diff --git a/.gitignore b/.gitignore index ca270b3..162fd6c 100644 --- a/.gitignore +++ b/.gitignore @@ -2,4 +2,4 @@ !.env.sample .idea/ -node_modules/ +node_modules/ \ No newline at end of file diff --git a/README.md b/README.md index 3eedac2..50b468c 100644 --- a/README.md +++ b/README.md @@ -15,7 +15,6 @@ All compiled files in `dist` are therefore committed. 1. Set environment variables: `cp .env.example .env` and edit the file 1. Install dependencies: `npm i` -1. Install compiler: `npm i -g @vercel/ncc` 1. Build: `npm run build` 1. Run locally: `npm run start` diff --git a/action.yml b/action.yml index 9f3aaae..203b0a2 100644 --- a/action.yml +++ b/action.yml @@ -10,10 +10,6 @@ inputs: description: 'Path to descriptions.json' required: true default: 'docs/description/description.json' - doc_patterns_path: - description: 'Path to patterns.json' - required: false - default: 'docs/patterns.json' runs: using: 'node20' main: 'dist/index.js' diff --git a/dist/11.index.js b/dist/11.index.js new file mode 100644 index 0000000..56ddf4f --- /dev/null +++ b/dist/11.index.js @@ -0,0 +1,16688 @@ +"use strict"; +exports.id = 11; +exports.ids = [11]; +exports.modules = { + +/***/ 16815: +/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { + + +// EXPORTS +__webpack_require__.d(__webpack_exports__, { + "i": () => (/* binding */ Serializable), + "j": () => (/* binding */ get_lc_unique_name) +}); + +// EXTERNAL MODULE: ./node_modules/decamelize/index.js +var decamelize = __webpack_require__(70159); +// EXTERNAL MODULE: ./node_modules/camelcase/index.js +var camelcase = __webpack_require__(21362); +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/load/map_keys.js + + +function keyToJson(key, map) { + return map?.[key] || decamelize(key); +} +function keyFromJson(key, map) { + return map?.[key] || camelCase(key); +} +function mapKeys(fields, mapper, map) { + const mapped = {}; + for (const key in fields) { + if (Object.hasOwn(fields, key)) { + mapped[mapper(key, map)] = fields[key]; + } + } + return mapped; +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/load/serializable.js + +function shallowCopy(obj) { + return Array.isArray(obj) ? [...obj] : { ...obj }; +} +function replaceSecrets(root, secretsMap) { + const result = shallowCopy(root); + for (const [path, secretId] of Object.entries(secretsMap)) { + const [last, ...partsReverse] = path.split(".").reverse(); + // eslint-disable-next-line @typescript-eslint/no-explicit-any + let current = result; + for (const part of partsReverse.reverse()) { + if (current[part] === undefined) { + break; + } + current[part] = shallowCopy(current[part]); + current = current[part]; + } + if (current[last] !== undefined) { + current[last] = { + lc: 1, + type: "secret", + id: [secretId], + }; + } + } + return result; +} +/** + * Get a unique name for the module, rather than parent class implementations. + * Should not be subclassed, subclass lc_name above instead. + */ +function get_lc_unique_name( +// eslint-disable-next-line @typescript-eslint/no-use-before-define +serializableClass) { + // "super" here would refer to the parent class of Serializable, + // when we want the parent class of the module actually calling this method. + const parentClass = Object.getPrototypeOf(serializableClass); + const lcNameIsSubclassed = typeof serializableClass.lc_name === "function" && + (typeof parentClass.lc_name !== "function" || + serializableClass.lc_name() !== parentClass.lc_name()); + if (lcNameIsSubclassed) { + return serializableClass.lc_name(); + } + else { + return serializableClass.name; + } +} +class Serializable { + /** + * The name of the serializable. Override to provide an alias or + * to preserve the serialized module name in minified environments. + * + * Implemented as a static method to support loading logic. + */ + static lc_name() { + return this.name; + } + /** + * The final serialized identifier for the module. + */ + get lc_id() { + return [ + ...this.lc_namespace, + get_lc_unique_name(this.constructor), + ]; + } + /** + * A map of secrets, which will be omitted from serialization. + * Keys are paths to the secret in constructor args, e.g. "foo.bar.baz". + * Values are the secret ids, which will be used when deserializing. + */ + get lc_secrets() { + return undefined; + } + /** + * A map of additional attributes to merge with constructor args. + * Keys are the attribute names, e.g. "foo". + * Values are the attribute values, which will be serialized. + * These attributes need to be accepted by the constructor as arguments. + */ + get lc_attributes() { + return undefined; + } + /** + * A map of aliases for constructor args. + * Keys are the attribute names, e.g. "foo". + * Values are the alias that will replace the key in serialization. + * This is used to eg. make argument names match Python. + */ + get lc_aliases() { + return undefined; + } + constructor(kwargs, ..._args) { + Object.defineProperty(this, "lc_serializable", { + enumerable: true, + configurable: true, + writable: true, + value: false + }); + Object.defineProperty(this, "lc_kwargs", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.lc_kwargs = kwargs || {}; + } + toJSON() { + if (!this.lc_serializable) { + return this.toJSONNotImplemented(); + } + if ( + // eslint-disable-next-line no-instanceof/no-instanceof + this.lc_kwargs instanceof Serializable || + typeof this.lc_kwargs !== "object" || + Array.isArray(this.lc_kwargs)) { + // We do not support serialization of classes with arg not a POJO + // I'm aware the check above isn't as strict as it could be + return this.toJSONNotImplemented(); + } + const aliases = {}; + const secrets = {}; + const kwargs = Object.keys(this.lc_kwargs).reduce((acc, key) => { + acc[key] = key in this ? this[key] : this.lc_kwargs[key]; + return acc; + }, {}); + // get secrets, attributes and aliases from all superclasses + for ( + // eslint-disable-next-line @typescript-eslint/no-this-alias + let current = Object.getPrototypeOf(this); current; current = Object.getPrototypeOf(current)) { + Object.assign(aliases, Reflect.get(current, "lc_aliases", this)); + Object.assign(secrets, Reflect.get(current, "lc_secrets", this)); + Object.assign(kwargs, Reflect.get(current, "lc_attributes", this)); + } + // include all secrets used, even if not in kwargs, + // will be replaced with sentinel value in replaceSecrets + Object.keys(secrets).forEach((keyPath) => { + // eslint-disable-next-line @typescript-eslint/no-this-alias, @typescript-eslint/no-explicit-any + let read = this; + // eslint-disable-next-line @typescript-eslint/no-explicit-any + let write = kwargs; + const [last, ...partsReverse] = keyPath.split(".").reverse(); + for (const key of partsReverse.reverse()) { + if (!(key in read) || read[key] === undefined) + return; + if (!(key in write) || write[key] === undefined) { + if (typeof read[key] === "object" && read[key] != null) { + write[key] = {}; + } + else if (Array.isArray(read[key])) { + write[key] = []; + } + } + read = read[key]; + write = write[key]; + } + if (last in read && read[last] !== undefined) { + write[last] = write[last] || read[last]; + } + }); + return { + lc: 1, + type: "constructor", + id: this.lc_id, + kwargs: mapKeys(Object.keys(secrets).length ? replaceSecrets(kwargs, secrets) : kwargs, keyToJson, aliases), + }; + } + toJSONNotImplemented() { + return { + lc: 1, + type: "not_implemented", + id: this.lc_id, + }; + } +} + + +/***/ }), + +/***/ 76801: +/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { + + +// EXPORTS +__webpack_require__.d(__webpack_exports__, { + "GC": () => (/* reexport */ ai_AIMessageChunk), + "xk": () => (/* reexport */ human_HumanMessage), + "zs": () => (/* reexport */ getBufferString) +}); + +// UNUSED EXPORTS: AIMessage, BaseMessage, BaseMessageChunk, ChatMessage, ChatMessageChunk, FunctionMessage, FunctionMessageChunk, HumanMessageChunk, SystemMessage, SystemMessageChunk, ToolMessage, ToolMessageChunk, _mergeDicts, _mergeLists, coerceMessageLikeToMessage, convertToChunk, isAIMessage, isBaseMessage, isBaseMessageChunk, isOpenAIToolCallArray, mapChatMessagesToStoredMessages, mapStoredMessageToChatMessage, mapStoredMessagesToChatMessages, mergeContent + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/utils/json.js +function parseJsonMarkdown(s, parser = parsePartialJson) { + // eslint-disable-next-line no-param-reassign + s = s.trim(); + const match = /```(json)?(.*)```/s.exec(s); + if (!match) { + return parser(s); + } + else { + return parser(match[2]); + } +} +// Adapted from https://github.com/KillianLucas/open-interpreter/blob/main/interpreter/core/llm/utils/parse_partial_json.py +// MIT License +function parsePartialJson(s) { + // If the input is undefined, return null to indicate failure. + if (typeof s === "undefined") { + return null; + } + // Attempt to parse the string as-is. + try { + return JSON.parse(s); + } + catch (error) { + // Pass + } + // Initialize variables. + let new_s = ""; + const stack = []; + let isInsideString = false; + let escaped = false; + // Process each character in the string one at a time. + for (let char of s) { + if (isInsideString) { + if (char === '"' && !escaped) { + isInsideString = false; + } + else if (char === "\n" && !escaped) { + char = "\\n"; // Replace the newline character with the escape sequence. + } + else if (char === "\\") { + escaped = !escaped; + } + else { + escaped = false; + } + } + else { + if (char === '"') { + isInsideString = true; + escaped = false; + } + else if (char === "{") { + stack.push("}"); + } + else if (char === "[") { + stack.push("]"); + } + else if (char === "}" || char === "]") { + if (stack && stack[stack.length - 1] === char) { + stack.pop(); + } + else { + // Mismatched closing character; the input is malformed. + return null; + } + } + } + // Append the processed character to the new string. + new_s += char; + } + // If we're still inside a string at the end of processing, + // we need to close the string. + if (isInsideString) { + new_s += '"'; + } + // Close any remaining open structures in the reverse order that they were opened. + for (let i = stack.length - 1; i >= 0; i -= 1) { + new_s += stack[i]; + } + // Attempt to parse the modified string as JSON. + try { + return JSON.parse(new_s); + } + catch (error) { + // If we still can't parse the string as JSON, return null to indicate failure. + return null; + } +} + +// EXTERNAL MODULE: ./node_modules/@langchain/core/dist/load/serializable.js + 1 modules +var serializable = __webpack_require__(16815); +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/messages/base.js + +function base_mergeContent(firstContent, secondContent) { + // If first content is a string + if (typeof firstContent === "string") { + if (typeof secondContent === "string") { + return firstContent + secondContent; + } + else { + return [{ type: "text", text: firstContent }, ...secondContent]; + } + // If both are arrays + } + else if (Array.isArray(secondContent)) { + return [...firstContent, ...secondContent]; + // If the first content is a list and second is a string + } + else { + // Otherwise, add the second content as a new element of the list + return [...firstContent, { type: "text", text: secondContent }]; + } +} +/** + * Base class for all types of messages in a conversation. It includes + * properties like `content`, `name`, and `additional_kwargs`. It also + * includes methods like `toDict()` and `_getType()`. + */ +class base_BaseMessage extends serializable/* Serializable */.i { + get lc_aliases() { + // exclude snake case conversion to pascal case + return { + additional_kwargs: "additional_kwargs", + response_metadata: "response_metadata", + }; + } + /** + * @deprecated + * Use {@link BaseMessage.content} instead. + */ + get text() { + return typeof this.content === "string" ? this.content : ""; + } + constructor(fields, + /** @deprecated */ + kwargs) { + if (typeof fields === "string") { + // eslint-disable-next-line no-param-reassign + fields = { + content: fields, + additional_kwargs: kwargs, + response_metadata: {}, + }; + } + // Make sure the default value for additional_kwargs is passed into super() for serialization + if (!fields.additional_kwargs) { + // eslint-disable-next-line no-param-reassign + fields.additional_kwargs = {}; + } + if (!fields.response_metadata) { + // eslint-disable-next-line no-param-reassign + fields.response_metadata = {}; + } + super(fields); + Object.defineProperty(this, "lc_namespace", { + enumerable: true, + configurable: true, + writable: true, + value: ["langchain_core", "messages"] + }); + Object.defineProperty(this, "lc_serializable", { + enumerable: true, + configurable: true, + writable: true, + value: true + }); + /** The content of the message. */ + Object.defineProperty(this, "content", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + /** The name of the message sender in a multi-user chat. */ + Object.defineProperty(this, "name", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + /** Additional keyword arguments */ + Object.defineProperty(this, "additional_kwargs", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + /** Response metadata. For example: response headers, logprobs, token counts. */ + Object.defineProperty(this, "response_metadata", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.name = fields.name; + this.content = fields.content; + this.additional_kwargs = fields.additional_kwargs; + this.response_metadata = fields.response_metadata; + } + toDict() { + return { + type: this._getType(), + data: this.toJSON() + .kwargs, + }; + } +} +function isOpenAIToolCallArray(value) { + return (Array.isArray(value) && + value.every((v) => typeof v.index === "number")); +} +function base_mergeDicts( +// eslint-disable-next-line @typescript-eslint/no-explicit-any +left, +// eslint-disable-next-line @typescript-eslint/no-explicit-any +right +// eslint-disable-next-line @typescript-eslint/no-explicit-any +) { + const merged = { ...left }; + for (const [key, value] of Object.entries(right)) { + if (merged[key] == null) { + merged[key] = value; + } + else if (value == null) { + continue; + } + else if (typeof merged[key] !== typeof value || + Array.isArray(merged[key]) !== Array.isArray(value)) { + throw new Error(`field[${key}] already exists in the message chunk, but with a different type.`); + } + else if (typeof merged[key] === "string") { + merged[key] = merged[key] + value; + } + else if (!Array.isArray(merged[key]) && typeof merged[key] === "object") { + merged[key] = base_mergeDicts(merged[key], value); + } + else if (Array.isArray(merged[key])) { + merged[key] = _mergeLists(merged[key], value); + } + else if (merged[key] === value) { + continue; + } + else { + console.warn(`field[${key}] already exists in this message chunk and value has unsupported type.`); + } + } + return merged; +} +// eslint-disable-next-line @typescript-eslint/no-explicit-any +function _mergeLists(left, right) { + if (left === undefined && right === undefined) { + return undefined; + } + else if (left === undefined || right === undefined) { + return left || right; + } + else { + const merged = [...left]; + for (const item of right) { + if (typeof item === "object" && + "index" in item && + typeof item.index === "number") { + const toMerge = merged.findIndex((leftItem) => leftItem.index === item.index); + if (toMerge !== -1) { + merged[toMerge] = base_mergeDicts(merged[toMerge], item); + } + else { + merged.push(item); + } + } + else { + merged.push(item); + } + } + return merged; + } +} +/** + * Represents a chunk of a message, which can be concatenated with other + * message chunks. It includes a method `_merge_kwargs_dict()` for merging + * additional keyword arguments from another `BaseMessageChunk` into this + * one. It also overrides the `__add__()` method to support concatenation + * of `BaseMessageChunk` instances. + */ +class base_BaseMessageChunk extends base_BaseMessage { +} +function base_isBaseMessage(messageLike) { + return typeof messageLike?._getType === "function"; +} +function isBaseMessageChunk(messageLike) { + return (base_isBaseMessage(messageLike) && + typeof messageLike.concat === "function"); +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/messages/tool.js + +/** + * Represents a tool message in a conversation. + */ +class tool_ToolMessage extends (/* unused pure expression or super */ null && (BaseMessage)) { + static lc_name() { + return "ToolMessage"; + } + get lc_aliases() { + // exclude snake case conversion to pascal case + return { tool_call_id: "tool_call_id" }; + } + constructor(fields, tool_call_id, name) { + if (typeof fields === "string") { + // eslint-disable-next-line no-param-reassign, @typescript-eslint/no-non-null-assertion + fields = { content: fields, name, tool_call_id: tool_call_id }; + } + super(fields); + Object.defineProperty(this, "tool_call_id", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.tool_call_id = fields.tool_call_id; + } + _getType() { + return "tool"; + } + static isInstance(message) { + return message._getType() === "tool"; + } +} +/** + * Represents a chunk of a tool message, which can be concatenated + * with other tool message chunks. + */ +class ToolMessageChunk extends (/* unused pure expression or super */ null && (BaseMessageChunk)) { + constructor(fields) { + super(fields); + Object.defineProperty(this, "tool_call_id", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.tool_call_id = fields.tool_call_id; + } + static lc_name() { + return "ToolMessageChunk"; + } + _getType() { + return "tool"; + } + concat(chunk) { + return new ToolMessageChunk({ + content: mergeContent(this.content, chunk.content), + additional_kwargs: _mergeDicts(this.additional_kwargs, chunk.additional_kwargs), + response_metadata: _mergeDicts(this.response_metadata, chunk.response_metadata), + tool_call_id: this.tool_call_id, + }); + } +} +function tool_defaultToolCallParser( +// eslint-disable-next-line @typescript-eslint/no-explicit-any +rawToolCalls) { + const toolCalls = []; + const invalidToolCalls = []; + for (const toolCall of rawToolCalls) { + if (!toolCall.function) { + continue; + } + else { + const functionName = toolCall.function.name; + try { + const functionArgs = JSON.parse(toolCall.function.arguments); + const parsed = { + name: functionName || "", + args: functionArgs || {}, + id: toolCall.id, + }; + toolCalls.push(parsed); + } + catch (error) { + invalidToolCalls.push({ + name: functionName, + args: toolCall.function.arguments, + id: toolCall.id, + error: "Malformed args.", + }); + } + } + } + return [toolCalls, invalidToolCalls]; +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/messages/ai.js + + + +/** + * Represents an AI message in a conversation. + */ +class ai_AIMessage extends (/* unused pure expression or super */ null && (BaseMessage)) { + get lc_aliases() { + // exclude snake case conversion to pascal case + return { + ...super.lc_aliases, + tool_calls: "tool_calls", + invalid_tool_calls: "invalid_tool_calls", + }; + } + constructor(fields, + /** @deprecated */ + kwargs) { + let initParams; + if (typeof fields === "string") { + initParams = { + content: fields, + tool_calls: [], + invalid_tool_calls: [], + additional_kwargs: kwargs ?? {}, + }; + } + else { + initParams = fields; + const rawToolCalls = initParams.additional_kwargs?.tool_calls; + const toolCalls = initParams.tool_calls; + if (!(rawToolCalls == null) && + rawToolCalls.length > 0 && + (toolCalls === undefined || toolCalls.length === 0)) { + console.warn([ + "New LangChain packages are available that more efficiently handle", + "tool calling.\n\nPlease upgrade your packages to versions that set", + "message tool calls. e.g., `yarn add @langchain/anthropic`,", + "yarn add @langchain/openai`, etc.", + ].join(" ")); + } + try { + if (!(rawToolCalls == null) && toolCalls === undefined) { + const [toolCalls, invalidToolCalls] = defaultToolCallParser(rawToolCalls); + initParams.tool_calls = toolCalls ?? []; + initParams.invalid_tool_calls = invalidToolCalls ?? []; + } + else { + initParams.tool_calls = initParams.tool_calls ?? []; + initParams.invalid_tool_calls = initParams.invalid_tool_calls ?? []; + } + } + catch (e) { + // Do nothing if parsing fails + initParams.tool_calls = []; + initParams.invalid_tool_calls = []; + } + } + // Sadly, TypeScript only allows super() calls at root if the class has + // properties with initializers, so we have to check types twice. + super(initParams); + // These are typed as optional to avoid breaking changes and allow for casting + // from BaseMessage. + Object.defineProperty(this, "tool_calls", { + enumerable: true, + configurable: true, + writable: true, + value: [] + }); + Object.defineProperty(this, "invalid_tool_calls", { + enumerable: true, + configurable: true, + writable: true, + value: [] + }); + if (typeof initParams !== "string") { + this.tool_calls = initParams.tool_calls ?? this.tool_calls; + this.invalid_tool_calls = + initParams.invalid_tool_calls ?? this.invalid_tool_calls; + } + } + static lc_name() { + return "AIMessage"; + } + _getType() { + return "ai"; + } +} +function isAIMessage(x) { + return x._getType() === "ai"; +} +/** + * Represents a chunk of an AI message, which can be concatenated with + * other AI message chunks. + */ +class ai_AIMessageChunk extends base_BaseMessageChunk { + constructor(fields) { + let initParams; + if (typeof fields === "string") { + initParams = { + content: fields, + tool_calls: [], + invalid_tool_calls: [], + tool_call_chunks: [], + }; + } + else if (fields.tool_call_chunks === undefined) { + initParams = { + ...fields, + tool_calls: [], + invalid_tool_calls: [], + tool_call_chunks: [], + }; + } + else { + const toolCalls = []; + const invalidToolCalls = []; + for (const toolCallChunk of fields.tool_call_chunks) { + let parsedArgs = {}; + try { + parsedArgs = parsePartialJson(toolCallChunk.args ?? "{}") ?? {}; + if (typeof parsedArgs !== "object" || Array.isArray(parsedArgs)) { + throw new Error("Malformed tool call chunk args."); + } + toolCalls.push({ + name: toolCallChunk.name ?? "", + args: parsedArgs, + id: toolCallChunk.id, + }); + } + catch (e) { + invalidToolCalls.push({ + name: toolCallChunk.name, + args: toolCallChunk.args, + id: toolCallChunk.id, + error: "Malformed args.", + }); + } + } + initParams = { + ...fields, + tool_calls: toolCalls, + invalid_tool_calls: invalidToolCalls, + }; + } + // Sadly, TypeScript only allows super() calls at root if the class has + // properties with initializers, so we have to check types twice. + super(initParams); + // Must redeclare tool call fields since there is no multiple inheritance in JS. + // These are typed as optional to avoid breaking changes and allow for casting + // from BaseMessage. + Object.defineProperty(this, "tool_calls", { + enumerable: true, + configurable: true, + writable: true, + value: [] + }); + Object.defineProperty(this, "invalid_tool_calls", { + enumerable: true, + configurable: true, + writable: true, + value: [] + }); + Object.defineProperty(this, "tool_call_chunks", { + enumerable: true, + configurable: true, + writable: true, + value: [] + }); + this.tool_call_chunks = + initParams?.tool_call_chunks ?? this.tool_call_chunks; + this.tool_calls = initParams?.tool_calls ?? this.tool_calls; + this.invalid_tool_calls = + initParams?.invalid_tool_calls ?? this.invalid_tool_calls; + } + get lc_aliases() { + // exclude snake case conversion to pascal case + return { + ...super.lc_aliases, + tool_calls: "tool_calls", + invalid_tool_calls: "invalid_tool_calls", + tool_call_chunks: "tool_call_chunks", + }; + } + static lc_name() { + return "AIMessageChunk"; + } + _getType() { + return "ai"; + } + concat(chunk) { + const combinedFields = { + content: base_mergeContent(this.content, chunk.content), + additional_kwargs: base_mergeDicts(this.additional_kwargs, chunk.additional_kwargs), + response_metadata: base_mergeDicts(this.response_metadata, chunk.response_metadata), + tool_call_chunks: [], + }; + if (this.tool_call_chunks !== undefined || + chunk.tool_call_chunks !== undefined) { + const rawToolCalls = _mergeLists(this.tool_call_chunks, chunk.tool_call_chunks); + if (rawToolCalls !== undefined && rawToolCalls.length > 0) { + combinedFields.tool_call_chunks = rawToolCalls; + } + } + return new ai_AIMessageChunk(combinedFields); + } +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/messages/chat.js + +/** + * Represents a chat message in a conversation. + */ +class chat_ChatMessage extends (/* unused pure expression or super */ null && (BaseMessage)) { + static lc_name() { + return "ChatMessage"; + } + static _chatMessageClass() { + return chat_ChatMessage; + } + constructor(fields, role) { + if (typeof fields === "string") { + // eslint-disable-next-line no-param-reassign, @typescript-eslint/no-non-null-assertion + fields = { content: fields, role: role }; + } + super(fields); + Object.defineProperty(this, "role", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.role = fields.role; + } + _getType() { + return "generic"; + } + static isInstance(message) { + return message._getType() === "generic"; + } +} +/** + * Represents a chunk of a chat message, which can be concatenated with + * other chat message chunks. + */ +class chat_ChatMessageChunk extends (/* unused pure expression or super */ null && (BaseMessageChunk)) { + static lc_name() { + return "ChatMessageChunk"; + } + constructor(fields, role) { + if (typeof fields === "string") { + // eslint-disable-next-line no-param-reassign, @typescript-eslint/no-non-null-assertion + fields = { content: fields, role: role }; + } + super(fields); + Object.defineProperty(this, "role", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.role = fields.role; + } + _getType() { + return "generic"; + } + concat(chunk) { + return new chat_ChatMessageChunk({ + content: mergeContent(this.content, chunk.content), + additional_kwargs: _mergeDicts(this.additional_kwargs, chunk.additional_kwargs), + response_metadata: _mergeDicts(this.response_metadata, chunk.response_metadata), + role: this.role, + }); + } +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/messages/function.js + +/** + * Represents a function message in a conversation. + */ +class function_FunctionMessage extends (/* unused pure expression or super */ null && (BaseMessage)) { + static lc_name() { + return "FunctionMessage"; + } + constructor(fields, + /** @deprecated */ + name) { + if (typeof fields === "string") { + // eslint-disable-next-line no-param-reassign, @typescript-eslint/no-non-null-assertion + fields = { content: fields, name: name }; + } + super(fields); + } + _getType() { + return "function"; + } +} +/** + * Represents a chunk of a function message, which can be concatenated + * with other function message chunks. + */ +class function_FunctionMessageChunk extends (/* unused pure expression or super */ null && (BaseMessageChunk)) { + static lc_name() { + return "FunctionMessageChunk"; + } + _getType() { + return "function"; + } + concat(chunk) { + return new function_FunctionMessageChunk({ + content: mergeContent(this.content, chunk.content), + additional_kwargs: _mergeDicts(this.additional_kwargs, chunk.additional_kwargs), + response_metadata: _mergeDicts(this.response_metadata, chunk.response_metadata), + name: this.name ?? "", + }); + } +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/messages/human.js + +/** + * Represents a human message in a conversation. + */ +class human_HumanMessage extends base_BaseMessage { + static lc_name() { + return "HumanMessage"; + } + _getType() { + return "human"; + } +} +/** + * Represents a chunk of a human message, which can be concatenated with + * other human message chunks. + */ +class human_HumanMessageChunk extends (/* unused pure expression or super */ null && (BaseMessageChunk)) { + static lc_name() { + return "HumanMessageChunk"; + } + _getType() { + return "human"; + } + concat(chunk) { + return new human_HumanMessageChunk({ + content: mergeContent(this.content, chunk.content), + additional_kwargs: _mergeDicts(this.additional_kwargs, chunk.additional_kwargs), + response_metadata: _mergeDicts(this.response_metadata, chunk.response_metadata), + }); + } +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/messages/system.js + +/** + * Represents a system message in a conversation. + */ +class system_SystemMessage extends (/* unused pure expression or super */ null && (BaseMessage)) { + static lc_name() { + return "SystemMessage"; + } + _getType() { + return "system"; + } +} +/** + * Represents a chunk of a system message, which can be concatenated with + * other system message chunks. + */ +class system_SystemMessageChunk extends (/* unused pure expression or super */ null && (BaseMessageChunk)) { + static lc_name() { + return "SystemMessageChunk"; + } + _getType() { + return "system"; + } + concat(chunk) { + return new system_SystemMessageChunk({ + content: mergeContent(this.content, chunk.content), + additional_kwargs: _mergeDicts(this.additional_kwargs, chunk.additional_kwargs), + response_metadata: _mergeDicts(this.response_metadata, chunk.response_metadata), + }); + } +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/messages/utils.js + + + + + + + +function coerceMessageLikeToMessage(messageLike) { + if (typeof messageLike === "string") { + return new HumanMessage(messageLike); + } + else if (isBaseMessage(messageLike)) { + return messageLike; + } + const [type, content] = messageLike; + if (type === "human" || type === "user") { + return new HumanMessage({ content }); + } + else if (type === "ai" || type === "assistant") { + return new AIMessage({ content }); + } + else if (type === "system") { + return new SystemMessage({ content }); + } + else { + throw new Error(`Unable to coerce message from array: only human, AI, or system message coercion is currently supported.`); + } +} +/** + * This function is used by memory classes to get a string representation + * of the chat message history, based on the message content and role. + */ +function getBufferString(messages, humanPrefix = "Human", aiPrefix = "AI") { + const string_messages = []; + for (const m of messages) { + let role; + if (m._getType() === "human") { + role = humanPrefix; + } + else if (m._getType() === "ai") { + role = aiPrefix; + } + else if (m._getType() === "system") { + role = "System"; + } + else if (m._getType() === "function") { + role = "Function"; + } + else if (m._getType() === "tool") { + role = "Tool"; + } + else if (m._getType() === "generic") { + role = m.role; + } + else { + throw new Error(`Got unsupported message type: ${m._getType()}`); + } + const nameStr = m.name ? `${m.name}, ` : ""; + string_messages.push(`${role}: ${nameStr}${m.content}`); + } + return string_messages.join("\n"); +} +/** + * Maps messages from an older format (V1) to the current `StoredMessage` + * format. If the message is already in the `StoredMessage` format, it is + * returned as is. Otherwise, it transforms the V1 message into a + * `StoredMessage`. This function is important for maintaining + * compatibility with older message formats. + */ +function mapV1MessageToStoredMessage(message) { + // TODO: Remove this mapper when we deprecate the old message format. + if (message.data !== undefined) { + return message; + } + else { + const v1Message = message; + return { + type: v1Message.type, + data: { + content: v1Message.text, + role: v1Message.role, + name: undefined, + tool_call_id: undefined, + }, + }; + } +} +function mapStoredMessageToChatMessage(message) { + const storedMessage = mapV1MessageToStoredMessage(message); + switch (storedMessage.type) { + case "human": + return new HumanMessage(storedMessage.data); + case "ai": + return new AIMessage(storedMessage.data); + case "system": + return new SystemMessage(storedMessage.data); + case "function": + if (storedMessage.data.name === undefined) { + throw new Error("Name must be defined for function messages"); + } + return new FunctionMessage(storedMessage.data); + case "tool": + if (storedMessage.data.tool_call_id === undefined) { + throw new Error("Tool call ID must be defined for tool messages"); + } + return new ToolMessage(storedMessage.data); + case "chat": { + if (storedMessage.data.role === undefined) { + throw new Error("Role must be defined for chat messages"); + } + return new ChatMessage(storedMessage.data); + } + default: + throw new Error(`Got unexpected type: ${storedMessage.type}`); + } +} +/** + * Transforms an array of `StoredMessage` instances into an array of + * `BaseMessage` instances. It uses the `mapV1MessageToStoredMessage` + * function to ensure all messages are in the `StoredMessage` format, then + * creates new instances of the appropriate `BaseMessage` subclass based + * on the type of each message. This function is used to prepare stored + * messages for use in a chat context. + */ +function mapStoredMessagesToChatMessages(messages) { + return messages.map(mapStoredMessageToChatMessage); +} +/** + * Transforms an array of `BaseMessage` instances into an array of + * `StoredMessage` instances. It does this by calling the `toDict` method + * on each `BaseMessage`, which returns a `StoredMessage`. This function + * is used to prepare chat messages for storage. + */ +function mapChatMessagesToStoredMessages(messages) { + return messages.map((message) => message.toDict()); +} +function convertToChunk(message) { + const type = message._getType(); + if (type === "human") { + // eslint-disable-next-line @typescript-eslint/no-use-before-define + return new HumanMessageChunk({ ...message }); + } + else if (type === "ai") { + // eslint-disable-next-line @typescript-eslint/no-use-before-define + return new AIMessageChunk({ ...message }); + } + else if (type === "system") { + // eslint-disable-next-line @typescript-eslint/no-use-before-define + return new SystemMessageChunk({ ...message }); + } + else if (type === "function") { + // eslint-disable-next-line @typescript-eslint/no-use-before-define + return new FunctionMessageChunk({ ...message }); + // eslint-disable-next-line @typescript-eslint/no-use-before-define + } + else if (ChatMessage.isInstance(message)) { + // eslint-disable-next-line @typescript-eslint/no-use-before-define + return new ChatMessageChunk({ ...message }); + } + else { + throw new Error("Unknown message type."); + } +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/messages/index.js + + + + + + + +// TODO: Use a star export when we deprecate the +// existing "ToolCall" type in "base.js". + + + +/***/ }), + +/***/ 437: +/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { + +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "GU": () => (/* binding */ ChatPromptValue), +/* harmony export */ "nw": () => (/* binding */ StringPromptValue) +/* harmony export */ }); +/* unused harmony exports BasePromptValue, ImagePromptValue */ +/* harmony import */ var _load_serializable_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(16815); +/* harmony import */ var _messages_index_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(76801); + + +/** + * Base PromptValue class. All prompt values should extend this class. + */ +class BasePromptValue extends _load_serializable_js__WEBPACK_IMPORTED_MODULE_0__/* .Serializable */ .i { +} +/** + * Represents a prompt value as a string. It extends the BasePromptValue + * class and overrides the toString and toChatMessages methods. + */ +class StringPromptValue extends BasePromptValue { + static lc_name() { + return "StringPromptValue"; + } + constructor(value) { + super({ value }); + Object.defineProperty(this, "lc_namespace", { + enumerable: true, + configurable: true, + writable: true, + value: ["langchain_core", "prompt_values"] + }); + Object.defineProperty(this, "lc_serializable", { + enumerable: true, + configurable: true, + writable: true, + value: true + }); + Object.defineProperty(this, "value", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.value = value; + } + toString() { + return this.value; + } + toChatMessages() { + return [new _messages_index_js__WEBPACK_IMPORTED_MODULE_1__/* .HumanMessage */ .xk(this.value)]; + } +} +/** + * Class that represents a chat prompt value. It extends the + * BasePromptValue and includes an array of BaseMessage instances. + */ +class ChatPromptValue extends BasePromptValue { + static lc_name() { + return "ChatPromptValue"; + } + constructor(fields) { + if (Array.isArray(fields)) { + // eslint-disable-next-line no-param-reassign + fields = { messages: fields }; + } + super(fields); + Object.defineProperty(this, "lc_namespace", { + enumerable: true, + configurable: true, + writable: true, + value: ["langchain_core", "prompt_values"] + }); + Object.defineProperty(this, "lc_serializable", { + enumerable: true, + configurable: true, + writable: true, + value: true + }); + Object.defineProperty(this, "messages", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.messages = fields.messages; + } + toString() { + return (0,_messages_index_js__WEBPACK_IMPORTED_MODULE_1__/* .getBufferString */ .zs)(this.messages); + } + toChatMessages() { + return this.messages; + } +} +/** + * Class that represents an image prompt value. It extends the + * BasePromptValue and includes an ImageURL instance. + */ +class ImagePromptValue extends (/* unused pure expression or super */ null && (BasePromptValue)) { + static lc_name() { + return "ImagePromptValue"; + } + constructor(fields) { + if (!("imageUrl" in fields)) { + // eslint-disable-next-line no-param-reassign + fields = { imageUrl: fields }; + } + super(fields); + Object.defineProperty(this, "lc_namespace", { + enumerable: true, + configurable: true, + writable: true, + value: ["langchain_core", "prompt_values"] + }); + Object.defineProperty(this, "lc_serializable", { + enumerable: true, + configurable: true, + writable: true, + value: true + }); + Object.defineProperty(this, "imageUrl", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + /** @ignore */ + Object.defineProperty(this, "value", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.imageUrl = fields.imageUrl; + } + toString() { + return this.imageUrl.url; + } + toChatMessages() { + return [ + new HumanMessage({ + content: [ + { + type: "image_url", + image_url: { + detail: this.imageUrl.detail, + url: this.imageUrl.url, + }, + }, + ], + }), + ]; + } +} + + +/***/ }), + +/***/ 74200: +/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { + +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "d": () => (/* binding */ BasePromptTemplate) +/* harmony export */ }); +/* harmony import */ var _runnables_base_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(75139); +// Default generic "any" values are for backwards compatibility. +// Replace with "string" when we are comfortable with a breaking change. + +/** + * Base class for prompt templates. Exposes a format method that returns a + * string prompt given a set of input values. + */ +class BasePromptTemplate extends _runnables_base_js__WEBPACK_IMPORTED_MODULE_0__/* .Runnable */ .eq { + get lc_attributes() { + return { + partialVariables: undefined, // python doesn't support this yet + }; + } + constructor(input) { + super(input); + Object.defineProperty(this, "lc_serializable", { + enumerable: true, + configurable: true, + writable: true, + value: true + }); + Object.defineProperty(this, "lc_namespace", { + enumerable: true, + configurable: true, + writable: true, + value: ["langchain_core", "prompts", this._getPromptType()] + }); + Object.defineProperty(this, "inputVariables", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "outputParser", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "partialVariables", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + const { inputVariables } = input; + if (inputVariables.includes("stop")) { + throw new Error("Cannot have an input variable named 'stop', as it is used internally, please rename."); + } + Object.assign(this, input); + } + /** + * Merges partial variables and user variables. + * @param userVariables The user variables to merge with the partial variables. + * @returns A Promise that resolves to an object containing the merged variables. + */ + async mergePartialAndUserVariables(userVariables) { + const partialVariables = this.partialVariables ?? {}; + const partialValues = {}; + for (const [key, value] of Object.entries(partialVariables)) { + if (typeof value === "string") { + partialValues[key] = value; + } + else { + partialValues[key] = await value(); + } + } + const allKwargs = { + ...partialValues, + ...userVariables, + }; + return allKwargs; + } + /** + * Invokes the prompt template with the given input and options. + * @param input The input to invoke the prompt template with. + * @param options Optional configuration for the callback. + * @returns A Promise that resolves to the output of the prompt template. + */ + async invoke(input, options) { + return this._callWithConfig((input) => this.formatPromptValue(input), input, { ...options, runType: "prompt" }); + } + /** + * Return a json-like object representing this prompt template. + * @deprecated + */ + serialize() { + throw new Error("Use .toJSON() instead"); + } + /** + * @deprecated + * Load a prompt template from a json-like object describing it. + * + * @remarks + * Deserializing needs to be async because templates (e.g. {@link FewShotPromptTemplate}) can + * reference remote resources that we read asynchronously with a web + * request. + */ + static async deserialize(data) { + switch (data._type) { + case "prompt": { + const { PromptTemplate } = await Promise.resolve(/* import() */).then(__webpack_require__.bind(__webpack_require__, 99049)); + return PromptTemplate.deserialize(data); + } + case undefined: { + const { PromptTemplate } = await Promise.resolve(/* import() */).then(__webpack_require__.bind(__webpack_require__, 99049)); + return PromptTemplate.deserialize({ ...data, _type: "prompt" }); + } + case "few_shot": { + const { FewShotPromptTemplate } = await __webpack_require__.e(/* import() */ 50).then(__webpack_require__.bind(__webpack_require__, 58050)); + return FewShotPromptTemplate.deserialize(data); + } + default: + throw new Error(`Invalid prompt type in config: ${data._type}`); + } + } +} + + +/***/ }), + +/***/ 99049: +/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "PromptTemplate": () => (/* binding */ PromptTemplate) +/* harmony export */ }); +/* harmony import */ var _string_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(48166); +/* harmony import */ var _template_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(57645); +// Default generic "any" values are for backwards compatibility. +// Replace with "string" when we are comfortable with a breaking change. + + +/** + * Schema to represent a basic prompt for an LLM. + * @augments BasePromptTemplate + * @augments PromptTemplateInput + * + * @example + * ```ts + * import { PromptTemplate } from "langchain/prompts"; + * + * const prompt = new PromptTemplate({ + * inputVariables: ["foo"], + * template: "Say {foo}", + * }); + * ``` + */ +class PromptTemplate extends _string_js__WEBPACK_IMPORTED_MODULE_0__/* .BaseStringPromptTemplate */ .A { + static lc_name() { + return "PromptTemplate"; + } + constructor(input) { + super(input); + 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 + }); + // If input is mustache and validateTemplate is not defined, set it to false + if (input.templateFormat === "mustache" && + input.validateTemplate === undefined) { + this.validateTemplate = false; + } + Object.assign(this, input); + if (this.validateTemplate) { + if (this.templateFormat === "mustache") { + throw new Error("Mustache templates cannot be validated."); + } + let totalInputVariables = this.inputVariables; + if (this.partialVariables) { + totalInputVariables = totalInputVariables.concat(Object.keys(this.partialVariables)); + } + (0,_template_js__WEBPACK_IMPORTED_MODULE_1__/* .checkValidTemplate */ .af)(this.template, this.templateFormat, totalInputVariables); + } + } + _getPromptType() { + return "prompt"; + } + /** + * 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 allValues = await this.mergePartialAndUserVariables(values); + return (0,_template_js__WEBPACK_IMPORTED_MODULE_1__/* .renderTemplate */ .SM)(this.template, this.templateFormat, allValues); + } + /** + * Take examples in list format with prefix and suffix to create a prompt. + * + * Intended to be used a a way to dynamically create a prompt from examples. + * + * @param examples - List of examples to use in the prompt. + * @param suffix - String to go after the list of examples. Should generally set up the user's input. + * @param inputVariables - A list of variable names the final prompt template will expect + * @param exampleSeparator - The separator to use in between examples + * @param prefix - String that should go before any examples. Generally includes examples. + * + * @returns The final prompt template generated. + */ + static fromExamples(examples, suffix, inputVariables, exampleSeparator = "\n\n", prefix = "") { + const template = [prefix, ...examples, suffix].join(exampleSeparator); + return new PromptTemplate({ + inputVariables, + template, + }); + } + static fromTemplate(template, options) { + const { templateFormat = "f-string", ...rest } = options ?? {}; + const names = new Set(); + (0,_template_js__WEBPACK_IMPORTED_MODULE_1__/* .parseTemplate */ .$M)(template, templateFormat).forEach((node) => { + if (node.type === "variable") { + names.add(node.name); + } + }); + return new PromptTemplate({ + // Rely on extracted types + // eslint-disable-next-line @typescript-eslint/no-explicit-any + inputVariables: [...names], + templateFormat, + template, + ...rest, + }); + } + /** + * Partially applies values to the prompt template. + * @param values The values to be partially applied to the prompt template. + * @returns A new instance of PromptTemplate 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 PromptTemplate(promptDict); + } + serialize() { + if (this.outputParser !== undefined) { + throw new Error("Cannot serialize a prompt template with an output parser"); + } + return { + _type: this._getPromptType(), + input_variables: this.inputVariables, + template: this.template, + template_format: this.templateFormat, + }; + } + static async deserialize(data) { + if (!data.template) { + throw new Error("Prompt template must have a template"); + } + const res = new PromptTemplate({ + inputVariables: data.input_variables, + template: data.template, + templateFormat: data.template_format, + }); + return res; + } +} + + +/***/ }), + +/***/ 48166: +/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { + +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "A": () => (/* binding */ BaseStringPromptTemplate) +/* harmony export */ }); +/* harmony import */ var _prompt_values_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(437); +/* harmony import */ var _base_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(74200); +// Default generic "any" values are for backwards compatibility. +// Replace with "string" when we are comfortable with a breaking change. + + +/** + * Base class for string prompt templates. It extends the + * BasePromptTemplate class and overrides the formatPromptValue method to + * return a StringPromptValue. + */ +class BaseStringPromptTemplate extends _base_js__WEBPACK_IMPORTED_MODULE_1__/* .BasePromptTemplate */ .d { + /** + * 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 _prompt_values_js__WEBPACK_IMPORTED_MODULE_0__/* .StringPromptValue */ .nw(formattedPrompt); + } +} + + +/***/ }), + +/***/ 57645: +/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { + + +// EXPORTS +__webpack_require__.d(__webpack_exports__, { + "af": () => (/* binding */ checkValidTemplate), + "$M": () => (/* binding */ template_parseTemplate), + "SM": () => (/* binding */ renderTemplate) +}); + +// UNUSED EXPORTS: DEFAULT_FORMATTER_MAPPING, DEFAULT_PARSER_MAPPING, interpolateFString, interpolateMustache, parseFString, parseMustache + +;// CONCATENATED MODULE: ./node_modules/mustache/mustache.mjs +/*! + * mustache.js - Logic-less {{mustache}} templates with JavaScript + * http://github.com/janl/mustache.js + */ + +var objectToString = Object.prototype.toString; +var isArray = Array.isArray || function isArrayPolyfill (object) { + return objectToString.call(object) === '[object Array]'; +}; + +function isFunction (object) { + return typeof object === 'function'; +} + +/** + * More correct typeof string handling array + * which normally returns typeof 'object' + */ +function typeStr (obj) { + return isArray(obj) ? 'array' : typeof obj; +} + +function escapeRegExp (string) { + return string.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, '\\$&'); +} + +/** + * Null safe way of checking whether or not an object, + * including its prototype, has a given property + */ +function hasProperty (obj, propName) { + return obj != null && typeof obj === 'object' && (propName in obj); +} + +/** + * Safe way of detecting whether or not the given thing is a primitive and + * whether it has the given property + */ +function primitiveHasOwnProperty (primitive, propName) { + return ( + primitive != null + && typeof primitive !== 'object' + && primitive.hasOwnProperty + && primitive.hasOwnProperty(propName) + ); +} + +// Workaround for https://issues.apache.org/jira/browse/COUCHDB-577 +// See https://github.com/janl/mustache.js/issues/189 +var regExpTest = RegExp.prototype.test; +function testRegExp (re, string) { + return regExpTest.call(re, string); +} + +var nonSpaceRe = /\S/; +function isWhitespace (string) { + return !testRegExp(nonSpaceRe, string); +} + +var entityMap = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + "'": ''', + '/': '/', + '`': '`', + '=': '=' +}; + +function escapeHtml (string) { + return String(string).replace(/[&<>"'`=\/]/g, function fromEntityMap (s) { + return entityMap[s]; + }); +} + +var whiteRe = /\s*/; +var spaceRe = /\s+/; +var equalsRe = /\s*=/; +var curlyRe = /\s*\}/; +var tagRe = /#|\^|\/|>|\{|&|=|!/; + +/** + * Breaks up the given `template` string into a tree of tokens. If the `tags` + * argument is given here it must be an array with two string values: the + * opening and closing tags used in the template (e.g. [ "<%", "%>" ]). Of + * course, the default is to use mustaches (i.e. mustache.tags). + * + * A token is an array with at least 4 elements. The first element is the + * mustache symbol that was used inside the tag, e.g. "#" or "&". If the tag + * did not contain a symbol (i.e. {{myValue}}) this element is "name". For + * all text that appears outside a symbol this element is "text". + * + * The second element of a token is its "value". For mustache tags this is + * whatever else was inside the tag besides the opening symbol. For text tokens + * this is the text itself. + * + * The third and fourth elements of the token are the start and end indices, + * respectively, of the token in the original template. + * + * Tokens that are the root node of a subtree contain two more elements: 1) an + * array of tokens in the subtree and 2) the index in the original template at + * which the closing tag for that section begins. + * + * Tokens for partials also contain two more elements: 1) a string value of + * indendation prior to that tag and 2) the index of that tag on that line - + * eg a value of 2 indicates the partial is the third tag on this line. + */ +function parseTemplate (template, tags) { + if (!template) + return []; + var lineHasNonSpace = false; + var sections = []; // Stack to hold section tokens + var tokens = []; // Buffer to hold the tokens + var spaces = []; // Indices of whitespace tokens on the current line + var hasTag = false; // Is there a {{tag}} on the current line? + var nonSpace = false; // Is there a non-space char on the current line? + var indentation = ''; // Tracks indentation for tags that use it + var tagIndex = 0; // Stores a count of number of tags encountered on a line + + // Strips all whitespace tokens array for the current line + // if there was a {{#tag}} on it and otherwise only space. + function stripSpace () { + if (hasTag && !nonSpace) { + while (spaces.length) + delete tokens[spaces.pop()]; + } else { + spaces = []; + } + + hasTag = false; + nonSpace = false; + } + + var openingTagRe, closingTagRe, closingCurlyRe; + function compileTags (tagsToCompile) { + if (typeof tagsToCompile === 'string') + tagsToCompile = tagsToCompile.split(spaceRe, 2); + + if (!isArray(tagsToCompile) || tagsToCompile.length !== 2) + throw new Error('Invalid tags: ' + tagsToCompile); + + openingTagRe = new RegExp(escapeRegExp(tagsToCompile[0]) + '\\s*'); + closingTagRe = new RegExp('\\s*' + escapeRegExp(tagsToCompile[1])); + closingCurlyRe = new RegExp('\\s*' + escapeRegExp('}' + tagsToCompile[1])); + } + + compileTags(tags || mustache.tags); + + var scanner = new Scanner(template); + + var start, type, value, chr, token, openSection; + while (!scanner.eos()) { + start = scanner.pos; + + // Match any text between tags. + value = scanner.scanUntil(openingTagRe); + + if (value) { + for (var i = 0, valueLength = value.length; i < valueLength; ++i) { + chr = value.charAt(i); + + if (isWhitespace(chr)) { + spaces.push(tokens.length); + indentation += chr; + } else { + nonSpace = true; + lineHasNonSpace = true; + indentation += ' '; + } + + tokens.push([ 'text', chr, start, start + 1 ]); + start += 1; + + // Check for whitespace on the current line. + if (chr === '\n') { + stripSpace(); + indentation = ''; + tagIndex = 0; + lineHasNonSpace = false; + } + } + } + + // Match the opening tag. + if (!scanner.scan(openingTagRe)) + break; + + hasTag = true; + + // Get the tag type. + type = scanner.scan(tagRe) || 'name'; + scanner.scan(whiteRe); + + // Get the tag value. + if (type === '=') { + value = scanner.scanUntil(equalsRe); + scanner.scan(equalsRe); + scanner.scanUntil(closingTagRe); + } else if (type === '{') { + value = scanner.scanUntil(closingCurlyRe); + scanner.scan(curlyRe); + scanner.scanUntil(closingTagRe); + type = '&'; + } else { + value = scanner.scanUntil(closingTagRe); + } + + // Match the closing tag. + if (!scanner.scan(closingTagRe)) + throw new Error('Unclosed tag at ' + scanner.pos); + + if (type == '>') { + token = [ type, value, start, scanner.pos, indentation, tagIndex, lineHasNonSpace ]; + } else { + token = [ type, value, start, scanner.pos ]; + } + tagIndex++; + tokens.push(token); + + if (type === '#' || type === '^') { + sections.push(token); + } else if (type === '/') { + // Check section nesting. + openSection = sections.pop(); + + if (!openSection) + throw new Error('Unopened section "' + value + '" at ' + start); + + if (openSection[1] !== value) + throw new Error('Unclosed section "' + openSection[1] + '" at ' + start); + } else if (type === 'name' || type === '{' || type === '&') { + nonSpace = true; + } else if (type === '=') { + // Set the tags for the next time around. + compileTags(value); + } + } + + stripSpace(); + + // Make sure there are no open sections when we're done. + openSection = sections.pop(); + + if (openSection) + throw new Error('Unclosed section "' + openSection[1] + '" at ' + scanner.pos); + + return nestTokens(squashTokens(tokens)); +} + +/** + * Combines the values of consecutive text tokens in the given `tokens` array + * to a single token. + */ +function squashTokens (tokens) { + var squashedTokens = []; + + var token, lastToken; + for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) { + token = tokens[i]; + + if (token) { + if (token[0] === 'text' && lastToken && lastToken[0] === 'text') { + lastToken[1] += token[1]; + lastToken[3] = token[3]; + } else { + squashedTokens.push(token); + lastToken = token; + } + } + } + + return squashedTokens; +} + +/** + * Forms the given array of `tokens` into a nested tree structure where + * tokens that represent a section have two additional items: 1) an array of + * all tokens that appear in that section and 2) the index in the original + * template that represents the end of that section. + */ +function nestTokens (tokens) { + var nestedTokens = []; + var collector = nestedTokens; + var sections = []; + + var token, section; + for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) { + token = tokens[i]; + + switch (token[0]) { + case '#': + case '^': + collector.push(token); + sections.push(token); + collector = token[4] = []; + break; + case '/': + section = sections.pop(); + section[5] = token[2]; + collector = sections.length > 0 ? sections[sections.length - 1][4] : nestedTokens; + break; + default: + collector.push(token); + } + } + + return nestedTokens; +} + +/** + * A simple string scanner that is used by the template parser to find + * tokens in template strings. + */ +function Scanner (string) { + this.string = string; + this.tail = string; + this.pos = 0; +} + +/** + * Returns `true` if the tail is empty (end of string). + */ +Scanner.prototype.eos = function eos () { + return this.tail === ''; +}; + +/** + * Tries to match the given regular expression at the current position. + * Returns the matched text if it can match, the empty string otherwise. + */ +Scanner.prototype.scan = function scan (re) { + var match = this.tail.match(re); + + if (!match || match.index !== 0) + return ''; + + var string = match[0]; + + this.tail = this.tail.substring(string.length); + this.pos += string.length; + + return string; +}; + +/** + * Skips all text until the given regular expression can be matched. Returns + * the skipped string, which is the entire tail if no match can be made. + */ +Scanner.prototype.scanUntil = function scanUntil (re) { + var index = this.tail.search(re), match; + + switch (index) { + case -1: + match = this.tail; + this.tail = ''; + break; + case 0: + match = ''; + break; + default: + match = this.tail.substring(0, index); + this.tail = this.tail.substring(index); + } + + this.pos += match.length; + + return match; +}; + +/** + * Represents a rendering context by wrapping a view object and + * maintaining a reference to the parent context. + */ +function Context (view, parentContext) { + this.view = view; + this.cache = { '.': this.view }; + this.parent = parentContext; +} + +/** + * Creates a new context using the given view with this context + * as the parent. + */ +Context.prototype.push = function push (view) { + return new Context(view, this); +}; + +/** + * Returns the value of the given name in this context, traversing + * up the context hierarchy if the value is absent in this context's view. + */ +Context.prototype.lookup = function lookup (name) { + var cache = this.cache; + + var value; + if (cache.hasOwnProperty(name)) { + value = cache[name]; + } else { + var context = this, intermediateValue, names, index, lookupHit = false; + + while (context) { + if (name.indexOf('.') > 0) { + intermediateValue = context.view; + names = name.split('.'); + index = 0; + + /** + * Using the dot notion path in `name`, we descend through the + * nested objects. + * + * To be certain that the lookup has been successful, we have to + * check if the last object in the path actually has the property + * we are looking for. We store the result in `lookupHit`. + * + * This is specially necessary for when the value has been set to + * `undefined` and we want to avoid looking up parent contexts. + * + * In the case where dot notation is used, we consider the lookup + * to be successful even if the last "object" in the path is + * not actually an object but a primitive (e.g., a string, or an + * integer), because it is sometimes useful to access a property + * of an autoboxed primitive, such as the length of a string. + **/ + while (intermediateValue != null && index < names.length) { + if (index === names.length - 1) + lookupHit = ( + hasProperty(intermediateValue, names[index]) + || primitiveHasOwnProperty(intermediateValue, names[index]) + ); + + intermediateValue = intermediateValue[names[index++]]; + } + } else { + intermediateValue = context.view[name]; + + /** + * Only checking against `hasProperty`, which always returns `false` if + * `context.view` is not an object. Deliberately omitting the check + * against `primitiveHasOwnProperty` if dot notation is not used. + * + * Consider this example: + * ``` + * Mustache.render("The length of a football field is {{#length}}{{length}}{{/length}}.", {length: "100 yards"}) + * ``` + * + * If we were to check also against `primitiveHasOwnProperty`, as we do + * in the dot notation case, then render call would return: + * + * "The length of a football field is 9." + * + * rather than the expected: + * + * "The length of a football field is 100 yards." + **/ + lookupHit = hasProperty(context.view, name); + } + + if (lookupHit) { + value = intermediateValue; + break; + } + + context = context.parent; + } + + cache[name] = value; + } + + if (isFunction(value)) + value = value.call(this.view); + + return value; +}; + +/** + * A Writer knows how to take a stream of tokens and render them to a + * string, given a context. It also maintains a cache of templates to + * avoid the need to parse the same template twice. + */ +function Writer () { + this.templateCache = { + _cache: {}, + set: function set (key, value) { + this._cache[key] = value; + }, + get: function get (key) { + return this._cache[key]; + }, + clear: function clear () { + this._cache = {}; + } + }; +} + +/** + * Clears all cached templates in this writer. + */ +Writer.prototype.clearCache = function clearCache () { + if (typeof this.templateCache !== 'undefined') { + this.templateCache.clear(); + } +}; + +/** + * Parses and caches the given `template` according to the given `tags` or + * `mustache.tags` if `tags` is omitted, and returns the array of tokens + * that is generated from the parse. + */ +Writer.prototype.parse = function parse (template, tags) { + var cache = this.templateCache; + var cacheKey = template + ':' + (tags || mustache.tags).join(':'); + var isCacheEnabled = typeof cache !== 'undefined'; + var tokens = isCacheEnabled ? cache.get(cacheKey) : undefined; + + if (tokens == undefined) { + tokens = parseTemplate(template, tags); + isCacheEnabled && cache.set(cacheKey, tokens); + } + return tokens; +}; + +/** + * High-level method that is used to render the given `template` with + * the given `view`. + * + * The optional `partials` argument may be an object that contains the + * names and templates of partials that are used in the template. It may + * also be a function that is used to load partial templates on the fly + * that takes a single argument: the name of the partial. + * + * If the optional `config` argument is given here, then it should be an + * object with a `tags` attribute or an `escape` attribute or both. + * If an array is passed, then it will be interpreted the same way as + * a `tags` attribute on a `config` object. + * + * The `tags` attribute of a `config` object must be an array with two + * string values: the opening and closing tags used in the template (e.g. + * [ "<%", "%>" ]). The default is to mustache.tags. + * + * The `escape` attribute of a `config` object must be a function which + * accepts a string as input and outputs a safely escaped string. + * If an `escape` function is not provided, then an HTML-safe string + * escaping function is used as the default. + */ +Writer.prototype.render = function render (template, view, partials, config) { + var tags = this.getConfigTags(config); + var tokens = this.parse(template, tags); + var context = (view instanceof Context) ? view : new Context(view, undefined); + return this.renderTokens(tokens, context, partials, template, config); +}; + +/** + * Low-level method that renders the given array of `tokens` using + * the given `context` and `partials`. + * + * Note: The `originalTemplate` is only ever used to extract the portion + * of the original template that was contained in a higher-order section. + * If the template doesn't use higher-order sections, this argument may + * be omitted. + */ +Writer.prototype.renderTokens = function renderTokens (tokens, context, partials, originalTemplate, config) { + var buffer = ''; + + var token, symbol, value; + for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) { + value = undefined; + token = tokens[i]; + symbol = token[0]; + + if (symbol === '#') value = this.renderSection(token, context, partials, originalTemplate, config); + else if (symbol === '^') value = this.renderInverted(token, context, partials, originalTemplate, config); + else if (symbol === '>') value = this.renderPartial(token, context, partials, config); + else if (symbol === '&') value = this.unescapedValue(token, context); + else if (symbol === 'name') value = this.escapedValue(token, context, config); + else if (symbol === 'text') value = this.rawValue(token); + + if (value !== undefined) + buffer += value; + } + + return buffer; +}; + +Writer.prototype.renderSection = function renderSection (token, context, partials, originalTemplate, config) { + var self = this; + var buffer = ''; + var value = context.lookup(token[1]); + + // This function is used to render an arbitrary template + // in the current context by higher-order sections. + function subRender (template) { + return self.render(template, context, partials, config); + } + + if (!value) return; + + if (isArray(value)) { + for (var j = 0, valueLength = value.length; j < valueLength; ++j) { + buffer += this.renderTokens(token[4], context.push(value[j]), partials, originalTemplate, config); + } + } else if (typeof value === 'object' || typeof value === 'string' || typeof value === 'number') { + buffer += this.renderTokens(token[4], context.push(value), partials, originalTemplate, config); + } else if (isFunction(value)) { + if (typeof originalTemplate !== 'string') + throw new Error('Cannot use higher-order sections without the original template'); + + // Extract the portion of the original template that the section contains. + value = value.call(context.view, originalTemplate.slice(token[3], token[5]), subRender); + + if (value != null) + buffer += value; + } else { + buffer += this.renderTokens(token[4], context, partials, originalTemplate, config); + } + return buffer; +}; + +Writer.prototype.renderInverted = function renderInverted (token, context, partials, originalTemplate, config) { + var value = context.lookup(token[1]); + + // Use JavaScript's definition of falsy. Include empty arrays. + // See https://github.com/janl/mustache.js/issues/186 + if (!value || (isArray(value) && value.length === 0)) + return this.renderTokens(token[4], context, partials, originalTemplate, config); +}; + +Writer.prototype.indentPartial = function indentPartial (partial, indentation, lineHasNonSpace) { + var filteredIndentation = indentation.replace(/[^ \t]/g, ''); + var partialByNl = partial.split('\n'); + for (var i = 0; i < partialByNl.length; i++) { + if (partialByNl[i].length && (i > 0 || !lineHasNonSpace)) { + partialByNl[i] = filteredIndentation + partialByNl[i]; + } + } + return partialByNl.join('\n'); +}; + +Writer.prototype.renderPartial = function renderPartial (token, context, partials, config) { + if (!partials) return; + var tags = this.getConfigTags(config); + + var value = isFunction(partials) ? partials(token[1]) : partials[token[1]]; + if (value != null) { + var lineHasNonSpace = token[6]; + var tagIndex = token[5]; + var indentation = token[4]; + var indentedValue = value; + if (tagIndex == 0 && indentation) { + indentedValue = this.indentPartial(value, indentation, lineHasNonSpace); + } + var tokens = this.parse(indentedValue, tags); + return this.renderTokens(tokens, context, partials, indentedValue, config); + } +}; + +Writer.prototype.unescapedValue = function unescapedValue (token, context) { + var value = context.lookup(token[1]); + if (value != null) + return value; +}; + +Writer.prototype.escapedValue = function escapedValue (token, context, config) { + var escape = this.getConfigEscape(config) || mustache.escape; + var value = context.lookup(token[1]); + if (value != null) + return (typeof value === 'number' && escape === mustache.escape) ? String(value) : escape(value); +}; + +Writer.prototype.rawValue = function rawValue (token) { + return token[1]; +}; + +Writer.prototype.getConfigTags = function getConfigTags (config) { + if (isArray(config)) { + return config; + } + else if (config && typeof config === 'object') { + return config.tags; + } + else { + return undefined; + } +}; + +Writer.prototype.getConfigEscape = function getConfigEscape (config) { + if (config && typeof config === 'object' && !isArray(config)) { + return config.escape; + } + else { + return undefined; + } +}; + +var mustache = { + name: 'mustache.js', + version: '4.2.0', + tags: [ '{{', '}}' ], + clearCache: undefined, + escape: undefined, + parse: undefined, + render: undefined, + Scanner: undefined, + Context: undefined, + Writer: undefined, + /** + * Allows a user to override the default caching strategy, by providing an + * object with set, get and clear methods. This can also be used to disable + * the cache by setting it to the literal `undefined`. + */ + set templateCache (cache) { + defaultWriter.templateCache = cache; + }, + /** + * Gets the default or overridden caching object from the default writer. + */ + get templateCache () { + return defaultWriter.templateCache; + } +}; + +// All high-level mustache.* functions use this writer. +var defaultWriter = new Writer(); + +/** + * Clears all cached templates in the default writer. + */ +mustache.clearCache = function clearCache () { + return defaultWriter.clearCache(); +}; + +/** + * Parses and caches the given template in the default writer and returns the + * array of tokens it contains. Doing this ahead of time avoids the need to + * parse templates on the fly as they are rendered. + */ +mustache.parse = function parse (template, tags) { + return defaultWriter.parse(template, tags); +}; + +/** + * Renders the `template` with the given `view`, `partials`, and `config` + * using the default writer. + */ +mustache.render = function render (template, view, partials, config) { + if (typeof template !== 'string') { + throw new TypeError('Invalid template! Template should be a "string" ' + + 'but "' + typeStr(template) + '" was given as the first ' + + 'argument for mustache#render(template, view, partials)'); + } + + return defaultWriter.render(template, view, partials, config); +}; + +// Export the escaping function so that the user may override it. +// See https://github.com/janl/mustache.js/issues/244 +mustache.escape = escapeHtml; + +// Export these mainly for testing, but also for advanced usage. +mustache.Scanner = Scanner; +mustache.Context = Context; +mustache.Writer = Writer; + +/* harmony default export */ const mustache_mustache = (mustache); + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/prompts/template.js + +const parseFString = (template) => { + // Core logic replicated from internals of pythons built in Formatter class. + // https://github.com/python/cpython/blob/135ec7cefbaffd516b77362ad2b2ad1025af462e/Objects/stringlib/unicode_format.h#L700-L706 + const chars = template.split(""); + const nodes = []; + const nextBracket = (bracket, start) => { + for (let i = start; i < chars.length; i += 1) { + if (bracket.includes(chars[i])) { + return i; + } + } + return -1; + }; + let i = 0; + while (i < chars.length) { + if (chars[i] === "{" && i + 1 < chars.length && chars[i + 1] === "{") { + nodes.push({ type: "literal", text: "{" }); + i += 2; + } + else if (chars[i] === "}" && + i + 1 < chars.length && + chars[i + 1] === "}") { + nodes.push({ type: "literal", text: "}" }); + i += 2; + } + else if (chars[i] === "{") { + const j = nextBracket("}", i); + if (j < 0) { + throw new Error("Unclosed '{' in template."); + } + nodes.push({ + type: "variable", + name: chars.slice(i + 1, j).join(""), + }); + i = j + 1; + } + else if (chars[i] === "}") { + throw new Error("Single '}' in template."); + } + else { + const next = nextBracket("{}", i); + const text = (next < 0 ? chars.slice(i) : chars.slice(i, next)).join(""); + nodes.push({ type: "literal", text }); + i = next < 0 ? chars.length : next; + } + } + return nodes; +}; +/** + * Convert the result of mustache.parse into an array of ParsedTemplateNode, + * to make it compatible with other LangChain string parsing template formats. + * + * @param {mustache.TemplateSpans} template The result of parsing a mustache template with the mustache.js library. + * @returns {ParsedTemplateNode[]} + */ +const mustacheTemplateToNodes = (template) => template.map((temp) => { + if (temp[0] === "name") { + const name = temp[1].includes(".") ? temp[1].split(".")[0] : temp[1]; + return { type: "variable", name }; + } + else if (temp[0] === "#") { + return { type: "variable", name: temp[1] }; + } + else { + return { type: "literal", text: temp[1] }; + } +}); +const parseMustache = (template) => { + const parsed = mustache_mustache.parse(template); + return mustacheTemplateToNodes(parsed); +}; +const interpolateFString = (template, values) => parseFString(template).reduce((res, node) => { + if (node.type === "variable") { + if (node.name in values) { + return res + values[node.name]; + } + throw new Error(`(f-string) Missing value for input ${node.name}`); + } + return res + node.text; +}, ""); +const interpolateMustache = (template, values) => mustache_mustache.render(template, values); +const DEFAULT_FORMATTER_MAPPING = { + "f-string": interpolateFString, + mustache: interpolateMustache, +}; +const DEFAULT_PARSER_MAPPING = { + "f-string": parseFString, + mustache: parseMustache, +}; +const renderTemplate = (template, templateFormat, inputValues) => DEFAULT_FORMATTER_MAPPING[templateFormat](template, inputValues); +const template_parseTemplate = (template, templateFormat) => DEFAULT_PARSER_MAPPING[templateFormat](template); +const checkValidTemplate = (template, templateFormat, inputVariables) => { + if (!(templateFormat in DEFAULT_FORMATTER_MAPPING)) { + const validFormats = Object.keys(DEFAULT_FORMATTER_MAPPING); + throw new Error(`Invalid template format. Got \`${templateFormat}\`; + should be one of ${validFormats}`); + } + try { + const dummyInputs = inputVariables.reduce((acc, v) => { + acc[v] = "foo"; + return acc; + }, {}); + if (Array.isArray(template)) { + template.forEach((message) => { + if (message.type === "text") { + renderTemplate(message.text, templateFormat, dummyInputs); + } + else if (message.type === "image_url") { + if (typeof message.image_url === "string") { + renderTemplate(message.image_url, templateFormat, dummyInputs); + } + else { + const imageUrl = message.image_url.url; + renderTemplate(imageUrl, templateFormat, dummyInputs); + } + } + else { + throw new Error(`Invalid message template received. ${JSON.stringify(message, null, 2)}`); + } + }); + } + else { + renderTemplate(template, templateFormat, dummyInputs); + } + // eslint-disable-next-line @typescript-eslint/no-explicit-any + } + catch (e) { + throw new Error(`Invalid prompt schema: ${e.message}`); + } +}; + + +/***/ }), + +/***/ 75139: +/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { + + +// EXPORTS +__webpack_require__.d(__webpack_exports__, { + "eq": () => (/* binding */ Runnable) +}); + +// UNUSED EXPORTS: RunnableAssign, RunnableBinding, RunnableEach, RunnableLambda, RunnableMap, RunnableParallel, RunnablePick, RunnableRetry, RunnableSequence, RunnableWithFallbacks, _coerceToDict, _coerceToRunnable + +// NAMESPACE OBJECT: ./node_modules/@langchain/core/dist/utils/fast-json-patch/src/core.js +var core_namespaceObject = {}; +__webpack_require__.r(core_namespaceObject); +__webpack_require__.d(core_namespaceObject, { + "JsonPatchError": () => (JsonPatchError), + "_areEquals": () => (_areEquals), + "applyOperation": () => (applyOperation), + "applyPatch": () => (core_applyPatch), + "applyReducer": () => (applyReducer), + "deepClone": () => (deepClone), + "getValueByPointer": () => (getValueByPointer), + "validate": () => (core_validate), + "validator": () => (validator) +}); + +;// CONCATENATED MODULE: ./node_modules/zod/lib/index.mjs +var util; +(function (util) { + util.assertEqual = (val) => val; + function assertIs(_arg) { } + util.assertIs = assertIs; + function assertNever(_x) { + throw new Error(); + } + util.assertNever = assertNever; + util.arrayToEnum = (items) => { + const obj = {}; + for (const item of items) { + obj[item] = item; + } + return obj; + }; + util.getValidEnumValues = (obj) => { + const validKeys = util.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number"); + const filtered = {}; + for (const k of validKeys) { + filtered[k] = obj[k]; + } + return util.objectValues(filtered); + }; + util.objectValues = (obj) => { + return util.objectKeys(obj).map(function (e) { + return obj[e]; + }); + }; + util.objectKeys = typeof Object.keys === "function" // eslint-disable-line ban/ban + ? (obj) => Object.keys(obj) // eslint-disable-line ban/ban + : (object) => { + const keys = []; + for (const key in object) { + if (Object.prototype.hasOwnProperty.call(object, key)) { + keys.push(key); + } + } + return keys; + }; + util.find = (arr, checker) => { + for (const item of arr) { + if (checker(item)) + return item; + } + return undefined; + }; + util.isInteger = typeof Number.isInteger === "function" + ? (val) => Number.isInteger(val) // eslint-disable-line ban/ban + : (val) => typeof val === "number" && isFinite(val) && Math.floor(val) === val; + function joinValues(array, separator = " | ") { + return array + .map((val) => (typeof val === "string" ? `'${val}'` : val)) + .join(separator); + } + util.joinValues = joinValues; + util.jsonStringifyReplacer = (_, value) => { + if (typeof value === "bigint") { + return value.toString(); + } + return value; + }; +})(util || (util = {})); +var objectUtil; +(function (objectUtil) { + objectUtil.mergeShapes = (first, second) => { + return { + ...first, + ...second, // second overwrites first + }; + }; +})(objectUtil || (objectUtil = {})); +const ZodParsedType = util.arrayToEnum([ + "string", + "nan", + "number", + "integer", + "float", + "boolean", + "date", + "bigint", + "symbol", + "function", + "undefined", + "null", + "array", + "object", + "unknown", + "promise", + "void", + "never", + "map", + "set", +]); +const getParsedType = (data) => { + const t = typeof data; + switch (t) { + case "undefined": + return ZodParsedType.undefined; + case "string": + return ZodParsedType.string; + case "number": + return isNaN(data) ? ZodParsedType.nan : ZodParsedType.number; + case "boolean": + return ZodParsedType.boolean; + case "function": + return ZodParsedType.function; + case "bigint": + return ZodParsedType.bigint; + case "symbol": + return ZodParsedType.symbol; + case "object": + if (Array.isArray(data)) { + return ZodParsedType.array; + } + if (data === null) { + return ZodParsedType.null; + } + if (data.then && + typeof data.then === "function" && + data.catch && + typeof data.catch === "function") { + return ZodParsedType.promise; + } + if (typeof Map !== "undefined" && data instanceof Map) { + return ZodParsedType.map; + } + if (typeof Set !== "undefined" && data instanceof Set) { + return ZodParsedType.set; + } + if (typeof Date !== "undefined" && data instanceof Date) { + return ZodParsedType.date; + } + return ZodParsedType.object; + default: + return ZodParsedType.unknown; + } +}; + +const ZodIssueCode = util.arrayToEnum([ + "invalid_type", + "invalid_literal", + "custom", + "invalid_union", + "invalid_union_discriminator", + "invalid_enum_value", + "unrecognized_keys", + "invalid_arguments", + "invalid_return_type", + "invalid_date", + "invalid_string", + "too_small", + "too_big", + "invalid_intersection_types", + "not_multiple_of", + "not_finite", +]); +const quotelessJson = (obj) => { + const json = JSON.stringify(obj, null, 2); + return json.replace(/"([^"]+)":/g, "$1:"); +}; +class ZodError extends Error { + constructor(issues) { + super(); + this.issues = []; + this.addIssue = (sub) => { + this.issues = [...this.issues, sub]; + }; + this.addIssues = (subs = []) => { + this.issues = [...this.issues, ...subs]; + }; + const actualProto = new.target.prototype; + if (Object.setPrototypeOf) { + // eslint-disable-next-line ban/ban + Object.setPrototypeOf(this, actualProto); + } + else { + this.__proto__ = actualProto; + } + this.name = "ZodError"; + this.issues = issues; + } + get errors() { + return this.issues; + } + format(_mapper) { + const mapper = _mapper || + function (issue) { + return issue.message; + }; + const fieldErrors = { _errors: [] }; + const processError = (error) => { + for (const issue of error.issues) { + if (issue.code === "invalid_union") { + issue.unionErrors.map(processError); + } + else if (issue.code === "invalid_return_type") { + processError(issue.returnTypeError); + } + else if (issue.code === "invalid_arguments") { + processError(issue.argumentsError); + } + else if (issue.path.length === 0) { + fieldErrors._errors.push(mapper(issue)); + } + else { + let curr = fieldErrors; + let i = 0; + while (i < issue.path.length) { + const el = issue.path[i]; + const terminal = i === issue.path.length - 1; + if (!terminal) { + curr[el] = curr[el] || { _errors: [] }; + // if (typeof el === "string") { + // curr[el] = curr[el] || { _errors: [] }; + // } else if (typeof el === "number") { + // const errorArray: any = []; + // errorArray._errors = []; + // curr[el] = curr[el] || errorArray; + // } + } + else { + curr[el] = curr[el] || { _errors: [] }; + curr[el]._errors.push(mapper(issue)); + } + curr = curr[el]; + i++; + } + } + } + }; + processError(this); + return fieldErrors; + } + static assert(value) { + if (!(value instanceof ZodError)) { + throw new Error(`Not a ZodError: ${value}`); + } + } + toString() { + return this.message; + } + get message() { + return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2); + } + get isEmpty() { + return this.issues.length === 0; + } + flatten(mapper = (issue) => issue.message) { + const fieldErrors = {}; + const formErrors = []; + for (const sub of this.issues) { + if (sub.path.length > 0) { + fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || []; + fieldErrors[sub.path[0]].push(mapper(sub)); + } + else { + formErrors.push(mapper(sub)); + } + } + return { formErrors, fieldErrors }; + } + get formErrors() { + return this.flatten(); + } +} +ZodError.create = (issues) => { + const error = new ZodError(issues); + return error; +}; + +const errorMap = (issue, _ctx) => { + let message; + switch (issue.code) { + case ZodIssueCode.invalid_type: + if (issue.received === ZodParsedType.undefined) { + message = "Required"; + } + else { + message = `Expected ${issue.expected}, received ${issue.received}`; + } + break; + case ZodIssueCode.invalid_literal: + message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`; + break; + case ZodIssueCode.unrecognized_keys: + message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`; + break; + case ZodIssueCode.invalid_union: + message = `Invalid input`; + break; + case ZodIssueCode.invalid_union_discriminator: + message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`; + break; + case ZodIssueCode.invalid_enum_value: + message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`; + break; + case ZodIssueCode.invalid_arguments: + message = `Invalid function arguments`; + break; + case ZodIssueCode.invalid_return_type: + message = `Invalid function return type`; + break; + case ZodIssueCode.invalid_date: + message = `Invalid date`; + break; + case ZodIssueCode.invalid_string: + if (typeof issue.validation === "object") { + if ("includes" in issue.validation) { + message = `Invalid input: must include "${issue.validation.includes}"`; + if (typeof issue.validation.position === "number") { + message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`; + } + } + else if ("startsWith" in issue.validation) { + message = `Invalid input: must start with "${issue.validation.startsWith}"`; + } + else if ("endsWith" in issue.validation) { + message = `Invalid input: must end with "${issue.validation.endsWith}"`; + } + else { + util.assertNever(issue.validation); + } + } + else if (issue.validation !== "regex") { + message = `Invalid ${issue.validation}`; + } + else { + message = "Invalid"; + } + break; + case ZodIssueCode.too_small: + if (issue.type === "array") + message = `Array must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`; + else if (issue.type === "string") + message = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`; + else if (issue.type === "number") + message = `Number must be ${issue.exact + ? `exactly equal to ` + : issue.inclusive + ? `greater than or equal to ` + : `greater than `}${issue.minimum}`; + else if (issue.type === "date") + message = `Date must be ${issue.exact + ? `exactly equal to ` + : issue.inclusive + ? `greater than or equal to ` + : `greater than `}${new Date(Number(issue.minimum))}`; + else + message = "Invalid input"; + break; + case ZodIssueCode.too_big: + if (issue.type === "array") + message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`; + else if (issue.type === "string") + message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`; + else if (issue.type === "number") + message = `Number must be ${issue.exact + ? `exactly` + : issue.inclusive + ? `less than or equal to` + : `less than`} ${issue.maximum}`; + else if (issue.type === "bigint") + message = `BigInt must be ${issue.exact + ? `exactly` + : issue.inclusive + ? `less than or equal to` + : `less than`} ${issue.maximum}`; + else if (issue.type === "date") + message = `Date must be ${issue.exact + ? `exactly` + : issue.inclusive + ? `smaller than or equal to` + : `smaller than`} ${new Date(Number(issue.maximum))}`; + else + message = "Invalid input"; + break; + case ZodIssueCode.custom: + message = `Invalid input`; + break; + case ZodIssueCode.invalid_intersection_types: + message = `Intersection results could not be merged`; + break; + case ZodIssueCode.not_multiple_of: + message = `Number must be a multiple of ${issue.multipleOf}`; + break; + case ZodIssueCode.not_finite: + message = "Number must be finite"; + break; + default: + message = _ctx.defaultError; + util.assertNever(issue); + } + return { message }; +}; + +let overrideErrorMap = errorMap; +function setErrorMap(map) { + overrideErrorMap = map; +} +function getErrorMap() { + return overrideErrorMap; +} + +const makeIssue = (params) => { + const { data, path, errorMaps, issueData } = params; + const fullPath = [...path, ...(issueData.path || [])]; + const fullIssue = { + ...issueData, + path: fullPath, + }; + if (issueData.message !== undefined) { + return { + ...issueData, + path: fullPath, + message: issueData.message, + }; + } + let errorMessage = ""; + const maps = errorMaps + .filter((m) => !!m) + .slice() + .reverse(); + for (const map of maps) { + errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message; + } + return { + ...issueData, + path: fullPath, + message: errorMessage, + }; +}; +const EMPTY_PATH = []; +function addIssueToContext(ctx, issueData) { + const overrideMap = getErrorMap(); + const issue = makeIssue({ + issueData: issueData, + data: ctx.data, + path: ctx.path, + errorMaps: [ + ctx.common.contextualErrorMap, + ctx.schemaErrorMap, + overrideMap, + overrideMap === errorMap ? undefined : errorMap, // then global default map + ].filter((x) => !!x), + }); + ctx.common.issues.push(issue); +} +class ParseStatus { + constructor() { + this.value = "valid"; + } + dirty() { + if (this.value === "valid") + this.value = "dirty"; + } + abort() { + if (this.value !== "aborted") + this.value = "aborted"; + } + static mergeArray(status, results) { + const arrayValue = []; + for (const s of results) { + if (s.status === "aborted") + return INVALID; + if (s.status === "dirty") + status.dirty(); + arrayValue.push(s.value); + } + return { status: status.value, value: arrayValue }; + } + static async mergeObjectAsync(status, pairs) { + const syncPairs = []; + for (const pair of pairs) { + const key = await pair.key; + const value = await pair.value; + syncPairs.push({ + key, + value, + }); + } + return ParseStatus.mergeObjectSync(status, syncPairs); + } + static mergeObjectSync(status, pairs) { + const finalObject = {}; + for (const pair of pairs) { + const { key, value } = pair; + if (key.status === "aborted") + return INVALID; + if (value.status === "aborted") + return INVALID; + if (key.status === "dirty") + status.dirty(); + if (value.status === "dirty") + status.dirty(); + if (key.value !== "__proto__" && + (typeof value.value !== "undefined" || pair.alwaysSet)) { + finalObject[key.value] = value.value; + } + } + return { status: status.value, value: finalObject }; + } +} +const INVALID = Object.freeze({ + status: "aborted", +}); +const DIRTY = (value) => ({ status: "dirty", value }); +const OK = (value) => ({ status: "valid", value }); +const isAborted = (x) => x.status === "aborted"; +const isDirty = (x) => x.status === "dirty"; +const isValid = (x) => x.status === "valid"; +const isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise; + +/****************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ + +function __classPrivateFieldGet(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); +} + +function __classPrivateFieldSet(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; +} + +typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}; + +var errorUtil; +(function (errorUtil) { + errorUtil.errToObj = (message) => typeof message === "string" ? { message } : message || {}; + errorUtil.toString = (message) => typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message; +})(errorUtil || (errorUtil = {})); + +var _ZodEnum_cache, _ZodNativeEnum_cache; +class ParseInputLazyPath { + constructor(parent, value, path, key) { + this._cachedPath = []; + this.parent = parent; + this.data = value; + this._path = path; + this._key = key; + } + get path() { + if (!this._cachedPath.length) { + if (this._key instanceof Array) { + this._cachedPath.push(...this._path, ...this._key); + } + else { + this._cachedPath.push(...this._path, this._key); + } + } + return this._cachedPath; + } +} +const handleResult = (ctx, result) => { + if (isValid(result)) { + return { success: true, data: result.value }; + } + else { + if (!ctx.common.issues.length) { + throw new Error("Validation failed but no issues detected."); + } + return { + success: false, + get error() { + if (this._error) + return this._error; + const error = new ZodError(ctx.common.issues); + this._error = error; + return this._error; + }, + }; + } +}; +function processCreateParams(params) { + if (!params) + return {}; + const { errorMap, invalid_type_error, required_error, description } = params; + if (errorMap && (invalid_type_error || required_error)) { + throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`); + } + if (errorMap) + return { errorMap: errorMap, description }; + const customMap = (iss, ctx) => { + var _a, _b; + const { message } = params; + if (iss.code === "invalid_enum_value") { + return { message: message !== null && message !== void 0 ? message : ctx.defaultError }; + } + if (typeof ctx.data === "undefined") { + return { message: (_a = message !== null && message !== void 0 ? message : required_error) !== null && _a !== void 0 ? _a : ctx.defaultError }; + } + if (iss.code !== "invalid_type") + return { message: ctx.defaultError }; + return { message: (_b = message !== null && message !== void 0 ? message : invalid_type_error) !== null && _b !== void 0 ? _b : ctx.defaultError }; + }; + return { errorMap: customMap, description }; +} +class ZodType { + constructor(def) { + /** Alias of safeParseAsync */ + this.spa = this.safeParseAsync; + this._def = def; + this.parse = this.parse.bind(this); + this.safeParse = this.safeParse.bind(this); + this.parseAsync = this.parseAsync.bind(this); + this.safeParseAsync = this.safeParseAsync.bind(this); + this.spa = this.spa.bind(this); + this.refine = this.refine.bind(this); + this.refinement = this.refinement.bind(this); + this.superRefine = this.superRefine.bind(this); + this.optional = this.optional.bind(this); + this.nullable = this.nullable.bind(this); + this.nullish = this.nullish.bind(this); + this.array = this.array.bind(this); + this.promise = this.promise.bind(this); + this.or = this.or.bind(this); + this.and = this.and.bind(this); + this.transform = this.transform.bind(this); + this.brand = this.brand.bind(this); + this.default = this.default.bind(this); + this.catch = this.catch.bind(this); + this.describe = this.describe.bind(this); + this.pipe = this.pipe.bind(this); + this.readonly = this.readonly.bind(this); + this.isNullable = this.isNullable.bind(this); + this.isOptional = this.isOptional.bind(this); + } + get description() { + return this._def.description; + } + _getType(input) { + return getParsedType(input.data); + } + _getOrReturnCtx(input, ctx) { + return (ctx || { + common: input.parent.common, + data: input.data, + parsedType: getParsedType(input.data), + schemaErrorMap: this._def.errorMap, + path: input.path, + parent: input.parent, + }); + } + _processInputParams(input) { + return { + status: new ParseStatus(), + ctx: { + common: input.parent.common, + data: input.data, + parsedType: getParsedType(input.data), + schemaErrorMap: this._def.errorMap, + path: input.path, + parent: input.parent, + }, + }; + } + _parseSync(input) { + const result = this._parse(input); + if (isAsync(result)) { + throw new Error("Synchronous parse encountered promise."); + } + return result; + } + _parseAsync(input) { + const result = this._parse(input); + return Promise.resolve(result); + } + parse(data, params) { + const result = this.safeParse(data, params); + if (result.success) + return result.data; + throw result.error; + } + safeParse(data, params) { + var _a; + const ctx = { + common: { + issues: [], + async: (_a = params === null || params === void 0 ? void 0 : params.async) !== null && _a !== void 0 ? _a : false, + contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap, + }, + path: (params === null || params === void 0 ? void 0 : params.path) || [], + schemaErrorMap: this._def.errorMap, + parent: null, + data, + parsedType: getParsedType(data), + }; + const result = this._parseSync({ data, path: ctx.path, parent: ctx }); + return handleResult(ctx, result); + } + async parseAsync(data, params) { + const result = await this.safeParseAsync(data, params); + if (result.success) + return result.data; + throw result.error; + } + async safeParseAsync(data, params) { + const ctx = { + common: { + issues: [], + contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap, + async: true, + }, + path: (params === null || params === void 0 ? void 0 : params.path) || [], + schemaErrorMap: this._def.errorMap, + parent: null, + data, + parsedType: getParsedType(data), + }; + const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx }); + const result = await (isAsync(maybeAsyncResult) + ? maybeAsyncResult + : Promise.resolve(maybeAsyncResult)); + return handleResult(ctx, result); + } + refine(check, message) { + const getIssueProperties = (val) => { + if (typeof message === "string" || typeof message === "undefined") { + return { message }; + } + else if (typeof message === "function") { + return message(val); + } + else { + return message; + } + }; + return this._refinement((val, ctx) => { + const result = check(val); + const setError = () => ctx.addIssue({ + code: ZodIssueCode.custom, + ...getIssueProperties(val), + }); + if (typeof Promise !== "undefined" && result instanceof Promise) { + return result.then((data) => { + if (!data) { + setError(); + return false; + } + else { + return true; + } + }); + } + if (!result) { + setError(); + return false; + } + else { + return true; + } + }); + } + refinement(check, refinementData) { + return this._refinement((val, ctx) => { + if (!check(val)) { + ctx.addIssue(typeof refinementData === "function" + ? refinementData(val, ctx) + : refinementData); + return false; + } + else { + return true; + } + }); + } + _refinement(refinement) { + return new ZodEffects({ + schema: this, + typeName: ZodFirstPartyTypeKind.ZodEffects, + effect: { type: "refinement", refinement }, + }); + } + superRefine(refinement) { + return this._refinement(refinement); + } + optional() { + return ZodOptional.create(this, this._def); + } + nullable() { + return ZodNullable.create(this, this._def); + } + nullish() { + return this.nullable().optional(); + } + array() { + return ZodArray.create(this, this._def); + } + promise() { + return ZodPromise.create(this, this._def); + } + or(option) { + return ZodUnion.create([this, option], this._def); + } + and(incoming) { + return ZodIntersection.create(this, incoming, this._def); + } + transform(transform) { + return new ZodEffects({ + ...processCreateParams(this._def), + schema: this, + typeName: ZodFirstPartyTypeKind.ZodEffects, + effect: { type: "transform", transform }, + }); + } + default(def) { + const defaultValueFunc = typeof def === "function" ? def : () => def; + return new ZodDefault({ + ...processCreateParams(this._def), + innerType: this, + defaultValue: defaultValueFunc, + typeName: ZodFirstPartyTypeKind.ZodDefault, + }); + } + brand() { + return new ZodBranded({ + typeName: ZodFirstPartyTypeKind.ZodBranded, + type: this, + ...processCreateParams(this._def), + }); + } + catch(def) { + const catchValueFunc = typeof def === "function" ? def : () => def; + return new ZodCatch({ + ...processCreateParams(this._def), + innerType: this, + catchValue: catchValueFunc, + typeName: ZodFirstPartyTypeKind.ZodCatch, + }); + } + describe(description) { + const This = this.constructor; + return new This({ + ...this._def, + description, + }); + } + pipe(target) { + return ZodPipeline.create(this, target); + } + readonly() { + return ZodReadonly.create(this); + } + isOptional() { + return this.safeParse(undefined).success; + } + isNullable() { + return this.safeParse(null).success; + } +} +const cuidRegex = /^c[^\s-]{8,}$/i; +const cuid2Regex = /^[0-9a-z]+$/; +const ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/; +// const uuidRegex = +// /^([a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[a-f0-9]{4}-[a-f0-9]{12}|00000000-0000-0000-0000-000000000000)$/i; +const uuidRegex = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i; +const nanoidRegex = /^[a-z0-9_-]{21}$/i; +const durationRegex = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/; +// from https://stackoverflow.com/a/46181/1550155 +// old version: too slow, didn't support unicode +// const emailRegex = /^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))$/i; +//old email regex +// const emailRegex = /^(([^<>()[\].,;:\s@"]+(\.[^<>()[\].,;:\s@"]+)*)|(".+"))@((?!-)([^<>()[\].,;:\s@"]+\.)+[^<>()[\].,;:\s@"]{1,})[^-<>()[\].,;:\s@"]$/i; +// eslint-disable-next-line +// const emailRegex = +// /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\])|(\[IPv6:(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))\])|([A-Za-z0-9]([A-Za-z0-9-]*[A-Za-z0-9])*(\.[A-Za-z]{2,})+))$/; +// const emailRegex = +// /^[a-zA-Z0-9\.\!\#\$\%\&\'\*\+\/\=\?\^\_\`\{\|\}\~\-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/; +// const emailRegex = +// /^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])$/i; +const emailRegex = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i; +// const emailRegex = +// /^[a-z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-z0-9-]+(?:\.[a-z0-9\-]+)*$/i; +// from https://thekevinscott.com/emojis-in-javascript/#writing-a-regular-expression +const _emojiRegex = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`; +let emojiRegex; +// faster, simpler, safer +const ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/; +const ipv6Regex = /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/; +// https://stackoverflow.com/questions/7860392/determine-if-string-is-in-base64-using-javascript +const base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/; +// simple +// const dateRegexSource = `\\d{4}-\\d{2}-\\d{2}`; +// no leap year validation +// const dateRegexSource = `\\d{4}-((0[13578]|10|12)-31|(0[13-9]|1[0-2])-30|(0[1-9]|1[0-2])-(0[1-9]|1\\d|2\\d))`; +// with leap year validation +const dateRegexSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`; +const dateRegex = new RegExp(`^${dateRegexSource}$`); +function timeRegexSource(args) { + // let regex = `\\d{2}:\\d{2}:\\d{2}`; + let regex = `([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d`; + if (args.precision) { + regex = `${regex}\\.\\d{${args.precision}}`; + } + else if (args.precision == null) { + regex = `${regex}(\\.\\d+)?`; + } + return regex; +} +function timeRegex(args) { + return new RegExp(`^${timeRegexSource(args)}$`); +} +// Adapted from https://stackoverflow.com/a/3143231 +function datetimeRegex(args) { + let regex = `${dateRegexSource}T${timeRegexSource(args)}`; + const opts = []; + opts.push(args.local ? `Z?` : `Z`); + if (args.offset) + opts.push(`([+-]\\d{2}:?\\d{2})`); + regex = `${regex}(${opts.join("|")})`; + return new RegExp(`^${regex}$`); +} +function isValidIP(ip, version) { + if ((version === "v4" || !version) && ipv4Regex.test(ip)) { + return true; + } + if ((version === "v6" || !version) && ipv6Regex.test(ip)) { + return true; + } + return false; +} +class ZodString extends ZodType { + _parse(input) { + if (this._def.coerce) { + input.data = String(input.data); + } + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.string) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.string, + received: ctx.parsedType, + }); + return INVALID; + } + const status = new ParseStatus(); + let ctx = undefined; + for (const check of this._def.checks) { + if (check.kind === "min") { + if (input.data.length < check.value) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: check.value, + type: "string", + inclusive: true, + exact: false, + message: check.message, + }); + status.dirty(); + } + } + else if (check.kind === "max") { + if (input.data.length > check.value) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: check.value, + type: "string", + inclusive: true, + exact: false, + message: check.message, + }); + status.dirty(); + } + } + else if (check.kind === "length") { + const tooBig = input.data.length > check.value; + const tooSmall = input.data.length < check.value; + if (tooBig || tooSmall) { + ctx = this._getOrReturnCtx(input, ctx); + if (tooBig) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: check.value, + type: "string", + inclusive: true, + exact: true, + message: check.message, + }); + } + else if (tooSmall) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: check.value, + type: "string", + inclusive: true, + exact: true, + message: check.message, + }); + } + status.dirty(); + } + } + else if (check.kind === "email") { + if (!emailRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "email", + code: ZodIssueCode.invalid_string, + message: check.message, + }); + status.dirty(); + } + } + else if (check.kind === "emoji") { + if (!emojiRegex) { + emojiRegex = new RegExp(_emojiRegex, "u"); + } + if (!emojiRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "emoji", + code: ZodIssueCode.invalid_string, + message: check.message, + }); + status.dirty(); + } + } + else if (check.kind === "uuid") { + if (!uuidRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "uuid", + code: ZodIssueCode.invalid_string, + message: check.message, + }); + status.dirty(); + } + } + else if (check.kind === "nanoid") { + if (!nanoidRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "nanoid", + code: ZodIssueCode.invalid_string, + message: check.message, + }); + status.dirty(); + } + } + else if (check.kind === "cuid") { + if (!cuidRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "cuid", + code: ZodIssueCode.invalid_string, + message: check.message, + }); + status.dirty(); + } + } + else if (check.kind === "cuid2") { + if (!cuid2Regex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "cuid2", + code: ZodIssueCode.invalid_string, + message: check.message, + }); + status.dirty(); + } + } + else if (check.kind === "ulid") { + if (!ulidRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "ulid", + code: ZodIssueCode.invalid_string, + message: check.message, + }); + status.dirty(); + } + } + else if (check.kind === "url") { + try { + new URL(input.data); + } + catch (_a) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "url", + code: ZodIssueCode.invalid_string, + message: check.message, + }); + status.dirty(); + } + } + else if (check.kind === "regex") { + check.regex.lastIndex = 0; + const testResult = check.regex.test(input.data); + if (!testResult) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "regex", + code: ZodIssueCode.invalid_string, + message: check.message, + }); + status.dirty(); + } + } + else if (check.kind === "trim") { + input.data = input.data.trim(); + } + else if (check.kind === "includes") { + if (!input.data.includes(check.value, check.position)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: { includes: check.value, position: check.position }, + message: check.message, + }); + status.dirty(); + } + } + else if (check.kind === "toLowerCase") { + input.data = input.data.toLowerCase(); + } + else if (check.kind === "toUpperCase") { + input.data = input.data.toUpperCase(); + } + else if (check.kind === "startsWith") { + if (!input.data.startsWith(check.value)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: { startsWith: check.value }, + message: check.message, + }); + status.dirty(); + } + } + else if (check.kind === "endsWith") { + if (!input.data.endsWith(check.value)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: { endsWith: check.value }, + message: check.message, + }); + status.dirty(); + } + } + else if (check.kind === "datetime") { + const regex = datetimeRegex(check); + if (!regex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: "datetime", + message: check.message, + }); + status.dirty(); + } + } + else if (check.kind === "date") { + const regex = dateRegex; + if (!regex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: "date", + message: check.message, + }); + status.dirty(); + } + } + else if (check.kind === "time") { + const regex = timeRegex(check); + if (!regex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: "time", + message: check.message, + }); + status.dirty(); + } + } + else if (check.kind === "duration") { + if (!durationRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "duration", + code: ZodIssueCode.invalid_string, + message: check.message, + }); + status.dirty(); + } + } + else if (check.kind === "ip") { + if (!isValidIP(input.data, check.version)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "ip", + code: ZodIssueCode.invalid_string, + message: check.message, + }); + status.dirty(); + } + } + else if (check.kind === "base64") { + if (!base64Regex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "base64", + code: ZodIssueCode.invalid_string, + message: check.message, + }); + status.dirty(); + } + } + else { + util.assertNever(check); + } + } + return { status: status.value, value: input.data }; + } + _regex(regex, validation, message) { + return this.refinement((data) => regex.test(data), { + validation, + code: ZodIssueCode.invalid_string, + ...errorUtil.errToObj(message), + }); + } + _addCheck(check) { + return new ZodString({ + ...this._def, + checks: [...this._def.checks, check], + }); + } + email(message) { + return this._addCheck({ kind: "email", ...errorUtil.errToObj(message) }); + } + url(message) { + return this._addCheck({ kind: "url", ...errorUtil.errToObj(message) }); + } + emoji(message) { + return this._addCheck({ kind: "emoji", ...errorUtil.errToObj(message) }); + } + uuid(message) { + return this._addCheck({ kind: "uuid", ...errorUtil.errToObj(message) }); + } + nanoid(message) { + return this._addCheck({ kind: "nanoid", ...errorUtil.errToObj(message) }); + } + cuid(message) { + return this._addCheck({ kind: "cuid", ...errorUtil.errToObj(message) }); + } + cuid2(message) { + return this._addCheck({ kind: "cuid2", ...errorUtil.errToObj(message) }); + } + ulid(message) { + return this._addCheck({ kind: "ulid", ...errorUtil.errToObj(message) }); + } + base64(message) { + return this._addCheck({ kind: "base64", ...errorUtil.errToObj(message) }); + } + ip(options) { + return this._addCheck({ kind: "ip", ...errorUtil.errToObj(options) }); + } + datetime(options) { + var _a, _b; + if (typeof options === "string") { + return this._addCheck({ + kind: "datetime", + precision: null, + offset: false, + local: false, + message: options, + }); + } + return this._addCheck({ + kind: "datetime", + precision: typeof (options === null || options === void 0 ? void 0 : options.precision) === "undefined" ? null : options === null || options === void 0 ? void 0 : options.precision, + offset: (_a = options === null || options === void 0 ? void 0 : options.offset) !== null && _a !== void 0 ? _a : false, + local: (_b = options === null || options === void 0 ? void 0 : options.local) !== null && _b !== void 0 ? _b : false, + ...errorUtil.errToObj(options === null || options === void 0 ? void 0 : options.message), + }); + } + date(message) { + return this._addCheck({ kind: "date", message }); + } + time(options) { + if (typeof options === "string") { + return this._addCheck({ + kind: "time", + precision: null, + message: options, + }); + } + return this._addCheck({ + kind: "time", + precision: typeof (options === null || options === void 0 ? void 0 : options.precision) === "undefined" ? null : options === null || options === void 0 ? void 0 : options.precision, + ...errorUtil.errToObj(options === null || options === void 0 ? void 0 : options.message), + }); + } + duration(message) { + return this._addCheck({ kind: "duration", ...errorUtil.errToObj(message) }); + } + regex(regex, message) { + return this._addCheck({ + kind: "regex", + regex: regex, + ...errorUtil.errToObj(message), + }); + } + includes(value, options) { + return this._addCheck({ + kind: "includes", + value: value, + position: options === null || options === void 0 ? void 0 : options.position, + ...errorUtil.errToObj(options === null || options === void 0 ? void 0 : options.message), + }); + } + startsWith(value, message) { + return this._addCheck({ + kind: "startsWith", + value: value, + ...errorUtil.errToObj(message), + }); + } + endsWith(value, message) { + return this._addCheck({ + kind: "endsWith", + value: value, + ...errorUtil.errToObj(message), + }); + } + min(minLength, message) { + return this._addCheck({ + kind: "min", + value: minLength, + ...errorUtil.errToObj(message), + }); + } + max(maxLength, message) { + return this._addCheck({ + kind: "max", + value: maxLength, + ...errorUtil.errToObj(message), + }); + } + length(len, message) { + return this._addCheck({ + kind: "length", + value: len, + ...errorUtil.errToObj(message), + }); + } + /** + * @deprecated Use z.string().min(1) instead. + * @see {@link ZodString.min} + */ + nonempty(message) { + return this.min(1, errorUtil.errToObj(message)); + } + trim() { + return new ZodString({ + ...this._def, + checks: [...this._def.checks, { kind: "trim" }], + }); + } + toLowerCase() { + return new ZodString({ + ...this._def, + checks: [...this._def.checks, { kind: "toLowerCase" }], + }); + } + toUpperCase() { + return new ZodString({ + ...this._def, + checks: [...this._def.checks, { kind: "toUpperCase" }], + }); + } + get isDatetime() { + return !!this._def.checks.find((ch) => ch.kind === "datetime"); + } + get isDate() { + return !!this._def.checks.find((ch) => ch.kind === "date"); + } + get isTime() { + return !!this._def.checks.find((ch) => ch.kind === "time"); + } + get isDuration() { + return !!this._def.checks.find((ch) => ch.kind === "duration"); + } + get isEmail() { + return !!this._def.checks.find((ch) => ch.kind === "email"); + } + get isURL() { + return !!this._def.checks.find((ch) => ch.kind === "url"); + } + get isEmoji() { + return !!this._def.checks.find((ch) => ch.kind === "emoji"); + } + get isUUID() { + return !!this._def.checks.find((ch) => ch.kind === "uuid"); + } + get isNANOID() { + return !!this._def.checks.find((ch) => ch.kind === "nanoid"); + } + get isCUID() { + return !!this._def.checks.find((ch) => ch.kind === "cuid"); + } + get isCUID2() { + return !!this._def.checks.find((ch) => ch.kind === "cuid2"); + } + get isULID() { + return !!this._def.checks.find((ch) => ch.kind === "ulid"); + } + get isIP() { + return !!this._def.checks.find((ch) => ch.kind === "ip"); + } + get isBase64() { + return !!this._def.checks.find((ch) => ch.kind === "base64"); + } + get minLength() { + let min = null; + for (const ch of this._def.checks) { + if (ch.kind === "min") { + if (min === null || ch.value > min) + min = ch.value; + } + } + return min; + } + get maxLength() { + let max = null; + for (const ch of this._def.checks) { + if (ch.kind === "max") { + if (max === null || ch.value < max) + max = ch.value; + } + } + return max; + } +} +ZodString.create = (params) => { + var _a; + return new ZodString({ + checks: [], + typeName: ZodFirstPartyTypeKind.ZodString, + coerce: (_a = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a !== void 0 ? _a : false, + ...processCreateParams(params), + }); +}; +// https://stackoverflow.com/questions/3966484/why-does-modulus-operator-return-fractional-number-in-javascript/31711034#31711034 +function floatSafeRemainder(val, step) { + const valDecCount = (val.toString().split(".")[1] || "").length; + const stepDecCount = (step.toString().split(".")[1] || "").length; + const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount; + const valInt = parseInt(val.toFixed(decCount).replace(".", "")); + const stepInt = parseInt(step.toFixed(decCount).replace(".", "")); + return (valInt % stepInt) / Math.pow(10, decCount); +} +class ZodNumber extends ZodType { + constructor() { + super(...arguments); + this.min = this.gte; + this.max = this.lte; + this.step = this.multipleOf; + } + _parse(input) { + if (this._def.coerce) { + input.data = Number(input.data); + } + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.number) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.number, + received: ctx.parsedType, + }); + return INVALID; + } + let ctx = undefined; + const status = new ParseStatus(); + for (const check of this._def.checks) { + if (check.kind === "int") { + if (!util.isInteger(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: "integer", + received: "float", + message: check.message, + }); + status.dirty(); + } + } + else if (check.kind === "min") { + const tooSmall = check.inclusive + ? input.data < check.value + : input.data <= check.value; + if (tooSmall) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: check.value, + type: "number", + inclusive: check.inclusive, + exact: false, + message: check.message, + }); + status.dirty(); + } + } + else if (check.kind === "max") { + const tooBig = check.inclusive + ? input.data > check.value + : input.data >= check.value; + if (tooBig) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: check.value, + type: "number", + inclusive: check.inclusive, + exact: false, + message: check.message, + }); + status.dirty(); + } + } + else if (check.kind === "multipleOf") { + if (floatSafeRemainder(input.data, check.value) !== 0) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.not_multiple_of, + multipleOf: check.value, + message: check.message, + }); + status.dirty(); + } + } + else if (check.kind === "finite") { + if (!Number.isFinite(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.not_finite, + message: check.message, + }); + status.dirty(); + } + } + else { + util.assertNever(check); + } + } + return { status: status.value, value: input.data }; + } + gte(value, message) { + return this.setLimit("min", value, true, errorUtil.toString(message)); + } + gt(value, message) { + return this.setLimit("min", value, false, errorUtil.toString(message)); + } + lte(value, message) { + return this.setLimit("max", value, true, errorUtil.toString(message)); + } + lt(value, message) { + return this.setLimit("max", value, false, errorUtil.toString(message)); + } + setLimit(kind, value, inclusive, message) { + return new ZodNumber({ + ...this._def, + checks: [ + ...this._def.checks, + { + kind, + value, + inclusive, + message: errorUtil.toString(message), + }, + ], + }); + } + _addCheck(check) { + return new ZodNumber({ + ...this._def, + checks: [...this._def.checks, check], + }); + } + int(message) { + return this._addCheck({ + kind: "int", + message: errorUtil.toString(message), + }); + } + positive(message) { + return this._addCheck({ + kind: "min", + value: 0, + inclusive: false, + message: errorUtil.toString(message), + }); + } + negative(message) { + return this._addCheck({ + kind: "max", + value: 0, + inclusive: false, + message: errorUtil.toString(message), + }); + } + nonpositive(message) { + return this._addCheck({ + kind: "max", + value: 0, + inclusive: true, + message: errorUtil.toString(message), + }); + } + nonnegative(message) { + return this._addCheck({ + kind: "min", + value: 0, + inclusive: true, + message: errorUtil.toString(message), + }); + } + multipleOf(value, message) { + return this._addCheck({ + kind: "multipleOf", + value: value, + message: errorUtil.toString(message), + }); + } + finite(message) { + return this._addCheck({ + kind: "finite", + message: errorUtil.toString(message), + }); + } + safe(message) { + return this._addCheck({ + kind: "min", + inclusive: true, + value: Number.MIN_SAFE_INTEGER, + message: errorUtil.toString(message), + })._addCheck({ + kind: "max", + inclusive: true, + value: Number.MAX_SAFE_INTEGER, + message: errorUtil.toString(message), + }); + } + get minValue() { + let min = null; + for (const ch of this._def.checks) { + if (ch.kind === "min") { + if (min === null || ch.value > min) + min = ch.value; + } + } + return min; + } + get maxValue() { + let max = null; + for (const ch of this._def.checks) { + if (ch.kind === "max") { + if (max === null || ch.value < max) + max = ch.value; + } + } + return max; + } + get isInt() { + return !!this._def.checks.find((ch) => ch.kind === "int" || + (ch.kind === "multipleOf" && util.isInteger(ch.value))); + } + get isFinite() { + let max = null, min = null; + for (const ch of this._def.checks) { + if (ch.kind === "finite" || + ch.kind === "int" || + ch.kind === "multipleOf") { + return true; + } + else if (ch.kind === "min") { + if (min === null || ch.value > min) + min = ch.value; + } + else if (ch.kind === "max") { + if (max === null || ch.value < max) + max = ch.value; + } + } + return Number.isFinite(min) && Number.isFinite(max); + } +} +ZodNumber.create = (params) => { + return new ZodNumber({ + checks: [], + typeName: ZodFirstPartyTypeKind.ZodNumber, + coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false, + ...processCreateParams(params), + }); +}; +class ZodBigInt extends ZodType { + constructor() { + super(...arguments); + this.min = this.gte; + this.max = this.lte; + } + _parse(input) { + if (this._def.coerce) { + input.data = BigInt(input.data); + } + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.bigint) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.bigint, + received: ctx.parsedType, + }); + return INVALID; + } + let ctx = undefined; + const status = new ParseStatus(); + for (const check of this._def.checks) { + if (check.kind === "min") { + const tooSmall = check.inclusive + ? input.data < check.value + : input.data <= check.value; + if (tooSmall) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + type: "bigint", + minimum: check.value, + inclusive: check.inclusive, + message: check.message, + }); + status.dirty(); + } + } + else if (check.kind === "max") { + const tooBig = check.inclusive + ? input.data > check.value + : input.data >= check.value; + if (tooBig) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + type: "bigint", + maximum: check.value, + inclusive: check.inclusive, + message: check.message, + }); + status.dirty(); + } + } + else if (check.kind === "multipleOf") { + if (input.data % check.value !== BigInt(0)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.not_multiple_of, + multipleOf: check.value, + message: check.message, + }); + status.dirty(); + } + } + else { + util.assertNever(check); + } + } + return { status: status.value, value: input.data }; + } + gte(value, message) { + return this.setLimit("min", value, true, errorUtil.toString(message)); + } + gt(value, message) { + return this.setLimit("min", value, false, errorUtil.toString(message)); + } + lte(value, message) { + return this.setLimit("max", value, true, errorUtil.toString(message)); + } + lt(value, message) { + return this.setLimit("max", value, false, errorUtil.toString(message)); + } + setLimit(kind, value, inclusive, message) { + return new ZodBigInt({ + ...this._def, + checks: [ + ...this._def.checks, + { + kind, + value, + inclusive, + message: errorUtil.toString(message), + }, + ], + }); + } + _addCheck(check) { + return new ZodBigInt({ + ...this._def, + checks: [...this._def.checks, check], + }); + } + positive(message) { + return this._addCheck({ + kind: "min", + value: BigInt(0), + inclusive: false, + message: errorUtil.toString(message), + }); + } + negative(message) { + return this._addCheck({ + kind: "max", + value: BigInt(0), + inclusive: false, + message: errorUtil.toString(message), + }); + } + nonpositive(message) { + return this._addCheck({ + kind: "max", + value: BigInt(0), + inclusive: true, + message: errorUtil.toString(message), + }); + } + nonnegative(message) { + return this._addCheck({ + kind: "min", + value: BigInt(0), + inclusive: true, + message: errorUtil.toString(message), + }); + } + multipleOf(value, message) { + return this._addCheck({ + kind: "multipleOf", + value, + message: errorUtil.toString(message), + }); + } + get minValue() { + let min = null; + for (const ch of this._def.checks) { + if (ch.kind === "min") { + if (min === null || ch.value > min) + min = ch.value; + } + } + return min; + } + get maxValue() { + let max = null; + for (const ch of this._def.checks) { + if (ch.kind === "max") { + if (max === null || ch.value < max) + max = ch.value; + } + } + return max; + } +} +ZodBigInt.create = (params) => { + var _a; + return new ZodBigInt({ + checks: [], + typeName: ZodFirstPartyTypeKind.ZodBigInt, + coerce: (_a = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a !== void 0 ? _a : false, + ...processCreateParams(params), + }); +}; +class ZodBoolean extends ZodType { + _parse(input) { + if (this._def.coerce) { + input.data = Boolean(input.data); + } + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.boolean) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.boolean, + received: ctx.parsedType, + }); + return INVALID; + } + return OK(input.data); + } +} +ZodBoolean.create = (params) => { + return new ZodBoolean({ + typeName: ZodFirstPartyTypeKind.ZodBoolean, + coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false, + ...processCreateParams(params), + }); +}; +class ZodDate extends ZodType { + _parse(input) { + if (this._def.coerce) { + input.data = new Date(input.data); + } + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.date) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.date, + received: ctx.parsedType, + }); + return INVALID; + } + if (isNaN(input.data.getTime())) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_date, + }); + return INVALID; + } + const status = new ParseStatus(); + let ctx = undefined; + for (const check of this._def.checks) { + if (check.kind === "min") { + if (input.data.getTime() < check.value) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + message: check.message, + inclusive: true, + exact: false, + minimum: check.value, + type: "date", + }); + status.dirty(); + } + } + else if (check.kind === "max") { + if (input.data.getTime() > check.value) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + message: check.message, + inclusive: true, + exact: false, + maximum: check.value, + type: "date", + }); + status.dirty(); + } + } + else { + util.assertNever(check); + } + } + return { + status: status.value, + value: new Date(input.data.getTime()), + }; + } + _addCheck(check) { + return new ZodDate({ + ...this._def, + checks: [...this._def.checks, check], + }); + } + min(minDate, message) { + return this._addCheck({ + kind: "min", + value: minDate.getTime(), + message: errorUtil.toString(message), + }); + } + max(maxDate, message) { + return this._addCheck({ + kind: "max", + value: maxDate.getTime(), + message: errorUtil.toString(message), + }); + } + get minDate() { + let min = null; + for (const ch of this._def.checks) { + if (ch.kind === "min") { + if (min === null || ch.value > min) + min = ch.value; + } + } + return min != null ? new Date(min) : null; + } + get maxDate() { + let max = null; + for (const ch of this._def.checks) { + if (ch.kind === "max") { + if (max === null || ch.value < max) + max = ch.value; + } + } + return max != null ? new Date(max) : null; + } +} +ZodDate.create = (params) => { + return new ZodDate({ + checks: [], + coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false, + typeName: ZodFirstPartyTypeKind.ZodDate, + ...processCreateParams(params), + }); +}; +class ZodSymbol extends ZodType { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.symbol) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.symbol, + received: ctx.parsedType, + }); + return INVALID; + } + return OK(input.data); + } +} +ZodSymbol.create = (params) => { + return new ZodSymbol({ + typeName: ZodFirstPartyTypeKind.ZodSymbol, + ...processCreateParams(params), + }); +}; +class ZodUndefined extends ZodType { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.undefined) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.undefined, + received: ctx.parsedType, + }); + return INVALID; + } + return OK(input.data); + } +} +ZodUndefined.create = (params) => { + return new ZodUndefined({ + typeName: ZodFirstPartyTypeKind.ZodUndefined, + ...processCreateParams(params), + }); +}; +class ZodNull extends ZodType { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.null) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.null, + received: ctx.parsedType, + }); + return INVALID; + } + return OK(input.data); + } +} +ZodNull.create = (params) => { + return new ZodNull({ + typeName: ZodFirstPartyTypeKind.ZodNull, + ...processCreateParams(params), + }); +}; +class ZodAny extends ZodType { + constructor() { + super(...arguments); + // to prevent instances of other classes from extending ZodAny. this causes issues with catchall in ZodObject. + this._any = true; + } + _parse(input) { + return OK(input.data); + } +} +ZodAny.create = (params) => { + return new ZodAny({ + typeName: ZodFirstPartyTypeKind.ZodAny, + ...processCreateParams(params), + }); +}; +class ZodUnknown extends ZodType { + constructor() { + super(...arguments); + // required + this._unknown = true; + } + _parse(input) { + return OK(input.data); + } +} +ZodUnknown.create = (params) => { + return new ZodUnknown({ + typeName: ZodFirstPartyTypeKind.ZodUnknown, + ...processCreateParams(params), + }); +}; +class ZodNever extends ZodType { + _parse(input) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.never, + received: ctx.parsedType, + }); + return INVALID; + } +} +ZodNever.create = (params) => { + return new ZodNever({ + typeName: ZodFirstPartyTypeKind.ZodNever, + ...processCreateParams(params), + }); +}; +class ZodVoid extends ZodType { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.undefined) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.void, + received: ctx.parsedType, + }); + return INVALID; + } + return OK(input.data); + } +} +ZodVoid.create = (params) => { + return new ZodVoid({ + typeName: ZodFirstPartyTypeKind.ZodVoid, + ...processCreateParams(params), + }); +}; +class ZodArray extends ZodType { + _parse(input) { + const { ctx, status } = this._processInputParams(input); + const def = this._def; + if (ctx.parsedType !== ZodParsedType.array) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.array, + received: ctx.parsedType, + }); + return INVALID; + } + if (def.exactLength !== null) { + const tooBig = ctx.data.length > def.exactLength.value; + const tooSmall = ctx.data.length < def.exactLength.value; + if (tooBig || tooSmall) { + addIssueToContext(ctx, { + code: tooBig ? ZodIssueCode.too_big : ZodIssueCode.too_small, + minimum: (tooSmall ? def.exactLength.value : undefined), + maximum: (tooBig ? def.exactLength.value : undefined), + type: "array", + inclusive: true, + exact: true, + message: def.exactLength.message, + }); + status.dirty(); + } + } + if (def.minLength !== null) { + if (ctx.data.length < def.minLength.value) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: def.minLength.value, + type: "array", + inclusive: true, + exact: false, + message: def.minLength.message, + }); + status.dirty(); + } + } + if (def.maxLength !== null) { + if (ctx.data.length > def.maxLength.value) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: def.maxLength.value, + type: "array", + inclusive: true, + exact: false, + message: def.maxLength.message, + }); + status.dirty(); + } + } + if (ctx.common.async) { + return Promise.all([...ctx.data].map((item, i) => { + return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i)); + })).then((result) => { + return ParseStatus.mergeArray(status, result); + }); + } + const result = [...ctx.data].map((item, i) => { + return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i)); + }); + return ParseStatus.mergeArray(status, result); + } + get element() { + return this._def.type; + } + min(minLength, message) { + return new ZodArray({ + ...this._def, + minLength: { value: minLength, message: errorUtil.toString(message) }, + }); + } + max(maxLength, message) { + return new ZodArray({ + ...this._def, + maxLength: { value: maxLength, message: errorUtil.toString(message) }, + }); + } + length(len, message) { + return new ZodArray({ + ...this._def, + exactLength: { value: len, message: errorUtil.toString(message) }, + }); + } + nonempty(message) { + return this.min(1, message); + } +} +ZodArray.create = (schema, params) => { + return new ZodArray({ + type: schema, + minLength: null, + maxLength: null, + exactLength: null, + typeName: ZodFirstPartyTypeKind.ZodArray, + ...processCreateParams(params), + }); +}; +function deepPartialify(schema) { + if (schema instanceof ZodObject) { + const newShape = {}; + for (const key in schema.shape) { + const fieldSchema = schema.shape[key]; + newShape[key] = ZodOptional.create(deepPartialify(fieldSchema)); + } + return new ZodObject({ + ...schema._def, + shape: () => newShape, + }); + } + else if (schema instanceof ZodArray) { + return new ZodArray({ + ...schema._def, + type: deepPartialify(schema.element), + }); + } + else if (schema instanceof ZodOptional) { + return ZodOptional.create(deepPartialify(schema.unwrap())); + } + else if (schema instanceof ZodNullable) { + return ZodNullable.create(deepPartialify(schema.unwrap())); + } + else if (schema instanceof ZodTuple) { + return ZodTuple.create(schema.items.map((item) => deepPartialify(item))); + } + else { + return schema; + } +} +class ZodObject extends ZodType { + constructor() { + super(...arguments); + this._cached = null; + /** + * @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped. + * If you want to pass through unknown properties, use `.passthrough()` instead. + */ + this.nonstrict = this.passthrough; + // extend< + // Augmentation extends ZodRawShape, + // NewOutput extends util.flatten<{ + // [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation + // ? Augmentation[k]["_output"] + // : k extends keyof Output + // ? Output[k] + // : never; + // }>, + // NewInput extends util.flatten<{ + // [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation + // ? Augmentation[k]["_input"] + // : k extends keyof Input + // ? Input[k] + // : never; + // }> + // >( + // augmentation: Augmentation + // ): ZodObject< + // extendShape, + // UnknownKeys, + // Catchall, + // NewOutput, + // NewInput + // > { + // return new ZodObject({ + // ...this._def, + // shape: () => ({ + // ...this._def.shape(), + // ...augmentation, + // }), + // }) as any; + // } + /** + * @deprecated Use `.extend` instead + * */ + this.augment = this.extend; + } + _getCached() { + if (this._cached !== null) + return this._cached; + const shape = this._def.shape(); + const keys = util.objectKeys(shape); + return (this._cached = { shape, keys }); + } + _parse(input) { + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.object) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.object, + received: ctx.parsedType, + }); + return INVALID; + } + const { status, ctx } = this._processInputParams(input); + const { shape, keys: shapeKeys } = this._getCached(); + const extraKeys = []; + if (!(this._def.catchall instanceof ZodNever && + this._def.unknownKeys === "strip")) { + for (const key in ctx.data) { + if (!shapeKeys.includes(key)) { + extraKeys.push(key); + } + } + } + const pairs = []; + for (const key of shapeKeys) { + const keyValidator = shape[key]; + const value = ctx.data[key]; + pairs.push({ + key: { status: "valid", value: key }, + value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)), + alwaysSet: key in ctx.data, + }); + } + if (this._def.catchall instanceof ZodNever) { + const unknownKeys = this._def.unknownKeys; + if (unknownKeys === "passthrough") { + for (const key of extraKeys) { + pairs.push({ + key: { status: "valid", value: key }, + value: { status: "valid", value: ctx.data[key] }, + }); + } + } + else if (unknownKeys === "strict") { + if (extraKeys.length > 0) { + addIssueToContext(ctx, { + code: ZodIssueCode.unrecognized_keys, + keys: extraKeys, + }); + status.dirty(); + } + } + else if (unknownKeys === "strip") ; + else { + throw new Error(`Internal ZodObject error: invalid unknownKeys value.`); + } + } + else { + // run catchall validation + const catchall = this._def.catchall; + for (const key of extraKeys) { + const value = ctx.data[key]; + pairs.push({ + key: { status: "valid", value: key }, + value: catchall._parse(new ParseInputLazyPath(ctx, value, ctx.path, key) //, ctx.child(key), value, getParsedType(value) + ), + alwaysSet: key in ctx.data, + }); + } + } + if (ctx.common.async) { + return Promise.resolve() + .then(async () => { + const syncPairs = []; + for (const pair of pairs) { + const key = await pair.key; + const value = await pair.value; + syncPairs.push({ + key, + value, + alwaysSet: pair.alwaysSet, + }); + } + return syncPairs; + }) + .then((syncPairs) => { + return ParseStatus.mergeObjectSync(status, syncPairs); + }); + } + else { + return ParseStatus.mergeObjectSync(status, pairs); + } + } + get shape() { + return this._def.shape(); + } + strict(message) { + errorUtil.errToObj; + return new ZodObject({ + ...this._def, + unknownKeys: "strict", + ...(message !== undefined + ? { + errorMap: (issue, ctx) => { + var _a, _b, _c, _d; + const defaultError = (_c = (_b = (_a = this._def).errorMap) === null || _b === void 0 ? void 0 : _b.call(_a, issue, ctx).message) !== null && _c !== void 0 ? _c : ctx.defaultError; + if (issue.code === "unrecognized_keys") + return { + message: (_d = errorUtil.errToObj(message).message) !== null && _d !== void 0 ? _d : defaultError, + }; + return { + message: defaultError, + }; + }, + } + : {}), + }); + } + strip() { + return new ZodObject({ + ...this._def, + unknownKeys: "strip", + }); + } + passthrough() { + return new ZodObject({ + ...this._def, + unknownKeys: "passthrough", + }); + } + // const AugmentFactory = + // (def: Def) => + // ( + // augmentation: Augmentation + // ): ZodObject< + // extendShape, Augmentation>, + // Def["unknownKeys"], + // Def["catchall"] + // > => { + // return new ZodObject({ + // ...def, + // shape: () => ({ + // ...def.shape(), + // ...augmentation, + // }), + // }) as any; + // }; + extend(augmentation) { + return new ZodObject({ + ...this._def, + shape: () => ({ + ...this._def.shape(), + ...augmentation, + }), + }); + } + /** + * Prior to zod@1.0.12 there was a bug in the + * inferred type of merged objects. Please + * upgrade if you are experiencing issues. + */ + merge(merging) { + const merged = new ZodObject({ + unknownKeys: merging._def.unknownKeys, + catchall: merging._def.catchall, + shape: () => ({ + ...this._def.shape(), + ...merging._def.shape(), + }), + typeName: ZodFirstPartyTypeKind.ZodObject, + }); + return merged; + } + // merge< + // Incoming extends AnyZodObject, + // Augmentation extends Incoming["shape"], + // NewOutput extends { + // [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation + // ? Augmentation[k]["_output"] + // : k extends keyof Output + // ? Output[k] + // : never; + // }, + // NewInput extends { + // [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation + // ? Augmentation[k]["_input"] + // : k extends keyof Input + // ? Input[k] + // : never; + // } + // >( + // merging: Incoming + // ): ZodObject< + // extendShape>, + // Incoming["_def"]["unknownKeys"], + // Incoming["_def"]["catchall"], + // NewOutput, + // NewInput + // > { + // const merged: any = new ZodObject({ + // unknownKeys: merging._def.unknownKeys, + // catchall: merging._def.catchall, + // shape: () => + // objectUtil.mergeShapes(this._def.shape(), merging._def.shape()), + // typeName: ZodFirstPartyTypeKind.ZodObject, + // }) as any; + // return merged; + // } + setKey(key, schema) { + return this.augment({ [key]: schema }); + } + // merge( + // merging: Incoming + // ): //ZodObject = (merging) => { + // ZodObject< + // extendShape>, + // Incoming["_def"]["unknownKeys"], + // Incoming["_def"]["catchall"] + // > { + // // const mergedShape = objectUtil.mergeShapes( + // // this._def.shape(), + // // merging._def.shape() + // // ); + // const merged: any = new ZodObject({ + // unknownKeys: merging._def.unknownKeys, + // catchall: merging._def.catchall, + // shape: () => + // objectUtil.mergeShapes(this._def.shape(), merging._def.shape()), + // typeName: ZodFirstPartyTypeKind.ZodObject, + // }) as any; + // return merged; + // } + catchall(index) { + return new ZodObject({ + ...this._def, + catchall: index, + }); + } + pick(mask) { + const shape = {}; + util.objectKeys(mask).forEach((key) => { + if (mask[key] && this.shape[key]) { + shape[key] = this.shape[key]; + } + }); + return new ZodObject({ + ...this._def, + shape: () => shape, + }); + } + omit(mask) { + const shape = {}; + util.objectKeys(this.shape).forEach((key) => { + if (!mask[key]) { + shape[key] = this.shape[key]; + } + }); + return new ZodObject({ + ...this._def, + shape: () => shape, + }); + } + /** + * @deprecated + */ + deepPartial() { + return deepPartialify(this); + } + partial(mask) { + const newShape = {}; + util.objectKeys(this.shape).forEach((key) => { + const fieldSchema = this.shape[key]; + if (mask && !mask[key]) { + newShape[key] = fieldSchema; + } + else { + newShape[key] = fieldSchema.optional(); + } + }); + return new ZodObject({ + ...this._def, + shape: () => newShape, + }); + } + required(mask) { + const newShape = {}; + util.objectKeys(this.shape).forEach((key) => { + if (mask && !mask[key]) { + newShape[key] = this.shape[key]; + } + else { + const fieldSchema = this.shape[key]; + let newField = fieldSchema; + while (newField instanceof ZodOptional) { + newField = newField._def.innerType; + } + newShape[key] = newField; + } + }); + return new ZodObject({ + ...this._def, + shape: () => newShape, + }); + } + keyof() { + return createZodEnum(util.objectKeys(this.shape)); + } +} +ZodObject.create = (shape, params) => { + return new ZodObject({ + shape: () => shape, + unknownKeys: "strip", + catchall: ZodNever.create(), + typeName: ZodFirstPartyTypeKind.ZodObject, + ...processCreateParams(params), + }); +}; +ZodObject.strictCreate = (shape, params) => { + return new ZodObject({ + shape: () => shape, + unknownKeys: "strict", + catchall: ZodNever.create(), + typeName: ZodFirstPartyTypeKind.ZodObject, + ...processCreateParams(params), + }); +}; +ZodObject.lazycreate = (shape, params) => { + return new ZodObject({ + shape, + unknownKeys: "strip", + catchall: ZodNever.create(), + typeName: ZodFirstPartyTypeKind.ZodObject, + ...processCreateParams(params), + }); +}; +class ZodUnion extends ZodType { + _parse(input) { + const { ctx } = this._processInputParams(input); + const options = this._def.options; + function handleResults(results) { + // return first issue-free validation if it exists + for (const result of results) { + if (result.result.status === "valid") { + return result.result; + } + } + for (const result of results) { + if (result.result.status === "dirty") { + // add issues from dirty option + ctx.common.issues.push(...result.ctx.common.issues); + return result.result; + } + } + // return invalid + const unionErrors = results.map((result) => new ZodError(result.ctx.common.issues)); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_union, + unionErrors, + }); + return INVALID; + } + if (ctx.common.async) { + return Promise.all(options.map(async (option) => { + const childCtx = { + ...ctx, + common: { + ...ctx.common, + issues: [], + }, + parent: null, + }; + return { + result: await option._parseAsync({ + data: ctx.data, + path: ctx.path, + parent: childCtx, + }), + ctx: childCtx, + }; + })).then(handleResults); + } + else { + let dirty = undefined; + const issues = []; + for (const option of options) { + const childCtx = { + ...ctx, + common: { + ...ctx.common, + issues: [], + }, + parent: null, + }; + const result = option._parseSync({ + data: ctx.data, + path: ctx.path, + parent: childCtx, + }); + if (result.status === "valid") { + return result; + } + else if (result.status === "dirty" && !dirty) { + dirty = { result, ctx: childCtx }; + } + if (childCtx.common.issues.length) { + issues.push(childCtx.common.issues); + } + } + if (dirty) { + ctx.common.issues.push(...dirty.ctx.common.issues); + return dirty.result; + } + const unionErrors = issues.map((issues) => new ZodError(issues)); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_union, + unionErrors, + }); + return INVALID; + } + } + get options() { + return this._def.options; + } +} +ZodUnion.create = (types, params) => { + return new ZodUnion({ + options: types, + typeName: ZodFirstPartyTypeKind.ZodUnion, + ...processCreateParams(params), + }); +}; +///////////////////////////////////////////////////// +///////////////////////////////////////////////////// +////////// ////////// +////////// ZodDiscriminatedUnion ////////// +////////// ////////// +///////////////////////////////////////////////////// +///////////////////////////////////////////////////// +const getDiscriminator = (type) => { + if (type instanceof ZodLazy) { + return getDiscriminator(type.schema); + } + else if (type instanceof ZodEffects) { + return getDiscriminator(type.innerType()); + } + else if (type instanceof ZodLiteral) { + return [type.value]; + } + else if (type instanceof ZodEnum) { + return type.options; + } + else if (type instanceof ZodNativeEnum) { + // eslint-disable-next-line ban/ban + return util.objectValues(type.enum); + } + else if (type instanceof ZodDefault) { + return getDiscriminator(type._def.innerType); + } + else if (type instanceof ZodUndefined) { + return [undefined]; + } + else if (type instanceof ZodNull) { + return [null]; + } + else if (type instanceof ZodOptional) { + return [undefined, ...getDiscriminator(type.unwrap())]; + } + else if (type instanceof ZodNullable) { + return [null, ...getDiscriminator(type.unwrap())]; + } + else if (type instanceof ZodBranded) { + return getDiscriminator(type.unwrap()); + } + else if (type instanceof ZodReadonly) { + return getDiscriminator(type.unwrap()); + } + else if (type instanceof ZodCatch) { + return getDiscriminator(type._def.innerType); + } + else { + return []; + } +}; +class ZodDiscriminatedUnion extends ZodType { + _parse(input) { + const { ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.object) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.object, + received: ctx.parsedType, + }); + return INVALID; + } + const discriminator = this.discriminator; + const discriminatorValue = ctx.data[discriminator]; + const option = this.optionsMap.get(discriminatorValue); + if (!option) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_union_discriminator, + options: Array.from(this.optionsMap.keys()), + path: [discriminator], + }); + return INVALID; + } + if (ctx.common.async) { + return option._parseAsync({ + data: ctx.data, + path: ctx.path, + parent: ctx, + }); + } + else { + return option._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx, + }); + } + } + get discriminator() { + return this._def.discriminator; + } + get options() { + return this._def.options; + } + get optionsMap() { + return this._def.optionsMap; + } + /** + * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor. + * However, it only allows a union of objects, all of which need to share a discriminator property. This property must + * have a different value for each object in the union. + * @param discriminator the name of the discriminator property + * @param types an array of object schemas + * @param params + */ + static create(discriminator, options, params) { + // Get all the valid discriminator values + const optionsMap = new Map(); + // try { + for (const type of options) { + const discriminatorValues = getDiscriminator(type.shape[discriminator]); + if (!discriminatorValues.length) { + throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`); + } + for (const value of discriminatorValues) { + if (optionsMap.has(value)) { + throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`); + } + optionsMap.set(value, type); + } + } + return new ZodDiscriminatedUnion({ + typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion, + discriminator, + options, + optionsMap, + ...processCreateParams(params), + }); + } +} +function mergeValues(a, b) { + const aType = getParsedType(a); + const bType = getParsedType(b); + if (a === b) { + return { valid: true, data: a }; + } + else if (aType === ZodParsedType.object && bType === ZodParsedType.object) { + const bKeys = util.objectKeys(b); + const sharedKeys = util + .objectKeys(a) + .filter((key) => bKeys.indexOf(key) !== -1); + const newObj = { ...a, ...b }; + for (const key of sharedKeys) { + const sharedValue = mergeValues(a[key], b[key]); + if (!sharedValue.valid) { + return { valid: false }; + } + newObj[key] = sharedValue.data; + } + return { valid: true, data: newObj }; + } + else if (aType === ZodParsedType.array && bType === ZodParsedType.array) { + if (a.length !== b.length) { + return { valid: false }; + } + const newArray = []; + for (let index = 0; index < a.length; index++) { + const itemA = a[index]; + const itemB = b[index]; + const sharedValue = mergeValues(itemA, itemB); + if (!sharedValue.valid) { + return { valid: false }; + } + newArray.push(sharedValue.data); + } + return { valid: true, data: newArray }; + } + else if (aType === ZodParsedType.date && + bType === ZodParsedType.date && + +a === +b) { + return { valid: true, data: a }; + } + else { + return { valid: false }; + } +} +class ZodIntersection extends ZodType { + _parse(input) { + const { status, ctx } = this._processInputParams(input); + const handleParsed = (parsedLeft, parsedRight) => { + if (isAborted(parsedLeft) || isAborted(parsedRight)) { + return INVALID; + } + const merged = mergeValues(parsedLeft.value, parsedRight.value); + if (!merged.valid) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_intersection_types, + }); + return INVALID; + } + if (isDirty(parsedLeft) || isDirty(parsedRight)) { + status.dirty(); + } + return { status: status.value, value: merged.data }; + }; + if (ctx.common.async) { + return Promise.all([ + this._def.left._parseAsync({ + data: ctx.data, + path: ctx.path, + parent: ctx, + }), + this._def.right._parseAsync({ + data: ctx.data, + path: ctx.path, + parent: ctx, + }), + ]).then(([left, right]) => handleParsed(left, right)); + } + else { + return handleParsed(this._def.left._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx, + }), this._def.right._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx, + })); + } + } +} +ZodIntersection.create = (left, right, params) => { + return new ZodIntersection({ + left: left, + right: right, + typeName: ZodFirstPartyTypeKind.ZodIntersection, + ...processCreateParams(params), + }); +}; +class ZodTuple extends ZodType { + _parse(input) { + const { status, ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.array) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.array, + received: ctx.parsedType, + }); + return INVALID; + } + if (ctx.data.length < this._def.items.length) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: this._def.items.length, + inclusive: true, + exact: false, + type: "array", + }); + return INVALID; + } + const rest = this._def.rest; + if (!rest && ctx.data.length > this._def.items.length) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: this._def.items.length, + inclusive: true, + exact: false, + type: "array", + }); + status.dirty(); + } + const items = [...ctx.data] + .map((item, itemIndex) => { + const schema = this._def.items[itemIndex] || this._def.rest; + if (!schema) + return null; + return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex)); + }) + .filter((x) => !!x); // filter nulls + if (ctx.common.async) { + return Promise.all(items).then((results) => { + return ParseStatus.mergeArray(status, results); + }); + } + else { + return ParseStatus.mergeArray(status, items); + } + } + get items() { + return this._def.items; + } + rest(rest) { + return new ZodTuple({ + ...this._def, + rest, + }); + } +} +ZodTuple.create = (schemas, params) => { + if (!Array.isArray(schemas)) { + throw new Error("You must pass an array of schemas to z.tuple([ ... ])"); + } + return new ZodTuple({ + items: schemas, + typeName: ZodFirstPartyTypeKind.ZodTuple, + rest: null, + ...processCreateParams(params), + }); +}; +class ZodRecord extends ZodType { + get keySchema() { + return this._def.keyType; + } + get valueSchema() { + return this._def.valueType; + } + _parse(input) { + const { status, ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.object) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.object, + received: ctx.parsedType, + }); + return INVALID; + } + const pairs = []; + const keyType = this._def.keyType; + const valueType = this._def.valueType; + for (const key in ctx.data) { + pairs.push({ + key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)), + value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)), + alwaysSet: key in ctx.data, + }); + } + if (ctx.common.async) { + return ParseStatus.mergeObjectAsync(status, pairs); + } + else { + return ParseStatus.mergeObjectSync(status, pairs); + } + } + get element() { + return this._def.valueType; + } + static create(first, second, third) { + if (second instanceof ZodType) { + return new ZodRecord({ + keyType: first, + valueType: second, + typeName: ZodFirstPartyTypeKind.ZodRecord, + ...processCreateParams(third), + }); + } + return new ZodRecord({ + keyType: ZodString.create(), + valueType: first, + typeName: ZodFirstPartyTypeKind.ZodRecord, + ...processCreateParams(second), + }); + } +} +class ZodMap extends ZodType { + get keySchema() { + return this._def.keyType; + } + get valueSchema() { + return this._def.valueType; + } + _parse(input) { + const { status, ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.map) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.map, + received: ctx.parsedType, + }); + return INVALID; + } + const keyType = this._def.keyType; + const valueType = this._def.valueType; + const pairs = [...ctx.data.entries()].map(([key, value], index) => { + return { + key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, "key"])), + value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"])), + }; + }); + if (ctx.common.async) { + const finalMap = new Map(); + return Promise.resolve().then(async () => { + for (const pair of pairs) { + const key = await pair.key; + const value = await pair.value; + if (key.status === "aborted" || value.status === "aborted") { + return INVALID; + } + if (key.status === "dirty" || value.status === "dirty") { + status.dirty(); + } + finalMap.set(key.value, value.value); + } + return { status: status.value, value: finalMap }; + }); + } + else { + const finalMap = new Map(); + for (const pair of pairs) { + const key = pair.key; + const value = pair.value; + if (key.status === "aborted" || value.status === "aborted") { + return INVALID; + } + if (key.status === "dirty" || value.status === "dirty") { + status.dirty(); + } + finalMap.set(key.value, value.value); + } + return { status: status.value, value: finalMap }; + } + } +} +ZodMap.create = (keyType, valueType, params) => { + return new ZodMap({ + valueType, + keyType, + typeName: ZodFirstPartyTypeKind.ZodMap, + ...processCreateParams(params), + }); +}; +class ZodSet extends ZodType { + _parse(input) { + const { status, ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.set) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.set, + received: ctx.parsedType, + }); + return INVALID; + } + const def = this._def; + if (def.minSize !== null) { + if (ctx.data.size < def.minSize.value) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: def.minSize.value, + type: "set", + inclusive: true, + exact: false, + message: def.minSize.message, + }); + status.dirty(); + } + } + if (def.maxSize !== null) { + if (ctx.data.size > def.maxSize.value) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: def.maxSize.value, + type: "set", + inclusive: true, + exact: false, + message: def.maxSize.message, + }); + status.dirty(); + } + } + const valueType = this._def.valueType; + function finalizeSet(elements) { + const parsedSet = new Set(); + for (const element of elements) { + if (element.status === "aborted") + return INVALID; + if (element.status === "dirty") + status.dirty(); + parsedSet.add(element.value); + } + return { status: status.value, value: parsedSet }; + } + const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i))); + if (ctx.common.async) { + return Promise.all(elements).then((elements) => finalizeSet(elements)); + } + else { + return finalizeSet(elements); + } + } + min(minSize, message) { + return new ZodSet({ + ...this._def, + minSize: { value: minSize, message: errorUtil.toString(message) }, + }); + } + max(maxSize, message) { + return new ZodSet({ + ...this._def, + maxSize: { value: maxSize, message: errorUtil.toString(message) }, + }); + } + size(size, message) { + return this.min(size, message).max(size, message); + } + nonempty(message) { + return this.min(1, message); + } +} +ZodSet.create = (valueType, params) => { + return new ZodSet({ + valueType, + minSize: null, + maxSize: null, + typeName: ZodFirstPartyTypeKind.ZodSet, + ...processCreateParams(params), + }); +}; +class ZodFunction extends ZodType { + constructor() { + super(...arguments); + this.validate = this.implement; + } + _parse(input) { + const { ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.function) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.function, + received: ctx.parsedType, + }); + return INVALID; + } + function makeArgsIssue(args, error) { + return makeIssue({ + data: args, + path: ctx.path, + errorMaps: [ + ctx.common.contextualErrorMap, + ctx.schemaErrorMap, + getErrorMap(), + errorMap, + ].filter((x) => !!x), + issueData: { + code: ZodIssueCode.invalid_arguments, + argumentsError: error, + }, + }); + } + function makeReturnsIssue(returns, error) { + return makeIssue({ + data: returns, + path: ctx.path, + errorMaps: [ + ctx.common.contextualErrorMap, + ctx.schemaErrorMap, + getErrorMap(), + errorMap, + ].filter((x) => !!x), + issueData: { + code: ZodIssueCode.invalid_return_type, + returnTypeError: error, + }, + }); + } + const params = { errorMap: ctx.common.contextualErrorMap }; + const fn = ctx.data; + if (this._def.returns instanceof ZodPromise) { + // Would love a way to avoid disabling this rule, but we need + // an alias (using an arrow function was what caused 2651). + // eslint-disable-next-line @typescript-eslint/no-this-alias + const me = this; + return OK(async function (...args) { + const error = new ZodError([]); + const parsedArgs = await me._def.args + .parseAsync(args, params) + .catch((e) => { + error.addIssue(makeArgsIssue(args, e)); + throw error; + }); + const result = await Reflect.apply(fn, this, parsedArgs); + const parsedReturns = await me._def.returns._def.type + .parseAsync(result, params) + .catch((e) => { + error.addIssue(makeReturnsIssue(result, e)); + throw error; + }); + return parsedReturns; + }); + } + else { + // Would love a way to avoid disabling this rule, but we need + // an alias (using an arrow function was what caused 2651). + // eslint-disable-next-line @typescript-eslint/no-this-alias + const me = this; + return OK(function (...args) { + const parsedArgs = me._def.args.safeParse(args, params); + if (!parsedArgs.success) { + throw new ZodError([makeArgsIssue(args, parsedArgs.error)]); + } + const result = Reflect.apply(fn, this, parsedArgs.data); + const parsedReturns = me._def.returns.safeParse(result, params); + if (!parsedReturns.success) { + throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]); + } + return parsedReturns.data; + }); + } + } + parameters() { + return this._def.args; + } + returnType() { + return this._def.returns; + } + args(...items) { + return new ZodFunction({ + ...this._def, + args: ZodTuple.create(items).rest(ZodUnknown.create()), + }); + } + returns(returnType) { + return new ZodFunction({ + ...this._def, + returns: returnType, + }); + } + implement(func) { + const validatedFunc = this.parse(func); + return validatedFunc; + } + strictImplement(func) { + const validatedFunc = this.parse(func); + return validatedFunc; + } + static create(args, returns, params) { + return new ZodFunction({ + args: (args + ? args + : ZodTuple.create([]).rest(ZodUnknown.create())), + returns: returns || ZodUnknown.create(), + typeName: ZodFirstPartyTypeKind.ZodFunction, + ...processCreateParams(params), + }); + } +} +class ZodLazy extends ZodType { + get schema() { + return this._def.getter(); + } + _parse(input) { + const { ctx } = this._processInputParams(input); + const lazySchema = this._def.getter(); + return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx }); + } +} +ZodLazy.create = (getter, params) => { + return new ZodLazy({ + getter: getter, + typeName: ZodFirstPartyTypeKind.ZodLazy, + ...processCreateParams(params), + }); +}; +class ZodLiteral extends ZodType { + _parse(input) { + if (input.data !== this._def.value) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + received: ctx.data, + code: ZodIssueCode.invalid_literal, + expected: this._def.value, + }); + return INVALID; + } + return { status: "valid", value: input.data }; + } + get value() { + return this._def.value; + } +} +ZodLiteral.create = (value, params) => { + return new ZodLiteral({ + value: value, + typeName: ZodFirstPartyTypeKind.ZodLiteral, + ...processCreateParams(params), + }); +}; +function createZodEnum(values, params) { + return new ZodEnum({ + values, + typeName: ZodFirstPartyTypeKind.ZodEnum, + ...processCreateParams(params), + }); +} +class ZodEnum extends ZodType { + constructor() { + super(...arguments); + _ZodEnum_cache.set(this, void 0); + } + _parse(input) { + if (typeof input.data !== "string") { + const ctx = this._getOrReturnCtx(input); + const expectedValues = this._def.values; + addIssueToContext(ctx, { + expected: util.joinValues(expectedValues), + received: ctx.parsedType, + code: ZodIssueCode.invalid_type, + }); + return INVALID; + } + if (!__classPrivateFieldGet(this, _ZodEnum_cache, "f")) { + __classPrivateFieldSet(this, _ZodEnum_cache, new Set(this._def.values), "f"); + } + if (!__classPrivateFieldGet(this, _ZodEnum_cache, "f").has(input.data)) { + const ctx = this._getOrReturnCtx(input); + const expectedValues = this._def.values; + addIssueToContext(ctx, { + received: ctx.data, + code: ZodIssueCode.invalid_enum_value, + options: expectedValues, + }); + return INVALID; + } + return OK(input.data); + } + get options() { + return this._def.values; + } + get enum() { + const enumValues = {}; + for (const val of this._def.values) { + enumValues[val] = val; + } + return enumValues; + } + get Values() { + const enumValues = {}; + for (const val of this._def.values) { + enumValues[val] = val; + } + return enumValues; + } + get Enum() { + const enumValues = {}; + for (const val of this._def.values) { + enumValues[val] = val; + } + return enumValues; + } + extract(values, newDef = this._def) { + return ZodEnum.create(values, { + ...this._def, + ...newDef, + }); + } + exclude(values, newDef = this._def) { + return ZodEnum.create(this.options.filter((opt) => !values.includes(opt)), { + ...this._def, + ...newDef, + }); + } +} +_ZodEnum_cache = new WeakMap(); +ZodEnum.create = createZodEnum; +class ZodNativeEnum extends ZodType { + constructor() { + super(...arguments); + _ZodNativeEnum_cache.set(this, void 0); + } + _parse(input) { + const nativeEnumValues = util.getValidEnumValues(this._def.values); + const ctx = this._getOrReturnCtx(input); + if (ctx.parsedType !== ZodParsedType.string && + ctx.parsedType !== ZodParsedType.number) { + const expectedValues = util.objectValues(nativeEnumValues); + addIssueToContext(ctx, { + expected: util.joinValues(expectedValues), + received: ctx.parsedType, + code: ZodIssueCode.invalid_type, + }); + return INVALID; + } + if (!__classPrivateFieldGet(this, _ZodNativeEnum_cache, "f")) { + __classPrivateFieldSet(this, _ZodNativeEnum_cache, new Set(util.getValidEnumValues(this._def.values)), "f"); + } + if (!__classPrivateFieldGet(this, _ZodNativeEnum_cache, "f").has(input.data)) { + const expectedValues = util.objectValues(nativeEnumValues); + addIssueToContext(ctx, { + received: ctx.data, + code: ZodIssueCode.invalid_enum_value, + options: expectedValues, + }); + return INVALID; + } + return OK(input.data); + } + get enum() { + return this._def.values; + } +} +_ZodNativeEnum_cache = new WeakMap(); +ZodNativeEnum.create = (values, params) => { + return new ZodNativeEnum({ + values: values, + typeName: ZodFirstPartyTypeKind.ZodNativeEnum, + ...processCreateParams(params), + }); +}; +class ZodPromise extends ZodType { + unwrap() { + return this._def.type; + } + _parse(input) { + const { ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.promise && + ctx.common.async === false) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.promise, + received: ctx.parsedType, + }); + return INVALID; + } + const promisified = ctx.parsedType === ZodParsedType.promise + ? ctx.data + : Promise.resolve(ctx.data); + return OK(promisified.then((data) => { + return this._def.type.parseAsync(data, { + path: ctx.path, + errorMap: ctx.common.contextualErrorMap, + }); + })); + } +} +ZodPromise.create = (schema, params) => { + return new ZodPromise({ + type: schema, + typeName: ZodFirstPartyTypeKind.ZodPromise, + ...processCreateParams(params), + }); +}; +class ZodEffects extends ZodType { + innerType() { + return this._def.schema; + } + sourceType() { + return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects + ? this._def.schema.sourceType() + : this._def.schema; + } + _parse(input) { + const { status, ctx } = this._processInputParams(input); + const effect = this._def.effect || null; + const checkCtx = { + addIssue: (arg) => { + addIssueToContext(ctx, arg); + if (arg.fatal) { + status.abort(); + } + else { + status.dirty(); + } + }, + get path() { + return ctx.path; + }, + }; + checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx); + if (effect.type === "preprocess") { + const processed = effect.transform(ctx.data, checkCtx); + if (ctx.common.async) { + return Promise.resolve(processed).then(async (processed) => { + if (status.value === "aborted") + return INVALID; + const result = await this._def.schema._parseAsync({ + data: processed, + path: ctx.path, + parent: ctx, + }); + if (result.status === "aborted") + return INVALID; + if (result.status === "dirty") + return DIRTY(result.value); + if (status.value === "dirty") + return DIRTY(result.value); + return result; + }); + } + else { + if (status.value === "aborted") + return INVALID; + const result = this._def.schema._parseSync({ + data: processed, + path: ctx.path, + parent: ctx, + }); + if (result.status === "aborted") + return INVALID; + if (result.status === "dirty") + return DIRTY(result.value); + if (status.value === "dirty") + return DIRTY(result.value); + return result; + } + } + if (effect.type === "refinement") { + const executeRefinement = (acc) => { + const result = effect.refinement(acc, checkCtx); + if (ctx.common.async) { + return Promise.resolve(result); + } + if (result instanceof Promise) { + throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead."); + } + return acc; + }; + if (ctx.common.async === false) { + const inner = this._def.schema._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx, + }); + if (inner.status === "aborted") + return INVALID; + if (inner.status === "dirty") + status.dirty(); + // return value is ignored + executeRefinement(inner.value); + return { status: status.value, value: inner.value }; + } + else { + return this._def.schema + ._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }) + .then((inner) => { + if (inner.status === "aborted") + return INVALID; + if (inner.status === "dirty") + status.dirty(); + return executeRefinement(inner.value).then(() => { + return { status: status.value, value: inner.value }; + }); + }); + } + } + if (effect.type === "transform") { + if (ctx.common.async === false) { + const base = this._def.schema._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx, + }); + if (!isValid(base)) + return base; + const result = effect.transform(base.value, checkCtx); + if (result instanceof Promise) { + throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`); + } + return { status: status.value, value: result }; + } + else { + return this._def.schema + ._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }) + .then((base) => { + if (!isValid(base)) + return base; + return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({ status: status.value, value: result })); + }); + } + } + util.assertNever(effect); + } +} +ZodEffects.create = (schema, effect, params) => { + return new ZodEffects({ + schema, + typeName: ZodFirstPartyTypeKind.ZodEffects, + effect, + ...processCreateParams(params), + }); +}; +ZodEffects.createWithPreprocess = (preprocess, schema, params) => { + return new ZodEffects({ + schema, + effect: { type: "preprocess", transform: preprocess }, + typeName: ZodFirstPartyTypeKind.ZodEffects, + ...processCreateParams(params), + }); +}; +class ZodOptional extends ZodType { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType === ZodParsedType.undefined) { + return OK(undefined); + } + return this._def.innerType._parse(input); + } + unwrap() { + return this._def.innerType; + } +} +ZodOptional.create = (type, params) => { + return new ZodOptional({ + innerType: type, + typeName: ZodFirstPartyTypeKind.ZodOptional, + ...processCreateParams(params), + }); +}; +class ZodNullable extends ZodType { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType === ZodParsedType.null) { + return OK(null); + } + return this._def.innerType._parse(input); + } + unwrap() { + return this._def.innerType; + } +} +ZodNullable.create = (type, params) => { + return new ZodNullable({ + innerType: type, + typeName: ZodFirstPartyTypeKind.ZodNullable, + ...processCreateParams(params), + }); +}; +class ZodDefault extends ZodType { + _parse(input) { + const { ctx } = this._processInputParams(input); + let data = ctx.data; + if (ctx.parsedType === ZodParsedType.undefined) { + data = this._def.defaultValue(); + } + return this._def.innerType._parse({ + data, + path: ctx.path, + parent: ctx, + }); + } + removeDefault() { + return this._def.innerType; + } +} +ZodDefault.create = (type, params) => { + return new ZodDefault({ + innerType: type, + typeName: ZodFirstPartyTypeKind.ZodDefault, + defaultValue: typeof params.default === "function" + ? params.default + : () => params.default, + ...processCreateParams(params), + }); +}; +class ZodCatch extends ZodType { + _parse(input) { + const { ctx } = this._processInputParams(input); + // newCtx is used to not collect issues from inner types in ctx + const newCtx = { + ...ctx, + common: { + ...ctx.common, + issues: [], + }, + }; + const result = this._def.innerType._parse({ + data: newCtx.data, + path: newCtx.path, + parent: { + ...newCtx, + }, + }); + if (isAsync(result)) { + return result.then((result) => { + return { + status: "valid", + value: result.status === "valid" + ? result.value + : this._def.catchValue({ + get error() { + return new ZodError(newCtx.common.issues); + }, + input: newCtx.data, + }), + }; + }); + } + else { + return { + status: "valid", + value: result.status === "valid" + ? result.value + : this._def.catchValue({ + get error() { + return new ZodError(newCtx.common.issues); + }, + input: newCtx.data, + }), + }; + } + } + removeCatch() { + return this._def.innerType; + } +} +ZodCatch.create = (type, params) => { + return new ZodCatch({ + innerType: type, + typeName: ZodFirstPartyTypeKind.ZodCatch, + catchValue: typeof params.catch === "function" ? params.catch : () => params.catch, + ...processCreateParams(params), + }); +}; +class ZodNaN extends ZodType { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.nan) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.nan, + received: ctx.parsedType, + }); + return INVALID; + } + return { status: "valid", value: input.data }; + } +} +ZodNaN.create = (params) => { + return new ZodNaN({ + typeName: ZodFirstPartyTypeKind.ZodNaN, + ...processCreateParams(params), + }); +}; +const BRAND = Symbol("zod_brand"); +class ZodBranded extends ZodType { + _parse(input) { + const { ctx } = this._processInputParams(input); + const data = ctx.data; + return this._def.type._parse({ + data, + path: ctx.path, + parent: ctx, + }); + } + unwrap() { + return this._def.type; + } +} +class ZodPipeline extends ZodType { + _parse(input) { + const { status, ctx } = this._processInputParams(input); + if (ctx.common.async) { + const handleAsync = async () => { + const inResult = await this._def.in._parseAsync({ + data: ctx.data, + path: ctx.path, + parent: ctx, + }); + if (inResult.status === "aborted") + return INVALID; + if (inResult.status === "dirty") { + status.dirty(); + return DIRTY(inResult.value); + } + else { + return this._def.out._parseAsync({ + data: inResult.value, + path: ctx.path, + parent: ctx, + }); + } + }; + return handleAsync(); + } + else { + const inResult = this._def.in._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx, + }); + if (inResult.status === "aborted") + return INVALID; + if (inResult.status === "dirty") { + status.dirty(); + return { + status: "dirty", + value: inResult.value, + }; + } + else { + return this._def.out._parseSync({ + data: inResult.value, + path: ctx.path, + parent: ctx, + }); + } + } + } + static create(a, b) { + return new ZodPipeline({ + in: a, + out: b, + typeName: ZodFirstPartyTypeKind.ZodPipeline, + }); + } +} +class ZodReadonly extends ZodType { + _parse(input) { + const result = this._def.innerType._parse(input); + const freeze = (data) => { + if (isValid(data)) { + data.value = Object.freeze(data.value); + } + return data; + }; + return isAsync(result) + ? result.then((data) => freeze(data)) + : freeze(result); + } + unwrap() { + return this._def.innerType; + } +} +ZodReadonly.create = (type, params) => { + return new ZodReadonly({ + innerType: type, + typeName: ZodFirstPartyTypeKind.ZodReadonly, + ...processCreateParams(params), + }); +}; +function custom(check, params = {}, +/** + * @deprecated + * + * Pass `fatal` into the params object instead: + * + * ```ts + * z.string().custom((val) => val.length > 5, { fatal: false }) + * ``` + * + */ +fatal) { + if (check) + return ZodAny.create().superRefine((data, ctx) => { + var _a, _b; + if (!check(data)) { + const p = typeof params === "function" + ? params(data) + : typeof params === "string" + ? { message: params } + : params; + const _fatal = (_b = (_a = p.fatal) !== null && _a !== void 0 ? _a : fatal) !== null && _b !== void 0 ? _b : true; + const p2 = typeof p === "string" ? { message: p } : p; + ctx.addIssue({ code: "custom", ...p2, fatal: _fatal }); + } + }); + return ZodAny.create(); +} +const late = { + object: ZodObject.lazycreate, +}; +var ZodFirstPartyTypeKind; +(function (ZodFirstPartyTypeKind) { + ZodFirstPartyTypeKind["ZodString"] = "ZodString"; + ZodFirstPartyTypeKind["ZodNumber"] = "ZodNumber"; + ZodFirstPartyTypeKind["ZodNaN"] = "ZodNaN"; + ZodFirstPartyTypeKind["ZodBigInt"] = "ZodBigInt"; + ZodFirstPartyTypeKind["ZodBoolean"] = "ZodBoolean"; + ZodFirstPartyTypeKind["ZodDate"] = "ZodDate"; + ZodFirstPartyTypeKind["ZodSymbol"] = "ZodSymbol"; + ZodFirstPartyTypeKind["ZodUndefined"] = "ZodUndefined"; + ZodFirstPartyTypeKind["ZodNull"] = "ZodNull"; + ZodFirstPartyTypeKind["ZodAny"] = "ZodAny"; + ZodFirstPartyTypeKind["ZodUnknown"] = "ZodUnknown"; + ZodFirstPartyTypeKind["ZodNever"] = "ZodNever"; + ZodFirstPartyTypeKind["ZodVoid"] = "ZodVoid"; + ZodFirstPartyTypeKind["ZodArray"] = "ZodArray"; + ZodFirstPartyTypeKind["ZodObject"] = "ZodObject"; + ZodFirstPartyTypeKind["ZodUnion"] = "ZodUnion"; + ZodFirstPartyTypeKind["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion"; + ZodFirstPartyTypeKind["ZodIntersection"] = "ZodIntersection"; + ZodFirstPartyTypeKind["ZodTuple"] = "ZodTuple"; + ZodFirstPartyTypeKind["ZodRecord"] = "ZodRecord"; + ZodFirstPartyTypeKind["ZodMap"] = "ZodMap"; + ZodFirstPartyTypeKind["ZodSet"] = "ZodSet"; + ZodFirstPartyTypeKind["ZodFunction"] = "ZodFunction"; + ZodFirstPartyTypeKind["ZodLazy"] = "ZodLazy"; + ZodFirstPartyTypeKind["ZodLiteral"] = "ZodLiteral"; + ZodFirstPartyTypeKind["ZodEnum"] = "ZodEnum"; + ZodFirstPartyTypeKind["ZodEffects"] = "ZodEffects"; + ZodFirstPartyTypeKind["ZodNativeEnum"] = "ZodNativeEnum"; + ZodFirstPartyTypeKind["ZodOptional"] = "ZodOptional"; + ZodFirstPartyTypeKind["ZodNullable"] = "ZodNullable"; + ZodFirstPartyTypeKind["ZodDefault"] = "ZodDefault"; + ZodFirstPartyTypeKind["ZodCatch"] = "ZodCatch"; + ZodFirstPartyTypeKind["ZodPromise"] = "ZodPromise"; + ZodFirstPartyTypeKind["ZodBranded"] = "ZodBranded"; + ZodFirstPartyTypeKind["ZodPipeline"] = "ZodPipeline"; + ZodFirstPartyTypeKind["ZodReadonly"] = "ZodReadonly"; +})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {})); +const instanceOfType = ( +// const instanceOfType = any>( +cls, params = { + message: `Input not instance of ${cls.name}`, +}) => custom((data) => data instanceof cls, params); +const stringType = ZodString.create; +const numberType = ZodNumber.create; +const nanType = ZodNaN.create; +const bigIntType = ZodBigInt.create; +const booleanType = ZodBoolean.create; +const dateType = ZodDate.create; +const symbolType = ZodSymbol.create; +const undefinedType = ZodUndefined.create; +const nullType = ZodNull.create; +const anyType = ZodAny.create; +const unknownType = ZodUnknown.create; +const neverType = ZodNever.create; +const voidType = ZodVoid.create; +const arrayType = ZodArray.create; +const objectType = ZodObject.create; +const strictObjectType = ZodObject.strictCreate; +const unionType = ZodUnion.create; +const discriminatedUnionType = ZodDiscriminatedUnion.create; +const intersectionType = ZodIntersection.create; +const tupleType = ZodTuple.create; +const recordType = ZodRecord.create; +const mapType = ZodMap.create; +const setType = ZodSet.create; +const functionType = ZodFunction.create; +const lazyType = ZodLazy.create; +const literalType = ZodLiteral.create; +const enumType = ZodEnum.create; +const nativeEnumType = ZodNativeEnum.create; +const promiseType = ZodPromise.create; +const effectsType = ZodEffects.create; +const optionalType = ZodOptional.create; +const nullableType = ZodNullable.create; +const preprocessType = ZodEffects.createWithPreprocess; +const pipelineType = ZodPipeline.create; +const ostring = () => stringType().optional(); +const onumber = () => numberType().optional(); +const oboolean = () => booleanType().optional(); +const coerce = { + string: ((arg) => ZodString.create({ ...arg, coerce: true })), + number: ((arg) => ZodNumber.create({ ...arg, coerce: true })), + boolean: ((arg) => ZodBoolean.create({ + ...arg, + coerce: true, + })), + bigint: ((arg) => ZodBigInt.create({ ...arg, coerce: true })), + date: ((arg) => ZodDate.create({ ...arg, coerce: true })), +}; +const NEVER = INVALID; + +var z = /*#__PURE__*/Object.freeze({ + __proto__: null, + defaultErrorMap: errorMap, + setErrorMap: setErrorMap, + getErrorMap: getErrorMap, + makeIssue: makeIssue, + EMPTY_PATH: EMPTY_PATH, + addIssueToContext: addIssueToContext, + ParseStatus: ParseStatus, + INVALID: INVALID, + DIRTY: DIRTY, + OK: OK, + isAborted: isAborted, + isDirty: isDirty, + isValid: isValid, + isAsync: isAsync, + get util () { return util; }, + get objectUtil () { return objectUtil; }, + ZodParsedType: ZodParsedType, + getParsedType: getParsedType, + ZodType: ZodType, + datetimeRegex: datetimeRegex, + ZodString: ZodString, + ZodNumber: ZodNumber, + ZodBigInt: ZodBigInt, + ZodBoolean: ZodBoolean, + ZodDate: ZodDate, + ZodSymbol: ZodSymbol, + ZodUndefined: ZodUndefined, + ZodNull: ZodNull, + ZodAny: ZodAny, + ZodUnknown: ZodUnknown, + ZodNever: ZodNever, + ZodVoid: ZodVoid, + ZodArray: ZodArray, + ZodObject: ZodObject, + ZodUnion: ZodUnion, + ZodDiscriminatedUnion: ZodDiscriminatedUnion, + ZodIntersection: ZodIntersection, + ZodTuple: ZodTuple, + ZodRecord: ZodRecord, + ZodMap: ZodMap, + ZodSet: ZodSet, + ZodFunction: ZodFunction, + ZodLazy: ZodLazy, + ZodLiteral: ZodLiteral, + ZodEnum: ZodEnum, + ZodNativeEnum: ZodNativeEnum, + ZodPromise: ZodPromise, + ZodEffects: ZodEffects, + ZodTransformer: ZodEffects, + ZodOptional: ZodOptional, + ZodNullable: ZodNullable, + ZodDefault: ZodDefault, + ZodCatch: ZodCatch, + ZodNaN: ZodNaN, + BRAND: BRAND, + ZodBranded: ZodBranded, + ZodPipeline: ZodPipeline, + ZodReadonly: ZodReadonly, + custom: custom, + Schema: ZodType, + ZodSchema: ZodType, + late: late, + get ZodFirstPartyTypeKind () { return ZodFirstPartyTypeKind; }, + coerce: coerce, + any: anyType, + array: arrayType, + bigint: bigIntType, + boolean: booleanType, + date: dateType, + discriminatedUnion: discriminatedUnionType, + effect: effectsType, + 'enum': enumType, + 'function': functionType, + 'instanceof': instanceOfType, + intersection: intersectionType, + lazy: lazyType, + literal: literalType, + map: mapType, + nan: nanType, + nativeEnum: nativeEnumType, + never: neverType, + 'null': nullType, + nullable: nullableType, + number: numberType, + object: objectType, + oboolean: oboolean, + onumber: onumber, + optional: optionalType, + ostring: ostring, + pipeline: pipelineType, + preprocess: preprocessType, + promise: promiseType, + record: recordType, + set: setType, + strictObject: strictObjectType, + string: stringType, + symbol: symbolType, + transformer: effectsType, + tuple: tupleType, + 'undefined': undefinedType, + union: unionType, + unknown: unknownType, + 'void': voidType, + NEVER: NEVER, + ZodIssueCode: ZodIssueCode, + quotelessJson: quotelessJson, + ZodError: ZodError +}); + + + +// EXTERNAL MODULE: ./node_modules/p-retry/index.js +var p_retry = __webpack_require__(82548); +// EXTERNAL MODULE: ./node_modules/uuid/dist/index.js +var dist = __webpack_require__(75840); +;// CONCATENATED MODULE: ./node_modules/uuid/wrapper.mjs + +const v1 = dist.v1; +const v3 = dist.v3; +const v4 = dist.v4; +const v5 = dist.v5; +const NIL = dist.NIL; +const version = dist.version; +const validate = dist.validate; +const stringify = dist.stringify; +const parse = dist.parse; + +// EXTERNAL MODULE: ./node_modules/@langchain/core/dist/load/serializable.js + 1 modules +var serializable = __webpack_require__(16815); +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/utils/env.js +const isBrowser = () => typeof window !== "undefined" && typeof window.document !== "undefined"; +const isWebWorker = () => typeof globalThis === "object" && + globalThis.constructor && + globalThis.constructor.name === "DedicatedWorkerGlobalScope"; +const isJsDom = () => (typeof window !== "undefined" && window.name === "nodejs") || + (typeof navigator !== "undefined" && + (navigator.userAgent.includes("Node.js") || + navigator.userAgent.includes("jsdom"))); +// Supabase Edge Function provides a `Deno` global object +// without `version` property +const isDeno = () => typeof Deno !== "undefined"; +// Mark not-as-node if in Supabase Edge Function +const isNode = () => typeof process !== "undefined" && + typeof process.versions !== "undefined" && + typeof process.versions.node !== "undefined" && + !isDeno(); +const getEnv = () => { + let env; + if (isBrowser()) { + env = "browser"; + } + else if (isNode()) { + env = "node"; + } + else if (isWebWorker()) { + env = "webworker"; + } + else if (isJsDom()) { + env = "jsdom"; + } + else if (isDeno()) { + env = "deno"; + } + else { + env = "other"; + } + return env; +}; +let runtimeEnvironment; +async function env_getRuntimeEnvironment() { + if (runtimeEnvironment === undefined) { + const env = getEnv(); + runtimeEnvironment = { + library: "langchain-js", + runtime: env, + }; + } + return runtimeEnvironment; +} +function env_getEnvironmentVariable(name) { + // Certain Deno setups will throw an error if you try to access environment variables + // https://github.com/langchain-ai/langchainjs/issues/1412 + try { + return typeof process !== "undefined" + ? // eslint-disable-next-line no-process-env + process.env?.[name] + : undefined; + } + catch (e) { + return undefined; + } +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/callbacks/base.js + + + +/** + * Abstract class that provides a set of optional methods that can be + * overridden in derived classes to handle various events during the + * execution of a LangChain application. + */ +class BaseCallbackHandlerMethodsClass { +} +/** + * Abstract base class for creating callback handlers in the LangChain + * framework. It provides a set of optional methods that can be overridden + * in derived classes to handle various events during the execution of a + * LangChain application. + */ +class BaseCallbackHandler extends BaseCallbackHandlerMethodsClass { + get lc_namespace() { + return ["langchain_core", "callbacks", this.name]; + } + get lc_secrets() { + return undefined; + } + get lc_attributes() { + return undefined; + } + get lc_aliases() { + return undefined; + } + /** + * The name of the serializable. Override to provide an alias or + * to preserve the serialized module name in minified environments. + * + * Implemented as a static method to support loading logic. + */ + static lc_name() { + return this.name; + } + /** + * The final serialized identifier for the module. + */ + get lc_id() { + return [ + ...this.lc_namespace, + (0,serializable/* get_lc_unique_name */.j)(this.constructor), + ]; + } + constructor(input) { + super(); + Object.defineProperty(this, "lc_serializable", { + enumerable: true, + configurable: true, + writable: true, + value: false + }); + Object.defineProperty(this, "lc_kwargs", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "ignoreLLM", { + enumerable: true, + configurable: true, + writable: true, + value: false + }); + Object.defineProperty(this, "ignoreChain", { + enumerable: true, + configurable: true, + writable: true, + value: false + }); + Object.defineProperty(this, "ignoreAgent", { + enumerable: true, + configurable: true, + writable: true, + value: false + }); + Object.defineProperty(this, "ignoreRetriever", { + enumerable: true, + configurable: true, + writable: true, + value: false + }); + Object.defineProperty(this, "raiseError", { + enumerable: true, + configurable: true, + writable: true, + value: false + }); + Object.defineProperty(this, "awaitHandlers", { + enumerable: true, + configurable: true, + writable: true, + value: env_getEnvironmentVariable("LANGCHAIN_CALLBACKS_BACKGROUND") !== "true" + }); + this.lc_kwargs = input || {}; + if (input) { + this.ignoreLLM = input.ignoreLLM ?? this.ignoreLLM; + this.ignoreChain = input.ignoreChain ?? this.ignoreChain; + this.ignoreAgent = input.ignoreAgent ?? this.ignoreAgent; + this.ignoreRetriever = input.ignoreRetriever ?? this.ignoreRetriever; + this.raiseError = input.raiseError ?? this.raiseError; + this.awaitHandlers = + this.raiseError || (input._awaitHandler ?? this.awaitHandlers); + } + } + copy() { + return new this.constructor(this); + } + toJSON() { + return serializable/* Serializable.prototype.toJSON.call */.i.prototype.toJSON.call(this); + } + toJSONNotImplemented() { + return serializable/* Serializable.prototype.toJSONNotImplemented.call */.i.prototype.toJSONNotImplemented.call(this); + } + static fromMethods(methods) { + class Handler extends BaseCallbackHandler { + constructor() { + super(); + Object.defineProperty(this, "name", { + enumerable: true, + configurable: true, + writable: true, + value: v4() + }); + Object.assign(this, methods); + } + } + return new Handler(); + } +} + +// EXTERNAL MODULE: ./node_modules/ansi-styles/index.js +var ansi_styles = __webpack_require__(52068); +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/tracers/base.js + +// eslint-disable-next-line @typescript-eslint/no-explicit-any +function _coerceToDict(value, defaultKey) { + return value && !Array.isArray(value) && typeof value === "object" + ? value + : { [defaultKey]: value }; +} +function stripNonAlphanumeric(input) { + return input.replace(/[-:.]/g, ""); +} +function convertToDottedOrderFormat(epoch, runId, executionOrder) { + const paddedOrder = executionOrder.toFixed(0).slice(0, 3).padStart(3, "0"); + return (stripNonAlphanumeric(`${new Date(epoch).toISOString().slice(0, -1)}${paddedOrder}Z`) + runId); +} +class base_BaseTracer extends BaseCallbackHandler { + constructor(_fields) { + super(...arguments); + Object.defineProperty(this, "runMap", { + enumerable: true, + configurable: true, + writable: true, + value: new Map() + }); + } + copy() { + return this; + } + stringifyError(error) { + // eslint-disable-next-line no-instanceof/no-instanceof + if (error instanceof Error) { + return error.message + (error?.stack ? `\n\n${error.stack}` : ""); + } + if (typeof error === "string") { + return error; + } + return `${error}`; + } + _addChildRun(parentRun, childRun) { + parentRun.child_runs.push(childRun); + } + async _startTrace(run) { + const currentDottedOrder = convertToDottedOrderFormat(run.start_time, run.id, run.execution_order); + const storedRun = { ...run }; + if (storedRun.parent_run_id !== undefined) { + const parentRun = this.runMap.get(storedRun.parent_run_id); + if (parentRun) { + this._addChildRun(parentRun, storedRun); + parentRun.child_execution_order = Math.max(parentRun.child_execution_order, storedRun.child_execution_order); + storedRun.trace_id = parentRun.trace_id; + if (parentRun.dotted_order !== undefined) { + storedRun.dotted_order = [ + parentRun.dotted_order, + currentDottedOrder, + ].join("."); + } + else { + // This can happen naturally for callbacks added within a run + // console.debug(`Parent run with UUID ${storedRun.parent_run_id} has no dotted order.`); + } + } + else { + // This can happen naturally for callbacks added within a run + // console.debug( + // `Parent run with UUID ${storedRun.parent_run_id} not found.` + // ); + } + } + else { + storedRun.trace_id = storedRun.id; + storedRun.dotted_order = currentDottedOrder; + } + this.runMap.set(storedRun.id, storedRun); + await this.onRunCreate?.(storedRun); + } + async _endTrace(run) { + const parentRun = run.parent_run_id !== undefined && this.runMap.get(run.parent_run_id); + if (parentRun) { + parentRun.child_execution_order = Math.max(parentRun.child_execution_order, run.child_execution_order); + } + else { + await this.persistRun(run); + } + this.runMap.delete(run.id); + await this.onRunUpdate?.(run); + } + _getExecutionOrder(parentRunId) { + const parentRun = parentRunId !== undefined && this.runMap.get(parentRunId); + // If a run has no parent then execution order is 1 + if (!parentRun) { + return 1; + } + return parentRun.child_execution_order + 1; + } + async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name) { + const execution_order = this._getExecutionOrder(parentRunId); + const start_time = Date.now(); + const finalExtraParams = metadata + ? { ...extraParams, metadata } + : extraParams; + const run = { + id: runId, + name: name ?? llm.id[llm.id.length - 1], + parent_run_id: parentRunId, + start_time, + serialized: llm, + events: [ + { + name: "start", + time: new Date(start_time).toISOString(), + }, + ], + inputs: { prompts }, + execution_order, + child_runs: [], + child_execution_order: execution_order, + run_type: "llm", + extra: finalExtraParams ?? {}, + tags: tags || [], + }; + await this._startTrace(run); + await this.onLLMStart?.(run); + return run; + } + async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name) { + const execution_order = this._getExecutionOrder(parentRunId); + const start_time = Date.now(); + const finalExtraParams = metadata + ? { ...extraParams, metadata } + : extraParams; + const run = { + id: runId, + name: name ?? llm.id[llm.id.length - 1], + parent_run_id: parentRunId, + start_time, + serialized: llm, + events: [ + { + name: "start", + time: new Date(start_time).toISOString(), + }, + ], + inputs: { messages }, + execution_order, + child_runs: [], + child_execution_order: execution_order, + run_type: "llm", + extra: finalExtraParams ?? {}, + tags: tags || [], + }; + await this._startTrace(run); + await this.onLLMStart?.(run); + return run; + } + async handleLLMEnd(output, runId) { + const run = this.runMap.get(runId); + if (!run || run?.run_type !== "llm") { + throw new Error("No LLM run to end."); + } + run.end_time = Date.now(); + run.outputs = output; + run.events.push({ + name: "end", + time: new Date(run.end_time).toISOString(), + }); + await this.onLLMEnd?.(run); + await this._endTrace(run); + return run; + } + async handleLLMError(error, runId) { + const run = this.runMap.get(runId); + if (!run || run?.run_type !== "llm") { + throw new Error("No LLM run to end."); + } + run.end_time = Date.now(); + run.error = this.stringifyError(error); + run.events.push({ + name: "error", + time: new Date(run.end_time).toISOString(), + }); + await this.onLLMError?.(run); + await this._endTrace(run); + return run; + } + async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name) { + const execution_order = this._getExecutionOrder(parentRunId); + const start_time = Date.now(); + const run = { + id: runId, + name: name ?? chain.id[chain.id.length - 1], + parent_run_id: parentRunId, + start_time, + serialized: chain, + events: [ + { + name: "start", + time: new Date(start_time).toISOString(), + }, + ], + inputs, + execution_order, + child_execution_order: execution_order, + run_type: runType ?? "chain", + child_runs: [], + extra: metadata ? { metadata } : {}, + tags: tags || [], + }; + await this._startTrace(run); + await this.onChainStart?.(run); + return run; + } + async handleChainEnd(outputs, runId, _parentRunId, _tags, kwargs) { + const run = this.runMap.get(runId); + if (!run) { + throw new Error("No chain run to end."); + } + run.end_time = Date.now(); + run.outputs = _coerceToDict(outputs, "output"); + run.events.push({ + name: "end", + time: new Date(run.end_time).toISOString(), + }); + if (kwargs?.inputs !== undefined) { + run.inputs = _coerceToDict(kwargs.inputs, "input"); + } + await this.onChainEnd?.(run); + await this._endTrace(run); + return run; + } + async handleChainError(error, runId, _parentRunId, _tags, kwargs) { + const run = this.runMap.get(runId); + if (!run) { + throw new Error("No chain run to end."); + } + run.end_time = Date.now(); + run.error = this.stringifyError(error); + run.events.push({ + name: "error", + time: new Date(run.end_time).toISOString(), + }); + if (kwargs?.inputs !== undefined) { + run.inputs = _coerceToDict(kwargs.inputs, "input"); + } + await this.onChainError?.(run); + await this._endTrace(run); + return run; + } + async handleToolStart(tool, input, runId, parentRunId, tags, metadata, name) { + const execution_order = this._getExecutionOrder(parentRunId); + const start_time = Date.now(); + const run = { + id: runId, + name: name ?? tool.id[tool.id.length - 1], + parent_run_id: parentRunId, + start_time, + serialized: tool, + events: [ + { + name: "start", + time: new Date(start_time).toISOString(), + }, + ], + inputs: { input }, + execution_order, + child_execution_order: execution_order, + run_type: "tool", + child_runs: [], + extra: metadata ? { metadata } : {}, + tags: tags || [], + }; + await this._startTrace(run); + await this.onToolStart?.(run); + return run; + } + async handleToolEnd(output, runId) { + const run = this.runMap.get(runId); + if (!run || run?.run_type !== "tool") { + throw new Error("No tool run to end"); + } + run.end_time = Date.now(); + run.outputs = { output }; + run.events.push({ + name: "end", + time: new Date(run.end_time).toISOString(), + }); + await this.onToolEnd?.(run); + await this._endTrace(run); + return run; + } + async handleToolError(error, runId) { + const run = this.runMap.get(runId); + if (!run || run?.run_type !== "tool") { + throw new Error("No tool run to end"); + } + run.end_time = Date.now(); + run.error = this.stringifyError(error); + run.events.push({ + name: "error", + time: new Date(run.end_time).toISOString(), + }); + await this.onToolError?.(run); + await this._endTrace(run); + return run; + } + async handleAgentAction(action, runId) { + const run = this.runMap.get(runId); + if (!run || run?.run_type !== "chain") { + return; + } + const agentRun = run; + agentRun.actions = agentRun.actions || []; + agentRun.actions.push(action); + agentRun.events.push({ + name: "agent_action", + time: new Date().toISOString(), + kwargs: { action }, + }); + await this.onAgentAction?.(run); + } + async handleAgentEnd(action, runId) { + const run = this.runMap.get(runId); + if (!run || run?.run_type !== "chain") { + return; + } + run.events.push({ + name: "agent_end", + time: new Date().toISOString(), + kwargs: { action }, + }); + await this.onAgentEnd?.(run); + } + async handleRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name) { + const execution_order = this._getExecutionOrder(parentRunId); + const start_time = Date.now(); + const run = { + id: runId, + name: name ?? retriever.id[retriever.id.length - 1], + parent_run_id: parentRunId, + start_time, + serialized: retriever, + events: [ + { + name: "start", + time: new Date(start_time).toISOString(), + }, + ], + inputs: { query }, + execution_order, + child_execution_order: execution_order, + run_type: "retriever", + child_runs: [], + extra: metadata ? { metadata } : {}, + tags: tags || [], + }; + await this._startTrace(run); + await this.onRetrieverStart?.(run); + return run; + } + async handleRetrieverEnd(documents, runId) { + const run = this.runMap.get(runId); + if (!run || run?.run_type !== "retriever") { + throw new Error("No retriever run to end"); + } + run.end_time = Date.now(); + run.outputs = { documents }; + run.events.push({ + name: "end", + time: new Date(run.end_time).toISOString(), + }); + await this.onRetrieverEnd?.(run); + await this._endTrace(run); + return run; + } + async handleRetrieverError(error, runId) { + const run = this.runMap.get(runId); + if (!run || run?.run_type !== "retriever") { + throw new Error("No retriever run to end"); + } + run.end_time = Date.now(); + run.error = this.stringifyError(error); + run.events.push({ + name: "error", + time: new Date(run.end_time).toISOString(), + }); + await this.onRetrieverError?.(run); + await this._endTrace(run); + return run; + } + async handleText(text, runId) { + const run = this.runMap.get(runId); + if (!run || run?.run_type !== "chain") { + return; + } + run.events.push({ + name: "text", + time: new Date().toISOString(), + kwargs: { text }, + }); + await this.onText?.(run); + } + async handleLLMNewToken(token, idx, runId, _parentRunId, _tags, fields) { + const run = this.runMap.get(runId); + if (!run || run?.run_type !== "llm") { + throw new Error(`Invalid "runId" provided to "handleLLMNewToken" callback.`); + } + run.events.push({ + name: "new_token", + time: new Date().toISOString(), + kwargs: { token, idx, chunk: fields?.chunk }, + }); + await this.onLLMNewToken?.(run, token, { chunk: fields?.chunk }); + return run; + } +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/tracers/console.js + + +function wrap(style, text) { + return `${style.open}${text}${style.close}`; +} +function tryJsonStringify(obj, fallback) { + try { + return JSON.stringify(obj, null, 2); + } + catch (err) { + return fallback; + } +} +function elapsed(run) { + if (!run.end_time) + return ""; + const elapsed = run.end_time - run.start_time; + if (elapsed < 1000) { + return `${elapsed}ms`; + } + return `${(elapsed / 1000).toFixed(2)}s`; +} +const { color } = ansi_styles; +/** + * A tracer that logs all events to the console. It extends from the + * `BaseTracer` class and overrides its methods to provide custom logging + * functionality. + * @example + * ```typescript + * + * const llm = new ChatAnthropic({ + * temperature: 0, + * tags: ["example", "callbacks", "constructor"], + * callbacks: [new ConsoleCallbackHandler()], + * }); + * + * ``` + */ +class ConsoleCallbackHandler extends base_BaseTracer { + constructor() { + super(...arguments); + Object.defineProperty(this, "name", { + enumerable: true, + configurable: true, + writable: true, + value: "console_callback_handler" + }); + } + /** + * Method used to persist the run. In this case, it simply returns a + * resolved promise as there's no persistence logic. + * @param _run The run to persist. + * @returns A resolved promise. + */ + persistRun(_run) { + return Promise.resolve(); + } + // utility methods + /** + * Method used to get all the parent runs of a given run. + * @param run The run whose parents are to be retrieved. + * @returns An array of parent runs. + */ + getParents(run) { + const parents = []; + let currentRun = run; + while (currentRun.parent_run_id) { + const parent = this.runMap.get(currentRun.parent_run_id); + if (parent) { + parents.push(parent); + currentRun = parent; + } + else { + break; + } + } + return parents; + } + /** + * Method used to get a string representation of the run's lineage, which + * is used in logging. + * @param run The run whose lineage is to be retrieved. + * @returns A string representation of the run's lineage. + */ + getBreadcrumbs(run) { + const parents = this.getParents(run).reverse(); + const string = [...parents, run] + .map((parent, i, arr) => { + const name = `${parent.execution_order}:${parent.run_type}:${parent.name}`; + return i === arr.length - 1 ? wrap(ansi_styles.bold, name) : name; + }) + .join(" > "); + return wrap(color.grey, string); + } + // logging methods + /** + * Method used to log the start of a chain run. + * @param run The chain run that has started. + * @returns void + */ + onChainStart(run) { + const crumbs = this.getBreadcrumbs(run); + console.log(`${wrap(color.green, "[chain/start]")} [${crumbs}] Entering Chain run with input: ${tryJsonStringify(run.inputs, "[inputs]")}`); + } + /** + * Method used to log the end of a chain run. + * @param run The chain run that has ended. + * @returns void + */ + onChainEnd(run) { + const crumbs = this.getBreadcrumbs(run); + console.log(`${wrap(color.cyan, "[chain/end]")} [${crumbs}] [${elapsed(run)}] Exiting Chain run with output: ${tryJsonStringify(run.outputs, "[outputs]")}`); + } + /** + * Method used to log any errors of a chain run. + * @param run The chain run that has errored. + * @returns void + */ + onChainError(run) { + const crumbs = this.getBreadcrumbs(run); + console.log(`${wrap(color.red, "[chain/error]")} [${crumbs}] [${elapsed(run)}] Chain run errored with error: ${tryJsonStringify(run.error, "[error]")}`); + } + /** + * Method used to log the start of an LLM run. + * @param run The LLM run that has started. + * @returns void + */ + onLLMStart(run) { + const crumbs = this.getBreadcrumbs(run); + const inputs = "prompts" in run.inputs + ? { prompts: run.inputs.prompts.map((p) => p.trim()) } + : run.inputs; + console.log(`${wrap(color.green, "[llm/start]")} [${crumbs}] Entering LLM run with input: ${tryJsonStringify(inputs, "[inputs]")}`); + } + /** + * Method used to log the end of an LLM run. + * @param run The LLM run that has ended. + * @returns void + */ + onLLMEnd(run) { + const crumbs = this.getBreadcrumbs(run); + console.log(`${wrap(color.cyan, "[llm/end]")} [${crumbs}] [${elapsed(run)}] Exiting LLM run with output: ${tryJsonStringify(run.outputs, "[response]")}`); + } + /** + * Method used to log any errors of an LLM run. + * @param run The LLM run that has errored. + * @returns void + */ + onLLMError(run) { + const crumbs = this.getBreadcrumbs(run); + console.log(`${wrap(color.red, "[llm/error]")} [${crumbs}] [${elapsed(run)}] LLM run errored with error: ${tryJsonStringify(run.error, "[error]")}`); + } + /** + * Method used to log the start of a tool run. + * @param run The tool run that has started. + * @returns void + */ + onToolStart(run) { + const crumbs = this.getBreadcrumbs(run); + console.log(`${wrap(color.green, "[tool/start]")} [${crumbs}] Entering Tool run with input: "${run.inputs.input?.trim()}"`); + } + /** + * Method used to log the end of a tool run. + * @param run The tool run that has ended. + * @returns void + */ + onToolEnd(run) { + const crumbs = this.getBreadcrumbs(run); + console.log(`${wrap(color.cyan, "[tool/end]")} [${crumbs}] [${elapsed(run)}] Exiting Tool run with output: "${run.outputs?.output?.trim()}"`); + } + /** + * Method used to log any errors of a tool run. + * @param run The tool run that has errored. + * @returns void + */ + onToolError(run) { + const crumbs = this.getBreadcrumbs(run); + console.log(`${wrap(color.red, "[tool/error]")} [${crumbs}] [${elapsed(run)}] Tool run errored with error: ${tryJsonStringify(run.error, "[error]")}`); + } + /** + * Method used to log the start of a retriever run. + * @param run The retriever run that has started. + * @returns void + */ + onRetrieverStart(run) { + const crumbs = this.getBreadcrumbs(run); + console.log(`${wrap(color.green, "[retriever/start]")} [${crumbs}] Entering Retriever run with input: ${tryJsonStringify(run.inputs, "[inputs]")}`); + } + /** + * Method used to log the end of a retriever run. + * @param run The retriever run that has ended. + * @returns void + */ + onRetrieverEnd(run) { + const crumbs = this.getBreadcrumbs(run); + console.log(`${wrap(color.cyan, "[retriever/end]")} [${crumbs}] [${elapsed(run)}] Exiting Retriever run with output: ${tryJsonStringify(run.outputs, "[outputs]")}`); + } + /** + * Method used to log any errors of a retriever run. + * @param run The retriever run that has errored. + * @returns void + */ + onRetrieverError(run) { + const crumbs = this.getBreadcrumbs(run); + console.log(`${wrap(color.red, "[retriever/error]")} [${crumbs}] [${elapsed(run)}] Retriever run errored with error: ${tryJsonStringify(run.error, "[error]")}`); + } + /** + * Method used to log the action selected by the agent. + * @param run The run in which the agent action occurred. + * @returns void + */ + onAgentAction(run) { + const agentRun = run; + const crumbs = this.getBreadcrumbs(run); + console.log(`${wrap(color.blue, "[agent/action]")} [${crumbs}] Agent selected action: ${tryJsonStringify(agentRun.actions[agentRun.actions.length - 1], "[action]")}`); + } +} + +// EXTERNAL MODULE: ./node_modules/p-queue/dist/index.js +var p_queue_dist = __webpack_require__(28983); +;// CONCATENATED MODULE: ./node_modules/langsmith/dist/utils/async_caller.js + + +const STATUS_NO_RETRY = [ + 400, // Bad Request + 401, // Unauthorized + 403, // Forbidden + 404, // Not Found + 405, // Method Not Allowed + 406, // Not Acceptable + 407, // Proxy Authentication Required + 408, // Request Timeout +]; +const STATUS_IGNORE = [ + 409, // Conflict +]; +/** + * A class that can be used to make async calls with concurrency and retry logic. + * + * This is useful for making calls to any kind of "expensive" external resource, + * be it because it's rate-limited, subject to network issues, etc. + * + * Concurrent calls are limited by the `maxConcurrency` parameter, which defaults + * to `Infinity`. This means that by default, all calls will be made in parallel. + * + * Retries are limited by the `maxRetries` parameter, which defaults to 6. This + * means that by default, each call will be retried up to 6 times, with an + * exponential backoff between each attempt. + */ +class AsyncCaller { + constructor(params) { + Object.defineProperty(this, "maxConcurrency", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "maxRetries", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "queue", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "onFailedResponseHook", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.maxConcurrency = params.maxConcurrency ?? Infinity; + this.maxRetries = params.maxRetries ?? 6; + if ( true) { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + this.queue = new p_queue_dist["default"]({ + concurrency: this.maxConcurrency, + }); + } + else { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + this.queue = new p_queue_dist({ concurrency: this.maxConcurrency }); + } + this.onFailedResponseHook = params?.onFailedResponseHook; + } + // eslint-disable-next-line @typescript-eslint/no-explicit-any + call(callable, ...args) { + const onFailedResponseHook = this.onFailedResponseHook; + return this.queue.add(() => p_retry(() => callable(...args).catch((error) => { + // eslint-disable-next-line no-instanceof/no-instanceof + if (error instanceof Error) { + throw error; + } + else { + throw new Error(error); + } + }), { + async onFailedAttempt(error) { + if (error.message.startsWith("Cancel") || + error.message.startsWith("TimeoutError") || + error.message.startsWith("AbortError")) { + throw error; + } + // eslint-disable-next-line @typescript-eslint/no-explicit-any + if (error?.code === "ECONNABORTED") { + throw error; + } + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const response = error?.response; + const status = response?.status; + if (status) { + if (STATUS_NO_RETRY.includes(+status)) { + throw error; + } + else if (STATUS_IGNORE.includes(+status)) { + return; + } + if (onFailedResponseHook) { + await onFailedResponseHook(response); + } + } + }, + // If needed we can change some of the defaults here, + // but they're quite sensible. + retries: this.maxRetries, + randomize: true, + }), { throwOnTimeout: true }); + } + // eslint-disable-next-line @typescript-eslint/no-explicit-any + callWithOptions(options, callable, ...args) { + // Note this doesn't cancel the underlying request, + // when available prefer to use the signal option of the underlying call + if (options.signal) { + return Promise.race([ + this.call(callable, ...args), + new Promise((_, reject) => { + options.signal?.addEventListener("abort", () => { + reject(new Error("AbortError")); + }); + }), + ]); + } + return this.call(callable, ...args); + } + fetch(...args) { + return this.call(() => fetch(...args).then((res) => (res.ok ? res : Promise.reject(res)))); + } +} + +;// CONCATENATED MODULE: ./node_modules/langsmith/dist/utils/messages.js +function isLangChainMessage( +// eslint-disable-next-line @typescript-eslint/no-explicit-any +message) { + return typeof message?._getType === "function"; +} +function convertLangChainMessageToExample(message) { + const converted = { + type: message._getType(), + data: { content: message.content }, + }; + // Check for presence of keys in additional_kwargs + if (message?.additional_kwargs && + Object.keys(message.additional_kwargs).length > 0) { + converted.data.additional_kwargs = { ...message.additional_kwargs }; + } + return converted; +} + +;// CONCATENATED MODULE: ./node_modules/langsmith/dist/utils/env.js +// Inlined from https://github.com/flexdinesh/browser-or-node + +let globalEnv; +const env_isBrowser = () => typeof window !== "undefined" && typeof window.document !== "undefined"; +const env_isWebWorker = () => typeof globalThis === "object" && + globalThis.constructor && + globalThis.constructor.name === "DedicatedWorkerGlobalScope"; +const env_isJsDom = () => (typeof window !== "undefined" && window.name === "nodejs") || + (typeof navigator !== "undefined" && + (navigator.userAgent.includes("Node.js") || + navigator.userAgent.includes("jsdom"))); +// Supabase Edge Function provides a `Deno` global object +// without `version` property +const env_isDeno = () => typeof Deno !== "undefined"; +// Mark not-as-node if in Supabase Edge Function +const env_isNode = () => typeof process !== "undefined" && + typeof process.versions !== "undefined" && + typeof process.versions.node !== "undefined" && + !env_isDeno(); +const env_getEnv = () => { + if (globalEnv) { + return globalEnv; + } + if (env_isBrowser()) { + globalEnv = "browser"; + } + else if (env_isNode()) { + globalEnv = "node"; + } + else if (env_isWebWorker()) { + globalEnv = "webworker"; + } + else if (env_isJsDom()) { + globalEnv = "jsdom"; + } + else if (env_isDeno()) { + globalEnv = "deno"; + } + else { + globalEnv = "other"; + } + return globalEnv; +}; +let env_runtimeEnvironment; +async function utils_env_getRuntimeEnvironment() { + if (env_runtimeEnvironment === undefined) { + const env = env_getEnv(); + const releaseEnv = getShas(); + env_runtimeEnvironment = { + library: "langsmith", + runtime: env, + sdk: "langsmith-js", + sdk_version: __version__, + ...releaseEnv, + }; + } + return env_runtimeEnvironment; +} +/** + * Retrieves the LangChain-specific environment variables from the current runtime environment. + * Sensitive keys (containing the word "key", "token", or "secret") have their values redacted for security. + * + * @returns {Record} + * - A record of LangChain-specific environment variables. + */ +function getLangChainEnvVars() { + const allEnvVars = getEnvironmentVariables() || {}; + const envVars = {}; + for (const [key, value] of Object.entries(allEnvVars)) { + if (key.startsWith("LANGCHAIN_") && typeof value === "string") { + envVars[key] = value; + } + } + for (const key in envVars) { + if ((key.toLowerCase().includes("key") || + key.toLowerCase().includes("secret") || + key.toLowerCase().includes("token")) && + typeof envVars[key] === "string") { + const value = envVars[key]; + envVars[key] = + value.slice(0, 2) + "*".repeat(value.length - 4) + value.slice(-2); + } + } + return envVars; +} +/** + * Retrieves the LangChain-specific metadata from the current runtime environment. + * + * @returns {Record} + * - A record of LangChain-specific metadata environment variables. + */ +function getLangChainEnvVarsMetadata() { + const allEnvVars = getEnvironmentVariables() || {}; + const envVars = {}; + const excluded = [ + "LANGCHAIN_API_KEY", + "LANGCHAIN_ENDPOINT", + "LANGCHAIN_TRACING_V2", + "LANGCHAIN_PROJECT", + "LANGCHAIN_SESSION", + ]; + for (const [key, value] of Object.entries(allEnvVars)) { + if (key.startsWith("LANGCHAIN_") && + typeof value === "string" && + !excluded.includes(key) && + !key.toLowerCase().includes("key") && + !key.toLowerCase().includes("secret") && + !key.toLowerCase().includes("token")) { + if (key === "LANGCHAIN_REVISION_ID") { + envVars["revision_id"] = value; + } + else { + envVars[key] = value; + } + } + } + return envVars; +} +/** + * Retrieves the environment variables from the current runtime environment. + * + * This function is designed to operate in a variety of JS environments, + * including Node.js, Deno, browsers, etc. + * + * @returns {Record | undefined} + * - A record of environment variables if available. + * - `undefined` if the environment does not support or allows access to environment variables. + */ +function getEnvironmentVariables() { + try { + // Check for Node.js environment + // eslint-disable-next-line no-process-env + if (typeof process !== "undefined" && process.env) { + // eslint-disable-next-line no-process-env + return Object.entries(process.env).reduce((acc, [key, value]) => { + acc[key] = String(value); + return acc; + }, {}); + } + // For browsers and other environments, we may not have direct access to env variables + // Return undefined or any other fallback as required. + return undefined; + } + catch (e) { + // Catch any errors that might occur while trying to access environment variables + return undefined; + } +} +function utils_env_getEnvironmentVariable(name) { + // Certain Deno setups will throw an error if you try to access environment variables + // https://github.com/hwchase17/langchainjs/issues/1412 + try { + return typeof process !== "undefined" + ? // eslint-disable-next-line no-process-env + process.env?.[name] + : undefined; + } + catch (e) { + return undefined; + } +} +function setEnvironmentVariable(name, value) { + if (typeof process !== "undefined") { + // eslint-disable-next-line no-process-env + process.env[name] = value; + } +} +let cachedCommitSHAs; +/** + * Get the Git commit SHA from common environment variables + * used by different CI/CD platforms. + * @returns {string | undefined} The Git commit SHA or undefined if not found. + */ +function getShas() { + if (cachedCommitSHAs !== undefined) { + return cachedCommitSHAs; + } + const common_release_envs = [ + "VERCEL_GIT_COMMIT_SHA", + "NEXT_PUBLIC_VERCEL_GIT_COMMIT_SHA", + "COMMIT_REF", + "RENDER_GIT_COMMIT", + "CI_COMMIT_SHA", + "CIRCLE_SHA1", + "CF_PAGES_COMMIT_SHA", + "REACT_APP_GIT_SHA", + "SOURCE_VERSION", + "GITHUB_SHA", + "TRAVIS_COMMIT", + "GIT_COMMIT", + "BUILD_VCS_NUMBER", + "bamboo_planRepository_revision", + "Build.SourceVersion", + "BITBUCKET_COMMIT", + "DRONE_COMMIT_SHA", + "SEMAPHORE_GIT_SHA", + "BUILDKITE_COMMIT", + ]; + const shas = {}; + for (const env of common_release_envs) { + const envVar = utils_env_getEnvironmentVariable(env); + if (envVar !== undefined) { + shas[env] = envVar; + } + } + cachedCommitSHAs = shas; + return shas; +} + +;// CONCATENATED MODULE: ./node_modules/langsmith/dist/utils/_uuid.js + +function assertUuid(str) { + if (!validate(str)) { + throw new Error(`Invalid UUID: ${str}`); + } +} + +;// CONCATENATED MODULE: ./node_modules/langsmith/dist/client.js + + + + + + +async function mergeRuntimeEnvIntoRunCreates(runs) { + const runtimeEnv = await utils_env_getRuntimeEnvironment(); + const envVars = getLangChainEnvVarsMetadata(); + return runs.map((run) => { + const extra = run.extra ?? {}; + const metadata = extra.metadata; + run.extra = { + ...extra, + runtime: { + ...runtimeEnv, + ...extra?.runtime, + }, + metadata: { + ...envVars, + ...(envVars.revision_id || run.revision_id + ? { revision_id: run.revision_id ?? envVars.revision_id } + : {}), + ...metadata, + }, + }; + return run; + }); +} +const getTracingSamplingRate = () => { + const samplingRateStr = utils_env_getEnvironmentVariable("LANGCHAIN_TRACING_SAMPLING_RATE"); + if (samplingRateStr === undefined) { + return undefined; + } + const samplingRate = parseFloat(samplingRateStr); + if (samplingRate < 0 || samplingRate > 1) { + throw new Error(`LANGCHAIN_TRACING_SAMPLING_RATE must be between 0 and 1 if set. Got: ${samplingRate}`); + } + return samplingRate; +}; +// utility functions +const isLocalhost = (url) => { + const strippedUrl = url.replace("http://", "").replace("https://", ""); + const hostname = strippedUrl.split("/")[0].split(":")[0]; + return (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1"); +}; +const raiseForStatus = async (response, operation) => { + // consume the response body to release the connection + // https://undici.nodejs.org/#/?id=garbage-collection + const body = await response.text(); + if (!response.ok) { + throw new Error(`Failed to ${operation}: ${response.status} ${response.statusText} ${body}`); + } +}; +async function toArray(iterable) { + const result = []; + for await (const item of iterable) { + result.push(item); + } + return result; +} +function trimQuotes(str) { + if (str === undefined) { + return undefined; + } + return str + .trim() + .replace(/^"(.*)"$/, "$1") + .replace(/^'(.*)'$/, "$1"); +} +const handle429 = async (response) => { + if (response?.status === 429) { + const retryAfter = parseInt(response.headers.get("retry-after") ?? "30", 10) * 1000; + if (retryAfter > 0) { + await new Promise((resolve) => setTimeout(resolve, retryAfter)); + // Return directly after calling this check + return true; + } + } + // Fall back to existing status checks + return false; +}; +class Queue { + constructor() { + Object.defineProperty(this, "items", { + enumerable: true, + configurable: true, + writable: true, + value: [] + }); + } + get size() { + return this.items.length; + } + push(item) { + // this.items.push is synchronous with promise creation: + // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/Promise + return new Promise((resolve) => { + this.items.push([item, resolve]); + }); + } + pop(upToN) { + if (upToN < 1) { + throw new Error("Number of items to pop off may not be less than 1."); + } + const popped = []; + while (popped.length < upToN && this.items.length) { + const item = this.items.shift(); + if (item) { + popped.push(item); + } + else { + break; + } + } + return [popped.map((it) => it[0]), () => popped.forEach((it) => it[1]())]; + } +} +// 20 MB +const DEFAULT_BATCH_SIZE_LIMIT_BYTES = 20_971_520; +class client_Client { + constructor(config = {}) { + Object.defineProperty(this, "apiKey", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "apiUrl", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "webUrl", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "caller", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "batchIngestCaller", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "timeout_ms", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "_tenantId", { + enumerable: true, + configurable: true, + writable: true, + value: null + }); + Object.defineProperty(this, "hideInputs", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "hideOutputs", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "tracingSampleRate", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "sampledPostUuids", { + enumerable: true, + configurable: true, + writable: true, + value: new Set() + }); + Object.defineProperty(this, "autoBatchTracing", { + enumerable: true, + configurable: true, + writable: true, + value: true + }); + Object.defineProperty(this, "batchEndpointSupported", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "autoBatchQueue", { + enumerable: true, + configurable: true, + writable: true, + value: new Queue() + }); + Object.defineProperty(this, "pendingAutoBatchedRunLimit", { + enumerable: true, + configurable: true, + writable: true, + value: 100 + }); + Object.defineProperty(this, "autoBatchTimeout", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "autoBatchInitialDelayMs", { + enumerable: true, + configurable: true, + writable: true, + value: 250 + }); + Object.defineProperty(this, "autoBatchAggregationDelayMs", { + enumerable: true, + configurable: true, + writable: true, + value: 50 + }); + Object.defineProperty(this, "serverInfo", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "fetchOptions", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + const defaultConfig = client_Client.getDefaultClientConfig(); + this.tracingSampleRate = getTracingSamplingRate(); + this.apiUrl = trimQuotes(config.apiUrl ?? defaultConfig.apiUrl) ?? ""; + this.apiKey = trimQuotes(config.apiKey ?? defaultConfig.apiKey); + this.webUrl = trimQuotes(config.webUrl ?? defaultConfig.webUrl); + this.timeout_ms = config.timeout_ms ?? 12_000; + this.caller = new AsyncCaller(config.callerOptions ?? {}); + this.batchIngestCaller = new AsyncCaller({ + ...(config.callerOptions ?? {}), + onFailedResponseHook: handle429, + }); + this.hideInputs = config.hideInputs ?? defaultConfig.hideInputs; + this.hideOutputs = config.hideOutputs ?? defaultConfig.hideOutputs; + this.autoBatchTracing = config.autoBatchTracing ?? this.autoBatchTracing; + this.pendingAutoBatchedRunLimit = + config.pendingAutoBatchedRunLimit ?? this.pendingAutoBatchedRunLimit; + this.fetchOptions = config.fetchOptions || {}; + } + static getDefaultClientConfig() { + const apiKey = utils_env_getEnvironmentVariable("LANGCHAIN_API_KEY"); + const apiUrl = utils_env_getEnvironmentVariable("LANGCHAIN_ENDPOINT") ?? + "https://api.smith.langchain.com"; + const hideInputs = utils_env_getEnvironmentVariable("LANGCHAIN_HIDE_INPUTS") === "true"; + const hideOutputs = utils_env_getEnvironmentVariable("LANGCHAIN_HIDE_OUTPUTS") === "true"; + return { + apiUrl: apiUrl, + apiKey: apiKey, + webUrl: undefined, + hideInputs: hideInputs, + hideOutputs: hideOutputs, + }; + } + getHostUrl() { + if (this.webUrl) { + return this.webUrl; + } + else if (isLocalhost(this.apiUrl)) { + this.webUrl = "http://localhost:3000"; + return this.webUrl; + } + else if (this.apiUrl.includes("/api") && + !this.apiUrl.split(".", 1)[0].endsWith("api")) { + this.webUrl = this.apiUrl.replace("/api", ""); + return this.webUrl; + } + else if (this.apiUrl.split(".", 1)[0].includes("dev")) { + this.webUrl = "https://dev.smith.langchain.com"; + return this.webUrl; + } + else { + this.webUrl = "https://smith.langchain.com"; + return this.webUrl; + } + } + get headers() { + const headers = { + "User-Agent": `langsmith-js/${__version__}`, + }; + if (this.apiKey) { + headers["x-api-key"] = `${this.apiKey}`; + } + return headers; + } + processInputs(inputs) { + if (this.hideInputs === false) { + return inputs; + } + if (this.hideInputs === true) { + return {}; + } + if (typeof this.hideInputs === "function") { + return this.hideInputs(inputs); + } + return inputs; + } + processOutputs(outputs) { + if (this.hideOutputs === false) { + return outputs; + } + if (this.hideOutputs === true) { + return {}; + } + if (typeof this.hideOutputs === "function") { + return this.hideOutputs(outputs); + } + return outputs; + } + prepareRunCreateOrUpdateInputs(run) { + const runParams = { ...run }; + if (runParams.inputs !== undefined) { + runParams.inputs = this.processInputs(runParams.inputs); + } + if (runParams.outputs !== undefined) { + runParams.outputs = this.processOutputs(runParams.outputs); + } + return runParams; + } + async _getResponse(path, queryParams) { + const paramsString = queryParams?.toString() ?? ""; + const url = `${this.apiUrl}${path}?${paramsString}`; + const response = await this.caller.call(fetch, url, { + method: "GET", + headers: this.headers, + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + if (!response.ok) { + throw new Error(`Failed to fetch ${path}: ${response.status} ${response.statusText}`); + } + return response; + } + async _get(path, queryParams) { + const response = await this._getResponse(path, queryParams); + return response.json(); + } + async *_getPaginated(path, queryParams = new URLSearchParams()) { + let offset = Number(queryParams.get("offset")) || 0; + const limit = Number(queryParams.get("limit")) || 100; + while (true) { + queryParams.set("offset", String(offset)); + queryParams.set("limit", String(limit)); + const url = `${this.apiUrl}${path}?${queryParams}`; + const response = await this.caller.call(fetch, url, { + method: "GET", + headers: this.headers, + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + if (!response.ok) { + throw new Error(`Failed to fetch ${path}: ${response.status} ${response.statusText}`); + } + const items = await response.json(); + if (items.length === 0) { + break; + } + yield items; + if (items.length < limit) { + break; + } + offset += items.length; + } + } + async *_getCursorPaginatedList(path, body = null, requestMethod = "POST", dataKey = "runs") { + const bodyParams = body ? { ...body } : {}; + while (true) { + const response = await this.caller.call(fetch, `${this.apiUrl}${path}`, { + method: requestMethod, + headers: { ...this.headers, "Content-Type": "application/json" }, + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + body: JSON.stringify(bodyParams), + }); + const responseBody = await response.json(); + if (!responseBody) { + break; + } + if (!responseBody[dataKey]) { + break; + } + yield responseBody[dataKey]; + const cursors = responseBody.cursors; + if (!cursors) { + break; + } + if (!cursors.next) { + break; + } + bodyParams.cursor = cursors.next; + } + } + _filterForSampling(runs, patch = false) { + if (this.tracingSampleRate === undefined) { + return runs; + } + if (patch) { + const sampled = []; + for (const run of runs) { + if (this.sampledPostUuids.has(run.id)) { + sampled.push(run); + this.sampledPostUuids.delete(run.id); + } + } + return sampled; + } + else { + const sampled = []; + for (const run of runs) { + if (Math.random() < this.tracingSampleRate) { + sampled.push(run); + this.sampledPostUuids.add(run.id); + } + } + return sampled; + } + } + async drainAutoBatchQueue() { + while (this.autoBatchQueue.size >= 0) { + const [batch, done] = this.autoBatchQueue.pop(this.pendingAutoBatchedRunLimit); + if (!batch.length) { + done(); + return; + } + try { + await this.batchIngestRuns({ + runCreates: batch + .filter((item) => item.action === "create") + .map((item) => item.item), + runUpdates: batch + .filter((item) => item.action === "update") + .map((item) => item.item), + }); + } + finally { + done(); + } + } + } + async processRunOperation(item, immediatelyTriggerBatch) { + const oldTimeout = this.autoBatchTimeout; + clearTimeout(this.autoBatchTimeout); + this.autoBatchTimeout = undefined; + const itemPromise = this.autoBatchQueue.push(item); + if (immediatelyTriggerBatch || + this.autoBatchQueue.size > this.pendingAutoBatchedRunLimit) { + await this.drainAutoBatchQueue(); + } + if (this.autoBatchQueue.size > 0) { + this.autoBatchTimeout = setTimeout(() => { + this.autoBatchTimeout = undefined; + // This error would happen in the background and is uncatchable + // from the outside. So just log instead. + void this.drainAutoBatchQueue().catch(console.error); + }, oldTimeout + ? this.autoBatchAggregationDelayMs + : this.autoBatchInitialDelayMs); + } + return itemPromise; + } + async _getServerInfo() { + const response = await fetch(`${this.apiUrl}/info`, { + method: "GET", + headers: { Accept: "application/json" }, + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + if (!response.ok) { + // consume the response body to release the connection + // https://undici.nodejs.org/#/?id=garbage-collection + await response.text(); + throw new Error("Failed to retrieve server info."); + } + return response.json(); + } + async batchEndpointIsSupported() { + try { + this.serverInfo = await this._getServerInfo(); + } + catch (e) { + return false; + } + return true; + } + async createRun(run) { + if (!this._filterForSampling([run]).length) { + return; + } + const headers = { ...this.headers, "Content-Type": "application/json" }; + const session_name = run.project_name; + delete run.project_name; + const runCreate = this.prepareRunCreateOrUpdateInputs({ + session_name, + ...run, + start_time: run.start_time ?? Date.now(), + }); + if (this.autoBatchTracing && + runCreate.trace_id !== undefined && + runCreate.dotted_order !== undefined) { + void this.processRunOperation({ + action: "create", + item: runCreate, + }).catch(console.error); + return; + } + const mergedRunCreateParams = await mergeRuntimeEnvIntoRunCreates([ + runCreate, + ]); + const response = await this.caller.call(fetch, `${this.apiUrl}/runs`, { + method: "POST", + headers, + body: JSON.stringify(mergedRunCreateParams[0]), + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + await raiseForStatus(response, "create run"); + } + /** + * Batch ingest/upsert multiple runs in the Langsmith system. + * @param runs + */ + async batchIngestRuns({ runCreates, runUpdates, }) { + if (runCreates === undefined && runUpdates === undefined) { + return; + } + let preparedCreateParams = runCreates?.map((create) => this.prepareRunCreateOrUpdateInputs(create)) ?? []; + let preparedUpdateParams = runUpdates?.map((update) => this.prepareRunCreateOrUpdateInputs(update)) ?? []; + if (preparedCreateParams.length > 0 && preparedUpdateParams.length > 0) { + const createById = preparedCreateParams.reduce((params, run) => { + if (!run.id) { + return params; + } + params[run.id] = run; + return params; + }, {}); + const standaloneUpdates = []; + for (const updateParam of preparedUpdateParams) { + if (updateParam.id !== undefined && createById[updateParam.id]) { + createById[updateParam.id] = { + ...createById[updateParam.id], + ...updateParam, + }; + } + else { + standaloneUpdates.push(updateParam); + } + } + preparedCreateParams = Object.values(createById); + preparedUpdateParams = standaloneUpdates; + } + const rawBatch = { + post: this._filterForSampling(preparedCreateParams), + patch: this._filterForSampling(preparedUpdateParams, true), + }; + if (!rawBatch.post.length && !rawBatch.patch.length) { + return; + } + preparedCreateParams = await mergeRuntimeEnvIntoRunCreates(preparedCreateParams); + if (this.batchEndpointSupported === undefined) { + this.batchEndpointSupported = await this.batchEndpointIsSupported(); + } + if (!this.batchEndpointSupported) { + this.autoBatchTracing = false; + for (const preparedCreateParam of rawBatch.post) { + await this.createRun(preparedCreateParam); + } + for (const preparedUpdateParam of rawBatch.patch) { + if (preparedUpdateParam.id !== undefined) { + await this.updateRun(preparedUpdateParam.id, preparedUpdateParam); + } + } + return; + } + const sizeLimitBytes = this.serverInfo?.batch_ingest_config?.size_limit_bytes ?? + DEFAULT_BATCH_SIZE_LIMIT_BYTES; + const batchChunks = { + post: [], + patch: [], + }; + let currentBatchSizeBytes = 0; + for (const k of ["post", "patch"]) { + const key = k; + const batchItems = rawBatch[key].reverse(); + let batchItem = batchItems.pop(); + while (batchItem !== undefined) { + const stringifiedBatchItem = JSON.stringify(batchItem); + if (currentBatchSizeBytes > 0 && + currentBatchSizeBytes + stringifiedBatchItem.length > sizeLimitBytes) { + await this._postBatchIngestRuns(JSON.stringify(batchChunks)); + currentBatchSizeBytes = 0; + batchChunks.post = []; + batchChunks.patch = []; + } + currentBatchSizeBytes += stringifiedBatchItem.length; + batchChunks[key].push(batchItem); + batchItem = batchItems.pop(); + } + } + if (batchChunks.post.length > 0 || batchChunks.patch.length > 0) { + await this._postBatchIngestRuns(JSON.stringify(batchChunks)); + } + } + async _postBatchIngestRuns(body) { + const headers = { + ...this.headers, + "Content-Type": "application/json", + Accept: "application/json", + }; + const response = await this.batchIngestCaller.call(fetch, `${this.apiUrl}/runs/batch`, { + method: "POST", + headers, + body: body, + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + await raiseForStatus(response, "batch create run"); + } + async updateRun(runId, run) { + assertUuid(runId); + if (run.inputs) { + run.inputs = this.processInputs(run.inputs); + } + if (run.outputs) { + run.outputs = this.processOutputs(run.outputs); + } + // TODO: Untangle types + const data = { ...run, id: runId }; + if (!this._filterForSampling([data], true).length) { + return; + } + if (this.autoBatchTracing && + data.trace_id !== undefined && + data.dotted_order !== undefined) { + if (run.end_time !== undefined && data.parent_run_id === undefined) { + // Trigger a batch as soon as a root trace ends and block to ensure trace finishes + // in serverless environments. + await this.processRunOperation({ action: "update", item: data }, true); + return; + } + else { + void this.processRunOperation({ action: "update", item: data }).catch(console.error); + } + return; + } + const headers = { ...this.headers, "Content-Type": "application/json" }; + const response = await this.caller.call(fetch, `${this.apiUrl}/runs/${runId}`, { + method: "PATCH", + headers, + body: JSON.stringify(run), + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + await raiseForStatus(response, "update run"); + } + async readRun(runId, { loadChildRuns } = { loadChildRuns: false }) { + assertUuid(runId); + let run = await this._get(`/runs/${runId}`); + if (loadChildRuns && run.child_run_ids) { + run = await this._loadChildRuns(run); + } + return run; + } + async getRunUrl({ runId, run, projectOpts, }) { + if (run !== undefined) { + let sessionId; + if (run.session_id) { + sessionId = run.session_id; + } + else if (projectOpts?.projectName) { + sessionId = (await this.readProject({ projectName: projectOpts?.projectName })).id; + } + else if (projectOpts?.projectId) { + sessionId = projectOpts?.projectId; + } + else { + const project = await this.readProject({ + projectName: utils_env_getEnvironmentVariable("LANGCHAIN_PROJECT") || "default", + }); + sessionId = project.id; + } + const tenantId = await this._getTenantId(); + return `${this.getHostUrl()}/o/${tenantId}/projects/p/${sessionId}/r/${run.id}?poll=true`; + } + else if (runId !== undefined) { + const run_ = await this.readRun(runId); + if (!run_.app_path) { + throw new Error(`Run ${runId} has no app_path`); + } + const baseUrl = this.getHostUrl(); + return `${baseUrl}${run_.app_path}`; + } + else { + throw new Error("Must provide either runId or run"); + } + } + async _loadChildRuns(run) { + const childRuns = await toArray(this.listRuns({ id: run.child_run_ids })); + const treemap = {}; + const runs = {}; + // TODO: make dotted order required when the migration finishes + childRuns.sort((a, b) => (a?.dotted_order ?? "").localeCompare(b?.dotted_order ?? "")); + for (const childRun of childRuns) { + if (childRun.parent_run_id === null || + childRun.parent_run_id === undefined) { + throw new Error(`Child run ${childRun.id} has no parent`); + } + if (!(childRun.parent_run_id in treemap)) { + treemap[childRun.parent_run_id] = []; + } + treemap[childRun.parent_run_id].push(childRun); + runs[childRun.id] = childRun; + } + run.child_runs = treemap[run.id] || []; + for (const runId in treemap) { + if (runId !== run.id) { + runs[runId].child_runs = treemap[runId]; + } + } + return run; + } + /** + * List runs from the LangSmith server. + * @param projectId - The ID of the project to filter by. + * @param projectName - The name of the project to filter by. + * @param parentRunId - The ID of the parent run to filter by. + * @param traceId - The ID of the trace to filter by. + * @param referenceExampleId - The ID of the reference example to filter by. + * @param startTime - The start time to filter by. + * @param isRoot - Indicates whether to only return root runs. + * @param runType - The run type to filter by. + * @param error - Indicates whether to filter by error runs. + * @param id - The ID of the run to filter by. + * @param query - The query string to filter by. + * @param filter - The filter string to apply to the run spans. + * @param traceFilter - The filter string to apply on the root run of the trace. + * @param limit - The maximum number of runs to retrieve. + * @returns {AsyncIterable} - The runs. + * + * @example + * // List all runs in a project + * const projectRuns = client.listRuns({ projectName: "" }); + * + * @example + * // List LLM and Chat runs in the last 24 hours + * const todaysLLMRuns = client.listRuns({ + * projectName: "", + * start_time: new Date(Date.now() - 24 * 60 * 60 * 1000), + * run_type: "llm", + * }); + * + * @example + * // List traces in a project + * const rootRuns = client.listRuns({ + * projectName: "", + * execution_order: 1, + * }); + * + * @example + * // List runs without errors + * const correctRuns = client.listRuns({ + * projectName: "", + * error: false, + * }); + * + * @example + * // List runs by run ID + * const runIds = [ + * "a36092d2-4ad5-4fb4-9c0d-0dba9a2ed836", + * "9398e6be-964f-4aa4-8ae9-ad78cd4b7074", + * ]; + * const selectedRuns = client.listRuns({ run_ids: runIds }); + * + * @example + * // List all "chain" type runs that took more than 10 seconds and had `total_tokens` greater than 5000 + * const chainRuns = client.listRuns({ + * projectName: "", + * filter: 'and(eq(run_type, "chain"), gt(latency, 10), gt(total_tokens, 5000))', + * }); + * + * @example + * // List all runs called "extractor" whose root of the trace was assigned feedback "user_score" score of 1 + * const goodExtractorRuns = client.listRuns({ + * projectName: "", + * filter: 'eq(name, "extractor")', + * traceFilter: 'and(eq(feedback_key, "user_score"), eq(feedback_score, 1))', + * }); + * + * @example + * // List all runs that started after a specific timestamp and either have "error" not equal to null or a "Correctness" feedback score equal to 0 + * const complexRuns = client.listRuns({ + * projectName: "", + * filter: 'and(gt(start_time, "2023-07-15T12:34:56Z"), or(neq(error, null), and(eq(feedback_key, "Correctness"), eq(feedback_score, 0.0))))', + * }); + * + * @example + * // List all runs where `tags` include "experimental" or "beta" and `latency` is greater than 2 seconds + * const taggedRuns = client.listRuns({ + * projectName: "", + * filter: 'and(or(has(tags, "experimental"), has(tags, "beta")), gt(latency, 2))', + * }); + */ + async *listRuns(props) { + const { projectId, projectName, parentRunId, traceId, referenceExampleId, startTime, executionOrder, isRoot, runType, error, id, query, filter, traceFilter, treeFilter, limit, select, } = props; + let projectIds = []; + if (projectId) { + projectIds = Array.isArray(projectId) ? projectId : [projectId]; + } + if (projectName) { + const projectNames = Array.isArray(projectName) + ? projectName + : [projectName]; + const projectIds_ = await Promise.all(projectNames.map((name) => this.readProject({ projectName: name }).then((project) => project.id))); + projectIds.push(...projectIds_); + } + const default_select = [ + "app_path", + "child_run_ids", + "completion_cost", + "completion_tokens", + "dotted_order", + "end_time", + "error", + "events", + "extra", + "feedback_stats", + "first_token_time", + "id", + "inputs", + "name", + "outputs", + "parent_run_id", + "parent_run_ids", + "prompt_cost", + "prompt_tokens", + "reference_example_id", + "run_type", + "session_id", + "start_time", + "status", + "tags", + "total_cost", + "total_tokens", + "trace_id", + ]; + const body = { + session: projectIds.length ? projectIds : null, + run_type: runType, + reference_example: referenceExampleId, + query, + filter, + trace_filter: traceFilter, + tree_filter: treeFilter, + execution_order: executionOrder, + parent_run: parentRunId, + start_time: startTime ? startTime.toISOString() : null, + error, + id, + limit, + trace: traceId, + select: select ? select : default_select, + is_root: isRoot, + }; + let runsYielded = 0; + for await (const runs of this._getCursorPaginatedList("/runs/query", body)) { + if (limit) { + if (runsYielded >= limit) { + break; + } + if (runs.length + runsYielded > limit) { + const newRuns = runs.slice(0, limit - runsYielded); + yield* newRuns; + break; + } + runsYielded += runs.length; + yield* runs; + } + else { + yield* runs; + } + } + } + async shareRun(runId, { shareId } = {}) { + const data = { + run_id: runId, + share_token: shareId || v4(), + }; + assertUuid(runId); + const response = await this.caller.call(fetch, `${this.apiUrl}/runs/${runId}/share`, { + method: "PUT", + headers: this.headers, + body: JSON.stringify(data), + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + const result = await response.json(); + if (result === null || !("share_token" in result)) { + throw new Error("Invalid response from server"); + } + return `${this.getHostUrl()}/public/${result["share_token"]}/r`; + } + async unshareRun(runId) { + assertUuid(runId); + const response = await this.caller.call(fetch, `${this.apiUrl}/runs/${runId}/share`, { + method: "DELETE", + headers: this.headers, + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + await raiseForStatus(response, "unshare run"); + } + async readRunSharedLink(runId) { + assertUuid(runId); + const response = await this.caller.call(fetch, `${this.apiUrl}/runs/${runId}/share`, { + method: "GET", + headers: this.headers, + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + const result = await response.json(); + if (result === null || !("share_token" in result)) { + return undefined; + } + return `${this.getHostUrl()}/public/${result["share_token"]}/r`; + } + async listSharedRuns(shareToken, { runIds, } = {}) { + const queryParams = new URLSearchParams({ + share_token: shareToken, + }); + if (runIds !== undefined) { + for (const runId of runIds) { + queryParams.append("id", runId); + } + } + assertUuid(shareToken); + const response = await this.caller.call(fetch, `${this.apiUrl}/public/${shareToken}/runs${queryParams}`, { + method: "GET", + headers: this.headers, + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + const runs = await response.json(); + return runs; + } + async readDatasetSharedSchema(datasetId, datasetName) { + if (!datasetId && !datasetName) { + throw new Error("Either datasetId or datasetName must be given"); + } + if (!datasetId) { + const dataset = await this.readDataset({ datasetName }); + datasetId = dataset.id; + } + assertUuid(datasetId); + const response = await this.caller.call(fetch, `${this.apiUrl}/datasets/${datasetId}/share`, { + method: "GET", + headers: this.headers, + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + const shareSchema = await response.json(); + shareSchema.url = `${this.getHostUrl()}/public/${shareSchema.share_token}/d`; + return shareSchema; + } + async shareDataset(datasetId, datasetName) { + if (!datasetId && !datasetName) { + throw new Error("Either datasetId or datasetName must be given"); + } + if (!datasetId) { + const dataset = await this.readDataset({ datasetName }); + datasetId = dataset.id; + } + const data = { + dataset_id: datasetId, + }; + assertUuid(datasetId); + const response = await this.caller.call(fetch, `${this.apiUrl}/datasets/${datasetId}/share`, { + method: "PUT", + headers: this.headers, + body: JSON.stringify(data), + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + const shareSchema = await response.json(); + shareSchema.url = `${this.getHostUrl()}/public/${shareSchema.share_token}/d`; + return shareSchema; + } + async unshareDataset(datasetId) { + assertUuid(datasetId); + const response = await this.caller.call(fetch, `${this.apiUrl}/datasets/${datasetId}/share`, { + method: "DELETE", + headers: this.headers, + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + await raiseForStatus(response, "unshare dataset"); + } + async readSharedDataset(shareToken) { + assertUuid(shareToken); + const response = await this.caller.call(fetch, `${this.apiUrl}/public/${shareToken}/datasets`, { + method: "GET", + headers: this.headers, + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + const dataset = await response.json(); + return dataset; + } + async createProject({ projectName, description = null, metadata = null, upsert = false, projectExtra = null, referenceDatasetId = null, }) { + const upsert_ = upsert ? `?upsert=true` : ""; + const endpoint = `${this.apiUrl}/sessions${upsert_}`; + const extra = projectExtra || {}; + if (metadata) { + extra["metadata"] = metadata; + } + const body = { + name: projectName, + extra, + description, + }; + if (referenceDatasetId !== null) { + body["reference_dataset_id"] = referenceDatasetId; + } + const response = await this.caller.call(fetch, endpoint, { + method: "POST", + headers: { ...this.headers, "Content-Type": "application/json" }, + body: JSON.stringify(body), + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + const result = await response.json(); + if (!response.ok) { + throw new Error(`Failed to create session ${projectName}: ${response.status} ${response.statusText}`); + } + return result; + } + async updateProject(projectId, { name = null, description = null, metadata = null, projectExtra = null, endTime = null, }) { + const endpoint = `${this.apiUrl}/sessions/${projectId}`; + let extra = projectExtra; + if (metadata) { + extra = { ...(extra || {}), metadata }; + } + const body = { + name, + extra, + description, + end_time: endTime ? new Date(endTime).toISOString() : null, + }; + const response = await this.caller.call(fetch, endpoint, { + method: "PATCH", + headers: { ...this.headers, "Content-Type": "application/json" }, + body: JSON.stringify(body), + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + const result = await response.json(); + if (!response.ok) { + throw new Error(`Failed to update project ${projectId}: ${response.status} ${response.statusText}`); + } + return result; + } + async hasProject({ projectId, projectName, }) { + // TODO: Add a head request + let path = "/sessions"; + const params = new URLSearchParams(); + if (projectId !== undefined && projectName !== undefined) { + throw new Error("Must provide either projectName or projectId, not both"); + } + else if (projectId !== undefined) { + assertUuid(projectId); + path += `/${projectId}`; + } + else if (projectName !== undefined) { + params.append("name", projectName); + } + else { + throw new Error("Must provide projectName or projectId"); + } + const response = await this.caller.call(fetch, `${this.apiUrl}${path}?${params}`, { + method: "GET", + headers: this.headers, + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + // consume the response body to release the connection + // https://undici.nodejs.org/#/?id=garbage-collection + try { + const result = await response.json(); + if (!response.ok) { + return false; + } + // If it's OK and we're querying by name, need to check the list is not empty + if (Array.isArray(result)) { + return result.length > 0; + } + // projectId querying + return true; + } + catch (e) { + return false; + } + } + async readProject({ projectId, projectName, includeStats, }) { + let path = "/sessions"; + const params = new URLSearchParams(); + if (projectId !== undefined && projectName !== undefined) { + throw new Error("Must provide either projectName or projectId, not both"); + } + else if (projectId !== undefined) { + assertUuid(projectId); + path += `/${projectId}`; + } + else if (projectName !== undefined) { + params.append("name", projectName); + } + else { + throw new Error("Must provide projectName or projectId"); + } + if (includeStats !== undefined) { + params.append("include_stats", includeStats.toString()); + } + const response = await this._get(path, params); + let result; + if (Array.isArray(response)) { + if (response.length === 0) { + throw new Error(`Project[id=${projectId}, name=${projectName}] not found`); + } + result = response[0]; + } + else { + result = response; + } + return result; + } + async getProjectUrl({ projectId, projectName, }) { + if (projectId === undefined && projectName === undefined) { + throw new Error("Must provide either projectName or projectId"); + } + const project = await this.readProject({ projectId, projectName }); + const tenantId = await this._getTenantId(); + return `${this.getHostUrl()}/o/${tenantId}/projects/p/${project.id}`; + } + async _getTenantId() { + if (this._tenantId !== null) { + return this._tenantId; + } + const queryParams = new URLSearchParams({ limit: "1" }); + for await (const projects of this._getPaginated("/sessions", queryParams)) { + this._tenantId = projects[0].tenant_id; + return projects[0].tenant_id; + } + throw new Error("No projects found to resolve tenant."); + } + async *listProjects({ projectIds, name, nameContains, referenceDatasetId, referenceDatasetName, referenceFree, } = {}) { + const params = new URLSearchParams(); + if (projectIds !== undefined) { + for (const projectId of projectIds) { + params.append("id", projectId); + } + } + if (name !== undefined) { + params.append("name", name); + } + if (nameContains !== undefined) { + params.append("name_contains", nameContains); + } + if (referenceDatasetId !== undefined) { + params.append("reference_dataset", referenceDatasetId); + } + else if (referenceDatasetName !== undefined) { + const dataset = await this.readDataset({ + datasetName: referenceDatasetName, + }); + params.append("reference_dataset", dataset.id); + } + if (referenceFree !== undefined) { + params.append("reference_free", referenceFree.toString()); + } + for await (const projects of this._getPaginated("/sessions", params)) { + yield* projects; + } + } + async deleteProject({ projectId, projectName, }) { + let projectId_; + if (projectId === undefined && projectName === undefined) { + throw new Error("Must provide projectName or projectId"); + } + else if (projectId !== undefined && projectName !== undefined) { + throw new Error("Must provide either projectName or projectId, not both"); + } + else if (projectId === undefined) { + projectId_ = (await this.readProject({ projectName })).id; + } + else { + projectId_ = projectId; + } + assertUuid(projectId_); + const response = await this.caller.call(fetch, `${this.apiUrl}/sessions/${projectId_}`, { + method: "DELETE", + headers: this.headers, + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + await raiseForStatus(response, `delete session ${projectId_} (${projectName})`); + } + async uploadCsv({ csvFile, fileName, inputKeys, outputKeys, description, dataType, name, }) { + const url = `${this.apiUrl}/datasets/upload`; + const formData = new FormData(); + formData.append("file", csvFile, fileName); + inputKeys.forEach((key) => { + formData.append("input_keys", key); + }); + outputKeys.forEach((key) => { + formData.append("output_keys", key); + }); + if (description) { + formData.append("description", description); + } + if (dataType) { + formData.append("data_type", dataType); + } + if (name) { + formData.append("name", name); + } + const response = await this.caller.call(fetch, url, { + method: "POST", + headers: this.headers, + body: formData, + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + if (!response.ok) { + const result = await response.json(); + if (result.detail && result.detail.includes("already exists")) { + throw new Error(`Dataset ${fileName} already exists`); + } + throw new Error(`Failed to upload CSV: ${response.status} ${response.statusText}`); + } + const result = await response.json(); + return result; + } + async createDataset(name, { description, dataType, } = {}) { + const body = { + name, + description, + }; + if (dataType) { + body.data_type = dataType; + } + const response = await this.caller.call(fetch, `${this.apiUrl}/datasets`, { + method: "POST", + headers: { ...this.headers, "Content-Type": "application/json" }, + body: JSON.stringify(body), + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + if (!response.ok) { + const result = await response.json(); + if (result.detail && result.detail.includes("already exists")) { + throw new Error(`Dataset ${name} already exists`); + } + throw new Error(`Failed to create dataset ${response.status} ${response.statusText}`); + } + const result = await response.json(); + return result; + } + async readDataset({ datasetId, datasetName, }) { + let path = "/datasets"; + // limit to 1 result + const params = new URLSearchParams({ limit: "1" }); + if (datasetId !== undefined && datasetName !== undefined) { + throw new Error("Must provide either datasetName or datasetId, not both"); + } + else if (datasetId !== undefined) { + assertUuid(datasetId); + path += `/${datasetId}`; + } + else if (datasetName !== undefined) { + params.append("name", datasetName); + } + else { + throw new Error("Must provide datasetName or datasetId"); + } + const response = await this._get(path, params); + let result; + if (Array.isArray(response)) { + if (response.length === 0) { + throw new Error(`Dataset[id=${datasetId}, name=${datasetName}] not found`); + } + result = response[0]; + } + else { + result = response; + } + return result; + } + async hasDataset({ datasetId, datasetName, }) { + try { + await this.readDataset({ datasetId, datasetName }); + return true; + } + catch (e) { + if ( + // eslint-disable-next-line no-instanceof/no-instanceof + e instanceof Error && + e.message.toLocaleLowerCase().includes("not found")) { + return false; + } + throw e; + } + } + async diffDatasetVersions({ datasetId, datasetName, fromVersion, toVersion, }) { + let datasetId_ = datasetId; + if (datasetId_ === undefined && datasetName === undefined) { + throw new Error("Must provide either datasetName or datasetId"); + } + else if (datasetId_ !== undefined && datasetName !== undefined) { + throw new Error("Must provide either datasetName or datasetId, not both"); + } + else if (datasetId_ === undefined) { + const dataset = await this.readDataset({ datasetName }); + datasetId_ = dataset.id; + } + const urlParams = new URLSearchParams({ + from_version: typeof fromVersion === "string" + ? fromVersion + : fromVersion.toISOString(), + to_version: typeof toVersion === "string" ? toVersion : toVersion.toISOString(), + }); + const response = await this._get(`/datasets/${datasetId_}/versions/diff`, urlParams); + return response; + } + async readDatasetOpenaiFinetuning({ datasetId, datasetName, }) { + const path = "/datasets"; + if (datasetId !== undefined) { + // do nothing + } + else if (datasetName !== undefined) { + datasetId = (await this.readDataset({ datasetName })).id; + } + else { + throw new Error("Must provide datasetName or datasetId"); + } + const response = await this._getResponse(`${path}/${datasetId}/openai_ft`); + const datasetText = await response.text(); + const dataset = datasetText + .trim() + .split("\n") + .map((line) => JSON.parse(line)); + return dataset; + } + async *listDatasets({ limit = 100, offset = 0, datasetIds, datasetName, datasetNameContains, } = {}) { + const path = "/datasets"; + const params = new URLSearchParams({ + limit: limit.toString(), + offset: offset.toString(), + }); + if (datasetIds !== undefined) { + for (const id_ of datasetIds) { + params.append("id", id_); + } + } + if (datasetName !== undefined) { + params.append("name", datasetName); + } + if (datasetNameContains !== undefined) { + params.append("name_contains", datasetNameContains); + } + for await (const datasets of this._getPaginated(path, params)) { + yield* datasets; + } + } + async deleteDataset({ datasetId, datasetName, }) { + let path = "/datasets"; + let datasetId_ = datasetId; + if (datasetId !== undefined && datasetName !== undefined) { + throw new Error("Must provide either datasetName or datasetId, not both"); + } + else if (datasetName !== undefined) { + const dataset = await this.readDataset({ datasetName }); + datasetId_ = dataset.id; + } + if (datasetId_ !== undefined) { + assertUuid(datasetId_); + path += `/${datasetId_}`; + } + else { + throw new Error("Must provide datasetName or datasetId"); + } + const response = await this.caller.call(fetch, this.apiUrl + path, { + method: "DELETE", + headers: this.headers, + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + if (!response.ok) { + throw new Error(`Failed to delete ${path}: ${response.status} ${response.statusText}`); + } + await response.json(); + } + async createExample(inputs, outputs, { datasetId, datasetName, createdAt, exampleId, metadata, }) { + let datasetId_ = datasetId; + if (datasetId_ === undefined && datasetName === undefined) { + throw new Error("Must provide either datasetName or datasetId"); + } + else if (datasetId_ !== undefined && datasetName !== undefined) { + throw new Error("Must provide either datasetName or datasetId, not both"); + } + else if (datasetId_ === undefined) { + const dataset = await this.readDataset({ datasetName }); + datasetId_ = dataset.id; + } + const createdAt_ = createdAt || new Date(); + const data = { + dataset_id: datasetId_, + inputs, + outputs, + created_at: createdAt_?.toISOString(), + id: exampleId, + metadata, + }; + const response = await this.caller.call(fetch, `${this.apiUrl}/examples`, { + method: "POST", + headers: { ...this.headers, "Content-Type": "application/json" }, + body: JSON.stringify(data), + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + if (!response.ok) { + throw new Error(`Failed to create example: ${response.status} ${response.statusText}`); + } + const result = await response.json(); + return result; + } + async createExamples(props) { + const { inputs, outputs, metadata, sourceRunIds, exampleIds, datasetId, datasetName, } = props; + let datasetId_ = datasetId; + if (datasetId_ === undefined && datasetName === undefined) { + throw new Error("Must provide either datasetName or datasetId"); + } + else if (datasetId_ !== undefined && datasetName !== undefined) { + throw new Error("Must provide either datasetName or datasetId, not both"); + } + else if (datasetId_ === undefined) { + const dataset = await this.readDataset({ datasetName }); + datasetId_ = dataset.id; + } + const formattedExamples = inputs.map((input, idx) => { + return { + dataset_id: datasetId_, + inputs: input, + outputs: outputs ? outputs[idx] : undefined, + metadata: metadata ? metadata[idx] : undefined, + id: exampleIds ? exampleIds[idx] : undefined, + source_run_id: sourceRunIds ? sourceRunIds[idx] : undefined, + }; + }); + const response = await this.caller.call(fetch, `${this.apiUrl}/examples/bulk`, { + method: "POST", + headers: { ...this.headers, "Content-Type": "application/json" }, + body: JSON.stringify(formattedExamples), + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + if (!response.ok) { + throw new Error(`Failed to create examples: ${response.status} ${response.statusText}`); + } + const result = await response.json(); + return result; + } + async createLLMExample(input, generation, options) { + return this.createExample({ input }, { output: generation }, options); + } + async createChatExample(input, generations, options) { + const finalInput = input.map((message) => { + if (isLangChainMessage(message)) { + return convertLangChainMessageToExample(message); + } + return message; + }); + const finalOutput = isLangChainMessage(generations) + ? convertLangChainMessageToExample(generations) + : generations; + return this.createExample({ input: finalInput }, { output: finalOutput }, options); + } + async readExample(exampleId) { + assertUuid(exampleId); + const path = `/examples/${exampleId}`; + return await this._get(path); + } + async *listExamples({ datasetId, datasetName, exampleIds, asOf, inlineS3Urls, metadata, } = {}) { + let datasetId_; + if (datasetId !== undefined && datasetName !== undefined) { + throw new Error("Must provide either datasetName or datasetId, not both"); + } + else if (datasetId !== undefined) { + datasetId_ = datasetId; + } + else if (datasetName !== undefined) { + const dataset = await this.readDataset({ datasetName }); + datasetId_ = dataset.id; + } + else { + throw new Error("Must provide a datasetName or datasetId"); + } + const params = new URLSearchParams({ dataset: datasetId_ }); + const dataset_version = asOf + ? typeof asOf === "string" + ? asOf + : asOf?.toISOString() + : undefined; + if (dataset_version) { + params.append("as_of", dataset_version); + } + const inlineS3Urls_ = inlineS3Urls ?? true; + params.append("inline_s3_urls", inlineS3Urls_.toString()); + if (exampleIds !== undefined) { + for (const id_ of exampleIds) { + params.append("id", id_); + } + } + if (metadata !== undefined) { + const serializedMetadata = JSON.stringify(metadata); + params.append("metadata", serializedMetadata); + } + for await (const examples of this._getPaginated("/examples", params)) { + yield* examples; + } + } + async deleteExample(exampleId) { + assertUuid(exampleId); + const path = `/examples/${exampleId}`; + const response = await this.caller.call(fetch, this.apiUrl + path, { + method: "DELETE", + headers: this.headers, + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + if (!response.ok) { + throw new Error(`Failed to delete ${path}: ${response.status} ${response.statusText}`); + } + await response.json(); + } + async updateExample(exampleId, update) { + assertUuid(exampleId); + const response = await this.caller.call(fetch, `${this.apiUrl}/examples/${exampleId}`, { + method: "PATCH", + headers: { ...this.headers, "Content-Type": "application/json" }, + body: JSON.stringify(update), + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + if (!response.ok) { + throw new Error(`Failed to update example ${exampleId}: ${response.status} ${response.statusText}`); + } + const result = await response.json(); + return result; + } + async evaluateRun(run, evaluator, { sourceInfo, loadChildRuns, referenceExample, } = { loadChildRuns: false }) { + let run_; + if (typeof run === "string") { + run_ = await this.readRun(run, { loadChildRuns }); + } + else if (typeof run === "object" && "id" in run) { + run_ = run; + } + else { + throw new Error(`Invalid run type: ${typeof run}`); + } + if (run_.reference_example_id !== null && + run_.reference_example_id !== undefined) { + referenceExample = await this.readExample(run_.reference_example_id); + } + const feedbackResult = await evaluator.evaluateRun(run_, referenceExample); + let sourceInfo_ = sourceInfo ?? {}; + if (feedbackResult.evaluatorInfo) { + sourceInfo_ = { ...sourceInfo_, ...feedbackResult.evaluatorInfo }; + } + const runId = feedbackResult.targetRunId ?? run_.id; + return await this.createFeedback(runId, feedbackResult.key, { + score: feedbackResult?.score, + value: feedbackResult?.value, + comment: feedbackResult?.comment, + correction: feedbackResult?.correction, + sourceInfo: sourceInfo_, + feedbackSourceType: "model", + sourceRunId: feedbackResult?.sourceRunId, + }); + } + async createFeedback(runId, key, { score, value, correction, comment, sourceInfo, feedbackSourceType = "api", sourceRunId, feedbackId, feedbackConfig, projectId, comparativeExperimentId, }) { + if (!runId && !projectId) { + throw new Error("One of runId or projectId must be provided"); + } + if (runId && projectId) { + throw new Error("Only one of runId or projectId can be provided"); + } + const feedback_source = { + type: feedbackSourceType ?? "api", + metadata: sourceInfo ?? {}, + }; + if (sourceRunId !== undefined && + feedback_source?.metadata !== undefined && + !feedback_source.metadata["__run"]) { + feedback_source.metadata["__run"] = { run_id: sourceRunId }; + } + if (feedback_source?.metadata !== undefined && + feedback_source.metadata["__run"]?.run_id !== undefined) { + assertUuid(feedback_source.metadata["__run"].run_id); + } + const feedback = { + id: feedbackId ?? v4(), + run_id: runId, + key, + score, + value, + correction, + comment, + feedback_source: feedback_source, + comparative_experiment_id: comparativeExperimentId, + feedbackConfig, + session_id: projectId, + }; + const url = `${this.apiUrl}/feedback`; + const response = await this.caller.call(fetch, url, { + method: "POST", + headers: { ...this.headers, "Content-Type": "application/json" }, + body: JSON.stringify(feedback), + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + await raiseForStatus(response, "create feedback"); + return feedback; + } + async updateFeedback(feedbackId, { score, value, correction, comment, }) { + const feedbackUpdate = {}; + if (score !== undefined && score !== null) { + feedbackUpdate["score"] = score; + } + if (value !== undefined && value !== null) { + feedbackUpdate["value"] = value; + } + if (correction !== undefined && correction !== null) { + feedbackUpdate["correction"] = correction; + } + if (comment !== undefined && comment !== null) { + feedbackUpdate["comment"] = comment; + } + assertUuid(feedbackId); + const response = await this.caller.call(fetch, `${this.apiUrl}/feedback/${feedbackId}`, { + method: "PATCH", + headers: { ...this.headers, "Content-Type": "application/json" }, + body: JSON.stringify(feedbackUpdate), + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + await raiseForStatus(response, "update feedback"); + } + async readFeedback(feedbackId) { + assertUuid(feedbackId); + const path = `/feedback/${feedbackId}`; + const response = await this._get(path); + return response; + } + async deleteFeedback(feedbackId) { + assertUuid(feedbackId); + const path = `/feedback/${feedbackId}`; + const response = await this.caller.call(fetch, this.apiUrl + path, { + method: "DELETE", + headers: this.headers, + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + if (!response.ok) { + throw new Error(`Failed to delete ${path}: ${response.status} ${response.statusText}`); + } + await response.json(); + } + async *listFeedback({ runIds, feedbackKeys, feedbackSourceTypes, } = {}) { + const queryParams = new URLSearchParams(); + if (runIds) { + queryParams.append("run", runIds.join(",")); + } + if (feedbackKeys) { + for (const key of feedbackKeys) { + queryParams.append("key", key); + } + } + if (feedbackSourceTypes) { + for (const type of feedbackSourceTypes) { + queryParams.append("source", type); + } + } + for await (const feedbacks of this._getPaginated("/feedback", queryParams)) { + yield* feedbacks; + } + } + /** + * Creates a presigned feedback token and URL. + * + * The token can be used to authorize feedback metrics without + * needing an API key. This is useful for giving browser-based + * applications the ability to submit feedback without needing + * to expose an API key. + * + * @param runId - The ID of the run. + * @param feedbackKey - The feedback key. + * @param options - Additional options for the token. + * @param options.expiration - The expiration time for the token. + * + * @returns A promise that resolves to a FeedbackIngestToken. + */ + async createPresignedFeedbackToken(runId, feedbackKey, { expiration, feedbackConfig, } = {}) { + const body = { + run_id: runId, + feedback_key: feedbackKey, + feedback_config: feedbackConfig, + }; + if (expiration) { + if (typeof expiration === "string") { + body["expires_at"] = expiration; + } + else if (expiration?.hours || expiration?.minutes || expiration?.days) { + body["expires_in"] = expiration; + } + } + else { + body["expires_in"] = { + hours: 3, + }; + } + const response = await this.caller.call(fetch, `${this.apiUrl}/feedback/tokens`, { + method: "POST", + headers: { ...this.headers, "Content-Type": "application/json" }, + body: JSON.stringify(body), + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + const result = await response.json(); + return result; + } + async createComparativeExperiment({ name, experimentIds, referenceDatasetId, createdAt, description, metadata, id, }) { + if (experimentIds.length === 0) { + throw new Error("At least one experiment is required"); + } + if (!referenceDatasetId) { + referenceDatasetId = (await this.readProject({ + projectId: experimentIds[0], + })).reference_dataset_id; + } + if (!referenceDatasetId == null) { + throw new Error("A reference dataset is required"); + } + const body = { + id, + name, + experiment_ids: experimentIds, + reference_dataset_id: referenceDatasetId, + description, + created_at: (createdAt ?? new Date())?.toISOString(), + extra: {}, + }; + if (metadata) + body.extra["metadata"] = metadata; + const response = await this.caller.call(fetch, `${this.apiUrl}/datasets/comparative`, { + method: "POST", + headers: { ...this.headers, "Content-Type": "application/json" }, + body: JSON.stringify(body), + signal: AbortSignal.timeout(this.timeout_ms), + ...this.fetchOptions, + }); + return await response.json(); + } + /** + * Retrieves a list of presigned feedback tokens for a given run ID. + * @param runId The ID of the run. + * @returns An async iterable of FeedbackIngestToken objects. + */ + async *listPresignedFeedbackTokens(runId) { + assertUuid(runId); + const params = new URLSearchParams({ run_id: runId }); + for await (const tokens of this._getPaginated("/feedback/tokens", params)) { + yield* tokens; + } + } + _selectEvalResults(results) { + let results_; + if ("results" in results) { + results_ = results.results; + } + else { + results_ = [results]; + } + return results_; + } + async logEvaluationFeedback(evaluatorResponse, run, sourceInfo) { + const results = this._selectEvalResults(evaluatorResponse); + for (const res of results) { + let sourceInfo_ = sourceInfo || {}; + if (res.evaluatorInfo) { + sourceInfo_ = { ...res.evaluatorInfo, ...sourceInfo_ }; + } + let runId_ = null; + if (res.targetRunId) { + runId_ = res.targetRunId; + } + else if (run) { + runId_ = run.id; + } + await this.createFeedback(runId_, res.key, { + score: res.score, + value: res.value, + comment: res.comment, + correction: res.correction, + sourceInfo: sourceInfo_, + sourceRunId: res.sourceRunId, + feedbackConfig: res.feedbackConfig, + feedbackSourceType: "model", + }); + } + return results; + } +} + +;// CONCATENATED MODULE: ./node_modules/langsmith/dist/run_trees.js + + + +const warnedMessages = {}; +function warnOnce(message) { + if (!warnedMessages[message]) { + console.warn(message); + warnedMessages[message] = true; + } +} +function run_trees_stripNonAlphanumeric(input) { + return input.replace(/[-:.]/g, ""); +} +function run_trees_convertToDottedOrderFormat(epoch, runId, executionOrder = 1) { + // Date only has millisecond precision, so we use the microseconds to break + // possible ties, avoiding incorrect run order + const paddedOrder = executionOrder.toFixed(0).slice(0, 3).padStart(3, "0"); + return (run_trees_stripNonAlphanumeric(`${new Date(epoch).toISOString().slice(0, -1)}${paddedOrder}Z`) + runId); +} +class RunTree { + constructor(originalConfig) { + Object.defineProperty(this, "id", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "name", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "run_type", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "project_name", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "parent_run", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "child_runs", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "start_time", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "end_time", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "extra", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "tags", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "error", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "serialized", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "inputs", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "outputs", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "reference_example_id", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "client", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "events", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "trace_id", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "dotted_order", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "tracingEnabled", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "execution_order", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "child_execution_order", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + const defaultConfig = RunTree.getDefaultConfig(); + const { metadata, ...config } = originalConfig; + const client = config.client ?? new Client(); + const dedupedMetadata = { + ...metadata, + ...config?.extra?.metadata, + }; + config.extra = { ...config.extra, metadata: dedupedMetadata }; + Object.assign(this, { ...defaultConfig, ...config, client }); + if (!this.trace_id) { + if (this.parent_run) { + this.trace_id = this.parent_run.trace_id ?? this.id; + } + else { + this.trace_id = this.id; + } + } + this.execution_order ??= 1; + this.child_execution_order ??= 1; + if (!this.dotted_order) { + const currentDottedOrder = run_trees_convertToDottedOrderFormat(this.start_time, this.id, this.execution_order); + if (this.parent_run) { + this.dotted_order = + this.parent_run.dotted_order + "." + currentDottedOrder; + } + else { + this.dotted_order = currentDottedOrder; + } + } + } + static fromRunnableConfig(config, props) { + // We only handle the callback manager case for now + const callbackManager = config?.callbacks; + let parentRun; + let projectName; + if (callbackManager) { + const parentRunId = callbackManager?.getParentRunId?.() ?? ""; + const langChainTracer = callbackManager?.handlers?.find((handler) => handler?.name == "langchain_tracer"); + parentRun = langChainTracer?.getRun?.(parentRunId); + projectName = langChainTracer?.projectName; + } + const dedupedTags = [ + ...new Set((parentRun?.tags ?? []).concat(config?.tags ?? [])), + ]; + const dedupedMetadata = { + ...parentRun?.extra?.metadata, + ...config?.metadata, + }; + const rt = new RunTree({ + name: props?.name ?? "", + parent_run: parentRun, + tags: dedupedTags, + extra: { + metadata: dedupedMetadata, + }, + project_name: projectName, + }); + return rt; + } + static getDefaultConfig() { + return { + id: uuid.v4(), + run_type: "chain", + project_name: getEnvironmentVariable("LANGCHAIN_PROJECT") ?? + getEnvironmentVariable("LANGCHAIN_SESSION") ?? // TODO: Deprecate + "default", + child_runs: [], + api_url: getEnvironmentVariable("LANGCHAIN_ENDPOINT") ?? "http://localhost:1984", + api_key: getEnvironmentVariable("LANGCHAIN_API_KEY"), + caller_options: {}, + start_time: Date.now(), + serialized: {}, + inputs: {}, + extra: {}, + }; + } + createChild(config) { + const child_execution_order = this.child_execution_order + 1; + const child = new RunTree({ + ...config, + parent_run: this, + project_name: this.project_name, + client: this.client, + tracingEnabled: this.tracingEnabled, + execution_order: child_execution_order, + child_execution_order: child_execution_order, + }); + // propagate child_execution_order upwards + const visited = new Set(); + let current = this; + while (current != null && !visited.has(current.id)) { + visited.add(current.id); + current.child_execution_order = Math.max(current.child_execution_order, child_execution_order); + current = current.parent_run; + } + this.child_runs.push(child); + return child; + } + async end(outputs, error, endTime = Date.now()) { + this.outputs = this.outputs ?? outputs; + this.error = this.error ?? error; + this.end_time = this.end_time ?? endTime; + } + _convertToCreate(run, runtimeEnv, excludeChildRuns = true) { + const runExtra = run.extra ?? {}; + if (!runExtra.runtime) { + runExtra.runtime = {}; + } + if (runtimeEnv) { + for (const [k, v] of Object.entries(runtimeEnv)) { + if (!runExtra.runtime[k]) { + runExtra.runtime[k] = v; + } + } + } + let child_runs; + let parent_run_id; + if (!excludeChildRuns) { + child_runs = run.child_runs.map((child_run) => this._convertToCreate(child_run, runtimeEnv, excludeChildRuns)); + parent_run_id = undefined; + } + else { + parent_run_id = run.parent_run?.id; + child_runs = []; + } + const persistedRun = { + id: run.id, + name: run.name, + start_time: run.start_time, + end_time: run.end_time, + run_type: run.run_type, + reference_example_id: run.reference_example_id, + extra: runExtra, + serialized: run.serialized, + error: run.error, + inputs: run.inputs, + outputs: run.outputs, + session_name: run.project_name, + child_runs: child_runs, + parent_run_id: parent_run_id, + trace_id: run.trace_id, + dotted_order: run.dotted_order, + tags: run.tags, + }; + return persistedRun; + } + async postRun(excludeChildRuns = true) { + const runtimeEnv = await getRuntimeEnvironment(); + const runCreate = await this._convertToCreate(this, runtimeEnv, true); + await this.client.createRun(runCreate); + if (!excludeChildRuns) { + warnOnce("Posting with excludeChildRuns=false is deprecated and will be removed in a future version."); + for (const childRun of this.child_runs) { + await childRun.postRun(false); + } + } + } + async patchRun() { + const runUpdate = { + end_time: this.end_time, + error: this.error, + inputs: this.inputs, + outputs: this.outputs, + parent_run_id: this.parent_run?.id, + reference_example_id: this.reference_example_id, + extra: this.extra, + events: this.events, + dotted_order: this.dotted_order, + trace_id: this.trace_id, + tags: this.tags, + }; + await this.client.updateRun(this.id, runUpdate); + } + toJSON() { + return this._convertToCreate(this, undefined, false); + } +} +function isRunTree(x) { + return (x !== undefined && + typeof x.createChild === "function" && + typeof x.postRun === "function"); +} +function containsLangChainTracerLike(x) { + return (Array.isArray(x) && + x.some((callback) => { + return (typeof callback.name === "string" && + callback.name === "langchain_tracer"); + })); +} +function isRunnableConfigLike(x) { + // Check that it's an object with a callbacks arg + // that has either a CallbackManagerLike object with a langchain tracer within it + // or an array with a LangChainTracerLike object within it + return (x !== undefined && + typeof x.callbacks === "object" && + // Callback manager with a langchain tracer + (containsLangChainTracerLike(x.callbacks?.handlers) || + // Or it's an array with a LangChainTracerLike object within it + containsLangChainTracerLike(x.callbacks))); +} + +;// CONCATENATED MODULE: ./node_modules/langsmith/dist/index.js + + +// Update using yarn bump-version +const __version__ = "0.1.25"; + +;// CONCATENATED MODULE: ./node_modules/langsmith/index.js + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/tracers/tracer_langchain.js + + + +class tracer_langchain_LangChainTracer extends base_BaseTracer { + constructor(fields = {}) { + super(fields); + Object.defineProperty(this, "name", { + enumerable: true, + configurable: true, + writable: true, + value: "langchain_tracer" + }); + Object.defineProperty(this, "projectName", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "exampleId", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "client", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + const { exampleId, projectName, client } = fields; + this.projectName = + projectName ?? + env_getEnvironmentVariable("LANGCHAIN_PROJECT") ?? + env_getEnvironmentVariable("LANGCHAIN_SESSION"); + this.exampleId = exampleId; + this.client = client ?? new client_Client({}); + } + async _convertToCreate(run, example_id = undefined) { + return { + ...run, + extra: { + ...run.extra, + runtime: await env_getRuntimeEnvironment(), + }, + child_runs: undefined, + session_name: this.projectName, + reference_example_id: run.parent_run_id ? undefined : example_id, + }; + } + async persistRun(_run) { } + async onRunCreate(run) { + const persistedRun = await this._convertToCreate(run, this.exampleId); + await this.client.createRun(persistedRun); + } + async onRunUpdate(run) { + const runUpdate = { + end_time: run.end_time, + error: run.error, + outputs: run.outputs, + events: run.events, + inputs: run.inputs, + trace_id: run.trace_id, + dotted_order: run.dotted_order, + parent_run_id: run.parent_run_id, + }; + await this.client.updateRun(run.id, runUpdate); + } + getRun(id) { + return this.runMap.get(id); + } +} + +// EXTERNAL MODULE: ./node_modules/@langchain/core/dist/messages/index.js + 9 modules +var dist_messages = __webpack_require__(76801); +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/tracers/tracer_langchain_v1.js + + + +/** @deprecated Use LangChainTracer instead. */ +class tracer_langchain_v1_LangChainTracerV1 extends (/* unused pure expression or super */ null && (BaseTracer)) { + constructor() { + super(); + Object.defineProperty(this, "name", { + enumerable: true, + configurable: true, + writable: true, + value: "langchain_tracer" + }); + Object.defineProperty(this, "endpoint", { + enumerable: true, + configurable: true, + writable: true, + value: getEnvironmentVariable("LANGCHAIN_ENDPOINT") || "http://localhost:1984" + }); + Object.defineProperty(this, "headers", { + enumerable: true, + configurable: true, + writable: true, + value: { + "Content-Type": "application/json", + } + }); + Object.defineProperty(this, "session", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + const apiKey = getEnvironmentVariable("LANGCHAIN_API_KEY"); + if (apiKey) { + this.headers["x-api-key"] = apiKey; + } + } + async newSession(sessionName) { + const sessionCreate = { + start_time: Date.now(), + name: sessionName, + }; + const session = await this.persistSession(sessionCreate); + this.session = session; + return session; + } + async loadSession(sessionName) { + const endpoint = `${this.endpoint}/sessions?name=${sessionName}`; + return this._handleSessionResponse(endpoint); + } + async loadDefaultSession() { + const endpoint = `${this.endpoint}/sessions?name=default`; + return this._handleSessionResponse(endpoint); + } + async convertV2RunToRun(run) { + const session = this.session ?? (await this.loadDefaultSession()); + const serialized = run.serialized; + let runResult; + if (run.run_type === "llm") { + const prompts = run.inputs.prompts + ? run.inputs.prompts + : run.inputs.messages.map((x) => getBufferString(x)); + const llmRun = { + uuid: run.id, + start_time: run.start_time, + end_time: run.end_time, + execution_order: run.execution_order, + child_execution_order: run.child_execution_order, + serialized, + type: run.run_type, + session_id: session.id, + prompts, + response: run.outputs, + }; + runResult = llmRun; + } + else if (run.run_type === "chain") { + const child_runs = await Promise.all(run.child_runs.map((child_run) => this.convertV2RunToRun(child_run))); + const chainRun = { + uuid: run.id, + start_time: run.start_time, + end_time: run.end_time, + execution_order: run.execution_order, + child_execution_order: run.child_execution_order, + serialized, + type: run.run_type, + session_id: session.id, + inputs: run.inputs, + outputs: run.outputs, + child_llm_runs: child_runs.filter((child_run) => child_run.type === "llm"), + child_chain_runs: child_runs.filter((child_run) => child_run.type === "chain"), + child_tool_runs: child_runs.filter((child_run) => child_run.type === "tool"), + }; + runResult = chainRun; + } + else if (run.run_type === "tool") { + const child_runs = await Promise.all(run.child_runs.map((child_run) => this.convertV2RunToRun(child_run))); + const toolRun = { + uuid: run.id, + start_time: run.start_time, + end_time: run.end_time, + execution_order: run.execution_order, + child_execution_order: run.child_execution_order, + serialized, + type: run.run_type, + session_id: session.id, + tool_input: run.inputs.input, + output: run.outputs?.output, + action: JSON.stringify(serialized), + child_llm_runs: child_runs.filter((child_run) => child_run.type === "llm"), + child_chain_runs: child_runs.filter((child_run) => child_run.type === "chain"), + child_tool_runs: child_runs.filter((child_run) => child_run.type === "tool"), + }; + runResult = toolRun; + } + else { + throw new Error(`Unknown run type: ${run.run_type}`); + } + return runResult; + } + async persistRun(run) { + let endpoint; + let v1Run; + if (run.run_type !== undefined) { + v1Run = await this.convertV2RunToRun(run); + } + else { + v1Run = run; + } + if (v1Run.type === "llm") { + endpoint = `${this.endpoint}/llm-runs`; + } + else if (v1Run.type === "chain") { + endpoint = `${this.endpoint}/chain-runs`; + } + else { + endpoint = `${this.endpoint}/tool-runs`; + } + const response = await fetch(endpoint, { + method: "POST", + headers: this.headers, + body: JSON.stringify(v1Run), + }); + if (!response.ok) { + console.error(`Failed to persist run: ${response.status} ${response.statusText}`); + } + } + async persistSession(sessionCreate) { + const endpoint = `${this.endpoint}/sessions`; + const response = await fetch(endpoint, { + method: "POST", + headers: this.headers, + body: JSON.stringify(sessionCreate), + }); + if (!response.ok) { + console.error(`Failed to persist session: ${response.status} ${response.statusText}, using default session.`); + return { + id: 1, + ...sessionCreate, + }; + } + return { + id: (await response.json()).id, + ...sessionCreate, + }; + } + async _handleSessionResponse(endpoint) { + const response = await fetch(endpoint, { + method: "GET", + headers: this.headers, + }); + let tracerSession; + if (!response.ok) { + console.error(`Failed to load session: ${response.status} ${response.statusText}`); + tracerSession = { + id: 1, + start_time: Date.now(), + }; + this.session = tracerSession; + return tracerSession; + } + const resp = (await response.json()); + if (resp.length === 0) { + tracerSession = { + id: 1, + start_time: Date.now(), + }; + this.session = tracerSession; + return tracerSession; + } + [tracerSession] = resp; + this.session = tracerSession; + return tracerSession; + } +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/tracers/initialize.js + + +/** + * @deprecated Use the V2 handler instead. + * + * Function that returns an instance of `LangChainTracerV1`. If a session + * is provided, it loads that session into the tracer; otherwise, it loads + * a default session. + * @param session Optional session to load into the tracer. + * @returns An instance of `LangChainTracerV1`. + */ +async function getTracingCallbackHandler(session) { + const tracer = new LangChainTracerV1(); + if (session) { + await tracer.loadSession(session); + } + else { + await tracer.loadDefaultSession(); + } + return tracer; +} +/** + * Function that returns an instance of `LangChainTracer`. It does not + * load any session data. + * @returns An instance of `LangChainTracer`. + */ +async function getTracingV2CallbackHandler() { + return new tracer_langchain_LangChainTracer(); +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/callbacks/promises.js + +let queue; +/** + * Creates a queue using the p-queue library. The queue is configured to + * auto-start and has a concurrency of 1, meaning it will process tasks + * one at a time. + */ +function createQueue() { + const PQueue = true ? p_queue_dist["default"] : p_queue_dist; + return new PQueue({ + autoStart: true, + concurrency: 1, + }); +} +/** + * Consume a promise, either adding it to the queue or waiting for it to resolve + * @param promise Promise to consume + * @param wait Whether to wait for the promise to resolve or resolve immediately + */ +async function consumeCallback(promiseFn, wait) { + if (wait === true) { + await promiseFn(); + } + else { + if (typeof queue === "undefined") { + queue = createQueue(); + } + void queue.add(promiseFn); + } +} +/** + * Waits for all promises in the queue to resolve. If the queue is + * undefined, it immediately resolves a promise. + */ +function awaitAllCallbacks() { + return typeof queue !== "undefined" ? queue.onIdle() : Promise.resolve(); +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/callbacks/manager.js + + + + + + + + +if ( +/* #__PURE__ */ env_getEnvironmentVariable("LANGCHAIN_TRACING_V2") === "true" && + /* #__PURE__ */ env_getEnvironmentVariable("LANGCHAIN_CALLBACKS_BACKGROUND") !== + "true") { + /* #__PURE__ */ console.warn([ + "[WARN]: You have enabled LangSmith tracing without backgrounding callbacks.", + "[WARN]: If you are not using a serverless environment where you must wait for tracing calls to finish,", + `[WARN]: we suggest setting "process.env.LANGCHAIN_CALLBACKS_BACKGROUND=true" to avoid additional latency.`, + ].join("\n")); +} +function parseCallbackConfigArg(arg) { + if (!arg) { + return {}; + } + else if (Array.isArray(arg) || "name" in arg) { + return { callbacks: arg }; + } + else { + return arg; + } +} +/** + * Manage callbacks from different components of LangChain. + */ +class BaseCallbackManager { + setHandler(handler) { + return this.setHandlers([handler]); + } +} +/** + * Base class for run manager in LangChain. + */ +class BaseRunManager { + constructor(runId, handlers, inheritableHandlers, tags, inheritableTags, metadata, inheritableMetadata, _parentRunId) { + Object.defineProperty(this, "runId", { + enumerable: true, + configurable: true, + writable: true, + value: runId + }); + Object.defineProperty(this, "handlers", { + enumerable: true, + configurable: true, + writable: true, + value: handlers + }); + Object.defineProperty(this, "inheritableHandlers", { + enumerable: true, + configurable: true, + writable: true, + value: inheritableHandlers + }); + Object.defineProperty(this, "tags", { + enumerable: true, + configurable: true, + writable: true, + value: tags + }); + Object.defineProperty(this, "inheritableTags", { + enumerable: true, + configurable: true, + writable: true, + value: inheritableTags + }); + Object.defineProperty(this, "metadata", { + enumerable: true, + configurable: true, + writable: true, + value: metadata + }); + Object.defineProperty(this, "inheritableMetadata", { + enumerable: true, + configurable: true, + writable: true, + value: inheritableMetadata + }); + Object.defineProperty(this, "_parentRunId", { + enumerable: true, + configurable: true, + writable: true, + value: _parentRunId + }); + } + async handleText(text) { + await Promise.all(this.handlers.map((handler) => consumeCallback(async () => { + try { + await handler.handleText?.(text, this.runId, this._parentRunId, this.tags); + } + catch (err) { + console.error(`Error in handler ${handler.constructor.name}, handleText: ${err}`); + if (handler.raiseError) { + throw err; + } + } + }, handler.awaitHandlers))); + } +} +/** + * Manages callbacks for retriever runs. + */ +class CallbackManagerForRetrieverRun extends BaseRunManager { + getChild(tag) { + // eslint-disable-next-line @typescript-eslint/no-use-before-define + const manager = new CallbackManager(this.runId); + manager.setHandlers(this.inheritableHandlers); + manager.addTags(this.inheritableTags); + manager.addMetadata(this.inheritableMetadata); + if (tag) { + manager.addTags([tag], false); + } + return manager; + } + async handleRetrieverEnd(documents) { + await Promise.all(this.handlers.map((handler) => consumeCallback(async () => { + if (!handler.ignoreRetriever) { + try { + await handler.handleRetrieverEnd?.(documents, this.runId, this._parentRunId, this.tags); + } + catch (err) { + console.error(`Error in handler ${handler.constructor.name}, handleRetriever`); + if (handler.raiseError) { + throw err; + } + } + } + }, handler.awaitHandlers))); + } + async handleRetrieverError(err) { + await Promise.all(this.handlers.map((handler) => consumeCallback(async () => { + if (!handler.ignoreRetriever) { + try { + await handler.handleRetrieverError?.(err, this.runId, this._parentRunId, this.tags); + } + catch (error) { + console.error(`Error in handler ${handler.constructor.name}, handleRetrieverError: ${error}`); + if (handler.raiseError) { + throw err; + } + } + } + }, handler.awaitHandlers))); + } +} +class CallbackManagerForLLMRun extends BaseRunManager { + async handleLLMNewToken(token, idx, _runId, _parentRunId, _tags, fields) { + await Promise.all(this.handlers.map((handler) => consumeCallback(async () => { + if (!handler.ignoreLLM) { + try { + await handler.handleLLMNewToken?.(token, idx ?? { prompt: 0, completion: 0 }, this.runId, this._parentRunId, this.tags, fields); + } + catch (err) { + console.error(`Error in handler ${handler.constructor.name}, handleLLMNewToken: ${err}`); + if (handler.raiseError) { + throw err; + } + } + } + }, handler.awaitHandlers))); + } + async handleLLMError(err) { + await Promise.all(this.handlers.map((handler) => consumeCallback(async () => { + if (!handler.ignoreLLM) { + try { + await handler.handleLLMError?.(err, this.runId, this._parentRunId, this.tags); + } + catch (err) { + console.error(`Error in handler ${handler.constructor.name}, handleLLMError: ${err}`); + if (handler.raiseError) { + throw err; + } + } + } + }, handler.awaitHandlers))); + } + async handleLLMEnd(output) { + await Promise.all(this.handlers.map((handler) => consumeCallback(async () => { + if (!handler.ignoreLLM) { + try { + await handler.handleLLMEnd?.(output, this.runId, this._parentRunId, this.tags); + } + catch (err) { + console.error(`Error in handler ${handler.constructor.name}, handleLLMEnd: ${err}`); + if (handler.raiseError) { + throw err; + } + } + } + }, handler.awaitHandlers))); + } +} +class CallbackManagerForChainRun extends BaseRunManager { + getChild(tag) { + // eslint-disable-next-line @typescript-eslint/no-use-before-define + const manager = new CallbackManager(this.runId); + manager.setHandlers(this.inheritableHandlers); + manager.addTags(this.inheritableTags); + manager.addMetadata(this.inheritableMetadata); + if (tag) { + manager.addTags([tag], false); + } + return manager; + } + async handleChainError(err, _runId, _parentRunId, _tags, kwargs) { + await Promise.all(this.handlers.map((handler) => consumeCallback(async () => { + if (!handler.ignoreChain) { + try { + await handler.handleChainError?.(err, this.runId, this._parentRunId, this.tags, kwargs); + } + catch (err) { + console.error(`Error in handler ${handler.constructor.name}, handleChainError: ${err}`); + if (handler.raiseError) { + throw err; + } + } + } + }, handler.awaitHandlers))); + } + async handleChainEnd(output, _runId, _parentRunId, _tags, kwargs) { + await Promise.all(this.handlers.map((handler) => consumeCallback(async () => { + if (!handler.ignoreChain) { + try { + await handler.handleChainEnd?.(output, this.runId, this._parentRunId, this.tags, kwargs); + } + catch (err) { + console.error(`Error in handler ${handler.constructor.name}, handleChainEnd: ${err}`); + if (handler.raiseError) { + throw err; + } + } + } + }, handler.awaitHandlers))); + } + async handleAgentAction(action) { + await Promise.all(this.handlers.map((handler) => consumeCallback(async () => { + if (!handler.ignoreAgent) { + try { + await handler.handleAgentAction?.(action, this.runId, this._parentRunId, this.tags); + } + catch (err) { + console.error(`Error in handler ${handler.constructor.name}, handleAgentAction: ${err}`); + if (handler.raiseError) { + throw err; + } + } + } + }, handler.awaitHandlers))); + } + async handleAgentEnd(action) { + await Promise.all(this.handlers.map((handler) => consumeCallback(async () => { + if (!handler.ignoreAgent) { + try { + await handler.handleAgentEnd?.(action, this.runId, this._parentRunId, this.tags); + } + catch (err) { + console.error(`Error in handler ${handler.constructor.name}, handleAgentEnd: ${err}`); + if (handler.raiseError) { + throw err; + } + } + } + }, handler.awaitHandlers))); + } +} +class CallbackManagerForToolRun extends BaseRunManager { + getChild(tag) { + // eslint-disable-next-line @typescript-eslint/no-use-before-define + const manager = new CallbackManager(this.runId); + manager.setHandlers(this.inheritableHandlers); + manager.addTags(this.inheritableTags); + manager.addMetadata(this.inheritableMetadata); + if (tag) { + manager.addTags([tag], false); + } + return manager; + } + async handleToolError(err) { + await Promise.all(this.handlers.map((handler) => consumeCallback(async () => { + if (!handler.ignoreAgent) { + try { + await handler.handleToolError?.(err, this.runId, this._parentRunId, this.tags); + } + catch (err) { + console.error(`Error in handler ${handler.constructor.name}, handleToolError: ${err}`); + if (handler.raiseError) { + throw err; + } + } + } + }, handler.awaitHandlers))); + } + async handleToolEnd(output) { + await Promise.all(this.handlers.map((handler) => consumeCallback(async () => { + if (!handler.ignoreAgent) { + try { + await handler.handleToolEnd?.(output, this.runId, this._parentRunId, this.tags); + } + catch (err) { + console.error(`Error in handler ${handler.constructor.name}, handleToolEnd: ${err}`); + if (handler.raiseError) { + throw err; + } + } + } + }, handler.awaitHandlers))); + } +} +/** + * @example + * ```typescript + * const prompt = PromptTemplate.fromTemplate("What is the answer to {question}?"); + * + * // Example of using LLMChain with OpenAI and a simple prompt + * const chain = new LLMChain({ + * llm: new ChatOpenAI({ temperature: 0.9 }), + * prompt, + * }); + * + * // Running the chain with a single question + * const result = await chain.call({ + * question: "What is the airspeed velocity of an unladen swallow?", + * }); + * console.log("The answer is:", result); + * ``` + */ +class CallbackManager extends BaseCallbackManager { + constructor(parentRunId, options) { + super(); + Object.defineProperty(this, "handlers", { + enumerable: true, + configurable: true, + writable: true, + value: [] + }); + Object.defineProperty(this, "inheritableHandlers", { + enumerable: true, + configurable: true, + writable: true, + value: [] + }); + Object.defineProperty(this, "tags", { + enumerable: true, + configurable: true, + writable: true, + value: [] + }); + Object.defineProperty(this, "inheritableTags", { + enumerable: true, + configurable: true, + writable: true, + value: [] + }); + Object.defineProperty(this, "metadata", { + enumerable: true, + configurable: true, + writable: true, + value: {} + }); + Object.defineProperty(this, "inheritableMetadata", { + enumerable: true, + configurable: true, + writable: true, + value: {} + }); + Object.defineProperty(this, "name", { + enumerable: true, + configurable: true, + writable: true, + value: "callback_manager" + }); + Object.defineProperty(this, "_parentRunId", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.handlers = options?.handlers ?? this.handlers; + this.inheritableHandlers = + options?.inheritableHandlers ?? this.inheritableHandlers; + this.tags = options?.tags ?? this.tags; + this.inheritableTags = options?.inheritableTags ?? this.inheritableTags; + this.metadata = options?.metadata ?? this.metadata; + this.inheritableMetadata = + options?.inheritableMetadata ?? this.inheritableMetadata; + this._parentRunId = parentRunId; + } + /** + * Gets the parent run ID, if any. + * + * @returns The parent run ID. + */ + getParentRunId() { + return this._parentRunId; + } + async handleLLMStart(llm, prompts, runId = undefined, _parentRunId = undefined, extraParams = undefined, _tags = undefined, _metadata = undefined, runName = undefined) { + return Promise.all(prompts.map(async (prompt, idx) => { + // Can't have duplicate runs with the same run ID (if provided) + const runId_ = idx === 0 && runId ? runId : v4(); + await Promise.all(this.handlers.map((handler) => consumeCallback(async () => { + if (!handler.ignoreLLM) { + try { + await handler.handleLLMStart?.(llm, [prompt], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName); + } + catch (err) { + console.error(`Error in handler ${handler.constructor.name}, handleLLMStart: ${err}`); + if (handler.raiseError) { + throw err; + } + } + } + }, handler.awaitHandlers))); + return new CallbackManagerForLLMRun(runId_, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId); + })); + } + async handleChatModelStart(llm, messages, runId = undefined, _parentRunId = undefined, extraParams = undefined, _tags = undefined, _metadata = undefined, runName = undefined) { + return Promise.all(messages.map(async (messageGroup, idx) => { + // Can't have duplicate runs with the same run ID (if provided) + const runId_ = idx === 0 && runId ? runId : v4(); + await Promise.all(this.handlers.map((handler) => consumeCallback(async () => { + if (!handler.ignoreLLM) { + try { + if (handler.handleChatModelStart) { + await handler.handleChatModelStart?.(llm, [messageGroup], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName); + } + else if (handler.handleLLMStart) { + const messageString = (0,dist_messages/* getBufferString */.zs)(messageGroup); + await handler.handleLLMStart?.(llm, [messageString], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName); + } + } + catch (err) { + console.error(`Error in handler ${handler.constructor.name}, handleLLMStart: ${err}`); + if (handler.raiseError) { + throw err; + } + } + } + }, handler.awaitHandlers))); + return new CallbackManagerForLLMRun(runId_, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId); + })); + } + async handleChainStart(chain, inputs, runId = v4(), runType = undefined, _tags = undefined, _metadata = undefined, runName = undefined) { + await Promise.all(this.handlers.map((handler) => consumeCallback(async () => { + if (!handler.ignoreChain) { + try { + await handler.handleChainStart?.(chain, inputs, runId, this._parentRunId, this.tags, this.metadata, runType, runName); + } + catch (err) { + console.error(`Error in handler ${handler.constructor.name}, handleChainStart: ${err}`); + if (handler.raiseError) { + throw err; + } + } + } + }, handler.awaitHandlers))); + return new CallbackManagerForChainRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId); + } + async handleToolStart(tool, input, runId = v4(), _parentRunId = undefined, _tags = undefined, _metadata = undefined, runName = undefined) { + await Promise.all(this.handlers.map((handler) => consumeCallback(async () => { + if (!handler.ignoreAgent) { + try { + await handler.handleToolStart?.(tool, input, runId, this._parentRunId, this.tags, this.metadata, runName); + } + catch (err) { + console.error(`Error in handler ${handler.constructor.name}, handleToolStart: ${err}`); + if (handler.raiseError) { + throw err; + } + } + } + }, handler.awaitHandlers))); + return new CallbackManagerForToolRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId); + } + async handleRetrieverStart(retriever, query, runId = v4(), _parentRunId = undefined, _tags = undefined, _metadata = undefined, runName = undefined) { + await Promise.all(this.handlers.map((handler) => consumeCallback(async () => { + if (!handler.ignoreRetriever) { + try { + await handler.handleRetrieverStart?.(retriever, query, runId, this._parentRunId, this.tags, this.metadata, runName); + } + catch (err) { + console.error(`Error in handler ${handler.constructor.name}, handleRetrieverStart: ${err}`); + if (handler.raiseError) { + throw err; + } + } + } + }, handler.awaitHandlers))); + return new CallbackManagerForRetrieverRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId); + } + addHandler(handler, inherit = true) { + this.handlers.push(handler); + if (inherit) { + this.inheritableHandlers.push(handler); + } + } + removeHandler(handler) { + this.handlers = this.handlers.filter((_handler) => _handler !== handler); + this.inheritableHandlers = this.inheritableHandlers.filter((_handler) => _handler !== handler); + } + setHandlers(handlers, inherit = true) { + this.handlers = []; + this.inheritableHandlers = []; + for (const handler of handlers) { + this.addHandler(handler, inherit); + } + } + addTags(tags, inherit = true) { + this.removeTags(tags); // Remove duplicates + this.tags.push(...tags); + if (inherit) { + this.inheritableTags.push(...tags); + } + } + removeTags(tags) { + this.tags = this.tags.filter((tag) => !tags.includes(tag)); + this.inheritableTags = this.inheritableTags.filter((tag) => !tags.includes(tag)); + } + addMetadata(metadata, inherit = true) { + this.metadata = { ...this.metadata, ...metadata }; + if (inherit) { + this.inheritableMetadata = { ...this.inheritableMetadata, ...metadata }; + } + } + removeMetadata(metadata) { + for (const key of Object.keys(metadata)) { + delete this.metadata[key]; + delete this.inheritableMetadata[key]; + } + } + copy(additionalHandlers = [], inherit = true) { + const manager = new CallbackManager(this._parentRunId); + for (const handler of this.handlers) { + const inheritable = this.inheritableHandlers.includes(handler); + manager.addHandler(handler, inheritable); + } + for (const tag of this.tags) { + const inheritable = this.inheritableTags.includes(tag); + manager.addTags([tag], inheritable); + } + for (const key of Object.keys(this.metadata)) { + const inheritable = Object.keys(this.inheritableMetadata).includes(key); + manager.addMetadata({ [key]: this.metadata[key] }, inheritable); + } + for (const handler of additionalHandlers) { + if ( + // Prevent multiple copies of console_callback_handler + manager.handlers + .filter((h) => h.name === "console_callback_handler") + .some((h) => h.name === handler.name)) { + continue; + } + manager.addHandler(handler, inherit); + } + return manager; + } + static fromHandlers(handlers) { + class Handler extends BaseCallbackHandler { + constructor() { + super(); + Object.defineProperty(this, "name", { + enumerable: true, + configurable: true, + writable: true, + value: v4() + }); + Object.assign(this, handlers); + } + } + const manager = new this(); + manager.addHandler(new Handler()); + return manager; + } + static async configure(inheritableHandlers, localHandlers, inheritableTags, localTags, inheritableMetadata, localMetadata, options) { + let callbackManager; + if (inheritableHandlers || localHandlers) { + if (Array.isArray(inheritableHandlers) || !inheritableHandlers) { + callbackManager = new CallbackManager(); + callbackManager.setHandlers(inheritableHandlers?.map(ensureHandler) ?? [], true); + } + else { + callbackManager = inheritableHandlers; + } + callbackManager = callbackManager.copy(Array.isArray(localHandlers) + ? localHandlers.map(ensureHandler) + : localHandlers?.handlers, false); + } + const verboseEnabled = env_getEnvironmentVariable("LANGCHAIN_VERBOSE") === "true" || + options?.verbose; + const tracingV2Enabled = env_getEnvironmentVariable("LANGCHAIN_TRACING_V2") === "true"; + const tracingEnabled = tracingV2Enabled || + (env_getEnvironmentVariable("LANGCHAIN_TRACING") ?? false); + if (verboseEnabled || tracingEnabled) { + if (!callbackManager) { + callbackManager = new CallbackManager(); + } + if (verboseEnabled && + !callbackManager.handlers.some((handler) => handler.name === ConsoleCallbackHandler.prototype.name)) { + const consoleHandler = new ConsoleCallbackHandler(); + callbackManager.addHandler(consoleHandler, true); + } + if (tracingEnabled && + !callbackManager.handlers.some((handler) => handler.name === "langchain_tracer")) { + if (tracingV2Enabled) { + callbackManager.addHandler(await getTracingV2CallbackHandler(), true); + } + } + } + if (inheritableTags || localTags) { + if (callbackManager) { + callbackManager.addTags(inheritableTags ?? []); + callbackManager.addTags(localTags ?? [], false); + } + } + if (inheritableMetadata || localMetadata) { + if (callbackManager) { + callbackManager.addMetadata(inheritableMetadata ?? {}); + callbackManager.addMetadata(localMetadata ?? {}, false); + } + } + return callbackManager; + } +} +function ensureHandler(handler) { + if ("name" in handler) { + return handler; + } + return BaseCallbackHandler.fromMethods(handler); +} +/** + * @example + * ```typescript + * const prompt = PromptTemplate.fromTemplate(`What is the answer to {question}?`); + * + * // Example of using LLMChain to process a series of questions + * const chain = new LLMChain({ + * llm: new ChatOpenAI({ temperature: 0.9 }), + * prompt, + * }); + * + * // Process questions using the chain + * const processQuestions = async (questions) => { + * for (const question of questions) { + * const result = await chain.call({ question }); + * console.log(result); + * } + * }; + * + * // Example questions + * const questions = [ + * "What is your name?", + * "What is your quest?", + * "What is your favorite color?", + * ]; + * + * // Run the example + * processQuestions(questions).catch(console.error); + * + * ``` + */ +class TraceGroup { + constructor(groupName, options) { + Object.defineProperty(this, "groupName", { + enumerable: true, + configurable: true, + writable: true, + value: groupName + }); + Object.defineProperty(this, "options", { + enumerable: true, + configurable: true, + writable: true, + value: options + }); + Object.defineProperty(this, "runManager", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + } + async getTraceGroupCallbackManager(group_name, inputs, options) { + const cb = new LangChainTracer(options); + const cm = await CallbackManager.configure([cb]); + const runManager = await cm?.handleChainStart({ + lc: 1, + type: "not_implemented", + id: ["langchain", "callbacks", "groups", group_name], + }, inputs ?? {}); + if (!runManager) { + throw new Error("Failed to create run group callback manager."); + } + return runManager; + } + async start(inputs) { + if (!this.runManager) { + this.runManager = await this.getTraceGroupCallbackManager(this.groupName, inputs, this.options); + } + return this.runManager.getChild(); + } + async error(err) { + if (this.runManager) { + await this.runManager.handleChainError(err); + this.runManager = undefined; + } + } + async end(output) { + if (this.runManager) { + await this.runManager.handleChainEnd(output ?? {}); + this.runManager = undefined; + } + } +} +// eslint-disable-next-line @typescript-eslint/no-explicit-any +function manager_coerceToDict(value, defaultKey) { + return value && !Array.isArray(value) && typeof value === "object" + ? value + : { [defaultKey]: value }; +} +// eslint-disable-next-line @typescript-eslint/no-explicit-any +async function traceAsGroup(groupOptions, enclosedCode, ...args) { + const traceGroup = new TraceGroup(groupOptions.name, groupOptions); + const callbackManager = await traceGroup.start({ ...args }); + try { + const result = await enclosedCode(callbackManager, ...args); + await traceGroup.end(manager_coerceToDict(result, "output")); + return result; + } + catch (err) { + await traceGroup.error(err); + throw err; + } +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/utils/fast-json-patch/src/helpers.js +// @ts-nocheck +// Inlined because of ESM import issues +/*! + * https://github.com/Starcounter-Jack/JSON-Patch + * (c) 2017-2022 Joachim Wester + * MIT licensed + */ +const _hasOwnProperty = Object.prototype.hasOwnProperty; +function helpers_hasOwnProperty(obj, key) { + return _hasOwnProperty.call(obj, key); +} +function helpers_objectKeys(obj) { + if (Array.isArray(obj)) { + const keys = new Array(obj.length); + for (let k = 0; k < keys.length; k++) { + keys[k] = "" + k; + } + return keys; + } + if (Object.keys) { + return Object.keys(obj); + } + let keys = []; + for (let i in obj) { + if (helpers_hasOwnProperty(obj, i)) { + keys.push(i); + } + } + return keys; +} +/** + * Deeply clone the object. + * https://jsperf.com/deep-copy-vs-json-stringify-json-parse/25 (recursiveDeepCopy) + * @param {any} obj value to clone + * @return {any} cloned obj + */ +function helpers_deepClone(obj) { + switch (typeof obj) { + case "object": + return JSON.parse(JSON.stringify(obj)); //Faster than ES5 clone - http://jsperf.com/deep-cloning-of-objects/5 + case "undefined": + return null; //this is how JSON.stringify behaves for array items + default: + return obj; //no need to clone primitives + } +} +//3x faster than cached /^\d+$/.test(str) +function isInteger(str) { + let i = 0; + const len = str.length; + let charCode; + while (i < len) { + charCode = str.charCodeAt(i); + if (charCode >= 48 && charCode <= 57) { + i++; + continue; + } + return false; + } + return true; +} +/** + * Escapes a json pointer path + * @param path The raw pointer + * @return the Escaped path + */ +function helpers_escapePathComponent(path) { + if (path.indexOf("/") === -1 && path.indexOf("~") === -1) + return path; + return path.replace(/~/g, "~0").replace(/\//g, "~1"); +} +/** + * Unescapes a json pointer path + * @param path The escaped pointer + * @return The unescaped path + */ +function unescapePathComponent(path) { + return path.replace(/~1/g, "/").replace(/~0/g, "~"); +} +function _getPathRecursive(root, obj) { + let found; + for (let key in root) { + if (helpers_hasOwnProperty(root, key)) { + if (root[key] === obj) { + return helpers_escapePathComponent(key) + "/"; + } + else if (typeof root[key] === "object") { + found = _getPathRecursive(root[key], obj); + if (found != "") { + return helpers_escapePathComponent(key) + "/" + found; + } + } + } + } + return ""; +} +function getPath(root, obj) { + if (root === obj) { + return "/"; + } + const path = _getPathRecursive(root, obj); + if (path === "") { + throw new Error("Object not found in root"); + } + return `/${path}`; +} +/** + * Recursively checks whether an object has any undefined values inside. + */ +function hasUndefined(obj) { + if (obj === undefined) { + return true; + } + if (obj) { + if (Array.isArray(obj)) { + for (let i = 0, len = obj.length; i < len; i++) { + if (hasUndefined(obj[i])) { + return true; + } + } + } + else if (typeof obj === "object") { + const objKeys = helpers_objectKeys(obj); + const objKeysLength = objKeys.length; + for (var i = 0; i < objKeysLength; i++) { + if (hasUndefined(obj[objKeys[i]])) { + return true; + } + } + } + } + return false; +} +function patchErrorMessageFormatter(message, args) { + const messageParts = [message]; + for (const key in args) { + const value = typeof args[key] === "object" + ? JSON.stringify(args[key], null, 2) + : args[key]; // pretty print + if (typeof value !== "undefined") { + messageParts.push(`${key}: ${value}`); + } + } + return messageParts.join("\n"); +} +class PatchError extends Error { + constructor(message, name, index, operation, tree) { + super(patchErrorMessageFormatter(message, { name, index, operation, tree })); + Object.defineProperty(this, "name", { + enumerable: true, + configurable: true, + writable: true, + value: name + }); + Object.defineProperty(this, "index", { + enumerable: true, + configurable: true, + writable: true, + value: index + }); + Object.defineProperty(this, "operation", { + enumerable: true, + configurable: true, + writable: true, + value: operation + }); + Object.defineProperty(this, "tree", { + enumerable: true, + configurable: true, + writable: true, + value: tree + }); + Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain, see https://stackoverflow.com/a/48342359 + this.message = patchErrorMessageFormatter(message, { + name, + index, + operation, + tree, + }); + } +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/utils/fast-json-patch/src/core.js +// @ts-nocheck + +const JsonPatchError = PatchError; +const deepClone = helpers_deepClone; +/* We use a Javascript hash to store each + function. Each hash entry (property) uses + the operation identifiers specified in rfc6902. + In this way, we can map each patch operation + to its dedicated function in efficient way. + */ +/* The operations applicable to an object */ +const objOps = { + add: function (obj, key, document) { + obj[key] = this.value; + return { newDocument: document }; + }, + remove: function (obj, key, document) { + var removed = obj[key]; + delete obj[key]; + return { newDocument: document, removed }; + }, + replace: function (obj, key, document) { + var removed = obj[key]; + obj[key] = this.value; + return { newDocument: document, removed }; + }, + move: function (obj, key, document) { + /* in case move target overwrites an existing value, + return the removed value, this can be taxing performance-wise, + and is potentially unneeded */ + let removed = getValueByPointer(document, this.path); + if (removed) { + removed = helpers_deepClone(removed); + } + const originalValue = applyOperation(document, { + op: "remove", + path: this.from, + }).removed; + applyOperation(document, { + op: "add", + path: this.path, + value: originalValue, + }); + return { newDocument: document, removed }; + }, + copy: function (obj, key, document) { + const valueToCopy = getValueByPointer(document, this.from); + // enforce copy by value so further operations don't affect source (see issue #177) + applyOperation(document, { + op: "add", + path: this.path, + value: helpers_deepClone(valueToCopy), + }); + return { newDocument: document }; + }, + test: function (obj, key, document) { + return { newDocument: document, test: _areEquals(obj[key], this.value) }; + }, + _get: function (obj, key, document) { + this.value = obj[key]; + return { newDocument: document }; + }, +}; +/* The operations applicable to an array. Many are the same as for the object */ +var arrOps = { + add: function (arr, i, document) { + if (isInteger(i)) { + arr.splice(i, 0, this.value); + } + else { + // array props + arr[i] = this.value; + } + // this may be needed when using '-' in an array + return { newDocument: document, index: i }; + }, + remove: function (arr, i, document) { + var removedList = arr.splice(i, 1); + return { newDocument: document, removed: removedList[0] }; + }, + replace: function (arr, i, document) { + var removed = arr[i]; + arr[i] = this.value; + return { newDocument: document, removed }; + }, + move: objOps.move, + copy: objOps.copy, + test: objOps.test, + _get: objOps._get, +}; +/** + * Retrieves a value from a JSON document by a JSON pointer. + * Returns the value. + * + * @param document The document to get the value from + * @param pointer an escaped JSON pointer + * @return The retrieved value + */ +function getValueByPointer(document, pointer) { + if (pointer == "") { + return document; + } + var getOriginalDestination = { op: "_get", path: pointer }; + applyOperation(document, getOriginalDestination); + return getOriginalDestination.value; +} +/** + * Apply a single JSON Patch Operation on a JSON document. + * Returns the {newDocument, result} of the operation. + * It modifies the `document` and `operation` objects - it gets the values by reference. + * If you would like to avoid touching your values, clone them: + * `jsonpatch.applyOperation(document, jsonpatch._deepClone(operation))`. + * + * @param document The document to patch + * @param operation The operation to apply + * @param validateOperation `false` is without validation, `true` to use default jsonpatch's validation, or you can pass a `validateOperation` callback to be used for validation. + * @param mutateDocument Whether to mutate the original document or clone it before applying + * @param banPrototypeModifications Whether to ban modifications to `__proto__`, defaults to `true`. + * @return `{newDocument, result}` after the operation + */ +function applyOperation(document, operation, validateOperation = false, mutateDocument = true, banPrototypeModifications = true, index = 0) { + if (validateOperation) { + if (typeof validateOperation == "function") { + validateOperation(operation, 0, document, operation.path); + } + else { + validator(operation, 0); + } + } + /* ROOT OPERATIONS */ + if (operation.path === "") { + let returnValue = { newDocument: document }; + if (operation.op === "add") { + returnValue.newDocument = operation.value; + return returnValue; + } + else if (operation.op === "replace") { + returnValue.newDocument = operation.value; + returnValue.removed = document; //document we removed + return returnValue; + } + else if (operation.op === "move" || operation.op === "copy") { + // it's a move or copy to root + returnValue.newDocument = getValueByPointer(document, operation.from); // get the value by json-pointer in `from` field + if (operation.op === "move") { + // report removed item + returnValue.removed = document; + } + return returnValue; + } + else if (operation.op === "test") { + returnValue.test = _areEquals(document, operation.value); + if (returnValue.test === false) { + throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document); + } + returnValue.newDocument = document; + return returnValue; + } + else if (operation.op === "remove") { + // a remove on root + returnValue.removed = document; + returnValue.newDocument = null; + return returnValue; + } + else if (operation.op === "_get") { + operation.value = document; + return returnValue; + } + else { + /* bad operation */ + if (validateOperation) { + throw new JsonPatchError("Operation `op` property is not one of operations defined in RFC-6902", "OPERATION_OP_INVALID", index, operation, document); + } + else { + return returnValue; + } + } + } /* END ROOT OPERATIONS */ + else { + if (!mutateDocument) { + document = helpers_deepClone(document); + } + const path = operation.path || ""; + const keys = path.split("/"); + let obj = document; + let t = 1; //skip empty element - http://jsperf.com/to-shift-or-not-to-shift + let len = keys.length; + let existingPathFragment = undefined; + let key; + let validateFunction; + if (typeof validateOperation == "function") { + validateFunction = validateOperation; + } + else { + validateFunction = validator; + } + while (true) { + key = keys[t]; + if (key && key.indexOf("~") != -1) { + key = unescapePathComponent(key); + } + if (banPrototypeModifications && + (key == "__proto__" || + (key == "prototype" && t > 0 && keys[t - 1] == "constructor"))) { + throw new TypeError("JSON-Patch: modifying `__proto__` or `constructor/prototype` prop is banned for security reasons, if this was on purpose, please set `banPrototypeModifications` flag false and pass it to this function. More info in fast-json-patch README"); + } + if (validateOperation) { + if (existingPathFragment === undefined) { + if (obj[key] === undefined) { + existingPathFragment = keys.slice(0, t).join("/"); + } + else if (t == len - 1) { + existingPathFragment = operation.path; + } + if (existingPathFragment !== undefined) { + validateFunction(operation, 0, document, existingPathFragment); + } + } + } + t++; + if (Array.isArray(obj)) { + if (key === "-") { + key = obj.length; + } + else { + if (validateOperation && !isInteger(key)) { + throw new JsonPatchError("Expected an unsigned base-10 integer value, making the new referenced value the array element with the zero-based index", "OPERATION_PATH_ILLEGAL_ARRAY_INDEX", index, operation, document); + } // only parse key when it's an integer for `arr.prop` to work + else if (isInteger(key)) { + key = ~~key; + } + } + if (t >= len) { + if (validateOperation && operation.op === "add" && key > obj.length) { + throw new JsonPatchError("The specified index MUST NOT be greater than the number of elements in the array", "OPERATION_VALUE_OUT_OF_BOUNDS", index, operation, document); + } + const returnValue = arrOps[operation.op].call(operation, obj, key, document); // Apply patch + if (returnValue.test === false) { + throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document); + } + return returnValue; + } + } + else { + if (t >= len) { + const returnValue = objOps[operation.op].call(operation, obj, key, document); // Apply patch + if (returnValue.test === false) { + throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document); + } + return returnValue; + } + } + obj = obj[key]; + // If we have more keys in the path, but the next value isn't a non-null object, + // throw an OPERATION_PATH_UNRESOLVABLE error instead of iterating again. + if (validateOperation && t < len && (!obj || typeof obj !== "object")) { + throw new JsonPatchError("Cannot perform operation at the desired path", "OPERATION_PATH_UNRESOLVABLE", index, operation, document); + } + } + } +} +/** + * Apply a full JSON Patch array on a JSON document. + * Returns the {newDocument, result} of the patch. + * It modifies the `document` object and `patch` - it gets the values by reference. + * If you would like to avoid touching your values, clone them: + * `jsonpatch.applyPatch(document, jsonpatch._deepClone(patch))`. + * + * @param document The document to patch + * @param patch The patch to apply + * @param validateOperation `false` is without validation, `true` to use default jsonpatch's validation, or you can pass a `validateOperation` callback to be used for validation. + * @param mutateDocument Whether to mutate the original document or clone it before applying + * @param banPrototypeModifications Whether to ban modifications to `__proto__`, defaults to `true`. + * @return An array of `{newDocument, result}` after the patch + */ +function core_applyPatch(document, patch, validateOperation, mutateDocument = true, banPrototypeModifications = true) { + if (validateOperation) { + if (!Array.isArray(patch)) { + throw new JsonPatchError("Patch sequence must be an array", "SEQUENCE_NOT_AN_ARRAY"); + } + } + if (!mutateDocument) { + document = helpers_deepClone(document); + } + const results = new Array(patch.length); + for (let i = 0, length = patch.length; i < length; i++) { + // we don't need to pass mutateDocument argument because if it was true, we already deep cloned the object, we'll just pass `true` + results[i] = applyOperation(document, patch[i], validateOperation, true, banPrototypeModifications, i); + document = results[i].newDocument; // in case root was replaced + } + results.newDocument = document; + return results; +} +/** + * Apply a single JSON Patch Operation on a JSON document. + * Returns the updated document. + * Suitable as a reducer. + * + * @param document The document to patch + * @param operation The operation to apply + * @return The updated document + */ +function applyReducer(document, operation, index) { + const operationResult = applyOperation(document, operation); + if (operationResult.test === false) { + // failed test + throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document); + } + return operationResult.newDocument; +} +/** + * Validates a single operation. Called from `jsonpatch.validate`. Throws `JsonPatchError` in case of an error. + * @param {object} operation - operation object (patch) + * @param {number} index - index of operation in the sequence + * @param {object} [document] - object where the operation is supposed to be applied + * @param {string} [existingPathFragment] - comes along with `document` + */ +function validator(operation, index, document, existingPathFragment) { + if (typeof operation !== "object" || + operation === null || + Array.isArray(operation)) { + throw new JsonPatchError("Operation is not an object", "OPERATION_NOT_AN_OBJECT", index, operation, document); + } + else if (!objOps[operation.op]) { + throw new JsonPatchError("Operation `op` property is not one of operations defined in RFC-6902", "OPERATION_OP_INVALID", index, operation, document); + } + else if (typeof operation.path !== "string") { + throw new JsonPatchError("Operation `path` property is not a string", "OPERATION_PATH_INVALID", index, operation, document); + } + else if (operation.path.indexOf("/") !== 0 && operation.path.length > 0) { + // paths that aren't empty string should start with "/" + throw new JsonPatchError('Operation `path` property must start with "/"', "OPERATION_PATH_INVALID", index, operation, document); + } + else if ((operation.op === "move" || operation.op === "copy") && + typeof operation.from !== "string") { + throw new JsonPatchError("Operation `from` property is not present (applicable in `move` and `copy` operations)", "OPERATION_FROM_REQUIRED", index, operation, document); + } + else if ((operation.op === "add" || + operation.op === "replace" || + operation.op === "test") && + operation.value === undefined) { + throw new JsonPatchError("Operation `value` property is not present (applicable in `add`, `replace` and `test` operations)", "OPERATION_VALUE_REQUIRED", index, operation, document); + } + else if ((operation.op === "add" || + operation.op === "replace" || + operation.op === "test") && + hasUndefined(operation.value)) { + throw new JsonPatchError("Operation `value` property is not present (applicable in `add`, `replace` and `test` operations)", "OPERATION_VALUE_CANNOT_CONTAIN_UNDEFINED", index, operation, document); + } + else if (document) { + if (operation.op == "add") { + var pathLen = operation.path.split("/").length; + var existingPathLen = existingPathFragment.split("/").length; + if (pathLen !== existingPathLen + 1 && pathLen !== existingPathLen) { + throw new JsonPatchError("Cannot perform an `add` operation at the desired path", "OPERATION_PATH_CANNOT_ADD", index, operation, document); + } + } + else if (operation.op === "replace" || + operation.op === "remove" || + operation.op === "_get") { + if (operation.path !== existingPathFragment) { + throw new JsonPatchError("Cannot perform the operation at a path that does not exist", "OPERATION_PATH_UNRESOLVABLE", index, operation, document); + } + } + else if (operation.op === "move" || operation.op === "copy") { + var existingValue = { + op: "_get", + path: operation.from, + value: undefined, + }; + var error = core_validate([existingValue], document); + if (error && error.name === "OPERATION_PATH_UNRESOLVABLE") { + throw new JsonPatchError("Cannot perform the operation from a path that does not exist", "OPERATION_FROM_UNRESOLVABLE", index, operation, document); + } + } + } +} +/** + * Validates a sequence of operations. If `document` parameter is provided, the sequence is additionally validated against the object document. + * If error is encountered, returns a JsonPatchError object + * @param sequence + * @param document + * @returns {JsonPatchError|undefined} + */ +function core_validate(sequence, document, externalValidator) { + try { + if (!Array.isArray(sequence)) { + throw new JsonPatchError("Patch sequence must be an array", "SEQUENCE_NOT_AN_ARRAY"); + } + if (document) { + //clone document and sequence so that we can safely try applying operations + core_applyPatch(helpers_deepClone(document), helpers_deepClone(sequence), externalValidator || true); + } + else { + externalValidator = externalValidator || validator; + for (var i = 0; i < sequence.length; i++) { + externalValidator(sequence[i], i, document, undefined); + } + } + } + catch (e) { + if (e instanceof JsonPatchError) { + return e; + } + else { + throw e; + } + } +} +// based on https://github.com/epoberezkin/fast-deep-equal +// MIT License +// Copyright (c) 2017 Evgeny Poberezkin +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. +function _areEquals(a, b) { + if (a === b) + return true; + if (a && b && typeof a == "object" && typeof b == "object") { + var arrA = Array.isArray(a), arrB = Array.isArray(b), i, length, key; + if (arrA && arrB) { + length = a.length; + if (length != b.length) + return false; + for (i = length; i-- !== 0;) + if (!_areEquals(a[i], b[i])) + return false; + return true; + } + if (arrA != arrB) + return false; + var keys = Object.keys(a); + length = keys.length; + if (length !== Object.keys(b).length) + return false; + for (i = length; i-- !== 0;) + if (!b.hasOwnProperty(keys[i])) + return false; + for (i = length; i-- !== 0;) { + key = keys[i]; + if (!_areEquals(a[key], b[key])) + return false; + } + return true; + } + return a !== a && b !== b; +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/utils/fast-json-patch/src/duplex.js +// @ts-nocheck +// Inlined because of ESM import issues +/*! + * https://github.com/Starcounter-Jack/JSON-Patch + * (c) 2013-2021 Joachim Wester + * MIT license + */ + + +var beforeDict = new WeakMap(); +class Mirror { + constructor(obj) { + Object.defineProperty(this, "obj", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "observers", { + enumerable: true, + configurable: true, + writable: true, + value: new Map() + }); + Object.defineProperty(this, "value", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.obj = obj; + } +} +class ObserverInfo { + constructor(callback, observer) { + Object.defineProperty(this, "callback", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "observer", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.callback = callback; + this.observer = observer; + } +} +function getMirror(obj) { + return beforeDict.get(obj); +} +function getObserverFromMirror(mirror, callback) { + return mirror.observers.get(callback); +} +function removeObserverFromMirror(mirror, observer) { + mirror.observers.delete(observer.callback); +} +/** + * Detach an observer from an object + */ +function unobserve(root, observer) { + observer.unobserve(); +} +/** + * Observes changes made to an object, which can then be retrieved using generate + */ +function observe(obj, callback) { + var patches = []; + var observer; + var mirror = getMirror(obj); + if (!mirror) { + mirror = new Mirror(obj); + beforeDict.set(obj, mirror); + } + else { + const observerInfo = getObserverFromMirror(mirror, callback); + observer = observerInfo && observerInfo.observer; + } + if (observer) { + return observer; + } + observer = {}; + mirror.value = _deepClone(obj); + if (callback) { + observer.callback = callback; + observer.next = null; + var dirtyCheck = () => { + generate(observer); + }; + var fastCheck = () => { + clearTimeout(observer.next); + observer.next = setTimeout(dirtyCheck); + }; + if (typeof window !== "undefined") { + //not Node + window.addEventListener("mouseup", fastCheck); + window.addEventListener("keyup", fastCheck); + window.addEventListener("mousedown", fastCheck); + window.addEventListener("keydown", fastCheck); + window.addEventListener("change", fastCheck); + } + } + observer.patches = patches; + observer.object = obj; + observer.unobserve = () => { + generate(observer); + clearTimeout(observer.next); + removeObserverFromMirror(mirror, observer); + if (typeof window !== "undefined") { + window.removeEventListener("mouseup", fastCheck); + window.removeEventListener("keyup", fastCheck); + window.removeEventListener("mousedown", fastCheck); + window.removeEventListener("keydown", fastCheck); + window.removeEventListener("change", fastCheck); + } + }; + mirror.observers.set(callback, new ObserverInfo(callback, observer)); + return observer; +} +/** + * Generate an array of patches from an observer + */ +function generate(observer, invertible = false) { + var mirror = beforeDict.get(observer.object); + _generate(mirror.value, observer.object, observer.patches, "", invertible); + if (observer.patches.length) { + applyPatch(mirror.value, observer.patches); + } + var temp = observer.patches; + if (temp.length > 0) { + observer.patches = []; + if (observer.callback) { + observer.callback(temp); + } + } + return temp; +} +// Dirty check if obj is different from mirror, generate patches and update mirror +function _generate(mirror, obj, patches, path, invertible) { + if (obj === mirror) { + return; + } + if (typeof obj.toJSON === "function") { + obj = obj.toJSON(); + } + var newKeys = _objectKeys(obj); + var oldKeys = _objectKeys(mirror); + var changed = false; + var deleted = false; + //if ever "move" operation is implemented here, make sure this test runs OK: "should not generate the same patch twice (move)" + for (var t = oldKeys.length - 1; t >= 0; t--) { + var key = oldKeys[t]; + var oldVal = mirror[key]; + if (hasOwnProperty(obj, key) && + !(obj[key] === undefined && + oldVal !== undefined && + Array.isArray(obj) === false)) { + var newVal = obj[key]; + if (typeof oldVal == "object" && + oldVal != null && + typeof newVal == "object" && + newVal != null && + Array.isArray(oldVal) === Array.isArray(newVal)) { + _generate(oldVal, newVal, patches, path + "/" + escapePathComponent(key), invertible); + } + else { + if (oldVal !== newVal) { + changed = true; + if (invertible) { + patches.push({ + op: "test", + path: path + "/" + escapePathComponent(key), + value: _deepClone(oldVal), + }); + } + patches.push({ + op: "replace", + path: path + "/" + escapePathComponent(key), + value: _deepClone(newVal), + }); + } + } + } + else if (Array.isArray(mirror) === Array.isArray(obj)) { + if (invertible) { + patches.push({ + op: "test", + path: path + "/" + escapePathComponent(key), + value: _deepClone(oldVal), + }); + } + patches.push({ + op: "remove", + path: path + "/" + escapePathComponent(key), + }); + deleted = true; // property has been deleted + } + else { + if (invertible) { + patches.push({ op: "test", path, value: mirror }); + } + patches.push({ op: "replace", path, value: obj }); + changed = true; + } + } + if (!deleted && newKeys.length == oldKeys.length) { + return; + } + for (var t = 0; t < newKeys.length; t++) { + var key = newKeys[t]; + if (!hasOwnProperty(mirror, key) && obj[key] !== undefined) { + patches.push({ + op: "add", + path: path + "/" + escapePathComponent(key), + value: _deepClone(obj[key]), + }); + } + } +} +/** + * Create an array of patches from the differences in two objects + */ +function compare(tree1, tree2, invertible = false) { + var patches = []; + _generate(tree1, tree2, patches, "", invertible); + return patches; +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/utils/fast-json-patch/index.js + + + +/** + * Default export for backwards compat + */ + + +/* harmony default export */ const fast_json_patch = ({ + ...core_namespaceObject, + // ...duplex, + JsonPatchError: PatchError, + deepClone: helpers_deepClone, + escapePathComponent: helpers_escapePathComponent, + unescapePathComponent: unescapePathComponent, +}); + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/singletons/index.js +/* eslint-disable @typescript-eslint/no-explicit-any */ +class MockAsyncLocalStorage { + getStore() { + return undefined; + } + run(_store, callback) { + return callback(); + } +} +class AsyncLocalStorageProvider { + constructor() { + Object.defineProperty(this, "asyncLocalStorage", { + enumerable: true, + configurable: true, + writable: true, + value: new MockAsyncLocalStorage() + }); + Object.defineProperty(this, "hasBeenInitialized", { + enumerable: true, + configurable: true, + writable: true, + value: false + }); + } + getInstance() { + return this.asyncLocalStorage; + } + initializeGlobalInstance(instance) { + if (!this.hasBeenInitialized) { + this.hasBeenInitialized = true; + this.asyncLocalStorage = instance; + } + } +} +const AsyncLocalStorageProviderSingleton = new AsyncLocalStorageProvider(); + + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/utils/stream.js +// Make this a type to override ReadableStream's async iterator type in case +// the popular web-streams-polyfill is imported - the supplied types + +/* + * Support async iterator syntax for ReadableStreams in all environments. + * Source: https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490 + */ +class IterableReadableStream extends ReadableStream { + constructor() { + super(...arguments); + Object.defineProperty(this, "reader", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + } + ensureReader() { + if (!this.reader) { + this.reader = this.getReader(); + } + } + async next() { + this.ensureReader(); + try { + const result = await this.reader.read(); + if (result.done) { + this.reader.releaseLock(); // release lock when stream becomes closed + return { + done: true, + value: undefined, + }; + } + else { + return { + done: false, + value: result.value, + }; + } + } + catch (e) { + this.reader.releaseLock(); // release lock when stream becomes errored + throw e; + } + } + async return() { + this.ensureReader(); + // If wrapped in a Node stream, cancel is already called. + if (this.locked) { + const cancelPromise = this.reader.cancel(); // cancel first, but don't await yet + this.reader.releaseLock(); // release lock first + await cancelPromise; // now await it + } + return { done: true, value: undefined }; + } + // eslint-disable-next-line @typescript-eslint/no-explicit-any + async throw(e) { + this.ensureReader(); + if (this.locked) { + const cancelPromise = this.reader.cancel(); // cancel first, but don't await yet + this.reader.releaseLock(); // release lock first + await cancelPromise; // now await it + } + throw e; + } + [Symbol.asyncIterator]() { + return this; + } + static fromReadableStream(stream) { + // From https://developer.mozilla.org/en-US/docs/Web/API/Streams_API/Using_readable_streams#reading_the_stream + const reader = stream.getReader(); + return new IterableReadableStream({ + start(controller) { + return pump(); + function pump() { + return reader.read().then(({ done, value }) => { + // When no more data needs to be consumed, close the stream + if (done) { + controller.close(); + return; + } + // Enqueue the next data chunk into our target stream + controller.enqueue(value); + return pump(); + }); + } + }, + cancel() { + reader.releaseLock(); + }, + }); + } + static fromAsyncGenerator(generator) { + return new IterableReadableStream({ + async pull(controller) { + const { value, done } = await generator.next(); + // When no more data needs to be consumed, close the stream + if (done) { + controller.close(); + } + // Fix: `else if (value)` will hang the streaming when nullish value (e.g. empty string) is pulled + controller.enqueue(value); + }, + async cancel(reason) { + await generator.return(reason); + }, + }); + } +} +function atee(iter, length = 2) { + const buffers = Array.from({ length }, () => []); + return buffers.map(async function* makeIter(buffer) { + while (true) { + if (buffer.length === 0) { + const result = await iter.next(); + for (const buffer of buffers) { + buffer.push(result); + } + } + else if (buffer[0].done) { + return; + } + else { + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + yield buffer.shift().value; + } + } + }); +} +function concat(first, second) { + if (Array.isArray(first) && Array.isArray(second)) { + return first.concat(second); + } + else if (typeof first === "string" && typeof second === "string") { + return (first + second); + } + else if (typeof first === "number" && typeof second === "number") { + return (first + second); + } + else if ( + // eslint-disable-next-line @typescript-eslint/no-explicit-any + "concat" in first && + // eslint-disable-next-line @typescript-eslint/no-explicit-any + typeof first.concat === "function") { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + return first.concat(second); + } + else if (typeof first === "object" && typeof second === "object") { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const chunk = { ...first }; + // eslint-disable-next-line @typescript-eslint/no-explicit-any + for (const [key, value] of Object.entries(second)) { + if (key in chunk && !Array.isArray(chunk[key])) { + chunk[key] = concat(chunk[key], value); + } + else { + chunk[key] = value; + } + } + return chunk; + } + else { + throw new Error(`Cannot concat ${typeof first} and ${typeof second}`); + } +} +class AsyncGeneratorWithSetup { + constructor(params) { + Object.defineProperty(this, "generator", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "setup", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "config", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "firstResult", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "firstResultUsed", { + enumerable: true, + configurable: true, + writable: true, + value: false + }); + this.generator = params.generator; + this.config = params.config; + // setup is a promise that resolves only after the first iterator value + // is available. this is useful when setup of several piped generators + // needs to happen in logical order, ie. in the order in which input to + // to each generator is available. + this.setup = new Promise((resolve, reject) => { + const storage = AsyncLocalStorageProviderSingleton.getInstance(); + void storage.run(params.config, async () => { + this.firstResult = params.generator.next(); + if (params.startSetup) { + this.firstResult.then(params.startSetup).then(resolve, reject); + } + else { + this.firstResult.then((_result) => resolve(undefined), reject); + } + }); + }); + } + async next(...args) { + if (!this.firstResultUsed) { + this.firstResultUsed = true; + return this.firstResult; + } + const storage = AsyncLocalStorageProviderSingleton.getInstance(); + return storage.run(this.config, async () => { + return this.generator.next(...args); + }); + } + async return(value) { + return this.generator.return(value); + } + async throw(e) { + return this.generator.throw(e); + } + [Symbol.asyncIterator]() { + return this; + } +} +async function pipeGeneratorWithSetup(to, generator, startSetup, ...args) { + const gen = new AsyncGeneratorWithSetup({ generator, startSetup }); + const setup = await gen.setup; + return { output: to(gen, setup, ...args), setup }; +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/tracers/log_stream.js + + + + +/** + * List of jsonpatch JSONPatchOperations, which describe how to create the run state + * from an empty dict. This is the minimal representation of the log, designed to + * be serialized as JSON and sent over the wire to reconstruct the log on the other + * side. Reconstruction of the state can be done with any jsonpatch-compliant library, + * see https://jsonpatch.com for more information. + */ +class RunLogPatch { + constructor(fields) { + Object.defineProperty(this, "ops", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.ops = fields.ops ?? []; + } + concat(other) { + const ops = this.ops.concat(other.ops); + const states = core_applyPatch({}, ops); + // eslint-disable-next-line @typescript-eslint/no-use-before-define + return new RunLog({ + ops, + state: states[states.length - 1].newDocument, + }); + } +} +class RunLog extends RunLogPatch { + constructor(fields) { + super(fields); + Object.defineProperty(this, "state", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.state = fields.state; + } + concat(other) { + const ops = this.ops.concat(other.ops); + const states = core_applyPatch(this.state, other.ops); + return new RunLog({ ops, state: states[states.length - 1].newDocument }); + } + static fromRunLogPatch(patch) { + const states = core_applyPatch({}, patch.ops); + // eslint-disable-next-line @typescript-eslint/no-use-before-define + return new RunLog({ + ops: patch.ops, + state: states[states.length - 1].newDocument, + }); + } +} +/** + * Extract standardized inputs from a run. + * + * Standardizes the inputs based on the type of the runnable used. + * + * @param run - Run object + * @param schemaFormat - The schema format to use. + * + * @returns Valid inputs are only dict. By conventions, inputs always represented + * invocation using named arguments. + * A null means that the input is not yet known! + */ +async function _getStandardizedInputs(run, schemaFormat) { + if (schemaFormat === "original") { + throw new Error("Do not assign inputs with original schema drop the key for now. " + + "When inputs are added to streamLog they should be added with " + + "standardized schema for streaming events."); + } + const { inputs } = run; + if (["retriever", "llm", "prompt"].includes(run.run_type)) { + return inputs; + } + if (Object.keys(inputs).length === 1 && inputs?.input === "") { + return undefined; + } + // new style chains + // These nest an additional 'input' key inside the 'inputs' to make sure + // the input is always a dict. We need to unpack and user the inner value. + // We should try to fix this in Runnables and callbacks/tracers + // Runnables should be using a null type here not a placeholder + // dict. + return inputs.input; +} +async function _getStandardizedOutputs(run, schemaFormat) { + const { outputs } = run; + if (schemaFormat === "original") { + // Return the old schema, without standardizing anything + return outputs; + } + if (["retriever", "llm", "prompt"].includes(run.run_type)) { + return outputs; + } + // TODO: Remove this hacky check + if (outputs !== undefined && + Object.keys(outputs).length === 1 && + outputs?.output !== undefined) { + return outputs.output; + } + return outputs; +} +function isChatGenerationChunk(x) { + return x !== undefined && x.message !== undefined; +} +/** + * Class that extends the `BaseTracer` class from the + * `langchain.callbacks.tracers.base` module. It represents a callback + * handler that logs the execution of runs and emits `RunLog` instances to a + * `RunLogStream`. + */ +class LogStreamCallbackHandler extends base_BaseTracer { + constructor(fields) { + super({ _awaitHandler: true, ...fields }); + Object.defineProperty(this, "autoClose", { + enumerable: true, + configurable: true, + writable: true, + value: true + }); + Object.defineProperty(this, "includeNames", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "includeTypes", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "includeTags", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "excludeNames", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "excludeTypes", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "excludeTags", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "_schemaFormat", { + enumerable: true, + configurable: true, + writable: true, + value: "original" + }); + Object.defineProperty(this, "rootId", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "keyMapByRunId", { + enumerable: true, + configurable: true, + writable: true, + value: {} + }); + Object.defineProperty(this, "counterMapByRunName", { + enumerable: true, + configurable: true, + writable: true, + value: {} + }); + Object.defineProperty(this, "transformStream", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "writer", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "receiveStream", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "name", { + enumerable: true, + configurable: true, + writable: true, + value: "log_stream_tracer" + }); + this.autoClose = fields?.autoClose ?? true; + this.includeNames = fields?.includeNames; + this.includeTypes = fields?.includeTypes; + this.includeTags = fields?.includeTags; + this.excludeNames = fields?.excludeNames; + this.excludeTypes = fields?.excludeTypes; + this.excludeTags = fields?.excludeTags; + this._schemaFormat = fields?._schemaFormat ?? this._schemaFormat; + this.transformStream = new TransformStream(); + this.writer = this.transformStream.writable.getWriter(); + this.receiveStream = IterableReadableStream.fromReadableStream(this.transformStream.readable); + } + [Symbol.asyncIterator]() { + return this.receiveStream; + } + async persistRun(_run) { + // This is a legacy method only called once for an entire run tree + // and is therefore not useful here + } + _includeRun(run) { + if (run.id === this.rootId) { + return false; + } + const runTags = run.tags ?? []; + let include = this.includeNames === undefined && + this.includeTags === undefined && + this.includeTypes === undefined; + if (this.includeNames !== undefined) { + include = include || this.includeNames.includes(run.name); + } + if (this.includeTypes !== undefined) { + include = include || this.includeTypes.includes(run.run_type); + } + if (this.includeTags !== undefined) { + include = + include || + runTags.find((tag) => this.includeTags?.includes(tag)) !== undefined; + } + if (this.excludeNames !== undefined) { + include = include && !this.excludeNames.includes(run.name); + } + if (this.excludeTypes !== undefined) { + include = include && !this.excludeTypes.includes(run.run_type); + } + if (this.excludeTags !== undefined) { + include = + include && runTags.every((tag) => !this.excludeTags?.includes(tag)); + } + return include; + } + async *tapOutputIterable(runId, output) { + // Tap an output async iterator to stream its values to the log. + for await (const chunk of output) { + // root run is handled in .streamLog() + if (runId !== this.rootId) { + // if we can't find the run silently ignore + // eg. because this run wasn't included in the log + const key = this.keyMapByRunId[runId]; + if (key) { + await this.writer.write(new RunLogPatch({ + ops: [ + { + op: "add", + path: `/logs/${key}/streamed_output/-`, + value: chunk, + }, + ], + })); + } + } + yield chunk; + } + } + async onRunCreate(run) { + if (this.rootId === undefined) { + this.rootId = run.id; + await this.writer.write(new RunLogPatch({ + ops: [ + { + op: "replace", + path: "", + value: { + id: run.id, + name: run.name, + type: run.run_type, + streamed_output: [], + final_output: undefined, + logs: {}, + }, + }, + ], + })); + } + if (!this._includeRun(run)) { + return; + } + if (this.counterMapByRunName[run.name] === undefined) { + this.counterMapByRunName[run.name] = 0; + } + this.counterMapByRunName[run.name] += 1; + const count = this.counterMapByRunName[run.name]; + this.keyMapByRunId[run.id] = + count === 1 ? run.name : `${run.name}:${count}`; + const logEntry = { + id: run.id, + name: run.name, + type: run.run_type, + tags: run.tags ?? [], + metadata: run.extra?.metadata ?? {}, + start_time: new Date(run.start_time).toISOString(), + streamed_output: [], + streamed_output_str: [], + final_output: undefined, + end_time: undefined, + }; + if (this._schemaFormat === "streaming_events") { + logEntry.inputs = await _getStandardizedInputs(run, this._schemaFormat); + } + await this.writer.write(new RunLogPatch({ + ops: [ + { + op: "add", + path: `/logs/${this.keyMapByRunId[run.id]}`, + value: logEntry, + }, + ], + })); + } + async onRunUpdate(run) { + try { + const runName = this.keyMapByRunId[run.id]; + if (runName === undefined) { + return; + } + const ops = []; + if (this._schemaFormat === "streaming_events") { + ops.push({ + op: "replace", + path: `/logs/${runName}/inputs`, + value: await _getStandardizedInputs(run, this._schemaFormat), + }); + } + ops.push({ + op: "add", + path: `/logs/${runName}/final_output`, + value: await _getStandardizedOutputs(run, this._schemaFormat), + }); + if (run.end_time !== undefined) { + ops.push({ + op: "add", + path: `/logs/${runName}/end_time`, + value: new Date(run.end_time).toISOString(), + }); + } + const patch = new RunLogPatch({ ops }); + await this.writer.write(patch); + } + finally { + if (run.id === this.rootId) { + const patch = new RunLogPatch({ + ops: [ + { + op: "replace", + path: "/final_output", + value: await _getStandardizedOutputs(run, this._schemaFormat), + }, + ], + }); + await this.writer.write(patch); + if (this.autoClose) { + await this.writer.close(); + } + } + } + } + async onLLMNewToken(run, token, kwargs) { + const runName = this.keyMapByRunId[run.id]; + if (runName === undefined) { + return; + } + // TODO: Remove hack + const isChatModel = run.inputs.messages !== undefined; + let streamedOutputValue; + if (isChatModel) { + if (isChatGenerationChunk(kwargs?.chunk)) { + streamedOutputValue = kwargs?.chunk; + } + else { + streamedOutputValue = new dist_messages/* AIMessageChunk */.GC(token); + } + } + else { + streamedOutputValue = token; + } + const patch = new RunLogPatch({ + ops: [ + { + op: "add", + path: `/logs/${runName}/streamed_output_str/-`, + value: token, + }, + { + op: "add", + path: `/logs/${runName}/streamed_output/-`, + value: streamedOutputValue, + }, + ], + }); + await this.writer.write(patch); + } +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/runnables/config.js + + +const DEFAULT_RECURSION_LIMIT = 25; +async function getCallbackManagerForConfig(config) { + return CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata); +} +function mergeConfigs(...configs) { + // We do not want to call ensureConfig on the empty state here as this may cause + // double loading of callbacks if async local storage is being used. + const copy = {}; + for (const options of configs.filter((c) => !!c)) { + for (const key of Object.keys(options)) { + if (key === "metadata") { + copy[key] = { ...copy[key], ...options[key] }; + } + else if (key === "tags") { + const baseKeys = copy[key] ?? []; + copy[key] = [...new Set(baseKeys.concat(options[key] ?? []))]; + } + else if (key === "configurable") { + copy[key] = { ...copy[key], ...options[key] }; + } + else if (key === "callbacks") { + const baseCallbacks = copy.callbacks; + const providedCallbacks = options.callbacks; + // callbacks can be either undefined, Array or manager + // so merging two callbacks values has 6 cases + if (Array.isArray(providedCallbacks)) { + if (!baseCallbacks) { + copy.callbacks = providedCallbacks; + } + else if (Array.isArray(baseCallbacks)) { + copy.callbacks = baseCallbacks.concat(providedCallbacks); + } + else { + // baseCallbacks is a manager + const manager = baseCallbacks.copy(); + for (const callback of providedCallbacks) { + manager.addHandler(ensureHandler(callback), true); + } + copy.callbacks = manager; + } + } + else if (providedCallbacks) { + // providedCallbacks is a manager + if (!baseCallbacks) { + copy.callbacks = providedCallbacks; + } + else if (Array.isArray(baseCallbacks)) { + const manager = providedCallbacks.copy(); + for (const callback of baseCallbacks) { + manager.addHandler(ensureHandler(callback), true); + } + copy.callbacks = manager; + } + else { + // baseCallbacks is also a manager + copy.callbacks = new CallbackManager(providedCallbacks._parentRunId, { + handlers: baseCallbacks.handlers.concat(providedCallbacks.handlers), + inheritableHandlers: baseCallbacks.inheritableHandlers.concat(providedCallbacks.inheritableHandlers), + tags: Array.from(new Set(baseCallbacks.tags.concat(providedCallbacks.tags))), + inheritableTags: Array.from(new Set(baseCallbacks.inheritableTags.concat(providedCallbacks.inheritableTags))), + metadata: { + ...baseCallbacks.metadata, + ...providedCallbacks.metadata, + }, + }); + } + } + } + else { + const typedKey = key; + copy[typedKey] = options[typedKey] ?? copy[typedKey]; + } + } + } + return copy; +} +const PRIMITIVES = new Set(["string", "number", "boolean"]); +/** + * Ensure that a passed config is an object with all required keys present. + * + * Note: To make sure async local storage loading works correctly, this + * should not be called with a default or prepopulated config argument. + */ +function ensureConfig(config) { + const loadedConfig = config ?? AsyncLocalStorageProviderSingleton.getInstance().getStore(); + let empty = { + tags: [], + metadata: {}, + callbacks: undefined, + recursionLimit: 25, + runId: undefined, + }; + if (loadedConfig) { + empty = { ...empty, ...loadedConfig }; + } + if (loadedConfig?.configurable) { + for (const key of Object.keys(loadedConfig.configurable)) { + if (PRIMITIVES.has(typeof loadedConfig.configurable[key]) && + !empty.metadata?.[key]) { + if (!empty.metadata) { + empty.metadata = {}; + } + empty.metadata[key] = loadedConfig.configurable[key]; + } + } + } + return empty; +} +/** + * Helper function that patches runnable configs with updated properties. + */ +function patchConfig(config = {}, { callbacks, maxConcurrency, recursionLimit, runName, configurable, runId, } = {}) { + const newConfig = ensureConfig(config); + if (callbacks !== undefined) { + /** + * If we're replacing callbacks we need to unset runName + * since that should apply only to the same run as the original callbacks + */ + delete newConfig.runName; + newConfig.callbacks = callbacks; + } + if (recursionLimit !== undefined) { + newConfig.recursionLimit = recursionLimit; + } + if (maxConcurrency !== undefined) { + newConfig.maxConcurrency = maxConcurrency; + } + if (runName !== undefined) { + newConfig.runName = runName; + } + if (configurable !== undefined) { + newConfig.configurable = { ...newConfig.configurable, ...configurable }; + } + if (runId !== undefined) { + delete newConfig.runId; + } + return newConfig; +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/utils/async_caller.js + + +const async_caller_STATUS_NO_RETRY = [ + 400, + 401, + 402, + 403, + 404, + 405, + 406, + 407, + 409, // Conflict +]; +// eslint-disable-next-line @typescript-eslint/no-explicit-any +const defaultFailedAttemptHandler = (error) => { + if (error.message.startsWith("Cancel") || + error.message.startsWith("AbortError") || + error.name === "AbortError") { + throw error; + } + // eslint-disable-next-line @typescript-eslint/no-explicit-any + if (error?.code === "ECONNABORTED") { + throw error; + } + const status = + // eslint-disable-next-line @typescript-eslint/no-explicit-any + error?.response?.status ?? error?.status; + if (status && async_caller_STATUS_NO_RETRY.includes(+status)) { + throw error; + } + // eslint-disable-next-line @typescript-eslint/no-explicit-any + if (error?.error?.code === "insufficient_quota") { + const err = new Error(error?.message); + err.name = "InsufficientQuotaError"; + throw err; + } +}; +/** + * A class that can be used to make async calls with concurrency and retry logic. + * + * This is useful for making calls to any kind of "expensive" external resource, + * be it because it's rate-limited, subject to network issues, etc. + * + * Concurrent calls are limited by the `maxConcurrency` parameter, which defaults + * to `Infinity`. This means that by default, all calls will be made in parallel. + * + * Retries are limited by the `maxRetries` parameter, which defaults to 6. This + * means that by default, each call will be retried up to 6 times, with an + * exponential backoff between each attempt. + */ +class async_caller_AsyncCaller { + constructor(params) { + Object.defineProperty(this, "maxConcurrency", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "maxRetries", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "onFailedAttempt", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "queue", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.maxConcurrency = params.maxConcurrency ?? Infinity; + this.maxRetries = params.maxRetries ?? 6; + this.onFailedAttempt = + params.onFailedAttempt ?? defaultFailedAttemptHandler; + const PQueue = true ? p_queue_dist["default"] : p_queue_dist; + this.queue = new PQueue({ concurrency: this.maxConcurrency }); + } + // eslint-disable-next-line @typescript-eslint/no-explicit-any + call(callable, ...args) { + return this.queue.add(() => p_retry(() => callable(...args).catch((error) => { + // eslint-disable-next-line no-instanceof/no-instanceof + if (error instanceof Error) { + throw error; + } + else { + throw new Error(error); + } + }), { + onFailedAttempt: this.onFailedAttempt, + retries: this.maxRetries, + randomize: true, + // If needed we can change some of the defaults here, + // but they're quite sensible. + }), { throwOnTimeout: true }); + } + // eslint-disable-next-line @typescript-eslint/no-explicit-any + callWithOptions(options, callable, ...args) { + // Note this doesn't cancel the underlying request, + // when available prefer to use the signal option of the underlying call + if (options.signal) { + return Promise.race([ + this.call(callable, ...args), + new Promise((_, reject) => { + options.signal?.addEventListener("abort", () => { + reject(new Error("AbortError")); + }); + }), + ]); + } + return this.call(callable, ...args); + } + fetch(...args) { + return this.call(() => fetch(...args).then((res) => (res.ok ? res : Promise.reject(res)))); + } +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/tracers/root_listener.js + +class RootListenersTracer extends base_BaseTracer { + constructor({ config, onStart, onEnd, onError, }) { + super({ _awaitHandler: true }); + Object.defineProperty(this, "name", { + enumerable: true, + configurable: true, + writable: true, + value: "RootListenersTracer" + }); + /** The Run's ID. Type UUID */ + Object.defineProperty(this, "rootId", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "config", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "argOnStart", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "argOnEnd", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "argOnError", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.config = config; + this.argOnStart = onStart; + this.argOnEnd = onEnd; + this.argOnError = onError; + } + /** + * This is a legacy method only called once for an entire run tree + * therefore not useful here + * @param {Run} _ Not used + */ + persistRun(_) { + return Promise.resolve(); + } + async onRunCreate(run) { + if (this.rootId) { + return; + } + this.rootId = run.id; + if (this.argOnStart) { + if (this.argOnStart.length === 1) { + await this.argOnStart(run); + } + else if (this.argOnStart.length === 2) { + await this.argOnStart(run, this.config); + } + } + } + async onRunUpdate(run) { + if (run.id !== this.rootId) { + return; + } + if (!run.error) { + if (this.argOnEnd) { + if (this.argOnEnd.length === 1) { + await this.argOnEnd(run); + } + else if (this.argOnEnd.length === 2) { + await this.argOnEnd(run, this.config); + } + } + } + else if (this.argOnError) { + if (this.argOnError.length === 1) { + await this.argOnError(run); + } + else if (this.argOnError.length === 2) { + await this.argOnError(run, this.config); + } + } + } +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/runnables/utils.js +// eslint-disable-next-line @typescript-eslint/no-explicit-any +function utils_isRunnableInterface(thing) { + return thing ? thing.lc_runnable : false; +} +/** + * Utility to filter the root event in the streamEvents implementation. + * This is simply binding the arguments to the namespace to make save on + * a bit of typing in the streamEvents implementation. + * + * TODO: Refactor and remove. + */ +class _RootEventFilter { + constructor(fields) { + Object.defineProperty(this, "includeNames", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "includeTypes", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "includeTags", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "excludeNames", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "excludeTypes", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "excludeTags", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.includeNames = fields.includeNames; + this.includeTypes = fields.includeTypes; + this.includeTags = fields.includeTags; + this.excludeNames = fields.excludeNames; + this.excludeTypes = fields.excludeTypes; + this.excludeTags = fields.excludeTags; + } + includeEvent(event, rootType) { + let include = this.includeNames === undefined && + this.includeTypes === undefined && + this.includeTags === undefined; + const eventTags = event.tags ?? []; + if (this.includeNames !== undefined) { + include = include || this.includeNames.includes(event.name); + } + if (this.includeTypes !== undefined) { + include = include || this.includeTypes.includes(rootType); + } + if (this.includeTags !== undefined) { + include = + include || eventTags.some((tag) => this.includeTags?.includes(tag)); + } + if (this.excludeNames !== undefined) { + include = include && !this.excludeNames.includes(event.name); + } + if (this.excludeTypes !== undefined) { + include = include && !this.excludeTypes.includes(rootType); + } + if (this.excludeTags !== undefined) { + include = + include && eventTags.every((tag) => !this.excludeTags?.includes(tag)); + } + return include; + } +} + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/Options.js +const ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use"); +const defaultOptions = { + name: undefined, + $refStrategy: "root", + basePath: ["#"], + effectStrategy: "input", + pipeStrategy: "all", + dateStrategy: "format:date-time", + mapStrategy: "entries", + removeAdditionalStrategy: "passthrough", + definitionPath: "definitions", + target: "jsonSchema7", + strictUnions: false, + definitions: {}, + errorMessages: false, + markdownDescription: false, + patternStrategy: "escape", + emailStrategy: "format:email", + base64Strategy: "contentEncoding:base64", +}; +const getDefaultOptions = (options) => (typeof options === "string" + ? { + ...defaultOptions, + name: options, + } + : { + ...defaultOptions, + ...options, + }); + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/Refs.js + +const getRefs = (options) => { + const _options = getDefaultOptions(options); + const currentPath = _options.name !== undefined + ? [..._options.basePath, _options.definitionPath, _options.name] + : _options.basePath; + return { + ..._options, + currentPath: currentPath, + propertyPath: undefined, + seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [ + def._def, + { + def: def._def, + path: [..._options.basePath, _options.definitionPath, name], + // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now. + jsonSchema: undefined, + }, + ])), + }; +}; + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/any.js +function parseAnyDef() { + return {}; +} + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/errorMessages.js +function addErrorMessage(res, key, errorMessage, refs) { + if (!refs?.errorMessages) + return; + if (errorMessage) { + res.errorMessage = { + ...res.errorMessage, + [key]: errorMessage, + }; + } +} +function setResponseValueAndErrors(res, key, value, errorMessage, refs) { + res[key] = value; + addErrorMessage(res, key, errorMessage, refs); +} + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/array.js + + + +function parseArrayDef(def, refs) { + const res = { + type: "array", + }; + if (def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) { + res.items = parseDef_parseDef(def.type._def, { + ...refs, + currentPath: [...refs.currentPath, "items"], + }); + } + if (def.minLength) { + setResponseValueAndErrors(res, "minItems", def.minLength.value, def.minLength.message, refs); + } + if (def.maxLength) { + setResponseValueAndErrors(res, "maxItems", def.maxLength.value, def.maxLength.message, refs); + } + if (def.exactLength) { + setResponseValueAndErrors(res, "minItems", def.exactLength.value, def.exactLength.message, refs); + setResponseValueAndErrors(res, "maxItems", def.exactLength.value, def.exactLength.message, refs); + } + return res; +} + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js + +function parseBigintDef(def, refs) { + const res = { + type: "integer", + format: "int64", + }; + if (!def.checks) + return res; + for (const check of def.checks) { + switch (check.kind) { + case "min": + if (refs.target === "jsonSchema7") { + if (check.inclusive) { + setResponseValueAndErrors(res, "minimum", check.value, check.message, refs); + } + else { + setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs); + } + } + else { + if (!check.inclusive) { + res.exclusiveMinimum = true; + } + setResponseValueAndErrors(res, "minimum", check.value, check.message, refs); + } + break; + case "max": + if (refs.target === "jsonSchema7") { + if (check.inclusive) { + setResponseValueAndErrors(res, "maximum", check.value, check.message, refs); + } + else { + setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs); + } + } + else { + if (!check.inclusive) { + res.exclusiveMaximum = true; + } + setResponseValueAndErrors(res, "maximum", check.value, check.message, refs); + } + break; + case "multipleOf": + setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs); + break; + } + } + return res; +} + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js +function parseBooleanDef() { + return { + type: "boolean", + }; +} + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/branded.js + +function parseBrandedDef(_def, refs) { + return parseDef_parseDef(_def.type._def, refs); +} + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/catch.js + +const parseCatchDef = (def, refs) => { + return parseDef_parseDef(def.innerType._def, refs); +}; + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/date.js + +function parseDateDef(def, refs, overrideDateStrategy) { + const strategy = overrideDateStrategy ?? refs.dateStrategy; + if (Array.isArray(strategy)) { + return { + anyOf: strategy.map((item, i) => parseDateDef(def, refs, item)), + }; + } + switch (strategy) { + case "string": + case "format:date-time": + return { + type: "string", + format: "date-time", + }; + case "format:date": + return { + type: "string", + format: "date", + }; + case "integer": + return integerDateParser(def, refs); + } +} +const integerDateParser = (def, refs) => { + const res = { + type: "integer", + format: "unix-time", + }; + if (refs.target === "openApi3") { + return res; + } + for (const check of def.checks) { + switch (check.kind) { + case "min": + setResponseValueAndErrors(res, "minimum", check.value, // This is in milliseconds + check.message, refs); + break; + case "max": + setResponseValueAndErrors(res, "maximum", check.value, // This is in milliseconds + check.message, refs); + break; + } + } + return res; +}; + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/default.js + +function parseDefaultDef(_def, refs) { + return { + ...parseDef_parseDef(_def.innerType._def, refs), + default: _def.defaultValue(), + }; +} + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/effects.js + +function parseEffectsDef(_def, refs) { + return refs.effectStrategy === "input" + ? parseDef_parseDef(_def.schema._def, refs) + : {}; +} + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/enum.js +function parseEnumDef(def) { + return { + type: "string", + enum: def.values, + }; +} + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js + +const isJsonSchema7AllOfType = (type) => { + if ("type" in type && type.type === "string") + return false; + return "allOf" in type; +}; +function parseIntersectionDef(def, refs) { + const allOf = [ + parseDef_parseDef(def.left._def, { + ...refs, + currentPath: [...refs.currentPath, "allOf", "0"], + }), + parseDef_parseDef(def.right._def, { + ...refs, + currentPath: [...refs.currentPath, "allOf", "1"], + }), + ].filter((x) => !!x); + let unevaluatedProperties = refs.target === "jsonSchema2019-09" + ? { unevaluatedProperties: false } + : undefined; + const mergedAllOf = []; + // If either of the schemas is an allOf, merge them into a single allOf + allOf.forEach((schema) => { + if (isJsonSchema7AllOfType(schema)) { + mergedAllOf.push(...schema.allOf); + if (schema.unevaluatedProperties === undefined) { + // If one of the schemas has no unevaluatedProperties set, + // the merged schema should also have no unevaluatedProperties set + unevaluatedProperties = undefined; + } + } + else { + let nestedSchema = schema; + if ("additionalProperties" in schema && + schema.additionalProperties === false) { + const { additionalProperties, ...rest } = schema; + nestedSchema = rest; + } + else { + // As soon as one of the schemas has additionalProperties set not to false, we allow unevaluatedProperties + unevaluatedProperties = undefined; + } + mergedAllOf.push(nestedSchema); + } + }); + return mergedAllOf.length + ? { + allOf: mergedAllOf, + ...unevaluatedProperties, + } + : undefined; +} + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/literal.js +function parseLiteralDef(def, refs) { + const parsedType = typeof def.value; + if (parsedType !== "bigint" && + parsedType !== "number" && + parsedType !== "boolean" && + parsedType !== "string") { + return { + type: Array.isArray(def.value) ? "array" : "object", + }; + } + if (refs.target === "openApi3") { + return { + type: parsedType === "bigint" ? "integer" : parsedType, + enum: [def.value], + }; + } + return { + type: parsedType === "bigint" ? "integer" : parsedType, + const: def.value, + }; +} + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/string.js + +/** + * Generated from the .source property of regular expressins found here: + * https://github.com/colinhacks/zod/blob/master/src/types.ts. + * + * Escapes have been doubled, and expressions with /i flag have been changed accordingly + */ +const zodPatterns = { + /** + * `c` was changed to `[cC]` to replicate /i flag + */ + cuid: "^[cC][^\\s-]{8,}$", + cuid2: "^[a-z][a-z0-9]*$", + ulid: "^[0-9A-HJKMNP-TV-Z]{26}$", + /** + * `a-z` was added to replicate /i flag + */ + email: "^(?!\\.)(?!.*\\.\\.)([a-zA-Z0-9_+-\\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\\-]*\\.)+[a-zA-Z]{2,}$", + emoji: "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", + /** + * Unused + */ + uuid: "^[0-9a-fA-F]{8}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{12}$", + /** + * Unused + */ + ipv4: "^(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))$", + /** + * Unused + */ + ipv6: "^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$", + base64: "^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$", + nanoid: "^[a-zA-Z0-9_-]{21}$", +}; +function parseStringDef(def, refs) { + const res = { + type: "string", + }; + function processPattern(value) { + return refs.patternStrategy === "escape" + ? escapeNonAlphaNumeric(value) + : value; + } + if (def.checks) { + for (const check of def.checks) { + switch (check.kind) { + case "min": + setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" + ? Math.max(res.minLength, check.value) + : check.value, check.message, refs); + break; + case "max": + setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" + ? Math.min(res.maxLength, check.value) + : check.value, check.message, refs); + break; + case "email": + switch (refs.emailStrategy) { + case "format:email": + addFormat(res, "email", check.message, refs); + break; + case "format:idn-email": + addFormat(res, "idn-email", check.message, refs); + break; + case "pattern:zod": + addPattern(res, zodPatterns.email, check.message, refs); + break; + } + break; + case "url": + addFormat(res, "uri", check.message, refs); + break; + case "uuid": + addFormat(res, "uuid", check.message, refs); + break; + case "regex": + addPattern(res, check.regex.source, check.message, refs); + break; + case "cuid": + addPattern(res, zodPatterns.cuid, check.message, refs); + break; + case "cuid2": + addPattern(res, zodPatterns.cuid2, check.message, refs); + break; + case "startsWith": + addPattern(res, "^" + processPattern(check.value), check.message, refs); + break; + case "endsWith": + addPattern(res, processPattern(check.value) + "$", check.message, refs); + break; + case "datetime": + addFormat(res, "date-time", check.message, refs); + break; + case "date": + addFormat(res, "date", check.message, refs); + break; + case "time": + addFormat(res, "time", check.message, refs); + break; + case "duration": + addFormat(res, "duration", check.message, refs); + break; + case "length": + setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" + ? Math.max(res.minLength, check.value) + : check.value, check.message, refs); + setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" + ? Math.min(res.maxLength, check.value) + : check.value, check.message, refs); + break; + case "includes": { + addPattern(res, processPattern(check.value), check.message, refs); + break; + } + case "ip": { + if (check.version !== "v6") { + addFormat(res, "ipv4", check.message, refs); + } + if (check.version !== "v4") { + addFormat(res, "ipv6", check.message, refs); + } + break; + } + case "emoji": + addPattern(res, zodPatterns.emoji, check.message, refs); + break; + case "ulid": { + addPattern(res, zodPatterns.ulid, check.message, refs); + break; + } + case "base64": { + switch (refs.base64Strategy) { + case "format:binary": { + addFormat(res, "binary", check.message, refs); + break; + } + case "contentEncoding:base64": { + setResponseValueAndErrors(res, "contentEncoding", "base64", check.message, refs); + break; + } + case "pattern:zod": { + addPattern(res, zodPatterns.base64, check.message, refs); + break; + } + } + break; + } + case "nanoid": { + addPattern(res, zodPatterns.nanoid, check.message, refs); + } + case "toLowerCase": + case "toUpperCase": + case "trim": + break; + default: + ((_) => { })(check); + } + } + } + return res; +} +const escapeNonAlphaNumeric = (value) => Array.from(value) + .map((c) => (/[a-zA-Z0-9]/.test(c) ? c : `\\${c}`)) + .join(""); +const addFormat = (schema, value, message, refs) => { + if (schema.format || schema.anyOf?.some((x) => x.format)) { + if (!schema.anyOf) { + schema.anyOf = []; + } + if (schema.format) { + schema.anyOf.push({ + format: schema.format, + ...(schema.errorMessage && + refs.errorMessages && { + errorMessage: { format: schema.errorMessage.format }, + }), + }); + delete schema.format; + if (schema.errorMessage) { + delete schema.errorMessage.format; + if (Object.keys(schema.errorMessage).length === 0) { + delete schema.errorMessage; + } + } + } + schema.anyOf.push({ + format: value, + ...(message && + refs.errorMessages && { errorMessage: { format: message } }), + }); + } + else { + setResponseValueAndErrors(schema, "format", value, message, refs); + } +}; +const addPattern = (schema, value, message, refs) => { + if (schema.pattern || schema.allOf?.some((x) => x.pattern)) { + if (!schema.allOf) { + schema.allOf = []; + } + if (schema.pattern) { + schema.allOf.push({ + pattern: schema.pattern, + ...(schema.errorMessage && + refs.errorMessages && { + errorMessage: { pattern: schema.errorMessage.pattern }, + }), + }); + delete schema.pattern; + if (schema.errorMessage) { + delete schema.errorMessage.pattern; + if (Object.keys(schema.errorMessage).length === 0) { + delete schema.errorMessage; + } + } + } + schema.allOf.push({ + pattern: value, + ...(message && + refs.errorMessages && { errorMessage: { pattern: message } }), + }); + } + else { + setResponseValueAndErrors(schema, "pattern", value, message, refs); + } +}; + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/record.js + + + +function parseRecordDef(def, refs) { + if (refs.target === "openApi3" && + def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) { + return { + type: "object", + required: def.keyType._def.values, + properties: def.keyType._def.values.reduce((acc, key) => ({ + ...acc, + [key]: parseDef_parseDef(def.valueType._def, { + ...refs, + currentPath: [...refs.currentPath, "properties", key], + }) ?? {}, + }), {}), + additionalProperties: false, + }; + } + const schema = { + type: "object", + additionalProperties: parseDef_parseDef(def.valueType._def, { + ...refs, + currentPath: [...refs.currentPath, "additionalProperties"], + }) ?? {}, + }; + if (refs.target === "openApi3") { + return schema; + } + if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodString && + def.keyType._def.checks?.length) { + const keyType = Object.entries(parseStringDef(def.keyType._def, refs)).reduce((acc, [key, value]) => (key === "type" ? acc : { ...acc, [key]: value }), {}); + return { + ...schema, + propertyNames: keyType, + }; + } + else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) { + return { + ...schema, + propertyNames: { + enum: def.keyType._def.values, + }, + }; + } + return schema; +} + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/map.js + + +function parseMapDef(def, refs) { + if (refs.mapStrategy === "record") { + return parseRecordDef(def, refs); + } + const keys = parseDef_parseDef(def.keyType._def, { + ...refs, + currentPath: [...refs.currentPath, "items", "items", "0"], + }) || {}; + const values = parseDef_parseDef(def.valueType._def, { + ...refs, + currentPath: [...refs.currentPath, "items", "items", "1"], + }) || {}; + return { + type: "array", + maxItems: 125, + items: { + type: "array", + items: [keys, values], + minItems: 2, + maxItems: 2, + }, + }; +} + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js +function parseNativeEnumDef(def) { + const object = def.values; + const actualKeys = Object.keys(def.values).filter((key) => { + return typeof object[object[key]] !== "number"; + }); + const actualValues = actualKeys.map((key) => object[key]); + const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values))); + return { + type: parsedTypes.length === 1 + ? parsedTypes[0] === "string" + ? "string" + : "number" + : ["string", "number"], + enum: actualValues, + }; +} + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/never.js +function parseNeverDef() { + return { + not: {}, + }; +} + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/null.js +function parseNullDef(refs) { + return refs.target === "openApi3" + ? { + enum: ["null"], + nullable: true, + } + : { + type: "null", + }; +} + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/union.js + +const primitiveMappings = { + ZodString: "string", + ZodNumber: "number", + ZodBigInt: "integer", + ZodBoolean: "boolean", + ZodNull: "null", +}; +function parseUnionDef(def, refs) { + if (refs.target === "openApi3") + return asAnyOf(def, refs); + const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options; + // This blocks tries to look ahead a bit to produce nicer looking schemas with type array instead of anyOf. + if (options.every((x) => x._def.typeName in primitiveMappings && + (!x._def.checks || !x._def.checks.length))) { + // all types in union are primitive and lack checks, so might as well squash into {type: [...]} + const types = options.reduce((types, x) => { + const type = primitiveMappings[x._def.typeName]; //Can be safely casted due to row 43 + return type && !types.includes(type) ? [...types, type] : types; + }, []); + return { + type: types.length > 1 ? types : types[0], + }; + } + else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) { + // all options literals + const types = options.reduce((acc, x) => { + const type = typeof x._def.value; + switch (type) { + case "string": + case "number": + case "boolean": + return [...acc, type]; + case "bigint": + return [...acc, "integer"]; + case "object": + if (x._def.value === null) + return [...acc, "null"]; + case "symbol": + case "undefined": + case "function": + default: + return acc; + } + }, []); + if (types.length === options.length) { + // all the literals are primitive, as far as null can be considered primitive + const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i); + return { + type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0], + enum: options.reduce((acc, x) => { + return acc.includes(x._def.value) ? acc : [...acc, x._def.value]; + }, []), + }; + } + } + else if (options.every((x) => x._def.typeName === "ZodEnum")) { + return { + type: "string", + enum: options.reduce((acc, x) => [ + ...acc, + ...x._def.values.filter((x) => !acc.includes(x)), + ], []), + }; + } + return asAnyOf(def, refs); +} +const asAnyOf = (def, refs) => { + const anyOf = (def.options instanceof Map + ? Array.from(def.options.values()) + : def.options) + .map((x, i) => parseDef_parseDef(x._def, { + ...refs, + currentPath: [...refs.currentPath, "anyOf", `${i}`], + })) + .filter((x) => !!x && + (!refs.strictUnions || + (typeof x === "object" && Object.keys(x).length > 0))); + return anyOf.length ? { anyOf } : undefined; +}; + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/nullable.js + + +function parseNullableDef(def, refs) { + if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(def.innerType._def.typeName) && + (!def.innerType._def.checks || !def.innerType._def.checks.length)) { + if (refs.target === "openApi3") { + return { + type: primitiveMappings[def.innerType._def.typeName], + nullable: true, + }; + } + return { + type: [ + primitiveMappings[def.innerType._def.typeName], + "null", + ], + }; + } + if (refs.target === "openApi3") { + const base = parseDef_parseDef(def.innerType._def, { + ...refs, + currentPath: [...refs.currentPath], + }); + if (base && '$ref' in base) + return { allOf: [base], nullable: true }; + return base && { ...base, nullable: true }; + } + const base = parseDef_parseDef(def.innerType._def, { + ...refs, + currentPath: [...refs.currentPath, "anyOf", "0"], + }); + return base && { anyOf: [base, { type: "null" }] }; +} + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/number.js + +function parseNumberDef(def, refs) { + const res = { + type: "number", + }; + if (!def.checks) + return res; + for (const check of def.checks) { + switch (check.kind) { + case "int": + res.type = "integer"; + addErrorMessage(res, "type", check.message, refs); + break; + case "min": + if (refs.target === "jsonSchema7") { + if (check.inclusive) { + setResponseValueAndErrors(res, "minimum", check.value, check.message, refs); + } + else { + setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs); + } + } + else { + if (!check.inclusive) { + res.exclusiveMinimum = true; + } + setResponseValueAndErrors(res, "minimum", check.value, check.message, refs); + } + break; + case "max": + if (refs.target === "jsonSchema7") { + if (check.inclusive) { + setResponseValueAndErrors(res, "maximum", check.value, check.message, refs); + } + else { + setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs); + } + } + else { + if (!check.inclusive) { + res.exclusiveMaximum = true; + } + setResponseValueAndErrors(res, "maximum", check.value, check.message, refs); + } + break; + case "multipleOf": + setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs); + break; + } + } + return res; +} + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/object.js + +function decideAdditionalProperties(def, refs) { + if (refs.removeAdditionalStrategy === "strict") { + return def.catchall._def.typeName === "ZodNever" + ? def.unknownKeys !== "strict" + : parseDef_parseDef(def.catchall._def, { + ...refs, + currentPath: [...refs.currentPath, "additionalProperties"], + }) ?? true; + } + else { + return def.catchall._def.typeName === "ZodNever" + ? def.unknownKeys === "passthrough" + : parseDef_parseDef(def.catchall._def, { + ...refs, + currentPath: [...refs.currentPath, "additionalProperties"], + }) ?? true; + } +} +; +function parseObjectDefX(def, refs) { + Object.keys(def.shape()).reduce((schema, key) => { + let prop = def.shape()[key]; + const isOptional = prop.isOptional(); + if (!isOptional) { + prop = { ...prop._def.innerSchema }; + } + const propSchema = parseDef(prop._def, { + ...refs, + currentPath: [...refs.currentPath, "properties", key], + propertyPath: [...refs.currentPath, "properties", key], + }); + if (propSchema !== undefined) { + schema.properties[key] = propSchema; + if (!isOptional) { + if (!schema.required) { + schema.required = []; + } + schema.required.push(key); + } + } + return schema; + }, { + type: "object", + properties: {}, + additionalProperties: decideAdditionalProperties(def, refs), + }); + const result = { + type: "object", + ...Object.entries(def.shape()).reduce((acc, [propName, propDef]) => { + if (propDef === undefined || propDef._def === undefined) + return acc; + const parsedDef = parseDef(propDef._def, { + ...refs, + currentPath: [...refs.currentPath, "properties", propName], + propertyPath: [...refs.currentPath, "properties", propName], + }); + if (parsedDef === undefined) + return acc; + return { + properties: { ...acc.properties, [propName]: parsedDef }, + required: propDef.isOptional() + ? acc.required + : [...acc.required, propName], + }; + }, { properties: {}, required: [] }), + additionalProperties: decideAdditionalProperties(def, refs), + }; + if (!result.required.length) + delete result.required; + return result; +} +function parseObjectDef(def, refs) { + const result = { + type: "object", + ...Object.entries(def.shape()).reduce((acc, [propName, propDef]) => { + if (propDef === undefined || propDef._def === undefined) + return acc; + const parsedDef = parseDef_parseDef(propDef._def, { + ...refs, + currentPath: [...refs.currentPath, "properties", propName], + propertyPath: [...refs.currentPath, "properties", propName], + }); + if (parsedDef === undefined) + return acc; + return { + properties: { ...acc.properties, [propName]: parsedDef }, + required: propDef.isOptional() + ? acc.required + : [...acc.required, propName], + }; + }, { properties: {}, required: [] }), + additionalProperties: decideAdditionalProperties(def, refs), + }; + if (!result.required.length) + delete result.required; + return result; +} + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/optional.js + +const parseOptionalDef = (def, refs) => { + if (refs.currentPath.toString() === refs.propertyPath?.toString()) { + return parseDef_parseDef(def.innerType._def, refs); + } + const innerSchema = parseDef_parseDef(def.innerType._def, { + ...refs, + currentPath: [...refs.currentPath, "anyOf", "1"], + }); + return innerSchema + ? { + anyOf: [ + { + not: {}, + }, + innerSchema, + ], + } + : {}; +}; + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/pipeline.js + +const parsePipelineDef = (def, refs) => { + if (refs.pipeStrategy === "input") { + return parseDef_parseDef(def.in._def, refs); + } + else if (refs.pipeStrategy === "output") { + return parseDef_parseDef(def.out._def, refs); + } + const a = parseDef_parseDef(def.in._def, { + ...refs, + currentPath: [...refs.currentPath, "allOf", "0"], + }); + const b = parseDef_parseDef(def.out._def, { + ...refs, + currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"], + }); + return { + allOf: [a, b].filter((x) => x !== undefined), + }; +}; + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/promise.js + +function parsePromiseDef(def, refs) { + return parseDef_parseDef(def.type._def, refs); +} + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/set.js + + +function parseSetDef(def, refs) { + const items = parseDef_parseDef(def.valueType._def, { + ...refs, + currentPath: [...refs.currentPath, "items"], + }); + const schema = { + type: "array", + uniqueItems: true, + items, + }; + if (def.minSize) { + setResponseValueAndErrors(schema, "minItems", def.minSize.value, def.minSize.message, refs); + } + if (def.maxSize) { + setResponseValueAndErrors(schema, "maxItems", def.maxSize.value, def.maxSize.message, refs); + } + return schema; +} + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/tuple.js + +function parseTupleDef(def, refs) { + if (def.rest) { + return { + type: "array", + minItems: def.items.length, + items: def.items + .map((x, i) => parseDef_parseDef(x._def, { + ...refs, + currentPath: [...refs.currentPath, "items", `${i}`], + })) + .reduce((acc, x) => (x === undefined ? acc : [...acc, x]), []), + additionalItems: parseDef_parseDef(def.rest._def, { + ...refs, + currentPath: [...refs.currentPath, "additionalItems"], + }), + }; + } + else { + return { + type: "array", + minItems: def.items.length, + maxItems: def.items.length, + items: def.items + .map((x, i) => parseDef_parseDef(x._def, { + ...refs, + currentPath: [...refs.currentPath, "items", `${i}`], + })) + .reduce((acc, x) => (x === undefined ? acc : [...acc, x]), []), + }; + } +} + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js +function parseUndefinedDef() { + return { + not: {}, + }; +} + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js +function parseUnknownDef() { + return {}; +} + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parsers/readonly.js + +const parseReadonlyDef = (def, refs) => { + return parseDef_parseDef(def.innerType._def, refs); +}; + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/parseDef.js + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +function parseDef_parseDef(def, refs, forceResolution = false) { + const seenItem = refs.seen.get(def); + if (refs.override) { + const overrideResult = refs.override?.(def, refs, seenItem, forceResolution); + if (overrideResult !== ignoreOverride) { + return overrideResult; + } + } + if (seenItem && !forceResolution) { + const seenSchema = get$ref(seenItem, refs); + if (seenSchema !== undefined) { + return seenSchema; + } + } + const newItem = { def, path: refs.currentPath, jsonSchema: undefined }; + refs.seen.set(def, newItem); + const jsonSchema = selectParser(def, def.typeName, refs); + if (jsonSchema) { + addMeta(def, refs, jsonSchema); + } + newItem.jsonSchema = jsonSchema; + return jsonSchema; +} +const get$ref = (item, refs) => { + switch (refs.$refStrategy) { + case "root": + return { $ref: item.path.join("/") }; + case "relative": + return { $ref: getRelativePath(refs.currentPath, item.path) }; + case "none": + case "seen": { + if (item.path.length < refs.currentPath.length && + item.path.every((value, index) => refs.currentPath[index] === value)) { + console.warn(`Recursive reference detected at ${refs.currentPath.join("/")}! Defaulting to any`); + return {}; + } + return refs.$refStrategy === "seen" ? {} : undefined; + } + } +}; +const getRelativePath = (pathA, pathB) => { + let i = 0; + for (; i < pathA.length && i < pathB.length; i++) { + if (pathA[i] !== pathB[i]) + break; + } + return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/"); +}; +const selectParser = (def, typeName, refs) => { + switch (typeName) { + case ZodFirstPartyTypeKind.ZodString: + return parseStringDef(def, refs); + case ZodFirstPartyTypeKind.ZodNumber: + return parseNumberDef(def, refs); + case ZodFirstPartyTypeKind.ZodObject: + return parseObjectDef(def, refs); + case ZodFirstPartyTypeKind.ZodBigInt: + return parseBigintDef(def, refs); + case ZodFirstPartyTypeKind.ZodBoolean: + return parseBooleanDef(); + case ZodFirstPartyTypeKind.ZodDate: + return parseDateDef(def, refs); + case ZodFirstPartyTypeKind.ZodUndefined: + return parseUndefinedDef(); + case ZodFirstPartyTypeKind.ZodNull: + return parseNullDef(refs); + case ZodFirstPartyTypeKind.ZodArray: + return parseArrayDef(def, refs); + case ZodFirstPartyTypeKind.ZodUnion: + case ZodFirstPartyTypeKind.ZodDiscriminatedUnion: + return parseUnionDef(def, refs); + case ZodFirstPartyTypeKind.ZodIntersection: + return parseIntersectionDef(def, refs); + case ZodFirstPartyTypeKind.ZodTuple: + return parseTupleDef(def, refs); + case ZodFirstPartyTypeKind.ZodRecord: + return parseRecordDef(def, refs); + case ZodFirstPartyTypeKind.ZodLiteral: + return parseLiteralDef(def, refs); + case ZodFirstPartyTypeKind.ZodEnum: + return parseEnumDef(def); + case ZodFirstPartyTypeKind.ZodNativeEnum: + return parseNativeEnumDef(def); + case ZodFirstPartyTypeKind.ZodNullable: + return parseNullableDef(def, refs); + case ZodFirstPartyTypeKind.ZodOptional: + return parseOptionalDef(def, refs); + case ZodFirstPartyTypeKind.ZodMap: + return parseMapDef(def, refs); + case ZodFirstPartyTypeKind.ZodSet: + return parseSetDef(def, refs); + case ZodFirstPartyTypeKind.ZodLazy: + return parseDef_parseDef(def.getter()._def, refs); + case ZodFirstPartyTypeKind.ZodPromise: + return parsePromiseDef(def, refs); + case ZodFirstPartyTypeKind.ZodNaN: + case ZodFirstPartyTypeKind.ZodNever: + return parseNeverDef(); + case ZodFirstPartyTypeKind.ZodEffects: + return parseEffectsDef(def, refs); + case ZodFirstPartyTypeKind.ZodAny: + return parseAnyDef(); + case ZodFirstPartyTypeKind.ZodUnknown: + return parseUnknownDef(); + case ZodFirstPartyTypeKind.ZodDefault: + return parseDefaultDef(def, refs); + case ZodFirstPartyTypeKind.ZodBranded: + return parseBrandedDef(def, refs); + case ZodFirstPartyTypeKind.ZodReadonly: + return parseReadonlyDef(def, refs); + case ZodFirstPartyTypeKind.ZodCatch: + return parseCatchDef(def, refs); + case ZodFirstPartyTypeKind.ZodPipeline: + return parsePipelineDef(def, refs); + case ZodFirstPartyTypeKind.ZodFunction: + case ZodFirstPartyTypeKind.ZodVoid: + case ZodFirstPartyTypeKind.ZodSymbol: + return undefined; + default: + return ((_) => undefined)(typeName); + } +}; +const addMeta = (def, refs, jsonSchema) => { + if (def.description) { + jsonSchema.description = def.description; + if (refs.markdownDescription) { + jsonSchema.markdownDescription = def.description; + } + } + return jsonSchema; +}; + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js + + +const zodToJsonSchema_zodToJsonSchema = (schema, options) => { + const refs = getRefs(options); + const definitions = typeof options === "object" && options.definitions + ? Object.entries(options.definitions).reduce((acc, [name, schema]) => ({ + ...acc, + [name]: parseDef_parseDef(schema._def, { + ...refs, + currentPath: [...refs.basePath, refs.definitionPath, name], + }, true) ?? {}, + }), {}) + : undefined; + const name = typeof options === "string" ? options : options?.name; + const main = parseDef_parseDef(schema._def, name === undefined + ? refs + : { + ...refs, + currentPath: [...refs.basePath, refs.definitionPath, name], + }, false) ?? {}; + const combined = name === undefined + ? definitions + ? { + ...main, + [refs.definitionPath]: definitions, + } + : main + : { + $ref: [ + ...(refs.$refStrategy === "relative" ? [] : refs.basePath), + refs.definitionPath, + name, + ].join("/"), + [refs.definitionPath]: { + ...definitions, + [name]: main, + }, + }; + if (refs.target === "jsonSchema7") { + combined.$schema = "http://json-schema.org/draft-07/schema#"; + } + else if (refs.target === "jsonSchema2019-09") { + combined.$schema = "https://json-schema.org/draft/2019-09/schema#"; + } + return combined; +}; + + +;// CONCATENATED MODULE: ./node_modules/zod-to-json-schema/dist/esm/index.js + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +/* harmony default export */ const esm = ((/* unused pure expression or super */ null && (zodToJsonSchema))); + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/runnables/graph.js + + + +const MAX_DATA_DISPLAY_NAME_LENGTH = 42; +function nodeDataStr(node) { + if (!isUuid(node.id)) { + return node.id; + } + else if (isRunnableInterface(node.data)) { + try { + let data = node.data.toString(); + if (data.startsWith("<") || + data[0] !== data[0].toUpperCase() || + data.split("\n").length > 1) { + data = node.data.getName(); + } + else if (data.length > MAX_DATA_DISPLAY_NAME_LENGTH) { + data = `${data.substring(0, MAX_DATA_DISPLAY_NAME_LENGTH)}...`; + } + return data.startsWith("Runnable") ? data.slice("Runnable".length) : data; + } + catch (error) { + return node.data.getName(); + } + } + else { + return node.data.name ?? "UnknownSchema"; + } +} +function nodeDataJson(node) { + // if node.data is implements Runnable + if (utils_isRunnableInterface(node.data)) { + return { + type: "runnable", + data: { + id: node.data.lc_id, + name: node.data.getName(), + }, + }; + } + else { + return { + type: "schema", + data: { ...zodToJsonSchema_zodToJsonSchema(node.data.schema), title: node.data.name }, + }; + } +} +class Graph { + constructor() { + Object.defineProperty(this, "nodes", { + enumerable: true, + configurable: true, + writable: true, + value: {} + }); + Object.defineProperty(this, "edges", { + enumerable: true, + configurable: true, + writable: true, + value: [] + }); + } + // Convert the graph to a JSON-serializable format. + // eslint-disable-next-line @typescript-eslint/no-explicit-any + toJSON() { + const stableNodeIds = {}; + Object.values(this.nodes).forEach((node, i) => { + stableNodeIds[node.id] = validate(node.id) ? i : node.id; + }); + return { + nodes: Object.values(this.nodes).map((node) => ({ + id: stableNodeIds[node.id], + ...nodeDataJson(node), + })), + edges: this.edges.map((edge) => edge.data + ? { + source: stableNodeIds[edge.source], + target: stableNodeIds[edge.target], + data: edge.data, + } + : { + source: stableNodeIds[edge.source], + target: stableNodeIds[edge.target], + }), + }; + } + addNode(data, id) { + if (id !== undefined && this.nodes[id] !== undefined) { + throw new Error(`Node with id ${id} already exists`); + } + const nodeId = id || v4(); + const node = { id: nodeId, data }; + this.nodes[nodeId] = node; + return node; + } + removeNode(node) { + // Remove the node from the nodes map + delete this.nodes[node.id]; + // Filter out edges connected to the node + this.edges = this.edges.filter((edge) => edge.source !== node.id && edge.target !== node.id); + } + addEdge(source, target, data) { + if (this.nodes[source.id] === undefined) { + throw new Error(`Source node ${source.id} not in graph`); + } + if (this.nodes[target.id] === undefined) { + throw new Error(`Target node ${target.id} not in graph`); + } + const edge = { source: source.id, target: target.id, data }; + this.edges.push(edge); + return edge; + } + firstNode() { + const targets = new Set(this.edges.map((edge) => edge.target)); + const found = []; + Object.values(this.nodes).forEach((node) => { + if (!targets.has(node.id)) { + found.push(node); + } + }); + return found[0]; + } + lastNode() { + const sources = new Set(this.edges.map((edge) => edge.source)); + const found = []; + Object.values(this.nodes).forEach((node) => { + if (!sources.has(node.id)) { + found.push(node); + } + }); + return found[0]; + } + extend(graph) { + // Add all nodes from the other graph, taking care to avoid duplicates + Object.entries(graph.nodes).forEach(([key, value]) => { + this.nodes[key] = value; + }); + // Add all edges from the other graph + this.edges = [...this.edges, ...graph.edges]; + } + trimFirstNode() { + const firstNode = this.firstNode(); + if (firstNode) { + const outgoingEdges = this.edges.filter((edge) => edge.source === firstNode.id); + if (Object.keys(this.nodes).length === 1 || outgoingEdges.length === 1) { + this.removeNode(firstNode); + } + } + } + trimLastNode() { + const lastNode = this.lastNode(); + if (lastNode) { + const incomingEdges = this.edges.filter((edge) => edge.target === lastNode.id); + if (Object.keys(this.nodes).length === 1 || incomingEdges.length === 1) { + this.removeNode(lastNode); + } + } + } +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/runnables/wrappers.js + +function convertToHttpEventStream(stream) { + const encoder = new TextEncoder(); + const finalStream = new ReadableStream({ + async start(controller) { + for await (const chunk of stream) { + controller.enqueue(encoder.encode(`event: data\ndata: ${JSON.stringify(chunk)}\n\n`)); + } + controller.enqueue(encoder.encode("event: end\n\n")); + controller.close(); + }, + }); + return IterableReadableStream.fromReadableStream(finalStream); +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/runnables/iter.js + +function isIterator(thing) { + return (typeof thing === "object" && + thing !== null && + typeof thing[Symbol.iterator] === "function" && + // avoid detecting array/set as iterator + typeof thing.next === "function"); +} +function isAsyncIterable(thing) { + return (typeof thing === "object" && + thing !== null && + typeof thing[Symbol.asyncIterator] === + "function"); +} +function* consumeIteratorInContext(context, iter) { + const storage = AsyncLocalStorageProviderSingleton.getInstance(); + while (true) { + const { value, done } = storage.run(context, iter.next.bind(iter)); + if (done) { + break; + } + else { + yield value; + } + } +} +async function* consumeAsyncIterableInContext(context, iter) { + const storage = AsyncLocalStorageProviderSingleton.getInstance(); + const iterator = iter[Symbol.asyncIterator](); + while (true) { + const { value, done } = await storage.run(context, iterator.next.bind(iter)); + if (done) { + break; + } + else { + yield value; + } + } +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/runnables/base.js + + + + + + + + + + + + + + +// eslint-disable-next-line @typescript-eslint/no-explicit-any +function base_coerceToDict(value, defaultKey) { + return value && + !Array.isArray(value) && + // eslint-disable-next-line no-instanceof/no-instanceof + !(value instanceof Date) && + typeof value === "object" + ? value + : { [defaultKey]: value }; +} +/** + * A Runnable is a generic unit of work that can be invoked, batched, streamed, and/or + * transformed. + */ +class Runnable extends serializable/* Serializable */.i { + constructor() { + super(...arguments); + Object.defineProperty(this, "lc_runnable", { + enumerable: true, + configurable: true, + writable: true, + value: true + }); + Object.defineProperty(this, "name", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + } + getName(suffix) { + const name = + // eslint-disable-next-line @typescript-eslint/no-explicit-any + this.name ?? this.constructor.lc_name() ?? this.constructor.name; + return suffix ? `${name}${suffix}` : name; + } + /** + * Bind arguments to a Runnable, returning a new Runnable. + * @param kwargs + * @returns A new RunnableBinding that, when invoked, will apply the bound args. + */ + bind(kwargs) { + // eslint-disable-next-line @typescript-eslint/no-use-before-define + return new RunnableBinding({ bound: this, kwargs, config: {} }); + } + /** + * Return a new Runnable that maps a list of inputs to a list of outputs, + * by calling invoke() with each input. + */ + map() { + // eslint-disable-next-line @typescript-eslint/no-use-before-define + return new RunnableEach({ bound: this }); + } + /** + * Add retry logic to an existing runnable. + * @param kwargs + * @returns A new RunnableRetry that, when invoked, will retry according to the parameters. + */ + withRetry(fields) { + // eslint-disable-next-line @typescript-eslint/no-use-before-define + return new RunnableRetry({ + bound: this, + kwargs: {}, + config: {}, + maxAttemptNumber: fields?.stopAfterAttempt, + ...fields, + }); + } + /** + * Bind config to a Runnable, returning a new Runnable. + * @param config New configuration parameters to attach to the new runnable. + * @returns A new RunnableBinding with a config matching what's passed. + */ + withConfig(config) { + // eslint-disable-next-line @typescript-eslint/no-use-before-define + return new RunnableBinding({ + bound: this, + config, + kwargs: {}, + }); + } + /** + * Create a new runnable from the current one that will try invoking + * other passed fallback runnables if the initial invocation fails. + * @param fields.fallbacks Other runnables to call if the runnable errors. + * @returns A new RunnableWithFallbacks. + */ + withFallbacks(fields) { + // eslint-disable-next-line @typescript-eslint/no-use-before-define + return new RunnableWithFallbacks({ + runnable: this, + fallbacks: fields.fallbacks, + }); + } + _getOptionsList(options, length = 0) { + if (Array.isArray(options) && options.length !== length) { + throw new Error(`Passed "options" must be an array with the same length as the inputs, but got ${options.length} options for ${length} inputs`); + } + if (Array.isArray(options)) { + return options.map(ensureConfig); + } + if (length > 1 && !Array.isArray(options) && options.runId) { + console.warn("Provided runId will be used only for the first element of the batch."); + const subsequent = Object.fromEntries(Object.entries(options).filter(([key]) => key !== "runId")); + return Array.from({ length }, (_, i) => ensureConfig(i === 0 ? options : subsequent)); + } + return Array.from({ length }, () => ensureConfig(options)); + } + async batch(inputs, options, batchOptions) { + const configList = this._getOptionsList(options ?? {}, inputs.length); + const maxConcurrency = configList[0]?.maxConcurrency ?? batchOptions?.maxConcurrency; + const caller = new async_caller_AsyncCaller({ + maxConcurrency, + onFailedAttempt: (e) => { + throw e; + }, + }); + const batchCalls = inputs.map((input, i) => caller.call(async () => { + try { + const result = await this.invoke(input, configList[i]); + return result; + } + catch (e) { + if (batchOptions?.returnExceptions) { + return e; + } + throw e; + } + })); + return Promise.all(batchCalls); + } + /** + * Default streaming implementation. + * Subclasses should override this method if they support streaming output. + * @param input + * @param options + */ + async *_streamIterator(input, options) { + yield this.invoke(input, options); + } + /** + * Stream output in chunks. + * @param input + * @param options + * @returns A readable stream that is also an iterable. + */ + async stream(input, options) { + // Buffer the first streamed chunk to allow for initial errors + // to surface immediately. + const config = ensureConfig(options); + const wrappedGenerator = new AsyncGeneratorWithSetup({ + generator: this._streamIterator(input, config), + config, + }); + await wrappedGenerator.setup; + return IterableReadableStream.fromAsyncGenerator(wrappedGenerator); + } + _separateRunnableConfigFromCallOptions(options) { + let runnableConfig; + if (options === undefined) { + runnableConfig = ensureConfig(options); + } + else { + runnableConfig = ensureConfig({ + callbacks: options.callbacks, + tags: options.tags, + metadata: options.metadata, + runName: options.runName, + configurable: options.configurable, + recursionLimit: options.recursionLimit, + maxConcurrency: options.maxConcurrency, + runId: options.runId, + }); + } + const callOptions = { ...options }; + delete callOptions.callbacks; + delete callOptions.tags; + delete callOptions.metadata; + delete callOptions.runName; + delete callOptions.configurable; + delete callOptions.recursionLimit; + delete callOptions.maxConcurrency; + delete callOptions.runId; + return [runnableConfig, callOptions]; + } + async _callWithConfig(func, input, options) { + const config = ensureConfig(options); + const callbackManager_ = await getCallbackManagerForConfig(config); + const runManager = await callbackManager_?.handleChainStart(this.toJSON(), base_coerceToDict(input, "input"), config.runId, config?.runType, undefined, undefined, config?.runName ?? this.getName()); + delete config.runId; + let output; + try { + output = await func.call(this, input, config, runManager); + } + catch (e) { + await runManager?.handleChainError(e); + throw e; + } + await runManager?.handleChainEnd(base_coerceToDict(output, "output")); + return output; + } + /** + * Internal method that handles batching and configuration for a runnable + * It takes a function, input values, and optional configuration, and + * returns a promise that resolves to the output values. + * @param func The function to be executed for each input value. + * @param input The input values to be processed. + * @param config Optional configuration for the function execution. + * @returns A promise that resolves to the output values. + */ + async _batchWithConfig(func, inputs, options, batchOptions) { + const optionsList = this._getOptionsList(options ?? {}, inputs.length); + const callbackManagers = await Promise.all(optionsList.map(getCallbackManagerForConfig)); + const runManagers = await Promise.all(callbackManagers.map(async (callbackManager, i) => { + const handleStartRes = await callbackManager?.handleChainStart(this.toJSON(), base_coerceToDict(inputs[i], "input"), optionsList[i].runId, optionsList[i].runType, undefined, undefined, optionsList[i].runName ?? this.getName()); + delete optionsList[i].runId; + return handleStartRes; + })); + let outputs; + try { + outputs = await func.call(this, inputs, optionsList, runManagers, batchOptions); + } + catch (e) { + await Promise.all(runManagers.map((runManager) => runManager?.handleChainError(e))); + throw e; + } + await Promise.all(runManagers.map((runManager) => runManager?.handleChainEnd(base_coerceToDict(outputs, "output")))); + return outputs; + } + /** + * Helper method to transform an Iterator of Input values into an Iterator of + * Output values, with callbacks. + * Use this to implement `stream()` or `transform()` in Runnable subclasses. + */ + async *_transformStreamWithConfig(inputGenerator, transformer, options) { + let finalInput; + let finalInputSupported = true; + let finalOutput; + let finalOutputSupported = true; + const config = ensureConfig(options); + const callbackManager_ = await getCallbackManagerForConfig(config); + async function* wrapInputForTracing() { + for await (const chunk of inputGenerator) { + if (finalInputSupported) { + if (finalInput === undefined) { + finalInput = chunk; + } + else { + try { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + finalInput = concat(finalInput, chunk); + } + catch { + finalInput = undefined; + finalInputSupported = false; + } + } + } + yield chunk; + } + } + let runManager; + try { + const pipe = await pipeGeneratorWithSetup(transformer.bind(this), wrapInputForTracing(), async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, config.runId, config.runType, undefined, undefined, config.runName ?? this.getName()), config); + delete config.runId; + runManager = pipe.setup; + const isLogStreamHandler = (handler) => handler.name === "log_stream_tracer"; + const streamLogHandler = runManager?.handlers.find(isLogStreamHandler); + let iterator = pipe.output; + if (streamLogHandler !== undefined && runManager !== undefined) { + iterator = await streamLogHandler.tapOutputIterable(runManager.runId, pipe.output); + } + for await (const chunk of iterator) { + yield chunk; + if (finalOutputSupported) { + if (finalOutput === undefined) { + finalOutput = chunk; + } + else { + try { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + finalOutput = concat(finalOutput, chunk); + } + catch { + finalOutput = undefined; + finalOutputSupported = false; + } + } + } + } + } + catch (e) { + await runManager?.handleChainError(e, undefined, undefined, undefined, { + inputs: base_coerceToDict(finalInput, "input"), + }); + throw e; + } + await runManager?.handleChainEnd(finalOutput ?? {}, undefined, undefined, undefined, { inputs: base_coerceToDict(finalInput, "input") }); + } + getGraph(_) { + const graph = new Graph(); + // TODO: Add input schema for runnables + const inputNode = graph.addNode({ + name: `${this.getName()}Input`, + schema: z.any(), + }); + const runnableNode = graph.addNode(this); + // TODO: Add output schemas for runnables + const outputNode = graph.addNode({ + name: `${this.getName()}Output`, + schema: z.any(), + }); + graph.addEdge(inputNode, runnableNode); + graph.addEdge(runnableNode, outputNode); + return graph; + } + /** + * Create a new runnable sequence that runs each individual runnable in series, + * piping the output of one runnable into another runnable or runnable-like. + * @param coerceable A runnable, function, or object whose values are functions or runnables. + * @returns A new runnable sequence. + */ + pipe(coerceable) { + // eslint-disable-next-line @typescript-eslint/no-use-before-define + return new RunnableSequence({ + first: this, + last: _coerceToRunnable(coerceable), + }); + } + /** + * Pick keys from the dict output of this runnable. Returns a new runnable. + */ + pick(keys) { + // eslint-disable-next-line @typescript-eslint/no-use-before-define + return this.pipe(new RunnablePick(keys)); + } + /** + * Assigns new fields to the dict output of this runnable. Returns a new runnable. + */ + assign(mapping) { + return this.pipe( + // eslint-disable-next-line @typescript-eslint/no-use-before-define + new RunnableAssign( + // eslint-disable-next-line @typescript-eslint/no-use-before-define + new RunnableMap({ steps: mapping }))); + } + /** + * Default implementation of transform, which buffers input and then calls stream. + * Subclasses should override this method if they can start producing output while + * input is still being generated. + * @param generator + * @param options + */ + async *transform(generator, options) { + let finalChunk; + for await (const chunk of generator) { + if (finalChunk === undefined) { + finalChunk = chunk; + } + else { + // Make a best effort to gather, for any type that supports concat. + // This method should throw an error if gathering fails. + // eslint-disable-next-line @typescript-eslint/no-explicit-any + finalChunk = concat(finalChunk, chunk); + } + } + yield* this._streamIterator(finalChunk, ensureConfig(options)); + } + /** + * Stream all output from a runnable, as reported to the callback system. + * This includes all inner runs of LLMs, Retrievers, Tools, etc. + * Output is streamed as Log objects, which include a list of + * jsonpatch ops that describe how the state of the run has changed in each + * step, and the final state of the run. + * The jsonpatch ops can be applied in order to construct state. + * @param input + * @param options + * @param streamOptions + */ + async *streamLog(input, options, streamOptions) { + const logStreamCallbackHandler = new LogStreamCallbackHandler({ + ...streamOptions, + autoClose: false, + _schemaFormat: "original", + }); + const config = ensureConfig(options); + yield* this._streamLog(input, logStreamCallbackHandler, config); + } + async *_streamLog(input, logStreamCallbackHandler, config) { + const { callbacks } = config; + if (callbacks === undefined) { + // eslint-disable-next-line no-param-reassign + config.callbacks = [logStreamCallbackHandler]; + } + else if (Array.isArray(callbacks)) { + // eslint-disable-next-line no-param-reassign + config.callbacks = callbacks.concat([logStreamCallbackHandler]); + } + else { + const copiedCallbacks = callbacks.copy(); + copiedCallbacks.inheritableHandlers.push(logStreamCallbackHandler); + // eslint-disable-next-line no-param-reassign + config.callbacks = copiedCallbacks; + } + const runnableStreamPromise = this.stream(input, config); + async function consumeRunnableStream() { + try { + const runnableStream = await runnableStreamPromise; + for await (const chunk of runnableStream) { + const patch = new RunLogPatch({ + ops: [ + { + op: "add", + path: "/streamed_output/-", + value: chunk, + }, + ], + }); + await logStreamCallbackHandler.writer.write(patch); + } + } + finally { + await logStreamCallbackHandler.writer.close(); + } + } + const runnableStreamConsumePromise = consumeRunnableStream(); + try { + for await (const log of logStreamCallbackHandler) { + yield log; + } + } + finally { + await runnableStreamConsumePromise; + } + } + streamEvents(input, options, streamOptions) { + const stream = this._streamEvents(input, options, streamOptions); + if (options.encoding === "text/event-stream") { + return convertToHttpEventStream(stream); + } + else { + return IterableReadableStream.fromAsyncGenerator(stream); + } + } + async *_streamEvents(input, options, streamOptions) { + if (options.version !== "v1") { + throw new Error(`Only version "v1" of the events schema is currently supported.`); + } + let runLog; + let hasEncounteredStartEvent = false; + const config = ensureConfig(options); + const rootTags = config.tags ?? []; + const rootMetadata = config.metadata ?? {}; + const rootName = config.runName ?? this.getName(); + const logStreamCallbackHandler = new LogStreamCallbackHandler({ + ...streamOptions, + autoClose: false, + _schemaFormat: "streaming_events", + }); + const rootEventFilter = new _RootEventFilter({ + ...streamOptions, + }); + const logStream = this._streamLog(input, logStreamCallbackHandler, config); + for await (const log of logStream) { + if (!runLog) { + runLog = RunLog.fromRunLogPatch(log); + } + else { + runLog = runLog.concat(log); + } + if (runLog.state === undefined) { + throw new Error(`Internal error: "streamEvents" state is missing. Please open a bug report.`); + } + // Yield the start event for the root runnable if it hasn't been seen. + // The root run is never filtered out + if (!hasEncounteredStartEvent) { + hasEncounteredStartEvent = true; + const state = { ...runLog.state }; + const event = { + run_id: state.id, + event: `on_${state.type}_start`, + name: rootName, + tags: rootTags, + metadata: rootMetadata, + data: { + input, + }, + }; + if (rootEventFilter.includeEvent(event, state.type)) { + yield event; + } + } + const paths = log.ops + .filter((op) => op.path.startsWith("/logs/")) + .map((op) => op.path.split("/")[2]); + const dedupedPaths = [...new Set(paths)]; + for (const path of dedupedPaths) { + let eventType; + let data = {}; + const logEntry = runLog.state.logs[path]; + if (logEntry.end_time === undefined) { + if (logEntry.streamed_output.length > 0) { + eventType = "stream"; + } + else { + eventType = "start"; + } + } + else { + eventType = "end"; + } + if (eventType === "start") { + // Include the inputs with the start event if they are available. + // Usually they will NOT be available for components that operate + // on streams, since those components stream the input and + // don't know its final value until the end of the stream. + if (logEntry.inputs !== undefined) { + data.input = logEntry.inputs; + } + } + else if (eventType === "end") { + if (logEntry.inputs !== undefined) { + data.input = logEntry.inputs; + } + data.output = logEntry.final_output; + } + else if (eventType === "stream") { + const chunkCount = logEntry.streamed_output.length; + if (chunkCount !== 1) { + throw new Error(`Expected exactly one chunk of streamed output, got ${chunkCount} instead. Encountered in: "${logEntry.name}"`); + } + data = { chunk: logEntry.streamed_output[0] }; + // Clean up the stream, we don't need it anymore. + // And this avoids duplicates as well! + logEntry.streamed_output = []; + } + yield { + event: `on_${logEntry.type}_${eventType}`, + name: logEntry.name, + run_id: logEntry.id, + tags: logEntry.tags, + metadata: logEntry.metadata, + data, + }; + } + // Finally, we take care of the streaming output from the root chain + // if there is any. + const { state } = runLog; + if (state.streamed_output.length > 0) { + const chunkCount = state.streamed_output.length; + if (chunkCount !== 1) { + throw new Error(`Expected exactly one chunk of streamed output, got ${chunkCount} instead. Encountered in: "${state.name}"`); + } + const data = { chunk: state.streamed_output[0] }; + // Clean up the stream, we don't need it anymore. + state.streamed_output = []; + const event = { + event: `on_${state.type}_stream`, + run_id: state.id, + tags: rootTags, + metadata: rootMetadata, + name: rootName, + data, + }; + if (rootEventFilter.includeEvent(event, state.type)) { + yield event; + } + } + } + const state = runLog?.state; + if (state !== undefined) { + // Finally, yield the end event for the root runnable. + const event = { + event: `on_${state.type}_end`, + name: rootName, + run_id: state.id, + tags: rootTags, + metadata: rootMetadata, + data: { + output: state.final_output, + }, + }; + if (rootEventFilter.includeEvent(event, state.type)) + yield event; + } + } + // eslint-disable-next-line @typescript-eslint/no-explicit-any + static isRunnable(thing) { + return utils_isRunnableInterface(thing); + } + /** + * Bind lifecycle listeners to a Runnable, returning a new Runnable. + * The Run object contains information about the run, including its id, + * type, input, output, error, startTime, endTime, and any tags or metadata + * added to the run. + * + * @param {Object} params - The object containing the callback functions. + * @param {(run: Run) => void} params.onStart - Called before the runnable starts running, with the Run object. + * @param {(run: Run) => void} params.onEnd - Called after the runnable finishes running, with the Run object. + * @param {(run: Run) => void} params.onError - Called if the runnable throws an error, with the Run object. + */ + withListeners({ onStart, onEnd, onError, }) { + // eslint-disable-next-line @typescript-eslint/no-use-before-define + return new RunnableBinding({ + bound: this, + config: {}, + configFactories: [ + (config) => ({ + callbacks: [ + new RootListenersTracer({ + config, + onStart, + onEnd, + onError, + }), + ], + }), + ], + }); + } +} +/** + * A runnable that delegates calls to another runnable with a set of kwargs. + */ +class RunnableBinding extends Runnable { + static lc_name() { + return "RunnableBinding"; + } + constructor(fields) { + super(fields); + Object.defineProperty(this, "lc_namespace", { + enumerable: true, + configurable: true, + writable: true, + value: ["langchain_core", "runnables"] + }); + Object.defineProperty(this, "lc_serializable", { + enumerable: true, + configurable: true, + writable: true, + value: true + }); + Object.defineProperty(this, "bound", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "config", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "kwargs", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "configFactories", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.bound = fields.bound; + this.kwargs = fields.kwargs; + this.config = fields.config; + this.configFactories = fields.configFactories; + } + getName(suffix) { + return this.bound.getName(suffix); + } + async _mergeConfig(...options) { + const config = mergeConfigs(this.config, ...options); + return mergeConfigs(config, ...(this.configFactories + ? await Promise.all(this.configFactories.map(async (configFactory) => await configFactory(config))) + : [])); + } + bind(kwargs) { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + return new this.constructor({ + bound: this.bound, + kwargs: { ...this.kwargs, ...kwargs }, + config: this.config, + }); + } + withConfig(config) { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + return new this.constructor({ + bound: this.bound, + kwargs: this.kwargs, + config: { ...this.config, ...config }, + }); + } + withRetry(fields) { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + return new this.constructor({ + bound: this.bound.withRetry(fields), + kwargs: this.kwargs, + config: this.config, + }); + } + async invoke(input, options) { + return this.bound.invoke(input, await this._mergeConfig(ensureConfig(options), this.kwargs)); + } + async batch(inputs, options, batchOptions) { + const mergedOptions = Array.isArray(options) + ? await Promise.all(options.map(async (individualOption) => this._mergeConfig(ensureConfig(individualOption), this.kwargs))) + : await this._mergeConfig(ensureConfig(options), this.kwargs); + return this.bound.batch(inputs, mergedOptions, batchOptions); + } + async *_streamIterator(input, options) { + yield* this.bound._streamIterator(input, await this._mergeConfig(ensureConfig(options), this.kwargs)); + } + async stream(input, options) { + return this.bound.stream(input, await this._mergeConfig(ensureConfig(options), this.kwargs)); + } + async *transform( + // eslint-disable-next-line @typescript-eslint/no-explicit-any + generator, options) { + yield* this.bound.transform(generator, await this._mergeConfig(ensureConfig(options), this.kwargs)); + } + streamEvents(input, options, streamOptions) { + // eslint-disable-next-line @typescript-eslint/no-this-alias + const outerThis = this; + const generator = async function* () { + yield* outerThis.bound.streamEvents(input, { + ...(await outerThis._mergeConfig(ensureConfig(options), outerThis.kwargs)), + version: options.version, + }, streamOptions); + }; + return IterableReadableStream.fromAsyncGenerator(generator()); + } + static isRunnableBinding( + // eslint-disable-next-line @typescript-eslint/no-explicit-any + thing + // eslint-disable-next-line @typescript-eslint/no-explicit-any + ) { + return thing.bound && Runnable.isRunnable(thing.bound); + } + /** + * Bind lifecycle listeners to a Runnable, returning a new Runnable. + * The Run object contains information about the run, including its id, + * type, input, output, error, startTime, endTime, and any tags or metadata + * added to the run. + * + * @param {Object} params - The object containing the callback functions. + * @param {(run: Run) => void} params.onStart - Called before the runnable starts running, with the Run object. + * @param {(run: Run) => void} params.onEnd - Called after the runnable finishes running, with the Run object. + * @param {(run: Run) => void} params.onError - Called if the runnable throws an error, with the Run object. + */ + withListeners({ onStart, onEnd, onError, }) { + return new RunnableBinding({ + bound: this.bound, + kwargs: this.kwargs, + config: this.config, + configFactories: [ + (config) => ({ + callbacks: [ + new RootListenersTracer({ + config, + onStart, + onEnd, + onError, + }), + ], + }), + ], + }); + } +} +/** + * A runnable that delegates calls to another runnable + * with each element of the input sequence. + */ +class RunnableEach extends Runnable { + static lc_name() { + return "RunnableEach"; + } + constructor(fields) { + super(fields); + Object.defineProperty(this, "lc_serializable", { + enumerable: true, + configurable: true, + writable: true, + value: true + }); + Object.defineProperty(this, "lc_namespace", { + enumerable: true, + configurable: true, + writable: true, + value: ["langchain_core", "runnables"] + }); + Object.defineProperty(this, "bound", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.bound = fields.bound; + } + /** + * Binds the runnable with the specified arguments. + * @param kwargs The arguments to bind the runnable with. + * @returns A new instance of the `RunnableEach` class that is bound with the specified arguments. + */ + bind(kwargs) { + return new RunnableEach({ + bound: this.bound.bind(kwargs), + }); + } + /** + * Invokes the runnable with the specified input and configuration. + * @param input The input to invoke the runnable with. + * @param config The configuration to invoke the runnable with. + * @returns A promise that resolves to the output of the runnable. + */ + async invoke(inputs, config) { + return this._callWithConfig(this._invoke, inputs, config); + } + /** + * A helper method that is used to invoke the runnable with the specified input and configuration. + * @param input The input to invoke the runnable with. + * @param config The configuration to invoke the runnable with. + * @returns A promise that resolves to the output of the runnable. + */ + async _invoke(inputs, config, runManager) { + return this.bound.batch(inputs, patchConfig(config, { callbacks: runManager?.getChild() })); + } + /** + * Bind lifecycle listeners to a Runnable, returning a new Runnable. + * The Run object contains information about the run, including its id, + * type, input, output, error, startTime, endTime, and any tags or metadata + * added to the run. + * + * @param {Object} params - The object containing the callback functions. + * @param {(run: Run) => void} params.onStart - Called before the runnable starts running, with the Run object. + * @param {(run: Run) => void} params.onEnd - Called after the runnable finishes running, with the Run object. + * @param {(run: Run) => void} params.onError - Called if the runnable throws an error, with the Run object. + */ + withListeners({ onStart, onEnd, onError, }) { + return new RunnableEach({ + bound: this.bound.withListeners({ onStart, onEnd, onError }), + }); + } +} +/** + * Base class for runnables that can be retried a + * specified number of times. + */ +class RunnableRetry extends RunnableBinding { + static lc_name() { + return "RunnableRetry"; + } + constructor(fields) { + super(fields); + Object.defineProperty(this, "lc_namespace", { + enumerable: true, + configurable: true, + writable: true, + value: ["langchain_core", "runnables"] + }); + Object.defineProperty(this, "maxAttemptNumber", { + enumerable: true, + configurable: true, + writable: true, + value: 3 + }); + // eslint-disable-next-line @typescript-eslint/no-explicit-any + Object.defineProperty(this, "onFailedAttempt", { + enumerable: true, + configurable: true, + writable: true, + value: () => { } + }); + this.maxAttemptNumber = fields.maxAttemptNumber ?? this.maxAttemptNumber; + this.onFailedAttempt = fields.onFailedAttempt ?? this.onFailedAttempt; + } + _patchConfigForRetry(attempt, config, runManager) { + const tag = attempt > 1 ? `retry:attempt:${attempt}` : undefined; + return patchConfig(config, { callbacks: runManager?.getChild(tag) }); + } + async _invoke(input, config, runManager) { + return p_retry((attemptNumber) => super.invoke(input, this._patchConfigForRetry(attemptNumber, config, runManager)), { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + onFailedAttempt: (error) => this.onFailedAttempt(error, input), + retries: Math.max(this.maxAttemptNumber - 1, 0), + randomize: true, + }); + } + /** + * Method that invokes the runnable with the specified input, run manager, + * and config. It handles the retry logic by catching any errors and + * recursively invoking itself with the updated config for the next retry + * attempt. + * @param input The input for the runnable. + * @param runManager The run manager for the runnable. + * @param config The config for the runnable. + * @returns A promise that resolves to the output of the runnable. + */ + async invoke(input, config) { + return this._callWithConfig(this._invoke, input, config); + } + async _batch(inputs, configs, runManagers, batchOptions) { + const resultsMap = {}; + try { + await p_retry(async (attemptNumber) => { + const remainingIndexes = inputs + .map((_, i) => i) + .filter((i) => resultsMap[i.toString()] === undefined || + // eslint-disable-next-line no-instanceof/no-instanceof + resultsMap[i.toString()] instanceof Error); + const remainingInputs = remainingIndexes.map((i) => inputs[i]); + const patchedConfigs = remainingIndexes.map((i) => this._patchConfigForRetry(attemptNumber, configs?.[i], runManagers?.[i])); + const results = await super.batch(remainingInputs, patchedConfigs, { + ...batchOptions, + returnExceptions: true, + }); + let firstException; + for (let i = 0; i < results.length; i += 1) { + const result = results[i]; + const resultMapIndex = remainingIndexes[i]; + // eslint-disable-next-line no-instanceof/no-instanceof + if (result instanceof Error) { + if (firstException === undefined) { + firstException = result; + // eslint-disable-next-line @typescript-eslint/no-explicit-any + firstException.input = remainingInputs[i]; + } + } + resultsMap[resultMapIndex.toString()] = result; + } + if (firstException) { + throw firstException; + } + return results; + }, { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + onFailedAttempt: (error) => this.onFailedAttempt(error, error.input), + retries: Math.max(this.maxAttemptNumber - 1, 0), + randomize: true, + }); + } + catch (e) { + if (batchOptions?.returnExceptions !== true) { + throw e; + } + } + return Object.keys(resultsMap) + .sort((a, b) => parseInt(a, 10) - parseInt(b, 10)) + .map((key) => resultsMap[parseInt(key, 10)]); + } + async batch(inputs, options, batchOptions) { + return this._batchWithConfig(this._batch.bind(this), inputs, options, batchOptions); + } +} +/** + * A sequence of runnables, where the output of each is the input of the next. + * @example + * ```typescript + * const promptTemplate = PromptTemplate.fromTemplate( + * "Tell me a joke about {topic}", + * ); + * const chain = RunnableSequence.from([promptTemplate, new ChatOpenAI({})]); + * const result = await chain.invoke({ topic: "bears" }); + * ``` + */ +class RunnableSequence extends Runnable { + static lc_name() { + return "RunnableSequence"; + } + constructor(fields) { + super(fields); + Object.defineProperty(this, "first", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "middle", { + enumerable: true, + configurable: true, + writable: true, + value: [] + }); + // eslint-disable-next-line @typescript-eslint/no-explicit-any + Object.defineProperty(this, "last", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "lc_serializable", { + enumerable: true, + configurable: true, + writable: true, + value: true + }); + Object.defineProperty(this, "lc_namespace", { + enumerable: true, + configurable: true, + writable: true, + value: ["langchain_core", "runnables"] + }); + this.first = fields.first; + this.middle = fields.middle ?? this.middle; + this.last = fields.last; + this.name = fields.name; + } + get steps() { + return [this.first, ...this.middle, this.last]; + } + async invoke(input, options) { + const config = ensureConfig(options); + const callbackManager_ = await getCallbackManagerForConfig(config); + const runManager = await callbackManager_?.handleChainStart(this.toJSON(), base_coerceToDict(input, "input"), config.runId, undefined, undefined, undefined, config?.runName); + delete config.runId; + let nextStepInput = input; + let finalOutput; + try { + const initialSteps = [this.first, ...this.middle]; + for (let i = 0; i < initialSteps.length; i += 1) { + const step = initialSteps[i]; + nextStepInput = await step.invoke(nextStepInput, patchConfig(config, { + callbacks: runManager?.getChild(`seq:step:${i + 1}`), + })); + } + // TypeScript can't detect that the last output of the sequence returns RunOutput, so call it out of the loop here + finalOutput = await this.last.invoke(nextStepInput, patchConfig(config, { + callbacks: runManager?.getChild(`seq:step:${this.steps.length}`), + })); + } + catch (e) { + await runManager?.handleChainError(e); + throw e; + } + await runManager?.handleChainEnd(base_coerceToDict(finalOutput, "output")); + return finalOutput; + } + async batch(inputs, options, batchOptions) { + const configList = this._getOptionsList(options ?? {}, inputs.length); + const callbackManagers = await Promise.all(configList.map(getCallbackManagerForConfig)); + const runManagers = await Promise.all(callbackManagers.map(async (callbackManager, i) => { + const handleStartRes = await callbackManager?.handleChainStart(this.toJSON(), base_coerceToDict(inputs[i], "input"), configList[i].runId, undefined, undefined, undefined, configList[i].runName); + delete configList[i].runId; + return handleStartRes; + })); + // eslint-disable-next-line @typescript-eslint/no-explicit-any + let nextStepInputs = inputs; + try { + for (let i = 0; i < this.steps.length; i += 1) { + const step = this.steps[i]; + nextStepInputs = await step.batch(nextStepInputs, runManagers.map((runManager, j) => { + const childRunManager = runManager?.getChild(`seq:step:${i + 1}`); + return patchConfig(configList[j], { callbacks: childRunManager }); + }), batchOptions); + } + } + catch (e) { + await Promise.all(runManagers.map((runManager) => runManager?.handleChainError(e))); + throw e; + } + await Promise.all(runManagers.map((runManager) => runManager?.handleChainEnd(base_coerceToDict(nextStepInputs, "output")))); + return nextStepInputs; + } + async *_streamIterator(input, options) { + const callbackManager_ = await getCallbackManagerForConfig(options); + const { runId, ...otherOptions } = options ?? {}; + const runManager = await callbackManager_?.handleChainStart(this.toJSON(), base_coerceToDict(input, "input"), runId, undefined, undefined, undefined, otherOptions?.runName); + const steps = [this.first, ...this.middle, this.last]; + let concatSupported = true; + let finalOutput; + async function* inputGenerator() { + yield input; + } + try { + let finalGenerator = steps[0].transform(inputGenerator(), patchConfig(otherOptions, { + callbacks: runManager?.getChild(`seq:step:1`), + })); + for (let i = 1; i < steps.length; i += 1) { + const step = steps[i]; + finalGenerator = await step.transform(finalGenerator, patchConfig(otherOptions, { + callbacks: runManager?.getChild(`seq:step:${i + 1}`), + })); + } + for await (const chunk of finalGenerator) { + yield chunk; + if (concatSupported) { + if (finalOutput === undefined) { + finalOutput = chunk; + } + else { + try { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + finalOutput = concat(finalOutput, chunk); + } + catch (e) { + finalOutput = undefined; + concatSupported = false; + } + } + } + } + } + catch (e) { + await runManager?.handleChainError(e); + throw e; + } + await runManager?.handleChainEnd(base_coerceToDict(finalOutput, "output")); + } + getGraph(config) { + const graph = new Graph(); + // eslint-disable-next-line @typescript-eslint/no-explicit-any + let currentLastNode = null; + this.steps.forEach((step, index) => { + const stepGraph = step.getGraph(config); + if (index !== 0) { + stepGraph.trimFirstNode(); + } + if (index !== this.steps.length - 1) { + stepGraph.trimLastNode(); + } + graph.extend(stepGraph); + const stepFirstNode = stepGraph.firstNode(); + if (!stepFirstNode) { + throw new Error(`Runnable ${step} has no first node`); + } + if (currentLastNode) { + graph.addEdge(currentLastNode, stepFirstNode); + } + currentLastNode = stepGraph.lastNode(); + }); + return graph; + } + pipe(coerceable) { + if (RunnableSequence.isRunnableSequence(coerceable)) { + return new RunnableSequence({ + first: this.first, + middle: this.middle.concat([ + this.last, + coerceable.first, + ...coerceable.middle, + ]), + last: coerceable.last, + name: this.name ?? coerceable.name, + }); + } + else { + return new RunnableSequence({ + first: this.first, + middle: [...this.middle, this.last], + last: _coerceToRunnable(coerceable), + name: this.name, + }); + } + } + // eslint-disable-next-line @typescript-eslint/no-explicit-any + static isRunnableSequence(thing) { + return Array.isArray(thing.middle) && Runnable.isRunnable(thing); + } + // eslint-disable-next-line @typescript-eslint/no-explicit-any + static from([first, ...runnables], name) { + return new RunnableSequence({ + first: _coerceToRunnable(first), + middle: runnables.slice(0, -1).map(_coerceToRunnable), + last: _coerceToRunnable(runnables[runnables.length - 1]), + name, + }); + } +} +/** + * A runnable that runs a mapping of runnables in parallel, + * and returns a mapping of their outputs. + * @example + * ```typescript + * const mapChain = RunnableMap.from({ + * joke: PromptTemplate.fromTemplate("Tell me a joke about {topic}").pipe( + * new ChatAnthropic({}), + * ), + * poem: PromptTemplate.fromTemplate("write a 2-line poem about {topic}").pipe( + * new ChatAnthropic({}), + * ), + * }); + * const result = await mapChain.invoke({ topic: "bear" }); + * ``` + */ +class RunnableMap extends Runnable { + static lc_name() { + return "RunnableMap"; + } + getStepsKeys() { + return Object.keys(this.steps); + } + constructor(fields) { + super(fields); + Object.defineProperty(this, "lc_namespace", { + enumerable: true, + configurable: true, + writable: true, + value: ["langchain_core", "runnables"] + }); + Object.defineProperty(this, "lc_serializable", { + enumerable: true, + configurable: true, + writable: true, + value: true + }); + Object.defineProperty(this, "steps", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.steps = {}; + for (const [key, value] of Object.entries(fields.steps)) { + this.steps[key] = _coerceToRunnable(value); + } + } + static from(steps) { + return new RunnableMap({ steps }); + } + async invoke(input, options) { + const config = ensureConfig(options); + const callbackManager_ = await getCallbackManagerForConfig(config); + const runManager = await callbackManager_?.handleChainStart(this.toJSON(), { + input, + }, config.runId, undefined, undefined, undefined, config?.runName); + delete config.runId; + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const output = {}; + try { + await Promise.all(Object.entries(this.steps).map(async ([key, runnable]) => { + output[key] = await runnable.invoke(input, patchConfig(config, { + callbacks: runManager?.getChild(`map:key:${key}`), + })); + })); + } + catch (e) { + await runManager?.handleChainError(e); + throw e; + } + await runManager?.handleChainEnd(output); + return output; + } + async *_transform(generator, runManager, options) { + // shallow copy steps to ignore changes while iterating + const steps = { ...this.steps }; + // each step gets a copy of the input iterator + const inputCopies = atee(generator, Object.keys(steps).length); + // start the first iteration of each output iterator + const tasks = new Map(Object.entries(steps).map(([key, runnable], i) => { + const gen = runnable.transform(inputCopies[i], patchConfig(options, { + callbacks: runManager?.getChild(`map:key:${key}`), + })); + return [key, gen.next().then((result) => ({ key, gen, result }))]; + })); + // yield chunks as they become available, + // starting new iterations as needed, + // until all iterators are done + while (tasks.size) { + const { key, result, gen } = await Promise.race(tasks.values()); + tasks.delete(key); + if (!result.done) { + yield { [key]: result.value }; + tasks.set(key, gen.next().then((result) => ({ key, gen, result }))); + } + } + } + transform(generator, options) { + return this._transformStreamWithConfig(generator, this._transform.bind(this), options); + } + async stream(input, options) { + async function* generator() { + yield input; + } + const config = ensureConfig(options); + const wrappedGenerator = new AsyncGeneratorWithSetup({ + generator: this.transform(generator(), config), + config, + }); + await wrappedGenerator.setup; + return IterableReadableStream.fromAsyncGenerator(wrappedGenerator); + } +} +/** + * A runnable that runs a callable. + */ +class RunnableLambda extends Runnable { + static lc_name() { + return "RunnableLambda"; + } + constructor(fields) { + super(fields); + Object.defineProperty(this, "lc_namespace", { + enumerable: true, + configurable: true, + writable: true, + value: ["langchain_core", "runnables"] + }); + Object.defineProperty(this, "func", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.func = fields.func; + } + static from(func) { + return new RunnableLambda({ + func, + }); + } + async _invoke(input, config, runManager) { + return new Promise((resolve, reject) => { + const childConfig = patchConfig(config, { + callbacks: runManager?.getChild(), + recursionLimit: (config?.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1, + }); + void AsyncLocalStorageProviderSingleton.getInstance().run(childConfig, async () => { + try { + let output = await this.func(input, { + ...childConfig, + config: childConfig, + }); + if (output && Runnable.isRunnable(output)) { + if (config?.recursionLimit === 0) { + throw new Error("Recursion limit reached."); + } + output = await output.invoke(input, { + ...childConfig, + recursionLimit: (childConfig.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1, + }); + } + else if (isAsyncIterable(output)) { + let finalOutput; + for await (const chunk of consumeAsyncIterableInContext(childConfig, output)) { + if (finalOutput === undefined) { + finalOutput = chunk; + } + else { + // Make a best effort to gather, for any type that supports concat. + try { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + finalOutput = concat(finalOutput, chunk); + } + catch (e) { + finalOutput = chunk; + } + } + } + output = finalOutput; + } + else if (isIterator(output)) { + let finalOutput; + for (const chunk of consumeIteratorInContext(childConfig, output)) { + if (finalOutput === undefined) { + finalOutput = chunk; + } + else { + // Make a best effort to gather, for any type that supports concat. + try { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + finalOutput = concat(finalOutput, chunk); + } + catch (e) { + finalOutput = chunk; + } + } + } + output = finalOutput; + } + resolve(output); + } + catch (e) { + reject(e); + } + }); + }); + } + async invoke(input, options) { + return this._callWithConfig(this._invoke, input, options); + } + async *_transform(generator, runManager, config) { + let finalChunk; + for await (const chunk of generator) { + if (finalChunk === undefined) { + finalChunk = chunk; + } + else { + // Make a best effort to gather, for any type that supports concat. + try { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + finalChunk = concat(finalChunk, chunk); + } + catch (e) { + finalChunk = chunk; + } + } + } + const output = await new Promise((resolve, reject) => { + void AsyncLocalStorageProviderSingleton.getInstance().run(config, async () => { + try { + const res = await this.func(finalChunk, { + ...config, + config, + }); + resolve(res); + } + catch (e) { + reject(e); + } + }); + }); + if (output && Runnable.isRunnable(output)) { + if (config?.recursionLimit === 0) { + throw new Error("Recursion limit reached."); + } + const stream = await output.stream(finalChunk, patchConfig(config, { + callbacks: runManager?.getChild(), + recursionLimit: (config?.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1, + })); + for await (const chunk of stream) { + yield chunk; + } + } + else if (isAsyncIterable(output)) { + for await (const chunk of consumeAsyncIterableInContext(config, output)) { + yield chunk; + } + } + else if (isIterator(output)) { + for (const chunk of consumeIteratorInContext(config, output)) { + yield chunk; + } + } + else { + yield output; + } + } + transform(generator, options) { + return this._transformStreamWithConfig(generator, this._transform.bind(this), options); + } + async stream(input, options) { + async function* generator() { + yield input; + } + const config = ensureConfig(options); + const wrappedGenerator = new AsyncGeneratorWithSetup({ + generator: this.transform(generator(), config), + config, + }); + await wrappedGenerator.setup; + return IterableReadableStream.fromAsyncGenerator(wrappedGenerator); + } +} +class RunnableParallel extends (/* unused pure expression or super */ null && (RunnableMap)) { +} +/** + * A Runnable that can fallback to other Runnables if it fails. + */ +class RunnableWithFallbacks extends Runnable { + static lc_name() { + return "RunnableWithFallbacks"; + } + constructor(fields) { + super(fields); + Object.defineProperty(this, "lc_namespace", { + enumerable: true, + configurable: true, + writable: true, + value: ["langchain_core", "runnables"] + }); + Object.defineProperty(this, "lc_serializable", { + enumerable: true, + configurable: true, + writable: true, + value: true + }); + Object.defineProperty(this, "runnable", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "fallbacks", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.runnable = fields.runnable; + this.fallbacks = fields.fallbacks; + } + *runnables() { + yield this.runnable; + for (const fallback of this.fallbacks) { + yield fallback; + } + } + async invoke(input, options) { + const callbackManager_ = await CallbackManager.configure(options?.callbacks, undefined, options?.tags, undefined, options?.metadata); + const { runId, ...otherOptions } = options ?? {}; + const runManager = await callbackManager_?.handleChainStart(this.toJSON(), base_coerceToDict(input, "input"), runId, undefined, undefined, undefined, otherOptions?.runName); + let firstError; + for (const runnable of this.runnables()) { + try { + const output = await runnable.invoke(input, patchConfig(otherOptions, { callbacks: runManager?.getChild() })); + await runManager?.handleChainEnd(base_coerceToDict(output, "output")); + return output; + } + catch (e) { + if (firstError === undefined) { + firstError = e; + } + } + } + if (firstError === undefined) { + throw new Error("No error stored at end of fallback."); + } + await runManager?.handleChainError(firstError); + throw firstError; + } + async batch(inputs, options, batchOptions) { + if (batchOptions?.returnExceptions) { + throw new Error("Not implemented."); + } + const configList = this._getOptionsList(options ?? {}, inputs.length); + const callbackManagers = await Promise.all(configList.map((config) => CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata))); + const runManagers = await Promise.all(callbackManagers.map(async (callbackManager, i) => { + const handleStartRes = await callbackManager?.handleChainStart(this.toJSON(), base_coerceToDict(inputs[i], "input"), configList[i].runId, undefined, undefined, undefined, configList[i].runName); + delete configList[i].runId; + return handleStartRes; + })); + // eslint-disable-next-line @typescript-eslint/no-explicit-any + let firstError; + for (const runnable of this.runnables()) { + try { + const outputs = await runnable.batch(inputs, runManagers.map((runManager, j) => patchConfig(configList[j], { + callbacks: runManager?.getChild(), + })), batchOptions); + await Promise.all(runManagers.map((runManager, i) => runManager?.handleChainEnd(base_coerceToDict(outputs[i], "output")))); + return outputs; + } + catch (e) { + if (firstError === undefined) { + firstError = e; + } + } + } + if (!firstError) { + throw new Error("No error stored at end of fallbacks."); + } + await Promise.all(runManagers.map((runManager) => runManager?.handleChainError(firstError))); + throw firstError; + } +} +// TODO: Figure out why the compiler needs help eliminating Error as a RunOutput type +function _coerceToRunnable(coerceable) { + if (typeof coerceable === "function") { + return new RunnableLambda({ func: coerceable }); + } + else if (Runnable.isRunnable(coerceable)) { + return coerceable; + } + else if (!Array.isArray(coerceable) && typeof coerceable === "object") { + const runnables = {}; + for (const [key, value] of Object.entries(coerceable)) { + runnables[key] = _coerceToRunnable(value); + } + return new RunnableMap({ + steps: runnables, + }); + } + else { + throw new Error(`Expected a Runnable, function or object.\nInstead got an unsupported type.`); + } +} +/** + * A runnable that assigns key-value pairs to inputs of type `Record`. + */ +class RunnableAssign extends Runnable { + static lc_name() { + return "RunnableAssign"; + } + constructor(fields) { + // eslint-disable-next-line no-instanceof/no-instanceof + if (fields instanceof RunnableMap) { + // eslint-disable-next-line no-param-reassign + fields = { mapper: fields }; + } + super(fields); + Object.defineProperty(this, "lc_namespace", { + enumerable: true, + configurable: true, + writable: true, + value: ["langchain_core", "runnables"] + }); + Object.defineProperty(this, "lc_serializable", { + enumerable: true, + configurable: true, + writable: true, + value: true + }); + Object.defineProperty(this, "mapper", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.mapper = fields.mapper; + } + async invoke(input, options) { + const mapperResult = await this.mapper.invoke(input, options); + return { + ...input, + ...mapperResult, + }; + } + async *_transform(generator, runManager, options) { + // collect mapper keys + const mapperKeys = this.mapper.getStepsKeys(); + // create two input gens, one for the mapper, one for the input + const [forPassthrough, forMapper] = atee(generator); + // create mapper output gen + const mapperOutput = this.mapper.transform(forMapper, patchConfig(options, { callbacks: runManager?.getChild() })); + // start the mapper + const firstMapperChunkPromise = mapperOutput.next(); + // yield the passthrough + for await (const chunk of forPassthrough) { + if (typeof chunk !== "object" || Array.isArray(chunk)) { + throw new Error(`RunnableAssign can only be used with objects as input, got ${typeof chunk}`); + } + const filtered = Object.fromEntries(Object.entries(chunk).filter(([key]) => !mapperKeys.includes(key))); + if (Object.keys(filtered).length > 0) { + yield filtered; + } + } + // yield the mapper output + yield (await firstMapperChunkPromise).value; + for await (const chunk of mapperOutput) { + yield chunk; + } + } + transform(generator, options) { + return this._transformStreamWithConfig(generator, this._transform.bind(this), options); + } + async stream(input, options) { + async function* generator() { + yield input; + } + const config = ensureConfig(options); + const wrappedGenerator = new AsyncGeneratorWithSetup({ + generator: this.transform(generator(), config), + config, + }); + await wrappedGenerator.setup; + return IterableReadableStream.fromAsyncGenerator(wrappedGenerator); + } +} +/** + * A runnable that assigns key-value pairs to inputs of type `Record`. + */ +class RunnablePick extends Runnable { + static lc_name() { + return "RunnablePick"; + } + constructor(fields) { + if (typeof fields === "string" || Array.isArray(fields)) { + // eslint-disable-next-line no-param-reassign + fields = { keys: fields }; + } + super(fields); + Object.defineProperty(this, "lc_namespace", { + enumerable: true, + configurable: true, + writable: true, + value: ["langchain_core", "runnables"] + }); + Object.defineProperty(this, "lc_serializable", { + enumerable: true, + configurable: true, + writable: true, + value: true + }); + Object.defineProperty(this, "keys", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.keys = fields.keys; + } + async _pick(input) { + if (typeof this.keys === "string") { + return input[this.keys]; + } + else { + const picked = this.keys + .map((key) => [key, input[key]]) + .filter((v) => v[1] !== undefined); + return picked.length === 0 ? undefined : Object.fromEntries(picked); + } + } + async invoke(input, options) { + return this._callWithConfig(this._pick.bind(this), input, options); + } + async *_transform(generator) { + for await (const chunk of generator) { + const picked = await this._pick(chunk); + if (picked !== undefined) { + yield picked; + } + } + } + transform(generator, options) { + return this._transformStreamWithConfig(generator, this._transform.bind(this), options); + } + async stream(input, options) { + async function* generator() { + yield input; + } + const config = ensureConfig(options); + const wrappedGenerator = new AsyncGeneratorWithSetup({ + generator: this.transform(generator(), config), + config, + }); + await wrappedGenerator.setup; + return IterableReadableStream.fromAsyncGenerator(wrappedGenerator); + } +} + + +/***/ }) + +}; +; \ No newline at end of file diff --git a/dist/50.index.js b/dist/50.index.js new file mode 100644 index 0000000..0828db3 --- /dev/null +++ b/dist/50.index.js @@ -0,0 +1,1204 @@ +"use strict"; +exports.id = 50; +exports.ids = [50]; +exports.modules = { + +/***/ 58050: +/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { + +// ESM COMPAT FLAG +__webpack_require__.r(__webpack_exports__); + +// EXPORTS +__webpack_require__.d(__webpack_exports__, { + "FewShotChatMessagePromptTemplate": () => (/* binding */ FewShotChatMessagePromptTemplate), + "FewShotPromptTemplate": () => (/* binding */ FewShotPromptTemplate) +}); + +// EXTERNAL MODULE: ./node_modules/@langchain/core/dist/prompts/string.js +var string = __webpack_require__(48166); +// EXTERNAL MODULE: ./node_modules/@langchain/core/dist/prompts/template.js + 1 modules +var prompts_template = __webpack_require__(57645); +// EXTERNAL MODULE: ./node_modules/@langchain/core/dist/prompts/prompt.js +var prompts_prompt = __webpack_require__(99049); +// EXTERNAL MODULE: ./node_modules/@langchain/core/dist/messages/index.js + 9 modules +var messages = __webpack_require__(76801); +// EXTERNAL MODULE: ./node_modules/@langchain/core/dist/prompt_values.js +var prompt_values = __webpack_require__(437); +// EXTERNAL MODULE: ./node_modules/@langchain/core/dist/runnables/base.js + 69 modules +var base = __webpack_require__(75139); +// EXTERNAL MODULE: ./node_modules/@langchain/core/dist/prompts/base.js +var prompts_base = __webpack_require__(74200); +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/prompts/image.js + + + +/** + * An image prompt template for a multimodal model. + */ +class image_ImagePromptTemplate extends (/* unused pure expression or super */ null && (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 + }); + this.template = input.template; + this.templateFormat = input.templateFormat ?? this.templateFormat; + this.validateTemplate = input.validateTemplate ?? this.validateTemplate; + 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 image_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) { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const formatted = {}; + for (const [key, value] of Object.entries(this.template)) { + if (typeof value === "string") { + formatted[key] = value.replace(/{([^{}]*)}/g, (match, group) => { + const replacement = values[group]; + return typeof replacement === "string" || + typeof replacement === "number" + ? String(replacement) + : match; + }); + } + 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); + } +} + +;// CONCATENATED MODULE: ./node_modules/@langchain/core/dist/prompts/chat.js +// Default generic "any" values are for backwards compatibility. +// Replace with "string" when we are comfortable with a breaking change. + + + + + + + + +/** + * Abstract class that serves as a base for creating message prompt + * templates. It defines how to format messages for different roles in a + * conversation. + */ +class BaseMessagePromptTemplate extends (/* unused pure expression or super */ null && (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) => this.formatMessages(input), input, { ...options, runType: "prompt" }); + } +} +/** + * Class that represents a placeholder for messages in a chat prompt. It + * extends the BaseMessagePromptTemplate. + */ +class MessagesPlaceholder extends (/* unused pure expression or super */ null && (BaseMessagePromptTemplate)) { + static lc_name() { + return "MessagesPlaceholder"; + } + constructor(fields) { + if (typeof fields === "string") { + // eslint-disable-next-line no-param-reassign + 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]; + } + validateInputOrThrow(input, variableName) { + if (this.optional && !input) { + return false; + } + else if (!input) { + const error = new Error(`Error: Field "${variableName}" in prompt uses a MessagesPlaceholder, which expects an array of BaseMessages as an input value. Received: undefined`); + error.name = "InputFormatError"; + throw error; + } + let isInputBaseMessage = false; + if (Array.isArray(input)) { + isInputBaseMessage = input.every((message) => isBaseMessage(message)); + } + else { + isInputBaseMessage = isBaseMessage(input); + } + if (!isInputBaseMessage) { + const readableInput = typeof input === "string" ? input : JSON.stringify(input, null, 2); + const error = new Error(`Error: Field "${variableName}" in prompt uses a MessagesPlaceholder, which expects an array of BaseMessages as an input value. Received: ${readableInput}`); + error.name = "InputFormatError"; + throw error; + } + return true; + } + async formatMessages(values) { + this.validateInputOrThrow(values[this.variableName], this.variableName); + return values[this.variableName] ?? []; + } +} +/** + * Abstract class that serves as a base for creating message string prompt + * templates. It extends the BaseMessagePromptTemplate. + */ +class BaseMessageStringPromptTemplate extends (/* unused pure expression or super */ null && (BaseMessagePromptTemplate)) { + constructor(fields) { + if (!("prompt" in fields)) { + // eslint-disable-next-line no-param-reassign + 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. + */ +class BaseChatPromptTemplate extends prompts_base/* BasePromptTemplate */.d { + constructor(input) { + super(input); + } + async format(values) { + return (await this.formatPromptValue(values)).toString(); + } + async formatPromptValue(values) { + const resultMessages = await this.formatMessages(values); + return new prompt_values/* ChatPromptValue */.GU(resultMessages); + } +} +/** + * Class that represents a chat message prompt template. It extends the + * BaseMessageStringPromptTemplate. + */ +class ChatMessagePromptTemplate extends (/* unused pure expression or super */ null && (BaseMessageStringPromptTemplate)) { + static lc_name() { + return "ChatMessagePromptTemplate"; + } + constructor(fields, role) { + if (!("prompt" in fields)) { + // eslint-disable-next-line no-param-reassign, @typescript-eslint/no-non-null-assertion + fields = { prompt: fields, role: 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); + } +} +class _StringImageMessagePromptTemplate extends (/* unused pure expression or super */ null && (BaseMessagePromptTemplate)) { + static _messageClass() { + throw new Error("Can not invoke _messageClass from inside _StringImageMessagePromptTemplate"); + } + constructor( + /** @TODO When we come up with a better way to type prompt templates, fix this */ + // eslint-disable-next-line @typescript-eslint/no-explicit-any + fields, additionalOptions) { + if (!("prompt" in fields)) { + // eslint-disable-next-line no-param-reassign + 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 + }); + // ChatMessage contains role field, others don't. + // Because of this, we have a separate class property for ChatMessage. + 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) { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const constructor = this.constructor; + if (constructor._messageClass()) { + const MsgClass = constructor._messageClass(); + return new MsgClass({ content }); + } + else if (constructor.chatMessageClass) { + const MsgClass = constructor.chatMessageClass(); + // Assuming ChatMessage constructor also takes a content argument + 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" || + (typeof item === "object" && "text" in item)) { + let text = ""; + if (typeof item === "string") { + text = item; + } + else if (typeof item.text === "string") { + text = item.text ?? ""; + } + prompt.push(PromptTemplate.fromTemplate(text)); + } + else if (typeof item === "object" && "image_url" in item) { + let imgTemplate = item.image_url ?? ""; + let imgTemplateObject; + let inputVariables = []; + if (typeof imgTemplate === "string") { + const parsedTemplate = parseFString(imgTemplate); + const variables = parsedTemplate.flatMap((item) => item.type === "variable" ? [item.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, + }); + } + else if (typeof imgTemplate === "object") { + if ("url" in imgTemplate) { + const parsedTemplate = parseFString(imgTemplate.url); + inputVariables = parsedTemplate.flatMap((item) => item.type === "variable" ? [item.name] : []); + } + else { + inputVariables = []; + } + imgTemplateObject = new ImagePromptTemplate({ + template: imgTemplate, + inputVariables, + }); + } + else { + throw new Error("Invalid image template"); + } + prompt.push(imgTemplateObject); + } + } + return new this({ prompt, additionalOptions }); + } + async format(input) { + // eslint-disable-next-line no-instanceof/no-instanceof + 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) { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + 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] }; + } + // eslint-disable-next-line no-instanceof/no-instanceof + if (prompt instanceof BaseStringPromptTemplate) { + const formatted = await prompt.format(inputs); + content.push({ type: "text", text: formatted }); + /** @TODO replace this */ + // eslint-disable-next-line no-instanceof/no-instanceof + } + else if (prompt instanceof ImagePromptTemplate) { + const formatted = await prompt.format(inputs); + content.push({ type: "image_url", image_url: 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!", + * }); + * ``` + */ +class HumanMessagePromptTemplate extends (/* unused pure expression or super */ null && (_StringImageMessagePromptTemplate)) { + static _messageClass() { + return HumanMessage; + } + static lc_name() { + return "HumanMessagePromptTemplate"; + } +} +/** + * Class that represents an AI message prompt template. It extends the + * BaseMessageStringPromptTemplate. + */ +class AIMessagePromptTemplate extends (/* unused pure expression or super */ null && (_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!", + * }); + * ``` + */ +class SystemMessagePromptTemplate extends (/* unused pure expression or super */ null && (_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 (typeof messageContent !== "string" || + messageContent[0] !== "{" || + messageContent[messageContent.length - 1] !== "}") { + throw new Error(`Invalid placeholder template: "${messagePromptTemplateLike[1]}". Expected a variable name surrounded by curly braces.`); + } + const variableName = messageContent.slice(1, -1); + return new MessagesPlaceholder({ variableName, optional: true }); + } + const message = coerceMessageLikeToMessage(messagePromptTemplateLike); + let templateData; + if (typeof message.content === "string") { + templateData = message.content; + } + else { + // Assuming message.content is an array of complex objects, transform it. + templateData = message.content.map((item) => { + if ("text" in item) { + return { text: item.text }; + } + else if ("image_url" in item) { + return { 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) { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + 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!", + * }); + * ``` + */ +class ChatPromptTemplate extends (/* unused pure expression or super */ null && (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 is mustache and validateTemplate is not defined, set it to false + if (input.templateFormat === "mustache" && + input.validateTemplate === undefined) { + this.validateTemplate = false; + } + Object.assign(this, input); + if (this.validateTemplate) { + const inputVariablesMessages = new Set(); + for (const promptMessage of this.promptMessages) { + // eslint-disable-next-line no-instanceof/no-instanceof + 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); + const formattedUrl = await promptTemplatePlaceholder.format(inputValues); + if (typeof item.image_url !== "string" && "url" in item.image_url) { + // eslint-disable-next-line no-param-reassign + item.image_url.url = formattedUrl; + } + else { + // eslint-disable-next-line no-param-reassign + item.image_url = formattedUrl; + } + return item; + })); + // eslint-disable-next-line no-param-reassign + message.content = formattedMessageContent; + return message; + } + async formatMessages(values) { + const allValues = await this.mergePartialAndUserVariables(values); + let resultMessages = []; + for (const promptMessage of this.promptMessages) { + // eslint-disable-next-line no-instanceof/no-instanceof + 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)) { + throw new Error(`Missing value for input variable \`${inputVariable.toString()}\``); + } + acc[inputVariable] = allValues[inputVariable]; + return acc; + }, {}); + const message = await promptMessage.formatMessages(inputValues); + resultMessages = resultMessages.concat(message); + } + } + return resultMessages; + } + async partial(values) { + // This is implemented in a way it doesn't require making + // BaseMessagePromptTemplate aware of .partial() + 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( + // eslint-disable-next-line no-instanceof/no-instanceof + promptMessage instanceof ChatPromptTemplate + ? promptMessage.promptMessages + : [ + _coerceMessagePromptTemplateLike(promptMessage, extra), + ]), []); + const flattenedPartialVariables = promptMessages.reduce((acc, promptMessage) => + // eslint-disable-next-line no-instanceof/no-instanceof + promptMessage instanceof ChatPromptTemplate + ? Object.assign(acc, promptMessage.partialVariables) + : acc, Object.create(null)); + const inputVariables = new Set(); + for (const promptMessage of flattenedMessages) { + // eslint-disable-next-line no-instanceof/no-instanceof + 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 */ + // eslint-disable-next-line @typescript-eslint/no-explicit-any + static fromPromptMessages(promptMessages) { + return this.fromMessages(promptMessages); + } +} + +;// CONCATENATED MODULE: ./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" })); + * + * ``` + */ +class FewShotPromptTemplate extends string/* BaseStringPromptTemplate */.A { + 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 !== undefined && this.exampleSelector !== undefined) { + throw new Error("Only one of 'examples' and 'example_selector' should be provided"); + } + if (this.examples === undefined && this.exampleSelector === undefined) { + 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)); + } + (0,prompts_template/* checkValidTemplate */.af)(this.prefix + this.suffix, this.templateFormat, totalInputVariables); + } + } + _getPromptType() { + return "few_shot"; + } + static lc_name() { + return "FewShotPromptTemplate"; + } + async getExamples(inputVariables) { + if (this.examples !== undefined) { + return this.examples; + } + if (this.exampleSelector !== undefined) { + 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 (0,prompts_template/* renderTemplate */.SM)(template, this.templateFormat, allValues); + } + serialize() { + if (this.exampleSelector || !this.examples) { + throw new Error("Serializing an example selector is not currently supported"); + } + if (this.outputParser !== undefined) { + 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 prompts_prompt.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 + */ +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 !== undefined && this.exampleSelector !== undefined) { + throw new Error("Only one of 'examples' and 'example_selector' should be provided"); + } + if (this.examples === undefined && this.exampleSelector === undefined) { + 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)); + } + (0,prompts_template/* checkValidTemplate */.af)(this.prefix + this.suffix, this.templateFormat, totalInputVariables); + } + } + async getExamples(inputVariables) { + if (this.examples !== undefined) { + return this.examples; + } + if (this.exampleSelector !== undefined) { + 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) => { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + 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 (0,prompts_template/* renderTemplate */.SM)(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); + } +} + + +/***/ }) + +}; +; \ No newline at end of file diff --git a/dist/index.js b/dist/index.js index c298919..b02ae4f 100644 --- a/dist/index.js +++ b/dist/index.js @@ -1,7 +1,7 @@ /******/ (() => { // webpackBootstrap /******/ var __webpack_modules__ = ({ -/***/ 99777: +/***/ 87351: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -28,7 +28,7 @@ var __importStar = (this && this.__importStar) || function (mod) { Object.defineProperty(exports, "__esModule", ({ value: true })); exports.issue = exports.issueCommand = void 0; const os = __importStar(__nccwpck_require__(22037)); -const utils_1 = __nccwpck_require__(19855); +const utils_1 = __nccwpck_require__(5278); /** * Commands * @@ -100,7 +100,7 @@ function escapeProperty(s) { /***/ }), -/***/ 24181: +/***/ 42186: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -135,12 +135,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.getIDToken = exports.getState = exports.saveState = exports.group = exports.endGroup = exports.startGroup = exports.info = exports.notice = exports.warning = exports.error = exports.debug = exports.isDebug = exports.setFailed = exports.setCommandEcho = exports.setOutput = exports.getBooleanInput = exports.getMultilineInput = exports.getInput = exports.addPath = exports.setSecret = exports.exportVariable = exports.ExitCode = void 0; -const command_1 = __nccwpck_require__(99777); -const file_command_1 = __nccwpck_require__(33679); -const utils_1 = __nccwpck_require__(19855); +const command_1 = __nccwpck_require__(87351); +const file_command_1 = __nccwpck_require__(717); +const utils_1 = __nccwpck_require__(5278); const os = __importStar(__nccwpck_require__(22037)); const path = __importStar(__nccwpck_require__(71017)); -const oidc_utils_1 = __nccwpck_require__(46266); +const oidc_utils_1 = __nccwpck_require__(98041); /** * The code to exit an action */ @@ -425,17 +425,17 @@ exports.getIDToken = getIDToken; /** * Summary exports */ -var summary_1 = __nccwpck_require__(23154); +var summary_1 = __nccwpck_require__(81327); Object.defineProperty(exports, "summary", ({ enumerable: true, get: function () { return summary_1.summary; } })); /** * @deprecated use core.summary */ -var summary_2 = __nccwpck_require__(23154); +var summary_2 = __nccwpck_require__(81327); Object.defineProperty(exports, "markdownSummary", ({ enumerable: true, get: function () { return summary_2.markdownSummary; } })); /** * Path exports */ -var path_utils_1 = __nccwpck_require__(14605); +var path_utils_1 = __nccwpck_require__(2981); Object.defineProperty(exports, "toPosixPath", ({ enumerable: true, get: function () { return path_utils_1.toPosixPath; } })); Object.defineProperty(exports, "toWin32Path", ({ enumerable: true, get: function () { return path_utils_1.toWin32Path; } })); Object.defineProperty(exports, "toPlatformPath", ({ enumerable: true, get: function () { return path_utils_1.toPlatformPath; } })); @@ -443,7 +443,7 @@ Object.defineProperty(exports, "toPlatformPath", ({ enumerable: true, get: funct /***/ }), -/***/ 33679: +/***/ 717: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -474,8 +474,8 @@ exports.prepareKeyValueMessage = exports.issueFileCommand = void 0; /* eslint-disable @typescript-eslint/no-explicit-any */ const fs = __importStar(__nccwpck_require__(57147)); const os = __importStar(__nccwpck_require__(22037)); -const uuid_1 = __nccwpck_require__(49343); -const utils_1 = __nccwpck_require__(19855); +const uuid_1 = __nccwpck_require__(78974); +const utils_1 = __nccwpck_require__(5278); function issueFileCommand(command, message) { const filePath = process.env[`GITHUB_${command}`]; if (!filePath) { @@ -508,7 +508,7 @@ exports.prepareKeyValueMessage = prepareKeyValueMessage; /***/ }), -/***/ 46266: +/***/ 98041: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -524,9 +524,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.OidcClient = void 0; -const http_client_1 = __nccwpck_require__(35754); -const auth_1 = __nccwpck_require__(91475); -const core_1 = __nccwpck_require__(24181); +const http_client_1 = __nccwpck_require__(96255); +const auth_1 = __nccwpck_require__(35526); +const core_1 = __nccwpck_require__(42186); class OidcClient { static createHttpClient(allowRetry = true, maxRetry = 10) { const requestOptions = { @@ -592,7 +592,7 @@ exports.OidcClient = OidcClient; /***/ }), -/***/ 14605: +/***/ 2981: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -657,7 +657,7 @@ exports.toPlatformPath = toPlatformPath; /***/ }), -/***/ 23154: +/***/ 81327: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -947,7 +947,7 @@ exports.summary = _summary; /***/ }), -/***/ 19855: +/***/ 5278: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -994,7 +994,7 @@ exports.toCommandProperties = toCommandProperties; /***/ }), -/***/ 49343: +/***/ 78974: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -1058,29 +1058,29 @@ Object.defineProperty(exports, "parse", ({ } })); -var _v = _interopRequireDefault(__nccwpck_require__(12108)); +var _v = _interopRequireDefault(__nccwpck_require__(81595)); -var _v2 = _interopRequireDefault(__nccwpck_require__(5073)); +var _v2 = _interopRequireDefault(__nccwpck_require__(26993)); -var _v3 = _interopRequireDefault(__nccwpck_require__(74749)); +var _v3 = _interopRequireDefault(__nccwpck_require__(51472)); -var _v4 = _interopRequireDefault(__nccwpck_require__(71624)); +var _v4 = _interopRequireDefault(__nccwpck_require__(16217)); -var _nil = _interopRequireDefault(__nccwpck_require__(91740)); +var _nil = _interopRequireDefault(__nccwpck_require__(32381)); -var _version = _interopRequireDefault(__nccwpck_require__(50163)); +var _version = _interopRequireDefault(__nccwpck_require__(40427)); -var _validate = _interopRequireDefault(__nccwpck_require__(776)); +var _validate = _interopRequireDefault(__nccwpck_require__(92609)); -var _stringify = _interopRequireDefault(__nccwpck_require__(97082)); +var _stringify = _interopRequireDefault(__nccwpck_require__(61458)); -var _parse = _interopRequireDefault(__nccwpck_require__(23589)); +var _parse = _interopRequireDefault(__nccwpck_require__(26385)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } /***/ }), -/***/ 48810: +/***/ 5842: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -1110,7 +1110,7 @@ exports["default"] = _default; /***/ }), -/***/ 91740: +/***/ 32381: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -1125,7 +1125,7 @@ exports["default"] = _default; /***/ }), -/***/ 23589: +/***/ 26385: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -1136,7 +1136,7 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = void 0; -var _validate = _interopRequireDefault(__nccwpck_require__(776)); +var _validate = _interopRequireDefault(__nccwpck_require__(92609)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -1177,7 +1177,7 @@ exports["default"] = _default; /***/ }), -/***/ 96170: +/***/ 86230: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -1192,7 +1192,7 @@ exports["default"] = _default; /***/ }), -/***/ 78689: +/***/ 9784: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -1223,7 +1223,7 @@ function rng() { /***/ }), -/***/ 42043: +/***/ 38844: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -1253,7 +1253,7 @@ exports["default"] = _default; /***/ }), -/***/ 97082: +/***/ 61458: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -1264,7 +1264,7 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = void 0; -var _validate = _interopRequireDefault(__nccwpck_require__(776)); +var _validate = _interopRequireDefault(__nccwpck_require__(92609)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -1299,7 +1299,7 @@ exports["default"] = _default; /***/ }), -/***/ 12108: +/***/ 81595: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -1310,9 +1310,9 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = void 0; -var _rng = _interopRequireDefault(__nccwpck_require__(78689)); +var _rng = _interopRequireDefault(__nccwpck_require__(9784)); -var _stringify = _interopRequireDefault(__nccwpck_require__(97082)); +var _stringify = _interopRequireDefault(__nccwpck_require__(61458)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -1413,7 +1413,7 @@ exports["default"] = _default; /***/ }), -/***/ 5073: +/***/ 26993: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -1424,9 +1424,9 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = void 0; -var _v = _interopRequireDefault(__nccwpck_require__(57120)); +var _v = _interopRequireDefault(__nccwpck_require__(65920)); -var _md = _interopRequireDefault(__nccwpck_require__(48810)); +var _md = _interopRequireDefault(__nccwpck_require__(5842)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -1436,7 +1436,7 @@ exports["default"] = _default; /***/ }), -/***/ 57120: +/***/ 65920: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -1448,9 +1448,9 @@ Object.defineProperty(exports, "__esModule", ({ exports["default"] = _default; exports.URL = exports.DNS = void 0; -var _stringify = _interopRequireDefault(__nccwpck_require__(97082)); +var _stringify = _interopRequireDefault(__nccwpck_require__(61458)); -var _parse = _interopRequireDefault(__nccwpck_require__(23589)); +var _parse = _interopRequireDefault(__nccwpck_require__(26385)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -1521,7 +1521,7 @@ function _default(name, version, hashfunc) { /***/ }), -/***/ 74749: +/***/ 51472: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -1532,9 +1532,9 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = void 0; -var _rng = _interopRequireDefault(__nccwpck_require__(78689)); +var _rng = _interopRequireDefault(__nccwpck_require__(9784)); -var _stringify = _interopRequireDefault(__nccwpck_require__(97082)); +var _stringify = _interopRequireDefault(__nccwpck_require__(61458)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -1565,7 +1565,7 @@ exports["default"] = _default; /***/ }), -/***/ 71624: +/***/ 16217: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -1576,9 +1576,9 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = void 0; -var _v = _interopRequireDefault(__nccwpck_require__(57120)); +var _v = _interopRequireDefault(__nccwpck_require__(65920)); -var _sha = _interopRequireDefault(__nccwpck_require__(42043)); +var _sha = _interopRequireDefault(__nccwpck_require__(38844)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -1588,7 +1588,7 @@ exports["default"] = _default; /***/ }), -/***/ 776: +/***/ 92609: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -1599,7 +1599,7 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = void 0; -var _regex = _interopRequireDefault(__nccwpck_require__(96170)); +var _regex = _interopRequireDefault(__nccwpck_require__(86230)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -1612,7 +1612,7 @@ exports["default"] = _default; /***/ }), -/***/ 50163: +/***/ 40427: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -1623,7 +1623,7 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = void 0; -var _validate = _interopRequireDefault(__nccwpck_require__(776)); +var _validate = _interopRequireDefault(__nccwpck_require__(92609)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -1640,7 +1640,7 @@ exports["default"] = _default; /***/ }), -/***/ 91475: +/***/ 35526: /***/ (function(__unused_webpack_module, exports) { "use strict"; @@ -1728,7 +1728,7 @@ exports.PersonalAccessTokenCredentialHandler = PersonalAccessTokenCredentialHand /***/ }), -/***/ 35754: +/***/ 96255: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -1770,9 +1770,9 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.HttpClient = exports.isHttps = exports.HttpClientResponse = exports.HttpClientError = exports.getProxyUrl = exports.MediaTypes = exports.Headers = exports.HttpCodes = void 0; const http = __importStar(__nccwpck_require__(13685)); const https = __importStar(__nccwpck_require__(95687)); -const pm = __importStar(__nccwpck_require__(95804)); -const tunnel = __importStar(__nccwpck_require__(60586)); -const undici_1 = __nccwpck_require__(31888); +const pm = __importStar(__nccwpck_require__(19835)); +const tunnel = __importStar(__nccwpck_require__(74294)); +const undici_1 = __nccwpck_require__(41773); var HttpCodes; (function (HttpCodes) { HttpCodes[HttpCodes["OK"] = 200] = "OK"; @@ -2387,7 +2387,7 @@ const lowercaseKeys = (obj) => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCa /***/ }), -/***/ 95804: +/***/ 19835: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -2476,7 +2476,7 @@ function isLoopbackAddress(host) { /***/ }), -/***/ 70007: +/***/ 14175: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { /* @@ -2515,11 +2515,11 @@ module['exports'] = colors; colors.themes = {}; var util = __nccwpck_require__(73837); -var ansiStyles = colors.styles = __nccwpck_require__(87622); +var ansiStyles = colors.styles = __nccwpck_require__(95691); var defineProps = Object.defineProperties; var newLineRegex = new RegExp(/[\r\n]+/g); -colors.supportsColor = (__nccwpck_require__(57642).supportsColor); +colors.supportsColor = (__nccwpck_require__(21959).supportsColor); if (typeof colors.enabled === 'undefined') { colors.enabled = colors.supportsColor() !== false; @@ -2671,15 +2671,15 @@ var sequencer = function sequencer(map, str) { }; // custom formatter methods -colors.trap = __nccwpck_require__(20904); -colors.zalgo = __nccwpck_require__(19568); +colors.trap = __nccwpck_require__(29493); +colors.zalgo = __nccwpck_require__(80090); // maps colors.maps = {}; -colors.maps.america = __nccwpck_require__(95029)(colors); -colors.maps.zebra = __nccwpck_require__(13349)(colors); -colors.maps.rainbow = __nccwpck_require__(68902)(colors); -colors.maps.random = __nccwpck_require__(91242)(colors); +colors.maps.america = __nccwpck_require__(29337)(colors); +colors.maps.zebra = __nccwpck_require__(3792)(colors); +colors.maps.rainbow = __nccwpck_require__(19565)(colors); +colors.maps.random = __nccwpck_require__(78212)(colors); for (var map in colors.maps) { (function(map) { @@ -2694,7 +2694,7 @@ defineProps(colors, init()); /***/ }), -/***/ 20904: +/***/ 29493: /***/ ((module) => { module['exports'] = function runTheTrap(text, options) { @@ -2747,7 +2747,7 @@ module['exports'] = function runTheTrap(text, options) { /***/ }), -/***/ 19568: +/***/ 80090: /***/ ((module) => { // please no @@ -2864,7 +2864,7 @@ module['exports'] = function zalgo(text, options) { /***/ }), -/***/ 95029: +/***/ 29337: /***/ ((module) => { module['exports'] = function(colors) { @@ -2881,7 +2881,7 @@ module['exports'] = function(colors) { /***/ }), -/***/ 68902: +/***/ 19565: /***/ ((module) => { module['exports'] = function(colors) { @@ -2900,7 +2900,7 @@ module['exports'] = function(colors) { /***/ }), -/***/ 91242: +/***/ 78212: /***/ ((module) => { module['exports'] = function(colors) { @@ -2918,7 +2918,7 @@ module['exports'] = function(colors) { /***/ }), -/***/ 13349: +/***/ 3792: /***/ ((module) => { module['exports'] = function(colors) { @@ -2930,7 +2930,7 @@ module['exports'] = function(colors) { /***/ }), -/***/ 87622: +/***/ 95691: /***/ ((module) => { /* @@ -3032,7 +3032,7 @@ Object.keys(codes).forEach(function(key) { /***/ }), -/***/ 20732: +/***/ 63680: /***/ ((module) => { "use strict"; @@ -3075,7 +3075,7 @@ module.exports = function(flag, argv) { /***/ }), -/***/ 57642: +/***/ 21959: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -3107,7 +3107,7 @@ THE SOFTWARE. var os = __nccwpck_require__(22037); -var hasFlag = __nccwpck_require__(20732); +var hasFlag = __nccwpck_require__(63680); var env = process.env; @@ -3234,7 +3234,7 @@ module.exports = { /***/ }), -/***/ 3319: +/***/ 59256: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // @@ -3245,16 +3245,16 @@ module.exports = { // colors.red("foo") // // -var colors = __nccwpck_require__(70007); +var colors = __nccwpck_require__(14175); module['exports'] = colors; /***/ }), -/***/ 12643: +/***/ 24235: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var enabled = __nccwpck_require__(22290); +var enabled = __nccwpck_require__(3495); /** * Creates a new Adapter. @@ -3276,10 +3276,10 @@ module.exports = function create(fn) { /***/ }), -/***/ 64289: +/***/ 61009: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var adapter = __nccwpck_require__(12643); +var adapter = __nccwpck_require__(24235); /** * Extracts the values from process.env. @@ -3294,7 +3294,7 @@ module.exports = adapter(function processenv() { /***/ }), -/***/ 25746: +/***/ 73201: /***/ ((module) => { /** @@ -3513,7 +3513,7 @@ module.exports = function create(diagnostics) { /***/ }), -/***/ 21009: +/***/ 41238: /***/ ((module) => { /** @@ -3539,11 +3539,11 @@ module.exports = function (meta, messages) { /***/ }), -/***/ 88219: +/***/ 55037: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var colorspace = __nccwpck_require__(72900); -var kuler = __nccwpck_require__(84975); +var colorspace = __nccwpck_require__(85917); +var kuler = __nccwpck_require__(26287); /** * Prefix the messages with a colored namespace. @@ -3566,10 +3566,10 @@ module.exports = function ansiModifier(args, options) { /***/ }), -/***/ 39566: +/***/ 50611: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var create = __nccwpck_require__(25746); +var create = __nccwpck_require__(73201); var tty = (__nccwpck_require__(76224).isatty)(1); /** @@ -3597,9 +3597,9 @@ var diagnostics = create(function dev(namespace, options) { // // Configure the logger for the given environment. // -diagnostics.modify(__nccwpck_require__(88219)); -diagnostics.use(__nccwpck_require__(64289)); -diagnostics.set(__nccwpck_require__(21009)); +diagnostics.modify(__nccwpck_require__(55037)); +diagnostics.use(__nccwpck_require__(61009)); +diagnostics.set(__nccwpck_require__(41238)); // // Expose the diagnostics logger. @@ -3609,25 +3609,25 @@ module.exports = diagnostics; /***/ }), -/***/ 10624: +/***/ 33170: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // // Select the correct build version depending on the environment. // if (process.env.NODE_ENV === 'production') { - module.exports = __nccwpck_require__(50938); + module.exports = __nccwpck_require__(69827); } else { - module.exports = __nccwpck_require__(39566); + module.exports = __nccwpck_require__(50611); } /***/ }), -/***/ 50938: +/***/ 69827: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var create = __nccwpck_require__(25746); +var create = __nccwpck_require__(73201); /** * Create a new diagnostics logger. @@ -3655,7 +3655,7 @@ module.exports = diagnostics; /***/ }), -/***/ 62002: +/***/ 61659: /***/ ((module, exports, __nccwpck_require__) => { "use strict"; @@ -3667,7 +3667,7 @@ module.exports = diagnostics; Object.defineProperty(exports, "__esModule", ({ value: true })); -var eventTargetShim = __nccwpck_require__(9689); +var eventTargetShim = __nccwpck_require__(84697); /** * The signal class. @@ -3790,27 +3790,27 @@ module.exports.AbortSignal = AbortSignal /***/ }), -/***/ 1386: +/***/ 34623: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -module.exports = __nccwpck_require__(94850); -module.exports.HttpsAgent = __nccwpck_require__(13119); -module.exports.constants = __nccwpck_require__(52075); +module.exports = __nccwpck_require__(65006); +module.exports.HttpsAgent = __nccwpck_require__(55500); +module.exports.constants = __nccwpck_require__(27757); /***/ }), -/***/ 94850: +/***/ 65006: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; const OriginalAgent = (__nccwpck_require__(13685).Agent); -const ms = __nccwpck_require__(7456); +const ms = __nccwpck_require__(10845); const debug = (__nccwpck_require__(73837).debuglog)('agentkeepalive'); const { INIT_SOCKET, @@ -3820,7 +3820,7 @@ const { SOCKET_NAME, SOCKET_REQUEST_COUNT, SOCKET_REQUEST_FINISHED_COUNT, -} = __nccwpck_require__(52075); +} = __nccwpck_require__(27757); // OriginalAgent come from // - https://github.com/nodejs/node/blob/v8.12.0/lib/_http_agent.js @@ -4213,7 +4213,7 @@ function inspect(obj) { /***/ }), -/***/ 52075: +/***/ 27757: /***/ ((module) => { "use strict"; @@ -4235,18 +4235,18 @@ module.exports = { /***/ }), -/***/ 13119: +/***/ 55500: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; const OriginalHttpsAgent = (__nccwpck_require__(95687).Agent); -const HttpAgent = __nccwpck_require__(94850); +const HttpAgent = __nccwpck_require__(65006); const { INIT_SOCKET, CREATE_HTTPS_CONNECTION, -} = __nccwpck_require__(52075); +} = __nccwpck_require__(27757); class HttpsAgent extends HttpAgent { constructor(options) { @@ -4294,7 +4294,7 @@ module.exports = HttpsAgent; /***/ }), -/***/ 60565: +/***/ 52068: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -4467,7 +4467,7 @@ Object.defineProperty(module, 'exports', { /***/ }), -/***/ 88714: +/***/ 20991: /***/ ((module, exports, __nccwpck_require__) => { "use strict"; @@ -4478,15 +4478,15 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = asyncify; -var _initialParams = __nccwpck_require__(17146); +var _initialParams = __nccwpck_require__(9658); var _initialParams2 = _interopRequireDefault(_initialParams); -var _setImmediate = __nccwpck_require__(66771); +var _setImmediate = __nccwpck_require__(729); var _setImmediate2 = _interopRequireDefault(_setImmediate); -var _wrapAsync = __nccwpck_require__(25042); +var _wrapAsync = __nccwpck_require__(57456); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -4592,7 +4592,7 @@ module.exports = exports.default; /***/ }), -/***/ 24930: +/***/ 55460: /***/ ((module, exports, __nccwpck_require__) => { "use strict"; @@ -4602,31 +4602,31 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); -var _isArrayLike = __nccwpck_require__(68473); +var _isArrayLike = __nccwpck_require__(67157); var _isArrayLike2 = _interopRequireDefault(_isArrayLike); -var _breakLoop = __nccwpck_require__(34284); +var _breakLoop = __nccwpck_require__(8810); var _breakLoop2 = _interopRequireDefault(_breakLoop); -var _eachOfLimit = __nccwpck_require__(20542); +var _eachOfLimit = __nccwpck_require__(9342); var _eachOfLimit2 = _interopRequireDefault(_eachOfLimit); -var _once = __nccwpck_require__(83986); +var _once = __nccwpck_require__(27260); var _once2 = _interopRequireDefault(_once); -var _onlyOnce = __nccwpck_require__(42747); +var _onlyOnce = __nccwpck_require__(21990); var _onlyOnce2 = _interopRequireDefault(_onlyOnce); -var _wrapAsync = __nccwpck_require__(25042); +var _wrapAsync = __nccwpck_require__(57456); var _wrapAsync2 = _interopRequireDefault(_wrapAsync); -var _awaitify = __nccwpck_require__(96665); +var _awaitify = __nccwpck_require__(53887); var _awaitify2 = _interopRequireDefault(_awaitify); @@ -4784,7 +4784,7 @@ module.exports = exports.default; /***/ }), -/***/ 20542: +/***/ 9342: /***/ ((module, exports, __nccwpck_require__) => { "use strict"; @@ -4794,15 +4794,15 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); -var _eachOfLimit2 = __nccwpck_require__(78554); +var _eachOfLimit2 = __nccwpck_require__(36658); var _eachOfLimit3 = _interopRequireDefault(_eachOfLimit2); -var _wrapAsync = __nccwpck_require__(25042); +var _wrapAsync = __nccwpck_require__(57456); var _wrapAsync2 = _interopRequireDefault(_wrapAsync); -var _awaitify = __nccwpck_require__(96665); +var _awaitify = __nccwpck_require__(53887); var _awaitify2 = _interopRequireDefault(_awaitify); @@ -4838,7 +4838,7 @@ module.exports = exports.default; /***/ }), -/***/ 6576: +/***/ 81336: /***/ ((module, exports, __nccwpck_require__) => { "use strict"; @@ -4848,11 +4848,11 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); -var _eachOfLimit = __nccwpck_require__(20542); +var _eachOfLimit = __nccwpck_require__(9342); var _eachOfLimit2 = _interopRequireDefault(_eachOfLimit); -var _awaitify = __nccwpck_require__(96665); +var _awaitify = __nccwpck_require__(53887); var _awaitify2 = _interopRequireDefault(_awaitify); @@ -4884,7 +4884,7 @@ module.exports = exports.default; /***/ }), -/***/ 69301: +/***/ 51216: /***/ ((module, exports, __nccwpck_require__) => { "use strict"; @@ -4894,19 +4894,19 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); -var _eachOf = __nccwpck_require__(24930); +var _eachOf = __nccwpck_require__(55460); var _eachOf2 = _interopRequireDefault(_eachOf); -var _withoutIndex = __nccwpck_require__(67249); +var _withoutIndex = __nccwpck_require__(44674); var _withoutIndex2 = _interopRequireDefault(_withoutIndex); -var _wrapAsync = __nccwpck_require__(25042); +var _wrapAsync = __nccwpck_require__(57456); var _wrapAsync2 = _interopRequireDefault(_wrapAsync); -var _awaitify = __nccwpck_require__(96665); +var _awaitify = __nccwpck_require__(53887); var _awaitify2 = _interopRequireDefault(_awaitify); @@ -5020,7 +5020,7 @@ module.exports = exports.default; /***/ }), -/***/ 33123: +/***/ 2718: /***/ ((module, exports, __nccwpck_require__) => { "use strict"; @@ -5031,7 +5031,7 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = asyncEachOfLimit; -var _breakLoop = __nccwpck_require__(34284); +var _breakLoop = __nccwpck_require__(8810); var _breakLoop2 = _interopRequireDefault(_breakLoop); @@ -5102,7 +5102,7 @@ module.exports = exports.default; /***/ }), -/***/ 96665: +/***/ 53887: /***/ ((module, exports) => { "use strict"; @@ -5137,7 +5137,7 @@ module.exports = exports.default; /***/ }), -/***/ 34284: +/***/ 8810: /***/ ((module, exports) => { "use strict"; @@ -5154,7 +5154,7 @@ module.exports = exports.default; /***/ }), -/***/ 78554: +/***/ 36658: /***/ ((module, exports, __nccwpck_require__) => { "use strict"; @@ -5164,25 +5164,25 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); -var _once = __nccwpck_require__(83986); +var _once = __nccwpck_require__(27260); var _once2 = _interopRequireDefault(_once); -var _iterator = __nccwpck_require__(95042); +var _iterator = __nccwpck_require__(91420); var _iterator2 = _interopRequireDefault(_iterator); -var _onlyOnce = __nccwpck_require__(42747); +var _onlyOnce = __nccwpck_require__(21990); var _onlyOnce2 = _interopRequireDefault(_onlyOnce); -var _wrapAsync = __nccwpck_require__(25042); +var _wrapAsync = __nccwpck_require__(57456); -var _asyncEachOfLimit = __nccwpck_require__(33123); +var _asyncEachOfLimit = __nccwpck_require__(2718); var _asyncEachOfLimit2 = _interopRequireDefault(_asyncEachOfLimit); -var _breakLoop = __nccwpck_require__(34284); +var _breakLoop = __nccwpck_require__(8810); var _breakLoop2 = _interopRequireDefault(_breakLoop); @@ -5251,7 +5251,7 @@ module.exports = exports.default; /***/ }), -/***/ 89691: +/***/ 17645: /***/ ((module, exports) => { "use strict"; @@ -5269,7 +5269,7 @@ module.exports = exports.default; /***/ }), -/***/ 17146: +/***/ 9658: /***/ ((module, exports) => { "use strict"; @@ -5290,7 +5290,7 @@ module.exports = exports.default; /***/ }), -/***/ 68473: +/***/ 67157: /***/ ((module, exports) => { "use strict"; @@ -5307,7 +5307,7 @@ module.exports = exports.default; /***/ }), -/***/ 95042: +/***/ 91420: /***/ ((module, exports, __nccwpck_require__) => { "use strict"; @@ -5318,11 +5318,11 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = createIterator; -var _isArrayLike = __nccwpck_require__(68473); +var _isArrayLike = __nccwpck_require__(67157); var _isArrayLike2 = _interopRequireDefault(_isArrayLike); -var _getIterator = __nccwpck_require__(89691); +var _getIterator = __nccwpck_require__(17645); var _getIterator2 = _interopRequireDefault(_getIterator); @@ -5371,7 +5371,7 @@ module.exports = exports.default; /***/ }), -/***/ 83986: +/***/ 27260: /***/ ((module, exports) => { "use strict"; @@ -5395,7 +5395,7 @@ module.exports = exports.default; /***/ }), -/***/ 42747: +/***/ 21990: /***/ ((module, exports) => { "use strict"; @@ -5417,7 +5417,7 @@ module.exports = exports.default; /***/ }), -/***/ 55071: +/***/ 63221: /***/ ((module, exports, __nccwpck_require__) => { "use strict"; @@ -5427,15 +5427,15 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); -var _isArrayLike = __nccwpck_require__(68473); +var _isArrayLike = __nccwpck_require__(67157); var _isArrayLike2 = _interopRequireDefault(_isArrayLike); -var _wrapAsync = __nccwpck_require__(25042); +var _wrapAsync = __nccwpck_require__(57456); var _wrapAsync2 = _interopRequireDefault(_wrapAsync); -var _awaitify = __nccwpck_require__(96665); +var _awaitify = __nccwpck_require__(53887); var _awaitify2 = _interopRequireDefault(_awaitify); @@ -5458,7 +5458,7 @@ module.exports = exports.default; /***/ }), -/***/ 66771: +/***/ 729: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -5499,7 +5499,7 @@ exports["default"] = wrap(_defer); /***/ }), -/***/ 67249: +/***/ 44674: /***/ ((module, exports) => { "use strict"; @@ -5516,7 +5516,7 @@ module.exports = exports.default; /***/ }), -/***/ 25042: +/***/ 57456: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -5527,7 +5527,7 @@ Object.defineProperty(exports, "__esModule", ({ })); exports.isAsyncIterable = exports.isAsyncGenerator = exports.isAsync = undefined; -var _asyncify = __nccwpck_require__(88714); +var _asyncify = __nccwpck_require__(20991); var _asyncify2 = _interopRequireDefault(_asyncify); @@ -5557,7 +5557,7 @@ exports.isAsyncIterable = isAsyncIterable; /***/ }), -/***/ 50220: +/***/ 59619: /***/ ((module, exports, __nccwpck_require__) => { "use strict"; @@ -5568,11 +5568,11 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = series; -var _parallel2 = __nccwpck_require__(55071); +var _parallel2 = __nccwpck_require__(63221); var _parallel3 = _interopRequireDefault(_parallel2); -var _eachOfSeries = __nccwpck_require__(6576); +var _eachOfSeries = __nccwpck_require__(81336); var _eachOfSeries2 = _interopRequireDefault(_eachOfSeries); @@ -5750,20 +5750,20 @@ module.exports = exports.default; /***/ }), -/***/ 99327: +/***/ 14812: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { module.exports = { - parallel : __nccwpck_require__(21266), - serial : __nccwpck_require__(63979), - serialOrdered : __nccwpck_require__(32054) + parallel : __nccwpck_require__(8210), + serial : __nccwpck_require__(50445), + serialOrdered : __nccwpck_require__(3578) }; /***/ }), -/***/ 697: +/***/ 1700: /***/ ((module) => { // API @@ -5799,10 +5799,10 @@ function clean(key) /***/ }), -/***/ 58132: +/***/ 72794: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var defer = __nccwpck_require__(74960); +var defer = __nccwpck_require__(15295); // API module.exports = async; @@ -5840,7 +5840,7 @@ function async(callback) /***/ }), -/***/ 74960: +/***/ 15295: /***/ ((module) => { module.exports = defer; @@ -5873,11 +5873,11 @@ function defer(fn) /***/ }), -/***/ 3937: +/***/ 9023: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var async = __nccwpck_require__(58132) - , abort = __nccwpck_require__(697) +var async = __nccwpck_require__(72794) + , abort = __nccwpck_require__(1700) ; // API @@ -5955,7 +5955,7 @@ function runJob(iterator, key, item, callback) /***/ }), -/***/ 81057: +/***/ 42474: /***/ ((module) => { // API @@ -5999,11 +5999,11 @@ function state(list, sortMethod) /***/ }), -/***/ 28127: +/***/ 37942: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var abort = __nccwpck_require__(697) - , async = __nccwpck_require__(58132) +var abort = __nccwpck_require__(1700) + , async = __nccwpck_require__(72794) ; // API @@ -6035,12 +6035,12 @@ function terminator(callback) /***/ }), -/***/ 21266: +/***/ 8210: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var iterate = __nccwpck_require__(3937) - , initState = __nccwpck_require__(81057) - , terminator = __nccwpck_require__(28127) +var iterate = __nccwpck_require__(9023) + , initState = __nccwpck_require__(42474) + , terminator = __nccwpck_require__(37942) ; // Public API @@ -6085,10 +6085,10 @@ function parallel(list, iterator, callback) /***/ }), -/***/ 63979: +/***/ 50445: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var serialOrdered = __nccwpck_require__(32054); +var serialOrdered = __nccwpck_require__(3578); // Public API module.exports = serial; @@ -6109,12 +6109,12 @@ function serial(list, iterator, callback) /***/ }), -/***/ 32054: +/***/ 3578: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var iterate = __nccwpck_require__(3937) - , initState = __nccwpck_require__(81057) - , terminator = __nccwpck_require__(28127) +var iterate = __nccwpck_require__(9023) + , initState = __nccwpck_require__(42474) + , terminator = __nccwpck_require__(37942) ; // Public API @@ -6191,7 +6191,7 @@ function descending(a, b) /***/ }), -/***/ 95996: +/***/ 9417: /***/ ((module) => { "use strict"; @@ -6261,7 +6261,7 @@ function range(a, b, str) { /***/ }), -/***/ 55783: +/***/ 26463: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -6419,7 +6419,7 @@ function fromByteArray (uint8) { /***/ }), -/***/ 73599: +/***/ 44159: /***/ ((module) => { module.exports = { @@ -6433,10 +6433,10 @@ module.exports = { /***/ }), -/***/ 60635: +/***/ 33717: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var balanced = __nccwpck_require__(95996); +var balanced = __nccwpck_require__(9417); module.exports = expandTop; @@ -6643,7 +6643,7 @@ function expand(str, isTop) { /***/ }), -/***/ 64661: +/***/ 21362: /***/ ((module) => { "use strict"; @@ -6764,14 +6764,14 @@ module.exports["default"] = camelCase; /***/ }), -/***/ 36943: +/***/ 28513: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.groupSelectors = exports.getDocumentRoot = void 0; -var positionals_js_1 = __nccwpck_require__(47508); +var positionals_js_1 = __nccwpck_require__(59159); function getDocumentRoot(node) { while (node.parent) node = node.parent; @@ -6797,7 +6797,7 @@ exports.groupSelectors = groupSelectors; /***/ }), -/***/ 22599: +/***/ 95409: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -6847,14 +6847,14 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.select = exports.filter = exports.some = exports.is = exports.aliases = exports.pseudos = exports.filters = void 0; -var css_what_1 = __nccwpck_require__(22554); -var css_select_1 = __nccwpck_require__(98933); -var DomUtils = __importStar(__nccwpck_require__(76753)); -var boolbase = __importStar(__nccwpck_require__(73599)); -var helpers_js_1 = __nccwpck_require__(36943); -var positionals_js_1 = __nccwpck_require__(47508); +var css_what_1 = __nccwpck_require__(80284); +var css_select_1 = __nccwpck_require__(4508); +var DomUtils = __importStar(__nccwpck_require__(11754)); +var boolbase = __importStar(__nccwpck_require__(44159)); +var helpers_js_1 = __nccwpck_require__(28513); +var positionals_js_1 = __nccwpck_require__(59159); // Re-export pseudo extension points -var css_select_2 = __nccwpck_require__(98933); +var css_select_2 = __nccwpck_require__(4508); Object.defineProperty(exports, "filters", ({ enumerable: true, get: function () { return css_select_2.filters; } })); Object.defineProperty(exports, "pseudos", ({ enumerable: true, get: function () { return css_select_2.pseudos; } })); Object.defineProperty(exports, "aliases", ({ enumerable: true, get: function () { return css_select_2.aliases; } })); @@ -7106,7 +7106,7 @@ function filterElements(elements, sel, options) { /***/ }), -/***/ 47508: +/***/ 59159: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -7165,7 +7165,7 @@ exports.getLimit = getLimit; /***/ }), -/***/ 34502: +/***/ 68596: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -7177,9 +7177,9 @@ exports.getLimit = getLimit; */ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.toggleClass = exports.removeClass = exports.addClass = exports.hasClass = exports.removeAttr = exports.val = exports.data = exports.prop = exports.attr = void 0; -var static_js_1 = __nccwpck_require__(52243); -var utils_js_1 = __nccwpck_require__(18397); -var domutils_1 = __nccwpck_require__(76753); +var static_js_1 = __nccwpck_require__(80002); +var utils_js_1 = __nccwpck_require__(51183); +var domutils_1 = __nccwpck_require__(11754); var hasOwn = Object.prototype.hasOwnProperty; var rspace = /\s+/; var dataAttrPrefix = 'data-'; @@ -7794,14 +7794,14 @@ exports.toggleClass = toggleClass; /***/ }), -/***/ 42107: +/***/ 7084: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.css = void 0; -var utils_js_1 = __nccwpck_require__(18397); +var utils_js_1 = __nccwpck_require__(51183); /** * Set multiple CSS properties for every matched element. * @@ -7919,14 +7919,14 @@ function parse(styles) { /***/ }), -/***/ 92830: +/***/ 95954: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.serializeArray = exports.serialize = void 0; -var utils_js_1 = __nccwpck_require__(18397); +var utils_js_1 = __nccwpck_require__(51183); /* * https://github.com/jquery/jquery/blob/2.1.3/src/manipulation/var/rcheckableType.js * https://github.com/jquery/jquery/blob/2.1.3/src/serialize.js @@ -8018,7 +8018,7 @@ exports.serializeArray = serializeArray; /***/ }), -/***/ 73326: +/***/ 58196: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -8039,11 +8039,11 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.clone = exports.text = exports.toString = exports.html = exports.empty = exports.replaceWith = exports.remove = exports.insertBefore = exports.before = exports.insertAfter = exports.after = exports.wrapAll = exports.unwrap = exports.wrapInner = exports.wrap = exports.prepend = exports.append = exports.prependTo = exports.appendTo = exports._makeDomArray = void 0; -var domhandler_1 = __nccwpck_require__(85681); -var parse_js_1 = __nccwpck_require__(36749); -var static_js_1 = __nccwpck_require__(52243); -var utils_js_1 = __nccwpck_require__(18397); -var domutils_1 = __nccwpck_require__(76753); +var domhandler_1 = __nccwpck_require__(74038); +var parse_js_1 = __nccwpck_require__(29024); +var static_js_1 = __nccwpck_require__(80002); +var utils_js_1 = __nccwpck_require__(51183); +var domutils_1 = __nccwpck_require__(11754); /** * Create an array of nodes, recursing into arrays and parsing strings if necessary. * @@ -8886,7 +8886,7 @@ exports.clone = clone; /***/ }), -/***/ 18900: +/***/ 66563: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -8930,11 +8930,11 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.addBack = exports.add = exports.end = exports.slice = exports.index = exports.toArray = exports.get = exports.eq = exports.last = exports.first = exports.has = exports.not = exports.is = exports.filterArray = exports.filter = exports.map = exports.each = exports.contents = exports.children = exports.siblings = exports.prevUntil = exports.prevAll = exports.prev = exports.nextUntil = exports.nextAll = exports.next = exports.closest = exports.parentsUntil = exports.parents = exports.parent = exports.find = void 0; -var domhandler_1 = __nccwpck_require__(85681); -var select = __importStar(__nccwpck_require__(22599)); -var utils_js_1 = __nccwpck_require__(18397); -var static_js_1 = __nccwpck_require__(52243); -var domutils_1 = __nccwpck_require__(76753); +var domhandler_1 = __nccwpck_require__(74038); +var select = __importStar(__nccwpck_require__(95409)); +var utils_js_1 = __nccwpck_require__(51183); +var static_js_1 = __nccwpck_require__(80002); +var domutils_1 = __nccwpck_require__(11754); var reSiblingSelector = /^\s*[~+]/; /** * Get the descendants of each element in the current set of matched elements, @@ -9800,7 +9800,7 @@ exports.addBack = addBack; /***/ }), -/***/ 62650: +/***/ 10641: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -9830,11 +9830,11 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Cheerio = void 0; -var Attributes = __importStar(__nccwpck_require__(34502)); -var Traversing = __importStar(__nccwpck_require__(18900)); -var Manipulation = __importStar(__nccwpck_require__(73326)); -var Css = __importStar(__nccwpck_require__(42107)); -var Forms = __importStar(__nccwpck_require__(92830)); +var Attributes = __importStar(__nccwpck_require__(68596)); +var Traversing = __importStar(__nccwpck_require__(66563)); +var Manipulation = __importStar(__nccwpck_require__(58196)); +var Css = __importStar(__nccwpck_require__(7084)); +var Forms = __importStar(__nccwpck_require__(95954)); var Cheerio = /** @class */ (function () { /** * Instance of cheerio. Methods are specified in the modules. Usage of this @@ -9873,7 +9873,7 @@ Object.assign(Cheerio.prototype, Attributes, Traversing, Manipulation, Css, Form /***/ }), -/***/ 72416: +/***/ 34612: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -9914,12 +9914,12 @@ exports.root = exports.parseHTML = exports.merge = exports.contains = exports.te * * @category Cheerio */ -__exportStar(__nccwpck_require__(22168), exports); -var load_js_1 = __nccwpck_require__(83970); -var parse_js_1 = __nccwpck_require__(36749); -var parse5_adapter_js_1 = __nccwpck_require__(39056); -var dom_serializer_1 = __importDefault(__nccwpck_require__(24198)); -var htmlparser2_1 = __nccwpck_require__(86559); +__exportStar(__nccwpck_require__(59317), exports); +var load_js_1 = __nccwpck_require__(1313); +var parse_js_1 = __nccwpck_require__(29024); +var parse5_adapter_js_1 = __nccwpck_require__(28186); +var dom_serializer_1 = __importDefault(__nccwpck_require__(48621)); +var htmlparser2_1 = __nccwpck_require__(92928); var parse = (0, parse_js_1.getParse)(function (content, options, isDocument, context) { return options.xmlMode || options._useHtmlParser2 ? (0, htmlparser2_1.parseDocument)(content, options) @@ -9950,11 +9950,11 @@ exports.load = (0, load_js_1.getLoad)(parse, function (dom, options) { * @deprecated Use the function returned by `load` instead. */ exports["default"] = (0, exports.load)([]); -var static_js_1 = __nccwpck_require__(52243); +var static_js_1 = __nccwpck_require__(80002); Object.defineProperty(exports, "html", ({ enumerable: true, get: function () { return static_js_1.html; } })); Object.defineProperty(exports, "xml", ({ enumerable: true, get: function () { return static_js_1.xml; } })); Object.defineProperty(exports, "text", ({ enumerable: true, get: function () { return static_js_1.text; } })); -var staticMethods = __importStar(__nccwpck_require__(52243)); +var staticMethods = __importStar(__nccwpck_require__(80002)); /** * In order to promote consistency with the jQuery library, users are encouraged * to instead use the static method of the same name. @@ -10021,7 +10021,7 @@ exports.root = staticMethods.root; /***/ }), -/***/ 83970: +/***/ 1313: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -10077,10 +10077,10 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.getLoad = void 0; -var options_js_1 = __importStar(__nccwpck_require__(70621)); -var staticMethods = __importStar(__nccwpck_require__(52243)); -var cheerio_js_1 = __nccwpck_require__(62650); -var utils_js_1 = __nccwpck_require__(18397); +var options_js_1 = __importStar(__nccwpck_require__(79901)); +var staticMethods = __importStar(__nccwpck_require__(80002)); +var cheerio_js_1 = __nccwpck_require__(10641); +var utils_js_1 = __nccwpck_require__(51183); function getLoad(parse, render) { /** * Create a querying function, bound to a document created from the provided markup. @@ -10207,7 +10207,7 @@ function isNode(obj) { /***/ }), -/***/ 70621: +/***/ 79901: /***/ (function(__unused_webpack_module, exports) { "use strict"; @@ -10255,15 +10255,15 @@ exports.flatten = flatten; /***/ }), -/***/ 36749: +/***/ 29024: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.update = exports.getParse = void 0; -var domutils_1 = __nccwpck_require__(76753); -var domhandler_1 = __nccwpck_require__(85681); +var domutils_1 = __nccwpck_require__(11754); +var domhandler_1 = __nccwpck_require__(74038); /** * Get the parse function with options. * @@ -10340,7 +10340,7 @@ exports.update = update; /***/ }), -/***/ 39056: +/***/ 28186: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -10356,9 +10356,9 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.renderWithParse5 = exports.parseWithParse5 = void 0; -var domhandler_1 = __nccwpck_require__(85681); -var parse5_1 = __nccwpck_require__(71943); -var parse5_htmlparser2_tree_adapter_1 = __nccwpck_require__(20953); +var domhandler_1 = __nccwpck_require__(74038); +var parse5_1 = __nccwpck_require__(43095); +var parse5_htmlparser2_tree_adapter_1 = __nccwpck_require__(9000); /** * Parse the content with `parse5` in the context of the given `ParentNode`. * @@ -10414,7 +10414,7 @@ exports.renderWithParse5 = renderWithParse5; /***/ }), -/***/ 52243: +/***/ 80002: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -10455,8 +10455,8 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.merge = exports.contains = exports.root = exports.parseHTML = exports.text = exports.xml = exports.html = void 0; -var domutils_1 = __nccwpck_require__(76753); -var options_js_1 = __importStar(__nccwpck_require__(70621)); +var domutils_1 = __nccwpck_require__(11754); +var options_js_1 = __importStar(__nccwpck_require__(79901)); /** * Helper function to render a DOM. * @@ -10647,7 +10647,7 @@ function isArrayLike(item) { /***/ }), -/***/ 22168: +/***/ 59317: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -10657,14 +10657,14 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); /***/ }), -/***/ 18397: +/***/ 51183: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.isHtml = exports.cloneDom = exports.domEach = exports.cssCase = exports.camelCase = exports.isCheerio = exports.isTag = void 0; -var domhandler_1 = __nccwpck_require__(85681); +var domhandler_1 = __nccwpck_require__(74038); /** * Check if the DOM element is a tag. * @@ -10675,7 +10675,7 @@ var domhandler_1 = __nccwpck_require__(85681); * @param type - The DOM node to check. * @returns Whether the node is a tag. */ -var domhandler_2 = __nccwpck_require__(85681); +var domhandler_2 = __nccwpck_require__(74038); Object.defineProperty(exports, "isTag", ({ enumerable: true, get: function () { return domhandler_2.isTag; } })); /** * Checks if an object is a Cheerio instance. @@ -10786,7 +10786,7 @@ exports.isHtml = isHtml; /***/ }), -/***/ 60441: +/***/ 78510: /***/ ((module) => { "use strict"; @@ -10946,12 +10946,12 @@ module.exports = { /***/ }), -/***/ 21922: +/***/ 11069: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { /* MIT license */ -var colorNames = __nccwpck_require__(60441); -var swizzle = __nccwpck_require__(41539); +var colorNames = __nccwpck_require__(78510); +var swizzle = __nccwpck_require__(78679); var hasOwnProperty = Object.hasOwnProperty; var reverseNames = Object.create(null); @@ -11195,14 +11195,14 @@ function hexDouble(num) { /***/ }), -/***/ 73681: +/***/ 87177: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var colorString = __nccwpck_require__(21922); -var convert = __nccwpck_require__(51855); +var colorString = __nccwpck_require__(11069); +var convert = __nccwpck_require__(20241); var _slice = [].slice; @@ -11685,11 +11685,11 @@ module.exports = Color; /***/ }), -/***/ 1583: +/***/ 55479: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { /* MIT license */ -var cssKeywords = __nccwpck_require__(10147); +var cssKeywords = __nccwpck_require__(70074); // NOTE: conversions should only return primitive values (i.e. arrays, or // values that give correct `typeof` results). @@ -12560,11 +12560,11 @@ convert.rgb.gray = function (rgb) { /***/ }), -/***/ 51855: +/***/ 20241: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var conversions = __nccwpck_require__(1583); -var route = __nccwpck_require__(67560); +var conversions = __nccwpck_require__(55479); +var route = __nccwpck_require__(48110); var convert = {}; @@ -12645,10 +12645,10 @@ module.exports = convert; /***/ }), -/***/ 67560: +/***/ 48110: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var conversions = __nccwpck_require__(1583); +var conversions = __nccwpck_require__(55479); /* this function routes a model to all other models. @@ -12749,7 +12749,7 @@ module.exports = function (fromModel) { /***/ }), -/***/ 10147: +/***/ 70074: /***/ ((module) => { "use strict"; @@ -12909,14 +12909,14 @@ module.exports = { /***/ }), -/***/ 72900: +/***/ 85917: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var color = __nccwpck_require__(73681) - , hex = __nccwpck_require__(52189); +var color = __nccwpck_require__(87177) + , hex = __nccwpck_require__(67014); /** * Generate a color for a given name. But be reasonably smart about it by @@ -12946,12 +12946,12 @@ module.exports = function colorspace(namespace, delimiter) { /***/ }), -/***/ 72336: +/***/ 85443: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { var util = __nccwpck_require__(73837); var Stream = (__nccwpck_require__(12781).Stream); -var DelayedStream = __nccwpck_require__(9449); +var DelayedStream = __nccwpck_require__(18611); module.exports = CombinedStream; function CombinedStream() { @@ -13161,7 +13161,7 @@ CombinedStream.prototype._emitError = function(err) { /***/ }), -/***/ 16551: +/***/ 36863: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -13171,7 +13171,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.attributeRules = void 0; -var boolbase_1 = __importDefault(__nccwpck_require__(73599)); +var boolbase_1 = __importDefault(__nccwpck_require__(44159)); /** * All reserved characters in a regex, used for escaping. * @@ -13404,7 +13404,7 @@ exports.attributeRules = { /***/ }), -/***/ 61526: +/***/ 35030: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -13437,11 +13437,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.compileToken = exports.compileUnsafe = exports.compile = void 0; -var css_what_1 = __nccwpck_require__(22554); -var boolbase_1 = __importDefault(__nccwpck_require__(73599)); -var sort_js_1 = __importStar(__nccwpck_require__(37609)); -var general_js_1 = __nccwpck_require__(62528); -var subselects_js_1 = __nccwpck_require__(55435); +var css_what_1 = __nccwpck_require__(80284); +var boolbase_1 = __importDefault(__nccwpck_require__(44159)); +var sort_js_1 = __importStar(__nccwpck_require__(57320)); +var general_js_1 = __nccwpck_require__(45374); +var subselects_js_1 = __nccwpck_require__(15813); /** * Compiles a selector to an executable function. * @@ -13562,16 +13562,16 @@ function reduceRules(a, b) { /***/ }), -/***/ 62528: +/***/ 45374: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.compileGeneralSelector = void 0; -var attributes_js_1 = __nccwpck_require__(16551); -var index_js_1 = __nccwpck_require__(51757); -var css_what_1 = __nccwpck_require__(22554); +var attributes_js_1 = __nccwpck_require__(36863); +var index_js_1 = __nccwpck_require__(89312); +var css_what_1 = __nccwpck_require__(80284); function getElementParent(node, adapter) { var parent = adapter.getParent(node); if (parent && adapter.isTag(parent)) { @@ -13717,7 +13717,7 @@ exports.compileGeneralSelector = compileGeneralSelector; /***/ }), -/***/ 98933: +/***/ 4508: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -13750,10 +13750,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.aliases = exports.pseudos = exports.filters = exports.is = exports.selectOne = exports.selectAll = exports.prepareContext = exports._compileToken = exports._compileUnsafe = exports.compile = void 0; -var DomUtils = __importStar(__nccwpck_require__(76753)); -var boolbase_1 = __importDefault(__nccwpck_require__(73599)); -var compile_js_1 = __nccwpck_require__(61526); -var subselects_js_1 = __nccwpck_require__(55435); +var DomUtils = __importStar(__nccwpck_require__(11754)); +var boolbase_1 = __importDefault(__nccwpck_require__(44159)); +var compile_js_1 = __nccwpck_require__(35030); +var subselects_js_1 = __nccwpck_require__(15813); var defaultEquals = function (a, b) { return a === b; }; var defaultOptions = { adapter: DomUtils, @@ -13870,7 +13870,7 @@ exports.is = is; exports["default"] = exports.selectAll; // Export filters, pseudos and aliases to allow users to supply their own. /** @deprecated Use the `pseudos` option instead. */ -var index_js_1 = __nccwpck_require__(51757); +var index_js_1 = __nccwpck_require__(89312); Object.defineProperty(exports, "filters", ({ enumerable: true, get: function () { return index_js_1.filters; } })); Object.defineProperty(exports, "pseudos", ({ enumerable: true, get: function () { return index_js_1.pseudos; } })); Object.defineProperty(exports, "aliases", ({ enumerable: true, get: function () { return index_js_1.aliases; } })); @@ -13878,7 +13878,7 @@ Object.defineProperty(exports, "aliases", ({ enumerable: true, get: function () /***/ }), -/***/ 75282: +/***/ 24176: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -13919,7 +13919,7 @@ exports.aliases = { /***/ }), -/***/ 91814: +/***/ 51686: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -13929,8 +13929,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.filters = void 0; -var nth_check_1 = __importDefault(__nccwpck_require__(27159)); -var boolbase_1 = __importDefault(__nccwpck_require__(73599)); +var nth_check_1 = __importDefault(__nccwpck_require__(51260)); +var boolbase_1 = __importDefault(__nccwpck_require__(44159)); function getChildFunc(next, adapter) { return function (elem) { var parent = adapter.getParent(elem); @@ -14083,21 +14083,21 @@ function dynamicStatePseudo(name) { /***/ }), -/***/ 51757: +/***/ 89312: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.compilePseudoSelector = exports.aliases = exports.pseudos = exports.filters = void 0; -var css_what_1 = __nccwpck_require__(22554); -var filters_js_1 = __nccwpck_require__(91814); +var css_what_1 = __nccwpck_require__(80284); +var filters_js_1 = __nccwpck_require__(51686); Object.defineProperty(exports, "filters", ({ enumerable: true, get: function () { return filters_js_1.filters; } })); -var pseudos_js_1 = __nccwpck_require__(54005); +var pseudos_js_1 = __nccwpck_require__(8952); Object.defineProperty(exports, "pseudos", ({ enumerable: true, get: function () { return pseudos_js_1.pseudos; } })); -var aliases_js_1 = __nccwpck_require__(75282); +var aliases_js_1 = __nccwpck_require__(24176); Object.defineProperty(exports, "aliases", ({ enumerable: true, get: function () { return aliases_js_1.aliases; } })); -var subselects_js_1 = __nccwpck_require__(55435); +var subselects_js_1 = __nccwpck_require__(15813); function compilePseudoSelector(next, selector, options, context, compileToken) { var _a; var name = selector.name, data = selector.data; @@ -14136,7 +14136,7 @@ exports.compilePseudoSelector = compilePseudoSelector; /***/ }), -/***/ 54005: +/***/ 8952: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -14236,7 +14236,7 @@ exports.verifyPseudoArgs = verifyPseudoArgs; /***/ }), -/***/ 55435: +/***/ 15813: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -14255,8 +14255,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.subselects = exports.getNextSiblings = exports.ensureIsTag = exports.PLACEHOLDER_ELEMENT = void 0; -var boolbase_1 = __importDefault(__nccwpck_require__(73599)); -var sort_js_1 = __nccwpck_require__(37609); +var boolbase_1 = __importDefault(__nccwpck_require__(44159)); +var sort_js_1 = __nccwpck_require__(57320); /** Used as a placeholder for :has. Will be replaced with the actual element. */ exports.PLACEHOLDER_ELEMENT = {}; function ensureIsTag(next, adapter) { @@ -14355,14 +14355,14 @@ exports.subselects = { /***/ }), -/***/ 37609: +/***/ 57320: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.isTraversal = void 0; -var css_what_1 = __nccwpck_require__(22554); +var css_what_1 = __nccwpck_require__(80284); var procedure = new Map([ [css_what_1.SelectorType.Universal, 50], [css_what_1.SelectorType.Tag, 30], @@ -14446,7 +14446,7 @@ function getProcedure(token) { /***/ }), -/***/ 22554: +/***/ 80284: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -14467,24 +14467,24 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.stringify = exports.parse = exports.isTraversal = void 0; -__exportStar(__nccwpck_require__(30730), exports); -var parse_1 = __nccwpck_require__(62479); +__exportStar(__nccwpck_require__(98752), exports); +var parse_1 = __nccwpck_require__(67255); Object.defineProperty(exports, "isTraversal", ({ enumerable: true, get: function () { return parse_1.isTraversal; } })); Object.defineProperty(exports, "parse", ({ enumerable: true, get: function () { return parse_1.parse; } })); -var stringify_1 = __nccwpck_require__(72749); +var stringify_1 = __nccwpck_require__(19265); Object.defineProperty(exports, "stringify", ({ enumerable: true, get: function () { return stringify_1.stringify; } })); /***/ }), -/***/ 62479: +/***/ 67255: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parse = exports.isTraversal = void 0; -var types_1 = __nccwpck_require__(30730); +var types_1 = __nccwpck_require__(98752); var reName = /^[^\\#]?(?:\\(?:[\da-f]{1,6}\s?|.)|[\w\-\u00b0-\uFFFF])+/; var reEscape = /\\([\da-f]{1,6}\s?|(\s)|.)/gi; var actionTypes = new Map([ @@ -14910,7 +14910,7 @@ function parseSelector(subselects, selector, selectorIndex) { /***/ }), -/***/ 72749: +/***/ 19265: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -14926,7 +14926,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.stringify = void 0; -var types_1 = __nccwpck_require__(30730); +var types_1 = __nccwpck_require__(98752); var attribValChars = ["\\", '"']; var pseudoValChars = __spreadArray(__spreadArray([], attribValChars, true), ["(", ")"], false); var charsToEscapeInAttributeValue = new Set(attribValChars.map(function (c) { return c.charCodeAt(0); })); @@ -15056,7 +15056,7 @@ function escapeName(str, charsToEscape) { /***/ }), -/***/ 30730: +/***/ 98752: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -15106,7 +15106,7 @@ var AttributeAction; /***/ }), -/***/ 62984: +/***/ 70159: /***/ ((module) => { "use strict"; @@ -15127,7 +15127,7 @@ module.exports = function (str, sep) { /***/ }), -/***/ 9449: +/***/ 18611: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { var Stream = (__nccwpck_require__(12781).Stream); @@ -15241,7 +15241,7 @@ DelayedStream.prototype._checkIfMaxDataSizeExceeded = function() { /***/ }), -/***/ 59812: +/***/ 14802: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -15352,7 +15352,7 @@ exports.attributeNames = new Map([ /***/ }), -/***/ 24198: +/***/ 48621: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -15396,15 +15396,15 @@ exports.render = void 0; /* * Module dependencies */ -var ElementType = __importStar(__nccwpck_require__(73192)); -var entities_1 = __nccwpck_require__(41918); +var ElementType = __importStar(__nccwpck_require__(53944)); +var entities_1 = __nccwpck_require__(3000); /** * Mixed-case SVG and MathML tags & attributes * recognized by the HTML parser. * * @see https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inforeign */ -var foreignNames_js_1 = __nccwpck_require__(59812); +var foreignNames_js_1 = __nccwpck_require__(14802); var unencodedElements = new Set([ "style", "script", @@ -15589,7 +15589,7 @@ function renderComment(elem) { /***/ }), -/***/ 73192: +/***/ 53944: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -15652,7 +15652,7 @@ exports.Doctype = ElementType.Doctype; /***/ }), -/***/ 85681: +/***/ 74038: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -15673,9 +15673,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.DomHandler = void 0; -var domelementtype_1 = __nccwpck_require__(73192); -var node_js_1 = __nccwpck_require__(60403); -__exportStar(__nccwpck_require__(60403), exports); +var domelementtype_1 = __nccwpck_require__(53944); +var node_js_1 = __nccwpck_require__(7822); +__exportStar(__nccwpck_require__(7822), exports); // Default options var defaultOpts = { withStartIndices: false, @@ -15825,7 +15825,7 @@ exports["default"] = DomHandler; /***/ }), -/***/ 60403: +/***/ 7822: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -15858,7 +15858,7 @@ var __assign = (this && this.__assign) || function () { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.cloneNode = exports.hasChildren = exports.isDocument = exports.isDirective = exports.isComment = exports.isText = exports.isCDATA = exports.isTag = exports.Element = exports.Document = exports.CDATA = exports.NodeWithChildren = exports.ProcessingInstruction = exports.Comment = exports.Text = exports.DataNode = exports.Node = void 0; -var domelementtype_1 = __nccwpck_require__(73192); +var domelementtype_1 = __nccwpck_require__(53944); /** * This object will be used as the prototype for Nodes when creating a * DOM-Level-1-compliant structure. @@ -16307,15 +16307,15 @@ function cloneChildren(childs) { /***/ }), -/***/ 57954: +/***/ 71503: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.getFeed = void 0; -var stringify_js_1 = __nccwpck_require__(57916); -var legacy_js_1 = __nccwpck_require__(23489); +var stringify_js_1 = __nccwpck_require__(29561); +var legacy_js_1 = __nccwpck_require__(72185); /** * Get the feed object from the root of a DOM tree. * @@ -16505,14 +16505,14 @@ function isValidFeed(value) { /***/ }), -/***/ 71766: +/***/ 61447: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.uniqueSort = exports.compareDocumentPosition = exports.DocumentPosition = exports.removeSubsets = void 0; -var domhandler_1 = __nccwpck_require__(85681); +var domhandler_1 = __nccwpck_require__(74038); /** * Given an array of nodes, remove any member that is contained by another * member. @@ -16654,7 +16654,7 @@ exports.uniqueSort = uniqueSort; /***/ }), -/***/ 76753: +/***/ 11754: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -16675,15 +16675,15 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.hasChildren = exports.isDocument = exports.isComment = exports.isText = exports.isCDATA = exports.isTag = void 0; -__exportStar(__nccwpck_require__(57916), exports); -__exportStar(__nccwpck_require__(8643), exports); -__exportStar(__nccwpck_require__(31989), exports); -__exportStar(__nccwpck_require__(21281), exports); -__exportStar(__nccwpck_require__(23489), exports); -__exportStar(__nccwpck_require__(71766), exports); -__exportStar(__nccwpck_require__(57954), exports); +__exportStar(__nccwpck_require__(29561), exports); +__exportStar(__nccwpck_require__(79228), exports); +__exportStar(__nccwpck_require__(20177), exports); +__exportStar(__nccwpck_require__(39908), exports); +__exportStar(__nccwpck_require__(72185), exports); +__exportStar(__nccwpck_require__(61447), exports); +__exportStar(__nccwpck_require__(71503), exports); /** @deprecated Use these methods from `domhandler` directly. */ -var domhandler_1 = __nccwpck_require__(85681); +var domhandler_1 = __nccwpck_require__(74038); Object.defineProperty(exports, "isTag", ({ enumerable: true, get: function () { return domhandler_1.isTag; } })); Object.defineProperty(exports, "isCDATA", ({ enumerable: true, get: function () { return domhandler_1.isCDATA; } })); Object.defineProperty(exports, "isText", ({ enumerable: true, get: function () { return domhandler_1.isText; } })); @@ -16694,15 +16694,15 @@ Object.defineProperty(exports, "hasChildren", ({ enumerable: true, get: function /***/ }), -/***/ 23489: +/***/ 72185: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.getElementsByTagType = exports.getElementsByTagName = exports.getElementById = exports.getElements = exports.testElement = void 0; -var domhandler_1 = __nccwpck_require__(85681); -var querying_js_1 = __nccwpck_require__(21281); +var domhandler_1 = __nccwpck_require__(74038); +var querying_js_1 = __nccwpck_require__(39908); /** * A map of functions to check nodes against. */ @@ -16854,7 +16854,7 @@ exports.getElementsByTagType = getElementsByTagType; /***/ }), -/***/ 31989: +/***/ 20177: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -17004,14 +17004,14 @@ exports.prepend = prepend; /***/ }), -/***/ 21281: +/***/ 39908: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.findAll = exports.existsOne = exports.findOne = exports.findOneChild = exports.find = exports.filter = void 0; -var domhandler_1 = __nccwpck_require__(85681); +var domhandler_1 = __nccwpck_require__(74038); /** * Search a node and its children for nodes passing a test function. If `node` is not an array, it will be wrapped in one. * @@ -17170,7 +17170,7 @@ exports.findAll = findAll; /***/ }), -/***/ 57916: +/***/ 29561: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -17180,9 +17180,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.innerText = exports.textContent = exports.getText = exports.getInnerHTML = exports.getOuterHTML = void 0; -var domhandler_1 = __nccwpck_require__(85681); -var dom_serializer_1 = __importDefault(__nccwpck_require__(24198)); -var domelementtype_1 = __nccwpck_require__(73192); +var domhandler_1 = __nccwpck_require__(74038); +var dom_serializer_1 = __importDefault(__nccwpck_require__(48621)); +var domelementtype_1 = __nccwpck_require__(53944); /** * @category Stringify * @deprecated Use the `dom-serializer` module directly. @@ -17269,14 +17269,14 @@ exports.innerText = innerText; /***/ }), -/***/ 8643: +/***/ 79228: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.prevElementSibling = exports.nextElementSibling = exports.getName = exports.hasAttrib = exports.getAttributeValue = exports.getSiblings = exports.getParent = exports.getChildren = void 0; -var domhandler_1 = __nccwpck_require__(85681); +var domhandler_1 = __nccwpck_require__(74038); /** * Get a node's children. * @@ -17402,7 +17402,7 @@ exports.prevElementSibling = prevElementSibling; /***/ }), -/***/ 36406: +/***/ 12437: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { const fs = __nccwpck_require__(57147) @@ -17770,7 +17770,7 @@ module.exports = DotenvModule /***/ }), -/***/ 22290: +/***/ 3495: /***/ ((module) => { "use strict"; @@ -17812,7 +17812,7 @@ module.exports = function enabled(name, variable) { /***/ }), -/***/ 83942: +/***/ 85107: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -17845,13 +17845,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.decodeXML = exports.decodeHTMLStrict = exports.decodeHTMLAttribute = exports.decodeHTML = exports.determineBranch = exports.EntityDecoder = exports.DecodingMode = exports.BinTrieFlags = exports.fromCodePoint = exports.replaceCodePoint = exports.decodeCodePoint = exports.xmlDecodeTree = exports.htmlDecodeTree = void 0; -var decode_data_html_js_1 = __importDefault(__nccwpck_require__(35213)); +var decode_data_html_js_1 = __importDefault(__nccwpck_require__(76970)); exports.htmlDecodeTree = decode_data_html_js_1.default; -var decode_data_xml_js_1 = __importDefault(__nccwpck_require__(11086)); +var decode_data_xml_js_1 = __importDefault(__nccwpck_require__(27359)); exports.xmlDecodeTree = decode_data_xml_js_1.default; -var decode_codepoint_js_1 = __importStar(__nccwpck_require__(46628)); +var decode_codepoint_js_1 = __importStar(__nccwpck_require__(31227)); exports.decodeCodePoint = decode_codepoint_js_1.default; -var decode_codepoint_js_2 = __nccwpck_require__(46628); +var decode_codepoint_js_2 = __nccwpck_require__(31227); Object.defineProperty(exports, "replaceCodePoint", ({ enumerable: true, get: function () { return decode_codepoint_js_2.replaceCodePoint; } })); Object.defineProperty(exports, "fromCodePoint", ({ enumerable: true, get: function () { return decode_codepoint_js_2.fromCodePoint; } })); var CharCodes; @@ -18355,7 +18355,7 @@ exports.decodeXML = decodeXML; /***/ }), -/***/ 46628: +/***/ 31227: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -18438,7 +18438,7 @@ exports["default"] = decodeCodePoint; /***/ }), -/***/ 17040: +/***/ 2006: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -18448,8 +18448,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.encodeNonAsciiHTML = exports.encodeHTML = void 0; -var encode_html_js_1 = __importDefault(__nccwpck_require__(91064)); -var escape_js_1 = __nccwpck_require__(16484); +var encode_html_js_1 = __importDefault(__nccwpck_require__(88180)); +var escape_js_1 = __nccwpck_require__(37654); var htmlReplacer = /[\t\n!-,./:-@[-`\f{-}$\x80-\uFFFF]/g; /** * Encodes all characters in the input using HTML entities. This includes @@ -18522,7 +18522,7 @@ function encodeHTMLTrieRe(regExp, str) { /***/ }), -/***/ 16484: +/***/ 37654: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -18651,7 +18651,7 @@ exports.escapeText = getEscaper(/[&<>\u00A0]/g, new Map([ /***/ }), -/***/ 35213: +/***/ 76970: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -18667,7 +18667,7 @@ exports["default"] = new Uint16Array( /***/ }), -/***/ 11086: +/***/ 27359: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -18683,7 +18683,7 @@ exports["default"] = new Uint16Array( /***/ }), -/***/ 91064: +/***/ 88180: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -18702,16 +18702,16 @@ exports["default"] = new Map(/* #__PURE__ */ restoreDiff([[9, " "], [0, "&Ne /***/ }), -/***/ 41918: +/***/ 3000: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.decodeXMLStrict = exports.decodeHTML5Strict = exports.decodeHTML4Strict = exports.decodeHTML5 = exports.decodeHTML4 = exports.decodeHTMLAttribute = exports.decodeHTMLStrict = exports.decodeHTML = exports.decodeXML = exports.DecodingMode = exports.EntityDecoder = exports.encodeHTML5 = exports.encodeHTML4 = exports.encodeNonAsciiHTML = exports.encodeHTML = exports.escapeText = exports.escapeAttribute = exports.escapeUTF8 = exports.escape = exports.encodeXML = exports.encode = exports.decodeStrict = exports.decode = exports.EncodingMode = exports.EntityLevel = void 0; -var decode_js_1 = __nccwpck_require__(83942); -var encode_js_1 = __nccwpck_require__(17040); -var escape_js_1 = __nccwpck_require__(16484); +var decode_js_1 = __nccwpck_require__(85107); +var encode_js_1 = __nccwpck_require__(2006); +var escape_js_1 = __nccwpck_require__(37654); /** The level of entities to support. */ var EntityLevel; (function (EntityLevel) { @@ -18806,19 +18806,19 @@ function encode(data, options) { return (0, escape_js_1.encodeXML)(data); } exports.encode = encode; -var escape_js_2 = __nccwpck_require__(16484); +var escape_js_2 = __nccwpck_require__(37654); Object.defineProperty(exports, "encodeXML", ({ enumerable: true, get: function () { return escape_js_2.encodeXML; } })); Object.defineProperty(exports, "escape", ({ enumerable: true, get: function () { return escape_js_2.escape; } })); Object.defineProperty(exports, "escapeUTF8", ({ enumerable: true, get: function () { return escape_js_2.escapeUTF8; } })); Object.defineProperty(exports, "escapeAttribute", ({ enumerable: true, get: function () { return escape_js_2.escapeAttribute; } })); Object.defineProperty(exports, "escapeText", ({ enumerable: true, get: function () { return escape_js_2.escapeText; } })); -var encode_js_2 = __nccwpck_require__(17040); +var encode_js_2 = __nccwpck_require__(2006); Object.defineProperty(exports, "encodeHTML", ({ enumerable: true, get: function () { return encode_js_2.encodeHTML; } })); Object.defineProperty(exports, "encodeNonAsciiHTML", ({ enumerable: true, get: function () { return encode_js_2.encodeNonAsciiHTML; } })); // Legacy aliases (deprecated) Object.defineProperty(exports, "encodeHTML4", ({ enumerable: true, get: function () { return encode_js_2.encodeHTML; } })); Object.defineProperty(exports, "encodeHTML5", ({ enumerable: true, get: function () { return encode_js_2.encodeHTML; } })); -var decode_js_2 = __nccwpck_require__(83942); +var decode_js_2 = __nccwpck_require__(85107); Object.defineProperty(exports, "EntityDecoder", ({ enumerable: true, get: function () { return decode_js_2.EntityDecoder; } })); Object.defineProperty(exports, "DecodingMode", ({ enumerable: true, get: function () { return decode_js_2.DecodingMode; } })); Object.defineProperty(exports, "decodeXML", ({ enumerable: true, get: function () { return decode_js_2.decodeXML; } })); @@ -18835,7 +18835,7 @@ Object.defineProperty(exports, "decodeXMLStrict", ({ enumerable: true, get: func /***/ }), -/***/ 9689: +/***/ 84697: /***/ ((module, exports) => { "use strict"; @@ -19714,7 +19714,7 @@ module.exports.defineEventAttribute = defineEventAttribute /***/ }), -/***/ 81067: +/***/ 11848: /***/ ((module) => { "use strict"; @@ -20058,7 +20058,7 @@ if (true) { /***/ }), -/***/ 8054: +/***/ 74513: /***/ (function(__unused_webpack_module, exports) { (function (global, factory) { @@ -20482,7 +20482,7 @@ if (true) { /***/ }), -/***/ 84673: +/***/ 12743: /***/ ((module) => { "use strict"; @@ -20532,7 +20532,7 @@ module.exports = function name(fn) { /***/ }), -/***/ 13116: +/***/ 31133: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { var debug; @@ -20541,7 +20541,7 @@ module.exports = function () { if (!debug) { try { /* eslint global-require: off */ - debug = __nccwpck_require__(57969)("follow-redirects"); + debug = __nccwpck_require__(19975)("follow-redirects"); } catch (error) { /* */ } if (typeof debug !== "function") { @@ -20554,7 +20554,7 @@ module.exports = function () { /***/ }), -/***/ 6139: +/***/ 67707: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { var url = __nccwpck_require__(57310); @@ -20563,7 +20563,7 @@ var http = __nccwpck_require__(13685); var https = __nccwpck_require__(95687); var Writable = (__nccwpck_require__(12781).Writable); var assert = __nccwpck_require__(39491); -var debug = __nccwpck_require__(13116); +var debug = __nccwpck_require__(31133); // Whether to use the native URL object or the legacy url module var useNativeURL = false; @@ -21233,10 +21233,10 @@ module.exports.wrap = wrap; /***/ }), -/***/ 69346: +/***/ 64334: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var CombinedStream = __nccwpck_require__(72336); +var CombinedStream = __nccwpck_require__(85443); var util = __nccwpck_require__(73837); var path = __nccwpck_require__(71017); var http = __nccwpck_require__(13685); @@ -21244,9 +21244,9 @@ var https = __nccwpck_require__(95687); var parseUrl = (__nccwpck_require__(57310).parse); var fs = __nccwpck_require__(57147); var Stream = (__nccwpck_require__(12781).Stream); -var mime = __nccwpck_require__(42720); -var asynckit = __nccwpck_require__(99327); -var populate = __nccwpck_require__(18918); +var mime = __nccwpck_require__(43583); +var asynckit = __nccwpck_require__(14812); +var populate = __nccwpck_require__(17142); // Public API module.exports = FormData; @@ -21741,7 +21741,7 @@ FormData.prototype.toString = function () { /***/ }), -/***/ 18918: +/***/ 17142: /***/ ((module) => { // populates missing values @@ -21758,7 +21758,7 @@ module.exports = function(dst, src) { /***/ }), -/***/ 19041: +/***/ 46993: /***/ (function(__unused_webpack_module, exports) { /** @@ -21773,7 +21773,7 @@ module.exports = function(dst, src) { /***/ }), -/***/ 65292: +/***/ 78460: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -21803,8 +21803,8 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Parser = void 0; -var Tokenizer_js_1 = __importStar(__nccwpck_require__(34381)); -var decode_js_1 = __nccwpck_require__(83942); +var Tokenizer_js_1 = __importStar(__nccwpck_require__(82689)); +var decode_js_1 = __nccwpck_require__(85107); var formTags = new Set([ "input", "option", @@ -22298,14 +22298,14 @@ exports.Parser = Parser; /***/ }), -/***/ 34381: +/***/ 82689: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.QuoteType = void 0; -var decode_js_1 = __nccwpck_require__(83942); +var decode_js_1 = __nccwpck_require__(85107); var CharCodes; (function (CharCodes) { CharCodes[CharCodes["Tab"] = 9] = "Tab"; @@ -23243,7 +23243,7 @@ exports["default"] = Tokenizer; /***/ }), -/***/ 86559: +/***/ 92928: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -23276,11 +23276,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.DomUtils = exports.parseFeed = exports.getFeed = exports.ElementType = exports.Tokenizer = exports.createDomStream = exports.parseDOM = exports.parseDocument = exports.DefaultHandler = exports.DomHandler = exports.Parser = void 0; -var Parser_js_1 = __nccwpck_require__(65292); -var Parser_js_2 = __nccwpck_require__(65292); +var Parser_js_1 = __nccwpck_require__(78460); +var Parser_js_2 = __nccwpck_require__(78460); Object.defineProperty(exports, "Parser", ({ enumerable: true, get: function () { return Parser_js_2.Parser; } })); -var domhandler_1 = __nccwpck_require__(85681); -var domhandler_2 = __nccwpck_require__(85681); +var domhandler_1 = __nccwpck_require__(74038); +var domhandler_2 = __nccwpck_require__(74038); Object.defineProperty(exports, "DomHandler", ({ enumerable: true, get: function () { return domhandler_2.DomHandler; } })); // Old name for DomHandler Object.defineProperty(exports, "DefaultHandler", ({ enumerable: true, get: function () { return domhandler_2.DomHandler; } })); @@ -23323,15 +23323,15 @@ function createDomStream(callback, options, elementCallback) { return new Parser_js_1.Parser(handler, options); } exports.createDomStream = createDomStream; -var Tokenizer_js_1 = __nccwpck_require__(34381); +var Tokenizer_js_1 = __nccwpck_require__(82689); Object.defineProperty(exports, "Tokenizer", ({ enumerable: true, get: function () { return __importDefault(Tokenizer_js_1).default; } })); /* * All of the following exports exist for backwards-compatibility. * They should probably be removed eventually. */ -exports.ElementType = __importStar(__nccwpck_require__(73192)); -var domutils_1 = __nccwpck_require__(76753); -var domutils_2 = __nccwpck_require__(76753); +exports.ElementType = __importStar(__nccwpck_require__(53944)); +var domutils_1 = __nccwpck_require__(11754); +var domutils_2 = __nccwpck_require__(11754); Object.defineProperty(exports, "getFeed", ({ enumerable: true, get: function () { return domutils_2.getFeed; } })); var parseFeedDefaultOptions = { xmlMode: true }; /** @@ -23345,12 +23345,12 @@ function parseFeed(feed, options) { return (0, domutils_1.getFeed)(parseDOM(feed, options)); } exports.parseFeed = parseFeed; -exports.DomUtils = __importStar(__nccwpck_require__(76753)); +exports.DomUtils = __importStar(__nccwpck_require__(11754)); //# sourceMappingURL=index.js.map /***/ }), -/***/ 7456: +/***/ 10845: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -23367,7 +23367,7 @@ exports.DomUtils = __importStar(__nccwpck_require__(76753)); */ var util = __nccwpck_require__(73837); -var ms = __nccwpck_require__(83730); +var ms = __nccwpck_require__(80900); module.exports = function (t) { if (typeof t === 'number') return t; @@ -23382,7 +23382,7 @@ module.exports = function (t) { /***/ }), -/***/ 9581: +/***/ 44124: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { try { @@ -23392,13 +23392,13 @@ try { module.exports = util.inherits; } catch (e) { /* istanbul ignore next */ - module.exports = __nccwpck_require__(44345); + module.exports = __nccwpck_require__(8544); } /***/ }), -/***/ 44345: +/***/ 8544: /***/ ((module) => { if (typeof Object.create === 'function') { @@ -23432,7 +23432,7 @@ if (typeof Object.create === 'function') { /***/ }), -/***/ 82434: +/***/ 7604: /***/ ((module) => { module.exports = function isArrayish(obj) { @@ -23448,7 +23448,7 @@ module.exports = function isArrayish(obj) { /***/ }), -/***/ 83921: +/***/ 41554: /***/ ((module) => { "use strict"; @@ -23484,7 +23484,7 @@ module.exports = isStream; /***/ }), -/***/ 84975: +/***/ 26287: /***/ ((module) => { "use strict"; @@ -23610,13 +23610,13 @@ module.exports = Kuler; /***/ }), -/***/ 67275: +/***/ 29748: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const format = __nccwpck_require__(74018); +const format = __nccwpck_require__(23791); /* * function align (info) @@ -23632,15 +23632,15 @@ module.exports = format(info => { /***/ }), -/***/ 55069: +/***/ 46811: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const { Colorizer } = __nccwpck_require__(13027); -const { Padder } = __nccwpck_require__(20742); -const { configs, MESSAGE } = __nccwpck_require__(94079); +const { Colorizer } = __nccwpck_require__(73848); +const { Padder } = __nccwpck_require__(37033); +const { configs, MESSAGE } = __nccwpck_require__(93937); /** @@ -23692,14 +23692,14 @@ module.exports.Format = CliFormat; /***/ }), -/***/ 13027: +/***/ 73848: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const colors = __nccwpck_require__(3319); -const { LEVEL, MESSAGE } = __nccwpck_require__(94079); +const colors = __nccwpck_require__(59256); +const { LEVEL, MESSAGE } = __nccwpck_require__(93937); // // Fix colors not appearing in non-tty environments @@ -23822,13 +23822,13 @@ module.exports.Colorizer /***/ }), -/***/ 5543: +/***/ 77315: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const format = __nccwpck_require__(74018); +const format = __nccwpck_require__(23791); /* * function cascade(formats) @@ -23896,15 +23896,15 @@ module.exports.cascade = cascade; /***/ }), -/***/ 53950: +/***/ 43791: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; /* eslint no-undefined: 0 */ -const format = __nccwpck_require__(74018); -const { LEVEL, MESSAGE } = __nccwpck_require__(94079); +const format = __nccwpck_require__(23791); +const { LEVEL, MESSAGE } = __nccwpck_require__(93937); /* * function errors (info) @@ -23945,7 +23945,7 @@ module.exports = format((einfo, { stack, cause }) => { /***/ }), -/***/ 74018: +/***/ 23791: /***/ ((module) => { "use strict"; @@ -24005,7 +24005,7 @@ module.exports = formatFn => { /***/ }), -/***/ 63252: +/***/ 32955: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -24017,14 +24017,14 @@ module.exports = formatFn => { * Both the construction method and set of exposed * formats. */ -const format = exports.format = __nccwpck_require__(74018); +const format = exports.format = __nccwpck_require__(23791); /* * @api public * @method {function} levels * Registers the specified levels with logform. */ -exports.levels = __nccwpck_require__(21987); +exports.levels = __nccwpck_require__(53180); /* * @api private @@ -24044,36 +24044,36 @@ function exposeFormat(name, requireFormat) { // // Setup all transports as lazy-loaded getters. // -exposeFormat('align', function () { return __nccwpck_require__(67275); }); -exposeFormat('errors', function () { return __nccwpck_require__(53950); }); -exposeFormat('cli', function () { return __nccwpck_require__(55069); }); -exposeFormat('combine', function () { return __nccwpck_require__(5543); }); -exposeFormat('colorize', function () { return __nccwpck_require__(13027); }); -exposeFormat('json', function () { return __nccwpck_require__(6552); }); -exposeFormat('label', function () { return __nccwpck_require__(56635); }); -exposeFormat('logstash', function () { return __nccwpck_require__(16796); }); -exposeFormat('metadata', function () { return __nccwpck_require__(70813); }); -exposeFormat('ms', function () { return __nccwpck_require__(7269); }); -exposeFormat('padLevels', function () { return __nccwpck_require__(20742); }); -exposeFormat('prettyPrint', function () { return __nccwpck_require__(45775); }); -exposeFormat('printf', function () { return __nccwpck_require__(88620); }); -exposeFormat('simple', function () { return __nccwpck_require__(94846); }); -exposeFormat('splat', function () { return __nccwpck_require__(52821); }); -exposeFormat('timestamp', function () { return __nccwpck_require__(30999); }); -exposeFormat('uncolorize', function () { return __nccwpck_require__(96244); }); - - -/***/ }), - -/***/ 6552: +exposeFormat('align', function () { return __nccwpck_require__(29748); }); +exposeFormat('errors', function () { return __nccwpck_require__(43791); }); +exposeFormat('cli', function () { return __nccwpck_require__(46811); }); +exposeFormat('combine', function () { return __nccwpck_require__(77315); }); +exposeFormat('colorize', function () { return __nccwpck_require__(73848); }); +exposeFormat('json', function () { return __nccwpck_require__(45669); }); +exposeFormat('label', function () { return __nccwpck_require__(86941); }); +exposeFormat('logstash', function () { return __nccwpck_require__(84772); }); +exposeFormat('metadata', function () { return __nccwpck_require__(69760); }); +exposeFormat('ms', function () { return __nccwpck_require__(24734); }); +exposeFormat('padLevels', function () { return __nccwpck_require__(37033); }); +exposeFormat('prettyPrint', function () { return __nccwpck_require__(16182); }); +exposeFormat('printf', function () { return __nccwpck_require__(31843); }); +exposeFormat('simple', function () { return __nccwpck_require__(75313); }); +exposeFormat('splat', function () { return __nccwpck_require__(67081); }); +exposeFormat('timestamp', function () { return __nccwpck_require__(28381); }); +exposeFormat('uncolorize', function () { return __nccwpck_require__(56420); }); + + +/***/ }), + +/***/ 45669: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const format = __nccwpck_require__(74018); -const { MESSAGE } = __nccwpck_require__(94079); -const stringify = __nccwpck_require__(4046); +const format = __nccwpck_require__(23791); +const { MESSAGE } = __nccwpck_require__(93937); +const stringify = __nccwpck_require__(37560); /* * function replacer (key, value) @@ -24103,13 +24103,13 @@ module.exports = format((info, opts) => { /***/ }), -/***/ 56635: +/***/ 86941: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const format = __nccwpck_require__(74018); +const format = __nccwpck_require__(23791); /* * function label (info) @@ -24130,13 +24130,13 @@ module.exports = format((info, opts) => { /***/ }), -/***/ 21987: +/***/ 53180: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const { Colorizer } = __nccwpck_require__(13027); +const { Colorizer } = __nccwpck_require__(73848); /* * Simple method to register colors with a simpler require @@ -24150,15 +24150,15 @@ module.exports = config => { /***/ }), -/***/ 16796: +/***/ 84772: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const format = __nccwpck_require__(74018); -const { MESSAGE } = __nccwpck_require__(94079); -const jsonStringify = __nccwpck_require__(4046); +const format = __nccwpck_require__(23791); +const { MESSAGE } = __nccwpck_require__(93937); +const jsonStringify = __nccwpck_require__(37560); /* * function logstash (info) @@ -24187,13 +24187,13 @@ module.exports = format(info => { /***/ }), -/***/ 70813: +/***/ 69760: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const format = __nccwpck_require__(74018); +const format = __nccwpck_require__(23791); function fillExcept(info, fillExceptKeys, metadataKey) { const savedKeys = fillExceptKeys.reduce((acc, key) => { @@ -24256,14 +24256,14 @@ module.exports = format((info, opts = {}) => { /***/ }), -/***/ 7269: +/***/ 24734: /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { "use strict"; -const format = __nccwpck_require__(74018); -const ms = __nccwpck_require__(83730); +const format = __nccwpck_require__(23791); +const ms = __nccwpck_require__(80900); /* * function ms (info) @@ -24282,14 +24282,14 @@ module.exports = format(info => { /***/ }), -/***/ 20742: +/***/ 37033: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; /* eslint no-unused-vars: 0 */ -const { configs, LEVEL, MESSAGE } = __nccwpck_require__(94079); +const { configs, LEVEL, MESSAGE } = __nccwpck_require__(93937); class Padder { constructor(opts = { levels: configs.npm.levels }) { @@ -24373,15 +24373,15 @@ module.exports.Padder /***/ }), -/***/ 45775: +/***/ 16182: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; const inspect = (__nccwpck_require__(73837).inspect); -const format = __nccwpck_require__(74018); -const { LEVEL, MESSAGE, SPLAT } = __nccwpck_require__(94079); +const format = __nccwpck_require__(23791); +const { LEVEL, MESSAGE, SPLAT } = __nccwpck_require__(93937); /* * function prettyPrint (info) @@ -24410,13 +24410,13 @@ module.exports = format((info, opts = {}) => { /***/ }), -/***/ 88620: +/***/ 31843: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const { MESSAGE } = __nccwpck_require__(94079); +const { MESSAGE } = __nccwpck_require__(93937); class Printf { constructor(templateFn) { @@ -24444,16 +24444,16 @@ module.exports.Printf /***/ }), -/***/ 94846: +/***/ 75313: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; /* eslint no-undefined: 0 */ -const format = __nccwpck_require__(74018); -const { MESSAGE } = __nccwpck_require__(94079); -const jsonStringify = __nccwpck_require__(4046); +const format = __nccwpck_require__(23791); +const { MESSAGE } = __nccwpck_require__(93937); +const jsonStringify = __nccwpck_require__(37560); /* * function simple (info) @@ -24485,14 +24485,14 @@ module.exports = format(info => { /***/ }), -/***/ 52821: +/***/ 67081: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; const util = __nccwpck_require__(73837); -const { SPLAT } = __nccwpck_require__(94079); +const { SPLAT } = __nccwpck_require__(93937); /** * Captures the number of format (i.e. %s strings) in a given string. @@ -24625,14 +24625,14 @@ module.exports = opts => new Splatter(opts); /***/ }), -/***/ 30999: +/***/ 28381: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const fecha = __nccwpck_require__(8054); -const format = __nccwpck_require__(74018); +const fecha = __nccwpck_require__(74513); +const format = __nccwpck_require__(23791); /* * function timestamp (info) @@ -24663,15 +24663,15 @@ module.exports = format((info, opts = {}) => { /***/ }), -/***/ 96244: +/***/ 56420: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const colors = __nccwpck_require__(3319); -const format = __nccwpck_require__(74018); -const { MESSAGE } = __nccwpck_require__(94079); +const colors = __nccwpck_require__(59256); +const format = __nccwpck_require__(23791); +const { MESSAGE } = __nccwpck_require__(93937); /* * function uncolorize (info) @@ -24698,7 +24698,7 @@ module.exports = format((info, opts) => { /***/ }), -/***/ 80477: +/***/ 47426: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { /*! @@ -24717,7 +24717,7 @@ module.exports = __nccwpck_require__(53765) /***/ }), -/***/ 42720: +/***/ 43583: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -24735,7 +24735,7 @@ module.exports = __nccwpck_require__(53765) * @private */ -var db = __nccwpck_require__(80477) +var db = __nccwpck_require__(47426) var extname = (__nccwpck_require__(71017).extname) /** @@ -24913,7 +24913,7 @@ function populateMaps (extensions, types) { /***/ }), -/***/ 83730: +/***/ 80900: /***/ ((module) => { /** @@ -25082,7 +25082,7 @@ function plural(ms, msAbs, n, name) { /***/ }), -/***/ 70344: +/***/ 98272: /***/ (function(module) { (function (global, factory) { @@ -25860,7 +25860,7 @@ function plural(ms, msAbs, n, name) { /***/ }), -/***/ 22810: +/***/ 97760: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { /*! node-domexception. MIT License. Jimmy Wärting */ @@ -25883,7 +25883,7 @@ module.exports = globalThis.DOMException /***/ }), -/***/ 46326: +/***/ 80467: /***/ ((module, exports, __nccwpck_require__) => { "use strict"; @@ -25896,7 +25896,7 @@ function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'defau var Stream = _interopDefault(__nccwpck_require__(12781)); var http = _interopDefault(__nccwpck_require__(13685)); var Url = _interopDefault(__nccwpck_require__(57310)); -var whatwgUrl = _interopDefault(__nccwpck_require__(40750)); +var whatwgUrl = _interopDefault(__nccwpck_require__(28665)); var https = _interopDefault(__nccwpck_require__(95687)); var zlib = _interopDefault(__nccwpck_require__(59796)); @@ -26049,7 +26049,7 @@ FetchError.prototype.name = 'FetchError'; let convert; try { - convert = (__nccwpck_require__(32209).convert); + convert = (__nccwpck_require__(22877).convert); } catch (e) {} const INTERNALS = Symbol('Body internals'); @@ -27678,7 +27678,7 @@ exports.AbortError = AbortError; /***/ }), -/***/ 3957: +/***/ 29241: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -27688,7 +27688,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.generate = exports.compile = void 0; -var boolbase_1 = __importDefault(__nccwpck_require__(73599)); +var boolbase_1 = __importDefault(__nccwpck_require__(44159)); /** * Returns a function that checks if an elements index matches the given rule * highly optimized to return the fastest solution. @@ -27806,16 +27806,16 @@ exports.generate = generate; /***/ }), -/***/ 27159: +/***/ 51260: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.sequence = exports.generate = exports.compile = exports.parse = void 0; -var parse_js_1 = __nccwpck_require__(91760); +var parse_js_1 = __nccwpck_require__(57869); Object.defineProperty(exports, "parse", ({ enumerable: true, get: function () { return parse_js_1.parse; } })); -var compile_js_1 = __nccwpck_require__(3957); +var compile_js_1 = __nccwpck_require__(29241); Object.defineProperty(exports, "compile", ({ enumerable: true, get: function () { return compile_js_1.compile; } })); Object.defineProperty(exports, "generate", ({ enumerable: true, get: function () { return compile_js_1.generate; } })); /** @@ -27883,7 +27883,7 @@ exports.sequence = sequence; /***/ }), -/***/ 91760: +/***/ 57869: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -27967,13 +27967,13 @@ exports.parse = parse; /***/ }), -/***/ 42417: +/***/ 4118: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var name = __nccwpck_require__(84673); +var name = __nccwpck_require__(12743); /** * Wrap callbacks to prevent double execution. @@ -28017,7 +28017,7 @@ module.exports = function one(fn) { /***/ }), -/***/ 83403: +/***/ 31330: /***/ ((module) => { "use strict"; @@ -28040,15 +28040,15 @@ module.exports = (promise, onFinally) => { /***/ }), -/***/ 518: +/***/ 28983: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); -const EventEmitter = __nccwpck_require__(81067); -const p_timeout_1 = __nccwpck_require__(69512); -const priority_queue_1 = __nccwpck_require__(61748); +const EventEmitter = __nccwpck_require__(11848); +const p_timeout_1 = __nccwpck_require__(86424); +const priority_queue_1 = __nccwpck_require__(8492); // eslint-disable-next-line @typescript-eslint/no-empty-function const empty = () => { }; const timeoutError = new p_timeout_1.TimeoutError(); @@ -28327,7 +28327,7 @@ exports["default"] = PQueue; /***/ }), -/***/ 84254: +/***/ 62291: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -28356,13 +28356,13 @@ exports["default"] = lowerBound; /***/ }), -/***/ 61748: +/***/ 8492: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); -const lower_bound_1 = __nccwpck_require__(84254); +const lower_bound_1 = __nccwpck_require__(62291); class PriorityQueue { constructor() { this._queue = []; @@ -28396,12 +28396,12 @@ exports["default"] = PriorityQueue; /***/ }), -/***/ 21841: +/***/ 82548: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const retry = __nccwpck_require__(92757); +const retry = __nccwpck_require__(71604); const networkErrorMsgs = [ 'Failed to fetch', // Chrome @@ -28489,13 +28489,13 @@ module.exports.AbortError = AbortError; /***/ }), -/***/ 69512: +/***/ 86424: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const pFinally = __nccwpck_require__(83403); +const pFinally = __nccwpck_require__(31330); class TimeoutError extends Error { constructor(message) { @@ -28554,7 +28554,7 @@ module.exports.TimeoutError = TimeoutError; /***/ }), -/***/ 14404: +/***/ 63329: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -28670,7 +28670,7 @@ exports.getProxyForUrl = getProxyForUrl; /***/ }), -/***/ 81460: +/***/ 67214: /***/ ((module) => { "use strict"; @@ -28794,7 +28794,7 @@ module.exports.q = codes; /***/ }), -/***/ 35809: +/***/ 41359: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -28835,9 +28835,9 @@ var objectKeys = Object.keys || function (obj) { /**/ module.exports = Duplex; -var Readable = __nccwpck_require__(43928); -var Writable = __nccwpck_require__(8246); -__nccwpck_require__(9581)(Duplex, Readable); +var Readable = __nccwpck_require__(51433); +var Writable = __nccwpck_require__(32094); +__nccwpck_require__(44124)(Duplex, Readable); { // Allow the keys array to be GC'ed. var keys = objectKeys(Writable.prototype); @@ -28927,7 +28927,7 @@ Object.defineProperty(Duplex.prototype, 'destroyed', { /***/ }), -/***/ 73553: +/***/ 81542: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -28959,8 +28959,8 @@ Object.defineProperty(Duplex.prototype, 'destroyed', { module.exports = PassThrough; -var Transform = __nccwpck_require__(43372); -__nccwpck_require__(9581)(PassThrough, Transform); +var Transform = __nccwpck_require__(34415); +__nccwpck_require__(44124)(PassThrough, Transform); function PassThrough(options) { if (!(this instanceof PassThrough)) return new PassThrough(options); Transform.call(this, options); @@ -28971,7 +28971,7 @@ PassThrough.prototype._transform = function (chunk, encoding, cb) { /***/ }), -/***/ 43928: +/***/ 51433: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -29014,7 +29014,7 @@ var EElistenerCount = function EElistenerCount(emitter, type) { /**/ /**/ -var Stream = __nccwpck_require__(20507); +var Stream = __nccwpck_require__(62387); /**/ var Buffer = (__nccwpck_require__(14300).Buffer); @@ -29036,11 +29036,11 @@ if (debugUtil && debugUtil.debuglog) { } /**/ -var BufferList = __nccwpck_require__(129); -var destroyImpl = __nccwpck_require__(28901); -var _require = __nccwpck_require__(7390), +var BufferList = __nccwpck_require__(52746); +var destroyImpl = __nccwpck_require__(97049); +var _require = __nccwpck_require__(39948), getHighWaterMark = _require.getHighWaterMark; -var _require$codes = (__nccwpck_require__(81460)/* .codes */ .q), +var _require$codes = (__nccwpck_require__(67214)/* .codes */ .q), ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE, ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF, ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, @@ -29050,7 +29050,7 @@ var _require$codes = (__nccwpck_require__(81460)/* .codes */ .q), var StringDecoder; var createReadableStreamAsyncIterator; var from; -__nccwpck_require__(9581)(Readable, Stream); +__nccwpck_require__(44124)(Readable, Stream); var errorOrDestroy = destroyImpl.errorOrDestroy; var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume']; function prependListener(emitter, event, fn) { @@ -29065,7 +29065,7 @@ function prependListener(emitter, event, fn) { if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]]; } function ReadableState(options, stream, isDuplex) { - Duplex = Duplex || __nccwpck_require__(35809); + Duplex = Duplex || __nccwpck_require__(41359); options = options || {}; // Duplex streams are both readable and writable, but share @@ -29132,13 +29132,13 @@ function ReadableState(options, stream, isDuplex) { this.decoder = null; this.encoding = null; if (options.encoding) { - if (!StringDecoder) StringDecoder = (__nccwpck_require__(99350)/* .StringDecoder */ .s); + if (!StringDecoder) StringDecoder = (__nccwpck_require__(94841)/* .StringDecoder */ .s); this.decoder = new StringDecoder(options.encoding); this.encoding = options.encoding; } } function Readable(options) { - Duplex = Duplex || __nccwpck_require__(35809); + Duplex = Duplex || __nccwpck_require__(41359); if (!(this instanceof Readable)) return new Readable(options); // Checking for a Stream.Duplex instance is faster here instead of inside @@ -29275,7 +29275,7 @@ Readable.prototype.isPaused = function () { // backwards compatibility. Readable.prototype.setEncoding = function (enc) { - if (!StringDecoder) StringDecoder = (__nccwpck_require__(99350)/* .StringDecoder */ .s); + if (!StringDecoder) StringDecoder = (__nccwpck_require__(94841)/* .StringDecoder */ .s); var decoder = new StringDecoder(enc); this._readableState.decoder = decoder; // If setEncoding(null), decoder.encoding equals utf8 @@ -29894,7 +29894,7 @@ Readable.prototype.wrap = function (stream) { if (typeof Symbol === 'function') { Readable.prototype[Symbol.asyncIterator] = function () { if (createReadableStreamAsyncIterator === undefined) { - createReadableStreamAsyncIterator = __nccwpck_require__(29916); + createReadableStreamAsyncIterator = __nccwpck_require__(43306); } return createReadableStreamAsyncIterator(this); }; @@ -29991,7 +29991,7 @@ function endReadableNT(state, stream) { if (typeof Symbol === 'function') { Readable.from = function (iterable, opts) { if (from === undefined) { - from = __nccwpck_require__(62162); + from = __nccwpck_require__(39082); } return from(Readable, iterable, opts); }; @@ -30005,7 +30005,7 @@ function indexOf(xs, x) { /***/ }), -/***/ 43372: +/***/ 34415: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -30075,13 +30075,13 @@ function indexOf(xs, x) { module.exports = Transform; -var _require$codes = (__nccwpck_require__(81460)/* .codes */ .q), +var _require$codes = (__nccwpck_require__(67214)/* .codes */ .q), ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK, ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING, ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0; -var Duplex = __nccwpck_require__(35809); -__nccwpck_require__(9581)(Transform, Duplex); +var Duplex = __nccwpck_require__(41359); +__nccwpck_require__(44124)(Transform, Duplex); function afterTransform(er, data) { var ts = this._transformState; ts.transforming = false; @@ -30202,7 +30202,7 @@ function done(stream, er, data) { /***/ }), -/***/ 8246: +/***/ 32094: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -30263,12 +30263,12 @@ Writable.WritableState = WritableState; /**/ var internalUtil = { - deprecate: __nccwpck_require__(84150) + deprecate: __nccwpck_require__(65278) }; /**/ /**/ -var Stream = __nccwpck_require__(20507); +var Stream = __nccwpck_require__(62387); /**/ var Buffer = (__nccwpck_require__(14300).Buffer); @@ -30279,10 +30279,10 @@ function _uint8ArrayToBuffer(chunk) { function _isUint8Array(obj) { return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; } -var destroyImpl = __nccwpck_require__(28901); -var _require = __nccwpck_require__(7390), +var destroyImpl = __nccwpck_require__(97049); +var _require = __nccwpck_require__(39948), getHighWaterMark = _require.getHighWaterMark; -var _require$codes = (__nccwpck_require__(81460)/* .codes */ .q), +var _require$codes = (__nccwpck_require__(67214)/* .codes */ .q), ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE, ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK, @@ -30292,10 +30292,10 @@ var _require$codes = (__nccwpck_require__(81460)/* .codes */ .q), ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END, ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING; var errorOrDestroy = destroyImpl.errorOrDestroy; -__nccwpck_require__(9581)(Writable, Stream); +__nccwpck_require__(44124)(Writable, Stream); function nop() {} function WritableState(options, stream, isDuplex) { - Duplex = Duplex || __nccwpck_require__(35809); + Duplex = Duplex || __nccwpck_require__(41359); options = options || {}; // Duplex streams are both readable and writable, but share @@ -30437,7 +30437,7 @@ if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.protot }; } function Writable(options) { - Duplex = Duplex || __nccwpck_require__(35809); + Duplex = Duplex || __nccwpck_require__(41359); // Writable ctor is applied to Duplexes, too. // `realHasInstance` is necessary because using plain `instanceof` @@ -30850,7 +30850,7 @@ Writable.prototype._destroy = function (err, cb) { /***/ }), -/***/ 29916: +/***/ 43306: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -30860,7 +30860,7 @@ var _Object$setPrototypeO; function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } -var finished = __nccwpck_require__(80038); +var finished = __nccwpck_require__(76080); var kLastResolve = Symbol('lastResolve'); var kLastReject = Symbol('lastReject'); var kError = Symbol('error'); @@ -31037,7 +31037,7 @@ module.exports = createReadableStreamAsyncIterator; /***/ }), -/***/ 129: +/***/ 52746: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -31227,7 +31227,7 @@ module.exports = /*#__PURE__*/function () { /***/ }), -/***/ 28901: +/***/ 97049: /***/ ((module) => { "use strict"; @@ -31330,7 +31330,7 @@ module.exports = { /***/ }), -/***/ 80038: +/***/ 76080: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -31339,7 +31339,7 @@ module.exports = { -var ERR_STREAM_PREMATURE_CLOSE = (__nccwpck_require__(81460)/* .codes.ERR_STREAM_PREMATURE_CLOSE */ .q.ERR_STREAM_PREMATURE_CLOSE); +var ERR_STREAM_PREMATURE_CLOSE = (__nccwpck_require__(67214)/* .codes.ERR_STREAM_PREMATURE_CLOSE */ .q.ERR_STREAM_PREMATURE_CLOSE); function once(callback) { var called = false; return function () { @@ -31423,7 +31423,7 @@ module.exports = eos; /***/ }), -/***/ 62162: +/***/ 39082: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -31436,7 +31436,7 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } -var ERR_INVALID_ARG_TYPE = (__nccwpck_require__(81460)/* .codes.ERR_INVALID_ARG_TYPE */ .q.ERR_INVALID_ARG_TYPE); +var ERR_INVALID_ARG_TYPE = (__nccwpck_require__(67214)/* .codes.ERR_INVALID_ARG_TYPE */ .q.ERR_INVALID_ARG_TYPE); function from(Readable, iterable, opts) { var iterator; if (iterable && typeof iterable.next === 'function') { @@ -31483,7 +31483,7 @@ module.exports = from; /***/ }), -/***/ 62797: +/***/ 76989: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -31501,7 +31501,7 @@ function once(callback) { callback.apply(void 0, arguments); }; } -var _require$codes = (__nccwpck_require__(81460)/* .codes */ .q), +var _require$codes = (__nccwpck_require__(67214)/* .codes */ .q), ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS, ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED; function noop(err) { @@ -31517,7 +31517,7 @@ function destroyer(stream, reading, writing, callback) { stream.on('close', function () { closed = true; }); - if (eos === undefined) eos = __nccwpck_require__(80038); + if (eos === undefined) eos = __nccwpck_require__(76080); eos(stream, { readable: reading, writable: writing @@ -31576,13 +31576,13 @@ module.exports = pipeline; /***/ }), -/***/ 7390: +/***/ 39948: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var ERR_INVALID_OPT_VALUE = (__nccwpck_require__(81460)/* .codes.ERR_INVALID_OPT_VALUE */ .q.ERR_INVALID_OPT_VALUE); +var ERR_INVALID_OPT_VALUE = (__nccwpck_require__(67214)/* .codes.ERR_INVALID_OPT_VALUE */ .q.ERR_INVALID_OPT_VALUE); function highWaterMarkFrom(options, isDuplex, duplexKey) { return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null; } @@ -31605,7 +31605,7 @@ module.exports = { /***/ }), -/***/ 20507: +/***/ 62387: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { module.exports = __nccwpck_require__(12781); @@ -31613,7 +31613,7 @@ module.exports = __nccwpck_require__(12781); /***/ }), -/***/ 67278: +/***/ 51642: /***/ ((module, exports, __nccwpck_require__) => { var Stream = __nccwpck_require__(12781); @@ -31622,31 +31622,31 @@ if (process.env.READABLE_STREAM === 'disable' && Stream) { Object.assign(module.exports, Stream); module.exports.Stream = Stream; } else { - exports = module.exports = __nccwpck_require__(43928); + exports = module.exports = __nccwpck_require__(51433); exports.Stream = Stream || exports; exports.Readable = exports; - exports.Writable = __nccwpck_require__(8246); - exports.Duplex = __nccwpck_require__(35809); - exports.Transform = __nccwpck_require__(43372); - exports.PassThrough = __nccwpck_require__(73553); - exports.finished = __nccwpck_require__(80038); - exports.pipeline = __nccwpck_require__(62797); + exports.Writable = __nccwpck_require__(32094); + exports.Duplex = __nccwpck_require__(41359); + exports.Transform = __nccwpck_require__(34415); + exports.PassThrough = __nccwpck_require__(81542); + exports.finished = __nccwpck_require__(76080); + exports.pipeline = __nccwpck_require__(76989); } /***/ }), -/***/ 92757: +/***/ 71604: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = __nccwpck_require__(32663); +module.exports = __nccwpck_require__(56244); /***/ }), -/***/ 32663: +/***/ 56244: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -var RetryOperation = __nccwpck_require__(76408); +var RetryOperation = __nccwpck_require__(45369); exports.operation = function(options) { var timeouts = exports.timeouts(options); @@ -31750,7 +31750,7 @@ exports.wrap = function(obj, options, methods) { /***/ }), -/***/ 76408: +/***/ 45369: /***/ ((module) => { function RetryOperation(timeouts, options) { @@ -31919,7 +31919,7 @@ RetryOperation.prototype.mainError = function() { /***/ }), -/***/ 83925: +/***/ 21867: /***/ ((module, exports, __nccwpck_require__) => { /*! safe-buffer. MIT License. Feross Aboukhadijeh */ @@ -31991,7 +31991,7 @@ SafeBuffer.allocUnsafeSlow = function (size) { /***/ }), -/***/ 4046: +/***/ 37560: /***/ ((module, exports) => { "use strict"; @@ -32611,13 +32611,13 @@ function configure (options) { /***/ }), -/***/ 41539: +/***/ 78679: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var isArrayish = __nccwpck_require__(82434); +var isArrayish = __nccwpck_require__(7604); var concat = Array.prototype.concat; var slice = Array.prototype.slice; @@ -32648,7 +32648,7 @@ swizzle.wrap = function (fn) { /***/ }), -/***/ 42396: +/***/ 55315: /***/ ((__unused_webpack_module, exports) => { exports.get = function(belowFn) { @@ -32791,7 +32791,7 @@ exports._createParsedCallSite = function(properties) { /***/ }), -/***/ 99728: +/***/ 13259: /***/ (function(module) { void function(global) { @@ -32890,7 +32890,7 @@ void function(global) { /***/ }), -/***/ 99350: +/***/ 94841: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -32919,7 +32919,7 @@ void function(global) { /**/ -var Buffer = (__nccwpck_require__(83925).Buffer); +var Buffer = (__nccwpck_require__(21867).Buffer); /**/ var isEncoding = Buffer.isEncoding || function (encoding) { @@ -33193,7 +33193,7 @@ function simpleEnd(buf) { /***/ }), -/***/ 52189: +/***/ 67014: /***/ ((module) => { "use strict"; @@ -33225,7 +33225,7 @@ module.exports = function hex(str) { /***/ }), -/***/ 28394: +/***/ 84256: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -33426,7 +33426,7 @@ module.exports.PROCESSING_OPTIONS = PROCESSING_OPTIONS; /***/ }), -/***/ 54265: +/***/ 61416: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -33476,7 +33476,7 @@ exports.colors = { /***/ }), -/***/ 89313: +/***/ 67113: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -33494,7 +33494,7 @@ exports.colors = { * @type {Object} */ Object.defineProperty(exports, "cli", ({ - value: __nccwpck_require__(54265) + value: __nccwpck_require__(61416) })); /** @@ -33502,7 +33502,7 @@ Object.defineProperty(exports, "cli", ({ * @type {Object} */ Object.defineProperty(exports, "npm", ({ - value: __nccwpck_require__(35269) + value: __nccwpck_require__(43568) })); /** @@ -33510,13 +33510,13 @@ Object.defineProperty(exports, "npm", ({ * @type {Object} */ Object.defineProperty(exports, "syslog", ({ - value: __nccwpck_require__(16393) + value: __nccwpck_require__(96990) })); /***/ }), -/***/ 35269: +/***/ 43568: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -33560,7 +33560,7 @@ exports.colors = { /***/ }), -/***/ 16393: +/***/ 96990: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -33606,7 +33606,7 @@ exports.colors = { /***/ }), -/***/ 94079: +/***/ 93937: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -33654,21 +33654,21 @@ Object.defineProperty(exports, "SPLAT", ({ * @type {Object} */ Object.defineProperty(exports, "configs", ({ - value: __nccwpck_require__(89313) + value: __nccwpck_require__(67113) })); /***/ }), -/***/ 60586: +/***/ 74294: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = __nccwpck_require__(38526); +module.exports = __nccwpck_require__(54219); /***/ }), -/***/ 38526: +/***/ 54219: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -33940,32 +33940,32 @@ exports.debug = debug; // for test /***/ }), -/***/ 31888: +/***/ 41773: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const Client = __nccwpck_require__(551) -const Dispatcher = __nccwpck_require__(52905) -const errors = __nccwpck_require__(32692) -const Pool = __nccwpck_require__(23090) -const BalancedPool = __nccwpck_require__(96092) -const Agent = __nccwpck_require__(67401) -const util = __nccwpck_require__(13519) +const Client = __nccwpck_require__(33598) +const Dispatcher = __nccwpck_require__(60412) +const errors = __nccwpck_require__(48045) +const Pool = __nccwpck_require__(4634) +const BalancedPool = __nccwpck_require__(37931) +const Agent = __nccwpck_require__(7890) +const util = __nccwpck_require__(83983) const { InvalidArgumentError } = errors -const api = __nccwpck_require__(72790) -const buildConnector = __nccwpck_require__(87595) -const MockClient = __nccwpck_require__(28404) -const MockAgent = __nccwpck_require__(23388) -const MockPool = __nccwpck_require__(55551) -const mockErrors = __nccwpck_require__(33700) -const ProxyAgent = __nccwpck_require__(29952) -const RetryHandler = __nccwpck_require__(49432) -const { getGlobalDispatcher, setGlobalDispatcher } = __nccwpck_require__(26881) -const DecoratorHandler = __nccwpck_require__(53305) -const RedirectHandler = __nccwpck_require__(90152) -const createRedirectInterceptor = __nccwpck_require__(68685) +const api = __nccwpck_require__(44059) +const buildConnector = __nccwpck_require__(82067) +const MockClient = __nccwpck_require__(58687) +const MockAgent = __nccwpck_require__(66771) +const MockPool = __nccwpck_require__(26193) +const mockErrors = __nccwpck_require__(50888) +const ProxyAgent = __nccwpck_require__(97858) +const RetryHandler = __nccwpck_require__(82286) +const { getGlobalDispatcher, setGlobalDispatcher } = __nccwpck_require__(21892) +const DecoratorHandler = __nccwpck_require__(46930) +const RedirectHandler = __nccwpck_require__(72860) +const createRedirectInterceptor = __nccwpck_require__(38861) let hasCrypto try { @@ -34048,7 +34048,7 @@ if (util.nodeMajor > 16 || (util.nodeMajor === 16 && util.nodeMinor >= 8)) { let fetchImpl = null module.exports.fetch = async function fetch (resource) { if (!fetchImpl) { - fetchImpl = (__nccwpck_require__(56956).fetch) + fetchImpl = (__nccwpck_require__(74881).fetch) } try { @@ -34061,20 +34061,20 @@ if (util.nodeMajor > 16 || (util.nodeMajor === 16 && util.nodeMinor >= 8)) { throw err } } - module.exports.Headers = __nccwpck_require__(25582).Headers - module.exports.Response = __nccwpck_require__(74457).Response - module.exports.Request = __nccwpck_require__(31848).Request - module.exports.FormData = __nccwpck_require__(32891).FormData - module.exports.File = __nccwpck_require__(851).File - module.exports.FileReader = __nccwpck_require__(96610).FileReader + module.exports.Headers = __nccwpck_require__(10554).Headers + module.exports.Response = __nccwpck_require__(27823).Response + module.exports.Request = __nccwpck_require__(48359).Request + module.exports.FormData = __nccwpck_require__(72015).FormData + module.exports.File = __nccwpck_require__(78511).File + module.exports.FileReader = __nccwpck_require__(1446).FileReader - const { setGlobalOrigin, getGlobalOrigin } = __nccwpck_require__(91470) + const { setGlobalOrigin, getGlobalOrigin } = __nccwpck_require__(71246) module.exports.setGlobalOrigin = setGlobalOrigin module.exports.getGlobalOrigin = getGlobalOrigin - const { CacheStorage } = __nccwpck_require__(89005) - const { kConstruct } = __nccwpck_require__(91627) + const { CacheStorage } = __nccwpck_require__(37907) + const { kConstruct } = __nccwpck_require__(29174) // Cache & CacheStorage are tightly coupled with fetch. Even if it may run // in an older version of Node, it doesn't have any use without fetch. @@ -34082,21 +34082,21 @@ if (util.nodeMajor > 16 || (util.nodeMajor === 16 && util.nodeMinor >= 8)) { } if (util.nodeMajor >= 16) { - const { deleteCookie, getCookies, getSetCookies, setCookie } = __nccwpck_require__(61955) + const { deleteCookie, getCookies, getSetCookies, setCookie } = __nccwpck_require__(41724) module.exports.deleteCookie = deleteCookie module.exports.getCookies = getCookies module.exports.getSetCookies = getSetCookies module.exports.setCookie = setCookie - const { parseMIMEType, serializeAMimeType } = __nccwpck_require__(44194) + const { parseMIMEType, serializeAMimeType } = __nccwpck_require__(685) module.exports.parseMIMEType = parseMIMEType module.exports.serializeAMimeType = serializeAMimeType } if (util.nodeMajor >= 18 && hasCrypto) { - const { WebSocket } = __nccwpck_require__(7791) + const { WebSocket } = __nccwpck_require__(54284) module.exports.WebSocket = WebSocket } @@ -34115,20 +34115,20 @@ module.exports.mockErrors = mockErrors /***/ }), -/***/ 67401: +/***/ 7890: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const { InvalidArgumentError } = __nccwpck_require__(32692) -const { kClients, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = __nccwpck_require__(92176) -const DispatcherBase = __nccwpck_require__(12135) -const Pool = __nccwpck_require__(23090) -const Client = __nccwpck_require__(551) -const util = __nccwpck_require__(13519) -const createRedirectInterceptor = __nccwpck_require__(68685) -const { WeakRef, FinalizationRegistry } = __nccwpck_require__(10391)() +const { InvalidArgumentError } = __nccwpck_require__(48045) +const { kClients, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = __nccwpck_require__(72785) +const DispatcherBase = __nccwpck_require__(74839) +const Pool = __nccwpck_require__(4634) +const Client = __nccwpck_require__(33598) +const util = __nccwpck_require__(83983) +const createRedirectInterceptor = __nccwpck_require__(38861) +const { WeakRef, FinalizationRegistry } = __nccwpck_require__(56436)() const kOnConnect = Symbol('onConnect') const kOnDisconnect = Symbol('onDisconnect') @@ -34271,11 +34271,11 @@ module.exports = Agent /***/ }), -/***/ 23174: +/***/ 7032: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -const { addAbortListener } = __nccwpck_require__(13519) -const { RequestAbortedError } = __nccwpck_require__(32692) +const { addAbortListener } = __nccwpck_require__(83983) +const { RequestAbortedError } = __nccwpck_require__(48045) const kListener = Symbol('kListener') const kSignal = Symbol('kSignal') @@ -34332,16 +34332,16 @@ module.exports = { /***/ }), -/***/ 48371: +/***/ 29744: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; const { AsyncResource } = __nccwpck_require__(50852) -const { InvalidArgumentError, RequestAbortedError, SocketError } = __nccwpck_require__(32692) -const util = __nccwpck_require__(13519) -const { addSignal, removeSignal } = __nccwpck_require__(23174) +const { InvalidArgumentError, RequestAbortedError, SocketError } = __nccwpck_require__(48045) +const util = __nccwpck_require__(83983) +const { addSignal, removeSignal } = __nccwpck_require__(7032) class ConnectHandler extends AsyncResource { constructor (opts, callback) { @@ -34444,7 +34444,7 @@ module.exports = connect /***/ }), -/***/ 56300: +/***/ 28752: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -34459,10 +34459,10 @@ const { InvalidArgumentError, InvalidReturnValueError, RequestAbortedError -} = __nccwpck_require__(32692) -const util = __nccwpck_require__(13519) +} = __nccwpck_require__(48045) +const util = __nccwpck_require__(83983) const { AsyncResource } = __nccwpck_require__(50852) -const { addSignal, removeSignal } = __nccwpck_require__(23174) +const { addSignal, removeSignal } = __nccwpck_require__(7032) const assert = __nccwpck_require__(39491) const kResume = Symbol('resume') @@ -34701,21 +34701,21 @@ module.exports = pipeline /***/ }), -/***/ 63805: +/***/ 55448: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const Readable = __nccwpck_require__(44630) +const Readable = __nccwpck_require__(73858) const { InvalidArgumentError, RequestAbortedError -} = __nccwpck_require__(32692) -const util = __nccwpck_require__(13519) -const { getResolveErrorBodyCallback } = __nccwpck_require__(86698) +} = __nccwpck_require__(48045) +const util = __nccwpck_require__(83983) +const { getResolveErrorBodyCallback } = __nccwpck_require__(77474) const { AsyncResource } = __nccwpck_require__(50852) -const { addSignal, removeSignal } = __nccwpck_require__(23174) +const { addSignal, removeSignal } = __nccwpck_require__(7032) class RequestHandler extends AsyncResource { constructor (opts, callback) { @@ -34889,7 +34889,7 @@ module.exports.RequestHandler = RequestHandler /***/ }), -/***/ 16716: +/***/ 75395: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -34900,11 +34900,11 @@ const { InvalidArgumentError, InvalidReturnValueError, RequestAbortedError -} = __nccwpck_require__(32692) -const util = __nccwpck_require__(13519) -const { getResolveErrorBodyCallback } = __nccwpck_require__(86698) +} = __nccwpck_require__(48045) +const util = __nccwpck_require__(83983) +const { getResolveErrorBodyCallback } = __nccwpck_require__(77474) const { AsyncResource } = __nccwpck_require__(50852) -const { addSignal, removeSignal } = __nccwpck_require__(23174) +const { addSignal, removeSignal } = __nccwpck_require__(7032) class StreamHandler extends AsyncResource { constructor (opts, factory, callback) { @@ -35117,16 +35117,16 @@ module.exports = stream /***/ }), -/***/ 47272: +/***/ 36923: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const { InvalidArgumentError, RequestAbortedError, SocketError } = __nccwpck_require__(32692) +const { InvalidArgumentError, RequestAbortedError, SocketError } = __nccwpck_require__(48045) const { AsyncResource } = __nccwpck_require__(50852) -const util = __nccwpck_require__(13519) -const { addSignal, removeSignal } = __nccwpck_require__(23174) +const util = __nccwpck_require__(83983) +const { addSignal, removeSignal } = __nccwpck_require__(7032) const assert = __nccwpck_require__(39491) class UpgradeHandler extends AsyncResource { @@ -35230,22 +35230,22 @@ module.exports = upgrade /***/ }), -/***/ 72790: +/***/ 44059: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -module.exports.request = __nccwpck_require__(63805) -module.exports.stream = __nccwpck_require__(16716) -module.exports.pipeline = __nccwpck_require__(56300) -module.exports.upgrade = __nccwpck_require__(47272) -module.exports.connect = __nccwpck_require__(48371) +module.exports.request = __nccwpck_require__(55448) +module.exports.stream = __nccwpck_require__(75395) +module.exports.pipeline = __nccwpck_require__(28752) +module.exports.upgrade = __nccwpck_require__(36923) +module.exports.connect = __nccwpck_require__(29744) /***/ }), -/***/ 44630: +/***/ 73858: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -35255,9 +35255,9 @@ module.exports.connect = __nccwpck_require__(48371) const assert = __nccwpck_require__(39491) const { Readable } = __nccwpck_require__(12781) -const { RequestAbortedError, NotSupportedError, InvalidArgumentError } = __nccwpck_require__(32692) -const util = __nccwpck_require__(13519) -const { ReadableStreamFrom, toUSVString } = __nccwpck_require__(13519) +const { RequestAbortedError, NotSupportedError, InvalidArgumentError } = __nccwpck_require__(48045) +const util = __nccwpck_require__(83983) +const { ReadableStreamFrom, toUSVString } = __nccwpck_require__(83983) let Blob @@ -35575,14 +35575,14 @@ function consumeFinish (consume, err) { /***/ }), -/***/ 86698: +/***/ 77474: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { const assert = __nccwpck_require__(39491) const { ResponseStatusCodeError -} = __nccwpck_require__(32692) -const { toUSVString } = __nccwpck_require__(13519) +} = __nccwpck_require__(48045) +const { toUSVString } = __nccwpck_require__(83983) async function getResolveErrorBodyCallback ({ callback, body, contentType, statusCode, statusMessage, headers }) { assert(body) @@ -35628,7 +35628,7 @@ module.exports = { getResolveErrorBodyCallback } /***/ }), -/***/ 96092: +/***/ 37931: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -35637,7 +35637,7 @@ module.exports = { getResolveErrorBodyCallback } const { BalancedPoolMissingUpstreamError, InvalidArgumentError -} = __nccwpck_require__(32692) +} = __nccwpck_require__(48045) const { PoolBase, kClients, @@ -35645,10 +35645,10 @@ const { kAddClient, kRemoveClient, kGetDispatcher -} = __nccwpck_require__(49624) -const Pool = __nccwpck_require__(23090) -const { kUrl, kInterceptors } = __nccwpck_require__(92176) -const { parseOrigin } = __nccwpck_require__(13519) +} = __nccwpck_require__(73198) +const Pool = __nccwpck_require__(4634) +const { kUrl, kInterceptors } = __nccwpck_require__(72785) +const { parseOrigin } = __nccwpck_require__(83983) const kFactory = Symbol('factory') const kOptions = Symbol('options') @@ -35826,24 +35826,24 @@ module.exports = BalancedPool /***/ }), -/***/ 2053: +/***/ 66101: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const { kConstruct } = __nccwpck_require__(91627) -const { urlEquals, fieldValues: getFieldValues } = __nccwpck_require__(59199) -const { kEnumerableProperty, isDisturbed } = __nccwpck_require__(13519) -const { kHeadersList } = __nccwpck_require__(92176) -const { webidl } = __nccwpck_require__(72146) -const { Response, cloneResponse } = __nccwpck_require__(74457) -const { Request } = __nccwpck_require__(31848) -const { kState, kHeaders, kGuard, kRealm } = __nccwpck_require__(54693) -const { fetching } = __nccwpck_require__(56956) -const { urlIsHttpHttpsScheme, createDeferredPromise, readAllBytes } = __nccwpck_require__(70068) +const { kConstruct } = __nccwpck_require__(29174) +const { urlEquals, fieldValues: getFieldValues } = __nccwpck_require__(82396) +const { kEnumerableProperty, isDisturbed } = __nccwpck_require__(83983) +const { kHeadersList } = __nccwpck_require__(72785) +const { webidl } = __nccwpck_require__(21744) +const { Response, cloneResponse } = __nccwpck_require__(27823) +const { Request } = __nccwpck_require__(48359) +const { kState, kHeaders, kGuard, kRealm } = __nccwpck_require__(15861) +const { fetching } = __nccwpck_require__(74881) +const { urlIsHttpHttpsScheme, createDeferredPromise, readAllBytes } = __nccwpck_require__(52538) const assert = __nccwpck_require__(39491) -const { getGlobalDispatcher } = __nccwpck_require__(26881) +const { getGlobalDispatcher } = __nccwpck_require__(21892) /** * @see https://w3c.github.io/ServiceWorker/#dfn-cache-batch-operation @@ -36672,16 +36672,16 @@ module.exports = { /***/ }), -/***/ 89005: +/***/ 37907: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const { kConstruct } = __nccwpck_require__(91627) -const { Cache } = __nccwpck_require__(2053) -const { webidl } = __nccwpck_require__(72146) -const { kEnumerableProperty } = __nccwpck_require__(13519) +const { kConstruct } = __nccwpck_require__(29174) +const { Cache } = __nccwpck_require__(66101) +const { webidl } = __nccwpck_require__(21744) +const { kEnumerableProperty } = __nccwpck_require__(83983) class CacheStorage { /** @@ -36824,28 +36824,28 @@ module.exports = { /***/ }), -/***/ 91627: +/***/ 29174: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = { - kConstruct: (__nccwpck_require__(92176).kConstruct) + kConstruct: (__nccwpck_require__(72785).kConstruct) } /***/ }), -/***/ 59199: +/***/ 82396: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; const assert = __nccwpck_require__(39491) -const { URLSerializer } = __nccwpck_require__(44194) -const { isValidHeaderName } = __nccwpck_require__(70068) +const { URLSerializer } = __nccwpck_require__(685) +const { isValidHeaderName } = __nccwpck_require__(52538) /** * @see https://url.spec.whatwg.org/#concept-url-equals @@ -36894,7 +36894,7 @@ module.exports = { /***/ }), -/***/ 551: +/***/ 33598: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -36908,10 +36908,10 @@ const assert = __nccwpck_require__(39491) const net = __nccwpck_require__(41808) const http = __nccwpck_require__(13685) const { pipeline } = __nccwpck_require__(12781) -const util = __nccwpck_require__(13519) -const timers = __nccwpck_require__(24942) -const Request = __nccwpck_require__(85443) -const DispatcherBase = __nccwpck_require__(12135) +const util = __nccwpck_require__(83983) +const timers = __nccwpck_require__(29459) +const Request = __nccwpck_require__(62905) +const DispatcherBase = __nccwpck_require__(74839) const { RequestContentLengthMismatchError, ResponseContentLengthMismatchError, @@ -36925,8 +36925,8 @@ const { HTTPParserError, ResponseExceededMaxSizeError, ClientDestroyedError -} = __nccwpck_require__(32692) -const buildConnector = __nccwpck_require__(87595) +} = __nccwpck_require__(48045) +const buildConnector = __nccwpck_require__(82067) const { kUrl, kReset, @@ -36978,7 +36978,7 @@ const { kHTTP2BuildRequest, kHTTP2CopyHeaders, kHTTP1BuildRequest -} = __nccwpck_require__(92176) +} = __nccwpck_require__(72785) /** @type {import('http2')} */ let http2 @@ -37384,16 +37384,16 @@ function onHTTP2GoAway (code) { resume(client) } -const constants = __nccwpck_require__(38362) -const createRedirectInterceptor = __nccwpck_require__(68685) +const constants = __nccwpck_require__(30953) +const createRedirectInterceptor = __nccwpck_require__(38861) const EMPTY_BUF = Buffer.alloc(0) async function lazyllhttp () { - const llhttpWasmData = process.env.JEST_WORKER_ID ? __nccwpck_require__(93979) : undefined + const llhttpWasmData = process.env.JEST_WORKER_ID ? __nccwpck_require__(61145) : undefined let mod try { - mod = await WebAssembly.compile(Buffer.from(__nccwpck_require__(47248), 'base64')) + mod = await WebAssembly.compile(Buffer.from(__nccwpck_require__(95627), 'base64')) } catch (e) { /* istanbul ignore next */ @@ -37401,7 +37401,7 @@ async function lazyllhttp () { // being enabled, but the occurring of this other error // * https://github.com/emscripten-core/emscripten/issues/11495 // got me to remove that check to avoid breaking Node 12. - mod = await WebAssembly.compile(Buffer.from(llhttpWasmData || __nccwpck_require__(93979), 'base64')) + mod = await WebAssembly.compile(Buffer.from(llhttpWasmData || __nccwpck_require__(61145), 'base64')) } return await WebAssembly.instantiate(mod, { @@ -39185,7 +39185,7 @@ module.exports = Client /***/ }), -/***/ 10391: +/***/ 56436: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -39193,7 +39193,7 @@ module.exports = Client /* istanbul ignore file: only for Node 12 */ -const { kConnected, kSize } = __nccwpck_require__(92176) +const { kConnected, kSize } = __nccwpck_require__(72785) class CompatWeakRef { constructor (value) { @@ -39241,7 +39241,7 @@ module.exports = function () { /***/ }), -/***/ 65645: +/***/ 20663: /***/ ((module) => { "use strict"; @@ -39261,16 +39261,16 @@ module.exports = { /***/ }), -/***/ 61955: +/***/ 41724: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const { parseSetCookie } = __nccwpck_require__(65788) -const { stringify, getHeadersList } = __nccwpck_require__(75009) -const { webidl } = __nccwpck_require__(72146) -const { Headers } = __nccwpck_require__(25582) +const { parseSetCookie } = __nccwpck_require__(24408) +const { stringify, getHeadersList } = __nccwpck_require__(43121) +const { webidl } = __nccwpck_require__(21744) +const { Headers } = __nccwpck_require__(10554) /** * @typedef {Object} Cookie @@ -39453,15 +39453,15 @@ module.exports = { /***/ }), -/***/ 65788: +/***/ 24408: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const { maxNameValuePairSize, maxAttributeValueSize } = __nccwpck_require__(65645) -const { isCTLExcludingHtab } = __nccwpck_require__(75009) -const { collectASequenceOfCodePointsFast } = __nccwpck_require__(44194) +const { maxNameValuePairSize, maxAttributeValueSize } = __nccwpck_require__(20663) +const { isCTLExcludingHtab } = __nccwpck_require__(43121) +const { collectASequenceOfCodePointsFast } = __nccwpck_require__(685) const assert = __nccwpck_require__(39491) /** @@ -39778,14 +39778,14 @@ module.exports = { /***/ }), -/***/ 75009: +/***/ 43121: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; const assert = __nccwpck_require__(39491) -const { kHeadersList } = __nccwpck_require__(92176) +const { kHeadersList } = __nccwpck_require__(72785) function isCTLExcludingHtab (value) { if (value.length === 0) { @@ -40077,7 +40077,7 @@ module.exports = { /***/ }), -/***/ 87595: +/***/ 82067: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -40085,8 +40085,8 @@ module.exports = { const net = __nccwpck_require__(41808) const assert = __nccwpck_require__(39491) -const util = __nccwpck_require__(13519) -const { InvalidArgumentError, ConnectTimeoutError } = __nccwpck_require__(32692) +const util = __nccwpck_require__(83983) +const { InvalidArgumentError, ConnectTimeoutError } = __nccwpck_require__(48045) let tls // include tls conditionally since it is not always available @@ -40274,7 +40274,7 @@ module.exports = buildConnector /***/ }), -/***/ 33311: +/***/ 14462: /***/ ((module) => { "use strict"; @@ -40400,7 +40400,7 @@ module.exports = { /***/ }), -/***/ 32692: +/***/ 48045: /***/ ((module) => { "use strict"; @@ -40638,7 +40638,7 @@ module.exports = { /***/ }), -/***/ 85443: +/***/ 62905: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -40647,10 +40647,10 @@ module.exports = { const { InvalidArgumentError, NotSupportedError -} = __nccwpck_require__(32692) +} = __nccwpck_require__(48045) const assert = __nccwpck_require__(39491) -const { kHTTP2BuildRequest, kHTTP2CopyHeaders, kHTTP1BuildRequest } = __nccwpck_require__(92176) -const util = __nccwpck_require__(13519) +const { kHTTP2BuildRequest, kHTTP2CopyHeaders, kHTTP1BuildRequest } = __nccwpck_require__(72785) +const util = __nccwpck_require__(83983) // tokenRegExp and headerCharRegex have been lifted from // https://github.com/nodejs/node/blob/main/lib/_http_common.js @@ -40845,7 +40845,7 @@ class Request { } if (!extractBody) { - extractBody = (__nccwpck_require__(85749).extractBody) + extractBody = (__nccwpck_require__(41472).extractBody) } const [bodyStream, contentType] = extractBody(body) @@ -41145,7 +41145,7 @@ module.exports = Request /***/ }), -/***/ 92176: +/***/ 72785: /***/ ((module) => { module.exports = { @@ -41215,22 +41215,22 @@ module.exports = { /***/ }), -/***/ 13519: +/***/ 83983: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; const assert = __nccwpck_require__(39491) -const { kDestroyed, kBodyUsed } = __nccwpck_require__(92176) +const { kDestroyed, kBodyUsed } = __nccwpck_require__(72785) const { IncomingMessage } = __nccwpck_require__(13685) const stream = __nccwpck_require__(12781) const net = __nccwpck_require__(41808) -const { InvalidArgumentError } = __nccwpck_require__(32692) +const { InvalidArgumentError } = __nccwpck_require__(48045) const { Blob } = __nccwpck_require__(14300) const nodeUtil = __nccwpck_require__(73837) const { stringify } = __nccwpck_require__(63477) -const { headerNameLowerCasedRecord } = __nccwpck_require__(33311) +const { headerNameLowerCasedRecord } = __nccwpck_require__(14462) const [nodeMajor, nodeMinor] = process.versions.node.split('.').map(v => Number(v)) @@ -41745,19 +41745,19 @@ module.exports = { /***/ }), -/***/ 12135: +/***/ 74839: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const Dispatcher = __nccwpck_require__(52905) +const Dispatcher = __nccwpck_require__(60412) const { ClientDestroyedError, ClientClosedError, InvalidArgumentError -} = __nccwpck_require__(32692) -const { kDestroy, kClose, kDispatch, kInterceptors } = __nccwpck_require__(92176) +} = __nccwpck_require__(48045) +const { kDestroy, kClose, kDispatch, kInterceptors } = __nccwpck_require__(72785) const kDestroyed = Symbol('destroyed') const kClosed = Symbol('closed') @@ -41945,7 +41945,7 @@ module.exports = DispatcherBase /***/ }), -/***/ 52905: +/***/ 60412: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -41972,14 +41972,14 @@ module.exports = Dispatcher /***/ }), -/***/ 85749: +/***/ 41472: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const Busboy = __nccwpck_require__(61361) -const util = __nccwpck_require__(13519) +const Busboy = __nccwpck_require__(50727) +const util = __nccwpck_require__(83983) const { ReadableStreamFrom, isBlobLike, @@ -41987,18 +41987,18 @@ const { readableStreamClose, createDeferredPromise, fullyReadBody -} = __nccwpck_require__(70068) -const { FormData } = __nccwpck_require__(32891) -const { kState } = __nccwpck_require__(54693) -const { webidl } = __nccwpck_require__(72146) -const { DOMException, structuredClone } = __nccwpck_require__(94731) +} = __nccwpck_require__(52538) +const { FormData } = __nccwpck_require__(72015) +const { kState } = __nccwpck_require__(15861) +const { webidl } = __nccwpck_require__(21744) +const { DOMException, structuredClone } = __nccwpck_require__(41037) const { Blob, File: NativeFile } = __nccwpck_require__(14300) -const { kBodyUsed } = __nccwpck_require__(92176) +const { kBodyUsed } = __nccwpck_require__(72785) const assert = __nccwpck_require__(39491) -const { isErrored } = __nccwpck_require__(13519) +const { isErrored } = __nccwpck_require__(83983) const { isUint8Array, isArrayBuffer } = __nccwpck_require__(29830) -const { File: UndiciFile } = __nccwpck_require__(851) -const { parseMIMEType, serializeAMimeType } = __nccwpck_require__(44194) +const { File: UndiciFile } = __nccwpck_require__(78511) +const { parseMIMEType, serializeAMimeType } = __nccwpck_require__(685) let ReadableStream = globalThis.ReadableStream @@ -42585,7 +42585,7 @@ module.exports = { /***/ }), -/***/ 94731: +/***/ 41037: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -42744,12 +42744,12 @@ module.exports = { /***/ }), -/***/ 44194: +/***/ 685: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { const assert = __nccwpck_require__(39491) const { atob } = __nccwpck_require__(14300) -const { isomorphicDecode } = __nccwpck_require__(70068) +const { isomorphicDecode } = __nccwpck_require__(52538) const encoder = new TextEncoder() @@ -43378,7 +43378,7 @@ module.exports = { /***/ }), -/***/ 851: +/***/ 78511: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -43386,11 +43386,11 @@ module.exports = { const { Blob, File: NativeFile } = __nccwpck_require__(14300) const { types } = __nccwpck_require__(73837) -const { kState } = __nccwpck_require__(54693) -const { isBlobLike } = __nccwpck_require__(70068) -const { webidl } = __nccwpck_require__(72146) -const { parseMIMEType, serializeAMimeType } = __nccwpck_require__(44194) -const { kEnumerableProperty } = __nccwpck_require__(13519) +const { kState } = __nccwpck_require__(15861) +const { isBlobLike } = __nccwpck_require__(52538) +const { webidl } = __nccwpck_require__(21744) +const { parseMIMEType, serializeAMimeType } = __nccwpck_require__(685) +const { kEnumerableProperty } = __nccwpck_require__(83983) const encoder = new TextEncoder() class File extends Blob { @@ -43730,16 +43730,16 @@ module.exports = { File, FileLike, isFileLike } /***/ }), -/***/ 32891: +/***/ 72015: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const { isBlobLike, toUSVString, makeIterator } = __nccwpck_require__(70068) -const { kState } = __nccwpck_require__(54693) -const { File: UndiciFile, FileLike, isFileLike } = __nccwpck_require__(851) -const { webidl } = __nccwpck_require__(72146) +const { isBlobLike, toUSVString, makeIterator } = __nccwpck_require__(52538) +const { kState } = __nccwpck_require__(15861) +const { File: UndiciFile, FileLike, isFileLike } = __nccwpck_require__(78511) +const { webidl } = __nccwpck_require__(21744) const { Blob, File: NativeFile } = __nccwpck_require__(14300) /** @type {globalThis['File']} */ @@ -44003,7 +44003,7 @@ module.exports = { FormData } /***/ }), -/***/ 91470: +/***/ 71246: /***/ ((module) => { "use strict"; @@ -44051,7 +44051,7 @@ module.exports = { /***/ }), -/***/ 25582: +/***/ 10554: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -44059,15 +44059,15 @@ module.exports = { -const { kHeadersList, kConstruct } = __nccwpck_require__(92176) -const { kGuard } = __nccwpck_require__(54693) -const { kEnumerableProperty } = __nccwpck_require__(13519) +const { kHeadersList, kConstruct } = __nccwpck_require__(72785) +const { kGuard } = __nccwpck_require__(15861) +const { kEnumerableProperty } = __nccwpck_require__(83983) const { makeIterator, isValidHeaderName, isValidHeaderValue -} = __nccwpck_require__(70068) -const { webidl } = __nccwpck_require__(72146) +} = __nccwpck_require__(52538) +const { webidl } = __nccwpck_require__(21744) const assert = __nccwpck_require__(39491) const kHeadersMap = Symbol('headers map') @@ -44648,7 +44648,7 @@ module.exports = { /***/ }), -/***/ 56956: +/***/ 74881: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -44662,9 +44662,9 @@ const { makeAppropriateNetworkError, filterResponse, makeResponse -} = __nccwpck_require__(74457) -const { Headers } = __nccwpck_require__(25582) -const { Request, makeRequest } = __nccwpck_require__(31848) +} = __nccwpck_require__(27823) +const { Headers } = __nccwpck_require__(10554) +const { Request, makeRequest } = __nccwpck_require__(48359) const zlib = __nccwpck_require__(59796) const { bytesMatch, @@ -44695,10 +44695,10 @@ const { urlIsLocal, urlIsHttpHttpsScheme, urlHasHttpsScheme -} = __nccwpck_require__(70068) -const { kState, kHeaders, kGuard, kRealm } = __nccwpck_require__(54693) +} = __nccwpck_require__(52538) +const { kState, kHeaders, kGuard, kRealm } = __nccwpck_require__(15861) const assert = __nccwpck_require__(39491) -const { safelyExtractBody } = __nccwpck_require__(85749) +const { safelyExtractBody } = __nccwpck_require__(41472) const { redirectStatusSet, nullBodyStatus, @@ -44706,15 +44706,15 @@ const { requestBodyHeader, subresourceSet, DOMException -} = __nccwpck_require__(94731) -const { kHeadersList } = __nccwpck_require__(92176) +} = __nccwpck_require__(41037) +const { kHeadersList } = __nccwpck_require__(72785) const EE = __nccwpck_require__(82361) const { Readable, pipeline } = __nccwpck_require__(12781) -const { addAbortListener, isErrored, isReadable, nodeMajor, nodeMinor } = __nccwpck_require__(13519) -const { dataURLProcessor, serializeAMimeType } = __nccwpck_require__(44194) +const { addAbortListener, isErrored, isReadable, nodeMajor, nodeMinor } = __nccwpck_require__(83983) +const { dataURLProcessor, serializeAMimeType } = __nccwpck_require__(685) const { TransformStream } = __nccwpck_require__(35356) -const { getGlobalDispatcher } = __nccwpck_require__(26881) -const { webidl } = __nccwpck_require__(72146) +const { getGlobalDispatcher } = __nccwpck_require__(21892) +const { webidl } = __nccwpck_require__(21744) const { STATUS_CODES } = __nccwpck_require__(13685) const GET_OR_HEAD = ['GET', 'HEAD'] @@ -46804,7 +46804,7 @@ module.exports = { /***/ }), -/***/ 31848: +/***/ 48359: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -46812,17 +46812,17 @@ module.exports = { -const { extractBody, mixinBody, cloneBody } = __nccwpck_require__(85749) -const { Headers, fill: fillHeaders, HeadersList } = __nccwpck_require__(25582) -const { FinalizationRegistry } = __nccwpck_require__(10391)() -const util = __nccwpck_require__(13519) +const { extractBody, mixinBody, cloneBody } = __nccwpck_require__(41472) +const { Headers, fill: fillHeaders, HeadersList } = __nccwpck_require__(10554) +const { FinalizationRegistry } = __nccwpck_require__(56436)() +const util = __nccwpck_require__(83983) const { isValidHTTPToken, sameOrigin, normalizeMethod, makePolicyContainer, normalizeMethodRecord -} = __nccwpck_require__(70068) +} = __nccwpck_require__(52538) const { forbiddenMethodsSet, corsSafeListedMethodsSet, @@ -46832,13 +46832,13 @@ const { requestCredentials, requestCache, requestDuplex -} = __nccwpck_require__(94731) +} = __nccwpck_require__(41037) const { kEnumerableProperty } = util -const { kHeaders, kSignal, kState, kGuard, kRealm } = __nccwpck_require__(54693) -const { webidl } = __nccwpck_require__(72146) -const { getGlobalOrigin } = __nccwpck_require__(91470) -const { URLSerializer } = __nccwpck_require__(44194) -const { kHeadersList, kConstruct } = __nccwpck_require__(92176) +const { kHeaders, kSignal, kState, kGuard, kRealm } = __nccwpck_require__(15861) +const { webidl } = __nccwpck_require__(21744) +const { getGlobalOrigin } = __nccwpck_require__(71246) +const { URLSerializer } = __nccwpck_require__(685) +const { kHeadersList, kConstruct } = __nccwpck_require__(72785) const assert = __nccwpck_require__(39491) const { getMaxListeners, setMaxListeners, getEventListeners, defaultMaxListeners } = __nccwpck_require__(82361) @@ -47758,15 +47758,15 @@ module.exports = { Request, makeRequest } /***/ }), -/***/ 74457: +/***/ 27823: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const { Headers, HeadersList, fill } = __nccwpck_require__(25582) -const { extractBody, cloneBody, mixinBody } = __nccwpck_require__(85749) -const util = __nccwpck_require__(13519) +const { Headers, HeadersList, fill } = __nccwpck_require__(10554) +const { extractBody, cloneBody, mixinBody } = __nccwpck_require__(41472) +const util = __nccwpck_require__(83983) const { kEnumerableProperty } = util const { isValidReasonPhrase, @@ -47776,18 +47776,18 @@ const { serializeJavascriptValueToJSONString, isErrorLike, isomorphicEncode -} = __nccwpck_require__(70068) +} = __nccwpck_require__(52538) const { redirectStatusSet, nullBodyStatus, DOMException -} = __nccwpck_require__(94731) -const { kState, kHeaders, kGuard, kRealm } = __nccwpck_require__(54693) -const { webidl } = __nccwpck_require__(72146) -const { FormData } = __nccwpck_require__(32891) -const { getGlobalOrigin } = __nccwpck_require__(91470) -const { URLSerializer } = __nccwpck_require__(44194) -const { kHeadersList, kConstruct } = __nccwpck_require__(92176) +} = __nccwpck_require__(41037) +const { kState, kHeaders, kGuard, kRealm } = __nccwpck_require__(15861) +const { webidl } = __nccwpck_require__(21744) +const { FormData } = __nccwpck_require__(72015) +const { getGlobalOrigin } = __nccwpck_require__(71246) +const { URLSerializer } = __nccwpck_require__(685) +const { kHeadersList, kConstruct } = __nccwpck_require__(72785) const assert = __nccwpck_require__(39491) const { types } = __nccwpck_require__(73837) @@ -48337,7 +48337,7 @@ module.exports = { /***/ }), -/***/ 54693: +/***/ 15861: /***/ ((module) => { "use strict"; @@ -48355,16 +48355,16 @@ module.exports = { /***/ }), -/***/ 70068: +/***/ 52538: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const { redirectStatusSet, referrerPolicySet: referrerPolicyTokens, badPortsSet } = __nccwpck_require__(94731) -const { getGlobalOrigin } = __nccwpck_require__(91470) +const { redirectStatusSet, referrerPolicySet: referrerPolicyTokens, badPortsSet } = __nccwpck_require__(41037) +const { getGlobalOrigin } = __nccwpck_require__(71246) const { performance } = __nccwpck_require__(4074) -const { isBlobLike, toUSVString, ReadableStreamFrom } = __nccwpck_require__(13519) +const { isBlobLike, toUSVString, ReadableStreamFrom } = __nccwpck_require__(83983) const assert = __nccwpck_require__(39491) const { isUint8Array } = __nccwpck_require__(29830) @@ -49507,14 +49507,14 @@ module.exports = { /***/ }), -/***/ 72146: +/***/ 21744: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; const { types } = __nccwpck_require__(73837) -const { hasOwn, toUSVString } = __nccwpck_require__(70068) +const { hasOwn, toUSVString } = __nccwpck_require__(52538) /** @type {import('../../types/webidl').Webidl} */ const webidl = {} @@ -50161,7 +50161,7 @@ module.exports = { /***/ }), -/***/ 97874: +/***/ 84854: /***/ ((module) => { "use strict"; @@ -50459,7 +50459,7 @@ module.exports = { /***/ }), -/***/ 96610: +/***/ 1446: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -50469,16 +50469,16 @@ const { staticPropertyDescriptors, readOperation, fireAProgressEvent -} = __nccwpck_require__(45430) +} = __nccwpck_require__(87530) const { kState, kError, kResult, kEvents, kAborted -} = __nccwpck_require__(39734) -const { webidl } = __nccwpck_require__(72146) -const { kEnumerableProperty } = __nccwpck_require__(13519) +} = __nccwpck_require__(29054) +const { webidl } = __nccwpck_require__(21744) +const { kEnumerableProperty } = __nccwpck_require__(83983) class FileReader extends EventTarget { constructor () { @@ -50811,13 +50811,13 @@ module.exports = { /***/ }), -/***/ 9880: +/***/ 55504: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const { webidl } = __nccwpck_require__(72146) +const { webidl } = __nccwpck_require__(21744) const kState = Symbol('ProgressEvent state') @@ -50897,7 +50897,7 @@ module.exports = { /***/ }), -/***/ 39734: +/***/ 29054: /***/ ((module) => { "use strict"; @@ -50915,7 +50915,7 @@ module.exports = { /***/ }), -/***/ 45430: +/***/ 87530: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -50927,11 +50927,11 @@ const { kResult, kAborted, kLastProgressEventFired -} = __nccwpck_require__(39734) -const { ProgressEvent } = __nccwpck_require__(9880) -const { getEncoding } = __nccwpck_require__(97874) -const { DOMException } = __nccwpck_require__(94731) -const { serializeAMimeType, parseMIMEType } = __nccwpck_require__(44194) +} = __nccwpck_require__(29054) +const { ProgressEvent } = __nccwpck_require__(55504) +const { getEncoding } = __nccwpck_require__(84854) +const { DOMException } = __nccwpck_require__(41037) +const { serializeAMimeType, parseMIMEType } = __nccwpck_require__(685) const { types } = __nccwpck_require__(73837) const { StringDecoder } = __nccwpck_require__(71576) const { btoa } = __nccwpck_require__(14300) @@ -51315,7 +51315,7 @@ module.exports = { /***/ }), -/***/ 26881: +/***/ 21892: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -51324,8 +51324,8 @@ module.exports = { // We include a version number for the Dispatcher API. In case of breaking changes, // this version number must be increased to avoid conflicts. const globalDispatcher = Symbol.for('undici.globalDispatcher.1') -const { InvalidArgumentError } = __nccwpck_require__(32692) -const Agent = __nccwpck_require__(67401) +const { InvalidArgumentError } = __nccwpck_require__(48045) +const Agent = __nccwpck_require__(7890) if (getGlobalDispatcher() === undefined) { setGlobalDispatcher(new Agent()) @@ -51355,7 +51355,7 @@ module.exports = { /***/ }), -/***/ 53305: +/***/ 46930: /***/ ((module) => { "use strict"; @@ -51398,16 +51398,16 @@ module.exports = class DecoratorHandler { /***/ }), -/***/ 90152: +/***/ 72860: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const util = __nccwpck_require__(13519) -const { kBodyUsed } = __nccwpck_require__(92176) +const util = __nccwpck_require__(83983) +const { kBodyUsed } = __nccwpck_require__(72785) const assert = __nccwpck_require__(39491) -const { InvalidArgumentError } = __nccwpck_require__(32692) +const { InvalidArgumentError } = __nccwpck_require__(48045) const EE = __nccwpck_require__(82361) const redirectableStatusCodes = [300, 301, 302, 303, 307, 308] @@ -51627,14 +51627,14 @@ module.exports = RedirectHandler /***/ }), -/***/ 49432: +/***/ 82286: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { const assert = __nccwpck_require__(39491) -const { kRetryHandlerDefaultRetry } = __nccwpck_require__(92176) -const { RequestRetryError } = __nccwpck_require__(32692) -const { isDisturbed, parseHeaders, parseRangeHeader } = __nccwpck_require__(13519) +const { kRetryHandlerDefaultRetry } = __nccwpck_require__(72785) +const { RequestRetryError } = __nccwpck_require__(48045) +const { isDisturbed, parseHeaders, parseRangeHeader } = __nccwpck_require__(83983) function calculateRetryAfterHeader (retryAfter) { const current = Date.now() @@ -51970,13 +51970,13 @@ module.exports = RetryHandler /***/ }), -/***/ 68685: +/***/ 38861: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const RedirectHandler = __nccwpck_require__(90152) +const RedirectHandler = __nccwpck_require__(72860) function createRedirectInterceptor ({ maxRedirections: defaultMaxRedirections }) { return (dispatch) => { @@ -51999,14 +51999,14 @@ module.exports = createRedirectInterceptor /***/ }), -/***/ 38362: +/***/ 30953: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.SPECIAL_HEADERS = exports.HEADER_STATE = exports.MINOR = exports.MAJOR = exports.CONNECTION_TOKEN_CHARS = exports.HEADER_CHARS = exports.TOKEN = exports.STRICT_TOKEN = exports.HEX = exports.URL_CHAR = exports.STRICT_URL_CHAR = exports.USERINFO_CHARS = exports.MARK = exports.ALPHANUM = exports.NUM = exports.HEX_MAP = exports.NUM_MAP = exports.ALPHA = exports.FINISH = exports.H_METHOD_MAP = exports.METHOD_MAP = exports.METHODS_RTSP = exports.METHODS_ICE = exports.METHODS_HTTP = exports.METHODS = exports.LENIENT_FLAGS = exports.FLAGS = exports.TYPE = exports.ERROR = void 0; -const utils_1 = __nccwpck_require__(39704); +const utils_1 = __nccwpck_require__(41891); // C headers var ERROR; (function (ERROR) { @@ -52284,7 +52284,7 @@ exports.SPECIAL_HEADERS = { /***/ }), -/***/ 93979: +/***/ 61145: /***/ ((module) => { module.exports = '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' @@ -52292,7 +52292,7 @@ module.exports = 'AGFzbQEAAAABMAhgAX8Bf2ADf39/AX9gBH9/f38Bf2AAAGADf39/AGABfwBgAn /***/ }), -/***/ 47248: +/***/ 95627: /***/ ((module) => { module.exports = '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' @@ -52300,7 +52300,7 @@ module.exports = 'AGFzbQEAAAABMAhgAX8Bf2ADf39/AX9gBH9/f38Bf2AAAGADf39/AGABfwBgAn /***/ }), -/***/ 39704: +/***/ 41891: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -52322,14 +52322,14 @@ exports.enumToMap = enumToMap; /***/ }), -/***/ 23388: +/***/ 66771: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const { kClients } = __nccwpck_require__(92176) -const Agent = __nccwpck_require__(67401) +const { kClients } = __nccwpck_require__(72785) +const Agent = __nccwpck_require__(7890) const { kAgent, kMockAgentSet, @@ -52340,14 +52340,14 @@ const { kGetNetConnect, kOptions, kFactory -} = __nccwpck_require__(46117) -const MockClient = __nccwpck_require__(28404) -const MockPool = __nccwpck_require__(55551) -const { matchValue, buildMockOptions } = __nccwpck_require__(55083) -const { InvalidArgumentError, UndiciError } = __nccwpck_require__(32692) -const Dispatcher = __nccwpck_require__(52905) -const Pluralizer = __nccwpck_require__(10201) -const PendingInterceptorsFormatter = __nccwpck_require__(54209) +} = __nccwpck_require__(24347) +const MockClient = __nccwpck_require__(58687) +const MockPool = __nccwpck_require__(26193) +const { matchValue, buildMockOptions } = __nccwpck_require__(79323) +const { InvalidArgumentError, UndiciError } = __nccwpck_require__(48045) +const Dispatcher = __nccwpck_require__(60412) +const Pluralizer = __nccwpck_require__(78891) +const PendingInterceptorsFormatter = __nccwpck_require__(86823) class FakeWeakRef { constructor (value) { @@ -52501,15 +52501,15 @@ module.exports = MockAgent /***/ }), -/***/ 28404: +/***/ 58687: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; const { promisify } = __nccwpck_require__(73837) -const Client = __nccwpck_require__(551) -const { buildMockDispatch } = __nccwpck_require__(55083) +const Client = __nccwpck_require__(33598) +const { buildMockDispatch } = __nccwpck_require__(79323) const { kDispatches, kMockAgent, @@ -52518,10 +52518,10 @@ const { kOrigin, kOriginalDispatch, kConnected -} = __nccwpck_require__(46117) -const { MockInterceptor } = __nccwpck_require__(62276) -const Symbols = __nccwpck_require__(92176) -const { InvalidArgumentError } = __nccwpck_require__(32692) +} = __nccwpck_require__(24347) +const { MockInterceptor } = __nccwpck_require__(90410) +const Symbols = __nccwpck_require__(72785) +const { InvalidArgumentError } = __nccwpck_require__(48045) /** * MockClient provides an API that extends the Client to influence the mockDispatches. @@ -52568,13 +52568,13 @@ module.exports = MockClient /***/ }), -/***/ 33700: +/***/ 50888: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const { UndiciError } = __nccwpck_require__(32692) +const { UndiciError } = __nccwpck_require__(48045) class MockNotMatchedError extends UndiciError { constructor (message) { @@ -52593,13 +52593,13 @@ module.exports = { /***/ }), -/***/ 62276: +/***/ 90410: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const { getResponseData, buildKey, addMockDispatch } = __nccwpck_require__(55083) +const { getResponseData, buildKey, addMockDispatch } = __nccwpck_require__(79323) const { kDispatches, kDispatchKey, @@ -52607,9 +52607,9 @@ const { kDefaultTrailers, kContentLength, kMockDispatch -} = __nccwpck_require__(46117) -const { InvalidArgumentError } = __nccwpck_require__(32692) -const { buildURL } = __nccwpck_require__(13519) +} = __nccwpck_require__(24347) +const { InvalidArgumentError } = __nccwpck_require__(48045) +const { buildURL } = __nccwpck_require__(83983) /** * Defines the scope API for an interceptor reply @@ -52807,15 +52807,15 @@ module.exports.MockScope = MockScope /***/ }), -/***/ 55551: +/***/ 26193: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; const { promisify } = __nccwpck_require__(73837) -const Pool = __nccwpck_require__(23090) -const { buildMockDispatch } = __nccwpck_require__(55083) +const Pool = __nccwpck_require__(4634) +const { buildMockDispatch } = __nccwpck_require__(79323) const { kDispatches, kMockAgent, @@ -52824,10 +52824,10 @@ const { kOrigin, kOriginalDispatch, kConnected -} = __nccwpck_require__(46117) -const { MockInterceptor } = __nccwpck_require__(62276) -const Symbols = __nccwpck_require__(92176) -const { InvalidArgumentError } = __nccwpck_require__(32692) +} = __nccwpck_require__(24347) +const { MockInterceptor } = __nccwpck_require__(90410) +const Symbols = __nccwpck_require__(72785) +const { InvalidArgumentError } = __nccwpck_require__(48045) /** * MockPool provides an API that extends the Pool to influence the mockDispatches. @@ -52874,7 +52874,7 @@ module.exports = MockPool /***/ }), -/***/ 46117: +/***/ 24347: /***/ ((module) => { "use strict"; @@ -52905,21 +52905,21 @@ module.exports = { /***/ }), -/***/ 55083: +/***/ 79323: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const { MockNotMatchedError } = __nccwpck_require__(33700) +const { MockNotMatchedError } = __nccwpck_require__(50888) const { kDispatches, kMockAgent, kOriginalDispatch, kOrigin, kGetNetConnect -} = __nccwpck_require__(46117) -const { buildURL, nop } = __nccwpck_require__(13519) +} = __nccwpck_require__(24347) +const { buildURL, nop } = __nccwpck_require__(83983) const { STATUS_CODES } = __nccwpck_require__(13685) const { types: { @@ -53264,7 +53264,7 @@ module.exports = { /***/ }), -/***/ 54209: +/***/ 86823: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -53312,7 +53312,7 @@ module.exports = class PendingInterceptorsFormatter { /***/ }), -/***/ 10201: +/***/ 78891: /***/ ((module) => { "use strict"; @@ -53349,7 +53349,7 @@ module.exports = class Pluralizer { /***/ }), -/***/ 68653: +/***/ 68266: /***/ ((module) => { "use strict"; @@ -53474,16 +53474,16 @@ module.exports = class FixedQueue { /***/ }), -/***/ 49624: +/***/ 73198: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const DispatcherBase = __nccwpck_require__(12135) -const FixedQueue = __nccwpck_require__(68653) -const { kConnected, kSize, kRunning, kPending, kQueued, kBusy, kFree, kUrl, kClose, kDestroy, kDispatch } = __nccwpck_require__(92176) -const PoolStats = __nccwpck_require__(18157) +const DispatcherBase = __nccwpck_require__(74839) +const FixedQueue = __nccwpck_require__(68266) +const { kConnected, kSize, kRunning, kPending, kQueued, kBusy, kFree, kUrl, kClose, kDestroy, kDispatch } = __nccwpck_require__(72785) +const PoolStats = __nccwpck_require__(39689) const kClients = Symbol('clients') const kNeedDrain = Symbol('needDrain') @@ -53676,10 +53676,10 @@ module.exports = { /***/ }), -/***/ 18157: +/***/ 39689: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -const { kFree, kConnected, kPending, kQueued, kRunning, kSize } = __nccwpck_require__(92176) +const { kFree, kConnected, kPending, kQueued, kRunning, kSize } = __nccwpck_require__(72785) const kPool = Symbol('pool') class PoolStats { @@ -53717,7 +53717,7 @@ module.exports = PoolStats /***/ }), -/***/ 23090: +/***/ 4634: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -53729,14 +53729,14 @@ const { kNeedDrain, kAddClient, kGetDispatcher -} = __nccwpck_require__(49624) -const Client = __nccwpck_require__(551) +} = __nccwpck_require__(73198) +const Client = __nccwpck_require__(33598) const { InvalidArgumentError -} = __nccwpck_require__(32692) -const util = __nccwpck_require__(13519) -const { kUrl, kInterceptors } = __nccwpck_require__(92176) -const buildConnector = __nccwpck_require__(87595) +} = __nccwpck_require__(48045) +const util = __nccwpck_require__(83983) +const { kUrl, kInterceptors } = __nccwpck_require__(72785) +const buildConnector = __nccwpck_require__(82067) const kOptions = Symbol('options') const kConnections = Symbol('connections') @@ -53819,19 +53819,19 @@ module.exports = Pool /***/ }), -/***/ 29952: +/***/ 97858: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const { kProxy, kClose, kDestroy, kInterceptors } = __nccwpck_require__(92176) +const { kProxy, kClose, kDestroy, kInterceptors } = __nccwpck_require__(72785) const { URL } = __nccwpck_require__(57310) -const Agent = __nccwpck_require__(67401) -const Pool = __nccwpck_require__(23090) -const DispatcherBase = __nccwpck_require__(12135) -const { InvalidArgumentError, RequestAbortedError } = __nccwpck_require__(32692) -const buildConnector = __nccwpck_require__(87595) +const Agent = __nccwpck_require__(7890) +const Pool = __nccwpck_require__(4634) +const DispatcherBase = __nccwpck_require__(74839) +const { InvalidArgumentError, RequestAbortedError } = __nccwpck_require__(48045) +const buildConnector = __nccwpck_require__(82067) const kAgent = Symbol('proxy agent') const kClient = Symbol('proxy client') @@ -54016,7 +54016,7 @@ module.exports = ProxyAgent /***/ }), -/***/ 24942: +/***/ 29459: /***/ ((module) => { "use strict"; @@ -54121,27 +54121,27 @@ module.exports = { /***/ }), -/***/ 50972: +/***/ 35354: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; const diagnosticsChannel = __nccwpck_require__(67643) -const { uid, states } = __nccwpck_require__(39584) +const { uid, states } = __nccwpck_require__(19188) const { kReadyState, kSentClose, kByteParser, kReceivedClose -} = __nccwpck_require__(57077) -const { fireEvent, failWebsocketConnection } = __nccwpck_require__(42878) -const { CloseEvent } = __nccwpck_require__(18993) -const { makeRequest } = __nccwpck_require__(31848) -const { fetching } = __nccwpck_require__(56956) -const { Headers } = __nccwpck_require__(25582) -const { getGlobalDispatcher } = __nccwpck_require__(26881) -const { kHeadersList } = __nccwpck_require__(92176) +} = __nccwpck_require__(37578) +const { fireEvent, failWebsocketConnection } = __nccwpck_require__(25515) +const { CloseEvent } = __nccwpck_require__(52611) +const { makeRequest } = __nccwpck_require__(48359) +const { fetching } = __nccwpck_require__(74881) +const { Headers } = __nccwpck_require__(10554) +const { getGlobalDispatcher } = __nccwpck_require__(21892) +const { kHeadersList } = __nccwpck_require__(72785) const channels = {} channels.open = diagnosticsChannel.channel('undici:websocket:open') @@ -54420,7 +54420,7 @@ module.exports = { /***/ }), -/***/ 39584: +/***/ 19188: /***/ ((module) => { "use strict"; @@ -54479,14 +54479,14 @@ module.exports = { /***/ }), -/***/ 18993: +/***/ 52611: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const { webidl } = __nccwpck_require__(72146) -const { kEnumerableProperty } = __nccwpck_require__(13519) +const { webidl } = __nccwpck_require__(21744) +const { kEnumerableProperty } = __nccwpck_require__(83983) const { MessagePort } = __nccwpck_require__(71267) /** @@ -54790,13 +54790,13 @@ module.exports = { /***/ }), -/***/ 92112: +/***/ 25444: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const { maxUnsigned16Bit } = __nccwpck_require__(39584) +const { maxUnsigned16Bit } = __nccwpck_require__(19188) /** @type {import('crypto')} */ let crypto @@ -54871,7 +54871,7 @@ module.exports = { /***/ }), -/***/ 3887: +/***/ 11688: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -54879,10 +54879,10 @@ module.exports = { const { Writable } = __nccwpck_require__(12781) const diagnosticsChannel = __nccwpck_require__(67643) -const { parserStates, opcodes, states, emptyBuffer } = __nccwpck_require__(39584) -const { kReadyState, kSentClose, kResponse, kReceivedClose } = __nccwpck_require__(57077) -const { isValidStatusCode, failWebsocketConnection, websocketMessageReceived } = __nccwpck_require__(42878) -const { WebsocketFrameSend } = __nccwpck_require__(92112) +const { parserStates, opcodes, states, emptyBuffer } = __nccwpck_require__(19188) +const { kReadyState, kSentClose, kResponse, kReceivedClose } = __nccwpck_require__(37578) +const { isValidStatusCode, failWebsocketConnection, websocketMessageReceived } = __nccwpck_require__(25515) +const { WebsocketFrameSend } = __nccwpck_require__(25444) // This code was influenced by ws released under the MIT license. // Copyright (c) 2011 Einar Otto Stangvik @@ -55223,7 +55223,7 @@ module.exports = { /***/ }), -/***/ 57077: +/***/ 37578: /***/ ((module) => { "use strict"; @@ -55243,15 +55243,15 @@ module.exports = { /***/ }), -/***/ 42878: +/***/ 25515: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const { kReadyState, kController, kResponse, kBinaryType, kWebSocketURL } = __nccwpck_require__(57077) -const { states, opcodes } = __nccwpck_require__(39584) -const { MessageEvent, ErrorEvent } = __nccwpck_require__(18993) +const { kReadyState, kController, kResponse, kBinaryType, kWebSocketURL } = __nccwpck_require__(37578) +const { states, opcodes } = __nccwpck_require__(19188) +const { MessageEvent, ErrorEvent } = __nccwpck_require__(52611) /* globals Blob */ @@ -55451,17 +55451,17 @@ module.exports = { /***/ }), -/***/ 7791: +/***/ 54284: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const { webidl } = __nccwpck_require__(72146) -const { DOMException } = __nccwpck_require__(94731) -const { URLSerializer } = __nccwpck_require__(44194) -const { getGlobalOrigin } = __nccwpck_require__(91470) -const { staticPropertyDescriptors, states, opcodes, emptyBuffer } = __nccwpck_require__(39584) +const { webidl } = __nccwpck_require__(21744) +const { DOMException } = __nccwpck_require__(41037) +const { URLSerializer } = __nccwpck_require__(685) +const { getGlobalOrigin } = __nccwpck_require__(71246) +const { staticPropertyDescriptors, states, opcodes, emptyBuffer } = __nccwpck_require__(19188) const { kWebSocketURL, kReadyState, @@ -55470,13 +55470,13 @@ const { kResponse, kSentClose, kByteParser -} = __nccwpck_require__(57077) -const { isEstablished, isClosing, isValidSubprotocol, failWebsocketConnection, fireEvent } = __nccwpck_require__(42878) -const { establishWebSocketConnection } = __nccwpck_require__(50972) -const { WebsocketFrameSend } = __nccwpck_require__(92112) -const { ByteParser } = __nccwpck_require__(3887) -const { kEnumerableProperty, isBlobLike } = __nccwpck_require__(13519) -const { getGlobalDispatcher } = __nccwpck_require__(26881) +} = __nccwpck_require__(37578) +const { isEstablished, isClosing, isValidSubprotocol, failWebsocketConnection, fireEvent } = __nccwpck_require__(25515) +const { establishWebSocketConnection } = __nccwpck_require__(35354) +const { WebsocketFrameSend } = __nccwpck_require__(25444) +const { ByteParser } = __nccwpck_require__(11688) +const { kEnumerableProperty, isBlobLike } = __nccwpck_require__(83983) +const { getGlobalDispatcher } = __nccwpck_require__(21892) const { types } = __nccwpck_require__(73837) let experimentalWarned = false @@ -56100,7 +56100,7 @@ module.exports = { /***/ }), -/***/ 84150: +/***/ 65278: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { @@ -56113,7 +56113,7 @@ module.exports = __nccwpck_require__(73837).deprecate; /***/ }), -/***/ 40053: +/***/ 75840: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -56177,29 +56177,29 @@ Object.defineProperty(exports, "version", ({ } })); -var _v = _interopRequireDefault(__nccwpck_require__(5258)); +var _v = _interopRequireDefault(__nccwpck_require__(78628)); -var _v2 = _interopRequireDefault(__nccwpck_require__(63140)); +var _v2 = _interopRequireDefault(__nccwpck_require__(86409)); -var _v3 = _interopRequireDefault(__nccwpck_require__(70036)); +var _v3 = _interopRequireDefault(__nccwpck_require__(85122)); -var _v4 = _interopRequireDefault(__nccwpck_require__(17309)); +var _v4 = _interopRequireDefault(__nccwpck_require__(79120)); -var _nil = _interopRequireDefault(__nccwpck_require__(97198)); +var _nil = _interopRequireDefault(__nccwpck_require__(25332)); -var _version = _interopRequireDefault(__nccwpck_require__(2936)); +var _version = _interopRequireDefault(__nccwpck_require__(32414)); -var _validate = _interopRequireDefault(__nccwpck_require__(11890)); +var _validate = _interopRequireDefault(__nccwpck_require__(66900)); -var _stringify = _interopRequireDefault(__nccwpck_require__(49204)); +var _stringify = _interopRequireDefault(__nccwpck_require__(18950)); -var _parse = _interopRequireDefault(__nccwpck_require__(13725)); +var _parse = _interopRequireDefault(__nccwpck_require__(62746)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } /***/ }), -/***/ 9727: +/***/ 4569: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -56229,7 +56229,7 @@ exports["default"] = _default; /***/ }), -/***/ 28929: +/***/ 82054: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -56251,7 +56251,7 @@ exports["default"] = _default; /***/ }), -/***/ 97198: +/***/ 25332: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -56266,7 +56266,7 @@ exports["default"] = _default; /***/ }), -/***/ 13725: +/***/ 62746: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -56277,7 +56277,7 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = void 0; -var _validate = _interopRequireDefault(__nccwpck_require__(11890)); +var _validate = _interopRequireDefault(__nccwpck_require__(66900)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -56318,7 +56318,7 @@ exports["default"] = _default; /***/ }), -/***/ 79765: +/***/ 40814: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -56333,7 +56333,7 @@ exports["default"] = _default; /***/ }), -/***/ 47422: +/***/ 50807: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -56364,7 +56364,7 @@ function rng() { /***/ }), -/***/ 16317: +/***/ 85274: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -56394,7 +56394,7 @@ exports["default"] = _default; /***/ }), -/***/ 49204: +/***/ 18950: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -56406,7 +56406,7 @@ Object.defineProperty(exports, "__esModule", ({ exports["default"] = void 0; exports.unsafeStringify = unsafeStringify; -var _validate = _interopRequireDefault(__nccwpck_require__(11890)); +var _validate = _interopRequireDefault(__nccwpck_require__(66900)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -56445,7 +56445,7 @@ exports["default"] = _default; /***/ }), -/***/ 5258: +/***/ 78628: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -56456,9 +56456,9 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = void 0; -var _rng = _interopRequireDefault(__nccwpck_require__(47422)); +var _rng = _interopRequireDefault(__nccwpck_require__(50807)); -var _stringify = __nccwpck_require__(49204); +var _stringify = __nccwpck_require__(18950); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -56559,7 +56559,7 @@ exports["default"] = _default; /***/ }), -/***/ 63140: +/***/ 86409: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -56570,9 +56570,9 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = void 0; -var _v = _interopRequireDefault(__nccwpck_require__(40344)); +var _v = _interopRequireDefault(__nccwpck_require__(65998)); -var _md = _interopRequireDefault(__nccwpck_require__(9727)); +var _md = _interopRequireDefault(__nccwpck_require__(4569)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -56582,7 +56582,7 @@ exports["default"] = _default; /***/ }), -/***/ 40344: +/***/ 65998: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -56594,9 +56594,9 @@ Object.defineProperty(exports, "__esModule", ({ exports.URL = exports.DNS = void 0; exports["default"] = v35; -var _stringify = __nccwpck_require__(49204); +var _stringify = __nccwpck_require__(18950); -var _parse = _interopRequireDefault(__nccwpck_require__(13725)); +var _parse = _interopRequireDefault(__nccwpck_require__(62746)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -56669,7 +56669,7 @@ function v35(name, version, hashfunc) { /***/ }), -/***/ 70036: +/***/ 85122: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -56680,11 +56680,11 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = void 0; -var _native = _interopRequireDefault(__nccwpck_require__(28929)); +var _native = _interopRequireDefault(__nccwpck_require__(82054)); -var _rng = _interopRequireDefault(__nccwpck_require__(47422)); +var _rng = _interopRequireDefault(__nccwpck_require__(50807)); -var _stringify = __nccwpck_require__(49204); +var _stringify = __nccwpck_require__(18950); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -56719,7 +56719,7 @@ exports["default"] = _default; /***/ }), -/***/ 17309: +/***/ 79120: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -56730,9 +56730,9 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = void 0; -var _v = _interopRequireDefault(__nccwpck_require__(40344)); +var _v = _interopRequireDefault(__nccwpck_require__(65998)); -var _sha = _interopRequireDefault(__nccwpck_require__(16317)); +var _sha = _interopRequireDefault(__nccwpck_require__(85274)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -56742,7 +56742,7 @@ exports["default"] = _default; /***/ }), -/***/ 11890: +/***/ 66900: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -56753,7 +56753,7 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = void 0; -var _regex = _interopRequireDefault(__nccwpck_require__(79765)); +var _regex = _interopRequireDefault(__nccwpck_require__(40814)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -56766,7 +56766,7 @@ exports["default"] = _default; /***/ }), -/***/ 2936: +/***/ 32414: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -56777,7 +56777,7 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = void 0; -var _validate = _interopRequireDefault(__nccwpck_require__(11890)); +var _validate = _interopRequireDefault(__nccwpck_require__(66900)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -56794,7 +56794,7 @@ exports["default"] = _default; /***/ }), -/***/ 97245: +/***/ 21452: /***/ (function(__unused_webpack_module, exports) { /** @@ -61537,7 +61537,7 @@ exports["default"] = _default; /***/ }), -/***/ 35745: +/***/ 54886: /***/ ((module) => { "use strict"; @@ -61734,12 +61734,12 @@ conversions["RegExp"] = function (V, opts) { /***/ }), -/***/ 88007: +/***/ 97537: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; -const usm = __nccwpck_require__(53573); +const usm = __nccwpck_require__(2158); exports.implementation = class URLImpl { constructor(constructorArgs) { @@ -61942,15 +61942,15 @@ exports.implementation = class URLImpl { /***/ }), -/***/ 16588: +/***/ 63394: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const conversions = __nccwpck_require__(35745); -const utils = __nccwpck_require__(89939); -const Impl = __nccwpck_require__(88007); +const conversions = __nccwpck_require__(54886); +const utils = __nccwpck_require__(83185); +const Impl = __nccwpck_require__(97537); const impl = utils.implSymbol; @@ -62146,32 +62146,32 @@ module.exports = { /***/ }), -/***/ 40750: +/***/ 28665: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; -exports.URL = __nccwpck_require__(16588)["interface"]; -exports.serializeURL = __nccwpck_require__(53573).serializeURL; -exports.serializeURLOrigin = __nccwpck_require__(53573).serializeURLOrigin; -exports.basicURLParse = __nccwpck_require__(53573).basicURLParse; -exports.setTheUsername = __nccwpck_require__(53573).setTheUsername; -exports.setThePassword = __nccwpck_require__(53573).setThePassword; -exports.serializeHost = __nccwpck_require__(53573).serializeHost; -exports.serializeInteger = __nccwpck_require__(53573).serializeInteger; -exports.parseURL = __nccwpck_require__(53573).parseURL; +exports.URL = __nccwpck_require__(63394)["interface"]; +exports.serializeURL = __nccwpck_require__(2158).serializeURL; +exports.serializeURLOrigin = __nccwpck_require__(2158).serializeURLOrigin; +exports.basicURLParse = __nccwpck_require__(2158).basicURLParse; +exports.setTheUsername = __nccwpck_require__(2158).setTheUsername; +exports.setThePassword = __nccwpck_require__(2158).setThePassword; +exports.serializeHost = __nccwpck_require__(2158).serializeHost; +exports.serializeInteger = __nccwpck_require__(2158).serializeInteger; +exports.parseURL = __nccwpck_require__(2158).parseURL; /***/ }), -/***/ 53573: +/***/ 2158: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; const punycode = __nccwpck_require__(85477); -const tr46 = __nccwpck_require__(28394); +const tr46 = __nccwpck_require__(84256); const specialSchemes = { ftp: 21, @@ -63470,7 +63470,7 @@ module.exports.parseURL = function (input, options) { /***/ }), -/***/ 89939: +/***/ 83185: /***/ ((module) => { "use strict"; @@ -63498,30 +63498,30 @@ module.exports.implForWrapper = function (wrapper) { /***/ }), -/***/ 93230: +/***/ 57281: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; // Expose modern transport directly as the export -module.exports = __nccwpck_require__(1505); +module.exports = __nccwpck_require__(62429); // Expose legacy stream -module.exports.LegacyTransportStream = __nccwpck_require__(97510); +module.exports.LegacyTransportStream = __nccwpck_require__(66201); /***/ }), -/***/ 97510: +/***/ 66201: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; const util = __nccwpck_require__(73837); -const { LEVEL } = __nccwpck_require__(94079); -const TransportStream = __nccwpck_require__(1505); +const { LEVEL } = __nccwpck_require__(93937); +const TransportStream = __nccwpck_require__(62429); /** * Constructor function for the LegacyTransportStream. This is an internal @@ -63640,15 +63640,15 @@ LegacyTransportStream.prototype.close = function close() { /***/ }), -/***/ 1505: +/***/ 62429: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; const util = __nccwpck_require__(73837); -const Writable = __nccwpck_require__(8246); -const { LEVEL } = __nccwpck_require__(94079); +const Writable = __nccwpck_require__(32094); +const { LEVEL } = __nccwpck_require__(93937); /** * Constructor function for the TransportStream. This is the base prototype @@ -63859,7 +63859,7 @@ TransportStream.prototype._nop = function _nop() { /***/ }), -/***/ 71146: +/***/ 4158: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -63872,8 +63872,8 @@ TransportStream.prototype._nop = function _nop() { -const logform = __nccwpck_require__(63252); -const { warn } = __nccwpck_require__(34384); +const logform = __nccwpck_require__(32955); +const { warn } = __nccwpck_require__(18043); /** * Expose version. Use `require` method for `webpack` support. @@ -63884,12 +63884,12 @@ exports.version = __nccwpck_require__(12561).version; * Include transports defined by default by winston * @type {Array} */ -exports.transports = __nccwpck_require__(93664); +exports.transports = __nccwpck_require__(37804); /** * Expose utility methods * @type {Object} */ -exports.config = __nccwpck_require__(28534); +exports.config = __nccwpck_require__(24325); /** * Hoist format-related functionality from logform. * @type {Object} @@ -63904,32 +63904,32 @@ exports.format = logform.format; * Expose core Logging-related prototypes. * @type {function} */ -exports.createLogger = __nccwpck_require__(95263); +exports.createLogger = __nccwpck_require__(62878); /** * Expose core Logging-related prototypes. * @type {function} */ -exports.Logger = __nccwpck_require__(81495); +exports.Logger = __nccwpck_require__(85153); /** * Expose core Logging-related prototypes. * @type {Object} */ -exports.ExceptionHandler = __nccwpck_require__(21349); +exports.ExceptionHandler = __nccwpck_require__(27891); /** * Expose core Logging-related prototypes. * @type {Object} */ -exports.RejectionHandler = __nccwpck_require__(68287); +exports.RejectionHandler = __nccwpck_require__(61080); /** * Expose core Logging-related prototypes. * @type {Container} */ -exports.Container = __nccwpck_require__(14769); +exports.Container = __nccwpck_require__(67184); /** * Expose core Logging-related prototypes. * @type {Object} */ -exports.Transport = __nccwpck_require__(93230); +exports.Transport = __nccwpck_require__(57281); /** * We create and expose a default `Container` to `winston.loggers` so that the * programmer may manage multiple `winston.Logger` instances without any @@ -64058,7 +64058,7 @@ warn.forProperties(exports, 'deprecated', ['emitErrs', 'levelLength']); /***/ }), -/***/ 34384: +/***/ 18043: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -64112,7 +64112,7 @@ exports.warn = { /***/ }), -/***/ 28534: +/***/ 24325: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -64125,8 +64125,8 @@ exports.warn = { -const logform = __nccwpck_require__(63252); -const { configs } = __nccwpck_require__(94079); +const logform = __nccwpck_require__(32955); +const { configs } = __nccwpck_require__(93937); /** * Export config set for the CLI. @@ -64155,7 +64155,7 @@ exports.addColors = logform.levels; /***/ }), -/***/ 14769: +/***/ 67184: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -64168,7 +64168,7 @@ exports.addColors = logform.levels; -const createLogger = __nccwpck_require__(95263); +const createLogger = __nccwpck_require__(62878); /** * Inversion of control container for winston logger instances. @@ -64281,7 +64281,7 @@ module.exports = class Container { /***/ }), -/***/ 95263: +/***/ 62878: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -64294,10 +64294,10 @@ module.exports = class Container { -const { LEVEL } = __nccwpck_require__(94079); -const config = __nccwpck_require__(28534); -const Logger = __nccwpck_require__(81495); -const debug = __nccwpck_require__(10624)('winston:create-logger'); +const { LEVEL } = __nccwpck_require__(93937); +const config = __nccwpck_require__(24325); +const Logger = __nccwpck_require__(85153); +const debug = __nccwpck_require__(33170)('winston:create-logger'); function isLevelEnabledFunctionName(level) { return 'is' + level.charAt(0).toUpperCase() + level.slice(1) + 'Enabled'; @@ -64393,7 +64393,7 @@ module.exports = function (opts = {}) { /***/ }), -/***/ 21349: +/***/ 27891: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -64407,11 +64407,11 @@ module.exports = function (opts = {}) { const os = __nccwpck_require__(22037); -const asyncForEach = __nccwpck_require__(69301); -const debug = __nccwpck_require__(10624)('winston:exception'); -const once = __nccwpck_require__(42417); -const stackTrace = __nccwpck_require__(42396); -const ExceptionStream = __nccwpck_require__(71526); +const asyncForEach = __nccwpck_require__(51216); +const debug = __nccwpck_require__(33170)('winston:exception'); +const once = __nccwpck_require__(4118); +const stackTrace = __nccwpck_require__(55315); +const ExceptionStream = __nccwpck_require__(76268); /** * Object for handling uncaughtException events. @@ -64646,7 +64646,7 @@ module.exports = class ExceptionHandler { /***/ }), -/***/ 71526: +/***/ 76268: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -64659,7 +64659,7 @@ module.exports = class ExceptionHandler { -const { Writable } = __nccwpck_require__(67278); +const { Writable } = __nccwpck_require__(51642); /** * TODO: add class description. @@ -64708,7 +64708,7 @@ module.exports = class ExceptionStream extends Writable { /***/ }), -/***/ 81495: +/***/ 85153: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -64721,16 +64721,16 @@ module.exports = class ExceptionStream extends Writable { -const { Stream, Transform } = __nccwpck_require__(67278); -const asyncForEach = __nccwpck_require__(69301); -const { LEVEL, SPLAT } = __nccwpck_require__(94079); -const isStream = __nccwpck_require__(83921); -const ExceptionHandler = __nccwpck_require__(21349); -const RejectionHandler = __nccwpck_require__(68287); -const LegacyTransportStream = __nccwpck_require__(97510); -const Profiler = __nccwpck_require__(72289); -const { warn } = __nccwpck_require__(34384); -const config = __nccwpck_require__(28534); +const { Stream, Transform } = __nccwpck_require__(51642); +const asyncForEach = __nccwpck_require__(51216); +const { LEVEL, SPLAT } = __nccwpck_require__(93937); +const isStream = __nccwpck_require__(41554); +const ExceptionHandler = __nccwpck_require__(27891); +const RejectionHandler = __nccwpck_require__(61080); +const LegacyTransportStream = __nccwpck_require__(66201); +const Profiler = __nccwpck_require__(96959); +const { warn } = __nccwpck_require__(18043); +const config = __nccwpck_require__(24325); /** * Captures the number of format (i.e. %s strings) in a given string. @@ -64815,7 +64815,7 @@ class Logger extends Transform { } this.silent = silent; - this.format = format || this.format || __nccwpck_require__(6552)(); + this.format = format || this.format || __nccwpck_require__(45669)(); this.defaultMeta = defaultMeta || null; // Hoist other options onto this instance. @@ -65392,7 +65392,7 @@ module.exports = Logger; /***/ }), -/***/ 72289: +/***/ 96959: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -65418,7 +65418,7 @@ class Profiler { * @private */ constructor(logger) { - const Logger = __nccwpck_require__(81495); + const Logger = __nccwpck_require__(85153); if (typeof logger !== 'object' || Array.isArray(logger) || !(logger instanceof Logger)) { throw new Error('Logger is required for profiling'); } else { @@ -65453,7 +65453,7 @@ module.exports = Profiler; /***/ }), -/***/ 68287: +/***/ 61080: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -65467,11 +65467,11 @@ module.exports = Profiler; const os = __nccwpck_require__(22037); -const asyncForEach = __nccwpck_require__(69301); -const debug = __nccwpck_require__(10624)('winston:rejection'); -const once = __nccwpck_require__(42417); -const stackTrace = __nccwpck_require__(42396); -const RejectionStream = __nccwpck_require__(65002); +const asyncForEach = __nccwpck_require__(51216); +const debug = __nccwpck_require__(33170)('winston:rejection'); +const once = __nccwpck_require__(4118); +const stackTrace = __nccwpck_require__(55315); +const RejectionStream = __nccwpck_require__(28185); /** * Object for handling unhandledRejection events. @@ -65712,7 +65712,7 @@ module.exports = class RejectionHandler { /***/ }), -/***/ 65002: +/***/ 28185: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -65725,7 +65725,7 @@ module.exports = class RejectionHandler { -const { Writable } = __nccwpck_require__(67278); +const { Writable } = __nccwpck_require__(51642); /** * TODO: add class description. @@ -65772,7 +65772,7 @@ module.exports = class RejectionStream extends Writable { /***/ }), -/***/ 82403: +/***/ 31965: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -65787,7 +65787,7 @@ module.exports = class RejectionStream extends Writable { const fs = __nccwpck_require__(57147); const { StringDecoder } = __nccwpck_require__(71576); -const { Stream } = __nccwpck_require__(67278); +const { Stream } = __nccwpck_require__(51642); /** * Simple no-op function. @@ -65904,7 +65904,7 @@ module.exports = (options, iter) => { /***/ }), -/***/ 7984: +/***/ 17501: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -65919,8 +65919,8 @@ module.exports = (options, iter) => { const os = __nccwpck_require__(22037); -const { LEVEL, MESSAGE } = __nccwpck_require__(94079); -const TransportStream = __nccwpck_require__(93230); +const { LEVEL, MESSAGE } = __nccwpck_require__(93937); +const TransportStream = __nccwpck_require__(57281); /** * Transport for outputting to the console. @@ -66029,7 +66029,7 @@ module.exports = class Console extends TransportStream { /***/ }), -/***/ 1895: +/***/ 82478: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -66045,14 +66045,14 @@ module.exports = class Console extends TransportStream { const fs = __nccwpck_require__(57147); const path = __nccwpck_require__(71017); -const asyncSeries = __nccwpck_require__(50220); +const asyncSeries = __nccwpck_require__(59619); const zlib = __nccwpck_require__(59796); -const { MESSAGE } = __nccwpck_require__(94079); -const { Stream, PassThrough } = __nccwpck_require__(67278); -const TransportStream = __nccwpck_require__(93230); -const debug = __nccwpck_require__(10624)('winston:file'); +const { MESSAGE } = __nccwpck_require__(93937); +const { Stream, PassThrough } = __nccwpck_require__(51642); +const TransportStream = __nccwpck_require__(57281); +const debug = __nccwpck_require__(33170)('winston:file'); const os = __nccwpck_require__(22037); -const tailFile = __nccwpck_require__(82403); +const tailFile = __nccwpck_require__(31965); /** * Transport for outputting to a local log file. @@ -66802,7 +66802,7 @@ module.exports = class File extends TransportStream { /***/ }), -/***/ 95384: +/***/ 88028: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -66817,9 +66817,9 @@ module.exports = class File extends TransportStream { const http = __nccwpck_require__(13685); const https = __nccwpck_require__(95687); -const { Stream } = __nccwpck_require__(67278); -const TransportStream = __nccwpck_require__(93230); -const { configure } = __nccwpck_require__(4046); +const { Stream } = __nccwpck_require__(51642); +const TransportStream = __nccwpck_require__(57281); +const { configure } = __nccwpck_require__(37560); /** * Transport for outputting to a json-rpc server. @@ -67072,7 +67072,7 @@ module.exports = class Http extends TransportStream { /***/ }), -/***/ 93664: +/***/ 37804: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -67093,7 +67093,7 @@ Object.defineProperty(exports, "Console", ({ configurable: true, enumerable: true, get() { - return __nccwpck_require__(7984); + return __nccwpck_require__(17501); } })); @@ -67105,7 +67105,7 @@ Object.defineProperty(exports, "File", ({ configurable: true, enumerable: true, get() { - return __nccwpck_require__(1895); + return __nccwpck_require__(82478); } })); @@ -67117,7 +67117,7 @@ Object.defineProperty(exports, "Http", ({ configurable: true, enumerable: true, get() { - return __nccwpck_require__(95384); + return __nccwpck_require__(88028); } })); @@ -67129,14 +67129,14 @@ Object.defineProperty(exports, "Stream", ({ configurable: true, enumerable: true, get() { - return __nccwpck_require__(35919); + return __nccwpck_require__(14747); } })); /***/ }), -/***/ 35919: +/***/ 14747: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -67149,10 +67149,10 @@ Object.defineProperty(exports, "Stream", ({ -const isStream = __nccwpck_require__(83921); -const { MESSAGE } = __nccwpck_require__(94079); +const isStream = __nccwpck_require__(41554); +const { MESSAGE } = __nccwpck_require__(93937); const os = __nccwpck_require__(22037); -const TransportStream = __nccwpck_require__(93230); +const TransportStream = __nccwpck_require__(57281); /** * Transport for outputting to any arbitrary stream. @@ -67207,14 +67207,14 @@ module.exports = class Stream extends TransportStream { /***/ }), -/***/ 56057: +/***/ 69892: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.ZodError = exports.quotelessJson = exports.ZodIssueCode = void 0; -const util_1 = __nccwpck_require__(64252); +const util_1 = __nccwpck_require__(3985); exports.ZodIssueCode = util_1.util.arrayToEnum([ "invalid_type", "invalid_literal", @@ -67352,7 +67352,7 @@ ZodError.create = (issues) => { /***/ }), -/***/ 92721: +/***/ 69566: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -67362,7 +67362,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.getErrorMap = exports.setErrorMap = exports.defaultErrorMap = void 0; -const en_1 = __importDefault(__nccwpck_require__(43449)); +const en_1 = __importDefault(__nccwpck_require__(50468)); exports.defaultErrorMap = en_1.default; let overrideErrorMap = en_1.default; function setErrorMap(map) { @@ -67377,7 +67377,7 @@ exports.getErrorMap = getErrorMap; /***/ }), -/***/ 40397: +/***/ 49906: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -67393,17 +67393,17 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) { for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); }; Object.defineProperty(exports, "__esModule", ({ value: true })); -__exportStar(__nccwpck_require__(92721), exports); -__exportStar(__nccwpck_require__(49080), exports); -__exportStar(__nccwpck_require__(81541), exports); -__exportStar(__nccwpck_require__(64252), exports); -__exportStar(__nccwpck_require__(83948), exports); -__exportStar(__nccwpck_require__(56057), exports); +__exportStar(__nccwpck_require__(69566), exports); +__exportStar(__nccwpck_require__(10888), exports); +__exportStar(__nccwpck_require__(19449), exports); +__exportStar(__nccwpck_require__(3985), exports); +__exportStar(__nccwpck_require__(19335), exports); +__exportStar(__nccwpck_require__(69892), exports); /***/ }), -/***/ 18777: +/***/ 42513: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -67419,7 +67419,7 @@ var errorUtil; /***/ }), -/***/ 49080: +/***/ 10888: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -67429,8 +67429,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.isAsync = exports.isValid = exports.isDirty = exports.isAborted = exports.OK = exports.DIRTY = exports.INVALID = exports.ParseStatus = exports.addIssueToContext = exports.EMPTY_PATH = exports.makeIssue = void 0; -const errors_1 = __nccwpck_require__(92721); -const en_1 = __importDefault(__nccwpck_require__(43449)); +const errors_1 = __nccwpck_require__(69566); +const en_1 = __importDefault(__nccwpck_require__(50468)); const makeIssue = (params) => { const { data, path, errorMaps, issueData } = params; const fullPath = [...path, ...(issueData.path || [])]; @@ -67552,7 +67552,7 @@ exports.isAsync = isAsync; /***/ }), -/***/ 81541: +/***/ 19449: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -67562,7 +67562,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); /***/ }), -/***/ 64252: +/***/ 3985: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -67712,7 +67712,7 @@ exports.getParsedType = getParsedType; /***/ }), -/***/ 2180: +/***/ 63301: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -67741,22 +67741,22 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.z = void 0; -const z = __importStar(__nccwpck_require__(40397)); +const z = __importStar(__nccwpck_require__(49906)); exports.z = z; -__exportStar(__nccwpck_require__(40397), exports); +__exportStar(__nccwpck_require__(49906), exports); exports["default"] = z; /***/ }), -/***/ 43449: +/***/ 50468: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); -const util_1 = __nccwpck_require__(64252); -const ZodError_1 = __nccwpck_require__(56057); +const util_1 = __nccwpck_require__(3985); +const ZodError_1 = __nccwpck_require__(69892); const errorMap = (issue, _ctx) => { let message; switch (issue.code) { @@ -67886,7 +67886,7 @@ exports["default"] = errorMap; /***/ }), -/***/ 83948: +/***/ 19335: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -67906,11 +67906,11 @@ var _ZodEnum_cache, _ZodNativeEnum_cache; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.boolean = exports.bigint = exports.array = exports.any = exports.coerce = exports.ZodFirstPartyTypeKind = exports.late = exports.ZodSchema = exports.Schema = exports.custom = exports.ZodReadonly = exports.ZodPipeline = exports.ZodBranded = exports.BRAND = exports.ZodNaN = exports.ZodCatch = exports.ZodDefault = exports.ZodNullable = exports.ZodOptional = exports.ZodTransformer = exports.ZodEffects = exports.ZodPromise = exports.ZodNativeEnum = exports.ZodEnum = exports.ZodLiteral = exports.ZodLazy = exports.ZodFunction = exports.ZodSet = exports.ZodMap = exports.ZodRecord = exports.ZodTuple = exports.ZodIntersection = exports.ZodDiscriminatedUnion = exports.ZodUnion = exports.ZodObject = exports.ZodArray = exports.ZodVoid = exports.ZodNever = exports.ZodUnknown = exports.ZodAny = exports.ZodNull = exports.ZodUndefined = exports.ZodSymbol = exports.ZodDate = exports.ZodBoolean = exports.ZodBigInt = exports.ZodNumber = exports.ZodString = exports.datetimeRegex = exports.ZodType = void 0; exports.NEVER = exports["void"] = exports.unknown = exports.union = exports.undefined = exports.tuple = exports.transformer = exports.symbol = exports.string = exports.strictObject = exports.set = exports.record = exports.promise = exports.preprocess = exports.pipeline = exports.ostring = exports.optional = exports.onumber = exports.oboolean = exports.object = exports.number = exports.nullable = exports["null"] = exports.never = exports.nativeEnum = exports.nan = exports.map = exports.literal = exports.lazy = exports.intersection = exports["instanceof"] = exports["function"] = exports["enum"] = exports.effect = exports.discriminatedUnion = exports.date = void 0; -const errors_1 = __nccwpck_require__(92721); -const errorUtil_1 = __nccwpck_require__(18777); -const parseUtil_1 = __nccwpck_require__(49080); -const util_1 = __nccwpck_require__(64252); -const ZodError_1 = __nccwpck_require__(56057); +const errors_1 = __nccwpck_require__(69566); +const errorUtil_1 = __nccwpck_require__(42513); +const parseUtil_1 = __nccwpck_require__(10888); +const util_1 = __nccwpck_require__(3985); +const ZodError_1 = __nccwpck_require__(69892); class ParseInputLazyPath { constructor(parent, value, path, key) { this._cachedPath = []; @@ -71571,7 +71571,7 @@ exports.NEVER = parseUtil_1.INVALID; /***/ }), -/***/ 30670: +/***/ 7193: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -71589,17 +71589,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) { return (mod && mod.__esModule) ? mod : { "default": mod }; }; Object.defineProperty(exports, "__esModule", ({ value: true })); -const PatPatBot_1 = __importDefault(__nccwpck_require__(80629)); -const Gpt_1 = __importDefault(__nccwpck_require__(68639)); -const init_1 = __nccwpck_require__(72636); -const GoogleSearch_1 = __importDefault(__nccwpck_require__(59237)); -const Repository_1 = __importDefault(__nccwpck_require__(7591)); -const logging_1 = __importDefault(__nccwpck_require__(23877)); +const PatPatBot_1 = __importDefault(__nccwpck_require__(33181)); +const Gpt_1 = __importDefault(__nccwpck_require__(3877)); +const init_1 = __nccwpck_require__(17558); +const GoogleSearch_1 = __importDefault(__nccwpck_require__(47109)); +const Repository_1 = __importDefault(__nccwpck_require__(12648)); +const logging_1 = __importDefault(__nccwpck_require__(99566)); class Action { static run() { return __awaiter(this, void 0, void 0, function* () { const bot = new PatPatBot_1.default(new Gpt_1.default(init_1.API_KEY_OPENAI), new GoogleSearch_1.default()); - const repo = new Repository_1.default(init_1.REPO_NAME, init_1.DOCS_DIR, init_1.DOC_DESCRIPTIONS_PATH, init_1.DOC_PATTERNS_PATH); + const repo = new Repository_1.default(init_1.REPO_NAME, init_1.DOCS_DIR, init_1.DOC_DESCRIPTIONS_PATH); const maxIdx = Math.min(repo.docs.length, 20); // TODO remove this for (let idx = 0; idx < maxIdx; idx++) { let doc = repo.docs[idx]; @@ -71618,7 +71618,7 @@ exports["default"] = Action; /***/ }), -/***/ 42291: +/***/ 50800: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -71666,7 +71666,7 @@ exports["default"] = DocFile; /***/ }), -/***/ 59237: +/***/ 47109: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -71707,9 +71707,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) { return (mod && mod.__esModule) ? mod : { "default": mod }; }; Object.defineProperty(exports, "__esModule", ({ value: true })); -const axios_1 = __importDefault(__nccwpck_require__(49019)); -const cheerio = __importStar(__nccwpck_require__(72416)); -const string_format_1 = __importDefault(__nccwpck_require__(99728)); +const axios_1 = __importDefault(__nccwpck_require__(88757)); +const cheerio = __importStar(__nccwpck_require__(34612)); +const string_format_1 = __importDefault(__nccwpck_require__(13259)); class GoogleSearch { execute(promptTemplate_1) { return __awaiter(this, arguments, void 0, function* (promptTemplate, promptData = {}) { @@ -71765,7 +71765,7 @@ exports["default"] = GoogleSearch; /***/ }), -/***/ 68639: +/***/ 3877: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -71780,9 +71780,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }); }; Object.defineProperty(exports, "__esModule", ({ value: true })); -const openai_1 = __nccwpck_require__(14863); -const prompts_1 = __nccwpck_require__(63486); -const output_parsers_1 = __nccwpck_require__(39881); +const openai_1 = __nccwpck_require__(34739); +const prompts_1 = __nccwpck_require__(29477); +const output_parsers_1 = __nccwpck_require__(85304); const PROMPT_SYSTEM_DEFAULT = "You are a senior technical writer."; class Gpt { constructor(openaiApiKey, model = "gpt-4o") { @@ -71827,7 +71827,7 @@ exports["default"] = Gpt; /***/ }), -/***/ 21707: +/***/ 30662: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -71856,9 +71856,7 @@ class MetaFile { (0, fs_1.writeFileSync)(this.path, JSON.stringify(this.fileData, null, 2), 'utf-8'); } get patternDescriptions() { - return this.fileData.hasOwnProperty('patterns') - ? this.fileData.patterns - : this.fileData; + return this.fileData; } } exports["default"] = MetaFile; @@ -71866,7 +71864,7 @@ exports["default"] = MetaFile; /***/ }), -/***/ 80629: +/***/ 33181: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -71885,10 +71883,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.OUTPUT_ID = exports.INPUT_ID = void 0; -const init_1 = __nccwpck_require__(72636); -const PromptTemplate_1 = __importDefault(__nccwpck_require__(33734)); -const logging_1 = __importDefault(__nccwpck_require__(23877)); -const flat_1 = __nccwpck_require__(91634); +const init_1 = __nccwpck_require__(17558); +const PromptTemplate_1 = __importDefault(__nccwpck_require__(26781)); +const logging_1 = __importDefault(__nccwpck_require__(99566)); +const flat_1 = __nccwpck_require__(80630); exports.INPUT_ID = 'input'; exports.OUTPUT_ID = 'output'; class PatPatBot { @@ -71946,7 +71944,7 @@ exports["default"] = PatPatBot; /***/ }), -/***/ 33734: +/***/ 26781: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -72019,7 +72017,7 @@ exports["default"] = PromptTemplate; /***/ }), -/***/ 7591: +/***/ 12648: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -72028,14 +72026,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) { return (mod && mod.__esModule) ? mod : { "default": mod }; }; Object.defineProperty(exports, "__esModule", ({ value: true })); -const DocFile_1 = __importDefault(__nccwpck_require__(42291)); -const logging_1 = __importDefault(__nccwpck_require__(23877)); -const MetaFile_1 = __importDefault(__nccwpck_require__(21707)); +const DocFile_1 = __importDefault(__nccwpck_require__(50800)); +const logging_1 = __importDefault(__nccwpck_require__(99566)); +const MetaFile_1 = __importDefault(__nccwpck_require__(30662)); class Repository { - constructor(name, docsDir, docDescriptionPath, docPatternsPath, namePrefix = "codacy-") { + constructor(name, docsDir, docDescriptionPath, namePrefix = "codacy-") { this.name = namePrefix ? name.replace(namePrefix, "") : name; this.metaDescriptions = MetaFile_1.default.load(docDescriptionPath); - this.metaPatterns = MetaFile_1.default.load(docPatternsPath); this.docFileData = this.loadDocFiles(docsDir, this.metaDescriptions.patternDescriptions); logging_1.default.info(`Found ${Object.keys(this.docFileData).length} documentation files.`); } @@ -72045,11 +72042,9 @@ class Repository { saveAll() { this.docs.forEach((doc) => doc.save()); this.metaDescriptions.save(); - this.metaPatterns.save(); } updateMeta(data) { this.metaDescriptions.update(data); - this.metaPatterns.update(data); } loadDocFiles(docsDir, docDescriptions) { return docDescriptions.reduce((acc, { patternId }) => { @@ -72068,17 +72063,17 @@ exports["default"] = Repository; /***/ }), -/***/ 72636: +/***/ 17558: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.DOC_PATTERNS_PATH = exports.DOC_DESCRIPTIONS_PATH = exports.DOCS_DIR = exports.PATHS_PROMPTS = exports.REPO_NAME = exports.API_KEY_OPENAI = void 0; -const dotenv_1 = __nccwpck_require__(36406); -const glob_1 = __nccwpck_require__(65862); +exports.DOC_DESCRIPTIONS_PATH = exports.DOCS_DIR = exports.PATHS_PROMPTS = exports.REPO_NAME = exports.API_KEY_OPENAI = void 0; +const dotenv_1 = __nccwpck_require__(12437); +const glob_1 = __nccwpck_require__(38211); const path_1 = __nccwpck_require__(71017); -const core_1 = __nccwpck_require__(24181); +const core_1 = __nccwpck_require__(42186); (0, dotenv_1.config)(); const API_KEY_OPENAI = process.env.OPENAI_API_KEY; exports.API_KEY_OPENAI = API_KEY_OPENAI; @@ -72091,19 +72086,17 @@ const DOCS_DIR = (0, core_1.getInput)('docs_dir') || "docs/description"; exports.DOCS_DIR = DOCS_DIR; const DOC_DESCRIPTIONS_PATH = (0, core_1.getInput)('doc_descriptions_path') || "docs/description/description.json"; exports.DOC_DESCRIPTIONS_PATH = DOC_DESCRIPTIONS_PATH; -const DOC_PATTERNS_PATH = (0, core_1.getInput)('doc_patterns_path') || "docs/patterns.json"; -exports.DOC_PATTERNS_PATH = DOC_PATTERNS_PATH; /***/ }), -/***/ 23877: +/***/ 99566: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); -const winston_1 = __nccwpck_require__(71146); +const winston_1 = __nccwpck_require__(4158); const logger = (0, winston_1.createLogger)({ level: 'info', format: winston_1.format.combine(winston_1.format.timestamp(), winston_1.format.splat(), winston_1.format.printf(({ level, message, timestamp }) => { @@ -72118,7 +72111,7 @@ exports["default"] = logger; /***/ }), -/***/ 33709: +/***/ 70399: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -72127,13 +72120,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) { return (mod && mod.__esModule) ? mod : { "default": mod }; }; Object.defineProperty(exports, "__esModule", ({ value: true })); -const Action_1 = __importDefault(__nccwpck_require__(30670)); +const Action_1 = __importDefault(__nccwpck_require__(7193)); Action_1.default.run(); /***/ }), -/***/ 57969: +/***/ 19975: /***/ ((module) => { module.exports = eval("require")("debug"); @@ -72141,7 +72134,7 @@ module.exports = eval("require")("debug"); /***/ }), -/***/ 32209: +/***/ 22877: /***/ ((module) => { module.exports = eval("require")("encoding"); @@ -72429,7 +72422,7 @@ module.exports = require("zlib"); /***/ }), -/***/ 99136: +/***/ 92960: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -72438,10 +72431,10 @@ module.exports = require("zlib"); const WritableStream = (__nccwpck_require__(84492).Writable) const inherits = (__nccwpck_require__(47261).inherits) -const StreamSearch = __nccwpck_require__(18602) +const StreamSearch = __nccwpck_require__(51142) -const PartStream = __nccwpck_require__(48479) -const HeaderParser = __nccwpck_require__(34678) +const PartStream = __nccwpck_require__(81620) +const HeaderParser = __nccwpck_require__(92032) const DASH = 45 const B_ONEDASH = Buffer.from('-') @@ -72650,7 +72643,7 @@ module.exports = Dicer /***/ }), -/***/ 34678: +/***/ 92032: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -72658,9 +72651,9 @@ module.exports = Dicer const EventEmitter = (__nccwpck_require__(15673).EventEmitter) const inherits = (__nccwpck_require__(47261).inherits) -const getLimit = __nccwpck_require__(91231) +const getLimit = __nccwpck_require__(21467) -const StreamSearch = __nccwpck_require__(18602) +const StreamSearch = __nccwpck_require__(51142) const B_DCRLF = Buffer.from('\r\n\r\n') const RE_CRLF = /\r\n/g @@ -72758,7 +72751,7 @@ module.exports = HeaderParser /***/ }), -/***/ 48479: +/***/ 81620: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -72779,7 +72772,7 @@ module.exports = PartStream /***/ }), -/***/ 18602: +/***/ 51142: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -73015,7 +73008,7 @@ module.exports = SBMH /***/ }), -/***/ 61361: +/***/ 50727: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -73023,11 +73016,11 @@ module.exports = SBMH const WritableStream = (__nccwpck_require__(84492).Writable) const { inherits } = __nccwpck_require__(47261) -const Dicer = __nccwpck_require__(99136) +const Dicer = __nccwpck_require__(92960) -const MultipartParser = __nccwpck_require__(79890) -const UrlencodedParser = __nccwpck_require__(32888) -const parseParams = __nccwpck_require__(19626) +const MultipartParser = __nccwpck_require__(32183) +const UrlencodedParser = __nccwpck_require__(78306) +const parseParams = __nccwpck_require__(31854) function Busboy (opts) { if (!(this instanceof Busboy)) { return new Busboy(opts) } @@ -73108,7 +73101,7 @@ module.exports.Dicer = Dicer /***/ }), -/***/ 79890: +/***/ 32183: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -73124,12 +73117,12 @@ module.exports.Dicer = Dicer const { Readable } = __nccwpck_require__(84492) const { inherits } = __nccwpck_require__(47261) -const Dicer = __nccwpck_require__(99136) +const Dicer = __nccwpck_require__(92960) -const parseParams = __nccwpck_require__(19626) -const decodeText = __nccwpck_require__(25955) -const basename = __nccwpck_require__(27904) -const getLimit = __nccwpck_require__(91231) +const parseParams = __nccwpck_require__(31854) +const decodeText = __nccwpck_require__(84619) +const basename = __nccwpck_require__(48647) +const getLimit = __nccwpck_require__(21467) const RE_BOUNDARY = /^boundary$/i const RE_FIELD = /^form-data$/i @@ -73422,15 +73415,15 @@ module.exports = Multipart /***/ }), -/***/ 32888: +/***/ 78306: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const Decoder = __nccwpck_require__(43243) -const decodeText = __nccwpck_require__(25955) -const getLimit = __nccwpck_require__(91231) +const Decoder = __nccwpck_require__(27100) +const decodeText = __nccwpck_require__(84619) +const getLimit = __nccwpck_require__(21467) const RE_CHARSET = /^charset$/i @@ -73620,7 +73613,7 @@ module.exports = UrlEncoded /***/ }), -/***/ 43243: +/***/ 27100: /***/ ((module) => { "use strict"; @@ -73682,7 +73675,7 @@ module.exports = Decoder /***/ }), -/***/ 27904: +/***/ 48647: /***/ ((module) => { "use strict"; @@ -73704,7 +73697,7 @@ module.exports = function basename (path) { /***/ }), -/***/ 25955: +/***/ 84619: /***/ (function(module) { "use strict"; @@ -73826,7 +73819,7 @@ module.exports = decodeText /***/ }), -/***/ 91231: +/***/ 21467: /***/ ((module) => { "use strict"; @@ -73850,14 +73843,14 @@ module.exports = function getLimit (limits, name, defaultLimit) { /***/ }), -/***/ 19626: +/***/ 31854: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; /* eslint-disable object-property-newline */ -const decodeText = __nccwpck_require__(25955) +const decodeText = __nccwpck_require__(84619) const RE_ENCODED = /%[a-fA-F0-9][a-fA-F0-9]/g @@ -74054,7 +74047,7 @@ module.exports = parseParams /***/ }), -/***/ 17242: +/***/ 81778: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -74064,7 +74057,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); /***/ }), -/***/ 15988: +/***/ 75860: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -74086,12 +74079,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) { var _FormDataEncoder_instances, _FormDataEncoder_CRLF, _FormDataEncoder_CRLF_BYTES, _FormDataEncoder_CRLF_BYTES_LENGTH, _FormDataEncoder_DASHES, _FormDataEncoder_encoder, _FormDataEncoder_footer, _FormDataEncoder_form, _FormDataEncoder_options, _FormDataEncoder_getFieldHeader; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Encoder = exports.FormDataEncoder = void 0; -const createBoundary_1 = __importDefault(__nccwpck_require__(43190)); -const isPlainObject_1 = __importDefault(__nccwpck_require__(77970)); -const normalizeValue_1 = __importDefault(__nccwpck_require__(28989)); -const escapeName_1 = __importDefault(__nccwpck_require__(36602)); -const isFileLike_1 = __nccwpck_require__(2041); -const isFormData_1 = __nccwpck_require__(28699); +const createBoundary_1 = __importDefault(__nccwpck_require__(67956)); +const isPlainObject_1 = __importDefault(__nccwpck_require__(85240)); +const normalizeValue_1 = __importDefault(__nccwpck_require__(11391)); +const escapeName_1 = __importDefault(__nccwpck_require__(43864)); +const isFileLike_1 = __nccwpck_require__(96860); +const isFormData_1 = __nccwpck_require__(91633); const defaultOptions = { enableAdditionalHeaders: false }; @@ -74198,7 +74191,7 @@ exports.Encoder = FormDataEncoder; /***/ }), -/***/ 79280: +/***/ 96921: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -74208,7 +74201,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); /***/ }), -/***/ 62718: +/***/ 88824: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -74224,16 +74217,16 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) { for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); }; Object.defineProperty(exports, "__esModule", ({ value: true })); -__exportStar(__nccwpck_require__(15988), exports); -__exportStar(__nccwpck_require__(17242), exports); -__exportStar(__nccwpck_require__(79280), exports); -__exportStar(__nccwpck_require__(2041), exports); -__exportStar(__nccwpck_require__(28699), exports); +__exportStar(__nccwpck_require__(75860), exports); +__exportStar(__nccwpck_require__(81778), exports); +__exportStar(__nccwpck_require__(96921), exports); +__exportStar(__nccwpck_require__(96860), exports); +__exportStar(__nccwpck_require__(91633), exports); /***/ }), -/***/ 43190: +/***/ 67956: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -74253,7 +74246,7 @@ exports["default"] = createBoundary; /***/ }), -/***/ 36602: +/***/ 43864: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -74268,7 +74261,7 @@ exports["default"] = escapeName; /***/ }), -/***/ 2041: +/***/ 96860: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -74278,7 +74271,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.isFileLike = void 0; -const isFunction_1 = __importDefault(__nccwpck_require__(95797)); +const isFunction_1 = __importDefault(__nccwpck_require__(42498)); const isFileLike = (value) => Boolean(value && typeof value === "object" && (0, isFunction_1.default)(value.constructor) @@ -74292,7 +74285,7 @@ exports.isFileLike = isFileLike; /***/ }), -/***/ 28699: +/***/ 91633: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -74302,7 +74295,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.isFormDataLike = exports.isFormData = void 0; -const isFunction_1 = __importDefault(__nccwpck_require__(95797)); +const isFunction_1 = __importDefault(__nccwpck_require__(42498)); const isFormData = (value) => Boolean(value && (0, isFunction_1.default)(value.constructor) && value[Symbol.toStringTag] === "FormData" @@ -74316,7 +74309,7 @@ exports.isFormDataLike = exports.isFormData; /***/ }), -/***/ 95797: +/***/ 42498: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -74328,7 +74321,7 @@ exports["default"] = isFunction; /***/ }), -/***/ 77970: +/***/ 85240: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -74351,7 +74344,7 @@ exports["default"] = isPlainObject; /***/ }), -/***/ 28989: +/***/ 11391: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -74370,7 +74363,7 @@ exports["default"] = normalizeValue; /***/ }), -/***/ 41406: +/***/ 86637: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -74390,9 +74383,9 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function ( var _Blob_parts, _Blob_type, _Blob_size; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Blob = void 0; -const web_streams_polyfill_1 = __nccwpck_require__(19041); -const isFunction_1 = __nccwpck_require__(27607); -const blobHelpers_1 = __nccwpck_require__(93375); +const web_streams_polyfill_1 = __nccwpck_require__(46993); +const isFunction_1 = __nccwpck_require__(34245); +const blobHelpers_1 = __nccwpck_require__(17058); class Blob { constructor(blobParts = [], options = {}) { _Blob_parts.set(this, []); @@ -74500,7 +74493,7 @@ Object.defineProperties(Blob.prototype, { /***/ }), -/***/ 43062: +/***/ 33637: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -74519,7 +74512,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function ( var _File_name, _File_lastModified; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.File = void 0; -const Blob_1 = __nccwpck_require__(41406); +const Blob_1 = __nccwpck_require__(86637); class File extends Blob_1.Blob { constructor(fileBits, name, options = {}) { super(fileBits, options); @@ -74560,7 +74553,7 @@ exports.File = File; /***/ }), -/***/ 36400: +/***/ 47268: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -74574,11 +74567,11 @@ var _FormData_instances, _FormData_entries, _FormData_setEntry; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.FormData = void 0; const util_1 = __nccwpck_require__(73837); -const File_1 = __nccwpck_require__(43062); -const isFile_1 = __nccwpck_require__(44187); -const isBlob_1 = __nccwpck_require__(47956); -const isFunction_1 = __nccwpck_require__(27607); -const deprecateConstructorEntries_1 = __nccwpck_require__(51038); +const File_1 = __nccwpck_require__(33637); +const isFile_1 = __nccwpck_require__(54529); +const isBlob_1 = __nccwpck_require__(75493); +const isFunction_1 = __nccwpck_require__(34245); +const deprecateConstructorEntries_1 = __nccwpck_require__(52689); class FormData { constructor(entries) { _FormData_instances.add(this); @@ -74716,7 +74709,7 @@ exports.FormData = FormData; /***/ }), -/***/ 93375: +/***/ 17058: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -74724,7 +74717,7 @@ exports.FormData = FormData; /*! Based on fetch-blob. MIT License. Jimmy Wärting & David Frank */ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.sliceBlob = exports.consumeBlobParts = void 0; -const isFunction_1 = __nccwpck_require__(27607); +const isFunction_1 = __nccwpck_require__(34245); const CHUNK_SIZE = 65536; async function* clonePart(part) { const end = part.byteOffset + part.byteLength; @@ -74804,7 +74797,7 @@ exports.sliceBlob = sliceBlob; /***/ }), -/***/ 51038: +/***/ 52689: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -74818,7 +74811,7 @@ exports.deprecateConstructorEntries = (0, util_1.deprecate)(() => { }, "Construc /***/ }), -/***/ 20256: +/***/ 88735: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -74852,10 +74845,10 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.fileFromPath = exports.fileFromPathSync = void 0; const fs_1 = __nccwpck_require__(57147); const path_1 = __nccwpck_require__(71017); -const node_domexception_1 = __importDefault(__nccwpck_require__(22810)); -const File_1 = __nccwpck_require__(43062); -const isPlainObject_1 = __importDefault(__nccwpck_require__(81626)); -__exportStar(__nccwpck_require__(44187), exports); +const node_domexception_1 = __importDefault(__nccwpck_require__(97760)); +const File_1 = __nccwpck_require__(33637); +const isPlainObject_1 = __importDefault(__nccwpck_require__(24722)); +__exportStar(__nccwpck_require__(54529), exports); 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."; @@ -74923,7 +74916,7 @@ exports.fileFromPath = fileFromPath; /***/ }), -/***/ 17445: +/***/ 10880: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -74939,42 +74932,42 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) { for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); }; Object.defineProperty(exports, "__esModule", ({ value: true })); -__exportStar(__nccwpck_require__(36400), exports); -__exportStar(__nccwpck_require__(41406), exports); -__exportStar(__nccwpck_require__(43062), exports); +__exportStar(__nccwpck_require__(47268), exports); +__exportStar(__nccwpck_require__(86637), exports); +__exportStar(__nccwpck_require__(33637), exports); /***/ }), -/***/ 47956: +/***/ 75493: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.isBlob = void 0; -const Blob_1 = __nccwpck_require__(41406); +const Blob_1 = __nccwpck_require__(86637); const isBlob = (value) => value instanceof Blob_1.Blob; exports.isBlob = isBlob; /***/ }), -/***/ 44187: +/***/ 54529: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.isFile = void 0; -const File_1 = __nccwpck_require__(43062); +const File_1 = __nccwpck_require__(33637); const isFile = (value) => value instanceof File_1.File; exports.isFile = isFile; /***/ }), -/***/ 27607: +/***/ 34245: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -74987,7 +74980,7 @@ exports.isFunction = isFunction; /***/ }), -/***/ 81626: +/***/ 24722: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -75010,18 +75003,18 @@ exports["default"] = isPlainObject; /***/ }), -/***/ 24084: +/***/ 2487: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Glob = void 0; -const minimatch_1 = __nccwpck_require__(25900); -const path_scurry_1 = __nccwpck_require__(3208); +const minimatch_1 = __nccwpck_require__(4501); +const path_scurry_1 = __nccwpck_require__(51081); const node_url_1 = __nccwpck_require__(41041); -const pattern_js_1 = __nccwpck_require__(35110); -const walker_js_1 = __nccwpck_require__(8685); +const pattern_js_1 = __nccwpck_require__(86866); +const walker_js_1 = __nccwpck_require__(10153); // if no process global, just call it linux. // so we default to case-sensitive, / separators const defaultPlatform = typeof process === 'object' && @@ -75260,14 +75253,14 @@ exports.Glob = Glob; /***/ }), -/***/ 14409: +/***/ 33133: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.hasMagic = void 0; -const minimatch_1 = __nccwpck_require__(25900); +const minimatch_1 = __nccwpck_require__(4501); /** * Return true if the patterns provided contain any magic glob characters, * given the options provided. @@ -75294,7 +75287,7 @@ exports.hasMagic = hasMagic; /***/ }), -/***/ 83814: +/***/ 69703: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -75305,8 +75298,8 @@ exports.hasMagic = hasMagic; // Ignores are always parsed in dot:true mode Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Ignore = void 0; -const minimatch_1 = __nccwpck_require__(25900); -const pattern_js_1 = __nccwpck_require__(35110); +const minimatch_1 = __nccwpck_require__(4501); +const pattern_js_1 = __nccwpck_require__(86866); const defaultPlatform = typeof process === 'object' && process && typeof process.platform === 'string' @@ -75415,16 +75408,16 @@ exports.Ignore = Ignore; /***/ }), -/***/ 65862: +/***/ 38211: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.glob = exports.hasMagic = exports.Glob = exports.unescape = exports.escape = exports.sync = exports.iterate = exports.iterateSync = exports.stream = exports.streamSync = exports.globIterate = exports.globIterateSync = exports.globSync = exports.globStream = exports.globStreamSync = void 0; -const minimatch_1 = __nccwpck_require__(25900); -const glob_js_1 = __nccwpck_require__(24084); -const has_magic_js_1 = __nccwpck_require__(14409); +const minimatch_1 = __nccwpck_require__(4501); +const glob_js_1 = __nccwpck_require__(2487); +const has_magic_js_1 = __nccwpck_require__(33133); function globStreamSync(pattern, options = {}) { return new glob_js_1.Glob(pattern, options).streamSync(); } @@ -75460,12 +75453,12 @@ exports.sync = Object.assign(globSync, { iterate: globIterateSync, }); /* c8 ignore start */ -var minimatch_2 = __nccwpck_require__(25900); +var minimatch_2 = __nccwpck_require__(4501); Object.defineProperty(exports, "escape", ({ enumerable: true, get: function () { return minimatch_2.escape; } })); Object.defineProperty(exports, "unescape", ({ enumerable: true, get: function () { return minimatch_2.unescape; } })); -var glob_js_2 = __nccwpck_require__(24084); +var glob_js_2 = __nccwpck_require__(2487); Object.defineProperty(exports, "Glob", ({ enumerable: true, get: function () { return glob_js_2.Glob; } })); -var has_magic_js_2 = __nccwpck_require__(14409); +var has_magic_js_2 = __nccwpck_require__(33133); Object.defineProperty(exports, "hasMagic", ({ enumerable: true, get: function () { return has_magic_js_2.hasMagic; } })); /* c8 ignore stop */ exports.glob = Object.assign(glob_, { @@ -75490,7 +75483,7 @@ exports.glob.glob = exports.glob; /***/ }), -/***/ 35110: +/***/ 86866: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -75498,7 +75491,7 @@ exports.glob.glob = exports.glob; // this is just a very light wrapper around 2 arrays with an offset index Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Pattern = void 0; -const minimatch_1 = __nccwpck_require__(25900); +const minimatch_1 = __nccwpck_require__(4501); const isPatternList = (pl) => pl.length >= 1; const isGlobList = (gl) => gl.length >= 1; /** @@ -75716,7 +75709,7 @@ exports.Pattern = Pattern; /***/ }), -/***/ 81950: +/***/ 74628: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -75724,7 +75717,7 @@ exports.Pattern = Pattern; // synchronous utility for filtering entries and calculating subwalks Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Processor = exports.SubWalks = exports.MatchRecord = exports.HasWalkedCache = void 0; -const minimatch_1 = __nccwpck_require__(25900); +const minimatch_1 = __nccwpck_require__(4501); /** * A cache of which patterns have been processed for a given Path */ @@ -76025,7 +76018,7 @@ exports.Processor = Processor; /***/ }), -/***/ 8685: +/***/ 10153: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -76038,9 +76031,9 @@ exports.GlobStream = exports.GlobWalker = exports.GlobUtil = void 0; * * @module */ -const minipass_1 = __nccwpck_require__(52214); -const ignore_js_1 = __nccwpck_require__(83814); -const processor_js_1 = __nccwpck_require__(81950); +const minipass_1 = __nccwpck_require__(14968); +const ignore_js_1 = __nccwpck_require__(69703); +const processor_js_1 = __nccwpck_require__(74628); const makeIgnore = (ignore, opts) => typeof ignore === 'string' ? new ignore_js_1.Ignore([ignore], opts) : Array.isArray(ignore) @@ -76410,7 +76403,7 @@ exports.GlobStream = GlobStream; /***/ }), -/***/ 21132: +/***/ 73866: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -77863,7 +77856,7 @@ exports.LRUCache = LRUCache; /***/ }), -/***/ 56099: +/***/ 4149: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -77884,7 +77877,7 @@ exports.assertValidPattern = assertValidPattern; /***/ }), -/***/ 1578: +/***/ 15136: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -77892,8 +77885,8 @@ exports.assertValidPattern = assertValidPattern; // parse a single path portion Object.defineProperty(exports, "__esModule", ({ value: true })); exports.AST = void 0; -const brace_expressions_js_1 = __nccwpck_require__(99592); -const unescape_js_1 = __nccwpck_require__(63214); +const brace_expressions_js_1 = __nccwpck_require__(61812); +const unescape_js_1 = __nccwpck_require__(55698); const types = new Set(['!', '?', '+', '*', '@']); const isExtglobType = (c) => types.has(c); // Patterns that get prepended to bind to the start of either the @@ -78483,7 +78476,7 @@ exports.AST = AST; /***/ }), -/***/ 99592: +/***/ 61812: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -78642,7 +78635,7 @@ exports.parseClass = parseClass; /***/ }), -/***/ 60067: +/***/ 52804: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -78671,7 +78664,7 @@ exports.escape = escape; /***/ }), -/***/ 25900: +/***/ 4501: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -78681,11 +78674,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.unescape = exports.escape = exports.AST = exports.Minimatch = exports.match = exports.makeRe = exports.braceExpand = exports.defaults = exports.filter = exports.GLOBSTAR = exports.sep = exports.minimatch = void 0; -const brace_expansion_1 = __importDefault(__nccwpck_require__(60635)); -const assert_valid_pattern_js_1 = __nccwpck_require__(56099); -const ast_js_1 = __nccwpck_require__(1578); -const escape_js_1 = __nccwpck_require__(60067); -const unescape_js_1 = __nccwpck_require__(63214); +const brace_expansion_1 = __importDefault(__nccwpck_require__(33717)); +const assert_valid_pattern_js_1 = __nccwpck_require__(4149); +const ast_js_1 = __nccwpck_require__(15136); +const escape_js_1 = __nccwpck_require__(52804); +const unescape_js_1 = __nccwpck_require__(55698); const minimatch = (p, pattern, options = {}) => { (0, assert_valid_pattern_js_1.assertValidPattern)(pattern); // shortcut: comments match nothing. @@ -79679,11 +79672,11 @@ class Minimatch { } exports.Minimatch = Minimatch; /* c8 ignore start */ -var ast_js_2 = __nccwpck_require__(1578); +var ast_js_2 = __nccwpck_require__(15136); Object.defineProperty(exports, "AST", ({ enumerable: true, get: function () { return ast_js_2.AST; } })); -var escape_js_2 = __nccwpck_require__(60067); +var escape_js_2 = __nccwpck_require__(52804); Object.defineProperty(exports, "escape", ({ enumerable: true, get: function () { return escape_js_2.escape; } })); -var unescape_js_2 = __nccwpck_require__(63214); +var unescape_js_2 = __nccwpck_require__(55698); Object.defineProperty(exports, "unescape", ({ enumerable: true, get: function () { return unescape_js_2.unescape; } })); /* c8 ignore stop */ exports.minimatch.AST = ast_js_1.AST; @@ -79694,7 +79687,7 @@ exports.minimatch.unescape = unescape_js_1.unescape; /***/ }), -/***/ 63214: +/***/ 55698: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -79725,7 +79718,7 @@ exports.unescape = unescape; /***/ }), -/***/ 52214: +/***/ 14968: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -80760,7 +80753,7 @@ exports.Minipass = Minipass; /***/ }), -/***/ 20621: +/***/ 64595: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -80783,7 +80776,7 @@ exports.MultipartBody = MultipartBody; /***/ }), -/***/ 82990: +/***/ 43506: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -80806,19 +80799,19 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); /** * Disclaimer: modules in _shims aren't intended to be imported by SDK users. */ -__exportStar(__nccwpck_require__(14273), exports); +__exportStar(__nccwpck_require__(1749), exports); //# sourceMappingURL=runtime-node.js.map /***/ }), -/***/ 51039: +/***/ 6678: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { /** * Disclaimer: modules in _shims aren't intended to be imported by SDK users. */ -const shims = __nccwpck_require__(92615); -const auto = __nccwpck_require__(82990); +const shims = __nccwpck_require__(54437); +const auto = __nccwpck_require__(43506); if (!shims.kind) shims.setShims(auto.getRuntime(), { auto: true }); for (const property of Object.keys(shims)) { Object.defineProperty(exports, property, { @@ -80831,7 +80824,7 @@ for (const property of Object.keys(shims)) { /***/ }), -/***/ 14273: +/***/ 1749: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -80867,20 +80860,20 @@ exports.getRuntime = void 0; /** * Disclaimer: modules in _shims aren't intended to be imported by SDK users. */ -const nf = __importStar(__nccwpck_require__(46326)); -const fd = __importStar(__nccwpck_require__(17445)); -const agentkeepalive_1 = __importDefault(__nccwpck_require__(1386)); -const abort_controller_1 = __nccwpck_require__(62002); +const nf = __importStar(__nccwpck_require__(80467)); +const fd = __importStar(__nccwpck_require__(10880)); +const agentkeepalive_1 = __importDefault(__nccwpck_require__(34623)); +const abort_controller_1 = __nccwpck_require__(61659); const node_fs_1 = __nccwpck_require__(87561); -const form_data_encoder_1 = __nccwpck_require__(62718); +const form_data_encoder_1 = __nccwpck_require__(88824); const node_stream_1 = __nccwpck_require__(84492); -const MultipartBody_1 = __nccwpck_require__(20621); +const MultipartBody_1 = __nccwpck_require__(64595); // @ts-ignore (this package does not have proper export maps for this export) -const ponyfill_es2018_js_1 = __nccwpck_require__(97245); +const ponyfill_es2018_js_1 = __nccwpck_require__(21452); let fileFromPathWarned = false; async function fileFromPath(path, ...args) { // this import fails in environments that don't handle export maps correctly, like old versions of Jest - const { fileFromPath: _fileFromPath } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(20256))); + const { fileFromPath: _fileFromPath } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(88735))); if (!fileFromPathWarned) { console.warn(`fileFromPath is deprecated; use fs.createReadStream(${JSON.stringify(path)}) instead`); fileFromPathWarned = true; @@ -80928,7 +80921,7 @@ exports.getRuntime = getRuntime; /***/ }), -/***/ 92615: +/***/ 54437: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -80976,7 +80969,7 @@ exports.setShims = setShims; /***/ }), -/***/ 51780: +/***/ 11798: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -80995,12 +80988,12 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function ( var _AbstractPage_client; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.isObj = exports.toBase64 = exports.getRequiredHeader = exports.isHeadersProtocol = exports.isRunningInBrowser = exports.debug = exports.hasOwn = exports.isEmptyObj = exports.maybeCoerceBoolean = exports.maybeCoerceFloat = exports.maybeCoerceInteger = exports.coerceBoolean = exports.coerceFloat = exports.coerceInteger = exports.readEnv = exports.ensurePresent = exports.castToError = exports.sleep = exports.safeJSON = exports.isRequestOptions = exports.createResponseHeaders = exports.PagePromise = exports.AbstractPage = exports.APIClient = exports.APIPromise = exports.createForm = exports.multipartFormRequestOptions = exports.maybeMultipartFormRequestOptions = void 0; -const version_1 = __nccwpck_require__(61573); -const streaming_1 = __nccwpck_require__(3384); -const error_1 = __nccwpck_require__(29076); -const index_1 = __nccwpck_require__(51039); -const uploads_1 = __nccwpck_require__(50414); -var uploads_2 = __nccwpck_require__(50414); +const version_1 = __nccwpck_require__(96417); +const streaming_1 = __nccwpck_require__(20884); +const error_1 = __nccwpck_require__(8905); +const index_1 = __nccwpck_require__(6678); +const uploads_1 = __nccwpck_require__(73394); +var uploads_2 = __nccwpck_require__(73394); Object.defineProperty(exports, "maybeMultipartFormRequestOptions", ({ enumerable: true, get: function () { return uploads_2.maybeMultipartFormRequestOptions; } })); Object.defineProperty(exports, "multipartFormRequestOptions", ({ enumerable: true, get: function () { return uploads_2.multipartFormRequestOptions; } })); Object.defineProperty(exports, "createForm", ({ enumerable: true, get: function () { return uploads_2.createForm; } })); @@ -81862,7 +81855,7 @@ exports.isObj = isObj; /***/ }), -/***/ 29076: +/***/ 8905: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -81870,7 +81863,7 @@ exports.isObj = isObj; // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. Object.defineProperty(exports, "__esModule", ({ value: true })); exports.InternalServerError = exports.RateLimitError = exports.UnprocessableEntityError = exports.ConflictError = exports.NotFoundError = exports.PermissionDeniedError = exports.AuthenticationError = exports.BadRequestError = exports.APIConnectionTimeoutError = exports.APIConnectionError = exports.APIUserAbortError = exports.APIError = exports.OpenAIError = void 0; -const core_1 = __nccwpck_require__(51780); +const core_1 = __nccwpck_require__(11798); class OpenAIError extends Error { } exports.OpenAIError = OpenAIError; @@ -82017,7 +82010,7 @@ exports.InternalServerError = InternalServerError; /***/ }), -/***/ 1808: +/***/ 60047: /***/ (function(module, exports, __nccwpck_require__) { "use strict"; @@ -82049,11 +82042,11 @@ var __importStar = (this && this.__importStar) || function (mod) { var _a; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.AzureOpenAI = exports.fileFromPath = exports.toFile = exports.UnprocessableEntityError = exports.PermissionDeniedError = exports.InternalServerError = exports.AuthenticationError = exports.BadRequestError = exports.RateLimitError = exports.ConflictError = exports.NotFoundError = exports.APIUserAbortError = exports.APIConnectionTimeoutError = exports.APIConnectionError = exports.APIError = exports.OpenAIError = exports.OpenAI = void 0; -const Core = __importStar(__nccwpck_require__(51780)); -const Errors = __importStar(__nccwpck_require__(29076)); -const Uploads = __importStar(__nccwpck_require__(50414)); -const Pagination = __importStar(__nccwpck_require__(56671)); -const API = __importStar(__nccwpck_require__(75988)); +const Core = __importStar(__nccwpck_require__(11798)); +const Errors = __importStar(__nccwpck_require__(8905)); +const Uploads = __importStar(__nccwpck_require__(73394)); +const Pagination = __importStar(__nccwpck_require__(7401)); +const API = __importStar(__nccwpck_require__(65690)); /** API Client for interfacing with the OpenAI API. */ class OpenAI extends Core.APIClient { /** @@ -82286,7 +82279,7 @@ exports["default"] = OpenAI; /***/ }), -/***/ 87325: +/***/ 69365: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -82305,7 +82298,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function ( var _AbstractAssistantStreamRunner_connectedPromise, _AbstractAssistantStreamRunner_resolveConnectedPromise, _AbstractAssistantStreamRunner_rejectConnectedPromise, _AbstractAssistantStreamRunner_endPromise, _AbstractAssistantStreamRunner_resolveEndPromise, _AbstractAssistantStreamRunner_rejectEndPromise, _AbstractAssistantStreamRunner_listeners, _AbstractAssistantStreamRunner_ended, _AbstractAssistantStreamRunner_errored, _AbstractAssistantStreamRunner_aborted, _AbstractAssistantStreamRunner_catchingPromiseCreated, _AbstractAssistantStreamRunner_handleError; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.AbstractAssistantStreamRunner = void 0; -const error_1 = __nccwpck_require__(29076); +const error_1 = __nccwpck_require__(8905); class AbstractAssistantStreamRunner { constructor() { this.controller = new AbortController(); @@ -82539,7 +82532,7 @@ _AbstractAssistantStreamRunner_connectedPromise = new WeakMap(), _AbstractAssist /***/ }), -/***/ 41635: +/***/ 98398: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -82558,9 +82551,9 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function ( var _AbstractChatCompletionRunner_instances, _AbstractChatCompletionRunner_connectedPromise, _AbstractChatCompletionRunner_resolveConnectedPromise, _AbstractChatCompletionRunner_rejectConnectedPromise, _AbstractChatCompletionRunner_endPromise, _AbstractChatCompletionRunner_resolveEndPromise, _AbstractChatCompletionRunner_rejectEndPromise, _AbstractChatCompletionRunner_listeners, _AbstractChatCompletionRunner_ended, _AbstractChatCompletionRunner_errored, _AbstractChatCompletionRunner_aborted, _AbstractChatCompletionRunner_catchingPromiseCreated, _AbstractChatCompletionRunner_getFinalContent, _AbstractChatCompletionRunner_getFinalMessage, _AbstractChatCompletionRunner_getFinalFunctionCall, _AbstractChatCompletionRunner_getFinalFunctionCallResult, _AbstractChatCompletionRunner_calculateTotalUsage, _AbstractChatCompletionRunner_handleError, _AbstractChatCompletionRunner_validateParams, _AbstractChatCompletionRunner_stringifyFunctionCallResult; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.AbstractChatCompletionRunner = void 0; -const error_1 = __nccwpck_require__(29076); -const RunnableFunction_1 = __nccwpck_require__(96723); -const chatCompletionUtils_1 = __nccwpck_require__(32664); +const error_1 = __nccwpck_require__(8905); +const RunnableFunction_1 = __nccwpck_require__(75464); +const chatCompletionUtils_1 = __nccwpck_require__(87858); const DEFAULT_MAX_CHAT_COMPLETIONS = 10; class AbstractChatCompletionRunner { constructor() { @@ -83065,7 +83058,7 @@ _AbstractChatCompletionRunner_connectedPromise = new WeakMap(), _AbstractChatCom /***/ }), -/***/ 67185: +/***/ 27514: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -83107,10 +83100,10 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function ( var _AssistantStream_instances, _AssistantStream_events, _AssistantStream_runStepSnapshots, _AssistantStream_messageSnapshots, _AssistantStream_messageSnapshot, _AssistantStream_finalRun, _AssistantStream_currentContentIndex, _AssistantStream_currentContent, _AssistantStream_currentToolCallIndex, _AssistantStream_currentToolCall, _AssistantStream_currentEvent, _AssistantStream_currentRunSnapshot, _AssistantStream_currentRunStepSnapshot, _AssistantStream_addEvent, _AssistantStream_endRequest, _AssistantStream_handleMessage, _AssistantStream_handleRunStep, _AssistantStream_handleEvent, _AssistantStream_accumulateRunStep, _AssistantStream_accumulateMessage, _AssistantStream_accumulateContent, _AssistantStream_handleRun; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.AssistantStream = void 0; -const Core = __importStar(__nccwpck_require__(51780)); -const AbstractAssistantStreamRunner_1 = __nccwpck_require__(87325); -const streaming_1 = __nccwpck_require__(3384); -const error_1 = __nccwpck_require__(29076); +const Core = __importStar(__nccwpck_require__(11798)); +const AbstractAssistantStreamRunner_1 = __nccwpck_require__(69365); +const streaming_1 = __nccwpck_require__(20884); +const error_1 = __nccwpck_require__(8905); class AssistantStream extends AbstractAssistantStreamRunner_1.AbstractAssistantStreamRunner { constructor() { super(...arguments); @@ -83620,15 +83613,15 @@ _AssistantStream_addEvent = function _AssistantStream_addEvent(event) { /***/ }), -/***/ 57050: +/***/ 25575: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.ChatCompletionRunner = void 0; -const AbstractChatCompletionRunner_1 = __nccwpck_require__(41635); -const chatCompletionUtils_1 = __nccwpck_require__(32664); +const AbstractChatCompletionRunner_1 = __nccwpck_require__(98398); +const chatCompletionUtils_1 = __nccwpck_require__(87858); class ChatCompletionRunner extends AbstractChatCompletionRunner_1.AbstractChatCompletionRunner { /** @deprecated - please use `runTools` instead. */ static runFunctions(completions, params, options) { @@ -83661,7 +83654,7 @@ exports.ChatCompletionRunner = ChatCompletionRunner; /***/ }), -/***/ 10799: +/***/ 77823: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -83680,9 +83673,9 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function ( var _ChatCompletionStream_instances, _ChatCompletionStream_currentChatCompletionSnapshot, _ChatCompletionStream_beginRequest, _ChatCompletionStream_addChunk, _ChatCompletionStream_endRequest, _ChatCompletionStream_accumulateChatCompletion; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.ChatCompletionStream = void 0; -const error_1 = __nccwpck_require__(29076); -const AbstractChatCompletionRunner_1 = __nccwpck_require__(41635); -const streaming_1 = __nccwpck_require__(3384); +const error_1 = __nccwpck_require__(8905); +const AbstractChatCompletionRunner_1 = __nccwpck_require__(98398); +const streaming_1 = __nccwpck_require__(20884); class ChatCompletionStream extends AbstractChatCompletionRunner_1.AbstractChatCompletionRunner { constructor() { super(...arguments); @@ -83980,14 +83973,14 @@ function str(x) { /***/ }), -/***/ 34855: +/***/ 60794: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.ChatCompletionStreamingRunner = void 0; -const ChatCompletionStream_1 = __nccwpck_require__(10799); +const ChatCompletionStream_1 = __nccwpck_require__(77823); class ChatCompletionStreamingRunner extends ChatCompletionStream_1.ChatCompletionStream { static fromReadableStream(stream) { const runner = new ChatCompletionStreamingRunner(); @@ -84019,7 +84012,7 @@ exports.ChatCompletionStreamingRunner = ChatCompletionStreamingRunner; /***/ }), -/***/ 96723: +/***/ 75464: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -84061,7 +84054,7 @@ exports.ParsingToolFunction = ParsingToolFunction; /***/ }), -/***/ 92718: +/***/ 92626: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -84094,7 +84087,7 @@ exports.allSettledWithThrow = allSettledWithThrow; /***/ }), -/***/ 32664: +/***/ 87858: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -84121,7 +84114,7 @@ exports.isPresent = isPresent; /***/ }), -/***/ 56671: +/***/ 7401: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -84129,7 +84122,7 @@ exports.isPresent = isPresent; // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. Object.defineProperty(exports, "__esModule", ({ value: true })); exports.CursorPage = exports.Page = void 0; -const core_1 = __nccwpck_require__(51780); +const core_1 = __nccwpck_require__(11798); /** * Note: no pagination actually occurs yet, this is for forwards-compatibility. */ @@ -84192,7 +84185,7 @@ exports.CursorPage = CursorPage; /***/ }), -/***/ 19116: +/***/ 99593: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -84210,7 +84203,7 @@ exports.APIResource = APIResource; /***/ }), -/***/ 30319: +/***/ 86376: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -84241,10 +84234,10 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Audio = void 0; -const resource_1 = __nccwpck_require__(19116); -const SpeechAPI = __importStar(__nccwpck_require__(65891)); -const TranscriptionsAPI = __importStar(__nccwpck_require__(28926)); -const TranslationsAPI = __importStar(__nccwpck_require__(25611)); +const resource_1 = __nccwpck_require__(99593); +const SpeechAPI = __importStar(__nccwpck_require__(64117)); +const TranscriptionsAPI = __importStar(__nccwpck_require__(5622)); +const TranslationsAPI = __importStar(__nccwpck_require__(37735)); class Audio extends resource_1.APIResource { constructor() { super(...arguments); @@ -84263,7 +84256,7 @@ exports.Audio = Audio; /***/ }), -/***/ 65891: +/***/ 64117: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -84271,7 +84264,7 @@ exports.Audio = Audio; // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Speech = void 0; -const resource_1 = __nccwpck_require__(19116); +const resource_1 = __nccwpck_require__(99593); class Speech extends resource_1.APIResource { /** * Generates audio from the input text. @@ -84287,7 +84280,7 @@ exports.Speech = Speech; /***/ }), -/***/ 28926: +/***/ 5622: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -84295,8 +84288,8 @@ exports.Speech = Speech; // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Transcriptions = void 0; -const resource_1 = __nccwpck_require__(19116); -const core_1 = __nccwpck_require__(51780); +const resource_1 = __nccwpck_require__(99593); +const core_1 = __nccwpck_require__(11798); class Transcriptions extends resource_1.APIResource { /** * Transcribes audio into the input language. @@ -84312,7 +84305,7 @@ exports.Transcriptions = Transcriptions; /***/ }), -/***/ 25611: +/***/ 37735: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -84320,8 +84313,8 @@ exports.Transcriptions = Transcriptions; // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Translations = void 0; -const resource_1 = __nccwpck_require__(19116); -const core_1 = __nccwpck_require__(51780); +const resource_1 = __nccwpck_require__(99593); +const core_1 = __nccwpck_require__(11798); class Translations extends resource_1.APIResource { /** * Translates audio into English. @@ -84337,7 +84330,7 @@ exports.Translations = Translations; /***/ }), -/***/ 31557: +/***/ 10341: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -84368,10 +84361,10 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.BatchesPage = exports.Batches = void 0; -const resource_1 = __nccwpck_require__(19116); -const core_1 = __nccwpck_require__(51780); -const BatchesAPI = __importStar(__nccwpck_require__(31557)); -const pagination_1 = __nccwpck_require__(56671); +const resource_1 = __nccwpck_require__(99593); +const core_1 = __nccwpck_require__(11798); +const BatchesAPI = __importStar(__nccwpck_require__(10341)); +const pagination_1 = __nccwpck_require__(7401); class Batches extends resource_1.APIResource { /** * Creates and executes a batch from an uploaded file of requests @@ -84409,7 +84402,7 @@ exports.BatchesPage = BatchesPage; /***/ }), -/***/ 83973: +/***/ 70616: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -84440,10 +84433,10 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.AssistantsPage = exports.Assistants = void 0; -const resource_1 = __nccwpck_require__(19116); -const core_1 = __nccwpck_require__(51780); -const AssistantsAPI = __importStar(__nccwpck_require__(83973)); -const pagination_1 = __nccwpck_require__(56671); +const resource_1 = __nccwpck_require__(99593); +const core_1 = __nccwpck_require__(11798); +const AssistantsAPI = __importStar(__nccwpck_require__(70616)); +const pagination_1 = __nccwpck_require__(7401); class Assistants extends resource_1.APIResource { /** * Create an assistant with a model and instructions. @@ -84505,7 +84498,7 @@ exports.AssistantsPage = AssistantsPage; /***/ }), -/***/ 50434: +/***/ 40853: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -84536,11 +84529,11 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Beta = void 0; -const resource_1 = __nccwpck_require__(19116); -const AssistantsAPI = __importStar(__nccwpck_require__(83973)); -const ChatAPI = __importStar(__nccwpck_require__(93842)); -const ThreadsAPI = __importStar(__nccwpck_require__(7534)); -const VectorStoresAPI = __importStar(__nccwpck_require__(65854)); +const resource_1 = __nccwpck_require__(99593); +const AssistantsAPI = __importStar(__nccwpck_require__(70616)); +const ChatAPI = __importStar(__nccwpck_require__(78691)); +const ThreadsAPI = __importStar(__nccwpck_require__(21931)); +const VectorStoresAPI = __importStar(__nccwpck_require__(75822)); class Beta extends resource_1.APIResource { constructor() { super(...arguments); @@ -84563,7 +84556,7 @@ exports.Beta = Beta; /***/ }), -/***/ 93842: +/***/ 78691: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -84594,8 +84587,8 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Chat = void 0; -const resource_1 = __nccwpck_require__(19116); -const CompletionsAPI = __importStar(__nccwpck_require__(4911)); +const resource_1 = __nccwpck_require__(99593); +const CompletionsAPI = __importStar(__nccwpck_require__(559)); class Chat extends resource_1.APIResource { constructor() { super(...arguments); @@ -84610,7 +84603,7 @@ exports.Chat = Chat; /***/ }), -/***/ 4911: +/***/ 559: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -84618,18 +84611,18 @@ exports.Chat = Chat; // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Completions = exports.ChatCompletionStream = exports.ParsingToolFunction = exports.ParsingFunction = exports.ChatCompletionStreamingRunner = exports.ChatCompletionRunner = void 0; -const resource_1 = __nccwpck_require__(19116); -const ChatCompletionRunner_1 = __nccwpck_require__(57050); -var ChatCompletionRunner_2 = __nccwpck_require__(57050); +const resource_1 = __nccwpck_require__(99593); +const ChatCompletionRunner_1 = __nccwpck_require__(25575); +var ChatCompletionRunner_2 = __nccwpck_require__(25575); Object.defineProperty(exports, "ChatCompletionRunner", ({ enumerable: true, get: function () { return ChatCompletionRunner_2.ChatCompletionRunner; } })); -const ChatCompletionStreamingRunner_1 = __nccwpck_require__(34855); -var ChatCompletionStreamingRunner_2 = __nccwpck_require__(34855); +const ChatCompletionStreamingRunner_1 = __nccwpck_require__(60794); +var ChatCompletionStreamingRunner_2 = __nccwpck_require__(60794); Object.defineProperty(exports, "ChatCompletionStreamingRunner", ({ enumerable: true, get: function () { return ChatCompletionStreamingRunner_2.ChatCompletionStreamingRunner; } })); -var RunnableFunction_1 = __nccwpck_require__(96723); +var RunnableFunction_1 = __nccwpck_require__(75464); Object.defineProperty(exports, "ParsingFunction", ({ enumerable: true, get: function () { return RunnableFunction_1.ParsingFunction; } })); Object.defineProperty(exports, "ParsingToolFunction", ({ enumerable: true, get: function () { return RunnableFunction_1.ParsingToolFunction; } })); -const ChatCompletionStream_1 = __nccwpck_require__(10799); -var ChatCompletionStream_2 = __nccwpck_require__(10799); +const ChatCompletionStream_1 = __nccwpck_require__(77823); +var ChatCompletionStream_2 = __nccwpck_require__(77823); Object.defineProperty(exports, "ChatCompletionStream", ({ enumerable: true, get: function () { return ChatCompletionStream_2.ChatCompletionStream; } })); class Completions extends resource_1.APIResource { runFunctions(body, options) { @@ -84656,7 +84649,7 @@ exports.Completions = Completions; /***/ }), -/***/ 83221: +/***/ 81787: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -84687,10 +84680,10 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.MessagesPage = exports.Messages = void 0; -const resource_1 = __nccwpck_require__(19116); -const core_1 = __nccwpck_require__(51780); -const MessagesAPI = __importStar(__nccwpck_require__(83221)); -const pagination_1 = __nccwpck_require__(56671); +const resource_1 = __nccwpck_require__(99593); +const core_1 = __nccwpck_require__(11798); +const MessagesAPI = __importStar(__nccwpck_require__(81787)); +const pagination_1 = __nccwpck_require__(7401); class Messages extends resource_1.APIResource { /** * Create a message. @@ -84752,7 +84745,7 @@ exports.MessagesPage = MessagesPage; /***/ }), -/***/ 36315: +/***/ 3187: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -84783,13 +84776,13 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.RunsPage = exports.Runs = void 0; -const resource_1 = __nccwpck_require__(19116); -const core_1 = __nccwpck_require__(51780); -const AssistantStream_1 = __nccwpck_require__(67185); -const core_2 = __nccwpck_require__(51780); -const RunsAPI = __importStar(__nccwpck_require__(36315)); -const StepsAPI = __importStar(__nccwpck_require__(65519)); -const pagination_1 = __nccwpck_require__(56671); +const resource_1 = __nccwpck_require__(99593); +const core_1 = __nccwpck_require__(11798); +const AssistantStream_1 = __nccwpck_require__(27514); +const core_2 = __nccwpck_require__(11798); +const RunsAPI = __importStar(__nccwpck_require__(3187)); +const StepsAPI = __importStar(__nccwpck_require__(22630)); +const pagination_1 = __nccwpck_require__(7401); class Runs extends resource_1.APIResource { constructor() { super(...arguments); @@ -84949,7 +84942,7 @@ exports.RunsPage = RunsPage; /***/ }), -/***/ 65519: +/***/ 22630: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -84980,10 +84973,10 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.RunStepsPage = exports.Steps = void 0; -const resource_1 = __nccwpck_require__(19116); -const core_1 = __nccwpck_require__(51780); -const StepsAPI = __importStar(__nccwpck_require__(65519)); -const pagination_1 = __nccwpck_require__(56671); +const resource_1 = __nccwpck_require__(99593); +const core_1 = __nccwpck_require__(11798); +const StepsAPI = __importStar(__nccwpck_require__(22630)); +const pagination_1 = __nccwpck_require__(7401); class Steps extends resource_1.APIResource { /** * Retrieves a run step. @@ -85016,7 +85009,7 @@ exports.RunStepsPage = RunStepsPage; /***/ }), -/***/ 7534: +/***/ 21931: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -85047,11 +85040,11 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Threads = void 0; -const resource_1 = __nccwpck_require__(19116); -const core_1 = __nccwpck_require__(51780); -const AssistantStream_1 = __nccwpck_require__(67185); -const MessagesAPI = __importStar(__nccwpck_require__(83221)); -const RunsAPI = __importStar(__nccwpck_require__(36315)); +const resource_1 = __nccwpck_require__(99593); +const core_1 = __nccwpck_require__(11798); +const AssistantStream_1 = __nccwpck_require__(27514); +const MessagesAPI = __importStar(__nccwpck_require__(81787)); +const RunsAPI = __importStar(__nccwpck_require__(3187)); class Threads extends resource_1.APIResource { constructor() { super(...arguments); @@ -85131,7 +85124,7 @@ exports.Threads = Threads; /***/ }), -/***/ 42769: +/***/ 43922: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -85139,11 +85132,11 @@ exports.Threads = Threads; // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. Object.defineProperty(exports, "__esModule", ({ value: true })); exports.VectorStoreFilesPage = exports.FileBatches = void 0; -const resource_1 = __nccwpck_require__(19116); -const core_1 = __nccwpck_require__(51780); -const core_2 = __nccwpck_require__(51780); -const Util_1 = __nccwpck_require__(92718); -const files_1 = __nccwpck_require__(75841); +const resource_1 = __nccwpck_require__(99593); +const core_1 = __nccwpck_require__(11798); +const core_2 = __nccwpck_require__(11798); +const Util_1 = __nccwpck_require__(92626); +const files_1 = __nccwpck_require__(59180); Object.defineProperty(exports, "VectorStoreFilesPage", ({ enumerable: true, get: function () { return files_1.VectorStoreFilesPage; } })); class FileBatches extends resource_1.APIResource { /** @@ -85267,7 +85260,7 @@ exports.FileBatches = FileBatches; /***/ }), -/***/ 75841: +/***/ 59180: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -85298,11 +85291,11 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.VectorStoreFilesPage = exports.Files = void 0; -const resource_1 = __nccwpck_require__(19116); -const core_1 = __nccwpck_require__(51780); -const core_2 = __nccwpck_require__(51780); -const FilesAPI = __importStar(__nccwpck_require__(75841)); -const pagination_1 = __nccwpck_require__(56671); +const resource_1 = __nccwpck_require__(99593); +const core_1 = __nccwpck_require__(11798); +const core_2 = __nccwpck_require__(11798); +const FilesAPI = __importStar(__nccwpck_require__(59180)); +const pagination_1 = __nccwpck_require__(7401); class Files extends resource_1.APIResource { /** * Create a vector store file by attaching a @@ -85423,7 +85416,7 @@ exports.VectorStoreFilesPage = VectorStoreFilesPage; /***/ }), -/***/ 65854: +/***/ 75822: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -85454,12 +85447,12 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.VectorStoresPage = exports.VectorStores = void 0; -const resource_1 = __nccwpck_require__(19116); -const core_1 = __nccwpck_require__(51780); -const VectorStoresAPI = __importStar(__nccwpck_require__(65854)); -const FileBatchesAPI = __importStar(__nccwpck_require__(42769)); -const FilesAPI = __importStar(__nccwpck_require__(75841)); -const pagination_1 = __nccwpck_require__(56671); +const resource_1 = __nccwpck_require__(99593); +const core_1 = __nccwpck_require__(11798); +const VectorStoresAPI = __importStar(__nccwpck_require__(75822)); +const FileBatchesAPI = __importStar(__nccwpck_require__(43922)); +const FilesAPI = __importStar(__nccwpck_require__(59180)); +const pagination_1 = __nccwpck_require__(7401); class VectorStores extends resource_1.APIResource { constructor() { super(...arguments); @@ -85529,7 +85522,7 @@ exports.VectorStoresPage = VectorStoresPage; /***/ }), -/***/ 76843: +/***/ 7670: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -85560,8 +85553,8 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Chat = void 0; -const resource_1 = __nccwpck_require__(19116); -const CompletionsAPI = __importStar(__nccwpck_require__(38025)); +const resource_1 = __nccwpck_require__(99593); +const CompletionsAPI = __importStar(__nccwpck_require__(52875)); class Chat extends resource_1.APIResource { constructor() { super(...arguments); @@ -85576,7 +85569,7 @@ exports.Chat = Chat; /***/ }), -/***/ 38025: +/***/ 52875: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -85584,7 +85577,7 @@ exports.Chat = Chat; // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Completions = void 0; -const resource_1 = __nccwpck_require__(19116); +const resource_1 = __nccwpck_require__(99593); class Completions extends resource_1.APIResource { create(body, options) { return this._client.post('/chat/completions', { body, ...options, stream: body.stream ?? false }); @@ -85597,7 +85590,7 @@ exports.Completions = Completions; /***/ }), -/***/ 83685: +/***/ 18240: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -85605,15 +85598,15 @@ exports.Completions = Completions; // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Chat = exports.Completions = void 0; -var completions_1 = __nccwpck_require__(38025); +var completions_1 = __nccwpck_require__(52875); Object.defineProperty(exports, "Completions", ({ enumerable: true, get: function () { return completions_1.Completions; } })); -var chat_1 = __nccwpck_require__(76843); +var chat_1 = __nccwpck_require__(7670); Object.defineProperty(exports, "Chat", ({ enumerable: true, get: function () { return chat_1.Chat; } })); //# sourceMappingURL=index.js.map /***/ }), -/***/ 5098: +/***/ 99327: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -85621,7 +85614,7 @@ Object.defineProperty(exports, "Chat", ({ enumerable: true, get: function () { r // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Completions = void 0; -const resource_1 = __nccwpck_require__(19116); +const resource_1 = __nccwpck_require__(99593); class Completions extends resource_1.APIResource { create(body, options) { return this._client.post('/completions', { body, ...options, stream: body.stream ?? false }); @@ -85634,7 +85627,7 @@ exports.Completions = Completions; /***/ }), -/***/ 94014: +/***/ 8064: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -85642,7 +85635,7 @@ exports.Completions = Completions; // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Embeddings = void 0; -const resource_1 = __nccwpck_require__(19116); +const resource_1 = __nccwpck_require__(99593); class Embeddings extends resource_1.APIResource { /** * Creates an embedding vector representing the input text. @@ -85658,7 +85651,7 @@ exports.Embeddings = Embeddings; /***/ }), -/***/ 24177: +/***/ 53873: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -85689,13 +85682,13 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.FileObjectsPage = exports.Files = void 0; -const resource_1 = __nccwpck_require__(19116); -const core_1 = __nccwpck_require__(51780); -const core_2 = __nccwpck_require__(51780); -const error_1 = __nccwpck_require__(29076); -const FilesAPI = __importStar(__nccwpck_require__(24177)); -const core_3 = __nccwpck_require__(51780); -const pagination_1 = __nccwpck_require__(56671); +const resource_1 = __nccwpck_require__(99593); +const core_1 = __nccwpck_require__(11798); +const core_2 = __nccwpck_require__(11798); +const error_1 = __nccwpck_require__(8905); +const FilesAPI = __importStar(__nccwpck_require__(53873)); +const core_3 = __nccwpck_require__(11798); +const pagination_1 = __nccwpck_require__(7401); class Files extends resource_1.APIResource { /** * Upload a file that can be used across various endpoints. Individual files can be @@ -85785,7 +85778,7 @@ exports.FileObjectsPage = FileObjectsPage; /***/ }), -/***/ 44965: +/***/ 21364: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -85816,8 +85809,8 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.FineTuning = void 0; -const resource_1 = __nccwpck_require__(19116); -const JobsAPI = __importStar(__nccwpck_require__(6055)); +const resource_1 = __nccwpck_require__(99593); +const JobsAPI = __importStar(__nccwpck_require__(60816)); class FineTuning extends resource_1.APIResource { constructor() { super(...arguments); @@ -85834,7 +85827,7 @@ exports.FineTuning = FineTuning; /***/ }), -/***/ 35253: +/***/ 53104: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -85865,10 +85858,10 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.FineTuningJobCheckpointsPage = exports.Checkpoints = void 0; -const resource_1 = __nccwpck_require__(19116); -const core_1 = __nccwpck_require__(51780); -const CheckpointsAPI = __importStar(__nccwpck_require__(35253)); -const pagination_1 = __nccwpck_require__(56671); +const resource_1 = __nccwpck_require__(99593); +const core_1 = __nccwpck_require__(11798); +const CheckpointsAPI = __importStar(__nccwpck_require__(53104)); +const pagination_1 = __nccwpck_require__(7401); class Checkpoints extends resource_1.APIResource { list(fineTuningJobId, query = {}, options) { if ((0, core_1.isRequestOptions)(query)) { @@ -85888,7 +85881,7 @@ exports.FineTuningJobCheckpointsPage = FineTuningJobCheckpointsPage; /***/ }), -/***/ 6055: +/***/ 60816: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -85919,11 +85912,11 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.FineTuningJobEventsPage = exports.FineTuningJobsPage = exports.Jobs = void 0; -const resource_1 = __nccwpck_require__(19116); -const core_1 = __nccwpck_require__(51780); -const JobsAPI = __importStar(__nccwpck_require__(6055)); -const CheckpointsAPI = __importStar(__nccwpck_require__(35253)); -const pagination_1 = __nccwpck_require__(56671); +const resource_1 = __nccwpck_require__(99593); +const core_1 = __nccwpck_require__(11798); +const JobsAPI = __importStar(__nccwpck_require__(60816)); +const CheckpointsAPI = __importStar(__nccwpck_require__(53104)); +const pagination_1 = __nccwpck_require__(7401); class Jobs extends resource_1.APIResource { constructor() { super(...arguments); @@ -85988,7 +85981,7 @@ exports.FineTuningJobEventsPage = FineTuningJobEventsPage; /***/ }), -/***/ 65196: +/***/ 32621: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -85996,8 +85989,8 @@ exports.FineTuningJobEventsPage = FineTuningJobEventsPage; // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Images = void 0; -const resource_1 = __nccwpck_require__(19116); -const core_1 = __nccwpck_require__(51780); +const resource_1 = __nccwpck_require__(99593); +const core_1 = __nccwpck_require__(11798); class Images extends resource_1.APIResource { /** * Creates a variation of a given image. @@ -86025,7 +86018,7 @@ exports.Images = Images; /***/ }), -/***/ 75988: +/***/ 65690: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -86047,36 +86040,36 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Moderations = exports.Models = exports.ModelsPage = exports.Images = exports.FineTuning = exports.Files = exports.FileObjectsPage = exports.Embeddings = exports.Completions = exports.Beta = exports.Batches = exports.BatchesPage = exports.Audio = void 0; -__exportStar(__nccwpck_require__(83685), exports); -__exportStar(__nccwpck_require__(73511), exports); -var audio_1 = __nccwpck_require__(30319); +__exportStar(__nccwpck_require__(18240), exports); +__exportStar(__nccwpck_require__(4866), exports); +var audio_1 = __nccwpck_require__(86376); Object.defineProperty(exports, "Audio", ({ enumerable: true, get: function () { return audio_1.Audio; } })); -var batches_1 = __nccwpck_require__(31557); +var batches_1 = __nccwpck_require__(10341); Object.defineProperty(exports, "BatchesPage", ({ enumerable: true, get: function () { return batches_1.BatchesPage; } })); Object.defineProperty(exports, "Batches", ({ enumerable: true, get: function () { return batches_1.Batches; } })); -var beta_1 = __nccwpck_require__(50434); +var beta_1 = __nccwpck_require__(40853); Object.defineProperty(exports, "Beta", ({ enumerable: true, get: function () { return beta_1.Beta; } })); -var completions_1 = __nccwpck_require__(5098); +var completions_1 = __nccwpck_require__(99327); Object.defineProperty(exports, "Completions", ({ enumerable: true, get: function () { return completions_1.Completions; } })); -var embeddings_1 = __nccwpck_require__(94014); +var embeddings_1 = __nccwpck_require__(8064); Object.defineProperty(exports, "Embeddings", ({ enumerable: true, get: function () { return embeddings_1.Embeddings; } })); -var files_1 = __nccwpck_require__(24177); +var files_1 = __nccwpck_require__(53873); Object.defineProperty(exports, "FileObjectsPage", ({ enumerable: true, get: function () { return files_1.FileObjectsPage; } })); Object.defineProperty(exports, "Files", ({ enumerable: true, get: function () { return files_1.Files; } })); -var fine_tuning_1 = __nccwpck_require__(44965); +var fine_tuning_1 = __nccwpck_require__(21364); Object.defineProperty(exports, "FineTuning", ({ enumerable: true, get: function () { return fine_tuning_1.FineTuning; } })); -var images_1 = __nccwpck_require__(65196); +var images_1 = __nccwpck_require__(32621); Object.defineProperty(exports, "Images", ({ enumerable: true, get: function () { return images_1.Images; } })); -var models_1 = __nccwpck_require__(91158); +var models_1 = __nccwpck_require__(16467); Object.defineProperty(exports, "ModelsPage", ({ enumerable: true, get: function () { return models_1.ModelsPage; } })); Object.defineProperty(exports, "Models", ({ enumerable: true, get: function () { return models_1.Models; } })); -var moderations_1 = __nccwpck_require__(48465); +var moderations_1 = __nccwpck_require__(2085); Object.defineProperty(exports, "Moderations", ({ enumerable: true, get: function () { return moderations_1.Moderations; } })); //# sourceMappingURL=index.js.map /***/ }), -/***/ 91158: +/***/ 16467: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -86107,9 +86100,9 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.ModelsPage = exports.Models = void 0; -const resource_1 = __nccwpck_require__(19116); -const ModelsAPI = __importStar(__nccwpck_require__(91158)); -const pagination_1 = __nccwpck_require__(56671); +const resource_1 = __nccwpck_require__(99593); +const ModelsAPI = __importStar(__nccwpck_require__(16467)); +const pagination_1 = __nccwpck_require__(7401); class Models extends resource_1.APIResource { /** * Retrieves a model instance, providing basic information about the model such as @@ -86147,7 +86140,7 @@ exports.ModelsPage = ModelsPage; /***/ }), -/***/ 48465: +/***/ 2085: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -86155,7 +86148,7 @@ exports.ModelsPage = ModelsPage; // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Moderations = void 0; -const resource_1 = __nccwpck_require__(19116); +const resource_1 = __nccwpck_require__(99593); class Moderations extends resource_1.APIResource { /** * Classifies if text is potentially harmful. @@ -86171,7 +86164,7 @@ exports.Moderations = Moderations; /***/ }), -/***/ 73511: +/***/ 4866: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -86182,16 +86175,16 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); /***/ }), -/***/ 3384: +/***/ 20884: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.readableStreamAsyncIterable = exports._decodeChunks = exports._iterSSEMessages = exports.Stream = void 0; -const index_1 = __nccwpck_require__(51039); -const error_1 = __nccwpck_require__(29076); -const error_2 = __nccwpck_require__(29076); +const index_1 = __nccwpck_require__(6678); +const error_1 = __nccwpck_require__(8905); +const error_2 = __nccwpck_require__(8905); class Stream { constructor(iterator, controller) { this.iterator = iterator; @@ -86622,15 +86615,15 @@ exports.readableStreamAsyncIterable = readableStreamAsyncIterable; /***/ }), -/***/ 50414: +/***/ 73394: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.createForm = exports.multipartFormRequestOptions = exports.maybeMultipartFormRequestOptions = exports.isMultipartBody = exports.toFile = exports.isUploadable = exports.isBlobLike = exports.isFileLike = exports.isResponseLike = exports.fileFromPath = void 0; -const index_1 = __nccwpck_require__(51039); -var index_2 = __nccwpck_require__(51039); +const index_1 = __nccwpck_require__(6678); +var index_2 = __nccwpck_require__(6678); Object.defineProperty(exports, "fileFromPath", ({ enumerable: true, get: function () { return index_2.fileFromPath; } })); const isResponseLike = (value) => value != null && typeof value === 'object' && @@ -86794,7 +86787,7 @@ const addFormValue = async (form, key, value) => { /***/ }), -/***/ 61573: +/***/ 96417: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -86806,15 +86799,15 @@ exports.VERSION = '4.47.1'; // x-release-please-version /***/ }), -/***/ 20953: +/***/ 9000: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.adapter = exports.serializeDoctypeContent = void 0; -const parse5_1 = __nccwpck_require__(71943); -const domhandler_1 = __nccwpck_require__(85681); +const parse5_1 = __nccwpck_require__(43095); +const domhandler_1 = __nccwpck_require__(74038); function createTextNode(value) { return new domhandler_1.Text(value); } @@ -87028,14 +87021,14 @@ exports.adapter = { /***/ }), -/***/ 55906: +/***/ 97766: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.getDocumentMode = exports.isConforming = void 0; -const html_js_1 = __nccwpck_require__(45261); +const html_js_1 = __nccwpck_require__(54625); //Const const VALID_DOCTYPE_NAME = 'html'; const VALID_SYSTEM_ID = 'about:legacy-compat'; @@ -87155,7 +87148,7 @@ exports.getDocumentMode = getDocumentMode; /***/ }), -/***/ 55907: +/***/ 54215: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -87229,14 +87222,14 @@ var ERR; /***/ }), -/***/ 81716: +/***/ 69083: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.isIntegrationPoint = exports.adjustTokenSVGTagName = exports.adjustTokenXMLAttrs = exports.adjustTokenSVGAttrs = exports.adjustTokenMathMLAttrs = exports.causesExit = exports.SVG_TAG_NAMES_ADJUSTMENT_MAP = void 0; -const html_js_1 = __nccwpck_require__(45261); +const html_js_1 = __nccwpck_require__(54625); //MIME types const MIME_TYPES = { TEXT_HTML: 'text/html', @@ -87475,7 +87468,7 @@ exports.isIntegrationPoint = isIntegrationPoint; /***/ }), -/***/ 45261: +/***/ 54625: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -88011,7 +88004,7 @@ exports.hasUnescapedText = hasUnescapedText; /***/ }), -/***/ 47570: +/***/ 22517: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -88043,7 +88036,7 @@ exports.getTokenAttr = getTokenAttr; /***/ }), -/***/ 16438: +/***/ 36585: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -88127,31 +88120,31 @@ exports.isUndefinedCodePoint = isUndefinedCodePoint; /***/ }), -/***/ 71943: +/***/ 43095: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parseFragment = exports.parse = exports.TokenizerMode = exports.Tokenizer = exports.Token = exports.html = exports.foreignContent = exports.ErrorCodes = exports.serializeOuter = exports.serialize = exports.Parser = exports.defaultTreeAdapter = void 0; -const index_js_1 = __nccwpck_require__(91572); -var default_js_1 = __nccwpck_require__(47506); +const index_js_1 = __nccwpck_require__(66261); +var default_js_1 = __nccwpck_require__(153); Object.defineProperty(exports, "defaultTreeAdapter", ({ enumerable: true, get: function () { return default_js_1.defaultTreeAdapter; } })); -var index_js_2 = __nccwpck_require__(91572); +var index_js_2 = __nccwpck_require__(66261); Object.defineProperty(exports, "Parser", ({ enumerable: true, get: function () { return index_js_2.Parser; } })); -var index_js_3 = __nccwpck_require__(5277); +var index_js_3 = __nccwpck_require__(3094); Object.defineProperty(exports, "serialize", ({ enumerable: true, get: function () { return index_js_3.serialize; } })); Object.defineProperty(exports, "serializeOuter", ({ enumerable: true, get: function () { return index_js_3.serializeOuter; } })); -var error_codes_js_1 = __nccwpck_require__(55907); +var error_codes_js_1 = __nccwpck_require__(54215); Object.defineProperty(exports, "ErrorCodes", ({ enumerable: true, get: function () { return error_codes_js_1.ERR; } })); /** @internal */ -exports.foreignContent = __nccwpck_require__(81716); +exports.foreignContent = __nccwpck_require__(69083); /** @internal */ -exports.html = __nccwpck_require__(45261); +exports.html = __nccwpck_require__(54625); /** @internal */ -exports.Token = __nccwpck_require__(47570); +exports.Token = __nccwpck_require__(22517); /** @internal */ -var index_js_4 = __nccwpck_require__(50141); +var index_js_4 = __nccwpck_require__(11263); Object.defineProperty(exports, "Tokenizer", ({ enumerable: true, get: function () { return index_js_4.Tokenizer; } })); Object.defineProperty(exports, "TokenizerMode", ({ enumerable: true, get: function () { return index_js_4.TokenizerMode; } })); // Shorthands @@ -88191,7 +88184,7 @@ exports.parseFragment = parseFragment; /***/ }), -/***/ 74466: +/***/ 77552: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -88313,23 +88306,23 @@ exports.FormattingElementList = FormattingElementList; /***/ }), -/***/ 91572: +/***/ 66261: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Parser = void 0; -const index_js_1 = __nccwpck_require__(50141); -const open_element_stack_js_1 = __nccwpck_require__(15604); -const formatting_element_list_js_1 = __nccwpck_require__(74466); -const default_js_1 = __nccwpck_require__(47506); -const doctype = __nccwpck_require__(55906); -const foreignContent = __nccwpck_require__(81716); -const error_codes_js_1 = __nccwpck_require__(55907); -const unicode = __nccwpck_require__(16438); -const html_js_1 = __nccwpck_require__(45261); -const token_js_1 = __nccwpck_require__(47570); +const index_js_1 = __nccwpck_require__(11263); +const open_element_stack_js_1 = __nccwpck_require__(72012); +const formatting_element_list_js_1 = __nccwpck_require__(77552); +const default_js_1 = __nccwpck_require__(153); +const doctype = __nccwpck_require__(97766); +const foreignContent = __nccwpck_require__(69083); +const error_codes_js_1 = __nccwpck_require__(54215); +const unicode = __nccwpck_require__(36585); +const html_js_1 = __nccwpck_require__(54625); +const token_js_1 = __nccwpck_require__(22517); //Misc constants const HIDDEN_INPUT_TYPE = 'hidden'; //Adoption agency loops iteration count @@ -91483,14 +91476,14 @@ function endTagInForeignContent(p, token) { /***/ }), -/***/ 15604: +/***/ 72012: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.OpenElementStack = void 0; -const html_js_1 = __nccwpck_require__(45261); +const html_js_1 = __nccwpck_require__(54625); //Element utils const IMPLICIT_END_TAG_REQUIRED = new Set([html_js_1.TAG_ID.DD, html_js_1.TAG_ID.DT, html_js_1.TAG_ID.LI, html_js_1.TAG_ID.OPTGROUP, html_js_1.TAG_ID.OPTION, html_js_1.TAG_ID.P, html_js_1.TAG_ID.RB, html_js_1.TAG_ID.RP, html_js_1.TAG_ID.RT, html_js_1.TAG_ID.RTC]); const IMPLICIT_END_TAG_REQUIRED_THOROUGHLY = new Set([ @@ -91806,16 +91799,16 @@ exports.OpenElementStack = OpenElementStack; /***/ }), -/***/ 5277: +/***/ 3094: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.serializeOuter = exports.serialize = void 0; -const html_js_1 = __nccwpck_require__(45261); -const escape_js_1 = __nccwpck_require__(16484); -const default_js_1 = __nccwpck_require__(47506); +const html_js_1 = __nccwpck_require__(54625); +const escape_js_1 = __nccwpck_require__(37654); +const default_js_1 = __nccwpck_require__(153); // Sets const VOID_ELEMENTS = new Set([ html_js_1.TAG_NAMES.AREA, @@ -91986,19 +91979,19 @@ function serializeDocumentTypeNode(node, { treeAdapter }) { /***/ }), -/***/ 50141: +/***/ 11263: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Tokenizer = exports.TokenizerMode = void 0; -const preprocessor_js_1 = __nccwpck_require__(89839); -const unicode_js_1 = __nccwpck_require__(16438); -const token_js_1 = __nccwpck_require__(47570); -const decode_js_1 = __nccwpck_require__(83942); -const error_codes_js_1 = __nccwpck_require__(55907); -const html_js_1 = __nccwpck_require__(45261); +const preprocessor_js_1 = __nccwpck_require__(48245); +const unicode_js_1 = __nccwpck_require__(36585); +const token_js_1 = __nccwpck_require__(22517); +const decode_js_1 = __nccwpck_require__(85107); +const error_codes_js_1 = __nccwpck_require__(54215); +const html_js_1 = __nccwpck_require__(54625); //C1 Unicode control character reference replacements const C1_CONTROLS_REFERENCE_REPLACEMENTS = new Map([ [0x80, 8364], @@ -94901,15 +94894,15 @@ exports.Tokenizer = Tokenizer; /***/ }), -/***/ 89839: +/***/ 48245: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Preprocessor = void 0; -const unicode_js_1 = __nccwpck_require__(16438); -const error_codes_js_1 = __nccwpck_require__(55907); +const unicode_js_1 = __nccwpck_require__(36585); +const error_codes_js_1 = __nccwpck_require__(54215); //Const const DEFAULT_BUFFER_WATERLINE = 1 << 16; //Preprocessor @@ -95107,14 +95100,14 @@ exports.Preprocessor = Preprocessor; /***/ }), -/***/ 47506: +/***/ 153: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.defaultTreeAdapter = void 0; -const html_js_1 = __nccwpck_require__(45261); +const html_js_1 = __nccwpck_require__(54625); function createTextNode(value) { return { nodeName: '#text', @@ -95291,7 +95284,7 @@ exports.defaultTreeAdapter = { /***/ }), -/***/ 3208: +/***/ 51081: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -95321,7 +95314,7 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.PathScurry = exports.Path = exports.PathScurryDarwin = exports.PathScurryPosix = exports.PathScurryWin32 = exports.PathScurryBase = exports.PathPosix = exports.PathWin32 = exports.PathBase = exports.ChildrenCache = exports.ResolveCache = void 0; -const lru_cache_1 = __nccwpck_require__(21132); +const lru_cache_1 = __nccwpck_require__(73866); const node_path_1 = __nccwpck_require__(49411); const node_url_1 = __nccwpck_require__(41041); const fs_1 = __nccwpck_require__(57147); @@ -95330,7 +95323,7 @@ const realpathSync = fs_1.realpathSync.native; // TODO: test perf of fs/promises realpath vs realpathCB, // since the promises one uses realpath.native const promises_1 = __nccwpck_require__(93977); -const minipass_1 = __nccwpck_require__(52214); +const minipass_1 = __nccwpck_require__(14968); const defaultFS = { lstatSync: fs_1.lstatSync, readdir: fs_1.readdir, @@ -97312,7 +97305,7 @@ exports.PathScurry = process.platform === 'win32' ? PathScurryWin32 /***/ }), -/***/ 2571: +/***/ 92562: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -97353,14 +97346,14 @@ exports.getDefaultOptions = getDefaultOptions; /***/ }), -/***/ 35823: +/***/ 71214: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.getRefs = void 0; -const Options_js_1 = __nccwpck_require__(2571); +const Options_js_1 = __nccwpck_require__(92562); const getRefs = (options) => { const _options = (0, Options_js_1.getDefaultOptions)(options); const currentPath = _options.name !== undefined @@ -97386,7 +97379,7 @@ exports.getRefs = getRefs; /***/ }), -/***/ 76711: +/***/ 9055: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -97413,7 +97406,7 @@ exports.setResponseValueAndErrors = setResponseValueAndErrors; /***/ }), -/***/ 40823: +/***/ 9582: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -97433,86 +97426,86 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) { for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); }; Object.defineProperty(exports, "__esModule", ({ value: true })); -__exportStar(__nccwpck_require__(2571), exports); -__exportStar(__nccwpck_require__(35823), exports); -__exportStar(__nccwpck_require__(76711), exports); -__exportStar(__nccwpck_require__(10582), exports); -__exportStar(__nccwpck_require__(18462), exports); -__exportStar(__nccwpck_require__(28467), exports); -__exportStar(__nccwpck_require__(15074), exports); -__exportStar(__nccwpck_require__(77050), exports); -__exportStar(__nccwpck_require__(28500), exports); -__exportStar(__nccwpck_require__(27834), exports); -__exportStar(__nccwpck_require__(3886), exports); -__exportStar(__nccwpck_require__(29047), exports); -__exportStar(__nccwpck_require__(32694), exports); -__exportStar(__nccwpck_require__(34563), exports); -__exportStar(__nccwpck_require__(18330), exports); -__exportStar(__nccwpck_require__(6775), exports); -__exportStar(__nccwpck_require__(84908), exports); -__exportStar(__nccwpck_require__(12218), exports); -__exportStar(__nccwpck_require__(51783), exports); -__exportStar(__nccwpck_require__(21724), exports); -__exportStar(__nccwpck_require__(92191), exports); -__exportStar(__nccwpck_require__(96666), exports); -__exportStar(__nccwpck_require__(29235), exports); -__exportStar(__nccwpck_require__(60993), exports); -__exportStar(__nccwpck_require__(944), exports); -__exportStar(__nccwpck_require__(94558), exports); -__exportStar(__nccwpck_require__(85995), exports); -__exportStar(__nccwpck_require__(63783), exports); -__exportStar(__nccwpck_require__(47135), exports); -__exportStar(__nccwpck_require__(21036), exports); -__exportStar(__nccwpck_require__(61392), exports); -__exportStar(__nccwpck_require__(44920), exports); -__exportStar(__nccwpck_require__(24401), exports); -__exportStar(__nccwpck_require__(13544), exports); -__exportStar(__nccwpck_require__(97746), exports); -const zodToJsonSchema_js_1 = __nccwpck_require__(97746); +__exportStar(__nccwpck_require__(92562), exports); +__exportStar(__nccwpck_require__(71214), exports); +__exportStar(__nccwpck_require__(9055), exports); +__exportStar(__nccwpck_require__(34222), exports); +__exportStar(__nccwpck_require__(34014), exports); +__exportStar(__nccwpck_require__(16561), exports); +__exportStar(__nccwpck_require__(25015), exports); +__exportStar(__nccwpck_require__(51257), exports); +__exportStar(__nccwpck_require__(39768), exports); +__exportStar(__nccwpck_require__(22949), exports); +__exportStar(__nccwpck_require__(74049), exports); +__exportStar(__nccwpck_require__(16825), exports); +__exportStar(__nccwpck_require__(91474), exports); +__exportStar(__nccwpck_require__(30193), exports); +__exportStar(__nccwpck_require__(47166), exports); +__exportStar(__nccwpck_require__(36313), exports); +__exportStar(__nccwpck_require__(79773), exports); +__exportStar(__nccwpck_require__(22286), exports); +__exportStar(__nccwpck_require__(47870), exports); +__exportStar(__nccwpck_require__(91546), exports); +__exportStar(__nccwpck_require__(46143), exports); +__exportStar(__nccwpck_require__(45434), exports); +__exportStar(__nccwpck_require__(29833), exports); +__exportStar(__nccwpck_require__(13186), exports); +__exportStar(__nccwpck_require__(13451), exports); +__exportStar(__nccwpck_require__(90171), exports); +__exportStar(__nccwpck_require__(95407), exports); +__exportStar(__nccwpck_require__(69530), exports); +__exportStar(__nccwpck_require__(48276), exports); +__exportStar(__nccwpck_require__(78931), exports); +__exportStar(__nccwpck_require__(93476), exports); +__exportStar(__nccwpck_require__(45253), exports); +__exportStar(__nccwpck_require__(31079), exports); +__exportStar(__nccwpck_require__(26055), exports); +__exportStar(__nccwpck_require__(71146), exports); +const zodToJsonSchema_js_1 = __nccwpck_require__(71146); exports["default"] = zodToJsonSchema_js_1.zodToJsonSchema; /***/ }), -/***/ 10582: +/***/ 34222: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parseDef = void 0; -const zod_1 = __nccwpck_require__(2180); -const any_js_1 = __nccwpck_require__(18462); -const array_js_1 = __nccwpck_require__(28467); -const bigint_js_1 = __nccwpck_require__(15074); -const boolean_js_1 = __nccwpck_require__(77050); -const branded_js_1 = __nccwpck_require__(28500); -const catch_js_1 = __nccwpck_require__(27834); -const date_js_1 = __nccwpck_require__(3886); -const default_js_1 = __nccwpck_require__(29047); -const effects_js_1 = __nccwpck_require__(32694); -const enum_js_1 = __nccwpck_require__(34563); -const intersection_js_1 = __nccwpck_require__(18330); -const literal_js_1 = __nccwpck_require__(6775); -const map_js_1 = __nccwpck_require__(84908); -const nativeEnum_js_1 = __nccwpck_require__(12218); -const never_js_1 = __nccwpck_require__(51783); -const null_js_1 = __nccwpck_require__(21724); -const nullable_js_1 = __nccwpck_require__(92191); -const number_js_1 = __nccwpck_require__(96666); -const object_js_1 = __nccwpck_require__(29235); -const optional_js_1 = __nccwpck_require__(60993); -const pipeline_js_1 = __nccwpck_require__(944); -const promise_js_1 = __nccwpck_require__(94558); -const record_js_1 = __nccwpck_require__(63783); -const set_js_1 = __nccwpck_require__(47135); -const string_js_1 = __nccwpck_require__(21036); -const tuple_js_1 = __nccwpck_require__(61392); -const undefined_js_1 = __nccwpck_require__(44920); -const union_js_1 = __nccwpck_require__(24401); -const unknown_js_1 = __nccwpck_require__(13544); -const readonly_js_1 = __nccwpck_require__(85995); -const Options_js_1 = __nccwpck_require__(2571); +const zod_1 = __nccwpck_require__(63301); +const any_js_1 = __nccwpck_require__(34014); +const array_js_1 = __nccwpck_require__(16561); +const bigint_js_1 = __nccwpck_require__(25015); +const boolean_js_1 = __nccwpck_require__(51257); +const branded_js_1 = __nccwpck_require__(39768); +const catch_js_1 = __nccwpck_require__(22949); +const date_js_1 = __nccwpck_require__(74049); +const default_js_1 = __nccwpck_require__(16825); +const effects_js_1 = __nccwpck_require__(91474); +const enum_js_1 = __nccwpck_require__(30193); +const intersection_js_1 = __nccwpck_require__(47166); +const literal_js_1 = __nccwpck_require__(36313); +const map_js_1 = __nccwpck_require__(79773); +const nativeEnum_js_1 = __nccwpck_require__(22286); +const never_js_1 = __nccwpck_require__(47870); +const null_js_1 = __nccwpck_require__(91546); +const nullable_js_1 = __nccwpck_require__(46143); +const number_js_1 = __nccwpck_require__(45434); +const object_js_1 = __nccwpck_require__(29833); +const optional_js_1 = __nccwpck_require__(13186); +const pipeline_js_1 = __nccwpck_require__(13451); +const promise_js_1 = __nccwpck_require__(90171); +const record_js_1 = __nccwpck_require__(69530); +const set_js_1 = __nccwpck_require__(48276); +const string_js_1 = __nccwpck_require__(78931); +const tuple_js_1 = __nccwpck_require__(93476); +const undefined_js_1 = __nccwpck_require__(45253); +const union_js_1 = __nccwpck_require__(31079); +const unknown_js_1 = __nccwpck_require__(26055); +const readonly_js_1 = __nccwpck_require__(95407); +const Options_js_1 = __nccwpck_require__(92562); function parseDef(def, refs, forceResolution = false) { const seenItem = refs.seen.get(def); if (refs.override) { @@ -97649,7 +97642,7 @@ const addMeta = (def, refs, jsonSchema) => { /***/ }), -/***/ 18462: +/***/ 34014: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -97664,16 +97657,16 @@ exports.parseAnyDef = parseAnyDef; /***/ }), -/***/ 28467: +/***/ 16561: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parseArrayDef = void 0; -const zod_1 = __nccwpck_require__(2180); -const errorMessages_js_1 = __nccwpck_require__(76711); -const parseDef_js_1 = __nccwpck_require__(10582); +const zod_1 = __nccwpck_require__(63301); +const errorMessages_js_1 = __nccwpck_require__(9055); +const parseDef_js_1 = __nccwpck_require__(34222); function parseArrayDef(def, refs) { const res = { type: "array", @@ -97701,14 +97694,14 @@ exports.parseArrayDef = parseArrayDef; /***/ }), -/***/ 15074: +/***/ 25015: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parseBigintDef = void 0; -const errorMessages_js_1 = __nccwpck_require__(76711); +const errorMessages_js_1 = __nccwpck_require__(9055); function parseBigintDef(def, refs) { const res = { type: "integer", @@ -97762,7 +97755,7 @@ exports.parseBigintDef = parseBigintDef; /***/ }), -/***/ 77050: +/***/ 51257: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -97779,14 +97772,14 @@ exports.parseBooleanDef = parseBooleanDef; /***/ }), -/***/ 28500: +/***/ 39768: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parseBrandedDef = void 0; -const parseDef_js_1 = __nccwpck_require__(10582); +const parseDef_js_1 = __nccwpck_require__(34222); function parseBrandedDef(_def, refs) { return (0, parseDef_js_1.parseDef)(_def.type._def, refs); } @@ -97795,14 +97788,14 @@ exports.parseBrandedDef = parseBrandedDef; /***/ }), -/***/ 27834: +/***/ 22949: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parseCatchDef = void 0; -const parseDef_js_1 = __nccwpck_require__(10582); +const parseDef_js_1 = __nccwpck_require__(34222); const parseCatchDef = (def, refs) => { return (0, parseDef_js_1.parseDef)(def.innerType._def, refs); }; @@ -97811,14 +97804,14 @@ exports.parseCatchDef = parseCatchDef; /***/ }), -/***/ 3886: +/***/ 74049: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parseDateDef = void 0; -const errorMessages_js_1 = __nccwpck_require__(76711); +const errorMessages_js_1 = __nccwpck_require__(9055); function parseDateDef(def, refs, overrideDateStrategy) { const strategy = overrideDateStrategy ?? refs.dateStrategy; if (Array.isArray(strategy)) { @@ -97869,14 +97862,14 @@ const integerDateParser = (def, refs) => { /***/ }), -/***/ 29047: +/***/ 16825: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parseDefaultDef = void 0; -const parseDef_js_1 = __nccwpck_require__(10582); +const parseDef_js_1 = __nccwpck_require__(34222); function parseDefaultDef(_def, refs) { return { ...(0, parseDef_js_1.parseDef)(_def.innerType._def, refs), @@ -97888,14 +97881,14 @@ exports.parseDefaultDef = parseDefaultDef; /***/ }), -/***/ 32694: +/***/ 91474: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parseEffectsDef = void 0; -const parseDef_js_1 = __nccwpck_require__(10582); +const parseDef_js_1 = __nccwpck_require__(34222); function parseEffectsDef(_def, refs) { return refs.effectStrategy === "input" ? (0, parseDef_js_1.parseDef)(_def.schema._def, refs) @@ -97906,7 +97899,7 @@ exports.parseEffectsDef = parseEffectsDef; /***/ }), -/***/ 34563: +/***/ 30193: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -97924,14 +97917,14 @@ exports.parseEnumDef = parseEnumDef; /***/ }), -/***/ 18330: +/***/ 47166: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parseIntersectionDef = void 0; -const parseDef_js_1 = __nccwpck_require__(10582); +const parseDef_js_1 = __nccwpck_require__(34222); const isJsonSchema7AllOfType = (type) => { if ("type" in type && type.type === "string") return false; @@ -97988,7 +97981,7 @@ exports.parseIntersectionDef = parseIntersectionDef; /***/ }), -/***/ 6775: +/***/ 36313: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -98021,15 +98014,15 @@ exports.parseLiteralDef = parseLiteralDef; /***/ }), -/***/ 84908: +/***/ 79773: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parseMapDef = void 0; -const parseDef_js_1 = __nccwpck_require__(10582); -const record_js_1 = __nccwpck_require__(63783); +const parseDef_js_1 = __nccwpck_require__(34222); +const record_js_1 = __nccwpck_require__(69530); function parseMapDef(def, refs) { if (refs.mapStrategy === "record") { return (0, record_js_1.parseRecordDef)(def, refs); @@ -98058,7 +98051,7 @@ exports.parseMapDef = parseMapDef; /***/ }), -/***/ 12218: +/***/ 22286: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -98086,7 +98079,7 @@ exports.parseNativeEnumDef = parseNativeEnumDef; /***/ }), -/***/ 51783: +/***/ 47870: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -98103,7 +98096,7 @@ exports.parseNeverDef = parseNeverDef; /***/ }), -/***/ 21724: +/***/ 91546: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -98125,15 +98118,15 @@ exports.parseNullDef = parseNullDef; /***/ }), -/***/ 92191: +/***/ 46143: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parseNullableDef = void 0; -const parseDef_js_1 = __nccwpck_require__(10582); -const union_js_1 = __nccwpck_require__(24401); +const parseDef_js_1 = __nccwpck_require__(34222); +const union_js_1 = __nccwpck_require__(31079); function parseNullableDef(def, refs) { if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(def.innerType._def.typeName) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) { @@ -98170,14 +98163,14 @@ exports.parseNullableDef = parseNullableDef; /***/ }), -/***/ 96666: +/***/ 45434: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parseNumberDef = void 0; -const errorMessages_js_1 = __nccwpck_require__(76711); +const errorMessages_js_1 = __nccwpck_require__(9055); function parseNumberDef(def, refs) { const res = { type: "number", @@ -98234,14 +98227,14 @@ exports.parseNumberDef = parseNumberDef; /***/ }), -/***/ 29235: +/***/ 29833: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parseObjectDef = exports.parseObjectDefX = void 0; -const parseDef_js_1 = __nccwpck_require__(10582); +const parseDef_js_1 = __nccwpck_require__(34222); function decideAdditionalProperties(def, refs) { if (refs.removeAdditionalStrategy === "strict") { return def.catchall._def.typeName === "ZodNever" @@ -98345,14 +98338,14 @@ exports.parseObjectDef = parseObjectDef; /***/ }), -/***/ 60993: +/***/ 13186: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parseOptionalDef = void 0; -const parseDef_js_1 = __nccwpck_require__(10582); +const parseDef_js_1 = __nccwpck_require__(34222); const parseOptionalDef = (def, refs) => { if (refs.currentPath.toString() === refs.propertyPath?.toString()) { return (0, parseDef_js_1.parseDef)(def.innerType._def, refs); @@ -98377,14 +98370,14 @@ exports.parseOptionalDef = parseOptionalDef; /***/ }), -/***/ 944: +/***/ 13451: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parsePipelineDef = void 0; -const parseDef_js_1 = __nccwpck_require__(10582); +const parseDef_js_1 = __nccwpck_require__(34222); const parsePipelineDef = (def, refs) => { if (refs.pipeStrategy === "input") { return (0, parseDef_js_1.parseDef)(def.in._def, refs); @@ -98409,14 +98402,14 @@ exports.parsePipelineDef = parsePipelineDef; /***/ }), -/***/ 94558: +/***/ 90171: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parsePromiseDef = void 0; -const parseDef_js_1 = __nccwpck_require__(10582); +const parseDef_js_1 = __nccwpck_require__(34222); function parsePromiseDef(def, refs) { return (0, parseDef_js_1.parseDef)(def.type._def, refs); } @@ -98425,14 +98418,14 @@ exports.parsePromiseDef = parsePromiseDef; /***/ }), -/***/ 85995: +/***/ 95407: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parseReadonlyDef = void 0; -const parseDef_js_1 = __nccwpck_require__(10582); +const parseDef_js_1 = __nccwpck_require__(34222); const parseReadonlyDef = (def, refs) => { return (0, parseDef_js_1.parseDef)(def.innerType._def, refs); }; @@ -98441,16 +98434,16 @@ exports.parseReadonlyDef = parseReadonlyDef; /***/ }), -/***/ 63783: +/***/ 69530: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parseRecordDef = void 0; -const zod_1 = __nccwpck_require__(2180); -const parseDef_js_1 = __nccwpck_require__(10582); -const string_js_1 = __nccwpck_require__(21036); +const zod_1 = __nccwpck_require__(63301); +const parseDef_js_1 = __nccwpck_require__(34222); +const string_js_1 = __nccwpck_require__(78931); function parseRecordDef(def, refs) { if (refs.target === "openApi3" && def.keyType?._def.typeName === zod_1.ZodFirstPartyTypeKind.ZodEnum) { @@ -98500,15 +98493,15 @@ exports.parseRecordDef = parseRecordDef; /***/ }), -/***/ 47135: +/***/ 48276: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parseSetDef = void 0; -const errorMessages_js_1 = __nccwpck_require__(76711); -const parseDef_js_1 = __nccwpck_require__(10582); +const errorMessages_js_1 = __nccwpck_require__(9055); +const parseDef_js_1 = __nccwpck_require__(34222); function parseSetDef(def, refs) { const items = (0, parseDef_js_1.parseDef)(def.valueType._def, { ...refs, @@ -98532,14 +98525,14 @@ exports.parseSetDef = parseSetDef; /***/ }), -/***/ 21036: +/***/ 78931: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parseStringDef = exports.zodPatterns = void 0; -const errorMessages_js_1 = __nccwpck_require__(76711); +const errorMessages_js_1 = __nccwpck_require__(9055); /** * Generated from the .source property of regular expressins found here: * https://github.com/colinhacks/zod/blob/master/src/types.ts. @@ -98770,14 +98763,14 @@ const addPattern = (schema, value, message, refs) => { /***/ }), -/***/ 61392: +/***/ 93476: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parseTupleDef = void 0; -const parseDef_js_1 = __nccwpck_require__(10582); +const parseDef_js_1 = __nccwpck_require__(34222); function parseTupleDef(def, refs) { if (def.rest) { return { @@ -98814,7 +98807,7 @@ exports.parseTupleDef = parseTupleDef; /***/ }), -/***/ 44920: +/***/ 45253: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -98831,14 +98824,14 @@ exports.parseUndefinedDef = parseUndefinedDef; /***/ }), -/***/ 24401: +/***/ 31079: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parseUnionDef = exports.primitiveMappings = void 0; -const parseDef_js_1 = __nccwpck_require__(10582); +const parseDef_js_1 = __nccwpck_require__(34222); exports.primitiveMappings = { ZodString: "string", ZodNumber: "number", @@ -98923,7 +98916,7 @@ const asAnyOf = (def, refs) => { /***/ }), -/***/ 13544: +/***/ 26055: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -98938,15 +98931,15 @@ exports.parseUnknownDef = parseUnknownDef; /***/ }), -/***/ 97746: +/***/ 71146: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.zodToJsonSchema = void 0; -const parseDef_js_1 = __nccwpck_require__(10582); -const Refs_js_1 = __nccwpck_require__(35823); +const parseDef_js_1 = __nccwpck_require__(34222); +const Refs_js_1 = __nccwpck_require__(71214); const zodToJsonSchema = (schema, options) => { const refs = (0, Refs_js_1.getRefs)(options); const definitions = typeof options === "object" && options.definitions @@ -98996,15 +98989,15 @@ exports.zodToJsonSchema = zodToJsonSchema; /***/ }), -/***/ 41055: +/***/ 92442: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.InMemoryCache = exports.BaseCache = exports.serializeGeneration = exports.deserializeStoredGeneration = exports.getCacheKey = void 0; -const hash_js_1 = __nccwpck_require__(30326); -const index_js_1 = __nccwpck_require__(69772); +const hash_js_1 = __nccwpck_require__(8612); +const index_js_1 = __nccwpck_require__(56446); /** * This cache key should be consistent across all versions of langchain. * It is currently NOT consistent across versions of langchain. @@ -99093,7 +99086,7 @@ exports.InMemoryCache = InMemoryCache; /***/ }), -/***/ 4280: +/***/ 30243: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -99123,9 +99116,9 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.BaseCallbackHandler = void 0; -const uuid = __importStar(__nccwpck_require__(40053)); -const serializable_js_1 = __nccwpck_require__(37862); -const env_js_1 = __nccwpck_require__(14836); +const uuid = __importStar(__nccwpck_require__(75840)); +const serializable_js_1 = __nccwpck_require__(50413); +const env_js_1 = __nccwpck_require__(74301); /** * Abstract class that provides a set of optional methods that can be * overridden in derived classes to handle various events during the @@ -99261,21 +99254,21 @@ exports.BaseCallbackHandler = BaseCallbackHandler; /***/ }), -/***/ 73986: +/***/ 34853: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.traceAsGroup = exports.TraceGroup = exports.ensureHandler = exports.CallbackManager = exports.CallbackManagerForToolRun = exports.CallbackManagerForChainRun = exports.CallbackManagerForLLMRun = exports.CallbackManagerForRetrieverRun = exports.BaseCallbackManager = exports.parseCallbackConfigArg = void 0; -const uuid_1 = __nccwpck_require__(40053); -const base_js_1 = __nccwpck_require__(4280); -const console_js_1 = __nccwpck_require__(5796); -const initialize_js_1 = __nccwpck_require__(64550); -const index_js_1 = __nccwpck_require__(69772); -const env_js_1 = __nccwpck_require__(14836); -const tracer_langchain_js_1 = __nccwpck_require__(85421); -const promises_js_1 = __nccwpck_require__(69523); +const uuid_1 = __nccwpck_require__(75840); +const base_js_1 = __nccwpck_require__(30243); +const console_js_1 = __nccwpck_require__(97718); +const initialize_js_1 = __nccwpck_require__(67807); +const index_js_1 = __nccwpck_require__(56446); +const env_js_1 = __nccwpck_require__(74301); +const tracer_langchain_js_1 = __nccwpck_require__(60974); +const promises_js_1 = __nccwpck_require__(55405); if ( /* #__PURE__ */ (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_TRACING_V2") === "true" && /* #__PURE__ */ (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_CALLBACKS_BACKGROUND") !== @@ -100020,7 +100013,7 @@ exports.traceAsGroup = traceAsGroup; /***/ }), -/***/ 69523: +/***/ 55405: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -100030,7 +100023,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.awaitAllCallbacks = exports.consumeCallback = void 0; -const p_queue_1 = __importDefault(__nccwpck_require__(518)); +const p_queue_1 = __importDefault(__nccwpck_require__(28983)); let queue; /** * Creates a queue using the p-queue library. The queue is configured to @@ -100073,14 +100066,14 @@ exports.awaitAllCallbacks = awaitAllCallbacks; /***/ }), -/***/ 57739: +/***/ 69000: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Embeddings = void 0; -const async_caller_js_1 = __nccwpck_require__(70140); +const async_caller_js_1 = __nccwpck_require__(37264); /** * An abstract class that provides methods for embedding documents and * queries using LangChain. @@ -100105,19 +100098,19 @@ exports.Embeddings = Embeddings; /***/ }), -/***/ 10792: +/***/ 56663: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.BaseLanguageModel = exports.BaseLangChain = exports.calculateMaxTokens = exports.getModelContextSize = exports.getEmbeddingContextSize = exports.getModelNameForTiktoken = void 0; -const caches_js_1 = __nccwpck_require__(41055); -const prompt_values_js_1 = __nccwpck_require__(68018); -const index_js_1 = __nccwpck_require__(69772); -const async_caller_js_1 = __nccwpck_require__(70140); -const tiktoken_js_1 = __nccwpck_require__(76028); -const base_js_1 = __nccwpck_require__(46105); +const caches_js_1 = __nccwpck_require__(92442); +const prompt_values_js_1 = __nccwpck_require__(57125); +const index_js_1 = __nccwpck_require__(56446); +const async_caller_js_1 = __nccwpck_require__(37264); +const tiktoken_js_1 = __nccwpck_require__(6186); +const base_js_1 = __nccwpck_require__(87733); // https://www.npmjs.com/package/js-tiktoken const getModelNameForTiktoken = (modelName) => { if (modelName.startsWith("gpt-3.5-turbo-16k")) { @@ -100375,17 +100368,17 @@ exports.BaseLanguageModel = BaseLanguageModel; /***/ }), -/***/ 16853: +/***/ 41717: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.SimpleChatModel = exports.BaseChatModel = exports.createChatMessageChunkEncoderStream = void 0; -const index_js_1 = __nccwpck_require__(69772); -const outputs_js_1 = __nccwpck_require__(6141); -const base_js_1 = __nccwpck_require__(10792); -const manager_js_1 = __nccwpck_require__(73986); +const index_js_1 = __nccwpck_require__(56446); +const outputs_js_1 = __nccwpck_require__(13722); +const base_js_1 = __nccwpck_require__(56663); +const manager_js_1 = __nccwpck_require__(34853); /** * Creates a transform stream for encoding chat message chunks. * @deprecated Use {@link BytesOutputParser} instead @@ -100784,17 +100777,17 @@ exports.SimpleChatModel = SimpleChatModel; /***/ }), -/***/ 26644: +/***/ 53013: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.LLM = exports.BaseLLM = void 0; -const index_js_1 = __nccwpck_require__(69772); -const outputs_js_1 = __nccwpck_require__(6141); -const manager_js_1 = __nccwpck_require__(73986); -const base_js_1 = __nccwpck_require__(10792); +const index_js_1 = __nccwpck_require__(56446); +const outputs_js_1 = __nccwpck_require__(13722); +const manager_js_1 = __nccwpck_require__(34853); +const base_js_1 = __nccwpck_require__(56663); /** * LLM Wrapper. Takes in a prompt (or prompts) and returns a string. */ @@ -101119,7 +101112,7 @@ exports.LLM = LLM; /***/ }), -/***/ 34552: +/***/ 59152: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -101129,8 +101122,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.mapKeys = exports.keyFromJson = exports.keyToJson = void 0; -const decamelize_1 = __importDefault(__nccwpck_require__(62984)); -const camelcase_1 = __importDefault(__nccwpck_require__(64661)); +const decamelize_1 = __importDefault(__nccwpck_require__(70159)); +const camelcase_1 = __importDefault(__nccwpck_require__(21362)); function keyToJson(key, map) { return map?.[key] || (0, decamelize_1.default)(key); } @@ -101153,14 +101146,14 @@ exports.mapKeys = mapKeys; /***/ }), -/***/ 37862: +/***/ 50413: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Serializable = exports.get_lc_unique_name = void 0; -const map_keys_js_1 = __nccwpck_require__(34552); +const map_keys_js_1 = __nccwpck_require__(59152); function shallowCopy(obj) { return Array.isArray(obj) ? [...obj] : { ...obj }; } @@ -101341,16 +101334,16 @@ exports.Serializable = Serializable; /***/ }), -/***/ 43337: +/***/ 26881: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.AIMessageChunk = exports.isAIMessage = exports.AIMessage = void 0; -const json_js_1 = __nccwpck_require__(8840); -const base_js_1 = __nccwpck_require__(37551); -const tool_js_1 = __nccwpck_require__(13321); +const json_js_1 = __nccwpck_require__(3709); +const base_js_1 = __nccwpck_require__(70141); +const tool_js_1 = __nccwpck_require__(80022); /** * Represents an AI message in a conversation. */ @@ -101562,14 +101555,14 @@ exports.AIMessageChunk = AIMessageChunk; /***/ }), -/***/ 37551: +/***/ 70141: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.isBaseMessageChunk = exports.isBaseMessage = exports.BaseMessageChunk = exports._mergeLists = exports._mergeDicts = exports.isOpenAIToolCallArray = exports.BaseMessage = exports.mergeContent = void 0; -const serializable_js_1 = __nccwpck_require__(37862); +const serializable_js_1 = __nccwpck_require__(50413); function mergeContent(firstContent, secondContent) { // If first content is a string if (typeof firstContent === "string") { @@ -101782,14 +101775,14 @@ exports.isBaseMessageChunk = isBaseMessageChunk; /***/ }), -/***/ 60000: +/***/ 69080: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.ChatMessageChunk = exports.ChatMessage = void 0; -const base_js_1 = __nccwpck_require__(37551); +const base_js_1 = __nccwpck_require__(70141); /** * Represents a chat message in a conversation. */ @@ -101861,14 +101854,14 @@ exports.ChatMessageChunk = ChatMessageChunk; /***/ }), -/***/ 74595: +/***/ 17591: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.FunctionMessageChunk = exports.FunctionMessage = void 0; -const base_js_1 = __nccwpck_require__(37551); +const base_js_1 = __nccwpck_require__(70141); /** * Represents a function message in a conversation. */ @@ -101915,14 +101908,14 @@ exports.FunctionMessageChunk = FunctionMessageChunk; /***/ }), -/***/ 48442: +/***/ 62212: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.HumanMessageChunk = exports.HumanMessage = void 0; -const base_js_1 = __nccwpck_require__(37551); +const base_js_1 = __nccwpck_require__(70141); /** * Represents a human message in a conversation. */ @@ -101959,7 +101952,7 @@ exports.HumanMessageChunk = HumanMessageChunk; /***/ }), -/***/ 69772: +/***/ 56446: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -101980,30 +101973,30 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.ToolMessageChunk = exports.ToolMessage = void 0; -__exportStar(__nccwpck_require__(43337), exports); -__exportStar(__nccwpck_require__(37551), exports); -__exportStar(__nccwpck_require__(60000), exports); -__exportStar(__nccwpck_require__(74595), exports); -__exportStar(__nccwpck_require__(48442), exports); -__exportStar(__nccwpck_require__(86229), exports); -__exportStar(__nccwpck_require__(95520), exports); +__exportStar(__nccwpck_require__(26881), exports); +__exportStar(__nccwpck_require__(70141), exports); +__exportStar(__nccwpck_require__(69080), exports); +__exportStar(__nccwpck_require__(17591), exports); +__exportStar(__nccwpck_require__(62212), exports); +__exportStar(__nccwpck_require__(33654), exports); +__exportStar(__nccwpck_require__(3595), exports); // TODO: Use a star export when we deprecate the // existing "ToolCall" type in "base.js". -var tool_js_1 = __nccwpck_require__(13321); +var tool_js_1 = __nccwpck_require__(80022); Object.defineProperty(exports, "ToolMessage", ({ enumerable: true, get: function () { return tool_js_1.ToolMessage; } })); Object.defineProperty(exports, "ToolMessageChunk", ({ enumerable: true, get: function () { return tool_js_1.ToolMessageChunk; } })); /***/ }), -/***/ 86229: +/***/ 33654: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.SystemMessageChunk = exports.SystemMessage = void 0; -const base_js_1 = __nccwpck_require__(37551); +const base_js_1 = __nccwpck_require__(70141); /** * Represents a system message in a conversation. */ @@ -102040,14 +102033,14 @@ exports.SystemMessageChunk = SystemMessageChunk; /***/ }), -/***/ 13321: +/***/ 80022: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.defaultToolCallParser = exports.ToolMessageChunk = exports.ToolMessage = void 0; -const base_js_1 = __nccwpck_require__(37551); +const base_js_1 = __nccwpck_require__(70141); /** * Represents a tool message in a conversation. */ @@ -102149,20 +102142,20 @@ exports.defaultToolCallParser = defaultToolCallParser; /***/ }), -/***/ 95520: +/***/ 3595: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.convertToChunk = exports.mapChatMessagesToStoredMessages = exports.mapStoredMessagesToChatMessages = exports.mapStoredMessageToChatMessage = exports.getBufferString = exports.coerceMessageLikeToMessage = void 0; -const base_js_1 = __nccwpck_require__(37551); -const human_js_1 = __nccwpck_require__(48442); -const ai_js_1 = __nccwpck_require__(43337); -const system_js_1 = __nccwpck_require__(86229); -const chat_js_1 = __nccwpck_require__(60000); -const function_js_1 = __nccwpck_require__(74595); -const tool_js_1 = __nccwpck_require__(13321); +const base_js_1 = __nccwpck_require__(70141); +const human_js_1 = __nccwpck_require__(62212); +const ai_js_1 = __nccwpck_require__(26881); +const system_js_1 = __nccwpck_require__(33654); +const chat_js_1 = __nccwpck_require__(69080); +const function_js_1 = __nccwpck_require__(17591); +const tool_js_1 = __nccwpck_require__(80022); function coerceMessageLikeToMessage(messageLike) { if (typeof messageLike === "string") { return new human_js_1.HumanMessage(messageLike); @@ -102329,14 +102322,14 @@ exports.convertToChunk = convertToChunk; /***/ }), -/***/ 40605: +/***/ 4526: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.OutputParserException = exports.BaseOutputParser = exports.BaseLLMOutputParser = void 0; -const index_js_1 = __nccwpck_require__(2642); +const index_js_1 = __nccwpck_require__(90996); /** * Abstract base class for parsing the output of a Large Language Model * (LLM) call. It provides methods for parsing the result of an LLM call @@ -102459,14 +102452,14 @@ exports.OutputParserException = OutputParserException; /***/ }), -/***/ 20244: +/***/ 1717: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.BytesOutputParser = void 0; -const transform_js_1 = __nccwpck_require__(24815); +const transform_js_1 = __nccwpck_require__(55119); /** * OutputParser that parses LLMResult into the top likely string and * encodes it into bytes. @@ -102508,7 +102501,7 @@ exports.BytesOutputParser = BytesOutputParser; /***/ }), -/***/ 69360: +/***/ 95387: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -102528,28 +102521,28 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) { for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); }; Object.defineProperty(exports, "__esModule", ({ value: true })); -__exportStar(__nccwpck_require__(40605), exports); -__exportStar(__nccwpck_require__(20244), exports); -__exportStar(__nccwpck_require__(6103), exports); -__exportStar(__nccwpck_require__(59691), exports); -__exportStar(__nccwpck_require__(57662), exports); -__exportStar(__nccwpck_require__(24815), exports); -__exportStar(__nccwpck_require__(32656), exports); -__exportStar(__nccwpck_require__(59018), exports); +__exportStar(__nccwpck_require__(4526), exports); +__exportStar(__nccwpck_require__(1717), exports); +__exportStar(__nccwpck_require__(84994), exports); +__exportStar(__nccwpck_require__(77173), exports); +__exportStar(__nccwpck_require__(32375), exports); +__exportStar(__nccwpck_require__(55119), exports); +__exportStar(__nccwpck_require__(94781), exports); +__exportStar(__nccwpck_require__(48550), exports); /***/ }), -/***/ 32656: +/***/ 94781: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parseJsonMarkdown = exports.parsePartialJson = exports.JsonOutputParser = void 0; -const transform_js_1 = __nccwpck_require__(24815); -const json_patch_js_1 = __nccwpck_require__(43504); -const json_js_1 = __nccwpck_require__(8840); +const transform_js_1 = __nccwpck_require__(55119); +const json_patch_js_1 = __nccwpck_require__(11437); +const json_js_1 = __nccwpck_require__(3709); Object.defineProperty(exports, "parseJsonMarkdown", ({ enumerable: true, get: function () { return json_js_1.parseJsonMarkdown; } })); Object.defineProperty(exports, "parsePartialJson", ({ enumerable: true, get: function () { return json_js_1.parsePartialJson; } })); /** @@ -102600,15 +102593,15 @@ exports.JsonOutputParser = JsonOutputParser; /***/ }), -/***/ 6103: +/***/ 84994: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.MarkdownListOutputParser = exports.NumberedListOutputParser = exports.CustomListOutputParser = exports.CommaSeparatedListOutputParser = exports.ListOutputParser = void 0; -const base_js_1 = __nccwpck_require__(40605); -const transform_js_1 = __nccwpck_require__(24815); +const base_js_1 = __nccwpck_require__(4526); +const transform_js_1 = __nccwpck_require__(55119); /** * Class to parse the output of an LLM call to a list. * @augments BaseOutputParser @@ -102852,7 +102845,7 @@ exports.MarkdownListOutputParser = MarkdownListOutputParser; /***/ }), -/***/ 83968: +/***/ 38862: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -102872,20 +102865,20 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) { for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); }; Object.defineProperty(exports, "__esModule", ({ value: true })); -__exportStar(__nccwpck_require__(68021), exports); +__exportStar(__nccwpck_require__(35404), exports); /***/ }), -/***/ 68021: +/***/ 35404: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.JsonOutputKeyToolsParser = exports.JsonOutputToolsParser = exports.makeInvalidToolCall = exports.convertLangChainToolCallToOpenAI = exports.parseToolCall = void 0; -const base_js_1 = __nccwpck_require__(40605); -const json_js_1 = __nccwpck_require__(32656); +const base_js_1 = __nccwpck_require__(4526); +const json_js_1 = __nccwpck_require__(94781); function parseToolCall( // eslint-disable-next-line @typescript-eslint/no-explicit-any rawToolCall, options) { @@ -103114,14 +103107,14 @@ exports.JsonOutputKeyToolsParser = JsonOutputKeyToolsParser; /***/ }), -/***/ 59691: +/***/ 77173: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.StringOutputParser = void 0; -const transform_js_1 = __nccwpck_require__(24815); +const transform_js_1 = __nccwpck_require__(55119); /** * OutputParser that parses LLMResult into the top likely string. * @example @@ -103207,16 +103200,16 @@ exports.StringOutputParser = StringOutputParser; /***/ }), -/***/ 57662: +/***/ 32375: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.AsymmetricStructuredOutputParser = exports.JsonMarkdownStructuredOutputParser = exports.StructuredOutputParser = void 0; -const zod_1 = __nccwpck_require__(2180); -const zod_to_json_schema_1 = __nccwpck_require__(40823); -const base_js_1 = __nccwpck_require__(40605); +const zod_1 = __nccwpck_require__(63301); +const zod_to_json_schema_1 = __nccwpck_require__(9582); +const base_js_1 = __nccwpck_require__(4526); class StructuredOutputParser extends base_js_1.BaseOutputParser { static lc_name() { return "StructuredOutputParser"; @@ -103411,18 +103404,18 @@ exports.AsymmetricStructuredOutputParser = AsymmetricStructuredOutputParser; /***/ }), -/***/ 24815: +/***/ 55119: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.BaseCumulativeTransformOutputParser = exports.BaseTransformOutputParser = void 0; -const base_js_1 = __nccwpck_require__(40605); -const base_js_2 = __nccwpck_require__(37551); -const utils_js_1 = __nccwpck_require__(95520); -const outputs_js_1 = __nccwpck_require__(6141); -const index_js_1 = __nccwpck_require__(74775); +const base_js_1 = __nccwpck_require__(4526); +const base_js_2 = __nccwpck_require__(70141); +const utils_js_1 = __nccwpck_require__(3595); +const outputs_js_1 = __nccwpck_require__(13722); +const index_js_1 = __nccwpck_require__(14050); /** * Class to parse the output of an LLM call that also allows streaming inputs. */ @@ -103528,16 +103521,16 @@ exports.BaseCumulativeTransformOutputParser = BaseCumulativeTransformOutputParse /***/ }), -/***/ 59018: +/***/ 48550: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parseXMLMarkdown = exports.XMLOutputParser = exports.XML_FORMAT_INSTRUCTIONS = void 0; -const transform_js_1 = __nccwpck_require__(24815); -const json_patch_js_1 = __nccwpck_require__(43504); -const sax_js_1 = __nccwpck_require__(76861); +const transform_js_1 = __nccwpck_require__(55119); +const json_patch_js_1 = __nccwpck_require__(11437); +const sax_js_1 = __nccwpck_require__(10678); exports.XML_FORMAT_INSTRUCTIONS = `The output should be formatted as a XML file. 1. Output should conform to the tags below. 2. If tags are not given, make them on your own. @@ -103682,7 +103675,7 @@ exports.parseXMLMarkdown = parseXMLMarkdown; /***/ }), -/***/ 6141: +/***/ 13722: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -103749,15 +103742,15 @@ exports.ChatGenerationChunk = ChatGenerationChunk; /***/ }), -/***/ 68018: +/***/ 57125: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.ImagePromptValue = exports.ChatPromptValue = exports.StringPromptValue = exports.BasePromptValue = void 0; -const serializable_js_1 = __nccwpck_require__(37862); -const index_js_1 = __nccwpck_require__(69772); +const serializable_js_1 = __nccwpck_require__(50413); +const index_js_1 = __nccwpck_require__(56446); /** * Base PromptValue class. All prompt values should extend this class. */ @@ -103909,7 +103902,7 @@ exports.ImagePromptValue = ImagePromptValue; /***/ }), -/***/ 79511: +/***/ 62217: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -103918,7 +103911,7 @@ exports.ImagePromptValue = ImagePromptValue; // Replace with "string" when we are comfortable with a breaking change. Object.defineProperty(exports, "__esModule", ({ value: true })); exports.BasePromptTemplate = void 0; -const base_js_1 = __nccwpck_require__(46105); +const base_js_1 = __nccwpck_require__(87733); /** * Base class for prompt templates. Exposes a format method that returns a * string prompt given a set of input values. @@ -104017,15 +104010,15 @@ class BasePromptTemplate extends base_js_1.Runnable { static async deserialize(data) { switch (data._type) { case "prompt": { - const { PromptTemplate } = await __nccwpck_require__.e(/* import() */ 575).then(__nccwpck_require__.bind(__nccwpck_require__, 93513)); + const { PromptTemplate } = await __nccwpck_require__.e(/* import() */ 11).then(__nccwpck_require__.bind(__nccwpck_require__, 99049)); return PromptTemplate.deserialize(data); } case undefined: { - const { PromptTemplate } = await __nccwpck_require__.e(/* import() */ 575).then(__nccwpck_require__.bind(__nccwpck_require__, 93513)); + const { PromptTemplate } = await __nccwpck_require__.e(/* import() */ 11).then(__nccwpck_require__.bind(__nccwpck_require__, 99049)); return PromptTemplate.deserialize({ ...data, _type: "prompt" }); } case "few_shot": { - const { FewShotPromptTemplate } = await Promise.all(/* import() */[__nccwpck_require__.e(575), __nccwpck_require__.e(182)]).then(__nccwpck_require__.bind(__nccwpck_require__, 64182)); + const { FewShotPromptTemplate } = await Promise.all(/* import() */[__nccwpck_require__.e(11), __nccwpck_require__.e(50)]).then(__nccwpck_require__.bind(__nccwpck_require__, 58050)); return FewShotPromptTemplate.deserialize(data); } default: @@ -104038,7 +104031,7 @@ exports.BasePromptTemplate = BasePromptTemplate; /***/ }), -/***/ 54361: +/***/ 58178: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -104047,14 +104040,14 @@ exports.BasePromptTemplate = BasePromptTemplate; // Replace with "string" when we are comfortable with a breaking change. Object.defineProperty(exports, "__esModule", ({ value: true })); exports.ChatPromptTemplate = exports.SystemMessagePromptTemplate = exports.AIMessagePromptTemplate = exports.HumanMessagePromptTemplate = exports.ChatMessagePromptTemplate = exports.BaseChatPromptTemplate = exports.BaseMessageStringPromptTemplate = exports.MessagesPlaceholder = exports.BaseMessagePromptTemplate = void 0; -const index_js_1 = __nccwpck_require__(69772); -const prompt_values_js_1 = __nccwpck_require__(68018); -const base_js_1 = __nccwpck_require__(46105); -const string_js_1 = __nccwpck_require__(91677); -const base_js_2 = __nccwpck_require__(79511); -const prompt_js_1 = __nccwpck_require__(7673); -const image_js_1 = __nccwpck_require__(71091); -const template_js_1 = __nccwpck_require__(53553); +const index_js_1 = __nccwpck_require__(56446); +const prompt_values_js_1 = __nccwpck_require__(57125); +const base_js_1 = __nccwpck_require__(87733); +const string_js_1 = __nccwpck_require__(30833); +const base_js_2 = __nccwpck_require__(62217); +const prompt_js_1 = __nccwpck_require__(19407); +const image_js_1 = __nccwpck_require__(12640); +const template_js_1 = __nccwpck_require__(54033); /** * Abstract class that serves as a base for creating message prompt * templates. It defines how to format messages for different roles in a @@ -104753,17 +104746,17 @@ exports.ChatPromptTemplate = ChatPromptTemplate; /***/ }), -/***/ 61122: +/***/ 60390: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.FewShotChatMessagePromptTemplate = exports.FewShotPromptTemplate = void 0; -const string_js_1 = __nccwpck_require__(91677); -const template_js_1 = __nccwpck_require__(53553); -const prompt_js_1 = __nccwpck_require__(7673); -const chat_js_1 = __nccwpck_require__(54361); +const string_js_1 = __nccwpck_require__(30833); +const template_js_1 = __nccwpck_require__(54033); +const prompt_js_1 = __nccwpck_require__(19407); +const chat_js_1 = __nccwpck_require__(58178); /** * Prompt template that contains few-shot examples. * @augments BasePromptTemplate @@ -105116,16 +105109,16 @@ exports.FewShotChatMessagePromptTemplate = FewShotChatMessagePromptTemplate; /***/ }), -/***/ 71091: +/***/ 12640: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.ImagePromptTemplate = void 0; -const prompt_values_js_1 = __nccwpck_require__(68018); -const base_js_1 = __nccwpck_require__(79511); -const template_js_1 = __nccwpck_require__(53553); +const prompt_values_js_1 = __nccwpck_require__(57125); +const base_js_1 = __nccwpck_require__(62217); +const template_js_1 = __nccwpck_require__(54033); /** * An image prompt template for a multimodal model. */ @@ -105245,7 +105238,7 @@ exports.ImagePromptTemplate = ImagePromptTemplate; /***/ }), -/***/ 58254: +/***/ 68328: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -105265,29 +105258,29 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) { for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); }; Object.defineProperty(exports, "__esModule", ({ value: true })); -__exportStar(__nccwpck_require__(79511), exports); -__exportStar(__nccwpck_require__(54361), exports); -__exportStar(__nccwpck_require__(61122), exports); -__exportStar(__nccwpck_require__(67101), exports); -__exportStar(__nccwpck_require__(7673), exports); -__exportStar(__nccwpck_require__(76112), exports); -__exportStar(__nccwpck_require__(91677), exports); -__exportStar(__nccwpck_require__(53553), exports); -__exportStar(__nccwpck_require__(71091), exports); -__exportStar(__nccwpck_require__(19259), exports); +__exportStar(__nccwpck_require__(62217), exports); +__exportStar(__nccwpck_require__(58178), exports); +__exportStar(__nccwpck_require__(60390), exports); +__exportStar(__nccwpck_require__(8932), exports); +__exportStar(__nccwpck_require__(19407), exports); +__exportStar(__nccwpck_require__(48634), exports); +__exportStar(__nccwpck_require__(30833), exports); +__exportStar(__nccwpck_require__(54033), exports); +__exportStar(__nccwpck_require__(12640), exports); +__exportStar(__nccwpck_require__(88772), exports); /***/ }), -/***/ 67101: +/***/ 8932: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.PipelinePromptTemplate = void 0; -const base_js_1 = __nccwpck_require__(79511); -const chat_js_1 = __nccwpck_require__(54361); +const base_js_1 = __nccwpck_require__(62217); +const chat_js_1 = __nccwpck_require__(58178); /** * Class that handles a sequence of prompts, each of which may require * different input variables. Includes methods for formatting these @@ -105431,7 +105424,7 @@ exports.PipelinePromptTemplate = PipelinePromptTemplate; /***/ }), -/***/ 7673: +/***/ 19407: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -105440,8 +105433,8 @@ exports.PipelinePromptTemplate = PipelinePromptTemplate; // Replace with "string" when we are comfortable with a breaking change. Object.defineProperty(exports, "__esModule", ({ value: true })); exports.PromptTemplate = void 0; -const string_js_1 = __nccwpck_require__(91677); -const template_js_1 = __nccwpck_require__(53553); +const string_js_1 = __nccwpck_require__(30833); +const template_js_1 = __nccwpck_require__(54033); /** * Schema to represent a basic prompt for an LLM. * @augments BasePromptTemplate @@ -105593,7 +105586,7 @@ exports.PromptTemplate = PromptTemplate; /***/ }), -/***/ 76112: +/***/ 48634: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -105603,7 +105596,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); /***/ }), -/***/ 91677: +/***/ 30833: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -105612,8 +105605,8 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); // Replace with "string" when we are comfortable with a breaking change. Object.defineProperty(exports, "__esModule", ({ value: true })); exports.BaseStringPromptTemplate = void 0; -const prompt_values_js_1 = __nccwpck_require__(68018); -const base_js_1 = __nccwpck_require__(79511); +const prompt_values_js_1 = __nccwpck_require__(57125); +const base_js_1 = __nccwpck_require__(62217); /** * Base class for string prompt templates. It extends the * BasePromptTemplate class and overrides the formatPromptValue method to @@ -105636,14 +105629,14 @@ exports.BaseStringPromptTemplate = BaseStringPromptTemplate; /***/ }), -/***/ 19259: +/***/ 88772: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.StructuredPrompt = void 0; -const chat_js_1 = __nccwpck_require__(54361); +const chat_js_1 = __nccwpck_require__(58178); function isWithStructuredOutput(x // eslint-disable-next-line @typescript-eslint/ban-types ) { @@ -105708,7 +105701,7 @@ exports.StructuredPrompt = StructuredPrompt; /***/ }), -/***/ 53553: +/***/ 54033: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -105718,7 +105711,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.checkValidTemplate = exports.parseTemplate = exports.renderTemplate = exports.DEFAULT_PARSER_MAPPING = exports.DEFAULT_FORMATTER_MAPPING = exports.interpolateMustache = exports.interpolateFString = exports.parseMustache = exports.parseFString = void 0; -const mustache_1 = __importDefault(__nccwpck_require__(70344)); +const mustache_1 = __importDefault(__nccwpck_require__(98272)); const parseFString = (template) => { // Core logic replicated from internals of pythons built in Formatter class. // https://github.com/python/cpython/blob/135ec7cefbaffd516b77362ad2b2ad1025af462e/Objects/stringlib/unicode_format.h#L700-L706 @@ -105860,7 +105853,7 @@ exports.checkValidTemplate = checkValidTemplate; /***/ }), -/***/ 46105: +/***/ 87733: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -105870,20 +105863,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.RunnablePick = exports.RunnableAssign = exports._coerceToRunnable = exports.RunnableWithFallbacks = exports.RunnableParallel = exports.RunnableLambda = exports.RunnableMap = exports.RunnableSequence = exports.RunnableRetry = exports.RunnableEach = exports.RunnableBinding = exports.Runnable = exports._coerceToDict = void 0; -const zod_1 = __nccwpck_require__(2180); -const p_retry_1 = __importDefault(__nccwpck_require__(21841)); -const manager_js_1 = __nccwpck_require__(73986); -const log_stream_js_1 = __nccwpck_require__(21866); -const serializable_js_1 = __nccwpck_require__(37862); -const stream_js_1 = __nccwpck_require__(24027); -const config_js_1 = __nccwpck_require__(40580); -const async_caller_js_1 = __nccwpck_require__(70140); -const root_listener_js_1 = __nccwpck_require__(117); -const utils_js_1 = __nccwpck_require__(4026); -const index_js_1 = __nccwpck_require__(39756); -const graph_js_1 = __nccwpck_require__(11493); -const wrappers_js_1 = __nccwpck_require__(96223); -const iter_js_1 = __nccwpck_require__(39785); +const zod_1 = __nccwpck_require__(63301); +const p_retry_1 = __importDefault(__nccwpck_require__(82548)); +const manager_js_1 = __nccwpck_require__(34853); +const log_stream_js_1 = __nccwpck_require__(86134); +const serializable_js_1 = __nccwpck_require__(50413); +const stream_js_1 = __nccwpck_require__(1449); +const config_js_1 = __nccwpck_require__(42982); +const async_caller_js_1 = __nccwpck_require__(37264); +const root_listener_js_1 = __nccwpck_require__(48366); +const utils_js_1 = __nccwpck_require__(32538); +const index_js_1 = __nccwpck_require__(30930); +const graph_js_1 = __nccwpck_require__(18069); +const wrappers_js_1 = __nccwpck_require__(42966); +const iter_js_1 = __nccwpck_require__(47630); // eslint-disable-next-line @typescript-eslint/no-explicit-any function _coerceToDict(value, defaultKey) { return value && @@ -107633,16 +107626,16 @@ exports.RunnablePick = RunnablePick; /***/ }), -/***/ 55072: +/***/ 7416: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.RunnableBranch = void 0; -const base_js_1 = __nccwpck_require__(46105); -const config_js_1 = __nccwpck_require__(40580); -const stream_js_1 = __nccwpck_require__(24027); +const base_js_1 = __nccwpck_require__(87733); +const config_js_1 = __nccwpck_require__(42982); +const stream_js_1 = __nccwpck_require__(1449); /** * Class that represents a runnable branch. The RunnableBranch is * initialized with an array of branches and a default branch. When invoked, @@ -107848,15 +107841,15 @@ exports.RunnableBranch = RunnableBranch; /***/ }), -/***/ 40580: +/***/ 42982: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.patchConfig = exports.ensureConfig = exports.mergeConfigs = exports.getCallbackManagerForConfig = exports.DEFAULT_RECURSION_LIMIT = void 0; -const manager_js_1 = __nccwpck_require__(73986); -const index_js_1 = __nccwpck_require__(39756); +const manager_js_1 = __nccwpck_require__(34853); +const index_js_1 = __nccwpck_require__(30930); exports.DEFAULT_RECURSION_LIMIT = 25; async function getCallbackManagerForConfig(config) { return manager_js_1.CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata); @@ -108003,16 +107996,16 @@ exports.patchConfig = patchConfig; /***/ }), -/***/ 11493: +/***/ 18069: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Graph = exports.nodeDataStr = void 0; -const zod_to_json_schema_1 = __nccwpck_require__(40823); -const uuid_1 = __nccwpck_require__(40053); -const utils_js_1 = __nccwpck_require__(4026); +const zod_to_json_schema_1 = __nccwpck_require__(9582); +const uuid_1 = __nccwpck_require__(75840); +const utils_js_1 = __nccwpck_require__(32538); const MAX_DATA_DISPLAY_NAME_LENGTH = 42; function nodeDataStr(node) { if (!(0, uuid_1.validate)(node.id)) { @@ -108175,16 +108168,16 @@ exports.Graph = Graph; /***/ }), -/***/ 33710: +/***/ 56505: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.RunnableWithMessageHistory = void 0; -const index_js_1 = __nccwpck_require__(69772); -const base_js_1 = __nccwpck_require__(46105); -const passthrough_js_1 = __nccwpck_require__(55183); +const index_js_1 = __nccwpck_require__(56446); +const base_js_1 = __nccwpck_require__(87733); +const passthrough_js_1 = __nccwpck_require__(50555); /** * Wraps a LCEL chain and manages history. It appends input messages * and chain outputs as history, and adds the current history messages to @@ -108392,14 +108385,14 @@ exports.RunnableWithMessageHistory = RunnableWithMessageHistory; /***/ }), -/***/ 2642: +/***/ 90996: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.RunnableWithMessageHistory = exports.RunnableBranch = exports.RouterRunnable = exports.RunnablePassthrough = exports.mergeConfigs = exports.ensureConfig = exports.patchConfig = exports.getCallbackManagerForConfig = exports._coerceToRunnable = exports.RunnablePick = exports.RunnableAssign = exports.RunnableWithFallbacks = exports.RunnableLambda = exports.RunnableParallel = exports.RunnableMap = exports.RunnableSequence = exports.RunnableRetry = exports.RunnableEach = exports.RunnableBinding = exports.Runnable = void 0; -var base_js_1 = __nccwpck_require__(46105); +var base_js_1 = __nccwpck_require__(87733); Object.defineProperty(exports, "Runnable", ({ enumerable: true, get: function () { return base_js_1.Runnable; } })); Object.defineProperty(exports, "RunnableBinding", ({ enumerable: true, get: function () { return base_js_1.RunnableBinding; } })); Object.defineProperty(exports, "RunnableEach", ({ enumerable: true, get: function () { return base_js_1.RunnableEach; } })); @@ -108412,31 +108405,31 @@ Object.defineProperty(exports, "RunnableWithFallbacks", ({ enumerable: true, get Object.defineProperty(exports, "RunnableAssign", ({ enumerable: true, get: function () { return base_js_1.RunnableAssign; } })); Object.defineProperty(exports, "RunnablePick", ({ enumerable: true, get: function () { return base_js_1.RunnablePick; } })); Object.defineProperty(exports, "_coerceToRunnable", ({ enumerable: true, get: function () { return base_js_1._coerceToRunnable; } })); -var config_js_1 = __nccwpck_require__(40580); +var config_js_1 = __nccwpck_require__(42982); Object.defineProperty(exports, "getCallbackManagerForConfig", ({ enumerable: true, get: function () { return config_js_1.getCallbackManagerForConfig; } })); Object.defineProperty(exports, "patchConfig", ({ enumerable: true, get: function () { return config_js_1.patchConfig; } })); Object.defineProperty(exports, "ensureConfig", ({ enumerable: true, get: function () { return config_js_1.ensureConfig; } })); Object.defineProperty(exports, "mergeConfigs", ({ enumerable: true, get: function () { return config_js_1.mergeConfigs; } })); -var passthrough_js_1 = __nccwpck_require__(55183); +var passthrough_js_1 = __nccwpck_require__(50555); Object.defineProperty(exports, "RunnablePassthrough", ({ enumerable: true, get: function () { return passthrough_js_1.RunnablePassthrough; } })); -var router_js_1 = __nccwpck_require__(22541); +var router_js_1 = __nccwpck_require__(75179); Object.defineProperty(exports, "RouterRunnable", ({ enumerable: true, get: function () { return router_js_1.RouterRunnable; } })); -var branch_js_1 = __nccwpck_require__(55072); +var branch_js_1 = __nccwpck_require__(7416); Object.defineProperty(exports, "RunnableBranch", ({ enumerable: true, get: function () { return branch_js_1.RunnableBranch; } })); -var history_js_1 = __nccwpck_require__(33710); +var history_js_1 = __nccwpck_require__(56505); Object.defineProperty(exports, "RunnableWithMessageHistory", ({ enumerable: true, get: function () { return history_js_1.RunnableWithMessageHistory; } })); /***/ }), -/***/ 39785: +/***/ 47630: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.consumeAsyncIterableInContext = exports.consumeIteratorInContext = exports.isAsyncIterable = exports.isIterator = void 0; -const index_js_1 = __nccwpck_require__(39756); +const index_js_1 = __nccwpck_require__(30930); function isIterator(thing) { return (typeof thing === "object" && thing !== null && @@ -108483,16 +108476,16 @@ exports.consumeAsyncIterableInContext = consumeAsyncIterableInContext; /***/ }), -/***/ 55183: +/***/ 50555: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.RunnablePassthrough = void 0; -const stream_js_1 = __nccwpck_require__(24027); -const base_js_1 = __nccwpck_require__(46105); -const config_js_1 = __nccwpck_require__(40580); +const stream_js_1 = __nccwpck_require__(1449); +const base_js_1 = __nccwpck_require__(87733); +const config_js_1 = __nccwpck_require__(42982); /** * A runnable to passthrough inputs unchanged or with additional keys. * @@ -108618,15 +108611,15 @@ exports.RunnablePassthrough = RunnablePassthrough; /***/ }), -/***/ 22541: +/***/ 75179: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.RouterRunnable = void 0; -const base_js_1 = __nccwpck_require__(46105); -const config_js_1 = __nccwpck_require__(40580); +const base_js_1 = __nccwpck_require__(87733); +const config_js_1 = __nccwpck_require__(42982); /** * A runnable that routes to a set of runnables based on Input['key']. * Returns the output of the selected runnable. @@ -108700,7 +108693,7 @@ exports.RouterRunnable = RouterRunnable; /***/ }), -/***/ 4026: +/***/ 32538: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -108797,14 +108790,14 @@ exports._RootEventFilter = _RootEventFilter; /***/ }), -/***/ 96223: +/***/ 42966: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.convertToHttpEventStream = void 0; -const stream_js_1 = __nccwpck_require__(24027); +const stream_js_1 = __nccwpck_require__(1449); function convertToHttpEventStream(stream) { const encoder = new TextEncoder(); const finalStream = new ReadableStream({ @@ -108823,7 +108816,7 @@ exports.convertToHttpEventStream = convertToHttpEventStream; /***/ }), -/***/ 39756: +/***/ 30930: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -108871,17 +108864,17 @@ exports.AsyncLocalStorageProviderSingleton = AsyncLocalStorageProviderSingleton; /***/ }), -/***/ 64393: +/***/ 2728: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.BaseToolkit = exports.DynamicStructuredTool = exports.DynamicTool = exports.Tool = exports.StructuredTool = exports.ToolInputParsingException = void 0; -const zod_1 = __nccwpck_require__(2180); -const manager_js_1 = __nccwpck_require__(73986); -const base_js_1 = __nccwpck_require__(10792); -const config_js_1 = __nccwpck_require__(40580); +const zod_1 = __nccwpck_require__(63301); +const manager_js_1 = __nccwpck_require__(34853); +const base_js_1 = __nccwpck_require__(56663); +const config_js_1 = __nccwpck_require__(42982); /** * Custom error class used to handle exceptions related to tool input parsing. * It extends the built-in `Error` class and adds an optional `output` @@ -109114,14 +109107,14 @@ exports.BaseToolkit = BaseToolkit; /***/ }), -/***/ 74178: +/***/ 26674: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.BaseTracer = void 0; -const base_js_1 = __nccwpck_require__(4280); +const base_js_1 = __nccwpck_require__(30243); // eslint-disable-next-line @typescript-eslint/no-explicit-any function _coerceToDict(value, defaultKey) { return value && !Array.isArray(value) && typeof value === "object" @@ -109539,7 +109532,7 @@ exports.BaseTracer = BaseTracer; /***/ }), -/***/ 5796: +/***/ 97718: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -109549,8 +109542,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.ConsoleCallbackHandler = void 0; -const ansi_styles_1 = __importDefault(__nccwpck_require__(60565)); -const base_js_1 = __nccwpck_require__(74178); +const ansi_styles_1 = __importDefault(__nccwpck_require__(52068)); +const base_js_1 = __nccwpck_require__(26674); function wrap(style, text) { return `${style.open}${text}${style.close}`; } @@ -109771,15 +109764,15 @@ exports.ConsoleCallbackHandler = ConsoleCallbackHandler; /***/ }), -/***/ 64550: +/***/ 67807: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.getTracingV2CallbackHandler = exports.getTracingCallbackHandler = void 0; -const tracer_langchain_js_1 = __nccwpck_require__(85421); -const tracer_langchain_v1_js_1 = __nccwpck_require__(25827); +const tracer_langchain_js_1 = __nccwpck_require__(60974); +const tracer_langchain_v1_js_1 = __nccwpck_require__(948); /** * @deprecated Use the V2 handler instead. * @@ -109813,17 +109806,17 @@ exports.getTracingV2CallbackHandler = getTracingV2CallbackHandler; /***/ }), -/***/ 21866: +/***/ 86134: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.LogStreamCallbackHandler = exports.RunLog = exports.RunLogPatch = void 0; -const index_js_1 = __nccwpck_require__(17302); -const base_js_1 = __nccwpck_require__(74178); -const stream_js_1 = __nccwpck_require__(24027); -const index_js_2 = __nccwpck_require__(69772); +const index_js_1 = __nccwpck_require__(6865); +const base_js_1 = __nccwpck_require__(26674); +const stream_js_1 = __nccwpck_require__(1449); +const index_js_2 = __nccwpck_require__(56446); /** * List of jsonpatch JSONPatchOperations, which describe how to create the run state * from an empty dict. This is the minimal representation of the log, designed to @@ -110246,14 +110239,14 @@ exports.LogStreamCallbackHandler = LogStreamCallbackHandler; /***/ }), -/***/ 117: +/***/ 48366: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.RootListenersTracer = void 0; -const base_js_1 = __nccwpck_require__(74178); +const base_js_1 = __nccwpck_require__(26674); class RootListenersTracer extends base_js_1.BaseTracer { constructor({ config, onStart, onEnd, onError, }) { super({ _awaitHandler: true }); @@ -110350,16 +110343,16 @@ exports.RootListenersTracer = RootListenersTracer; /***/ }), -/***/ 85421: +/***/ 60974: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.LangChainTracer = void 0; -const langsmith_1 = __nccwpck_require__(73418); -const env_js_1 = __nccwpck_require__(14836); -const base_js_1 = __nccwpck_require__(74178); +const langsmith_1 = __nccwpck_require__(5907); +const env_js_1 = __nccwpck_require__(74301); +const base_js_1 = __nccwpck_require__(26674); class LangChainTracer extends base_js_1.BaseTracer { constructor(fields = {}) { super(fields); @@ -110434,16 +110427,16 @@ exports.LangChainTracer = LangChainTracer; /***/ }), -/***/ 25827: +/***/ 948: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.LangChainTracerV1 = void 0; -const index_js_1 = __nccwpck_require__(69772); -const env_js_1 = __nccwpck_require__(14836); -const base_js_1 = __nccwpck_require__(74178); +const index_js_1 = __nccwpck_require__(56446); +const env_js_1 = __nccwpck_require__(74301); +const base_js_1 = __nccwpck_require__(26674); /** @deprecated Use LangChainTracer instead. */ class LangChainTracerV1 extends base_js_1.BaseTracer { constructor() { @@ -110642,7 +110635,7 @@ exports.LangChainTracerV1 = LangChainTracerV1; /***/ }), -/***/ 74775: +/***/ 14050: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -110662,12 +110655,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) { for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); }; Object.defineProperty(exports, "__esModule", ({ value: true })); -__exportStar(__nccwpck_require__(99841), exports); +__exportStar(__nccwpck_require__(4684), exports); /***/ }), -/***/ 90264: +/***/ 36700: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -110718,14 +110711,14 @@ exports.deepCompareStrict = deepCompareStrict; /***/ }), -/***/ 6986: +/***/ 24451: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.dereference = exports.initialBaseURI = exports.ignoredKeyword = exports.schemaMapKeyword = exports.schemaArrayKeyword = exports.schemaKeyword = void 0; -const pointer_js_1 = __nccwpck_require__(3260); +const pointer_js_1 = __nccwpck_require__(12807); exports.schemaKeyword = { additionalItems: true, unevaluatedItems: true, @@ -110897,7 +110890,7 @@ exports.dereference = dereference; /***/ }), -/***/ 3316: +/***/ 41398: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -111044,7 +111037,7 @@ function regex(str) { /***/ }), -/***/ 99841: +/***/ 4684: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -111064,19 +111057,19 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) { for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); }; Object.defineProperty(exports, "__esModule", ({ value: true })); -__exportStar(__nccwpck_require__(90264), exports); -__exportStar(__nccwpck_require__(6986), exports); -__exportStar(__nccwpck_require__(3316), exports); -__exportStar(__nccwpck_require__(3260), exports); -__exportStar(__nccwpck_require__(44409), exports); -__exportStar(__nccwpck_require__(33420), exports); -__exportStar(__nccwpck_require__(32918), exports); -__exportStar(__nccwpck_require__(12027), exports); +__exportStar(__nccwpck_require__(36700), exports); +__exportStar(__nccwpck_require__(24451), exports); +__exportStar(__nccwpck_require__(41398), exports); +__exportStar(__nccwpck_require__(12807), exports); +__exportStar(__nccwpck_require__(48760), exports); +__exportStar(__nccwpck_require__(9424), exports); +__exportStar(__nccwpck_require__(13640), exports); +__exportStar(__nccwpck_require__(60957), exports); /***/ }), -/***/ 3260: +/***/ 12807: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -111095,7 +111088,7 @@ exports.escapePointer = escapePointer; /***/ }), -/***/ 44409: +/***/ 48760: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -111105,7 +111098,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); /***/ }), -/***/ 33420: +/***/ 9424: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -111141,18 +111134,18 @@ exports.ucs2length = ucs2length; /***/ }), -/***/ 32918: +/***/ 13640: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.validate = void 0; -const deep_compare_strict_js_1 = __nccwpck_require__(90264); -const dereference_js_1 = __nccwpck_require__(6986); -const format_js_1 = __nccwpck_require__(3316); -const pointer_js_1 = __nccwpck_require__(3260); -const ucs2_length_js_1 = __nccwpck_require__(33420); +const deep_compare_strict_js_1 = __nccwpck_require__(36700); +const dereference_js_1 = __nccwpck_require__(24451); +const format_js_1 = __nccwpck_require__(41398); +const pointer_js_1 = __nccwpck_require__(12807); +const ucs2_length_js_1 = __nccwpck_require__(9424); function validate(instance, schema, draft = "2019-09", lookup = (0, dereference_js_1.dereference)(schema), shortCircuit = true, recursiveAnchor = null, instanceLocation = "#", schemaLocation = "#", evaluated = Object.create(null)) { if (schema === true) { return { valid: true, errors: [] }; @@ -111957,15 +111950,15 @@ exports.validate = validate; /***/ }), -/***/ 12027: +/***/ 60957: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Validator = void 0; -const dereference_js_1 = __nccwpck_require__(6986); -const validate_js_1 = __nccwpck_require__(32918); +const dereference_js_1 = __nccwpck_require__(24451); +const validate_js_1 = __nccwpck_require__(13640); class Validator { constructor(schema, draft = "2019-09", shortCircuit = true) { Object.defineProperty(this, "schema", { @@ -112009,7 +112002,7 @@ exports.Validator = Validator; /***/ }), -/***/ 70140: +/***/ 37264: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -112019,8 +112012,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.AsyncCaller = void 0; -const p_retry_1 = __importDefault(__nccwpck_require__(21841)); -const p_queue_1 = __importDefault(__nccwpck_require__(518)); +const p_retry_1 = __importDefault(__nccwpck_require__(82548)); +const p_queue_1 = __importDefault(__nccwpck_require__(28983)); const STATUS_NO_RETRY = [ 400, 401, @@ -112145,7 +112138,7 @@ exports.AsyncCaller = AsyncCaller; /***/ }), -/***/ 49291: +/***/ 71355: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -112164,7 +112157,7 @@ exports.chunkArray = chunkArray; /***/ }), -/***/ 14836: +/***/ 74301: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -112245,7 +112238,7 @@ exports.getEnvironmentVariable = getEnvironmentVariable; /***/ }), -/***/ 17302: +/***/ 6865: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -112278,9 +112271,9 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.unescapePathComponent = exports.escapePathComponent = exports.deepClone = exports.JsonPatchError = void 0; -__exportStar(__nccwpck_require__(18365), exports); -__exportStar(__nccwpck_require__(80871), exports); -var helpers_js_1 = __nccwpck_require__(76298); +__exportStar(__nccwpck_require__(89099), exports); +__exportStar(__nccwpck_require__(87528), exports); +var helpers_js_1 = __nccwpck_require__(52484); Object.defineProperty(exports, "JsonPatchError", ({ enumerable: true, get: function () { return helpers_js_1.PatchError; } })); Object.defineProperty(exports, "deepClone", ({ enumerable: true, get: function () { return helpers_js_1._deepClone; } })); Object.defineProperty(exports, "escapePathComponent", ({ enumerable: true, get: function () { return helpers_js_1.escapePathComponent; } })); @@ -112288,8 +112281,8 @@ Object.defineProperty(exports, "unescapePathComponent", ({ enumerable: true, get /** * Default export for backwards compat */ -const core = __importStar(__nccwpck_require__(18365)); -const helpers_js_2 = __nccwpck_require__(76298); +const core = __importStar(__nccwpck_require__(89099)); +const helpers_js_2 = __nccwpck_require__(52484); exports["default"] = { ...core, // ...duplex, @@ -112302,7 +112295,7 @@ exports["default"] = { /***/ }), -/***/ 18365: +/***/ 89099: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -112310,7 +112303,7 @@ exports["default"] = { // @ts-nocheck Object.defineProperty(exports, "__esModule", ({ value: true })); exports._areEquals = exports.validate = exports.validator = exports.applyReducer = exports.applyPatch = exports.applyOperation = exports.getValueByPointer = exports.deepClone = exports.JsonPatchError = void 0; -const helpers_js_1 = __nccwpck_require__(76298); +const helpers_js_1 = __nccwpck_require__(52484); exports.JsonPatchError = helpers_js_1.PatchError; exports.deepClone = helpers_js_1._deepClone; /* We use a Javascript hash to store each @@ -112779,7 +112772,7 @@ exports._areEquals = _areEquals; /***/ }), -/***/ 80871: +/***/ 87528: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -112793,8 +112786,8 @@ exports.compare = exports.generate = exports.observe = exports.unobserve = void * (c) 2013-2021 Joachim Wester * MIT license */ -const helpers_js_1 = __nccwpck_require__(76298); -const core_js_1 = __nccwpck_require__(18365); +const helpers_js_1 = __nccwpck_require__(52484); +const core_js_1 = __nccwpck_require__(89099); var beforeDict = new WeakMap(); class Mirror { constructor(obj) { @@ -113024,7 +113017,7 @@ exports.compare = compare; /***/ }), -/***/ 76298: +/***/ 52484: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -113226,14 +113219,14 @@ exports.PatchError = PatchError; /***/ }), -/***/ 45349: +/***/ 59984: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.isStructuredTool = exports.convertToOpenAITool = exports.convertToOpenAIFunction = void 0; -const zod_to_json_schema_1 = __nccwpck_require__(40823); +const zod_to_json_schema_1 = __nccwpck_require__(9582); /** * Formats a `StructuredTool` instance into a format that is compatible * with OpenAI function calling. It uses the `zodToJsonSchema` @@ -113277,20 +113270,20 @@ exports.isStructuredTool = isStructuredTool; /***/ }), -/***/ 30326: +/***/ 8612: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.insecureHash = void 0; -var hash_js_1 = __nccwpck_require__(58079); +var hash_js_1 = __nccwpck_require__(25424); Object.defineProperty(exports, "insecureHash", ({ enumerable: true, get: function () { return hash_js_1.insecureHash; } })); /***/ }), -/***/ 58079: +/***/ 25424: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -113656,7 +113649,7 @@ exports.insecureHash = insecureHash; /***/ }), -/***/ 8840: +/***/ 3709: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -113757,21 +113750,21 @@ exports.parsePartialJson = parsePartialJson; /***/ }), -/***/ 43504: +/***/ 11437: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.applyPatch = exports.compare = void 0; -var index_js_1 = __nccwpck_require__(17302); +var index_js_1 = __nccwpck_require__(6865); Object.defineProperty(exports, "compare", ({ enumerable: true, get: function () { return index_js_1.compare; } })); Object.defineProperty(exports, "applyPatch", ({ enumerable: true, get: function () { return index_js_1.applyPatch; } })); /***/ }), -/***/ 76861: +/***/ 10678: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -115337,7 +115330,7 @@ exports.sax = sax; /***/ }), -/***/ 24027: +/***/ 1449: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -115346,7 +115339,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.pipeGeneratorWithSetup = exports.AsyncGeneratorWithSetup = exports.concat = exports.atee = exports.IterableReadableStream = void 0; // Make this a type to override ReadableStream's async iterator type in case // the popular web-streams-polyfill is imported - the supplied types -const index_js_1 = __nccwpck_require__(39756); +const index_js_1 = __nccwpck_require__(30930); /* * Support async iterator syntax for ReadableStreams in all environments. * Source: https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490 @@ -115594,15 +115587,15 @@ exports.pipeGeneratorWithSetup = pipeGeneratorWithSetup; /***/ }), -/***/ 76028: +/***/ 6186: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.encodingForModel = exports.getEncoding = void 0; -const lite_1 = __nccwpck_require__(83411); -const async_caller_js_1 = __nccwpck_require__(70140); +const lite_1 = __nccwpck_require__(83791); +const async_caller_js_1 = __nccwpck_require__(37264); const cache = {}; const caller = /* #__PURE__ */ new async_caller_js_1.AsyncCaller({}); async function getEncoding(encoding) { @@ -115627,114 +115620,114 @@ exports.encodingForModel = encodingForModel; /***/ }), -/***/ 90008: +/***/ 3944: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = __nccwpck_require__(57739); +module.exports = __nccwpck_require__(69000); /***/ }), -/***/ 33292: +/***/ 40209: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = __nccwpck_require__(10792); +module.exports = __nccwpck_require__(56663); /***/ }), -/***/ 55559: +/***/ 47880: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = __nccwpck_require__(16853); +module.exports = __nccwpck_require__(41717); /***/ }), -/***/ 36281: +/***/ 55804: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = __nccwpck_require__(26644); +module.exports = __nccwpck_require__(53013); /***/ }), -/***/ 44316: +/***/ 94976: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = __nccwpck_require__(69772); +module.exports = __nccwpck_require__(56446); /***/ }), -/***/ 39881: +/***/ 85304: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = __nccwpck_require__(69360); +module.exports = __nccwpck_require__(95387); /***/ }), -/***/ 8186: +/***/ 28121: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = __nccwpck_require__(83968); +module.exports = __nccwpck_require__(38862); /***/ }), -/***/ 73132: +/***/ 89102: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = __nccwpck_require__(6141); +module.exports = __nccwpck_require__(13722); /***/ }), -/***/ 63486: +/***/ 29477: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = __nccwpck_require__(58254); +module.exports = __nccwpck_require__(68328); /***/ }), -/***/ 58959: +/***/ 41708: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = __nccwpck_require__(2642); +module.exports = __nccwpck_require__(90996); /***/ }), -/***/ 45491: +/***/ 53173: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = __nccwpck_require__(64393); +module.exports = __nccwpck_require__(2728); /***/ }), -/***/ 55471: +/***/ 29974: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = __nccwpck_require__(49291); +module.exports = __nccwpck_require__(71355); /***/ }), -/***/ 27961: +/***/ 75444: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = __nccwpck_require__(14836); +module.exports = __nccwpck_require__(74301); /***/ }), -/***/ 95905: +/***/ 97058: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = __nccwpck_require__(45349); +module.exports = __nccwpck_require__(59984); /***/ }), -/***/ 38683: +/***/ 59731: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.AzureChatOpenAI = void 0; -const openai_1 = __nccwpck_require__(1808); -const chat_models_js_1 = __nccwpck_require__(7395); -const azure_js_1 = __nccwpck_require__(78236); +const openai_1 = __nccwpck_require__(60047); +const chat_models_js_1 = __nccwpck_require__(41898); +const azure_js_1 = __nccwpck_require__(41067); class AzureChatOpenAI extends chat_models_js_1.ChatOpenAI { _llmType() { return "azure_openai"; @@ -115833,17 +115826,17 @@ exports.AzureChatOpenAI = AzureChatOpenAI; /***/ }), -/***/ 40576: +/***/ 2426: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.AzureOpenAIEmbeddings = void 0; -const openai_1 = __nccwpck_require__(1808); -const embeddings_js_1 = __nccwpck_require__(24751); -const azure_js_1 = __nccwpck_require__(78236); -const openai_js_1 = __nccwpck_require__(82399); +const openai_1 = __nccwpck_require__(60047); +const embeddings_js_1 = __nccwpck_require__(23033); +const azure_js_1 = __nccwpck_require__(41067); +const openai_js_1 = __nccwpck_require__(58060); class AzureOpenAIEmbeddings extends embeddings_js_1.OpenAIEmbeddings { constructor(fields, configuration) { const newFields = { ...fields }; @@ -115918,16 +115911,16 @@ exports.AzureOpenAIEmbeddings = AzureOpenAIEmbeddings; /***/ }), -/***/ 47108: +/***/ 4543: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.AzureOpenAI = void 0; -const openai_1 = __nccwpck_require__(1808); -const llms_js_1 = __nccwpck_require__(68739); -const azure_js_1 = __nccwpck_require__(78236); +const openai_1 = __nccwpck_require__(60047); +const llms_js_1 = __nccwpck_require__(35413); +const azure_js_1 = __nccwpck_require__(41067); class AzureOpenAI extends llms_js_1.OpenAI { get lc_aliases() { return { @@ -116017,26 +116010,26 @@ exports.AzureOpenAI = AzureOpenAI; /***/ }), -/***/ 7395: +/***/ 41898: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.ChatOpenAI = exports.messageToOpenAIRole = void 0; -const openai_1 = __nccwpck_require__(1808); -const messages_1 = __nccwpck_require__(44316); -const outputs_1 = __nccwpck_require__(73132); -const env_1 = __nccwpck_require__(27961); -const chat_models_1 = __nccwpck_require__(55559); -const function_calling_1 = __nccwpck_require__(95905); -const runnables_1 = __nccwpck_require__(58959); -const output_parsers_1 = __nccwpck_require__(39881); -const openai_tools_1 = __nccwpck_require__(8186); -const zod_to_json_schema_1 = __nccwpck_require__(40823); -const azure_js_1 = __nccwpck_require__(78236); -const openai_js_1 = __nccwpck_require__(82399); -const openai_format_fndef_js_1 = __nccwpck_require__(67003); +const openai_1 = __nccwpck_require__(60047); +const messages_1 = __nccwpck_require__(94976); +const outputs_1 = __nccwpck_require__(89102); +const env_1 = __nccwpck_require__(75444); +const chat_models_1 = __nccwpck_require__(47880); +const function_calling_1 = __nccwpck_require__(97058); +const runnables_1 = __nccwpck_require__(41708); +const output_parsers_1 = __nccwpck_require__(85304); +const openai_tools_1 = __nccwpck_require__(28121); +const zod_to_json_schema_1 = __nccwpck_require__(9582); +const azure_js_1 = __nccwpck_require__(41067); +const openai_js_1 = __nccwpck_require__(58060); +const openai_format_fndef_js_1 = __nccwpck_require__(65820); function extractGenericMessageCustomRole(message) { if (message.role !== "system" && message.role !== "assistant" && @@ -116994,19 +116987,19 @@ function isStructuredOutputMethodParams(x /***/ }), -/***/ 24751: +/***/ 23033: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.OpenAIEmbeddings = void 0; -const openai_1 = __nccwpck_require__(1808); -const env_1 = __nccwpck_require__(27961); -const embeddings_1 = __nccwpck_require__(90008); -const chunk_array_1 = __nccwpck_require__(55471); -const azure_js_1 = __nccwpck_require__(78236); -const openai_js_1 = __nccwpck_require__(82399); +const openai_1 = __nccwpck_require__(60047); +const env_1 = __nccwpck_require__(75444); +const embeddings_1 = __nccwpck_require__(3944); +const chunk_array_1 = __nccwpck_require__(29974); +const azure_js_1 = __nccwpck_require__(41067); +const openai_js_1 = __nccwpck_require__(58060); /** * Class for generating embeddings using the OpenAI API. Extends the * Embeddings class and implements OpenAIEmbeddingsParams and @@ -117283,7 +117276,7 @@ exports.OpenAIEmbeddings = OpenAIEmbeddings; /***/ }), -/***/ 73655: +/***/ 97451: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -117304,36 +117297,36 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.toFile = exports.OpenAIClient = void 0; -var openai_1 = __nccwpck_require__(1808); +var openai_1 = __nccwpck_require__(60047); Object.defineProperty(exports, "OpenAIClient", ({ enumerable: true, get: function () { return openai_1.OpenAI; } })); Object.defineProperty(exports, "toFile", ({ enumerable: true, get: function () { return openai_1.toFile; } })); -__exportStar(__nccwpck_require__(7395), exports); -__exportStar(__nccwpck_require__(38683), exports); -__exportStar(__nccwpck_require__(68739), exports); -__exportStar(__nccwpck_require__(47108), exports); -__exportStar(__nccwpck_require__(40576), exports); -__exportStar(__nccwpck_require__(24751), exports); -__exportStar(__nccwpck_require__(38413), exports); -__exportStar(__nccwpck_require__(82399), exports); -__exportStar(__nccwpck_require__(78236), exports); -__exportStar(__nccwpck_require__(69841), exports); +__exportStar(__nccwpck_require__(41898), exports); +__exportStar(__nccwpck_require__(59731), exports); +__exportStar(__nccwpck_require__(35413), exports); +__exportStar(__nccwpck_require__(4543), exports); +__exportStar(__nccwpck_require__(2426), exports); +__exportStar(__nccwpck_require__(23033), exports); +__exportStar(__nccwpck_require__(95227), exports); +__exportStar(__nccwpck_require__(58060), exports); +__exportStar(__nccwpck_require__(41067), exports); +__exportStar(__nccwpck_require__(72134), exports); /***/ }), -/***/ 62912: +/***/ 53522: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.OpenAIChat = void 0; -const openai_1 = __nccwpck_require__(1808); -const outputs_1 = __nccwpck_require__(73132); -const env_1 = __nccwpck_require__(27961); -const llms_1 = __nccwpck_require__(36281); -const azure_js_1 = __nccwpck_require__(78236); -const openai_js_1 = __nccwpck_require__(82399); +const openai_1 = __nccwpck_require__(60047); +const outputs_1 = __nccwpck_require__(89102); +const env_1 = __nccwpck_require__(75444); +const llms_1 = __nccwpck_require__(55804); +const azure_js_1 = __nccwpck_require__(41067); +const openai_js_1 = __nccwpck_require__(58060); /** * @deprecated For legacy compatibility. Use ChatOpenAI instead. * @@ -117785,23 +117778,23 @@ exports.OpenAIChat = OpenAIChat; /***/ }), -/***/ 68739: +/***/ 35413: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.OpenAI = exports.OpenAIChat = void 0; -const openai_1 = __nccwpck_require__(1808); -const base_1 = __nccwpck_require__(33292); -const outputs_1 = __nccwpck_require__(73132); -const env_1 = __nccwpck_require__(27961); -const llms_1 = __nccwpck_require__(36281); -const chunk_array_1 = __nccwpck_require__(55471); -const azure_js_1 = __nccwpck_require__(78236); -const legacy_js_1 = __nccwpck_require__(62912); +const openai_1 = __nccwpck_require__(60047); +const base_1 = __nccwpck_require__(40209); +const outputs_1 = __nccwpck_require__(89102); +const env_1 = __nccwpck_require__(75444); +const llms_1 = __nccwpck_require__(55804); +const chunk_array_1 = __nccwpck_require__(29974); +const azure_js_1 = __nccwpck_require__(41067); +const legacy_js_1 = __nccwpck_require__(53522); Object.defineProperty(exports, "OpenAIChat", ({ enumerable: true, get: function () { return legacy_js_1.OpenAIChat; } })); -const openai_js_1 = __nccwpck_require__(82399); +const openai_js_1 = __nccwpck_require__(58060); /** * Wrapper around OpenAI large language models. * @@ -118357,16 +118350,16 @@ exports.OpenAI = OpenAI; /***/ }), -/***/ 24464: +/***/ 14039: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.DallEAPIWrapper = void 0; -const env_1 = __nccwpck_require__(27961); -const openai_1 = __nccwpck_require__(1808); -const tools_1 = __nccwpck_require__(45491); +const env_1 = __nccwpck_require__(75444); +const openai_1 = __nccwpck_require__(60047); +const tools_1 = __nccwpck_require__(53173); /** * A tool for generating images with Open AIs Dall-E 2 or 3 API. */ @@ -118491,7 +118484,7 @@ Object.defineProperty(DallEAPIWrapper, "toolName", { /***/ }), -/***/ 69841: +/***/ 72134: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -118511,12 +118504,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) { for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); }; Object.defineProperty(exports, "__esModule", ({ value: true })); -__exportStar(__nccwpck_require__(24464), exports); +__exportStar(__nccwpck_require__(14039), exports); /***/ }), -/***/ 38413: +/***/ 95227: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -118526,7 +118519,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); /***/ }), -/***/ 78236: +/***/ 41067: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -118578,7 +118571,7 @@ exports.getEndpoint = getEndpoint; /***/ }), -/***/ 67003: +/***/ 65820: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -118667,16 +118660,16 @@ function formatType(param, indent) { /***/ }), -/***/ 82399: +/***/ 58060: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.formatToOpenAIAssistantTool = exports.formatToOpenAITool = exports.formatToOpenAIFunction = exports.wrapOpenAIClientError = void 0; -const openai_1 = __nccwpck_require__(1808); -const zod_to_json_schema_1 = __nccwpck_require__(40823); -const function_calling_1 = __nccwpck_require__(95905); +const openai_1 = __nccwpck_require__(60047); +const zod_to_json_schema_1 = __nccwpck_require__(9582); +const function_calling_1 = __nccwpck_require__(97058); Object.defineProperty(exports, "formatToOpenAIFunction", ({ enumerable: true, get: function () { return function_calling_1.convertToOpenAIFunction; } })); Object.defineProperty(exports, "formatToOpenAITool", ({ enumerable: true, get: function () { return function_calling_1.convertToOpenAITool; } })); // eslint-disable-next-line @typescript-eslint/no-explicit-any @@ -118711,27 +118704,27 @@ exports.formatToOpenAIAssistantTool = formatToOpenAIAssistantTool; /***/ }), -/***/ 14863: +/***/ 34739: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = __nccwpck_require__(73655); +module.exports = __nccwpck_require__(97451); /***/ }), -/***/ 49019: +/***/ 88757: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; // Axios v1.7.1 Copyright (c) 2024 Matt Zabriskie and contributors -const FormData$1 = __nccwpck_require__(69346); +const FormData$1 = __nccwpck_require__(64334); const url = __nccwpck_require__(57310); -const proxyFromEnv = __nccwpck_require__(14404); +const proxyFromEnv = __nccwpck_require__(63329); const http = __nccwpck_require__(13685); const https = __nccwpck_require__(95687); const util = __nccwpck_require__(73837); -const followRedirects = __nccwpck_require__(6139); +const followRedirects = __nccwpck_require__(67707); const zlib = __nccwpck_require__(59796); const stream = __nccwpck_require__(12781); const events = __nccwpck_require__(82361); @@ -123431,13 +123424,13 @@ module.exports = axios; /***/ }), -/***/ 83411: +/***/ 83791: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; -var base64 = __nccwpck_require__(55783); +var base64 = __nccwpck_require__(26463); function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; } @@ -123678,7 +123671,7 @@ exports.getEncodingNameForModel = getEncodingNameForModel; /***/ }), -/***/ 50489: +/***/ 37277: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -123708,12 +123701,12 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Client = exports.DEFAULT_BATCH_SIZE_LIMIT_BYTES = exports.Queue = void 0; -const uuid = __importStar(__nccwpck_require__(40053)); -const async_caller_js_1 = __nccwpck_require__(58975); -const messages_js_1 = __nccwpck_require__(49981); -const env_js_1 = __nccwpck_require__(57622); -const index_js_1 = __nccwpck_require__(99754); -const _uuid_js_1 = __nccwpck_require__(26171); +const uuid = __importStar(__nccwpck_require__(75840)); +const async_caller_js_1 = __nccwpck_require__(20341); +const messages_js_1 = __nccwpck_require__(59792); +const env_js_1 = __nccwpck_require__(60302); +const index_js_1 = __nccwpck_require__(9323); +const _uuid_js_1 = __nccwpck_require__(70754); async function mergeRuntimeEnvIntoRunCreates(runs) { const runtimeEnv = await (0, env_js_1.getRuntimeEnvironment)(); const envVars = (0, env_js_1.getLangChainEnvVarsMetadata)(); @@ -125554,16 +125547,16 @@ exports.Client = Client; /***/ }), -/***/ 99754: +/***/ 9323: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.__version__ = exports.RunTree = exports.Client = void 0; -var client_js_1 = __nccwpck_require__(50489); +var client_js_1 = __nccwpck_require__(37277); Object.defineProperty(exports, "Client", ({ enumerable: true, get: function () { return client_js_1.Client; } })); -var run_trees_js_1 = __nccwpck_require__(9698); +var run_trees_js_1 = __nccwpck_require__(16571); Object.defineProperty(exports, "RunTree", ({ enumerable: true, get: function () { return run_trees_js_1.RunTree; } })); // Update using yarn bump-version exports.__version__ = "0.1.25"; @@ -125571,7 +125564,7 @@ exports.__version__ = "0.1.25"; /***/ }), -/***/ 9698: +/***/ 16571: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -125601,9 +125594,9 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.isRunnableConfigLike = exports.isRunTree = exports.RunTree = exports.convertToDottedOrderFormat = void 0; -const uuid = __importStar(__nccwpck_require__(40053)); -const env_js_1 = __nccwpck_require__(57622); -const client_js_1 = __nccwpck_require__(50489); +const uuid = __importStar(__nccwpck_require__(75840)); +const env_js_1 = __nccwpck_require__(60302); +const client_js_1 = __nccwpck_require__(37277); const warnedMessages = {}; function warnOnce(message) { if (!warnedMessages[message]) { @@ -125962,7 +125955,7 @@ exports.isRunnableConfigLike = isRunnableConfigLike; /***/ }), -/***/ 26171: +/***/ 70754: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -125992,7 +125985,7 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.assertUuid = void 0; -const uuid = __importStar(__nccwpck_require__(40053)); +const uuid = __importStar(__nccwpck_require__(75840)); function assertUuid(str) { if (!uuid.validate(str)) { throw new Error(`Invalid UUID: ${str}`); @@ -126003,7 +125996,7 @@ exports.assertUuid = assertUuid; /***/ }), -/***/ 58975: +/***/ 20341: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -126013,8 +126006,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.AsyncCaller = void 0; -const p_retry_1 = __importDefault(__nccwpck_require__(21841)); -const p_queue_1 = __importDefault(__nccwpck_require__(518)); +const p_retry_1 = __importDefault(__nccwpck_require__(82548)); +const p_queue_1 = __importDefault(__nccwpck_require__(28983)); const STATUS_NO_RETRY = [ 400, // Bad Request 401, // Unauthorized @@ -126149,7 +126142,7 @@ exports.AsyncCaller = AsyncCaller; /***/ }), -/***/ 57622: +/***/ 60302: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -126157,7 +126150,7 @@ exports.AsyncCaller = AsyncCaller; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.getShas = exports.setEnvironmentVariable = exports.getEnvironmentVariable = exports.getEnvironmentVariables = exports.getLangChainEnvVarsMetadata = exports.getLangChainEnvVars = exports.getRuntimeEnvironment = exports.getEnv = exports.isNode = exports.isDeno = exports.isJsDom = exports.isWebWorker = exports.isBrowser = void 0; // Inlined from https://github.com/flexdinesh/browser-or-node -const index_js_1 = __nccwpck_require__(99754); +const index_js_1 = __nccwpck_require__(9323); let globalEnv; const isBrowser = () => typeof window !== "undefined" && typeof window.document !== "undefined"; exports.isBrowser = isBrowser; @@ -126381,7 +126374,7 @@ exports.getShas = getShas; /***/ }), -/***/ 49981: +/***/ 59792: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -126411,14 +126404,14 @@ exports.convertLangChainMessageToExample = convertLangChainMessageToExample; /***/ }), -/***/ 73418: +/***/ 5907: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = __nccwpck_require__(99754); +module.exports = __nccwpck_require__(9323); /***/ }), -/***/ 91634: +/***/ 80630: /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __nccwpck_require__) => { "use strict"; @@ -126769,7 +126762,7 @@ module.exports = {"version":"3.13.0"}; /******/ // startup /******/ // Load entry module and return exports /******/ // This entry module is referenced by other modules so it can't be inlined -/******/ var __webpack_exports__ = __nccwpck_require__(33709); +/******/ var __webpack_exports__ = __nccwpck_require__(70399); /******/ module.exports = __webpack_exports__; /******/ /******/ })() diff --git a/package-lock.json b/package-lock.json index b48d9d0..a257a35 100644 --- a/package-lock.json +++ b/package-lock.json @@ -26,6 +26,7 @@ "@types/string-format": "^2.0.3", "@types/underscore": "^1.11.15", "@types/xml2js": "^0.4.14", + "@vercel/ncc": "^0.38.1", "typescript": "^5.4.5" } }, @@ -351,6 +352,15 @@ "@types/node": "*" } }, + "node_modules/@vercel/ncc": { + "version": "0.38.1", + "resolved": "https://registry.npmjs.org/@vercel/ncc/-/ncc-0.38.1.tgz", + "integrity": "sha512-IBBb+iI2NLu4VQn3Vwldyi2QwaXt5+hTyh58ggAMoCGE6DJmPvwL3KPBWcJl1m9LYPChBLE980Jw+CS4Wokqxw==", + "dev": true, + "bin": { + "ncc": "dist/ncc/cli.js" + } + }, "node_modules/abort-controller": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz", diff --git a/package.json b/package.json index 03d5dd0..d71f5b3 100644 --- a/package.json +++ b/package.json @@ -20,6 +20,7 @@ "@types/string-format": "^2.0.3", "@types/underscore": "^1.11.15", "@types/xml2js": "^0.4.14", + "@vercel/ncc": "^0.38.1", "typescript": "^5.4.5" }, "dependencies": { diff --git a/src/lib/Action.ts b/src/lib/Action.ts index 93ca795..596bbf3 100644 --- a/src/lib/Action.ts +++ b/src/lib/Action.ts @@ -1,6 +1,6 @@ import PatPatBot from "./PatPatBot"; import Gpt from "./Gpt"; -import {API_KEY_OPENAI, DOC_DESCRIPTIONS_PATH, DOC_PATTERNS_PATH, DOCS_DIR, REPO_NAME} from "./init"; +import {API_KEY_OPENAI, DOC_DESCRIPTIONS_PATH, DOCS_DIR, REPO_NAME} from "./init"; import GoogleSearch from "./GoogleSearch"; import Repository from "./Repository"; import logger from "./logging"; @@ -16,7 +16,6 @@ class Action { REPO_NAME, DOCS_DIR, DOC_DESCRIPTIONS_PATH, - DOC_PATTERNS_PATH, ); const maxIdx = Math.min(repo.docs.length, 20); // TODO remove this diff --git a/src/lib/MetaFile.ts b/src/lib/MetaFile.ts index 6a21195..4ffc8f1 100644 --- a/src/lib/MetaFile.ts +++ b/src/lib/MetaFile.ts @@ -1,5 +1,5 @@ import {readFileSync, writeFileSync} from "fs"; -import {DocData, MetaData, MetaDescriptions, MetaPatterns} from "./types"; +import {DocData, MetaData, MetaDescriptions} from "./types"; class MetaFile { private readonly path: string; @@ -33,9 +33,7 @@ class MetaFile { } get patternDescriptions(): MetaDescriptions { - return this.fileData.hasOwnProperty('patterns') - ? (this.fileData as MetaPatterns).patterns - : (this.fileData as MetaDescriptions); + return (this.fileData as MetaDescriptions); } } diff --git a/src/lib/Repository.ts b/src/lib/Repository.ts index 8eef720..9049ec6 100644 --- a/src/lib/Repository.ts +++ b/src/lib/Repository.ts @@ -6,19 +6,16 @@ import MetaFile from "./MetaFile"; class Repository { private readonly name: string; private readonly metaDescriptions: MetaFile; - private readonly metaPatterns: MetaFile; private readonly docFileData: Record; constructor( name: string, docsDir: string, docDescriptionPath: string, - docPatternsPath: string, namePrefix: string = "codacy-" ) { this.name = namePrefix ? name.replace(namePrefix, "") : name; this.metaDescriptions = MetaFile.load(docDescriptionPath); - this.metaPatterns = MetaFile.load(docPatternsPath); this.docFileData = this.loadDocFiles(docsDir, this.metaDescriptions.patternDescriptions); logger.info(`Found ${Object.keys(this.docFileData).length} documentation files.`); } @@ -30,12 +27,10 @@ class Repository { saveAll() { this.docs.forEach((doc) => doc.save()); this.metaDescriptions.save(); - this.metaPatterns.save(); } updateMeta(data: DocData) { this.metaDescriptions.update(data); - this.metaPatterns.update(data); } private loadDocFiles(docsDir: string, docDescriptions: MetaDescriptions) { diff --git a/src/lib/init.ts b/src/lib/init.ts index 5b08f70..9acde89 100644 --- a/src/lib/init.ts +++ b/src/lib/init.ts @@ -12,7 +12,6 @@ const PATHS_PROMPTS = glob.sync(join(__dirname, "..", "prompts", "*.json")).sort // TODO getInput doesn't read default values from action.yml locally. Should it? const DOCS_DIR = getInput('docs_dir') || "docs/description"; const DOC_DESCRIPTIONS_PATH = getInput('doc_descriptions_path') || "docs/description/description.json"; -const DOC_PATTERNS_PATH = getInput('doc_patterns_path') || "docs/patterns.json"; export { API_KEY_OPENAI, @@ -20,5 +19,4 @@ export { PATHS_PROMPTS, DOCS_DIR, DOC_DESCRIPTIONS_PATH, - DOC_PATTERNS_PATH, }; diff --git a/src/lib/types.d.ts b/src/lib/types.d.ts index 40f49fe..94a79a2 100644 --- a/src/lib/types.d.ts +++ b/src/lib/types.d.ts @@ -35,8 +35,7 @@ export type DocDescription = { patPatBotReviewed?: string, }; export type MetaDescriptions = DocDescription[]; // see docs/description/description.json -export type MetaPatterns = { patterns: MetaDescriptions }; // see docs/patterns.json -export type MetaData = MetaDescriptions | MetaPatterns; +export type MetaData = MetaDescriptions; // The following helper types represent the expected shape of the prompt files content. export type PromptTemplateData = {