diff --git a/.claude/skills/defuddle/SKILL.md b/.claude/skills/defuddle/SKILL.md new file mode 100644 index 0000000..287b1fc --- /dev/null +++ b/.claude/skills/defuddle/SKILL.md @@ -0,0 +1,41 @@ +--- +name: defuddle +description: Extract clean markdown content from web pages using Defuddle CLI, removing clutter and navigation to save tokens. Use instead of WebFetch when the user provides a URL to read or analyze, for online documentation, articles, blog posts, or any standard web page. Do NOT use for URLs ending in .md — those are already markdown, use WebFetch directly. +--- + +# Defuddle + +Use Defuddle CLI to extract clean readable content from web pages. Prefer over WebFetch for standard web pages — it removes navigation, ads, and clutter, reducing token usage. + +If not installed: `npm install -g defuddle` + +## Usage + +Always use `--md` for markdown output: + +```bash +defuddle parse --md +``` + +Save to file: + +```bash +defuddle parse --md -o content.md +``` + +Extract specific metadata: + +```bash +defuddle parse -p title +defuddle parse -p description +defuddle parse -p domain +``` + +## Output formats + +| Flag | Format | +|------|--------| +| `--md` | Markdown (default choice) | +| `--json` | JSON with both HTML and markdown | +| (none) | HTML | +| `-p ` | Specific metadata property | diff --git a/.claude/skills/excalidraw-diagram/SKILL.md b/.claude/skills/excalidraw-diagram/SKILL.md new file mode 100644 index 0000000..0534315 --- /dev/null +++ b/.claude/skills/excalidraw-diagram/SKILL.md @@ -0,0 +1,476 @@ +--- +name: excalidraw-diagram +description: Generate Excalidraw diagrams from text content. Supports three output modes - Obsidian (.md), Standard (.excalidraw), and Animated (.excalidraw with animation order). Triggers on "Excalidraw", "画图", "流程图", "思维导图", "可视化", "diagram", "标准Excalidraw", "standard excalidraw", "Excalidraw动画", "动画图", "animate". +metadata: + version: 1.2.1 +--- + +# Excalidraw Diagram Generator + +Create Excalidraw diagrams from text content with multiple output formats. + +## Output Modes + +根据用户的触发词选择输出模式： + +| 触发词 | 输出模式 | 文件格式 | 用途 | +|--------|----------|----------|------| +| `Excalidraw`、`画图`、`流程图`、`思维导图` | **Obsidian**（默认） | `.md` | 在 Obsidian 中直接打开 | +| `标准Excalidraw`、`standard excalidraw` | **Standard** | `.excalidraw` | 在 excalidraw.com 打开/编辑/分享 | +| `Excalidraw动画`、`动画图`、`animate` | **Animated** | `.excalidraw` | 拖到 excalidraw-animate 生成动画 | + +## Workflow + +1. **Detect output mode** from trigger words (see Output Modes table above) +2. Analyze content - identify concepts, relationships, hierarchy +3. Choose diagram type (see Diagram Types below) +4. Generate Excalidraw JSON (add animation order if Animated mode) +5. Output in correct format based on mode +6. **Automatically save to current working directory** +7. Notify user with file path and usage instructions + +## Output Formats + +### Mode 1: Obsidian Format (Default) + +**严格按照以下结构输出，不得有任何修改：** + +```markdown +--- +excalidraw-plugin: parsed +tags: [excalidraw] +--- +==⚠ Switch to EXCALIDRAW VIEW in the MORE OPTIONS menu of this document. ⚠== You can decompress Drawing data with the command palette: 'Decompress current Excalidraw file'. For more info check in plugin settings under 'Saving' + +# Excalidraw Data + +## Text Elements +%% +## Drawing +\`\`\`json +{JSON 完整数据} +\`\`\` +%% +``` + +**关键要点：** +- Frontmatter 必须包含 `tags: [excalidraw]` +- 警告信息必须完整 +- JSON 必须被 `%%` 标记包围 +- 不能使用 `excalidraw-plugin: parsed` 以外的其他 frontmatter 设置 +- **文件扩展名**：`.md` + +### Mode 2: Standard Excalidraw Format + +直接输出纯 JSON 文件，可在 excalidraw.com 打开： + +```json +{ + "type": "excalidraw", + "version": 2, + "source": "https://excalidraw.com", + "elements": [...], + "appState": { + "gridSize": null, + "viewBackgroundColor": "#ffffff" + }, + "files": {} +} +``` + +**关键要点：** +- `source` 使用 `https://excalidraw.com`（不是 Obsidian 插件） +- 纯 JSON，无 Markdown 包装 +- **文件扩展名**：`.excalidraw` + +### Mode 3: Animated Excalidraw Format + +与 Standard 格式相同，但每个元素添加 `customData.animate` 字段控制动画顺序： + +```json +{ + "id": "element-1", + "type": "rectangle", + "customData": { + "animate": { + "order": 1, + "duration": 500 + } + }, + ...其他标准字段 +} +``` + +**动画顺序规则：** +- `order`: 动画播放顺序（1, 2, 3...），数字越小越先出现 +- `duration`: 该元素的绘制时长（毫秒），默认 500 +- 相同 `order` 的元素同时出现 +- 建议顺序：标题 → 主要框架 → 连接线 → 细节文字 + +**使用方法：** +1. 生成 `.excalidraw` 文件 +2. 拖到 https://dai-shi.github.io/excalidraw-animate/ +3. 点击 Animate 预览，然后导出 SVG 或 WebM + +**文件扩展名**：`.excalidraw` + +--- + +## Diagram Types & Selection Guide + +选择合适的图表形式，以提升理解力与视觉吸引力。 + +| 类型 | 英文 | 使用场景 | 做法 | +|------|------|---------|------| +| **流程图** | Flowchart | 步骤说明、工作流程、任务执行顺序 | 用箭头连接各步骤，清晰表达流程走向 | +| **思维导图** | Mind Map | 概念发散、主题分类、灵感捕捉 | 以中心为核心向外发散，放射状结构 | +| **层级图** | Hierarchy | 组织结构、内容分级、系统拆解 | 自上而下或自左至右构建层级节点 | +| **关系图** | Relationship | 要素之间的影响、依赖、互动 | 图形间用连线表示关联，箭头与说明 | +| **对比图** | Comparison | 两种以上方案或观点的对照分析 | 左右两栏或表格形式，标明比较维度 | +| **时间线图** | Timeline | 事件发展、项目进度、模型演化 | 以时间为轴，标出关键时间点与事件 | +| **矩阵图** | Matrix | 双维度分类、任务优先级、定位 | 建立 X 与 Y 两个维度，坐标平面安置 | +| **自由布局** | Freeform | 内容零散、灵感记录、初步信息收集 | 无需结构限制，自由放置图块与箭头 | + +## Design Rules + +### Text & Format +- **所有文本元素必须使用** `fontFamily: 5`（Excalifont 手写字体） +- **文本中的双引号替换规则**：`"` 替换为 `『』` +- **文本中的圆括号替换规则**：`()` 替换为 `「」` +- **字体大小规则**（硬性下限，低于此值在正常缩放下不可读）： + - 标题：20-28px（最小 20px） + - 副标题：18-20px + - 正文/标签：16-18px（最小 16px） + - 次要注释：14px（仅限不重要的辅助说明，慎用） + - **绝对禁止低于 14px** +- **行高**：所有文本使用 `lineHeight: 1.25` +- **文字居中估算**：独立文本元素没有自动居中，需手动计算 x 坐标： + - 估算文字宽度：`estimatedWidth = text.length * fontSize * 0.5`（CJK 字符用 `* 1.0`） + - 居中公式：`x = centerX - estimatedWidth / 2` + - 示例：文字 "Hello"（5字符, fontSize 20）居中于 x=300 → `estimatedWidth = 5 * 20 * 0.5 = 50` → `x = 300 - 25 = 275` + +### Layout & Design +- **画布范围**：建议所有元素在 0-1200 x 0-800 区域内 +- **最小形状尺寸**：带文字的矩形/椭圆不小于 120x60px +- **元素间距**：最小 20-30px 间距，防止重叠 +- **层次清晰**：使用不同颜色和形状区分不同层级的信息 +- **图形元素**：适当使用矩形框、圆形、箭头等元素来组织信息 +- **禁止 Emoji**：不要在图表文本中使用任何 Emoji 符号，如需视觉标记请使用简单图形（圆形、方形、箭头）或颜色区分 + +### Color Palette + +**文字颜色（strokeColor for text）：** + +| 用途 | 色值 | 说明 | +|------|------|------| +| 标题 | `#1e40af` | 深蓝 | +| 副标题/连接线 | `#3b82f6` | 亮蓝 | +| 正文文字 | `#374151` | 深灰（白底最浅不低于 `#757575`） | +| 强调/重点 | `#f59e0b` | 金色 | + +**形状填充色（backgroundColor, fillStyle: "solid"）：** + +| 色值 | 语义 | 适用场景 | +|------|------|---------| +| `#a5d8ff` | 浅蓝 | 输入、数据源、主要节点 | +| `#b2f2bb` | 浅绿 | 成功、输出、已完成 | +| `#ffd8a8` | 浅橙 | 警告、待处理、外部依赖 | +| `#d0bfff` | 浅紫 | 处理中、中间件、特殊项 | +| `#ffc9c9` | 浅红 | 错误、关键、告警 | +| `#fff3bf` | 浅黄 | 备注、决策、规划 | +| `#c3fae8` | 浅青 | 存储、数据、缓存 | +| `#eebefa` | 浅粉 | 分析、指标、统计 | + +**区域背景色（大矩形 + opacity: 30，用于分层图表）：** + +| 色值 | 语义 | +|------|------| +| `#dbe4ff` | 前端/UI 层 | +| `#e5dbff` | 逻辑/处理层 | +| `#d3f9d8` | 数据/工具层 | + +**对比度规则：** +- 白底上文字最浅不低于 `#757575`，否则不可读 +- 浅色填充上用深色变体文字（如浅绿底用 `#15803d`，不用 `#22c55e`） +- 避免浅灰色文字（`#b0b0b0`、`#999`）出现在白底上 + +参考：[references/excalidraw-schema.md](references/excalidraw-schema.md) + +## JSON Structure + +**Obsidian 模式：** +```json +{ + "type": "excalidraw", + "version": 2, + "source": "https://github.com/zsviczian/obsidian-excalidraw-plugin", + "elements": [...], + "appState": { "gridSize": null, "viewBackgroundColor": "#ffffff" }, + "files": {} +} +``` + +**Standard / Animated 模式：** +```json +{ + "type": "excalidraw", + "version": 2, + "source": "https://excalidraw.com", + "elements": [...], + "appState": { "gridSize": null, "viewBackgroundColor": "#ffffff" }, + "files": {} +} +``` + +## Element Template + +Each element requires these fields (do NOT add extra fields like `frameId`, `index`, `versionNonce`, `rawText` -- they may cause issues on excalidraw.com. `boundElements` must be `null` not `[]`, `updated` must be `1` not timestamps): + +```json +{ + "id": "unique-id", + "type": "rectangle", + "x": 100, "y": 100, + "width": 200, "height": 50, + "angle": 0, + "strokeColor": "#1e1e1e", + "backgroundColor": "transparent", + "fillStyle": "solid", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "groupIds": [], + "roundness": {"type": 3}, + "seed": 123456789, + "version": 1, + "isDeleted": false, + "boundElements": null, + "updated": 1, + "link": null, + "locked": false +} +``` + +`strokeStyle` values: `"solid"`（实线，默认）| `"dashed"`（虚线）| `"dotted"`（点线）。虚线适合表示可选路径、异步流、弱关联等。 + +Text elements add: +```json +{ + "text": "显示文本", + "fontSize": 20, + "fontFamily": 5, + "textAlign": "center", + "verticalAlign": "middle", + "containerId": null, + "originalText": "显示文本", + "autoResize": true, + "lineHeight": 1.25 +} +``` + +**Animated 模式额外添加** `customData` 字段： +```json +{ + "id": "title-1", + "type": "text", + "customData": { + "animate": { + "order": 1, + "duration": 500 + } + }, + ...其他字段 +} +``` + +See [references/excalidraw-schema.md](references/excalidraw-schema.md) for all element types. + +--- + +## Additional Technical Requirements + +### Text Elements 处理 +- `## Text Elements` 部分在 Markdown 中**必须留空**，仅用 `%%` 作为分隔符 +- Obsidian ExcaliDraw 插件会根据 JSON 数据**自动填充文本元素** +- 不需要手动列出所有文本内容 + +### 坐标与布局 +- **坐标系统**：左上角为原点 (0,0) +- **推荐范围**：所有元素在 0-1200 x 0-800 像素范围内 +- **元素 ID**：每个元素需要唯一的 `id`（可以是字符串，如「title」「box1」等） + +### Required Fields for All Elements + +**IMPORTANT**: Do NOT include `frameId`, `index`, `versionNonce`, or `rawText` fields. Use `boundElements: null` (not `[]`), and `updated: 1` (not timestamps). + +```json +{ + "id": "unique-identifier", + "type": "rectangle|text|arrow|ellipse|diamond", + "x": 100, "y": 100, + "width": 200, "height": 50, + "angle": 0, + "strokeColor": "#color-hex", + "backgroundColor": "transparent|#color-hex", + "fillStyle": "solid", + "strokeWidth": 2, + "strokeStyle": "solid|dashed|dotted", + "roughness": 1, + "opacity": 100, + "groupIds": [], + "roundness": {"type": 3}, + "seed": 123456789, + "version": 1, + "isDeleted": false, + "boundElements": null, + "updated": 1, + "link": null, + "locked": false +} +``` + +### Text-Specific Properties +文本元素 (type: "text") 需要额外属性（do NOT include `rawText`）： +```json +{ + "text": "显示文本", + "fontSize": 20, + "fontFamily": 5, + "textAlign": "center", + "verticalAlign": "middle", + "containerId": null, + "originalText": "显示文本", + "autoResize": true, + "lineHeight": 1.25 +} +``` + +### appState 配置 +```json +"appState": { + "gridSize": null, + "viewBackgroundColor": "#ffffff" +} +``` + +### files 字段 +```json +"files": {} +``` + +## Common Mistakes to Avoid + +- **文字偏移** — 独立 text 元素的 `x` 是左边缘，不是中心。必须用居中公式手动计算，否则文字会偏到一边 +- **元素重叠** — y 坐标相近的元素容易堆叠。放置新元素前检查与周围元素是否有至少 20px 间距 +- **画布留白不足** — 内容不要贴着画布边缘。在四周留 50-80px 的 padding +- **标题没有居中于图表** — 标题应居中于下方图表的整体宽度，不是固定在 x=0 +- **箭头标签溢出** — 长文字标签（如 "ATP + NADPH"）会超出短箭头。保持标签简短或加大箭头长度 +- **对比度不够** — 浅色文字在白底上几乎不可见。文字颜色不低于 `#757575`，有色文字用深色变体 +- **字号太小** — 低于 14px 在正常缩放下不可读，正文最小 16px + +## Implementation Notes + +### Auto-save & File Generation Workflow + +当生成 Excalidraw 图表时，**必须自动执行以下步骤**： + +#### 1. 选择合适的图表类型 +- 根据用户提供的内容特性，参考上方 「Diagram Types & Selection Guide」 表 +- 分析内容的核心诉求，选择最合适的可视化形式 + +#### 2. 生成有意义的文件名 + +根据输出模式选择文件扩展名： + +| 模式 | 文件名格式 | 示例 | +|------|-----------|------| +| Obsidian | `[主题].[类型].md` | `商业模式.relationship.md` | +| Standard | `[主题].[类型].excalidraw` | `商业模式.relationship.excalidraw` | +| Animated | `[主题].[类型].animate.excalidraw` | `商业模式.relationship.animate.excalidraw` | + +- 优先使用中文以提高清晰度 + +#### 3. 使用 Write 工具自动保存文件 +- **保存位置**：当前工作目录（自动检测环境变量） +- **完整路径**：`{current_directory}/[filename].md` +- 这样可以实现灵活迁移，无需硬编码路径 + +#### 4. 确保 Markdown 结构完全正确 +**必须按以下格式生成**（不能有任何修改）： + +```markdown +--- +excalidraw-plugin: parsed +tags: [excalidraw] +--- +==⚠ Switch to EXCALIDRAW VIEW in the MORE OPTIONS menu of this document. ⚠== You can decompress Drawing data with the command palette: 'Decompress current Excalidraw file'. For more info check in plugin settings under 'Saving' + +# Excalidraw Data + +## Text Elements +%% +## Drawing +\`\`\`json +{完整的 JSON 数据} +\`\`\` +%% +``` + +#### 5. JSON 数据要求 +- 包含完整的 Excalidraw JSON 结构 +- 所有文本元素使用 `fontFamily: 5` +- 文本中的 `"` 替换为 `『』` +- 文本中的 `()` 替换为 `「」` +- JSON 格式必须有效，通过语法检查 +- 所有元素有唯一的 `id` +- 包含 `appState` 和 `files: {}` 字段 + +#### 6. 用户反馈与确认 +向用户报告： +- 图表已生成 +- 精确的保存位置 +- 如何在 Obsidian 中查看 +- 图表的设计选择说明（选择了什么类型的图表、为什么） +- 是否需要调整或修改 + +### Example Output Messages + +**Obsidian 模式：** +``` +Excalidraw 图已生成！ + +保存位置：商业模式.relationship.md + +使用方法： +1. 在 Obsidian 中打开此文件 +2. 点击右上角 MORE OPTIONS 菜单 +3. 选择 Switch to EXCALIDRAW VIEW +``` + +**Standard 模式：** +``` +Excalidraw 图已生成！ + +保存位置：商业模式.relationship.excalidraw + +使用方法： +1. 打开 https://excalidraw.com +2. 点击左上角菜单 → Open → 选择此文件 +3. 或直接拖拽文件到 excalidraw.com 页面 +``` + +**Animated 模式：** +``` +Excalidraw 动画图已生成！ + +保存位置：商业模式.relationship.animate.excalidraw + +动画顺序：标题(1) → 主框架(2-4) → 连接线(5-7) → 说明文字(8-10) + +生成动画： +1. 打开 https://dai-shi.github.io/excalidraw-animate/ +2. 点击 Load File 选择此文件 +3. 预览动画效果 +4. 点击 Export 导出 SVG 或 WebM +``` diff --git a/.claude/skills/excalidraw-diagram/references/excalidraw-schema.md b/.claude/skills/excalidraw-diagram/references/excalidraw-schema.md new file mode 100644 index 0000000..c890d82 --- /dev/null +++ b/.claude/skills/excalidraw-diagram/references/excalidraw-schema.md @@ -0,0 +1,201 @@ +# Excalidraw JSON Schema Reference + +## Color Palette + +### Primary Colors +| Purpose | Color | Hex | +|---------|-------|-----| +| Main Title | Deep Blue | `#1e40af` | +| Subtitle | Medium Blue | `#3b82f6` | +| Body Text | Dark Gray | `#374151` | +| Emphasis | Orange | `#f59e0b` | +| Success | Green | `#10b981` | +| Warning | Red | `#ef4444` | + +### Background Colors +| Purpose | Color | Hex | +|---------|-------|-----| +| Light Blue | Background | `#dbeafe` | +| Light Gray | Neutral | `#f3f4f6` | +| Light Orange | Highlight | `#fef3c7` | +| Light Green | Success | `#d1fae5` | +| Light Purple | Accent | `#ede9fe` | + +## Element Types + +### Rectangle +```json +{ + "type": "rectangle", + "id": "unique-id", + "x": 100, + "y": 100, + "width": 200, + "height": 80, + "strokeColor": "#1e40af", + "backgroundColor": "#dbeafe", + "fillStyle": "solid", + "strokeWidth": 2, + "roughness": 1, + "opacity": 100, + "roundness": { "type": 3 } +} +``` + +### Text +```json +{ + "type": "text", + "id": "unique-id", + "x": 150, + "y": 130, + "text": "Content here", + "fontSize": 20, + "fontFamily": 5, + "textAlign": "center", + "verticalAlign": "middle", + "strokeColor": "#1e40af", + "backgroundColor": "transparent" +} +``` + +### Arrow +```json +{ + "type": "arrow", + "id": "unique-id", + "x": 300, + "y": 140, + "width": 100, + "height": 0, + "points": [[0, 0], [100, 0]], + "strokeColor": "#374151", + "strokeWidth": 2, + "startArrowhead": null, + "endArrowhead": "arrow" +} +``` + +### Ellipse +```json +{ + "type": "ellipse", + "id": "unique-id", + "x": 100, + "y": 100, + "width": 120, + "height": 120, + "strokeColor": "#10b981", + "backgroundColor": "#d1fae5", + "fillStyle": "solid" +} +``` + +### Diamond +```json +{ + "type": "diamond", + "id": "unique-id", + "x": 100, + "y": 100, + "width": 150, + "height": 100, + "strokeColor": "#f59e0b", + "backgroundColor": "#fef3c7", + "fillStyle": "solid" +} +``` + +### Line +```json +{ + "type": "line", + "id": "unique-id", + "x": 100, + "y": 100, + "points": [[0, 0], [200, 100]], + "strokeColor": "#374151", + "strokeWidth": 2 +} +``` + +## Full JSON Structure + +```json +{ + "type": "excalidraw", + "version": 2, + "source": "https://excalidraw.com", + "elements": [ + // Array of elements + ], + "appState": { + "gridSize": null, + "viewBackgroundColor": "#ffffff" + }, + "files": {} +} +``` + +## Font Family Values + +| Value | Font Name | +|-------|-----------| +| 1 | Virgil (hand-drawn) | +| 2 | Helvetica | +| 3 | Cascadia | +| 4 | Assistant | +| 5 | Excalifont (recommended) | + +## Fill Styles + +- `solid` - Solid fill +- `hachure` - Hatched lines +- `cross-hatch` - Cross-hatched +- `dots` - Dotted pattern + +## Roundness Types + +- `{ "type": 1 }` - Sharp corners +- `{ "type": 2 }` - Slight rounding +- `{ "type": 3 }` - Full rounding (recommended) + +## Element Binding + +To connect text to a container: + +```json +{ + "type": "rectangle", + "id": "container-id", + "boundElements": [{ "id": "text-id", "type": "text" }] +} +``` + +```json +{ + "type": "text", + "id": "text-id", + "containerId": "container-id" +} +``` + +## Arrow Binding + +To connect arrows to shapes: + +```json +{ + "type": "arrow", + "startBinding": { + "elementId": "source-shape-id", + "focus": 0, + "gap": 5 + }, + "endBinding": { + "elementId": "target-shape-id", + "focus": 0, + "gap": 5 + } +} +``` diff --git a/.claude/skills/mermaid-visualizer/SKILL.md b/.claude/skills/mermaid-visualizer/SKILL.md new file mode 100644 index 0000000..d9ed66c --- /dev/null +++ b/.claude/skills/mermaid-visualizer/SKILL.md @@ -0,0 +1,276 @@ +--- +name: mermaid-visualizer +description: Transform text content into professional Mermaid diagrams for presentations and documentation. Use when users ask to visualize concepts, create flowcharts, or make diagrams from text. Supports process flows, system architectures, comparisons, mindmaps, and more with built-in syntax error prevention. +--- + +# Mermaid Visualizer + +## Overview + +Convert text content into clean, professional Mermaid diagrams optimized for presentations and documentation. Automatically handles common syntax pitfalls (list syntax conflicts, subgraph naming, spacing issues) to ensure diagrams render correctly in Obsidian, GitHub, and other Mermaid-compatible platforms. + +## Quick Start + +When creating a Mermaid diagram: + +1. **Analyze the content** - Identify key concepts, relationships, and flow +2. **Choose diagram type** - Select the most appropriate visualization (see Diagram Types below) +3. **Select configuration** - Determine layout, detail level, and styling +4. **Generate diagram** - Create syntactically correct Mermaid code +5. **Output in markdown** - Wrap in proper code fence with optional explanation + +**Default assumptions:** +- Vertical layout (TB) unless horizontal requested +- Medium detail level (balanced between simplicity and information) +- Professional color scheme with semantic colors +- Obsidian/GitHub compatible syntax + +## Diagram Types + +### 1. Process Flow (graph TB/LR) +**Best for:** Workflows, decision trees, sequential processes, AI agent architectures + +**Use when:** Content describes steps, stages, or a sequence of actions + +**Key features:** +- Swimlanes via subgraph for grouping related steps +- Arrow labels for transitions +- Feedback loops and branches +- Color-coded stages + +**Configuration options:** +- `layout`: "vertical" (TB), "horizontal" (LR) +- `detail`: "simple" (core steps only), "standard" (with descriptions), "detailed" (with annotations) +- `style`: "minimal", "professional", "colorful" + +### 2. Circular Flow (graph TD with circular layout) +**Best for:** Cyclic processes, continuous improvement loops, agent feedback systems + +**Use when:** Content emphasizes iteration, feedback, or circular relationships + +**Key features:** +- Central hub with radiating elements +- Curved feedback arrows +- Clear cycle indicators + +### 3. Comparison Diagram (graph TB with parallel paths) +**Best for:** Before/after comparisons, A vs B analysis, traditional vs modern systems + +**Use when:** Content contrasts two or more approaches or systems + +**Key features:** +- Side-by-side layout +- Central comparison node +- Clear differentiation via color/style + +### 4. Mindmap +**Best for:** Hierarchical concepts, knowledge organization, topic breakdowns + +**Use when:** Content is hierarchical with clear parent-child relationships + +**Key features:** +- Radial tree structure +- Multiple levels of nesting +- Clean visual hierarchy + +### 5. Sequence Diagram +**Best for:** Interactions between components, API calls, message flows + +**Use when:** Content involves communication between actors/systems over time + +**Key features:** +- Timeline-based layout +- Clear actor separation +- Activation boxes for processes + +### 6. State Diagram +**Best for:** System states, status transitions, lifecycle stages + +**Use when:** Content describes states and transitions between them + +**Key features:** +- Clear state nodes +- Labeled transitions +- Start and end states + +## Critical Syntax Rules + +**Always follow these rules to prevent parsing errors:** + +### Rule 1: Avoid List Syntax Conflicts +``` +❌ WRONG: [1. Perception] → Triggers "Unsupported markdown: list" +✅ RIGHT: [1.Perception] → Remove space after period +✅ RIGHT: [① Perception] → Use circled numbers (①②③④⑤⑥⑦⑧⑨⑩) +✅ RIGHT: [(1) Perception] → Use parentheses +✅ RIGHT: [Step 1: Perception] → Use "Step" prefix +``` + +### Rule 2: Subgraph Naming +``` +❌ WRONG: subgraph AI Agent Core → Space in name without quotes +✅ RIGHT: subgraph agent["AI Agent Core"] → Use ID with display name +✅ RIGHT: subgraph agent → Use simple ID only +``` + +### Rule 3: Node References +``` +❌ WRONG: Title --> AI Agent Core → Reference display name directly +✅ RIGHT: Title --> agent → Reference subgraph ID +``` + +### Rule 4: Special Characters in Node Text +``` +✅ Use quotes for text with spaces: ["Text with spaces"] +✅ Escape or avoid: quotation marks → use 『』instead +✅ Escape or avoid: parentheses → use 「」instead +✅ Line breaks in circle nodes only: ((Text
Break)) +``` + +### Rule 5: Arrow Types +- `-->` solid arrow +- `-.->` dashed arrow (for supporting systems, optional paths) +- `==>` thick arrow (for emphasis) +- `~~~` invisible link (for layout only) + +For complete syntax reference and edge cases, see [references/syntax-rules.md](references/syntax-rules.md) + +## Configuration Options + +All diagrams accept these parameters: + +**Layout:** +- `direction`: "vertical" (TB), "horizontal" (LR), "right-to-left" (RL), "bottom-to-top" (BT) +- `aspect`: "portrait" (default), "landscape" (wide), "square" + +**Detail Level:** +- `simple`: Core elements only, minimal labels +- `standard`: Balanced detail with key descriptions (default) +- `detailed`: Full annotations, explanations, and metadata +- `presentation`: Optimized for slides (larger text, fewer details) + +**Style:** +- `minimal`: Monochrome, clean lines +- `professional`: Semantic colors, clear hierarchy (default) +- `colorful`: Vibrant colors, high contrast +- `academic`: Formal styling for papers/documentation + +**Additional Options:** +- `show_legend`: true/false - Include color/symbol legend +- `numbered`: true/false - Add sequence numbers to steps +- `title`: string - Add diagram title + +## Example Usage Patterns + +**Pattern 1: Basic request** +``` +User: "Visualize the software development lifecycle" +Response: [Analyze → Choose graph TB → Generate with standard detail] +``` + +**Pattern 2: With configuration** +``` +User: "Create a horizontal flowchart of our sales process with lots of detail" +Response: [Analyze → Choose graph LR → Generate with detailed level] +``` + +**Pattern 3: Comparison** +``` +User: "Compare traditional AI vs AI agents" +Response: [Analyze → Choose comparison layout → Generate with contrasting styles] +``` + +## Workflow + +1. **Understand the content** + - Identify main concepts, entities, and relationships + - Determine hierarchy or sequence + - Note any comparisons or contrasts + +2. **Select diagram type** + - Match content structure to diagram type + - Consider user's presentation context + - Default to process flow if ambiguous + +3. **Choose configuration** + - Apply user-specified options + - Use sensible defaults for unspecified options + - Optimize for readability + +4. **Generate Mermaid code** + - Follow all syntax rules strictly + - Use semantic naming (descriptive IDs) + - Apply consistent styling + - Test for common errors: + * No "number. space" patterns in node text + * All subgraphs use ID["display name"] format + * All node references use IDs not display names + +5. **Output with context** + - Wrap in ```mermaid code fence + - Add brief explanation of diagram structure + - Mention rendering compatibility (Obsidian, GitHub, etc.) + - Offer to adjust or create variations + +## Color Scheme Defaults + +Standard professional palette: +- Green (#d3f9d8/#2f9e44): Input, perception, start states +- Red (#ffe3e3/#c92a2a): Planning, decision points +- Purple (#e5dbff/#5f3dc4): Processing, reasoning +- Orange (#ffe8cc/#d9480f): Actions, tool usage +- Cyan (#c5f6fa/#0c8599): Output, execution, results +- Yellow (#fff4e6/#e67700): Storage, memory, data +- Pink (#f3d9fa/#862e9c): Learning, optimization +- Blue (#e7f5ff/#1971c2): Metadata, definitions, titles +- Gray (#f8f9fa/#868e96): Neutral elements, traditional systems + +## Common Patterns + +### Swimlane Pattern (Grouping) +```mermaid +graph TB + subgraph core["Core Process"] + A --> B --> C + end + subgraph support["Supporting Systems"] + D + E + end + core -.-> support +``` + +### Feedback Loop Pattern +```mermaid +graph TB + A[Start] --> B[Process] + B --> C[End] + C -.->|Feedback| A +``` + +### Hub and Spoke Pattern +```mermaid +graph TB + Central[Hub] + A[Spoke 1] --> Central + B[Spoke 2] --> Central + C[Spoke 3] --> Central +``` + +## Quality Checklist + +Before outputting, verify: +- [ ] No "number. space" patterns in any node text +- [ ] All subgraphs use proper ID syntax +- [ ] All arrows use correct syntax (-->, -.->) +- [ ] Colors applied consistently +- [ ] Layout direction specified +- [ ] Style declarations present +- [ ] No ambiguous node references +- [ ] Compatible with Obsidian/GitHub renderers +- [ ] **No Emoji** in any node text - use text labels or color coding instead + +## References + +For detailed syntax rules and troubleshooting, see: +- [references/syntax-rules.md](references/syntax-rules.md) - Complete syntax reference and error prevention diff --git a/.claude/skills/mermaid-visualizer/references/syntax-rules.md b/.claude/skills/mermaid-visualizer/references/syntax-rules.md new file mode 100644 index 0000000..75a319a --- /dev/null +++ b/.claude/skills/mermaid-visualizer/references/syntax-rules.md @@ -0,0 +1,484 @@ +# Mermaid Syntax Rules Reference + +This reference provides comprehensive syntax rules and error prevention strategies for Mermaid diagrams. Load this when encountering syntax errors or needing detailed syntax information. + +## Table of Contents + +1. [Critical Error Prevention](#critical-error-prevention) +2. [Node Syntax](#node-syntax) +3. [Subgraph Syntax](#subgraph-syntax) +4. [Arrow and Connection Types](#arrow-and-connection-types) +5. [Styling and Colors](#styling-and-colors) +6. [Layout and Direction](#layout-and-direction) +7. [Advanced Patterns](#advanced-patterns) +8. [Troubleshooting](#troubleshooting) + +## Critical Error Prevention + +### List Syntax Conflict (Most Common Error) + +**Problem:** Mermaid parser interprets `number. space` as Markdown ordered list syntax. + +**Error Message:** `Parse error: Unsupported markdown: list` + +**Solutions:** + +```mermaid +❌ [1. Perception] +❌ [2. Planning] +❌ [3. Reasoning] + +✅ [1.Perception] # Remove space +✅ [① Perception] # Use circled numbers +✅ [(1) Perception] # Use parentheses +✅ [Step 1: Perception] # Use prefix +✅ [Step 1 - Perception] # Use dash +✅ [Perception] # Remove numbering +``` + +**Circled number reference:** +``` +① ② ③ ④ ⑤ ⑥ ⑦ ⑧ ⑨ ⑩ ⑪ ⑫ ⑬ ⑭ ⑮ ⑯ ⑰ ⑱ ⑲ ⑳ +``` + +### Subgraph Naming Rules + +**Rule:** Subgraphs with spaces must use ID + display name format. + +```mermaid +❌ subgraph Core Process + A --> B + end + +✅ subgraph core["Core Process"] + A --> B + end + +✅ subgraph core_process + A --> B + end +``` + +**Referencing subgraphs:** +```mermaid +❌ Title --> Core Process # Cannot reference display name +✅ Title --> core # Must reference ID +``` + +### Node Reference Rules + +**Rule:** Always reference nodes by ID, never by display text. + +```mermaid +# Define nodes +A[Display Text A] +B["Display Text B"] + +# Reference nodes +A --> B ✅ Use node IDs +Display Text A --> Display Text B ❌ Cannot use display text +``` + +## Node Syntax + +### Basic Node Types + +```mermaid +# Rectangle (default) +A[Rectangle Text] + +# Rectangle with rounded corners +B(Rounded Text) + +# Stadium shape +C([Stadium Text]) + +# Circle +D((Circle
Text)) + +# Asymmetric shape +E>Right Arrow] + +# Rhombus (decision) +F{Decision?} + +# Hexagon +G{{Hexagon}} + +# Parallelogram +H[/Parallelogram/] + +# Database +I[(Database)] + +# Trapezoid +J[/Trapezoid\] +``` + +### Node Text Rules + +**Line breaks:** +- `
` only works in circle nodes: `((Text
Break))` +- For other nodes, use separate annotation nodes or keep text concise + +**Special characters:** +- Spaces: Use quotes if needed: `["Text with spaces"]` +- Quotes: Replace with 『』or avoid +- Parentheses: Replace with 「」or avoid +- Colons: Generally safe but avoid if causing issues +- Hyphens/dashes: Safe to use + +**Length guidelines:** +- Keep node text under 50 characters +- Use multiple lines (circle nodes) or separate annotation nodes for longer content +- Consider splitting into multiple nodes if text is too long + +## Subgraph Syntax + +### Basic Structure + +```mermaid +graph TB + # Correct format with ID and display name + subgraph id["Display Name"] + direction TB + A --> B + end + + # Simple ID only (no spaces) + subgraph simple + C --> D + end + + # Can set direction inside subgraph + subgraph horiz["Horizontal"] + direction LR + E --> F + end +``` + +### Nested Subgraphs + +```mermaid +graph TB + subgraph outer["Outer Group"] + direction TB + + subgraph inner1["Inner 1"] + A --> B + end + + subgraph inner2["Inner 2"] + C --> D + end + + inner1 -.-> inner2 + end +``` + +**Limitation:** Keep nesting to 2 levels maximum for readability. + +### Connecting Subgraphs + +```mermaid +graph TB + subgraph g1["Group 1"] + A[Node A] + end + + subgraph g2["Group 2"] + B[Node B] + end + + # Connect individual nodes (recommended) + A --> B + + # Connect subgraphs (creates invisible link for layout) + g1 -.-> g2 +``` + +## Arrow and Connection Types + +### Basic Arrows + +```mermaid +A --> B # Solid arrow +A -.-> B # Dashed arrow +A ==> B # Thick arrow +A ~~~> B # Invisible link (layout only, not rendered) +``` + +### Arrow Labels + +```mermaid +A -->|Label Text| B +A -.->|Optional| B +A ==>|Important| B +``` + +### Multi-target Connections + +```mermaid +# One to many +A --> B & C & D + +# Many to one +A & B & C --> D + +# Chaining +A --> B --> C --> D +``` + +### Bidirectional + +```mermaid +A <--> B # Bidirectional solid +A <-.-> B # Bidirectional dashed +``` + +## Styling and Colors + +### Inline Styling + +```mermaid +style NodeID fill:#color,stroke:#color,stroke-width:2px +``` + +### Color Format + +- Hex colors: `#ff0000` or `#f00` +- RGB: `rgb(255,0,0)` +- Color names: `red`, `blue`, etc. (limited support) + +### Common Style Patterns + +```mermaid +# Professional look +style A fill:#d3f9d8,stroke:#2f9e44,stroke-width:2px + +# Emphasis +style B fill:#ffe3e3,stroke:#c92a2a,stroke-width:3px + +# Muted/secondary +style C fill:#f8f9fa,stroke:#dee2e6,stroke-width:1px + +# Title/header +style D fill:#1971c2,stroke:#1971c2,stroke-width:3px,color:#ffffff +``` + +### Styling Multiple Nodes + +```mermaid +# Apply same style to multiple nodes +style A,B,C fill:#d3f9d8,stroke:#2f9e44,stroke-width:2px +``` + +## Layout and Direction + +### Direction Codes + +```mermaid +graph TB # Top to Bottom (vertical) +graph BT # Bottom to Top +graph LR # Left to Right (horizontal) +graph RL # Right to Left +graph TD # Top Down (same as TB) +``` + +### Layout Control Tips + +1. **Vertical layouts (TB/BT):** Best for sequential processes, hierarchies +2. **Horizontal layouts (LR/RL):** Best for timelines, wide displays +3. **Mixed directions:** Set different directions in subgraphs + +```mermaid +graph TB + subgraph vertical["Vertical Flow"] + direction TB + A --> B --> C + end + + subgraph horizontal["Horizontal Flow"] + direction LR + D --> E --> F + end +``` + +## Advanced Patterns + +### Feedback Loop Pattern + +```mermaid +graph TB + A[Start] --> B[Process] + B --> C[Output] + C -.->|Feedback| A + + style A fill:#d3f9d8,stroke:#2f9e44,stroke-width:2px + style B fill:#e5dbff,stroke:#5f3dc4,stroke-width:2px + style C fill:#c5f6fa,stroke:#0c8599,stroke-width:2px +``` + +### Swimlane Pattern + +```mermaid +graph TB + subgraph lane1["Lane 1"] + A[Step 1] --> B[Step 2] + end + + subgraph lane2["Lane 2"] + C[Step 3] --> D[Step 4] + end + + B --> C +``` + +### Hub and Spoke + +```mermaid +graph TB + Hub[Central Hub] + + A[Spoke 1] --> Hub + B[Spoke 2] --> Hub + C[Spoke 3] --> Hub + Hub --> D[Output] +``` + +### Decision Tree + +```mermaid +graph TB + Start[Start] --> Decision{Decision Point?} + Decision -->|Option A| PathA[Path A] + Decision -->|Option B| PathB[Path B] + Decision -->|Option C| PathC[Path C] + + PathA --> End[End] + PathB --> End + PathC --> End +``` + +### Comparison Layout + +```mermaid +graph TB + Title[Comparison] + + subgraph left["System A"] + A1[Feature 1] + A2[Feature 2] + A3[Feature 3] + end + + subgraph right["System B"] + B1[Feature 1] + B2[Feature 2] + B3[Feature 3] + end + + Title --> left + Title --> right + + subgraph compare["Key Differences"] + Diff[Difference Summary] + end + + left --> compare + right --> compare +``` + +## Troubleshooting + +### Common Errors and Solutions + +#### Error: "Parse error on line X: Expecting 'SEMI', 'NEWLINE', 'EOF'" + +**Causes:** +1. Subgraph name with spaces not using ID format +2. Node reference using display text instead of ID +3. Invalid special characters in node text + +**Solutions:** +- Use `subgraph id["Display Name"]` format +- Reference nodes by ID only +- Quote node text with special characters + +#### Error: "Unsupported markdown: list" + +**Cause:** Using `number. space` pattern in node text + +**Solution:** Remove space or use alternatives (①, (1), Step 1:) + +#### Error: "Parse error: unexpected character" + +**Causes:** +1. Unescaped special characters +2. Improper quotes +3. Invalid Mermaid syntax + +**Solutions:** +- Replace problematic characters (quotes → 『』, parens → 「」) +- Use proper node definition syntax +- Check arrow syntax + +#### Diagram doesn't render correctly + +**Causes:** +1. Missing style declarations +2. Incorrect direction specification +3. Invalid connections + +**Solutions:** +- Verify all style declarations use valid syntax +- Check direction is set in graph declaration or subgraph +- Ensure all node IDs are defined before referencing + +### Validation Checklist + +Before finalizing any diagram: + +- [ ] No `number. space` patterns in node text +- [ ] All subgraphs use proper ID syntax if they contain spaces +- [ ] All node references use IDs not display text +- [ ] All arrows use valid syntax (-->, -.->) +- [ ] All style declarations are syntactically correct +- [ ] Direction is explicitly set +- [ ] No unescaped special characters in node text +- [ ] All connections reference defined nodes + +### Platform-Specific Notes + +**Obsidian:** +- Older Mermaid version, more strict parsing +- Limited support for `
` (only in circle nodes) +- Test diagrams before finalizing + +**GitHub:** +- Good Mermaid support +- Renders most modern syntax +- May differ slightly from Obsidian rendering + +**Mermaid Live Editor:** +- Most up-to-date parser +- Best for testing new syntax +- May support features not available in Obsidian/GitHub + +## Quick Reference + +### Safe Numbering Methods +✅ `1.Text` `①Text` `(1)Text` `Step 1:Text` +❌ `1. Text` + +### Safe Subgraph Syntax +✅ `subgraph id["Name"]` `subgraph simple_name` +❌ `subgraph Name With Spaces` + +### Safe Node References +✅ `NodeID --> AnotherID` +❌ `"Display Text" --> "Other Text"` + +### Safe Special Characters +✅ `『』` for quotes, `「」` for parentheses +❌ `"` unescaped quotes, `()` in problematic contexts \ No newline at end of file diff --git a/.claude/skills/obsidian-bases/SKILL.md b/.claude/skills/obsidian-bases/SKILL.md new file mode 100644 index 0000000..7e84aa4 --- /dev/null +++ b/.claude/skills/obsidian-bases/SKILL.md @@ -0,0 +1,497 @@ +--- +name: obsidian-bases +description: Create and edit Obsidian Bases (.base files) with views, filters, formulas, and summaries. Use when working with .base files, creating database-like views of notes, or when the user mentions Bases, table views, card views, filters, or formulas in Obsidian. +--- + +# Obsidian Bases Skill + +## Workflow + +1. **Create the file**: Create a `.base` file in the vault with valid YAML content +2. **Define scope**: Add `filters` to select which notes appear (by tag, folder, property, or date) +3. **Add formulas** (optional): Define computed properties in the `formulas` section +4. **Configure views**: Add one or more views (`table`, `cards`, `list`, or `map`) with `order` specifying which properties to display +5. **Validate**: Verify the file is valid YAML with no syntax errors. Check that all referenced properties and formulas exist. Common issues: unquoted strings containing special YAML characters, mismatched quotes in formula expressions, referencing `formula.X` without defining `X` in `formulas` +6. **Test in Obsidian**: Open the `.base` file in Obsidian to confirm the view renders correctly. If it shows a YAML error, check quoting rules below + +## Schema + +Base files use the `.base` extension and contain valid YAML. + +```yaml +# Global filters apply to ALL views in the base +filters: + # Can be a single filter string + # OR a recursive filter object with and/or/not + and: [] + or: [] + not: [] + +# Define formula properties that can be used across all views +formulas: + formula_name: 'expression' + +# Configure display names and settings for properties +properties: + property_name: + displayName: "Display Name" + formula.formula_name: + displayName: "Formula Display Name" + file.ext: + displayName: "Extension" + +# Define custom summary formulas +summaries: + custom_summary_name: 'values.mean().round(3)' + +# Define one or more views +views: + - type: table | cards | list | map + name: "View Name" + limit: 10 # Optional: limit results + groupBy: # Optional: group results + property: property_name + direction: ASC | DESC + filters: # View-specific filters + and: [] + order: # Properties to display in order + - file.name + - property_name + - formula.formula_name + summaries: # Map properties to summary formulas + property_name: Average +``` + +## Filter Syntax + +Filters narrow down results. They can be applied globally or per-view. + +### Filter Structure + +```yaml +# Single filter +filters: 'status == "done"' + +# AND - all conditions must be true +filters: + and: + - 'status == "done"' + - 'priority > 3' + +# OR - any condition can be true +filters: + or: + - 'file.hasTag("book")' + - 'file.hasTag("article")' + +# NOT - exclude matching items +filters: + not: + - 'file.hasTag("archived")' + +# Nested filters +filters: + or: + - file.hasTag("tag") + - and: + - file.hasTag("book") + - file.hasLink("Textbook") + - not: + - file.hasTag("book") + - file.inFolder("Required Reading") +``` + +### Filter Operators + +| Operator | Description | +|----------|-------------| +| `==` | equals | +| `!=` | not equal | +| `>` | greater than | +| `<` | less than | +| `>=` | greater than or equal | +| `<=` | less than or equal | +| `&&` | logical and | +| `\|\|` | logical or | +| ! | logical not | + +## Properties + +### Three Types of Properties + +1. **Note properties** - From frontmatter: `note.author` or just `author` +2. **File properties** - File metadata: `file.name`, `file.mtime`, etc. +3. **Formula properties** - Computed values: `formula.my_formula` + +### File Properties Reference + +| Property | Type | Description | +|----------|------|-------------| +| `file.name` | String | File name | +| `file.basename` | String | File name without extension | +| `file.path` | String | Full path to file | +| `file.folder` | String | Parent folder path | +| `file.ext` | String | File extension | +| `file.size` | Number | File size in bytes | +| `file.ctime` | Date | Created time | +| `file.mtime` | Date | Modified time | +| `file.tags` | List | All tags in file | +| `file.links` | List | Internal links in file | +| `file.backlinks` | List | Files linking to this file | +| `file.embeds` | List | Embeds in the note | +| `file.properties` | Object | All frontmatter properties | + +### The `this` Keyword + +- In main content area: refers to the base file itself +- When embedded: refers to the embedding file +- In sidebar: refers to the active file in main content + +## Formula Syntax + +Formulas compute values from properties. Defined in the `formulas` section. + +```yaml +formulas: + # Simple arithmetic + total: "price * quantity" + + # Conditional logic + status_icon: 'if(done, "✅", "⏳")' + + # String formatting + formatted_price: 'if(price, price.toFixed(2) + " dollars")' + + # Date formatting + created: 'file.ctime.format("YYYY-MM-DD")' + + # Calculate days since created (use .days for Duration) + days_old: '(now() - file.ctime).days' + + # Calculate days until due date + days_until_due: 'if(due_date, (date(due_date) - today()).days, "")' +``` + +## Key Functions + +Most commonly used functions. For the complete reference of all types (Date, String, Number, List, File, Link, Object, RegExp), see [FUNCTIONS_REFERENCE.md](references/FUNCTIONS_REFERENCE.md). + +| Function | Signature | Description | +|----------|-----------|-------------| +| `date()` | `date(string): date` | Parse string to date (`YYYY-MM-DD HH:mm:ss`) | +| `now()` | `now(): date` | Current date and time | +| `today()` | `today(): date` | Current date (time = 00:00:00) | +| `if()` | `if(condition, trueResult, falseResult?)` | Conditional | +| `duration()` | `duration(string): duration` | Parse duration string | +| `file()` | `file(path): file` | Get file object | +| `link()` | `link(path, display?): Link` | Create a link | + +### Duration Type + +When subtracting two dates, the result is a **Duration** type (not a number). + +**Duration Fields:** `duration.days`, `duration.hours`, `duration.minutes`, `duration.seconds`, `duration.milliseconds` + +**IMPORTANT:** Duration does NOT support `.round()`, `.floor()`, `.ceil()` directly. Access a numeric field first (like `.days`), then apply number functions. + +```yaml +# CORRECT: Calculate days between dates +"(date(due_date) - today()).days" # Returns number of days +"(now() - file.ctime).days" # Days since created +"(date(due_date) - today()).days.round(0)" # Rounded days + +# WRONG - will cause error: +# "((date(due) - today()) / 86400000).round(0)" # Duration doesn't support division then round +``` + +### Date Arithmetic + +```yaml +# Duration units: y/year/years, M/month/months, d/day/days, +# w/week/weeks, h/hour/hours, m/minute/minutes, s/second/seconds +"now() + \"1 day\"" # Tomorrow +"today() + \"7d\"" # A week from today +"now() - file.ctime" # Returns Duration +"(now() - file.ctime).days" # Get days as number +``` + +## View Types + +### Table View + +```yaml +views: + - type: table + name: "My Table" + order: + - file.name + - status + - due_date + summaries: + price: Sum + count: Average +``` + +### Cards View + +```yaml +views: + - type: cards + name: "Gallery" + order: + - file.name + - cover_image + - description +``` + +### List View + +```yaml +views: + - type: list + name: "Simple List" + order: + - file.name + - status +``` + +### Map View + +Requires latitude/longitude properties and the Maps community plugin. + +```yaml +views: + - type: map + name: "Locations" + # Map-specific settings for lat/lng properties +``` + +## Default Summary Formulas + +| Name | Input Type | Description | +|------|------------|-------------| +| `Average` | Number | Mathematical mean | +| `Min` | Number | Smallest number | +| `Max` | Number | Largest number | +| `Sum` | Number | Sum of all numbers | +| `Range` | Number | Max - Min | +| `Median` | Number | Mathematical median | +| `Stddev` | Number | Standard deviation | +| `Earliest` | Date | Earliest date | +| `Latest` | Date | Latest date | +| `Range` | Date | Latest - Earliest | +| `Checked` | Boolean | Count of true values | +| `Unchecked` | Boolean | Count of false values | +| `Empty` | Any | Count of empty values | +| `Filled` | Any | Count of non-empty values | +| `Unique` | Any | Count of unique values | + +## Complete Examples + +### Task Tracker Base + +```yaml +filters: + and: + - file.hasTag("task") + - 'file.ext == "md"' + +formulas: + days_until_due: 'if(due, (date(due) - today()).days, "")' + is_overdue: 'if(due, date(due) < today() && status != "done", false)' + priority_label: 'if(priority == 1, "🔴 High", if(priority == 2, "🟡 Medium", "🟢 Low"))' + +properties: + status: + displayName: Status + formula.days_until_due: + displayName: "Days Until Due" + formula.priority_label: + displayName: Priority + +views: + - type: table + name: "Active Tasks" + filters: + and: + - 'status != "done"' + order: + - file.name + - status + - formula.priority_label + - due + - formula.days_until_due + groupBy: + property: status + direction: ASC + summaries: + formula.days_until_due: Average + + - type: table + name: "Completed" + filters: + and: + - 'status == "done"' + order: + - file.name + - completed_date +``` + +### Reading List Base + +```yaml +filters: + or: + - file.hasTag("book") + - file.hasTag("article") + +formulas: + reading_time: 'if(pages, (pages * 2).toString() + " min", "")' + status_icon: 'if(status == "reading", "📖", if(status == "done", "✅", "📚"))' + year_read: 'if(finished_date, date(finished_date).year, "")' + +properties: + author: + displayName: Author + formula.status_icon: + displayName: "" + formula.reading_time: + displayName: "Est. Time" + +views: + - type: cards + name: "Library" + order: + - cover + - file.name + - author + - formula.status_icon + filters: + not: + - 'status == "dropped"' + + - type: table + name: "Reading List" + filters: + and: + - 'status == "to-read"' + order: + - file.name + - author + - pages + - formula.reading_time +``` + +### Daily Notes Index + +```yaml +filters: + and: + - file.inFolder("Daily Notes") + - '/^\d{4}-\d{2}-\d{2}$/.matches(file.basename)' + +formulas: + word_estimate: '(file.size / 5).round(0)' + day_of_week: 'date(file.basename).format("dddd")' + +properties: + formula.day_of_week: + displayName: "Day" + formula.word_estimate: + displayName: "~Words" + +views: + - type: table + name: "Recent Notes" + limit: 30 + order: + - file.name + - formula.day_of_week + - formula.word_estimate + - file.mtime +``` + +## Embedding Bases + +Embed in Markdown files: + +```markdown +![[MyBase.base]] + + +![[MyBase.base#View Name]] +``` + +## YAML Quoting Rules + +- Use single quotes for formulas containing double quotes: `'if(done, "Yes", "No")'` +- Use double quotes for simple strings: `"My View Name"` +- Escape nested quotes properly in complex expressions + +## Troubleshooting + +### YAML Syntax Errors + +**Unquoted special characters**: Strings containing `:`, `{`, `}`, `[`, `]`, `,`, `&`, `*`, `#`, `?`, `|`, `-`, `<`, `>`, `=`, `!`, `%`, `@`, `` ` `` must be quoted. + +```yaml +# WRONG - colon in unquoted string +displayName: Status: Active + +# CORRECT +displayName: "Status: Active" +``` + +**Mismatched quotes in formulas**: When a formula contains double quotes, wrap the entire formula in single quotes. + +```yaml +# WRONG - double quotes inside double quotes +formulas: + label: "if(done, "Yes", "No")" + +# CORRECT - single quotes wrapping double quotes +formulas: + label: 'if(done, "Yes", "No")' +``` + +### Common Formula Errors + +**Duration math without field access**: Subtracting dates returns a Duration, not a number. Always access `.days`, `.hours`, etc. + +```yaml +# WRONG - Duration is not a number +"(now() - file.ctime).round(0)" + +# CORRECT - access .days first, then round +"(now() - file.ctime).days.round(0)" +``` + +**Missing null checks**: Properties may not exist on all notes. Use `if()` to guard. + +```yaml +# WRONG - crashes if due_date is empty +"(date(due_date) - today()).days" + +# CORRECT - guard with if() +'if(due_date, (date(due_date) - today()).days, "")' +``` + +**Referencing undefined formulas**: Ensure every `formula.X` in `order` or `properties` has a matching entry in `formulas`. + +```yaml +# This will fail silently if 'total' is not defined in formulas +order: + - formula.total + +# Fix: define it +formulas: + total: "price * quantity" +``` + +## References + +- [Bases Syntax](https://help.obsidian.md/bases/syntax) +- [Functions](https://help.obsidian.md/bases/functions) +- [Views](https://help.obsidian.md/bases/views) +- [Formulas](https://help.obsidian.md/formulas) +- [Complete Functions Reference](references/FUNCTIONS_REFERENCE.md) diff --git a/.claude/skills/obsidian-bases/references/FUNCTIONS_REFERENCE.md b/.claude/skills/obsidian-bases/references/FUNCTIONS_REFERENCE.md new file mode 100644 index 0000000..047888d --- /dev/null +++ b/.claude/skills/obsidian-bases/references/FUNCTIONS_REFERENCE.md @@ -0,0 +1,173 @@ +# Functions Reference + +## Global Functions + +| Function | Signature | Description | +|----------|-----------|-------------| +| `date()` | `date(string): date` | Parse string to date. Format: `YYYY-MM-DD HH:mm:ss` | +| `duration()` | `duration(string): duration` | Parse duration string | +| `now()` | `now(): date` | Current date and time | +| `today()` | `today(): date` | Current date (time = 00:00:00) | +| `if()` | `if(condition, trueResult, falseResult?)` | Conditional | +| `min()` | `min(n1, n2, ...): number` | Smallest number | +| `max()` | `max(n1, n2, ...): number` | Largest number | +| `number()` | `number(any): number` | Convert to number | +| `link()` | `link(path, display?): Link` | Create a link | +| `list()` | `list(element): List` | Wrap in list if not already | +| `file()` | `file(path): file` | Get file object | +| `image()` | `image(path): image` | Create image for rendering | +| `icon()` | `icon(name): icon` | Lucide icon by name | +| `html()` | `html(string): html` | Render as HTML | +| `escapeHTML()` | `escapeHTML(string): string` | Escape HTML characters | + +## Any Type Functions + +| Function | Signature | Description | +|----------|-----------|-------------| +| `isTruthy()` | `any.isTruthy(): boolean` | Coerce to boolean | +| `isType()` | `any.isType(type): boolean` | Check type | +| `toString()` | `any.toString(): string` | Convert to string | + +## Date Functions & Fields + +**Fields:** `date.year`, `date.month`, `date.day`, `date.hour`, `date.minute`, `date.second`, `date.millisecond` + +| Function | Signature | Description | +|----------|-----------|-------------| +| `date()` | `date.date(): date` | Remove time portion | +| `format()` | `date.format(string): string` | Format with Moment.js pattern | +| `time()` | `date.time(): string` | Get time as string | +| `relative()` | `date.relative(): string` | Human-readable relative time | +| `isEmpty()` | `date.isEmpty(): boolean` | Always false for dates | + +## Duration Type + +When subtracting two dates, the result is a **Duration** type (not a number). Duration has its own properties and methods. + +**Duration Fields:** +| Field | Type | Description | +|-------|------|-------------| +| `duration.days` | Number | Total days in duration | +| `duration.hours` | Number | Total hours in duration | +| `duration.minutes` | Number | Total minutes in duration | +| `duration.seconds` | Number | Total seconds in duration | +| `duration.milliseconds` | Number | Total milliseconds in duration | + +**IMPORTANT:** Duration does NOT support `.round()`, `.floor()`, `.ceil()` directly. You must access a numeric field first (like `.days`), then apply number functions. + +```yaml +# CORRECT: Calculate days between dates +"(date(due_date) - today()).days" # Returns number of days +"(now() - file.ctime).days" # Days since created + +# CORRECT: Round the numeric result if needed +"(date(due_date) - today()).days.round(0)" # Rounded days +"(now() - file.ctime).hours.round(0)" # Rounded hours + +# WRONG - will cause error: +# "((date(due) - today()) / 86400000).round(0)" # Duration doesn't support division then round +``` + +## Date Arithmetic + +```yaml +# Duration units: y/year/years, M/month/months, d/day/days, +# w/week/weeks, h/hour/hours, m/minute/minutes, s/second/seconds + +# Add/subtract durations +"date + \"1M\"" # Add 1 month +"date - \"2h\"" # Subtract 2 hours +"now() + \"1 day\"" # Tomorrow +"today() + \"7d\"" # A week from today + +# Subtract dates returns Duration type +"now() - file.ctime" # Returns Duration +"(now() - file.ctime).days" # Get days as number +"(now() - file.ctime).hours" # Get hours as number + +# Complex duration arithmetic +"now() + (duration('1d') * 2)" +``` + +## String Functions + +**Field:** `string.length` + +| Function | Signature | Description | +|----------|-----------|-------------| +| `contains()` | `string.contains(value): boolean` | Check substring | +| `containsAll()` | `string.containsAll(...values): boolean` | All substrings present | +| `containsAny()` | `string.containsAny(...values): boolean` | Any substring present | +| `startsWith()` | `string.startsWith(query): boolean` | Starts with query | +| `endsWith()` | `string.endsWith(query): boolean` | Ends with query | +| `isEmpty()` | `string.isEmpty(): boolean` | Empty or not present | +| `lower()` | `string.lower(): string` | To lowercase | +| `title()` | `string.title(): string` | To Title Case | +| `trim()` | `string.trim(): string` | Remove whitespace | +| `replace()` | `string.replace(pattern, replacement): string` | Replace pattern | +| `repeat()` | `string.repeat(count): string` | Repeat string | +| `reverse()` | `string.reverse(): string` | Reverse string | +| `slice()` | `string.slice(start, end?): string` | Substring | +| `split()` | `string.split(separator, n?): list` | Split to list | + +## Number Functions + +| Function | Signature | Description | +|----------|-----------|-------------| +| `abs()` | `number.abs(): number` | Absolute value | +| `ceil()` | `number.ceil(): number` | Round up | +| `floor()` | `number.floor(): number` | Round down | +| `round()` | `number.round(digits?): number` | Round to digits | +| `toFixed()` | `number.toFixed(precision): string` | Fixed-point notation | +| `isEmpty()` | `number.isEmpty(): boolean` | Not present | + +## List Functions + +**Field:** `list.length` + +| Function | Signature | Description | +|----------|-----------|-------------| +| `contains()` | `list.contains(value): boolean` | Element exists | +| `containsAll()` | `list.containsAll(...values): boolean` | All elements exist | +| `containsAny()` | `list.containsAny(...values): boolean` | Any element exists | +| `filter()` | `list.filter(expression): list` | Filter by condition (uses `value`, `index`) | +| `map()` | `list.map(expression): list` | Transform elements (uses `value`, `index`) | +| `reduce()` | `list.reduce(expression, initial): any` | Reduce to single value (uses `value`, `index`, `acc`) | +| `flat()` | `list.flat(): list` | Flatten nested lists | +| `join()` | `list.join(separator): string` | Join to string | +| `reverse()` | `list.reverse(): list` | Reverse order | +| `slice()` | `list.slice(start, end?): list` | Sublist | +| `sort()` | `list.sort(): list` | Sort ascending | +| `unique()` | `list.unique(): list` | Remove duplicates | +| `isEmpty()` | `list.isEmpty(): boolean` | No elements | + +## File Functions + +| Function | Signature | Description | +|----------|-----------|-------------| +| `asLink()` | `file.asLink(display?): Link` | Convert to link | +| `hasLink()` | `file.hasLink(otherFile): boolean` | Has link to file | +| `hasTag()` | `file.hasTag(...tags): boolean` | Has any of the tags | +| `hasProperty()` | `file.hasProperty(name): boolean` | Has property | +| `inFolder()` | `file.inFolder(folder): boolean` | In folder or subfolder | + +## Link Functions + +| Function | Signature | Description | +|----------|-----------|-------------| +| `asFile()` | `link.asFile(): file` | Get file object | +| `linksTo()` | `link.linksTo(file): boolean` | Links to file | + +## Object Functions + +| Function | Signature | Description | +|----------|-----------|-------------| +| `isEmpty()` | `object.isEmpty(): boolean` | No properties | +| `keys()` | `object.keys(): list` | List of keys | +| `values()` | `object.values(): list` | List of values | + +## Regular Expression Functions + +| Function | Signature | Description | +|----------|-----------|-------------| +| `matches()` | `regexp.matches(string): boolean` | Test if matches | diff --git a/.claude/skills/obsidian-canvas-creator/SKILL.md b/.claude/skills/obsidian-canvas-creator/SKILL.md new file mode 100644 index 0000000..a519102 --- /dev/null +++ b/.claude/skills/obsidian-canvas-creator/SKILL.md @@ -0,0 +1,211 @@ +--- +name: obsidian-canvas-creator +description: Create Obsidian Canvas files from text content, supporting both MindMap and freeform layouts. Use this skill when users want to visualize content as an interactive canvas, create mind maps, or organize information spatially in Obsidian format. +--- + +# Obsidian Canvas Creator + +Transform text content into structured Obsidian Canvas files with support for MindMap and freeform layouts. + +## When to Use This Skill + +- User requests to create a canvas, mind map, or visual diagram from text +- User wants to organize information spatially +- User mentions "Obsidian Canvas" or similar visualization tools +- Converting structured content (articles, notes, outlines) into visual format + +## Core Workflow + +### 1. Analyze Content + +Read and understand the input content: +- Identify main topics and hierarchical relationships +- Extract key points, facts, and supporting details +- Note any existing structure (headings, lists, sections) + +### 2. Determine Layout Type + +Ask user to choose or infer from context: + +**MindMap Layout:** +- Radial structure from center +- Parent-child relationships +- Clear hierarchy +- Good for: brainstorming, topic exploration, hierarchical content + +**Freeform Layout:** +- Custom positioning +- Flexible relationships +- Multiple connection types +- Good for: complex networks, non-hierarchical content, custom arrangements + +### 3. Plan Structure + +**For MindMap:** +- Identify central concept (root node) +- Map primary branches (main topics) +- Organize secondary branches (subtopics) +- Position leaf nodes (details) + +**For Freeform:** +- Group related concepts +- Identify connection patterns +- Plan spatial zones +- Consider visual flow + +### 4. Generate Canvas + +Create JSON following the Canvas specification: + +**Node Creation:** +- Assign unique 8-12 character hex IDs +- Set appropriate dimensions based on content length +- Apply consistent color schemes +- Ensure no coordinate overlaps + +**Edge Creation:** +- Connect parent-child relationships +- Use appropriate arrow styles +- Add labels for complex relationships +- Choose line styles (straight for hierarchy, curved for cross-references) + +**Grouping (Optional):** +- Create visual containers for related nodes +- Use subtle background colors +- Add descriptive labels + +### 5. Apply Layout Algorithm + +**MindMap Layout Calculations:** + +Refer to `references/layout-algorithms.md` for detailed algorithms. Key principles: + +- Center root at (0, 0) +- Distribute primary nodes radially +- Space secondary nodes based on sibling count +- Maintain minimum spacing: 320px horizontal, 200px vertical + +**Freeform Layout Principles:** + +- Start with logical groupings +- Position groups with clear separation +- Connect across groups with curved edges +- Balance visual weight across canvas + +### 6. Validate and Output + +Before outputting: + +**Validation Checklist:** +- All nodes have unique IDs +- No coordinate overlaps (check distance > node dimensions + spacing) +- All edges reference valid node IDs +- Groups (if any) have labels +- Colors use consistent format (hex or preset numbers) +- JSON is properly escaped (Chinese quotes: 『』 for double, 「」 for single) + +**Output Format:** +- Complete, valid JSON Canvas file +- No additional explanation text +- Directly importable into Obsidian + +## Node Sizing Guidelines + +**Text Length-Based Sizing:** +- Short text (<30 chars): 220 × 100 px +- Medium text (30-60 chars): 260 × 120 px +- Long text (60-100 chars): 320 × 140 px +- Very long text (>100 chars): 320 × 180 px + +## Color Schemes + +**Preset Colors (Recommended):** +- `"1"` - Red (warnings, important) +- `"2"` - Orange (action items) +- `"3"` - Yellow (questions, notes) +- `"4"` - Green (positive, completed) +- `"5"` - Cyan (information, details) +- `"6"` - Purple (concepts, abstract) + +**Custom Hex Colors:** +Use for brand consistency or specific themes. Always use uppercase format: `"#4A90E2"` + +## Critical Rules + +1. **Quote Handling:** + - Chinese double quotes → 『』 + - Chinese single quotes → 「」 + - English double quotes → `\"` + +2. **ID Generation:** + - 8-12 character random hex strings + - Must be unique across all nodes and edges + +3. **Z-Index Order:** + - Output groups first (bottom layer) + - Then subgroups + - Finally text/link nodes (top layer) + +4. **Spacing Requirements:** + - Minimum horizontal: 320px between node centers + - Minimum vertical: 200px between node centers + - Account for node dimensions when calculating + +5. **JSON Structure:** + - Top level contains only `nodes` and `edges` arrays + - No extra wrapping objects + - No comments in output + +6. **No Emoji:** + - Do not use any Emoji symbols in node text + - Use color coding or text labels for visual distinction instead + +## Examples + +### Simple MindMap Request +User: "Create a mind map about solar system planets" + +Process: +1. Identify center: "Solar System" +2. Primary branches: Inner Planets, Outer Planets, Dwarf Planets +3. Secondary nodes: Individual planets with key facts +4. Apply radial layout +5. Generate JSON with proper spacing + +### Freeform Content Request +User: "Turn this article into a canvas" + [article text] + +Process: +1. Extract article structure (intro, body sections, conclusion) +2. Identify key concepts and relationships +3. Group related sections spatially +4. Connect with labeled edges +5. Apply freeform layout with clear zones + +## Reference Documents + +- **Canvas Specification**: `references/canvas-spec.md` - Complete JSON Canvas format specification +- **Layout Algorithms**: `references/layout-algorithms.md` - Detailed positioning algorithms for both layout types + +Load these references when: +- Need specification details for edge cases +- Implementing complex layout calculations +- Troubleshooting validation errors + +## Tips for Quality Canvases + +1. **Keep text concise**: Each node should be scannable (<2 lines preferred) +2. **Use hierarchy**: Group by importance and relationship +3. **Balance the canvas**: Distribute nodes to avoid clustering +4. **Strategic colors**: Use colors to encode meaning, not just decoration +5. **Meaningful connections**: Only add edges that clarify relationships +6. **Test in Obsidian**: Verify the output opens correctly + +## Common Pitfalls to Avoid + +- Overlapping nodes (always check distances) +- Inconsistent quote escaping (breaks JSON parsing) +- Missing group labels (causes sidebar navigation issues) +- Too much text in nodes (use file nodes for long content) +- Duplicate IDs (each must be unique) +- Unconnected nodes (unless intentional islands) diff --git a/.claude/skills/obsidian-canvas-creator/assets/template-freeform-grouped.canvas b/.claude/skills/obsidian-canvas-creator/assets/template-freeform-grouped.canvas new file mode 100644 index 0000000..2611c83 --- /dev/null +++ b/.claude/skills/obsidian-canvas-creator/assets/template-freeform-grouped.canvas @@ -0,0 +1,132 @@ +{ + "nodes": [ + { + "id": "group01", + "type": "group", + "x": -50, + "y": -50, + "width": 600, + "height": 400, + "label": "Group 1 - Core Concepts", + "color": "4" + }, + { + "id": "group02", + "type": "group", + "x": 650, + "y": -50, + "width": 600, + "height": 400, + "label": "Group 2 - Applications", + "color": "5" + }, + { + "id": "node01", + "type": "text", + "x": 0, + "y": 0, + "width": 240, + "height": 100, + "text": "Concept A", + "color": "4" + }, + { + "id": "node02", + "type": "text", + "x": 290, + "y": 0, + "width": 240, + "height": 100, + "text": "Concept B", + "color": "4" + }, + { + "id": "node03", + "type": "text", + "x": 0, + "y": 150, + "width": 240, + "height": 100, + "text": "Concept C", + "color": "4" + }, + { + "id": "node04", + "type": "text", + "x": 290, + "y": 150, + "width": 240, + "height": 100, + "text": "Concept D", + "color": "4" + }, + { + "id": "node05", + "type": "text", + "x": 700, + "y": 0, + "width": 240, + "height": 100, + "text": "Application 1", + "color": "5" + }, + { + "id": "node06", + "type": "text", + "x": 990, + "y": 0, + "width": 240, + "height": 100, + "text": "Application 2", + "color": "5" + }, + { + "id": "node07", + "type": "text", + "x": 700, + "y": 150, + "width": 240, + "height": 100, + "text": "Application 3", + "color": "5" + } + ], + "edges": [ + { + "id": "e1", + "fromNode": "node01", + "fromSide": "bottom", + "toNode": "node03", + "toSide": "top", + "toEnd": "arrow" + }, + { + "id": "e2", + "fromNode": "node02", + "fromSide": "bottom", + "toNode": "node04", + "toSide": "top", + "toEnd": "arrow" + }, + { + "id": "e3", + "fromNode": "node01", + "fromSide": "right", + "toNode": "node05", + "toSide": "left", + "toEnd": "arrow", + "label": "leads to", + "color": "3" + }, + { + "id": "e4", + "fromNode": "node02", + "fromSide": "right", + "toNode": "node06", + "toSide": "left", + "toEnd": "arrow", + "label": "enables", + "color": "3" + } + ] +} diff --git a/.claude/skills/obsidian-canvas-creator/assets/template-mindmap-simple.canvas b/.claude/skills/obsidian-canvas-creator/assets/template-mindmap-simple.canvas new file mode 100644 index 0000000..986b44f --- /dev/null +++ b/.claude/skills/obsidian-canvas-creator/assets/template-mindmap-simple.canvas @@ -0,0 +1,106 @@ +{ + "nodes": [ + { + "id": "root001", + "type": "text", + "x": -150, + "y": -60, + "width": 300, + "height": 120, + "text": "# Central Topic\n\nMain concept goes here", + "color": "4" + }, + { + "id": "branch01", + "type": "text", + "x": 250, + "y": -200, + "width": 220, + "height": 100, + "text": "Branch 1\n\nFirst main idea", + "color": "5" + }, + { + "id": "branch02", + "type": "text", + "x": 250, + "y": -50, + "width": 220, + "height": 100, + "text": "Branch 2\n\nSecond main idea", + "color": "5" + }, + { + "id": "branch03", + "type": "text", + "x": 250, + "y": 100, + "width": 220, + "height": 100, + "text": "Branch 3\n\nThird main idea", + "color": "5" + }, + { + "id": "detail01", + "type": "text", + "x": 550, + "y": -200, + "width": 200, + "height": 80, + "text": "Detail A", + "color": "6" + }, + { + "id": "detail02", + "type": "text", + "x": 550, + "y": -100, + "width": 200, + "height": 80, + "text": "Detail B", + "color": "6" + } + ], + "edges": [ + { + "id": "e1", + "fromNode": "root001", + "fromSide": "right", + "toNode": "branch01", + "toSide": "left", + "toEnd": "arrow" + }, + { + "id": "e2", + "fromNode": "root001", + "fromSide": "right", + "toNode": "branch02", + "toSide": "left", + "toEnd": "arrow" + }, + { + "id": "e3", + "fromNode": "root001", + "fromSide": "right", + "toNode": "branch03", + "toSide": "left", + "toEnd": "arrow" + }, + { + "id": "e4", + "fromNode": "branch01", + "fromSide": "right", + "toNode": "detail01", + "toSide": "left", + "toEnd": "arrow" + }, + { + "id": "e5", + "fromNode": "branch01", + "fromSide": "right", + "toNode": "detail02", + "toSide": "left", + "toEnd": "arrow" + } + ] +} diff --git a/.claude/skills/obsidian-canvas-creator/references/canvas-spec.md b/.claude/skills/obsidian-canvas-creator/references/canvas-spec.md new file mode 100644 index 0000000..06ea9e5 --- /dev/null +++ b/.claude/skills/obsidian-canvas-creator/references/canvas-spec.md @@ -0,0 +1,403 @@ +# JSON Canvas Specification for Obsidian + +Version 1.0 — 2024-03-11 + +## Overview + +JSON Canvas is a format for representing infinite canvas documents. This specification defines the structure for creating canvas files compatible with Obsidian. + +## Top Level Structure + +The root JSON object contains two optional arrays: + +```json +{ + "nodes": [...], + "edges": [...] +} +``` + +- `nodes` (optional, array): All canvas objects (text, files, links, groups) +- `edges` (optional, array): All connections between nodes + +## Node Types + +### Common Attributes + +All nodes share these required attributes: + +- `id` (required, string): Unique identifier for the node +- `type` (required, string): Node type (`text`, `file`, `link`, `group`) +- `x` (required, integer): X position in pixels +- `y` (required, integer): Y position in pixels +- `width` (required, integer): Width in pixels +- `height` (required, integer): Height in pixels +- `color` (optional, string/number): Color (hex `"#FF0000"` or preset `"1"`) + +### Text Nodes + +Store plain text with Markdown formatting. + +**Required Attributes:** +- `text` (string): Content in Markdown syntax + +**Example:** +```json +{ + "id": "abc123", + "type": "text", + "x": 0, + "y": 0, + "width": 250, + "height": 100, + "text": "# Main Topic\n\nKey point here", + "color": "4" +} +``` + +### File Nodes + +Reference other files or attachments (images, PDFs, etc.). + +**Required Attributes:** +- `file` (string): Path to file in the vault + +**Optional Attributes:** +- `subpath` (string): Link to specific heading/block (starts with `#`) + +**Example:** +```json +{ + "id": "def456", + "type": "file", + "x": 300, + "y": 0, + "width": 400, + "height": 300, + "file": "Images/diagram.png" +} +``` + +**With Subpath:** +```json +{ + "id": "ghi789", + "type": "file", + "x": 0, + "y": 200, + "width": 250, + "height": 100, + "file": "Notes/Meeting Notes.md", + "subpath": "#Action Items" +} +``` + +### Link Nodes + +Reference external URLs. + +**Required Attributes:** +- `url` (string): Full URL including protocol + +**Example:** +```json +{ + "id": "jkl012", + "type": "link", + "x": 0, + "y": -200, + "width": 250, + "height": 100, + "url": "https://obsidian.md", + "color": "5" +} +``` + +### Group Nodes + +Visual containers for organizing related nodes. + +**Optional Attributes:** +- `label` (string): Text label for the group (recommended) +- `background` (string): Path to background image +- `backgroundStyle` (string): Image rendering style + - `cover`: Fill entire node + - `ratio`: Maintain aspect ratio + - `repeat`: Tile as pattern + +**Example:** +```json +{ + "id": "group1", + "type": "group", + "x": -50, + "y": -50, + "width": 600, + "height": 400, + "label": "Main Concepts", + "color": "4" +} +``` + +**With Background:** +```json +{ + "id": "group2", + "type": "group", + "x": 700, + "y": 0, + "width": 500, + "height": 600, + "label": "Reference Materials", + "background": "Images/texture.png", + "backgroundStyle": "repeat" +} +``` + +## Z-Index and Layering + +Nodes are displayed in array order: +- **First node**: Bottom layer (rendered below others) +- **Last node**: Top layer (rendered above others) + +**Best Practice Order:** +1. Group nodes (backgrounds) +2. Sub-groups +3. Regular nodes (text, file, link) + +This ensures groups appear behind content. + +## Edges (Connections) + +Edges connect nodes with lines. + +**Required Attributes:** +- `id` (required, string): Unique identifier +- `fromNode` (required, string): Starting node ID +- `toNode` (required, string): Ending node ID + +**Optional Attributes:** +- `fromSide` (string): Starting edge side + - Values: `top`, `right`, `bottom`, `left` +- `fromEnd` (string): Start endpoint shape + - Values: `none` (default), `arrow` +- `toSide` (string): Ending edge side + - Values: `top`, `right`, `bottom`, `left` +- `toEnd` (string): End endpoint shape + - Values: `arrow` (default), `none` +- `color` (string/number): Edge color +- `label` (string): Text label on edge + +**Example - Simple Connection:** +```json +{ + "id": "edge1", + "fromNode": "abc123", + "toNode": "def456" +} +``` + +**Example - Fully Specified:** +```json +{ + "id": "edge2", + "fromNode": "def456", + "fromSide": "bottom", + "fromEnd": "none", + "toNode": "ghi789", + "toSide": "top", + "toEnd": "arrow", + "color": "3", + "label": "leads to" +} +``` + +## Color System + +### Preset Colors + +Use string numbers `"1"` through `"6"`: + +- `"1"` - Red +- `"2"` - Orange +- `"3"` - Yellow +- `"4"` - Green +- `"5"` - Cyan +- `"6"` - Purple + +**Note:** Exact colors adapt to Obsidian's theme. These provide semantic meaning across light/dark modes. + +### Custom Hex Colors + +Use hex format: `"#RRGGBB"` + +**Examples:** +- `"#4A90E2"` (blue) +- `"#50E3C2"` (teal) +- `"#F5A623"` (orange) + +**Best Practice:** Use consistent format within a canvas (all hex OR all presets). + +## Complete Example + +```json +{ + "nodes": [ + { + "id": "group001", + "type": "group", + "x": -50, + "y": -50, + "width": 700, + "height": 500, + "label": "Core Concepts", + "color": "4" + }, + { + "id": "center01", + "type": "text", + "x": 0, + "y": 0, + "width": 300, + "height": 120, + "text": "# Central Topic\n\nMain idea here", + "color": "4" + }, + { + "id": "branch01", + "type": "text", + "x": 400, + "y": -100, + "width": 220, + "height": 100, + "text": "Subtopic A", + "color": "5" + }, + { + "id": "branch02", + "type": "text", + "x": 400, + "y": 100, + "width": 220, + "height": 100, + "text": "Subtopic B", + "color": "5" + }, + { + "id": "detail01", + "type": "text", + "x": 700, + "y": -100, + "width": 200, + "height": 80, + "text": "Detail 1", + "color": "6" + } + ], + "edges": [ + { + "id": "e1", + "fromNode": "center01", + "fromSide": "right", + "toNode": "branch01", + "toSide": "left", + "toEnd": "arrow" + }, + { + "id": "e2", + "fromNode": "center01", + "fromSide": "right", + "toNode": "branch02", + "toSide": "left", + "toEnd": "arrow" + }, + { + "id": "e3", + "fromNode": "branch01", + "fromSide": "right", + "toNode": "detail01", + "toSide": "left", + "toEnd": "arrow", + "color": "3" + } + ] +} +``` + +## Validation Requirements + +When creating canvas files, ensure: + +1. **Unique IDs**: All `id` values must be unique across nodes and edges +2. **Valid References**: All edge `fromNode` and `toNode` must reference existing node IDs +3. **Required Fields**: All required attributes are present for each type +4. **Valid Coordinates**: All position/dimension values are integers +5. **Color Format**: Colors use either hex (`"#RRGGBB"`) or preset strings (`"1"` to `"6"`) +6. **Quote Escaping**: Special characters properly escaped in JSON strings + +## Common Issues and Solutions + +### Issue: Canvas won't open in Obsidian +**Solutions:** +- Validate JSON syntax (use JSON validator) +- Check all IDs are unique +- Verify all edge references exist +- Ensure required fields present + +### Issue: Nodes appear overlapped +**Solutions:** +- Increase spacing between coordinates +- Account for node dimensions in positioning +- Use minimum spacing: 320px horizontal, 200px vertical + +### Issue: Groups don't show properly +**Solutions:** +- Ensure groups appear before content nodes in array +- Add explicit `label` to all groups +- Check group dimensions encompass child nodes + +### Issue: Colors don't match expectations +**Solutions:** +- Use consistent color format (all hex OR all presets) +- Remember presets adapt to theme +- Test in both light and dark mode if using custom colors + +### Issue: Text appears truncated +**Solutions:** +- Increase node dimensions +- Break long text into multiple nodes +- Use file nodes for lengthy content + +## Character Encoding for Chinese Content + +When canvas contains Chinese text, apply these transformations: + +- Chinese double quotes `"` → `『』` +- Chinese single quotes `'` → `「」` +- English double quotes must be escaped: `\"` + +**Example:** +```json +{ + "text": "『核心概念』包含:「子概念A」和「子概念B」" +} +``` + +This prevents JSON parsing errors with mixed-language content. + +## Performance Considerations + +- **Large Canvases**: Keep node count reasonable (<500 for smooth performance) +- **Image Files**: Use compressed images for backgrounds +- **Text Length**: Keep node text concise; use file nodes for long content +- **Edge Complexity**: Minimize crossing edges for clarity + +## Future Extensions + +This specification may be extended with: +- Additional node types +- More edge styling options +- Animation properties +- Interactive behaviors + +Always check Obsidian documentation for latest Canvas features. diff --git a/.claude/skills/obsidian-canvas-creator/references/layout-algorithms.md b/.claude/skills/obsidian-canvas-creator/references/layout-algorithms.md new file mode 100644 index 0000000..08b086a --- /dev/null +++ b/.claude/skills/obsidian-canvas-creator/references/layout-algorithms.md @@ -0,0 +1,614 @@ +# Layout Algorithms for Obsidian Canvas + +Detailed algorithms for positioning nodes in MindMap and Freeform layouts. + +## Layout Principles + +### Universal Spacing Constants + +``` +HORIZONTAL_SPACING = 320 // Minimum horizontal space between node centers +VERTICAL_SPACING = 200 // Minimum vertical space between node centers +NODE_PADDING = 20 // Internal padding within nodes +``` + +### Collision Detection + +Before finalizing any node position, verify: + +```python +def check_collision(node1, node2): + """Returns True if nodes overlap or are too close""" + center1_x = node1.x + node1.width / 2 + center1_y = node1.y + node1.height / 2 + center2_x = node2.x + node2.width / 2 + center2_y = node2.y + node2.height / 2 + + dx = abs(center1_x - center2_x) + dy = abs(center1_y - center2_y) + + min_dx = (node1.width + node2.width) / 2 + HORIZONTAL_SPACING + min_dy = (node1.height + node2.height) / 2 + VERTICAL_SPACING + + return dx < min_dx or dy < min_dy +``` + +## MindMap Layout Algorithm + +### 1. Radial Tree Layout + +Place root at center, arrange children radially. + +#### Step 1: Position Root Node + +```python +root = { + "x": 0 - (root_width / 2), # Center horizontally + "y": 0 - (root_height / 2), # Center vertically + "width": root_width, + "height": root_height +} +``` + +#### Step 2: Calculate Primary Branch Positions + +Distribute first-level children around root: + +```python +def position_primary_branches(root, children, radius=400): + """Position first-level children in a circle around root""" + n = len(children) + angle_step = 2 * pi / n + + positions = [] + for i, child in enumerate(children): + angle = i * angle_step + + # Calculate position on circle + x = root.center_x + radius * cos(angle) - child.width / 2 + y = root.center_y + radius * sin(angle) - child.height / 2 + + positions.append({"x": x, "y": y}) + + return positions +``` + +**Radius Selection:** +- Small canvases (≤10 children): 400px +- Medium canvases (11-20 children): 500px +- Large canvases (>20 children): 600px + +#### Step 3: Position Secondary Branches + +For each primary branch, arrange its children: + +**Horizontal Layout** (preferred for most cases): + +```python +def position_secondary_horizontal(parent, children, distance=350): + """Arrange children horizontally to the right of parent""" + n = len(children) + total_height = sum(child.height for child in children) + total_spacing = (n - 1) * VERTICAL_SPACING + + # Start position (top of vertical arrangement) + start_y = parent.center_y - (total_height + total_spacing) / 2 + + positions = [] + current_y = start_y + + for child in children: + x = parent.x + parent.width + distance + y = current_y + + positions.append({"x": x, "y": y}) + current_y += child.height + VERTICAL_SPACING + + return positions +``` + +**Vertical Layout** (for left/right primary branches): + +```python +def position_secondary_vertical(parent, children, distance=250): + """Arrange children vertically below parent""" + n = len(children) + total_width = sum(child.width for child in children) + total_spacing = (n - 1) * HORIZONTAL_SPACING + + # Start position (left of horizontal arrangement) + start_x = parent.center_x - (total_width + total_spacing) / 2 + + positions = [] + current_x = start_x + + for child in children: + x = current_x + y = parent.y + parent.height + distance + + positions.append({"x": x, "y": y}) + current_x += child.width + HORIZONTAL_SPACING + + return positions +``` + +#### Step 4: Balance and Adjust + +After initial placement, check for collisions and adjust: + +```python +def balance_layout(nodes): + """Adjust nodes to prevent overlaps""" + max_iterations = 10 + + for iteration in range(max_iterations): + collisions = find_all_collisions(nodes) + if not collisions: + break + + for node1, node2 in collisions: + # Move node2 away from node1 + dx = node2.center_x - node1.center_x + dy = node2.center_y - node1.center_y + distance = sqrt(dx*dx + dy*dy) + + # Calculate required distance + min_dist = calculate_min_distance(node1, node2) + + if distance > 0: + # Move proportionally + move_x = (dx / distance) * (min_dist - distance) / 2 + move_y = (dy / distance) * (min_dist - distance) / 2 + + node2.x += move_x + node2.y += move_y +``` + +### 2. Tree Layout (Hierarchical Top-Down) + +Alternative for deep hierarchies. + +#### Positioning Formula + +```python +def position_tree_layout(root, tree): + """Top-down tree layout""" + # Level 0 (root) + root.x = 0 - root.width / 2 + root.y = 0 - root.height / 2 + + # Process each level + for level in range(1, max_depth): + nodes_at_level = get_nodes_at_level(tree, level) + + # Calculate horizontal spacing + total_width = sum(node.width for node in nodes_at_level) + total_spacing = (len(nodes_at_level) - 1) * HORIZONTAL_SPACING + + start_x = -(total_width + total_spacing) / 2 + y = level * (150 + VERTICAL_SPACING) # 150px level height + + current_x = start_x + for node in nodes_at_level: + node.x = current_x + node.y = y + current_x += node.width + HORIZONTAL_SPACING +``` + +## Freeform Layout Algorithm + +### 1. Content-Based Grouping + +First, identify natural groupings in content: + +```python +def identify_groups(nodes, content_structure): + """Group nodes by semantic relationships""" + groups = [] + + # Analyze content structure + for section in content_structure: + group_nodes = [node for node in nodes if node.section == section] + + if len(group_nodes) > 1: + groups.append({ + "label": section.title, + "nodes": group_nodes + }) + + return groups +``` + +### 2. Grid-Based Zone Layout + +Divide canvas into zones for different groups: + +```python +def layout_zones(groups, canvas_width=2000, canvas_height=1500): + """Arrange groups in grid zones""" + n_groups = len(groups) + + # Calculate grid dimensions + cols = ceil(sqrt(n_groups)) + rows = ceil(n_groups / cols) + + zone_width = canvas_width / cols + zone_height = canvas_height / rows + + # Assign zones + zones = [] + for i, group in enumerate(groups): + col = i % cols + row = i // cols + + zone = { + "x": col * zone_width - canvas_width / 2, + "y": row * zone_height - canvas_height / 2, + "width": zone_width * 0.9, # Leave 10% margin + "height": zone_height * 0.9, + "group": group + } + zones.append(zone) + + return zones +``` + +### 3. Within-Zone Node Positioning + +Position nodes within each zone: + +**Option A: Organic Flow** + +```python +def position_organic(zone, nodes): + """Organic, flowing arrangement within zone""" + positions = [] + + # Start at zone top-left with margin + current_x = zone.x + 50 + current_y = zone.y + 50 + row_height = 0 + + for node in nodes: + # Check if node fits in current row + if current_x + node.width > zone.x + zone.width - 50: + # Move to next row + current_x = zone.x + 50 + current_y += row_height + VERTICAL_SPACING + row_height = 0 + + positions.append({ + "x": current_x, + "y": current_y + }) + + current_x += node.width + HORIZONTAL_SPACING + row_height = max(row_height, node.height) + + return positions +``` + +**Option B: Structured Grid** + +```python +def position_grid(zone, nodes): + """Grid arrangement within zone""" + n = len(nodes) + cols = ceil(sqrt(n)) + rows = ceil(n / cols) + + cell_width = (zone.width - 100) / cols # 50px margin each side + cell_height = (zone.height - 100) / rows + + positions = [] + for i, node in enumerate(nodes): + col = i % cols + row = i // cols + + # Center node in cell + x = zone.x + 50 + col * cell_width + (cell_width - node.width) / 2 + y = zone.y + 50 + row * cell_height + (cell_height - node.height) / 2 + + positions.append({"x": x, "y": y}) + + return positions +``` + +### 4. Cross-Zone Connections + +Calculate optimal edge paths between zones: + +```python +def calculate_edge_path(from_node, to_node): + """Determine edge connection points""" + # Calculate centers + from_center = (from_node.x + from_node.width/2, + from_node.y + from_node.height/2) + to_center = (to_node.x + to_node.width/2, + to_node.y + to_node.height/2) + + # Determine best sides to connect + dx = to_center[0] - from_center[0] + dy = to_center[1] - from_center[1] + + # Choose sides based on direction + if abs(dx) > abs(dy): + # Horizontal connection + from_side = "right" if dx > 0 else "left" + to_side = "left" if dx > 0 else "right" + else: + # Vertical connection + from_side = "bottom" if dy > 0 else "top" + to_side = "top" if dy > 0 else "bottom" + + return { + "fromSide": from_side, + "toSide": to_side + } +``` + +## Advanced Techniques + +### Force-Directed Layout + +For complex networks with many cross-connections: + +```python +def force_directed_layout(nodes, edges, iterations=100): + """Spring-based layout algorithm""" + # Constants + SPRING_LENGTH = 200 + SPRING_CONSTANT = 0.1 + REPULSION_CONSTANT = 5000 + + for iteration in range(iterations): + # Calculate repulsive forces (all pairs) + for node1 in nodes: + force_x, force_y = 0, 0 + + for node2 in nodes: + if node1 == node2: + continue + + dx = node1.x - node2.x + dy = node1.y - node2.y + distance = sqrt(dx*dx + dy*dy) + + if distance > 0: + # Repulsive force + force = REPULSION_CONSTANT / (distance * distance) + force_x += (dx / distance) * force + force_y += (dy / distance) * force + + node1.force_x = force_x + node1.force_y = force_y + + # Calculate attractive forces (connected nodes) + for edge in edges: + node1 = get_node(edge.fromNode) + node2 = get_node(edge.toNode) + + dx = node2.x - node1.x + dy = node2.y - node1.y + distance = sqrt(dx*dx + dy*dy) + + # Spring force + force = SPRING_CONSTANT * (distance - SPRING_LENGTH) + + node1.force_x += (dx / distance) * force + node1.force_y += (dy / distance) * force + node2.force_x -= (dx / distance) * force + node2.force_y -= (dy / distance) * force + + # Apply forces + for node in nodes: + node.x += node.force_x + node.y += node.force_y +``` + +### Hierarchical Clustering + +Group related nodes automatically: + +```python +def hierarchical_cluster(nodes, similarity_threshold=0.7): + """Cluster nodes by content similarity""" + clusters = [] + + # Calculate similarity matrix + similarity = calculate_similarity_matrix(nodes) + + # Agglomerative clustering + current_clusters = [[node] for node in nodes] + + while len(current_clusters) > 1: + # Find most similar clusters + max_sim = 0 + merge_i, merge_j = 0, 1 + + for i in range(len(current_clusters)): + for j in range(i + 1, len(current_clusters)): + sim = cluster_similarity(current_clusters[i], + current_clusters[j], + similarity) + if sim > max_sim: + max_sim = sim + merge_i, merge_j = i, j + + if max_sim < similarity_threshold: + break + + # Merge clusters + current_clusters[merge_i].extend(current_clusters[merge_j]) + current_clusters.pop(merge_j) + + return current_clusters +``` + +## Layout Optimization + +### Minimize Edge Crossings + +```python +def minimize_crossings(nodes, edges): + """Reduce edge crossing through node repositioning""" + crossings = count_crossings(edges) + + # Try swapping adjacent nodes + improved = True + while improved: + improved = False + + for i in range(len(nodes) - 1): + # Swap nodes i and i+1 + swap_positions(nodes[i], nodes[i+1]) + new_crossings = count_crossings(edges) + + if new_crossings < crossings: + crossings = new_crossings + improved = True + else: + # Swap back + swap_positions(nodes[i], nodes[i+1]) +``` + +### Visual Balance + +```python +def calculate_visual_weight(canvas): + """Calculate center of mass for visual balance""" + total_weight = 0 + weighted_x = 0 + weighted_y = 0 + + for node in canvas.nodes: + # Weight is proportional to area + weight = node.width * node.height + total_weight += weight + + weighted_x += node.center_x * weight + weighted_y += node.center_y * weight + + center_x = weighted_x / total_weight + center_y = weighted_y / total_weight + + # Shift entire canvas to center at (0, 0) + offset_x = -center_x + offset_y = -center_y + + for node in canvas.nodes: + node.x += offset_x + node.y += offset_y +``` + +## Performance Optimization + +### Spatial Indexing + +For large canvases, use spatial indexing to speed up collision detection: + +```python +class SpatialGrid: + """Grid-based spatial index for fast collision detection""" + + def __init__(self, cell_size=500): + self.cell_size = cell_size + self.grid = {} + + def add_node(self, node): + """Add node to grid""" + cells = self.get_cells(node) + for cell in cells: + if cell not in self.grid: + self.grid[cell] = [] + self.grid[cell].append(node) + + def get_cells(self, node): + """Get grid cells node occupies""" + min_x = int(node.x / self.cell_size) + max_x = int((node.x + node.width) / self.cell_size) + min_y = int(node.y / self.cell_size) + max_y = int((node.y + node.height) / self.cell_size) + + cells = [] + for x in range(min_x, max_x + 1): + for y in range(min_y, max_y + 1): + cells.append((x, y)) + return cells + + def get_nearby_nodes(self, node): + """Get nodes in nearby cells""" + cells = self.get_cells(node) + nearby = set() + + for cell in cells: + if cell in self.grid: + nearby.update(self.grid[cell]) + + return nearby +``` + +## Common Layout Patterns + +### Timeline Layout + +For chronological content: + +```python +def layout_timeline(events, direction="horizontal"): + """Create timeline layout""" + if direction == "horizontal": + for i, event in enumerate(events): + event.x = i * (event.width + HORIZONTAL_SPACING) + event.y = 0 + else: # vertical + for i, event in enumerate(events): + event.x = 0 + event.y = i * (event.height + VERTICAL_SPACING) +``` + +### Circular Layout + +For cyclical processes: + +```python +def layout_circular(nodes, radius=500): + """Arrange nodes in a circle""" + n = len(nodes) + angle_step = 2 * pi / n + + for i, node in enumerate(nodes): + angle = i * angle_step + node.x = radius * cos(angle) - node.width / 2 + node.y = radius * sin(angle) - node.height / 2 +``` + +### Matrix Layout + +For comparing multiple dimensions: + +```python +def layout_matrix(nodes, rows, cols): + """Arrange nodes in a matrix""" + cell_width = 400 + cell_height = 250 + + for i, node in enumerate(nodes): + row = i // cols + col = i % cols + + node.x = col * cell_width + node.y = row * cell_height +``` + +## Quality Checks + +Before finalizing layout, verify: + +1. **No Overlaps**: All nodes have minimum spacing +2. **Balanced**: Visual center near (0, 0) +3. **Accessible**: All nodes reachable via edges +4. **Readable**: Text sizes appropriate for zoom level +5. **Efficient**: Edge paths reasonably direct + +Use these algorithms as foundations, adapting to specific content and user preferences. diff --git a/.claude/skills/obsidian-cli/SKILL.md b/.claude/skills/obsidian-cli/SKILL.md new file mode 100644 index 0000000..0046c45 --- /dev/null +++ b/.claude/skills/obsidian-cli/SKILL.md @@ -0,0 +1,106 @@ +--- +name: obsidian-cli +description: Interact with Obsidian vaults using the Obsidian CLI to read, create, search, and manage notes, tasks, properties, and more. Also supports plugin and theme development with commands to reload plugins, run JavaScript, capture errors, take screenshots, and inspect the DOM. Use when the user asks to interact with their Obsidian vault, manage notes, search vault content, perform vault operations from the command line, or develop and debug Obsidian plugins and themes. +--- + +# Obsidian CLI + +Use the `obsidian` CLI to interact with a running Obsidian instance. Requires Obsidian to be open. + +## Command reference + +Run `obsidian help` to see all available commands. This is always up to date. Full docs: https://help.obsidian.md/cli + +## Syntax + +**Parameters** take a value with `=`. Quote values with spaces: + +```bash +obsidian create name="My Note" content="Hello world" +``` + +**Flags** are boolean switches with no value: + +```bash +obsidian create name="My Note" silent overwrite +``` + +For multiline content use `\n` for newline and `\t` for tab. + +## File targeting + +Many commands accept `file` or `path` to target a file. Without either, the active file is used. + +- `file=` — resolves like a wikilink (name only, no path or extension needed) +- `path=` — exact path from vault root, e.g. `folder/note.md` + +## Vault targeting + +Commands target the most recently focused vault by default. Use `vault=` as the first parameter to target a specific vault: + +```bash +obsidian vault="My Vault" search query="test" +``` + +## Common patterns + +```bash +obsidian read file="My Note" +obsidian create name="New Note" content="# Hello" template="Template" silent +obsidian append file="My Note" content="New line" +obsidian search query="search term" limit=10 +obsidian daily:read +obsidian daily:append content="- [ ] New task" +obsidian property:set name="status" value="done" file="My Note" +obsidian tasks daily todo +obsidian tags sort=count counts +obsidian backlinks file="My Note" +``` + +Use `--copy` on any command to copy output to clipboard. Use `silent` to prevent files from opening. Use `total` on list commands to get a count. + +## Plugin development + +### Develop/test cycle + +After making code changes to a plugin or theme, follow this workflow: + +1. **Reload** the plugin to pick up changes: + ```bash + obsidian plugin:reload id=my-plugin + ``` +2. **Check for errors** — if errors appear, fix and repeat from step 1: + ```bash + obsidian dev:errors + ``` +3. **Verify visually** with a screenshot or DOM inspection: + ```bash + obsidian dev:screenshot path=screenshot.png + obsidian dev:dom selector=".workspace-leaf" text + ``` +4. **Check console output** for warnings or unexpected logs: + ```bash + obsidian dev:console level=error + ``` + +### Additional developer commands + +Run JavaScript in the app context: + +```bash +obsidian eval code="app.vault.getFiles().length" +``` + +Inspect CSS values: + +```bash +obsidian dev:css selector=".workspace-leaf" prop=background-color +``` + +Toggle mobile emulation: + +```bash +obsidian dev:mobile on +``` + +Run `obsidian help` to see additional developer commands including CDP and debugger controls. diff --git a/.claude/skills/obsidian-markdown/SKILL.md b/.claude/skills/obsidian-markdown/SKILL.md new file mode 100644 index 0000000..bca51a4 --- /dev/null +++ b/.claude/skills/obsidian-markdown/SKILL.md @@ -0,0 +1,196 @@ +--- +name: obsidian-markdown +description: Create and edit Obsidian Flavored Markdown with wikilinks, embeds, callouts, properties, and other Obsidian-specific syntax. Use when working with .md files in Obsidian, or when the user mentions wikilinks, callouts, frontmatter, tags, embeds, or Obsidian notes. +--- + +# Obsidian Flavored Markdown Skill + +Create and edit valid Obsidian Flavored Markdown. Obsidian extends CommonMark and GFM with wikilinks, embeds, callouts, properties, comments, and other syntax. This skill covers only Obsidian-specific extensions -- standard Markdown (headings, bold, italic, lists, quotes, code blocks, tables) is assumed knowledge. + +## Workflow: Creating an Obsidian Note + +1. **Add frontmatter** with properties (title, tags, aliases) at the top of the file. See [PROPERTIES.md](references/PROPERTIES.md) for all property types. +2. **Write content** using standard Markdown for structure, plus Obsidian-specific syntax below. +3. **Link related notes** using wikilinks (`[[Note]]`) for internal vault connections, or standard Markdown links for external URLs. +4. **Embed content** from other notes, images, or PDFs using the `![[embed]]` syntax. See [EMBEDS.md](references/EMBEDS.md) for all embed types. +5. **Add callouts** for highlighted information using `> [!type]` syntax. See [CALLOUTS.md](references/CALLOUTS.md) for all callout types. +6. **Verify** the note renders correctly in Obsidian's reading view. + +> When choosing between wikilinks and Markdown links: use `[[wikilinks]]` for notes within the vault (Obsidian tracks renames automatically) and `[text](url)` for external URLs only. + +## Internal Links (Wikilinks) + +```markdown +[[Note Name]] Link to note +[[Note Name|Display Text]] Custom display text +[[Note Name#Heading]] Link to heading +[[Note Name#^block-id]] Link to block +[[#Heading in same note]] Same-note heading link +``` + +Define a block ID by appending `^block-id` to any paragraph: + +```markdown +This paragraph can be linked to. ^my-block-id +``` + +For lists and quotes, place the block ID on a separate line after the block: + +```markdown +> A quote block + +^quote-id +``` + +## Embeds + +Prefix any wikilink with `!` to embed its content inline: + +```markdown +![[Note Name]] Embed full note +![[Note Name#Heading]] Embed section +![[image.png]] Embed image +![[image.png|300]] Embed image with width +![[document.pdf#page=3]] Embed PDF page +``` + +See [EMBEDS.md](references/EMBEDS.md) for audio, video, search embeds, and external images. + +## Callouts + +```markdown +> [!note] +> Basic callout. + +> [!warning] Custom Title +> Callout with a custom title. + +> [!faq]- Collapsed by default +> Foldable callout (- collapsed, + expanded). +``` + +Common types: `note`, `tip`, `warning`, `info`, `example`, `quote`, `bug`, `danger`, `success`, `failure`, `question`, `abstract`, `todo`. + +See [CALLOUTS.md](references/CALLOUTS.md) for the full list with aliases, nesting, and custom CSS callouts. + +## Properties (Frontmatter) + +```yaml +--- +title: My Note +date: 2024-01-15 +tags: + - project + - active +aliases: + - Alternative Name +cssclasses: + - custom-class +--- +``` + +Default properties: `tags` (searchable labels), `aliases` (alternative note names for link suggestions), `cssclasses` (CSS classes for styling). + +See [PROPERTIES.md](references/PROPERTIES.md) for all property types, tag syntax rules, and advanced usage. + +## Tags + +```markdown +#tag Inline tag +#nested/tag Nested tag with hierarchy +``` + +Tags can contain letters, numbers (not first character), underscores, hyphens, and forward slashes. Tags can also be defined in frontmatter under the `tags` property. + +## Comments + +```markdown +This is visible %%but this is hidden%% text. + +%% +This entire block is hidden in reading view. +%% +``` + +## Obsidian-Specific Formatting + +```markdown +==Highlighted text== Highlight syntax +``` + +## Math (LaTeX) + +```markdown +Inline: $e^{i\pi} + 1 = 0$ + +Block: +$$ +\frac{a}{b} = c +$$ +``` + +## Diagrams (Mermaid) + +````markdown +```mermaid +graph TD + A[Start] --> B{Decision} + B -->|Yes| C[Do this] + B -->|No| D[Do that] +``` +```` + +To link Mermaid nodes to Obsidian notes, add `class NodeName internal-link;`. + +## Footnotes + +```markdown +Text with a footnote[^1]. + +[^1]: Footnote content. + +Inline footnote.^[This is inline.] +``` + +## Complete Example + +````markdown +--- +title: Project Alpha +date: 2024-01-15 +tags: + - project + - active +status: in-progress +--- + +# Project Alpha + +This project aims to [[improve workflow]] using modern techniques. + +> [!important] Key Deadline +> The first milestone is due on ==January 30th==. + +## Tasks + +- [x] Initial planning +- [ ] Development phase + - [ ] Backend implementation + - [ ] Frontend design + +## Notes + +The algorithm uses $O(n \log n)$ sorting. See [[Algorithm Notes#Sorting]] for details. + +![[Architecture Diagram.png|600]] + +Reviewed in [[Meeting Notes 2024-01-10#Decisions]]. +```` + +## References + +- [Obsidian Flavored Markdown](https://help.obsidian.md/obsidian-flavored-markdown) +- [Internal links](https://help.obsidian.md/links) +- [Embed files](https://help.obsidian.md/embeds) +- [Callouts](https://help.obsidian.md/callouts) +- [Properties](https://help.obsidian.md/properties) diff --git a/.claude/skills/obsidian-markdown/references/CALLOUTS.md b/.claude/skills/obsidian-markdown/references/CALLOUTS.md new file mode 100644 index 0000000..c086824 --- /dev/null +++ b/.claude/skills/obsidian-markdown/references/CALLOUTS.md @@ -0,0 +1,58 @@ +# Callouts Reference + +## Basic Callout + +```markdown +> [!note] +> This is a note callout. + +> [!info] Custom Title +> This callout has a custom title. + +> [!tip] Title Only +``` + +## Foldable Callouts + +```markdown +> [!faq]- Collapsed by default +> This content is hidden until expanded. + +> [!faq]+ Expanded by default +> This content is visible but can be collapsed. +``` + +## Nested Callouts + +```markdown +> [!question] Outer callout +> > [!note] Inner callout +> > Nested content +``` + +## Supported Callout Types + +| Type | Aliases | Color / Icon | +|------|---------|-------------| +| `note` | - | Blue, pencil | +| `abstract` | `summary`, `tldr` | Teal, clipboard | +| `info` | - | Blue, info | +| `todo` | - | Blue, checkbox | +| `tip` | `hint`, `important` | Cyan, flame | +| `success` | `check`, `done` | Green, checkmark | +| `question` | `help`, `faq` | Yellow, question mark | +| `warning` | `caution`, `attention` | Orange, warning | +| `failure` | `fail`, `missing` | Red, X | +| `danger` | `error` | Red, zap | +| `bug` | - | Red, bug | +| `example` | - | Purple, list | +| `quote` | `cite` | Gray, quote | + +## Custom Callouts (CSS) + +```css +.callout[data-callout="custom-type"] { + --callout-color: 255, 0, 0; + --callout-icon: lucide-alert-circle; +} +``` diff --git a/.claude/skills/obsidian-markdown/references/EMBEDS.md b/.claude/skills/obsidian-markdown/references/EMBEDS.md new file mode 100644 index 0000000..14a8989 --- /dev/null +++ b/.claude/skills/obsidian-markdown/references/EMBEDS.md @@ -0,0 +1,63 @@ +# Embeds Reference + +## Embed Notes + +```markdown +![[Note Name]] +![[Note Name#Heading]] +![[Note Name#^block-id]] +``` + +## Embed Images + +```markdown +![[image.png]] +![[image.png|640x480]] Width x Height +![[image.png|300]] Width only (maintains aspect ratio) +``` + +## External Images + +```markdown +![Alt text](https://example.com/image.png) +![Alt text|300](https://example.com/image.png) +``` + +## Embed Audio + +```markdown +![[audio.mp3]] +![[audio.ogg]] +``` + +## Embed PDF + +```markdown +![[document.pdf]] +![[document.pdf#page=3]] +![[document.pdf#height=400]] +``` + +## Embed Lists + +```markdown +![[Note#^list-id]] +``` + +Where the list has a block ID: + +```markdown +- Item 1 +- Item 2 +- Item 3 + +^list-id +``` + +## Embed Search Results + +````markdown +```query +tag:#project status:done +``` +```` diff --git a/.claude/skills/obsidian-markdown/references/PROPERTIES.md b/.claude/skills/obsidian-markdown/references/PROPERTIES.md new file mode 100644 index 0000000..e46a63a --- /dev/null +++ b/.claude/skills/obsidian-markdown/references/PROPERTIES.md @@ -0,0 +1,61 @@ +# Properties (Frontmatter) Reference + +Properties use YAML frontmatter at the start of a note: + +```yaml +--- +title: My Note Title +date: 2024-01-15 +tags: + - project + - important +aliases: + - My Note + - Alternative Name +cssclasses: + - custom-class +status: in-progress +rating: 4.5 +completed: false +due: 2024-02-01T14:30:00 +--- +``` + +## Property Types + +| Type | Example | +|------|---------| +| Text | `title: My Title` | +| Number | `rating: 4.5` | +| Checkbox | `completed: true` | +| Date | `date: 2024-01-15` | +| Date & Time | `due: 2024-01-15T14:30:00` | +| List | `tags: [one, two]` or YAML list | +| Links | `related: "[[Other Note]]"` | + +## Default Properties + +- `tags` - Note tags (searchable, shown in graph view) +- `aliases` - Alternative names for the note (used in link suggestions) +- `cssclasses` - CSS classes applied to the note in reading/editing view + +## Tags + +```markdown +#tag +#nested/tag +#tag-with-dashes +#tag_with_underscores +``` + +Tags can contain: letters (any language), numbers (not first character), underscores `_`, hyphens `-`, forward slashes `/` (for nesting). + +In frontmatter: + +```yaml +--- +tags: + - tag1 + - nested/tag2 +--- +``` diff --git a/.claudian/claudian-settings.json b/.claudian/claudian-settings.json new file mode 100644 index 0000000..e16901c --- /dev/null +++ b/.claudian/claudian-settings.json @@ -0,0 +1,68 @@ +{ + "userName": "BlueRose", + "permissionMode": "yolo", + "model": "opus[1m]", + "thinkingBudget": "medium", + "effortLevel": "low", + "serviceTier": "default", + "enableAutoTitleGeneration": true, + "titleGenerationModel": "", + "excludedTags": [], + "mediaFolder": "", + "systemPrompt": "", + "persistentExternalContextPaths": [], + "sharedEnvironmentVariables": "", + "envSnippets": [], + "customContextLimits": {}, + "keyboardNavigation": { + "scrollUpKey": "w", + "scrollDownKey": "s", + "focusInputKey": "i" + }, + "locale": "en", + "providerConfigs": { + "claude": { + "safeMode": "acceptEdits", + "cliPath": "", + "cliPathsByHost": {}, + "loadUserSettings": true, + "enableChrome": false, + "enableBangBash": false, + "enableOpus1M": true, + "enableSonnet1M": false, + "lastModel": "opus[1m]", + "environmentVariables": "", + "environmentHash": "" + }, + "codex": { + "enabled": false, + "safeMode": "workspace-write", + "cliPath": "", + "cliPathsByHost": {}, + "reasoningSummary": "detailed", + "environmentVariables": "", + "environmentHash": "", + "installationMethod": "native-windows", + "installationMethodsByHost": {}, + "wslDistroOverride": "", + "wslDistroOverridesByHost": {} + } + }, + "settingsProvider": "claude", + "savedProviderModel": { + "claude": "opus[1m]" + }, + "savedProviderEffort": { + "claude": "low" + }, + "savedProviderServiceTier": {}, + "savedProviderThinkingBudget": { + "claude": "medium" + }, + "lastCustomModel": "", + "maxTabs": 3, + "tabBarPosition": "input", + "enableAutoScroll": true, + "openInMainTab": false, + "hiddenProviderCommands": {} +} \ No newline at end of file diff --git a/.claudian/sessions/conv-1776071385957-rol42oxg8.meta.json b/.claudian/sessions/conv-1776071385957-rol42oxg8.meta.json new file mode 100644 index 0000000..14753c1 --- /dev/null +++ b/.claudian/sessions/conv-1776071385957-rol42oxg8.meta.json @@ -0,0 +1,24 @@ +{ + "id": "conv-1776071385957-rol42oxg8", + "providerId": "claude", + "title": "Greet user in Chinese", + "titleGenerationStatus": "success", + "createdAt": 1776071385957, + "updatedAt": 1776179962356, + "lastResponseAt": 1776179962356, + "sessionId": "c432006f-72f1-4f80-9625-7cb62e468878", + "providerState": { + "providerSessionId": "c432006f-72f1-4f80-9625-7cb62e468878" + }, + "currentNote": "07-Other/AI/Obsidian/Obsidian CLI.md", + "usage": { + "model": "opus[1m]", + "inputTokens": 1, + "cacheCreationInputTokens": 1084, + "cacheReadInputTokens": 41428, + "contextWindow": 1000000, + "contextTokens": 42513, + "percentage": 4, + "contextWindowIsAuthoritative": true + } +} \ No newline at end of file diff --git a/.obsidian/app.json b/.obsidian/app.json index 0cd8116..900b5fb 100644 --- a/.obsidian/app.json +++ b/.obsidian/app.json @@ -4,7 +4,7 @@ "promptDelete": false, "pdfExportSettings": { "includeName": true, - "pageSize": "A3", + "pageSize": "A4", "landscape": false, "margin": "0", "downscalePercent": 87 diff --git a/.obsidian/community-plugins.json b/.obsidian/community-plugins.json index 9d44a31..b1d7f06 100644 --- a/.obsidian/community-plugins.json +++ b/.obsidian/community-plugins.json @@ -36,5 +36,6 @@ "Enhanced-editing", "table-editor-obsidian", "obsidian-excalidraw-plugin", - "image-captions" + "image-captions", + "claudian" ] \ No newline at end of file diff --git a/.obsidian/plugins/claudian/data.json b/.obsidian/plugins/claudian/data.json new file mode 100644 index 0000000..2fdd55a --- /dev/null +++ b/.obsidian/plugins/claudian/data.json @@ -0,0 +1,11 @@ +{ + "tabManagerState": { + "openTabs": [ + { + "tabId": "tab-1776071369651-6oz9pqs", + "conversationId": "conv-1776071385957-rol42oxg8" + } + ], + "activeTabId": "tab-1776071369651-6oz9pqs" + } +} \ No newline at end of file diff --git a/.obsidian/plugins/claudian/main.js b/.obsidian/plugins/claudian/main.js new file mode 100644 index 0000000..a6eea6d --- /dev/null +++ b/.obsidian/plugins/claudian/main.js @@ -0,0 +1,84218 @@ +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __typeError = (msg) => { + throw TypeError(msg); +}; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __esm = (fn, res) => function __init() { + return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res; +}; +var __commonJS = (cb2, mod) => function __require() { + return mod || (0, cb2[__getOwnPropNames(cb2)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); +var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); +var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg); +var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj)); +var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value); +var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value); + +// src/utils/path.ts +function getVaultPath(app) { + const adapter = app.vault.adapter; + if ("basePath" in adapter) { + return adapter.basePath; + } + return null; +} +function getEnvValue(key) { + const hasKey = (name) => Object.prototype.hasOwnProperty.call(process.env, name); + if (hasKey(key)) { + return process.env[key]; + } + if (process.platform !== "win32") { + return void 0; + } + const upper = key.toUpperCase(); + if (hasKey(upper)) { + return process.env[upper]; + } + const lower = key.toLowerCase(); + if (hasKey(lower)) { + return process.env[lower]; + } + const matchKey = Object.keys(process.env).find((name) => name.toLowerCase() === key.toLowerCase()); + return matchKey ? process.env[matchKey] : void 0; +} +function expandEnvironmentVariables(value) { + if (!value.includes("%") && !value.includes("$") && !value.includes("!")) { + return value; + } + const isWindows2 = process.platform === "win32"; + let expanded = value; + expanded = expanded.replace(/%([A-Za-z_][A-Za-z0-9_]*(?:\([A-Za-z0-9_]+\))?[A-Za-z0-9_]*)%/g, (match, name) => { + const envValue = getEnvValue(name); + return envValue !== void 0 ? envValue : match; + }); + if (isWindows2) { + expanded = expanded.replace(/!([A-Za-z_][A-Za-z0-9_]*)!/g, (match, name) => { + const envValue = getEnvValue(name); + return envValue !== void 0 ? envValue : match; + }); + expanded = expanded.replace(/\$env:([A-Za-z_][A-Za-z0-9_]*)/gi, (match, name) => { + const envValue = getEnvValue(name); + return envValue !== void 0 ? envValue : match; + }); + } + expanded = expanded.replace(/\$([A-Za-z_][A-Za-z0-9_]*)|\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (match, name1, name2) => { + const key = name1 != null ? name1 : name2; + if (!key) return match; + const envValue = getEnvValue(key); + return envValue !== void 0 ? envValue : match; + }); + return expanded; +} +function expandHomePath(p) { + const expanded = expandEnvironmentVariables(p); + if (expanded === "~") { + return os4.homedir(); + } + if (expanded.startsWith("~/")) { + return path4.join(os4.homedir(), expanded.slice(2)); + } + if (expanded.startsWith("~\\")) { + return path4.join(os4.homedir(), expanded.slice(2)); + } + return expanded; +} +function stripSurroundingQuotes(value) { + if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) { + return value.slice(1, -1); + } + return value; +} +function parsePathEntries(pathValue) { + if (!pathValue) { + return []; + } + const delimiter = process.platform === "win32" ? ";" : ":"; + return pathValue.split(delimiter).map((segment) => stripSurroundingQuotes(segment.trim())).filter((segment) => { + if (!segment) return false; + const upper = segment.toUpperCase(); + return upper !== "$PATH" && upper !== "${PATH}" && upper !== "%PATH%"; + }).map((segment) => translateMsysPath(expandHomePath(segment))); +} +function isNvmBuiltInLatestAlias(alias) { + return NVM_LATEST_INSTALLED_ALIASES.has(alias); +} +function findMatchingNvmVersion(entries, resolvedAlias) { + if (isNvmBuiltInLatestAlias(resolvedAlias)) { + return entries[0]; + } + const version2 = resolvedAlias.replace(/^v/, ""); + return entries.find((entry) => { + const entryVersion = entry.slice(1); + return entryVersion === version2 || entryVersion.startsWith(version2 + "."); + }); +} +function resolveNvmAlias(nvmDir, alias, depth = 0) { + if (depth > 5) return null; + if (/^\d/.test(alias) || alias.startsWith("v")) return alias; + if (isNvmBuiltInLatestAlias(alias)) return alias; + try { + const aliasFile = path4.join(nvmDir, "alias", ...alias.split("/")); + const target = fs4.readFileSync(aliasFile, "utf8").trim(); + if (!target) return null; + return resolveNvmAlias(nvmDir, target, depth + 1); + } catch (e3) { + return null; + } +} +function resolveNvmDefaultBin(home) { + const nvmDir = process.env.NVM_DIR || path4.join(home, ".nvm"); + try { + const alias = fs4.readFileSync(path4.join(nvmDir, "alias", "default"), "utf8").trim(); + if (!alias) return null; + const resolved = resolveNvmAlias(nvmDir, alias); + if (!resolved) return null; + const versionsDir = path4.join(nvmDir, "versions", "node"); + const entries = fs4.readdirSync(versionsDir).filter((entry) => entry.startsWith("v")).sort((a3, b) => b.localeCompare(a3, void 0, { numeric: true })); + const matched = findMatchingNvmVersion(entries, resolved); + if (matched) { + const binDir = path4.join(versionsDir, matched, "bin"); + if (fs4.existsSync(binDir)) return binDir; + } + } catch (e3) { + } + return null; +} +function resolveRealPath(p) { + var _a3; + const realpathFn = (_a3 = fs4.realpathSync.native) != null ? _a3 : fs4.realpathSync; + try { + return realpathFn(p); + } catch (e3) { + const absolute = path4.resolve(p); + let current = absolute; + const suffix = []; + for (; ; ) { + try { + if (fs4.existsSync(current)) { + const resolvedExisting = realpathFn(current); + return suffix.length > 0 ? path4.join(resolvedExisting, ...suffix.reverse()) : resolvedExisting; + } + } catch (e4) { + } + const parent = path4.dirname(current); + if (parent === current) { + return absolute; + } + suffix.push(path4.basename(current)); + current = parent; + } + } +} +function translateMsysPath(value) { + var _a3; + if (process.platform !== "win32") { + return value; + } + const msysMatch = value.match(/^\/([a-zA-Z])(\/.*)?$/); + if (msysMatch) { + const driveLetter = msysMatch[1].toUpperCase(); + const restOfPath = (_a3 = msysMatch[2]) != null ? _a3 : ""; + return `${driveLetter}:${restOfPath.replace(/\//g, "\\")}`; + } + return value; +} +function normalizePathBeforeResolution(p) { + const expanded = expandHomePath(p); + return translateMsysPath(expanded); +} +function normalizeWindowsPathPrefix(value) { + if (process.platform !== "win32") { + return value; + } + const normalized = translateMsysPath(value); + if (normalized.startsWith("\\\\?\\UNC\\")) { + return `\\\\${normalized.slice("\\\\?\\UNC\\".length)}`; + } + if (normalized.startsWith("\\\\?\\")) { + return normalized.slice("\\\\?\\".length); + } + return normalized; +} +function normalizePathForFilesystem(value) { + if (!value || typeof value !== "string") { + return ""; + } + const expanded = normalizePathBeforeResolution(value); + const normalized = (() => { + try { + return process.platform === "win32" ? path4.win32.normalize(expanded) : path4.normalize(expanded); + } catch (e3) { + return expanded; + } + })(); + return normalizeWindowsPathPrefix(normalized); +} +function normalizePathForComparison2(value) { + if (!value || typeof value !== "string") { + return ""; + } + const expanded = normalizePathBeforeResolution(value); + const normalized = (() => { + try { + return process.platform === "win32" ? path4.win32.normalize(expanded) : path4.normalize(expanded); + } catch (e3) { + return expanded; + } + })(); + const normalizedWithPrefix = normalizeWindowsPathPrefix(normalized).replace(/\\/g, "/").replace(/\/+$/, ""); + return process.platform === "win32" ? normalizedWithPrefix.toLowerCase() : normalizedWithPrefix; +} +function isPathWithinDirectory(candidatePath, directoryPath, relativeBasePath) { + if (!candidatePath || !directoryPath) { + return false; + } + const directoryReal = normalizePathForComparison2(resolveRealPath(directoryPath)); + const normalizedCandidate = normalizePathForFilesystem(candidatePath); + if (!normalizedCandidate) { + return false; + } + const absCandidate = path4.isAbsolute(normalizedCandidate) ? normalizedCandidate : path4.resolve(relativeBasePath != null ? relativeBasePath : directoryPath, normalizedCandidate); + const resolvedCandidate = normalizePathForComparison2(resolveRealPath(absCandidate)); + return resolvedCandidate === directoryReal || resolvedCandidate.startsWith(directoryReal + "/"); +} +function isPathWithinVault(candidatePath, vaultPath) { + return isPathWithinDirectory(candidatePath, vaultPath, vaultPath); +} +function normalizePathForVault(rawPath, vaultPath) { + if (!rawPath) return null; + const normalizedRaw = normalizePathForFilesystem(rawPath); + if (!normalizedRaw) return null; + if (vaultPath && isPathWithinVault(normalizedRaw, vaultPath)) { + const absolute = path4.isAbsolute(normalizedRaw) ? normalizedRaw : path4.resolve(vaultPath, normalizedRaw); + const relative3 = path4.relative(vaultPath, absolute); + return relative3 ? relative3.replace(/\\/g, "/") : null; + } + return normalizedRaw.replace(/\\/g, "/"); +} +var fs4, os4, path4, NVM_LATEST_INSTALLED_ALIASES; +var init_path = __esm({ + "src/utils/path.ts"() { + fs4 = __toESM(require("fs")); + os4 = __toESM(require("os")); + path4 = __toESM(require("path")); + NVM_LATEST_INSTALLED_ALIASES = /* @__PURE__ */ new Set(["node", "stable"]); + } +}); + +// src/utils/env.ts +var env_exports = {}; +__export(env_exports, { + MAX_CONTEXT_LIMIT: () => MAX_CONTEXT_LIMIT, + MIN_CONTEXT_LIMIT: () => MIN_CONTEXT_LIMIT, + cliPathRequiresNode: () => cliPathRequiresNode, + findNodeDirectory: () => findNodeDirectory, + findNodeExecutable: () => findNodeExecutable, + formatContextLimit: () => formatContextLimit, + getEnhancedPath: () => getEnhancedPath, + getHostnameKey: () => getHostnameKey, + getMissingNodeError: () => getMissingNodeError, + parseContextLimit: () => parseContextLimit, + parseEnvironmentVariables: () => parseEnvironmentVariables +}); +function getHomeDir() { + return process.env.HOME || process.env.USERPROFILE || ""; +} +function getAppProvidedCliPaths() { + if (process.platform === "darwin") { + const appBundleMatch = process.execPath.match(/^(.+?\.app)\//); + if (appBundleMatch) { + return [path5.join(appBundleMatch[1], "Contents", "MacOS")]; + } + return [path5.dirname(process.execPath)]; + } + if (process.platform === "win32") { + return [path5.dirname(process.execPath)]; + } + return []; +} +function getExtraBinaryPaths() { + const home = getHomeDir(); + if (isWindows) { + const paths = []; + const localAppData = process.env.LOCALAPPDATA; + const appData = process.env.APPDATA; + const programFiles = process.env.ProgramFiles || "C:\\Program Files"; + const programFilesX86 = process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)"; + const programData = process.env.ProgramData || "C:\\ProgramData"; + if (appData) { + paths.push(path5.join(appData, "npm")); + } + if (localAppData) { + paths.push(path5.join(localAppData, "Programs", "nodejs")); + paths.push(path5.join(localAppData, "Programs", "node")); + } + paths.push(path5.join(programFiles, "nodejs")); + paths.push(path5.join(programFilesX86, "nodejs")); + const nvmSymlink = process.env.NVM_SYMLINK; + if (nvmSymlink) { + paths.push(nvmSymlink); + } + const nvmHome = process.env.NVM_HOME; + if (nvmHome) { + paths.push(nvmHome); + } else if (appData) { + paths.push(path5.join(appData, "nvm")); + } + const voltaHome = process.env.VOLTA_HOME; + if (voltaHome) { + paths.push(path5.join(voltaHome, "bin")); + } else if (home) { + paths.push(path5.join(home, ".volta", "bin")); + } + const fnmMultishell = process.env.FNM_MULTISHELL_PATH; + if (fnmMultishell) { + paths.push(fnmMultishell); + } + const fnmDir = process.env.FNM_DIR; + if (fnmDir) { + paths.push(fnmDir); + } else if (localAppData) { + paths.push(path5.join(localAppData, "fnm")); + } + const chocolateyInstall = process.env.ChocolateyInstall; + if (chocolateyInstall) { + paths.push(path5.join(chocolateyInstall, "bin")); + } else { + paths.push(path5.join(programData, "chocolatey", "bin")); + } + const scoopDir = process.env.SCOOP; + if (scoopDir) { + paths.push(path5.join(scoopDir, "shims")); + paths.push(path5.join(scoopDir, "apps", "nodejs", "current", "bin")); + paths.push(path5.join(scoopDir, "apps", "nodejs", "current")); + } else if (home) { + paths.push(path5.join(home, "scoop", "shims")); + paths.push(path5.join(home, "scoop", "apps", "nodejs", "current", "bin")); + paths.push(path5.join(home, "scoop", "apps", "nodejs", "current")); + } + paths.push(path5.join(programFiles, "Docker", "Docker", "resources", "bin")); + if (home) { + paths.push(path5.join(home, ".local", "bin")); + paths.push(path5.join(home, ".bun", "bin")); + } + paths.push(...getAppProvidedCliPaths()); + return paths; + } else { + const paths = [ + "/usr/local/bin", + "/opt/homebrew/bin", + // macOS ARM Homebrew + "/usr/bin", + "/bin" + ]; + const voltaHome = process.env.VOLTA_HOME; + if (voltaHome) { + paths.push(path5.join(voltaHome, "bin")); + } + const asdfRoot = process.env.ASDF_DATA_DIR || process.env.ASDF_DIR; + if (asdfRoot) { + paths.push(path5.join(asdfRoot, "shims")); + paths.push(path5.join(asdfRoot, "bin")); + } + const fnmMultishell = process.env.FNM_MULTISHELL_PATH; + if (fnmMultishell) { + paths.push(fnmMultishell); + } + const fnmDir = process.env.FNM_DIR; + if (fnmDir) { + paths.push(fnmDir); + } + if (home) { + paths.push(path5.join(home, ".local", "bin")); + paths.push(path5.join(home, ".bun", "bin")); + paths.push(path5.join(home, ".docker", "bin")); + paths.push(path5.join(home, ".volta", "bin")); + paths.push(path5.join(home, ".asdf", "shims")); + paths.push(path5.join(home, ".asdf", "bin")); + paths.push(path5.join(home, ".fnm")); + const nvmBin = process.env.NVM_BIN; + if (nvmBin) { + paths.push(nvmBin); + } else { + const nvmDefault = resolveNvmDefaultBin(home); + if (nvmDefault) { + paths.push(nvmDefault); + } + } + } + paths.push(...getAppProvidedCliPaths()); + return paths; + } +} +function findNodeDirectory(additionalPaths) { + const searchPaths = getExtraBinaryPaths(); + const currentPath = process.env.PATH || ""; + const pathDirs = parsePathEntries(currentPath); + const additionalDirs = additionalPaths ? parsePathEntries(additionalPaths) : []; + const allPaths = [...additionalDirs, ...searchPaths, ...pathDirs]; + for (const dir of allPaths) { + if (!dir) continue; + try { + const nodePath2 = path5.join(dir, NODE_EXECUTABLE); + if (fs5.existsSync(nodePath2)) { + const stat = fs5.statSync(nodePath2); + if (stat.isFile()) { + return dir; + } + } + } catch (e3) { + } + } + return null; +} +function findNodeExecutable(additionalPaths) { + const nodeDir = findNodeDirectory(additionalPaths); + if (nodeDir) { + return path5.join(nodeDir, NODE_EXECUTABLE); + } + return null; +} +function cliPathRequiresNode(cliPath) { + const jsExtensions = [".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx"]; + const lower = cliPath.toLowerCase(); + if (jsExtensions.some((ext) => lower.endsWith(ext))) { + return true; + } + try { + if (!fs5.existsSync(cliPath)) { + return false; + } + const stat = fs5.statSync(cliPath); + if (!stat.isFile()) { + return false; + } + let fd = null; + try { + fd = fs5.openSync(cliPath, "r"); + const buffer = Buffer.alloc(200); + const bytesRead = fs5.readSync(fd, buffer, 0, buffer.length, 0); + const header = buffer.slice(0, bytesRead).toString("utf8"); + return header.startsWith("#!") && header.toLowerCase().includes("node"); + } finally { + if (fd !== null) { + try { + fs5.closeSync(fd); + } catch (e3) { + } + } + } + } catch (e3) { + return false; + } +} +function getMissingNodeError(cliPath, enhancedPath) { + if (!cliPathRequiresNode(cliPath)) { + return null; + } + const nodePath2 = findNodeExecutable(enhancedPath); + if (nodePath2) { + return null; + } + return "Claude Code CLI requires Node.js, but Node was not found on PATH. Install Node.js or use the native Claude Code binary, then restart Obsidian."; +} +function getEnhancedPath(additionalPaths, cliPath) { + const extraPaths = getExtraBinaryPaths().filter((p) => p); + const currentPath = process.env.PATH || ""; + const segments = []; + if (additionalPaths) { + segments.push(...parsePathEntries(additionalPaths)); + } + let cliDirHasNode = false; + if (cliPath) { + try { + const cliDir = path5.dirname(cliPath); + const nodeInCliDir = path5.join(cliDir, NODE_EXECUTABLE); + if (fs5.existsSync(nodeInCliDir)) { + const stat = fs5.statSync(nodeInCliDir); + if (stat.isFile()) { + segments.push(cliDir); + cliDirHasNode = true; + } + } + } catch (e3) { + } + } + if (cliPath && cliPathRequiresNode(cliPath) && !cliDirHasNode) { + const nodeDir = findNodeDirectory(); + if (nodeDir) { + segments.push(nodeDir); + } + } + segments.push(...extraPaths); + if (currentPath) { + segments.push(...parsePathEntries(currentPath)); + } + const seen = /* @__PURE__ */ new Set(); + const unique = segments.filter((p) => { + const normalized = isWindows ? p.toLowerCase() : p; + if (seen.has(normalized)) return false; + seen.add(normalized); + return true; + }); + return unique.join(PATH_SEPARATOR); +} +function parseEnvironmentVariables(input) { + const result = {}; + for (const line of input.split(/\r?\n/)) { + const trimmed = line.trim(); + if (!trimmed || trimmed.startsWith("#")) continue; + const normalized = trimmed.startsWith("export ") ? trimmed.slice(7) : trimmed; + const eqIndex = normalized.indexOf("="); + if (eqIndex > 0) { + const key = normalized.substring(0, eqIndex).trim(); + let value = normalized.substring(eqIndex + 1).trim(); + if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) { + value = value.slice(1, -1); + } + if (key) { + result[key] = value; + } + } + } + return result; +} +function getHostnameKey() { + return os5.hostname(); +} +function parseContextLimit(input) { + var _a3; + const trimmed = input.trim().toLowerCase().replace(/,/g, ""); + if (!trimmed) return null; + const match = trimmed.match(/^(\d+(?:\.\d+)?)\s*(k|m)?$/); + if (!match) return null; + const value = parseFloat(match[1]); + const suffix = match[2]; + if (isNaN(value) || value <= 0) return null; + const MULTIPLIERS = { k: 1e3, m: 1e6 }; + const multiplier = suffix ? (_a3 = MULTIPLIERS[suffix]) != null ? _a3 : 1 : 1; + const result = Math.round(value * multiplier); + if (result < MIN_CONTEXT_LIMIT || result > MAX_CONTEXT_LIMIT) return null; + return result; +} +function formatContextLimit(tokens) { + if (tokens >= 1e6 && tokens % 1e6 === 0) { + return `${tokens / 1e6}m`; + } + if (tokens >= 1e3 && tokens % 1e3 === 0) { + return `${tokens / 1e3}k`; + } + return tokens.toLocaleString(); +} +var fs5, os5, path5, isWindows, PATH_SEPARATOR, NODE_EXECUTABLE, MIN_CONTEXT_LIMIT, MAX_CONTEXT_LIMIT; +var init_env = __esm({ + "src/utils/env.ts"() { + fs5 = __toESM(require("fs")); + os5 = __toESM(require("os")); + path5 = __toESM(require("path")); + init_path(); + isWindows = process.platform === "win32"; + PATH_SEPARATOR = isWindows ? ";" : ":"; + NODE_EXECUTABLE = isWindows ? "node.exe" : "node"; + MIN_CONTEXT_LIMIT = 1e3; + MAX_CONTEXT_LIMIT = 1e7; + } +}); + +// node_modules/ajv/dist/compile/codegen/code.js +var require_code = __commonJS({ + "node_modules/ajv/dist/compile/codegen/code.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.regexpCode = exports.getEsmExportName = exports.getProperty = exports.safeStringify = exports.stringify = exports.strConcat = exports.addCodeArg = exports.str = exports._ = exports.nil = exports._Code = exports.Name = exports.IDENTIFIER = exports._CodeOrName = void 0; + var _CodeOrName = class { + }; + exports._CodeOrName = _CodeOrName; + exports.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i; + var Name = class extends _CodeOrName { + constructor(s3) { + super(); + if (!exports.IDENTIFIER.test(s3)) + throw new Error("CodeGen: name must be a valid identifier"); + this.str = s3; + } + toString() { + return this.str; + } + emptyStr() { + return false; + } + get names() { + return { [this.str]: 1 }; + } + }; + exports.Name = Name; + var _Code = class extends _CodeOrName { + constructor(code) { + super(); + this._items = typeof code === "string" ? [code] : code; + } + toString() { + return this.str; + } + emptyStr() { + if (this._items.length > 1) + return false; + const item = this._items[0]; + return item === "" || item === '""'; + } + get str() { + var _a3; + return (_a3 = this._str) !== null && _a3 !== void 0 ? _a3 : this._str = this._items.reduce((s3, c) => `${s3}${c}`, ""); + } + get names() { + var _a3; + return (_a3 = this._names) !== null && _a3 !== void 0 ? _a3 : this._names = this._items.reduce((names, c) => { + if (c instanceof Name) + names[c.str] = (names[c.str] || 0) + 1; + return names; + }, {}); + } + }; + exports._Code = _Code; + exports.nil = new _Code(""); + function _3(strs, ...args) { + const code = [strs[0]]; + let i3 = 0; + while (i3 < args.length) { + addCodeArg(code, args[i3]); + code.push(strs[++i3]); + } + return new _Code(code); + } + exports._ = _3; + var plus = new _Code("+"); + function str(strs, ...args) { + const expr = [safeStringify(strs[0])]; + let i3 = 0; + while (i3 < args.length) { + expr.push(plus); + addCodeArg(expr, args[i3]); + expr.push(plus, safeStringify(strs[++i3])); + } + optimize(expr); + return new _Code(expr); + } + exports.str = str; + function addCodeArg(code, arg) { + if (arg instanceof _Code) + code.push(...arg._items); + else if (arg instanceof Name) + code.push(arg); + else + code.push(interpolate(arg)); + } + exports.addCodeArg = addCodeArg; + function optimize(expr) { + let i3 = 1; + while (i3 < expr.length - 1) { + if (expr[i3] === plus) { + const res = mergeExprItems(expr[i3 - 1], expr[i3 + 1]); + if (res !== void 0) { + expr.splice(i3 - 1, 3, res); + continue; + } + expr[i3++] = "+"; + } + i3++; + } + } + function mergeExprItems(a3, b) { + if (b === '""') + return a3; + if (a3 === '""') + return b; + if (typeof a3 == "string") { + if (b instanceof Name || a3[a3.length - 1] !== '"') + return; + if (typeof b != "string") + return `${a3.slice(0, -1)}${b}"`; + if (b[0] === '"') + return a3.slice(0, -1) + b.slice(1); + return; + } + if (typeof b == "string" && b[0] === '"' && !(a3 instanceof Name)) + return `"${a3}${b.slice(1)}`; + return; + } + function strConcat(c12, c22) { + return c22.emptyStr() ? c12 : c12.emptyStr() ? c22 : str`${c12}${c22}`; + } + exports.strConcat = strConcat; + function interpolate(x) { + return typeof x == "number" || typeof x == "boolean" || x === null ? x : safeStringify(Array.isArray(x) ? x.join(",") : x); + } + function stringify2(x) { + return new _Code(safeStringify(x)); + } + exports.stringify = stringify2; + function safeStringify(x) { + return JSON.stringify(x).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029"); + } + exports.safeStringify = safeStringify; + function getProperty(key) { + return typeof key == "string" && exports.IDENTIFIER.test(key) ? new _Code(`.${key}`) : _3`[${key}]`; + } + exports.getProperty = getProperty; + function getEsmExportName(key) { + if (typeof key == "string" && exports.IDENTIFIER.test(key)) { + return new _Code(`${key}`); + } + throw new Error(`CodeGen: invalid export name: ${key}, use explicit $id name mapping`); + } + exports.getEsmExportName = getEsmExportName; + function regexpCode(rx) { + return new _Code(rx.toString()); + } + exports.regexpCode = regexpCode; + } +}); + +// node_modules/ajv/dist/compile/codegen/scope.js +var require_scope = __commonJS({ + "node_modules/ajv/dist/compile/codegen/scope.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ValueScope = exports.ValueScopeName = exports.Scope = exports.varKinds = exports.UsedValueState = void 0; + var code_1 = require_code(); + var ValueError = class extends Error { + constructor(name) { + super(`CodeGen: "code" for ${name} not defined`); + this.value = name.value; + } + }; + var UsedValueState; + (function(UsedValueState2) { + UsedValueState2[UsedValueState2["Started"] = 0] = "Started"; + UsedValueState2[UsedValueState2["Completed"] = 1] = "Completed"; + })(UsedValueState || (exports.UsedValueState = UsedValueState = {})); + exports.varKinds = { + const: new code_1.Name("const"), + let: new code_1.Name("let"), + var: new code_1.Name("var") + }; + var Scope2 = class { + constructor({ prefixes, parent } = {}) { + this._names = {}; + this._prefixes = prefixes; + this._parent = parent; + } + toName(nameOrPrefix) { + return nameOrPrefix instanceof code_1.Name ? nameOrPrefix : this.name(nameOrPrefix); + } + name(prefix) { + return new code_1.Name(this._newName(prefix)); + } + _newName(prefix) { + const ng = this._names[prefix] || this._nameGroup(prefix); + return `${prefix}${ng.index++}`; + } + _nameGroup(prefix) { + var _a3, _b2; + if (((_b2 = (_a3 = this._parent) === null || _a3 === void 0 ? void 0 : _a3._prefixes) === null || _b2 === void 0 ? void 0 : _b2.has(prefix)) || this._prefixes && !this._prefixes.has(prefix)) { + throw new Error(`CodeGen: prefix "${prefix}" is not allowed in this scope`); + } + return this._names[prefix] = { prefix, index: 0 }; + } + }; + exports.Scope = Scope2; + var ValueScopeName = class extends code_1.Name { + constructor(prefix, nameStr) { + super(nameStr); + this.prefix = prefix; + } + setValue(value, { property, itemIndex }) { + this.value = value; + this.scopePath = (0, code_1._)`.${new code_1.Name(property)}[${itemIndex}]`; + } + }; + exports.ValueScopeName = ValueScopeName; + var line = (0, code_1._)`\n`; + var ValueScope = class extends Scope2 { + constructor(opts) { + super(opts); + this._values = {}; + this._scope = opts.scope; + this.opts = { ...opts, _n: opts.lines ? line : code_1.nil }; + } + get() { + return this._scope; + } + name(prefix) { + return new ValueScopeName(prefix, this._newName(prefix)); + } + value(nameOrPrefix, value) { + var _a3; + if (value.ref === void 0) + throw new Error("CodeGen: ref must be passed in value"); + const name = this.toName(nameOrPrefix); + const { prefix } = name; + const valueKey = (_a3 = value.key) !== null && _a3 !== void 0 ? _a3 : value.ref; + let vs = this._values[prefix]; + if (vs) { + const _name = vs.get(valueKey); + if (_name) + return _name; + } else { + vs = this._values[prefix] = /* @__PURE__ */ new Map(); + } + vs.set(valueKey, name); + const s3 = this._scope[prefix] || (this._scope[prefix] = []); + const itemIndex = s3.length; + s3[itemIndex] = value.ref; + name.setValue(value, { property: prefix, itemIndex }); + return name; + } + getValue(prefix, keyOrRef) { + const vs = this._values[prefix]; + if (!vs) + return; + return vs.get(keyOrRef); + } + scopeRefs(scopeName, values = this._values) { + return this._reduceValues(values, (name) => { + if (name.scopePath === void 0) + throw new Error(`CodeGen: name "${name}" has no value`); + return (0, code_1._)`${scopeName}${name.scopePath}`; + }); + } + scopeCode(values = this._values, usedValues, getCode) { + return this._reduceValues(values, (name) => { + if (name.value === void 0) + throw new Error(`CodeGen: name "${name}" has no value`); + return name.value.code; + }, usedValues, getCode); + } + _reduceValues(values, valueCode, usedValues = {}, getCode) { + let code = code_1.nil; + for (const prefix in values) { + const vs = values[prefix]; + if (!vs) + continue; + const nameSet = usedValues[prefix] = usedValues[prefix] || /* @__PURE__ */ new Map(); + vs.forEach((name) => { + if (nameSet.has(name)) + return; + nameSet.set(name, UsedValueState.Started); + let c = valueCode(name); + if (c) { + const def = this.opts.es5 ? exports.varKinds.var : exports.varKinds.const; + code = (0, code_1._)`${code}${def} ${name} = ${c};${this.opts._n}`; + } else if (c = getCode === null || getCode === void 0 ? void 0 : getCode(name)) { + code = (0, code_1._)`${code}${c}${this.opts._n}`; + } else { + throw new ValueError(name); + } + nameSet.set(name, UsedValueState.Completed); + }); + } + return code; + } + }; + exports.ValueScope = ValueScope; + } +}); + +// node_modules/ajv/dist/compile/codegen/index.js +var require_codegen = __commonJS({ + "node_modules/ajv/dist/compile/codegen/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.or = exports.and = exports.not = exports.CodeGen = exports.operators = exports.varKinds = exports.ValueScopeName = exports.ValueScope = exports.Scope = exports.Name = exports.regexpCode = exports.stringify = exports.getProperty = exports.nil = exports.strConcat = exports.str = exports._ = void 0; + var code_1 = require_code(); + var scope_1 = require_scope(); + var code_2 = require_code(); + Object.defineProperty(exports, "_", { enumerable: true, get: function() { + return code_2._; + } }); + Object.defineProperty(exports, "str", { enumerable: true, get: function() { + return code_2.str; + } }); + Object.defineProperty(exports, "strConcat", { enumerable: true, get: function() { + return code_2.strConcat; + } }); + Object.defineProperty(exports, "nil", { enumerable: true, get: function() { + return code_2.nil; + } }); + Object.defineProperty(exports, "getProperty", { enumerable: true, get: function() { + return code_2.getProperty; + } }); + Object.defineProperty(exports, "stringify", { enumerable: true, get: function() { + return code_2.stringify; + } }); + Object.defineProperty(exports, "regexpCode", { enumerable: true, get: function() { + return code_2.regexpCode; + } }); + Object.defineProperty(exports, "Name", { enumerable: true, get: function() { + return code_2.Name; + } }); + var scope_2 = require_scope(); + Object.defineProperty(exports, "Scope", { enumerable: true, get: function() { + return scope_2.Scope; + } }); + Object.defineProperty(exports, "ValueScope", { enumerable: true, get: function() { + return scope_2.ValueScope; + } }); + Object.defineProperty(exports, "ValueScopeName", { enumerable: true, get: function() { + return scope_2.ValueScopeName; + } }); + Object.defineProperty(exports, "varKinds", { enumerable: true, get: function() { + return scope_2.varKinds; + } }); + exports.operators = { + GT: new code_1._Code(">"), + GTE: new code_1._Code(">="), + LT: new code_1._Code("<"), + LTE: new code_1._Code("<="), + EQ: new code_1._Code("==="), + NEQ: new code_1._Code("!=="), + NOT: new code_1._Code("!"), + OR: new code_1._Code("||"), + AND: new code_1._Code("&&"), + ADD: new code_1._Code("+") + }; + var Node = class { + optimizeNodes() { + return this; + } + optimizeNames(_names, _constants) { + return this; + } + }; + var Def = class extends Node { + constructor(varKind, name, rhs) { + super(); + this.varKind = varKind; + this.name = name; + this.rhs = rhs; + } + render({ es5, _n }) { + const varKind = es5 ? scope_1.varKinds.var : this.varKind; + const rhs = this.rhs === void 0 ? "" : ` = ${this.rhs}`; + return `${varKind} ${this.name}${rhs};` + _n; + } + optimizeNames(names, constants) { + if (!names[this.name.str]) + return; + if (this.rhs) + this.rhs = optimizeExpr(this.rhs, names, constants); + return this; + } + get names() { + return this.rhs instanceof code_1._CodeOrName ? this.rhs.names : {}; + } + }; + var Assign = class extends Node { + constructor(lhs, rhs, sideEffects) { + super(); + this.lhs = lhs; + this.rhs = rhs; + this.sideEffects = sideEffects; + } + render({ _n }) { + return `${this.lhs} = ${this.rhs};` + _n; + } + optimizeNames(names, constants) { + if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects) + return; + this.rhs = optimizeExpr(this.rhs, names, constants); + return this; + } + get names() { + const names = this.lhs instanceof code_1.Name ? {} : { ...this.lhs.names }; + return addExprNames(names, this.rhs); + } + }; + var AssignOp = class extends Assign { + constructor(lhs, op, rhs, sideEffects) { + super(lhs, rhs, sideEffects); + this.op = op; + } + render({ _n }) { + return `${this.lhs} ${this.op}= ${this.rhs};` + _n; + } + }; + var Label = class extends Node { + constructor(label) { + super(); + this.label = label; + this.names = {}; + } + render({ _n }) { + return `${this.label}:` + _n; + } + }; + var Break = class extends Node { + constructor(label) { + super(); + this.label = label; + this.names = {}; + } + render({ _n }) { + const label = this.label ? ` ${this.label}` : ""; + return `break${label};` + _n; + } + }; + var Throw = class extends Node { + constructor(error48) { + super(); + this.error = error48; + } + render({ _n }) { + return `throw ${this.error};` + _n; + } + get names() { + return this.error.names; + } + }; + var AnyCode = class extends Node { + constructor(code) { + super(); + this.code = code; + } + render({ _n }) { + return `${this.code};` + _n; + } + optimizeNodes() { + return `${this.code}` ? this : void 0; + } + optimizeNames(names, constants) { + this.code = optimizeExpr(this.code, names, constants); + return this; + } + get names() { + return this.code instanceof code_1._CodeOrName ? this.code.names : {}; + } + }; + var ParentNode = class extends Node { + constructor(nodes = []) { + super(); + this.nodes = nodes; + } + render(opts) { + return this.nodes.reduce((code, n3) => code + n3.render(opts), ""); + } + optimizeNodes() { + const { nodes } = this; + let i3 = nodes.length; + while (i3--) { + const n3 = nodes[i3].optimizeNodes(); + if (Array.isArray(n3)) + nodes.splice(i3, 1, ...n3); + else if (n3) + nodes[i3] = n3; + else + nodes.splice(i3, 1); + } + return nodes.length > 0 ? this : void 0; + } + optimizeNames(names, constants) { + const { nodes } = this; + let i3 = nodes.length; + while (i3--) { + const n3 = nodes[i3]; + if (n3.optimizeNames(names, constants)) + continue; + subtractNames(names, n3.names); + nodes.splice(i3, 1); + } + return nodes.length > 0 ? this : void 0; + } + get names() { + return this.nodes.reduce((names, n3) => addNames(names, n3.names), {}); + } + }; + var BlockNode = class extends ParentNode { + render(opts) { + return "{" + opts._n + super.render(opts) + "}" + opts._n; + } + }; + var Root = class extends ParentNode { + }; + var Else = class extends BlockNode { + }; + Else.kind = "else"; + var If = class _If extends BlockNode { + constructor(condition, nodes) { + super(nodes); + this.condition = condition; + } + render(opts) { + let code = `if(${this.condition})` + super.render(opts); + if (this.else) + code += "else " + this.else.render(opts); + return code; + } + optimizeNodes() { + super.optimizeNodes(); + const cond = this.condition; + if (cond === true) + return this.nodes; + let e3 = this.else; + if (e3) { + const ns = e3.optimizeNodes(); + e3 = this.else = Array.isArray(ns) ? new Else(ns) : ns; + } + if (e3) { + if (cond === false) + return e3 instanceof _If ? e3 : e3.nodes; + if (this.nodes.length) + return this; + return new _If(not(cond), e3 instanceof _If ? [e3] : e3.nodes); + } + if (cond === false || !this.nodes.length) + return void 0; + return this; + } + optimizeNames(names, constants) { + var _a3; + this.else = (_a3 = this.else) === null || _a3 === void 0 ? void 0 : _a3.optimizeNames(names, constants); + if (!(super.optimizeNames(names, constants) || this.else)) + return; + this.condition = optimizeExpr(this.condition, names, constants); + return this; + } + get names() { + const names = super.names; + addExprNames(names, this.condition); + if (this.else) + addNames(names, this.else.names); + return names; + } + }; + If.kind = "if"; + var For = class extends BlockNode { + }; + For.kind = "for"; + var ForLoop = class extends For { + constructor(iteration) { + super(); + this.iteration = iteration; + } + render(opts) { + return `for(${this.iteration})` + super.render(opts); + } + optimizeNames(names, constants) { + if (!super.optimizeNames(names, constants)) + return; + this.iteration = optimizeExpr(this.iteration, names, constants); + return this; + } + get names() { + return addNames(super.names, this.iteration.names); + } + }; + var ForRange = class extends For { + constructor(varKind, name, from, to) { + super(); + this.varKind = varKind; + this.name = name; + this.from = from; + this.to = to; + } + render(opts) { + const varKind = opts.es5 ? scope_1.varKinds.var : this.varKind; + const { name, from, to } = this; + return `for(${varKind} ${name}=${from}; ${name}<${to}; ${name}++)` + super.render(opts); + } + get names() { + const names = addExprNames(super.names, this.from); + return addExprNames(names, this.to); + } + }; + var ForIter = class extends For { + constructor(loop, varKind, name, iterable) { + super(); + this.loop = loop; + this.varKind = varKind; + this.name = name; + this.iterable = iterable; + } + render(opts) { + return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts); + } + optimizeNames(names, constants) { + if (!super.optimizeNames(names, constants)) + return; + this.iterable = optimizeExpr(this.iterable, names, constants); + return this; + } + get names() { + return addNames(super.names, this.iterable.names); + } + }; + var Func = class extends BlockNode { + constructor(name, args, async) { + super(); + this.name = name; + this.args = args; + this.async = async; + } + render(opts) { + const _async = this.async ? "async " : ""; + return `${_async}function ${this.name}(${this.args})` + super.render(opts); + } + }; + Func.kind = "func"; + var Return = class extends ParentNode { + render(opts) { + return "return " + super.render(opts); + } + }; + Return.kind = "return"; + var Try = class extends BlockNode { + render(opts) { + let code = "try" + super.render(opts); + if (this.catch) + code += this.catch.render(opts); + if (this.finally) + code += this.finally.render(opts); + return code; + } + optimizeNodes() { + var _a3, _b2; + super.optimizeNodes(); + (_a3 = this.catch) === null || _a3 === void 0 ? void 0 : _a3.optimizeNodes(); + (_b2 = this.finally) === null || _b2 === void 0 ? void 0 : _b2.optimizeNodes(); + return this; + } + optimizeNames(names, constants) { + var _a3, _b2; + super.optimizeNames(names, constants); + (_a3 = this.catch) === null || _a3 === void 0 ? void 0 : _a3.optimizeNames(names, constants); + (_b2 = this.finally) === null || _b2 === void 0 ? void 0 : _b2.optimizeNames(names, constants); + return this; + } + get names() { + const names = super.names; + if (this.catch) + addNames(names, this.catch.names); + if (this.finally) + addNames(names, this.finally.names); + return names; + } + }; + var Catch = class extends BlockNode { + constructor(error48) { + super(); + this.error = error48; + } + render(opts) { + return `catch(${this.error})` + super.render(opts); + } + }; + Catch.kind = "catch"; + var Finally = class extends BlockNode { + render(opts) { + return "finally" + super.render(opts); + } + }; + Finally.kind = "finally"; + var CodeGen = class { + constructor(extScope, opts = {}) { + this._values = {}; + this._blockStarts = []; + this._constants = {}; + this.opts = { ...opts, _n: opts.lines ? "\n" : "" }; + this._extScope = extScope; + this._scope = new scope_1.Scope({ parent: extScope }); + this._nodes = [new Root()]; + } + toString() { + return this._root.render(this.opts); + } + // returns unique name in the internal scope + name(prefix) { + return this._scope.name(prefix); + } + // reserves unique name in the external scope + scopeName(prefix) { + return this._extScope.name(prefix); + } + // reserves unique name in the external scope and assigns value to it + scopeValue(prefixOrName, value) { + const name = this._extScope.value(prefixOrName, value); + const vs = this._values[name.prefix] || (this._values[name.prefix] = /* @__PURE__ */ new Set()); + vs.add(name); + return name; + } + getScopeValue(prefix, keyOrRef) { + return this._extScope.getValue(prefix, keyOrRef); + } + // return code that assigns values in the external scope to the names that are used internally + // (same names that were returned by gen.scopeName or gen.scopeValue) + scopeRefs(scopeName) { + return this._extScope.scopeRefs(scopeName, this._values); + } + scopeCode() { + return this._extScope.scopeCode(this._values); + } + _def(varKind, nameOrPrefix, rhs, constant) { + const name = this._scope.toName(nameOrPrefix); + if (rhs !== void 0 && constant) + this._constants[name.str] = rhs; + this._leafNode(new Def(varKind, name, rhs)); + return name; + } + // `const` declaration (`var` in es5 mode) + const(nameOrPrefix, rhs, _constant) { + return this._def(scope_1.varKinds.const, nameOrPrefix, rhs, _constant); + } + // `let` declaration with optional assignment (`var` in es5 mode) + let(nameOrPrefix, rhs, _constant) { + return this._def(scope_1.varKinds.let, nameOrPrefix, rhs, _constant); + } + // `var` declaration with optional assignment + var(nameOrPrefix, rhs, _constant) { + return this._def(scope_1.varKinds.var, nameOrPrefix, rhs, _constant); + } + // assignment code + assign(lhs, rhs, sideEffects) { + return this._leafNode(new Assign(lhs, rhs, sideEffects)); + } + // `+=` code + add(lhs, rhs) { + return this._leafNode(new AssignOp(lhs, exports.operators.ADD, rhs)); + } + // appends passed SafeExpr to code or executes Block + code(c) { + if (typeof c == "function") + c(); + else if (c !== code_1.nil) + this._leafNode(new AnyCode(c)); + return this; + } + // returns code for object literal for the passed argument list of key-value pairs + object(...keyValues) { + const code = ["{"]; + for (const [key, value] of keyValues) { + if (code.length > 1) + code.push(","); + code.push(key); + if (key !== value || this.opts.es5) { + code.push(":"); + (0, code_1.addCodeArg)(code, value); + } + } + code.push("}"); + return new code_1._Code(code); + } + // `if` clause (or statement if `thenBody` and, optionally, `elseBody` are passed) + if(condition, thenBody, elseBody) { + this._blockNode(new If(condition)); + if (thenBody && elseBody) { + this.code(thenBody).else().code(elseBody).endIf(); + } else if (thenBody) { + this.code(thenBody).endIf(); + } else if (elseBody) { + throw new Error('CodeGen: "else" body without "then" body'); + } + return this; + } + // `else if` clause - invalid without `if` or after `else` clauses + elseIf(condition) { + return this._elseNode(new If(condition)); + } + // `else` clause - only valid after `if` or `else if` clauses + else() { + return this._elseNode(new Else()); + } + // end `if` statement (needed if gen.if was used only with condition) + endIf() { + return this._endBlockNode(If, Else); + } + _for(node, forBody) { + this._blockNode(node); + if (forBody) + this.code(forBody).endFor(); + return this; + } + // a generic `for` clause (or statement if `forBody` is passed) + for(iteration, forBody) { + return this._for(new ForLoop(iteration), forBody); + } + // `for` statement for a range of values + forRange(nameOrPrefix, from, to, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.let) { + const name = this._scope.toName(nameOrPrefix); + return this._for(new ForRange(varKind, name, from, to), () => forBody(name)); + } + // `for-of` statement (in es5 mode replace with a normal for loop) + forOf(nameOrPrefix, iterable, forBody, varKind = scope_1.varKinds.const) { + const name = this._scope.toName(nameOrPrefix); + if (this.opts.es5) { + const arr = iterable instanceof code_1.Name ? iterable : this.var("_arr", iterable); + return this.forRange("_i", 0, (0, code_1._)`${arr}.length`, (i3) => { + this.var(name, (0, code_1._)`${arr}[${i3}]`); + forBody(name); + }); + } + return this._for(new ForIter("of", varKind, name, iterable), () => forBody(name)); + } + // `for-in` statement. + // With option `ownProperties` replaced with a `for-of` loop for object keys + forIn(nameOrPrefix, obj, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.const) { + if (this.opts.ownProperties) { + return this.forOf(nameOrPrefix, (0, code_1._)`Object.keys(${obj})`, forBody); + } + const name = this._scope.toName(nameOrPrefix); + return this._for(new ForIter("in", varKind, name, obj), () => forBody(name)); + } + // end `for` loop + endFor() { + return this._endBlockNode(For); + } + // `label` statement + label(label) { + return this._leafNode(new Label(label)); + } + // `break` statement + break(label) { + return this._leafNode(new Break(label)); + } + // `return` statement + return(value) { + const node = new Return(); + this._blockNode(node); + this.code(value); + if (node.nodes.length !== 1) + throw new Error('CodeGen: "return" should have one node'); + return this._endBlockNode(Return); + } + // `try` statement + try(tryBody, catchCode, finallyCode) { + if (!catchCode && !finallyCode) + throw new Error('CodeGen: "try" without "catch" and "finally"'); + const node = new Try(); + this._blockNode(node); + this.code(tryBody); + if (catchCode) { + const error48 = this.name("e"); + this._currNode = node.catch = new Catch(error48); + catchCode(error48); + } + if (finallyCode) { + this._currNode = node.finally = new Finally(); + this.code(finallyCode); + } + return this._endBlockNode(Catch, Finally); + } + // `throw` statement + throw(error48) { + return this._leafNode(new Throw(error48)); + } + // start self-balancing block + block(body, nodeCount) { + this._blockStarts.push(this._nodes.length); + if (body) + this.code(body).endBlock(nodeCount); + return this; + } + // end the current self-balancing block + endBlock(nodeCount) { + const len = this._blockStarts.pop(); + if (len === void 0) + throw new Error("CodeGen: not in self-balancing block"); + const toClose = this._nodes.length - len; + if (toClose < 0 || nodeCount !== void 0 && toClose !== nodeCount) { + throw new Error(`CodeGen: wrong number of nodes: ${toClose} vs ${nodeCount} expected`); + } + this._nodes.length = len; + return this; + } + // `function` heading (or definition if funcBody is passed) + func(name, args = code_1.nil, async, funcBody) { + this._blockNode(new Func(name, args, async)); + if (funcBody) + this.code(funcBody).endFunc(); + return this; + } + // end function definition + endFunc() { + return this._endBlockNode(Func); + } + optimize(n3 = 1) { + while (n3-- > 0) { + this._root.optimizeNodes(); + this._root.optimizeNames(this._root.names, this._constants); + } + } + _leafNode(node) { + this._currNode.nodes.push(node); + return this; + } + _blockNode(node) { + this._currNode.nodes.push(node); + this._nodes.push(node); + } + _endBlockNode(N1, N22) { + const n3 = this._currNode; + if (n3 instanceof N1 || N22 && n3 instanceof N22) { + this._nodes.pop(); + return this; + } + throw new Error(`CodeGen: not in block "${N22 ? `${N1.kind}/${N22.kind}` : N1.kind}"`); + } + _elseNode(node) { + const n3 = this._currNode; + if (!(n3 instanceof If)) { + throw new Error('CodeGen: "else" without "if"'); + } + this._currNode = n3.else = node; + return this; + } + get _root() { + return this._nodes[0]; + } + get _currNode() { + const ns = this._nodes; + return ns[ns.length - 1]; + } + set _currNode(node) { + const ns = this._nodes; + ns[ns.length - 1] = node; + } + }; + exports.CodeGen = CodeGen; + function addNames(names, from) { + for (const n3 in from) + names[n3] = (names[n3] || 0) + (from[n3] || 0); + return names; + } + function addExprNames(names, from) { + return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names; + } + function optimizeExpr(expr, names, constants) { + if (expr instanceof code_1.Name) + return replaceName(expr); + if (!canOptimize(expr)) + return expr; + return new code_1._Code(expr._items.reduce((items, c) => { + if (c instanceof code_1.Name) + c = replaceName(c); + if (c instanceof code_1._Code) + items.push(...c._items); + else + items.push(c); + return items; + }, [])); + function replaceName(n3) { + const c = constants[n3.str]; + if (c === void 0 || names[n3.str] !== 1) + return n3; + delete names[n3.str]; + return c; + } + function canOptimize(e3) { + return e3 instanceof code_1._Code && e3._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants[c.str] !== void 0); + } + } + function subtractNames(names, from) { + for (const n3 in from) + names[n3] = (names[n3] || 0) - (from[n3] || 0); + } + function not(x) { + return typeof x == "boolean" || typeof x == "number" || x === null ? !x : (0, code_1._)`!${par(x)}`; + } + exports.not = not; + var andCode = mappend(exports.operators.AND); + function and(...args) { + return args.reduce(andCode); + } + exports.and = and; + var orCode = mappend(exports.operators.OR); + function or(...args) { + return args.reduce(orCode); + } + exports.or = or; + function mappend(op) { + return (x, y6) => x === code_1.nil ? y6 : y6 === code_1.nil ? x : (0, code_1._)`${par(x)} ${op} ${par(y6)}`; + } + function par(x) { + return x instanceof code_1.Name ? x : (0, code_1._)`(${x})`; + } + } +}); + +// node_modules/ajv/dist/compile/util.js +var require_util = __commonJS({ + "node_modules/ajv/dist/compile/util.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.checkStrictMode = exports.getErrorPath = exports.Type = exports.useFunc = exports.setEvaluated = exports.evaluatedPropsToName = exports.mergeEvaluated = exports.eachItem = exports.unescapeJsonPointer = exports.escapeJsonPointer = exports.escapeFragment = exports.unescapeFragment = exports.schemaRefOrVal = exports.schemaHasRulesButRef = exports.schemaHasRules = exports.checkUnknownRules = exports.alwaysValidSchema = exports.toHash = void 0; + var codegen_1 = require_codegen(); + var code_1 = require_code(); + function toHash(arr) { + const hash2 = {}; + for (const item of arr) + hash2[item] = true; + return hash2; + } + exports.toHash = toHash; + function alwaysValidSchema(it, schema) { + if (typeof schema == "boolean") + return schema; + if (Object.keys(schema).length === 0) + return true; + checkUnknownRules(it, schema); + return !schemaHasRules(schema, it.self.RULES.all); + } + exports.alwaysValidSchema = alwaysValidSchema; + function checkUnknownRules(it, schema = it.schema) { + const { opts, self: self2 } = it; + if (!opts.strictSchema) + return; + if (typeof schema === "boolean") + return; + const rules = self2.RULES.keywords; + for (const key in schema) { + if (!rules[key]) + checkStrictMode(it, `unknown keyword: "${key}"`); + } + } + exports.checkUnknownRules = checkUnknownRules; + function schemaHasRules(schema, rules) { + if (typeof schema == "boolean") + return !schema; + for (const key in schema) + if (rules[key]) + return true; + return false; + } + exports.schemaHasRules = schemaHasRules; + function schemaHasRulesButRef(schema, RULES) { + if (typeof schema == "boolean") + return !schema; + for (const key in schema) + if (key !== "$ref" && RULES.all[key]) + return true; + return false; + } + exports.schemaHasRulesButRef = schemaHasRulesButRef; + function schemaRefOrVal({ topSchemaRef, schemaPath }, schema, keyword, $data) { + if (!$data) { + if (typeof schema == "number" || typeof schema == "boolean") + return schema; + if (typeof schema == "string") + return (0, codegen_1._)`${schema}`; + } + return (0, codegen_1._)`${topSchemaRef}${schemaPath}${(0, codegen_1.getProperty)(keyword)}`; + } + exports.schemaRefOrVal = schemaRefOrVal; + function unescapeFragment(str) { + return unescapeJsonPointer(decodeURIComponent(str)); + } + exports.unescapeFragment = unescapeFragment; + function escapeFragment(str) { + return encodeURIComponent(escapeJsonPointer(str)); + } + exports.escapeFragment = escapeFragment; + function escapeJsonPointer(str) { + if (typeof str == "number") + return `${str}`; + return str.replace(/~/g, "~0").replace(/\//g, "~1"); + } + exports.escapeJsonPointer = escapeJsonPointer; + function unescapeJsonPointer(str) { + return str.replace(/~1/g, "/").replace(/~0/g, "~"); + } + exports.unescapeJsonPointer = unescapeJsonPointer; + function eachItem(xs, f6) { + if (Array.isArray(xs)) { + for (const x of xs) + f6(x); + } else { + f6(xs); + } + } + exports.eachItem = eachItem; + function makeMergeEvaluated({ mergeNames, mergeToName, mergeValues: mergeValues3, resultToName }) { + return (gen, from, to, toName) => { + const res = to === void 0 ? from : to instanceof codegen_1.Name ? (from instanceof codegen_1.Name ? mergeNames(gen, from, to) : mergeToName(gen, from, to), to) : from instanceof codegen_1.Name ? (mergeToName(gen, to, from), from) : mergeValues3(from, to); + return toName === codegen_1.Name && !(res instanceof codegen_1.Name) ? resultToName(gen, res) : res; + }; + } + exports.mergeEvaluated = { + props: makeMergeEvaluated({ + mergeNames: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true && ${from} !== undefined`, () => { + gen.if((0, codegen_1._)`${from} === true`, () => gen.assign(to, true), () => gen.assign(to, (0, codegen_1._)`${to} || {}`).code((0, codegen_1._)`Object.assign(${to}, ${from})`)); + }), + mergeToName: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true`, () => { + if (from === true) { + gen.assign(to, true); + } else { + gen.assign(to, (0, codegen_1._)`${to} || {}`); + setEvaluated(gen, to, from); + } + }), + mergeValues: (from, to) => from === true ? true : { ...from, ...to }, + resultToName: evaluatedPropsToName + }), + items: makeMergeEvaluated({ + mergeNames: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true && ${from} !== undefined`, () => gen.assign(to, (0, codegen_1._)`${from} === true ? true : ${to} > ${from} ? ${to} : ${from}`)), + mergeToName: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true`, () => gen.assign(to, from === true ? true : (0, codegen_1._)`${to} > ${from} ? ${to} : ${from}`)), + mergeValues: (from, to) => from === true ? true : Math.max(from, to), + resultToName: (gen, items) => gen.var("items", items) + }) + }; + function evaluatedPropsToName(gen, ps) { + if (ps === true) + return gen.var("props", true); + const props = gen.var("props", (0, codegen_1._)`{}`); + if (ps !== void 0) + setEvaluated(gen, props, ps); + return props; + } + exports.evaluatedPropsToName = evaluatedPropsToName; + function setEvaluated(gen, props, ps) { + Object.keys(ps).forEach((p) => gen.assign((0, codegen_1._)`${props}${(0, codegen_1.getProperty)(p)}`, true)); + } + exports.setEvaluated = setEvaluated; + var snippets = {}; + function useFunc(gen, f6) { + return gen.scopeValue("func", { + ref: f6, + code: snippets[f6.code] || (snippets[f6.code] = new code_1._Code(f6.code)) + }); + } + exports.useFunc = useFunc; + var Type; + (function(Type2) { + Type2[Type2["Num"] = 0] = "Num"; + Type2[Type2["Str"] = 1] = "Str"; + })(Type || (exports.Type = Type = {})); + function getErrorPath(dataProp, dataPropType, jsPropertySyntax) { + if (dataProp instanceof codegen_1.Name) { + const isNumber = dataPropType === Type.Num; + return jsPropertySyntax ? isNumber ? (0, codegen_1._)`"[" + ${dataProp} + "]"` : (0, codegen_1._)`"['" + ${dataProp} + "']"` : isNumber ? (0, codegen_1._)`"/" + ${dataProp}` : (0, codegen_1._)`"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")`; + } + return jsPropertySyntax ? (0, codegen_1.getProperty)(dataProp).toString() : "/" + escapeJsonPointer(dataProp); + } + exports.getErrorPath = getErrorPath; + function checkStrictMode(it, msg, mode = it.opts.strictSchema) { + if (!mode) + return; + msg = `strict mode: ${msg}`; + if (mode === true) + throw new Error(msg); + it.self.logger.warn(msg); + } + exports.checkStrictMode = checkStrictMode; + } +}); + +// node_modules/ajv/dist/compile/names.js +var require_names = __commonJS({ + "node_modules/ajv/dist/compile/names.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var names = { + // validation function arguments + data: new codegen_1.Name("data"), + // data passed to validation function + // args passed from referencing schema + valCxt: new codegen_1.Name("valCxt"), + // validation/data context - should not be used directly, it is destructured to the names below + instancePath: new codegen_1.Name("instancePath"), + parentData: new codegen_1.Name("parentData"), + parentDataProperty: new codegen_1.Name("parentDataProperty"), + rootData: new codegen_1.Name("rootData"), + // root data - same as the data passed to the first/top validation function + dynamicAnchors: new codegen_1.Name("dynamicAnchors"), + // used to support recursiveRef and dynamicRef + // function scoped variables + vErrors: new codegen_1.Name("vErrors"), + // null or array of validation errors + errors: new codegen_1.Name("errors"), + // counter of validation errors + this: new codegen_1.Name("this"), + // "globals" + self: new codegen_1.Name("self"), + scope: new codegen_1.Name("scope"), + // JTD serialize/parse name for JSON string and position + json: new codegen_1.Name("json"), + jsonPos: new codegen_1.Name("jsonPos"), + jsonLen: new codegen_1.Name("jsonLen"), + jsonPart: new codegen_1.Name("jsonPart") + }; + exports.default = names; + } +}); + +// node_modules/ajv/dist/compile/errors.js +var require_errors = __commonJS({ + "node_modules/ajv/dist/compile/errors.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.extendErrors = exports.resetErrorsCount = exports.reportExtraError = exports.reportError = exports.keyword$DataError = exports.keywordError = void 0; + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var names_1 = require_names(); + exports.keywordError = { + message: ({ keyword }) => (0, codegen_1.str)`must pass "${keyword}" keyword validation` + }; + exports.keyword$DataError = { + message: ({ keyword, schemaType }) => schemaType ? (0, codegen_1.str)`"${keyword}" keyword must be ${schemaType} ($data)` : (0, codegen_1.str)`"${keyword}" keyword is invalid ($data)` + }; + function reportError(cxt, error48 = exports.keywordError, errorPaths, overrideAllErrors) { + const { it } = cxt; + const { gen, compositeRule, allErrors } = it; + const errObj = errorObjectCode(cxt, error48, errorPaths); + if (overrideAllErrors !== null && overrideAllErrors !== void 0 ? overrideAllErrors : compositeRule || allErrors) { + addError(gen, errObj); + } else { + returnErrors(it, (0, codegen_1._)`[${errObj}]`); + } + } + exports.reportError = reportError; + function reportExtraError(cxt, error48 = exports.keywordError, errorPaths) { + const { it } = cxt; + const { gen, compositeRule, allErrors } = it; + const errObj = errorObjectCode(cxt, error48, errorPaths); + addError(gen, errObj); + if (!(compositeRule || allErrors)) { + returnErrors(it, names_1.default.vErrors); + } + } + exports.reportExtraError = reportExtraError; + function resetErrorsCount(gen, errsCount) { + gen.assign(names_1.default.errors, errsCount); + gen.if((0, codegen_1._)`${names_1.default.vErrors} !== null`, () => gen.if(errsCount, () => gen.assign((0, codegen_1._)`${names_1.default.vErrors}.length`, errsCount), () => gen.assign(names_1.default.vErrors, null))); + } + exports.resetErrorsCount = resetErrorsCount; + function extendErrors({ gen, keyword, schemaValue, data, errsCount, it }) { + if (errsCount === void 0) + throw new Error("ajv implementation error"); + const err = gen.name("err"); + gen.forRange("i", errsCount, names_1.default.errors, (i3) => { + gen.const(err, (0, codegen_1._)`${names_1.default.vErrors}[${i3}]`); + gen.if((0, codegen_1._)`${err}.instancePath === undefined`, () => gen.assign((0, codegen_1._)`${err}.instancePath`, (0, codegen_1.strConcat)(names_1.default.instancePath, it.errorPath))); + gen.assign((0, codegen_1._)`${err}.schemaPath`, (0, codegen_1.str)`${it.errSchemaPath}/${keyword}`); + if (it.opts.verbose) { + gen.assign((0, codegen_1._)`${err}.schema`, schemaValue); + gen.assign((0, codegen_1._)`${err}.data`, data); + } + }); + } + exports.extendErrors = extendErrors; + function addError(gen, errObj) { + const err = gen.const("err", errObj); + gen.if((0, codegen_1._)`${names_1.default.vErrors} === null`, () => gen.assign(names_1.default.vErrors, (0, codegen_1._)`[${err}]`), (0, codegen_1._)`${names_1.default.vErrors}.push(${err})`); + gen.code((0, codegen_1._)`${names_1.default.errors}++`); + } + function returnErrors(it, errs) { + const { gen, validateName, schemaEnv } = it; + if (schemaEnv.$async) { + gen.throw((0, codegen_1._)`new ${it.ValidationError}(${errs})`); + } else { + gen.assign((0, codegen_1._)`${validateName}.errors`, errs); + gen.return(false); + } + } + var E2 = { + keyword: new codegen_1.Name("keyword"), + schemaPath: new codegen_1.Name("schemaPath"), + // also used in JTD errors + params: new codegen_1.Name("params"), + propertyName: new codegen_1.Name("propertyName"), + message: new codegen_1.Name("message"), + schema: new codegen_1.Name("schema"), + parentSchema: new codegen_1.Name("parentSchema") + }; + function errorObjectCode(cxt, error48, errorPaths) { + const { createErrors } = cxt.it; + if (createErrors === false) + return (0, codegen_1._)`{}`; + return errorObject(cxt, error48, errorPaths); + } + function errorObject(cxt, error48, errorPaths = {}) { + const { gen, it } = cxt; + const keyValues = [ + errorInstancePath(it, errorPaths), + errorSchemaPath(cxt, errorPaths) + ]; + extraErrorProps(cxt, error48, keyValues); + return gen.object(...keyValues); + } + function errorInstancePath({ errorPath }, { instancePath }) { + const instPath = instancePath ? (0, codegen_1.str)`${errorPath}${(0, util_1.getErrorPath)(instancePath, util_1.Type.Str)}` : errorPath; + return [names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, instPath)]; + } + function errorSchemaPath({ keyword, it: { errSchemaPath } }, { schemaPath, parentSchema }) { + let schPath = parentSchema ? errSchemaPath : (0, codegen_1.str)`${errSchemaPath}/${keyword}`; + if (schemaPath) { + schPath = (0, codegen_1.str)`${schPath}${(0, util_1.getErrorPath)(schemaPath, util_1.Type.Str)}`; + } + return [E2.schemaPath, schPath]; + } + function extraErrorProps(cxt, { params, message }, keyValues) { + const { keyword, data, schemaValue, it } = cxt; + const { opts, propertyName, topSchemaRef, schemaPath } = it; + keyValues.push([E2.keyword, keyword], [E2.params, typeof params == "function" ? params(cxt) : params || (0, codegen_1._)`{}`]); + if (opts.messages) { + keyValues.push([E2.message, typeof message == "function" ? message(cxt) : message]); + } + if (opts.verbose) { + keyValues.push([E2.schema, schemaValue], [E2.parentSchema, (0, codegen_1._)`${topSchemaRef}${schemaPath}`], [names_1.default.data, data]); + } + if (propertyName) + keyValues.push([E2.propertyName, propertyName]); + } + } +}); + +// node_modules/ajv/dist/compile/validate/boolSchema.js +var require_boolSchema = __commonJS({ + "node_modules/ajv/dist/compile/validate/boolSchema.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.boolOrEmptySchema = exports.topBoolOrEmptySchema = void 0; + var errors_1 = require_errors(); + var codegen_1 = require_codegen(); + var names_1 = require_names(); + var boolError = { + message: "boolean schema is false" + }; + function topBoolOrEmptySchema(it) { + const { gen, schema, validateName } = it; + if (schema === false) { + falseSchemaError(it, false); + } else if (typeof schema == "object" && schema.$async === true) { + gen.return(names_1.default.data); + } else { + gen.assign((0, codegen_1._)`${validateName}.errors`, null); + gen.return(true); + } + } + exports.topBoolOrEmptySchema = topBoolOrEmptySchema; + function boolOrEmptySchema(it, valid) { + const { gen, schema } = it; + if (schema === false) { + gen.var(valid, false); + falseSchemaError(it); + } else { + gen.var(valid, true); + } + } + exports.boolOrEmptySchema = boolOrEmptySchema; + function falseSchemaError(it, overrideAllErrors) { + const { gen, data } = it; + const cxt = { + gen, + keyword: "false schema", + data, + schema: false, + schemaCode: false, + schemaValue: false, + params: {}, + it + }; + (0, errors_1.reportError)(cxt, boolError, void 0, overrideAllErrors); + } + } +}); + +// node_modules/ajv/dist/compile/rules.js +var require_rules = __commonJS({ + "node_modules/ajv/dist/compile/rules.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.getRules = exports.isJSONType = void 0; + var _jsonTypes = ["string", "number", "integer", "boolean", "null", "object", "array"]; + var jsonTypes = new Set(_jsonTypes); + function isJSONType(x) { + return typeof x == "string" && jsonTypes.has(x); + } + exports.isJSONType = isJSONType; + function getRules() { + const groups = { + number: { type: "number", rules: [] }, + string: { type: "string", rules: [] }, + array: { type: "array", rules: [] }, + object: { type: "object", rules: [] } + }; + return { + types: { ...groups, integer: true, boolean: true, null: true }, + rules: [{ rules: [] }, groups.number, groups.string, groups.array, groups.object], + post: { rules: [] }, + all: {}, + keywords: {} + }; + } + exports.getRules = getRules; + } +}); + +// node_modules/ajv/dist/compile/validate/applicability.js +var require_applicability = __commonJS({ + "node_modules/ajv/dist/compile/validate/applicability.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.shouldUseRule = exports.shouldUseGroup = exports.schemaHasRulesForType = void 0; + function schemaHasRulesForType({ schema, self: self2 }, type) { + const group = self2.RULES.types[type]; + return group && group !== true && shouldUseGroup(schema, group); + } + exports.schemaHasRulesForType = schemaHasRulesForType; + function shouldUseGroup(schema, group) { + return group.rules.some((rule) => shouldUseRule(schema, rule)); + } + exports.shouldUseGroup = shouldUseGroup; + function shouldUseRule(schema, rule) { + var _a3; + return schema[rule.keyword] !== void 0 || ((_a3 = rule.definition.implements) === null || _a3 === void 0 ? void 0 : _a3.some((kwd) => schema[kwd] !== void 0)); + } + exports.shouldUseRule = shouldUseRule; + } +}); + +// node_modules/ajv/dist/compile/validate/dataType.js +var require_dataType = __commonJS({ + "node_modules/ajv/dist/compile/validate/dataType.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.reportTypeError = exports.checkDataTypes = exports.checkDataType = exports.coerceAndCheckDataType = exports.getJSONTypes = exports.getSchemaTypes = exports.DataType = void 0; + var rules_1 = require_rules(); + var applicability_1 = require_applicability(); + var errors_1 = require_errors(); + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var DataType; + (function(DataType2) { + DataType2[DataType2["Correct"] = 0] = "Correct"; + DataType2[DataType2["Wrong"] = 1] = "Wrong"; + })(DataType || (exports.DataType = DataType = {})); + function getSchemaTypes(schema) { + const types = getJSONTypes(schema.type); + const hasNull = types.includes("null"); + if (hasNull) { + if (schema.nullable === false) + throw new Error("type: null contradicts nullable: false"); + } else { + if (!types.length && schema.nullable !== void 0) { + throw new Error('"nullable" cannot be used without "type"'); + } + if (schema.nullable === true) + types.push("null"); + } + return types; + } + exports.getSchemaTypes = getSchemaTypes; + function getJSONTypes(ts) { + const types = Array.isArray(ts) ? ts : ts ? [ts] : []; + if (types.every(rules_1.isJSONType)) + return types; + throw new Error("type must be JSONType or JSONType[]: " + types.join(",")); + } + exports.getJSONTypes = getJSONTypes; + function coerceAndCheckDataType(it, types) { + const { gen, data, opts } = it; + const coerceTo = coerceToTypes(types, opts.coerceTypes); + const checkTypes = types.length > 0 && !(coerceTo.length === 0 && types.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types[0])); + if (checkTypes) { + const wrongType = checkDataTypes(types, data, opts.strictNumbers, DataType.Wrong); + gen.if(wrongType, () => { + if (coerceTo.length) + coerceData(it, types, coerceTo); + else + reportTypeError(it); + }); + } + return checkTypes; + } + exports.coerceAndCheckDataType = coerceAndCheckDataType; + var COERCIBLE = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "null"]); + function coerceToTypes(types, coerceTypes) { + return coerceTypes ? types.filter((t3) => COERCIBLE.has(t3) || coerceTypes === "array" && t3 === "array") : []; + } + function coerceData(it, types, coerceTo) { + const { gen, data, opts } = it; + const dataType = gen.let("dataType", (0, codegen_1._)`typeof ${data}`); + const coerced = gen.let("coerced", (0, codegen_1._)`undefined`); + if (opts.coerceTypes === "array") { + gen.if((0, codegen_1._)`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1._)`${data}[0]`).assign(dataType, (0, codegen_1._)`typeof ${data}`).if(checkDataTypes(types, data, opts.strictNumbers), () => gen.assign(coerced, data))); + } + gen.if((0, codegen_1._)`${coerced} !== undefined`); + for (const t3 of coerceTo) { + if (COERCIBLE.has(t3) || t3 === "array" && opts.coerceTypes === "array") { + coerceSpecificType(t3); + } + } + gen.else(); + reportTypeError(it); + gen.endIf(); + gen.if((0, codegen_1._)`${coerced} !== undefined`, () => { + gen.assign(data, coerced); + assignParentData(it, coerced); + }); + function coerceSpecificType(t3) { + switch (t3) { + case "string": + gen.elseIf((0, codegen_1._)`${dataType} == "number" || ${dataType} == "boolean"`).assign(coerced, (0, codegen_1._)`"" + ${data}`).elseIf((0, codegen_1._)`${data} === null`).assign(coerced, (0, codegen_1._)`""`); + return; + case "number": + gen.elseIf((0, codegen_1._)`${dataType} == "boolean" || ${data} === null + || (${dataType} == "string" && ${data} && ${data} == +${data})`).assign(coerced, (0, codegen_1._)`+${data}`); + return; + case "integer": + gen.elseIf((0, codegen_1._)`${dataType} === "boolean" || ${data} === null + || (${dataType} === "string" && ${data} && ${data} == +${data} && !(${data} % 1))`).assign(coerced, (0, codegen_1._)`+${data}`); + return; + case "boolean": + gen.elseIf((0, codegen_1._)`${data} === "false" || ${data} === 0 || ${data} === null`).assign(coerced, false).elseIf((0, codegen_1._)`${data} === "true" || ${data} === 1`).assign(coerced, true); + return; + case "null": + gen.elseIf((0, codegen_1._)`${data} === "" || ${data} === 0 || ${data} === false`); + gen.assign(coerced, null); + return; + case "array": + gen.elseIf((0, codegen_1._)`${dataType} === "string" || ${dataType} === "number" + || ${dataType} === "boolean" || ${data} === null`).assign(coerced, (0, codegen_1._)`[${data}]`); + } + } + } + function assignParentData({ gen, parentData, parentDataProperty }, expr) { + gen.if((0, codegen_1._)`${parentData} !== undefined`, () => gen.assign((0, codegen_1._)`${parentData}[${parentDataProperty}]`, expr)); + } + function checkDataType(dataType, data, strictNums, correct = DataType.Correct) { + const EQ = correct === DataType.Correct ? codegen_1.operators.EQ : codegen_1.operators.NEQ; + let cond; + switch (dataType) { + case "null": + return (0, codegen_1._)`${data} ${EQ} null`; + case "array": + cond = (0, codegen_1._)`Array.isArray(${data})`; + break; + case "object": + cond = (0, codegen_1._)`${data} && typeof ${data} == "object" && !Array.isArray(${data})`; + break; + case "integer": + cond = numCond((0, codegen_1._)`!(${data} % 1) && !isNaN(${data})`); + break; + case "number": + cond = numCond(); + break; + default: + return (0, codegen_1._)`typeof ${data} ${EQ} ${dataType}`; + } + return correct === DataType.Correct ? cond : (0, codegen_1.not)(cond); + function numCond(_cond = codegen_1.nil) { + return (0, codegen_1.and)((0, codegen_1._)`typeof ${data} == "number"`, _cond, strictNums ? (0, codegen_1._)`isFinite(${data})` : codegen_1.nil); + } + } + exports.checkDataType = checkDataType; + function checkDataTypes(dataTypes, data, strictNums, correct) { + if (dataTypes.length === 1) { + return checkDataType(dataTypes[0], data, strictNums, correct); + } + let cond; + const types = (0, util_1.toHash)(dataTypes); + if (types.array && types.object) { + const notObj = (0, codegen_1._)`typeof ${data} != "object"`; + cond = types.null ? notObj : (0, codegen_1._)`!${data} || ${notObj}`; + delete types.null; + delete types.array; + delete types.object; + } else { + cond = codegen_1.nil; + } + if (types.number) + delete types.integer; + for (const t3 in types) + cond = (0, codegen_1.and)(cond, checkDataType(t3, data, strictNums, correct)); + return cond; + } + exports.checkDataTypes = checkDataTypes; + var typeError = { + message: ({ schema }) => `must be ${schema}`, + params: ({ schema, schemaValue }) => typeof schema == "string" ? (0, codegen_1._)`{type: ${schema}}` : (0, codegen_1._)`{type: ${schemaValue}}` + }; + function reportTypeError(it) { + const cxt = getTypeErrorContext(it); + (0, errors_1.reportError)(cxt, typeError); + } + exports.reportTypeError = reportTypeError; + function getTypeErrorContext(it) { + const { gen, data, schema } = it; + const schemaCode = (0, util_1.schemaRefOrVal)(it, schema, "type"); + return { + gen, + keyword: "type", + data, + schema: schema.type, + schemaCode, + schemaValue: schemaCode, + parentSchema: schema, + params: {}, + it + }; + } + } +}); + +// node_modules/ajv/dist/compile/validate/defaults.js +var require_defaults = __commonJS({ + "node_modules/ajv/dist/compile/validate/defaults.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.assignDefaults = void 0; + var codegen_1 = require_codegen(); + var util_1 = require_util(); + function assignDefaults(it, ty) { + const { properties, items } = it.schema; + if (ty === "object" && properties) { + for (const key in properties) { + assignDefault(it, key, properties[key].default); + } + } else if (ty === "array" && Array.isArray(items)) { + items.forEach((sch, i3) => assignDefault(it, i3, sch.default)); + } + } + exports.assignDefaults = assignDefaults; + function assignDefault(it, prop, defaultValue) { + const { gen, compositeRule, data, opts } = it; + if (defaultValue === void 0) + return; + const childData = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(prop)}`; + if (compositeRule) { + (0, util_1.checkStrictMode)(it, `default is ignored for: ${childData}`); + return; + } + let condition = (0, codegen_1._)`${childData} === undefined`; + if (opts.useDefaults === "empty") { + condition = (0, codegen_1._)`${condition} || ${childData} === null || ${childData} === ""`; + } + gen.if(condition, (0, codegen_1._)`${childData} = ${(0, codegen_1.stringify)(defaultValue)}`); + } + } +}); + +// node_modules/ajv/dist/vocabularies/code.js +var require_code2 = __commonJS({ + "node_modules/ajv/dist/vocabularies/code.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.validateUnion = exports.validateArray = exports.usePattern = exports.callValidateCode = exports.schemaProperties = exports.allSchemaProperties = exports.noPropertyInData = exports.propertyInData = exports.isOwnProperty = exports.hasPropFunc = exports.reportMissingProp = exports.checkMissingProp = exports.checkReportMissingProp = void 0; + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var names_1 = require_names(); + var util_2 = require_util(); + function checkReportMissingProp(cxt, prop) { + const { gen, data, it } = cxt; + gen.if(noPropertyInData(gen, data, prop, it.opts.ownProperties), () => { + cxt.setParams({ missingProperty: (0, codegen_1._)`${prop}` }, true); + cxt.error(); + }); + } + exports.checkReportMissingProp = checkReportMissingProp; + function checkMissingProp({ gen, data, it: { opts } }, properties, missing) { + return (0, codegen_1.or)(...properties.map((prop) => (0, codegen_1.and)(noPropertyInData(gen, data, prop, opts.ownProperties), (0, codegen_1._)`${missing} = ${prop}`))); + } + exports.checkMissingProp = checkMissingProp; + function reportMissingProp(cxt, missing) { + cxt.setParams({ missingProperty: missing }, true); + cxt.error(); + } + exports.reportMissingProp = reportMissingProp; + function hasPropFunc(gen) { + return gen.scopeValue("func", { + // eslint-disable-next-line @typescript-eslint/unbound-method + ref: Object.prototype.hasOwnProperty, + code: (0, codegen_1._)`Object.prototype.hasOwnProperty` + }); + } + exports.hasPropFunc = hasPropFunc; + function isOwnProperty(gen, data, property) { + return (0, codegen_1._)`${hasPropFunc(gen)}.call(${data}, ${property})`; + } + exports.isOwnProperty = isOwnProperty; + function propertyInData(gen, data, property, ownProperties) { + const cond = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(property)} !== undefined`; + return ownProperties ? (0, codegen_1._)`${cond} && ${isOwnProperty(gen, data, property)}` : cond; + } + exports.propertyInData = propertyInData; + function noPropertyInData(gen, data, property, ownProperties) { + const cond = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(property)} === undefined`; + return ownProperties ? (0, codegen_1.or)(cond, (0, codegen_1.not)(isOwnProperty(gen, data, property))) : cond; + } + exports.noPropertyInData = noPropertyInData; + function allSchemaProperties(schemaMap) { + return schemaMap ? Object.keys(schemaMap).filter((p) => p !== "__proto__") : []; + } + exports.allSchemaProperties = allSchemaProperties; + function schemaProperties(it, schemaMap) { + return allSchemaProperties(schemaMap).filter((p) => !(0, util_1.alwaysValidSchema)(it, schemaMap[p])); + } + exports.schemaProperties = schemaProperties; + function callValidateCode({ schemaCode, data, it: { gen, topSchemaRef, schemaPath, errorPath }, it }, func, context, passSchema) { + const dataAndSchema = passSchema ? (0, codegen_1._)`${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}` : data; + const valCxt = [ + [names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, errorPath)], + [names_1.default.parentData, it.parentData], + [names_1.default.parentDataProperty, it.parentDataProperty], + [names_1.default.rootData, names_1.default.rootData] + ]; + if (it.opts.dynamicRef) + valCxt.push([names_1.default.dynamicAnchors, names_1.default.dynamicAnchors]); + const args = (0, codegen_1._)`${dataAndSchema}, ${gen.object(...valCxt)}`; + return context !== codegen_1.nil ? (0, codegen_1._)`${func}.call(${context}, ${args})` : (0, codegen_1._)`${func}(${args})`; + } + exports.callValidateCode = callValidateCode; + var newRegExp = (0, codegen_1._)`new RegExp`; + function usePattern({ gen, it: { opts } }, pattern) { + const u = opts.unicodeRegExp ? "u" : ""; + const { regExp } = opts.code; + const rx = regExp(pattern, u); + return gen.scopeValue("pattern", { + key: rx.toString(), + ref: rx, + code: (0, codegen_1._)`${regExp.code === "new RegExp" ? newRegExp : (0, util_2.useFunc)(gen, regExp)}(${pattern}, ${u})` + }); + } + exports.usePattern = usePattern; + function validateArray(cxt) { + const { gen, data, keyword, it } = cxt; + const valid = gen.name("valid"); + if (it.allErrors) { + const validArr = gen.let("valid", true); + validateItems(() => gen.assign(validArr, false)); + return validArr; + } + gen.var(valid, true); + validateItems(() => gen.break()); + return valid; + function validateItems(notValid) { + const len = gen.const("len", (0, codegen_1._)`${data}.length`); + gen.forRange("i", 0, len, (i3) => { + cxt.subschema({ + keyword, + dataProp: i3, + dataPropType: util_1.Type.Num + }, valid); + gen.if((0, codegen_1.not)(valid), notValid); + }); + } + } + exports.validateArray = validateArray; + function validateUnion(cxt) { + const { gen, schema, keyword, it } = cxt; + if (!Array.isArray(schema)) + throw new Error("ajv implementation error"); + const alwaysValid = schema.some((sch) => (0, util_1.alwaysValidSchema)(it, sch)); + if (alwaysValid && !it.opts.unevaluated) + return; + const valid = gen.let("valid", false); + const schValid = gen.name("_valid"); + gen.block(() => schema.forEach((_sch, i3) => { + const schCxt = cxt.subschema({ + keyword, + schemaProp: i3, + compositeRule: true + }, schValid); + gen.assign(valid, (0, codegen_1._)`${valid} || ${schValid}`); + const merged = cxt.mergeValidEvaluated(schCxt, schValid); + if (!merged) + gen.if((0, codegen_1.not)(valid)); + })); + cxt.result(valid, () => cxt.reset(), () => cxt.error(true)); + } + exports.validateUnion = validateUnion; + } +}); + +// node_modules/ajv/dist/compile/validate/keyword.js +var require_keyword = __commonJS({ + "node_modules/ajv/dist/compile/validate/keyword.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.validateKeywordUsage = exports.validSchemaType = exports.funcKeywordCode = exports.macroKeywordCode = void 0; + var codegen_1 = require_codegen(); + var names_1 = require_names(); + var code_1 = require_code2(); + var errors_1 = require_errors(); + function macroKeywordCode(cxt, def) { + const { gen, keyword, schema, parentSchema, it } = cxt; + const macroSchema = def.macro.call(it.self, schema, parentSchema, it); + const schemaRef = useKeyword(gen, keyword, macroSchema); + if (it.opts.validateSchema !== false) + it.self.validateSchema(macroSchema, true); + const valid = gen.name("valid"); + cxt.subschema({ + schema: macroSchema, + schemaPath: codegen_1.nil, + errSchemaPath: `${it.errSchemaPath}/${keyword}`, + topSchemaRef: schemaRef, + compositeRule: true + }, valid); + cxt.pass(valid, () => cxt.error(true)); + } + exports.macroKeywordCode = macroKeywordCode; + function funcKeywordCode(cxt, def) { + var _a3; + const { gen, keyword, schema, parentSchema, $data, it } = cxt; + checkAsyncKeyword(it, def); + const validate = !$data && def.compile ? def.compile.call(it.self, schema, parentSchema, it) : def.validate; + const validateRef = useKeyword(gen, keyword, validate); + const valid = gen.let("valid"); + cxt.block$data(valid, validateKeyword); + cxt.ok((_a3 = def.valid) !== null && _a3 !== void 0 ? _a3 : valid); + function validateKeyword() { + if (def.errors === false) { + assignValid(); + if (def.modifying) + modifyData(cxt); + reportErrs(() => cxt.error()); + } else { + const ruleErrs = def.async ? validateAsync() : validateSync(); + if (def.modifying) + modifyData(cxt); + reportErrs(() => addErrs(cxt, ruleErrs)); + } + } + function validateAsync() { + const ruleErrs = gen.let("ruleErrs", null); + gen.try(() => assignValid((0, codegen_1._)`await `), (e3) => gen.assign(valid, false).if((0, codegen_1._)`${e3} instanceof ${it.ValidationError}`, () => gen.assign(ruleErrs, (0, codegen_1._)`${e3}.errors`), () => gen.throw(e3))); + return ruleErrs; + } + function validateSync() { + const validateErrs = (0, codegen_1._)`${validateRef}.errors`; + gen.assign(validateErrs, null); + assignValid(codegen_1.nil); + return validateErrs; + } + function assignValid(_await = def.async ? (0, codegen_1._)`await ` : codegen_1.nil) { + const passCxt = it.opts.passContext ? names_1.default.this : names_1.default.self; + const passSchema = !("compile" in def && !$data || def.schema === false); + gen.assign(valid, (0, codegen_1._)`${_await}${(0, code_1.callValidateCode)(cxt, validateRef, passCxt, passSchema)}`, def.modifying); + } + function reportErrs(errors) { + var _a4; + gen.if((0, codegen_1.not)((_a4 = def.valid) !== null && _a4 !== void 0 ? _a4 : valid), errors); + } + } + exports.funcKeywordCode = funcKeywordCode; + function modifyData(cxt) { + const { gen, data, it } = cxt; + gen.if(it.parentData, () => gen.assign(data, (0, codegen_1._)`${it.parentData}[${it.parentDataProperty}]`)); + } + function addErrs(cxt, errs) { + const { gen } = cxt; + gen.if((0, codegen_1._)`Array.isArray(${errs})`, () => { + gen.assign(names_1.default.vErrors, (0, codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`).assign(names_1.default.errors, (0, codegen_1._)`${names_1.default.vErrors}.length`); + (0, errors_1.extendErrors)(cxt); + }, () => cxt.error()); + } + function checkAsyncKeyword({ schemaEnv }, def) { + if (def.async && !schemaEnv.$async) + throw new Error("async keyword in sync schema"); + } + function useKeyword(gen, keyword, result) { + if (result === void 0) + throw new Error(`keyword "${keyword}" failed to compile`); + return gen.scopeValue("keyword", typeof result == "function" ? { ref: result } : { ref: result, code: (0, codegen_1.stringify)(result) }); + } + function validSchemaType(schema, schemaType, allowUndefined = false) { + return !schemaType.length || schemaType.some((st) => st === "array" ? Array.isArray(schema) : st === "object" ? schema && typeof schema == "object" && !Array.isArray(schema) : typeof schema == st || allowUndefined && typeof schema == "undefined"); + } + exports.validSchemaType = validSchemaType; + function validateKeywordUsage({ schema, opts, self: self2, errSchemaPath }, def, keyword) { + if (Array.isArray(def.keyword) ? !def.keyword.includes(keyword) : def.keyword !== keyword) { + throw new Error("ajv implementation error"); + } + const deps = def.dependencies; + if (deps === null || deps === void 0 ? void 0 : deps.some((kwd) => !Object.prototype.hasOwnProperty.call(schema, kwd))) { + throw new Error(`parent schema must have dependencies of ${keyword}: ${deps.join(",")}`); + } + if (def.validateSchema) { + const valid = def.validateSchema(schema[keyword]); + if (!valid) { + const msg = `keyword "${keyword}" value is invalid at path "${errSchemaPath}": ` + self2.errorsText(def.validateSchema.errors); + if (opts.validateSchema === "log") + self2.logger.error(msg); + else + throw new Error(msg); + } + } + } + exports.validateKeywordUsage = validateKeywordUsage; + } +}); + +// node_modules/ajv/dist/compile/validate/subschema.js +var require_subschema = __commonJS({ + "node_modules/ajv/dist/compile/validate/subschema.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.extendSubschemaMode = exports.extendSubschemaData = exports.getSubschema = void 0; + var codegen_1 = require_codegen(); + var util_1 = require_util(); + function getSubschema(it, { keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef }) { + if (keyword !== void 0 && schema !== void 0) { + throw new Error('both "keyword" and "schema" passed, only one allowed'); + } + if (keyword !== void 0) { + const sch = it.schema[keyword]; + return schemaProp === void 0 ? { + schema: sch, + schemaPath: (0, codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}`, + errSchemaPath: `${it.errSchemaPath}/${keyword}` + } : { + schema: sch[schemaProp], + schemaPath: (0, codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}${(0, codegen_1.getProperty)(schemaProp)}`, + errSchemaPath: `${it.errSchemaPath}/${keyword}/${(0, util_1.escapeFragment)(schemaProp)}` + }; + } + if (schema !== void 0) { + if (schemaPath === void 0 || errSchemaPath === void 0 || topSchemaRef === void 0) { + throw new Error('"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"'); + } + return { + schema, + schemaPath, + topSchemaRef, + errSchemaPath + }; + } + throw new Error('either "keyword" or "schema" must be passed'); + } + exports.getSubschema = getSubschema; + function extendSubschemaData(subschema, it, { dataProp, dataPropType: dpType, data, dataTypes, propertyName }) { + if (data !== void 0 && dataProp !== void 0) { + throw new Error('both "data" and "dataProp" passed, only one allowed'); + } + const { gen } = it; + if (dataProp !== void 0) { + const { errorPath, dataPathArr, opts } = it; + const nextData = gen.let("data", (0, codegen_1._)`${it.data}${(0, codegen_1.getProperty)(dataProp)}`, true); + dataContextProps(nextData); + subschema.errorPath = (0, codegen_1.str)`${errorPath}${(0, util_1.getErrorPath)(dataProp, dpType, opts.jsPropertySyntax)}`; + subschema.parentDataProperty = (0, codegen_1._)`${dataProp}`; + subschema.dataPathArr = [...dataPathArr, subschema.parentDataProperty]; + } + if (data !== void 0) { + const nextData = data instanceof codegen_1.Name ? data : gen.let("data", data, true); + dataContextProps(nextData); + if (propertyName !== void 0) + subschema.propertyName = propertyName; + } + if (dataTypes) + subschema.dataTypes = dataTypes; + function dataContextProps(_nextData) { + subschema.data = _nextData; + subschema.dataLevel = it.dataLevel + 1; + subschema.dataTypes = []; + it.definedProperties = /* @__PURE__ */ new Set(); + subschema.parentData = it.data; + subschema.dataNames = [...it.dataNames, _nextData]; + } + } + exports.extendSubschemaData = extendSubschemaData; + function extendSubschemaMode(subschema, { jtdDiscriminator, jtdMetadata, compositeRule, createErrors, allErrors }) { + if (compositeRule !== void 0) + subschema.compositeRule = compositeRule; + if (createErrors !== void 0) + subschema.createErrors = createErrors; + if (allErrors !== void 0) + subschema.allErrors = allErrors; + subschema.jtdDiscriminator = jtdDiscriminator; + subschema.jtdMetadata = jtdMetadata; + } + exports.extendSubschemaMode = extendSubschemaMode; + } +}); + +// node_modules/fast-deep-equal/index.js +var require_fast_deep_equal = __commonJS({ + "node_modules/fast-deep-equal/index.js"(exports, module2) { + "use strict"; + module2.exports = function equal(a3, b) { + if (a3 === b) return true; + if (a3 && b && typeof a3 == "object" && typeof b == "object") { + if (a3.constructor !== b.constructor) return false; + var length, i3, keys; + if (Array.isArray(a3)) { + length = a3.length; + if (length != b.length) return false; + for (i3 = length; i3-- !== 0; ) + if (!equal(a3[i3], b[i3])) return false; + return true; + } + if (a3.constructor === RegExp) return a3.source === b.source && a3.flags === b.flags; + if (a3.valueOf !== Object.prototype.valueOf) return a3.valueOf() === b.valueOf(); + if (a3.toString !== Object.prototype.toString) return a3.toString() === b.toString(); + keys = Object.keys(a3); + length = keys.length; + if (length !== Object.keys(b).length) return false; + for (i3 = length; i3-- !== 0; ) + if (!Object.prototype.hasOwnProperty.call(b, keys[i3])) return false; + for (i3 = length; i3-- !== 0; ) { + var key = keys[i3]; + if (!equal(a3[key], b[key])) return false; + } + return true; + } + return a3 !== a3 && b !== b; + }; + } +}); + +// node_modules/json-schema-traverse/index.js +var require_json_schema_traverse = __commonJS({ + "node_modules/json-schema-traverse/index.js"(exports, module2) { + "use strict"; + var traverse = module2.exports = function(schema, opts, cb2) { + if (typeof opts == "function") { + cb2 = opts; + opts = {}; + } + cb2 = opts.cb || cb2; + var pre = typeof cb2 == "function" ? cb2 : cb2.pre || function() { + }; + var post = cb2.post || function() { + }; + _traverse(opts, pre, post, schema, "", schema); + }; + traverse.keywords = { + additionalItems: true, + items: true, + contains: true, + additionalProperties: true, + propertyNames: true, + not: true, + if: true, + then: true, + else: true + }; + traverse.arrayKeywords = { + items: true, + allOf: true, + anyOf: true, + oneOf: true + }; + traverse.propsKeywords = { + $defs: true, + definitions: true, + properties: true, + patternProperties: true, + dependencies: true + }; + traverse.skipKeywords = { + default: true, + enum: true, + const: true, + required: true, + maximum: true, + minimum: true, + exclusiveMaximum: true, + exclusiveMinimum: true, + multipleOf: true, + maxLength: true, + minLength: true, + pattern: true, + format: true, + maxItems: true, + minItems: true, + uniqueItems: true, + maxProperties: true, + minProperties: true + }; + function _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) { + if (schema && typeof schema == "object" && !Array.isArray(schema)) { + pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex); + for (var key in schema) { + var sch = schema[key]; + if (Array.isArray(sch)) { + if (key in traverse.arrayKeywords) { + for (var i3 = 0; i3 < sch.length; i3++) + _traverse(opts, pre, post, sch[i3], jsonPtr + "/" + key + "/" + i3, rootSchema, jsonPtr, key, schema, i3); + } + } else if (key in traverse.propsKeywords) { + if (sch && typeof sch == "object") { + for (var prop in sch) + _traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop); + } + } else if (key in traverse.keywords || opts.allKeys && !(key in traverse.skipKeywords)) { + _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema); + } + } + post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex); + } + } + function escapeJsonPtr(str) { + return str.replace(/~/g, "~0").replace(/\//g, "~1"); + } + } +}); + +// node_modules/ajv/dist/compile/resolve.js +var require_resolve = __commonJS({ + "node_modules/ajv/dist/compile/resolve.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.getSchemaRefs = exports.resolveUrl = exports.normalizeId = exports._getFullPath = exports.getFullPath = exports.inlineRef = void 0; + var util_1 = require_util(); + var equal = require_fast_deep_equal(); + var traverse = require_json_schema_traverse(); + var SIMPLE_INLINED = /* @__PURE__ */ new Set([ + "type", + "format", + "pattern", + "maxLength", + "minLength", + "maxProperties", + "minProperties", + "maxItems", + "minItems", + "maximum", + "minimum", + "uniqueItems", + "multipleOf", + "required", + "enum", + "const" + ]); + function inlineRef(schema, limit = true) { + if (typeof schema == "boolean") + return true; + if (limit === true) + return !hasRef(schema); + if (!limit) + return false; + return countKeys(schema) <= limit; + } + exports.inlineRef = inlineRef; + var REF_KEYWORDS = /* @__PURE__ */ new Set([ + "$ref", + "$recursiveRef", + "$recursiveAnchor", + "$dynamicRef", + "$dynamicAnchor" + ]); + function hasRef(schema) { + for (const key in schema) { + if (REF_KEYWORDS.has(key)) + return true; + const sch = schema[key]; + if (Array.isArray(sch) && sch.some(hasRef)) + return true; + if (typeof sch == "object" && hasRef(sch)) + return true; + } + return false; + } + function countKeys(schema) { + let count = 0; + for (const key in schema) { + if (key === "$ref") + return Infinity; + count++; + if (SIMPLE_INLINED.has(key)) + continue; + if (typeof schema[key] == "object") { + (0, util_1.eachItem)(schema[key], (sch) => count += countKeys(sch)); + } + if (count === Infinity) + return Infinity; + } + return count; + } + function getFullPath(resolver, id = "", normalize3) { + if (normalize3 !== false) + id = normalizeId(id); + const p = resolver.parse(id); + return _getFullPath(resolver, p); + } + exports.getFullPath = getFullPath; + function _getFullPath(resolver, p) { + const serialized = resolver.serialize(p); + return serialized.split("#")[0] + "#"; + } + exports._getFullPath = _getFullPath; + var TRAILING_SLASH_HASH = /#\/?$/; + function normalizeId(id) { + return id ? id.replace(TRAILING_SLASH_HASH, "") : ""; + } + exports.normalizeId = normalizeId; + function resolveUrl(resolver, baseId, id) { + id = normalizeId(id); + return resolver.resolve(baseId, id); + } + exports.resolveUrl = resolveUrl; + var ANCHOR = /^[a-z_][-a-z0-9._]*$/i; + function getSchemaRefs(schema, baseId) { + if (typeof schema == "boolean") + return {}; + const { schemaId, uriResolver } = this.opts; + const schId = normalizeId(schema[schemaId] || baseId); + const baseIds = { "": schId }; + const pathPrefix = getFullPath(uriResolver, schId, false); + const localRefs = {}; + const schemaRefs = /* @__PURE__ */ new Set(); + traverse(schema, { allKeys: true }, (sch, jsonPtr, _3, parentJsonPtr) => { + if (parentJsonPtr === void 0) + return; + const fullPath = pathPrefix + jsonPtr; + let innerBaseId = baseIds[parentJsonPtr]; + if (typeof sch[schemaId] == "string") + innerBaseId = addRef.call(this, sch[schemaId]); + addAnchor.call(this, sch.$anchor); + addAnchor.call(this, sch.$dynamicAnchor); + baseIds[jsonPtr] = innerBaseId; + function addRef(ref) { + const _resolve = this.opts.uriResolver.resolve; + ref = normalizeId(innerBaseId ? _resolve(innerBaseId, ref) : ref); + if (schemaRefs.has(ref)) + throw ambiguos(ref); + schemaRefs.add(ref); + let schOrRef = this.refs[ref]; + if (typeof schOrRef == "string") + schOrRef = this.refs[schOrRef]; + if (typeof schOrRef == "object") { + checkAmbiguosRef(sch, schOrRef.schema, ref); + } else if (ref !== normalizeId(fullPath)) { + if (ref[0] === "#") { + checkAmbiguosRef(sch, localRefs[ref], ref); + localRefs[ref] = sch; + } else { + this.refs[ref] = fullPath; + } + } + return ref; + } + function addAnchor(anchor) { + if (typeof anchor == "string") { + if (!ANCHOR.test(anchor)) + throw new Error(`invalid anchor "${anchor}"`); + addRef.call(this, `#${anchor}`); + } + } + }); + return localRefs; + function checkAmbiguosRef(sch1, sch2, ref) { + if (sch2 !== void 0 && !equal(sch1, sch2)) + throw ambiguos(ref); + } + function ambiguos(ref) { + return new Error(`reference "${ref}" resolves to more than one schema`); + } + } + exports.getSchemaRefs = getSchemaRefs; + } +}); + +// node_modules/ajv/dist/compile/validate/index.js +var require_validate = __commonJS({ + "node_modules/ajv/dist/compile/validate/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.getData = exports.KeywordCxt = exports.validateFunctionCode = void 0; + var boolSchema_1 = require_boolSchema(); + var dataType_1 = require_dataType(); + var applicability_1 = require_applicability(); + var dataType_2 = require_dataType(); + var defaults_1 = require_defaults(); + var keyword_1 = require_keyword(); + var subschema_1 = require_subschema(); + var codegen_1 = require_codegen(); + var names_1 = require_names(); + var resolve_1 = require_resolve(); + var util_1 = require_util(); + var errors_1 = require_errors(); + function validateFunctionCode(it) { + if (isSchemaObj(it)) { + checkKeywords(it); + if (schemaCxtHasRules(it)) { + topSchemaObjCode(it); + return; + } + } + validateFunction(it, () => (0, boolSchema_1.topBoolOrEmptySchema)(it)); + } + exports.validateFunctionCode = validateFunctionCode; + function validateFunction({ gen, validateName, schema, schemaEnv, opts }, body) { + if (opts.code.es5) { + gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${names_1.default.valCxt}`, schemaEnv.$async, () => { + gen.code((0, codegen_1._)`"use strict"; ${funcSourceUrl(schema, opts)}`); + destructureValCxtES5(gen, opts); + gen.code(body); + }); + } else { + gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema, opts)).code(body)); + } + } + function destructureValCxt(opts) { + return (0, codegen_1._)`{${names_1.default.instancePath}="", ${names_1.default.parentData}, ${names_1.default.parentDataProperty}, ${names_1.default.rootData}=${names_1.default.data}${opts.dynamicRef ? (0, codegen_1._)`, ${names_1.default.dynamicAnchors}={}` : codegen_1.nil}}={}`; + } + function destructureValCxtES5(gen, opts) { + gen.if(names_1.default.valCxt, () => { + gen.var(names_1.default.instancePath, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.instancePath}`); + gen.var(names_1.default.parentData, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.parentData}`); + gen.var(names_1.default.parentDataProperty, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.parentDataProperty}`); + gen.var(names_1.default.rootData, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.rootData}`); + if (opts.dynamicRef) + gen.var(names_1.default.dynamicAnchors, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.dynamicAnchors}`); + }, () => { + gen.var(names_1.default.instancePath, (0, codegen_1._)`""`); + gen.var(names_1.default.parentData, (0, codegen_1._)`undefined`); + gen.var(names_1.default.parentDataProperty, (0, codegen_1._)`undefined`); + gen.var(names_1.default.rootData, names_1.default.data); + if (opts.dynamicRef) + gen.var(names_1.default.dynamicAnchors, (0, codegen_1._)`{}`); + }); + } + function topSchemaObjCode(it) { + const { schema, opts, gen } = it; + validateFunction(it, () => { + if (opts.$comment && schema.$comment) + commentKeyword(it); + checkNoDefault(it); + gen.let(names_1.default.vErrors, null); + gen.let(names_1.default.errors, 0); + if (opts.unevaluated) + resetEvaluated(it); + typeAndKeywords(it); + returnResults(it); + }); + return; + } + function resetEvaluated(it) { + const { gen, validateName } = it; + it.evaluated = gen.const("evaluated", (0, codegen_1._)`${validateName}.evaluated`); + gen.if((0, codegen_1._)`${it.evaluated}.dynamicProps`, () => gen.assign((0, codegen_1._)`${it.evaluated}.props`, (0, codegen_1._)`undefined`)); + gen.if((0, codegen_1._)`${it.evaluated}.dynamicItems`, () => gen.assign((0, codegen_1._)`${it.evaluated}.items`, (0, codegen_1._)`undefined`)); + } + function funcSourceUrl(schema, opts) { + const schId = typeof schema == "object" && schema[opts.schemaId]; + return schId && (opts.code.source || opts.code.process) ? (0, codegen_1._)`/*# sourceURL=${schId} */` : codegen_1.nil; + } + function subschemaCode(it, valid) { + if (isSchemaObj(it)) { + checkKeywords(it); + if (schemaCxtHasRules(it)) { + subSchemaObjCode(it, valid); + return; + } + } + (0, boolSchema_1.boolOrEmptySchema)(it, valid); + } + function schemaCxtHasRules({ schema, self: self2 }) { + if (typeof schema == "boolean") + return !schema; + for (const key in schema) + if (self2.RULES.all[key]) + return true; + return false; + } + function isSchemaObj(it) { + return typeof it.schema != "boolean"; + } + function subSchemaObjCode(it, valid) { + const { schema, gen, opts } = it; + if (opts.$comment && schema.$comment) + commentKeyword(it); + updateContext(it); + checkAsyncSchema(it); + const errsCount = gen.const("_errs", names_1.default.errors); + typeAndKeywords(it, errsCount); + gen.var(valid, (0, codegen_1._)`${errsCount} === ${names_1.default.errors}`); + } + function checkKeywords(it) { + (0, util_1.checkUnknownRules)(it); + checkRefsAndKeywords(it); + } + function typeAndKeywords(it, errsCount) { + if (it.opts.jtd) + return schemaKeywords(it, [], false, errsCount); + const types = (0, dataType_1.getSchemaTypes)(it.schema); + const checkedTypes = (0, dataType_1.coerceAndCheckDataType)(it, types); + schemaKeywords(it, types, !checkedTypes, errsCount); + } + function checkRefsAndKeywords(it) { + const { schema, errSchemaPath, opts, self: self2 } = it; + if (schema.$ref && opts.ignoreKeywordsWithRef && (0, util_1.schemaHasRulesButRef)(schema, self2.RULES)) { + self2.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`); + } + } + function checkNoDefault(it) { + const { schema, opts } = it; + if (schema.default !== void 0 && opts.useDefaults && opts.strictSchema) { + (0, util_1.checkStrictMode)(it, "default is ignored in the schema root"); + } + } + function updateContext(it) { + const schId = it.schema[it.opts.schemaId]; + if (schId) + it.baseId = (0, resolve_1.resolveUrl)(it.opts.uriResolver, it.baseId, schId); + } + function checkAsyncSchema(it) { + if (it.schema.$async && !it.schemaEnv.$async) + throw new Error("async schema in sync schema"); + } + function commentKeyword({ gen, schemaEnv, schema, errSchemaPath, opts }) { + const msg = schema.$comment; + if (opts.$comment === true) { + gen.code((0, codegen_1._)`${names_1.default.self}.logger.log(${msg})`); + } else if (typeof opts.$comment == "function") { + const schemaPath = (0, codegen_1.str)`${errSchemaPath}/$comment`; + const rootName = gen.scopeValue("root", { ref: schemaEnv.root }); + gen.code((0, codegen_1._)`${names_1.default.self}.opts.$comment(${msg}, ${schemaPath}, ${rootName}.schema)`); + } + } + function returnResults(it) { + const { gen, schemaEnv, validateName, ValidationError, opts } = it; + if (schemaEnv.$async) { + gen.if((0, codegen_1._)`${names_1.default.errors} === 0`, () => gen.return(names_1.default.data), () => gen.throw((0, codegen_1._)`new ${ValidationError}(${names_1.default.vErrors})`)); + } else { + gen.assign((0, codegen_1._)`${validateName}.errors`, names_1.default.vErrors); + if (opts.unevaluated) + assignEvaluated(it); + gen.return((0, codegen_1._)`${names_1.default.errors} === 0`); + } + } + function assignEvaluated({ gen, evaluated, props, items }) { + if (props instanceof codegen_1.Name) + gen.assign((0, codegen_1._)`${evaluated}.props`, props); + if (items instanceof codegen_1.Name) + gen.assign((0, codegen_1._)`${evaluated}.items`, items); + } + function schemaKeywords(it, types, typeErrors, errsCount) { + const { gen, schema, data, allErrors, opts, self: self2 } = it; + const { RULES } = self2; + if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema, RULES))) { + gen.block(() => keywordCode(it, "$ref", RULES.all.$ref.definition)); + return; + } + if (!opts.jtd) + checkStrictTypes(it, types); + gen.block(() => { + for (const group of RULES.rules) + groupKeywords(group); + groupKeywords(RULES.post); + }); + function groupKeywords(group) { + if (!(0, applicability_1.shouldUseGroup)(schema, group)) + return; + if (group.type) { + gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers)); + iterateKeywords(it, group); + if (types.length === 1 && types[0] === group.type && typeErrors) { + gen.else(); + (0, dataType_2.reportTypeError)(it); + } + gen.endIf(); + } else { + iterateKeywords(it, group); + } + if (!allErrors) + gen.if((0, codegen_1._)`${names_1.default.errors} === ${errsCount || 0}`); + } + } + function iterateKeywords(it, group) { + const { gen, schema, opts: { useDefaults } } = it; + if (useDefaults) + (0, defaults_1.assignDefaults)(it, group.type); + gen.block(() => { + for (const rule of group.rules) { + if ((0, applicability_1.shouldUseRule)(schema, rule)) { + keywordCode(it, rule.keyword, rule.definition, group.type); + } + } + }); + } + function checkStrictTypes(it, types) { + if (it.schemaEnv.meta || !it.opts.strictTypes) + return; + checkContextTypes(it, types); + if (!it.opts.allowUnionTypes) + checkMultipleTypes(it, types); + checkKeywordTypes(it, it.dataTypes); + } + function checkContextTypes(it, types) { + if (!types.length) + return; + if (!it.dataTypes.length) { + it.dataTypes = types; + return; + } + types.forEach((t3) => { + if (!includesType(it.dataTypes, t3)) { + strictTypesError(it, `type "${t3}" not allowed by context "${it.dataTypes.join(",")}"`); + } + }); + narrowSchemaTypes(it, types); + } + function checkMultipleTypes(it, ts) { + if (ts.length > 1 && !(ts.length === 2 && ts.includes("null"))) { + strictTypesError(it, "use allowUnionTypes to allow union type keyword"); + } + } + function checkKeywordTypes(it, ts) { + const rules = it.self.RULES.all; + for (const keyword in rules) { + const rule = rules[keyword]; + if (typeof rule == "object" && (0, applicability_1.shouldUseRule)(it.schema, rule)) { + const { type } = rule.definition; + if (type.length && !type.some((t3) => hasApplicableType(ts, t3))) { + strictTypesError(it, `missing type "${type.join(",")}" for keyword "${keyword}"`); + } + } + } + } + function hasApplicableType(schTs, kwdT) { + return schTs.includes(kwdT) || kwdT === "number" && schTs.includes("integer"); + } + function includesType(ts, t3) { + return ts.includes(t3) || t3 === "integer" && ts.includes("number"); + } + function narrowSchemaTypes(it, withTypes) { + const ts = []; + for (const t3 of it.dataTypes) { + if (includesType(withTypes, t3)) + ts.push(t3); + else if (withTypes.includes("integer") && t3 === "number") + ts.push("integer"); + } + it.dataTypes = ts; + } + function strictTypesError(it, msg) { + const schemaPath = it.schemaEnv.baseId + it.errSchemaPath; + msg += ` at "${schemaPath}" (strictTypes)`; + (0, util_1.checkStrictMode)(it, msg, it.opts.strictTypes); + } + var KeywordCxt = class { + constructor(it, def, keyword) { + (0, keyword_1.validateKeywordUsage)(it, def, keyword); + this.gen = it.gen; + this.allErrors = it.allErrors; + this.keyword = keyword; + this.data = it.data; + this.schema = it.schema[keyword]; + this.$data = def.$data && it.opts.$data && this.schema && this.schema.$data; + this.schemaValue = (0, util_1.schemaRefOrVal)(it, this.schema, keyword, this.$data); + this.schemaType = def.schemaType; + this.parentSchema = it.schema; + this.params = {}; + this.it = it; + this.def = def; + if (this.$data) { + this.schemaCode = it.gen.const("vSchema", getData(this.$data, it)); + } else { + this.schemaCode = this.schemaValue; + if (!(0, keyword_1.validSchemaType)(this.schema, def.schemaType, def.allowUndefined)) { + throw new Error(`${keyword} value must be ${JSON.stringify(def.schemaType)}`); + } + } + if ("code" in def ? def.trackErrors : def.errors !== false) { + this.errsCount = it.gen.const("_errs", names_1.default.errors); + } + } + result(condition, successAction, failAction) { + this.failResult((0, codegen_1.not)(condition), successAction, failAction); + } + failResult(condition, successAction, failAction) { + this.gen.if(condition); + if (failAction) + failAction(); + else + this.error(); + if (successAction) { + this.gen.else(); + successAction(); + if (this.allErrors) + this.gen.endIf(); + } else { + if (this.allErrors) + this.gen.endIf(); + else + this.gen.else(); + } + } + pass(condition, failAction) { + this.failResult((0, codegen_1.not)(condition), void 0, failAction); + } + fail(condition) { + if (condition === void 0) { + this.error(); + if (!this.allErrors) + this.gen.if(false); + return; + } + this.gen.if(condition); + this.error(); + if (this.allErrors) + this.gen.endIf(); + else + this.gen.else(); + } + fail$data(condition) { + if (!this.$data) + return this.fail(condition); + const { schemaCode } = this; + this.fail((0, codegen_1._)`${schemaCode} !== undefined && (${(0, codegen_1.or)(this.invalid$data(), condition)})`); + } + error(append, errorParams, errorPaths) { + if (errorParams) { + this.setParams(errorParams); + this._error(append, errorPaths); + this.setParams({}); + return; + } + this._error(append, errorPaths); + } + _error(append, errorPaths) { + ; + (append ? errors_1.reportExtraError : errors_1.reportError)(this, this.def.error, errorPaths); + } + $dataError() { + (0, errors_1.reportError)(this, this.def.$dataError || errors_1.keyword$DataError); + } + reset() { + if (this.errsCount === void 0) + throw new Error('add "trackErrors" to keyword definition'); + (0, errors_1.resetErrorsCount)(this.gen, this.errsCount); + } + ok(cond) { + if (!this.allErrors) + this.gen.if(cond); + } + setParams(obj, assign) { + if (assign) + Object.assign(this.params, obj); + else + this.params = obj; + } + block$data(valid, codeBlock, $dataValid = codegen_1.nil) { + this.gen.block(() => { + this.check$data(valid, $dataValid); + codeBlock(); + }); + } + check$data(valid = codegen_1.nil, $dataValid = codegen_1.nil) { + if (!this.$data) + return; + const { gen, schemaCode, schemaType, def } = this; + gen.if((0, codegen_1.or)((0, codegen_1._)`${schemaCode} === undefined`, $dataValid)); + if (valid !== codegen_1.nil) + gen.assign(valid, true); + if (schemaType.length || def.validateSchema) { + gen.elseIf(this.invalid$data()); + this.$dataError(); + if (valid !== codegen_1.nil) + gen.assign(valid, false); + } + gen.else(); + } + invalid$data() { + const { gen, schemaCode, schemaType, def, it } = this; + return (0, codegen_1.or)(wrong$DataType(), invalid$DataSchema()); + function wrong$DataType() { + if (schemaType.length) { + if (!(schemaCode instanceof codegen_1.Name)) + throw new Error("ajv implementation error"); + const st = Array.isArray(schemaType) ? schemaType : [schemaType]; + return (0, codegen_1._)`${(0, dataType_2.checkDataTypes)(st, schemaCode, it.opts.strictNumbers, dataType_2.DataType.Wrong)}`; + } + return codegen_1.nil; + } + function invalid$DataSchema() { + if (def.validateSchema) { + const validateSchemaRef = gen.scopeValue("validate$data", { ref: def.validateSchema }); + return (0, codegen_1._)`!${validateSchemaRef}(${schemaCode})`; + } + return codegen_1.nil; + } + } + subschema(appl, valid) { + const subschema = (0, subschema_1.getSubschema)(this.it, appl); + (0, subschema_1.extendSubschemaData)(subschema, this.it, appl); + (0, subschema_1.extendSubschemaMode)(subschema, appl); + const nextContext = { ...this.it, ...subschema, items: void 0, props: void 0 }; + subschemaCode(nextContext, valid); + return nextContext; + } + mergeEvaluated(schemaCxt, toName) { + const { it, gen } = this; + if (!it.opts.unevaluated) + return; + if (it.props !== true && schemaCxt.props !== void 0) { + it.props = util_1.mergeEvaluated.props(gen, schemaCxt.props, it.props, toName); + } + if (it.items !== true && schemaCxt.items !== void 0) { + it.items = util_1.mergeEvaluated.items(gen, schemaCxt.items, it.items, toName); + } + } + mergeValidEvaluated(schemaCxt, valid) { + const { it, gen } = this; + if (it.opts.unevaluated && (it.props !== true || it.items !== true)) { + gen.if(valid, () => this.mergeEvaluated(schemaCxt, codegen_1.Name)); + return true; + } + } + }; + exports.KeywordCxt = KeywordCxt; + function keywordCode(it, keyword, def, ruleType) { + const cxt = new KeywordCxt(it, def, keyword); + if ("code" in def) { + def.code(cxt, ruleType); + } else if (cxt.$data && def.validate) { + (0, keyword_1.funcKeywordCode)(cxt, def); + } else if ("macro" in def) { + (0, keyword_1.macroKeywordCode)(cxt, def); + } else if (def.compile || def.validate) { + (0, keyword_1.funcKeywordCode)(cxt, def); + } + } + var JSON_POINTER = /^\/(?:[^~]|~0|~1)*$/; + var RELATIVE_JSON_POINTER = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/; + function getData($data, { dataLevel, dataNames, dataPathArr }) { + let jsonPointer; + let data; + if ($data === "") + return names_1.default.rootData; + if ($data[0] === "/") { + if (!JSON_POINTER.test($data)) + throw new Error(`Invalid JSON-pointer: ${$data}`); + jsonPointer = $data; + data = names_1.default.rootData; + } else { + const matches = RELATIVE_JSON_POINTER.exec($data); + if (!matches) + throw new Error(`Invalid JSON-pointer: ${$data}`); + const up = +matches[1]; + jsonPointer = matches[2]; + if (jsonPointer === "#") { + if (up >= dataLevel) + throw new Error(errorMsg("property/index", up)); + return dataPathArr[dataLevel - up]; + } + if (up > dataLevel) + throw new Error(errorMsg("data", up)); + data = dataNames[dataLevel - up]; + if (!jsonPointer) + return data; + } + let expr = data; + const segments = jsonPointer.split("/"); + for (const segment of segments) { + if (segment) { + data = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)((0, util_1.unescapeJsonPointer)(segment))}`; + expr = (0, codegen_1._)`${expr} && ${data}`; + } + } + return expr; + function errorMsg(pointerType, up) { + return `Cannot access ${pointerType} ${up} levels up, current level is ${dataLevel}`; + } + } + exports.getData = getData; + } +}); + +// node_modules/ajv/dist/runtime/validation_error.js +var require_validation_error = __commonJS({ + "node_modules/ajv/dist/runtime/validation_error.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var ValidationError = class extends Error { + constructor(errors) { + super("validation failed"); + this.errors = errors; + this.ajv = this.validation = true; + } + }; + exports.default = ValidationError; + } +}); + +// node_modules/ajv/dist/compile/ref_error.js +var require_ref_error = __commonJS({ + "node_modules/ajv/dist/compile/ref_error.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var resolve_1 = require_resolve(); + var MissingRefError = class extends Error { + constructor(resolver, baseId, ref, msg) { + super(msg || `can't resolve reference ${ref} from id ${baseId}`); + this.missingRef = (0, resolve_1.resolveUrl)(resolver, baseId, ref); + this.missingSchema = (0, resolve_1.normalizeId)((0, resolve_1.getFullPath)(resolver, this.missingRef)); + } + }; + exports.default = MissingRefError; + } +}); + +// node_modules/ajv/dist/compile/index.js +var require_compile = __commonJS({ + "node_modules/ajv/dist/compile/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.resolveSchema = exports.getCompilingSchema = exports.resolveRef = exports.compileSchema = exports.SchemaEnv = void 0; + var codegen_1 = require_codegen(); + var validation_error_1 = require_validation_error(); + var names_1 = require_names(); + var resolve_1 = require_resolve(); + var util_1 = require_util(); + var validate_1 = require_validate(); + var SchemaEnv = class { + constructor(env) { + var _a3; + this.refs = {}; + this.dynamicAnchors = {}; + let schema; + if (typeof env.schema == "object") + schema = env.schema; + this.schema = env.schema; + this.schemaId = env.schemaId; + this.root = env.root || this; + this.baseId = (_a3 = env.baseId) !== null && _a3 !== void 0 ? _a3 : (0, resolve_1.normalizeId)(schema === null || schema === void 0 ? void 0 : schema[env.schemaId || "$id"]); + this.schemaPath = env.schemaPath; + this.localRefs = env.localRefs; + this.meta = env.meta; + this.$async = schema === null || schema === void 0 ? void 0 : schema.$async; + this.refs = {}; + } + }; + exports.SchemaEnv = SchemaEnv; + function compileSchema(sch) { + const _sch = getCompilingSchema.call(this, sch); + if (_sch) + return _sch; + const rootId = (0, resolve_1.getFullPath)(this.opts.uriResolver, sch.root.baseId); + const { es5, lines } = this.opts.code; + const { ownProperties } = this.opts; + const gen = new codegen_1.CodeGen(this.scope, { es5, lines, ownProperties }); + let _ValidationError; + if (sch.$async) { + _ValidationError = gen.scopeValue("Error", { + ref: validation_error_1.default, + code: (0, codegen_1._)`require("ajv/dist/runtime/validation_error").default` + }); + } + const validateName = gen.scopeName("validate"); + sch.validateName = validateName; + const schemaCxt = { + gen, + allErrors: this.opts.allErrors, + data: names_1.default.data, + parentData: names_1.default.parentData, + parentDataProperty: names_1.default.parentDataProperty, + dataNames: [names_1.default.data], + dataPathArr: [codegen_1.nil], + // TODO can its length be used as dataLevel if nil is removed? + dataLevel: 0, + dataTypes: [], + definedProperties: /* @__PURE__ */ new Set(), + topSchemaRef: gen.scopeValue("schema", this.opts.code.source === true ? { ref: sch.schema, code: (0, codegen_1.stringify)(sch.schema) } : { ref: sch.schema }), + validateName, + ValidationError: _ValidationError, + schema: sch.schema, + schemaEnv: sch, + rootId, + baseId: sch.baseId || rootId, + schemaPath: codegen_1.nil, + errSchemaPath: sch.schemaPath || (this.opts.jtd ? "" : "#"), + errorPath: (0, codegen_1._)`""`, + opts: this.opts, + self: this + }; + let sourceCode; + try { + this._compilations.add(sch); + (0, validate_1.validateFunctionCode)(schemaCxt); + gen.optimize(this.opts.code.optimize); + const validateCode = gen.toString(); + sourceCode = `${gen.scopeRefs(names_1.default.scope)}return ${validateCode}`; + if (this.opts.code.process) + sourceCode = this.opts.code.process(sourceCode, sch); + const makeValidate = new Function(`${names_1.default.self}`, `${names_1.default.scope}`, sourceCode); + const validate = makeValidate(this, this.scope.get()); + this.scope.value(validateName, { ref: validate }); + validate.errors = null; + validate.schema = sch.schema; + validate.schemaEnv = sch; + if (sch.$async) + validate.$async = true; + if (this.opts.code.source === true) { + validate.source = { validateName, validateCode, scopeValues: gen._values }; + } + if (this.opts.unevaluated) { + const { props, items } = schemaCxt; + validate.evaluated = { + props: props instanceof codegen_1.Name ? void 0 : props, + items: items instanceof codegen_1.Name ? void 0 : items, + dynamicProps: props instanceof codegen_1.Name, + dynamicItems: items instanceof codegen_1.Name + }; + if (validate.source) + validate.source.evaluated = (0, codegen_1.stringify)(validate.evaluated); + } + sch.validate = validate; + return sch; + } catch (e3) { + delete sch.validate; + delete sch.validateName; + if (sourceCode) + this.logger.error("Error compiling schema, function code:", sourceCode); + throw e3; + } finally { + this._compilations.delete(sch); + } + } + exports.compileSchema = compileSchema; + function resolveRef(root, baseId, ref) { + var _a3; + ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref); + const schOrFunc = root.refs[ref]; + if (schOrFunc) + return schOrFunc; + let _sch = resolve5.call(this, root, ref); + if (_sch === void 0) { + const schema = (_a3 = root.localRefs) === null || _a3 === void 0 ? void 0 : _a3[ref]; + const { schemaId } = this.opts; + if (schema) + _sch = new SchemaEnv({ schema, schemaId, root, baseId }); + } + if (_sch === void 0) + return; + return root.refs[ref] = inlineOrCompile.call(this, _sch); + } + exports.resolveRef = resolveRef; + function inlineOrCompile(sch) { + if ((0, resolve_1.inlineRef)(sch.schema, this.opts.inlineRefs)) + return sch.schema; + return sch.validate ? sch : compileSchema.call(this, sch); + } + function getCompilingSchema(schEnv) { + for (const sch of this._compilations) { + if (sameSchemaEnv(sch, schEnv)) + return sch; + } + } + exports.getCompilingSchema = getCompilingSchema; + function sameSchemaEnv(s12, s22) { + return s12.schema === s22.schema && s12.root === s22.root && s12.baseId === s22.baseId; + } + function resolve5(root, ref) { + let sch; + while (typeof (sch = this.refs[ref]) == "string") + ref = sch; + return sch || this.schemas[ref] || resolveSchema.call(this, root, ref); + } + function resolveSchema(root, ref) { + const p = this.opts.uriResolver.parse(ref); + const refPath = (0, resolve_1._getFullPath)(this.opts.uriResolver, p); + let baseId = (0, resolve_1.getFullPath)(this.opts.uriResolver, root.baseId, void 0); + if (Object.keys(root.schema).length > 0 && refPath === baseId) { + return getJsonPointer.call(this, p, root); + } + const id = (0, resolve_1.normalizeId)(refPath); + const schOrRef = this.refs[id] || this.schemas[id]; + if (typeof schOrRef == "string") { + const sch = resolveSchema.call(this, root, schOrRef); + if (typeof (sch === null || sch === void 0 ? void 0 : sch.schema) !== "object") + return; + return getJsonPointer.call(this, p, sch); + } + if (typeof (schOrRef === null || schOrRef === void 0 ? void 0 : schOrRef.schema) !== "object") + return; + if (!schOrRef.validate) + compileSchema.call(this, schOrRef); + if (id === (0, resolve_1.normalizeId)(ref)) { + const { schema } = schOrRef; + const { schemaId } = this.opts; + const schId = schema[schemaId]; + if (schId) + baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId); + return new SchemaEnv({ schema, schemaId, root, baseId }); + } + return getJsonPointer.call(this, p, schOrRef); + } + exports.resolveSchema = resolveSchema; + var PREVENT_SCOPE_CHANGE = /* @__PURE__ */ new Set([ + "properties", + "patternProperties", + "enum", + "dependencies", + "definitions" + ]); + function getJsonPointer(parsedRef, { baseId, schema, root }) { + var _a3; + if (((_a3 = parsedRef.fragment) === null || _a3 === void 0 ? void 0 : _a3[0]) !== "/") + return; + for (const part of parsedRef.fragment.slice(1).split("/")) { + if (typeof schema === "boolean") + return; + const partSchema = schema[(0, util_1.unescapeFragment)(part)]; + if (partSchema === void 0) + return; + schema = partSchema; + const schId = typeof schema === "object" && schema[this.opts.schemaId]; + if (!PREVENT_SCOPE_CHANGE.has(part) && schId) { + baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId); + } + } + let env; + if (typeof schema != "boolean" && schema.$ref && !(0, util_1.schemaHasRulesButRef)(schema, this.RULES)) { + const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema.$ref); + env = resolveSchema.call(this, root, $ref); + } + const { schemaId } = this.opts; + env = env || new SchemaEnv({ schema, schemaId, root, baseId }); + if (env.schema !== env.root.schema) + return env; + return void 0; + } + } +}); + +// node_modules/ajv/dist/refs/data.json +var require_data = __commonJS({ + "node_modules/ajv/dist/refs/data.json"(exports, module2) { + module2.exports = { + $id: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#", + description: "Meta-schema for $data reference (JSON AnySchema extension proposal)", + type: "object", + required: ["$data"], + properties: { + $data: { + type: "string", + anyOf: [{ format: "relative-json-pointer" }, { format: "json-pointer" }] + } + }, + additionalProperties: false + }; + } +}); + +// node_modules/fast-uri/lib/utils.js +var require_utils = __commonJS({ + "node_modules/fast-uri/lib/utils.js"(exports, module2) { + "use strict"; + var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu); + var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u); + function stringArrayToHexStripped(input) { + let acc = ""; + let code = 0; + let i3 = 0; + for (i3 = 0; i3 < input.length; i3++) { + code = input[i3].charCodeAt(0); + if (code === 48) { + continue; + } + if (!(code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102)) { + return ""; + } + acc += input[i3]; + break; + } + for (i3 += 1; i3 < input.length; i3++) { + code = input[i3].charCodeAt(0); + if (!(code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102)) { + return ""; + } + acc += input[i3]; + } + return acc; + } + var nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u); + function consumeIsZone(buffer) { + buffer.length = 0; + return true; + } + function consumeHextets(buffer, address, output) { + if (buffer.length) { + const hex3 = stringArrayToHexStripped(buffer); + if (hex3 !== "") { + address.push(hex3); + } else { + output.error = true; + return false; + } + buffer.length = 0; + } + return true; + } + function getIPV6(input) { + let tokenCount = 0; + const output = { error: false, address: "", zone: "" }; + const address = []; + const buffer = []; + let endipv6Encountered = false; + let endIpv6 = false; + let consume = consumeHextets; + for (let i3 = 0; i3 < input.length; i3++) { + const cursor = input[i3]; + if (cursor === "[" || cursor === "]") { + continue; + } + if (cursor === ":") { + if (endipv6Encountered === true) { + endIpv6 = true; + } + if (!consume(buffer, address, output)) { + break; + } + if (++tokenCount > 7) { + output.error = true; + break; + } + if (i3 > 0 && input[i3 - 1] === ":") { + endipv6Encountered = true; + } + address.push(":"); + continue; + } else if (cursor === "%") { + if (!consume(buffer, address, output)) { + break; + } + consume = consumeIsZone; + } else { + buffer.push(cursor); + continue; + } + } + if (buffer.length) { + if (consume === consumeIsZone) { + output.zone = buffer.join(""); + } else if (endIpv6) { + address.push(buffer.join("")); + } else { + address.push(stringArrayToHexStripped(buffer)); + } + } + output.address = address.join(""); + return output; + } + function normalizeIPv6(host) { + if (findToken(host, ":") < 2) { + return { host, isIPV6: false }; + } + const ipv63 = getIPV6(host); + if (!ipv63.error) { + let newHost = ipv63.address; + let escapedHost = ipv63.address; + if (ipv63.zone) { + newHost += "%" + ipv63.zone; + escapedHost += "%25" + ipv63.zone; + } + return { host: newHost, isIPV6: true, escapedHost }; + } else { + return { host, isIPV6: false }; + } + } + function findToken(str, token) { + let ind = 0; + for (let i3 = 0; i3 < str.length; i3++) { + if (str[i3] === token) ind++; + } + return ind; + } + function removeDotSegments(path19) { + let input = path19; + const output = []; + let nextSlash = -1; + let len = 0; + while (len = input.length) { + if (len === 1) { + if (input === ".") { + break; + } else if (input === "/") { + output.push("/"); + break; + } else { + output.push(input); + break; + } + } else if (len === 2) { + if (input[0] === ".") { + if (input[1] === ".") { + break; + } else if (input[1] === "/") { + input = input.slice(2); + continue; + } + } else if (input[0] === "/") { + if (input[1] === "." || input[1] === "/") { + output.push("/"); + break; + } + } + } else if (len === 3) { + if (input === "/..") { + if (output.length !== 0) { + output.pop(); + } + output.push("/"); + break; + } + } + if (input[0] === ".") { + if (input[1] === ".") { + if (input[2] === "/") { + input = input.slice(3); + continue; + } + } else if (input[1] === "/") { + input = input.slice(2); + continue; + } + } else if (input[0] === "/") { + if (input[1] === ".") { + if (input[2] === "/") { + input = input.slice(2); + continue; + } else if (input[2] === ".") { + if (input[3] === "/") { + input = input.slice(3); + if (output.length !== 0) { + output.pop(); + } + continue; + } + } + } + } + if ((nextSlash = input.indexOf("/", 1)) === -1) { + output.push(input); + break; + } else { + output.push(input.slice(0, nextSlash)); + input = input.slice(nextSlash); + } + } + return output.join(""); + } + function normalizeComponentEncoding(component, esc2) { + const func = esc2 !== true ? escape : unescape; + if (component.scheme !== void 0) { + component.scheme = func(component.scheme); + } + if (component.userinfo !== void 0) { + component.userinfo = func(component.userinfo); + } + if (component.host !== void 0) { + component.host = func(component.host); + } + if (component.path !== void 0) { + component.path = func(component.path); + } + if (component.query !== void 0) { + component.query = func(component.query); + } + if (component.fragment !== void 0) { + component.fragment = func(component.fragment); + } + return component; + } + function recomposeAuthority(component) { + const uriTokens = []; + if (component.userinfo !== void 0) { + uriTokens.push(component.userinfo); + uriTokens.push("@"); + } + if (component.host !== void 0) { + let host = unescape(component.host); + if (!isIPv4(host)) { + const ipV6res = normalizeIPv6(host); + if (ipV6res.isIPV6 === true) { + host = `[${ipV6res.escapedHost}]`; + } else { + host = component.host; + } + } + uriTokens.push(host); + } + if (typeof component.port === "number" || typeof component.port === "string") { + uriTokens.push(":"); + uriTokens.push(String(component.port)); + } + return uriTokens.length ? uriTokens.join("") : void 0; + } + module2.exports = { + nonSimpleDomain, + recomposeAuthority, + normalizeComponentEncoding, + removeDotSegments, + isIPv4, + isUUID, + normalizeIPv6, + stringArrayToHexStripped + }; + } +}); + +// node_modules/fast-uri/lib/schemes.js +var require_schemes = __commonJS({ + "node_modules/fast-uri/lib/schemes.js"(exports, module2) { + "use strict"; + var { isUUID } = require_utils(); + var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu; + var supportedSchemeNames = ( + /** @type {const} */ + [ + "http", + "https", + "ws", + "wss", + "urn", + "urn:uuid" + ] + ); + function isValidSchemeName(name) { + return supportedSchemeNames.indexOf( + /** @type {*} */ + name + ) !== -1; + } + function wsIsSecure(wsComponent) { + if (wsComponent.secure === true) { + return true; + } else if (wsComponent.secure === false) { + return false; + } else if (wsComponent.scheme) { + return wsComponent.scheme.length === 3 && (wsComponent.scheme[0] === "w" || wsComponent.scheme[0] === "W") && (wsComponent.scheme[1] === "s" || wsComponent.scheme[1] === "S") && (wsComponent.scheme[2] === "s" || wsComponent.scheme[2] === "S"); + } else { + return false; + } + } + function httpParse(component) { + if (!component.host) { + component.error = component.error || "HTTP URIs must have a host."; + } + return component; + } + function httpSerialize(component) { + const secure = String(component.scheme).toLowerCase() === "https"; + if (component.port === (secure ? 443 : 80) || component.port === "") { + component.port = void 0; + } + if (!component.path) { + component.path = "/"; + } + return component; + } + function wsParse(wsComponent) { + wsComponent.secure = wsIsSecure(wsComponent); + wsComponent.resourceName = (wsComponent.path || "/") + (wsComponent.query ? "?" + wsComponent.query : ""); + wsComponent.path = void 0; + wsComponent.query = void 0; + return wsComponent; + } + function wsSerialize(wsComponent) { + if (wsComponent.port === (wsIsSecure(wsComponent) ? 443 : 80) || wsComponent.port === "") { + wsComponent.port = void 0; + } + if (typeof wsComponent.secure === "boolean") { + wsComponent.scheme = wsComponent.secure ? "wss" : "ws"; + wsComponent.secure = void 0; + } + if (wsComponent.resourceName) { + const [path19, query] = wsComponent.resourceName.split("?"); + wsComponent.path = path19 && path19 !== "/" ? path19 : void 0; + wsComponent.query = query; + wsComponent.resourceName = void 0; + } + wsComponent.fragment = void 0; + return wsComponent; + } + function urnParse(urnComponent, options) { + if (!urnComponent.path) { + urnComponent.error = "URN can not be parsed"; + return urnComponent; + } + const matches = urnComponent.path.match(URN_REG); + if (matches) { + const scheme = options.scheme || urnComponent.scheme || "urn"; + urnComponent.nid = matches[1].toLowerCase(); + urnComponent.nss = matches[2]; + const urnScheme = `${scheme}:${options.nid || urnComponent.nid}`; + const schemeHandler = getSchemeHandler(urnScheme); + urnComponent.path = void 0; + if (schemeHandler) { + urnComponent = schemeHandler.parse(urnComponent, options); + } + } else { + urnComponent.error = urnComponent.error || "URN can not be parsed."; + } + return urnComponent; + } + function urnSerialize(urnComponent, options) { + if (urnComponent.nid === void 0) { + throw new Error("URN without nid cannot be serialized"); + } + const scheme = options.scheme || urnComponent.scheme || "urn"; + const nid = urnComponent.nid.toLowerCase(); + const urnScheme = `${scheme}:${options.nid || nid}`; + const schemeHandler = getSchemeHandler(urnScheme); + if (schemeHandler) { + urnComponent = schemeHandler.serialize(urnComponent, options); + } + const uriComponent = urnComponent; + const nss = urnComponent.nss; + uriComponent.path = `${nid || options.nid}:${nss}`; + options.skipEscape = true; + return uriComponent; + } + function urnuuidParse(urnComponent, options) { + const uuidComponent = urnComponent; + uuidComponent.uuid = uuidComponent.nss; + uuidComponent.nss = void 0; + if (!options.tolerant && (!uuidComponent.uuid || !isUUID(uuidComponent.uuid))) { + uuidComponent.error = uuidComponent.error || "UUID is not valid."; + } + return uuidComponent; + } + function urnuuidSerialize(uuidComponent) { + const urnComponent = uuidComponent; + urnComponent.nss = (uuidComponent.uuid || "").toLowerCase(); + return urnComponent; + } + var http2 = ( + /** @type {SchemeHandler} */ + { + scheme: "http", + domainHost: true, + parse: httpParse, + serialize: httpSerialize + } + ); + var https2 = ( + /** @type {SchemeHandler} */ + { + scheme: "https", + domainHost: http2.domainHost, + parse: httpParse, + serialize: httpSerialize + } + ); + var ws = ( + /** @type {SchemeHandler} */ + { + scheme: "ws", + domainHost: true, + parse: wsParse, + serialize: wsSerialize + } + ); + var wss = ( + /** @type {SchemeHandler} */ + { + scheme: "wss", + domainHost: ws.domainHost, + parse: ws.parse, + serialize: ws.serialize + } + ); + var urn = ( + /** @type {SchemeHandler} */ + { + scheme: "urn", + parse: urnParse, + serialize: urnSerialize, + skipNormalize: true + } + ); + var urnuuid = ( + /** @type {SchemeHandler} */ + { + scheme: "urn:uuid", + parse: urnuuidParse, + serialize: urnuuidSerialize, + skipNormalize: true + } + ); + var SCHEMES = ( + /** @type {Record} */ + { + http: http2, + https: https2, + ws, + wss, + urn, + "urn:uuid": urnuuid + } + ); + Object.setPrototypeOf(SCHEMES, null); + function getSchemeHandler(scheme) { + return scheme && (SCHEMES[ + /** @type {SchemeName} */ + scheme + ] || SCHEMES[ + /** @type {SchemeName} */ + scheme.toLowerCase() + ]) || void 0; + } + module2.exports = { + wsIsSecure, + SCHEMES, + isValidSchemeName, + getSchemeHandler + }; + } +}); + +// node_modules/fast-uri/index.js +var require_fast_uri = __commonJS({ + "node_modules/fast-uri/index.js"(exports, module2) { + "use strict"; + var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils(); + var { SCHEMES, getSchemeHandler } = require_schemes(); + function normalize3(uri, options) { + if (typeof uri === "string") { + uri = /** @type {T} */ + serialize(parse4(uri, options), options); + } else if (typeof uri === "object") { + uri = /** @type {T} */ + parse4(serialize(uri, options), options); + } + return uri; + } + function resolve5(baseURI, relativeURI, options) { + const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" }; + const resolved = resolveComponent(parse4(baseURI, schemelessOptions), parse4(relativeURI, schemelessOptions), schemelessOptions, true); + schemelessOptions.skipEscape = true; + return serialize(resolved, schemelessOptions); + } + function resolveComponent(base, relative3, options, skipNormalization) { + const target = {}; + if (!skipNormalization) { + base = parse4(serialize(base, options), options); + relative3 = parse4(serialize(relative3, options), options); + } + options = options || {}; + if (!options.tolerant && relative3.scheme) { + target.scheme = relative3.scheme; + target.userinfo = relative3.userinfo; + target.host = relative3.host; + target.port = relative3.port; + target.path = removeDotSegments(relative3.path || ""); + target.query = relative3.query; + } else { + if (relative3.userinfo !== void 0 || relative3.host !== void 0 || relative3.port !== void 0) { + target.userinfo = relative3.userinfo; + target.host = relative3.host; + target.port = relative3.port; + target.path = removeDotSegments(relative3.path || ""); + target.query = relative3.query; + } else { + if (!relative3.path) { + target.path = base.path; + if (relative3.query !== void 0) { + target.query = relative3.query; + } else { + target.query = base.query; + } + } else { + if (relative3.path[0] === "/") { + target.path = removeDotSegments(relative3.path); + } else { + if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) { + target.path = "/" + relative3.path; + } else if (!base.path) { + target.path = relative3.path; + } else { + target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative3.path; + } + target.path = removeDotSegments(target.path); + } + target.query = relative3.query; + } + target.userinfo = base.userinfo; + target.host = base.host; + target.port = base.port; + } + target.scheme = base.scheme; + } + target.fragment = relative3.fragment; + return target; + } + function equal(uriA, uriB, options) { + if (typeof uriA === "string") { + uriA = unescape(uriA); + uriA = serialize(normalizeComponentEncoding(parse4(uriA, options), true), { ...options, skipEscape: true }); + } else if (typeof uriA === "object") { + uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true }); + } + if (typeof uriB === "string") { + uriB = unescape(uriB); + uriB = serialize(normalizeComponentEncoding(parse4(uriB, options), true), { ...options, skipEscape: true }); + } else if (typeof uriB === "object") { + uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true }); + } + return uriA.toLowerCase() === uriB.toLowerCase(); + } + function serialize(cmpts, opts) { + const component = { + host: cmpts.host, + scheme: cmpts.scheme, + userinfo: cmpts.userinfo, + port: cmpts.port, + path: cmpts.path, + query: cmpts.query, + nid: cmpts.nid, + nss: cmpts.nss, + uuid: cmpts.uuid, + fragment: cmpts.fragment, + reference: cmpts.reference, + resourceName: cmpts.resourceName, + secure: cmpts.secure, + error: "" + }; + const options = Object.assign({}, opts); + const uriTokens = []; + const schemeHandler = getSchemeHandler(options.scheme || component.scheme); + if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options); + if (component.path !== void 0) { + if (!options.skipEscape) { + component.path = escape(component.path); + if (component.scheme !== void 0) { + component.path = component.path.split("%3A").join(":"); + } + } else { + component.path = unescape(component.path); + } + } + if (options.reference !== "suffix" && component.scheme) { + uriTokens.push(component.scheme, ":"); + } + const authority = recomposeAuthority(component); + if (authority !== void 0) { + if (options.reference !== "suffix") { + uriTokens.push("//"); + } + uriTokens.push(authority); + if (component.path && component.path[0] !== "/") { + uriTokens.push("/"); + } + } + if (component.path !== void 0) { + let s3 = component.path; + if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) { + s3 = removeDotSegments(s3); + } + if (authority === void 0 && s3[0] === "/" && s3[1] === "/") { + s3 = "/%2F" + s3.slice(2); + } + uriTokens.push(s3); + } + if (component.query !== void 0) { + uriTokens.push("?", component.query); + } + if (component.fragment !== void 0) { + uriTokens.push("#", component.fragment); + } + return uriTokens.join(""); + } + var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u; + function parse4(uri, opts) { + const options = Object.assign({}, opts); + const parsed = { + scheme: void 0, + userinfo: void 0, + host: "", + port: void 0, + path: "", + query: void 0, + fragment: void 0 + }; + let isIP = false; + if (options.reference === "suffix") { + if (options.scheme) { + uri = options.scheme + ":" + uri; + } else { + uri = "//" + uri; + } + } + const matches = uri.match(URI_PARSE); + if (matches) { + parsed.scheme = matches[1]; + parsed.userinfo = matches[3]; + parsed.host = matches[4]; + parsed.port = parseInt(matches[5], 10); + parsed.path = matches[6] || ""; + parsed.query = matches[7]; + parsed.fragment = matches[8]; + if (isNaN(parsed.port)) { + parsed.port = matches[5]; + } + if (parsed.host) { + const ipv4result = isIPv4(parsed.host); + if (ipv4result === false) { + const ipv6result = normalizeIPv6(parsed.host); + parsed.host = ipv6result.host.toLowerCase(); + isIP = ipv6result.isIPV6; + } else { + isIP = true; + } + } + if (parsed.scheme === void 0 && parsed.userinfo === void 0 && parsed.host === void 0 && parsed.port === void 0 && parsed.query === void 0 && !parsed.path) { + parsed.reference = "same-document"; + } else if (parsed.scheme === void 0) { + parsed.reference = "relative"; + } else if (parsed.fragment === void 0) { + parsed.reference = "absolute"; + } else { + parsed.reference = "uri"; + } + if (options.reference && options.reference !== "suffix" && options.reference !== parsed.reference) { + parsed.error = parsed.error || "URI is not a " + options.reference + " reference."; + } + const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme); + if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) { + if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) { + try { + parsed.host = URL.domainToASCII(parsed.host.toLowerCase()); + } catch (e3) { + parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e3; + } + } + } + if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) { + if (uri.indexOf("%") !== -1) { + if (parsed.scheme !== void 0) { + parsed.scheme = unescape(parsed.scheme); + } + if (parsed.host !== void 0) { + parsed.host = unescape(parsed.host); + } + } + if (parsed.path) { + parsed.path = escape(unescape(parsed.path)); + } + if (parsed.fragment) { + parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment)); + } + } + if (schemeHandler && schemeHandler.parse) { + schemeHandler.parse(parsed, options); + } + } else { + parsed.error = parsed.error || "URI can not be parsed."; + } + return parsed; + } + var fastUri = { + SCHEMES, + normalize: normalize3, + resolve: resolve5, + resolveComponent, + equal, + serialize, + parse: parse4 + }; + module2.exports = fastUri; + module2.exports.default = fastUri; + module2.exports.fastUri = fastUri; + } +}); + +// node_modules/ajv/dist/runtime/uri.js +var require_uri = __commonJS({ + "node_modules/ajv/dist/runtime/uri.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var uri = require_fast_uri(); + uri.code = 'require("ajv/dist/runtime/uri").default'; + exports.default = uri; + } +}); + +// node_modules/ajv/dist/core.js +var require_core = __commonJS({ + "node_modules/ajv/dist/core.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = void 0; + var validate_1 = require_validate(); + Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() { + return validate_1.KeywordCxt; + } }); + var codegen_1 = require_codegen(); + Object.defineProperty(exports, "_", { enumerable: true, get: function() { + return codegen_1._; + } }); + Object.defineProperty(exports, "str", { enumerable: true, get: function() { + return codegen_1.str; + } }); + Object.defineProperty(exports, "stringify", { enumerable: true, get: function() { + return codegen_1.stringify; + } }); + Object.defineProperty(exports, "nil", { enumerable: true, get: function() { + return codegen_1.nil; + } }); + Object.defineProperty(exports, "Name", { enumerable: true, get: function() { + return codegen_1.Name; + } }); + Object.defineProperty(exports, "CodeGen", { enumerable: true, get: function() { + return codegen_1.CodeGen; + } }); + var validation_error_1 = require_validation_error(); + var ref_error_1 = require_ref_error(); + var rules_1 = require_rules(); + var compile_1 = require_compile(); + var codegen_2 = require_codegen(); + var resolve_1 = require_resolve(); + var dataType_1 = require_dataType(); + var util_1 = require_util(); + var $dataRefSchema = require_data(); + var uri_1 = require_uri(); + var defaultRegExp = (str, flags) => new RegExp(str, flags); + defaultRegExp.code = "new RegExp"; + var META_IGNORE_OPTIONS = ["removeAdditional", "useDefaults", "coerceTypes"]; + var EXT_SCOPE_NAMES = /* @__PURE__ */ new Set([ + "validate", + "serialize", + "parse", + "wrapper", + "root", + "schema", + "keyword", + "pattern", + "formats", + "validate$data", + "func", + "obj", + "Error" + ]); + var removedOptions = { + errorDataPath: "", + format: "`validateFormats: false` can be used instead.", + nullable: '"nullable" keyword is supported by default.', + jsonPointers: "Deprecated jsPropertySyntax can be used instead.", + extendRefs: "Deprecated ignoreKeywordsWithRef can be used instead.", + missingRefs: "Pass empty schema with $id that should be ignored to ajv.addSchema.", + processCode: "Use option `code: {process: (code, schemaEnv: object) => string}`", + sourceCode: "Use option `code: {source: true}`", + strictDefaults: "It is default now, see option `strict`.", + strictKeywords: "It is default now, see option `strict`.", + uniqueItems: '"uniqueItems" keyword is always validated.', + unknownFormats: "Disable strict mode or pass `true` to `ajv.addFormat` (or `formats` option).", + cache: "Map is used as cache, schema object as key.", + serialize: "Map is used as cache, schema object as key.", + ajvErrors: "It is default now." + }; + var deprecatedOptions = { + ignoreKeywordsWithRef: "", + jsPropertySyntax: "", + unicode: '"minLength"/"maxLength" account for unicode characters by default.' + }; + var MAX_EXPRESSION = 200; + function requiredOptions(o3) { + var _a3, _b2, _c, _d, _e, _f, _g, _h, _j2, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z2, _02; + const s3 = o3.strict; + const _optz = (_a3 = o3.code) === null || _a3 === void 0 ? void 0 : _a3.optimize; + const optimize = _optz === true || _optz === void 0 ? 1 : _optz || 0; + const regExp = (_c = (_b2 = o3.code) === null || _b2 === void 0 ? void 0 : _b2.regExp) !== null && _c !== void 0 ? _c : defaultRegExp; + const uriResolver = (_d = o3.uriResolver) !== null && _d !== void 0 ? _d : uri_1.default; + return { + strictSchema: (_f = (_e = o3.strictSchema) !== null && _e !== void 0 ? _e : s3) !== null && _f !== void 0 ? _f : true, + strictNumbers: (_h = (_g = o3.strictNumbers) !== null && _g !== void 0 ? _g : s3) !== null && _h !== void 0 ? _h : true, + strictTypes: (_k = (_j2 = o3.strictTypes) !== null && _j2 !== void 0 ? _j2 : s3) !== null && _k !== void 0 ? _k : "log", + strictTuples: (_m = (_l = o3.strictTuples) !== null && _l !== void 0 ? _l : s3) !== null && _m !== void 0 ? _m : "log", + strictRequired: (_p = (_o = o3.strictRequired) !== null && _o !== void 0 ? _o : s3) !== null && _p !== void 0 ? _p : false, + code: o3.code ? { ...o3.code, optimize, regExp } : { optimize, regExp }, + loopRequired: (_q = o3.loopRequired) !== null && _q !== void 0 ? _q : MAX_EXPRESSION, + loopEnum: (_r = o3.loopEnum) !== null && _r !== void 0 ? _r : MAX_EXPRESSION, + meta: (_s = o3.meta) !== null && _s !== void 0 ? _s : true, + messages: (_t = o3.messages) !== null && _t !== void 0 ? _t : true, + inlineRefs: (_u = o3.inlineRefs) !== null && _u !== void 0 ? _u : true, + schemaId: (_v = o3.schemaId) !== null && _v !== void 0 ? _v : "$id", + addUsedSchema: (_w = o3.addUsedSchema) !== null && _w !== void 0 ? _w : true, + validateSchema: (_x = o3.validateSchema) !== null && _x !== void 0 ? _x : true, + validateFormats: (_y = o3.validateFormats) !== null && _y !== void 0 ? _y : true, + unicodeRegExp: (_z2 = o3.unicodeRegExp) !== null && _z2 !== void 0 ? _z2 : true, + int32range: (_02 = o3.int32range) !== null && _02 !== void 0 ? _02 : true, + uriResolver + }; + } + var Ajv2 = class { + constructor(opts = {}) { + this.schemas = {}; + this.refs = {}; + this.formats = {}; + this._compilations = /* @__PURE__ */ new Set(); + this._loading = {}; + this._cache = /* @__PURE__ */ new Map(); + opts = this.opts = { ...opts, ...requiredOptions(opts) }; + const { es5, lines } = this.opts.code; + this.scope = new codegen_2.ValueScope({ scope: {}, prefixes: EXT_SCOPE_NAMES, es5, lines }); + this.logger = getLogger(opts.logger); + const formatOpt = opts.validateFormats; + opts.validateFormats = false; + this.RULES = (0, rules_1.getRules)(); + checkOptions.call(this, removedOptions, opts, "NOT SUPPORTED"); + checkOptions.call(this, deprecatedOptions, opts, "DEPRECATED", "warn"); + this._metaOpts = getMetaSchemaOptions.call(this); + if (opts.formats) + addInitialFormats.call(this); + this._addVocabularies(); + this._addDefaultMetaSchema(); + if (opts.keywords) + addInitialKeywords.call(this, opts.keywords); + if (typeof opts.meta == "object") + this.addMetaSchema(opts.meta); + addInitialSchemas.call(this); + opts.validateFormats = formatOpt; + } + _addVocabularies() { + this.addKeyword("$async"); + } + _addDefaultMetaSchema() { + const { $data, meta: meta3, schemaId } = this.opts; + let _dataRefSchema = $dataRefSchema; + if (schemaId === "id") { + _dataRefSchema = { ...$dataRefSchema }; + _dataRefSchema.id = _dataRefSchema.$id; + delete _dataRefSchema.$id; + } + if (meta3 && $data) + this.addMetaSchema(_dataRefSchema, _dataRefSchema[schemaId], false); + } + defaultMeta() { + const { meta: meta3, schemaId } = this.opts; + return this.opts.defaultMeta = typeof meta3 == "object" ? meta3[schemaId] || meta3 : void 0; + } + validate(schemaKeyRef, data) { + let v2; + if (typeof schemaKeyRef == "string") { + v2 = this.getSchema(schemaKeyRef); + if (!v2) + throw new Error(`no schema with key or ref "${schemaKeyRef}"`); + } else { + v2 = this.compile(schemaKeyRef); + } + const valid = v2(data); + if (!("$async" in v2)) + this.errors = v2.errors; + return valid; + } + compile(schema, _meta) { + const sch = this._addSchema(schema, _meta); + return sch.validate || this._compileSchemaEnv(sch); + } + compileAsync(schema, meta3) { + if (typeof this.opts.loadSchema != "function") { + throw new Error("options.loadSchema should be a function"); + } + const { loadSchema } = this.opts; + return runCompileAsync.call(this, schema, meta3); + async function runCompileAsync(_schema, _meta) { + await loadMetaSchema.call(this, _schema.$schema); + const sch = this._addSchema(_schema, _meta); + return sch.validate || _compileAsync.call(this, sch); + } + async function loadMetaSchema($ref) { + if ($ref && !this.getSchema($ref)) { + await runCompileAsync.call(this, { $ref }, true); + } + } + async function _compileAsync(sch) { + try { + return this._compileSchemaEnv(sch); + } catch (e3) { + if (!(e3 instanceof ref_error_1.default)) + throw e3; + checkLoaded.call(this, e3); + await loadMissingSchema.call(this, e3.missingSchema); + return _compileAsync.call(this, sch); + } + } + function checkLoaded({ missingSchema: ref, missingRef }) { + if (this.refs[ref]) { + throw new Error(`AnySchema ${ref} is loaded but ${missingRef} cannot be resolved`); + } + } + async function loadMissingSchema(ref) { + const _schema = await _loadSchema.call(this, ref); + if (!this.refs[ref]) + await loadMetaSchema.call(this, _schema.$schema); + if (!this.refs[ref]) + this.addSchema(_schema, ref, meta3); + } + async function _loadSchema(ref) { + const p = this._loading[ref]; + if (p) + return p; + try { + return await (this._loading[ref] = loadSchema(ref)); + } finally { + delete this._loading[ref]; + } + } + } + // Adds schema to the instance + addSchema(schema, key, _meta, _validateSchema = this.opts.validateSchema) { + if (Array.isArray(schema)) { + for (const sch of schema) + this.addSchema(sch, void 0, _meta, _validateSchema); + return this; + } + let id; + if (typeof schema === "object") { + const { schemaId } = this.opts; + id = schema[schemaId]; + if (id !== void 0 && typeof id != "string") { + throw new Error(`schema ${schemaId} must be string`); + } + } + key = (0, resolve_1.normalizeId)(key || id); + this._checkUnique(key); + this.schemas[key] = this._addSchema(schema, _meta, key, _validateSchema, true); + return this; + } + // Add schema that will be used to validate other schemas + // options in META_IGNORE_OPTIONS are alway set to false + addMetaSchema(schema, key, _validateSchema = this.opts.validateSchema) { + this.addSchema(schema, key, true, _validateSchema); + return this; + } + // Validate schema against its meta-schema + validateSchema(schema, throwOrLogError) { + if (typeof schema == "boolean") + return true; + let $schema; + $schema = schema.$schema; + if ($schema !== void 0 && typeof $schema != "string") { + throw new Error("$schema must be a string"); + } + $schema = $schema || this.opts.defaultMeta || this.defaultMeta(); + if (!$schema) { + this.logger.warn("meta-schema not available"); + this.errors = null; + return true; + } + const valid = this.validate($schema, schema); + if (!valid && throwOrLogError) { + const message = "schema is invalid: " + this.errorsText(); + if (this.opts.validateSchema === "log") + this.logger.error(message); + else + throw new Error(message); + } + return valid; + } + // Get compiled schema by `key` or `ref`. + // (`key` that was passed to `addSchema` or full schema reference - `schema.$id` or resolved id) + getSchema(keyRef) { + let sch; + while (typeof (sch = getSchEnv.call(this, keyRef)) == "string") + keyRef = sch; + if (sch === void 0) { + const { schemaId } = this.opts; + const root = new compile_1.SchemaEnv({ schema: {}, schemaId }); + sch = compile_1.resolveSchema.call(this, root, keyRef); + if (!sch) + return; + this.refs[keyRef] = sch; + } + return sch.validate || this._compileSchemaEnv(sch); + } + // Remove cached schema(s). + // If no parameter is passed all schemas but meta-schemas are removed. + // If RegExp is passed all schemas with key/id matching pattern but meta-schemas are removed. + // Even if schema is referenced by other schemas it still can be removed as other schemas have local references. + removeSchema(schemaKeyRef) { + if (schemaKeyRef instanceof RegExp) { + this._removeAllSchemas(this.schemas, schemaKeyRef); + this._removeAllSchemas(this.refs, schemaKeyRef); + return this; + } + switch (typeof schemaKeyRef) { + case "undefined": + this._removeAllSchemas(this.schemas); + this._removeAllSchemas(this.refs); + this._cache.clear(); + return this; + case "string": { + const sch = getSchEnv.call(this, schemaKeyRef); + if (typeof sch == "object") + this._cache.delete(sch.schema); + delete this.schemas[schemaKeyRef]; + delete this.refs[schemaKeyRef]; + return this; + } + case "object": { + const cacheKey = schemaKeyRef; + this._cache.delete(cacheKey); + let id = schemaKeyRef[this.opts.schemaId]; + if (id) { + id = (0, resolve_1.normalizeId)(id); + delete this.schemas[id]; + delete this.refs[id]; + } + return this; + } + default: + throw new Error("ajv.removeSchema: invalid parameter"); + } + } + // add "vocabulary" - a collection of keywords + addVocabulary(definitions) { + for (const def of definitions) + this.addKeyword(def); + return this; + } + addKeyword(kwdOrDef, def) { + let keyword; + if (typeof kwdOrDef == "string") { + keyword = kwdOrDef; + if (typeof def == "object") { + this.logger.warn("these parameters are deprecated, see docs for addKeyword"); + def.keyword = keyword; + } + } else if (typeof kwdOrDef == "object" && def === void 0) { + def = kwdOrDef; + keyword = def.keyword; + if (Array.isArray(keyword) && !keyword.length) { + throw new Error("addKeywords: keyword must be string or non-empty array"); + } + } else { + throw new Error("invalid addKeywords parameters"); + } + checkKeyword.call(this, keyword, def); + if (!def) { + (0, util_1.eachItem)(keyword, (kwd) => addRule.call(this, kwd)); + return this; + } + keywordMetaschema.call(this, def); + const definition = { + ...def, + type: (0, dataType_1.getJSONTypes)(def.type), + schemaType: (0, dataType_1.getJSONTypes)(def.schemaType) + }; + (0, util_1.eachItem)(keyword, definition.type.length === 0 ? (k3) => addRule.call(this, k3, definition) : (k3) => definition.type.forEach((t3) => addRule.call(this, k3, definition, t3))); + return this; + } + getKeyword(keyword) { + const rule = this.RULES.all[keyword]; + return typeof rule == "object" ? rule.definition : !!rule; + } + // Remove keyword + removeKeyword(keyword) { + const { RULES } = this; + delete RULES.keywords[keyword]; + delete RULES.all[keyword]; + for (const group of RULES.rules) { + const i3 = group.rules.findIndex((rule) => rule.keyword === keyword); + if (i3 >= 0) + group.rules.splice(i3, 1); + } + return this; + } + // Add format + addFormat(name, format) { + if (typeof format == "string") + format = new RegExp(format); + this.formats[name] = format; + return this; + } + errorsText(errors = this.errors, { separator = ", ", dataVar = "data" } = {}) { + if (!errors || errors.length === 0) + return "No errors"; + return errors.map((e3) => `${dataVar}${e3.instancePath} ${e3.message}`).reduce((text, msg) => text + separator + msg); + } + $dataMetaSchema(metaSchema, keywordsJsonPointers) { + const rules = this.RULES.all; + metaSchema = JSON.parse(JSON.stringify(metaSchema)); + for (const jsonPointer of keywordsJsonPointers) { + const segments = jsonPointer.split("/").slice(1); + let keywords = metaSchema; + for (const seg of segments) + keywords = keywords[seg]; + for (const key in rules) { + const rule = rules[key]; + if (typeof rule != "object") + continue; + const { $data } = rule.definition; + const schema = keywords[key]; + if ($data && schema) + keywords[key] = schemaOrData(schema); + } + } + return metaSchema; + } + _removeAllSchemas(schemas, regex) { + for (const keyRef in schemas) { + const sch = schemas[keyRef]; + if (!regex || regex.test(keyRef)) { + if (typeof sch == "string") { + delete schemas[keyRef]; + } else if (sch && !sch.meta) { + this._cache.delete(sch.schema); + delete schemas[keyRef]; + } + } + } + } + _addSchema(schema, meta3, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) { + let id; + const { schemaId } = this.opts; + if (typeof schema == "object") { + id = schema[schemaId]; + } else { + if (this.opts.jtd) + throw new Error("schema must be object"); + else if (typeof schema != "boolean") + throw new Error("schema must be object or boolean"); + } + let sch = this._cache.get(schema); + if (sch !== void 0) + return sch; + baseId = (0, resolve_1.normalizeId)(id || baseId); + const localRefs = resolve_1.getSchemaRefs.call(this, schema, baseId); + sch = new compile_1.SchemaEnv({ schema, schemaId, meta: meta3, baseId, localRefs }); + this._cache.set(sch.schema, sch); + if (addSchema && !baseId.startsWith("#")) { + if (baseId) + this._checkUnique(baseId); + this.refs[baseId] = sch; + } + if (validateSchema) + this.validateSchema(schema, true); + return sch; + } + _checkUnique(id) { + if (this.schemas[id] || this.refs[id]) { + throw new Error(`schema with key or id "${id}" already exists`); + } + } + _compileSchemaEnv(sch) { + if (sch.meta) + this._compileMetaSchema(sch); + else + compile_1.compileSchema.call(this, sch); + if (!sch.validate) + throw new Error("ajv implementation error"); + return sch.validate; + } + _compileMetaSchema(sch) { + const currentOpts = this.opts; + this.opts = this._metaOpts; + try { + compile_1.compileSchema.call(this, sch); + } finally { + this.opts = currentOpts; + } + } + }; + Ajv2.ValidationError = validation_error_1.default; + Ajv2.MissingRefError = ref_error_1.default; + exports.default = Ajv2; + function checkOptions(checkOpts, options, msg, log = "error") { + for (const key in checkOpts) { + const opt = key; + if (opt in options) + this.logger[log](`${msg}: option ${key}. ${checkOpts[opt]}`); + } + } + function getSchEnv(keyRef) { + keyRef = (0, resolve_1.normalizeId)(keyRef); + return this.schemas[keyRef] || this.refs[keyRef]; + } + function addInitialSchemas() { + const optsSchemas = this.opts.schemas; + if (!optsSchemas) + return; + if (Array.isArray(optsSchemas)) + this.addSchema(optsSchemas); + else + for (const key in optsSchemas) + this.addSchema(optsSchemas[key], key); + } + function addInitialFormats() { + for (const name in this.opts.formats) { + const format = this.opts.formats[name]; + if (format) + this.addFormat(name, format); + } + } + function addInitialKeywords(defs) { + if (Array.isArray(defs)) { + this.addVocabulary(defs); + return; + } + this.logger.warn("keywords option as map is deprecated, pass array"); + for (const keyword in defs) { + const def = defs[keyword]; + if (!def.keyword) + def.keyword = keyword; + this.addKeyword(def); + } + } + function getMetaSchemaOptions() { + const metaOpts = { ...this.opts }; + for (const opt of META_IGNORE_OPTIONS) + delete metaOpts[opt]; + return metaOpts; + } + var noLogs = { log() { + }, warn() { + }, error() { + } }; + function getLogger(logger) { + if (logger === false) + return noLogs; + if (logger === void 0) + return console; + if (logger.log && logger.warn && logger.error) + return logger; + throw new Error("logger must implement log, warn and error methods"); + } + var KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i; + function checkKeyword(keyword, def) { + const { RULES } = this; + (0, util_1.eachItem)(keyword, (kwd) => { + if (RULES.keywords[kwd]) + throw new Error(`Keyword ${kwd} is already defined`); + if (!KEYWORD_NAME.test(kwd)) + throw new Error(`Keyword ${kwd} has invalid name`); + }); + if (!def) + return; + if (def.$data && !("code" in def || "validate" in def)) { + throw new Error('$data keyword must have "code" or "validate" function'); + } + } + function addRule(keyword, definition, dataType) { + var _a3; + const post = definition === null || definition === void 0 ? void 0 : definition.post; + if (dataType && post) + throw new Error('keyword with "post" flag cannot have "type"'); + const { RULES } = this; + let ruleGroup = post ? RULES.post : RULES.rules.find(({ type: t3 }) => t3 === dataType); + if (!ruleGroup) { + ruleGroup = { type: dataType, rules: [] }; + RULES.rules.push(ruleGroup); + } + RULES.keywords[keyword] = true; + if (!definition) + return; + const rule = { + keyword, + definition: { + ...definition, + type: (0, dataType_1.getJSONTypes)(definition.type), + schemaType: (0, dataType_1.getJSONTypes)(definition.schemaType) + } + }; + if (definition.before) + addBeforeRule.call(this, ruleGroup, rule, definition.before); + else + ruleGroup.rules.push(rule); + RULES.all[keyword] = rule; + (_a3 = definition.implements) === null || _a3 === void 0 ? void 0 : _a3.forEach((kwd) => this.addKeyword(kwd)); + } + function addBeforeRule(ruleGroup, rule, before) { + const i3 = ruleGroup.rules.findIndex((_rule) => _rule.keyword === before); + if (i3 >= 0) { + ruleGroup.rules.splice(i3, 0, rule); + } else { + ruleGroup.rules.push(rule); + this.logger.warn(`rule ${before} is not defined`); + } + } + function keywordMetaschema(def) { + let { metaSchema } = def; + if (metaSchema === void 0) + return; + if (def.$data && this.opts.$data) + metaSchema = schemaOrData(metaSchema); + def.validateSchema = this.compile(metaSchema, true); + } + var $dataRef = { + $ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#" + }; + function schemaOrData(schema) { + return { anyOf: [schema, $dataRef] }; + } + } +}); + +// node_modules/ajv/dist/vocabularies/core/id.js +var require_id = __commonJS({ + "node_modules/ajv/dist/vocabularies/core/id.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var def = { + keyword: "id", + code() { + throw new Error('NOT SUPPORTED: keyword "id", use "$id" for schema ID'); + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/core/ref.js +var require_ref = __commonJS({ + "node_modules/ajv/dist/vocabularies/core/ref.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.callRef = exports.getValidate = void 0; + var ref_error_1 = require_ref_error(); + var code_1 = require_code2(); + var codegen_1 = require_codegen(); + var names_1 = require_names(); + var compile_1 = require_compile(); + var util_1 = require_util(); + var def = { + keyword: "$ref", + schemaType: "string", + code(cxt) { + const { gen, schema: $ref, it } = cxt; + const { baseId, schemaEnv: env, validateName, opts, self: self2 } = it; + const { root } = env; + if (($ref === "#" || $ref === "#/") && baseId === root.baseId) + return callRootRef(); + const schOrEnv = compile_1.resolveRef.call(self2, root, baseId, $ref); + if (schOrEnv === void 0) + throw new ref_error_1.default(it.opts.uriResolver, baseId, $ref); + if (schOrEnv instanceof compile_1.SchemaEnv) + return callValidate(schOrEnv); + return inlineRefSchema(schOrEnv); + function callRootRef() { + if (env === root) + return callRef(cxt, validateName, env, env.$async); + const rootName = gen.scopeValue("root", { ref: root }); + return callRef(cxt, (0, codegen_1._)`${rootName}.validate`, root, root.$async); + } + function callValidate(sch) { + const v2 = getValidate(cxt, sch); + callRef(cxt, v2, sch, sch.$async); + } + function inlineRefSchema(sch) { + const schName = gen.scopeValue("schema", opts.code.source === true ? { ref: sch, code: (0, codegen_1.stringify)(sch) } : { ref: sch }); + const valid = gen.name("valid"); + const schCxt = cxt.subschema({ + schema: sch, + dataTypes: [], + schemaPath: codegen_1.nil, + topSchemaRef: schName, + errSchemaPath: $ref + }, valid); + cxt.mergeEvaluated(schCxt); + cxt.ok(valid); + } + } + }; + function getValidate(cxt, sch) { + const { gen } = cxt; + return sch.validate ? gen.scopeValue("validate", { ref: sch.validate }) : (0, codegen_1._)`${gen.scopeValue("wrapper", { ref: sch })}.validate`; + } + exports.getValidate = getValidate; + function callRef(cxt, v2, sch, $async) { + const { gen, it } = cxt; + const { allErrors, schemaEnv: env, opts } = it; + const passCxt = opts.passContext ? names_1.default.this : codegen_1.nil; + if ($async) + callAsyncRef(); + else + callSyncRef(); + function callAsyncRef() { + if (!env.$async) + throw new Error("async schema referenced by sync schema"); + const valid = gen.let("valid"); + gen.try(() => { + gen.code((0, codegen_1._)`await ${(0, code_1.callValidateCode)(cxt, v2, passCxt)}`); + addEvaluatedFrom(v2); + if (!allErrors) + gen.assign(valid, true); + }, (e3) => { + gen.if((0, codegen_1._)`!(${e3} instanceof ${it.ValidationError})`, () => gen.throw(e3)); + addErrorsFrom(e3); + if (!allErrors) + gen.assign(valid, false); + }); + cxt.ok(valid); + } + function callSyncRef() { + cxt.result((0, code_1.callValidateCode)(cxt, v2, passCxt), () => addEvaluatedFrom(v2), () => addErrorsFrom(v2)); + } + function addErrorsFrom(source) { + const errs = (0, codegen_1._)`${source}.errors`; + gen.assign(names_1.default.vErrors, (0, codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`); + gen.assign(names_1.default.errors, (0, codegen_1._)`${names_1.default.vErrors}.length`); + } + function addEvaluatedFrom(source) { + var _a3; + if (!it.opts.unevaluated) + return; + const schEvaluated = (_a3 = sch === null || sch === void 0 ? void 0 : sch.validate) === null || _a3 === void 0 ? void 0 : _a3.evaluated; + if (it.props !== true) { + if (schEvaluated && !schEvaluated.dynamicProps) { + if (schEvaluated.props !== void 0) { + it.props = util_1.mergeEvaluated.props(gen, schEvaluated.props, it.props); + } + } else { + const props = gen.var("props", (0, codegen_1._)`${source}.evaluated.props`); + it.props = util_1.mergeEvaluated.props(gen, props, it.props, codegen_1.Name); + } + } + if (it.items !== true) { + if (schEvaluated && !schEvaluated.dynamicItems) { + if (schEvaluated.items !== void 0) { + it.items = util_1.mergeEvaluated.items(gen, schEvaluated.items, it.items); + } + } else { + const items = gen.var("items", (0, codegen_1._)`${source}.evaluated.items`); + it.items = util_1.mergeEvaluated.items(gen, items, it.items, codegen_1.Name); + } + } + } + } + exports.callRef = callRef; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/core/index.js +var require_core2 = __commonJS({ + "node_modules/ajv/dist/vocabularies/core/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var id_1 = require_id(); + var ref_1 = require_ref(); + var core = [ + "$schema", + "$id", + "$defs", + "$vocabulary", + { keyword: "$comment" }, + "definitions", + id_1.default, + ref_1.default + ]; + exports.default = core; + } +}); + +// node_modules/ajv/dist/vocabularies/validation/limitNumber.js +var require_limitNumber = __commonJS({ + "node_modules/ajv/dist/vocabularies/validation/limitNumber.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var ops = codegen_1.operators; + var KWDs = { + maximum: { okStr: "<=", ok: ops.LTE, fail: ops.GT }, + minimum: { okStr: ">=", ok: ops.GTE, fail: ops.LT }, + exclusiveMaximum: { okStr: "<", ok: ops.LT, fail: ops.GTE }, + exclusiveMinimum: { okStr: ">", ok: ops.GT, fail: ops.LTE } + }; + var error48 = { + message: ({ keyword, schemaCode }) => (0, codegen_1.str)`must be ${KWDs[keyword].okStr} ${schemaCode}`, + params: ({ keyword, schemaCode }) => (0, codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}` + }; + var def = { + keyword: Object.keys(KWDs), + type: "number", + schemaType: "number", + $data: true, + error: error48, + code(cxt) { + const { keyword, data, schemaCode } = cxt; + cxt.fail$data((0, codegen_1._)`${data} ${KWDs[keyword].fail} ${schemaCode} || isNaN(${data})`); + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/validation/multipleOf.js +var require_multipleOf = __commonJS({ + "node_modules/ajv/dist/vocabularies/validation/multipleOf.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var error48 = { + message: ({ schemaCode }) => (0, codegen_1.str)`must be multiple of ${schemaCode}`, + params: ({ schemaCode }) => (0, codegen_1._)`{multipleOf: ${schemaCode}}` + }; + var def = { + keyword: "multipleOf", + type: "number", + schemaType: "number", + $data: true, + error: error48, + code(cxt) { + const { gen, data, schemaCode, it } = cxt; + const prec = it.opts.multipleOfPrecision; + const res = gen.let("res"); + const invalid = prec ? (0, codegen_1._)`Math.abs(Math.round(${res}) - ${res}) > 1e-${prec}` : (0, codegen_1._)`${res} !== parseInt(${res})`; + cxt.fail$data((0, codegen_1._)`(${schemaCode} === 0 || (${res} = ${data}/${schemaCode}, ${invalid}))`); + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/runtime/ucs2length.js +var require_ucs2length = __commonJS({ + "node_modules/ajv/dist/runtime/ucs2length.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + function ucs2length(str) { + const len = str.length; + let length = 0; + let pos = 0; + let value; + while (pos < len) { + length++; + value = str.charCodeAt(pos++); + if (value >= 55296 && value <= 56319 && pos < len) { + value = str.charCodeAt(pos); + if ((value & 64512) === 56320) + pos++; + } + } + return length; + } + exports.default = ucs2length; + ucs2length.code = 'require("ajv/dist/runtime/ucs2length").default'; + } +}); + +// node_modules/ajv/dist/vocabularies/validation/limitLength.js +var require_limitLength = __commonJS({ + "node_modules/ajv/dist/vocabularies/validation/limitLength.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var ucs2length_1 = require_ucs2length(); + var error48 = { + message({ keyword, schemaCode }) { + const comp = keyword === "maxLength" ? "more" : "fewer"; + return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} characters`; + }, + params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}` + }; + var def = { + keyword: ["maxLength", "minLength"], + type: "string", + schemaType: "number", + $data: true, + error: error48, + code(cxt) { + const { keyword, data, schemaCode, it } = cxt; + const op = keyword === "maxLength" ? codegen_1.operators.GT : codegen_1.operators.LT; + const len = it.opts.unicode === false ? (0, codegen_1._)`${data}.length` : (0, codegen_1._)`${(0, util_1.useFunc)(cxt.gen, ucs2length_1.default)}(${data})`; + cxt.fail$data((0, codegen_1._)`${len} ${op} ${schemaCode}`); + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/validation/pattern.js +var require_pattern = __commonJS({ + "node_modules/ajv/dist/vocabularies/validation/pattern.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var code_1 = require_code2(); + var util_1 = require_util(); + var codegen_1 = require_codegen(); + var error48 = { + message: ({ schemaCode }) => (0, codegen_1.str)`must match pattern "${schemaCode}"`, + params: ({ schemaCode }) => (0, codegen_1._)`{pattern: ${schemaCode}}` + }; + var def = { + keyword: "pattern", + type: "string", + schemaType: "string", + $data: true, + error: error48, + code(cxt) { + const { gen, data, $data, schema, schemaCode, it } = cxt; + const u = it.opts.unicodeRegExp ? "u" : ""; + if ($data) { + const { regExp } = it.opts.code; + const regExpCode = regExp.code === "new RegExp" ? (0, codegen_1._)`new RegExp` : (0, util_1.useFunc)(gen, regExp); + const valid = gen.let("valid"); + gen.try(() => gen.assign(valid, (0, codegen_1._)`${regExpCode}(${schemaCode}, ${u}).test(${data})`), () => gen.assign(valid, false)); + cxt.fail$data((0, codegen_1._)`!${valid}`); + } else { + const regExp = (0, code_1.usePattern)(cxt, schema); + cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`); + } + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/validation/limitProperties.js +var require_limitProperties = __commonJS({ + "node_modules/ajv/dist/vocabularies/validation/limitProperties.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var error48 = { + message({ keyword, schemaCode }) { + const comp = keyword === "maxProperties" ? "more" : "fewer"; + return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} properties`; + }, + params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}` + }; + var def = { + keyword: ["maxProperties", "minProperties"], + type: "object", + schemaType: "number", + $data: true, + error: error48, + code(cxt) { + const { keyword, data, schemaCode } = cxt; + const op = keyword === "maxProperties" ? codegen_1.operators.GT : codegen_1.operators.LT; + cxt.fail$data((0, codegen_1._)`Object.keys(${data}).length ${op} ${schemaCode}`); + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/validation/required.js +var require_required = __commonJS({ + "node_modules/ajv/dist/vocabularies/validation/required.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var code_1 = require_code2(); + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var error48 = { + message: ({ params: { missingProperty } }) => (0, codegen_1.str)`must have required property '${missingProperty}'`, + params: ({ params: { missingProperty } }) => (0, codegen_1._)`{missingProperty: ${missingProperty}}` + }; + var def = { + keyword: "required", + type: "object", + schemaType: "array", + $data: true, + error: error48, + code(cxt) { + const { gen, schema, schemaCode, data, $data, it } = cxt; + const { opts } = it; + if (!$data && schema.length === 0) + return; + const useLoop = schema.length >= opts.loopRequired; + if (it.allErrors) + allErrorsMode(); + else + exitOnErrorMode(); + if (opts.strictRequired) { + const props = cxt.parentSchema.properties; + const { definedProperties } = cxt.it; + for (const requiredKey of schema) { + if ((props === null || props === void 0 ? void 0 : props[requiredKey]) === void 0 && !definedProperties.has(requiredKey)) { + const schemaPath = it.schemaEnv.baseId + it.errSchemaPath; + const msg = `required property "${requiredKey}" is not defined at "${schemaPath}" (strictRequired)`; + (0, util_1.checkStrictMode)(it, msg, it.opts.strictRequired); + } + } + } + function allErrorsMode() { + if (useLoop || $data) { + cxt.block$data(codegen_1.nil, loopAllRequired); + } else { + for (const prop of schema) { + (0, code_1.checkReportMissingProp)(cxt, prop); + } + } + } + function exitOnErrorMode() { + const missing = gen.let("missing"); + if (useLoop || $data) { + const valid = gen.let("valid", true); + cxt.block$data(valid, () => loopUntilMissing(missing, valid)); + cxt.ok(valid); + } else { + gen.if((0, code_1.checkMissingProp)(cxt, schema, missing)); + (0, code_1.reportMissingProp)(cxt, missing); + gen.else(); + } + } + function loopAllRequired() { + gen.forOf("prop", schemaCode, (prop) => { + cxt.setParams({ missingProperty: prop }); + gen.if((0, code_1.noPropertyInData)(gen, data, prop, opts.ownProperties), () => cxt.error()); + }); + } + function loopUntilMissing(missing, valid) { + cxt.setParams({ missingProperty: missing }); + gen.forOf(missing, schemaCode, () => { + gen.assign(valid, (0, code_1.propertyInData)(gen, data, missing, opts.ownProperties)); + gen.if((0, codegen_1.not)(valid), () => { + cxt.error(); + gen.break(); + }); + }, codegen_1.nil); + } + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/validation/limitItems.js +var require_limitItems = __commonJS({ + "node_modules/ajv/dist/vocabularies/validation/limitItems.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var error48 = { + message({ keyword, schemaCode }) { + const comp = keyword === "maxItems" ? "more" : "fewer"; + return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} items`; + }, + params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}` + }; + var def = { + keyword: ["maxItems", "minItems"], + type: "array", + schemaType: "number", + $data: true, + error: error48, + code(cxt) { + const { keyword, data, schemaCode } = cxt; + const op = keyword === "maxItems" ? codegen_1.operators.GT : codegen_1.operators.LT; + cxt.fail$data((0, codegen_1._)`${data}.length ${op} ${schemaCode}`); + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/runtime/equal.js +var require_equal = __commonJS({ + "node_modules/ajv/dist/runtime/equal.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var equal = require_fast_deep_equal(); + equal.code = 'require("ajv/dist/runtime/equal").default'; + exports.default = equal; + } +}); + +// node_modules/ajv/dist/vocabularies/validation/uniqueItems.js +var require_uniqueItems = __commonJS({ + "node_modules/ajv/dist/vocabularies/validation/uniqueItems.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var dataType_1 = require_dataType(); + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var equal_1 = require_equal(); + var error48 = { + message: ({ params: { i: i3, j } }) => (0, codegen_1.str)`must NOT have duplicate items (items ## ${j} and ${i3} are identical)`, + params: ({ params: { i: i3, j } }) => (0, codegen_1._)`{i: ${i3}, j: ${j}}` + }; + var def = { + keyword: "uniqueItems", + type: "array", + schemaType: "boolean", + $data: true, + error: error48, + code(cxt) { + const { gen, data, $data, schema, parentSchema, schemaCode, it } = cxt; + if (!$data && !schema) + return; + const valid = gen.let("valid"); + const itemTypes = parentSchema.items ? (0, dataType_1.getSchemaTypes)(parentSchema.items) : []; + cxt.block$data(valid, validateUniqueItems, (0, codegen_1._)`${schemaCode} === false`); + cxt.ok(valid); + function validateUniqueItems() { + const i3 = gen.let("i", (0, codegen_1._)`${data}.length`); + const j = gen.let("j"); + cxt.setParams({ i: i3, j }); + gen.assign(valid, true); + gen.if((0, codegen_1._)`${i3} > 1`, () => (canOptimize() ? loopN : loopN2)(i3, j)); + } + function canOptimize() { + return itemTypes.length > 0 && !itemTypes.some((t3) => t3 === "object" || t3 === "array"); + } + function loopN(i3, j) { + const item = gen.name("item"); + const wrongType = (0, dataType_1.checkDataTypes)(itemTypes, item, it.opts.strictNumbers, dataType_1.DataType.Wrong); + const indices = gen.const("indices", (0, codegen_1._)`{}`); + gen.for((0, codegen_1._)`;${i3}--;`, () => { + gen.let(item, (0, codegen_1._)`${data}[${i3}]`); + gen.if(wrongType, (0, codegen_1._)`continue`); + if (itemTypes.length > 1) + gen.if((0, codegen_1._)`typeof ${item} == "string"`, (0, codegen_1._)`${item} += "_"`); + gen.if((0, codegen_1._)`typeof ${indices}[${item}] == "number"`, () => { + gen.assign(j, (0, codegen_1._)`${indices}[${item}]`); + cxt.error(); + gen.assign(valid, false).break(); + }).code((0, codegen_1._)`${indices}[${item}] = ${i3}`); + }); + } + function loopN2(i3, j) { + const eql = (0, util_1.useFunc)(gen, equal_1.default); + const outer = gen.name("outer"); + gen.label(outer).for((0, codegen_1._)`;${i3}--;`, () => gen.for((0, codegen_1._)`${j} = ${i3}; ${j}--;`, () => gen.if((0, codegen_1._)`${eql}(${data}[${i3}], ${data}[${j}])`, () => { + cxt.error(); + gen.assign(valid, false).break(outer); + }))); + } + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/validation/const.js +var require_const = __commonJS({ + "node_modules/ajv/dist/vocabularies/validation/const.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var equal_1 = require_equal(); + var error48 = { + message: "must be equal to constant", + params: ({ schemaCode }) => (0, codegen_1._)`{allowedValue: ${schemaCode}}` + }; + var def = { + keyword: "const", + $data: true, + error: error48, + code(cxt) { + const { gen, data, $data, schemaCode, schema } = cxt; + if ($data || schema && typeof schema == "object") { + cxt.fail$data((0, codegen_1._)`!${(0, util_1.useFunc)(gen, equal_1.default)}(${data}, ${schemaCode})`); + } else { + cxt.fail((0, codegen_1._)`${schema} !== ${data}`); + } + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/validation/enum.js +var require_enum = __commonJS({ + "node_modules/ajv/dist/vocabularies/validation/enum.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var equal_1 = require_equal(); + var error48 = { + message: "must be equal to one of the allowed values", + params: ({ schemaCode }) => (0, codegen_1._)`{allowedValues: ${schemaCode}}` + }; + var def = { + keyword: "enum", + schemaType: "array", + $data: true, + error: error48, + code(cxt) { + const { gen, data, $data, schema, schemaCode, it } = cxt; + if (!$data && schema.length === 0) + throw new Error("enum must have non-empty array"); + const useLoop = schema.length >= it.opts.loopEnum; + let eql; + const getEql = () => eql !== null && eql !== void 0 ? eql : eql = (0, util_1.useFunc)(gen, equal_1.default); + let valid; + if (useLoop || $data) { + valid = gen.let("valid"); + cxt.block$data(valid, loopEnum); + } else { + if (!Array.isArray(schema)) + throw new Error("ajv implementation error"); + const vSchema = gen.const("vSchema", schemaCode); + valid = (0, codegen_1.or)(...schema.map((_x, i3) => equalCode(vSchema, i3))); + } + cxt.pass(valid); + function loopEnum() { + gen.assign(valid, false); + gen.forOf("v", schemaCode, (v2) => gen.if((0, codegen_1._)`${getEql()}(${data}, ${v2})`, () => gen.assign(valid, true).break())); + } + function equalCode(vSchema, i3) { + const sch = schema[i3]; + return typeof sch === "object" && sch !== null ? (0, codegen_1._)`${getEql()}(${data}, ${vSchema}[${i3}])` : (0, codegen_1._)`${data} === ${sch}`; + } + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/validation/index.js +var require_validation = __commonJS({ + "node_modules/ajv/dist/vocabularies/validation/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var limitNumber_1 = require_limitNumber(); + var multipleOf_1 = require_multipleOf(); + var limitLength_1 = require_limitLength(); + var pattern_1 = require_pattern(); + var limitProperties_1 = require_limitProperties(); + var required_1 = require_required(); + var limitItems_1 = require_limitItems(); + var uniqueItems_1 = require_uniqueItems(); + var const_1 = require_const(); + var enum_1 = require_enum(); + var validation = [ + // number + limitNumber_1.default, + multipleOf_1.default, + // string + limitLength_1.default, + pattern_1.default, + // object + limitProperties_1.default, + required_1.default, + // array + limitItems_1.default, + uniqueItems_1.default, + // any + { keyword: "type", schemaType: ["string", "array"] }, + { keyword: "nullable", schemaType: "boolean" }, + const_1.default, + enum_1.default + ]; + exports.default = validation; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/additionalItems.js +var require_additionalItems = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/additionalItems.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.validateAdditionalItems = void 0; + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var error48 = { + message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`, + params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}` + }; + var def = { + keyword: "additionalItems", + type: "array", + schemaType: ["boolean", "object"], + before: "uniqueItems", + error: error48, + code(cxt) { + const { parentSchema, it } = cxt; + const { items } = parentSchema; + if (!Array.isArray(items)) { + (0, util_1.checkStrictMode)(it, '"additionalItems" is ignored when "items" is not an array of schemas'); + return; + } + validateAdditionalItems(cxt, items); + } + }; + function validateAdditionalItems(cxt, items) { + const { gen, schema, data, keyword, it } = cxt; + it.items = true; + const len = gen.const("len", (0, codegen_1._)`${data}.length`); + if (schema === false) { + cxt.setParams({ len: items.length }); + cxt.pass((0, codegen_1._)`${len} <= ${items.length}`); + } else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) { + const valid = gen.var("valid", (0, codegen_1._)`${len} <= ${items.length}`); + gen.if((0, codegen_1.not)(valid), () => validateItems(valid)); + cxt.ok(valid); + } + function validateItems(valid) { + gen.forRange("i", items.length, len, (i3) => { + cxt.subschema({ keyword, dataProp: i3, dataPropType: util_1.Type.Num }, valid); + if (!it.allErrors) + gen.if((0, codegen_1.not)(valid), () => gen.break()); + }); + } + } + exports.validateAdditionalItems = validateAdditionalItems; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/items.js +var require_items = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/items.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.validateTuple = void 0; + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var code_1 = require_code2(); + var def = { + keyword: "items", + type: "array", + schemaType: ["object", "array", "boolean"], + before: "uniqueItems", + code(cxt) { + const { schema, it } = cxt; + if (Array.isArray(schema)) + return validateTuple(cxt, "additionalItems", schema); + it.items = true; + if ((0, util_1.alwaysValidSchema)(it, schema)) + return; + cxt.ok((0, code_1.validateArray)(cxt)); + } + }; + function validateTuple(cxt, extraItems, schArr = cxt.schema) { + const { gen, parentSchema, data, keyword, it } = cxt; + checkStrictTuple(parentSchema); + if (it.opts.unevaluated && schArr.length && it.items !== true) { + it.items = util_1.mergeEvaluated.items(gen, schArr.length, it.items); + } + const valid = gen.name("valid"); + const len = gen.const("len", (0, codegen_1._)`${data}.length`); + schArr.forEach((sch, i3) => { + if ((0, util_1.alwaysValidSchema)(it, sch)) + return; + gen.if((0, codegen_1._)`${len} > ${i3}`, () => cxt.subschema({ + keyword, + schemaProp: i3, + dataProp: i3 + }, valid)); + cxt.ok(valid); + }); + function checkStrictTuple(sch) { + const { opts, errSchemaPath } = it; + const l3 = schArr.length; + const fullTuple = l3 === sch.minItems && (l3 === sch.maxItems || sch[extraItems] === false); + if (opts.strictTuples && !fullTuple) { + const msg = `"${keyword}" is ${l3}-tuple, but minItems or maxItems/${extraItems} are not specified or different at path "${errSchemaPath}"`; + (0, util_1.checkStrictMode)(it, msg, opts.strictTuples); + } + } + } + exports.validateTuple = validateTuple; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/prefixItems.js +var require_prefixItems = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/prefixItems.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var items_1 = require_items(); + var def = { + keyword: "prefixItems", + type: "array", + schemaType: ["array"], + before: "uniqueItems", + code: (cxt) => (0, items_1.validateTuple)(cxt, "items") + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/items2020.js +var require_items2020 = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/items2020.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var code_1 = require_code2(); + var additionalItems_1 = require_additionalItems(); + var error48 = { + message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`, + params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}` + }; + var def = { + keyword: "items", + type: "array", + schemaType: ["object", "boolean"], + before: "uniqueItems", + error: error48, + code(cxt) { + const { schema, parentSchema, it } = cxt; + const { prefixItems } = parentSchema; + it.items = true; + if ((0, util_1.alwaysValidSchema)(it, schema)) + return; + if (prefixItems) + (0, additionalItems_1.validateAdditionalItems)(cxt, prefixItems); + else + cxt.ok((0, code_1.validateArray)(cxt)); + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/contains.js +var require_contains = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/contains.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var error48 = { + message: ({ params: { min, max } }) => max === void 0 ? (0, codegen_1.str)`must contain at least ${min} valid item(s)` : (0, codegen_1.str)`must contain at least ${min} and no more than ${max} valid item(s)`, + params: ({ params: { min, max } }) => max === void 0 ? (0, codegen_1._)`{minContains: ${min}}` : (0, codegen_1._)`{minContains: ${min}, maxContains: ${max}}` + }; + var def = { + keyword: "contains", + type: "array", + schemaType: ["object", "boolean"], + before: "uniqueItems", + trackErrors: true, + error: error48, + code(cxt) { + const { gen, schema, parentSchema, data, it } = cxt; + let min; + let max; + const { minContains, maxContains } = parentSchema; + if (it.opts.next) { + min = minContains === void 0 ? 1 : minContains; + max = maxContains; + } else { + min = 1; + } + const len = gen.const("len", (0, codegen_1._)`${data}.length`); + cxt.setParams({ min, max }); + if (max === void 0 && min === 0) { + (0, util_1.checkStrictMode)(it, `"minContains" == 0 without "maxContains": "contains" keyword ignored`); + return; + } + if (max !== void 0 && min > max) { + (0, util_1.checkStrictMode)(it, `"minContains" > "maxContains" is always invalid`); + cxt.fail(); + return; + } + if ((0, util_1.alwaysValidSchema)(it, schema)) { + let cond = (0, codegen_1._)`${len} >= ${min}`; + if (max !== void 0) + cond = (0, codegen_1._)`${cond} && ${len} <= ${max}`; + cxt.pass(cond); + return; + } + it.items = true; + const valid = gen.name("valid"); + if (max === void 0 && min === 1) { + validateItems(valid, () => gen.if(valid, () => gen.break())); + } else if (min === 0) { + gen.let(valid, true); + if (max !== void 0) + gen.if((0, codegen_1._)`${data}.length > 0`, validateItemsWithCount); + } else { + gen.let(valid, false); + validateItemsWithCount(); + } + cxt.result(valid, () => cxt.reset()); + function validateItemsWithCount() { + const schValid = gen.name("_valid"); + const count = gen.let("count", 0); + validateItems(schValid, () => gen.if(schValid, () => checkLimits(count))); + } + function validateItems(_valid, block) { + gen.forRange("i", 0, len, (i3) => { + cxt.subschema({ + keyword: "contains", + dataProp: i3, + dataPropType: util_1.Type.Num, + compositeRule: true + }, _valid); + block(); + }); + } + function checkLimits(count) { + gen.code((0, codegen_1._)`${count}++`); + if (max === void 0) { + gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true).break()); + } else { + gen.if((0, codegen_1._)`${count} > ${max}`, () => gen.assign(valid, false).break()); + if (min === 1) + gen.assign(valid, true); + else + gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true)); + } + } + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/dependencies.js +var require_dependencies = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/dependencies.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.validateSchemaDeps = exports.validatePropertyDeps = exports.error = void 0; + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var code_1 = require_code2(); + exports.error = { + message: ({ params: { property, depsCount, deps } }) => { + const property_ies = depsCount === 1 ? "property" : "properties"; + return (0, codegen_1.str)`must have ${property_ies} ${deps} when property ${property} is present`; + }, + params: ({ params: { property, depsCount, deps, missingProperty } }) => (0, codegen_1._)`{property: ${property}, + missingProperty: ${missingProperty}, + depsCount: ${depsCount}, + deps: ${deps}}` + // TODO change to reference + }; + var def = { + keyword: "dependencies", + type: "object", + schemaType: "object", + error: exports.error, + code(cxt) { + const [propDeps, schDeps] = splitDependencies(cxt); + validatePropertyDeps(cxt, propDeps); + validateSchemaDeps(cxt, schDeps); + } + }; + function splitDependencies({ schema }) { + const propertyDeps = {}; + const schemaDeps = {}; + for (const key in schema) { + if (key === "__proto__") + continue; + const deps = Array.isArray(schema[key]) ? propertyDeps : schemaDeps; + deps[key] = schema[key]; + } + return [propertyDeps, schemaDeps]; + } + function validatePropertyDeps(cxt, propertyDeps = cxt.schema) { + const { gen, data, it } = cxt; + if (Object.keys(propertyDeps).length === 0) + return; + const missing = gen.let("missing"); + for (const prop in propertyDeps) { + const deps = propertyDeps[prop]; + if (deps.length === 0) + continue; + const hasProperty = (0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties); + cxt.setParams({ + property: prop, + depsCount: deps.length, + deps: deps.join(", ") + }); + if (it.allErrors) { + gen.if(hasProperty, () => { + for (const depProp of deps) { + (0, code_1.checkReportMissingProp)(cxt, depProp); + } + }); + } else { + gen.if((0, codegen_1._)`${hasProperty} && (${(0, code_1.checkMissingProp)(cxt, deps, missing)})`); + (0, code_1.reportMissingProp)(cxt, missing); + gen.else(); + } + } + } + exports.validatePropertyDeps = validatePropertyDeps; + function validateSchemaDeps(cxt, schemaDeps = cxt.schema) { + const { gen, data, keyword, it } = cxt; + const valid = gen.name("valid"); + for (const prop in schemaDeps) { + if ((0, util_1.alwaysValidSchema)(it, schemaDeps[prop])) + continue; + gen.if( + (0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties), + () => { + const schCxt = cxt.subschema({ keyword, schemaProp: prop }, valid); + cxt.mergeValidEvaluated(schCxt, valid); + }, + () => gen.var(valid, true) + // TODO var + ); + cxt.ok(valid); + } + } + exports.validateSchemaDeps = validateSchemaDeps; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/propertyNames.js +var require_propertyNames = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/propertyNames.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var error48 = { + message: "property name must be valid", + params: ({ params }) => (0, codegen_1._)`{propertyName: ${params.propertyName}}` + }; + var def = { + keyword: "propertyNames", + type: "object", + schemaType: ["object", "boolean"], + error: error48, + code(cxt) { + const { gen, schema, data, it } = cxt; + if ((0, util_1.alwaysValidSchema)(it, schema)) + return; + const valid = gen.name("valid"); + gen.forIn("key", data, (key) => { + cxt.setParams({ propertyName: key }); + cxt.subschema({ + keyword: "propertyNames", + data: key, + dataTypes: ["string"], + propertyName: key, + compositeRule: true + }, valid); + gen.if((0, codegen_1.not)(valid), () => { + cxt.error(true); + if (!it.allErrors) + gen.break(); + }); + }); + cxt.ok(valid); + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/additionalProperties.js +var require_additionalProperties = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/additionalProperties.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var code_1 = require_code2(); + var codegen_1 = require_codegen(); + var names_1 = require_names(); + var util_1 = require_util(); + var error48 = { + message: "must NOT have additional properties", + params: ({ params }) => (0, codegen_1._)`{additionalProperty: ${params.additionalProperty}}` + }; + var def = { + keyword: "additionalProperties", + type: ["object"], + schemaType: ["boolean", "object"], + allowUndefined: true, + trackErrors: true, + error: error48, + code(cxt) { + const { gen, schema, parentSchema, data, errsCount, it } = cxt; + if (!errsCount) + throw new Error("ajv implementation error"); + const { allErrors, opts } = it; + it.props = true; + if (opts.removeAdditional !== "all" && (0, util_1.alwaysValidSchema)(it, schema)) + return; + const props = (0, code_1.allSchemaProperties)(parentSchema.properties); + const patProps = (0, code_1.allSchemaProperties)(parentSchema.patternProperties); + checkAdditionalProperties(); + cxt.ok((0, codegen_1._)`${errsCount} === ${names_1.default.errors}`); + function checkAdditionalProperties() { + gen.forIn("key", data, (key) => { + if (!props.length && !patProps.length) + additionalPropertyCode(key); + else + gen.if(isAdditional(key), () => additionalPropertyCode(key)); + }); + } + function isAdditional(key) { + let definedProp; + if (props.length > 8) { + const propsSchema = (0, util_1.schemaRefOrVal)(it, parentSchema.properties, "properties"); + definedProp = (0, code_1.isOwnProperty)(gen, propsSchema, key); + } else if (props.length) { + definedProp = (0, codegen_1.or)(...props.map((p) => (0, codegen_1._)`${key} === ${p}`)); + } else { + definedProp = codegen_1.nil; + } + if (patProps.length) { + definedProp = (0, codegen_1.or)(definedProp, ...patProps.map((p) => (0, codegen_1._)`${(0, code_1.usePattern)(cxt, p)}.test(${key})`)); + } + return (0, codegen_1.not)(definedProp); + } + function deleteAdditional(key) { + gen.code((0, codegen_1._)`delete ${data}[${key}]`); + } + function additionalPropertyCode(key) { + if (opts.removeAdditional === "all" || opts.removeAdditional && schema === false) { + deleteAdditional(key); + return; + } + if (schema === false) { + cxt.setParams({ additionalProperty: key }); + cxt.error(); + if (!allErrors) + gen.break(); + return; + } + if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) { + const valid = gen.name("valid"); + if (opts.removeAdditional === "failing") { + applyAdditionalSchema(key, valid, false); + gen.if((0, codegen_1.not)(valid), () => { + cxt.reset(); + deleteAdditional(key); + }); + } else { + applyAdditionalSchema(key, valid); + if (!allErrors) + gen.if((0, codegen_1.not)(valid), () => gen.break()); + } + } + } + function applyAdditionalSchema(key, valid, errors) { + const subschema = { + keyword: "additionalProperties", + dataProp: key, + dataPropType: util_1.Type.Str + }; + if (errors === false) { + Object.assign(subschema, { + compositeRule: true, + createErrors: false, + allErrors: false + }); + } + cxt.subschema(subschema, valid); + } + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/properties.js +var require_properties = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/properties.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var validate_1 = require_validate(); + var code_1 = require_code2(); + var util_1 = require_util(); + var additionalProperties_1 = require_additionalProperties(); + var def = { + keyword: "properties", + type: "object", + schemaType: "object", + code(cxt) { + const { gen, schema, parentSchema, data, it } = cxt; + if (it.opts.removeAdditional === "all" && parentSchema.additionalProperties === void 0) { + additionalProperties_1.default.code(new validate_1.KeywordCxt(it, additionalProperties_1.default, "additionalProperties")); + } + const allProps = (0, code_1.allSchemaProperties)(schema); + for (const prop of allProps) { + it.definedProperties.add(prop); + } + if (it.opts.unevaluated && allProps.length && it.props !== true) { + it.props = util_1.mergeEvaluated.props(gen, (0, util_1.toHash)(allProps), it.props); + } + const properties = allProps.filter((p) => !(0, util_1.alwaysValidSchema)(it, schema[p])); + if (properties.length === 0) + return; + const valid = gen.name("valid"); + for (const prop of properties) { + if (hasDefault(prop)) { + applyPropertySchema(prop); + } else { + gen.if((0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties)); + applyPropertySchema(prop); + if (!it.allErrors) + gen.else().var(valid, true); + gen.endIf(); + } + cxt.it.definedProperties.add(prop); + cxt.ok(valid); + } + function hasDefault(prop) { + return it.opts.useDefaults && !it.compositeRule && schema[prop].default !== void 0; + } + function applyPropertySchema(prop) { + cxt.subschema({ + keyword: "properties", + schemaProp: prop, + dataProp: prop + }, valid); + } + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/patternProperties.js +var require_patternProperties = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/patternProperties.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var code_1 = require_code2(); + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var util_2 = require_util(); + var def = { + keyword: "patternProperties", + type: "object", + schemaType: "object", + code(cxt) { + const { gen, schema, data, parentSchema, it } = cxt; + const { opts } = it; + const patterns = (0, code_1.allSchemaProperties)(schema); + const alwaysValidPatterns = patterns.filter((p) => (0, util_1.alwaysValidSchema)(it, schema[p])); + if (patterns.length === 0 || alwaysValidPatterns.length === patterns.length && (!it.opts.unevaluated || it.props === true)) { + return; + } + const checkProperties = opts.strictSchema && !opts.allowMatchingProperties && parentSchema.properties; + const valid = gen.name("valid"); + if (it.props !== true && !(it.props instanceof codegen_1.Name)) { + it.props = (0, util_2.evaluatedPropsToName)(gen, it.props); + } + const { props } = it; + validatePatternProperties(); + function validatePatternProperties() { + for (const pat of patterns) { + if (checkProperties) + checkMatchingProperties(pat); + if (it.allErrors) { + validateProperties(pat); + } else { + gen.var(valid, true); + validateProperties(pat); + gen.if(valid); + } + } + } + function checkMatchingProperties(pat) { + for (const prop in checkProperties) { + if (new RegExp(pat).test(prop)) { + (0, util_1.checkStrictMode)(it, `property ${prop} matches pattern ${pat} (use allowMatchingProperties)`); + } + } + } + function validateProperties(pat) { + gen.forIn("key", data, (key) => { + gen.if((0, codegen_1._)`${(0, code_1.usePattern)(cxt, pat)}.test(${key})`, () => { + const alwaysValid = alwaysValidPatterns.includes(pat); + if (!alwaysValid) { + cxt.subschema({ + keyword: "patternProperties", + schemaProp: pat, + dataProp: key, + dataPropType: util_2.Type.Str + }, valid); + } + if (it.opts.unevaluated && props !== true) { + gen.assign((0, codegen_1._)`${props}[${key}]`, true); + } else if (!alwaysValid && !it.allErrors) { + gen.if((0, codegen_1.not)(valid), () => gen.break()); + } + }); + }); + } + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/not.js +var require_not = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/not.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var util_1 = require_util(); + var def = { + keyword: "not", + schemaType: ["object", "boolean"], + trackErrors: true, + code(cxt) { + const { gen, schema, it } = cxt; + if ((0, util_1.alwaysValidSchema)(it, schema)) { + cxt.fail(); + return; + } + const valid = gen.name("valid"); + cxt.subschema({ + keyword: "not", + compositeRule: true, + createErrors: false, + allErrors: false + }, valid); + cxt.failResult(valid, () => cxt.reset(), () => cxt.error()); + }, + error: { message: "must NOT be valid" } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/anyOf.js +var require_anyOf = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/anyOf.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var code_1 = require_code2(); + var def = { + keyword: "anyOf", + schemaType: "array", + trackErrors: true, + code: code_1.validateUnion, + error: { message: "must match a schema in anyOf" } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/oneOf.js +var require_oneOf = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/oneOf.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var error48 = { + message: "must match exactly one schema in oneOf", + params: ({ params }) => (0, codegen_1._)`{passingSchemas: ${params.passing}}` + }; + var def = { + keyword: "oneOf", + schemaType: "array", + trackErrors: true, + error: error48, + code(cxt) { + const { gen, schema, parentSchema, it } = cxt; + if (!Array.isArray(schema)) + throw new Error("ajv implementation error"); + if (it.opts.discriminator && parentSchema.discriminator) + return; + const schArr = schema; + const valid = gen.let("valid", false); + const passing = gen.let("passing", null); + const schValid = gen.name("_valid"); + cxt.setParams({ passing }); + gen.block(validateOneOf); + cxt.result(valid, () => cxt.reset(), () => cxt.error(true)); + function validateOneOf() { + schArr.forEach((sch, i3) => { + let schCxt; + if ((0, util_1.alwaysValidSchema)(it, sch)) { + gen.var(schValid, true); + } else { + schCxt = cxt.subschema({ + keyword: "oneOf", + schemaProp: i3, + compositeRule: true + }, schValid); + } + if (i3 > 0) { + gen.if((0, codegen_1._)`${schValid} && ${valid}`).assign(valid, false).assign(passing, (0, codegen_1._)`[${passing}, ${i3}]`).else(); + } + gen.if(schValid, () => { + gen.assign(valid, true); + gen.assign(passing, i3); + if (schCxt) + cxt.mergeEvaluated(schCxt, codegen_1.Name); + }); + }); + } + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/allOf.js +var require_allOf = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/allOf.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var util_1 = require_util(); + var def = { + keyword: "allOf", + schemaType: "array", + code(cxt) { + const { gen, schema, it } = cxt; + if (!Array.isArray(schema)) + throw new Error("ajv implementation error"); + const valid = gen.name("valid"); + schema.forEach((sch, i3) => { + if ((0, util_1.alwaysValidSchema)(it, sch)) + return; + const schCxt = cxt.subschema({ keyword: "allOf", schemaProp: i3 }, valid); + cxt.ok(valid); + cxt.mergeEvaluated(schCxt); + }); + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/if.js +var require_if = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/if.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var error48 = { + message: ({ params }) => (0, codegen_1.str)`must match "${params.ifClause}" schema`, + params: ({ params }) => (0, codegen_1._)`{failingKeyword: ${params.ifClause}}` + }; + var def = { + keyword: "if", + schemaType: ["object", "boolean"], + trackErrors: true, + error: error48, + code(cxt) { + const { gen, parentSchema, it } = cxt; + if (parentSchema.then === void 0 && parentSchema.else === void 0) { + (0, util_1.checkStrictMode)(it, '"if" without "then" and "else" is ignored'); + } + const hasThen = hasSchema(it, "then"); + const hasElse = hasSchema(it, "else"); + if (!hasThen && !hasElse) + return; + const valid = gen.let("valid", true); + const schValid = gen.name("_valid"); + validateIf(); + cxt.reset(); + if (hasThen && hasElse) { + const ifClause = gen.let("ifClause"); + cxt.setParams({ ifClause }); + gen.if(schValid, validateClause("then", ifClause), validateClause("else", ifClause)); + } else if (hasThen) { + gen.if(schValid, validateClause("then")); + } else { + gen.if((0, codegen_1.not)(schValid), validateClause("else")); + } + cxt.pass(valid, () => cxt.error(true)); + function validateIf() { + const schCxt = cxt.subschema({ + keyword: "if", + compositeRule: true, + createErrors: false, + allErrors: false + }, schValid); + cxt.mergeEvaluated(schCxt); + } + function validateClause(keyword, ifClause) { + return () => { + const schCxt = cxt.subschema({ keyword }, schValid); + gen.assign(valid, schValid); + cxt.mergeValidEvaluated(schCxt, valid); + if (ifClause) + gen.assign(ifClause, (0, codegen_1._)`${keyword}`); + else + cxt.setParams({ ifClause: keyword }); + }; + } + } + }; + function hasSchema(it, keyword) { + const schema = it.schema[keyword]; + return schema !== void 0 && !(0, util_1.alwaysValidSchema)(it, schema); + } + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/thenElse.js +var require_thenElse = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/thenElse.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var util_1 = require_util(); + var def = { + keyword: ["then", "else"], + schemaType: ["object", "boolean"], + code({ keyword, parentSchema, it }) { + if (parentSchema.if === void 0) + (0, util_1.checkStrictMode)(it, `"${keyword}" without "if" is ignored`); + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/index.js +var require_applicator = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var additionalItems_1 = require_additionalItems(); + var prefixItems_1 = require_prefixItems(); + var items_1 = require_items(); + var items2020_1 = require_items2020(); + var contains_1 = require_contains(); + var dependencies_1 = require_dependencies(); + var propertyNames_1 = require_propertyNames(); + var additionalProperties_1 = require_additionalProperties(); + var properties_1 = require_properties(); + var patternProperties_1 = require_patternProperties(); + var not_1 = require_not(); + var anyOf_1 = require_anyOf(); + var oneOf_1 = require_oneOf(); + var allOf_1 = require_allOf(); + var if_1 = require_if(); + var thenElse_1 = require_thenElse(); + function getApplicator(draft2020 = false) { + const applicator = [ + // any + not_1.default, + anyOf_1.default, + oneOf_1.default, + allOf_1.default, + if_1.default, + thenElse_1.default, + // object + propertyNames_1.default, + additionalProperties_1.default, + dependencies_1.default, + properties_1.default, + patternProperties_1.default + ]; + if (draft2020) + applicator.push(prefixItems_1.default, items2020_1.default); + else + applicator.push(additionalItems_1.default, items_1.default); + applicator.push(contains_1.default); + return applicator; + } + exports.default = getApplicator; + } +}); + +// node_modules/ajv/dist/vocabularies/format/format.js +var require_format = __commonJS({ + "node_modules/ajv/dist/vocabularies/format/format.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var error48 = { + message: ({ schemaCode }) => (0, codegen_1.str)`must match format "${schemaCode}"`, + params: ({ schemaCode }) => (0, codegen_1._)`{format: ${schemaCode}}` + }; + var def = { + keyword: "format", + type: ["number", "string"], + schemaType: "string", + $data: true, + error: error48, + code(cxt, ruleType) { + const { gen, data, $data, schema, schemaCode, it } = cxt; + const { opts, errSchemaPath, schemaEnv, self: self2 } = it; + if (!opts.validateFormats) + return; + if ($data) + validate$DataFormat(); + else + validateFormat(); + function validate$DataFormat() { + const fmts = gen.scopeValue("formats", { + ref: self2.formats, + code: opts.code.formats + }); + const fDef = gen.const("fDef", (0, codegen_1._)`${fmts}[${schemaCode}]`); + const fType = gen.let("fType"); + const format = gen.let("format"); + gen.if((0, codegen_1._)`typeof ${fDef} == "object" && !(${fDef} instanceof RegExp)`, () => gen.assign(fType, (0, codegen_1._)`${fDef}.type || "string"`).assign(format, (0, codegen_1._)`${fDef}.validate`), () => gen.assign(fType, (0, codegen_1._)`"string"`).assign(format, fDef)); + cxt.fail$data((0, codegen_1.or)(unknownFmt(), invalidFmt())); + function unknownFmt() { + if (opts.strictSchema === false) + return codegen_1.nil; + return (0, codegen_1._)`${schemaCode} && !${format}`; + } + function invalidFmt() { + const callFormat = schemaEnv.$async ? (0, codegen_1._)`(${fDef}.async ? await ${format}(${data}) : ${format}(${data}))` : (0, codegen_1._)`${format}(${data})`; + const validData = (0, codegen_1._)`(typeof ${format} == "function" ? ${callFormat} : ${format}.test(${data}))`; + return (0, codegen_1._)`${format} && ${format} !== true && ${fType} === ${ruleType} && !${validData}`; + } + } + function validateFormat() { + const formatDef = self2.formats[schema]; + if (!formatDef) { + unknownFormat(); + return; + } + if (formatDef === true) + return; + const [fmtType, format, fmtRef] = getFormat(formatDef); + if (fmtType === ruleType) + cxt.pass(validCondition()); + function unknownFormat() { + if (opts.strictSchema === false) { + self2.logger.warn(unknownMsg()); + return; + } + throw new Error(unknownMsg()); + function unknownMsg() { + return `unknown format "${schema}" ignored in schema at path "${errSchemaPath}"`; + } + } + function getFormat(fmtDef) { + const code = fmtDef instanceof RegExp ? (0, codegen_1.regexpCode)(fmtDef) : opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(schema)}` : void 0; + const fmt = gen.scopeValue("formats", { key: schema, ref: fmtDef, code }); + if (typeof fmtDef == "object" && !(fmtDef instanceof RegExp)) { + return [fmtDef.type || "string", fmtDef.validate, (0, codegen_1._)`${fmt}.validate`]; + } + return ["string", fmtDef, fmt]; + } + function validCondition() { + if (typeof formatDef == "object" && !(formatDef instanceof RegExp) && formatDef.async) { + if (!schemaEnv.$async) + throw new Error("async format in sync schema"); + return (0, codegen_1._)`await ${fmtRef}(${data})`; + } + return typeof format == "function" ? (0, codegen_1._)`${fmtRef}(${data})` : (0, codegen_1._)`${fmtRef}.test(${data})`; + } + } + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/format/index.js +var require_format2 = __commonJS({ + "node_modules/ajv/dist/vocabularies/format/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var format_1 = require_format(); + var format = [format_1.default]; + exports.default = format; + } +}); + +// node_modules/ajv/dist/vocabularies/metadata.js +var require_metadata = __commonJS({ + "node_modules/ajv/dist/vocabularies/metadata.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.contentVocabulary = exports.metadataVocabulary = void 0; + exports.metadataVocabulary = [ + "title", + "description", + "default", + "deprecated", + "readOnly", + "writeOnly", + "examples" + ]; + exports.contentVocabulary = [ + "contentMediaType", + "contentEncoding", + "contentSchema" + ]; + } +}); + +// node_modules/ajv/dist/vocabularies/draft7.js +var require_draft7 = __commonJS({ + "node_modules/ajv/dist/vocabularies/draft7.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var core_1 = require_core2(); + var validation_1 = require_validation(); + var applicator_1 = require_applicator(); + var format_1 = require_format2(); + var metadata_1 = require_metadata(); + var draft7Vocabularies = [ + core_1.default, + validation_1.default, + (0, applicator_1.default)(), + format_1.default, + metadata_1.metadataVocabulary, + metadata_1.contentVocabulary + ]; + exports.default = draft7Vocabularies; + } +}); + +// node_modules/ajv/dist/vocabularies/discriminator/types.js +var require_types = __commonJS({ + "node_modules/ajv/dist/vocabularies/discriminator/types.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.DiscrError = void 0; + var DiscrError; + (function(DiscrError2) { + DiscrError2["Tag"] = "tag"; + DiscrError2["Mapping"] = "mapping"; + })(DiscrError || (exports.DiscrError = DiscrError = {})); + } +}); + +// node_modules/ajv/dist/vocabularies/discriminator/index.js +var require_discriminator = __commonJS({ + "node_modules/ajv/dist/vocabularies/discriminator/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var types_1 = require_types(); + var compile_1 = require_compile(); + var ref_error_1 = require_ref_error(); + var util_1 = require_util(); + var error48 = { + message: ({ params: { discrError, tagName } }) => discrError === types_1.DiscrError.Tag ? `tag "${tagName}" must be string` : `value of tag "${tagName}" must be in oneOf`, + params: ({ params: { discrError, tag, tagName } }) => (0, codegen_1._)`{error: ${discrError}, tag: ${tagName}, tagValue: ${tag}}` + }; + var def = { + keyword: "discriminator", + type: "object", + schemaType: "object", + error: error48, + code(cxt) { + const { gen, data, schema, parentSchema, it } = cxt; + const { oneOf } = parentSchema; + if (!it.opts.discriminator) { + throw new Error("discriminator: requires discriminator option"); + } + const tagName = schema.propertyName; + if (typeof tagName != "string") + throw new Error("discriminator: requires propertyName"); + if (schema.mapping) + throw new Error("discriminator: mapping is not supported"); + if (!oneOf) + throw new Error("discriminator: requires oneOf keyword"); + const valid = gen.let("valid", false); + const tag = gen.const("tag", (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(tagName)}`); + gen.if((0, codegen_1._)`typeof ${tag} == "string"`, () => validateMapping(), () => cxt.error(false, { discrError: types_1.DiscrError.Tag, tag, tagName })); + cxt.ok(valid); + function validateMapping() { + const mapping = getMapping(); + gen.if(false); + for (const tagValue in mapping) { + gen.elseIf((0, codegen_1._)`${tag} === ${tagValue}`); + gen.assign(valid, applyTagSchema(mapping[tagValue])); + } + gen.else(); + cxt.error(false, { discrError: types_1.DiscrError.Mapping, tag, tagName }); + gen.endIf(); + } + function applyTagSchema(schemaProp) { + const _valid = gen.name("valid"); + const schCxt = cxt.subschema({ keyword: "oneOf", schemaProp }, _valid); + cxt.mergeEvaluated(schCxt, codegen_1.Name); + return _valid; + } + function getMapping() { + var _a3; + const oneOfMapping = {}; + const topRequired = hasRequired(parentSchema); + let tagRequired = true; + for (let i3 = 0; i3 < oneOf.length; i3++) { + let sch = oneOf[i3]; + if ((sch === null || sch === void 0 ? void 0 : sch.$ref) && !(0, util_1.schemaHasRulesButRef)(sch, it.self.RULES)) { + const ref = sch.$ref; + sch = compile_1.resolveRef.call(it.self, it.schemaEnv.root, it.baseId, ref); + if (sch instanceof compile_1.SchemaEnv) + sch = sch.schema; + if (sch === void 0) + throw new ref_error_1.default(it.opts.uriResolver, it.baseId, ref); + } + const propSch = (_a3 = sch === null || sch === void 0 ? void 0 : sch.properties) === null || _a3 === void 0 ? void 0 : _a3[tagName]; + if (typeof propSch != "object") { + throw new Error(`discriminator: oneOf subschemas (or referenced schemas) must have "properties/${tagName}"`); + } + tagRequired = tagRequired && (topRequired || hasRequired(sch)); + addMappings(propSch, i3); + } + if (!tagRequired) + throw new Error(`discriminator: "${tagName}" must be required`); + return oneOfMapping; + function hasRequired({ required: required2 }) { + return Array.isArray(required2) && required2.includes(tagName); + } + function addMappings(sch, i3) { + if (sch.const) { + addMapping(sch.const, i3); + } else if (sch.enum) { + for (const tagValue of sch.enum) { + addMapping(tagValue, i3); + } + } else { + throw new Error(`discriminator: "properties/${tagName}" must have "const" or "enum"`); + } + } + function addMapping(tagValue, i3) { + if (typeof tagValue != "string" || tagValue in oneOfMapping) { + throw new Error(`discriminator: "${tagName}" values must be unique strings`); + } + oneOfMapping[tagValue] = i3; + } + } + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/refs/json-schema-draft-07.json +var require_json_schema_draft_07 = __commonJS({ + "node_modules/ajv/dist/refs/json-schema-draft-07.json"(exports, module2) { + module2.exports = { + $schema: "http://json-schema.org/draft-07/schema#", + $id: "http://json-schema.org/draft-07/schema#", + title: "Core schema meta-schema", + definitions: { + schemaArray: { + type: "array", + minItems: 1, + items: { $ref: "#" } + }, + nonNegativeInteger: { + type: "integer", + minimum: 0 + }, + nonNegativeIntegerDefault0: { + allOf: [{ $ref: "#/definitions/nonNegativeInteger" }, { default: 0 }] + }, + simpleTypes: { + enum: ["array", "boolean", "integer", "null", "number", "object", "string"] + }, + stringArray: { + type: "array", + items: { type: "string" }, + uniqueItems: true, + default: [] + } + }, + type: ["object", "boolean"], + properties: { + $id: { + type: "string", + format: "uri-reference" + }, + $schema: { + type: "string", + format: "uri" + }, + $ref: { + type: "string", + format: "uri-reference" + }, + $comment: { + type: "string" + }, + title: { + type: "string" + }, + description: { + type: "string" + }, + default: true, + readOnly: { + type: "boolean", + default: false + }, + examples: { + type: "array", + items: true + }, + multipleOf: { + type: "number", + exclusiveMinimum: 0 + }, + maximum: { + type: "number" + }, + exclusiveMaximum: { + type: "number" + }, + minimum: { + type: "number" + }, + exclusiveMinimum: { + type: "number" + }, + maxLength: { $ref: "#/definitions/nonNegativeInteger" }, + minLength: { $ref: "#/definitions/nonNegativeIntegerDefault0" }, + pattern: { + type: "string", + format: "regex" + }, + additionalItems: { $ref: "#" }, + items: { + anyOf: [{ $ref: "#" }, { $ref: "#/definitions/schemaArray" }], + default: true + }, + maxItems: { $ref: "#/definitions/nonNegativeInteger" }, + minItems: { $ref: "#/definitions/nonNegativeIntegerDefault0" }, + uniqueItems: { + type: "boolean", + default: false + }, + contains: { $ref: "#" }, + maxProperties: { $ref: "#/definitions/nonNegativeInteger" }, + minProperties: { $ref: "#/definitions/nonNegativeIntegerDefault0" }, + required: { $ref: "#/definitions/stringArray" }, + additionalProperties: { $ref: "#" }, + definitions: { + type: "object", + additionalProperties: { $ref: "#" }, + default: {} + }, + properties: { + type: "object", + additionalProperties: { $ref: "#" }, + default: {} + }, + patternProperties: { + type: "object", + additionalProperties: { $ref: "#" }, + propertyNames: { format: "regex" }, + default: {} + }, + dependencies: { + type: "object", + additionalProperties: { + anyOf: [{ $ref: "#" }, { $ref: "#/definitions/stringArray" }] + } + }, + propertyNames: { $ref: "#" }, + const: true, + enum: { + type: "array", + items: true, + minItems: 1, + uniqueItems: true + }, + type: { + anyOf: [ + { $ref: "#/definitions/simpleTypes" }, + { + type: "array", + items: { $ref: "#/definitions/simpleTypes" }, + minItems: 1, + uniqueItems: true + } + ] + }, + format: { type: "string" }, + contentMediaType: { type: "string" }, + contentEncoding: { type: "string" }, + if: { $ref: "#" }, + then: { $ref: "#" }, + else: { $ref: "#" }, + allOf: { $ref: "#/definitions/schemaArray" }, + anyOf: { $ref: "#/definitions/schemaArray" }, + oneOf: { $ref: "#/definitions/schemaArray" }, + not: { $ref: "#" } + }, + default: true + }; + } +}); + +// node_modules/ajv/dist/ajv.js +var require_ajv = __commonJS({ + "node_modules/ajv/dist/ajv.js"(exports, module2) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv = void 0; + var core_1 = require_core(); + var draft7_1 = require_draft7(); + var discriminator_1 = require_discriminator(); + var draft7MetaSchema = require_json_schema_draft_07(); + var META_SUPPORT_DATA = ["/properties"]; + var META_SCHEMA_ID = "http://json-schema.org/draft-07/schema"; + var Ajv2 = class extends core_1.default { + _addVocabularies() { + super._addVocabularies(); + draft7_1.default.forEach((v2) => this.addVocabulary(v2)); + if (this.opts.discriminator) + this.addKeyword(discriminator_1.default); + } + _addDefaultMetaSchema() { + super._addDefaultMetaSchema(); + if (!this.opts.meta) + return; + const metaSchema = this.opts.$data ? this.$dataMetaSchema(draft7MetaSchema, META_SUPPORT_DATA) : draft7MetaSchema; + this.addMetaSchema(metaSchema, META_SCHEMA_ID, false); + this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID; + } + defaultMeta() { + return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0); + } + }; + exports.Ajv = Ajv2; + module2.exports = exports = Ajv2; + module2.exports.Ajv = Ajv2; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.default = Ajv2; + var validate_1 = require_validate(); + Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() { + return validate_1.KeywordCxt; + } }); + var codegen_1 = require_codegen(); + Object.defineProperty(exports, "_", { enumerable: true, get: function() { + return codegen_1._; + } }); + Object.defineProperty(exports, "str", { enumerable: true, get: function() { + return codegen_1.str; + } }); + Object.defineProperty(exports, "stringify", { enumerable: true, get: function() { + return codegen_1.stringify; + } }); + Object.defineProperty(exports, "nil", { enumerable: true, get: function() { + return codegen_1.nil; + } }); + Object.defineProperty(exports, "Name", { enumerable: true, get: function() { + return codegen_1.Name; + } }); + Object.defineProperty(exports, "CodeGen", { enumerable: true, get: function() { + return codegen_1.CodeGen; + } }); + var validation_error_1 = require_validation_error(); + Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function() { + return validation_error_1.default; + } }); + var ref_error_1 = require_ref_error(); + Object.defineProperty(exports, "MissingRefError", { enumerable: true, get: function() { + return ref_error_1.default; + } }); + } +}); + +// node_modules/ajv-formats/dist/formats.js +var require_formats = __commonJS({ + "node_modules/ajv-formats/dist/formats.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.formatNames = exports.fastFormats = exports.fullFormats = void 0; + function fmtDef(validate, compare) { + return { validate, compare }; + } + exports.fullFormats = { + // date: http://tools.ietf.org/html/rfc3339#section-5.6 + date: fmtDef(date7, compareDate), + // date-time: http://tools.ietf.org/html/rfc3339#section-5.6 + time: fmtDef(getTime(true), compareTime), + "date-time": fmtDef(getDateTime(true), compareDateTime), + "iso-time": fmtDef(getTime(), compareIsoTime), + "iso-date-time": fmtDef(getDateTime(), compareIsoDateTime), + // duration: https://tools.ietf.org/html/rfc3339#appendix-A + duration: /^P(?!$)((\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?|(\d+W)?)$/, + uri, + "uri-reference": /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i, + // uri-template: https://tools.ietf.org/html/rfc6570 + "uri-template": /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i, + // For the source: https://gist.github.com/dperini/729294 + // For test cases: https://mathiasbynens.be/demo/url-regex + url: /^(?:https?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu, + email: /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i, + hostname: /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i, + // optimized https://www.safaribooksonline.com/library/view/regular-expressions-cookbook/9780596802837/ch07s16.html + ipv4: /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/, + ipv6: /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i, + regex, + // uuid: http://tools.ietf.org/html/rfc4122 + uuid: /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i, + // JSON-pointer: https://tools.ietf.org/html/rfc6901 + // uri fragment: https://tools.ietf.org/html/rfc3986#appendix-A + "json-pointer": /^(?:\/(?:[^~/]|~0|~1)*)*$/, + "json-pointer-uri-fragment": /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i, + // relative JSON-pointer: http://tools.ietf.org/html/draft-luff-relative-json-pointer-00 + "relative-json-pointer": /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/, + // the following formats are used by the openapi specification: https://spec.openapis.org/oas/v3.0.0#data-types + // byte: https://github.com/miguelmota/is-base64 + byte, + // signed 32 bit integer + int32: { type: "number", validate: validateInt32 }, + // signed 64 bit integer + int64: { type: "number", validate: validateInt64 }, + // C-type float + float: { type: "number", validate: validateNumber }, + // C-type double + double: { type: "number", validate: validateNumber }, + // hint to the UI to hide input strings + password: true, + // unchecked string payload + binary: true + }; + exports.fastFormats = { + ...exports.fullFormats, + date: fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\d$/, compareDate), + time: fmtDef(/^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i, compareTime), + "date-time": fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i, compareDateTime), + "iso-time": fmtDef(/^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, compareIsoTime), + "iso-date-time": fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\d[t\s](?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, compareIsoDateTime), + // uri: https://github.com/mafintosh/is-my-json-valid/blob/master/formats.js + uri: /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/)?[^\s]*$/i, + "uri-reference": /^(?:(?:[a-z][a-z0-9+\-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i, + // email (sources from jsen validator): + // http://stackoverflow.com/questions/201323/using-a-regular-expression-to-validate-an-email-address#answer-8829363 + // http://www.w3.org/TR/html5/forms.html#valid-e-mail-address (search for 'wilful violation') + email: /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i + }; + exports.formatNames = Object.keys(exports.fullFormats); + function isLeapYear(year) { + return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0); + } + var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/; + var DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; + function date7(str) { + const matches = DATE.exec(str); + if (!matches) + return false; + const year = +matches[1]; + const month = +matches[2]; + const day = +matches[3]; + return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && isLeapYear(year) ? 29 : DAYS[month]); + } + function compareDate(d12, d22) { + if (!(d12 && d22)) + return void 0; + if (d12 > d22) + return 1; + if (d12 < d22) + return -1; + return 0; + } + var TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i; + function getTime(strictTimeZone) { + return function time4(str) { + const matches = TIME.exec(str); + if (!matches) + return false; + const hr = +matches[1]; + const min = +matches[2]; + const sec = +matches[3]; + const tz2 = matches[4]; + const tzSign = matches[5] === "-" ? -1 : 1; + const tzH = +(matches[6] || 0); + const tzM = +(matches[7] || 0); + if (tzH > 23 || tzM > 59 || strictTimeZone && !tz2) + return false; + if (hr <= 23 && min <= 59 && sec < 60) + return true; + const utcMin = min - tzM * tzSign; + const utcHr = hr - tzH * tzSign - (utcMin < 0 ? 1 : 0); + return (utcHr === 23 || utcHr === -1) && (utcMin === 59 || utcMin === -1) && sec < 61; + }; + } + function compareTime(s12, s22) { + if (!(s12 && s22)) + return void 0; + const t12 = (/* @__PURE__ */ new Date("2020-01-01T" + s12)).valueOf(); + const t22 = (/* @__PURE__ */ new Date("2020-01-01T" + s22)).valueOf(); + if (!(t12 && t22)) + return void 0; + return t12 - t22; + } + function compareIsoTime(t12, t22) { + if (!(t12 && t22)) + return void 0; + const a12 = TIME.exec(t12); + const a22 = TIME.exec(t22); + if (!(a12 && a22)) + return void 0; + t12 = a12[1] + a12[2] + a12[3]; + t22 = a22[1] + a22[2] + a22[3]; + if (t12 > t22) + return 1; + if (t12 < t22) + return -1; + return 0; + } + var DATE_TIME_SEPARATOR = /t|\s/i; + function getDateTime(strictTimeZone) { + const time4 = getTime(strictTimeZone); + return function date_time(str) { + const dateTime = str.split(DATE_TIME_SEPARATOR); + return dateTime.length === 2 && date7(dateTime[0]) && time4(dateTime[1]); + }; + } + function compareDateTime(dt1, dt2) { + if (!(dt1 && dt2)) + return void 0; + const d12 = new Date(dt1).valueOf(); + const d22 = new Date(dt2).valueOf(); + if (!(d12 && d22)) + return void 0; + return d12 - d22; + } + function compareIsoDateTime(dt1, dt2) { + if (!(dt1 && dt2)) + return void 0; + const [d12, t12] = dt1.split(DATE_TIME_SEPARATOR); + const [d22, t22] = dt2.split(DATE_TIME_SEPARATOR); + const res = compareDate(d12, d22); + if (res === void 0) + return void 0; + return res || compareTime(t12, t22); + } + var NOT_URI_FRAGMENT = /\/|:/; + var URI = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i; + function uri(str) { + return NOT_URI_FRAGMENT.test(str) && URI.test(str); + } + var BYTE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm; + function byte(str) { + BYTE.lastIndex = 0; + return BYTE.test(str); + } + var MIN_INT32 = -(2 ** 31); + var MAX_INT32 = 2 ** 31 - 1; + function validateInt32(value) { + return Number.isInteger(value) && value <= MAX_INT32 && value >= MIN_INT32; + } + function validateInt64(value) { + return Number.isInteger(value); + } + function validateNumber() { + return true; + } + var Z_ANCHOR = /[^\\]\\Z/; + function regex(str) { + if (Z_ANCHOR.test(str)) + return false; + try { + new RegExp(str); + return true; + } catch (e3) { + return false; + } + } + } +}); + +// node_modules/ajv-formats/dist/limit.js +var require_limit = __commonJS({ + "node_modules/ajv-formats/dist/limit.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.formatLimitDefinition = void 0; + var ajv_1 = require_ajv(); + var codegen_1 = require_codegen(); + var ops = codegen_1.operators; + var KWDs = { + formatMaximum: { okStr: "<=", ok: ops.LTE, fail: ops.GT }, + formatMinimum: { okStr: ">=", ok: ops.GTE, fail: ops.LT }, + formatExclusiveMaximum: { okStr: "<", ok: ops.LT, fail: ops.GTE }, + formatExclusiveMinimum: { okStr: ">", ok: ops.GT, fail: ops.LTE } + }; + var error48 = { + message: ({ keyword, schemaCode }) => (0, codegen_1.str)`should be ${KWDs[keyword].okStr} ${schemaCode}`, + params: ({ keyword, schemaCode }) => (0, codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}` + }; + exports.formatLimitDefinition = { + keyword: Object.keys(KWDs), + type: "string", + schemaType: "string", + $data: true, + error: error48, + code(cxt) { + const { gen, data, schemaCode, keyword, it } = cxt; + const { opts, self: self2 } = it; + if (!opts.validateFormats) + return; + const fCxt = new ajv_1.KeywordCxt(it, self2.RULES.all.format.definition, "format"); + if (fCxt.$data) + validate$DataFormat(); + else + validateFormat(); + function validate$DataFormat() { + const fmts = gen.scopeValue("formats", { + ref: self2.formats, + code: opts.code.formats + }); + const fmt = gen.const("fmt", (0, codegen_1._)`${fmts}[${fCxt.schemaCode}]`); + cxt.fail$data((0, codegen_1.or)((0, codegen_1._)`typeof ${fmt} != "object"`, (0, codegen_1._)`${fmt} instanceof RegExp`, (0, codegen_1._)`typeof ${fmt}.compare != "function"`, compareCode(fmt))); + } + function validateFormat() { + const format = fCxt.schema; + const fmtDef = self2.formats[format]; + if (!fmtDef || fmtDef === true) + return; + if (typeof fmtDef != "object" || fmtDef instanceof RegExp || typeof fmtDef.compare != "function") { + throw new Error(`"${keyword}": format "${format}" does not define "compare" function`); + } + const fmt = gen.scopeValue("formats", { + key: format, + ref: fmtDef, + code: opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(format)}` : void 0 + }); + cxt.fail$data(compareCode(fmt)); + } + function compareCode(fmt) { + return (0, codegen_1._)`${fmt}.compare(${data}, ${schemaCode}) ${KWDs[keyword].fail} 0`; + } + }, + dependencies: ["format"] + }; + var formatLimitPlugin = (ajv) => { + ajv.addKeyword(exports.formatLimitDefinition); + return ajv; + }; + exports.default = formatLimitPlugin; + } +}); + +// node_modules/ajv-formats/dist/index.js +var require_dist = __commonJS({ + "node_modules/ajv-formats/dist/index.js"(exports, module2) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var formats_1 = require_formats(); + var limit_1 = require_limit(); + var codegen_1 = require_codegen(); + var fullName = new codegen_1.Name("fullFormats"); + var fastName = new codegen_1.Name("fastFormats"); + var formatsPlugin = (ajv, opts = { keywords: true }) => { + if (Array.isArray(opts)) { + addFormats(ajv, opts, formats_1.fullFormats, fullName); + return ajv; + } + const [formats, exportName] = opts.mode === "fast" ? [formats_1.fastFormats, fastName] : [formats_1.fullFormats, fullName]; + const list = opts.formats || formats_1.formatNames; + addFormats(ajv, list, formats, exportName); + if (opts.keywords) + (0, limit_1.default)(ajv); + return ajv; + }; + formatsPlugin.get = (name, mode = "full") => { + const formats = mode === "fast" ? formats_1.fastFormats : formats_1.fullFormats; + const f6 = formats[name]; + if (!f6) + throw new Error(`Unknown format "${name}"`); + return f6; + }; + function addFormats(ajv, list, fs19, exportName) { + var _a3; + var _b2; + (_a3 = (_b2 = ajv.opts.code).formats) !== null && _a3 !== void 0 ? _a3 : _b2.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`; + for (const f6 of list) + ajv.addFormat(f6, fs19[f6]); + } + module2.exports = exports = formatsPlugin; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.default = formatsPlugin; + } +}); + +// node_modules/isexe/windows.js +var require_windows = __commonJS({ + "node_modules/isexe/windows.js"(exports, module2) { + module2.exports = isexe; + isexe.sync = sync; + var fs19 = require("fs"); + function checkPathExt(path19, options) { + var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT; + if (!pathext) { + return true; + } + pathext = pathext.split(";"); + if (pathext.indexOf("") !== -1) { + return true; + } + for (var i3 = 0; i3 < pathext.length; i3++) { + var p = pathext[i3].toLowerCase(); + if (p && path19.substr(-p.length).toLowerCase() === p) { + return true; + } + } + return false; + } + function checkStat(stat, path19, options) { + if (!stat.isSymbolicLink() && !stat.isFile()) { + return false; + } + return checkPathExt(path19, options); + } + function isexe(path19, options, cb2) { + fs19.stat(path19, function(er, stat) { + cb2(er, er ? false : checkStat(stat, path19, options)); + }); + } + function sync(path19, options) { + return checkStat(fs19.statSync(path19), path19, options); + } + } +}); + +// node_modules/isexe/mode.js +var require_mode = __commonJS({ + "node_modules/isexe/mode.js"(exports, module2) { + module2.exports = isexe; + isexe.sync = sync; + var fs19 = require("fs"); + function isexe(path19, options, cb2) { + fs19.stat(path19, function(er, stat) { + cb2(er, er ? false : checkStat(stat, options)); + }); + } + function sync(path19, options) { + return checkStat(fs19.statSync(path19), options); + } + function checkStat(stat, options) { + return stat.isFile() && checkMode(stat, options); + } + function checkMode(stat, options) { + var mod = stat.mode; + var uid = stat.uid; + var gid = stat.gid; + var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid(); + var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid(); + var u = parseInt("100", 8); + var g = parseInt("010", 8); + var o3 = parseInt("001", 8); + var ug = u | g; + var ret = mod & o3 || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0; + return ret; + } + } +}); + +// node_modules/isexe/index.js +var require_isexe = __commonJS({ + "node_modules/isexe/index.js"(exports, module2) { + var fs19 = require("fs"); + var core; + if (process.platform === "win32" || global.TESTING_WINDOWS) { + core = require_windows(); + } else { + core = require_mode(); + } + module2.exports = isexe; + isexe.sync = sync; + function isexe(path19, options, cb2) { + if (typeof options === "function") { + cb2 = options; + options = {}; + } + if (!cb2) { + if (typeof Promise !== "function") { + throw new TypeError("callback not provided"); + } + return new Promise(function(resolve5, reject) { + isexe(path19, options || {}, function(er, is) { + if (er) { + reject(er); + } else { + resolve5(is); + } + }); + }); + } + core(path19, options || {}, function(er, is) { + if (er) { + if (er.code === "EACCES" || options && options.ignoreErrors) { + er = null; + is = false; + } + } + cb2(er, is); + }); + } + function sync(path19, options) { + try { + return core.sync(path19, options || {}); + } catch (er) { + if (options && options.ignoreErrors || er.code === "EACCES") { + return false; + } else { + throw er; + } + } + } + } +}); + +// node_modules/which/which.js +var require_which = __commonJS({ + "node_modules/which/which.js"(exports, module2) { + var isWindows2 = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys"; + var path19 = require("path"); + var COLON = isWindows2 ? ";" : ":"; + var isexe = require_isexe(); + var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" }); + var getPathInfo = (cmd, opt) => { + const colon = opt.colon || COLON; + const pathEnv = cmd.match(/\//) || isWindows2 && cmd.match(/\\/) ? [""] : [ + // windows always checks the cwd first + ...isWindows2 ? [process.cwd()] : [], + ...(opt.path || process.env.PATH || /* istanbul ignore next: very unusual */ + "").split(colon) + ]; + const pathExtExe = isWindows2 ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : ""; + const pathExt = isWindows2 ? pathExtExe.split(colon) : [""]; + if (isWindows2) { + if (cmd.indexOf(".") !== -1 && pathExt[0] !== "") + pathExt.unshift(""); + } + return { + pathEnv, + pathExt, + pathExtExe + }; + }; + var which = (cmd, opt, cb2) => { + if (typeof opt === "function") { + cb2 = opt; + opt = {}; + } + if (!opt) + opt = {}; + const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt); + const found = []; + const step = (i3) => new Promise((resolve5, reject) => { + if (i3 === pathEnv.length) + return opt.all && found.length ? resolve5(found) : reject(getNotFoundError(cmd)); + const ppRaw = pathEnv[i3]; + const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw; + const pCmd = path19.join(pathPart, cmd); + const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd; + resolve5(subStep(p, i3, 0)); + }); + const subStep = (p, i3, ii) => new Promise((resolve5, reject) => { + if (ii === pathExt.length) + return resolve5(step(i3 + 1)); + const ext = pathExt[ii]; + isexe(p + ext, { pathExt: pathExtExe }, (er, is) => { + if (!er && is) { + if (opt.all) + found.push(p + ext); + else + return resolve5(p + ext); + } + return resolve5(subStep(p, i3, ii + 1)); + }); + }); + return cb2 ? step(0).then((res) => cb2(null, res), cb2) : step(0); + }; + var whichSync = (cmd, opt) => { + opt = opt || {}; + const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt); + const found = []; + for (let i3 = 0; i3 < pathEnv.length; i3++) { + const ppRaw = pathEnv[i3]; + const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw; + const pCmd = path19.join(pathPart, cmd); + const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd; + for (let j = 0; j < pathExt.length; j++) { + const cur = p + pathExt[j]; + try { + const is = isexe.sync(cur, { pathExt: pathExtExe }); + if (is) { + if (opt.all) + found.push(cur); + else + return cur; + } + } catch (ex) { + } + } + } + if (opt.all && found.length) + return found; + if (opt.nothrow) + return null; + throw getNotFoundError(cmd); + }; + module2.exports = which; + which.sync = whichSync; + } +}); + +// node_modules/path-key/index.js +var require_path_key = __commonJS({ + "node_modules/path-key/index.js"(exports, module2) { + "use strict"; + var pathKey = (options = {}) => { + const environment = options.env || process.env; + const platform = options.platform || process.platform; + if (platform !== "win32") { + return "PATH"; + } + return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path"; + }; + module2.exports = pathKey; + module2.exports.default = pathKey; + } +}); + +// node_modules/cross-spawn/lib/util/resolveCommand.js +var require_resolveCommand = __commonJS({ + "node_modules/cross-spawn/lib/util/resolveCommand.js"(exports, module2) { + "use strict"; + var path19 = require("path"); + var which = require_which(); + var getPathKey = require_path_key(); + function resolveCommandAttempt(parsed, withoutPathExt) { + const env = parsed.options.env || process.env; + const cwd = process.cwd(); + const hasCustomCwd = parsed.options.cwd != null; + const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled; + if (shouldSwitchCwd) { + try { + process.chdir(parsed.options.cwd); + } catch (err) { + } + } + let resolved; + try { + resolved = which.sync(parsed.command, { + path: env[getPathKey({ env })], + pathExt: withoutPathExt ? path19.delimiter : void 0 + }); + } catch (e3) { + } finally { + if (shouldSwitchCwd) { + process.chdir(cwd); + } + } + if (resolved) { + resolved = path19.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved); + } + return resolved; + } + function resolveCommand(parsed) { + return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true); + } + module2.exports = resolveCommand; + } +}); + +// node_modules/cross-spawn/lib/util/escape.js +var require_escape = __commonJS({ + "node_modules/cross-spawn/lib/util/escape.js"(exports, module2) { + "use strict"; + var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g; + function escapeCommand(arg) { + arg = arg.replace(metaCharsRegExp, "^$1"); + return arg; + } + function escapeArgument(arg, doubleEscapeMetaChars) { + arg = `${arg}`; + arg = arg.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"'); + arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1"); + arg = `"${arg}"`; + arg = arg.replace(metaCharsRegExp, "^$1"); + if (doubleEscapeMetaChars) { + arg = arg.replace(metaCharsRegExp, "^$1"); + } + return arg; + } + module2.exports.command = escapeCommand; + module2.exports.argument = escapeArgument; + } +}); + +// node_modules/shebang-regex/index.js +var require_shebang_regex = __commonJS({ + "node_modules/shebang-regex/index.js"(exports, module2) { + "use strict"; + module2.exports = /^#!(.*)/; + } +}); + +// node_modules/shebang-command/index.js +var require_shebang_command = __commonJS({ + "node_modules/shebang-command/index.js"(exports, module2) { + "use strict"; + var shebangRegex = require_shebang_regex(); + module2.exports = (string5 = "") => { + const match = string5.match(shebangRegex); + if (!match) { + return null; + } + const [path19, argument] = match[0].replace(/#! ?/, "").split(" "); + const binary = path19.split("/").pop(); + if (binary === "env") { + return argument; + } + return argument ? `${binary} ${argument}` : binary; + }; + } +}); + +// node_modules/cross-spawn/lib/util/readShebang.js +var require_readShebang = __commonJS({ + "node_modules/cross-spawn/lib/util/readShebang.js"(exports, module2) { + "use strict"; + var fs19 = require("fs"); + var shebangCommand = require_shebang_command(); + function readShebang(command) { + const size = 150; + const buffer = Buffer.alloc(size); + let fd; + try { + fd = fs19.openSync(command, "r"); + fs19.readSync(fd, buffer, 0, size, 0); + fs19.closeSync(fd); + } catch (e3) { + } + return shebangCommand(buffer.toString()); + } + module2.exports = readShebang; + } +}); + +// node_modules/cross-spawn/lib/parse.js +var require_parse = __commonJS({ + "node_modules/cross-spawn/lib/parse.js"(exports, module2) { + "use strict"; + var path19 = require("path"); + var resolveCommand = require_resolveCommand(); + var escape2 = require_escape(); + var readShebang = require_readShebang(); + var isWin = process.platform === "win32"; + var isExecutableRegExp = /\.(?:com|exe)$/i; + var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i; + function detectShebang(parsed) { + parsed.file = resolveCommand(parsed); + const shebang = parsed.file && readShebang(parsed.file); + if (shebang) { + parsed.args.unshift(parsed.file); + parsed.command = shebang; + return resolveCommand(parsed); + } + return parsed.file; + } + function parseNonShell(parsed) { + if (!isWin) { + return parsed; + } + const commandFile = detectShebang(parsed); + const needsShell = !isExecutableRegExp.test(commandFile); + if (parsed.options.forceShell || needsShell) { + const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile); + parsed.command = path19.normalize(parsed.command); + parsed.command = escape2.command(parsed.command); + parsed.args = parsed.args.map((arg) => escape2.argument(arg, needsDoubleEscapeMetaChars)); + const shellCommand = [parsed.command].concat(parsed.args).join(" "); + parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`]; + parsed.command = process.env.comspec || "cmd.exe"; + parsed.options.windowsVerbatimArguments = true; + } + return parsed; + } + function parse4(command, args, options) { + if (args && !Array.isArray(args)) { + options = args; + args = null; + } + args = args ? args.slice(0) : []; + options = Object.assign({}, options); + const parsed = { + command, + args, + options, + file: void 0, + original: { + command, + args + } + }; + return options.shell ? parsed : parseNonShell(parsed); + } + module2.exports = parse4; + } +}); + +// node_modules/cross-spawn/lib/enoent.js +var require_enoent = __commonJS({ + "node_modules/cross-spawn/lib/enoent.js"(exports, module2) { + "use strict"; + var isWin = process.platform === "win32"; + function notFoundError(original, syscall) { + return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), { + code: "ENOENT", + errno: "ENOENT", + syscall: `${syscall} ${original.command}`, + path: original.command, + spawnargs: original.args + }); + } + function hookChildProcess(cp, parsed) { + if (!isWin) { + return; + } + const originalEmit = cp.emit; + cp.emit = function(name, arg1) { + if (name === "exit") { + const err = verifyENOENT(arg1, parsed); + if (err) { + return originalEmit.call(cp, "error", err); + } + } + return originalEmit.apply(cp, arguments); + }; + } + function verifyENOENT(status, parsed) { + if (isWin && status === 1 && !parsed.file) { + return notFoundError(parsed.original, "spawn"); + } + return null; + } + function verifyENOENTSync(status, parsed) { + if (isWin && status === 1 && !parsed.file) { + return notFoundError(parsed.original, "spawnSync"); + } + return null; + } + module2.exports = { + hookChildProcess, + verifyENOENT, + verifyENOENTSync, + notFoundError + }; + } +}); + +// node_modules/cross-spawn/index.js +var require_cross_spawn = __commonJS({ + "node_modules/cross-spawn/index.js"(exports, module2) { + "use strict"; + var cp = require("child_process"); + var parse4 = require_parse(); + var enoent = require_enoent(); + function spawn4(command, args, options) { + const parsed = parse4(command, args, options); + const spawned = cp.spawn(parsed.command, parsed.args, parsed.options); + enoent.hookChildProcess(spawned, parsed); + return spawned; + } + function spawnSync(command, args, options) { + const parsed = parse4(command, args, options); + const result = cp.spawnSync(parsed.command, parsed.args, parsed.options); + result.error = result.error || enoent.verifyENOENTSync(result.status, parsed); + return result; + } + module2.exports = spawn4; + module2.exports.spawn = spawn4; + module2.exports.sync = spawnSync; + module2.exports._parse = parse4; + module2.exports._enoent = enoent; + } +}); + +// src/main.ts +var main_exports = {}; +__export(main_exports, { + default: () => ClaudianPlugin +}); +module.exports = __toCommonJS(main_exports); + +// src/utils/electronCompat.ts +function isAbortSignalLike(target) { + if (!target || typeof target !== "object") return false; + const t3 = target; + return typeof t3.aborted === "boolean" && typeof t3.addEventListener === "function" && typeof t3.removeEventListener === "function"; +} +function patchSetMaxListenersForElectron() { + const events = require("events"); + if (events.setMaxListeners.__electronPatched) return; + const original = events.setMaxListeners; + const patched = function patchedSetMaxListeners(...args) { + try { + return original.apply(this, args); + } catch (error48) { + const eventTargets = args.slice(1); + if (eventTargets.length > 0 && eventTargets.every(isAbortSignalLike)) { + return; + } + throw error48; + } + }; + patched.__electronPatched = true; + events.setMaxListeners = patched; +} + +// src/core/providers/types.ts +var DEFAULT_CHAT_PROVIDER_ID = "claude"; + +// src/core/providers/ProviderRegistry.ts +var ProviderRegistry = class { + static register(providerId, registration) { + this.registrations[providerId] = registration; + } + static getProviderRegistration(providerId) { + const registration = this.registrations[providerId]; + if (!registration) { + throw new Error(`Provider "${providerId}" is not registered.`); + } + return registration; + } + static createChatRuntime(options) { + var _a3; + const providerId = (_a3 = options.providerId) != null ? _a3 : DEFAULT_CHAT_PROVIDER_ID; + return this.getProviderRegistration(providerId).createRuntime(options); + } + static createTitleGenerationService(plugin, providerId = DEFAULT_CHAT_PROVIDER_ID) { + return this.getProviderRegistration(providerId).createTitleGenerationService(plugin); + } + static createInstructionRefineService(plugin, providerId = DEFAULT_CHAT_PROVIDER_ID) { + return this.getProviderRegistration(providerId).createInstructionRefineService(plugin); + } + static createInlineEditService(plugin, providerId = DEFAULT_CHAT_PROVIDER_ID) { + return this.getProviderRegistration(providerId).createInlineEditService(plugin); + } + static getConversationHistoryService(providerId = DEFAULT_CHAT_PROVIDER_ID) { + return this.getProviderRegistration(providerId).historyService; + } + static getTaskResultInterpreter(providerId = DEFAULT_CHAT_PROVIDER_ID) { + return this.getProviderRegistration(providerId).taskResultInterpreter; + } + static getSubagentLifecycleAdapter(providerId = DEFAULT_CHAT_PROVIDER_ID) { + var _a3; + return (_a3 = this.getProviderRegistration(providerId).subagentLifecycleAdapter) != null ? _a3 : null; + } + static getCapabilities(providerId = DEFAULT_CHAT_PROVIDER_ID) { + return this.getProviderRegistration(providerId).capabilities; + } + static getEnvironmentKeyPatterns(providerId) { + var _a3; + return (_a3 = this.getProviderRegistration(providerId).environmentKeyPatterns) != null ? _a3 : []; + } + static getChatUIConfig(providerId = DEFAULT_CHAT_PROVIDER_ID) { + return this.getProviderRegistration(providerId).chatUIConfig; + } + static getSettingsReconciler(providerId = DEFAULT_CHAT_PROVIDER_ID) { + return this.getProviderRegistration(providerId).settingsReconciler; + } + static getRegisteredProviderIds() { + return Object.keys(this.registrations); + } + static getEnabledProviderIds(settings11) { + return this.getRegisteredProviderIds().filter((providerId) => this.getProviderRegistration(providerId).isEnabled(settings11)).sort((a3, b) => this.getProviderRegistration(a3).blankTabOrder - this.getProviderRegistration(b).blankTabOrder); + } + static getProviderDisplayName(providerId) { + return this.getProviderRegistration(providerId).displayName; + } + static isEnabled(providerId, settings11) { + return this.getProviderRegistration(providerId).isEnabled(settings11); + } + static resolveSettingsProviderId(settings11) { + var _a3; + const current = settings11.settingsProvider; + if (typeof current === "string") { + const currentProvider = current; + if (this.getRegisteredProviderIds().includes(currentProvider) && this.isEnabled(currentProvider, settings11)) { + return currentProvider; + } + } + if (this.isEnabled(DEFAULT_CHAT_PROVIDER_ID, settings11)) { + return DEFAULT_CHAT_PROVIDER_ID; + } + return (_a3 = this.getEnabledProviderIds(settings11)[0]) != null ? _a3 : DEFAULT_CHAT_PROVIDER_ID; + } + static resolveProviderForModel(model, settings11 = {}) { + for (const providerId of this.getRegisteredProviderIds()) { + if (providerId === DEFAULT_CHAT_PROVIDER_ID) { + continue; + } + if (this.getChatUIConfig(providerId).ownsModel(model, settings11)) { + return providerId; + } + } + return DEFAULT_CHAT_PROVIDER_ID; + } + static getCustomModelIds(envVars) { + const ids = /* @__PURE__ */ new Set(); + for (const providerId of this.getRegisteredProviderIds()) { + for (const modelId of this.getChatUIConfig(providerId).getCustomModelIds(envVars)) { + ids.add(modelId); + } + } + return ids; + } +}; +ProviderRegistry.registrations = {}; + +// src/core/storage/HomeFileAdapter.ts +var fs = __toESM(require("fs")); +var os = __toESM(require("os")); +var path = __toESM(require("path")); +var HomeFileAdapter = class { + constructor(root = os.homedir()) { + this.root = root; + } + resolve(relativePath) { + return path.join(this.root, relativePath); + } + async exists(p) { + try { + await fs.promises.access(this.resolve(p)); + return true; + } catch (e3) { + return false; + } + } + async read(p) { + return fs.promises.readFile(this.resolve(p), "utf-8"); + } + async write(p, content) { + const full = this.resolve(p); + await fs.promises.mkdir(path.dirname(full), { recursive: true }); + await fs.promises.writeFile(full, content, "utf-8"); + } + async delete(p) { + try { + await fs.promises.unlink(this.resolve(p)); + } catch (err) { + if (err.code !== "ENOENT") throw err; + } + } + async deleteFolder(p) { + try { + await fs.promises.rmdir(this.resolve(p)); + } catch (e3) { + } + } + async listFolders(folder) { + const full = this.resolve(folder); + try { + const entries = await fs.promises.readdir(full, { withFileTypes: true }); + return entries.filter((e3) => e3.isDirectory()).map((e3) => `${folder}/${e3.name}`); + } catch (e3) { + return []; + } + } + async ensureFolder(p) { + await fs.promises.mkdir(this.resolve(p), { recursive: true }); + } +}; + +// src/core/providers/ProviderWorkspaceRegistry.ts +var ProviderWorkspaceRegistry = class { + static register(providerId, registration) { + this.registrations[providerId] = registration; + } + static getWorkspaceRegistration(providerId) { + const registration = this.registrations[providerId]; + if (!registration) { + throw new Error(`Provider workspace "${providerId}" is not registered.`); + } + return registration; + } + static async initializeAll(plugin) { + const providerIds = Object.keys(this.registrations); + const storage = plugin.storage; + const vaultAdapter = storage.getAdapter(); + const homeAdapter = new HomeFileAdapter(); + for (const providerId of providerIds) { + this.services[providerId] = await this.getWorkspaceRegistration(providerId).initialize({ + plugin, + storage, + vaultAdapter, + homeAdapter + }); + } + } + static setServices(providerId, services) { + if (services) { + this.services[providerId] = services; + } else { + delete this.services[providerId]; + } + } + static clear() { + this.services = {}; + } + static getServices(providerId) { + var _a3; + return (_a3 = this.services[providerId]) != null ? _a3 : null; + } + static requireServices(providerId) { + const services = this.getServices(providerId); + if (!services) { + throw new Error(`Provider workspace "${providerId}" is not initialized.`); + } + return services; + } + static getCommandCatalog(providerId) { + var _a3, _b2; + return (_b2 = (_a3 = this.getServices(providerId)) == null ? void 0 : _a3.commandCatalog) != null ? _b2 : null; + } + static getAgentMentionProvider(providerId) { + var _a3, _b2; + return (_b2 = (_a3 = this.getServices(providerId)) == null ? void 0 : _a3.agentMentionProvider) != null ? _b2 : null; + } + static async refreshAgentMentions(providerId) { + var _a3, _b2; + await ((_b2 = (_a3 = this.getServices(providerId)) == null ? void 0 : _a3.refreshAgentMentions) == null ? void 0 : _b2.call(_a3)); + } + static getCliResolver(providerId) { + var _a3, _b2; + return (_b2 = (_a3 = this.getServices(providerId)) == null ? void 0 : _a3.cliResolver) != null ? _b2 : null; + } + static getMcpServerManager(providerId) { + var _a3, _b2; + return (_b2 = (_a3 = this.getServices(providerId)) == null ? void 0 : _a3.mcpServerManager) != null ? _b2 : null; + } + static getSettingsTabRenderer(providerId) { + var _a3, _b2; + return (_b2 = (_a3 = this.getServices(providerId)) == null ? void 0 : _a3.settingsTabRenderer) != null ? _b2 : null; + } +}; +ProviderWorkspaceRegistry.registrations = {}; +ProviderWorkspaceRegistry.services = {}; + +// src/utils/mcp.ts +function extractMcpMentions(text, validNames) { + const mentions = /* @__PURE__ */ new Set(); + const regex = /@([a-zA-Z0-9._-]+)(?!\/)/g; + let match; + while ((match = regex.exec(text)) !== null) { + const name = match[1]; + if (validNames.has(name)) { + mentions.add(name); + } + } + return mentions; +} +function transformMcpMentions(text, validNames) { + if (validNames.size === 0) return text; + const sortedNames = Array.from(validNames).sort((a3, b) => b.length - a3.length); + const escapedNames = sortedNames.map(escapeRegExp).join("|"); + const pattern = new RegExp( + `@(${escapedNames})(?! MCP)(?!/)(?![a-zA-Z0-9_-])(?!\\.[a-zA-Z0-9_-])`, + "g" + ); + return text.replace(pattern, "@$1 MCP"); +} +function escapeRegExp(str) { + return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); +} +function parseCommand(command, providedArgs) { + if (providedArgs && providedArgs.length > 0) { + return { cmd: command, args: providedArgs }; + } + const parts = splitCommandString(command); + if (parts.length === 0) { + return { cmd: "", args: [] }; + } + return { cmd: parts[0], args: parts.slice(1) }; +} +function splitCommandString(cmdStr) { + const parts = []; + let current = ""; + let inQuote = false; + let quoteChar = ""; + for (let i3 = 0; i3 < cmdStr.length; i3++) { + const char = cmdStr[i3]; + if ((char === '"' || char === "'") && !inQuote) { + inQuote = true; + quoteChar = char; + continue; + } + if (char === quoteChar && inQuote) { + inQuote = false; + quoteChar = ""; + continue; + } + if (/\s/.test(char) && !inQuote) { + if (current) { + parts.push(current); + current = ""; + } + continue; + } + current += char; + } + if (current) { + parts.push(current); + } + return parts; +} + +// src/core/mcp/McpServerManager.ts +var McpServerManager = class { + constructor(storage) { + this.servers = []; + this.storage = storage; + } + async loadServers() { + this.servers = await this.storage.load(); + } + getServers() { + return this.servers; + } + getEnabledCount() { + return this.servers.filter((s3) => s3.enabled).length; + } + /** + * Get servers to include in SDK options. + * + * A server is included if: + * - It is enabled AND + * - Either context-saving is disabled OR the server is @-mentioned + * + * @param mentionedNames Set of server names that were @-mentioned in the prompt + */ + getActiveServers(mentionedNames) { + const result = {}; + for (const server of this.servers) { + if (!server.enabled) continue; + if (server.contextSaving && !mentionedNames.has(server.name)) { + continue; + } + result[server.name] = server.config; + } + return result; + } + /** + * Get disabled MCP tools formatted for SDK disallowedTools option. + * + * Only returns disabled tools from servers that would be active (same filter as getActiveServers). + * + * @param mentionedNames Set of server names that were @-mentioned in the prompt + */ + getDisallowedMcpTools(mentionedNames) { + return this.collectDisallowedTools( + (s3) => !s3.contextSaving || mentionedNames.has(s3.name) + ); + } + /** + * Get all disabled MCP tools from ALL enabled servers (ignoring @-mentions). + * + * Used for persistent queries to pre-register all disabled tools upfront, + * so @-mentioning servers doesn't require cold start. + */ + getAllDisallowedMcpTools() { + return this.collectDisallowedTools().sort(); + } + collectDisallowedTools(filter) { + const disallowed = /* @__PURE__ */ new Set(); + for (const server of this.servers) { + if (!server.enabled) continue; + if (filter && !filter(server)) continue; + if (!server.disabledTools || server.disabledTools.length === 0) continue; + for (const tool of server.disabledTools) { + const normalized = tool.trim(); + if (!normalized) continue; + disallowed.add(`mcp__${server.name}__${normalized}`); + } + } + return Array.from(disallowed); + } + hasServers() { + return this.servers.length > 0; + } + getContextSavingServers() { + return this.servers.filter((s3) => s3.enabled && s3.contextSaving); + } + getContextSavingNames() { + return new Set(this.getContextSavingServers().map((s3) => s3.name)); + } + /** Only matches against enabled servers with context-saving mode. */ + extractMentions(text) { + return extractMcpMentions(text, this.getContextSavingNames()); + } + /** + * Appends " MCP" after each valid @mention. Applied to API requests only, not shown in UI. + */ + transformMentions(text) { + return transformMcpMentions(text, this.getContextSavingNames()); + } +}; + +// src/providers/claude/agents/AgentManager.ts +var fs2 = __toESM(require("fs")); +var os2 = __toESM(require("os")); +var path2 = __toESM(require("path")); + +// src/utils/frontmatter.ts +var import_obsidian = require("obsidian"); +var FRONTMATTER_PATTERN = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/; +var VALID_KEY_PATTERN = /^[\w-]+$/; +function isValidKey(key) { + return key.length > 0 && VALID_KEY_PATTERN.test(key); +} +function unquote(value) { + if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) { + return value.slice(1, -1); + } + return value; +} +function parseScalarValue(rawValue) { + const value = rawValue.trim(); + if (value === "true") return true; + if (value === "false") return false; + if (value === "null" || value === "") return null; + if (!Number.isNaN(Number(value))) return Number(value); + if (value.startsWith("[") && value.endsWith("]")) { + return value.slice(1, -1).split(",").map((item) => item.trim()).filter(Boolean).map((item) => unquote(item)); + } + return unquote(value); +} +function parseFrontmatterFallback(yamlContent) { + const result = {}; + const lines = yamlContent.split(/\r?\n/); + let currentListKey = null; + let currentList = []; + function flushList() { + if (!currentListKey) return; + result[currentListKey] = currentList; + currentListKey = null; + currentList = []; + } + let pendingBareKey = null; + for (const line of lines) { + const trimmed = line.trim(); + if (!trimmed || trimmed.startsWith("#")) continue; + if (currentListKey) { + if (trimmed.startsWith("- ")) { + currentList.push(parseScalarValue(trimmed.slice(2))); + continue; + } + flushList(); + } + if (pendingBareKey) { + if (trimmed.startsWith("- ")) { + currentListKey = pendingBareKey; + currentList = []; + pendingBareKey = null; + currentList.push(parseScalarValue(trimmed.slice(2))); + continue; + } + result[pendingBareKey] = ""; + pendingBareKey = null; + } + const colonIndex = trimmed.indexOf(": "); + if (colonIndex === -1) { + if (trimmed.endsWith(":")) { + const key2 = trimmed.slice(0, -1).trim(); + if (isValidKey(key2)) { + pendingBareKey = key2; + } + } + continue; + } + const key = trimmed.slice(0, colonIndex).trim(); + if (!isValidKey(key)) continue; + result[key] = parseScalarValue(trimmed.slice(colonIndex + 2)); + } + if (pendingBareKey) { + result[pendingBareKey] = ""; + } + flushList(); + return result; +} +function parseFrontmatter(content) { + const match = content.match(FRONTMATTER_PATTERN); + if (!match) return null; + try { + const parsed = (0, import_obsidian.parseYaml)(match[1]); + if (parsed !== null && parsed !== void 0 && typeof parsed !== "object") { + return null; + } + return { + frontmatter: parsed != null ? parsed : {}, + body: match[2] + }; + } catch (e3) { + const fallbackParsed = parseFrontmatterFallback(match[1]); + if (Object.keys(fallbackParsed).length > 0) { + return { + frontmatter: fallbackParsed, + body: match[2] + }; + } + return null; + } +} +function extractString(fm, key) { + const val = fm[key]; + if (typeof val === "string" && val.length > 0) return val; + if (Array.isArray(val) && val.length > 0 && val.every((v2) => typeof v2 === "string")) { + return val.map((v2) => `[${v2}]`).join(" "); + } + return void 0; +} +function normalizeStringArray(val) { + if (val === void 0 || val === null) return void 0; + if (Array.isArray(val)) { + return val.map((v2) => String(v2).trim()).filter(Boolean); + } + if (typeof val === "string") { + const trimmed = val.trim(); + if (!trimmed) return void 0; + return trimmed.split(",").map((s3) => s3.trim()).filter(Boolean); + } + return void 0; +} +function extractStringArray(fm, key) { + return normalizeStringArray(fm[key]); +} +function extractBoolean(fm, key) { + const val = fm[key]; + if (typeof val === "boolean") return val; + return void 0; +} +function isRecord(value) { + return value != null && typeof value === "object" && !Array.isArray(value); +} +var MAX_SLUG_LENGTH = 64; +var SLUG_PATTERN = /^[a-z0-9-]+$/; +var YAML_RESERVED_WORDS = /* @__PURE__ */ new Set(["true", "false", "null", "yes", "no", "on", "off"]); +function validateSlugName(name, label) { + if (!name) { + return `${label} name is required`; + } + if (name.length > MAX_SLUG_LENGTH) { + return `${label} name must be ${MAX_SLUG_LENGTH} characters or fewer`; + } + if (!SLUG_PATTERN.test(name)) { + return `${label} name can only contain lowercase letters, numbers, and hyphens`; + } + if (YAML_RESERVED_WORDS.has(name)) { + return `${label} name cannot be a YAML reserved word (true, false, null, yes, no, on, off)`; + } + return null; +} + +// src/providers/claude/types/agent.ts +var AGENT_PERMISSION_MODES = ["default", "acceptEdits", "dontAsk", "bypassPermissions", "plan", "delegate"]; + +// src/providers/claude/agents/AgentStorage.ts +var KNOWN_AGENT_KEYS = /* @__PURE__ */ new Set([ + "name", + "description", + "tools", + "disallowedTools", + "model", + "skills", + "permissionMode", + "hooks" +]); +function parseAgentFile(content) { + const parsed = parseFrontmatter(content); + if (!parsed) return null; + const { frontmatter: fm, body } = parsed; + const name = fm.name; + const description = fm.description; + if (typeof name !== "string" || !name.trim()) return null; + if (typeof description !== "string" || !description.trim()) return null; + const tools = fm.tools; + const disallowedTools = fm.disallowedTools; + if (tools !== void 0 && !isStringOrArray(tools)) return null; + if (disallowedTools !== void 0 && !isStringOrArray(disallowedTools)) return null; + const model = typeof fm.model === "string" ? fm.model : void 0; + const extra = {}; + for (const key of Object.keys(fm)) { + if (!KNOWN_AGENT_KEYS.has(key)) { + extra[key] = fm[key]; + } + } + const frontmatter = { + name, + description, + tools, + disallowedTools, + model, + skills: extractStringArray(fm, "skills"), + permissionMode: typeof fm.permissionMode === "string" ? fm.permissionMode : void 0, + hooks: isRecord(fm.hooks) ? fm.hooks : void 0, + extraFrontmatter: Object.keys(extra).length > 0 ? extra : void 0 + }; + return { frontmatter, body: body.trim() }; +} +function isStringOrArray(value) { + return typeof value === "string" || Array.isArray(value); +} +function parseToolsList(tools) { + return normalizeStringArray(tools); +} +function parsePermissionMode(mode) { + if (!mode) return void 0; + const trimmed = mode.trim(); + if (AGENT_PERMISSION_MODES.includes(trimmed)) { + return trimmed; + } + return void 0; +} +var VALID_MODELS = ["sonnet", "opus", "haiku", "inherit"]; +function parseModel(model) { + if (!model) return "inherit"; + const normalized = model.toLowerCase().trim(); + if (VALID_MODELS.includes(normalized)) { + return normalized; + } + return "inherit"; +} +function buildAgentFromFrontmatter(frontmatter, body, meta3) { + return { + id: meta3.id, + name: frontmatter.name, + description: frontmatter.description, + prompt: body, + tools: parseToolsList(frontmatter.tools), + disallowedTools: parseToolsList(frontmatter.disallowedTools), + model: parseModel(frontmatter.model), + source: meta3.source, + filePath: meta3.filePath, + pluginName: meta3.pluginName, + skills: frontmatter.skills, + permissionMode: parsePermissionMode(frontmatter.permissionMode), + hooks: frontmatter.hooks, + extraFrontmatter: frontmatter.extraFrontmatter + }; +} + +// src/providers/claude/agents/AgentManager.ts +var GLOBAL_AGENTS_DIR = path2.join(os2.homedir(), ".claude", "agents"); +var VAULT_AGENTS_DIR = ".claude/agents"; +var PLUGIN_AGENTS_DIR = "agents"; +var FALLBACK_BUILTIN_AGENT_NAMES = ["Explore", "Plan", "Bash", "general-purpose"]; +var BUILTIN_AGENT_DESCRIPTIONS = { + "Explore": "Fast codebase exploration and search", + "Plan": "Implementation planning and architecture", + "Bash": "Command execution specialist", + "general-purpose": "Multi-step tasks and complex workflows" +}; +function makeBuiltinAgent(name) { + var _a3; + return { + id: name, + name: name.replace(/-/g, " ").replace(/\b\w/g, (l3) => l3.toUpperCase()), + description: (_a3 = BUILTIN_AGENT_DESCRIPTIONS[name]) != null ? _a3 : "", + prompt: "", + // Built-in — prompt managed by SDK + source: "builtin" + }; +} +function normalizePluginName(name) { + return name.toLowerCase().replace(/\s+/g, "-"); +} +var AgentManager = class { + constructor(vaultPath, pluginManager) { + this.agents = []; + this.builtinAgentNames = FALLBACK_BUILTIN_AGENT_NAMES; + this.vaultPath = vaultPath; + this.pluginManager = pluginManager; + } + /** Built-in agents are those from init that are NOT loaded from files. */ + setBuiltinAgentNames(names) { + this.builtinAgentNames = names; + const fileAgentIds = new Set( + this.agents.filter((a3) => a3.source !== "builtin").map((a3) => a3.id) + ); + this.agents = [ + ...names.filter((n3) => !fileAgentIds.has(n3)).map(makeBuiltinAgent), + ...this.agents.filter((a3) => a3.source !== "builtin") + ]; + } + async loadAgents() { + this.agents = []; + for (const name of this.builtinAgentNames) { + this.addAgent(makeBuiltinAgent(name)); + } + try { + this.loadPluginAgents(); + } catch (e3) { + } + try { + this.loadVaultAgents(); + } catch (e3) { + } + try { + this.loadGlobalAgents(); + } catch (e3) { + } + } + getAvailableAgents() { + return [...this.agents]; + } + getAgentById(id) { + return this.agents.find((a3) => a3.id === id); + } + /** Used for @-mention filtering in the chat input. */ + searchAgents(query) { + const q3 = query.toLowerCase(); + return this.agents.filter( + (a3) => a3.name.toLowerCase().includes(q3) || a3.id.toLowerCase().includes(q3) || a3.description.toLowerCase().includes(q3) + ); + } + loadPluginAgents() { + for (const plugin of this.pluginManager.getPlugins()) { + if (!plugin.enabled) continue; + const agentsDir = path2.join(plugin.installPath, PLUGIN_AGENTS_DIR); + if (!fs2.existsSync(agentsDir)) continue; + this.loadAgentsFromFiles( + this.listMarkdownFiles(agentsDir), + (filePath) => this.parsePluginAgentFromFile(filePath, plugin.name) + ); + } + } + loadVaultAgents() { + this.loadAgentsFromDirectory(path2.join(this.vaultPath, VAULT_AGENTS_DIR), "vault"); + } + loadGlobalAgents() { + this.loadAgentsFromDirectory(GLOBAL_AGENTS_DIR, "global"); + } + loadAgentsFromDirectory(dir, source) { + if (!fs2.existsSync(dir)) return; + this.loadAgentsFromFiles( + this.listMarkdownFiles(dir), + (filePath) => this.parseAgentFromFile(filePath, source) + ); + } + listMarkdownFiles(dir) { + const files = []; + try { + const entries = fs2.readdirSync(dir, { withFileTypes: true }); + for (const entry of entries) { + if (entry.isFile() && entry.name.endsWith(".md")) { + files.push(path2.join(dir, entry.name)); + } + } + } catch (e3) { + } + return files; + } + parsePluginAgentFromFile(filePath, pluginName) { + return this.parseAgentDefinition( + filePath, + (agentName) => `${normalizePluginName(pluginName)}:${agentName}`, + (frontmatter, body, id) => buildAgentFromFrontmatter(frontmatter, body, { + id, + source: "plugin", + pluginName, + filePath + }) + ); + } + parseAgentFromFile(filePath, source) { + return this.parseAgentDefinition( + filePath, + (agentName) => agentName, + (frontmatter, body, id) => buildAgentFromFrontmatter(frontmatter, body, { + id, + source, + filePath + }) + ); + } + loadAgentsFromFiles(filePaths, loadAgent) { + for (const filePath of filePaths) { + this.addAgent(loadAgent(filePath)); + } + } + addAgent(agent) { + if (!agent) { + return; + } + if (this.agents.some((existing) => existing.id === agent.id)) { + return; + } + this.agents.push(agent); + } + parseAgentDefinition(filePath, buildId, buildAgent) { + try { + const content = fs2.readFileSync(filePath, "utf-8"); + const parsed = parseAgentFile(content); + if (!parsed) { + return null; + } + const { frontmatter, body } = parsed; + return buildAgent(frontmatter, body, buildId(frontmatter.name)); + } catch (e3) { + return null; + } + } +}; + +// src/utils/slashCommand.ts +function extractFirstParagraph(content) { + const paragraph = content.split(/\n\s*\n/).find((p) => p.trim()); + if (!paragraph) return void 0; + return paragraph.trim().replace(/\n/g, " "); +} +function validateCommandName(name) { + return validateSlugName(name, "Command"); +} +function isSkill(cmd) { + if (cmd.kind) return cmd.kind === "skill"; + return cmd.id.startsWith("skill-"); +} +function parsedToSlashCommand(parsed, identity) { + return { + ...identity, + description: parsed.description, + argumentHint: parsed.argumentHint, + allowedTools: parsed.allowedTools, + model: parsed.model, + content: parsed.promptContent, + disableModelInvocation: parsed.disableModelInvocation, + userInvocable: parsed.userInvocable, + context: parsed.context, + agent: parsed.agent, + hooks: parsed.hooks + }; +} +function parseSlashCommandContent(content) { + var _a3, _b2, _c, _d; + const parsed = parseFrontmatter(content); + if (!parsed) { + return { promptContent: content }; + } + const fm = parsed.frontmatter; + return { + // Existing fields — support both kebab-case (file format) and camelCase + description: extractString(fm, "description"), + argumentHint: (_a3 = extractString(fm, "argument-hint")) != null ? _a3 : extractString(fm, "argumentHint"), + allowedTools: (_b2 = extractStringArray(fm, "allowed-tools")) != null ? _b2 : extractStringArray(fm, "allowedTools"), + model: extractString(fm, "model"), + promptContent: parsed.body, + // Skill fields — kebab-case preferred (CC file format), camelCase for backwards compat + disableModelInvocation: (_c = extractBoolean(fm, "disable-model-invocation")) != null ? _c : extractBoolean(fm, "disableModelInvocation"), + userInvocable: (_d = extractBoolean(fm, "user-invocable")) != null ? _d : extractBoolean(fm, "userInvocable"), + context: extractString(fm, "context") === "fork" ? "fork" : void 0, + agent: extractString(fm, "agent"), + hooks: isRecord(fm.hooks) ? fm.hooks : void 0 + }; +} +function normalizeArgumentHint(hint) { + if (!hint) return hint; + if (hint.includes("[") || hint.includes("<")) return hint; + return `[${hint}]`; +} +function yamlString(value) { + if (value.includes(":") || value.includes("#") || value.includes("\n") || value.startsWith(" ") || value.endsWith(" ") || value.startsWith("[") || value.startsWith("{")) { + return `"${value.replace(/"/g, '\\"')}"`; + } + return value; +} +function serializeCommand(cmd) { + const parsed = parseSlashCommandContent(cmd.content); + return serializeSlashCommandMarkdown(cmd, parsed.promptContent); +} +function serializeSlashCommandMarkdown(cmd, body) { + const lines = ["---"]; + if (cmd.name) { + lines.push(`name: ${cmd.name}`); + } + if (cmd.description) { + lines.push(`description: ${yamlString(cmd.description)}`); + } + if (cmd.argumentHint) { + lines.push(`argument-hint: ${yamlString(cmd.argumentHint)}`); + } + if (cmd.allowedTools && cmd.allowedTools.length > 0) { + lines.push("allowed-tools:"); + for (const tool of cmd.allowedTools) { + lines.push(` - ${yamlString(tool)}`); + } + } + if (cmd.model) { + lines.push(`model: ${cmd.model}`); + } + if (cmd.disableModelInvocation !== void 0) { + lines.push(`disable-model-invocation: ${cmd.disableModelInvocation}`); + } + if (cmd.userInvocable !== void 0) { + lines.push(`user-invocable: ${cmd.userInvocable}`); + } + if (cmd.context) { + lines.push(`context: ${cmd.context}`); + } + if (cmd.agent) { + lines.push(`agent: ${cmd.agent}`); + } + if (cmd.hooks !== void 0) { + lines.push(`hooks: ${JSON.stringify(cmd.hooks)}`); + } + if (lines.length === 1) { + lines.push(""); + } + lines.push("---"); + lines.push(body); + return lines.join("\n"); +} + +// src/providers/claude/commands/ClaudeCommandCatalog.ts +function slashCommandToEntry(cmd) { + var _a3; + const skill = isSkill(cmd); + return { + id: cmd.id, + providerId: "claude", + kind: skill ? "skill" : "command", + name: cmd.name, + description: cmd.description, + content: cmd.content, + argumentHint: cmd.argumentHint, + allowedTools: cmd.allowedTools, + model: cmd.model, + disableModelInvocation: cmd.disableModelInvocation, + userInvocable: cmd.userInvocable, + context: cmd.context, + agent: cmd.agent, + hooks: cmd.hooks, + scope: cmd.source === "sdk" ? "runtime" : "vault", + source: (_a3 = cmd.source) != null ? _a3 : "user", + isEditable: cmd.source !== "sdk", + isDeletable: cmd.source !== "sdk", + displayPrefix: "/", + insertPrefix: "/" + }; +} +function entryToSlashCommand(entry) { + return { + id: entry.id, + name: entry.name, + description: entry.description, + content: entry.content, + argumentHint: entry.argumentHint, + allowedTools: entry.allowedTools, + model: entry.model, + disableModelInvocation: entry.disableModelInvocation, + userInvocable: entry.userInvocable, + context: entry.context, + agent: entry.agent, + hooks: entry.hooks, + source: entry.source, + kind: entry.kind + }; +} +var ClaudeCommandCatalog = class { + constructor(commandStorage, skillStorage) { + this.commandStorage = commandStorage; + this.skillStorage = skillStorage; + this.sdkCommands = []; + } + setRuntimeCommands(commands) { + this.sdkCommands = commands; + } + async listDropdownEntries(context) { + void context; + const commands = await this.commandStorage.loadAll(); + const skills = await this.skillStorage.loadAll(); + const vaultEntries = [...commands, ...skills].map(slashCommandToEntry); + const sdkEntries = this.sdkCommands.map(slashCommandToEntry); + const seen = new Set(vaultEntries.map((e3) => e3.name.toLowerCase())); + const deduped = sdkEntries.filter((e3) => !seen.has(e3.name.toLowerCase())); + return [...vaultEntries, ...deduped]; + } + async listVaultEntries() { + const commands = await this.commandStorage.loadAll(); + const skills = await this.skillStorage.loadAll(); + return [...commands, ...skills].map(slashCommandToEntry); + } + async saveVaultEntry(entry) { + const cmd = entryToSlashCommand(entry); + if (entry.kind === "skill") { + await this.skillStorage.save(cmd); + } else { + await this.commandStorage.save(cmd); + } + } + async deleteVaultEntry(entry) { + if (entry.kind === "skill") { + await this.skillStorage.delete(entry.id); + } else { + await this.commandStorage.delete(entry.id); + } + } + getDropdownConfig() { + return { + providerId: "claude", + triggerChars: ["/"], + builtInPrefix: "/", + skillPrefix: "/", + commandPrefix: "/" + }; + } + async refresh() { + } +}; + +// src/providers/claude/plugins/PluginManager.ts +var fs3 = __toESM(require("fs")); +var import_obsidian2 = require("obsidian"); +var os3 = __toESM(require("os")); +var path3 = __toESM(require("path")); +var INSTALLED_PLUGINS_PATH = path3.join(os3.homedir(), ".claude", "plugins", "installed_plugins.json"); +var GLOBAL_SETTINGS_PATH = path3.join(os3.homedir(), ".claude", "settings.json"); +function readJsonFile(filePath) { + try { + if (!fs3.existsSync(filePath)) { + return null; + } + const content = fs3.readFileSync(filePath, "utf-8"); + return JSON.parse(content); + } catch (e3) { + return null; + } +} +function normalizePathForComparison(p) { + try { + const resolved = fs3.realpathSync(p); + if (typeof resolved === "string" && resolved.length > 0) { + return resolved; + } + } catch (e3) { + } + return path3.resolve(p); +} +function selectInstalledPluginEntry(entries, normalizedVaultPath) { + var _a3; + for (const entry of entries) { + if (entry.scope !== "project") continue; + if (!entry.projectPath) continue; + if (normalizePathForComparison(entry.projectPath) === normalizedVaultPath) { + return entry; + } + } + return (_a3 = entries.find((e3) => e3.scope === "user")) != null ? _a3 : null; +} +function extractPluginName(pluginId) { + const atIndex = pluginId.indexOf("@"); + if (atIndex > 0) { + return pluginId.substring(0, atIndex); + } + return pluginId; +} +var PluginManager = class { + constructor(vaultPath, ccSettingsStorage) { + this.plugins = []; + this.vaultPath = vaultPath; + this.ccSettingsStorage = ccSettingsStorage; + } + async loadPlugins() { + var _a3, _b2, _c, _d; + const installedPlugins = readJsonFile(INSTALLED_PLUGINS_PATH); + const globalSettings = readJsonFile(GLOBAL_SETTINGS_PATH); + const projectSettings = await this.loadProjectSettings(); + const globalEnabled = (_a3 = globalSettings == null ? void 0 : globalSettings.enabledPlugins) != null ? _a3 : {}; + const projectEnabled = (_b2 = projectSettings == null ? void 0 : projectSettings.enabledPlugins) != null ? _b2 : {}; + const plugins = []; + const normalizedVaultPath = normalizePathForComparison(this.vaultPath); + if (installedPlugins == null ? void 0 : installedPlugins.plugins) { + for (const [pluginId, entries] of Object.entries(installedPlugins.plugins)) { + if (!entries || entries.length === 0) continue; + const entriesArray = Array.isArray(entries) ? entries : [entries]; + if (!Array.isArray(entries)) { + new import_obsidian2.Notice(`Claudian: plugin "${pluginId}" has malformed entry in installed_plugins.json (expected array, got ${typeof entries})`); + } + const entry = selectInstalledPluginEntry(entriesArray, normalizedVaultPath); + if (!entry) continue; + const scope = entry.scope === "project" ? "project" : "user"; + const enabled = (_d = (_c = projectEnabled[pluginId]) != null ? _c : globalEnabled[pluginId]) != null ? _d : true; + plugins.push({ + id: pluginId, + name: extractPluginName(pluginId), + enabled, + scope, + installPath: entry.installPath + }); + } + } + this.plugins = plugins.sort((a3, b) => { + if (a3.scope !== b.scope) { + return a3.scope === "project" ? -1 : 1; + } + return a3.id.localeCompare(b.id); + }); + } + async loadProjectSettings() { + const projectSettingsPath = path3.join(this.vaultPath, ".claude", "settings.json"); + return readJsonFile(projectSettingsPath); + } + getPlugins() { + return [...this.plugins]; + } + hasPlugins() { + return this.plugins.length > 0; + } + hasEnabledPlugins() { + return this.plugins.some((p) => p.enabled); + } + getEnabledCount() { + return this.plugins.filter((p) => p.enabled).length; + } + /** Used to detect changes that require restarting the persistent query. */ + getPluginsKey() { + const enabledPlugins = this.plugins.filter((p) => p.enabled).sort((a3, b) => a3.id.localeCompare(b.id)); + if (enabledPlugins.length === 0) { + return ""; + } + return enabledPlugins.map((p) => `${p.id}:${p.installPath}`).join("|"); + } + /** Writes to project .claude/settings.json so CLI respects the state. */ + async togglePlugin(pluginId) { + const plugin = this.plugins.find((p) => p.id === pluginId); + if (!plugin) { + return; + } + const newEnabled = !plugin.enabled; + plugin.enabled = newEnabled; + await this.ccSettingsStorage.setPluginEnabled(pluginId, newEnabled); + } + async enablePlugin(pluginId) { + const plugin = this.plugins.find((p) => p.id === pluginId); + if (!plugin || plugin.enabled) { + return; + } + plugin.enabled = true; + await this.ccSettingsStorage.setPluginEnabled(pluginId, true); + } + async disablePlugin(pluginId) { + const plugin = this.plugins.find((p) => p.id === pluginId); + if (!plugin || !plugin.enabled) { + return; + } + plugin.enabled = false; + await this.ccSettingsStorage.setPluginEnabled(pluginId, false); + } +}; + +// src/providers/claude/runtime/ClaudeCliResolver.ts +var fs7 = __toESM(require("fs")); + +// src/core/providers/providerEnvironment.ts +init_env(); + +// src/core/providers/providerConfig.ts +function isRecord2(value) { + return !!value && typeof value === "object" && !Array.isArray(value); +} +function getProviderConfig(settings11, providerId) { + const candidate = settings11.providerConfigs; + if (!isRecord2(candidate)) { + return {}; + } + const config2 = candidate[providerId]; + return isRecord2(config2) ? { ...config2 } : {}; +} +function setProviderConfig(settings11, providerId, config2) { + const current = settings11.providerConfigs; + const nextConfigs = isRecord2(current) ? { ...current } : {}; + nextConfigs[providerId] = { ...config2 }; + settings11.providerConfigs = nextConfigs; +} + +// src/core/providers/providerEnvironment.ts +var SHARED_ENVIRONMENT_KEYS = /* @__PURE__ */ new Set([ + "PATH", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "ALL_PROXY", + "SSL_CERT_FILE", + "SSL_CERT_DIR", + "REQUESTS_CA_BUNDLE", + "CURL_CA_BUNDLE", + "NODE_EXTRA_CA_CERTS", + "TMPDIR", + "TMP", + "TEMP" +]); +function resolveScopeProviderId(scope) { + return scope.startsWith("provider:") ? scope.slice("provider:".length) : null; +} +function classifyEnvironmentKey(key) { + const normalized = key.trim().toUpperCase(); + if (!normalized) { + return { type: "shared-unknown" }; + } + if (SHARED_ENVIRONMENT_KEYS.has(normalized)) { + return { type: "shared-known" }; + } + for (const providerId of ProviderRegistry.getRegisteredProviderIds()) { + const patterns = ProviderRegistry.getEnvironmentKeyPatterns(providerId); + if (patterns.some((pattern) => pattern.test(normalized))) { + return { type: "provider", providerId }; + } + } + return { type: "shared-unknown" }; +} +function extractEnvironmentKey(line) { + const trimmed = line.trim(); + if (!trimmed || trimmed.startsWith("#")) { + return null; + } + const normalized = trimmed.startsWith("export ") ? trimmed.slice(7) : trimmed; + const eqIndex = normalized.indexOf("="); + if (eqIndex <= 0) { + return null; + } + const key = normalized.slice(0, eqIndex).trim(); + return key || null; +} +function appendLines(target, pendingDecorators, line) { + target.push(...pendingDecorators, line); +} +function createClassifiedEnvironmentLines() { + return { + shared: [], + providers: {}, + reviewKeys: /* @__PURE__ */ new Set() + }; +} +function joinEnvironmentLines(lines) { + return lines.join("\n"); +} +function hasMeaningfulEnvironmentContent(envText) { + return envText.split(/\r?\n/).some((line) => { + const trimmed = line.trim(); + return trimmed.length > 0 && !trimmed.startsWith("#"); + }); +} +function getLegacyEnvironmentClassification(settings11) { + const legacyEnvironmentVariables = settings11.environmentVariables; + if (typeof legacyEnvironmentVariables !== "string" || legacyEnvironmentVariables.length === 0) { + return { + shared: "", + providers: {}, + reviewKeys: [] + }; + } + return classifyEnvironmentVariablesByOwnership(legacyEnvironmentVariables); +} +function classifyEnvironmentVariablesByOwnership(input) { + var _a3; + const result = createClassifiedEnvironmentLines(); + let pendingDecorators = []; + for (const line of input.split(/\r?\n/)) { + const trimmed = line.trim(); + if (!trimmed || trimmed.startsWith("#")) { + pendingDecorators.push(line); + continue; + } + const key = extractEnvironmentKey(line); + if (!key) { + appendLines(result.shared, pendingDecorators, line); + pendingDecorators = []; + continue; + } + const ownership = classifyEnvironmentKey(key); + if (ownership.type === "provider") { + const target = (_a3 = result.providers[ownership.providerId]) != null ? _a3 : []; + appendLines(target, pendingDecorators, line); + result.providers[ownership.providerId] = target; + } else { + appendLines(result.shared, pendingDecorators, line); + if (ownership.type === "shared-unknown") { + result.reviewKeys.add(key); + } + } + pendingDecorators = []; + } + if (pendingDecorators.length > 0) { + result.shared.push(...pendingDecorators); + } + return { + shared: joinEnvironmentLines(result.shared), + providers: Object.fromEntries( + Object.entries(result.providers).map(([providerId, lines]) => [ + providerId, + joinEnvironmentLines(lines != null ? lines : []) + ]) + ), + reviewKeys: Array.from(result.reviewKeys) + }; +} +function getSharedEnvironmentVariables(settings11) { + const sharedEnvironmentVariables = settings11.sharedEnvironmentVariables; + if (typeof sharedEnvironmentVariables === "string") { + return sharedEnvironmentVariables; + } + return getLegacyEnvironmentClassification(settings11).shared; +} +function setSharedEnvironmentVariables(settings11, envText) { + settings11.sharedEnvironmentVariables = envText; + delete settings11.environmentVariables; +} +function getProviderEnvironmentVariables(settings11, providerId) { + var _a3; + const providerConfig = getProviderConfig(settings11, providerId); + if (typeof providerConfig.environmentVariables === "string") { + return providerConfig.environmentVariables; + } + return (_a3 = getLegacyEnvironmentClassification(settings11).providers[providerId]) != null ? _a3 : ""; +} +function setProviderEnvironmentVariables(settings11, providerId, envText) { + setProviderConfig(settings11, providerId, { + ...getProviderConfig(settings11, providerId), + environmentVariables: envText + }); + delete settings11.environmentVariables; +} +function joinEnvironmentTexts(...parts) { + const filtered = parts.filter((part) => typeof part === "string" && part.length > 0); + if (filtered.length === 0) { + return ""; + } + return filtered.reduce((combined, part) => { + if (!combined) { + return part; + } + return combined.endsWith("\n") ? `${combined}${part}` : `${combined} +${part}`; + }, ""); +} +function getRuntimeEnvironmentText(settings11, providerId) { + return joinEnvironmentTexts( + getSharedEnvironmentVariables(settings11), + getProviderEnvironmentVariables(settings11, providerId) + ); +} +function getRuntimeEnvironmentVariables(settings11, providerId) { + return parseEnvironmentVariables(getRuntimeEnvironmentText(settings11, providerId)); +} +function getEnvironmentVariablesForScope(settings11, scope) { + var _a3; + if (scope === "shared") { + return getSharedEnvironmentVariables(settings11); + } + return getProviderEnvironmentVariables(settings11, (_a3 = resolveScopeProviderId(scope)) != null ? _a3 : ""); +} +function setEnvironmentVariablesForScope(settings11, scope, envText) { + if (scope === "shared") { + setSharedEnvironmentVariables(settings11, envText); + return; + } + const providerId = resolveScopeProviderId(scope); + if (!providerId) { + return; + } + setProviderEnvironmentVariables(settings11, providerId, envText); +} +function getEnvironmentReviewKeysForScope(envText, scope) { + const reviewKeys = /* @__PURE__ */ new Set(); + const expectedProviderId = resolveScopeProviderId(scope); + for (const line of envText.split(/\r?\n/)) { + const key = extractEnvironmentKey(line); + if (!key || reviewKeys.has(key)) { + continue; + } + const ownership = classifyEnvironmentKey(key); + if (scope === "shared") { + if (ownership.type !== "shared-known") { + reviewKeys.add(key); + } + continue; + } + if (ownership.type !== "provider" || ownership.providerId !== expectedProviderId) { + reviewKeys.add(key); + } + } + return Array.from(reviewKeys); +} +function inferEnvironmentSnippetScope(envText) { + const classified = classifyEnvironmentVariablesByOwnership(envText); + const nonEmptyScopes = []; + if (hasMeaningfulEnvironmentContent(classified.shared)) { + nonEmptyScopes.push("shared"); + } + for (const [providerId, providerEnv] of Object.entries(classified.providers)) { + if (providerEnv && hasMeaningfulEnvironmentContent(providerEnv)) { + nonEmptyScopes.push(`provider:${providerId}`); + } + } + return nonEmptyScopes.length === 1 ? nonEmptyScopes[0] : void 0; +} +function resolveEnvironmentSnippetScope(envText, fallbackScope) { + const inferredScope = inferEnvironmentSnippetScope(envText); + if (inferredScope) { + return inferredScope; + } + return hasMeaningfulEnvironmentContent(envText) ? void 0 : fallbackScope; +} +function getEnvironmentScopeUpdates(envText, fallbackScope) { + const classified = classifyEnvironmentVariablesByOwnership(envText); + const updates = []; + if (classified.shared.trim()) { + updates.push({ scope: "shared", envText: classified.shared }); + } + for (const [providerId, providerEnv] of Object.entries(classified.providers)) { + if (!providerEnv || !providerEnv.trim()) { + continue; + } + updates.push({ + scope: `provider:${providerId}`, + envText: providerEnv + }); + } + if (updates.length > 0) { + return updates; + } + if (fallbackScope) { + return [{ scope: fallbackScope, envText }]; + } + return []; +} + +// src/providers/claude/runtime/ClaudeCliResolver.ts +init_env(); +init_path(); + +// src/providers/claude/cli/findClaudeCLIPath.ts +var fs6 = __toESM(require("fs")); +var os6 = __toESM(require("os")); +var path6 = __toESM(require("path")); +init_path(); +function getEnvValue2(name) { + return process.env[name]; +} +function dedupePaths(entries) { + const seen = /* @__PURE__ */ new Set(); + return entries.filter((entry) => { + const key = process.platform === "win32" ? entry.toLowerCase() : entry; + if (seen.has(key)) return false; + seen.add(key); + return true; + }); +} +function findFirstExistingPath(entries, candidates) { + for (const dir of entries) { + if (!dir) continue; + for (const candidate of candidates) { + const fullPath = path6.join(dir, candidate); + if (isExistingFile(fullPath)) { + return fullPath; + } + } + } + return null; +} +function isExistingFile(filePath) { + try { + if (fs6.existsSync(filePath)) { + const stat = fs6.statSync(filePath); + return stat.isFile(); + } + } catch (e3) { + } + return false; +} +function resolveCliJsNearPathEntry(entry, isWindows2) { + const directCandidate = path6.join(entry, "node_modules", "@anthropic-ai", "claude-code", "cli.js"); + if (isExistingFile(directCandidate)) { + return directCandidate; + } + const baseName = path6.basename(entry).toLowerCase(); + if (baseName === "bin") { + const prefix = path6.dirname(entry); + const candidate = isWindows2 ? path6.join(prefix, "node_modules", "@anthropic-ai", "claude-code", "cli.js") : path6.join(prefix, "lib", "node_modules", "@anthropic-ai", "claude-code", "cli.js"); + if (isExistingFile(candidate)) { + return candidate; + } + } + return null; +} +function resolveCliJsFromPathEntries(entries, isWindows2) { + for (const entry of entries) { + const candidate = resolveCliJsNearPathEntry(entry, isWindows2); + if (candidate) { + return candidate; + } + } + return null; +} +function resolveClaudeFromPathEntries(entries, isWindows2) { + if (entries.length === 0) { + return null; + } + if (!isWindows2) { + const unixCandidate = findFirstExistingPath(entries, ["claude"]); + return unixCandidate; + } + const exeCandidate = findFirstExistingPath(entries, ["claude.exe", "claude"]); + if (exeCandidate) { + return exeCandidate; + } + const cliJsCandidate = resolveCliJsFromPathEntries(entries, isWindows2); + if (cliJsCandidate) { + return cliJsCandidate; + } + return null; +} +function getNpmGlobalPrefix() { + if (process.env.npm_config_prefix) { + return process.env.npm_config_prefix; + } + if (process.platform === "win32") { + const appDataNpm = process.env.APPDATA ? path6.join(process.env.APPDATA, "npm") : null; + if (appDataNpm && fs6.existsSync(appDataNpm)) { + return appDataNpm; + } + } + return null; +} +function getNpmCliJsPaths() { + const homeDir = os6.homedir(); + const isWindows2 = process.platform === "win32"; + const cliJsPaths = []; + if (isWindows2) { + cliJsPaths.push( + path6.join(homeDir, "AppData", "Roaming", "npm", "node_modules", "@anthropic-ai", "claude-code", "cli.js") + ); + const npmPrefix = getNpmGlobalPrefix(); + if (npmPrefix) { + cliJsPaths.push( + path6.join(npmPrefix, "node_modules", "@anthropic-ai", "claude-code", "cli.js") + ); + } + const programFiles = process.env.ProgramFiles || "C:\\Program Files"; + const programFilesX86 = process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)"; + cliJsPaths.push( + path6.join(programFiles, "nodejs", "node_global", "node_modules", "@anthropic-ai", "claude-code", "cli.js"), + path6.join(programFilesX86, "nodejs", "node_global", "node_modules", "@anthropic-ai", "claude-code", "cli.js") + ); + cliJsPaths.push( + path6.join("D:", "Program Files", "nodejs", "node_global", "node_modules", "@anthropic-ai", "claude-code", "cli.js") + ); + } else { + cliJsPaths.push( + path6.join(homeDir, ".npm-global", "lib", "node_modules", "@anthropic-ai", "claude-code", "cli.js"), + "/usr/local/lib/node_modules/@anthropic-ai/claude-code/cli.js", + "/usr/lib/node_modules/@anthropic-ai/claude-code/cli.js" + ); + if (process.env.npm_config_prefix) { + cliJsPaths.push( + path6.join(process.env.npm_config_prefix, "lib", "node_modules", "@anthropic-ai", "claude-code", "cli.js") + ); + } + } + return cliJsPaths; +} +function findClaudeCLIPath(pathValue) { + const homeDir = os6.homedir(); + const isWindows2 = process.platform === "win32"; + const customEntries = dedupePaths(parsePathEntries(pathValue)); + if (customEntries.length > 0) { + const customResolution = resolveClaudeFromPathEntries(customEntries, isWindows2); + if (customResolution) { + return customResolution; + } + } + if (isWindows2) { + const exePaths = [ + path6.join(homeDir, ".claude", "local", "claude.exe"), + path6.join(homeDir, "AppData", "Local", "Claude", "claude.exe"), + path6.join(process.env.ProgramFiles || "C:\\Program Files", "Claude", "claude.exe"), + path6.join(process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)", "Claude", "claude.exe"), + path6.join(homeDir, ".local", "bin", "claude.exe") + ]; + for (const p of exePaths) { + if (isExistingFile(p)) { + return p; + } + } + const cliJsPaths = getNpmCliJsPaths(); + for (const p of cliJsPaths) { + if (isExistingFile(p)) { + return p; + } + } + } + const commonPaths = [ + path6.join(homeDir, ".claude", "local", "claude"), + path6.join(homeDir, ".local", "bin", "claude"), + path6.join(homeDir, ".volta", "bin", "claude"), + path6.join(homeDir, ".asdf", "shims", "claude"), + path6.join(homeDir, ".asdf", "bin", "claude"), + "/usr/local/bin/claude", + "/opt/homebrew/bin/claude", + path6.join(homeDir, "bin", "claude"), + path6.join(homeDir, ".npm-global", "bin", "claude") + ]; + const npmPrefix = getNpmGlobalPrefix(); + if (npmPrefix) { + commonPaths.push(path6.join(npmPrefix, "bin", "claude")); + } + const nvmBin = resolveNvmDefaultBin(homeDir); + if (nvmBin) { + commonPaths.push(path6.join(nvmBin, "claude")); + } + for (const p of commonPaths) { + if (isExistingFile(p)) { + return p; + } + } + if (!isWindows2) { + const cliJsPaths = getNpmCliJsPaths(); + for (const p of cliJsPaths) { + if (isExistingFile(p)) { + return p; + } + } + } + const envEntries = dedupePaths(parsePathEntries(getEnvValue2("PATH"))); + if (envEntries.length > 0) { + const envResolution = resolveClaudeFromPathEntries(envEntries, isWindows2); + if (envResolution) { + return envResolution; + } + } + return null; +} + +// src/providers/claude/settings.ts +var DEFAULT_CLAUDE_PROVIDER_SETTINGS = Object.freeze({ + safeMode: "acceptEdits", + cliPath: "", + cliPathsByHost: {}, + loadUserSettings: true, + enableChrome: false, + enableBangBash: false, + enableOpus1M: false, + enableSonnet1M: false, + lastModel: "haiku", + environmentVariables: "", + environmentHash: "" +}); +function normalizeHostnameCliPaths(value) { + if (!value || typeof value !== "object" || Array.isArray(value)) { + return {}; + } + const result = {}; + for (const [key, entry] of Object.entries(value)) { + if (typeof entry === "string" && entry.trim()) { + result[key] = entry.trim(); + } + } + return result; +} +function getClaudeProviderSettings(settings11) { + var _a3, _b2, _c, _d, _e, _f, _g, _h, _i, _j2, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u; + const config2 = getProviderConfig(settings11, "claude"); + return { + safeMode: (_b2 = (_a3 = config2.safeMode) != null ? _a3 : settings11.claudeSafeMode) != null ? _b2 : DEFAULT_CLAUDE_PROVIDER_SETTINGS.safeMode, + cliPath: (_d = (_c = config2.cliPath) != null ? _c : settings11.claudeCliPath) != null ? _d : DEFAULT_CLAUDE_PROVIDER_SETTINGS.cliPath, + cliPathsByHost: normalizeHostnameCliPaths((_e = config2.cliPathsByHost) != null ? _e : settings11.claudeCliPathsByHost), + loadUserSettings: (_g = (_f = config2.loadUserSettings) != null ? _f : settings11.loadUserClaudeSettings) != null ? _g : DEFAULT_CLAUDE_PROVIDER_SETTINGS.loadUserSettings, + enableChrome: (_i = (_h = config2.enableChrome) != null ? _h : settings11.enableChrome) != null ? _i : DEFAULT_CLAUDE_PROVIDER_SETTINGS.enableChrome, + enableBangBash: (_k = (_j2 = config2.enableBangBash) != null ? _j2 : settings11.enableBangBash) != null ? _k : DEFAULT_CLAUDE_PROVIDER_SETTINGS.enableBangBash, + enableOpus1M: (_m = (_l = config2.enableOpus1M) != null ? _l : settings11.enableOpus1M) != null ? _m : DEFAULT_CLAUDE_PROVIDER_SETTINGS.enableOpus1M, + enableSonnet1M: (_o = (_n = config2.enableSonnet1M) != null ? _n : settings11.enableSonnet1M) != null ? _o : DEFAULT_CLAUDE_PROVIDER_SETTINGS.enableSonnet1M, + lastModel: (_q = (_p = config2.lastModel) != null ? _p : settings11.lastClaudeModel) != null ? _q : DEFAULT_CLAUDE_PROVIDER_SETTINGS.lastModel, + environmentVariables: (_s = (_r = config2.environmentVariables) != null ? _r : getProviderEnvironmentVariables(settings11, "claude")) != null ? _s : DEFAULT_CLAUDE_PROVIDER_SETTINGS.environmentVariables, + environmentHash: (_u = (_t = config2.environmentHash) != null ? _t : settings11.lastEnvHash) != null ? _u : DEFAULT_CLAUDE_PROVIDER_SETTINGS.environmentHash + }; +} +function updateClaudeProviderSettings(settings11, updates) { + const next = { + ...getClaudeProviderSettings(settings11), + ...updates + }; + setProviderConfig(settings11, "claude", next); + return next; +} + +// src/providers/claude/runtime/ClaudeCliResolver.ts +var ClaudeCliResolver = class { + constructor() { + this.resolvedPath = null; + this.lastHostnamePath = ""; + this.lastLegacyPath = ""; + this.lastEnvText = ""; + this.cachedHostname = getHostnameKey(); + } + /** + * Resolves CLI path with priority: hostname-specific -> legacy -> auto-detect. + * @param settings Full app settings bag + */ + resolveFromSettings(settings11) { + var _a3; + const hostnameKey = this.cachedHostname; + const claudeSettings = getClaudeProviderSettings(settings11); + const hostnamePath = ((_a3 = claudeSettings.cliPathsByHost[hostnameKey]) != null ? _a3 : "").trim(); + const normalizedLegacy = claudeSettings.cliPath.trim(); + const normalizedEnv = getRuntimeEnvironmentText(settings11, "claude"); + if (this.resolvedPath && hostnamePath === this.lastHostnamePath && normalizedLegacy === this.lastLegacyPath && normalizedEnv === this.lastEnvText) { + return this.resolvedPath; + } + this.lastHostnamePath = hostnamePath; + this.lastLegacyPath = normalizedLegacy; + this.lastEnvText = normalizedEnv; + this.resolvedPath = resolveClaudeCliPath(hostnamePath, normalizedLegacy, normalizedEnv); + return this.resolvedPath; + } + resolve(hostnamePaths, legacyPath, envText) { + return this.resolveFromSettings({ + sharedEnvironmentVariables: envText, + providerConfigs: { + claude: { + cliPath: legacyPath != null ? legacyPath : "", + cliPathsByHost: hostnamePaths != null ? hostnamePaths : {} + } + } + }); + } + reset() { + this.resolvedPath = null; + this.lastHostnamePath = ""; + this.lastLegacyPath = ""; + this.lastEnvText = ""; + } +}; +function resolveConfiguredPath(rawPath) { + const trimmed = (rawPath != null ? rawPath : "").trim(); + if (!trimmed) return null; + try { + const expanded = expandHomePath(trimmed); + if (fs7.existsSync(expanded) && fs7.statSync(expanded).isFile()) { + return expanded; + } + } catch (e3) { + } + return null; +} +function resolveClaudeCliPath(hostnamePath, legacyPath, envText) { + var _a3, _b2; + return (_b2 = (_a3 = resolveConfiguredPath(hostnamePath)) != null ? _a3 : resolveConfiguredPath(legacyPath)) != null ? _b2 : findClaudeCLIPath(parseEnvironmentVariables(envText || "").PATH); +} + +// src/providers/claude/storage/StorageService.ts +var import_obsidian3 = require("obsidian"); + +// src/core/bootstrap/StoragePaths.ts +var CLAUDIAN_STORAGE_PATH = ".claudian"; +var LEGACY_CLAUDIAN_SETTINGS_PATH = ".claude/claudian-settings.json"; +var CLAUDIAN_SETTINGS_PATH = `${CLAUDIAN_STORAGE_PATH}/claudian-settings.json`; +var LEGACY_SESSIONS_PATH = ".claude/sessions"; +var SESSIONS_PATH = `${CLAUDIAN_STORAGE_PATH}/sessions`; + +// src/core/providers/commands/hiddenCommands.ts +function normalizeHiddenCommandName(value) { + return value.trim().replace(/^[/$]+/, ""); +} +function normalizeHiddenCommandList(value) { + if (!Array.isArray(value)) { + return []; + } + const seen = /* @__PURE__ */ new Set(); + const normalized = []; + for (const item of value) { + if (typeof item !== "string") { + continue; + } + const commandName = normalizeHiddenCommandName(item); + if (!commandName) { + continue; + } + const key = commandName.toLowerCase(); + if (seen.has(key)) { + continue; + } + seen.add(key); + normalized.push(commandName); + } + return normalized; +} +function getDefaultHiddenProviderCommands() { + return {}; +} +function normalizeHiddenProviderCommands(value) { + if (!value || typeof value !== "object") { + return getDefaultHiddenProviderCommands(); + } + const candidate = value; + const normalized = {}; + for (const [providerId, commands] of Object.entries(candidate)) { + const next = normalizeHiddenCommandList(commands); + if (next.length > 0) { + normalized[providerId] = next; + } + } + return normalized; +} +function getHiddenProviderCommands(settings11, providerId) { + var _a3, _b2; + return (_b2 = (_a3 = settings11.hiddenProviderCommands) == null ? void 0 : _a3[providerId]) != null ? _b2 : []; +} +function getHiddenProviderCommandSet(settings11, providerId) { + return new Set(getHiddenProviderCommands(settings11, providerId).map((command) => command.toLowerCase())); +} + +// src/providers/codex/settings.ts +init_env(); +function normalizeCodexInstallationMethod(value) { + return value === "wsl" ? "wsl" : "native-windows"; +} +function normalizeOptionalString(value) { + return typeof value === "string" ? value.trim() : ""; +} +var DEFAULT_CODEX_PROVIDER_SETTINGS = Object.freeze({ + enabled: false, + safeMode: "workspace-write", + cliPath: "", + cliPathsByHost: {}, + reasoningSummary: "detailed", + environmentVariables: "", + environmentHash: "", + installationMethod: "native-windows", + installationMethodsByHost: {}, + wslDistroOverride: "", + wslDistroOverridesByHost: {} +}); +function normalizeHostnameCliPaths2(value) { + if (!value || typeof value !== "object" || Array.isArray(value)) { + return {}; + } + const result = {}; + for (const [key, entry] of Object.entries(value)) { + if (typeof entry === "string" && entry.trim()) { + result[key] = entry.trim(); + } + } + return result; +} +function normalizeInstallationMethodsByHost(value) { + if (!value || typeof value !== "object" || Array.isArray(value)) { + return {}; + } + const result = {}; + for (const [key, entry] of Object.entries(value)) { + if (typeof key === "string" && key.trim()) { + result[key] = normalizeCodexInstallationMethod(entry); + } + } + return result; +} +function getCodexProviderSettings(settings11) { + var _a3, _b2, _c, _d, _e, _f, _g, _h, _i, _j2, _k, _l, _m, _n, _o; + const config2 = getProviderConfig(settings11, "codex"); + const hostnameKey = getHostnameKey(); + const installationMethodsByHost = normalizeInstallationMethodsByHost(config2.installationMethodsByHost); + const wslDistroOverridesByHost = normalizeHostnameCliPaths2(config2.wslDistroOverridesByHost); + const hasHostScopedInstallationMethods = Object.keys(installationMethodsByHost).length > 0; + const hasHostScopedWslDistroOverrides = Object.keys(wslDistroOverridesByHost).length > 0; + const legacyInstallationMethod = normalizeCodexInstallationMethod(config2.installationMethod); + const legacyWslDistroOverride = normalizeOptionalString(config2.wslDistroOverride); + return { + enabled: (_b2 = (_a3 = config2.enabled) != null ? _a3 : settings11.codexEnabled) != null ? _b2 : DEFAULT_CODEX_PROVIDER_SETTINGS.enabled, + safeMode: (_d = (_c = config2.safeMode) != null ? _c : settings11.codexSafeMode) != null ? _d : DEFAULT_CODEX_PROVIDER_SETTINGS.safeMode, + cliPath: (_f = (_e = config2.cliPath) != null ? _e : settings11.codexCliPath) != null ? _f : DEFAULT_CODEX_PROVIDER_SETTINGS.cliPath, + cliPathsByHost: normalizeHostnameCliPaths2((_g = config2.cliPathsByHost) != null ? _g : settings11.codexCliPathsByHost), + reasoningSummary: (_i = (_h = config2.reasoningSummary) != null ? _h : settings11.codexReasoningSummary) != null ? _i : DEFAULT_CODEX_PROVIDER_SETTINGS.reasoningSummary, + environmentVariables: (_k = (_j2 = config2.environmentVariables) != null ? _j2 : getProviderEnvironmentVariables(settings11, "codex")) != null ? _k : DEFAULT_CODEX_PROVIDER_SETTINGS.environmentVariables, + environmentHash: (_m = (_l = config2.environmentHash) != null ? _l : settings11.lastCodexEnvHash) != null ? _m : DEFAULT_CODEX_PROVIDER_SETTINGS.environmentHash, + installationMethod: (_n = installationMethodsByHost[hostnameKey]) != null ? _n : hasHostScopedInstallationMethods ? DEFAULT_CODEX_PROVIDER_SETTINGS.installationMethod : legacyInstallationMethod, + installationMethodsByHost, + wslDistroOverride: (_o = wslDistroOverridesByHost[hostnameKey]) != null ? _o : hasHostScopedWslDistroOverrides ? DEFAULT_CODEX_PROVIDER_SETTINGS.wslDistroOverride : legacyWslDistroOverride, + wslDistroOverridesByHost + }; +} +function updateCodexProviderSettings(settings11, updates) { + var _a3, _b2; + const current = getCodexProviderSettings(settings11); + const hostnameKey = getHostnameKey(); + const installationMethodsByHost = "installationMethodsByHost" in updates ? normalizeInstallationMethodsByHost(updates.installationMethodsByHost) : { ...current.installationMethodsByHost }; + const wslDistroOverridesByHost = "wslDistroOverridesByHost" in updates ? normalizeHostnameCliPaths2(updates.wslDistroOverridesByHost) : { ...current.wslDistroOverridesByHost }; + if (Object.keys(installationMethodsByHost).length === 0 && current.installationMethod !== DEFAULT_CODEX_PROVIDER_SETTINGS.installationMethod) { + installationMethodsByHost[hostnameKey] = current.installationMethod; + } + if (Object.keys(wslDistroOverridesByHost).length === 0 && current.wslDistroOverride) { + wslDistroOverridesByHost[hostnameKey] = current.wslDistroOverride; + } + if ("installationMethod" in updates) { + installationMethodsByHost[hostnameKey] = normalizeCodexInstallationMethod(updates.installationMethod); + } + if ("wslDistroOverride" in updates) { + const normalizedDistroOverride = normalizeOptionalString(updates.wslDistroOverride); + if (normalizedDistroOverride) { + wslDistroOverridesByHost[hostnameKey] = normalizedDistroOverride; + } else { + delete wslDistroOverridesByHost[hostnameKey]; + } + } + const next = { + ...current, + ...updates, + installationMethod: (_a3 = installationMethodsByHost[hostnameKey]) != null ? _a3 : DEFAULT_CODEX_PROVIDER_SETTINGS.installationMethod, + installationMethodsByHost, + wslDistroOverride: (_b2 = wslDistroOverridesByHost[hostnameKey]) != null ? _b2 : DEFAULT_CODEX_PROVIDER_SETTINGS.wslDistroOverride, + wslDistroOverridesByHost + }; + setProviderConfig(settings11, "codex", { + enabled: next.enabled, + safeMode: next.safeMode, + cliPath: next.cliPath, + cliPathsByHost: next.cliPathsByHost, + reasoningSummary: next.reasoningSummary, + environmentVariables: next.environmentVariables, + environmentHash: next.environmentHash, + installationMethodsByHost, + wslDistroOverridesByHost + }); + return next; +} + +// src/app/settings/defaultSettings.ts +var DEFAULT_CLAUDIAN_SETTINGS = { + userName: "", + permissionMode: "yolo", + model: "haiku", + thinkingBudget: "off", + effortLevel: "high", + serviceTier: "default", + enableAutoTitleGeneration: true, + titleGenerationModel: "", + excludedTags: [], + mediaFolder: "", + systemPrompt: "", + persistentExternalContextPaths: [], + sharedEnvironmentVariables: "", + envSnippets: [], + customContextLimits: {}, + keyboardNavigation: { + scrollUpKey: "w", + scrollDownKey: "s", + focusInputKey: "i" + }, + locale: "en", + providerConfigs: { + claude: { ...DEFAULT_CLAUDE_PROVIDER_SETTINGS }, + codex: { ...DEFAULT_CODEX_PROVIDER_SETTINGS } + }, + settingsProvider: "claude", + savedProviderModel: {}, + savedProviderEffort: {}, + savedProviderServiceTier: {}, + savedProviderThinkingBudget: {}, + lastCustomModel: "", + maxTabs: 3, + tabBarPosition: "input", + enableAutoScroll: true, + openInMainTab: false, + hiddenProviderCommands: getDefaultHiddenProviderCommands() +}; + +// src/app/settings/ClaudianSettingsStorage.ts +var LEGACY_TOP_LEVEL_PROVIDER_FIELDS = [ + "claudeSafeMode", + "codexSafeMode", + "claudeCliPath", + "claudeCliPathsByHost", + "codexCliPath", + "codexCliPathsByHost", + "codexReasoningSummary", + "loadUserClaudeSettings", + "codexEnabled", + "lastClaudeModel", + "enableChrome", + "enableBangBash", + "enableOpus1M", + "enableSonnet1M", + "environmentVariables", + "lastEnvHash", + "lastCodexEnvHash" +]; +function stripLegacyFields(settings11) { + const { + activeConversationId: _activeConversationId, + show1MModel: _show1MModel, + hiddenSlashCommands: _hiddenSlashCommands, + slashCommands: _slashCommands, + allowExternalAccess: _allowExternalAccess, + allowedExportPaths: _allowedExportPaths, + enableBlocklist: _enableBlocklist, + blockedCommands: _blockedCommands, + claudeSafeMode: _claudeSafeMode, + codexSafeMode: _codexSafeMode, + claudeCliPath: _claudeCliPath, + claudeCliPathsByHost: _claudeCliPathsByHost, + codexCliPath: _codexCliPath, + codexCliPathsByHost: _codexCliPathsByHost, + codexReasoningSummary: _codexReasoningSummary, + loadUserClaudeSettings: _loadUserClaudeSettings, + codexEnabled: _codexEnabled, + lastClaudeModel: _lastClaudeModel, + enableChrome: _enableChrome, + enableBangBash: _enableBangBash, + enableOpus1M: _enableOpus1M, + enableSonnet1M: _enableSonnet1M, + environmentVariables: _environmentVariables, + lastEnvHash: _lastEnvHash, + lastCodexEnvHash: _lastCodexEnvHash, + ...cleaned + } = settings11; + return cleaned; +} +function normalizeProviderConfigs(value) { + if (!value || typeof value !== "object" || Array.isArray(value)) { + return {}; + } + const result = {}; + for (const [providerId, config2] of Object.entries(value)) { + if (config2 && typeof config2 === "object" && !Array.isArray(config2)) { + result[providerId] = { ...config2 }; + } + } + return result; +} +function isEnvironmentScope(value) { + return value === "shared" || typeof value === "string" && value.startsWith("provider:"); +} +function normalizeContextLimits(value) { + if (!value || typeof value !== "object" || Array.isArray(value)) { + return void 0; + } + const result = {}; + for (const [key, entry] of Object.entries(value)) { + if (typeof entry === "number" && Number.isFinite(entry) && entry > 0) { + result[key] = entry; + } + } + return Object.keys(result).length > 0 ? result : void 0; +} +function normalizeEnvSnippets(value) { + if (!Array.isArray(value)) { + return []; + } + const snippets = []; + for (const item of value) { + if (!item || typeof item !== "object" || Array.isArray(item)) { + continue; + } + const candidate = item; + if (typeof candidate.id !== "string" || typeof candidate.name !== "string" || typeof candidate.description !== "string" || typeof candidate.envVars !== "string") { + continue; + } + snippets.push({ + id: candidate.id, + name: candidate.name, + description: candidate.description, + envVars: candidate.envVars, + scope: resolveEnvironmentSnippetScope( + candidate.envVars, + isEnvironmentScope(candidate.scope) ? candidate.scope : inferEnvironmentSnippetScope(candidate.envVars) + ), + contextLimits: normalizeContextLimits(candidate.contextLimits) + }); + } + return snippets; +} +function hasLegacyTopLevelProviderFields(stored) { + return LEGACY_TOP_LEVEL_PROVIDER_FIELDS.some((key) => key in stored); +} +function mergeLegacyClaudeHiddenCommands(hiddenProviderCommands, legacyHiddenSlashCommands) { + const legacyCommands = normalizeHiddenCommandList(legacyHiddenSlashCommands); + if (legacyCommands.length === 0 || hiddenProviderCommands.claude) { + return hiddenProviderCommands; + } + return { + ...hiddenProviderCommands, + claude: legacyCommands + }; +} +var ClaudianSettingsStorage = class { + constructor(adapter) { + this.adapter = adapter; + } + async load() { + var _a3; + const settingsPath = await this.getLoadPath(); + if (!settingsPath) { + return this.getDefaults(); + } + const content = await this.adapter.read(settingsPath); + const stored = JSON.parse(content); + const hiddenProviderCommands = mergeLegacyClaudeHiddenCommands( + normalizeHiddenProviderCommands(stored.hiddenProviderCommands), + stored.hiddenSlashCommands + ); + const envSnippets = normalizeEnvSnippets(stored.envSnippets); + const providerConfigs = normalizeProviderConfigs(stored.providerConfigs); + const legacyProviderSettings = { + ...stored, + hiddenProviderCommands, + providerConfigs + }; + const storedWithoutLegacy = stripLegacyFields({ + ...legacyProviderSettings + }); + const legacyNormalized = { + ...storedWithoutLegacy, + sharedEnvironmentVariables: getSharedEnvironmentVariables(legacyProviderSettings), + envSnippets, + hiddenProviderCommands, + providerConfigs + }; + const merged = { + ...this.getDefaults(), + ...legacyNormalized + }; + updateClaudeProviderSettings( + merged, + getClaudeProviderSettings(legacyProviderSettings) + ); + updateCodexProviderSettings( + merged, + getCodexProviderSettings(legacyProviderSettings) + ); + if (settingsPath !== CLAUDIAN_SETTINGS_PATH || (hasLegacyTopLevelProviderFields(stored) || "show1MModel" in stored || "slashCommands" in stored || "hiddenSlashCommands" in stored || "activeConversationId" in stored || "allowExternalAccess" in stored || "allowedExportPaths" in stored || "enableBlocklist" in stored || "blockedCommands" in stored || JSON.stringify(envSnippets) !== JSON.stringify((_a3 = stored.envSnippets) != null ? _a3 : []))) { + await this.save(merged); + } + return merged; + } + async save(settings11) { + const content = JSON.stringify( + stripLegacyFields(settings11), + null, + 2 + ); + await this.adapter.write(CLAUDIAN_SETTINGS_PATH, content); + await this.deleteLegacyFileIfPresent(); + } + async exists() { + if (await this.adapter.exists(CLAUDIAN_SETTINGS_PATH)) { + return true; + } + return this.adapter.exists(LEGACY_CLAUDIAN_SETTINGS_PATH); + } + async update(updates) { + const current = await this.load(); + await this.save({ ...current, ...updates }); + } + async setLastModel(model, isCustom) { + if (isCustom) { + await this.update({ lastCustomModel: model }); + return; + } + const current = await this.load(); + updateClaudeProviderSettings( + current, + { lastModel: model } + ); + await this.save(current); + } + async setLastEnvHash(hash2) { + const current = await this.load(); + updateClaudeProviderSettings( + current, + { environmentHash: hash2 } + ); + await this.save(current); + } + getDefaults() { + return DEFAULT_CLAUDIAN_SETTINGS; + } + async getLoadPath() { + if (await this.adapter.exists(CLAUDIAN_SETTINGS_PATH)) { + return CLAUDIAN_SETTINGS_PATH; + } + if (await this.adapter.exists(LEGACY_CLAUDIAN_SETTINGS_PATH)) { + return LEGACY_CLAUDIAN_SETTINGS_PATH; + } + return null; + } + async deleteLegacyFileIfPresent() { + if (await this.adapter.exists(LEGACY_CLAUDIAN_SETTINGS_PATH)) { + await this.adapter.delete(LEGACY_CLAUDIAN_SETTINGS_PATH); + } + } +}; + +// src/core/bootstrap/SessionStorage.ts +var SessionStorage = class { + constructor(adapter) { + this.adapter = adapter; + } + getMetadataPath(id) { + return `${SESSIONS_PATH}/${id}.meta.json`; + } + getLegacyMetadataPath(id) { + return `${LEGACY_SESSIONS_PATH}/${id}.meta.json`; + } + async saveMetadata(metadata) { + const filePath = this.getMetadataPath(metadata.id); + const content = JSON.stringify(metadata, null, 2); + await this.adapter.write(filePath, content); + await this.deleteLegacyMetadataIfPresent(metadata.id); + } + async loadMetadata(id) { + const filePath = await this.getLoadPath(id); + try { + if (!filePath) { + return null; + } + const content = await this.adapter.read(filePath); + const metadata = JSON.parse(content); + if (filePath !== this.getMetadataPath(id)) { + await this.saveMetadata(metadata); + } + return metadata; + } catch (e3) { + return null; + } + } + async deleteMetadata(id) { + await this.adapter.delete(this.getMetadataPath(id)); + await this.deleteLegacyMetadataIfPresent(id); + } + async listMetadata() { + const metas = []; + const files = await this.listUniqueMetadataFiles(); + for (const filePath of files) { + try { + const content = await this.adapter.read(filePath); + const raw = JSON.parse(content); + metas.push(raw); + if (filePath.startsWith(`${LEGACY_SESSIONS_PATH}/`)) { + await this.saveMetadata(raw); + } + } catch (e3) { + } + } + return metas; + } + async listAllConversations() { + const nativeMetas = await this.listMetadata(); + const metas = nativeMetas.map((meta3) => { + var _a3; + return { + id: meta3.id, + providerId: (_a3 = meta3.providerId) != null ? _a3 : DEFAULT_CHAT_PROVIDER_ID, + title: meta3.title, + createdAt: meta3.createdAt, + updatedAt: meta3.updatedAt, + lastResponseAt: meta3.lastResponseAt, + messageCount: 0, + preview: "SDK session", + titleGenerationStatus: meta3.titleGenerationStatus + }; + }); + return metas.sort( + (a3, b) => { + var _a3, _b2; + return ((_a3 = b.lastResponseAt) != null ? _a3 : b.createdAt) - ((_b2 = a3.lastResponseAt) != null ? _b2 : a3.createdAt); + } + ); + } + toSessionMetadata(conversation) { + var _a3, _b2, _c; + const providerState = (_c = (_b2 = (_a3 = ProviderRegistry.getConversationHistoryService(conversation.providerId)).buildPersistedProviderState) == null ? void 0 : _b2.call(_a3, conversation)) != null ? _c : conversation.providerState; + return { + id: conversation.id, + providerId: conversation.providerId, + title: conversation.title, + titleGenerationStatus: conversation.titleGenerationStatus, + createdAt: conversation.createdAt, + updatedAt: conversation.updatedAt, + lastResponseAt: conversation.lastResponseAt, + sessionId: conversation.sessionId, + providerState: providerState && Object.keys(providerState).length > 0 ? providerState : void 0, + currentNote: conversation.currentNote, + externalContextPaths: conversation.externalContextPaths, + enabledMcpServers: conversation.enabledMcpServers, + usage: conversation.usage, + resumeAtMessageId: conversation.resumeAtMessageId + }; + } + async getLoadPath(id) { + const filePath = this.getMetadataPath(id); + if (await this.adapter.exists(filePath)) { + return filePath; + } + const legacyFilePath = this.getLegacyMetadataPath(id); + if (await this.adapter.exists(legacyFilePath)) { + return legacyFilePath; + } + return null; + } + async deleteLegacyMetadataIfPresent(id) { + const legacyFilePath = this.getLegacyMetadataPath(id); + if (await this.adapter.exists(legacyFilePath)) { + await this.adapter.delete(legacyFilePath); + } + } + async listUniqueMetadataFiles() { + const preferredFiles = await this.listMetadataFiles(SESSIONS_PATH); + const fallbackFiles = await this.listMetadataFiles(LEGACY_SESSIONS_PATH); + const filesByName = /* @__PURE__ */ new Map(); + for (const filePath of preferredFiles) { + filesByName.set(this.getFileName(filePath), filePath); + } + for (const filePath of fallbackFiles) { + const fileName = this.getFileName(filePath); + if (!filesByName.has(fileName)) { + filesByName.set(fileName, filePath); + } + } + return Array.from(filesByName.values()); + } + async listMetadataFiles(folderPath) { + try { + const files = await this.adapter.listFiles(folderPath); + return files.filter((filePath) => filePath.endsWith(".meta.json")); + } catch (e3) { + return []; + } + } + getFileName(filePath) { + var _a3; + const parts = filePath.split("/"); + return (_a3 = parts[parts.length - 1]) != null ? _a3 : filePath; + } +}; + +// src/core/storage/VaultFileAdapter.ts +var VaultFileAdapter = class { + constructor(app) { + this.app = app; + this.writeQueue = Promise.resolve(); + } + async exists(path19) { + return this.app.vault.adapter.exists(path19); + } + async read(path19) { + return this.app.vault.adapter.read(path19); + } + async write(path19, content) { + await this.ensureParentFolder(path19); + await this.app.vault.adapter.write(path19, content); + } + async append(path19, content) { + await this.ensureParentFolder(path19); + this.writeQueue = this.writeQueue.then(async () => { + if (await this.exists(path19)) { + const existing = await this.read(path19); + await this.app.vault.adapter.write(path19, existing + content); + } else { + await this.app.vault.adapter.write(path19, content); + } + }).catch(() => { + }); + await this.writeQueue; + } + async delete(path19) { + if (await this.exists(path19)) { + await this.app.vault.adapter.remove(path19); + } + } + /** Fails silently if non-empty or missing. */ + async deleteFolder(path19) { + try { + if (await this.exists(path19)) { + await this.app.vault.adapter.rmdir(path19, false); + } + } catch (e3) { + } + } + async listFiles(folder) { + if (!await this.exists(folder)) { + return []; + } + const listing = await this.app.vault.adapter.list(folder); + return listing.files; + } + /** List subfolders in a folder. Returns relative paths from the folder. */ + async listFolders(folder) { + if (!await this.exists(folder)) { + return []; + } + const listing = await this.app.vault.adapter.list(folder); + return listing.folders; + } + /** Recursively list all files in a folder and subfolders. */ + async listFilesRecursive(folder) { + const allFiles = []; + const processFolder = async (currentFolder) => { + if (!await this.exists(currentFolder)) return; + const listing = await this.app.vault.adapter.list(currentFolder); + allFiles.push(...listing.files); + for (const subfolder of listing.folders) { + await processFolder(subfolder); + } + }; + await processFolder(folder); + return allFiles; + } + async ensureParentFolder(filePath) { + const folder = filePath.substring(0, filePath.lastIndexOf("/")); + if (folder && !await this.exists(folder)) { + await this.ensureFolder(folder); + } + } + /** Ensure a folder exists, creating it and parent folders if needed. */ + async ensureFolder(path19) { + if (await this.exists(path19)) return; + const parts = path19.split("/").filter(Boolean); + let current = ""; + for (const part of parts) { + current = current ? `${current}/${part}` : part; + if (!await this.exists(current)) { + await this.app.vault.adapter.mkdir(current); + } + } + } + /** Rename/move a file. */ + async rename(oldPath, newPath) { + await this.app.vault.adapter.rename(oldPath, newPath); + } + async stat(path19) { + try { + const stat = await this.app.vault.adapter.stat(path19); + if (!stat) return null; + return { mtime: stat.mtime, size: stat.size }; + } catch (e3) { + return null; + } + } +}; + +// src/providers/claude/types/settings.ts +function createPermissionRule(rule) { + return rule; +} +var DEFAULT_CC_SETTINGS = { + $schema: "https://json.schemastore.org/claude-code-settings.json", + permissions: { + allow: [], + deny: [], + ask: [] + } +}; +var DEFAULT_CC_PERMISSIONS = { + allow: [], + deny: [], + ask: [] +}; + +// src/utils/agent.ts +function validateAgentName(name) { + return validateSlugName(name, "Agent"); +} +function pushYamlList(lines, key, items) { + if (!items || items.length === 0) return; + lines.push(`${key}:`); + for (const item of items) { + lines.push(` - ${yamlString(item)}`); + } +} +function serializeAgent(agent) { + const lines = ["---"]; + lines.push(`name: ${agent.name}`); + lines.push(`description: ${yamlString(agent.description)}`); + pushYamlList(lines, "tools", agent.tools); + pushYamlList(lines, "disallowedTools", agent.disallowedTools); + if (agent.model && agent.model !== "inherit") { + lines.push(`model: ${agent.model}`); + } + if (agent.permissionMode) { + lines.push(`permissionMode: ${agent.permissionMode}`); + } + pushYamlList(lines, "skills", agent.skills); + if (agent.hooks !== void 0) { + lines.push(`hooks: ${JSON.stringify(agent.hooks)}`); + } + if (agent.extraFrontmatter) { + for (const [key, value] of Object.entries(agent.extraFrontmatter)) { + lines.push(`${key}: ${JSON.stringify(value)}`); + } + } + lines.push("---"); + lines.push(agent.prompt); + return lines.join("\n"); +} + +// src/providers/claude/storage/AgentVaultStorage.ts +var AGENTS_PATH = ".claude/agents"; +var AgentVaultStorage = class { + constructor(adapter) { + this.adapter = adapter; + } + async loadAll() { + const agents = []; + try { + const files = await this.adapter.listFiles(AGENTS_PATH); + for (const filePath of files) { + if (!filePath.endsWith(".md")) continue; + try { + const content = await this.adapter.read(filePath); + const parsed = parseAgentFile(content); + if (!parsed) continue; + const { frontmatter, body } = parsed; + agents.push(buildAgentFromFrontmatter(frontmatter, body, { + id: frontmatter.name, + source: "vault", + filePath + })); + } catch (e3) { + } + } + } catch (e3) { + } + return agents; + } + async load(agent) { + const filePath = this.resolvePath(agent); + try { + const content = await this.adapter.read(filePath); + const parsed = parseAgentFile(content); + if (!parsed) return null; + const { frontmatter, body } = parsed; + return buildAgentFromFrontmatter(frontmatter, body, { + id: frontmatter.name, + source: agent.source, + filePath + }); + } catch (error48) { + if (this.isFileNotFoundError(error48)) { + return null; + } + throw error48; + } + } + async save(agent) { + await this.adapter.write(this.resolvePath(agent), serializeAgent(agent)); + } + async delete(agent) { + await this.adapter.delete(this.resolvePath(agent)); + } + resolvePath(agent) { + if (!agent.filePath) { + return `${AGENTS_PATH}/${agent.name}.md`; + } + const normalized = agent.filePath.replace(/\\/g, "/"); + const idx = normalized.lastIndexOf(`${AGENTS_PATH}/`); + if (idx !== -1) { + return normalized.slice(idx); + } + return `${AGENTS_PATH}/${agent.name}.md`; + } + isFileNotFoundError(error48) { + if (!error48) return false; + if (typeof error48 === "string") { + return /enoent|not found|no such file/i.test(error48); + } + if (typeof error48 === "object") { + const maybeCode = error48.code; + if (typeof maybeCode === "string" && /enoent|not.?found/i.test(maybeCode)) { + return true; + } + const maybeMessage = error48.message; + if (typeof maybeMessage === "string" && /enoent|not found|no such file/i.test(maybeMessage)) { + return true; + } + } + return false; + } +}; + +// src/providers/claude/storage/CCSettingsStorage.ts +var CC_SETTINGS_PATH = ".claude/settings.json"; +var CC_SETTINGS_SCHEMA = "https://json.schemastore.org/claude-code-settings.json"; +function normalizeRuleList(value) { + if (!Array.isArray(value)) return []; + return value.filter((r3) => typeof r3 === "string"); +} +function normalizePermissions(permissions) { + if (!permissions || typeof permissions !== "object") { + return { ...DEFAULT_CC_PERMISSIONS }; + } + const p = permissions; + return { + allow: normalizeRuleList(p.allow), + deny: normalizeRuleList(p.deny), + ask: normalizeRuleList(p.ask), + defaultMode: typeof p.defaultMode === "string" ? p.defaultMode : void 0, + additionalDirectories: Array.isArray(p.additionalDirectories) ? p.additionalDirectories.filter((d) => typeof d === "string") : void 0 + }; +} +var CCSettingsStorage = class { + constructor(adapter) { + this.adapter = adapter; + } + async load() { + if (!await this.adapter.exists(CC_SETTINGS_PATH)) { + return { ...DEFAULT_CC_SETTINGS }; + } + const content = await this.adapter.read(CC_SETTINGS_PATH); + const stored = JSON.parse(content); + return { + $schema: CC_SETTINGS_SCHEMA, + ...stored, + permissions: normalizePermissions(stored.permissions) + }; + } + async save(settings11) { + var _a3; + let existing = {}; + if (await this.adapter.exists(CC_SETTINGS_PATH)) { + try { + const content2 = await this.adapter.read(CC_SETTINGS_PATH); + existing = JSON.parse(content2); + } catch (e3) { + } + } + const merged = { + ...existing, + $schema: CC_SETTINGS_SCHEMA, + permissions: (_a3 = settings11.permissions) != null ? _a3 : { ...DEFAULT_CC_PERMISSIONS } + }; + if (settings11.enabledPlugins !== void 0) { + merged.enabledPlugins = settings11.enabledPlugins; + } + const content = JSON.stringify(merged, null, 2); + await this.adapter.write(CC_SETTINGS_PATH, content); + } + async exists() { + return this.adapter.exists(CC_SETTINGS_PATH); + } + async getPermissions() { + var _a3; + const settings11 = await this.load(); + return (_a3 = settings11.permissions) != null ? _a3 : { ...DEFAULT_CC_PERMISSIONS }; + } + async updatePermissions(permissions) { + const settings11 = await this.load(); + settings11.permissions = permissions; + await this.save(settings11); + } + async addAllowRule(rule) { + var _a3, _b2; + const permissions = await this.getPermissions(); + if (!((_a3 = permissions.allow) == null ? void 0 : _a3.includes(rule))) { + permissions.allow = [...(_b2 = permissions.allow) != null ? _b2 : [], rule]; + await this.updatePermissions(permissions); + } + } + async addDenyRule(rule) { + var _a3, _b2; + const permissions = await this.getPermissions(); + if (!((_a3 = permissions.deny) == null ? void 0 : _a3.includes(rule))) { + permissions.deny = [...(_b2 = permissions.deny) != null ? _b2 : [], rule]; + await this.updatePermissions(permissions); + } + } + async addAskRule(rule) { + var _a3, _b2; + const permissions = await this.getPermissions(); + if (!((_a3 = permissions.ask) == null ? void 0 : _a3.includes(rule))) { + permissions.ask = [...(_b2 = permissions.ask) != null ? _b2 : [], rule]; + await this.updatePermissions(permissions); + } + } + async removeRule(rule) { + var _a3, _b2, _c; + const permissions = await this.getPermissions(); + permissions.allow = (_a3 = permissions.allow) == null ? void 0 : _a3.filter((r3) => r3 !== rule); + permissions.deny = (_b2 = permissions.deny) == null ? void 0 : _b2.filter((r3) => r3 !== rule); + permissions.ask = (_c = permissions.ask) == null ? void 0 : _c.filter((r3) => r3 !== rule); + await this.updatePermissions(permissions); + } + async getEnabledPlugins() { + var _a3; + const settings11 = await this.load(); + return (_a3 = settings11.enabledPlugins) != null ? _a3 : {}; + } + async setPluginEnabled(pluginId, enabled) { + var _a3; + const settings11 = await this.load(); + const enabledPlugins = (_a3 = settings11.enabledPlugins) != null ? _a3 : {}; + enabledPlugins[pluginId] = enabled; + settings11.enabledPlugins = enabledPlugins; + await this.save(settings11); + } + async getExplicitlyEnabledPluginIds() { + const enabledPlugins = await this.getEnabledPlugins(); + return Object.entries(enabledPlugins).filter(([, enabled]) => enabled).map(([id]) => id); + } + async isPluginDisabled(pluginId) { + const enabledPlugins = await this.getEnabledPlugins(); + return enabledPlugins[pluginId] === false; + } +}; + +// src/core/types/chat.ts +var VIEW_TYPE_CLAUDIAN = "claudian-view"; + +// src/core/types/mcp.ts +function getMcpServerType(config2) { + if (config2.type === "sse") return "sse"; + if (config2.type === "http") return "http"; + if ("url" in config2) return "http"; + return "stdio"; +} +function isValidMcpServerConfig(obj) { + if (!obj || typeof obj !== "object") return false; + const config2 = obj; + if (config2.command && typeof config2.command === "string") return true; + if (config2.url && typeof config2.url === "string") return true; + return false; +} +var DEFAULT_MCP_SERVER = { + enabled: true, + contextSaving: true +}; + +// src/providers/claude/storage/McpStorage.ts +var MCP_CONFIG_PATH = ".claude/mcp.json"; +var McpStorage = class { + constructor(adapter) { + this.adapter = adapter; + } + async load() { + var _a3, _b2, _c, _d, _e; + try { + if (!await this.adapter.exists(MCP_CONFIG_PATH)) { + return []; + } + const content = await this.adapter.read(MCP_CONFIG_PATH); + const file2 = JSON.parse(content); + if (!file2.mcpServers || typeof file2.mcpServers !== "object") { + return []; + } + const claudianMeta = (_b2 = (_a3 = file2._claudian) == null ? void 0 : _a3.servers) != null ? _b2 : {}; + const servers = []; + for (const [name, config2] of Object.entries(file2.mcpServers)) { + if (!isValidMcpServerConfig(config2)) { + continue; + } + const meta3 = (_c = claudianMeta[name]) != null ? _c : {}; + const disabledTools = Array.isArray(meta3.disabledTools) ? meta3.disabledTools.filter((tool) => typeof tool === "string") : void 0; + const normalizedDisabledTools = disabledTools && disabledTools.length > 0 ? disabledTools : void 0; + servers.push({ + name, + config: config2, + enabled: (_d = meta3.enabled) != null ? _d : DEFAULT_MCP_SERVER.enabled, + contextSaving: (_e = meta3.contextSaving) != null ? _e : DEFAULT_MCP_SERVER.contextSaving, + disabledTools: normalizedDisabledTools, + description: meta3.description + }); + } + return servers; + } catch (e3) { + return []; + } + } + async save(servers) { + var _a3; + const mcpServers = {}; + const claudianServers = {}; + for (const server of servers) { + mcpServers[server.name] = server.config; + const meta3 = {}; + if (server.enabled !== DEFAULT_MCP_SERVER.enabled) { + meta3.enabled = server.enabled; + } + if (server.contextSaving !== DEFAULT_MCP_SERVER.contextSaving) { + meta3.contextSaving = server.contextSaving; + } + const normalizedDisabledTools = (_a3 = server.disabledTools) == null ? void 0 : _a3.map((tool) => tool.trim()).filter((tool) => tool.length > 0); + if (normalizedDisabledTools && normalizedDisabledTools.length > 0) { + meta3.disabledTools = normalizedDisabledTools; + } + if (server.description) { + meta3.description = server.description; + } + if (Object.keys(meta3).length > 0) { + claudianServers[server.name] = meta3; + } + } + let existing = null; + if (await this.adapter.exists(MCP_CONFIG_PATH)) { + try { + const raw = await this.adapter.read(MCP_CONFIG_PATH); + const parsed = JSON.parse(raw); + if (parsed && typeof parsed === "object") { + existing = parsed; + } + } catch (e3) { + existing = null; + } + } + const file2 = existing ? { ...existing } : {}; + file2.mcpServers = mcpServers; + const existingClaudian = existing && typeof existing._claudian === "object" ? existing._claudian : null; + if (Object.keys(claudianServers).length > 0) { + file2._claudian = { ...existingClaudian != null ? existingClaudian : {}, servers: claudianServers }; + } else if (existingClaudian) { + const { servers: _servers, ...rest } = existingClaudian; + if (Object.keys(rest).length > 0) { + file2._claudian = rest; + } else { + delete file2._claudian; + } + } else { + delete file2._claudian; + } + const content = JSON.stringify(file2, null, 2); + await this.adapter.write(MCP_CONFIG_PATH, content); + } + async exists() { + return this.adapter.exists(MCP_CONFIG_PATH); + } +}; + +// src/providers/claude/storage/SkillStorage.ts +var SKILLS_PATH = ".claude/skills"; +var SkillStorage = class { + constructor(adapter) { + this.adapter = adapter; + } + async loadAll() { + const skills = []; + try { + const folders = await this.adapter.listFolders(SKILLS_PATH); + for (const folder of folders) { + const skillName = folder.split("/").pop(); + const skillPath = `${SKILLS_PATH}/${skillName}/SKILL.md`; + try { + if (!await this.adapter.exists(skillPath)) continue; + const content = await this.adapter.read(skillPath); + const parsed = parseSlashCommandContent(content); + skills.push({ + ...parsedToSlashCommand(parsed, { + id: `skill-${skillName}`, + name: skillName, + source: "user" + }), + kind: "skill" + }); + } catch (e3) { + } + } + } catch (e3) { + return []; + } + return skills; + } + async save(skill) { + const name = skill.name; + const dirPath = `${SKILLS_PATH}/${name}`; + const filePath = `${dirPath}/SKILL.md`; + await this.adapter.ensureFolder(dirPath); + await this.adapter.write(filePath, serializeCommand(skill)); + } + async delete(skillId) { + const name = skillId.replace(/^skill-/, ""); + const dirPath = `${SKILLS_PATH}/${name}`; + const filePath = `${dirPath}/SKILL.md`; + await this.adapter.delete(filePath); + await this.adapter.deleteFolder(dirPath); + } +}; + +// src/providers/claude/storage/SlashCommandStorage.ts +var COMMANDS_PATH = ".claude/commands"; +var SlashCommandStorage = class { + constructor(adapter) { + this.adapter = adapter; + } + async loadAll() { + const commands = []; + try { + const files = await this.adapter.listFilesRecursive(COMMANDS_PATH); + for (const filePath of files) { + if (!filePath.endsWith(".md")) continue; + try { + const command = await this.loadFromFile(filePath); + if (command) { + commands.push(command); + } + } catch (e3) { + } + } + } catch (e3) { + } + return commands; + } + async loadFromFile(filePath) { + const content = await this.adapter.read(filePath); + return this.parseFile(content, filePath); + } + async save(command) { + const filePath = this.getFilePath(command); + await this.adapter.write(filePath, serializeCommand(command)); + } + async delete(commandId) { + const files = await this.adapter.listFilesRecursive(COMMANDS_PATH); + for (const filePath of files) { + if (!filePath.endsWith(".md")) continue; + const id = this.filePathToId(filePath); + if (id === commandId) { + await this.adapter.delete(filePath); + return; + } + } + } + getFilePath(command) { + const safeName = command.name.replace(/[^a-zA-Z0-9_/-]/g, "-"); + return `${COMMANDS_PATH}/${safeName}.md`; + } + parseFile(content, filePath) { + const parsed = parseSlashCommandContent(content); + return { + ...parsedToSlashCommand(parsed, { + id: this.filePathToId(filePath), + name: this.filePathToName(filePath) + }), + kind: "command" + }; + } + filePathToId(filePath) { + const relativePath = filePath.replace(`${COMMANDS_PATH}/`, "").replace(/\.md$/, ""); + const escaped = relativePath.replace(/-/g, "-_").replace(/\//g, "--"); + return `cmd-${escaped}`; + } + filePathToName(filePath) { + return filePath.replace(`${COMMANDS_PATH}/`, "").replace(/\.md$/, ""); + } +}; + +// src/providers/claude/storage/StorageService.ts +var CLAUDE_PATH = ".claude"; +var StorageService = class { + constructor(plugin, adapter) { + this.plugin = plugin; + this.app = plugin.app; + this.adapter = adapter != null ? adapter : new VaultFileAdapter(this.app); + this.ccSettings = new CCSettingsStorage(this.adapter); + this.claudianSettings = new ClaudianSettingsStorage(this.adapter); + this.commands = new SlashCommandStorage(this.adapter); + this.skills = new SkillStorage(this.adapter); + this.sessions = new SessionStorage(this.adapter); + this.mcp = new McpStorage(this.adapter); + this.agents = new AgentVaultStorage(this.adapter); + } + async initialize() { + await this.ensureDirectories(); + const cc = await this.ccSettings.load(); + const claudian = await this.claudianSettings.load(); + return { cc, claudian }; + } + async ensureDirectories() { + await this.adapter.ensureFolder(CLAUDE_PATH); + await this.adapter.ensureFolder(CLAUDIAN_STORAGE_PATH); + await this.adapter.ensureFolder(COMMANDS_PATH); + await this.adapter.ensureFolder(SKILLS_PATH); + await this.adapter.ensureFolder(SESSIONS_PATH); + await this.adapter.ensureFolder(AGENTS_PATH); + } + async loadAllSlashCommands() { + const commands = await this.commands.loadAll(); + const skills = await this.skills.loadAll(); + return [...commands, ...skills]; + } + getAdapter() { + return this.adapter; + } + async getPermissions() { + return this.ccSettings.getPermissions(); + } + async updatePermissions(permissions) { + return this.ccSettings.updatePermissions(permissions); + } + async addAllowRule(rule) { + return this.ccSettings.addAllowRule(createPermissionRule(rule)); + } + async addDenyRule(rule) { + return this.ccSettings.addDenyRule(createPermissionRule(rule)); + } + async removePermissionRule(rule) { + return this.ccSettings.removeRule(createPermissionRule(rule)); + } + async updateClaudianSettings(updates) { + return this.claudianSettings.update(updates); + } + async saveClaudianSettings(settings11) { + return this.claudianSettings.save(settings11); + } + async loadClaudianSettings() { + return this.claudianSettings.load(); + } + async getTabManagerState() { + try { + const data = await this.plugin.loadData(); + if (data == null ? void 0 : data.tabManagerState) { + return this.validateTabManagerState(data.tabManagerState); + } + return null; + } catch (e3) { + return null; + } + } + validateTabManagerState(data) { + if (!data || typeof data !== "object") { + return null; + } + const state = data; + if (!Array.isArray(state.openTabs)) { + return null; + } + const validatedTabs = []; + for (const tab of state.openTabs) { + if (!tab || typeof tab !== "object") { + continue; + } + const tabObj = tab; + if (typeof tabObj.tabId !== "string") { + continue; + } + validatedTabs.push({ + tabId: tabObj.tabId, + conversationId: typeof tabObj.conversationId === "string" ? tabObj.conversationId : null + }); + } + const activeTabId = typeof state.activeTabId === "string" ? state.activeTabId : null; + return { + openTabs: validatedTabs, + activeTabId + }; + } + async setTabManagerState(state) { + try { + const data = await this.plugin.loadData() || {}; + data.tabManagerState = state; + await this.plugin.saveData(data); + } catch (e3) { + new import_obsidian3.Notice("Failed to save tab layout"); + } + } +}; + +// src/providers/claude/ui/ClaudeSettingsTab.ts +var fs8 = __toESM(require("fs")); +var import_obsidian13 = require("obsidian"); + +// src/features/settings/ui/EnvironmentSettingsSection.ts +var import_obsidian5 = require("obsidian"); + +// src/features/settings/ui/EnvSnippetManager.ts +var import_obsidian4 = require("obsidian"); + +// src/i18n/locales/de.json +var de_exports = {}; +__export(de_exports, { + chat: () => chat, + common: () => common, + default: () => de_default, + settings: () => settings +}); +var common = { + save: "Speichern", + cancel: "Abbrechen", + delete: "L\xF6schen", + edit: "Bearbeiten", + add: "Hinzuf\xFCgen", + remove: "Entfernen", + clear: "L\xF6schen", + clearAll: "Alle l\xF6schen", + loading: "L\xE4dt", + error: "Fehler", + success: "Erfolg", + warning: "Warnung", + confirm: "Best\xE4tigen", + settings: "Einstellungen", + advanced: "Erweitert", + enabled: "Aktiviert", + disabled: "Deaktiviert", + platform: "Plattform", + refresh: "Aktualisieren", + rewind: "Zur\xFCckspulen" +}; +var chat = { + rewind: { + confirmMessage: "Zu diesem Punkt zur\xFCckspulen? Datei\xE4nderungen nach dieser Nachricht werden r\xFCckg\xE4ngig gemacht. Das Zur\xFCckspulen betrifft keine manuell oder \xFCber Bash bearbeiteten Dateien.", + confirmButton: "Zur\xFCckspulen", + ariaLabel: "Hierher zur\xFCckspulen", + notice: "Zur\xFCckgespult: {count} Datei(en) wiederhergestellt", + noticeSaveFailed: "Zur\xFCckgespult: {count} Datei(en) wiederhergestellt, aber Status konnte nicht gespeichert werden: {error}", + failed: "Zur\xFCckspulen fehlgeschlagen: {error}", + cannot: "Zur\xFCckspulen nicht m\xF6glich: {error}", + unavailableStreaming: "Zur\xFCckspulen w\xE4hrend des Streamings nicht m\xF6glich", + unavailableNoUuid: "Zur\xFCckspulen nicht m\xF6glich: Nachrichtenkennungen fehlen" + }, + fork: { + ariaLabel: "Konversation verzweigen", + chooseTarget: "Konversation verzweigen", + targetNewTab: "Neuer Tab", + targetCurrentTab: "Aktueller Tab", + maxTabsReached: "Verzweigung nicht m\xF6glich: maximal {count} Tabs erreicht", + notice: "In neuem Tab verzweigt", + noticeCurrentTab: "Im aktuellen Tab verzweigt", + failed: "Verzweigung fehlgeschlagen: {error}", + unavailableStreaming: "Verzweigung w\xE4hrend des Streamings nicht m\xF6glich", + unavailableNoUuid: "Verzweigung nicht m\xF6glich: Nachrichtenkennungen fehlen", + unavailableNoResponse: "Verzweigung nicht m\xF6glich: keine Antwort zum Verzweigen vorhanden", + errorMessageNotFound: "Nachricht nicht gefunden", + errorNoSession: "Keine Sitzungs-ID verf\xFCgbar", + errorNoActiveTab: "Kein aktiver Tab", + commandNoMessages: "Verzweigung nicht m\xF6glich: keine Nachrichten in der Konversation", + commandNoAssistantUuid: "Verzweigung nicht m\xF6glich: keine Assistentenantwort mit Kennungen" + }, + bangBash: { + placeholder: "> Einen Bash-Befehl ausf\xFChren...", + commandPanel: "Befehlspanel", + copyAriaLabel: "Neueste Befehlsausgabe kopieren", + clearAriaLabel: "Bash-Ausgabe l\xF6schen", + commandLabel: "{command}", + statusLabel: "Status des Befehls: {status}", + collapseOutput: "Befehlsausgabe einklappen", + expandOutput: "Befehlsausgabe ausklappen", + running: "Wird ausgef\xFChrt...", + copyFailed: "Kopieren in die Zwischenablage fehlgeschlagen" + } +}; +var settings = { + title: "Claudian Einstellungen", + tabs: { + general: "Allgemein", + claude: "Claude", + codex: "Codex" + }, + display: "Anzeige", + conversations: "Unterhaltungen", + content: "Inhalte", + input: "Eingabe", + setup: "Einrichtung", + models: "Modelle", + experimental: "Experimentell", + userName: { + name: "Wie soll Claudian dich nennen?", + desc: "Dein Name f\xFCr personalisierte Begr\xFC\xDFungen (leer lassen f\xFCr allgemeine Begr\xFC\xDFungen)" + }, + excludedTags: { + name: "Ausgeschlossene Tags", + desc: "Notizen mit diesen Tags werden nicht automatisch als Kontext geladen (einer pro Zeile, ohne #)" + }, + mediaFolder: { + name: "Medienordner", + desc: "Ordner mit Anh\xE4ngen/Bildern. Wenn Notizen ![[image.jpg]] verwenden, sucht Claude hier. Leer lassen f\xFCr Vault-Stammverzeichnis." + }, + systemPrompt: { + name: "Benutzerdefinierter System-Prompt", + desc: "Zus\xE4tzliche Anweisungen, die an den Standard-System-Prompt angeh\xE4ngt werden" + }, + autoTitle: { + name: "Konversationstitel automatisch generieren", + desc: "Generiert automatisch Konversationstitel nach der ersten Nutzernachricht." + }, + titleModel: { + name: "Titel-Generierungsmodell", + desc: "Modell zur automatischen Generierung von Konversationstiteln.", + auto: "Automatisch (Haiku)" + }, + navMappings: { + name: "Vim-Style Navigationszuordnungen", + desc: 'Eine Zuordnung pro Zeile. Format: "map " (Aktionen: scrollUp, scrollDown, focusInput).' + }, + hotkeys: "Tastenk\xFCrzel", + inlineEditHotkey: { + name: "Inline-Bearbeitung", + descWithKey: "Aktuelles Tastenk\xFCrzel: {hotkey}", + descNoKey: "Kein Tastenk\xFCrzel festgelegt", + btnChange: "\xC4ndern", + btnSet: "Festlegen" + }, + openChatHotkey: { + name: "Chat \xF6ffnen", + descWithKey: "Aktuelles Tastenk\xFCrzel: {hotkey}", + descNoKey: "Kein Tastenk\xFCrzel festgelegt", + btnChange: "\xC4ndern", + btnSet: "Festlegen" + }, + newSessionHotkey: { + name: "Neue Sitzung", + descWithKey: "Aktuelles Tastenk\xFCrzel: {hotkey}", + descNoKey: "Kein Tastenk\xFCrzel festgelegt", + btnChange: "\xC4ndern", + btnSet: "Festlegen" + }, + newTabHotkey: { + name: "Neuer Tab", + descWithKey: "Aktuelles Tastenk\xFCrzel: {hotkey}", + descNoKey: "Kein Tastenk\xFCrzel festgelegt", + btnChange: "\xC4ndern", + btnSet: "Festlegen" + }, + closeTabHotkey: { + name: "Tab schlie\xDFen", + descWithKey: "Aktuelles Tastenk\xFCrzel: {hotkey}", + descNoKey: "Kein Tastenk\xFCrzel festgelegt", + btnChange: "\xC4ndern", + btnSet: "Festlegen" + }, + slashCommands: { + name: "Befehle und F\xE4higkeiten", + desc: "Verwalte Vault-Befehle und -F\xE4higkeiten in .claude/commands/ und .claude/skills/. Ausgel\xF6st durch /Name." + }, + hiddenSlashCommands: { + name: "Ausgeblendete Befehle", + desc: "Bestimmte Schr\xE4gstrich-Befehle aus dem Dropdown ausblenden. N\xFCtzlich, um Claude Code-Befehle auszublenden, die f\xFCr Claudian nicht relevant sind. Gib Befehlsnamen ohne f\xFChrenden Schr\xE4gstrich ein, einen pro Zeile.", + placeholder: "commit\nbuild\ntest" + }, + mcpServers: { + name: "MCP-Server", + desc: "Verwalte Vault-MCP-Serverkonfigurationen in .claude/mcp.json. Server mit Kontext-Speichermodus ben\xF6tigen @mention zur Aktivierung." + }, + plugins: { + name: "Claude Code-Plugins", + desc: "Verwalte Claude Code Plugins aus ~/.claude/plugins. Aktivierte Plugins werden pro Vault in .claude/settings.json gespeichert." + }, + subagents: { + name: "Sub-Agenten", + desc: "Verwalte Vault-Sub-Agenten in .claude/agents/. Jede Markdown-Datei definiert einen benutzerdefinierten Agenten.", + noAgents: "Keine Sub-Agenten konfiguriert. Klicke auf +, um einen zu erstellen.", + deleteConfirm: 'Sub-Agent "{name}" l\xF6schen?', + saveFailed: "Sub-Agent konnte nicht gespeichert werden: {message}", + refreshFailed: "Sub-Agenten konnten nicht aktualisiert werden: {message}", + deleteFailed: "Sub-Agent konnte nicht gel\xF6scht werden: {message}", + renameCleanupFailed: 'Warnung: Alte Datei f\xFCr "{name}" konnte nicht entfernt werden', + created: 'Sub-Agent "{name}" erstellt', + updated: 'Sub-Agent "{name}" aktualisiert', + deleted: 'Sub-Agent "{name}" gel\xF6scht', + duplicateName: 'Ein Agent mit dem Namen "{name}" existiert bereits', + descriptionRequired: "Beschreibung ist erforderlich", + promptRequired: "System-Prompt ist erforderlich", + modal: { + titleEdit: "Sub-Agent bearbeiten", + titleAdd: "Sub-Agent hinzuf\xFCgen", + name: "Name", + nameDesc: "Nur Kleinbuchstaben, Zahlen und Bindestriche", + namePlaceholder: "code-reviewer", + description: "Beschreibung", + descriptionDesc: "Kurzbeschreibung dieses Agenten", + descriptionPlaceholder: "Pr\xFCft Code auf Fehler und Stil", + advancedOptions: "Erweiterte Optionen", + model: "Modell", + modelDesc: "Modell\xFCberschreibung f\xFCr diesen Agenten", + tools: "Tools", + toolsDesc: "Kommagetrennte Liste zul\xE4ssiger Tools (leer = alle)", + disallowedTools: "Nicht erlaubte Tools", + disallowedToolsDesc: "Kommagetrennte Liste der zu verbietenden Tools", + skills: "F\xE4higkeiten", + skillsDesc: "Kommagetrennte Liste von F\xE4higkeiten", + prompt: "System-Prompt", + promptDesc: "Anweisungen f\xFCr den Agenten", + promptPlaceholder: "Du bist ein Code-Reviewer. Analysiere den angegebenen Code auf..." + } + }, + safety: "Sicherheit", + loadUserSettings: { + name: "Benutzer-Claude-Einstellungen laden", + desc: "L\xE4dt ~/.claude/settings.json. Wenn aktiviert, k\xF6nnen Benutzer-Claude-Code-Berechtigungsregeln den Sicherheitsmodus umgehen." + }, + claudeSafeMode: { + name: "Safe mode", + desc: "Permission mode used when the Safe toggle is active." + }, + codexSafeMode: { + name: "Safe mode", + desc: "Sandbox mode used when the Safe toggle is active." + }, + environment: "Umgebung", + customVariables: { + name: "Benutzerdefinierte Variablen", + desc: "Umgebungsvariablen f\xFCr Claude SDK (KEY=VALUE-Format, eine pro Zeile). Export-Pr\xE4fix unterst\xFCtzt." + }, + envSnippets: { + name: "Snippets", + addBtn: "Snippet hinzuf\xFCgen", + noSnippets: "Keine gespeicherten Umgebungsvariablen-Snippets. Klicken Sie auf +, um Ihre aktuelle Konfiguration zu speichern.", + nameRequired: "Bitte geben Sie einen Namen f\xFCr das Snippet ein", + modal: { + titleEdit: "Snippet bearbeiten", + titleSave: "Snippet speichern", + name: "Name", + namePlaceholder: "Ein beschreibender Name f\xFCr diese Umgebungskonfiguration", + description: "Beschreibung", + descPlaceholder: "Optionale Beschreibung", + envVars: "Umgebungsvariablen", + envVarsPlaceholder: "KEY=VALUE-Format, eine pro Zeile (export-Pr\xE4fix unterst\xFCtzt)", + save: "Speichern", + update: "Aktualisieren", + cancel: "Abbrechen" + } + }, + customContextLimits: { + name: "Benutzerdefinierte Kontextlimits", + desc: "Legen Sie die Kontextfenstergr\xF6\xDFen f\xFCr Ihre benutzerdefinierten Modelle fest. Leer lassen f\xFCr den Standardwert (200k Token).", + invalid: "Ung\xFCltiges Format. Verwenden Sie: 256k, 1m oder exakte Anzahl (1000-10000000)." + }, + enableOpus1M: { + name: "Opus 1M Kontextfenster", + desc: "Opus 1M in der Modellauswahl anzeigen. In Max-, Team- und Enterprise-Pl\xE4nen enthalten. API- und Pro-Nutzer ben\xF6tigen zus\xE4tzliche Nutzung." + }, + enableSonnet1M: { + name: "Sonnet 1M Kontextfenster", + desc: "Sonnet 1M in der Modellauswahl anzeigen. Erfordert zus\xE4tzliche Nutzung bei Max-, Team- und Enterprise-Pl\xE4nen. API- und Pro-Nutzer ben\xF6tigen zus\xE4tzliche Nutzung." + }, + enableChrome: { + name: "Chrome-Erweiterung aktivieren", + desc: "Erlaubt Claude die Interaktion mit Chrome \xFCber die claude-in-chrome-Erweiterung. Die Erweiterung muss installiert sein. Erfordert Neustart der Sitzung." + }, + enableBangBash: { + name: "Bash-Modus (!) aktivieren", + desc: "Gib ! in ein leeres Eingabefeld ein, um den Bash-Modus zu starten. F\xFChrt Befehle direkt \xFCber Node.js child_process aus. Die Ansicht muss neu ge\xF6ffnet werden.", + validation: { + noNode: "Node.js wurde auf PATH nicht gefunden. Installiere Node.js oder pr\xFCfe deine PATH-Konfiguration." + } + }, + maxTabs: { + name: "Maximale Chat-Tabs", + desc: "Maximale Anzahl gleichzeitiger Chat-Tabs (3-10). Jeder Tab verwendet eine separate Claude-Sitzung.", + warning: "Mehr als 5 Tabs k\xF6nnen Leistung und Speichernutzung beeintr\xE4chtigen." + }, + tabBarPosition: { + name: "Tab-Leiste Position", + desc: "W\xE4hlen Sie, wo Tab-Badges und Aktionsschaltfl\xE4chen angezeigt werden", + input: "\xDCber Eingabefeld (Standard)", + header: "In Kopfzeile" + }, + enableAutoScroll: { + name: "Automatisches Scrollen w\xE4hrend Streaming", + desc: "Automatisch nach unten scrollen, w\xE4hrend Claude Antworten streamt. Deaktivieren, um oben zu bleiben und von Anfang an zu lesen." + }, + openInMainTab: { + name: "Im Haupteditorbereich \xF6ffnen", + desc: "Chat-Panel als Haupttab im zentralen Editorbereich statt in der rechten Seitenleiste \xF6ffnen" + }, + cliPath: { + name: "Claude CLI-Pfad", + desc: "Benutzerdefinierter Pfad zum Claude Code CLI. Leer lassen f\xFCr automatische Erkennung.", + descWindows: "F\xFCr den nativen Installer verwenden Sie claude.exe. F\xFCr npm/pnpm/yarn oder andere Paketmanager-Installationen verwenden Sie den cli.js-Pfad (nicht claude.cmd).", + descUnix: 'F\xFCgen Sie die Ausgabe von "which claude" ein \u2014 funktioniert sowohl f\xFCr native als auch npm/pnpm/yarn-Installationen.', + validation: { + notExist: "Pfad existiert nicht", + isDirectory: "Pfad ist ein Verzeichnis, keine Datei" + } + }, + language: { + name: "Sprache", + desc: "Anzeigesprache der Plugin-Oberfl\xE4che \xE4ndern" + } +}; +var de_default = { + common, + chat, + settings +}; + +// src/i18n/locales/en.json +var en_exports = {}; +__export(en_exports, { + chat: () => chat2, + common: () => common2, + default: () => en_default, + settings: () => settings2 +}); +var common2 = { + save: "Save", + cancel: "Cancel", + delete: "Delete", + edit: "Edit", + add: "Add", + remove: "Remove", + clear: "Clear", + clearAll: "Clear all", + loading: "Loading", + error: "Error", + success: "Success", + warning: "Warning", + confirm: "Confirm", + settings: "Settings", + advanced: "Advanced", + enabled: "Enabled", + disabled: "Disabled", + platform: "Platform", + refresh: "Refresh", + rewind: "Rewind" +}; +var chat2 = { + rewind: { + confirmMessage: "Rewind to this point? File changes after this message will be reverted. Rewinding does not affect files edited manually or via bash.", + confirmButton: "Rewind", + ariaLabel: "Rewind to here", + notice: "Rewound: {count} file(s) reverted", + noticeSaveFailed: "Rewound: {count} file(s) reverted, but failed to save state: {error}", + failed: "Rewind failed: {error}", + cannot: "Cannot rewind: {error}", + unavailableStreaming: "Cannot rewind while streaming", + unavailableNoUuid: "Cannot rewind: missing message identifiers" + }, + fork: { + ariaLabel: "Fork conversation", + chooseTarget: "Fork conversation", + targetNewTab: "New tab", + targetCurrentTab: "Current tab", + maxTabsReached: "Cannot fork: maximum {count} tabs reached", + notice: "Forked to new tab", + noticeCurrentTab: "Forked in current tab", + failed: "Fork failed: {error}", + unavailableStreaming: "Cannot fork while streaming", + unavailableNoUuid: "Cannot fork: missing message identifiers", + unavailableNoResponse: "Cannot fork: no response to fork from", + errorMessageNotFound: "Message not found", + errorNoSession: "No session ID available", + errorNoActiveTab: "No active tab", + commandNoMessages: "Cannot fork: no messages in conversation", + commandNoAssistantUuid: "Cannot fork: no assistant response with identifiers" + }, + bangBash: { + placeholder: "> Run a bash command...", + commandPanel: "Command panel", + copyAriaLabel: "Copy latest command output", + clearAriaLabel: "Clear bash output", + commandLabel: "{command}", + statusLabel: "Status: {status}", + collapseOutput: "Collapse command output", + expandOutput: "Expand command output", + running: "Running...", + copyFailed: "Failed to copy to clipboard" + } +}; +var settings2 = { + title: "Claudian Settings", + tabs: { + general: "General", + claude: "Claude", + codex: "Codex" + }, + display: "Display", + conversations: "Conversations", + content: "Content", + input: "Input", + setup: "Setup", + models: "Models", + experimental: "Experimental", + userName: { + name: "What should Claudian call you?", + desc: "Your name for personalized greetings (leave empty for generic greetings)" + }, + excludedTags: { + name: "Excluded tags", + desc: "Notes with these tags will not auto-load as context (one per line, without #)" + }, + mediaFolder: { + name: "Media folder", + desc: "Folder containing attachments/images. When notes use ![[image.jpg]], Claude will look here. Leave empty for vault root." + }, + systemPrompt: { + name: "Custom system prompt", + desc: "Additional instructions appended to the default system prompt" + }, + autoTitle: { + name: "Auto-generate conversation titles", + desc: "Automatically generate conversation titles after the first user message is sent." + }, + titleModel: { + name: "Title generation model", + desc: "Model used for auto-generating conversation titles.", + auto: "Auto (Haiku)" + }, + navMappings: { + name: "Vim-style navigation mappings", + desc: 'One mapping per line. Format: "map " (actions: scrollUp, scrollDown, focusInput).' + }, + hotkeys: "Hotkeys", + inlineEditHotkey: { + name: "Inline Edit", + descWithKey: "Current hotkey: {hotkey}", + descNoKey: "No hotkey set", + btnChange: "Change", + btnSet: "Set hotkey" + }, + openChatHotkey: { + name: "Open Chat", + descWithKey: "Current hotkey: {hotkey}", + descNoKey: "No hotkey set", + btnChange: "Change", + btnSet: "Set hotkey" + }, + newSessionHotkey: { + name: "New Session", + descWithKey: "Current hotkey: {hotkey}", + descNoKey: "No hotkey set", + btnChange: "Change", + btnSet: "Set hotkey" + }, + newTabHotkey: { + name: "New Tab", + descWithKey: "Current hotkey: {hotkey}", + descNoKey: "No hotkey set", + btnChange: "Change", + btnSet: "Set hotkey" + }, + closeTabHotkey: { + name: "Close Tab", + descWithKey: "Current hotkey: {hotkey}", + descNoKey: "No hotkey set", + btnChange: "Change", + btnSet: "Set hotkey" + }, + slashCommands: { + name: "Commands and Skills", + desc: "Manage vault-level commands and skills stored in .claude/commands/ and .claude/skills/. Triggered by /name." + }, + hiddenSlashCommands: { + name: "Hidden Commands", + desc: "Hide specific slash commands from the dropdown. Useful for hiding Claude Code commands that are not relevant to Claudian. Enter command names without the leading slash, one per line.", + placeholder: "commit\nbuild\ntest" + }, + mcpServers: { + name: "MCP Servers", + desc: "Manage vault-level MCP server configurations stored in .claude/mcp.json. Servers with context-saving mode require @mention to activate." + }, + plugins: { + name: "Claude Code Plugins", + desc: "Manage Claude Code plugins discovered from ~/.claude/plugins. Enabled plugins are stored per vault in .claude/settings.json." + }, + subagents: { + name: "Subagents", + desc: "Manage vault-level subagents stored in .claude/agents/. Each Markdown file defines one custom agent.", + noAgents: "No subagents configured. Click + to create one.", + deleteConfirm: 'Delete subagent "{name}"?', + saveFailed: "Failed to save subagent: {message}", + refreshFailed: "Failed to refresh subagents: {message}", + deleteFailed: "Failed to delete subagent: {message}", + renameCleanupFailed: 'Warning: could not remove old file for "{name}"', + created: 'Subagent "{name}" created', + updated: 'Subagent "{name}" updated', + deleted: 'Subagent "{name}" deleted', + duplicateName: 'An agent named "{name}" already exists', + descriptionRequired: "Description is required", + promptRequired: "System prompt is required", + modal: { + titleEdit: "Edit Subagent", + titleAdd: "Add Subagent", + name: "Name", + nameDesc: "Lowercase letters, numbers, and hyphens only", + namePlaceholder: "code-reviewer", + description: "Description", + descriptionDesc: "Brief description of this agent", + descriptionPlaceholder: "Reviews code for bugs and style", + advancedOptions: "Advanced options", + model: "Model", + modelDesc: "Model override for this agent", + tools: "Tools", + toolsDesc: "Comma-separated list of allowed tools (empty = all)", + disallowedTools: "Disallowed tools", + disallowedToolsDesc: "Comma-separated list of tools to disallow", + skills: "Skills", + skillsDesc: "Comma-separated list of skills", + prompt: "System prompt", + promptDesc: "Instructions for the agent", + promptPlaceholder: "You are a code reviewer. Analyze the given code for..." + } + }, + safety: "Safety", + loadUserSettings: { + name: "Load user Claude settings", + desc: "Load ~/.claude/settings.json. When enabled, user's Claude Code permission rules may bypass Safe mode." + }, + claudeSafeMode: { + name: "Safe mode", + desc: "Permission mode used when the Safe toggle is active." + }, + codexSafeMode: { + name: "Safe mode", + desc: "Sandbox mode used when the Safe toggle is active." + }, + environment: "Environment", + customVariables: { + name: "Custom variables", + desc: "Environment variables for Claude SDK (KEY=VALUE format, one per line). Shell export prefix supported." + }, + envSnippets: { + name: "Snippets", + addBtn: "Add snippet", + noSnippets: "No saved environment snippets yet. Click + to save your current environment configuration.", + nameRequired: "Please enter a name for the snippet", + modal: { + titleEdit: "Edit snippet", + titleSave: "Save snippet", + name: "Name", + namePlaceholder: "A descriptive name for this environment configuration", + description: "Description", + descPlaceholder: "Optional description", + envVars: "Environment variables", + envVarsPlaceholder: "KEY=VALUE format, one per line (export prefix supported)", + save: "Save", + update: "Update", + cancel: "Cancel" + } + }, + customContextLimits: { + name: "Custom Context Limits", + desc: "Set context window sizes for your custom models. Leave empty to use the default (200k tokens).", + invalid: "Invalid format. Use: 256k, 1m, or exact count (1000-10000000)." + }, + enableOpus1M: { + name: "Opus 1M context window", + desc: "Show Opus 1M in the model selector. Included with Max, Team, and Enterprise plans. API and Pro users need extra usage." + }, + enableSonnet1M: { + name: "Sonnet 1M context window", + desc: "Show Sonnet 1M in the model selector. Requires extra usage on Max, Team, and Enterprise plans. API and Pro users need extra usage." + }, + enableChrome: { + name: "Enable Chrome extension", + desc: "Allow Claude to interact with Chrome via the claude-in-chrome extension. Requires the extension to be installed. Requires session restart." + }, + enableBangBash: { + name: "Enable bash mode (!)", + desc: "Type ! on empty input to enter bash mode. Runs commands directly via Node.js child_process. Requires view reopen.", + validation: { + noNode: "Node.js not found on PATH. Install Node.js or check your PATH configuration." + } + }, + maxTabs: { + name: "Maximum chat tabs", + desc: "Maximum number of concurrent chat tabs (3-10). Each tab uses a separate Claude session.", + warning: "More than 5 tabs may impact performance and memory usage." + }, + tabBarPosition: { + name: "Tab bar position", + desc: "Choose where to display tab badges and action buttons", + input: "Above input (default)", + header: "In header" + }, + enableAutoScroll: { + name: "Auto-scroll during streaming", + desc: "Automatically scroll to the bottom as Claude streams responses. Disable to stay at the top and read from the beginning." + }, + openInMainTab: { + name: "Open in main editor area", + desc: "Open chat panel as a main tab in the center editor area instead of the right sidebar" + }, + cliPath: { + name: "Claude CLI path", + desc: "Custom path to Claude Code CLI. Leave empty for auto-detection.", + descWindows: "For the native installer, use claude.exe. For npm/pnpm/yarn or other package manager installs, use the cli.js path (not claude.cmd).", + descUnix: 'Paste the output of "which claude" \u2014 works for both native and npm/pnpm/yarn installs.', + validation: { + notExist: "Path does not exist", + isDirectory: "Path is a directory, not a file" + } + }, + language: { + name: "Language", + desc: "Change the display language of the plugin interface" + } +}; +var en_default = { + common: common2, + chat: chat2, + settings: settings2 +}; + +// src/i18n/locales/es.json +var es_exports = {}; +__export(es_exports, { + chat: () => chat3, + common: () => common3, + default: () => es_default, + settings: () => settings3 +}); +var common3 = { + save: "Guardar", + cancel: "Cancelar", + delete: "Eliminar", + edit: "Editar", + add: "Agregar", + remove: "Eliminar", + clear: "Limpiar", + clearAll: "Limpiar todo", + loading: "Cargando", + error: "Error", + success: "\xC9xito", + warning: "Advertencia", + confirm: "Confirmar", + settings: "Configuraci\xF3n", + advanced: "Avanzado", + enabled: "Habilitado", + disabled: "Deshabilitado", + platform: "Plataforma", + refresh: "Actualizar", + rewind: "Rebobinar" +}; +var chat3 = { + rewind: { + confirmMessage: "\xBFRebobinar a este punto? Los cambios de archivos despu\xE9s de este mensaje ser\xE1n revertidos. El rebobinado no afecta archivos editados manualmente o mediante bash.", + confirmButton: "Rebobinar", + ariaLabel: "Rebobinar hasta aqu\xED", + notice: "Rebobinado: {count} archivo(s) revertido(s)", + noticeSaveFailed: "Rebobinado: {count} archivo(s) revertido(s), pero no se pudo guardar el estado: {error}", + failed: "Error al rebobinar: {error}", + cannot: "No se puede rebobinar: {error}", + unavailableStreaming: "No se puede rebobinar durante la transmisi\xF3n", + unavailableNoUuid: "No se puede rebobinar: faltan identificadores de mensaje" + }, + fork: { + ariaLabel: "Bifurcar conversaci\xF3n", + chooseTarget: "Bifurcar conversaci\xF3n", + targetNewTab: "Nueva pesta\xF1a", + targetCurrentTab: "Pesta\xF1a actual", + maxTabsReached: "No se puede bifurcar: m\xE1ximo de {count} pesta\xF1as alcanzado", + notice: "Bifurcado a nueva pesta\xF1a", + noticeCurrentTab: "Bifurcado en pesta\xF1a actual", + failed: "Error al bifurcar: {error}", + unavailableStreaming: "No se puede bifurcar durante la transmisi\xF3n", + unavailableNoUuid: "No se puede bifurcar: faltan identificadores de mensaje", + unavailableNoResponse: "No se puede bifurcar: no hay respuesta para bifurcar", + errorMessageNotFound: "Mensaje no encontrado", + errorNoSession: "No hay ning\xFAn ID de sesi\xF3n disponible", + errorNoActiveTab: "No hay ninguna pesta\xF1a activa", + commandNoMessages: "No se puede bifurcar: no hay mensajes en la conversaci\xF3n", + commandNoAssistantUuid: "No se puede bifurcar: no hay respuesta del asistente con identificadores" + }, + bangBash: { + placeholder: "> Ejecuta un comando bash...", + commandPanel: "Panel de comandos", + copyAriaLabel: "Copiar la salida del comando m\xE1s reciente", + clearAriaLabel: "Limpiar la salida de bash", + commandLabel: "{command}", + statusLabel: "Estado: {status}", + collapseOutput: "Contraer la salida del comando", + expandOutput: "Expandir la salida del comando", + running: "Ejecutando...", + copyFailed: "No se pudo copiar al portapapeles" + } +}; +var settings3 = { + title: "Configuraci\xF3n de Claudian", + tabs: { + general: "General", + claude: "Claude", + codex: "Codex" + }, + display: "Pantalla", + conversations: "Conversaciones", + content: "Contenido", + input: "Entrada", + setup: "Configuraci\xF3n", + models: "Modelos", + experimental: "Experimental", + userName: { + name: "\xBFC\xF3mo deber\xEDa Claudian llamarte?", + desc: "Tu nombre para saludos personalizados (dejar vac\xEDo para saludos gen\xE9ricos)" + }, + excludedTags: { + name: "Etiquetas excluidas", + desc: "Las notas con estas etiquetas no se cargar\xE1n autom\xE1ticamente como contexto (una por l\xEDnea, sin #)" + }, + mediaFolder: { + name: "Carpeta de medios", + desc: "Carpeta que contiene archivos adjuntos/imagenes. Cuando las notas usan ![[image.jpg]], Claude buscar\xE1 aqu\xED. Dejar vac\xEDo para la ra\xEDz del dep\xF3sito." + }, + systemPrompt: { + name: "Prompt de sistema personalizado", + desc: "Instrucciones adicionales a\xF1adidas al prompt de sistema por defecto" + }, + autoTitle: { + name: "Generar autom\xE1ticamente t\xEDtulos de conversaci\xF3n", + desc: "Genera autom\xE1ticamente t\xEDtulos de conversaci\xF3n despu\xE9s del primer mensaje del usuario." + }, + titleModel: { + name: "Modelo de generaci\xF3n de t\xEDtulos", + desc: "Modelo utilizado para generar autom\xE1ticamente t\xEDtulos de conversaci\xF3n.", + auto: "Autom\xE1tico (Haiku)" + }, + navMappings: { + name: "Mapeos de navegaci\xF3n estilo Vim", + desc: 'Un mapeo por l\xEDnea. Formato: "map " (acciones: scrollUp, scrollDown, focusInput).' + }, + hotkeys: "Atajos de teclado", + inlineEditHotkey: { + name: "Edici\xF3n en l\xEDnea", + descWithKey: "Atajo actual: {hotkey}", + descNoKey: "Sin atajo configurado", + btnChange: "Cambiar", + btnSet: "Configurar" + }, + openChatHotkey: { + name: "Abrir chat", + descWithKey: "Atajo actual: {hotkey}", + descNoKey: "Sin atajo configurado", + btnChange: "Cambiar", + btnSet: "Configurar" + }, + newSessionHotkey: { + name: "Nueva sesi\xF3n", + descWithKey: "Atajo actual: {hotkey}", + descNoKey: "Sin atajo configurado", + btnChange: "Cambiar", + btnSet: "Configurar" + }, + newTabHotkey: { + name: "Nueva pesta\xF1a", + descWithKey: "Atajo actual: {hotkey}", + descNoKey: "Sin atajo configurado", + btnChange: "Cambiar", + btnSet: "Configurar" + }, + closeTabHotkey: { + name: "Cerrar pesta\xF1a", + descWithKey: "Atajo actual: {hotkey}", + descNoKey: "Sin atajo configurado", + btnChange: "Cambiar", + btnSet: "Configurar" + }, + slashCommands: { + name: "Comandos y habilidades", + desc: "Administra comandos y habilidades a nivel de vault almacenados en .claude/commands/ y .claude/skills/. Activados por /nombre." + }, + hiddenSlashCommands: { + name: "Comandos ocultos", + desc: "Oculta comandos slash espec\xEDficos del men\xFA desplegable. \xDAtil para ocultar comandos de Claude Code que no son relevantes para Claudian. Ingresa nombres de comandos sin la barra inicial, uno por l\xEDnea.", + placeholder: "commit\nbuild\ntest" + }, + mcpServers: { + name: "Servidores MCP", + desc: "Administra configuraciones de servidores MCP a nivel de vault almacenadas en .claude/mcp.json. Los servidores con modo de guardado de contexto requieren @mention para activarse." + }, + plugins: { + name: "Plugins de Claude Code", + desc: "Administra plugins de Claude Code descubiertos desde ~/.claude/plugins. Los plugins habilitados se almacenan por vault en .claude/settings.json." + }, + subagents: { + name: "Subagentes", + desc: "Administra subagentes a nivel de vault almacenados en .claude/agents/. Cada archivo Markdown define un agente personalizado.", + noAgents: "No hay subagentes configurados. Haz clic en + para crear uno.", + deleteConfirm: '\xBFEliminar el subagente "{name}"?', + saveFailed: "No se pudo guardar el subagente: {message}", + refreshFailed: "No se pudieron actualizar los subagentes: {message}", + deleteFailed: "No se pudo eliminar el subagente: {message}", + renameCleanupFailed: 'Advertencia: no se pudo eliminar el archivo anterior de "{name}"', + created: 'Se cre\xF3 el subagente "{name}"', + updated: 'Se actualiz\xF3 el subagente "{name}"', + deleted: 'Se elimin\xF3 el subagente "{name}"', + duplicateName: 'Ya existe un agente con el nombre "{name}"', + descriptionRequired: "La descripci\xF3n es obligatoria", + promptRequired: "El prompt del sistema es obligatorio", + modal: { + titleEdit: "Editar subagente", + titleAdd: "Agregar subagente", + name: "Nombre", + nameDesc: "Solo letras min\xFAsculas, n\xFAmeros y guiones", + namePlaceholder: "code-reviewer", + description: "Descripci\xF3n", + descriptionDesc: "Descripci\xF3n breve de este agente", + descriptionPlaceholder: "Revisa c\xF3digo en busca de errores y estilo", + advancedOptions: "Opciones avanzadas", + model: "Modelo", + modelDesc: "Modelo alternativo para este agente", + tools: "Herramientas", + toolsDesc: "Lista separada por comas de las herramientas permitidas (vac\xEDo = todas)", + disallowedTools: "Herramientas no permitidas", + disallowedToolsDesc: "Lista separada por comas de herramientas no permitidas", + skills: "Habilidades", + skillsDesc: "Lista separada por comas de habilidades", + prompt: "Prompt del sistema", + promptDesc: "Instrucciones para el agente", + promptPlaceholder: "Eres un revisor de c\xF3digo. Analiza el c\xF3digo proporcionado para..." + } + }, + safety: "Seguridad", + loadUserSettings: { + name: "Cargar configuraci\xF3n de usuario Claude", + desc: "Carga ~/.claude/settings.json. Cuando est\xE1 habilitado, las reglas de permisos del usuario pueden eludir el modo seguro." + }, + claudeSafeMode: { + name: "Safe mode", + desc: "Permission mode used when the Safe toggle is active." + }, + codexSafeMode: { + name: "Safe mode", + desc: "Sandbox mode used when the Safe toggle is active." + }, + environment: "Entorno", + customVariables: { + name: "Variables personalizadas", + desc: "Variables de entorno para Claude SDK (formato KEY=VALUE, una por l\xEDnea). Prefijo export soportado." + }, + envSnippets: { + name: "Fragmentos", + addBtn: "A\xF1adir fragmento", + noSnippets: "No hay fragmentos de entorno guardados. Haga clic en + para guardar su configuraci\xF3n actual.", + nameRequired: "Por favor ingrese un nombre para el fragmento", + modal: { + titleEdit: "Editar fragmento", + titleSave: "Guardar fragmento", + name: "Nombre", + namePlaceholder: "Un nombre descriptivo para esta configuraci\xF3n", + description: "Descripci\xF3n", + descPlaceholder: "Descripci\xF3n opcional", + envVars: "Variables de entorno", + envVarsPlaceholder: "Formato KEY=VALUE, una por l\xEDnea (prefijo export soportado)", + save: "Guardar", + update: "Actualizar", + cancel: "Cancelar" + } + }, + customContextLimits: { + name: "L\xEDmites de contexto personalizados", + desc: "Establezca tama\xF1os de ventana de contexto para sus modelos personalizados. Deje vac\xEDo para usar el valor predeterminado (200k tokens).", + invalid: "Formato inv\xE1lido. Use: 256k, 1m o n\xFAmero exacto (1000-10000000)." + }, + enableOpus1M: { + name: "Ventana de contexto Opus 1M", + desc: "Mostrar Opus 1M en el selector de modelos. Incluido en planes Max, Team y Enterprise. Usuarios de API y Pro necesitan uso adicional." + }, + enableSonnet1M: { + name: "Ventana de contexto Sonnet 1M", + desc: "Mostrar Sonnet 1M en el selector de modelos. Requiere uso adicional en planes Max, Team y Enterprise. Usuarios de API y Pro necesitan uso adicional." + }, + enableChrome: { + name: "Habilitar extensi\xF3n de Chrome", + desc: "Permitir que Claude interact\xFAe con Chrome a trav\xE9s de la extensi\xF3n claude-in-chrome. Requiere que la extensi\xF3n est\xE9 instalada. Requiere reinicio de sesi\xF3n." + }, + enableBangBash: { + name: "Habilitar modo bash (!)", + desc: "Escribe ! en una entrada vac\xEDa para entrar en modo bash. Ejecuta comandos directamente mediante Node.js child_process. Requiere volver a abrir la vista.", + validation: { + noNode: "Node.js no se encontr\xF3 en PATH. Instala Node.js o revisa tu configuraci\xF3n de PATH." + } + }, + maxTabs: { + name: "M\xE1ximo de pesta\xF1as de chat", + desc: "N\xFAmero m\xE1ximo de pesta\xF1as de chat simult\xE1neas (3-10). Cada pesta\xF1a usa una sesi\xF3n de Claude separada.", + warning: "M\xE1s de 5 pesta\xF1as puede afectar el rendimiento y el uso de memoria." + }, + tabBarPosition: { + name: "Posici\xF3n de la barra de pesta\xF1as", + desc: "Elige d\xF3nde mostrar las insignias de pesta\xF1as y los botones de acci\xF3n", + input: "Sobre el \xE1rea de entrada (predeterminado)", + header: "En el encabezado" + }, + enableAutoScroll: { + name: "Desplazamiento autom\xE1tico durante streaming", + desc: "Desplazarse autom\xE1ticamente hacia abajo mientras Claude transmite respuestas. Desactivar para quedarse arriba y leer desde el principio." + }, + openInMainTab: { + name: "Abrir en \xE1rea de editor principal", + desc: "Abrir el panel de chat como una pesta\xF1a principal en el \xE1rea de editor central en lugar de la barra lateral derecha" + }, + cliPath: { + name: "Ruta CLI Claude", + desc: "Ruta personalizada a Claude Code CLI. Dejar vac\xEDo para detecci\xF3n autom\xE1tica.", + descWindows: "Para el instalador nativo, use claude.exe. Para instalaciones con npm/pnpm/yarn u otros gestores de paquetes, use la ruta cli.js (no claude.cmd).", + descUnix: 'Pegue la salida de "which claude" \u2014 funciona tanto para instalaciones nativas como npm/pnpm/yarn.', + validation: { + notExist: "La ruta no existe", + isDirectory: "La ruta es un directorio, no un archivo" + } + }, + language: { + name: "Idioma", + desc: "Cambiar el idioma de visualizaci\xF3n de la interfaz del plugin" + } +}; +var es_default = { + common: common3, + chat: chat3, + settings: settings3 +}; + +// src/i18n/locales/fr.json +var fr_exports = {}; +__export(fr_exports, { + chat: () => chat4, + common: () => common4, + default: () => fr_default, + settings: () => settings4 +}); +var common4 = { + save: "Enregistrer", + cancel: "Annuler", + delete: "Supprimer", + edit: "Modifier", + add: "Ajouter", + remove: "Supprimer", + clear: "Effacer", + clearAll: "Tout effacer", + loading: "Chargement", + error: "Erreur", + success: "Succ\xE8s", + warning: "Avertissement", + confirm: "Confirmer", + settings: "Param\xE8tres", + advanced: "Avanc\xE9", + enabled: "Activ\xE9", + disabled: "D\xE9sactiv\xE9", + platform: "Plateforme", + refresh: "Actualiser", + rewind: "Rembobiner" +}; +var chat4 = { + rewind: { + confirmMessage: "Rembobiner jusqu'\xE0 ce point ? Les modifications de fichiers apr\xE8s ce message seront annul\xE9es. Le rembobinage n'affecte pas les fichiers modifi\xE9s manuellement ou via bash.", + confirmButton: "Rembobiner", + ariaLabel: "Rembobiner jusqu'ici", + notice: "Rembobin\xE9 : {count} fichier(s) restaur\xE9(s)", + noticeSaveFailed: "Rembobin\xE9 : {count} fichier(s) restaur\xE9(s), mais impossible d'enregistrer l'\xE9tat : {error}", + failed: "\xC9chec du rembobinage : {error}", + cannot: "Impossible de rembobiner : {error}", + unavailableStreaming: "Impossible de rembobiner pendant le streaming", + unavailableNoUuid: "Impossible de rembobiner : identifiants de message manquants" + }, + fork: { + ariaLabel: "Bifurquer la conversation", + chooseTarget: "Bifurquer la conversation", + targetNewTab: "Nouvel onglet", + targetCurrentTab: "Onglet actuel", + maxTabsReached: "Impossible de bifurquer : maximum de {count} onglets atteint", + notice: "Bifurqu\xE9 dans un nouvel onglet", + noticeCurrentTab: "Bifurqu\xE9 dans l'onglet actuel", + failed: "\xC9chec de la bifurcation : {error}", + unavailableStreaming: "Impossible de bifurquer pendant le streaming", + unavailableNoUuid: "Impossible de bifurquer : identifiants de message manquants", + unavailableNoResponse: "Impossible de bifurquer : aucune r\xE9ponse pour bifurquer", + errorMessageNotFound: "Message introuvable", + errorNoSession: "Aucun ID de session disponible", + errorNoActiveTab: "Aucun onglet actif", + commandNoMessages: "Impossible de bifurquer : aucun message dans la conversation", + commandNoAssistantUuid: "Impossible de bifurquer : aucune r\xE9ponse de l\u2019assistant avec des identifiants" + }, + bangBash: { + placeholder: "> Ex\xE9cuter une commande bash...", + commandPanel: "Panneau de commandes", + copyAriaLabel: "Copier la sortie de la derni\xE8re commande", + clearAriaLabel: "Effacer la sortie bash", + commandLabel: "{command}", + statusLabel: "Statut : {status}", + collapseOutput: "R\xE9duire la sortie de la commande", + expandOutput: "D\xE9velopper la sortie de la commande", + running: "Ex\xE9cution...", + copyFailed: "\xC9chec de la copie dans le presse-papiers" + } +}; +var settings4 = { + title: "Param\xE8tres Claudian", + tabs: { + general: "G\xE9n\xE9ral", + claude: "Claude", + codex: "Codex" + }, + display: "Affichage", + conversations: "Conversations", + content: "Contenu", + input: "Saisie", + setup: "Configuration", + models: "Mod\xE8les", + experimental: "Exp\xE9rimental", + userName: { + name: "Comment Claudian doit-il vous appeler ?", + desc: "Votre nom pour les salutations personnalis\xE9es (laisser vide pour les salutations g\xE9n\xE9riques)" + }, + excludedTags: { + name: "Tags exclus", + desc: "Les notes avec ces tags ne seront pas charg\xE9es automatiquement comme contexte (un par ligne, sans #)" + }, + mediaFolder: { + name: "Dossier des m\xE9dias", + desc: "Dossier contenant les pi\xE8ces jointes/images. Lorsque les notes utilisent ![[image.jpg]], Claude cherchera ici. Laisser vide pour la racine du coffre." + }, + systemPrompt: { + name: "Prompt syst\xE8me personnalis\xE9", + desc: "Instructions suppl\xE9mentaires ajout\xE9es au prompt syst\xE8me par d\xE9faut" + }, + autoTitle: { + name: "G\xE9n\xE9rer automatiquement les titres de conversation", + desc: "G\xE9n\xE8re automatiquement les titres de conversation apr\xE8s le premier message de l'utilisateur." + }, + titleModel: { + name: "Mod\xE8le de g\xE9n\xE9ration de titre", + desc: "Mod\xE8le utilis\xE9 pour g\xE9n\xE9rer automatiquement les titres de conversation.", + auto: "Automatique (Haiku)" + }, + navMappings: { + name: "Mappages de navigation style Vim", + desc: 'Un mappage par ligne. Format : "map " (actions : scrollUp, scrollDown, focusInput).' + }, + hotkeys: "Raccourcis clavier", + inlineEditHotkey: { + name: "\xC9dition en ligne", + descWithKey: "Raccourci actuel : {hotkey}", + descNoKey: "Aucun raccourci d\xE9fini", + btnChange: "Modifier", + btnSet: "D\xE9finir" + }, + openChatHotkey: { + name: "Ouvrir le chat", + descWithKey: "Raccourci actuel : {hotkey}", + descNoKey: "Aucun raccourci d\xE9fini", + btnChange: "Modifier", + btnSet: "D\xE9finir" + }, + newSessionHotkey: { + name: "Nouvelle session", + descWithKey: "Raccourci actuel : {hotkey}", + descNoKey: "Aucun raccourci d\xE9fini", + btnChange: "Modifier", + btnSet: "D\xE9finir" + }, + newTabHotkey: { + name: "Nouvel onglet", + descWithKey: "Raccourci actuel : {hotkey}", + descNoKey: "Aucun raccourci d\xE9fini", + btnChange: "Modifier", + btnSet: "D\xE9finir" + }, + closeTabHotkey: { + name: "Fermer l'onglet", + descWithKey: "Raccourci actuel : {hotkey}", + descNoKey: "Aucun raccourci d\xE9fini", + btnChange: "Modifier", + btnSet: "D\xE9finir" + }, + slashCommands: { + name: "Commandes et comp\xE9tences", + desc: "G\xE9rez les commandes et comp\xE9tences au niveau du vault stock\xE9es dans .claude/commands/ et .claude/skills/. D\xE9clench\xE9es par /nom." + }, + hiddenSlashCommands: { + name: "Commandes masqu\xE9es", + desc: "Masquer des commandes slash sp\xE9cifiques du menu d\xE9roulant. Utile pour masquer les commandes Claude Code qui ne sont pas pertinentes pour Claudian. Entrez les noms de commandes sans le slash initial, un par ligne.", + placeholder: "commit\nbuild\ntest" + }, + mcpServers: { + name: "Serveurs MCP", + desc: "G\xE9rez les configurations de serveurs MCP au niveau du vault stock\xE9es dans .claude/mcp.json. Les serveurs avec mode de sauvegarde de contexte n\xE9cessitent une @mention pour s'activer." + }, + plugins: { + name: "Plugins Claude Code", + desc: "G\xE9rez les plugins Claude Code d\xE9couverts dans ~/.claude/plugins. Les plugins activ\xE9s sont stock\xE9s par vault dans .claude/settings.json." + }, + subagents: { + name: "Sous-agents", + desc: "G\xE9rez les sous-agents au niveau du vault stock\xE9s dans .claude/agents/. Chaque fichier Markdown d\xE9finit un agent personnalis\xE9.", + noAgents: "Aucun sous-agent configur\xE9. Cliquez sur + pour en cr\xE9er un.", + deleteConfirm: 'Supprimer le sous-agent "{name}" ?', + saveFailed: "\xC9chec de l\u2019enregistrement du sous-agent : {message}", + refreshFailed: "\xC9chec de l\u2019actualisation des subagents : {message}", + deleteFailed: "\xC9chec de la suppression du sous-agent : {message}", + renameCleanupFailed: 'Avertissement : impossible de supprimer l\u2019ancien fichier pour "{name}"', + created: 'Sous-agent "{name}" cr\xE9\xE9', + updated: 'Sous-agent "{name}" mis \xE0 jour', + deleted: 'Sous-agent "{name}" supprim\xE9', + duplicateName: 'Un agent nomm\xE9 "{name}" existe d\xE9j\xE0', + descriptionRequired: "La description est obligatoire", + promptRequired: "Le prompt syst\xE8me est obligatoire", + modal: { + titleEdit: "Modifier le sous-agent", + titleAdd: "Ajouter un sous-agent", + name: "Nom", + nameDesc: "Lettres minuscules, chiffres et tirets uniquement", + namePlaceholder: "code-reviewer", + description: "Description", + descriptionDesc: "Br\xE8ve description de cet agent", + descriptionPlaceholder: "Examine le code pour d\xE9tecter les bugs et les probl\xE8mes de style", + advancedOptions: "Options avanc\xE9es", + model: "Mod\xE8le", + modelDesc: "Mod\xE8le \xE0 utiliser pour cet agent", + tools: "Outils", + toolsDesc: "Liste des outils autoris\xE9s, s\xE9par\xE9s par des virgules (vide = tous)", + disallowedTools: "Outils non autoris\xE9s", + disallowedToolsDesc: "Liste des outils \xE0 interdire, s\xE9par\xE9s par des virgules", + skills: "Comp\xE9tences", + skillsDesc: "Liste des comp\xE9tences, s\xE9par\xE9es par des virgules", + prompt: "Prompt syst\xE8me", + promptDesc: "Instructions pour l\u2019agent", + promptPlaceholder: "Vous \xEAtes un relecteur de code. Analysez le code fourni pour..." + } + }, + safety: "S\xE9curit\xE9", + loadUserSettings: { + name: "Charger les param\xE8tres utilisateur Claude", + desc: "Charge ~/.claude/settings.json. Lorsqu'activ\xE9, les r\xE8gles de permission de l'utilisateur peuvent contourner le mode s\xE9curis\xE9." + }, + claudeSafeMode: { + name: "Safe mode", + desc: "Permission mode used when the Safe toggle is active." + }, + codexSafeMode: { + name: "Safe mode", + desc: "Sandbox mode used when the Safe toggle is active." + }, + environment: "Environnement", + customVariables: { + name: "Variables personnalis\xE9es", + desc: "Variables d'environnement pour Claude SDK (format KEY=VALUE, une par ligne). Pr\xE9fixe export support\xE9." + }, + envSnippets: { + name: "Extraits", + addBtn: "Ajouter un extrait", + noSnippets: "Aucun extrait d'environnement enregistr\xE9. Cliquez sur + pour sauvegarder votre configuration actuelle.", + nameRequired: "Veuillez entrer un nom pour l'extrait", + modal: { + titleEdit: "Modifier l'extrait", + titleSave: "Sauvegarder l'extrait", + name: "Nom", + namePlaceholder: "Un nom descriptif pour cette configuration", + description: "Description", + descPlaceholder: "Description optionnelle", + envVars: "Variables d'environnement", + envVarsPlaceholder: "Format KEY=VALUE, une par ligne (pr\xE9fixe export support\xE9)", + save: "Enregistrer", + update: "Mettre \xE0 jour", + cancel: "Annuler" + } + }, + customContextLimits: { + name: "Limites de contexte personnalis\xE9es", + desc: "D\xE9finissez les tailles de fen\xEAtre de contexte pour vos mod\xE8les personnalis\xE9s. Laissez vide pour utiliser la valeur par d\xE9faut (200k tokens).", + invalid: "Format invalide. Utilisez : 256k, 1m ou nombre exact (1000-10000000)." + }, + enableOpus1M: { + name: "Fen\xEAtre de contexte Opus 1M", + desc: "Afficher Opus 1M dans le s\xE9lecteur de mod\xE8le. Inclus avec les plans Max, Team et Enterprise. Les utilisateurs API et Pro n\xE9cessitent une utilisation suppl\xE9mentaire." + }, + enableSonnet1M: { + name: "Fen\xEAtre de contexte Sonnet 1M", + desc: "Afficher Sonnet 1M dans le s\xE9lecteur de mod\xE8le. N\xE9cessite une utilisation suppl\xE9mentaire sur les plans Max, Team et Enterprise. Les utilisateurs API et Pro n\xE9cessitent une utilisation suppl\xE9mentaire." + }, + enableChrome: { + name: "Activer l'extension Chrome", + desc: "Permettre \xE0 Claude d'interagir avec Chrome via l'extension claude-in-chrome. L'extension doit \xEAtre install\xE9e. N\xE9cessite un red\xE9marrage de session." + }, + enableBangBash: { + name: "Activer le mode bash (!)", + desc: "Saisissez ! dans un champ vide pour passer en mode bash. Ex\xE9cute les commandes directement via le child_process de Node.js. N\xE9cessite de rouvrir la vue.", + validation: { + noNode: "Node.js introuvable dans PATH. Installez Node.js ou v\xE9rifiez votre configuration PATH." + } + }, + maxTabs: { + name: "Maximum d'onglets de chat", + desc: "Nombre maximum d'onglets de chat simultan\xE9s (3-10). Chaque onglet utilise une session Claude s\xE9par\xE9e.", + warning: "Plus de 5 onglets peut affecter les performances et l'utilisation de la m\xE9moire." + }, + tabBarPosition: { + name: "Position de la barre d'onglets", + desc: "Choisissez o\xF9 afficher les badges d'onglets et les boutons d'action", + input: "Au-dessus de la saisie (par d\xE9faut)", + header: "Dans l'en-t\xEAte" + }, + enableAutoScroll: { + name: "D\xE9filement automatique pendant le streaming", + desc: "D\xE9filer automatiquement vers le bas pendant que Claude diffuse les r\xE9ponses. D\xE9sactiver pour rester en haut et lire depuis le d\xE9but." + }, + openInMainTab: { + name: "Ouvrir dans la zone d'\xE9diteur principale", + desc: "Ouvrir le panneau de chat comme un onglet principal dans la zone d'\xE9diteur centrale au lieu de la barre lat\xE9rale droite" + }, + cliPath: { + name: "Chemin CLI Claude", + desc: "Chemin personnalis\xE9 vers Claude Code CLI. Laisser vide pour la d\xE9tection automatique.", + descWindows: "Pour l'installateur natif, utilisez claude.exe. Pour les installations npm/pnpm/yarn ou autres gestionnaires de paquets, utilisez le chemin cli.js (pas claude.cmd).", + descUnix: 'Collez la sortie de "which claude" \u2014 fonctionne pour les installations natives et npm/pnpm/yarn.', + validation: { + notExist: "Le chemin n'existe pas", + isDirectory: "Le chemin est un r\xE9pertoire, pas un fichier" + } + }, + language: { + name: "Langue", + desc: "Changer la langue d'affichage de l'interface du plugin" + } +}; +var fr_default = { + common: common4, + chat: chat4, + settings: settings4 +}; + +// src/i18n/locales/ja.json +var ja_exports = {}; +__export(ja_exports, { + chat: () => chat5, + common: () => common5, + default: () => ja_default, + settings: () => settings5 +}); +var common5 = { + save: "\u4FDD\u5B58", + cancel: "\u30AD\u30E3\u30F3\u30BB\u30EB", + delete: "\u524A\u9664", + edit: "\u7DE8\u96C6", + add: "\u8FFD\u52A0", + remove: "\u524A\u9664", + clear: "\u30AF\u30EA\u30A2", + clearAll: "\u3059\u3079\u3066\u30AF\u30EA\u30A2", + loading: "\u8AAD\u307F\u8FBC\u307F\u4E2D", + error: "\u30A8\u30E9\u30FC", + success: "\u6210\u529F", + warning: "\u8B66\u544A", + confirm: "\u78BA\u8A8D", + settings: "\u8A2D\u5B9A", + advanced: "\u8A73\u7D30", + enabled: "\u6709\u52B9", + disabled: "\u7121\u52B9", + platform: "\u30D7\u30E9\u30C3\u30C8\u30D5\u30A9\u30FC\u30E0", + refresh: "\u66F4\u65B0", + rewind: "\u5DFB\u304D\u623B\u3057" +}; +var chat5 = { + rewind: { + confirmMessage: "\u3053\u306E\u6642\u70B9\u306B\u5DFB\u304D\u623B\u3057\u307E\u3059\u304B\uFF1F\u3053\u306E\u30E1\u30C3\u30BB\u30FC\u30B8\u4EE5\u964D\u306E\u30D5\u30A1\u30A4\u30EB\u5909\u66F4\u304C\u5143\u306B\u623B\u3055\u308C\u307E\u3059\u3002\u624B\u52D5\u307E\u305F\u306Fbash\u3067\u7DE8\u96C6\u3055\u308C\u305F\u30D5\u30A1\u30A4\u30EB\u306B\u306F\u5F71\u97FF\u3057\u307E\u305B\u3093\u3002", + confirmButton: "\u5DFB\u304D\u623B\u3059", + ariaLabel: "\u3053\u3053\u306B\u5DFB\u304D\u623B\u3059", + notice: "\u5DFB\u304D\u623B\u3057\u5B8C\u4E86\uFF1A{count} \u500B\u306E\u30D5\u30A1\u30A4\u30EB\u3092\u5FA9\u5143", + noticeSaveFailed: "\u5DFB\u304D\u623B\u3057\u5B8C\u4E86\uFF1A{count} \u500B\u306E\u30D5\u30A1\u30A4\u30EB\u3092\u5FA9\u5143\u3057\u307E\u3057\u305F\u304C\u3001\u72B6\u614B\u3092\u4FDD\u5B58\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F\uFF1A{error}", + failed: "\u5DFB\u304D\u623B\u3057\u306B\u5931\u6557\uFF1A{error}", + cannot: "\u5DFB\u304D\u623B\u3057\u3067\u304D\u307E\u305B\u3093\uFF1A{error}", + unavailableStreaming: "\u30B9\u30C8\u30EA\u30FC\u30DF\u30F3\u30B0\u4E2D\u306F\u5DFB\u304D\u623B\u3057\u3067\u304D\u307E\u305B\u3093", + unavailableNoUuid: "\u5DFB\u304D\u623B\u3057\u3067\u304D\u307E\u305B\u3093\uFF1A\u30E1\u30C3\u30BB\u30FC\u30B8\u8B58\u5225\u5B50\u304C\u3042\u308A\u307E\u305B\u3093" + }, + fork: { + ariaLabel: "\u4F1A\u8A71\u3092\u5206\u5C90", + chooseTarget: "\u4F1A\u8A71\u3092\u5206\u5C90", + targetNewTab: "\u65B0\u3057\u3044\u30BF\u30D6", + targetCurrentTab: "\u73FE\u5728\u306E\u30BF\u30D6", + maxTabsReached: "\u5206\u5C90\u3067\u304D\u307E\u305B\u3093\uFF1A\u6700\u5927 {count} \u30BF\u30D6\u306B\u9054\u3057\u307E\u3057\u305F", + notice: "\u65B0\u3057\u3044\u30BF\u30D6\u306B\u5206\u5C90\u3057\u307E\u3057\u305F", + noticeCurrentTab: "\u73FE\u5728\u306E\u30BF\u30D6\u3067\u5206\u5C90\u3057\u307E\u3057\u305F", + failed: "\u5206\u5C90\u306B\u5931\u6557\uFF1A{error}", + unavailableStreaming: "\u30B9\u30C8\u30EA\u30FC\u30DF\u30F3\u30B0\u4E2D\u306F\u5206\u5C90\u3067\u304D\u307E\u305B\u3093", + unavailableNoUuid: "\u5206\u5C90\u3067\u304D\u307E\u305B\u3093\uFF1A\u30E1\u30C3\u30BB\u30FC\u30B8\u8B58\u5225\u5B50\u304C\u3042\u308A\u307E\u305B\u3093", + unavailableNoResponse: "\u5206\u5C90\u3067\u304D\u307E\u305B\u3093\uFF1A\u5206\u5C90\u5143\u306E\u5FDC\u7B54\u304C\u3042\u308A\u307E\u305B\u3093", + errorMessageNotFound: "\u30E1\u30C3\u30BB\u30FC\u30B8\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093", + errorNoSession: "\u30BB\u30C3\u30B7\u30E7\u30F3 ID \u304C\u3042\u308A\u307E\u305B\u3093", + errorNoActiveTab: "\u30A2\u30AF\u30C6\u30A3\u30D6\u306A\u30BF\u30D6\u304C\u3042\u308A\u307E\u305B\u3093", + commandNoMessages: "\u30D5\u30A9\u30FC\u30AF\u3067\u304D\u307E\u305B\u3093: \u4F1A\u8A71\u306B\u30E1\u30C3\u30BB\u30FC\u30B8\u304C\u3042\u308A\u307E\u305B\u3093", + commandNoAssistantUuid: "\u30D5\u30A9\u30FC\u30AF\u3067\u304D\u307E\u305B\u3093: \u8B58\u5225\u5B50\u4ED8\u304D\u306E\u30A2\u30B7\u30B9\u30BF\u30F3\u30C8\u5FDC\u7B54\u304C\u3042\u308A\u307E\u305B\u3093" + }, + bangBash: { + placeholder: "> bash \u30B3\u30DE\u30F3\u30C9\u3092\u5B9F\u884C...", + commandPanel: "\u30B3\u30DE\u30F3\u30C9\u30D1\u30CD\u30EB", + copyAriaLabel: "\u6700\u65B0\u306E\u30B3\u30DE\u30F3\u30C9\u51FA\u529B\u3092\u30B3\u30D4\u30FC", + clearAriaLabel: "bash \u51FA\u529B\u3092\u30AF\u30EA\u30A2", + commandLabel: "{command}", + statusLabel: "\u72B6\u614B: {status}", + collapseOutput: "\u30B3\u30DE\u30F3\u30C9\u51FA\u529B\u3092\u6298\u308A\u305F\u305F\u3080", + expandOutput: "\u30B3\u30DE\u30F3\u30C9\u51FA\u529B\u3092\u5C55\u958B", + running: "\u5B9F\u884C\u4E2D...", + copyFailed: "\u30AF\u30EA\u30C3\u30D7\u30DC\u30FC\u30C9\u3078\u306E\u30B3\u30D4\u30FC\u306B\u5931\u6557\u3057\u307E\u3057\u305F" + } +}; +var settings5 = { + title: "Claudian \u8A2D\u5B9A", + tabs: { + general: "\u4E00\u822C", + claude: "Claude", + codex: "Codex" + }, + display: "\u8868\u793A", + conversations: "\u4F1A\u8A71", + content: "\u30B3\u30F3\u30C6\u30F3\u30C4", + input: "\u5165\u529B", + setup: "\u30BB\u30C3\u30C8\u30A2\u30C3\u30D7", + models: "\u30E2\u30C7\u30EB", + experimental: "\u5B9F\u9A13\u7684\u6A5F\u80FD", + userName: { + name: "Claudian \u306F\u3069\u306E\u3088\u3046\u306B\u547C\u3073\u307E\u3059\u304B\uFF1F", + desc: "\u30D1\u30FC\u30BD\u30CA\u30E9\u30A4\u30BA\u3055\u308C\u305F\u6328\u62F6\u306B\u4F7F\u7528\u3059\u308B\u540D\u524D\uFF08\u7A7A\u6B04\u3067\u4E00\u822C\u306E\u6328\u62F6\uFF09" + }, + excludedTags: { + name: "\u9664\u5916\u30BF\u30B0", + desc: "\u3053\u308C\u3089\u306E\u30BF\u30B0\u3092\u542B\u3080\u30CE\u30FC\u30C8\u306F\u81EA\u52D5\u7684\u306B\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u3068\u3057\u3066\u8AAD\u307F\u8FBC\u307E\u308C\u307E\u305B\u3093\uFF081\u884C\u306B1\u3064\u3001#\u306A\u3057\uFF09" + }, + mediaFolder: { + name: "\u30E1\u30C7\u30A3\u30A2\u30D5\u30A9\u30EB\u30C0", + desc: "\u6DFB\u4ED8\u30D5\u30A1\u30A4\u30EB/\u753B\u50CF\u3092\u683C\u7D0D\u3059\u308B\u30D5\u30A9\u30EB\u30C0\u3002\u30CE\u30FC\u30C8\u304C ![[image.jpg]] \u3092\u4F7F\u7528\u3059\u308B\u5834\u5408\u3001Claude \u306F\u3053\u3053\u3067\u63A2\u3057\u307E\u3059\u3002\u7A7A\u6B04\u3067\u30EA\u30DD\u30B8\u30C8\u30EA\u306E\u30EB\u30FC\u30C8\u3092\u4F7F\u7528\u3002" + }, + systemPrompt: { + name: "\u30AB\u30B9\u30BF\u30E0\u30B7\u30B9\u30C6\u30E0\u30D7\u30ED\u30F3\u30D7\u30C8", + desc: "\u30C7\u30D5\u30A9\u30EB\u30C8\u306E\u30B7\u30B9\u30C6\u30E0\u30D7\u30ED\u30F3\u30D7\u30C8\u306B\u8FFD\u52A0\u3055\u308C\u308B\u8FFD\u52A0\u6307\u793A" + }, + autoTitle: { + name: "\u4F1A\u8A71\u30BF\u30A4\u30C8\u30EB\u3092\u81EA\u52D5\u751F\u6210", + desc: "\u6700\u521D\u306E\u30E6\u30FC\u30B6\u30FC\u30E1\u30C3\u30BB\u30FC\u30B8\u9001\u4FE1\u5F8C\u306B\u4F1A\u8A71\u30BF\u30A4\u30C8\u30EB\u3092\u81EA\u52D5\u7684\u306B\u751F\u6210\u3057\u307E\u3059\u3002" + }, + titleModel: { + name: "\u30BF\u30A4\u30C8\u30EB\u751F\u6210\u30E2\u30C7\u30EB", + desc: "\u4F1A\u8A71\u30BF\u30A4\u30C8\u30EB\u3092\u81EA\u52D5\u751F\u6210\u3059\u308B\u305F\u3081\u306B\u4F7F\u7528\u3055\u308C\u308B\u30E2\u30C7\u30EB\u3002", + auto: "\u81EA\u52D5 (Haiku)" + }, + navMappings: { + name: "Vim\u30B9\u30BF\u30A4\u30EB\u30CA\u30D3\u30B2\u30FC\u30B7\u30E7\u30F3\u30DE\u30C3\u30D4\u30F3\u30B0", + desc: '1\u884C\u306B1\u3064\u306E\u30DE\u30C3\u30D4\u30F3\u30B0\u3002\u5F62\u5F0F\uFF1A"map <\u30AD\u30FC> <\u30A2\u30AF\u30B7\u30E7\u30F3>"\uFF08\u30A2\u30AF\u30B7\u30E7\u30F3\uFF1AscrollUp, scrollDown, focusInput\uFF09\u3002' + }, + hotkeys: "\u30DB\u30C3\u30C8\u30AD\u30FC", + inlineEditHotkey: { + name: "\u30A4\u30F3\u30E9\u30A4\u30F3\u7DE8\u96C6", + descWithKey: "\u73FE\u5728\u306E\u30DB\u30C3\u30C8\u30AD\u30FC: {hotkey}", + descNoKey: "\u30DB\u30C3\u30C8\u30AD\u30FC\u672A\u8A2D\u5B9A", + btnChange: "\u5909\u66F4", + btnSet: "\u8A2D\u5B9A" + }, + openChatHotkey: { + name: "\u30C1\u30E3\u30C3\u30C8\u3092\u958B\u304F", + descWithKey: "\u73FE\u5728\u306E\u30DB\u30C3\u30C8\u30AD\u30FC: {hotkey}", + descNoKey: "\u30DB\u30C3\u30C8\u30AD\u30FC\u672A\u8A2D\u5B9A", + btnChange: "\u5909\u66F4", + btnSet: "\u8A2D\u5B9A" + }, + newSessionHotkey: { + name: "\u65B0\u898F\u30BB\u30C3\u30B7\u30E7\u30F3", + descWithKey: "\u73FE\u5728\u306E\u30DB\u30C3\u30C8\u30AD\u30FC: {hotkey}", + descNoKey: "\u30DB\u30C3\u30C8\u30AD\u30FC\u672A\u8A2D\u5B9A", + btnChange: "\u5909\u66F4", + btnSet: "\u8A2D\u5B9A" + }, + newTabHotkey: { + name: "\u65B0\u898F\u30BF\u30D6", + descWithKey: "\u73FE\u5728\u306E\u30DB\u30C3\u30C8\u30AD\u30FC: {hotkey}", + descNoKey: "\u30DB\u30C3\u30C8\u30AD\u30FC\u672A\u8A2D\u5B9A", + btnChange: "\u5909\u66F4", + btnSet: "\u8A2D\u5B9A" + }, + closeTabHotkey: { + name: "\u30BF\u30D6\u3092\u9589\u3058\u308B", + descWithKey: "\u73FE\u5728\u306E\u30DB\u30C3\u30C8\u30AD\u30FC: {hotkey}", + descNoKey: "\u30DB\u30C3\u30C8\u30AD\u30FC\u672A\u8A2D\u5B9A", + btnChange: "\u5909\u66F4", + btnSet: "\u8A2D\u5B9A" + }, + slashCommands: { + name: "\u30B3\u30DE\u30F3\u30C9\u3068\u30B9\u30AD\u30EB", + desc: ".claude/commands/ \u3068 .claude/skills/ \u306B\u4FDD\u5B58\u3055\u308C\u305F Vault \u30EC\u30D9\u30EB\u306E\u30B3\u30DE\u30F3\u30C9\u3068\u30B9\u30AD\u30EB\u3092\u7BA1\u7406\u3057\u307E\u3059\u3002/\u540D\u524D \u3067\u30C8\u30EA\u30AC\u30FC\u3055\u308C\u307E\u3059\u3002" + }, + hiddenSlashCommands: { + name: "\u975E\u8868\u793A\u30B3\u30DE\u30F3\u30C9", + desc: "\u30C9\u30ED\u30C3\u30D7\u30C0\u30A6\u30F3\u304B\u3089\u7279\u5B9A\u306E\u30B9\u30E9\u30C3\u30B7\u30E5\u30B3\u30DE\u30F3\u30C9\u3092\u975E\u8868\u793A\u306B\u3057\u307E\u3059\u3002Claudian \u306B\u95A2\u4FC2\u306E\u306A\u3044 Claude Code \u30B3\u30DE\u30F3\u30C9\u3092\u975E\u8868\u793A\u306B\u3059\u308B\u306E\u306B\u4FBF\u5229\u3067\u3059\u3002\u5148\u982D\u306E\u30B9\u30E9\u30C3\u30B7\u30E5\u306A\u3057\u3067\u30B3\u30DE\u30F3\u30C9\u540D\u30921\u884C\u306B1\u3064\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044\u3002", + placeholder: "commit\nbuild\ntest" + }, + mcpServers: { + name: "MCP \u30B5\u30FC\u30D0\u30FC", + desc: ".claude/mcp.json \u306B\u4FDD\u5B58\u3055\u308C\u305F Vault \u30EC\u30D9\u30EB\u306E MCP \u30B5\u30FC\u30D0\u30FC\u8A2D\u5B9A\u3092\u7BA1\u7406\u3057\u307E\u3059\u3002\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u4FDD\u5B58\u30E2\u30FC\u30C9\u306E\u30B5\u30FC\u30D0\u30FC\u306F @mention \u3067\u30A2\u30AF\u30C6\u30A3\u30D6\u306B\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002" + }, + plugins: { + name: "Claude Code \u30D7\u30E9\u30B0\u30A4\u30F3", + desc: "~/.claude/plugins \u304B\u3089\u691C\u51FA\u3055\u308C\u305F Claude Code \u30D7\u30E9\u30B0\u30A4\u30F3\u3092\u7BA1\u7406\u3057\u307E\u3059\u3002\u6709\u52B9\u5316\u3055\u308C\u305F\u30D7\u30E9\u30B0\u30A4\u30F3\u306F Vault \u3054\u3068\u306B .claude/settings.json \u306B\u4FDD\u5B58\u3055\u308C\u307E\u3059\u3002" + }, + subagents: { + name: "\u30B5\u30D6\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8", + desc: ".claude/agents/ \u306B\u4FDD\u5B58\u3055\u308C\u305F Vault \u30EC\u30D9\u30EB\u306E\u30B5\u30D6\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u3092\u7BA1\u7406\u3057\u307E\u3059\u3002\u5404 Markdown \u30D5\u30A1\u30A4\u30EB\u304C\u30AB\u30B9\u30BF\u30E0\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u30921\u3064\u5B9A\u7FA9\u3057\u307E\u3059\u3002", + noAgents: "\u30B5\u30D6\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u304C\u8A2D\u5B9A\u3055\u308C\u3066\u3044\u307E\u305B\u3093\u3002+ \u3092\u30AF\u30EA\u30C3\u30AF\u3057\u3066\u4F5C\u6210\u3057\u3066\u304F\u3060\u3055\u3044\u3002", + deleteConfirm: "\u30B5\u30D6\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u300C{name}\u300D\u3092\u524A\u9664\u3057\u307E\u3059\u304B\uFF1F", + saveFailed: "\u30B5\u30D6\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u306E\u4FDD\u5B58\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {message}", + refreshFailed: "\u30B5\u30D6\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u3092\u66F4\u65B0\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F: {message}", + deleteFailed: "\u30B5\u30D6\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u306E\u524A\u9664\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {message}", + renameCleanupFailed: "\u8B66\u544A: \u300C{name}\u300D\u306E\u53E4\u3044\u30D5\u30A1\u30A4\u30EB\u3092\u524A\u9664\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F", + created: "\u30B5\u30D6\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u300C{name}\u300D\u3092\u4F5C\u6210\u3057\u307E\u3057\u305F", + updated: "\u30B5\u30D6\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u300C{name}\u300D\u3092\u66F4\u65B0\u3057\u307E\u3057\u305F", + deleted: "\u30B5\u30D6\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u300C{name}\u300D\u3092\u524A\u9664\u3057\u307E\u3057\u305F", + duplicateName: "\u300C{name}\u300D\u3068\u3044\u3046\u540D\u524D\u306E\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u306F\u65E2\u306B\u5B58\u5728\u3057\u307E\u3059", + descriptionRequired: "\u8AAC\u660E\u306F\u5FC5\u9808\u3067\u3059", + promptRequired: "\u30B7\u30B9\u30C6\u30E0\u30D7\u30ED\u30F3\u30D7\u30C8\u306F\u5FC5\u9808\u3067\u3059", + modal: { + titleEdit: "\u30B5\u30D6\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u3092\u7DE8\u96C6", + titleAdd: "\u30B5\u30D6\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u3092\u8FFD\u52A0", + name: "\u540D\u524D", + nameDesc: "\u5C0F\u6587\u5B57\u3001\u6570\u5B57\u3001\u30CF\u30A4\u30D5\u30F3\u306E\u307F\u4F7F\u7528\u3067\u304D\u307E\u3059", + namePlaceholder: "code-reviewer", + description: "\u8AAC\u660E", + descriptionDesc: "\u3053\u306E\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u306E\u7C21\u5358\u306A\u8AAC\u660E", + descriptionPlaceholder: "\u30B3\u30FC\u30C9\u306E\u30D0\u30B0\u3084\u30B9\u30BF\u30A4\u30EB\u3092\u30EC\u30D3\u30E5\u30FC\u3057\u307E\u3059", + advancedOptions: "\u8A73\u7D30\u30AA\u30D7\u30B7\u30E7\u30F3", + model: "\u30E2\u30C7\u30EB", + modelDesc: "\u3053\u306E\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u306E\u30E2\u30C7\u30EB\u4E0A\u66F8\u304D", + tools: "\u30C4\u30FC\u30EB", + toolsDesc: "\u8A31\u53EF\u3059\u308B\u30C4\u30FC\u30EB\u306E\u30AB\u30F3\u30DE\u533A\u5207\u308A\u30EA\u30B9\u30C8\uFF08\u7A7A\u6B04 = \u3059\u3079\u3066\uFF09", + disallowedTools: "\u7981\u6B62\u30C4\u30FC\u30EB", + disallowedToolsDesc: "\u7981\u6B62\u3059\u308B\u30C4\u30FC\u30EB\u306E\u30AB\u30F3\u30DE\u533A\u5207\u308A\u30EA\u30B9\u30C8", + skills: "\u30B9\u30AD\u30EB", + skillsDesc: "\u30B9\u30AD\u30EB\u306E\u30AB\u30F3\u30DE\u533A\u5207\u308A\u30EA\u30B9\u30C8", + prompt: "\u30B7\u30B9\u30C6\u30E0\u30D7\u30ED\u30F3\u30D7\u30C8", + promptDesc: "\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u3078\u306E\u6307\u793A", + promptPlaceholder: "\u3042\u306A\u305F\u306F\u30B3\u30FC\u30C9\u30EC\u30D3\u30E5\u30A2\u30FC\u3067\u3059\u3002\u4E0E\u3048\u3089\u308C\u305F\u30B3\u30FC\u30C9\u3092\u5206\u6790\u3057\u3066..." + } + }, + safety: "\u30BB\u30AD\u30E5\u30EA\u30C6\u30A3", + loadUserSettings: { + name: "\u30E6\u30FC\u30B6\u30FCClaude\u8A2D\u5B9A\u3092\u8AAD\u307F\u8FBC\u3080", + desc: "~/.claude/settings.json \u3092\u8AAD\u307F\u8FBC\u307F\u307E\u3059\u3002\u6709\u52B9\u306B\u3059\u308B\u3068\u3001\u30E6\u30FC\u30B6\u30FC\u306E Claude Code \u8A31\u53EF\u30EB\u30FC\u30EB\u304C\u30BB\u30AD\u30E5\u30EA\u30C6\u30A3\u30E2\u30FC\u30C9\u3092\u30D0\u30A4\u30D1\u30B9\u3059\u308B\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059\u3002" + }, + claudeSafeMode: { + name: "Safe mode", + desc: "Permission mode used when the Safe toggle is active." + }, + codexSafeMode: { + name: "Safe mode", + desc: "Sandbox mode used when the Safe toggle is active." + }, + environment: "\u74B0\u5883", + customVariables: { + name: "\u30AB\u30B9\u30BF\u30E0\u5909\u6570", + desc: "Claude SDK\u306E\u74B0\u5883\u5909\u6570\uFF08KEY=VALUE\u5F62\u5F0F\u30011\u884C\u306B1\u3064\uFF09\u3002export\u30D7\u30EC\u30D5\u30A3\u30C3\u30AF\u30B9\u5BFE\u5FDC\u3002" + }, + envSnippets: { + name: "\u30B9\u30CB\u30DA\u30C3\u30C8", + addBtn: "\u30B9\u30CB\u30DA\u30C3\u30C8\u3092\u8FFD\u52A0", + noSnippets: "\u4FDD\u5B58\u3055\u308C\u305F\u74B0\u5883\u5909\u6570\u30B9\u30CB\u30DA\u30C3\u30C8\u306F\u3042\u308A\u307E\u305B\u3093\u3002+\u3092\u30AF\u30EA\u30C3\u30AF\u3057\u3066\u73FE\u5728\u306E\u8A2D\u5B9A\u3092\u4FDD\u5B58\u3057\u3066\u304F\u3060\u3055\u3044\u3002", + nameRequired: "\u30B9\u30CB\u30DA\u30C3\u30C8\u306E\u540D\u524D\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044", + modal: { + titleEdit: "\u30B9\u30CB\u30DA\u30C3\u30C8\u3092\u7DE8\u96C6", + titleSave: "\u30B9\u30CB\u30DA\u30C3\u30C8\u3092\u4FDD\u5B58", + name: "\u540D\u524D", + namePlaceholder: "\u3053\u306E\u8A2D\u5B9A\u306E\u308F\u304B\u308A\u3084\u3059\u3044\u540D\u524D", + description: "\u8AAC\u660E", + descPlaceholder: "\u4EFB\u610F\u306E\u8AAC\u660E", + envVars: "\u74B0\u5883\u5909\u6570", + envVarsPlaceholder: "KEY=VALUE\u5F62\u5F0F\u30011\u884C\u306B1\u3064\uFF08export\u30D7\u30EC\u30D5\u30A3\u30C3\u30AF\u30B9\u5BFE\u5FDC\uFF09", + save: "\u4FDD\u5B58", + update: "\u66F4\u65B0", + cancel: "\u30AD\u30E3\u30F3\u30BB\u30EB" + } + }, + customContextLimits: { + name: "\u30AB\u30B9\u30BF\u30E0\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u5236\u9650", + desc: "\u30AB\u30B9\u30BF\u30E0\u30E2\u30C7\u30EB\u306E\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u30A6\u30A3\u30F3\u30C9\u30A6\u30B5\u30A4\u30BA\u3092\u8A2D\u5B9A\u3057\u307E\u3059\u3002\u30C7\u30D5\u30A9\u30EB\u30C8\uFF08200k\u30C8\u30FC\u30AF\u30F3\uFF09\u3092\u4F7F\u7528\u3059\u308B\u5834\u5408\u306F\u7A7A\u6B04\u306E\u307E\u307E\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002", + invalid: "\u7121\u52B9\u306A\u5F62\u5F0F\u3067\u3059\u3002\u4F7F\u7528\uFF1A256k\u30011m\u3001\u307E\u305F\u306F\u6B63\u78BA\u306A\u6570\u5024\uFF081000-10000000\uFF09\u3002" + }, + enableOpus1M: { + name: "Opus 1M\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u30A6\u30A3\u30F3\u30C9\u30A6", + desc: "\u30E2\u30C7\u30EB\u30BB\u30EC\u30AF\u30BF\u30FC\u306BOpus 1M\u3092\u8868\u793A\u3057\u307E\u3059\u3002Max\u3001Team\u3001Enterprise\u30D7\u30E9\u30F3\u306B\u542B\u307E\u308C\u307E\u3059\u3002API\u304A\u3088\u3073Pro\u30E6\u30FC\u30B6\u30FC\u306F\u8FFD\u52A0\u4F7F\u7528\u91CF\u304C\u5FC5\u8981\u3067\u3059\u3002" + }, + enableSonnet1M: { + name: "Sonnet 1M\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u30A6\u30A3\u30F3\u30C9\u30A6", + desc: "\u30E2\u30C7\u30EB\u30BB\u30EC\u30AF\u30BF\u30FC\u306BSonnet 1M\u3092\u8868\u793A\u3057\u307E\u3059\u3002Max\u3001Team\u3001Enterprise\u30D7\u30E9\u30F3\u3067\u306F\u8FFD\u52A0\u4F7F\u7528\u91CF\u304C\u5FC5\u8981\u3067\u3059\u3002API\u304A\u3088\u3073Pro\u30E6\u30FC\u30B6\u30FC\u306F\u8FFD\u52A0\u4F7F\u7528\u91CF\u304C\u5FC5\u8981\u3067\u3059\u3002" + }, + enableChrome: { + name: "Chrome\u62E1\u5F35\u6A5F\u80FD\u3092\u6709\u52B9\u5316", + desc: "claude-in-chrome\u62E1\u5F35\u6A5F\u80FD\u3092\u901A\u3058\u3066Claude\u304CChrome\u3068\u9023\u643A\u3067\u304D\u308B\u3088\u3046\u306B\u3057\u307E\u3059\u3002\u62E1\u5F35\u6A5F\u80FD\u306E\u30A4\u30F3\u30B9\u30C8\u30FC\u30EB\u304C\u5FC5\u8981\u3067\u3059\u3002\u30BB\u30C3\u30B7\u30E7\u30F3\u306E\u518D\u8D77\u52D5\u304C\u5FC5\u8981\u3067\u3059\u3002" + }, + enableBangBash: { + name: "bash \u30E2\u30FC\u30C9 (!) \u3092\u6709\u52B9\u5316", + desc: "\u5165\u529B\u6B04\u304C\u7A7A\u306E\u72B6\u614B\u3067 ! \u3092\u5165\u529B\u3059\u308B\u3068 bash \u30E2\u30FC\u30C9\u306B\u5165\u308A\u307E\u3059\u3002Node.js \u306E child_process \u7D4C\u7531\u3067\u30B3\u30DE\u30F3\u30C9\u3092\u76F4\u63A5\u5B9F\u884C\u3057\u307E\u3059\u3002\u30D3\u30E5\u30FC\u306E\u518D\u30AA\u30FC\u30D7\u30F3\u304C\u5FC5\u8981\u3067\u3059\u3002", + validation: { + noNode: "PATH \u306B Node.js \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002Node.js \u3092\u30A4\u30F3\u30B9\u30C8\u30FC\u30EB\u3059\u308B\u304B\u3001PATH \u8A2D\u5B9A\u3092\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\u3002" + } + }, + maxTabs: { + name: "\u6700\u5927\u30C1\u30E3\u30C3\u30C8\u30BF\u30D6\u6570", + desc: "\u540C\u6642\u306B\u958B\u3051\u308B\u6700\u5927\u30C1\u30E3\u30C3\u30C8\u30BF\u30D6\u6570\uFF083-10\uFF09\u3002\u5404\u30BF\u30D6\u306F\u500B\u5225\u306E Claude \u30BB\u30C3\u30B7\u30E7\u30F3\u3092\u4F7F\u7528\u3057\u307E\u3059\u3002", + warning: "5 \u30BF\u30D6\u3092\u8D85\u3048\u308B\u3068\u30D1\u30D5\u30A9\u30FC\u30DE\u30F3\u30B9\u3084\u30E1\u30E2\u30EA\u4F7F\u7528\u91CF\u306B\u5F71\u97FF\u3059\u308B\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059\u3002" + }, + tabBarPosition: { + name: "\u30BF\u30D6\u30D0\u30FC\u306E\u4F4D\u7F6E", + desc: "\u30BF\u30D6\u30D0\u30C3\u30B8\u3068\u30A2\u30AF\u30B7\u30E7\u30F3\u30DC\u30BF\u30F3\u306E\u8868\u793A\u4F4D\u7F6E\u3092\u9078\u629E", + input: "\u5165\u529B\u6B04\u306E\u4E0A\uFF08\u30C7\u30D5\u30A9\u30EB\u30C8\uFF09", + header: "\u30D8\u30C3\u30C0\u30FC\u5185" + }, + enableAutoScroll: { + name: "\u30B9\u30C8\u30EA\u30FC\u30DF\u30F3\u30B0\u4E2D\u306E\u81EA\u52D5\u30B9\u30AF\u30ED\u30FC\u30EB", + desc: "Claude\u304C\u5FDC\u7B54\u3092\u30B9\u30C8\u30EA\u30FC\u30DF\u30F3\u30B0\u3057\u3066\u3044\u308B\u9593\u3001\u81EA\u52D5\u7684\u306B\u4E0B\u306B\u30B9\u30AF\u30ED\u30FC\u30EB\u3057\u307E\u3059\u3002\u7121\u52B9\u306B\u3059\u308B\u3068\u4E0A\u90E8\u306B\u7559\u307E\u308A\u3001\u6700\u521D\u304B\u3089\u8AAD\u3080\u3053\u3068\u304C\u3067\u304D\u307E\u3059\u3002" + }, + openInMainTab: { + name: "\u30E1\u30A4\u30F3\u30A8\u30C7\u30A3\u30BF\u9818\u57DF\u3067\u958B\u304F", + desc: "\u30C1\u30E3\u30C3\u30C8\u30D1\u30CD\u30EB\u3092\u53F3\u30B5\u30A4\u30C9\u30D0\u30FC\u3067\u306F\u306A\u304F\u3001\u4E2D\u592E\u30A8\u30C7\u30A3\u30BF\u9818\u57DF\u306E\u30E1\u30A4\u30F3\u30BF\u30D6\u3068\u3057\u3066\u958B\u304D\u307E\u3059" + }, + cliPath: { + name: "Claude CLI \u30D1\u30B9", + desc: "Claude Code CLI \u306E\u30AB\u30B9\u30BF\u30E0\u30D1\u30B9\u3002\u7A7A\u6B04\u3067\u81EA\u52D5\u691C\u51FA\u3092\u4F7F\u7528\u3002", + descWindows: "\u30CD\u30A4\u30C6\u30A3\u30D6\u30A4\u30F3\u30B9\u30C8\u30FC\u30E9\u30FC\u306E\u5834\u5408\u306F claude.exe \u3092\u4F7F\u7528\u3002npm/pnpm/yarn \u3084\u305D\u306E\u4ED6\u306E\u30D1\u30C3\u30B1\u30FC\u30B8\u30DE\u30CD\u30FC\u30B8\u30E3\u30FC\u3067\u306E\u30A4\u30F3\u30B9\u30C8\u30FC\u30EB\u306E\u5834\u5408\u306F cli.js \u30D1\u30B9\u3092\u4F7F\u7528\uFF08claude.cmd \u3067\u306F\u306A\u3044\uFF09\u3002", + descUnix: '"which claude" \u306E\u51FA\u529B\u3092\u8CBC\u308A\u4ED8\u3051\u3066\u304F\u3060\u3055\u3044 - \u30CD\u30A4\u30C6\u30A3\u30D6\u3068 npm/pnpm/yarn \u30A4\u30F3\u30B9\u30C8\u30FC\u30EB\u306E\u4E21\u65B9\u3067\u52D5\u4F5C\u3057\u307E\u3059\u3002', + validation: { + notExist: "\u30D1\u30B9\u304C\u5B58\u5728\u3057\u307E\u305B\u3093", + isDirectory: "\u30D1\u30B9\u306F\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u3067\u30D5\u30A1\u30A4\u30EB\u3067\u306F\u3042\u308A\u307E\u305B\u3093" + } + }, + language: { + name: "\u8A00\u8A9E", + desc: "\u30D7\u30E9\u30B0\u30A4\u30F3\u30A4\u30F3\u30BF\u30FC\u30D5\u30A7\u30FC\u30B9\u306E\u8868\u793A\u8A00\u8A9E\u3092\u5909\u66F4" + } +}; +var ja_default = { + common: common5, + chat: chat5, + settings: settings5 +}; + +// src/i18n/locales/ko.json +var ko_exports = {}; +__export(ko_exports, { + chat: () => chat6, + common: () => common6, + default: () => ko_default, + settings: () => settings6 +}); +var common6 = { + save: "\uC800\uC7A5", + cancel: "\uCDE8\uC18C", + delete: "\uC0AD\uC81C", + edit: "\uD3B8\uC9D1", + add: "\uCD94\uAC00", + remove: "\uC81C\uAC70", + clear: "\uC9C0\uC6B0\uAE30", + clearAll: "\uBAA8\uB450 \uC9C0\uC6B0\uAE30", + loading: "\uB85C\uB529 \uC911", + error: "\uC624\uB958", + success: "\uC131\uACF5", + warning: "\uACBD\uACE0", + confirm: "\uD655\uC778", + settings: "\uC124\uC815", + advanced: "\uACE0\uAE09", + enabled: "\uD65C\uC131\uD654", + disabled: "\uBE44\uD65C\uC131\uD654", + platform: "\uD50C\uB7AB\uD3FC", + refresh: "\uC0C8\uB85C\uACE0\uCE68", + rewind: "\uB418\uAC10\uAE30" +}; +var chat6 = { + rewind: { + confirmMessage: "\uC774 \uC2DC\uC810\uC73C\uB85C \uB418\uAC10\uC73C\uC2DC\uACA0\uC2B5\uB2C8\uAE4C? \uC774 \uBA54\uC2DC\uC9C0 \uC774\uD6C4\uC758 \uD30C\uC77C \uBCC0\uACBD \uC0AC\uD56D\uC774 \uB418\uB3CC\uB824\uC9D1\uB2C8\uB2E4. \uC218\uB3D9\uC73C\uB85C \uB610\uB294 bash\uB97C \uD1B5\uD574 \uD3B8\uC9D1\uB41C \uD30C\uC77C\uC5D0\uB294 \uC601\uD5A5\uC744 \uBBF8\uCE58\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.", + confirmButton: "\uB418\uAC10\uAE30", + ariaLabel: "\uC5EC\uAE30\uB85C \uB418\uAC10\uAE30", + notice: "\uB418\uAC10\uAE30 \uC644\uB8CC: {count}\uAC1C \uD30C\uC77C \uBCF5\uC6D0\uB428", + noticeSaveFailed: "\uB418\uAC10\uAE30 \uC644\uB8CC: {count}\uAC1C \uD30C\uC77C \uBCF5\uC6D0\uB428, \uD558\uC9C0\uB9CC \uC0C1\uD0DC\uB97C \uC800\uC7A5\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4: {error}", + failed: "\uB418\uAC10\uAE30 \uC2E4\uD328: {error}", + cannot: "\uB418\uAC10\uAE30 \uBD88\uAC00: {error}", + unavailableStreaming: "\uC2A4\uD2B8\uB9AC\uBC0D \uC911\uC5D0\uB294 \uB418\uAC10\uAE30\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4", + unavailableNoUuid: "\uB418\uAC10\uAE30 \uBD88\uAC00: \uBA54\uC2DC\uC9C0 \uC2DD\uBCC4\uC790 \uB204\uB77D" + }, + fork: { + ariaLabel: "\uB300\uD654 \uBD84\uAE30", + chooseTarget: "\uB300\uD654 \uBD84\uAE30", + targetNewTab: "\uC0C8 \uD0ED", + targetCurrentTab: "\uD604\uC7AC \uD0ED", + maxTabsReached: "\uBD84\uAE30 \uBD88\uAC00: \uCD5C\uB300 {count}\uAC1C \uD0ED\uC5D0 \uB3C4\uB2EC\uD588\uC2B5\uB2C8\uB2E4", + notice: "\uC0C8 \uD0ED\uC73C\uB85C \uBD84\uAE30\uB428", + noticeCurrentTab: "\uD604\uC7AC \uD0ED\uC5D0\uC11C \uBD84\uAE30\uB428", + failed: "\uBD84\uAE30 \uC2E4\uD328: {error}", + unavailableStreaming: "\uC2A4\uD2B8\uB9AC\uBC0D \uC911\uC5D0\uB294 \uBD84\uAE30\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4", + unavailableNoUuid: "\uBD84\uAE30 \uBD88\uAC00: \uBA54\uC2DC\uC9C0 \uC2DD\uBCC4\uC790 \uB204\uB77D", + unavailableNoResponse: "\uBD84\uAE30 \uBD88\uAC00: \uBD84\uAE30\uD560 \uC751\uB2F5\uC774 \uC5C6\uC2B5\uB2C8\uB2E4", + errorMessageNotFound: "\uBA54\uC2DC\uC9C0\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4", + errorNoSession: "\uC0AC\uC6A9 \uAC00\uB2A5\uD55C \uC138\uC158 ID\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4", + errorNoActiveTab: "\uD65C\uC131 \uD0ED\uC774 \uC5C6\uC2B5\uB2C8\uB2E4", + commandNoMessages: "\uD3EC\uD06C\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: \uB300\uD654\uC5D0 \uBA54\uC2DC\uC9C0\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4", + commandNoAssistantUuid: "\uD3EC\uD06C\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: \uC2DD\uBCC4\uC790\uAC00 \uC788\uB294 \uC5B4\uC2DC\uC2A4\uD134\uD2B8 \uC751\uB2F5\uC774 \uC5C6\uC2B5\uB2C8\uB2E4" + }, + bangBash: { + placeholder: "> bash \uBA85\uB839 \uC2E4\uD589...", + commandPanel: "\uBA85\uB839 \uD328\uB110", + copyAriaLabel: "\uCD5C\uC2E0 \uBA85\uB839 \uCD9C\uB825\uC744 \uBCF5\uC0AC", + clearAriaLabel: "bash \uCD9C\uB825 \uC9C0\uC6B0\uAE30", + commandLabel: "{command}", + statusLabel: "\uC0C1\uD0DC: {status}", + collapseOutput: "\uBA85\uB839 \uCD9C\uB825 \uC811\uAE30", + expandOutput: "\uBA85\uB839 \uCD9C\uB825 \uD3BC\uCE58\uAE30", + running: "\uC2E4\uD589 \uC911...", + copyFailed: "\uD074\uB9BD\uBCF4\uB4DC\uC5D0 \uBCF5\uC0AC\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4" + } +}; +var settings6 = { + title: "Claudian \uC124\uC815", + tabs: { + general: "\uC77C\uBC18", + claude: "Claude", + codex: "Codex" + }, + display: "\uD45C\uC2DC", + conversations: "\uB300\uD654", + content: "\uCF58\uD150\uCE20", + input: "\uC785\uB825", + setup: "\uC124\uC815", + models: "\uBAA8\uB378", + experimental: "\uC2E4\uD5D8\uC801 \uAE30\uB2A5", + userName: { + name: "Claudian\uC774 \uB2F9\uC2E0\uC744 \uC5B4\uB5BB\uAC8C \uBD88\uB7EC\uC57C \uD569\uB2C8\uAE4C?", + desc: "\uAC1C\uC778\uD654\uB41C \uC778\uC0AC\uC5D0 \uC0AC\uC6A9\uD560 \uC774\uB984 (\uBE44\uC6CC\uB450\uBA74 \uC77C\uBC18 \uC778\uC0AC)" + }, + excludedTags: { + name: "\uC81C\uC678 \uD0DC\uADF8", + desc: "\uC774 \uD0DC\uADF8\uAC00 \uD3EC\uD568\uB41C \uB178\uD2B8\uB294 \uC790\uB3D9\uC73C\uB85C \uCEE8\uD14D\uC2A4\uD2B8\uB85C \uB85C\uB4DC\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4 (\uD55C \uC904\uC5D0 \uD558\uB098, # \uC81C\uC678)" + }, + mediaFolder: { + name: "\uBBF8\uB514\uC5B4 \uD3F4\uB354", + desc: "\uCCA8\uBD80 \uD30C\uC77C/\uC774\uBBF8\uC9C0\uB97C \uC800\uC7A5\uD560 \uD3F4\uB354. \uB178\uD2B8\uAC00 ![[image.jpg]]\uB97C \uC0AC\uC6A9\uD560 \uB54C Claude\uAC00 \uC5EC\uAE30\uC11C \uCC3E\uC2B5\uB2C8\uB2E4. \uBE44\uC6CC\uB450\uBA74 \uC800\uC7A5\uC18C \uB8E8\uD2B8 \uC0AC\uC6A9." + }, + systemPrompt: { + name: "\uCEE4\uC2A4\uD140 \uC2DC\uC2A4\uD15C \uD504\uB86C\uD504\uD2B8", + desc: "\uAE30\uBCF8 \uC2DC\uC2A4\uD15C \uD504\uB86C\uD504\uD2B8\uC5D0 \uCD94\uAC00\uB418\uB294 \uCD94\uAC00 \uC9C0\uCE68" + }, + autoTitle: { + name: "\uB300\uD654 \uC81C\uBAA9 \uC790\uB3D9 \uC0DD\uC131", + desc: "\uCCAB \uBC88\uC9F8 \uC0AC\uC6A9\uC790 \uBA54\uC2DC\uC9C0 \uC804\uC1A1 \uD6C4 \uC790\uB3D9\uC73C\uB85C \uB300\uD654 \uC81C\uBAA9\uC744 \uC0DD\uC131\uD569\uB2C8\uB2E4." + }, + titleModel: { + name: "\uC81C\uBAA9 \uC0DD\uC131 \uBAA8\uB378", + desc: "\uB300\uD654 \uC81C\uBAA9\uC744 \uC790\uB3D9 \uC0DD\uC131\uD558\uB294 \uB370 \uC0AC\uC6A9\uB418\uB294 \uBAA8\uB378.", + auto: "\uC790\uB3D9 (Haiku)" + }, + navMappings: { + name: "Vim \uC2A4\uD0C0\uC77C \uB124\uBE44\uAC8C\uC774\uC158 \uB9E4\uD551", + desc: '\uD55C \uC904\uC5D0 \uD558\uB098\uC758 \uB9E4\uD551. \uD615\uC2DD: "map <\uD0A4> <\uB3D9\uC791>" (\uB3D9\uC791: scrollUp, scrollDown, focusInput).' + }, + hotkeys: "\uB2E8\uCD95\uD0A4", + inlineEditHotkey: { + name: "\uC778\uB77C\uC778 \uD3B8\uC9D1", + descWithKey: "\uD604\uC7AC \uB2E8\uCD95\uD0A4: {hotkey}", + descNoKey: "\uB2E8\uCD95\uD0A4 \uBBF8\uC124\uC815", + btnChange: "\uBCC0\uACBD", + btnSet: "\uB2E8\uCD95\uD0A4 \uC124\uC815" + }, + openChatHotkey: { + name: "\uCC44\uD305 \uC5F4\uAE30", + descWithKey: "\uD604\uC7AC \uB2E8\uCD95\uD0A4: {hotkey}", + descNoKey: "\uB2E8\uCD95\uD0A4 \uBBF8\uC124\uC815", + btnChange: "\uBCC0\uACBD", + btnSet: "\uB2E8\uCD95\uD0A4 \uC124\uC815" + }, + newSessionHotkey: { + name: "\uC0C8 \uC138\uC158", + descWithKey: "\uD604\uC7AC \uB2E8\uCD95\uD0A4: {hotkey}", + descNoKey: "\uB2E8\uCD95\uD0A4 \uBBF8\uC124\uC815", + btnChange: "\uBCC0\uACBD", + btnSet: "\uB2E8\uCD95\uD0A4 \uC124\uC815" + }, + newTabHotkey: { + name: "\uC0C8 \uD0ED", + descWithKey: "\uD604\uC7AC \uB2E8\uCD95\uD0A4: {hotkey}", + descNoKey: "\uB2E8\uCD95\uD0A4 \uBBF8\uC124\uC815", + btnChange: "\uBCC0\uACBD", + btnSet: "\uB2E8\uCD95\uD0A4 \uC124\uC815" + }, + closeTabHotkey: { + name: "\uD0ED \uB2EB\uAE30", + descWithKey: "\uD604\uC7AC \uB2E8\uCD95\uD0A4: {hotkey}", + descNoKey: "\uB2E8\uCD95\uD0A4 \uBBF8\uC124\uC815", + btnChange: "\uBCC0\uACBD", + btnSet: "\uB2E8\uCD95\uD0A4 \uC124\uC815" + }, + slashCommands: { + name: "\uBA85\uB839\uC5B4\uC640 \uC2A4\uD0AC", + desc: ".claude/commands/ \uBC0F .claude/skills/\uC5D0 \uC800\uC7A5\uB41C Vault \uC218\uC900\uC758 \uBA85\uB839\uC5B4\uC640 \uC2A4\uD0AC\uC744 \uAD00\uB9AC\uD569\uB2C8\uB2E4. /\uC774\uB984\uC73C\uB85C \uD2B8\uB9AC\uAC70\uB429\uB2C8\uB2E4." + }, + hiddenSlashCommands: { + name: "\uC228\uACA8\uC9C4 \uBA85\uB839\uC5B4", + desc: "\uB4DC\uB86D\uB2E4\uC6B4\uC5D0\uC11C \uD2B9\uC815 \uC2AC\uB798\uC2DC \uBA85\uB839\uC5B4\uB97C \uC228\uAE41\uB2C8\uB2E4. Claudian\uACFC \uAD00\uB828 \uC5C6\uB294 Claude Code \uBA85\uB839\uC5B4\uB97C \uC228\uAE30\uB294 \uB370 \uC720\uC6A9\uD569\uB2C8\uB2E4. \uC55E\uC758 \uC2AC\uB798\uC2DC \uC5C6\uC774 \uD55C \uC904\uC5D0 \uD558\uB098\uC529 \uBA85\uB839\uC5B4 \uC774\uB984\uC744 \uC785\uB825\uD558\uC138\uC694.", + placeholder: "commit\nbuild\ntest" + }, + mcpServers: { + name: "MCP \uC11C\uBC84", + desc: ".claude/mcp.json\uC5D0 \uC800\uC7A5\uB41C Vault \uC218\uC900\uC758 MCP \uC11C\uBC84 \uAD6C\uC131\uC744 \uAD00\uB9AC\uD569\uB2C8\uB2E4. \uCEE8\uD14D\uC2A4\uD2B8 \uC800\uC7A5 \uBAA8\uB4DC \uC11C\uBC84\uB294 @mention\uC73C\uB85C \uD65C\uC131\uD654\uD574\uC57C \uD569\uB2C8\uB2E4." + }, + plugins: { + name: "Claude Code \uD50C\uB7EC\uADF8\uC778", + desc: "~/.claude/plugins\uC5D0\uC11C \uBC1C\uACAC\uB41C Claude Code \uD50C\uB7EC\uADF8\uC778\uC744 \uAD00\uB9AC\uD569\uB2C8\uB2E4. \uD65C\uC131\uD654\uB41C \uD50C\uB7EC\uADF8\uC778\uC740 .claude/settings.json\uC5D0 Vault\uBCC4\uB85C \uC800\uC7A5\uB429\uB2C8\uB2E4." + }, + subagents: { + name: "\uC11C\uBE0C\uC5D0\uC774\uC804\uD2B8", + desc: ".claude/agents/\uC5D0 \uC800\uC7A5\uB41C Vault \uC218\uC900\uC758 \uC11C\uBE0C\uC5D0\uC774\uC804\uD2B8\uB97C \uAD00\uB9AC\uD569\uB2C8\uB2E4. \uAC01 Markdown \uD30C\uC77C\uC774 \uD558\uB098\uC758 \uCEE4\uC2A4\uD140 \uC5D0\uC774\uC804\uD2B8\uB97C \uC815\uC758\uD569\uB2C8\uB2E4.", + noAgents: "\uAD6C\uC131\uB41C \uC11C\uBE0C\uC5D0\uC774\uC804\uD2B8\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4. +\uB97C \uD074\uB9AD\uD574 \uC0C8\uB85C \uB9CC\uB4DC\uC138\uC694.", + deleteConfirm: '\uC11C\uBE0C\uC5D0\uC774\uC804\uD2B8 "{name}"\uC744 \uC0AD\uC81C\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?', + saveFailed: "\uC11C\uBE0C\uC5D0\uC774\uC804\uD2B8\uB97C \uC800\uC7A5\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4: {message}", + refreshFailed: "\uC11C\uBE0C\uC5D0\uC774\uC804\uD2B8\uB97C \uC0C8\uB85C\uACE0\uCE68\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4: {message}", + deleteFailed: "\uC11C\uBE0C\uC5D0\uC774\uC804\uD2B8\uB97C \uC0AD\uC81C\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4: {message}", + renameCleanupFailed: '\uACBD\uACE0: "{name}"\uC758 \uC774\uC804 \uD30C\uC77C\uC744 \uC81C\uAC70\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4', + created: '\uC11C\uBE0C\uC5D0\uC774\uC804\uD2B8 "{name}"\uB97C \uC0DD\uC131\uD588\uC2B5\uB2C8\uB2E4', + updated: '\uC11C\uBE0C\uC5D0\uC774\uC804\uD2B8 "{name}"\uB97C \uC5C5\uB370\uC774\uD2B8\uD588\uC2B5\uB2C8\uB2E4', + deleted: '\uC11C\uBE0C\uC5D0\uC774\uC804\uD2B8 "{name}"\uB97C \uC0AD\uC81C\uD588\uC2B5\uB2C8\uB2E4', + duplicateName: '"{name}"\uC774\uB77C\uB294 \uC774\uB984\uC758 \uC5D0\uC774\uC804\uD2B8\uAC00 \uC774\uBBF8 \uC788\uC2B5\uB2C8\uB2E4', + descriptionRequired: "\uC124\uBA85\uC740 \uD544\uC218\uC785\uB2C8\uB2E4", + promptRequired: "\uC2DC\uC2A4\uD15C \uD504\uB86C\uD504\uD2B8\uB294 \uD544\uC218\uC785\uB2C8\uB2E4", + modal: { + titleEdit: "\uC11C\uBE0C\uC5D0\uC774\uC804\uD2B8 \uD3B8\uC9D1", + titleAdd: "\uC11C\uBE0C\uC5D0\uC774\uC804\uD2B8 \uCD94\uAC00", + name: "\uC774\uB984", + nameDesc: "\uC18C\uBB38\uC790, \uC22B\uC790, \uD558\uC774\uD508\uB9CC \uC0AC\uC6A9\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4", + namePlaceholder: "code-reviewer", + description: "\uC124\uBA85", + descriptionDesc: "\uC774 \uC5D0\uC774\uC804\uD2B8\uC5D0 \uB300\uD55C \uAC04\uB2E8\uD55C \uC124\uBA85", + descriptionPlaceholder: "\uCF54\uB4DC\uC758 \uBC84\uADF8\uC640 \uC2A4\uD0C0\uC77C\uC744 \uAC80\uD1A0\uD569\uB2C8\uB2E4", + advancedOptions: "\uACE0\uAE09 \uC635\uC158", + model: "\uBAA8\uB378", + modelDesc: "\uC774 \uC5D0\uC774\uC804\uD2B8\uC5D0 \uC0AC\uC6A9\uD560 \uBAA8\uB378 \uC7AC\uC815\uC758", + tools: "\uB3C4\uAD6C", + toolsDesc: "\uD5C8\uC6A9\uD560 \uB3C4\uAD6C\uB97C \uC27C\uD45C\uB85C \uAD6C\uBD84\uD574 \uC785\uB825\uD558\uC138\uC694 (\uBE44\uC6CC\uB450\uBA74 \uBAA8\uB450 \uD5C8\uC6A9)", + disallowedTools: "\uAE08\uC9C0 \uB3C4\uAD6C", + disallowedToolsDesc: "\uAE08\uC9C0\uD560 \uB3C4\uAD6C\uB97C \uC27C\uD45C\uB85C \uAD6C\uBD84\uD574 \uC785\uB825\uD558\uC138\uC694", + skills: "\uC2A4\uD0AC", + skillsDesc: "\uC2A4\uD0AC \uBAA9\uB85D\uC744 \uC27C\uD45C\uB85C \uAD6C\uBD84\uD574 \uC785\uB825\uD558\uC138\uC694", + prompt: "\uC2DC\uC2A4\uD15C \uD504\uB86C\uD504\uD2B8", + promptDesc: "\uC5D0\uC774\uC804\uD2B8\uC6A9 \uC9C0\uCE68", + promptPlaceholder: "\uB2F9\uC2E0\uC740 \uCF54\uB4DC \uB9AC\uBDF0\uC5B4\uC785\uB2C8\uB2E4. \uC8FC\uC5B4\uC9C4 \uCF54\uB4DC\uB97C \uBD84\uC11D\uD558\uC5EC..." + } + }, + safety: "\uBCF4\uC548", + loadUserSettings: { + name: "\uC0AC\uC6A9\uC790 Claude \uC124\uC815 \uB85C\uB4DC", + desc: "~/.claude/settings.json\uC744 \uB85C\uB4DC\uD569\uB2C8\uB2E4. \uD65C\uC131\uD654\uD558\uBA74 \uC0AC\uC6A9\uC790\uC758 Claude Code \uD5C8\uC6A9 \uADDC\uCE59\uC774 \uBCF4\uC548 \uBAA8\uB4DC\uB97C \uC6B0\uD68C\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4." + }, + claudeSafeMode: { + name: "Safe mode", + desc: "Permission mode used when the Safe toggle is active." + }, + codexSafeMode: { + name: "Safe mode", + desc: "Sandbox mode used when the Safe toggle is active." + }, + environment: "\uD658\uACBD", + customVariables: { + name: "\uCEE4\uC2A4\uD140 \uBCC0\uC218", + desc: "Claude SDK \uD658\uACBD \uBCC0\uC218 (KEY=VALUE \uD615\uC2DD, \uD55C \uC904\uC5D0 \uD558\uB098). export \uC811\uB450\uC0AC \uC9C0\uC6D0." + }, + envSnippets: { + name: "\uC2A4\uB2C8\uD3AB", + addBtn: "\uC2A4\uB2C8\uD3AB \uCD94\uAC00", + noSnippets: "\uC800\uC7A5\uB41C \uD658\uACBD \uBCC0\uC218 \uC2A4\uB2C8\uD3AB\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. +\uB97C \uD074\uB9AD\uD558\uC5EC \uD604\uC7AC \uAD6C\uC131\uC744 \uC800\uC7A5\uD558\uC138\uC694.", + nameRequired: "\uC2A4\uB2C8\uD3AB \uC774\uB984\uC744 \uC785\uB825\uD558\uC138\uC694", + modal: { + titleEdit: "\uC2A4\uB2C8\uD3AB \uD3B8\uC9D1", + titleSave: "\uC2A4\uB2C8\uD3AB \uC800\uC7A5", + name: "\uC774\uB984", + namePlaceholder: "\uC774 \uAD6C\uC131\uC5D0 \uB300\uD55C \uC124\uBA85\uC801\uC778 \uC774\uB984", + description: "\uC124\uBA85", + descPlaceholder: "\uC120\uD0DD\uC801 \uC124\uBA85", + envVars: "\uD658\uACBD \uBCC0\uC218", + envVarsPlaceholder: "KEY=VALUE \uD615\uC2DD, \uD55C \uC904\uC5D0 \uD558\uB098 (export \uC811\uB450\uC0AC \uC9C0\uC6D0)", + save: "\uC800\uC7A5", + update: "\uC5C5\uB370\uC774\uD2B8", + cancel: "\uCDE8\uC18C" + } + }, + customContextLimits: { + name: "\uC0AC\uC6A9\uC790 \uC815\uC758 \uCEE8\uD14D\uC2A4\uD2B8 \uC81C\uD55C", + desc: "\uC0AC\uC6A9\uC790 \uC815\uC758 \uBAA8\uB378\uC758 \uCEE8\uD14D\uC2A4\uD2B8 \uCC3D \uD06C\uAE30\uB97C \uC124\uC815\uD569\uB2C8\uB2E4. \uAE30\uBCF8\uAC12(200k \uD1A0\uD070)\uC744 \uC0AC\uC6A9\uD558\uB824\uBA74 \uBE44\uC6CC\uB450\uC138\uC694.", + invalid: "\uC798\uBABB\uB41C \uD615\uC2DD\uC785\uB2C8\uB2E4. \uC0AC\uC6A9: 256k, 1m \uB610\uB294 \uC815\uD655\uD55C \uC22B\uC790(1000-10000000)." + }, + enableOpus1M: { + name: "Opus 1M \uCEE8\uD14D\uC2A4\uD2B8 \uC708\uB3C4\uC6B0", + desc: "\uBAA8\uB378 \uC120\uD0DD\uAE30\uC5D0\uC11C Opus 1M\uC744 \uD45C\uC2DC\uD569\uB2C8\uB2E4. Max, Team, Enterprise \uD50C\uB79C\uC5D0 \uD3EC\uD568\uB429\uB2C8\uB2E4. API \uBC0F Pro \uC0AC\uC6A9\uC790\uB294 \uCD94\uAC00 \uC0AC\uC6A9\uB7C9\uC774 \uD544\uC694\uD569\uB2C8\uB2E4." + }, + enableSonnet1M: { + name: "Sonnet 1M \uCEE8\uD14D\uC2A4\uD2B8 \uC708\uB3C4\uC6B0", + desc: "\uBAA8\uB378 \uC120\uD0DD\uAE30\uC5D0\uC11C Sonnet 1M\uC744 \uD45C\uC2DC\uD569\uB2C8\uB2E4. Max, Team, Enterprise \uD50C\uB79C\uC5D0\uC11C \uCD94\uAC00 \uC0AC\uC6A9\uB7C9\uC774 \uD544\uC694\uD569\uB2C8\uB2E4. API \uBC0F Pro \uC0AC\uC6A9\uC790\uB294 \uCD94\uAC00 \uC0AC\uC6A9\uB7C9\uC774 \uD544\uC694\uD569\uB2C8\uB2E4." + }, + enableChrome: { + name: "Chrome \uD655\uC7A5 \uD504\uB85C\uADF8\uB7A8 \uD65C\uC131\uD654", + desc: "claude-in-chrome \uD655\uC7A5 \uD504\uB85C\uADF8\uB7A8\uC744 \uD1B5\uD574 Claude\uAC00 Chrome\uACFC \uC0C1\uD638\uC791\uC6A9\uD560 \uC218 \uC788\uB3C4\uB85D \uD569\uB2C8\uB2E4. \uD655\uC7A5 \uD504\uB85C\uADF8\uB7A8\uC774 \uC124\uCE58\uB418\uC5B4 \uC788\uC5B4\uC57C \uD569\uB2C8\uB2E4. \uC138\uC158 \uC7AC\uC2DC\uC791\uC774 \uD544\uC694\uD569\uB2C8\uB2E4." + }, + enableBangBash: { + name: "bash \uBAA8\uB4DC (!) \uD65C\uC131\uD654", + desc: "\uC785\uB825\uCC3D\uC774 \uBE44\uC5B4 \uC788\uC744 \uB54C !\uB97C \uC785\uB825\uD558\uBA74 bash \uBAA8\uB4DC\uB85C \uB4E4\uC5B4\uAC11\uB2C8\uB2E4. Node.js child_process\uB97C \uD1B5\uD574 \uBA85\uB839\uC744 \uC9C1\uC811 \uC2E4\uD589\uD569\uB2C8\uB2E4. \uBCF4\uAE30\uB97C \uB2E4\uC2DC \uC5F4\uC5B4\uC57C \uD569\uB2C8\uB2E4.", + validation: { + noNode: "PATH\uC5D0\uC11C Node.js\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. Node.js\uB97C \uC124\uCE58\uD558\uAC70\uB098 PATH \uC124\uC815\uC744 \uD655\uC778\uD558\uC138\uC694." + } + }, + maxTabs: { + name: "\uCD5C\uB300 \uCC44\uD305 \uD0ED \uC218", + desc: "\uB3D9\uC2DC\uC5D0 \uC5F4 \uC218 \uC788\uB294 \uCD5C\uB300 \uCC44\uD305 \uD0ED \uC218(3-10). \uAC01 \uD0ED\uC740 \uBCC4\uB3C4\uC758 Claude \uC138\uC158\uC744 \uC0AC\uC6A9\uD569\uB2C8\uB2E4.", + warning: "5\uAC1C \uD0ED\uC744 \uCD08\uACFC\uD558\uBA74 \uC131\uB2A5 \uBC0F \uBA54\uBAA8\uB9AC \uC0AC\uC6A9\uB7C9\uC5D0 \uC601\uD5A5\uC744 \uC904 \uC218 \uC788\uC2B5\uB2C8\uB2E4." + }, + tabBarPosition: { + name: "\uD0ED \uBC14 \uC704\uCE58", + desc: "\uD0ED \uBC30\uC9C0\uC640 \uC791\uC5C5 \uBC84\uD2BC\uC758 \uD45C\uC2DC \uC704\uCE58 \uC120\uD0DD", + input: "\uC785\uB825\uCC3D \uC704(\uAE30\uBCF8\uAC12)", + header: "\uD5E4\uB354\uC5D0" + }, + enableAutoScroll: { + name: "\uC2A4\uD2B8\uB9AC\uBC0D \uC911 \uC790\uB3D9 \uC2A4\uD06C\uB864", + desc: "Claude\uAC00 \uC751\uB2F5\uC744 \uC2A4\uD2B8\uB9AC\uBC0D\uD558\uB294 \uB3D9\uC548 \uC790\uB3D9\uC73C\uB85C \uC544\uB798\uB85C \uC2A4\uD06C\uB864\uD569\uB2C8\uB2E4. \uBE44\uD65C\uC131\uD654\uD558\uBA74 \uC0C1\uB2E8\uC5D0 \uBA38\uBB3C\uB7EC \uCC98\uC74C\uBD80\uD130 \uC77D\uC744 \uC218 \uC788\uC2B5\uB2C8\uB2E4." + }, + openInMainTab: { + name: "\uBA54\uC778 \uD3B8\uC9D1\uAE30 \uC601\uC5ED\uC5D0\uC11C \uC5F4\uAE30", + desc: "\uCC44\uD305 \uD328\uB110\uC744 \uC624\uB978\uCABD \uC0AC\uC774\uB4DC\uBC14\uAC00 \uC544\uB2CC \uC911\uC559 \uD3B8\uC9D1\uAE30 \uC601\uC5ED\uC758 \uBA54\uC778 \uD0ED\uC73C\uB85C \uC5FD\uB2C8\uB2E4" + }, + cliPath: { + name: "Claude CLI \uACBD\uB85C", + desc: "Claude Code CLI\uC758 \uC0AC\uC6A9\uC790 \uC815\uC758 \uACBD\uB85C. \uBE44\uC6CC\uB450\uBA74 \uC790\uB3D9 \uAC10\uC9C0 \uC0AC\uC6A9.", + descWindows: "\uB124\uC774\uD2F0\uBE0C \uC124\uCE58 \uD504\uB85C\uADF8\uB7A8\uC758 \uACBD\uC6B0 claude.exe\uB97C \uC0AC\uC6A9\uD558\uC138\uC694. npm/pnpm/yarn \uB610\uB294 \uAE30\uD0C0 \uD328\uD0A4\uC9C0 \uAD00\uB9AC\uC790 \uC124\uCE58\uC758 \uACBD\uC6B0 cli.js \uACBD\uB85C\uB97C \uC0AC\uC6A9\uD558\uC138\uC694 (claude.cmd\uAC00 \uC544\uB2D8).", + descUnix: '"which claude"\uC758 \uCD9C\uB825\uC744 \uBD99\uC5EC\uB123\uC73C\uC138\uC694 - \uB124\uC774\uD2F0\uBE0C \uBC0F npm/pnpm/yarn \uC124\uCE58 \uBAA8\uB450\uC5D0\uC11C \uC791\uB3D9\uD569\uB2C8\uB2E4.', + validation: { + notExist: "\uACBD\uB85C\uAC00 \uC874\uC7AC\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4", + isDirectory: "\uACBD\uB85C\uAC00 \uB514\uB809\uD1A0\uB9AC\uC785\uB2C8\uB2E4 \uD30C\uC77C\uC774 \uC544\uB2D9\uB2C8\uB2E4" + } + }, + language: { + name: "\uC5B8\uC5B4", + desc: "\uD50C\uB7EC\uADF8\uC778 \uC778\uD130\uD398\uC774\uC2A4\uC758 \uD45C\uC2DC \uC5B8\uC5B4 \uBCC0\uACBD" + } +}; +var ko_default = { + common: common6, + chat: chat6, + settings: settings6 +}; + +// src/i18n/locales/pt.json +var pt_exports = {}; +__export(pt_exports, { + chat: () => chat7, + common: () => common7, + default: () => pt_default, + settings: () => settings7 +}); +var common7 = { + save: "Salvar", + cancel: "Cancelar", + delete: "Excluir", + edit: "Editar", + add: "Adicionar", + remove: "Remover", + clear: "Limpar", + clearAll: "Limpar tudo", + loading: "Carregando", + error: "Erro", + success: "Sucesso", + warning: "Aviso", + confirm: "Confirmar", + settings: "Configura\xE7\xF5es", + advanced: "Avan\xE7ado", + enabled: "Ativado", + disabled: "Desativado", + platform: "Plataforma", + refresh: "Atualizar", + rewind: "Retroceder" +}; +var chat7 = { + rewind: { + confirmMessage: "Retroceder at\xE9 este ponto? As altera\xE7\xF5es de arquivos ap\xF3s esta mensagem ser\xE3o revertidas. O retrocesso n\xE3o afeta arquivos editados manualmente ou via bash.", + confirmButton: "Retroceder", + ariaLabel: "Retroceder at\xE9 aqui", + notice: "Retrocedido: {count} arquivo(s) revertido(s)", + noticeSaveFailed: "Retrocedido: {count} arquivo(s) revertido(s), mas n\xE3o foi poss\xEDvel salvar o estado: {error}", + failed: "Falha ao retroceder: {error}", + cannot: "N\xE3o \xE9 poss\xEDvel retroceder: {error}", + unavailableStreaming: "N\xE3o \xE9 poss\xEDvel retroceder durante a transmiss\xE3o", + unavailableNoUuid: "N\xE3o \xE9 poss\xEDvel retroceder: identificadores de mensagem ausentes" + }, + fork: { + ariaLabel: "Bifurcar conversa", + chooseTarget: "Bifurcar conversa", + targetNewTab: "Nova aba", + targetCurrentTab: "Aba atual", + maxTabsReached: "N\xE3o \xE9 poss\xEDvel bifurcar: m\xE1ximo de {count} abas atingido", + notice: "Bifurcado para nova aba", + noticeCurrentTab: "Bifurcado na aba atual", + failed: "Falha ao bifurcar: {error}", + unavailableStreaming: "N\xE3o \xE9 poss\xEDvel bifurcar durante a transmiss\xE3o", + unavailableNoUuid: "N\xE3o \xE9 poss\xEDvel bifurcar: identificadores de mensagem ausentes", + unavailableNoResponse: "N\xE3o \xE9 poss\xEDvel bifurcar: nenhuma resposta para bifurcar", + errorMessageNotFound: "Mensagem n\xE3o encontrada", + errorNoSession: "Nenhum ID de sess\xE3o dispon\xEDvel", + errorNoActiveTab: "Nenhuma aba ativa", + commandNoMessages: "N\xE3o \xE9 poss\xEDvel bifurcar: n\xE3o h\xE1 mensagens na conversa", + commandNoAssistantUuid: "N\xE3o \xE9 poss\xEDvel bifurcar: n\xE3o h\xE1 resposta do assistente com identificadores" + }, + bangBash: { + placeholder: "> Executar um comando bash...", + commandPanel: "Painel de comandos", + copyAriaLabel: "Copiar a sa\xEDda do comando mais recente", + clearAriaLabel: "Limpar a sa\xEDda do bash", + commandLabel: "{command}", + statusLabel: "Estado: {status}", + collapseOutput: "Recolher a sa\xEDda do comando", + expandOutput: "Expandir a sa\xEDda do comando", + running: "Executando...", + copyFailed: "Falha ao copiar para a \xE1rea de transfer\xEAncia" + } +}; +var settings7 = { + title: "Configura\xE7\xF5es do Claudian", + tabs: { + general: "Geral", + claude: "Claude", + codex: "Codex" + }, + display: "Exibi\xE7\xE3o", + conversations: "Conversas", + content: "Conte\xFAdo", + input: "Entrada", + setup: "Configura\xE7\xE3o", + models: "Modelos", + experimental: "Experimental", + userName: { + name: "Como o Claudian deve cham\xE1-lo?", + desc: "Seu nome para sauda\xE7\xF5es personalizadas (deixe vazio para sauda\xE7\xF5es gen\xE9ricas)" + }, + excludedTags: { + name: "Tags exclu\xEDdas", + desc: "Notas com estas tags n\xE3o ser\xE3o carregadas automaticamente como contexto (uma por linha, sem #)" + }, + mediaFolder: { + name: "Pasta de m\xEDdia", + desc: "Pasta contendo anexos/imagens. Quando notas usam ![[image.jpg]], Claude procurar\xE1 aqui. Deixe vazio para a raiz do reposit\xF3rio." + }, + systemPrompt: { + name: "Prompt de sistema personalizado", + desc: "Instru\xE7\xF5es adicionais anexadas ao prompt de sistema padr\xE3o" + }, + autoTitle: { + name: "Gerar automaticamente t\xEDtulos de conversa", + desc: "Gera automaticamente t\xEDtulos de conversa ap\xF3s a primeira mensagem do usu\xE1rio." + }, + titleModel: { + name: "Modelo de gera\xE7\xE3o de t\xEDtulo", + desc: "Modelo usado para gerar automaticamente t\xEDtulos de conversa.", + auto: "Autom\xE1tico (Haiku)" + }, + navMappings: { + name: "Mapeamentos de navega\xE7\xE3o estilo Vim", + desc: 'Um mapeamento por linha. Formato: "map " (a\xE7\xF5es: scrollUp, scrollDown, focusInput).' + }, + hotkeys: "Atalhos", + inlineEditHotkey: { + name: "Edi\xE7\xE3o em linha", + descWithKey: "Atalho atual: {hotkey}", + descNoKey: "Nenhum atalho definido", + btnChange: "Alterar", + btnSet: "Definir" + }, + openChatHotkey: { + name: "Abrir chat", + descWithKey: "Atalho atual: {hotkey}", + descNoKey: "Nenhum atalho definido", + btnChange: "Alterar", + btnSet: "Definir" + }, + newSessionHotkey: { + name: "Nova sess\xE3o", + descWithKey: "Atalho atual: {hotkey}", + descNoKey: "Nenhum atalho definido", + btnChange: "Alterar", + btnSet: "Definir" + }, + newTabHotkey: { + name: "Nova aba", + descWithKey: "Atalho atual: {hotkey}", + descNoKey: "Nenhum atalho definido", + btnChange: "Alterar", + btnSet: "Definir" + }, + closeTabHotkey: { + name: "Fechar aba", + descWithKey: "Atalho atual: {hotkey}", + descNoKey: "Nenhum atalho definido", + btnChange: "Alterar", + btnSet: "Definir" + }, + slashCommands: { + name: "Comandos e habilidades", + desc: "Gerencie comandos e habilidades a n\xEDvel de vault armazenados em .claude/commands/ e .claude/skills/. Acionados por /nome." + }, + hiddenSlashCommands: { + name: "Comandos ocultos", + desc: "Ocultar comandos slash espec\xEDficos do menu suspenso. \xDAtil para ocultar comandos do Claude Code que n\xE3o s\xE3o relevantes para o Claudian. Digite os nomes dos comandos sem a barra inicial, um por linha.", + placeholder: "commit\nbuild\ntest" + }, + mcpServers: { + name: "Servidores MCP", + desc: "Gerencie configura\xE7\xF5es de servidores MCP a n\xEDvel de vault armazenadas em .claude/mcp.json. Servidores com modo de salvamento de contexto exigem @mention para ativar." + }, + plugins: { + name: "Plugins do Claude Code", + desc: "Gerencie plugins do Claude Code descobertos em ~/.claude/plugins. Plugins ativados s\xE3o armazenados por vault em .claude/settings.json." + }, + subagents: { + name: "Subagentes", + desc: "Gerencie subagentes a n\xEDvel de vault armazenados em .claude/agents/. Cada arquivo Markdown define um agente personalizado.", + noAgents: "Nenhum subagente configurado. Clique em + para criar um.", + deleteConfirm: 'Excluir o subagente "{name}"?', + saveFailed: "Falha ao salvar o subagente: {message}", + refreshFailed: "Falha ao atualizar subagentes: {message}", + deleteFailed: "Falha ao excluir o subagente: {message}", + renameCleanupFailed: 'Aviso: n\xE3o foi poss\xEDvel remover o arquivo antigo de "{name}"', + created: 'Subagente "{name}" criado', + updated: 'Subagente "{name}" atualizado', + deleted: 'Subagente "{name}" exclu\xEDdo', + duplicateName: 'J\xE1 existe um agente chamado "{name}"', + descriptionRequired: "A descri\xE7\xE3o \xE9 obrigat\xF3ria", + promptRequired: "O prompt do sistema \xE9 obrigat\xF3rio", + modal: { + titleEdit: "Editar subagente", + titleAdd: "Adicionar subagente", + name: "Nome", + nameDesc: "Use apenas letras min\xFAsculas, n\xFAmeros e h\xEDfens", + namePlaceholder: "code-reviewer", + description: "Descri\xE7\xE3o", + descriptionDesc: "Breve descri\xE7\xE3o deste agente", + descriptionPlaceholder: "Revisa c\xF3digo em busca de bugs e estilo", + advancedOptions: "Op\xE7\xF5es avan\xE7adas", + model: "Modelo", + modelDesc: "Substituir o modelo deste agente", + tools: "Ferramentas", + toolsDesc: "Lista de ferramentas permitidas separadas por v\xEDrgula (vazio = todas)", + disallowedTools: "Ferramentas n\xE3o permitidas", + disallowedToolsDesc: "Lista de ferramentas a desativar separadas por v\xEDrgula", + skills: "Habilidades", + skillsDesc: "Lista de habilidades separadas por v\xEDrgula", + prompt: "Prompt do sistema", + promptDesc: "Instru\xE7\xF5es para o agente", + promptPlaceholder: "Voc\xEA \xE9 um revisor de c\xF3digo. Analise o c\xF3digo fornecido para..." + } + }, + safety: "Seguran\xE7a", + loadUserSettings: { + name: "Carregar configura\xE7\xF5es do usu\xE1rio Claude", + desc: "Carrega ~/.claude/settings.json. Quando habilitado, as regras de permiss\xE3o do usu\xE1rio podem ignorar o modo seguro." + }, + claudeSafeMode: { + name: "Safe mode", + desc: "Permission mode used when the Safe toggle is active." + }, + codexSafeMode: { + name: "Safe mode", + desc: "Sandbox mode used when the Safe toggle is active." + }, + environment: "Ambiente", + customVariables: { + name: "Vari\xE1veis personalizadas", + desc: "Vari\xE1veis de ambiente para Claude SDK (formato KEY=VALUE, uma por linha). Prefixo export suportado." + }, + envSnippets: { + name: "Snippets", + addBtn: "Adicionar snippet", + noSnippets: "Nenhum snippet de ambiente salvo. Clique em + para salvar sua configura\xE7\xE3o atual.", + nameRequired: "Por favor, insira um nome para o snippet", + modal: { + titleEdit: "Editar snippet", + titleSave: "Salvar snippet", + name: "Nome", + namePlaceholder: "Um nome descritivo para esta configura\xE7\xE3o", + description: "Descri\xE7\xE3o", + descPlaceholder: "Descri\xE7\xE3o opcional", + envVars: "Vari\xE1veis de ambiente", + envVarsPlaceholder: "Formato KEY=VALUE, uma por linha (prefixo export suportado)", + save: "Salvar", + update: "Atualizar", + cancel: "Cancelar" + } + }, + customContextLimits: { + name: "Limites de contexto personalizados", + desc: "Defina tamanhos de janela de contexto para seus modelos personalizados. Deixe vazio para usar o padr\xE3o (200k tokens).", + invalid: "Formato inv\xE1lido. Use: 256k, 1m ou n\xFAmero exato (1000-10000000)." + }, + enableOpus1M: { + name: "Janela de contexto Opus 1M", + desc: "Mostrar Opus 1M no seletor de modelos. Inclu\xEDdo nos planos Max, Team e Enterprise. Usu\xE1rios de API e Pro precisam de uso adicional." + }, + enableSonnet1M: { + name: "Janela de contexto Sonnet 1M", + desc: "Mostrar Sonnet 1M no seletor de modelos. Requer uso adicional nos planos Max, Team e Enterprise. Usu\xE1rios de API e Pro precisam de uso adicional." + }, + enableChrome: { + name: "Habilitar extens\xE3o do Chrome", + desc: "Permitir que o Claude interaja com o Chrome atrav\xE9s da extens\xE3o claude-in-chrome. Requer que a extens\xE3o esteja instalada. Requer rein\xEDcio de sess\xE3o." + }, + enableBangBash: { + name: "Ativar modo bash (!)", + desc: "Digite ! com a entrada vazia para entrar no modo bash. Executa comandos diretamente via Node.js child_process. Requer reabrir a visualiza\xE7\xE3o.", + validation: { + noNode: "Node.js n\xE3o encontrado no PATH. Instale o Node.js ou verifique a configura\xE7\xE3o do PATH." + } + }, + maxTabs: { + name: "M\xE1ximo de abas de chat", + desc: "N\xFAmero m\xE1ximo de abas de chat simult\xE2neas (3-10). Cada aba usa uma sess\xE3o Claude separada.", + warning: "Mais de 5 abas pode afetar o desempenho e o uso de mem\xF3ria." + }, + tabBarPosition: { + name: "Posi\xE7\xE3o da barra de abas", + desc: "Escolha onde exibir os emblemas de abas e bot\xF5es de a\xE7\xE3o", + input: "Acima da entrada (padr\xE3o)", + header: "No cabe\xE7alho" + }, + enableAutoScroll: { + name: "Rolagem autom\xE1tica durante streaming", + desc: "Rolar automaticamente para baixo enquanto o Claude transmite respostas. Desativar para ficar no topo e ler desde o in\xEDcio." + }, + openInMainTab: { + name: "Abrir na \xE1rea do editor principal", + desc: "Abrir o painel de chat como uma aba principal na \xE1rea do editor central em vez da barra lateral direita" + }, + cliPath: { + name: "Caminho CLI Claude", + desc: "Caminho personalizado para Claude Code CLI. Deixe vazio para detec\xE7\xE3o autom\xE1tica.", + descWindows: "Para o instalador nativo, use claude.exe. Para instala\xE7\xF5es com npm/pnpm/yarn ou outros gerenciadores de pacotes, use o caminho cli.js (n\xE3o claude.cmd).", + descUnix: 'Cole a sa\xEDda de "which claude" \u2014 funciona tanto para instala\xE7\xF5es nativas quanto npm/pnpm/yarn.', + validation: { + notExist: "Caminho n\xE3o existe", + isDirectory: "Caminho \xE9 um diret\xF3rio, n\xE3o um arquivo" + } + }, + language: { + name: "Idioma", + desc: "Alterar o idioma de exibi\xE7\xE3o da interface do plugin" + } +}; +var pt_default = { + common: common7, + chat: chat7, + settings: settings7 +}; + +// src/i18n/locales/ru.json +var ru_exports = {}; +__export(ru_exports, { + chat: () => chat8, + common: () => common8, + default: () => ru_default, + settings: () => settings8 +}); +var common8 = { + save: "\u0421\u043E\u0445\u0440\u0430\u043D\u0438\u0442\u044C", + cancel: "\u041E\u0442\u043C\u0435\u043D\u0430", + delete: "\u0423\u0434\u0430\u043B\u0438\u0442\u044C", + edit: "\u0420\u0435\u0434\u0430\u043A\u0442\u0438\u0440\u043E\u0432\u0430\u0442\u044C", + add: "\u0414\u043E\u0431\u0430\u0432\u0438\u0442\u044C", + remove: "\u0423\u0434\u0430\u043B\u0438\u0442\u044C", + clear: "\u041E\u0447\u0438\u0441\u0442\u0438\u0442\u044C", + clearAll: "\u041E\u0447\u0438\u0441\u0442\u0438\u0442\u044C \u0432\u0441\u0451", + loading: "\u0417\u0430\u0433\u0440\u0443\u0437\u043A\u0430", + error: "\u041E\u0448\u0438\u0431\u043A\u0430", + success: "\u0423\u0441\u043F\u0435\u0445", + warning: "\u041F\u0440\u0435\u0434\u0443\u043F\u0440\u0435\u0436\u0434\u0435\u043D\u0438\u0435", + confirm: "\u041F\u043E\u0434\u0442\u0432\u0435\u0440\u0434\u0438\u0442\u044C", + settings: "\u041D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u0438", + advanced: "\u0414\u043E\u043F\u043E\u043B\u043D\u0438\u0442\u0435\u043B\u044C\u043D\u043E", + enabled: "\u0412\u043A\u043B\u044E\u0447\u0435\u043D\u043E", + disabled: "\u041E\u0442\u043A\u043B\u044E\u0447\u0435\u043D\u043E", + platform: "\u041F\u043B\u0430\u0442\u0444\u043E\u0440\u043C\u0430", + refresh: "\u041E\u0431\u043D\u043E\u0432\u0438\u0442\u044C", + rewind: "\u041E\u0442\u043A\u0430\u0442\u0438\u0442\u044C" +}; +var chat8 = { + rewind: { + confirmMessage: "\u041E\u0442\u043A\u0430\u0442\u0438\u0442\u044C \u0434\u043E \u044D\u0442\u043E\u0439 \u0442\u043E\u0447\u043A\u0438? \u0418\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u044F \u0444\u0430\u0439\u043B\u043E\u0432 \u043F\u043E\u0441\u043B\u0435 \u044D\u0442\u043E\u0433\u043E \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u044F \u0431\u0443\u0434\u0443\u0442 \u043E\u0442\u043C\u0435\u043D\u0435\u043D\u044B. \u041E\u0442\u043A\u0430\u0442 \u043D\u0435 \u0437\u0430\u0442\u0440\u0430\u0433\u0438\u0432\u0430\u0435\u0442 \u0444\u0430\u0439\u043B\u044B, \u043E\u0442\u0440\u0435\u0434\u0430\u043A\u0442\u0438\u0440\u043E\u0432\u0430\u043D\u043D\u044B\u0435 \u0432\u0440\u0443\u0447\u043D\u0443\u044E \u0438\u043B\u0438 \u0447\u0435\u0440\u0435\u0437 bash.", + confirmButton: "\u041E\u0442\u043A\u0430\u0442\u0438\u0442\u044C", + ariaLabel: "\u041E\u0442\u043A\u0430\u0442\u0438\u0442\u044C \u0441\u044E\u0434\u0430", + notice: "\u041E\u0442\u043A\u0430\u0447\u0435\u043D\u043E: \u0432\u043E\u0441\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D\u043E \u0444\u0430\u0439\u043B\u043E\u0432 \u2014 {count}", + noticeSaveFailed: "\u041E\u0442\u043A\u0430\u0442 \u0432\u044B\u043F\u043E\u043B\u043D\u0435\u043D: \u0432\u043E\u0441\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D\u043E \u0444\u0430\u0439\u043B\u043E\u0432 \u2014 {count}, \u043D\u043E \u043D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0441\u043E\u0445\u0440\u0430\u043D\u0438\u0442\u044C \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435: {error}", + failed: "\u041E\u0448\u0438\u0431\u043A\u0430 \u043E\u0442\u043A\u0430\u0442\u0430: {error}", + cannot: "\u041D\u0435\u0432\u043E\u0437\u043C\u043E\u0436\u043D\u043E \u043E\u0442\u043A\u0430\u0442\u0438\u0442\u044C: {error}", + unavailableStreaming: "\u041D\u0435\u0432\u043E\u0437\u043C\u043E\u0436\u043D\u043E \u043E\u0442\u043A\u0430\u0442\u0438\u0442\u044C \u0432\u043E \u0432\u0440\u0435\u043C\u044F \u043F\u043E\u0442\u043E\u043A\u043E\u0432\u043E\u0439 \u043F\u0435\u0440\u0435\u0434\u0430\u0447\u0438", + unavailableNoUuid: "\u041D\u0435\u0432\u043E\u0437\u043C\u043E\u0436\u043D\u043E \u043E\u0442\u043A\u0430\u0442\u0438\u0442\u044C: \u043E\u0442\u0441\u0443\u0442\u0441\u0442\u0432\u0443\u044E\u0442 \u0438\u0434\u0435\u043D\u0442\u0438\u0444\u0438\u043A\u0430\u0442\u043E\u0440\u044B \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u0439" + }, + fork: { + ariaLabel: "\u041E\u0442\u0432\u0435\u0442\u0432\u0438\u0442\u044C \u0440\u0430\u0437\u0433\u043E\u0432\u043E\u0440", + chooseTarget: "\u041E\u0442\u0432\u0435\u0442\u0432\u0438\u0442\u044C \u0440\u0430\u0437\u0433\u043E\u0432\u043E\u0440", + targetNewTab: "\u041D\u043E\u0432\u0430\u044F \u0432\u043A\u043B\u0430\u0434\u043A\u0430", + targetCurrentTab: "\u0422\u0435\u043A\u0443\u0449\u0430\u044F \u0432\u043A\u043B\u0430\u0434\u043A\u0430", + maxTabsReached: "\u041D\u0435\u0432\u043E\u0437\u043C\u043E\u0436\u043D\u043E \u043E\u0442\u0432\u0435\u0442\u0432\u0438\u0442\u044C: \u0434\u043E\u0441\u0442\u0438\u0433\u043D\u0443\u0442 \u043C\u0430\u043A\u0441\u0438\u043C\u0443\u043C {count} \u0432\u043A\u043B\u0430\u0434\u043E\u043A", + notice: "\u041E\u0442\u0432\u0435\u0442\u0432\u043B\u0435\u043D\u043E \u0432 \u043D\u043E\u0432\u0443\u044E \u0432\u043A\u043B\u0430\u0434\u043A\u0443", + noticeCurrentTab: "\u041E\u0442\u0432\u0435\u0442\u0432\u043B\u0435\u043D\u043E \u0432 \u0442\u0435\u043A\u0443\u0449\u0435\u0439 \u0432\u043A\u043B\u0430\u0434\u043A\u0435", + failed: "\u041E\u0448\u0438\u0431\u043A\u0430 \u043E\u0442\u0432\u0435\u0442\u0432\u043B\u0435\u043D\u0438\u044F: {error}", + unavailableStreaming: "\u041D\u0435\u0432\u043E\u0437\u043C\u043E\u0436\u043D\u043E \u043E\u0442\u0432\u0435\u0442\u0432\u0438\u0442\u044C \u0432\u043E \u0432\u0440\u0435\u043C\u044F \u043F\u043E\u0442\u043E\u043A\u043E\u0432\u043E\u0439 \u043F\u0435\u0440\u0435\u0434\u0430\u0447\u0438", + unavailableNoUuid: "\u041D\u0435\u0432\u043E\u0437\u043C\u043E\u0436\u043D\u043E \u043E\u0442\u0432\u0435\u0442\u0432\u0438\u0442\u044C: \u043E\u0442\u0441\u0443\u0442\u0441\u0442\u0432\u0443\u044E\u0442 \u0438\u0434\u0435\u043D\u0442\u0438\u0444\u0438\u043A\u0430\u0442\u043E\u0440\u044B \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u0439", + unavailableNoResponse: "\u041D\u0435\u0432\u043E\u0437\u043C\u043E\u0436\u043D\u043E \u043E\u0442\u0432\u0435\u0442\u0432\u0438\u0442\u044C: \u043D\u0435\u0442 \u043E\u0442\u0432\u0435\u0442\u0430 \u0434\u043B\u044F \u043E\u0442\u0432\u0435\u0442\u0432\u043B\u0435\u043D\u0438\u044F", + errorMessageNotFound: "\u0421\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u0435 \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u043E", + errorNoSession: "\u0418\u0434\u0435\u043D\u0442\u0438\u0444\u0438\u043A\u0430\u0442\u043E\u0440 \u0441\u0435\u0441\u0441\u0438\u0438 \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D", + errorNoActiveTab: "\u041D\u0435\u0442 \u0430\u043A\u0442\u0438\u0432\u043D\u043E\u0439 \u0432\u043A\u043B\u0430\u0434\u043A\u0438", + commandNoMessages: "\u041D\u0435\u043B\u044C\u0437\u044F \u0444\u043E\u0440\u043A\u043D\u0443\u0442\u044C: \u0432 \u0434\u0438\u0430\u043B\u043E\u0433\u0435 \u043D\u0435\u0442 \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u0439", + commandNoAssistantUuid: "\u041D\u0435\u043B\u044C\u0437\u044F \u0444\u043E\u0440\u043A\u043D\u0443\u0442\u044C: \u043D\u0435\u0442 \u043E\u0442\u0432\u0435\u0442\u0430 \u0430\u0441\u0441\u0438\u0441\u0442\u0435\u043D\u0442\u0430 \u0441 \u0438\u0434\u0435\u043D\u0442\u0438\u0444\u0438\u043A\u0430\u0442\u043E\u0440\u0430\u043C\u0438" + }, + bangBash: { + placeholder: "> \u0412\u044B\u043F\u043E\u043B\u043D\u0438\u0442\u044C \u043A\u043E\u043C\u0430\u043D\u0434\u0443 bash...", + commandPanel: "\u041F\u0430\u043D\u0435\u043B\u044C \u043A\u043E\u043C\u0430\u043D\u0434", + copyAriaLabel: "\u0421\u043A\u043E\u043F\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u0432\u044B\u0432\u043E\u0434 \u043F\u043E\u0441\u043B\u0435\u0434\u043D\u0435\u0439 \u043A\u043E\u043C\u0430\u043D\u0434\u044B", + clearAriaLabel: "\u041E\u0447\u0438\u0441\u0442\u0438\u0442\u044C \u0432\u044B\u0432\u043E\u0434 bash", + commandLabel: "{command}", + statusLabel: "\u0421\u0442\u0430\u0442\u0443\u0441: {status}", + collapseOutput: "\u0421\u0432\u0435\u0440\u043D\u0443\u0442\u044C \u0432\u044B\u0432\u043E\u0434 \u043A\u043E\u043C\u0430\u043D\u0434\u044B", + expandOutput: "\u0420\u0430\u0437\u0432\u0435\u0440\u043D\u0443\u0442\u044C \u0432\u044B\u0432\u043E\u0434 \u043A\u043E\u043C\u0430\u043D\u0434\u044B", + running: "\u0412\u044B\u043F\u043E\u043B\u043D\u044F\u0435\u0442\u0441\u044F...", + copyFailed: "\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0441\u043A\u043E\u043F\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u0432 \u0431\u0443\u0444\u0435\u0440 \u043E\u0431\u043C\u0435\u043D\u0430" + } +}; +var settings8 = { + title: "\u041D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u0438 Claudian", + tabs: { + general: "\u041E\u0431\u0449\u0438\u0435", + claude: "Claude", + codex: "Codex" + }, + display: "\u041E\u0442\u043E\u0431\u0440\u0430\u0436\u0435\u043D\u0438\u0435", + conversations: "\u0420\u0430\u0437\u0433\u043E\u0432\u043E\u0440\u044B", + content: "\u0421\u043E\u0434\u0435\u0440\u0436\u0430\u043D\u0438\u0435", + input: "\u0412\u0432\u043E\u0434", + setup: "\u041D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u0430", + models: "\u041C\u043E\u0434\u0435\u043B\u0438", + experimental: "\u042D\u043A\u0441\u043F\u0435\u0440\u0438\u043C\u0435\u043D\u0442\u0430\u043B\u044C\u043D\u043E\u0435", + userName: { + name: "\u041A\u0430\u043A Claudian \u0434\u043E\u043B\u0436\u0435\u043D \u043E\u0431\u0440\u0430\u0449\u0430\u0442\u044C\u0441\u044F \u043A \u0432\u0430\u043C?", + desc: "\u0412\u0430\u0448\u0435 \u0438\u043C\u044F \u0434\u043B\u044F \u043F\u0435\u0440\u0441\u043E\u043D\u0430\u043B\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u043D\u043D\u044B\u0445 \u043F\u0440\u0438\u0432\u0435\u0442\u0441\u0442\u0432\u0438\u0439 (\u043E\u0441\u0442\u0430\u0432\u044C\u0442\u0435 \u043F\u0443\u0441\u0442\u044B\u043C \u0434\u043B\u044F \u043E\u0431\u0449\u0438\u0445 \u043F\u0440\u0438\u0432\u0435\u0442\u0441\u0442\u0432\u0438\u0439)" + }, + excludedTags: { + name: "\u0418\u0441\u043A\u043B\u044E\u0447\u0435\u043D\u043D\u044B\u0435 \u0442\u0435\u0433\u0438", + desc: "\u0417\u0430\u043C\u0435\u0442\u043A\u0438 \u0441 \u044D\u0442\u0438\u043C\u0438 \u0442\u0435\u0433\u0430\u043C\u0438 \u043D\u0435 \u0431\u0443\u0434\u0443\u0442 \u0430\u0432\u0442\u043E\u043C\u0430\u0442\u0438\u0447\u0435\u0441\u043A\u0438 \u0437\u0430\u0433\u0440\u0443\u0436\u0430\u0442\u044C\u0441\u044F \u043A\u0430\u043A \u043A\u043E\u043D\u0442\u0435\u043A\u0441\u0442 (\u043F\u043E \u043E\u0434\u043D\u043E\u043C\u0443 \u0432 \u0441\u0442\u0440\u043E\u043A\u0435, \u0431\u0435\u0437 #)" + }, + mediaFolder: { + name: "\u041F\u0430\u043F\u043A\u0430 \u043C\u0435\u0434\u0438\u0430\u0444\u0430\u0439\u043B\u043E\u0432", + desc: "\u041F\u0430\u043F\u043A\u0430 \u0441 \u0432\u043B\u043E\u0436\u0435\u043D\u0438\u044F\u043C\u0438/\u0438\u0437\u043E\u0431\u0440\u0430\u0436\u0435\u043D\u0438\u044F\u043C\u0438. \u041A\u043E\u0433\u0434\u0430 \u0437\u0430\u043C\u0435\u0442\u043A\u0438 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u044E\u0442 ![[image.jpg]], Claude \u0431\u0443\u0434\u0435\u0442 \u0438\u0441\u043A\u0430\u0442\u044C \u0437\u0434\u0435\u0441\u044C. \u041E\u0441\u0442\u0430\u0432\u044C\u0442\u0435 \u043F\u0443\u0441\u0442\u044B\u043C \u0434\u043B\u044F \u043A\u043E\u0440\u043D\u044F \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430." + }, + systemPrompt: { + name: "\u041F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044C\u0441\u043A\u0438\u0439 \u0441\u0438\u0441\u0442\u0435\u043C\u043D\u044B\u0439 \u043F\u0440\u043E\u043C\u043F\u0442", + desc: "\u0414\u043E\u043F\u043E\u043B\u043D\u0438\u0442\u0435\u043B\u044C\u043D\u044B\u0435 \u0438\u043D\u0441\u0442\u0440\u0443\u043A\u0446\u0438\u0438, \u0434\u043E\u0431\u0430\u0432\u043B\u044F\u0435\u043C\u044B\u0435 \u043A \u0441\u0438\u0441\u0442\u0435\u043C\u043D\u043E\u043C\u0443 \u043F\u0440\u043E\u043C\u043F\u0442\u0443 \u043F\u043E \u0443\u043C\u043E\u043B\u0447\u0430\u043D\u0438\u044E" + }, + autoTitle: { + name: "\u0410\u0432\u0442\u043E\u043C\u0430\u0442\u0438\u0447\u0435\u0441\u043A\u0438 \u0433\u0435\u043D\u0435\u0440\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u0437\u0430\u0433\u043E\u043B\u043E\u0432\u043A\u0438 \u0431\u0435\u0441\u0435\u0434", + desc: "\u0410\u0432\u0442\u043E\u043C\u0430\u0442\u0438\u0447\u0435\u0441\u043A\u0438 \u0433\u0435\u043D\u0435\u0440\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u0437\u0430\u0433\u043E\u043B\u043E\u0432\u043A\u0438 \u0431\u0435\u0441\u0435\u0434 \u043F\u043E\u0441\u043B\u0435 \u043F\u0435\u0440\u0432\u043E\u0433\u043E \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u044F \u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044F." + }, + titleModel: { + name: "\u041C\u043E\u0434\u0435\u043B\u044C \u0433\u0435\u043D\u0435\u0440\u0430\u0446\u0438\u0438 \u0437\u0430\u0433\u043E\u043B\u043E\u0432\u043A\u043E\u0432", + desc: "\u041C\u043E\u0434\u0435\u043B\u044C, \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0435\u043C\u0430\u044F \u0434\u043B\u044F \u0430\u0432\u0442\u043E\u043C\u0430\u0442\u0438\u0447\u0435\u0441\u043A\u043E\u0439 \u0433\u0435\u043D\u0435\u0440\u0430\u0446\u0438\u0438 \u0437\u0430\u0433\u043E\u043B\u043E\u0432\u043A\u043E\u0432 \u0431\u0435\u0441\u0435\u0434.", + auto: "\u0410\u0432\u0442\u043E (Haiku)" + }, + navMappings: { + name: "\u0421\u043E\u043F\u043E\u0441\u0442\u0430\u0432\u043B\u0435\u043D\u0438\u044F \u043D\u0430\u0432\u0438\u0433\u0430\u0446\u0438\u0438 \u0432 \u0441\u0442\u0438\u043B\u0435 Vim", + desc: '\u041F\u043E \u043E\u0434\u043D\u043E\u043C\u0443 \u0441\u043E\u043F\u043E\u0441\u0442\u0430\u0432\u043B\u0435\u043D\u0438\u044E \u0432 \u0441\u0442\u0440\u043E\u043A\u0435. \u0424\u043E\u0440\u043C\u0430\u0442: "map <\u043A\u043B\u044E\u0447> <\u0434\u0435\u0439\u0441\u0442\u0432\u0438\u0435>" (\u0434\u0435\u0439\u0441\u0442\u0432\u0438\u044F: scrollUp, scrollDown, focusInput).' + }, + hotkeys: "\u0413\u043E\u0440\u044F\u0447\u0438\u0435 \u043A\u043B\u0430\u0432\u0438\u0448\u0438", + inlineEditHotkey: { + name: "\u0418\u043D\u043B\u0430\u0439\u043D-\u0440\u0435\u0434\u0430\u043A\u0442\u0438\u0440\u043E\u0432\u0430\u043D\u0438\u0435", + descWithKey: "\u0422\u0435\u043A\u0443\u0449\u0430\u044F \u043A\u043B\u0430\u0432\u0438\u0448\u0430: {hotkey}", + descNoKey: "\u041A\u043B\u0430\u0432\u0438\u0448\u0430 \u043D\u0435 \u043D\u0430\u0437\u043D\u0430\u0447\u0435\u043D\u0430", + btnChange: "\u0418\u0437\u043C\u0435\u043D\u0438\u0442\u044C", + btnSet: "\u041D\u0430\u0437\u043D\u0430\u0447\u0438\u0442\u044C" + }, + openChatHotkey: { + name: "\u041E\u0442\u043A\u0440\u044B\u0442\u044C \u0447\u0430\u0442", + descWithKey: "\u0422\u0435\u043A\u0443\u0449\u0430\u044F \u043A\u043B\u0430\u0432\u0438\u0448\u0430: {hotkey}", + descNoKey: "\u041A\u043B\u0430\u0432\u0438\u0448\u0430 \u043D\u0435 \u043D\u0430\u0437\u043D\u0430\u0447\u0435\u043D\u0430", + btnChange: "\u0418\u0437\u043C\u0435\u043D\u0438\u0442\u044C", + btnSet: "\u041D\u0430\u0437\u043D\u0430\u0447\u0438\u0442\u044C" + }, + newSessionHotkey: { + name: "\u041D\u043E\u0432\u0430\u044F \u0441\u0435\u0441\u0441\u0438\u044F", + descWithKey: "\u0422\u0435\u043A\u0443\u0449\u0430\u044F \u043A\u043B\u0430\u0432\u0438\u0448\u0430: {hotkey}", + descNoKey: "\u041A\u043B\u0430\u0432\u0438\u0448\u0430 \u043D\u0435 \u043D\u0430\u0437\u043D\u0430\u0447\u0435\u043D\u0430", + btnChange: "\u0418\u0437\u043C\u0435\u043D\u0438\u0442\u044C", + btnSet: "\u041D\u0430\u0437\u043D\u0430\u0447\u0438\u0442\u044C" + }, + newTabHotkey: { + name: "\u041D\u043E\u0432\u0430\u044F \u0432\u043A\u043B\u0430\u0434\u043A\u0430", + descWithKey: "\u0422\u0435\u043A\u0443\u0449\u0430\u044F \u043A\u043B\u0430\u0432\u0438\u0448\u0430: {hotkey}", + descNoKey: "\u041A\u043B\u0430\u0432\u0438\u0448\u0430 \u043D\u0435 \u043D\u0430\u0437\u043D\u0430\u0447\u0435\u043D\u0430", + btnChange: "\u0418\u0437\u043C\u0435\u043D\u0438\u0442\u044C", + btnSet: "\u041D\u0430\u0437\u043D\u0430\u0447\u0438\u0442\u044C" + }, + closeTabHotkey: { + name: "\u0417\u0430\u043A\u0440\u044B\u0442\u044C \u0432\u043A\u043B\u0430\u0434\u043A\u0443", + descWithKey: "\u0422\u0435\u043A\u0443\u0449\u0430\u044F \u043A\u043B\u0430\u0432\u0438\u0448\u0430: {hotkey}", + descNoKey: "\u041A\u043B\u0430\u0432\u0438\u0448\u0430 \u043D\u0435 \u043D\u0430\u0437\u043D\u0430\u0447\u0435\u043D\u0430", + btnChange: "\u0418\u0437\u043C\u0435\u043D\u0438\u0442\u044C", + btnSet: "\u041D\u0430\u0437\u043D\u0430\u0447\u0438\u0442\u044C" + }, + slashCommands: { + name: "\u041A\u043E\u043C\u0430\u043D\u0434\u044B \u0438 \u043D\u0430\u0432\u044B\u043A\u0438", + desc: "\u0423\u043F\u0440\u0430\u0432\u043B\u0435\u043D\u0438\u0435 \u043A\u043E\u043C\u0430\u043D\u0434\u0430\u043C\u0438 \u0438 \u043D\u0430\u0432\u044B\u043A\u0430\u043C\u0438 \u043D\u0430 \u0443\u0440\u043E\u0432\u043D\u0435 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430, \u0440\u0430\u0441\u043F\u043E\u043B\u043E\u0436\u0435\u043D\u043D\u044B\u043C\u0438 \u0432 .claude/commands/ \u0438 .claude/skills/. \u0417\u0430\u043F\u0443\u0441\u043A\u0430\u044E\u0442\u0441\u044F \u0447\u0435\u0440\u0435\u0437 /\u0438\u043C\u044F." + }, + hiddenSlashCommands: { + name: "\u0421\u043A\u0440\u044B\u0442\u044B\u0435 \u043A\u043E\u043C\u0430\u043D\u0434\u044B", + desc: "\u0421\u043A\u0440\u044B\u0442\u044C \u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0451\u043D\u043D\u044B\u0435 \u043A\u043E\u043C\u0430\u043D\u0434\u044B \u0441\u043E \u0441\u043B\u044D\u0448\u0435\u043C \u0438\u0437 \u0432\u044B\u043F\u0430\u0434\u0430\u044E\u0449\u0435\u0433\u043E \u0441\u043F\u0438\u0441\u043A\u0430. \u041F\u043E\u043B\u0435\u0437\u043D\u043E \u0434\u043B\u044F \u0441\u043A\u0440\u044B\u0442\u0438\u044F \u043A\u043E\u043C\u0430\u043D\u0434 Claude Code, \u043A\u043E\u0442\u043E\u0440\u044B\u0435 \u043D\u0435 \u0430\u043A\u0442\u0443\u0430\u043B\u044C\u043D\u044B \u0434\u043B\u044F Claudian. \u0412\u0432\u043E\u0434\u0438\u0442\u0435 \u0438\u043C\u0435\u043D\u0430 \u043A\u043E\u043C\u0430\u043D\u0434 \u0431\u0435\u0437 \u043D\u0430\u0447\u0430\u043B\u044C\u043D\u043E\u0433\u043E \u0441\u043B\u044D\u0448\u0430, \u043F\u043E \u043E\u0434\u043D\u043E\u0439 \u043D\u0430 \u0441\u0442\u0440\u043E\u043A\u0443.", + placeholder: "commit\nbuild\ntest" + }, + mcpServers: { + name: "MCP \u0441\u0435\u0440\u0432\u0435\u0440\u044B", + desc: "\u0423\u043F\u0440\u0430\u0432\u043B\u0435\u043D\u0438\u0435 \u043A\u043E\u043D\u0444\u0438\u0433\u0443\u0440\u0430\u0446\u0438\u044F\u043C\u0438 MCP-\u0441\u0435\u0440\u0432\u0435\u0440\u043E\u0432 \u043D\u0430 \u0443\u0440\u043E\u0432\u043D\u0435 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430 \u0432 .claude/mcp.json. \u0421\u0435\u0440\u0432\u0435\u0440\u044B \u0441 \u0440\u0435\u0436\u0438\u043C\u043E\u043C \u0441\u043E\u0445\u0440\u0430\u043D\u0435\u043D\u0438\u044F \u043A\u043E\u043D\u0442\u0435\u043A\u0441\u0442\u0430 \u0442\u0440\u0435\u0431\u0443\u044E\u0442 @mention \u0434\u043B\u044F \u0430\u043A\u0442\u0438\u0432\u0430\u0446\u0438\u0438." + }, + plugins: { + name: "\u041F\u043B\u0430\u0433\u0438\u043D\u044B Claude Code", + desc: "\u0423\u043F\u0440\u0430\u0432\u043B\u0435\u043D\u0438\u0435 \u043F\u043B\u0430\u0433\u0438\u043D\u0430\u043C\u0438 Claude Code \u0438\u0437 ~/.claude/plugins. \u0412\u043A\u043B\u044E\u0447\u0435\u043D\u043D\u044B\u0435 \u043F\u043B\u0430\u0433\u0438\u043D\u044B \u0441\u043E\u0445\u0440\u0430\u043D\u044F\u044E\u0442\u0441\u044F \u0434\u043B\u044F \u043A\u0430\u0436\u0434\u043E\u0433\u043E \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430 \u0432 .claude/settings.json." + }, + subagents: { + name: "\u0421\u0443\u0431\u0430\u0433\u0435\u043D\u0442\u044B", + desc: "\u0423\u043F\u0440\u0430\u0432\u043B\u0435\u043D\u0438\u0435 \u0441\u0443\u0431\u0430\u0433\u0435\u043D\u0442\u0430\u043C\u0438 \u043D\u0430 \u0443\u0440\u043E\u0432\u043D\u0435 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430 \u0432 .claude/agents/. \u041A\u0430\u0436\u0434\u044B\u0439 Markdown-\u0444\u0430\u0439\u043B \u043E\u043F\u0440\u0435\u0434\u0435\u043B\u044F\u0435\u0442 \u043E\u0434\u043D\u043E\u0433\u043E \u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044C\u0441\u043A\u043E\u0433\u043E \u0430\u0433\u0435\u043D\u0442\u0430.", + noAgents: "\u0421\u0443\u0431\u0430\u0433\u0435\u043D\u0442\u044B \u043D\u0435 \u043D\u0430\u0441\u0442\u0440\u043E\u0435\u043D\u044B. \u041D\u0430\u0436\u043C\u0438\u0442\u0435 +, \u0447\u0442\u043E\u0431\u044B \u0441\u043E\u0437\u0434\u0430\u0442\u044C \u043E\u0434\u043D\u043E\u0433\u043E.", + deleteConfirm: '\u0423\u0434\u0430\u043B\u0438\u0442\u044C \u0441\u0443\u0431\u0430\u0433\u0435\u043D\u0442\u0430 "{name}"?', + saveFailed: "\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0441\u043E\u0445\u0440\u0430\u043D\u0438\u0442\u044C \u0441\u0443\u0431\u0430\u0433\u0435\u043D\u0442\u0430: {message}", + refreshFailed: "\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043E\u0431\u043D\u043E\u0432\u0438\u0442\u044C \u0441\u0443\u0431\u0430\u0433\u0435\u043D\u0442\u043E\u0432: {message}", + deleteFailed: "\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0443\u0434\u0430\u043B\u0438\u0442\u044C \u0441\u0443\u0431\u0430\u0433\u0435\u043D\u0442\u0430: {message}", + renameCleanupFailed: '\u041F\u0440\u0435\u0434\u0443\u043F\u0440\u0435\u0436\u0434\u0435\u043D\u0438\u0435: \u043D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0443\u0434\u0430\u043B\u0438\u0442\u044C \u0441\u0442\u0430\u0440\u044B\u0439 \u0444\u0430\u0439\u043B \u0434\u043B\u044F "{name}"', + created: '\u0421\u0443\u0431\u0430\u0433\u0435\u043D\u0442 "{name}" \u0441\u043E\u0437\u0434\u0430\u043D', + updated: '\u0421\u0443\u0431\u0430\u0433\u0435\u043D\u0442 "{name}" \u043E\u0431\u043D\u043E\u0432\u043B\u0451\u043D', + deleted: '\u0421\u0443\u0431\u0430\u0433\u0435\u043D\u0442 "{name}" \u0443\u0434\u0430\u043B\u0451\u043D', + duplicateName: '\u0410\u0433\u0435\u043D\u0442 \u0441 \u0438\u043C\u0435\u043D\u0435\u043C "{name}" \u0443\u0436\u0435 \u0441\u0443\u0449\u0435\u0441\u0442\u0432\u0443\u0435\u0442', + descriptionRequired: "\u041E\u043F\u0438\u0441\u0430\u043D\u0438\u0435 \u043E\u0431\u044F\u0437\u0430\u0442\u0435\u043B\u044C\u043D\u043E", + promptRequired: "\u0421\u0438\u0441\u0442\u0435\u043C\u043D\u044B\u0439 \u043F\u0440\u043E\u043C\u043F\u0442 \u043E\u0431\u044F\u0437\u0430\u0442\u0435\u043B\u0435\u043D", + modal: { + titleEdit: "\u0420\u0435\u0434\u0430\u043A\u0442\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u0441\u0443\u0431\u0430\u0433\u0435\u043D\u0442\u0430", + titleAdd: "\u0414\u043E\u0431\u0430\u0432\u0438\u0442\u044C \u0441\u0443\u0431\u0430\u0433\u0435\u043D\u0442\u0430", + name: "\u0418\u043C\u044F", + nameDesc: "\u0422\u043E\u043B\u044C\u043A\u043E \u0441\u0442\u0440\u043E\u0447\u043D\u044B\u0435 \u0431\u0443\u043A\u0432\u044B, \u0446\u0438\u0444\u0440\u044B \u0438 \u0434\u0435\u0444\u0438\u0441\u044B", + namePlaceholder: "code-reviewer", + description: "\u041E\u043F\u0438\u0441\u0430\u043D\u0438\u0435", + descriptionDesc: "\u041A\u0440\u0430\u0442\u043A\u043E\u0435 \u043E\u043F\u0438\u0441\u0430\u043D\u0438\u0435 \u044D\u0442\u043E\u0433\u043E \u0430\u0433\u0435\u043D\u0442\u0430", + descriptionPlaceholder: "\u041F\u0440\u043E\u0432\u0435\u0440\u044F\u0435\u0442 \u043A\u043E\u0434 \u043D\u0430 \u043E\u0448\u0438\u0431\u043A\u0438 \u0438 \u0441\u0442\u0438\u043B\u044C", + advancedOptions: "\u0414\u043E\u043F\u043E\u043B\u043D\u0438\u0442\u0435\u043B\u044C\u043D\u044B\u0435 \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440\u044B", + model: "\u041C\u043E\u0434\u0435\u043B\u044C", + modelDesc: "\u041F\u0435\u0440\u0435\u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0435\u043D\u0438\u0435 \u043C\u043E\u0434\u0435\u043B\u0438 \u0434\u043B\u044F \u044D\u0442\u043E\u0433\u043E \u0430\u0433\u0435\u043D\u0442\u0430", + tools: "\u0418\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u044B", + toolsDesc: "\u0421\u043F\u0438\u0441\u043E\u043A \u0440\u0430\u0437\u0440\u0435\u0448\u0451\u043D\u043D\u044B\u0445 \u0438\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u043E\u0432 \u0447\u0435\u0440\u0435\u0437 \u0437\u0430\u043F\u044F\u0442\u0443\u044E (\u043F\u0443\u0441\u0442\u043E = \u0432\u0441\u0435)", + disallowedTools: "\u0417\u0430\u043F\u0440\u0435\u0449\u0451\u043D\u043D\u044B\u0435 \u0438\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u044B", + disallowedToolsDesc: "\u0421\u043F\u0438\u0441\u043E\u043A \u0438\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u043E\u0432, \u043A\u043E\u0442\u043E\u0440\u044B\u0435 \u043D\u0443\u0436\u043D\u043E \u0437\u0430\u043F\u0440\u0435\u0442\u0438\u0442\u044C, \u0447\u0435\u0440\u0435\u0437 \u0437\u0430\u043F\u044F\u0442\u0443\u044E", + skills: "\u041D\u0430\u0432\u044B\u043A\u0438", + skillsDesc: "\u0421\u043F\u0438\u0441\u043E\u043A \u043D\u0430\u0432\u044B\u043A\u043E\u0432 \u0447\u0435\u0440\u0435\u0437 \u0437\u0430\u043F\u044F\u0442\u0443\u044E", + prompt: "\u0421\u0438\u0441\u0442\u0435\u043C\u043D\u044B\u0439 \u043F\u0440\u043E\u043C\u043F\u0442", + promptDesc: "\u0418\u043D\u0441\u0442\u0440\u0443\u043A\u0446\u0438\u0438 \u0434\u043B\u044F \u0430\u0433\u0435\u043D\u0442\u0430", + promptPlaceholder: "\u0412\u044B \u0441\u043F\u0435\u0446\u0438\u0430\u043B\u0438\u0441\u0442 \u043F\u043E \u043F\u0440\u043E\u0432\u0435\u0440\u043A\u0435 \u043A\u043E\u0434\u0430. \u041F\u0440\u043E\u0430\u043D\u0430\u043B\u0438\u0437\u0438\u0440\u0443\u0439\u0442\u0435 \u043F\u0440\u0435\u0434\u043E\u0441\u0442\u0430\u0432\u043B\u0435\u043D\u043D\u044B\u0439 \u043A\u043E\u0434 \u043D\u0430 \u043F\u0440\u0435\u0434\u043C\u0435\u0442..." + } + }, + safety: "\u0411\u0435\u0437\u043E\u043F\u0430\u0441\u043D\u043E\u0441\u0442\u044C", + loadUserSettings: { + name: "\u0417\u0430\u0433\u0440\u0443\u0436\u0430\u0442\u044C \u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044C\u0441\u043A\u0438\u0435 \u043D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u0438 Claude", + desc: "\u0417\u0430\u0433\u0440\u0443\u0436\u0430\u0435\u0442 ~/.claude/settings.json. \u041F\u0440\u0438 \u0432\u043A\u043B\u044E\u0447\u0435\u043D\u0438\u0438 \u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044C\u0441\u043A\u0438\u0435 \u043F\u0440\u0430\u0432\u0438\u043B\u0430 \u0440\u0430\u0437\u0440\u0435\u0448\u0435\u043D\u0438\u0439 Claude Code \u043C\u043E\u0433\u0443\u0442 \u043E\u0431\u0445\u043E\u0434\u0438\u0442\u044C \u0431\u0435\u0437\u043E\u043F\u0430\u0441\u043D\u044B\u0439 \u0440\u0435\u0436\u0438\u043C." + }, + claudeSafeMode: { + name: "Safe mode", + desc: "Permission mode used when the Safe toggle is active." + }, + codexSafeMode: { + name: "Safe mode", + desc: "Sandbox mode used when the Safe toggle is active." + }, + environment: "\u041E\u043A\u0440\u0443\u0436\u0435\u043D\u0438\u0435", + customVariables: { + name: "\u041F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044C\u0441\u043A\u0438\u0435 \u043F\u0435\u0440\u0435\u043C\u0435\u043D\u043D\u044B\u0435", + desc: "\u041F\u0435\u0440\u0435\u043C\u0435\u043D\u043D\u044B\u0435 \u043E\u043A\u0440\u0443\u0436\u0435\u043D\u0438\u044F \u0434\u043B\u044F Claude SDK (\u0444\u043E\u0440\u043C\u0430\u0442 KEY=VALUE, \u043F\u043E \u043E\u0434\u043D\u043E\u0439 \u0432 \u0441\u0442\u0440\u043E\u043A\u0435). \u041F\u0440\u0435\u0444\u0438\u043A\u0441 export \u043F\u043E\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u0442\u0441\u044F." + }, + envSnippets: { + name: "\u0421\u043D\u0438\u043F\u043F\u0435\u0442\u044B", + addBtn: "\u0414\u043E\u0431\u0430\u0432\u0438\u0442\u044C \u0441\u043D\u0438\u043F\u043F\u0435\u0442", + noSnippets: "\u041D\u0435\u0442 \u0441\u043E\u0445\u0440\u0430\u043D\u0435\u043D\u043D\u044B\u0445 \u0441\u043D\u0438\u043F\u043F\u0435\u0442\u043E\u0432 \u043E\u043A\u0440\u0443\u0436\u0435\u043D\u0438\u044F. \u041D\u0430\u0436\u043C\u0438\u0442\u0435 +, \u0447\u0442\u043E\u0431\u044B \u0441\u043E\u0445\u0440\u0430\u043D\u0438\u0442\u044C \u0442\u0435\u043A\u0443\u0449\u0443\u044E \u043A\u043E\u043D\u0444\u0438\u0433\u0443\u0440\u0430\u0446\u0438\u044E.", + nameRequired: "\u041F\u043E\u0436\u0430\u043B\u0443\u0439\u0441\u0442\u0430, \u0432\u0432\u0435\u0434\u0438\u0442\u0435 \u043D\u0430\u0437\u0432\u0430\u043D\u0438\u0435 \u0441\u043D\u0438\u043F\u043F\u0435\u0442\u0430", + modal: { + titleEdit: "\u0420\u0435\u0434\u0430\u043A\u0442\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u0441\u043D\u0438\u043F\u043F\u0435\u0442", + titleSave: "\u0421\u043E\u0445\u0440\u0430\u043D\u0438\u0442\u044C \u0441\u043D\u0438\u043F\u043F\u0435\u0442", + name: "\u0418\u043C\u044F", + namePlaceholder: "\u041E\u043F\u0438\u0441\u0430\u0442\u0435\u043B\u044C\u043D\u043E\u0435 \u043D\u0430\u0437\u0432\u0430\u043D\u0438\u0435 \u0434\u043B\u044F \u044D\u0442\u043E\u0439 \u043A\u043E\u043D\u0444\u0438\u0433\u0443\u0440\u0430\u0446\u0438\u0438", + description: "\u041E\u043F\u0438\u0441\u0430\u043D\u0438\u0435", + descPlaceholder: "\u041E\u043F\u0446\u0438\u043E\u043D\u0430\u043B\u044C\u043D\u043E\u0435 \u043E\u043F\u0438\u0441\u0430\u043D\u0438\u0435", + envVars: "\u041F\u0435\u0440\u0435\u043C\u0435\u043D\u043D\u044B\u0435 \u043E\u043A\u0440\u0443\u0436\u0435\u043D\u0438\u044F", + envVarsPlaceholder: "\u0424\u043E\u0440\u043C\u0430\u0442 KEY=VALUE, \u043F\u043E \u043E\u0434\u043D\u043E\u0439 \u0432 \u0441\u0442\u0440\u043E\u043A\u0435 (\u043F\u0440\u0435\u0444\u0438\u043A\u0441 export \u043F\u043E\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u0442\u0441\u044F)", + save: "\u0421\u043E\u0445\u0440\u0430\u043D\u0438\u0442\u044C", + update: "\u041E\u0431\u043D\u043E\u0432\u0438\u0442\u044C", + cancel: "\u041E\u0442\u043C\u0435\u043D\u0430" + } + }, + customContextLimits: { + name: "\u041F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044C\u0441\u043A\u0438\u0435 \u043B\u0438\u043C\u0438\u0442\u044B \u043A\u043E\u043D\u0442\u0435\u043A\u0441\u0442\u0430", + desc: "\u0423\u0441\u0442\u0430\u043D\u043E\u0432\u0438\u0442\u0435 \u0440\u0430\u0437\u043C\u0435\u0440\u044B \u043E\u043A\u043D\u0430 \u043A\u043E\u043D\u0442\u0435\u043A\u0441\u0442\u0430 \u0434\u043B\u044F \u0432\u0430\u0448\u0438\u0445 \u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044C\u0441\u043A\u0438\u0445 \u043C\u043E\u0434\u0435\u043B\u0435\u0439. \u041E\u0441\u0442\u0430\u0432\u044C\u0442\u0435 \u043F\u0443\u0441\u0442\u044B\u043C \u0434\u043B\u044F \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u043D\u0438\u044F \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u044F \u043F\u043E \u0443\u043C\u043E\u043B\u0447\u0430\u043D\u0438\u044E (200k \u0442\u043E\u043A\u0435\u043D\u043E\u0432).", + invalid: "\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0444\u043E\u0440\u043C\u0430\u0442. \u0418\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439\u0442\u0435: 256k, 1m \u0438\u043B\u0438 \u0442\u043E\u0447\u043D\u043E\u0435 \u0447\u0438\u0441\u043B\u043E (1000-10000000)." + }, + enableOpus1M: { + name: "\u041A\u043E\u043D\u0442\u0435\u043A\u0441\u0442\u043D\u043E\u0435 \u043E\u043A\u043D\u043E Opus 1M", + desc: "\u041F\u043E\u043A\u0430\u0437\u0430\u0442\u044C Opus 1M \u0432 \u0441\u0435\u043B\u0435\u043A\u0442\u043E\u0440\u0435 \u043C\u043E\u0434\u0435\u043B\u0435\u0439. \u0412\u043A\u043B\u044E\u0447\u0435\u043D\u043E \u0432 \u043F\u043B\u0430\u043D\u044B Max, Team \u0438 Enterprise. \u041F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044F\u043C API \u0438 Pro \u0442\u0440\u0435\u0431\u0443\u0435\u0442\u0441\u044F \u0434\u043E\u043F\u043E\u043B\u043D\u0438\u0442\u0435\u043B\u044C\u043D\u043E\u0435 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u043D\u0438\u0435." + }, + enableSonnet1M: { + name: "\u041A\u043E\u043D\u0442\u0435\u043A\u0441\u0442\u043D\u043E\u0435 \u043E\u043A\u043D\u043E Sonnet 1M", + desc: "\u041F\u043E\u043A\u0430\u0437\u0430\u0442\u044C Sonnet 1M \u0432 \u0441\u0435\u043B\u0435\u043A\u0442\u043E\u0440\u0435 \u043C\u043E\u0434\u0435\u043B\u0435\u0439. \u0422\u0440\u0435\u0431\u0443\u0435\u0442\u0441\u044F \u0434\u043E\u043F\u043E\u043B\u043D\u0438\u0442\u0435\u043B\u044C\u043D\u043E\u0435 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u043D\u0438\u0435 \u0432 \u043F\u043B\u0430\u043D\u0430\u0445 Max, Team \u0438 Enterprise. \u041F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044F\u043C API \u0438 Pro \u0442\u0440\u0435\u0431\u0443\u0435\u0442\u0441\u044F \u0434\u043E\u043F\u043E\u043B\u043D\u0438\u0442\u0435\u043B\u044C\u043D\u043E\u0435 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u043D\u0438\u0435." + }, + enableChrome: { + name: "\u0412\u043A\u043B\u044E\u0447\u0438\u0442\u044C \u0440\u0430\u0441\u0448\u0438\u0440\u0435\u043D\u0438\u0435 Chrome", + desc: "\u0420\u0430\u0437\u0440\u0435\u0448\u0438\u0442\u044C Claude \u0432\u0437\u0430\u0438\u043C\u043E\u0434\u0435\u0439\u0441\u0442\u0432\u043E\u0432\u0430\u0442\u044C \u0441 Chrome \u0447\u0435\u0440\u0435\u0437 \u0440\u0430\u0441\u0448\u0438\u0440\u0435\u043D\u0438\u0435 claude-in-chrome. \u0422\u0440\u0435\u0431\u0443\u0435\u0442\u0441\u044F \u0443\u0441\u0442\u0430\u043D\u043E\u0432\u043A\u0430 \u0440\u0430\u0441\u0448\u0438\u0440\u0435\u043D\u0438\u044F. \u0422\u0440\u0435\u0431\u0443\u0435\u0442\u0441\u044F \u043F\u0435\u0440\u0435\u0437\u0430\u043F\u0443\u0441\u043A \u0441\u0435\u0441\u0441\u0438\u0438." + }, + enableBangBash: { + name: "\u0412\u043A\u043B\u044E\u0447\u0438\u0442\u044C \u0440\u0435\u0436\u0438\u043C bash (!)", + desc: "\u0412\u0432\u0435\u0434\u0438\u0442\u0435 ! \u0432 \u043F\u0443\u0441\u0442\u043E\u043C \u043F\u043E\u043B\u0435 \u0432\u0432\u043E\u0434\u0430, \u0447\u0442\u043E\u0431\u044B \u043F\u0435\u0440\u0435\u0439\u0442\u0438 \u0432 \u0440\u0435\u0436\u0438\u043C bash. \u041A\u043E\u043C\u0430\u043D\u0434\u044B \u0432\u044B\u043F\u043E\u043B\u043D\u044F\u044E\u0442\u0441\u044F \u043D\u0430\u043F\u0440\u044F\u043C\u0443\u044E \u0447\u0435\u0440\u0435\u0437 Node.js child_process. \u0422\u0440\u0435\u0431\u0443\u0435\u0442\u0441\u044F \u043F\u043E\u0432\u0442\u043E\u0440\u043D\u043E \u043E\u0442\u043A\u0440\u044B\u0442\u044C \u043F\u0440\u0435\u0434\u0441\u0442\u0430\u0432\u043B\u0435\u043D\u0438\u0435.", + validation: { + noNode: "Node.js \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D \u0432 PATH. \u0423\u0441\u0442\u0430\u043D\u043E\u0432\u0438\u0442\u0435 Node.js \u0438\u043B\u0438 \u043F\u0440\u043E\u0432\u0435\u0440\u044C\u0442\u0435 \u043D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u0443 PATH." + } + }, + maxTabs: { + name: "\u041C\u0430\u043A\u0441\u0438\u043C\u0443\u043C \u0432\u043A\u043B\u0430\u0434\u043E\u043A \u0447\u0430\u0442\u0430", + desc: "\u041C\u0430\u043A\u0441\u0438\u043C\u0430\u043B\u044C\u043D\u043E\u0435 \u043A\u043E\u043B\u0438\u0447\u0435\u0441\u0442\u0432\u043E \u043E\u0434\u043D\u043E\u0432\u0440\u0435\u043C\u0435\u043D\u043D\u044B\u0445 \u0432\u043A\u043B\u0430\u0434\u043E\u043A \u0447\u0430\u0442\u0430 (3-10). \u041A\u0430\u0436\u0434\u0430\u044F \u0432\u043A\u043B\u0430\u0434\u043A\u0430 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0435\u0442 \u043E\u0442\u0434\u0435\u043B\u044C\u043D\u0443\u044E \u0441\u0435\u0441\u0441\u0438\u044E Claude.", + warning: "\u0411\u043E\u043B\u0435\u0435 5 \u0432\u043A\u043B\u0430\u0434\u043E\u043A \u043C\u043E\u0436\u0435\u0442 \u043F\u043E\u0432\u043B\u0438\u044F\u0442\u044C \u043D\u0430 \u043F\u0440\u043E\u0438\u0437\u0432\u043E\u0434\u0438\u0442\u0435\u043B\u044C\u043D\u043E\u0441\u0442\u044C \u0438 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u043D\u0438\u0435 \u043F\u0430\u043C\u044F\u0442\u0438." + }, + tabBarPosition: { + name: "\u041F\u043E\u043B\u043E\u0436\u0435\u043D\u0438\u0435 \u043F\u0430\u043D\u0435\u043B\u0438 \u0432\u043A\u043B\u0430\u0434\u043E\u043A", + desc: "\u0412\u044B\u0431\u0435\u0440\u0438\u0442\u0435, \u0433\u0434\u0435 \u043E\u0442\u043E\u0431\u0440\u0430\u0436\u0430\u0442\u044C \u0437\u043D\u0430\u0447\u043A\u0438 \u0432\u043A\u043B\u0430\u0434\u043E\u043A \u0438 \u043A\u043D\u043E\u043F\u043A\u0438 \u0434\u0435\u0439\u0441\u0442\u0432\u0438\u0439", + input: "\u041D\u0430\u0434 \u043F\u043E\u043B\u0435\u043C \u0432\u0432\u043E\u0434\u0430 (\u043F\u043E \u0443\u043C\u043E\u043B\u0447\u0430\u043D\u0438\u044E)", + header: "\u0412 \u0437\u0430\u0433\u043E\u043B\u043E\u0432\u043A\u0435" + }, + enableAutoScroll: { + name: "\u0410\u0432\u0442\u043E\u043F\u0440\u043E\u043A\u0440\u0443\u0442\u043A\u0430 \u0432\u043E \u0432\u0440\u0435\u043C\u044F \u043F\u043E\u0442\u043E\u043A\u043E\u0432\u043E\u0439 \u043F\u0435\u0440\u0435\u0434\u0430\u0447\u0438", + desc: "\u0410\u0432\u0442\u043E\u043C\u0430\u0442\u0438\u0447\u0435\u0441\u043A\u0438 \u043F\u0440\u043E\u043A\u0440\u0443\u0447\u0438\u0432\u0430\u0442\u044C \u0432\u043D\u0438\u0437, \u043F\u043E\u043A\u0430 Claude \u043F\u0435\u0440\u0435\u0434\u0430\u0435\u0442 \u043E\u0442\u0432\u0435\u0442\u044B. \u041E\u0442\u043A\u043B\u044E\u0447\u0438\u0442\u0435, \u0447\u0442\u043E\u0431\u044B \u043E\u0441\u0442\u0430\u0432\u0430\u0442\u044C\u0441\u044F \u043D\u0430\u0432\u0435\u0440\u0445\u0443 \u0438 \u0447\u0438\u0442\u0430\u0442\u044C \u0441 \u043D\u0430\u0447\u0430\u043B\u0430." + }, + openInMainTab: { + name: "\u041E\u0442\u043A\u0440\u044B\u0432\u0430\u0442\u044C \u0432 \u043E\u0441\u043D\u043E\u0432\u043D\u043E\u0439 \u043E\u0431\u043B\u0430\u0441\u0442\u0438 \u0440\u0435\u0434\u0430\u043A\u0442\u043E\u0440\u0430", + desc: "\u041E\u0442\u043A\u0440\u044B\u0432\u0430\u0442\u044C \u043F\u0430\u043D\u0435\u043B\u044C \u0447\u0430\u0442\u0430 \u0432 \u0432\u0438\u0434\u0435 \u043E\u0441\u043D\u043E\u0432\u043D\u043E\u0439 \u0432\u043A\u043B\u0430\u0434\u043A\u0438 \u0432 \u0446\u0435\u043D\u0442\u0440\u0430\u043B\u044C\u043D\u043E\u0439 \u043E\u0431\u043B\u0430\u0441\u0442\u0438 \u0440\u0435\u0434\u0430\u043A\u0442\u043E\u0440\u0430 \u0432\u043C\u0435\u0441\u0442\u043E \u043F\u0440\u0430\u0432\u043E\u0439 \u0431\u043E\u043A\u043E\u0432\u043E\u0439 \u043F\u0430\u043D\u0435\u043B\u0438" + }, + cliPath: { + name: "\u041F\u0443\u0442\u044C \u043A CLI Claude", + desc: "\u041F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044C\u0441\u043A\u0438\u0439 \u043F\u0443\u0442\u044C \u043A Claude Code CLI. \u041E\u0441\u0442\u0430\u0432\u044C\u0442\u0435 \u043F\u0443\u0441\u0442\u044B\u043C \u0434\u043B\u044F \u0430\u0432\u0442\u043E\u043C\u0430\u0442\u0438\u0447\u0435\u0441\u043A\u043E\u0433\u043E \u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0435\u043D\u0438\u044F.", + descWindows: "\u0414\u043B\u044F \u043D\u0430\u0442\u0438\u0432\u043D\u043E\u0433\u043E \u0443\u0441\u0442\u0430\u043D\u043E\u0432\u0449\u0438\u043A\u0430 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439\u0442\u0435 claude.exe. \u0414\u043B\u044F \u0443\u0441\u0442\u0430\u043D\u043E\u0432\u043E\u043A \u0447\u0435\u0440\u0435\u0437 npm/pnpm/yarn \u0438\u043B\u0438 \u0434\u0440\u0443\u0433\u0438\u0435 \u043C\u0435\u043D\u0435\u0434\u0436\u0435\u0440\u044B \u043F\u0430\u043A\u0435\u0442\u043E\u0432 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439\u0442\u0435 \u043F\u0443\u0442\u044C \u043A cli.js (\u043D\u0435 claude.cmd).", + descUnix: '\u0412\u0441\u0442\u0430\u0432\u044C\u0442\u0435 \u0432\u044B\u0432\u043E\u0434 \u043A\u043E\u043C\u0430\u043D\u0434\u044B "which claude" \u2014 \u0440\u0430\u0431\u043E\u0442\u0430\u0435\u0442 \u043A\u0430\u043A \u0434\u043B\u044F \u043D\u0430\u0442\u0438\u0432\u043D\u044B\u0445 \u0443\u0441\u0442\u0430\u043D\u043E\u0432\u043E\u043A, \u0442\u0430\u043A \u0438 \u0434\u043B\u044F npm/pnpm/yarn.', + validation: { + notExist: "\u041F\u0443\u0442\u044C \u043D\u0435 \u0441\u0443\u0449\u0435\u0441\u0442\u0432\u0443\u0435\u0442", + isDirectory: "\u041F\u0443\u0442\u044C \u044F\u0432\u043B\u044F\u0435\u0442\u0441\u044F \u0434\u0438\u0440\u0435\u043A\u0442\u043E\u0440\u0438\u0435\u0439, \u0430 \u043D\u0435 \u0444\u0430\u0439\u043B\u043E\u043C" + } + }, + language: { + name: "\u042F\u0437\u044B\u043A", + desc: "\u0418\u0437\u043C\u0435\u043D\u0438\u0442\u044C \u044F\u0437\u044B\u043A \u0438\u043D\u0442\u0435\u0440\u0444\u0435\u0439\u0441\u0430 \u043F\u043B\u0430\u0433\u0438\u043D\u0430" + } +}; +var ru_default = { + common: common8, + chat: chat8, + settings: settings8 +}; + +// src/i18n/locales/zh-CN.json +var zh_CN_exports = {}; +__export(zh_CN_exports, { + chat: () => chat9, + common: () => common9, + default: () => zh_CN_default, + settings: () => settings9 +}); +var common9 = { + save: "\u4FDD\u5B58", + cancel: "\u53D6\u6D88", + delete: "\u5220\u9664", + edit: "\u7F16\u8F91", + add: "\u6DFB\u52A0", + remove: "\u79FB\u9664", + clear: "\u6E05\u9664", + clearAll: "\u6E05\u9664\u5168\u90E8", + loading: "\u52A0\u8F7D\u4E2D", + error: "\u9519\u8BEF", + success: "\u6210\u529F", + warning: "\u8B66\u544A", + confirm: "\u786E\u8BA4", + settings: "\u8BBE\u7F6E", + advanced: "\u9AD8\u7EA7", + enabled: "\u5DF2\u542F\u7528", + disabled: "\u5DF2\u7981\u7528", + platform: "\u5E73\u53F0", + refresh: "\u5237\u65B0", + rewind: "\u56DE\u9000" +}; +var chat9 = { + rewind: { + confirmMessage: "\u56DE\u9000\u5230\u6B64\u5904\uFF1F\u6B64\u6D88\u606F\u4E4B\u540E\u7684\u6587\u4EF6\u66F4\u6539\u5C06\u88AB\u8FD8\u539F\u3002\u56DE\u9000\u4E0D\u4F1A\u5F71\u54CD\u624B\u52A8\u6216\u901A\u8FC7 bash \u7F16\u8F91\u7684\u6587\u4EF6\u3002", + confirmButton: "\u56DE\u9000", + ariaLabel: "\u56DE\u9000\u5230\u6B64\u5904", + notice: "\u5DF2\u56DE\u9000\uFF1A\u8FD8\u539F\u4E86 {count} \u4E2A\u6587\u4EF6", + noticeSaveFailed: "\u5DF2\u56DE\u9000\uFF1A\u8FD8\u539F\u4E86 {count} \u4E2A\u6587\u4EF6\uFF0C\u4F46\u65E0\u6CD5\u4FDD\u5B58\u72B6\u6001\uFF1A{error}", + failed: "\u56DE\u9000\u5931\u8D25\uFF1A{error}", + cannot: "\u65E0\u6CD5\u56DE\u9000\uFF1A{error}", + unavailableStreaming: "\u6D41\u5F0F\u54CD\u5E94\u4E2D\u65E0\u6CD5\u56DE\u9000", + unavailableNoUuid: "\u65E0\u6CD5\u56DE\u9000\uFF1A\u7F3A\u5C11\u6D88\u606F\u6807\u8BC6\u7B26" + }, + fork: { + ariaLabel: "\u5206\u53C9\u5BF9\u8BDD", + chooseTarget: "\u5206\u53C9\u5BF9\u8BDD", + targetNewTab: "\u65B0\u6807\u7B7E\u9875", + targetCurrentTab: "\u5F53\u524D\u6807\u7B7E\u9875", + maxTabsReached: "\u65E0\u6CD5\u5206\u53C9\uFF1A\u5DF2\u8FBE\u5230\u6700\u5927 {count} \u4E2A\u6807\u7B7E\u9875", + notice: "\u5DF2\u5206\u53C9\u5230\u65B0\u6807\u7B7E\u9875", + noticeCurrentTab: "\u5DF2\u5728\u5F53\u524D\u6807\u7B7E\u9875\u5206\u53C9", + failed: "\u5206\u53C9\u5931\u8D25\uFF1A{error}", + unavailableStreaming: "\u6D41\u5F0F\u54CD\u5E94\u4E2D\u65E0\u6CD5\u5206\u53C9", + unavailableNoUuid: "\u65E0\u6CD5\u5206\u53C9\uFF1A\u7F3A\u5C11\u6D88\u606F\u6807\u8BC6\u7B26", + unavailableNoResponse: "\u65E0\u6CD5\u5206\u53C9\uFF1A\u6CA1\u6709\u53EF\u5206\u53C9\u7684\u54CD\u5E94", + errorMessageNotFound: "\u672A\u627E\u5230\u6D88\u606F", + errorNoSession: "\u6CA1\u6709\u53EF\u7528\u7684\u4F1A\u8BDD ID", + errorNoActiveTab: "\u6CA1\u6709\u6D3B\u52A8\u6807\u7B7E\u9875", + commandNoMessages: "\u65E0\u6CD5\u5206\u53C9\uFF1A\u5BF9\u8BDD\u4E2D\u6CA1\u6709\u6D88\u606F", + commandNoAssistantUuid: "\u65E0\u6CD5\u5206\u53C9\uFF1A\u6CA1\u6709\u5E26\u6807\u8BC6\u7B26\u7684\u52A9\u624B\u56DE\u590D" + }, + bangBash: { + placeholder: "> \u8FD0\u884C\u547D\u4EE4...", + commandPanel: "\u547D\u4EE4\u9762\u677F", + copyAriaLabel: "\u590D\u5236\u6700\u65B0\u547D\u4EE4\u8F93\u51FA", + clearAriaLabel: "\u6E05\u9664\u547D\u4EE4\u8F93\u51FA", + commandLabel: "{command}", + statusLabel: "\u72B6\u6001: {status}", + collapseOutput: "\u6298\u53E0\u547D\u4EE4\u8F93\u51FA", + expandOutput: "\u5C55\u5F00\u547D\u4EE4\u8F93\u51FA", + running: "\u8FD0\u884C\u4E2D...", + copyFailed: "\u590D\u5236\u5230\u526A\u8D34\u677F\u5931\u8D25" + } +}; +var settings9 = { + title: "Claudian \u8BBE\u7F6E", + tabs: { + general: "\u901A\u7528", + claude: "Claude", + codex: "Codex" + }, + display: "\u663E\u793A", + conversations: "\u5BF9\u8BDD", + content: "\u5185\u5BB9", + input: "\u8F93\u5165", + setup: "\u8BBE\u7F6E", + models: "\u6A21\u578B", + experimental: "\u5B9E\u9A8C\u6027\u529F\u80FD", + userName: { + name: "Claudian \u5E94\u8BE5\u5982\u4F55\u79F0\u547C\u4F60\uFF1F", + desc: "\u7528\u4E8E\u4E2A\u6027\u5316\u95EE\u5019\u7684\u7528\u6237\u540D\uFF08\u7559\u7A7A\u4F7F\u7528\u901A\u7528\u95EE\u5019\uFF09" + }, + excludedTags: { + name: "\u6392\u9664\u7684\u6807\u7B7E", + desc: "\u5305\u542B\u8FD9\u4E9B\u6807\u7B7E\u7684\u7B14\u8BB0\u4E0D\u4F1A\u81EA\u52A8\u52A0\u8F7D\u4E3A\u4E0A\u4E0B\u6587\uFF08\u6BCF\u884C\u4E00\u4E2A\uFF0C\u4E0D\u5E26 #\uFF09" + }, + mediaFolder: { + name: "\u5A92\u4F53\u6587\u4EF6\u5939", + desc: "\u5B58\u653E\u9644\u4EF6/\u56FE\u7247\u7684\u6587\u4EF6\u5939\u3002\u5F53\u7B14\u8BB0\u4F7F\u7528 ![[image.jpg]] \u65F6\uFF0CClaude \u4F1A\u5728\u6B64\u67E5\u627E\u3002\u7559\u7A7A\u4F7F\u7528\u4ED3\u5E93\u6839\u76EE\u5F55\u3002" + }, + systemPrompt: { + name: "\u81EA\u5B9A\u4E49\u7CFB\u7EDF\u63D0\u793A\u8BCD", + desc: "\u9644\u52A0\u5230\u9ED8\u8BA4\u7CFB\u7EDF\u63D0\u793A\u8BCD\u7684\u989D\u5916\u6307\u4EE4" + }, + autoTitle: { + name: "\u81EA\u52A8\u751F\u6210\u5BF9\u8BDD\u6807\u9898", + desc: "\u5728\u7528\u6237\u53D1\u9001\u9996\u6761\u6D88\u606F\u540E\u81EA\u52A8\u751F\u6210\u5BF9\u8BDD\u6807\u9898\u3002" + }, + titleModel: { + name: "\u6807\u9898\u751F\u6210\u6A21\u578B", + desc: "\u7528\u4E8E\u81EA\u52A8\u751F\u6210\u5BF9\u8BDD\u6807\u9898\u7684\u6A21\u578B\u3002", + auto: "\u81EA\u52A8 (Haiku)" + }, + navMappings: { + name: "Vim \u98CE\u683C\u5BFC\u822A\u6620\u5C04", + desc: '\u6BCF\u884C\u4E00\u4E2A\u6620\u5C04\u3002\u683C\u5F0F\uFF1A"map <\u952E> <\u52A8\u4F5C>"\uFF08\u52A8\u4F5C\uFF1AscrollUp, scrollDown, focusInput\uFF09\u3002' + }, + hotkeys: "\u5FEB\u6377\u952E", + inlineEditHotkey: { + name: "\u5185\u8054\u7F16\u8F91", + descWithKey: "\u5F53\u524D\u5FEB\u6377\u952E\uFF1A{hotkey}", + descNoKey: "\u672A\u8BBE\u7F6E\u5FEB\u6377\u952E", + btnChange: "\u66F4\u6539", + btnSet: "\u8BBE\u7F6E\u5FEB\u6377\u952E" + }, + openChatHotkey: { + name: "\u6253\u5F00\u804A\u5929", + descWithKey: "\u5F53\u524D\u5FEB\u6377\u952E\uFF1A{hotkey}", + descNoKey: "\u672A\u8BBE\u7F6E\u5FEB\u6377\u952E", + btnChange: "\u66F4\u6539", + btnSet: "\u8BBE\u7F6E\u5FEB\u6377\u952E" + }, + newSessionHotkey: { + name: "\u65B0\u4F1A\u8BDD", + descWithKey: "\u5F53\u524D\u5FEB\u6377\u952E\uFF1A{hotkey}", + descNoKey: "\u672A\u8BBE\u7F6E\u5FEB\u6377\u952E", + btnChange: "\u66F4\u6539", + btnSet: "\u8BBE\u7F6E\u5FEB\u6377\u952E" + }, + newTabHotkey: { + name: "\u65B0\u6807\u7B7E\u9875", + descWithKey: "\u5F53\u524D\u5FEB\u6377\u952E\uFF1A{hotkey}", + descNoKey: "\u672A\u8BBE\u7F6E\u5FEB\u6377\u952E", + btnChange: "\u66F4\u6539", + btnSet: "\u8BBE\u7F6E\u5FEB\u6377\u952E" + }, + closeTabHotkey: { + name: "\u5173\u95ED\u6807\u7B7E\u9875", + descWithKey: "\u5F53\u524D\u5FEB\u6377\u952E\uFF1A{hotkey}", + descNoKey: "\u672A\u8BBE\u7F6E\u5FEB\u6377\u952E", + btnChange: "\u66F4\u6539", + btnSet: "\u8BBE\u7F6E\u5FEB\u6377\u952E" + }, + slashCommands: { + name: "\u547D\u4EE4\u4E0E\u6280\u80FD", + desc: "\u7BA1\u7406\u5B58\u50A8\u5728 .claude/commands/ \u548C .claude/skills/ \u4E2D\u7684 Vault \u7EA7\u547D\u4EE4\u4E0E\u6280\u80FD\u3002\u7531 /\u540D\u79F0 \u89E6\u53D1\u3002" + }, + hiddenSlashCommands: { + name: "\u9690\u85CF\u547D\u4EE4", + desc: "\u4ECE\u4E0B\u62C9\u83DC\u5355\u4E2D\u9690\u85CF\u7279\u5B9A\u7684\u659C\u6760\u547D\u4EE4\u3002\u9002\u7528\u4E8E\u9690\u85CF\u4E0E Claudian \u65E0\u5173\u7684 Claude Code \u547D\u4EE4\u3002\u6BCF\u884C\u8F93\u5165\u4E00\u4E2A\u547D\u4EE4\u540D\u79F0\uFF0C\u65E0\u9700\u524D\u5BFC\u659C\u6760\u3002", + placeholder: "commit\nbuild\ntest" + }, + mcpServers: { + name: "MCP \u670D\u52A1\u5668", + desc: "\u7BA1\u7406\u5B58\u50A8\u5728 .claude/mcp.json \u4E2D\u7684 Vault \u7EA7 MCP \u670D\u52A1\u5668\u914D\u7F6E\u3002\u542F\u7528\u4E0A\u4E0B\u6587\u4FDD\u5B58\u6A21\u5F0F\u7684\u670D\u52A1\u5668\u9700\u8981 @ \u63D0\u53CA\u624D\u80FD\u6FC0\u6D3B\u3002" + }, + plugins: { + name: "Claude Code \u63D2\u4EF6", + desc: "\u7BA1\u7406\u4ECE ~/.claude/plugins \u53D1\u73B0\u7684 Claude Code \u63D2\u4EF6\u3002\u542F\u7528\u7684\u63D2\u4EF6\u6309 Vault \u5B58\u50A8\u5728 .claude/settings.json \u4E2D\u3002" + }, + subagents: { + name: "\u5B50\u4EE3\u7406", + desc: "\u7BA1\u7406\u5B58\u50A8\u5728 .claude/agents/ \u4E2D\u7684 Vault \u7EA7\u5B50\u4EE3\u7406\u3002\u6BCF\u4E2A Markdown \u6587\u4EF6\u5B9A\u4E49\u4E00\u4E2A\u81EA\u5B9A\u4E49\u4EE3\u7406\u3002", + noAgents: "\u5C1A\u672A\u914D\u7F6E\u5B50\u4EE3\u7406\u3002\u70B9\u51FB + \u521B\u5EFA\u4E00\u4E2A\u3002", + deleteConfirm: "\u5220\u9664\u5B50\u4EE3\u7406\u201C{name}\u201D\uFF1F", + saveFailed: "\u4FDD\u5B58\u5B50\u4EE3\u7406\u5931\u8D25\uFF1A{message}", + refreshFailed: "\u5237\u65B0\u5B50\u4EE3\u7406\u5931\u8D25\uFF1A{message}", + deleteFailed: "\u5220\u9664\u5B50\u4EE3\u7406\u5931\u8D25\uFF1A{message}", + renameCleanupFailed: "\u8B66\u544A\uFF1A\u65E0\u6CD5\u5220\u9664\u201C{name}\u201D\u7684\u65E7\u6587\u4EF6", + created: "\u5DF2\u521B\u5EFA\u5B50\u4EE3\u7406\u201C{name}\u201D", + updated: "\u5DF2\u66F4\u65B0\u5B50\u4EE3\u7406\u201C{name}\u201D", + deleted: "\u5DF2\u5220\u9664\u5B50\u4EE3\u7406\u201C{name}\u201D", + duplicateName: "\u540D\u4E3A\u201C{name}\u201D\u7684\u4EE3\u7406\u5DF2\u5B58\u5728", + descriptionRequired: "\u63CF\u8FF0\u4E3A\u5FC5\u586B\u9879", + promptRequired: "\u7CFB\u7EDF\u63D0\u793A\u8BCD\u4E3A\u5FC5\u586B\u9879", + modal: { + titleEdit: "\u7F16\u8F91\u5B50\u4EE3\u7406", + titleAdd: "\u6DFB\u52A0\u5B50\u4EE3\u7406", + name: "\u540D\u79F0", + nameDesc: "\u4EC5\u5141\u8BB8\u5C0F\u5199\u5B57\u6BCD\u3001\u6570\u5B57\u548C\u8FDE\u5B57\u7B26", + namePlaceholder: "code-reviewer", + description: "\u63CF\u8FF0", + descriptionDesc: "\u8BE5\u4EE3\u7406\u7684\u7B80\u8981\u63CF\u8FF0", + descriptionPlaceholder: "\u5BA1\u67E5\u4EE3\u7801\u4E2D\u7684\u9519\u8BEF\u548C\u98CE\u683C\u95EE\u9898", + advancedOptions: "\u9AD8\u7EA7\u9009\u9879", + model: "\u6A21\u578B", + modelDesc: "\u8BE5\u4EE3\u7406\u7684\u6A21\u578B\u8986\u76D6", + tools: "\u5DE5\u5177", + toolsDesc: "\u5141\u8BB8\u4F7F\u7528\u7684\u5DE5\u5177\u5217\u8868\uFF0C\u7528\u9017\u53F7\u5206\u9694\uFF08\u7559\u7A7A = \u5168\u90E8\uFF09", + disallowedTools: "\u7981\u7528\u5DE5\u5177", + disallowedToolsDesc: "\u8981\u7981\u7528\u7684\u5DE5\u5177\u5217\u8868\uFF0C\u7528\u9017\u53F7\u5206\u9694", + skills: "\u6280\u80FD", + skillsDesc: "\u6280\u80FD\u5217\u8868\uFF0C\u7528\u9017\u53F7\u5206\u9694", + prompt: "\u7CFB\u7EDF\u63D0\u793A\u8BCD", + promptDesc: "\u7ED9\u4EE3\u7406\u7684\u6307\u4EE4", + promptPlaceholder: "\u4F60\u662F\u4E00\u540D\u4EE3\u7801\u5BA1\u67E5\u5458\u3002\u8BF7\u5206\u6790\u7ED9\u5B9A\u4EE3\u7801\u4E2D\u7684..." + } + }, + safety: "\u5B89\u5168", + loadUserSettings: { + name: "\u52A0\u8F7D\u7528\u6237 Claude \u8BBE\u7F6E", + desc: "\u52A0\u8F7D ~/.claude/settings.json\u3002\u542F\u7528\u540E\uFF0C\u7528\u6237\u7684 Claude Code \u6743\u9650\u89C4\u5219\u53EF\u80FD\u7ED5\u8FC7\u5B89\u5168\u6A21\u5F0F\u3002" + }, + claudeSafeMode: { + name: "Safe mode", + desc: "Permission mode used when the Safe toggle is active." + }, + codexSafeMode: { + name: "Safe mode", + desc: "Sandbox mode used when the Safe toggle is active." + }, + environment: "\u73AF\u5883", + customVariables: { + name: "\u81EA\u5B9A\u4E49\u53D8\u91CF", + desc: "Claude SDK \u7684\u73AF\u5883\u53D8\u91CF\uFF08KEY=VALUE \u683C\u5F0F\uFF0C\u6BCF\u884C\u4E00\u4E2A\uFF09\u3002\u652F\u6301 export \u524D\u7F00\u3002" + }, + envSnippets: { + name: "\u7247\u6BB5", + addBtn: "\u6DFB\u52A0\u7247\u6BB5", + noSnippets: "\u5C1A\u65E0\u4FDD\u5B58\u7684\u73AF\u5883\u53D8\u91CF\u7247\u6BB5\u3002\u70B9\u51FB + \u4FDD\u5B58\u5F53\u524D\u914D\u7F6E\u3002", + nameRequired: "\u8BF7\u8F93\u5165\u7247\u6BB5\u540D\u79F0", + modal: { + titleEdit: "\u7F16\u8F91\u7247\u6BB5", + titleSave: "\u4FDD\u5B58\u7247\u6BB5", + name: "\u540D\u79F0", + namePlaceholder: "\u6B64\u914D\u7F6E\u7684\u63CF\u8FF0\u6027\u540D\u79F0", + description: "\u63CF\u8FF0", + descPlaceholder: "\u53EF\u9009\u63CF\u8FF0", + envVars: "\u73AF\u5883\u53D8\u91CF", + envVarsPlaceholder: "KEY=VALUE \u683C\u5F0F\uFF0C\u6BCF\u884C\u4E00\u4E2A\uFF08\u652F\u6301 export \u524D\u7F00\uFF09", + save: "\u4FDD\u5B58", + update: "\u66F4\u65B0", + cancel: "\u53D6\u6D88" + } + }, + customContextLimits: { + name: "\u81EA\u5B9A\u4E49\u4E0A\u4E0B\u6587\u9650\u5236", + desc: "\u4E3A\u60A8\u7684\u81EA\u5B9A\u4E49\u6A21\u578B\u8BBE\u7F6E\u4E0A\u4E0B\u6587\u7A97\u53E3\u5927\u5C0F\u3002\u7559\u7A7A\u4F7F\u7528\u9ED8\u8BA4\u503C\uFF08200k \u4EE4\u724C\uFF09\u3002", + invalid: "\u683C\u5F0F\u65E0\u6548\u3002\u4F7F\u7528\uFF1A256k\u30011m \u6216\u7CBE\u786E\u6570\u91CF\uFF081000-10000000\uFF09\u3002" + }, + enableOpus1M: { + name: "Opus 1M \u4E0A\u4E0B\u6587\u7A97\u53E3", + desc: "\u5728\u6A21\u578B\u9009\u62E9\u5668\u4E2D\u663E\u793A Opus 1M\u3002Max\u3001Team \u548C Enterprise \u8BA1\u5212\u5DF2\u5305\u542B\u3002API \u548C Pro \u7528\u6237\u9700\u8981\u989D\u5916\u7528\u91CF\u3002" + }, + enableSonnet1M: { + name: "Sonnet 1M \u4E0A\u4E0B\u6587\u7A97\u53E3", + desc: "\u5728\u6A21\u578B\u9009\u62E9\u5668\u4E2D\u663E\u793A Sonnet 1M\u3002Max\u3001Team \u548C Enterprise \u8BA1\u5212\u9700\u8981\u989D\u5916\u7528\u91CF\u3002API \u548C Pro \u7528\u6237\u9700\u8981\u989D\u5916\u7528\u91CF\u3002" + }, + enableChrome: { + name: "\u542F\u7528 Chrome \u6269\u5C55", + desc: "\u5141\u8BB8 Claude \u901A\u8FC7 claude-in-chrome \u6269\u5C55\u4E0E Chrome \u4EA4\u4E92\u3002\u9700\u8981\u5B89\u88C5\u8BE5\u6269\u5C55\u3002\u9700\u8981\u91CD\u542F\u4F1A\u8BDD\u3002" + }, + enableBangBash: { + name: "\u542F\u7528\u547D\u4EE4\u6A21\u5F0F (!)", + desc: "\u5728\u7A7A\u8F93\u5165\u6846\u4E2D\u8F93\u5165 ! \u8FDB\u5165\u547D\u4EE4\u6A21\u5F0F\u3002\u901A\u8FC7 Node.js child_process \u76F4\u63A5\u8FD0\u884C\u547D\u4EE4\u3002\u9700\u8981\u91CD\u65B0\u6253\u5F00\u89C6\u56FE\u3002", + validation: { + noNode: "\u672A\u5728 PATH \u4E2D\u627E\u5230 Node.js\u3002\u8BF7\u5B89\u88C5 Node.js \u6216\u68C0\u67E5 PATH \u914D\u7F6E\u3002" + } + }, + maxTabs: { + name: "\u6700\u5927\u804A\u5929\u6807\u7B7E\u6570", + desc: "\u540C\u65F6\u5F00\u542F\u7684\u6700\u5927\u804A\u5929\u6807\u7B7E\u6570\uFF083-10\uFF09\u3002\u6BCF\u4E2A\u6807\u7B7E\u4F7F\u7528\u72EC\u7ACB\u7684 Claude \u4F1A\u8BDD\u3002", + warning: "\u8D85\u8FC7 5 \u4E2A\u6807\u7B7E\u53EF\u80FD\u4F1A\u5F71\u54CD\u6027\u80FD\u548C\u5185\u5B58\u4F7F\u7528\u3002" + }, + tabBarPosition: { + name: "\u6807\u7B7E\u680F\u4F4D\u7F6E", + desc: "\u9009\u62E9\u6807\u7B7E\u5FBD\u7AE0\u548C\u64CD\u4F5C\u6309\u94AE\u7684\u663E\u793A\u4F4D\u7F6E", + input: "\u8F93\u5165\u6846\u4E0A\u65B9\uFF08\u9ED8\u8BA4\uFF09", + header: "\u5728\u6807\u9898\u680F" + }, + enableAutoScroll: { + name: "\u6D41\u5F0F\u4F20\u8F93\u65F6\u81EA\u52A8\u6EDA\u52A8", + desc: "\u5728 Claude \u6D41\u5F0F\u4F20\u8F93\u54CD\u5E94\u65F6\u81EA\u52A8\u6EDA\u52A8\u5230\u5E95\u90E8\u3002\u7981\u7528\u540E\u5C06\u505C\u7559\u5728\u9876\u90E8\uFF0C\u4ECE\u5934\u5F00\u59CB\u9605\u8BFB\u3002" + }, + openInMainTab: { + name: "\u5728\u4E3B\u7F16\u8F91\u5668\u533A\u57DF\u6253\u5F00", + desc: "\u5728\u4E2D\u592E\u7F16\u8F91\u5668\u533A\u57DF\u4EE5\u4E3B\u6807\u7B7E\u9875\u5F62\u5F0F\u6253\u5F00\u804A\u5929\u9762\u677F\uFF0C\u800C\u4E0D\u662F\u5728\u53F3\u4FA7\u8FB9\u680F" + }, + cliPath: { + name: "Claude CLI \u8DEF\u5F84", + desc: "Claude Code CLI \u7684\u81EA\u5B9A\u4E49\u8DEF\u5F84\u3002\u7559\u7A7A\u4F7F\u7528\u81EA\u52A8\u68C0\u6D4B\u3002", + descWindows: "\u5BF9\u4E8E\u539F\u751F\u5B89\u88C5\u7A0B\u5E8F\uFF0C\u4F7F\u7528 claude.exe\u3002\u5BF9\u4E8E npm/pnpm/yarn \u6216\u5176\u4ED6\u5305\u7BA1\u7406\u5668\u5B89\u88C5\uFF0C\u4F7F\u7528 cli.js \u8DEF\u5F84\uFF08\u4E0D\u662F claude.cmd\uFF09\u3002", + descUnix: '\u7C98\u8D34 "which claude" \u7684\u8F93\u51FA - \u9002\u7528\u4E8E\u539F\u751F\u5B89\u88C5\u548C npm/pnpm/yarn \u5B89\u88C5\u3002', + validation: { + notExist: "\u8DEF\u5F84\u4E0D\u5B58\u5728", + isDirectory: "\u8DEF\u5F84\u662F\u76EE\u5F55\uFF0C\u4E0D\u662F\u6587\u4EF6" + } + }, + language: { + name: "\u8BED\u8A00", + desc: "\u66F4\u6539\u63D2\u4EF6\u754C\u9762\u7684\u663E\u793A\u8BED\u8A00" + } +}; +var zh_CN_default = { + common: common9, + chat: chat9, + settings: settings9 +}; + +// src/i18n/locales/zh-TW.json +var zh_TW_exports = {}; +__export(zh_TW_exports, { + chat: () => chat10, + common: () => common10, + default: () => zh_TW_default, + settings: () => settings10 +}); +var common10 = { + save: "\u4FDD\u5B58", + cancel: "\u53D6\u6D88", + delete: "\u522A\u9664", + edit: "\u7DE8\u8F2F", + add: "\u6DFB\u52A0", + remove: "\u79FB\u9664", + clear: "\u6E05\u9664", + clearAll: "\u6E05\u9664\u5168\u90E8", + loading: "\u52A0\u8F09\u4E2D", + error: "\u932F\u8AA4", + success: "\u6210\u529F", + warning: "\u8B66\u544A", + confirm: "\u78BA\u8A8D", + settings: "\u8A2D\u7F6E", + advanced: "\u9AD8\u7D1A", + enabled: "\u5DF2\u555F\u7528", + disabled: "\u5DF2\u7981\u7528", + platform: "\u5E73\u53F0", + refresh: "\u91CD\u65B0\u6574\u7406", + rewind: "\u56DE\u9000" +}; +var chat10 = { + rewind: { + confirmMessage: "\u56DE\u9000\u5230\u6B64\u8655\uFF1F\u6B64\u8A0A\u606F\u4E4B\u5F8C\u7684\u6A94\u6848\u8B8A\u66F4\u5C07\u88AB\u9084\u539F\u3002\u56DE\u9000\u4E0D\u6703\u5F71\u97FF\u624B\u52D5\u6216\u900F\u904E bash \u7DE8\u8F2F\u7684\u6A94\u6848\u3002", + confirmButton: "\u56DE\u9000", + ariaLabel: "\u56DE\u9000\u5230\u6B64\u8655", + notice: "\u5DF2\u56DE\u9000\uFF1A\u9084\u539F\u4E86 {count} \u500B\u6A94\u6848", + noticeSaveFailed: "\u5DF2\u56DE\u9000\uFF1A\u9084\u539F\u4E86 {count} \u500B\u6A94\u6848\uFF0C\u4F46\u7121\u6CD5\u5132\u5B58\u72C0\u614B\uFF1A{error}", + failed: "\u56DE\u9000\u5931\u6557\uFF1A{error}", + cannot: "\u7121\u6CD5\u56DE\u9000\uFF1A{error}", + unavailableStreaming: "\u4E32\u6D41\u56DE\u61C9\u4E2D\u7121\u6CD5\u56DE\u9000", + unavailableNoUuid: "\u7121\u6CD5\u56DE\u9000\uFF1A\u7F3A\u5C11\u8A0A\u606F\u8B58\u5225\u78BC" + }, + fork: { + ariaLabel: "\u5206\u53C9\u5C0D\u8A71", + chooseTarget: "\u5206\u53C9\u5C0D\u8A71", + targetNewTab: "\u65B0\u5206\u9801", + targetCurrentTab: "\u76EE\u524D\u5206\u9801", + maxTabsReached: "\u7121\u6CD5\u5206\u53C9\uFF1A\u5DF2\u9054\u5230\u6700\u5927 {count} \u500B\u5206\u9801", + notice: "\u5DF2\u5206\u53C9\u5230\u65B0\u5206\u9801", + noticeCurrentTab: "\u5DF2\u5728\u76EE\u524D\u5206\u9801\u5206\u53C9", + failed: "\u5206\u53C9\u5931\u6557\uFF1A{error}", + unavailableStreaming: "\u4E32\u6D41\u56DE\u61C9\u4E2D\u7121\u6CD5\u5206\u53C9", + unavailableNoUuid: "\u7121\u6CD5\u5206\u53C9\uFF1A\u7F3A\u5C11\u8A0A\u606F\u8B58\u5225\u78BC", + unavailableNoResponse: "\u7121\u6CD5\u5206\u53C9\uFF1A\u6C92\u6709\u53EF\u5206\u53C9\u7684\u56DE\u61C9", + errorMessageNotFound: "\u627E\u4E0D\u5230\u8A0A\u606F", + errorNoSession: "\u6C92\u6709\u53EF\u7528\u7684\u5DE5\u4F5C\u968E\u6BB5 ID", + errorNoActiveTab: "\u6C92\u6709\u4F7F\u7528\u4E2D\u7684\u5206\u9801", + commandNoMessages: "\u7121\u6CD5\u5206\u53C9\uFF1A\u5C0D\u8A71\u4E2D\u6C92\u6709\u8A0A\u606F", + commandNoAssistantUuid: "\u7121\u6CD5\u5206\u53C9\uFF1A\u6C92\u6709\u5E36\u8B58\u5225\u78BC\u7684\u52A9\u624B\u56DE\u8986" + }, + bangBash: { + placeholder: "> \u57F7\u884C bash \u6307\u4EE4...", + commandPanel: "\u6307\u4EE4\u9762\u677F", + copyAriaLabel: "\u8907\u88FD\u6700\u65B0\u7684\u6307\u4EE4\u8F38\u51FA", + clearAriaLabel: "\u6E05\u9664 bash \u8F38\u51FA", + commandLabel: "{command}", + statusLabel: "\u72C0\u614B\uFF1A{status}", + collapseOutput: "\u647A\u758A\u6307\u4EE4\u8F38\u51FA", + expandOutput: "\u5C55\u958B\u6307\u4EE4\u8F38\u51FA", + running: "\u57F7\u884C\u4E2D...", + copyFailed: "\u8907\u88FD\u5230\u526A\u8CBC\u7C3F\u5931\u6557" + } +}; +var settings10 = { + title: "Claudian \u8A2D\u5B9A", + tabs: { + general: "\u4E00\u822C", + claude: "Claude", + codex: "Codex" + }, + display: "\u986F\u793A", + conversations: "\u5C0D\u8A71", + content: "\u5167\u5BB9", + input: "\u8F38\u5165", + setup: "\u8A2D\u5B9A", + models: "\u6A21\u578B", + experimental: "\u5BE6\u9A57\u6027\u529F\u80FD", + userName: { + name: "Claudian \u61C9\u8A72\u5982\u4F55\u7A31\u547C\u60A8\uFF1F", + desc: "\u7528\u65BC\u500B\u4EBA\u5316\u554F\u5019\u7684\u4F7F\u7528\u8005\u540D\u7A31\uFF08\u7559\u7A7A\u4F7F\u7528\u901A\u7528\u554F\u5019\uFF09" + }, + excludedTags: { + name: "\u6392\u9664\u7684\u6A19\u7C64", + desc: "\u5305\u542B\u9019\u4E9B\u6A19\u7C64\u7684\u7B46\u8A18\u4E0D\u6703\u81EA\u52D5\u8F09\u5165\u70BA\u4E0A\u4E0B\u6587\uFF08\u6BCF\u884C\u4E00\u500B\uFF0C\u4E0D\u5E36 #\uFF09" + }, + mediaFolder: { + name: "\u5A92\u9AD4\u8CC7\u6599\u593E", + desc: "\u5B58\u653E\u9644\u4EF6/\u5716\u7247\u7684\u8CC7\u6599\u593E\u3002\u7576\u7B46\u8A18\u4F7F\u7528 ![[image.jpg]] \u6642\uFF0CClaude \u6703\u5728\u6B64\u67E5\u627E\u3002\u7559\u7A7A\u4F7F\u7528\u5132\u5B58\u5EAB\u6839\u76EE\u9304\u3002" + }, + systemPrompt: { + name: "\u81EA\u8A02\u7CFB\u7D71\u63D0\u793A\u8A5E", + desc: "\u9644\u52A0\u5230\u9810\u8A2D\u7CFB\u7D71\u63D0\u793A\u8A5E\u7684\u984D\u5916\u6307\u4EE4" + }, + autoTitle: { + name: "\u81EA\u52D5\u751F\u6210\u5C0D\u8A71\u6A19\u984C", + desc: "\u5728\u4F7F\u7528\u8005\u9001\u51FA\u7B2C\u4E00\u5247\u8A0A\u606F\u5F8C\u81EA\u52D5\u751F\u6210\u5C0D\u8A71\u6A19\u984C\u3002" + }, + titleModel: { + name: "\u6A19\u984C\u751F\u6210\u6A21\u578B", + desc: "\u7528\u65BC\u81EA\u52D5\u751F\u6210\u5C0D\u8A71\u6A19\u984C\u7684\u6A21\u578B\u3002", + auto: "\u81EA\u52D5 (Haiku)" + }, + navMappings: { + name: "Vim \u98A8\u683C\u5C0E\u822A\u6620\u5C04", + desc: '\u6BCF\u884C\u4E00\u500B\u6620\u5C04\u3002\u683C\u5F0F\uFF1A"map <\u9375> <\u52D5\u4F5C>"\uFF08\u52D5\u4F5C\uFF1AscrollUp, scrollDown, focusInput\uFF09\u3002' + }, + hotkeys: "\u5FEB\u6377\u9375", + inlineEditHotkey: { + name: "\u5167\u5D4C\u7DE8\u8F2F", + descWithKey: "\u76EE\u524D\u5FEB\u6377\u9375\uFF1A{hotkey}", + descNoKey: "\u672A\u8A2D\u5B9A\u5FEB\u6377\u9375", + btnChange: "\u8B8A\u66F4", + btnSet: "\u8A2D\u5B9A\u5FEB\u6377\u9375" + }, + openChatHotkey: { + name: "\u958B\u555F\u804A\u5929", + descWithKey: "\u76EE\u524D\u5FEB\u6377\u9375\uFF1A{hotkey}", + descNoKey: "\u672A\u8A2D\u5B9A\u5FEB\u6377\u9375", + btnChange: "\u8B8A\u66F4", + btnSet: "\u8A2D\u5B9A\u5FEB\u6377\u9375" + }, + newSessionHotkey: { + name: "\u65B0\u5DE5\u4F5C\u968E\u6BB5", + descWithKey: "\u76EE\u524D\u5FEB\u6377\u9375\uFF1A{hotkey}", + descNoKey: "\u672A\u8A2D\u5B9A\u5FEB\u6377\u9375", + btnChange: "\u8B8A\u66F4", + btnSet: "\u8A2D\u5B9A\u5FEB\u6377\u9375" + }, + newTabHotkey: { + name: "\u65B0\u5206\u9801", + descWithKey: "\u76EE\u524D\u5FEB\u6377\u9375\uFF1A{hotkey}", + descNoKey: "\u672A\u8A2D\u5B9A\u5FEB\u6377\u9375", + btnChange: "\u8B8A\u66F4", + btnSet: "\u8A2D\u5B9A\u5FEB\u6377\u9375" + }, + closeTabHotkey: { + name: "\u95DC\u9589\u5206\u9801", + descWithKey: "\u76EE\u524D\u5FEB\u6377\u9375\uFF1A{hotkey}", + descNoKey: "\u672A\u8A2D\u5B9A\u5FEB\u6377\u9375", + btnChange: "\u8B8A\u66F4", + btnSet: "\u8A2D\u5B9A\u5FEB\u6377\u9375" + }, + slashCommands: { + name: "\u547D\u4EE4\u8207\u6280\u80FD", + desc: "\u7BA1\u7406\u5132\u5B58\u5728 .claude/commands/ \u548C .claude/skills/ \u4E2D\u7684 Vault \u7D1A\u547D\u4EE4\u8207\u6280\u80FD\u3002\u7531 /\u540D\u7A31 \u89F8\u767C\u3002" + }, + hiddenSlashCommands: { + name: "\u96B1\u85CF\u547D\u4EE4", + desc: "\u5F9E\u4E0B\u62C9\u9078\u55AE\u4E2D\u96B1\u85CF\u7279\u5B9A\u7684\u659C\u7DDA\u547D\u4EE4\u3002\u9069\u7528\u65BC\u96B1\u85CF\u8207 Claudian \u7121\u95DC\u7684 Claude Code \u547D\u4EE4\u3002\u6BCF\u884C\u8F38\u5165\u4E00\u500B\u547D\u4EE4\u540D\u7A31\uFF0C\u7121\u9700\u524D\u5C0E\u659C\u7DDA\u3002", + placeholder: "commit\nbuild\ntest" + }, + mcpServers: { + name: "MCP \u4F3A\u670D\u5668", + desc: "\u7BA1\u7406\u5132\u5B58\u5728 .claude/mcp.json \u4E2D\u7684 Vault \u7D1A MCP \u4F3A\u670D\u5668\u914D\u7F6E\u3002\u555F\u7528\u4E0A\u4E0B\u6587\u4FDD\u5B58\u6A21\u5F0F\u7684\u4F3A\u670D\u5668\u9700\u8981 @ \u63D0\u53CA\u624D\u80FD\u555F\u7528\u3002" + }, + plugins: { + name: "Claude Code \u5916\u639B\u7A0B\u5F0F", + desc: "\u7BA1\u7406\u5F9E ~/.claude/plugins \u767C\u73FE\u7684 Claude Code \u5916\u639B\u7A0B\u5F0F\u3002\u5DF2\u555F\u7528\u7684\u5916\u639B\u7A0B\u5F0F\u6309 Vault \u5132\u5B58\u5728 .claude/settings.json \u4E2D\u3002" + }, + subagents: { + name: "\u5B50\u4EE3\u7406", + desc: "\u7BA1\u7406\u5132\u5B58\u5728 .claude/agents/ \u4E2D\u7684 Vault \u7D1A\u5B50\u4EE3\u7406\u3002\u6BCF\u500B Markdown \u6A94\u6848\u5B9A\u7FA9\u4E00\u500B\u81EA\u8A02\u4EE3\u7406\u3002", + noAgents: "\u5C1A\u672A\u8A2D\u5B9A\u5B50\u4EE3\u7406\u3002\u9EDE\u64CA + \u5EFA\u7ACB\u4E00\u500B\u3002", + deleteConfirm: "\u522A\u9664\u5B50\u4EE3\u7406\u300C{name}\u300D\uFF1F", + saveFailed: "\u5132\u5B58\u5B50\u4EE3\u7406\u5931\u6557\uFF1A{message}", + refreshFailed: "\u91CD\u65B0\u6574\u7406\u5B50\u4EE3\u7406\u5931\u6557\uFF1A{message}", + deleteFailed: "\u522A\u9664\u5B50\u4EE3\u7406\u5931\u6557\uFF1A{message}", + renameCleanupFailed: "\u8B66\u544A\uFF1A\u7121\u6CD5\u79FB\u9664\u300C{name}\u300D\u7684\u820A\u6A94\u6848", + created: "\u5DF2\u5EFA\u7ACB\u5B50\u4EE3\u7406\u300C{name}\u300D", + updated: "\u5DF2\u66F4\u65B0\u5B50\u4EE3\u7406\u300C{name}\u300D", + deleted: "\u5DF2\u522A\u9664\u5B50\u4EE3\u7406\u300C{name}\u300D", + duplicateName: "\u5DF2\u5B58\u5728\u540D\u70BA\u300C{name}\u300D\u7684\u4EE3\u7406", + descriptionRequired: "\u63CF\u8FF0\u70BA\u5FC5\u586B", + promptRequired: "\u7CFB\u7D71\u63D0\u793A\u8A5E\u70BA\u5FC5\u586B", + modal: { + titleEdit: "\u7DE8\u8F2F\u5B50\u4EE3\u7406", + titleAdd: "\u65B0\u589E\u5B50\u4EE3\u7406", + name: "\u540D\u7A31", + nameDesc: "\u50C5\u9650\u5C0F\u5BEB\u5B57\u6BCD\u3001\u6578\u5B57\u8207\u9023\u5B57\u865F", + namePlaceholder: "code-reviewer", + description: "\u63CF\u8FF0", + descriptionDesc: "\u6B64\u4EE3\u7406\u7684\u7C21\u77ED\u63CF\u8FF0", + descriptionPlaceholder: "\u6AA2\u67E5\u7A0B\u5F0F\u78BC\u4E2D\u7684\u932F\u8AA4\u8207\u98A8\u683C\u554F\u984C", + advancedOptions: "\u9032\u968E\u9078\u9805", + model: "\u6A21\u578B", + modelDesc: "\u6B64\u4EE3\u7406\u7684\u6A21\u578B\u8986\u5BEB", + tools: "\u5DE5\u5177", + toolsDesc: "\u5141\u8A31\u5DE5\u5177\u7684\u9017\u865F\u5206\u9694\u6E05\u55AE\uFF08\u7559\u7A7A = \u5168\u90E8\uFF09", + disallowedTools: "\u7981\u7528\u5DE5\u5177", + disallowedToolsDesc: "\u8981\u7981\u7528\u7684\u5DE5\u5177\u6E05\u55AE\uFF0C\u4EE5\u9017\u865F\u5206\u9694", + skills: "\u6280\u80FD", + skillsDesc: "\u6280\u80FD\u6E05\u55AE\uFF0C\u4EE5\u9017\u865F\u5206\u9694", + prompt: "\u7CFB\u7D71\u63D0\u793A\u8A5E", + promptDesc: "\u7D66\u4EE3\u7406\u7684\u6307\u793A", + promptPlaceholder: "\u4F60\u662F\u4E00\u540D\u7A0B\u5F0F\u78BC\u5BE9\u67E5\u54E1\u3002\u8ACB\u5206\u6790\u7D66\u5B9A\u7684\u7A0B\u5F0F\u78BC..." + } + }, + safety: "\u5B89\u5168", + loadUserSettings: { + name: "\u8F09\u5165\u4F7F\u7528\u8005 Claude \u8A2D\u5B9A", + desc: "\u8F09\u5165 ~/.claude/settings.json\u3002\u555F\u7528\u5F8C\uFF0C\u4F7F\u7528\u8005\u7684 Claude Code \u6B0A\u9650\u898F\u5247\u53EF\u80FD\u7E5E\u904E\u5B89\u5168\u6A21\u5F0F\u3002" + }, + claudeSafeMode: { + name: "Safe mode", + desc: "Permission mode used when the Safe toggle is active." + }, + codexSafeMode: { + name: "Safe mode", + desc: "Sandbox mode used when the Safe toggle is active." + }, + environment: "\u74B0\u5883", + customVariables: { + name: "\u81EA\u8A02\u8B8A\u6578", + desc: "Claude SDK \u7684\u74B0\u5883\u8B8A\u6578\uFF08KEY=VALUE \u683C\u5F0F\uFF0C\u6BCF\u884C\u4E00\u500B\uFF09\u3002\u652F\u63F4 export \u524D\u7DB4\u3002" + }, + envSnippets: { + name: "\u7247\u6BB5", + addBtn: "\u65B0\u589E\u7247\u6BB5", + noSnippets: "\u5C1A\u7121\u4FDD\u5B58\u7684\u74B0\u5883\u8B8A\u6578\u7247\u6BB5\u3002\u9EDE\u64CA + \u4FDD\u5B58\u7576\u524D\u914D\u7F6E\u3002", + nameRequired: "\u8ACB\u8F38\u5165\u7247\u6BB5\u540D\u7A31", + modal: { + titleEdit: "\u7DE8\u8F2F\u7247\u6BB5", + titleSave: "\u4FDD\u5B58\u7247\u6BB5", + name: "\u540D\u7A31", + namePlaceholder: "\u6B64\u914D\u7F6E\u7684\u63CF\u8FF0\u6027\u540D\u7A31", + description: "\u63CF\u8FF0", + descPlaceholder: "\u53EF\u9078\u63CF\u8FF0", + envVars: "\u74B0\u5883\u8B8A\u6578", + envVarsPlaceholder: "KEY=VALUE \u683C\u5F0F\uFF0C\u6BCF\u884C\u4E00\u500B\uFF08\u652F\u63F4 export \u524D\u7DB4\uFF09", + save: "\u4FDD\u5B58", + update: "\u66F4\u65B0", + cancel: "\u53D6\u6D88" + } + }, + customContextLimits: { + name: "\u81EA\u8A02\u4E0A\u4E0B\u6587\u9650\u5236", + desc: "\u70BA\u60A8\u7684\u81EA\u8A02\u6A21\u578B\u8A2D\u5B9A\u4E0A\u4E0B\u6587\u8996\u7A97\u5927\u5C0F\u3002\u7559\u7A7A\u4F7F\u7528\u9810\u8A2D\u503C\uFF08200k \u6B0A\u6756\uFF09\u3002", + invalid: "\u683C\u5F0F\u7121\u6548\u3002\u4F7F\u7528\uFF1A256k\u30011m \u6216\u7CBE\u78BA\u6578\u91CF\uFF081000-10000000\uFF09\u3002" + }, + enableOpus1M: { + name: "Opus 1M \u4E0A\u4E0B\u6587\u8996\u7A97", + desc: "\u5728\u6A21\u578B\u9078\u64C7\u5668\u4E2D\u986F\u793A Opus 1M\u3002Max\u3001Team \u548C Enterprise \u65B9\u6848\u5DF2\u5305\u542B\u3002API \u548C Pro \u4F7F\u7528\u8005\u9700\u8981\u984D\u5916\u7528\u91CF\u3002" + }, + enableSonnet1M: { + name: "Sonnet 1M \u4E0A\u4E0B\u6587\u8996\u7A97", + desc: "\u5728\u6A21\u578B\u9078\u64C7\u5668\u4E2D\u986F\u793A Sonnet 1M\u3002Max\u3001Team \u548C Enterprise \u65B9\u6848\u9700\u8981\u984D\u5916\u7528\u91CF\u3002API \u548C Pro \u4F7F\u7528\u8005\u9700\u8981\u984D\u5916\u7528\u91CF\u3002" + }, + enableChrome: { + name: "\u555F\u7528 Chrome \u64F4\u5145\u529F\u80FD", + desc: "\u5141\u8A31 Claude \u900F\u904E claude-in-chrome \u64F4\u5145\u529F\u80FD\u8207 Chrome \u4E92\u52D5\u3002\u9700\u8981\u5B89\u88DD\u8A72\u64F4\u5145\u529F\u80FD\u3002\u9700\u8981\u91CD\u65B0\u555F\u52D5\u5DE5\u4F5C\u968E\u6BB5\u3002" + }, + enableBangBash: { + name: "\u555F\u7528 bash \u6A21\u5F0F (!)", + desc: "\u5728\u7A7A\u767D\u8F38\u5165\u6846\u4E2D\u8F38\u5165 ! \u4EE5\u9032\u5165 bash \u6A21\u5F0F\u3002\u900F\u904E Node.js child_process \u76F4\u63A5\u57F7\u884C\u6307\u4EE4\u3002\u9700\u8981\u91CD\u65B0\u958B\u555F\u6AA2\u8996\u3002", + validation: { + noNode: "\u5728 PATH \u4E2D\u627E\u4E0D\u5230 Node.js\u3002\u8ACB\u5B89\u88DD Node.js \u6216\u6AA2\u67E5 PATH \u8A2D\u5B9A\u3002" + } + }, + maxTabs: { + name: "\u6700\u5927\u804A\u5929\u6A19\u7C64\u6578", + desc: "\u540C\u6642\u958B\u555F\u7684\u6700\u5927\u804A\u5929\u6A19\u7C64\u6578\uFF083-10\uFF09\u3002\u6BCF\u500B\u6A19\u7C64\u4F7F\u7528\u7368\u7ACB\u7684 Claude \u5C0D\u8A71\u3002", + warning: "\u8D85\u904E 5 \u500B\u6A19\u7C64\u53EF\u80FD\u6703\u5F71\u97FF\u6548\u80FD\u548C\u8A18\u61B6\u9AD4\u4F7F\u7528\u3002" + }, + tabBarPosition: { + name: "\u6A19\u7C64\u5217\u4F4D\u7F6E", + desc: "\u9078\u64C7\u6A19\u7C64\u5FBD\u7AE0\u548C\u64CD\u4F5C\u6309\u9215\u7684\u986F\u793A\u4F4D\u7F6E", + input: "\u8F38\u5165\u6846\u4E0A\u65B9\uFF08\u9810\u8A2D\uFF09", + header: "\u5728\u6A19\u984C\u5217" + }, + enableAutoScroll: { + name: "\u4E32\u6D41\u50B3\u8F38\u6642\u81EA\u52D5\u6372\u52D5", + desc: "\u5728 Claude \u4E32\u6D41\u50B3\u8F38\u56DE\u61C9\u6642\u81EA\u52D5\u6372\u52D5\u5230\u5E95\u90E8\u3002\u505C\u7528\u5F8C\u5C07\u505C\u7559\u5728\u9802\u90E8\uFF0C\u5F9E\u982D\u958B\u59CB\u95B1\u8B80\u3002" + }, + openInMainTab: { + name: "\u5728\u4E3B\u7DE8\u8F2F\u5668\u5340\u57DF\u958B\u555F", + desc: "\u5728\u4E2D\u592E\u7DE8\u8F2F\u5668\u5340\u57DF\u4EE5\u4E3B\u5206\u9801\u5F62\u5F0F\u958B\u555F\u804A\u5929\u9762\u677F\uFF0C\u800C\u4E0D\u662F\u5728\u53F3\u5074\u908A\u6B04" + }, + cliPath: { + name: "Claude CLI \u8DEF\u5F91", + desc: "Claude Code CLI \u7684\u81EA\u8A02\u8DEF\u5F91\u3002\u7559\u7A7A\u4F7F\u7528\u81EA\u52D5\u6AA2\u6E2C\u3002", + descWindows: "\u5C0D\u65BC\u539F\u751F\u5B89\u88DD\u7A0B\u5F0F\uFF0C\u4F7F\u7528 claude.exe\u3002\u5C0D\u65BC npm/pnpm/yarn \u6216\u5176\u4ED6\u5957\u4EF6\u7BA1\u7406\u5668\u5B89\u88DD\uFF0C\u4F7F\u7528 cli.js \u8DEF\u5F91\uFF08\u4E0D\u662F claude.cmd\uFF09\u3002", + descUnix: '\u8CBC\u4E0A "which claude" \u7684\u8F38\u51FA - \u9069\u7528\u65BC\u539F\u751F\u5B89\u88DD\u548C npm/pnpm/yarn \u5B89\u88DD\u3002', + validation: { + notExist: "\u8DEF\u5F91\u4E0D\u5B58\u5728", + isDirectory: "\u8DEF\u5F91\u662F\u76EE\u9304\uFF0C\u4E0D\u662F\u6A94\u6848" + } + }, + language: { + name: "\u8A9E\u8A00", + desc: "\u66F4\u6539\u63D2\u4EF6\u4ECB\u9762\u7684\u986F\u793A\u8A9E\u8A00" + } +}; +var zh_TW_default = { + common: common10, + chat: chat10, + settings: settings10 +}; + +// src/i18n/i18n.ts +var translations = { + en: en_exports, + "zh-CN": zh_CN_exports, + "zh-TW": zh_TW_exports, + ja: ja_exports, + ko: ko_exports, + de: de_exports, + fr: fr_exports, + es: es_exports, + ru: ru_exports, + pt: pt_exports +}; +var DEFAULT_LOCALE = "en"; +var currentLocale = DEFAULT_LOCALE; +function t(key, params) { + const dict = translations[currentLocale]; + const keys = key.split("."); + let value = dict; + for (const k3 of keys) { + if (value && typeof value === "object" && k3 in value) { + value = value[k3]; + } else { + if (currentLocale !== DEFAULT_LOCALE) { + return tFallback(key, params); + } + return key; + } + } + if (typeof value !== "string") { + return key; + } + if (params) { + return value.replace(/\{(\w+)\}/g, (_3, param) => { + var _a3, _b2; + return (_b2 = (_a3 = params[param]) == null ? void 0 : _a3.toString()) != null ? _b2 : `{${param}}`; + }); + } + return value; +} +function tFallback(key, params) { + const dict = translations[DEFAULT_LOCALE]; + const keys = key.split("."); + let value = dict; + for (const k3 of keys) { + if (value && typeof value === "object" && k3 in value) { + value = value[k3]; + } else { + return key; + } + } + if (typeof value !== "string") { + return key; + } + if (params) { + return value.replace(/\{(\w+)\}/g, (_3, param) => { + var _a3, _b2; + return (_b2 = (_a3 = params[param]) == null ? void 0 : _a3.toString()) != null ? _b2 : `{${param}}`; + }); + } + return value; +} +function setLocale(locale) { + if (!translations[locale]) { + return false; + } + currentLocale = locale; + return true; +} +function getAvailableLocales() { + return Object.keys(translations); +} +function getLocaleDisplayName(locale) { + const names = { + "en": "English", + "zh-CN": "\u7B80\u4F53\u4E2D\u6587", + "zh-TW": "\u7E41\u9AD4\u4E2D\u6587", + "ja": "\u65E5\u672C\u8A9E", + "ko": "\uD55C\uAD6D\uC5B4", + "de": "Deutsch", + "fr": "Fran\xE7ais", + "es": "Espa\xF1ol", + "ru": "\u0420\u0443\u0441\u0441\u043A\u0438\u0439", + "pt": "Portugu\xEAs" + }; + return names[locale] || locale; +} + +// src/features/settings/ui/EnvSnippetManager.ts +init_env(); +var EnvSnippetModal = class extends import_obsidian4.Modal { + constructor(app, plugin, snippet, scope, onSave) { + super(app); + this.plugin = plugin; + this.snippet = snippet; + this.snippetScope = scope; + this.onSave = onSave; + } + onOpen() { + const { contentEl } = this; + this.setTitle(this.snippet ? t("settings.envSnippets.modal.titleEdit") : t("settings.envSnippets.modal.titleSave")); + this.modalEl.addClass("claudian-env-snippet-modal"); + let nameEl; + let descEl; + let envVarsEl; + const contextLimitInputs = /* @__PURE__ */ new Map(); + let contextLimitsContainer = null; + const handleKeyDown = (e3) => { + if (e3.key === "Enter" && !e3.isComposing) { + e3.preventDefault(); + saveSnippet(); + } else if (e3.key === "Escape" && !e3.isComposing) { + e3.preventDefault(); + this.close(); + } + }; + const saveSnippet = () => { + var _a3, _b2, _c; + const name = nameEl.value.trim(); + if (!name) { + new import_obsidian4.Notice(t("settings.envSnippets.nameRequired")); + return; + } + const contextLimits = {}; + for (const [modelId, input] of contextLimitInputs) { + const value = input.value.trim(); + if (value) { + const parsed = parseContextLimit(value); + if (parsed !== null) { + contextLimits[modelId] = parsed; + } + } + } + const snippet = { + id: ((_a3 = this.snippet) == null ? void 0 : _a3.id) || `snippet-${Date.now()}`, + name, + description: descEl.value.trim(), + envVars: envVarsEl.value, + scope: resolveEnvironmentSnippetScope( + envVarsEl.value, + (_c = (_b2 = this.snippet) == null ? void 0 : _b2.scope) != null ? _c : this.snippetScope + ), + contextLimits: Object.keys(contextLimits).length > 0 ? contextLimits : void 0 + }; + this.onSave(snippet); + this.close(); + }; + const renderContextLimitFields = () => { + var _a3, _b2, _c; + if (!contextLimitsContainer) return; + contextLimitsContainer.empty(); + contextLimitInputs.clear(); + const envVars = parseEnvironmentVariables(envVarsEl.value); + const uniqueModelIds = ProviderRegistry.getCustomModelIds(envVars); + if (uniqueModelIds.size === 0) { + contextLimitsContainer.style.display = "none"; + return; + } + contextLimitsContainer.style.display = "block"; + const existingLimits = (_c = (_b2 = (_a3 = this.snippet) == null ? void 0 : _a3.contextLimits) != null ? _b2 : this.plugin.settings.customContextLimits) != null ? _c : {}; + contextLimitsContainer.createEl("div", { + text: t("settings.customContextLimits.name"), + cls: "setting-item-name" + }); + contextLimitsContainer.createEl("div", { + text: t("settings.customContextLimits.desc"), + cls: "setting-item-description" + }); + for (const modelId of uniqueModelIds) { + const row = contextLimitsContainer.createDiv({ cls: "claudian-snippet-limit-row" }); + row.createSpan({ text: modelId, cls: "claudian-snippet-limit-model" }); + row.createSpan({ cls: "claudian-snippet-limit-spacer" }); + const input = row.createEl("input", { + type: "text", + placeholder: "200k", + cls: "claudian-snippet-limit-input" + }); + input.value = existingLimits[modelId] ? formatContextLimit(existingLimits[modelId]) : ""; + contextLimitInputs.set(modelId, input); + } + }; + new import_obsidian4.Setting(contentEl).setName(t("settings.envSnippets.modal.name")).setDesc(t("settings.envSnippets.modal.namePlaceholder")).addText((text) => { + var _a3; + nameEl = text.inputEl; + text.setValue(((_a3 = this.snippet) == null ? void 0 : _a3.name) || ""); + text.inputEl.addEventListener("keydown", handleKeyDown); + }); + new import_obsidian4.Setting(contentEl).setName(t("settings.envSnippets.modal.description")).setDesc(t("settings.envSnippets.modal.descPlaceholder")).addText((text) => { + var _a3; + descEl = text.inputEl; + text.setValue(((_a3 = this.snippet) == null ? void 0 : _a3.description) || ""); + text.inputEl.addEventListener("keydown", handleKeyDown); + }); + const envVarsSetting = new import_obsidian4.Setting(contentEl).setName(t("settings.envSnippets.modal.envVars")).setDesc(t("settings.envSnippets.modal.envVarsPlaceholder")).addTextArea((text) => { + var _a3, _b2; + envVarsEl = text.inputEl; + const envVarsToShow = (_b2 = (_a3 = this.snippet) == null ? void 0 : _a3.envVars) != null ? _b2 : this.plugin.getEnvironmentVariablesForScope(this.snippetScope); + text.setValue(envVarsToShow); + text.inputEl.rows = 8; + text.inputEl.addEventListener("blur", () => renderContextLimitFields()); + }); + envVarsSetting.settingEl.addClass("claudian-env-snippet-setting"); + envVarsSetting.controlEl.addClass("claudian-env-snippet-control"); + contextLimitsContainer = contentEl.createDiv({ cls: "claudian-snippet-context-limits" }); + renderContextLimitFields(); + const buttonContainer = contentEl.createDiv({ cls: "claudian-snippet-buttons" }); + const cancelBtn = buttonContainer.createEl("button", { + text: t("settings.envSnippets.modal.cancel"), + cls: "claudian-cancel-btn" + }); + cancelBtn.addEventListener("click", () => this.close()); + const saveBtn = buttonContainer.createEl("button", { + text: this.snippet ? t("settings.envSnippets.modal.update") : t("settings.envSnippets.modal.save"), + cls: "claudian-save-btn" + }); + saveBtn.addEventListener("click", () => saveSnippet()); + setTimeout(() => nameEl == null ? void 0 : nameEl.focus(), 50); + } + onClose() { + const { contentEl } = this; + contentEl.empty(); + } +}; +var EnvSnippetManager = class { + constructor(containerEl, plugin, scope, onContextLimitsChange) { + this.containerEl = containerEl; + this.plugin = plugin; + this.scope = scope; + this.onContextLimitsChange = onContextLimitsChange; + this.render(); + } + render() { + this.containerEl.empty(); + const headerEl = this.containerEl.createDiv({ cls: "claudian-snippet-header" }); + headerEl.createSpan({ text: t("settings.envSnippets.name"), cls: "claudian-snippet-label" }); + const saveBtn = headerEl.createEl("button", { + cls: "claudian-settings-action-btn", + attr: { "aria-label": t("settings.envSnippets.addBtn") } + }); + (0, import_obsidian4.setIcon)(saveBtn, "plus"); + saveBtn.addEventListener("click", () => this.saveCurrentEnv()); + const snippets = this.plugin.settings.envSnippets.filter((snippet) => this.shouldDisplaySnippet(snippet)); + if (snippets.length === 0) { + const emptyEl = this.containerEl.createDiv({ cls: "claudian-snippet-empty" }); + emptyEl.setText(t("settings.envSnippets.noSnippets")); + return; + } + const listEl = this.containerEl.createDiv({ cls: "claudian-snippet-list" }); + for (const snippet of snippets) { + const itemEl = listEl.createDiv({ cls: "claudian-snippet-item" }); + const infoEl = itemEl.createDiv({ cls: "claudian-snippet-info" }); + const nameEl = infoEl.createDiv({ cls: "claudian-snippet-name" }); + nameEl.setText(snippet.name); + if (snippet.description) { + const descEl = infoEl.createDiv({ cls: "claudian-snippet-description" }); + descEl.setText(snippet.description); + } + const actionsEl = itemEl.createDiv({ cls: "claudian-snippet-actions" }); + const restoreBtn = actionsEl.createEl("button", { + cls: "claudian-settings-action-btn", + attr: { "aria-label": "Insert" } + }); + (0, import_obsidian4.setIcon)(restoreBtn, "clipboard-paste"); + restoreBtn.addEventListener("click", async () => { + try { + await this.insertSnippet(snippet); + } catch (e3) { + new import_obsidian4.Notice("Failed to insert snippet"); + } + }); + const editBtn = actionsEl.createEl("button", { + cls: "claudian-settings-action-btn", + attr: { "aria-label": "Edit" } + }); + (0, import_obsidian4.setIcon)(editBtn, "pencil"); + editBtn.addEventListener("click", () => { + this.editSnippet(snippet); + }); + const deleteBtn = actionsEl.createEl("button", { + cls: "claudian-settings-action-btn claudian-settings-delete-btn", + attr: { "aria-label": "Delete" } + }); + (0, import_obsidian4.setIcon)(deleteBtn, "trash-2"); + deleteBtn.addEventListener("click", async () => { + try { + if (confirm(`Delete environment snippet "${snippet.name}"?`)) { + await this.deleteSnippet(snippet); + } + } catch (e3) { + new import_obsidian4.Notice("Failed to delete snippet"); + } + }); + } + } + async saveCurrentEnv() { + const modal = new EnvSnippetModal( + this.plugin.app, + this.plugin, + null, + this.scope, + async (snippet) => { + this.plugin.settings.envSnippets.push(snippet); + await this.plugin.saveSettings(); + this.render(); + new import_obsidian4.Notice(`Environment snippet "${snippet.name}" saved`); + } + ); + modal.open(); + } + async insertSnippet(snippet) { + var _a3, _b2, _c; + const snippetContent = snippet.envVars.trim(); + const updates = getEnvironmentScopeUpdates( + snippetContent, + (_a3 = snippet.scope) != null ? _a3 : this.scope + ); + if (updates.length === 1) { + const [update] = updates; + this.syncTextareaValue(update.scope, update.envText); + await this.plugin.applyEnvironmentVariables(update.scope, update.envText); + } else if (updates.length > 1) { + for (const update of updates) { + this.syncTextareaValue(update.scope, update.envText); + } + await this.plugin.applyEnvironmentVariablesBatch(updates); + } + if (snippet.contextLimits) { + this.plugin.settings.customContextLimits = { + ...this.plugin.settings.customContextLimits, + ...snippet.contextLimits + }; + } + await this.plugin.saveSettings(); + (_b2 = this.onContextLimitsChange) == null ? void 0 : _b2.call(this); + const view = (_c = this.plugin.app.workspace.getLeavesOfType("claudian-view")[0]) == null ? void 0 : _c.view; + view == null ? void 0 : view.refreshModelSelector(); + } + editSnippet(snippet) { + const modal = new EnvSnippetModal( + this.plugin.app, + this.plugin, + snippet, + this.scope, + async (updatedSnippet) => { + const index = this.plugin.settings.envSnippets.findIndex((s3) => s3.id === snippet.id); + if (index !== -1) { + this.plugin.settings.envSnippets[index] = updatedSnippet; + await this.plugin.saveSettings(); + this.render(); + new import_obsidian4.Notice(`Environment snippet "${updatedSnippet.name}" updated`); + } + } + ); + modal.open(); + } + async deleteSnippet(snippet) { + this.plugin.settings.envSnippets = this.plugin.settings.envSnippets.filter((s3) => s3.id !== snippet.id); + await this.plugin.saveSettings(); + this.render(); + new import_obsidian4.Notice(`Environment snippet "${snippet.name}" deleted`); + } + refresh() { + this.render(); + } + shouldDisplaySnippet(snippet) { + if (this.scope === "shared") { + return !snippet.scope || snippet.scope === "shared"; + } + return snippet.scope === this.scope; + } + syncTextareaValue(scope, value) { + const selector = `.claudian-settings-env-textarea[data-env-scope="${scope}"]`; + const envTextarea = document.querySelector(selector); + if (envTextarea) { + envTextarea.value = value; + } + } +}; + +// src/features/settings/ui/EnvironmentSettingsSection.ts +function renderEnvironmentSettingsSection(options) { + const { + container, + plugin, + scope, + heading, + name, + desc, + placeholder, + renderCustomContextLimits + } = options; + if (heading) { + new import_obsidian5.Setting(container).setName(heading).setHeading(); + } + let envTextarea = null; + const reviewEl = container.createDiv({ cls: "claudian-env-review-warning" }); + reviewEl.style.color = "var(--text-warning)"; + reviewEl.style.fontSize = "0.85em"; + reviewEl.style.marginTop = "-0.5em"; + reviewEl.style.marginBottom = "0.5em"; + reviewEl.style.display = "none"; + const updateReviewWarning = () => { + var _a3; + const reviewKeys = getEnvironmentReviewKeysForScope((_a3 = envTextarea == null ? void 0 : envTextarea.value) != null ? _a3 : "", scope); + if (reviewKeys.length === 0) { + reviewEl.style.display = "none"; + reviewEl.empty(); + return; + } + reviewEl.setText(`Review environment ownership for: ${reviewKeys.join(", ")}`); + reviewEl.style.display = "block"; + }; + new import_obsidian5.Setting(container).setName(name).setDesc(desc).addTextArea((text) => { + text.setPlaceholder(placeholder).setValue(plugin.getEnvironmentVariablesForScope(scope)); + text.inputEl.rows = 6; + text.inputEl.cols = 50; + text.inputEl.addClass("claudian-settings-env-textarea"); + text.inputEl.dataset.envScope = scope; + text.inputEl.addEventListener("input", () => updateReviewWarning()); + text.inputEl.addEventListener("blur", async () => { + await plugin.applyEnvironmentVariables(scope, text.inputEl.value); + renderCustomContextLimits == null ? void 0 : renderCustomContextLimits(contextLimitsContainer); + updateReviewWarning(); + }); + envTextarea = text.inputEl; + }); + updateReviewWarning(); + const contextLimitsContainer = container.createDiv({ cls: "claudian-context-limits-container" }); + renderCustomContextLimits == null ? void 0 : renderCustomContextLimits(contextLimitsContainer); + const envSnippetsContainer = container.createDiv({ cls: "claudian-env-snippets-container" }); + new EnvSnippetManager(envSnippetsContainer, plugin, scope, () => { + renderCustomContextLimits == null ? void 0 : renderCustomContextLimits(contextLimitsContainer); + }); +} + +// src/features/settings/ui/McpSettingsManager.ts +var import_obsidian8 = require("obsidian"); + +// src/core/mcp/McpConfigParser.ts +function parseClipboardConfig(json2) { + try { + const parsed = JSON.parse(json2); + if (!parsed || typeof parsed !== "object") { + throw new Error("Invalid JSON object"); + } + if (parsed.mcpServers && typeof parsed.mcpServers === "object") { + const servers2 = []; + for (const [name, config2] of Object.entries(parsed.mcpServers)) { + if (isValidMcpServerConfig(config2)) { + servers2.push({ name, config: config2 }); + } + } + if (servers2.length === 0) { + throw new Error("No valid server configs found in mcpServers"); + } + return { servers: servers2, needsName: false }; + } + if (isValidMcpServerConfig(parsed)) { + return { + servers: [{ name: "", config: parsed }], + needsName: true + }; + } + const entries = Object.entries(parsed); + if (entries.length === 1) { + const [name, config2] = entries[0]; + if (isValidMcpServerConfig(config2)) { + return { + servers: [{ name, config: config2 }], + needsName: false + }; + } + } + const servers = []; + for (const [name, config2] of entries) { + if (isValidMcpServerConfig(config2)) { + servers.push({ name, config: config2 }); + } + } + if (servers.length > 0) { + return { servers, needsName: false }; + } + throw new Error("Invalid MCP configuration format"); + } catch (error48) { + if (error48 instanceof SyntaxError) { + throw new Error("Invalid JSON", { cause: error48 }); + } + throw error48; + } +} +function tryParseClipboardConfig(text) { + const trimmed = text.trim(); + if (!trimmed.startsWith("{")) { + return null; + } + try { + return parseClipboardConfig(trimmed); + } catch (e3) { + return null; + } +} + +// node_modules/zod/v3/helpers/util.js +var util; +(function(util2) { + util2.assertEqual = (_3) => { + }; + function assertIs2(_arg) { + } + util2.assertIs = assertIs2; + function assertNever2(_x) { + throw new Error(); + } + util2.assertNever = assertNever2; + util2.arrayToEnum = (items) => { + const obj = {}; + for (const item of items) { + obj[item] = item; + } + return obj; + }; + util2.getValidEnumValues = (obj) => { + const validKeys = util2.objectKeys(obj).filter((k3) => typeof obj[obj[k3]] !== "number"); + const filtered = {}; + for (const k3 of validKeys) { + filtered[k3] = obj[k3]; + } + return util2.objectValues(filtered); + }; + util2.objectValues = (obj) => { + return util2.objectKeys(obj).map(function(e3) { + return obj[e3]; + }); + }; + util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object3) => { + const keys = []; + for (const key in object3) { + if (Object.prototype.hasOwnProperty.call(object3, key)) { + keys.push(key); + } + } + return keys; + }; + util2.find = (arr, checker) => { + for (const item of arr) { + if (checker(item)) + return item; + } + return void 0; + }; + util2.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val; + function joinValues2(array2, separator = " | ") { + return array2.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator); + } + util2.joinValues = joinValues2; + util2.jsonStringifyReplacer = (_3, value) => { + if (typeof value === "bigint") { + return value.toString(); + } + return value; + }; +})(util || (util = {})); +var objectUtil; +(function(objectUtil2) { + objectUtil2.mergeShapes = (first, second) => { + return { + ...first, + ...second + // second overwrites first + }; + }; +})(objectUtil || (objectUtil = {})); +var ZodParsedType = util.arrayToEnum([ + "string", + "nan", + "number", + "integer", + "float", + "boolean", + "date", + "bigint", + "symbol", + "function", + "undefined", + "null", + "array", + "object", + "unknown", + "promise", + "void", + "never", + "map", + "set" +]); +var getParsedType = (data) => { + const t3 = typeof data; + switch (t3) { + case "undefined": + return ZodParsedType.undefined; + case "string": + return ZodParsedType.string; + case "number": + return Number.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; + } +}; + +// node_modules/zod/v3/ZodError.js +var 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" +]); +var ZodError = class _ZodError extends Error { + get errors() { + return this.issues; + } + 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) { + Object.setPrototypeOf(this, actualProto); + } else { + this.__proto__ = actualProto; + } + this.name = "ZodError"; + this.issues = issues; + } + format(_mapper) { + const mapper = _mapper || function(issue2) { + return issue2.message; + }; + const fieldErrors = { _errors: [] }; + const processError = (error48) => { + for (const issue2 of error48.issues) { + if (issue2.code === "invalid_union") { + issue2.unionErrors.map(processError); + } else if (issue2.code === "invalid_return_type") { + processError(issue2.returnTypeError); + } else if (issue2.code === "invalid_arguments") { + processError(issue2.argumentsError); + } else if (issue2.path.length === 0) { + fieldErrors._errors.push(mapper(issue2)); + } else { + let curr = fieldErrors; + let i3 = 0; + while (i3 < issue2.path.length) { + const el2 = issue2.path[i3]; + const terminal = i3 === issue2.path.length - 1; + if (!terminal) { + curr[el2] = curr[el2] || { _errors: [] }; + } else { + curr[el2] = curr[el2] || { _errors: [] }; + curr[el2]._errors.push(mapper(issue2)); + } + curr = curr[el2]; + i3++; + } + } + } + }; + 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 = (issue2) => issue2.message) { + const fieldErrors = /* @__PURE__ */ Object.create(null); + const formErrors = []; + for (const sub of this.issues) { + if (sub.path.length > 0) { + const firstEl = sub.path[0]; + fieldErrors[firstEl] = fieldErrors[firstEl] || []; + fieldErrors[firstEl].push(mapper(sub)); + } else { + formErrors.push(mapper(sub)); + } + } + return { formErrors, fieldErrors }; + } + get formErrors() { + return this.flatten(); + } +}; +ZodError.create = (issues) => { + const error48 = new ZodError(issues); + return error48; +}; + +// node_modules/zod/v3/locales/en.js +var errorMap = (issue2, _ctx) => { + let message; + switch (issue2.code) { + case ZodIssueCode.invalid_type: + if (issue2.received === ZodParsedType.undefined) { + message = "Required"; + } else { + message = `Expected ${issue2.expected}, received ${issue2.received}`; + } + break; + case ZodIssueCode.invalid_literal: + message = `Invalid literal value, expected ${JSON.stringify(issue2.expected, util.jsonStringifyReplacer)}`; + break; + case ZodIssueCode.unrecognized_keys: + message = `Unrecognized key(s) in object: ${util.joinValues(issue2.keys, ", ")}`; + break; + case ZodIssueCode.invalid_union: + message = `Invalid input`; + break; + case ZodIssueCode.invalid_union_discriminator: + message = `Invalid discriminator value. Expected ${util.joinValues(issue2.options)}`; + break; + case ZodIssueCode.invalid_enum_value: + message = `Invalid enum value. Expected ${util.joinValues(issue2.options)}, received '${issue2.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 issue2.validation === "object") { + if ("includes" in issue2.validation) { + message = `Invalid input: must include "${issue2.validation.includes}"`; + if (typeof issue2.validation.position === "number") { + message = `${message} at one or more positions greater than or equal to ${issue2.validation.position}`; + } + } else if ("startsWith" in issue2.validation) { + message = `Invalid input: must start with "${issue2.validation.startsWith}"`; + } else if ("endsWith" in issue2.validation) { + message = `Invalid input: must end with "${issue2.validation.endsWith}"`; + } else { + util.assertNever(issue2.validation); + } + } else if (issue2.validation !== "regex") { + message = `Invalid ${issue2.validation}`; + } else { + message = "Invalid"; + } + break; + case ZodIssueCode.too_small: + if (issue2.type === "array") + message = `Array must contain ${issue2.exact ? "exactly" : issue2.inclusive ? `at least` : `more than`} ${issue2.minimum} element(s)`; + else if (issue2.type === "string") + message = `String must contain ${issue2.exact ? "exactly" : issue2.inclusive ? `at least` : `over`} ${issue2.minimum} character(s)`; + else if (issue2.type === "number") + message = `Number must be ${issue2.exact ? `exactly equal to ` : issue2.inclusive ? `greater than or equal to ` : `greater than `}${issue2.minimum}`; + else if (issue2.type === "bigint") + message = `Number must be ${issue2.exact ? `exactly equal to ` : issue2.inclusive ? `greater than or equal to ` : `greater than `}${issue2.minimum}`; + else if (issue2.type === "date") + message = `Date must be ${issue2.exact ? `exactly equal to ` : issue2.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue2.minimum))}`; + else + message = "Invalid input"; + break; + case ZodIssueCode.too_big: + if (issue2.type === "array") + message = `Array must contain ${issue2.exact ? `exactly` : issue2.inclusive ? `at most` : `less than`} ${issue2.maximum} element(s)`; + else if (issue2.type === "string") + message = `String must contain ${issue2.exact ? `exactly` : issue2.inclusive ? `at most` : `under`} ${issue2.maximum} character(s)`; + else if (issue2.type === "number") + message = `Number must be ${issue2.exact ? `exactly` : issue2.inclusive ? `less than or equal to` : `less than`} ${issue2.maximum}`; + else if (issue2.type === "bigint") + message = `BigInt must be ${issue2.exact ? `exactly` : issue2.inclusive ? `less than or equal to` : `less than`} ${issue2.maximum}`; + else if (issue2.type === "date") + message = `Date must be ${issue2.exact ? `exactly` : issue2.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue2.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 ${issue2.multipleOf}`; + break; + case ZodIssueCode.not_finite: + message = "Number must be finite"; + break; + default: + message = _ctx.defaultError; + util.assertNever(issue2); + } + return { message }; +}; +var en_default2 = errorMap; + +// node_modules/zod/v3/errors.js +var overrideErrorMap = en_default2; +function getErrorMap() { + return overrideErrorMap; +} + +// node_modules/zod/v3/helpers/parseUtil.js +var makeIssue = (params) => { + const { data, path: path19, errorMaps, issueData } = params; + const fullPath = [...path19, ...issueData.path || []]; + const fullIssue = { + ...issueData, + path: fullPath + }; + if (issueData.message !== void 0) { + return { + ...issueData, + path: fullPath, + message: issueData.message + }; + } + let errorMessage = ""; + const maps = errorMaps.filter((m3) => !!m3).slice().reverse(); + for (const map2 of maps) { + errorMessage = map2(fullIssue, { data, defaultError: errorMessage }).message; + } + return { + ...issueData, + path: fullPath, + message: errorMessage + }; +}; +function addIssueToContext(ctx, issueData) { + const overrideMap = getErrorMap(); + const issue2 = makeIssue({ + issueData, + data: ctx.data, + path: ctx.path, + errorMaps: [ + ctx.common.contextualErrorMap, + // contextual error map is first priority + ctx.schemaErrorMap, + // then schema-bound map if available + overrideMap, + // then global override map + overrideMap === en_default2 ? void 0 : en_default2 + // then global default map + ].filter((x) => !!x) + }); + ctx.common.issues.push(issue2); +} +var ParseStatus = 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 s3 of results) { + if (s3.status === "aborted") + return INVALID; + if (s3.status === "dirty") + status.dirty(); + arrayValue.push(s3.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 }; + } +}; +var INVALID = Object.freeze({ + status: "aborted" +}); +var DIRTY = (value) => ({ status: "dirty", value }); +var OK = (value) => ({ status: "valid", value }); +var isAborted = (x) => x.status === "aborted"; +var isDirty = (x) => x.status === "dirty"; +var isValid = (x) => x.status === "valid"; +var isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise; + +// node_modules/zod/v3/helpers/errorUtil.js +var errorUtil; +(function(errorUtil2) { + errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {}; + errorUtil2.toString = (message) => typeof message === "string" ? message : message == null ? void 0 : message.message; +})(errorUtil || (errorUtil = {})); + +// node_modules/zod/v3/types.js +var ParseInputLazyPath = class { + constructor(parent, value, path19, key) { + this._cachedPath = []; + this.parent = parent; + this.data = value; + this._path = path19; + this._key = key; + } + get path() { + if (!this._cachedPath.length) { + if (Array.isArray(this._key)) { + this._cachedPath.push(...this._path, ...this._key); + } else { + this._cachedPath.push(...this._path, this._key); + } + } + return this._cachedPath; + } +}; +var 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 error48 = new ZodError(ctx.common.issues); + this._error = error48; + return this._error; + } + }; + } +}; +function processCreateParams(params) { + if (!params) + return {}; + const { errorMap: errorMap2, invalid_type_error, required_error, description } = params; + if (errorMap2 && (invalid_type_error || required_error)) { + throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`); + } + if (errorMap2) + return { errorMap: errorMap2, description }; + const customMap = (iss, ctx) => { + var _a3, _b2; + const { message } = params; + if (iss.code === "invalid_enum_value") { + return { message: message != null ? message : ctx.defaultError }; + } + if (typeof ctx.data === "undefined") { + return { message: (_a3 = message != null ? message : required_error) != null ? _a3 : ctx.defaultError }; + } + if (iss.code !== "invalid_type") + return { message: ctx.defaultError }; + return { message: (_b2 = message != null ? message : invalid_type_error) != null ? _b2 : ctx.defaultError }; + }; + return { errorMap: customMap, description }; +} +var ZodType = class { + 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 _a3; + const ctx = { + common: { + issues: [], + async: (_a3 = params == null ? void 0 : params.async) != null ? _a3 : false, + contextualErrorMap: params == null ? void 0 : params.errorMap + }, + path: (params == null ? 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); + } + "~validate"(data) { + var _a3, _b2; + const ctx = { + common: { + issues: [], + async: !!this["~standard"].async + }, + path: [], + schemaErrorMap: this._def.errorMap, + parent: null, + data, + parsedType: getParsedType(data) + }; + if (!this["~standard"].async) { + try { + const result = this._parseSync({ data, path: [], parent: ctx }); + return isValid(result) ? { + value: result.value + } : { + issues: ctx.common.issues + }; + } catch (err) { + if ((_b2 = (_a3 = err == null ? void 0 : err.message) == null ? void 0 : _a3.toLowerCase()) == null ? void 0 : _b2.includes("encountered")) { + this["~standard"].async = true; + } + ctx.common = { + issues: [], + async: true + }; + } + } + return this._parseAsync({ data, path: [], parent: ctx }).then((result) => isValid(result) ? { + value: result.value + } : { + issues: ctx.common.issues + }); + } + 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 ? void 0 : params.errorMap, + async: true + }, + path: (params == null ? 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(check2, 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 = check2(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(check2, refinementData) { + return this._refinement((val, ctx) => { + if (!check2(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); + } + constructor(def) { + 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); + this["~standard"] = { + version: 1, + vendor: "zod", + validate: (data) => this["~validate"](data) + }; + } + optional() { + return ZodOptional.create(this, this._def); + } + nullable() { + return ZodNullable.create(this, this._def); + } + nullish() { + return this.nullable().optional(); + } + array() { + return ZodArray.create(this); + } + 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(transform2) { + return new ZodEffects({ + ...processCreateParams(this._def), + schema: this, + typeName: ZodFirstPartyTypeKind.ZodEffects, + effect: { type: "transform", transform: transform2 } + }); + } + 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(void 0).success; + } + isNullable() { + return this.safeParse(null).success; + } +}; +var cuidRegex = /^c[^\s-]{8,}$/i; +var cuid2Regex = /^[0-9a-z]+$/; +var ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/i; +var 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; +var nanoidRegex = /^[a-z0-9_-]{21}$/i; +var jwtRegex = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/; +var 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)?)??$/; +var emailRegex = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i; +var _emojiRegex = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`; +var emojiRegex; +var 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])$/; +var ipv4CidrRegex = /^(?:(?: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])\/(3[0-2]|[12]?[0-9])$/; +var ipv6Regex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/; +var ipv6CidrRegex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/; +var base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/; +var base64urlRegex = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/; +var 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])))`; +var dateRegex = new RegExp(`^${dateRegexSource}$`); +function timeRegexSource(args) { + let secondsRegexSource = `[0-5]\\d`; + if (args.precision) { + secondsRegexSource = `${secondsRegexSource}\\.\\d{${args.precision}}`; + } else if (args.precision == null) { + secondsRegexSource = `${secondsRegexSource}(\\.\\d+)?`; + } + const secondsQuantifier = args.precision ? "+" : "?"; + return `([01]\\d|2[0-3]):[0-5]\\d(:${secondsRegexSource})${secondsQuantifier}`; +} +function timeRegex(args) { + return new RegExp(`^${timeRegexSource(args)}$`); +} +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, version2) { + if ((version2 === "v4" || !version2) && ipv4Regex.test(ip)) { + return true; + } + if ((version2 === "v6" || !version2) && ipv6Regex.test(ip)) { + return true; + } + return false; +} +function isValidJWT(jwt2, alg) { + if (!jwtRegex.test(jwt2)) + return false; + try { + const [header] = jwt2.split("."); + if (!header) + return false; + const base643 = header.replace(/-/g, "+").replace(/_/g, "/").padEnd(header.length + (4 - header.length % 4) % 4, "="); + const decoded = JSON.parse(atob(base643)); + if (typeof decoded !== "object" || decoded === null) + return false; + if ("typ" in decoded && (decoded == null ? void 0 : decoded.typ) !== "JWT") + return false; + if (!decoded.alg) + return false; + if (alg && decoded.alg !== alg) + return false; + return true; + } catch (e3) { + return false; + } +} +function isValidCidr(ip, version2) { + if ((version2 === "v4" || !version2) && ipv4CidrRegex.test(ip)) { + return true; + } + if ((version2 === "v6" || !version2) && ipv6CidrRegex.test(ip)) { + return true; + } + return false; +} +var ZodString = class _ZodString2 extends ZodType { + _parse(input) { + if (this._def.coerce) { + input.data = String(input.data); + } + const parsedType2 = this._getType(input); + if (parsedType2 !== ZodParsedType.string) { + const ctx2 = this._getOrReturnCtx(input); + addIssueToContext(ctx2, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.string, + received: ctx2.parsedType + }); + return INVALID; + } + const status = new ParseStatus(); + let ctx = void 0; + for (const check2 of this._def.checks) { + if (check2.kind === "min") { + if (input.data.length < check2.value) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: check2.value, + type: "string", + inclusive: true, + exact: false, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "max") { + if (input.data.length > check2.value) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: check2.value, + type: "string", + inclusive: true, + exact: false, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "length") { + const tooBig = input.data.length > check2.value; + const tooSmall = input.data.length < check2.value; + if (tooBig || tooSmall) { + ctx = this._getOrReturnCtx(input, ctx); + if (tooBig) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: check2.value, + type: "string", + inclusive: true, + exact: true, + message: check2.message + }); + } else if (tooSmall) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: check2.value, + type: "string", + inclusive: true, + exact: true, + message: check2.message + }); + } + status.dirty(); + } + } else if (check2.kind === "email") { + if (!emailRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "email", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.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: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "uuid") { + if (!uuidRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "uuid", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "nanoid") { + if (!nanoidRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "nanoid", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "cuid") { + if (!cuidRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "cuid", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "cuid2") { + if (!cuid2Regex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "cuid2", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "ulid") { + if (!ulidRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "ulid", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "url") { + try { + new URL(input.data); + } catch (e3) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "url", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "regex") { + check2.regex.lastIndex = 0; + const testResult = check2.regex.test(input.data); + if (!testResult) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "regex", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "trim") { + input.data = input.data.trim(); + } else if (check2.kind === "includes") { + if (!input.data.includes(check2.value, check2.position)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: { includes: check2.value, position: check2.position }, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "toLowerCase") { + input.data = input.data.toLowerCase(); + } else if (check2.kind === "toUpperCase") { + input.data = input.data.toUpperCase(); + } else if (check2.kind === "startsWith") { + if (!input.data.startsWith(check2.value)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: { startsWith: check2.value }, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "endsWith") { + if (!input.data.endsWith(check2.value)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: { endsWith: check2.value }, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "datetime") { + const regex = datetimeRegex(check2); + if (!regex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: "datetime", + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "date") { + const regex = dateRegex; + if (!regex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: "date", + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "time") { + const regex = timeRegex(check2); + if (!regex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: "time", + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "duration") { + if (!durationRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "duration", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "ip") { + if (!isValidIP(input.data, check2.version)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "ip", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "jwt") { + if (!isValidJWT(input.data, check2.alg)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "jwt", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "cidr") { + if (!isValidCidr(input.data, check2.version)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "cidr", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "base64") { + if (!base64Regex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "base64", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "base64url") { + if (!base64urlRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "base64url", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else { + util.assertNever(check2); + } + } + 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(check2) { + return new _ZodString2({ + ...this._def, + checks: [...this._def.checks, check2] + }); + } + 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) }); + } + base64url(message) { + return this._addCheck({ + kind: "base64url", + ...errorUtil.errToObj(message) + }); + } + jwt(options) { + return this._addCheck({ kind: "jwt", ...errorUtil.errToObj(options) }); + } + ip(options) { + return this._addCheck({ kind: "ip", ...errorUtil.errToObj(options) }); + } + cidr(options) { + return this._addCheck({ kind: "cidr", ...errorUtil.errToObj(options) }); + } + datetime(options) { + var _a3, _b2; + 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 ? void 0 : options.precision) === "undefined" ? null : options == null ? void 0 : options.precision, + offset: (_a3 = options == null ? void 0 : options.offset) != null ? _a3 : false, + local: (_b2 = options == null ? void 0 : options.local) != null ? _b2 : false, + ...errorUtil.errToObj(options == null ? 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 ? void 0 : options.precision) === "undefined" ? null : options == null ? void 0 : options.precision, + ...errorUtil.errToObj(options == null ? void 0 : options.message) + }); + } + duration(message) { + return this._addCheck({ kind: "duration", ...errorUtil.errToObj(message) }); + } + regex(regex, message) { + return this._addCheck({ + kind: "regex", + regex, + ...errorUtil.errToObj(message) + }); + } + includes(value, options) { + return this._addCheck({ + kind: "includes", + value, + position: options == null ? void 0 : options.position, + ...errorUtil.errToObj(options == null ? void 0 : options.message) + }); + } + startsWith(value, message) { + return this._addCheck({ + kind: "startsWith", + value, + ...errorUtil.errToObj(message) + }); + } + endsWith(value, message) { + return this._addCheck({ + kind: "endsWith", + 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) + }); + } + /** + * Equivalent to `.min(1)` + */ + nonempty(message) { + return this.min(1, errorUtil.errToObj(message)); + } + trim() { + return new _ZodString2({ + ...this._def, + checks: [...this._def.checks, { kind: "trim" }] + }); + } + toLowerCase() { + return new _ZodString2({ + ...this._def, + checks: [...this._def.checks, { kind: "toLowerCase" }] + }); + } + toUpperCase() { + return new _ZodString2({ + ...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 isCIDR() { + return !!this._def.checks.find((ch) => ch.kind === "cidr"); + } + get isBase64() { + return !!this._def.checks.find((ch) => ch.kind === "base64"); + } + get isBase64url() { + return !!this._def.checks.find((ch) => ch.kind === "base64url"); + } + 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 _a3; + return new ZodString({ + checks: [], + typeName: ZodFirstPartyTypeKind.ZodString, + coerce: (_a3 = params == null ? void 0 : params.coerce) != null ? _a3 : false, + ...processCreateParams(params) + }); +}; +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 = Number.parseInt(val.toFixed(decCount).replace(".", "")); + const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", "")); + return valInt % stepInt / 10 ** decCount; +} +var ZodNumber = 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 parsedType2 = this._getType(input); + if (parsedType2 !== ZodParsedType.number) { + const ctx2 = this._getOrReturnCtx(input); + addIssueToContext(ctx2, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.number, + received: ctx2.parsedType + }); + return INVALID; + } + let ctx = void 0; + const status = new ParseStatus(); + for (const check2 of this._def.checks) { + if (check2.kind === "int") { + if (!util.isInteger(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: "integer", + received: "float", + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "min") { + const tooSmall = check2.inclusive ? input.data < check2.value : input.data <= check2.value; + if (tooSmall) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: check2.value, + type: "number", + inclusive: check2.inclusive, + exact: false, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "max") { + const tooBig = check2.inclusive ? input.data > check2.value : input.data >= check2.value; + if (tooBig) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: check2.value, + type: "number", + inclusive: check2.inclusive, + exact: false, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "multipleOf") { + if (floatSafeRemainder(input.data, check2.value) !== 0) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.not_multiple_of, + multipleOf: check2.value, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "finite") { + if (!Number.isFinite(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.not_finite, + message: check2.message + }); + status.dirty(); + } + } else { + util.assertNever(check2); + } + } + 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(check2) { + return new _ZodNumber({ + ...this._def, + checks: [...this._def.checks, check2] + }); + } + 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, + 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; + let 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 ? void 0 : params.coerce) || false, + ...processCreateParams(params) + }); +}; +var ZodBigInt = class _ZodBigInt extends ZodType { + constructor() { + super(...arguments); + this.min = this.gte; + this.max = this.lte; + } + _parse(input) { + if (this._def.coerce) { + try { + input.data = BigInt(input.data); + } catch (e3) { + return this._getInvalidInput(input); + } + } + const parsedType2 = this._getType(input); + if (parsedType2 !== ZodParsedType.bigint) { + return this._getInvalidInput(input); + } + let ctx = void 0; + const status = new ParseStatus(); + for (const check2 of this._def.checks) { + if (check2.kind === "min") { + const tooSmall = check2.inclusive ? input.data < check2.value : input.data <= check2.value; + if (tooSmall) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + type: "bigint", + minimum: check2.value, + inclusive: check2.inclusive, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "max") { + const tooBig = check2.inclusive ? input.data > check2.value : input.data >= check2.value; + if (tooBig) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + type: "bigint", + maximum: check2.value, + inclusive: check2.inclusive, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "multipleOf") { + if (input.data % check2.value !== BigInt(0)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.not_multiple_of, + multipleOf: check2.value, + message: check2.message + }); + status.dirty(); + } + } else { + util.assertNever(check2); + } + } + return { status: status.value, value: input.data }; + } + _getInvalidInput(input) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.bigint, + received: ctx.parsedType + }); + return INVALID; + } + 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(check2) { + return new _ZodBigInt({ + ...this._def, + checks: [...this._def.checks, check2] + }); + } + 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 _a3; + return new ZodBigInt({ + checks: [], + typeName: ZodFirstPartyTypeKind.ZodBigInt, + coerce: (_a3 = params == null ? void 0 : params.coerce) != null ? _a3 : false, + ...processCreateParams(params) + }); +}; +var ZodBoolean = class extends ZodType { + _parse(input) { + if (this._def.coerce) { + input.data = Boolean(input.data); + } + const parsedType2 = this._getType(input); + if (parsedType2 !== 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 ? void 0 : params.coerce) || false, + ...processCreateParams(params) + }); +}; +var ZodDate = class _ZodDate extends ZodType { + _parse(input) { + if (this._def.coerce) { + input.data = new Date(input.data); + } + const parsedType2 = this._getType(input); + if (parsedType2 !== ZodParsedType.date) { + const ctx2 = this._getOrReturnCtx(input); + addIssueToContext(ctx2, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.date, + received: ctx2.parsedType + }); + return INVALID; + } + if (Number.isNaN(input.data.getTime())) { + const ctx2 = this._getOrReturnCtx(input); + addIssueToContext(ctx2, { + code: ZodIssueCode.invalid_date + }); + return INVALID; + } + const status = new ParseStatus(); + let ctx = void 0; + for (const check2 of this._def.checks) { + if (check2.kind === "min") { + if (input.data.getTime() < check2.value) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + message: check2.message, + inclusive: true, + exact: false, + minimum: check2.value, + type: "date" + }); + status.dirty(); + } + } else if (check2.kind === "max") { + if (input.data.getTime() > check2.value) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + message: check2.message, + inclusive: true, + exact: false, + maximum: check2.value, + type: "date" + }); + status.dirty(); + } + } else { + util.assertNever(check2); + } + } + return { + status: status.value, + value: new Date(input.data.getTime()) + }; + } + _addCheck(check2) { + return new _ZodDate({ + ...this._def, + checks: [...this._def.checks, check2] + }); + } + 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 ? void 0 : params.coerce) || false, + typeName: ZodFirstPartyTypeKind.ZodDate, + ...processCreateParams(params) + }); +}; +var ZodSymbol = class extends ZodType { + _parse(input) { + const parsedType2 = this._getType(input); + if (parsedType2 !== 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) + }); +}; +var ZodUndefined = class extends ZodType { + _parse(input) { + const parsedType2 = this._getType(input); + if (parsedType2 !== 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) + }); +}; +var ZodNull = class extends ZodType { + _parse(input) { + const parsedType2 = this._getType(input); + if (parsedType2 !== 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) + }); +}; +var ZodAny = class extends ZodType { + constructor() { + super(...arguments); + this._any = true; + } + _parse(input) { + return OK(input.data); + } +}; +ZodAny.create = (params) => { + return new ZodAny({ + typeName: ZodFirstPartyTypeKind.ZodAny, + ...processCreateParams(params) + }); +}; +var ZodUnknown = class extends ZodType { + constructor() { + super(...arguments); + this._unknown = true; + } + _parse(input) { + return OK(input.data); + } +}; +ZodUnknown.create = (params) => { + return new ZodUnknown({ + typeName: ZodFirstPartyTypeKind.ZodUnknown, + ...processCreateParams(params) + }); +}; +var ZodNever = class 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) + }); +}; +var ZodVoid = class extends ZodType { + _parse(input) { + const parsedType2 = this._getType(input); + if (parsedType2 !== 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) + }); +}; +var ZodArray = 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 : void 0, + maximum: tooBig ? def.exactLength.value : void 0, + 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, i3) => { + return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i3)); + })).then((result2) => { + return ParseStatus.mergeArray(status, result2); + }); + } + const result = [...ctx.data].map((item, i3) => { + return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i3)); + }); + 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; + } +} +var ZodObject = class _ZodObject extends ZodType { + constructor() { + super(...arguments); + this._cached = null; + this.nonstrict = this.passthrough; + this.augment = this.extend; + } + _getCached() { + if (this._cached !== null) + return this._cached; + const shape = this._def.shape(); + const keys = util.objectKeys(shape); + this._cached = { shape, keys }; + return this._cached; + } + _parse(input) { + const parsedType2 = this._getType(input); + if (parsedType2 !== ZodParsedType.object) { + const ctx2 = this._getOrReturnCtx(input); + addIssueToContext(ctx2, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.object, + received: ctx2.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 { + 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 !== void 0 ? { + errorMap: (issue2, ctx) => { + var _a3, _b2, _c, _d; + const defaultError = (_c = (_b2 = (_a3 = this._def).errorMap) == null ? void 0 : _b2.call(_a3, issue2, ctx).message) != null ? _c : ctx.defaultError; + if (issue2.code === "unrecognized_keys") + return { + message: (_d = errorUtil.errToObj(message).message) != null ? _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 = {}; + for (const key of util.objectKeys(mask)) { + if (mask[key] && this.shape[key]) { + shape[key] = this.shape[key]; + } + } + return new _ZodObject({ + ...this._def, + shape: () => shape + }); + } + omit(mask) { + const shape = {}; + for (const key of util.objectKeys(this.shape)) { + if (!mask[key]) { + shape[key] = this.shape[key]; + } + } + return new _ZodObject({ + ...this._def, + shape: () => shape + }); + } + /** + * @deprecated + */ + deepPartial() { + return deepPartialify(this); + } + partial(mask) { + const newShape = {}; + for (const key of util.objectKeys(this.shape)) { + 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 = {}; + for (const key of util.objectKeys(this.shape)) { + 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) + }); +}; +var ZodUnion = class extends ZodType { + _parse(input) { + const { ctx } = this._processInputParams(input); + const options = this._def.options; + function handleResults(results) { + for (const result of results) { + if (result.result.status === "valid") { + return result.result; + } + } + for (const result of results) { + if (result.result.status === "dirty") { + ctx.common.issues.push(...result.ctx.common.issues); + return result.result; + } + } + 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 = void 0; + 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((issues2) => new ZodError(issues2)); + 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) + }); +}; +var 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) { + return util.objectValues(type.enum); + } else if (type instanceof ZodDefault) { + return getDiscriminator(type._def.innerType); + } else if (type instanceof ZodUndefined) { + return [void 0]; + } else if (type instanceof ZodNull) { + return [null]; + } else if (type instanceof ZodOptional) { + return [void 0, ...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 []; + } +}; +var ZodDiscriminatedUnion = 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) { + const optionsMap = /* @__PURE__ */ new Map(); + 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(a3, b) { + const aType = getParsedType(a3); + const bType = getParsedType(b); + if (a3 === b) { + return { valid: true, data: a3 }; + } else if (aType === ZodParsedType.object && bType === ZodParsedType.object) { + const bKeys = util.objectKeys(b); + const sharedKeys = util.objectKeys(a3).filter((key) => bKeys.indexOf(key) !== -1); + const newObj = { ...a3, ...b }; + for (const key of sharedKeys) { + const sharedValue = mergeValues(a3[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 (a3.length !== b.length) { + return { valid: false }; + } + const newArray = []; + for (let index = 0; index < a3.length; index++) { + const itemA = a3[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 && +a3 === +b) { + return { valid: true, data: a3 }; + } else { + return { valid: false }; + } +} +var ZodIntersection = class 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, + right, + typeName: ZodFirstPartyTypeKind.ZodIntersection, + ...processCreateParams(params) + }); +}; +var ZodTuple = 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); + 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) + }); +}; +var ZodRecord = 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) + }); + } +}; +var ZodMap = class 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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) + }); +}; +var ZodSet = 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(elements2) { + const parsedSet = /* @__PURE__ */ new Set(); + for (const element of elements2) { + 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, i3) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i3))); + if (ctx.common.async) { + return Promise.all(elements).then((elements2) => finalizeSet(elements2)); + } 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) + }); +}; +var ZodFunction = 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, error48) { + return makeIssue({ + data: args, + path: ctx.path, + errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), en_default2].filter((x) => !!x), + issueData: { + code: ZodIssueCode.invalid_arguments, + argumentsError: error48 + } + }); + } + function makeReturnsIssue(returns, error48) { + return makeIssue({ + data: returns, + path: ctx.path, + errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), en_default2].filter((x) => !!x), + issueData: { + code: ZodIssueCode.invalid_return_type, + returnTypeError: error48 + } + }); + } + const params = { errorMap: ctx.common.contextualErrorMap }; + const fn = ctx.data; + if (this._def.returns instanceof ZodPromise) { + const me = this; + return OK(async function(...args) { + const error48 = new ZodError([]); + const parsedArgs = await me._def.args.parseAsync(args, params).catch((e3) => { + error48.addIssue(makeArgsIssue(args, e3)); + throw error48; + }); + const result = await Reflect.apply(fn, this, parsedArgs); + const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e3) => { + error48.addIssue(makeReturnsIssue(result, e3)); + throw error48; + }); + return parsedReturns; + }); + } else { + 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) + }); + } +}; +var ZodLazy = class 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, + typeName: ZodFirstPartyTypeKind.ZodLazy, + ...processCreateParams(params) + }); +}; +var ZodLiteral = class 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, + typeName: ZodFirstPartyTypeKind.ZodLiteral, + ...processCreateParams(params) + }); +}; +function createZodEnum(values, params) { + return new ZodEnum({ + values, + typeName: ZodFirstPartyTypeKind.ZodEnum, + ...processCreateParams(params) + }); +} +var ZodEnum = class _ZodEnum extends ZodType { + _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 (!this._cache) { + this._cache = new Set(this._def.values); + } + if (!this._cache.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.create = createZodEnum; +var ZodNativeEnum = class extends ZodType { + _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 (!this._cache) { + this._cache = new Set(util.getValidEnumValues(this._def.values)); + } + if (!this._cache.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.create = (values, params) => { + return new ZodNativeEnum({ + values, + typeName: ZodFirstPartyTypeKind.ZodNativeEnum, + ...processCreateParams(params) + }); +}; +var ZodPromise = class 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) + }); +}; +var ZodEffects = class 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 (processed2) => { + if (status.value === "aborted") + return INVALID; + const result = await this._def.schema._parseAsync({ + data: processed2, + 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(); + 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 INVALID; + 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 INVALID; + 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 = (preprocess2, schema, params) => { + return new ZodEffects({ + schema, + effect: { type: "preprocess", transform: preprocess2 }, + typeName: ZodFirstPartyTypeKind.ZodEffects, + ...processCreateParams(params) + }); +}; +var ZodOptional = class extends ZodType { + _parse(input) { + const parsedType2 = this._getType(input); + if (parsedType2 === ZodParsedType.undefined) { + return OK(void 0); + } + 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) + }); +}; +var ZodNullable = class extends ZodType { + _parse(input) { + const parsedType2 = this._getType(input); + if (parsedType2 === 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) + }); +}; +var ZodDefault = class 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) + }); +}; +var ZodCatch = class extends ZodType { + _parse(input) { + const { ctx } = this._processInputParams(input); + 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((result2) => { + return { + status: "valid", + value: result2.status === "valid" ? result2.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) + }); +}; +var ZodNaN = class extends ZodType { + _parse(input) { + const parsedType2 = this._getType(input); + if (parsedType2 !== 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) + }); +}; +var ZodBranded = class 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; + } +}; +var ZodPipeline = 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(a3, b) { + return new _ZodPipeline({ + in: a3, + out: b, + typeName: ZodFirstPartyTypeKind.ZodPipeline + }); + } +}; +var ZodReadonly = class 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) + }); +}; +var late = { + object: ZodObject.lazycreate +}; +var ZodFirstPartyTypeKind; +(function(ZodFirstPartyTypeKind3) { + ZodFirstPartyTypeKind3["ZodString"] = "ZodString"; + ZodFirstPartyTypeKind3["ZodNumber"] = "ZodNumber"; + ZodFirstPartyTypeKind3["ZodNaN"] = "ZodNaN"; + ZodFirstPartyTypeKind3["ZodBigInt"] = "ZodBigInt"; + ZodFirstPartyTypeKind3["ZodBoolean"] = "ZodBoolean"; + ZodFirstPartyTypeKind3["ZodDate"] = "ZodDate"; + ZodFirstPartyTypeKind3["ZodSymbol"] = "ZodSymbol"; + ZodFirstPartyTypeKind3["ZodUndefined"] = "ZodUndefined"; + ZodFirstPartyTypeKind3["ZodNull"] = "ZodNull"; + ZodFirstPartyTypeKind3["ZodAny"] = "ZodAny"; + ZodFirstPartyTypeKind3["ZodUnknown"] = "ZodUnknown"; + ZodFirstPartyTypeKind3["ZodNever"] = "ZodNever"; + ZodFirstPartyTypeKind3["ZodVoid"] = "ZodVoid"; + ZodFirstPartyTypeKind3["ZodArray"] = "ZodArray"; + ZodFirstPartyTypeKind3["ZodObject"] = "ZodObject"; + ZodFirstPartyTypeKind3["ZodUnion"] = "ZodUnion"; + ZodFirstPartyTypeKind3["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion"; + ZodFirstPartyTypeKind3["ZodIntersection"] = "ZodIntersection"; + ZodFirstPartyTypeKind3["ZodTuple"] = "ZodTuple"; + ZodFirstPartyTypeKind3["ZodRecord"] = "ZodRecord"; + ZodFirstPartyTypeKind3["ZodMap"] = "ZodMap"; + ZodFirstPartyTypeKind3["ZodSet"] = "ZodSet"; + ZodFirstPartyTypeKind3["ZodFunction"] = "ZodFunction"; + ZodFirstPartyTypeKind3["ZodLazy"] = "ZodLazy"; + ZodFirstPartyTypeKind3["ZodLiteral"] = "ZodLiteral"; + ZodFirstPartyTypeKind3["ZodEnum"] = "ZodEnum"; + ZodFirstPartyTypeKind3["ZodEffects"] = "ZodEffects"; + ZodFirstPartyTypeKind3["ZodNativeEnum"] = "ZodNativeEnum"; + ZodFirstPartyTypeKind3["ZodOptional"] = "ZodOptional"; + ZodFirstPartyTypeKind3["ZodNullable"] = "ZodNullable"; + ZodFirstPartyTypeKind3["ZodDefault"] = "ZodDefault"; + ZodFirstPartyTypeKind3["ZodCatch"] = "ZodCatch"; + ZodFirstPartyTypeKind3["ZodPromise"] = "ZodPromise"; + ZodFirstPartyTypeKind3["ZodBranded"] = "ZodBranded"; + ZodFirstPartyTypeKind3["ZodPipeline"] = "ZodPipeline"; + ZodFirstPartyTypeKind3["ZodReadonly"] = "ZodReadonly"; +})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {})); +var stringType = ZodString.create; +var numberType = ZodNumber.create; +var nanType = ZodNaN.create; +var bigIntType = ZodBigInt.create; +var booleanType = ZodBoolean.create; +var dateType = ZodDate.create; +var symbolType = ZodSymbol.create; +var undefinedType = ZodUndefined.create; +var nullType = ZodNull.create; +var anyType = ZodAny.create; +var unknownType = ZodUnknown.create; +var neverType = ZodNever.create; +var voidType = ZodVoid.create; +var arrayType = ZodArray.create; +var objectType = ZodObject.create; +var strictObjectType = ZodObject.strictCreate; +var unionType = ZodUnion.create; +var discriminatedUnionType = ZodDiscriminatedUnion.create; +var intersectionType = ZodIntersection.create; +var tupleType = ZodTuple.create; +var recordType = ZodRecord.create; +var mapType = ZodMap.create; +var setType = ZodSet.create; +var functionType = ZodFunction.create; +var lazyType = ZodLazy.create; +var literalType = ZodLiteral.create; +var enumType = ZodEnum.create; +var nativeEnumType = ZodNativeEnum.create; +var promiseType = ZodPromise.create; +var effectsType = ZodEffects.create; +var optionalType = ZodOptional.create; +var nullableType = ZodNullable.create; +var preprocessType = ZodEffects.createWithPreprocess; +var pipelineType = ZodPipeline.create; + +// node_modules/zod/v4/core/index.js +var core_exports2 = {}; +__export(core_exports2, { + $ZodAny: () => $ZodAny, + $ZodArray: () => $ZodArray, + $ZodAsyncError: () => $ZodAsyncError, + $ZodBase64: () => $ZodBase64, + $ZodBase64URL: () => $ZodBase64URL, + $ZodBigInt: () => $ZodBigInt, + $ZodBigIntFormat: () => $ZodBigIntFormat, + $ZodBoolean: () => $ZodBoolean, + $ZodCIDRv4: () => $ZodCIDRv4, + $ZodCIDRv6: () => $ZodCIDRv6, + $ZodCUID: () => $ZodCUID, + $ZodCUID2: () => $ZodCUID2, + $ZodCatch: () => $ZodCatch, + $ZodCheck: () => $ZodCheck, + $ZodCheckBigIntFormat: () => $ZodCheckBigIntFormat, + $ZodCheckEndsWith: () => $ZodCheckEndsWith, + $ZodCheckGreaterThan: () => $ZodCheckGreaterThan, + $ZodCheckIncludes: () => $ZodCheckIncludes, + $ZodCheckLengthEquals: () => $ZodCheckLengthEquals, + $ZodCheckLessThan: () => $ZodCheckLessThan, + $ZodCheckLowerCase: () => $ZodCheckLowerCase, + $ZodCheckMaxLength: () => $ZodCheckMaxLength, + $ZodCheckMaxSize: () => $ZodCheckMaxSize, + $ZodCheckMimeType: () => $ZodCheckMimeType, + $ZodCheckMinLength: () => $ZodCheckMinLength, + $ZodCheckMinSize: () => $ZodCheckMinSize, + $ZodCheckMultipleOf: () => $ZodCheckMultipleOf, + $ZodCheckNumberFormat: () => $ZodCheckNumberFormat, + $ZodCheckOverwrite: () => $ZodCheckOverwrite, + $ZodCheckProperty: () => $ZodCheckProperty, + $ZodCheckRegex: () => $ZodCheckRegex, + $ZodCheckSizeEquals: () => $ZodCheckSizeEquals, + $ZodCheckStartsWith: () => $ZodCheckStartsWith, + $ZodCheckStringFormat: () => $ZodCheckStringFormat, + $ZodCheckUpperCase: () => $ZodCheckUpperCase, + $ZodCodec: () => $ZodCodec, + $ZodCustom: () => $ZodCustom, + $ZodCustomStringFormat: () => $ZodCustomStringFormat, + $ZodDate: () => $ZodDate, + $ZodDefault: () => $ZodDefault, + $ZodDiscriminatedUnion: () => $ZodDiscriminatedUnion, + $ZodE164: () => $ZodE164, + $ZodEmail: () => $ZodEmail, + $ZodEmoji: () => $ZodEmoji, + $ZodEncodeError: () => $ZodEncodeError, + $ZodEnum: () => $ZodEnum, + $ZodError: () => $ZodError, + $ZodExactOptional: () => $ZodExactOptional, + $ZodFile: () => $ZodFile, + $ZodFunction: () => $ZodFunction, + $ZodGUID: () => $ZodGUID, + $ZodIPv4: () => $ZodIPv4, + $ZodIPv6: () => $ZodIPv6, + $ZodISODate: () => $ZodISODate, + $ZodISODateTime: () => $ZodISODateTime, + $ZodISODuration: () => $ZodISODuration, + $ZodISOTime: () => $ZodISOTime, + $ZodIntersection: () => $ZodIntersection, + $ZodJWT: () => $ZodJWT, + $ZodKSUID: () => $ZodKSUID, + $ZodLazy: () => $ZodLazy, + $ZodLiteral: () => $ZodLiteral, + $ZodMAC: () => $ZodMAC, + $ZodMap: () => $ZodMap, + $ZodNaN: () => $ZodNaN, + $ZodNanoID: () => $ZodNanoID, + $ZodNever: () => $ZodNever, + $ZodNonOptional: () => $ZodNonOptional, + $ZodNull: () => $ZodNull, + $ZodNullable: () => $ZodNullable, + $ZodNumber: () => $ZodNumber, + $ZodNumberFormat: () => $ZodNumberFormat, + $ZodObject: () => $ZodObject, + $ZodObjectJIT: () => $ZodObjectJIT, + $ZodOptional: () => $ZodOptional, + $ZodPipe: () => $ZodPipe, + $ZodPrefault: () => $ZodPrefault, + $ZodPromise: () => $ZodPromise, + $ZodReadonly: () => $ZodReadonly, + $ZodRealError: () => $ZodRealError, + $ZodRecord: () => $ZodRecord, + $ZodRegistry: () => $ZodRegistry, + $ZodSet: () => $ZodSet, + $ZodString: () => $ZodString, + $ZodStringFormat: () => $ZodStringFormat, + $ZodSuccess: () => $ZodSuccess, + $ZodSymbol: () => $ZodSymbol, + $ZodTemplateLiteral: () => $ZodTemplateLiteral, + $ZodTransform: () => $ZodTransform, + $ZodTuple: () => $ZodTuple, + $ZodType: () => $ZodType, + $ZodULID: () => $ZodULID, + $ZodURL: () => $ZodURL, + $ZodUUID: () => $ZodUUID, + $ZodUndefined: () => $ZodUndefined, + $ZodUnion: () => $ZodUnion, + $ZodUnknown: () => $ZodUnknown, + $ZodVoid: () => $ZodVoid, + $ZodXID: () => $ZodXID, + $ZodXor: () => $ZodXor, + $brand: () => $brand, + $constructor: () => $constructor, + $input: () => $input, + $output: () => $output, + Doc: () => Doc, + JSONSchema: () => json_schema_exports, + JSONSchemaGenerator: () => JSONSchemaGenerator, + NEVER: () => NEVER, + TimePrecision: () => TimePrecision, + _any: () => _any, + _array: () => _array, + _base64: () => _base64, + _base64url: () => _base64url, + _bigint: () => _bigint, + _boolean: () => _boolean, + _catch: () => _catch, + _check: () => _check, + _cidrv4: () => _cidrv4, + _cidrv6: () => _cidrv6, + _coercedBigint: () => _coercedBigint, + _coercedBoolean: () => _coercedBoolean, + _coercedDate: () => _coercedDate, + _coercedNumber: () => _coercedNumber, + _coercedString: () => _coercedString, + _cuid: () => _cuid, + _cuid2: () => _cuid2, + _custom: () => _custom, + _date: () => _date, + _decode: () => _decode, + _decodeAsync: () => _decodeAsync, + _default: () => _default, + _discriminatedUnion: () => _discriminatedUnion, + _e164: () => _e164, + _email: () => _email, + _emoji: () => _emoji2, + _encode: () => _encode, + _encodeAsync: () => _encodeAsync, + _endsWith: () => _endsWith, + _enum: () => _enum, + _file: () => _file, + _float32: () => _float32, + _float64: () => _float64, + _gt: () => _gt, + _gte: () => _gte, + _guid: () => _guid, + _includes: () => _includes, + _int: () => _int, + _int32: () => _int32, + _int64: () => _int64, + _intersection: () => _intersection, + _ipv4: () => _ipv4, + _ipv6: () => _ipv6, + _isoDate: () => _isoDate, + _isoDateTime: () => _isoDateTime, + _isoDuration: () => _isoDuration, + _isoTime: () => _isoTime, + _jwt: () => _jwt, + _ksuid: () => _ksuid, + _lazy: () => _lazy, + _length: () => _length, + _literal: () => _literal, + _lowercase: () => _lowercase, + _lt: () => _lt, + _lte: () => _lte, + _mac: () => _mac, + _map: () => _map, + _max: () => _lte, + _maxLength: () => _maxLength, + _maxSize: () => _maxSize, + _mime: () => _mime, + _min: () => _gte, + _minLength: () => _minLength, + _minSize: () => _minSize, + _multipleOf: () => _multipleOf, + _nan: () => _nan, + _nanoid: () => _nanoid, + _nativeEnum: () => _nativeEnum, + _negative: () => _negative, + _never: () => _never, + _nonnegative: () => _nonnegative, + _nonoptional: () => _nonoptional, + _nonpositive: () => _nonpositive, + _normalize: () => _normalize, + _null: () => _null2, + _nullable: () => _nullable, + _number: () => _number, + _optional: () => _optional, + _overwrite: () => _overwrite, + _parse: () => _parse, + _parseAsync: () => _parseAsync, + _pipe: () => _pipe, + _positive: () => _positive, + _promise: () => _promise, + _property: () => _property, + _readonly: () => _readonly, + _record: () => _record, + _refine: () => _refine, + _regex: () => _regex, + _safeDecode: () => _safeDecode, + _safeDecodeAsync: () => _safeDecodeAsync, + _safeEncode: () => _safeEncode, + _safeEncodeAsync: () => _safeEncodeAsync, + _safeParse: () => _safeParse, + _safeParseAsync: () => _safeParseAsync, + _set: () => _set, + _size: () => _size, + _slugify: () => _slugify, + _startsWith: () => _startsWith, + _string: () => _string, + _stringFormat: () => _stringFormat, + _stringbool: () => _stringbool, + _success: () => _success, + _superRefine: () => _superRefine, + _symbol: () => _symbol, + _templateLiteral: () => _templateLiteral, + _toLowerCase: () => _toLowerCase, + _toUpperCase: () => _toUpperCase, + _transform: () => _transform, + _trim: () => _trim, + _tuple: () => _tuple, + _uint32: () => _uint32, + _uint64: () => _uint64, + _ulid: () => _ulid, + _undefined: () => _undefined2, + _union: () => _union, + _unknown: () => _unknown, + _uppercase: () => _uppercase, + _url: () => _url, + _uuid: () => _uuid, + _uuidv4: () => _uuidv4, + _uuidv6: () => _uuidv6, + _uuidv7: () => _uuidv7, + _void: () => _void, + _xid: () => _xid, + _xor: () => _xor, + clone: () => clone, + config: () => config, + createStandardJSONSchemaMethod: () => createStandardJSONSchemaMethod, + createToJSONSchemaMethod: () => createToJSONSchemaMethod, + decode: () => decode, + decodeAsync: () => decodeAsync, + describe: () => describe, + encode: () => encode, + encodeAsync: () => encodeAsync, + extractDefs: () => extractDefs, + finalize: () => finalize, + flattenError: () => flattenError, + formatError: () => formatError, + globalConfig: () => globalConfig, + globalRegistry: () => globalRegistry, + initializeContext: () => initializeContext, + isValidBase64: () => isValidBase64, + isValidBase64URL: () => isValidBase64URL, + isValidJWT: () => isValidJWT2, + locales: () => locales_exports, + meta: () => meta, + parse: () => parse, + parseAsync: () => parseAsync, + prettifyError: () => prettifyError, + process: () => process2, + regexes: () => regexes_exports, + registry: () => registry, + safeDecode: () => safeDecode, + safeDecodeAsync: () => safeDecodeAsync, + safeEncode: () => safeEncode, + safeEncodeAsync: () => safeEncodeAsync, + safeParse: () => safeParse, + safeParseAsync: () => safeParseAsync, + toDotPath: () => toDotPath, + toJSONSchema: () => toJSONSchema, + treeifyError: () => treeifyError, + util: () => util_exports, + version: () => version +}); + +// node_modules/zod/v4/core/core.js +var NEVER = Object.freeze({ + status: "aborted" +}); +// @__NO_SIDE_EFFECTS__ +function $constructor(name, initializer3, params) { + var _a3; + function init(inst, def) { + if (!inst._zod) { + Object.defineProperty(inst, "_zod", { + value: { + def, + constr: _3, + traits: /* @__PURE__ */ new Set() + }, + enumerable: false + }); + } + if (inst._zod.traits.has(name)) { + return; + } + inst._zod.traits.add(name); + initializer3(inst, def); + const proto = _3.prototype; + const keys = Object.keys(proto); + for (let i3 = 0; i3 < keys.length; i3++) { + const k3 = keys[i3]; + if (!(k3 in inst)) { + inst[k3] = proto[k3].bind(inst); + } + } + } + const Parent = (_a3 = params == null ? void 0 : params.Parent) != null ? _a3 : Object; + class Definition extends Parent { + } + Object.defineProperty(Definition, "name", { value: name }); + function _3(def) { + var _a5; + var _a4; + const inst = (params == null ? void 0 : params.Parent) ? new Definition() : this; + init(inst, def); + (_a5 = (_a4 = inst._zod).deferred) != null ? _a5 : _a4.deferred = []; + for (const fn of inst._zod.deferred) { + fn(); + } + return inst; + } + Object.defineProperty(_3, "init", { value: init }); + Object.defineProperty(_3, Symbol.hasInstance, { + value: (inst) => { + var _a4, _b2; + if ((params == null ? void 0 : params.Parent) && inst instanceof params.Parent) + return true; + return (_b2 = (_a4 = inst == null ? void 0 : inst._zod) == null ? void 0 : _a4.traits) == null ? void 0 : _b2.has(name); + } + }); + Object.defineProperty(_3, "name", { value: name }); + return _3; +} +var $brand = /* @__PURE__ */ Symbol("zod_brand"); +var $ZodAsyncError = class extends Error { + constructor() { + super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`); + } +}; +var $ZodEncodeError = class extends Error { + constructor(name) { + super(`Encountered unidirectional transform during encode: ${name}`); + this.name = "ZodEncodeError"; + } +}; +var globalConfig = {}; +function config(newConfig) { + if (newConfig) + Object.assign(globalConfig, newConfig); + return globalConfig; +} + +// node_modules/zod/v4/core/util.js +var util_exports = {}; +__export(util_exports, { + BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES, + Class: () => Class, + NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES, + aborted: () => aborted, + allowsEval: () => allowsEval, + assert: () => assert, + assertEqual: () => assertEqual, + assertIs: () => assertIs, + assertNever: () => assertNever, + assertNotEqual: () => assertNotEqual, + assignProp: () => assignProp, + base64ToUint8Array: () => base64ToUint8Array, + base64urlToUint8Array: () => base64urlToUint8Array, + cached: () => cached, + captureStackTrace: () => captureStackTrace, + cleanEnum: () => cleanEnum, + cleanRegex: () => cleanRegex, + clone: () => clone, + cloneDef: () => cloneDef, + createTransparentProxy: () => createTransparentProxy, + defineLazy: () => defineLazy, + esc: () => esc, + escapeRegex: () => escapeRegex, + extend: () => extend, + finalizeIssue: () => finalizeIssue, + floatSafeRemainder: () => floatSafeRemainder2, + getElementAtPath: () => getElementAtPath, + getEnumValues: () => getEnumValues, + getLengthableOrigin: () => getLengthableOrigin, + getParsedType: () => getParsedType2, + getSizableOrigin: () => getSizableOrigin, + hexToUint8Array: () => hexToUint8Array, + isObject: () => isObject, + isPlainObject: () => isPlainObject, + issue: () => issue, + joinValues: () => joinValues, + jsonStringifyReplacer: () => jsonStringifyReplacer, + merge: () => merge, + mergeDefs: () => mergeDefs, + normalizeParams: () => normalizeParams, + nullish: () => nullish, + numKeys: () => numKeys, + objectClone: () => objectClone, + omit: () => omit, + optionalKeys: () => optionalKeys, + parsedType: () => parsedType, + partial: () => partial, + pick: () => pick, + prefixIssues: () => prefixIssues, + primitiveTypes: () => primitiveTypes, + promiseAllObject: () => promiseAllObject, + propertyKeyTypes: () => propertyKeyTypes, + randomString: () => randomString, + required: () => required, + safeExtend: () => safeExtend, + shallowClone: () => shallowClone, + slugify: () => slugify, + stringifyPrimitive: () => stringifyPrimitive, + uint8ArrayToBase64: () => uint8ArrayToBase64, + uint8ArrayToBase64url: () => uint8ArrayToBase64url, + uint8ArrayToHex: () => uint8ArrayToHex, + unwrapMessage: () => unwrapMessage +}); +function assertEqual(val) { + return val; +} +function assertNotEqual(val) { + return val; +} +function assertIs(_arg) { +} +function assertNever(_x) { + throw new Error("Unexpected value in exhaustive check"); +} +function assert(_3) { +} +function getEnumValues(entries) { + const numericValues = Object.values(entries).filter((v2) => typeof v2 === "number"); + const values = Object.entries(entries).filter(([k3, _3]) => numericValues.indexOf(+k3) === -1).map(([_3, v2]) => v2); + return values; +} +function joinValues(array2, separator = "|") { + return array2.map((val) => stringifyPrimitive(val)).join(separator); +} +function jsonStringifyReplacer(_3, value) { + if (typeof value === "bigint") + return value.toString(); + return value; +} +function cached(getter) { + const set2 = false; + return { + get value() { + if (!set2) { + const value = getter(); + Object.defineProperty(this, "value", { value }); + return value; + } + throw new Error("cached value already set"); + } + }; +} +function nullish(input) { + return input === null || input === void 0; +} +function cleanRegex(source) { + const start = source.startsWith("^") ? 1 : 0; + const end = source.endsWith("$") ? source.length - 1 : source.length; + return source.slice(start, end); +} +function floatSafeRemainder2(val, step) { + const valDecCount = (val.toString().split(".")[1] || "").length; + const stepString = step.toString(); + let stepDecCount = (stepString.split(".")[1] || "").length; + if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) { + const match = stepString.match(/\d?e-(\d?)/); + if (match == null ? void 0 : match[1]) { + stepDecCount = Number.parseInt(match[1]); + } + } + const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount; + const valInt = Number.parseInt(val.toFixed(decCount).replace(".", "")); + const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", "")); + return valInt % stepInt / 10 ** decCount; +} +var EVALUATING = /* @__PURE__ */ Symbol("evaluating"); +function defineLazy(object3, key, getter) { + let value = void 0; + Object.defineProperty(object3, key, { + get() { + if (value === EVALUATING) { + return void 0; + } + if (value === void 0) { + value = EVALUATING; + value = getter(); + } + return value; + }, + set(v2) { + Object.defineProperty(object3, key, { + value: v2 + // configurable: true, + }); + }, + configurable: true + }); +} +function objectClone(obj) { + return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj)); +} +function assignProp(target, prop, value) { + Object.defineProperty(target, prop, { + value, + writable: true, + enumerable: true, + configurable: true + }); +} +function mergeDefs(...defs) { + const mergedDescriptors = {}; + for (const def of defs) { + const descriptors = Object.getOwnPropertyDescriptors(def); + Object.assign(mergedDescriptors, descriptors); + } + return Object.defineProperties({}, mergedDescriptors); +} +function cloneDef(schema) { + return mergeDefs(schema._zod.def); +} +function getElementAtPath(obj, path19) { + if (!path19) + return obj; + return path19.reduce((acc, key) => acc == null ? void 0 : acc[key], obj); +} +function promiseAllObject(promisesObj) { + const keys = Object.keys(promisesObj); + const promises2 = keys.map((key) => promisesObj[key]); + return Promise.all(promises2).then((results) => { + const resolvedObj = {}; + for (let i3 = 0; i3 < keys.length; i3++) { + resolvedObj[keys[i3]] = results[i3]; + } + return resolvedObj; + }); +} +function randomString(length = 10) { + const chars = "abcdefghijklmnopqrstuvwxyz"; + let str = ""; + for (let i3 = 0; i3 < length; i3++) { + str += chars[Math.floor(Math.random() * chars.length)]; + } + return str; +} +function esc(str) { + return JSON.stringify(str); +} +function slugify(input) { + return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, ""); +} +var captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => { +}; +function isObject(data) { + return typeof data === "object" && data !== null && !Array.isArray(data); +} +var allowsEval = cached(() => { + var _a3; + if (typeof navigator !== "undefined" && ((_a3 = navigator == null ? void 0 : navigator.userAgent) == null ? void 0 : _a3.includes("Cloudflare"))) { + return false; + } + try { + const F3 = Function; + new F3(""); + return true; + } catch (_3) { + return false; + } +}); +function isPlainObject(o3) { + if (isObject(o3) === false) + return false; + const ctor = o3.constructor; + if (ctor === void 0) + return true; + if (typeof ctor !== "function") + return true; + const prot = ctor.prototype; + if (isObject(prot) === false) + return false; + if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) { + return false; + } + return true; +} +function shallowClone(o3) { + if (isPlainObject(o3)) + return { ...o3 }; + if (Array.isArray(o3)) + return [...o3]; + return o3; +} +function numKeys(data) { + let keyCount = 0; + for (const key in data) { + if (Object.prototype.hasOwnProperty.call(data, key)) { + keyCount++; + } + } + return keyCount; +} +var getParsedType2 = (data) => { + const t3 = typeof data; + switch (t3) { + case "undefined": + return "undefined"; + case "string": + return "string"; + case "number": + return Number.isNaN(data) ? "nan" : "number"; + case "boolean": + return "boolean"; + case "function": + return "function"; + case "bigint": + return "bigint"; + case "symbol": + return "symbol"; + case "object": + if (Array.isArray(data)) { + return "array"; + } + if (data === null) { + return "null"; + } + if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") { + return "promise"; + } + if (typeof Map !== "undefined" && data instanceof Map) { + return "map"; + } + if (typeof Set !== "undefined" && data instanceof Set) { + return "set"; + } + if (typeof Date !== "undefined" && data instanceof Date) { + return "date"; + } + if (typeof File !== "undefined" && data instanceof File) { + return "file"; + } + return "object"; + default: + throw new Error(`Unknown data type: ${t3}`); + } +}; +var propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]); +var primitiveTypes = /* @__PURE__ */ new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]); +function escapeRegex(str) { + return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); +} +function clone(inst, def, params) { + const cl = new inst._zod.constr(def != null ? def : inst._zod.def); + if (!def || (params == null ? void 0 : params.parent)) + cl._zod.parent = inst; + return cl; +} +function normalizeParams(_params) { + const params = _params; + if (!params) + return {}; + if (typeof params === "string") + return { error: () => params }; + if ((params == null ? void 0 : params.message) !== void 0) { + if ((params == null ? void 0 : params.error) !== void 0) + throw new Error("Cannot specify both `message` and `error` params"); + params.error = params.message; + } + delete params.message; + if (typeof params.error === "string") + return { ...params, error: () => params.error }; + return params; +} +function createTransparentProxy(getter) { + let target; + return new Proxy({}, { + get(_3, prop, receiver) { + target != null ? target : target = getter(); + return Reflect.get(target, prop, receiver); + }, + set(_3, prop, value, receiver) { + target != null ? target : target = getter(); + return Reflect.set(target, prop, value, receiver); + }, + has(_3, prop) { + target != null ? target : target = getter(); + return Reflect.has(target, prop); + }, + deleteProperty(_3, prop) { + target != null ? target : target = getter(); + return Reflect.deleteProperty(target, prop); + }, + ownKeys(_3) { + target != null ? target : target = getter(); + return Reflect.ownKeys(target); + }, + getOwnPropertyDescriptor(_3, prop) { + target != null ? target : target = getter(); + return Reflect.getOwnPropertyDescriptor(target, prop); + }, + defineProperty(_3, prop, descriptor) { + target != null ? target : target = getter(); + return Reflect.defineProperty(target, prop, descriptor); + } + }); +} +function stringifyPrimitive(value) { + if (typeof value === "bigint") + return value.toString() + "n"; + if (typeof value === "string") + return `"${value}"`; + return `${value}`; +} +function optionalKeys(shape) { + return Object.keys(shape).filter((k3) => { + return shape[k3]._zod.optin === "optional" && shape[k3]._zod.optout === "optional"; + }); +} +var NUMBER_FORMAT_RANGES = { + safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER], + int32: [-2147483648, 2147483647], + uint32: [0, 4294967295], + float32: [-34028234663852886e22, 34028234663852886e22], + float64: [-Number.MAX_VALUE, Number.MAX_VALUE] +}; +var BIGINT_FORMAT_RANGES = { + int64: [/* @__PURE__ */ BigInt("-9223372036854775808"), /* @__PURE__ */ BigInt("9223372036854775807")], + uint64: [/* @__PURE__ */ BigInt(0), /* @__PURE__ */ BigInt("18446744073709551615")] +}; +function pick(schema, mask) { + const currDef = schema._zod.def; + const checks = currDef.checks; + const hasChecks = checks && checks.length > 0; + if (hasChecks) { + throw new Error(".pick() cannot be used on object schemas containing refinements"); + } + const def = mergeDefs(schema._zod.def, { + get shape() { + const newShape = {}; + for (const key in mask) { + if (!(key in currDef.shape)) { + throw new Error(`Unrecognized key: "${key}"`); + } + if (!mask[key]) + continue; + newShape[key] = currDef.shape[key]; + } + assignProp(this, "shape", newShape); + return newShape; + }, + checks: [] + }); + return clone(schema, def); +} +function omit(schema, mask) { + const currDef = schema._zod.def; + const checks = currDef.checks; + const hasChecks = checks && checks.length > 0; + if (hasChecks) { + throw new Error(".omit() cannot be used on object schemas containing refinements"); + } + const def = mergeDefs(schema._zod.def, { + get shape() { + const newShape = { ...schema._zod.def.shape }; + for (const key in mask) { + if (!(key in currDef.shape)) { + throw new Error(`Unrecognized key: "${key}"`); + } + if (!mask[key]) + continue; + delete newShape[key]; + } + assignProp(this, "shape", newShape); + return newShape; + }, + checks: [] + }); + return clone(schema, def); +} +function extend(schema, shape) { + if (!isPlainObject(shape)) { + throw new Error("Invalid input to extend: expected a plain object"); + } + const checks = schema._zod.def.checks; + const hasChecks = checks && checks.length > 0; + if (hasChecks) { + const existingShape = schema._zod.def.shape; + for (const key in shape) { + if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) { + throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead."); + } + } + } + const def = mergeDefs(schema._zod.def, { + get shape() { + const _shape = { ...schema._zod.def.shape, ...shape }; + assignProp(this, "shape", _shape); + return _shape; + } + }); + return clone(schema, def); +} +function safeExtend(schema, shape) { + if (!isPlainObject(shape)) { + throw new Error("Invalid input to safeExtend: expected a plain object"); + } + const def = mergeDefs(schema._zod.def, { + get shape() { + const _shape = { ...schema._zod.def.shape, ...shape }; + assignProp(this, "shape", _shape); + return _shape; + } + }); + return clone(schema, def); +} +function merge(a3, b) { + const def = mergeDefs(a3._zod.def, { + get shape() { + const _shape = { ...a3._zod.def.shape, ...b._zod.def.shape }; + assignProp(this, "shape", _shape); + return _shape; + }, + get catchall() { + return b._zod.def.catchall; + }, + checks: [] + // delete existing checks + }); + return clone(a3, def); +} +function partial(Class2, schema, mask) { + const currDef = schema._zod.def; + const checks = currDef.checks; + const hasChecks = checks && checks.length > 0; + if (hasChecks) { + throw new Error(".partial() cannot be used on object schemas containing refinements"); + } + const def = mergeDefs(schema._zod.def, { + get shape() { + const oldShape = schema._zod.def.shape; + const shape = { ...oldShape }; + if (mask) { + for (const key in mask) { + if (!(key in oldShape)) { + throw new Error(`Unrecognized key: "${key}"`); + } + if (!mask[key]) + continue; + shape[key] = Class2 ? new Class2({ + type: "optional", + innerType: oldShape[key] + }) : oldShape[key]; + } + } else { + for (const key in oldShape) { + shape[key] = Class2 ? new Class2({ + type: "optional", + innerType: oldShape[key] + }) : oldShape[key]; + } + } + assignProp(this, "shape", shape); + return shape; + }, + checks: [] + }); + return clone(schema, def); +} +function required(Class2, schema, mask) { + const def = mergeDefs(schema._zod.def, { + get shape() { + const oldShape = schema._zod.def.shape; + const shape = { ...oldShape }; + if (mask) { + for (const key in mask) { + if (!(key in shape)) { + throw new Error(`Unrecognized key: "${key}"`); + } + if (!mask[key]) + continue; + shape[key] = new Class2({ + type: "nonoptional", + innerType: oldShape[key] + }); + } + } else { + for (const key in oldShape) { + shape[key] = new Class2({ + type: "nonoptional", + innerType: oldShape[key] + }); + } + } + assignProp(this, "shape", shape); + return shape; + } + }); + return clone(schema, def); +} +function aborted(x, startIndex = 0) { + var _a3; + if (x.aborted === true) + return true; + for (let i3 = startIndex; i3 < x.issues.length; i3++) { + if (((_a3 = x.issues[i3]) == null ? void 0 : _a3.continue) !== true) { + return true; + } + } + return false; +} +function prefixIssues(path19, issues) { + return issues.map((iss) => { + var _a4; + var _a3; + (_a4 = (_a3 = iss).path) != null ? _a4 : _a3.path = []; + iss.path.unshift(path19); + return iss; + }); +} +function unwrapMessage(message) { + return typeof message === "string" ? message : message == null ? void 0 : message.message; +} +function finalizeIssue(iss, ctx, config2) { + var _a3, _b2, _c, _d, _e, _f, _g, _h, _i, _j2, _k; + const full = { ...iss, path: (_a3 = iss.path) != null ? _a3 : [] }; + if (!iss.message) { + const message = (_k = (_j2 = (_h = (_f = unwrapMessage((_d = (_c = (_b2 = iss.inst) == null ? void 0 : _b2._zod.def) == null ? void 0 : _c.error) == null ? void 0 : _d.call(_c, iss))) != null ? _f : unwrapMessage((_e = ctx == null ? void 0 : ctx.error) == null ? void 0 : _e.call(ctx, iss))) != null ? _h : unwrapMessage((_g = config2.customError) == null ? void 0 : _g.call(config2, iss))) != null ? _j2 : unwrapMessage((_i = config2.localeError) == null ? void 0 : _i.call(config2, iss))) != null ? _k : "Invalid input"; + full.message = message; + } + delete full.inst; + delete full.continue; + if (!(ctx == null ? void 0 : ctx.reportInput)) { + delete full.input; + } + return full; +} +function getSizableOrigin(input) { + if (input instanceof Set) + return "set"; + if (input instanceof Map) + return "map"; + if (input instanceof File) + return "file"; + return "unknown"; +} +function getLengthableOrigin(input) { + if (Array.isArray(input)) + return "array"; + if (typeof input === "string") + return "string"; + return "unknown"; +} +function parsedType(data) { + const t3 = typeof data; + switch (t3) { + case "number": { + return Number.isNaN(data) ? "nan" : "number"; + } + case "object": { + if (data === null) { + return "null"; + } + if (Array.isArray(data)) { + return "array"; + } + const obj = data; + if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) { + return obj.constructor.name; + } + } + } + return t3; +} +function issue(...args) { + const [iss, input, inst] = args; + if (typeof iss === "string") { + return { + message: iss, + code: "custom", + input, + inst + }; + } + return { ...iss }; +} +function cleanEnum(obj) { + return Object.entries(obj).filter(([k3, _3]) => { + return Number.isNaN(Number.parseInt(k3, 10)); + }).map((el2) => el2[1]); +} +function base64ToUint8Array(base643) { + const binaryString = atob(base643); + const bytes = new Uint8Array(binaryString.length); + for (let i3 = 0; i3 < binaryString.length; i3++) { + bytes[i3] = binaryString.charCodeAt(i3); + } + return bytes; +} +function uint8ArrayToBase64(bytes) { + let binaryString = ""; + for (let i3 = 0; i3 < bytes.length; i3++) { + binaryString += String.fromCharCode(bytes[i3]); + } + return btoa(binaryString); +} +function base64urlToUint8Array(base64url3) { + const base643 = base64url3.replace(/-/g, "+").replace(/_/g, "/"); + const padding = "=".repeat((4 - base643.length % 4) % 4); + return base64ToUint8Array(base643 + padding); +} +function uint8ArrayToBase64url(bytes) { + return uint8ArrayToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, ""); +} +function hexToUint8Array(hex3) { + const cleanHex = hex3.replace(/^0x/, ""); + if (cleanHex.length % 2 !== 0) { + throw new Error("Invalid hex string length"); + } + const bytes = new Uint8Array(cleanHex.length / 2); + for (let i3 = 0; i3 < cleanHex.length; i3 += 2) { + bytes[i3 / 2] = Number.parseInt(cleanHex.slice(i3, i3 + 2), 16); + } + return bytes; +} +function uint8ArrayToHex(bytes) { + return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join(""); +} +var Class = class { + constructor(..._args) { + } +}; + +// node_modules/zod/v4/core/errors.js +var initializer = (inst, def) => { + inst.name = "$ZodError"; + Object.defineProperty(inst, "_zod", { + value: inst._zod, + enumerable: false + }); + Object.defineProperty(inst, "issues", { + value: def, + enumerable: false + }); + inst.message = JSON.stringify(def, jsonStringifyReplacer, 2); + Object.defineProperty(inst, "toString", { + value: () => inst.message, + enumerable: false + }); +}; +var $ZodError = $constructor("$ZodError", initializer); +var $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error }); +function flattenError(error48, mapper = (issue2) => issue2.message) { + const fieldErrors = {}; + const formErrors = []; + for (const sub of error48.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 }; +} +function formatError(error48, mapper = (issue2) => issue2.message) { + const fieldErrors = { _errors: [] }; + const processError = (error49) => { + for (const issue2 of error49.issues) { + if (issue2.code === "invalid_union" && issue2.errors.length) { + issue2.errors.map((issues) => processError({ issues })); + } else if (issue2.code === "invalid_key") { + processError({ issues: issue2.issues }); + } else if (issue2.code === "invalid_element") { + processError({ issues: issue2.issues }); + } else if (issue2.path.length === 0) { + fieldErrors._errors.push(mapper(issue2)); + } else { + let curr = fieldErrors; + let i3 = 0; + while (i3 < issue2.path.length) { + const el2 = issue2.path[i3]; + const terminal = i3 === issue2.path.length - 1; + if (!terminal) { + curr[el2] = curr[el2] || { _errors: [] }; + } else { + curr[el2] = curr[el2] || { _errors: [] }; + curr[el2]._errors.push(mapper(issue2)); + } + curr = curr[el2]; + i3++; + } + } + } + }; + processError(error48); + return fieldErrors; +} +function treeifyError(error48, mapper = (issue2) => issue2.message) { + const result = { errors: [] }; + const processError = (error49, path19 = []) => { + var _a4, _b3, _c, _d; + var _a3, _b2; + for (const issue2 of error49.issues) { + if (issue2.code === "invalid_union" && issue2.errors.length) { + issue2.errors.map((issues) => processError({ issues }, issue2.path)); + } else if (issue2.code === "invalid_key") { + processError({ issues: issue2.issues }, issue2.path); + } else if (issue2.code === "invalid_element") { + processError({ issues: issue2.issues }, issue2.path); + } else { + const fullpath = [...path19, ...issue2.path]; + if (fullpath.length === 0) { + result.errors.push(mapper(issue2)); + continue; + } + let curr = result; + let i3 = 0; + while (i3 < fullpath.length) { + const el2 = fullpath[i3]; + const terminal = i3 === fullpath.length - 1; + if (typeof el2 === "string") { + (_a4 = curr.properties) != null ? _a4 : curr.properties = {}; + (_b3 = (_a3 = curr.properties)[el2]) != null ? _b3 : _a3[el2] = { errors: [] }; + curr = curr.properties[el2]; + } else { + (_c = curr.items) != null ? _c : curr.items = []; + (_d = (_b2 = curr.items)[el2]) != null ? _d : _b2[el2] = { errors: [] }; + curr = curr.items[el2]; + } + if (terminal) { + curr.errors.push(mapper(issue2)); + } + i3++; + } + } + } + }; + processError(error48); + return result; +} +function toDotPath(_path) { + const segs = []; + const path19 = _path.map((seg) => typeof seg === "object" ? seg.key : seg); + for (const seg of path19) { + if (typeof seg === "number") + segs.push(`[${seg}]`); + else if (typeof seg === "symbol") + segs.push(`[${JSON.stringify(String(seg))}]`); + else if (/[^\w$]/.test(seg)) + segs.push(`[${JSON.stringify(seg)}]`); + else { + if (segs.length) + segs.push("."); + segs.push(seg); + } + } + return segs.join(""); +} +function prettifyError(error48) { + var _a3; + const lines = []; + const issues = [...error48.issues].sort((a3, b) => { + var _a4, _b2; + return ((_a4 = a3.path) != null ? _a4 : []).length - ((_b2 = b.path) != null ? _b2 : []).length; + }); + for (const issue2 of issues) { + lines.push(`\u2716 ${issue2.message}`); + if ((_a3 = issue2.path) == null ? void 0 : _a3.length) + lines.push(` \u2192 at ${toDotPath(issue2.path)}`); + } + return lines.join("\n"); +} + +// node_modules/zod/v4/core/parse.js +var _parse = (_Err) => (schema, value, _ctx, _params) => { + var _a3; + const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false }; + const result = schema._zod.run({ value, issues: [] }, ctx); + if (result instanceof Promise) { + throw new $ZodAsyncError(); + } + if (result.issues.length) { + const e3 = new ((_a3 = _params == null ? void 0 : _params.Err) != null ? _a3 : _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config()))); + captureStackTrace(e3, _params == null ? void 0 : _params.callee); + throw e3; + } + return result.value; +}; +var parse = /* @__PURE__ */ _parse($ZodRealError); +var _parseAsync = (_Err) => async (schema, value, _ctx, params) => { + var _a3; + const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true }; + let result = schema._zod.run({ value, issues: [] }, ctx); + if (result instanceof Promise) + result = await result; + if (result.issues.length) { + const e3 = new ((_a3 = params == null ? void 0 : params.Err) != null ? _a3 : _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config()))); + captureStackTrace(e3, params == null ? void 0 : params.callee); + throw e3; + } + return result.value; +}; +var parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError); +var _safeParse = (_Err) => (schema, value, _ctx) => { + const ctx = _ctx ? { ..._ctx, async: false } : { async: false }; + const result = schema._zod.run({ value, issues: [] }, ctx); + if (result instanceof Promise) { + throw new $ZodAsyncError(); + } + return result.issues.length ? { + success: false, + error: new (_Err != null ? _Err : $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config()))) + } : { success: true, data: result.value }; +}; +var safeParse = /* @__PURE__ */ _safeParse($ZodRealError); +var _safeParseAsync = (_Err) => async (schema, value, _ctx) => { + const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true }; + let result = schema._zod.run({ value, issues: [] }, ctx); + if (result instanceof Promise) + result = await result; + return result.issues.length ? { + success: false, + error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config()))) + } : { success: true, data: result.value }; +}; +var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError); +var _encode = (_Err) => (schema, value, _ctx) => { + const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" }; + return _parse(_Err)(schema, value, ctx); +}; +var encode = /* @__PURE__ */ _encode($ZodRealError); +var _decode = (_Err) => (schema, value, _ctx) => { + return _parse(_Err)(schema, value, _ctx); +}; +var decode = /* @__PURE__ */ _decode($ZodRealError); +var _encodeAsync = (_Err) => async (schema, value, _ctx) => { + const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" }; + return _parseAsync(_Err)(schema, value, ctx); +}; +var encodeAsync = /* @__PURE__ */ _encodeAsync($ZodRealError); +var _decodeAsync = (_Err) => async (schema, value, _ctx) => { + return _parseAsync(_Err)(schema, value, _ctx); +}; +var decodeAsync = /* @__PURE__ */ _decodeAsync($ZodRealError); +var _safeEncode = (_Err) => (schema, value, _ctx) => { + const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" }; + return _safeParse(_Err)(schema, value, ctx); +}; +var safeEncode = /* @__PURE__ */ _safeEncode($ZodRealError); +var _safeDecode = (_Err) => (schema, value, _ctx) => { + return _safeParse(_Err)(schema, value, _ctx); +}; +var safeDecode = /* @__PURE__ */ _safeDecode($ZodRealError); +var _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => { + const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" }; + return _safeParseAsync(_Err)(schema, value, ctx); +}; +var safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync($ZodRealError); +var _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => { + return _safeParseAsync(_Err)(schema, value, _ctx); +}; +var safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync($ZodRealError); + +// node_modules/zod/v4/core/regexes.js +var regexes_exports = {}; +__export(regexes_exports, { + base64: () => base64, + base64url: () => base64url, + bigint: () => bigint, + boolean: () => boolean, + browserEmail: () => browserEmail, + cidrv4: () => cidrv4, + cidrv6: () => cidrv6, + cuid: () => cuid, + cuid2: () => cuid2, + date: () => date, + datetime: () => datetime, + domain: () => domain, + duration: () => duration, + e164: () => e164, + email: () => email, + emoji: () => emoji, + extendedDuration: () => extendedDuration, + guid: () => guid, + hex: () => hex, + hostname: () => hostname2, + html5Email: () => html5Email, + idnEmail: () => idnEmail, + integer: () => integer, + ipv4: () => ipv4, + ipv6: () => ipv6, + ksuid: () => ksuid, + lowercase: () => lowercase, + mac: () => mac, + md5_base64: () => md5_base64, + md5_base64url: () => md5_base64url, + md5_hex: () => md5_hex, + nanoid: () => nanoid, + null: () => _null, + number: () => number, + rfc5322Email: () => rfc5322Email, + sha1_base64: () => sha1_base64, + sha1_base64url: () => sha1_base64url, + sha1_hex: () => sha1_hex, + sha256_base64: () => sha256_base64, + sha256_base64url: () => sha256_base64url, + sha256_hex: () => sha256_hex, + sha384_base64: () => sha384_base64, + sha384_base64url: () => sha384_base64url, + sha384_hex: () => sha384_hex, + sha512_base64: () => sha512_base64, + sha512_base64url: () => sha512_base64url, + sha512_hex: () => sha512_hex, + string: () => string, + time: () => time, + ulid: () => ulid, + undefined: () => _undefined, + unicodeEmail: () => unicodeEmail, + uppercase: () => uppercase, + uuid: () => uuid, + uuid4: () => uuid4, + uuid6: () => uuid6, + uuid7: () => uuid7, + xid: () => xid +}); +var cuid = /^[cC][^\s-]{8,}$/; +var cuid2 = /^[0-9a-z]+$/; +var ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/; +var xid = /^[0-9a-vA-V]{20}$/; +var ksuid = /^[A-Za-z0-9]{27}$/; +var nanoid = /^[a-zA-Z0-9_-]{21}$/; +var duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/; +var extendedDuration = /^[-+]?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)?)??$/; +var guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/; +var uuid = (version2) => { + if (!version2) + return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/; + return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version2}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`); +}; +var uuid4 = /* @__PURE__ */ uuid(4); +var uuid6 = /* @__PURE__ */ uuid(6); +var uuid7 = /* @__PURE__ */ uuid(7); +var email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/; +var html5Email = /^[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])?)*$/; +var rfc5322Email = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/; +var unicodeEmail = /^[^\s@"]{1,64}@[^\s@]{1,255}$/u; +var idnEmail = unicodeEmail; +var browserEmail = /^[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])?)*$/; +var _emoji = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`; +function emoji() { + return new RegExp(_emoji, "u"); +} +var ipv4 = /^(?:(?: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])$/; +var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/; +var mac = (delimiter) => { + const escapedDelim = escapeRegex(delimiter != null ? delimiter : ":"); + return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`); +}; +var cidrv4 = /^((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])\/([0-9]|[1-2][0-9]|3[0-2])$/; +var cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/; +var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/; +var base64url = /^[A-Za-z0-9_-]*$/; +var hostname2 = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/; +var domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/; +var e164 = /^\+[1-9]\d{6,14}$/; +var dateSource = `(?:(?:\\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])))`; +var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`); +function timeSource(args) { + const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`; + const regex = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`; + return regex; +} +function time(args) { + return new RegExp(`^${timeSource(args)}$`); +} +function datetime(args) { + const time4 = timeSource({ precision: args.precision }); + const opts = ["Z"]; + if (args.local) + opts.push(""); + if (args.offset) + opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`); + const timeRegex2 = `${time4}(?:${opts.join("|")})`; + return new RegExp(`^${dateSource}T(?:${timeRegex2})$`); +} +var string = (params) => { + var _a3, _b2; + const regex = params ? `[\\s\\S]{${(_a3 = params == null ? void 0 : params.minimum) != null ? _a3 : 0},${(_b2 = params == null ? void 0 : params.maximum) != null ? _b2 : ""}}` : `[\\s\\S]*`; + return new RegExp(`^${regex}$`); +}; +var bigint = /^-?\d+n?$/; +var integer = /^-?\d+$/; +var number = /^-?\d+(?:\.\d+)?$/; +var boolean = /^(?:true|false)$/i; +var _null = /^null$/i; +var _undefined = /^undefined$/i; +var lowercase = /^[^A-Z]*$/; +var uppercase = /^[^a-z]*$/; +var hex = /^[0-9a-fA-F]*$/; +function fixedBase64(bodyLength, padding) { + return new RegExp(`^[A-Za-z0-9+/]{${bodyLength}}${padding}$`); +} +function fixedBase64url(length) { + return new RegExp(`^[A-Za-z0-9_-]{${length}}$`); +} +var md5_hex = /^[0-9a-fA-F]{32}$/; +var md5_base64 = /* @__PURE__ */ fixedBase64(22, "=="); +var md5_base64url = /* @__PURE__ */ fixedBase64url(22); +var sha1_hex = /^[0-9a-fA-F]{40}$/; +var sha1_base64 = /* @__PURE__ */ fixedBase64(27, "="); +var sha1_base64url = /* @__PURE__ */ fixedBase64url(27); +var sha256_hex = /^[0-9a-fA-F]{64}$/; +var sha256_base64 = /* @__PURE__ */ fixedBase64(43, "="); +var sha256_base64url = /* @__PURE__ */ fixedBase64url(43); +var sha384_hex = /^[0-9a-fA-F]{96}$/; +var sha384_base64 = /* @__PURE__ */ fixedBase64(64, ""); +var sha384_base64url = /* @__PURE__ */ fixedBase64url(64); +var sha512_hex = /^[0-9a-fA-F]{128}$/; +var sha512_base64 = /* @__PURE__ */ fixedBase64(86, "=="); +var sha512_base64url = /* @__PURE__ */ fixedBase64url(86); + +// node_modules/zod/v4/core/checks.js +var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => { + var _a4, _b2; + var _a3; + (_a4 = inst._zod) != null ? _a4 : inst._zod = {}; + inst._zod.def = def; + (_b2 = (_a3 = inst._zod).onattach) != null ? _b2 : _a3.onattach = []; +}); +var numericOriginMap = { + number: "number", + bigint: "bigint", + object: "date" +}; +var $ZodCheckLessThan = /* @__PURE__ */ $constructor("$ZodCheckLessThan", (inst, def) => { + $ZodCheck.init(inst, def); + const origin = numericOriginMap[typeof def.value]; + inst._zod.onattach.push((inst2) => { + var _a3; + const bag = inst2._zod.bag; + const curr = (_a3 = def.inclusive ? bag.maximum : bag.exclusiveMaximum) != null ? _a3 : Number.POSITIVE_INFINITY; + if (def.value < curr) { + if (def.inclusive) + bag.maximum = def.value; + else + bag.exclusiveMaximum = def.value; + } + }); + inst._zod.check = (payload) => { + if (def.inclusive ? payload.value <= def.value : payload.value < def.value) { + return; + } + payload.issues.push({ + origin, + code: "too_big", + maximum: typeof def.value === "object" ? def.value.getTime() : def.value, + input: payload.value, + inclusive: def.inclusive, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan", (inst, def) => { + $ZodCheck.init(inst, def); + const origin = numericOriginMap[typeof def.value]; + inst._zod.onattach.push((inst2) => { + var _a3; + const bag = inst2._zod.bag; + const curr = (_a3 = def.inclusive ? bag.minimum : bag.exclusiveMinimum) != null ? _a3 : Number.NEGATIVE_INFINITY; + if (def.value > curr) { + if (def.inclusive) + bag.minimum = def.value; + else + bag.exclusiveMinimum = def.value; + } + }); + inst._zod.check = (payload) => { + if (def.inclusive ? payload.value >= def.value : payload.value > def.value) { + return; + } + payload.issues.push({ + origin, + code: "too_small", + minimum: typeof def.value === "object" ? def.value.getTime() : def.value, + input: payload.value, + inclusive: def.inclusive, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckMultipleOf = /* @__PURE__ */ $constructor("$ZodCheckMultipleOf", (inst, def) => { + $ZodCheck.init(inst, def); + inst._zod.onattach.push((inst2) => { + var _a4; + var _a3; + (_a4 = (_a3 = inst2._zod.bag).multipleOf) != null ? _a4 : _a3.multipleOf = def.value; + }); + inst._zod.check = (payload) => { + if (typeof payload.value !== typeof def.value) + throw new Error("Cannot mix number and bigint in multiple_of check."); + const isMultiple = typeof payload.value === "bigint" ? payload.value % def.value === BigInt(0) : floatSafeRemainder2(payload.value, def.value) === 0; + if (isMultiple) + return; + payload.issues.push({ + origin: typeof payload.value, + code: "not_multiple_of", + divisor: def.value, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat", (inst, def) => { + var _a3; + $ZodCheck.init(inst, def); + def.format = def.format || "float64"; + const isInt = (_a3 = def.format) == null ? void 0 : _a3.includes("int"); + const origin = isInt ? "int" : "number"; + const [minimum, maximum] = NUMBER_FORMAT_RANGES[def.format]; + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.format = def.format; + bag.minimum = minimum; + bag.maximum = maximum; + if (isInt) + bag.pattern = integer; + }); + inst._zod.check = (payload) => { + const input = payload.value; + if (isInt) { + if (!Number.isInteger(input)) { + payload.issues.push({ + expected: origin, + format: def.format, + code: "invalid_type", + continue: false, + input, + inst + }); + return; + } + if (!Number.isSafeInteger(input)) { + if (input > 0) { + payload.issues.push({ + input, + code: "too_big", + maximum: Number.MAX_SAFE_INTEGER, + note: "Integers must be within the safe integer range.", + inst, + origin, + inclusive: true, + continue: !def.abort + }); + } else { + payload.issues.push({ + input, + code: "too_small", + minimum: Number.MIN_SAFE_INTEGER, + note: "Integers must be within the safe integer range.", + inst, + origin, + inclusive: true, + continue: !def.abort + }); + } + return; + } + } + if (input < minimum) { + payload.issues.push({ + origin: "number", + input, + code: "too_small", + minimum, + inclusive: true, + inst, + continue: !def.abort + }); + } + if (input > maximum) { + payload.issues.push({ + origin: "number", + input, + code: "too_big", + maximum, + inclusive: true, + inst, + continue: !def.abort + }); + } + }; +}); +var $ZodCheckBigIntFormat = /* @__PURE__ */ $constructor("$ZodCheckBigIntFormat", (inst, def) => { + $ZodCheck.init(inst, def); + const [minimum, maximum] = BIGINT_FORMAT_RANGES[def.format]; + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.format = def.format; + bag.minimum = minimum; + bag.maximum = maximum; + }); + inst._zod.check = (payload) => { + const input = payload.value; + if (input < minimum) { + payload.issues.push({ + origin: "bigint", + input, + code: "too_small", + minimum, + inclusive: true, + inst, + continue: !def.abort + }); + } + if (input > maximum) { + payload.issues.push({ + origin: "bigint", + input, + code: "too_big", + maximum, + inclusive: true, + inst, + continue: !def.abort + }); + } + }; +}); +var $ZodCheckMaxSize = /* @__PURE__ */ $constructor("$ZodCheckMaxSize", (inst, def) => { + var _a4; + var _a3; + $ZodCheck.init(inst, def); + (_a4 = (_a3 = inst._zod.def).when) != null ? _a4 : _a3.when = (payload) => { + const val = payload.value; + return !nullish(val) && val.size !== void 0; + }; + inst._zod.onattach.push((inst2) => { + var _a5; + const curr = (_a5 = inst2._zod.bag.maximum) != null ? _a5 : Number.POSITIVE_INFINITY; + if (def.maximum < curr) + inst2._zod.bag.maximum = def.maximum; + }); + inst._zod.check = (payload) => { + const input = payload.value; + const size = input.size; + if (size <= def.maximum) + return; + payload.issues.push({ + origin: getSizableOrigin(input), + code: "too_big", + maximum: def.maximum, + inclusive: true, + input, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckMinSize = /* @__PURE__ */ $constructor("$ZodCheckMinSize", (inst, def) => { + var _a4; + var _a3; + $ZodCheck.init(inst, def); + (_a4 = (_a3 = inst._zod.def).when) != null ? _a4 : _a3.when = (payload) => { + const val = payload.value; + return !nullish(val) && val.size !== void 0; + }; + inst._zod.onattach.push((inst2) => { + var _a5; + const curr = (_a5 = inst2._zod.bag.minimum) != null ? _a5 : Number.NEGATIVE_INFINITY; + if (def.minimum > curr) + inst2._zod.bag.minimum = def.minimum; + }); + inst._zod.check = (payload) => { + const input = payload.value; + const size = input.size; + if (size >= def.minimum) + return; + payload.issues.push({ + origin: getSizableOrigin(input), + code: "too_small", + minimum: def.minimum, + inclusive: true, + input, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckSizeEquals = /* @__PURE__ */ $constructor("$ZodCheckSizeEquals", (inst, def) => { + var _a4; + var _a3; + $ZodCheck.init(inst, def); + (_a4 = (_a3 = inst._zod.def).when) != null ? _a4 : _a3.when = (payload) => { + const val = payload.value; + return !nullish(val) && val.size !== void 0; + }; + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.minimum = def.size; + bag.maximum = def.size; + bag.size = def.size; + }); + inst._zod.check = (payload) => { + const input = payload.value; + const size = input.size; + if (size === def.size) + return; + const tooBig = size > def.size; + payload.issues.push({ + origin: getSizableOrigin(input), + ...tooBig ? { code: "too_big", maximum: def.size } : { code: "too_small", minimum: def.size }, + inclusive: true, + exact: true, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => { + var _a4; + var _a3; + $ZodCheck.init(inst, def); + (_a4 = (_a3 = inst._zod.def).when) != null ? _a4 : _a3.when = (payload) => { + const val = payload.value; + return !nullish(val) && val.length !== void 0; + }; + inst._zod.onattach.push((inst2) => { + var _a5; + const curr = (_a5 = inst2._zod.bag.maximum) != null ? _a5 : Number.POSITIVE_INFINITY; + if (def.maximum < curr) + inst2._zod.bag.maximum = def.maximum; + }); + inst._zod.check = (payload) => { + const input = payload.value; + const length = input.length; + if (length <= def.maximum) + return; + const origin = getLengthableOrigin(input); + payload.issues.push({ + origin, + code: "too_big", + maximum: def.maximum, + inclusive: true, + input, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => { + var _a4; + var _a3; + $ZodCheck.init(inst, def); + (_a4 = (_a3 = inst._zod.def).when) != null ? _a4 : _a3.when = (payload) => { + const val = payload.value; + return !nullish(val) && val.length !== void 0; + }; + inst._zod.onattach.push((inst2) => { + var _a5; + const curr = (_a5 = inst2._zod.bag.minimum) != null ? _a5 : Number.NEGATIVE_INFINITY; + if (def.minimum > curr) + inst2._zod.bag.minimum = def.minimum; + }); + inst._zod.check = (payload) => { + const input = payload.value; + const length = input.length; + if (length >= def.minimum) + return; + const origin = getLengthableOrigin(input); + payload.issues.push({ + origin, + code: "too_small", + minimum: def.minimum, + inclusive: true, + input, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => { + var _a4; + var _a3; + $ZodCheck.init(inst, def); + (_a4 = (_a3 = inst._zod.def).when) != null ? _a4 : _a3.when = (payload) => { + const val = payload.value; + return !nullish(val) && val.length !== void 0; + }; + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.minimum = def.length; + bag.maximum = def.length; + bag.length = def.length; + }); + inst._zod.check = (payload) => { + const input = payload.value; + const length = input.length; + if (length === def.length) + return; + const origin = getLengthableOrigin(input); + const tooBig = length > def.length; + payload.issues.push({ + origin, + ...tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length }, + inclusive: true, + exact: true, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => { + var _a4, _b3; + var _a3, _b2; + $ZodCheck.init(inst, def); + inst._zod.onattach.push((inst2) => { + var _a5; + const bag = inst2._zod.bag; + bag.format = def.format; + if (def.pattern) { + (_a5 = bag.patterns) != null ? _a5 : bag.patterns = /* @__PURE__ */ new Set(); + bag.patterns.add(def.pattern); + } + }); + if (def.pattern) + (_a4 = (_a3 = inst._zod).check) != null ? _a4 : _a3.check = (payload) => { + def.pattern.lastIndex = 0; + if (def.pattern.test(payload.value)) + return; + payload.issues.push({ + origin: "string", + code: "invalid_format", + format: def.format, + input: payload.value, + ...def.pattern ? { pattern: def.pattern.toString() } : {}, + inst, + continue: !def.abort + }); + }; + else + (_b3 = (_b2 = inst._zod).check) != null ? _b3 : _b2.check = () => { + }; +}); +var $ZodCheckRegex = /* @__PURE__ */ $constructor("$ZodCheckRegex", (inst, def) => { + $ZodCheckStringFormat.init(inst, def); + inst._zod.check = (payload) => { + def.pattern.lastIndex = 0; + if (def.pattern.test(payload.value)) + return; + payload.issues.push({ + origin: "string", + code: "invalid_format", + format: "regex", + input: payload.value, + pattern: def.pattern.toString(), + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckLowerCase = /* @__PURE__ */ $constructor("$ZodCheckLowerCase", (inst, def) => { + var _a3; + (_a3 = def.pattern) != null ? _a3 : def.pattern = lowercase; + $ZodCheckStringFormat.init(inst, def); +}); +var $ZodCheckUpperCase = /* @__PURE__ */ $constructor("$ZodCheckUpperCase", (inst, def) => { + var _a3; + (_a3 = def.pattern) != null ? _a3 : def.pattern = uppercase; + $ZodCheckStringFormat.init(inst, def); +}); +var $ZodCheckIncludes = /* @__PURE__ */ $constructor("$ZodCheckIncludes", (inst, def) => { + $ZodCheck.init(inst, def); + const escapedRegex = escapeRegex(def.includes); + const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position}}${escapedRegex}` : escapedRegex); + def.pattern = pattern; + inst._zod.onattach.push((inst2) => { + var _a3; + const bag = inst2._zod.bag; + (_a3 = bag.patterns) != null ? _a3 : bag.patterns = /* @__PURE__ */ new Set(); + bag.patterns.add(pattern); + }); + inst._zod.check = (payload) => { + if (payload.value.includes(def.includes, def.position)) + return; + payload.issues.push({ + origin: "string", + code: "invalid_format", + format: "includes", + includes: def.includes, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckStartsWith = /* @__PURE__ */ $constructor("$ZodCheckStartsWith", (inst, def) => { + var _a3; + $ZodCheck.init(inst, def); + const pattern = new RegExp(`^${escapeRegex(def.prefix)}.*`); + (_a3 = def.pattern) != null ? _a3 : def.pattern = pattern; + inst._zod.onattach.push((inst2) => { + var _a4; + const bag = inst2._zod.bag; + (_a4 = bag.patterns) != null ? _a4 : bag.patterns = /* @__PURE__ */ new Set(); + bag.patterns.add(pattern); + }); + inst._zod.check = (payload) => { + if (payload.value.startsWith(def.prefix)) + return; + payload.issues.push({ + origin: "string", + code: "invalid_format", + format: "starts_with", + prefix: def.prefix, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckEndsWith = /* @__PURE__ */ $constructor("$ZodCheckEndsWith", (inst, def) => { + var _a3; + $ZodCheck.init(inst, def); + const pattern = new RegExp(`.*${escapeRegex(def.suffix)}$`); + (_a3 = def.pattern) != null ? _a3 : def.pattern = pattern; + inst._zod.onattach.push((inst2) => { + var _a4; + const bag = inst2._zod.bag; + (_a4 = bag.patterns) != null ? _a4 : bag.patterns = /* @__PURE__ */ new Set(); + bag.patterns.add(pattern); + }); + inst._zod.check = (payload) => { + if (payload.value.endsWith(def.suffix)) + return; + payload.issues.push({ + origin: "string", + code: "invalid_format", + format: "ends_with", + suffix: def.suffix, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +function handleCheckPropertyResult(result, payload, property) { + if (result.issues.length) { + payload.issues.push(...prefixIssues(property, result.issues)); + } +} +var $ZodCheckProperty = /* @__PURE__ */ $constructor("$ZodCheckProperty", (inst, def) => { + $ZodCheck.init(inst, def); + inst._zod.check = (payload) => { + const result = def.schema._zod.run({ + value: payload.value[def.property], + issues: [] + }, {}); + if (result instanceof Promise) { + return result.then((result2) => handleCheckPropertyResult(result2, payload, def.property)); + } + handleCheckPropertyResult(result, payload, def.property); + return; + }; +}); +var $ZodCheckMimeType = /* @__PURE__ */ $constructor("$ZodCheckMimeType", (inst, def) => { + $ZodCheck.init(inst, def); + const mimeSet = new Set(def.mime); + inst._zod.onattach.push((inst2) => { + inst2._zod.bag.mime = def.mime; + }); + inst._zod.check = (payload) => { + if (mimeSet.has(payload.value.type)) + return; + payload.issues.push({ + code: "invalid_value", + values: def.mime, + input: payload.value.type, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (inst, def) => { + $ZodCheck.init(inst, def); + inst._zod.check = (payload) => { + payload.value = def.tx(payload.value); + }; +}); + +// node_modules/zod/v4/core/doc.js +var Doc = class { + constructor(args = []) { + this.content = []; + this.indent = 0; + if (this) + this.args = args; + } + indented(fn) { + this.indent += 1; + fn(this); + this.indent -= 1; + } + write(arg) { + if (typeof arg === "function") { + arg(this, { execution: "sync" }); + arg(this, { execution: "async" }); + return; + } + const content = arg; + const lines = content.split("\n").filter((x) => x); + const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length)); + const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x); + for (const line of dedented) { + this.content.push(line); + } + } + compile() { + var _a3; + const F3 = Function; + const args = this == null ? void 0 : this.args; + const content = (_a3 = this == null ? void 0 : this.content) != null ? _a3 : [``]; + const lines = [...content.map((x) => ` ${x}`)]; + return new F3(...args, lines.join("\n")); + } +}; + +// node_modules/zod/v4/core/versions.js +var version = { + major: 4, + minor: 3, + patch: 6 +}; + +// node_modules/zod/v4/core/schemas.js +var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => { + var _a4, _b2, _c; + var _a3; + inst != null ? inst : inst = {}; + inst._zod.def = def; + inst._zod.bag = inst._zod.bag || {}; + inst._zod.version = version; + const checks = [...(_a4 = inst._zod.def.checks) != null ? _a4 : []]; + if (inst._zod.traits.has("$ZodCheck")) { + checks.unshift(inst); + } + for (const ch of checks) { + for (const fn of ch._zod.onattach) { + fn(inst); + } + } + if (checks.length === 0) { + (_b2 = (_a3 = inst._zod).deferred) != null ? _b2 : _a3.deferred = []; + (_c = inst._zod.deferred) == null ? void 0 : _c.push(() => { + inst._zod.run = inst._zod.parse; + }); + } else { + const runChecks = (payload, checks2, ctx) => { + let isAborted2 = aborted(payload); + let asyncResult; + for (const ch of checks2) { + if (ch._zod.def.when) { + const shouldRun = ch._zod.def.when(payload); + if (!shouldRun) + continue; + } else if (isAborted2) { + continue; + } + const currLen = payload.issues.length; + const _3 = ch._zod.check(payload); + if (_3 instanceof Promise && (ctx == null ? void 0 : ctx.async) === false) { + throw new $ZodAsyncError(); + } + if (asyncResult || _3 instanceof Promise) { + asyncResult = (asyncResult != null ? asyncResult : Promise.resolve()).then(async () => { + await _3; + const nextLen = payload.issues.length; + if (nextLen === currLen) + return; + if (!isAborted2) + isAborted2 = aborted(payload, currLen); + }); + } else { + const nextLen = payload.issues.length; + if (nextLen === currLen) + continue; + if (!isAborted2) + isAborted2 = aborted(payload, currLen); + } + } + if (asyncResult) { + return asyncResult.then(() => { + return payload; + }); + } + return payload; + }; + const handleCanaryResult = (canary, payload, ctx) => { + if (aborted(canary)) { + canary.aborted = true; + return canary; + } + const checkResult = runChecks(payload, checks, ctx); + if (checkResult instanceof Promise) { + if (ctx.async === false) + throw new $ZodAsyncError(); + return checkResult.then((checkResult2) => inst._zod.parse(checkResult2, ctx)); + } + return inst._zod.parse(checkResult, ctx); + }; + inst._zod.run = (payload, ctx) => { + if (ctx.skipChecks) { + return inst._zod.parse(payload, ctx); + } + if (ctx.direction === "backward") { + const canary = inst._zod.parse({ value: payload.value, issues: [] }, { ...ctx, skipChecks: true }); + if (canary instanceof Promise) { + return canary.then((canary2) => { + return handleCanaryResult(canary2, payload, ctx); + }); + } + return handleCanaryResult(canary, payload, ctx); + } + const result = inst._zod.parse(payload, ctx); + if (result instanceof Promise) { + if (ctx.async === false) + throw new $ZodAsyncError(); + return result.then((result2) => runChecks(result2, checks, ctx)); + } + return runChecks(result, checks, ctx); + }; + } + defineLazy(inst, "~standard", () => ({ + validate: (value) => { + var _a5; + try { + const r3 = safeParse(inst, value); + return r3.success ? { value: r3.data } : { issues: (_a5 = r3.error) == null ? void 0 : _a5.issues }; + } catch (_3) { + return safeParseAsync(inst, value).then((r3) => { + var _a6; + return r3.success ? { value: r3.data } : { issues: (_a6 = r3.error) == null ? void 0 : _a6.issues }; + }); + } + }, + vendor: "zod", + version: 1 + })); +}); +var $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => { + var _a3, _b2, _c; + $ZodType.init(inst, def); + inst._zod.pattern = (_c = [...(_b2 = (_a3 = inst == null ? void 0 : inst._zod.bag) == null ? void 0 : _a3.patterns) != null ? _b2 : []].pop()) != null ? _c : string(inst._zod.bag); + inst._zod.parse = (payload, _3) => { + if (def.coerce) + try { + payload.value = String(payload.value); + } catch (_6) { + } + if (typeof payload.value === "string") + return payload; + payload.issues.push({ + expected: "string", + code: "invalid_type", + input: payload.value, + inst + }); + return payload; + }; +}); +var $ZodStringFormat = /* @__PURE__ */ $constructor("$ZodStringFormat", (inst, def) => { + $ZodCheckStringFormat.init(inst, def); + $ZodString.init(inst, def); +}); +var $ZodGUID = /* @__PURE__ */ $constructor("$ZodGUID", (inst, def) => { + var _a3; + (_a3 = def.pattern) != null ? _a3 : def.pattern = guid; + $ZodStringFormat.init(inst, def); +}); +var $ZodUUID = /* @__PURE__ */ $constructor("$ZodUUID", (inst, def) => { + var _a3, _b2; + if (def.version) { + const versionMap = { + v1: 1, + v2: 2, + v3: 3, + v4: 4, + v5: 5, + v6: 6, + v7: 7, + v8: 8 + }; + const v2 = versionMap[def.version]; + if (v2 === void 0) + throw new Error(`Invalid UUID version: "${def.version}"`); + (_a3 = def.pattern) != null ? _a3 : def.pattern = uuid(v2); + } else + (_b2 = def.pattern) != null ? _b2 : def.pattern = uuid(); + $ZodStringFormat.init(inst, def); +}); +var $ZodEmail = /* @__PURE__ */ $constructor("$ZodEmail", (inst, def) => { + var _a3; + (_a3 = def.pattern) != null ? _a3 : def.pattern = email; + $ZodStringFormat.init(inst, def); +}); +var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => { + $ZodStringFormat.init(inst, def); + inst._zod.check = (payload) => { + try { + const trimmed = payload.value.trim(); + const url2 = new URL(trimmed); + if (def.hostname) { + def.hostname.lastIndex = 0; + if (!def.hostname.test(url2.hostname)) { + payload.issues.push({ + code: "invalid_format", + format: "url", + note: "Invalid hostname", + pattern: def.hostname.source, + input: payload.value, + inst, + continue: !def.abort + }); + } + } + if (def.protocol) { + def.protocol.lastIndex = 0; + if (!def.protocol.test(url2.protocol.endsWith(":") ? url2.protocol.slice(0, -1) : url2.protocol)) { + payload.issues.push({ + code: "invalid_format", + format: "url", + note: "Invalid protocol", + pattern: def.protocol.source, + input: payload.value, + inst, + continue: !def.abort + }); + } + } + if (def.normalize) { + payload.value = url2.href; + } else { + payload.value = trimmed; + } + return; + } catch (_3) { + payload.issues.push({ + code: "invalid_format", + format: "url", + input: payload.value, + inst, + continue: !def.abort + }); + } + }; +}); +var $ZodEmoji = /* @__PURE__ */ $constructor("$ZodEmoji", (inst, def) => { + var _a3; + (_a3 = def.pattern) != null ? _a3 : def.pattern = emoji(); + $ZodStringFormat.init(inst, def); +}); +var $ZodNanoID = /* @__PURE__ */ $constructor("$ZodNanoID", (inst, def) => { + var _a3; + (_a3 = def.pattern) != null ? _a3 : def.pattern = nanoid; + $ZodStringFormat.init(inst, def); +}); +var $ZodCUID = /* @__PURE__ */ $constructor("$ZodCUID", (inst, def) => { + var _a3; + (_a3 = def.pattern) != null ? _a3 : def.pattern = cuid; + $ZodStringFormat.init(inst, def); +}); +var $ZodCUID2 = /* @__PURE__ */ $constructor("$ZodCUID2", (inst, def) => { + var _a3; + (_a3 = def.pattern) != null ? _a3 : def.pattern = cuid2; + $ZodStringFormat.init(inst, def); +}); +var $ZodULID = /* @__PURE__ */ $constructor("$ZodULID", (inst, def) => { + var _a3; + (_a3 = def.pattern) != null ? _a3 : def.pattern = ulid; + $ZodStringFormat.init(inst, def); +}); +var $ZodXID = /* @__PURE__ */ $constructor("$ZodXID", (inst, def) => { + var _a3; + (_a3 = def.pattern) != null ? _a3 : def.pattern = xid; + $ZodStringFormat.init(inst, def); +}); +var $ZodKSUID = /* @__PURE__ */ $constructor("$ZodKSUID", (inst, def) => { + var _a3; + (_a3 = def.pattern) != null ? _a3 : def.pattern = ksuid; + $ZodStringFormat.init(inst, def); +}); +var $ZodISODateTime = /* @__PURE__ */ $constructor("$ZodISODateTime", (inst, def) => { + var _a3; + (_a3 = def.pattern) != null ? _a3 : def.pattern = datetime(def); + $ZodStringFormat.init(inst, def); +}); +var $ZodISODate = /* @__PURE__ */ $constructor("$ZodISODate", (inst, def) => { + var _a3; + (_a3 = def.pattern) != null ? _a3 : def.pattern = date; + $ZodStringFormat.init(inst, def); +}); +var $ZodISOTime = /* @__PURE__ */ $constructor("$ZodISOTime", (inst, def) => { + var _a3; + (_a3 = def.pattern) != null ? _a3 : def.pattern = time(def); + $ZodStringFormat.init(inst, def); +}); +var $ZodISODuration = /* @__PURE__ */ $constructor("$ZodISODuration", (inst, def) => { + var _a3; + (_a3 = def.pattern) != null ? _a3 : def.pattern = duration; + $ZodStringFormat.init(inst, def); +}); +var $ZodIPv4 = /* @__PURE__ */ $constructor("$ZodIPv4", (inst, def) => { + var _a3; + (_a3 = def.pattern) != null ? _a3 : def.pattern = ipv4; + $ZodStringFormat.init(inst, def); + inst._zod.bag.format = `ipv4`; +}); +var $ZodIPv6 = /* @__PURE__ */ $constructor("$ZodIPv6", (inst, def) => { + var _a3; + (_a3 = def.pattern) != null ? _a3 : def.pattern = ipv6; + $ZodStringFormat.init(inst, def); + inst._zod.bag.format = `ipv6`; + inst._zod.check = (payload) => { + try { + new URL(`http://[${payload.value}]`); + } catch (e3) { + payload.issues.push({ + code: "invalid_format", + format: "ipv6", + input: payload.value, + inst, + continue: !def.abort + }); + } + }; +}); +var $ZodMAC = /* @__PURE__ */ $constructor("$ZodMAC", (inst, def) => { + var _a3; + (_a3 = def.pattern) != null ? _a3 : def.pattern = mac(def.delimiter); + $ZodStringFormat.init(inst, def); + inst._zod.bag.format = `mac`; +}); +var $ZodCIDRv4 = /* @__PURE__ */ $constructor("$ZodCIDRv4", (inst, def) => { + var _a3; + (_a3 = def.pattern) != null ? _a3 : def.pattern = cidrv4; + $ZodStringFormat.init(inst, def); +}); +var $ZodCIDRv6 = /* @__PURE__ */ $constructor("$ZodCIDRv6", (inst, def) => { + var _a3; + (_a3 = def.pattern) != null ? _a3 : def.pattern = cidrv6; + $ZodStringFormat.init(inst, def); + inst._zod.check = (payload) => { + const parts = payload.value.split("/"); + try { + if (parts.length !== 2) + throw new Error(); + const [address, prefix] = parts; + if (!prefix) + throw new Error(); + const prefixNum = Number(prefix); + if (`${prefixNum}` !== prefix) + throw new Error(); + if (prefixNum < 0 || prefixNum > 128) + throw new Error(); + new URL(`http://[${address}]`); + } catch (e3) { + payload.issues.push({ + code: "invalid_format", + format: "cidrv6", + input: payload.value, + inst, + continue: !def.abort + }); + } + }; +}); +function isValidBase64(data) { + if (data === "") + return true; + if (data.length % 4 !== 0) + return false; + try { + atob(data); + return true; + } catch (e3) { + return false; + } +} +var $ZodBase64 = /* @__PURE__ */ $constructor("$ZodBase64", (inst, def) => { + var _a3; + (_a3 = def.pattern) != null ? _a3 : def.pattern = base64; + $ZodStringFormat.init(inst, def); + inst._zod.bag.contentEncoding = "base64"; + inst._zod.check = (payload) => { + if (isValidBase64(payload.value)) + return; + payload.issues.push({ + code: "invalid_format", + format: "base64", + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +function isValidBase64URL(data) { + if (!base64url.test(data)) + return false; + const base643 = data.replace(/[-_]/g, (c) => c === "-" ? "+" : "/"); + const padded = base643.padEnd(Math.ceil(base643.length / 4) * 4, "="); + return isValidBase64(padded); +} +var $ZodBase64URL = /* @__PURE__ */ $constructor("$ZodBase64URL", (inst, def) => { + var _a3; + (_a3 = def.pattern) != null ? _a3 : def.pattern = base64url; + $ZodStringFormat.init(inst, def); + inst._zod.bag.contentEncoding = "base64url"; + inst._zod.check = (payload) => { + if (isValidBase64URL(payload.value)) + return; + payload.issues.push({ + code: "invalid_format", + format: "base64url", + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodE164 = /* @__PURE__ */ $constructor("$ZodE164", (inst, def) => { + var _a3; + (_a3 = def.pattern) != null ? _a3 : def.pattern = e164; + $ZodStringFormat.init(inst, def); +}); +function isValidJWT2(token, algorithm = null) { + try { + const tokensParts = token.split("."); + if (tokensParts.length !== 3) + return false; + const [header] = tokensParts; + if (!header) + return false; + const parsedHeader = JSON.parse(atob(header)); + if ("typ" in parsedHeader && (parsedHeader == null ? void 0 : parsedHeader.typ) !== "JWT") + return false; + if (!parsedHeader.alg) + return false; + if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm)) + return false; + return true; + } catch (e3) { + return false; + } +} +var $ZodJWT = /* @__PURE__ */ $constructor("$ZodJWT", (inst, def) => { + $ZodStringFormat.init(inst, def); + inst._zod.check = (payload) => { + if (isValidJWT2(payload.value, def.alg)) + return; + payload.issues.push({ + code: "invalid_format", + format: "jwt", + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCustomStringFormat = /* @__PURE__ */ $constructor("$ZodCustomStringFormat", (inst, def) => { + $ZodStringFormat.init(inst, def); + inst._zod.check = (payload) => { + if (def.fn(payload.value)) + return; + payload.issues.push({ + code: "invalid_format", + format: def.format, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => { + var _a3; + $ZodType.init(inst, def); + inst._zod.pattern = (_a3 = inst._zod.bag.pattern) != null ? _a3 : number; + inst._zod.parse = (payload, _ctx) => { + if (def.coerce) + try { + payload.value = Number(payload.value); + } catch (_3) { + } + const input = payload.value; + if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) { + return payload; + } + const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : void 0 : void 0; + payload.issues.push({ + expected: "number", + code: "invalid_type", + input, + inst, + ...received ? { received } : {} + }); + return payload; + }; +}); +var $ZodNumberFormat = /* @__PURE__ */ $constructor("$ZodNumberFormat", (inst, def) => { + $ZodCheckNumberFormat.init(inst, def); + $ZodNumber.init(inst, def); +}); +var $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.pattern = boolean; + inst._zod.parse = (payload, _ctx) => { + if (def.coerce) + try { + payload.value = Boolean(payload.value); + } catch (_3) { + } + const input = payload.value; + if (typeof input === "boolean") + return payload; + payload.issues.push({ + expected: "boolean", + code: "invalid_type", + input, + inst + }); + return payload; + }; +}); +var $ZodBigInt = /* @__PURE__ */ $constructor("$ZodBigInt", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.pattern = bigint; + inst._zod.parse = (payload, _ctx) => { + if (def.coerce) + try { + payload.value = BigInt(payload.value); + } catch (_3) { + } + if (typeof payload.value === "bigint") + return payload; + payload.issues.push({ + expected: "bigint", + code: "invalid_type", + input: payload.value, + inst + }); + return payload; + }; +}); +var $ZodBigIntFormat = /* @__PURE__ */ $constructor("$ZodBigIntFormat", (inst, def) => { + $ZodCheckBigIntFormat.init(inst, def); + $ZodBigInt.init(inst, def); +}); +var $ZodSymbol = /* @__PURE__ */ $constructor("$ZodSymbol", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, _ctx) => { + const input = payload.value; + if (typeof input === "symbol") + return payload; + payload.issues.push({ + expected: "symbol", + code: "invalid_type", + input, + inst + }); + return payload; + }; +}); +var $ZodUndefined = /* @__PURE__ */ $constructor("$ZodUndefined", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.pattern = _undefined; + inst._zod.values = /* @__PURE__ */ new Set([void 0]); + inst._zod.optin = "optional"; + inst._zod.optout = "optional"; + inst._zod.parse = (payload, _ctx) => { + const input = payload.value; + if (typeof input === "undefined") + return payload; + payload.issues.push({ + expected: "undefined", + code: "invalid_type", + input, + inst + }); + return payload; + }; +}); +var $ZodNull = /* @__PURE__ */ $constructor("$ZodNull", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.pattern = _null; + inst._zod.values = /* @__PURE__ */ new Set([null]); + inst._zod.parse = (payload, _ctx) => { + const input = payload.value; + if (input === null) + return payload; + payload.issues.push({ + expected: "null", + code: "invalid_type", + input, + inst + }); + return payload; + }; +}); +var $ZodAny = /* @__PURE__ */ $constructor("$ZodAny", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload) => payload; +}); +var $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload) => payload; +}); +var $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, _ctx) => { + payload.issues.push({ + expected: "never", + code: "invalid_type", + input: payload.value, + inst + }); + return payload; + }; +}); +var $ZodVoid = /* @__PURE__ */ $constructor("$ZodVoid", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, _ctx) => { + const input = payload.value; + if (typeof input === "undefined") + return payload; + payload.issues.push({ + expected: "void", + code: "invalid_type", + input, + inst + }); + return payload; + }; +}); +var $ZodDate = /* @__PURE__ */ $constructor("$ZodDate", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, _ctx) => { + if (def.coerce) { + try { + payload.value = new Date(payload.value); + } catch (_err) { + } + } + const input = payload.value; + const isDate = input instanceof Date; + const isValidDate = isDate && !Number.isNaN(input.getTime()); + if (isValidDate) + return payload; + payload.issues.push({ + expected: "date", + code: "invalid_type", + input, + ...isDate ? { received: "Invalid Date" } : {}, + inst + }); + return payload; + }; +}); +function handleArrayResult(result, final, index) { + if (result.issues.length) { + final.issues.push(...prefixIssues(index, result.issues)); + } + final.value[index] = result.value; +} +var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, ctx) => { + const input = payload.value; + if (!Array.isArray(input)) { + payload.issues.push({ + expected: "array", + code: "invalid_type", + input, + inst + }); + return payload; + } + payload.value = Array(input.length); + const proms = []; + for (let i3 = 0; i3 < input.length; i3++) { + const item = input[i3]; + const result = def.element._zod.run({ + value: item, + issues: [] + }, ctx); + if (result instanceof Promise) { + proms.push(result.then((result2) => handleArrayResult(result2, payload, i3))); + } else { + handleArrayResult(result, payload, i3); + } + } + if (proms.length) { + return Promise.all(proms).then(() => payload); + } + return payload; + }; +}); +function handlePropertyResult(result, final, key, input, isOptionalOut) { + if (result.issues.length) { + if (isOptionalOut && !(key in input)) { + return; + } + final.issues.push(...prefixIssues(key, result.issues)); + } + if (result.value === void 0) { + if (key in input) { + final.value[key] = void 0; + } + } else { + final.value[key] = result.value; + } +} +function normalizeDef(def) { + var _a3, _b2, _c, _d; + const keys = Object.keys(def.shape); + for (const k3 of keys) { + if (!((_d = (_c = (_b2 = (_a3 = def.shape) == null ? void 0 : _a3[k3]) == null ? void 0 : _b2._zod) == null ? void 0 : _c.traits) == null ? void 0 : _d.has("$ZodType"))) { + throw new Error(`Invalid element at key "${k3}": expected a Zod schema`); + } + } + const okeys = optionalKeys(def.shape); + return { + ...def, + keys, + keySet: new Set(keys), + numKeys: keys.length, + optionalKeys: new Set(okeys) + }; +} +function handleCatchall(proms, input, payload, ctx, def, inst) { + const unrecognized = []; + const keySet = def.keySet; + const _catchall = def.catchall._zod; + const t3 = _catchall.def.type; + const isOptionalOut = _catchall.optout === "optional"; + for (const key in input) { + if (keySet.has(key)) + continue; + if (t3 === "never") { + unrecognized.push(key); + continue; + } + const r3 = _catchall.run({ value: input[key], issues: [] }, ctx); + if (r3 instanceof Promise) { + proms.push(r3.then((r4) => handlePropertyResult(r4, payload, key, input, isOptionalOut))); + } else { + handlePropertyResult(r3, payload, key, input, isOptionalOut); + } + } + if (unrecognized.length) { + payload.issues.push({ + code: "unrecognized_keys", + keys: unrecognized, + input, + inst + }); + } + if (!proms.length) + return payload; + return Promise.all(proms).then(() => { + return payload; + }); +} +var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => { + $ZodType.init(inst, def); + const desc = Object.getOwnPropertyDescriptor(def, "shape"); + if (!(desc == null ? void 0 : desc.get)) { + const sh = def.shape; + Object.defineProperty(def, "shape", { + get: () => { + const newSh = { ...sh }; + Object.defineProperty(def, "shape", { + value: newSh + }); + return newSh; + } + }); + } + const _normalized = cached(() => normalizeDef(def)); + defineLazy(inst._zod, "propValues", () => { + var _a3; + const shape = def.shape; + const propValues = {}; + for (const key in shape) { + const field = shape[key]._zod; + if (field.values) { + (_a3 = propValues[key]) != null ? _a3 : propValues[key] = /* @__PURE__ */ new Set(); + for (const v2 of field.values) + propValues[key].add(v2); + } + } + return propValues; + }); + const isObject2 = isObject; + const catchall = def.catchall; + let value; + inst._zod.parse = (payload, ctx) => { + value != null ? value : value = _normalized.value; + const input = payload.value; + if (!isObject2(input)) { + payload.issues.push({ + expected: "object", + code: "invalid_type", + input, + inst + }); + return payload; + } + payload.value = {}; + const proms = []; + const shape = value.shape; + for (const key of value.keys) { + const el2 = shape[key]; + const isOptionalOut = el2._zod.optout === "optional"; + const r3 = el2._zod.run({ value: input[key], issues: [] }, ctx); + if (r3 instanceof Promise) { + proms.push(r3.then((r4) => handlePropertyResult(r4, payload, key, input, isOptionalOut))); + } else { + handlePropertyResult(r3, payload, key, input, isOptionalOut); + } + } + if (!catchall) { + return proms.length ? Promise.all(proms).then(() => payload) : payload; + } + return handleCatchall(proms, input, payload, ctx, _normalized.value, inst); + }; +}); +var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) => { + $ZodObject.init(inst, def); + const superParse = inst._zod.parse; + const _normalized = cached(() => normalizeDef(def)); + const generateFastpass = (shape) => { + var _a3; + const doc = new Doc(["shape", "payload", "ctx"]); + const normalized = _normalized.value; + const parseStr = (key) => { + const k3 = esc(key); + return `shape[${k3}]._zod.run({ value: input[${k3}], issues: [] }, ctx)`; + }; + doc.write(`const input = payload.value;`); + const ids = /* @__PURE__ */ Object.create(null); + let counter = 0; + for (const key of normalized.keys) { + ids[key] = `key_${counter++}`; + } + doc.write(`const newResult = {};`); + for (const key of normalized.keys) { + const id = ids[key]; + const k3 = esc(key); + const schema = shape[key]; + const isOptionalOut = ((_a3 = schema == null ? void 0 : schema._zod) == null ? void 0 : _a3.optout) === "optional"; + doc.write(`const ${id} = ${parseStr(key)};`); + if (isOptionalOut) { + doc.write(` + if (${id}.issues.length) { + if (${k3} in input) { + payload.issues = payload.issues.concat(${id}.issues.map(iss => ({ + ...iss, + path: iss.path ? [${k3}, ...iss.path] : [${k3}] + }))); + } + } + + if (${id}.value === undefined) { + if (${k3} in input) { + newResult[${k3}] = undefined; + } + } else { + newResult[${k3}] = ${id}.value; + } + + `); + } else { + doc.write(` + if (${id}.issues.length) { + payload.issues = payload.issues.concat(${id}.issues.map(iss => ({ + ...iss, + path: iss.path ? [${k3}, ...iss.path] : [${k3}] + }))); + } + + if (${id}.value === undefined) { + if (${k3} in input) { + newResult[${k3}] = undefined; + } + } else { + newResult[${k3}] = ${id}.value; + } + + `); + } + } + doc.write(`payload.value = newResult;`); + doc.write(`return payload;`); + const fn = doc.compile(); + return (payload, ctx) => fn(shape, payload, ctx); + }; + let fastpass; + const isObject2 = isObject; + const jit = !globalConfig.jitless; + const allowsEval2 = allowsEval; + const fastEnabled = jit && allowsEval2.value; + const catchall = def.catchall; + let value; + inst._zod.parse = (payload, ctx) => { + value != null ? value : value = _normalized.value; + const input = payload.value; + if (!isObject2(input)) { + payload.issues.push({ + expected: "object", + code: "invalid_type", + input, + inst + }); + return payload; + } + if (jit && fastEnabled && (ctx == null ? void 0 : ctx.async) === false && ctx.jitless !== true) { + if (!fastpass) + fastpass = generateFastpass(def.shape); + payload = fastpass(payload, ctx); + if (!catchall) + return payload; + return handleCatchall([], input, payload, ctx, value, inst); + } + return superParse(payload, ctx); + }; +}); +function handleUnionResults(results, final, inst, ctx) { + for (const result of results) { + if (result.issues.length === 0) { + final.value = result.value; + return final; + } + } + const nonaborted = results.filter((r3) => !aborted(r3)); + if (nonaborted.length === 1) { + final.value = nonaborted[0].value; + return nonaborted[0]; + } + final.issues.push({ + code: "invalid_union", + input: final.value, + inst, + errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config()))) + }); + return final; +} +var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "optin", () => def.options.some((o3) => o3._zod.optin === "optional") ? "optional" : void 0); + defineLazy(inst._zod, "optout", () => def.options.some((o3) => o3._zod.optout === "optional") ? "optional" : void 0); + defineLazy(inst._zod, "values", () => { + if (def.options.every((o3) => o3._zod.values)) { + return new Set(def.options.flatMap((option) => Array.from(option._zod.values))); + } + return void 0; + }); + defineLazy(inst._zod, "pattern", () => { + if (def.options.every((o3) => o3._zod.pattern)) { + const patterns = def.options.map((o3) => o3._zod.pattern); + return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`); + } + return void 0; + }); + const single = def.options.length === 1; + const first = def.options[0]._zod.run; + inst._zod.parse = (payload, ctx) => { + if (single) { + return first(payload, ctx); + } + let async = false; + const results = []; + for (const option of def.options) { + const result = option._zod.run({ + value: payload.value, + issues: [] + }, ctx); + if (result instanceof Promise) { + results.push(result); + async = true; + } else { + if (result.issues.length === 0) + return result; + results.push(result); + } + } + if (!async) + return handleUnionResults(results, payload, inst, ctx); + return Promise.all(results).then((results2) => { + return handleUnionResults(results2, payload, inst, ctx); + }); + }; +}); +function handleExclusiveUnionResults(results, final, inst, ctx) { + const successes = results.filter((r3) => r3.issues.length === 0); + if (successes.length === 1) { + final.value = successes[0].value; + return final; + } + if (successes.length === 0) { + final.issues.push({ + code: "invalid_union", + input: final.value, + inst, + errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config()))) + }); + } else { + final.issues.push({ + code: "invalid_union", + input: final.value, + inst, + errors: [], + inclusive: false + }); + } + return final; +} +var $ZodXor = /* @__PURE__ */ $constructor("$ZodXor", (inst, def) => { + $ZodUnion.init(inst, def); + def.inclusive = false; + const single = def.options.length === 1; + const first = def.options[0]._zod.run; + inst._zod.parse = (payload, ctx) => { + if (single) { + return first(payload, ctx); + } + let async = false; + const results = []; + for (const option of def.options) { + const result = option._zod.run({ + value: payload.value, + issues: [] + }, ctx); + if (result instanceof Promise) { + results.push(result); + async = true; + } else { + results.push(result); + } + } + if (!async) + return handleExclusiveUnionResults(results, payload, inst, ctx); + return Promise.all(results).then((results2) => { + return handleExclusiveUnionResults(results2, payload, inst, ctx); + }); + }; +}); +var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnion", (inst, def) => { + def.inclusive = false; + $ZodUnion.init(inst, def); + const _super = inst._zod.parse; + defineLazy(inst._zod, "propValues", () => { + const propValues = {}; + for (const option of def.options) { + const pv = option._zod.propValues; + if (!pv || Object.keys(pv).length === 0) + throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`); + for (const [k3, v2] of Object.entries(pv)) { + if (!propValues[k3]) + propValues[k3] = /* @__PURE__ */ new Set(); + for (const val of v2) { + propValues[k3].add(val); + } + } + } + return propValues; + }); + const disc = cached(() => { + var _a3; + const opts = def.options; + const map2 = /* @__PURE__ */ new Map(); + for (const o3 of opts) { + const values = (_a3 = o3._zod.propValues) == null ? void 0 : _a3[def.discriminator]; + if (!values || values.size === 0) + throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o3)}"`); + for (const v2 of values) { + if (map2.has(v2)) { + throw new Error(`Duplicate discriminator value "${String(v2)}"`); + } + map2.set(v2, o3); + } + } + return map2; + }); + inst._zod.parse = (payload, ctx) => { + const input = payload.value; + if (!isObject(input)) { + payload.issues.push({ + code: "invalid_type", + expected: "object", + input, + inst + }); + return payload; + } + const opt = disc.value.get(input == null ? void 0 : input[def.discriminator]); + if (opt) { + return opt._zod.run(payload, ctx); + } + if (def.unionFallback) { + return _super(payload, ctx); + } + payload.issues.push({ + code: "invalid_union", + errors: [], + note: "No matching discriminator", + discriminator: def.discriminator, + input, + path: [def.discriminator], + inst + }); + return payload; + }; +}); +var $ZodIntersection = /* @__PURE__ */ $constructor("$ZodIntersection", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, ctx) => { + const input = payload.value; + const left = def.left._zod.run({ value: input, issues: [] }, ctx); + const right = def.right._zod.run({ value: input, issues: [] }, ctx); + const async = left instanceof Promise || right instanceof Promise; + if (async) { + return Promise.all([left, right]).then(([left2, right2]) => { + return handleIntersectionResults(payload, left2, right2); + }); + } + return handleIntersectionResults(payload, left, right); + }; +}); +function mergeValues2(a3, b) { + if (a3 === b) { + return { valid: true, data: a3 }; + } + if (a3 instanceof Date && b instanceof Date && +a3 === +b) { + return { valid: true, data: a3 }; + } + if (isPlainObject(a3) && isPlainObject(b)) { + const bKeys = Object.keys(b); + const sharedKeys = Object.keys(a3).filter((key) => bKeys.indexOf(key) !== -1); + const newObj = { ...a3, ...b }; + for (const key of sharedKeys) { + const sharedValue = mergeValues2(a3[key], b[key]); + if (!sharedValue.valid) { + return { + valid: false, + mergeErrorPath: [key, ...sharedValue.mergeErrorPath] + }; + } + newObj[key] = sharedValue.data; + } + return { valid: true, data: newObj }; + } + if (Array.isArray(a3) && Array.isArray(b)) { + if (a3.length !== b.length) { + return { valid: false, mergeErrorPath: [] }; + } + const newArray = []; + for (let index = 0; index < a3.length; index++) { + const itemA = a3[index]; + const itemB = b[index]; + const sharedValue = mergeValues2(itemA, itemB); + if (!sharedValue.valid) { + return { + valid: false, + mergeErrorPath: [index, ...sharedValue.mergeErrorPath] + }; + } + newArray.push(sharedValue.data); + } + return { valid: true, data: newArray }; + } + return { valid: false, mergeErrorPath: [] }; +} +function handleIntersectionResults(result, left, right) { + const unrecKeys = /* @__PURE__ */ new Map(); + let unrecIssue; + for (const iss of left.issues) { + if (iss.code === "unrecognized_keys") { + unrecIssue != null ? unrecIssue : unrecIssue = iss; + for (const k3 of iss.keys) { + if (!unrecKeys.has(k3)) + unrecKeys.set(k3, {}); + unrecKeys.get(k3).l = true; + } + } else { + result.issues.push(iss); + } + } + for (const iss of right.issues) { + if (iss.code === "unrecognized_keys") { + for (const k3 of iss.keys) { + if (!unrecKeys.has(k3)) + unrecKeys.set(k3, {}); + unrecKeys.get(k3).r = true; + } + } else { + result.issues.push(iss); + } + } + const bothKeys = [...unrecKeys].filter(([, f6]) => f6.l && f6.r).map(([k3]) => k3); + if (bothKeys.length && unrecIssue) { + result.issues.push({ ...unrecIssue, keys: bothKeys }); + } + if (aborted(result)) + return result; + const merged = mergeValues2(left.value, right.value); + if (!merged.valid) { + throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`); + } + result.value = merged.data; + return result; +} +var $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => { + $ZodType.init(inst, def); + const items = def.items; + inst._zod.parse = (payload, ctx) => { + const input = payload.value; + if (!Array.isArray(input)) { + payload.issues.push({ + input, + inst, + expected: "tuple", + code: "invalid_type" + }); + return payload; + } + payload.value = []; + const proms = []; + const reversedIndex = [...items].reverse().findIndex((item) => item._zod.optin !== "optional"); + const optStart = reversedIndex === -1 ? 0 : items.length - reversedIndex; + if (!def.rest) { + const tooBig = input.length > items.length; + const tooSmall = input.length < optStart - 1; + if (tooBig || tooSmall) { + payload.issues.push({ + ...tooBig ? { code: "too_big", maximum: items.length, inclusive: true } : { code: "too_small", minimum: items.length }, + input, + inst, + origin: "array" + }); + return payload; + } + } + let i3 = -1; + for (const item of items) { + i3++; + if (i3 >= input.length) { + if (i3 >= optStart) + continue; + } + const result = item._zod.run({ + value: input[i3], + issues: [] + }, ctx); + if (result instanceof Promise) { + proms.push(result.then((result2) => handleTupleResult(result2, payload, i3))); + } else { + handleTupleResult(result, payload, i3); + } + } + if (def.rest) { + const rest = input.slice(items.length); + for (const el2 of rest) { + i3++; + const result = def.rest._zod.run({ + value: el2, + issues: [] + }, ctx); + if (result instanceof Promise) { + proms.push(result.then((result2) => handleTupleResult(result2, payload, i3))); + } else { + handleTupleResult(result, payload, i3); + } + } + } + if (proms.length) + return Promise.all(proms).then(() => payload); + return payload; + }; +}); +function handleTupleResult(result, final, index) { + if (result.issues.length) { + final.issues.push(...prefixIssues(index, result.issues)); + } + final.value[index] = result.value; +} +var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, ctx) => { + const input = payload.value; + if (!isPlainObject(input)) { + payload.issues.push({ + expected: "record", + code: "invalid_type", + input, + inst + }); + return payload; + } + const proms = []; + const values = def.keyType._zod.values; + if (values) { + payload.value = {}; + const recordKeys = /* @__PURE__ */ new Set(); + for (const key of values) { + if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") { + recordKeys.add(typeof key === "number" ? key.toString() : key); + const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx); + if (result instanceof Promise) { + proms.push(result.then((result2) => { + if (result2.issues.length) { + payload.issues.push(...prefixIssues(key, result2.issues)); + } + payload.value[key] = result2.value; + })); + } else { + if (result.issues.length) { + payload.issues.push(...prefixIssues(key, result.issues)); + } + payload.value[key] = result.value; + } + } + } + let unrecognized; + for (const key in input) { + if (!recordKeys.has(key)) { + unrecognized = unrecognized != null ? unrecognized : []; + unrecognized.push(key); + } + } + if (unrecognized && unrecognized.length > 0) { + payload.issues.push({ + code: "unrecognized_keys", + input, + inst, + keys: unrecognized + }); + } + } else { + payload.value = {}; + for (const key of Reflect.ownKeys(input)) { + if (key === "__proto__") + continue; + let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx); + if (keyResult instanceof Promise) { + throw new Error("Async schemas not supported in object keys currently"); + } + const checkNumericKey = typeof key === "string" && number.test(key) && keyResult.issues.length; + if (checkNumericKey) { + const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx); + if (retryResult instanceof Promise) { + throw new Error("Async schemas not supported in object keys currently"); + } + if (retryResult.issues.length === 0) { + keyResult = retryResult; + } + } + if (keyResult.issues.length) { + if (def.mode === "loose") { + payload.value[key] = input[key]; + } else { + payload.issues.push({ + code: "invalid_key", + origin: "record", + issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())), + input: key, + path: [key], + inst + }); + } + continue; + } + const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx); + if (result instanceof Promise) { + proms.push(result.then((result2) => { + if (result2.issues.length) { + payload.issues.push(...prefixIssues(key, result2.issues)); + } + payload.value[keyResult.value] = result2.value; + })); + } else { + if (result.issues.length) { + payload.issues.push(...prefixIssues(key, result.issues)); + } + payload.value[keyResult.value] = result.value; + } + } + } + if (proms.length) { + return Promise.all(proms).then(() => payload); + } + return payload; + }; +}); +var $ZodMap = /* @__PURE__ */ $constructor("$ZodMap", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, ctx) => { + const input = payload.value; + if (!(input instanceof Map)) { + payload.issues.push({ + expected: "map", + code: "invalid_type", + input, + inst + }); + return payload; + } + const proms = []; + payload.value = /* @__PURE__ */ new Map(); + for (const [key, value] of input) { + const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx); + const valueResult = def.valueType._zod.run({ value, issues: [] }, ctx); + if (keyResult instanceof Promise || valueResult instanceof Promise) { + proms.push(Promise.all([keyResult, valueResult]).then(([keyResult2, valueResult2]) => { + handleMapResult(keyResult2, valueResult2, payload, key, input, inst, ctx); + })); + } else { + handleMapResult(keyResult, valueResult, payload, key, input, inst, ctx); + } + } + if (proms.length) + return Promise.all(proms).then(() => payload); + return payload; + }; +}); +function handleMapResult(keyResult, valueResult, final, key, input, inst, ctx) { + if (keyResult.issues.length) { + if (propertyKeyTypes.has(typeof key)) { + final.issues.push(...prefixIssues(key, keyResult.issues)); + } else { + final.issues.push({ + code: "invalid_key", + origin: "map", + input, + inst, + issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())) + }); + } + } + if (valueResult.issues.length) { + if (propertyKeyTypes.has(typeof key)) { + final.issues.push(...prefixIssues(key, valueResult.issues)); + } else { + final.issues.push({ + origin: "map", + code: "invalid_element", + input, + inst, + key, + issues: valueResult.issues.map((iss) => finalizeIssue(iss, ctx, config())) + }); + } + } + final.value.set(keyResult.value, valueResult.value); +} +var $ZodSet = /* @__PURE__ */ $constructor("$ZodSet", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, ctx) => { + const input = payload.value; + if (!(input instanceof Set)) { + payload.issues.push({ + input, + inst, + expected: "set", + code: "invalid_type" + }); + return payload; + } + const proms = []; + payload.value = /* @__PURE__ */ new Set(); + for (const item of input) { + const result = def.valueType._zod.run({ value: item, issues: [] }, ctx); + if (result instanceof Promise) { + proms.push(result.then((result2) => handleSetResult(result2, payload))); + } else + handleSetResult(result, payload); + } + if (proms.length) + return Promise.all(proms).then(() => payload); + return payload; + }; +}); +function handleSetResult(result, final) { + if (result.issues.length) { + final.issues.push(...result.issues); + } + final.value.add(result.value); +} +var $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => { + $ZodType.init(inst, def); + const values = getEnumValues(def.entries); + const valuesSet = new Set(values); + inst._zod.values = valuesSet; + inst._zod.pattern = new RegExp(`^(${values.filter((k3) => propertyKeyTypes.has(typeof k3)).map((o3) => typeof o3 === "string" ? escapeRegex(o3) : o3.toString()).join("|")})$`); + inst._zod.parse = (payload, _ctx) => { + const input = payload.value; + if (valuesSet.has(input)) { + return payload; + } + payload.issues.push({ + code: "invalid_value", + values, + input, + inst + }); + return payload; + }; +}); +var $ZodLiteral = /* @__PURE__ */ $constructor("$ZodLiteral", (inst, def) => { + $ZodType.init(inst, def); + if (def.values.length === 0) { + throw new Error("Cannot create literal schema with no valid values"); + } + const values = new Set(def.values); + inst._zod.values = values; + inst._zod.pattern = new RegExp(`^(${def.values.map((o3) => typeof o3 === "string" ? escapeRegex(o3) : o3 ? escapeRegex(o3.toString()) : String(o3)).join("|")})$`); + inst._zod.parse = (payload, _ctx) => { + const input = payload.value; + if (values.has(input)) { + return payload; + } + payload.issues.push({ + code: "invalid_value", + values: def.values, + input, + inst + }); + return payload; + }; +}); +var $ZodFile = /* @__PURE__ */ $constructor("$ZodFile", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, _ctx) => { + const input = payload.value; + if (input instanceof File) + return payload; + payload.issues.push({ + expected: "file", + code: "invalid_type", + input, + inst + }); + return payload; + }; +}); +var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, ctx) => { + if (ctx.direction === "backward") { + throw new $ZodEncodeError(inst.constructor.name); + } + const _out = def.transform(payload.value, payload); + if (ctx.async) { + const output = _out instanceof Promise ? _out : Promise.resolve(_out); + return output.then((output2) => { + payload.value = output2; + return payload; + }); + } + if (_out instanceof Promise) { + throw new $ZodAsyncError(); + } + payload.value = _out; + return payload; + }; +}); +function handleOptionalResult(result, input) { + if (result.issues.length && input === void 0) { + return { issues: [], value: void 0 }; + } + return result; +} +var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.optin = "optional"; + inst._zod.optout = "optional"; + defineLazy(inst._zod, "values", () => { + return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, void 0]) : void 0; + }); + defineLazy(inst._zod, "pattern", () => { + const pattern = def.innerType._zod.pattern; + return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0; + }); + inst._zod.parse = (payload, ctx) => { + if (def.innerType._zod.optin === "optional") { + const result = def.innerType._zod.run(payload, ctx); + if (result instanceof Promise) + return result.then((r3) => handleOptionalResult(r3, payload.value)); + return handleOptionalResult(result, payload.value); + } + if (payload.value === void 0) { + return payload; + } + return def.innerType._zod.run(payload, ctx); + }; +}); +var $ZodExactOptional = /* @__PURE__ */ $constructor("$ZodExactOptional", (inst, def) => { + $ZodOptional.init(inst, def); + defineLazy(inst._zod, "values", () => def.innerType._zod.values); + defineLazy(inst._zod, "pattern", () => def.innerType._zod.pattern); + inst._zod.parse = (payload, ctx) => { + return def.innerType._zod.run(payload, ctx); + }; +}); +var $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "optin", () => def.innerType._zod.optin); + defineLazy(inst._zod, "optout", () => def.innerType._zod.optout); + defineLazy(inst._zod, "pattern", () => { + const pattern = def.innerType._zod.pattern; + return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0; + }); + defineLazy(inst._zod, "values", () => { + return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, null]) : void 0; + }); + inst._zod.parse = (payload, ctx) => { + if (payload.value === null) + return payload; + return def.innerType._zod.run(payload, ctx); + }; +}); +var $ZodDefault = /* @__PURE__ */ $constructor("$ZodDefault", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.optin = "optional"; + defineLazy(inst._zod, "values", () => def.innerType._zod.values); + inst._zod.parse = (payload, ctx) => { + if (ctx.direction === "backward") { + return def.innerType._zod.run(payload, ctx); + } + if (payload.value === void 0) { + payload.value = def.defaultValue; + return payload; + } + const result = def.innerType._zod.run(payload, ctx); + if (result instanceof Promise) { + return result.then((result2) => handleDefaultResult(result2, def)); + } + return handleDefaultResult(result, def); + }; +}); +function handleDefaultResult(payload, def) { + if (payload.value === void 0) { + payload.value = def.defaultValue; + } + return payload; +} +var $ZodPrefault = /* @__PURE__ */ $constructor("$ZodPrefault", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.optin = "optional"; + defineLazy(inst._zod, "values", () => def.innerType._zod.values); + inst._zod.parse = (payload, ctx) => { + if (ctx.direction === "backward") { + return def.innerType._zod.run(payload, ctx); + } + if (payload.value === void 0) { + payload.value = def.defaultValue; + } + return def.innerType._zod.run(payload, ctx); + }; +}); +var $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "values", () => { + const v2 = def.innerType._zod.values; + return v2 ? new Set([...v2].filter((x) => x !== void 0)) : void 0; + }); + inst._zod.parse = (payload, ctx) => { + const result = def.innerType._zod.run(payload, ctx); + if (result instanceof Promise) { + return result.then((result2) => handleNonOptionalResult(result2, inst)); + } + return handleNonOptionalResult(result, inst); + }; +}); +function handleNonOptionalResult(payload, inst) { + if (!payload.issues.length && payload.value === void 0) { + payload.issues.push({ + code: "invalid_type", + expected: "nonoptional", + input: payload.value, + inst + }); + } + return payload; +} +var $ZodSuccess = /* @__PURE__ */ $constructor("$ZodSuccess", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, ctx) => { + if (ctx.direction === "backward") { + throw new $ZodEncodeError("ZodSuccess"); + } + const result = def.innerType._zod.run(payload, ctx); + if (result instanceof Promise) { + return result.then((result2) => { + payload.value = result2.issues.length === 0; + return payload; + }); + } + payload.value = result.issues.length === 0; + return payload; + }; +}); +var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "optin", () => def.innerType._zod.optin); + defineLazy(inst._zod, "optout", () => def.innerType._zod.optout); + defineLazy(inst._zod, "values", () => def.innerType._zod.values); + inst._zod.parse = (payload, ctx) => { + if (ctx.direction === "backward") { + return def.innerType._zod.run(payload, ctx); + } + const result = def.innerType._zod.run(payload, ctx); + if (result instanceof Promise) { + return result.then((result2) => { + payload.value = result2.value; + if (result2.issues.length) { + payload.value = def.catchValue({ + ...payload, + error: { + issues: result2.issues.map((iss) => finalizeIssue(iss, ctx, config())) + }, + input: payload.value + }); + payload.issues = []; + } + return payload; + }); + } + payload.value = result.value; + if (result.issues.length) { + payload.value = def.catchValue({ + ...payload, + error: { + issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config())) + }, + input: payload.value + }); + payload.issues = []; + } + return payload; + }; +}); +var $ZodNaN = /* @__PURE__ */ $constructor("$ZodNaN", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, _ctx) => { + if (typeof payload.value !== "number" || !Number.isNaN(payload.value)) { + payload.issues.push({ + input: payload.value, + inst, + expected: "nan", + code: "invalid_type" + }); + return payload; + } + return payload; + }; +}); +var $ZodPipe = /* @__PURE__ */ $constructor("$ZodPipe", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "values", () => def.in._zod.values); + defineLazy(inst._zod, "optin", () => def.in._zod.optin); + defineLazy(inst._zod, "optout", () => def.out._zod.optout); + defineLazy(inst._zod, "propValues", () => def.in._zod.propValues); + inst._zod.parse = (payload, ctx) => { + if (ctx.direction === "backward") { + const right = def.out._zod.run(payload, ctx); + if (right instanceof Promise) { + return right.then((right2) => handlePipeResult(right2, def.in, ctx)); + } + return handlePipeResult(right, def.in, ctx); + } + const left = def.in._zod.run(payload, ctx); + if (left instanceof Promise) { + return left.then((left2) => handlePipeResult(left2, def.out, ctx)); + } + return handlePipeResult(left, def.out, ctx); + }; +}); +function handlePipeResult(left, next, ctx) { + if (left.issues.length) { + left.aborted = true; + return left; + } + return next._zod.run({ value: left.value, issues: left.issues }, ctx); +} +var $ZodCodec = /* @__PURE__ */ $constructor("$ZodCodec", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "values", () => def.in._zod.values); + defineLazy(inst._zod, "optin", () => def.in._zod.optin); + defineLazy(inst._zod, "optout", () => def.out._zod.optout); + defineLazy(inst._zod, "propValues", () => def.in._zod.propValues); + inst._zod.parse = (payload, ctx) => { + const direction = ctx.direction || "forward"; + if (direction === "forward") { + const left = def.in._zod.run(payload, ctx); + if (left instanceof Promise) { + return left.then((left2) => handleCodecAResult(left2, def, ctx)); + } + return handleCodecAResult(left, def, ctx); + } else { + const right = def.out._zod.run(payload, ctx); + if (right instanceof Promise) { + return right.then((right2) => handleCodecAResult(right2, def, ctx)); + } + return handleCodecAResult(right, def, ctx); + } + }; +}); +function handleCodecAResult(result, def, ctx) { + if (result.issues.length) { + result.aborted = true; + return result; + } + const direction = ctx.direction || "forward"; + if (direction === "forward") { + const transformed = def.transform(result.value, result); + if (transformed instanceof Promise) { + return transformed.then((value) => handleCodecTxResult(result, value, def.out, ctx)); + } + return handleCodecTxResult(result, transformed, def.out, ctx); + } else { + const transformed = def.reverseTransform(result.value, result); + if (transformed instanceof Promise) { + return transformed.then((value) => handleCodecTxResult(result, value, def.in, ctx)); + } + return handleCodecTxResult(result, transformed, def.in, ctx); + } +} +function handleCodecTxResult(left, value, nextSchema, ctx) { + if (left.issues.length) { + left.aborted = true; + return left; + } + return nextSchema._zod.run({ value, issues: left.issues }, ctx); +} +var $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues); + defineLazy(inst._zod, "values", () => def.innerType._zod.values); + defineLazy(inst._zod, "optin", () => { + var _a3, _b2; + return (_b2 = (_a3 = def.innerType) == null ? void 0 : _a3._zod) == null ? void 0 : _b2.optin; + }); + defineLazy(inst._zod, "optout", () => { + var _a3, _b2; + return (_b2 = (_a3 = def.innerType) == null ? void 0 : _a3._zod) == null ? void 0 : _b2.optout; + }); + inst._zod.parse = (payload, ctx) => { + if (ctx.direction === "backward") { + return def.innerType._zod.run(payload, ctx); + } + const result = def.innerType._zod.run(payload, ctx); + if (result instanceof Promise) { + return result.then(handleReadonlyResult); + } + return handleReadonlyResult(result); + }; +}); +function handleReadonlyResult(payload) { + payload.value = Object.freeze(payload.value); + return payload; +} +var $ZodTemplateLiteral = /* @__PURE__ */ $constructor("$ZodTemplateLiteral", (inst, def) => { + $ZodType.init(inst, def); + const regexParts = []; + for (const part of def.parts) { + if (typeof part === "object" && part !== null) { + if (!part._zod.pattern) { + throw new Error(`Invalid template literal part, no pattern found: ${[...part._zod.traits].shift()}`); + } + const source = part._zod.pattern instanceof RegExp ? part._zod.pattern.source : part._zod.pattern; + if (!source) + throw new Error(`Invalid template literal part: ${part._zod.traits}`); + const start = source.startsWith("^") ? 1 : 0; + const end = source.endsWith("$") ? source.length - 1 : source.length; + regexParts.push(source.slice(start, end)); + } else if (part === null || primitiveTypes.has(typeof part)) { + regexParts.push(escapeRegex(`${part}`)); + } else { + throw new Error(`Invalid template literal part: ${part}`); + } + } + inst._zod.pattern = new RegExp(`^${regexParts.join("")}$`); + inst._zod.parse = (payload, _ctx) => { + var _a3; + if (typeof payload.value !== "string") { + payload.issues.push({ + input: payload.value, + inst, + expected: "string", + code: "invalid_type" + }); + return payload; + } + inst._zod.pattern.lastIndex = 0; + if (!inst._zod.pattern.test(payload.value)) { + payload.issues.push({ + input: payload.value, + inst, + code: "invalid_format", + format: (_a3 = def.format) != null ? _a3 : "template_literal", + pattern: inst._zod.pattern.source + }); + return payload; + } + return payload; + }; +}); +var $ZodFunction = /* @__PURE__ */ $constructor("$ZodFunction", (inst, def) => { + $ZodType.init(inst, def); + inst._def = def; + inst._zod.def = def; + inst.implement = (func) => { + if (typeof func !== "function") { + throw new Error("implement() must be called with a function"); + } + return function(...args) { + const parsedArgs = inst._def.input ? parse(inst._def.input, args) : args; + const result = Reflect.apply(func, this, parsedArgs); + if (inst._def.output) { + return parse(inst._def.output, result); + } + return result; + }; + }; + inst.implementAsync = (func) => { + if (typeof func !== "function") { + throw new Error("implementAsync() must be called with a function"); + } + return async function(...args) { + const parsedArgs = inst._def.input ? await parseAsync(inst._def.input, args) : args; + const result = await Reflect.apply(func, this, parsedArgs); + if (inst._def.output) { + return await parseAsync(inst._def.output, result); + } + return result; + }; + }; + inst._zod.parse = (payload, _ctx) => { + if (typeof payload.value !== "function") { + payload.issues.push({ + code: "invalid_type", + expected: "function", + input: payload.value, + inst + }); + return payload; + } + const hasPromiseOutput = inst._def.output && inst._def.output._zod.def.type === "promise"; + if (hasPromiseOutput) { + payload.value = inst.implementAsync(payload.value); + } else { + payload.value = inst.implement(payload.value); + } + return payload; + }; + inst.input = (...args) => { + const F3 = inst.constructor; + if (Array.isArray(args[0])) { + return new F3({ + type: "function", + input: new $ZodTuple({ + type: "tuple", + items: args[0], + rest: args[1] + }), + output: inst._def.output + }); + } + return new F3({ + type: "function", + input: args[0], + output: inst._def.output + }); + }; + inst.output = (output) => { + const F3 = inst.constructor; + return new F3({ + type: "function", + input: inst._def.input, + output + }); + }; + return inst; +}); +var $ZodPromise = /* @__PURE__ */ $constructor("$ZodPromise", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, ctx) => { + return Promise.resolve(payload.value).then((inner) => def.innerType._zod.run({ value: inner, issues: [] }, ctx)); + }; +}); +var $ZodLazy = /* @__PURE__ */ $constructor("$ZodLazy", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "innerType", () => def.getter()); + defineLazy(inst._zod, "pattern", () => { + var _a3, _b2; + return (_b2 = (_a3 = inst._zod.innerType) == null ? void 0 : _a3._zod) == null ? void 0 : _b2.pattern; + }); + defineLazy(inst._zod, "propValues", () => { + var _a3, _b2; + return (_b2 = (_a3 = inst._zod.innerType) == null ? void 0 : _a3._zod) == null ? void 0 : _b2.propValues; + }); + defineLazy(inst._zod, "optin", () => { + var _a3, _b2, _c; + return (_c = (_b2 = (_a3 = inst._zod.innerType) == null ? void 0 : _a3._zod) == null ? void 0 : _b2.optin) != null ? _c : void 0; + }); + defineLazy(inst._zod, "optout", () => { + var _a3, _b2, _c; + return (_c = (_b2 = (_a3 = inst._zod.innerType) == null ? void 0 : _a3._zod) == null ? void 0 : _b2.optout) != null ? _c : void 0; + }); + inst._zod.parse = (payload, ctx) => { + const inner = inst._zod.innerType; + return inner._zod.run(payload, ctx); + }; +}); +var $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => { + $ZodCheck.init(inst, def); + $ZodType.init(inst, def); + inst._zod.parse = (payload, _3) => { + return payload; + }; + inst._zod.check = (payload) => { + const input = payload.value; + const r3 = def.fn(input); + if (r3 instanceof Promise) { + return r3.then((r4) => handleRefineResult(r4, payload, input, inst)); + } + handleRefineResult(r3, payload, input, inst); + return; + }; +}); +function handleRefineResult(result, payload, input, inst) { + var _a3; + if (!result) { + const _iss = { + code: "custom", + input, + inst, + // incorporates params.error into issue reporting + path: [...(_a3 = inst._zod.def.path) != null ? _a3 : []], + // incorporates params.error into issue reporting + continue: !inst._zod.def.abort + // params: inst._zod.def.params, + }; + if (inst._zod.def.params) + _iss.params = inst._zod.def.params; + payload.issues.push(issue(_iss)); + } +} + +// node_modules/zod/v4/locales/index.js +var locales_exports = {}; +__export(locales_exports, { + ar: () => ar_default, + az: () => az_default, + be: () => be_default, + bg: () => bg_default, + ca: () => ca_default, + cs: () => cs_default, + da: () => da_default, + de: () => de_default2, + en: () => en_default3, + eo: () => eo_default, + es: () => es_default2, + fa: () => fa_default, + fi: () => fi_default, + fr: () => fr_default2, + frCA: () => fr_CA_default, + he: () => he_default, + hu: () => hu_default, + hy: () => hy_default, + id: () => id_default, + is: () => is_default, + it: () => it_default, + ja: () => ja_default2, + ka: () => ka_default, + kh: () => kh_default, + km: () => km_default, + ko: () => ko_default2, + lt: () => lt_default, + mk: () => mk_default, + ms: () => ms_default, + nl: () => nl_default, + no: () => no_default, + ota: () => ota_default, + pl: () => pl_default, + ps: () => ps_default, + pt: () => pt_default2, + ru: () => ru_default2, + sl: () => sl_default, + sv: () => sv_default, + ta: () => ta_default, + th: () => th_default, + tr: () => tr_default, + ua: () => ua_default, + uk: () => uk_default, + ur: () => ur_default, + uz: () => uz_default, + vi: () => vi_default, + yo: () => yo_default, + zhCN: () => zh_CN_default2, + zhTW: () => zh_TW_default2 +}); + +// node_modules/zod/v4/locales/ar.js +var error = () => { + const Sizable = { + string: { unit: "\u062D\u0631\u0641", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" }, + file: { unit: "\u0628\u0627\u064A\u062A", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" }, + array: { unit: "\u0639\u0646\u0635\u0631", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" }, + set: { unit: "\u0639\u0646\u0635\u0631", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "\u0645\u062F\u062E\u0644", + email: "\u0628\u0631\u064A\u062F \u0625\u0644\u0643\u062A\u0631\u0648\u0646\u064A", + url: "\u0631\u0627\u0628\u0637", + emoji: "\u0625\u064A\u0645\u0648\u062C\u064A", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "\u062A\u0627\u0631\u064A\u062E \u0648\u0648\u0642\u062A \u0628\u0645\u0639\u064A\u0627\u0631 ISO", + date: "\u062A\u0627\u0631\u064A\u062E \u0628\u0645\u0639\u064A\u0627\u0631 ISO", + time: "\u0648\u0642\u062A \u0628\u0645\u0639\u064A\u0627\u0631 ISO", + duration: "\u0645\u062F\u0629 \u0628\u0645\u0639\u064A\u0627\u0631 ISO", + ipv4: "\u0639\u0646\u0648\u0627\u0646 IPv4", + ipv6: "\u0639\u0646\u0648\u0627\u0646 IPv6", + cidrv4: "\u0645\u062F\u0649 \u0639\u0646\u0627\u0648\u064A\u0646 \u0628\u0635\u064A\u063A\u0629 IPv4", + cidrv6: "\u0645\u062F\u0649 \u0639\u0646\u0627\u0648\u064A\u0646 \u0628\u0635\u064A\u063A\u0629 IPv6", + base64: "\u0646\u064E\u0635 \u0628\u062A\u0631\u0645\u064A\u0632 base64-encoded", + base64url: "\u0646\u064E\u0635 \u0628\u062A\u0631\u0645\u064A\u0632 base64url-encoded", + json_string: "\u0646\u064E\u0635 \u0639\u0644\u0649 \u0647\u064A\u0626\u0629 JSON", + e164: "\u0631\u0642\u0645 \u0647\u0627\u062A\u0641 \u0628\u0645\u0639\u064A\u0627\u0631 E.164", + jwt: "JWT", + template_literal: "\u0645\u062F\u062E\u0644" + }; + const TypeDictionary = { + nan: "NaN" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `\u0645\u062F\u062E\u0644\u0627\u062A \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644\u0629: \u064A\u0641\u062A\u0631\u0636 \u0625\u062F\u062E\u0627\u0644 instanceof ${issue2.expected}\u060C \u0648\u0644\u0643\u0646 \u062A\u0645 \u0625\u062F\u062E\u0627\u0644 ${received}`; + } + return `\u0645\u062F\u062E\u0644\u0627\u062A \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644\u0629: \u064A\u0641\u062A\u0631\u0636 \u0625\u062F\u062E\u0627\u0644 ${expected}\u060C \u0648\u0644\u0643\u0646 \u062A\u0645 \u0625\u062F\u062E\u0627\u0644 ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `\u0645\u062F\u062E\u0644\u0627\u062A \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644\u0629: \u064A\u0641\u062A\u0631\u0636 \u0625\u062F\u062E\u0627\u0644 ${stringifyPrimitive(issue2.values[0])}`; + return `\u0627\u062E\u062A\u064A\u0627\u0631 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062A\u0648\u0642\u0639 \u0627\u0646\u062A\u0642\u0627\u0621 \u0623\u062D\u062F \u0647\u0630\u0647 \u0627\u0644\u062E\u064A\u0627\u0631\u0627\u062A: ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return ` \u0623\u0643\u0628\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0623\u0646 \u062A\u0643\u0648\u0646 ${(_c = issue2.origin) != null ? _c : "\u0627\u0644\u0642\u064A\u0645\u0629"} ${adj} ${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\u0639\u0646\u0635\u0631"}`; + return `\u0623\u0643\u0628\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0623\u0646 \u062A\u0643\u0648\u0646 ${(_e = issue2.origin) != null ? _e : "\u0627\u0644\u0642\u064A\u0645\u0629"} ${adj} ${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `\u0623\u0635\u063A\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0644\u0640 ${issue2.origin} \u0623\u0646 \u064A\u0643\u0648\u0646 ${adj} ${issue2.minimum.toString()} ${sizing.unit}`; + } + return `\u0623\u0635\u063A\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0644\u0640 ${issue2.origin} \u0623\u0646 \u064A\u0643\u0648\u0646 ${adj} ${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0628\u062F\u0623 \u0628\u0640 "${issue2.prefix}"`; + if (_issue.format === "ends_with") + return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0646\u062A\u0647\u064A \u0628\u0640 "${_issue.suffix}"`; + if (_issue.format === "includes") + return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u062A\u0636\u0645\u0651\u064E\u0646 "${_issue.includes}"`; + if (_issue.format === "regex") + return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0637\u0627\u0628\u0642 \u0627\u0644\u0646\u0645\u0637 ${_issue.pattern}`; + return `${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format} \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644`; + } + case "not_multiple_of": + return `\u0631\u0642\u0645 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0643\u0648\u0646 \u0645\u0646 \u0645\u0636\u0627\u0639\u0641\u0627\u062A ${issue2.divisor}`; + case "unrecognized_keys": + return `\u0645\u0639\u0631\u0641${issue2.keys.length > 1 ? "\u0627\u062A" : ""} \u063A\u0631\u064A\u0628${issue2.keys.length > 1 ? "\u0629" : ""}: ${joinValues(issue2.keys, "\u060C ")}`; + case "invalid_key": + return `\u0645\u0639\u0631\u0641 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644 \u0641\u064A ${issue2.origin}`; + case "invalid_union": + return "\u0645\u062F\u062E\u0644 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644"; + case "invalid_element": + return `\u0645\u062F\u062E\u0644 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644 \u0641\u064A ${issue2.origin}`; + default: + return "\u0645\u062F\u062E\u0644 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644"; + } + }; +}; +function ar_default() { + return { + localeError: error() + }; +} + +// node_modules/zod/v4/locales/az.js +var error2 = () => { + const Sizable = { + string: { unit: "simvol", verb: "olmal\u0131d\u0131r" }, + file: { unit: "bayt", verb: "olmal\u0131d\u0131r" }, + array: { unit: "element", verb: "olmal\u0131d\u0131r" }, + set: { unit: "element", verb: "olmal\u0131d\u0131r" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "input", + email: "email address", + url: "URL", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO datetime", + date: "ISO date", + time: "ISO time", + duration: "ISO duration", + ipv4: "IPv4 address", + ipv6: "IPv6 address", + cidrv4: "IPv4 range", + cidrv6: "IPv6 range", + base64: "base64-encoded string", + base64url: "base64url-encoded string", + json_string: "JSON string", + e164: "E.164 number", + jwt: "JWT", + template_literal: "input" + }; + const TypeDictionary = { + nan: "NaN" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `Yanl\u0131\u015F d\u0259y\u0259r: g\xF6zl\u0259nil\u0259n instanceof ${issue2.expected}, daxil olan ${received}`; + } + return `Yanl\u0131\u015F d\u0259y\u0259r: g\xF6zl\u0259nil\u0259n ${expected}, daxil olan ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `Yanl\u0131\u015F d\u0259y\u0259r: g\xF6zl\u0259nil\u0259n ${stringifyPrimitive(issue2.values[0])}`; + return `Yanl\u0131\u015F se\xE7im: a\u015Fa\u011F\u0131dak\u0131lardan biri olmal\u0131d\u0131r: ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `\xC7ox b\xF6y\xFCk: g\xF6zl\u0259nil\u0259n ${(_c = issue2.origin) != null ? _c : "d\u0259y\u0259r"} ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "element"}`; + return `\xC7ox b\xF6y\xFCk: g\xF6zl\u0259nil\u0259n ${(_e = issue2.origin) != null ? _e : "d\u0259y\u0259r"} ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `\xC7ox ki\xE7ik: g\xF6zl\u0259nil\u0259n ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit}`; + return `\xC7ox ki\xE7ik: g\xF6zl\u0259nil\u0259n ${issue2.origin} ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `Yanl\u0131\u015F m\u0259tn: "${_issue.prefix}" il\u0259 ba\u015Flamal\u0131d\u0131r`; + if (_issue.format === "ends_with") + return `Yanl\u0131\u015F m\u0259tn: "${_issue.suffix}" il\u0259 bitm\u0259lidir`; + if (_issue.format === "includes") + return `Yanl\u0131\u015F m\u0259tn: "${_issue.includes}" daxil olmal\u0131d\u0131r`; + if (_issue.format === "regex") + return `Yanl\u0131\u015F m\u0259tn: ${_issue.pattern} \u015Fablonuna uy\u011Fun olmal\u0131d\u0131r`; + return `Yanl\u0131\u015F ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format}`; + } + case "not_multiple_of": + return `Yanl\u0131\u015F \u0259d\u0259d: ${issue2.divisor} il\u0259 b\xF6l\xFCn\u0259 bil\u0259n olmal\u0131d\u0131r`; + case "unrecognized_keys": + return `Tan\u0131nmayan a\xE7ar${issue2.keys.length > 1 ? "lar" : ""}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `${issue2.origin} daxilind\u0259 yanl\u0131\u015F a\xE7ar`; + case "invalid_union": + return "Yanl\u0131\u015F d\u0259y\u0259r"; + case "invalid_element": + return `${issue2.origin} daxilind\u0259 yanl\u0131\u015F d\u0259y\u0259r`; + default: + return `Yanl\u0131\u015F d\u0259y\u0259r`; + } + }; +}; +function az_default() { + return { + localeError: error2() + }; +} + +// node_modules/zod/v4/locales/be.js +function getBelarusianPlural(count, one, few, many) { + const absCount = Math.abs(count); + const lastDigit = absCount % 10; + const lastTwoDigits = absCount % 100; + if (lastTwoDigits >= 11 && lastTwoDigits <= 19) { + return many; + } + if (lastDigit === 1) { + return one; + } + if (lastDigit >= 2 && lastDigit <= 4) { + return few; + } + return many; +} +var error3 = () => { + const Sizable = { + string: { + unit: { + one: "\u0441\u0456\u043C\u0432\u0430\u043B", + few: "\u0441\u0456\u043C\u0432\u0430\u043B\u044B", + many: "\u0441\u0456\u043C\u0432\u0430\u043B\u0430\u045E" + }, + verb: "\u043C\u0435\u0446\u044C" + }, + array: { + unit: { + one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442", + few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u044B", + many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430\u045E" + }, + verb: "\u043C\u0435\u0446\u044C" + }, + set: { + unit: { + one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442", + few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u044B", + many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430\u045E" + }, + verb: "\u043C\u0435\u0446\u044C" + }, + file: { + unit: { + one: "\u0431\u0430\u0439\u0442", + few: "\u0431\u0430\u0439\u0442\u044B", + many: "\u0431\u0430\u0439\u0442\u0430\u045E" + }, + verb: "\u043C\u0435\u0446\u044C" + } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "\u0443\u0432\u043E\u0434", + email: "email \u0430\u0434\u0440\u0430\u0441", + url: "URL", + emoji: "\u044D\u043C\u043E\u0434\u0437\u0456", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO \u0434\u0430\u0442\u0430 \u0456 \u0447\u0430\u0441", + date: "ISO \u0434\u0430\u0442\u0430", + time: "ISO \u0447\u0430\u0441", + duration: "ISO \u043F\u0440\u0430\u0446\u044F\u0433\u043B\u0430\u0441\u0446\u044C", + ipv4: "IPv4 \u0430\u0434\u0440\u0430\u0441", + ipv6: "IPv6 \u0430\u0434\u0440\u0430\u0441", + cidrv4: "IPv4 \u0434\u044B\u044F\u043F\u0430\u0437\u043E\u043D", + cidrv6: "IPv6 \u0434\u044B\u044F\u043F\u0430\u0437\u043E\u043D", + base64: "\u0440\u0430\u0434\u043E\u043A \u0443 \u0444\u0430\u0440\u043C\u0430\u0446\u0435 base64", + base64url: "\u0440\u0430\u0434\u043E\u043A \u0443 \u0444\u0430\u0440\u043C\u0430\u0446\u0435 base64url", + json_string: "JSON \u0440\u0430\u0434\u043E\u043A", + e164: "\u043D\u0443\u043C\u0430\u0440 E.164", + jwt: "JWT", + template_literal: "\u0443\u0432\u043E\u0434" + }; + const TypeDictionary = { + nan: "NaN", + number: "\u043B\u0456\u043A", + array: "\u043C\u0430\u0441\u0456\u045E" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434: \u0447\u0430\u043A\u0430\u045E\u0441\u044F instanceof ${issue2.expected}, \u0430\u0442\u0440\u044B\u043C\u0430\u043D\u0430 ${received}`; + } + return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434: \u0447\u0430\u043A\u0430\u045E\u0441\u044F ${expected}, \u0430\u0442\u0440\u044B\u043C\u0430\u043D\u0430 ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F ${stringifyPrimitive(issue2.values[0])}`; + return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0432\u0430\u0440\u044B\u044F\u043D\u0442: \u0447\u0430\u043A\u0430\u045E\u0441\u044F \u0430\u0434\u0437\u0456\u043D \u0437 ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) { + const maxValue = Number(issue2.maximum); + const unit = getBelarusianPlural(maxValue, sizing.unit.one, sizing.unit.few, sizing.unit.many); + return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u0432\u044F\u043B\u0456\u043A\u0456: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${(_c = issue2.origin) != null ? _c : "\u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435"} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 ${sizing.verb} ${adj}${issue2.maximum.toString()} ${unit}`; + } + return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u0432\u044F\u043B\u0456\u043A\u0456: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${(_d = issue2.origin) != null ? _d : "\u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435"} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 \u0431\u044B\u0446\u044C ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + const minValue = Number(issue2.minimum); + const unit = getBelarusianPlural(minValue, sizing.unit.one, sizing.unit.few, sizing.unit.many); + return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u043C\u0430\u043B\u044B: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue2.origin} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 ${sizing.verb} ${adj}${issue2.minimum.toString()} ${unit}`; + } + return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u043C\u0430\u043B\u044B: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue2.origin} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 \u0431\u044B\u0446\u044C ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u043F\u0430\u0447\u044B\u043D\u0430\u0446\u0446\u0430 \u0437 "${_issue.prefix}"`; + if (_issue.format === "ends_with") + return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0437\u0430\u043A\u0430\u043D\u0447\u0432\u0430\u0446\u0446\u0430 \u043D\u0430 "${_issue.suffix}"`; + if (_issue.format === "includes") + return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0437\u043C\u044F\u0448\u0447\u0430\u0446\u044C "${_issue.includes}"`; + if (_issue.format === "regex") + return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0430\u0434\u043F\u0430\u0432\u044F\u0434\u0430\u0446\u044C \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${_issue.pattern}`; + return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B ${(_e = FormatDictionary[_issue.format]) != null ? _e : issue2.format}`; + } + case "not_multiple_of": + return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u043B\u0456\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0431\u044B\u0446\u044C \u043A\u0440\u0430\u0442\u043D\u044B\u043C ${issue2.divisor}`; + case "unrecognized_keys": + return `\u041D\u0435\u0440\u0430\u0441\u043F\u0430\u0437\u043D\u0430\u043D\u044B ${issue2.keys.length > 1 ? "\u043A\u043B\u044E\u0447\u044B" : "\u043A\u043B\u044E\u0447"}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u043A\u043B\u044E\u0447 \u0443 ${issue2.origin}`; + case "invalid_union": + return "\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434"; + case "invalid_element": + return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u0430\u0435 \u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435 \u045E ${issue2.origin}`; + default: + return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434`; + } + }; +}; +function be_default() { + return { + localeError: error3() + }; +} + +// node_modules/zod/v4/locales/bg.js +var error4 = () => { + const Sizable = { + string: { unit: "\u0441\u0438\u043C\u0432\u043E\u043B\u0430", verb: "\u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430" }, + file: { unit: "\u0431\u0430\u0439\u0442\u0430", verb: "\u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430" }, + array: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0430", verb: "\u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430" }, + set: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0430", verb: "\u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "\u0432\u0445\u043E\u0434", + email: "\u0438\u043C\u0435\u0439\u043B \u0430\u0434\u0440\u0435\u0441", + url: "URL", + emoji: "\u0435\u043C\u043E\u0434\u0436\u0438", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO \u0432\u0440\u0435\u043C\u0435", + date: "ISO \u0434\u0430\u0442\u0430", + time: "ISO \u0432\u0440\u0435\u043C\u0435", + duration: "ISO \u043F\u0440\u043E\u0434\u044A\u043B\u0436\u0438\u0442\u0435\u043B\u043D\u043E\u0441\u0442", + ipv4: "IPv4 \u0430\u0434\u0440\u0435\u0441", + ipv6: "IPv6 \u0430\u0434\u0440\u0435\u0441", + cidrv4: "IPv4 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D", + cidrv6: "IPv6 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D", + base64: "base64-\u043A\u043E\u0434\u0438\u0440\u0430\u043D \u043D\u0438\u0437", + base64url: "base64url-\u043A\u043E\u0434\u0438\u0440\u0430\u043D \u043D\u0438\u0437", + json_string: "JSON \u043D\u0438\u0437", + e164: "E.164 \u043D\u043E\u043C\u0435\u0440", + jwt: "JWT", + template_literal: "\u0432\u0445\u043E\u0434" + }; + const TypeDictionary = { + nan: "NaN", + number: "\u0447\u0438\u0441\u043B\u043E", + array: "\u043C\u0430\u0441\u0438\u0432" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434: \u043E\u0447\u0430\u043A\u0432\u0430\u043D instanceof ${issue2.expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D ${received}`; + } + return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434: \u043E\u0447\u0430\u043A\u0432\u0430\u043D ${expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434: \u043E\u0447\u0430\u043A\u0432\u0430\u043D ${stringifyPrimitive(issue2.values[0])}`; + return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430 \u043E\u043F\u0446\u0438\u044F: \u043E\u0447\u0430\u043A\u0432\u0430\u043D\u043E \u0435\u0434\u043D\u043E \u043E\u0442 ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `\u0422\u0432\u044A\u0440\u0434\u0435 \u0433\u043E\u043B\u044F\u043C\u043E: \u043E\u0447\u0430\u043A\u0432\u0430 \u0441\u0435 ${(_c = issue2.origin) != null ? _c : "\u0441\u0442\u043E\u0439\u043D\u043E\u0441\u0442"} \u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430 ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0430"}`; + return `\u0422\u0432\u044A\u0440\u0434\u0435 \u0433\u043E\u043B\u044F\u043C\u043E: \u043E\u0447\u0430\u043A\u0432\u0430 \u0441\u0435 ${(_e = issue2.origin) != null ? _e : "\u0441\u0442\u043E\u0439\u043D\u043E\u0441\u0442"} \u0434\u0430 \u0431\u044A\u0434\u0435 ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `\u0422\u0432\u044A\u0440\u0434\u0435 \u043C\u0430\u043B\u043A\u043E: \u043E\u0447\u0430\u043A\u0432\u0430 \u0441\u0435 ${issue2.origin} \u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430 ${adj}${issue2.minimum.toString()} ${sizing.unit}`; + } + return `\u0422\u0432\u044A\u0440\u0434\u0435 \u043C\u0430\u043B\u043A\u043E: \u043E\u0447\u0430\u043A\u0432\u0430 \u0441\u0435 ${issue2.origin} \u0434\u0430 \u0431\u044A\u0434\u0435 ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") { + return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043D\u0438\u0437: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0437\u0430\u043F\u043E\u0447\u0432\u0430 \u0441 "${_issue.prefix}"`; + } + if (_issue.format === "ends_with") + return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043D\u0438\u0437: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0437\u0430\u0432\u044A\u0440\u0448\u0432\u0430 \u0441 "${_issue.suffix}"`; + if (_issue.format === "includes") + return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043D\u0438\u0437: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0432\u043A\u043B\u044E\u0447\u0432\u0430 "${_issue.includes}"`; + if (_issue.format === "regex") + return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043D\u0438\u0437: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0441\u044A\u0432\u043F\u0430\u0434\u0430 \u0441 ${_issue.pattern}`; + let invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D"; + if (_issue.format === "emoji") + invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u043E"; + if (_issue.format === "datetime") + invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u043E"; + if (_issue.format === "date") + invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430"; + if (_issue.format === "time") + invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u043E"; + if (_issue.format === "duration") + invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430"; + return `${invalid_adj} ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format}`; + } + case "not_multiple_of": + return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u043E \u0447\u0438\u0441\u043B\u043E: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0431\u044A\u0434\u0435 \u043A\u0440\u0430\u0442\u043D\u043E \u043D\u0430 ${issue2.divisor}`; + case "unrecognized_keys": + return `\u041D\u0435\u0440\u0430\u0437\u043F\u043E\u0437\u043D\u0430\u0442${issue2.keys.length > 1 ? "\u0438" : ""} \u043A\u043B\u044E\u0447${issue2.keys.length > 1 ? "\u043E\u0432\u0435" : ""}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043A\u043B\u044E\u0447 \u0432 ${issue2.origin}`; + case "invalid_union": + return "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434"; + case "invalid_element": + return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430 \u0441\u0442\u043E\u0439\u043D\u043E\u0441\u0442 \u0432 ${issue2.origin}`; + default: + return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434`; + } + }; +}; +function bg_default() { + return { + localeError: error4() + }; +} + +// node_modules/zod/v4/locales/ca.js +var error5 = () => { + const Sizable = { + string: { unit: "car\xE0cters", verb: "contenir" }, + file: { unit: "bytes", verb: "contenir" }, + array: { unit: "elements", verb: "contenir" }, + set: { unit: "elements", verb: "contenir" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "entrada", + email: "adre\xE7a electr\xF2nica", + url: "URL", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "data i hora ISO", + date: "data ISO", + time: "hora ISO", + duration: "durada ISO", + ipv4: "adre\xE7a IPv4", + ipv6: "adre\xE7a IPv6", + cidrv4: "rang IPv4", + cidrv6: "rang IPv6", + base64: "cadena codificada en base64", + base64url: "cadena codificada en base64url", + json_string: "cadena JSON", + e164: "n\xFAmero E.164", + jwt: "JWT", + template_literal: "entrada" + }; + const TypeDictionary = { + nan: "NaN" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `Tipus inv\xE0lid: s'esperava instanceof ${issue2.expected}, s'ha rebut ${received}`; + } + return `Tipus inv\xE0lid: s'esperava ${expected}, s'ha rebut ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `Valor inv\xE0lid: s'esperava ${stringifyPrimitive(issue2.values[0])}`; + return `Opci\xF3 inv\xE0lida: s'esperava una de ${joinValues(issue2.values, " o ")}`; + case "too_big": { + const adj = issue2.inclusive ? "com a m\xE0xim" : "menys de"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `Massa gran: s'esperava que ${(_c = issue2.origin) != null ? _c : "el valor"} contingu\xE9s ${adj} ${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elements"}`; + return `Massa gran: s'esperava que ${(_e = issue2.origin) != null ? _e : "el valor"} fos ${adj} ${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? "com a m\xEDnim" : "m\xE9s de"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `Massa petit: s'esperava que ${issue2.origin} contingu\xE9s ${adj} ${issue2.minimum.toString()} ${sizing.unit}`; + } + return `Massa petit: s'esperava que ${issue2.origin} fos ${adj} ${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") { + return `Format inv\xE0lid: ha de comen\xE7ar amb "${_issue.prefix}"`; + } + if (_issue.format === "ends_with") + return `Format inv\xE0lid: ha d'acabar amb "${_issue.suffix}"`; + if (_issue.format === "includes") + return `Format inv\xE0lid: ha d'incloure "${_issue.includes}"`; + if (_issue.format === "regex") + return `Format inv\xE0lid: ha de coincidir amb el patr\xF3 ${_issue.pattern}`; + return `Format inv\xE0lid per a ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format}`; + } + case "not_multiple_of": + return `N\xFAmero inv\xE0lid: ha de ser m\xFAltiple de ${issue2.divisor}`; + case "unrecognized_keys": + return `Clau${issue2.keys.length > 1 ? "s" : ""} no reconeguda${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `Clau inv\xE0lida a ${issue2.origin}`; + case "invalid_union": + return "Entrada inv\xE0lida"; + // Could also be "Tipus d'unió invàlid" but "Entrada invàlida" is more general + case "invalid_element": + return `Element inv\xE0lid a ${issue2.origin}`; + default: + return `Entrada inv\xE0lida`; + } + }; +}; +function ca_default() { + return { + localeError: error5() + }; +} + +// node_modules/zod/v4/locales/cs.js +var error6 = () => { + const Sizable = { + string: { unit: "znak\u016F", verb: "m\xEDt" }, + file: { unit: "bajt\u016F", verb: "m\xEDt" }, + array: { unit: "prvk\u016F", verb: "m\xEDt" }, + set: { unit: "prvk\u016F", verb: "m\xEDt" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "regul\xE1rn\xED v\xFDraz", + email: "e-mailov\xE1 adresa", + url: "URL", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "datum a \u010Das ve form\xE1tu ISO", + date: "datum ve form\xE1tu ISO", + time: "\u010Das ve form\xE1tu ISO", + duration: "doba trv\xE1n\xED ISO", + ipv4: "IPv4 adresa", + ipv6: "IPv6 adresa", + cidrv4: "rozsah IPv4", + cidrv6: "rozsah IPv6", + base64: "\u0159et\u011Bzec zak\xF3dovan\xFD ve form\xE1tu base64", + base64url: "\u0159et\u011Bzec zak\xF3dovan\xFD ve form\xE1tu base64url", + json_string: "\u0159et\u011Bzec ve form\xE1tu JSON", + e164: "\u010D\xEDslo E.164", + jwt: "JWT", + template_literal: "vstup" + }; + const TypeDictionary = { + nan: "NaN", + number: "\u010D\xEDslo", + string: "\u0159et\u011Bzec", + function: "funkce", + array: "pole" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f, _g, _h, _i; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `Neplatn\xFD vstup: o\u010Dek\xE1v\xE1no instanceof ${issue2.expected}, obdr\u017Eeno ${received}`; + } + return `Neplatn\xFD vstup: o\u010Dek\xE1v\xE1no ${expected}, obdr\u017Eeno ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `Neplatn\xFD vstup: o\u010Dek\xE1v\xE1no ${stringifyPrimitive(issue2.values[0])}`; + return `Neplatn\xE1 mo\u017Enost: o\u010Dek\xE1v\xE1na jedna z hodnot ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `Hodnota je p\u0159\xEDli\u0161 velk\xE1: ${(_c = issue2.origin) != null ? _c : "hodnota"} mus\xED m\xEDt ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "prvk\u016F"}`; + } + return `Hodnota je p\u0159\xEDli\u0161 velk\xE1: ${(_e = issue2.origin) != null ? _e : "hodnota"} mus\xED b\xFDt ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `Hodnota je p\u0159\xEDli\u0161 mal\xE1: ${(_f = issue2.origin) != null ? _f : "hodnota"} mus\xED m\xEDt ${adj}${issue2.minimum.toString()} ${(_g = sizing.unit) != null ? _g : "prvk\u016F"}`; + } + return `Hodnota je p\u0159\xEDli\u0161 mal\xE1: ${(_h = issue2.origin) != null ? _h : "hodnota"} mus\xED b\xFDt ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `Neplatn\xFD \u0159et\u011Bzec: mus\xED za\u010D\xEDnat na "${_issue.prefix}"`; + if (_issue.format === "ends_with") + return `Neplatn\xFD \u0159et\u011Bzec: mus\xED kon\u010Dit na "${_issue.suffix}"`; + if (_issue.format === "includes") + return `Neplatn\xFD \u0159et\u011Bzec: mus\xED obsahovat "${_issue.includes}"`; + if (_issue.format === "regex") + return `Neplatn\xFD \u0159et\u011Bzec: mus\xED odpov\xEDdat vzoru ${_issue.pattern}`; + return `Neplatn\xFD form\xE1t ${(_i = FormatDictionary[_issue.format]) != null ? _i : issue2.format}`; + } + case "not_multiple_of": + return `Neplatn\xE9 \u010D\xEDslo: mus\xED b\xFDt n\xE1sobkem ${issue2.divisor}`; + case "unrecognized_keys": + return `Nezn\xE1m\xE9 kl\xED\u010De: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `Neplatn\xFD kl\xED\u010D v ${issue2.origin}`; + case "invalid_union": + return "Neplatn\xFD vstup"; + case "invalid_element": + return `Neplatn\xE1 hodnota v ${issue2.origin}`; + default: + return `Neplatn\xFD vstup`; + } + }; +}; +function cs_default() { + return { + localeError: error6() + }; +} + +// node_modules/zod/v4/locales/da.js +var error7 = () => { + const Sizable = { + string: { unit: "tegn", verb: "havde" }, + file: { unit: "bytes", verb: "havde" }, + array: { unit: "elementer", verb: "indeholdt" }, + set: { unit: "elementer", verb: "indeholdt" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "input", + email: "e-mailadresse", + url: "URL", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO dato- og klokkesl\xE6t", + date: "ISO-dato", + time: "ISO-klokkesl\xE6t", + duration: "ISO-varighed", + ipv4: "IPv4-omr\xE5de", + ipv6: "IPv6-omr\xE5de", + cidrv4: "IPv4-spektrum", + cidrv6: "IPv6-spektrum", + base64: "base64-kodet streng", + base64url: "base64url-kodet streng", + json_string: "JSON-streng", + e164: "E.164-nummer", + jwt: "JWT", + template_literal: "input" + }; + const TypeDictionary = { + nan: "NaN", + string: "streng", + number: "tal", + boolean: "boolean", + array: "liste", + object: "objekt", + set: "s\xE6t", + file: "fil" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `Ugyldigt input: forventede instanceof ${issue2.expected}, fik ${received}`; + } + return `Ugyldigt input: forventede ${expected}, fik ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `Ugyldig v\xE6rdi: forventede ${stringifyPrimitive(issue2.values[0])}`; + return `Ugyldigt valg: forventede en af f\xF8lgende ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + const origin = (_c = TypeDictionary[issue2.origin]) != null ? _c : issue2.origin; + if (sizing) + return `For stor: forventede ${origin != null ? origin : "value"} ${sizing.verb} ${adj} ${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elementer"}`; + return `For stor: forventede ${origin != null ? origin : "value"} havde ${adj} ${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + const origin = (_e = TypeDictionary[issue2.origin]) != null ? _e : issue2.origin; + if (sizing) { + return `For lille: forventede ${origin} ${sizing.verb} ${adj} ${issue2.minimum.toString()} ${sizing.unit}`; + } + return `For lille: forventede ${origin} havde ${adj} ${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `Ugyldig streng: skal starte med "${_issue.prefix}"`; + if (_issue.format === "ends_with") + return `Ugyldig streng: skal ende med "${_issue.suffix}"`; + if (_issue.format === "includes") + return `Ugyldig streng: skal indeholde "${_issue.includes}"`; + if (_issue.format === "regex") + return `Ugyldig streng: skal matche m\xF8nsteret ${_issue.pattern}`; + return `Ugyldig ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format}`; + } + case "not_multiple_of": + return `Ugyldigt tal: skal v\xE6re deleligt med ${issue2.divisor}`; + case "unrecognized_keys": + return `${issue2.keys.length > 1 ? "Ukendte n\xF8gler" : "Ukendt n\xF8gle"}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `Ugyldig n\xF8gle i ${issue2.origin}`; + case "invalid_union": + return "Ugyldigt input: matcher ingen af de tilladte typer"; + case "invalid_element": + return `Ugyldig v\xE6rdi i ${issue2.origin}`; + default: + return `Ugyldigt input`; + } + }; +}; +function da_default() { + return { + localeError: error7() + }; +} + +// node_modules/zod/v4/locales/de.js +var error8 = () => { + const Sizable = { + string: { unit: "Zeichen", verb: "zu haben" }, + file: { unit: "Bytes", verb: "zu haben" }, + array: { unit: "Elemente", verb: "zu haben" }, + set: { unit: "Elemente", verb: "zu haben" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "Eingabe", + email: "E-Mail-Adresse", + url: "URL", + emoji: "Emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO-Datum und -Uhrzeit", + date: "ISO-Datum", + time: "ISO-Uhrzeit", + duration: "ISO-Dauer", + ipv4: "IPv4-Adresse", + ipv6: "IPv6-Adresse", + cidrv4: "IPv4-Bereich", + cidrv6: "IPv6-Bereich", + base64: "Base64-codierter String", + base64url: "Base64-URL-codierter String", + json_string: "JSON-String", + e164: "E.164-Nummer", + jwt: "JWT", + template_literal: "Eingabe" + }; + const TypeDictionary = { + nan: "NaN", + number: "Zahl", + array: "Array" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `Ung\xFCltige Eingabe: erwartet instanceof ${issue2.expected}, erhalten ${received}`; + } + return `Ung\xFCltige Eingabe: erwartet ${expected}, erhalten ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `Ung\xFCltige Eingabe: erwartet ${stringifyPrimitive(issue2.values[0])}`; + return `Ung\xFCltige Option: erwartet eine von ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `Zu gro\xDF: erwartet, dass ${(_c = issue2.origin) != null ? _c : "Wert"} ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "Elemente"} hat`; + return `Zu gro\xDF: erwartet, dass ${(_e = issue2.origin) != null ? _e : "Wert"} ${adj}${issue2.maximum.toString()} ist`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `Zu klein: erwartet, dass ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit} hat`; + } + return `Zu klein: erwartet, dass ${issue2.origin} ${adj}${issue2.minimum.toString()} ist`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `Ung\xFCltiger String: muss mit "${_issue.prefix}" beginnen`; + if (_issue.format === "ends_with") + return `Ung\xFCltiger String: muss mit "${_issue.suffix}" enden`; + if (_issue.format === "includes") + return `Ung\xFCltiger String: muss "${_issue.includes}" enthalten`; + if (_issue.format === "regex") + return `Ung\xFCltiger String: muss dem Muster ${_issue.pattern} entsprechen`; + return `Ung\xFCltig: ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format}`; + } + case "not_multiple_of": + return `Ung\xFCltige Zahl: muss ein Vielfaches von ${issue2.divisor} sein`; + case "unrecognized_keys": + return `${issue2.keys.length > 1 ? "Unbekannte Schl\xFCssel" : "Unbekannter Schl\xFCssel"}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `Ung\xFCltiger Schl\xFCssel in ${issue2.origin}`; + case "invalid_union": + return "Ung\xFCltige Eingabe"; + case "invalid_element": + return `Ung\xFCltiger Wert in ${issue2.origin}`; + default: + return `Ung\xFCltige Eingabe`; + } + }; +}; +function de_default2() { + return { + localeError: error8() + }; +} + +// node_modules/zod/v4/locales/en.js +var error9 = () => { + const Sizable = { + string: { unit: "characters", verb: "to have" }, + file: { unit: "bytes", verb: "to have" }, + array: { unit: "items", verb: "to have" }, + set: { unit: "items", verb: "to have" }, + map: { unit: "entries", verb: "to have" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "input", + email: "email address", + url: "URL", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO datetime", + date: "ISO date", + time: "ISO time", + duration: "ISO duration", + ipv4: "IPv4 address", + ipv6: "IPv6 address", + mac: "MAC address", + cidrv4: "IPv4 range", + cidrv6: "IPv6 range", + base64: "base64-encoded string", + base64url: "base64url-encoded string", + json_string: "JSON string", + e164: "E.164 number", + jwt: "JWT", + template_literal: "input" + }; + const TypeDictionary = { + // Compatibility: "nan" -> "NaN" for display + nan: "NaN" + // All other type names omitted - they fall back to raw values via ?? operator + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + return `Invalid input: expected ${expected}, received ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `Invalid input: expected ${stringifyPrimitive(issue2.values[0])}`; + return `Invalid option: expected one of ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `Too big: expected ${(_c = issue2.origin) != null ? _c : "value"} to have ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elements"}`; + return `Too big: expected ${(_e = issue2.origin) != null ? _e : "value"} to be ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `Too small: expected ${issue2.origin} to have ${adj}${issue2.minimum.toString()} ${sizing.unit}`; + } + return `Too small: expected ${issue2.origin} to be ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") { + return `Invalid string: must start with "${_issue.prefix}"`; + } + if (_issue.format === "ends_with") + return `Invalid string: must end with "${_issue.suffix}"`; + if (_issue.format === "includes") + return `Invalid string: must include "${_issue.includes}"`; + if (_issue.format === "regex") + return `Invalid string: must match pattern ${_issue.pattern}`; + return `Invalid ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format}`; + } + case "not_multiple_of": + return `Invalid number: must be a multiple of ${issue2.divisor}`; + case "unrecognized_keys": + return `Unrecognized key${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `Invalid key in ${issue2.origin}`; + case "invalid_union": + return "Invalid input"; + case "invalid_element": + return `Invalid value in ${issue2.origin}`; + default: + return `Invalid input`; + } + }; +}; +function en_default3() { + return { + localeError: error9() + }; +} + +// node_modules/zod/v4/locales/eo.js +var error10 = () => { + const Sizable = { + string: { unit: "karaktrojn", verb: "havi" }, + file: { unit: "bajtojn", verb: "havi" }, + array: { unit: "elementojn", verb: "havi" }, + set: { unit: "elementojn", verb: "havi" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "enigo", + email: "retadreso", + url: "URL", + emoji: "emo\u011Dio", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO-datotempo", + date: "ISO-dato", + time: "ISO-tempo", + duration: "ISO-da\u016Dro", + ipv4: "IPv4-adreso", + ipv6: "IPv6-adreso", + cidrv4: "IPv4-rango", + cidrv6: "IPv6-rango", + base64: "64-ume kodita karaktraro", + base64url: "URL-64-ume kodita karaktraro", + json_string: "JSON-karaktraro", + e164: "E.164-nombro", + jwt: "JWT", + template_literal: "enigo" + }; + const TypeDictionary = { + nan: "NaN", + number: "nombro", + array: "tabelo", + null: "senvalora" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `Nevalida enigo: atendi\u011Dis instanceof ${issue2.expected}, ricevi\u011Dis ${received}`; + } + return `Nevalida enigo: atendi\u011Dis ${expected}, ricevi\u011Dis ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `Nevalida enigo: atendi\u011Dis ${stringifyPrimitive(issue2.values[0])}`; + return `Nevalida opcio: atendi\u011Dis unu el ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `Tro granda: atendi\u011Dis ke ${(_c = issue2.origin) != null ? _c : "valoro"} havu ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elementojn"}`; + return `Tro granda: atendi\u011Dis ke ${(_e = issue2.origin) != null ? _e : "valoro"} havu ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `Tro malgranda: atendi\u011Dis ke ${issue2.origin} havu ${adj}${issue2.minimum.toString()} ${sizing.unit}`; + } + return `Tro malgranda: atendi\u011Dis ke ${issue2.origin} estu ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `Nevalida karaktraro: devas komenci\u011Di per "${_issue.prefix}"`; + if (_issue.format === "ends_with") + return `Nevalida karaktraro: devas fini\u011Di per "${_issue.suffix}"`; + if (_issue.format === "includes") + return `Nevalida karaktraro: devas inkluzivi "${_issue.includes}"`; + if (_issue.format === "regex") + return `Nevalida karaktraro: devas kongrui kun la modelo ${_issue.pattern}`; + return `Nevalida ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format}`; + } + case "not_multiple_of": + return `Nevalida nombro: devas esti oblo de ${issue2.divisor}`; + case "unrecognized_keys": + return `Nekonata${issue2.keys.length > 1 ? "j" : ""} \u015Dlosilo${issue2.keys.length > 1 ? "j" : ""}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `Nevalida \u015Dlosilo en ${issue2.origin}`; + case "invalid_union": + return "Nevalida enigo"; + case "invalid_element": + return `Nevalida valoro en ${issue2.origin}`; + default: + return `Nevalida enigo`; + } + }; +}; +function eo_default() { + return { + localeError: error10() + }; +} + +// node_modules/zod/v4/locales/es.js +var error11 = () => { + const Sizable = { + string: { unit: "caracteres", verb: "tener" }, + file: { unit: "bytes", verb: "tener" }, + array: { unit: "elementos", verb: "tener" }, + set: { unit: "elementos", verb: "tener" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "entrada", + email: "direcci\xF3n de correo electr\xF3nico", + url: "URL", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "fecha y hora ISO", + date: "fecha ISO", + time: "hora ISO", + duration: "duraci\xF3n ISO", + ipv4: "direcci\xF3n IPv4", + ipv6: "direcci\xF3n IPv6", + cidrv4: "rango IPv4", + cidrv6: "rango IPv6", + base64: "cadena codificada en base64", + base64url: "URL codificada en base64", + json_string: "cadena JSON", + e164: "n\xFAmero E.164", + jwt: "JWT", + template_literal: "entrada" + }; + const TypeDictionary = { + nan: "NaN", + string: "texto", + number: "n\xFAmero", + boolean: "booleano", + array: "arreglo", + object: "objeto", + set: "conjunto", + file: "archivo", + date: "fecha", + bigint: "n\xFAmero grande", + symbol: "s\xEDmbolo", + undefined: "indefinido", + null: "nulo", + function: "funci\xF3n", + map: "mapa", + record: "registro", + tuple: "tupla", + enum: "enumeraci\xF3n", + union: "uni\xF3n", + literal: "literal", + promise: "promesa", + void: "vac\xEDo", + never: "nunca", + unknown: "desconocido", + any: "cualquiera" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f, _g, _h; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `Entrada inv\xE1lida: se esperaba instanceof ${issue2.expected}, recibido ${received}`; + } + return `Entrada inv\xE1lida: se esperaba ${expected}, recibido ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `Entrada inv\xE1lida: se esperaba ${stringifyPrimitive(issue2.values[0])}`; + return `Opci\xF3n inv\xE1lida: se esperaba una de ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + const origin = (_c = TypeDictionary[issue2.origin]) != null ? _c : issue2.origin; + if (sizing) + return `Demasiado grande: se esperaba que ${origin != null ? origin : "valor"} tuviera ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elementos"}`; + return `Demasiado grande: se esperaba que ${origin != null ? origin : "valor"} fuera ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + const origin = (_e = TypeDictionary[issue2.origin]) != null ? _e : issue2.origin; + if (sizing) { + return `Demasiado peque\xF1o: se esperaba que ${origin} tuviera ${adj}${issue2.minimum.toString()} ${sizing.unit}`; + } + return `Demasiado peque\xF1o: se esperaba que ${origin} fuera ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `Cadena inv\xE1lida: debe comenzar con "${_issue.prefix}"`; + if (_issue.format === "ends_with") + return `Cadena inv\xE1lida: debe terminar en "${_issue.suffix}"`; + if (_issue.format === "includes") + return `Cadena inv\xE1lida: debe incluir "${_issue.includes}"`; + if (_issue.format === "regex") + return `Cadena inv\xE1lida: debe coincidir con el patr\xF3n ${_issue.pattern}`; + return `Inv\xE1lido ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format}`; + } + case "not_multiple_of": + return `N\xFAmero inv\xE1lido: debe ser m\xFAltiplo de ${issue2.divisor}`; + case "unrecognized_keys": + return `Llave${issue2.keys.length > 1 ? "s" : ""} desconocida${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `Llave inv\xE1lida en ${(_g = TypeDictionary[issue2.origin]) != null ? _g : issue2.origin}`; + case "invalid_union": + return "Entrada inv\xE1lida"; + case "invalid_element": + return `Valor inv\xE1lido en ${(_h = TypeDictionary[issue2.origin]) != null ? _h : issue2.origin}`; + default: + return `Entrada inv\xE1lida`; + } + }; +}; +function es_default2() { + return { + localeError: error11() + }; +} + +// node_modules/zod/v4/locales/fa.js +var error12 = () => { + const Sizable = { + string: { unit: "\u06A9\u0627\u0631\u0627\u06A9\u062A\u0631", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" }, + file: { unit: "\u0628\u0627\u06CC\u062A", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" }, + array: { unit: "\u0622\u06CC\u062A\u0645", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" }, + set: { unit: "\u0622\u06CC\u062A\u0645", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "\u0648\u0631\u0648\u062F\u06CC", + email: "\u0622\u062F\u0631\u0633 \u0627\u06CC\u0645\u06CC\u0644", + url: "URL", + emoji: "\u0627\u06CC\u0645\u0648\u062C\u06CC", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "\u062A\u0627\u0631\u06CC\u062E \u0648 \u0632\u0645\u0627\u0646 \u0627\u06CC\u0632\u0648", + date: "\u062A\u0627\u0631\u06CC\u062E \u0627\u06CC\u0632\u0648", + time: "\u0632\u0645\u0627\u0646 \u0627\u06CC\u0632\u0648", + duration: "\u0645\u062F\u062A \u0632\u0645\u0627\u0646 \u0627\u06CC\u0632\u0648", + ipv4: "IPv4 \u0622\u062F\u0631\u0633", + ipv6: "IPv6 \u0622\u062F\u0631\u0633", + cidrv4: "IPv4 \u062F\u0627\u0645\u0646\u0647", + cidrv6: "IPv6 \u062F\u0627\u0645\u0646\u0647", + base64: "base64-encoded \u0631\u0634\u062A\u0647", + base64url: "base64url-encoded \u0631\u0634\u062A\u0647", + json_string: "JSON \u0631\u0634\u062A\u0647", + e164: "E.164 \u0639\u062F\u062F", + jwt: "JWT", + template_literal: "\u0648\u0631\u0648\u062F\u06CC" + }; + const TypeDictionary = { + nan: "NaN", + number: "\u0639\u062F\u062F", + array: "\u0622\u0631\u0627\u06CC\u0647" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A instanceof ${issue2.expected} \u0645\u06CC\u200C\u0628\u0648\u062F\u060C ${received} \u062F\u0631\u06CC\u0627\u0641\u062A \u0634\u062F`; + } + return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A ${expected} \u0645\u06CC\u200C\u0628\u0648\u062F\u060C ${received} \u062F\u0631\u06CC\u0627\u0641\u062A \u0634\u062F`; + } + case "invalid_value": + if (issue2.values.length === 1) { + return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A ${stringifyPrimitive(issue2.values[0])} \u0645\u06CC\u200C\u0628\u0648\u062F`; + } + return `\u06AF\u0632\u06CC\u0646\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A \u06CC\u06A9\u06CC \u0627\u0632 ${joinValues(issue2.values, "|")} \u0645\u06CC\u200C\u0628\u0648\u062F`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `\u062E\u06CC\u0644\u06CC \u0628\u0632\u0631\u06AF: ${(_c = issue2.origin) != null ? _c : "\u0645\u0642\u062F\u0627\u0631"} \u0628\u0627\u06CC\u062F ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\u0639\u0646\u0635\u0631"} \u0628\u0627\u0634\u062F`; + } + return `\u062E\u06CC\u0644\u06CC \u0628\u0632\u0631\u06AF: ${(_e = issue2.origin) != null ? _e : "\u0645\u0642\u062F\u0627\u0631"} \u0628\u0627\u06CC\u062F ${adj}${issue2.maximum.toString()} \u0628\u0627\u0634\u062F`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `\u062E\u06CC\u0644\u06CC \u06A9\u0648\u0686\u06A9: ${issue2.origin} \u0628\u0627\u06CC\u062F ${adj}${issue2.minimum.toString()} ${sizing.unit} \u0628\u0627\u0634\u062F`; + } + return `\u062E\u06CC\u0644\u06CC \u06A9\u0648\u0686\u06A9: ${issue2.origin} \u0628\u0627\u06CC\u062F ${adj}${issue2.minimum.toString()} \u0628\u0627\u0634\u062F`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") { + return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0628\u0627 "${_issue.prefix}" \u0634\u0631\u0648\u0639 \u0634\u0648\u062F`; + } + if (_issue.format === "ends_with") { + return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0628\u0627 "${_issue.suffix}" \u062A\u0645\u0627\u0645 \u0634\u0648\u062F`; + } + if (_issue.format === "includes") { + return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0634\u0627\u0645\u0644 "${_issue.includes}" \u0628\u0627\u0634\u062F`; + } + if (_issue.format === "regex") { + return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0628\u0627 \u0627\u0644\u06AF\u0648\u06CC ${_issue.pattern} \u0645\u0637\u0627\u0628\u0642\u062A \u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F`; + } + return `${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format} \u0646\u0627\u0645\u0639\u062A\u0628\u0631`; + } + case "not_multiple_of": + return `\u0639\u062F\u062F \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0645\u0636\u0631\u0628 ${issue2.divisor} \u0628\u0627\u0634\u062F`; + case "unrecognized_keys": + return `\u06A9\u0644\u06CC\u062F${issue2.keys.length > 1 ? "\u0647\u0627\u06CC" : ""} \u0646\u0627\u0634\u0646\u0627\u0633: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `\u06A9\u0644\u06CC\u062F \u0646\u0627\u0634\u0646\u0627\u0633 \u062F\u0631 ${issue2.origin}`; + case "invalid_union": + return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631`; + case "invalid_element": + return `\u0645\u0642\u062F\u0627\u0631 \u0646\u0627\u0645\u0639\u062A\u0628\u0631 \u062F\u0631 ${issue2.origin}`; + default: + return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631`; + } + }; +}; +function fa_default() { + return { + localeError: error12() + }; +} + +// node_modules/zod/v4/locales/fi.js +var error13 = () => { + const Sizable = { + string: { unit: "merkki\xE4", subject: "merkkijonon" }, + file: { unit: "tavua", subject: "tiedoston" }, + array: { unit: "alkiota", subject: "listan" }, + set: { unit: "alkiota", subject: "joukon" }, + number: { unit: "", subject: "luvun" }, + bigint: { unit: "", subject: "suuren kokonaisluvun" }, + int: { unit: "", subject: "kokonaisluvun" }, + date: { unit: "", subject: "p\xE4iv\xE4m\xE4\xE4r\xE4n" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "s\xE4\xE4nn\xF6llinen lauseke", + email: "s\xE4hk\xF6postiosoite", + url: "URL-osoite", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO-aikaleima", + date: "ISO-p\xE4iv\xE4m\xE4\xE4r\xE4", + time: "ISO-aika", + duration: "ISO-kesto", + ipv4: "IPv4-osoite", + ipv6: "IPv6-osoite", + cidrv4: "IPv4-alue", + cidrv6: "IPv6-alue", + base64: "base64-koodattu merkkijono", + base64url: "base64url-koodattu merkkijono", + json_string: "JSON-merkkijono", + e164: "E.164-luku", + jwt: "JWT", + template_literal: "templaattimerkkijono" + }; + const TypeDictionary = { + nan: "NaN" + }; + return (issue2) => { + var _a3, _b2, _c; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `Virheellinen tyyppi: odotettiin instanceof ${issue2.expected}, oli ${received}`; + } + return `Virheellinen tyyppi: odotettiin ${expected}, oli ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `Virheellinen sy\xF6te: t\xE4ytyy olla ${stringifyPrimitive(issue2.values[0])}`; + return `Virheellinen valinta: t\xE4ytyy olla yksi seuraavista: ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `Liian suuri: ${sizing.subject} t\xE4ytyy olla ${adj}${issue2.maximum.toString()} ${sizing.unit}`.trim(); + } + return `Liian suuri: arvon t\xE4ytyy olla ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `Liian pieni: ${sizing.subject} t\xE4ytyy olla ${adj}${issue2.minimum.toString()} ${sizing.unit}`.trim(); + } + return `Liian pieni: arvon t\xE4ytyy olla ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `Virheellinen sy\xF6te: t\xE4ytyy alkaa "${_issue.prefix}"`; + if (_issue.format === "ends_with") + return `Virheellinen sy\xF6te: t\xE4ytyy loppua "${_issue.suffix}"`; + if (_issue.format === "includes") + return `Virheellinen sy\xF6te: t\xE4ytyy sis\xE4lt\xE4\xE4 "${_issue.includes}"`; + if (_issue.format === "regex") { + return `Virheellinen sy\xF6te: t\xE4ytyy vastata s\xE4\xE4nn\xF6llist\xE4 lauseketta ${_issue.pattern}`; + } + return `Virheellinen ${(_c = FormatDictionary[_issue.format]) != null ? _c : issue2.format}`; + } + case "not_multiple_of": + return `Virheellinen luku: t\xE4ytyy olla luvun ${issue2.divisor} monikerta`; + case "unrecognized_keys": + return `${issue2.keys.length > 1 ? "Tuntemattomat avaimet" : "Tuntematon avain"}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return "Virheellinen avain tietueessa"; + case "invalid_union": + return "Virheellinen unioni"; + case "invalid_element": + return "Virheellinen arvo joukossa"; + default: + return `Virheellinen sy\xF6te`; + } + }; +}; +function fi_default() { + return { + localeError: error13() + }; +} + +// node_modules/zod/v4/locales/fr.js +var error14 = () => { + const Sizable = { + string: { unit: "caract\xE8res", verb: "avoir" }, + file: { unit: "octets", verb: "avoir" }, + array: { unit: "\xE9l\xE9ments", verb: "avoir" }, + set: { unit: "\xE9l\xE9ments", verb: "avoir" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "entr\xE9e", + email: "adresse e-mail", + url: "URL", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "date et heure ISO", + date: "date ISO", + time: "heure ISO", + duration: "dur\xE9e ISO", + ipv4: "adresse IPv4", + ipv6: "adresse IPv6", + cidrv4: "plage IPv4", + cidrv6: "plage IPv6", + base64: "cha\xEEne encod\xE9e en base64", + base64url: "cha\xEEne encod\xE9e en base64url", + json_string: "cha\xEEne JSON", + e164: "num\xE9ro E.164", + jwt: "JWT", + template_literal: "entr\xE9e" + }; + const TypeDictionary = { + nan: "NaN", + number: "nombre", + array: "tableau" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `Entr\xE9e invalide : instanceof ${issue2.expected} attendu, ${received} re\xE7u`; + } + return `Entr\xE9e invalide : ${expected} attendu, ${received} re\xE7u`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `Entr\xE9e invalide : ${stringifyPrimitive(issue2.values[0])} attendu`; + return `Option invalide : une valeur parmi ${joinValues(issue2.values, "|")} attendue`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `Trop grand : ${(_c = issue2.origin) != null ? _c : "valeur"} doit ${sizing.verb} ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\xE9l\xE9ment(s)"}`; + return `Trop grand : ${(_e = issue2.origin) != null ? _e : "valeur"} doit \xEAtre ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `Trop petit : ${issue2.origin} doit ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`; + } + return `Trop petit : ${issue2.origin} doit \xEAtre ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `Cha\xEEne invalide : doit commencer par "${_issue.prefix}"`; + if (_issue.format === "ends_with") + return `Cha\xEEne invalide : doit se terminer par "${_issue.suffix}"`; + if (_issue.format === "includes") + return `Cha\xEEne invalide : doit inclure "${_issue.includes}"`; + if (_issue.format === "regex") + return `Cha\xEEne invalide : doit correspondre au mod\xE8le ${_issue.pattern}`; + return `${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format} invalide`; + } + case "not_multiple_of": + return `Nombre invalide : doit \xEAtre un multiple de ${issue2.divisor}`; + case "unrecognized_keys": + return `Cl\xE9${issue2.keys.length > 1 ? "s" : ""} non reconnue${issue2.keys.length > 1 ? "s" : ""} : ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `Cl\xE9 invalide dans ${issue2.origin}`; + case "invalid_union": + return "Entr\xE9e invalide"; + case "invalid_element": + return `Valeur invalide dans ${issue2.origin}`; + default: + return `Entr\xE9e invalide`; + } + }; +}; +function fr_default2() { + return { + localeError: error14() + }; +} + +// node_modules/zod/v4/locales/fr-CA.js +var error15 = () => { + const Sizable = { + string: { unit: "caract\xE8res", verb: "avoir" }, + file: { unit: "octets", verb: "avoir" }, + array: { unit: "\xE9l\xE9ments", verb: "avoir" }, + set: { unit: "\xE9l\xE9ments", verb: "avoir" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "entr\xE9e", + email: "adresse courriel", + url: "URL", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "date-heure ISO", + date: "date ISO", + time: "heure ISO", + duration: "dur\xE9e ISO", + ipv4: "adresse IPv4", + ipv6: "adresse IPv6", + cidrv4: "plage IPv4", + cidrv6: "plage IPv6", + base64: "cha\xEEne encod\xE9e en base64", + base64url: "cha\xEEne encod\xE9e en base64url", + json_string: "cha\xEEne JSON", + e164: "num\xE9ro E.164", + jwt: "JWT", + template_literal: "entr\xE9e" + }; + const TypeDictionary = { + nan: "NaN" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `Entr\xE9e invalide : attendu instanceof ${issue2.expected}, re\xE7u ${received}`; + } + return `Entr\xE9e invalide : attendu ${expected}, re\xE7u ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `Entr\xE9e invalide : attendu ${stringifyPrimitive(issue2.values[0])}`; + return `Option invalide : attendu l'une des valeurs suivantes ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "\u2264" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `Trop grand : attendu que ${(_c = issue2.origin) != null ? _c : "la valeur"} ait ${adj}${issue2.maximum.toString()} ${sizing.unit}`; + return `Trop grand : attendu que ${(_d = issue2.origin) != null ? _d : "la valeur"} soit ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? "\u2265" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `Trop petit : attendu que ${issue2.origin} ait ${adj}${issue2.minimum.toString()} ${sizing.unit}`; + } + return `Trop petit : attendu que ${issue2.origin} soit ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") { + return `Cha\xEEne invalide : doit commencer par "${_issue.prefix}"`; + } + if (_issue.format === "ends_with") + return `Cha\xEEne invalide : doit se terminer par "${_issue.suffix}"`; + if (_issue.format === "includes") + return `Cha\xEEne invalide : doit inclure "${_issue.includes}"`; + if (_issue.format === "regex") + return `Cha\xEEne invalide : doit correspondre au motif ${_issue.pattern}`; + return `${(_e = FormatDictionary[_issue.format]) != null ? _e : issue2.format} invalide`; + } + case "not_multiple_of": + return `Nombre invalide : doit \xEAtre un multiple de ${issue2.divisor}`; + case "unrecognized_keys": + return `Cl\xE9${issue2.keys.length > 1 ? "s" : ""} non reconnue${issue2.keys.length > 1 ? "s" : ""} : ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `Cl\xE9 invalide dans ${issue2.origin}`; + case "invalid_union": + return "Entr\xE9e invalide"; + case "invalid_element": + return `Valeur invalide dans ${issue2.origin}`; + default: + return `Entr\xE9e invalide`; + } + }; +}; +function fr_CA_default() { + return { + localeError: error15() + }; +} + +// node_modules/zod/v4/locales/he.js +var error16 = () => { + const TypeNames = { + string: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA", gender: "f" }, + number: { label: "\u05DE\u05E1\u05E4\u05E8", gender: "m" }, + boolean: { label: "\u05E2\u05E8\u05DA \u05D1\u05D5\u05DC\u05D9\u05D0\u05E0\u05D9", gender: "m" }, + bigint: { label: "BigInt", gender: "m" }, + date: { label: "\u05EA\u05D0\u05E8\u05D9\u05DA", gender: "m" }, + array: { label: "\u05DE\u05E2\u05E8\u05DA", gender: "m" }, + object: { label: "\u05D0\u05D5\u05D1\u05D9\u05D9\u05E7\u05D8", gender: "m" }, + null: { label: "\u05E2\u05E8\u05DA \u05E8\u05D9\u05E7 (null)", gender: "m" }, + undefined: { label: "\u05E2\u05E8\u05DA \u05DC\u05D0 \u05DE\u05D5\u05D2\u05D3\u05E8 (undefined)", gender: "m" }, + symbol: { label: "\u05E1\u05D9\u05DE\u05D1\u05D5\u05DC (Symbol)", gender: "m" }, + function: { label: "\u05E4\u05D5\u05E0\u05E7\u05E6\u05D9\u05D4", gender: "f" }, + map: { label: "\u05DE\u05E4\u05D4 (Map)", gender: "f" }, + set: { label: "\u05E7\u05D1\u05D5\u05E6\u05D4 (Set)", gender: "f" }, + file: { label: "\u05E7\u05D5\u05D1\u05E5", gender: "m" }, + promise: { label: "Promise", gender: "m" }, + NaN: { label: "NaN", gender: "m" }, + unknown: { label: "\u05E2\u05E8\u05DA \u05DC\u05D0 \u05D9\u05D3\u05D5\u05E2", gender: "m" }, + value: { label: "\u05E2\u05E8\u05DA", gender: "m" } + }; + const Sizable = { + string: { unit: "\u05EA\u05D5\u05D5\u05D9\u05DD", shortLabel: "\u05E7\u05E6\u05E8", longLabel: "\u05D0\u05E8\u05D5\u05DA" }, + file: { unit: "\u05D1\u05D9\u05D9\u05D8\u05D9\u05DD", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" }, + array: { unit: "\u05E4\u05E8\u05D9\u05D8\u05D9\u05DD", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" }, + set: { unit: "\u05E4\u05E8\u05D9\u05D8\u05D9\u05DD", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" }, + number: { unit: "", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" } + // no unit + }; + const typeEntry = (t3) => t3 ? TypeNames[t3] : void 0; + const typeLabel = (t3) => { + const e3 = typeEntry(t3); + if (e3) + return e3.label; + return t3 != null ? t3 : TypeNames.unknown.label; + }; + const withDefinite = (t3) => `\u05D4${typeLabel(t3)}`; + const verbFor = (t3) => { + var _a3; + const e3 = typeEntry(t3); + const gender = (_a3 = e3 == null ? void 0 : e3.gender) != null ? _a3 : "m"; + return gender === "f" ? "\u05E6\u05E8\u05D9\u05DB\u05D4 \u05DC\u05D4\u05D9\u05D5\u05EA" : "\u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA"; + }; + const getSizing = (origin) => { + var _a3; + if (!origin) + return null; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + }; + const FormatDictionary = { + regex: { label: "\u05E7\u05DC\u05D8", gender: "m" }, + email: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA \u05D0\u05D9\u05DE\u05D9\u05D9\u05DC", gender: "f" }, + url: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA \u05E8\u05E9\u05EA", gender: "f" }, + emoji: { label: "\u05D0\u05D9\u05DE\u05D5\u05D2'\u05D9", gender: "m" }, + uuid: { label: "UUID", gender: "m" }, + nanoid: { label: "nanoid", gender: "m" }, + guid: { label: "GUID", gender: "m" }, + cuid: { label: "cuid", gender: "m" }, + cuid2: { label: "cuid2", gender: "m" }, + ulid: { label: "ULID", gender: "m" }, + xid: { label: "XID", gender: "m" }, + ksuid: { label: "KSUID", gender: "m" }, + datetime: { label: "\u05EA\u05D0\u05E8\u05D9\u05DA \u05D5\u05D6\u05DE\u05DF ISO", gender: "m" }, + date: { label: "\u05EA\u05D0\u05E8\u05D9\u05DA ISO", gender: "m" }, + time: { label: "\u05D6\u05DE\u05DF ISO", gender: "m" }, + duration: { label: "\u05DE\u05E9\u05DA \u05D6\u05DE\u05DF ISO", gender: "m" }, + ipv4: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA IPv4", gender: "f" }, + ipv6: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA IPv6", gender: "f" }, + cidrv4: { label: "\u05D8\u05D5\u05D5\u05D7 IPv4", gender: "m" }, + cidrv6: { label: "\u05D8\u05D5\u05D5\u05D7 IPv6", gender: "m" }, + base64: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D1\u05D1\u05E1\u05D9\u05E1 64", gender: "f" }, + base64url: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D1\u05D1\u05E1\u05D9\u05E1 64 \u05DC\u05DB\u05EA\u05D5\u05D1\u05D5\u05EA \u05E8\u05E9\u05EA", gender: "f" }, + json_string: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA JSON", gender: "f" }, + e164: { label: "\u05DE\u05E1\u05E4\u05E8 E.164", gender: "m" }, + jwt: { label: "JWT", gender: "m" }, + ends_with: { label: "\u05E7\u05DC\u05D8", gender: "m" }, + includes: { label: "\u05E7\u05DC\u05D8", gender: "m" }, + lowercase: { label: "\u05E7\u05DC\u05D8", gender: "m" }, + starts_with: { label: "\u05E7\u05DC\u05D8", gender: "m" }, + uppercase: { label: "\u05E7\u05DC\u05D8", gender: "m" } + }; + const TypeDictionary = { + nan: "NaN" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f, _g, _h, _i, _j2, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u; + switch (issue2.code) { + case "invalid_type": { + const expectedKey = issue2.expected; + const expected = (_a3 = TypeDictionary[expectedKey != null ? expectedKey : ""]) != null ? _a3 : typeLabel(expectedKey); + const receivedType = parsedType(issue2.input); + const received = (_d = (_c = TypeDictionary[receivedType]) != null ? _c : (_b2 = TypeNames[receivedType]) == null ? void 0 : _b2.label) != null ? _d : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA instanceof ${issue2.expected}, \u05D4\u05EA\u05E7\u05D1\u05DC ${received}`; + } + return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${expected}, \u05D4\u05EA\u05E7\u05D1\u05DC ${received}`; + } + case "invalid_value": { + if (issue2.values.length === 1) { + return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D4\u05E2\u05E8\u05DA \u05D7\u05D9\u05D9\u05D1 \u05DC\u05D4\u05D9\u05D5\u05EA ${stringifyPrimitive(issue2.values[0])}`; + } + const stringified = issue2.values.map((v2) => stringifyPrimitive(v2)); + if (issue2.values.length === 2) { + return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D4\u05D0\u05E4\u05E9\u05E8\u05D5\u05D9\u05D5\u05EA \u05D4\u05DE\u05EA\u05D0\u05D9\u05DE\u05D5\u05EA \u05D4\u05DF ${stringified[0]} \u05D0\u05D5 ${stringified[1]}`; + } + const lastValue = stringified[stringified.length - 1]; + const restValues = stringified.slice(0, -1).join(", "); + return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D4\u05D0\u05E4\u05E9\u05E8\u05D5\u05D9\u05D5\u05EA \u05D4\u05DE\u05EA\u05D0\u05D9\u05DE\u05D5\u05EA \u05D4\u05DF ${restValues} \u05D0\u05D5 ${lastValue}`; + } + case "too_big": { + const sizing = getSizing(issue2.origin); + const subject = withDefinite((_e = issue2.origin) != null ? _e : "value"); + if (issue2.origin === "string") { + return `${(_f = sizing == null ? void 0 : sizing.longLabel) != null ? _f : "\u05D0\u05E8\u05D5\u05DA"} \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DB\u05D4 \u05DC\u05D4\u05DB\u05D9\u05DC ${issue2.maximum.toString()} ${(_g = sizing == null ? void 0 : sizing.unit) != null ? _g : ""} ${issue2.inclusive ? "\u05D0\u05D5 \u05E4\u05D7\u05D5\u05EA" : "\u05DC\u05DB\u05DC \u05D4\u05D9\u05D5\u05EA\u05E8"}`.trim(); + } + if (issue2.origin === "number") { + const comparison = issue2.inclusive ? `\u05E7\u05D8\u05DF \u05D0\u05D5 \u05E9\u05D5\u05D5\u05D4 \u05DC-${issue2.maximum}` : `\u05E7\u05D8\u05DF \u05DE-${issue2.maximum}`; + return `\u05D2\u05D3\u05D5\u05DC \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${comparison}`; + } + if (issue2.origin === "array" || issue2.origin === "set") { + const verb = issue2.origin === "set" ? "\u05E6\u05E8\u05D9\u05DB\u05D4" : "\u05E6\u05E8\u05D9\u05DA"; + const comparison = issue2.inclusive ? `${issue2.maximum} ${(_h = sizing == null ? void 0 : sizing.unit) != null ? _h : ""} \u05D0\u05D5 \u05E4\u05D7\u05D5\u05EA` : `\u05E4\u05D7\u05D5\u05EA \u05DE-${issue2.maximum} ${(_i = sizing == null ? void 0 : sizing.unit) != null ? _i : ""}`; + return `\u05D2\u05D3\u05D5\u05DC \u05DE\u05D3\u05D9: ${subject} ${verb} \u05DC\u05D4\u05DB\u05D9\u05DC ${comparison}`.trim(); + } + const adj = issue2.inclusive ? "<=" : "<"; + const be = verbFor((_j2 = issue2.origin) != null ? _j2 : "value"); + if (sizing == null ? void 0 : sizing.unit) { + return `${sizing.longLabel} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue2.maximum.toString()} ${sizing.unit}`; + } + return `${(_k = sizing == null ? void 0 : sizing.longLabel) != null ? _k : "\u05D2\u05D3\u05D5\u05DC"} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const sizing = getSizing(issue2.origin); + const subject = withDefinite((_l = issue2.origin) != null ? _l : "value"); + if (issue2.origin === "string") { + return `${(_m = sizing == null ? void 0 : sizing.shortLabel) != null ? _m : "\u05E7\u05E6\u05E8"} \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DB\u05D4 \u05DC\u05D4\u05DB\u05D9\u05DC ${issue2.minimum.toString()} ${(_n = sizing == null ? void 0 : sizing.unit) != null ? _n : ""} ${issue2.inclusive ? "\u05D0\u05D5 \u05D9\u05D5\u05EA\u05E8" : "\u05DC\u05E4\u05D7\u05D5\u05EA"}`.trim(); + } + if (issue2.origin === "number") { + const comparison = issue2.inclusive ? `\u05D2\u05D3\u05D5\u05DC \u05D0\u05D5 \u05E9\u05D5\u05D5\u05D4 \u05DC-${issue2.minimum}` : `\u05D2\u05D3\u05D5\u05DC \u05DE-${issue2.minimum}`; + return `\u05E7\u05D8\u05DF \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${comparison}`; + } + if (issue2.origin === "array" || issue2.origin === "set") { + const verb = issue2.origin === "set" ? "\u05E6\u05E8\u05D9\u05DB\u05D4" : "\u05E6\u05E8\u05D9\u05DA"; + if (issue2.minimum === 1 && issue2.inclusive) { + const singularPhrase = issue2.origin === "set" ? "\u05DC\u05E4\u05D7\u05D5\u05EA \u05E4\u05E8\u05D9\u05D8 \u05D0\u05D7\u05D3" : "\u05DC\u05E4\u05D7\u05D5\u05EA \u05E4\u05E8\u05D9\u05D8 \u05D0\u05D7\u05D3"; + return `\u05E7\u05D8\u05DF \u05DE\u05D3\u05D9: ${subject} ${verb} \u05DC\u05D4\u05DB\u05D9\u05DC ${singularPhrase}`; + } + const comparison = issue2.inclusive ? `${issue2.minimum} ${(_o = sizing == null ? void 0 : sizing.unit) != null ? _o : ""} \u05D0\u05D5 \u05D9\u05D5\u05EA\u05E8` : `\u05D9\u05D5\u05EA\u05E8 \u05DE-${issue2.minimum} ${(_p = sizing == null ? void 0 : sizing.unit) != null ? _p : ""}`; + return `\u05E7\u05D8\u05DF \u05DE\u05D3\u05D9: ${subject} ${verb} \u05DC\u05D4\u05DB\u05D9\u05DC ${comparison}`.trim(); + } + const adj = issue2.inclusive ? ">=" : ">"; + const be = verbFor((_q = issue2.origin) != null ? _q : "value"); + if (sizing == null ? void 0 : sizing.unit) { + return `${sizing.shortLabel} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue2.minimum.toString()} ${sizing.unit}`; + } + return `${(_r = sizing == null ? void 0 : sizing.shortLabel) != null ? _r : "\u05E7\u05D8\u05DF"} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05D4\u05EA\u05D7\u05D9\u05DC \u05D1 "${_issue.prefix}"`; + if (_issue.format === "ends_with") + return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05D4\u05E1\u05EA\u05D9\u05D9\u05DD \u05D1 "${_issue.suffix}"`; + if (_issue.format === "includes") + return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05DB\u05DC\u05D5\u05DC "${_issue.includes}"`; + if (_issue.format === "regex") + return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05D4\u05EA\u05D0\u05D9\u05DD \u05DC\u05EA\u05D1\u05E0\u05D9\u05EA ${_issue.pattern}`; + const nounEntry = FormatDictionary[_issue.format]; + const noun = (_s = nounEntry == null ? void 0 : nounEntry.label) != null ? _s : _issue.format; + const gender = (_t = nounEntry == null ? void 0 : nounEntry.gender) != null ? _t : "m"; + const adjective = gender === "f" ? "\u05EA\u05E7\u05D9\u05E0\u05D4" : "\u05EA\u05E7\u05D9\u05DF"; + return `${noun} \u05DC\u05D0 ${adjective}`; + } + case "not_multiple_of": + return `\u05DE\u05E1\u05E4\u05E8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D7\u05D9\u05D9\u05D1 \u05DC\u05D4\u05D9\u05D5\u05EA \u05DE\u05DB\u05E4\u05DC\u05D4 \u05E9\u05DC ${issue2.divisor}`; + case "unrecognized_keys": + return `\u05DE\u05E4\u05EA\u05D7${issue2.keys.length > 1 ? "\u05D5\u05EA" : ""} \u05DC\u05D0 \u05DE\u05D6\u05D5\u05D4${issue2.keys.length > 1 ? "\u05D9\u05DD" : "\u05D4"}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": { + return `\u05E9\u05D3\u05D4 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF \u05D1\u05D0\u05D5\u05D1\u05D9\u05D9\u05E7\u05D8`; + } + case "invalid_union": + return "\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF"; + case "invalid_element": { + const place = withDefinite((_u = issue2.origin) != null ? _u : "array"); + return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF \u05D1${place}`; + } + default: + return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF`; + } + }; +}; +function he_default() { + return { + localeError: error16() + }; +} + +// node_modules/zod/v4/locales/hu.js +var error17 = () => { + const Sizable = { + string: { unit: "karakter", verb: "legyen" }, + file: { unit: "byte", verb: "legyen" }, + array: { unit: "elem", verb: "legyen" }, + set: { unit: "elem", verb: "legyen" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "bemenet", + email: "email c\xEDm", + url: "URL", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO id\u0151b\xE9lyeg", + date: "ISO d\xE1tum", + time: "ISO id\u0151", + duration: "ISO id\u0151intervallum", + ipv4: "IPv4 c\xEDm", + ipv6: "IPv6 c\xEDm", + cidrv4: "IPv4 tartom\xE1ny", + cidrv6: "IPv6 tartom\xE1ny", + base64: "base64-k\xF3dolt string", + base64url: "base64url-k\xF3dolt string", + json_string: "JSON string", + e164: "E.164 sz\xE1m", + jwt: "JWT", + template_literal: "bemenet" + }; + const TypeDictionary = { + nan: "NaN", + number: "sz\xE1m", + array: "t\xF6mb" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k instanceof ${issue2.expected}, a kapott \xE9rt\xE9k ${received}`; + } + return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${expected}, a kapott \xE9rt\xE9k ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${stringifyPrimitive(issue2.values[0])}`; + return `\xC9rv\xE9nytelen opci\xF3: valamelyik \xE9rt\xE9k v\xE1rt ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `T\xFAl nagy: ${(_c = issue2.origin) != null ? _c : "\xE9rt\xE9k"} m\xE9rete t\xFAl nagy ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elem"}`; + return `T\xFAl nagy: a bemeneti \xE9rt\xE9k ${(_e = issue2.origin) != null ? _e : "\xE9rt\xE9k"} t\xFAl nagy: ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `T\xFAl kicsi: a bemeneti \xE9rt\xE9k ${issue2.origin} m\xE9rete t\xFAl kicsi ${adj}${issue2.minimum.toString()} ${sizing.unit}`; + } + return `T\xFAl kicsi: a bemeneti \xE9rt\xE9k ${issue2.origin} t\xFAl kicsi ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `\xC9rv\xE9nytelen string: "${_issue.prefix}" \xE9rt\xE9kkel kell kezd\u0151dnie`; + if (_issue.format === "ends_with") + return `\xC9rv\xE9nytelen string: "${_issue.suffix}" \xE9rt\xE9kkel kell v\xE9gz\u0151dnie`; + if (_issue.format === "includes") + return `\xC9rv\xE9nytelen string: "${_issue.includes}" \xE9rt\xE9ket kell tartalmaznia`; + if (_issue.format === "regex") + return `\xC9rv\xE9nytelen string: ${_issue.pattern} mint\xE1nak kell megfelelnie`; + return `\xC9rv\xE9nytelen ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format}`; + } + case "not_multiple_of": + return `\xC9rv\xE9nytelen sz\xE1m: ${issue2.divisor} t\xF6bbsz\xF6r\xF6s\xE9nek kell lennie`; + case "unrecognized_keys": + return `Ismeretlen kulcs${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `\xC9rv\xE9nytelen kulcs ${issue2.origin}`; + case "invalid_union": + return "\xC9rv\xE9nytelen bemenet"; + case "invalid_element": + return `\xC9rv\xE9nytelen \xE9rt\xE9k: ${issue2.origin}`; + default: + return `\xC9rv\xE9nytelen bemenet`; + } + }; +}; +function hu_default() { + return { + localeError: error17() + }; +} + +// node_modules/zod/v4/locales/hy.js +function getArmenianPlural(count, one, many) { + return Math.abs(count) === 1 ? one : many; +} +function withDefiniteArticle(word) { + if (!word) + return ""; + const vowels = ["\u0561", "\u0565", "\u0568", "\u056B", "\u0578", "\u0578\u0582", "\u0585"]; + const lastChar = word[word.length - 1]; + return word + (vowels.includes(lastChar) ? "\u0576" : "\u0568"); +} +var error18 = () => { + const Sizable = { + string: { + unit: { + one: "\u0576\u0577\u0561\u0576", + many: "\u0576\u0577\u0561\u0576\u0576\u0565\u0580" + }, + verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C" + }, + file: { + unit: { + one: "\u0562\u0561\u0575\u0569", + many: "\u0562\u0561\u0575\u0569\u0565\u0580" + }, + verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C" + }, + array: { + unit: { + one: "\u057F\u0561\u0580\u0580", + many: "\u057F\u0561\u0580\u0580\u0565\u0580" + }, + verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C" + }, + set: { + unit: { + one: "\u057F\u0561\u0580\u0580", + many: "\u057F\u0561\u0580\u0580\u0565\u0580" + }, + verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C" + } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "\u0574\u0578\u0582\u057F\u0584", + email: "\u0567\u056C. \u0570\u0561\u057D\u0581\u0565", + url: "URL", + emoji: "\u0567\u0574\u0578\u057B\u056B", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO \u0561\u0574\u057D\u0561\u0569\u056B\u057E \u0587 \u056A\u0561\u0574", + date: "ISO \u0561\u0574\u057D\u0561\u0569\u056B\u057E", + time: "ISO \u056A\u0561\u0574", + duration: "ISO \u057F\u0587\u0578\u0572\u0578\u0582\u0569\u0575\u0578\u0582\u0576", + ipv4: "IPv4 \u0570\u0561\u057D\u0581\u0565", + ipv6: "IPv6 \u0570\u0561\u057D\u0581\u0565", + cidrv4: "IPv4 \u0574\u056B\u057B\u0561\u056F\u0561\u0575\u0584", + cidrv6: "IPv6 \u0574\u056B\u057B\u0561\u056F\u0561\u0575\u0584", + base64: "base64 \u0571\u0587\u0561\u0579\u0561\u0583\u0578\u057E \u057F\u0578\u0572", + base64url: "base64url \u0571\u0587\u0561\u0579\u0561\u0583\u0578\u057E \u057F\u0578\u0572", + json_string: "JSON \u057F\u0578\u0572", + e164: "E.164 \u0570\u0561\u0574\u0561\u0580", + jwt: "JWT", + template_literal: "\u0574\u0578\u0582\u057F\u0584" + }; + const TypeDictionary = { + nan: "NaN", + number: "\u0569\u056B\u057E", + array: "\u0566\u0561\u0576\u0563\u057E\u0561\u056E" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 instanceof ${issue2.expected}, \u057D\u057F\u0561\u0581\u057E\u0565\u056C \u0567 ${received}`; + } + return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 ${expected}, \u057D\u057F\u0561\u0581\u057E\u0565\u056C \u0567 ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 ${stringifyPrimitive(issue2.values[1])}`; + return `\u054D\u056D\u0561\u056C \u057F\u0561\u0580\u0562\u0565\u0580\u0561\u056F\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 \u0570\u0565\u057F\u0587\u0575\u0561\u056C\u0576\u0565\u0580\u056B\u0581 \u0574\u0565\u056F\u0568\u055D ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) { + const maxValue = Number(issue2.maximum); + const unit = getArmenianPlural(maxValue, sizing.unit.one, sizing.unit.many); + return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0574\u0565\u056E \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle((_c = issue2.origin) != null ? _c : "\u0561\u0580\u056A\u0565\u0584")} \u056F\u0578\u0582\u0576\u0565\u0576\u0561 ${adj}${issue2.maximum.toString()} ${unit}`; + } + return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0574\u0565\u056E \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle((_d = issue2.origin) != null ? _d : "\u0561\u0580\u056A\u0565\u0584")} \u056C\u056B\u0576\u056B ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + const minValue = Number(issue2.minimum); + const unit = getArmenianPlural(minValue, sizing.unit.one, sizing.unit.many); + return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0583\u0578\u0584\u0580 \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle(issue2.origin)} \u056F\u0578\u0582\u0576\u0565\u0576\u0561 ${adj}${issue2.minimum.toString()} ${unit}`; + } + return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0583\u0578\u0584\u0580 \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle(issue2.origin)} \u056C\u056B\u0576\u056B ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u057D\u056F\u057D\u057E\u056B "${_issue.prefix}"-\u0578\u057E`; + if (_issue.format === "ends_with") + return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u0561\u057E\u0561\u0580\u057F\u057E\u056B "${_issue.suffix}"-\u0578\u057E`; + if (_issue.format === "includes") + return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u057A\u0561\u0580\u0578\u0582\u0576\u0561\u056F\u056B "${_issue.includes}"`; + if (_issue.format === "regex") + return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u0570\u0561\u0574\u0561\u057A\u0561\u057F\u0561\u057D\u056D\u0561\u0576\u056B ${_issue.pattern} \u0571\u0587\u0561\u0579\u0561\u0583\u056B\u0576`; + return `\u054D\u056D\u0561\u056C ${(_e = FormatDictionary[_issue.format]) != null ? _e : issue2.format}`; + } + case "not_multiple_of": + return `\u054D\u056D\u0561\u056C \u0569\u056B\u057E\u2024 \u057A\u0565\u057F\u0584 \u0567 \u0562\u0561\u0566\u0574\u0561\u057A\u0561\u057F\u056B\u056F \u056C\u056B\u0576\u056B ${issue2.divisor}-\u056B`; + case "unrecognized_keys": + return `\u0549\u0573\u0561\u0576\u0561\u0579\u057E\u0561\u056E \u0562\u0561\u0576\u0561\u056C\u056B${issue2.keys.length > 1 ? "\u0576\u0565\u0580" : ""}. ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `\u054D\u056D\u0561\u056C \u0562\u0561\u0576\u0561\u056C\u056B ${withDefiniteArticle(issue2.origin)}-\u0578\u0582\u0574`; + case "invalid_union": + return "\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574"; + case "invalid_element": + return `\u054D\u056D\u0561\u056C \u0561\u0580\u056A\u0565\u0584 ${withDefiniteArticle(issue2.origin)}-\u0578\u0582\u0574`; + default: + return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574`; + } + }; +}; +function hy_default() { + return { + localeError: error18() + }; +} + +// node_modules/zod/v4/locales/id.js +var error19 = () => { + const Sizable = { + string: { unit: "karakter", verb: "memiliki" }, + file: { unit: "byte", verb: "memiliki" }, + array: { unit: "item", verb: "memiliki" }, + set: { unit: "item", verb: "memiliki" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "input", + email: "alamat email", + url: "URL", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "tanggal dan waktu format ISO", + date: "tanggal format ISO", + time: "jam format ISO", + duration: "durasi format ISO", + ipv4: "alamat IPv4", + ipv6: "alamat IPv6", + cidrv4: "rentang alamat IPv4", + cidrv6: "rentang alamat IPv6", + base64: "string dengan enkode base64", + base64url: "string dengan enkode base64url", + json_string: "string JSON", + e164: "angka E.164", + jwt: "JWT", + template_literal: "input" + }; + const TypeDictionary = { + nan: "NaN" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `Input tidak valid: diharapkan instanceof ${issue2.expected}, diterima ${received}`; + } + return `Input tidak valid: diharapkan ${expected}, diterima ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `Input tidak valid: diharapkan ${stringifyPrimitive(issue2.values[0])}`; + return `Pilihan tidak valid: diharapkan salah satu dari ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `Terlalu besar: diharapkan ${(_c = issue2.origin) != null ? _c : "value"} memiliki ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elemen"}`; + return `Terlalu besar: diharapkan ${(_e = issue2.origin) != null ? _e : "value"} menjadi ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `Terlalu kecil: diharapkan ${issue2.origin} memiliki ${adj}${issue2.minimum.toString()} ${sizing.unit}`; + } + return `Terlalu kecil: diharapkan ${issue2.origin} menjadi ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `String tidak valid: harus dimulai dengan "${_issue.prefix}"`; + if (_issue.format === "ends_with") + return `String tidak valid: harus berakhir dengan "${_issue.suffix}"`; + if (_issue.format === "includes") + return `String tidak valid: harus menyertakan "${_issue.includes}"`; + if (_issue.format === "regex") + return `String tidak valid: harus sesuai pola ${_issue.pattern}`; + return `${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format} tidak valid`; + } + case "not_multiple_of": + return `Angka tidak valid: harus kelipatan dari ${issue2.divisor}`; + case "unrecognized_keys": + return `Kunci tidak dikenali ${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `Kunci tidak valid di ${issue2.origin}`; + case "invalid_union": + return "Input tidak valid"; + case "invalid_element": + return `Nilai tidak valid di ${issue2.origin}`; + default: + return `Input tidak valid`; + } + }; +}; +function id_default() { + return { + localeError: error19() + }; +} + +// node_modules/zod/v4/locales/is.js +var error20 = () => { + const Sizable = { + string: { unit: "stafi", verb: "a\xF0 hafa" }, + file: { unit: "b\xE6ti", verb: "a\xF0 hafa" }, + array: { unit: "hluti", verb: "a\xF0 hafa" }, + set: { unit: "hluti", verb: "a\xF0 hafa" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "gildi", + email: "netfang", + url: "vefsl\xF3\xF0", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO dagsetning og t\xEDmi", + date: "ISO dagsetning", + time: "ISO t\xEDmi", + duration: "ISO t\xEDmalengd", + ipv4: "IPv4 address", + ipv6: "IPv6 address", + cidrv4: "IPv4 range", + cidrv6: "IPv6 range", + base64: "base64-encoded strengur", + base64url: "base64url-encoded strengur", + json_string: "JSON strengur", + e164: "E.164 t\xF6lugildi", + jwt: "JWT", + template_literal: "gildi" + }; + const TypeDictionary = { + nan: "NaN", + number: "n\xFAmer", + array: "fylki" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `Rangt gildi: \xDE\xFA sl\xF3st inn ${received} \xFEar sem \xE1 a\xF0 vera instanceof ${issue2.expected}`; + } + return `Rangt gildi: \xDE\xFA sl\xF3st inn ${received} \xFEar sem \xE1 a\xF0 vera ${expected}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `Rangt gildi: gert r\xE1\xF0 fyrir ${stringifyPrimitive(issue2.values[0])}`; + return `\xD3gilt val: m\xE1 vera eitt af eftirfarandi ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `Of st\xF3rt: gert er r\xE1\xF0 fyrir a\xF0 ${(_c = issue2.origin) != null ? _c : "gildi"} hafi ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "hluti"}`; + return `Of st\xF3rt: gert er r\xE1\xF0 fyrir a\xF0 ${(_e = issue2.origin) != null ? _e : "gildi"} s\xE9 ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `Of l\xEDti\xF0: gert er r\xE1\xF0 fyrir a\xF0 ${issue2.origin} hafi ${adj}${issue2.minimum.toString()} ${sizing.unit}`; + } + return `Of l\xEDti\xF0: gert er r\xE1\xF0 fyrir a\xF0 ${issue2.origin} s\xE9 ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") { + return `\xD3gildur strengur: ver\xF0ur a\xF0 byrja \xE1 "${_issue.prefix}"`; + } + if (_issue.format === "ends_with") + return `\xD3gildur strengur: ver\xF0ur a\xF0 enda \xE1 "${_issue.suffix}"`; + if (_issue.format === "includes") + return `\xD3gildur strengur: ver\xF0ur a\xF0 innihalda "${_issue.includes}"`; + if (_issue.format === "regex") + return `\xD3gildur strengur: ver\xF0ur a\xF0 fylgja mynstri ${_issue.pattern}`; + return `Rangt ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format}`; + } + case "not_multiple_of": + return `R\xF6ng tala: ver\xF0ur a\xF0 vera margfeldi af ${issue2.divisor}`; + case "unrecognized_keys": + return `\xD3\xFEekkt ${issue2.keys.length > 1 ? "ir lyklar" : "ur lykill"}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `Rangur lykill \xED ${issue2.origin}`; + case "invalid_union": + return "Rangt gildi"; + case "invalid_element": + return `Rangt gildi \xED ${issue2.origin}`; + default: + return `Rangt gildi`; + } + }; +}; +function is_default() { + return { + localeError: error20() + }; +} + +// node_modules/zod/v4/locales/it.js +var error21 = () => { + const Sizable = { + string: { unit: "caratteri", verb: "avere" }, + file: { unit: "byte", verb: "avere" }, + array: { unit: "elementi", verb: "avere" }, + set: { unit: "elementi", verb: "avere" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "input", + email: "indirizzo email", + url: "URL", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "data e ora ISO", + date: "data ISO", + time: "ora ISO", + duration: "durata ISO", + ipv4: "indirizzo IPv4", + ipv6: "indirizzo IPv6", + cidrv4: "intervallo IPv4", + cidrv6: "intervallo IPv6", + base64: "stringa codificata in base64", + base64url: "URL codificata in base64", + json_string: "stringa JSON", + e164: "numero E.164", + jwt: "JWT", + template_literal: "input" + }; + const TypeDictionary = { + nan: "NaN", + number: "numero", + array: "vettore" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `Input non valido: atteso instanceof ${issue2.expected}, ricevuto ${received}`; + } + return `Input non valido: atteso ${expected}, ricevuto ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `Input non valido: atteso ${stringifyPrimitive(issue2.values[0])}`; + return `Opzione non valida: atteso uno tra ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `Troppo grande: ${(_c = issue2.origin) != null ? _c : "valore"} deve avere ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elementi"}`; + return `Troppo grande: ${(_e = issue2.origin) != null ? _e : "valore"} deve essere ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `Troppo piccolo: ${issue2.origin} deve avere ${adj}${issue2.minimum.toString()} ${sizing.unit}`; + } + return `Troppo piccolo: ${issue2.origin} deve essere ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `Stringa non valida: deve iniziare con "${_issue.prefix}"`; + if (_issue.format === "ends_with") + return `Stringa non valida: deve terminare con "${_issue.suffix}"`; + if (_issue.format === "includes") + return `Stringa non valida: deve includere "${_issue.includes}"`; + if (_issue.format === "regex") + return `Stringa non valida: deve corrispondere al pattern ${_issue.pattern}`; + return `Invalid ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format}`; + } + case "not_multiple_of": + return `Numero non valido: deve essere un multiplo di ${issue2.divisor}`; + case "unrecognized_keys": + return `Chiav${issue2.keys.length > 1 ? "i" : "e"} non riconosciut${issue2.keys.length > 1 ? "e" : "a"}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `Chiave non valida in ${issue2.origin}`; + case "invalid_union": + return "Input non valido"; + case "invalid_element": + return `Valore non valido in ${issue2.origin}`; + default: + return `Input non valido`; + } + }; +}; +function it_default() { + return { + localeError: error21() + }; +} + +// node_modules/zod/v4/locales/ja.js +var error22 = () => { + const Sizable = { + string: { unit: "\u6587\u5B57", verb: "\u3067\u3042\u308B" }, + file: { unit: "\u30D0\u30A4\u30C8", verb: "\u3067\u3042\u308B" }, + array: { unit: "\u8981\u7D20", verb: "\u3067\u3042\u308B" }, + set: { unit: "\u8981\u7D20", verb: "\u3067\u3042\u308B" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "\u5165\u529B\u5024", + email: "\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9", + url: "URL", + emoji: "\u7D75\u6587\u5B57", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO\u65E5\u6642", + date: "ISO\u65E5\u4ED8", + time: "ISO\u6642\u523B", + duration: "ISO\u671F\u9593", + ipv4: "IPv4\u30A2\u30C9\u30EC\u30B9", + ipv6: "IPv6\u30A2\u30C9\u30EC\u30B9", + cidrv4: "IPv4\u7BC4\u56F2", + cidrv6: "IPv6\u7BC4\u56F2", + base64: "base64\u30A8\u30F3\u30B3\u30FC\u30C9\u6587\u5B57\u5217", + base64url: "base64url\u30A8\u30F3\u30B3\u30FC\u30C9\u6587\u5B57\u5217", + json_string: "JSON\u6587\u5B57\u5217", + e164: "E.164\u756A\u53F7", + jwt: "JWT", + template_literal: "\u5165\u529B\u5024" + }; + const TypeDictionary = { + nan: "NaN", + number: "\u6570\u5024", + array: "\u914D\u5217" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `\u7121\u52B9\u306A\u5165\u529B: instanceof ${issue2.expected}\u304C\u671F\u5F85\u3055\u308C\u307E\u3057\u305F\u304C\u3001${received}\u304C\u5165\u529B\u3055\u308C\u307E\u3057\u305F`; + } + return `\u7121\u52B9\u306A\u5165\u529B: ${expected}\u304C\u671F\u5F85\u3055\u308C\u307E\u3057\u305F\u304C\u3001${received}\u304C\u5165\u529B\u3055\u308C\u307E\u3057\u305F`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `\u7121\u52B9\u306A\u5165\u529B: ${stringifyPrimitive(issue2.values[0])}\u304C\u671F\u5F85\u3055\u308C\u307E\u3057\u305F`; + return `\u7121\u52B9\u306A\u9078\u629E: ${joinValues(issue2.values, "\u3001")}\u306E\u3044\u305A\u308C\u304B\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`; + case "too_big": { + const adj = issue2.inclusive ? "\u4EE5\u4E0B\u3067\u3042\u308B" : "\u3088\u308A\u5C0F\u3055\u3044"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `\u5927\u304D\u3059\u304E\u308B\u5024: ${(_c = issue2.origin) != null ? _c : "\u5024"}\u306F${issue2.maximum.toString()}${(_d = sizing.unit) != null ? _d : "\u8981\u7D20"}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`; + return `\u5927\u304D\u3059\u304E\u308B\u5024: ${(_e = issue2.origin) != null ? _e : "\u5024"}\u306F${issue2.maximum.toString()}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`; + } + case "too_small": { + const adj = issue2.inclusive ? "\u4EE5\u4E0A\u3067\u3042\u308B" : "\u3088\u308A\u5927\u304D\u3044"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `\u5C0F\u3055\u3059\u304E\u308B\u5024: ${issue2.origin}\u306F${issue2.minimum.toString()}${sizing.unit}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`; + return `\u5C0F\u3055\u3059\u304E\u308B\u5024: ${issue2.origin}\u306F${issue2.minimum.toString()}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `\u7121\u52B9\u306A\u6587\u5B57\u5217: "${_issue.prefix}"\u3067\u59CB\u307E\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`; + if (_issue.format === "ends_with") + return `\u7121\u52B9\u306A\u6587\u5B57\u5217: "${_issue.suffix}"\u3067\u7D42\u308F\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`; + if (_issue.format === "includes") + return `\u7121\u52B9\u306A\u6587\u5B57\u5217: "${_issue.includes}"\u3092\u542B\u3080\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`; + if (_issue.format === "regex") + return `\u7121\u52B9\u306A\u6587\u5B57\u5217: \u30D1\u30BF\u30FC\u30F3${_issue.pattern}\u306B\u4E00\u81F4\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`; + return `\u7121\u52B9\u306A${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format}`; + } + case "not_multiple_of": + return `\u7121\u52B9\u306A\u6570\u5024: ${issue2.divisor}\u306E\u500D\u6570\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`; + case "unrecognized_keys": + return `\u8A8D\u8B58\u3055\u308C\u3066\u3044\u306A\u3044\u30AD\u30FC${issue2.keys.length > 1 ? "\u7FA4" : ""}: ${joinValues(issue2.keys, "\u3001")}`; + case "invalid_key": + return `${issue2.origin}\u5185\u306E\u7121\u52B9\u306A\u30AD\u30FC`; + case "invalid_union": + return "\u7121\u52B9\u306A\u5165\u529B"; + case "invalid_element": + return `${issue2.origin}\u5185\u306E\u7121\u52B9\u306A\u5024`; + default: + return `\u7121\u52B9\u306A\u5165\u529B`; + } + }; +}; +function ja_default2() { + return { + localeError: error22() + }; +} + +// node_modules/zod/v4/locales/ka.js +var error23 = () => { + const Sizable = { + string: { unit: "\u10E1\u10D8\u10DB\u10D1\u10DD\u10DA\u10DD", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" }, + file: { unit: "\u10D1\u10D0\u10D8\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" }, + array: { unit: "\u10D4\u10DA\u10D4\u10DB\u10D4\u10DC\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" }, + set: { unit: "\u10D4\u10DA\u10D4\u10DB\u10D4\u10DC\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "\u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0", + email: "\u10D4\u10DA-\u10E4\u10DD\u10E1\u10E2\u10D8\u10E1 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8", + url: "URL", + emoji: "\u10D4\u10DB\u10DD\u10EF\u10D8", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "\u10D7\u10D0\u10E0\u10D8\u10E6\u10D8-\u10D3\u10E0\u10DD", + date: "\u10D7\u10D0\u10E0\u10D8\u10E6\u10D8", + time: "\u10D3\u10E0\u10DD", + duration: "\u10EE\u10D0\u10DC\u10D2\u10E0\u10EB\u10DA\u10D8\u10D5\u10DD\u10D1\u10D0", + ipv4: "IPv4 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8", + ipv6: "IPv6 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8", + cidrv4: "IPv4 \u10D3\u10D8\u10D0\u10DE\u10D0\u10D6\u10DD\u10DC\u10D8", + cidrv6: "IPv6 \u10D3\u10D8\u10D0\u10DE\u10D0\u10D6\u10DD\u10DC\u10D8", + base64: "base64-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8", + base64url: "base64url-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8", + json_string: "JSON \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8", + e164: "E.164 \u10DC\u10DD\u10DB\u10D4\u10E0\u10D8", + jwt: "JWT", + template_literal: "\u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0" + }; + const TypeDictionary = { + nan: "NaN", + number: "\u10E0\u10D8\u10EA\u10EE\u10D5\u10D8", + string: "\u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8", + boolean: "\u10D1\u10E3\u10DA\u10D4\u10D0\u10DC\u10D8", + function: "\u10E4\u10E3\u10DC\u10E5\u10EA\u10D8\u10D0", + array: "\u10DB\u10D0\u10E1\u10D8\u10D5\u10D8" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 instanceof ${issue2.expected}, \u10DB\u10D8\u10E6\u10D4\u10D1\u10E3\u10DA\u10D8 ${received}`; + } + return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${expected}, \u10DB\u10D8\u10E6\u10D4\u10D1\u10E3\u10DA\u10D8 ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${stringifyPrimitive(issue2.values[0])}`; + return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D5\u10D0\u10E0\u10D8\u10D0\u10DC\u10E2\u10D8: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8\u10D0 \u10D4\u10E0\u10D7-\u10D4\u10E0\u10D7\u10D8 ${joinValues(issue2.values, "|")}-\u10D3\u10D0\u10DC`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10D3\u10D8\u10D3\u10D8: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${(_c = issue2.origin) != null ? _c : "\u10DB\u10DC\u10D8\u10E8\u10D5\u10DC\u10D4\u10DA\u10DD\u10D1\u10D0"} ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit}`; + return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10D3\u10D8\u10D3\u10D8: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${(_d = issue2.origin) != null ? _d : "\u10DB\u10DC\u10D8\u10E8\u10D5\u10DC\u10D4\u10DA\u10DD\u10D1\u10D0"} \u10D8\u10E7\u10DD\u10E1 ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10DE\u10D0\u10E2\u10D0\u10E0\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`; + } + return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10DE\u10D0\u10E2\u10D0\u10E0\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue2.origin} \u10D8\u10E7\u10DD\u10E1 ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") { + return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10D8\u10EC\u10E7\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 "${_issue.prefix}"-\u10D8\u10D7`; + } + if (_issue.format === "ends_with") + return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10DB\u10D7\u10D0\u10D5\u10E0\u10D3\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 "${_issue.suffix}"-\u10D8\u10D7`; + if (_issue.format === "includes") + return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1 "${_issue.includes}"-\u10E1`; + if (_issue.format === "regex") + return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D4\u10E1\u10D0\u10D1\u10D0\u10DB\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 \u10E8\u10D0\u10D1\u10DA\u10DD\u10DC\u10E1 ${_issue.pattern}`; + return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 ${(_e = FormatDictionary[_issue.format]) != null ? _e : issue2.format}`; + } + case "not_multiple_of": + return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E0\u10D8\u10EA\u10EE\u10D5\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10D8\u10E7\u10DD\u10E1 ${issue2.divisor}-\u10D8\u10E1 \u10EF\u10D4\u10E0\u10D0\u10D3\u10D8`; + case "unrecognized_keys": + return `\u10E3\u10EA\u10DC\u10DD\u10D1\u10D8 \u10D2\u10D0\u10E1\u10D0\u10E6\u10D4\u10D1${issue2.keys.length > 1 ? "\u10D4\u10D1\u10D8" : "\u10D8"}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D2\u10D0\u10E1\u10D0\u10E6\u10D4\u10D1\u10D8 ${issue2.origin}-\u10E8\u10D8`; + case "invalid_union": + return "\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0"; + case "invalid_element": + return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10DB\u10DC\u10D8\u10E8\u10D5\u10DC\u10D4\u10DA\u10DD\u10D1\u10D0 ${issue2.origin}-\u10E8\u10D8`; + default: + return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0`; + } + }; +}; +function ka_default() { + return { + localeError: error23() + }; +} + +// node_modules/zod/v4/locales/km.js +var error24 = () => { + const Sizable = { + string: { unit: "\u178F\u17BD\u17A2\u1780\u17D2\u179F\u179A", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" }, + file: { unit: "\u1794\u17C3", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" }, + array: { unit: "\u1792\u17B6\u178F\u17BB", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" }, + set: { unit: "\u1792\u17B6\u178F\u17BB", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B", + email: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793\u17A2\u17CA\u17B8\u1798\u17C2\u179B", + url: "URL", + emoji: "\u179F\u1789\u17D2\u1789\u17B6\u17A2\u17B6\u179A\u1798\u17D2\u1798\u178E\u17CD", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "\u1780\u17B6\u179B\u1794\u179A\u17B7\u1785\u17D2\u1786\u17C1\u1791 \u1793\u17B7\u1784\u1798\u17C9\u17C4\u1784 ISO", + date: "\u1780\u17B6\u179B\u1794\u179A\u17B7\u1785\u17D2\u1786\u17C1\u1791 ISO", + time: "\u1798\u17C9\u17C4\u1784 ISO", + duration: "\u179A\u1799\u17C8\u1796\u17C1\u179B ISO", + ipv4: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv4", + ipv6: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv6", + cidrv4: "\u178A\u17C2\u1793\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv4", + cidrv6: "\u178A\u17C2\u1793\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv6", + base64: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u17A2\u17CA\u17B7\u1780\u17BC\u178A base64", + base64url: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u17A2\u17CA\u17B7\u1780\u17BC\u178A base64url", + json_string: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A JSON", + e164: "\u179B\u17C1\u1781 E.164", + jwt: "JWT", + template_literal: "\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B" + }; + const TypeDictionary = { + nan: "NaN", + number: "\u179B\u17C1\u1781", + array: "\u17A2\u17B6\u179A\u17C1 (Array)", + null: "\u1782\u17D2\u1798\u17B6\u1793\u178F\u1798\u17D2\u179B\u17C3 (null)" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A instanceof ${issue2.expected} \u1794\u17C9\u17BB\u1793\u17D2\u178F\u17C2\u1791\u1791\u17BD\u179B\u1794\u17B6\u1793 ${received}`; + } + return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${expected} \u1794\u17C9\u17BB\u1793\u17D2\u178F\u17C2\u1791\u1791\u17BD\u179B\u1794\u17B6\u1793 ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${stringifyPrimitive(issue2.values[0])}`; + return `\u1787\u1798\u17D2\u179A\u17BE\u179F\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1787\u17B6\u1798\u17BD\u1799\u1780\u17D2\u1793\u17BB\u1784\u1785\u17C6\u178E\u17C4\u1798 ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `\u1792\u17C6\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${(_c = issue2.origin) != null ? _c : "\u178F\u1798\u17D2\u179B\u17C3"} ${adj} ${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\u1792\u17B6\u178F\u17BB"}`; + return `\u1792\u17C6\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${(_e = issue2.origin) != null ? _e : "\u178F\u1798\u17D2\u179B\u17C3"} ${adj} ${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `\u178F\u17BC\u1785\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue2.origin} ${adj} ${issue2.minimum.toString()} ${sizing.unit}`; + } + return `\u178F\u17BC\u1785\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue2.origin} ${adj} ${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") { + return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1785\u17B6\u1794\u17CB\u1795\u17D2\u178F\u17BE\u1798\u178A\u17C4\u1799 "${_issue.prefix}"`; + } + if (_issue.format === "ends_with") + return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1794\u1789\u17D2\u1785\u1794\u17CB\u178A\u17C4\u1799 "${_issue.suffix}"`; + if (_issue.format === "includes") + return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1798\u17B6\u1793 "${_issue.includes}"`; + if (_issue.format === "regex") + return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u178F\u17C2\u1795\u17D2\u1782\u17BC\u1795\u17D2\u1782\u1784\u1793\u17B9\u1784\u1791\u1798\u17D2\u179A\u1784\u17CB\u178A\u17C2\u179B\u1794\u17B6\u1793\u1780\u17C6\u178E\u178F\u17CB ${_issue.pattern}`; + return `\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format}`; + } + case "not_multiple_of": + return `\u179B\u17C1\u1781\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u178F\u17C2\u1787\u17B6\u1796\u17A0\u17BB\u1782\u17BB\u178E\u1793\u17C3 ${issue2.divisor}`; + case "unrecognized_keys": + return `\u179A\u1780\u1783\u17BE\u1789\u179F\u17C4\u1798\u17B7\u1793\u179F\u17D2\u1782\u17B6\u179B\u17CB\u17D6 ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `\u179F\u17C4\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u1793\u17C5\u1780\u17D2\u1793\u17BB\u1784 ${issue2.origin}`; + case "invalid_union": + return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C`; + case "invalid_element": + return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u1793\u17C5\u1780\u17D2\u1793\u17BB\u1784 ${issue2.origin}`; + default: + return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C`; + } + }; +}; +function km_default() { + return { + localeError: error24() + }; +} + +// node_modules/zod/v4/locales/kh.js +function kh_default() { + return km_default(); +} + +// node_modules/zod/v4/locales/ko.js +var error25 = () => { + const Sizable = { + string: { unit: "\uBB38\uC790", verb: "to have" }, + file: { unit: "\uBC14\uC774\uD2B8", verb: "to have" }, + array: { unit: "\uAC1C", verb: "to have" }, + set: { unit: "\uAC1C", verb: "to have" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "\uC785\uB825", + email: "\uC774\uBA54\uC77C \uC8FC\uC18C", + url: "URL", + emoji: "\uC774\uBAA8\uC9C0", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO \uB0A0\uC9DC\uC2DC\uAC04", + date: "ISO \uB0A0\uC9DC", + time: "ISO \uC2DC\uAC04", + duration: "ISO \uAE30\uAC04", + ipv4: "IPv4 \uC8FC\uC18C", + ipv6: "IPv6 \uC8FC\uC18C", + cidrv4: "IPv4 \uBC94\uC704", + cidrv6: "IPv6 \uBC94\uC704", + base64: "base64 \uC778\uCF54\uB529 \uBB38\uC790\uC5F4", + base64url: "base64url \uC778\uCF54\uB529 \uBB38\uC790\uC5F4", + json_string: "JSON \uBB38\uC790\uC5F4", + e164: "E.164 \uBC88\uD638", + jwt: "JWT", + template_literal: "\uC785\uB825" + }; + const TypeDictionary = { + nan: "NaN" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f, _g, _h, _i; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `\uC798\uBABB\uB41C \uC785\uB825: \uC608\uC0C1 \uD0C0\uC785\uC740 instanceof ${issue2.expected}, \uBC1B\uC740 \uD0C0\uC785\uC740 ${received}\uC785\uB2C8\uB2E4`; + } + return `\uC798\uBABB\uB41C \uC785\uB825: \uC608\uC0C1 \uD0C0\uC785\uC740 ${expected}, \uBC1B\uC740 \uD0C0\uC785\uC740 ${received}\uC785\uB2C8\uB2E4`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `\uC798\uBABB\uB41C \uC785\uB825: \uAC12\uC740 ${stringifyPrimitive(issue2.values[0])} \uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4`; + return `\uC798\uBABB\uB41C \uC635\uC158: ${joinValues(issue2.values, "\uB610\uB294 ")} \uC911 \uD558\uB098\uC5EC\uC57C \uD569\uB2C8\uB2E4`; + case "too_big": { + const adj = issue2.inclusive ? "\uC774\uD558" : "\uBBF8\uB9CC"; + const suffix = adj === "\uBBF8\uB9CC" ? "\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4" : "\uC5EC\uC57C \uD569\uB2C8\uB2E4"; + const sizing = getSizing(issue2.origin); + const unit = (_c = sizing == null ? void 0 : sizing.unit) != null ? _c : "\uC694\uC18C"; + if (sizing) + return `${(_d = issue2.origin) != null ? _d : "\uAC12"}\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4: ${issue2.maximum.toString()}${unit} ${adj}${suffix}`; + return `${(_e = issue2.origin) != null ? _e : "\uAC12"}\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4: ${issue2.maximum.toString()} ${adj}${suffix}`; + } + case "too_small": { + const adj = issue2.inclusive ? "\uC774\uC0C1" : "\uCD08\uACFC"; + const suffix = adj === "\uC774\uC0C1" ? "\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4" : "\uC5EC\uC57C \uD569\uB2C8\uB2E4"; + const sizing = getSizing(issue2.origin); + const unit = (_f = sizing == null ? void 0 : sizing.unit) != null ? _f : "\uC694\uC18C"; + if (sizing) { + return `${(_g = issue2.origin) != null ? _g : "\uAC12"}\uC774 \uB108\uBB34 \uC791\uC2B5\uB2C8\uB2E4: ${issue2.minimum.toString()}${unit} ${adj}${suffix}`; + } + return `${(_h = issue2.origin) != null ? _h : "\uAC12"}\uC774 \uB108\uBB34 \uC791\uC2B5\uB2C8\uB2E4: ${issue2.minimum.toString()} ${adj}${suffix}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") { + return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: "${_issue.prefix}"(\uC73C)\uB85C \uC2DC\uC791\uD574\uC57C \uD569\uB2C8\uB2E4`; + } + if (_issue.format === "ends_with") + return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: "${_issue.suffix}"(\uC73C)\uB85C \uB05D\uB098\uC57C \uD569\uB2C8\uB2E4`; + if (_issue.format === "includes") + return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: "${_issue.includes}"\uC744(\uB97C) \uD3EC\uD568\uD574\uC57C \uD569\uB2C8\uB2E4`; + if (_issue.format === "regex") + return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: \uC815\uADDC\uC2DD ${_issue.pattern} \uD328\uD134\uACFC \uC77C\uCE58\uD574\uC57C \uD569\uB2C8\uB2E4`; + return `\uC798\uBABB\uB41C ${(_i = FormatDictionary[_issue.format]) != null ? _i : issue2.format}`; + } + case "not_multiple_of": + return `\uC798\uBABB\uB41C \uC22B\uC790: ${issue2.divisor}\uC758 \uBC30\uC218\uC5EC\uC57C \uD569\uB2C8\uB2E4`; + case "unrecognized_keys": + return `\uC778\uC2DD\uD560 \uC218 \uC5C6\uB294 \uD0A4: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `\uC798\uBABB\uB41C \uD0A4: ${issue2.origin}`; + case "invalid_union": + return `\uC798\uBABB\uB41C \uC785\uB825`; + case "invalid_element": + return `\uC798\uBABB\uB41C \uAC12: ${issue2.origin}`; + default: + return `\uC798\uBABB\uB41C \uC785\uB825`; + } + }; +}; +function ko_default2() { + return { + localeError: error25() + }; +} + +// node_modules/zod/v4/locales/lt.js +var capitalizeFirstCharacter = (text) => { + return text.charAt(0).toUpperCase() + text.slice(1); +}; +function getUnitTypeFromNumber(number5) { + const abs = Math.abs(number5); + const last = abs % 10; + const last2 = abs % 100; + if (last2 >= 11 && last2 <= 19 || last === 0) + return "many"; + if (last === 1) + return "one"; + return "few"; +} +var error26 = () => { + const Sizable = { + string: { + unit: { + one: "simbolis", + few: "simboliai", + many: "simboli\u0173" + }, + verb: { + smaller: { + inclusive: "turi b\u016Bti ne ilgesn\u0117 kaip", + notInclusive: "turi b\u016Bti trumpesn\u0117 kaip" + }, + bigger: { + inclusive: "turi b\u016Bti ne trumpesn\u0117 kaip", + notInclusive: "turi b\u016Bti ilgesn\u0117 kaip" + } + } + }, + file: { + unit: { + one: "baitas", + few: "baitai", + many: "bait\u0173" + }, + verb: { + smaller: { + inclusive: "turi b\u016Bti ne didesnis kaip", + notInclusive: "turi b\u016Bti ma\u017Eesnis kaip" + }, + bigger: { + inclusive: "turi b\u016Bti ne ma\u017Eesnis kaip", + notInclusive: "turi b\u016Bti didesnis kaip" + } + } + }, + array: { + unit: { + one: "element\u0105", + few: "elementus", + many: "element\u0173" + }, + verb: { + smaller: { + inclusive: "turi tur\u0117ti ne daugiau kaip", + notInclusive: "turi tur\u0117ti ma\u017Eiau kaip" + }, + bigger: { + inclusive: "turi tur\u0117ti ne ma\u017Eiau kaip", + notInclusive: "turi tur\u0117ti daugiau kaip" + } + } + }, + set: { + unit: { + one: "element\u0105", + few: "elementus", + many: "element\u0173" + }, + verb: { + smaller: { + inclusive: "turi tur\u0117ti ne daugiau kaip", + notInclusive: "turi tur\u0117ti ma\u017Eiau kaip" + }, + bigger: { + inclusive: "turi tur\u0117ti ne ma\u017Eiau kaip", + notInclusive: "turi tur\u0117ti daugiau kaip" + } + } + } + }; + function getSizing(origin, unitType, inclusive, targetShouldBe) { + var _a3; + const result = (_a3 = Sizable[origin]) != null ? _a3 : null; + if (result === null) + return result; + return { + unit: result.unit[unitType], + verb: result.verb[targetShouldBe][inclusive ? "inclusive" : "notInclusive"] + }; + } + const FormatDictionary = { + regex: "\u012Fvestis", + email: "el. pa\u0161to adresas", + url: "URL", + emoji: "jaustukas", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO data ir laikas", + date: "ISO data", + time: "ISO laikas", + duration: "ISO trukm\u0117", + ipv4: "IPv4 adresas", + ipv6: "IPv6 adresas", + cidrv4: "IPv4 tinklo prefiksas (CIDR)", + cidrv6: "IPv6 tinklo prefiksas (CIDR)", + base64: "base64 u\u017Ekoduota eilut\u0117", + base64url: "base64url u\u017Ekoduota eilut\u0117", + json_string: "JSON eilut\u0117", + e164: "E.164 numeris", + jwt: "JWT", + template_literal: "\u012Fvestis" + }; + const TypeDictionary = { + nan: "NaN", + number: "skai\u010Dius", + bigint: "sveikasis skai\u010Dius", + string: "eilut\u0117", + boolean: "login\u0117 reik\u0161m\u0117", + undefined: "neapibr\u0117\u017Eta reik\u0161m\u0117", + function: "funkcija", + symbol: "simbolis", + array: "masyvas", + object: "objektas", + null: "nulin\u0117 reik\u0161m\u0117" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f, _g, _h, _i, _j2, _k, _l, _m, _n, _o; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `Gautas tipas ${received}, o tik\u0117tasi - instanceof ${issue2.expected}`; + } + return `Gautas tipas ${received}, o tik\u0117tasi - ${expected}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `Privalo b\u016Bti ${stringifyPrimitive(issue2.values[0])}`; + return `Privalo b\u016Bti vienas i\u0161 ${joinValues(issue2.values, "|")} pasirinkim\u0173`; + case "too_big": { + const origin = (_c = TypeDictionary[issue2.origin]) != null ? _c : issue2.origin; + const sizing = getSizing(issue2.origin, getUnitTypeFromNumber(Number(issue2.maximum)), (_d = issue2.inclusive) != null ? _d : false, "smaller"); + if (sizing == null ? void 0 : sizing.verb) + return `${capitalizeFirstCharacter((_e = origin != null ? origin : issue2.origin) != null ? _e : "reik\u0161m\u0117")} ${sizing.verb} ${issue2.maximum.toString()} ${(_f = sizing.unit) != null ? _f : "element\u0173"}`; + const adj = issue2.inclusive ? "ne didesnis kaip" : "ma\u017Eesnis kaip"; + return `${capitalizeFirstCharacter((_g = origin != null ? origin : issue2.origin) != null ? _g : "reik\u0161m\u0117")} turi b\u016Bti ${adj} ${issue2.maximum.toString()} ${sizing == null ? void 0 : sizing.unit}`; + } + case "too_small": { + const origin = (_h = TypeDictionary[issue2.origin]) != null ? _h : issue2.origin; + const sizing = getSizing(issue2.origin, getUnitTypeFromNumber(Number(issue2.minimum)), (_i = issue2.inclusive) != null ? _i : false, "bigger"); + if (sizing == null ? void 0 : sizing.verb) + return `${capitalizeFirstCharacter((_j2 = origin != null ? origin : issue2.origin) != null ? _j2 : "reik\u0161m\u0117")} ${sizing.verb} ${issue2.minimum.toString()} ${(_k = sizing.unit) != null ? _k : "element\u0173"}`; + const adj = issue2.inclusive ? "ne ma\u017Eesnis kaip" : "didesnis kaip"; + return `${capitalizeFirstCharacter((_l = origin != null ? origin : issue2.origin) != null ? _l : "reik\u0161m\u0117")} turi b\u016Bti ${adj} ${issue2.minimum.toString()} ${sizing == null ? void 0 : sizing.unit}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") { + return `Eilut\u0117 privalo prasid\u0117ti "${_issue.prefix}"`; + } + if (_issue.format === "ends_with") + return `Eilut\u0117 privalo pasibaigti "${_issue.suffix}"`; + if (_issue.format === "includes") + return `Eilut\u0117 privalo \u012Ftraukti "${_issue.includes}"`; + if (_issue.format === "regex") + return `Eilut\u0117 privalo atitikti ${_issue.pattern}`; + return `Neteisingas ${(_m = FormatDictionary[_issue.format]) != null ? _m : issue2.format}`; + } + case "not_multiple_of": + return `Skai\u010Dius privalo b\u016Bti ${issue2.divisor} kartotinis.`; + case "unrecognized_keys": + return `Neatpa\u017Eint${issue2.keys.length > 1 ? "i" : "as"} rakt${issue2.keys.length > 1 ? "ai" : "as"}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return "Rastas klaidingas raktas"; + case "invalid_union": + return "Klaidinga \u012Fvestis"; + case "invalid_element": { + const origin = (_n = TypeDictionary[issue2.origin]) != null ? _n : issue2.origin; + return `${capitalizeFirstCharacter((_o = origin != null ? origin : issue2.origin) != null ? _o : "reik\u0161m\u0117")} turi klaiding\u0105 \u012Fvest\u012F`; + } + default: + return "Klaidinga \u012Fvestis"; + } + }; +}; +function lt_default() { + return { + localeError: error26() + }; +} + +// node_modules/zod/v4/locales/mk.js +var error27 = () => { + const Sizable = { + string: { unit: "\u0437\u043D\u0430\u0446\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" }, + file: { unit: "\u0431\u0430\u0458\u0442\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" }, + array: { unit: "\u0441\u0442\u0430\u0432\u043A\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" }, + set: { unit: "\u0441\u0442\u0430\u0432\u043A\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "\u0432\u043D\u0435\u0441", + email: "\u0430\u0434\u0440\u0435\u0441\u0430 \u043D\u0430 \u0435-\u043F\u043E\u0448\u0442\u0430", + url: "URL", + emoji: "\u0435\u043C\u043E\u045F\u0438", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO \u0434\u0430\u0442\u0443\u043C \u0438 \u0432\u0440\u0435\u043C\u0435", + date: "ISO \u0434\u0430\u0442\u0443\u043C", + time: "ISO \u0432\u0440\u0435\u043C\u0435", + duration: "ISO \u0432\u0440\u0435\u043C\u0435\u0442\u0440\u0430\u0435\u045A\u0435", + ipv4: "IPv4 \u0430\u0434\u0440\u0435\u0441\u0430", + ipv6: "IPv6 \u0430\u0434\u0440\u0435\u0441\u0430", + cidrv4: "IPv4 \u043E\u043F\u0441\u0435\u0433", + cidrv6: "IPv6 \u043E\u043F\u0441\u0435\u0433", + base64: "base64-\u0435\u043D\u043A\u043E\u0434\u0438\u0440\u0430\u043D\u0430 \u043D\u0438\u0437\u0430", + base64url: "base64url-\u0435\u043D\u043A\u043E\u0434\u0438\u0440\u0430\u043D\u0430 \u043D\u0438\u0437\u0430", + json_string: "JSON \u043D\u0438\u0437\u0430", + e164: "E.164 \u0431\u0440\u043E\u0458", + jwt: "JWT", + template_literal: "\u0432\u043D\u0435\u0441" + }; + const TypeDictionary = { + nan: "NaN", + number: "\u0431\u0440\u043E\u0458", + array: "\u043D\u0438\u0437\u0430" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 instanceof ${issue2.expected}, \u043F\u0440\u0438\u043C\u0435\u043D\u043E ${received}`; + } + return `\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${expected}, \u043F\u0440\u0438\u043C\u0435\u043D\u043E ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `Invalid input: expected ${stringifyPrimitive(issue2.values[0])}`; + return `\u0413\u0440\u0435\u0448\u0430\u043D\u0430 \u043E\u043F\u0446\u0438\u0458\u0430: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 \u0435\u0434\u043D\u0430 ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u0433\u043E\u043B\u0435\u043C: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${(_c = issue2.origin) != null ? _c : "\u0432\u0440\u0435\u0434\u043D\u043E\u0441\u0442\u0430"} \u0434\u0430 \u0438\u043C\u0430 ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0438"}`; + return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u0433\u043E\u043B\u0435\u043C: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${(_e = issue2.origin) != null ? _e : "\u0432\u0440\u0435\u0434\u043D\u043E\u0441\u0442\u0430"} \u0434\u0430 \u0431\u0438\u0434\u0435 ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u043C\u0430\u043B: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue2.origin} \u0434\u0430 \u0438\u043C\u0430 ${adj}${issue2.minimum.toString()} ${sizing.unit}`; + } + return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u043C\u0430\u043B: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue2.origin} \u0434\u0430 \u0431\u0438\u0434\u0435 ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") { + return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0437\u0430\u043F\u043E\u0447\u043D\u0443\u0432\u0430 \u0441\u043E "${_issue.prefix}"`; + } + if (_issue.format === "ends_with") + return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0437\u0430\u0432\u0440\u0448\u0443\u0432\u0430 \u0441\u043E "${_issue.suffix}"`; + if (_issue.format === "includes") + return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0432\u043A\u043B\u0443\u0447\u0443\u0432\u0430 "${_issue.includes}"`; + if (_issue.format === "regex") + return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u043E\u0434\u0433\u043E\u0430\u0440\u0430 \u043D\u0430 \u043F\u0430\u0442\u0435\u0440\u043D\u043E\u0442 ${_issue.pattern}`; + return `Invalid ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format}`; + } + case "not_multiple_of": + return `\u0413\u0440\u0435\u0448\u0435\u043D \u0431\u0440\u043E\u0458: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0431\u0438\u0434\u0435 \u0434\u0435\u043B\u0438\u0432 \u0441\u043E ${issue2.divisor}`; + case "unrecognized_keys": + return `${issue2.keys.length > 1 ? "\u041D\u0435\u043F\u0440\u0435\u043F\u043E\u0437\u043D\u0430\u0435\u043D\u0438 \u043A\u043B\u0443\u0447\u0435\u0432\u0438" : "\u041D\u0435\u043F\u0440\u0435\u043F\u043E\u0437\u043D\u0430\u0435\u043D \u043A\u043B\u0443\u0447"}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `\u0413\u0440\u0435\u0448\u0435\u043D \u043A\u043B\u0443\u0447 \u0432\u043E ${issue2.origin}`; + case "invalid_union": + return "\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441"; + case "invalid_element": + return `\u0413\u0440\u0435\u0448\u043D\u0430 \u0432\u0440\u0435\u0434\u043D\u043E\u0441\u0442 \u0432\u043E ${issue2.origin}`; + default: + return `\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441`; + } + }; +}; +function mk_default() { + return { + localeError: error27() + }; +} + +// node_modules/zod/v4/locales/ms.js +var error28 = () => { + const Sizable = { + string: { unit: "aksara", verb: "mempunyai" }, + file: { unit: "bait", verb: "mempunyai" }, + array: { unit: "elemen", verb: "mempunyai" }, + set: { unit: "elemen", verb: "mempunyai" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "input", + email: "alamat e-mel", + url: "URL", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "tarikh masa ISO", + date: "tarikh ISO", + time: "masa ISO", + duration: "tempoh ISO", + ipv4: "alamat IPv4", + ipv6: "alamat IPv6", + cidrv4: "julat IPv4", + cidrv6: "julat IPv6", + base64: "string dikodkan base64", + base64url: "string dikodkan base64url", + json_string: "string JSON", + e164: "nombor E.164", + jwt: "JWT", + template_literal: "input" + }; + const TypeDictionary = { + nan: "NaN", + number: "nombor" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `Input tidak sah: dijangka instanceof ${issue2.expected}, diterima ${received}`; + } + return `Input tidak sah: dijangka ${expected}, diterima ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `Input tidak sah: dijangka ${stringifyPrimitive(issue2.values[0])}`; + return `Pilihan tidak sah: dijangka salah satu daripada ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `Terlalu besar: dijangka ${(_c = issue2.origin) != null ? _c : "nilai"} ${sizing.verb} ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elemen"}`; + return `Terlalu besar: dijangka ${(_e = issue2.origin) != null ? _e : "nilai"} adalah ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `Terlalu kecil: dijangka ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`; + } + return `Terlalu kecil: dijangka ${issue2.origin} adalah ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `String tidak sah: mesti bermula dengan "${_issue.prefix}"`; + if (_issue.format === "ends_with") + return `String tidak sah: mesti berakhir dengan "${_issue.suffix}"`; + if (_issue.format === "includes") + return `String tidak sah: mesti mengandungi "${_issue.includes}"`; + if (_issue.format === "regex") + return `String tidak sah: mesti sepadan dengan corak ${_issue.pattern}`; + return `${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format} tidak sah`; + } + case "not_multiple_of": + return `Nombor tidak sah: perlu gandaan ${issue2.divisor}`; + case "unrecognized_keys": + return `Kunci tidak dikenali: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `Kunci tidak sah dalam ${issue2.origin}`; + case "invalid_union": + return "Input tidak sah"; + case "invalid_element": + return `Nilai tidak sah dalam ${issue2.origin}`; + default: + return `Input tidak sah`; + } + }; +}; +function ms_default() { + return { + localeError: error28() + }; +} + +// node_modules/zod/v4/locales/nl.js +var error29 = () => { + const Sizable = { + string: { unit: "tekens", verb: "heeft" }, + file: { unit: "bytes", verb: "heeft" }, + array: { unit: "elementen", verb: "heeft" }, + set: { unit: "elementen", verb: "heeft" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "invoer", + email: "emailadres", + url: "URL", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO datum en tijd", + date: "ISO datum", + time: "ISO tijd", + duration: "ISO duur", + ipv4: "IPv4-adres", + ipv6: "IPv6-adres", + cidrv4: "IPv4-bereik", + cidrv6: "IPv6-bereik", + base64: "base64-gecodeerde tekst", + base64url: "base64 URL-gecodeerde tekst", + json_string: "JSON string", + e164: "E.164-nummer", + jwt: "JWT", + template_literal: "invoer" + }; + const TypeDictionary = { + nan: "NaN", + number: "getal" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `Ongeldige invoer: verwacht instanceof ${issue2.expected}, ontving ${received}`; + } + return `Ongeldige invoer: verwacht ${expected}, ontving ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `Ongeldige invoer: verwacht ${stringifyPrimitive(issue2.values[0])}`; + return `Ongeldige optie: verwacht \xE9\xE9n van ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + const longName = issue2.origin === "date" ? "laat" : issue2.origin === "string" ? "lang" : "groot"; + if (sizing) + return `Te ${longName}: verwacht dat ${(_c = issue2.origin) != null ? _c : "waarde"} ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elementen"} ${sizing.verb}`; + return `Te ${longName}: verwacht dat ${(_e = issue2.origin) != null ? _e : "waarde"} ${adj}${issue2.maximum.toString()} is`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + const shortName = issue2.origin === "date" ? "vroeg" : issue2.origin === "string" ? "kort" : "klein"; + if (sizing) { + return `Te ${shortName}: verwacht dat ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit} ${sizing.verb}`; + } + return `Te ${shortName}: verwacht dat ${issue2.origin} ${adj}${issue2.minimum.toString()} is`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") { + return `Ongeldige tekst: moet met "${_issue.prefix}" beginnen`; + } + if (_issue.format === "ends_with") + return `Ongeldige tekst: moet op "${_issue.suffix}" eindigen`; + if (_issue.format === "includes") + return `Ongeldige tekst: moet "${_issue.includes}" bevatten`; + if (_issue.format === "regex") + return `Ongeldige tekst: moet overeenkomen met patroon ${_issue.pattern}`; + return `Ongeldig: ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format}`; + } + case "not_multiple_of": + return `Ongeldig getal: moet een veelvoud van ${issue2.divisor} zijn`; + case "unrecognized_keys": + return `Onbekende key${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `Ongeldige key in ${issue2.origin}`; + case "invalid_union": + return "Ongeldige invoer"; + case "invalid_element": + return `Ongeldige waarde in ${issue2.origin}`; + default: + return `Ongeldige invoer`; + } + }; +}; +function nl_default() { + return { + localeError: error29() + }; +} + +// node_modules/zod/v4/locales/no.js +var error30 = () => { + const Sizable = { + string: { unit: "tegn", verb: "\xE5 ha" }, + file: { unit: "bytes", verb: "\xE5 ha" }, + array: { unit: "elementer", verb: "\xE5 inneholde" }, + set: { unit: "elementer", verb: "\xE5 inneholde" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "input", + email: "e-postadresse", + url: "URL", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO dato- og klokkeslett", + date: "ISO-dato", + time: "ISO-klokkeslett", + duration: "ISO-varighet", + ipv4: "IPv4-omr\xE5de", + ipv6: "IPv6-omr\xE5de", + cidrv4: "IPv4-spekter", + cidrv6: "IPv6-spekter", + base64: "base64-enkodet streng", + base64url: "base64url-enkodet streng", + json_string: "JSON-streng", + e164: "E.164-nummer", + jwt: "JWT", + template_literal: "input" + }; + const TypeDictionary = { + nan: "NaN", + number: "tall", + array: "liste" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `Ugyldig input: forventet instanceof ${issue2.expected}, fikk ${received}`; + } + return `Ugyldig input: forventet ${expected}, fikk ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `Ugyldig verdi: forventet ${stringifyPrimitive(issue2.values[0])}`; + return `Ugyldig valg: forventet en av ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `For stor(t): forventet ${(_c = issue2.origin) != null ? _c : "value"} til \xE5 ha ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elementer"}`; + return `For stor(t): forventet ${(_e = issue2.origin) != null ? _e : "value"} til \xE5 ha ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `For lite(n): forventet ${issue2.origin} til \xE5 ha ${adj}${issue2.minimum.toString()} ${sizing.unit}`; + } + return `For lite(n): forventet ${issue2.origin} til \xE5 ha ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `Ugyldig streng: m\xE5 starte med "${_issue.prefix}"`; + if (_issue.format === "ends_with") + return `Ugyldig streng: m\xE5 ende med "${_issue.suffix}"`; + if (_issue.format === "includes") + return `Ugyldig streng: m\xE5 inneholde "${_issue.includes}"`; + if (_issue.format === "regex") + return `Ugyldig streng: m\xE5 matche m\xF8nsteret ${_issue.pattern}`; + return `Ugyldig ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format}`; + } + case "not_multiple_of": + return `Ugyldig tall: m\xE5 v\xE6re et multiplum av ${issue2.divisor}`; + case "unrecognized_keys": + return `${issue2.keys.length > 1 ? "Ukjente n\xF8kler" : "Ukjent n\xF8kkel"}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `Ugyldig n\xF8kkel i ${issue2.origin}`; + case "invalid_union": + return "Ugyldig input"; + case "invalid_element": + return `Ugyldig verdi i ${issue2.origin}`; + default: + return `Ugyldig input`; + } + }; +}; +function no_default() { + return { + localeError: error30() + }; +} + +// node_modules/zod/v4/locales/ota.js +var error31 = () => { + const Sizable = { + string: { unit: "harf", verb: "olmal\u0131d\u0131r" }, + file: { unit: "bayt", verb: "olmal\u0131d\u0131r" }, + array: { unit: "unsur", verb: "olmal\u0131d\u0131r" }, + set: { unit: "unsur", verb: "olmal\u0131d\u0131r" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "giren", + email: "epostag\xE2h", + url: "URL", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO heng\xE2m\u0131", + date: "ISO tarihi", + time: "ISO zaman\u0131", + duration: "ISO m\xFCddeti", + ipv4: "IPv4 ni\u015F\xE2n\u0131", + ipv6: "IPv6 ni\u015F\xE2n\u0131", + cidrv4: "IPv4 menzili", + cidrv6: "IPv6 menzili", + base64: "base64-\u015Fifreli metin", + base64url: "base64url-\u015Fifreli metin", + json_string: "JSON metin", + e164: "E.164 say\u0131s\u0131", + jwt: "JWT", + template_literal: "giren" + }; + const TypeDictionary = { + nan: "NaN", + number: "numara", + array: "saf", + null: "gayb" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `F\xE2sit giren: umulan instanceof ${issue2.expected}, al\u0131nan ${received}`; + } + return `F\xE2sit giren: umulan ${expected}, al\u0131nan ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `F\xE2sit giren: umulan ${stringifyPrimitive(issue2.values[0])}`; + return `F\xE2sit tercih: m\xFBteberler ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `Fazla b\xFCy\xFCk: ${(_c = issue2.origin) != null ? _c : "value"}, ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elements"} sahip olmal\u0131yd\u0131.`; + return `Fazla b\xFCy\xFCk: ${(_e = issue2.origin) != null ? _e : "value"}, ${adj}${issue2.maximum.toString()} olmal\u0131yd\u0131.`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `Fazla k\xFC\xE7\xFCk: ${issue2.origin}, ${adj}${issue2.minimum.toString()} ${sizing.unit} sahip olmal\u0131yd\u0131.`; + } + return `Fazla k\xFC\xE7\xFCk: ${issue2.origin}, ${adj}${issue2.minimum.toString()} olmal\u0131yd\u0131.`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `F\xE2sit metin: "${_issue.prefix}" ile ba\u015Flamal\u0131.`; + if (_issue.format === "ends_with") + return `F\xE2sit metin: "${_issue.suffix}" ile bitmeli.`; + if (_issue.format === "includes") + return `F\xE2sit metin: "${_issue.includes}" ihtiv\xE2 etmeli.`; + if (_issue.format === "regex") + return `F\xE2sit metin: ${_issue.pattern} nak\u015F\u0131na uymal\u0131.`; + return `F\xE2sit ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format}`; + } + case "not_multiple_of": + return `F\xE2sit say\u0131: ${issue2.divisor} kat\u0131 olmal\u0131yd\u0131.`; + case "unrecognized_keys": + return `Tan\u0131nmayan anahtar ${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `${issue2.origin} i\xE7in tan\u0131nmayan anahtar var.`; + case "invalid_union": + return "Giren tan\u0131namad\u0131."; + case "invalid_element": + return `${issue2.origin} i\xE7in tan\u0131nmayan k\u0131ymet var.`; + default: + return `K\u0131ymet tan\u0131namad\u0131.`; + } + }; +}; +function ota_default() { + return { + localeError: error31() + }; +} + +// node_modules/zod/v4/locales/ps.js +var error32 = () => { + const Sizable = { + string: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" }, + file: { unit: "\u0628\u0627\u06CC\u067C\u0633", verb: "\u0648\u0644\u0631\u064A" }, + array: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" }, + set: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "\u0648\u0631\u0648\u062F\u064A", + email: "\u0628\u0631\u06CC\u069A\u0646\u0627\u0644\u06CC\u06A9", + url: "\u06CC\u0648 \u0622\u0631 \u0627\u0644", + emoji: "\u0627\u06CC\u0645\u0648\u062C\u064A", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "\u0646\u06CC\u067C\u0647 \u0627\u0648 \u0648\u062E\u062A", + date: "\u0646\u06D0\u067C\u0647", + time: "\u0648\u062E\u062A", + duration: "\u0645\u0648\u062F\u0647", + ipv4: "\u062F IPv4 \u067E\u062A\u0647", + ipv6: "\u062F IPv6 \u067E\u062A\u0647", + cidrv4: "\u062F IPv4 \u0633\u0627\u062D\u0647", + cidrv6: "\u062F IPv6 \u0633\u0627\u062D\u0647", + base64: "base64-encoded \u0645\u062A\u0646", + base64url: "base64url-encoded \u0645\u062A\u0646", + json_string: "JSON \u0645\u062A\u0646", + e164: "\u062F E.164 \u0634\u0645\u06D0\u0631\u0647", + jwt: "JWT", + template_literal: "\u0648\u0631\u0648\u062F\u064A" + }; + const TypeDictionary = { + nan: "NaN", + number: "\u0639\u062F\u062F", + array: "\u0627\u0631\u06D0" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `\u0646\u0627\u0633\u0645 \u0648\u0631\u0648\u062F\u064A: \u0628\u0627\u06CC\u062F instanceof ${issue2.expected} \u0648\u0627\u06CC, \u0645\u06AB\u0631 ${received} \u062A\u0631\u0644\u0627\u0633\u0647 \u0634\u0648`; + } + return `\u0646\u0627\u0633\u0645 \u0648\u0631\u0648\u062F\u064A: \u0628\u0627\u06CC\u062F ${expected} \u0648\u0627\u06CC, \u0645\u06AB\u0631 ${received} \u062A\u0631\u0644\u0627\u0633\u0647 \u0634\u0648`; + } + case "invalid_value": + if (issue2.values.length === 1) { + return `\u0646\u0627\u0633\u0645 \u0648\u0631\u0648\u062F\u064A: \u0628\u0627\u06CC\u062F ${stringifyPrimitive(issue2.values[0])} \u0648\u0627\u06CC`; + } + return `\u0646\u0627\u0633\u0645 \u0627\u0646\u062A\u062E\u0627\u0628: \u0628\u0627\u06CC\u062F \u06CC\u0648 \u0644\u0647 ${joinValues(issue2.values, "|")} \u0685\u062E\u0647 \u0648\u0627\u06CC`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `\u0689\u06CC\u0631 \u0644\u0648\u06CC: ${(_c = issue2.origin) != null ? _c : "\u0627\u0631\u0632\u069A\u062A"} \u0628\u0627\u06CC\u062F ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\u0639\u0646\u0635\u0631\u0648\u0646\u0647"} \u0648\u0644\u0631\u064A`; + } + return `\u0689\u06CC\u0631 \u0644\u0648\u06CC: ${(_e = issue2.origin) != null ? _e : "\u0627\u0631\u0632\u069A\u062A"} \u0628\u0627\u06CC\u062F ${adj}${issue2.maximum.toString()} \u0648\u064A`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `\u0689\u06CC\u0631 \u06A9\u0648\u0686\u0646\u06CC: ${issue2.origin} \u0628\u0627\u06CC\u062F ${adj}${issue2.minimum.toString()} ${sizing.unit} \u0648\u0644\u0631\u064A`; + } + return `\u0689\u06CC\u0631 \u06A9\u0648\u0686\u0646\u06CC: ${issue2.origin} \u0628\u0627\u06CC\u062F ${adj}${issue2.minimum.toString()} \u0648\u064A`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") { + return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F \u062F "${_issue.prefix}" \u0633\u0631\u0647 \u067E\u06CC\u0644 \u0634\u064A`; + } + if (_issue.format === "ends_with") { + return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F \u062F "${_issue.suffix}" \u0633\u0631\u0647 \u067E\u0627\u06CC \u062A\u0647 \u0648\u0631\u0633\u064A\u0696\u064A`; + } + if (_issue.format === "includes") { + return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F "${_issue.includes}" \u0648\u0644\u0631\u064A`; + } + if (_issue.format === "regex") { + return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F \u062F ${_issue.pattern} \u0633\u0631\u0647 \u0645\u0637\u0627\u0628\u0642\u062A \u0648\u0644\u0631\u064A`; + } + return `${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format} \u0646\u0627\u0633\u0645 \u062F\u06CC`; + } + case "not_multiple_of": + return `\u0646\u0627\u0633\u0645 \u0639\u062F\u062F: \u0628\u0627\u06CC\u062F \u062F ${issue2.divisor} \u0645\u0636\u0631\u0628 \u0648\u064A`; + case "unrecognized_keys": + return `\u0646\u0627\u0633\u0645 ${issue2.keys.length > 1 ? "\u06A9\u0644\u06CC\u0689\u0648\u0646\u0647" : "\u06A9\u0644\u06CC\u0689"}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `\u0646\u0627\u0633\u0645 \u06A9\u0644\u06CC\u0689 \u067E\u0647 ${issue2.origin} \u06A9\u06D0`; + case "invalid_union": + return `\u0646\u0627\u0633\u0645\u0647 \u0648\u0631\u0648\u062F\u064A`; + case "invalid_element": + return `\u0646\u0627\u0633\u0645 \u0639\u0646\u0635\u0631 \u067E\u0647 ${issue2.origin} \u06A9\u06D0`; + default: + return `\u0646\u0627\u0633\u0645\u0647 \u0648\u0631\u0648\u062F\u064A`; + } + }; +}; +function ps_default() { + return { + localeError: error32() + }; +} + +// node_modules/zod/v4/locales/pl.js +var error33 = () => { + const Sizable = { + string: { unit: "znak\xF3w", verb: "mie\u0107" }, + file: { unit: "bajt\xF3w", verb: "mie\u0107" }, + array: { unit: "element\xF3w", verb: "mie\u0107" }, + set: { unit: "element\xF3w", verb: "mie\u0107" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "wyra\u017Cenie", + email: "adres email", + url: "URL", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "data i godzina w formacie ISO", + date: "data w formacie ISO", + time: "godzina w formacie ISO", + duration: "czas trwania ISO", + ipv4: "adres IPv4", + ipv6: "adres IPv6", + cidrv4: "zakres IPv4", + cidrv6: "zakres IPv6", + base64: "ci\u0105g znak\xF3w zakodowany w formacie base64", + base64url: "ci\u0105g znak\xF3w zakodowany w formacie base64url", + json_string: "ci\u0105g znak\xF3w w formacie JSON", + e164: "liczba E.164", + jwt: "JWT", + template_literal: "wej\u015Bcie" + }; + const TypeDictionary = { + nan: "NaN", + number: "liczba", + array: "tablica" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f, _g, _h, _i; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano instanceof ${issue2.expected}, otrzymano ${received}`; + } + return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano ${expected}, otrzymano ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano ${stringifyPrimitive(issue2.values[0])}`; + return `Nieprawid\u0142owa opcja: oczekiwano jednej z warto\u015Bci ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `Za du\u017Ca warto\u015B\u0107: oczekiwano, \u017Ce ${(_c = issue2.origin) != null ? _c : "warto\u015B\u0107"} b\u0119dzie mie\u0107 ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "element\xF3w"}`; + } + return `Zbyt du\u017C(y/a/e): oczekiwano, \u017Ce ${(_e = issue2.origin) != null ? _e : "warto\u015B\u0107"} b\u0119dzie wynosi\u0107 ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `Za ma\u0142a warto\u015B\u0107: oczekiwano, \u017Ce ${(_f = issue2.origin) != null ? _f : "warto\u015B\u0107"} b\u0119dzie mie\u0107 ${adj}${issue2.minimum.toString()} ${(_g = sizing.unit) != null ? _g : "element\xF3w"}`; + } + return `Zbyt ma\u0142(y/a/e): oczekiwano, \u017Ce ${(_h = issue2.origin) != null ? _h : "warto\u015B\u0107"} b\u0119dzie wynosi\u0107 ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi zaczyna\u0107 si\u0119 od "${_issue.prefix}"`; + if (_issue.format === "ends_with") + return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi ko\u0144czy\u0107 si\u0119 na "${_issue.suffix}"`; + if (_issue.format === "includes") + return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi zawiera\u0107 "${_issue.includes}"`; + if (_issue.format === "regex") + return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi odpowiada\u0107 wzorcowi ${_issue.pattern}`; + return `Nieprawid\u0142ow(y/a/e) ${(_i = FormatDictionary[_issue.format]) != null ? _i : issue2.format}`; + } + case "not_multiple_of": + return `Nieprawid\u0142owa liczba: musi by\u0107 wielokrotno\u015Bci\u0105 ${issue2.divisor}`; + case "unrecognized_keys": + return `Nierozpoznane klucze${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `Nieprawid\u0142owy klucz w ${issue2.origin}`; + case "invalid_union": + return "Nieprawid\u0142owe dane wej\u015Bciowe"; + case "invalid_element": + return `Nieprawid\u0142owa warto\u015B\u0107 w ${issue2.origin}`; + default: + return `Nieprawid\u0142owe dane wej\u015Bciowe`; + } + }; +}; +function pl_default() { + return { + localeError: error33() + }; +} + +// node_modules/zod/v4/locales/pt.js +var error34 = () => { + const Sizable = { + string: { unit: "caracteres", verb: "ter" }, + file: { unit: "bytes", verb: "ter" }, + array: { unit: "itens", verb: "ter" }, + set: { unit: "itens", verb: "ter" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "padr\xE3o", + email: "endere\xE7o de e-mail", + url: "URL", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "data e hora ISO", + date: "data ISO", + time: "hora ISO", + duration: "dura\xE7\xE3o ISO", + ipv4: "endere\xE7o IPv4", + ipv6: "endere\xE7o IPv6", + cidrv4: "faixa de IPv4", + cidrv6: "faixa de IPv6", + base64: "texto codificado em base64", + base64url: "URL codificada em base64", + json_string: "texto JSON", + e164: "n\xFAmero E.164", + jwt: "JWT", + template_literal: "entrada" + }; + const TypeDictionary = { + nan: "NaN", + number: "n\xFAmero", + null: "nulo" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `Tipo inv\xE1lido: esperado instanceof ${issue2.expected}, recebido ${received}`; + } + return `Tipo inv\xE1lido: esperado ${expected}, recebido ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `Entrada inv\xE1lida: esperado ${stringifyPrimitive(issue2.values[0])}`; + return `Op\xE7\xE3o inv\xE1lida: esperada uma das ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `Muito grande: esperado que ${(_c = issue2.origin) != null ? _c : "valor"} tivesse ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elementos"}`; + return `Muito grande: esperado que ${(_e = issue2.origin) != null ? _e : "valor"} fosse ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `Muito pequeno: esperado que ${issue2.origin} tivesse ${adj}${issue2.minimum.toString()} ${sizing.unit}`; + } + return `Muito pequeno: esperado que ${issue2.origin} fosse ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `Texto inv\xE1lido: deve come\xE7ar com "${_issue.prefix}"`; + if (_issue.format === "ends_with") + return `Texto inv\xE1lido: deve terminar com "${_issue.suffix}"`; + if (_issue.format === "includes") + return `Texto inv\xE1lido: deve incluir "${_issue.includes}"`; + if (_issue.format === "regex") + return `Texto inv\xE1lido: deve corresponder ao padr\xE3o ${_issue.pattern}`; + return `${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format} inv\xE1lido`; + } + case "not_multiple_of": + return `N\xFAmero inv\xE1lido: deve ser m\xFAltiplo de ${issue2.divisor}`; + case "unrecognized_keys": + return `Chave${issue2.keys.length > 1 ? "s" : ""} desconhecida${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `Chave inv\xE1lida em ${issue2.origin}`; + case "invalid_union": + return "Entrada inv\xE1lida"; + case "invalid_element": + return `Valor inv\xE1lido em ${issue2.origin}`; + default: + return `Campo inv\xE1lido`; + } + }; +}; +function pt_default2() { + return { + localeError: error34() + }; +} + +// node_modules/zod/v4/locales/ru.js +function getRussianPlural(count, one, few, many) { + const absCount = Math.abs(count); + const lastDigit = absCount % 10; + const lastTwoDigits = absCount % 100; + if (lastTwoDigits >= 11 && lastTwoDigits <= 19) { + return many; + } + if (lastDigit === 1) { + return one; + } + if (lastDigit >= 2 && lastDigit <= 4) { + return few; + } + return many; +} +var error35 = () => { + const Sizable = { + string: { + unit: { + one: "\u0441\u0438\u043C\u0432\u043E\u043B", + few: "\u0441\u0438\u043C\u0432\u043E\u043B\u0430", + many: "\u0441\u0438\u043C\u0432\u043E\u043B\u043E\u0432" + }, + verb: "\u0438\u043C\u0435\u0442\u044C" + }, + file: { + unit: { + one: "\u0431\u0430\u0439\u0442", + few: "\u0431\u0430\u0439\u0442\u0430", + many: "\u0431\u0430\u0439\u0442" + }, + verb: "\u0438\u043C\u0435\u0442\u044C" + }, + array: { + unit: { + one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442", + few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430", + many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u043E\u0432" + }, + verb: "\u0438\u043C\u0435\u0442\u044C" + }, + set: { + unit: { + one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442", + few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430", + many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u043E\u0432" + }, + verb: "\u0438\u043C\u0435\u0442\u044C" + } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "\u0432\u0432\u043E\u0434", + email: "email \u0430\u0434\u0440\u0435\u0441", + url: "URL", + emoji: "\u044D\u043C\u043E\u0434\u0437\u0438", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO \u0434\u0430\u0442\u0430 \u0438 \u0432\u0440\u0435\u043C\u044F", + date: "ISO \u0434\u0430\u0442\u0430", + time: "ISO \u0432\u0440\u0435\u043C\u044F", + duration: "ISO \u0434\u043B\u0438\u0442\u0435\u043B\u044C\u043D\u043E\u0441\u0442\u044C", + ipv4: "IPv4 \u0430\u0434\u0440\u0435\u0441", + ipv6: "IPv6 \u0430\u0434\u0440\u0435\u0441", + cidrv4: "IPv4 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D", + cidrv6: "IPv6 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D", + base64: "\u0441\u0442\u0440\u043E\u043A\u0430 \u0432 \u0444\u043E\u0440\u043C\u0430\u0442\u0435 base64", + base64url: "\u0441\u0442\u0440\u043E\u043A\u0430 \u0432 \u0444\u043E\u0440\u043C\u0430\u0442\u0435 base64url", + json_string: "JSON \u0441\u0442\u0440\u043E\u043A\u0430", + e164: "\u043D\u043E\u043C\u0435\u0440 E.164", + jwt: "JWT", + template_literal: "\u0432\u0432\u043E\u0434" + }; + const TypeDictionary = { + nan: "NaN", + number: "\u0447\u0438\u0441\u043B\u043E", + array: "\u043C\u0430\u0441\u0441\u0438\u0432" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C instanceof ${issue2.expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${received}`; + } + return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C ${expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C ${stringifyPrimitive(issue2.values[0])}`; + return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0430\u0440\u0438\u0430\u043D\u0442: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C \u043E\u0434\u043D\u043E \u0438\u0437 ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) { + const maxValue = Number(issue2.maximum); + const unit = getRussianPlural(maxValue, sizing.unit.one, sizing.unit.few, sizing.unit.many); + return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u0431\u043E\u043B\u044C\u0448\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${(_c = issue2.origin) != null ? _c : "\u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435"} \u0431\u0443\u0434\u0435\u0442 \u0438\u043C\u0435\u0442\u044C ${adj}${issue2.maximum.toString()} ${unit}`; + } + return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u0431\u043E\u043B\u044C\u0448\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${(_d = issue2.origin) != null ? _d : "\u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435"} \u0431\u0443\u0434\u0435\u0442 ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + const minValue = Number(issue2.minimum); + const unit = getRussianPlural(minValue, sizing.unit.one, sizing.unit.few, sizing.unit.many); + return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u043C\u0430\u043B\u0435\u043D\u044C\u043A\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue2.origin} \u0431\u0443\u0434\u0435\u0442 \u0438\u043C\u0435\u0442\u044C ${adj}${issue2.minimum.toString()} ${unit}`; + } + return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u043C\u0430\u043B\u0435\u043D\u044C\u043A\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue2.origin} \u0431\u0443\u0434\u0435\u0442 ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u043D\u0430\u0447\u0438\u043D\u0430\u0442\u044C\u0441\u044F \u0441 "${_issue.prefix}"`; + if (_issue.format === "ends_with") + return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0437\u0430\u043A\u0430\u043D\u0447\u0438\u0432\u0430\u0442\u044C\u0441\u044F \u043D\u0430 "${_issue.suffix}"`; + if (_issue.format === "includes") + return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0441\u043E\u0434\u0435\u0440\u0436\u0430\u0442\u044C "${_issue.includes}"`; + if (_issue.format === "regex") + return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0441\u043E\u043E\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u043E\u0432\u0430\u0442\u044C \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${_issue.pattern}`; + return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 ${(_e = FormatDictionary[_issue.format]) != null ? _e : issue2.format}`; + } + case "not_multiple_of": + return `\u041D\u0435\u0432\u0435\u0440\u043D\u043E\u0435 \u0447\u0438\u0441\u043B\u043E: \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043A\u0440\u0430\u0442\u043D\u044B\u043C ${issue2.divisor}`; + case "unrecognized_keys": + return `\u041D\u0435\u0440\u0430\u0441\u043F\u043E\u0437\u043D\u0430\u043D\u043D${issue2.keys.length > 1 ? "\u044B\u0435" : "\u044B\u0439"} \u043A\u043B\u044E\u0447${issue2.keys.length > 1 ? "\u0438" : ""}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u043A\u043B\u044E\u0447 \u0432 ${issue2.origin}`; + case "invalid_union": + return "\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0435 \u0432\u0445\u043E\u0434\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435"; + case "invalid_element": + return `\u041D\u0435\u0432\u0435\u0440\u043D\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u0432 ${issue2.origin}`; + default: + return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0435 \u0432\u0445\u043E\u0434\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435`; + } + }; +}; +function ru_default2() { + return { + localeError: error35() + }; +} + +// node_modules/zod/v4/locales/sl.js +var error36 = () => { + const Sizable = { + string: { unit: "znakov", verb: "imeti" }, + file: { unit: "bajtov", verb: "imeti" }, + array: { unit: "elementov", verb: "imeti" }, + set: { unit: "elementov", verb: "imeti" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "vnos", + email: "e-po\u0161tni naslov", + url: "URL", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO datum in \u010Das", + date: "ISO datum", + time: "ISO \u010Das", + duration: "ISO trajanje", + ipv4: "IPv4 naslov", + ipv6: "IPv6 naslov", + cidrv4: "obseg IPv4", + cidrv6: "obseg IPv6", + base64: "base64 kodiran niz", + base64url: "base64url kodiran niz", + json_string: "JSON niz", + e164: "E.164 \u0161tevilka", + jwt: "JWT", + template_literal: "vnos" + }; + const TypeDictionary = { + nan: "NaN", + number: "\u0161tevilo", + array: "tabela" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `Neveljaven vnos: pri\u010Dakovano instanceof ${issue2.expected}, prejeto ${received}`; + } + return `Neveljaven vnos: pri\u010Dakovano ${expected}, prejeto ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `Neveljaven vnos: pri\u010Dakovano ${stringifyPrimitive(issue2.values[0])}`; + return `Neveljavna mo\u017Enost: pri\u010Dakovano eno izmed ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `Preveliko: pri\u010Dakovano, da bo ${(_c = issue2.origin) != null ? _c : "vrednost"} imelo ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elementov"}`; + return `Preveliko: pri\u010Dakovano, da bo ${(_e = issue2.origin) != null ? _e : "vrednost"} ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `Premajhno: pri\u010Dakovano, da bo ${issue2.origin} imelo ${adj}${issue2.minimum.toString()} ${sizing.unit}`; + } + return `Premajhno: pri\u010Dakovano, da bo ${issue2.origin} ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") { + return `Neveljaven niz: mora se za\u010Deti z "${_issue.prefix}"`; + } + if (_issue.format === "ends_with") + return `Neveljaven niz: mora se kon\u010Dati z "${_issue.suffix}"`; + if (_issue.format === "includes") + return `Neveljaven niz: mora vsebovati "${_issue.includes}"`; + if (_issue.format === "regex") + return `Neveljaven niz: mora ustrezati vzorcu ${_issue.pattern}`; + return `Neveljaven ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format}`; + } + case "not_multiple_of": + return `Neveljavno \u0161tevilo: mora biti ve\u010Dkratnik ${issue2.divisor}`; + case "unrecognized_keys": + return `Neprepoznan${issue2.keys.length > 1 ? "i klju\u010Di" : " klju\u010D"}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `Neveljaven klju\u010D v ${issue2.origin}`; + case "invalid_union": + return "Neveljaven vnos"; + case "invalid_element": + return `Neveljavna vrednost v ${issue2.origin}`; + default: + return "Neveljaven vnos"; + } + }; +}; +function sl_default() { + return { + localeError: error36() + }; +} + +// node_modules/zod/v4/locales/sv.js +var error37 = () => { + const Sizable = { + string: { unit: "tecken", verb: "att ha" }, + file: { unit: "bytes", verb: "att ha" }, + array: { unit: "objekt", verb: "att inneh\xE5lla" }, + set: { unit: "objekt", verb: "att inneh\xE5lla" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "regulj\xE4rt uttryck", + email: "e-postadress", + url: "URL", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO-datum och tid", + date: "ISO-datum", + time: "ISO-tid", + duration: "ISO-varaktighet", + ipv4: "IPv4-intervall", + ipv6: "IPv6-intervall", + cidrv4: "IPv4-spektrum", + cidrv6: "IPv6-spektrum", + base64: "base64-kodad str\xE4ng", + base64url: "base64url-kodad str\xE4ng", + json_string: "JSON-str\xE4ng", + e164: "E.164-nummer", + jwt: "JWT", + template_literal: "mall-literal" + }; + const TypeDictionary = { + nan: "NaN", + number: "antal", + array: "lista" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f, _g, _h, _i, _j2; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `Ogiltig inmatning: f\xF6rv\xE4ntat instanceof ${issue2.expected}, fick ${received}`; + } + return `Ogiltig inmatning: f\xF6rv\xE4ntat ${expected}, fick ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `Ogiltig inmatning: f\xF6rv\xE4ntat ${stringifyPrimitive(issue2.values[0])}`; + return `Ogiltigt val: f\xF6rv\xE4ntade en av ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `F\xF6r stor(t): f\xF6rv\xE4ntade ${(_c = issue2.origin) != null ? _c : "v\xE4rdet"} att ha ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "element"}`; + } + return `F\xF6r stor(t): f\xF6rv\xE4ntat ${(_e = issue2.origin) != null ? _e : "v\xE4rdet"} att ha ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `F\xF6r lite(t): f\xF6rv\xE4ntade ${(_f = issue2.origin) != null ? _f : "v\xE4rdet"} att ha ${adj}${issue2.minimum.toString()} ${sizing.unit}`; + } + return `F\xF6r lite(t): f\xF6rv\xE4ntade ${(_g = issue2.origin) != null ? _g : "v\xE4rdet"} att ha ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") { + return `Ogiltig str\xE4ng: m\xE5ste b\xF6rja med "${_issue.prefix}"`; + } + if (_issue.format === "ends_with") + return `Ogiltig str\xE4ng: m\xE5ste sluta med "${_issue.suffix}"`; + if (_issue.format === "includes") + return `Ogiltig str\xE4ng: m\xE5ste inneh\xE5lla "${_issue.includes}"`; + if (_issue.format === "regex") + return `Ogiltig str\xE4ng: m\xE5ste matcha m\xF6nstret "${_issue.pattern}"`; + return `Ogiltig(t) ${(_h = FormatDictionary[_issue.format]) != null ? _h : issue2.format}`; + } + case "not_multiple_of": + return `Ogiltigt tal: m\xE5ste vara en multipel av ${issue2.divisor}`; + case "unrecognized_keys": + return `${issue2.keys.length > 1 ? "Ok\xE4nda nycklar" : "Ok\xE4nd nyckel"}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `Ogiltig nyckel i ${(_i = issue2.origin) != null ? _i : "v\xE4rdet"}`; + case "invalid_union": + return "Ogiltig input"; + case "invalid_element": + return `Ogiltigt v\xE4rde i ${(_j2 = issue2.origin) != null ? _j2 : "v\xE4rdet"}`; + default: + return `Ogiltig input`; + } + }; +}; +function sv_default() { + return { + localeError: error37() + }; +} + +// node_modules/zod/v4/locales/ta.js +var error38 = () => { + const Sizable = { + string: { unit: "\u0B8E\u0BB4\u0BC1\u0BA4\u0BCD\u0BA4\u0BC1\u0B95\u0BCD\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" }, + file: { unit: "\u0BAA\u0BC8\u0B9F\u0BCD\u0B9F\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" }, + array: { unit: "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" }, + set: { unit: "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "\u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1", + email: "\u0BAE\u0BBF\u0BA9\u0BCD\u0BA9\u0B9E\u0BCD\u0B9A\u0BB2\u0BCD \u0BAE\u0BC1\u0B95\u0BB5\u0BB0\u0BBF", + url: "URL", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO \u0BA4\u0BC7\u0BA4\u0BBF \u0BA8\u0BC7\u0BB0\u0BAE\u0BCD", + date: "ISO \u0BA4\u0BC7\u0BA4\u0BBF", + time: "ISO \u0BA8\u0BC7\u0BB0\u0BAE\u0BCD", + duration: "ISO \u0B95\u0BBE\u0BB2 \u0B85\u0BB3\u0BB5\u0BC1", + ipv4: "IPv4 \u0BAE\u0BC1\u0B95\u0BB5\u0BB0\u0BBF", + ipv6: "IPv6 \u0BAE\u0BC1\u0B95\u0BB5\u0BB0\u0BBF", + cidrv4: "IPv4 \u0BB5\u0BB0\u0BAE\u0BCD\u0BAA\u0BC1", + cidrv6: "IPv6 \u0BB5\u0BB0\u0BAE\u0BCD\u0BAA\u0BC1", + base64: "base64-encoded \u0B9A\u0BB0\u0BAE\u0BCD", + base64url: "base64url-encoded \u0B9A\u0BB0\u0BAE\u0BCD", + json_string: "JSON \u0B9A\u0BB0\u0BAE\u0BCD", + e164: "E.164 \u0B8E\u0BA3\u0BCD", + jwt: "JWT", + template_literal: "input" + }; + const TypeDictionary = { + nan: "NaN", + number: "\u0B8E\u0BA3\u0BCD", + array: "\u0B85\u0BA3\u0BBF", + null: "\u0BB5\u0BC6\u0BB1\u0BC1\u0BAE\u0BC8" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 instanceof ${issue2.expected}, \u0BAA\u0BC6\u0BB1\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${received}`; + } + return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${expected}, \u0BAA\u0BC6\u0BB1\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${stringifyPrimitive(issue2.values[0])}`; + return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0BB5\u0BBF\u0BB0\u0BC1\u0BAA\u0BCD\u0BAA\u0BAE\u0BCD: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${joinValues(issue2.values, "|")} \u0B87\u0BB2\u0BCD \u0B92\u0BA9\u0BCD\u0BB1\u0BC1`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `\u0BAE\u0BBF\u0B95 \u0BAA\u0BC6\u0BB0\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${(_c = issue2.origin) != null ? _c : "\u0BAE\u0BA4\u0BBF\u0BAA\u0BCD\u0BAA\u0BC1"} ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD"} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`; + } + return `\u0BAE\u0BBF\u0B95 \u0BAA\u0BC6\u0BB0\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${(_e = issue2.origin) != null ? _e : "\u0BAE\u0BA4\u0BBF\u0BAA\u0BCD\u0BAA\u0BC1"} ${adj}${issue2.maximum.toString()} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `\u0BAE\u0BBF\u0B95\u0B9A\u0BCD \u0B9A\u0BBF\u0BB1\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`; + } + return `\u0BAE\u0BBF\u0B95\u0B9A\u0BCD \u0B9A\u0BBF\u0BB1\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue2.origin} ${adj}${issue2.minimum.toString()} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: "${_issue.prefix}" \u0B87\u0BB2\u0BCD \u0BA4\u0BCA\u0B9F\u0B99\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`; + if (_issue.format === "ends_with") + return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: "${_issue.suffix}" \u0B87\u0BB2\u0BCD \u0BAE\u0BC1\u0B9F\u0BBF\u0BB5\u0B9F\u0BC8\u0BAF \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`; + if (_issue.format === "includes") + return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: "${_issue.includes}" \u0B90 \u0B89\u0BB3\u0BCD\u0BB3\u0B9F\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`; + if (_issue.format === "regex") + return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: ${_issue.pattern} \u0BAE\u0BC1\u0BB1\u0BC8\u0BAA\u0BBE\u0B9F\u0BCD\u0B9F\u0BC1\u0B9F\u0BA9\u0BCD \u0BAA\u0BCA\u0BB0\u0BC1\u0BA8\u0BCD\u0BA4 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`; + return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format}`; + } + case "not_multiple_of": + return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B8E\u0BA3\u0BCD: ${issue2.divisor} \u0B87\u0BA9\u0BCD \u0BAA\u0BB2\u0BAE\u0BBE\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`; + case "unrecognized_keys": + return `\u0B85\u0B9F\u0BC8\u0BAF\u0BBE\u0BB3\u0BAE\u0BCD \u0BA4\u0BC6\u0BB0\u0BBF\u0BAF\u0BBE\u0BA4 \u0BB5\u0BBF\u0B9A\u0BC8${issue2.keys.length > 1 ? "\u0B95\u0BB3\u0BCD" : ""}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `${issue2.origin} \u0B87\u0BB2\u0BCD \u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0BB5\u0BBF\u0B9A\u0BC8`; + case "invalid_union": + return "\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1"; + case "invalid_element": + return `${issue2.origin} \u0B87\u0BB2\u0BCD \u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0BAE\u0BA4\u0BBF\u0BAA\u0BCD\u0BAA\u0BC1`; + default: + return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1`; + } + }; +}; +function ta_default() { + return { + localeError: error38() + }; +} + +// node_modules/zod/v4/locales/th.js +var error39 = () => { + const Sizable = { + string: { unit: "\u0E15\u0E31\u0E27\u0E2D\u0E31\u0E01\u0E29\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" }, + file: { unit: "\u0E44\u0E1A\u0E15\u0E4C", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" }, + array: { unit: "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" }, + set: { unit: "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E17\u0E35\u0E48\u0E1B\u0E49\u0E2D\u0E19", + email: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48\u0E2D\u0E35\u0E40\u0E21\u0E25", + url: "URL", + emoji: "\u0E2D\u0E34\u0E42\u0E21\u0E08\u0E34", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "\u0E27\u0E31\u0E19\u0E17\u0E35\u0E48\u0E40\u0E27\u0E25\u0E32\u0E41\u0E1A\u0E1A ISO", + date: "\u0E27\u0E31\u0E19\u0E17\u0E35\u0E48\u0E41\u0E1A\u0E1A ISO", + time: "\u0E40\u0E27\u0E25\u0E32\u0E41\u0E1A\u0E1A ISO", + duration: "\u0E0A\u0E48\u0E27\u0E07\u0E40\u0E27\u0E25\u0E32\u0E41\u0E1A\u0E1A ISO", + ipv4: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48 IPv4", + ipv6: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48 IPv6", + cidrv4: "\u0E0A\u0E48\u0E27\u0E07 IP \u0E41\u0E1A\u0E1A IPv4", + cidrv6: "\u0E0A\u0E48\u0E27\u0E07 IP \u0E41\u0E1A\u0E1A IPv6", + base64: "\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E41\u0E1A\u0E1A Base64", + base64url: "\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E41\u0E1A\u0E1A Base64 \u0E2A\u0E33\u0E2B\u0E23\u0E31\u0E1A URL", + json_string: "\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E41\u0E1A\u0E1A JSON", + e164: "\u0E40\u0E1A\u0E2D\u0E23\u0E4C\u0E42\u0E17\u0E23\u0E28\u0E31\u0E1E\u0E17\u0E4C\u0E23\u0E30\u0E2B\u0E27\u0E48\u0E32\u0E07\u0E1B\u0E23\u0E30\u0E40\u0E17\u0E28 (E.164)", + jwt: "\u0E42\u0E17\u0E40\u0E04\u0E19 JWT", + template_literal: "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E17\u0E35\u0E48\u0E1B\u0E49\u0E2D\u0E19" + }; + const TypeDictionary = { + nan: "NaN", + number: "\u0E15\u0E31\u0E27\u0E40\u0E25\u0E02", + array: "\u0E2D\u0E32\u0E23\u0E4C\u0E40\u0E23\u0E22\u0E4C (Array)", + null: "\u0E44\u0E21\u0E48\u0E21\u0E35\u0E04\u0E48\u0E32 (null)" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `\u0E1B\u0E23\u0E30\u0E40\u0E20\u0E17\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 instanceof ${issue2.expected} \u0E41\u0E15\u0E48\u0E44\u0E14\u0E49\u0E23\u0E31\u0E1A ${received}`; + } + return `\u0E1B\u0E23\u0E30\u0E40\u0E20\u0E17\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 ${expected} \u0E41\u0E15\u0E48\u0E44\u0E14\u0E49\u0E23\u0E31\u0E1A ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `\u0E04\u0E48\u0E32\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 ${stringifyPrimitive(issue2.values[0])}`; + return `\u0E15\u0E31\u0E27\u0E40\u0E25\u0E37\u0E2D\u0E01\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19\u0E2B\u0E19\u0E36\u0E48\u0E07\u0E43\u0E19 ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "\u0E44\u0E21\u0E48\u0E40\u0E01\u0E34\u0E19" : "\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `\u0E40\u0E01\u0E34\u0E19\u0E01\u0E33\u0E2B\u0E19\u0E14: ${(_c = issue2.origin) != null ? _c : "\u0E04\u0E48\u0E32"} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23"}`; + return `\u0E40\u0E01\u0E34\u0E19\u0E01\u0E33\u0E2B\u0E19\u0E14: ${(_e = issue2.origin) != null ? _e : "\u0E04\u0E48\u0E32"} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? "\u0E2D\u0E22\u0E48\u0E32\u0E07\u0E19\u0E49\u0E2D\u0E22" : "\u0E21\u0E32\u0E01\u0E01\u0E27\u0E48\u0E32"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32\u0E01\u0E33\u0E2B\u0E19\u0E14: ${issue2.origin} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue2.minimum.toString()} ${sizing.unit}`; + } + return `\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32\u0E01\u0E33\u0E2B\u0E19\u0E14: ${issue2.origin} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") { + return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E15\u0E49\u0E2D\u0E07\u0E02\u0E36\u0E49\u0E19\u0E15\u0E49\u0E19\u0E14\u0E49\u0E27\u0E22 "${_issue.prefix}"`; + } + if (_issue.format === "ends_with") + return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E15\u0E49\u0E2D\u0E07\u0E25\u0E07\u0E17\u0E49\u0E32\u0E22\u0E14\u0E49\u0E27\u0E22 "${_issue.suffix}"`; + if (_issue.format === "includes") + return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E15\u0E49\u0E2D\u0E07\u0E21\u0E35 "${_issue.includes}" \u0E2D\u0E22\u0E39\u0E48\u0E43\u0E19\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21`; + if (_issue.format === "regex") + return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E15\u0E49\u0E2D\u0E07\u0E15\u0E23\u0E07\u0E01\u0E31\u0E1A\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E17\u0E35\u0E48\u0E01\u0E33\u0E2B\u0E19\u0E14 ${_issue.pattern}`; + return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format}`; + } + case "not_multiple_of": + return `\u0E15\u0E31\u0E27\u0E40\u0E25\u0E02\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E15\u0E49\u0E2D\u0E07\u0E40\u0E1B\u0E47\u0E19\u0E08\u0E33\u0E19\u0E27\u0E19\u0E17\u0E35\u0E48\u0E2B\u0E32\u0E23\u0E14\u0E49\u0E27\u0E22 ${issue2.divisor} \u0E44\u0E14\u0E49\u0E25\u0E07\u0E15\u0E31\u0E27`; + case "unrecognized_keys": + return `\u0E1E\u0E1A\u0E04\u0E35\u0E22\u0E4C\u0E17\u0E35\u0E48\u0E44\u0E21\u0E48\u0E23\u0E39\u0E49\u0E08\u0E31\u0E01: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `\u0E04\u0E35\u0E22\u0E4C\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07\u0E43\u0E19 ${issue2.origin}`; + case "invalid_union": + return "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E44\u0E21\u0E48\u0E15\u0E23\u0E07\u0E01\u0E31\u0E1A\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E22\u0E39\u0E40\u0E19\u0E35\u0E22\u0E19\u0E17\u0E35\u0E48\u0E01\u0E33\u0E2B\u0E19\u0E14\u0E44\u0E27\u0E49"; + case "invalid_element": + return `\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07\u0E43\u0E19 ${issue2.origin}`; + default: + return `\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07`; + } + }; +}; +function th_default() { + return { + localeError: error39() + }; +} + +// node_modules/zod/v4/locales/tr.js +var error40 = () => { + const Sizable = { + string: { unit: "karakter", verb: "olmal\u0131" }, + file: { unit: "bayt", verb: "olmal\u0131" }, + array: { unit: "\xF6\u011Fe", verb: "olmal\u0131" }, + set: { unit: "\xF6\u011Fe", verb: "olmal\u0131" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "girdi", + email: "e-posta adresi", + url: "URL", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO tarih ve saat", + date: "ISO tarih", + time: "ISO saat", + duration: "ISO s\xFCre", + ipv4: "IPv4 adresi", + ipv6: "IPv6 adresi", + cidrv4: "IPv4 aral\u0131\u011F\u0131", + cidrv6: "IPv6 aral\u0131\u011F\u0131", + base64: "base64 ile \u015Fifrelenmi\u015F metin", + base64url: "base64url ile \u015Fifrelenmi\u015F metin", + json_string: "JSON dizesi", + e164: "E.164 say\u0131s\u0131", + jwt: "JWT", + template_literal: "\u015Eablon dizesi" + }; + const TypeDictionary = { + nan: "NaN" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `Ge\xE7ersiz de\u011Fer: beklenen instanceof ${issue2.expected}, al\u0131nan ${received}`; + } + return `Ge\xE7ersiz de\u011Fer: beklenen ${expected}, al\u0131nan ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `Ge\xE7ersiz de\u011Fer: beklenen ${stringifyPrimitive(issue2.values[0])}`; + return `Ge\xE7ersiz se\xE7enek: a\u015Fa\u011F\u0131dakilerden biri olmal\u0131: ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `\xC7ok b\xFCy\xFCk: beklenen ${(_c = issue2.origin) != null ? _c : "de\u011Fer"} ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\xF6\u011Fe"}`; + return `\xC7ok b\xFCy\xFCk: beklenen ${(_e = issue2.origin) != null ? _e : "de\u011Fer"} ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `\xC7ok k\xFC\xE7\xFCk: beklenen ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit}`; + return `\xC7ok k\xFC\xE7\xFCk: beklenen ${issue2.origin} ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `Ge\xE7ersiz metin: "${_issue.prefix}" ile ba\u015Flamal\u0131`; + if (_issue.format === "ends_with") + return `Ge\xE7ersiz metin: "${_issue.suffix}" ile bitmeli`; + if (_issue.format === "includes") + return `Ge\xE7ersiz metin: "${_issue.includes}" i\xE7ermeli`; + if (_issue.format === "regex") + return `Ge\xE7ersiz metin: ${_issue.pattern} desenine uymal\u0131`; + return `Ge\xE7ersiz ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format}`; + } + case "not_multiple_of": + return `Ge\xE7ersiz say\u0131: ${issue2.divisor} ile tam b\xF6l\xFCnebilmeli`; + case "unrecognized_keys": + return `Tan\u0131nmayan anahtar${issue2.keys.length > 1 ? "lar" : ""}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `${issue2.origin} i\xE7inde ge\xE7ersiz anahtar`; + case "invalid_union": + return "Ge\xE7ersiz de\u011Fer"; + case "invalid_element": + return `${issue2.origin} i\xE7inde ge\xE7ersiz de\u011Fer`; + default: + return `Ge\xE7ersiz de\u011Fer`; + } + }; +}; +function tr_default() { + return { + localeError: error40() + }; +} + +// node_modules/zod/v4/locales/uk.js +var error41 = () => { + const Sizable = { + string: { unit: "\u0441\u0438\u043C\u0432\u043E\u043B\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" }, + file: { unit: "\u0431\u0430\u0439\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" }, + array: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" }, + set: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "\u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456", + email: "\u0430\u0434\u0440\u0435\u0441\u0430 \u0435\u043B\u0435\u043A\u0442\u0440\u043E\u043D\u043D\u043E\u0457 \u043F\u043E\u0448\u0442\u0438", + url: "URL", + emoji: "\u0435\u043C\u043E\u0434\u0437\u0456", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "\u0434\u0430\u0442\u0430 \u0442\u0430 \u0447\u0430\u0441 ISO", + date: "\u0434\u0430\u0442\u0430 ISO", + time: "\u0447\u0430\u0441 ISO", + duration: "\u0442\u0440\u0438\u0432\u0430\u043B\u0456\u0441\u0442\u044C ISO", + ipv4: "\u0430\u0434\u0440\u0435\u0441\u0430 IPv4", + ipv6: "\u0430\u0434\u0440\u0435\u0441\u0430 IPv6", + cidrv4: "\u0434\u0456\u0430\u043F\u0430\u0437\u043E\u043D IPv4", + cidrv6: "\u0434\u0456\u0430\u043F\u0430\u0437\u043E\u043D IPv6", + base64: "\u0440\u044F\u0434\u043E\u043A \u0443 \u043A\u043E\u0434\u0443\u0432\u0430\u043D\u043D\u0456 base64", + base64url: "\u0440\u044F\u0434\u043E\u043A \u0443 \u043A\u043E\u0434\u0443\u0432\u0430\u043D\u043D\u0456 base64url", + json_string: "\u0440\u044F\u0434\u043E\u043A JSON", + e164: "\u043D\u043E\u043C\u0435\u0440 E.164", + jwt: "JWT", + template_literal: "\u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456" + }; + const TypeDictionary = { + nan: "NaN", + number: "\u0447\u0438\u0441\u043B\u043E", + array: "\u043C\u0430\u0441\u0438\u0432" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F instanceof ${issue2.expected}, \u043E\u0442\u0440\u0438\u043C\u0430\u043D\u043E ${received}`; + } + return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F ${expected}, \u043E\u0442\u0440\u0438\u043C\u0430\u043D\u043E ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F ${stringifyPrimitive(issue2.values[0])}`; + return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0430 \u043E\u043F\u0446\u0456\u044F: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F \u043E\u0434\u043D\u0435 \u0437 ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u0432\u0435\u043B\u0438\u043A\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${(_c = issue2.origin) != null ? _c : "\u0437\u043D\u0430\u0447\u0435\u043D\u043D\u044F"} ${sizing.verb} ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432"}`; + return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u0432\u0435\u043B\u0438\u043A\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${(_e = issue2.origin) != null ? _e : "\u0437\u043D\u0430\u0447\u0435\u043D\u043D\u044F"} \u0431\u0443\u0434\u0435 ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u043C\u0430\u043B\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`; + } + return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u043C\u0430\u043B\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${issue2.origin} \u0431\u0443\u0434\u0435 ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u043F\u043E\u0447\u0438\u043D\u0430\u0442\u0438\u0441\u044F \u0437 "${_issue.prefix}"`; + if (_issue.format === "ends_with") + return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u0437\u0430\u043A\u0456\u043D\u0447\u0443\u0432\u0430\u0442\u0438\u0441\u044F \u043D\u0430 "${_issue.suffix}"`; + if (_issue.format === "includes") + return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u043C\u0456\u0441\u0442\u0438\u0442\u0438 "${_issue.includes}"`; + if (_issue.format === "regex") + return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u0432\u0456\u0434\u043F\u043E\u0432\u0456\u0434\u0430\u0442\u0438 \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${_issue.pattern}`; + return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format}`; + } + case "not_multiple_of": + return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0435 \u0447\u0438\u0441\u043B\u043E: \u043F\u043E\u0432\u0438\u043D\u043D\u043E \u0431\u0443\u0442\u0438 \u043A\u0440\u0430\u0442\u043D\u0438\u043C ${issue2.divisor}`; + case "unrecognized_keys": + return `\u041D\u0435\u0440\u043E\u0437\u043F\u0456\u0437\u043D\u0430\u043D\u0438\u0439 \u043A\u043B\u044E\u0447${issue2.keys.length > 1 ? "\u0456" : ""}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u043A\u043B\u044E\u0447 \u0443 ${issue2.origin}`; + case "invalid_union": + return "\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456"; + case "invalid_element": + return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u043D\u044F \u0443 ${issue2.origin}`; + default: + return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456`; + } + }; +}; +function uk_default() { + return { + localeError: error41() + }; +} + +// node_modules/zod/v4/locales/ua.js +function ua_default() { + return uk_default(); +} + +// node_modules/zod/v4/locales/ur.js +var error42 = () => { + const Sizable = { + string: { unit: "\u062D\u0631\u0648\u0641", verb: "\u06C1\u0648\u0646\u0627" }, + file: { unit: "\u0628\u0627\u0626\u0679\u0633", verb: "\u06C1\u0648\u0646\u0627" }, + array: { unit: "\u0622\u0626\u0679\u0645\u0632", verb: "\u06C1\u0648\u0646\u0627" }, + set: { unit: "\u0622\u0626\u0679\u0645\u0632", verb: "\u06C1\u0648\u0646\u0627" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "\u0627\u0646 \u067E\u0679", + email: "\u0627\u06CC \u0645\u06CC\u0644 \u0627\u06CC\u0688\u0631\u06CC\u0633", + url: "\u06CC\u0648 \u0622\u0631 \u0627\u06CC\u0644", + emoji: "\u0627\u06CC\u0645\u0648\u062C\u06CC", + uuid: "\u06CC\u0648 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC", + uuidv4: "\u06CC\u0648 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC \u0648\u06CC 4", + uuidv6: "\u06CC\u0648 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC \u0648\u06CC 6", + nanoid: "\u0646\u06CC\u0646\u0648 \u0622\u0626\u06CC \u0688\u06CC", + guid: "\u062C\u06CC \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC", + cuid: "\u0633\u06CC \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC", + cuid2: "\u0633\u06CC \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC 2", + ulid: "\u06CC\u0648 \u0627\u06CC\u0644 \u0622\u0626\u06CC \u0688\u06CC", + xid: "\u0627\u06CC\u06A9\u0633 \u0622\u0626\u06CC \u0688\u06CC", + ksuid: "\u06A9\u06D2 \u0627\u06CC\u0633 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC", + datetime: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u0688\u06CC\u0679 \u0679\u0627\u0626\u0645", + date: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u062A\u0627\u0631\u06CC\u062E", + time: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u0648\u0642\u062A", + duration: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u0645\u062F\u062A", + ipv4: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 4 \u0627\u06CC\u0688\u0631\u06CC\u0633", + ipv6: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 6 \u0627\u06CC\u0688\u0631\u06CC\u0633", + cidrv4: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 4 \u0631\u06CC\u0646\u062C", + cidrv6: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 6 \u0631\u06CC\u0646\u062C", + base64: "\u0628\u06CC\u0633 64 \u0627\u0646 \u06A9\u0648\u0688\u0688 \u0633\u0679\u0631\u0646\u06AF", + base64url: "\u0628\u06CC\u0633 64 \u06CC\u0648 \u0622\u0631 \u0627\u06CC\u0644 \u0627\u0646 \u06A9\u0648\u0688\u0688 \u0633\u0679\u0631\u0646\u06AF", + json_string: "\u062C\u06D2 \u0627\u06CC\u0633 \u0627\u0648 \u0627\u06CC\u0646 \u0633\u0679\u0631\u0646\u06AF", + e164: "\u0627\u06CC 164 \u0646\u0645\u0628\u0631", + jwt: "\u062C\u06D2 \u0688\u0628\u0644\u06CC\u0648 \u0679\u06CC", + template_literal: "\u0627\u0646 \u067E\u0679" + }; + const TypeDictionary = { + nan: "NaN", + number: "\u0646\u0645\u0628\u0631", + array: "\u0622\u0631\u06D2", + null: "\u0646\u0644" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: instanceof ${issue2.expected} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627\u060C ${received} \u0645\u0648\u0635\u0648\u0644 \u06C1\u0648\u0627`; + } + return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: ${expected} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627\u060C ${received} \u0645\u0648\u0635\u0648\u0644 \u06C1\u0648\u0627`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: ${stringifyPrimitive(issue2.values[0])} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`; + return `\u063A\u0644\u0637 \u0622\u067E\u0634\u0646: ${joinValues(issue2.values, "|")} \u0645\u06CC\u06BA \u0633\u06D2 \u0627\u06CC\u06A9 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `\u0628\u06C1\u062A \u0628\u0691\u0627: ${(_c = issue2.origin) != null ? _c : "\u0648\u06CC\u0644\u06CC\u0648"} \u06A9\u06D2 ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\u0639\u0646\u0627\u0635\u0631"} \u06C1\u0648\u0646\u06D2 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u06D2`; + return `\u0628\u06C1\u062A \u0628\u0691\u0627: ${(_e = issue2.origin) != null ? _e : "\u0648\u06CC\u0644\u06CC\u0648"} \u06A9\u0627 ${adj}${issue2.maximum.toString()} \u06C1\u0648\u0646\u0627 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `\u0628\u06C1\u062A \u0686\u06BE\u0648\u0679\u0627: ${issue2.origin} \u06A9\u06D2 ${adj}${issue2.minimum.toString()} ${sizing.unit} \u06C1\u0648\u0646\u06D2 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u06D2`; + } + return `\u0628\u06C1\u062A \u0686\u06BE\u0648\u0679\u0627: ${issue2.origin} \u06A9\u0627 ${adj}${issue2.minimum.toString()} \u06C1\u0648\u0646\u0627 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") { + return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: "${_issue.prefix}" \u0633\u06D2 \u0634\u0631\u0648\u0639 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`; + } + if (_issue.format === "ends_with") + return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: "${_issue.suffix}" \u067E\u0631 \u062E\u062A\u0645 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`; + if (_issue.format === "includes") + return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: "${_issue.includes}" \u0634\u0627\u0645\u0644 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`; + if (_issue.format === "regex") + return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: \u067E\u06CC\u0679\u0631\u0646 ${_issue.pattern} \u0633\u06D2 \u0645\u06CC\u0686 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`; + return `\u063A\u0644\u0637 ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format}`; + } + case "not_multiple_of": + return `\u063A\u0644\u0637 \u0646\u0645\u0628\u0631: ${issue2.divisor} \u06A9\u0627 \u0645\u0636\u0627\u0639\u0641 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`; + case "unrecognized_keys": + return `\u063A\u06CC\u0631 \u062A\u0633\u0644\u06CC\u0645 \u0634\u062F\u06C1 \u06A9\u06CC${issue2.keys.length > 1 ? "\u0632" : ""}: ${joinValues(issue2.keys, "\u060C ")}`; + case "invalid_key": + return `${issue2.origin} \u0645\u06CC\u06BA \u063A\u0644\u0637 \u06A9\u06CC`; + case "invalid_union": + return "\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679"; + case "invalid_element": + return `${issue2.origin} \u0645\u06CC\u06BA \u063A\u0644\u0637 \u0648\u06CC\u0644\u06CC\u0648`; + default: + return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679`; + } + }; +}; +function ur_default() { + return { + localeError: error42() + }; +} + +// node_modules/zod/v4/locales/uz.js +var error43 = () => { + const Sizable = { + string: { unit: "belgi", verb: "bo\u2018lishi kerak" }, + file: { unit: "bayt", verb: "bo\u2018lishi kerak" }, + array: { unit: "element", verb: "bo\u2018lishi kerak" }, + set: { unit: "element", verb: "bo\u2018lishi kerak" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "kirish", + email: "elektron pochta manzili", + url: "URL", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO sana va vaqti", + date: "ISO sana", + time: "ISO vaqt", + duration: "ISO davomiylik", + ipv4: "IPv4 manzil", + ipv6: "IPv6 manzil", + mac: "MAC manzil", + cidrv4: "IPv4 diapazon", + cidrv6: "IPv6 diapazon", + base64: "base64 kodlangan satr", + base64url: "base64url kodlangan satr", + json_string: "JSON satr", + e164: "E.164 raqam", + jwt: "JWT", + template_literal: "kirish" + }; + const TypeDictionary = { + nan: "NaN", + number: "raqam", + array: "massiv" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `Noto\u2018g\u2018ri kirish: kutilgan instanceof ${issue2.expected}, qabul qilingan ${received}`; + } + return `Noto\u2018g\u2018ri kirish: kutilgan ${expected}, qabul qilingan ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `Noto\u2018g\u2018ri kirish: kutilgan ${stringifyPrimitive(issue2.values[0])}`; + return `Noto\u2018g\u2018ri variant: quyidagilardan biri kutilgan ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `Juda katta: kutilgan ${(_c = issue2.origin) != null ? _c : "qiymat"} ${adj}${issue2.maximum.toString()} ${sizing.unit} ${sizing.verb}`; + return `Juda katta: kutilgan ${(_d = issue2.origin) != null ? _d : "qiymat"} ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `Juda kichik: kutilgan ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit} ${sizing.verb}`; + } + return `Juda kichik: kutilgan ${issue2.origin} ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `Noto\u2018g\u2018ri satr: "${_issue.prefix}" bilan boshlanishi kerak`; + if (_issue.format === "ends_with") + return `Noto\u2018g\u2018ri satr: "${_issue.suffix}" bilan tugashi kerak`; + if (_issue.format === "includes") + return `Noto\u2018g\u2018ri satr: "${_issue.includes}" ni o\u2018z ichiga olishi kerak`; + if (_issue.format === "regex") + return `Noto\u2018g\u2018ri satr: ${_issue.pattern} shabloniga mos kelishi kerak`; + return `Noto\u2018g\u2018ri ${(_e = FormatDictionary[_issue.format]) != null ? _e : issue2.format}`; + } + case "not_multiple_of": + return `Noto\u2018g\u2018ri raqam: ${issue2.divisor} ning karralisi bo\u2018lishi kerak`; + case "unrecognized_keys": + return `Noma\u2019lum kalit${issue2.keys.length > 1 ? "lar" : ""}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `${issue2.origin} dagi kalit noto\u2018g\u2018ri`; + case "invalid_union": + return "Noto\u2018g\u2018ri kirish"; + case "invalid_element": + return `${issue2.origin} da noto\u2018g\u2018ri qiymat`; + default: + return `Noto\u2018g\u2018ri kirish`; + } + }; +}; +function uz_default() { + return { + localeError: error43() + }; +} + +// node_modules/zod/v4/locales/vi.js +var error44 = () => { + const Sizable = { + string: { unit: "k\xFD t\u1EF1", verb: "c\xF3" }, + file: { unit: "byte", verb: "c\xF3" }, + array: { unit: "ph\u1EA7n t\u1EED", verb: "c\xF3" }, + set: { unit: "ph\u1EA7n t\u1EED", verb: "c\xF3" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "\u0111\u1EA7u v\xE0o", + email: "\u0111\u1ECBa ch\u1EC9 email", + url: "URL", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ng\xE0y gi\u1EDD ISO", + date: "ng\xE0y ISO", + time: "gi\u1EDD ISO", + duration: "kho\u1EA3ng th\u1EDDi gian ISO", + ipv4: "\u0111\u1ECBa ch\u1EC9 IPv4", + ipv6: "\u0111\u1ECBa ch\u1EC9 IPv6", + cidrv4: "d\u1EA3i IPv4", + cidrv6: "d\u1EA3i IPv6", + base64: "chu\u1ED7i m\xE3 h\xF3a base64", + base64url: "chu\u1ED7i m\xE3 h\xF3a base64url", + json_string: "chu\u1ED7i JSON", + e164: "s\u1ED1 E.164", + jwt: "JWT", + template_literal: "\u0111\u1EA7u v\xE0o" + }; + const TypeDictionary = { + nan: "NaN", + number: "s\u1ED1", + array: "m\u1EA3ng" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i instanceof ${issue2.expected}, nh\u1EADn \u0111\u01B0\u1EE3c ${received}`; + } + return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i ${expected}, nh\u1EADn \u0111\u01B0\u1EE3c ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i ${stringifyPrimitive(issue2.values[0])}`; + return `T\xF9y ch\u1ECDn kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i m\u1ED9t trong c\xE1c gi\xE1 tr\u1ECB ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `Qu\xE1 l\u1EDBn: mong \u0111\u1EE3i ${(_c = issue2.origin) != null ? _c : "gi\xE1 tr\u1ECB"} ${sizing.verb} ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "ph\u1EA7n t\u1EED"}`; + return `Qu\xE1 l\u1EDBn: mong \u0111\u1EE3i ${(_e = issue2.origin) != null ? _e : "gi\xE1 tr\u1ECB"} ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `Qu\xE1 nh\u1ECF: mong \u0111\u1EE3i ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`; + } + return `Qu\xE1 nh\u1ECF: mong \u0111\u1EE3i ${issue2.origin} ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i b\u1EAFt \u0111\u1EA7u b\u1EB1ng "${_issue.prefix}"`; + if (_issue.format === "ends_with") + return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i k\u1EBFt th\xFAc b\u1EB1ng "${_issue.suffix}"`; + if (_issue.format === "includes") + return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i bao g\u1ED3m "${_issue.includes}"`; + if (_issue.format === "regex") + return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i kh\u1EDBp v\u1EDBi m\u1EABu ${_issue.pattern}`; + return `${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format} kh\xF4ng h\u1EE3p l\u1EC7`; + } + case "not_multiple_of": + return `S\u1ED1 kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i l\xE0 b\u1ED9i s\u1ED1 c\u1EE7a ${issue2.divisor}`; + case "unrecognized_keys": + return `Kh\xF3a kh\xF4ng \u0111\u01B0\u1EE3c nh\u1EADn d\u1EA1ng: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `Kh\xF3a kh\xF4ng h\u1EE3p l\u1EC7 trong ${issue2.origin}`; + case "invalid_union": + return "\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7"; + case "invalid_element": + return `Gi\xE1 tr\u1ECB kh\xF4ng h\u1EE3p l\u1EC7 trong ${issue2.origin}`; + default: + return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7`; + } + }; +}; +function vi_default() { + return { + localeError: error44() + }; +} + +// node_modules/zod/v4/locales/zh-CN.js +var error45 = () => { + const Sizable = { + string: { unit: "\u5B57\u7B26", verb: "\u5305\u542B" }, + file: { unit: "\u5B57\u8282", verb: "\u5305\u542B" }, + array: { unit: "\u9879", verb: "\u5305\u542B" }, + set: { unit: "\u9879", verb: "\u5305\u542B" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "\u8F93\u5165", + email: "\u7535\u5B50\u90AE\u4EF6", + url: "URL", + emoji: "\u8868\u60C5\u7B26\u53F7", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO\u65E5\u671F\u65F6\u95F4", + date: "ISO\u65E5\u671F", + time: "ISO\u65F6\u95F4", + duration: "ISO\u65F6\u957F", + ipv4: "IPv4\u5730\u5740", + ipv6: "IPv6\u5730\u5740", + cidrv4: "IPv4\u7F51\u6BB5", + cidrv6: "IPv6\u7F51\u6BB5", + base64: "base64\u7F16\u7801\u5B57\u7B26\u4E32", + base64url: "base64url\u7F16\u7801\u5B57\u7B26\u4E32", + json_string: "JSON\u5B57\u7B26\u4E32", + e164: "E.164\u53F7\u7801", + jwt: "JWT", + template_literal: "\u8F93\u5165" + }; + const TypeDictionary = { + nan: "NaN", + number: "\u6570\u5B57", + array: "\u6570\u7EC4", + null: "\u7A7A\u503C(null)" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B instanceof ${issue2.expected}\uFF0C\u5B9E\u9645\u63A5\u6536 ${received}`; + } + return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B ${expected}\uFF0C\u5B9E\u9645\u63A5\u6536 ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B ${stringifyPrimitive(issue2.values[0])}`; + return `\u65E0\u6548\u9009\u9879\uFF1A\u671F\u671B\u4EE5\u4E0B\u4E4B\u4E00 ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `\u6570\u503C\u8FC7\u5927\uFF1A\u671F\u671B ${(_c = issue2.origin) != null ? _c : "\u503C"} ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\u4E2A\u5143\u7D20"}`; + return `\u6570\u503C\u8FC7\u5927\uFF1A\u671F\u671B ${(_e = issue2.origin) != null ? _e : "\u503C"} ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `\u6570\u503C\u8FC7\u5C0F\uFF1A\u671F\u671B ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit}`; + } + return `\u6570\u503C\u8FC7\u5C0F\uFF1A\u671F\u671B ${issue2.origin} ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u4EE5 "${_issue.prefix}" \u5F00\u5934`; + if (_issue.format === "ends_with") + return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u4EE5 "${_issue.suffix}" \u7ED3\u5C3E`; + if (_issue.format === "includes") + return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u5305\u542B "${_issue.includes}"`; + if (_issue.format === "regex") + return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u6EE1\u8DB3\u6B63\u5219\u8868\u8FBE\u5F0F ${_issue.pattern}`; + return `\u65E0\u6548${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format}`; + } + case "not_multiple_of": + return `\u65E0\u6548\u6570\u5B57\uFF1A\u5FC5\u987B\u662F ${issue2.divisor} \u7684\u500D\u6570`; + case "unrecognized_keys": + return `\u51FA\u73B0\u672A\u77E5\u7684\u952E(key): ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `${issue2.origin} \u4E2D\u7684\u952E(key)\u65E0\u6548`; + case "invalid_union": + return "\u65E0\u6548\u8F93\u5165"; + case "invalid_element": + return `${issue2.origin} \u4E2D\u5305\u542B\u65E0\u6548\u503C(value)`; + default: + return `\u65E0\u6548\u8F93\u5165`; + } + }; +}; +function zh_CN_default2() { + return { + localeError: error45() + }; +} + +// node_modules/zod/v4/locales/zh-TW.js +var error46 = () => { + const Sizable = { + string: { unit: "\u5B57\u5143", verb: "\u64C1\u6709" }, + file: { unit: "\u4F4D\u5143\u7D44", verb: "\u64C1\u6709" }, + array: { unit: "\u9805\u76EE", verb: "\u64C1\u6709" }, + set: { unit: "\u9805\u76EE", verb: "\u64C1\u6709" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "\u8F38\u5165", + email: "\u90F5\u4EF6\u5730\u5740", + url: "URL", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO \u65E5\u671F\u6642\u9593", + date: "ISO \u65E5\u671F", + time: "ISO \u6642\u9593", + duration: "ISO \u671F\u9593", + ipv4: "IPv4 \u4F4D\u5740", + ipv6: "IPv6 \u4F4D\u5740", + cidrv4: "IPv4 \u7BC4\u570D", + cidrv6: "IPv6 \u7BC4\u570D", + base64: "base64 \u7DE8\u78BC\u5B57\u4E32", + base64url: "base64url \u7DE8\u78BC\u5B57\u4E32", + json_string: "JSON \u5B57\u4E32", + e164: "E.164 \u6578\u503C", + jwt: "JWT", + template_literal: "\u8F38\u5165" + }; + const TypeDictionary = { + nan: "NaN" + }; + return (issue2) => { + var _a3, _b2, _c, _d, _e, _f; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA instanceof ${issue2.expected}\uFF0C\u4F46\u6536\u5230 ${received}`; + } + return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA ${expected}\uFF0C\u4F46\u6536\u5230 ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA ${stringifyPrimitive(issue2.values[0])}`; + return `\u7121\u6548\u7684\u9078\u9805\uFF1A\u9810\u671F\u70BA\u4EE5\u4E0B\u5176\u4E2D\u4E4B\u4E00 ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `\u6578\u503C\u904E\u5927\uFF1A\u9810\u671F ${(_c = issue2.origin) != null ? _c : "\u503C"} \u61C9\u70BA ${adj}${issue2.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\u500B\u5143\u7D20"}`; + return `\u6578\u503C\u904E\u5927\uFF1A\u9810\u671F ${(_e = issue2.origin) != null ? _e : "\u503C"} \u61C9\u70BA ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `\u6578\u503C\u904E\u5C0F\uFF1A\u9810\u671F ${issue2.origin} \u61C9\u70BA ${adj}${issue2.minimum.toString()} ${sizing.unit}`; + } + return `\u6578\u503C\u904E\u5C0F\uFF1A\u9810\u671F ${issue2.origin} \u61C9\u70BA ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") { + return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u4EE5 "${_issue.prefix}" \u958B\u982D`; + } + if (_issue.format === "ends_with") + return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u4EE5 "${_issue.suffix}" \u7D50\u5C3E`; + if (_issue.format === "includes") + return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u5305\u542B "${_issue.includes}"`; + if (_issue.format === "regex") + return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u7B26\u5408\u683C\u5F0F ${_issue.pattern}`; + return `\u7121\u6548\u7684 ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue2.format}`; + } + case "not_multiple_of": + return `\u7121\u6548\u7684\u6578\u5B57\uFF1A\u5FC5\u9808\u70BA ${issue2.divisor} \u7684\u500D\u6578`; + case "unrecognized_keys": + return `\u7121\u6CD5\u8B58\u5225\u7684\u9375\u503C${issue2.keys.length > 1 ? "\u5011" : ""}\uFF1A${joinValues(issue2.keys, "\u3001")}`; + case "invalid_key": + return `${issue2.origin} \u4E2D\u6709\u7121\u6548\u7684\u9375\u503C`; + case "invalid_union": + return "\u7121\u6548\u7684\u8F38\u5165\u503C"; + case "invalid_element": + return `${issue2.origin} \u4E2D\u6709\u7121\u6548\u7684\u503C`; + default: + return `\u7121\u6548\u7684\u8F38\u5165\u503C`; + } + }; +}; +function zh_TW_default2() { + return { + localeError: error46() + }; +} + +// node_modules/zod/v4/locales/yo.js +var error47 = () => { + const Sizable = { + string: { unit: "\xE0mi", verb: "n\xED" }, + file: { unit: "bytes", verb: "n\xED" }, + array: { unit: "nkan", verb: "n\xED" }, + set: { unit: "nkan", verb: "n\xED" } + }; + function getSizing(origin) { + var _a3; + return (_a3 = Sizable[origin]) != null ? _a3 : null; + } + const FormatDictionary = { + regex: "\u1EB9\u0300r\u1ECD \xECb\xE1w\u1ECDl\xE9", + email: "\xE0d\xEDr\u1EB9\u0301s\xEC \xECm\u1EB9\u0301l\xEC", + url: "URL", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "\xE0k\xF3k\xF2 ISO", + date: "\u1ECDj\u1ECD\u0301 ISO", + time: "\xE0k\xF3k\xF2 ISO", + duration: "\xE0k\xF3k\xF2 t\xF3 p\xE9 ISO", + ipv4: "\xE0d\xEDr\u1EB9\u0301s\xEC IPv4", + ipv6: "\xE0d\xEDr\u1EB9\u0301s\xEC IPv6", + cidrv4: "\xE0gb\xE8gb\xE8 IPv4", + cidrv6: "\xE0gb\xE8gb\xE8 IPv6", + base64: "\u1ECD\u0300r\u1ECD\u0300 t\xED a k\u1ECD\u0301 n\xED base64", + base64url: "\u1ECD\u0300r\u1ECD\u0300 base64url", + json_string: "\u1ECD\u0300r\u1ECD\u0300 JSON", + e164: "n\u1ECD\u0301mb\xE0 E.164", + jwt: "JWT", + template_literal: "\u1EB9\u0300r\u1ECD \xECb\xE1w\u1ECDl\xE9" + }; + const TypeDictionary = { + nan: "NaN", + number: "n\u1ECD\u0301mb\xE0", + array: "akop\u1ECD" + }; + return (issue2) => { + var _a3, _b2, _c, _d; + switch (issue2.code) { + case "invalid_type": { + const expected = (_a3 = TypeDictionary[issue2.expected]) != null ? _a3 : issue2.expected; + const receivedType = parsedType(issue2.input); + const received = (_b2 = TypeDictionary[receivedType]) != null ? _b2 : receivedType; + if (/^[A-Z]/.test(issue2.expected)) { + return `\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e: a n\xED l\xE1ti fi instanceof ${issue2.expected}, \xE0m\u1ECD\u0300 a r\xED ${received}`; + } + return `\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e: a n\xED l\xE1ti fi ${expected}, \xE0m\u1ECD\u0300 a r\xED ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e: a n\xED l\xE1ti fi ${stringifyPrimitive(issue2.values[0])}`; + return `\xC0\u1E63\xE0y\xE0n a\u1E63\xEC\u1E63e: yan \u1ECD\u0300kan l\xE1ra ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `T\xF3 p\u1ECD\u0300 j\xF9: a n\xED l\xE1ti j\u1EB9\u0301 p\xE9 ${(_c = issue2.origin) != null ? _c : "iye"} ${sizing.verb} ${adj}${issue2.maximum} ${sizing.unit}`; + return `T\xF3 p\u1ECD\u0300 j\xF9: a n\xED l\xE1ti j\u1EB9\u0301 ${adj}${issue2.maximum}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `K\xE9r\xE9 ju: a n\xED l\xE1ti j\u1EB9\u0301 p\xE9 ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum} ${sizing.unit}`; + return `K\xE9r\xE9 ju: a n\xED l\xE1ti j\u1EB9\u0301 ${adj}${issue2.minimum}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") + return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 b\u1EB9\u0300r\u1EB9\u0300 p\u1EB9\u0300l\xFA "${_issue.prefix}"`; + if (_issue.format === "ends_with") + return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 par\xED p\u1EB9\u0300l\xFA "${_issue.suffix}"`; + if (_issue.format === "includes") + return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 n\xED "${_issue.includes}"`; + if (_issue.format === "regex") + return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 b\xE1 \xE0p\u1EB9\u1EB9r\u1EB9 mu ${_issue.pattern}`; + return `A\u1E63\xEC\u1E63e: ${(_d = FormatDictionary[_issue.format]) != null ? _d : issue2.format}`; + } + case "not_multiple_of": + return `N\u1ECD\u0301mb\xE0 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 j\u1EB9\u0301 \xE8y\xE0 p\xEDp\xEDn ti ${issue2.divisor}`; + case "unrecognized_keys": + return `B\u1ECDt\xECn\xEC \xE0\xECm\u1ECD\u0300: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `B\u1ECDt\xECn\xEC a\u1E63\xEC\u1E63e n\xEDn\xFA ${issue2.origin}`; + case "invalid_union": + return "\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e"; + case "invalid_element": + return `Iye a\u1E63\xEC\u1E63e n\xEDn\xFA ${issue2.origin}`; + default: + return "\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e"; + } + }; +}; +function yo_default() { + return { + localeError: error47() + }; +} + +// node_modules/zod/v4/core/registries.js +var _a; +var $output = /* @__PURE__ */ Symbol("ZodOutput"); +var $input = /* @__PURE__ */ Symbol("ZodInput"); +var $ZodRegistry = class { + constructor() { + this._map = /* @__PURE__ */ new WeakMap(); + this._idmap = /* @__PURE__ */ new Map(); + } + add(schema, ..._meta) { + const meta3 = _meta[0]; + this._map.set(schema, meta3); + if (meta3 && typeof meta3 === "object" && "id" in meta3) { + this._idmap.set(meta3.id, schema); + } + return this; + } + clear() { + this._map = /* @__PURE__ */ new WeakMap(); + this._idmap = /* @__PURE__ */ new Map(); + return this; + } + remove(schema) { + const meta3 = this._map.get(schema); + if (meta3 && typeof meta3 === "object" && "id" in meta3) { + this._idmap.delete(meta3.id); + } + this._map.delete(schema); + return this; + } + get(schema) { + var _a3; + const p = schema._zod.parent; + if (p) { + const pm = { ...(_a3 = this.get(p)) != null ? _a3 : {} }; + delete pm.id; + const f6 = { ...pm, ...this._map.get(schema) }; + return Object.keys(f6).length ? f6 : void 0; + } + return this._map.get(schema); + } + has(schema) { + return this._map.has(schema); + } +}; +function registry() { + return new $ZodRegistry(); +} +var _a2; +(_a2 = (_a = globalThis).__zod_globalRegistry) != null ? _a2 : _a.__zod_globalRegistry = registry(); +var globalRegistry = globalThis.__zod_globalRegistry; + +// node_modules/zod/v4/core/api.js +// @__NO_SIDE_EFFECTS__ +function _string(Class2, params) { + return new Class2({ + type: "string", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _coercedString(Class2, params) { + return new Class2({ + type: "string", + coerce: true, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _email(Class2, params) { + return new Class2({ + type: "string", + format: "email", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _guid(Class2, params) { + return new Class2({ + type: "string", + format: "guid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _uuid(Class2, params) { + return new Class2({ + type: "string", + format: "uuid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _uuidv4(Class2, params) { + return new Class2({ + type: "string", + format: "uuid", + check: "string_format", + abort: false, + version: "v4", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _uuidv6(Class2, params) { + return new Class2({ + type: "string", + format: "uuid", + check: "string_format", + abort: false, + version: "v6", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _uuidv7(Class2, params) { + return new Class2({ + type: "string", + format: "uuid", + check: "string_format", + abort: false, + version: "v7", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _url(Class2, params) { + return new Class2({ + type: "string", + format: "url", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _emoji2(Class2, params) { + return new Class2({ + type: "string", + format: "emoji", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _nanoid(Class2, params) { + return new Class2({ + type: "string", + format: "nanoid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _cuid(Class2, params) { + return new Class2({ + type: "string", + format: "cuid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _cuid2(Class2, params) { + return new Class2({ + type: "string", + format: "cuid2", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _ulid(Class2, params) { + return new Class2({ + type: "string", + format: "ulid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _xid(Class2, params) { + return new Class2({ + type: "string", + format: "xid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _ksuid(Class2, params) { + return new Class2({ + type: "string", + format: "ksuid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _ipv4(Class2, params) { + return new Class2({ + type: "string", + format: "ipv4", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _ipv6(Class2, params) { + return new Class2({ + type: "string", + format: "ipv6", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _mac(Class2, params) { + return new Class2({ + type: "string", + format: "mac", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _cidrv4(Class2, params) { + return new Class2({ + type: "string", + format: "cidrv4", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _cidrv6(Class2, params) { + return new Class2({ + type: "string", + format: "cidrv6", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _base64(Class2, params) { + return new Class2({ + type: "string", + format: "base64", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _base64url(Class2, params) { + return new Class2({ + type: "string", + format: "base64url", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _e164(Class2, params) { + return new Class2({ + type: "string", + format: "e164", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _jwt(Class2, params) { + return new Class2({ + type: "string", + format: "jwt", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +var TimePrecision = { + Any: null, + Minute: -1, + Second: 0, + Millisecond: 3, + Microsecond: 6 +}; +// @__NO_SIDE_EFFECTS__ +function _isoDateTime(Class2, params) { + return new Class2({ + type: "string", + format: "datetime", + check: "string_format", + offset: false, + local: false, + precision: null, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _isoDate(Class2, params) { + return new Class2({ + type: "string", + format: "date", + check: "string_format", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _isoTime(Class2, params) { + return new Class2({ + type: "string", + format: "time", + check: "string_format", + precision: null, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _isoDuration(Class2, params) { + return new Class2({ + type: "string", + format: "duration", + check: "string_format", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _number(Class2, params) { + return new Class2({ + type: "number", + checks: [], + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _coercedNumber(Class2, params) { + return new Class2({ + type: "number", + coerce: true, + checks: [], + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _int(Class2, params) { + return new Class2({ + type: "number", + check: "number_format", + abort: false, + format: "safeint", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _float32(Class2, params) { + return new Class2({ + type: "number", + check: "number_format", + abort: false, + format: "float32", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _float64(Class2, params) { + return new Class2({ + type: "number", + check: "number_format", + abort: false, + format: "float64", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _int32(Class2, params) { + return new Class2({ + type: "number", + check: "number_format", + abort: false, + format: "int32", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _uint32(Class2, params) { + return new Class2({ + type: "number", + check: "number_format", + abort: false, + format: "uint32", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _boolean(Class2, params) { + return new Class2({ + type: "boolean", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _coercedBoolean(Class2, params) { + return new Class2({ + type: "boolean", + coerce: true, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _bigint(Class2, params) { + return new Class2({ + type: "bigint", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _coercedBigint(Class2, params) { + return new Class2({ + type: "bigint", + coerce: true, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _int64(Class2, params) { + return new Class2({ + type: "bigint", + check: "bigint_format", + abort: false, + format: "int64", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _uint64(Class2, params) { + return new Class2({ + type: "bigint", + check: "bigint_format", + abort: false, + format: "uint64", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _symbol(Class2, params) { + return new Class2({ + type: "symbol", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _undefined2(Class2, params) { + return new Class2({ + type: "undefined", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _null2(Class2, params) { + return new Class2({ + type: "null", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _any(Class2) { + return new Class2({ + type: "any" + }); +} +// @__NO_SIDE_EFFECTS__ +function _unknown(Class2) { + return new Class2({ + type: "unknown" + }); +} +// @__NO_SIDE_EFFECTS__ +function _never(Class2, params) { + return new Class2({ + type: "never", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _void(Class2, params) { + return new Class2({ + type: "void", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _date(Class2, params) { + return new Class2({ + type: "date", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _coercedDate(Class2, params) { + return new Class2({ + type: "date", + coerce: true, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _nan(Class2, params) { + return new Class2({ + type: "nan", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _lt(value, params) { + return new $ZodCheckLessThan({ + check: "less_than", + ...normalizeParams(params), + value, + inclusive: false + }); +} +// @__NO_SIDE_EFFECTS__ +function _lte(value, params) { + return new $ZodCheckLessThan({ + check: "less_than", + ...normalizeParams(params), + value, + inclusive: true + }); +} +// @__NO_SIDE_EFFECTS__ +function _gt(value, params) { + return new $ZodCheckGreaterThan({ + check: "greater_than", + ...normalizeParams(params), + value, + inclusive: false + }); +} +// @__NO_SIDE_EFFECTS__ +function _gte(value, params) { + return new $ZodCheckGreaterThan({ + check: "greater_than", + ...normalizeParams(params), + value, + inclusive: true + }); +} +// @__NO_SIDE_EFFECTS__ +function _positive(params) { + return /* @__PURE__ */ _gt(0, params); +} +// @__NO_SIDE_EFFECTS__ +function _negative(params) { + return /* @__PURE__ */ _lt(0, params); +} +// @__NO_SIDE_EFFECTS__ +function _nonpositive(params) { + return /* @__PURE__ */ _lte(0, params); +} +// @__NO_SIDE_EFFECTS__ +function _nonnegative(params) { + return /* @__PURE__ */ _gte(0, params); +} +// @__NO_SIDE_EFFECTS__ +function _multipleOf(value, params) { + return new $ZodCheckMultipleOf({ + check: "multiple_of", + ...normalizeParams(params), + value + }); +} +// @__NO_SIDE_EFFECTS__ +function _maxSize(maximum, params) { + return new $ZodCheckMaxSize({ + check: "max_size", + ...normalizeParams(params), + maximum + }); +} +// @__NO_SIDE_EFFECTS__ +function _minSize(minimum, params) { + return new $ZodCheckMinSize({ + check: "min_size", + ...normalizeParams(params), + minimum + }); +} +// @__NO_SIDE_EFFECTS__ +function _size(size, params) { + return new $ZodCheckSizeEquals({ + check: "size_equals", + ...normalizeParams(params), + size + }); +} +// @__NO_SIDE_EFFECTS__ +function _maxLength(maximum, params) { + const ch = new $ZodCheckMaxLength({ + check: "max_length", + ...normalizeParams(params), + maximum + }); + return ch; +} +// @__NO_SIDE_EFFECTS__ +function _minLength(minimum, params) { + return new $ZodCheckMinLength({ + check: "min_length", + ...normalizeParams(params), + minimum + }); +} +// @__NO_SIDE_EFFECTS__ +function _length(length, params) { + return new $ZodCheckLengthEquals({ + check: "length_equals", + ...normalizeParams(params), + length + }); +} +// @__NO_SIDE_EFFECTS__ +function _regex(pattern, params) { + return new $ZodCheckRegex({ + check: "string_format", + format: "regex", + ...normalizeParams(params), + pattern + }); +} +// @__NO_SIDE_EFFECTS__ +function _lowercase(params) { + return new $ZodCheckLowerCase({ + check: "string_format", + format: "lowercase", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _uppercase(params) { + return new $ZodCheckUpperCase({ + check: "string_format", + format: "uppercase", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _includes(includes, params) { + return new $ZodCheckIncludes({ + check: "string_format", + format: "includes", + ...normalizeParams(params), + includes + }); +} +// @__NO_SIDE_EFFECTS__ +function _startsWith(prefix, params) { + return new $ZodCheckStartsWith({ + check: "string_format", + format: "starts_with", + ...normalizeParams(params), + prefix + }); +} +// @__NO_SIDE_EFFECTS__ +function _endsWith(suffix, params) { + return new $ZodCheckEndsWith({ + check: "string_format", + format: "ends_with", + ...normalizeParams(params), + suffix + }); +} +// @__NO_SIDE_EFFECTS__ +function _property(property, schema, params) { + return new $ZodCheckProperty({ + check: "property", + property, + schema, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _mime(types, params) { + return new $ZodCheckMimeType({ + check: "mime_type", + mime: types, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _overwrite(tx) { + return new $ZodCheckOverwrite({ + check: "overwrite", + tx + }); +} +// @__NO_SIDE_EFFECTS__ +function _normalize(form) { + return /* @__PURE__ */ _overwrite((input) => input.normalize(form)); +} +// @__NO_SIDE_EFFECTS__ +function _trim() { + return /* @__PURE__ */ _overwrite((input) => input.trim()); +} +// @__NO_SIDE_EFFECTS__ +function _toLowerCase() { + return /* @__PURE__ */ _overwrite((input) => input.toLowerCase()); +} +// @__NO_SIDE_EFFECTS__ +function _toUpperCase() { + return /* @__PURE__ */ _overwrite((input) => input.toUpperCase()); +} +// @__NO_SIDE_EFFECTS__ +function _slugify() { + return /* @__PURE__ */ _overwrite((input) => slugify(input)); +} +// @__NO_SIDE_EFFECTS__ +function _array(Class2, element, params) { + return new Class2({ + type: "array", + element, + // get element() { + // return element; + // }, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _union(Class2, options, params) { + return new Class2({ + type: "union", + options, + ...normalizeParams(params) + }); +} +function _xor(Class2, options, params) { + return new Class2({ + type: "union", + options, + inclusive: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _discriminatedUnion(Class2, discriminator, options, params) { + return new Class2({ + type: "union", + options, + discriminator, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _intersection(Class2, left, right) { + return new Class2({ + type: "intersection", + left, + right + }); +} +// @__NO_SIDE_EFFECTS__ +function _tuple(Class2, items, _paramsOrRest, _params) { + const hasRest = _paramsOrRest instanceof $ZodType; + const params = hasRest ? _params : _paramsOrRest; + const rest = hasRest ? _paramsOrRest : null; + return new Class2({ + type: "tuple", + items, + rest, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _record(Class2, keyType, valueType, params) { + return new Class2({ + type: "record", + keyType, + valueType, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _map(Class2, keyType, valueType, params) { + return new Class2({ + type: "map", + keyType, + valueType, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _set(Class2, valueType, params) { + return new Class2({ + type: "set", + valueType, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _enum(Class2, values, params) { + const entries = Array.isArray(values) ? Object.fromEntries(values.map((v2) => [v2, v2])) : values; + return new Class2({ + type: "enum", + entries, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _nativeEnum(Class2, entries, params) { + return new Class2({ + type: "enum", + entries, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _literal(Class2, value, params) { + return new Class2({ + type: "literal", + values: Array.isArray(value) ? value : [value], + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _file(Class2, params) { + return new Class2({ + type: "file", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _transform(Class2, fn) { + return new Class2({ + type: "transform", + transform: fn + }); +} +// @__NO_SIDE_EFFECTS__ +function _optional(Class2, innerType) { + return new Class2({ + type: "optional", + innerType + }); +} +// @__NO_SIDE_EFFECTS__ +function _nullable(Class2, innerType) { + return new Class2({ + type: "nullable", + innerType + }); +} +// @__NO_SIDE_EFFECTS__ +function _default(Class2, innerType, defaultValue) { + return new Class2({ + type: "default", + innerType, + get defaultValue() { + return typeof defaultValue === "function" ? defaultValue() : shallowClone(defaultValue); + } + }); +} +// @__NO_SIDE_EFFECTS__ +function _nonoptional(Class2, innerType, params) { + return new Class2({ + type: "nonoptional", + innerType, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _success(Class2, innerType) { + return new Class2({ + type: "success", + innerType + }); +} +// @__NO_SIDE_EFFECTS__ +function _catch(Class2, innerType, catchValue) { + return new Class2({ + type: "catch", + innerType, + catchValue: typeof catchValue === "function" ? catchValue : () => catchValue + }); +} +// @__NO_SIDE_EFFECTS__ +function _pipe(Class2, in_, out) { + return new Class2({ + type: "pipe", + in: in_, + out + }); +} +// @__NO_SIDE_EFFECTS__ +function _readonly(Class2, innerType) { + return new Class2({ + type: "readonly", + innerType + }); +} +// @__NO_SIDE_EFFECTS__ +function _templateLiteral(Class2, parts, params) { + return new Class2({ + type: "template_literal", + parts, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _lazy(Class2, getter) { + return new Class2({ + type: "lazy", + getter + }); +} +// @__NO_SIDE_EFFECTS__ +function _promise(Class2, innerType) { + return new Class2({ + type: "promise", + innerType + }); +} +// @__NO_SIDE_EFFECTS__ +function _custom(Class2, fn, _params) { + var _a3; + const norm = normalizeParams(_params); + (_a3 = norm.abort) != null ? _a3 : norm.abort = true; + const schema = new Class2({ + type: "custom", + check: "custom", + fn, + ...norm + }); + return schema; +} +// @__NO_SIDE_EFFECTS__ +function _refine(Class2, fn, _params) { + const schema = new Class2({ + type: "custom", + check: "custom", + fn, + ...normalizeParams(_params) + }); + return schema; +} +// @__NO_SIDE_EFFECTS__ +function _superRefine(fn) { + const ch = /* @__PURE__ */ _check((payload) => { + payload.addIssue = (issue2) => { + var _a3, _b2, _c, _d; + if (typeof issue2 === "string") { + payload.issues.push(issue(issue2, payload.value, ch._zod.def)); + } else { + const _issue = issue2; + if (_issue.fatal) + _issue.continue = false; + (_a3 = _issue.code) != null ? _a3 : _issue.code = "custom"; + (_b2 = _issue.input) != null ? _b2 : _issue.input = payload.value; + (_c = _issue.inst) != null ? _c : _issue.inst = ch; + (_d = _issue.continue) != null ? _d : _issue.continue = !ch._zod.def.abort; + payload.issues.push(issue(_issue)); + } + }; + return fn(payload.value, payload); + }); + return ch; +} +// @__NO_SIDE_EFFECTS__ +function _check(fn, params) { + const ch = new $ZodCheck({ + check: "custom", + ...normalizeParams(params) + }); + ch._zod.check = fn; + return ch; +} +// @__NO_SIDE_EFFECTS__ +function describe(description) { + const ch = new $ZodCheck({ check: "describe" }); + ch._zod.onattach = [ + (inst) => { + var _a3; + const existing = (_a3 = globalRegistry.get(inst)) != null ? _a3 : {}; + globalRegistry.add(inst, { ...existing, description }); + } + ]; + ch._zod.check = () => { + }; + return ch; +} +// @__NO_SIDE_EFFECTS__ +function meta(metadata) { + const ch = new $ZodCheck({ check: "meta" }); + ch._zod.onattach = [ + (inst) => { + var _a3; + const existing = (_a3 = globalRegistry.get(inst)) != null ? _a3 : {}; + globalRegistry.add(inst, { ...existing, ...metadata }); + } + ]; + ch._zod.check = () => { + }; + return ch; +} +// @__NO_SIDE_EFFECTS__ +function _stringbool(Classes, _params) { + var _a3, _b2, _c, _d, _e; + const params = normalizeParams(_params); + let truthyArray = (_a3 = params.truthy) != null ? _a3 : ["true", "1", "yes", "on", "y", "enabled"]; + let falsyArray = (_b2 = params.falsy) != null ? _b2 : ["false", "0", "no", "off", "n", "disabled"]; + if (params.case !== "sensitive") { + truthyArray = truthyArray.map((v2) => typeof v2 === "string" ? v2.toLowerCase() : v2); + falsyArray = falsyArray.map((v2) => typeof v2 === "string" ? v2.toLowerCase() : v2); + } + const truthySet = new Set(truthyArray); + const falsySet = new Set(falsyArray); + const _Codec = (_c = Classes.Codec) != null ? _c : $ZodCodec; + const _Boolean = (_d = Classes.Boolean) != null ? _d : $ZodBoolean; + const _String = (_e = Classes.String) != null ? _e : $ZodString; + const stringSchema = new _String({ type: "string", error: params.error }); + const booleanSchema = new _Boolean({ type: "boolean", error: params.error }); + const codec2 = new _Codec({ + type: "pipe", + in: stringSchema, + out: booleanSchema, + transform: ((input, payload) => { + let data = input; + if (params.case !== "sensitive") + data = data.toLowerCase(); + if (truthySet.has(data)) { + return true; + } else if (falsySet.has(data)) { + return false; + } else { + payload.issues.push({ + code: "invalid_value", + expected: "stringbool", + values: [...truthySet, ...falsySet], + input: payload.value, + inst: codec2, + continue: false + }); + return {}; + } + }), + reverseTransform: ((input, _payload) => { + if (input === true) { + return truthyArray[0] || "true"; + } else { + return falsyArray[0] || "false"; + } + }), + error: params.error + }); + return codec2; +} +// @__NO_SIDE_EFFECTS__ +function _stringFormat(Class2, format, fnOrRegex, _params = {}) { + const params = normalizeParams(_params); + const def = { + ...normalizeParams(_params), + check: "string_format", + type: "string", + format, + fn: typeof fnOrRegex === "function" ? fnOrRegex : (val) => fnOrRegex.test(val), + ...params + }; + if (fnOrRegex instanceof RegExp) { + def.pattern = fnOrRegex; + } + const inst = new Class2(def); + return inst; +} + +// node_modules/zod/v4/core/to-json-schema.js +function initializeContext(params) { + var _a3, _b2, _c, _d, _e, _f, _g, _h, _i; + let target = (_a3 = params == null ? void 0 : params.target) != null ? _a3 : "draft-2020-12"; + if (target === "draft-4") + target = "draft-04"; + if (target === "draft-7") + target = "draft-07"; + return { + processors: (_b2 = params.processors) != null ? _b2 : {}, + metadataRegistry: (_c = params == null ? void 0 : params.metadata) != null ? _c : globalRegistry, + target, + unrepresentable: (_d = params == null ? void 0 : params.unrepresentable) != null ? _d : "throw", + override: (_e = params == null ? void 0 : params.override) != null ? _e : (() => { + }), + io: (_f = params == null ? void 0 : params.io) != null ? _f : "output", + counter: 0, + seen: /* @__PURE__ */ new Map(), + cycles: (_g = params == null ? void 0 : params.cycles) != null ? _g : "ref", + reused: (_h = params == null ? void 0 : params.reused) != null ? _h : "inline", + external: (_i = params == null ? void 0 : params.external) != null ? _i : void 0 + }; +} +function process2(schema, ctx, _params = { path: [], schemaPath: [] }) { + var _a4, _b2, _c; + var _a3; + const def = schema._zod.def; + const seen = ctx.seen.get(schema); + if (seen) { + seen.count++; + const isCycle = _params.schemaPath.includes(schema); + if (isCycle) { + seen.cycle = _params.path; + } + return seen.schema; + } + const result = { schema: {}, count: 1, cycle: void 0, path: _params.path }; + ctx.seen.set(schema, result); + const overrideSchema = (_b2 = (_a4 = schema._zod).toJSONSchema) == null ? void 0 : _b2.call(_a4); + if (overrideSchema) { + result.schema = overrideSchema; + } else { + const params = { + ..._params, + schemaPath: [..._params.schemaPath, schema], + path: _params.path + }; + if (schema._zod.processJSONSchema) { + schema._zod.processJSONSchema(ctx, result.schema, params); + } else { + const _json = result.schema; + const processor = ctx.processors[def.type]; + if (!processor) { + throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`); + } + processor(schema, ctx, _json, params); + } + const parent = schema._zod.parent; + if (parent) { + if (!result.ref) + result.ref = parent; + process2(parent, ctx, params); + ctx.seen.get(parent).isParent = true; + } + } + const meta3 = ctx.metadataRegistry.get(schema); + if (meta3) + Object.assign(result.schema, meta3); + if (ctx.io === "input" && isTransforming(schema)) { + delete result.schema.examples; + delete result.schema.default; + } + if (ctx.io === "input" && result.schema._prefault) + (_c = (_a3 = result.schema).default) != null ? _c : _a3.default = result.schema._prefault; + delete result.schema._prefault; + const _result = ctx.seen.get(schema); + return _result.schema; +} +function extractDefs(ctx, schema) { + var _a3, _b2, _c, _d; + const root = ctx.seen.get(schema); + if (!root) + throw new Error("Unprocessed schema. This is a bug in Zod."); + const idToSchema = /* @__PURE__ */ new Map(); + for (const entry of ctx.seen.entries()) { + const id = (_a3 = ctx.metadataRegistry.get(entry[0])) == null ? void 0 : _a3.id; + if (id) { + const existing = idToSchema.get(id); + if (existing && existing !== entry[0]) { + throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`); + } + idToSchema.set(id, entry[0]); + } + } + const makeURI = (entry) => { + var _a4, _b3, _c2, _d2, _e; + const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions"; + if (ctx.external) { + const externalId = (_a4 = ctx.external.registry.get(entry[0])) == null ? void 0 : _a4.id; + const uriGenerator = (_b3 = ctx.external.uri) != null ? _b3 : ((id2) => id2); + if (externalId) { + return { ref: uriGenerator(externalId) }; + } + const id = (_d2 = (_c2 = entry[1].defId) != null ? _c2 : entry[1].schema.id) != null ? _d2 : `schema${ctx.counter++}`; + entry[1].defId = id; + return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` }; + } + if (entry[1] === root) { + return { ref: "#" }; + } + const uriPrefix = `#`; + const defUriPrefix = `${uriPrefix}/${defsSegment}/`; + const defId = (_e = entry[1].schema.id) != null ? _e : `__schema${ctx.counter++}`; + return { defId, ref: defUriPrefix + defId }; + }; + const extractToDef = (entry) => { + if (entry[1].schema.$ref) { + return; + } + const seen = entry[1]; + const { ref, defId } = makeURI(entry); + seen.def = { ...seen.schema }; + if (defId) + seen.defId = defId; + const schema2 = seen.schema; + for (const key in schema2) { + delete schema2[key]; + } + schema2.$ref = ref; + }; + if (ctx.cycles === "throw") { + for (const entry of ctx.seen.entries()) { + const seen = entry[1]; + if (seen.cycle) { + throw new Error(`Cycle detected: #/${(_b2 = seen.cycle) == null ? void 0 : _b2.join("/")}/ + +Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`); + } + } + } + for (const entry of ctx.seen.entries()) { + const seen = entry[1]; + if (schema === entry[0]) { + extractToDef(entry); + continue; + } + if (ctx.external) { + const ext = (_c = ctx.external.registry.get(entry[0])) == null ? void 0 : _c.id; + if (schema !== entry[0] && ext) { + extractToDef(entry); + continue; + } + } + const id = (_d = ctx.metadataRegistry.get(entry[0])) == null ? void 0 : _d.id; + if (id) { + extractToDef(entry); + continue; + } + if (seen.cycle) { + extractToDef(entry); + continue; + } + if (seen.count > 1) { + if (ctx.reused === "ref") { + extractToDef(entry); + continue; + } + } + } +} +function finalize(ctx, schema) { + var _a3, _b2, _c, _d, _e; + const root = ctx.seen.get(schema); + if (!root) + throw new Error("Unprocessed schema. This is a bug in Zod."); + const flattenRef = (zodSchema) => { + var _a4, _b3, _c2; + const seen = ctx.seen.get(zodSchema); + if (seen.ref === null) + return; + const schema2 = (_a4 = seen.def) != null ? _a4 : seen.schema; + const _cached = { ...schema2 }; + const ref = seen.ref; + seen.ref = null; + if (ref) { + flattenRef(ref); + const refSeen = ctx.seen.get(ref); + const refSchema = refSeen.schema; + if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) { + schema2.allOf = (_b3 = schema2.allOf) != null ? _b3 : []; + schema2.allOf.push(refSchema); + } else { + Object.assign(schema2, refSchema); + } + Object.assign(schema2, _cached); + const isParentRef = zodSchema._zod.parent === ref; + if (isParentRef) { + for (const key in schema2) { + if (key === "$ref" || key === "allOf") + continue; + if (!(key in _cached)) { + delete schema2[key]; + } + } + } + if (refSchema.$ref && refSeen.def) { + for (const key in schema2) { + if (key === "$ref" || key === "allOf") + continue; + if (key in refSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(refSeen.def[key])) { + delete schema2[key]; + } + } + } + } + const parent = zodSchema._zod.parent; + if (parent && parent !== ref) { + flattenRef(parent); + const parentSeen = ctx.seen.get(parent); + if (parentSeen == null ? void 0 : parentSeen.schema.$ref) { + schema2.$ref = parentSeen.schema.$ref; + if (parentSeen.def) { + for (const key in schema2) { + if (key === "$ref" || key === "allOf") + continue; + if (key in parentSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(parentSeen.def[key])) { + delete schema2[key]; + } + } + } + } + } + ctx.override({ + zodSchema, + jsonSchema: schema2, + path: (_c2 = seen.path) != null ? _c2 : [] + }); + }; + for (const entry of [...ctx.seen.entries()].reverse()) { + flattenRef(entry[0]); + } + const result = {}; + if (ctx.target === "draft-2020-12") { + result.$schema = "https://json-schema.org/draft/2020-12/schema"; + } else if (ctx.target === "draft-07") { + result.$schema = "http://json-schema.org/draft-07/schema#"; + } else if (ctx.target === "draft-04") { + result.$schema = "http://json-schema.org/draft-04/schema#"; + } else if (ctx.target === "openapi-3.0") { + } else { + } + if ((_a3 = ctx.external) == null ? void 0 : _a3.uri) { + const id = (_b2 = ctx.external.registry.get(schema)) == null ? void 0 : _b2.id; + if (!id) + throw new Error("Schema is missing an `id` property"); + result.$id = ctx.external.uri(id); + } + Object.assign(result, (_c = root.def) != null ? _c : root.schema); + const defs = (_e = (_d = ctx.external) == null ? void 0 : _d.defs) != null ? _e : {}; + for (const entry of ctx.seen.entries()) { + const seen = entry[1]; + if (seen.def && seen.defId) { + defs[seen.defId] = seen.def; + } + } + if (ctx.external) { + } else { + if (Object.keys(defs).length > 0) { + if (ctx.target === "draft-2020-12") { + result.$defs = defs; + } else { + result.definitions = defs; + } + } + } + try { + const finalized = JSON.parse(JSON.stringify(result)); + Object.defineProperty(finalized, "~standard", { + value: { + ...schema["~standard"], + jsonSchema: { + input: createStandardJSONSchemaMethod(schema, "input", ctx.processors), + output: createStandardJSONSchemaMethod(schema, "output", ctx.processors) + } + }, + enumerable: false, + writable: false + }); + return finalized; + } catch (_err) { + throw new Error("Error converting schema to JSON."); + } +} +function isTransforming(_schema, _ctx) { + const ctx = _ctx != null ? _ctx : { seen: /* @__PURE__ */ new Set() }; + if (ctx.seen.has(_schema)) + return false; + ctx.seen.add(_schema); + const def = _schema._zod.def; + if (def.type === "transform") + return true; + if (def.type === "array") + return isTransforming(def.element, ctx); + if (def.type === "set") + return isTransforming(def.valueType, ctx); + if (def.type === "lazy") + return isTransforming(def.getter(), ctx); + if (def.type === "promise" || def.type === "optional" || def.type === "nonoptional" || def.type === "nullable" || def.type === "readonly" || def.type === "default" || def.type === "prefault") { + return isTransforming(def.innerType, ctx); + } + if (def.type === "intersection") { + return isTransforming(def.left, ctx) || isTransforming(def.right, ctx); + } + if (def.type === "record" || def.type === "map") { + return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx); + } + if (def.type === "pipe") { + return isTransforming(def.in, ctx) || isTransforming(def.out, ctx); + } + if (def.type === "object") { + for (const key in def.shape) { + if (isTransforming(def.shape[key], ctx)) + return true; + } + return false; + } + if (def.type === "union") { + for (const option of def.options) { + if (isTransforming(option, ctx)) + return true; + } + return false; + } + if (def.type === "tuple") { + for (const item of def.items) { + if (isTransforming(item, ctx)) + return true; + } + if (def.rest && isTransforming(def.rest, ctx)) + return true; + return false; + } + return false; +} +var createToJSONSchemaMethod = (schema, processors = {}) => (params) => { + const ctx = initializeContext({ ...params, processors }); + process2(schema, ctx); + extractDefs(ctx, schema); + return finalize(ctx, schema); +}; +var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => { + const { libraryOptions, target } = params != null ? params : {}; + const ctx = initializeContext({ ...libraryOptions != null ? libraryOptions : {}, target, io, processors }); + process2(schema, ctx); + extractDefs(ctx, schema); + return finalize(ctx, schema); +}; + +// node_modules/zod/v4/core/json-schema-processors.js +var formatMap = { + guid: "uuid", + url: "uri", + datetime: "date-time", + json_string: "json-string", + regex: "" + // do not set +}; +var stringProcessor = (schema, ctx, _json, _params) => { + var _a3; + const json2 = _json; + json2.type = "string"; + const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag; + if (typeof minimum === "number") + json2.minLength = minimum; + if (typeof maximum === "number") + json2.maxLength = maximum; + if (format) { + json2.format = (_a3 = formatMap[format]) != null ? _a3 : format; + if (json2.format === "") + delete json2.format; + if (format === "time") { + delete json2.format; + } + } + if (contentEncoding) + json2.contentEncoding = contentEncoding; + if (patterns && patterns.size > 0) { + const regexes = [...patterns]; + if (regexes.length === 1) + json2.pattern = regexes[0].source; + else if (regexes.length > 1) { + json2.allOf = [ + ...regexes.map((regex) => ({ + ...ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0" ? { type: "string" } : {}, + pattern: regex.source + })) + ]; + } + } +}; +var numberProcessor = (schema, ctx, _json, _params) => { + const json2 = _json; + const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag; + if (typeof format === "string" && format.includes("int")) + json2.type = "integer"; + else + json2.type = "number"; + if (typeof exclusiveMinimum === "number") { + if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") { + json2.minimum = exclusiveMinimum; + json2.exclusiveMinimum = true; + } else { + json2.exclusiveMinimum = exclusiveMinimum; + } + } + if (typeof minimum === "number") { + json2.minimum = minimum; + if (typeof exclusiveMinimum === "number" && ctx.target !== "draft-04") { + if (exclusiveMinimum >= minimum) + delete json2.minimum; + else + delete json2.exclusiveMinimum; + } + } + if (typeof exclusiveMaximum === "number") { + if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") { + json2.maximum = exclusiveMaximum; + json2.exclusiveMaximum = true; + } else { + json2.exclusiveMaximum = exclusiveMaximum; + } + } + if (typeof maximum === "number") { + json2.maximum = maximum; + if (typeof exclusiveMaximum === "number" && ctx.target !== "draft-04") { + if (exclusiveMaximum <= maximum) + delete json2.maximum; + else + delete json2.exclusiveMaximum; + } + } + if (typeof multipleOf === "number") + json2.multipleOf = multipleOf; +}; +var booleanProcessor = (_schema, _ctx, json2, _params) => { + json2.type = "boolean"; +}; +var bigintProcessor = (_schema, ctx, _json, _params) => { + if (ctx.unrepresentable === "throw") { + throw new Error("BigInt cannot be represented in JSON Schema"); + } +}; +var symbolProcessor = (_schema, ctx, _json, _params) => { + if (ctx.unrepresentable === "throw") { + throw new Error("Symbols cannot be represented in JSON Schema"); + } +}; +var nullProcessor = (_schema, ctx, json2, _params) => { + if (ctx.target === "openapi-3.0") { + json2.type = "string"; + json2.nullable = true; + json2.enum = [null]; + } else { + json2.type = "null"; + } +}; +var undefinedProcessor = (_schema, ctx, _json, _params) => { + if (ctx.unrepresentable === "throw") { + throw new Error("Undefined cannot be represented in JSON Schema"); + } +}; +var voidProcessor = (_schema, ctx, _json, _params) => { + if (ctx.unrepresentable === "throw") { + throw new Error("Void cannot be represented in JSON Schema"); + } +}; +var neverProcessor = (_schema, _ctx, json2, _params) => { + json2.not = {}; +}; +var anyProcessor = (_schema, _ctx, _json, _params) => { +}; +var unknownProcessor = (_schema, _ctx, _json, _params) => { +}; +var dateProcessor = (_schema, ctx, _json, _params) => { + if (ctx.unrepresentable === "throw") { + throw new Error("Date cannot be represented in JSON Schema"); + } +}; +var enumProcessor = (schema, _ctx, json2, _params) => { + const def = schema._zod.def; + const values = getEnumValues(def.entries); + if (values.every((v2) => typeof v2 === "number")) + json2.type = "number"; + if (values.every((v2) => typeof v2 === "string")) + json2.type = "string"; + json2.enum = values; +}; +var literalProcessor = (schema, ctx, json2, _params) => { + const def = schema._zod.def; + const vals = []; + for (const val of def.values) { + if (val === void 0) { + if (ctx.unrepresentable === "throw") { + throw new Error("Literal `undefined` cannot be represented in JSON Schema"); + } else { + } + } else if (typeof val === "bigint") { + if (ctx.unrepresentable === "throw") { + throw new Error("BigInt literals cannot be represented in JSON Schema"); + } else { + vals.push(Number(val)); + } + } else { + vals.push(val); + } + } + if (vals.length === 0) { + } else if (vals.length === 1) { + const val = vals[0]; + json2.type = val === null ? "null" : typeof val; + if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") { + json2.enum = [val]; + } else { + json2.const = val; + } + } else { + if (vals.every((v2) => typeof v2 === "number")) + json2.type = "number"; + if (vals.every((v2) => typeof v2 === "string")) + json2.type = "string"; + if (vals.every((v2) => typeof v2 === "boolean")) + json2.type = "boolean"; + if (vals.every((v2) => v2 === null)) + json2.type = "null"; + json2.enum = vals; + } +}; +var nanProcessor = (_schema, ctx, _json, _params) => { + if (ctx.unrepresentable === "throw") { + throw new Error("NaN cannot be represented in JSON Schema"); + } +}; +var templateLiteralProcessor = (schema, _ctx, json2, _params) => { + const _json = json2; + const pattern = schema._zod.pattern; + if (!pattern) + throw new Error("Pattern not found in template literal"); + _json.type = "string"; + _json.pattern = pattern.source; +}; +var fileProcessor = (schema, _ctx, json2, _params) => { + const _json = json2; + const file2 = { + type: "string", + format: "binary", + contentEncoding: "binary" + }; + const { minimum, maximum, mime } = schema._zod.bag; + if (minimum !== void 0) + file2.minLength = minimum; + if (maximum !== void 0) + file2.maxLength = maximum; + if (mime) { + if (mime.length === 1) { + file2.contentMediaType = mime[0]; + Object.assign(_json, file2); + } else { + Object.assign(_json, file2); + _json.anyOf = mime.map((m3) => ({ contentMediaType: m3 })); + } + } else { + Object.assign(_json, file2); + } +}; +var successProcessor = (_schema, _ctx, json2, _params) => { + json2.type = "boolean"; +}; +var customProcessor = (_schema, ctx, _json, _params) => { + if (ctx.unrepresentable === "throw") { + throw new Error("Custom types cannot be represented in JSON Schema"); + } +}; +var functionProcessor = (_schema, ctx, _json, _params) => { + if (ctx.unrepresentable === "throw") { + throw new Error("Function types cannot be represented in JSON Schema"); + } +}; +var transformProcessor = (_schema, ctx, _json, _params) => { + if (ctx.unrepresentable === "throw") { + throw new Error("Transforms cannot be represented in JSON Schema"); + } +}; +var mapProcessor = (_schema, ctx, _json, _params) => { + if (ctx.unrepresentable === "throw") { + throw new Error("Map cannot be represented in JSON Schema"); + } +}; +var setProcessor = (_schema, ctx, _json, _params) => { + if (ctx.unrepresentable === "throw") { + throw new Error("Set cannot be represented in JSON Schema"); + } +}; +var arrayProcessor = (schema, ctx, _json, params) => { + const json2 = _json; + const def = schema._zod.def; + const { minimum, maximum } = schema._zod.bag; + if (typeof minimum === "number") + json2.minItems = minimum; + if (typeof maximum === "number") + json2.maxItems = maximum; + json2.type = "array"; + json2.items = process2(def.element, ctx, { ...params, path: [...params.path, "items"] }); +}; +var objectProcessor = (schema, ctx, _json, params) => { + var _a3; + const json2 = _json; + const def = schema._zod.def; + json2.type = "object"; + json2.properties = {}; + const shape = def.shape; + for (const key in shape) { + json2.properties[key] = process2(shape[key], ctx, { + ...params, + path: [...params.path, "properties", key] + }); + } + const allKeys = new Set(Object.keys(shape)); + const requiredKeys = new Set([...allKeys].filter((key) => { + const v2 = def.shape[key]._zod; + if (ctx.io === "input") { + return v2.optin === void 0; + } else { + return v2.optout === void 0; + } + })); + if (requiredKeys.size > 0) { + json2.required = Array.from(requiredKeys); + } + if (((_a3 = def.catchall) == null ? void 0 : _a3._zod.def.type) === "never") { + json2.additionalProperties = false; + } else if (!def.catchall) { + if (ctx.io === "output") + json2.additionalProperties = false; + } else if (def.catchall) { + json2.additionalProperties = process2(def.catchall, ctx, { + ...params, + path: [...params.path, "additionalProperties"] + }); + } +}; +var unionProcessor = (schema, ctx, json2, params) => { + const def = schema._zod.def; + const isExclusive = def.inclusive === false; + const options = def.options.map((x, i3) => process2(x, ctx, { + ...params, + path: [...params.path, isExclusive ? "oneOf" : "anyOf", i3] + })); + if (isExclusive) { + json2.oneOf = options; + } else { + json2.anyOf = options; + } +}; +var intersectionProcessor = (schema, ctx, json2, params) => { + const def = schema._zod.def; + const a3 = process2(def.left, ctx, { + ...params, + path: [...params.path, "allOf", 0] + }); + const b = process2(def.right, ctx, { + ...params, + path: [...params.path, "allOf", 1] + }); + const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1; + const allOf = [ + ...isSimpleIntersection(a3) ? a3.allOf : [a3], + ...isSimpleIntersection(b) ? b.allOf : [b] + ]; + json2.allOf = allOf; +}; +var tupleProcessor = (schema, ctx, _json, params) => { + const json2 = _json; + const def = schema._zod.def; + json2.type = "array"; + const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items"; + const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems"; + const prefixItems = def.items.map((x, i3) => process2(x, ctx, { + ...params, + path: [...params.path, prefixPath, i3] + })); + const rest = def.rest ? process2(def.rest, ctx, { + ...params, + path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []] + }) : null; + if (ctx.target === "draft-2020-12") { + json2.prefixItems = prefixItems; + if (rest) { + json2.items = rest; + } + } else if (ctx.target === "openapi-3.0") { + json2.items = { + anyOf: prefixItems + }; + if (rest) { + json2.items.anyOf.push(rest); + } + json2.minItems = prefixItems.length; + if (!rest) { + json2.maxItems = prefixItems.length; + } + } else { + json2.items = prefixItems; + if (rest) { + json2.additionalItems = rest; + } + } + const { minimum, maximum } = schema._zod.bag; + if (typeof minimum === "number") + json2.minItems = minimum; + if (typeof maximum === "number") + json2.maxItems = maximum; +}; +var recordProcessor = (schema, ctx, _json, params) => { + const json2 = _json; + const def = schema._zod.def; + json2.type = "object"; + const keyType = def.keyType; + const keyBag = keyType._zod.bag; + const patterns = keyBag == null ? void 0 : keyBag.patterns; + if (def.mode === "loose" && patterns && patterns.size > 0) { + const valueSchema = process2(def.valueType, ctx, { + ...params, + path: [...params.path, "patternProperties", "*"] + }); + json2.patternProperties = {}; + for (const pattern of patterns) { + json2.patternProperties[pattern.source] = valueSchema; + } + } else { + if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") { + json2.propertyNames = process2(def.keyType, ctx, { + ...params, + path: [...params.path, "propertyNames"] + }); + } + json2.additionalProperties = process2(def.valueType, ctx, { + ...params, + path: [...params.path, "additionalProperties"] + }); + } + const keyValues = keyType._zod.values; + if (keyValues) { + const validKeyValues = [...keyValues].filter((v2) => typeof v2 === "string" || typeof v2 === "number"); + if (validKeyValues.length > 0) { + json2.required = validKeyValues; + } + } +}; +var nullableProcessor = (schema, ctx, json2, params) => { + const def = schema._zod.def; + const inner = process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + if (ctx.target === "openapi-3.0") { + seen.ref = def.innerType; + json2.nullable = true; + } else { + json2.anyOf = [inner, { type: "null" }]; + } +}; +var nonoptionalProcessor = (schema, ctx, _json, params) => { + const def = schema._zod.def; + process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = def.innerType; +}; +var defaultProcessor = (schema, ctx, json2, params) => { + const def = schema._zod.def; + process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = def.innerType; + json2.default = JSON.parse(JSON.stringify(def.defaultValue)); +}; +var prefaultProcessor = (schema, ctx, json2, params) => { + const def = schema._zod.def; + process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = def.innerType; + if (ctx.io === "input") + json2._prefault = JSON.parse(JSON.stringify(def.defaultValue)); +}; +var catchProcessor = (schema, ctx, json2, params) => { + const def = schema._zod.def; + process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = def.innerType; + let catchValue; + try { + catchValue = def.catchValue(void 0); + } catch (e3) { + throw new Error("Dynamic catch values are not supported in JSON Schema"); + } + json2.default = catchValue; +}; +var pipeProcessor = (schema, ctx, _json, params) => { + const def = schema._zod.def; + const innerType = ctx.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out; + process2(innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = innerType; +}; +var readonlyProcessor = (schema, ctx, json2, params) => { + const def = schema._zod.def; + process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = def.innerType; + json2.readOnly = true; +}; +var promiseProcessor = (schema, ctx, _json, params) => { + const def = schema._zod.def; + process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = def.innerType; +}; +var optionalProcessor = (schema, ctx, _json, params) => { + const def = schema._zod.def; + process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = def.innerType; +}; +var lazyProcessor = (schema, ctx, _json, params) => { + const innerType = schema._zod.innerType; + process2(innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = innerType; +}; +var allProcessors = { + string: stringProcessor, + number: numberProcessor, + boolean: booleanProcessor, + bigint: bigintProcessor, + symbol: symbolProcessor, + null: nullProcessor, + undefined: undefinedProcessor, + void: voidProcessor, + never: neverProcessor, + any: anyProcessor, + unknown: unknownProcessor, + date: dateProcessor, + enum: enumProcessor, + literal: literalProcessor, + nan: nanProcessor, + template_literal: templateLiteralProcessor, + file: fileProcessor, + success: successProcessor, + custom: customProcessor, + function: functionProcessor, + transform: transformProcessor, + map: mapProcessor, + set: setProcessor, + array: arrayProcessor, + object: objectProcessor, + union: unionProcessor, + intersection: intersectionProcessor, + tuple: tupleProcessor, + record: recordProcessor, + nullable: nullableProcessor, + nonoptional: nonoptionalProcessor, + default: defaultProcessor, + prefault: prefaultProcessor, + catch: catchProcessor, + pipe: pipeProcessor, + readonly: readonlyProcessor, + promise: promiseProcessor, + optional: optionalProcessor, + lazy: lazyProcessor +}; +function toJSONSchema(input, params) { + if ("_idmap" in input) { + const registry2 = input; + const ctx2 = initializeContext({ ...params, processors: allProcessors }); + const defs = {}; + for (const entry of registry2._idmap.entries()) { + const [_3, schema] = entry; + process2(schema, ctx2); + } + const schemas = {}; + const external = { + registry: registry2, + uri: params == null ? void 0 : params.uri, + defs + }; + ctx2.external = external; + for (const entry of registry2._idmap.entries()) { + const [key, schema] = entry; + extractDefs(ctx2, schema); + schemas[key] = finalize(ctx2, schema); + } + if (Object.keys(defs).length > 0) { + const defsSegment = ctx2.target === "draft-2020-12" ? "$defs" : "definitions"; + schemas.__shared = { + [defsSegment]: defs + }; + } + return { schemas }; + } + const ctx = initializeContext({ ...params, processors: allProcessors }); + process2(input, ctx); + extractDefs(ctx, input); + return finalize(ctx, input); +} + +// node_modules/zod/v4/core/json-schema-generator.js +var JSONSchemaGenerator = class { + /** @deprecated Access via ctx instead */ + get metadataRegistry() { + return this.ctx.metadataRegistry; + } + /** @deprecated Access via ctx instead */ + get target() { + return this.ctx.target; + } + /** @deprecated Access via ctx instead */ + get unrepresentable() { + return this.ctx.unrepresentable; + } + /** @deprecated Access via ctx instead */ + get override() { + return this.ctx.override; + } + /** @deprecated Access via ctx instead */ + get io() { + return this.ctx.io; + } + /** @deprecated Access via ctx instead */ + get counter() { + return this.ctx.counter; + } + set counter(value) { + this.ctx.counter = value; + } + /** @deprecated Access via ctx instead */ + get seen() { + return this.ctx.seen; + } + constructor(params) { + var _a3; + let normalizedTarget = (_a3 = params == null ? void 0 : params.target) != null ? _a3 : "draft-2020-12"; + if (normalizedTarget === "draft-4") + normalizedTarget = "draft-04"; + if (normalizedTarget === "draft-7") + normalizedTarget = "draft-07"; + this.ctx = initializeContext({ + processors: allProcessors, + target: normalizedTarget, + ...(params == null ? void 0 : params.metadata) && { metadata: params.metadata }, + ...(params == null ? void 0 : params.unrepresentable) && { unrepresentable: params.unrepresentable }, + ...(params == null ? void 0 : params.override) && { override: params.override }, + ...(params == null ? void 0 : params.io) && { io: params.io } + }); + } + /** + * Process a schema to prepare it for JSON Schema generation. + * This must be called before emit(). + */ + process(schema, _params = { path: [], schemaPath: [] }) { + return process2(schema, this.ctx, _params); + } + /** + * Emit the final JSON Schema after processing. + * Must call process() first. + */ + emit(schema, _params) { + if (_params) { + if (_params.cycles) + this.ctx.cycles = _params.cycles; + if (_params.reused) + this.ctx.reused = _params.reused; + if (_params.external) + this.ctx.external = _params.external; + } + extractDefs(this.ctx, schema); + const result = finalize(this.ctx, schema); + const { "~standard": _3, ...plainResult } = result; + return plainResult; + } +}; + +// node_modules/zod/v4/core/json-schema.js +var json_schema_exports = {}; + +// node_modules/zod/v4/mini/schemas.js +var ZodMiniType = /* @__PURE__ */ $constructor("ZodMiniType", (inst, def) => { + if (!inst._zod) + throw new Error("Uninitialized schema in ZodMiniType."); + $ZodType.init(inst, def); + inst.def = def; + inst.type = def.type; + inst.parse = (data, params) => parse(inst, data, params, { callee: inst.parse }); + inst.safeParse = (data, params) => safeParse(inst, data, params); + inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync }); + inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params); + inst.check = (...checks) => { + var _a3; + return inst.clone({ + ...def, + checks: [ + ...(_a3 = def.checks) != null ? _a3 : [], + ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch) + ] + }, { parent: true }); + }; + inst.with = inst.check; + inst.clone = (_def, params) => clone(inst, _def, params); + inst.brand = () => inst; + inst.register = ((reg, meta3) => { + reg.add(inst, meta3); + return inst; + }); + inst.apply = (fn) => fn(inst); +}); +var ZodMiniString = /* @__PURE__ */ $constructor("ZodMiniString", (inst, def) => { + $ZodString.init(inst, def); + ZodMiniType.init(inst, def); +}); +var ZodMiniStringFormat = /* @__PURE__ */ $constructor("ZodMiniStringFormat", (inst, def) => { + $ZodStringFormat.init(inst, def); + ZodMiniString.init(inst, def); +}); +var ZodMiniNumber = /* @__PURE__ */ $constructor("ZodMiniNumber", (inst, def) => { + $ZodNumber.init(inst, def); + ZodMiniType.init(inst, def); +}); +var ZodMiniBoolean = /* @__PURE__ */ $constructor("ZodMiniBoolean", (inst, def) => { + $ZodBoolean.init(inst, def); + ZodMiniType.init(inst, def); +}); +var ZodMiniBigInt = /* @__PURE__ */ $constructor("ZodMiniBigInt", (inst, def) => { + $ZodBigInt.init(inst, def); + ZodMiniType.init(inst, def); +}); +var ZodMiniDate = /* @__PURE__ */ $constructor("ZodMiniDate", (inst, def) => { + $ZodDate.init(inst, def); + ZodMiniType.init(inst, def); +}); + +// node_modules/zod/v4/mini/iso.js +var iso_exports = {}; +__export(iso_exports, { + ZodMiniISODate: () => ZodMiniISODate, + ZodMiniISODateTime: () => ZodMiniISODateTime, + ZodMiniISODuration: () => ZodMiniISODuration, + ZodMiniISOTime: () => ZodMiniISOTime, + date: () => date2, + datetime: () => datetime2, + duration: () => duration2, + time: () => time2 +}); +var ZodMiniISODateTime = /* @__PURE__ */ $constructor("ZodMiniISODateTime", (inst, def) => { + $ZodISODateTime.init(inst, def); + ZodMiniStringFormat.init(inst, def); +}); +// @__NO_SIDE_EFFECTS__ +function datetime2(params) { + return _isoDateTime(ZodMiniISODateTime, params); +} +var ZodMiniISODate = /* @__PURE__ */ $constructor("ZodMiniISODate", (inst, def) => { + $ZodISODate.init(inst, def); + ZodMiniStringFormat.init(inst, def); +}); +// @__NO_SIDE_EFFECTS__ +function date2(params) { + return _isoDate(ZodMiniISODate, params); +} +var ZodMiniISOTime = /* @__PURE__ */ $constructor("ZodMiniISOTime", (inst, def) => { + $ZodISOTime.init(inst, def); + ZodMiniStringFormat.init(inst, def); +}); +// @__NO_SIDE_EFFECTS__ +function time2(params) { + return _isoTime(ZodMiniISOTime, params); +} +var ZodMiniISODuration = /* @__PURE__ */ $constructor("ZodMiniISODuration", (inst, def) => { + $ZodISODuration.init(inst, def); + ZodMiniStringFormat.init(inst, def); +}); +// @__NO_SIDE_EFFECTS__ +function duration2(params) { + return _isoDuration(ZodMiniISODuration, params); +} + +// node_modules/zod/v4/mini/coerce.js +var coerce_exports = {}; +__export(coerce_exports, { + bigint: () => bigint2, + boolean: () => boolean2, + date: () => date3, + number: () => number2, + string: () => string2 +}); +// @__NO_SIDE_EFFECTS__ +function string2(params) { + return _coercedString(ZodMiniString, params); +} +// @__NO_SIDE_EFFECTS__ +function number2(params) { + return _coercedNumber(ZodMiniNumber, params); +} +// @__NO_SIDE_EFFECTS__ +function boolean2(params) { + return _coercedBoolean(ZodMiniBoolean, params); +} +// @__NO_SIDE_EFFECTS__ +function bigint2(params) { + return _coercedBigint(ZodMiniBigInt, params); +} +// @__NO_SIDE_EFFECTS__ +function date3(params) { + return _coercedDate(ZodMiniDate, params); +} + +// node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js +function isZ4Schema(s3) { + const schema = s3; + return !!schema._zod; +} +function safeParse2(schema, data) { + if (isZ4Schema(schema)) { + const result2 = safeParse(schema, data); + return result2; + } + const v3Schema = schema; + const result = v3Schema.safeParse(data); + return result; +} +function getObjectShape(schema) { + var _a3, _b2; + if (!schema) + return void 0; + let rawShape; + if (isZ4Schema(schema)) { + const v4Schema = schema; + rawShape = (_b2 = (_a3 = v4Schema._zod) == null ? void 0 : _a3.def) == null ? void 0 : _b2.shape; + } else { + const v3Schema = schema; + rawShape = v3Schema.shape; + } + if (!rawShape) + return void 0; + if (typeof rawShape === "function") { + try { + return rawShape(); + } catch (e3) { + return void 0; + } + } + return rawShape; +} +function getLiteralValue(schema) { + var _a3; + if (isZ4Schema(schema)) { + const v4Schema = schema; + const def2 = (_a3 = v4Schema._zod) == null ? void 0 : _a3.def; + if (def2) { + if (def2.value !== void 0) + return def2.value; + if (Array.isArray(def2.values) && def2.values.length > 0) { + return def2.values[0]; + } + } + } + const v3Schema = schema; + const def = v3Schema._def; + if (def) { + if (def.value !== void 0) + return def.value; + if (Array.isArray(def.values) && def.values.length > 0) { + return def.values[0]; + } + } + const directValue = schema.value; + if (directValue !== void 0) + return directValue; + return void 0; +} + +// node_modules/zod/v4/classic/schemas.js +var schemas_exports3 = {}; +__export(schemas_exports3, { + ZodAny: () => ZodAny2, + ZodArray: () => ZodArray2, + ZodBase64: () => ZodBase64, + ZodBase64URL: () => ZodBase64URL, + ZodBigInt: () => ZodBigInt2, + ZodBigIntFormat: () => ZodBigIntFormat, + ZodBoolean: () => ZodBoolean2, + ZodCIDRv4: () => ZodCIDRv4, + ZodCIDRv6: () => ZodCIDRv6, + ZodCUID: () => ZodCUID, + ZodCUID2: () => ZodCUID2, + ZodCatch: () => ZodCatch2, + ZodCodec: () => ZodCodec, + ZodCustom: () => ZodCustom, + ZodCustomStringFormat: () => ZodCustomStringFormat, + ZodDate: () => ZodDate2, + ZodDefault: () => ZodDefault2, + ZodDiscriminatedUnion: () => ZodDiscriminatedUnion2, + ZodE164: () => ZodE164, + ZodEmail: () => ZodEmail, + ZodEmoji: () => ZodEmoji, + ZodEnum: () => ZodEnum2, + ZodExactOptional: () => ZodExactOptional, + ZodFile: () => ZodFile, + ZodFunction: () => ZodFunction2, + ZodGUID: () => ZodGUID, + ZodIPv4: () => ZodIPv4, + ZodIPv6: () => ZodIPv6, + ZodIntersection: () => ZodIntersection2, + ZodJWT: () => ZodJWT, + ZodKSUID: () => ZodKSUID, + ZodLazy: () => ZodLazy2, + ZodLiteral: () => ZodLiteral2, + ZodMAC: () => ZodMAC, + ZodMap: () => ZodMap2, + ZodNaN: () => ZodNaN2, + ZodNanoID: () => ZodNanoID, + ZodNever: () => ZodNever2, + ZodNonOptional: () => ZodNonOptional, + ZodNull: () => ZodNull2, + ZodNullable: () => ZodNullable2, + ZodNumber: () => ZodNumber2, + ZodNumberFormat: () => ZodNumberFormat, + ZodObject: () => ZodObject2, + ZodOptional: () => ZodOptional2, + ZodPipe: () => ZodPipe, + ZodPrefault: () => ZodPrefault, + ZodPromise: () => ZodPromise2, + ZodReadonly: () => ZodReadonly2, + ZodRecord: () => ZodRecord2, + ZodSet: () => ZodSet2, + ZodString: () => ZodString2, + ZodStringFormat: () => ZodStringFormat, + ZodSuccess: () => ZodSuccess, + ZodSymbol: () => ZodSymbol2, + ZodTemplateLiteral: () => ZodTemplateLiteral, + ZodTransform: () => ZodTransform, + ZodTuple: () => ZodTuple2, + ZodType: () => ZodType2, + ZodULID: () => ZodULID, + ZodURL: () => ZodURL, + ZodUUID: () => ZodUUID, + ZodUndefined: () => ZodUndefined2, + ZodUnion: () => ZodUnion2, + ZodUnknown: () => ZodUnknown2, + ZodVoid: () => ZodVoid2, + ZodXID: () => ZodXID, + ZodXor: () => ZodXor, + _ZodString: () => _ZodString, + _default: () => _default2, + _function: () => _function, + any: () => any, + array: () => array, + base64: () => base642, + base64url: () => base64url2, + bigint: () => bigint3, + boolean: () => boolean3, + catch: () => _catch2, + check: () => check, + cidrv4: () => cidrv42, + cidrv6: () => cidrv62, + codec: () => codec, + cuid: () => cuid3, + cuid2: () => cuid22, + custom: () => custom, + date: () => date5, + describe: () => describe2, + discriminatedUnion: () => discriminatedUnion, + e164: () => e1642, + email: () => email2, + emoji: () => emoji2, + enum: () => _enum2, + exactOptional: () => exactOptional, + file: () => file, + float32: () => float32, + float64: () => float64, + function: () => _function, + guid: () => guid2, + hash: () => hash, + hex: () => hex2, + hostname: () => hostname3, + httpUrl: () => httpUrl, + instanceof: () => _instanceof, + int: () => int, + int32: () => int32, + int64: () => int64, + intersection: () => intersection, + ipv4: () => ipv42, + ipv6: () => ipv62, + json: () => json, + jwt: () => jwt, + keyof: () => keyof, + ksuid: () => ksuid2, + lazy: () => lazy, + literal: () => literal, + looseObject: () => looseObject, + looseRecord: () => looseRecord, + mac: () => mac2, + map: () => map, + meta: () => meta2, + nan: () => nan, + nanoid: () => nanoid2, + nativeEnum: () => nativeEnum, + never: () => never, + nonoptional: () => nonoptional, + null: () => _null3, + nullable: () => nullable, + nullish: () => nullish2, + number: () => number3, + object: () => object2, + optional: () => optional, + partialRecord: () => partialRecord, + pipe: () => pipe, + prefault: () => prefault, + preprocess: () => preprocess, + promise: () => promise, + readonly: () => readonly, + record: () => record, + refine: () => refine, + set: () => set, + strictObject: () => strictObject, + string: () => string3, + stringFormat: () => stringFormat, + stringbool: () => stringbool, + success: () => success, + superRefine: () => superRefine, + symbol: () => symbol, + templateLiteral: () => templateLiteral, + transform: () => transform, + tuple: () => tuple, + uint32: () => uint32, + uint64: () => uint64, + ulid: () => ulid2, + undefined: () => _undefined3, + union: () => union, + unknown: () => unknown, + url: () => url, + uuid: () => uuid2, + uuidv4: () => uuidv4, + uuidv6: () => uuidv6, + uuidv7: () => uuidv7, + void: () => _void2, + xid: () => xid2, + xor: () => xor +}); + +// node_modules/zod/v4/classic/checks.js +var checks_exports2 = {}; +__export(checks_exports2, { + endsWith: () => _endsWith, + gt: () => _gt, + gte: () => _gte, + includes: () => _includes, + length: () => _length, + lowercase: () => _lowercase, + lt: () => _lt, + lte: () => _lte, + maxLength: () => _maxLength, + maxSize: () => _maxSize, + mime: () => _mime, + minLength: () => _minLength, + minSize: () => _minSize, + multipleOf: () => _multipleOf, + negative: () => _negative, + nonnegative: () => _nonnegative, + nonpositive: () => _nonpositive, + normalize: () => _normalize, + overwrite: () => _overwrite, + positive: () => _positive, + property: () => _property, + regex: () => _regex, + size: () => _size, + slugify: () => _slugify, + startsWith: () => _startsWith, + toLowerCase: () => _toLowerCase, + toUpperCase: () => _toUpperCase, + trim: () => _trim, + uppercase: () => _uppercase +}); + +// node_modules/zod/v4/classic/iso.js +var iso_exports2 = {}; +__export(iso_exports2, { + ZodISODate: () => ZodISODate, + ZodISODateTime: () => ZodISODateTime, + ZodISODuration: () => ZodISODuration, + ZodISOTime: () => ZodISOTime, + date: () => date4, + datetime: () => datetime3, + duration: () => duration3, + time: () => time3 +}); +var ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => { + $ZodISODateTime.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function datetime3(params) { + return _isoDateTime(ZodISODateTime, params); +} +var ZodISODate = /* @__PURE__ */ $constructor("ZodISODate", (inst, def) => { + $ZodISODate.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function date4(params) { + return _isoDate(ZodISODate, params); +} +var ZodISOTime = /* @__PURE__ */ $constructor("ZodISOTime", (inst, def) => { + $ZodISOTime.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function time3(params) { + return _isoTime(ZodISOTime, params); +} +var ZodISODuration = /* @__PURE__ */ $constructor("ZodISODuration", (inst, def) => { + $ZodISODuration.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function duration3(params) { + return _isoDuration(ZodISODuration, params); +} + +// node_modules/zod/v4/classic/errors.js +var initializer2 = (inst, issues) => { + $ZodError.init(inst, issues); + inst.name = "ZodError"; + Object.defineProperties(inst, { + format: { + value: (mapper) => formatError(inst, mapper) + // enumerable: false, + }, + flatten: { + value: (mapper) => flattenError(inst, mapper) + // enumerable: false, + }, + addIssue: { + value: (issue2) => { + inst.issues.push(issue2); + inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2); + } + // enumerable: false, + }, + addIssues: { + value: (issues2) => { + inst.issues.push(...issues2); + inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2); + } + // enumerable: false, + }, + isEmpty: { + get() { + return inst.issues.length === 0; + } + // enumerable: false, + } + }); +}; +var ZodError2 = $constructor("ZodError", initializer2); +var ZodRealError = $constructor("ZodError", initializer2, { + Parent: Error +}); + +// node_modules/zod/v4/classic/parse.js +var parse2 = /* @__PURE__ */ _parse(ZodRealError); +var parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError); +var safeParse3 = /* @__PURE__ */ _safeParse(ZodRealError); +var safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError); +var encode2 = /* @__PURE__ */ _encode(ZodRealError); +var decode2 = /* @__PURE__ */ _decode(ZodRealError); +var encodeAsync2 = /* @__PURE__ */ _encodeAsync(ZodRealError); +var decodeAsync2 = /* @__PURE__ */ _decodeAsync(ZodRealError); +var safeEncode2 = /* @__PURE__ */ _safeEncode(ZodRealError); +var safeDecode2 = /* @__PURE__ */ _safeDecode(ZodRealError); +var safeEncodeAsync2 = /* @__PURE__ */ _safeEncodeAsync(ZodRealError); +var safeDecodeAsync2 = /* @__PURE__ */ _safeDecodeAsync(ZodRealError); + +// node_modules/zod/v4/classic/schemas.js +var ZodType2 = /* @__PURE__ */ $constructor("ZodType", (inst, def) => { + $ZodType.init(inst, def); + Object.assign(inst["~standard"], { + jsonSchema: { + input: createStandardJSONSchemaMethod(inst, "input"), + output: createStandardJSONSchemaMethod(inst, "output") + } + }); + inst.toJSONSchema = createToJSONSchemaMethod(inst, {}); + inst.def = def; + inst.type = def.type; + Object.defineProperty(inst, "_def", { value: def }); + inst.check = (...checks) => { + var _a3; + return inst.clone(util_exports.mergeDefs(def, { + checks: [ + ...(_a3 = def.checks) != null ? _a3 : [], + ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch) + ] + }), { + parent: true + }); + }; + inst.with = inst.check; + inst.clone = (def2, params) => clone(inst, def2, params); + inst.brand = () => inst; + inst.register = ((reg, meta3) => { + reg.add(inst, meta3); + return inst; + }); + inst.parse = (data, params) => parse2(inst, data, params, { callee: inst.parse }); + inst.safeParse = (data, params) => safeParse3(inst, data, params); + inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync }); + inst.safeParseAsync = async (data, params) => safeParseAsync2(inst, data, params); + inst.spa = inst.safeParseAsync; + inst.encode = (data, params) => encode2(inst, data, params); + inst.decode = (data, params) => decode2(inst, data, params); + inst.encodeAsync = async (data, params) => encodeAsync2(inst, data, params); + inst.decodeAsync = async (data, params) => decodeAsync2(inst, data, params); + inst.safeEncode = (data, params) => safeEncode2(inst, data, params); + inst.safeDecode = (data, params) => safeDecode2(inst, data, params); + inst.safeEncodeAsync = async (data, params) => safeEncodeAsync2(inst, data, params); + inst.safeDecodeAsync = async (data, params) => safeDecodeAsync2(inst, data, params); + inst.refine = (check2, params) => inst.check(refine(check2, params)); + inst.superRefine = (refinement) => inst.check(superRefine(refinement)); + inst.overwrite = (fn) => inst.check(_overwrite(fn)); + inst.optional = () => optional(inst); + inst.exactOptional = () => exactOptional(inst); + inst.nullable = () => nullable(inst); + inst.nullish = () => optional(nullable(inst)); + inst.nonoptional = (params) => nonoptional(inst, params); + inst.array = () => array(inst); + inst.or = (arg) => union([inst, arg]); + inst.and = (arg) => intersection(inst, arg); + inst.transform = (tx) => pipe(inst, transform(tx)); + inst.default = (def2) => _default2(inst, def2); + inst.prefault = (def2) => prefault(inst, def2); + inst.catch = (params) => _catch2(inst, params); + inst.pipe = (target) => pipe(inst, target); + inst.readonly = () => readonly(inst); + inst.describe = (description) => { + const cl = inst.clone(); + globalRegistry.add(cl, { description }); + return cl; + }; + Object.defineProperty(inst, "description", { + get() { + var _a3; + return (_a3 = globalRegistry.get(inst)) == null ? void 0 : _a3.description; + }, + configurable: true + }); + inst.meta = (...args) => { + if (args.length === 0) { + return globalRegistry.get(inst); + } + const cl = inst.clone(); + globalRegistry.add(cl, args[0]); + return cl; + }; + inst.isOptional = () => inst.safeParse(void 0).success; + inst.isNullable = () => inst.safeParse(null).success; + inst.apply = (fn) => fn(inst); + return inst; +}); +var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => { + var _a3, _b2, _c; + $ZodString.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => stringProcessor(inst, ctx, json2, params); + const bag = inst._zod.bag; + inst.format = (_a3 = bag.format) != null ? _a3 : null; + inst.minLength = (_b2 = bag.minimum) != null ? _b2 : null; + inst.maxLength = (_c = bag.maximum) != null ? _c : null; + inst.regex = (...args) => inst.check(_regex(...args)); + inst.includes = (...args) => inst.check(_includes(...args)); + inst.startsWith = (...args) => inst.check(_startsWith(...args)); + inst.endsWith = (...args) => inst.check(_endsWith(...args)); + inst.min = (...args) => inst.check(_minLength(...args)); + inst.max = (...args) => inst.check(_maxLength(...args)); + inst.length = (...args) => inst.check(_length(...args)); + inst.nonempty = (...args) => inst.check(_minLength(1, ...args)); + inst.lowercase = (params) => inst.check(_lowercase(params)); + inst.uppercase = (params) => inst.check(_uppercase(params)); + inst.trim = () => inst.check(_trim()); + inst.normalize = (...args) => inst.check(_normalize(...args)); + inst.toLowerCase = () => inst.check(_toLowerCase()); + inst.toUpperCase = () => inst.check(_toUpperCase()); + inst.slugify = () => inst.check(_slugify()); +}); +var ZodString2 = /* @__PURE__ */ $constructor("ZodString", (inst, def) => { + $ZodString.init(inst, def); + _ZodString.init(inst, def); + inst.email = (params) => inst.check(_email(ZodEmail, params)); + inst.url = (params) => inst.check(_url(ZodURL, params)); + inst.jwt = (params) => inst.check(_jwt(ZodJWT, params)); + inst.emoji = (params) => inst.check(_emoji2(ZodEmoji, params)); + inst.guid = (params) => inst.check(_guid(ZodGUID, params)); + inst.uuid = (params) => inst.check(_uuid(ZodUUID, params)); + inst.uuidv4 = (params) => inst.check(_uuidv4(ZodUUID, params)); + inst.uuidv6 = (params) => inst.check(_uuidv6(ZodUUID, params)); + inst.uuidv7 = (params) => inst.check(_uuidv7(ZodUUID, params)); + inst.nanoid = (params) => inst.check(_nanoid(ZodNanoID, params)); + inst.guid = (params) => inst.check(_guid(ZodGUID, params)); + inst.cuid = (params) => inst.check(_cuid(ZodCUID, params)); + inst.cuid2 = (params) => inst.check(_cuid2(ZodCUID2, params)); + inst.ulid = (params) => inst.check(_ulid(ZodULID, params)); + inst.base64 = (params) => inst.check(_base64(ZodBase64, params)); + inst.base64url = (params) => inst.check(_base64url(ZodBase64URL, params)); + inst.xid = (params) => inst.check(_xid(ZodXID, params)); + inst.ksuid = (params) => inst.check(_ksuid(ZodKSUID, params)); + inst.ipv4 = (params) => inst.check(_ipv4(ZodIPv4, params)); + inst.ipv6 = (params) => inst.check(_ipv6(ZodIPv6, params)); + inst.cidrv4 = (params) => inst.check(_cidrv4(ZodCIDRv4, params)); + inst.cidrv6 = (params) => inst.check(_cidrv6(ZodCIDRv6, params)); + inst.e164 = (params) => inst.check(_e164(ZodE164, params)); + inst.datetime = (params) => inst.check(datetime3(params)); + inst.date = (params) => inst.check(date4(params)); + inst.time = (params) => inst.check(time3(params)); + inst.duration = (params) => inst.check(duration3(params)); +}); +function string3(params) { + return _string(ZodString2, params); +} +var ZodStringFormat = /* @__PURE__ */ $constructor("ZodStringFormat", (inst, def) => { + $ZodStringFormat.init(inst, def); + _ZodString.init(inst, def); +}); +var ZodEmail = /* @__PURE__ */ $constructor("ZodEmail", (inst, def) => { + $ZodEmail.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function email2(params) { + return _email(ZodEmail, params); +} +var ZodGUID = /* @__PURE__ */ $constructor("ZodGUID", (inst, def) => { + $ZodGUID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function guid2(params) { + return _guid(ZodGUID, params); +} +var ZodUUID = /* @__PURE__ */ $constructor("ZodUUID", (inst, def) => { + $ZodUUID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function uuid2(params) { + return _uuid(ZodUUID, params); +} +function uuidv4(params) { + return _uuidv4(ZodUUID, params); +} +function uuidv6(params) { + return _uuidv6(ZodUUID, params); +} +function uuidv7(params) { + return _uuidv7(ZodUUID, params); +} +var ZodURL = /* @__PURE__ */ $constructor("ZodURL", (inst, def) => { + $ZodURL.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function url(params) { + return _url(ZodURL, params); +} +function httpUrl(params) { + return _url(ZodURL, { + protocol: /^https?$/, + hostname: regexes_exports.domain, + ...util_exports.normalizeParams(params) + }); +} +var ZodEmoji = /* @__PURE__ */ $constructor("ZodEmoji", (inst, def) => { + $ZodEmoji.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function emoji2(params) { + return _emoji2(ZodEmoji, params); +} +var ZodNanoID = /* @__PURE__ */ $constructor("ZodNanoID", (inst, def) => { + $ZodNanoID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function nanoid2(params) { + return _nanoid(ZodNanoID, params); +} +var ZodCUID = /* @__PURE__ */ $constructor("ZodCUID", (inst, def) => { + $ZodCUID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function cuid3(params) { + return _cuid(ZodCUID, params); +} +var ZodCUID2 = /* @__PURE__ */ $constructor("ZodCUID2", (inst, def) => { + $ZodCUID2.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function cuid22(params) { + return _cuid2(ZodCUID2, params); +} +var ZodULID = /* @__PURE__ */ $constructor("ZodULID", (inst, def) => { + $ZodULID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function ulid2(params) { + return _ulid(ZodULID, params); +} +var ZodXID = /* @__PURE__ */ $constructor("ZodXID", (inst, def) => { + $ZodXID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function xid2(params) { + return _xid(ZodXID, params); +} +var ZodKSUID = /* @__PURE__ */ $constructor("ZodKSUID", (inst, def) => { + $ZodKSUID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function ksuid2(params) { + return _ksuid(ZodKSUID, params); +} +var ZodIPv4 = /* @__PURE__ */ $constructor("ZodIPv4", (inst, def) => { + $ZodIPv4.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function ipv42(params) { + return _ipv4(ZodIPv4, params); +} +var ZodMAC = /* @__PURE__ */ $constructor("ZodMAC", (inst, def) => { + $ZodMAC.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function mac2(params) { + return _mac(ZodMAC, params); +} +var ZodIPv6 = /* @__PURE__ */ $constructor("ZodIPv6", (inst, def) => { + $ZodIPv6.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function ipv62(params) { + return _ipv6(ZodIPv6, params); +} +var ZodCIDRv4 = /* @__PURE__ */ $constructor("ZodCIDRv4", (inst, def) => { + $ZodCIDRv4.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function cidrv42(params) { + return _cidrv4(ZodCIDRv4, params); +} +var ZodCIDRv6 = /* @__PURE__ */ $constructor("ZodCIDRv6", (inst, def) => { + $ZodCIDRv6.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function cidrv62(params) { + return _cidrv6(ZodCIDRv6, params); +} +var ZodBase64 = /* @__PURE__ */ $constructor("ZodBase64", (inst, def) => { + $ZodBase64.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function base642(params) { + return _base64(ZodBase64, params); +} +var ZodBase64URL = /* @__PURE__ */ $constructor("ZodBase64URL", (inst, def) => { + $ZodBase64URL.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function base64url2(params) { + return _base64url(ZodBase64URL, params); +} +var ZodE164 = /* @__PURE__ */ $constructor("ZodE164", (inst, def) => { + $ZodE164.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function e1642(params) { + return _e164(ZodE164, params); +} +var ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (inst, def) => { + $ZodJWT.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function jwt(params) { + return _jwt(ZodJWT, params); +} +var ZodCustomStringFormat = /* @__PURE__ */ $constructor("ZodCustomStringFormat", (inst, def) => { + $ZodCustomStringFormat.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function stringFormat(format, fnOrRegex, _params = {}) { + return _stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params); +} +function hostname3(_params) { + return _stringFormat(ZodCustomStringFormat, "hostname", regexes_exports.hostname, _params); +} +function hex2(_params) { + return _stringFormat(ZodCustomStringFormat, "hex", regexes_exports.hex, _params); +} +function hash(alg, params) { + var _a3; + const enc = (_a3 = params == null ? void 0 : params.enc) != null ? _a3 : "hex"; + const format = `${alg}_${enc}`; + const regex = regexes_exports[format]; + if (!regex) + throw new Error(`Unrecognized hash format: ${format}`); + return _stringFormat(ZodCustomStringFormat, format, regex, params); +} +var ZodNumber2 = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => { + var _a3, _b2, _c, _d, _e, _f, _g, _h, _i; + $ZodNumber.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => numberProcessor(inst, ctx, json2, params); + inst.gt = (value, params) => inst.check(_gt(value, params)); + inst.gte = (value, params) => inst.check(_gte(value, params)); + inst.min = (value, params) => inst.check(_gte(value, params)); + inst.lt = (value, params) => inst.check(_lt(value, params)); + inst.lte = (value, params) => inst.check(_lte(value, params)); + inst.max = (value, params) => inst.check(_lte(value, params)); + inst.int = (params) => inst.check(int(params)); + inst.safe = (params) => inst.check(int(params)); + inst.positive = (params) => inst.check(_gt(0, params)); + inst.nonnegative = (params) => inst.check(_gte(0, params)); + inst.negative = (params) => inst.check(_lt(0, params)); + inst.nonpositive = (params) => inst.check(_lte(0, params)); + inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params)); + inst.step = (value, params) => inst.check(_multipleOf(value, params)); + inst.finite = () => inst; + const bag = inst._zod.bag; + inst.minValue = (_c = Math.max((_a3 = bag.minimum) != null ? _a3 : Number.NEGATIVE_INFINITY, (_b2 = bag.exclusiveMinimum) != null ? _b2 : Number.NEGATIVE_INFINITY)) != null ? _c : null; + inst.maxValue = (_f = Math.min((_d = bag.maximum) != null ? _d : Number.POSITIVE_INFINITY, (_e = bag.exclusiveMaximum) != null ? _e : Number.POSITIVE_INFINITY)) != null ? _f : null; + inst.isInt = ((_g = bag.format) != null ? _g : "").includes("int") || Number.isSafeInteger((_h = bag.multipleOf) != null ? _h : 0.5); + inst.isFinite = true; + inst.format = (_i = bag.format) != null ? _i : null; +}); +function number3(params) { + return _number(ZodNumber2, params); +} +var ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, def) => { + $ZodNumberFormat.init(inst, def); + ZodNumber2.init(inst, def); +}); +function int(params) { + return _int(ZodNumberFormat, params); +} +function float32(params) { + return _float32(ZodNumberFormat, params); +} +function float64(params) { + return _float64(ZodNumberFormat, params); +} +function int32(params) { + return _int32(ZodNumberFormat, params); +} +function uint32(params) { + return _uint32(ZodNumberFormat, params); +} +var ZodBoolean2 = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => { + $ZodBoolean.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => booleanProcessor(inst, ctx, json2, params); +}); +function boolean3(params) { + return _boolean(ZodBoolean2, params); +} +var ZodBigInt2 = /* @__PURE__ */ $constructor("ZodBigInt", (inst, def) => { + var _a3, _b2, _c; + $ZodBigInt.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => bigintProcessor(inst, ctx, json2, params); + inst.gte = (value, params) => inst.check(_gte(value, params)); + inst.min = (value, params) => inst.check(_gte(value, params)); + inst.gt = (value, params) => inst.check(_gt(value, params)); + inst.gte = (value, params) => inst.check(_gte(value, params)); + inst.min = (value, params) => inst.check(_gte(value, params)); + inst.lt = (value, params) => inst.check(_lt(value, params)); + inst.lte = (value, params) => inst.check(_lte(value, params)); + inst.max = (value, params) => inst.check(_lte(value, params)); + inst.positive = (params) => inst.check(_gt(BigInt(0), params)); + inst.negative = (params) => inst.check(_lt(BigInt(0), params)); + inst.nonpositive = (params) => inst.check(_lte(BigInt(0), params)); + inst.nonnegative = (params) => inst.check(_gte(BigInt(0), params)); + inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params)); + const bag = inst._zod.bag; + inst.minValue = (_a3 = bag.minimum) != null ? _a3 : null; + inst.maxValue = (_b2 = bag.maximum) != null ? _b2 : null; + inst.format = (_c = bag.format) != null ? _c : null; +}); +function bigint3(params) { + return _bigint(ZodBigInt2, params); +} +var ZodBigIntFormat = /* @__PURE__ */ $constructor("ZodBigIntFormat", (inst, def) => { + $ZodBigIntFormat.init(inst, def); + ZodBigInt2.init(inst, def); +}); +function int64(params) { + return _int64(ZodBigIntFormat, params); +} +function uint64(params) { + return _uint64(ZodBigIntFormat, params); +} +var ZodSymbol2 = /* @__PURE__ */ $constructor("ZodSymbol", (inst, def) => { + $ZodSymbol.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => symbolProcessor(inst, ctx, json2, params); +}); +function symbol(params) { + return _symbol(ZodSymbol2, params); +} +var ZodUndefined2 = /* @__PURE__ */ $constructor("ZodUndefined", (inst, def) => { + $ZodUndefined.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => undefinedProcessor(inst, ctx, json2, params); +}); +function _undefined3(params) { + return _undefined2(ZodUndefined2, params); +} +var ZodNull2 = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => { + $ZodNull.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => nullProcessor(inst, ctx, json2, params); +}); +function _null3(params) { + return _null2(ZodNull2, params); +} +var ZodAny2 = /* @__PURE__ */ $constructor("ZodAny", (inst, def) => { + $ZodAny.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => anyProcessor(inst, ctx, json2, params); +}); +function any() { + return _any(ZodAny2); +} +var ZodUnknown2 = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => { + $ZodUnknown.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => unknownProcessor(inst, ctx, json2, params); +}); +function unknown() { + return _unknown(ZodUnknown2); +} +var ZodNever2 = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => { + $ZodNever.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => neverProcessor(inst, ctx, json2, params); +}); +function never(params) { + return _never(ZodNever2, params); +} +var ZodVoid2 = /* @__PURE__ */ $constructor("ZodVoid", (inst, def) => { + $ZodVoid.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => voidProcessor(inst, ctx, json2, params); +}); +function _void2(params) { + return _void(ZodVoid2, params); +} +var ZodDate2 = /* @__PURE__ */ $constructor("ZodDate", (inst, def) => { + $ZodDate.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => dateProcessor(inst, ctx, json2, params); + inst.min = (value, params) => inst.check(_gte(value, params)); + inst.max = (value, params) => inst.check(_lte(value, params)); + const c = inst._zod.bag; + inst.minDate = c.minimum ? new Date(c.minimum) : null; + inst.maxDate = c.maximum ? new Date(c.maximum) : null; +}); +function date5(params) { + return _date(ZodDate2, params); +} +var ZodArray2 = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => { + $ZodArray.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => arrayProcessor(inst, ctx, json2, params); + inst.element = def.element; + inst.min = (minLength, params) => inst.check(_minLength(minLength, params)); + inst.nonempty = (params) => inst.check(_minLength(1, params)); + inst.max = (maxLength, params) => inst.check(_maxLength(maxLength, params)); + inst.length = (len, params) => inst.check(_length(len, params)); + inst.unwrap = () => inst.element; +}); +function array(element, params) { + return _array(ZodArray2, element, params); +} +function keyof(schema) { + const shape = schema._zod.def.shape; + return _enum2(Object.keys(shape)); +} +var ZodObject2 = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => { + $ZodObjectJIT.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => objectProcessor(inst, ctx, json2, params); + util_exports.defineLazy(inst, "shape", () => { + return def.shape; + }); + inst.keyof = () => _enum2(Object.keys(inst._zod.def.shape)); + inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall }); + inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() }); + inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() }); + inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() }); + inst.strip = () => inst.clone({ ...inst._zod.def, catchall: void 0 }); + inst.extend = (incoming) => { + return util_exports.extend(inst, incoming); + }; + inst.safeExtend = (incoming) => { + return util_exports.safeExtend(inst, incoming); + }; + inst.merge = (other) => util_exports.merge(inst, other); + inst.pick = (mask) => util_exports.pick(inst, mask); + inst.omit = (mask) => util_exports.omit(inst, mask); + inst.partial = (...args) => util_exports.partial(ZodOptional2, inst, args[0]); + inst.required = (...args) => util_exports.required(ZodNonOptional, inst, args[0]); +}); +function object2(shape, params) { + const def = { + type: "object", + shape: shape != null ? shape : {}, + ...util_exports.normalizeParams(params) + }; + return new ZodObject2(def); +} +function strictObject(shape, params) { + return new ZodObject2({ + type: "object", + shape, + catchall: never(), + ...util_exports.normalizeParams(params) + }); +} +function looseObject(shape, params) { + return new ZodObject2({ + type: "object", + shape, + catchall: unknown(), + ...util_exports.normalizeParams(params) + }); +} +var ZodUnion2 = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => { + $ZodUnion.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params); + inst.options = def.options; +}); +function union(options, params) { + return new ZodUnion2({ + type: "union", + options, + ...util_exports.normalizeParams(params) + }); +} +var ZodXor = /* @__PURE__ */ $constructor("ZodXor", (inst, def) => { + ZodUnion2.init(inst, def); + $ZodXor.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params); + inst.options = def.options; +}); +function xor(options, params) { + return new ZodXor({ + type: "union", + options, + inclusive: false, + ...util_exports.normalizeParams(params) + }); +} +var ZodDiscriminatedUnion2 = /* @__PURE__ */ $constructor("ZodDiscriminatedUnion", (inst, def) => { + ZodUnion2.init(inst, def); + $ZodDiscriminatedUnion.init(inst, def); +}); +function discriminatedUnion(discriminator, options, params) { + return new ZodDiscriminatedUnion2({ + type: "union", + options, + discriminator, + ...util_exports.normalizeParams(params) + }); +} +var ZodIntersection2 = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => { + $ZodIntersection.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => intersectionProcessor(inst, ctx, json2, params); +}); +function intersection(left, right) { + return new ZodIntersection2({ + type: "intersection", + left, + right + }); +} +var ZodTuple2 = /* @__PURE__ */ $constructor("ZodTuple", (inst, def) => { + $ZodTuple.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => tupleProcessor(inst, ctx, json2, params); + inst.rest = (rest) => inst.clone({ + ...inst._zod.def, + rest + }); +}); +function tuple(items, _paramsOrRest, _params) { + const hasRest = _paramsOrRest instanceof $ZodType; + const params = hasRest ? _params : _paramsOrRest; + const rest = hasRest ? _paramsOrRest : null; + return new ZodTuple2({ + type: "tuple", + items, + rest, + ...util_exports.normalizeParams(params) + }); +} +var ZodRecord2 = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => { + $ZodRecord.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => recordProcessor(inst, ctx, json2, params); + inst.keyType = def.keyType; + inst.valueType = def.valueType; +}); +function record(keyType, valueType, params) { + return new ZodRecord2({ + type: "record", + keyType, + valueType, + ...util_exports.normalizeParams(params) + }); +} +function partialRecord(keyType, valueType, params) { + const k3 = clone(keyType); + k3._zod.values = void 0; + return new ZodRecord2({ + type: "record", + keyType: k3, + valueType, + ...util_exports.normalizeParams(params) + }); +} +function looseRecord(keyType, valueType, params) { + return new ZodRecord2({ + type: "record", + keyType, + valueType, + mode: "loose", + ...util_exports.normalizeParams(params) + }); +} +var ZodMap2 = /* @__PURE__ */ $constructor("ZodMap", (inst, def) => { + $ZodMap.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => mapProcessor(inst, ctx, json2, params); + inst.keyType = def.keyType; + inst.valueType = def.valueType; + inst.min = (...args) => inst.check(_minSize(...args)); + inst.nonempty = (params) => inst.check(_minSize(1, params)); + inst.max = (...args) => inst.check(_maxSize(...args)); + inst.size = (...args) => inst.check(_size(...args)); +}); +function map(keyType, valueType, params) { + return new ZodMap2({ + type: "map", + keyType, + valueType, + ...util_exports.normalizeParams(params) + }); +} +var ZodSet2 = /* @__PURE__ */ $constructor("ZodSet", (inst, def) => { + $ZodSet.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => setProcessor(inst, ctx, json2, params); + inst.min = (...args) => inst.check(_minSize(...args)); + inst.nonempty = (params) => inst.check(_minSize(1, params)); + inst.max = (...args) => inst.check(_maxSize(...args)); + inst.size = (...args) => inst.check(_size(...args)); +}); +function set(valueType, params) { + return new ZodSet2({ + type: "set", + valueType, + ...util_exports.normalizeParams(params) + }); +} +var ZodEnum2 = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => { + $ZodEnum.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => enumProcessor(inst, ctx, json2, params); + inst.enum = def.entries; + inst.options = Object.values(def.entries); + const keys = new Set(Object.keys(def.entries)); + inst.extract = (values, params) => { + const newEntries = {}; + for (const value of values) { + if (keys.has(value)) { + newEntries[value] = def.entries[value]; + } else + throw new Error(`Key ${value} not found in enum`); + } + return new ZodEnum2({ + ...def, + checks: [], + ...util_exports.normalizeParams(params), + entries: newEntries + }); + }; + inst.exclude = (values, params) => { + const newEntries = { ...def.entries }; + for (const value of values) { + if (keys.has(value)) { + delete newEntries[value]; + } else + throw new Error(`Key ${value} not found in enum`); + } + return new ZodEnum2({ + ...def, + checks: [], + ...util_exports.normalizeParams(params), + entries: newEntries + }); + }; +}); +function _enum2(values, params) { + const entries = Array.isArray(values) ? Object.fromEntries(values.map((v2) => [v2, v2])) : values; + return new ZodEnum2({ + type: "enum", + entries, + ...util_exports.normalizeParams(params) + }); +} +function nativeEnum(entries, params) { + return new ZodEnum2({ + type: "enum", + entries, + ...util_exports.normalizeParams(params) + }); +} +var ZodLiteral2 = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => { + $ZodLiteral.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => literalProcessor(inst, ctx, json2, params); + inst.values = new Set(def.values); + Object.defineProperty(inst, "value", { + get() { + if (def.values.length > 1) { + throw new Error("This schema contains multiple valid literal values. Use `.values` instead."); + } + return def.values[0]; + } + }); +}); +function literal(value, params) { + return new ZodLiteral2({ + type: "literal", + values: Array.isArray(value) ? value : [value], + ...util_exports.normalizeParams(params) + }); +} +var ZodFile = /* @__PURE__ */ $constructor("ZodFile", (inst, def) => { + $ZodFile.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => fileProcessor(inst, ctx, json2, params); + inst.min = (size, params) => inst.check(_minSize(size, params)); + inst.max = (size, params) => inst.check(_maxSize(size, params)); + inst.mime = (types, params) => inst.check(_mime(Array.isArray(types) ? types : [types], params)); +}); +function file(params) { + return _file(ZodFile, params); +} +var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => { + $ZodTransform.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => transformProcessor(inst, ctx, json2, params); + inst._zod.parse = (payload, _ctx) => { + if (_ctx.direction === "backward") { + throw new $ZodEncodeError(inst.constructor.name); + } + payload.addIssue = (issue2) => { + var _a3, _b2, _c; + if (typeof issue2 === "string") { + payload.issues.push(util_exports.issue(issue2, payload.value, def)); + } else { + const _issue = issue2; + if (_issue.fatal) + _issue.continue = false; + (_a3 = _issue.code) != null ? _a3 : _issue.code = "custom"; + (_b2 = _issue.input) != null ? _b2 : _issue.input = payload.value; + (_c = _issue.inst) != null ? _c : _issue.inst = inst; + payload.issues.push(util_exports.issue(_issue)); + } + }; + const output = def.transform(payload.value, payload); + if (output instanceof Promise) { + return output.then((output2) => { + payload.value = output2; + return payload; + }); + } + payload.value = output; + return payload; + }; +}); +function transform(fn) { + return new ZodTransform({ + type: "transform", + transform: fn + }); +} +var ZodOptional2 = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => { + $ZodOptional.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function optional(innerType) { + return new ZodOptional2({ + type: "optional", + innerType + }); +} +var ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (inst, def) => { + $ZodExactOptional.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function exactOptional(innerType) { + return new ZodExactOptional({ + type: "optional", + innerType + }); +} +var ZodNullable2 = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => { + $ZodNullable.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => nullableProcessor(inst, ctx, json2, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function nullable(innerType) { + return new ZodNullable2({ + type: "nullable", + innerType + }); +} +function nullish2(innerType) { + return optional(nullable(innerType)); +} +var ZodDefault2 = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => { + $ZodDefault.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => defaultProcessor(inst, ctx, json2, params); + inst.unwrap = () => inst._zod.def.innerType; + inst.removeDefault = inst.unwrap; +}); +function _default2(innerType, defaultValue) { + return new ZodDefault2({ + type: "default", + innerType, + get defaultValue() { + return typeof defaultValue === "function" ? defaultValue() : util_exports.shallowClone(defaultValue); + } + }); +} +var ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => { + $ZodPrefault.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => prefaultProcessor(inst, ctx, json2, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function prefault(innerType, defaultValue) { + return new ZodPrefault({ + type: "prefault", + innerType, + get defaultValue() { + return typeof defaultValue === "function" ? defaultValue() : util_exports.shallowClone(defaultValue); + } + }); +} +var ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => { + $ZodNonOptional.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => nonoptionalProcessor(inst, ctx, json2, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function nonoptional(innerType, params) { + return new ZodNonOptional({ + type: "nonoptional", + innerType, + ...util_exports.normalizeParams(params) + }); +} +var ZodSuccess = /* @__PURE__ */ $constructor("ZodSuccess", (inst, def) => { + $ZodSuccess.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => successProcessor(inst, ctx, json2, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function success(innerType) { + return new ZodSuccess({ + type: "success", + innerType + }); +} +var ZodCatch2 = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => { + $ZodCatch.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => catchProcessor(inst, ctx, json2, params); + inst.unwrap = () => inst._zod.def.innerType; + inst.removeCatch = inst.unwrap; +}); +function _catch2(innerType, catchValue) { + return new ZodCatch2({ + type: "catch", + innerType, + catchValue: typeof catchValue === "function" ? catchValue : () => catchValue + }); +} +var ZodNaN2 = /* @__PURE__ */ $constructor("ZodNaN", (inst, def) => { + $ZodNaN.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => nanProcessor(inst, ctx, json2, params); +}); +function nan(params) { + return _nan(ZodNaN2, params); +} +var ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => { + $ZodPipe.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => pipeProcessor(inst, ctx, json2, params); + inst.in = def.in; + inst.out = def.out; +}); +function pipe(in_, out) { + return new ZodPipe({ + type: "pipe", + in: in_, + out + // ...util.normalizeParams(params), + }); +} +var ZodCodec = /* @__PURE__ */ $constructor("ZodCodec", (inst, def) => { + ZodPipe.init(inst, def); + $ZodCodec.init(inst, def); +}); +function codec(in_, out, params) { + return new ZodCodec({ + type: "pipe", + in: in_, + out, + transform: params.decode, + reverseTransform: params.encode + }); +} +var ZodReadonly2 = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => { + $ZodReadonly.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => readonlyProcessor(inst, ctx, json2, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function readonly(innerType) { + return new ZodReadonly2({ + type: "readonly", + innerType + }); +} +var ZodTemplateLiteral = /* @__PURE__ */ $constructor("ZodTemplateLiteral", (inst, def) => { + $ZodTemplateLiteral.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => templateLiteralProcessor(inst, ctx, json2, params); +}); +function templateLiteral(parts, params) { + return new ZodTemplateLiteral({ + type: "template_literal", + parts, + ...util_exports.normalizeParams(params) + }); +} +var ZodLazy2 = /* @__PURE__ */ $constructor("ZodLazy", (inst, def) => { + $ZodLazy.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => lazyProcessor(inst, ctx, json2, params); + inst.unwrap = () => inst._zod.def.getter(); +}); +function lazy(getter) { + return new ZodLazy2({ + type: "lazy", + getter + }); +} +var ZodPromise2 = /* @__PURE__ */ $constructor("ZodPromise", (inst, def) => { + $ZodPromise.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => promiseProcessor(inst, ctx, json2, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function promise(innerType) { + return new ZodPromise2({ + type: "promise", + innerType + }); +} +var ZodFunction2 = /* @__PURE__ */ $constructor("ZodFunction", (inst, def) => { + $ZodFunction.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => functionProcessor(inst, ctx, json2, params); +}); +function _function(params) { + var _a3, _b2; + return new ZodFunction2({ + type: "function", + input: Array.isArray(params == null ? void 0 : params.input) ? tuple(params == null ? void 0 : params.input) : (_a3 = params == null ? void 0 : params.input) != null ? _a3 : array(unknown()), + output: (_b2 = params == null ? void 0 : params.output) != null ? _b2 : unknown() + }); +} +var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => { + $ZodCustom.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => customProcessor(inst, ctx, json2, params); +}); +function check(fn) { + const ch = new $ZodCheck({ + check: "custom" + // ...util.normalizeParams(params), + }); + ch._zod.check = fn; + return ch; +} +function custom(fn, _params) { + return _custom(ZodCustom, fn != null ? fn : (() => true), _params); +} +function refine(fn, _params = {}) { + return _refine(ZodCustom, fn, _params); +} +function superRefine(fn) { + return _superRefine(fn); +} +var describe2 = describe; +var meta2 = meta; +function _instanceof(cls, params = {}) { + const inst = new ZodCustom({ + type: "custom", + check: "custom", + fn: (data) => data instanceof cls, + abort: true, + ...util_exports.normalizeParams(params) + }); + inst._zod.bag.Class = cls; + inst._zod.check = (payload) => { + var _a3; + if (!(payload.value instanceof cls)) { + payload.issues.push({ + code: "invalid_type", + expected: cls.name, + input: payload.value, + inst, + path: [...(_a3 = inst._zod.def.path) != null ? _a3 : []] + }); + } + }; + return inst; +} +var stringbool = (...args) => _stringbool({ + Codec: ZodCodec, + Boolean: ZodBoolean2, + String: ZodString2 +}, ...args); +function json(params) { + const jsonSchema = lazy(() => { + return union([string3(params), number3(), boolean3(), _null3(), array(jsonSchema), record(string3(), jsonSchema)]); + }); + return jsonSchema; +} +function preprocess(fn, schema) { + return pipe(transform(fn), schema); +} + +// node_modules/zod/v4/classic/compat.js +var ZodIssueCode2 = { + invalid_type: "invalid_type", + too_big: "too_big", + too_small: "too_small", + invalid_format: "invalid_format", + not_multiple_of: "not_multiple_of", + unrecognized_keys: "unrecognized_keys", + invalid_union: "invalid_union", + invalid_key: "invalid_key", + invalid_element: "invalid_element", + invalid_value: "invalid_value", + custom: "custom" +}; +var ZodFirstPartyTypeKind2; +/* @__PURE__ */ (function(ZodFirstPartyTypeKind3) { +})(ZodFirstPartyTypeKind2 || (ZodFirstPartyTypeKind2 = {})); + +// node_modules/zod/v4/classic/from-json-schema.js +var z = { + ...schemas_exports3, + ...checks_exports2, + iso: iso_exports2 +}; + +// node_modules/zod/v4/classic/coerce.js +var coerce_exports2 = {}; +__export(coerce_exports2, { + bigint: () => bigint4, + boolean: () => boolean4, + date: () => date6, + number: () => number4, + string: () => string4 +}); +function string4(params) { + return _coercedString(ZodString2, params); +} +function number4(params) { + return _coercedNumber(ZodNumber2, params); +} +function boolean4(params) { + return _coercedBoolean(ZodBoolean2, params); +} +function bigint4(params) { + return _coercedBigint(ZodBigInt2, params); +} +function date6(params) { + return _coercedDate(ZodDate2, params); +} + +// node_modules/zod/v4/classic/external.js +config(en_default3()); + +// node_modules/@modelcontextprotocol/sdk/dist/esm/types.js +var LATEST_PROTOCOL_VERSION = "2025-11-25"; +var SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-06-18", "2025-03-26", "2024-11-05", "2024-10-07"]; +var RELATED_TASK_META_KEY = "io.modelcontextprotocol/related-task"; +var JSONRPC_VERSION = "2.0"; +var AssertObjectSchema = custom((v2) => v2 !== null && (typeof v2 === "object" || typeof v2 === "function")); +var ProgressTokenSchema = union([string3(), number3().int()]); +var CursorSchema = string3(); +var TaskCreationParamsSchema = looseObject({ + /** + * Requested duration in milliseconds to retain task from creation. + */ + ttl: number3().optional(), + /** + * Time in milliseconds to wait between task status requests. + */ + pollInterval: number3().optional() +}); +var TaskMetadataSchema = object2({ + ttl: number3().optional() +}); +var RelatedTaskMetadataSchema = object2({ + taskId: string3() +}); +var RequestMetaSchema = looseObject({ + /** + * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications. + */ + progressToken: ProgressTokenSchema.optional(), + /** + * If specified, this request is related to the provided task. + */ + [RELATED_TASK_META_KEY]: RelatedTaskMetadataSchema.optional() +}); +var BaseRequestParamsSchema = object2({ + /** + * See [General fields: `_meta`](/specification/draft/basic/index#meta) for notes on `_meta` usage. + */ + _meta: RequestMetaSchema.optional() +}); +var TaskAugmentedRequestParamsSchema = BaseRequestParamsSchema.extend({ + /** + * If specified, the caller is requesting task-augmented execution for this request. + * The request will return a CreateTaskResult immediately, and the actual result can be + * retrieved later via tasks/result. + * + * Task augmentation is subject to capability negotiation - receivers MUST declare support + * for task augmentation of specific request types in their capabilities. + */ + task: TaskMetadataSchema.optional() +}); +var isTaskAugmentedRequestParams = (value) => TaskAugmentedRequestParamsSchema.safeParse(value).success; +var RequestSchema = object2({ + method: string3(), + params: BaseRequestParamsSchema.loose().optional() +}); +var NotificationsParamsSchema = object2({ + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: RequestMetaSchema.optional() +}); +var NotificationSchema = object2({ + method: string3(), + params: NotificationsParamsSchema.loose().optional() +}); +var ResultSchema = looseObject({ + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: RequestMetaSchema.optional() +}); +var RequestIdSchema = union([string3(), number3().int()]); +var JSONRPCRequestSchema = object2({ + jsonrpc: literal(JSONRPC_VERSION), + id: RequestIdSchema, + ...RequestSchema.shape +}).strict(); +var isJSONRPCRequest = (value) => JSONRPCRequestSchema.safeParse(value).success; +var JSONRPCNotificationSchema = object2({ + jsonrpc: literal(JSONRPC_VERSION), + ...NotificationSchema.shape +}).strict(); +var isJSONRPCNotification = (value) => JSONRPCNotificationSchema.safeParse(value).success; +var JSONRPCResultResponseSchema = object2({ + jsonrpc: literal(JSONRPC_VERSION), + id: RequestIdSchema, + result: ResultSchema +}).strict(); +var isJSONRPCResultResponse = (value) => JSONRPCResultResponseSchema.safeParse(value).success; +var ErrorCode; +(function(ErrorCode2) { + ErrorCode2[ErrorCode2["ConnectionClosed"] = -32e3] = "ConnectionClosed"; + ErrorCode2[ErrorCode2["RequestTimeout"] = -32001] = "RequestTimeout"; + ErrorCode2[ErrorCode2["ParseError"] = -32700] = "ParseError"; + ErrorCode2[ErrorCode2["InvalidRequest"] = -32600] = "InvalidRequest"; + ErrorCode2[ErrorCode2["MethodNotFound"] = -32601] = "MethodNotFound"; + ErrorCode2[ErrorCode2["InvalidParams"] = -32602] = "InvalidParams"; + ErrorCode2[ErrorCode2["InternalError"] = -32603] = "InternalError"; + ErrorCode2[ErrorCode2["UrlElicitationRequired"] = -32042] = "UrlElicitationRequired"; +})(ErrorCode || (ErrorCode = {})); +var JSONRPCErrorResponseSchema = object2({ + jsonrpc: literal(JSONRPC_VERSION), + id: RequestIdSchema.optional(), + error: object2({ + /** + * The error type that occurred. + */ + code: number3().int(), + /** + * A short description of the error. The message SHOULD be limited to a concise single sentence. + */ + message: string3(), + /** + * Additional information about the error. The value of this member is defined by the sender (e.g. detailed error information, nested errors etc.). + */ + data: unknown().optional() + }) +}).strict(); +var isJSONRPCErrorResponse = (value) => JSONRPCErrorResponseSchema.safeParse(value).success; +var JSONRPCMessageSchema = union([ + JSONRPCRequestSchema, + JSONRPCNotificationSchema, + JSONRPCResultResponseSchema, + JSONRPCErrorResponseSchema +]); +var JSONRPCResponseSchema = union([JSONRPCResultResponseSchema, JSONRPCErrorResponseSchema]); +var EmptyResultSchema = ResultSchema.strict(); +var CancelledNotificationParamsSchema = NotificationsParamsSchema.extend({ + /** + * The ID of the request to cancel. + * + * This MUST correspond to the ID of a request previously issued in the same direction. + */ + requestId: RequestIdSchema.optional(), + /** + * An optional string describing the reason for the cancellation. This MAY be logged or presented to the user. + */ + reason: string3().optional() +}); +var CancelledNotificationSchema = NotificationSchema.extend({ + method: literal("notifications/cancelled"), + params: CancelledNotificationParamsSchema +}); +var IconSchema = object2({ + /** + * URL or data URI for the icon. + */ + src: string3(), + /** + * Optional MIME type for the icon. + */ + mimeType: string3().optional(), + /** + * Optional array of strings that specify sizes at which the icon can be used. + * Each string should be in WxH format (e.g., `"48x48"`, `"96x96"`) or `"any"` for scalable formats like SVG. + * + * If not provided, the client should assume that the icon can be used at any size. + */ + sizes: array(string3()).optional(), + /** + * Optional specifier for the theme this icon is designed for. `light` indicates + * the icon is designed to be used with a light background, and `dark` indicates + * the icon is designed to be used with a dark background. + * + * If not provided, the client should assume the icon can be used with any theme. + */ + theme: _enum2(["light", "dark"]).optional() +}); +var IconsSchema = object2({ + /** + * Optional set of sized icons that the client can display in a user interface. + * + * Clients that support rendering icons MUST support at least the following MIME types: + * - `image/png` - PNG images (safe, universal compatibility) + * - `image/jpeg` (and `image/jpg`) - JPEG images (safe, universal compatibility) + * + * Clients that support rendering icons SHOULD also support: + * - `image/svg+xml` - SVG images (scalable but requires security precautions) + * - `image/webp` - WebP images (modern, efficient format) + */ + icons: array(IconSchema).optional() +}); +var BaseMetadataSchema = object2({ + /** Intended for programmatic or logical use, but used as a display name in past specs or fallback */ + name: string3(), + /** + * Intended for UI and end-user contexts — optimized to be human-readable and easily understood, + * even by those unfamiliar with domain-specific terminology. + * + * If not provided, the name should be used for display (except for Tool, + * where `annotations.title` should be given precedence over using `name`, + * if present). + */ + title: string3().optional() +}); +var ImplementationSchema = BaseMetadataSchema.extend({ + ...BaseMetadataSchema.shape, + ...IconsSchema.shape, + version: string3(), + /** + * An optional URL of the website for this implementation. + */ + websiteUrl: string3().optional(), + /** + * An optional human-readable description of what this implementation does. + * + * This can be used by clients or servers to provide context about their purpose + * and capabilities. For example, a server might describe the types of resources + * or tools it provides, while a client might describe its intended use case. + */ + description: string3().optional() +}); +var FormElicitationCapabilitySchema = intersection(object2({ + applyDefaults: boolean3().optional() +}), record(string3(), unknown())); +var ElicitationCapabilitySchema = preprocess((value) => { + if (value && typeof value === "object" && !Array.isArray(value)) { + if (Object.keys(value).length === 0) { + return { form: {} }; + } + } + return value; +}, intersection(object2({ + form: FormElicitationCapabilitySchema.optional(), + url: AssertObjectSchema.optional() +}), record(string3(), unknown()).optional())); +var ClientTasksCapabilitySchema = looseObject({ + /** + * Present if the client supports listing tasks. + */ + list: AssertObjectSchema.optional(), + /** + * Present if the client supports cancelling tasks. + */ + cancel: AssertObjectSchema.optional(), + /** + * Capabilities for task creation on specific request types. + */ + requests: looseObject({ + /** + * Task support for sampling requests. + */ + sampling: looseObject({ + createMessage: AssertObjectSchema.optional() + }).optional(), + /** + * Task support for elicitation requests. + */ + elicitation: looseObject({ + create: AssertObjectSchema.optional() + }).optional() + }).optional() +}); +var ServerTasksCapabilitySchema = looseObject({ + /** + * Present if the server supports listing tasks. + */ + list: AssertObjectSchema.optional(), + /** + * Present if the server supports cancelling tasks. + */ + cancel: AssertObjectSchema.optional(), + /** + * Capabilities for task creation on specific request types. + */ + requests: looseObject({ + /** + * Task support for tool requests. + */ + tools: looseObject({ + call: AssertObjectSchema.optional() + }).optional() + }).optional() +}); +var ClientCapabilitiesSchema = object2({ + /** + * Experimental, non-standard capabilities that the client supports. + */ + experimental: record(string3(), AssertObjectSchema).optional(), + /** + * Present if the client supports sampling from an LLM. + */ + sampling: object2({ + /** + * Present if the client supports context inclusion via includeContext parameter. + * If not declared, servers SHOULD only use `includeContext: "none"` (or omit it). + */ + context: AssertObjectSchema.optional(), + /** + * Present if the client supports tool use via tools and toolChoice parameters. + */ + tools: AssertObjectSchema.optional() + }).optional(), + /** + * Present if the client supports eliciting user input. + */ + elicitation: ElicitationCapabilitySchema.optional(), + /** + * Present if the client supports listing roots. + */ + roots: object2({ + /** + * Whether the client supports issuing notifications for changes to the roots list. + */ + listChanged: boolean3().optional() + }).optional(), + /** + * Present if the client supports task creation. + */ + tasks: ClientTasksCapabilitySchema.optional(), + /** + * Extensions that the client supports. Keys are extension identifiers (vendor-prefix/extension-name). + */ + extensions: record(string3(), AssertObjectSchema).optional() +}); +var InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({ + /** + * The latest version of the Model Context Protocol that the client supports. The client MAY decide to support older versions as well. + */ + protocolVersion: string3(), + capabilities: ClientCapabilitiesSchema, + clientInfo: ImplementationSchema +}); +var InitializeRequestSchema = RequestSchema.extend({ + method: literal("initialize"), + params: InitializeRequestParamsSchema +}); +var ServerCapabilitiesSchema = object2({ + /** + * Experimental, non-standard capabilities that the server supports. + */ + experimental: record(string3(), AssertObjectSchema).optional(), + /** + * Present if the server supports sending log messages to the client. + */ + logging: AssertObjectSchema.optional(), + /** + * Present if the server supports sending completions to the client. + */ + completions: AssertObjectSchema.optional(), + /** + * Present if the server offers any prompt templates. + */ + prompts: object2({ + /** + * Whether this server supports issuing notifications for changes to the prompt list. + */ + listChanged: boolean3().optional() + }).optional(), + /** + * Present if the server offers any resources to read. + */ + resources: object2({ + /** + * Whether this server supports clients subscribing to resource updates. + */ + subscribe: boolean3().optional(), + /** + * Whether this server supports issuing notifications for changes to the resource list. + */ + listChanged: boolean3().optional() + }).optional(), + /** + * Present if the server offers any tools to call. + */ + tools: object2({ + /** + * Whether this server supports issuing notifications for changes to the tool list. + */ + listChanged: boolean3().optional() + }).optional(), + /** + * Present if the server supports task creation. + */ + tasks: ServerTasksCapabilitySchema.optional(), + /** + * Extensions that the server supports. Keys are extension identifiers (vendor-prefix/extension-name). + */ + extensions: record(string3(), AssertObjectSchema).optional() +}); +var InitializeResultSchema = ResultSchema.extend({ + /** + * The version of the Model Context Protocol that the server wants to use. This may not match the version that the client requested. If the client cannot support this version, it MUST disconnect. + */ + protocolVersion: string3(), + capabilities: ServerCapabilitiesSchema, + serverInfo: ImplementationSchema, + /** + * Instructions describing how to use the server and its features. + * + * This can be used by clients to improve the LLM's understanding of available tools, resources, etc. It can be thought of like a "hint" to the model. For example, this information MAY be added to the system prompt. + */ + instructions: string3().optional() +}); +var InitializedNotificationSchema = NotificationSchema.extend({ + method: literal("notifications/initialized"), + params: NotificationsParamsSchema.optional() +}); +var isInitializedNotification = (value) => InitializedNotificationSchema.safeParse(value).success; +var PingRequestSchema = RequestSchema.extend({ + method: literal("ping"), + params: BaseRequestParamsSchema.optional() +}); +var ProgressSchema = object2({ + /** + * The progress thus far. This should increase every time progress is made, even if the total is unknown. + */ + progress: number3(), + /** + * Total number of items to process (or total progress required), if known. + */ + total: optional(number3()), + /** + * An optional message describing the current progress. + */ + message: optional(string3()) +}); +var ProgressNotificationParamsSchema = object2({ + ...NotificationsParamsSchema.shape, + ...ProgressSchema.shape, + /** + * The progress token which was given in the initial request, used to associate this notification with the request that is proceeding. + */ + progressToken: ProgressTokenSchema +}); +var ProgressNotificationSchema = NotificationSchema.extend({ + method: literal("notifications/progress"), + params: ProgressNotificationParamsSchema +}); +var PaginatedRequestParamsSchema = BaseRequestParamsSchema.extend({ + /** + * An opaque token representing the current pagination position. + * If provided, the server should return results starting after this cursor. + */ + cursor: CursorSchema.optional() +}); +var PaginatedRequestSchema = RequestSchema.extend({ + params: PaginatedRequestParamsSchema.optional() +}); +var PaginatedResultSchema = ResultSchema.extend({ + /** + * An opaque token representing the pagination position after the last returned result. + * If present, there may be more results available. + */ + nextCursor: CursorSchema.optional() +}); +var TaskStatusSchema = _enum2(["working", "input_required", "completed", "failed", "cancelled"]); +var TaskSchema = object2({ + taskId: string3(), + status: TaskStatusSchema, + /** + * Time in milliseconds to keep task results available after completion. + * If null, the task has unlimited lifetime until manually cleaned up. + */ + ttl: union([number3(), _null3()]), + /** + * ISO 8601 timestamp when the task was created. + */ + createdAt: string3(), + /** + * ISO 8601 timestamp when the task was last updated. + */ + lastUpdatedAt: string3(), + pollInterval: optional(number3()), + /** + * Optional diagnostic message for failed tasks or other status information. + */ + statusMessage: optional(string3()) +}); +var CreateTaskResultSchema = ResultSchema.extend({ + task: TaskSchema +}); +var TaskStatusNotificationParamsSchema = NotificationsParamsSchema.merge(TaskSchema); +var TaskStatusNotificationSchema = NotificationSchema.extend({ + method: literal("notifications/tasks/status"), + params: TaskStatusNotificationParamsSchema +}); +var GetTaskRequestSchema = RequestSchema.extend({ + method: literal("tasks/get"), + params: BaseRequestParamsSchema.extend({ + taskId: string3() + }) +}); +var GetTaskResultSchema = ResultSchema.merge(TaskSchema); +var GetTaskPayloadRequestSchema = RequestSchema.extend({ + method: literal("tasks/result"), + params: BaseRequestParamsSchema.extend({ + taskId: string3() + }) +}); +var GetTaskPayloadResultSchema = ResultSchema.loose(); +var ListTasksRequestSchema = PaginatedRequestSchema.extend({ + method: literal("tasks/list") +}); +var ListTasksResultSchema = PaginatedResultSchema.extend({ + tasks: array(TaskSchema) +}); +var CancelTaskRequestSchema = RequestSchema.extend({ + method: literal("tasks/cancel"), + params: BaseRequestParamsSchema.extend({ + taskId: string3() + }) +}); +var CancelTaskResultSchema = ResultSchema.merge(TaskSchema); +var ResourceContentsSchema = object2({ + /** + * The URI of this resource. + */ + uri: string3(), + /** + * The MIME type of this resource, if known. + */ + mimeType: optional(string3()), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: record(string3(), unknown()).optional() +}); +var TextResourceContentsSchema = ResourceContentsSchema.extend({ + /** + * The text of the item. This must only be set if the item can actually be represented as text (not binary data). + */ + text: string3() +}); +var Base64Schema = string3().refine((val) => { + try { + atob(val); + return true; + } catch (e3) { + return false; + } +}, { message: "Invalid Base64 string" }); +var BlobResourceContentsSchema = ResourceContentsSchema.extend({ + /** + * A base64-encoded string representing the binary data of the item. + */ + blob: Base64Schema +}); +var RoleSchema = _enum2(["user", "assistant"]); +var AnnotationsSchema = object2({ + /** + * Intended audience(s) for the resource. + */ + audience: array(RoleSchema).optional(), + /** + * Importance hint for the resource, from 0 (least) to 1 (most). + */ + priority: number3().min(0).max(1).optional(), + /** + * ISO 8601 timestamp for the most recent modification. + */ + lastModified: iso_exports2.datetime({ offset: true }).optional() +}); +var ResourceSchema = object2({ + ...BaseMetadataSchema.shape, + ...IconsSchema.shape, + /** + * The URI of this resource. + */ + uri: string3(), + /** + * A description of what this resource represents. + * + * This can be used by clients to improve the LLM's understanding of available resources. It can be thought of like a "hint" to the model. + */ + description: optional(string3()), + /** + * The MIME type of this resource, if known. + */ + mimeType: optional(string3()), + /** + * The size of the raw resource content, in bytes (i.e., before base64 encoding or any tokenization), if known. + * + * This can be used by Hosts to display file sizes and estimate context window usage. + */ + size: optional(number3()), + /** + * Optional annotations for the client. + */ + annotations: AnnotationsSchema.optional(), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: optional(looseObject({})) +}); +var ResourceTemplateSchema = object2({ + ...BaseMetadataSchema.shape, + ...IconsSchema.shape, + /** + * A URI template (according to RFC 6570) that can be used to construct resource URIs. + */ + uriTemplate: string3(), + /** + * A description of what this template is for. + * + * This can be used by clients to improve the LLM's understanding of available resources. It can be thought of like a "hint" to the model. + */ + description: optional(string3()), + /** + * The MIME type for all resources that match this template. This should only be included if all resources matching this template have the same type. + */ + mimeType: optional(string3()), + /** + * Optional annotations for the client. + */ + annotations: AnnotationsSchema.optional(), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: optional(looseObject({})) +}); +var ListResourcesRequestSchema = PaginatedRequestSchema.extend({ + method: literal("resources/list") +}); +var ListResourcesResultSchema = PaginatedResultSchema.extend({ + resources: array(ResourceSchema) +}); +var ListResourceTemplatesRequestSchema = PaginatedRequestSchema.extend({ + method: literal("resources/templates/list") +}); +var ListResourceTemplatesResultSchema = PaginatedResultSchema.extend({ + resourceTemplates: array(ResourceTemplateSchema) +}); +var ResourceRequestParamsSchema = BaseRequestParamsSchema.extend({ + /** + * The URI of the resource to read. The URI can use any protocol; it is up to the server how to interpret it. + * + * @format uri + */ + uri: string3() +}); +var ReadResourceRequestParamsSchema = ResourceRequestParamsSchema; +var ReadResourceRequestSchema = RequestSchema.extend({ + method: literal("resources/read"), + params: ReadResourceRequestParamsSchema +}); +var ReadResourceResultSchema = ResultSchema.extend({ + contents: array(union([TextResourceContentsSchema, BlobResourceContentsSchema])) +}); +var ResourceListChangedNotificationSchema = NotificationSchema.extend({ + method: literal("notifications/resources/list_changed"), + params: NotificationsParamsSchema.optional() +}); +var SubscribeRequestParamsSchema = ResourceRequestParamsSchema; +var SubscribeRequestSchema = RequestSchema.extend({ + method: literal("resources/subscribe"), + params: SubscribeRequestParamsSchema +}); +var UnsubscribeRequestParamsSchema = ResourceRequestParamsSchema; +var UnsubscribeRequestSchema = RequestSchema.extend({ + method: literal("resources/unsubscribe"), + params: UnsubscribeRequestParamsSchema +}); +var ResourceUpdatedNotificationParamsSchema = NotificationsParamsSchema.extend({ + /** + * The URI of the resource that has been updated. This might be a sub-resource of the one that the client actually subscribed to. + */ + uri: string3() +}); +var ResourceUpdatedNotificationSchema = NotificationSchema.extend({ + method: literal("notifications/resources/updated"), + params: ResourceUpdatedNotificationParamsSchema +}); +var PromptArgumentSchema = object2({ + /** + * The name of the argument. + */ + name: string3(), + /** + * A human-readable description of the argument. + */ + description: optional(string3()), + /** + * Whether this argument must be provided. + */ + required: optional(boolean3()) +}); +var PromptSchema = object2({ + ...BaseMetadataSchema.shape, + ...IconsSchema.shape, + /** + * An optional description of what this prompt provides + */ + description: optional(string3()), + /** + * A list of arguments to use for templating the prompt. + */ + arguments: optional(array(PromptArgumentSchema)), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: optional(looseObject({})) +}); +var ListPromptsRequestSchema = PaginatedRequestSchema.extend({ + method: literal("prompts/list") +}); +var ListPromptsResultSchema = PaginatedResultSchema.extend({ + prompts: array(PromptSchema) +}); +var GetPromptRequestParamsSchema = BaseRequestParamsSchema.extend({ + /** + * The name of the prompt or prompt template. + */ + name: string3(), + /** + * Arguments to use for templating the prompt. + */ + arguments: record(string3(), string3()).optional() +}); +var GetPromptRequestSchema = RequestSchema.extend({ + method: literal("prompts/get"), + params: GetPromptRequestParamsSchema +}); +var TextContentSchema = object2({ + type: literal("text"), + /** + * The text content of the message. + */ + text: string3(), + /** + * Optional annotations for the client. + */ + annotations: AnnotationsSchema.optional(), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: record(string3(), unknown()).optional() +}); +var ImageContentSchema = object2({ + type: literal("image"), + /** + * The base64-encoded image data. + */ + data: Base64Schema, + /** + * The MIME type of the image. Different providers may support different image types. + */ + mimeType: string3(), + /** + * Optional annotations for the client. + */ + annotations: AnnotationsSchema.optional(), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: record(string3(), unknown()).optional() +}); +var AudioContentSchema = object2({ + type: literal("audio"), + /** + * The base64-encoded audio data. + */ + data: Base64Schema, + /** + * The MIME type of the audio. Different providers may support different audio types. + */ + mimeType: string3(), + /** + * Optional annotations for the client. + */ + annotations: AnnotationsSchema.optional(), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: record(string3(), unknown()).optional() +}); +var ToolUseContentSchema = object2({ + type: literal("tool_use"), + /** + * The name of the tool to invoke. + * Must match a tool name from the request's tools array. + */ + name: string3(), + /** + * Unique identifier for this tool call. + * Used to correlate with ToolResultContent in subsequent messages. + */ + id: string3(), + /** + * Arguments to pass to the tool. + * Must conform to the tool's inputSchema. + */ + input: record(string3(), unknown()), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: record(string3(), unknown()).optional() +}); +var EmbeddedResourceSchema = object2({ + type: literal("resource"), + resource: union([TextResourceContentsSchema, BlobResourceContentsSchema]), + /** + * Optional annotations for the client. + */ + annotations: AnnotationsSchema.optional(), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: record(string3(), unknown()).optional() +}); +var ResourceLinkSchema = ResourceSchema.extend({ + type: literal("resource_link") +}); +var ContentBlockSchema = union([ + TextContentSchema, + ImageContentSchema, + AudioContentSchema, + ResourceLinkSchema, + EmbeddedResourceSchema +]); +var PromptMessageSchema = object2({ + role: RoleSchema, + content: ContentBlockSchema +}); +var GetPromptResultSchema = ResultSchema.extend({ + /** + * An optional description for the prompt. + */ + description: string3().optional(), + messages: array(PromptMessageSchema) +}); +var PromptListChangedNotificationSchema = NotificationSchema.extend({ + method: literal("notifications/prompts/list_changed"), + params: NotificationsParamsSchema.optional() +}); +var ToolAnnotationsSchema = object2({ + /** + * A human-readable title for the tool. + */ + title: string3().optional(), + /** + * If true, the tool does not modify its environment. + * + * Default: false + */ + readOnlyHint: boolean3().optional(), + /** + * If true, the tool may perform destructive updates to its environment. + * If false, the tool performs only additive updates. + * + * (This property is meaningful only when `readOnlyHint == false`) + * + * Default: true + */ + destructiveHint: boolean3().optional(), + /** + * If true, calling the tool repeatedly with the same arguments + * will have no additional effect on the its environment. + * + * (This property is meaningful only when `readOnlyHint == false`) + * + * Default: false + */ + idempotentHint: boolean3().optional(), + /** + * If true, this tool may interact with an "open world" of external + * entities. If false, the tool's domain of interaction is closed. + * For example, the world of a web search tool is open, whereas that + * of a memory tool is not. + * + * Default: true + */ + openWorldHint: boolean3().optional() +}); +var ToolExecutionSchema = object2({ + /** + * Indicates the tool's preference for task-augmented execution. + * - "required": Clients MUST invoke the tool as a task + * - "optional": Clients MAY invoke the tool as a task or normal request + * - "forbidden": Clients MUST NOT attempt to invoke the tool as a task + * + * If not present, defaults to "forbidden". + */ + taskSupport: _enum2(["required", "optional", "forbidden"]).optional() +}); +var ToolSchema = object2({ + ...BaseMetadataSchema.shape, + ...IconsSchema.shape, + /** + * A human-readable description of the tool. + */ + description: string3().optional(), + /** + * A JSON Schema 2020-12 object defining the expected parameters for the tool. + * Must have type: 'object' at the root level per MCP spec. + */ + inputSchema: object2({ + type: literal("object"), + properties: record(string3(), AssertObjectSchema).optional(), + required: array(string3()).optional() + }).catchall(unknown()), + /** + * An optional JSON Schema 2020-12 object defining the structure of the tool's output + * returned in the structuredContent field of a CallToolResult. + * Must have type: 'object' at the root level per MCP spec. + */ + outputSchema: object2({ + type: literal("object"), + properties: record(string3(), AssertObjectSchema).optional(), + required: array(string3()).optional() + }).catchall(unknown()).optional(), + /** + * Optional additional tool information. + */ + annotations: ToolAnnotationsSchema.optional(), + /** + * Execution-related properties for this tool. + */ + execution: ToolExecutionSchema.optional(), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: record(string3(), unknown()).optional() +}); +var ListToolsRequestSchema = PaginatedRequestSchema.extend({ + method: literal("tools/list") +}); +var ListToolsResultSchema = PaginatedResultSchema.extend({ + tools: array(ToolSchema) +}); +var CallToolResultSchema = ResultSchema.extend({ + /** + * A list of content objects that represent the result of the tool call. + * + * If the Tool does not define an outputSchema, this field MUST be present in the result. + * For backwards compatibility, this field is always present, but it may be empty. + */ + content: array(ContentBlockSchema).default([]), + /** + * An object containing structured tool output. + * + * If the Tool defines an outputSchema, this field MUST be present in the result, and contain a JSON object that matches the schema. + */ + structuredContent: record(string3(), unknown()).optional(), + /** + * Whether the tool call ended in an error. + * + * If not set, this is assumed to be false (the call was successful). + * + * Any errors that originate from the tool SHOULD be reported inside the result + * object, with `isError` set to true, _not_ as an MCP protocol-level error + * response. Otherwise, the LLM would not be able to see that an error occurred + * and self-correct. + * + * However, any errors in _finding_ the tool, an error indicating that the + * server does not support tool calls, or any other exceptional conditions, + * should be reported as an MCP error response. + */ + isError: boolean3().optional() +}); +var CompatibilityCallToolResultSchema = CallToolResultSchema.or(ResultSchema.extend({ + toolResult: unknown() +})); +var CallToolRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({ + /** + * The name of the tool to call. + */ + name: string3(), + /** + * Arguments to pass to the tool. + */ + arguments: record(string3(), unknown()).optional() +}); +var CallToolRequestSchema = RequestSchema.extend({ + method: literal("tools/call"), + params: CallToolRequestParamsSchema +}); +var ToolListChangedNotificationSchema = NotificationSchema.extend({ + method: literal("notifications/tools/list_changed"), + params: NotificationsParamsSchema.optional() +}); +var ListChangedOptionsBaseSchema = object2({ + /** + * If true, the list will be refreshed automatically when a list changed notification is received. + * The callback will be called with the updated list. + * + * If false, the callback will be called with null items, allowing manual refresh. + * + * @default true + */ + autoRefresh: boolean3().default(true), + /** + * Debounce time in milliseconds for list changed notification processing. + * + * Multiple notifications received within this timeframe will only trigger one refresh. + * Set to 0 to disable debouncing. + * + * @default 300 + */ + debounceMs: number3().int().nonnegative().default(300) +}); +var LoggingLevelSchema = _enum2(["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"]); +var SetLevelRequestParamsSchema = BaseRequestParamsSchema.extend({ + /** + * The level of logging that the client wants to receive from the server. The server should send all logs at this level and higher (i.e., more severe) to the client as notifications/logging/message. + */ + level: LoggingLevelSchema +}); +var SetLevelRequestSchema = RequestSchema.extend({ + method: literal("logging/setLevel"), + params: SetLevelRequestParamsSchema +}); +var LoggingMessageNotificationParamsSchema = NotificationsParamsSchema.extend({ + /** + * The severity of this log message. + */ + level: LoggingLevelSchema, + /** + * An optional name of the logger issuing this message. + */ + logger: string3().optional(), + /** + * The data to be logged, such as a string message or an object. Any JSON serializable type is allowed here. + */ + data: unknown() +}); +var LoggingMessageNotificationSchema = NotificationSchema.extend({ + method: literal("notifications/message"), + params: LoggingMessageNotificationParamsSchema +}); +var ModelHintSchema = object2({ + /** + * A hint for a model name. + */ + name: string3().optional() +}); +var ModelPreferencesSchema = object2({ + /** + * Optional hints to use for model selection. + */ + hints: array(ModelHintSchema).optional(), + /** + * How much to prioritize cost when selecting a model. + */ + costPriority: number3().min(0).max(1).optional(), + /** + * How much to prioritize sampling speed (latency) when selecting a model. + */ + speedPriority: number3().min(0).max(1).optional(), + /** + * How much to prioritize intelligence and capabilities when selecting a model. + */ + intelligencePriority: number3().min(0).max(1).optional() +}); +var ToolChoiceSchema = object2({ + /** + * Controls when tools are used: + * - "auto": Model decides whether to use tools (default) + * - "required": Model MUST use at least one tool before completing + * - "none": Model MUST NOT use any tools + */ + mode: _enum2(["auto", "required", "none"]).optional() +}); +var ToolResultContentSchema = object2({ + type: literal("tool_result"), + toolUseId: string3().describe("The unique identifier for the corresponding tool call."), + content: array(ContentBlockSchema).default([]), + structuredContent: object2({}).loose().optional(), + isError: boolean3().optional(), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: record(string3(), unknown()).optional() +}); +var SamplingContentSchema = discriminatedUnion("type", [TextContentSchema, ImageContentSchema, AudioContentSchema]); +var SamplingMessageContentBlockSchema = discriminatedUnion("type", [ + TextContentSchema, + ImageContentSchema, + AudioContentSchema, + ToolUseContentSchema, + ToolResultContentSchema +]); +var SamplingMessageSchema = object2({ + role: RoleSchema, + content: union([SamplingMessageContentBlockSchema, array(SamplingMessageContentBlockSchema)]), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: record(string3(), unknown()).optional() +}); +var CreateMessageRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({ + messages: array(SamplingMessageSchema), + /** + * The server's preferences for which model to select. The client MAY modify or omit this request. + */ + modelPreferences: ModelPreferencesSchema.optional(), + /** + * An optional system prompt the server wants to use for sampling. The client MAY modify or omit this prompt. + */ + systemPrompt: string3().optional(), + /** + * A request to include context from one or more MCP servers (including the caller), to be attached to the prompt. + * The client MAY ignore this request. + * + * Default is "none". Values "thisServer" and "allServers" are soft-deprecated. Servers SHOULD only use these values if the client + * declares ClientCapabilities.sampling.context. These values may be removed in future spec releases. + */ + includeContext: _enum2(["none", "thisServer", "allServers"]).optional(), + temperature: number3().optional(), + /** + * The requested maximum number of tokens to sample (to prevent runaway completions). + * + * The client MAY choose to sample fewer tokens than the requested maximum. + */ + maxTokens: number3().int(), + stopSequences: array(string3()).optional(), + /** + * Optional metadata to pass through to the LLM provider. The format of this metadata is provider-specific. + */ + metadata: AssertObjectSchema.optional(), + /** + * Tools that the model may use during generation. + * The client MUST return an error if this field is provided but ClientCapabilities.sampling.tools is not declared. + */ + tools: array(ToolSchema).optional(), + /** + * Controls how the model uses tools. + * The client MUST return an error if this field is provided but ClientCapabilities.sampling.tools is not declared. + * Default is `{ mode: "auto" }`. + */ + toolChoice: ToolChoiceSchema.optional() +}); +var CreateMessageRequestSchema = RequestSchema.extend({ + method: literal("sampling/createMessage"), + params: CreateMessageRequestParamsSchema +}); +var CreateMessageResultSchema = ResultSchema.extend({ + /** + * The name of the model that generated the message. + */ + model: string3(), + /** + * The reason why sampling stopped, if known. + * + * Standard values: + * - "endTurn": Natural end of the assistant's turn + * - "stopSequence": A stop sequence was encountered + * - "maxTokens": Maximum token limit was reached + * + * This field is an open string to allow for provider-specific stop reasons. + */ + stopReason: optional(_enum2(["endTurn", "stopSequence", "maxTokens"]).or(string3())), + role: RoleSchema, + /** + * Response content. Single content block (text, image, or audio). + */ + content: SamplingContentSchema +}); +var CreateMessageResultWithToolsSchema = ResultSchema.extend({ + /** + * The name of the model that generated the message. + */ + model: string3(), + /** + * The reason why sampling stopped, if known. + * + * Standard values: + * - "endTurn": Natural end of the assistant's turn + * - "stopSequence": A stop sequence was encountered + * - "maxTokens": Maximum token limit was reached + * - "toolUse": The model wants to use one or more tools + * + * This field is an open string to allow for provider-specific stop reasons. + */ + stopReason: optional(_enum2(["endTurn", "stopSequence", "maxTokens", "toolUse"]).or(string3())), + role: RoleSchema, + /** + * Response content. May be a single block or array. May include ToolUseContent if stopReason is "toolUse". + */ + content: union([SamplingMessageContentBlockSchema, array(SamplingMessageContentBlockSchema)]) +}); +var BooleanSchemaSchema = object2({ + type: literal("boolean"), + title: string3().optional(), + description: string3().optional(), + default: boolean3().optional() +}); +var StringSchemaSchema = object2({ + type: literal("string"), + title: string3().optional(), + description: string3().optional(), + minLength: number3().optional(), + maxLength: number3().optional(), + format: _enum2(["email", "uri", "date", "date-time"]).optional(), + default: string3().optional() +}); +var NumberSchemaSchema = object2({ + type: _enum2(["number", "integer"]), + title: string3().optional(), + description: string3().optional(), + minimum: number3().optional(), + maximum: number3().optional(), + default: number3().optional() +}); +var UntitledSingleSelectEnumSchemaSchema = object2({ + type: literal("string"), + title: string3().optional(), + description: string3().optional(), + enum: array(string3()), + default: string3().optional() +}); +var TitledSingleSelectEnumSchemaSchema = object2({ + type: literal("string"), + title: string3().optional(), + description: string3().optional(), + oneOf: array(object2({ + const: string3(), + title: string3() + })), + default: string3().optional() +}); +var LegacyTitledEnumSchemaSchema = object2({ + type: literal("string"), + title: string3().optional(), + description: string3().optional(), + enum: array(string3()), + enumNames: array(string3()).optional(), + default: string3().optional() +}); +var SingleSelectEnumSchemaSchema = union([UntitledSingleSelectEnumSchemaSchema, TitledSingleSelectEnumSchemaSchema]); +var UntitledMultiSelectEnumSchemaSchema = object2({ + type: literal("array"), + title: string3().optional(), + description: string3().optional(), + minItems: number3().optional(), + maxItems: number3().optional(), + items: object2({ + type: literal("string"), + enum: array(string3()) + }), + default: array(string3()).optional() +}); +var TitledMultiSelectEnumSchemaSchema = object2({ + type: literal("array"), + title: string3().optional(), + description: string3().optional(), + minItems: number3().optional(), + maxItems: number3().optional(), + items: object2({ + anyOf: array(object2({ + const: string3(), + title: string3() + })) + }), + default: array(string3()).optional() +}); +var MultiSelectEnumSchemaSchema = union([UntitledMultiSelectEnumSchemaSchema, TitledMultiSelectEnumSchemaSchema]); +var EnumSchemaSchema = union([LegacyTitledEnumSchemaSchema, SingleSelectEnumSchemaSchema, MultiSelectEnumSchemaSchema]); +var PrimitiveSchemaDefinitionSchema = union([EnumSchemaSchema, BooleanSchemaSchema, StringSchemaSchema, NumberSchemaSchema]); +var ElicitRequestFormParamsSchema = TaskAugmentedRequestParamsSchema.extend({ + /** + * The elicitation mode. + * + * Optional for backward compatibility. Clients MUST treat missing mode as "form". + */ + mode: literal("form").optional(), + /** + * The message to present to the user describing what information is being requested. + */ + message: string3(), + /** + * A restricted subset of JSON Schema. + * Only top-level properties are allowed, without nesting. + */ + requestedSchema: object2({ + type: literal("object"), + properties: record(string3(), PrimitiveSchemaDefinitionSchema), + required: array(string3()).optional() + }) +}); +var ElicitRequestURLParamsSchema = TaskAugmentedRequestParamsSchema.extend({ + /** + * The elicitation mode. + */ + mode: literal("url"), + /** + * The message to present to the user explaining why the interaction is needed. + */ + message: string3(), + /** + * The ID of the elicitation, which must be unique within the context of the server. + * The client MUST treat this ID as an opaque value. + */ + elicitationId: string3(), + /** + * The URL that the user should navigate to. + */ + url: string3().url() +}); +var ElicitRequestParamsSchema = union([ElicitRequestFormParamsSchema, ElicitRequestURLParamsSchema]); +var ElicitRequestSchema = RequestSchema.extend({ + method: literal("elicitation/create"), + params: ElicitRequestParamsSchema +}); +var ElicitationCompleteNotificationParamsSchema = NotificationsParamsSchema.extend({ + /** + * The ID of the elicitation that completed. + */ + elicitationId: string3() +}); +var ElicitationCompleteNotificationSchema = NotificationSchema.extend({ + method: literal("notifications/elicitation/complete"), + params: ElicitationCompleteNotificationParamsSchema +}); +var ElicitResultSchema = ResultSchema.extend({ + /** + * The user action in response to the elicitation. + * - "accept": User submitted the form/confirmed the action + * - "decline": User explicitly decline the action + * - "cancel": User dismissed without making an explicit choice + */ + action: _enum2(["accept", "decline", "cancel"]), + /** + * The submitted form data, only present when action is "accept". + * Contains values matching the requested schema. + * Per MCP spec, content is "typically omitted" for decline/cancel actions. + * We normalize null to undefined for leniency while maintaining type compatibility. + */ + content: preprocess((val) => val === null ? void 0 : val, record(string3(), union([string3(), number3(), boolean3(), array(string3())])).optional()) +}); +var ResourceTemplateReferenceSchema = object2({ + type: literal("ref/resource"), + /** + * The URI or URI template of the resource. + */ + uri: string3() +}); +var PromptReferenceSchema = object2({ + type: literal("ref/prompt"), + /** + * The name of the prompt or prompt template + */ + name: string3() +}); +var CompleteRequestParamsSchema = BaseRequestParamsSchema.extend({ + ref: union([PromptReferenceSchema, ResourceTemplateReferenceSchema]), + /** + * The argument's information + */ + argument: object2({ + /** + * The name of the argument + */ + name: string3(), + /** + * The value of the argument to use for completion matching. + */ + value: string3() + }), + context: object2({ + /** + * Previously-resolved variables in a URI template or prompt. + */ + arguments: record(string3(), string3()).optional() + }).optional() +}); +var CompleteRequestSchema = RequestSchema.extend({ + method: literal("completion/complete"), + params: CompleteRequestParamsSchema +}); +var CompleteResultSchema = ResultSchema.extend({ + completion: looseObject({ + /** + * An array of completion values. Must not exceed 100 items. + */ + values: array(string3()).max(100), + /** + * The total number of completion options available. This can exceed the number of values actually sent in the response. + */ + total: optional(number3().int()), + /** + * Indicates whether there are additional completion options beyond those provided in the current response, even if the exact total is unknown. + */ + hasMore: optional(boolean3()) + }) +}); +var RootSchema = object2({ + /** + * The URI identifying the root. This *must* start with file:// for now. + */ + uri: string3().startsWith("file://"), + /** + * An optional name for the root. + */ + name: string3().optional(), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: record(string3(), unknown()).optional() +}); +var ListRootsRequestSchema = RequestSchema.extend({ + method: literal("roots/list"), + params: BaseRequestParamsSchema.optional() +}); +var ListRootsResultSchema = ResultSchema.extend({ + roots: array(RootSchema) +}); +var RootsListChangedNotificationSchema = NotificationSchema.extend({ + method: literal("notifications/roots/list_changed"), + params: NotificationsParamsSchema.optional() +}); +var ClientRequestSchema = union([ + PingRequestSchema, + InitializeRequestSchema, + CompleteRequestSchema, + SetLevelRequestSchema, + GetPromptRequestSchema, + ListPromptsRequestSchema, + ListResourcesRequestSchema, + ListResourceTemplatesRequestSchema, + ReadResourceRequestSchema, + SubscribeRequestSchema, + UnsubscribeRequestSchema, + CallToolRequestSchema, + ListToolsRequestSchema, + GetTaskRequestSchema, + GetTaskPayloadRequestSchema, + ListTasksRequestSchema, + CancelTaskRequestSchema +]); +var ClientNotificationSchema = union([ + CancelledNotificationSchema, + ProgressNotificationSchema, + InitializedNotificationSchema, + RootsListChangedNotificationSchema, + TaskStatusNotificationSchema +]); +var ClientResultSchema = union([ + EmptyResultSchema, + CreateMessageResultSchema, + CreateMessageResultWithToolsSchema, + ElicitResultSchema, + ListRootsResultSchema, + GetTaskResultSchema, + ListTasksResultSchema, + CreateTaskResultSchema +]); +var ServerRequestSchema = union([ + PingRequestSchema, + CreateMessageRequestSchema, + ElicitRequestSchema, + ListRootsRequestSchema, + GetTaskRequestSchema, + GetTaskPayloadRequestSchema, + ListTasksRequestSchema, + CancelTaskRequestSchema +]); +var ServerNotificationSchema = union([ + CancelledNotificationSchema, + ProgressNotificationSchema, + LoggingMessageNotificationSchema, + ResourceUpdatedNotificationSchema, + ResourceListChangedNotificationSchema, + ToolListChangedNotificationSchema, + PromptListChangedNotificationSchema, + TaskStatusNotificationSchema, + ElicitationCompleteNotificationSchema +]); +var ServerResultSchema = union([ + EmptyResultSchema, + InitializeResultSchema, + CompleteResultSchema, + GetPromptResultSchema, + ListPromptsResultSchema, + ListResourcesResultSchema, + ListResourceTemplatesResultSchema, + ReadResourceResultSchema, + CallToolResultSchema, + ListToolsResultSchema, + GetTaskResultSchema, + ListTasksResultSchema, + CreateTaskResultSchema +]); +var McpError = class _McpError extends Error { + constructor(code, message, data) { + super(`MCP error ${code}: ${message}`); + this.code = code; + this.data = data; + this.name = "McpError"; + } + /** + * Factory method to create the appropriate error type based on the error code and data + */ + static fromError(code, message, data) { + if (code === ErrorCode.UrlElicitationRequired && data) { + const errorData = data; + if (errorData.elicitations) { + return new UrlElicitationRequiredError(errorData.elicitations, message); + } + } + return new _McpError(code, message, data); + } +}; +var UrlElicitationRequiredError = class extends McpError { + constructor(elicitations, message = `URL elicitation${elicitations.length > 1 ? "s" : ""} required`) { + super(ErrorCode.UrlElicitationRequired, message, { + elicitations + }); + } + get elicitations() { + var _a3, _b2; + return (_b2 = (_a3 = this.data) == null ? void 0 : _a3.elicitations) != null ? _b2 : []; + } +}; + +// node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.js +function isTerminal(status) { + return status === "completed" || status === "failed" || status === "cancelled"; +} + +// node_modules/zod-to-json-schema/dist/esm/parsers/string.js +var ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789"); + +// node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-json-schema-compat.js +function getMethodLiteral(schema) { + const shape = getObjectShape(schema); + const methodSchema = shape == null ? void 0 : shape.method; + if (!methodSchema) { + throw new Error("Schema is missing a method literal"); + } + const value = getLiteralValue(methodSchema); + if (typeof value !== "string") { + throw new Error("Schema method literal must be a string"); + } + return value; +} +function parseWithCompat(schema, data) { + const result = safeParse2(schema, data); + if (!result.success) { + throw result.error; + } + return result.data; +} + +// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.js +var DEFAULT_REQUEST_TIMEOUT_MSEC = 6e4; +var Protocol = class { + constructor(_options) { + this._options = _options; + this._requestMessageId = 0; + this._requestHandlers = /* @__PURE__ */ new Map(); + this._requestHandlerAbortControllers = /* @__PURE__ */ new Map(); + this._notificationHandlers = /* @__PURE__ */ new Map(); + this._responseHandlers = /* @__PURE__ */ new Map(); + this._progressHandlers = /* @__PURE__ */ new Map(); + this._timeoutInfo = /* @__PURE__ */ new Map(); + this._pendingDebouncedNotifications = /* @__PURE__ */ new Set(); + this._taskProgressTokens = /* @__PURE__ */ new Map(); + this._requestResolvers = /* @__PURE__ */ new Map(); + this.setNotificationHandler(CancelledNotificationSchema, (notification) => { + this._oncancel(notification); + }); + this.setNotificationHandler(ProgressNotificationSchema, (notification) => { + this._onprogress(notification); + }); + this.setRequestHandler( + PingRequestSchema, + // Automatic pong by default. + (_request) => ({}) + ); + this._taskStore = _options == null ? void 0 : _options.taskStore; + this._taskMessageQueue = _options == null ? void 0 : _options.taskMessageQueue; + if (this._taskStore) { + this.setRequestHandler(GetTaskRequestSchema, async (request, extra) => { + const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId); + if (!task) { + throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found"); + } + return { + ...task + }; + }); + this.setRequestHandler(GetTaskPayloadRequestSchema, async (request, extra) => { + const handleTaskResult = async () => { + var _a3; + const taskId = request.params.taskId; + if (this._taskMessageQueue) { + let queuedMessage; + while (queuedMessage = await this._taskMessageQueue.dequeue(taskId, extra.sessionId)) { + if (queuedMessage.type === "response" || queuedMessage.type === "error") { + const message = queuedMessage.message; + const requestId = message.id; + const resolver = this._requestResolvers.get(requestId); + if (resolver) { + this._requestResolvers.delete(requestId); + if (queuedMessage.type === "response") { + resolver(message); + } else { + const errorMessage = message; + const error48 = new McpError(errorMessage.error.code, errorMessage.error.message, errorMessage.error.data); + resolver(error48); + } + } else { + const messageType = queuedMessage.type === "response" ? "Response" : "Error"; + this._onerror(new Error(`${messageType} handler missing for request ${requestId}`)); + } + continue; + } + await ((_a3 = this._transport) == null ? void 0 : _a3.send(queuedMessage.message, { relatedRequestId: extra.requestId })); + } + } + const task = await this._taskStore.getTask(taskId, extra.sessionId); + if (!task) { + throw new McpError(ErrorCode.InvalidParams, `Task not found: ${taskId}`); + } + if (!isTerminal(task.status)) { + await this._waitForTaskUpdate(taskId, extra.signal); + return await handleTaskResult(); + } + if (isTerminal(task.status)) { + const result = await this._taskStore.getTaskResult(taskId, extra.sessionId); + this._clearTaskQueue(taskId); + return { + ...result, + _meta: { + ...result._meta, + [RELATED_TASK_META_KEY]: { + taskId + } + } + }; + } + return await handleTaskResult(); + }; + return await handleTaskResult(); + }); + this.setRequestHandler(ListTasksRequestSchema, async (request, extra) => { + var _a3; + try { + const { tasks, nextCursor } = await this._taskStore.listTasks((_a3 = request.params) == null ? void 0 : _a3.cursor, extra.sessionId); + return { + tasks, + nextCursor, + _meta: {} + }; + } catch (error48) { + throw new McpError(ErrorCode.InvalidParams, `Failed to list tasks: ${error48 instanceof Error ? error48.message : String(error48)}`); + } + }); + this.setRequestHandler(CancelTaskRequestSchema, async (request, extra) => { + try { + const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId); + if (!task) { + throw new McpError(ErrorCode.InvalidParams, `Task not found: ${request.params.taskId}`); + } + if (isTerminal(task.status)) { + throw new McpError(ErrorCode.InvalidParams, `Cannot cancel task in terminal status: ${task.status}`); + } + await this._taskStore.updateTaskStatus(request.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId); + this._clearTaskQueue(request.params.taskId); + const cancelledTask = await this._taskStore.getTask(request.params.taskId, extra.sessionId); + if (!cancelledTask) { + throw new McpError(ErrorCode.InvalidParams, `Task not found after cancellation: ${request.params.taskId}`); + } + return { + _meta: {}, + ...cancelledTask + }; + } catch (error48) { + if (error48 instanceof McpError) { + throw error48; + } + throw new McpError(ErrorCode.InvalidRequest, `Failed to cancel task: ${error48 instanceof Error ? error48.message : String(error48)}`); + } + }); + } + } + async _oncancel(notification) { + if (!notification.params.requestId) { + return; + } + const controller = this._requestHandlerAbortControllers.get(notification.params.requestId); + controller == null ? void 0 : controller.abort(notification.params.reason); + } + _setupTimeout(messageId, timeout, maxTotalTimeout, onTimeout, resetTimeoutOnProgress = false) { + this._timeoutInfo.set(messageId, { + timeoutId: setTimeout(onTimeout, timeout), + startTime: Date.now(), + timeout, + maxTotalTimeout, + resetTimeoutOnProgress, + onTimeout + }); + } + _resetTimeout(messageId) { + const info = this._timeoutInfo.get(messageId); + if (!info) + return false; + const totalElapsed = Date.now() - info.startTime; + if (info.maxTotalTimeout && totalElapsed >= info.maxTotalTimeout) { + this._timeoutInfo.delete(messageId); + throw McpError.fromError(ErrorCode.RequestTimeout, "Maximum total timeout exceeded", { + maxTotalTimeout: info.maxTotalTimeout, + totalElapsed + }); + } + clearTimeout(info.timeoutId); + info.timeoutId = setTimeout(info.onTimeout, info.timeout); + return true; + } + _cleanupTimeout(messageId) { + const info = this._timeoutInfo.get(messageId); + if (info) { + clearTimeout(info.timeoutId); + this._timeoutInfo.delete(messageId); + } + } + /** + * Attaches to the given transport, starts it, and starts listening for messages. + * + * The Protocol object assumes ownership of the Transport, replacing any callbacks that have already been set, and expects that it is the only user of the Transport instance going forward. + */ + async connect(transport) { + var _a3, _b2, _c; + if (this._transport) { + throw new Error("Already connected to a transport. Call close() before connecting to a new transport, or use a separate Protocol instance per connection."); + } + this._transport = transport; + const _onclose = (_a3 = this.transport) == null ? void 0 : _a3.onclose; + this._transport.onclose = () => { + _onclose == null ? void 0 : _onclose(); + this._onclose(); + }; + const _onerror = (_b2 = this.transport) == null ? void 0 : _b2.onerror; + this._transport.onerror = (error48) => { + _onerror == null ? void 0 : _onerror(error48); + this._onerror(error48); + }; + const _onmessage = (_c = this._transport) == null ? void 0 : _c.onmessage; + this._transport.onmessage = (message, extra) => { + _onmessage == null ? void 0 : _onmessage(message, extra); + if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) { + this._onresponse(message); + } else if (isJSONRPCRequest(message)) { + this._onrequest(message, extra); + } else if (isJSONRPCNotification(message)) { + this._onnotification(message); + } else { + this._onerror(new Error(`Unknown message type: ${JSON.stringify(message)}`)); + } + }; + await this._transport.start(); + } + _onclose() { + var _a3; + const responseHandlers = this._responseHandlers; + this._responseHandlers = /* @__PURE__ */ new Map(); + this._progressHandlers.clear(); + this._taskProgressTokens.clear(); + this._pendingDebouncedNotifications.clear(); + for (const info of this._timeoutInfo.values()) { + clearTimeout(info.timeoutId); + } + this._timeoutInfo.clear(); + for (const controller of this._requestHandlerAbortControllers.values()) { + controller.abort(); + } + this._requestHandlerAbortControllers.clear(); + const error48 = McpError.fromError(ErrorCode.ConnectionClosed, "Connection closed"); + this._transport = void 0; + (_a3 = this.onclose) == null ? void 0 : _a3.call(this); + for (const handler of responseHandlers.values()) { + handler(error48); + } + } + _onerror(error48) { + var _a3; + (_a3 = this.onerror) == null ? void 0 : _a3.call(this, error48); + } + _onnotification(notification) { + var _a3; + const handler = (_a3 = this._notificationHandlers.get(notification.method)) != null ? _a3 : this.fallbackNotificationHandler; + if (handler === void 0) { + return; + } + Promise.resolve().then(() => handler(notification)).catch((error48) => this._onerror(new Error(`Uncaught error in notification handler: ${error48}`))); + } + _onrequest(request, extra) { + var _a3, _b2, _c, _d, _e; + const handler = (_a3 = this._requestHandlers.get(request.method)) != null ? _a3 : this.fallbackRequestHandler; + const capturedTransport = this._transport; + const relatedTaskId = (_d = (_c = (_b2 = request.params) == null ? void 0 : _b2._meta) == null ? void 0 : _c[RELATED_TASK_META_KEY]) == null ? void 0 : _d.taskId; + if (handler === void 0) { + const errorResponse = { + jsonrpc: "2.0", + id: request.id, + error: { + code: ErrorCode.MethodNotFound, + message: "Method not found" + } + }; + if (relatedTaskId && this._taskMessageQueue) { + this._enqueueTaskMessage(relatedTaskId, { + type: "error", + message: errorResponse, + timestamp: Date.now() + }, capturedTransport == null ? void 0 : capturedTransport.sessionId).catch((error48) => this._onerror(new Error(`Failed to enqueue error response: ${error48}`))); + } else { + capturedTransport == null ? void 0 : capturedTransport.send(errorResponse).catch((error48) => this._onerror(new Error(`Failed to send an error response: ${error48}`))); + } + return; + } + const abortController = new AbortController(); + this._requestHandlerAbortControllers.set(request.id, abortController); + const taskCreationParams = isTaskAugmentedRequestParams(request.params) ? request.params.task : void 0; + const taskStore = this._taskStore ? this.requestTaskStore(request, capturedTransport == null ? void 0 : capturedTransport.sessionId) : void 0; + const fullExtra = { + signal: abortController.signal, + sessionId: capturedTransport == null ? void 0 : capturedTransport.sessionId, + _meta: (_e = request.params) == null ? void 0 : _e._meta, + sendNotification: async (notification) => { + if (abortController.signal.aborted) + return; + const notificationOptions = { relatedRequestId: request.id }; + if (relatedTaskId) { + notificationOptions.relatedTask = { taskId: relatedTaskId }; + } + await this.notification(notification, notificationOptions); + }, + sendRequest: async (r3, resultSchema, options) => { + var _a4, _b3; + if (abortController.signal.aborted) { + throw new McpError(ErrorCode.ConnectionClosed, "Request was cancelled"); + } + const requestOptions = { ...options, relatedRequestId: request.id }; + if (relatedTaskId && !requestOptions.relatedTask) { + requestOptions.relatedTask = { taskId: relatedTaskId }; + } + const effectiveTaskId = (_b3 = (_a4 = requestOptions.relatedTask) == null ? void 0 : _a4.taskId) != null ? _b3 : relatedTaskId; + if (effectiveTaskId && taskStore) { + await taskStore.updateTaskStatus(effectiveTaskId, "input_required"); + } + return await this.request(r3, resultSchema, requestOptions); + }, + authInfo: extra == null ? void 0 : extra.authInfo, + requestId: request.id, + requestInfo: extra == null ? void 0 : extra.requestInfo, + taskId: relatedTaskId, + taskStore, + taskRequestedTtl: taskCreationParams == null ? void 0 : taskCreationParams.ttl, + closeSSEStream: extra == null ? void 0 : extra.closeSSEStream, + closeStandaloneSSEStream: extra == null ? void 0 : extra.closeStandaloneSSEStream + }; + Promise.resolve().then(() => { + if (taskCreationParams) { + this.assertTaskHandlerCapability(request.method); + } + }).then(() => handler(request, fullExtra)).then(async (result) => { + if (abortController.signal.aborted) { + return; + } + const response = { + result, + jsonrpc: "2.0", + id: request.id + }; + if (relatedTaskId && this._taskMessageQueue) { + await this._enqueueTaskMessage(relatedTaskId, { + type: "response", + message: response, + timestamp: Date.now() + }, capturedTransport == null ? void 0 : capturedTransport.sessionId); + } else { + await (capturedTransport == null ? void 0 : capturedTransport.send(response)); + } + }, async (error48) => { + var _a4; + if (abortController.signal.aborted) { + return; + } + const errorResponse = { + jsonrpc: "2.0", + id: request.id, + error: { + code: Number.isSafeInteger(error48["code"]) ? error48["code"] : ErrorCode.InternalError, + message: (_a4 = error48.message) != null ? _a4 : "Internal error", + ...error48["data"] !== void 0 && { data: error48["data"] } + } + }; + if (relatedTaskId && this._taskMessageQueue) { + await this._enqueueTaskMessage(relatedTaskId, { + type: "error", + message: errorResponse, + timestamp: Date.now() + }, capturedTransport == null ? void 0 : capturedTransport.sessionId); + } else { + await (capturedTransport == null ? void 0 : capturedTransport.send(errorResponse)); + } + }).catch((error48) => this._onerror(new Error(`Failed to send response: ${error48}`))).finally(() => { + if (this._requestHandlerAbortControllers.get(request.id) === abortController) { + this._requestHandlerAbortControllers.delete(request.id); + } + }); + } + _onprogress(notification) { + const { progressToken, ...params } = notification.params; + const messageId = Number(progressToken); + const handler = this._progressHandlers.get(messageId); + if (!handler) { + this._onerror(new Error(`Received a progress notification for an unknown token: ${JSON.stringify(notification)}`)); + return; + } + const responseHandler = this._responseHandlers.get(messageId); + const timeoutInfo = this._timeoutInfo.get(messageId); + if (timeoutInfo && responseHandler && timeoutInfo.resetTimeoutOnProgress) { + try { + this._resetTimeout(messageId); + } catch (error48) { + this._responseHandlers.delete(messageId); + this._progressHandlers.delete(messageId); + this._cleanupTimeout(messageId); + responseHandler(error48); + return; + } + } + handler(params); + } + _onresponse(response) { + const messageId = Number(response.id); + const resolver = this._requestResolvers.get(messageId); + if (resolver) { + this._requestResolvers.delete(messageId); + if (isJSONRPCResultResponse(response)) { + resolver(response); + } else { + const error48 = new McpError(response.error.code, response.error.message, response.error.data); + resolver(error48); + } + return; + } + const handler = this._responseHandlers.get(messageId); + if (handler === void 0) { + this._onerror(new Error(`Received a response for an unknown message ID: ${JSON.stringify(response)}`)); + return; + } + this._responseHandlers.delete(messageId); + this._cleanupTimeout(messageId); + let isTaskResponse = false; + if (isJSONRPCResultResponse(response) && response.result && typeof response.result === "object") { + const result = response.result; + if (result.task && typeof result.task === "object") { + const task = result.task; + if (typeof task.taskId === "string") { + isTaskResponse = true; + this._taskProgressTokens.set(task.taskId, messageId); + } + } + } + if (!isTaskResponse) { + this._progressHandlers.delete(messageId); + } + if (isJSONRPCResultResponse(response)) { + handler(response); + } else { + const error48 = McpError.fromError(response.error.code, response.error.message, response.error.data); + handler(error48); + } + } + get transport() { + return this._transport; + } + /** + * Closes the connection. + */ + async close() { + var _a3; + await ((_a3 = this._transport) == null ? void 0 : _a3.close()); + } + /** + * Sends a request and returns an AsyncGenerator that yields response messages. + * The generator is guaranteed to end with either a 'result' or 'error' message. + * + * @example + * ```typescript + * const stream = protocol.requestStream(request, resultSchema, options); + * for await (const message of stream) { + * switch (message.type) { + * case 'taskCreated': + * console.log('Task created:', message.task.taskId); + * break; + * case 'taskStatus': + * console.log('Task status:', message.task.status); + * break; + * case 'result': + * console.log('Final result:', message.result); + * break; + * case 'error': + * console.error('Error:', message.error); + * break; + * } + * } + * ``` + * + * @experimental Use `client.experimental.tasks.requestStream()` to access this method. + */ + async *requestStream(request, resultSchema, options) { + var _a3, _b2, _c, _d; + const { task } = options != null ? options : {}; + if (!task) { + try { + const result = await this.request(request, resultSchema, options); + yield { type: "result", result }; + } catch (error48) { + yield { + type: "error", + error: error48 instanceof McpError ? error48 : new McpError(ErrorCode.InternalError, String(error48)) + }; + } + return; + } + let taskId; + try { + const createResult = await this.request(request, CreateTaskResultSchema, options); + if (createResult.task) { + taskId = createResult.task.taskId; + yield { type: "taskCreated", task: createResult.task }; + } else { + throw new McpError(ErrorCode.InternalError, "Task creation did not return a task"); + } + while (true) { + const task2 = await this.getTask({ taskId }, options); + yield { type: "taskStatus", task: task2 }; + if (isTerminal(task2.status)) { + if (task2.status === "completed") { + const result = await this.getTaskResult({ taskId }, resultSchema, options); + yield { type: "result", result }; + } else if (task2.status === "failed") { + yield { + type: "error", + error: new McpError(ErrorCode.InternalError, `Task ${taskId} failed`) + }; + } else if (task2.status === "cancelled") { + yield { + type: "error", + error: new McpError(ErrorCode.InternalError, `Task ${taskId} was cancelled`) + }; + } + return; + } + if (task2.status === "input_required") { + const result = await this.getTaskResult({ taskId }, resultSchema, options); + yield { type: "result", result }; + return; + } + const pollInterval = (_c = (_b2 = task2.pollInterval) != null ? _b2 : (_a3 = this._options) == null ? void 0 : _a3.defaultTaskPollInterval) != null ? _c : 1e3; + await new Promise((resolve5) => setTimeout(resolve5, pollInterval)); + (_d = options == null ? void 0 : options.signal) == null ? void 0 : _d.throwIfAborted(); + } + } catch (error48) { + yield { + type: "error", + error: error48 instanceof McpError ? error48 : new McpError(ErrorCode.InternalError, String(error48)) + }; + } + } + /** + * Sends a request and waits for a response. + * + * Do not use this method to emit notifications! Use notification() instead. + */ + request(request, resultSchema, options) { + const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options != null ? options : {}; + return new Promise((resolve5, reject) => { + var _a3, _b2, _c, _d, _e, _f, _g; + const earlyReject = (error48) => { + reject(error48); + }; + if (!this._transport) { + earlyReject(new Error("Not connected")); + return; + } + if (((_a3 = this._options) == null ? void 0 : _a3.enforceStrictCapabilities) === true) { + try { + this.assertCapabilityForMethod(request.method); + if (task) { + this.assertTaskCapability(request.method); + } + } catch (e3) { + earlyReject(e3); + return; + } + } + (_b2 = options == null ? void 0 : options.signal) == null ? void 0 : _b2.throwIfAborted(); + const messageId = this._requestMessageId++; + const jsonrpcRequest = { + ...request, + jsonrpc: "2.0", + id: messageId + }; + if (options == null ? void 0 : options.onprogress) { + this._progressHandlers.set(messageId, options.onprogress); + jsonrpcRequest.params = { + ...request.params, + _meta: { + ...((_c = request.params) == null ? void 0 : _c._meta) || {}, + progressToken: messageId + } + }; + } + if (task) { + jsonrpcRequest.params = { + ...jsonrpcRequest.params, + task + }; + } + if (relatedTask) { + jsonrpcRequest.params = { + ...jsonrpcRequest.params, + _meta: { + ...((_d = jsonrpcRequest.params) == null ? void 0 : _d._meta) || {}, + [RELATED_TASK_META_KEY]: relatedTask + } + }; + } + const cancel = (reason) => { + var _a4; + this._responseHandlers.delete(messageId); + this._progressHandlers.delete(messageId); + this._cleanupTimeout(messageId); + (_a4 = this._transport) == null ? void 0 : _a4.send({ + jsonrpc: "2.0", + method: "notifications/cancelled", + params: { + requestId: messageId, + reason: String(reason) + } + }, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error49) => this._onerror(new Error(`Failed to send cancellation: ${error49}`))); + const error48 = reason instanceof McpError ? reason : new McpError(ErrorCode.RequestTimeout, String(reason)); + reject(error48); + }; + this._responseHandlers.set(messageId, (response) => { + var _a4; + if ((_a4 = options == null ? void 0 : options.signal) == null ? void 0 : _a4.aborted) { + return; + } + if (response instanceof Error) { + return reject(response); + } + try { + const parseResult = safeParse2(resultSchema, response.result); + if (!parseResult.success) { + reject(parseResult.error); + } else { + resolve5(parseResult.data); + } + } catch (error48) { + reject(error48); + } + }); + (_e = options == null ? void 0 : options.signal) == null ? void 0 : _e.addEventListener("abort", () => { + var _a4; + cancel((_a4 = options == null ? void 0 : options.signal) == null ? void 0 : _a4.reason); + }); + const timeout = (_f = options == null ? void 0 : options.timeout) != null ? _f : DEFAULT_REQUEST_TIMEOUT_MSEC; + const timeoutHandler = () => cancel(McpError.fromError(ErrorCode.RequestTimeout, "Request timed out", { timeout })); + this._setupTimeout(messageId, timeout, options == null ? void 0 : options.maxTotalTimeout, timeoutHandler, (_g = options == null ? void 0 : options.resetTimeoutOnProgress) != null ? _g : false); + const relatedTaskId = relatedTask == null ? void 0 : relatedTask.taskId; + if (relatedTaskId) { + const responseResolver = (response) => { + const handler = this._responseHandlers.get(messageId); + if (handler) { + handler(response); + } else { + this._onerror(new Error(`Response handler missing for side-channeled request ${messageId}`)); + } + }; + this._requestResolvers.set(messageId, responseResolver); + this._enqueueTaskMessage(relatedTaskId, { + type: "request", + message: jsonrpcRequest, + timestamp: Date.now() + }).catch((error48) => { + this._cleanupTimeout(messageId); + reject(error48); + }); + } else { + this._transport.send(jsonrpcRequest, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error48) => { + this._cleanupTimeout(messageId); + reject(error48); + }); + } + }); + } + /** + * Gets the current status of a task. + * + * @experimental Use `client.experimental.tasks.getTask()` to access this method. + */ + async getTask(params, options) { + return this.request({ method: "tasks/get", params }, GetTaskResultSchema, options); + } + /** + * Retrieves the result of a completed task. + * + * @experimental Use `client.experimental.tasks.getTaskResult()` to access this method. + */ + async getTaskResult(params, resultSchema, options) { + return this.request({ method: "tasks/result", params }, resultSchema, options); + } + /** + * Lists tasks, optionally starting from a pagination cursor. + * + * @experimental Use `client.experimental.tasks.listTasks()` to access this method. + */ + async listTasks(params, options) { + return this.request({ method: "tasks/list", params }, ListTasksResultSchema, options); + } + /** + * Cancels a specific task. + * + * @experimental Use `client.experimental.tasks.cancelTask()` to access this method. + */ + async cancelTask(params, options) { + return this.request({ method: "tasks/cancel", params }, CancelTaskResultSchema, options); + } + /** + * Emits a notification, which is a one-way message that does not expect a response. + */ + async notification(notification, options) { + var _a3, _b2, _c, _d, _e; + if (!this._transport) { + throw new Error("Not connected"); + } + this.assertNotificationCapability(notification.method); + const relatedTaskId = (_a3 = options == null ? void 0 : options.relatedTask) == null ? void 0 : _a3.taskId; + if (relatedTaskId) { + const jsonrpcNotification2 = { + ...notification, + jsonrpc: "2.0", + params: { + ...notification.params, + _meta: { + ...((_b2 = notification.params) == null ? void 0 : _b2._meta) || {}, + [RELATED_TASK_META_KEY]: options.relatedTask + } + } + }; + await this._enqueueTaskMessage(relatedTaskId, { + type: "notification", + message: jsonrpcNotification2, + timestamp: Date.now() + }); + return; + } + const debouncedMethods = (_d = (_c = this._options) == null ? void 0 : _c.debouncedNotificationMethods) != null ? _d : []; + const canDebounce = debouncedMethods.includes(notification.method) && !notification.params && !(options == null ? void 0 : options.relatedRequestId) && !(options == null ? void 0 : options.relatedTask); + if (canDebounce) { + if (this._pendingDebouncedNotifications.has(notification.method)) { + return; + } + this._pendingDebouncedNotifications.add(notification.method); + Promise.resolve().then(() => { + var _a4, _b3; + this._pendingDebouncedNotifications.delete(notification.method); + if (!this._transport) { + return; + } + let jsonrpcNotification2 = { + ...notification, + jsonrpc: "2.0" + }; + if (options == null ? void 0 : options.relatedTask) { + jsonrpcNotification2 = { + ...jsonrpcNotification2, + params: { + ...jsonrpcNotification2.params, + _meta: { + ...((_a4 = jsonrpcNotification2.params) == null ? void 0 : _a4._meta) || {}, + [RELATED_TASK_META_KEY]: options.relatedTask + } + } + }; + } + (_b3 = this._transport) == null ? void 0 : _b3.send(jsonrpcNotification2, options).catch((error48) => this._onerror(error48)); + }); + return; + } + let jsonrpcNotification = { + ...notification, + jsonrpc: "2.0" + }; + if (options == null ? void 0 : options.relatedTask) { + jsonrpcNotification = { + ...jsonrpcNotification, + params: { + ...jsonrpcNotification.params, + _meta: { + ...((_e = jsonrpcNotification.params) == null ? void 0 : _e._meta) || {}, + [RELATED_TASK_META_KEY]: options.relatedTask + } + } + }; + } + await this._transport.send(jsonrpcNotification, options); + } + /** + * Registers a handler to invoke when this protocol object receives a request with the given method. + * + * Note that this will replace any previous request handler for the same method. + */ + setRequestHandler(requestSchema, handler) { + const method = getMethodLiteral(requestSchema); + this.assertRequestHandlerCapability(method); + this._requestHandlers.set(method, (request, extra) => { + const parsed = parseWithCompat(requestSchema, request); + return Promise.resolve(handler(parsed, extra)); + }); + } + /** + * Removes the request handler for the given method. + */ + removeRequestHandler(method) { + this._requestHandlers.delete(method); + } + /** + * Asserts that a request handler has not already been set for the given method, in preparation for a new one being automatically installed. + */ + assertCanSetRequestHandler(method) { + if (this._requestHandlers.has(method)) { + throw new Error(`A request handler for ${method} already exists, which would be overridden`); + } + } + /** + * Registers a handler to invoke when this protocol object receives a notification with the given method. + * + * Note that this will replace any previous notification handler for the same method. + */ + setNotificationHandler(notificationSchema, handler) { + const method = getMethodLiteral(notificationSchema); + this._notificationHandlers.set(method, (notification) => { + const parsed = parseWithCompat(notificationSchema, notification); + return Promise.resolve(handler(parsed)); + }); + } + /** + * Removes the notification handler for the given method. + */ + removeNotificationHandler(method) { + this._notificationHandlers.delete(method); + } + /** + * Cleans up the progress handler associated with a task. + * This should be called when a task reaches a terminal status. + */ + _cleanupTaskProgressHandler(taskId) { + const progressToken = this._taskProgressTokens.get(taskId); + if (progressToken !== void 0) { + this._progressHandlers.delete(progressToken); + this._taskProgressTokens.delete(taskId); + } + } + /** + * Enqueues a task-related message for side-channel delivery via tasks/result. + * @param taskId The task ID to associate the message with + * @param message The message to enqueue + * @param sessionId Optional session ID for binding the operation to a specific session + * @throws Error if taskStore is not configured or if enqueue fails (e.g., queue overflow) + * + * Note: If enqueue fails, it's the TaskMessageQueue implementation's responsibility to handle + * the error appropriately (e.g., by failing the task, logging, etc.). The Protocol layer + * simply propagates the error. + */ + async _enqueueTaskMessage(taskId, message, sessionId) { + var _a3; + if (!this._taskStore || !this._taskMessageQueue) { + throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured"); + } + const maxQueueSize = (_a3 = this._options) == null ? void 0 : _a3.maxTaskQueueSize; + await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize); + } + /** + * Clears the message queue for a task and rejects any pending request resolvers. + * @param taskId The task ID whose queue should be cleared + * @param sessionId Optional session ID for binding the operation to a specific session + */ + async _clearTaskQueue(taskId, sessionId) { + if (this._taskMessageQueue) { + const messages = await this._taskMessageQueue.dequeueAll(taskId, sessionId); + for (const message of messages) { + if (message.type === "request" && isJSONRPCRequest(message.message)) { + const requestId = message.message.id; + const resolver = this._requestResolvers.get(requestId); + if (resolver) { + resolver(new McpError(ErrorCode.InternalError, "Task cancelled or completed")); + this._requestResolvers.delete(requestId); + } else { + this._onerror(new Error(`Resolver missing for request ${requestId} during task ${taskId} cleanup`)); + } + } + } + } + } + /** + * Waits for a task update (new messages or status change) with abort signal support. + * Uses polling to check for updates at the task's configured poll interval. + * @param taskId The task ID to wait for + * @param signal Abort signal to cancel the wait + * @returns Promise that resolves when an update occurs or rejects if aborted + */ + async _waitForTaskUpdate(taskId, signal) { + var _a3, _b2, _c; + let interval = (_b2 = (_a3 = this._options) == null ? void 0 : _a3.defaultTaskPollInterval) != null ? _b2 : 1e3; + try { + const task = await ((_c = this._taskStore) == null ? void 0 : _c.getTask(taskId)); + if (task == null ? void 0 : task.pollInterval) { + interval = task.pollInterval; + } + } catch (e3) { + } + return new Promise((resolve5, reject) => { + if (signal.aborted) { + reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled")); + return; + } + const timeoutId = setTimeout(resolve5, interval); + signal.addEventListener("abort", () => { + clearTimeout(timeoutId); + reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled")); + }, { once: true }); + }); + } + requestTaskStore(request, sessionId) { + const taskStore = this._taskStore; + if (!taskStore) { + throw new Error("No task store configured"); + } + return { + createTask: async (taskParams) => { + if (!request) { + throw new Error("No request provided"); + } + return await taskStore.createTask(taskParams, request.id, { + method: request.method, + params: request.params + }, sessionId); + }, + getTask: async (taskId) => { + const task = await taskStore.getTask(taskId, sessionId); + if (!task) { + throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found"); + } + return task; + }, + storeTaskResult: async (taskId, status, result) => { + await taskStore.storeTaskResult(taskId, status, result, sessionId); + const task = await taskStore.getTask(taskId, sessionId); + if (task) { + const notification = TaskStatusNotificationSchema.parse({ + method: "notifications/tasks/status", + params: task + }); + await this.notification(notification); + if (isTerminal(task.status)) { + this._cleanupTaskProgressHandler(taskId); + } + } + }, + getTaskResult: (taskId) => { + return taskStore.getTaskResult(taskId, sessionId); + }, + updateTaskStatus: async (taskId, status, statusMessage) => { + const task = await taskStore.getTask(taskId, sessionId); + if (!task) { + throw new McpError(ErrorCode.InvalidParams, `Task "${taskId}" not found - it may have been cleaned up`); + } + if (isTerminal(task.status)) { + throw new McpError(ErrorCode.InvalidParams, `Cannot update task "${taskId}" from terminal status "${task.status}" to "${status}". Terminal states (completed, failed, cancelled) cannot transition to other states.`); + } + await taskStore.updateTaskStatus(taskId, status, statusMessage, sessionId); + const updatedTask = await taskStore.getTask(taskId, sessionId); + if (updatedTask) { + const notification = TaskStatusNotificationSchema.parse({ + method: "notifications/tasks/status", + params: updatedTask + }); + await this.notification(notification); + if (isTerminal(updatedTask.status)) { + this._cleanupTaskProgressHandler(taskId); + } + } + }, + listTasks: (cursor) => { + return taskStore.listTasks(cursor, sessionId); + } + }; + } +}; +function isPlainObject2(value) { + return value !== null && typeof value === "object" && !Array.isArray(value); +} +function mergeCapabilities(base, additional) { + const result = { ...base }; + for (const key in additional) { + const k3 = key; + const addValue = additional[k3]; + if (addValue === void 0) + continue; + const baseValue = result[k3]; + if (isPlainObject2(baseValue) && isPlainObject2(addValue)) { + result[k3] = { ...baseValue, ...addValue }; + } else { + result[k3] = addValue; + } + } + return result; +} + +// node_modules/@modelcontextprotocol/sdk/dist/esm/validation/ajv-provider.js +var import_ajv = __toESM(require_ajv(), 1); +var import_ajv_formats = __toESM(require_dist(), 1); +function createDefaultAjvInstance() { + const ajv = new import_ajv.default({ + strict: false, + validateFormats: true, + validateSchema: false, + allErrors: true + }); + const addFormats = import_ajv_formats.default; + addFormats(ajv); + return ajv; +} +var AjvJsonSchemaValidator = class { + /** + * Create an AJV validator + * + * @param ajv - Optional pre-configured AJV instance. If not provided, a default instance will be created. + * + * @example + * ```typescript + * // Use default configuration (recommended for most cases) + * import { AjvJsonSchemaValidator } from '@modelcontextprotocol/sdk/validation/ajv'; + * const validator = new AjvJsonSchemaValidator(); + * + * // Or provide custom AJV instance for advanced configuration + * import { Ajv } from 'ajv'; + * import addFormats from 'ajv-formats'; + * + * const ajv = new Ajv({ validateFormats: true }); + * addFormats(ajv); + * const validator = new AjvJsonSchemaValidator(ajv); + * ``` + */ + constructor(ajv) { + this._ajv = ajv != null ? ajv : createDefaultAjvInstance(); + } + /** + * Create a validator for the given JSON Schema + * + * The validator is compiled once and can be reused multiple times. + * If the schema has an $id, it will be cached by AJV automatically. + * + * @param schema - Standard JSON Schema object + * @returns A validator function that validates input data + */ + getValidator(schema) { + var _a3; + const ajvValidator = "$id" in schema && typeof schema.$id === "string" ? (_a3 = this._ajv.getSchema(schema.$id)) != null ? _a3 : this._ajv.compile(schema) : this._ajv.compile(schema); + return (input) => { + const valid = ajvValidator(input); + if (valid) { + return { + valid: true, + data: input, + errorMessage: void 0 + }; + } else { + return { + valid: false, + data: void 0, + errorMessage: this._ajv.errorsText(ajvValidator.errors) + }; + } + }; + } +}; + +// node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/client.js +var ExperimentalClientTasks = class { + constructor(_client) { + this._client = _client; + } + /** + * Calls a tool and returns an AsyncGenerator that yields response messages. + * The generator is guaranteed to end with either a 'result' or 'error' message. + * + * This method provides streaming access to tool execution, allowing you to + * observe intermediate task status updates for long-running tool calls. + * Automatically validates structured output if the tool has an outputSchema. + * + * @example + * ```typescript + * const stream = client.experimental.tasks.callToolStream({ name: 'myTool', arguments: {} }); + * for await (const message of stream) { + * switch (message.type) { + * case 'taskCreated': + * console.log('Tool execution started:', message.task.taskId); + * break; + * case 'taskStatus': + * console.log('Tool status:', message.task.status); + * break; + * case 'result': + * console.log('Tool result:', message.result); + * break; + * case 'error': + * console.error('Tool error:', message.error); + * break; + * } + * } + * ``` + * + * @param params - Tool call parameters (name and arguments) + * @param resultSchema - Zod schema for validating the result (defaults to CallToolResultSchema) + * @param options - Optional request options (timeout, signal, task creation params, etc.) + * @returns AsyncGenerator that yields ResponseMessage objects + * + * @experimental + */ + async *callToolStream(params, resultSchema = CallToolResultSchema, options) { + var _a3; + const clientInternal = this._client; + const optionsWithTask = { + ...options, + // We check if the tool is known to be a task during auto-configuration, but assume + // the caller knows what they're doing if they pass this explicitly + task: (_a3 = options == null ? void 0 : options.task) != null ? _a3 : clientInternal.isToolTask(params.name) ? {} : void 0 + }; + const stream = clientInternal.requestStream({ method: "tools/call", params }, resultSchema, optionsWithTask); + const validator = clientInternal.getToolOutputValidator(params.name); + for await (const message of stream) { + if (message.type === "result" && validator) { + const result = message.result; + if (!result.structuredContent && !result.isError) { + yield { + type: "error", + error: new McpError(ErrorCode.InvalidRequest, `Tool ${params.name} has an output schema but did not return structured content`) + }; + return; + } + if (result.structuredContent) { + try { + const validationResult = validator(result.structuredContent); + if (!validationResult.valid) { + yield { + type: "error", + error: new McpError(ErrorCode.InvalidParams, `Structured content does not match the tool's output schema: ${validationResult.errorMessage}`) + }; + return; + } + } catch (error48) { + if (error48 instanceof McpError) { + yield { type: "error", error: error48 }; + return; + } + yield { + type: "error", + error: new McpError(ErrorCode.InvalidParams, `Failed to validate structured content: ${error48 instanceof Error ? error48.message : String(error48)}`) + }; + return; + } + } + } + yield message; + } + } + /** + * Gets the current status of a task. + * + * @param taskId - The task identifier + * @param options - Optional request options + * @returns The task status + * + * @experimental + */ + async getTask(taskId, options) { + return this._client.getTask({ taskId }, options); + } + /** + * Retrieves the result of a completed task. + * + * @param taskId - The task identifier + * @param resultSchema - Zod schema for validating the result + * @param options - Optional request options + * @returns The task result + * + * @experimental + */ + async getTaskResult(taskId, resultSchema, options) { + return this._client.getTaskResult({ taskId }, resultSchema, options); + } + /** + * Lists tasks with optional pagination. + * + * @param cursor - Optional pagination cursor + * @param options - Optional request options + * @returns List of tasks with optional next cursor + * + * @experimental + */ + async listTasks(cursor, options) { + return this._client.listTasks(cursor ? { cursor } : void 0, options); + } + /** + * Cancels a running task. + * + * @param taskId - The task identifier + * @param options - Optional request options + * + * @experimental + */ + async cancelTask(taskId, options) { + return this._client.cancelTask({ taskId }, options); + } + /** + * Sends a request and returns an AsyncGenerator that yields response messages. + * The generator is guaranteed to end with either a 'result' or 'error' message. + * + * This method provides streaming access to request processing, allowing you to + * observe intermediate task status updates for task-augmented requests. + * + * @param request - The request to send + * @param resultSchema - Zod schema for validating the result + * @param options - Optional request options (timeout, signal, task creation params, etc.) + * @returns AsyncGenerator that yields ResponseMessage objects + * + * @experimental + */ + requestStream(request, resultSchema, options) { + return this._client.requestStream(request, resultSchema, options); + } +}; + +// node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js +function assertToolsCallTaskCapability(requests, method, entityName) { + var _a3; + if (!requests) { + throw new Error(`${entityName} does not support task creation (required for ${method})`); + } + switch (method) { + case "tools/call": + if (!((_a3 = requests.tools) == null ? void 0 : _a3.call)) { + throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`); + } + break; + default: + break; + } +} +function assertClientRequestTaskCapability(requests, method, entityName) { + var _a3, _b2; + if (!requests) { + throw new Error(`${entityName} does not support task creation (required for ${method})`); + } + switch (method) { + case "sampling/createMessage": + if (!((_a3 = requests.sampling) == null ? void 0 : _a3.createMessage)) { + throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`); + } + break; + case "elicitation/create": + if (!((_b2 = requests.elicitation) == null ? void 0 : _b2.create)) { + throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`); + } + break; + default: + break; + } +} + +// node_modules/@modelcontextprotocol/sdk/dist/esm/client/index.js +function applyElicitationDefaults(schema, data) { + if (!schema || data === null || typeof data !== "object") + return; + if (schema.type === "object" && schema.properties && typeof schema.properties === "object") { + const obj = data; + const props = schema.properties; + for (const key of Object.keys(props)) { + const propSchema = props[key]; + if (obj[key] === void 0 && Object.prototype.hasOwnProperty.call(propSchema, "default")) { + obj[key] = propSchema.default; + } + if (obj[key] !== void 0) { + applyElicitationDefaults(propSchema, obj[key]); + } + } + } + if (Array.isArray(schema.anyOf)) { + for (const sub of schema.anyOf) { + if (typeof sub !== "boolean") { + applyElicitationDefaults(sub, data); + } + } + } + if (Array.isArray(schema.oneOf)) { + for (const sub of schema.oneOf) { + if (typeof sub !== "boolean") { + applyElicitationDefaults(sub, data); + } + } + } +} +function getSupportedElicitationModes(capabilities) { + if (!capabilities) { + return { supportsFormMode: false, supportsUrlMode: false }; + } + const hasFormCapability = capabilities.form !== void 0; + const hasUrlCapability = capabilities.url !== void 0; + const supportsFormMode = hasFormCapability || !hasFormCapability && !hasUrlCapability; + const supportsUrlMode = hasUrlCapability; + return { supportsFormMode, supportsUrlMode }; +} +var Client = class extends Protocol { + /** + * Initializes this client with the given name and version information. + */ + constructor(_clientInfo, options) { + var _a3, _b2; + super(options); + this._clientInfo = _clientInfo; + this._cachedToolOutputValidators = /* @__PURE__ */ new Map(); + this._cachedKnownTaskTools = /* @__PURE__ */ new Set(); + this._cachedRequiredTaskTools = /* @__PURE__ */ new Set(); + this._listChangedDebounceTimers = /* @__PURE__ */ new Map(); + this._capabilities = (_a3 = options == null ? void 0 : options.capabilities) != null ? _a3 : {}; + this._jsonSchemaValidator = (_b2 = options == null ? void 0 : options.jsonSchemaValidator) != null ? _b2 : new AjvJsonSchemaValidator(); + if (options == null ? void 0 : options.listChanged) { + this._pendingListChangedConfig = options.listChanged; + } + } + /** + * Set up handlers for list changed notifications based on config and server capabilities. + * This should only be called after initialization when server capabilities are known. + * Handlers are silently skipped if the server doesn't advertise the corresponding listChanged capability. + * @internal + */ + _setupListChangedHandlers(config2) { + var _a3, _b2, _c, _d, _e, _f; + if (config2.tools && ((_b2 = (_a3 = this._serverCapabilities) == null ? void 0 : _a3.tools) == null ? void 0 : _b2.listChanged)) { + this._setupListChangedHandler("tools", ToolListChangedNotificationSchema, config2.tools, async () => { + const result = await this.listTools(); + return result.tools; + }); + } + if (config2.prompts && ((_d = (_c = this._serverCapabilities) == null ? void 0 : _c.prompts) == null ? void 0 : _d.listChanged)) { + this._setupListChangedHandler("prompts", PromptListChangedNotificationSchema, config2.prompts, async () => { + const result = await this.listPrompts(); + return result.prompts; + }); + } + if (config2.resources && ((_f = (_e = this._serverCapabilities) == null ? void 0 : _e.resources) == null ? void 0 : _f.listChanged)) { + this._setupListChangedHandler("resources", ResourceListChangedNotificationSchema, config2.resources, async () => { + const result = await this.listResources(); + return result.resources; + }); + } + } + /** + * Access experimental features. + * + * WARNING: These APIs are experimental and may change without notice. + * + * @experimental + */ + get experimental() { + if (!this._experimental) { + this._experimental = { + tasks: new ExperimentalClientTasks(this) + }; + } + return this._experimental; + } + /** + * Registers new capabilities. This can only be called before connecting to a transport. + * + * The new capabilities will be merged with any existing capabilities previously given (e.g., at initialization). + */ + registerCapabilities(capabilities) { + if (this.transport) { + throw new Error("Cannot register capabilities after connecting to transport"); + } + this._capabilities = mergeCapabilities(this._capabilities, capabilities); + } + /** + * Override request handler registration to enforce client-side validation for elicitation. + */ + setRequestHandler(requestSchema, handler) { + var _a3, _b2, _c; + const shape = getObjectShape(requestSchema); + const methodSchema = shape == null ? void 0 : shape.method; + if (!methodSchema) { + throw new Error("Schema is missing a method literal"); + } + let methodValue; + if (isZ4Schema(methodSchema)) { + const v4Schema = methodSchema; + const v4Def = (_a3 = v4Schema._zod) == null ? void 0 : _a3.def; + methodValue = (_b2 = v4Def == null ? void 0 : v4Def.value) != null ? _b2 : v4Schema.value; + } else { + const v3Schema = methodSchema; + const legacyDef = v3Schema._def; + methodValue = (_c = legacyDef == null ? void 0 : legacyDef.value) != null ? _c : v3Schema.value; + } + if (typeof methodValue !== "string") { + throw new Error("Schema method literal must be a string"); + } + const method = methodValue; + if (method === "elicitation/create") { + const wrappedHandler = async (request, extra) => { + var _a4, _b3, _c2; + const validatedRequest = safeParse2(ElicitRequestSchema, request); + if (!validatedRequest.success) { + const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error); + throw new McpError(ErrorCode.InvalidParams, `Invalid elicitation request: ${errorMessage}`); + } + const { params } = validatedRequest.data; + params.mode = (_a4 = params.mode) != null ? _a4 : "form"; + const { supportsFormMode, supportsUrlMode } = getSupportedElicitationModes(this._capabilities.elicitation); + if (params.mode === "form" && !supportsFormMode) { + throw new McpError(ErrorCode.InvalidParams, "Client does not support form-mode elicitation requests"); + } + if (params.mode === "url" && !supportsUrlMode) { + throw new McpError(ErrorCode.InvalidParams, "Client does not support URL-mode elicitation requests"); + } + const result = await Promise.resolve(handler(request, extra)); + if (params.task) { + const taskValidationResult = safeParse2(CreateTaskResultSchema, result); + if (!taskValidationResult.success) { + const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error); + throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`); + } + return taskValidationResult.data; + } + const validationResult = safeParse2(ElicitResultSchema, result); + if (!validationResult.success) { + const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error); + throw new McpError(ErrorCode.InvalidParams, `Invalid elicitation result: ${errorMessage}`); + } + const validatedResult = validationResult.data; + const requestedSchema = params.mode === "form" ? params.requestedSchema : void 0; + if (params.mode === "form" && validatedResult.action === "accept" && validatedResult.content && requestedSchema) { + if ((_c2 = (_b3 = this._capabilities.elicitation) == null ? void 0 : _b3.form) == null ? void 0 : _c2.applyDefaults) { + try { + applyElicitationDefaults(requestedSchema, validatedResult.content); + } catch (e3) { + } + } + } + return validatedResult; + }; + return super.setRequestHandler(requestSchema, wrappedHandler); + } + if (method === "sampling/createMessage") { + const wrappedHandler = async (request, extra) => { + const validatedRequest = safeParse2(CreateMessageRequestSchema, request); + if (!validatedRequest.success) { + const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error); + throw new McpError(ErrorCode.InvalidParams, `Invalid sampling request: ${errorMessage}`); + } + const { params } = validatedRequest.data; + const result = await Promise.resolve(handler(request, extra)); + if (params.task) { + const taskValidationResult = safeParse2(CreateTaskResultSchema, result); + if (!taskValidationResult.success) { + const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error); + throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`); + } + return taskValidationResult.data; + } + const hasTools = params.tools || params.toolChoice; + const resultSchema = hasTools ? CreateMessageResultWithToolsSchema : CreateMessageResultSchema; + const validationResult = safeParse2(resultSchema, result); + if (!validationResult.success) { + const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error); + throw new McpError(ErrorCode.InvalidParams, `Invalid sampling result: ${errorMessage}`); + } + return validationResult.data; + }; + return super.setRequestHandler(requestSchema, wrappedHandler); + } + return super.setRequestHandler(requestSchema, handler); + } + assertCapability(capability, method) { + var _a3; + if (!((_a3 = this._serverCapabilities) == null ? void 0 : _a3[capability])) { + throw new Error(`Server does not support ${capability} (required for ${method})`); + } + } + async connect(transport, options) { + await super.connect(transport); + if (transport.sessionId !== void 0) { + return; + } + try { + const result = await this.request({ + method: "initialize", + params: { + protocolVersion: LATEST_PROTOCOL_VERSION, + capabilities: this._capabilities, + clientInfo: this._clientInfo + } + }, InitializeResultSchema, options); + if (result === void 0) { + throw new Error(`Server sent invalid initialize result: ${result}`); + } + if (!SUPPORTED_PROTOCOL_VERSIONS.includes(result.protocolVersion)) { + throw new Error(`Server's protocol version is not supported: ${result.protocolVersion}`); + } + this._serverCapabilities = result.capabilities; + this._serverVersion = result.serverInfo; + if (transport.setProtocolVersion) { + transport.setProtocolVersion(result.protocolVersion); + } + this._instructions = result.instructions; + await this.notification({ + method: "notifications/initialized" + }); + if (this._pendingListChangedConfig) { + this._setupListChangedHandlers(this._pendingListChangedConfig); + this._pendingListChangedConfig = void 0; + } + } catch (error48) { + void this.close(); + throw error48; + } + } + /** + * After initialization has completed, this will be populated with the server's reported capabilities. + */ + getServerCapabilities() { + return this._serverCapabilities; + } + /** + * After initialization has completed, this will be populated with information about the server's name and version. + */ + getServerVersion() { + return this._serverVersion; + } + /** + * After initialization has completed, this may be populated with information about the server's instructions. + */ + getInstructions() { + return this._instructions; + } + assertCapabilityForMethod(method) { + var _a3, _b2, _c, _d, _e; + switch (method) { + case "logging/setLevel": + if (!((_a3 = this._serverCapabilities) == null ? void 0 : _a3.logging)) { + throw new Error(`Server does not support logging (required for ${method})`); + } + break; + case "prompts/get": + case "prompts/list": + if (!((_b2 = this._serverCapabilities) == null ? void 0 : _b2.prompts)) { + throw new Error(`Server does not support prompts (required for ${method})`); + } + break; + case "resources/list": + case "resources/templates/list": + case "resources/read": + case "resources/subscribe": + case "resources/unsubscribe": + if (!((_c = this._serverCapabilities) == null ? void 0 : _c.resources)) { + throw new Error(`Server does not support resources (required for ${method})`); + } + if (method === "resources/subscribe" && !this._serverCapabilities.resources.subscribe) { + throw new Error(`Server does not support resource subscriptions (required for ${method})`); + } + break; + case "tools/call": + case "tools/list": + if (!((_d = this._serverCapabilities) == null ? void 0 : _d.tools)) { + throw new Error(`Server does not support tools (required for ${method})`); + } + break; + case "completion/complete": + if (!((_e = this._serverCapabilities) == null ? void 0 : _e.completions)) { + throw new Error(`Server does not support completions (required for ${method})`); + } + break; + case "initialize": + break; + case "ping": + break; + } + } + assertNotificationCapability(method) { + var _a3; + switch (method) { + case "notifications/roots/list_changed": + if (!((_a3 = this._capabilities.roots) == null ? void 0 : _a3.listChanged)) { + throw new Error(`Client does not support roots list changed notifications (required for ${method})`); + } + break; + case "notifications/initialized": + break; + case "notifications/cancelled": + break; + case "notifications/progress": + break; + } + } + assertRequestHandlerCapability(method) { + if (!this._capabilities) { + return; + } + switch (method) { + case "sampling/createMessage": + if (!this._capabilities.sampling) { + throw new Error(`Client does not support sampling capability (required for ${method})`); + } + break; + case "elicitation/create": + if (!this._capabilities.elicitation) { + throw new Error(`Client does not support elicitation capability (required for ${method})`); + } + break; + case "roots/list": + if (!this._capabilities.roots) { + throw new Error(`Client does not support roots capability (required for ${method})`); + } + break; + case "tasks/get": + case "tasks/list": + case "tasks/result": + case "tasks/cancel": + if (!this._capabilities.tasks) { + throw new Error(`Client does not support tasks capability (required for ${method})`); + } + break; + case "ping": + break; + } + } + assertTaskCapability(method) { + var _a3, _b2; + assertToolsCallTaskCapability((_b2 = (_a3 = this._serverCapabilities) == null ? void 0 : _a3.tasks) == null ? void 0 : _b2.requests, method, "Server"); + } + assertTaskHandlerCapability(method) { + var _a3; + if (!this._capabilities) { + return; + } + assertClientRequestTaskCapability((_a3 = this._capabilities.tasks) == null ? void 0 : _a3.requests, method, "Client"); + } + async ping(options) { + return this.request({ method: "ping" }, EmptyResultSchema, options); + } + async complete(params, options) { + return this.request({ method: "completion/complete", params }, CompleteResultSchema, options); + } + async setLoggingLevel(level, options) { + return this.request({ method: "logging/setLevel", params: { level } }, EmptyResultSchema, options); + } + async getPrompt(params, options) { + return this.request({ method: "prompts/get", params }, GetPromptResultSchema, options); + } + async listPrompts(params, options) { + return this.request({ method: "prompts/list", params }, ListPromptsResultSchema, options); + } + async listResources(params, options) { + return this.request({ method: "resources/list", params }, ListResourcesResultSchema, options); + } + async listResourceTemplates(params, options) { + return this.request({ method: "resources/templates/list", params }, ListResourceTemplatesResultSchema, options); + } + async readResource(params, options) { + return this.request({ method: "resources/read", params }, ReadResourceResultSchema, options); + } + async subscribeResource(params, options) { + return this.request({ method: "resources/subscribe", params }, EmptyResultSchema, options); + } + async unsubscribeResource(params, options) { + return this.request({ method: "resources/unsubscribe", params }, EmptyResultSchema, options); + } + /** + * Calls a tool and waits for the result. Automatically validates structured output if the tool has an outputSchema. + * + * For task-based execution with streaming behavior, use client.experimental.tasks.callToolStream() instead. + */ + async callTool(params, resultSchema = CallToolResultSchema, options) { + if (this.isToolTaskRequired(params.name)) { + throw new McpError(ErrorCode.InvalidRequest, `Tool "${params.name}" requires task-based execution. Use client.experimental.tasks.callToolStream() instead.`); + } + const result = await this.request({ method: "tools/call", params }, resultSchema, options); + const validator = this.getToolOutputValidator(params.name); + if (validator) { + if (!result.structuredContent && !result.isError) { + throw new McpError(ErrorCode.InvalidRequest, `Tool ${params.name} has an output schema but did not return structured content`); + } + if (result.structuredContent) { + try { + const validationResult = validator(result.structuredContent); + if (!validationResult.valid) { + throw new McpError(ErrorCode.InvalidParams, `Structured content does not match the tool's output schema: ${validationResult.errorMessage}`); + } + } catch (error48) { + if (error48 instanceof McpError) { + throw error48; + } + throw new McpError(ErrorCode.InvalidParams, `Failed to validate structured content: ${error48 instanceof Error ? error48.message : String(error48)}`); + } + } + } + return result; + } + isToolTask(toolName) { + var _a3, _b2, _c, _d; + if (!((_d = (_c = (_b2 = (_a3 = this._serverCapabilities) == null ? void 0 : _a3.tasks) == null ? void 0 : _b2.requests) == null ? void 0 : _c.tools) == null ? void 0 : _d.call)) { + return false; + } + return this._cachedKnownTaskTools.has(toolName); + } + /** + * Check if a tool requires task-based execution. + * Unlike isToolTask which includes 'optional' tools, this only checks for 'required'. + */ + isToolTaskRequired(toolName) { + return this._cachedRequiredTaskTools.has(toolName); + } + /** + * Cache validators for tool output schemas. + * Called after listTools() to pre-compile validators for better performance. + */ + cacheToolMetadata(tools) { + var _a3; + this._cachedToolOutputValidators.clear(); + this._cachedKnownTaskTools.clear(); + this._cachedRequiredTaskTools.clear(); + for (const tool of tools) { + if (tool.outputSchema) { + const toolValidator = this._jsonSchemaValidator.getValidator(tool.outputSchema); + this._cachedToolOutputValidators.set(tool.name, toolValidator); + } + const taskSupport = (_a3 = tool.execution) == null ? void 0 : _a3.taskSupport; + if (taskSupport === "required" || taskSupport === "optional") { + this._cachedKnownTaskTools.add(tool.name); + } + if (taskSupport === "required") { + this._cachedRequiredTaskTools.add(tool.name); + } + } + } + /** + * Get cached validator for a tool + */ + getToolOutputValidator(toolName) { + return this._cachedToolOutputValidators.get(toolName); + } + async listTools(params, options) { + const result = await this.request({ method: "tools/list", params }, ListToolsResultSchema, options); + this.cacheToolMetadata(result.tools); + return result; + } + /** + * Set up a single list changed handler. + * @internal + */ + _setupListChangedHandler(listType, notificationSchema, options, fetcher) { + const parseResult = ListChangedOptionsBaseSchema.safeParse(options); + if (!parseResult.success) { + throw new Error(`Invalid ${listType} listChanged options: ${parseResult.error.message}`); + } + if (typeof options.onChanged !== "function") { + throw new Error(`Invalid ${listType} listChanged options: onChanged must be a function`); + } + const { autoRefresh, debounceMs } = parseResult.data; + const { onChanged } = options; + const refresh = async () => { + if (!autoRefresh) { + onChanged(null, null); + return; + } + try { + const items = await fetcher(); + onChanged(null, items); + } catch (e3) { + const error48 = e3 instanceof Error ? e3 : new Error(String(e3)); + onChanged(error48, null); + } + }; + const handler = () => { + if (debounceMs) { + const existingTimer = this._listChangedDebounceTimers.get(listType); + if (existingTimer) { + clearTimeout(existingTimer); + } + const timer = setTimeout(refresh, debounceMs); + this._listChangedDebounceTimers.set(listType, timer); + } else { + refresh(); + } + }; + this.setNotificationHandler(notificationSchema, handler); + } + async sendRootsListChanged() { + return this.notification({ method: "notifications/roots/list_changed" }); + } +}; + +// node_modules/eventsource-parser/dist/index.js +var ParseError = class extends Error { + constructor(message, options) { + super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line; + } +}; +function noop(_arg) { +} +function createParser(callbacks) { + if (typeof callbacks == "function") + throw new TypeError( + "`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?" + ); + const { onEvent = noop, onError = noop, onRetry = noop, onComment } = callbacks; + let incompleteLine = "", isFirstChunk = true, id, data = "", eventType = ""; + function feed(newChunk) { + const chunk = isFirstChunk ? newChunk.replace(/^\xEF\xBB\xBF/, "") : newChunk, [complete, incomplete] = splitLines(`${incompleteLine}${chunk}`); + for (const line of complete) + parseLine(line); + incompleteLine = incomplete, isFirstChunk = false; + } + function parseLine(line) { + if (line === "") { + dispatchEvent(); + return; + } + if (line.startsWith(":")) { + onComment && onComment(line.slice(line.startsWith(": ") ? 2 : 1)); + return; + } + const fieldSeparatorIndex = line.indexOf(":"); + if (fieldSeparatorIndex !== -1) { + const field = line.slice(0, fieldSeparatorIndex), offset = line[fieldSeparatorIndex + 1] === " " ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset); + processField(field, value, line); + return; + } + processField(line, "", line); + } + function processField(field, value, line) { + switch (field) { + case "event": + eventType = value; + break; + case "data": + data = `${data}${value} +`; + break; + case "id": + id = value.includes("\0") ? void 0 : value; + break; + case "retry": + /^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError( + new ParseError(`Invalid \`retry\` value: "${value}"`, { + type: "invalid-retry", + value, + line + }) + ); + break; + default: + onError( + new ParseError( + `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`, + { type: "unknown-field", field, value, line } + ) + ); + break; + } + } + function dispatchEvent() { + data.length > 0 && onEvent({ + id, + event: eventType || void 0, + // If the data buffer's last character is a U+000A LINE FEED (LF) character, + // then remove the last character from the data buffer. + data: data.endsWith(` +`) ? data.slice(0, -1) : data + }), id = void 0, data = "", eventType = ""; + } + function reset(options = {}) { + incompleteLine && options.consume && parseLine(incompleteLine), isFirstChunk = true, id = void 0, data = "", eventType = "", incompleteLine = ""; + } + return { feed, reset }; +} +function splitLines(chunk) { + const lines = []; + let incompleteLine = "", searchIndex = 0; + for (; searchIndex < chunk.length; ) { + const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(` +`, searchIndex); + let lineEnd = -1; + if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = Math.min(crIndex, lfIndex) : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) { + incompleteLine = chunk.slice(searchIndex); + break; + } else { + const line = chunk.slice(searchIndex, lineEnd); + lines.push(line), searchIndex = lineEnd + 1, chunk[searchIndex - 1] === "\r" && chunk[searchIndex] === ` +` && searchIndex++; + } + } + return [lines, incompleteLine]; +} + +// node_modules/eventsource/dist/index.js +var ErrorEvent = class extends Event { + /** + * Constructs a new `ErrorEvent` instance. This is typically not called directly, + * but rather emitted by the `EventSource` object when an error occurs. + * + * @param type - The type of the event (should be "error") + * @param errorEventInitDict - Optional properties to include in the error event + */ + constructor(type, errorEventInitDict) { + var _a3, _b2; + super(type), this.code = (_a3 = errorEventInitDict == null ? void 0 : errorEventInitDict.code) != null ? _a3 : void 0, this.message = (_b2 = errorEventInitDict == null ? void 0 : errorEventInitDict.message) != null ? _b2 : void 0; + } + /** + * Node.js "hides" the `message` and `code` properties of the `ErrorEvent` instance, + * when it is `console.log`'ed. This makes it harder to debug errors. To ease debugging, + * we explicitly include the properties in the `inspect` method. + * + * This is automatically called by Node.js when you `console.log` an instance of this class. + * + * @param _depth - The current depth + * @param options - The options passed to `util.inspect` + * @param inspect - The inspect function to use (prevents having to import it from `util`) + * @returns A string representation of the error + */ + [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")](_depth, options, inspect) { + return inspect(inspectableError(this), options); + } + /** + * Deno "hides" the `message` and `code` properties of the `ErrorEvent` instance, + * when it is `console.log`'ed. This makes it harder to debug errors. To ease debugging, + * we explicitly include the properties in the `inspect` method. + * + * This is automatically called by Deno when you `console.log` an instance of this class. + * + * @param inspect - The inspect function to use (prevents having to import it from `util`) + * @param options - The options passed to `Deno.inspect` + * @returns A string representation of the error + */ + [/* @__PURE__ */ Symbol.for("Deno.customInspect")](inspect, options) { + return inspect(inspectableError(this), options); + } +}; +function syntaxError(message) { + const DomException = globalThis.DOMException; + return typeof DomException == "function" ? new DomException(message, "SyntaxError") : new SyntaxError(message); +} +function flattenError2(err) { + return err instanceof Error ? "errors" in err && Array.isArray(err.errors) ? err.errors.map(flattenError2).join(", ") : "cause" in err && err.cause instanceof Error ? `${err}: ${flattenError2(err.cause)}` : err.message : `${err}`; +} +function inspectableError(err) { + return { + type: err.type, + message: err.message, + code: err.code, + defaultPrevented: err.defaultPrevented, + cancelable: err.cancelable, + timeStamp: err.timeStamp + }; +} +var __typeError2 = (msg) => { + throw TypeError(msg); +}; +var __accessCheck2 = (obj, member, msg) => member.has(obj) || __typeError2("Cannot " + msg); +var __privateGet2 = (obj, member, getter) => (__accessCheck2(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj)); +var __privateAdd2 = (obj, member, value) => member.has(obj) ? __typeError2("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value); +var __privateSet2 = (obj, member, value, setter) => (__accessCheck2(obj, member, "write to private field"), member.set(obj, value), value); +var __privateMethod = (obj, member, method) => (__accessCheck2(obj, member, "access private method"), method); +var _readyState; +var _url2; +var _redirectUrl; +var _withCredentials; +var _fetch; +var _reconnectInterval; +var _reconnectTimer; +var _lastEventId; +var _controller; +var _parser; +var _onError; +var _onMessage; +var _onOpen; +var _EventSource_instances; +var connect_fn; +var _onFetchResponse; +var _onFetchError; +var getRequestOptions_fn; +var _onEvent; +var _onRetryChange; +var failConnection_fn; +var scheduleReconnect_fn; +var _reconnect; +var EventSource = class extends EventTarget { + constructor(url2, eventSourceInitDict) { + var _a3, _b2; + super(), __privateAdd2(this, _EventSource_instances), this.CONNECTING = 0, this.OPEN = 1, this.CLOSED = 2, __privateAdd2(this, _readyState), __privateAdd2(this, _url2), __privateAdd2(this, _redirectUrl), __privateAdd2(this, _withCredentials), __privateAdd2(this, _fetch), __privateAdd2(this, _reconnectInterval), __privateAdd2(this, _reconnectTimer), __privateAdd2(this, _lastEventId, null), __privateAdd2(this, _controller), __privateAdd2(this, _parser), __privateAdd2(this, _onError, null), __privateAdd2(this, _onMessage, null), __privateAdd2(this, _onOpen, null), __privateAdd2(this, _onFetchResponse, async (response) => { + var _a22; + __privateGet2(this, _parser).reset(); + const { body, redirected, status, headers } = response; + if (status === 204) { + __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, "Server sent HTTP 204, not reconnecting", 204), this.close(); + return; + } + if (redirected ? __privateSet2(this, _redirectUrl, new URL(response.url)) : __privateSet2(this, _redirectUrl, void 0), status !== 200) { + __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, `Non-200 status code (${status})`, status); + return; + } + if (!(headers.get("content-type") || "").startsWith("text/event-stream")) { + __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, 'Invalid content type, expected "text/event-stream"', status); + return; + } + if (__privateGet2(this, _readyState) === this.CLOSED) + return; + __privateSet2(this, _readyState, this.OPEN); + const openEvent = new Event("open"); + if ((_a22 = __privateGet2(this, _onOpen)) == null || _a22.call(this, openEvent), this.dispatchEvent(openEvent), typeof body != "object" || !body || !("getReader" in body)) { + __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, "Invalid response body, expected a web ReadableStream", status), this.close(); + return; + } + const decoder = new TextDecoder(), reader = body.getReader(); + let open = true; + do { + const { done, value } = await reader.read(); + value && __privateGet2(this, _parser).feed(decoder.decode(value, { stream: !done })), done && (open = false, __privateGet2(this, _parser).reset(), __privateMethod(this, _EventSource_instances, scheduleReconnect_fn).call(this)); + } while (open); + }), __privateAdd2(this, _onFetchError, (err) => { + __privateSet2(this, _controller, void 0), !(err.name === "AbortError" || err.type === "aborted") && __privateMethod(this, _EventSource_instances, scheduleReconnect_fn).call(this, flattenError2(err)); + }), __privateAdd2(this, _onEvent, (event) => { + typeof event.id == "string" && __privateSet2(this, _lastEventId, event.id); + const messageEvent = new MessageEvent(event.event || "message", { + data: event.data, + origin: __privateGet2(this, _redirectUrl) ? __privateGet2(this, _redirectUrl).origin : __privateGet2(this, _url2).origin, + lastEventId: event.id || "" + }); + __privateGet2(this, _onMessage) && (!event.event || event.event === "message") && __privateGet2(this, _onMessage).call(this, messageEvent), this.dispatchEvent(messageEvent); + }), __privateAdd2(this, _onRetryChange, (value) => { + __privateSet2(this, _reconnectInterval, value); + }), __privateAdd2(this, _reconnect, () => { + __privateSet2(this, _reconnectTimer, void 0), __privateGet2(this, _readyState) === this.CONNECTING && __privateMethod(this, _EventSource_instances, connect_fn).call(this); + }); + try { + if (url2 instanceof URL) + __privateSet2(this, _url2, url2); + else if (typeof url2 == "string") + __privateSet2(this, _url2, new URL(url2, getBaseURL())); + else + throw new Error("Invalid URL"); + } catch (e3) { + throw syntaxError("An invalid or illegal string was specified"); + } + __privateSet2(this, _parser, createParser({ + onEvent: __privateGet2(this, _onEvent), + onRetry: __privateGet2(this, _onRetryChange) + })), __privateSet2(this, _readyState, this.CONNECTING), __privateSet2(this, _reconnectInterval, 3e3), __privateSet2(this, _fetch, (_a3 = eventSourceInitDict == null ? void 0 : eventSourceInitDict.fetch) != null ? _a3 : globalThis.fetch), __privateSet2(this, _withCredentials, (_b2 = eventSourceInitDict == null ? void 0 : eventSourceInitDict.withCredentials) != null ? _b2 : false), __privateMethod(this, _EventSource_instances, connect_fn).call(this); + } + /** + * Returns the state of this EventSource object's connection. It can have the values described below. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/readyState) + * + * Note: typed as `number` instead of `0 | 1 | 2` for compatibility with the `EventSource` interface, + * defined in the TypeScript `dom` library. + * + * @public + */ + get readyState() { + return __privateGet2(this, _readyState); + } + /** + * Returns the URL providing the event stream. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/url) + * + * @public + */ + get url() { + return __privateGet2(this, _url2).href; + } + /** + * Returns true if the credentials mode for connection requests to the URL providing the event stream is set to "include", and false otherwise. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/withCredentials) + */ + get withCredentials() { + return __privateGet2(this, _withCredentials); + } + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/error_event) */ + get onerror() { + return __privateGet2(this, _onError); + } + set onerror(value) { + __privateSet2(this, _onError, value); + } + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/message_event) */ + get onmessage() { + return __privateGet2(this, _onMessage); + } + set onmessage(value) { + __privateSet2(this, _onMessage, value); + } + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/open_event) */ + get onopen() { + return __privateGet2(this, _onOpen); + } + set onopen(value) { + __privateSet2(this, _onOpen, value); + } + addEventListener(type, listener, options) { + const listen = listener; + super.addEventListener(type, listen, options); + } + removeEventListener(type, listener, options) { + const listen = listener; + super.removeEventListener(type, listen, options); + } + /** + * Aborts any instances of the fetch algorithm started for this EventSource object, and sets the readyState attribute to CLOSED. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/close) + * + * @public + */ + close() { + __privateGet2(this, _reconnectTimer) && clearTimeout(__privateGet2(this, _reconnectTimer)), __privateGet2(this, _readyState) !== this.CLOSED && (__privateGet2(this, _controller) && __privateGet2(this, _controller).abort(), __privateSet2(this, _readyState, this.CLOSED), __privateSet2(this, _controller, void 0)); + } +}; +_readyState = /* @__PURE__ */ new WeakMap(), _url2 = /* @__PURE__ */ new WeakMap(), _redirectUrl = /* @__PURE__ */ new WeakMap(), _withCredentials = /* @__PURE__ */ new WeakMap(), _fetch = /* @__PURE__ */ new WeakMap(), _reconnectInterval = /* @__PURE__ */ new WeakMap(), _reconnectTimer = /* @__PURE__ */ new WeakMap(), _lastEventId = /* @__PURE__ */ new WeakMap(), _controller = /* @__PURE__ */ new WeakMap(), _parser = /* @__PURE__ */ new WeakMap(), _onError = /* @__PURE__ */ new WeakMap(), _onMessage = /* @__PURE__ */ new WeakMap(), _onOpen = /* @__PURE__ */ new WeakMap(), _EventSource_instances = /* @__PURE__ */ new WeakSet(), /** +* Connect to the given URL and start receiving events +* +* @internal +*/ +connect_fn = function() { + __privateSet2(this, _readyState, this.CONNECTING), __privateSet2(this, _controller, new AbortController()), __privateGet2(this, _fetch)(__privateGet2(this, _url2), __privateMethod(this, _EventSource_instances, getRequestOptions_fn).call(this)).then(__privateGet2(this, _onFetchResponse)).catch(__privateGet2(this, _onFetchError)); +}, _onFetchResponse = /* @__PURE__ */ new WeakMap(), _onFetchError = /* @__PURE__ */ new WeakMap(), /** +* Get request options for the `fetch()` request +* +* @returns The request options +* @internal +*/ +getRequestOptions_fn = function() { + var _a3; + const init = { + // [spec] Let `corsAttributeState` be `Anonymous`… + // [spec] …will have their mode set to "cors"… + mode: "cors", + redirect: "follow", + headers: { Accept: "text/event-stream", ...__privateGet2(this, _lastEventId) ? { "Last-Event-ID": __privateGet2(this, _lastEventId) } : void 0 }, + cache: "no-store", + signal: (_a3 = __privateGet2(this, _controller)) == null ? void 0 : _a3.signal + }; + return "window" in globalThis && (init.credentials = this.withCredentials ? "include" : "same-origin"), init; +}, _onEvent = /* @__PURE__ */ new WeakMap(), _onRetryChange = /* @__PURE__ */ new WeakMap(), /** +* Handles the process referred to in the EventSource specification as "failing a connection". +* +* @param error - The error causing the connection to fail +* @param code - The HTTP status code, if available +* @internal +*/ +failConnection_fn = function(message, code) { + var _a3; + __privateGet2(this, _readyState) !== this.CLOSED && __privateSet2(this, _readyState, this.CLOSED); + const errorEvent = new ErrorEvent("error", { code, message }); + (_a3 = __privateGet2(this, _onError)) == null || _a3.call(this, errorEvent), this.dispatchEvent(errorEvent); +}, /** +* Schedules a reconnection attempt against the EventSource endpoint. +* +* @param message - The error causing the connection to fail +* @param code - The HTTP status code, if available +* @internal +*/ +scheduleReconnect_fn = function(message, code) { + var _a3; + if (__privateGet2(this, _readyState) === this.CLOSED) + return; + __privateSet2(this, _readyState, this.CONNECTING); + const errorEvent = new ErrorEvent("error", { code, message }); + (_a3 = __privateGet2(this, _onError)) == null || _a3.call(this, errorEvent), this.dispatchEvent(errorEvent), __privateSet2(this, _reconnectTimer, setTimeout(__privateGet2(this, _reconnect), __privateGet2(this, _reconnectInterval))); +}, _reconnect = /* @__PURE__ */ new WeakMap(), /** +* ReadyState representing an EventSource currently trying to connect +* +* @public +*/ +EventSource.CONNECTING = 0, /** +* ReadyState representing an EventSource connection that is open (eg connected) +* +* @public +*/ +EventSource.OPEN = 1, /** +* ReadyState representing an EventSource connection that is closed (eg disconnected) +* +* @public +*/ +EventSource.CLOSED = 2; +function getBaseURL() { + const doc = "document" in globalThis ? globalThis.document : void 0; + return doc && typeof doc == "object" && "baseURI" in doc && typeof doc.baseURI == "string" ? doc.baseURI : void 0; +} + +// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/transport.js +function normalizeHeaders(headers) { + if (!headers) + return {}; + if (headers instanceof Headers) { + return Object.fromEntries(headers.entries()); + } + if (Array.isArray(headers)) { + return Object.fromEntries(headers); + } + return { ...headers }; +} +function createFetchWithInit(baseFetch = fetch, baseInit) { + if (!baseInit) { + return baseFetch; + } + return async (url2, init) => { + const mergedInit = { + ...baseInit, + ...init, + // Headers need special handling - merge instead of replace + headers: (init == null ? void 0 : init.headers) ? { ...normalizeHeaders(baseInit.headers), ...normalizeHeaders(init.headers) } : baseInit.headers + }; + return baseFetch(url2, mergedInit); + }; +} + +// node_modules/pkce-challenge/dist/index.browser.js +var crypto; +crypto = globalThis.crypto; +async function getRandomValues(size) { + return (await crypto).getRandomValues(new Uint8Array(size)); +} +async function random(size) { + const mask = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~"; + const evenDistCutoff = Math.pow(2, 8) - Math.pow(2, 8) % mask.length; + let result = ""; + while (result.length < size) { + const randomBytes = await getRandomValues(size - result.length); + for (const randomByte of randomBytes) { + if (randomByte < evenDistCutoff) { + result += mask[randomByte % mask.length]; + } + } + } + return result; +} +async function generateVerifier(length) { + return await random(length); +} +async function generateChallenge(code_verifier) { + const buffer = await (await crypto).subtle.digest("SHA-256", new TextEncoder().encode(code_verifier)); + return btoa(String.fromCharCode(...new Uint8Array(buffer))).replace(/\//g, "_").replace(/\+/g, "-").replace(/=/g, ""); +} +async function pkceChallenge(length) { + if (!length) + length = 43; + if (length < 43 || length > 128) { + throw `Expected a length between 43 and 128. Received ${length}.`; + } + const verifier = await generateVerifier(length); + const challenge = await generateChallenge(verifier); + return { + code_verifier: verifier, + code_challenge: challenge + }; +} + +// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth.js +var SafeUrlSchema = url().superRefine((val, ctx) => { + if (!URL.canParse(val)) { + ctx.addIssue({ + code: ZodIssueCode2.custom, + message: "URL must be parseable", + fatal: true + }); + return NEVER; + } +}).refine((url2) => { + const u = new URL(url2); + return u.protocol !== "javascript:" && u.protocol !== "data:" && u.protocol !== "vbscript:"; +}, { message: "URL cannot use javascript:, data:, or vbscript: scheme" }); +var OAuthProtectedResourceMetadataSchema = looseObject({ + resource: string3().url(), + authorization_servers: array(SafeUrlSchema).optional(), + jwks_uri: string3().url().optional(), + scopes_supported: array(string3()).optional(), + bearer_methods_supported: array(string3()).optional(), + resource_signing_alg_values_supported: array(string3()).optional(), + resource_name: string3().optional(), + resource_documentation: string3().optional(), + resource_policy_uri: string3().url().optional(), + resource_tos_uri: string3().url().optional(), + tls_client_certificate_bound_access_tokens: boolean3().optional(), + authorization_details_types_supported: array(string3()).optional(), + dpop_signing_alg_values_supported: array(string3()).optional(), + dpop_bound_access_tokens_required: boolean3().optional() +}); +var OAuthMetadataSchema = looseObject({ + issuer: string3(), + authorization_endpoint: SafeUrlSchema, + token_endpoint: SafeUrlSchema, + registration_endpoint: SafeUrlSchema.optional(), + scopes_supported: array(string3()).optional(), + response_types_supported: array(string3()), + response_modes_supported: array(string3()).optional(), + grant_types_supported: array(string3()).optional(), + token_endpoint_auth_methods_supported: array(string3()).optional(), + token_endpoint_auth_signing_alg_values_supported: array(string3()).optional(), + service_documentation: SafeUrlSchema.optional(), + revocation_endpoint: SafeUrlSchema.optional(), + revocation_endpoint_auth_methods_supported: array(string3()).optional(), + revocation_endpoint_auth_signing_alg_values_supported: array(string3()).optional(), + introspection_endpoint: string3().optional(), + introspection_endpoint_auth_methods_supported: array(string3()).optional(), + introspection_endpoint_auth_signing_alg_values_supported: array(string3()).optional(), + code_challenge_methods_supported: array(string3()).optional(), + client_id_metadata_document_supported: boolean3().optional() +}); +var OpenIdProviderMetadataSchema = looseObject({ + issuer: string3(), + authorization_endpoint: SafeUrlSchema, + token_endpoint: SafeUrlSchema, + userinfo_endpoint: SafeUrlSchema.optional(), + jwks_uri: SafeUrlSchema, + registration_endpoint: SafeUrlSchema.optional(), + scopes_supported: array(string3()).optional(), + response_types_supported: array(string3()), + response_modes_supported: array(string3()).optional(), + grant_types_supported: array(string3()).optional(), + acr_values_supported: array(string3()).optional(), + subject_types_supported: array(string3()), + id_token_signing_alg_values_supported: array(string3()), + id_token_encryption_alg_values_supported: array(string3()).optional(), + id_token_encryption_enc_values_supported: array(string3()).optional(), + userinfo_signing_alg_values_supported: array(string3()).optional(), + userinfo_encryption_alg_values_supported: array(string3()).optional(), + userinfo_encryption_enc_values_supported: array(string3()).optional(), + request_object_signing_alg_values_supported: array(string3()).optional(), + request_object_encryption_alg_values_supported: array(string3()).optional(), + request_object_encryption_enc_values_supported: array(string3()).optional(), + token_endpoint_auth_methods_supported: array(string3()).optional(), + token_endpoint_auth_signing_alg_values_supported: array(string3()).optional(), + display_values_supported: array(string3()).optional(), + claim_types_supported: array(string3()).optional(), + claims_supported: array(string3()).optional(), + service_documentation: string3().optional(), + claims_locales_supported: array(string3()).optional(), + ui_locales_supported: array(string3()).optional(), + claims_parameter_supported: boolean3().optional(), + request_parameter_supported: boolean3().optional(), + request_uri_parameter_supported: boolean3().optional(), + require_request_uri_registration: boolean3().optional(), + op_policy_uri: SafeUrlSchema.optional(), + op_tos_uri: SafeUrlSchema.optional(), + client_id_metadata_document_supported: boolean3().optional() +}); +var OpenIdProviderDiscoveryMetadataSchema = object2({ + ...OpenIdProviderMetadataSchema.shape, + ...OAuthMetadataSchema.pick({ + code_challenge_methods_supported: true + }).shape +}); +var OAuthTokensSchema = object2({ + access_token: string3(), + id_token: string3().optional(), + // Optional for OAuth 2.1, but necessary in OpenID Connect + token_type: string3(), + expires_in: coerce_exports2.number().optional(), + scope: string3().optional(), + refresh_token: string3().optional() +}).strip(); +var OAuthErrorResponseSchema = object2({ + error: string3(), + error_description: string3().optional(), + error_uri: string3().optional() +}); +var OptionalSafeUrlSchema = SafeUrlSchema.optional().or(literal("").transform(() => void 0)); +var OAuthClientMetadataSchema = object2({ + redirect_uris: array(SafeUrlSchema), + token_endpoint_auth_method: string3().optional(), + grant_types: array(string3()).optional(), + response_types: array(string3()).optional(), + client_name: string3().optional(), + client_uri: SafeUrlSchema.optional(), + logo_uri: OptionalSafeUrlSchema, + scope: string3().optional(), + contacts: array(string3()).optional(), + tos_uri: OptionalSafeUrlSchema, + policy_uri: string3().optional(), + jwks_uri: SafeUrlSchema.optional(), + jwks: any().optional(), + software_id: string3().optional(), + software_version: string3().optional(), + software_statement: string3().optional() +}).strip(); +var OAuthClientInformationSchema = object2({ + client_id: string3(), + client_secret: string3().optional(), + client_id_issued_at: number3().optional(), + client_secret_expires_at: number3().optional() +}).strip(); +var OAuthClientInformationFullSchema = OAuthClientMetadataSchema.merge(OAuthClientInformationSchema); +var OAuthClientRegistrationErrorSchema = object2({ + error: string3(), + error_description: string3().optional() +}).strip(); +var OAuthTokenRevocationRequestSchema = object2({ + token: string3(), + token_type_hint: string3().optional() +}).strip(); + +// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth-utils.js +function resourceUrlFromServerUrl(url2) { + const resourceURL = typeof url2 === "string" ? new URL(url2) : new URL(url2.href); + resourceURL.hash = ""; + return resourceURL; +} +function checkResourceAllowed({ requestedResource, configuredResource }) { + const requested = typeof requestedResource === "string" ? new URL(requestedResource) : new URL(requestedResource.href); + const configured = typeof configuredResource === "string" ? new URL(configuredResource) : new URL(configuredResource.href); + if (requested.origin !== configured.origin) { + return false; + } + if (requested.pathname.length < configured.pathname.length) { + return false; + } + const requestedPath = requested.pathname.endsWith("/") ? requested.pathname : requested.pathname + "/"; + const configuredPath = configured.pathname.endsWith("/") ? configured.pathname : configured.pathname + "/"; + return requestedPath.startsWith(configuredPath); +} + +// node_modules/@modelcontextprotocol/sdk/dist/esm/server/auth/errors.js +var OAuthError = class extends Error { + constructor(message, errorUri) { + super(message); + this.errorUri = errorUri; + this.name = this.constructor.name; + } + /** + * Converts the error to a standard OAuth error response object + */ + toResponseObject() { + const response = { + error: this.errorCode, + error_description: this.message + }; + if (this.errorUri) { + response.error_uri = this.errorUri; + } + return response; + } + get errorCode() { + return this.constructor.errorCode; + } +}; +var InvalidRequestError = class extends OAuthError { +}; +InvalidRequestError.errorCode = "invalid_request"; +var InvalidClientError = class extends OAuthError { +}; +InvalidClientError.errorCode = "invalid_client"; +var InvalidGrantError = class extends OAuthError { +}; +InvalidGrantError.errorCode = "invalid_grant"; +var UnauthorizedClientError = class extends OAuthError { +}; +UnauthorizedClientError.errorCode = "unauthorized_client"; +var UnsupportedGrantTypeError = class extends OAuthError { +}; +UnsupportedGrantTypeError.errorCode = "unsupported_grant_type"; +var InvalidScopeError = class extends OAuthError { +}; +InvalidScopeError.errorCode = "invalid_scope"; +var AccessDeniedError = class extends OAuthError { +}; +AccessDeniedError.errorCode = "access_denied"; +var ServerError = class extends OAuthError { +}; +ServerError.errorCode = "server_error"; +var TemporarilyUnavailableError = class extends OAuthError { +}; +TemporarilyUnavailableError.errorCode = "temporarily_unavailable"; +var UnsupportedResponseTypeError = class extends OAuthError { +}; +UnsupportedResponseTypeError.errorCode = "unsupported_response_type"; +var UnsupportedTokenTypeError = class extends OAuthError { +}; +UnsupportedTokenTypeError.errorCode = "unsupported_token_type"; +var InvalidTokenError = class extends OAuthError { +}; +InvalidTokenError.errorCode = "invalid_token"; +var MethodNotAllowedError = class extends OAuthError { +}; +MethodNotAllowedError.errorCode = "method_not_allowed"; +var TooManyRequestsError = class extends OAuthError { +}; +TooManyRequestsError.errorCode = "too_many_requests"; +var InvalidClientMetadataError = class extends OAuthError { +}; +InvalidClientMetadataError.errorCode = "invalid_client_metadata"; +var InsufficientScopeError = class extends OAuthError { +}; +InsufficientScopeError.errorCode = "insufficient_scope"; +var InvalidTargetError = class extends OAuthError { +}; +InvalidTargetError.errorCode = "invalid_target"; +var OAUTH_ERRORS = { + [InvalidRequestError.errorCode]: InvalidRequestError, + [InvalidClientError.errorCode]: InvalidClientError, + [InvalidGrantError.errorCode]: InvalidGrantError, + [UnauthorizedClientError.errorCode]: UnauthorizedClientError, + [UnsupportedGrantTypeError.errorCode]: UnsupportedGrantTypeError, + [InvalidScopeError.errorCode]: InvalidScopeError, + [AccessDeniedError.errorCode]: AccessDeniedError, + [ServerError.errorCode]: ServerError, + [TemporarilyUnavailableError.errorCode]: TemporarilyUnavailableError, + [UnsupportedResponseTypeError.errorCode]: UnsupportedResponseTypeError, + [UnsupportedTokenTypeError.errorCode]: UnsupportedTokenTypeError, + [InvalidTokenError.errorCode]: InvalidTokenError, + [MethodNotAllowedError.errorCode]: MethodNotAllowedError, + [TooManyRequestsError.errorCode]: TooManyRequestsError, + [InvalidClientMetadataError.errorCode]: InvalidClientMetadataError, + [InsufficientScopeError.errorCode]: InsufficientScopeError, + [InvalidTargetError.errorCode]: InvalidTargetError +}; + +// node_modules/@modelcontextprotocol/sdk/dist/esm/client/auth.js +var UnauthorizedError = class extends Error { + constructor(message) { + super(message != null ? message : "Unauthorized"); + } +}; +function isClientAuthMethod(method) { + return ["client_secret_basic", "client_secret_post", "none"].includes(method); +} +var AUTHORIZATION_CODE_RESPONSE_TYPE = "code"; +var AUTHORIZATION_CODE_CHALLENGE_METHOD = "S256"; +function selectClientAuthMethod(clientInformation, supportedMethods) { + const hasClientSecret = clientInformation.client_secret !== void 0; + if ("token_endpoint_auth_method" in clientInformation && clientInformation.token_endpoint_auth_method && isClientAuthMethod(clientInformation.token_endpoint_auth_method) && (supportedMethods.length === 0 || supportedMethods.includes(clientInformation.token_endpoint_auth_method))) { + return clientInformation.token_endpoint_auth_method; + } + if (supportedMethods.length === 0) { + return hasClientSecret ? "client_secret_basic" : "none"; + } + if (hasClientSecret && supportedMethods.includes("client_secret_basic")) { + return "client_secret_basic"; + } + if (hasClientSecret && supportedMethods.includes("client_secret_post")) { + return "client_secret_post"; + } + if (supportedMethods.includes("none")) { + return "none"; + } + return hasClientSecret ? "client_secret_post" : "none"; +} +function applyClientAuthentication(method, clientInformation, headers, params) { + const { client_id, client_secret } = clientInformation; + switch (method) { + case "client_secret_basic": + applyBasicAuth(client_id, client_secret, headers); + return; + case "client_secret_post": + applyPostAuth(client_id, client_secret, params); + return; + case "none": + applyPublicAuth(client_id, params); + return; + default: + throw new Error(`Unsupported client authentication method: ${method}`); + } +} +function applyBasicAuth(clientId, clientSecret, headers) { + if (!clientSecret) { + throw new Error("client_secret_basic authentication requires a client_secret"); + } + const credentials = btoa(`${clientId}:${clientSecret}`); + headers.set("Authorization", `Basic ${credentials}`); +} +function applyPostAuth(clientId, clientSecret, params) { + params.set("client_id", clientId); + if (clientSecret) { + params.set("client_secret", clientSecret); + } +} +function applyPublicAuth(clientId, params) { + params.set("client_id", clientId); +} +async function parseErrorResponse(input) { + const statusCode = input instanceof Response ? input.status : void 0; + const body = input instanceof Response ? await input.text() : input; + try { + const result = OAuthErrorResponseSchema.parse(JSON.parse(body)); + const { error: error48, error_description, error_uri } = result; + const errorClass = OAUTH_ERRORS[error48] || ServerError; + return new errorClass(error_description || "", error_uri); + } catch (error48) { + const errorMessage = `${statusCode ? `HTTP ${statusCode}: ` : ""}Invalid OAuth error response: ${error48}. Raw body: ${body}`; + return new ServerError(errorMessage); + } +} +async function auth(provider, options) { + var _a3, _b2; + try { + return await authInternal(provider, options); + } catch (error48) { + if (error48 instanceof InvalidClientError || error48 instanceof UnauthorizedClientError) { + await ((_a3 = provider.invalidateCredentials) == null ? void 0 : _a3.call(provider, "all")); + return await authInternal(provider, options); + } else if (error48 instanceof InvalidGrantError) { + await ((_b2 = provider.invalidateCredentials) == null ? void 0 : _b2.call(provider, "tokens")); + return await authInternal(provider, options); + } + throw error48; + } +} +async function authInternal(provider, { serverUrl, authorizationCode, scope, resourceMetadataUrl, fetchFn }) { + var _a3, _b2, _c, _d, _e, _f; + const cachedState = await ((_a3 = provider.discoveryState) == null ? void 0 : _a3.call(provider)); + let resourceMetadata; + let authorizationServerUrl; + let metadata; + let effectiveResourceMetadataUrl = resourceMetadataUrl; + if (!effectiveResourceMetadataUrl && (cachedState == null ? void 0 : cachedState.resourceMetadataUrl)) { + effectiveResourceMetadataUrl = new URL(cachedState.resourceMetadataUrl); + } + if (cachedState == null ? void 0 : cachedState.authorizationServerUrl) { + authorizationServerUrl = cachedState.authorizationServerUrl; + resourceMetadata = cachedState.resourceMetadata; + metadata = (_b2 = cachedState.authorizationServerMetadata) != null ? _b2 : await discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn }); + if (!resourceMetadata) { + try { + resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl: effectiveResourceMetadataUrl }, fetchFn); + } catch (e3) { + } + } + if (metadata !== cachedState.authorizationServerMetadata || resourceMetadata !== cachedState.resourceMetadata) { + await ((_c = provider.saveDiscoveryState) == null ? void 0 : _c.call(provider, { + authorizationServerUrl: String(authorizationServerUrl), + resourceMetadataUrl: effectiveResourceMetadataUrl == null ? void 0 : effectiveResourceMetadataUrl.toString(), + resourceMetadata, + authorizationServerMetadata: metadata + })); + } + } else { + const serverInfo = await discoverOAuthServerInfo(serverUrl, { resourceMetadataUrl: effectiveResourceMetadataUrl, fetchFn }); + authorizationServerUrl = serverInfo.authorizationServerUrl; + metadata = serverInfo.authorizationServerMetadata; + resourceMetadata = serverInfo.resourceMetadata; + await ((_d = provider.saveDiscoveryState) == null ? void 0 : _d.call(provider, { + authorizationServerUrl: String(authorizationServerUrl), + resourceMetadataUrl: effectiveResourceMetadataUrl == null ? void 0 : effectiveResourceMetadataUrl.toString(), + resourceMetadata, + authorizationServerMetadata: metadata + })); + } + const resource = await selectResourceURL(serverUrl, provider, resourceMetadata); + const resolvedScope = scope || ((_e = resourceMetadata == null ? void 0 : resourceMetadata.scopes_supported) == null ? void 0 : _e.join(" ")) || provider.clientMetadata.scope; + let clientInformation = await Promise.resolve(provider.clientInformation()); + if (!clientInformation) { + if (authorizationCode !== void 0) { + throw new Error("Existing OAuth client information is required when exchanging an authorization code"); + } + const supportsUrlBasedClientId = (metadata == null ? void 0 : metadata.client_id_metadata_document_supported) === true; + const clientMetadataUrl = provider.clientMetadataUrl; + if (clientMetadataUrl && !isHttpsUrl(clientMetadataUrl)) { + throw new InvalidClientMetadataError(`clientMetadataUrl must be a valid HTTPS URL with a non-root pathname, got: ${clientMetadataUrl}`); + } + const shouldUseUrlBasedClientId = supportsUrlBasedClientId && clientMetadataUrl; + if (shouldUseUrlBasedClientId) { + clientInformation = { + client_id: clientMetadataUrl + }; + await ((_f = provider.saveClientInformation) == null ? void 0 : _f.call(provider, clientInformation)); + } else { + if (!provider.saveClientInformation) { + throw new Error("OAuth client information must be saveable for dynamic registration"); + } + const fullInformation = await registerClient(authorizationServerUrl, { + metadata, + clientMetadata: provider.clientMetadata, + scope: resolvedScope, + fetchFn + }); + await provider.saveClientInformation(fullInformation); + clientInformation = fullInformation; + } + } + const nonInteractiveFlow = !provider.redirectUrl; + if (authorizationCode !== void 0 || nonInteractiveFlow) { + const tokens2 = await fetchToken(provider, authorizationServerUrl, { + metadata, + resource, + authorizationCode, + fetchFn + }); + await provider.saveTokens(tokens2); + return "AUTHORIZED"; + } + const tokens = await provider.tokens(); + if (tokens == null ? void 0 : tokens.refresh_token) { + try { + const newTokens = await refreshAuthorization(authorizationServerUrl, { + metadata, + clientInformation, + refreshToken: tokens.refresh_token, + resource, + addClientAuthentication: provider.addClientAuthentication, + fetchFn + }); + await provider.saveTokens(newTokens); + return "AUTHORIZED"; + } catch (error48) { + if (!(error48 instanceof OAuthError) || error48 instanceof ServerError) { + } else { + throw error48; + } + } + } + const state = provider.state ? await provider.state() : void 0; + const { authorizationUrl, codeVerifier } = await startAuthorization(authorizationServerUrl, { + metadata, + clientInformation, + state, + redirectUrl: provider.redirectUrl, + scope: resolvedScope, + resource + }); + await provider.saveCodeVerifier(codeVerifier); + await provider.redirectToAuthorization(authorizationUrl); + return "REDIRECT"; +} +function isHttpsUrl(value) { + if (!value) + return false; + try { + const url2 = new URL(value); + return url2.protocol === "https:" && url2.pathname !== "/"; + } catch (e3) { + return false; + } +} +async function selectResourceURL(serverUrl, provider, resourceMetadata) { + const defaultResource = resourceUrlFromServerUrl(serverUrl); + if (provider.validateResourceURL) { + return await provider.validateResourceURL(defaultResource, resourceMetadata == null ? void 0 : resourceMetadata.resource); + } + if (!resourceMetadata) { + return void 0; + } + if (!checkResourceAllowed({ requestedResource: defaultResource, configuredResource: resourceMetadata.resource })) { + throw new Error(`Protected resource ${resourceMetadata.resource} does not match expected ${defaultResource} (or origin)`); + } + return new URL(resourceMetadata.resource); +} +function extractWWWAuthenticateParams(res) { + const authenticateHeader = res.headers.get("WWW-Authenticate"); + if (!authenticateHeader) { + return {}; + } + const [type, scheme] = authenticateHeader.split(" "); + if (type.toLowerCase() !== "bearer" || !scheme) { + return {}; + } + const resourceMetadataMatch = extractFieldFromWwwAuth(res, "resource_metadata") || void 0; + let resourceMetadataUrl; + if (resourceMetadataMatch) { + try { + resourceMetadataUrl = new URL(resourceMetadataMatch); + } catch (e3) { + } + } + const scope = extractFieldFromWwwAuth(res, "scope") || void 0; + const error48 = extractFieldFromWwwAuth(res, "error") || void 0; + return { + resourceMetadataUrl, + scope, + error: error48 + }; +} +function extractFieldFromWwwAuth(response, fieldName) { + const wwwAuthHeader = response.headers.get("WWW-Authenticate"); + if (!wwwAuthHeader) { + return null; + } + const pattern = new RegExp(`${fieldName}=(?:"([^"]+)"|([^\\s,]+))`); + const match = wwwAuthHeader.match(pattern); + if (match) { + return match[1] || match[2]; + } + return null; +} +async function discoverOAuthProtectedResourceMetadata(serverUrl, opts, fetchFn = fetch) { + var _a3, _b2; + const response = await discoverMetadataWithFallback(serverUrl, "oauth-protected-resource", fetchFn, { + protocolVersion: opts == null ? void 0 : opts.protocolVersion, + metadataUrl: opts == null ? void 0 : opts.resourceMetadataUrl + }); + if (!response || response.status === 404) { + await ((_a3 = response == null ? void 0 : response.body) == null ? void 0 : _a3.cancel()); + throw new Error(`Resource server does not implement OAuth 2.0 Protected Resource Metadata.`); + } + if (!response.ok) { + await ((_b2 = response.body) == null ? void 0 : _b2.cancel()); + throw new Error(`HTTP ${response.status} trying to load well-known OAuth protected resource metadata.`); + } + return OAuthProtectedResourceMetadataSchema.parse(await response.json()); +} +async function fetchWithCorsRetry(url2, headers, fetchFn = fetch) { + try { + return await fetchFn(url2, { headers }); + } catch (error48) { + if (error48 instanceof TypeError) { + if (headers) { + return fetchWithCorsRetry(url2, void 0, fetchFn); + } else { + return void 0; + } + } + throw error48; + } +} +function buildWellKnownPath(wellKnownPrefix, pathname = "", options = {}) { + if (pathname.endsWith("/")) { + pathname = pathname.slice(0, -1); + } + return options.prependPathname ? `${pathname}/.well-known/${wellKnownPrefix}` : `/.well-known/${wellKnownPrefix}${pathname}`; +} +async function tryMetadataDiscovery(url2, protocolVersion, fetchFn = fetch) { + const headers = { + "MCP-Protocol-Version": protocolVersion + }; + return await fetchWithCorsRetry(url2, headers, fetchFn); +} +function shouldAttemptFallback(response, pathname) { + return !response || response.status >= 400 && response.status < 500 && pathname !== "/"; +} +async function discoverMetadataWithFallback(serverUrl, wellKnownType, fetchFn, opts) { + var _a3, _b2; + const issuer = new URL(serverUrl); + const protocolVersion = (_a3 = opts == null ? void 0 : opts.protocolVersion) != null ? _a3 : LATEST_PROTOCOL_VERSION; + let url2; + if (opts == null ? void 0 : opts.metadataUrl) { + url2 = new URL(opts.metadataUrl); + } else { + const wellKnownPath = buildWellKnownPath(wellKnownType, issuer.pathname); + url2 = new URL(wellKnownPath, (_b2 = opts == null ? void 0 : opts.metadataServerUrl) != null ? _b2 : issuer); + url2.search = issuer.search; + } + let response = await tryMetadataDiscovery(url2, protocolVersion, fetchFn); + if (!(opts == null ? void 0 : opts.metadataUrl) && shouldAttemptFallback(response, issuer.pathname)) { + const rootUrl = new URL(`/.well-known/${wellKnownType}`, issuer); + response = await tryMetadataDiscovery(rootUrl, protocolVersion, fetchFn); + } + return response; +} +function buildDiscoveryUrls(authorizationServerUrl) { + const url2 = typeof authorizationServerUrl === "string" ? new URL(authorizationServerUrl) : authorizationServerUrl; + const hasPath = url2.pathname !== "/"; + const urlsToTry = []; + if (!hasPath) { + urlsToTry.push({ + url: new URL("/.well-known/oauth-authorization-server", url2.origin), + type: "oauth" + }); + urlsToTry.push({ + url: new URL(`/.well-known/openid-configuration`, url2.origin), + type: "oidc" + }); + return urlsToTry; + } + let pathname = url2.pathname; + if (pathname.endsWith("/")) { + pathname = pathname.slice(0, -1); + } + urlsToTry.push({ + url: new URL(`/.well-known/oauth-authorization-server${pathname}`, url2.origin), + type: "oauth" + }); + urlsToTry.push({ + url: new URL(`/.well-known/openid-configuration${pathname}`, url2.origin), + type: "oidc" + }); + urlsToTry.push({ + url: new URL(`${pathname}/.well-known/openid-configuration`, url2.origin), + type: "oidc" + }); + return urlsToTry; +} +async function discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn = fetch, protocolVersion = LATEST_PROTOCOL_VERSION } = {}) { + var _a3; + const headers = { + "MCP-Protocol-Version": protocolVersion, + Accept: "application/json" + }; + const urlsToTry = buildDiscoveryUrls(authorizationServerUrl); + for (const { url: endpointUrl, type } of urlsToTry) { + const response = await fetchWithCorsRetry(endpointUrl, headers, fetchFn); + if (!response) { + continue; + } + if (!response.ok) { + await ((_a3 = response.body) == null ? void 0 : _a3.cancel()); + if (response.status >= 400 && response.status < 500) { + continue; + } + throw new Error(`HTTP ${response.status} trying to load ${type === "oauth" ? "OAuth" : "OpenID provider"} metadata from ${endpointUrl}`); + } + if (type === "oauth") { + return OAuthMetadataSchema.parse(await response.json()); + } else { + return OpenIdProviderDiscoveryMetadataSchema.parse(await response.json()); + } + } + return void 0; +} +async function discoverOAuthServerInfo(serverUrl, opts) { + let resourceMetadata; + let authorizationServerUrl; + try { + resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl: opts == null ? void 0 : opts.resourceMetadataUrl }, opts == null ? void 0 : opts.fetchFn); + if (resourceMetadata.authorization_servers && resourceMetadata.authorization_servers.length > 0) { + authorizationServerUrl = resourceMetadata.authorization_servers[0]; + } + } catch (e3) { + } + if (!authorizationServerUrl) { + authorizationServerUrl = String(new URL("/", serverUrl)); + } + const authorizationServerMetadata = await discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn: opts == null ? void 0 : opts.fetchFn }); + return { + authorizationServerUrl, + authorizationServerMetadata, + resourceMetadata + }; +} +async function startAuthorization(authorizationServerUrl, { metadata, clientInformation, redirectUrl, scope, state, resource }) { + let authorizationUrl; + if (metadata) { + authorizationUrl = new URL(metadata.authorization_endpoint); + if (!metadata.response_types_supported.includes(AUTHORIZATION_CODE_RESPONSE_TYPE)) { + throw new Error(`Incompatible auth server: does not support response type ${AUTHORIZATION_CODE_RESPONSE_TYPE}`); + } + if (metadata.code_challenge_methods_supported && !metadata.code_challenge_methods_supported.includes(AUTHORIZATION_CODE_CHALLENGE_METHOD)) { + throw new Error(`Incompatible auth server: does not support code challenge method ${AUTHORIZATION_CODE_CHALLENGE_METHOD}`); + } + } else { + authorizationUrl = new URL("/authorize", authorizationServerUrl); + } + const challenge = await pkceChallenge(); + const codeVerifier = challenge.code_verifier; + const codeChallenge = challenge.code_challenge; + authorizationUrl.searchParams.set("response_type", AUTHORIZATION_CODE_RESPONSE_TYPE); + authorizationUrl.searchParams.set("client_id", clientInformation.client_id); + authorizationUrl.searchParams.set("code_challenge", codeChallenge); + authorizationUrl.searchParams.set("code_challenge_method", AUTHORIZATION_CODE_CHALLENGE_METHOD); + authorizationUrl.searchParams.set("redirect_uri", String(redirectUrl)); + if (state) { + authorizationUrl.searchParams.set("state", state); + } + if (scope) { + authorizationUrl.searchParams.set("scope", scope); + } + if (scope == null ? void 0 : scope.includes("offline_access")) { + authorizationUrl.searchParams.append("prompt", "consent"); + } + if (resource) { + authorizationUrl.searchParams.set("resource", resource.href); + } + return { authorizationUrl, codeVerifier }; +} +function prepareAuthorizationCodeRequest(authorizationCode, codeVerifier, redirectUri) { + return new URLSearchParams({ + grant_type: "authorization_code", + code: authorizationCode, + code_verifier: codeVerifier, + redirect_uri: String(redirectUri) + }); +} +async function executeTokenRequest(authorizationServerUrl, { metadata, tokenRequestParams, clientInformation, addClientAuthentication, resource, fetchFn }) { + var _a3; + const tokenUrl = (metadata == null ? void 0 : metadata.token_endpoint) ? new URL(metadata.token_endpoint) : new URL("/token", authorizationServerUrl); + const headers = new Headers({ + "Content-Type": "application/x-www-form-urlencoded", + Accept: "application/json" + }); + if (resource) { + tokenRequestParams.set("resource", resource.href); + } + if (addClientAuthentication) { + await addClientAuthentication(headers, tokenRequestParams, tokenUrl, metadata); + } else if (clientInformation) { + const supportedMethods = (_a3 = metadata == null ? void 0 : metadata.token_endpoint_auth_methods_supported) != null ? _a3 : []; + const authMethod = selectClientAuthMethod(clientInformation, supportedMethods); + applyClientAuthentication(authMethod, clientInformation, headers, tokenRequestParams); + } + const response = await (fetchFn != null ? fetchFn : fetch)(tokenUrl, { + method: "POST", + headers, + body: tokenRequestParams + }); + if (!response.ok) { + throw await parseErrorResponse(response); + } + return OAuthTokensSchema.parse(await response.json()); +} +async function refreshAuthorization(authorizationServerUrl, { metadata, clientInformation, refreshToken, resource, addClientAuthentication, fetchFn }) { + const tokenRequestParams = new URLSearchParams({ + grant_type: "refresh_token", + refresh_token: refreshToken + }); + const tokens = await executeTokenRequest(authorizationServerUrl, { + metadata, + tokenRequestParams, + clientInformation, + addClientAuthentication, + resource, + fetchFn + }); + return { refresh_token: refreshToken, ...tokens }; +} +async function fetchToken(provider, authorizationServerUrl, { metadata, resource, authorizationCode, fetchFn } = {}) { + const scope = provider.clientMetadata.scope; + let tokenRequestParams; + if (provider.prepareTokenRequest) { + tokenRequestParams = await provider.prepareTokenRequest(scope); + } + if (!tokenRequestParams) { + if (!authorizationCode) { + throw new Error("Either provider.prepareTokenRequest() or authorizationCode is required"); + } + if (!provider.redirectUrl) { + throw new Error("redirectUrl is required for authorization_code flow"); + } + const codeVerifier = await provider.codeVerifier(); + tokenRequestParams = prepareAuthorizationCodeRequest(authorizationCode, codeVerifier, provider.redirectUrl); + } + const clientInformation = await provider.clientInformation(); + return executeTokenRequest(authorizationServerUrl, { + metadata, + tokenRequestParams, + clientInformation: clientInformation != null ? clientInformation : void 0, + addClientAuthentication: provider.addClientAuthentication, + resource, + fetchFn + }); +} +async function registerClient(authorizationServerUrl, { metadata, clientMetadata, scope, fetchFn }) { + let registrationUrl; + if (metadata) { + if (!metadata.registration_endpoint) { + throw new Error("Incompatible auth server: does not support dynamic client registration"); + } + registrationUrl = new URL(metadata.registration_endpoint); + } else { + registrationUrl = new URL("/register", authorizationServerUrl); + } + const response = await (fetchFn != null ? fetchFn : fetch)(registrationUrl, { + method: "POST", + headers: { + "Content-Type": "application/json" + }, + body: JSON.stringify({ + ...clientMetadata, + ...scope !== void 0 ? { scope } : {} + }) + }); + if (!response.ok) { + throw await parseErrorResponse(response); + } + return OAuthClientInformationFullSchema.parse(await response.json()); +} + +// node_modules/@modelcontextprotocol/sdk/dist/esm/client/sse.js +var SseError = class extends Error { + constructor(code, message, event) { + super(`SSE error: ${message}`); + this.code = code; + this.event = event; + } +}; +var SSEClientTransport = class { + constructor(url2, opts) { + this._url = url2; + this._resourceMetadataUrl = void 0; + this._scope = void 0; + this._eventSourceInit = opts == null ? void 0 : opts.eventSourceInit; + this._requestInit = opts == null ? void 0 : opts.requestInit; + this._authProvider = opts == null ? void 0 : opts.authProvider; + this._fetch = opts == null ? void 0 : opts.fetch; + this._fetchWithInit = createFetchWithInit(opts == null ? void 0 : opts.fetch, opts == null ? void 0 : opts.requestInit); + } + async _authThenStart() { + var _a3; + if (!this._authProvider) { + throw new UnauthorizedError("No auth provider"); + } + let result; + try { + result = await auth(this._authProvider, { + serverUrl: this._url, + resourceMetadataUrl: this._resourceMetadataUrl, + scope: this._scope, + fetchFn: this._fetchWithInit + }); + } catch (error48) { + (_a3 = this.onerror) == null ? void 0 : _a3.call(this, error48); + throw error48; + } + if (result !== "AUTHORIZED") { + throw new UnauthorizedError(); + } + return await this._startOrAuth(); + } + async _commonHeaders() { + var _a3; + const headers = {}; + if (this._authProvider) { + const tokens = await this._authProvider.tokens(); + if (tokens) { + headers["Authorization"] = `Bearer ${tokens.access_token}`; + } + } + if (this._protocolVersion) { + headers["mcp-protocol-version"] = this._protocolVersion; + } + const extraHeaders = normalizeHeaders((_a3 = this._requestInit) == null ? void 0 : _a3.headers); + return new Headers({ + ...headers, + ...extraHeaders + }); + } + _startOrAuth() { + var _a3, _b2, _c; + const fetchImpl = (_c = (_b2 = (_a3 = this == null ? void 0 : this._eventSourceInit) == null ? void 0 : _a3.fetch) != null ? _b2 : this._fetch) != null ? _c : fetch; + return new Promise((resolve5, reject) => { + this._eventSource = new EventSource(this._url.href, { + ...this._eventSourceInit, + fetch: async (url2, init) => { + const headers = await this._commonHeaders(); + headers.set("Accept", "text/event-stream"); + const response = await fetchImpl(url2, { + ...init, + headers + }); + if (response.status === 401 && response.headers.has("www-authenticate")) { + const { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(response); + this._resourceMetadataUrl = resourceMetadataUrl; + this._scope = scope; + } + return response; + } + }); + this._abortController = new AbortController(); + this._eventSource.onerror = (event) => { + var _a4; + if (event.code === 401 && this._authProvider) { + this._authThenStart().then(resolve5, reject); + return; + } + const error48 = new SseError(event.code, event.message, event); + reject(error48); + (_a4 = this.onerror) == null ? void 0 : _a4.call(this, error48); + }; + this._eventSource.onopen = () => { + }; + this._eventSource.addEventListener("endpoint", (event) => { + var _a4; + const messageEvent = event; + try { + this._endpoint = new URL(messageEvent.data, this._url); + if (this._endpoint.origin !== this._url.origin) { + throw new Error(`Endpoint origin does not match connection origin: ${this._endpoint.origin}`); + } + } catch (error48) { + reject(error48); + (_a4 = this.onerror) == null ? void 0 : _a4.call(this, error48); + void this.close(); + return; + } + resolve5(); + }); + this._eventSource.onmessage = (event) => { + var _a4, _b3; + const messageEvent = event; + let message; + try { + message = JSONRPCMessageSchema.parse(JSON.parse(messageEvent.data)); + } catch (error48) { + (_a4 = this.onerror) == null ? void 0 : _a4.call(this, error48); + return; + } + (_b3 = this.onmessage) == null ? void 0 : _b3.call(this, message); + }; + }); + } + async start() { + if (this._eventSource) { + throw new Error("SSEClientTransport already started! If using Client class, note that connect() calls start() automatically."); + } + return await this._startOrAuth(); + } + /** + * Call this method after the user has finished authorizing via their user agent and is redirected back to the MCP client application. This will exchange the authorization code for an access token, enabling the next connection attempt to successfully auth. + */ + async finishAuth(authorizationCode) { + if (!this._authProvider) { + throw new UnauthorizedError("No auth provider"); + } + const result = await auth(this._authProvider, { + serverUrl: this._url, + authorizationCode, + resourceMetadataUrl: this._resourceMetadataUrl, + scope: this._scope, + fetchFn: this._fetchWithInit + }); + if (result !== "AUTHORIZED") { + throw new UnauthorizedError("Failed to authorize"); + } + } + async close() { + var _a3, _b2, _c; + (_a3 = this._abortController) == null ? void 0 : _a3.abort(); + (_b2 = this._eventSource) == null ? void 0 : _b2.close(); + (_c = this.onclose) == null ? void 0 : _c.call(this); + } + async send(message) { + var _a3, _b2, _c, _d; + if (!this._endpoint) { + throw new Error("Not connected"); + } + try { + const headers = await this._commonHeaders(); + headers.set("content-type", "application/json"); + const init = { + ...this._requestInit, + method: "POST", + headers, + body: JSON.stringify(message), + signal: (_a3 = this._abortController) == null ? void 0 : _a3.signal + }; + const response = await ((_b2 = this._fetch) != null ? _b2 : fetch)(this._endpoint, init); + if (!response.ok) { + const text = await response.text().catch(() => null); + if (response.status === 401 && this._authProvider) { + const { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(response); + this._resourceMetadataUrl = resourceMetadataUrl; + this._scope = scope; + const result = await auth(this._authProvider, { + serverUrl: this._url, + resourceMetadataUrl: this._resourceMetadataUrl, + scope: this._scope, + fetchFn: this._fetchWithInit + }); + if (result !== "AUTHORIZED") { + throw new UnauthorizedError(); + } + return this.send(message); + } + throw new Error(`Error POSTing to endpoint (HTTP ${response.status}): ${text}`); + } + await ((_c = response.body) == null ? void 0 : _c.cancel()); + } catch (error48) { + (_d = this.onerror) == null ? void 0 : _d.call(this, error48); + throw error48; + } + } + setProtocolVersion(version2) { + this._protocolVersion = version2; + } +}; + +// node_modules/@modelcontextprotocol/sdk/dist/esm/client/stdio.js +var import_cross_spawn = __toESM(require_cross_spawn(), 1); +var import_node_process = __toESM(require("node:process"), 1); +var import_node_stream = require("node:stream"); + +// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js +var ReadBuffer = class { + append(chunk) { + this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk; + } + readMessage() { + if (!this._buffer) { + return null; + } + const index = this._buffer.indexOf("\n"); + if (index === -1) { + return null; + } + const line = this._buffer.toString("utf8", 0, index).replace(/\r$/, ""); + this._buffer = this._buffer.subarray(index + 1); + return deserializeMessage(line); + } + clear() { + this._buffer = void 0; + } +}; +function deserializeMessage(line) { + return JSONRPCMessageSchema.parse(JSON.parse(line)); +} +function serializeMessage(message) { + return JSON.stringify(message) + "\n"; +} + +// node_modules/@modelcontextprotocol/sdk/dist/esm/client/stdio.js +var DEFAULT_INHERITED_ENV_VARS = import_node_process.default.platform === "win32" ? [ + "APPDATA", + "HOMEDRIVE", + "HOMEPATH", + "LOCALAPPDATA", + "PATH", + "PROCESSOR_ARCHITECTURE", + "SYSTEMDRIVE", + "SYSTEMROOT", + "TEMP", + "USERNAME", + "USERPROFILE", + "PROGRAMFILES" +] : ( + /* list inspired by the default env inheritance of sudo */ + ["HOME", "LOGNAME", "PATH", "SHELL", "TERM", "USER"] +); +function getDefaultEnvironment() { + const env = {}; + for (const key of DEFAULT_INHERITED_ENV_VARS) { + const value = import_node_process.default.env[key]; + if (value === void 0) { + continue; + } + if (value.startsWith("()")) { + continue; + } + env[key] = value; + } + return env; +} +var StdioClientTransport = class { + constructor(server) { + this._readBuffer = new ReadBuffer(); + this._stderrStream = null; + this._serverParams = server; + if (server.stderr === "pipe" || server.stderr === "overlapped") { + this._stderrStream = new import_node_stream.PassThrough(); + } + } + /** + * Starts the server process and prepares to communicate with it. + */ + async start() { + if (this._process) { + throw new Error("StdioClientTransport already started! If using Client class, note that connect() calls start() automatically."); + } + return new Promise((resolve5, reject) => { + var _a3, _b2, _c, _d, _e; + this._process = (0, import_cross_spawn.default)(this._serverParams.command, (_a3 = this._serverParams.args) != null ? _a3 : [], { + // merge default env with server env because mcp server needs some env vars + env: { + ...getDefaultEnvironment(), + ...this._serverParams.env + }, + stdio: ["pipe", "pipe", (_b2 = this._serverParams.stderr) != null ? _b2 : "inherit"], + shell: false, + windowsHide: import_node_process.default.platform === "win32", + cwd: this._serverParams.cwd + }); + this._process.on("error", (error48) => { + var _a4; + reject(error48); + (_a4 = this.onerror) == null ? void 0 : _a4.call(this, error48); + }); + this._process.on("spawn", () => { + resolve5(); + }); + this._process.on("close", (_code) => { + var _a4; + this._process = void 0; + (_a4 = this.onclose) == null ? void 0 : _a4.call(this); + }); + (_c = this._process.stdin) == null ? void 0 : _c.on("error", (error48) => { + var _a4; + (_a4 = this.onerror) == null ? void 0 : _a4.call(this, error48); + }); + (_d = this._process.stdout) == null ? void 0 : _d.on("data", (chunk) => { + this._readBuffer.append(chunk); + this.processReadBuffer(); + }); + (_e = this._process.stdout) == null ? void 0 : _e.on("error", (error48) => { + var _a4; + (_a4 = this.onerror) == null ? void 0 : _a4.call(this, error48); + }); + if (this._stderrStream && this._process.stderr) { + this._process.stderr.pipe(this._stderrStream); + } + }); + } + /** + * The stderr stream of the child process, if `StdioServerParameters.stderr` was set to "pipe" or "overlapped". + * + * If stderr piping was requested, a PassThrough stream is returned _immediately_, allowing callers to + * attach listeners before the start method is invoked. This prevents loss of any early + * error output emitted by the child process. + */ + get stderr() { + var _a3, _b2; + if (this._stderrStream) { + return this._stderrStream; + } + return (_b2 = (_a3 = this._process) == null ? void 0 : _a3.stderr) != null ? _b2 : null; + } + /** + * The child process pid spawned by this transport. + * + * This is only available after the transport has been started. + */ + get pid() { + var _a3, _b2; + return (_b2 = (_a3 = this._process) == null ? void 0 : _a3.pid) != null ? _b2 : null; + } + processReadBuffer() { + var _a3, _b2; + while (true) { + try { + const message = this._readBuffer.readMessage(); + if (message === null) { + break; + } + (_a3 = this.onmessage) == null ? void 0 : _a3.call(this, message); + } catch (error48) { + (_b2 = this.onerror) == null ? void 0 : _b2.call(this, error48); + } + } + } + async close() { + var _a3; + if (this._process) { + const processToClose = this._process; + this._process = void 0; + const closePromise = new Promise((resolve5) => { + processToClose.once("close", () => { + resolve5(); + }); + }); + try { + (_a3 = processToClose.stdin) == null ? void 0 : _a3.end(); + } catch (e3) { + } + await Promise.race([closePromise, new Promise((resolve5) => setTimeout(resolve5, 2e3).unref())]); + if (processToClose.exitCode === null) { + try { + processToClose.kill("SIGTERM"); + } catch (e3) { + } + await Promise.race([closePromise, new Promise((resolve5) => setTimeout(resolve5, 2e3).unref())]); + } + if (processToClose.exitCode === null) { + try { + processToClose.kill("SIGKILL"); + } catch (e3) { + } + } + } + this._readBuffer.clear(); + } + send(message) { + return new Promise((resolve5) => { + var _a3; + if (!((_a3 = this._process) == null ? void 0 : _a3.stdin)) { + throw new Error("Not connected"); + } + const json2 = serializeMessage(message); + if (this._process.stdin.write(json2)) { + resolve5(); + } else { + this._process.stdin.once("drain", resolve5); + } + }); + } +}; + +// node_modules/eventsource-parser/dist/stream.js +var EventSourceParserStream = class extends TransformStream { + constructor({ onError, onRetry, onComment } = {}) { + let parser; + super({ + start(controller) { + parser = createParser({ + onEvent: (event) => { + controller.enqueue(event); + }, + onError(error48) { + onError === "terminate" ? controller.error(error48) : typeof onError == "function" && onError(error48); + }, + onRetry, + onComment + }); + }, + transform(chunk) { + parser.feed(chunk); + } + }); + } +}; + +// node_modules/@modelcontextprotocol/sdk/dist/esm/client/streamableHttp.js +var DEFAULT_STREAMABLE_HTTP_RECONNECTION_OPTIONS = { + initialReconnectionDelay: 1e3, + maxReconnectionDelay: 3e4, + reconnectionDelayGrowFactor: 1.5, + maxRetries: 2 +}; +var StreamableHTTPError = class extends Error { + constructor(code, message) { + super(`Streamable HTTP error: ${message}`); + this.code = code; + } +}; +var StreamableHTTPClientTransport = class { + constructor(url2, opts) { + var _a3; + this._hasCompletedAuthFlow = false; + this._url = url2; + this._resourceMetadataUrl = void 0; + this._scope = void 0; + this._requestInit = opts == null ? void 0 : opts.requestInit; + this._authProvider = opts == null ? void 0 : opts.authProvider; + this._fetch = opts == null ? void 0 : opts.fetch; + this._fetchWithInit = createFetchWithInit(opts == null ? void 0 : opts.fetch, opts == null ? void 0 : opts.requestInit); + this._sessionId = opts == null ? void 0 : opts.sessionId; + this._reconnectionOptions = (_a3 = opts == null ? void 0 : opts.reconnectionOptions) != null ? _a3 : DEFAULT_STREAMABLE_HTTP_RECONNECTION_OPTIONS; + } + async _authThenStart() { + var _a3; + if (!this._authProvider) { + throw new UnauthorizedError("No auth provider"); + } + let result; + try { + result = await auth(this._authProvider, { + serverUrl: this._url, + resourceMetadataUrl: this._resourceMetadataUrl, + scope: this._scope, + fetchFn: this._fetchWithInit + }); + } catch (error48) { + (_a3 = this.onerror) == null ? void 0 : _a3.call(this, error48); + throw error48; + } + if (result !== "AUTHORIZED") { + throw new UnauthorizedError(); + } + return await this._startOrAuthSse({ resumptionToken: void 0 }); + } + async _commonHeaders() { + var _a3; + const headers = {}; + if (this._authProvider) { + const tokens = await this._authProvider.tokens(); + if (tokens) { + headers["Authorization"] = `Bearer ${tokens.access_token}`; + } + } + if (this._sessionId) { + headers["mcp-session-id"] = this._sessionId; + } + if (this._protocolVersion) { + headers["mcp-protocol-version"] = this._protocolVersion; + } + const extraHeaders = normalizeHeaders((_a3 = this._requestInit) == null ? void 0 : _a3.headers); + return new Headers({ + ...headers, + ...extraHeaders + }); + } + async _startOrAuthSse(options) { + var _a3, _b2, _c, _d; + const { resumptionToken } = options; + try { + const headers = await this._commonHeaders(); + headers.set("Accept", "text/event-stream"); + if (resumptionToken) { + headers.set("last-event-id", resumptionToken); + } + const response = await ((_a3 = this._fetch) != null ? _a3 : fetch)(this._url, { + method: "GET", + headers, + signal: (_b2 = this._abortController) == null ? void 0 : _b2.signal + }); + if (!response.ok) { + await ((_c = response.body) == null ? void 0 : _c.cancel()); + if (response.status === 401 && this._authProvider) { + return await this._authThenStart(); + } + if (response.status === 405) { + return; + } + throw new StreamableHTTPError(response.status, `Failed to open SSE stream: ${response.statusText}`); + } + this._handleSseStream(response.body, options, true); + } catch (error48) { + (_d = this.onerror) == null ? void 0 : _d.call(this, error48); + throw error48; + } + } + /** + * Calculates the next reconnection delay using backoff algorithm + * + * @param attempt Current reconnection attempt count for the specific stream + * @returns Time to wait in milliseconds before next reconnection attempt + */ + _getNextReconnectionDelay(attempt) { + if (this._serverRetryMs !== void 0) { + return this._serverRetryMs; + } + const initialDelay = this._reconnectionOptions.initialReconnectionDelay; + const growFactor = this._reconnectionOptions.reconnectionDelayGrowFactor; + const maxDelay = this._reconnectionOptions.maxReconnectionDelay; + return Math.min(initialDelay * Math.pow(growFactor, attempt), maxDelay); + } + /** + * Schedule a reconnection attempt using server-provided retry interval or backoff + * + * @param lastEventId The ID of the last received event for resumability + * @param attemptCount Current reconnection attempt count for this specific stream + */ + _scheduleReconnection(options, attemptCount = 0) { + var _a3; + const maxRetries = this._reconnectionOptions.maxRetries; + if (attemptCount >= maxRetries) { + (_a3 = this.onerror) == null ? void 0 : _a3.call(this, new Error(`Maximum reconnection attempts (${maxRetries}) exceeded.`)); + return; + } + const delay = this._getNextReconnectionDelay(attemptCount); + this._reconnectionTimeout = setTimeout(() => { + this._startOrAuthSse(options).catch((error48) => { + var _a4; + (_a4 = this.onerror) == null ? void 0 : _a4.call(this, new Error(`Failed to reconnect SSE stream: ${error48 instanceof Error ? error48.message : String(error48)}`)); + this._scheduleReconnection(options, attemptCount + 1); + }); + }, delay); + } + _handleSseStream(stream, options, isReconnectable) { + if (!stream) { + return; + } + const { onresumptiontoken, replayMessageId } = options; + let lastEventId; + let hasPrimingEvent = false; + let receivedResponse = false; + const processStream = async () => { + var _a3, _b2, _c, _d; + try { + const reader = stream.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream({ + onRetry: (retryMs) => { + this._serverRetryMs = retryMs; + } + })).getReader(); + while (true) { + const { value: event, done } = await reader.read(); + if (done) { + break; + } + if (event.id) { + lastEventId = event.id; + hasPrimingEvent = true; + onresumptiontoken == null ? void 0 : onresumptiontoken(event.id); + } + if (!event.data) { + continue; + } + if (!event.event || event.event === "message") { + try { + const message = JSONRPCMessageSchema.parse(JSON.parse(event.data)); + if (isJSONRPCResultResponse(message)) { + receivedResponse = true; + if (replayMessageId !== void 0) { + message.id = replayMessageId; + } + } + (_a3 = this.onmessage) == null ? void 0 : _a3.call(this, message); + } catch (error48) { + (_b2 = this.onerror) == null ? void 0 : _b2.call(this, error48); + } + } + } + const canResume = isReconnectable || hasPrimingEvent; + const needsReconnect = canResume && !receivedResponse; + if (needsReconnect && this._abortController && !this._abortController.signal.aborted) { + this._scheduleReconnection({ + resumptionToken: lastEventId, + onresumptiontoken, + replayMessageId + }, 0); + } + } catch (error48) { + (_c = this.onerror) == null ? void 0 : _c.call(this, new Error(`SSE stream disconnected: ${error48}`)); + const canResume = isReconnectable || hasPrimingEvent; + const needsReconnect = canResume && !receivedResponse; + if (needsReconnect && this._abortController && !this._abortController.signal.aborted) { + try { + this._scheduleReconnection({ + resumptionToken: lastEventId, + onresumptiontoken, + replayMessageId + }, 0); + } catch (error49) { + (_d = this.onerror) == null ? void 0 : _d.call(this, new Error(`Failed to reconnect: ${error49 instanceof Error ? error49.message : String(error49)}`)); + } + } + } + }; + processStream(); + } + async start() { + if (this._abortController) { + throw new Error("StreamableHTTPClientTransport already started! If using Client class, note that connect() calls start() automatically."); + } + this._abortController = new AbortController(); + } + /** + * Call this method after the user has finished authorizing via their user agent and is redirected back to the MCP client application. This will exchange the authorization code for an access token, enabling the next connection attempt to successfully auth. + */ + async finishAuth(authorizationCode) { + if (!this._authProvider) { + throw new UnauthorizedError("No auth provider"); + } + const result = await auth(this._authProvider, { + serverUrl: this._url, + authorizationCode, + resourceMetadataUrl: this._resourceMetadataUrl, + scope: this._scope, + fetchFn: this._fetchWithInit + }); + if (result !== "AUTHORIZED") { + throw new UnauthorizedError("Failed to authorize"); + } + } + async close() { + var _a3, _b2; + if (this._reconnectionTimeout) { + clearTimeout(this._reconnectionTimeout); + this._reconnectionTimeout = void 0; + } + (_a3 = this._abortController) == null ? void 0 : _a3.abort(); + (_b2 = this.onclose) == null ? void 0 : _b2.call(this); + } + async send(message, options) { + var _a3, _b2, _c, _d, _e, _f, _g; + try { + const { resumptionToken, onresumptiontoken } = options || {}; + if (resumptionToken) { + this._startOrAuthSse({ resumptionToken, replayMessageId: isJSONRPCRequest(message) ? message.id : void 0 }).catch((err) => { + var _a4; + return (_a4 = this.onerror) == null ? void 0 : _a4.call(this, err); + }); + return; + } + const headers = await this._commonHeaders(); + headers.set("content-type", "application/json"); + headers.set("accept", "application/json, text/event-stream"); + const init = { + ...this._requestInit, + method: "POST", + headers, + body: JSON.stringify(message), + signal: (_a3 = this._abortController) == null ? void 0 : _a3.signal + }; + const response = await ((_b2 = this._fetch) != null ? _b2 : fetch)(this._url, init); + const sessionId = response.headers.get("mcp-session-id"); + if (sessionId) { + this._sessionId = sessionId; + } + if (!response.ok) { + const text = await response.text().catch(() => null); + if (response.status === 401 && this._authProvider) { + if (this._hasCompletedAuthFlow) { + throw new StreamableHTTPError(401, "Server returned 401 after successful authentication"); + } + const { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(response); + this._resourceMetadataUrl = resourceMetadataUrl; + this._scope = scope; + const result = await auth(this._authProvider, { + serverUrl: this._url, + resourceMetadataUrl: this._resourceMetadataUrl, + scope: this._scope, + fetchFn: this._fetchWithInit + }); + if (result !== "AUTHORIZED") { + throw new UnauthorizedError(); + } + this._hasCompletedAuthFlow = true; + return this.send(message); + } + if (response.status === 403 && this._authProvider) { + const { resourceMetadataUrl, scope, error: error48 } = extractWWWAuthenticateParams(response); + if (error48 === "insufficient_scope") { + const wwwAuthHeader = response.headers.get("WWW-Authenticate"); + if (this._lastUpscopingHeader === wwwAuthHeader) { + throw new StreamableHTTPError(403, "Server returned 403 after trying upscoping"); + } + if (scope) { + this._scope = scope; + } + if (resourceMetadataUrl) { + this._resourceMetadataUrl = resourceMetadataUrl; + } + this._lastUpscopingHeader = wwwAuthHeader != null ? wwwAuthHeader : void 0; + const result = await auth(this._authProvider, { + serverUrl: this._url, + resourceMetadataUrl: this._resourceMetadataUrl, + scope: this._scope, + fetchFn: this._fetch + }); + if (result !== "AUTHORIZED") { + throw new UnauthorizedError(); + } + return this.send(message); + } + } + throw new StreamableHTTPError(response.status, `Error POSTing to endpoint: ${text}`); + } + this._hasCompletedAuthFlow = false; + this._lastUpscopingHeader = void 0; + if (response.status === 202) { + await ((_c = response.body) == null ? void 0 : _c.cancel()); + if (isInitializedNotification(message)) { + this._startOrAuthSse({ resumptionToken: void 0 }).catch((err) => { + var _a4; + return (_a4 = this.onerror) == null ? void 0 : _a4.call(this, err); + }); + } + return; + } + const messages = Array.isArray(message) ? message : [message]; + const hasRequests = messages.filter((msg) => "method" in msg && "id" in msg && msg.id !== void 0).length > 0; + const contentType = response.headers.get("content-type"); + if (hasRequests) { + if (contentType == null ? void 0 : contentType.includes("text/event-stream")) { + this._handleSseStream(response.body, { onresumptiontoken }, false); + } else if (contentType == null ? void 0 : contentType.includes("application/json")) { + const data = await response.json(); + const responseMessages = Array.isArray(data) ? data.map((msg) => JSONRPCMessageSchema.parse(msg)) : [JSONRPCMessageSchema.parse(data)]; + for (const msg of responseMessages) { + (_d = this.onmessage) == null ? void 0 : _d.call(this, msg); + } + } else { + await ((_e = response.body) == null ? void 0 : _e.cancel()); + throw new StreamableHTTPError(-1, `Unexpected content type: ${contentType}`); + } + } else { + await ((_f = response.body) == null ? void 0 : _f.cancel()); + } + } catch (error48) { + (_g = this.onerror) == null ? void 0 : _g.call(this, error48); + throw error48; + } + } + get sessionId() { + return this._sessionId; + } + /** + * Terminates the current session by sending a DELETE request to the server. + * + * Clients that no longer need a particular session + * (e.g., because the user is leaving the client application) SHOULD send an + * HTTP DELETE to the MCP endpoint with the Mcp-Session-Id header to explicitly + * terminate the session. + * + * The server MAY respond with HTTP 405 Method Not Allowed, indicating that + * the server does not allow clients to terminate sessions. + */ + async terminateSession() { + var _a3, _b2, _c, _d; + if (!this._sessionId) { + return; + } + try { + const headers = await this._commonHeaders(); + const init = { + ...this._requestInit, + method: "DELETE", + headers, + signal: (_a3 = this._abortController) == null ? void 0 : _a3.signal + }; + const response = await ((_b2 = this._fetch) != null ? _b2 : fetch)(this._url, init); + await ((_c = response.body) == null ? void 0 : _c.cancel()); + if (!response.ok && response.status !== 405) { + throw new StreamableHTTPError(response.status, `Failed to terminate session: ${response.statusText}`); + } + this._sessionId = void 0; + } catch (error48) { + (_d = this.onerror) == null ? void 0 : _d.call(this, error48); + throw error48; + } + } + setProtocolVersion(version2) { + this._protocolVersion = version2; + } + get protocolVersion() { + return this._protocolVersion; + } + /** + * Resume an SSE stream from a previous event ID. + * Opens a GET SSE connection with Last-Event-ID header to replay missed events. + * + * @param lastEventId The event ID to resume from + * @param options Optional callback to receive new resumption tokens + */ + async resumeStream(lastEventId, options) { + await this._startOrAuthSse({ + resumptionToken: lastEventId, + onresumptiontoken: options == null ? void 0 : options.onresumptiontoken + }); + } +}; + +// src/core/mcp/McpTester.ts +var http = __toESM(require("http")); +var https = __toESM(require("https")); +init_env(); +function createNodeFetch() { + return async (input, init) => { + var _a3, _b2, _c; + const requestUrl = getRequestUrl(input); + const method = (_a3 = init == null ? void 0 : init.method) != null ? _a3 : input instanceof Request ? input.method : "GET"; + const headers = mergeHeaders(input, init); + const signal = (_b2 = init == null ? void 0 : init.signal) != null ? _b2 : input instanceof Request ? input.signal : void 0; + const body = await getRequestBody((_c = init == null ? void 0 : init.body) != null ? _c : input instanceof Request ? input.body : void 0); + const transport = requestUrl.protocol === "https:" ? https : http; + return new Promise((resolve5, reject) => { + let settled = false; + const fail = (error48) => { + if (settled) return; + settled = true; + signal == null ? void 0 : signal.removeEventListener("abort", onAbort); + reject(error48 instanceof Error ? error48 : new Error(String(error48))); + }; + const onAbort = () => { + var _a4; + req.destroy(new Error("Request aborted")); + fail((_a4 = signal == null ? void 0 : signal.reason) != null ? _a4 : new Error("Request aborted")); + }; + const requestHeaders = Object.fromEntries(headers.entries()); + if (body) { + requestHeaders["content-length"] = String(body.byteLength); + } + const req = transport.request( + requestUrl, + { + method, + headers: requestHeaders + }, + (res) => { + if (settled) return; + settled = true; + signal == null ? void 0 : signal.removeEventListener("abort", onAbort); + resolve5(createFetchResponse(res)); + } + ); + req.on("error", (error48) => fail(error48)); + if (signal) { + if (signal.aborted) { + onAbort(); + return; + } + signal.addEventListener("abort", onAbort, { once: true }); + } + if (body) { + req.end(body); + } else { + req.end(); + } + }); + }; +} +function createFetchResponse(res) { + var _a3, _b2, _c, _d; + const responseHeaders = new Headers(); + for (const [key, value] of Object.entries(res.headers)) { + if (value === void 0) continue; + if (Array.isArray(value)) { + for (const headerValue of value) { + responseHeaders.append(key, headerValue); + } + } else { + responseHeaders.append(key, value); + } + } + const body = new ReadableStream({ + start(controller) { + res.on("data", (chunk) => { + const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk; + controller.enqueue(new Uint8Array(buffer)); + }); + res.on("end", () => controller.close()); + res.on("error", (error48) => controller.error(error48)); + }, + cancel(reason) { + res.destroy(reason instanceof Error ? reason : new Error("Response body cancelled")); + } + }); + let bodyUsed = false; + const readAsText = async () => { + if (bodyUsed) { + throw new TypeError("Body has already been consumed"); + } + bodyUsed = true; + const reader = body.getReader(); + const chunks = []; + let total = 0; + let done = false; + try { + while (!done) { + const { value, done: streamDone } = await reader.read(); + done = streamDone; + if (done) break; + if (value) { + chunks.push(value); + total += value.byteLength; + } + } + } finally { + reader.releaseLock(); + } + const merged = new Uint8Array(total); + let offset = 0; + for (const chunk of chunks) { + merged.set(chunk, offset); + offset += chunk.byteLength; + } + return new TextDecoder().decode(merged); + }; + return { + ok: ((_a3 = res.statusCode) != null ? _a3 : 500) >= 200 && ((_b2 = res.statusCode) != null ? _b2 : 500) < 300, + status: (_c = res.statusCode) != null ? _c : 500, + statusText: (_d = res.statusMessage) != null ? _d : "", + headers: responseHeaders, + body, + text: readAsText, + json: async () => JSON.parse(await readAsText()) + }; +} +function getRequestUrl(input) { + if (input instanceof URL) { + return input; + } + if (typeof input === "string") { + return new URL(input); + } + return new URL(input.url); +} +function mergeHeaders(input, init) { + const headers = new Headers(input instanceof Request ? input.headers : void 0); + if (init == null ? void 0 : init.headers) { + const initHeaders = new Headers(init.headers); + for (const [key, value] of initHeaders.entries()) { + headers.set(key, value); + } + } + return headers; +} +async function getRequestBody(body) { + if (body === void 0 || body === null) { + return void 0; + } + const serialized = await new Response(body).arrayBuffer(); + return Buffer.from(serialized); +} +var nodeFetch = createNodeFetch(); +async function testMcpServer(server) { + var _a3; + const type = getMcpServerType(server.config); + let transport; + try { + if (type === "stdio") { + const config2 = server.config; + const { cmd, args } = parseCommand(config2.command, config2.args); + if (!cmd) { + return { success: false, tools: [], error: "Missing command" }; + } + transport = new StdioClientTransport({ + command: cmd, + args, + env: { ...process.env, ...config2.env, PATH: getEnhancedPath((_a3 = config2.env) == null ? void 0 : _a3.PATH) }, + stderr: "ignore" + }); + } else { + const config2 = server.config; + const url2 = new URL(config2.url); + const options = { + fetch: nodeFetch, + requestInit: config2.headers ? { headers: config2.headers } : void 0 + }; + transport = type === "sse" ? new SSEClientTransport(url2, options) : new StreamableHTTPClientTransport(url2, options); + } + } catch (error48) { + return { + success: false, + tools: [], + error: error48 instanceof Error ? error48.message : "Invalid server configuration" + }; + } + const client = new Client({ name: "claudian-tester", version: "1.0.0" }); + const controller = new AbortController(); + const timeout = setTimeout(() => controller.abort(), 1e4); + try { + await client.connect(transport, { signal: controller.signal }); + const serverVersion = client.getServerVersion(); + let tools = []; + try { + const result = await client.listTools(void 0, { signal: controller.signal }); + tools = result.tools.map((t3) => ({ + name: t3.name, + description: t3.description, + inputSchema: t3.inputSchema + })); + } catch (e3) { + } + return { + success: true, + serverName: serverVersion == null ? void 0 : serverVersion.name, + serverVersion: serverVersion == null ? void 0 : serverVersion.version, + tools + }; + } catch (error48) { + if (controller.signal.aborted) { + return { success: false, tools: [], error: "Connection timeout (10s)" }; + } + return { + success: false, + tools: [], + error: error48 instanceof Error ? error48.message : "Unknown error" + }; + } finally { + clearTimeout(timeout); + try { + await client.close(); + } catch (e3) { + } + } +} + +// src/features/settings/ui/McpServerModal.ts +var import_obsidian6 = require("obsidian"); +var McpServerModal = class extends import_obsidian6.Modal { + constructor(app, existingServer, onSave, initialType, prefillConfig) { + super(app); + this.serverName = ""; + this.serverType = "stdio"; + this.enabled = DEFAULT_MCP_SERVER.enabled; + this.contextSaving = DEFAULT_MCP_SERVER.contextSaving; + this.command = ""; + this.env = ""; + this.url = ""; + this.headers = ""; + this.typeFieldsEl = null; + this.nameInputEl = null; + this.existingServer = existingServer; + this.onSave = onSave; + if (existingServer) { + this.serverName = existingServer.name; + this.serverType = getMcpServerType(existingServer.config); + this.enabled = existingServer.enabled; + this.contextSaving = existingServer.contextSaving; + this.initFromConfig(existingServer.config); + } else if (prefillConfig) { + this.serverName = prefillConfig.name; + this.serverType = getMcpServerType(prefillConfig.config); + this.initFromConfig(prefillConfig.config); + } else if (initialType) { + this.serverType = initialType; + } + } + initFromConfig(config2) { + const type = getMcpServerType(config2); + if (type === "stdio") { + const stdioConfig = config2; + if (stdioConfig.args && stdioConfig.args.length > 0) { + this.command = stdioConfig.command + " " + stdioConfig.args.join(" "); + } else { + this.command = stdioConfig.command; + } + this.env = this.envRecordToString(stdioConfig.env); + } else { + const urlConfig = config2; + this.url = urlConfig.url; + this.headers = this.envRecordToString(urlConfig.headers); + } + } + onOpen() { + this.setTitle(this.existingServer ? "Edit MCP Server" : "Add MCP Server"); + this.modalEl.addClass("claudian-mcp-modal"); + const { contentEl } = this; + new import_obsidian6.Setting(contentEl).setName("Server name").setDesc("Unique identifier for this server").addText((text) => { + this.nameInputEl = text.inputEl; + text.setValue(this.serverName); + text.setPlaceholder("my-mcp-server"); + text.onChange((value) => { + this.serverName = value; + }); + text.inputEl.addEventListener("keydown", (e3) => this.handleKeyDown(e3)); + }); + new import_obsidian6.Setting(contentEl).setName("Type").setDesc("Server connection type").addDropdown((dropdown) => { + dropdown.addOption("stdio", "stdio (local command)"); + dropdown.addOption("sse", "sse (Server-Sent Events)"); + dropdown.addOption("http", "http (HTTP endpoint)"); + dropdown.setValue(this.serverType); + dropdown.onChange((value) => { + this.serverType = value; + this.renderTypeFields(); + }); + }); + this.typeFieldsEl = contentEl.createDiv({ cls: "claudian-mcp-type-fields" }); + this.renderTypeFields(); + new import_obsidian6.Setting(contentEl).setName("Enabled").setDesc("Whether this server is active").addToggle((toggle) => { + toggle.setValue(this.enabled); + toggle.onChange((value) => { + this.enabled = value; + }); + }); + new import_obsidian6.Setting(contentEl).setName("Context-saving mode").setDesc("Hide tools from agent unless @-mentioned (saves context window)").addToggle((toggle) => { + toggle.setValue(this.contextSaving); + toggle.onChange((value) => { + this.contextSaving = value; + }); + }); + const buttonContainer = contentEl.createDiv({ cls: "claudian-mcp-buttons" }); + const cancelBtn = buttonContainer.createEl("button", { + text: "Cancel", + cls: "claudian-cancel-btn" + }); + cancelBtn.addEventListener("click", () => this.close()); + const saveBtn = buttonContainer.createEl("button", { + text: this.existingServer ? "Update" : "Add", + cls: "claudian-save-btn mod-cta" + }); + saveBtn.addEventListener("click", () => this.save()); + } + renderTypeFields() { + if (!this.typeFieldsEl) return; + this.typeFieldsEl.empty(); + if (this.serverType === "stdio") { + this.renderStdioFields(); + } else { + this.renderUrlFields(); + } + } + renderStdioFields() { + if (!this.typeFieldsEl) return; + const cmdSetting = new import_obsidian6.Setting(this.typeFieldsEl).setName("Command").setDesc("Full command with arguments"); + cmdSetting.settingEl.addClass("claudian-mcp-cmd-setting"); + const cmdTextarea = cmdSetting.controlEl.createEl("textarea", { + cls: "claudian-mcp-cmd-textarea" + }); + cmdTextarea.value = this.command; + cmdTextarea.placeholder = "docker exec -i mcp-server python -m src.server"; + cmdTextarea.rows = 2; + cmdTextarea.addEventListener("input", () => { + this.command = cmdTextarea.value; + }); + const envSetting = new import_obsidian6.Setting(this.typeFieldsEl).setName("Environment variables").setDesc("KEY=VALUE per line (optional)"); + envSetting.settingEl.addClass("claudian-mcp-env-setting"); + const envTextarea = envSetting.controlEl.createEl("textarea", { + cls: "claudian-mcp-env-textarea" + }); + envTextarea.value = this.env; + envTextarea.placeholder = "API_KEY=your-key"; + envTextarea.rows = 2; + envTextarea.addEventListener("input", () => { + this.env = envTextarea.value; + }); + } + renderUrlFields() { + if (!this.typeFieldsEl) return; + new import_obsidian6.Setting(this.typeFieldsEl).setName("URL").setDesc(this.serverType === "sse" ? "SSE endpoint URL" : "HTTP endpoint URL").addText((text) => { + text.setValue(this.url); + text.setPlaceholder("http://localhost:3000/sse"); + text.onChange((value) => { + this.url = value; + }); + text.inputEl.addEventListener("keydown", (e3) => this.handleKeyDown(e3)); + }); + const headersSetting = new import_obsidian6.Setting(this.typeFieldsEl).setName("Headers").setDesc("HTTP headers (KEY=VALUE per line)"); + headersSetting.settingEl.addClass("claudian-mcp-env-setting"); + const headersTextarea = headersSetting.controlEl.createEl("textarea", { + cls: "claudian-mcp-env-textarea" + }); + headersTextarea.value = this.headers; + headersTextarea.placeholder = "Authorization=Bearer token\nContent-Type=application/json"; + headersTextarea.rows = 3; + headersTextarea.addEventListener("input", () => { + this.headers = headersTextarea.value; + }); + } + handleKeyDown(e3) { + if (e3.key === "Enter" && !e3.shiftKey && !e3.isComposing) { + e3.preventDefault(); + this.save(); + } else if (e3.key === "Escape" && !e3.isComposing) { + e3.preventDefault(); + this.close(); + } + } + save() { + var _a3, _b2, _c; + const name = this.serverName.trim(); + if (!name) { + new import_obsidian6.Notice("Please enter a server name"); + (_a3 = this.nameInputEl) == null ? void 0 : _a3.focus(); + return; + } + if (!/^[a-zA-Z0-9._-]+$/.test(name)) { + new import_obsidian6.Notice("Server name can only contain letters, numbers, dots, hyphens, and underscores"); + (_b2 = this.nameInputEl) == null ? void 0 : _b2.focus(); + return; + } + let config2; + if (this.serverType === "stdio") { + const fullCommand = this.command.trim(); + if (!fullCommand) { + new import_obsidian6.Notice("Please enter a command"); + return; + } + const { cmd, args } = parseCommand(fullCommand); + const stdioConfig = { command: cmd }; + if (args.length > 0) { + stdioConfig.args = args; + } + const env = this.parseEnvString(this.env); + if (Object.keys(env).length > 0) { + stdioConfig.env = env; + } + config2 = stdioConfig; + } else { + const url2 = this.url.trim(); + if (!url2) { + new import_obsidian6.Notice("Please enter a URL"); + return; + } + if (this.serverType === "sse") { + const sseConfig = { type: "sse", url: url2 }; + const headers = this.parseEnvString(this.headers); + if (Object.keys(headers).length > 0) { + sseConfig.headers = headers; + } + config2 = sseConfig; + } else { + const httpConfig = { type: "http", url: url2 }; + const headers = this.parseEnvString(this.headers); + if (Object.keys(headers).length > 0) { + httpConfig.headers = headers; + } + config2 = httpConfig; + } + } + const server = { + name, + config: config2, + enabled: this.enabled, + contextSaving: this.contextSaving, + disabledTools: (_c = this.existingServer) == null ? void 0 : _c.disabledTools + }; + this.onSave(server); + this.close(); + } + parseEnvString(envStr) { + const result = {}; + if (!envStr.trim()) return result; + for (const line of envStr.split("\n")) { + const trimmed = line.trim(); + if (!trimmed || trimmed.startsWith("#")) continue; + const eqIndex = trimmed.indexOf("="); + if (eqIndex === -1) continue; + const key = trimmed.substring(0, eqIndex).trim(); + const value = trimmed.substring(eqIndex + 1).trim(); + if (key) { + result[key] = value; + } + } + return result; + } + envRecordToString(env) { + if (!env) return ""; + return Object.entries(env).map(([key, value]) => `${key}=${value}`).join("\n"); + } + onClose() { + this.contentEl.empty(); + } +}; + +// src/features/settings/ui/McpTestModal.ts +var import_obsidian7 = require("obsidian"); +function formatToggleError(error48) { + if (!(error48 instanceof Error)) return "Failed to update tool setting"; + const msg = error48.message.toLowerCase(); + if (msg.includes("permission") || msg.includes("eacces")) { + return "Permission denied. Check .claude/ folder permissions."; + } + if (msg.includes("enospc") || msg.includes("disk full") || msg.includes("no space")) { + return "Disk full. Free up space and try again."; + } + if (msg.includes("json") || msg.includes("syntax")) { + return "Config file corrupted. Check .claude/mcp.json"; + } + return error48.message || "Failed to update tool setting"; +} +var McpTestModal = class extends import_obsidian7.Modal { + constructor(app, serverName, initialDisabledTools, onToolToggle, onBulkToggle) { + super(app); + this.result = null; + this.loading = true; + this.contentEl_ = null; + this.toolToggles = /* @__PURE__ */ new Map(); + this.toolElements = /* @__PURE__ */ new Map(); + this.toggleAllBtn = null; + this.pendingToggle = false; + this.serverName = serverName; + this.disabledTools = new Set( + (initialDisabledTools != null ? initialDisabledTools : []).map((tool) => tool.trim()).filter((tool) => tool.length > 0) + ); + this.onToolToggle = onToolToggle; + this.onBulkToggle = onBulkToggle; + } + onOpen() { + this.setTitle(`Verify: ${this.serverName}`); + this.modalEl.addClass("claudian-mcp-test-modal"); + this.contentEl_ = this.contentEl; + this.renderLoading(); + } + setResult(result) { + this.result = result; + this.loading = false; + this.render(); + } + setError(error48) { + this.result = { success: false, tools: [], error: error48 }; + this.loading = false; + this.render(); + } + renderLoading() { + if (!this.contentEl_) return; + this.contentEl_.empty(); + const loadingEl = this.contentEl_.createDiv({ cls: "claudian-mcp-test-loading" }); + const spinnerEl = loadingEl.createDiv({ cls: "claudian-mcp-test-spinner" }); + spinnerEl.innerHTML = ` + + `; + loadingEl.createSpan({ text: "Connecting to MCP server..." }); + } + render() { + if (!this.contentEl_) return; + this.contentEl_.empty(); + if (!this.result) { + this.renderLoading(); + return; + } + const statusEl = this.contentEl_.createDiv({ cls: "claudian-mcp-test-status" }); + const iconEl = statusEl.createSpan({ cls: "claudian-mcp-test-icon" }); + if (this.result.success) { + (0, import_obsidian7.setIcon)(iconEl, "check-circle"); + iconEl.addClass("success"); + } else { + (0, import_obsidian7.setIcon)(iconEl, "x-circle"); + iconEl.addClass("error"); + } + const textEl = statusEl.createSpan({ cls: "claudian-mcp-test-text" }); + if (this.result.success) { + let statusText = "Connected successfully"; + if (this.result.serverName) { + statusText += ` to ${this.result.serverName}`; + if (this.result.serverVersion) { + statusText += ` v${this.result.serverVersion}`; + } + } + textEl.setText(statusText); + } else { + textEl.setText("Connection failed"); + } + if (this.result.error) { + const errorEl = this.contentEl_.createDiv({ cls: "claudian-mcp-test-error" }); + errorEl.setText(this.result.error); + } + this.toolToggles.clear(); + this.toolElements.clear(); + if (this.result.tools.length > 0) { + const toolsSection = this.contentEl_.createDiv({ cls: "claudian-mcp-test-tools" }); + const toolsHeader = toolsSection.createDiv({ cls: "claudian-mcp-test-tools-header" }); + toolsHeader.setText(`Available Tools (${this.result.tools.length})`); + const toolsList = toolsSection.createDiv({ cls: "claudian-mcp-test-tools-list" }); + for (const tool of this.result.tools) { + this.renderTool(toolsList, tool); + } + } else if (this.result.success) { + const noToolsEl = this.contentEl_.createDiv({ cls: "claudian-mcp-test-no-tools" }); + noToolsEl.setText("No tools information available. Tools will be loaded when used in chat."); + } + const buttonContainer = this.contentEl_.createDiv({ cls: "claudian-mcp-test-buttons" }); + if (this.result.tools.length > 0 && this.onToolToggle) { + this.toggleAllBtn = buttonContainer.createEl("button", { + cls: "claudian-mcp-toggle-all-btn" + }); + this.updateToggleAllButton(); + this.toggleAllBtn.addEventListener("click", () => this.handleToggleAll()); + } + const closeBtn = buttonContainer.createEl("button", { + text: "Close", + cls: "mod-cta" + }); + closeBtn.addEventListener("click", () => this.close()); + } + renderTool(container, tool) { + const toolEl = container.createDiv({ cls: "claudian-mcp-test-tool" }); + const headerEl = toolEl.createDiv({ cls: "claudian-mcp-test-tool-header" }); + const iconEl = headerEl.createSpan({ cls: "claudian-mcp-test-tool-icon" }); + (0, import_obsidian7.setIcon)(iconEl, "wrench"); + const nameEl = headerEl.createSpan({ cls: "claudian-mcp-test-tool-name" }); + nameEl.setText(tool.name); + const toggleEl = headerEl.createDiv({ cls: "claudian-mcp-test-tool-toggle" }); + const toggleContainer = toggleEl.createDiv({ cls: "checkbox-container" }); + const checkbox = toggleContainer.createEl("input", { + type: "checkbox", + attr: { tabindex: "0" } + }); + const isEnabled = !this.disabledTools.has(tool.name); + checkbox.checked = isEnabled; + toggleContainer.toggleClass("is-enabled", isEnabled); + this.updateToolState(toolEl, isEnabled); + this.toolToggles.set(tool.name, { checkbox, container: toggleContainer }); + this.toolElements.set(tool.name, toolEl); + if (!this.onToolToggle) { + checkbox.disabled = true; + } else { + toggleContainer.addEventListener("click", (e3) => { + e3.preventDefault(); + e3.stopPropagation(); + if (checkbox.disabled) return; + checkbox.checked = !checkbox.checked; + this.handleToolToggle(tool.name, checkbox, toggleContainer); + }); + } + if (tool.description) { + const descEl = toolEl.createDiv({ cls: "claudian-mcp-test-tool-desc" }); + descEl.setText(tool.description); + } + } + async handleToolToggle(toolName, checkbox, container) { + var _a3; + const toolEl = this.toolElements.get(toolName); + if (!toolEl) return; + const wasDisabled = this.disabledTools.has(toolName); + const nextDisabled = !checkbox.checked; + if (nextDisabled) { + this.disabledTools.add(toolName); + } else { + this.disabledTools.delete(toolName); + } + container.toggleClass("is-enabled", !nextDisabled); + this.updateToolState(toolEl, !nextDisabled); + this.updateToggleAllButton(); + checkbox.disabled = true; + try { + await ((_a3 = this.onToolToggle) == null ? void 0 : _a3.call(this, toolName, !nextDisabled)); + } catch (error48) { + if (nextDisabled) { + this.disabledTools.delete(toolName); + } else { + this.disabledTools.add(toolName); + } + checkbox.checked = !wasDisabled; + container.toggleClass("is-enabled", !wasDisabled); + this.updateToolState(toolEl, !wasDisabled); + this.updateToggleAllButton(); + new import_obsidian7.Notice(formatToggleError(error48)); + } finally { + checkbox.disabled = false; + } + } + updateToolState(toolEl, enabled) { + toolEl.toggleClass("claudian-mcp-test-tool-disabled", !enabled); + } + updateToggleAllButton() { + if (!this.toggleAllBtn || !this.result) return; + const allEnabled = this.disabledTools.size === 0; + const allDisabled = this.disabledTools.size === this.result.tools.length; + if (allEnabled) { + this.toggleAllBtn.setText("Disable All"); + this.toggleAllBtn.toggleClass("is-destructive", true); + } else { + this.toggleAllBtn.setText(allDisabled ? "Enable All" : "Enable All"); + this.toggleAllBtn.toggleClass("is-destructive", false); + } + } + async handleToggleAll() { + if (!this.result || this.pendingToggle || !this.onBulkToggle) return; + const allEnabled = this.disabledTools.size === 0; + const previousDisabled = new Set(this.disabledTools); + const newDisabledTools = allEnabled ? this.result.tools.map((t3) => t3.name) : []; + this.pendingToggle = true; + if (this.toggleAllBtn) this.toggleAllBtn.disabled = true; + for (const { checkbox } of this.toolToggles.values()) { + checkbox.disabled = true; + } + this.disabledTools = new Set(newDisabledTools); + for (const tool of this.result.tools) { + const toggle = this.toolToggles.get(tool.name); + const toolEl = this.toolElements.get(tool.name); + if (!toggle || !toolEl) continue; + const isEnabled = !this.disabledTools.has(tool.name); + toggle.checkbox.checked = isEnabled; + toggle.container.toggleClass("is-enabled", isEnabled); + this.updateToolState(toolEl, isEnabled); + } + this.updateToggleAllButton(); + try { + await this.onBulkToggle(newDisabledTools); + } catch (error48) { + this.disabledTools = previousDisabled; + for (const tool of this.result.tools) { + const toggle = this.toolToggles.get(tool.name); + const toolEl = this.toolElements.get(tool.name); + if (!toggle || !toolEl) continue; + const isEnabled = !this.disabledTools.has(tool.name); + toggle.checkbox.checked = isEnabled; + toggle.container.toggleClass("is-enabled", isEnabled); + this.updateToolState(toolEl, isEnabled); + } + this.updateToggleAllButton(); + new import_obsidian7.Notice(formatToggleError(error48)); + } + for (const { checkbox } of this.toolToggles.values()) { + checkbox.disabled = false; + } + this.pendingToggle = false; + if (this.toggleAllBtn) this.toggleAllBtn.disabled = false; + } + onClose() { + this.contentEl.empty(); + } +}; + +// src/features/settings/ui/McpSettingsManager.ts +var McpSettingsManager = class { + constructor(containerEl, deps) { + this.servers = []; + this.app = deps.app; + this.containerEl = containerEl; + this.mcpStorage = deps.mcpStorage; + this.broadcastMcpReload = deps.broadcastMcpReload; + this.loadAndRender(); + } + async loadAndRender() { + this.servers = await this.mcpStorage.load(); + this.render(); + } + render() { + this.containerEl.empty(); + const headerEl = this.containerEl.createDiv({ cls: "claudian-mcp-header" }); + headerEl.createSpan({ text: "MCP Servers", cls: "claudian-mcp-label" }); + const addContainer = headerEl.createDiv({ cls: "claudian-mcp-add-container" }); + const addBtn = addContainer.createEl("button", { + cls: "claudian-settings-action-btn", + attr: { "aria-label": "Add" } + }); + (0, import_obsidian8.setIcon)(addBtn, "plus"); + const dropdown = addContainer.createDiv({ cls: "claudian-mcp-add-dropdown" }); + const stdioOption = dropdown.createDiv({ cls: "claudian-mcp-add-option" }); + (0, import_obsidian8.setIcon)(stdioOption.createSpan({ cls: "claudian-mcp-add-option-icon" }), "terminal"); + stdioOption.createSpan({ text: "stdio (local command)" }); + stdioOption.addEventListener("click", () => { + dropdown.removeClass("is-visible"); + this.openModal(null, "stdio"); + }); + const httpOption = dropdown.createDiv({ cls: "claudian-mcp-add-option" }); + (0, import_obsidian8.setIcon)(httpOption.createSpan({ cls: "claudian-mcp-add-option-icon" }), "globe"); + httpOption.createSpan({ text: "http / sse (remote)" }); + httpOption.addEventListener("click", () => { + dropdown.removeClass("is-visible"); + this.openModal(null, "http"); + }); + const importOption = dropdown.createDiv({ cls: "claudian-mcp-add-option" }); + (0, import_obsidian8.setIcon)(importOption.createSpan({ cls: "claudian-mcp-add-option-icon" }), "clipboard-paste"); + importOption.createSpan({ text: "Import from clipboard" }); + importOption.addEventListener("click", () => { + dropdown.removeClass("is-visible"); + this.importFromClipboard(); + }); + addBtn.addEventListener("click", (e3) => { + e3.stopPropagation(); + dropdown.toggleClass("is-visible", !dropdown.hasClass("is-visible")); + }); + document.addEventListener("click", () => { + dropdown.removeClass("is-visible"); + }); + if (this.servers.length === 0) { + const emptyEl = this.containerEl.createDiv({ cls: "claudian-mcp-empty" }); + emptyEl.setText('No MCP servers configured. Click "Add" to add one.'); + return; + } + const listEl = this.containerEl.createDiv({ cls: "claudian-mcp-list" }); + for (const server of this.servers) { + this.renderServerItem(listEl, server); + } + } + renderServerItem(listEl, server) { + const itemEl = listEl.createDiv({ cls: "claudian-mcp-item" }); + if (!server.enabled) { + itemEl.addClass("claudian-mcp-item-disabled"); + } + const statusEl = itemEl.createDiv({ cls: "claudian-mcp-status" }); + statusEl.addClass( + server.enabled ? "claudian-mcp-status-enabled" : "claudian-mcp-status-disabled" + ); + const infoEl = itemEl.createDiv({ cls: "claudian-mcp-info" }); + const nameRow = infoEl.createDiv({ cls: "claudian-mcp-name-row" }); + const nameEl = nameRow.createSpan({ cls: "claudian-mcp-name" }); + nameEl.setText(server.name); + const serverType = getMcpServerType(server.config); + const typeEl = nameRow.createSpan({ cls: "claudian-mcp-type-badge" }); + typeEl.setText(serverType); + if (server.contextSaving) { + const csEl = nameRow.createSpan({ cls: "claudian-mcp-context-saving-badge" }); + csEl.setText("@"); + csEl.setAttribute("title", "Context-saving: mention with @" + server.name + " to enable"); + } + const previewEl = infoEl.createDiv({ cls: "claudian-mcp-preview" }); + if (server.description) { + previewEl.setText(server.description); + } else { + previewEl.setText(this.getServerPreview(server, serverType)); + } + const actionsEl = itemEl.createDiv({ cls: "claudian-mcp-actions" }); + const testBtn = actionsEl.createEl("button", { + cls: "claudian-mcp-action-btn", + attr: { "aria-label": "Verify (show tools)" } + }); + (0, import_obsidian8.setIcon)(testBtn, "zap"); + testBtn.addEventListener("click", () => this.testServer(server)); + const toggleBtn = actionsEl.createEl("button", { + cls: "claudian-mcp-action-btn", + attr: { "aria-label": server.enabled ? "Disable" : "Enable" } + }); + (0, import_obsidian8.setIcon)(toggleBtn, server.enabled ? "toggle-right" : "toggle-left"); + toggleBtn.addEventListener("click", () => this.toggleServer(server)); + const editBtn = actionsEl.createEl("button", { + cls: "claudian-mcp-action-btn", + attr: { "aria-label": "Edit" } + }); + (0, import_obsidian8.setIcon)(editBtn, "pencil"); + editBtn.addEventListener("click", () => this.openModal(server)); + const deleteBtn = actionsEl.createEl("button", { + cls: "claudian-mcp-action-btn claudian-mcp-delete-btn", + attr: { "aria-label": "Delete" } + }); + (0, import_obsidian8.setIcon)(deleteBtn, "trash-2"); + deleteBtn.addEventListener("click", () => this.deleteServer(server)); + } + async testServer(server) { + const modal = new McpTestModal( + this.app, + server.name, + server.disabledTools, + async (toolName, enabled) => { + await this.updateDisabledTool(server, toolName, enabled); + }, + async (disabledTools) => { + await this.updateAllDisabledTools(server, disabledTools); + } + ); + modal.open(); + try { + const result = await testMcpServer(server); + modal.setResult(result); + } catch (error48) { + modal.setError(error48 instanceof Error ? error48.message : "Verification failed"); + } + } + /** Rolls back on save failure; warns on reload failure (since save succeeded). */ + async updateServerDisabledTools(server, newDisabledTools) { + const previous = server.disabledTools ? [...server.disabledTools] : void 0; + server.disabledTools = newDisabledTools; + try { + await this.mcpStorage.save(this.servers); + } catch (error48) { + server.disabledTools = previous; + throw error48; + } + try { + await this.broadcastMcpReload(); + } catch (e3) { + new import_obsidian8.Notice("Setting saved but reload failed. Changes will apply on next session."); + } + } + async updateDisabledTool(server, toolName, enabled) { + var _a3; + const disabledTools = new Set((_a3 = server.disabledTools) != null ? _a3 : []); + if (enabled) { + disabledTools.delete(toolName); + } else { + disabledTools.add(toolName); + } + await this.updateServerDisabledTools( + server, + disabledTools.size > 0 ? Array.from(disabledTools) : void 0 + ); + } + async updateAllDisabledTools(server, disabledTools) { + await this.updateServerDisabledTools( + server, + disabledTools.length > 0 ? disabledTools : void 0 + ); + } + getServerPreview(server, type) { + var _a3; + if (type === "stdio") { + const config2 = server.config; + const args = ((_a3 = config2.args) == null ? void 0 : _a3.join(" ")) || ""; + return args ? `${config2.command} ${args}` : config2.command; + } else { + const config2 = server.config; + return config2.url; + } + } + openModal(existing, initialType) { + const modal = new McpServerModal( + this.app, + existing, + async (server) => { + await this.saveServer(server, existing); + }, + initialType + ); + modal.open(); + } + async importFromClipboard() { + try { + const text = await navigator.clipboard.readText(); + if (!text.trim()) { + new import_obsidian8.Notice("Clipboard is empty"); + return; + } + const parsed = tryParseClipboardConfig(text); + if (!parsed || parsed.servers.length === 0) { + new import_obsidian8.Notice("No valid MCP configuration found in clipboard"); + return; + } + if (parsed.needsName || parsed.servers.length === 1) { + const server = parsed.servers[0]; + const type = getMcpServerType(server.config); + const modal = new McpServerModal( + this.app, + null, + async (savedServer) => { + await this.saveServer(savedServer, null); + }, + type, + server + // Pre-fill with parsed config + ); + modal.open(); + if (parsed.needsName) { + new import_obsidian8.Notice("Enter a name for the server"); + } + return; + } + await this.importServers(parsed.servers); + } catch (e3) { + new import_obsidian8.Notice("Failed to read clipboard"); + } + } + async saveServer(server, existing) { + if (existing) { + const index = this.servers.findIndex((s3) => s3.name === existing.name); + if (index !== -1) { + if (server.name !== existing.name) { + const conflict = this.servers.find((s3) => s3.name === server.name); + if (conflict) { + new import_obsidian8.Notice(`Server "${server.name}" already exists`); + return; + } + } + this.servers[index] = server; + } + } else { + const conflict = this.servers.find((s3) => s3.name === server.name); + if (conflict) { + new import_obsidian8.Notice(`Server "${server.name}" already exists`); + return; + } + this.servers.push(server); + } + await this.mcpStorage.save(this.servers); + await this.broadcastMcpReload(); + this.render(); + new import_obsidian8.Notice(existing ? `MCP server "${server.name}" updated` : `MCP server "${server.name}" added`); + } + async importServers(servers) { + const added = []; + const skipped = []; + for (const server of servers) { + const name = server.name.trim(); + if (!name || !/^[a-zA-Z0-9._-]+$/.test(name)) { + skipped.push(server.name || ""); + continue; + } + const conflict = this.servers.find((s3) => s3.name === name); + if (conflict) { + skipped.push(name); + continue; + } + this.servers.push({ + name, + config: server.config, + enabled: DEFAULT_MCP_SERVER.enabled, + contextSaving: DEFAULT_MCP_SERVER.contextSaving + }); + added.push(name); + } + if (added.length === 0) { + new import_obsidian8.Notice("No new MCP servers imported"); + return; + } + await this.mcpStorage.save(this.servers); + await this.broadcastMcpReload(); + this.render(); + let message = `Imported ${added.length} MCP server${added.length > 1 ? "s" : ""}`; + if (skipped.length > 0) { + message += ` (${skipped.length} skipped)`; + } + new import_obsidian8.Notice(message); + } + async toggleServer(server) { + server.enabled = !server.enabled; + await this.mcpStorage.save(this.servers); + await this.broadcastMcpReload(); + this.render(); + new import_obsidian8.Notice(`MCP server "${server.name}" ${server.enabled ? "enabled" : "disabled"}`); + } + async deleteServer(server) { + if (!confirm(`Delete MCP server "${server.name}"?`)) { + return; + } + this.servers = this.servers.filter((s3) => s3.name !== server.name); + await this.mcpStorage.save(this.servers); + await this.broadcastMcpReload(); + this.render(); + new import_obsidian8.Notice(`MCP server "${server.name}" deleted`); + } + /** Refresh the server list (call after external changes). */ + refresh() { + this.loadAndRender(); + } +}; + +// src/providers/claude/ui/ClaudeSettingsTab.ts +init_env(); +init_path(); + +// src/providers/claude/ui/AgentSettings.ts +var import_obsidian10 = require("obsidian"); + +// src/shared/modals/ConfirmModal.ts +var import_obsidian9 = require("obsidian"); +function confirmDelete(app, message) { + return new Promise((resolve5) => { + new ConfirmModal(app, message, resolve5).open(); + }); +} +function confirm2(app, message, confirmText) { + return new Promise((resolve5) => { + new ConfirmModal(app, message, resolve5, confirmText).open(); + }); +} +var ConfirmModal = class extends import_obsidian9.Modal { + constructor(app, message, resolve5, confirmText) { + super(app); + this.resolved = false; + this.message = message; + this.resolve = resolve5; + this.confirmText = confirmText != null ? confirmText : t("common.delete"); + } + onOpen() { + this.setTitle(t("common.confirm")); + this.modalEl.addClass("claudian-confirm-modal"); + this.contentEl.createEl("p", { text: this.message }); + new import_obsidian9.Setting(this.contentEl).addButton( + (btn) => btn.setButtonText(t("common.cancel")).onClick(() => this.close()) + ).addButton( + (btn) => btn.setButtonText(this.confirmText).setWarning().onClick(() => { + this.resolved = true; + this.resolve(true); + this.close(); + }) + ); + } + onClose() { + if (!this.resolved) { + this.resolve(false); + } + this.contentEl.empty(); + } +}; + +// src/providers/claude/ui/AgentSettings.ts +var MODEL_OPTIONS = [ + { value: "inherit", label: "Inherit" }, + { value: "sonnet", label: "Sonnet" }, + { value: "opus", label: "Opus" }, + { value: "haiku", label: "Haiku" } +]; +var AgentModal = class extends import_obsidian10.Modal { + constructor(app, existingAgent, getAvailableAgents, onSave) { + super(app); + this.existingAgent = existingAgent; + this.getAvailableAgents = getAvailableAgents; + this.onSave = onSave; + } + onOpen() { + var _a3, _b2, _c, _d, _e, _f, _g, _h, _i, _j2; + this.setTitle( + this.existingAgent ? t("settings.subagents.modal.titleEdit") : t("settings.subagents.modal.titleAdd") + ); + this.modalEl.addClass("claudian-sp-modal"); + const { contentEl } = this; + let nameInput; + let descInput; + let modelValue = (_b2 = (_a3 = this.existingAgent) == null ? void 0 : _a3.model) != null ? _b2 : "inherit"; + let toolsInput; + let disallowedToolsInput; + let skillsInput; + new import_obsidian10.Setting(contentEl).setName(t("settings.subagents.modal.name")).setDesc(t("settings.subagents.modal.nameDesc")).addText((text) => { + var _a4; + nameInput = text.inputEl; + text.setValue(((_a4 = this.existingAgent) == null ? void 0 : _a4.name) || "").setPlaceholder(t("settings.subagents.modal.namePlaceholder")); + }); + new import_obsidian10.Setting(contentEl).setName(t("settings.subagents.modal.description")).setDesc(t("settings.subagents.modal.descriptionDesc")).addText((text) => { + var _a4; + descInput = text.inputEl; + text.setValue(((_a4 = this.existingAgent) == null ? void 0 : _a4.description) || "").setPlaceholder(t("settings.subagents.modal.descriptionPlaceholder")); + }); + const details = contentEl.createEl("details", { cls: "claudian-sp-advanced-section" }); + details.createEl("summary", { + text: t("settings.subagents.modal.advancedOptions"), + cls: "claudian-sp-advanced-summary" + }); + if (((_c = this.existingAgent) == null ? void 0 : _c.model) && this.existingAgent.model !== "inherit" || ((_e = (_d = this.existingAgent) == null ? void 0 : _d.tools) == null ? void 0 : _e.length) || ((_g = (_f = this.existingAgent) == null ? void 0 : _f.disallowedTools) == null ? void 0 : _g.length) || ((_i = (_h = this.existingAgent) == null ? void 0 : _h.skills) == null ? void 0 : _i.length)) { + details.open = true; + } + new import_obsidian10.Setting(details).setName(t("settings.subagents.modal.model")).setDesc(t("settings.subagents.modal.modelDesc")).addDropdown((dropdown) => { + for (const opt of MODEL_OPTIONS) { + dropdown.addOption(opt.value, opt.label); + } + dropdown.setValue(modelValue).onChange((value) => { + modelValue = value; + }); + }); + new import_obsidian10.Setting(details).setName(t("settings.subagents.modal.tools")).setDesc(t("settings.subagents.modal.toolsDesc")).addText((text) => { + var _a4, _b3; + toolsInput = text.inputEl; + text.setValue(((_b3 = (_a4 = this.existingAgent) == null ? void 0 : _a4.tools) == null ? void 0 : _b3.join(", ")) || ""); + }); + new import_obsidian10.Setting(details).setName(t("settings.subagents.modal.disallowedTools")).setDesc(t("settings.subagents.modal.disallowedToolsDesc")).addText((text) => { + var _a4, _b3; + disallowedToolsInput = text.inputEl; + text.setValue(((_b3 = (_a4 = this.existingAgent) == null ? void 0 : _a4.disallowedTools) == null ? void 0 : _b3.join(", ")) || ""); + }); + new import_obsidian10.Setting(details).setName(t("settings.subagents.modal.skills")).setDesc(t("settings.subagents.modal.skillsDesc")).addText((text) => { + var _a4, _b3; + skillsInput = text.inputEl; + text.setValue(((_b3 = (_a4 = this.existingAgent) == null ? void 0 : _a4.skills) == null ? void 0 : _b3.join(", ")) || ""); + }); + new import_obsidian10.Setting(contentEl).setName(t("settings.subagents.modal.prompt")).setDesc(t("settings.subagents.modal.promptDesc")); + const contentArea = contentEl.createEl("textarea", { + cls: "claudian-sp-content-area", + attr: { + rows: "10", + placeholder: t("settings.subagents.modal.promptPlaceholder") + } + }); + contentArea.value = ((_j2 = this.existingAgent) == null ? void 0 : _j2.prompt) || ""; + const buttonContainer = contentEl.createDiv({ cls: "claudian-sp-modal-buttons" }); + const cancelBtn = buttonContainer.createEl("button", { + text: t("common.cancel"), + cls: "claudian-cancel-btn" + }); + cancelBtn.addEventListener("click", () => this.close()); + const saveBtn = buttonContainer.createEl("button", { + text: t("common.save"), + cls: "claudian-save-btn" + }); + saveBtn.addEventListener("click", async () => { + var _a4, _b3, _c2, _d2; + const name = nameInput.value.trim(); + const nameError = validateAgentName(name); + if (nameError) { + new import_obsidian10.Notice(nameError); + return; + } + const description = descInput.value.trim(); + if (!description) { + new import_obsidian10.Notice(t("settings.subagents.descriptionRequired")); + return; + } + const prompt = contentArea.value; + if (!prompt.trim()) { + new import_obsidian10.Notice(t("settings.subagents.promptRequired")); + return; + } + const allAgents = this.getAvailableAgents(); + const duplicate = allAgents.find( + (a3) => { + var _a5; + return a3.id.toLowerCase() === name.toLowerCase() && a3.id !== ((_a5 = this.existingAgent) == null ? void 0 : _a5.id); + } + ); + if (duplicate) { + new import_obsidian10.Notice(t("settings.subagents.duplicateName", { name })); + return; + } + const parseList = (input) => { + const val = input.value.trim(); + if (!val) return void 0; + return val.split(",").map((s3) => s3.trim()).filter(Boolean); + }; + const agent = { + id: name, + name, + description, + prompt, + tools: parseList(toolsInput), + disallowedTools: parseList(disallowedToolsInput), + model: modelValue || "inherit", + source: "vault", + filePath: (_a4 = this.existingAgent) == null ? void 0 : _a4.filePath, + skills: parseList(skillsInput), + permissionMode: (_b3 = this.existingAgent) == null ? void 0 : _b3.permissionMode, + hooks: (_c2 = this.existingAgent) == null ? void 0 : _c2.hooks, + extraFrontmatter: (_d2 = this.existingAgent) == null ? void 0 : _d2.extraFrontmatter + }; + try { + await this.onSave(agent); + } catch (err) { + const message = err instanceof Error ? err.message : "Unknown error"; + new import_obsidian10.Notice(t("settings.subagents.saveFailed", { message })); + return; + } + this.close(); + }); + } + onClose() { + this.contentEl.empty(); + } +}; +var AgentSettings = class { + constructor(containerEl, deps) { + this.app = deps.app; + this.containerEl = containerEl; + this.agentManager = deps.agentManager; + this.agentStorage = deps.agentStorage; + this.render(); + } + render() { + this.containerEl.empty(); + const headerEl = this.containerEl.createDiv({ cls: "claudian-sp-header" }); + headerEl.createSpan({ text: t("settings.subagents.name"), cls: "claudian-sp-label" }); + const actionsEl = headerEl.createDiv({ cls: "claudian-sp-header-actions" }); + const refreshBtn = actionsEl.createEl("button", { + cls: "claudian-settings-action-btn", + attr: { "aria-label": t("common.refresh") } + }); + (0, import_obsidian10.setIcon)(refreshBtn, "refresh-cw"); + refreshBtn.addEventListener("click", () => { + void this.refreshAgents(); + }); + const addBtn = actionsEl.createEl("button", { + cls: "claudian-settings-action-btn", + attr: { "aria-label": t("common.add") } + }); + (0, import_obsidian10.setIcon)(addBtn, "plus"); + addBtn.addEventListener("click", () => { + void this.openAgentModal(null); + }); + const allAgents = this.agentManager.getAvailableAgents(); + const vaultAgents = allAgents.filter((a3) => a3.source === "vault"); + if (vaultAgents.length === 0) { + const emptyEl = this.containerEl.createDiv({ cls: "claudian-sp-empty-state" }); + emptyEl.setText(t("settings.subagents.noAgents")); + return; + } + const listEl = this.containerEl.createDiv({ cls: "claudian-sp-list" }); + for (const agent of vaultAgents) { + this.renderAgentItem(listEl, agent); + } + } + renderAgentItem(listEl, agent) { + const itemEl = listEl.createDiv({ cls: "claudian-sp-item" }); + const infoEl = itemEl.createDiv({ cls: "claudian-sp-info" }); + const headerRow = infoEl.createDiv({ cls: "claudian-sp-item-header" }); + const nameEl = headerRow.createSpan({ cls: "claudian-sp-item-name" }); + nameEl.setText(agent.name); + if (agent.description) { + const descEl = infoEl.createDiv({ cls: "claudian-sp-item-desc" }); + descEl.setText(agent.description); + } + const actionsEl = itemEl.createDiv({ cls: "claudian-sp-item-actions" }); + const editBtn = actionsEl.createEl("button", { + cls: "claudian-settings-action-btn", + attr: { "aria-label": t("common.edit") } + }); + (0, import_obsidian10.setIcon)(editBtn, "pencil"); + editBtn.addEventListener("click", () => { + void this.openAgentModal(agent); + }); + const deleteBtn = actionsEl.createEl("button", { + cls: "claudian-settings-action-btn claudian-settings-delete-btn", + attr: { "aria-label": t("common.delete") } + }); + (0, import_obsidian10.setIcon)(deleteBtn, "trash-2"); + deleteBtn.addEventListener("click", async () => { + const confirmed = await confirmDelete( + this.app, + t("settings.subagents.deleteConfirm", { name: agent.name }) + ); + if (!confirmed) return; + try { + await this.deleteAgent(agent); + } catch (err) { + const message = err instanceof Error ? err.message : "Unknown error"; + new import_obsidian10.Notice(t("settings.subagents.deleteFailed", { message })); + } + }); + } + async refreshAgents() { + try { + await this.agentManager.loadAgents(); + this.render(); + } catch (err) { + const message = err instanceof Error ? err.message : "Unknown error"; + new import_obsidian10.Notice(t("settings.subagents.refreshFailed", { message })); + } + } + async openAgentModal(existingAgent) { + var _a3; + let fresh; + if (existingAgent) { + try { + fresh = (_a3 = await this.agentStorage.load(existingAgent)) != null ? _a3 : existingAgent; + } catch (err) { + const message = err instanceof Error ? err.message : "Unknown error"; + new import_obsidian10.Notice(`Failed to load subagent "${existingAgent.name}": ${message}`); + return; + } + } else { + fresh = null; + } + new AgentModal( + this.app, + fresh, + () => this.agentManager.getAvailableAgents(), + (agent) => this.saveAgent(agent, fresh) + ).open(); + } + async saveAgent(agent, existing) { + if (existing && existing.name !== agent.name) { + await this.agentStorage.save({ ...agent, filePath: void 0 }); + try { + await this.agentStorage.delete(existing); + } catch (e3) { + new import_obsidian10.Notice(t("settings.subagents.renameCleanupFailed", { name: existing.name })); + } + } else { + await this.agentStorage.save(agent); + } + try { + await this.agentManager.loadAgents(); + } catch (e3) { + } + this.render(); + new import_obsidian10.Notice( + existing ? t("settings.subagents.updated", { name: agent.name }) : t("settings.subagents.created", { name: agent.name }) + ); + } + async deleteAgent(agent) { + await this.agentStorage.delete(agent); + try { + await this.agentManager.loadAgents(); + } catch (e3) { + } + this.render(); + new import_obsidian10.Notice(t("settings.subagents.deleted", { name: agent.name })); + } +}; + +// src/providers/claude/ui/PluginSettingsManager.ts +var import_obsidian11 = require("obsidian"); +var PluginSettingsManager = class { + constructor(containerEl, deps) { + this.containerEl = containerEl; + this.pluginManager = deps.pluginManager; + this.agentManager = deps.agentManager; + this.restartTabs = deps.restartTabs; + this.render(); + } + render() { + this.containerEl.empty(); + const headerEl = this.containerEl.createDiv({ cls: "claudian-plugin-header" }); + headerEl.createSpan({ text: "Claude Code Plugins", cls: "claudian-plugin-label" }); + const refreshBtn = headerEl.createEl("button", { + cls: "claudian-settings-action-btn", + attr: { "aria-label": "Refresh" } + }); + (0, import_obsidian11.setIcon)(refreshBtn, "refresh-cw"); + refreshBtn.addEventListener("click", () => this.refreshPlugins()); + const plugins = this.pluginManager.getPlugins(); + if (plugins.length === 0) { + const emptyEl = this.containerEl.createDiv({ cls: "claudian-plugin-empty" }); + emptyEl.setText("No Claude Code plugins found. Enable plugins via the Claude CLI."); + return; + } + const projectPlugins = plugins.filter((p) => p.scope === "project"); + const userPlugins = plugins.filter((p) => p.scope === "user"); + const listEl = this.containerEl.createDiv({ cls: "claudian-plugin-list" }); + if (projectPlugins.length > 0) { + const sectionHeader = listEl.createDiv({ cls: "claudian-plugin-section-header" }); + sectionHeader.setText("Project Plugins"); + for (const plugin of projectPlugins) { + this.renderPluginItem(listEl, plugin); + } + } + if (userPlugins.length > 0) { + const sectionHeader = listEl.createDiv({ cls: "claudian-plugin-section-header" }); + sectionHeader.setText("User Plugins"); + for (const plugin of userPlugins) { + this.renderPluginItem(listEl, plugin); + } + } + } + renderPluginItem(listEl, plugin) { + const itemEl = listEl.createDiv({ cls: "claudian-plugin-item" }); + if (!plugin.enabled) { + itemEl.addClass("claudian-plugin-item-disabled"); + } + const statusEl = itemEl.createDiv({ cls: "claudian-plugin-status" }); + if (plugin.enabled) { + statusEl.addClass("claudian-plugin-status-enabled"); + } else { + statusEl.addClass("claudian-plugin-status-disabled"); + } + const infoEl = itemEl.createDiv({ cls: "claudian-plugin-info" }); + const nameRow = infoEl.createDiv({ cls: "claudian-plugin-name-row" }); + const nameEl = nameRow.createSpan({ cls: "claudian-plugin-name" }); + nameEl.setText(plugin.name); + const actionsEl = itemEl.createDiv({ cls: "claudian-plugin-actions" }); + const toggleBtn = actionsEl.createEl("button", { + cls: "claudian-plugin-action-btn", + attr: { "aria-label": plugin.enabled ? "Disable" : "Enable" } + }); + (0, import_obsidian11.setIcon)(toggleBtn, plugin.enabled ? "toggle-right" : "toggle-left"); + toggleBtn.addEventListener("click", () => this.togglePlugin(plugin.id)); + } + async togglePlugin(pluginId) { + var _a3; + const plugin = this.pluginManager.getPlugins().find((p) => p.id === pluginId); + const wasEnabled = (_a3 = plugin == null ? void 0 : plugin.enabled) != null ? _a3 : false; + try { + await this.pluginManager.togglePlugin(pluginId); + await this.agentManager.loadAgents(); + try { + await this.restartTabs(); + } catch (e3) { + new import_obsidian11.Notice("Plugin toggled, but some tabs failed to restart."); + } + new import_obsidian11.Notice(`Plugin "${pluginId}" ${wasEnabled ? "disabled" : "enabled"}`); + } catch (err) { + await this.pluginManager.togglePlugin(pluginId); + const message = err instanceof Error ? err.message : "Unknown error"; + new import_obsidian11.Notice(`Failed to toggle plugin: ${message}`); + } finally { + this.render(); + } + } + async refreshPlugins() { + try { + await this.pluginManager.loadPlugins(); + await this.agentManager.loadAgents(); + new import_obsidian11.Notice("Plugin list refreshed"); + } catch (err) { + const message = err instanceof Error ? err.message : "Unknown error"; + new import_obsidian11.Notice(`Failed to refresh plugins: ${message}`); + } finally { + this.render(); + } + } + refresh() { + this.render(); + } +}; + +// src/providers/claude/ui/SlashCommandSettings.ts +var import_obsidian12 = require("obsidian"); +function resolveAllowedTools(inputValue, parsedTools) { + const trimmed = inputValue.trim(); + if (trimmed) { + return trimmed.split(",").map((s3) => s3.trim()).filter(Boolean); + } + if (parsedTools && parsedTools.length > 0) { + return parsedTools; + } + return void 0; +} +function isSkillEntry(entry) { + return entry.kind === "skill"; +} +var SlashCommandModal = class extends import_obsidian12.Modal { + constructor(app, entries, existingEntry, onSave) { + super(app); + this.entries = entries; + this.existingEntry = existingEntry; + this.onSave = onSave; + } + onOpen() { + var _a3, _b2, _c, _d, _e, _f, _g, _h, _i, _j2, _k, _l, _m; + const existingIsSkill = this.existingEntry ? isSkillEntry(this.existingEntry) : false; + let selectedType = existingIsSkill ? "skill" : "command"; + const typeLabel = () => selectedType === "skill" ? "Skill" : "Slash Command"; + this.setTitle(this.existingEntry ? `Edit ${typeLabel()}` : `Add ${typeLabel()}`); + this.modalEl.addClass("claudian-sp-modal"); + const { contentEl } = this; + let nameInput; + let descInput; + let hintInput; + let modelInput; + let toolsInput; + let disableModelToggle = (_b2 = (_a3 = this.existingEntry) == null ? void 0 : _a3.disableModelInvocation) != null ? _b2 : false; + let disableUserInvocation = ((_c = this.existingEntry) == null ? void 0 : _c.userInvocable) === false; + let contextValue = (_e = (_d = this.existingEntry) == null ? void 0 : _d.context) != null ? _e : ""; + let agentInput; + let disableUserSetting; + let disableUserToggle; + const updateSkillOnlyFields = () => { + const isSkillType = selectedType === "skill"; + disableUserSetting.settingEl.style.display = isSkillType ? "" : "none"; + if (!isSkillType) { + disableUserInvocation = false; + disableUserToggle.setValue(false); + } + }; + new import_obsidian12.Setting(contentEl).setName("Type").setDesc("Command or skill").addDropdown((dropdown) => { + dropdown.addOption("command", "Command").addOption("skill", "Skill").setValue(selectedType).onChange((value) => { + selectedType = value; + this.setTitle(this.existingEntry ? `Edit ${typeLabel()}` : `Add ${typeLabel()}`); + updateSkillOnlyFields(); + }); + if (this.existingEntry) { + dropdown.setDisabled(true); + } + }); + new import_obsidian12.Setting(contentEl).setName("Command name").setDesc('The name used after / (e.g., "review" for /review)').addText((text) => { + var _a4; + nameInput = text.inputEl; + text.setValue(((_a4 = this.existingEntry) == null ? void 0 : _a4.name) || "").setPlaceholder("review-code"); + }); + new import_obsidian12.Setting(contentEl).setName("Description").setDesc("Optional description shown in dropdown").addText((text) => { + var _a4; + descInput = text.inputEl; + text.setValue(((_a4 = this.existingEntry) == null ? void 0 : _a4.description) || ""); + }); + const details = contentEl.createEl("details", { cls: "claudian-sp-advanced-section" }); + details.createEl("summary", { + text: "Advanced options", + cls: "claudian-sp-advanced-summary" + }); + if (((_f = this.existingEntry) == null ? void 0 : _f.argumentHint) || ((_g = this.existingEntry) == null ? void 0 : _g.model) || ((_i = (_h = this.existingEntry) == null ? void 0 : _h.allowedTools) == null ? void 0 : _i.length) || ((_j2 = this.existingEntry) == null ? void 0 : _j2.disableModelInvocation) || ((_k = this.existingEntry) == null ? void 0 : _k.userInvocable) === false || ((_l = this.existingEntry) == null ? void 0 : _l.context) || ((_m = this.existingEntry) == null ? void 0 : _m.agent)) { + details.open = true; + } + new import_obsidian12.Setting(details).setName("Argument hint").setDesc('Placeholder text for arguments (e.g., "[file] [focus]")').addText((text) => { + var _a4; + hintInput = text.inputEl; + text.setValue(((_a4 = this.existingEntry) == null ? void 0 : _a4.argumentHint) || ""); + }); + new import_obsidian12.Setting(details).setName("Model override").setDesc("Optional model to use for this command").addText((text) => { + var _a4; + modelInput = text.inputEl; + text.setValue(((_a4 = this.existingEntry) == null ? void 0 : _a4.model) || "").setPlaceholder("claude-sonnet-4-5"); + }); + new import_obsidian12.Setting(details).setName("Allowed tools").setDesc("Comma-separated list of tools to allow (empty = all)").addText((text) => { + var _a4, _b3; + toolsInput = text.inputEl; + text.setValue(((_b3 = (_a4 = this.existingEntry) == null ? void 0 : _a4.allowedTools) == null ? void 0 : _b3.join(", ")) || ""); + }); + new import_obsidian12.Setting(details).setName("Disable model invocation").setDesc("Prevent the model from invoking this command itself").addToggle((toggle) => { + toggle.setValue(disableModelToggle).onChange((value) => { + disableModelToggle = value; + }); + }); + disableUserSetting = new import_obsidian12.Setting(details).setName("Disable user invocation").setDesc("Prevent the user from invoking this skill directly").addToggle((toggle) => { + disableUserToggle = toggle; + toggle.setValue(disableUserInvocation).onChange((value) => { + disableUserInvocation = value; + }); + }); + updateSkillOnlyFields(); + new import_obsidian12.Setting(details).setName("Context").setDesc("Run in a subagent (fork)").addToggle((toggle) => { + toggle.setValue(contextValue === "fork").onChange((value) => { + contextValue = value ? "fork" : ""; + agentSetting.settingEl.style.display = value ? "" : "none"; + }); + }); + const agentSetting = new import_obsidian12.Setting(details).setName("Agent").setDesc("Subagent type when context is fork").addText((text) => { + var _a4; + agentInput = text.inputEl; + text.setValue(((_a4 = this.existingEntry) == null ? void 0 : _a4.agent) || "").setPlaceholder("code-reviewer"); + }); + agentSetting.settingEl.style.display = contextValue === "fork" ? "" : "none"; + new import_obsidian12.Setting(contentEl).setName("Prompt template").setDesc("Use $ARGUMENTS, $1, $2, @file, !`bash`"); + const contentArea = contentEl.createEl("textarea", { + cls: "claudian-sp-content-area", + attr: { + rows: "10", + placeholder: "Review this code for:\n$ARGUMENTS\n\n@$1" + } + }); + const initialContent = this.existingEntry ? parseSlashCommandContent(this.existingEntry.content).promptContent : ""; + contentArea.value = initialContent; + const buttonContainer = contentEl.createDiv({ cls: "claudian-sp-modal-buttons" }); + const cancelBtn = buttonContainer.createEl("button", { + text: "Cancel", + cls: "claudian-cancel-btn" + }); + cancelBtn.addEventListener("click", () => this.close()); + const saveBtn = buttonContainer.createEl("button", { + text: "Save", + cls: "claudian-save-btn" + }); + saveBtn.addEventListener("click", async () => { + var _a4, _b3, _c2, _d2, _e2, _f2; + const name = nameInput.value.trim(); + const nameError = validateCommandName(name); + if (nameError) { + new import_obsidian12.Notice(nameError); + return; + } + const content = contentArea.value; + if (!content.trim()) { + new import_obsidian12.Notice("Prompt template is required"); + return; + } + const existing = this.entries.find( + (entry2) => { + var _a5; + return entry2.name.toLowerCase() === name.toLowerCase() && entry2.id !== ((_a5 = this.existingEntry) == null ? void 0 : _a5.id); + } + ); + if (existing) { + new import_obsidian12.Notice(`A command named "/${name}" already exists`); + return; + } + const parsed = parseSlashCommandContent(content); + const promptContent = parsed.promptContent; + const isSkillType = selectedType === "skill"; + const entry = { + id: ((_a4 = this.existingEntry) == null ? void 0 : _a4.id) || (isSkillType ? `skill-${name}` : `cmd-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`), + providerId: "claude", + kind: isSkillType ? "skill" : "command", + name, + description: descInput.value.trim() || parsed.description || void 0, + argumentHint: normalizeArgumentHint(hintInput.value.trim()) || parsed.argumentHint || void 0, + allowedTools: resolveAllowedTools(toolsInput.value, parsed.allowedTools), + model: modelInput.value.trim() || parsed.model || void 0, + content: promptContent, + disableModelInvocation: disableModelToggle || void 0, + userInvocable: disableUserInvocation ? false : void 0, + context: contextValue || void 0, + agent: contextValue === "fork" ? agentInput.value.trim() || void 0 : void 0, + hooks: (_c2 = parsed.hooks) != null ? _c2 : (_b3 = this.existingEntry) == null ? void 0 : _b3.hooks, + scope: "vault", + source: (_e2 = (_d2 = this.existingEntry) == null ? void 0 : _d2.source) != null ? _e2 : "user", + isEditable: true, + isDeletable: true, + displayPrefix: "/", + insertPrefix: "/", + persistenceKey: (_f2 = this.existingEntry) == null ? void 0 : _f2.persistenceKey + }; + try { + await this.onSave(entry); + } catch (e3) { + const label = isSkillType ? "skill" : "slash command"; + new import_obsidian12.Notice(`Failed to save ${label}`); + return; + } + this.close(); + }); + const handleKeyDown = (e3) => { + if (e3.key === "Escape") { + e3.preventDefault(); + this.close(); + } + }; + contentEl.addEventListener("keydown", handleKeyDown); + } + onClose() { + this.contentEl.empty(); + } +}; +var SlashCommandSettings = class { + constructor(containerEl, app, catalog) { + this.commands = []; + this.app = app; + this.containerEl = containerEl; + this.catalog = catalog; + void this.loadAndRender(); + } + async loadAndRender() { + if (!this.catalog) { + this.renderUnavailable(); + return; + } + this.commands = await this.catalog.listVaultEntries(); + this.render(); + } + renderUnavailable() { + this.containerEl.empty(); + const emptyEl = this.containerEl.createDiv({ cls: "claudian-sp-empty-state" }); + emptyEl.setText("Claude command catalog is unavailable."); + } + render() { + this.containerEl.empty(); + const headerEl = this.containerEl.createDiv({ cls: "claudian-sp-header" }); + headerEl.createSpan({ text: t("settings.slashCommands.name"), cls: "claudian-sp-label" }); + const actionsEl = headerEl.createDiv({ cls: "claudian-sp-header-actions" }); + const addBtn = actionsEl.createEl("button", { + cls: "claudian-settings-action-btn", + attr: { "aria-label": "Add" } + }); + (0, import_obsidian12.setIcon)(addBtn, "plus"); + addBtn.addEventListener("click", () => this.openCommandModal(null)); + if (this.commands.length === 0) { + const emptyEl = this.containerEl.createDiv({ cls: "claudian-sp-empty-state" }); + emptyEl.setText("No commands or skills configured. Click + to create one."); + return; + } + const listEl = this.containerEl.createDiv({ cls: "claudian-sp-list" }); + for (const cmd of this.commands) { + this.renderCommandItem(listEl, cmd); + } + } + renderCommandItem(listEl, cmd) { + const itemEl = listEl.createDiv({ cls: "claudian-sp-item" }); + const infoEl = itemEl.createDiv({ cls: "claudian-sp-info" }); + const headerRow = infoEl.createDiv({ cls: "claudian-sp-item-header" }); + const nameEl = headerRow.createSpan({ cls: "claudian-sp-item-name" }); + nameEl.setText(`/${cmd.name}`); + if (isSkillEntry(cmd)) { + headerRow.createSpan({ text: "skill", cls: "claudian-slash-item-badge" }); + } + if (cmd.argumentHint) { + const hintEl = headerRow.createSpan({ cls: "claudian-slash-item-hint" }); + hintEl.setText(cmd.argumentHint); + } + if (cmd.description) { + const descEl = infoEl.createDiv({ cls: "claudian-sp-item-desc" }); + descEl.setText(cmd.description); + } + const actionsEl = itemEl.createDiv({ cls: "claudian-sp-item-actions" }); + if (cmd.isEditable) { + const editBtn = actionsEl.createEl("button", { + cls: "claudian-settings-action-btn", + attr: { "aria-label": "Edit" } + }); + (0, import_obsidian12.setIcon)(editBtn, "pencil"); + editBtn.addEventListener("click", () => this.openCommandModal(cmd)); + } + if (!isSkillEntry(cmd) && cmd.isEditable) { + const convertBtn = actionsEl.createEl("button", { + cls: "claudian-settings-action-btn", + attr: { "aria-label": "Convert to skill" } + }); + (0, import_obsidian12.setIcon)(convertBtn, "package"); + convertBtn.addEventListener("click", async () => { + try { + await this.transformToSkill(cmd); + } catch (e3) { + new import_obsidian12.Notice("Failed to convert to skill"); + } + }); + } + if (cmd.isDeletable) { + const deleteBtn = actionsEl.createEl("button", { + cls: "claudian-settings-action-btn claudian-settings-delete-btn", + attr: { "aria-label": "Delete" } + }); + (0, import_obsidian12.setIcon)(deleteBtn, "trash-2"); + deleteBtn.addEventListener("click", async () => { + try { + await this.deleteCommand(cmd); + } catch (e3) { + const label = isSkillEntry(cmd) ? "skill" : "slash command"; + new import_obsidian12.Notice(`Failed to delete ${label}`); + } + }); + } + } + openCommandModal(existingCmd) { + const modal = new SlashCommandModal( + this.app, + this.commands, + existingCmd, + async (cmd) => { + await this.saveCommand(cmd, existingCmd); + } + ); + modal.open(); + } + async saveCommand(cmd, existing) { + if (!this.catalog) { + return; + } + await this.catalog.saveVaultEntry(cmd); + if (existing && existing.name !== cmd.name) { + await this.catalog.deleteVaultEntry(existing); + } + await this.reloadCommands(); + this.render(); + const label = isSkillEntry(cmd) ? "Skill" : "Slash command"; + new import_obsidian12.Notice(`${label} "/${cmd.name}" ${existing ? "updated" : "created"}`); + } + async deleteCommand(cmd) { + if (!this.catalog) { + return; + } + await this.catalog.deleteVaultEntry(cmd); + await this.reloadCommands(); + this.render(); + const label = isSkillEntry(cmd) ? "Skill" : "Slash command"; + new import_obsidian12.Notice(`${label} "/${cmd.name}" deleted`); + } + async transformToSkill(cmd) { + if (!this.catalog) { + return; + } + const skillName = cmd.name.toLowerCase().replace(/[^a-z0-9-]/g, "-").slice(0, 64); + const existingSkill = this.commands.find( + (entry) => isSkillEntry(entry) && entry.name === skillName + ); + if (existingSkill) { + new import_obsidian12.Notice(`A skill named "/${skillName}" already exists`); + return; + } + const skill = { + ...cmd, + id: `skill-${skillName}`, + kind: "skill", + name: skillName, + description: cmd.description || extractFirstParagraph(cmd.content), + source: "user", + scope: "vault", + isEditable: true, + isDeletable: true, + displayPrefix: "/", + insertPrefix: "/" + }; + await this.catalog.saveVaultEntry(skill); + await this.catalog.deleteVaultEntry(cmd); + await this.reloadCommands(); + this.render(); + new import_obsidian12.Notice(`Converted "/${cmd.name}" to skill`); + } + async reloadCommands() { + if (!this.catalog) { + this.commands = []; + return; + } + this.commands = await this.catalog.listVaultEntries(); + } + refresh() { + void this.loadAndRender(); + } +}; + +// src/providers/claude/ui/ClaudeSettingsTab.ts +var claudeSettingsTabRenderer = { + render(container, context) { + const claudeWorkspace = getClaudeWorkspaceServices(); + const settingsBag = context.plugin.settings; + const claudeSettings = getClaudeProviderSettings(settingsBag); + new import_obsidian13.Setting(container).setName(t("settings.setup")).setHeading(); + const hostnameKey = getHostnameKey(); + const platformDesc = process.platform === "win32" ? t("settings.cliPath.descWindows") : t("settings.cliPath.descUnix"); + const cliPathDescription = `${t("settings.cliPath.desc")} ${platformDesc}`; + const cliPathSetting = new import_obsidian13.Setting(container).setName(`${t("settings.cliPath.name")} (${hostnameKey})`).setDesc(cliPathDescription); + const validationEl = container.createDiv({ cls: "claudian-cli-path-validation" }); + validationEl.style.color = "var(--text-error)"; + validationEl.style.fontSize = "0.85em"; + validationEl.style.marginTop = "-0.5em"; + validationEl.style.marginBottom = "0.5em"; + validationEl.style.display = "none"; + const validatePath = (value) => { + const trimmed = value.trim(); + if (!trimmed) return null; + const expandedPath = expandHomePath(trimmed); + if (!fs8.existsSync(expandedPath)) { + return t("settings.cliPath.validation.notExist"); + } + const stat = fs8.statSync(expandedPath); + if (!stat.isFile()) { + return t("settings.cliPath.validation.isDirectory"); + } + return null; + }; + const updateCliPathValidation = (value, inputEl) => { + const error48 = validatePath(value); + if (error48) { + validationEl.setText(error48); + validationEl.style.display = "block"; + if (inputEl) { + inputEl.style.borderColor = "var(--text-error)"; + } + return false; + } + validationEl.style.display = "none"; + if (inputEl) { + inputEl.style.borderColor = ""; + } + return true; + }; + const currentValue = claudeSettings.cliPathsByHost[hostnameKey] || ""; + const cliPathsByHost = { ...claudeSettings.cliPathsByHost }; + let cliPathInputEl = null; + const persistCliPath = async (value) => { + var _a3; + const isValid2 = updateCliPathValidation(value, cliPathInputEl != null ? cliPathInputEl : void 0); + if (!isValid2) { + return false; + } + const trimmed = value.trim(); + if (trimmed) { + cliPathsByHost[hostnameKey] = trimmed; + } else { + delete cliPathsByHost[hostnameKey]; + } + updateClaudeProviderSettings(settingsBag, { cliPathsByHost: { ...cliPathsByHost } }); + await context.plugin.saveSettings(); + claudeWorkspace.cliResolver.reset(); + const view = context.plugin.getView(); + await ((_a3 = view == null ? void 0 : view.getTabManager()) == null ? void 0 : _a3.broadcastToAllTabs( + (service) => Promise.resolve(service.cleanup()) + )); + return true; + }; + cliPathSetting.addText((text) => { + const placeholder = process.platform === "win32" ? "D:\\nodejs\\node_global\\node_modules\\@anthropic-ai\\claude-code\\cli.js" : "/usr/local/lib/node_modules/@anthropic-ai/claude-code/cli.js"; + text.setPlaceholder(placeholder).setValue(currentValue).onChange(async (value) => { + await persistCliPath(value); + }); + text.inputEl.addClass("claudian-settings-cli-path-input"); + text.inputEl.style.width = "100%"; + cliPathInputEl = text.inputEl; + updateCliPathValidation(currentValue, text.inputEl); + }); + new import_obsidian13.Setting(container).setName(t("settings.safety")).setHeading(); + new import_obsidian13.Setting(container).setName(t("settings.claudeSafeMode.name")).setDesc(t("settings.claudeSafeMode.desc")).addDropdown((dropdown) => { + dropdown.addOption("acceptEdits", "acceptEdits").addOption("default", "default").setValue(claudeSettings.safeMode).onChange(async (value) => { + updateClaudeProviderSettings( + settingsBag, + { safeMode: value } + ); + await context.plugin.saveSettings(); + }); + }); + new import_obsidian13.Setting(container).setName(t("settings.loadUserSettings.name")).setDesc(t("settings.loadUserSettings.desc")).addToggle( + (toggle) => toggle.setValue(claudeSettings.loadUserSettings).onChange(async (value) => { + updateClaudeProviderSettings(settingsBag, { loadUserSettings: value }); + await context.plugin.saveSettings(); + }) + ); + new import_obsidian13.Setting(container).setName(t("settings.models")).setHeading(); + new import_obsidian13.Setting(container).setName(t("settings.enableOpus1M.name")).setDesc(t("settings.enableOpus1M.desc")).addToggle( + (toggle) => toggle.setValue(claudeSettings.enableOpus1M).onChange(async (value) => { + updateClaudeProviderSettings(settingsBag, { enableOpus1M: value }); + context.plugin.normalizeModelVariantSettings(); + await context.plugin.saveSettings(); + context.refreshModelSelectors(); + }) + ); + new import_obsidian13.Setting(container).setName(t("settings.enableSonnet1M.name")).setDesc(t("settings.enableSonnet1M.desc")).addToggle( + (toggle) => toggle.setValue(claudeSettings.enableSonnet1M).onChange(async (value) => { + updateClaudeProviderSettings(settingsBag, { enableSonnet1M: value }); + context.plugin.normalizeModelVariantSettings(); + await context.plugin.saveSettings(); + context.refreshModelSelectors(); + }) + ); + new import_obsidian13.Setting(container).setName(t("settings.slashCommands.name")).setHeading(); + const slashCommandsDesc = container.createDiv({ cls: "claudian-sp-settings-desc" }); + const descP = slashCommandsDesc.createEl("p", { cls: "setting-item-description" }); + descP.appendText(t("settings.slashCommands.desc") + " "); + descP.createEl("a", { + text: "Learn more", + href: "https://code.claude.com/docs/en/skills" + }); + const slashCommandsContainer = container.createDiv({ cls: "claudian-slash-commands-container" }); + new SlashCommandSettings( + slashCommandsContainer, + context.plugin.app, + claudeWorkspace.commandCatalog + ); + context.renderHiddenProviderCommandSetting(container, "claude", { + name: t("settings.hiddenSlashCommands.name"), + desc: t("settings.hiddenSlashCommands.desc"), + placeholder: t("settings.hiddenSlashCommands.placeholder") + }); + new import_obsidian13.Setting(container).setName(t("settings.subagents.name")).setHeading(); + const agentsDesc = container.createDiv({ cls: "claudian-sp-settings-desc" }); + agentsDesc.createEl("p", { + text: t("settings.subagents.desc"), + cls: "setting-item-description" + }); + const agentsContainer = container.createDiv({ cls: "claudian-agents-container" }); + new AgentSettings(agentsContainer, { + app: context.plugin.app, + agentManager: claudeWorkspace.agentManager, + agentStorage: claudeWorkspace.agentStorage + }); + new import_obsidian13.Setting(container).setName(t("settings.mcpServers.name")).setHeading(); + const mcpDesc = container.createDiv({ cls: "claudian-mcp-settings-desc" }); + mcpDesc.createEl("p", { + text: t("settings.mcpServers.desc"), + cls: "setting-item-description" + }); + const mcpContainer = container.createDiv({ cls: "claudian-mcp-container" }); + new McpSettingsManager(mcpContainer, { + app: context.plugin.app, + mcpStorage: claudeWorkspace.mcpStorage, + broadcastMcpReload: async () => { + var _a3; + for (const view of context.plugin.getAllViews()) { + await ((_a3 = view.getTabManager()) == null ? void 0 : _a3.broadcastToAllTabs( + (service) => service.reloadMcpServers() + )); + } + } + }); + new import_obsidian13.Setting(container).setName(t("settings.plugins.name")).setHeading(); + const pluginsDesc = container.createDiv({ cls: "claudian-plugin-settings-desc" }); + pluginsDesc.createEl("p", { + text: t("settings.plugins.desc"), + cls: "setting-item-description" + }); + const pluginsContainer = container.createDiv({ cls: "claudian-plugins-container" }); + new PluginSettingsManager(pluginsContainer, { + pluginManager: claudeWorkspace.pluginManager, + agentManager: claudeWorkspace.agentManager, + restartTabs: async () => { + const view = context.plugin.getView(); + const tabManager = view == null ? void 0 : view.getTabManager(); + if (!tabManager) { + return; + } + await tabManager.broadcastToAllTabs( + async (service) => { + await service.ensureReady({ force: true }); + } + ); + } + }); + renderEnvironmentSettingsSection({ + container, + plugin: context.plugin, + scope: "provider:claude", + heading: t("settings.environment"), + name: t("settings.customVariables.name"), + desc: "Claude-owned runtime variables only. Use this for ANTHROPIC_* and Claude-specific toggles.", + placeholder: "ANTHROPIC_API_KEY=your-key\nANTHROPIC_BASE_URL=https://api.example.com\nANTHROPIC_MODEL=custom-model\nCLAUDE_CODE_USE_BEDROCK=1", + renderCustomContextLimits: (target) => context.renderCustomContextLimits(target, "claude") + }); + new import_obsidian13.Setting(container).setName(t("settings.experimental")).setHeading(); + new import_obsidian13.Setting(container).setName(t("settings.enableChrome.name")).setDesc(t("settings.enableChrome.desc")).addToggle( + (toggle) => toggle.setValue(claudeSettings.enableChrome).onChange(async (value) => { + updateClaudeProviderSettings(settingsBag, { enableChrome: value }); + await context.plugin.saveSettings(); + }) + ); + new import_obsidian13.Setting(container).setName(t("settings.enableBangBash.name")).setDesc(t("settings.enableBangBash.desc")).addToggle( + (toggle) => toggle.setValue(claudeSettings.enableBangBash).onChange(async (value) => { + bangBashValidationEl.style.display = "none"; + if (value) { + const { findNodeExecutable: findNodeExecutable2, getEnhancedPath: getEnhancedPath2 } = await Promise.resolve().then(() => (init_env(), env_exports)); + const nodePath2 = findNodeExecutable2(getEnhancedPath2()); + if (!nodePath2) { + bangBashValidationEl.setText(t("settings.enableBangBash.validation.noNode")); + bangBashValidationEl.style.display = "block"; + toggle.setValue(false); + return; + } + } + updateClaudeProviderSettings(settingsBag, { enableBangBash: value }); + await context.plugin.saveSettings(); + }) + ); + const bangBashValidationEl = container.createDiv({ cls: "claudian-bang-bash-validation" }); + bangBashValidationEl.style.color = "var(--text-error)"; + bangBashValidationEl.style.fontSize = "0.85em"; + bangBashValidationEl.style.marginTop = "-0.5em"; + bangBashValidationEl.style.marginBottom = "0.5em"; + bangBashValidationEl.style.display = "none"; + } +}; + +// src/providers/claude/app/ClaudeWorkspaceServices.ts +async function createClaudeWorkspaceServices(plugin, adapter) { + var _a3; + const claudeStorage = new StorageService(plugin, adapter); + await claudeStorage.ensureDirectories(); + const cliResolver = new ClaudeCliResolver(); + const mcpStorage = claudeStorage.mcp; + const mcpManager = new McpServerManager(mcpStorage); + await mcpManager.loadServers(); + const vaultPath = (_a3 = plugin.app.vault.adapter.basePath) != null ? _a3 : ""; + const pluginManager = new PluginManager(vaultPath, claudeStorage.ccSettings); + await pluginManager.loadPlugins(); + const agentStorage = claudeStorage.agents; + const agentManager = new AgentManager(vaultPath, pluginManager); + await agentManager.loadAgents(); + const commandCatalog = new ClaudeCommandCatalog( + claudeStorage.commands, + claudeStorage.skills + ); + return { + claudeStorage, + cliResolver, + mcpStorage, + mcpServerManager: mcpManager, + mcpManager, + pluginManager, + agentStorage, + agentManager, + commandCatalog, + agentMentionProvider: agentManager, + settingsTabRenderer: claudeSettingsTabRenderer, + refreshAgentMentions: async () => { + await agentManager.loadAgents(); + } + }; +} +var claudeWorkspaceRegistration = { + initialize: async ({ plugin, vaultAdapter }) => createClaudeWorkspaceServices(plugin, vaultAdapter) +}; +function getClaudeWorkspaceServices() { + return ProviderWorkspaceRegistry.requireServices("claude"); +} + +// src/utils/context.ts +var CURRENT_NOTE_PREFIX_REGEX = /^\n[\s\S]*?<\/current_note>\n\n/; +var CURRENT_NOTE_SUFFIX_REGEX = /\n\n\n[\s\S]*?<\/current_note>$/; +var XML_CONTEXT_PATTERN = /\n\n<(?:current_note|editor_selection|editor_cursor|context_files|canvas_selection|browser_selection)[\s>]/; +function formatCurrentNote(notePath) { + return ` +${notePath} +`; +} +function appendCurrentNote(prompt, notePath) { + return `${prompt} + +${formatCurrentNote(notePath)}`; +} +function stripCurrentNoteContext(prompt) { + const strippedPrefix = prompt.replace(CURRENT_NOTE_PREFIX_REGEX, ""); + if (strippedPrefix !== prompt) { + return strippedPrefix; + } + return prompt.replace(CURRENT_NOTE_SUFFIX_REGEX, ""); +} +function extractContentBeforeXmlContext(text) { + if (!text) return void 0; + const queryMatch = text.match(/\n?([\s\S]*?)\n?<\/query>/); + if (queryMatch) { + return queryMatch[1].trim(); + } + const xmlMatch = text.match(XML_CONTEXT_PATTERN); + if ((xmlMatch == null ? void 0 : xmlMatch.index) !== void 0) { + return text.substring(0, xmlMatch.index).trim(); + } + return void 0; +} +function extractUserQuery(prompt) { + if (!prompt) return ""; + const extracted = extractContentBeforeXmlContext(prompt); + if (extracted !== void 0) { + return extracted; + } + return prompt.replace(/[\s\S]*?<\/current_note>\s*/g, "").replace(/\s*/g, "").replace(/\s*/g, "").replace(/[\s\S]*?<\/context_files>\s*/g, "").replace(/\s*/g, "").replace(/\s*/g, "").trim(); +} +function formatContextFilesLine(files) { + return ` +${files.join(", ")} +`; +} +function appendContextFiles(prompt, files) { + return `${prompt} + +${formatContextFilesLine(files)}`; +} + +// src/utils/date.ts +function getTodayDate() { + const now = /* @__PURE__ */ new Date(); + const readable = now.toLocaleDateString("en-US", { + weekday: "long", + year: "numeric", + month: "long", + day: "numeric" + }); + const iso = now.toISOString().split("T")[0]; + return `${readable} (${iso})`; +} +function formatDurationMmSs(seconds) { + if (!Number.isFinite(seconds) || seconds < 0) { + return "0s"; + } + const mins = Math.floor(seconds / 60); + const secs = seconds % 60; + if (mins === 0) { + return `${secs}s`; + } + return `${mins}m ${secs}s`; +} + +// src/core/prompt/inlineEdit.ts +function parseInlineEditResponse(responseText) { + const replacementMatch = responseText.match(/([\s\S]*?)<\/replacement>/); + if (replacementMatch) { + return { success: true, editedText: replacementMatch[1] }; + } + const insertionMatch = responseText.match(/([\s\S]*?)<\/insertion>/); + if (insertionMatch) { + return { success: true, insertedText: insertionMatch[1] }; + } + const trimmed = responseText.trim(); + if (trimmed) { + return { success: true, clarification: trimmed }; + } + return { success: false, error: "Empty response" }; +} +function buildCursorPrompt(request) { + const ctx = request.cursorContext; + const lineAttr = ` line="${ctx.line + 1}"`; + let cursorContent; + if (ctx.isInbetween) { + const parts = []; + if (ctx.beforeCursor) parts.push(ctx.beforeCursor); + parts.push("| #inbetween"); + if (ctx.afterCursor) parts.push(ctx.afterCursor); + cursorContent = parts.join("\n"); + } else { + cursorContent = `${ctx.beforeCursor}|${ctx.afterCursor} #inline`; + } + return [ + request.instruction, + "", + ``, + cursorContent, + "" + ].join("\n"); +} +function buildInlineEditPrompt(request) { + let prompt; + if (request.mode === "cursor") { + prompt = buildCursorPrompt(request); + } else { + const lineAttr = request.startLine && request.lineCount ? ` lines="${request.startLine}-${request.startLine + request.lineCount - 1}"` : ""; + prompt = [ + request.instruction, + "", + ``, + request.selectedText, + "" + ].join("\n"); + } + if (request.contextFiles && request.contextFiles.length > 0) { + prompt = appendContextFiles(prompt, request.contextFiles); + } + return prompt; +} +function getInlineEditSystemPrompt() { + const pathRules = '- **Paths**: Must be RELATIVE to vault root (e.g., "notes/file.md").'; + return `Today is ${getTodayDate()}. + +You are **Claudian**, an expert editor and writing assistant embedded in Obsidian. You help users refine their text, answer questions, and generate content with high precision. + +## Core Directives + +1. **Style Matching**: Mimic the user's tone, voice, and formatting style (indentation, bullet points, capitalization). +2. **Context Awareness**: Always Read the full file (or significant context) to understand the broader topic before editing. Do not rely solely on the selection. +3. **Silent Execution**: Use tools (Read, WebSearch) silently. Your final output must be ONLY the result. +4. **No Fluff**: No pleasantries, no "Here is the text", no "I have updated...". Just the content. + +## Input Format + +User messages have the instruction first, followed by XML context tags: + +### Selection Mode +\`\`\` +user's instruction + + +selected text here + +\`\`\` +Use \`\` tags for edits. + +### Cursor Mode +\`\`\` +user's instruction + + +text before|text after #inline + +\`\`\` +Or between paragraphs: +\`\`\` +user's instruction + + +Previous paragraph +| #inbetween +Next paragraph + +\`\`\` +Use \`\` tags to insert new content at the cursor position (\`|\`). + +## Tools & Path Rules + +- **Tools**: Read, Grep, Glob, LS, WebSearch, WebFetch. (All read-only). +${pathRules} + +## Thinking Process + +Before generating the final output, mentally check: +1. **Context**: Have I read enough of the file to understand the *topic* and *structure*? +2. **Style**: What is the user's indentation (2 vs 4 spaces, tabs)? What is their tone? +3. **Type**: Is this **Prose** (flow, grammar, clarity) or **Code** (syntax, logic, variable names)? + - *Prose*: Ensure smooth transitions. + - *Code*: Preserve syntax validity; do not break surrounding brackets/indentation. + +## Output Rules - CRITICAL + +**ABSOLUTE RULE**: Your text output must contain ONLY the final answer, replacement, or insertion. NEVER output: +- "I'll read the file..." / "Let me check..." / "I will..." +- "I'm asked about..." / "The user wants..." +- "Based on my analysis..." / "After reading..." +- "Here's..." / "The answer is..." +- ANY announcement of what you're about to do or did + +Use tools silently. Your text output = final result only. + +### When Replacing Selected Text (Selection Mode) + +If the user wants to MODIFY or REPLACE the selected text, wrap the replacement in tags: + +your replacement text here + +The content inside the tags should be ONLY the replacement text - no explanation. + +### When Inserting at Cursor (Cursor Mode) + +If the user wants to INSERT new content at the cursor position, wrap the insertion in tags: + +your inserted text here + +The content inside the tags should be ONLY the text to insert - no explanation. + +### When Answering Questions or Providing Information + +If the user is asking a QUESTION, respond WITHOUT tags. Output the answer directly. + +WRONG: "I'll read the full context of this file to give you a better explanation. This is a guide about..." +CORRECT: "This is a guide about..." + +### When Clarification is Needed + +If the request is ambiguous, ask a clarifying question. Keep questions concise and specific. + +## Examples + +### Selection Mode +Input: +\`\`\` +translate to French + + +Hello world + +\`\`\` + +CORRECT (replacement): +Bonjour le monde + +Input: +\`\`\` +what does this do? + + +const x = arr.reduce((a, b) => a + b, 0); + +\`\`\` + +CORRECT (question - no tags): +This code sums all numbers in the array \`arr\`. It uses \`reduce\` to iterate through the array, accumulating the total starting from 0. + +### Cursor Mode + +Input: +\`\`\` +what animal? + + +The quick brown | jumps over the lazy dog. #inline + +\`\`\` + +CORRECT (insertion): +fox + +### Q&A +Input: +\`\`\` +add a brief description section + + +# Introduction +This is my project. +| #inbetween +## Features + +\`\`\` + +CORRECT (insertion): + +## Description + +This project provides tools for managing your notes efficiently. + + +Input: +\`\`\` +translate to Spanish + + +The bank was steep. + +\`\`\` + +CORRECT (asking for clarification): +"Bank" can mean a financial institution (banco) or a river bank (orilla). Which meaning should I use? + +Then after user clarifies "river bank": +La orilla era empinada.`; +} + +// src/core/providers/ProviderSettingsCoordinator.ts +var PROJECTION_KEYS = /* @__PURE__ */ new Set([ + "model", + "effortLevel", + "serviceTier", + "thinkingBudget" +]); +function getSettingsProviderId(settings11) { + return ProviderRegistry.resolveSettingsProviderId(settings11); +} +function ensureProjectionMap(settings11, key) { + const current = settings11[key]; + if (current && typeof current === "object") { + return current; + } + const next = {}; + settings11[key] = next; + return next; +} +function cloneProviderSettings(settings11) { + return { + ...settings11, + savedProviderModel: { ...settings11.savedProviderModel }, + savedProviderEffort: { ...settings11.savedProviderEffort }, + savedProviderServiceTier: { ...settings11.savedProviderServiceTier }, + savedProviderThinkingBudget: { ...settings11.savedProviderThinkingBudget } + }; +} +function mergeProviderSettings(target, source) { + for (const [key, value] of Object.entries(source)) { + if (PROJECTION_KEYS.has(key)) { + continue; + } + target[key] = value; + } +} +var ProviderSettingsCoordinator = class { + static normalizeProviderSelection(settings11) { + const next = getSettingsProviderId(settings11); + if (settings11.settingsProvider === next) { + return false; + } + settings11.settingsProvider = next; + return true; + } + static getProviderSettingsSnapshot(settings11, providerId) { + const snapshot = cloneProviderSettings(settings11); + this.projectProviderState(snapshot, providerId); + return snapshot; + } + static commitProviderSettingsSnapshot(settings11, providerId, snapshot) { + this.persistProjectedProviderState(snapshot, providerId); + if (providerId === getSettingsProviderId(settings11)) { + Object.assign(settings11, snapshot); + return; + } + mergeProviderSettings(settings11, snapshot); + } + static persistProjectedProviderState(settings11, providerId = getSettingsProviderId(settings11)) { + var _a3, _b2, _c; + const savedModel = ensureProjectionMap(settings11, "savedProviderModel"); + const savedEffort = ensureProjectionMap(settings11, "savedProviderEffort"); + const savedServiceTier = ensureProjectionMap(settings11, "savedProviderServiceTier"); + const savedBudget = ensureProjectionMap(settings11, "savedProviderThinkingBudget"); + if (typeof settings11.model === "string") { + savedModel[providerId] = settings11.model; + } + if (typeof settings11.effortLevel === "string") { + savedEffort[providerId] = settings11.effortLevel; + } + const serviceTierToggle = (_c = (_b2 = (_a3 = ProviderRegistry.getChatUIConfig(providerId)).getServiceTierToggle) == null ? void 0 : _b2.call(_a3, settings11)) != null ? _c : null; + if (serviceTierToggle && typeof settings11.serviceTier === "string") { + savedServiceTier[providerId] = settings11.serviceTier; + } + if (typeof settings11.thinkingBudget === "string") { + savedBudget[providerId] = settings11.thinkingBudget; + } + } + static projectProviderState(settings11, providerId) { + var _a3, _b2, _c, _d, _e; + const uiConfig = ProviderRegistry.getChatUIConfig(providerId); + const savedModel = settings11.savedProviderModel; + const savedEffort = settings11.savedProviderEffort; + const savedServiceTier = settings11.savedProviderServiceTier; + const savedBudget = settings11.savedProviderThinkingBudget; + const currentModel = typeof settings11.model === "string" ? settings11.model : ""; + const currentEffort = typeof settings11.effortLevel === "string" ? settings11.effortLevel : void 0; + const currentServiceTier = typeof settings11.serviceTier === "string" ? settings11.serviceTier : void 0; + const currentBudget = typeof settings11.thinkingBudget === "string" ? settings11.thinkingBudget : void 0; + const modelOptions = uiConfig.getModelOptions(settings11); + const shouldPreferCurrentProjection = providerId === getSettingsProviderId(settings11); + const isDefaultModelOfAnotherProvider = currentModel.length > 0 && ProviderRegistry.getRegisteredProviderIds().filter((id) => id !== providerId).some((id) => ProviderRegistry.getChatUIConfig(id).isDefaultModel(currentModel)); + const canReuseCurrentModel = currentModel.length > 0 && !isDefaultModelOfAnotherProvider && (shouldPreferCurrentProjection || modelOptions.some((option) => option.value === currentModel)); + const fallbackModel = canReuseCurrentModel ? currentModel : (_b2 = (_a3 = modelOptions[0]) == null ? void 0 : _a3.value) != null ? _b2 : currentModel; + const savedModelValue = savedModel == null ? void 0 : savedModel[providerId]; + const isSavedModelValid = savedModelValue !== void 0 && modelOptions.some((option) => option.value === savedModelValue); + const model = (_c = isSavedModelValid ? savedModelValue : void 0) != null ? _c : fallbackModel; + const canReuseCurrentProjection = canReuseCurrentModel && model === currentModel; + if (model) { + settings11.model = model; + uiConfig.applyModelDefaults(model, settings11); + } + const serviceTierToggle = (_e = (_d = uiConfig.getServiceTierToggle) == null ? void 0 : _d.call(uiConfig, { + ...settings11, + ...model ? { model } : {} + })) != null ? _e : null; + if ((savedEffort == null ? void 0 : savedEffort[providerId]) !== void 0) { + settings11.effortLevel = savedEffort[providerId]; + } else if (canReuseCurrentProjection && currentEffort !== void 0) { + settings11.effortLevel = currentEffort; + } else if (model && uiConfig.isAdaptiveReasoningModel(model)) { + settings11.effortLevel = uiConfig.getDefaultReasoningValue(model); + } + if (serviceTierToggle) { + if ((savedServiceTier == null ? void 0 : savedServiceTier[providerId]) !== void 0) { + settings11.serviceTier = savedServiceTier[providerId]; + } else if (canReuseCurrentProjection && currentServiceTier !== void 0) { + settings11.serviceTier = currentServiceTier; + } else { + settings11.serviceTier = serviceTierToggle.inactiveValue; + } + } else { + if ((savedServiceTier == null ? void 0 : savedServiceTier[providerId]) !== void 0) { + settings11.serviceTier = savedServiceTier[providerId]; + } else if (canReuseCurrentProjection && currentServiceTier !== void 0) { + settings11.serviceTier = currentServiceTier; + } else { + settings11.serviceTier = "default"; + } + } + if ((savedBudget == null ? void 0 : savedBudget[providerId]) !== void 0) { + settings11.thinkingBudget = savedBudget[providerId]; + } else if (canReuseCurrentProjection && currentBudget !== void 0) { + settings11.thinkingBudget = currentBudget; + } else if (model && !uiConfig.isAdaptiveReasoningModel(model)) { + settings11.thinkingBudget = uiConfig.getDefaultReasoningValue(model); + } + } + /** Each provider's reconciler only processes its own conversations. */ + static reconcileAllProviders(settings11, conversations) { + return this.reconcileProviders( + settings11, + conversations, + ProviderRegistry.getRegisteredProviderIds() + ); + } + static reconcileProviders(settings11, conversations, providerIds) { + let anyChanged = false; + const allInvalidated = []; + const settingsProvider = getSettingsProviderId(settings11); + for (const providerId of providerIds) { + const reconciler = ProviderRegistry.getSettingsReconciler(providerId); + const providerConversations = conversations.filter((c) => c.providerId === providerId); + const targetSettings = providerId === settingsProvider ? settings11 : cloneProviderSettings(settings11); + if (providerId !== settingsProvider) { + this.projectProviderState(targetSettings, providerId); + } + const { changed, invalidatedConversations } = reconciler.reconcileModelWithEnvironment( + targetSettings, + providerConversations + ); + if (changed) { + anyChanged = true; + this.persistProjectedProviderState(targetSettings, providerId); + if (providerId !== settingsProvider) { + mergeProviderSettings(settings11, targetSettings); + } + } + allInvalidated.push(...invalidatedConversations); + } + return { changed: anyChanged, invalidatedConversations: allInvalidated }; + } + static normalizeAllModelVariants(settings11) { + let anyChanged = false; + const settingsProvider = getSettingsProviderId(settings11); + for (const providerId of ProviderRegistry.getRegisteredProviderIds()) { + const reconciler = ProviderRegistry.getSettingsReconciler(providerId); + const targetSettings = providerId === settingsProvider ? settings11 : cloneProviderSettings(settings11); + if (providerId !== settingsProvider) { + this.projectProviderState(targetSettings, providerId); + } + const changed = reconciler.normalizeModelVariantSettings(targetSettings); + if (changed) { + anyChanged = true; + this.persistProjectedProviderState(targetSettings, providerId); + if (providerId !== settingsProvider) { + mergeProviderSettings(settings11, targetSettings); + } + } + } + return anyChanged; + } + /** + * Project the settings provider's saved values into the top-level + * model/effortLevel/thinkingBudget fields. + */ + static projectActiveProviderState(settings11) { + this.projectProviderState(settings11, getSettingsProviderId(settings11)); + } +}; + +// src/core/tools/toolNames.ts +var TOOL_AGENT_OUTPUT = "TaskOutput"; +var TOOL_ASK_USER_QUESTION = "AskUserQuestion"; +var TOOL_BASH = "Bash"; +var TOOL_BASH_OUTPUT = "BashOutput"; +var TOOL_EDIT = "Edit"; +var TOOL_GLOB = "Glob"; +var TOOL_GREP = "Grep"; +var TOOL_KILL_SHELL = "KillShell"; +var TOOL_LS = "LS"; +var TOOL_LIST_MCP_RESOURCES = "ListMcpResources"; +var TOOL_MCP = "Mcp"; +var TOOL_NOTEBOOK_EDIT = "NotebookEdit"; +var TOOL_READ = "Read"; +var TOOL_READ_MCP_RESOURCE = "ReadMcpResource"; +var TOOL_SKILL = "Skill"; +var TOOL_SUBAGENT = "Agent"; +var TOOL_SUBAGENT_LEGACY = "Task"; +var TOOL_TASK = TOOL_SUBAGENT; +var TOOL_TODO_WRITE = "TodoWrite"; +var TOOL_TOOL_SEARCH = "ToolSearch"; +var TOOL_WEB_FETCH = "WebFetch"; +var TOOL_WEB_SEARCH = "WebSearch"; +var TOOL_WRITE = "Write"; +var TOOL_ENTER_PLAN_MODE = "EnterPlanMode"; +var TOOL_EXIT_PLAN_MODE = "ExitPlanMode"; +var TOOL_APPLY_PATCH = "apply_patch"; +var TOOL_WRITE_STDIN = "write_stdin"; +var TOOL_SPAWN_AGENT = "spawn_agent"; +var TOOL_SEND_INPUT = "send_input"; +var TOOL_WAIT = "wait"; +var TOOL_WAIT_AGENT = "wait_agent"; +var TOOL_RESUME_AGENT = "resume_agent"; +var TOOL_CLOSE_AGENT = "close_agent"; +var AGENT_LIFECYCLE_TOOLS = [ + TOOL_SPAWN_AGENT, + TOOL_SEND_INPUT, + TOOL_WAIT, + TOOL_WAIT_AGENT, + TOOL_RESUME_AGENT, + TOOL_CLOSE_AGENT +]; +function isAgentLifecycleTool(name) { + return AGENT_LIFECYCLE_TOOLS.includes(name); +} +var TOOLS_SKIP_BLOCKED_DETECTION = [ + TOOL_ENTER_PLAN_MODE, + TOOL_EXIT_PLAN_MODE, + TOOL_ASK_USER_QUESTION +]; +var SUBAGENT_TOOL_NAMES = [ + TOOL_SUBAGENT, + TOOL_SUBAGENT_LEGACY +]; +function skipsBlockedDetection(name) { + return TOOLS_SKIP_BLOCKED_DETECTION.includes(name); +} +function isSubagentToolName(name) { + return SUBAGENT_TOOL_NAMES.includes(name); +} +var EDIT_TOOLS = [TOOL_WRITE, TOOL_EDIT, TOOL_NOTEBOOK_EDIT]; +var WRITE_EDIT_TOOLS = [TOOL_WRITE, TOOL_EDIT]; +var READ_ONLY_TOOLS = [ + TOOL_READ, + TOOL_GREP, + TOOL_GLOB, + TOOL_LS, + TOOL_WEB_SEARCH, + TOOL_WEB_FETCH +]; +function isEditTool(toolName) { + return EDIT_TOOLS.includes(toolName); +} +function isWriteEditTool(toolName) { + return WRITE_EDIT_TOOLS.includes(toolName); +} +function isReadOnlyTool(toolName) { + return READ_ONLY_TOOLS.includes(toolName); +} + +// node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs +var import_path5 = require("path"); +var import_url = require("url"); +var import_events = require("events"); +var import_child_process = require("child_process"); +var import_readline = require("readline"); +var import_os = require("os"); +var import_path6 = require("path"); +var import_crypto = require("crypto"); +var import_promises = require("fs/promises"); +var import_path7 = require("path"); +var import_fs = require("fs"); +var import_process = require("process"); +var import_crypto2 = require("crypto"); +var import_promises2 = require("fs/promises"); +var import_path8 = require("path"); +var r = __toESM(require("fs"), 1); +var import_promises3 = require("fs/promises"); +var import_path9 = require("path"); +var import_url2 = require("url"); +var import_promises4 = require("fs/promises"); +var import_promises5 = require("fs/promises"); +var import_path10 = require("path"); +var import_child_process2 = require("child_process"); +var import_util6 = require("util"); +var import_promises6 = require("fs/promises"); +var import_path11 = require("path"); +var import_fs2 = require("fs"); +var import_promises7 = require("fs/promises"); +var import_path12 = require("path"); +var import_crypto3 = require("crypto"); +var import_promises8 = require("fs/promises"); +var import_path13 = require("path"); +var import_promises9 = require("fs/promises"); +var import_path14 = require("path"); +var import_meta = {}; +var IL = Object.create; +var { getPrototypeOf: AL, defineProperty: sQ, getOwnPropertyNames: bL } = Object; +var PL = Object.prototype.hasOwnProperty; +function ZL($) { + return this[$]; +} +var EL; +var RL; +var uU = ($, X, J) => { + var Q = $ != null && typeof $ === "object"; + if (Q) { + var Y = X ? EL != null ? EL : EL = /* @__PURE__ */ new WeakMap() : RL != null ? RL : RL = /* @__PURE__ */ new WeakMap(), z6 = Y.get($); + if (z6) return z6; + } + J = $ != null ? IL(AL($)) : {}; + let W = X || !$ || !$.__esModule ? sQ(J, "default", { value: $, enumerable: true }) : J; + for (let G of bL($)) if (!PL.call(W, G)) sQ(W, G, { get: ZL.bind($, G), enumerable: true }); + if (Q) Y.set($, W); + return W; +}; +var k = ($, X) => () => (X || $((X = { exports: {} }).exports, X), X.exports); +var SL = ($) => $; +function vL($, X) { + this[$] = SL.bind(null, X); +} +var $1 = ($, X) => { + for (var J in X) sQ($, J, { get: X[J], enumerable: true, configurable: true, set: vL.bind(X, J) }); +}; +var CL = Symbol.dispose || /* @__PURE__ */ Symbol.for("Symbol.dispose"); +var kL = Symbol.asyncDispose || /* @__PURE__ */ Symbol.for("Symbol.asyncDispose"); +var N$ = ($, X, J) => { + if (X != null) { + if (typeof X !== "object" && typeof X !== "function") throw TypeError('Object expected to be assigned to "using" declaration'); + var Q; + if (J) Q = X[kL]; + if (Q === void 0) Q = X[CL]; + if (typeof Q !== "function") throw TypeError("Object not disposable"); + $.push([J, Q, X]); + } else if (J) $.push([J]); + return X; +}; +var V$ = ($, X, J) => { + var Q = typeof SuppressedError === "function" ? SuppressedError : function(W, G, U, H) { + return H = Error(U), H.name = "SuppressedError", H.error = W, H.suppressed = G, H; + }, Y = (W) => X = J ? new Q(W, X, "An error was suppressed during disposal") : (J = true, W), z6 = (W) => { + while (W = $.pop()) try { + var G = W[1] && W[1].call(W[2]); + if (W[0]) return Promise.resolve(G).then(z6, (U) => (Y(U), z6())); + } catch (U) { + Y(U); + } + if (J) throw X; + }; + return z6(); +}; +var A9 = k((wO) => { + Object.defineProperty(wO, "__esModule", { value: true }); + wO.regexpCode = wO.getEsmExportName = wO.getProperty = wO.safeStringify = wO.stringify = wO.strConcat = wO.addCodeArg = wO.str = wO._ = wO.nil = wO._Code = wO.Name = wO.IDENTIFIER = wO._CodeOrName = void 0; + class BQ { + } + wO._CodeOrName = BQ; + wO.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i; + class y0 extends BQ { + constructor($) { + super(); + if (!wO.IDENTIFIER.test($)) throw Error("CodeGen: name must be a valid identifier"); + this.str = $; + } + toString() { + return this.str; + } + emptyStr() { + return false; + } + get names() { + return { [this.str]: 1 }; + } + } + wO.Name = y0; + class x6 extends BQ { + constructor($) { + super(); + this._items = typeof $ === "string" ? [$] : $; + } + toString() { + return this.str; + } + emptyStr() { + if (this._items.length > 1) return false; + let $ = this._items[0]; + return $ === "" || $ === '""'; + } + get str() { + var $; + return ($ = this._str) !== null && $ !== void 0 ? $ : this._str = this._items.reduce((X, J) => `${X}${J}`, ""); + } + get names() { + var $; + return ($ = this._names) !== null && $ !== void 0 ? $ : this._names = this._items.reduce((X, J) => { + if (J instanceof y0) X[J.str] = (X[J.str] || 0) + 1; + return X; + }, {}); + } + } + wO._Code = x6; + wO.nil = new x6(""); + function VO($, ...X) { + let J = [$[0]], Q = 0; + while (Q < X.length) b3(J, X[Q]), J.push($[++Q]); + return new x6(J); + } + wO._ = VO; + var A3 = new x6("+"); + function OO($, ...X) { + let J = [I9($[0])], Q = 0; + while (Q < X.length) J.push(A3), b3(J, X[Q]), J.push(A3, I9($[++Q])); + return LZ(J), new x6(J); + } + wO.str = OO; + function b3($, X) { + if (X instanceof x6) $.push(...X._items); + else if (X instanceof y0) $.push(X); + else $.push(MZ(X)); + } + wO.addCodeArg = b3; + function LZ($) { + let X = 1; + while (X < $.length - 1) { + if ($[X] === A3) { + let J = jZ($[X - 1], $[X + 1]); + if (J !== void 0) { + $.splice(X - 1, 3, J); + continue; + } + $[X++] = "+"; + } + X++; + } + } + function jZ($, X) { + if (X === '""') return $; + if ($ === '""') return X; + if (typeof $ == "string") { + if (X instanceof y0 || $[$.length - 1] !== '"') return; + if (typeof X != "string") return `${$.slice(0, -1)}${X}"`; + if (X[0] === '"') return $.slice(0, -1) + X.slice(1); + return; + } + if (typeof X == "string" && X[0] === '"' && !($ instanceof y0)) return `"${$}${X.slice(1)}`; + return; + } + function FZ($, X) { + return X.emptyStr() ? $ : $.emptyStr() ? X : OO`${$}${X}`; + } + wO.strConcat = FZ; + function MZ($) { + return typeof $ == "number" || typeof $ == "boolean" || $ === null ? $ : I9(Array.isArray($) ? $.join(",") : $); + } + function IZ($) { + return new x6(I9($)); + } + wO.stringify = IZ; + function I9($) { + return JSON.stringify($).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029"); + } + wO.safeStringify = I9; + function AZ($) { + return typeof $ == "string" && wO.IDENTIFIER.test($) ? new x6(`.${$}`) : VO`[${$}]`; + } + wO.getProperty = AZ; + function bZ($) { + if (typeof $ == "string" && wO.IDENTIFIER.test($)) return new x6(`${$}`); + throw Error(`CodeGen: invalid export name: ${$}, use explicit $id name mapping`); + } + wO.getEsmExportName = bZ; + function PZ($) { + return new x6($.toString()); + } + wO.regexpCode = PZ; +}); +var R3 = k((LO) => { + Object.defineProperty(LO, "__esModule", { value: true }); + LO.ValueScope = LO.ValueScopeName = LO.Scope = LO.varKinds = LO.UsedValueState = void 0; + var Y6 = A9(); + class qO extends Error { + constructor($) { + super(`CodeGen: "code" for ${$} not defined`); + this.value = $.value; + } + } + var DQ; + (function($) { + $[$.Started = 0] = "Started", $[$.Completed = 1] = "Completed"; + })(DQ || (LO.UsedValueState = DQ = {})); + LO.varKinds = { const: new Y6.Name("const"), let: new Y6.Name("let"), var: new Y6.Name("var") }; + class Z3 { + constructor({ prefixes: $, parent: X } = {}) { + this._names = {}, this._prefixes = $, this._parent = X; + } + toName($) { + return $ instanceof Y6.Name ? $ : this.name($); + } + name($) { + return new Y6.Name(this._newName($)); + } + _newName($) { + let X = this._names[$] || this._nameGroup($); + return `${$}${X.index++}`; + } + _nameGroup($) { + var X, J; + if (((J = (X = this._parent) === null || X === void 0 ? void 0 : X._prefixes) === null || J === void 0 ? void 0 : J.has($)) || this._prefixes && !this._prefixes.has($)) throw Error(`CodeGen: prefix "${$}" is not allowed in this scope`); + return this._names[$] = { prefix: $, index: 0 }; + } + } + LO.Scope = Z3; + class E3 extends Y6.Name { + constructor($, X) { + super(X); + this.prefix = $; + } + setValue($, { property: X, itemIndex: J }) { + this.value = $, this.scopePath = Y6._`.${new Y6.Name(X)}[${J}]`; + } + } + LO.ValueScopeName = E3; + var gZ = Y6._`\n`; + class DO extends Z3 { + constructor($) { + super($); + this._values = {}, this._scope = $.scope, this.opts = { ...$, _n: $.lines ? gZ : Y6.nil }; + } + get() { + return this._scope; + } + name($) { + return new E3($, this._newName($)); + } + value($, X) { + var J; + if (X.ref === void 0) throw Error("CodeGen: ref must be passed in value"); + let Q = this.toName($), { prefix: Y } = Q, z6 = (J = X.key) !== null && J !== void 0 ? J : X.ref, W = this._values[Y]; + if (W) { + let H = W.get(z6); + if (H) return H; + } else W = this._values[Y] = /* @__PURE__ */ new Map(); + W.set(z6, Q); + let G = this._scope[Y] || (this._scope[Y] = []), U = G.length; + return G[U] = X.ref, Q.setValue(X, { property: Y, itemIndex: U }), Q; + } + getValue($, X) { + let J = this._values[$]; + if (!J) return; + return J.get(X); + } + scopeRefs($, X = this._values) { + return this._reduceValues(X, (J) => { + if (J.scopePath === void 0) throw Error(`CodeGen: name "${J}" has no value`); + return Y6._`${$}${J.scopePath}`; + }); + } + scopeCode($ = this._values, X, J) { + return this._reduceValues($, (Q) => { + if (Q.value === void 0) throw Error(`CodeGen: name "${Q}" has no value`); + return Q.value.code; + }, X, J); + } + _reduceValues($, X, J = {}, Q) { + let Y = Y6.nil; + for (let z6 in $) { + let W = $[z6]; + if (!W) continue; + let G = J[z6] = J[z6] || /* @__PURE__ */ new Map(); + W.forEach((U) => { + if (G.has(U)) return; + G.set(U, DQ.Started); + let H = X(U); + if (H) { + let K = this.opts.es5 ? LO.varKinds.var : LO.varKinds.const; + Y = Y6._`${Y}${K} ${U} = ${H};${this.opts._n}`; + } else if (H = Q === null || Q === void 0 ? void 0 : Q(U)) Y = Y6._`${Y}${H}${this.opts._n}`; + else throw new qO(U); + G.set(U, DQ.Completed); + }); + } + return Y; + } + } + LO.ValueScope = DO; +}); +var a = k((Q6) => { + Object.defineProperty(Q6, "__esModule", { value: true }); + Q6.or = Q6.and = Q6.not = Q6.CodeGen = Q6.operators = Q6.varKinds = Q6.ValueScopeName = Q6.ValueScope = Q6.Scope = Q6.Name = Q6.regexpCode = Q6.stringify = Q6.getProperty = Q6.nil = Q6.strConcat = Q6.str = Q6._ = void 0; + var Y$ = A9(), T6 = R3(), c4 = A9(); + Object.defineProperty(Q6, "_", { enumerable: true, get: function() { + return c4._; + } }); + Object.defineProperty(Q6, "str", { enumerable: true, get: function() { + return c4.str; + } }); + Object.defineProperty(Q6, "strConcat", { enumerable: true, get: function() { + return c4.strConcat; + } }); + Object.defineProperty(Q6, "nil", { enumerable: true, get: function() { + return c4.nil; + } }); + Object.defineProperty(Q6, "getProperty", { enumerable: true, get: function() { + return c4.getProperty; + } }); + Object.defineProperty(Q6, "stringify", { enumerable: true, get: function() { + return c4.stringify; + } }); + Object.defineProperty(Q6, "regexpCode", { enumerable: true, get: function() { + return c4.regexpCode; + } }); + Object.defineProperty(Q6, "Name", { enumerable: true, get: function() { + return c4.Name; + } }); + var AQ = R3(); + Object.defineProperty(Q6, "Scope", { enumerable: true, get: function() { + return AQ.Scope; + } }); + Object.defineProperty(Q6, "ValueScope", { enumerable: true, get: function() { + return AQ.ValueScope; + } }); + Object.defineProperty(Q6, "ValueScopeName", { enumerable: true, get: function() { + return AQ.ValueScopeName; + } }); + Object.defineProperty(Q6, "varKinds", { enumerable: true, get: function() { + return AQ.varKinds; + } }); + Q6.operators = { GT: new Y$._Code(">"), GTE: new Y$._Code(">="), LT: new Y$._Code("<"), LTE: new Y$._Code("<="), EQ: new Y$._Code("==="), NEQ: new Y$._Code("!=="), NOT: new Y$._Code("!"), OR: new Y$._Code("||"), AND: new Y$._Code("&&"), ADD: new Y$._Code("+") }; + class p4 { + optimizeNodes() { + return this; + } + optimizeNames($, X) { + return this; + } + } + class FO extends p4 { + constructor($, X, J) { + super(); + this.varKind = $, this.name = X, this.rhs = J; + } + render({ es5: $, _n: X }) { + let J = $ ? T6.varKinds.var : this.varKind, Q = this.rhs === void 0 ? "" : ` = ${this.rhs}`; + return `${J} ${this.name}${Q};` + X; + } + optimizeNames($, X) { + if (!$[this.name.str]) return; + if (this.rhs) this.rhs = g0(this.rhs, $, X); + return this; + } + get names() { + return this.rhs instanceof Y$._CodeOrName ? this.rhs.names : {}; + } + } + class C3 extends p4 { + constructor($, X, J) { + super(); + this.lhs = $, this.rhs = X, this.sideEffects = J; + } + render({ _n: $ }) { + return `${this.lhs} = ${this.rhs};` + $; + } + optimizeNames($, X) { + if (this.lhs instanceof Y$.Name && !$[this.lhs.str] && !this.sideEffects) return; + return this.rhs = g0(this.rhs, $, X), this; + } + get names() { + let $ = this.lhs instanceof Y$.Name ? {} : { ...this.lhs.names }; + return IQ($, this.rhs); + } + } + class MO extends C3 { + constructor($, X, J, Q) { + super($, J, Q); + this.op = X; + } + render({ _n: $ }) { + return `${this.lhs} ${this.op}= ${this.rhs};` + $; + } + } + class IO extends p4 { + constructor($) { + super(); + this.label = $, this.names = {}; + } + render({ _n: $ }) { + return `${this.label}:` + $; + } + } + class AO extends p4 { + constructor($) { + super(); + this.label = $, this.names = {}; + } + render({ _n: $ }) { + return `break${this.label ? ` ${this.label}` : ""};` + $; + } + } + class bO extends p4 { + constructor($) { + super(); + this.error = $; + } + render({ _n: $ }) { + return `throw ${this.error};` + $; + } + get names() { + return this.error.names; + } + } + class PO extends p4 { + constructor($) { + super(); + this.code = $; + } + render({ _n: $ }) { + return `${this.code};` + $; + } + optimizeNodes() { + return `${this.code}` ? this : void 0; + } + optimizeNames($, X) { + return this.code = g0(this.code, $, X), this; + } + get names() { + return this.code instanceof Y$._CodeOrName ? this.code.names : {}; + } + } + class bQ extends p4 { + constructor($ = []) { + super(); + this.nodes = $; + } + render($) { + return this.nodes.reduce((X, J) => X + J.render($), ""); + } + optimizeNodes() { + let { nodes: $ } = this, X = $.length; + while (X--) { + let J = $[X].optimizeNodes(); + if (Array.isArray(J)) $.splice(X, 1, ...J); + else if (J) $[X] = J; + else $.splice(X, 1); + } + return $.length > 0 ? this : void 0; + } + optimizeNames($, X) { + let { nodes: J } = this, Q = J.length; + while (Q--) { + let Y = J[Q]; + if (Y.optimizeNames($, X)) continue; + lZ($, Y.names), J.splice(Q, 1); + } + return J.length > 0 ? this : void 0; + } + get names() { + return this.nodes.reduce(($, X) => E1($, X.names), {}); + } + } + class i4 extends bQ { + render($) { + return "{" + $._n + super.render($) + "}" + $._n; + } + } + class ZO extends bQ { + } + class b9 extends i4 { + } + b9.kind = "else"; + class w4 extends i4 { + constructor($, X) { + super(X); + this.condition = $; + } + render($) { + let X = `if(${this.condition})` + super.render($); + if (this.else) X += "else " + this.else.render($); + return X; + } + optimizeNodes() { + super.optimizeNodes(); + let $ = this.condition; + if ($ === true) return this.nodes; + let X = this.else; + if (X) { + let J = X.optimizeNodes(); + X = this.else = Array.isArray(J) ? new b9(J) : J; + } + if (X) { + if ($ === false) return X instanceof w4 ? X : X.nodes; + if (this.nodes.length) return this; + return new w4(CO($), X instanceof w4 ? [X] : X.nodes); + } + if ($ === false || !this.nodes.length) return; + return this; + } + optimizeNames($, X) { + var J; + if (this.else = (J = this.else) === null || J === void 0 ? void 0 : J.optimizeNames($, X), !(super.optimizeNames($, X) || this.else)) return; + return this.condition = g0(this.condition, $, X), this; + } + get names() { + let $ = super.names; + if (IQ($, this.condition), this.else) E1($, this.else.names); + return $; + } + } + w4.kind = "if"; + class f0 extends i4 { + } + f0.kind = "for"; + class EO extends f0 { + constructor($) { + super(); + this.iteration = $; + } + render($) { + return `for(${this.iteration})` + super.render($); + } + optimizeNames($, X) { + if (!super.optimizeNames($, X)) return; + return this.iteration = g0(this.iteration, $, X), this; + } + get names() { + return E1(super.names, this.iteration.names); + } + } + class RO extends f0 { + constructor($, X, J, Q) { + super(); + this.varKind = $, this.name = X, this.from = J, this.to = Q; + } + render($) { + let X = $.es5 ? T6.varKinds.var : this.varKind, { name: J, from: Q, to: Y } = this; + return `for(${X} ${J}=${Q}; ${J}<${Y}; ${J}++)` + super.render($); + } + get names() { + let $ = IQ(super.names, this.from); + return IQ($, this.to); + } + } + class S3 extends f0 { + constructor($, X, J, Q) { + super(); + this.loop = $, this.varKind = X, this.name = J, this.iterable = Q; + } + render($) { + return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render($); + } + optimizeNames($, X) { + if (!super.optimizeNames($, X)) return; + return this.iterable = g0(this.iterable, $, X), this; + } + get names() { + return E1(super.names, this.iterable.names); + } + } + class LQ extends i4 { + constructor($, X, J) { + super(); + this.name = $, this.args = X, this.async = J; + } + render($) { + return `${this.async ? "async " : ""}function ${this.name}(${this.args})` + super.render($); + } + } + LQ.kind = "func"; + class jQ extends bQ { + render($) { + return "return " + super.render($); + } + } + jQ.kind = "return"; + class SO extends i4 { + render($) { + let X = "try" + super.render($); + if (this.catch) X += this.catch.render($); + if (this.finally) X += this.finally.render($); + return X; + } + optimizeNodes() { + var $, X; + return super.optimizeNodes(), ($ = this.catch) === null || $ === void 0 || $.optimizeNodes(), (X = this.finally) === null || X === void 0 || X.optimizeNodes(), this; + } + optimizeNames($, X) { + var J, Q; + return super.optimizeNames($, X), (J = this.catch) === null || J === void 0 || J.optimizeNames($, X), (Q = this.finally) === null || Q === void 0 || Q.optimizeNames($, X), this; + } + get names() { + let $ = super.names; + if (this.catch) E1($, this.catch.names); + if (this.finally) E1($, this.finally.names); + return $; + } + } + class FQ extends i4 { + constructor($) { + super(); + this.error = $; + } + render($) { + return `catch(${this.error})` + super.render($); + } + } + FQ.kind = "catch"; + class MQ extends i4 { + render($) { + return "finally" + super.render($); + } + } + MQ.kind = "finally"; + class vO { + constructor($, X = {}) { + this._values = {}, this._blockStarts = [], this._constants = {}, this.opts = { ...X, _n: X.lines ? ` +` : "" }, this._extScope = $, this._scope = new T6.Scope({ parent: $ }), this._nodes = [new ZO()]; + } + toString() { + return this._root.render(this.opts); + } + name($) { + return this._scope.name($); + } + scopeName($) { + return this._extScope.name($); + } + scopeValue($, X) { + let J = this._extScope.value($, X); + return (this._values[J.prefix] || (this._values[J.prefix] = /* @__PURE__ */ new Set())).add(J), J; + } + getScopeValue($, X) { + return this._extScope.getValue($, X); + } + scopeRefs($) { + return this._extScope.scopeRefs($, this._values); + } + scopeCode() { + return this._extScope.scopeCode(this._values); + } + _def($, X, J, Q) { + let Y = this._scope.toName(X); + if (J !== void 0 && Q) this._constants[Y.str] = J; + return this._leafNode(new FO($, Y, J)), Y; + } + const($, X, J) { + return this._def(T6.varKinds.const, $, X, J); + } + let($, X, J) { + return this._def(T6.varKinds.let, $, X, J); + } + var($, X, J) { + return this._def(T6.varKinds.var, $, X, J); + } + assign($, X, J) { + return this._leafNode(new C3($, X, J)); + } + add($, X) { + return this._leafNode(new MO($, Q6.operators.ADD, X)); + } + code($) { + if (typeof $ == "function") $(); + else if ($ !== Y$.nil) this._leafNode(new PO($)); + return this; + } + object(...$) { + let X = ["{"]; + for (let [J, Q] of $) { + if (X.length > 1) X.push(","); + if (X.push(J), J !== Q || this.opts.es5) X.push(":"), (0, Y$.addCodeArg)(X, Q); + } + return X.push("}"), new Y$._Code(X); + } + if($, X, J) { + if (this._blockNode(new w4($)), X && J) this.code(X).else().code(J).endIf(); + else if (X) this.code(X).endIf(); + else if (J) throw Error('CodeGen: "else" body without "then" body'); + return this; + } + elseIf($) { + return this._elseNode(new w4($)); + } + else() { + return this._elseNode(new b9()); + } + endIf() { + return this._endBlockNode(w4, b9); + } + _for($, X) { + if (this._blockNode($), X) this.code(X).endFor(); + return this; + } + for($, X) { + return this._for(new EO($), X); + } + forRange($, X, J, Q, Y = this.opts.es5 ? T6.varKinds.var : T6.varKinds.let) { + let z6 = this._scope.toName($); + return this._for(new RO(Y, z6, X, J), () => Q(z6)); + } + forOf($, X, J, Q = T6.varKinds.const) { + let Y = this._scope.toName($); + if (this.opts.es5) { + let z6 = X instanceof Y$.Name ? X : this.var("_arr", X); + return this.forRange("_i", 0, Y$._`${z6}.length`, (W) => { + this.var(Y, Y$._`${z6}[${W}]`), J(Y); + }); + } + return this._for(new S3("of", Q, Y, X), () => J(Y)); + } + forIn($, X, J, Q = this.opts.es5 ? T6.varKinds.var : T6.varKinds.const) { + if (this.opts.ownProperties) return this.forOf($, Y$._`Object.keys(${X})`, J); + let Y = this._scope.toName($); + return this._for(new S3("in", Q, Y, X), () => J(Y)); + } + endFor() { + return this._endBlockNode(f0); + } + label($) { + return this._leafNode(new IO($)); + } + break($) { + return this._leafNode(new AO($)); + } + return($) { + let X = new jQ(); + if (this._blockNode(X), this.code($), X.nodes.length !== 1) throw Error('CodeGen: "return" should have one node'); + return this._endBlockNode(jQ); + } + try($, X, J) { + if (!X && !J) throw Error('CodeGen: "try" without "catch" and "finally"'); + let Q = new SO(); + if (this._blockNode(Q), this.code($), X) { + let Y = this.name("e"); + this._currNode = Q.catch = new FQ(Y), X(Y); + } + if (J) this._currNode = Q.finally = new MQ(), this.code(J); + return this._endBlockNode(FQ, MQ); + } + throw($) { + return this._leafNode(new bO($)); + } + block($, X) { + if (this._blockStarts.push(this._nodes.length), $) this.code($).endBlock(X); + return this; + } + endBlock($) { + let X = this._blockStarts.pop(); + if (X === void 0) throw Error("CodeGen: not in self-balancing block"); + let J = this._nodes.length - X; + if (J < 0 || $ !== void 0 && J !== $) throw Error(`CodeGen: wrong number of nodes: ${J} vs ${$} expected`); + return this._nodes.length = X, this; + } + func($, X = Y$.nil, J, Q) { + if (this._blockNode(new LQ($, X, J)), Q) this.code(Q).endFunc(); + return this; + } + endFunc() { + return this._endBlockNode(LQ); + } + optimize($ = 1) { + while ($-- > 0) this._root.optimizeNodes(), this._root.optimizeNames(this._root.names, this._constants); + } + _leafNode($) { + return this._currNode.nodes.push($), this; + } + _blockNode($) { + this._currNode.nodes.push($), this._nodes.push($); + } + _endBlockNode($, X) { + let J = this._currNode; + if (J instanceof $ || X && J instanceof X) return this._nodes.pop(), this; + throw Error(`CodeGen: not in block "${X ? `${$.kind}/${X.kind}` : $.kind}"`); + } + _elseNode($) { + let X = this._currNode; + if (!(X instanceof w4)) throw Error('CodeGen: "else" without "if"'); + return this._currNode = X.else = $, this; + } + get _root() { + return this._nodes[0]; + } + get _currNode() { + let $ = this._nodes; + return $[$.length - 1]; + } + set _currNode($) { + let X = this._nodes; + X[X.length - 1] = $; + } + } + Q6.CodeGen = vO; + function E1($, X) { + for (let J in X) $[J] = ($[J] || 0) + (X[J] || 0); + return $; + } + function IQ($, X) { + return X instanceof Y$._CodeOrName ? E1($, X.names) : $; + } + function g0($, X, J) { + if ($ instanceof Y$.Name) return Q($); + if (!Y($)) return $; + return new Y$._Code($._items.reduce((z6, W) => { + if (W instanceof Y$.Name) W = Q(W); + if (W instanceof Y$._Code) z6.push(...W._items); + else z6.push(W); + return z6; + }, [])); + function Q(z6) { + let W = J[z6.str]; + if (W === void 0 || X[z6.str] !== 1) return z6; + return delete X[z6.str], W; + } + function Y(z6) { + return z6 instanceof Y$._Code && z6._items.some((W) => W instanceof Y$.Name && X[W.str] === 1 && J[W.str] !== void 0); + } + } + function lZ($, X) { + for (let J in X) $[J] = ($[J] || 0) - (X[J] || 0); + } + function CO($) { + return typeof $ == "boolean" || typeof $ == "number" || $ === null ? !$ : Y$._`!${v3($)}`; + } + Q6.not = CO; + var cZ = kO(Q6.operators.AND); + function pZ(...$) { + return $.reduce(cZ); + } + Q6.and = pZ; + var iZ = kO(Q6.operators.OR); + function nZ(...$) { + return $.reduce(iZ); + } + Q6.or = nZ; + function kO($) { + return (X, J) => X === Y$.nil ? J : J === Y$.nil ? X : Y$._`${v3(X)} ${$} ${v3(J)}`; + } + function v3($) { + return $ instanceof Y$.Name ? $ : Y$._`(${$})`; + } +}); +var Q$ = k((mO) => { + Object.defineProperty(mO, "__esModule", { value: true }); + mO.checkStrictMode = mO.getErrorPath = mO.Type = mO.useFunc = mO.setEvaluated = mO.evaluatedPropsToName = mO.mergeEvaluated = mO.eachItem = mO.unescapeJsonPointer = mO.escapeJsonPointer = mO.escapeFragment = mO.unescapeFragment = mO.schemaRefOrVal = mO.schemaHasRulesButRef = mO.schemaHasRules = mO.checkUnknownRules = mO.alwaysValidSchema = mO.toHash = void 0; + var K$ = a(), tZ = A9(); + function aZ($) { + let X = {}; + for (let J of $) X[J] = true; + return X; + } + mO.toHash = aZ; + function sZ($, X) { + if (typeof X == "boolean") return X; + if (Object.keys(X).length === 0) return true; + return yO($, X), !fO(X, $.self.RULES.all); + } + mO.alwaysValidSchema = sZ; + function yO($, X = $.schema) { + let { opts: J, self: Q } = $; + if (!J.strictSchema) return; + if (typeof X === "boolean") return; + let Y = Q.RULES.keywords; + for (let z6 in X) if (!Y[z6]) uO($, `unknown keyword: "${z6}"`); + } + mO.checkUnknownRules = yO; + function fO($, X) { + if (typeof $ == "boolean") return !$; + for (let J in $) if (X[J]) return true; + return false; + } + mO.schemaHasRules = fO; + function eZ($, X) { + if (typeof $ == "boolean") return !$; + for (let J in $) if (J !== "$ref" && X.all[J]) return true; + return false; + } + mO.schemaHasRulesButRef = eZ; + function $E({ topSchemaRef: $, schemaPath: X }, J, Q, Y) { + if (!Y) { + if (typeof J == "number" || typeof J == "boolean") return J; + if (typeof J == "string") return K$._`${J}`; + } + return K$._`${$}${X}${(0, K$.getProperty)(Q)}`; + } + mO.schemaRefOrVal = $E; + function XE($) { + return gO(decodeURIComponent($)); + } + mO.unescapeFragment = XE; + function JE($) { + return encodeURIComponent(_3($)); + } + mO.escapeFragment = JE; + function _3($) { + if (typeof $ == "number") return `${$}`; + return $.replace(/~/g, "~0").replace(/\//g, "~1"); + } + mO.escapeJsonPointer = _3; + function gO($) { + return $.replace(/~1/g, "/").replace(/~0/g, "~"); + } + mO.unescapeJsonPointer = gO; + function YE($, X) { + if (Array.isArray($)) for (let J of $) X(J); + else X($); + } + mO.eachItem = YE; + function xO({ mergeNames: $, mergeToName: X, mergeValues: J, resultToName: Q }) { + return (Y, z6, W, G) => { + let U = W === void 0 ? z6 : W instanceof K$.Name ? (z6 instanceof K$.Name ? $(Y, z6, W) : X(Y, z6, W), W) : z6 instanceof K$.Name ? (X(Y, W, z6), z6) : J(z6, W); + return G === K$.Name && !(U instanceof K$.Name) ? Q(Y, U) : U; + }; + } + mO.mergeEvaluated = { props: xO({ mergeNames: ($, X, J) => $.if(K$._`${J} !== true && ${X} !== undefined`, () => { + $.if(K$._`${X} === true`, () => $.assign(J, true), () => $.assign(J, K$._`${J} || {}`).code(K$._`Object.assign(${J}, ${X})`)); + }), mergeToName: ($, X, J) => $.if(K$._`${J} !== true`, () => { + if (X === true) $.assign(J, true); + else $.assign(J, K$._`${J} || {}`), x3($, J, X); + }), mergeValues: ($, X) => $ === true ? true : { ...$, ...X }, resultToName: hO }), items: xO({ mergeNames: ($, X, J) => $.if(K$._`${J} !== true && ${X} !== undefined`, () => $.assign(J, K$._`${X} === true ? true : ${J} > ${X} ? ${J} : ${X}`)), mergeToName: ($, X, J) => $.if(K$._`${J} !== true`, () => $.assign(J, X === true ? true : K$._`${J} > ${X} ? ${J} : ${X}`)), mergeValues: ($, X) => $ === true ? true : Math.max($, X), resultToName: ($, X) => $.var("items", X) }) }; + function hO($, X) { + if (X === true) return $.var("props", true); + let J = $.var("props", K$._`{}`); + if (X !== void 0) x3($, J, X); + return J; + } + mO.evaluatedPropsToName = hO; + function x3($, X, J) { + Object.keys(J).forEach((Q) => $.assign(K$._`${X}${(0, K$.getProperty)(Q)}`, true)); + } + mO.setEvaluated = x3; + var TO = {}; + function QE($, X) { + return $.scopeValue("func", { ref: X, code: TO[X.code] || (TO[X.code] = new tZ._Code(X.code)) }); + } + mO.useFunc = QE; + var k3; + (function($) { + $[$.Num = 0] = "Num", $[$.Str = 1] = "Str"; + })(k3 || (mO.Type = k3 = {})); + function zE($, X, J) { + if ($ instanceof K$.Name) { + let Q = X === k3.Num; + return J ? Q ? K$._`"[" + ${$} + "]"` : K$._`"['" + ${$} + "']"` : Q ? K$._`"/" + ${$}` : K$._`"/" + ${$}.replace(/~/g, "~0").replace(/\\//g, "~1")`; + } + return J ? (0, K$.getProperty)($).toString() : "/" + _3($); + } + mO.getErrorPath = zE; + function uO($, X, J = $.opts.strictSchema) { + if (!J) return; + if (X = `strict mode: ${X}`, J === true) throw Error(X); + $.self.logger.warn(X); + } + mO.checkStrictMode = uO; +}); +var B4 = k((cO) => { + Object.defineProperty(cO, "__esModule", { value: true }); + var c$ = a(), AE = { data: new c$.Name("data"), valCxt: new c$.Name("valCxt"), instancePath: new c$.Name("instancePath"), parentData: new c$.Name("parentData"), parentDataProperty: new c$.Name("parentDataProperty"), rootData: new c$.Name("rootData"), dynamicAnchors: new c$.Name("dynamicAnchors"), vErrors: new c$.Name("vErrors"), errors: new c$.Name("errors"), this: new c$.Name("this"), self: new c$.Name("self"), scope: new c$.Name("scope"), json: new c$.Name("json"), jsonPos: new c$.Name("jsonPos"), jsonLen: new c$.Name("jsonLen"), jsonPart: new c$.Name("jsonPart") }; + cO.default = AE; +}); +var P9 = k((dO) => { + Object.defineProperty(dO, "__esModule", { value: true }); + dO.extendErrors = dO.resetErrorsCount = dO.reportExtraError = dO.reportError = dO.keyword$DataError = dO.keywordError = void 0; + var z$ = a(), ZQ = Q$(), o$ = B4(); + dO.keywordError = { message: ({ keyword: $ }) => z$.str`must pass "${$}" keyword validation` }; + dO.keyword$DataError = { message: ({ keyword: $, schemaType: X }) => X ? z$.str`"${$}" keyword must be ${X} ($data)` : z$.str`"${$}" keyword is invalid ($data)` }; + function PE($, X = dO.keywordError, J, Q) { + let { it: Y } = $, { gen: z6, compositeRule: W, allErrors: G } = Y, U = nO($, X, J); + if (Q !== null && Q !== void 0 ? Q : W || G) pO(z6, U); + else iO(Y, z$._`[${U}]`); + } + dO.reportError = PE; + function ZE($, X = dO.keywordError, J) { + let { it: Q } = $, { gen: Y, compositeRule: z6, allErrors: W } = Q, G = nO($, X, J); + if (pO(Y, G), !(z6 || W)) iO(Q, o$.default.vErrors); + } + dO.reportExtraError = ZE; + function EE($, X) { + $.assign(o$.default.errors, X), $.if(z$._`${o$.default.vErrors} !== null`, () => $.if(X, () => $.assign(z$._`${o$.default.vErrors}.length`, X), () => $.assign(o$.default.vErrors, null))); + } + dO.resetErrorsCount = EE; + function RE({ gen: $, keyword: X, schemaValue: J, data: Q, errsCount: Y, it: z6 }) { + if (Y === void 0) throw Error("ajv implementation error"); + let W = $.name("err"); + $.forRange("i", Y, o$.default.errors, (G) => { + if ($.const(W, z$._`${o$.default.vErrors}[${G}]`), $.if(z$._`${W}.instancePath === undefined`, () => $.assign(z$._`${W}.instancePath`, (0, z$.strConcat)(o$.default.instancePath, z6.errorPath))), $.assign(z$._`${W}.schemaPath`, z$.str`${z6.errSchemaPath}/${X}`), z6.opts.verbose) $.assign(z$._`${W}.schema`, J), $.assign(z$._`${W}.data`, Q); + }); + } + dO.extendErrors = RE; + function pO($, X) { + let J = $.const("err", X); + $.if(z$._`${o$.default.vErrors} === null`, () => $.assign(o$.default.vErrors, z$._`[${J}]`), z$._`${o$.default.vErrors}.push(${J})`), $.code(z$._`${o$.default.errors}++`); + } + function iO($, X) { + let { gen: J, validateName: Q, schemaEnv: Y } = $; + if (Y.$async) J.throw(z$._`new ${$.ValidationError}(${X})`); + else J.assign(z$._`${Q}.errors`, X), J.return(false); + } + var R1 = { keyword: new z$.Name("keyword"), schemaPath: new z$.Name("schemaPath"), params: new z$.Name("params"), propertyName: new z$.Name("propertyName"), message: new z$.Name("message"), schema: new z$.Name("schema"), parentSchema: new z$.Name("parentSchema") }; + function nO($, X, J) { + let { createErrors: Q } = $.it; + if (Q === false) return z$._`{}`; + return SE($, X, J); + } + function SE($, X, J = {}) { + let { gen: Q, it: Y } = $, z6 = [vE(Y, J), CE($, J)]; + return kE($, X, z6), Q.object(...z6); + } + function vE({ errorPath: $ }, { instancePath: X }) { + let J = X ? z$.str`${$}${(0, ZQ.getErrorPath)(X, ZQ.Type.Str)}` : $; + return [o$.default.instancePath, (0, z$.strConcat)(o$.default.instancePath, J)]; + } + function CE({ keyword: $, it: { errSchemaPath: X } }, { schemaPath: J, parentSchema: Q }) { + let Y = Q ? X : z$.str`${X}/${$}`; + if (J) Y = z$.str`${Y}${(0, ZQ.getErrorPath)(J, ZQ.Type.Str)}`; + return [R1.schemaPath, Y]; + } + function kE($, { params: X, message: J }, Q) { + let { keyword: Y, data: z6, schemaValue: W, it: G } = $, { opts: U, propertyName: H, topSchemaRef: K, schemaPath: V } = G; + if (Q.push([R1.keyword, Y], [R1.params, typeof X == "function" ? X($) : X || z$._`{}`]), U.messages) Q.push([R1.message, typeof J == "function" ? J($) : J]); + if (U.verbose) Q.push([R1.schema, W], [R1.parentSchema, z$._`${K}${V}`], [o$.default.data, z6]); + if (H) Q.push([R1.propertyName, H]); + } +}); +var sO = k((tO) => { + Object.defineProperty(tO, "__esModule", { value: true }); + tO.boolOrEmptySchema = tO.topBoolOrEmptySchema = void 0; + var fE = P9(), gE = a(), hE = B4(), uE = { message: "boolean schema is false" }; + function mE($) { + let { gen: X, schema: J, validateName: Q } = $; + if (J === false) oO($, false); + else if (typeof J == "object" && J.$async === true) X.return(hE.default.data); + else X.assign(gE._`${Q}.errors`, null), X.return(true); + } + tO.topBoolOrEmptySchema = mE; + function lE($, X) { + let { gen: J, schema: Q } = $; + if (Q === false) J.var(X, false), oO($); + else J.var(X, true); + } + tO.boolOrEmptySchema = lE; + function oO($, X) { + let { gen: J, data: Q } = $, Y = { gen: J, keyword: "false schema", data: Q, schema: false, schemaCode: false, schemaValue: false, params: {}, it: $ }; + (0, fE.reportError)(Y, uE, void 0, X); + } +}); +var y3 = k((eO) => { + Object.defineProperty(eO, "__esModule", { value: true }); + eO.getRules = eO.isJSONType = void 0; + var pE = ["string", "number", "integer", "boolean", "null", "object", "array"], iE = new Set(pE); + function nE($) { + return typeof $ == "string" && iE.has($); + } + eO.isJSONType = nE; + function dE() { + let $ = { number: { type: "number", rules: [] }, string: { type: "string", rules: [] }, array: { type: "array", rules: [] }, object: { type: "object", rules: [] } }; + return { types: { ...$, integer: true, boolean: true, null: true }, rules: [{ rules: [] }, $.number, $.string, $.array, $.object], post: { rules: [] }, all: {}, keywords: {} }; + } + eO.getRules = dE; +}); +var f3 = k((Yw) => { + Object.defineProperty(Yw, "__esModule", { value: true }); + Yw.shouldUseRule = Yw.shouldUseGroup = Yw.schemaHasRulesForType = void 0; + function oE({ schema: $, self: X }, J) { + let Q = X.RULES.types[J]; + return Q && Q !== true && Xw($, Q); + } + Yw.schemaHasRulesForType = oE; + function Xw($, X) { + return X.rules.some((J) => Jw($, J)); + } + Yw.shouldUseGroup = Xw; + function Jw($, X) { + var J; + return $[X.keyword] !== void 0 || ((J = X.definition.implements) === null || J === void 0 ? void 0 : J.some((Q) => $[Q] !== void 0)); + } + Yw.shouldUseRule = Jw; +}); +var Z9 = k((Uw) => { + Object.defineProperty(Uw, "__esModule", { value: true }); + Uw.reportTypeError = Uw.checkDataTypes = Uw.checkDataType = Uw.coerceAndCheckDataType = Uw.getJSONTypes = Uw.getSchemaTypes = Uw.DataType = void 0; + var sE = y3(), eE = f3(), $R = P9(), t3 = a(), zw = Q$(), h0; + (function($) { + $[$.Correct = 0] = "Correct", $[$.Wrong = 1] = "Wrong"; + })(h0 || (Uw.DataType = h0 = {})); + function XR($) { + let X = Ww($.type); + if (X.includes("null")) { + if ($.nullable === false) throw Error("type: null contradicts nullable: false"); + } else { + if (!X.length && $.nullable !== void 0) throw Error('"nullable" cannot be used without "type"'); + if ($.nullable === true) X.push("null"); + } + return X; + } + Uw.getSchemaTypes = XR; + function Ww($) { + let X = Array.isArray($) ? $ : $ ? [$] : []; + if (X.every(sE.isJSONType)) return X; + throw Error("type must be JSONType or JSONType[]: " + X.join(",")); + } + Uw.getJSONTypes = Ww; + function JR($, X) { + let { gen: J, data: Q, opts: Y } = $, z6 = YR(X, Y.coerceTypes), W = X.length > 0 && !(z6.length === 0 && X.length === 1 && (0, eE.schemaHasRulesForType)($, X[0])); + if (W) { + let G = h3(X, Q, Y.strictNumbers, h0.Wrong); + J.if(G, () => { + if (z6.length) QR($, X, z6); + else u3($); + }); + } + return W; + } + Uw.coerceAndCheckDataType = JR; + var Gw = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "null"]); + function YR($, X) { + return X ? $.filter((J) => Gw.has(J) || X === "array" && J === "array") : []; + } + function QR($, X, J) { + let { gen: Q, data: Y, opts: z6 } = $, W = Q.let("dataType", t3._`typeof ${Y}`), G = Q.let("coerced", t3._`undefined`); + if (z6.coerceTypes === "array") Q.if(t3._`${W} == 'object' && Array.isArray(${Y}) && ${Y}.length == 1`, () => Q.assign(Y, t3._`${Y}[0]`).assign(W, t3._`typeof ${Y}`).if(h3(X, Y, z6.strictNumbers), () => Q.assign(G, Y))); + Q.if(t3._`${G} !== undefined`); + for (let H of J) if (Gw.has(H) || H === "array" && z6.coerceTypes === "array") U(H); + Q.else(), u3($), Q.endIf(), Q.if(t3._`${G} !== undefined`, () => { + Q.assign(Y, G), zR($, G); + }); + function U(H) { + switch (H) { + case "string": + Q.elseIf(t3._`${W} == "number" || ${W} == "boolean"`).assign(G, t3._`"" + ${Y}`).elseIf(t3._`${Y} === null`).assign(G, t3._`""`); + return; + case "number": + Q.elseIf(t3._`${W} == "boolean" || ${Y} === null + || (${W} == "string" && ${Y} && ${Y} == +${Y})`).assign(G, t3._`+${Y}`); + return; + case "integer": + Q.elseIf(t3._`${W} === "boolean" || ${Y} === null + || (${W} === "string" && ${Y} && ${Y} == +${Y} && !(${Y} % 1))`).assign(G, t3._`+${Y}`); + return; + case "boolean": + Q.elseIf(t3._`${Y} === "false" || ${Y} === 0 || ${Y} === null`).assign(G, false).elseIf(t3._`${Y} === "true" || ${Y} === 1`).assign(G, true); + return; + case "null": + Q.elseIf(t3._`${Y} === "" || ${Y} === 0 || ${Y} === false`), Q.assign(G, null); + return; + case "array": + Q.elseIf(t3._`${W} === "string" || ${W} === "number" + || ${W} === "boolean" || ${Y} === null`).assign(G, t3._`[${Y}]`); + } + } + } + function zR({ gen: $, parentData: X, parentDataProperty: J }, Q) { + $.if(t3._`${X} !== undefined`, () => $.assign(t3._`${X}[${J}]`, Q)); + } + function g3($, X, J, Q = h0.Correct) { + let Y = Q === h0.Correct ? t3.operators.EQ : t3.operators.NEQ, z6; + switch ($) { + case "null": + return t3._`${X} ${Y} null`; + case "array": + z6 = t3._`Array.isArray(${X})`; + break; + case "object": + z6 = t3._`${X} && typeof ${X} == "object" && !Array.isArray(${X})`; + break; + case "integer": + z6 = W(t3._`!(${X} % 1) && !isNaN(${X})`); + break; + case "number": + z6 = W(); + break; + default: + return t3._`typeof ${X} ${Y} ${$}`; + } + return Q === h0.Correct ? z6 : (0, t3.not)(z6); + function W(G = t3.nil) { + return (0, t3.and)(t3._`typeof ${X} == "number"`, G, J ? t3._`isFinite(${X})` : t3.nil); + } + } + Uw.checkDataType = g3; + function h3($, X, J, Q) { + if ($.length === 1) return g3($[0], X, J, Q); + let Y, z6 = (0, zw.toHash)($); + if (z6.array && z6.object) { + let W = t3._`typeof ${X} != "object"`; + Y = z6.null ? W : t3._`!${X} || ${W}`, delete z6.null, delete z6.array, delete z6.object; + } else Y = t3.nil; + if (z6.number) delete z6.integer; + for (let W in z6) Y = (0, t3.and)(Y, g3(W, X, J, Q)); + return Y; + } + Uw.checkDataTypes = h3; + var WR = { message: ({ schema: $ }) => `must be ${$}`, params: ({ schema: $, schemaValue: X }) => typeof $ == "string" ? t3._`{type: ${$}}` : t3._`{type: ${X}}` }; + function u3($) { + let X = GR($); + (0, $R.reportError)(X, WR); + } + Uw.reportTypeError = u3; + function GR($) { + let { gen: X, data: J, schema: Q } = $, Y = (0, zw.schemaRefOrVal)($, Q, "type"); + return { gen: X, keyword: "type", data: J, schema: Q.type, schemaCode: Y, schemaValue: Y, parentSchema: Q, params: {}, it: $ }; + } +}); +var Ow = k((Nw) => { + Object.defineProperty(Nw, "__esModule", { value: true }); + Nw.assignDefaults = void 0; + var u0 = a(), wR = Q$(); + function BR($, X) { + let { properties: J, items: Q } = $.schema; + if (X === "object" && J) for (let Y in J) Kw($, Y, J[Y].default); + else if (X === "array" && Array.isArray(Q)) Q.forEach((Y, z6) => Kw($, z6, Y.default)); + } + Nw.assignDefaults = BR; + function Kw($, X, J) { + let { gen: Q, compositeRule: Y, data: z6, opts: W } = $; + if (J === void 0) return; + let G = u0._`${z6}${(0, u0.getProperty)(X)}`; + if (Y) { + (0, wR.checkStrictMode)($, `default is ignored for: ${G}`); + return; + } + let U = u0._`${G} === undefined`; + if (W.useDefaults === "empty") U = u0._`${U} || ${G} === null || ${G} === ""`; + Q.if(U, u0._`${G} = ${(0, u0.stringify)(J)}`); + } +}); +var Z6 = k((qw) => { + Object.defineProperty(qw, "__esModule", { value: true }); + qw.validateUnion = qw.validateArray = qw.usePattern = qw.callValidateCode = qw.schemaProperties = qw.allSchemaProperties = qw.noPropertyInData = qw.propertyInData = qw.isOwnProperty = qw.hasPropFunc = qw.reportMissingProp = qw.checkMissingProp = qw.checkReportMissingProp = void 0; + var j$ = a(), m3 = Q$(), n4 = B4(), qR = Q$(); + function DR($, X) { + let { gen: J, data: Q, it: Y } = $; + J.if(c3(J, Q, X, Y.opts.ownProperties), () => { + $.setParams({ missingProperty: j$._`${X}` }, true), $.error(); + }); + } + qw.checkReportMissingProp = DR; + function LR({ gen: $, data: X, it: { opts: J } }, Q, Y) { + return (0, j$.or)(...Q.map((z6) => (0, j$.and)(c3($, X, z6, J.ownProperties), j$._`${Y} = ${z6}`))); + } + qw.checkMissingProp = LR; + function jR($, X) { + $.setParams({ missingProperty: X }, true), $.error(); + } + qw.reportMissingProp = jR; + function ww($) { + return $.scopeValue("func", { ref: Object.prototype.hasOwnProperty, code: j$._`Object.prototype.hasOwnProperty` }); + } + qw.hasPropFunc = ww; + function l3($, X, J) { + return j$._`${ww($)}.call(${X}, ${J})`; + } + qw.isOwnProperty = l3; + function FR($, X, J, Q) { + let Y = j$._`${X}${(0, j$.getProperty)(J)} !== undefined`; + return Q ? j$._`${Y} && ${l3($, X, J)}` : Y; + } + qw.propertyInData = FR; + function c3($, X, J, Q) { + let Y = j$._`${X}${(0, j$.getProperty)(J)} === undefined`; + return Q ? (0, j$.or)(Y, (0, j$.not)(l3($, X, J))) : Y; + } + qw.noPropertyInData = c3; + function Bw($) { + return $ ? Object.keys($).filter((X) => X !== "__proto__") : []; + } + qw.allSchemaProperties = Bw; + function MR($, X) { + return Bw(X).filter((J) => !(0, m3.alwaysValidSchema)($, X[J])); + } + qw.schemaProperties = MR; + function IR({ schemaCode: $, data: X, it: { gen: J, topSchemaRef: Q, schemaPath: Y, errorPath: z6 }, it: W }, G, U, H) { + let K = H ? j$._`${$}, ${X}, ${Q}${Y}` : X, V = [[n4.default.instancePath, (0, j$.strConcat)(n4.default.instancePath, z6)], [n4.default.parentData, W.parentData], [n4.default.parentDataProperty, W.parentDataProperty], [n4.default.rootData, n4.default.rootData]]; + if (W.opts.dynamicRef) V.push([n4.default.dynamicAnchors, n4.default.dynamicAnchors]); + let O = j$._`${K}, ${J.object(...V)}`; + return U !== j$.nil ? j$._`${G}.call(${U}, ${O})` : j$._`${G}(${O})`; + } + qw.callValidateCode = IR; + var AR = j$._`new RegExp`; + function bR({ gen: $, it: { opts: X } }, J) { + let Q = X.unicodeRegExp ? "u" : "", { regExp: Y } = X.code, z6 = Y(J, Q); + return $.scopeValue("pattern", { key: z6.toString(), ref: z6, code: j$._`${Y.code === "new RegExp" ? AR : (0, qR.useFunc)($, Y)}(${J}, ${Q})` }); + } + qw.usePattern = bR; + function PR($) { + let { gen: X, data: J, keyword: Q, it: Y } = $, z6 = X.name("valid"); + if (Y.allErrors) { + let G = X.let("valid", true); + return W(() => X.assign(G, false)), G; + } + return X.var(z6, true), W(() => X.break()), z6; + function W(G) { + let U = X.const("len", j$._`${J}.length`); + X.forRange("i", 0, U, (H) => { + $.subschema({ keyword: Q, dataProp: H, dataPropType: m3.Type.Num }, z6), X.if((0, j$.not)(z6), G); + }); + } + } + qw.validateArray = PR; + function ZR($) { + let { gen: X, schema: J, keyword: Q, it: Y } = $; + if (!Array.isArray(J)) throw Error("ajv implementation error"); + if (J.some((U) => (0, m3.alwaysValidSchema)(Y, U)) && !Y.opts.unevaluated) return; + let W = X.let("valid", false), G = X.name("_valid"); + X.block(() => J.forEach((U, H) => { + let K = $.subschema({ keyword: Q, schemaProp: H, compositeRule: true }, G); + if (X.assign(W, j$._`${W} || ${G}`), !$.mergeValidEvaluated(K, G)) X.if((0, j$.not)(W)); + })), $.result(W, () => $.reset(), () => $.error(true)); + } + qw.validateUnion = ZR; +}); +var Iw = k((Fw) => { + Object.defineProperty(Fw, "__esModule", { value: true }); + Fw.validateKeywordUsage = Fw.validSchemaType = Fw.funcKeywordCode = Fw.macroKeywordCode = void 0; + var t$ = a(), S1 = B4(), hR = Z6(), uR = P9(); + function mR($, X) { + let { gen: J, keyword: Q, schema: Y, parentSchema: z6, it: W } = $, G = X.macro.call(W.self, Y, z6, W), U = jw(J, Q, G); + if (W.opts.validateSchema !== false) W.self.validateSchema(G, true); + let H = J.name("valid"); + $.subschema({ schema: G, schemaPath: t$.nil, errSchemaPath: `${W.errSchemaPath}/${Q}`, topSchemaRef: U, compositeRule: true }, H), $.pass(H, () => $.error(true)); + } + Fw.macroKeywordCode = mR; + function lR($, X) { + var J; + let { gen: Q, keyword: Y, schema: z6, parentSchema: W, $data: G, it: U } = $; + pR(U, X); + let H = !G && X.compile ? X.compile.call(U.self, z6, W, U) : X.validate, K = jw(Q, Y, H), V = Q.let("valid"); + $.block$data(V, O), $.ok((J = X.valid) !== null && J !== void 0 ? J : V); + function O() { + if (X.errors === false) { + if (B(), X.modifying) Lw($); + L(() => $.error()); + } else { + let j = X.async ? N() : w(); + if (X.modifying) Lw($); + L(() => cR($, j)); + } + } + function N() { + let j = Q.let("ruleErrs", null); + return Q.try(() => B(t$._`await `), (I) => Q.assign(V, false).if(t$._`${I} instanceof ${U.ValidationError}`, () => Q.assign(j, t$._`${I}.errors`), () => Q.throw(I))), j; + } + function w() { + let j = t$._`${K}.errors`; + return Q.assign(j, null), B(t$.nil), j; + } + function B(j = X.async ? t$._`await ` : t$.nil) { + let I = U.opts.passContext ? S1.default.this : S1.default.self, b = !("compile" in X && !G || X.schema === false); + Q.assign(V, t$._`${j}${(0, hR.callValidateCode)($, K, I, b)}`, X.modifying); + } + function L(j) { + var I; + Q.if((0, t$.not)((I = X.valid) !== null && I !== void 0 ? I : V), j); + } + } + Fw.funcKeywordCode = lR; + function Lw($) { + let { gen: X, data: J, it: Q } = $; + X.if(Q.parentData, () => X.assign(J, t$._`${Q.parentData}[${Q.parentDataProperty}]`)); + } + function cR($, X) { + let { gen: J } = $; + J.if(t$._`Array.isArray(${X})`, () => { + J.assign(S1.default.vErrors, t$._`${S1.default.vErrors} === null ? ${X} : ${S1.default.vErrors}.concat(${X})`).assign(S1.default.errors, t$._`${S1.default.vErrors}.length`), (0, uR.extendErrors)($); + }, () => $.error()); + } + function pR({ schemaEnv: $ }, X) { + if (X.async && !$.$async) throw Error("async keyword in sync schema"); + } + function jw($, X, J) { + if (J === void 0) throw Error(`keyword "${X}" failed to compile`); + return $.scopeValue("keyword", typeof J == "function" ? { ref: J } : { ref: J, code: (0, t$.stringify)(J) }); + } + function iR($, X, J = false) { + return !X.length || X.some((Q) => Q === "array" ? Array.isArray($) : Q === "object" ? $ && typeof $ == "object" && !Array.isArray($) : typeof $ == Q || J && typeof $ > "u"); + } + Fw.validSchemaType = iR; + function nR({ schema: $, opts: X, self: J, errSchemaPath: Q }, Y, z6) { + if (Array.isArray(Y.keyword) ? !Y.keyword.includes(z6) : Y.keyword !== z6) throw Error("ajv implementation error"); + let W = Y.dependencies; + if (W === null || W === void 0 ? void 0 : W.some((G) => !Object.prototype.hasOwnProperty.call($, G))) throw Error(`parent schema must have dependencies of ${z6}: ${W.join(",")}`); + if (Y.validateSchema) { + if (!Y.validateSchema($[z6])) { + let U = `keyword "${z6}" value is invalid at path "${Q}": ` + J.errorsText(Y.validateSchema.errors); + if (X.validateSchema === "log") J.logger.error(U); + else throw Error(U); + } + } + } + Fw.validateKeywordUsage = nR; +}); +var Zw = k((bw) => { + Object.defineProperty(bw, "__esModule", { value: true }); + bw.extendSubschemaMode = bw.extendSubschemaData = bw.getSubschema = void 0; + var i6 = a(), Aw = Q$(); + function tR($, { keyword: X, schemaProp: J, schema: Q, schemaPath: Y, errSchemaPath: z6, topSchemaRef: W }) { + if (X !== void 0 && Q !== void 0) throw Error('both "keyword" and "schema" passed, only one allowed'); + if (X !== void 0) { + let G = $.schema[X]; + return J === void 0 ? { schema: G, schemaPath: i6._`${$.schemaPath}${(0, i6.getProperty)(X)}`, errSchemaPath: `${$.errSchemaPath}/${X}` } : { schema: G[J], schemaPath: i6._`${$.schemaPath}${(0, i6.getProperty)(X)}${(0, i6.getProperty)(J)}`, errSchemaPath: `${$.errSchemaPath}/${X}/${(0, Aw.escapeFragment)(J)}` }; + } + if (Q !== void 0) { + if (Y === void 0 || z6 === void 0 || W === void 0) throw Error('"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"'); + return { schema: Q, schemaPath: Y, topSchemaRef: W, errSchemaPath: z6 }; + } + throw Error('either "keyword" or "schema" must be passed'); + } + bw.getSubschema = tR; + function aR($, X, { dataProp: J, dataPropType: Q, data: Y, dataTypes: z6, propertyName: W }) { + if (Y !== void 0 && J !== void 0) throw Error('both "data" and "dataProp" passed, only one allowed'); + let { gen: G } = X; + if (J !== void 0) { + let { errorPath: H, dataPathArr: K, opts: V } = X, O = G.let("data", i6._`${X.data}${(0, i6.getProperty)(J)}`, true); + U(O), $.errorPath = i6.str`${H}${(0, Aw.getErrorPath)(J, Q, V.jsPropertySyntax)}`, $.parentDataProperty = i6._`${J}`, $.dataPathArr = [...K, $.parentDataProperty]; + } + if (Y !== void 0) { + let H = Y instanceof i6.Name ? Y : G.let("data", Y, true); + if (U(H), W !== void 0) $.propertyName = W; + } + if (z6) $.dataTypes = z6; + function U(H) { + $.data = H, $.dataLevel = X.dataLevel + 1, $.dataTypes = [], X.definedProperties = /* @__PURE__ */ new Set(), $.parentData = X.data, $.dataNames = [...X.dataNames, H]; + } + } + bw.extendSubschemaData = aR; + function sR($, { jtdDiscriminator: X, jtdMetadata: J, compositeRule: Q, createErrors: Y, allErrors: z6 }) { + if (Q !== void 0) $.compositeRule = Q; + if (Y !== void 0) $.createErrors = Y; + if (z6 !== void 0) $.allErrors = z6; + $.jtdDiscriminator = X, $.jtdMetadata = J; + } + bw.extendSubschemaMode = sR; +}); +var p3 = k((co, Ew) => { + Ew.exports = function $(X, J) { + if (X === J) return true; + if (X && J && typeof X == "object" && typeof J == "object") { + if (X.constructor !== J.constructor) return false; + var Q, Y, z6; + if (Array.isArray(X)) { + if (Q = X.length, Q != J.length) return false; + for (Y = Q; Y-- !== 0; ) if (!$(X[Y], J[Y])) return false; + return true; + } + if (X.constructor === RegExp) return X.source === J.source && X.flags === J.flags; + if (X.valueOf !== Object.prototype.valueOf) return X.valueOf() === J.valueOf(); + if (X.toString !== Object.prototype.toString) return X.toString() === J.toString(); + if (z6 = Object.keys(X), Q = z6.length, Q !== Object.keys(J).length) return false; + for (Y = Q; Y-- !== 0; ) if (!Object.prototype.hasOwnProperty.call(J, z6[Y])) return false; + for (Y = Q; Y-- !== 0; ) { + var W = z6[Y]; + if (!$(X[W], J[W])) return false; + } + return true; + } + return X !== X && J !== J; + }; +}); +var Sw = k((po, Rw) => { + var d4 = Rw.exports = function($, X, J) { + if (typeof X == "function") J = X, X = {}; + J = X.cb || J; + var Q = typeof J == "function" ? J : J.pre || function() { + }, Y = J.post || function() { + }; + EQ(X, Q, Y, $, "", $); + }; + d4.keywords = { additionalItems: true, items: true, contains: true, additionalProperties: true, propertyNames: true, not: true, if: true, then: true, else: true }; + d4.arrayKeywords = { items: true, allOf: true, anyOf: true, oneOf: true }; + d4.propsKeywords = { $defs: true, definitions: true, properties: true, patternProperties: true, dependencies: true }; + d4.skipKeywords = { default: true, enum: true, const: true, required: true, maximum: true, minimum: true, exclusiveMaximum: true, exclusiveMinimum: true, multipleOf: true, maxLength: true, minLength: true, pattern: true, format: true, maxItems: true, minItems: true, uniqueItems: true, maxProperties: true, minProperties: true }; + function EQ($, X, J, Q, Y, z6, W, G, U, H) { + if (Q && typeof Q == "object" && !Array.isArray(Q)) { + X(Q, Y, z6, W, G, U, H); + for (var K in Q) { + var V = Q[K]; + if (Array.isArray(V)) { + if (K in d4.arrayKeywords) for (var O = 0; O < V.length; O++) EQ($, X, J, V[O], Y + "/" + K + "/" + O, z6, Y, K, Q, O); + } else if (K in d4.propsKeywords) { + if (V && typeof V == "object") for (var N in V) EQ($, X, J, V[N], Y + "/" + K + "/" + XS(N), z6, Y, K, Q, N); + } else if (K in d4.keywords || $.allKeys && !(K in d4.skipKeywords)) EQ($, X, J, V, Y + "/" + K, z6, Y, K, Q); + } + J(Q, Y, z6, W, G, U, H); + } + } + function XS($) { + return $.replace(/~/g, "~0").replace(/\//g, "~1"); + } +}); +var E9 = k((_w) => { + Object.defineProperty(_w, "__esModule", { value: true }); + _w.getSchemaRefs = _w.resolveUrl = _w.normalizeId = _w._getFullPath = _w.getFullPath = _w.inlineRef = void 0; + var JS = Q$(), YS = p3(), QS = Sw(), zS = /* @__PURE__ */ new Set(["type", "format", "pattern", "maxLength", "minLength", "maxProperties", "minProperties", "maxItems", "minItems", "maximum", "minimum", "uniqueItems", "multipleOf", "required", "enum", "const"]); + function WS($, X = true) { + if (typeof $ == "boolean") return true; + if (X === true) return !i3($); + if (!X) return false; + return vw($) <= X; + } + _w.inlineRef = WS; + var GS = /* @__PURE__ */ new Set(["$ref", "$recursiveRef", "$recursiveAnchor", "$dynamicRef", "$dynamicAnchor"]); + function i3($) { + for (let X in $) { + if (GS.has(X)) return true; + let J = $[X]; + if (Array.isArray(J) && J.some(i3)) return true; + if (typeof J == "object" && i3(J)) return true; + } + return false; + } + function vw($) { + let X = 0; + for (let J in $) { + if (J === "$ref") return 1 / 0; + if (X++, zS.has(J)) continue; + if (typeof $[J] == "object") (0, JS.eachItem)($[J], (Q) => X += vw(Q)); + if (X === 1 / 0) return 1 / 0; + } + return X; + } + function Cw($, X = "", J) { + if (J !== false) X = m0(X); + let Q = $.parse(X); + return kw($, Q); + } + _w.getFullPath = Cw; + function kw($, X) { + return $.serialize(X).split("#")[0] + "#"; + } + _w._getFullPath = kw; + var US = /#\/?$/; + function m0($) { + return $ ? $.replace(US, "") : ""; + } + _w.normalizeId = m0; + function HS($, X, J) { + return J = m0(J), $.resolve(X, J); + } + _w.resolveUrl = HS; + var KS = /^[a-z_][-a-z0-9._]*$/i; + function NS($, X) { + if (typeof $ == "boolean") return {}; + let { schemaId: J, uriResolver: Q } = this.opts, Y = m0($[J] || X), z6 = { "": Y }, W = Cw(Q, Y, false), G = {}, U = /* @__PURE__ */ new Set(); + return QS($, { allKeys: true }, (V, O, N, w) => { + if (w === void 0) return; + let B = W + O, L = z6[w]; + if (typeof V[J] == "string") L = j.call(this, V[J]); + I.call(this, V.$anchor), I.call(this, V.$dynamicAnchor), z6[O] = L; + function j(b) { + let x = this.opts.uriResolver.resolve; + if (b = m0(L ? x(L, b) : b), U.has(b)) throw K(b); + U.add(b); + let h = this.refs[b]; + if (typeof h == "string") h = this.refs[h]; + if (typeof h == "object") H(V, h.schema, b); + else if (b !== m0(B)) if (b[0] === "#") H(V, G[b], b), G[b] = V; + else this.refs[b] = B; + return b; + } + function I(b) { + if (typeof b == "string") { + if (!KS.test(b)) throw Error(`invalid anchor "${b}"`); + j.call(this, `#${b}`); + } + } + }), G; + function H(V, O, N) { + if (O !== void 0 && !YS(V, O)) throw K(N); + } + function K(V) { + return Error(`reference "${V}" resolves to more than one schema`); + } + } + _w.getSchemaRefs = NS; +}); +var v9 = k((ow) => { + Object.defineProperty(ow, "__esModule", { value: true }); + ow.getData = ow.KeywordCxt = ow.validateFunctionCode = void 0; + var hw = sO(), Tw = Z9(), d3 = f3(), RQ = Z9(), DS = Ow(), S9 = Iw(), n3 = Zw(), u = a(), d = B4(), LS = E9(), q4 = Q$(), R9 = P9(); + function jS($) { + if (lw($)) { + if (cw($), mw($)) { + IS($); + return; + } + } + uw($, () => (0, hw.topBoolOrEmptySchema)($)); + } + ow.validateFunctionCode = jS; + function uw({ gen: $, validateName: X, schema: J, schemaEnv: Q, opts: Y }, z6) { + if (Y.code.es5) $.func(X, u._`${d.default.data}, ${d.default.valCxt}`, Q.$async, () => { + $.code(u._`"use strict"; ${yw(J, Y)}`), MS($, Y), $.code(z6); + }); + else $.func(X, u._`${d.default.data}, ${FS(Y)}`, Q.$async, () => $.code(yw(J, Y)).code(z6)); + } + function FS($) { + return u._`{${d.default.instancePath}="", ${d.default.parentData}, ${d.default.parentDataProperty}, ${d.default.rootData}=${d.default.data}${$.dynamicRef ? u._`, ${d.default.dynamicAnchors}={}` : u.nil}}={}`; + } + function MS($, X) { + $.if(d.default.valCxt, () => { + if ($.var(d.default.instancePath, u._`${d.default.valCxt}.${d.default.instancePath}`), $.var(d.default.parentData, u._`${d.default.valCxt}.${d.default.parentData}`), $.var(d.default.parentDataProperty, u._`${d.default.valCxt}.${d.default.parentDataProperty}`), $.var(d.default.rootData, u._`${d.default.valCxt}.${d.default.rootData}`), X.dynamicRef) $.var(d.default.dynamicAnchors, u._`${d.default.valCxt}.${d.default.dynamicAnchors}`); + }, () => { + if ($.var(d.default.instancePath, u._`""`), $.var(d.default.parentData, u._`undefined`), $.var(d.default.parentDataProperty, u._`undefined`), $.var(d.default.rootData, d.default.data), X.dynamicRef) $.var(d.default.dynamicAnchors, u._`{}`); + }); + } + function IS($) { + let { schema: X, opts: J, gen: Q } = $; + uw($, () => { + if (J.$comment && X.$comment) iw($); + if (ES($), Q.let(d.default.vErrors, null), Q.let(d.default.errors, 0), J.unevaluated) AS($); + pw($), vS($); + }); + return; + } + function AS($) { + let { gen: X, validateName: J } = $; + $.evaluated = X.const("evaluated", u._`${J}.evaluated`), X.if(u._`${$.evaluated}.dynamicProps`, () => X.assign(u._`${$.evaluated}.props`, u._`undefined`)), X.if(u._`${$.evaluated}.dynamicItems`, () => X.assign(u._`${$.evaluated}.items`, u._`undefined`)); + } + function yw($, X) { + let J = typeof $ == "object" && $[X.schemaId]; + return J && (X.code.source || X.code.process) ? u._`/*# sourceURL=${J} */` : u.nil; + } + function bS($, X) { + if (lw($)) { + if (cw($), mw($)) { + PS($, X); + return; + } + } + (0, hw.boolOrEmptySchema)($, X); + } + function mw({ schema: $, self: X }) { + if (typeof $ == "boolean") return !$; + for (let J in $) if (X.RULES.all[J]) return true; + return false; + } + function lw($) { + return typeof $.schema != "boolean"; + } + function PS($, X) { + let { schema: J, gen: Q, opts: Y } = $; + if (Y.$comment && J.$comment) iw($); + RS($), SS($); + let z6 = Q.const("_errs", d.default.errors); + pw($, z6), Q.var(X, u._`${z6} === ${d.default.errors}`); + } + function cw($) { + (0, q4.checkUnknownRules)($), ZS($); + } + function pw($, X) { + if ($.opts.jtd) return fw($, [], false, X); + let J = (0, Tw.getSchemaTypes)($.schema), Q = (0, Tw.coerceAndCheckDataType)($, J); + fw($, J, !Q, X); + } + function ZS($) { + let { schema: X, errSchemaPath: J, opts: Q, self: Y } = $; + if (X.$ref && Q.ignoreKeywordsWithRef && (0, q4.schemaHasRulesButRef)(X, Y.RULES)) Y.logger.warn(`$ref: keywords ignored in schema at path "${J}"`); + } + function ES($) { + let { schema: X, opts: J } = $; + if (X.default !== void 0 && J.useDefaults && J.strictSchema) (0, q4.checkStrictMode)($, "default is ignored in the schema root"); + } + function RS($) { + let X = $.schema[$.opts.schemaId]; + if (X) $.baseId = (0, LS.resolveUrl)($.opts.uriResolver, $.baseId, X); + } + function SS($) { + if ($.schema.$async && !$.schemaEnv.$async) throw Error("async schema in sync schema"); + } + function iw({ gen: $, schemaEnv: X, schema: J, errSchemaPath: Q, opts: Y }) { + let z6 = J.$comment; + if (Y.$comment === true) $.code(u._`${d.default.self}.logger.log(${z6})`); + else if (typeof Y.$comment == "function") { + let W = u.str`${Q}/$comment`, G = $.scopeValue("root", { ref: X.root }); + $.code(u._`${d.default.self}.opts.$comment(${z6}, ${W}, ${G}.schema)`); + } + } + function vS($) { + let { gen: X, schemaEnv: J, validateName: Q, ValidationError: Y, opts: z6 } = $; + if (J.$async) X.if(u._`${d.default.errors} === 0`, () => X.return(d.default.data), () => X.throw(u._`new ${Y}(${d.default.vErrors})`)); + else { + if (X.assign(u._`${Q}.errors`, d.default.vErrors), z6.unevaluated) CS($); + X.return(u._`${d.default.errors} === 0`); + } + } + function CS({ gen: $, evaluated: X, props: J, items: Q }) { + if (J instanceof u.Name) $.assign(u._`${X}.props`, J); + if (Q instanceof u.Name) $.assign(u._`${X}.items`, Q); + } + function fw($, X, J, Q) { + let { gen: Y, schema: z6, data: W, allErrors: G, opts: U, self: H } = $, { RULES: K } = H; + if (z6.$ref && (U.ignoreKeywordsWithRef || !(0, q4.schemaHasRulesButRef)(z6, K))) { + Y.block(() => dw($, "$ref", K.all.$ref.definition)); + return; + } + if (!U.jtd) kS($, X); + Y.block(() => { + for (let O of K.rules) V(O); + V(K.post); + }); + function V(O) { + if (!(0, d3.shouldUseGroup)(z6, O)) return; + if (O.type) { + if (Y.if((0, RQ.checkDataType)(O.type, W, U.strictNumbers)), gw($, O), X.length === 1 && X[0] === O.type && J) Y.else(), (0, RQ.reportTypeError)($); + Y.endIf(); + } else gw($, O); + if (!G) Y.if(u._`${d.default.errors} === ${Q || 0}`); + } + } + function gw($, X) { + let { gen: J, schema: Q, opts: { useDefaults: Y } } = $; + if (Y) (0, DS.assignDefaults)($, X.type); + J.block(() => { + for (let z6 of X.rules) if ((0, d3.shouldUseRule)(Q, z6)) dw($, z6.keyword, z6.definition, X.type); + }); + } + function kS($, X) { + if ($.schemaEnv.meta || !$.opts.strictTypes) return; + if (_S($, X), !$.opts.allowUnionTypes) xS($, X); + TS($, $.dataTypes); + } + function _S($, X) { + if (!X.length) return; + if (!$.dataTypes.length) { + $.dataTypes = X; + return; + } + X.forEach((J) => { + if (!nw($.dataTypes, J)) r3($, `type "${J}" not allowed by context "${$.dataTypes.join(",")}"`); + }), fS($, X); + } + function xS($, X) { + if (X.length > 1 && !(X.length === 2 && X.includes("null"))) r3($, "use allowUnionTypes to allow union type keyword"); + } + function TS($, X) { + let J = $.self.RULES.all; + for (let Q in J) { + let Y = J[Q]; + if (typeof Y == "object" && (0, d3.shouldUseRule)($.schema, Y)) { + let { type: z6 } = Y.definition; + if (z6.length && !z6.some((W) => yS(X, W))) r3($, `missing type "${z6.join(",")}" for keyword "${Q}"`); + } + } + } + function yS($, X) { + return $.includes(X) || X === "number" && $.includes("integer"); + } + function nw($, X) { + return $.includes(X) || X === "integer" && $.includes("number"); + } + function fS($, X) { + let J = []; + for (let Q of $.dataTypes) if (nw(X, Q)) J.push(Q); + else if (X.includes("integer") && Q === "number") J.push("integer"); + $.dataTypes = J; + } + function r3($, X) { + let J = $.schemaEnv.baseId + $.errSchemaPath; + X += ` at "${J}" (strictTypes)`, (0, q4.checkStrictMode)($, X, $.opts.strictTypes); + } + class o3 { + constructor($, X, J) { + if ((0, S9.validateKeywordUsage)($, X, J), this.gen = $.gen, this.allErrors = $.allErrors, this.keyword = J, this.data = $.data, this.schema = $.schema[J], this.$data = X.$data && $.opts.$data && this.schema && this.schema.$data, this.schemaValue = (0, q4.schemaRefOrVal)($, this.schema, J, this.$data), this.schemaType = X.schemaType, this.parentSchema = $.schema, this.params = {}, this.it = $, this.def = X, this.$data) this.schemaCode = $.gen.const("vSchema", rw(this.$data, $)); + else if (this.schemaCode = this.schemaValue, !(0, S9.validSchemaType)(this.schema, X.schemaType, X.allowUndefined)) throw Error(`${J} value must be ${JSON.stringify(X.schemaType)}`); + if ("code" in X ? X.trackErrors : X.errors !== false) this.errsCount = $.gen.const("_errs", d.default.errors); + } + result($, X, J) { + this.failResult((0, u.not)($), X, J); + } + failResult($, X, J) { + if (this.gen.if($), J) J(); + else this.error(); + if (X) { + if (this.gen.else(), X(), this.allErrors) this.gen.endIf(); + } else if (this.allErrors) this.gen.endIf(); + else this.gen.else(); + } + pass($, X) { + this.failResult((0, u.not)($), void 0, X); + } + fail($) { + if ($ === void 0) { + if (this.error(), !this.allErrors) this.gen.if(false); + return; + } + if (this.gen.if($), this.error(), this.allErrors) this.gen.endIf(); + else this.gen.else(); + } + fail$data($) { + if (!this.$data) return this.fail($); + let { schemaCode: X } = this; + this.fail(u._`${X} !== undefined && (${(0, u.or)(this.invalid$data(), $)})`); + } + error($, X, J) { + if (X) { + this.setParams(X), this._error($, J), this.setParams({}); + return; + } + this._error($, J); + } + _error($, X) { + ($ ? R9.reportExtraError : R9.reportError)(this, this.def.error, X); + } + $dataError() { + (0, R9.reportError)(this, this.def.$dataError || R9.keyword$DataError); + } + reset() { + if (this.errsCount === void 0) throw Error('add "trackErrors" to keyword definition'); + (0, R9.resetErrorsCount)(this.gen, this.errsCount); + } + ok($) { + if (!this.allErrors) this.gen.if($); + } + setParams($, X) { + if (X) Object.assign(this.params, $); + else this.params = $; + } + block$data($, X, J = u.nil) { + this.gen.block(() => { + this.check$data($, J), X(); + }); + } + check$data($ = u.nil, X = u.nil) { + if (!this.$data) return; + let { gen: J, schemaCode: Q, schemaType: Y, def: z6 } = this; + if (J.if((0, u.or)(u._`${Q} === undefined`, X)), $ !== u.nil) J.assign($, true); + if (Y.length || z6.validateSchema) { + if (J.elseIf(this.invalid$data()), this.$dataError(), $ !== u.nil) J.assign($, false); + } + J.else(); + } + invalid$data() { + let { gen: $, schemaCode: X, schemaType: J, def: Q, it: Y } = this; + return (0, u.or)(z6(), W()); + function z6() { + if (J.length) { + if (!(X instanceof u.Name)) throw Error("ajv implementation error"); + let G = Array.isArray(J) ? J : [J]; + return u._`${(0, RQ.checkDataTypes)(G, X, Y.opts.strictNumbers, RQ.DataType.Wrong)}`; + } + return u.nil; + } + function W() { + if (Q.validateSchema) { + let G = $.scopeValue("validate$data", { ref: Q.validateSchema }); + return u._`!${G}(${X})`; + } + return u.nil; + } + } + subschema($, X) { + let J = (0, n3.getSubschema)(this.it, $); + (0, n3.extendSubschemaData)(J, this.it, $), (0, n3.extendSubschemaMode)(J, $); + let Q = { ...this.it, ...J, items: void 0, props: void 0 }; + return bS(Q, X), Q; + } + mergeEvaluated($, X) { + let { it: J, gen: Q } = this; + if (!J.opts.unevaluated) return; + if (J.props !== true && $.props !== void 0) J.props = q4.mergeEvaluated.props(Q, $.props, J.props, X); + if (J.items !== true && $.items !== void 0) J.items = q4.mergeEvaluated.items(Q, $.items, J.items, X); + } + mergeValidEvaluated($, X) { + let { it: J, gen: Q } = this; + if (J.opts.unevaluated && (J.props !== true || J.items !== true)) return Q.if(X, () => this.mergeEvaluated($, u.Name)), true; + } + } + ow.KeywordCxt = o3; + function dw($, X, J, Q) { + let Y = new o3($, J, X); + if ("code" in J) J.code(Y, Q); + else if (Y.$data && J.validate) (0, S9.funcKeywordCode)(Y, J); + else if ("macro" in J) (0, S9.macroKeywordCode)(Y, J); + else if (J.compile || J.validate) (0, S9.funcKeywordCode)(Y, J); + } + var gS = /^\/(?:[^~]|~0|~1)*$/, hS = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/; + function rw($, { dataLevel: X, dataNames: J, dataPathArr: Q }) { + let Y, z6; + if ($ === "") return d.default.rootData; + if ($[0] === "/") { + if (!gS.test($)) throw Error(`Invalid JSON-pointer: ${$}`); + Y = $, z6 = d.default.rootData; + } else { + let H = hS.exec($); + if (!H) throw Error(`Invalid JSON-pointer: ${$}`); + let K = +H[1]; + if (Y = H[2], Y === "#") { + if (K >= X) throw Error(U("property/index", K)); + return Q[X - K]; + } + if (K > X) throw Error(U("data", K)); + if (z6 = J[X - K], !Y) return z6; + } + let W = z6, G = Y.split("/"); + for (let H of G) if (H) z6 = u._`${z6}${(0, u.getProperty)((0, q4.unescapeJsonPointer)(H))}`, W = u._`${W} && ${z6}`; + return W; + function U(H, K) { + return `Cannot access ${H} ${K} levels up, current level is ${X}`; + } + } + ow.getData = rw; +}); +var SQ = k((sw) => { + Object.defineProperty(sw, "__esModule", { value: true }); + class aw extends Error { + constructor($) { + super("validation failed"); + this.errors = $, this.ajv = this.validation = true; + } + } + sw.default = aw; +}); +var C9 = k(($B) => { + Object.defineProperty($B, "__esModule", { value: true }); + var t3 = E9(); + class ew extends Error { + constructor($, X, J, Q) { + super(Q || `can't resolve reference ${J} from id ${X}`); + this.missingRef = (0, t3.resolveUrl)($, X, J), this.missingSchema = (0, t3.normalizeId)((0, t3.getFullPath)($, this.missingRef)); + } + } + $B.default = ew; +}); +var CQ = k((YB) => { + Object.defineProperty(YB, "__esModule", { value: true }); + YB.resolveSchema = YB.getCompilingSchema = YB.resolveRef = YB.compileSchema = YB.SchemaEnv = void 0; + var y6 = a(), pS = SQ(), v1 = B4(), f6 = E9(), XB = Q$(), iS = v9(); + class k9 { + constructor($) { + var X; + this.refs = {}, this.dynamicAnchors = {}; + let J; + if (typeof $.schema == "object") J = $.schema; + this.schema = $.schema, this.schemaId = $.schemaId, this.root = $.root || this, this.baseId = (X = $.baseId) !== null && X !== void 0 ? X : (0, f6.normalizeId)(J === null || J === void 0 ? void 0 : J[$.schemaId || "$id"]), this.schemaPath = $.schemaPath, this.localRefs = $.localRefs, this.meta = $.meta, this.$async = J === null || J === void 0 ? void 0 : J.$async, this.refs = {}; + } + } + YB.SchemaEnv = k9; + function s3($) { + let X = JB.call(this, $); + if (X) return X; + let J = (0, f6.getFullPath)(this.opts.uriResolver, $.root.baseId), { es5: Q, lines: Y } = this.opts.code, { ownProperties: z6 } = this.opts, W = new y6.CodeGen(this.scope, { es5: Q, lines: Y, ownProperties: z6 }), G; + if ($.$async) G = W.scopeValue("Error", { ref: pS.default, code: y6._`require("ajv/dist/runtime/validation_error").default` }); + let U = W.scopeName("validate"); + $.validateName = U; + let H = { gen: W, allErrors: this.opts.allErrors, data: v1.default.data, parentData: v1.default.parentData, parentDataProperty: v1.default.parentDataProperty, dataNames: [v1.default.data], dataPathArr: [y6.nil], dataLevel: 0, dataTypes: [], definedProperties: /* @__PURE__ */ new Set(), topSchemaRef: W.scopeValue("schema", this.opts.code.source === true ? { ref: $.schema, code: (0, y6.stringify)($.schema) } : { ref: $.schema }), validateName: U, ValidationError: G, schema: $.schema, schemaEnv: $, rootId: J, baseId: $.baseId || J, schemaPath: y6.nil, errSchemaPath: $.schemaPath || (this.opts.jtd ? "" : "#"), errorPath: y6._`""`, opts: this.opts, self: this }, K; + try { + this._compilations.add($), (0, iS.validateFunctionCode)(H), W.optimize(this.opts.code.optimize); + let V = W.toString(); + if (K = `${W.scopeRefs(v1.default.scope)}return ${V}`, this.opts.code.process) K = this.opts.code.process(K, $); + let N = Function(`${v1.default.self}`, `${v1.default.scope}`, K)(this, this.scope.get()); + if (this.scope.value(U, { ref: N }), N.errors = null, N.schema = $.schema, N.schemaEnv = $, $.$async) N.$async = true; + if (this.opts.code.source === true) N.source = { validateName: U, validateCode: V, scopeValues: W._values }; + if (this.opts.unevaluated) { + let { props: w, items: B } = H; + if (N.evaluated = { props: w instanceof y6.Name ? void 0 : w, items: B instanceof y6.Name ? void 0 : B, dynamicProps: w instanceof y6.Name, dynamicItems: B instanceof y6.Name }, N.source) N.source.evaluated = (0, y6.stringify)(N.evaluated); + } + return $.validate = N, $; + } catch (V) { + if (delete $.validate, delete $.validateName, K) this.logger.error("Error compiling schema, function code:", K); + throw V; + } finally { + this._compilations.delete($); + } + } + YB.compileSchema = s3; + function nS($, X, J) { + var Q; + J = (0, f6.resolveUrl)(this.opts.uriResolver, X, J); + let Y = $.refs[J]; + if (Y) return Y; + let z6 = oS.call(this, $, J); + if (z6 === void 0) { + let W = (Q = $.localRefs) === null || Q === void 0 ? void 0 : Q[J], { schemaId: G } = this.opts; + if (W) z6 = new k9({ schema: W, schemaId: G, root: $, baseId: X }); + } + if (z6 === void 0) return; + return $.refs[J] = dS.call(this, z6); + } + YB.resolveRef = nS; + function dS($) { + if ((0, f6.inlineRef)($.schema, this.opts.inlineRefs)) return $.schema; + return $.validate ? $ : s3.call(this, $); + } + function JB($) { + for (let X of this._compilations) if (rS(X, $)) return X; + } + YB.getCompilingSchema = JB; + function rS($, X) { + return $.schema === X.schema && $.root === X.root && $.baseId === X.baseId; + } + function oS($, X) { + let J; + while (typeof (J = this.refs[X]) == "string") X = J; + return J || this.schemas[X] || vQ.call(this, $, X); + } + function vQ($, X) { + let J = this.opts.uriResolver.parse(X), Q = (0, f6._getFullPath)(this.opts.uriResolver, J), Y = (0, f6.getFullPath)(this.opts.uriResolver, $.baseId, void 0); + if (Object.keys($.schema).length > 0 && Q === Y) return a3.call(this, J, $); + let z6 = (0, f6.normalizeId)(Q), W = this.refs[z6] || this.schemas[z6]; + if (typeof W == "string") { + let G = vQ.call(this, $, W); + if (typeof (G === null || G === void 0 ? void 0 : G.schema) !== "object") return; + return a3.call(this, J, G); + } + if (typeof (W === null || W === void 0 ? void 0 : W.schema) !== "object") return; + if (!W.validate) s3.call(this, W); + if (z6 === (0, f6.normalizeId)(X)) { + let { schema: G } = W, { schemaId: U } = this.opts, H = G[U]; + if (H) Y = (0, f6.resolveUrl)(this.opts.uriResolver, Y, H); + return new k9({ schema: G, schemaId: U, root: $, baseId: Y }); + } + return a3.call(this, J, W); + } + YB.resolveSchema = vQ; + var tS = /* @__PURE__ */ new Set(["properties", "patternProperties", "enum", "dependencies", "definitions"]); + function a3($, { baseId: X, schema: J, root: Q }) { + var Y; + if (((Y = $.fragment) === null || Y === void 0 ? void 0 : Y[0]) !== "/") return; + for (let G of $.fragment.slice(1).split("/")) { + if (typeof J === "boolean") return; + let U = J[(0, XB.unescapeFragment)(G)]; + if (U === void 0) return; + J = U; + let H = typeof J === "object" && J[this.opts.schemaId]; + if (!tS.has(G) && H) X = (0, f6.resolveUrl)(this.opts.uriResolver, X, H); + } + let z6; + if (typeof J != "boolean" && J.$ref && !(0, XB.schemaHasRulesButRef)(J, this.RULES)) { + let G = (0, f6.resolveUrl)(this.opts.uriResolver, X, J.$ref); + z6 = vQ.call(this, Q, G); + } + let { schemaId: W } = this.opts; + if (z6 = z6 || new k9({ schema: J, schemaId: W, root: Q, baseId: X }), z6.schema !== z6.root.schema) return z6; + return; + } +}); +var zB = k((ao, Xv) => { + Xv.exports = { $id: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#", description: "Meta-schema for $data reference (JSON AnySchema extension proposal)", type: "object", required: ["$data"], properties: { $data: { type: "string", anyOf: [{ format: "relative-json-pointer" }, { format: "json-pointer" }] } }, additionalProperties: false }; +}); +var GB = k((so, WB) => { + var Jv = { 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, a: 10, A: 10, b: 11, B: 11, c: 12, C: 12, d: 13, D: 13, e: 14, E: 14, f: 15, F: 15 }; + WB.exports = { HEX: Jv }; +}); +var BB = k((eo, wB) => { + var { HEX: Yv } = GB(), Qv = /^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u; + function NB($) { + if (OB($, ".") < 3) return { host: $, isIPV4: false }; + let X = $.match(Qv) || [], [J] = X; + if (J) return { host: Wv(J, "."), isIPV4: true }; + else return { host: $, isIPV4: false }; + } + function e3($, X = false) { + let J = "", Q = true; + for (let Y of $) { + if (Yv[Y] === void 0) return; + if (Y !== "0" && Q === true) Q = false; + if (!Q) J += Y; + } + if (X && J.length === 0) J = "0"; + return J; + } + function zv($) { + let X = 0, J = { error: false, address: "", zone: "" }, Q = [], Y = [], z6 = false, W = false, G = false; + function U() { + if (Y.length) { + if (z6 === false) { + let H = e3(Y); + if (H !== void 0) Q.push(H); + else return J.error = true, false; + } + Y.length = 0; + } + return true; + } + for (let H = 0; H < $.length; H++) { + let K = $[H]; + if (K === "[" || K === "]") continue; + if (K === ":") { + if (W === true) G = true; + if (!U()) break; + if (X++, Q.push(":"), X > 7) { + J.error = true; + break; + } + if (H - 1 >= 0 && $[H - 1] === ":") W = true; + continue; + } else if (K === "%") { + if (!U()) break; + z6 = true; + } else { + Y.push(K); + continue; + } + } + if (Y.length) if (z6) J.zone = Y.join(""); + else if (G) Q.push(Y.join("")); + else Q.push(e3(Y)); + return J.address = Q.join(""), J; + } + function VB($) { + if (OB($, ":") < 2) return { host: $, isIPV6: false }; + let X = zv($); + if (!X.error) { + let { address: J, address: Q } = X; + if (X.zone) J += "%" + X.zone, Q += "%25" + X.zone; + return { host: J, escapedHost: Q, isIPV6: true }; + } else return { host: $, isIPV6: false }; + } + function Wv($, X) { + let J = "", Q = true, Y = $.length; + for (let z6 = 0; z6 < Y; z6++) { + let W = $[z6]; + if (W === "0" && Q) { + if (z6 + 1 <= Y && $[z6 + 1] === X || z6 + 1 === Y) J += W, Q = false; + } else { + if (W === X) Q = true; + else Q = false; + J += W; + } + } + return J; + } + function OB($, X) { + let J = 0; + for (let Q = 0; Q < $.length; Q++) if ($[Q] === X) J++; + return J; + } + var UB = /^\.\.?\//u, HB = /^\/\.(?:\/|$)/u, KB = /^\/\.\.(?:\/|$)/u, Gv = /^\/?(?:.|\n)*?(?=\/|$)/u; + function Uv($) { + let X = []; + while ($.length) if ($.match(UB)) $ = $.replace(UB, ""); + else if ($.match(HB)) $ = $.replace(HB, "/"); + else if ($.match(KB)) $ = $.replace(KB, "/"), X.pop(); + else if ($ === "." || $ === "..") $ = ""; + else { + let J = $.match(Gv); + if (J) { + let Q = J[0]; + $ = $.slice(Q.length), X.push(Q); + } else throw Error("Unexpected dot segment condition"); + } + return X.join(""); + } + function Hv($, X) { + let J = X !== true ? escape : unescape; + if ($.scheme !== void 0) $.scheme = J($.scheme); + if ($.userinfo !== void 0) $.userinfo = J($.userinfo); + if ($.host !== void 0) $.host = J($.host); + if ($.path !== void 0) $.path = J($.path); + if ($.query !== void 0) $.query = J($.query); + if ($.fragment !== void 0) $.fragment = J($.fragment); + return $; + } + function Kv($) { + let X = []; + if ($.userinfo !== void 0) X.push($.userinfo), X.push("@"); + if ($.host !== void 0) { + let J = unescape($.host), Q = NB(J); + if (Q.isIPV4) J = Q.host; + else { + let Y = VB(Q.host); + if (Y.isIPV6 === true) J = `[${Y.escapedHost}]`; + else J = $.host; + } + X.push(J); + } + if (typeof $.port === "number" || typeof $.port === "string") X.push(":"), X.push(String($.port)); + return X.length ? X.join("") : void 0; + } + wB.exports = { recomposeAuthority: Kv, normalizeComponentEncoding: Hv, removeDotSegments: Uv, normalizeIPv4: NB, normalizeIPv6: VB, stringArrayToHexStripped: e3 }; +}); +var MB = k(($t, FB) => { + var Nv = /^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu, Vv = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu; + function qB($) { + return typeof $.secure === "boolean" ? $.secure : String($.scheme).toLowerCase() === "wss"; + } + function DB($) { + if (!$.host) $.error = $.error || "HTTP URIs must have a host."; + return $; + } + function LB($) { + let X = String($.scheme).toLowerCase() === "https"; + if ($.port === (X ? 443 : 80) || $.port === "") $.port = void 0; + if (!$.path) $.path = "/"; + return $; + } + function Ov($) { + return $.secure = qB($), $.resourceName = ($.path || "/") + ($.query ? "?" + $.query : ""), $.path = void 0, $.query = void 0, $; + } + function wv($) { + if ($.port === (qB($) ? 443 : 80) || $.port === "") $.port = void 0; + if (typeof $.secure === "boolean") $.scheme = $.secure ? "wss" : "ws", $.secure = void 0; + if ($.resourceName) { + let [X, J] = $.resourceName.split("?"); + $.path = X && X !== "/" ? X : void 0, $.query = J, $.resourceName = void 0; + } + return $.fragment = void 0, $; + } + function Bv($, X) { + if (!$.path) return $.error = "URN can not be parsed", $; + let J = $.path.match(Vv); + if (J) { + let Q = X.scheme || $.scheme || "urn"; + $.nid = J[1].toLowerCase(), $.nss = J[2]; + let Y = `${Q}:${X.nid || $.nid}`, z6 = $U[Y]; + if ($.path = void 0, z6) $ = z6.parse($, X); + } else $.error = $.error || "URN can not be parsed."; + return $; + } + function qv($, X) { + let J = X.scheme || $.scheme || "urn", Q = $.nid.toLowerCase(), Y = `${J}:${X.nid || Q}`, z6 = $U[Y]; + if (z6) $ = z6.serialize($, X); + let W = $, G = $.nss; + return W.path = `${Q || X.nid}:${G}`, X.skipEscape = true, W; + } + function Dv($, X) { + let J = $; + if (J.uuid = J.nss, J.nss = void 0, !X.tolerant && (!J.uuid || !Nv.test(J.uuid))) J.error = J.error || "UUID is not valid."; + return J; + } + function Lv($) { + let X = $; + return X.nss = ($.uuid || "").toLowerCase(), X; + } + var jB = { scheme: "http", domainHost: true, parse: DB, serialize: LB }, jv = { scheme: "https", domainHost: jB.domainHost, parse: DB, serialize: LB }, kQ = { scheme: "ws", domainHost: true, parse: Ov, serialize: wv }, Fv = { scheme: "wss", domainHost: kQ.domainHost, parse: kQ.parse, serialize: kQ.serialize }, Mv = { scheme: "urn", parse: Bv, serialize: qv, skipNormalize: true }, Iv = { scheme: "urn:uuid", parse: Dv, serialize: Lv, skipNormalize: true }, $U = { http: jB, https: jv, ws: kQ, wss: Fv, urn: Mv, "urn:uuid": Iv }; + FB.exports = $U; +}); +var AB = k((Xt, xQ) => { + var { normalizeIPv6: Av, normalizeIPv4: bv, removeDotSegments: _9, recomposeAuthority: Pv, normalizeComponentEncoding: _Q } = BB(), XU = MB(); + function Zv($, X) { + if (typeof $ === "string") $ = n6(D4($, X), X); + else if (typeof $ === "object") $ = D4(n6($, X), X); + return $; + } + function Ev($, X, J) { + let Q = Object.assign({ scheme: "null" }, J), Y = IB(D4($, Q), D4(X, Q), Q, true); + return n6(Y, { ...Q, skipEscape: true }); + } + function IB($, X, J, Q) { + let Y = {}; + if (!Q) $ = D4(n6($, J), J), X = D4(n6(X, J), J); + if (J = J || {}, !J.tolerant && X.scheme) Y.scheme = X.scheme, Y.userinfo = X.userinfo, Y.host = X.host, Y.port = X.port, Y.path = _9(X.path || ""), Y.query = X.query; + else { + if (X.userinfo !== void 0 || X.host !== void 0 || X.port !== void 0) Y.userinfo = X.userinfo, Y.host = X.host, Y.port = X.port, Y.path = _9(X.path || ""), Y.query = X.query; + else { + if (!X.path) if (Y.path = $.path, X.query !== void 0) Y.query = X.query; + else Y.query = $.query; + else { + if (X.path.charAt(0) === "/") Y.path = _9(X.path); + else { + if (($.userinfo !== void 0 || $.host !== void 0 || $.port !== void 0) && !$.path) Y.path = "/" + X.path; + else if (!$.path) Y.path = X.path; + else Y.path = $.path.slice(0, $.path.lastIndexOf("/") + 1) + X.path; + Y.path = _9(Y.path); + } + Y.query = X.query; + } + Y.userinfo = $.userinfo, Y.host = $.host, Y.port = $.port; + } + Y.scheme = $.scheme; + } + return Y.fragment = X.fragment, Y; + } + function Rv($, X, J) { + if (typeof $ === "string") $ = unescape($), $ = n6(_Q(D4($, J), true), { ...J, skipEscape: true }); + else if (typeof $ === "object") $ = n6(_Q($, true), { ...J, skipEscape: true }); + if (typeof X === "string") X = unescape(X), X = n6(_Q(D4(X, J), true), { ...J, skipEscape: true }); + else if (typeof X === "object") X = n6(_Q(X, true), { ...J, skipEscape: true }); + return $.toLowerCase() === X.toLowerCase(); + } + function n6($, X) { + let J = { host: $.host, scheme: $.scheme, userinfo: $.userinfo, port: $.port, path: $.path, query: $.query, nid: $.nid, nss: $.nss, uuid: $.uuid, fragment: $.fragment, reference: $.reference, resourceName: $.resourceName, secure: $.secure, error: "" }, Q = Object.assign({}, X), Y = [], z6 = XU[(Q.scheme || J.scheme || "").toLowerCase()]; + if (z6 && z6.serialize) z6.serialize(J, Q); + if (J.path !== void 0) if (!Q.skipEscape) { + if (J.path = escape(J.path), J.scheme !== void 0) J.path = J.path.split("%3A").join(":"); + } else J.path = unescape(J.path); + if (Q.reference !== "suffix" && J.scheme) Y.push(J.scheme, ":"); + let W = Pv(J); + if (W !== void 0) { + if (Q.reference !== "suffix") Y.push("//"); + if (Y.push(W), J.path && J.path.charAt(0) !== "/") Y.push("/"); + } + if (J.path !== void 0) { + let G = J.path; + if (!Q.absolutePath && (!z6 || !z6.absolutePath)) G = _9(G); + if (W === void 0) G = G.replace(/^\/\//u, "/%2F"); + Y.push(G); + } + if (J.query !== void 0) Y.push("?", J.query); + if (J.fragment !== void 0) Y.push("#", J.fragment); + return Y.join(""); + } + var Sv = Array.from({ length: 127 }, ($, X) => /[^!"$&'()*+,\-.;=_`a-z{}~]/u.test(String.fromCharCode(X))); + function vv($) { + let X = 0; + for (let J = 0, Q = $.length; J < Q; ++J) if (X = $.charCodeAt(J), X > 126 || Sv[X]) return true; + return false; + } + var Cv = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u; + function D4($, X) { + let J = Object.assign({}, X), Q = { scheme: void 0, userinfo: void 0, host: "", port: void 0, path: "", query: void 0, fragment: void 0 }, Y = $.indexOf("%") !== -1, z6 = false; + if (J.reference === "suffix") $ = (J.scheme ? J.scheme + ":" : "") + "//" + $; + let W = $.match(Cv); + if (W) { + if (Q.scheme = W[1], Q.userinfo = W[3], Q.host = W[4], Q.port = parseInt(W[5], 10), Q.path = W[6] || "", Q.query = W[7], Q.fragment = W[8], isNaN(Q.port)) Q.port = W[5]; + if (Q.host) { + let U = bv(Q.host); + if (U.isIPV4 === false) { + let H = Av(U.host); + Q.host = H.host.toLowerCase(), z6 = H.isIPV6; + } else Q.host = U.host, z6 = true; + } + if (Q.scheme === void 0 && Q.userinfo === void 0 && Q.host === void 0 && Q.port === void 0 && Q.query === void 0 && !Q.path) Q.reference = "same-document"; + else if (Q.scheme === void 0) Q.reference = "relative"; + else if (Q.fragment === void 0) Q.reference = "absolute"; + else Q.reference = "uri"; + if (J.reference && J.reference !== "suffix" && J.reference !== Q.reference) Q.error = Q.error || "URI is not a " + J.reference + " reference."; + let G = XU[(J.scheme || Q.scheme || "").toLowerCase()]; + if (!J.unicodeSupport && (!G || !G.unicodeSupport)) { + if (Q.host && (J.domainHost || G && G.domainHost) && z6 === false && vv(Q.host)) try { + Q.host = URL.domainToASCII(Q.host.toLowerCase()); + } catch (U) { + Q.error = Q.error || "Host's domain name can not be converted to ASCII: " + U; + } + } + if (!G || G && !G.skipNormalize) { + if (Y && Q.scheme !== void 0) Q.scheme = unescape(Q.scheme); + if (Y && Q.host !== void 0) Q.host = unescape(Q.host); + if (Q.path) Q.path = escape(unescape(Q.path)); + if (Q.fragment) Q.fragment = encodeURI(decodeURIComponent(Q.fragment)); + } + if (G && G.parse) G.parse(Q, J); + } else Q.error = Q.error || "URI can not be parsed."; + return Q; + } + var JU = { SCHEMES: XU, normalize: Zv, resolve: Ev, resolveComponents: IB, equal: Rv, serialize: n6, parse: D4 }; + xQ.exports = JU; + xQ.exports.default = JU; + xQ.exports.fastUri = JU; +}); +var ZB = k((PB) => { + Object.defineProperty(PB, "__esModule", { value: true }); + var bB = AB(); + bB.code = 'require("ajv/dist/runtime/uri").default'; + PB.default = bB; +}); +var xB = k((L4) => { + Object.defineProperty(L4, "__esModule", { value: true }); + L4.CodeGen = L4.Name = L4.nil = L4.stringify = L4.str = L4._ = L4.KeywordCxt = void 0; + var _v = v9(); + Object.defineProperty(L4, "KeywordCxt", { enumerable: true, get: function() { + return _v.KeywordCxt; + } }); + var l0 = a(); + Object.defineProperty(L4, "_", { enumerable: true, get: function() { + return l0._; + } }); + Object.defineProperty(L4, "str", { enumerable: true, get: function() { + return l0.str; + } }); + Object.defineProperty(L4, "stringify", { enumerable: true, get: function() { + return l0.stringify; + } }); + Object.defineProperty(L4, "nil", { enumerable: true, get: function() { + return l0.nil; + } }); + Object.defineProperty(L4, "Name", { enumerable: true, get: function() { + return l0.Name; + } }); + Object.defineProperty(L4, "CodeGen", { enumerable: true, get: function() { + return l0.CodeGen; + } }); + var xv = SQ(), CB = C9(), Tv = y3(), x9 = CQ(), yv = a(), T9 = E9(), TQ = Z9(), QU = Q$(), EB = zB(), fv = ZB(), kB = ($, X) => new RegExp($, X); + kB.code = "new RegExp"; + var gv = ["removeAdditional", "useDefaults", "coerceTypes"], hv = /* @__PURE__ */ new Set(["validate", "serialize", "parse", "wrapper", "root", "schema", "keyword", "pattern", "formats", "validate$data", "func", "obj", "Error"]), uv = { errorDataPath: "", format: "`validateFormats: false` can be used instead.", nullable: '"nullable" keyword is supported by default.', jsonPointers: "Deprecated jsPropertySyntax can be used instead.", extendRefs: "Deprecated ignoreKeywordsWithRef can be used instead.", missingRefs: "Pass empty schema with $id that should be ignored to ajv.addSchema.", processCode: "Use option `code: {process: (code, schemaEnv: object) => string}`", sourceCode: "Use option `code: {source: true}`", strictDefaults: "It is default now, see option `strict`.", strictKeywords: "It is default now, see option `strict`.", uniqueItems: '"uniqueItems" keyword is always validated.', unknownFormats: "Disable strict mode or pass `true` to `ajv.addFormat` (or `formats` option).", cache: "Map is used as cache, schema object as key.", serialize: "Map is used as cache, schema object as key.", ajvErrors: "It is default now." }, mv = { ignoreKeywordsWithRef: "", jsPropertySyntax: "", unicode: '"minLength"/"maxLength" account for unicode characters by default.' }, RB = 200; + function lv($) { + var X, J, Q, Y, z6, W, G, U, H, K, V, O, N, w, B, L, j, I, b, x, h, B$, x$, G6, o6; + let u6 = $.strict, a4 = (X = $.code) === null || X === void 0 ? void 0 : X.optimize, _1 = a4 === true || a4 === void 0 ? 1 : a4 || 0, t6 = (Q = (J = $.code) === null || J === void 0 ? void 0 : J.regExp) !== null && Q !== void 0 ? Q : kB, r0 = (Y = $.uriResolver) !== null && Y !== void 0 ? Y : fv.default; + return { strictSchema: (W = (z6 = $.strictSchema) !== null && z6 !== void 0 ? z6 : u6) !== null && W !== void 0 ? W : true, strictNumbers: (U = (G = $.strictNumbers) !== null && G !== void 0 ? G : u6) !== null && U !== void 0 ? U : true, strictTypes: (K = (H = $.strictTypes) !== null && H !== void 0 ? H : u6) !== null && K !== void 0 ? K : "log", strictTuples: (O = (V = $.strictTuples) !== null && V !== void 0 ? V : u6) !== null && O !== void 0 ? O : "log", strictRequired: (w = (N = $.strictRequired) !== null && N !== void 0 ? N : u6) !== null && w !== void 0 ? w : false, code: $.code ? { ...$.code, optimize: _1, regExp: t6 } : { optimize: _1, regExp: t6 }, loopRequired: (B = $.loopRequired) !== null && B !== void 0 ? B : RB, loopEnum: (L = $.loopEnum) !== null && L !== void 0 ? L : RB, meta: (j = $.meta) !== null && j !== void 0 ? j : true, messages: (I = $.messages) !== null && I !== void 0 ? I : true, inlineRefs: (b = $.inlineRefs) !== null && b !== void 0 ? b : true, schemaId: (x = $.schemaId) !== null && x !== void 0 ? x : "$id", addUsedSchema: (h = $.addUsedSchema) !== null && h !== void 0 ? h : true, validateSchema: (B$ = $.validateSchema) !== null && B$ !== void 0 ? B$ : true, validateFormats: (x$ = $.validateFormats) !== null && x$ !== void 0 ? x$ : true, unicodeRegExp: (G6 = $.unicodeRegExp) !== null && G6 !== void 0 ? G6 : true, int32range: (o6 = $.int32range) !== null && o6 !== void 0 ? o6 : true, uriResolver: r0 }; + } + class yQ { + constructor($ = {}) { + this.schemas = {}, this.refs = {}, this.formats = {}, this._compilations = /* @__PURE__ */ new Set(), this._loading = {}, this._cache = /* @__PURE__ */ new Map(), $ = this.opts = { ...$, ...lv($) }; + let { es5: X, lines: J } = this.opts.code; + this.scope = new yv.ValueScope({ scope: {}, prefixes: hv, es5: X, lines: J }), this.logger = rv($.logger); + let Q = $.validateFormats; + if ($.validateFormats = false, this.RULES = (0, Tv.getRules)(), SB.call(this, uv, $, "NOT SUPPORTED"), SB.call(this, mv, $, "DEPRECATED", "warn"), this._metaOpts = nv.call(this), $.formats) pv.call(this); + if (this._addVocabularies(), this._addDefaultMetaSchema(), $.keywords) iv.call(this, $.keywords); + if (typeof $.meta == "object") this.addMetaSchema($.meta); + cv.call(this), $.validateFormats = Q; + } + _addVocabularies() { + this.addKeyword("$async"); + } + _addDefaultMetaSchema() { + let { $data: $, meta: X, schemaId: J } = this.opts, Q = EB; + if (J === "id") Q = { ...EB }, Q.id = Q.$id, delete Q.$id; + if (X && $) this.addMetaSchema(Q, Q[J], false); + } + defaultMeta() { + let { meta: $, schemaId: X } = this.opts; + return this.opts.defaultMeta = typeof $ == "object" ? $[X] || $ : void 0; + } + validate($, X) { + let J; + if (typeof $ == "string") { + if (J = this.getSchema($), !J) throw Error(`no schema with key or ref "${$}"`); + } else J = this.compile($); + let Q = J(X); + if (!("$async" in J)) this.errors = J.errors; + return Q; + } + compile($, X) { + let J = this._addSchema($, X); + return J.validate || this._compileSchemaEnv(J); + } + compileAsync($, X) { + if (typeof this.opts.loadSchema != "function") throw Error("options.loadSchema should be a function"); + let { loadSchema: J } = this.opts; + return Q.call(this, $, X); + async function Q(H, K) { + await Y.call(this, H.$schema); + let V = this._addSchema(H, K); + return V.validate || z6.call(this, V); + } + async function Y(H) { + if (H && !this.getSchema(H)) await Q.call(this, { $ref: H }, true); + } + async function z6(H) { + try { + return this._compileSchemaEnv(H); + } catch (K) { + if (!(K instanceof CB.default)) throw K; + return W.call(this, K), await G.call(this, K.missingSchema), z6.call(this, H); + } + } + function W({ missingSchema: H, missingRef: K }) { + if (this.refs[H]) throw Error(`AnySchema ${H} is loaded but ${K} cannot be resolved`); + } + async function G(H) { + let K = await U.call(this, H); + if (!this.refs[H]) await Y.call(this, K.$schema); + if (!this.refs[H]) this.addSchema(K, H, X); + } + async function U(H) { + let K = this._loading[H]; + if (K) return K; + try { + return await (this._loading[H] = J(H)); + } finally { + delete this._loading[H]; + } + } + } + addSchema($, X, J, Q = this.opts.validateSchema) { + if (Array.isArray($)) { + for (let z6 of $) this.addSchema(z6, void 0, J, Q); + return this; + } + let Y; + if (typeof $ === "object") { + let { schemaId: z6 } = this.opts; + if (Y = $[z6], Y !== void 0 && typeof Y != "string") throw Error(`schema ${z6} must be string`); + } + return X = (0, T9.normalizeId)(X || Y), this._checkUnique(X), this.schemas[X] = this._addSchema($, J, X, Q, true), this; + } + addMetaSchema($, X, J = this.opts.validateSchema) { + return this.addSchema($, X, true, J), this; + } + validateSchema($, X) { + if (typeof $ == "boolean") return true; + let J; + if (J = $.$schema, J !== void 0 && typeof J != "string") throw Error("$schema must be a string"); + if (J = J || this.opts.defaultMeta || this.defaultMeta(), !J) return this.logger.warn("meta-schema not available"), this.errors = null, true; + let Q = this.validate(J, $); + if (!Q && X) { + let Y = "schema is invalid: " + this.errorsText(); + if (this.opts.validateSchema === "log") this.logger.error(Y); + else throw Error(Y); + } + return Q; + } + getSchema($) { + let X; + while (typeof (X = vB.call(this, $)) == "string") $ = X; + if (X === void 0) { + let { schemaId: J } = this.opts, Q = new x9.SchemaEnv({ schema: {}, schemaId: J }); + if (X = x9.resolveSchema.call(this, Q, $), !X) return; + this.refs[$] = X; + } + return X.validate || this._compileSchemaEnv(X); + } + removeSchema($) { + if ($ instanceof RegExp) return this._removeAllSchemas(this.schemas, $), this._removeAllSchemas(this.refs, $), this; + switch (typeof $) { + case "undefined": + return this._removeAllSchemas(this.schemas), this._removeAllSchemas(this.refs), this._cache.clear(), this; + case "string": { + let X = vB.call(this, $); + if (typeof X == "object") this._cache.delete(X.schema); + return delete this.schemas[$], delete this.refs[$], this; + } + case "object": { + let X = $; + this._cache.delete(X); + let J = $[this.opts.schemaId]; + if (J) J = (0, T9.normalizeId)(J), delete this.schemas[J], delete this.refs[J]; + return this; + } + default: + throw Error("ajv.removeSchema: invalid parameter"); + } + } + addVocabulary($) { + for (let X of $) this.addKeyword(X); + return this; + } + addKeyword($, X) { + let J; + if (typeof $ == "string") { + if (J = $, typeof X == "object") this.logger.warn("these parameters are deprecated, see docs for addKeyword"), X.keyword = J; + } else if (typeof $ == "object" && X === void 0) { + if (X = $, J = X.keyword, Array.isArray(J) && !J.length) throw Error("addKeywords: keyword must be string or non-empty array"); + } else throw Error("invalid addKeywords parameters"); + if (tv.call(this, J, X), !X) return (0, QU.eachItem)(J, (Y) => YU.call(this, Y)), this; + sv.call(this, X); + let Q = { ...X, type: (0, TQ.getJSONTypes)(X.type), schemaType: (0, TQ.getJSONTypes)(X.schemaType) }; + return (0, QU.eachItem)(J, Q.type.length === 0 ? (Y) => YU.call(this, Y, Q) : (Y) => Q.type.forEach((z6) => YU.call(this, Y, Q, z6))), this; + } + getKeyword($) { + let X = this.RULES.all[$]; + return typeof X == "object" ? X.definition : !!X; + } + removeKeyword($) { + let { RULES: X } = this; + delete X.keywords[$], delete X.all[$]; + for (let J of X.rules) { + let Q = J.rules.findIndex((Y) => Y.keyword === $); + if (Q >= 0) J.rules.splice(Q, 1); + } + return this; + } + addFormat($, X) { + if (typeof X == "string") X = new RegExp(X); + return this.formats[$] = X, this; + } + errorsText($ = this.errors, { separator: X = ", ", dataVar: J = "data" } = {}) { + if (!$ || $.length === 0) return "No errors"; + return $.map((Q) => `${J}${Q.instancePath} ${Q.message}`).reduce((Q, Y) => Q + X + Y); + } + $dataMetaSchema($, X) { + let J = this.RULES.all; + $ = JSON.parse(JSON.stringify($)); + for (let Q of X) { + let Y = Q.split("/").slice(1), z6 = $; + for (let W of Y) z6 = z6[W]; + for (let W in J) { + let G = J[W]; + if (typeof G != "object") continue; + let { $data: U } = G.definition, H = z6[W]; + if (U && H) z6[W] = _B(H); + } + } + return $; + } + _removeAllSchemas($, X) { + for (let J in $) { + let Q = $[J]; + if (!X || X.test(J)) { + if (typeof Q == "string") delete $[J]; + else if (Q && !Q.meta) this._cache.delete(Q.schema), delete $[J]; + } + } + } + _addSchema($, X, J, Q = this.opts.validateSchema, Y = this.opts.addUsedSchema) { + let z6, { schemaId: W } = this.opts; + if (typeof $ == "object") z6 = $[W]; + else if (this.opts.jtd) throw Error("schema must be object"); + else if (typeof $ != "boolean") throw Error("schema must be object or boolean"); + let G = this._cache.get($); + if (G !== void 0) return G; + J = (0, T9.normalizeId)(z6 || J); + let U = T9.getSchemaRefs.call(this, $, J); + if (G = new x9.SchemaEnv({ schema: $, schemaId: W, meta: X, baseId: J, localRefs: U }), this._cache.set(G.schema, G), Y && !J.startsWith("#")) { + if (J) this._checkUnique(J); + this.refs[J] = G; + } + if (Q) this.validateSchema($, true); + return G; + } + _checkUnique($) { + if (this.schemas[$] || this.refs[$]) throw Error(`schema with key or id "${$}" already exists`); + } + _compileSchemaEnv($) { + if ($.meta) this._compileMetaSchema($); + else x9.compileSchema.call(this, $); + if (!$.validate) throw Error("ajv implementation error"); + return $.validate; + } + _compileMetaSchema($) { + let X = this.opts; + this.opts = this._metaOpts; + try { + x9.compileSchema.call(this, $); + } finally { + this.opts = X; + } + } + } + yQ.ValidationError = xv.default; + yQ.MissingRefError = CB.default; + L4.default = yQ; + function SB($, X, J, Q = "error") { + for (let Y in $) { + let z6 = Y; + if (z6 in X) this.logger[Q](`${J}: option ${Y}. ${$[z6]}`); + } + } + function vB($) { + return $ = (0, T9.normalizeId)($), this.schemas[$] || this.refs[$]; + } + function cv() { + let $ = this.opts.schemas; + if (!$) return; + if (Array.isArray($)) this.addSchema($); + else for (let X in $) this.addSchema($[X], X); + } + function pv() { + for (let $ in this.opts.formats) { + let X = this.opts.formats[$]; + if (X) this.addFormat($, X); + } + } + function iv($) { + if (Array.isArray($)) { + this.addVocabulary($); + return; + } + this.logger.warn("keywords option as map is deprecated, pass array"); + for (let X in $) { + let J = $[X]; + if (!J.keyword) J.keyword = X; + this.addKeyword(J); + } + } + function nv() { + let $ = { ...this.opts }; + for (let X of gv) delete $[X]; + return $; + } + var dv = { log() { + }, warn() { + }, error() { + } }; + function rv($) { + if ($ === false) return dv; + if ($ === void 0) return console; + if ($.log && $.warn && $.error) return $; + throw Error("logger must implement log, warn and error methods"); + } + var ov = /^[a-z_$][a-z0-9_$:-]*$/i; + function tv($, X) { + let { RULES: J } = this; + if ((0, QU.eachItem)($, (Q) => { + if (J.keywords[Q]) throw Error(`Keyword ${Q} is already defined`); + if (!ov.test(Q)) throw Error(`Keyword ${Q} has invalid name`); + }), !X) return; + if (X.$data && !("code" in X || "validate" in X)) throw Error('$data keyword must have "code" or "validate" function'); + } + function YU($, X, J) { + var Q; + let Y = X === null || X === void 0 ? void 0 : X.post; + if (J && Y) throw Error('keyword with "post" flag cannot have "type"'); + let { RULES: z6 } = this, W = Y ? z6.post : z6.rules.find(({ type: U }) => U === J); + if (!W) W = { type: J, rules: [] }, z6.rules.push(W); + if (z6.keywords[$] = true, !X) return; + let G = { keyword: $, definition: { ...X, type: (0, TQ.getJSONTypes)(X.type), schemaType: (0, TQ.getJSONTypes)(X.schemaType) } }; + if (X.before) av.call(this, W, G, X.before); + else W.rules.push(G); + z6.all[$] = G, (Q = X.implements) === null || Q === void 0 || Q.forEach((U) => this.addKeyword(U)); + } + function av($, X, J) { + let Q = $.rules.findIndex((Y) => Y.keyword === J); + if (Q >= 0) $.rules.splice(Q, 0, X); + else $.rules.push(X), this.logger.warn(`rule ${J} is not defined`); + } + function sv($) { + let { metaSchema: X } = $; + if (X === void 0) return; + if ($.$data && this.opts.$data) X = _B(X); + $.validateSchema = this.compile(X, true); + } + var ev = { $ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#" }; + function _B($) { + return { anyOf: [$, ev] }; + } +}); +var yB = k((TB) => { + Object.defineProperty(TB, "__esModule", { value: true }); + var JC = { keyword: "id", code() { + throw Error('NOT SUPPORTED: keyword "id", use "$id" for schema ID'); + } }; + TB.default = JC; +}); +var lB = k((uB) => { + Object.defineProperty(uB, "__esModule", { value: true }); + uB.callRef = uB.getValidate = void 0; + var QC = C9(), fB = Z6(), z6 = a(), c0 = B4(), gB = CQ(), fQ = Q$(), zC = { keyword: "$ref", schemaType: "string", code($) { + let { gen: X, schema: J, it: Q } = $, { baseId: Y, schemaEnv: z10, validateName: W, opts: G, self: U } = Q, { root: H } = z10; + if ((J === "#" || J === "#/") && Y === H.baseId) return V(); + let K = gB.resolveRef.call(U, H, Y, J); + if (K === void 0) throw new QC.default(Q.opts.uriResolver, Y, J); + if (K instanceof gB.SchemaEnv) return O(K); + return N(K); + function V() { + if (z10 === H) return gQ($, W, z10, z10.$async); + let w = X.scopeValue("root", { ref: H }); + return gQ($, z6._`${w}.validate`, H, H.$async); + } + function O(w) { + let B = hB($, w); + gQ($, B, w, w.$async); + } + function N(w) { + let B = X.scopeValue("schema", G.code.source === true ? { ref: w, code: (0, z6.stringify)(w) } : { ref: w }), L = X.name("valid"), j = $.subschema({ schema: w, dataTypes: [], schemaPath: z6.nil, topSchemaRef: B, errSchemaPath: J }, L); + $.mergeEvaluated(j), $.ok(L); + } + } }; + function hB($, X) { + let { gen: J } = $; + return X.validate ? J.scopeValue("validate", { ref: X.validate }) : z6._`${J.scopeValue("wrapper", { ref: X })}.validate`; + } + uB.getValidate = hB; + function gQ($, X, J, Q) { + let { gen: Y, it: z10 } = $, { allErrors: W, schemaEnv: G, opts: U } = z10, H = U.passContext ? c0.default.this : z6.nil; + if (Q) K(); + else V(); + function K() { + if (!G.$async) throw Error("async schema referenced by sync schema"); + let w = Y.let("valid"); + Y.try(() => { + if (Y.code(z6._`await ${(0, fB.callValidateCode)($, X, H)}`), N(X), !W) Y.assign(w, true); + }, (B) => { + if (Y.if(z6._`!(${B} instanceof ${z10.ValidationError})`, () => Y.throw(B)), O(B), !W) Y.assign(w, false); + }), $.ok(w); + } + function V() { + $.result((0, fB.callValidateCode)($, X, H), () => N(X), () => O(X)); + } + function O(w) { + let B = z6._`${w}.errors`; + Y.assign(c0.default.vErrors, z6._`${c0.default.vErrors} === null ? ${B} : ${c0.default.vErrors}.concat(${B})`), Y.assign(c0.default.errors, z6._`${c0.default.vErrors}.length`); + } + function N(w) { + var B; + if (!z10.opts.unevaluated) return; + let L = (B = J === null || J === void 0 ? void 0 : J.validate) === null || B === void 0 ? void 0 : B.evaluated; + if (z10.props !== true) if (L && !L.dynamicProps) { + if (L.props !== void 0) z10.props = fQ.mergeEvaluated.props(Y, L.props, z10.props); + } else { + let j = Y.var("props", z6._`${w}.evaluated.props`); + z10.props = fQ.mergeEvaluated.props(Y, j, z10.props, z6.Name); + } + if (z10.items !== true) if (L && !L.dynamicItems) { + if (L.items !== void 0) z10.items = fQ.mergeEvaluated.items(Y, L.items, z10.items); + } else { + let j = Y.var("items", z6._`${w}.evaluated.items`); + z10.items = fQ.mergeEvaluated.items(Y, j, z10.items, z6.Name); + } + } + } + uB.callRef = gQ; + uB.default = zC; +}); +var pB = k((cB) => { + Object.defineProperty(cB, "__esModule", { value: true }); + var UC = yB(), HC = lB(), KC = ["$schema", "$id", "$defs", "$vocabulary", { keyword: "$comment" }, "definitions", UC.default, HC.default]; + cB.default = KC; +}); +var nB = k((iB) => { + Object.defineProperty(iB, "__esModule", { value: true }); + var hQ = a(), r4 = hQ.operators, uQ = { maximum: { okStr: "<=", ok: r4.LTE, fail: r4.GT }, minimum: { okStr: ">=", ok: r4.GTE, fail: r4.LT }, exclusiveMaximum: { okStr: "<", ok: r4.LT, fail: r4.GTE }, exclusiveMinimum: { okStr: ">", ok: r4.GT, fail: r4.LTE } }, VC = { message: ({ keyword: $, schemaCode: X }) => hQ.str`must be ${uQ[$].okStr} ${X}`, params: ({ keyword: $, schemaCode: X }) => hQ._`{comparison: ${uQ[$].okStr}, limit: ${X}}` }, OC = { keyword: Object.keys(uQ), type: "number", schemaType: "number", $data: true, error: VC, code($) { + let { keyword: X, data: J, schemaCode: Q } = $; + $.fail$data(hQ._`${J} ${uQ[X].fail} ${Q} || isNaN(${J})`); + } }; + iB.default = OC; +}); +var rB = k((dB) => { + Object.defineProperty(dB, "__esModule", { value: true }); + var y9 = a(), BC = { message: ({ schemaCode: $ }) => y9.str`must be multiple of ${$}`, params: ({ schemaCode: $ }) => y9._`{multipleOf: ${$}}` }, qC = { keyword: "multipleOf", type: "number", schemaType: "number", $data: true, error: BC, code($) { + let { gen: X, data: J, schemaCode: Q, it: Y } = $, z6 = Y.opts.multipleOfPrecision, W = X.let("res"), G = z6 ? y9._`Math.abs(Math.round(${W}) - ${W}) > 1e-${z6}` : y9._`${W} !== parseInt(${W})`; + $.fail$data(y9._`(${Q} === 0 || (${W} = ${J}/${Q}, ${G}))`); + } }; + dB.default = qC; +}); +var aB = k((tB) => { + Object.defineProperty(tB, "__esModule", { value: true }); + function oB($) { + let X = $.length, J = 0, Q = 0, Y; + while (Q < X) if (J++, Y = $.charCodeAt(Q++), Y >= 55296 && Y <= 56319 && Q < X) { + if (Y = $.charCodeAt(Q), (Y & 64512) === 56320) Q++; + } + return J; + } + tB.default = oB; + oB.code = 'require("ajv/dist/runtime/ucs2length").default'; +}); +var eB = k((sB) => { + Object.defineProperty(sB, "__esModule", { value: true }); + var C1 = a(), jC = Q$(), FC = aB(), MC = { message({ keyword: $, schemaCode: X }) { + let J = $ === "maxLength" ? "more" : "fewer"; + return C1.str`must NOT have ${J} than ${X} characters`; + }, params: ({ schemaCode: $ }) => C1._`{limit: ${$}}` }, IC = { keyword: ["maxLength", "minLength"], type: "string", schemaType: "number", $data: true, error: MC, code($) { + let { keyword: X, data: J, schemaCode: Q, it: Y } = $, z6 = X === "maxLength" ? C1.operators.GT : C1.operators.LT, W = Y.opts.unicode === false ? C1._`${J}.length` : C1._`${(0, jC.useFunc)($.gen, FC.default)}(${J})`; + $.fail$data(C1._`${W} ${z6} ${Q}`); + } }; + sB.default = IC; +}); +var Xq = k(($q) => { + Object.defineProperty($q, "__esModule", { value: true }); + var bC = Z6(), PC = Q$(), p0 = a(), ZC = { message: ({ schemaCode: $ }) => p0.str`must match pattern "${$}"`, params: ({ schemaCode: $ }) => p0._`{pattern: ${$}}` }, EC = { keyword: "pattern", type: "string", schemaType: "string", $data: true, error: ZC, code($) { + let { gen: X, data: J, $data: Q, schema: Y, schemaCode: z6, it: W } = $, G = W.opts.unicodeRegExp ? "u" : ""; + if (Q) { + let { regExp: U } = W.opts.code, H = U.code === "new RegExp" ? p0._`new RegExp` : (0, PC.useFunc)(X, U), K = X.let("valid"); + X.try(() => X.assign(K, p0._`${H}(${z6}, ${G}).test(${J})`), () => X.assign(K, false)), $.fail$data(p0._`!${K}`); + } else { + let U = (0, bC.usePattern)($, Y); + $.fail$data(p0._`!${U}.test(${J})`); + } + } }; + $q.default = EC; +}); +var Yq = k((Jq) => { + Object.defineProperty(Jq, "__esModule", { value: true }); + var f9 = a(), SC = { message({ keyword: $, schemaCode: X }) { + let J = $ === "maxProperties" ? "more" : "fewer"; + return f9.str`must NOT have ${J} than ${X} properties`; + }, params: ({ schemaCode: $ }) => f9._`{limit: ${$}}` }, vC = { keyword: ["maxProperties", "minProperties"], type: "object", schemaType: "number", $data: true, error: SC, code($) { + let { keyword: X, data: J, schemaCode: Q } = $, Y = X === "maxProperties" ? f9.operators.GT : f9.operators.LT; + $.fail$data(f9._`Object.keys(${J}).length ${Y} ${Q}`); + } }; + Jq.default = vC; +}); +var zq = k((Qq) => { + Object.defineProperty(Qq, "__esModule", { value: true }); + var g9 = Z6(), h9 = a(), kC = Q$(), _C = { message: ({ params: { missingProperty: $ } }) => h9.str`must have required property '${$}'`, params: ({ params: { missingProperty: $ } }) => h9._`{missingProperty: ${$}}` }, xC = { keyword: "required", type: "object", schemaType: "array", $data: true, error: _C, code($) { + let { gen: X, schema: J, schemaCode: Q, data: Y, $data: z6, it: W } = $, { opts: G } = W; + if (!z6 && J.length === 0) return; + let U = J.length >= G.loopRequired; + if (W.allErrors) H(); + else K(); + if (G.strictRequired) { + let N = $.parentSchema.properties, { definedProperties: w } = $.it; + for (let B of J) if ((N === null || N === void 0 ? void 0 : N[B]) === void 0 && !w.has(B)) { + let L = W.schemaEnv.baseId + W.errSchemaPath, j = `required property "${B}" is not defined at "${L}" (strictRequired)`; + (0, kC.checkStrictMode)(W, j, W.opts.strictRequired); + } + } + function H() { + if (U || z6) $.block$data(h9.nil, V); + else for (let N of J) (0, g9.checkReportMissingProp)($, N); + } + function K() { + let N = X.let("missing"); + if (U || z6) { + let w = X.let("valid", true); + $.block$data(w, () => O(N, w)), $.ok(w); + } else X.if((0, g9.checkMissingProp)($, J, N)), (0, g9.reportMissingProp)($, N), X.else(); + } + function V() { + X.forOf("prop", Q, (N) => { + $.setParams({ missingProperty: N }), X.if((0, g9.noPropertyInData)(X, Y, N, G.ownProperties), () => $.error()); + }); + } + function O(N, w) { + $.setParams({ missingProperty: N }), X.forOf(N, Q, () => { + X.assign(w, (0, g9.propertyInData)(X, Y, N, G.ownProperties)), X.if((0, h9.not)(w), () => { + $.error(), X.break(); + }); + }, h9.nil); + } + } }; + Qq.default = xC; +}); +var Gq = k((Wq) => { + Object.defineProperty(Wq, "__esModule", { value: true }); + var u9 = a(), yC = { message({ keyword: $, schemaCode: X }) { + let J = $ === "maxItems" ? "more" : "fewer"; + return u9.str`must NOT have ${J} than ${X} items`; + }, params: ({ schemaCode: $ }) => u9._`{limit: ${$}}` }, fC = { keyword: ["maxItems", "minItems"], type: "array", schemaType: "number", $data: true, error: yC, code($) { + let { keyword: X, data: J, schemaCode: Q } = $, Y = X === "maxItems" ? u9.operators.GT : u9.operators.LT; + $.fail$data(u9._`${J}.length ${Y} ${Q}`); + } }; + Wq.default = fC; +}); +var mQ = k((Hq) => { + Object.defineProperty(Hq, "__esModule", { value: true }); + var Uq = p3(); + Uq.code = 'require("ajv/dist/runtime/equal").default'; + Hq.default = Uq; +}); +var Nq = k((Kq) => { + Object.defineProperty(Kq, "__esModule", { value: true }); + var zU = Z9(), h$ = a(), uC = Q$(), mC = mQ(), lC = { message: ({ params: { i: $, j: X } }) => h$.str`must NOT have duplicate items (items ## ${X} and ${$} are identical)`, params: ({ params: { i: $, j: X } }) => h$._`{i: ${$}, j: ${X}}` }, cC = { keyword: "uniqueItems", type: "array", schemaType: "boolean", $data: true, error: lC, code($) { + let { gen: X, data: J, $data: Q, schema: Y, parentSchema: z6, schemaCode: W, it: G } = $; + if (!Q && !Y) return; + let U = X.let("valid"), H = z6.items ? (0, zU.getSchemaTypes)(z6.items) : []; + $.block$data(U, K, h$._`${W} === false`), $.ok(U); + function K() { + let w = X.let("i", h$._`${J}.length`), B = X.let("j"); + $.setParams({ i: w, j: B }), X.assign(U, true), X.if(h$._`${w} > 1`, () => (V() ? O : N)(w, B)); + } + function V() { + return H.length > 0 && !H.some((w) => w === "object" || w === "array"); + } + function O(w, B) { + let L = X.name("item"), j = (0, zU.checkDataTypes)(H, L, G.opts.strictNumbers, zU.DataType.Wrong), I = X.const("indices", h$._`{}`); + X.for(h$._`;${w}--;`, () => { + if (X.let(L, h$._`${J}[${w}]`), X.if(j, h$._`continue`), H.length > 1) X.if(h$._`typeof ${L} == "string"`, h$._`${L} += "_"`); + X.if(h$._`typeof ${I}[${L}] == "number"`, () => { + X.assign(B, h$._`${I}[${L}]`), $.error(), X.assign(U, false).break(); + }).code(h$._`${I}[${L}] = ${w}`); + }); + } + function N(w, B) { + let L = (0, uC.useFunc)(X, mC.default), j = X.name("outer"); + X.label(j).for(h$._`;${w}--;`, () => X.for(h$._`${B} = ${w}; ${B}--;`, () => X.if(h$._`${L}(${J}[${w}], ${J}[${B}])`, () => { + $.error(), X.assign(U, false).break(j); + }))); + } + } }; + Kq.default = cC; +}); +var Oq = k((Vq) => { + Object.defineProperty(Vq, "__esModule", { value: true }); + var WU = a(), iC = Q$(), nC = mQ(), dC = { message: "must be equal to constant", params: ({ schemaCode: $ }) => WU._`{allowedValue: ${$}}` }, rC = { keyword: "const", $data: true, error: dC, code($) { + let { gen: X, data: J, $data: Q, schemaCode: Y, schema: z6 } = $; + if (Q || z6 && typeof z6 == "object") $.fail$data(WU._`!${(0, iC.useFunc)(X, nC.default)}(${J}, ${Y})`); + else $.fail(WU._`${z6} !== ${J}`); + } }; + Vq.default = rC; +}); +var Bq = k((wq) => { + Object.defineProperty(wq, "__esModule", { value: true }); + var m9 = a(), tC = Q$(), aC = mQ(), sC = { message: "must be equal to one of the allowed values", params: ({ schemaCode: $ }) => m9._`{allowedValues: ${$}}` }, eC = { keyword: "enum", schemaType: "array", $data: true, error: sC, code($) { + let { gen: X, data: J, $data: Q, schema: Y, schemaCode: z6, it: W } = $; + if (!Q && Y.length === 0) throw Error("enum must have non-empty array"); + let G = Y.length >= W.opts.loopEnum, U, H = () => U !== null && U !== void 0 ? U : U = (0, tC.useFunc)(X, aC.default), K; + if (G || Q) K = X.let("valid"), $.block$data(K, V); + else { + if (!Array.isArray(Y)) throw Error("ajv implementation error"); + let N = X.const("vSchema", z6); + K = (0, m9.or)(...Y.map((w, B) => O(N, B))); + } + $.pass(K); + function V() { + X.assign(K, false), X.forOf("v", z6, (N) => X.if(m9._`${H()}(${J}, ${N})`, () => X.assign(K, true).break())); + } + function O(N, w) { + let B = Y[w]; + return typeof B === "object" && B !== null ? m9._`${H()}(${J}, ${N}[${w}])` : m9._`${J} === ${B}`; + } + } }; + wq.default = eC; +}); +var Dq = k((qq) => { + Object.defineProperty(qq, "__esModule", { value: true }); + var Xk = nB(), Jk = rB(), Yk = eB(), Qk = Xq(), zk = Yq(), Wk = zq(), Gk = Gq(), Uk = Nq(), Hk = Oq(), Kk = Bq(), Nk = [Xk.default, Jk.default, Yk.default, Qk.default, zk.default, Wk.default, Gk.default, Uk.default, { keyword: "type", schemaType: ["string", "array"] }, { keyword: "nullable", schemaType: "boolean" }, Hk.default, Kk.default]; + qq.default = Nk; +}); +var UU = k((jq) => { + Object.defineProperty(jq, "__esModule", { value: true }); + jq.validateAdditionalItems = void 0; + var k1 = a(), GU = Q$(), Ok = { message: ({ params: { len: $ } }) => k1.str`must NOT have more than ${$} items`, params: ({ params: { len: $ } }) => k1._`{limit: ${$}}` }, wk = { keyword: "additionalItems", type: "array", schemaType: ["boolean", "object"], before: "uniqueItems", error: Ok, code($) { + let { parentSchema: X, it: J } = $, { items: Q } = X; + if (!Array.isArray(Q)) { + (0, GU.checkStrictMode)(J, '"additionalItems" is ignored when "items" is not an array of schemas'); + return; + } + Lq($, Q); + } }; + function Lq($, X) { + let { gen: J, schema: Q, data: Y, keyword: z6, it: W } = $; + W.items = true; + let G = J.const("len", k1._`${Y}.length`); + if (Q === false) $.setParams({ len: X.length }), $.pass(k1._`${G} <= ${X.length}`); + else if (typeof Q == "object" && !(0, GU.alwaysValidSchema)(W, Q)) { + let H = J.var("valid", k1._`${G} <= ${X.length}`); + J.if((0, k1.not)(H), () => U(H)), $.ok(H); + } + function U(H) { + J.forRange("i", X.length, G, (K) => { + if ($.subschema({ keyword: z6, dataProp: K, dataPropType: GU.Type.Num }, H), !W.allErrors) J.if((0, k1.not)(H), () => J.break()); + }); + } + } + jq.validateAdditionalItems = Lq; + jq.default = wk; +}); +var HU = k((Aq) => { + Object.defineProperty(Aq, "__esModule", { value: true }); + Aq.validateTuple = void 0; + var Mq = a(), lQ = Q$(), qk = Z6(), Dk = { keyword: "items", type: "array", schemaType: ["object", "array", "boolean"], before: "uniqueItems", code($) { + let { schema: X, it: J } = $; + if (Array.isArray(X)) return Iq($, "additionalItems", X); + if (J.items = true, (0, lQ.alwaysValidSchema)(J, X)) return; + $.ok((0, qk.validateArray)($)); + } }; + function Iq($, X, J = $.schema) { + let { gen: Q, parentSchema: Y, data: z6, keyword: W, it: G } = $; + if (K(Y), G.opts.unevaluated && J.length && G.items !== true) G.items = lQ.mergeEvaluated.items(Q, J.length, G.items); + let U = Q.name("valid"), H = Q.const("len", Mq._`${z6}.length`); + J.forEach((V, O) => { + if ((0, lQ.alwaysValidSchema)(G, V)) return; + Q.if(Mq._`${H} > ${O}`, () => $.subschema({ keyword: W, schemaProp: O, dataProp: O }, U)), $.ok(U); + }); + function K(V) { + let { opts: O, errSchemaPath: N } = G, w = J.length, B = w === V.minItems && (w === V.maxItems || V[X] === false); + if (O.strictTuples && !B) { + let L = `"${W}" is ${w}-tuple, but minItems or maxItems/${X} are not specified or different at path "${N}"`; + (0, lQ.checkStrictMode)(G, L, O.strictTuples); + } + } + } + Aq.validateTuple = Iq; + Aq.default = Dk; +}); +var Zq = k((Pq) => { + Object.defineProperty(Pq, "__esModule", { value: true }); + var jk = HU(), Fk = { keyword: "prefixItems", type: "array", schemaType: ["array"], before: "uniqueItems", code: ($) => (0, jk.validateTuple)($, "items") }; + Pq.default = Fk; +}); +var Sq = k((Rq) => { + Object.defineProperty(Rq, "__esModule", { value: true }); + var Eq = a(), Ik = Q$(), Ak = Z6(), bk = UU(), Pk = { message: ({ params: { len: $ } }) => Eq.str`must NOT have more than ${$} items`, params: ({ params: { len: $ } }) => Eq._`{limit: ${$}}` }, Zk = { keyword: "items", type: "array", schemaType: ["object", "boolean"], before: "uniqueItems", error: Pk, code($) { + let { schema: X, parentSchema: J, it: Q } = $, { prefixItems: Y } = J; + if (Q.items = true, (0, Ik.alwaysValidSchema)(Q, X)) return; + if (Y) (0, bk.validateAdditionalItems)($, Y); + else $.ok((0, Ak.validateArray)($)); + } }; + Rq.default = Zk; +}); +var Cq = k((vq) => { + Object.defineProperty(vq, "__esModule", { value: true }); + var E6 = a(), cQ = Q$(), Rk = { message: ({ params: { min: $, max: X } }) => X === void 0 ? E6.str`must contain at least ${$} valid item(s)` : E6.str`must contain at least ${$} and no more than ${X} valid item(s)`, params: ({ params: { min: $, max: X } }) => X === void 0 ? E6._`{minContains: ${$}}` : E6._`{minContains: ${$}, maxContains: ${X}}` }, Sk = { keyword: "contains", type: "array", schemaType: ["object", "boolean"], before: "uniqueItems", trackErrors: true, error: Rk, code($) { + let { gen: X, schema: J, parentSchema: Q, data: Y, it: z6 } = $, W, G, { minContains: U, maxContains: H } = Q; + if (z6.opts.next) W = U === void 0 ? 1 : U, G = H; + else W = 1; + let K = X.const("len", E6._`${Y}.length`); + if ($.setParams({ min: W, max: G }), G === void 0 && W === 0) { + (0, cQ.checkStrictMode)(z6, '"minContains" == 0 without "maxContains": "contains" keyword ignored'); + return; + } + if (G !== void 0 && W > G) { + (0, cQ.checkStrictMode)(z6, '"minContains" > "maxContains" is always invalid'), $.fail(); + return; + } + if ((0, cQ.alwaysValidSchema)(z6, J)) { + let B = E6._`${K} >= ${W}`; + if (G !== void 0) B = E6._`${B} && ${K} <= ${G}`; + $.pass(B); + return; + } + z6.items = true; + let V = X.name("valid"); + if (G === void 0 && W === 1) N(V, () => X.if(V, () => X.break())); + else if (W === 0) { + if (X.let(V, true), G !== void 0) X.if(E6._`${Y}.length > 0`, O); + } else X.let(V, false), O(); + $.result(V, () => $.reset()); + function O() { + let B = X.name("_valid"), L = X.let("count", 0); + N(B, () => X.if(B, () => w(L))); + } + function N(B, L) { + X.forRange("i", 0, K, (j) => { + $.subschema({ keyword: "contains", dataProp: j, dataPropType: cQ.Type.Num, compositeRule: true }, B), L(); + }); + } + function w(B) { + if (X.code(E6._`${B}++`), G === void 0) X.if(E6._`${B} >= ${W}`, () => X.assign(V, true).break()); + else if (X.if(E6._`${B} > ${G}`, () => X.assign(V, false).break()), W === 1) X.assign(V, true); + else X.if(E6._`${B} >= ${W}`, () => X.assign(V, true)); + } + } }; + vq.default = Sk; +}); +var fq = k((xq) => { + Object.defineProperty(xq, "__esModule", { value: true }); + xq.validateSchemaDeps = xq.validatePropertyDeps = xq.error = void 0; + var KU = a(), Ck = Q$(), l9 = Z6(); + xq.error = { message: ({ params: { property: $, depsCount: X, deps: J } }) => { + let Q = X === 1 ? "property" : "properties"; + return KU.str`must have ${Q} ${J} when property ${$} is present`; + }, params: ({ params: { property: $, depsCount: X, deps: J, missingProperty: Q } }) => KU._`{property: ${$}, + missingProperty: ${Q}, + depsCount: ${X}, + deps: ${J}}` }; + var kk = { keyword: "dependencies", type: "object", schemaType: "object", error: xq.error, code($) { + let [X, J] = _k($); + kq($, X), _q($, J); + } }; + function _k({ schema: $ }) { + let X = {}, J = {}; + for (let Q in $) { + if (Q === "__proto__") continue; + let Y = Array.isArray($[Q]) ? X : J; + Y[Q] = $[Q]; + } + return [X, J]; + } + function kq($, X = $.schema) { + let { gen: J, data: Q, it: Y } = $; + if (Object.keys(X).length === 0) return; + let z6 = J.let("missing"); + for (let W in X) { + let G = X[W]; + if (G.length === 0) continue; + let U = (0, l9.propertyInData)(J, Q, W, Y.opts.ownProperties); + if ($.setParams({ property: W, depsCount: G.length, deps: G.join(", ") }), Y.allErrors) J.if(U, () => { + for (let H of G) (0, l9.checkReportMissingProp)($, H); + }); + else J.if(KU._`${U} && (${(0, l9.checkMissingProp)($, G, z6)})`), (0, l9.reportMissingProp)($, z6), J.else(); + } + } + xq.validatePropertyDeps = kq; + function _q($, X = $.schema) { + let { gen: J, data: Q, keyword: Y, it: z6 } = $, W = J.name("valid"); + for (let G in X) { + if ((0, Ck.alwaysValidSchema)(z6, X[G])) continue; + J.if((0, l9.propertyInData)(J, Q, G, z6.opts.ownProperties), () => { + let U = $.subschema({ keyword: Y, schemaProp: G }, W); + $.mergeValidEvaluated(U, W); + }, () => J.var(W, true)), $.ok(W); + } + } + xq.validateSchemaDeps = _q; + xq.default = kk; +}); +var uq = k((hq) => { + Object.defineProperty(hq, "__esModule", { value: true }); + var gq = a(), yk = Q$(), fk = { message: "property name must be valid", params: ({ params: $ }) => gq._`{propertyName: ${$.propertyName}}` }, gk = { keyword: "propertyNames", type: "object", schemaType: ["object", "boolean"], error: fk, code($) { + let { gen: X, schema: J, data: Q, it: Y } = $; + if ((0, yk.alwaysValidSchema)(Y, J)) return; + let z6 = X.name("valid"); + X.forIn("key", Q, (W) => { + $.setParams({ propertyName: W }), $.subschema({ keyword: "propertyNames", data: W, dataTypes: ["string"], propertyName: W, compositeRule: true }, z6), X.if((0, gq.not)(z6), () => { + if ($.error(true), !Y.allErrors) X.break(); + }); + }), $.ok(z6); + } }; + hq.default = gk; +}); +var NU = k((mq) => { + Object.defineProperty(mq, "__esModule", { value: true }); + var pQ = Z6(), g6 = a(), uk = B4(), iQ = Q$(), mk = { message: "must NOT have additional properties", params: ({ params: $ }) => g6._`{additionalProperty: ${$.additionalProperty}}` }, lk = { keyword: "additionalProperties", type: ["object"], schemaType: ["boolean", "object"], allowUndefined: true, trackErrors: true, error: mk, code($) { + let { gen: X, schema: J, parentSchema: Q, data: Y, errsCount: z6, it: W } = $; + if (!z6) throw Error("ajv implementation error"); + let { allErrors: G, opts: U } = W; + if (W.props = true, U.removeAdditional !== "all" && (0, iQ.alwaysValidSchema)(W, J)) return; + let H = (0, pQ.allSchemaProperties)(Q.properties), K = (0, pQ.allSchemaProperties)(Q.patternProperties); + V(), $.ok(g6._`${z6} === ${uk.default.errors}`); + function V() { + X.forIn("key", Y, (L) => { + if (!H.length && !K.length) w(L); + else X.if(O(L), () => w(L)); + }); + } + function O(L) { + let j; + if (H.length > 8) { + let I = (0, iQ.schemaRefOrVal)(W, Q.properties, "properties"); + j = (0, pQ.isOwnProperty)(X, I, L); + } else if (H.length) j = (0, g6.or)(...H.map((I) => g6._`${L} === ${I}`)); + else j = g6.nil; + if (K.length) j = (0, g6.or)(j, ...K.map((I) => g6._`${(0, pQ.usePattern)($, I)}.test(${L})`)); + return (0, g6.not)(j); + } + function N(L) { + X.code(g6._`delete ${Y}[${L}]`); + } + function w(L) { + if (U.removeAdditional === "all" || U.removeAdditional && J === false) { + N(L); + return; + } + if (J === false) { + if ($.setParams({ additionalProperty: L }), $.error(), !G) X.break(); + return; + } + if (typeof J == "object" && !(0, iQ.alwaysValidSchema)(W, J)) { + let j = X.name("valid"); + if (U.removeAdditional === "failing") B(L, j, false), X.if((0, g6.not)(j), () => { + $.reset(), N(L); + }); + else if (B(L, j), !G) X.if((0, g6.not)(j), () => X.break()); + } + } + function B(L, j, I) { + let b = { keyword: "additionalProperties", dataProp: L, dataPropType: iQ.Type.Str }; + if (I === false) Object.assign(b, { compositeRule: true, createErrors: false, allErrors: false }); + $.subschema(b, j); + } + } }; + mq.default = lk; +}); +var iq = k((pq) => { + Object.defineProperty(pq, "__esModule", { value: true }); + var pk = v9(), lq = Z6(), VU = Q$(), cq = NU(), ik = { keyword: "properties", type: "object", schemaType: "object", code($) { + let { gen: X, schema: J, parentSchema: Q, data: Y, it: z6 } = $; + if (z6.opts.removeAdditional === "all" && Q.additionalProperties === void 0) cq.default.code(new pk.KeywordCxt(z6, cq.default, "additionalProperties")); + let W = (0, lq.allSchemaProperties)(J); + for (let V of W) z6.definedProperties.add(V); + if (z6.opts.unevaluated && W.length && z6.props !== true) z6.props = VU.mergeEvaluated.props(X, (0, VU.toHash)(W), z6.props); + let G = W.filter((V) => !(0, VU.alwaysValidSchema)(z6, J[V])); + if (G.length === 0) return; + let U = X.name("valid"); + for (let V of G) { + if (H(V)) K(V); + else { + if (X.if((0, lq.propertyInData)(X, Y, V, z6.opts.ownProperties)), K(V), !z6.allErrors) X.else().var(U, true); + X.endIf(); + } + $.it.definedProperties.add(V), $.ok(U); + } + function H(V) { + return z6.opts.useDefaults && !z6.compositeRule && J[V].default !== void 0; + } + function K(V) { + $.subschema({ keyword: "properties", schemaProp: V, dataProp: V }, U); + } + } }; + pq.default = ik; +}); +var tq = k((oq) => { + Object.defineProperty(oq, "__esModule", { value: true }); + var nq = Z6(), nQ = a(), dq = Q$(), rq = Q$(), dk = { keyword: "patternProperties", type: "object", schemaType: "object", code($) { + let { gen: X, schema: J, data: Q, parentSchema: Y, it: z6 } = $, { opts: W } = z6, G = (0, nq.allSchemaProperties)(J), U = G.filter((B) => (0, dq.alwaysValidSchema)(z6, J[B])); + if (G.length === 0 || U.length === G.length && (!z6.opts.unevaluated || z6.props === true)) return; + let H = W.strictSchema && !W.allowMatchingProperties && Y.properties, K = X.name("valid"); + if (z6.props !== true && !(z6.props instanceof nQ.Name)) z6.props = (0, rq.evaluatedPropsToName)(X, z6.props); + let { props: V } = z6; + O(); + function O() { + for (let B of G) { + if (H) N(B); + if (z6.allErrors) w(B); + else X.var(K, true), w(B), X.if(K); + } + } + function N(B) { + for (let L in H) if (new RegExp(B).test(L)) (0, dq.checkStrictMode)(z6, `property ${L} matches pattern ${B} (use allowMatchingProperties)`); + } + function w(B) { + X.forIn("key", Q, (L) => { + X.if(nQ._`${(0, nq.usePattern)($, B)}.test(${L})`, () => { + let j = U.includes(B); + if (!j) $.subschema({ keyword: "patternProperties", schemaProp: B, dataProp: L, dataPropType: rq.Type.Str }, K); + if (z6.opts.unevaluated && V !== true) X.assign(nQ._`${V}[${L}]`, true); + else if (!j && !z6.allErrors) X.if((0, nQ.not)(K), () => X.break()); + }); + }); + } + } }; + oq.default = dk; +}); +var sq = k((aq) => { + Object.defineProperty(aq, "__esModule", { value: true }); + var ok = Q$(), tk = { keyword: "not", schemaType: ["object", "boolean"], trackErrors: true, code($) { + let { gen: X, schema: J, it: Q } = $; + if ((0, ok.alwaysValidSchema)(Q, J)) { + $.fail(); + return; + } + let Y = X.name("valid"); + $.subschema({ keyword: "not", compositeRule: true, createErrors: false, allErrors: false }, Y), $.failResult(Y, () => $.reset(), () => $.error()); + }, error: { message: "must NOT be valid" } }; + aq.default = tk; +}); +var $D = k((eq) => { + Object.defineProperty(eq, "__esModule", { value: true }); + var sk = Z6(), ek = { keyword: "anyOf", schemaType: "array", trackErrors: true, code: sk.validateUnion, error: { message: "must match a schema in anyOf" } }; + eq.default = ek; +}); +var JD = k((XD) => { + Object.defineProperty(XD, "__esModule", { value: true }); + var dQ = a(), X_ = Q$(), J_ = { message: "must match exactly one schema in oneOf", params: ({ params: $ }) => dQ._`{passingSchemas: ${$.passing}}` }, Y_ = { keyword: "oneOf", schemaType: "array", trackErrors: true, error: J_, code($) { + let { gen: X, schema: J, parentSchema: Q, it: Y } = $; + if (!Array.isArray(J)) throw Error("ajv implementation error"); + if (Y.opts.discriminator && Q.discriminator) return; + let z6 = J, W = X.let("valid", false), G = X.let("passing", null), U = X.name("_valid"); + $.setParams({ passing: G }), X.block(H), $.result(W, () => $.reset(), () => $.error(true)); + function H() { + z6.forEach((K, V) => { + let O; + if ((0, X_.alwaysValidSchema)(Y, K)) X.var(U, true); + else O = $.subschema({ keyword: "oneOf", schemaProp: V, compositeRule: true }, U); + if (V > 0) X.if(dQ._`${U} && ${W}`).assign(W, false).assign(G, dQ._`[${G}, ${V}]`).else(); + X.if(U, () => { + if (X.assign(W, true), X.assign(G, V), O) $.mergeEvaluated(O, dQ.Name); + }); + }); + } + } }; + XD.default = Y_; +}); +var QD = k((YD) => { + Object.defineProperty(YD, "__esModule", { value: true }); + var z_ = Q$(), W_ = { keyword: "allOf", schemaType: "array", code($) { + let { gen: X, schema: J, it: Q } = $; + if (!Array.isArray(J)) throw Error("ajv implementation error"); + let Y = X.name("valid"); + J.forEach((z6, W) => { + if ((0, z_.alwaysValidSchema)(Q, z6)) return; + let G = $.subschema({ keyword: "allOf", schemaProp: W }, Y); + $.ok(Y), $.mergeEvaluated(G); + }); + } }; + YD.default = W_; +}); +var UD = k((GD) => { + Object.defineProperty(GD, "__esModule", { value: true }); + var rQ = a(), WD = Q$(), U_ = { message: ({ params: $ }) => rQ.str`must match "${$.ifClause}" schema`, params: ({ params: $ }) => rQ._`{failingKeyword: ${$.ifClause}}` }, H_ = { keyword: "if", schemaType: ["object", "boolean"], trackErrors: true, error: U_, code($) { + let { gen: X, parentSchema: J, it: Q } = $; + if (J.then === void 0 && J.else === void 0) (0, WD.checkStrictMode)(Q, '"if" without "then" and "else" is ignored'); + let Y = zD(Q, "then"), z6 = zD(Q, "else"); + if (!Y && !z6) return; + let W = X.let("valid", true), G = X.name("_valid"); + if (U(), $.reset(), Y && z6) { + let K = X.let("ifClause"); + $.setParams({ ifClause: K }), X.if(G, H("then", K), H("else", K)); + } else if (Y) X.if(G, H("then")); + else X.if((0, rQ.not)(G), H("else")); + $.pass(W, () => $.error(true)); + function U() { + let K = $.subschema({ keyword: "if", compositeRule: true, createErrors: false, allErrors: false }, G); + $.mergeEvaluated(K); + } + function H(K, V) { + return () => { + let O = $.subschema({ keyword: K }, G); + if (X.assign(W, G), $.mergeValidEvaluated(O, W), V) X.assign(V, rQ._`${K}`); + else $.setParams({ ifClause: K }); + }; + } + } }; + function zD($, X) { + let J = $.schema[X]; + return J !== void 0 && !(0, WD.alwaysValidSchema)($, J); + } + GD.default = H_; +}); +var KD = k((HD) => { + Object.defineProperty(HD, "__esModule", { value: true }); + var N_ = Q$(), V_ = { keyword: ["then", "else"], schemaType: ["object", "boolean"], code({ keyword: $, parentSchema: X, it: J }) { + if (X.if === void 0) (0, N_.checkStrictMode)(J, `"${$}" without "if" is ignored`); + } }; + HD.default = V_; +}); +var VD = k((ND) => { + Object.defineProperty(ND, "__esModule", { value: true }); + var w_ = UU(), B_ = Zq(), q_ = HU(), D_ = Sq(), L_ = Cq(), j_ = fq(), F_ = uq(), M_ = NU(), I_ = iq(), A_ = tq(), b_ = sq(), P_ = $D(), Z_ = JD(), E_ = QD(), R_ = UD(), S_ = KD(); + function v_($ = false) { + let X = [b_.default, P_.default, Z_.default, E_.default, R_.default, S_.default, F_.default, M_.default, j_.default, I_.default, A_.default]; + if ($) X.push(B_.default, D_.default); + else X.push(w_.default, q_.default); + return X.push(L_.default), X; + } + ND.default = v_; +}); +var wD = k((OD) => { + Object.defineProperty(OD, "__esModule", { value: true }); + var R$ = a(), k_ = { message: ({ schemaCode: $ }) => R$.str`must match format "${$}"`, params: ({ schemaCode: $ }) => R$._`{format: ${$}}` }, __ = { keyword: "format", type: ["number", "string"], schemaType: "string", $data: true, error: k_, code($, X) { + let { gen: J, data: Q, $data: Y, schema: z6, schemaCode: W, it: G } = $, { opts: U, errSchemaPath: H, schemaEnv: K, self: V } = G; + if (!U.validateFormats) return; + if (Y) O(); + else N(); + function O() { + let w = J.scopeValue("formats", { ref: V.formats, code: U.code.formats }), B = J.const("fDef", R$._`${w}[${W}]`), L = J.let("fType"), j = J.let("format"); + J.if(R$._`typeof ${B} == "object" && !(${B} instanceof RegExp)`, () => J.assign(L, R$._`${B}.type || "string"`).assign(j, R$._`${B}.validate`), () => J.assign(L, R$._`"string"`).assign(j, B)), $.fail$data((0, R$.or)(I(), b())); + function I() { + if (U.strictSchema === false) return R$.nil; + return R$._`${W} && !${j}`; + } + function b() { + let x = K.$async ? R$._`(${B}.async ? await ${j}(${Q}) : ${j}(${Q}))` : R$._`${j}(${Q})`, h = R$._`(typeof ${j} == "function" ? ${x} : ${j}.test(${Q}))`; + return R$._`${j} && ${j} !== true && ${L} === ${X} && !${h}`; + } + } + function N() { + let w = V.formats[z6]; + if (!w) { + I(); + return; + } + if (w === true) return; + let [B, L, j] = b(w); + if (B === X) $.pass(x()); + function I() { + if (U.strictSchema === false) { + V.logger.warn(h()); + return; + } + throw Error(h()); + function h() { + return `unknown format "${z6}" ignored in schema at path "${H}"`; + } + } + function b(h) { + let B$ = h instanceof RegExp ? (0, R$.regexpCode)(h) : U.code.formats ? R$._`${U.code.formats}${(0, R$.getProperty)(z6)}` : void 0, x$ = J.scopeValue("formats", { key: z6, ref: h, code: B$ }); + if (typeof h == "object" && !(h instanceof RegExp)) return [h.type || "string", h.validate, R$._`${x$}.validate`]; + return ["string", h, x$]; + } + function x() { + if (typeof w == "object" && !(w instanceof RegExp) && w.async) { + if (!K.$async) throw Error("async format in sync schema"); + return R$._`await ${j}(${Q})`; + } + return typeof L == "function" ? R$._`${j}(${Q})` : R$._`${j}.test(${Q})`; + } + } + } }; + OD.default = __; +}); +var qD = k((BD) => { + Object.defineProperty(BD, "__esModule", { value: true }); + var T_ = wD(), y_ = [T_.default]; + BD.default = y_; +}); +var jD = k((DD) => { + Object.defineProperty(DD, "__esModule", { value: true }); + DD.contentVocabulary = DD.metadataVocabulary = void 0; + DD.metadataVocabulary = ["title", "description", "default", "deprecated", "readOnly", "writeOnly", "examples"]; + DD.contentVocabulary = ["contentMediaType", "contentEncoding", "contentSchema"]; +}); +var ID = k((MD) => { + Object.defineProperty(MD, "__esModule", { value: true }); + var h_ = pB(), u_ = Dq(), m_ = VD(), l_ = qD(), FD = jD(), c_ = [h_.default, u_.default, (0, m_.default)(), l_.default, FD.metadataVocabulary, FD.contentVocabulary]; + MD.default = c_; +}); +var ZD = k((bD) => { + Object.defineProperty(bD, "__esModule", { value: true }); + bD.DiscrError = void 0; + var AD; + (function($) { + $.Tag = "tag", $.Mapping = "mapping"; + })(AD || (bD.DiscrError = AD = {})); +}); +var SD = k((RD) => { + Object.defineProperty(RD, "__esModule", { value: true }); + var i0 = a(), OU = ZD(), ED = CQ(), i_ = C9(), n_ = Q$(), d_ = { message: ({ params: { discrError: $, tagName: X } }) => $ === OU.DiscrError.Tag ? `tag "${X}" must be string` : `value of tag "${X}" must be in oneOf`, params: ({ params: { discrError: $, tag: X, tagName: J } }) => i0._`{error: ${$}, tag: ${J}, tagValue: ${X}}` }, r_ = { keyword: "discriminator", type: "object", schemaType: "object", error: d_, code($) { + let { gen: X, data: J, schema: Q, parentSchema: Y, it: z6 } = $, { oneOf: W } = Y; + if (!z6.opts.discriminator) throw Error("discriminator: requires discriminator option"); + let G = Q.propertyName; + if (typeof G != "string") throw Error("discriminator: requires propertyName"); + if (Q.mapping) throw Error("discriminator: mapping is not supported"); + if (!W) throw Error("discriminator: requires oneOf keyword"); + let U = X.let("valid", false), H = X.const("tag", i0._`${J}${(0, i0.getProperty)(G)}`); + X.if(i0._`typeof ${H} == "string"`, () => K(), () => $.error(false, { discrError: OU.DiscrError.Tag, tag: H, tagName: G })), $.ok(U); + function K() { + let N = O(); + X.if(false); + for (let w in N) X.elseIf(i0._`${H} === ${w}`), X.assign(U, V(N[w])); + X.else(), $.error(false, { discrError: OU.DiscrError.Mapping, tag: H, tagName: G }), X.endIf(); + } + function V(N) { + let w = X.name("valid"), B = $.subschema({ keyword: "oneOf", schemaProp: N }, w); + return $.mergeEvaluated(B, i0.Name), w; + } + function O() { + var N; + let w = {}, B = j(Y), L = true; + for (let x = 0; x < W.length; x++) { + let h = W[x]; + if ((h === null || h === void 0 ? void 0 : h.$ref) && !(0, n_.schemaHasRulesButRef)(h, z6.self.RULES)) { + let x$ = h.$ref; + if (h = ED.resolveRef.call(z6.self, z6.schemaEnv.root, z6.baseId, x$), h instanceof ED.SchemaEnv) h = h.schema; + if (h === void 0) throw new i_.default(z6.opts.uriResolver, z6.baseId, x$); + } + let B$ = (N = h === null || h === void 0 ? void 0 : h.properties) === null || N === void 0 ? void 0 : N[G]; + if (typeof B$ != "object") throw Error(`discriminator: oneOf subschemas (or referenced schemas) must have "properties/${G}"`); + L = L && (B || j(h)), I(B$, x); + } + if (!L) throw Error(`discriminator: "${G}" must be required`); + return w; + function j({ required: x }) { + return Array.isArray(x) && x.includes(G); + } + function I(x, h) { + if (x.const) b(x.const, h); + else if (x.enum) for (let B$ of x.enum) b(B$, h); + else throw Error(`discriminator: "properties/${G}" must have "const" or "enum"`); + } + function b(x, h) { + if (typeof x != "string" || x in w) throw Error(`discriminator: "${G}" values must be unique strings`); + w[x] = h; + } + } + } }; + RD.default = r_; +}); +var vD = k((ot, t_) => { + t_.exports = { $schema: "http://json-schema.org/draft-07/schema#", $id: "http://json-schema.org/draft-07/schema#", title: "Core schema meta-schema", definitions: { schemaArray: { type: "array", minItems: 1, items: { $ref: "#" } }, nonNegativeInteger: { type: "integer", minimum: 0 }, nonNegativeIntegerDefault0: { allOf: [{ $ref: "#/definitions/nonNegativeInteger" }, { default: 0 }] }, simpleTypes: { enum: ["array", "boolean", "integer", "null", "number", "object", "string"] }, stringArray: { type: "array", items: { type: "string" }, uniqueItems: true, default: [] } }, type: ["object", "boolean"], properties: { $id: { type: "string", format: "uri-reference" }, $schema: { type: "string", format: "uri" }, $ref: { type: "string", format: "uri-reference" }, $comment: { type: "string" }, title: { type: "string" }, description: { type: "string" }, default: true, readOnly: { type: "boolean", default: false }, examples: { type: "array", items: true }, multipleOf: { type: "number", exclusiveMinimum: 0 }, maximum: { type: "number" }, exclusiveMaximum: { type: "number" }, minimum: { type: "number" }, exclusiveMinimum: { type: "number" }, maxLength: { $ref: "#/definitions/nonNegativeInteger" }, minLength: { $ref: "#/definitions/nonNegativeIntegerDefault0" }, pattern: { type: "string", format: "regex" }, additionalItems: { $ref: "#" }, items: { anyOf: [{ $ref: "#" }, { $ref: "#/definitions/schemaArray" }], default: true }, maxItems: { $ref: "#/definitions/nonNegativeInteger" }, minItems: { $ref: "#/definitions/nonNegativeIntegerDefault0" }, uniqueItems: { type: "boolean", default: false }, contains: { $ref: "#" }, maxProperties: { $ref: "#/definitions/nonNegativeInteger" }, minProperties: { $ref: "#/definitions/nonNegativeIntegerDefault0" }, required: { $ref: "#/definitions/stringArray" }, additionalProperties: { $ref: "#" }, definitions: { type: "object", additionalProperties: { $ref: "#" }, default: {} }, properties: { type: "object", additionalProperties: { $ref: "#" }, default: {} }, patternProperties: { type: "object", additionalProperties: { $ref: "#" }, propertyNames: { format: "regex" }, default: {} }, dependencies: { type: "object", additionalProperties: { anyOf: [{ $ref: "#" }, { $ref: "#/definitions/stringArray" }] } }, propertyNames: { $ref: "#" }, const: true, enum: { type: "array", items: true, minItems: 1, uniqueItems: true }, type: { anyOf: [{ $ref: "#/definitions/simpleTypes" }, { type: "array", items: { $ref: "#/definitions/simpleTypes" }, minItems: 1, uniqueItems: true }] }, format: { type: "string" }, contentMediaType: { type: "string" }, contentEncoding: { type: "string" }, if: { $ref: "#" }, then: { $ref: "#" }, else: { $ref: "#" }, allOf: { $ref: "#/definitions/schemaArray" }, anyOf: { $ref: "#/definitions/schemaArray" }, oneOf: { $ref: "#/definitions/schemaArray" }, not: { $ref: "#" } }, default: true }; +}); +var BU = k((W6, wU) => { + Object.defineProperty(W6, "__esModule", { value: true }); + W6.MissingRefError = W6.ValidationError = W6.CodeGen = W6.Name = W6.nil = W6.stringify = W6.str = W6._ = W6.KeywordCxt = W6.Ajv = void 0; + var a_ = xB(), s_ = ID(), e_ = SD(), CD = vD(), $x = ["/properties"], oQ = "http://json-schema.org/draft-07/schema"; + class c9 extends a_.default { + _addVocabularies() { + if (super._addVocabularies(), s_.default.forEach(($) => this.addVocabulary($)), this.opts.discriminator) this.addKeyword(e_.default); + } + _addDefaultMetaSchema() { + if (super._addDefaultMetaSchema(), !this.opts.meta) return; + let $ = this.opts.$data ? this.$dataMetaSchema(CD, $x) : CD; + this.addMetaSchema($, oQ, false), this.refs["http://json-schema.org/schema"] = oQ; + } + defaultMeta() { + return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(oQ) ? oQ : void 0); + } + } + W6.Ajv = c9; + wU.exports = W6 = c9; + wU.exports.Ajv = c9; + Object.defineProperty(W6, "__esModule", { value: true }); + W6.default = c9; + var Xx = v9(); + Object.defineProperty(W6, "KeywordCxt", { enumerable: true, get: function() { + return Xx.KeywordCxt; + } }); + var n0 = a(); + Object.defineProperty(W6, "_", { enumerable: true, get: function() { + return n0._; + } }); + Object.defineProperty(W6, "str", { enumerable: true, get: function() { + return n0.str; + } }); + Object.defineProperty(W6, "stringify", { enumerable: true, get: function() { + return n0.stringify; + } }); + Object.defineProperty(W6, "nil", { enumerable: true, get: function() { + return n0.nil; + } }); + Object.defineProperty(W6, "Name", { enumerable: true, get: function() { + return n0.Name; + } }); + Object.defineProperty(W6, "CodeGen", { enumerable: true, get: function() { + return n0.CodeGen; + } }); + var Jx = SQ(); + Object.defineProperty(W6, "ValidationError", { enumerable: true, get: function() { + return Jx.default; + } }); + var Yx = C9(); + Object.defineProperty(W6, "MissingRefError", { enumerable: true, get: function() { + return Yx.default; + } }); +}); +var mD = k((hD) => { + Object.defineProperty(hD, "__esModule", { value: true }); + hD.formatNames = hD.fastFormats = hD.fullFormats = void 0; + function d6($, X) { + return { validate: $, compare: X }; + } + hD.fullFormats = { date: d6(TD, jU), time: d6(DU(true), FU), "date-time": d6(kD(true), fD), "iso-time": d6(DU(), yD), "iso-date-time": d6(kD(), gD), duration: /^P(?!$)((\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?|(\d+W)?)$/, uri: Nx, "uri-reference": /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i, "uri-template": /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i, url: /^(?:https?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu, email: /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i, hostname: /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i, ipv4: /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/, ipv6: /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i, regex: Lx, uuid: /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i, "json-pointer": /^(?:\/(?:[^~/]|~0|~1)*)*$/, "json-pointer-uri-fragment": /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i, "relative-json-pointer": /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/, byte: Vx, int32: { type: "number", validate: Bx }, int64: { type: "number", validate: qx }, float: { type: "number", validate: xD }, double: { type: "number", validate: xD }, password: true, binary: true }; + hD.fastFormats = { ...hD.fullFormats, date: d6(/^\d\d\d\d-[0-1]\d-[0-3]\d$/, jU), time: d6(/^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i, FU), "date-time": d6(/^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i, fD), "iso-time": d6(/^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, yD), "iso-date-time": d6(/^\d\d\d\d-[0-1]\d-[0-3]\d[t\s](?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, gD), uri: /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/)?[^\s]*$/i, "uri-reference": /^(?:(?:[a-z][a-z0-9+\-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i, email: /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i }; + hD.formatNames = Object.keys(hD.fullFormats); + function Wx($) { + return $ % 4 === 0 && ($ % 100 !== 0 || $ % 400 === 0); + } + var Gx = /^(\d\d\d\d)-(\d\d)-(\d\d)$/, Ux = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; + function TD($) { + let X = Gx.exec($); + if (!X) return false; + let J = +X[1], Q = +X[2], Y = +X[3]; + return Q >= 1 && Q <= 12 && Y >= 1 && Y <= (Q === 2 && Wx(J) ? 29 : Ux[Q]); + } + function jU($, X) { + if (!($ && X)) return; + if ($ > X) return 1; + if ($ < X) return -1; + return 0; + } + var qU = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i; + function DU($) { + return function(J) { + let Q = qU.exec(J); + if (!Q) return false; + let Y = +Q[1], z6 = +Q[2], W = +Q[3], G = Q[4], U = Q[5] === "-" ? -1 : 1, H = +(Q[6] || 0), K = +(Q[7] || 0); + if (H > 23 || K > 59 || $ && !G) return false; + if (Y <= 23 && z6 <= 59 && W < 60) return true; + let V = z6 - K * U, O = Y - H * U - (V < 0 ? 1 : 0); + return (O === 23 || O === -1) && (V === 59 || V === -1) && W < 61; + }; + } + function FU($, X) { + if (!($ && X)) return; + let J = (/* @__PURE__ */ new Date("2020-01-01T" + $)).valueOf(), Q = (/* @__PURE__ */ new Date("2020-01-01T" + X)).valueOf(); + if (!(J && Q)) return; + return J - Q; + } + function yD($, X) { + if (!($ && X)) return; + let J = qU.exec($), Q = qU.exec(X); + if (!(J && Q)) return; + if ($ = J[1] + J[2] + J[3], X = Q[1] + Q[2] + Q[3], $ > X) return 1; + if ($ < X) return -1; + return 0; + } + var LU = /t|\s/i; + function kD($) { + let X = DU($); + return function(Q) { + let Y = Q.split(LU); + return Y.length === 2 && TD(Y[0]) && X(Y[1]); + }; + } + function fD($, X) { + if (!($ && X)) return; + let J = new Date($).valueOf(), Q = new Date(X).valueOf(); + if (!(J && Q)) return; + return J - Q; + } + function gD($, X) { + if (!($ && X)) return; + let [J, Q] = $.split(LU), [Y, z6] = X.split(LU), W = jU(J, Y); + if (W === void 0) return; + return W || FU(Q, z6); + } + var Hx = /\/|:/, Kx = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i; + function Nx($) { + return Hx.test($) && Kx.test($); + } + var _D = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm; + function Vx($) { + return _D.lastIndex = 0, _D.test($); + } + var Ox = -2147483648, wx = 2147483647; + function Bx($) { + return Number.isInteger($) && $ <= wx && $ >= Ox; + } + function qx($) { + return Number.isInteger($); + } + function xD() { + return true; + } + var Dx = /[^\\]\\Z/; + function Lx($) { + if (Dx.test($)) return false; + try { + return new RegExp($), true; + } catch (X) { + return false; + } + } +}); +var cD = k((lD) => { + Object.defineProperty(lD, "__esModule", { value: true }); + lD.formatLimitDefinition = void 0; + var Fx = BU(), h6 = a(), o4 = h6.operators, tQ = { formatMaximum: { okStr: "<=", ok: o4.LTE, fail: o4.GT }, formatMinimum: { okStr: ">=", ok: o4.GTE, fail: o4.LT }, formatExclusiveMaximum: { okStr: "<", ok: o4.LT, fail: o4.GTE }, formatExclusiveMinimum: { okStr: ">", ok: o4.GT, fail: o4.LTE } }, Mx = { message: ({ keyword: $, schemaCode: X }) => h6.str`should be ${tQ[$].okStr} ${X}`, params: ({ keyword: $, schemaCode: X }) => h6._`{comparison: ${tQ[$].okStr}, limit: ${X}}` }; + lD.formatLimitDefinition = { keyword: Object.keys(tQ), type: "string", schemaType: "string", $data: true, error: Mx, code($) { + let { gen: X, data: J, schemaCode: Q, keyword: Y, it: z6 } = $, { opts: W, self: G } = z6; + if (!W.validateFormats) return; + let U = new Fx.KeywordCxt(z6, G.RULES.all.format.definition, "format"); + if (U.$data) H(); + else K(); + function H() { + let O = X.scopeValue("formats", { ref: G.formats, code: W.code.formats }), N = X.const("fmt", h6._`${O}[${U.schemaCode}]`); + $.fail$data((0, h6.or)(h6._`typeof ${N} != "object"`, h6._`${N} instanceof RegExp`, h6._`typeof ${N}.compare != "function"`, V(N))); + } + function K() { + let O = U.schema, N = G.formats[O]; + if (!N || N === true) return; + if (typeof N != "object" || N instanceof RegExp || typeof N.compare != "function") throw Error(`"${Y}": format "${O}" does not define "compare" function`); + let w = X.scopeValue("formats", { key: O, ref: N, code: W.code.formats ? h6._`${W.code.formats}${(0, h6.getProperty)(O)}` : void 0 }); + $.fail$data(V(w)); + } + function V(O) { + return h6._`${O}.compare(${J}, ${Q}) ${tQ[Y].fail} 0`; + } + }, dependencies: ["format"] }; + var Ix = ($) => { + return $.addKeyword(lD.formatLimitDefinition), $; + }; + lD.default = Ix; +}); +var dD = k((p9, nD) => { + Object.defineProperty(p9, "__esModule", { value: true }); + var d0 = mD(), bx = cD(), AU = a(), pD = new AU.Name("fullFormats"), Px = new AU.Name("fastFormats"), bU = ($, X = { keywords: true }) => { + if (Array.isArray(X)) return iD($, X, d0.fullFormats, pD), $; + let [J, Q] = X.mode === "fast" ? [d0.fastFormats, Px] : [d0.fullFormats, pD], Y = X.formats || d0.formatNames; + if (iD($, Y, J, Q), X.keywords) (0, bx.default)($); + return $; + }; + bU.get = ($, X = "full") => { + let Q = (X === "fast" ? d0.fastFormats : d0.fullFormats)[$]; + if (!Q) throw Error(`Unknown format "${$}"`); + return Q; + }; + function iD($, X, J, Q) { + var Y, z6; + (Y = (z6 = $.opts.code).formats) !== null && Y !== void 0 || (z6.formats = AU._`require("ajv-formats/dist/formats").${Q}`); + for (let W of X) $.addFormat(W, J[W]); + } + nD.exports = p9 = bU; + Object.defineProperty(p9, "__esModule", { value: true }); + p9.default = bU; +}); +var xL = 50; +function y1($ = xL) { + let X = new AbortController(); + return (0, import_events.setMaxListeners)($, X.signal), X; +} +var a$ = class extends Error { +}; +function f1() { + return process.versions.bun !== void 0; +} +var fL = typeof global == "object" && global && global.Object === Object && global; +var mU = fL; +var gL = typeof self == "object" && self && self.Object === Object && self; +var hL = mU || gL || Function("return this")(); +var g1 = hL; +var uL = g1.Symbol; +var h1 = uL; +var lU = Object.prototype; +var mL = lU.hasOwnProperty; +var lL = lU.toString; +var e0 = h1 ? h1.toStringTag : void 0; +function cL($) { + var X = mL.call($, e0), J = $[e0]; + try { + $[e0] = void 0; + var Q = true; + } catch (z6) { + } + var Y = lL.call($); + if (Q) if (X) $[e0] = J; + else delete $[e0]; + return Y; +} +var cU = cL; +var pL = Object.prototype; +var iL = pL.toString; +function nL($) { + return iL.call($); +} +var pU = nL; +var dL = "[object Null]"; +var rL = "[object Undefined]"; +var iU = h1 ? h1.toStringTag : void 0; +function oL($) { + if ($ == null) return $ === void 0 ? rL : dL; + return iU && iU in Object($) ? cU($) : pU($); +} +var nU = oL; +function tL($) { + var X = typeof $; + return $ != null && (X == "object" || X == "function"); +} +var o9 = tL; +var aL = "[object AsyncFunction]"; +var sL = "[object Function]"; +var eL = "[object GeneratorFunction]"; +var $j = "[object Proxy]"; +function Xj($) { + if (!o9($)) return false; + var X = nU($); + return X == sL || X == eL || X == aL || X == $j; +} +var dU = Xj; +var Jj = g1["__core-js_shared__"]; +var t9 = Jj; +var rU = (function() { + var $ = /[^.]+$/.exec(t9 && t9.keys && t9.keys.IE_PROTO || ""); + return $ ? "Symbol(src)_1." + $ : ""; +})(); +function Yj($) { + return !!rU && rU in $; +} +var oU = Yj; +var Qj = Function.prototype; +var zj = Qj.toString; +function Wj($) { + if ($ != null) { + try { + return zj.call($); + } catch (X) { + } + try { + return $ + ""; + } catch (X) { + } + } + return ""; +} +var tU = Wj; +var Gj = /[\\^$.*+?()[\]{}|]/g; +var Uj = /^\[object .+?Constructor\]$/; +var Hj = Function.prototype; +var Kj = Object.prototype; +var Nj = Hj.toString; +var Vj = Kj.hasOwnProperty; +var Oj = RegExp("^" + Nj.call(Vj).replace(Gj, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"); +function wj($) { + if (!o9($) || oU($)) return false; + var X = dU($) ? Oj : Uj; + return X.test(tU($)); +} +var aU = wj; +function Bj($, X) { + return $ == null ? void 0 : $[X]; +} +var sU = Bj; +function qj($, X) { + var J = sU($, X); + return aU(J) ? J : void 0; +} +var a9 = qj; +var Dj = a9(Object, "create"); +var a6 = Dj; +function Lj() { + this.__data__ = a6 ? a6(null) : {}, this.size = 0; +} +var eU = Lj; +function jj($) { + var X = this.has($) && delete this.__data__[$]; + return this.size -= X ? 1 : 0, X; +} +var $H = jj; +var Fj = "__lodash_hash_undefined__"; +var Mj = Object.prototype; +var Ij = Mj.hasOwnProperty; +function Aj($) { + var X = this.__data__; + if (a6) { + var J = X[$]; + return J === Fj ? void 0 : J; + } + return Ij.call(X, $) ? X[$] : void 0; +} +var XH = Aj; +var bj = Object.prototype; +var Pj = bj.hasOwnProperty; +function Zj($) { + var X = this.__data__; + return a6 ? X[$] !== void 0 : Pj.call(X, $); +} +var JH = Zj; +var Ej = "__lodash_hash_undefined__"; +function Rj($, X) { + var J = this.__data__; + return this.size += this.has($) ? 0 : 1, J[$] = a6 && X === void 0 ? Ej : X, this; +} +var YH = Rj; +function u1($) { + var X = -1, J = $ == null ? 0 : $.length; + this.clear(); + while (++X < J) { + var Q = $[X]; + this.set(Q[0], Q[1]); + } +} +u1.prototype.clear = eU; +u1.prototype.delete = $H; +u1.prototype.get = XH; +u1.prototype.has = JH; +u1.prototype.set = YH; +var eQ = u1; +function Sj() { + this.__data__ = [], this.size = 0; +} +var QH = Sj; +function vj($, X) { + return $ === X || $ !== $ && X !== X; +} +var zH = vj; +function Cj($, X) { + var J = $.length; + while (J--) if (zH($[J][0], X)) return J; + return -1; +} +var F4 = Cj; +var kj = Array.prototype; +var _j = kj.splice; +function xj($) { + var X = this.__data__, J = F4(X, $); + if (J < 0) return false; + var Q = X.length - 1; + if (J == Q) X.pop(); + else _j.call(X, J, 1); + return --this.size, true; +} +var WH = xj; +function Tj($) { + var X = this.__data__, J = F4(X, $); + return J < 0 ? void 0 : X[J][1]; +} +var GH = Tj; +function yj($) { + return F4(this.__data__, $) > -1; +} +var UH = yj; +function fj($, X) { + var J = this.__data__, Q = F4(J, $); + if (Q < 0) ++this.size, J.push([$, X]); + else J[Q][1] = X; + return this; +} +var HH = fj; +function m1($) { + var X = -1, J = $ == null ? 0 : $.length; + this.clear(); + while (++X < J) { + var Q = $[X]; + this.set(Q[0], Q[1]); + } +} +m1.prototype.clear = QH; +m1.prototype.delete = WH; +m1.prototype.get = GH; +m1.prototype.has = UH; +m1.prototype.set = HH; +var KH = m1; +var gj = a9(g1, "Map"); +var NH = gj; +function hj() { + this.size = 0, this.__data__ = { hash: new eQ(), map: new (NH || KH)(), string: new eQ() }; +} +var VH = hj; +function uj($) { + var X = typeof $; + return X == "string" || X == "number" || X == "symbol" || X == "boolean" ? $ !== "__proto__" : $ === null; +} +var OH = uj; +function mj($, X) { + var J = $.__data__; + return OH(X) ? J[typeof X == "string" ? "string" : "hash"] : J.map; +} +var M4 = mj; +function lj($) { + var X = M4(this, $).delete($); + return this.size -= X ? 1 : 0, X; +} +var wH = lj; +function cj($) { + return M4(this, $).get($); +} +var BH = cj; +function pj($) { + return M4(this, $).has($); +} +var qH = pj; +function ij($, X) { + var J = M4(this, $), Q = J.size; + return J.set($, X), this.size += J.size == Q ? 0 : 1, this; +} +var DH = ij; +function l1($) { + var X = -1, J = $ == null ? 0 : $.length; + this.clear(); + while (++X < J) { + var Q = $[X]; + this.set(Q[0], Q[1]); + } +} +l1.prototype.clear = VH; +l1.prototype.delete = wH; +l1.prototype.get = BH; +l1.prototype.has = qH; +l1.prototype.set = DH; +var $z = l1; +var nj = "Expected a function"; +function Xz($, X) { + if (typeof $ != "function" || X != null && typeof X != "function") throw TypeError(nj); + var J = function() { + var Q = arguments, Y = X ? X.apply(this, Q) : Q[0], z6 = J.cache; + if (z6.has(Y)) return z6.get(Y); + var W = $.apply(this, Q); + return J.cache = z6.set(Y, W) || z6, W; + }; + return J.cache = new (Xz.Cache || $z)(), J; +} +Xz.Cache = $z; +var R6 = Xz; +var c1 = R6(() => { + var _a3; + return ((_a3 = process.env.CLAUDE_CONFIG_DIR) != null ? _a3 : (0, import_path6.join)((0, import_os.homedir)(), ".claude")).normalize("NFC"); +}, () => process.env.CLAUDE_CONFIG_DIR); +function B6($) { + if (!$) return false; + if (typeof $ === "boolean") return $; + let X = $.toLowerCase().trim(); + return ["1", "true", "yes", "on"].includes(X); +} +function v($, X, J, Q, Y) { + if (Q === "m") throw TypeError("Private method is not writable"); + if (Q === "a" && !Y) throw TypeError("Private accessor was defined without a setter"); + if (typeof X === "function" ? $ !== X || !Y : !X.has($)) throw TypeError("Cannot write private member to an object whose class did not declare it"); + return Q === "a" ? Y.call($, J) : Y ? Y.value = J : X.set($, J), J; +} +function D($, X, J, Q) { + if (J === "a" && !Q) throw TypeError("Private accessor was defined without a getter"); + if (typeof X === "function" ? $ !== X || !Q : !X.has($)) throw TypeError("Cannot read private member from an object whose class did not declare it"); + return J === "m" ? Q : J === "a" ? Q.call($) : Q ? Q.value : X.get($); +} +var Jz = function() { + let { crypto: $ } = globalThis; + if ($ == null ? void 0 : $.randomUUID) return Jz = $.randomUUID.bind($), $.randomUUID(); + let X = new Uint8Array(1), J = $ ? () => $.getRandomValues(X)[0] : () => Math.random() * 255 & 255; + return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (Q) => (+Q ^ J() & 15 >> +Q / 4).toString(16)); +}; +function s6($) { + return typeof $ === "object" && $ !== null && ("name" in $ && $.name === "AbortError" || "message" in $ && String($.message).includes("FetchRequestCanceledException")); +} +var $X = ($) => { + if ($ instanceof Error) return $; + if (typeof $ === "object" && $ !== null) { + try { + if (Object.prototype.toString.call($) === "[object Error]") { + let X = Error($.message, $.cause ? { cause: $.cause } : {}); + if ($.stack) X.stack = $.stack; + if ($.cause && !X.cause) X.cause = $.cause; + if ($.name) X.name = $.name; + return X; + } + } catch (e3) { + } + try { + return Error(JSON.stringify($)); + } catch (e3) { + } + } + return Error($); +}; +var T = class extends Error { +}; +var v$ = class _v$ extends T { + constructor($, X, J, Q) { + super(`${_v$.makeMessage($, X, J)}`); + this.status = $, this.headers = Q, this.requestID = Q == null ? void 0 : Q.get("request-id"), this.error = X; + } + static makeMessage($, X, J) { + let Q = (X == null ? void 0 : X.message) ? typeof X.message === "string" ? X.message : JSON.stringify(X.message) : X ? JSON.stringify(X) : J; + if ($ && Q) return `${$} ${Q}`; + if ($) return `${$} status code (no body)`; + if (Q) return Q; + return "(no status code or body)"; + } + static generate($, X, J, Q) { + if (!$ || !Q) return new X1({ message: J, cause: $X(X) }); + let Y = X; + if ($ === 400) return new JX($, Y, J, Q); + if ($ === 401) return new YX($, Y, J, Q); + if ($ === 403) return new QX($, Y, J, Q); + if ($ === 404) return new zX($, Y, J, Q); + if ($ === 409) return new WX($, Y, J, Q); + if ($ === 422) return new GX($, Y, J, Q); + if ($ === 429) return new UX($, Y, J, Q); + if ($ >= 500) return new HX($, Y, J, Q); + return new _v$($, Y, J, Q); + } +}; +var T$ = class extends v$ { + constructor({ message: $ } = {}) { + super(void 0, void 0, $ || "Request was aborted.", void 0); + } +}; +var X1 = class extends v$ { + constructor({ message: $, cause: X }) { + super(void 0, void 0, $ || "Connection error.", void 0); + if (X) this.cause = X; + } +}; +var XX = class extends X1 { + constructor({ message: $ } = {}) { + super({ message: $ != null ? $ : "Request timed out." }); + } +}; +var JX = class extends v$ { +}; +var YX = class extends v$ { +}; +var QX = class extends v$ { +}; +var zX = class extends v$ { +}; +var WX = class extends v$ { +}; +var GX = class extends v$ { +}; +var UX = class extends v$ { +}; +var HX = class extends v$ { +}; +var tj = /^[a-z][a-z0-9+.-]*:/i; +var LH = ($) => { + return tj.test($); +}; +var Yz = ($) => (Yz = Array.isArray, Yz($)); +var Qz = Yz; +function s9($) { + if (typeof $ !== "object") return {}; + return $ != null ? $ : {}; +} +function zz($) { + if (!$) return true; + for (let X in $) return false; + return true; +} +function jH($, X) { + return Object.prototype.hasOwnProperty.call($, X); +} +var FH = ($, X) => { + if (typeof X !== "number" || !Number.isInteger(X)) throw new T(`${$} must be an integer`); + if (X < 0) throw new T(`${$} must be a positive integer`); + return X; +}; +var e9 = ($) => { + try { + return JSON.parse($); + } catch (X) { + return; + } +}; +var MH = ($) => new Promise((X) => setTimeout(X, $)); +var I4 = "0.80.0"; +var PH = () => { + return typeof window < "u" && typeof window.document < "u" && typeof navigator < "u"; +}; +function aj() { + if (typeof Deno < "u" && Deno.build != null) return "deno"; + if (typeof EdgeRuntime < "u") return "edge"; + if (Object.prototype.toString.call(typeof globalThis.process < "u" ? globalThis.process : 0) === "[object process]") return "node"; + return "unknown"; +} +var sj = () => { + var _a3, _b2, _c, _d, _e; + let $ = aj(); + if ($ === "deno") return { "X-Stainless-Lang": "js", "X-Stainless-Package-Version": I4, "X-Stainless-OS": AH(Deno.build.os), "X-Stainless-Arch": IH(Deno.build.arch), "X-Stainless-Runtime": "deno", "X-Stainless-Runtime-Version": typeof Deno.version === "string" ? Deno.version : (_b2 = (_a3 = Deno.version) == null ? void 0 : _a3.deno) != null ? _b2 : "unknown" }; + if (typeof EdgeRuntime < "u") return { "X-Stainless-Lang": "js", "X-Stainless-Package-Version": I4, "X-Stainless-OS": "Unknown", "X-Stainless-Arch": `other:${EdgeRuntime}`, "X-Stainless-Runtime": "edge", "X-Stainless-Runtime-Version": globalThis.process.version }; + if ($ === "node") return { "X-Stainless-Lang": "js", "X-Stainless-Package-Version": I4, "X-Stainless-OS": AH((_c = globalThis.process.platform) != null ? _c : "unknown"), "X-Stainless-Arch": IH((_d = globalThis.process.arch) != null ? _d : "unknown"), "X-Stainless-Runtime": "node", "X-Stainless-Runtime-Version": (_e = globalThis.process.version) != null ? _e : "unknown" }; + let X = ej(); + if (X) return { "X-Stainless-Lang": "js", "X-Stainless-Package-Version": I4, "X-Stainless-OS": "Unknown", "X-Stainless-Arch": "unknown", "X-Stainless-Runtime": `browser:${X.browser}`, "X-Stainless-Runtime-Version": X.version }; + return { "X-Stainless-Lang": "js", "X-Stainless-Package-Version": I4, "X-Stainless-OS": "Unknown", "X-Stainless-Arch": "unknown", "X-Stainless-Runtime": "unknown", "X-Stainless-Runtime-Version": "unknown" }; +}; +function ej() { + if (typeof navigator > "u" || !navigator) return null; + let $ = [{ key: "edge", pattern: /Edge(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, { key: "ie", pattern: /MSIE(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, { key: "ie", pattern: /Trident(?:.*rv\:(\d+)\.(\d+)(?:\.(\d+))?)?/ }, { key: "chrome", pattern: /Chrome(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, { key: "firefox", pattern: /Firefox(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, { key: "safari", pattern: /(?:Version\W+(\d+)\.(\d+)(?:\.(\d+))?)?(?:\W+Mobile\S*)?\W+Safari/ }]; + for (let { key: X, pattern: J } of $) { + let Q = J.exec(navigator.userAgent); + if (Q) { + let Y = Q[1] || 0, z6 = Q[2] || 0, W = Q[3] || 0; + return { browser: X, version: `${Y}.${z6}.${W}` }; + } + } + return null; +} +var IH = ($) => { + if ($ === "x32") return "x32"; + if ($ === "x86_64" || $ === "x64") return "x64"; + if ($ === "arm") return "arm"; + if ($ === "aarch64" || $ === "arm64") return "arm64"; + if ($) return `other:${$}`; + return "unknown"; +}; +var AH = ($) => { + if ($ = $.toLowerCase(), $.includes("ios")) return "iOS"; + if ($ === "android") return "Android"; + if ($ === "darwin") return "MacOS"; + if ($ === "win32") return "Windows"; + if ($ === "freebsd") return "FreeBSD"; + if ($ === "openbsd") return "OpenBSD"; + if ($ === "linux") return "Linux"; + if ($) return `Other:${$}`; + return "Unknown"; +}; +var bH; +var ZH = () => { + return bH != null ? bH : bH = sj(); +}; +function EH() { + if (typeof fetch < "u") return fetch; + throw Error("`fetch` is not defined as a global; Either pass `fetch` to the client, `new Anthropic({ fetch })` or polyfill the global, `globalThis.fetch = fetch`"); +} +function Wz(...$) { + let X = globalThis.ReadableStream; + if (typeof X > "u") throw Error("`ReadableStream` is not defined as a global; You will need to polyfill it, `globalThis.ReadableStream = ReadableStream`"); + return new X(...$); +} +function $J($) { + let X = Symbol.asyncIterator in $ ? $[Symbol.asyncIterator]() : $[Symbol.iterator](); + return Wz({ start() { + }, async pull(J) { + let { done: Q, value: Y } = await X.next(); + if (Q) J.close(); + else J.enqueue(Y); + }, async cancel() { + var _a3; + await ((_a3 = X.return) == null ? void 0 : _a3.call(X)); + } }); +} +function KX($) { + if ($[Symbol.asyncIterator]) return $; + let X = $.getReader(); + return { async next() { + try { + let J = await X.read(); + if (J == null ? void 0 : J.done) X.releaseLock(); + return J; + } catch (J) { + throw X.releaseLock(), J; + } + }, async return() { + let J = X.cancel(); + return X.releaseLock(), await J, { done: true, value: void 0 }; + }, [Symbol.asyncIterator]() { + return this; + } }; +} +async function RH($) { + var _a3, _b2; + if ($ === null || typeof $ !== "object") return; + if ($[Symbol.asyncIterator]) { + await ((_b2 = (_a3 = $[Symbol.asyncIterator]()).return) == null ? void 0 : _b2.call(_a3)); + return; + } + let X = $.getReader(), J = X.cancel(); + X.releaseLock(), await J; +} +var SH = ({ headers: $, body: X }) => { + return { bodyHeaders: { "content-type": "application/json" }, body: JSON.stringify(X) }; +}; +function vH($) { + return Object.entries($).filter(([X, J]) => typeof J < "u").map(([X, J]) => { + if (typeof J === "string" || typeof J === "number" || typeof J === "boolean") return `${encodeURIComponent(X)}=${encodeURIComponent(J)}`; + if (J === null) return `${encodeURIComponent(X)}=`; + throw new T(`Cannot stringify type ${typeof J}; Expected string, number, boolean, or null. If you need to pass nested query parameters, you can manually encode them, e.g. { query: { 'foo[key1]': value1, 'foo[key2]': value2 } }, and please open a GitHub issue requesting better support for your use case.`); + }).join("&"); +} +function _H($) { + let X = 0; + for (let Y of $) X += Y.length; + let J = new Uint8Array(X), Q = 0; + for (let Y of $) J.set(Y, Q), Q += Y.length; + return J; +} +var CH; +function NX($) { + let X; + return (CH != null ? CH : (X = new globalThis.TextEncoder(), CH = X.encode.bind(X)))($); +} +var kH; +function Gz($) { + let X; + return (kH != null ? kH : (X = new globalThis.TextDecoder(), kH = X.decode.bind(X)))($); +} +var U6; +var H6; +var A4 = class { + constructor() { + U6.set(this, void 0), H6.set(this, void 0), v(this, U6, new Uint8Array(), "f"), v(this, H6, null, "f"); + } + decode($) { + if ($ == null) return []; + let X = $ instanceof ArrayBuffer ? new Uint8Array($) : typeof $ === "string" ? NX($) : $; + v(this, U6, _H([D(this, U6, "f"), X]), "f"); + let J = [], Q; + while ((Q = JF(D(this, U6, "f"), D(this, H6, "f"))) != null) { + if (Q.carriage && D(this, H6, "f") == null) { + v(this, H6, Q.index, "f"); + continue; + } + if (D(this, H6, "f") != null && (Q.index !== D(this, H6, "f") + 1 || Q.carriage)) { + J.push(Gz(D(this, U6, "f").subarray(0, D(this, H6, "f") - 1))), v(this, U6, D(this, U6, "f").subarray(D(this, H6, "f")), "f"), v(this, H6, null, "f"); + continue; + } + let Y = D(this, H6, "f") !== null ? Q.preceding - 1 : Q.preceding, z6 = Gz(D(this, U6, "f").subarray(0, Y)); + J.push(z6), v(this, U6, D(this, U6, "f").subarray(Q.index), "f"), v(this, H6, null, "f"); + } + return J; + } + flush() { + if (!D(this, U6, "f").length) return []; + return this.decode(` +`); + } +}; +U6 = /* @__PURE__ */ new WeakMap(), H6 = /* @__PURE__ */ new WeakMap(); +A4.NEWLINE_CHARS = /* @__PURE__ */ new Set([` +`, "\r"]); +A4.NEWLINE_REGEXP = /\r\n|[\n\r]/g; +function JF($, X) { + for (let Y = X != null ? X : 0; Y < $.length; Y++) { + if ($[Y] === 10) return { preceding: Y, index: Y + 1, carriage: false }; + if ($[Y] === 13) return { preceding: Y, index: Y + 1, carriage: true }; + } + return null; +} +function xH($) { + for (let Q = 0; Q < $.length - 1; Q++) { + if ($[Q] === 10 && $[Q + 1] === 10) return Q + 2; + if ($[Q] === 13 && $[Q + 1] === 13) return Q + 2; + if ($[Q] === 13 && $[Q + 1] === 10 && Q + 3 < $.length && $[Q + 2] === 13 && $[Q + 3] === 10) return Q + 4; + } + return -1; +} +var JJ = { off: 0, error: 200, warn: 300, info: 400, debug: 500 }; +var Uz = ($, X, J) => { + if (!$) return; + if (jH(JJ, $)) return $; + _$(J).warn(`${X} was set to ${JSON.stringify($)}, expected one of ${JSON.stringify(Object.keys(JJ))}`); + return; +}; +function VX() { +} +function XJ($, X, J) { + if (!X || JJ[$] > JJ[J]) return VX; + else return X[$].bind(X); +} +var YF = { error: VX, warn: VX, info: VX, debug: VX }; +var TH = /* @__PURE__ */ new WeakMap(); +function _$($) { + var _a3; + let X = $.logger, J = (_a3 = $.logLevel) != null ? _a3 : "off"; + if (!X) return YF; + let Q = TH.get(X); + if (Q && Q[0] === J) return Q[1]; + let Y = { error: XJ("error", X, J), warn: XJ("warn", X, J), info: XJ("info", X, J), debug: XJ("debug", X, J) }; + return TH.set(X, [J, Y]), Y; +} +var e6 = ($) => { + if ($.options) $.options = { ...$.options }, delete $.options.headers; + if ($.headers) $.headers = Object.fromEntries(($.headers instanceof Headers ? [...$.headers] : Object.entries($.headers)).map(([X, J]) => [X, X.toLowerCase() === "x-api-key" || X.toLowerCase() === "authorization" || X.toLowerCase() === "cookie" || X.toLowerCase() === "set-cookie" ? "***" : J])); + if ("retryOfRequestLogID" in $) { + if ($.retryOfRequestLogID) $.retryOf = $.retryOfRequestLogID; + delete $.retryOfRequestLogID; + } + return $; +}; +var OX; +var K6 = class _K6 { + constructor($, X, J) { + this.iterator = $, OX.set(this, void 0), this.controller = X, v(this, OX, J, "f"); + } + static fromSSEResponse($, X, J) { + let Q = false, Y = J ? _$(J) : console; + async function* z6() { + var _a3; + if (Q) throw new T("Cannot iterate over a consumed stream, use `.tee()` to split the stream."); + Q = true; + let W = false; + try { + for await (let G of QF($, X)) { + if (G.event === "completion") try { + yield JSON.parse(G.data); + } catch (U) { + throw Y.error("Could not parse message into JSON:", G.data), Y.error("From chunk:", G.raw), U; + } + if (G.event === "message_start" || G.event === "message_delta" || G.event === "message_stop" || G.event === "content_block_start" || G.event === "content_block_delta" || G.event === "content_block_stop") try { + yield JSON.parse(G.data); + } catch (U) { + throw Y.error("Could not parse message into JSON:", G.data), Y.error("From chunk:", G.raw), U; + } + if (G.event === "ping") continue; + if (G.event === "error") throw new v$(void 0, (_a3 = e9(G.data)) != null ? _a3 : G.data, void 0, $.headers); + } + W = true; + } catch (G) { + if (s6(G)) return; + throw G; + } finally { + if (!W) X.abort(); + } + } + return new _K6(z6, X, J); + } + static fromReadableStream($, X, J) { + let Q = false; + async function* Y() { + let W = new A4(), G = KX($); + for await (let U of G) for (let H of W.decode(U)) yield H; + for (let U of W.flush()) yield U; + } + async function* z6() { + if (Q) throw new T("Cannot iterate over a consumed stream, use `.tee()` to split the stream."); + Q = true; + let W = false; + try { + for await (let G of Y()) { + if (W) continue; + if (G) yield JSON.parse(G); + } + W = true; + } catch (G) { + if (s6(G)) return; + throw G; + } finally { + if (!W) X.abort(); + } + } + return new _K6(z6, X, J); + } + [(OX = /* @__PURE__ */ new WeakMap(), Symbol.asyncIterator)]() { + return this.iterator(); + } + tee() { + let $ = [], X = [], J = this.iterator(), Q = (Y) => { + return { next: () => { + if (Y.length === 0) { + let z6 = J.next(); + $.push(z6), X.push(z6); + } + return Y.shift(); + } }; + }; + return [new _K6(() => Q($), this.controller, D(this, OX, "f")), new _K6(() => Q(X), this.controller, D(this, OX, "f"))]; + } + toReadableStream() { + let $ = this, X; + return Wz({ async start() { + X = $[Symbol.asyncIterator](); + }, async pull(J) { + try { + let { value: Q, done: Y } = await X.next(); + if (Y) return J.close(); + let z6 = NX(JSON.stringify(Q) + ` +`); + J.enqueue(z6); + } catch (Q) { + J.error(Q); + } + }, async cancel() { + var _a3; + await ((_a3 = X.return) == null ? void 0 : _a3.call(X)); + } }); + } +}; +async function* QF($, X) { + if (!$.body) { + if (X.abort(), typeof globalThis.navigator < "u" && globalThis.navigator.product === "ReactNative") throw new T("The default react-native fetch implementation does not support streaming. Please use expo/fetch: https://docs.expo.dev/versions/latest/sdk/expo/#expofetch-api"); + throw new T("Attempted to iterate over a response with no body"); + } + let J = new yH(), Q = new A4(), Y = KX($.body); + for await (let z6 of zF(Y)) for (let W of Q.decode(z6)) { + let G = J.decode(W); + if (G) yield G; + } + for (let z6 of Q.flush()) { + let W = J.decode(z6); + if (W) yield W; + } +} +async function* zF($) { + let X = new Uint8Array(); + for await (let J of $) { + if (J == null) continue; + let Q = J instanceof ArrayBuffer ? new Uint8Array(J) : typeof J === "string" ? NX(J) : J, Y = new Uint8Array(X.length + Q.length); + Y.set(X), Y.set(Q, X.length), X = Y; + let z6; + while ((z6 = xH(X)) !== -1) yield X.slice(0, z6), X = X.slice(z6); + } + if (X.length > 0) yield X; +} +var yH = class { + constructor() { + this.event = null, this.data = [], this.chunks = []; + } + decode($) { + if ($.endsWith("\r")) $ = $.substring(0, $.length - 1); + if (!$) { + if (!this.event && !this.data.length) return null; + let Y = { event: this.event, data: this.data.join(` +`), raw: this.chunks }; + return this.event = null, this.data = [], this.chunks = [], Y; + } + if (this.chunks.push($), $.startsWith(":")) return null; + let [X, J, Q] = WF($, ":"); + if (Q.startsWith(" ")) Q = Q.substring(1); + if (X === "event") this.event = Q; + else if (X === "data") this.data.push(Q); + return null; + } +}; +function WF($, X) { + let J = $.indexOf(X); + if (J !== -1) return [$.substring(0, J), X, $.substring(J + X.length)]; + return [$, "", ""]; +} +async function YJ($, X) { + let { response: J, requestLogID: Q, retryOfRequestLogID: Y, startTime: z6 } = X, W = await (async () => { + var _a3, _b2; + if (X.options.stream) { + if (_$($).debug("response", J.status, J.url, J.headers, J.body), X.options.__streamClass) return X.options.__streamClass.fromSSEResponse(J, X.controller); + return K6.fromSSEResponse(J, X.controller); + } + if (J.status === 204) return null; + if (X.options.__binaryResponse) return J; + let U = (_b2 = (_a3 = J.headers.get("content-type")) == null ? void 0 : _a3.split(";")[0]) == null ? void 0 : _b2.trim(); + if ((U == null ? void 0 : U.includes("application/json")) || (U == null ? void 0 : U.endsWith("+json"))) { + if (J.headers.get("content-length") === "0") return; + let O = await J.json(); + return Hz(O, J); + } + return await J.text(); + })(); + return _$($).debug(`[${Q}] response parsed`, e6({ retryOfRequestLogID: Y, url: J.url, status: J.status, body: W, durationMs: Date.now() - z6 })), W; +} +function Hz($, X) { + if (!$ || typeof $ !== "object" || Array.isArray($)) return $; + return Object.defineProperty($, "_request_id", { value: X.headers.get("request-id"), enumerable: false }); +} +var wX; +var J1 = class _J1 extends Promise { + constructor($, X, J = YJ) { + super((Q) => { + Q(null); + }); + this.responsePromise = X, this.parseResponse = J, wX.set(this, void 0), v(this, wX, $, "f"); + } + _thenUnwrap($) { + return new _J1(D(this, wX, "f"), this.responsePromise, async (X, J) => Hz($(await this.parseResponse(X, J), J), J.response)); + } + asResponse() { + return this.responsePromise.then(($) => $.response); + } + async withResponse() { + let [$, X] = await Promise.all([this.parse(), this.asResponse()]); + return { data: $, response: X, request_id: X.headers.get("request-id") }; + } + parse() { + if (!this.parsedPromise) this.parsedPromise = this.responsePromise.then(($) => this.parseResponse(D(this, wX, "f"), $)); + return this.parsedPromise; + } + then($, X) { + return this.parse().then($, X); + } + catch($) { + return this.parse().catch($); + } + finally($) { + return this.parse().finally($); + } +}; +wX = /* @__PURE__ */ new WeakMap(); +var QJ; +var Kz = class { + constructor($, X, J, Q) { + QJ.set(this, void 0), v(this, QJ, $, "f"), this.options = Q, this.response = X, this.body = J; + } + hasNextPage() { + if (!this.getPaginatedItems().length) return false; + return this.nextPageRequestOptions() != null; + } + async getNextPage() { + let $ = this.nextPageRequestOptions(); + if (!$) throw new T("No next page expected; please check `.hasNextPage()` before calling `.getNextPage()`."); + return await D(this, QJ, "f").requestAPIList(this.constructor, $); + } + async *iterPages() { + let $ = this; + yield $; + while ($.hasNextPage()) $ = await $.getNextPage(), yield $; + } + async *[(QJ = /* @__PURE__ */ new WeakMap(), Symbol.asyncIterator)]() { + for await (let $ of this.iterPages()) for (let X of $.getPaginatedItems()) yield X; + } +}; +var zJ = class extends J1 { + constructor($, X, J) { + super($, X, async (Q, Y) => new J(Q, Y.response, await YJ(Q, Y), Y.options)); + } + async *[Symbol.asyncIterator]() { + let $ = await this; + for await (let X of $) yield X; + } +}; +var S6 = class extends Kz { + constructor($, X, J, Q) { + super($, X, J, Q); + this.data = J.data || [], this.has_more = J.has_more || false, this.first_id = J.first_id || null, this.last_id = J.last_id || null; + } + getPaginatedItems() { + var _a3; + return (_a3 = this.data) != null ? _a3 : []; + } + hasNextPage() { + if (this.has_more === false) return false; + return super.hasNextPage(); + } + nextPageRequestOptions() { + var _a3; + if ((_a3 = this.options.query) == null ? void 0 : _a3.before_id) { + let X = this.first_id; + if (!X) return null; + return { ...this.options, query: { ...s9(this.options.query), before_id: X } }; + } + let $ = this.last_id; + if (!$) return null; + return { ...this.options, query: { ...s9(this.options.query), after_id: $ } }; + } +}; +var BX = class extends Kz { + constructor($, X, J, Q) { + super($, X, J, Q); + this.data = J.data || [], this.has_more = J.has_more || false, this.next_page = J.next_page || null; + } + getPaginatedItems() { + var _a3; + return (_a3 = this.data) != null ? _a3 : []; + } + hasNextPage() { + if (this.has_more === false) return false; + return super.hasNextPage(); + } + nextPageRequestOptions() { + let $ = this.next_page; + if (!$) return null; + return { ...this.options, query: { ...s9(this.options.query), page: $ } }; + } +}; +var Vz = () => { + var _a3; + if (typeof File > "u") { + let { process: $ } = globalThis, X = typeof ((_a3 = $ == null ? void 0 : $.versions) == null ? void 0 : _a3.node) === "string" && parseInt($.versions.node.split(".")) < 20; + throw Error("`File` is not defined as a global, which is required for file uploads." + (X ? " Update to Node 20 LTS or newer, or set `globalThis.File` to `import('node:buffer').File`." : "")); + } +}; +function Y1($, X, J) { + return Vz(), new File($, X != null ? X : "unknown_file", J); +} +function qX($, X) { + let J = typeof $ === "object" && $ !== null && ("name" in $ && $.name && String($.name) || "url" in $ && $.url && String($.url) || "filename" in $ && $.filename && String($.filename) || "path" in $ && $.path && String($.path)) || ""; + return X ? J.split(/[\\/]/).pop() || void 0 : J; +} +var Oz = ($) => $ != null && typeof $ === "object" && typeof $[Symbol.asyncIterator] === "function"; +var p1 = async ($, X, J = true) => { + return { ...$, body: await HF($.body, X, J) }; +}; +var fH = /* @__PURE__ */ new WeakMap(); +function UF($) { + let X = typeof $ === "function" ? $ : $.fetch, J = fH.get(X); + if (J) return J; + let Q = (async () => { + try { + let Y = "Response" in X ? X.Response : (await X("data:,")).constructor, z6 = new FormData(); + if (z6.toString() === await new Y(z6).text()) return false; + return true; + } catch (e3) { + return true; + } + })(); + return fH.set(X, Q), Q; +} +var HF = async ($, X, J = true) => { + if (!await UF(X)) throw TypeError("The provided fetch function does not support file uploads with the current global FormData class."); + let Q = new FormData(); + return await Promise.all(Object.entries($ || {}).map(([Y, z6]) => Nz(Q, Y, z6, J))), Q; +}; +var KF = ($) => $ instanceof Blob && "name" in $; +var Nz = async ($, X, J, Q) => { + if (J === void 0) return; + if (J == null) throw TypeError(`Received null for "${X}"; to pass null in FormData, you must use the string 'null'`); + if (typeof J === "string" || typeof J === "number" || typeof J === "boolean") $.append(X, String(J)); + else if (J instanceof Response) { + let Y = {}, z6 = J.headers.get("Content-Type"); + if (z6) Y = { type: z6 }; + $.append(X, Y1([await J.blob()], qX(J, Q), Y)); + } else if (Oz(J)) $.append(X, Y1([await new Response($J(J)).blob()], qX(J, Q))); + else if (KF(J)) $.append(X, Y1([J], qX(J, Q), { type: J.type })); + else if (Array.isArray(J)) await Promise.all(J.map((Y) => Nz($, X + "[]", Y, Q))); + else if (typeof J === "object") await Promise.all(Object.entries(J).map(([Y, z6]) => Nz($, `${X}[${Y}]`, z6, Q))); + else throw TypeError(`Invalid value given to form, expected a string, number, boolean, object, Array, File or Blob but got ${J} instead`); +}; +var gH = ($) => $ != null && typeof $ === "object" && typeof $.size === "number" && typeof $.type === "string" && typeof $.text === "function" && typeof $.slice === "function" && typeof $.arrayBuffer === "function"; +var NF = ($) => $ != null && typeof $ === "object" && typeof $.name === "string" && typeof $.lastModified === "number" && gH($); +var VF = ($) => $ != null && typeof $ === "object" && typeof $.url === "string" && typeof $.blob === "function"; +async function WJ($, X, J) { + if (Vz(), $ = await $, X || (X = qX($, true)), NF($)) { + if ($ instanceof File && X == null && J == null) return $; + return Y1([await $.arrayBuffer()], X != null ? X : $.name, { type: $.type, lastModified: $.lastModified, ...J }); + } + if (VF($)) { + let Y = await $.blob(); + return X || (X = new URL($.url).pathname.split(/[\\/]/).pop()), Y1(await wz(Y), X, J); + } + let Q = await wz($); + if (!(J == null ? void 0 : J.type)) { + let Y = Q.find((z6) => typeof z6 === "object" && "type" in z6 && z6.type); + if (typeof Y === "string") J = { ...J, type: Y }; + } + return Y1(Q, X, J); +} +async function wz($) { + var _a3; + let X = []; + if (typeof $ === "string" || ArrayBuffer.isView($) || $ instanceof ArrayBuffer) X.push($); + else if (gH($)) X.push($ instanceof Blob ? $ : await $.arrayBuffer()); + else if (Oz($)) for await (let J of $) X.push(...await wz(J)); + else { + let J = (_a3 = $ == null ? void 0 : $.constructor) == null ? void 0 : _a3.name; + throw Error(`Unexpected data type: ${typeof $}${J ? `; constructor: ${J}` : ""}${OF($)}`); + } + return X; +} +function OF($) { + if (typeof $ !== "object" || $ === null) return ""; + return `; props: [${Object.getOwnPropertyNames($).map((J) => `"${J}"`).join(", ")}]`; +} +var A$ = class { + constructor($) { + this._client = $; + } +}; +var hH = /* @__PURE__ */ Symbol.for("brand.privateNullableHeaders"); +function* BF($) { + if (!$) return; + if (hH in $) { + let { values: Q, nulls: Y } = $; + yield* Q.entries(); + for (let z6 of Y) yield [z6, null]; + return; + } + let X = false, J; + if ($ instanceof Headers) J = $.entries(); + else if (Qz($)) J = $; + else X = true, J = Object.entries($ != null ? $ : {}); + for (let Q of J) { + let Y = Q[0]; + if (typeof Y !== "string") throw TypeError("expected header name to be a string"); + let z6 = Qz(Q[1]) ? Q[1] : [Q[1]], W = false; + for (let G of z6) { + if (G === void 0) continue; + if (X && !W) W = true, yield [Y, null]; + yield [Y, G]; + } + } +} +var n = ($) => { + let X = new Headers(), J = /* @__PURE__ */ new Set(); + for (let Q of $) { + let Y = /* @__PURE__ */ new Set(); + for (let [z6, W] of BF(Q)) { + let G = z6.toLowerCase(); + if (!Y.has(G)) X.delete(z6), Y.add(G); + if (W === null) X.delete(z6), J.add(G); + else X.append(z6, W), J.delete(G); + } + } + return { [hH]: true, values: X, nulls: J }; +}; +var DX = /* @__PURE__ */ Symbol("anthropic.sdk.stainlessHelper"); +function GJ($) { + return typeof $ === "object" && $ !== null && DX in $; +} +function Bz($, X) { + let J = /* @__PURE__ */ new Set(); + if ($) { + for (let Q of $) if (GJ(Q)) J.add(Q[DX]); + } + if (X) for (let Q of X) { + if (GJ(Q)) J.add(Q[DX]); + if (Array.isArray(Q.content)) { + for (let Y of Q.content) if (GJ(Y)) J.add(Y[DX]); + } + } + return Array.from(J); +} +function UJ($, X) { + let J = Bz($, X); + if (J.length === 0) return {}; + return { "x-stainless-helper": J.join(", ") }; +} +function uH($) { + if (GJ($)) return { "x-stainless-helper": $[DX] }; + return {}; +} +function lH($) { + return $.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent); +} +var mH = Object.freeze(/* @__PURE__ */ Object.create(null)); +var qF = ($ = lH) => function(J, ...Q) { + if (J.length === 1) return J[0]; + let Y = false, z6 = [], W = J.reduce((K, V, O) => { + var _a3, _b2, _c; + if (/[?#]/.test(V)) Y = true; + let N = Q[O], w = (Y ? encodeURIComponent : $)("" + N); + if (O !== Q.length && (N == null || typeof N === "object" && N.toString === ((_c = Object.getPrototypeOf((_b2 = Object.getPrototypeOf((_a3 = N.hasOwnProperty) != null ? _a3 : mH)) != null ? _b2 : mH)) == null ? void 0 : _c.toString))) w = N + "", z6.push({ start: K.length + V.length, length: w.length, error: `Value of type ${Object.prototype.toString.call(N).slice(8, -1)} is not a valid path parameter` }); + return K + V + (O === Q.length ? "" : w); + }, ""), G = W.split(/[?#]/, 1)[0], U = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi, H; + while ((H = U.exec(G)) !== null) z6.push({ start: H.index, length: H[0].length, error: `Value "${H[0]}" can't be safely passed as a path parameter` }); + if (z6.sort((K, V) => K.start - V.start), z6.length > 0) { + let K = 0, V = z6.reduce((O, N) => { + let w = " ".repeat(N.start - K), B = "^".repeat(N.length); + return K = N.start + N.length, O + w + B; + }, ""); + throw new T(`Path parameters result in path with invalid segments: +${z6.map((O) => O.error).join(` +`)} +${W} +${V}`); + } + return W; +}; +var F$ = qF(lH); +var LX = class extends A$ { + list($ = {}, X) { + let { betas: J, ...Q } = $ != null ? $ : {}; + return this._client.getAPIList("/v1/files", S6, { query: Q, ...X, headers: n([{ "anthropic-beta": [...J != null ? J : [], "files-api-2025-04-14"].toString() }, X == null ? void 0 : X.headers]) }); + } + delete($, X = {}, J) { + let { betas: Q } = X != null ? X : {}; + return this._client.delete(F$`/v1/files/${$}`, { ...J, headers: n([{ "anthropic-beta": [...Q != null ? Q : [], "files-api-2025-04-14"].toString() }, J == null ? void 0 : J.headers]) }); + } + download($, X = {}, J) { + let { betas: Q } = X != null ? X : {}; + return this._client.get(F$`/v1/files/${$}/content`, { ...J, headers: n([{ "anthropic-beta": [...Q != null ? Q : [], "files-api-2025-04-14"].toString(), Accept: "application/binary" }, J == null ? void 0 : J.headers]), __binaryResponse: true }); + } + retrieveMetadata($, X = {}, J) { + let { betas: Q } = X != null ? X : {}; + return this._client.get(F$`/v1/files/${$}`, { ...J, headers: n([{ "anthropic-beta": [...Q != null ? Q : [], "files-api-2025-04-14"].toString() }, J == null ? void 0 : J.headers]) }); + } + upload($, X) { + let { betas: J, ...Q } = $; + return this._client.post("/v1/files", p1({ body: Q, ...X, headers: n([{ "anthropic-beta": [...J != null ? J : [], "files-api-2025-04-14"].toString() }, uH(Q.file), X == null ? void 0 : X.headers]) }, this._client)); + } +}; +var jX = class extends A$ { + retrieve($, X = {}, J) { + let { betas: Q } = X != null ? X : {}; + return this._client.get(F$`/v1/models/${$}?beta=true`, { ...J, headers: n([{ ...(Q == null ? void 0 : Q.toString()) != null ? { "anthropic-beta": Q == null ? void 0 : Q.toString() } : void 0 }, J == null ? void 0 : J.headers]) }); + } + list($ = {}, X) { + let { betas: J, ...Q } = $ != null ? $ : {}; + return this._client.getAPIList("/v1/models?beta=true", S6, { query: Q, ...X, headers: n([{ ...(J == null ? void 0 : J.toString()) != null ? { "anthropic-beta": J == null ? void 0 : J.toString() } : void 0 }, X == null ? void 0 : X.headers]) }); + } +}; +var HJ = { "claude-opus-4-20250514": 8192, "claude-opus-4-0": 8192, "claude-4-opus-20250514": 8192, "anthropic.claude-opus-4-20250514-v1:0": 8192, "claude-opus-4@20250514": 8192, "claude-opus-4-1-20250805": 8192, "anthropic.claude-opus-4-1-20250805-v1:0": 8192, "claude-opus-4-1@20250805": 8192 }; +function cH($) { + var _a3, _b2; + return (_b2 = $ == null ? void 0 : $.output_format) != null ? _b2 : (_a3 = $ == null ? void 0 : $.output_config) == null ? void 0 : _a3.format; +} +function qz($, X, J) { + let Q = cH(X); + if (!X || !("parse" in (Q != null ? Q : {}))) return { ...$, content: $.content.map((Y) => { + if (Y.type === "text") { + let z6 = Object.defineProperty({ ...Y }, "parsed_output", { value: null, enumerable: false }); + return Object.defineProperty(z6, "parsed", { get() { + return J.logger.warn("The `parsed` property on `text` blocks is deprecated, please use `parsed_output` instead."), null; + }, enumerable: false }); + } + return Y; + }), parsed_output: null }; + return Dz($, X, J); +} +function Dz($, X, J) { + let Q = null, Y = $.content.map((z6) => { + if (z6.type === "text") { + let W = jF(X, z6.text); + if (Q === null) Q = W; + let G = Object.defineProperty({ ...z6 }, "parsed_output", { value: W, enumerable: false }); + return Object.defineProperty(G, "parsed", { get() { + return J.logger.warn("The `parsed` property on `text` blocks is deprecated, please use `parsed_output` instead."), W; + }, enumerable: false }); + } + return z6; + }); + return { ...$, content: Y, parsed_output: Q }; +} +function jF($, X) { + let J = cH($); + if ((J == null ? void 0 : J.type) !== "json_schema") return null; + try { + if ("parse" in J) return J.parse(X); + return JSON.parse(X); + } catch (Q) { + throw new T(`Failed to parse structured output: ${Q}`); + } +} +var FF = ($) => { + let X = 0, J = []; + while (X < $.length) { + let Q = $[X]; + if (Q === "\\") { + X++; + continue; + } + if (Q === "{") { + J.push({ type: "brace", value: "{" }), X++; + continue; + } + if (Q === "}") { + J.push({ type: "brace", value: "}" }), X++; + continue; + } + if (Q === "[") { + J.push({ type: "paren", value: "[" }), X++; + continue; + } + if (Q === "]") { + J.push({ type: "paren", value: "]" }), X++; + continue; + } + if (Q === ":") { + J.push({ type: "separator", value: ":" }), X++; + continue; + } + if (Q === ",") { + J.push({ type: "delimiter", value: "," }), X++; + continue; + } + if (Q === '"') { + let G = "", U = false; + Q = $[++X]; + while (Q !== '"') { + if (X === $.length) { + U = true; + break; + } + if (Q === "\\") { + if (X++, X === $.length) { + U = true; + break; + } + G += Q + $[X], Q = $[++X]; + } else G += Q, Q = $[++X]; + } + if (Q = $[++X], !U) J.push({ type: "string", value: G }); + continue; + } + if (Q && /\s/.test(Q)) { + X++; + continue; + } + let z6 = /[0-9]/; + if (Q && z6.test(Q) || Q === "-" || Q === ".") { + let G = ""; + if (Q === "-") G += Q, Q = $[++X]; + while (Q && z6.test(Q) || Q === ".") G += Q, Q = $[++X]; + J.push({ type: "number", value: G }); + continue; + } + let W = /[a-z]/i; + if (Q && W.test(Q)) { + let G = ""; + while (Q && W.test(Q)) { + if (X === $.length) break; + G += Q, Q = $[++X]; + } + if (G == "true" || G == "false" || G === "null") J.push({ type: "name", value: G }); + else { + X++; + continue; + } + continue; + } + X++; + } + return J; +}; +var i1 = ($) => { + if ($.length === 0) return $; + let X = $[$.length - 1]; + switch (X.type) { + case "separator": + return $ = $.slice(0, $.length - 1), i1($); + break; + case "number": + let J = X.value[X.value.length - 1]; + if (J === "." || J === "-") return $ = $.slice(0, $.length - 1), i1($); + case "string": + let Q = $[$.length - 2]; + if ((Q == null ? void 0 : Q.type) === "delimiter") return $ = $.slice(0, $.length - 1), i1($); + else if ((Q == null ? void 0 : Q.type) === "brace" && Q.value === "{") return $ = $.slice(0, $.length - 1), i1($); + break; + case "delimiter": + return $ = $.slice(0, $.length - 1), i1($); + break; + } + return $; +}; +var MF = ($) => { + let X = []; + if ($.map((J) => { + if (J.type === "brace") if (J.value === "{") X.push("}"); + else X.splice(X.lastIndexOf("}"), 1); + if (J.type === "paren") if (J.value === "[") X.push("]"); + else X.splice(X.lastIndexOf("]"), 1); + }), X.length > 0) X.reverse().map((J) => { + if (J === "}") $.push({ type: "brace", value: "}" }); + else if (J === "]") $.push({ type: "paren", value: "]" }); + }); + return $; +}; +var IF = ($) => { + let X = ""; + return $.map((J) => { + switch (J.type) { + case "string": + X += '"' + J.value + '"'; + break; + default: + X += J.value; + break; + } + }), X; +}; +var KJ = ($) => JSON.parse(IF(MF(i1(FF($))))); +var q6; +var b4; +var n1; +var FX; +var NJ; +var MX; +var IX; +var VJ; +var AX; +var $4; +var bX; +var OJ; +var wJ; +var Q1; +var BJ; +var qJ; +var PX; +var Lz; +var pH; +var DJ; +var jz; +var Fz; +var Mz; +var iH; +var nH = "__json_buf"; +function dH($) { + return $.type === "tool_use" || $.type === "server_tool_use" || $.type === "mcp_tool_use"; +} +var ZX = class _ZX { + constructor($, X) { + var _a3; + q6.add(this), this.messages = [], this.receivedMessages = [], b4.set(this, void 0), n1.set(this, null), this.controller = new AbortController(), FX.set(this, void 0), NJ.set(this, () => { + }), MX.set(this, () => { + }), IX.set(this, void 0), VJ.set(this, () => { + }), AX.set(this, () => { + }), $4.set(this, {}), bX.set(this, false), OJ.set(this, false), wJ.set(this, false), Q1.set(this, false), BJ.set(this, void 0), qJ.set(this, void 0), PX.set(this, void 0), DJ.set(this, (J) => { + if (v(this, OJ, true, "f"), s6(J)) J = new T$(); + if (J instanceof T$) return v(this, wJ, true, "f"), this._emit("abort", J); + if (J instanceof T) return this._emit("error", J); + if (J instanceof Error) { + let Q = new T(J.message); + return Q.cause = J, this._emit("error", Q); + } + return this._emit("error", new T(String(J))); + }), v(this, FX, new Promise((J, Q) => { + v(this, NJ, J, "f"), v(this, MX, Q, "f"); + }), "f"), v(this, IX, new Promise((J, Q) => { + v(this, VJ, J, "f"), v(this, AX, Q, "f"); + }), "f"), D(this, FX, "f").catch(() => { + }), D(this, IX, "f").catch(() => { + }), v(this, n1, $, "f"), v(this, PX, (_a3 = X == null ? void 0 : X.logger) != null ? _a3 : console, "f"); + } + get response() { + return D(this, BJ, "f"); + } + get request_id() { + return D(this, qJ, "f"); + } + async withResponse() { + v(this, Q1, true, "f"); + let $ = await D(this, FX, "f"); + if (!$) throw Error("Could not resolve a `Response` object"); + return { data: this, response: $, request_id: $.headers.get("request-id") }; + } + static fromReadableStream($) { + let X = new _ZX(null); + return X._run(() => X._fromReadableStream($)), X; + } + static createMessage($, X, J, { logger: Q } = {}) { + let Y = new _ZX(X, { logger: Q }); + for (let z6 of X.messages) Y._addMessageParam(z6); + return v(Y, n1, { ...X, stream: true }, "f"), Y._run(() => Y._createMessage($, { ...X, stream: true }, { ...J, headers: { ...J == null ? void 0 : J.headers, "X-Stainless-Helper-Method": "stream" } })), Y; + } + _run($) { + $().then(() => { + this._emitFinal(), this._emit("end"); + }, D(this, DJ, "f")); + } + _addMessageParam($) { + this.messages.push($); + } + _addMessage($, X = true) { + if (this.receivedMessages.push($), X) this._emit("message", $); + } + async _createMessage($, X, J) { + var _a3; + let Q = J == null ? void 0 : J.signal, Y; + if (Q) { + if (Q.aborted) this.controller.abort(); + Y = this.controller.abort.bind(this.controller), Q.addEventListener("abort", Y); + } + try { + D(this, q6, "m", jz).call(this); + let { response: z6, data: W } = await $.create({ ...X, stream: true }, { ...J, signal: this.controller.signal }).withResponse(); + this._connected(z6); + for await (let G of W) D(this, q6, "m", Fz).call(this, G); + if ((_a3 = W.controller.signal) == null ? void 0 : _a3.aborted) throw new T$(); + D(this, q6, "m", Mz).call(this); + } finally { + if (Q && Y) Q.removeEventListener("abort", Y); + } + } + _connected($) { + if (this.ended) return; + v(this, BJ, $, "f"), v(this, qJ, $ == null ? void 0 : $.headers.get("request-id"), "f"), D(this, NJ, "f").call(this, $), this._emit("connect"); + } + get ended() { + return D(this, bX, "f"); + } + get errored() { + return D(this, OJ, "f"); + } + get aborted() { + return D(this, wJ, "f"); + } + abort() { + this.controller.abort(); + } + on($, X) { + return (D(this, $4, "f")[$] || (D(this, $4, "f")[$] = [])).push({ listener: X }), this; + } + off($, X) { + let J = D(this, $4, "f")[$]; + if (!J) return this; + let Q = J.findIndex((Y) => Y.listener === X); + if (Q >= 0) J.splice(Q, 1); + return this; + } + once($, X) { + return (D(this, $4, "f")[$] || (D(this, $4, "f")[$] = [])).push({ listener: X, once: true }), this; + } + emitted($) { + return new Promise((X, J) => { + if (v(this, Q1, true, "f"), $ !== "error") this.once("error", J); + this.once($, X); + }); + } + async done() { + v(this, Q1, true, "f"), await D(this, IX, "f"); + } + get currentMessage() { + return D(this, b4, "f"); + } + async finalMessage() { + return await this.done(), D(this, q6, "m", Lz).call(this); + } + async finalText() { + return await this.done(), D(this, q6, "m", pH).call(this); + } + _emit($, ...X) { + if (D(this, bX, "f")) return; + if ($ === "end") v(this, bX, true, "f"), D(this, VJ, "f").call(this); + let J = D(this, $4, "f")[$]; + if (J) D(this, $4, "f")[$] = J.filter((Q) => !Q.once), J.forEach(({ listener: Q }) => Q(...X)); + if ($ === "abort") { + let Q = X[0]; + if (!D(this, Q1, "f") && !(J == null ? void 0 : J.length)) Promise.reject(Q); + D(this, MX, "f").call(this, Q), D(this, AX, "f").call(this, Q), this._emit("end"); + return; + } + if ($ === "error") { + let Q = X[0]; + if (!D(this, Q1, "f") && !(J == null ? void 0 : J.length)) Promise.reject(Q); + D(this, MX, "f").call(this, Q), D(this, AX, "f").call(this, Q), this._emit("end"); + } + } + _emitFinal() { + if (this.receivedMessages.at(-1)) this._emit("finalMessage", D(this, q6, "m", Lz).call(this)); + } + async _fromReadableStream($, X) { + var _a3; + let J = X == null ? void 0 : X.signal, Q; + if (J) { + if (J.aborted) this.controller.abort(); + Q = this.controller.abort.bind(this.controller), J.addEventListener("abort", Q); + } + try { + D(this, q6, "m", jz).call(this), this._connected(null); + let Y = K6.fromReadableStream($, this.controller); + for await (let z6 of Y) D(this, q6, "m", Fz).call(this, z6); + if ((_a3 = Y.controller.signal) == null ? void 0 : _a3.aborted) throw new T$(); + D(this, q6, "m", Mz).call(this); + } finally { + if (J && Q) J.removeEventListener("abort", Q); + } + } + [(b4 = /* @__PURE__ */ new WeakMap(), n1 = /* @__PURE__ */ new WeakMap(), FX = /* @__PURE__ */ new WeakMap(), NJ = /* @__PURE__ */ new WeakMap(), MX = /* @__PURE__ */ new WeakMap(), IX = /* @__PURE__ */ new WeakMap(), VJ = /* @__PURE__ */ new WeakMap(), AX = /* @__PURE__ */ new WeakMap(), $4 = /* @__PURE__ */ new WeakMap(), bX = /* @__PURE__ */ new WeakMap(), OJ = /* @__PURE__ */ new WeakMap(), wJ = /* @__PURE__ */ new WeakMap(), Q1 = /* @__PURE__ */ new WeakMap(), BJ = /* @__PURE__ */ new WeakMap(), qJ = /* @__PURE__ */ new WeakMap(), PX = /* @__PURE__ */ new WeakMap(), DJ = /* @__PURE__ */ new WeakMap(), q6 = /* @__PURE__ */ new WeakSet(), Lz = function() { + if (this.receivedMessages.length === 0) throw new T("stream ended without producing a Message with role=assistant"); + return this.receivedMessages.at(-1); + }, pH = function() { + if (this.receivedMessages.length === 0) throw new T("stream ended without producing a Message with role=assistant"); + let X = this.receivedMessages.at(-1).content.filter((J) => J.type === "text").map((J) => J.text); + if (X.length === 0) throw new T("stream ended without producing a content block with type=text"); + return X.join(" "); + }, jz = function() { + if (this.ended) return; + v(this, b4, void 0, "f"); + }, Fz = function(X) { + var _a3; + if (this.ended) return; + let J = D(this, q6, "m", iH).call(this, X); + switch (this._emit("streamEvent", X, J), X.type) { + case "content_block_delta": { + let Q = J.content.at(-1); + switch (X.delta.type) { + case "text_delta": { + if (Q.type === "text") this._emit("text", X.delta.text, Q.text || ""); + break; + } + case "citations_delta": { + if (Q.type === "text") this._emit("citation", X.delta.citation, (_a3 = Q.citations) != null ? _a3 : []); + break; + } + case "input_json_delta": { + if (dH(Q) && Q.input) this._emit("inputJson", X.delta.partial_json, Q.input); + break; + } + case "thinking_delta": { + if (Q.type === "thinking") this._emit("thinking", X.delta.thinking, Q.thinking); + break; + } + case "signature_delta": { + if (Q.type === "thinking") this._emit("signature", Q.signature); + break; + } + case "compaction_delta": { + if (Q.type === "compaction" && Q.content) this._emit("compaction", Q.content); + break; + } + default: + rH(X.delta); + } + break; + } + case "message_stop": { + this._addMessageParam(J), this._addMessage(qz(J, D(this, n1, "f"), { logger: D(this, PX, "f") }), true); + break; + } + case "content_block_stop": { + this._emit("contentBlock", J.content.at(-1)); + break; + } + case "message_start": { + v(this, b4, J, "f"); + break; + } + case "content_block_start": + case "message_delta": + break; + } + }, Mz = function() { + if (this.ended) throw new T("stream has ended, this shouldn't happen"); + let X = D(this, b4, "f"); + if (!X) throw new T("request ended without sending any chunks"); + return v(this, b4, void 0, "f"), qz(X, D(this, n1, "f"), { logger: D(this, PX, "f") }); + }, iH = function(X) { + var _a3; + let J = D(this, b4, "f"); + if (X.type === "message_start") { + if (J) throw new T(`Unexpected event order, got ${X.type} before receiving "message_stop"`); + return X.message; + } + if (!J) throw new T(`Unexpected event order, got ${X.type} before "message_start"`); + switch (X.type) { + case "message_stop": + return J; + case "message_delta": + if (J.container = X.delta.container, J.stop_reason = X.delta.stop_reason, J.stop_sequence = X.delta.stop_sequence, J.usage.output_tokens = X.usage.output_tokens, J.context_management = X.context_management, X.usage.input_tokens != null) J.usage.input_tokens = X.usage.input_tokens; + if (X.usage.cache_creation_input_tokens != null) J.usage.cache_creation_input_tokens = X.usage.cache_creation_input_tokens; + if (X.usage.cache_read_input_tokens != null) J.usage.cache_read_input_tokens = X.usage.cache_read_input_tokens; + if (X.usage.server_tool_use != null) J.usage.server_tool_use = X.usage.server_tool_use; + if (X.usage.iterations != null) J.usage.iterations = X.usage.iterations; + return J; + case "content_block_start": + return J.content.push(X.content_block), J; + case "content_block_delta": { + let Q = J.content.at(X.index); + switch (X.delta.type) { + case "text_delta": { + if ((Q == null ? void 0 : Q.type) === "text") J.content[X.index] = { ...Q, text: (Q.text || "") + X.delta.text }; + break; + } + case "citations_delta": { + if ((Q == null ? void 0 : Q.type) === "text") J.content[X.index] = { ...Q, citations: [...(_a3 = Q.citations) != null ? _a3 : [], X.delta.citation] }; + break; + } + case "input_json_delta": { + if (Q && dH(Q)) { + let Y = Q[nH] || ""; + Y += X.delta.partial_json; + let z6 = { ...Q }; + if (Object.defineProperty(z6, nH, { value: Y, enumerable: false, writable: true }), Y) try { + z6.input = KJ(Y); + } catch (W) { + let G = new T(`Unable to parse tool parameter JSON from model. Please retry your request or adjust your prompt. Error: ${W}. JSON: ${Y}`); + D(this, DJ, "f").call(this, G); + } + J.content[X.index] = z6; + } + break; + } + case "thinking_delta": { + if ((Q == null ? void 0 : Q.type) === "thinking") J.content[X.index] = { ...Q, thinking: Q.thinking + X.delta.thinking }; + break; + } + case "signature_delta": { + if ((Q == null ? void 0 : Q.type) === "thinking") J.content[X.index] = { ...Q, signature: X.delta.signature }; + break; + } + case "compaction_delta": { + if ((Q == null ? void 0 : Q.type) === "compaction") J.content[X.index] = { ...Q, content: (Q.content || "") + X.delta.content }; + break; + } + default: + rH(X.delta); + } + return J; + } + case "content_block_stop": + return J; + } + }, Symbol.asyncIterator)]() { + let $ = [], X = [], J = false; + return this.on("streamEvent", (Q) => { + let Y = X.shift(); + if (Y) Y.resolve(Q); + else $.push(Q); + }), this.on("end", () => { + J = true; + for (let Q of X) Q.resolve(void 0); + X.length = 0; + }), this.on("abort", (Q) => { + J = true; + for (let Y of X) Y.reject(Q); + X.length = 0; + }), this.on("error", (Q) => { + J = true; + for (let Y of X) Y.reject(Q); + X.length = 0; + }), { next: async () => { + if (!$.length) { + if (J) return { value: void 0, done: true }; + return new Promise((Y, z6) => X.push({ resolve: Y, reject: z6 })).then((Y) => Y ? { value: Y, done: false } : { value: void 0, done: true }); + } + return { value: $.shift(), done: false }; + }, return: async () => { + return this.abort(), { value: void 0, done: true }; + } }; + } + toReadableStream() { + return new K6(this[Symbol.asyncIterator].bind(this), this.controller).toReadableStream(); + } +}; +function rH($) { +} +var d1 = class extends Error { + constructor($) { + let X = typeof $ === "string" ? $ : $.map((J) => { + if (J.type === "text") return J.text; + return `[${J.type}]`; + }).join(" "); + super(X); + this.name = "ToolError", this.content = $; + } +}; +var oH = 1e5; +var tH = `You have been working on the task described above but have not yet completed it. Write a continuation summary that will allow you (or another instance of yourself) to resume work efficiently in a future context window where the conversation history will be replaced with this summary. Your summary should be structured, concise, and actionable. Include: +1. Task Overview +The user's core request and success criteria +Any clarifications or constraints they specified +2. Current State +What has been completed so far +Files created, modified, or analyzed (with paths if relevant) +Key outputs or artifacts produced +3. Important Discoveries +Technical constraints or requirements uncovered +Decisions made and their rationale +Errors encountered and how they were resolved +What approaches were tried that didn't work (and why) +4. Next Steps +Specific actions needed to complete the task +Any blockers or open questions to resolve +Priority order if multiple steps remain +5. Context to Preserve +User preferences or style requirements +Domain-specific details that aren't obvious +Any promises made to the user +Be concise but complete\u2014err on the side of including information that would prevent duplicate work or repeated mistakes. Write in a way that enables immediate resumption of the task. +Wrap your summary in tags.`; +var EX; +var r1; +var z1; +var C$; +var RX; +var N6; +var X4; +var P4; +var SX; +var aH; +var Iz; +function sH() { + let $, X; + return { promise: new Promise((Q, Y) => { + $ = Q, X = Y; + }), resolve: $, reject: X }; +} +var vX = class { + constructor($, X, J) { + EX.add(this), this.client = $, r1.set(this, false), z1.set(this, false), C$.set(this, void 0), RX.set(this, void 0), N6.set(this, void 0), X4.set(this, void 0), P4.set(this, void 0), SX.set(this, 0), v(this, C$, { params: { ...X, messages: structuredClone(X.messages) } }, "f"); + let Y = ["BetaToolRunner", ...Bz(X.tools, X.messages)].join(", "); + v(this, RX, { ...J, headers: n([{ "x-stainless-helper": Y }, J == null ? void 0 : J.headers]) }, "f"), v(this, P4, sH(), "f"); + } + async *[(r1 = /* @__PURE__ */ new WeakMap(), z1 = /* @__PURE__ */ new WeakMap(), C$ = /* @__PURE__ */ new WeakMap(), RX = /* @__PURE__ */ new WeakMap(), N6 = /* @__PURE__ */ new WeakMap(), X4 = /* @__PURE__ */ new WeakMap(), P4 = /* @__PURE__ */ new WeakMap(), SX = /* @__PURE__ */ new WeakMap(), EX = /* @__PURE__ */ new WeakSet(), aH = async function() { + var _a3, _b2, _c, _d, _e, _f; + let X = D(this, C$, "f").params.compactionControl; + if (!X || !X.enabled) return false; + let J = 0; + if (D(this, N6, "f") !== void 0) try { + let U = await D(this, N6, "f"); + J = U.usage.input_tokens + ((_a3 = U.usage.cache_creation_input_tokens) != null ? _a3 : 0) + ((_b2 = U.usage.cache_read_input_tokens) != null ? _b2 : 0) + U.usage.output_tokens; + } catch (e3) { + return false; + } + let Q = (_c = X.contextTokenThreshold) != null ? _c : oH; + if (J < Q) return false; + let Y = (_d = X.model) != null ? _d : D(this, C$, "f").params.model, z6 = (_e = X.summaryPrompt) != null ? _e : tH, W = D(this, C$, "f").params.messages; + if (W[W.length - 1].role === "assistant") { + let U = W[W.length - 1]; + if (Array.isArray(U.content)) { + let H = U.content.filter((K) => K.type !== "tool_use"); + if (H.length === 0) W.pop(); + else U.content = H; + } + } + let G = await this.client.beta.messages.create({ model: Y, messages: [...W, { role: "user", content: [{ type: "text", text: z6 }] }], max_tokens: D(this, C$, "f").params.max_tokens }, { headers: { "x-stainless-helper": "compaction" } }); + if (((_f = G.content[0]) == null ? void 0 : _f.type) !== "text") throw new T("Expected text response for compaction"); + return D(this, C$, "f").params.messages = [{ role: "user", content: G.content }], true; + }, Symbol.asyncIterator)]() { + var $; + if (D(this, r1, "f")) throw new T("Cannot iterate over a consumed stream"); + v(this, r1, true, "f"), v(this, z1, true, "f"), v(this, X4, void 0, "f"); + try { + while (true) { + let X; + try { + if (D(this, C$, "f").params.max_iterations && D(this, SX, "f") >= D(this, C$, "f").params.max_iterations) break; + v(this, z1, false, "f"), v(this, X4, void 0, "f"), v(this, SX, ($ = D(this, SX, "f"), $++, $), "f"), v(this, N6, void 0, "f"); + let { max_iterations: J, compactionControl: Q, ...Y } = D(this, C$, "f").params; + if (Y.stream) X = this.client.beta.messages.stream({ ...Y }, D(this, RX, "f")), v(this, N6, X.finalMessage(), "f"), D(this, N6, "f").catch(() => { + }), yield X; + else v(this, N6, this.client.beta.messages.create({ ...Y, stream: false }, D(this, RX, "f")), "f"), yield D(this, N6, "f"); + if (!await D(this, EX, "m", aH).call(this)) { + if (!D(this, z1, "f")) { + let { role: G, content: U } = await D(this, N6, "f"); + D(this, C$, "f").params.messages.push({ role: G, content: U }); + } + let W = await D(this, EX, "m", Iz).call(this, D(this, C$, "f").params.messages.at(-1)); + if (W) D(this, C$, "f").params.messages.push(W); + else if (!D(this, z1, "f")) break; + } + } finally { + if (X) X.abort(); + } + } + if (!D(this, N6, "f")) throw new T("ToolRunner concluded without a message from the server"); + D(this, P4, "f").resolve(await D(this, N6, "f")); + } catch (X) { + throw v(this, r1, false, "f"), D(this, P4, "f").promise.catch(() => { + }), D(this, P4, "f").reject(X), v(this, P4, sH(), "f"), X; + } + } + setMessagesParams($) { + if (typeof $ === "function") D(this, C$, "f").params = $(D(this, C$, "f").params); + else D(this, C$, "f").params = $; + v(this, z1, true, "f"), v(this, X4, void 0, "f"); + } + async generateToolResponse() { + var _a3; + let $ = (_a3 = await D(this, N6, "f")) != null ? _a3 : this.params.messages.at(-1); + if (!$) return null; + return D(this, EX, "m", Iz).call(this, $); + } + done() { + return D(this, P4, "f").promise; + } + async runUntilDone() { + if (!D(this, r1, "f")) for await (let $ of this) ; + return this.done(); + } + get params() { + return D(this, C$, "f").params; + } + pushMessages(...$) { + this.setMessagesParams((X) => ({ ...X, messages: [...X.messages, ...$] })); + } + then($, X) { + return this.runUntilDone().then($, X); + } +}; +Iz = async function(X) { + if (D(this, X4, "f") !== void 0) return D(this, X4, "f"); + return v(this, X4, AF(D(this, C$, "f").params, X), "f"), D(this, X4, "f"); +}; +async function AF($, X = $.messages.at(-1)) { + if (!X || X.role !== "assistant" || !X.content || typeof X.content === "string") return null; + let J = X.content.filter((Y) => Y.type === "tool_use"); + if (J.length === 0) return null; + return { role: "user", content: await Promise.all(J.map(async (Y) => { + let z6 = $.tools.find((W) => ("name" in W ? W.name : W.mcp_server_name) === Y.name); + if (!z6 || !("run" in z6)) return { type: "tool_result", tool_use_id: Y.id, content: `Error: Tool '${Y.name}' not found`, is_error: true }; + try { + let W = Y.input; + if ("parse" in z6 && z6.parse) W = z6.parse(W); + let G = await z6.run(W); + return { type: "tool_result", tool_use_id: Y.id, content: G }; + } catch (W) { + return { type: "tool_result", tool_use_id: Y.id, content: W instanceof d1 ? W.content : `Error: ${W instanceof Error ? W.message : String(W)}`, is_error: true }; + } + })) }; +} +var o1 = class _o1 { + constructor($, X) { + this.iterator = $, this.controller = X; + } + async *decoder() { + let $ = new A4(); + for await (let X of this.iterator) for (let J of $.decode(X)) yield JSON.parse(J); + for (let X of $.flush()) yield JSON.parse(X); + } + [Symbol.asyncIterator]() { + return this.decoder(); + } + static fromResponse($, X) { + if (!$.body) { + if (X.abort(), typeof globalThis.navigator < "u" && globalThis.navigator.product === "ReactNative") throw new T("The default react-native fetch implementation does not support streaming. Please use expo/fetch: https://docs.expo.dev/versions/latest/sdk/expo/#expofetch-api"); + throw new T("Attempted to iterate over a response with no body"); + } + return new _o1(KX($.body), X); + } +}; +var CX = class extends A$ { + create($, X) { + let { betas: J, ...Q } = $; + return this._client.post("/v1/messages/batches?beta=true", { body: Q, ...X, headers: n([{ "anthropic-beta": [...J != null ? J : [], "message-batches-2024-09-24"].toString() }, X == null ? void 0 : X.headers]) }); + } + retrieve($, X = {}, J) { + let { betas: Q } = X != null ? X : {}; + return this._client.get(F$`/v1/messages/batches/${$}?beta=true`, { ...J, headers: n([{ "anthropic-beta": [...Q != null ? Q : [], "message-batches-2024-09-24"].toString() }, J == null ? void 0 : J.headers]) }); + } + list($ = {}, X) { + let { betas: J, ...Q } = $ != null ? $ : {}; + return this._client.getAPIList("/v1/messages/batches?beta=true", S6, { query: Q, ...X, headers: n([{ "anthropic-beta": [...J != null ? J : [], "message-batches-2024-09-24"].toString() }, X == null ? void 0 : X.headers]) }); + } + delete($, X = {}, J) { + let { betas: Q } = X != null ? X : {}; + return this._client.delete(F$`/v1/messages/batches/${$}?beta=true`, { ...J, headers: n([{ "anthropic-beta": [...Q != null ? Q : [], "message-batches-2024-09-24"].toString() }, J == null ? void 0 : J.headers]) }); + } + cancel($, X = {}, J) { + let { betas: Q } = X != null ? X : {}; + return this._client.post(F$`/v1/messages/batches/${$}/cancel?beta=true`, { ...J, headers: n([{ "anthropic-beta": [...Q != null ? Q : [], "message-batches-2024-09-24"].toString() }, J == null ? void 0 : J.headers]) }); + } + async results($, X = {}, J) { + let Q = await this.retrieve($); + if (!Q.results_url) throw new T(`No batch \`results_url\`; Has it finished processing? ${Q.processing_status} - ${Q.id}`); + let { betas: Y } = X != null ? X : {}; + return this._client.get(Q.results_url, { ...J, headers: n([{ "anthropic-beta": [...Y != null ? Y : [], "message-batches-2024-09-24"].toString(), Accept: "application/binary" }, J == null ? void 0 : J.headers]), stream: true, __binaryResponse: true })._thenUnwrap((z6, W) => o1.fromResponse(W.response, W.controller)); + } +}; +var eH = { "claude-1.3": "November 6th, 2024", "claude-1.3-100k": "November 6th, 2024", "claude-instant-1.1": "November 6th, 2024", "claude-instant-1.1-100k": "November 6th, 2024", "claude-instant-1.2": "November 6th, 2024", "claude-3-sonnet-20240229": "July 21st, 2025", "claude-3-opus-20240229": "January 5th, 2026", "claude-2.1": "July 21st, 2025", "claude-2.0": "July 21st, 2025", "claude-3-7-sonnet-latest": "February 19th, 2026", "claude-3-7-sonnet-20250219": "February 19th, 2026" }; +var PF = ["claude-opus-4-6"]; +var Z4 = class extends A$ { + constructor() { + super(...arguments); + this.batches = new CX(this._client); + } + create($, X) { + var _a3, _b2; + let J = $K($), { betas: Q, ...Y } = J; + if (Y.model in eH) console.warn(`The model '${Y.model}' is deprecated and will reach end-of-life on ${eH[Y.model]} +Please migrate to a newer model. Visit https://docs.anthropic.com/en/docs/resources/model-deprecations for more information.`); + if (Y.model in PF && Y.thinking && Y.thinking.type === "enabled") console.warn(`Using Claude with ${Y.model} and 'thinking.type=enabled' is deprecated. Use 'thinking.type=adaptive' instead which results in better model performance in our testing: https://platform.claude.com/docs/en/build-with-claude/adaptive-thinking`); + let z6 = this._client._options.timeout; + if (!Y.stream && z6 == null) { + let G = (_a3 = HJ[Y.model]) != null ? _a3 : void 0; + z6 = this._client.calculateNonstreamingTimeout(Y.max_tokens, G); + } + let W = UJ(Y.tools, Y.messages); + return this._client.post("/v1/messages?beta=true", { body: Y, timeout: z6 != null ? z6 : 6e5, ...X, headers: n([{ ...(Q == null ? void 0 : Q.toString()) != null ? { "anthropic-beta": Q == null ? void 0 : Q.toString() } : void 0 }, W, X == null ? void 0 : X.headers]), stream: (_b2 = J.stream) != null ? _b2 : false }); + } + parse($, X) { + var _a3; + return X = { ...X, headers: n([{ "anthropic-beta": [...(_a3 = $.betas) != null ? _a3 : [], "structured-outputs-2025-12-15"].toString() }, X == null ? void 0 : X.headers]) }, this.create($, X).then((J) => { + var _a4; + return Dz(J, $, { logger: (_a4 = this._client.logger) != null ? _a4 : console }); + }); + } + stream($, X) { + return ZX.createMessage(this, $, X); + } + countTokens($, X) { + let J = $K($), { betas: Q, ...Y } = J; + return this._client.post("/v1/messages/count_tokens?beta=true", { body: Y, ...X, headers: n([{ "anthropic-beta": [...Q != null ? Q : [], "token-counting-2024-11-01"].toString() }, X == null ? void 0 : X.headers]) }); + } + toolRunner($, X) { + return new vX(this._client, $, X); + } +}; +function $K($) { + var _a3; + if (!$.output_format) return $; + if ((_a3 = $.output_config) == null ? void 0 : _a3.format) throw new T("Both output_format and output_config.format were provided. Please use only output_config.format (output_format is deprecated)."); + let { output_format: X, ...J } = $; + return { ...J, output_config: { ...$.output_config, format: X } }; +} +Z4.Batches = CX; +Z4.BetaToolRunner = vX; +Z4.ToolError = d1; +var kX = class extends A$ { + create($, X = {}, J) { + let { betas: Q, ...Y } = X != null ? X : {}; + return this._client.post(F$`/v1/skills/${$}/versions?beta=true`, p1({ body: Y, ...J, headers: n([{ "anthropic-beta": [...Q != null ? Q : [], "skills-2025-10-02"].toString() }, J == null ? void 0 : J.headers]) }, this._client)); + } + retrieve($, X, J) { + let { skill_id: Q, betas: Y } = X; + return this._client.get(F$`/v1/skills/${Q}/versions/${$}?beta=true`, { ...J, headers: n([{ "anthropic-beta": [...Y != null ? Y : [], "skills-2025-10-02"].toString() }, J == null ? void 0 : J.headers]) }); + } + list($, X = {}, J) { + let { betas: Q, ...Y } = X != null ? X : {}; + return this._client.getAPIList(F$`/v1/skills/${$}/versions?beta=true`, BX, { query: Y, ...J, headers: n([{ "anthropic-beta": [...Q != null ? Q : [], "skills-2025-10-02"].toString() }, J == null ? void 0 : J.headers]) }); + } + delete($, X, J) { + let { skill_id: Q, betas: Y } = X; + return this._client.delete(F$`/v1/skills/${Q}/versions/${$}?beta=true`, { ...J, headers: n([{ "anthropic-beta": [...Y != null ? Y : [], "skills-2025-10-02"].toString() }, J == null ? void 0 : J.headers]) }); + } +}; +var t1 = class extends A$ { + constructor() { + super(...arguments); + this.versions = new kX(this._client); + } + create($ = {}, X) { + let { betas: J, ...Q } = $ != null ? $ : {}; + return this._client.post("/v1/skills?beta=true", p1({ body: Q, ...X, headers: n([{ "anthropic-beta": [...J != null ? J : [], "skills-2025-10-02"].toString() }, X == null ? void 0 : X.headers]) }, this._client, false)); + } + retrieve($, X = {}, J) { + let { betas: Q } = X != null ? X : {}; + return this._client.get(F$`/v1/skills/${$}?beta=true`, { ...J, headers: n([{ "anthropic-beta": [...Q != null ? Q : [], "skills-2025-10-02"].toString() }, J == null ? void 0 : J.headers]) }); + } + list($ = {}, X) { + let { betas: J, ...Q } = $ != null ? $ : {}; + return this._client.getAPIList("/v1/skills?beta=true", BX, { query: Q, ...X, headers: n([{ "anthropic-beta": [...J != null ? J : [], "skills-2025-10-02"].toString() }, X == null ? void 0 : X.headers]) }); + } + delete($, X = {}, J) { + let { betas: Q } = X != null ? X : {}; + return this._client.delete(F$`/v1/skills/${$}?beta=true`, { ...J, headers: n([{ "anthropic-beta": [...Q != null ? Q : [], "skills-2025-10-02"].toString() }, J == null ? void 0 : J.headers]) }); + } +}; +t1.Versions = kX; +var m6 = class extends A$ { + constructor() { + super(...arguments); + this.models = new jX(this._client), this.messages = new Z4(this._client), this.files = new LX(this._client), this.skills = new t1(this._client); + } +}; +m6.Models = jX; +m6.Messages = Z4; +m6.Files = LX; +m6.Skills = t1; +var a1 = class extends A$ { + create($, X) { + var _a3, _b2; + let { betas: J, ...Q } = $; + return this._client.post("/v1/complete", { body: Q, timeout: (_a3 = this._client._options.timeout) != null ? _a3 : 6e5, ...X, headers: n([{ ...(J == null ? void 0 : J.toString()) != null ? { "anthropic-beta": J == null ? void 0 : J.toString() } : void 0 }, X == null ? void 0 : X.headers]), stream: (_b2 = $.stream) != null ? _b2 : false }); + } +}; +function XK($) { + var _a3; + return (_a3 = $ == null ? void 0 : $.output_config) == null ? void 0 : _a3.format; +} +function Az($, X, J) { + let Q = XK(X); + if (!X || !("parse" in (Q != null ? Q : {}))) return { ...$, content: $.content.map((Y) => { + if (Y.type === "text") return Object.defineProperty({ ...Y }, "parsed_output", { value: null, enumerable: false }); + return Y; + }), parsed_output: null }; + return bz($, X, J); +} +function bz($, X, J) { + let Q = null, Y = $.content.map((z6) => { + if (z6.type === "text") { + let W = SF(X, z6.text); + if (Q === null) Q = W; + return Object.defineProperty({ ...z6 }, "parsed_output", { value: W, enumerable: false }); + } + return z6; + }); + return { ...$, content: Y, parsed_output: Q }; +} +function SF($, X) { + let J = XK($); + if ((J == null ? void 0 : J.type) !== "json_schema") return null; + try { + if ("parse" in J) return J.parse(X); + return JSON.parse(X); + } catch (Q) { + throw new T(`Failed to parse structured output: ${Q}`); + } +} +var D6; +var E4; +var s1; +var _X; +var LJ; +var xX; +var TX; +var jJ; +var yX; +var J4; +var fX; +var FJ; +var MJ; +var W1; +var IJ; +var AJ; +var gX; +var Pz; +var JK; +var Zz; +var Ez; +var Rz; +var Sz; +var YK; +var QK = "__json_buf"; +function zK($) { + return $.type === "tool_use" || $.type === "server_tool_use"; +} +var hX = class _hX { + constructor($, X) { + var _a3; + D6.add(this), this.messages = [], this.receivedMessages = [], E4.set(this, void 0), s1.set(this, null), this.controller = new AbortController(), _X.set(this, void 0), LJ.set(this, () => { + }), xX.set(this, () => { + }), TX.set(this, void 0), jJ.set(this, () => { + }), yX.set(this, () => { + }), J4.set(this, {}), fX.set(this, false), FJ.set(this, false), MJ.set(this, false), W1.set(this, false), IJ.set(this, void 0), AJ.set(this, void 0), gX.set(this, void 0), Zz.set(this, (J) => { + if (v(this, FJ, true, "f"), s6(J)) J = new T$(); + if (J instanceof T$) return v(this, MJ, true, "f"), this._emit("abort", J); + if (J instanceof T) return this._emit("error", J); + if (J instanceof Error) { + let Q = new T(J.message); + return Q.cause = J, this._emit("error", Q); + } + return this._emit("error", new T(String(J))); + }), v(this, _X, new Promise((J, Q) => { + v(this, LJ, J, "f"), v(this, xX, Q, "f"); + }), "f"), v(this, TX, new Promise((J, Q) => { + v(this, jJ, J, "f"), v(this, yX, Q, "f"); + }), "f"), D(this, _X, "f").catch(() => { + }), D(this, TX, "f").catch(() => { + }), v(this, s1, $, "f"), v(this, gX, (_a3 = X == null ? void 0 : X.logger) != null ? _a3 : console, "f"); + } + get response() { + return D(this, IJ, "f"); + } + get request_id() { + return D(this, AJ, "f"); + } + async withResponse() { + v(this, W1, true, "f"); + let $ = await D(this, _X, "f"); + if (!$) throw Error("Could not resolve a `Response` object"); + return { data: this, response: $, request_id: $.headers.get("request-id") }; + } + static fromReadableStream($) { + let X = new _hX(null); + return X._run(() => X._fromReadableStream($)), X; + } + static createMessage($, X, J, { logger: Q } = {}) { + let Y = new _hX(X, { logger: Q }); + for (let z6 of X.messages) Y._addMessageParam(z6); + return v(Y, s1, { ...X, stream: true }, "f"), Y._run(() => Y._createMessage($, { ...X, stream: true }, { ...J, headers: { ...J == null ? void 0 : J.headers, "X-Stainless-Helper-Method": "stream" } })), Y; + } + _run($) { + $().then(() => { + this._emitFinal(), this._emit("end"); + }, D(this, Zz, "f")); + } + _addMessageParam($) { + this.messages.push($); + } + _addMessage($, X = true) { + if (this.receivedMessages.push($), X) this._emit("message", $); + } + async _createMessage($, X, J) { + var _a3; + let Q = J == null ? void 0 : J.signal, Y; + if (Q) { + if (Q.aborted) this.controller.abort(); + Y = this.controller.abort.bind(this.controller), Q.addEventListener("abort", Y); + } + try { + D(this, D6, "m", Ez).call(this); + let { response: z6, data: W } = await $.create({ ...X, stream: true }, { ...J, signal: this.controller.signal }).withResponse(); + this._connected(z6); + for await (let G of W) D(this, D6, "m", Rz).call(this, G); + if ((_a3 = W.controller.signal) == null ? void 0 : _a3.aborted) throw new T$(); + D(this, D6, "m", Sz).call(this); + } finally { + if (Q && Y) Q.removeEventListener("abort", Y); + } + } + _connected($) { + if (this.ended) return; + v(this, IJ, $, "f"), v(this, AJ, $ == null ? void 0 : $.headers.get("request-id"), "f"), D(this, LJ, "f").call(this, $), this._emit("connect"); + } + get ended() { + return D(this, fX, "f"); + } + get errored() { + return D(this, FJ, "f"); + } + get aborted() { + return D(this, MJ, "f"); + } + abort() { + this.controller.abort(); + } + on($, X) { + return (D(this, J4, "f")[$] || (D(this, J4, "f")[$] = [])).push({ listener: X }), this; + } + off($, X) { + let J = D(this, J4, "f")[$]; + if (!J) return this; + let Q = J.findIndex((Y) => Y.listener === X); + if (Q >= 0) J.splice(Q, 1); + return this; + } + once($, X) { + return (D(this, J4, "f")[$] || (D(this, J4, "f")[$] = [])).push({ listener: X, once: true }), this; + } + emitted($) { + return new Promise((X, J) => { + if (v(this, W1, true, "f"), $ !== "error") this.once("error", J); + this.once($, X); + }); + } + async done() { + v(this, W1, true, "f"), await D(this, TX, "f"); + } + get currentMessage() { + return D(this, E4, "f"); + } + async finalMessage() { + return await this.done(), D(this, D6, "m", Pz).call(this); + } + async finalText() { + return await this.done(), D(this, D6, "m", JK).call(this); + } + _emit($, ...X) { + if (D(this, fX, "f")) return; + if ($ === "end") v(this, fX, true, "f"), D(this, jJ, "f").call(this); + let J = D(this, J4, "f")[$]; + if (J) D(this, J4, "f")[$] = J.filter((Q) => !Q.once), J.forEach(({ listener: Q }) => Q(...X)); + if ($ === "abort") { + let Q = X[0]; + if (!D(this, W1, "f") && !(J == null ? void 0 : J.length)) Promise.reject(Q); + D(this, xX, "f").call(this, Q), D(this, yX, "f").call(this, Q), this._emit("end"); + return; + } + if ($ === "error") { + let Q = X[0]; + if (!D(this, W1, "f") && !(J == null ? void 0 : J.length)) Promise.reject(Q); + D(this, xX, "f").call(this, Q), D(this, yX, "f").call(this, Q), this._emit("end"); + } + } + _emitFinal() { + if (this.receivedMessages.at(-1)) this._emit("finalMessage", D(this, D6, "m", Pz).call(this)); + } + async _fromReadableStream($, X) { + var _a3; + let J = X == null ? void 0 : X.signal, Q; + if (J) { + if (J.aborted) this.controller.abort(); + Q = this.controller.abort.bind(this.controller), J.addEventListener("abort", Q); + } + try { + D(this, D6, "m", Ez).call(this), this._connected(null); + let Y = K6.fromReadableStream($, this.controller); + for await (let z6 of Y) D(this, D6, "m", Rz).call(this, z6); + if ((_a3 = Y.controller.signal) == null ? void 0 : _a3.aborted) throw new T$(); + D(this, D6, "m", Sz).call(this); + } finally { + if (J && Q) J.removeEventListener("abort", Q); + } + } + [(E4 = /* @__PURE__ */ new WeakMap(), s1 = /* @__PURE__ */ new WeakMap(), _X = /* @__PURE__ */ new WeakMap(), LJ = /* @__PURE__ */ new WeakMap(), xX = /* @__PURE__ */ new WeakMap(), TX = /* @__PURE__ */ new WeakMap(), jJ = /* @__PURE__ */ new WeakMap(), yX = /* @__PURE__ */ new WeakMap(), J4 = /* @__PURE__ */ new WeakMap(), fX = /* @__PURE__ */ new WeakMap(), FJ = /* @__PURE__ */ new WeakMap(), MJ = /* @__PURE__ */ new WeakMap(), W1 = /* @__PURE__ */ new WeakMap(), IJ = /* @__PURE__ */ new WeakMap(), AJ = /* @__PURE__ */ new WeakMap(), gX = /* @__PURE__ */ new WeakMap(), Zz = /* @__PURE__ */ new WeakMap(), D6 = /* @__PURE__ */ new WeakSet(), Pz = function() { + if (this.receivedMessages.length === 0) throw new T("stream ended without producing a Message with role=assistant"); + return this.receivedMessages.at(-1); + }, JK = function() { + if (this.receivedMessages.length === 0) throw new T("stream ended without producing a Message with role=assistant"); + let X = this.receivedMessages.at(-1).content.filter((J) => J.type === "text").map((J) => J.text); + if (X.length === 0) throw new T("stream ended without producing a content block with type=text"); + return X.join(" "); + }, Ez = function() { + if (this.ended) return; + v(this, E4, void 0, "f"); + }, Rz = function(X) { + var _a3; + if (this.ended) return; + let J = D(this, D6, "m", YK).call(this, X); + switch (this._emit("streamEvent", X, J), X.type) { + case "content_block_delta": { + let Q = J.content.at(-1); + switch (X.delta.type) { + case "text_delta": { + if (Q.type === "text") this._emit("text", X.delta.text, Q.text || ""); + break; + } + case "citations_delta": { + if (Q.type === "text") this._emit("citation", X.delta.citation, (_a3 = Q.citations) != null ? _a3 : []); + break; + } + case "input_json_delta": { + if (zK(Q) && Q.input) this._emit("inputJson", X.delta.partial_json, Q.input); + break; + } + case "thinking_delta": { + if (Q.type === "thinking") this._emit("thinking", X.delta.thinking, Q.thinking); + break; + } + case "signature_delta": { + if (Q.type === "thinking") this._emit("signature", Q.signature); + break; + } + default: + WK(X.delta); + } + break; + } + case "message_stop": { + this._addMessageParam(J), this._addMessage(Az(J, D(this, s1, "f"), { logger: D(this, gX, "f") }), true); + break; + } + case "content_block_stop": { + this._emit("contentBlock", J.content.at(-1)); + break; + } + case "message_start": { + v(this, E4, J, "f"); + break; + } + case "content_block_start": + case "message_delta": + break; + } + }, Sz = function() { + if (this.ended) throw new T("stream has ended, this shouldn't happen"); + let X = D(this, E4, "f"); + if (!X) throw new T("request ended without sending any chunks"); + return v(this, E4, void 0, "f"), Az(X, D(this, s1, "f"), { logger: D(this, gX, "f") }); + }, YK = function(X) { + var _a3; + let J = D(this, E4, "f"); + if (X.type === "message_start") { + if (J) throw new T(`Unexpected event order, got ${X.type} before receiving "message_stop"`); + return X.message; + } + if (!J) throw new T(`Unexpected event order, got ${X.type} before "message_start"`); + switch (X.type) { + case "message_stop": + return J; + case "message_delta": + if (J.stop_reason = X.delta.stop_reason, J.stop_sequence = X.delta.stop_sequence, J.usage.output_tokens = X.usage.output_tokens, X.usage.input_tokens != null) J.usage.input_tokens = X.usage.input_tokens; + if (X.usage.cache_creation_input_tokens != null) J.usage.cache_creation_input_tokens = X.usage.cache_creation_input_tokens; + if (X.usage.cache_read_input_tokens != null) J.usage.cache_read_input_tokens = X.usage.cache_read_input_tokens; + if (X.usage.server_tool_use != null) J.usage.server_tool_use = X.usage.server_tool_use; + return J; + case "content_block_start": + return J.content.push({ ...X.content_block }), J; + case "content_block_delta": { + let Q = J.content.at(X.index); + switch (X.delta.type) { + case "text_delta": { + if ((Q == null ? void 0 : Q.type) === "text") J.content[X.index] = { ...Q, text: (Q.text || "") + X.delta.text }; + break; + } + case "citations_delta": { + if ((Q == null ? void 0 : Q.type) === "text") J.content[X.index] = { ...Q, citations: [...(_a3 = Q.citations) != null ? _a3 : [], X.delta.citation] }; + break; + } + case "input_json_delta": { + if (Q && zK(Q)) { + let Y = Q[QK] || ""; + Y += X.delta.partial_json; + let z6 = { ...Q }; + if (Object.defineProperty(z6, QK, { value: Y, enumerable: false, writable: true }), Y) z6.input = KJ(Y); + J.content[X.index] = z6; + } + break; + } + case "thinking_delta": { + if ((Q == null ? void 0 : Q.type) === "thinking") J.content[X.index] = { ...Q, thinking: Q.thinking + X.delta.thinking }; + break; + } + case "signature_delta": { + if ((Q == null ? void 0 : Q.type) === "thinking") J.content[X.index] = { ...Q, signature: X.delta.signature }; + break; + } + default: + WK(X.delta); + } + return J; + } + case "content_block_stop": + return J; + } + }, Symbol.asyncIterator)]() { + let $ = [], X = [], J = false; + return this.on("streamEvent", (Q) => { + let Y = X.shift(); + if (Y) Y.resolve(Q); + else $.push(Q); + }), this.on("end", () => { + J = true; + for (let Q of X) Q.resolve(void 0); + X.length = 0; + }), this.on("abort", (Q) => { + J = true; + for (let Y of X) Y.reject(Q); + X.length = 0; + }), this.on("error", (Q) => { + J = true; + for (let Y of X) Y.reject(Q); + X.length = 0; + }), { next: async () => { + if (!$.length) { + if (J) return { value: void 0, done: true }; + return new Promise((Y, z6) => X.push({ resolve: Y, reject: z6 })).then((Y) => Y ? { value: Y, done: false } : { value: void 0, done: true }); + } + return { value: $.shift(), done: false }; + }, return: async () => { + return this.abort(), { value: void 0, done: true }; + } }; + } + toReadableStream() { + return new K6(this[Symbol.asyncIterator].bind(this), this.controller).toReadableStream(); + } +}; +function WK($) { +} +var uX = class extends A$ { + create($, X) { + return this._client.post("/v1/messages/batches", { body: $, ...X }); + } + retrieve($, X) { + return this._client.get(F$`/v1/messages/batches/${$}`, X); + } + list($ = {}, X) { + return this._client.getAPIList("/v1/messages/batches", S6, { query: $, ...X }); + } + delete($, X) { + return this._client.delete(F$`/v1/messages/batches/${$}`, X); + } + cancel($, X) { + return this._client.post(F$`/v1/messages/batches/${$}/cancel`, X); + } + async results($, X) { + let J = await this.retrieve($); + if (!J.results_url) throw new T(`No batch \`results_url\`; Has it finished processing? ${J.processing_status} - ${J.id}`); + return this._client.get(J.results_url, { ...X, headers: n([{ Accept: "application/binary" }, X == null ? void 0 : X.headers]), stream: true, __binaryResponse: true })._thenUnwrap((Q, Y) => o1.fromResponse(Y.response, Y.controller)); + } +}; +var G1 = class extends A$ { + constructor() { + super(...arguments); + this.batches = new uX(this._client); + } + create($, X) { + var _a3, _b2; + if ($.model in GK) console.warn(`The model '${$.model}' is deprecated and will reach end-of-life on ${GK[$.model]} +Please migrate to a newer model. Visit https://docs.anthropic.com/en/docs/resources/model-deprecations for more information.`); + if ($.model in CF && $.thinking && $.thinking.type === "enabled") console.warn(`Using Claude with ${$.model} and 'thinking.type=enabled' is deprecated. Use 'thinking.type=adaptive' instead which results in better model performance in our testing: https://platform.claude.com/docs/en/build-with-claude/adaptive-thinking`); + let J = this._client._options.timeout; + if (!$.stream && J == null) { + let Y = (_a3 = HJ[$.model]) != null ? _a3 : void 0; + J = this._client.calculateNonstreamingTimeout($.max_tokens, Y); + } + let Q = UJ($.tools, $.messages); + return this._client.post("/v1/messages", { body: $, timeout: J != null ? J : 6e5, ...X, headers: n([Q, X == null ? void 0 : X.headers]), stream: (_b2 = $.stream) != null ? _b2 : false }); + } + parse($, X) { + return this.create($, X).then((J) => { + var _a3; + return bz(J, $, { logger: (_a3 = this._client.logger) != null ? _a3 : console }); + }); + } + stream($, X) { + var _a3; + return hX.createMessage(this, $, X, { logger: (_a3 = this._client.logger) != null ? _a3 : console }); + } + countTokens($, X) { + return this._client.post("/v1/messages/count_tokens", { body: $, ...X }); + } +}; +var GK = { "claude-1.3": "November 6th, 2024", "claude-1.3-100k": "November 6th, 2024", "claude-instant-1.1": "November 6th, 2024", "claude-instant-1.1-100k": "November 6th, 2024", "claude-instant-1.2": "November 6th, 2024", "claude-3-sonnet-20240229": "July 21st, 2025", "claude-3-opus-20240229": "January 5th, 2026", "claude-2.1": "July 21st, 2025", "claude-2.0": "July 21st, 2025", "claude-3-7-sonnet-latest": "February 19th, 2026", "claude-3-7-sonnet-20250219": "February 19th, 2026", "claude-3-5-haiku-latest": "February 19th, 2026", "claude-3-5-haiku-20241022": "February 19th, 2026" }; +var CF = ["claude-opus-4-6"]; +G1.Batches = uX; +var e1 = class extends A$ { + retrieve($, X = {}, J) { + let { betas: Q } = X != null ? X : {}; + return this._client.get(F$`/v1/models/${$}`, { ...J, headers: n([{ ...(Q == null ? void 0 : Q.toString()) != null ? { "anthropic-beta": Q == null ? void 0 : Q.toString() } : void 0 }, J == null ? void 0 : J.headers]) }); + } + list($ = {}, X) { + let { betas: J, ...Q } = $ != null ? $ : {}; + return this._client.getAPIList("/v1/models", S6, { query: Q, ...X, headers: n([{ ...(J == null ? void 0 : J.toString()) != null ? { "anthropic-beta": J == null ? void 0 : J.toString() } : void 0 }, X == null ? void 0 : X.headers]) }); + } +}; +var mX = ($) => { + var _a3, _b2, _c, _d, _e, _f; + if (typeof globalThis.process < "u") return (_c = (_b2 = (_a3 = globalThis.process.env) == null ? void 0 : _a3[$]) == null ? void 0 : _b2.trim()) != null ? _c : void 0; + if (typeof globalThis.Deno < "u") return (_f = (_e = (_d = globalThis.Deno.env) == null ? void 0 : _d.get) == null ? void 0 : _e.call(_d, $)) == null ? void 0 : _f.trim(); + return; +}; +var vz; +var Cz; +var bJ; +var UK; +var HK = "\\n\\nHuman:"; +var KK = "\\n\\nAssistant:"; +var P$ = class { + constructor({ baseURL: $ = mX("ANTHROPIC_BASE_URL"), apiKey: X = ((_a3) => (_a3 = mX("ANTHROPIC_API_KEY")) != null ? _a3 : null)(), authToken: J = ((_b2) => (_b2 = mX("ANTHROPIC_AUTH_TOKEN")) != null ? _b2 : null)(), ...Q } = {}) { + var _a4, _b3, _c, _d, _e, _f; + vz.add(this), bJ.set(this, void 0); + let Y = { apiKey: X, authToken: J, ...Q, baseURL: $ || "https://api.anthropic.com" }; + if (!Y.dangerouslyAllowBrowser && PH()) throw new T(`It looks like you're running in a browser-like environment. + +This is disabled by default, as it risks exposing your secret API credentials to attackers. +If you understand the risks and have appropriate mitigations in place, +you can set the \`dangerouslyAllowBrowser\` option to \`true\`, e.g., + +new Anthropic({ apiKey, dangerouslyAllowBrowser: true }); +`); + this.baseURL = Y.baseURL, this.timeout = (_a4 = Y.timeout) != null ? _a4 : Cz.DEFAULT_TIMEOUT, this.logger = (_b3 = Y.logger) != null ? _b3 : console; + let z6 = "warn"; + this.logLevel = z6, this.logLevel = (_d = (_c = Uz(Y.logLevel, "ClientOptions.logLevel", this)) != null ? _c : Uz(mX("ANTHROPIC_LOG"), "process.env['ANTHROPIC_LOG']", this)) != null ? _d : z6, this.fetchOptions = Y.fetchOptions, this.maxRetries = (_e = Y.maxRetries) != null ? _e : 2, this.fetch = (_f = Y.fetch) != null ? _f : EH(), v(this, bJ, SH, "f"), this._options = Y, this.apiKey = typeof X === "string" ? X : null, this.authToken = J; + } + withOptions($) { + return new this.constructor({ ...this._options, baseURL: this.baseURL, maxRetries: this.maxRetries, timeout: this.timeout, logger: this.logger, logLevel: this.logLevel, fetch: this.fetch, fetchOptions: this.fetchOptions, apiKey: this.apiKey, authToken: this.authToken, ...$ }); + } + defaultQuery() { + return this._options.defaultQuery; + } + validateHeaders({ values: $, nulls: X }) { + if ($.get("x-api-key") || $.get("authorization")) return; + if (this.apiKey && $.get("x-api-key")) return; + if (X.has("x-api-key")) return; + if (this.authToken && $.get("authorization")) return; + if (X.has("authorization")) return; + throw Error('Could not resolve authentication method. Expected either apiKey or authToken to be set. Or for one of the "X-Api-Key" or "Authorization" headers to be explicitly omitted'); + } + async authHeaders($) { + return n([await this.apiKeyAuth($), await this.bearerAuth($)]); + } + async apiKeyAuth($) { + if (this.apiKey == null) return; + return n([{ "X-Api-Key": this.apiKey }]); + } + async bearerAuth($) { + if (this.authToken == null) return; + return n([{ Authorization: `Bearer ${this.authToken}` }]); + } + stringifyQuery($) { + return vH($); + } + getUserAgent() { + return `${this.constructor.name}/JS ${I4}`; + } + defaultIdempotencyKey() { + return `stainless-node-retry-${Jz()}`; + } + makeStatusError($, X, J, Q) { + return v$.generate($, X, J, Q); + } + buildURL($, X, J) { + let Q = !D(this, vz, "m", UK).call(this) && J || this.baseURL, Y = LH($) ? new URL($) : new URL(Q + (Q.endsWith("/") && $.startsWith("/") ? $.slice(1) : $)), z6 = this.defaultQuery(), W = Object.fromEntries(Y.searchParams); + if (!zz(z6) || !zz(W)) X = { ...W, ...z6, ...X }; + if (typeof X === "object" && X && !Array.isArray(X)) Y.search = this.stringifyQuery(X); + return Y.toString(); + } + _calculateNonstreamingTimeout($) { + if (3600 * $ / 128e3 > 600) throw new T("Streaming is required for operations that may take longer than 10 minutes. See https://github.com/anthropics/anthropic-sdk-typescript#streaming-responses for more details"); + return 6e5; + } + async prepareOptions($) { + } + async prepareRequest($, { url: X, options: J }) { + } + get($, X) { + return this.methodRequest("get", $, X); + } + post($, X) { + return this.methodRequest("post", $, X); + } + patch($, X) { + return this.methodRequest("patch", $, X); + } + put($, X) { + return this.methodRequest("put", $, X); + } + delete($, X) { + return this.methodRequest("delete", $, X); + } + methodRequest($, X, J) { + return this.request(Promise.resolve(J).then((Q) => { + return { method: $, path: X, ...Q }; + })); + } + request($, X = null) { + return new J1(this, this.makeRequest($, X, void 0)); + } + async makeRequest($, X, J) { + var _a3, _b2, _c; + let Q = await $, Y = (_a3 = Q.maxRetries) != null ? _a3 : this.maxRetries; + if (X == null) X = Y; + await this.prepareOptions(Q); + let { req: z6, url: W, timeout: G } = await this.buildRequest(Q, { retryCount: Y - X }); + await this.prepareRequest(z6, { url: W, options: Q }); + let U = "log_" + (Math.random() * 16777216 | 0).toString(16).padStart(6, "0"), H = J === void 0 ? "" : `, retryOf: ${J}`, K = Date.now(); + if (_$(this).debug(`[${U}] sending request`, e6({ retryOfRequestLogID: J, method: Q.method, url: W, options: Q, headers: z6.headers })), (_b2 = Q.signal) == null ? void 0 : _b2.aborted) throw new T$(); + let V = new AbortController(), O = await this.fetchWithTimeout(W, z6, G, V).catch($X), N = Date.now(); + if (O instanceof globalThis.Error) { + let L = `retrying, ${X} attempts remaining`; + if ((_c = Q.signal) == null ? void 0 : _c.aborted) throw new T$(); + let j = s6(O) || /timed? ?out/i.test(String(O) + ("cause" in O ? String(O.cause) : "")); + if (X) return _$(this).info(`[${U}] connection ${j ? "timed out" : "failed"} - ${L}`), _$(this).debug(`[${U}] connection ${j ? "timed out" : "failed"} (${L})`, e6({ retryOfRequestLogID: J, url: W, durationMs: N - K, message: O.message })), this.retryRequest(Q, X, J != null ? J : U); + if (_$(this).info(`[${U}] connection ${j ? "timed out" : "failed"} - error; no more retries left`), _$(this).debug(`[${U}] connection ${j ? "timed out" : "failed"} (error; no more retries left)`, e6({ retryOfRequestLogID: J, url: W, durationMs: N - K, message: O.message })), j) throw new XX(); + throw new X1({ cause: O }); + } + let w = [...O.headers.entries()].filter(([L]) => L === "request-id").map(([L, j]) => ", " + L + ": " + JSON.stringify(j)).join(""), B = `[${U}${H}${w}] ${z6.method} ${W} ${O.ok ? "succeeded" : "failed"} with status ${O.status} in ${N - K}ms`; + if (!O.ok) { + let L = await this.shouldRetry(O); + if (X && L) { + let B$ = `retrying, ${X} attempts remaining`; + return await RH(O.body), _$(this).info(`${B} - ${B$}`), _$(this).debug(`[${U}] response error (${B$})`, e6({ retryOfRequestLogID: J, url: O.url, status: O.status, headers: O.headers, durationMs: N - K })), this.retryRequest(Q, X, J != null ? J : U, O.headers); + } + let j = L ? "error; no more retries left" : "error; not retryable"; + _$(this).info(`${B} - ${j}`); + let I = await O.text().catch((B$) => $X(B$).message), b = e9(I), x = b ? void 0 : I; + throw _$(this).debug(`[${U}] response error (${j})`, e6({ retryOfRequestLogID: J, url: O.url, status: O.status, headers: O.headers, message: x, durationMs: Date.now() - K })), this.makeStatusError(O.status, b, x, O.headers); + } + return _$(this).info(B), _$(this).debug(`[${U}] response start`, e6({ retryOfRequestLogID: J, url: O.url, status: O.status, headers: O.headers, durationMs: N - K })), { response: O, options: Q, controller: V, requestLogID: U, retryOfRequestLogID: J, startTime: K }; + } + getAPIList($, X, J) { + return this.requestAPIList(X, J && "then" in J ? J.then((Q) => ({ method: "get", path: $, ...Q })) : { method: "get", path: $, ...J }); + } + requestAPIList($, X) { + let J = this.makeRequest(X, null, void 0); + return new zJ(this, J, $); + } + async fetchWithTimeout($, X, J, Q) { + let { signal: Y, method: z6, ...W } = X || {}, G = this._makeAbort(Q); + if (Y) Y.addEventListener("abort", G, { once: true }); + let U = setTimeout(G, J), H = globalThis.ReadableStream && W.body instanceof globalThis.ReadableStream || typeof W.body === "object" && W.body !== null && Symbol.asyncIterator in W.body, K = { signal: Q.signal, ...H ? { duplex: "half" } : {}, method: "GET", ...W }; + if (z6) K.method = z6.toUpperCase(); + try { + return await this.fetch.call(void 0, $, K); + } finally { + clearTimeout(U); + } + } + async shouldRetry($) { + let X = $.headers.get("x-should-retry"); + if (X === "true") return true; + if (X === "false") return false; + if ($.status === 408) return true; + if ($.status === 409) return true; + if ($.status === 429) return true; + if ($.status >= 500) return true; + return false; + } + async retryRequest($, X, J, Q) { + var _a3; + let Y, z6 = Q == null ? void 0 : Q.get("retry-after-ms"); + if (z6) { + let G = parseFloat(z6); + if (!Number.isNaN(G)) Y = G; + } + let W = Q == null ? void 0 : Q.get("retry-after"); + if (W && !Y) { + let G = parseFloat(W); + if (!Number.isNaN(G)) Y = G * 1e3; + else Y = Date.parse(W) - Date.now(); + } + if (Y === void 0) { + let G = (_a3 = $.maxRetries) != null ? _a3 : this.maxRetries; + Y = this.calculateDefaultRetryTimeoutMillis(X, G); + } + return await MH(Y), this.makeRequest($, X - 1, J); + } + calculateDefaultRetryTimeoutMillis($, X) { + let Y = X - $, z6 = Math.min(0.5 * Math.pow(2, Y), 8), W = 1 - Math.random() * 0.25; + return z6 * W * 1e3; + } + calculateNonstreamingTimeout($, X) { + if (36e5 * $ / 128e3 > 6e5 || X != null && $ > X) throw new T("Streaming is required for operations that may take longer than 10 minutes. See https://github.com/anthropics/anthropic-sdk-typescript#long-requests for more details"); + return 6e5; + } + async buildRequest($, { retryCount: X = 0 } = {}) { + var _a3, _b2, _c; + let J = { ...$ }, { method: Q, path: Y, query: z6, defaultBaseURL: W } = J, G = this.buildURL(Y, z6, W); + if ("timeout" in J) FH("timeout", J.timeout); + J.timeout = (_a3 = J.timeout) != null ? _a3 : this.timeout; + let { bodyHeaders: U, body: H } = this.buildBody({ options: J }), K = await this.buildHeaders({ options: $, method: Q, bodyHeaders: U, retryCount: X }); + return { req: { method: Q, headers: K, ...J.signal && { signal: J.signal }, ...globalThis.ReadableStream && H instanceof globalThis.ReadableStream && { duplex: "half" }, ...H && { body: H }, ...(_b2 = this.fetchOptions) != null ? _b2 : {}, ...(_c = J.fetchOptions) != null ? _c : {} }, url: G, timeout: J.timeout }; + } + async buildHeaders({ options: $, method: X, bodyHeaders: J, retryCount: Q }) { + let Y = {}; + if (this.idempotencyHeader && X !== "get") { + if (!$.idempotencyKey) $.idempotencyKey = this.defaultIdempotencyKey(); + Y[this.idempotencyHeader] = $.idempotencyKey; + } + let z6 = n([Y, { Accept: "application/json", "User-Agent": this.getUserAgent(), "X-Stainless-Retry-Count": String(Q), ...$.timeout ? { "X-Stainless-Timeout": String(Math.trunc($.timeout / 1e3)) } : {}, ...ZH(), ...this._options.dangerouslyAllowBrowser ? { "anthropic-dangerous-direct-browser-access": "true" } : void 0, "anthropic-version": "2023-06-01" }, await this.authHeaders($), this._options.defaultHeaders, J, $.headers]); + return this.validateHeaders(z6), z6.values; + } + _makeAbort($) { + return () => $.abort(); + } + buildBody({ options: { body: $, headers: X } }) { + if (!$) return { bodyHeaders: void 0, body: void 0 }; + let J = n([X]); + if (ArrayBuffer.isView($) || $ instanceof ArrayBuffer || $ instanceof DataView || typeof $ === "string" && J.values.has("content-type") || globalThis.Blob && $ instanceof globalThis.Blob || $ instanceof FormData || $ instanceof URLSearchParams || globalThis.ReadableStream && $ instanceof globalThis.ReadableStream) return { bodyHeaders: void 0, body: $ }; + else if (typeof $ === "object" && (Symbol.asyncIterator in $ || Symbol.iterator in $ && "next" in $ && typeof $.next === "function")) return { bodyHeaders: void 0, body: $J($) }; + else if (typeof $ === "object" && J.values.get("content-type") === "application/x-www-form-urlencoded") return { bodyHeaders: { "content-type": "application/x-www-form-urlencoded" }, body: this.stringifyQuery($) }; + else return D(this, bJ, "f").call(this, { body: $, headers: J }); + } +}; +Cz = P$, bJ = /* @__PURE__ */ new WeakMap(), vz = /* @__PURE__ */ new WeakSet(), UK = function() { + return this.baseURL !== "https://api.anthropic.com"; +}; +P$.Anthropic = Cz; +P$.HUMAN_PROMPT = HK; +P$.AI_PROMPT = KK; +P$.DEFAULT_TIMEOUT = 6e5; +P$.AnthropicError = T; +P$.APIError = v$; +P$.APIConnectionError = X1; +P$.APIConnectionTimeoutError = XX; +P$.APIUserAbortError = T$; +P$.NotFoundError = zX; +P$.ConflictError = WX; +P$.RateLimitError = UX; +P$.BadRequestError = JX; +P$.AuthenticationError = YX; +P$.InternalServerError = HX; +P$.PermissionDeniedError = QX; +P$.UnprocessableEntityError = GX; +P$.toFile = WJ; +var U1 = class extends P$ { + constructor() { + super(...arguments); + this.completions = new a1(this), this.messages = new G1(this), this.models = new e1(this), this.beta = new m6(this); + } +}; +U1.Completions = a1; +U1.Messages = G1; +U1.Models = e1; +U1.Beta = m6; +function lX($) { + return $ instanceof Error ? $.message : String($); +} +function H1($) { + if ($ && typeof $ === "object" && "code" in $ && typeof $.code === "string") return $.code; + return; +} +function VK($) { + return H1($) === "ENOENT"; +} +var X0; +var $0 = null; +function yF() { + if ($0) return $0; + if (!B6(process.env.DEBUG_CLAUDE_AGENT_SDK)) return X0 = null, $0 = Promise.resolve(), $0; + let $ = (0, import_path7.join)(c1(), "debug"); + return X0 = (0, import_path7.join)($, `sdk-${(0, import_crypto.randomUUID)()}.txt`), process.stderr.write(`SDK debug logs: ${X0} +`), $0 = (0, import_promises.mkdir)($, { recursive: true }).then(() => { + }).catch(() => { + }), $0; +} +function s$($) { + if (X0 === null) return; + let J = `${(/* @__PURE__ */ new Date()).toISOString()} ${$} +`; + yF().then(() => { + if (X0) (0, import_promises.appendFile)(X0, J).catch(() => { + }); + }); +} +function kz() { + let $ = /* @__PURE__ */ new Set(); + return { subscribe(X) { + return $.add(X), () => { + $.delete(X); + }; + }, emit(...X) { + for (let J of $) J(...X); + }, clear() { + $.clear(); + } }; +} +function gF() { + let $ = ""; + if (typeof process < "u" && typeof process.cwd === "function" && typeof import_fs.realpathSync === "function") { + let J = (0, import_process.cwd)(); + try { + $ = (0, import_fs.realpathSync)(J).normalize("NFC"); + } catch (e3) { + $ = J.normalize("NFC"); + } + } + return { originalCwd: $, projectRoot: $, totalCostUSD: 0, totalAPIDuration: 0, totalAPIDurationWithoutRetries: 0, totalToolDuration: 0, turnHookDurationMs: 0, turnToolDurationMs: 0, turnClassifierDurationMs: 0, turnToolCount: 0, turnHookCount: 0, turnClassifierCount: 0, startTime: Date.now(), lastInteractionTime: Date.now(), totalLinesAdded: 0, totalLinesRemoved: 0, hasUnknownModelCost: false, cwd: $, modelUsage: {}, mainLoopModelOverride: void 0, initialMainLoopModel: null, modelStrings: null, isInteractive: false, kairosActive: false, strictToolResultPairing: false, memoryToggledOff: false, sdkAgentProgressSummariesEnabled: false, userMsgOptIn: false, clientType: "cli", sessionSource: void 0, questionPreviewFormat: void 0, sessionIngressToken: void 0, oauthTokenFromFd: void 0, apiKeyFromFd: void 0, flagSettingsPath: void 0, flagSettingsInline: null, allowedSettingSources: ["userSettings", "projectSettings", "localSettings", "flagSettings", "policySettings"], meter: null, sessionCounter: null, locCounter: null, prCounter: null, commitCounter: null, costCounter: null, tokenCounter: null, codeEditToolDecisionCounter: null, activeTimeCounter: null, statsStore: null, sessionId: (0, import_crypto2.randomUUID)(), parentSessionId: void 0, loggerProvider: null, eventLogger: null, meterProvider: null, tracerProvider: null, agentColorMap: /* @__PURE__ */ new Map(), agentColorIndex: 0, lastAPIRequest: null, lastAPIRequestMessages: null, lastClassifierRequests: null, cachedClaudeMdContent: null, inMemoryErrorLog: [], inlinePlugins: [], chromeFlagOverride: void 0, useCoworkPlugins: false, sessionBypassPermissionsMode: false, scheduledTasksEnabled: false, sessionCronTasks: [], sessionCreatedTeams: /* @__PURE__ */ new Set(), sessionTrustAccepted: false, sessionPersistenceDisabled: false, hasExitedPlanMode: false, needsPlanModeExitAttachment: false, needsAutoModeExitAttachment: false, lspRecommendationShownThisSession: false, initJsonSchema: null, registeredHooks: null, planSlugCache: /* @__PURE__ */ new Map(), teleportedSessionInfo: null, invokedSkills: /* @__PURE__ */ new Map(), slowOperations: [], sdkBetas: void 0, mainThreadAgentType: void 0, isRemoteMode: false, ...false, directConnectServerUrl: void 0, systemPromptSectionCache: /* @__PURE__ */ new Map(), lastEmittedDate: null, additionalDirectoriesForClaudeMd: [], allowedChannels: [], hasDevChannels: false, sessionProjectDir: null, promptCache1hAllowlist: null, afkModeHeaderLatched: null, fastModeHeaderLatched: null, cacheEditingHeaderLatched: null, thinkingClearLatched: null, promptId: null, lastMainRequestId: void 0, lastApiCompletionTimestamp: null, pendingPostCompaction: false }; +} +var hF = gF(); +function BK() { + return hF.sessionId; +} +var uF = kz(); +var Su = uF.subscribe; +var mF = kz(); +var vu = mF.subscribe; +function qK({ writeFn: $, flushIntervalMs: X = 1e3, maxBufferSize: J = 100, maxBufferBytes: Q = 1 / 0, immediateMode: Y = false }) { + let z6 = [], W = 0, G = null, U = null; + function H() { + if (G) clearTimeout(G), G = null; + } + function K() { + if (U) $(U.join("")), U = null; + if (z6.length === 0) return; + $(z6.join("")), z6 = [], W = 0, H(); + } + function V() { + if (!G) G = setTimeout(K, X); + } + function O() { + if (U) { + U.push(...z6), z6 = [], W = 0, H(); + return; + } + let N = z6; + z6 = [], W = 0, H(), U = N, setImmediate(() => { + let w = U; + if (U = null, w) $(w.join("")); + }); + } + return { write(N) { + if (Y) { + $(N); + return; + } + if (z6.push(N), W += N.length, V(), z6.length >= J || W >= Q) O(); + }, flush: K, dispose() { + K(); + } }; +} +var DK = /* @__PURE__ */ new Set(); +function LK($) { + return DK.add($), () => DK.delete($); +} +var jK = R6(($) => { + if (!$ || $.trim() === "") return null; + let X = $.split(",").map((z6) => z6.trim()).filter(Boolean); + if (X.length === 0) return null; + let J = X.some((z6) => z6.startsWith("!")), Q = X.some((z6) => !z6.startsWith("!")); + if (J && Q) return null; + let Y = X.map((z6) => z6.replace(/^!/, "").toLowerCase()); + return { include: J ? [] : Y, exclude: J ? Y : [], isExclusive: J }; +}); +function lF($) { + let X = [], J = $.match(/^MCP server ["']([^"']+)["']/); + if (J && J[1]) X.push("mcp"), X.push(J[1].toLowerCase()); + else { + let z6 = $.match(/^([^:[]+):/); + if (z6 && z6[1]) X.push(z6[1].trim().toLowerCase()); + } + let Q = $.match(/^\[([^\]]+)]/); + if (Q && Q[1]) X.push(Q[1].trim().toLowerCase()); + if ($.toLowerCase().includes("1p event:")) X.push("1p"); + let Y = $.match(/:\s*([^:]+?)(?:\s+(?:type|mode|status|event))?:/); + if (Y && Y[1]) { + let z6 = Y[1].trim().toLowerCase(); + if (z6.length < 30 && !z6.includes(" ")) X.push(z6); + } + return Array.from(new Set(X)); +} +function cF($, X) { + if (!X) return true; + if ($.length === 0) return false; + if (X.isExclusive) return !$.some((J) => X.exclude.includes(J)); + else return $.some((J) => X.include.includes(J)); +} +function FK($, X) { + if (!X) return true; + let J = lF($); + return cF(J, X); +} +var sF = { cwd() { + return process.cwd(); +}, existsSync($) { + let J = []; + try { + const X = N$(J, b$`fs.existsSync(${$})`, 0); + return r.existsSync($); + } catch (Q) { + var Y = Q, z6 = 1; + } finally { + V$(J, Y, z6); + } +}, async stat($) { + return (0, import_promises3.stat)($); +}, async readdir($) { + return (0, import_promises3.readdir)($, { withFileTypes: true }); +}, async unlink($) { + return (0, import_promises3.unlink)($); +}, async rmdir($) { + return (0, import_promises3.rmdir)($); +}, async rm($, X) { + return (0, import_promises3.rm)($, X); +}, async mkdir($, X) { + try { + await (0, import_promises3.mkdir)($, { recursive: true, ...X }); + } catch (J) { + if (H1(J) !== "EEXIST") throw J; + } +}, async readFile($, X) { + return (0, import_promises3.readFile)($, { encoding: X.encoding }); +}, async rename($, X) { + return (0, import_promises3.rename)($, X); +}, statSync($) { + let J = []; + try { + const X = N$(J, b$`fs.statSync(${$})`, 0); + return r.statSync($); + } catch (Q) { + var Y = Q, z6 = 1; + } finally { + V$(J, Y, z6); + } +}, lstatSync($) { + let J = []; + try { + const X = N$(J, b$`fs.lstatSync(${$})`, 0); + return r.lstatSync($); + } catch (Q) { + var Y = Q, z6 = 1; + } finally { + V$(J, Y, z6); + } +}, readFileSync($, X) { + let Q = []; + try { + const J = N$(Q, b$`fs.readFileSync(${$})`, 0); + return r.readFileSync($, { encoding: X.encoding }); + } catch (Y) { + var z6 = Y, W = 1; + } finally { + V$(Q, z6, W); + } +}, readFileBytesSync($) { + let J = []; + try { + const X = N$(J, b$`fs.readFileBytesSync(${$})`, 0); + return r.readFileSync($); + } catch (Q) { + var Y = Q, z6 = 1; + } finally { + V$(J, Y, z6); + } +}, readSync($, X) { + let Y = []; + try { + const J = N$(Y, b$`fs.readSync(${$}, ${X.length} bytes)`, 0); + let Q = void 0; + try { + Q = r.openSync($, "r"); + let U = Buffer.alloc(X.length), H = r.readSync(Q, U, 0, X.length, 0); + return { buffer: U, bytesRead: H }; + } finally { + if (Q) r.closeSync(Q); + } + } catch (z6) { + var W = z6, G = 1; + } finally { + V$(Y, W, G); + } +}, appendFileSync($, X, J) { + let Y = []; + try { + const Q = N$(Y, b$`fs.appendFileSync(${$}, ${X.length} chars)`, 0); + if ((J == null ? void 0 : J.mode) !== void 0) try { + let U = r.openSync($, "ax", J.mode); + try { + r.appendFileSync(U, X); + } finally { + r.closeSync(U); + } + return; + } catch (U) { + if (H1(U) !== "EEXIST") throw U; + } + r.appendFileSync($, X); + } catch (z6) { + var W = z6, G = 1; + } finally { + V$(Y, W, G); + } +}, copyFileSync($, X) { + let Q = []; + try { + const J = N$(Q, b$`fs.copyFileSync(${$} → ${X})`, 0); + r.copyFileSync($, X); + } catch (Y) { + var z6 = Y, W = 1; + } finally { + V$(Q, z6, W); + } +}, unlinkSync($) { + let J = []; + try { + const X = N$(J, b$`fs.unlinkSync(${$})`, 0); + r.unlinkSync($); + } catch (Q) { + var Y = Q, z6 = 1; + } finally { + V$(J, Y, z6); + } +}, renameSync($, X) { + let Q = []; + try { + const J = N$(Q, b$`fs.renameSync(${$} → ${X})`, 0); + r.renameSync($, X); + } catch (Y) { + var z6 = Y, W = 1; + } finally { + V$(Q, z6, W); + } +}, linkSync($, X) { + let Q = []; + try { + const J = N$(Q, b$`fs.linkSync(${$} → ${X})`, 0); + r.linkSync($, X); + } catch (Y) { + var z6 = Y, W = 1; + } finally { + V$(Q, z6, W); + } +}, symlinkSync($, X, J) { + let Y = []; + try { + const Q = N$(Y, b$`fs.symlinkSync(${$} → ${X})`, 0); + r.symlinkSync($, X, J); + } catch (z6) { + var W = z6, G = 1; + } finally { + V$(Y, W, G); + } +}, readlinkSync($) { + let J = []; + try { + const X = N$(J, b$`fs.readlinkSync(${$})`, 0); + return r.readlinkSync($); + } catch (Q) { + var Y = Q, z6 = 1; + } finally { + V$(J, Y, z6); + } +}, realpathSync($) { + let J = []; + try { + const X = N$(J, b$`fs.realpathSync(${$})`, 0); + return r.realpathSync($).normalize("NFC"); + } catch (Q) { + var Y = Q, z6 = 1; + } finally { + V$(J, Y, z6); + } +}, mkdirSync($, X) { + let Y = []; + try { + const J = N$(Y, b$`fs.mkdirSync(${$})`, 0); + let Q = { recursive: true }; + if ((X == null ? void 0 : X.mode) !== void 0) Q.mode = X.mode; + try { + r.mkdirSync($, Q); + } catch (U) { + if (H1(U) !== "EEXIST") throw U; + } + } catch (z6) { + var W = z6, G = 1; + } finally { + V$(Y, W, G); + } +}, readdirSync($) { + let J = []; + try { + const X = N$(J, b$`fs.readdirSync(${$})`, 0); + return r.readdirSync($, { withFileTypes: true }); + } catch (Q) { + var Y = Q, z6 = 1; + } finally { + V$(J, Y, z6); + } +}, readdirStringSync($) { + let J = []; + try { + const X = N$(J, b$`fs.readdirStringSync(${$})`, 0); + return r.readdirSync($); + } catch (Q) { + var Y = Q, z6 = 1; + } finally { + V$(J, Y, z6); + } +}, isDirEmptySync($) { + let Q = []; + try { + const X = N$(Q, b$`fs.isDirEmptySync(${$})`, 0); + let J = this.readdirSync($); + return J.length === 0; + } catch (Y) { + var z6 = Y, W = 1; + } finally { + V$(Q, z6, W); + } +}, rmdirSync($) { + let J = []; + try { + const X = N$(J, b$`fs.rmdirSync(${$})`, 0); + r.rmdirSync($); + } catch (Q) { + var Y = Q, z6 = 1; + } finally { + V$(J, Y, z6); + } +}, rmSync($, X) { + let Q = []; + try { + const J = N$(Q, b$`fs.rmSync(${$})`, 0); + r.rmSync($, X); + } catch (Y) { + var z6 = Y, W = 1; + } finally { + V$(Q, z6, W); + } +}, createWriteStream($) { + return r.createWriteStream($); +}, async readFileBytes($, X) { + if (X === void 0) return (0, import_promises3.readFile)($); + let J = await (0, import_promises3.open)($, "r"); + try { + let { size: Q } = await J.stat(), Y = Math.min(Q, X), z6 = Buffer.allocUnsafe(Y), W = 0; + while (W < Y) { + let { bytesRead: G } = await J.read(z6, W, Y - W, W); + if (G === 0) break; + W += G; + } + return W < Y ? z6.subarray(0, W) : z6; + } finally { + await J.close(); + } +} }; +var eF = sF; +function _z() { + return eF; +} +function $M($, X) { + if ($.destroyed) return; + $.write(X); +} +function IK($) { + $M(process.stderr, $); +} +var Tz = { verbose: 0, debug: 1, info: 2, warn: 3, error: 4 }; +var zM = R6(() => { + var _a3; + let $ = (_a3 = process.env.CLAUDE_CODE_DEBUG_LOG_LEVEL) == null ? void 0 : _a3.toLowerCase().trim(); + if ($ && Object.hasOwn(Tz, $)) return $; + return "debug"; +}); +var WM = false; +var yz = R6(() => { + return WM || B6(process.env.DEBUG) || B6(process.env.DEBUG_SDK) || process.argv.includes("--debug") || process.argv.includes("-d") || PK() || process.argv.some(($) => $.startsWith("--debug=")) || ZK() !== null; +}); +var GM = R6(() => { + let $ = process.argv.find((J) => J.startsWith("--debug=")); + if (!$) return null; + let X = $.substring(8); + return jK(X); +}); +var PK = R6(() => { + return process.argv.includes("--debug-to-stderr") || process.argv.includes("-d2e"); +}); +var ZK = R6(() => { + for (let $ = 0; $ < process.argv.length; $++) { + let X = process.argv[$]; + if (X.startsWith("--debug-file=")) return X.substring(13); + if (X === "--debug-file" && $ + 1 < process.argv.length) return process.argv[$ + 1]; + } + return null; +}); +function UM($) { + if (!yz()) return false; + if (typeof process > "u" || typeof process.versions > "u" || typeof process.versions.node > "u") return false; + let X = GM(); + return FK($, X); +} +var HM = false; +var ZJ = null; +var xz = Promise.resolve(); +async function KM($, X, J, Q) { + if ($) await (0, import_promises2.mkdir)(X, { recursive: true }).catch(() => { + }); + await (0, import_promises2.appendFile)(J, Q), RK(); +} +function NM() { +} +function VM() { + if (!ZJ) { + let $ = null; + ZJ = qK({ writeFn: (X) => { + let J = EK(), Q = (0, import_path8.dirname)(J), Y = $ !== Q; + if ($ = Q, yz()) { + if (Y) try { + _z().mkdirSync(Q); + } catch (e3) { + } + _z().appendFileSync(J, X), RK(); + return; + } + xz = xz.then(KM.bind(null, Y, Q, J, X)).catch(NM); + }, flushIntervalMs: 1e3, maxBufferSize: 100, immediateMode: yz() }), LK(async () => { + ZJ == null ? void 0 : ZJ.dispose(), await xz; + }); + } + return ZJ; +} +function L6($, { level: X } = { level: "debug" }) { + if (Tz[X] < Tz[zM()]) return; + if (!UM($)) return; + if (HM && $.includes(` +`)) $ = q$($); + let Q = `${(/* @__PURE__ */ new Date()).toISOString()} [${X.toUpperCase()}] ${$.trim()} +`; + if (PK()) { + IK(Q); + return; + } + VM().write(Q); +} +function EK() { + var _a3, _b2; + return (_b2 = (_a3 = ZK()) != null ? _a3 : process.env.CLAUDE_CODE_DEBUG_LOGS_DIR) != null ? _b2 : (0, import_path8.join)(c1(), "debug", `${BK()}.txt`); +} +var RK = R6(async () => { + try { + let $ = EK(), X = (0, import_path8.dirname)($), J = (0, import_path8.join)(X, "latest"); + await (0, import_promises2.unlink)(J).catch(() => { + }), await (0, import_promises2.symlink)($, J); + } catch (e3) { + } +}); +var Qm = (() => { + let $ = process.env.CLAUDE_CODE_SLOW_OPERATION_THRESHOLD_MS; + if ($ !== void 0) { + let X = Number($); + if (!Number.isNaN(X) && X >= 0) return X; + } + return 1 / 0; +})(); +var OM = { [Symbol.dispose]() { +} }; +function wM() { + return OM; +} +var b$ = wM; +function q$($, X, J) { + let Y = []; + try { + const Q = N$(Y, b$`JSON.stringify(${$})`, 0); + return JSON.stringify($, X, J); + } catch (z6) { + var W = z6, G = 1; + } finally { + V$(Y, W, G); + } +} +var j6 = ($, X) => { + let Q = []; + try { + const J = N$(Q, b$`JSON.parse(${$})`, 0); + return typeof X > "u" ? JSON.parse($) : JSON.parse($, X); + } catch (Y) { + var z6 = Y, W = 1; + } finally { + V$(Q, z6, W); + } +}; +function BM($) { + let X = $.trim(); + return X.startsWith("{") && X.endsWith("}"); +} +function SK($, X) { + let J = { ...$ }; + if (X) { + let Q = X.enabled === true && X.failIfUnavailable === void 0 ? { ...X, failIfUnavailable: true } : X, Y = J.settings; + if (Y && !BM(Y)) throw Error("Cannot use both a settings file path and the sandbox option. Include the sandbox configuration in your settings file instead."); + let z6 = { sandbox: Q }; + if (Y) try { + z6 = { ...j6(Y), sandbox: Q }; + } catch (e3) { + } + J.settings = q$(z6); + } + return J; +} +var LM = 2e3; +var cX = class { + constructor($) { + __publicField(this, "options"); + __publicField(this, "process"); + __publicField(this, "processStdin"); + __publicField(this, "processStdout"); + __publicField(this, "ready", false); + __publicField(this, "abortController"); + __publicField(this, "exitError"); + __publicField(this, "exitListeners", []); + __publicField(this, "processExitHandler"); + __publicField(this, "abortHandler"); + this.options = $; + this.abortController = $.abortController || y1(), this.initialize(); + } + getDefaultExecutable() { + return f1() ? "bun" : "node"; + } + spawnLocalProcess($) { + let { command: X, args: J, cwd: Q, env: Y, signal: z6 } = $, W = B6(Y.DEBUG_CLAUDE_AGENT_SDK) || this.options.stderr ? "pipe" : "ignore", G = (0, import_child_process.spawn)(X, J, { cwd: Q, stdio: ["pipe", "pipe", W], signal: z6, env: Y, windowsHide: true }); + if (B6(Y.DEBUG_CLAUDE_AGENT_SDK) || this.options.stderr) G.stderr.on("data", (H) => { + let K = H.toString(); + if (s$(K), this.options.stderr) this.options.stderr(K); + }); + return { stdin: G.stdin, stdout: G.stdout, get killed() { + return G.killed; + }, get exitCode() { + return G.exitCode; + }, kill: G.kill.bind(G), on: G.on.bind(G), once: G.once.bind(G), off: G.off.bind(G) }; + } + initialize() { + try { + let { additionalDirectories: $ = [], agent: X, betas: J, cwd: Q, executable: Y = this.getDefaultExecutable(), executableArgs: z6 = [], extraArgs: W = {}, pathToClaudeCodeExecutable: G, env: U = { ...process.env }, thinkingConfig: H, maxTurns: K, maxBudgetUsd: V, taskBudget: O, model: N, fallbackModel: w, jsonSchema: B, permissionMode: L, allowDangerouslySkipPermissions: j, permissionPromptToolName: I, continueConversation: b, resume: x, settingSources: h, allowedTools: B$ = [], disallowedTools: x$ = [], tools: G6, mcpServers: o6, strictMcpConfig: u6, canUseTool: a4, includePartialMessages: _1, plugins: t6, sandbox: r0 } = this.options, p = ["--output-format", "stream-json", "--verbose", "--input-format", "stream-json"]; + if (H) switch (H.type) { + case "enabled": + if (H.budgetTokens === void 0) p.push("--thinking", "adaptive"); + else p.push("--max-thinking-tokens", H.budgetTokens.toString()); + break; + case "disabled": + p.push("--thinking", "disabled"); + break; + case "adaptive": + p.push("--thinking", "adaptive"); + break; + } + if (this.options.effort) p.push("--effort", this.options.effort); + if (K) p.push("--max-turns", K.toString()); + if (V !== void 0) p.push("--max-budget-usd", V.toString()); + if (O) p.push("--task-budget", O.total.toString()); + if (N) p.push("--model", N); + if (X) p.push("--agent", X); + if (J && J.length > 0) p.push("--betas", J.join(",")); + if (B) p.push("--json-schema", q$(B)); + if (this.options.debugFile) p.push("--debug-file", this.options.debugFile); + else if (this.options.debug) p.push("--debug"); + if (B6(U.DEBUG_CLAUDE_AGENT_SDK)) p.push("--debug-to-stderr"); + if (a4) { + if (I) throw Error("canUseTool callback cannot be used with permissionPromptToolName. Please use one or the other."); + p.push("--permission-prompt-tool", "stdio"); + } else if (I) p.push("--permission-prompt-tool", I); + if (b) p.push("--continue"); + if (x) p.push("--resume", x); + if (this.options.proactive) p.push("--proactive"); + if (this.options.assistant) p.push("--assistant"); + if (this.options.channels && this.options.channels.length > 0) p.push("--channels", ...this.options.channels); + if (B$.length > 0) p.push("--allowedTools", B$.join(",")); + if (x$.length > 0) p.push("--disallowedTools", x$.join(",")); + if (G6 !== void 0) if (Array.isArray(G6)) if (G6.length === 0) p.push("--tools", ""); + else p.push("--tools", G6.join(",")); + else p.push("--tools", "default"); + if (o6 && Object.keys(o6).length > 0) p.push("--mcp-config", q$({ mcpServers: o6 })); + if (h !== void 0) p.push(`--setting-sources=${h.join(",")}`); + if (u6) p.push("--strict-mcp-config"); + if (L) p.push("--permission-mode", L); + if (j) p.push("--allow-dangerously-skip-permissions"); + if (w) { + if (N && w === N) throw Error("Fallback model cannot be the same as the main model. Please specify a different model for fallbackModel option."); + p.push("--fallback-model", w); + } + if (this.options.includeHookEvents) p.push("--include-hook-events"); + if (_1) p.push("--include-partial-messages"); + for (let p$ of $) p.push("--add-dir", p$); + if (t6 && t6.length > 0) for (let p$ of t6) if (p$.type === "local") p.push("--plugin-dir", p$.path); + else throw Error(`Unsupported plugin type: ${p$.type}`); + if (this.options.forkSession) p.push("--fork-session"); + if (this.options.resumeSessionAt) p.push("--resume-session-at", this.options.resumeSessionAt); + if (this.options.sessionId) p.push("--session-id", this.options.sessionId); + if (this.options.persistSession === false) p.push("--no-session-persistence"); + let n9 = { ...W != null ? W : {} }; + if (this.options.settings) n9.settings = this.options.settings; + let aQ = SK(n9, r0); + for (let [p$, j4] of Object.entries(aQ)) if (j4 === null) p.push(`--${p$}`); + else p.push(`--${p$}`, j4); + if (!U.CLAUDE_CODE_ENTRYPOINT) U.CLAUDE_CODE_ENTRYPOINT = "sdk-ts"; + if (delete U.NODE_OPTIONS, B6(U.DEBUG_CLAUDE_AGENT_SDK)) U.DEBUG = "1"; + else delete U.DEBUG; + let o0 = jM(G), t0 = o0 ? G : Y, s4 = o0 ? [...z6, ...p] : [...z6, G, ...p], d9 = { command: t0, args: s4, cwd: Q, env: U, signal: this.abortController.signal }; + if (this.options.spawnClaudeCodeProcess) s$(`Spawning Claude Code (custom): ${t0} ${s4.join(" ")}`), this.process = this.options.spawnClaudeCodeProcess(d9); + else s$(`Spawning Claude Code: ${t0} ${s4.join(" ")}`), this.process = this.spawnLocalProcess(d9); + this.processStdin = this.process.stdin, this.processStdout = this.process.stdout; + let x1 = () => { + if (this.process && !this.process.killed) this.process.kill("SIGTERM"); + }; + this.processExitHandler = x1, this.abortHandler = x1, process.on("exit", this.processExitHandler), this.abortController.signal.addEventListener("abort", this.abortHandler), this.process.on("error", (p$) => { + if (this.ready = false, this.abortController.signal.aborted) this.exitError = new a$("Claude Code process aborted by user"); + else if (VK(p$)) { + let j4 = o0 ? `Claude Code native binary not found at ${G}. Please ensure Claude Code is installed via native installer or specify a valid path with options.pathToClaudeCodeExecutable.` : `Claude Code executable not found at ${G}. Is options.pathToClaudeCodeExecutable set?`; + this.exitError = ReferenceError(j4), s$(this.exitError.message); + } else this.exitError = Error(`Failed to spawn Claude Code process: ${p$.message}`), s$(this.exitError.message); + }), this.process.on("exit", (p$, j4) => { + if (this.ready = false, this.abortController.signal.aborted) this.exitError = new a$("Claude Code process aborted by user"); + else { + let a0 = this.getProcessExitError(p$, j4); + if (a0) this.exitError = a0, s$(a0.message); + } + }), this.ready = true; + } catch ($) { + throw this.ready = false, $; + } + } + getProcessExitError($, X) { + if ($ !== 0 && $ !== null) return Error(`Claude Code process exited with code ${$}`); + else if (X) return Error(`Claude Code process terminated by signal ${X}`); + return; + } + write($) { + var _a3, _b2; + if (this.abortController.signal.aborted) throw new a$("Operation aborted"); + if (!this.ready || !this.processStdin) throw Error("ProcessTransport is not ready for writing"); + if (this.processStdin.writableEnded) { + s$("[ProcessTransport] Dropping write to ended stdin stream"); + return; + } + if (((_a3 = this.process) == null ? void 0 : _a3.killed) || ((_b2 = this.process) == null ? void 0 : _b2.exitCode) !== null) throw Error("Cannot write to terminated process"); + if (this.exitError) throw Error(`Cannot write to process that exited with error: ${this.exitError.message}`); + s$(`[ProcessTransport] Writing to stdin: ${$.substring(0, 100)}`); + try { + if (!this.processStdin.write($)) s$("[ProcessTransport] Write buffer full, data queued"); + } catch (X) { + throw this.ready = false, Error(`Failed to write to process stdin: ${lX(X)}`); + } + } + close() { + var _a3; + if (this.processStdin) this.processStdin.end(), this.processStdin = void 0; + if (this.abortHandler) this.abortController.signal.removeEventListener("abort", this.abortHandler), this.abortHandler = void 0; + for (let { handler: X } of this.exitListeners) (_a3 = this.process) == null ? void 0 : _a3.off("exit", X); + this.exitListeners = []; + let $ = this.process; + if ($ && !$.killed && $.exitCode === null) setTimeout((X) => { + if (X.killed || X.exitCode !== null) return; + X.kill("SIGTERM"), setTimeout((J) => { + if (J.exitCode === null) J.kill("SIGKILL"); + }, 5e3, X).unref(); + }, LM, $).unref(), $.once("exit", () => { + if (this.processExitHandler) process.off("exit", this.processExitHandler), this.processExitHandler = void 0; + }); + else if (this.processExitHandler) process.off("exit", this.processExitHandler), this.processExitHandler = void 0; + this.ready = false; + } + isReady() { + return this.ready; + } + async *readMessages() { + if (!this.processStdout) throw Error("ProcessTransport output stream not available"); + if (this.exitError) throw this.exitError; + let $ = (0, import_readline.createInterface)({ input: this.processStdout }), X = this.process ? (() => { + let J = this.process, Q = () => $.close(); + return J.on("error", Q), () => J.off("error", Q); + })() : void 0; + if (this.exitError) $.close(); + try { + for await (let J of $) if (J.trim()) { + let Q; + try { + Q = j6(J); + } catch (Y) { + s$(`Non-JSON stdout: ${J}`); + continue; + } + yield Q; + } + if (this.exitError) throw this.exitError; + await this.waitForExit(); + } catch (J) { + throw J; + } finally { + X == null ? void 0 : X(), $.close(); + } + } + endInput() { + if (this.processStdin) this.processStdin.end(); + } + getInputStream() { + return this.processStdin; + } + onExit($) { + if (!this.process) return () => { + }; + let X = (J, Q) => { + let Y = this.getProcessExitError(J, Q); + $(Y); + }; + return this.process.on("exit", X), this.exitListeners.push({ callback: $, handler: X }), () => { + if (this.process) this.process.off("exit", X); + let J = this.exitListeners.findIndex((Q) => Q.handler === X); + if (J !== -1) this.exitListeners.splice(J, 1); + }; + } + async waitForExit() { + if (!this.process) { + if (this.exitError) throw this.exitError; + return; + } + if (this.process.exitCode !== null || this.process.killed || this.exitError) { + if (this.exitError) throw this.exitError; + return; + } + return new Promise(($, X) => { + let J = (Y, z6) => { + if (this.abortController.signal.aborted) { + X(new a$("Operation aborted")); + return; + } + let W = this.getProcessExitError(Y, z6); + if (W) X(W); + else $(); + }; + this.process.once("exit", J); + let Q = (Y) => { + this.process.off("exit", J), X(Y); + }; + this.process.once("error", Q), this.process.once("exit", () => { + this.process.off("error", Q); + }); + }); + } +}; +function jM($) { + return ![".js", ".mjs", ".tsx", ".ts", ".jsx"].some((J) => $.endsWith(J)); +} +var K1 = class { + constructor($) { + __publicField(this, "returned"); + __publicField(this, "queue", []); + __publicField(this, "readResolve"); + __publicField(this, "readReject"); + __publicField(this, "isDone", false); + __publicField(this, "hasError"); + __publicField(this, "started", false); + this.returned = $; + } + [Symbol.asyncIterator]() { + if (this.started) throw Error("Stream can only be iterated once"); + return this.started = true, this; + } + next() { + if (this.queue.length > 0) return Promise.resolve({ done: false, value: this.queue.shift() }); + if (this.isDone) return Promise.resolve({ done: true, value: void 0 }); + if (this.hasError) return Promise.reject(this.hasError); + return new Promise(($, X) => { + this.readResolve = $, this.readReject = X; + }); + } + enqueue($) { + if (this.readResolve) { + let X = this.readResolve; + this.readResolve = void 0, this.readReject = void 0, X({ done: false, value: $ }); + } else this.queue.push($); + } + done() { + if (this.isDone = true, this.readResolve) { + let $ = this.readResolve; + this.readResolve = void 0, this.readReject = void 0, $({ done: true, value: void 0 }); + } + } + error($) { + if (this.hasError = $, this.readReject) { + let X = this.readReject; + this.readResolve = void 0, this.readReject = void 0, X($); + } + } + return() { + if (this.isDone = true, this.returned) this.returned(); + return Promise.resolve({ done: true, value: void 0 }); + } +}; +var fz = class { + constructor($) { + __publicField(this, "sendMcpMessage"); + __publicField(this, "isClosed", false); + __publicField(this, "onclose"); + __publicField(this, "onerror"); + __publicField(this, "onmessage"); + this.sendMcpMessage = $; + } + async start() { + } + async send($) { + if (this.isClosed) throw Error("Transport is closed"); + this.sendMcpMessage($); + } + async close() { + var _a3; + if (this.isClosed) return; + this.isClosed = true, (_a3 = this.onclose) == null ? void 0 : _a3.call(this); + } +}; +var pX = class { + constructor($, X, J, Q, Y, z6 = /* @__PURE__ */ new Map(), W, G, U) { + __publicField(this, "transport"); + __publicField(this, "isSingleUserTurn"); + __publicField(this, "canUseTool"); + __publicField(this, "hooks"); + __publicField(this, "abortController"); + __publicField(this, "jsonSchema"); + __publicField(this, "initConfig"); + __publicField(this, "onElicitation"); + __publicField(this, "pendingControlResponses", /* @__PURE__ */ new Map()); + __publicField(this, "cleanupPerformed", false); + __publicField(this, "sdkMessages"); + __publicField(this, "inputStream", new K1()); + __publicField(this, "initialization"); + __publicField(this, "cancelControllers", /* @__PURE__ */ new Map()); + __publicField(this, "hookCallbacks", /* @__PURE__ */ new Map()); + __publicField(this, "nextCallbackId", 0); + __publicField(this, "sdkMcpTransports", /* @__PURE__ */ new Map()); + __publicField(this, "sdkMcpServerInstances", /* @__PURE__ */ new Map()); + __publicField(this, "pendingMcpResponses", /* @__PURE__ */ new Map()); + __publicField(this, "firstResultReceivedResolve"); + __publicField(this, "firstResultReceived", false); + __publicField(this, "lastErrorResultText"); + this.transport = $; + this.isSingleUserTurn = X; + this.canUseTool = J; + this.hooks = Q; + this.abortController = Y; + this.jsonSchema = W; + this.initConfig = G; + this.onElicitation = U; + for (let [H, K] of z6) this.connectSdkMcpServer(H, K); + this.sdkMessages = this.readSdkMessages(), this.readMessages(), this.initialization = this.initialize(), this.initialization.catch(() => { + }); + } + setIsSingleUserTurn($) { + this.isSingleUserTurn = $; + } + hasBidirectionalNeeds() { + return this.sdkMcpTransports.size > 0 || this.hooks !== void 0 && Object.keys(this.hooks).length > 0 || this.canUseTool !== void 0 || this.onElicitation !== void 0; + } + setError($) { + this.inputStream.error($); + } + async stopTask($) { + await this.request({ subtype: "stop_task", task_id: $ }); + } + close() { + this.cleanup(); + } + cleanup($) { + if (this.cleanupPerformed) return; + this.cleanupPerformed = true; + try { + for (let J of this.cancelControllers.values()) J.abort(); + this.cancelControllers.clear(), this.transport.close(); + let X = Error("Query closed before response received"); + for (let { reject: J } of this.pendingControlResponses.values()) J(X); + this.pendingControlResponses.clear(); + for (let { reject: J } of this.pendingMcpResponses.values()) J(X); + this.pendingMcpResponses.clear(), this.hookCallbacks.clear(); + for (let J of this.sdkMcpTransports.values()) J.close().catch(() => { + }); + if (this.sdkMcpTransports.clear(), $) this.inputStream.error($); + else this.inputStream.done(); + } catch (X) { + } + } + next(...[$]) { + return this.sdkMessages.next(...[$]); + } + return($) { + return this.sdkMessages.return($); + } + throw($) { + return this.sdkMessages.throw($); + } + [Symbol.asyncIterator]() { + return this.sdkMessages; + } + [Symbol.asyncDispose]() { + return this.sdkMessages[Symbol.asyncDispose](); + } + async readMessages() { + try { + for await (let $ of this.transport.readMessages()) { + if ($.type === "control_response") { + let X = this.pendingControlResponses.get($.response.request_id); + if (X) X.handler($.response); + continue; + } else if ($.type === "control_request") { + this.handleControlRequest($); + continue; + } else if ($.type === "control_cancel_request") { + this.handleControlCancelRequest($); + continue; + } else if ($.type === "keep_alive") continue; + if ($.type === "system" && $.subtype === "post_turn_summary") continue; + if ($.type === "result") { + if (this.lastErrorResultText = $.is_error ? $.subtype === "success" ? $.result : $.errors.join("; ") : void 0, this.firstResultReceived = true, this.firstResultReceivedResolve) this.firstResultReceivedResolve(); + if (this.isSingleUserTurn) L6("[Query.readMessages] First result received for single-turn query, closing stdin"), this.transport.endInput(); + } else if (!($.type === "system" && $.subtype === "session_state_changed")) this.lastErrorResultText = void 0; + this.inputStream.enqueue($); + } + if (this.firstResultReceivedResolve) this.firstResultReceivedResolve(); + this.inputStream.done(), this.cleanup(); + } catch ($) { + if (this.firstResultReceivedResolve) this.firstResultReceivedResolve(); + if (this.lastErrorResultText !== void 0 && !($ instanceof a$)) { + let X = Error(`Claude Code returned an error result: ${this.lastErrorResultText}`); + L6(`[Query.readMessages] Replacing exit error with result text. Original: ${lX($)}`), this.inputStream.error(X), this.cleanup(X); + return; + } + this.inputStream.error($), this.cleanup($); + } + } + async handleControlRequest($) { + let X = new AbortController(); + this.cancelControllers.set($.request_id, X); + try { + let J = await this.processControlRequest($, X.signal); + if (this.cleanupPerformed) return; + let Q = { type: "control_response", response: { subtype: "success", request_id: $.request_id, response: J } }; + await Promise.resolve(this.transport.write(q$(Q) + ` +`)); + } catch (J) { + if (this.cleanupPerformed) return; + let Q = { type: "control_response", response: { subtype: "error", request_id: $.request_id, error: lX(J) } }; + await Promise.resolve(this.transport.write(q$(Q) + ` +`)); + } finally { + this.cancelControllers.delete($.request_id); + } + } + handleControlCancelRequest($) { + let X = this.cancelControllers.get($.request_id); + if (X) X.abort(), this.cancelControllers.delete($.request_id); + } + async processControlRequest($, X) { + if ($.request.subtype === "can_use_tool") { + if (!this.canUseTool) throw Error("canUseTool callback is not provided."); + return { ...await this.canUseTool($.request.tool_name, $.request.input, { signal: X, suggestions: $.request.permission_suggestions, blockedPath: $.request.blocked_path, decisionReason: $.request.decision_reason, title: $.request.title, displayName: $.request.display_name, description: $.request.description, toolUseID: $.request.tool_use_id, agentID: $.request.agent_id }), toolUseID: $.request.tool_use_id }; + } else if ($.request.subtype === "hook_callback") return await this.handleHookCallbacks($.request.callback_id, $.request.input, $.request.tool_use_id, X); + else if ($.request.subtype === "mcp_message") { + let J = $.request, Q = this.sdkMcpTransports.get(J.server_name); + if (!Q) throw Error(`SDK MCP server not found: ${J.server_name}`); + if ("method" in J.message && "id" in J.message && J.message.id !== null) return { mcp_response: await this.handleMcpControlRequest(J.server_name, J, Q) }; + else { + if (Q.onmessage) Q.onmessage(J.message); + return { mcp_response: { jsonrpc: "2.0", result: {}, id: 0 } }; + } + } else if ($.request.subtype === "elicitation") { + let J = $.request; + if (this.onElicitation) return await this.onElicitation({ serverName: J.mcp_server_name, message: J.message, mode: J.mode, url: J.url, elicitationId: J.elicitation_id, requestedSchema: J.requested_schema }, { signal: X }); + return { action: "decline" }; + } + throw Error("Unsupported control request subtype: " + $.request.subtype); + } + async *readSdkMessages() { + for await (let $ of this.inputStream) yield $; + } + async initialize() { + var _a3, _b2, _c, _d, _e; + let $; + if (this.hooks) { + $ = {}; + for (let [Y, z6] of Object.entries(this.hooks)) if (z6.length > 0) $[Y] = z6.map((W) => { + let G = []; + for (let U of W.hooks) { + let H = `hook_${this.nextCallbackId++}`; + this.hookCallbacks.set(H, U), G.push(H); + } + return { matcher: W.matcher, hookCallbackIds: G, timeout: W.timeout }; + }); + } + let X = this.sdkMcpTransports.size > 0 ? Array.from(this.sdkMcpTransports.keys()) : void 0, J = { subtype: "initialize", hooks: $, sdkMcpServers: X, jsonSchema: this.jsonSchema, systemPrompt: (_a3 = this.initConfig) == null ? void 0 : _a3.systemPrompt, appendSystemPrompt: (_b2 = this.initConfig) == null ? void 0 : _b2.appendSystemPrompt, agents: (_c = this.initConfig) == null ? void 0 : _c.agents, promptSuggestions: (_d = this.initConfig) == null ? void 0 : _d.promptSuggestions, agentProgressSummaries: (_e = this.initConfig) == null ? void 0 : _e.agentProgressSummaries }; + return (await this.request(J)).response; + } + async interrupt() { + await this.request({ subtype: "interrupt" }); + } + async setPermissionMode($) { + await this.request({ subtype: "set_permission_mode", mode: $ }); + } + async setModel($) { + await this.request({ subtype: "set_model", model: $ }); + } + async setMaxThinkingTokens($) { + await this.request({ subtype: "set_max_thinking_tokens", max_thinking_tokens: $ }); + } + async applyFlagSettings($) { + await this.request({ subtype: "apply_flag_settings", settings: $ }); + } + async getSettings() { + return (await this.request({ subtype: "get_settings" })).response; + } + async rewindFiles($, X) { + return (await this.request({ subtype: "rewind_files", user_message_id: $, dry_run: X == null ? void 0 : X.dryRun })).response; + } + async cancelAsyncMessage($) { + return (await this.request({ subtype: "cancel_async_message", message_uuid: $ })).response.cancelled; + } + async seedReadState($, X) { + await this.request({ subtype: "seed_read_state", path: $, mtime: X }); + } + async enableRemoteControl($) { + return (await this.request({ subtype: "remote_control", enabled: $ })).response; + } + async setProactive($) { + await this.request({ subtype: "set_proactive", enabled: $ }); + } + async generateSessionTitle($, X) { + return (await this.request({ subtype: "generate_session_title", description: $, persist: X == null ? void 0 : X.persist })).response.title; + } + async askSideQuestion($) { + return (await this.request({ subtype: "side_question", question: $ })).response.response; + } + processPendingPermissionRequests($) { + for (let X of $) if (X.request.subtype === "can_use_tool") this.handleControlRequest(X).catch(() => { + }); + } + request($) { + let X = Math.random().toString(36).substring(2, 15), J = { request_id: X, type: "control_request", request: $ }; + return new Promise((Q, Y) => { + this.pendingControlResponses.set(X, { handler: (z6) => { + if (this.pendingControlResponses.delete(X), z6.subtype === "success") Q(z6); + else if (Y(Error(z6.error)), z6.pending_permission_requests) this.processPendingPermissionRequests(z6.pending_permission_requests); + }, reject: Y }), Promise.resolve(this.transport.write(q$(J) + ` +`)).catch((z6) => { + this.pendingControlResponses.delete(X), Y(z6); + }); + }); + } + initializationResult() { + return this.initialization; + } + async supportedCommands() { + return (await this.initialization).commands; + } + async supportedModels() { + return (await this.initialization).models; + } + async supportedAgents() { + return (await this.initialization).agents; + } + async reconnectMcpServer($) { + await this.request({ subtype: "mcp_reconnect", serverName: $ }); + } + async toggleMcpServer($, X) { + await this.request({ subtype: "mcp_toggle", serverName: $, enabled: X }); + } + async enableChannel($) { + await this.request({ subtype: "channel_enable", serverName: $ }); + } + async mcpAuthenticate($) { + return (await this.request({ subtype: "mcp_authenticate", serverName: $ })).response; + } + async mcpClearAuth($) { + return (await this.request({ subtype: "mcp_clear_auth", serverName: $ })).response; + } + async mcpSubmitOAuthCallbackUrl($, X) { + return (await this.request({ subtype: "mcp_oauth_callback_url", serverName: $, callbackUrl: X })).response; + } + async claudeAuthenticate($) { + return (await this.request({ subtype: "claude_authenticate", loginWithClaudeAi: $ })).response; + } + async claudeOAuthCallback($, X) { + return (await this.request({ subtype: "claude_oauth_callback", authorizationCode: $, state: X })).response; + } + async claudeOAuthWaitForCompletion() { + return (await this.request({ subtype: "claude_oauth_wait_for_completion" })).response; + } + async mcpServerStatus() { + return (await this.request({ subtype: "mcp_status" })).response.mcpServers; + } + async getContextUsage() { + return (await this.request({ subtype: "get_context_usage" })).response; + } + async reloadPlugins() { + return (await this.request({ subtype: "reload_plugins" })).response; + } + async setMcpServers($) { + let X = {}, J = {}; + for (let [G, U] of Object.entries($)) if (U.type === "sdk" && "instance" in U) X[G] = U.instance; + else J[G] = U; + let Q = new Set(this.sdkMcpServerInstances.keys()), Y = new Set(Object.keys(X)); + for (let G of Q) if (!Y.has(G)) await this.disconnectSdkMcpServer(G); + for (let [G, U] of Object.entries(X)) if (!Q.has(G)) this.connectSdkMcpServer(G, U); + let z6 = {}; + for (let G of Object.keys(X)) z6[G] = { type: "sdk", name: G }; + return (await this.request({ subtype: "mcp_set_servers", servers: { ...J, ...z6 } })).response; + } + async accountInfo() { + return (await this.initialization).account; + } + async streamInput($) { + var _a3; + L6("[Query.streamInput] Starting to process input stream"); + try { + let X = 0; + for await (let J of $) { + if (X++, L6(`[Query.streamInput] Processing message ${X}: ${J.type}`), (_a3 = this.abortController) == null ? void 0 : _a3.signal.aborted) break; + await Promise.resolve(this.transport.write(q$(J) + ` +`)); + } + if (L6(`[Query.streamInput] Finished processing ${X} messages from input stream`), X > 0 && this.hasBidirectionalNeeds()) L6("[Query.streamInput] Has bidirectional needs, waiting for first result"), await this.waitForFirstResult(); + L6("[Query] Calling transport.endInput() to close stdin to CLI process"), this.transport.endInput(); + } catch (X) { + if (!(X instanceof a$)) throw X; + } + } + waitForFirstResult() { + if (this.firstResultReceived) return L6("[Query.waitForFirstResult] Result already received, returning immediately"), Promise.resolve(); + return new Promise(($) => { + var _a3, _b2; + if ((_a3 = this.abortController) == null ? void 0 : _a3.signal.aborted) { + $(); + return; + } + (_b2 = this.abortController) == null ? void 0 : _b2.signal.addEventListener("abort", () => $(), { once: true }), this.firstResultReceivedResolve = $; + }); + } + handleHookCallbacks($, X, J, Q) { + let Y = this.hookCallbacks.get($); + if (!Y) throw Error(`No hook callback found for ID: ${$}`); + return Y(X, J, { signal: Q }); + } + connectSdkMcpServer($, X) { + let J = new fz((Q) => this.sendMcpServerMessageToCli($, Q)); + this.sdkMcpTransports.set($, J), this.sdkMcpServerInstances.set($, X), X.connect(J).catch((Q) => { + if (this.sdkMcpTransports.get($) === J) this.sdkMcpTransports.delete($); + if (this.sdkMcpServerInstances.get($) === X) this.sdkMcpServerInstances.delete($); + L6(`[Query.connectSdkMcpServer] Failed to connect MCP server '${$}': ${Q}`, { level: "error" }); + }); + } + async disconnectSdkMcpServer($) { + let X = this.sdkMcpTransports.get($); + if (X) await X.close(), this.sdkMcpTransports.delete($); + this.sdkMcpServerInstances.delete($); + } + sendMcpServerMessageToCli($, X) { + if ("id" in X && X.id !== null && X.id !== void 0) { + let Q = `${$}:${X.id}`, Y = this.pendingMcpResponses.get(Q); + if (Y) { + Y.resolve(X), this.pendingMcpResponses.delete(Q); + return; + } + } + let J = { type: "control_request", request_id: (0, import_crypto2.randomUUID)(), request: { subtype: "mcp_message", server_name: $, message: X } }; + Promise.resolve(this.transport.write(q$(J) + ` +`)).catch((Q) => { + L6(`[Query.sendMcpServerMessageToCli] Transport write failed: ${Q}`, { level: "error" }); + }); + } + handleMcpControlRequest($, X, J) { + let Q = "id" in X.message ? X.message.id : null, Y = `${$}:${Q}`; + return new Promise((z6, W) => { + let G = () => { + this.pendingMcpResponses.delete(Y); + }, U = (K) => { + G(), z6(K); + }, H = (K) => { + G(), W(K); + }; + if (this.pendingMcpResponses.set(Y, { resolve: U, reject: H }), J.onmessage) J.onmessage(X.message); + else { + G(), W(Error("No message handler registered")); + return; + } + }); + } +}; +var bM = (0, import_util6.promisify)(import_child_process2.execFile); +var RJ = Buffer.from('{"type":"attribution-snapshot"'); +var xM = Buffer.from('{"type":"system"'); +var iX = 10; +var TM = Buffer.from([iX]); +var X$; +(function($) { + $.assertEqual = (Y) => { + }; + function X(Y) { + } + $.assertIs = X; + function J(Y) { + throw Error(); + } + $.assertNever = J, $.arrayToEnum = (Y) => { + let z6 = {}; + for (let W of Y) z6[W] = W; + return z6; + }, $.getValidEnumValues = (Y) => { + let z6 = $.objectKeys(Y).filter((G) => typeof Y[Y[G]] !== "number"), W = {}; + for (let G of z6) W[G] = Y[G]; + return $.objectValues(W); + }, $.objectValues = (Y) => { + return $.objectKeys(Y).map(function(z6) { + return Y[z6]; + }); + }, $.objectKeys = typeof Object.keys === "function" ? (Y) => Object.keys(Y) : (Y) => { + let z6 = []; + for (let W in Y) if (Object.prototype.hasOwnProperty.call(Y, W)) z6.push(W); + return z6; + }, $.find = (Y, z6) => { + for (let W of Y) if (z6(W)) return W; + return; + }, $.isInteger = typeof Number.isInteger === "function" ? (Y) => Number.isInteger(Y) : (Y) => typeof Y === "number" && Number.isFinite(Y) && Math.floor(Y) === Y; + function Q(Y, z6 = " | ") { + return Y.map((W) => typeof W === "string" ? `'${W}'` : W).join(z6); + } + $.joinValues = Q, $.jsonStringifyReplacer = (Y, z6) => { + if (typeof z6 === "bigint") return z6.toString(); + return z6; + }; +})(X$ || (X$ = {})); +var sK; +(function($) { + $.mergeShapes = (X, J) => { + return { ...X, ...J }; + }; +})(sK || (sK = {})); +var R = X$.arrayToEnum(["string", "nan", "number", "integer", "float", "boolean", "date", "bigint", "symbol", "function", "undefined", "null", "array", "object", "unknown", "promise", "void", "never", "map", "set"]); +var Y4 = ($) => { + switch (typeof $) { + case "undefined": + return R.undefined; + case "string": + return R.string; + case "number": + return Number.isNaN($) ? R.nan : R.number; + case "boolean": + return R.boolean; + case "function": + return R.function; + case "bigint": + return R.bigint; + case "symbol": + return R.symbol; + case "object": + if (Array.isArray($)) return R.array; + if ($ === null) return R.null; + if ($.then && typeof $.then === "function" && $.catch && typeof $.catch === "function") return R.promise; + if (typeof Map < "u" && $ instanceof Map) return R.map; + if (typeof Set < "u" && $ instanceof Set) return R.set; + if (typeof Date < "u" && $ instanceof Date) return R.date; + return R.object; + default: + return R.unknown; + } +}; +var A = X$.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"]); +var V6 = class _V6 extends Error { + get errors() { + return this.issues; + } + constructor($) { + super(); + this.issues = [], this.addIssue = (J) => { + this.issues = [...this.issues, J]; + }, this.addIssues = (J = []) => { + this.issues = [...this.issues, ...J]; + }; + let X = new.target.prototype; + if (Object.setPrototypeOf) Object.setPrototypeOf(this, X); + else this.__proto__ = X; + this.name = "ZodError", this.issues = $; + } + format($) { + let X = $ || function(Y) { + return Y.message; + }, J = { _errors: [] }, Q = (Y) => { + for (let z6 of Y.issues) if (z6.code === "invalid_union") z6.unionErrors.map(Q); + else if (z6.code === "invalid_return_type") Q(z6.returnTypeError); + else if (z6.code === "invalid_arguments") Q(z6.argumentsError); + else if (z6.path.length === 0) J._errors.push(X(z6)); + else { + let W = J, G = 0; + while (G < z6.path.length) { + let U = z6.path[G]; + if (G !== z6.path.length - 1) W[U] = W[U] || { _errors: [] }; + else W[U] = W[U] || { _errors: [] }, W[U]._errors.push(X(z6)); + W = W[U], G++; + } + } + }; + return Q(this), J; + } + static assert($) { + if (!($ instanceof _V6)) throw Error(`Not a ZodError: ${$}`); + } + toString() { + return this.message; + } + get message() { + return JSON.stringify(this.issues, X$.jsonStringifyReplacer, 2); + } + get isEmpty() { + return this.issues.length === 0; + } + flatten($ = (X) => X.message) { + let X = {}, J = []; + for (let Q of this.issues) if (Q.path.length > 0) { + let Y = Q.path[0]; + X[Y] = X[Y] || [], X[Y].push($(Q)); + } else J.push($(Q)); + return { formErrors: J, fieldErrors: X }; + } + get formErrors() { + return this.flatten(); + } +}; +V6.create = ($) => { + return new V6($); +}; +var qI = ($, X) => { + let J; + switch ($.code) { + case A.invalid_type: + if ($.received === R.undefined) J = "Required"; + else J = `Expected ${$.expected}, received ${$.received}`; + break; + case A.invalid_literal: + J = `Invalid literal value, expected ${JSON.stringify($.expected, X$.jsonStringifyReplacer)}`; + break; + case A.unrecognized_keys: + J = `Unrecognized key(s) in object: ${X$.joinValues($.keys, ", ")}`; + break; + case A.invalid_union: + J = "Invalid input"; + break; + case A.invalid_union_discriminator: + J = `Invalid discriminator value. Expected ${X$.joinValues($.options)}`; + break; + case A.invalid_enum_value: + J = `Invalid enum value. Expected ${X$.joinValues($.options)}, received '${$.received}'`; + break; + case A.invalid_arguments: + J = "Invalid function arguments"; + break; + case A.invalid_return_type: + J = "Invalid function return type"; + break; + case A.invalid_date: + J = "Invalid date"; + break; + case A.invalid_string: + if (typeof $.validation === "object") if ("includes" in $.validation) { + if (J = `Invalid input: must include "${$.validation.includes}"`, typeof $.validation.position === "number") J = `${J} at one or more positions greater than or equal to ${$.validation.position}`; + } else if ("startsWith" in $.validation) J = `Invalid input: must start with "${$.validation.startsWith}"`; + else if ("endsWith" in $.validation) J = `Invalid input: must end with "${$.validation.endsWith}"`; + else X$.assertNever($.validation); + else if ($.validation !== "regex") J = `Invalid ${$.validation}`; + else J = "Invalid"; + break; + case A.too_small: + if ($.type === "array") J = `Array must contain ${$.exact ? "exactly" : $.inclusive ? "at least" : "more than"} ${$.minimum} element(s)`; + else if ($.type === "string") J = `String must contain ${$.exact ? "exactly" : $.inclusive ? "at least" : "over"} ${$.minimum} character(s)`; + else if ($.type === "number") J = `Number must be ${$.exact ? "exactly equal to " : $.inclusive ? "greater than or equal to " : "greater than "}${$.minimum}`; + else if ($.type === "bigint") J = `Number must be ${$.exact ? "exactly equal to " : $.inclusive ? "greater than or equal to " : "greater than "}${$.minimum}`; + else if ($.type === "date") J = `Date must be ${$.exact ? "exactly equal to " : $.inclusive ? "greater than or equal to " : "greater than "}${new Date(Number($.minimum))}`; + else J = "Invalid input"; + break; + case A.too_big: + if ($.type === "array") J = `Array must contain ${$.exact ? "exactly" : $.inclusive ? "at most" : "less than"} ${$.maximum} element(s)`; + else if ($.type === "string") J = `String must contain ${$.exact ? "exactly" : $.inclusive ? "at most" : "under"} ${$.maximum} character(s)`; + else if ($.type === "number") J = `Number must be ${$.exact ? "exactly" : $.inclusive ? "less than or equal to" : "less than"} ${$.maximum}`; + else if ($.type === "bigint") J = `BigInt must be ${$.exact ? "exactly" : $.inclusive ? "less than or equal to" : "less than"} ${$.maximum}`; + else if ($.type === "date") J = `Date must be ${$.exact ? "exactly" : $.inclusive ? "smaller than or equal to" : "smaller than"} ${new Date(Number($.maximum))}`; + else J = "Invalid input"; + break; + case A.custom: + J = "Invalid input"; + break; + case A.invalid_intersection_types: + J = "Intersection results could not be merged"; + break; + case A.not_multiple_of: + J = `Number must be a multiple of ${$.multipleOf}`; + break; + case A.not_finite: + J = "Number must be finite"; + break; + default: + J = X.defaultError, X$.assertNever($); + } + return { message: J }; +}; +var S4 = qI; +var DI = S4; +function rX() { + return DI; +} +var _J = ($) => { + let { data: X, path: J, errorMaps: Q, issueData: Y } = $, z6 = [...J, ...Y.path || []], W = { ...Y, path: z6 }; + if (Y.message !== void 0) return { ...Y, path: z6, message: Y.message }; + let G = "", U = Q.filter((H) => !!H).slice().reverse(); + for (let H of U) G = H(W, { data: X, defaultError: G }).message; + return { ...Y, path: z6, message: G }; +}; +function C($, X) { + let J = rX(), Q = _J({ issueData: X, data: $.data, path: $.path, errorMaps: [$.common.contextualErrorMap, $.schemaErrorMap, J, J === S4 ? void 0 : S4].filter((Y) => !!Y) }); + $.common.issues.push(Q); +} +var u$ = class _u$ { + constructor() { + this.value = "valid"; + } + dirty() { + if (this.value === "valid") this.value = "dirty"; + } + abort() { + if (this.value !== "aborted") this.value = "aborted"; + } + static mergeArray($, X) { + let J = []; + for (let Q of X) { + if (Q.status === "aborted") return l; + if (Q.status === "dirty") $.dirty(); + J.push(Q.value); + } + return { status: $.value, value: J }; + } + static async mergeObjectAsync($, X) { + let J = []; + for (let Q of X) { + let Y = await Q.key, z6 = await Q.value; + J.push({ key: Y, value: z6 }); + } + return _u$.mergeObjectSync($, J); + } + static mergeObjectSync($, X) { + let J = {}; + for (let Q of X) { + let { key: Y, value: z6 } = Q; + if (Y.status === "aborted") return l; + if (z6.status === "aborted") return l; + if (Y.status === "dirty") $.dirty(); + if (z6.status === "dirty") $.dirty(); + if (Y.value !== "__proto__" && (typeof z6.value < "u" || Q.alwaysSet)) J[Y.value] = z6.value; + } + return { status: $.value, value: J }; + } +}; +var l = Object.freeze({ status: "aborted" }); +var z0 = ($) => ({ status: "dirty", value: $ }); +var n$ = ($) => ({ status: "valid", value: $ }); +var sz = ($) => $.status === "aborted"; +var ez = ($) => $.status === "dirty"; +var w1 = ($) => $.status === "valid"; +var oX = ($) => typeof Promise < "u" && $ instanceof Promise; +var y; +(function($) { + $.errToObj = (X) => typeof X === "string" ? { message: X } : X || {}, $.toString = (X) => typeof X === "string" ? X : X == null ? void 0 : X.message; +})(y || (y = {})); +var v6 = class { + constructor($, X, J, Q) { + this._cachedPath = [], this.parent = $, this.data = X, this._path = J, this._key = Q; + } + get path() { + if (!this._cachedPath.length) if (Array.isArray(this._key)) this._cachedPath.push(...this._path, ...this._key); + else this._cachedPath.push(...this._path, this._key); + return this._cachedPath; + } +}; +var eK = ($, X) => { + if (w1(X)) return { success: true, data: X.value }; + else { + if (!$.common.issues.length) throw Error("Validation failed but no issues detected."); + return { success: false, get error() { + if (this._error) return this._error; + let J = new V6($.common.issues); + return this._error = J, this._error; + } }; + } +}; +function o($) { + if (!$) return {}; + let { errorMap: X, invalid_type_error: J, required_error: Q, description: Y } = $; + if (X && (J || Q)) throw Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`); + if (X) return { errorMap: X, description: Y }; + return { errorMap: (W, G) => { + var _a3, _b2; + let { message: U } = $; + if (W.code === "invalid_enum_value") return { message: U != null ? U : G.defaultError }; + if (typeof G.data > "u") return { message: (_a3 = U != null ? U : Q) != null ? _a3 : G.defaultError }; + if (W.code !== "invalid_type") return { message: G.defaultError }; + return { message: (_b2 = U != null ? U : J) != null ? _b2 : G.defaultError }; + }, description: Y }; +} +var e = class { + get description() { + return this._def.description; + } + _getType($) { + return Y4($.data); + } + _getOrReturnCtx($, X) { + return X || { common: $.parent.common, data: $.data, parsedType: Y4($.data), schemaErrorMap: this._def.errorMap, path: $.path, parent: $.parent }; + } + _processInputParams($) { + return { status: new u$(), ctx: { common: $.parent.common, data: $.data, parsedType: Y4($.data), schemaErrorMap: this._def.errorMap, path: $.path, parent: $.parent } }; + } + _parseSync($) { + let X = this._parse($); + if (oX(X)) throw Error("Synchronous parse encountered promise."); + return X; + } + _parseAsync($) { + let X = this._parse($); + return Promise.resolve(X); + } + parse($, X) { + let J = this.safeParse($, X); + if (J.success) return J.data; + throw J.error; + } + safeParse($, X) { + var _a3; + let J = { common: { issues: [], async: (_a3 = X == null ? void 0 : X.async) != null ? _a3 : false, contextualErrorMap: X == null ? void 0 : X.errorMap }, path: (X == null ? void 0 : X.path) || [], schemaErrorMap: this._def.errorMap, parent: null, data: $, parsedType: Y4($) }, Q = this._parseSync({ data: $, path: J.path, parent: J }); + return eK(J, Q); + } + "~validate"($) { + var _a3, _b2; + let X = { common: { issues: [], async: !!this["~standard"].async }, path: [], schemaErrorMap: this._def.errorMap, parent: null, data: $, parsedType: Y4($) }; + if (!this["~standard"].async) try { + let J = this._parseSync({ data: $, path: [], parent: X }); + return w1(J) ? { value: J.value } : { issues: X.common.issues }; + } catch (J) { + if ((_b2 = (_a3 = J == null ? void 0 : J.message) == null ? void 0 : _a3.toLowerCase()) == null ? void 0 : _b2.includes("encountered")) this["~standard"].async = true; + X.common = { issues: [], async: true }; + } + return this._parseAsync({ data: $, path: [], parent: X }).then((J) => w1(J) ? { value: J.value } : { issues: X.common.issues }); + } + async parseAsync($, X) { + let J = await this.safeParseAsync($, X); + if (J.success) return J.data; + throw J.error; + } + async safeParseAsync($, X) { + let J = { common: { issues: [], contextualErrorMap: X == null ? void 0 : X.errorMap, async: true }, path: (X == null ? void 0 : X.path) || [], schemaErrorMap: this._def.errorMap, parent: null, data: $, parsedType: Y4($) }, Q = this._parse({ data: $, path: J.path, parent: J }), Y = await (oX(Q) ? Q : Promise.resolve(Q)); + return eK(J, Y); + } + refine($, X) { + let J = (Q) => { + if (typeof X === "string" || typeof X > "u") return { message: X }; + else if (typeof X === "function") return X(Q); + else return X; + }; + return this._refinement((Q, Y) => { + let z6 = $(Q), W = () => Y.addIssue({ code: A.custom, ...J(Q) }); + if (typeof Promise < "u" && z6 instanceof Promise) return z6.then((G) => { + if (!G) return W(), false; + else return true; + }); + if (!z6) return W(), false; + else return true; + }); + } + refinement($, X) { + return this._refinement((J, Q) => { + if (!$(J)) return Q.addIssue(typeof X === "function" ? X(J, Q) : X), false; + else return true; + }); + } + _refinement($) { + return new p6({ schema: this, typeName: P.ZodEffects, effect: { type: "refinement", refinement: $ } }); + } + superRefine($) { + return this._refinement($); + } + constructor($) { + this.spa = this.safeParseAsync, this._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), this["~standard"] = { version: 1, vendor: "zod", validate: (X) => this["~validate"](X) }; + } + optional() { + return M6.create(this, this._def); + } + nullable() { + return v4.create(this, this._def); + } + nullish() { + return this.nullable().optional(); + } + array() { + return c6.create(this); + } + promise() { + return K0.create(this, this._def); + } + or($) { + return $8.create([this, $], this._def); + } + and($) { + return X8.create(this, $, this._def); + } + transform($) { + return new p6({ ...o(this._def), schema: this, typeName: P.ZodEffects, effect: { type: "transform", transform: $ } }); + } + default($) { + let X = typeof $ === "function" ? $ : () => $; + return new z8({ ...o(this._def), innerType: this, defaultValue: X, typeName: P.ZodDefault }); + } + brand() { + return new Y5({ typeName: P.ZodBranded, type: this, ...o(this._def) }); + } + catch($) { + let X = typeof $ === "function" ? $ : () => $; + return new W8({ ...o(this._def), innerType: this, catchValue: X, typeName: P.ZodCatch }); + } + describe($) { + return new this.constructor({ ...this._def, description: $ }); + } + pipe($) { + return mJ.create(this, $); + } + readonly() { + return G8.create(this); + } + isOptional() { + return this.safeParse(void 0).success; + } + isNullable() { + return this.safeParse(null).success; + } +}; +var LI = /^c[^\s-]{8,}$/i; +var jI = /^[0-9a-z]+$/; +var FI = /^[0-9A-HJKMNP-TV-Z]{26}$/i; +var MI = /^[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; +var II = /^[a-z0-9_-]{21}$/i; +var AI = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/; +var bI = /^[-+]?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)?)??$/; +var PI = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i; +var ZI = "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$"; +var $5; +var EI = /^(?:(?: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])$/; +var RI = /^(?:(?: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])\/(3[0-2]|[12]?[0-9])$/; +var SI = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/; +var vI = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/; +var CI = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/; +var kI = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/; +var $N = "((\\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])))"; +var _I = new RegExp(`^${$N}$`); +function XN($) { + let X = "[0-5]\\d"; + if ($.precision) X = `${X}\\.\\d{${$.precision}}`; + else if ($.precision == null) X = `${X}(\\.\\d+)?`; + let J = $.precision ? "+" : "?"; + return `([01]\\d|2[0-3]):[0-5]\\d(:${X})${J}`; +} +function xI($) { + return new RegExp(`^${XN($)}$`); +} +function TI($) { + let X = `${$N}T${XN($)}`, J = []; + if (J.push($.local ? "Z?" : "Z"), $.offset) J.push("([+-]\\d{2}:?\\d{2})"); + return X = `${X}(${J.join("|")})`, new RegExp(`^${X}$`); +} +function yI($, X) { + if ((X === "v4" || !X) && EI.test($)) return true; + if ((X === "v6" || !X) && SI.test($)) return true; + return false; +} +function fI($, X) { + if (!AI.test($)) return false; + try { + let [J] = $.split("."); + if (!J) return false; + let Q = J.replace(/-/g, "+").replace(/_/g, "/").padEnd(J.length + (4 - J.length % 4) % 4, "="), Y = JSON.parse(atob(Q)); + if (typeof Y !== "object" || Y === null) return false; + if ("typ" in Y && (Y == null ? void 0 : Y.typ) !== "JWT") return false; + if (!Y.alg) return false; + if (X && Y.alg !== X) return false; + return true; + } catch (e3) { + return false; + } +} +function gI($, X) { + if ((X === "v4" || !X) && RI.test($)) return true; + if ((X === "v6" || !X) && vI.test($)) return true; + return false; +} +var z4 = class _z4 extends e { + _parse($) { + if (this._def.coerce) $.data = String($.data); + if (this._getType($) !== R.string) { + let Y = this._getOrReturnCtx($); + return C(Y, { code: A.invalid_type, expected: R.string, received: Y.parsedType }), l; + } + let J = new u$(), Q = void 0; + for (let Y of this._def.checks) if (Y.kind === "min") { + if ($.data.length < Y.value) Q = this._getOrReturnCtx($, Q), C(Q, { code: A.too_small, minimum: Y.value, type: "string", inclusive: true, exact: false, message: Y.message }), J.dirty(); + } else if (Y.kind === "max") { + if ($.data.length > Y.value) Q = this._getOrReturnCtx($, Q), C(Q, { code: A.too_big, maximum: Y.value, type: "string", inclusive: true, exact: false, message: Y.message }), J.dirty(); + } else if (Y.kind === "length") { + let z6 = $.data.length > Y.value, W = $.data.length < Y.value; + if (z6 || W) { + if (Q = this._getOrReturnCtx($, Q), z6) C(Q, { code: A.too_big, maximum: Y.value, type: "string", inclusive: true, exact: true, message: Y.message }); + else if (W) C(Q, { code: A.too_small, minimum: Y.value, type: "string", inclusive: true, exact: true, message: Y.message }); + J.dirty(); + } + } else if (Y.kind === "email") { + if (!PI.test($.data)) Q = this._getOrReturnCtx($, Q), C(Q, { validation: "email", code: A.invalid_string, message: Y.message }), J.dirty(); + } else if (Y.kind === "emoji") { + if (!$5) $5 = new RegExp(ZI, "u"); + if (!$5.test($.data)) Q = this._getOrReturnCtx($, Q), C(Q, { validation: "emoji", code: A.invalid_string, message: Y.message }), J.dirty(); + } else if (Y.kind === "uuid") { + if (!MI.test($.data)) Q = this._getOrReturnCtx($, Q), C(Q, { validation: "uuid", code: A.invalid_string, message: Y.message }), J.dirty(); + } else if (Y.kind === "nanoid") { + if (!II.test($.data)) Q = this._getOrReturnCtx($, Q), C(Q, { validation: "nanoid", code: A.invalid_string, message: Y.message }), J.dirty(); + } else if (Y.kind === "cuid") { + if (!LI.test($.data)) Q = this._getOrReturnCtx($, Q), C(Q, { validation: "cuid", code: A.invalid_string, message: Y.message }), J.dirty(); + } else if (Y.kind === "cuid2") { + if (!jI.test($.data)) Q = this._getOrReturnCtx($, Q), C(Q, { validation: "cuid2", code: A.invalid_string, message: Y.message }), J.dirty(); + } else if (Y.kind === "ulid") { + if (!FI.test($.data)) Q = this._getOrReturnCtx($, Q), C(Q, { validation: "ulid", code: A.invalid_string, message: Y.message }), J.dirty(); + } else if (Y.kind === "url") try { + new URL($.data); + } catch (e3) { + Q = this._getOrReturnCtx($, Q), C(Q, { validation: "url", code: A.invalid_string, message: Y.message }), J.dirty(); + } + else if (Y.kind === "regex") { + if (Y.regex.lastIndex = 0, !Y.regex.test($.data)) Q = this._getOrReturnCtx($, Q), C(Q, { validation: "regex", code: A.invalid_string, message: Y.message }), J.dirty(); + } else if (Y.kind === "trim") $.data = $.data.trim(); + else if (Y.kind === "includes") { + if (!$.data.includes(Y.value, Y.position)) Q = this._getOrReturnCtx($, Q), C(Q, { code: A.invalid_string, validation: { includes: Y.value, position: Y.position }, message: Y.message }), J.dirty(); + } else if (Y.kind === "toLowerCase") $.data = $.data.toLowerCase(); + else if (Y.kind === "toUpperCase") $.data = $.data.toUpperCase(); + else if (Y.kind === "startsWith") { + if (!$.data.startsWith(Y.value)) Q = this._getOrReturnCtx($, Q), C(Q, { code: A.invalid_string, validation: { startsWith: Y.value }, message: Y.message }), J.dirty(); + } else if (Y.kind === "endsWith") { + if (!$.data.endsWith(Y.value)) Q = this._getOrReturnCtx($, Q), C(Q, { code: A.invalid_string, validation: { endsWith: Y.value }, message: Y.message }), J.dirty(); + } else if (Y.kind === "datetime") { + if (!TI(Y).test($.data)) Q = this._getOrReturnCtx($, Q), C(Q, { code: A.invalid_string, validation: "datetime", message: Y.message }), J.dirty(); + } else if (Y.kind === "date") { + if (!_I.test($.data)) Q = this._getOrReturnCtx($, Q), C(Q, { code: A.invalid_string, validation: "date", message: Y.message }), J.dirty(); + } else if (Y.kind === "time") { + if (!xI(Y).test($.data)) Q = this._getOrReturnCtx($, Q), C(Q, { code: A.invalid_string, validation: "time", message: Y.message }), J.dirty(); + } else if (Y.kind === "duration") { + if (!bI.test($.data)) Q = this._getOrReturnCtx($, Q), C(Q, { validation: "duration", code: A.invalid_string, message: Y.message }), J.dirty(); + } else if (Y.kind === "ip") { + if (!yI($.data, Y.version)) Q = this._getOrReturnCtx($, Q), C(Q, { validation: "ip", code: A.invalid_string, message: Y.message }), J.dirty(); + } else if (Y.kind === "jwt") { + if (!fI($.data, Y.alg)) Q = this._getOrReturnCtx($, Q), C(Q, { validation: "jwt", code: A.invalid_string, message: Y.message }), J.dirty(); + } else if (Y.kind === "cidr") { + if (!gI($.data, Y.version)) Q = this._getOrReturnCtx($, Q), C(Q, { validation: "cidr", code: A.invalid_string, message: Y.message }), J.dirty(); + } else if (Y.kind === "base64") { + if (!CI.test($.data)) Q = this._getOrReturnCtx($, Q), C(Q, { validation: "base64", code: A.invalid_string, message: Y.message }), J.dirty(); + } else if (Y.kind === "base64url") { + if (!kI.test($.data)) Q = this._getOrReturnCtx($, Q), C(Q, { validation: "base64url", code: A.invalid_string, message: Y.message }), J.dirty(); + } else X$.assertNever(Y); + return { status: J.value, value: $.data }; + } + _regex($, X, J) { + return this.refinement((Q) => $.test(Q), { validation: X, code: A.invalid_string, ...y.errToObj(J) }); + } + _addCheck($) { + return new _z4({ ...this._def, checks: [...this._def.checks, $] }); + } + email($) { + return this._addCheck({ kind: "email", ...y.errToObj($) }); + } + url($) { + return this._addCheck({ kind: "url", ...y.errToObj($) }); + } + emoji($) { + return this._addCheck({ kind: "emoji", ...y.errToObj($) }); + } + uuid($) { + return this._addCheck({ kind: "uuid", ...y.errToObj($) }); + } + nanoid($) { + return this._addCheck({ kind: "nanoid", ...y.errToObj($) }); + } + cuid($) { + return this._addCheck({ kind: "cuid", ...y.errToObj($) }); + } + cuid2($) { + return this._addCheck({ kind: "cuid2", ...y.errToObj($) }); + } + ulid($) { + return this._addCheck({ kind: "ulid", ...y.errToObj($) }); + } + base64($) { + return this._addCheck({ kind: "base64", ...y.errToObj($) }); + } + base64url($) { + return this._addCheck({ kind: "base64url", ...y.errToObj($) }); + } + jwt($) { + return this._addCheck({ kind: "jwt", ...y.errToObj($) }); + } + ip($) { + return this._addCheck({ kind: "ip", ...y.errToObj($) }); + } + cidr($) { + return this._addCheck({ kind: "cidr", ...y.errToObj($) }); + } + datetime($) { + var _a3, _b2; + if (typeof $ === "string") return this._addCheck({ kind: "datetime", precision: null, offset: false, local: false, message: $ }); + return this._addCheck({ kind: "datetime", precision: typeof ($ == null ? void 0 : $.precision) > "u" ? null : $ == null ? void 0 : $.precision, offset: (_a3 = $ == null ? void 0 : $.offset) != null ? _a3 : false, local: (_b2 = $ == null ? void 0 : $.local) != null ? _b2 : false, ...y.errToObj($ == null ? void 0 : $.message) }); + } + date($) { + return this._addCheck({ kind: "date", message: $ }); + } + time($) { + if (typeof $ === "string") return this._addCheck({ kind: "time", precision: null, message: $ }); + return this._addCheck({ kind: "time", precision: typeof ($ == null ? void 0 : $.precision) > "u" ? null : $ == null ? void 0 : $.precision, ...y.errToObj($ == null ? void 0 : $.message) }); + } + duration($) { + return this._addCheck({ kind: "duration", ...y.errToObj($) }); + } + regex($, X) { + return this._addCheck({ kind: "regex", regex: $, ...y.errToObj(X) }); + } + includes($, X) { + return this._addCheck({ kind: "includes", value: $, position: X == null ? void 0 : X.position, ...y.errToObj(X == null ? void 0 : X.message) }); + } + startsWith($, X) { + return this._addCheck({ kind: "startsWith", value: $, ...y.errToObj(X) }); + } + endsWith($, X) { + return this._addCheck({ kind: "endsWith", value: $, ...y.errToObj(X) }); + } + min($, X) { + return this._addCheck({ kind: "min", value: $, ...y.errToObj(X) }); + } + max($, X) { + return this._addCheck({ kind: "max", value: $, ...y.errToObj(X) }); + } + length($, X) { + return this._addCheck({ kind: "length", value: $, ...y.errToObj(X) }); + } + nonempty($) { + return this.min(1, y.errToObj($)); + } + trim() { + return new _z4({ ...this._def, checks: [...this._def.checks, { kind: "trim" }] }); + } + toLowerCase() { + return new _z4({ ...this._def, checks: [...this._def.checks, { kind: "toLowerCase" }] }); + } + toUpperCase() { + return new _z4({ ...this._def, checks: [...this._def.checks, { kind: "toUpperCase" }] }); + } + get isDatetime() { + return !!this._def.checks.find(($) => $.kind === "datetime"); + } + get isDate() { + return !!this._def.checks.find(($) => $.kind === "date"); + } + get isTime() { + return !!this._def.checks.find(($) => $.kind === "time"); + } + get isDuration() { + return !!this._def.checks.find(($) => $.kind === "duration"); + } + get isEmail() { + return !!this._def.checks.find(($) => $.kind === "email"); + } + get isURL() { + return !!this._def.checks.find(($) => $.kind === "url"); + } + get isEmoji() { + return !!this._def.checks.find(($) => $.kind === "emoji"); + } + get isUUID() { + return !!this._def.checks.find(($) => $.kind === "uuid"); + } + get isNANOID() { + return !!this._def.checks.find(($) => $.kind === "nanoid"); + } + get isCUID() { + return !!this._def.checks.find(($) => $.kind === "cuid"); + } + get isCUID2() { + return !!this._def.checks.find(($) => $.kind === "cuid2"); + } + get isULID() { + return !!this._def.checks.find(($) => $.kind === "ulid"); + } + get isIP() { + return !!this._def.checks.find(($) => $.kind === "ip"); + } + get isCIDR() { + return !!this._def.checks.find(($) => $.kind === "cidr"); + } + get isBase64() { + return !!this._def.checks.find(($) => $.kind === "base64"); + } + get isBase64url() { + return !!this._def.checks.find(($) => $.kind === "base64url"); + } + get minLength() { + let $ = null; + for (let X of this._def.checks) if (X.kind === "min") { + if ($ === null || X.value > $) $ = X.value; + } + return $; + } + get maxLength() { + let $ = null; + for (let X of this._def.checks) if (X.kind === "max") { + if ($ === null || X.value < $) $ = X.value; + } + return $; + } +}; +z4.create = ($) => { + var _a3; + return new z4({ checks: [], typeName: P.ZodString, coerce: (_a3 = $ == null ? void 0 : $.coerce) != null ? _a3 : false, ...o($) }); +}; +function hI($, X) { + let J = ($.toString().split(".")[1] || "").length, Q = (X.toString().split(".")[1] || "").length, Y = J > Q ? J : Q, z6 = Number.parseInt($.toFixed(Y).replace(".", "")), W = Number.parseInt(X.toFixed(Y).replace(".", "")); + return z6 % W / 10 ** Y; +} +var G0 = class _G0 extends e { + constructor() { + super(...arguments); + this.min = this.gte, this.max = this.lte, this.step = this.multipleOf; + } + _parse($) { + if (this._def.coerce) $.data = Number($.data); + if (this._getType($) !== R.number) { + let Y = this._getOrReturnCtx($); + return C(Y, { code: A.invalid_type, expected: R.number, received: Y.parsedType }), l; + } + let J = void 0, Q = new u$(); + for (let Y of this._def.checks) if (Y.kind === "int") { + if (!X$.isInteger($.data)) J = this._getOrReturnCtx($, J), C(J, { code: A.invalid_type, expected: "integer", received: "float", message: Y.message }), Q.dirty(); + } else if (Y.kind === "min") { + if (Y.inclusive ? $.data < Y.value : $.data <= Y.value) J = this._getOrReturnCtx($, J), C(J, { code: A.too_small, minimum: Y.value, type: "number", inclusive: Y.inclusive, exact: false, message: Y.message }), Q.dirty(); + } else if (Y.kind === "max") { + if (Y.inclusive ? $.data > Y.value : $.data >= Y.value) J = this._getOrReturnCtx($, J), C(J, { code: A.too_big, maximum: Y.value, type: "number", inclusive: Y.inclusive, exact: false, message: Y.message }), Q.dirty(); + } else if (Y.kind === "multipleOf") { + if (hI($.data, Y.value) !== 0) J = this._getOrReturnCtx($, J), C(J, { code: A.not_multiple_of, multipleOf: Y.value, message: Y.message }), Q.dirty(); + } else if (Y.kind === "finite") { + if (!Number.isFinite($.data)) J = this._getOrReturnCtx($, J), C(J, { code: A.not_finite, message: Y.message }), Q.dirty(); + } else X$.assertNever(Y); + return { status: Q.value, value: $.data }; + } + gte($, X) { + return this.setLimit("min", $, true, y.toString(X)); + } + gt($, X) { + return this.setLimit("min", $, false, y.toString(X)); + } + lte($, X) { + return this.setLimit("max", $, true, y.toString(X)); + } + lt($, X) { + return this.setLimit("max", $, false, y.toString(X)); + } + setLimit($, X, J, Q) { + return new _G0({ ...this._def, checks: [...this._def.checks, { kind: $, value: X, inclusive: J, message: y.toString(Q) }] }); + } + _addCheck($) { + return new _G0({ ...this._def, checks: [...this._def.checks, $] }); + } + int($) { + return this._addCheck({ kind: "int", message: y.toString($) }); + } + positive($) { + return this._addCheck({ kind: "min", value: 0, inclusive: false, message: y.toString($) }); + } + negative($) { + return this._addCheck({ kind: "max", value: 0, inclusive: false, message: y.toString($) }); + } + nonpositive($) { + return this._addCheck({ kind: "max", value: 0, inclusive: true, message: y.toString($) }); + } + nonnegative($) { + return this._addCheck({ kind: "min", value: 0, inclusive: true, message: y.toString($) }); + } + multipleOf($, X) { + return this._addCheck({ kind: "multipleOf", value: $, message: y.toString(X) }); + } + finite($) { + return this._addCheck({ kind: "finite", message: y.toString($) }); + } + safe($) { + return this._addCheck({ kind: "min", inclusive: true, value: Number.MIN_SAFE_INTEGER, message: y.toString($) })._addCheck({ kind: "max", inclusive: true, value: Number.MAX_SAFE_INTEGER, message: y.toString($) }); + } + get minValue() { + let $ = null; + for (let X of this._def.checks) if (X.kind === "min") { + if ($ === null || X.value > $) $ = X.value; + } + return $; + } + get maxValue() { + let $ = null; + for (let X of this._def.checks) if (X.kind === "max") { + if ($ === null || X.value < $) $ = X.value; + } + return $; + } + get isInt() { + return !!this._def.checks.find(($) => $.kind === "int" || $.kind === "multipleOf" && X$.isInteger($.value)); + } + get isFinite() { + let $ = null, X = null; + for (let J of this._def.checks) if (J.kind === "finite" || J.kind === "int" || J.kind === "multipleOf") return true; + else if (J.kind === "min") { + if (X === null || J.value > X) X = J.value; + } else if (J.kind === "max") { + if ($ === null || J.value < $) $ = J.value; + } + return Number.isFinite(X) && Number.isFinite($); + } +}; +G0.create = ($) => { + return new G0({ checks: [], typeName: P.ZodNumber, coerce: ($ == null ? void 0 : $.coerce) || false, ...o($) }); +}; +var U0 = class _U0 extends e { + constructor() { + super(...arguments); + this.min = this.gte, this.max = this.lte; + } + _parse($) { + if (this._def.coerce) try { + $.data = BigInt($.data); + } catch (e3) { + return this._getInvalidInput($); + } + if (this._getType($) !== R.bigint) return this._getInvalidInput($); + let J = void 0, Q = new u$(); + for (let Y of this._def.checks) if (Y.kind === "min") { + if (Y.inclusive ? $.data < Y.value : $.data <= Y.value) J = this._getOrReturnCtx($, J), C(J, { code: A.too_small, type: "bigint", minimum: Y.value, inclusive: Y.inclusive, message: Y.message }), Q.dirty(); + } else if (Y.kind === "max") { + if (Y.inclusive ? $.data > Y.value : $.data >= Y.value) J = this._getOrReturnCtx($, J), C(J, { code: A.too_big, type: "bigint", maximum: Y.value, inclusive: Y.inclusive, message: Y.message }), Q.dirty(); + } else if (Y.kind === "multipleOf") { + if ($.data % Y.value !== BigInt(0)) J = this._getOrReturnCtx($, J), C(J, { code: A.not_multiple_of, multipleOf: Y.value, message: Y.message }), Q.dirty(); + } else X$.assertNever(Y); + return { status: Q.value, value: $.data }; + } + _getInvalidInput($) { + let X = this._getOrReturnCtx($); + return C(X, { code: A.invalid_type, expected: R.bigint, received: X.parsedType }), l; + } + gte($, X) { + return this.setLimit("min", $, true, y.toString(X)); + } + gt($, X) { + return this.setLimit("min", $, false, y.toString(X)); + } + lte($, X) { + return this.setLimit("max", $, true, y.toString(X)); + } + lt($, X) { + return this.setLimit("max", $, false, y.toString(X)); + } + setLimit($, X, J, Q) { + return new _U0({ ...this._def, checks: [...this._def.checks, { kind: $, value: X, inclusive: J, message: y.toString(Q) }] }); + } + _addCheck($) { + return new _U0({ ...this._def, checks: [...this._def.checks, $] }); + } + positive($) { + return this._addCheck({ kind: "min", value: BigInt(0), inclusive: false, message: y.toString($) }); + } + negative($) { + return this._addCheck({ kind: "max", value: BigInt(0), inclusive: false, message: y.toString($) }); + } + nonpositive($) { + return this._addCheck({ kind: "max", value: BigInt(0), inclusive: true, message: y.toString($) }); + } + nonnegative($) { + return this._addCheck({ kind: "min", value: BigInt(0), inclusive: true, message: y.toString($) }); + } + multipleOf($, X) { + return this._addCheck({ kind: "multipleOf", value: $, message: y.toString(X) }); + } + get minValue() { + let $ = null; + for (let X of this._def.checks) if (X.kind === "min") { + if ($ === null || X.value > $) $ = X.value; + } + return $; + } + get maxValue() { + let $ = null; + for (let X of this._def.checks) if (X.kind === "max") { + if ($ === null || X.value < $) $ = X.value; + } + return $; + } +}; +U0.create = ($) => { + var _a3; + return new U0({ checks: [], typeName: P.ZodBigInt, coerce: (_a3 = $ == null ? void 0 : $.coerce) != null ? _a3 : false, ...o($) }); +}; +var xJ = class extends e { + _parse($) { + if (this._def.coerce) $.data = Boolean($.data); + if (this._getType($) !== R.boolean) { + let J = this._getOrReturnCtx($); + return C(J, { code: A.invalid_type, expected: R.boolean, received: J.parsedType }), l; + } + return n$($.data); + } +}; +xJ.create = ($) => { + return new xJ({ typeName: P.ZodBoolean, coerce: ($ == null ? void 0 : $.coerce) || false, ...o($) }); +}; +var aX = class _aX extends e { + _parse($) { + if (this._def.coerce) $.data = new Date($.data); + if (this._getType($) !== R.date) { + let Y = this._getOrReturnCtx($); + return C(Y, { code: A.invalid_type, expected: R.date, received: Y.parsedType }), l; + } + if (Number.isNaN($.data.getTime())) { + let Y = this._getOrReturnCtx($); + return C(Y, { code: A.invalid_date }), l; + } + let J = new u$(), Q = void 0; + for (let Y of this._def.checks) if (Y.kind === "min") { + if ($.data.getTime() < Y.value) Q = this._getOrReturnCtx($, Q), C(Q, { code: A.too_small, message: Y.message, inclusive: true, exact: false, minimum: Y.value, type: "date" }), J.dirty(); + } else if (Y.kind === "max") { + if ($.data.getTime() > Y.value) Q = this._getOrReturnCtx($, Q), C(Q, { code: A.too_big, message: Y.message, inclusive: true, exact: false, maximum: Y.value, type: "date" }), J.dirty(); + } else X$.assertNever(Y); + return { status: J.value, value: new Date($.data.getTime()) }; + } + _addCheck($) { + return new _aX({ ...this._def, checks: [...this._def.checks, $] }); + } + min($, X) { + return this._addCheck({ kind: "min", value: $.getTime(), message: y.toString(X) }); + } + max($, X) { + return this._addCheck({ kind: "max", value: $.getTime(), message: y.toString(X) }); + } + get minDate() { + let $ = null; + for (let X of this._def.checks) if (X.kind === "min") { + if ($ === null || X.value > $) $ = X.value; + } + return $ != null ? new Date($) : null; + } + get maxDate() { + let $ = null; + for (let X of this._def.checks) if (X.kind === "max") { + if ($ === null || X.value < $) $ = X.value; + } + return $ != null ? new Date($) : null; + } +}; +aX.create = ($) => { + return new aX({ checks: [], coerce: ($ == null ? void 0 : $.coerce) || false, typeName: P.ZodDate, ...o($) }); +}; +var TJ = class extends e { + _parse($) { + if (this._getType($) !== R.symbol) { + let J = this._getOrReturnCtx($); + return C(J, { code: A.invalid_type, expected: R.symbol, received: J.parsedType }), l; + } + return n$($.data); + } +}; +TJ.create = ($) => { + return new TJ({ typeName: P.ZodSymbol, ...o($) }); +}; +var sX = class extends e { + _parse($) { + if (this._getType($) !== R.undefined) { + let J = this._getOrReturnCtx($); + return C(J, { code: A.invalid_type, expected: R.undefined, received: J.parsedType }), l; + } + return n$($.data); + } +}; +sX.create = ($) => { + return new sX({ typeName: P.ZodUndefined, ...o($) }); +}; +var eX = class extends e { + _parse($) { + if (this._getType($) !== R.null) { + let J = this._getOrReturnCtx($); + return C(J, { code: A.invalid_type, expected: R.null, received: J.parsedType }), l; + } + return n$($.data); + } +}; +eX.create = ($) => { + return new eX({ typeName: P.ZodNull, ...o($) }); +}; +var yJ = class extends e { + constructor() { + super(...arguments); + this._any = true; + } + _parse($) { + return n$($.data); + } +}; +yJ.create = ($) => { + return new yJ({ typeName: P.ZodAny, ...o($) }); +}; +var B1 = class extends e { + constructor() { + super(...arguments); + this._unknown = true; + } + _parse($) { + return n$($.data); + } +}; +B1.create = ($) => { + return new B1({ typeName: P.ZodUnknown, ...o($) }); +}; +var W4 = class extends e { + _parse($) { + let X = this._getOrReturnCtx($); + return C(X, { code: A.invalid_type, expected: R.never, received: X.parsedType }), l; + } +}; +W4.create = ($) => { + return new W4({ typeName: P.ZodNever, ...o($) }); +}; +var fJ = class extends e { + _parse($) { + if (this._getType($) !== R.undefined) { + let J = this._getOrReturnCtx($); + return C(J, { code: A.invalid_type, expected: R.void, received: J.parsedType }), l; + } + return n$($.data); + } +}; +fJ.create = ($) => { + return new fJ({ typeName: P.ZodVoid, ...o($) }); +}; +var c6 = class _c6 extends e { + _parse($) { + let { ctx: X, status: J } = this._processInputParams($), Q = this._def; + if (X.parsedType !== R.array) return C(X, { code: A.invalid_type, expected: R.array, received: X.parsedType }), l; + if (Q.exactLength !== null) { + let z6 = X.data.length > Q.exactLength.value, W = X.data.length < Q.exactLength.value; + if (z6 || W) C(X, { code: z6 ? A.too_big : A.too_small, minimum: W ? Q.exactLength.value : void 0, maximum: z6 ? Q.exactLength.value : void 0, type: "array", inclusive: true, exact: true, message: Q.exactLength.message }), J.dirty(); + } + if (Q.minLength !== null) { + if (X.data.length < Q.minLength.value) C(X, { code: A.too_small, minimum: Q.minLength.value, type: "array", inclusive: true, exact: false, message: Q.minLength.message }), J.dirty(); + } + if (Q.maxLength !== null) { + if (X.data.length > Q.maxLength.value) C(X, { code: A.too_big, maximum: Q.maxLength.value, type: "array", inclusive: true, exact: false, message: Q.maxLength.message }), J.dirty(); + } + if (X.common.async) return Promise.all([...X.data].map((z6, W) => { + return Q.type._parseAsync(new v6(X, z6, X.path, W)); + })).then((z6) => { + return u$.mergeArray(J, z6); + }); + let Y = [...X.data].map((z6, W) => { + return Q.type._parseSync(new v6(X, z6, X.path, W)); + }); + return u$.mergeArray(J, Y); + } + get element() { + return this._def.type; + } + min($, X) { + return new _c6({ ...this._def, minLength: { value: $, message: y.toString(X) } }); + } + max($, X) { + return new _c6({ ...this._def, maxLength: { value: $, message: y.toString(X) } }); + } + length($, X) { + return new _c6({ ...this._def, exactLength: { value: $, message: y.toString(X) } }); + } + nonempty($) { + return this.min(1, $); + } +}; +c6.create = ($, X) => { + return new c6({ type: $, minLength: null, maxLength: null, exactLength: null, typeName: P.ZodArray, ...o(X) }); +}; +function W0($) { + if ($ instanceof Z$) { + let X = {}; + for (let J in $.shape) { + let Q = $.shape[J]; + X[J] = M6.create(W0(Q)); + } + return new Z$({ ...$._def, shape: () => X }); + } else if ($ instanceof c6) return new c6({ ...$._def, type: W0($.element) }); + else if ($ instanceof M6) return M6.create(W0($.unwrap())); + else if ($ instanceof v4) return v4.create(W0($.unwrap())); + else if ($ instanceof G4) return G4.create($.items.map((X) => W0(X))); + else return $; +} +var Z$ = class _Z$ extends e { + constructor() { + super(...arguments); + this._cached = null, this.nonstrict = this.passthrough, this.augment = this.extend; + } + _getCached() { + if (this._cached !== null) return this._cached; + let $ = this._def.shape(), X = X$.objectKeys($); + return this._cached = { shape: $, keys: X }, this._cached; + } + _parse($) { + if (this._getType($) !== R.object) { + let U = this._getOrReturnCtx($); + return C(U, { code: A.invalid_type, expected: R.object, received: U.parsedType }), l; + } + let { status: J, ctx: Q } = this._processInputParams($), { shape: Y, keys: z6 } = this._getCached(), W = []; + if (!(this._def.catchall instanceof W4 && this._def.unknownKeys === "strip")) { + for (let U in Q.data) if (!z6.includes(U)) W.push(U); + } + let G = []; + for (let U of z6) { + let H = Y[U], K = Q.data[U]; + G.push({ key: { status: "valid", value: U }, value: H._parse(new v6(Q, K, Q.path, U)), alwaysSet: U in Q.data }); + } + if (this._def.catchall instanceof W4) { + let U = this._def.unknownKeys; + if (U === "passthrough") for (let H of W) G.push({ key: { status: "valid", value: H }, value: { status: "valid", value: Q.data[H] } }); + else if (U === "strict") { + if (W.length > 0) C(Q, { code: A.unrecognized_keys, keys: W }), J.dirty(); + } else if (U === "strip") ; + else throw Error("Internal ZodObject error: invalid unknownKeys value."); + } else { + let U = this._def.catchall; + for (let H of W) { + let K = Q.data[H]; + G.push({ key: { status: "valid", value: H }, value: U._parse(new v6(Q, K, Q.path, H)), alwaysSet: H in Q.data }); + } + } + if (Q.common.async) return Promise.resolve().then(async () => { + let U = []; + for (let H of G) { + let K = await H.key, V = await H.value; + U.push({ key: K, value: V, alwaysSet: H.alwaysSet }); + } + return U; + }).then((U) => { + return u$.mergeObjectSync(J, U); + }); + else return u$.mergeObjectSync(J, G); + } + get shape() { + return this._def.shape(); + } + strict($) { + return y.errToObj, new _Z$({ ...this._def, unknownKeys: "strict", ...$ !== void 0 ? { errorMap: (X, J) => { + var _a3, _b2, _c, _d; + let Q = (_c = (_b2 = (_a3 = this._def).errorMap) == null ? void 0 : _b2.call(_a3, X, J).message) != null ? _c : J.defaultError; + if (X.code === "unrecognized_keys") return { message: (_d = y.errToObj($).message) != null ? _d : Q }; + return { message: Q }; + } } : {} }); + } + strip() { + return new _Z$({ ...this._def, unknownKeys: "strip" }); + } + passthrough() { + return new _Z$({ ...this._def, unknownKeys: "passthrough" }); + } + extend($) { + return new _Z$({ ...this._def, shape: () => ({ ...this._def.shape(), ...$ }) }); + } + merge($) { + return new _Z$({ unknownKeys: $._def.unknownKeys, catchall: $._def.catchall, shape: () => ({ ...this._def.shape(), ...$._def.shape() }), typeName: P.ZodObject }); + } + setKey($, X) { + return this.augment({ [$]: X }); + } + catchall($) { + return new _Z$({ ...this._def, catchall: $ }); + } + pick($) { + let X = {}; + for (let J of X$.objectKeys($)) if ($[J] && this.shape[J]) X[J] = this.shape[J]; + return new _Z$({ ...this._def, shape: () => X }); + } + omit($) { + let X = {}; + for (let J of X$.objectKeys(this.shape)) if (!$[J]) X[J] = this.shape[J]; + return new _Z$({ ...this._def, shape: () => X }); + } + deepPartial() { + return W0(this); + } + partial($) { + let X = {}; + for (let J of X$.objectKeys(this.shape)) { + let Q = this.shape[J]; + if ($ && !$[J]) X[J] = Q; + else X[J] = Q.optional(); + } + return new _Z$({ ...this._def, shape: () => X }); + } + required($) { + let X = {}; + for (let J of X$.objectKeys(this.shape)) if ($ && !$[J]) X[J] = this.shape[J]; + else { + let Y = this.shape[J]; + while (Y instanceof M6) Y = Y._def.innerType; + X[J] = Y; + } + return new _Z$({ ...this._def, shape: () => X }); + } + keyof() { + return JN(X$.objectKeys(this.shape)); + } +}; +Z$.create = ($, X) => { + return new Z$({ shape: () => $, unknownKeys: "strip", catchall: W4.create(), typeName: P.ZodObject, ...o(X) }); +}; +Z$.strictCreate = ($, X) => { + return new Z$({ shape: () => $, unknownKeys: "strict", catchall: W4.create(), typeName: P.ZodObject, ...o(X) }); +}; +Z$.lazycreate = ($, X) => { + return new Z$({ shape: $, unknownKeys: "strip", catchall: W4.create(), typeName: P.ZodObject, ...o(X) }); +}; +var $8 = class extends e { + _parse($) { + let { ctx: X } = this._processInputParams($), J = this._def.options; + function Q(Y) { + for (let W of Y) if (W.result.status === "valid") return W.result; + for (let W of Y) if (W.result.status === "dirty") return X.common.issues.push(...W.ctx.common.issues), W.result; + let z6 = Y.map((W) => new V6(W.ctx.common.issues)); + return C(X, { code: A.invalid_union, unionErrors: z6 }), l; + } + if (X.common.async) return Promise.all(J.map(async (Y) => { + let z6 = { ...X, common: { ...X.common, issues: [] }, parent: null }; + return { result: await Y._parseAsync({ data: X.data, path: X.path, parent: z6 }), ctx: z6 }; + })).then(Q); + else { + let Y = void 0, z6 = []; + for (let G of J) { + let U = { ...X, common: { ...X.common, issues: [] }, parent: null }, H = G._parseSync({ data: X.data, path: X.path, parent: U }); + if (H.status === "valid") return H; + else if (H.status === "dirty" && !Y) Y = { result: H, ctx: U }; + if (U.common.issues.length) z6.push(U.common.issues); + } + if (Y) return X.common.issues.push(...Y.ctx.common.issues), Y.result; + let W = z6.map((G) => new V6(G)); + return C(X, { code: A.invalid_union, unionErrors: W }), l; + } + } + get options() { + return this._def.options; + } +}; +$8.create = ($, X) => { + return new $8({ options: $, typeName: P.ZodUnion, ...o(X) }); +}; +var Q4 = ($) => { + if ($ instanceof J8) return Q4($.schema); + else if ($ instanceof p6) return Q4($.innerType()); + else if ($ instanceof Y8) return [$.value]; + else if ($ instanceof q1) return $.options; + else if ($ instanceof Q8) return X$.objectValues($.enum); + else if ($ instanceof z8) return Q4($._def.innerType); + else if ($ instanceof sX) return [void 0]; + else if ($ instanceof eX) return [null]; + else if ($ instanceof M6) return [void 0, ...Q4($.unwrap())]; + else if ($ instanceof v4) return [null, ...Q4($.unwrap())]; + else if ($ instanceof Y5) return Q4($.unwrap()); + else if ($ instanceof G8) return Q4($.unwrap()); + else if ($ instanceof W8) return Q4($._def.innerType); + else return []; +}; +var J5 = class _J5 extends e { + _parse($) { + let { ctx: X } = this._processInputParams($); + if (X.parsedType !== R.object) return C(X, { code: A.invalid_type, expected: R.object, received: X.parsedType }), l; + let J = this.discriminator, Q = X.data[J], Y = this.optionsMap.get(Q); + if (!Y) return C(X, { code: A.invalid_union_discriminator, options: Array.from(this.optionsMap.keys()), path: [J] }), l; + if (X.common.async) return Y._parseAsync({ data: X.data, path: X.path, parent: X }); + else return Y._parseSync({ data: X.data, path: X.path, parent: X }); + } + get discriminator() { + return this._def.discriminator; + } + get options() { + return this._def.options; + } + get optionsMap() { + return this._def.optionsMap; + } + static create($, X, J) { + let Q = /* @__PURE__ */ new Map(); + for (let Y of X) { + let z6 = Q4(Y.shape[$]); + if (!z6.length) throw Error(`A discriminator value for key \`${$}\` could not be extracted from all schema options`); + for (let W of z6) { + if (Q.has(W)) throw Error(`Discriminator property ${String($)} has duplicate value ${String(W)}`); + Q.set(W, Y); + } + } + return new _J5({ typeName: P.ZodDiscriminatedUnion, discriminator: $, options: X, optionsMap: Q, ...o(J) }); + } +}; +function X5($, X) { + let J = Y4($), Q = Y4(X); + if ($ === X) return { valid: true, data: $ }; + else if (J === R.object && Q === R.object) { + let Y = X$.objectKeys(X), z6 = X$.objectKeys($).filter((G) => Y.indexOf(G) !== -1), W = { ...$, ...X }; + for (let G of z6) { + let U = X5($[G], X[G]); + if (!U.valid) return { valid: false }; + W[G] = U.data; + } + return { valid: true, data: W }; + } else if (J === R.array && Q === R.array) { + if ($.length !== X.length) return { valid: false }; + let Y = []; + for (let z6 = 0; z6 < $.length; z6++) { + let W = $[z6], G = X[z6], U = X5(W, G); + if (!U.valid) return { valid: false }; + Y.push(U.data); + } + return { valid: true, data: Y }; + } else if (J === R.date && Q === R.date && +$ === +X) return { valid: true, data: $ }; + else return { valid: false }; +} +var X8 = class extends e { + _parse($) { + let { status: X, ctx: J } = this._processInputParams($), Q = (Y, z6) => { + if (sz(Y) || sz(z6)) return l; + let W = X5(Y.value, z6.value); + if (!W.valid) return C(J, { code: A.invalid_intersection_types }), l; + if (ez(Y) || ez(z6)) X.dirty(); + return { status: X.value, value: W.data }; + }; + if (J.common.async) return Promise.all([this._def.left._parseAsync({ data: J.data, path: J.path, parent: J }), this._def.right._parseAsync({ data: J.data, path: J.path, parent: J })]).then(([Y, z6]) => Q(Y, z6)); + else return Q(this._def.left._parseSync({ data: J.data, path: J.path, parent: J }), this._def.right._parseSync({ data: J.data, path: J.path, parent: J })); + } +}; +X8.create = ($, X, J) => { + return new X8({ left: $, right: X, typeName: P.ZodIntersection, ...o(J) }); +}; +var G4 = class _G4 extends e { + _parse($) { + let { status: X, ctx: J } = this._processInputParams($); + if (J.parsedType !== R.array) return C(J, { code: A.invalid_type, expected: R.array, received: J.parsedType }), l; + if (J.data.length < this._def.items.length) return C(J, { code: A.too_small, minimum: this._def.items.length, inclusive: true, exact: false, type: "array" }), l; + if (!this._def.rest && J.data.length > this._def.items.length) C(J, { code: A.too_big, maximum: this._def.items.length, inclusive: true, exact: false, type: "array" }), X.dirty(); + let Y = [...J.data].map((z6, W) => { + let G = this._def.items[W] || this._def.rest; + if (!G) return null; + return G._parse(new v6(J, z6, J.path, W)); + }).filter((z6) => !!z6); + if (J.common.async) return Promise.all(Y).then((z6) => { + return u$.mergeArray(X, z6); + }); + else return u$.mergeArray(X, Y); + } + get items() { + return this._def.items; + } + rest($) { + return new _G4({ ...this._def, rest: $ }); + } +}; +G4.create = ($, X) => { + if (!Array.isArray($)) throw Error("You must pass an array of schemas to z.tuple([ ... ])"); + return new G4({ items: $, typeName: P.ZodTuple, rest: null, ...o(X) }); +}; +var gJ = class _gJ extends e { + get keySchema() { + return this._def.keyType; + } + get valueSchema() { + return this._def.valueType; + } + _parse($) { + let { status: X, ctx: J } = this._processInputParams($); + if (J.parsedType !== R.object) return C(J, { code: A.invalid_type, expected: R.object, received: J.parsedType }), l; + let Q = [], Y = this._def.keyType, z6 = this._def.valueType; + for (let W in J.data) Q.push({ key: Y._parse(new v6(J, W, J.path, W)), value: z6._parse(new v6(J, J.data[W], J.path, W)), alwaysSet: W in J.data }); + if (J.common.async) return u$.mergeObjectAsync(X, Q); + else return u$.mergeObjectSync(X, Q); + } + get element() { + return this._def.valueType; + } + static create($, X, J) { + if (X instanceof e) return new _gJ({ keyType: $, valueType: X, typeName: P.ZodRecord, ...o(J) }); + return new _gJ({ keyType: z4.create(), valueType: $, typeName: P.ZodRecord, ...o(X) }); + } +}; +var hJ = class extends e { + get keySchema() { + return this._def.keyType; + } + get valueSchema() { + return this._def.valueType; + } + _parse($) { + let { status: X, ctx: J } = this._processInputParams($); + if (J.parsedType !== R.map) return C(J, { code: A.invalid_type, expected: R.map, received: J.parsedType }), l; + let Q = this._def.keyType, Y = this._def.valueType, z6 = [...J.data.entries()].map(([W, G], U) => { + return { key: Q._parse(new v6(J, W, J.path, [U, "key"])), value: Y._parse(new v6(J, G, J.path, [U, "value"])) }; + }); + if (J.common.async) { + let W = /* @__PURE__ */ new Map(); + return Promise.resolve().then(async () => { + for (let G of z6) { + let U = await G.key, H = await G.value; + if (U.status === "aborted" || H.status === "aborted") return l; + if (U.status === "dirty" || H.status === "dirty") X.dirty(); + W.set(U.value, H.value); + } + return { status: X.value, value: W }; + }); + } else { + let W = /* @__PURE__ */ new Map(); + for (let G of z6) { + let { key: U, value: H } = G; + if (U.status === "aborted" || H.status === "aborted") return l; + if (U.status === "dirty" || H.status === "dirty") X.dirty(); + W.set(U.value, H.value); + } + return { status: X.value, value: W }; + } + } +}; +hJ.create = ($, X, J) => { + return new hJ({ valueType: X, keyType: $, typeName: P.ZodMap, ...o(J) }); +}; +var H0 = class _H0 extends e { + _parse($) { + let { status: X, ctx: J } = this._processInputParams($); + if (J.parsedType !== R.set) return C(J, { code: A.invalid_type, expected: R.set, received: J.parsedType }), l; + let Q = this._def; + if (Q.minSize !== null) { + if (J.data.size < Q.minSize.value) C(J, { code: A.too_small, minimum: Q.minSize.value, type: "set", inclusive: true, exact: false, message: Q.minSize.message }), X.dirty(); + } + if (Q.maxSize !== null) { + if (J.data.size > Q.maxSize.value) C(J, { code: A.too_big, maximum: Q.maxSize.value, type: "set", inclusive: true, exact: false, message: Q.maxSize.message }), X.dirty(); + } + let Y = this._def.valueType; + function z6(G) { + let U = /* @__PURE__ */ new Set(); + for (let H of G) { + if (H.status === "aborted") return l; + if (H.status === "dirty") X.dirty(); + U.add(H.value); + } + return { status: X.value, value: U }; + } + let W = [...J.data.values()].map((G, U) => Y._parse(new v6(J, G, J.path, U))); + if (J.common.async) return Promise.all(W).then((G) => z6(G)); + else return z6(W); + } + min($, X) { + return new _H0({ ...this._def, minSize: { value: $, message: y.toString(X) } }); + } + max($, X) { + return new _H0({ ...this._def, maxSize: { value: $, message: y.toString(X) } }); + } + size($, X) { + return this.min($, X).max($, X); + } + nonempty($) { + return this.min(1, $); + } +}; +H0.create = ($, X) => { + return new H0({ valueType: $, minSize: null, maxSize: null, typeName: P.ZodSet, ...o(X) }); +}; +var tX = class _tX extends e { + constructor() { + super(...arguments); + this.validate = this.implement; + } + _parse($) { + let { ctx: X } = this._processInputParams($); + if (X.parsedType !== R.function) return C(X, { code: A.invalid_type, expected: R.function, received: X.parsedType }), l; + function J(W, G) { + return _J({ data: W, path: X.path, errorMaps: [X.common.contextualErrorMap, X.schemaErrorMap, rX(), S4].filter((U) => !!U), issueData: { code: A.invalid_arguments, argumentsError: G } }); + } + function Q(W, G) { + return _J({ data: W, path: X.path, errorMaps: [X.common.contextualErrorMap, X.schemaErrorMap, rX(), S4].filter((U) => !!U), issueData: { code: A.invalid_return_type, returnTypeError: G } }); + } + let Y = { errorMap: X.common.contextualErrorMap }, z6 = X.data; + if (this._def.returns instanceof K0) { + let W = this; + return n$(async function(...G) { + let U = new V6([]), H = await W._def.args.parseAsync(G, Y).catch((O) => { + throw U.addIssue(J(G, O)), U; + }), K = await Reflect.apply(z6, this, H); + return await W._def.returns._def.type.parseAsync(K, Y).catch((O) => { + throw U.addIssue(Q(K, O)), U; + }); + }); + } else { + let W = this; + return n$(function(...G) { + let U = W._def.args.safeParse(G, Y); + if (!U.success) throw new V6([J(G, U.error)]); + let H = Reflect.apply(z6, this, U.data), K = W._def.returns.safeParse(H, Y); + if (!K.success) throw new V6([Q(H, K.error)]); + return K.data; + }); + } + } + parameters() { + return this._def.args; + } + returnType() { + return this._def.returns; + } + args(...$) { + return new _tX({ ...this._def, args: G4.create($).rest(B1.create()) }); + } + returns($) { + return new _tX({ ...this._def, returns: $ }); + } + implement($) { + return this.parse($); + } + strictImplement($) { + return this.parse($); + } + static create($, X, J) { + return new _tX({ args: $ ? $ : G4.create([]).rest(B1.create()), returns: X || B1.create(), typeName: P.ZodFunction, ...o(J) }); + } +}; +var J8 = class extends e { + get schema() { + return this._def.getter(); + } + _parse($) { + let { ctx: X } = this._processInputParams($); + return this._def.getter()._parse({ data: X.data, path: X.path, parent: X }); + } +}; +J8.create = ($, X) => { + return new J8({ getter: $, typeName: P.ZodLazy, ...o(X) }); +}; +var Y8 = class extends e { + _parse($) { + if ($.data !== this._def.value) { + let X = this._getOrReturnCtx($); + return C(X, { received: X.data, code: A.invalid_literal, expected: this._def.value }), l; + } + return { status: "valid", value: $.data }; + } + get value() { + return this._def.value; + } +}; +Y8.create = ($, X) => { + return new Y8({ value: $, typeName: P.ZodLiteral, ...o(X) }); +}; +function JN($, X) { + return new q1({ values: $, typeName: P.ZodEnum, ...o(X) }); +} +var q1 = class _q1 extends e { + _parse($) { + if (typeof $.data !== "string") { + let X = this._getOrReturnCtx($), J = this._def.values; + return C(X, { expected: X$.joinValues(J), received: X.parsedType, code: A.invalid_type }), l; + } + if (!this._cache) this._cache = new Set(this._def.values); + if (!this._cache.has($.data)) { + let X = this._getOrReturnCtx($), J = this._def.values; + return C(X, { received: X.data, code: A.invalid_enum_value, options: J }), l; + } + return n$($.data); + } + get options() { + return this._def.values; + } + get enum() { + let $ = {}; + for (let X of this._def.values) $[X] = X; + return $; + } + get Values() { + let $ = {}; + for (let X of this._def.values) $[X] = X; + return $; + } + get Enum() { + let $ = {}; + for (let X of this._def.values) $[X] = X; + return $; + } + extract($, X = this._def) { + return _q1.create($, { ...this._def, ...X }); + } + exclude($, X = this._def) { + return _q1.create(this.options.filter((J) => !$.includes(J)), { ...this._def, ...X }); + } +}; +q1.create = JN; +var Q8 = class extends e { + _parse($) { + let X = X$.getValidEnumValues(this._def.values), J = this._getOrReturnCtx($); + if (J.parsedType !== R.string && J.parsedType !== R.number) { + let Q = X$.objectValues(X); + return C(J, { expected: X$.joinValues(Q), received: J.parsedType, code: A.invalid_type }), l; + } + if (!this._cache) this._cache = new Set(X$.getValidEnumValues(this._def.values)); + if (!this._cache.has($.data)) { + let Q = X$.objectValues(X); + return C(J, { received: J.data, code: A.invalid_enum_value, options: Q }), l; + } + return n$($.data); + } + get enum() { + return this._def.values; + } +}; +Q8.create = ($, X) => { + return new Q8({ values: $, typeName: P.ZodNativeEnum, ...o(X) }); +}; +var K0 = class extends e { + unwrap() { + return this._def.type; + } + _parse($) { + let { ctx: X } = this._processInputParams($); + if (X.parsedType !== R.promise && X.common.async === false) return C(X, { code: A.invalid_type, expected: R.promise, received: X.parsedType }), l; + let J = X.parsedType === R.promise ? X.data : Promise.resolve(X.data); + return n$(J.then((Q) => { + return this._def.type.parseAsync(Q, { path: X.path, errorMap: X.common.contextualErrorMap }); + })); + } +}; +K0.create = ($, X) => { + return new K0({ type: $, typeName: P.ZodPromise, ...o(X) }); +}; +var p6 = class extends e { + innerType() { + return this._def.schema; + } + sourceType() { + return this._def.schema._def.typeName === P.ZodEffects ? this._def.schema.sourceType() : this._def.schema; + } + _parse($) { + let { status: X, ctx: J } = this._processInputParams($), Q = this._def.effect || null, Y = { addIssue: (z6) => { + if (C(J, z6), z6.fatal) X.abort(); + else X.dirty(); + }, get path() { + return J.path; + } }; + if (Y.addIssue = Y.addIssue.bind(Y), Q.type === "preprocess") { + let z6 = Q.transform(J.data, Y); + if (J.common.async) return Promise.resolve(z6).then(async (W) => { + if (X.value === "aborted") return l; + let G = await this._def.schema._parseAsync({ data: W, path: J.path, parent: J }); + if (G.status === "aborted") return l; + if (G.status === "dirty") return z0(G.value); + if (X.value === "dirty") return z0(G.value); + return G; + }); + else { + if (X.value === "aborted") return l; + let W = this._def.schema._parseSync({ data: z6, path: J.path, parent: J }); + if (W.status === "aborted") return l; + if (W.status === "dirty") return z0(W.value); + if (X.value === "dirty") return z0(W.value); + return W; + } + } + if (Q.type === "refinement") { + let z6 = (W) => { + let G = Q.refinement(W, Y); + if (J.common.async) return Promise.resolve(G); + if (G instanceof Promise) throw Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead."); + return W; + }; + if (J.common.async === false) { + let W = this._def.schema._parseSync({ data: J.data, path: J.path, parent: J }); + if (W.status === "aborted") return l; + if (W.status === "dirty") X.dirty(); + return z6(W.value), { status: X.value, value: W.value }; + } else return this._def.schema._parseAsync({ data: J.data, path: J.path, parent: J }).then((W) => { + if (W.status === "aborted") return l; + if (W.status === "dirty") X.dirty(); + return z6(W.value).then(() => { + return { status: X.value, value: W.value }; + }); + }); + } + if (Q.type === "transform") if (J.common.async === false) { + let z6 = this._def.schema._parseSync({ data: J.data, path: J.path, parent: J }); + if (!w1(z6)) return l; + let W = Q.transform(z6.value, Y); + if (W instanceof Promise) throw Error("Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead."); + return { status: X.value, value: W }; + } else return this._def.schema._parseAsync({ data: J.data, path: J.path, parent: J }).then((z6) => { + if (!w1(z6)) return l; + return Promise.resolve(Q.transform(z6.value, Y)).then((W) => ({ status: X.value, value: W })); + }); + X$.assertNever(Q); + } +}; +p6.create = ($, X, J) => { + return new p6({ schema: $, typeName: P.ZodEffects, effect: X, ...o(J) }); +}; +p6.createWithPreprocess = ($, X, J) => { + return new p6({ schema: X, effect: { type: "preprocess", transform: $ }, typeName: P.ZodEffects, ...o(J) }); +}; +var M6 = class extends e { + _parse($) { + if (this._getType($) === R.undefined) return n$(void 0); + return this._def.innerType._parse($); + } + unwrap() { + return this._def.innerType; + } +}; +M6.create = ($, X) => { + return new M6({ innerType: $, typeName: P.ZodOptional, ...o(X) }); +}; +var v4 = class extends e { + _parse($) { + if (this._getType($) === R.null) return n$(null); + return this._def.innerType._parse($); + } + unwrap() { + return this._def.innerType; + } +}; +v4.create = ($, X) => { + return new v4({ innerType: $, typeName: P.ZodNullable, ...o(X) }); +}; +var z8 = class extends e { + _parse($) { + let { ctx: X } = this._processInputParams($), J = X.data; + if (X.parsedType === R.undefined) J = this._def.defaultValue(); + return this._def.innerType._parse({ data: J, path: X.path, parent: X }); + } + removeDefault() { + return this._def.innerType; + } +}; +z8.create = ($, X) => { + return new z8({ innerType: $, typeName: P.ZodDefault, defaultValue: typeof X.default === "function" ? X.default : () => X.default, ...o(X) }); +}; +var W8 = class extends e { + _parse($) { + let { ctx: X } = this._processInputParams($), J = { ...X, common: { ...X.common, issues: [] } }, Q = this._def.innerType._parse({ data: J.data, path: J.path, parent: { ...J } }); + if (oX(Q)) return Q.then((Y) => { + return { status: "valid", value: Y.status === "valid" ? Y.value : this._def.catchValue({ get error() { + return new V6(J.common.issues); + }, input: J.data }) }; + }); + else return { status: "valid", value: Q.status === "valid" ? Q.value : this._def.catchValue({ get error() { + return new V6(J.common.issues); + }, input: J.data }) }; + } + removeCatch() { + return this._def.innerType; + } +}; +W8.create = ($, X) => { + return new W8({ innerType: $, typeName: P.ZodCatch, catchValue: typeof X.catch === "function" ? X.catch : () => X.catch, ...o(X) }); +}; +var uJ = class extends e { + _parse($) { + if (this._getType($) !== R.nan) { + let J = this._getOrReturnCtx($); + return C(J, { code: A.invalid_type, expected: R.nan, received: J.parsedType }), l; + } + return { status: "valid", value: $.data }; + } +}; +uJ.create = ($) => { + return new uJ({ typeName: P.ZodNaN, ...o($) }); +}; +var Y5 = class extends e { + _parse($) { + let { ctx: X } = this._processInputParams($), J = X.data; + return this._def.type._parse({ data: J, path: X.path, parent: X }); + } + unwrap() { + return this._def.type; + } +}; +var mJ = class _mJ extends e { + _parse($) { + let { status: X, ctx: J } = this._processInputParams($); + if (J.common.async) return (async () => { + let Y = await this._def.in._parseAsync({ data: J.data, path: J.path, parent: J }); + if (Y.status === "aborted") return l; + if (Y.status === "dirty") return X.dirty(), z0(Y.value); + else return this._def.out._parseAsync({ data: Y.value, path: J.path, parent: J }); + })(); + else { + let Q = this._def.in._parseSync({ data: J.data, path: J.path, parent: J }); + if (Q.status === "aborted") return l; + if (Q.status === "dirty") return X.dirty(), { status: "dirty", value: Q.value }; + else return this._def.out._parseSync({ data: Q.value, path: J.path, parent: J }); + } + } + static create($, X) { + return new _mJ({ in: $, out: X, typeName: P.ZodPipeline }); + } +}; +var G8 = class extends e { + _parse($) { + let X = this._def.innerType._parse($), J = (Q) => { + if (w1(Q)) Q.value = Object.freeze(Q.value); + return Q; + }; + return oX(X) ? X.then((Q) => J(Q)) : J(X); + } + unwrap() { + return this._def.innerType; + } +}; +G8.create = ($, X) => { + return new G8({ innerType: $, typeName: P.ZodReadonly, ...o(X) }); +}; +var rl = { object: Z$.lazycreate }; +var P; +(function($) { + $.ZodString = "ZodString", $.ZodNumber = "ZodNumber", $.ZodNaN = "ZodNaN", $.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", $.ZodEffects = "ZodEffects", $.ZodNativeEnum = "ZodNativeEnum", $.ZodOptional = "ZodOptional", $.ZodNullable = "ZodNullable", $.ZodDefault = "ZodDefault", $.ZodCatch = "ZodCatch", $.ZodPromise = "ZodPromise", $.ZodBranded = "ZodBranded", $.ZodPipeline = "ZodPipeline", $.ZodReadonly = "ZodReadonly"; +})(P || (P = {})); +var ol = z4.create; +var tl = G0.create; +var al = uJ.create; +var sl = U0.create; +var el = xJ.create; +var $c = aX.create; +var Xc = TJ.create; +var Jc = sX.create; +var Yc = eX.create; +var Qc = yJ.create; +var zc = B1.create; +var Wc = W4.create; +var Gc = fJ.create; +var Uc = c6.create; +var YN = Z$.create; +var Hc = Z$.strictCreate; +var Kc = $8.create; +var Nc = J5.create; +var Vc = X8.create; +var Oc = G4.create; +var wc = gJ.create; +var Bc = hJ.create; +var qc = H0.create; +var Dc = tX.create; +var Lc = J8.create; +var jc = Y8.create; +var Fc = q1.create; +var Mc = Q8.create; +var Ic = K0.create; +var Ac = p6.create; +var bc = M6.create; +var Pc = v4.create; +var Zc = p6.createWithPreprocess; +var Ec = mJ.create; +var C6 = {}; +$1(C6, { version: () => GW, util: () => E, treeifyError: () => iJ, toJSONSchema: () => Z0, toDotPath: () => WN, safeParseAsync: () => _4, safeParse: () => k4, registry: () => A8, regexes: () => x4, prettifyError: () => nJ, parseAsync: () => F1, parse: () => j1, locales: () => M0, isValidJWT: () => bN, isValidBase64URL: () => AN, isValidBase64: () => OW, globalRegistry: () => X6, globalConfig: () => U8, function: () => Z7, formatError: () => B0, flattenError: () => w0, config: () => E$, clone: () => m$, _xid: () => T8, _void: () => L7, _uuidv7: () => R8, _uuidv6: () => E8, _uuidv4: () => Z8, _uuid: () => P8, _url: () => S8, _uppercase: () => r8, _unknown: () => A1, _union: () => Y2, _undefined: () => w7, _ulid: () => x8, _uint64: () => V7, _uint32: () => U7, _tuple: () => VG, _trim: () => $9, _transform: () => V2, _toUpperCase: () => J9, _toLowerCase: () => X9, _templateLiteral: () => M2, _symbol: () => O7, _success: () => D2, _stringbool: () => b7, _stringFormat: () => P7, _string: () => X7, _startsWith: () => t8, _size: () => i8, _set: () => U2, _safeParseAsync: () => tJ, _safeParse: () => oJ, _regex: () => n8, _refine: () => A7, _record: () => W2, _readonly: () => F2, _property: () => NG, _promise: () => A2, _positive: () => GG, _pipe: () => j2, _parseAsync: () => rJ, _parse: () => dJ, _overwrite: () => V4, _optional: () => O2, _number: () => Y7, _nullable: () => w2, _null: () => B7, _normalize: () => e8, _nonpositive: () => HG, _nonoptional: () => q2, _nonnegative: () => KG, _never: () => D7, _negative: () => UG, _nativeEnum: () => K2, _nanoid: () => C8, _nan: () => F7, _multipleOf: () => b1, _minSize: () => P1, _minLength: () => f4, _min: () => J6, _mime: () => s8, _maxSize: () => A0, _maxLength: () => b0, _max: () => I6, _map: () => G2, _lte: () => I6, _lt: () => K4, _lowercase: () => d8, _literal: () => N2, _length: () => P0, _lazy: () => I2, _ksuid: () => y8, _jwt: () => p8, _isoTime: () => XG, _isoDuration: () => JG, _isoDateTime: () => eW, _isoDate: () => $G, _ipv6: () => g8, _ipv4: () => f8, _intersection: () => z2, _int64: () => N7, _int32: () => G7, _int: () => Q7, _includes: () => o8, _guid: () => I0, _gte: () => J6, _gt: () => N4, _float64: () => W7, _float32: () => z7, _file: () => M7, _enum: () => H2, _endsWith: () => a8, _emoji: () => v8, _email: () => b8, _e164: () => c8, _discriminatedUnion: () => Q2, _default: () => B2, _date: () => j7, _custom: () => I7, _cuid2: () => _8, _cuid: () => k8, _coercedString: () => sW, _coercedNumber: () => YG, _coercedDate: () => WG, _coercedBoolean: () => QG, _coercedBigint: () => zG, _cidrv6: () => u8, _cidrv4: () => h8, _catch: () => L2, _boolean: () => H7, _bigint: () => K7, _base64url: () => l8, _base64: () => m8, _array: () => Y9, _any: () => q7, TimePrecision: () => J7, NEVER: () => lJ, JSONSchemaGenerator: () => E7, JSONSchema: () => RN, Doc: () => $Y, $output: () => eY, $input: () => $7, $constructor: () => q, $brand: () => cJ, $ZodXID: () => VY, $ZodVoid: () => vY, $ZodUnknown: () => I1, $ZodUnion: () => F8, $ZodUndefined: () => ZY, $ZodUUID: () => QY, $ZodURL: () => WY, $ZodULID: () => NY, $ZodType: () => i, $ZodTuple: () => y4, $ZodTransform: () => j0, $ZodTemplateLiteral: () => oY, $ZodSymbol: () => PY, $ZodSuccess: () => iY, $ZodStringFormat: () => H$, $ZodString: () => T4, $ZodSet: () => yY, $ZodRegistry: () => I8, $ZodRecord: () => xY, $ZodRealError: () => O0, $ZodReadonly: () => rY, $ZodPromise: () => tY, $ZodPrefault: () => cY, $ZodPipe: () => F0, $ZodOptional: () => uY, $ZodObject: () => j8, $ZodNumberFormat: () => AY, $ZodNumber: () => D8, $ZodNullable: () => mY, $ZodNull: () => EY, $ZodNonOptional: () => pY, $ZodNever: () => SY, $ZodNanoID: () => UY, $ZodNaN: () => dY, $ZodMap: () => TY, $ZodLiteral: () => gY, $ZodLazy: () => aY, $ZodKSUID: () => OY, $ZodJWT: () => MY, $ZodIntersection: () => _Y, $ZodISOTime: () => NW, $ZodISODuration: () => VW, $ZodISODateTime: () => HW, $ZodISODate: () => KW, $ZodIPv6: () => BY, $ZodIPv4: () => wY, $ZodGUID: () => YY, $ZodFunction: () => OG, $ZodFile: () => hY, $ZodError: () => q8, $ZodEnum: () => fY, $ZodEmoji: () => GY, $ZodEmail: () => zY, $ZodE164: () => FY, $ZodDiscriminatedUnion: () => kY, $ZodDefault: () => lY, $ZodDate: () => CY, $ZodCustomStringFormat: () => IY, $ZodCustom: () => sY, $ZodCheckUpperCase: () => $W, $ZodCheckStringFormat: () => q0, $ZodCheckStartsWith: () => JW, $ZodCheckSizeEquals: () => r5, $ZodCheckRegex: () => s5, $ZodCheckProperty: () => QW, $ZodCheckOverwrite: () => WW, $ZodCheckNumberFormat: () => p5, $ZodCheckMultipleOf: () => c5, $ZodCheckMinSize: () => d5, $ZodCheckMinLength: () => t5, $ZodCheckMimeType: () => zW, $ZodCheckMaxSize: () => n5, $ZodCheckMaxLength: () => o5, $ZodCheckLowerCase: () => e5, $ZodCheckLessThan: () => sJ, $ZodCheckLengthEquals: () => a5, $ZodCheckIncludes: () => XW, $ZodCheckGreaterThan: () => eJ, $ZodCheckEndsWith: () => YW, $ZodCheckBigIntFormat: () => i5, $ZodCheck: () => M$, $ZodCatch: () => nY, $ZodCUID2: () => KY, $ZodCUID: () => HY, $ZodCIDRv6: () => DY, $ZodCIDRv4: () => qY, $ZodBoolean: () => D0, $ZodBigIntFormat: () => bY, $ZodBigInt: () => L8, $ZodBase64URL: () => jY, $ZodBase64: () => LY, $ZodAsyncError: () => U4, $ZodArray: () => L0, $ZodAny: () => RY }); +var lJ = Object.freeze({ status: "aborted" }); +function q($, X, J) { + var _a3; + function Q(G, U) { + var _a4, _b2; + var H; + Object.defineProperty(G, "_zod", { value: (_a4 = G._zod) != null ? _a4 : {}, enumerable: false }), (_b2 = (H = G._zod).traits) != null ? _b2 : H.traits = /* @__PURE__ */ new Set(), G._zod.traits.add($), X(G, U); + for (let K in W.prototype) if (!(K in G)) Object.defineProperty(G, K, { value: W.prototype[K].bind(G) }); + G._zod.constr = W, G._zod.def = U; + } + let Y = (_a3 = J == null ? void 0 : J.Parent) != null ? _a3 : Object; + class z6 extends Y { + } + Object.defineProperty(z6, "name", { value: $ }); + function W(G) { + var _a4; + var U; + let H = (J == null ? void 0 : J.Parent) ? new z6() : this; + Q(H, G), (_a4 = (U = H._zod).deferred) != null ? _a4 : U.deferred = []; + for (let K of H._zod.deferred) K(); + return H; + } + return Object.defineProperty(W, "init", { value: Q }), Object.defineProperty(W, Symbol.hasInstance, { value: (G) => { + var _a4, _b2; + if ((J == null ? void 0 : J.Parent) && G instanceof J.Parent) return true; + return (_b2 = (_a4 = G == null ? void 0 : G._zod) == null ? void 0 : _a4.traits) == null ? void 0 : _b2.has($); + } }), Object.defineProperty(W, "name", { value: $ }), W; +} +var cJ = /* @__PURE__ */ Symbol("zod_brand"); +var U4 = class extends Error { + constructor() { + super("Encountered Promise during synchronous parse. Use .parseAsync() instead."); + } +}; +var U8 = {}; +function E$($) { + if ($) Object.assign(U8, $); + return U8; +} +var E = {}; +$1(E, { unwrapMessage: () => H8, stringifyPrimitive: () => S, required: () => JA, randomString: () => dI, propertyKeyTypes: () => O8, promiseAllObject: () => nI, primitiveTypes: () => H5, prefixIssues: () => $6, pick: () => aI, partial: () => XA, optionalKeys: () => K5, omit: () => sI, numKeys: () => rI, nullish: () => C4, normalizeParams: () => Z, merge: () => $A, jsonStringifyReplacer: () => z5, joinValues: () => M, issue: () => O5, isPlainObject: () => V0, isObject: () => N0, getSizableOrigin: () => w8, getParsedType: () => oI, getLengthableOrigin: () => B8, getEnumValues: () => K8, getElementAtPath: () => iI, floatSafeRemainder: () => W5, finalizeIssue: () => O6, extend: () => eI, escapeRegex: () => H4, esc: () => D1, defineLazy: () => W$, createTransparentProxy: () => tI, clone: () => m$, cleanRegex: () => V8, cleanEnum: () => YA, captureStackTrace: () => pJ, cached: () => N8, assignProp: () => G5, assertNotEqual: () => mI, assertNever: () => cI, assertIs: () => lI, assertEqual: () => uI, assert: () => pI, allowsEval: () => U5, aborted: () => L1, NUMBER_FORMAT_RANGES: () => N5, Class: () => QN, BIGINT_FORMAT_RANGES: () => V5 }); +function uI($) { + return $; +} +function mI($) { + return $; +} +function lI($) { +} +function cI($) { + throw Error(); +} +function pI($) { +} +function K8($) { + let X = Object.values($).filter((Q) => typeof Q === "number"); + return Object.entries($).filter(([Q, Y]) => X.indexOf(+Q) === -1).map(([Q, Y]) => Y); +} +function M($, X = "|") { + return $.map((J) => S(J)).join(X); +} +function z5($, X) { + if (typeof X === "bigint") return X.toString(); + return X; +} +function N8($) { + return { get value() { + { + let J = $(); + return Object.defineProperty(this, "value", { value: J }), J; + } + throw Error("cached value already set"); + } }; +} +function C4($) { + return $ === null || $ === void 0; +} +function V8($) { + let X = $.startsWith("^") ? 1 : 0, J = $.endsWith("$") ? $.length - 1 : $.length; + return $.slice(X, J); +} +function W5($, X) { + let J = ($.toString().split(".")[1] || "").length, Q = (X.toString().split(".")[1] || "").length, Y = J > Q ? J : Q, z6 = Number.parseInt($.toFixed(Y).replace(".", "")), W = Number.parseInt(X.toFixed(Y).replace(".", "")); + return z6 % W / 10 ** Y; +} +function W$($, X, J) { + Object.defineProperty($, X, { get() { + { + let Y = J(); + return $[X] = Y, Y; + } + throw Error("cached value already set"); + }, set(Y) { + Object.defineProperty($, X, { value: Y }); + }, configurable: true }); +} +function G5($, X, J) { + Object.defineProperty($, X, { value: J, writable: true, enumerable: true, configurable: true }); +} +function iI($, X) { + if (!X) return $; + return X.reduce((J, Q) => J == null ? void 0 : J[Q], $); +} +function nI($) { + let X = Object.keys($), J = X.map((Q) => $[Q]); + return Promise.all(J).then((Q) => { + let Y = {}; + for (let z6 = 0; z6 < X.length; z6++) Y[X[z6]] = Q[z6]; + return Y; + }); +} +function dI($ = 10) { + let J = ""; + for (let Q = 0; Q < $; Q++) J += "abcdefghijklmnopqrstuvwxyz"[Math.floor(Math.random() * 26)]; + return J; +} +function D1($) { + return JSON.stringify($); +} +var pJ = Error.captureStackTrace ? Error.captureStackTrace : (...$) => { +}; +function N0($) { + return typeof $ === "object" && $ !== null && !Array.isArray($); +} +var U5 = N8(() => { + var _a3; + if (typeof navigator < "u" && ((_a3 = navigator == null ? void 0 : navigator.userAgent) == null ? void 0 : _a3.includes("Cloudflare"))) return false; + try { + return new Function(""), true; + } catch ($) { + return false; + } +}); +function V0($) { + if (N0($) === false) return false; + let X = $.constructor; + if (X === void 0) return true; + let J = X.prototype; + if (N0(J) === false) return false; + if (Object.prototype.hasOwnProperty.call(J, "isPrototypeOf") === false) return false; + return true; +} +function rI($) { + let X = 0; + for (let J in $) if (Object.prototype.hasOwnProperty.call($, J)) X++; + return X; +} +var oI = ($) => { + let X = typeof $; + switch (X) { + case "undefined": + return "undefined"; + case "string": + return "string"; + case "number": + return Number.isNaN($) ? "nan" : "number"; + case "boolean": + return "boolean"; + case "function": + return "function"; + case "bigint": + return "bigint"; + case "symbol": + return "symbol"; + case "object": + if (Array.isArray($)) return "array"; + if ($ === null) return "null"; + if ($.then && typeof $.then === "function" && $.catch && typeof $.catch === "function") return "promise"; + if (typeof Map < "u" && $ instanceof Map) return "map"; + if (typeof Set < "u" && $ instanceof Set) return "set"; + if (typeof Date < "u" && $ instanceof Date) return "date"; + if (typeof File < "u" && $ instanceof File) return "file"; + return "object"; + default: + throw Error(`Unknown data type: ${X}`); + } +}; +var O8 = /* @__PURE__ */ new Set(["string", "number", "symbol"]); +var H5 = /* @__PURE__ */ new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]); +function H4($) { + return $.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); +} +function m$($, X, J) { + let Q = new $._zod.constr(X != null ? X : $._zod.def); + if (!X || (J == null ? void 0 : J.parent)) Q._zod.parent = $; + return Q; +} +function Z($) { + let X = $; + if (!X) return {}; + if (typeof X === "string") return { error: () => X }; + if ((X == null ? void 0 : X.message) !== void 0) { + if ((X == null ? void 0 : X.error) !== void 0) throw Error("Cannot specify both `message` and `error` params"); + X.error = X.message; + } + if (delete X.message, typeof X.error === "string") return { ...X, error: () => X.error }; + return X; +} +function tI($) { + let X; + return new Proxy({}, { get(J, Q, Y) { + return X != null ? X : X = $(), Reflect.get(X, Q, Y); + }, set(J, Q, Y, z6) { + return X != null ? X : X = $(), Reflect.set(X, Q, Y, z6); + }, has(J, Q) { + return X != null ? X : X = $(), Reflect.has(X, Q); + }, deleteProperty(J, Q) { + return X != null ? X : X = $(), Reflect.deleteProperty(X, Q); + }, ownKeys(J) { + return X != null ? X : X = $(), Reflect.ownKeys(X); + }, getOwnPropertyDescriptor(J, Q) { + return X != null ? X : X = $(), Reflect.getOwnPropertyDescriptor(X, Q); + }, defineProperty(J, Q, Y) { + return X != null ? X : X = $(), Reflect.defineProperty(X, Q, Y); + } }); +} +function S($) { + if (typeof $ === "bigint") return $.toString() + "n"; + if (typeof $ === "string") return `"${$}"`; + return `${$}`; +} +function K5($) { + return Object.keys($).filter((X) => { + return $[X]._zod.optin === "optional" && $[X]._zod.optout === "optional"; + }); +} +var N5 = { safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER], int32: [-2147483648, 2147483647], uint32: [0, 4294967295], float32: [-34028234663852886e22, 34028234663852886e22], float64: [-Number.MAX_VALUE, Number.MAX_VALUE] }; +var V5 = { int64: [BigInt("-9223372036854775808"), BigInt("9223372036854775807")], uint64: [BigInt(0), BigInt("18446744073709551615")] }; +function aI($, X) { + let J = {}, Q = $._zod.def; + for (let Y in X) { + if (!(Y in Q.shape)) throw Error(`Unrecognized key: "${Y}"`); + if (!X[Y]) continue; + J[Y] = Q.shape[Y]; + } + return m$($, { ...$._zod.def, shape: J, checks: [] }); +} +function sI($, X) { + let J = { ...$._zod.def.shape }, Q = $._zod.def; + for (let Y in X) { + if (!(Y in Q.shape)) throw Error(`Unrecognized key: "${Y}"`); + if (!X[Y]) continue; + delete J[Y]; + } + return m$($, { ...$._zod.def, shape: J, checks: [] }); +} +function eI($, X) { + if (!V0(X)) throw Error("Invalid input to extend: expected a plain object"); + let J = { ...$._zod.def, get shape() { + let Q = { ...$._zod.def.shape, ...X }; + return G5(this, "shape", Q), Q; + }, checks: [] }; + return m$($, J); +} +function $A($, X) { + return m$($, { ...$._zod.def, get shape() { + let J = { ...$._zod.def.shape, ...X._zod.def.shape }; + return G5(this, "shape", J), J; + }, catchall: X._zod.def.catchall, checks: [] }); +} +function XA($, X, J) { + let Q = X._zod.def.shape, Y = { ...Q }; + if (J) for (let z6 in J) { + if (!(z6 in Q)) throw Error(`Unrecognized key: "${z6}"`); + if (!J[z6]) continue; + Y[z6] = $ ? new $({ type: "optional", innerType: Q[z6] }) : Q[z6]; + } + else for (let z6 in Q) Y[z6] = $ ? new $({ type: "optional", innerType: Q[z6] }) : Q[z6]; + return m$(X, { ...X._zod.def, shape: Y, checks: [] }); +} +function JA($, X, J) { + let Q = X._zod.def.shape, Y = { ...Q }; + if (J) for (let z6 in J) { + if (!(z6 in Y)) throw Error(`Unrecognized key: "${z6}"`); + if (!J[z6]) continue; + Y[z6] = new $({ type: "nonoptional", innerType: Q[z6] }); + } + else for (let z6 in Q) Y[z6] = new $({ type: "nonoptional", innerType: Q[z6] }); + return m$(X, { ...X._zod.def, shape: Y, checks: [] }); +} +function L1($, X = 0) { + var _a3; + for (let J = X; J < $.issues.length; J++) if (((_a3 = $.issues[J]) == null ? void 0 : _a3.continue) !== true) return true; + return false; +} +function $6($, X) { + return X.map((J) => { + var _a3; + var Q; + return (_a3 = (Q = J).path) != null ? _a3 : Q.path = [], J.path.unshift($), J; + }); +} +function H8($) { + return typeof $ === "string" ? $ : $ == null ? void 0 : $.message; +} +function O6($, X, J) { + var _a3, _b2, _c, _d, _e, _f, _g, _h, _i, _j2, _k; + let Q = { ...$, path: (_a3 = $.path) != null ? _a3 : [] }; + if (!$.message) { + let Y = (_k = (_j2 = (_h = (_f = H8((_d = (_c = (_b2 = $.inst) == null ? void 0 : _b2._zod.def) == null ? void 0 : _c.error) == null ? void 0 : _d.call(_c, $))) != null ? _f : H8((_e = X == null ? void 0 : X.error) == null ? void 0 : _e.call(X, $))) != null ? _h : H8((_g = J.customError) == null ? void 0 : _g.call(J, $))) != null ? _j2 : H8((_i = J.localeError) == null ? void 0 : _i.call(J, $))) != null ? _k : "Invalid input"; + Q.message = Y; + } + if (delete Q.inst, delete Q.continue, !(X == null ? void 0 : X.reportInput)) delete Q.input; + return Q; +} +function w8($) { + if ($ instanceof Set) return "set"; + if ($ instanceof Map) return "map"; + if ($ instanceof File) return "file"; + return "unknown"; +} +function B8($) { + if (Array.isArray($)) return "array"; + if (typeof $ === "string") return "string"; + return "unknown"; +} +function O5(...$) { + let [X, J, Q] = $; + if (typeof X === "string") return { message: X, code: "custom", input: J, inst: Q }; + return { ...X }; +} +function YA($) { + return Object.entries($).filter(([X, J]) => { + return Number.isNaN(Number.parseInt(X, 10)); + }).map((X) => X[1]); +} +var QN = class { + constructor(...$) { + } +}; +var zN = ($, X) => { + $.name = "$ZodError", Object.defineProperty($, "_zod", { value: $._zod, enumerable: false }), Object.defineProperty($, "issues", { value: X, enumerable: false }), Object.defineProperty($, "message", { get() { + return JSON.stringify(X, z5, 2); + }, enumerable: true }); +}; +var q8 = q("$ZodError", zN); +var O0 = q("$ZodError", zN, { Parent: Error }); +function w0($, X = (J) => J.message) { + let J = {}, Q = []; + for (let Y of $.issues) if (Y.path.length > 0) J[Y.path[0]] = J[Y.path[0]] || [], J[Y.path[0]].push(X(Y)); + else Q.push(X(Y)); + return { formErrors: Q, fieldErrors: J }; +} +function B0($, X) { + let J = X || function(z6) { + return z6.message; + }, Q = { _errors: [] }, Y = (z6) => { + for (let W of z6.issues) if (W.code === "invalid_union" && W.errors.length) W.errors.map((G) => Y({ issues: G })); + else if (W.code === "invalid_key") Y({ issues: W.issues }); + else if (W.code === "invalid_element") Y({ issues: W.issues }); + else if (W.path.length === 0) Q._errors.push(J(W)); + else { + let G = Q, U = 0; + while (U < W.path.length) { + let H = W.path[U]; + if (U !== W.path.length - 1) G[H] = G[H] || { _errors: [] }; + else G[H] = G[H] || { _errors: [] }, G[H]._errors.push(J(W)); + G = G[H], U++; + } + } + }; + return Y($), Q; +} +function iJ($, X) { + let J = X || function(z6) { + return z6.message; + }, Q = { errors: [] }, Y = (z6, W = []) => { + var _a3, _b2, _c, _d; + var G, U; + for (let H of z6.issues) if (H.code === "invalid_union" && H.errors.length) H.errors.map((K) => Y({ issues: K }, H.path)); + else if (H.code === "invalid_key") Y({ issues: H.issues }, H.path); + else if (H.code === "invalid_element") Y({ issues: H.issues }, H.path); + else { + let K = [...W, ...H.path]; + if (K.length === 0) { + Q.errors.push(J(H)); + continue; + } + let V = Q, O = 0; + while (O < K.length) { + let N = K[O], w = O === K.length - 1; + if (typeof N === "string") (_a3 = V.properties) != null ? _a3 : V.properties = {}, (_b2 = (G = V.properties)[N]) != null ? _b2 : G[N] = { errors: [] }, V = V.properties[N]; + else (_c = V.items) != null ? _c : V.items = [], (_d = (U = V.items)[N]) != null ? _d : U[N] = { errors: [] }, V = V.items[N]; + if (w) V.errors.push(J(H)); + O++; + } + } + }; + return Y($), Q; +} +function WN($) { + let X = []; + for (let J of $) if (typeof J === "number") X.push(`[${J}]`); + else if (typeof J === "symbol") X.push(`[${JSON.stringify(String(J))}]`); + else if (/[^\w$]/.test(J)) X.push(`[${JSON.stringify(J)}]`); + else { + if (X.length) X.push("."); + X.push(J); + } + return X.join(""); +} +function nJ($) { + var _a3; + let X = [], J = [...$.issues].sort((Q, Y) => Q.path.length - Y.path.length); + for (let Q of J) if (X.push(`\u2716 ${Q.message}`), (_a3 = Q.path) == null ? void 0 : _a3.length) X.push(` \u2192 at ${WN(Q.path)}`); + return X.join(` +`); +} +var dJ = ($) => (X, J, Q, Y) => { + var _a3; + let z6 = Q ? Object.assign(Q, { async: false }) : { async: false }, W = X._zod.run({ value: J, issues: [] }, z6); + if (W instanceof Promise) throw new U4(); + if (W.issues.length) { + let G = new ((_a3 = Y == null ? void 0 : Y.Err) != null ? _a3 : $)(W.issues.map((U) => O6(U, z6, E$()))); + throw pJ(G, Y == null ? void 0 : Y.callee), G; + } + return W.value; +}; +var j1 = dJ(O0); +var rJ = ($) => async (X, J, Q, Y) => { + var _a3; + let z6 = Q ? Object.assign(Q, { async: true }) : { async: true }, W = X._zod.run({ value: J, issues: [] }, z6); + if (W instanceof Promise) W = await W; + if (W.issues.length) { + let G = new ((_a3 = Y == null ? void 0 : Y.Err) != null ? _a3 : $)(W.issues.map((U) => O6(U, z6, E$()))); + throw pJ(G, Y == null ? void 0 : Y.callee), G; + } + return W.value; +}; +var F1 = rJ(O0); +var oJ = ($) => (X, J, Q) => { + let Y = Q ? { ...Q, async: false } : { async: false }, z6 = X._zod.run({ value: J, issues: [] }, Y); + if (z6 instanceof Promise) throw new U4(); + return z6.issues.length ? { success: false, error: new ($ != null ? $ : q8)(z6.issues.map((W) => O6(W, Y, E$()))) } : { success: true, data: z6.value }; +}; +var k4 = oJ(O0); +var tJ = ($) => async (X, J, Q) => { + let Y = Q ? Object.assign(Q, { async: true }) : { async: true }, z6 = X._zod.run({ value: J, issues: [] }, Y); + if (z6 instanceof Promise) z6 = await z6; + return z6.issues.length ? { success: false, error: new $(z6.issues.map((W) => O6(W, Y, E$()))) } : { success: true, data: z6.value }; +}; +var _4 = tJ(O0); +var x4 = {}; +$1(x4, { xid: () => D5, uuid7: () => UA, uuid6: () => GA, uuid4: () => WA, uuid: () => M1, uppercase: () => l5, unicodeEmail: () => NA, undefined: () => u5, ulid: () => q5, time: () => k5, string: () => x5, rfc5322Email: () => KA, number: () => f5, null: () => h5, nanoid: () => j5, lowercase: () => m5, ksuid: () => L5, ipv6: () => P5, ipv4: () => b5, integer: () => y5, html5Email: () => HA, hostname: () => S5, guid: () => M5, extendedDuration: () => zA, emoji: () => A5, email: () => I5, e164: () => v5, duration: () => F5, domain: () => wA, datetime: () => _5, date: () => C5, cuid2: () => B5, cuid: () => w5, cidrv6: () => E5, cidrv4: () => Z5, browserEmail: () => VA, boolean: () => g5, bigint: () => T5, base64url: () => aJ, base64: () => R5, _emoji: () => OA }); +var w5 = /^[cC][^\s-]{8,}$/; +var B5 = /^[0-9a-z]+$/; +var q5 = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/; +var D5 = /^[0-9a-vA-V]{20}$/; +var L5 = /^[A-Za-z0-9]{27}$/; +var j5 = /^[a-zA-Z0-9_-]{21}$/; +var F5 = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/; +var zA = /^[-+]?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)?)??$/; +var M5 = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/; +var M1 = ($) => { + if (!$) return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000)$/; + return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${$}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`); +}; +var WA = M1(4); +var GA = M1(6); +var UA = M1(7); +var I5 = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/; +var HA = /^[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])?)*$/; +var KA = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/; +var NA = /^[^\s@"]{1,64}@[^\s@]{1,255}$/u; +var VA = /^[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])?)*$/; +var OA = "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$"; +function A5() { + return new RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u"); +} +var b5 = /^(?:(?: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])$/; +var P5 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})$/; +var Z5 = /^((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])\/([0-9]|[1-2][0-9]|3[0-2])$/; +var E5 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/; +var R5 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/; +var aJ = /^[A-Za-z0-9_-]*$/; +var S5 = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/; +var wA = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/; +var v5 = /^\+(?:[0-9]){6,14}[0-9]$/; +var GN = "(?:(?:\\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])))"; +var C5 = new RegExp(`^${GN}$`); +function UN($) { + return typeof $.precision === "number" ? $.precision === -1 ? "(?:[01]\\d|2[0-3]):[0-5]\\d" : $.precision === 0 ? "(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d" : `(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d\\.\\d{${$.precision}}` : "(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?"; +} +function k5($) { + return new RegExp(`^${UN($)}$`); +} +function _5($) { + let X = UN({ precision: $.precision }), J = ["Z"]; + if ($.local) J.push(""); + if ($.offset) J.push("([+-]\\d{2}:\\d{2})"); + let Q = `${X}(?:${J.join("|")})`; + return new RegExp(`^${GN}T(?:${Q})$`); +} +var x5 = ($) => { + var _a3, _b2; + let X = $ ? `[\\s\\S]{${(_a3 = $ == null ? void 0 : $.minimum) != null ? _a3 : 0},${(_b2 = $ == null ? void 0 : $.maximum) != null ? _b2 : ""}}` : "[\\s\\S]*"; + return new RegExp(`^${X}$`); +}; +var T5 = /^\d+n?$/; +var y5 = /^\d+$/; +var f5 = /^-?\d+(?:\.\d+)?/i; +var g5 = /true|false/i; +var h5 = /null/i; +var u5 = /undefined/i; +var m5 = /^[^A-Z]*$/; +var l5 = /^[^a-z]*$/; +var M$ = q("$ZodCheck", ($, X) => { + var _a3, _b2; + var J; + (_a3 = $._zod) != null ? _a3 : $._zod = {}, $._zod.def = X, (_b2 = (J = $._zod).onattach) != null ? _b2 : J.onattach = []; +}); +var KN = { number: "number", bigint: "bigint", object: "date" }; +var sJ = q("$ZodCheckLessThan", ($, X) => { + M$.init($, X); + let J = KN[typeof X.value]; + $._zod.onattach.push((Q) => { + var _a3; + let Y = Q._zod.bag, z6 = (_a3 = X.inclusive ? Y.maximum : Y.exclusiveMaximum) != null ? _a3 : Number.POSITIVE_INFINITY; + if (X.value < z6) if (X.inclusive) Y.maximum = X.value; + else Y.exclusiveMaximum = X.value; + }), $._zod.check = (Q) => { + if (X.inclusive ? Q.value <= X.value : Q.value < X.value) return; + Q.issues.push({ origin: J, code: "too_big", maximum: X.value, input: Q.value, inclusive: X.inclusive, inst: $, continue: !X.abort }); + }; +}); +var eJ = q("$ZodCheckGreaterThan", ($, X) => { + M$.init($, X); + let J = KN[typeof X.value]; + $._zod.onattach.push((Q) => { + var _a3; + let Y = Q._zod.bag, z6 = (_a3 = X.inclusive ? Y.minimum : Y.exclusiveMinimum) != null ? _a3 : Number.NEGATIVE_INFINITY; + if (X.value > z6) if (X.inclusive) Y.minimum = X.value; + else Y.exclusiveMinimum = X.value; + }), $._zod.check = (Q) => { + if (X.inclusive ? Q.value >= X.value : Q.value > X.value) return; + Q.issues.push({ origin: J, code: "too_small", minimum: X.value, input: Q.value, inclusive: X.inclusive, inst: $, continue: !X.abort }); + }; +}); +var c5 = q("$ZodCheckMultipleOf", ($, X) => { + M$.init($, X), $._zod.onattach.push((J) => { + var _a3; + var Q; + (_a3 = (Q = J._zod.bag).multipleOf) != null ? _a3 : Q.multipleOf = X.value; + }), $._zod.check = (J) => { + if (typeof J.value !== typeof X.value) throw Error("Cannot mix number and bigint in multiple_of check."); + if (typeof J.value === "bigint" ? J.value % X.value === BigInt(0) : W5(J.value, X.value) === 0) return; + J.issues.push({ origin: typeof J.value, code: "not_multiple_of", divisor: X.value, input: J.value, inst: $, continue: !X.abort }); + }; +}); +var p5 = q("$ZodCheckNumberFormat", ($, X) => { + var _a3; + M$.init($, X), X.format = X.format || "float64"; + let J = (_a3 = X.format) == null ? void 0 : _a3.includes("int"), Q = J ? "int" : "number", [Y, z6] = N5[X.format]; + $._zod.onattach.push((W) => { + let G = W._zod.bag; + if (G.format = X.format, G.minimum = Y, G.maximum = z6, J) G.pattern = y5; + }), $._zod.check = (W) => { + let G = W.value; + if (J) { + if (!Number.isInteger(G)) { + W.issues.push({ expected: Q, format: X.format, code: "invalid_type", input: G, inst: $ }); + return; + } + if (!Number.isSafeInteger(G)) { + if (G > 0) W.issues.push({ input: G, code: "too_big", maximum: Number.MAX_SAFE_INTEGER, note: "Integers must be within the safe integer range.", inst: $, origin: Q, continue: !X.abort }); + else W.issues.push({ input: G, code: "too_small", minimum: Number.MIN_SAFE_INTEGER, note: "Integers must be within the safe integer range.", inst: $, origin: Q, continue: !X.abort }); + return; + } + } + if (G < Y) W.issues.push({ origin: "number", input: G, code: "too_small", minimum: Y, inclusive: true, inst: $, continue: !X.abort }); + if (G > z6) W.issues.push({ origin: "number", input: G, code: "too_big", maximum: z6, inst: $ }); + }; +}); +var i5 = q("$ZodCheckBigIntFormat", ($, X) => { + M$.init($, X); + let [J, Q] = V5[X.format]; + $._zod.onattach.push((Y) => { + let z6 = Y._zod.bag; + z6.format = X.format, z6.minimum = J, z6.maximum = Q; + }), $._zod.check = (Y) => { + let z6 = Y.value; + if (z6 < J) Y.issues.push({ origin: "bigint", input: z6, code: "too_small", minimum: J, inclusive: true, inst: $, continue: !X.abort }); + if (z6 > Q) Y.issues.push({ origin: "bigint", input: z6, code: "too_big", maximum: Q, inst: $ }); + }; +}); +var n5 = q("$ZodCheckMaxSize", ($, X) => { + M$.init($, X), $._zod.when = (J) => { + let Q = J.value; + return !C4(Q) && Q.size !== void 0; + }, $._zod.onattach.push((J) => { + var _a3; + let Q = (_a3 = J._zod.bag.maximum) != null ? _a3 : Number.POSITIVE_INFINITY; + if (X.maximum < Q) J._zod.bag.maximum = X.maximum; + }), $._zod.check = (J) => { + let Q = J.value; + if (Q.size <= X.maximum) return; + J.issues.push({ origin: w8(Q), code: "too_big", maximum: X.maximum, input: Q, inst: $, continue: !X.abort }); + }; +}); +var d5 = q("$ZodCheckMinSize", ($, X) => { + M$.init($, X), $._zod.when = (J) => { + let Q = J.value; + return !C4(Q) && Q.size !== void 0; + }, $._zod.onattach.push((J) => { + var _a3; + let Q = (_a3 = J._zod.bag.minimum) != null ? _a3 : Number.NEGATIVE_INFINITY; + if (X.minimum > Q) J._zod.bag.minimum = X.minimum; + }), $._zod.check = (J) => { + let Q = J.value; + if (Q.size >= X.minimum) return; + J.issues.push({ origin: w8(Q), code: "too_small", minimum: X.minimum, input: Q, inst: $, continue: !X.abort }); + }; +}); +var r5 = q("$ZodCheckSizeEquals", ($, X) => { + M$.init($, X), $._zod.when = (J) => { + let Q = J.value; + return !C4(Q) && Q.size !== void 0; + }, $._zod.onattach.push((J) => { + let Q = J._zod.bag; + Q.minimum = X.size, Q.maximum = X.size, Q.size = X.size; + }), $._zod.check = (J) => { + let Q = J.value, Y = Q.size; + if (Y === X.size) return; + let z6 = Y > X.size; + J.issues.push({ origin: w8(Q), ...z6 ? { code: "too_big", maximum: X.size } : { code: "too_small", minimum: X.size }, inclusive: true, exact: true, input: J.value, inst: $, continue: !X.abort }); + }; +}); +var o5 = q("$ZodCheckMaxLength", ($, X) => { + M$.init($, X), $._zod.when = (J) => { + let Q = J.value; + return !C4(Q) && Q.length !== void 0; + }, $._zod.onattach.push((J) => { + var _a3; + let Q = (_a3 = J._zod.bag.maximum) != null ? _a3 : Number.POSITIVE_INFINITY; + if (X.maximum < Q) J._zod.bag.maximum = X.maximum; + }), $._zod.check = (J) => { + let Q = J.value; + if (Q.length <= X.maximum) return; + let z6 = B8(Q); + J.issues.push({ origin: z6, code: "too_big", maximum: X.maximum, inclusive: true, input: Q, inst: $, continue: !X.abort }); + }; +}); +var t5 = q("$ZodCheckMinLength", ($, X) => { + M$.init($, X), $._zod.when = (J) => { + let Q = J.value; + return !C4(Q) && Q.length !== void 0; + }, $._zod.onattach.push((J) => { + var _a3; + let Q = (_a3 = J._zod.bag.minimum) != null ? _a3 : Number.NEGATIVE_INFINITY; + if (X.minimum > Q) J._zod.bag.minimum = X.minimum; + }), $._zod.check = (J) => { + let Q = J.value; + if (Q.length >= X.minimum) return; + let z6 = B8(Q); + J.issues.push({ origin: z6, code: "too_small", minimum: X.minimum, inclusive: true, input: Q, inst: $, continue: !X.abort }); + }; +}); +var a5 = q("$ZodCheckLengthEquals", ($, X) => { + M$.init($, X), $._zod.when = (J) => { + let Q = J.value; + return !C4(Q) && Q.length !== void 0; + }, $._zod.onattach.push((J) => { + let Q = J._zod.bag; + Q.minimum = X.length, Q.maximum = X.length, Q.length = X.length; + }), $._zod.check = (J) => { + let Q = J.value, Y = Q.length; + if (Y === X.length) return; + let z6 = B8(Q), W = Y > X.length; + J.issues.push({ origin: z6, ...W ? { code: "too_big", maximum: X.length } : { code: "too_small", minimum: X.length }, inclusive: true, exact: true, input: J.value, inst: $, continue: !X.abort }); + }; +}); +var q0 = q("$ZodCheckStringFormat", ($, X) => { + var _a3, _b2; + var J, Q; + if (M$.init($, X), $._zod.onattach.push((Y) => { + var _a4; + let z6 = Y._zod.bag; + if (z6.format = X.format, X.pattern) (_a4 = z6.patterns) != null ? _a4 : z6.patterns = /* @__PURE__ */ new Set(), z6.patterns.add(X.pattern); + }), X.pattern) (_a3 = (J = $._zod).check) != null ? _a3 : J.check = (Y) => { + if (X.pattern.lastIndex = 0, X.pattern.test(Y.value)) return; + Y.issues.push({ origin: "string", code: "invalid_format", format: X.format, input: Y.value, ...X.pattern ? { pattern: X.pattern.toString() } : {}, inst: $, continue: !X.abort }); + }; + else (_b2 = (Q = $._zod).check) != null ? _b2 : Q.check = () => { + }; +}); +var s5 = q("$ZodCheckRegex", ($, X) => { + q0.init($, X), $._zod.check = (J) => { + if (X.pattern.lastIndex = 0, X.pattern.test(J.value)) return; + J.issues.push({ origin: "string", code: "invalid_format", format: "regex", input: J.value, pattern: X.pattern.toString(), inst: $, continue: !X.abort }); + }; +}); +var e5 = q("$ZodCheckLowerCase", ($, X) => { + var _a3; + (_a3 = X.pattern) != null ? _a3 : X.pattern = m5, q0.init($, X); +}); +var $W = q("$ZodCheckUpperCase", ($, X) => { + var _a3; + (_a3 = X.pattern) != null ? _a3 : X.pattern = l5, q0.init($, X); +}); +var XW = q("$ZodCheckIncludes", ($, X) => { + M$.init($, X); + let J = H4(X.includes), Q = new RegExp(typeof X.position === "number" ? `^.{${X.position}}${J}` : J); + X.pattern = Q, $._zod.onattach.push((Y) => { + var _a3; + let z6 = Y._zod.bag; + (_a3 = z6.patterns) != null ? _a3 : z6.patterns = /* @__PURE__ */ new Set(), z6.patterns.add(Q); + }), $._zod.check = (Y) => { + if (Y.value.includes(X.includes, X.position)) return; + Y.issues.push({ origin: "string", code: "invalid_format", format: "includes", includes: X.includes, input: Y.value, inst: $, continue: !X.abort }); + }; +}); +var JW = q("$ZodCheckStartsWith", ($, X) => { + var _a3; + M$.init($, X); + let J = new RegExp(`^${H4(X.prefix)}.*`); + (_a3 = X.pattern) != null ? _a3 : X.pattern = J, $._zod.onattach.push((Q) => { + var _a4; + let Y = Q._zod.bag; + (_a4 = Y.patterns) != null ? _a4 : Y.patterns = /* @__PURE__ */ new Set(), Y.patterns.add(J); + }), $._zod.check = (Q) => { + if (Q.value.startsWith(X.prefix)) return; + Q.issues.push({ origin: "string", code: "invalid_format", format: "starts_with", prefix: X.prefix, input: Q.value, inst: $, continue: !X.abort }); + }; +}); +var YW = q("$ZodCheckEndsWith", ($, X) => { + var _a3; + M$.init($, X); + let J = new RegExp(`.*${H4(X.suffix)}$`); + (_a3 = X.pattern) != null ? _a3 : X.pattern = J, $._zod.onattach.push((Q) => { + var _a4; + let Y = Q._zod.bag; + (_a4 = Y.patterns) != null ? _a4 : Y.patterns = /* @__PURE__ */ new Set(), Y.patterns.add(J); + }), $._zod.check = (Q) => { + if (Q.value.endsWith(X.suffix)) return; + Q.issues.push({ origin: "string", code: "invalid_format", format: "ends_with", suffix: X.suffix, input: Q.value, inst: $, continue: !X.abort }); + }; +}); +function HN($, X, J) { + if ($.issues.length) X.issues.push(...$6(J, $.issues)); +} +var QW = q("$ZodCheckProperty", ($, X) => { + M$.init($, X), $._zod.check = (J) => { + let Q = X.schema._zod.run({ value: J.value[X.property], issues: [] }, {}); + if (Q instanceof Promise) return Q.then((Y) => HN(Y, J, X.property)); + HN(Q, J, X.property); + return; + }; +}); +var zW = q("$ZodCheckMimeType", ($, X) => { + M$.init($, X); + let J = new Set(X.mime); + $._zod.onattach.push((Q) => { + Q._zod.bag.mime = X.mime; + }), $._zod.check = (Q) => { + if (J.has(Q.value.type)) return; + Q.issues.push({ code: "invalid_value", values: X.mime, input: Q.value.type, inst: $ }); + }; +}); +var WW = q("$ZodCheckOverwrite", ($, X) => { + M$.init($, X), $._zod.check = (J) => { + J.value = X.tx(J.value); + }; +}); +var $Y = class { + constructor($ = []) { + if (this.content = [], this.indent = 0, this) this.args = $; + } + indented($) { + this.indent += 1, $(this), this.indent -= 1; + } + write($) { + if (typeof $ === "function") { + $(this, { execution: "sync" }), $(this, { execution: "async" }); + return; + } + let J = $.split(` +`).filter((z6) => z6), Q = Math.min(...J.map((z6) => z6.length - z6.trimStart().length)), Y = J.map((z6) => z6.slice(Q)).map((z6) => " ".repeat(this.indent * 2) + z6); + for (let z6 of Y) this.content.push(z6); + } + compile() { + var _a3; + let $ = Function, X = this == null ? void 0 : this.args, Q = [...((_a3 = this == null ? void 0 : this.content) != null ? _a3 : [""]).map((Y) => ` ${Y}`)]; + return new $(...X, Q.join(` +`)); + } +}; +var GW = { major: 4, minor: 0, patch: 0 }; +var i = q("$ZodType", ($, X) => { + var _a3, _b2, _c; + var J; + $ != null ? $ : $ = {}, $._zod.def = X, $._zod.bag = $._zod.bag || {}, $._zod.version = GW; + let Q = [...(_a3 = $._zod.def.checks) != null ? _a3 : []]; + if ($._zod.traits.has("$ZodCheck")) Q.unshift($); + for (let Y of Q) for (let z6 of Y._zod.onattach) z6($); + if (Q.length === 0) (_b2 = (J = $._zod).deferred) != null ? _b2 : J.deferred = [], (_c = $._zod.deferred) == null ? void 0 : _c.push(() => { + $._zod.run = $._zod.parse; + }); + else { + let Y = (z6, W, G) => { + let U = L1(z6), H; + for (let K of W) { + if (K._zod.when) { + if (!K._zod.when(z6)) continue; + } else if (U) continue; + let V = z6.issues.length, O = K._zod.check(z6); + if (O instanceof Promise && (G == null ? void 0 : G.async) === false) throw new U4(); + if (H || O instanceof Promise) H = (H != null ? H : Promise.resolve()).then(async () => { + if (await O, z6.issues.length === V) return; + if (!U) U = L1(z6, V); + }); + else { + if (z6.issues.length === V) continue; + if (!U) U = L1(z6, V); + } + } + if (H) return H.then(() => { + return z6; + }); + return z6; + }; + $._zod.run = (z6, W) => { + let G = $._zod.parse(z6, W); + if (G instanceof Promise) { + if (W.async === false) throw new U4(); + return G.then((U) => Y(U, Q, W)); + } + return Y(G, Q, W); + }; + } + $["~standard"] = { validate: (Y) => { + var _a4; + try { + let z6 = k4($, Y); + return z6.success ? { value: z6.data } : { issues: (_a4 = z6.error) == null ? void 0 : _a4.issues }; + } catch (z6) { + return _4($, Y).then((W) => { + var _a5; + return W.success ? { value: W.data } : { issues: (_a5 = W.error) == null ? void 0 : _a5.issues }; + }); + } + }, vendor: "zod", version: 1 }; +}); +var T4 = q("$ZodString", ($, X) => { + var _a3, _b2, _c; + i.init($, X), $._zod.pattern = (_c = [...(_b2 = (_a3 = $ == null ? void 0 : $._zod.bag) == null ? void 0 : _a3.patterns) != null ? _b2 : []].pop()) != null ? _c : x5($._zod.bag), $._zod.parse = (J, Q) => { + if (X.coerce) try { + J.value = String(J.value); + } catch (Y) { + } + if (typeof J.value === "string") return J; + return J.issues.push({ expected: "string", code: "invalid_type", input: J.value, inst: $ }), J; + }; +}); +var H$ = q("$ZodStringFormat", ($, X) => { + q0.init($, X), T4.init($, X); +}); +var YY = q("$ZodGUID", ($, X) => { + var _a3; + (_a3 = X.pattern) != null ? _a3 : X.pattern = M5, H$.init($, X); +}); +var QY = q("$ZodUUID", ($, X) => { + var _a3, _b2; + if (X.version) { + let Q = { v1: 1, v2: 2, v3: 3, v4: 4, v5: 5, v6: 6, v7: 7, v8: 8 }[X.version]; + if (Q === void 0) throw Error(`Invalid UUID version: "${X.version}"`); + (_a3 = X.pattern) != null ? _a3 : X.pattern = M1(Q); + } else (_b2 = X.pattern) != null ? _b2 : X.pattern = M1(); + H$.init($, X); +}); +var zY = q("$ZodEmail", ($, X) => { + var _a3; + (_a3 = X.pattern) != null ? _a3 : X.pattern = I5, H$.init($, X); +}); +var WY = q("$ZodURL", ($, X) => { + H$.init($, X), $._zod.check = (J) => { + try { + let Q = J.value, Y = new URL(Q), z6 = Y.href; + if (X.hostname) { + if (X.hostname.lastIndex = 0, !X.hostname.test(Y.hostname)) J.issues.push({ code: "invalid_format", format: "url", note: "Invalid hostname", pattern: S5.source, input: J.value, inst: $, continue: !X.abort }); + } + if (X.protocol) { + if (X.protocol.lastIndex = 0, !X.protocol.test(Y.protocol.endsWith(":") ? Y.protocol.slice(0, -1) : Y.protocol)) J.issues.push({ code: "invalid_format", format: "url", note: "Invalid protocol", pattern: X.protocol.source, input: J.value, inst: $, continue: !X.abort }); + } + if (!Q.endsWith("/") && z6.endsWith("/")) J.value = z6.slice(0, -1); + else J.value = z6; + return; + } catch (Q) { + J.issues.push({ code: "invalid_format", format: "url", input: J.value, inst: $, continue: !X.abort }); + } + }; +}); +var GY = q("$ZodEmoji", ($, X) => { + var _a3; + (_a3 = X.pattern) != null ? _a3 : X.pattern = A5(), H$.init($, X); +}); +var UY = q("$ZodNanoID", ($, X) => { + var _a3; + (_a3 = X.pattern) != null ? _a3 : X.pattern = j5, H$.init($, X); +}); +var HY = q("$ZodCUID", ($, X) => { + var _a3; + (_a3 = X.pattern) != null ? _a3 : X.pattern = w5, H$.init($, X); +}); +var KY = q("$ZodCUID2", ($, X) => { + var _a3; + (_a3 = X.pattern) != null ? _a3 : X.pattern = B5, H$.init($, X); +}); +var NY = q("$ZodULID", ($, X) => { + var _a3; + (_a3 = X.pattern) != null ? _a3 : X.pattern = q5, H$.init($, X); +}); +var VY = q("$ZodXID", ($, X) => { + var _a3; + (_a3 = X.pattern) != null ? _a3 : X.pattern = D5, H$.init($, X); +}); +var OY = q("$ZodKSUID", ($, X) => { + var _a3; + (_a3 = X.pattern) != null ? _a3 : X.pattern = L5, H$.init($, X); +}); +var HW = q("$ZodISODateTime", ($, X) => { + var _a3; + (_a3 = X.pattern) != null ? _a3 : X.pattern = _5(X), H$.init($, X); +}); +var KW = q("$ZodISODate", ($, X) => { + var _a3; + (_a3 = X.pattern) != null ? _a3 : X.pattern = C5, H$.init($, X); +}); +var NW = q("$ZodISOTime", ($, X) => { + var _a3; + (_a3 = X.pattern) != null ? _a3 : X.pattern = k5(X), H$.init($, X); +}); +var VW = q("$ZodISODuration", ($, X) => { + var _a3; + (_a3 = X.pattern) != null ? _a3 : X.pattern = F5, H$.init($, X); +}); +var wY = q("$ZodIPv4", ($, X) => { + var _a3; + (_a3 = X.pattern) != null ? _a3 : X.pattern = b5, H$.init($, X), $._zod.onattach.push((J) => { + let Q = J._zod.bag; + Q.format = "ipv4"; + }); +}); +var BY = q("$ZodIPv6", ($, X) => { + var _a3; + (_a3 = X.pattern) != null ? _a3 : X.pattern = P5, H$.init($, X), $._zod.onattach.push((J) => { + let Q = J._zod.bag; + Q.format = "ipv6"; + }), $._zod.check = (J) => { + try { + new URL(`http://[${J.value}]`); + } catch (e3) { + J.issues.push({ code: "invalid_format", format: "ipv6", input: J.value, inst: $, continue: !X.abort }); + } + }; +}); +var qY = q("$ZodCIDRv4", ($, X) => { + var _a3; + (_a3 = X.pattern) != null ? _a3 : X.pattern = Z5, H$.init($, X); +}); +var DY = q("$ZodCIDRv6", ($, X) => { + var _a3; + (_a3 = X.pattern) != null ? _a3 : X.pattern = E5, H$.init($, X), $._zod.check = (J) => { + let [Q, Y] = J.value.split("/"); + try { + if (!Y) throw Error(); + let z6 = Number(Y); + if (`${z6}` !== Y) throw Error(); + if (z6 < 0 || z6 > 128) throw Error(); + new URL(`http://[${Q}]`); + } catch (e3) { + J.issues.push({ code: "invalid_format", format: "cidrv6", input: J.value, inst: $, continue: !X.abort }); + } + }; +}); +function OW($) { + if ($ === "") return true; + if ($.length % 4 !== 0) return false; + try { + return atob($), true; + } catch (e3) { + return false; + } +} +var LY = q("$ZodBase64", ($, X) => { + var _a3; + (_a3 = X.pattern) != null ? _a3 : X.pattern = R5, H$.init($, X), $._zod.onattach.push((J) => { + J._zod.bag.contentEncoding = "base64"; + }), $._zod.check = (J) => { + if (OW(J.value)) return; + J.issues.push({ code: "invalid_format", format: "base64", input: J.value, inst: $, continue: !X.abort }); + }; +}); +function AN($) { + if (!aJ.test($)) return false; + let X = $.replace(/[-_]/g, (Q) => Q === "-" ? "+" : "/"), J = X.padEnd(Math.ceil(X.length / 4) * 4, "="); + return OW(J); +} +var jY = q("$ZodBase64URL", ($, X) => { + var _a3; + (_a3 = X.pattern) != null ? _a3 : X.pattern = aJ, H$.init($, X), $._zod.onattach.push((J) => { + J._zod.bag.contentEncoding = "base64url"; + }), $._zod.check = (J) => { + if (AN(J.value)) return; + J.issues.push({ code: "invalid_format", format: "base64url", input: J.value, inst: $, continue: !X.abort }); + }; +}); +var FY = q("$ZodE164", ($, X) => { + var _a3; + (_a3 = X.pattern) != null ? _a3 : X.pattern = v5, H$.init($, X); +}); +function bN($, X = null) { + try { + let J = $.split("."); + if (J.length !== 3) return false; + let [Q] = J; + if (!Q) return false; + let Y = JSON.parse(atob(Q)); + if ("typ" in Y && (Y == null ? void 0 : Y.typ) !== "JWT") return false; + if (!Y.alg) return false; + if (X && (!("alg" in Y) || Y.alg !== X)) return false; + return true; + } catch (e3) { + return false; + } +} +var MY = q("$ZodJWT", ($, X) => { + H$.init($, X), $._zod.check = (J) => { + if (bN(J.value, X.alg)) return; + J.issues.push({ code: "invalid_format", format: "jwt", input: J.value, inst: $, continue: !X.abort }); + }; +}); +var IY = q("$ZodCustomStringFormat", ($, X) => { + H$.init($, X), $._zod.check = (J) => { + if (X.fn(J.value)) return; + J.issues.push({ code: "invalid_format", format: X.format, input: J.value, inst: $, continue: !X.abort }); + }; +}); +var D8 = q("$ZodNumber", ($, X) => { + var _a3; + i.init($, X), $._zod.pattern = (_a3 = $._zod.bag.pattern) != null ? _a3 : f5, $._zod.parse = (J, Q) => { + if (X.coerce) try { + J.value = Number(J.value); + } catch (W) { + } + let Y = J.value; + if (typeof Y === "number" && !Number.isNaN(Y) && Number.isFinite(Y)) return J; + let z6 = typeof Y === "number" ? Number.isNaN(Y) ? "NaN" : !Number.isFinite(Y) ? "Infinity" : void 0 : void 0; + return J.issues.push({ expected: "number", code: "invalid_type", input: Y, inst: $, ...z6 ? { received: z6 } : {} }), J; + }; +}); +var AY = q("$ZodNumber", ($, X) => { + p5.init($, X), D8.init($, X); +}); +var D0 = q("$ZodBoolean", ($, X) => { + i.init($, X), $._zod.pattern = g5, $._zod.parse = (J, Q) => { + if (X.coerce) try { + J.value = Boolean(J.value); + } catch (z6) { + } + let Y = J.value; + if (typeof Y === "boolean") return J; + return J.issues.push({ expected: "boolean", code: "invalid_type", input: Y, inst: $ }), J; + }; +}); +var L8 = q("$ZodBigInt", ($, X) => { + i.init($, X), $._zod.pattern = T5, $._zod.parse = (J, Q) => { + if (X.coerce) try { + J.value = BigInt(J.value); + } catch (Y) { + } + if (typeof J.value === "bigint") return J; + return J.issues.push({ expected: "bigint", code: "invalid_type", input: J.value, inst: $ }), J; + }; +}); +var bY = q("$ZodBigInt", ($, X) => { + i5.init($, X), L8.init($, X); +}); +var PY = q("$ZodSymbol", ($, X) => { + i.init($, X), $._zod.parse = (J, Q) => { + let Y = J.value; + if (typeof Y === "symbol") return J; + return J.issues.push({ expected: "symbol", code: "invalid_type", input: Y, inst: $ }), J; + }; +}); +var ZY = q("$ZodUndefined", ($, X) => { + i.init($, X), $._zod.pattern = u5, $._zod.values = /* @__PURE__ */ new Set([void 0]), $._zod.optin = "optional", $._zod.optout = "optional", $._zod.parse = (J, Q) => { + let Y = J.value; + if (typeof Y > "u") return J; + return J.issues.push({ expected: "undefined", code: "invalid_type", input: Y, inst: $ }), J; + }; +}); +var EY = q("$ZodNull", ($, X) => { + i.init($, X), $._zod.pattern = h5, $._zod.values = /* @__PURE__ */ new Set([null]), $._zod.parse = (J, Q) => { + let Y = J.value; + if (Y === null) return J; + return J.issues.push({ expected: "null", code: "invalid_type", input: Y, inst: $ }), J; + }; +}); +var RY = q("$ZodAny", ($, X) => { + i.init($, X), $._zod.parse = (J) => J; +}); +var I1 = q("$ZodUnknown", ($, X) => { + i.init($, X), $._zod.parse = (J) => J; +}); +var SY = q("$ZodNever", ($, X) => { + i.init($, X), $._zod.parse = (J, Q) => { + return J.issues.push({ expected: "never", code: "invalid_type", input: J.value, inst: $ }), J; + }; +}); +var vY = q("$ZodVoid", ($, X) => { + i.init($, X), $._zod.parse = (J, Q) => { + let Y = J.value; + if (typeof Y > "u") return J; + return J.issues.push({ expected: "void", code: "invalid_type", input: Y, inst: $ }), J; + }; +}); +var CY = q("$ZodDate", ($, X) => { + i.init($, X), $._zod.parse = (J, Q) => { + if (X.coerce) try { + J.value = new Date(J.value); + } catch (G) { + } + let Y = J.value, z6 = Y instanceof Date; + if (z6 && !Number.isNaN(Y.getTime())) return J; + return J.issues.push({ expected: "date", code: "invalid_type", input: Y, ...z6 ? { received: "Invalid Date" } : {}, inst: $ }), J; + }; +}); +function VN($, X, J) { + if ($.issues.length) X.issues.push(...$6(J, $.issues)); + X.value[J] = $.value; +} +var L0 = q("$ZodArray", ($, X) => { + i.init($, X), $._zod.parse = (J, Q) => { + let Y = J.value; + if (!Array.isArray(Y)) return J.issues.push({ expected: "array", code: "invalid_type", input: Y, inst: $ }), J; + J.value = Array(Y.length); + let z6 = []; + for (let W = 0; W < Y.length; W++) { + let G = Y[W], U = X.element._zod.run({ value: G, issues: [] }, Q); + if (U instanceof Promise) z6.push(U.then((H) => VN(H, J, W))); + else VN(U, J, W); + } + if (z6.length) return Promise.all(z6).then(() => J); + return J; + }; +}); +function XY($, X, J) { + if ($.issues.length) X.issues.push(...$6(J, $.issues)); + X.value[J] = $.value; +} +function ON($, X, J, Q) { + if ($.issues.length) if (Q[J] === void 0) if (J in Q) X.value[J] = void 0; + else X.value[J] = $.value; + else X.issues.push(...$6(J, $.issues)); + else if ($.value === void 0) { + if (J in Q) X.value[J] = void 0; + } else X.value[J] = $.value; +} +var j8 = q("$ZodObject", ($, X) => { + i.init($, X); + let J = N8(() => { + let V = Object.keys(X.shape); + for (let N of V) if (!(X.shape[N] instanceof i)) throw Error(`Invalid element at key "${N}": expected a Zod schema`); + let O = K5(X.shape); + return { shape: X.shape, keys: V, keySet: new Set(V), numKeys: V.length, optionalKeys: new Set(O) }; + }); + W$($._zod, "propValues", () => { + var _a3; + let V = X.shape, O = {}; + for (let N in V) { + let w = V[N]._zod; + if (w.values) { + (_a3 = O[N]) != null ? _a3 : O[N] = /* @__PURE__ */ new Set(); + for (let B of w.values) O[N].add(B); + } + } + return O; + }); + let Q = (V) => { + let O = new $Y(["shape", "payload", "ctx"]), N = J.value, w = (I) => { + let b = D1(I); + return `shape[${b}]._zod.run({ value: input[${b}], issues: [] }, ctx)`; + }; + O.write("const input = payload.value;"); + let B = /* @__PURE__ */ Object.create(null), L = 0; + for (let I of N.keys) B[I] = `key_${L++}`; + O.write("const newResult = {}"); + for (let I of N.keys) if (N.optionalKeys.has(I)) { + let b = B[I]; + O.write(`const ${b} = ${w(I)};`); + let x = D1(I); + O.write(` + if (${b}.issues.length) { + if (input[${x}] === undefined) { + if (${x} in input) { + newResult[${x}] = undefined; + } + } else { + payload.issues = payload.issues.concat( + ${b}.issues.map((iss) => ({ + ...iss, + path: iss.path ? [${x}, ...iss.path] : [${x}], + })) + ); + } + } else if (${b}.value === undefined) { + if (${x} in input) newResult[${x}] = undefined; + } else { + newResult[${x}] = ${b}.value; + } + `); + } else { + let b = B[I]; + O.write(`const ${b} = ${w(I)};`), O.write(` + if (${b}.issues.length) payload.issues = payload.issues.concat(${b}.issues.map(iss => ({ + ...iss, + path: iss.path ? [${D1(I)}, ...iss.path] : [${D1(I)}] + })));`), O.write(`newResult[${D1(I)}] = ${b}.value`); + } + O.write("payload.value = newResult;"), O.write("return payload;"); + let j = O.compile(); + return (I, b) => j(V, I, b); + }, Y, z6 = N0, W = !U8.jitless, U = W && U5.value, H = X.catchall, K; + $._zod.parse = (V, O) => { + K != null ? K : K = J.value; + let N = V.value; + if (!z6(N)) return V.issues.push({ expected: "object", code: "invalid_type", input: N, inst: $ }), V; + let w = []; + if (W && U && (O == null ? void 0 : O.async) === false && O.jitless !== true) { + if (!Y) Y = Q(X.shape); + V = Y(V, O); + } else { + V.value = {}; + let b = K.shape; + for (let x of K.keys) { + let h = b[x], B$ = h._zod.run({ value: N[x], issues: [] }, O), x$ = h._zod.optin === "optional" && h._zod.optout === "optional"; + if (B$ instanceof Promise) w.push(B$.then((G6) => x$ ? ON(G6, V, x, N) : XY(G6, V, x))); + else if (x$) ON(B$, V, x, N); + else XY(B$, V, x); + } + } + if (!H) return w.length ? Promise.all(w).then(() => V) : V; + let B = [], L = K.keySet, j = H._zod, I = j.def.type; + for (let b of Object.keys(N)) { + if (L.has(b)) continue; + if (I === "never") { + B.push(b); + continue; + } + let x = j.run({ value: N[b], issues: [] }, O); + if (x instanceof Promise) w.push(x.then((h) => XY(h, V, b))); + else XY(x, V, b); + } + if (B.length) V.issues.push({ code: "unrecognized_keys", keys: B, input: N, inst: $ }); + if (!w.length) return V; + return Promise.all(w).then(() => { + return V; + }); + }; +}); +function wN($, X, J, Q) { + for (let Y of $) if (Y.issues.length === 0) return X.value = Y.value, X; + return X.issues.push({ code: "invalid_union", input: X.value, inst: J, errors: $.map((Y) => Y.issues.map((z6) => O6(z6, Q, E$()))) }), X; +} +var F8 = q("$ZodUnion", ($, X) => { + i.init($, X), W$($._zod, "optin", () => X.options.some((J) => J._zod.optin === "optional") ? "optional" : void 0), W$($._zod, "optout", () => X.options.some((J) => J._zod.optout === "optional") ? "optional" : void 0), W$($._zod, "values", () => { + if (X.options.every((J) => J._zod.values)) return new Set(X.options.flatMap((J) => Array.from(J._zod.values))); + return; + }), W$($._zod, "pattern", () => { + if (X.options.every((J) => J._zod.pattern)) { + let J = X.options.map((Q) => Q._zod.pattern); + return new RegExp(`^(${J.map((Q) => V8(Q.source)).join("|")})$`); + } + return; + }), $._zod.parse = (J, Q) => { + let Y = false, z6 = []; + for (let W of X.options) { + let G = W._zod.run({ value: J.value, issues: [] }, Q); + if (G instanceof Promise) z6.push(G), Y = true; + else { + if (G.issues.length === 0) return G; + z6.push(G); + } + } + if (!Y) return wN(z6, J, $, Q); + return Promise.all(z6).then((W) => { + return wN(W, J, $, Q); + }); + }; +}); +var kY = q("$ZodDiscriminatedUnion", ($, X) => { + F8.init($, X); + let J = $._zod.parse; + W$($._zod, "propValues", () => { + let Y = {}; + for (let z6 of X.options) { + let W = z6._zod.propValues; + if (!W || Object.keys(W).length === 0) throw Error(`Invalid discriminated union option at index "${X.options.indexOf(z6)}"`); + for (let [G, U] of Object.entries(W)) { + if (!Y[G]) Y[G] = /* @__PURE__ */ new Set(); + for (let H of U) Y[G].add(H); + } + } + return Y; + }); + let Q = N8(() => { + let Y = X.options, z6 = /* @__PURE__ */ new Map(); + for (let W of Y) { + let G = W._zod.propValues[X.discriminator]; + if (!G || G.size === 0) throw Error(`Invalid discriminated union option at index "${X.options.indexOf(W)}"`); + for (let U of G) { + if (z6.has(U)) throw Error(`Duplicate discriminator value "${String(U)}"`); + z6.set(U, W); + } + } + return z6; + }); + $._zod.parse = (Y, z6) => { + let W = Y.value; + if (!N0(W)) return Y.issues.push({ code: "invalid_type", expected: "object", input: W, inst: $ }), Y; + let G = Q.value.get(W == null ? void 0 : W[X.discriminator]); + if (G) return G._zod.run(Y, z6); + if (X.unionFallback) return J(Y, z6); + return Y.issues.push({ code: "invalid_union", errors: [], note: "No matching discriminator", input: W, path: [X.discriminator], inst: $ }), Y; + }; +}); +var _Y = q("$ZodIntersection", ($, X) => { + i.init($, X), $._zod.parse = (J, Q) => { + let Y = J.value, z6 = X.left._zod.run({ value: Y, issues: [] }, Q), W = X.right._zod.run({ value: Y, issues: [] }, Q); + if (z6 instanceof Promise || W instanceof Promise) return Promise.all([z6, W]).then(([U, H]) => { + return BN(J, U, H); + }); + return BN(J, z6, W); + }; +}); +function UW($, X) { + if ($ === X) return { valid: true, data: $ }; + if ($ instanceof Date && X instanceof Date && +$ === +X) return { valid: true, data: $ }; + if (V0($) && V0(X)) { + let J = Object.keys(X), Q = Object.keys($).filter((z6) => J.indexOf(z6) !== -1), Y = { ...$, ...X }; + for (let z6 of Q) { + let W = UW($[z6], X[z6]); + if (!W.valid) return { valid: false, mergeErrorPath: [z6, ...W.mergeErrorPath] }; + Y[z6] = W.data; + } + return { valid: true, data: Y }; + } + if (Array.isArray($) && Array.isArray(X)) { + if ($.length !== X.length) return { valid: false, mergeErrorPath: [] }; + let J = []; + for (let Q = 0; Q < $.length; Q++) { + let Y = $[Q], z6 = X[Q], W = UW(Y, z6); + if (!W.valid) return { valid: false, mergeErrorPath: [Q, ...W.mergeErrorPath] }; + J.push(W.data); + } + return { valid: true, data: J }; + } + return { valid: false, mergeErrorPath: [] }; +} +function BN($, X, J) { + if (X.issues.length) $.issues.push(...X.issues); + if (J.issues.length) $.issues.push(...J.issues); + if (L1($)) return $; + let Q = UW(X.value, J.value); + if (!Q.valid) throw Error(`Unmergable intersection. Error path: ${JSON.stringify(Q.mergeErrorPath)}`); + return $.value = Q.data, $; +} +var y4 = q("$ZodTuple", ($, X) => { + i.init($, X); + let J = X.items, Q = J.length - [...J].reverse().findIndex((Y) => Y._zod.optin !== "optional"); + $._zod.parse = (Y, z6) => { + let W = Y.value; + if (!Array.isArray(W)) return Y.issues.push({ input: W, inst: $, expected: "tuple", code: "invalid_type" }), Y; + Y.value = []; + let G = []; + if (!X.rest) { + let H = W.length > J.length, K = W.length < Q - 1; + if (H || K) return Y.issues.push({ input: W, inst: $, origin: "array", ...H ? { code: "too_big", maximum: J.length } : { code: "too_small", minimum: J.length } }), Y; + } + let U = -1; + for (let H of J) { + if (U++, U >= W.length) { + if (U >= Q) continue; + } + let K = H._zod.run({ value: W[U], issues: [] }, z6); + if (K instanceof Promise) G.push(K.then((V) => JY(V, Y, U))); + else JY(K, Y, U); + } + if (X.rest) { + let H = W.slice(J.length); + for (let K of H) { + U++; + let V = X.rest._zod.run({ value: K, issues: [] }, z6); + if (V instanceof Promise) G.push(V.then((O) => JY(O, Y, U))); + else JY(V, Y, U); + } + } + if (G.length) return Promise.all(G).then(() => Y); + return Y; + }; +}); +function JY($, X, J) { + if ($.issues.length) X.issues.push(...$6(J, $.issues)); + X.value[J] = $.value; +} +var xY = q("$ZodRecord", ($, X) => { + i.init($, X), $._zod.parse = (J, Q) => { + let Y = J.value; + if (!V0(Y)) return J.issues.push({ expected: "record", code: "invalid_type", input: Y, inst: $ }), J; + let z6 = []; + if (X.keyType._zod.values) { + let W = X.keyType._zod.values; + J.value = {}; + for (let U of W) if (typeof U === "string" || typeof U === "number" || typeof U === "symbol") { + let H = X.valueType._zod.run({ value: Y[U], issues: [] }, Q); + if (H instanceof Promise) z6.push(H.then((K) => { + if (K.issues.length) J.issues.push(...$6(U, K.issues)); + J.value[U] = K.value; + })); + else { + if (H.issues.length) J.issues.push(...$6(U, H.issues)); + J.value[U] = H.value; + } + } + let G; + for (let U in Y) if (!W.has(U)) G = G != null ? G : [], G.push(U); + if (G && G.length > 0) J.issues.push({ code: "unrecognized_keys", input: Y, inst: $, keys: G }); + } else { + J.value = {}; + for (let W of Reflect.ownKeys(Y)) { + if (W === "__proto__") continue; + let G = X.keyType._zod.run({ value: W, issues: [] }, Q); + if (G instanceof Promise) throw Error("Async schemas not supported in object keys currently"); + if (G.issues.length) { + J.issues.push({ origin: "record", code: "invalid_key", issues: G.issues.map((H) => O6(H, Q, E$())), input: W, path: [W], inst: $ }), J.value[G.value] = G.value; + continue; + } + let U = X.valueType._zod.run({ value: Y[W], issues: [] }, Q); + if (U instanceof Promise) z6.push(U.then((H) => { + if (H.issues.length) J.issues.push(...$6(W, H.issues)); + J.value[G.value] = H.value; + })); + else { + if (U.issues.length) J.issues.push(...$6(W, U.issues)); + J.value[G.value] = U.value; + } + } + } + if (z6.length) return Promise.all(z6).then(() => J); + return J; + }; +}); +var TY = q("$ZodMap", ($, X) => { + i.init($, X), $._zod.parse = (J, Q) => { + let Y = J.value; + if (!(Y instanceof Map)) return J.issues.push({ expected: "map", code: "invalid_type", input: Y, inst: $ }), J; + let z6 = []; + J.value = /* @__PURE__ */ new Map(); + for (let [W, G] of Y) { + let U = X.keyType._zod.run({ value: W, issues: [] }, Q), H = X.valueType._zod.run({ value: G, issues: [] }, Q); + if (U instanceof Promise || H instanceof Promise) z6.push(Promise.all([U, H]).then(([K, V]) => { + qN(K, V, J, W, Y, $, Q); + })); + else qN(U, H, J, W, Y, $, Q); + } + if (z6.length) return Promise.all(z6).then(() => J); + return J; + }; +}); +function qN($, X, J, Q, Y, z6, W) { + if ($.issues.length) if (O8.has(typeof Q)) J.issues.push(...$6(Q, $.issues)); + else J.issues.push({ origin: "map", code: "invalid_key", input: Y, inst: z6, issues: $.issues.map((G) => O6(G, W, E$())) }); + if (X.issues.length) if (O8.has(typeof Q)) J.issues.push(...$6(Q, X.issues)); + else J.issues.push({ origin: "map", code: "invalid_element", input: Y, inst: z6, key: Q, issues: X.issues.map((G) => O6(G, W, E$())) }); + J.value.set($.value, X.value); +} +var yY = q("$ZodSet", ($, X) => { + i.init($, X), $._zod.parse = (J, Q) => { + let Y = J.value; + if (!(Y instanceof Set)) return J.issues.push({ input: Y, inst: $, expected: "set", code: "invalid_type" }), J; + let z6 = []; + J.value = /* @__PURE__ */ new Set(); + for (let W of Y) { + let G = X.valueType._zod.run({ value: W, issues: [] }, Q); + if (G instanceof Promise) z6.push(G.then((U) => DN(U, J))); + else DN(G, J); + } + if (z6.length) return Promise.all(z6).then(() => J); + return J; + }; +}); +function DN($, X) { + if ($.issues.length) X.issues.push(...$.issues); + X.value.add($.value); +} +var fY = q("$ZodEnum", ($, X) => { + i.init($, X); + let J = K8(X.entries); + $._zod.values = new Set(J), $._zod.pattern = new RegExp(`^(${J.filter((Q) => O8.has(typeof Q)).map((Q) => typeof Q === "string" ? H4(Q) : Q.toString()).join("|")})$`), $._zod.parse = (Q, Y) => { + let z6 = Q.value; + if ($._zod.values.has(z6)) return Q; + return Q.issues.push({ code: "invalid_value", values: J, input: z6, inst: $ }), Q; + }; +}); +var gY = q("$ZodLiteral", ($, X) => { + i.init($, X), $._zod.values = new Set(X.values), $._zod.pattern = new RegExp(`^(${X.values.map((J) => typeof J === "string" ? H4(J) : J ? J.toString() : String(J)).join("|")})$`), $._zod.parse = (J, Q) => { + let Y = J.value; + if ($._zod.values.has(Y)) return J; + return J.issues.push({ code: "invalid_value", values: X.values, input: Y, inst: $ }), J; + }; +}); +var hY = q("$ZodFile", ($, X) => { + i.init($, X), $._zod.parse = (J, Q) => { + let Y = J.value; + if (Y instanceof File) return J; + return J.issues.push({ expected: "file", code: "invalid_type", input: Y, inst: $ }), J; + }; +}); +var j0 = q("$ZodTransform", ($, X) => { + i.init($, X), $._zod.parse = (J, Q) => { + let Y = X.transform(J.value, J); + if (Q.async) return (Y instanceof Promise ? Y : Promise.resolve(Y)).then((W) => { + return J.value = W, J; + }); + if (Y instanceof Promise) throw new U4(); + return J.value = Y, J; + }; +}); +var uY = q("$ZodOptional", ($, X) => { + i.init($, X), $._zod.optin = "optional", $._zod.optout = "optional", W$($._zod, "values", () => { + return X.innerType._zod.values ? /* @__PURE__ */ new Set([...X.innerType._zod.values, void 0]) : void 0; + }), W$($._zod, "pattern", () => { + let J = X.innerType._zod.pattern; + return J ? new RegExp(`^(${V8(J.source)})?$`) : void 0; + }), $._zod.parse = (J, Q) => { + if (X.innerType._zod.optin === "optional") return X.innerType._zod.run(J, Q); + if (J.value === void 0) return J; + return X.innerType._zod.run(J, Q); + }; +}); +var mY = q("$ZodNullable", ($, X) => { + i.init($, X), W$($._zod, "optin", () => X.innerType._zod.optin), W$($._zod, "optout", () => X.innerType._zod.optout), W$($._zod, "pattern", () => { + let J = X.innerType._zod.pattern; + return J ? new RegExp(`^(${V8(J.source)}|null)$`) : void 0; + }), W$($._zod, "values", () => { + return X.innerType._zod.values ? /* @__PURE__ */ new Set([...X.innerType._zod.values, null]) : void 0; + }), $._zod.parse = (J, Q) => { + if (J.value === null) return J; + return X.innerType._zod.run(J, Q); + }; +}); +var lY = q("$ZodDefault", ($, X) => { + i.init($, X), $._zod.optin = "optional", W$($._zod, "values", () => X.innerType._zod.values), $._zod.parse = (J, Q) => { + if (J.value === void 0) return J.value = X.defaultValue, J; + let Y = X.innerType._zod.run(J, Q); + if (Y instanceof Promise) return Y.then((z6) => LN(z6, X)); + return LN(Y, X); + }; +}); +function LN($, X) { + if ($.value === void 0) $.value = X.defaultValue; + return $; +} +var cY = q("$ZodPrefault", ($, X) => { + i.init($, X), $._zod.optin = "optional", W$($._zod, "values", () => X.innerType._zod.values), $._zod.parse = (J, Q) => { + if (J.value === void 0) J.value = X.defaultValue; + return X.innerType._zod.run(J, Q); + }; +}); +var pY = q("$ZodNonOptional", ($, X) => { + i.init($, X), W$($._zod, "values", () => { + let J = X.innerType._zod.values; + return J ? new Set([...J].filter((Q) => Q !== void 0)) : void 0; + }), $._zod.parse = (J, Q) => { + let Y = X.innerType._zod.run(J, Q); + if (Y instanceof Promise) return Y.then((z6) => jN(z6, $)); + return jN(Y, $); + }; +}); +function jN($, X) { + if (!$.issues.length && $.value === void 0) $.issues.push({ code: "invalid_type", expected: "nonoptional", input: $.value, inst: X }); + return $; +} +var iY = q("$ZodSuccess", ($, X) => { + i.init($, X), $._zod.parse = (J, Q) => { + let Y = X.innerType._zod.run(J, Q); + if (Y instanceof Promise) return Y.then((z6) => { + return J.value = z6.issues.length === 0, J; + }); + return J.value = Y.issues.length === 0, J; + }; +}); +var nY = q("$ZodCatch", ($, X) => { + i.init($, X), $._zod.optin = "optional", W$($._zod, "optout", () => X.innerType._zod.optout), W$($._zod, "values", () => X.innerType._zod.values), $._zod.parse = (J, Q) => { + let Y = X.innerType._zod.run(J, Q); + if (Y instanceof Promise) return Y.then((z6) => { + if (J.value = z6.value, z6.issues.length) J.value = X.catchValue({ ...J, error: { issues: z6.issues.map((W) => O6(W, Q, E$())) }, input: J.value }), J.issues = []; + return J; + }); + if (J.value = Y.value, Y.issues.length) J.value = X.catchValue({ ...J, error: { issues: Y.issues.map((z6) => O6(z6, Q, E$())) }, input: J.value }), J.issues = []; + return J; + }; +}); +var dY = q("$ZodNaN", ($, X) => { + i.init($, X), $._zod.parse = (J, Q) => { + if (typeof J.value !== "number" || !Number.isNaN(J.value)) return J.issues.push({ input: J.value, inst: $, expected: "nan", code: "invalid_type" }), J; + return J; + }; +}); +var F0 = q("$ZodPipe", ($, X) => { + i.init($, X), W$($._zod, "values", () => X.in._zod.values), W$($._zod, "optin", () => X.in._zod.optin), W$($._zod, "optout", () => X.out._zod.optout), $._zod.parse = (J, Q) => { + let Y = X.in._zod.run(J, Q); + if (Y instanceof Promise) return Y.then((z6) => FN(z6, X, Q)); + return FN(Y, X, Q); + }; +}); +function FN($, X, J) { + if (L1($)) return $; + return X.out._zod.run({ value: $.value, issues: $.issues }, J); +} +var rY = q("$ZodReadonly", ($, X) => { + i.init($, X), W$($._zod, "propValues", () => X.innerType._zod.propValues), W$($._zod, "values", () => X.innerType._zod.values), W$($._zod, "optin", () => X.innerType._zod.optin), W$($._zod, "optout", () => X.innerType._zod.optout), $._zod.parse = (J, Q) => { + let Y = X.innerType._zod.run(J, Q); + if (Y instanceof Promise) return Y.then(MN); + return MN(Y); + }; +}); +function MN($) { + return $.value = Object.freeze($.value), $; +} +var oY = q("$ZodTemplateLiteral", ($, X) => { + i.init($, X); + let J = []; + for (let Q of X.parts) if (Q instanceof i) { + if (!Q._zod.pattern) throw Error(`Invalid template literal part, no pattern found: ${[...Q._zod.traits].shift()}`); + let Y = Q._zod.pattern instanceof RegExp ? Q._zod.pattern.source : Q._zod.pattern; + if (!Y) throw Error(`Invalid template literal part: ${Q._zod.traits}`); + let z6 = Y.startsWith("^") ? 1 : 0, W = Y.endsWith("$") ? Y.length - 1 : Y.length; + J.push(Y.slice(z6, W)); + } else if (Q === null || H5.has(typeof Q)) J.push(H4(`${Q}`)); + else throw Error(`Invalid template literal part: ${Q}`); + $._zod.pattern = new RegExp(`^${J.join("")}$`), $._zod.parse = (Q, Y) => { + if (typeof Q.value !== "string") return Q.issues.push({ input: Q.value, inst: $, expected: "template_literal", code: "invalid_type" }), Q; + if ($._zod.pattern.lastIndex = 0, !$._zod.pattern.test(Q.value)) return Q.issues.push({ input: Q.value, inst: $, code: "invalid_format", format: "template_literal", pattern: $._zod.pattern.source }), Q; + return Q; + }; +}); +var tY = q("$ZodPromise", ($, X) => { + i.init($, X), $._zod.parse = (J, Q) => { + return Promise.resolve(J.value).then((Y) => X.innerType._zod.run({ value: Y, issues: [] }, Q)); + }; +}); +var aY = q("$ZodLazy", ($, X) => { + i.init($, X), W$($._zod, "innerType", () => X.getter()), W$($._zod, "pattern", () => $._zod.innerType._zod.pattern), W$($._zod, "propValues", () => $._zod.innerType._zod.propValues), W$($._zod, "optin", () => $._zod.innerType._zod.optin), W$($._zod, "optout", () => $._zod.innerType._zod.optout), $._zod.parse = (J, Q) => { + return $._zod.innerType._zod.run(J, Q); + }; +}); +var sY = q("$ZodCustom", ($, X) => { + M$.init($, X), i.init($, X), $._zod.parse = (J, Q) => { + return J; + }, $._zod.check = (J) => { + let Q = J.value, Y = X.fn(Q); + if (Y instanceof Promise) return Y.then((z6) => IN(z6, J, Q, $)); + IN(Y, J, Q, $); + return; + }; +}); +function IN($, X, J, Q) { + var _a3; + if (!$) { + let Y = { code: "custom", input: J, inst: Q, path: [...(_a3 = Q._zod.def.path) != null ? _a3 : []], continue: !Q._zod.def.abort }; + if (Q._zod.def.params) Y.params = Q._zod.def.params; + X.issues.push(O5(Y)); + } +} +var M0 = {}; +$1(M0, { zhTW: () => aW, zhCN: () => tW, vi: () => oW, ur: () => rW, ua: () => dW, tr: () => nW, th: () => iW, ta: () => pW, sv: () => cW, sl: () => lW, ru: () => mW, pt: () => uW, ps: () => gW, pl: () => hW, ota: () => fW, no: () => yW, nl: () => TW, ms: () => xW, mk: () => _W, ko: () => kW, kh: () => CW, ja: () => vW, it: () => SW, id: () => RW, hu: () => EW, he: () => ZW, frCA: () => PW, fr: () => bW, fi: () => AW, fa: () => IW, es: () => MW, eo: () => FW, en: () => M8, de: () => jW, cs: () => LW, ca: () => DW, be: () => qW, az: () => BW, ar: () => wW }); +var BA = () => { + let $ = { string: { unit: "\u062D\u0631\u0641", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" }, file: { unit: "\u0628\u0627\u064A\u062A", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" }, array: { unit: "\u0639\u0646\u0635\u0631", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" }, set: { unit: "\u0639\u0646\u0635\u0631", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "number"; + case "object": { + if (Array.isArray(Y)) return "array"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "\u0645\u062F\u062E\u0644", email: "\u0628\u0631\u064A\u062F \u0625\u0644\u0643\u062A\u0631\u0648\u0646\u064A", url: "\u0631\u0627\u0628\u0637", emoji: "\u0625\u064A\u0645\u0648\u062C\u064A", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "\u062A\u0627\u0631\u064A\u062E \u0648\u0648\u0642\u062A \u0628\u0645\u0639\u064A\u0627\u0631 ISO", date: "\u062A\u0627\u0631\u064A\u062E \u0628\u0645\u0639\u064A\u0627\u0631 ISO", time: "\u0648\u0642\u062A \u0628\u0645\u0639\u064A\u0627\u0631 ISO", duration: "\u0645\u062F\u0629 \u0628\u0645\u0639\u064A\u0627\u0631 ISO", ipv4: "\u0639\u0646\u0648\u0627\u0646 IPv4", ipv6: "\u0639\u0646\u0648\u0627\u0646 IPv6", cidrv4: "\u0645\u062F\u0649 \u0639\u0646\u0627\u0648\u064A\u0646 \u0628\u0635\u064A\u063A\u0629 IPv4", cidrv6: "\u0645\u062F\u0649 \u0639\u0646\u0627\u0648\u064A\u0646 \u0628\u0635\u064A\u063A\u0629 IPv6", base64: "\u0646\u064E\u0635 \u0628\u062A\u0631\u0645\u064A\u0632 base64-encoded", base64url: "\u0646\u064E\u0635 \u0628\u062A\u0631\u0645\u064A\u0632 base64url-encoded", json_string: "\u0646\u064E\u0635 \u0639\u0644\u0649 \u0647\u064A\u0626\u0629 JSON", e164: "\u0631\u0642\u0645 \u0647\u0627\u062A\u0641 \u0628\u0645\u0639\u064A\u0627\u0631 E.164", jwt: "JWT", template_literal: "\u0645\u062F\u062E\u0644" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `\u0645\u062F\u062E\u0644\u0627\u062A \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644\u0629: \u064A\u0641\u062A\u0631\u0636 \u0625\u062F\u062E\u0627\u0644 ${Y.expected}\u060C \u0648\u0644\u0643\u0646 \u062A\u0645 \u0625\u062F\u062E\u0627\u0644 ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `\u0645\u062F\u062E\u0644\u0627\u062A \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644\u0629: \u064A\u0641\u062A\u0631\u0636 \u0625\u062F\u062E\u0627\u0644 ${S(Y.values[0])}`; + return `\u0627\u062E\u062A\u064A\u0627\u0631 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062A\u0648\u0642\u0639 \u0627\u0646\u062A\u0642\u0627\u0621 \u0623\u062D\u062F \u0647\u0630\u0647 \u0627\u0644\u062E\u064A\u0627\u0631\u0627\u062A: ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return ` \u0623\u0643\u0628\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0623\u0646 \u062A\u0643\u0648\u0646 ${(_a3 = Y.origin) != null ? _a3 : "\u0627\u0644\u0642\u064A\u0645\u0629"} ${z6} ${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "\u0639\u0646\u0635\u0631"}`; + return `\u0623\u0643\u0628\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0623\u0646 \u062A\u0643\u0648\u0646 ${(_c = Y.origin) != null ? _c : "\u0627\u0644\u0642\u064A\u0645\u0629"} ${z6} ${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `\u0623\u0635\u063A\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0644\u0640 ${Y.origin} \u0623\u0646 \u064A\u0643\u0648\u0646 ${z6} ${Y.minimum.toString()} ${W.unit}`; + return `\u0623\u0635\u063A\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0644\u0640 ${Y.origin} \u0623\u0646 \u064A\u0643\u0648\u0646 ${z6} ${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0628\u062F\u0623 \u0628\u0640 "${Y.prefix}"`; + if (z6.format === "ends_with") return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0646\u062A\u0647\u064A \u0628\u0640 "${z6.suffix}"`; + if (z6.format === "includes") return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u062A\u0636\u0645\u0651\u064E\u0646 "${z6.includes}"`; + if (z6.format === "regex") return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0637\u0627\u0628\u0642 \u0627\u0644\u0646\u0645\u0637 ${z6.pattern}`; + return `${(_d = Q[z6.format]) != null ? _d : Y.format} \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644`; + } + case "not_multiple_of": + return `\u0631\u0642\u0645 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0643\u0648\u0646 \u0645\u0646 \u0645\u0636\u0627\u0639\u0641\u0627\u062A ${Y.divisor}`; + case "unrecognized_keys": + return `\u0645\u0639\u0631\u0641${Y.keys.length > 1 ? "\u0627\u062A" : ""} \u063A\u0631\u064A\u0628${Y.keys.length > 1 ? "\u0629" : ""}: ${M(Y.keys, "\u060C ")}`; + case "invalid_key": + return `\u0645\u0639\u0631\u0641 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644 \u0641\u064A ${Y.origin}`; + case "invalid_union": + return "\u0645\u062F\u062E\u0644 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644"; + case "invalid_element": + return `\u0645\u062F\u062E\u0644 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644 \u0641\u064A ${Y.origin}`; + default: + return "\u0645\u062F\u062E\u0644 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644"; + } + }; +}; +function wW() { + return { localeError: BA() }; +} +var qA = () => { + let $ = { string: { unit: "simvol", verb: "olmal\u0131d\u0131r" }, file: { unit: "bayt", verb: "olmal\u0131d\u0131r" }, array: { unit: "element", verb: "olmal\u0131d\u0131r" }, set: { unit: "element", verb: "olmal\u0131d\u0131r" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "number"; + case "object": { + if (Array.isArray(Y)) return "array"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "input", email: "email address", url: "URL", emoji: "emoji", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "ISO datetime", date: "ISO date", time: "ISO time", duration: "ISO duration", ipv4: "IPv4 address", ipv6: "IPv6 address", cidrv4: "IPv4 range", cidrv6: "IPv6 range", base64: "base64-encoded string", base64url: "base64url-encoded string", json_string: "JSON string", e164: "E.164 number", jwt: "JWT", template_literal: "input" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `Yanl\u0131\u015F d\u0259y\u0259r: g\xF6zl\u0259nil\u0259n ${Y.expected}, daxil olan ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `Yanl\u0131\u015F d\u0259y\u0259r: g\xF6zl\u0259nil\u0259n ${S(Y.values[0])}`; + return `Yanl\u0131\u015F se\xE7im: a\u015Fa\u011F\u0131dak\u0131lardan biri olmal\u0131d\u0131r: ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `\xC7ox b\xF6y\xFCk: g\xF6zl\u0259nil\u0259n ${(_a3 = Y.origin) != null ? _a3 : "d\u0259y\u0259r"} ${z6}${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "element"}`; + return `\xC7ox b\xF6y\xFCk: g\xF6zl\u0259nil\u0259n ${(_c = Y.origin) != null ? _c : "d\u0259y\u0259r"} ${z6}${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `\xC7ox ki\xE7ik: g\xF6zl\u0259nil\u0259n ${Y.origin} ${z6}${Y.minimum.toString()} ${W.unit}`; + return `\xC7ox ki\xE7ik: g\xF6zl\u0259nil\u0259n ${Y.origin} ${z6}${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `Yanl\u0131\u015F m\u0259tn: "${z6.prefix}" il\u0259 ba\u015Flamal\u0131d\u0131r`; + if (z6.format === "ends_with") return `Yanl\u0131\u015F m\u0259tn: "${z6.suffix}" il\u0259 bitm\u0259lidir`; + if (z6.format === "includes") return `Yanl\u0131\u015F m\u0259tn: "${z6.includes}" daxil olmal\u0131d\u0131r`; + if (z6.format === "regex") return `Yanl\u0131\u015F m\u0259tn: ${z6.pattern} \u015Fablonuna uy\u011Fun olmal\u0131d\u0131r`; + return `Yanl\u0131\u015F ${(_d = Q[z6.format]) != null ? _d : Y.format}`; + } + case "not_multiple_of": + return `Yanl\u0131\u015F \u0259d\u0259d: ${Y.divisor} il\u0259 b\xF6l\xFCn\u0259 bil\u0259n olmal\u0131d\u0131r`; + case "unrecognized_keys": + return `Tan\u0131nmayan a\xE7ar${Y.keys.length > 1 ? "lar" : ""}: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `${Y.origin} daxilind\u0259 yanl\u0131\u015F a\xE7ar`; + case "invalid_union": + return "Yanl\u0131\u015F d\u0259y\u0259r"; + case "invalid_element": + return `${Y.origin} daxilind\u0259 yanl\u0131\u015F d\u0259y\u0259r`; + default: + return "Yanl\u0131\u015F d\u0259y\u0259r"; + } + }; +}; +function BW() { + return { localeError: qA() }; +} +function ZN($, X, J, Q) { + let Y = Math.abs($), z6 = Y % 10, W = Y % 100; + if (W >= 11 && W <= 19) return Q; + if (z6 === 1) return X; + if (z6 >= 2 && z6 <= 4) return J; + return Q; +} +var DA = () => { + let $ = { string: { unit: { one: "\u0441\u0456\u043C\u0432\u0430\u043B", few: "\u0441\u0456\u043C\u0432\u0430\u043B\u044B", many: "\u0441\u0456\u043C\u0432\u0430\u043B\u0430\u045E" }, verb: "\u043C\u0435\u0446\u044C" }, array: { unit: { one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442", few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u044B", many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430\u045E" }, verb: "\u043C\u0435\u0446\u044C" }, set: { unit: { one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442", few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u044B", many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430\u045E" }, verb: "\u043C\u0435\u0446\u044C" }, file: { unit: { one: "\u0431\u0430\u0439\u0442", few: "\u0431\u0430\u0439\u0442\u044B", many: "\u0431\u0430\u0439\u0442\u0430\u045E" }, verb: "\u043C\u0435\u0446\u044C" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "\u043B\u0456\u043A"; + case "object": { + if (Array.isArray(Y)) return "\u043C\u0430\u0441\u0456\u045E"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "\u0443\u0432\u043E\u0434", email: "email \u0430\u0434\u0440\u0430\u0441", url: "URL", emoji: "\u044D\u043C\u043E\u0434\u0437\u0456", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "ISO \u0434\u0430\u0442\u0430 \u0456 \u0447\u0430\u0441", date: "ISO \u0434\u0430\u0442\u0430", time: "ISO \u0447\u0430\u0441", duration: "ISO \u043F\u0440\u0430\u0446\u044F\u0433\u043B\u0430\u0441\u0446\u044C", ipv4: "IPv4 \u0430\u0434\u0440\u0430\u0441", ipv6: "IPv6 \u0430\u0434\u0440\u0430\u0441", cidrv4: "IPv4 \u0434\u044B\u044F\u043F\u0430\u0437\u043E\u043D", cidrv6: "IPv6 \u0434\u044B\u044F\u043F\u0430\u0437\u043E\u043D", base64: "\u0440\u0430\u0434\u043E\u043A \u0443 \u0444\u0430\u0440\u043C\u0430\u0446\u0435 base64", base64url: "\u0440\u0430\u0434\u043E\u043A \u0443 \u0444\u0430\u0440\u043C\u0430\u0446\u0435 base64url", json_string: "JSON \u0440\u0430\u0434\u043E\u043A", e164: "\u043D\u0443\u043C\u0430\u0440 E.164", jwt: "JWT", template_literal: "\u0443\u0432\u043E\u0434" }; + return (Y) => { + var _a3, _b2, _c; + switch (Y.code) { + case "invalid_type": + return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434: \u0447\u0430\u043A\u0430\u045E\u0441\u044F ${Y.expected}, \u0430\u0442\u0440\u044B\u043C\u0430\u043D\u0430 ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F ${S(Y.values[0])}`; + return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0432\u0430\u0440\u044B\u044F\u043D\u0442: \u0447\u0430\u043A\u0430\u045E\u0441\u044F \u0430\u0434\u0437\u0456\u043D \u0437 ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) { + let G = Number(Y.maximum), U = ZN(G, W.unit.one, W.unit.few, W.unit.many); + return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u0432\u044F\u043B\u0456\u043A\u0456: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${(_a3 = Y.origin) != null ? _a3 : "\u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435"} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 ${W.verb} ${z6}${Y.maximum.toString()} ${U}`; + } + return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u0432\u044F\u043B\u0456\u043A\u0456: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${(_b2 = Y.origin) != null ? _b2 : "\u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435"} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 \u0431\u044B\u0446\u044C ${z6}${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) { + let G = Number(Y.minimum), U = ZN(G, W.unit.one, W.unit.few, W.unit.many); + return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u043C\u0430\u043B\u044B: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${Y.origin} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 ${W.verb} ${z6}${Y.minimum.toString()} ${U}`; + } + return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u043C\u0430\u043B\u044B: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${Y.origin} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 \u0431\u044B\u0446\u044C ${z6}${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u043F\u0430\u0447\u044B\u043D\u0430\u0446\u0446\u0430 \u0437 "${z6.prefix}"`; + if (z6.format === "ends_with") return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0437\u0430\u043A\u0430\u043D\u0447\u0432\u0430\u0446\u0446\u0430 \u043D\u0430 "${z6.suffix}"`; + if (z6.format === "includes") return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0437\u043C\u044F\u0448\u0447\u0430\u0446\u044C "${z6.includes}"`; + if (z6.format === "regex") return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0430\u0434\u043F\u0430\u0432\u044F\u0434\u0430\u0446\u044C \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${z6.pattern}`; + return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B ${(_c = Q[z6.format]) != null ? _c : Y.format}`; + } + case "not_multiple_of": + return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u043B\u0456\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0431\u044B\u0446\u044C \u043A\u0440\u0430\u0442\u043D\u044B\u043C ${Y.divisor}`; + case "unrecognized_keys": + return `\u041D\u0435\u0440\u0430\u0441\u043F\u0430\u0437\u043D\u0430\u043D\u044B ${Y.keys.length > 1 ? "\u043A\u043B\u044E\u0447\u044B" : "\u043A\u043B\u044E\u0447"}: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u043A\u043B\u044E\u0447 \u0443 ${Y.origin}`; + case "invalid_union": + return "\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434"; + case "invalid_element": + return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u0430\u0435 \u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435 \u045E ${Y.origin}`; + default: + return "\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434"; + } + }; +}; +function qW() { + return { localeError: DA() }; +} +var LA = () => { + let $ = { string: { unit: "car\xE0cters", verb: "contenir" }, file: { unit: "bytes", verb: "contenir" }, array: { unit: "elements", verb: "contenir" }, set: { unit: "elements", verb: "contenir" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "number"; + case "object": { + if (Array.isArray(Y)) return "array"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "entrada", email: "adre\xE7a electr\xF2nica", url: "URL", emoji: "emoji", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "data i hora ISO", date: "data ISO", time: "hora ISO", duration: "durada ISO", ipv4: "adre\xE7a IPv4", ipv6: "adre\xE7a IPv6", cidrv4: "rang IPv4", cidrv6: "rang IPv6", base64: "cadena codificada en base64", base64url: "cadena codificada en base64url", json_string: "cadena JSON", e164: "n\xFAmero E.164", jwt: "JWT", template_literal: "entrada" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `Tipus inv\xE0lid: s'esperava ${Y.expected}, s'ha rebut ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `Valor inv\xE0lid: s'esperava ${S(Y.values[0])}`; + return `Opci\xF3 inv\xE0lida: s'esperava una de ${M(Y.values, " o ")}`; + case "too_big": { + let z6 = Y.inclusive ? "com a m\xE0xim" : "menys de", W = X(Y.origin); + if (W) return `Massa gran: s'esperava que ${(_a3 = Y.origin) != null ? _a3 : "el valor"} contingu\xE9s ${z6} ${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "elements"}`; + return `Massa gran: s'esperava que ${(_c = Y.origin) != null ? _c : "el valor"} fos ${z6} ${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? "com a m\xEDnim" : "m\xE9s de", W = X(Y.origin); + if (W) return `Massa petit: s'esperava que ${Y.origin} contingu\xE9s ${z6} ${Y.minimum.toString()} ${W.unit}`; + return `Massa petit: s'esperava que ${Y.origin} fos ${z6} ${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `Format inv\xE0lid: ha de comen\xE7ar amb "${z6.prefix}"`; + if (z6.format === "ends_with") return `Format inv\xE0lid: ha d'acabar amb "${z6.suffix}"`; + if (z6.format === "includes") return `Format inv\xE0lid: ha d'incloure "${z6.includes}"`; + if (z6.format === "regex") return `Format inv\xE0lid: ha de coincidir amb el patr\xF3 ${z6.pattern}`; + return `Format inv\xE0lid per a ${(_d = Q[z6.format]) != null ? _d : Y.format}`; + } + case "not_multiple_of": + return `N\xFAmero inv\xE0lid: ha de ser m\xFAltiple de ${Y.divisor}`; + case "unrecognized_keys": + return `Clau${Y.keys.length > 1 ? "s" : ""} no reconeguda${Y.keys.length > 1 ? "s" : ""}: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `Clau inv\xE0lida a ${Y.origin}`; + case "invalid_union": + return "Entrada inv\xE0lida"; + case "invalid_element": + return `Element inv\xE0lid a ${Y.origin}`; + default: + return "Entrada inv\xE0lida"; + } + }; +}; +function DW() { + return { localeError: LA() }; +} +var jA = () => { + let $ = { string: { unit: "znak\u016F", verb: "m\xEDt" }, file: { unit: "bajt\u016F", verb: "m\xEDt" }, array: { unit: "prvk\u016F", verb: "m\xEDt" }, set: { unit: "prvk\u016F", verb: "m\xEDt" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "\u010D\xEDslo"; + case "string": + return "\u0159et\u011Bzec"; + case "boolean": + return "boolean"; + case "bigint": + return "bigint"; + case "function": + return "funkce"; + case "symbol": + return "symbol"; + case "undefined": + return "undefined"; + case "object": { + if (Array.isArray(Y)) return "pole"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "regul\xE1rn\xED v\xFDraz", email: "e-mailov\xE1 adresa", url: "URL", emoji: "emoji", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "datum a \u010Das ve form\xE1tu ISO", date: "datum ve form\xE1tu ISO", time: "\u010Das ve form\xE1tu ISO", duration: "doba trv\xE1n\xED ISO", ipv4: "IPv4 adresa", ipv6: "IPv6 adresa", cidrv4: "rozsah IPv4", cidrv6: "rozsah IPv6", base64: "\u0159et\u011Bzec zak\xF3dovan\xFD ve form\xE1tu base64", base64url: "\u0159et\u011Bzec zak\xF3dovan\xFD ve form\xE1tu base64url", json_string: "\u0159et\u011Bzec ve form\xE1tu JSON", e164: "\u010D\xEDslo E.164", jwt: "JWT", template_literal: "vstup" }; + return (Y) => { + var _a3, _b2, _c, _d, _e, _f, _g; + switch (Y.code) { + case "invalid_type": + return `Neplatn\xFD vstup: o\u010Dek\xE1v\xE1no ${Y.expected}, obdr\u017Eeno ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `Neplatn\xFD vstup: o\u010Dek\xE1v\xE1no ${S(Y.values[0])}`; + return `Neplatn\xE1 mo\u017Enost: o\u010Dek\xE1v\xE1na jedna z hodnot ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `Hodnota je p\u0159\xEDli\u0161 velk\xE1: ${(_a3 = Y.origin) != null ? _a3 : "hodnota"} mus\xED m\xEDt ${z6}${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "prvk\u016F"}`; + return `Hodnota je p\u0159\xEDli\u0161 velk\xE1: ${(_c = Y.origin) != null ? _c : "hodnota"} mus\xED b\xFDt ${z6}${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `Hodnota je p\u0159\xEDli\u0161 mal\xE1: ${(_d = Y.origin) != null ? _d : "hodnota"} mus\xED m\xEDt ${z6}${Y.minimum.toString()} ${(_e = W.unit) != null ? _e : "prvk\u016F"}`; + return `Hodnota je p\u0159\xEDli\u0161 mal\xE1: ${(_f = Y.origin) != null ? _f : "hodnota"} mus\xED b\xFDt ${z6}${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `Neplatn\xFD \u0159et\u011Bzec: mus\xED za\u010D\xEDnat na "${z6.prefix}"`; + if (z6.format === "ends_with") return `Neplatn\xFD \u0159et\u011Bzec: mus\xED kon\u010Dit na "${z6.suffix}"`; + if (z6.format === "includes") return `Neplatn\xFD \u0159et\u011Bzec: mus\xED obsahovat "${z6.includes}"`; + if (z6.format === "regex") return `Neplatn\xFD \u0159et\u011Bzec: mus\xED odpov\xEDdat vzoru ${z6.pattern}`; + return `Neplatn\xFD form\xE1t ${(_g = Q[z6.format]) != null ? _g : Y.format}`; + } + case "not_multiple_of": + return `Neplatn\xE9 \u010D\xEDslo: mus\xED b\xFDt n\xE1sobkem ${Y.divisor}`; + case "unrecognized_keys": + return `Nezn\xE1m\xE9 kl\xED\u010De: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `Neplatn\xFD kl\xED\u010D v ${Y.origin}`; + case "invalid_union": + return "Neplatn\xFD vstup"; + case "invalid_element": + return `Neplatn\xE1 hodnota v ${Y.origin}`; + default: + return "Neplatn\xFD vstup"; + } + }; +}; +function LW() { + return { localeError: jA() }; +} +var FA = () => { + let $ = { string: { unit: "Zeichen", verb: "zu haben" }, file: { unit: "Bytes", verb: "zu haben" }, array: { unit: "Elemente", verb: "zu haben" }, set: { unit: "Elemente", verb: "zu haben" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "Zahl"; + case "object": { + if (Array.isArray(Y)) return "Array"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "Eingabe", email: "E-Mail-Adresse", url: "URL", emoji: "Emoji", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "ISO-Datum und -Uhrzeit", date: "ISO-Datum", time: "ISO-Uhrzeit", duration: "ISO-Dauer", ipv4: "IPv4-Adresse", ipv6: "IPv6-Adresse", cidrv4: "IPv4-Bereich", cidrv6: "IPv6-Bereich", base64: "Base64-codierter String", base64url: "Base64-URL-codierter String", json_string: "JSON-String", e164: "E.164-Nummer", jwt: "JWT", template_literal: "Eingabe" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `Ung\xFCltige Eingabe: erwartet ${Y.expected}, erhalten ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `Ung\xFCltige Eingabe: erwartet ${S(Y.values[0])}`; + return `Ung\xFCltige Option: erwartet eine von ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `Zu gro\xDF: erwartet, dass ${(_a3 = Y.origin) != null ? _a3 : "Wert"} ${z6}${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "Elemente"} hat`; + return `Zu gro\xDF: erwartet, dass ${(_c = Y.origin) != null ? _c : "Wert"} ${z6}${Y.maximum.toString()} ist`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `Zu klein: erwartet, dass ${Y.origin} ${z6}${Y.minimum.toString()} ${W.unit} hat`; + return `Zu klein: erwartet, dass ${Y.origin} ${z6}${Y.minimum.toString()} ist`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `Ung\xFCltiger String: muss mit "${z6.prefix}" beginnen`; + if (z6.format === "ends_with") return `Ung\xFCltiger String: muss mit "${z6.suffix}" enden`; + if (z6.format === "includes") return `Ung\xFCltiger String: muss "${z6.includes}" enthalten`; + if (z6.format === "regex") return `Ung\xFCltiger String: muss dem Muster ${z6.pattern} entsprechen`; + return `Ung\xFCltig: ${(_d = Q[z6.format]) != null ? _d : Y.format}`; + } + case "not_multiple_of": + return `Ung\xFCltige Zahl: muss ein Vielfaches von ${Y.divisor} sein`; + case "unrecognized_keys": + return `${Y.keys.length > 1 ? "Unbekannte Schl\xFCssel" : "Unbekannter Schl\xFCssel"}: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `Ung\xFCltiger Schl\xFCssel in ${Y.origin}`; + case "invalid_union": + return "Ung\xFCltige Eingabe"; + case "invalid_element": + return `Ung\xFCltiger Wert in ${Y.origin}`; + default: + return "Ung\xFCltige Eingabe"; + } + }; +}; +function jW() { + return { localeError: FA() }; +} +var MA = ($) => { + let X = typeof $; + switch (X) { + case "number": + return Number.isNaN($) ? "NaN" : "number"; + case "object": { + if (Array.isArray($)) return "array"; + if ($ === null) return "null"; + if (Object.getPrototypeOf($) !== Object.prototype && $.constructor) return $.constructor.name; + } + } + return X; +}; +var IA = () => { + let $ = { string: { unit: "characters", verb: "to have" }, file: { unit: "bytes", verb: "to have" }, array: { unit: "items", verb: "to have" }, set: { unit: "items", verb: "to have" } }; + function X(Q) { + var _a3; + return (_a3 = $[Q]) != null ? _a3 : null; + } + let J = { regex: "input", email: "email address", url: "URL", emoji: "emoji", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "ISO datetime", date: "ISO date", time: "ISO time", duration: "ISO duration", ipv4: "IPv4 address", ipv6: "IPv6 address", cidrv4: "IPv4 range", cidrv6: "IPv6 range", base64: "base64-encoded string", base64url: "base64url-encoded string", json_string: "JSON string", e164: "E.164 number", jwt: "JWT", template_literal: "input" }; + return (Q) => { + var _a3, _b2, _c, _d; + switch (Q.code) { + case "invalid_type": + return `Invalid input: expected ${Q.expected}, received ${MA(Q.input)}`; + case "invalid_value": + if (Q.values.length === 1) return `Invalid input: expected ${S(Q.values[0])}`; + return `Invalid option: expected one of ${M(Q.values, "|")}`; + case "too_big": { + let Y = Q.inclusive ? "<=" : "<", z6 = X(Q.origin); + if (z6) return `Too big: expected ${(_a3 = Q.origin) != null ? _a3 : "value"} to have ${Y}${Q.maximum.toString()} ${(_b2 = z6.unit) != null ? _b2 : "elements"}`; + return `Too big: expected ${(_c = Q.origin) != null ? _c : "value"} to be ${Y}${Q.maximum.toString()}`; + } + case "too_small": { + let Y = Q.inclusive ? ">=" : ">", z6 = X(Q.origin); + if (z6) return `Too small: expected ${Q.origin} to have ${Y}${Q.minimum.toString()} ${z6.unit}`; + return `Too small: expected ${Q.origin} to be ${Y}${Q.minimum.toString()}`; + } + case "invalid_format": { + let Y = Q; + if (Y.format === "starts_with") return `Invalid string: must start with "${Y.prefix}"`; + if (Y.format === "ends_with") return `Invalid string: must end with "${Y.suffix}"`; + if (Y.format === "includes") return `Invalid string: must include "${Y.includes}"`; + if (Y.format === "regex") return `Invalid string: must match pattern ${Y.pattern}`; + return `Invalid ${(_d = J[Y.format]) != null ? _d : Q.format}`; + } + case "not_multiple_of": + return `Invalid number: must be a multiple of ${Q.divisor}`; + case "unrecognized_keys": + return `Unrecognized key${Q.keys.length > 1 ? "s" : ""}: ${M(Q.keys, ", ")}`; + case "invalid_key": + return `Invalid key in ${Q.origin}`; + case "invalid_union": + return "Invalid input"; + case "invalid_element": + return `Invalid value in ${Q.origin}`; + default: + return "Invalid input"; + } + }; +}; +function M8() { + return { localeError: IA() }; +} +var AA = ($) => { + let X = typeof $; + switch (X) { + case "number": + return Number.isNaN($) ? "NaN" : "nombro"; + case "object": { + if (Array.isArray($)) return "tabelo"; + if ($ === null) return "senvalora"; + if (Object.getPrototypeOf($) !== Object.prototype && $.constructor) return $.constructor.name; + } + } + return X; +}; +var bA = () => { + let $ = { string: { unit: "karaktrojn", verb: "havi" }, file: { unit: "bajtojn", verb: "havi" }, array: { unit: "elementojn", verb: "havi" }, set: { unit: "elementojn", verb: "havi" } }; + function X(Q) { + var _a3; + return (_a3 = $[Q]) != null ? _a3 : null; + } + let J = { regex: "enigo", email: "retadreso", url: "URL", emoji: "emo\u011Dio", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "ISO-datotempo", date: "ISO-dato", time: "ISO-tempo", duration: "ISO-da\u016Dro", ipv4: "IPv4-adreso", ipv6: "IPv6-adreso", cidrv4: "IPv4-rango", cidrv6: "IPv6-rango", base64: "64-ume kodita karaktraro", base64url: "URL-64-ume kodita karaktraro", json_string: "JSON-karaktraro", e164: "E.164-nombro", jwt: "JWT", template_literal: "enigo" }; + return (Q) => { + var _a3, _b2, _c, _d; + switch (Q.code) { + case "invalid_type": + return `Nevalida enigo: atendi\u011Dis ${Q.expected}, ricevi\u011Dis ${AA(Q.input)}`; + case "invalid_value": + if (Q.values.length === 1) return `Nevalida enigo: atendi\u011Dis ${S(Q.values[0])}`; + return `Nevalida opcio: atendi\u011Dis unu el ${M(Q.values, "|")}`; + case "too_big": { + let Y = Q.inclusive ? "<=" : "<", z6 = X(Q.origin); + if (z6) return `Tro granda: atendi\u011Dis ke ${(_a3 = Q.origin) != null ? _a3 : "valoro"} havu ${Y}${Q.maximum.toString()} ${(_b2 = z6.unit) != null ? _b2 : "elementojn"}`; + return `Tro granda: atendi\u011Dis ke ${(_c = Q.origin) != null ? _c : "valoro"} havu ${Y}${Q.maximum.toString()}`; + } + case "too_small": { + let Y = Q.inclusive ? ">=" : ">", z6 = X(Q.origin); + if (z6) return `Tro malgranda: atendi\u011Dis ke ${Q.origin} havu ${Y}${Q.minimum.toString()} ${z6.unit}`; + return `Tro malgranda: atendi\u011Dis ke ${Q.origin} estu ${Y}${Q.minimum.toString()}`; + } + case "invalid_format": { + let Y = Q; + if (Y.format === "starts_with") return `Nevalida karaktraro: devas komenci\u011Di per "${Y.prefix}"`; + if (Y.format === "ends_with") return `Nevalida karaktraro: devas fini\u011Di per "${Y.suffix}"`; + if (Y.format === "includes") return `Nevalida karaktraro: devas inkluzivi "${Y.includes}"`; + if (Y.format === "regex") return `Nevalida karaktraro: devas kongrui kun la modelo ${Y.pattern}`; + return `Nevalida ${(_d = J[Y.format]) != null ? _d : Q.format}`; + } + case "not_multiple_of": + return `Nevalida nombro: devas esti oblo de ${Q.divisor}`; + case "unrecognized_keys": + return `Nekonata${Q.keys.length > 1 ? "j" : ""} \u015Dlosilo${Q.keys.length > 1 ? "j" : ""}: ${M(Q.keys, ", ")}`; + case "invalid_key": + return `Nevalida \u015Dlosilo en ${Q.origin}`; + case "invalid_union": + return "Nevalida enigo"; + case "invalid_element": + return `Nevalida valoro en ${Q.origin}`; + default: + return "Nevalida enigo"; + } + }; +}; +function FW() { + return { localeError: bA() }; +} +var PA = () => { + let $ = { string: { unit: "caracteres", verb: "tener" }, file: { unit: "bytes", verb: "tener" }, array: { unit: "elementos", verb: "tener" }, set: { unit: "elementos", verb: "tener" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "n\xFAmero"; + case "object": { + if (Array.isArray(Y)) return "arreglo"; + if (Y === null) return "nulo"; + if (Object.getPrototypeOf(Y) !== Object.prototype) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "entrada", email: "direcci\xF3n de correo electr\xF3nico", url: "URL", emoji: "emoji", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "fecha y hora ISO", date: "fecha ISO", time: "hora ISO", duration: "duraci\xF3n ISO", ipv4: "direcci\xF3n IPv4", ipv6: "direcci\xF3n IPv6", cidrv4: "rango IPv4", cidrv6: "rango IPv6", base64: "cadena codificada en base64", base64url: "URL codificada en base64", json_string: "cadena JSON", e164: "n\xFAmero E.164", jwt: "JWT", template_literal: "entrada" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `Entrada inv\xE1lida: se esperaba ${Y.expected}, recibido ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `Entrada inv\xE1lida: se esperaba ${S(Y.values[0])}`; + return `Opci\xF3n inv\xE1lida: se esperaba una de ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `Demasiado grande: se esperaba que ${(_a3 = Y.origin) != null ? _a3 : "valor"} tuviera ${z6}${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "elementos"}`; + return `Demasiado grande: se esperaba que ${(_c = Y.origin) != null ? _c : "valor"} fuera ${z6}${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `Demasiado peque\xF1o: se esperaba que ${Y.origin} tuviera ${z6}${Y.minimum.toString()} ${W.unit}`; + return `Demasiado peque\xF1o: se esperaba que ${Y.origin} fuera ${z6}${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `Cadena inv\xE1lida: debe comenzar con "${z6.prefix}"`; + if (z6.format === "ends_with") return `Cadena inv\xE1lida: debe terminar en "${z6.suffix}"`; + if (z6.format === "includes") return `Cadena inv\xE1lida: debe incluir "${z6.includes}"`; + if (z6.format === "regex") return `Cadena inv\xE1lida: debe coincidir con el patr\xF3n ${z6.pattern}`; + return `Inv\xE1lido ${(_d = Q[z6.format]) != null ? _d : Y.format}`; + } + case "not_multiple_of": + return `N\xFAmero inv\xE1lido: debe ser m\xFAltiplo de ${Y.divisor}`; + case "unrecognized_keys": + return `Llave${Y.keys.length > 1 ? "s" : ""} desconocida${Y.keys.length > 1 ? "s" : ""}: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `Llave inv\xE1lida en ${Y.origin}`; + case "invalid_union": + return "Entrada inv\xE1lida"; + case "invalid_element": + return `Valor inv\xE1lido en ${Y.origin}`; + default: + return "Entrada inv\xE1lida"; + } + }; +}; +function MW() { + return { localeError: PA() }; +} +var ZA = () => { + let $ = { string: { unit: "\u06A9\u0627\u0631\u0627\u06A9\u062A\u0631", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" }, file: { unit: "\u0628\u0627\u06CC\u062A", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" }, array: { unit: "\u0622\u06CC\u062A\u0645", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" }, set: { unit: "\u0622\u06CC\u062A\u0645", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "\u0639\u062F\u062F"; + case "object": { + if (Array.isArray(Y)) return "\u0622\u0631\u0627\u06CC\u0647"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "\u0648\u0631\u0648\u062F\u06CC", email: "\u0622\u062F\u0631\u0633 \u0627\u06CC\u0645\u06CC\u0644", url: "URL", emoji: "\u0627\u06CC\u0645\u0648\u062C\u06CC", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "\u062A\u0627\u0631\u06CC\u062E \u0648 \u0632\u0645\u0627\u0646 \u0627\u06CC\u0632\u0648", date: "\u062A\u0627\u0631\u06CC\u062E \u0627\u06CC\u0632\u0648", time: "\u0632\u0645\u0627\u0646 \u0627\u06CC\u0632\u0648", duration: "\u0645\u062F\u062A \u0632\u0645\u0627\u0646 \u0627\u06CC\u0632\u0648", ipv4: "IPv4 \u0622\u062F\u0631\u0633", ipv6: "IPv6 \u0622\u062F\u0631\u0633", cidrv4: "IPv4 \u062F\u0627\u0645\u0646\u0647", cidrv6: "IPv6 \u062F\u0627\u0645\u0646\u0647", base64: "base64-encoded \u0631\u0634\u062A\u0647", base64url: "base64url-encoded \u0631\u0634\u062A\u0647", json_string: "JSON \u0631\u0634\u062A\u0647", e164: "E.164 \u0639\u062F\u062F", jwt: "JWT", template_literal: "\u0648\u0631\u0648\u062F\u06CC" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A ${Y.expected} \u0645\u06CC\u200C\u0628\u0648\u062F\u060C ${J(Y.input)} \u062F\u0631\u06CC\u0627\u0641\u062A \u0634\u062F`; + case "invalid_value": + if (Y.values.length === 1) return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A ${S(Y.values[0])} \u0645\u06CC\u200C\u0628\u0648\u062F`; + return `\u06AF\u0632\u06CC\u0646\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A \u06CC\u06A9\u06CC \u0627\u0632 ${M(Y.values, "|")} \u0645\u06CC\u200C\u0628\u0648\u062F`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `\u062E\u06CC\u0644\u06CC \u0628\u0632\u0631\u06AF: ${(_a3 = Y.origin) != null ? _a3 : "\u0645\u0642\u062F\u0627\u0631"} \u0628\u0627\u06CC\u062F ${z6}${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "\u0639\u0646\u0635\u0631"} \u0628\u0627\u0634\u062F`; + return `\u062E\u06CC\u0644\u06CC \u0628\u0632\u0631\u06AF: ${(_c = Y.origin) != null ? _c : "\u0645\u0642\u062F\u0627\u0631"} \u0628\u0627\u06CC\u062F ${z6}${Y.maximum.toString()} \u0628\u0627\u0634\u062F`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `\u062E\u06CC\u0644\u06CC \u06A9\u0648\u0686\u06A9: ${Y.origin} \u0628\u0627\u06CC\u062F ${z6}${Y.minimum.toString()} ${W.unit} \u0628\u0627\u0634\u062F`; + return `\u062E\u06CC\u0644\u06CC \u06A9\u0648\u0686\u06A9: ${Y.origin} \u0628\u0627\u06CC\u062F ${z6}${Y.minimum.toString()} \u0628\u0627\u0634\u062F`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0628\u0627 "${z6.prefix}" \u0634\u0631\u0648\u0639 \u0634\u0648\u062F`; + if (z6.format === "ends_with") return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0628\u0627 "${z6.suffix}" \u062A\u0645\u0627\u0645 \u0634\u0648\u062F`; + if (z6.format === "includes") return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0634\u0627\u0645\u0644 "${z6.includes}" \u0628\u0627\u0634\u062F`; + if (z6.format === "regex") return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0628\u0627 \u0627\u0644\u06AF\u0648\u06CC ${z6.pattern} \u0645\u0637\u0627\u0628\u0642\u062A \u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F`; + return `${(_d = Q[z6.format]) != null ? _d : Y.format} \u0646\u0627\u0645\u0639\u062A\u0628\u0631`; + } + case "not_multiple_of": + return `\u0639\u062F\u062F \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0645\u0636\u0631\u0628 ${Y.divisor} \u0628\u0627\u0634\u062F`; + case "unrecognized_keys": + return `\u06A9\u0644\u06CC\u062F${Y.keys.length > 1 ? "\u0647\u0627\u06CC" : ""} \u0646\u0627\u0634\u0646\u0627\u0633: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `\u06A9\u0644\u06CC\u062F \u0646\u0627\u0634\u0646\u0627\u0633 \u062F\u0631 ${Y.origin}`; + case "invalid_union": + return "\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631"; + case "invalid_element": + return `\u0645\u0642\u062F\u0627\u0631 \u0646\u0627\u0645\u0639\u062A\u0628\u0631 \u062F\u0631 ${Y.origin}`; + default: + return "\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631"; + } + }; +}; +function IW() { + return { localeError: ZA() }; +} +var EA = () => { + let $ = { string: { unit: "merkki\xE4", subject: "merkkijonon" }, file: { unit: "tavua", subject: "tiedoston" }, array: { unit: "alkiota", subject: "listan" }, set: { unit: "alkiota", subject: "joukon" }, number: { unit: "", subject: "luvun" }, bigint: { unit: "", subject: "suuren kokonaisluvun" }, int: { unit: "", subject: "kokonaisluvun" }, date: { unit: "", subject: "p\xE4iv\xE4m\xE4\xE4r\xE4n" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "number"; + case "object": { + if (Array.isArray(Y)) return "array"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "s\xE4\xE4nn\xF6llinen lauseke", email: "s\xE4hk\xF6postiosoite", url: "URL-osoite", emoji: "emoji", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "ISO-aikaleima", date: "ISO-p\xE4iv\xE4m\xE4\xE4r\xE4", time: "ISO-aika", duration: "ISO-kesto", ipv4: "IPv4-osoite", ipv6: "IPv6-osoite", cidrv4: "IPv4-alue", cidrv6: "IPv6-alue", base64: "base64-koodattu merkkijono", base64url: "base64url-koodattu merkkijono", json_string: "JSON-merkkijono", e164: "E.164-luku", jwt: "JWT", template_literal: "templaattimerkkijono" }; + return (Y) => { + var _a3; + switch (Y.code) { + case "invalid_type": + return `Virheellinen tyyppi: odotettiin ${Y.expected}, oli ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `Virheellinen sy\xF6te: t\xE4ytyy olla ${S(Y.values[0])}`; + return `Virheellinen valinta: t\xE4ytyy olla yksi seuraavista: ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `Liian suuri: ${W.subject} t\xE4ytyy olla ${z6}${Y.maximum.toString()} ${W.unit}`.trim(); + return `Liian suuri: arvon t\xE4ytyy olla ${z6}${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `Liian pieni: ${W.subject} t\xE4ytyy olla ${z6}${Y.minimum.toString()} ${W.unit}`.trim(); + return `Liian pieni: arvon t\xE4ytyy olla ${z6}${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `Virheellinen sy\xF6te: t\xE4ytyy alkaa "${z6.prefix}"`; + if (z6.format === "ends_with") return `Virheellinen sy\xF6te: t\xE4ytyy loppua "${z6.suffix}"`; + if (z6.format === "includes") return `Virheellinen sy\xF6te: t\xE4ytyy sis\xE4lt\xE4\xE4 "${z6.includes}"`; + if (z6.format === "regex") return `Virheellinen sy\xF6te: t\xE4ytyy vastata s\xE4\xE4nn\xF6llist\xE4 lauseketta ${z6.pattern}`; + return `Virheellinen ${(_a3 = Q[z6.format]) != null ? _a3 : Y.format}`; + } + case "not_multiple_of": + return `Virheellinen luku: t\xE4ytyy olla luvun ${Y.divisor} monikerta`; + case "unrecognized_keys": + return `${Y.keys.length > 1 ? "Tuntemattomat avaimet" : "Tuntematon avain"}: ${M(Y.keys, ", ")}`; + case "invalid_key": + return "Virheellinen avain tietueessa"; + case "invalid_union": + return "Virheellinen unioni"; + case "invalid_element": + return "Virheellinen arvo joukossa"; + default: + return "Virheellinen sy\xF6te"; + } + }; +}; +function AW() { + return { localeError: EA() }; +} +var RA = () => { + let $ = { string: { unit: "caract\xE8res", verb: "avoir" }, file: { unit: "octets", verb: "avoir" }, array: { unit: "\xE9l\xE9ments", verb: "avoir" }, set: { unit: "\xE9l\xE9ments", verb: "avoir" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "nombre"; + case "object": { + if (Array.isArray(Y)) return "tableau"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "entr\xE9e", email: "adresse e-mail", url: "URL", emoji: "emoji", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "date et heure ISO", date: "date ISO", time: "heure ISO", duration: "dur\xE9e ISO", ipv4: "adresse IPv4", ipv6: "adresse IPv6", cidrv4: "plage IPv4", cidrv6: "plage IPv6", base64: "cha\xEEne encod\xE9e en base64", base64url: "cha\xEEne encod\xE9e en base64url", json_string: "cha\xEEne JSON", e164: "num\xE9ro E.164", jwt: "JWT", template_literal: "entr\xE9e" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `Entr\xE9e invalide : ${Y.expected} attendu, ${J(Y.input)} re\xE7u`; + case "invalid_value": + if (Y.values.length === 1) return `Entr\xE9e invalide : ${S(Y.values[0])} attendu`; + return `Option invalide : une valeur parmi ${M(Y.values, "|")} attendue`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `Trop grand : ${(_a3 = Y.origin) != null ? _a3 : "valeur"} doit ${W.verb} ${z6}${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "\xE9l\xE9ment(s)"}`; + return `Trop grand : ${(_c = Y.origin) != null ? _c : "valeur"} doit \xEAtre ${z6}${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `Trop petit : ${Y.origin} doit ${W.verb} ${z6}${Y.minimum.toString()} ${W.unit}`; + return `Trop petit : ${Y.origin} doit \xEAtre ${z6}${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `Cha\xEEne invalide : doit commencer par "${z6.prefix}"`; + if (z6.format === "ends_with") return `Cha\xEEne invalide : doit se terminer par "${z6.suffix}"`; + if (z6.format === "includes") return `Cha\xEEne invalide : doit inclure "${z6.includes}"`; + if (z6.format === "regex") return `Cha\xEEne invalide : doit correspondre au mod\xE8le ${z6.pattern}`; + return `${(_d = Q[z6.format]) != null ? _d : Y.format} invalide`; + } + case "not_multiple_of": + return `Nombre invalide : doit \xEAtre un multiple de ${Y.divisor}`; + case "unrecognized_keys": + return `Cl\xE9${Y.keys.length > 1 ? "s" : ""} non reconnue${Y.keys.length > 1 ? "s" : ""} : ${M(Y.keys, ", ")}`; + case "invalid_key": + return `Cl\xE9 invalide dans ${Y.origin}`; + case "invalid_union": + return "Entr\xE9e invalide"; + case "invalid_element": + return `Valeur invalide dans ${Y.origin}`; + default: + return "Entr\xE9e invalide"; + } + }; +}; +function bW() { + return { localeError: RA() }; +} +var SA = () => { + let $ = { string: { unit: "caract\xE8res", verb: "avoir" }, file: { unit: "octets", verb: "avoir" }, array: { unit: "\xE9l\xE9ments", verb: "avoir" }, set: { unit: "\xE9l\xE9ments", verb: "avoir" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "number"; + case "object": { + if (Array.isArray(Y)) return "array"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "entr\xE9e", email: "adresse courriel", url: "URL", emoji: "emoji", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "date-heure ISO", date: "date ISO", time: "heure ISO", duration: "dur\xE9e ISO", ipv4: "adresse IPv4", ipv6: "adresse IPv6", cidrv4: "plage IPv4", cidrv6: "plage IPv6", base64: "cha\xEEne encod\xE9e en base64", base64url: "cha\xEEne encod\xE9e en base64url", json_string: "cha\xEEne JSON", e164: "num\xE9ro E.164", jwt: "JWT", template_literal: "entr\xE9e" }; + return (Y) => { + var _a3, _b2, _c; + switch (Y.code) { + case "invalid_type": + return `Entr\xE9e invalide : attendu ${Y.expected}, re\xE7u ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `Entr\xE9e invalide : attendu ${S(Y.values[0])}`; + return `Option invalide : attendu l'une des valeurs suivantes ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "\u2264" : "<", W = X(Y.origin); + if (W) return `Trop grand : attendu que ${(_a3 = Y.origin) != null ? _a3 : "la valeur"} ait ${z6}${Y.maximum.toString()} ${W.unit}`; + return `Trop grand : attendu que ${(_b2 = Y.origin) != null ? _b2 : "la valeur"} soit ${z6}${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? "\u2265" : ">", W = X(Y.origin); + if (W) return `Trop petit : attendu que ${Y.origin} ait ${z6}${Y.minimum.toString()} ${W.unit}`; + return `Trop petit : attendu que ${Y.origin} soit ${z6}${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `Cha\xEEne invalide : doit commencer par "${z6.prefix}"`; + if (z6.format === "ends_with") return `Cha\xEEne invalide : doit se terminer par "${z6.suffix}"`; + if (z6.format === "includes") return `Cha\xEEne invalide : doit inclure "${z6.includes}"`; + if (z6.format === "regex") return `Cha\xEEne invalide : doit correspondre au motif ${z6.pattern}`; + return `${(_c = Q[z6.format]) != null ? _c : Y.format} invalide`; + } + case "not_multiple_of": + return `Nombre invalide : doit \xEAtre un multiple de ${Y.divisor}`; + case "unrecognized_keys": + return `Cl\xE9${Y.keys.length > 1 ? "s" : ""} non reconnue${Y.keys.length > 1 ? "s" : ""} : ${M(Y.keys, ", ")}`; + case "invalid_key": + return `Cl\xE9 invalide dans ${Y.origin}`; + case "invalid_union": + return "Entr\xE9e invalide"; + case "invalid_element": + return `Valeur invalide dans ${Y.origin}`; + default: + return "Entr\xE9e invalide"; + } + }; +}; +function PW() { + return { localeError: SA() }; +} +var vA = () => { + let $ = { string: { unit: "\u05D0\u05D5\u05EA\u05D9\u05D5\u05EA", verb: "\u05DC\u05DB\u05DC\u05D5\u05DC" }, file: { unit: "\u05D1\u05D9\u05D9\u05D8\u05D9\u05DD", verb: "\u05DC\u05DB\u05DC\u05D5\u05DC" }, array: { unit: "\u05E4\u05E8\u05D9\u05D8\u05D9\u05DD", verb: "\u05DC\u05DB\u05DC\u05D5\u05DC" }, set: { unit: "\u05E4\u05E8\u05D9\u05D8\u05D9\u05DD", verb: "\u05DC\u05DB\u05DC\u05D5\u05DC" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "number"; + case "object": { + if (Array.isArray(Y)) return "array"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "\u05E7\u05DC\u05D8", email: "\u05DB\u05EA\u05D5\u05D1\u05EA \u05D0\u05D9\u05DE\u05D9\u05D9\u05DC", url: "\u05DB\u05EA\u05D5\u05D1\u05EA \u05E8\u05E9\u05EA", emoji: "\u05D0\u05D9\u05DE\u05D5\u05D2'\u05D9", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "\u05EA\u05D0\u05E8\u05D9\u05DA \u05D5\u05D6\u05DE\u05DF ISO", date: "\u05EA\u05D0\u05E8\u05D9\u05DA ISO", time: "\u05D6\u05DE\u05DF ISO", duration: "\u05DE\u05E9\u05DA \u05D6\u05DE\u05DF ISO", ipv4: "\u05DB\u05EA\u05D5\u05D1\u05EA IPv4", ipv6: "\u05DB\u05EA\u05D5\u05D1\u05EA IPv6", cidrv4: "\u05D8\u05D5\u05D5\u05D7 IPv4", cidrv6: "\u05D8\u05D5\u05D5\u05D7 IPv6", base64: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D1\u05D1\u05E1\u05D9\u05E1 64", base64url: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D1\u05D1\u05E1\u05D9\u05E1 64 \u05DC\u05DB\u05EA\u05D5\u05D1\u05D5\u05EA \u05E8\u05E9\u05EA", json_string: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA JSON", e164: "\u05DE\u05E1\u05E4\u05E8 E.164", jwt: "JWT", template_literal: "\u05E7\u05DC\u05D8" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05E6\u05E8\u05D9\u05DA ${Y.expected}, \u05D4\u05EA\u05E7\u05D1\u05DC ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05E6\u05E8\u05D9\u05DA ${S(Y.values[0])}`; + return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05E6\u05E8\u05D9\u05DA \u05D0\u05D7\u05EA \u05DE\u05D4\u05D0\u05E4\u05E9\u05E8\u05D5\u05D9\u05D5\u05EA ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `\u05D2\u05D3\u05D5\u05DC \u05DE\u05D3\u05D9: ${(_a3 = Y.origin) != null ? _a3 : "value"} \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${z6}${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "elements"}`; + return `\u05D2\u05D3\u05D5\u05DC \u05DE\u05D3\u05D9: ${(_c = Y.origin) != null ? _c : "value"} \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${z6}${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `\u05E7\u05D8\u05DF \u05DE\u05D3\u05D9: ${Y.origin} \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${z6}${Y.minimum.toString()} ${W.unit}`; + return `\u05E7\u05D8\u05DF \u05DE\u05D3\u05D9: ${Y.origin} \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${z6}${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05E0\u05D4: \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05D4\u05EA\u05D7\u05D9\u05DC \u05D1"${z6.prefix}"`; + if (z6.format === "ends_with") return `\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05E0\u05D4: \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05D4\u05E1\u05EA\u05D9\u05D9\u05DD \u05D1 "${z6.suffix}"`; + if (z6.format === "includes") return `\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05E0\u05D4: \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05DB\u05DC\u05D5\u05DC "${z6.includes}"`; + if (z6.format === "regex") return `\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05E0\u05D4: \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05D4\u05EA\u05D0\u05D9\u05DD \u05DC\u05EA\u05D1\u05E0\u05D9\u05EA ${z6.pattern}`; + return `${(_d = Q[z6.format]) != null ? _d : Y.format} \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF`; + } + case "not_multiple_of": + return `\u05DE\u05E1\u05E4\u05E8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D7\u05D9\u05D9\u05D1 \u05DC\u05D4\u05D9\u05D5\u05EA \u05DE\u05DB\u05E4\u05DC\u05D4 \u05E9\u05DC ${Y.divisor}`; + case "unrecognized_keys": + return `\u05DE\u05E4\u05EA\u05D7${Y.keys.length > 1 ? "\u05D5\u05EA" : ""} \u05DC\u05D0 \u05DE\u05D6\u05D5\u05D4${Y.keys.length > 1 ? "\u05D9\u05DD" : "\u05D4"}: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `\u05DE\u05E4\u05EA\u05D7 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF \u05D1${Y.origin}`; + case "invalid_union": + return "\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF"; + case "invalid_element": + return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF \u05D1${Y.origin}`; + default: + return "\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF"; + } + }; +}; +function ZW() { + return { localeError: vA() }; +} +var CA = () => { + let $ = { string: { unit: "karakter", verb: "legyen" }, file: { unit: "byte", verb: "legyen" }, array: { unit: "elem", verb: "legyen" }, set: { unit: "elem", verb: "legyen" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "sz\xE1m"; + case "object": { + if (Array.isArray(Y)) return "t\xF6mb"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "bemenet", email: "email c\xEDm", url: "URL", emoji: "emoji", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "ISO id\u0151b\xE9lyeg", date: "ISO d\xE1tum", time: "ISO id\u0151", duration: "ISO id\u0151intervallum", ipv4: "IPv4 c\xEDm", ipv6: "IPv6 c\xEDm", cidrv4: "IPv4 tartom\xE1ny", cidrv6: "IPv6 tartom\xE1ny", base64: "base64-k\xF3dolt string", base64url: "base64url-k\xF3dolt string", json_string: "JSON string", e164: "E.164 sz\xE1m", jwt: "JWT", template_literal: "bemenet" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${Y.expected}, a kapott \xE9rt\xE9k ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${S(Y.values[0])}`; + return `\xC9rv\xE9nytelen opci\xF3: valamelyik \xE9rt\xE9k v\xE1rt ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `T\xFAl nagy: ${(_a3 = Y.origin) != null ? _a3 : "\xE9rt\xE9k"} m\xE9rete t\xFAl nagy ${z6}${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "elem"}`; + return `T\xFAl nagy: a bemeneti \xE9rt\xE9k ${(_c = Y.origin) != null ? _c : "\xE9rt\xE9k"} t\xFAl nagy: ${z6}${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `T\xFAl kicsi: a bemeneti \xE9rt\xE9k ${Y.origin} m\xE9rete t\xFAl kicsi ${z6}${Y.minimum.toString()} ${W.unit}`; + return `T\xFAl kicsi: a bemeneti \xE9rt\xE9k ${Y.origin} t\xFAl kicsi ${z6}${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `\xC9rv\xE9nytelen string: "${z6.prefix}" \xE9rt\xE9kkel kell kezd\u0151dnie`; + if (z6.format === "ends_with") return `\xC9rv\xE9nytelen string: "${z6.suffix}" \xE9rt\xE9kkel kell v\xE9gz\u0151dnie`; + if (z6.format === "includes") return `\xC9rv\xE9nytelen string: "${z6.includes}" \xE9rt\xE9ket kell tartalmaznia`; + if (z6.format === "regex") return `\xC9rv\xE9nytelen string: ${z6.pattern} mint\xE1nak kell megfelelnie`; + return `\xC9rv\xE9nytelen ${(_d = Q[z6.format]) != null ? _d : Y.format}`; + } + case "not_multiple_of": + return `\xC9rv\xE9nytelen sz\xE1m: ${Y.divisor} t\xF6bbsz\xF6r\xF6s\xE9nek kell lennie`; + case "unrecognized_keys": + return `Ismeretlen kulcs${Y.keys.length > 1 ? "s" : ""}: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `\xC9rv\xE9nytelen kulcs ${Y.origin}`; + case "invalid_union": + return "\xC9rv\xE9nytelen bemenet"; + case "invalid_element": + return `\xC9rv\xE9nytelen \xE9rt\xE9k: ${Y.origin}`; + default: + return "\xC9rv\xE9nytelen bemenet"; + } + }; +}; +function EW() { + return { localeError: CA() }; +} +var kA = () => { + let $ = { string: { unit: "karakter", verb: "memiliki" }, file: { unit: "byte", verb: "memiliki" }, array: { unit: "item", verb: "memiliki" }, set: { unit: "item", verb: "memiliki" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "number"; + case "object": { + if (Array.isArray(Y)) return "array"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "input", email: "alamat email", url: "URL", emoji: "emoji", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "tanggal dan waktu format ISO", date: "tanggal format ISO", time: "jam format ISO", duration: "durasi format ISO", ipv4: "alamat IPv4", ipv6: "alamat IPv6", cidrv4: "rentang alamat IPv4", cidrv6: "rentang alamat IPv6", base64: "string dengan enkode base64", base64url: "string dengan enkode base64url", json_string: "string JSON", e164: "angka E.164", jwt: "JWT", template_literal: "input" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `Input tidak valid: diharapkan ${Y.expected}, diterima ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `Input tidak valid: diharapkan ${S(Y.values[0])}`; + return `Pilihan tidak valid: diharapkan salah satu dari ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `Terlalu besar: diharapkan ${(_a3 = Y.origin) != null ? _a3 : "value"} memiliki ${z6}${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "elemen"}`; + return `Terlalu besar: diharapkan ${(_c = Y.origin) != null ? _c : "value"} menjadi ${z6}${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `Terlalu kecil: diharapkan ${Y.origin} memiliki ${z6}${Y.minimum.toString()} ${W.unit}`; + return `Terlalu kecil: diharapkan ${Y.origin} menjadi ${z6}${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `String tidak valid: harus dimulai dengan "${z6.prefix}"`; + if (z6.format === "ends_with") return `String tidak valid: harus berakhir dengan "${z6.suffix}"`; + if (z6.format === "includes") return `String tidak valid: harus menyertakan "${z6.includes}"`; + if (z6.format === "regex") return `String tidak valid: harus sesuai pola ${z6.pattern}`; + return `${(_d = Q[z6.format]) != null ? _d : Y.format} tidak valid`; + } + case "not_multiple_of": + return `Angka tidak valid: harus kelipatan dari ${Y.divisor}`; + case "unrecognized_keys": + return `Kunci tidak dikenali ${Y.keys.length > 1 ? "s" : ""}: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `Kunci tidak valid di ${Y.origin}`; + case "invalid_union": + return "Input tidak valid"; + case "invalid_element": + return `Nilai tidak valid di ${Y.origin}`; + default: + return "Input tidak valid"; + } + }; +}; +function RW() { + return { localeError: kA() }; +} +var _A = () => { + let $ = { string: { unit: "caratteri", verb: "avere" }, file: { unit: "byte", verb: "avere" }, array: { unit: "elementi", verb: "avere" }, set: { unit: "elementi", verb: "avere" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "numero"; + case "object": { + if (Array.isArray(Y)) return "vettore"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "input", email: "indirizzo email", url: "URL", emoji: "emoji", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "data e ora ISO", date: "data ISO", time: "ora ISO", duration: "durata ISO", ipv4: "indirizzo IPv4", ipv6: "indirizzo IPv6", cidrv4: "intervallo IPv4", cidrv6: "intervallo IPv6", base64: "stringa codificata in base64", base64url: "URL codificata in base64", json_string: "stringa JSON", e164: "numero E.164", jwt: "JWT", template_literal: "input" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `Input non valido: atteso ${Y.expected}, ricevuto ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `Input non valido: atteso ${S(Y.values[0])}`; + return `Opzione non valida: atteso uno tra ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `Troppo grande: ${(_a3 = Y.origin) != null ? _a3 : "valore"} deve avere ${z6}${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "elementi"}`; + return `Troppo grande: ${(_c = Y.origin) != null ? _c : "valore"} deve essere ${z6}${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `Troppo piccolo: ${Y.origin} deve avere ${z6}${Y.minimum.toString()} ${W.unit}`; + return `Troppo piccolo: ${Y.origin} deve essere ${z6}${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `Stringa non valida: deve iniziare con "${z6.prefix}"`; + if (z6.format === "ends_with") return `Stringa non valida: deve terminare con "${z6.suffix}"`; + if (z6.format === "includes") return `Stringa non valida: deve includere "${z6.includes}"`; + if (z6.format === "regex") return `Stringa non valida: deve corrispondere al pattern ${z6.pattern}`; + return `Invalid ${(_d = Q[z6.format]) != null ? _d : Y.format}`; + } + case "not_multiple_of": + return `Numero non valido: deve essere un multiplo di ${Y.divisor}`; + case "unrecognized_keys": + return `Chiav${Y.keys.length > 1 ? "i" : "e"} non riconosciut${Y.keys.length > 1 ? "e" : "a"}: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `Chiave non valida in ${Y.origin}`; + case "invalid_union": + return "Input non valido"; + case "invalid_element": + return `Valore non valido in ${Y.origin}`; + default: + return "Input non valido"; + } + }; +}; +function SW() { + return { localeError: _A() }; +} +var xA = () => { + let $ = { string: { unit: "\u6587\u5B57", verb: "\u3067\u3042\u308B" }, file: { unit: "\u30D0\u30A4\u30C8", verb: "\u3067\u3042\u308B" }, array: { unit: "\u8981\u7D20", verb: "\u3067\u3042\u308B" }, set: { unit: "\u8981\u7D20", verb: "\u3067\u3042\u308B" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "\u6570\u5024"; + case "object": { + if (Array.isArray(Y)) return "\u914D\u5217"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "\u5165\u529B\u5024", email: "\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9", url: "URL", emoji: "\u7D75\u6587\u5B57", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "ISO\u65E5\u6642", date: "ISO\u65E5\u4ED8", time: "ISO\u6642\u523B", duration: "ISO\u671F\u9593", ipv4: "IPv4\u30A2\u30C9\u30EC\u30B9", ipv6: "IPv6\u30A2\u30C9\u30EC\u30B9", cidrv4: "IPv4\u7BC4\u56F2", cidrv6: "IPv6\u7BC4\u56F2", base64: "base64\u30A8\u30F3\u30B3\u30FC\u30C9\u6587\u5B57\u5217", base64url: "base64url\u30A8\u30F3\u30B3\u30FC\u30C9\u6587\u5B57\u5217", json_string: "JSON\u6587\u5B57\u5217", e164: "E.164\u756A\u53F7", jwt: "JWT", template_literal: "\u5165\u529B\u5024" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `\u7121\u52B9\u306A\u5165\u529B: ${Y.expected}\u304C\u671F\u5F85\u3055\u308C\u307E\u3057\u305F\u304C\u3001${J(Y.input)}\u304C\u5165\u529B\u3055\u308C\u307E\u3057\u305F`; + case "invalid_value": + if (Y.values.length === 1) return `\u7121\u52B9\u306A\u5165\u529B: ${S(Y.values[0])}\u304C\u671F\u5F85\u3055\u308C\u307E\u3057\u305F`; + return `\u7121\u52B9\u306A\u9078\u629E: ${M(Y.values, "\u3001")}\u306E\u3044\u305A\u308C\u304B\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`; + case "too_big": { + let z6 = Y.inclusive ? "\u4EE5\u4E0B\u3067\u3042\u308B" : "\u3088\u308A\u5C0F\u3055\u3044", W = X(Y.origin); + if (W) return `\u5927\u304D\u3059\u304E\u308B\u5024: ${(_a3 = Y.origin) != null ? _a3 : "\u5024"}\u306F${Y.maximum.toString()}${(_b2 = W.unit) != null ? _b2 : "\u8981\u7D20"}${z6}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`; + return `\u5927\u304D\u3059\u304E\u308B\u5024: ${(_c = Y.origin) != null ? _c : "\u5024"}\u306F${Y.maximum.toString()}${z6}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`; + } + case "too_small": { + let z6 = Y.inclusive ? "\u4EE5\u4E0A\u3067\u3042\u308B" : "\u3088\u308A\u5927\u304D\u3044", W = X(Y.origin); + if (W) return `\u5C0F\u3055\u3059\u304E\u308B\u5024: ${Y.origin}\u306F${Y.minimum.toString()}${W.unit}${z6}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`; + return `\u5C0F\u3055\u3059\u304E\u308B\u5024: ${Y.origin}\u306F${Y.minimum.toString()}${z6}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `\u7121\u52B9\u306A\u6587\u5B57\u5217: "${z6.prefix}"\u3067\u59CB\u307E\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`; + if (z6.format === "ends_with") return `\u7121\u52B9\u306A\u6587\u5B57\u5217: "${z6.suffix}"\u3067\u7D42\u308F\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`; + if (z6.format === "includes") return `\u7121\u52B9\u306A\u6587\u5B57\u5217: "${z6.includes}"\u3092\u542B\u3080\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`; + if (z6.format === "regex") return `\u7121\u52B9\u306A\u6587\u5B57\u5217: \u30D1\u30BF\u30FC\u30F3${z6.pattern}\u306B\u4E00\u81F4\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`; + return `\u7121\u52B9\u306A${(_d = Q[z6.format]) != null ? _d : Y.format}`; + } + case "not_multiple_of": + return `\u7121\u52B9\u306A\u6570\u5024: ${Y.divisor}\u306E\u500D\u6570\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`; + case "unrecognized_keys": + return `\u8A8D\u8B58\u3055\u308C\u3066\u3044\u306A\u3044\u30AD\u30FC${Y.keys.length > 1 ? "\u7FA4" : ""}: ${M(Y.keys, "\u3001")}`; + case "invalid_key": + return `${Y.origin}\u5185\u306E\u7121\u52B9\u306A\u30AD\u30FC`; + case "invalid_union": + return "\u7121\u52B9\u306A\u5165\u529B"; + case "invalid_element": + return `${Y.origin}\u5185\u306E\u7121\u52B9\u306A\u5024`; + default: + return "\u7121\u52B9\u306A\u5165\u529B"; + } + }; +}; +function vW() { + return { localeError: xA() }; +} +var TA = () => { + let $ = { string: { unit: "\u178F\u17BD\u17A2\u1780\u17D2\u179F\u179A", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" }, file: { unit: "\u1794\u17C3", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" }, array: { unit: "\u1792\u17B6\u178F\u17BB", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" }, set: { unit: "\u1792\u17B6\u178F\u17BB", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "\u1798\u17B7\u1793\u1798\u17C2\u1793\u1787\u17B6\u179B\u17C1\u1781 (NaN)" : "\u179B\u17C1\u1781"; + case "object": { + if (Array.isArray(Y)) return "\u17A2\u17B6\u179A\u17C1 (Array)"; + if (Y === null) return "\u1782\u17D2\u1798\u17B6\u1793\u178F\u1798\u17D2\u179B\u17C3 (null)"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B", email: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793\u17A2\u17CA\u17B8\u1798\u17C2\u179B", url: "URL", emoji: "\u179F\u1789\u17D2\u1789\u17B6\u17A2\u17B6\u179A\u1798\u17D2\u1798\u178E\u17CD", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "\u1780\u17B6\u179B\u1794\u179A\u17B7\u1785\u17D2\u1786\u17C1\u1791 \u1793\u17B7\u1784\u1798\u17C9\u17C4\u1784 ISO", date: "\u1780\u17B6\u179B\u1794\u179A\u17B7\u1785\u17D2\u1786\u17C1\u1791 ISO", time: "\u1798\u17C9\u17C4\u1784 ISO", duration: "\u179A\u1799\u17C8\u1796\u17C1\u179B ISO", ipv4: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv4", ipv6: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv6", cidrv4: "\u178A\u17C2\u1793\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv4", cidrv6: "\u178A\u17C2\u1793\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv6", base64: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u17A2\u17CA\u17B7\u1780\u17BC\u178A base64", base64url: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u17A2\u17CA\u17B7\u1780\u17BC\u178A base64url", json_string: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A JSON", e164: "\u179B\u17C1\u1781 E.164", jwt: "JWT", template_literal: "\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${Y.expected} \u1794\u17C9\u17BB\u1793\u17D2\u178F\u17C2\u1791\u1791\u17BD\u179B\u1794\u17B6\u1793 ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${S(Y.values[0])}`; + return `\u1787\u1798\u17D2\u179A\u17BE\u179F\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1787\u17B6\u1798\u17BD\u1799\u1780\u17D2\u1793\u17BB\u1784\u1785\u17C6\u178E\u17C4\u1798 ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `\u1792\u17C6\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${(_a3 = Y.origin) != null ? _a3 : "\u178F\u1798\u17D2\u179B\u17C3"} ${z6} ${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "\u1792\u17B6\u178F\u17BB"}`; + return `\u1792\u17C6\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${(_c = Y.origin) != null ? _c : "\u178F\u1798\u17D2\u179B\u17C3"} ${z6} ${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `\u178F\u17BC\u1785\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${Y.origin} ${z6} ${Y.minimum.toString()} ${W.unit}`; + return `\u178F\u17BC\u1785\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${Y.origin} ${z6} ${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1785\u17B6\u1794\u17CB\u1795\u17D2\u178F\u17BE\u1798\u178A\u17C4\u1799 "${z6.prefix}"`; + if (z6.format === "ends_with") return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1794\u1789\u17D2\u1785\u1794\u17CB\u178A\u17C4\u1799 "${z6.suffix}"`; + if (z6.format === "includes") return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1798\u17B6\u1793 "${z6.includes}"`; + if (z6.format === "regex") return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u178F\u17C2\u1795\u17D2\u1782\u17BC\u1795\u17D2\u1782\u1784\u1793\u17B9\u1784\u1791\u1798\u17D2\u179A\u1784\u17CB\u178A\u17C2\u179B\u1794\u17B6\u1793\u1780\u17C6\u178E\u178F\u17CB ${z6.pattern}`; + return `\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 ${(_d = Q[z6.format]) != null ? _d : Y.format}`; + } + case "not_multiple_of": + return `\u179B\u17C1\u1781\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u178F\u17C2\u1787\u17B6\u1796\u17A0\u17BB\u1782\u17BB\u178E\u1793\u17C3 ${Y.divisor}`; + case "unrecognized_keys": + return `\u179A\u1780\u1783\u17BE\u1789\u179F\u17C4\u1798\u17B7\u1793\u179F\u17D2\u1782\u17B6\u179B\u17CB\u17D6 ${M(Y.keys, ", ")}`; + case "invalid_key": + return `\u179F\u17C4\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u1793\u17C5\u1780\u17D2\u1793\u17BB\u1784 ${Y.origin}`; + case "invalid_union": + return "\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C"; + case "invalid_element": + return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u1793\u17C5\u1780\u17D2\u1793\u17BB\u1784 ${Y.origin}`; + default: + return "\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C"; + } + }; +}; +function CW() { + return { localeError: TA() }; +} +var yA = () => { + let $ = { string: { unit: "\uBB38\uC790", verb: "to have" }, file: { unit: "\uBC14\uC774\uD2B8", verb: "to have" }, array: { unit: "\uAC1C", verb: "to have" }, set: { unit: "\uAC1C", verb: "to have" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "number"; + case "object": { + if (Array.isArray(Y)) return "array"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "\uC785\uB825", email: "\uC774\uBA54\uC77C \uC8FC\uC18C", url: "URL", emoji: "\uC774\uBAA8\uC9C0", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "ISO \uB0A0\uC9DC\uC2DC\uAC04", date: "ISO \uB0A0\uC9DC", time: "ISO \uC2DC\uAC04", duration: "ISO \uAE30\uAC04", ipv4: "IPv4 \uC8FC\uC18C", ipv6: "IPv6 \uC8FC\uC18C", cidrv4: "IPv4 \uBC94\uC704", cidrv6: "IPv6 \uBC94\uC704", base64: "base64 \uC778\uCF54\uB529 \uBB38\uC790\uC5F4", base64url: "base64url \uC778\uCF54\uB529 \uBB38\uC790\uC5F4", json_string: "JSON \uBB38\uC790\uC5F4", e164: "E.164 \uBC88\uD638", jwt: "JWT", template_literal: "\uC785\uB825" }; + return (Y) => { + var _a3, _b2, _c, _d, _e, _f, _g; + switch (Y.code) { + case "invalid_type": + return `\uC798\uBABB\uB41C \uC785\uB825: \uC608\uC0C1 \uD0C0\uC785\uC740 ${Y.expected}, \uBC1B\uC740 \uD0C0\uC785\uC740 ${J(Y.input)}\uC785\uB2C8\uB2E4`; + case "invalid_value": + if (Y.values.length === 1) return `\uC798\uBABB\uB41C \uC785\uB825: \uAC12\uC740 ${S(Y.values[0])} \uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4`; + return `\uC798\uBABB\uB41C \uC635\uC158: ${M(Y.values, "\uB610\uB294 ")} \uC911 \uD558\uB098\uC5EC\uC57C \uD569\uB2C8\uB2E4`; + case "too_big": { + let z6 = Y.inclusive ? "\uC774\uD558" : "\uBBF8\uB9CC", W = z6 === "\uBBF8\uB9CC" ? "\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4" : "\uC5EC\uC57C \uD569\uB2C8\uB2E4", G = X(Y.origin), U = (_a3 = G == null ? void 0 : G.unit) != null ? _a3 : "\uC694\uC18C"; + if (G) return `${(_b2 = Y.origin) != null ? _b2 : "\uAC12"}\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4: ${Y.maximum.toString()}${U} ${z6}${W}`; + return `${(_c = Y.origin) != null ? _c : "\uAC12"}\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4: ${Y.maximum.toString()} ${z6}${W}`; + } + case "too_small": { + let z6 = Y.inclusive ? "\uC774\uC0C1" : "\uCD08\uACFC", W = z6 === "\uC774\uC0C1" ? "\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4" : "\uC5EC\uC57C \uD569\uB2C8\uB2E4", G = X(Y.origin), U = (_d = G == null ? void 0 : G.unit) != null ? _d : "\uC694\uC18C"; + if (G) return `${(_e = Y.origin) != null ? _e : "\uAC12"}\uC774 \uB108\uBB34 \uC791\uC2B5\uB2C8\uB2E4: ${Y.minimum.toString()}${U} ${z6}${W}`; + return `${(_f = Y.origin) != null ? _f : "\uAC12"}\uC774 \uB108\uBB34 \uC791\uC2B5\uB2C8\uB2E4: ${Y.minimum.toString()} ${z6}${W}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: "${z6.prefix}"(\uC73C)\uB85C \uC2DC\uC791\uD574\uC57C \uD569\uB2C8\uB2E4`; + if (z6.format === "ends_with") return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: "${z6.suffix}"(\uC73C)\uB85C \uB05D\uB098\uC57C \uD569\uB2C8\uB2E4`; + if (z6.format === "includes") return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: "${z6.includes}"\uC744(\uB97C) \uD3EC\uD568\uD574\uC57C \uD569\uB2C8\uB2E4`; + if (z6.format === "regex") return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: \uC815\uADDC\uC2DD ${z6.pattern} \uD328\uD134\uACFC \uC77C\uCE58\uD574\uC57C \uD569\uB2C8\uB2E4`; + return `\uC798\uBABB\uB41C ${(_g = Q[z6.format]) != null ? _g : Y.format}`; + } + case "not_multiple_of": + return `\uC798\uBABB\uB41C \uC22B\uC790: ${Y.divisor}\uC758 \uBC30\uC218\uC5EC\uC57C \uD569\uB2C8\uB2E4`; + case "unrecognized_keys": + return `\uC778\uC2DD\uD560 \uC218 \uC5C6\uB294 \uD0A4: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `\uC798\uBABB\uB41C \uD0A4: ${Y.origin}`; + case "invalid_union": + return "\uC798\uBABB\uB41C \uC785\uB825"; + case "invalid_element": + return `\uC798\uBABB\uB41C \uAC12: ${Y.origin}`; + default: + return "\uC798\uBABB\uB41C \uC785\uB825"; + } + }; +}; +function kW() { + return { localeError: yA() }; +} +var fA = () => { + let $ = { string: { unit: "\u0437\u043D\u0430\u0446\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" }, file: { unit: "\u0431\u0430\u0458\u0442\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" }, array: { unit: "\u0441\u0442\u0430\u0432\u043A\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" }, set: { unit: "\u0441\u0442\u0430\u0432\u043A\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "\u0431\u0440\u043E\u0458"; + case "object": { + if (Array.isArray(Y)) return "\u043D\u0438\u0437\u0430"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "\u0432\u043D\u0435\u0441", email: "\u0430\u0434\u0440\u0435\u0441\u0430 \u043D\u0430 \u0435-\u043F\u043E\u0448\u0442\u0430", url: "URL", emoji: "\u0435\u043C\u043E\u045F\u0438", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "ISO \u0434\u0430\u0442\u0443\u043C \u0438 \u0432\u0440\u0435\u043C\u0435", date: "ISO \u0434\u0430\u0442\u0443\u043C", time: "ISO \u0432\u0440\u0435\u043C\u0435", duration: "ISO \u0432\u0440\u0435\u043C\u0435\u0442\u0440\u0430\u0435\u045A\u0435", ipv4: "IPv4 \u0430\u0434\u0440\u0435\u0441\u0430", ipv6: "IPv6 \u0430\u0434\u0440\u0435\u0441\u0430", cidrv4: "IPv4 \u043E\u043F\u0441\u0435\u0433", cidrv6: "IPv6 \u043E\u043F\u0441\u0435\u0433", base64: "base64-\u0435\u043D\u043A\u043E\u0434\u0438\u0440\u0430\u043D\u0430 \u043D\u0438\u0437\u0430", base64url: "base64url-\u0435\u043D\u043A\u043E\u0434\u0438\u0440\u0430\u043D\u0430 \u043D\u0438\u0437\u0430", json_string: "JSON \u043D\u0438\u0437\u0430", e164: "E.164 \u0431\u0440\u043E\u0458", jwt: "JWT", template_literal: "\u0432\u043D\u0435\u0441" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${Y.expected}, \u043F\u0440\u0438\u043C\u0435\u043D\u043E ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `Invalid input: expected ${S(Y.values[0])}`; + return `\u0413\u0440\u0435\u0448\u0430\u043D\u0430 \u043E\u043F\u0446\u0438\u0458\u0430: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 \u0435\u0434\u043D\u0430 ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u0433\u043E\u043B\u0435\u043C: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${(_a3 = Y.origin) != null ? _a3 : "\u0432\u0440\u0435\u0434\u043D\u043E\u0441\u0442\u0430"} \u0434\u0430 \u0438\u043C\u0430 ${z6}${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0438"}`; + return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u0433\u043E\u043B\u0435\u043C: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${(_c = Y.origin) != null ? _c : "\u0432\u0440\u0435\u0434\u043D\u043E\u0441\u0442\u0430"} \u0434\u0430 \u0431\u0438\u0434\u0435 ${z6}${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u043C\u0430\u043B: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${Y.origin} \u0434\u0430 \u0438\u043C\u0430 ${z6}${Y.minimum.toString()} ${W.unit}`; + return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u043C\u0430\u043B: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${Y.origin} \u0434\u0430 \u0431\u0438\u0434\u0435 ${z6}${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0437\u0430\u043F\u043E\u0447\u043D\u0443\u0432\u0430 \u0441\u043E "${z6.prefix}"`; + if (z6.format === "ends_with") return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0437\u0430\u0432\u0440\u0448\u0443\u0432\u0430 \u0441\u043E "${z6.suffix}"`; + if (z6.format === "includes") return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0432\u043A\u043B\u0443\u0447\u0443\u0432\u0430 "${z6.includes}"`; + if (z6.format === "regex") return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u043E\u0434\u0433\u043E\u0430\u0440\u0430 \u043D\u0430 \u043F\u0430\u0442\u0435\u0440\u043D\u043E\u0442 ${z6.pattern}`; + return `Invalid ${(_d = Q[z6.format]) != null ? _d : Y.format}`; + } + case "not_multiple_of": + return `\u0413\u0440\u0435\u0448\u0435\u043D \u0431\u0440\u043E\u0458: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0431\u0438\u0434\u0435 \u0434\u0435\u043B\u0438\u0432 \u0441\u043E ${Y.divisor}`; + case "unrecognized_keys": + return `${Y.keys.length > 1 ? "\u041D\u0435\u043F\u0440\u0435\u043F\u043E\u0437\u043D\u0430\u0435\u043D\u0438 \u043A\u043B\u0443\u0447\u0435\u0432\u0438" : "\u041D\u0435\u043F\u0440\u0435\u043F\u043E\u0437\u043D\u0430\u0435\u043D \u043A\u043B\u0443\u0447"}: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `\u0413\u0440\u0435\u0448\u0435\u043D \u043A\u043B\u0443\u0447 \u0432\u043E ${Y.origin}`; + case "invalid_union": + return "\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441"; + case "invalid_element": + return `\u0413\u0440\u0435\u0448\u043D\u0430 \u0432\u0440\u0435\u0434\u043D\u043E\u0441\u0442 \u0432\u043E ${Y.origin}`; + default: + return "\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441"; + } + }; +}; +function _W() { + return { localeError: fA() }; +} +var gA = () => { + let $ = { string: { unit: "aksara", verb: "mempunyai" }, file: { unit: "bait", verb: "mempunyai" }, array: { unit: "elemen", verb: "mempunyai" }, set: { unit: "elemen", verb: "mempunyai" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "nombor"; + case "object": { + if (Array.isArray(Y)) return "array"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "input", email: "alamat e-mel", url: "URL", emoji: "emoji", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "tarikh masa ISO", date: "tarikh ISO", time: "masa ISO", duration: "tempoh ISO", ipv4: "alamat IPv4", ipv6: "alamat IPv6", cidrv4: "julat IPv4", cidrv6: "julat IPv6", base64: "string dikodkan base64", base64url: "string dikodkan base64url", json_string: "string JSON", e164: "nombor E.164", jwt: "JWT", template_literal: "input" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `Input tidak sah: dijangka ${Y.expected}, diterima ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `Input tidak sah: dijangka ${S(Y.values[0])}`; + return `Pilihan tidak sah: dijangka salah satu daripada ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `Terlalu besar: dijangka ${(_a3 = Y.origin) != null ? _a3 : "nilai"} ${W.verb} ${z6}${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "elemen"}`; + return `Terlalu besar: dijangka ${(_c = Y.origin) != null ? _c : "nilai"} adalah ${z6}${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `Terlalu kecil: dijangka ${Y.origin} ${W.verb} ${z6}${Y.minimum.toString()} ${W.unit}`; + return `Terlalu kecil: dijangka ${Y.origin} adalah ${z6}${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `String tidak sah: mesti bermula dengan "${z6.prefix}"`; + if (z6.format === "ends_with") return `String tidak sah: mesti berakhir dengan "${z6.suffix}"`; + if (z6.format === "includes") return `String tidak sah: mesti mengandungi "${z6.includes}"`; + if (z6.format === "regex") return `String tidak sah: mesti sepadan dengan corak ${z6.pattern}`; + return `${(_d = Q[z6.format]) != null ? _d : Y.format} tidak sah`; + } + case "not_multiple_of": + return `Nombor tidak sah: perlu gandaan ${Y.divisor}`; + case "unrecognized_keys": + return `Kunci tidak dikenali: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `Kunci tidak sah dalam ${Y.origin}`; + case "invalid_union": + return "Input tidak sah"; + case "invalid_element": + return `Nilai tidak sah dalam ${Y.origin}`; + default: + return "Input tidak sah"; + } + }; +}; +function xW() { + return { localeError: gA() }; +} +var hA = () => { + let $ = { string: { unit: "tekens" }, file: { unit: "bytes" }, array: { unit: "elementen" }, set: { unit: "elementen" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "getal"; + case "object": { + if (Array.isArray(Y)) return "array"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "invoer", email: "emailadres", url: "URL", emoji: "emoji", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "ISO datum en tijd", date: "ISO datum", time: "ISO tijd", duration: "ISO duur", ipv4: "IPv4-adres", ipv6: "IPv6-adres", cidrv4: "IPv4-bereik", cidrv6: "IPv6-bereik", base64: "base64-gecodeerde tekst", base64url: "base64 URL-gecodeerde tekst", json_string: "JSON string", e164: "E.164-nummer", jwt: "JWT", template_literal: "invoer" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `Ongeldige invoer: verwacht ${Y.expected}, ontving ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `Ongeldige invoer: verwacht ${S(Y.values[0])}`; + return `Ongeldige optie: verwacht \xE9\xE9n van ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `Te lang: verwacht dat ${(_a3 = Y.origin) != null ? _a3 : "waarde"} ${z6}${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "elementen"} bevat`; + return `Te lang: verwacht dat ${(_c = Y.origin) != null ? _c : "waarde"} ${z6}${Y.maximum.toString()} is`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `Te kort: verwacht dat ${Y.origin} ${z6}${Y.minimum.toString()} ${W.unit} bevat`; + return `Te kort: verwacht dat ${Y.origin} ${z6}${Y.minimum.toString()} is`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `Ongeldige tekst: moet met "${z6.prefix}" beginnen`; + if (z6.format === "ends_with") return `Ongeldige tekst: moet op "${z6.suffix}" eindigen`; + if (z6.format === "includes") return `Ongeldige tekst: moet "${z6.includes}" bevatten`; + if (z6.format === "regex") return `Ongeldige tekst: moet overeenkomen met patroon ${z6.pattern}`; + return `Ongeldig: ${(_d = Q[z6.format]) != null ? _d : Y.format}`; + } + case "not_multiple_of": + return `Ongeldig getal: moet een veelvoud van ${Y.divisor} zijn`; + case "unrecognized_keys": + return `Onbekende key${Y.keys.length > 1 ? "s" : ""}: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `Ongeldige key in ${Y.origin}`; + case "invalid_union": + return "Ongeldige invoer"; + case "invalid_element": + return `Ongeldige waarde in ${Y.origin}`; + default: + return "Ongeldige invoer"; + } + }; +}; +function TW() { + return { localeError: hA() }; +} +var uA = () => { + let $ = { string: { unit: "tegn", verb: "\xE5 ha" }, file: { unit: "bytes", verb: "\xE5 ha" }, array: { unit: "elementer", verb: "\xE5 inneholde" }, set: { unit: "elementer", verb: "\xE5 inneholde" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "tall"; + case "object": { + if (Array.isArray(Y)) return "liste"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "input", email: "e-postadresse", url: "URL", emoji: "emoji", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "ISO dato- og klokkeslett", date: "ISO-dato", time: "ISO-klokkeslett", duration: "ISO-varighet", ipv4: "IPv4-omr\xE5de", ipv6: "IPv6-omr\xE5de", cidrv4: "IPv4-spekter", cidrv6: "IPv6-spekter", base64: "base64-enkodet streng", base64url: "base64url-enkodet streng", json_string: "JSON-streng", e164: "E.164-nummer", jwt: "JWT", template_literal: "input" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `Ugyldig input: forventet ${Y.expected}, fikk ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `Ugyldig verdi: forventet ${S(Y.values[0])}`; + return `Ugyldig valg: forventet en av ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `For stor(t): forventet ${(_a3 = Y.origin) != null ? _a3 : "value"} til \xE5 ha ${z6}${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "elementer"}`; + return `For stor(t): forventet ${(_c = Y.origin) != null ? _c : "value"} til \xE5 ha ${z6}${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `For lite(n): forventet ${Y.origin} til \xE5 ha ${z6}${Y.minimum.toString()} ${W.unit}`; + return `For lite(n): forventet ${Y.origin} til \xE5 ha ${z6}${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `Ugyldig streng: m\xE5 starte med "${z6.prefix}"`; + if (z6.format === "ends_with") return `Ugyldig streng: m\xE5 ende med "${z6.suffix}"`; + if (z6.format === "includes") return `Ugyldig streng: m\xE5 inneholde "${z6.includes}"`; + if (z6.format === "regex") return `Ugyldig streng: m\xE5 matche m\xF8nsteret ${z6.pattern}`; + return `Ugyldig ${(_d = Q[z6.format]) != null ? _d : Y.format}`; + } + case "not_multiple_of": + return `Ugyldig tall: m\xE5 v\xE6re et multiplum av ${Y.divisor}`; + case "unrecognized_keys": + return `${Y.keys.length > 1 ? "Ukjente n\xF8kler" : "Ukjent n\xF8kkel"}: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `Ugyldig n\xF8kkel i ${Y.origin}`; + case "invalid_union": + return "Ugyldig input"; + case "invalid_element": + return `Ugyldig verdi i ${Y.origin}`; + default: + return "Ugyldig input"; + } + }; +}; +function yW() { + return { localeError: uA() }; +} +var mA = () => { + let $ = { string: { unit: "harf", verb: "olmal\u0131d\u0131r" }, file: { unit: "bayt", verb: "olmal\u0131d\u0131r" }, array: { unit: "unsur", verb: "olmal\u0131d\u0131r" }, set: { unit: "unsur", verb: "olmal\u0131d\u0131r" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "numara"; + case "object": { + if (Array.isArray(Y)) return "saf"; + if (Y === null) return "gayb"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "giren", email: "epostag\xE2h", url: "URL", emoji: "emoji", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "ISO heng\xE2m\u0131", date: "ISO tarihi", time: "ISO zaman\u0131", duration: "ISO m\xFCddeti", ipv4: "IPv4 ni\u015F\xE2n\u0131", ipv6: "IPv6 ni\u015F\xE2n\u0131", cidrv4: "IPv4 menzili", cidrv6: "IPv6 menzili", base64: "base64-\u015Fifreli metin", base64url: "base64url-\u015Fifreli metin", json_string: "JSON metin", e164: "E.164 say\u0131s\u0131", jwt: "JWT", template_literal: "giren" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `F\xE2sit giren: umulan ${Y.expected}, al\u0131nan ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `F\xE2sit giren: umulan ${S(Y.values[0])}`; + return `F\xE2sit tercih: m\xFBteberler ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `Fazla b\xFCy\xFCk: ${(_a3 = Y.origin) != null ? _a3 : "value"}, ${z6}${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "elements"} sahip olmal\u0131yd\u0131.`; + return `Fazla b\xFCy\xFCk: ${(_c = Y.origin) != null ? _c : "value"}, ${z6}${Y.maximum.toString()} olmal\u0131yd\u0131.`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `Fazla k\xFC\xE7\xFCk: ${Y.origin}, ${z6}${Y.minimum.toString()} ${W.unit} sahip olmal\u0131yd\u0131.`; + return `Fazla k\xFC\xE7\xFCk: ${Y.origin}, ${z6}${Y.minimum.toString()} olmal\u0131yd\u0131.`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `F\xE2sit metin: "${z6.prefix}" ile ba\u015Flamal\u0131.`; + if (z6.format === "ends_with") return `F\xE2sit metin: "${z6.suffix}" ile bitmeli.`; + if (z6.format === "includes") return `F\xE2sit metin: "${z6.includes}" ihtiv\xE2 etmeli.`; + if (z6.format === "regex") return `F\xE2sit metin: ${z6.pattern} nak\u015F\u0131na uymal\u0131.`; + return `F\xE2sit ${(_d = Q[z6.format]) != null ? _d : Y.format}`; + } + case "not_multiple_of": + return `F\xE2sit say\u0131: ${Y.divisor} kat\u0131 olmal\u0131yd\u0131.`; + case "unrecognized_keys": + return `Tan\u0131nmayan anahtar ${Y.keys.length > 1 ? "s" : ""}: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `${Y.origin} i\xE7in tan\u0131nmayan anahtar var.`; + case "invalid_union": + return "Giren tan\u0131namad\u0131."; + case "invalid_element": + return `${Y.origin} i\xE7in tan\u0131nmayan k\u0131ymet var.`; + default: + return "K\u0131ymet tan\u0131namad\u0131."; + } + }; +}; +function fW() { + return { localeError: mA() }; +} +var lA = () => { + let $ = { string: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" }, file: { unit: "\u0628\u0627\u06CC\u067C\u0633", verb: "\u0648\u0644\u0631\u064A" }, array: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" }, set: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "\u0639\u062F\u062F"; + case "object": { + if (Array.isArray(Y)) return "\u0627\u0631\u06D0"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "\u0648\u0631\u0648\u062F\u064A", email: "\u0628\u0631\u06CC\u069A\u0646\u0627\u0644\u06CC\u06A9", url: "\u06CC\u0648 \u0622\u0631 \u0627\u0644", emoji: "\u0627\u06CC\u0645\u0648\u062C\u064A", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "\u0646\u06CC\u067C\u0647 \u0627\u0648 \u0648\u062E\u062A", date: "\u0646\u06D0\u067C\u0647", time: "\u0648\u062E\u062A", duration: "\u0645\u0648\u062F\u0647", ipv4: "\u062F IPv4 \u067E\u062A\u0647", ipv6: "\u062F IPv6 \u067E\u062A\u0647", cidrv4: "\u062F IPv4 \u0633\u0627\u062D\u0647", cidrv6: "\u062F IPv6 \u0633\u0627\u062D\u0647", base64: "base64-encoded \u0645\u062A\u0646", base64url: "base64url-encoded \u0645\u062A\u0646", json_string: "JSON \u0645\u062A\u0646", e164: "\u062F E.164 \u0634\u0645\u06D0\u0631\u0647", jwt: "JWT", template_literal: "\u0648\u0631\u0648\u062F\u064A" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `\u0646\u0627\u0633\u0645 \u0648\u0631\u0648\u062F\u064A: \u0628\u0627\u06CC\u062F ${Y.expected} \u0648\u0627\u06CC, \u0645\u06AB\u0631 ${J(Y.input)} \u062A\u0631\u0644\u0627\u0633\u0647 \u0634\u0648`; + case "invalid_value": + if (Y.values.length === 1) return `\u0646\u0627\u0633\u0645 \u0648\u0631\u0648\u062F\u064A: \u0628\u0627\u06CC\u062F ${S(Y.values[0])} \u0648\u0627\u06CC`; + return `\u0646\u0627\u0633\u0645 \u0627\u0646\u062A\u062E\u0627\u0628: \u0628\u0627\u06CC\u062F \u06CC\u0648 \u0644\u0647 ${M(Y.values, "|")} \u0685\u062E\u0647 \u0648\u0627\u06CC`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `\u0689\u06CC\u0631 \u0644\u0648\u06CC: ${(_a3 = Y.origin) != null ? _a3 : "\u0627\u0631\u0632\u069A\u062A"} \u0628\u0627\u06CC\u062F ${z6}${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "\u0639\u0646\u0635\u0631\u0648\u0646\u0647"} \u0648\u0644\u0631\u064A`; + return `\u0689\u06CC\u0631 \u0644\u0648\u06CC: ${(_c = Y.origin) != null ? _c : "\u0627\u0631\u0632\u069A\u062A"} \u0628\u0627\u06CC\u062F ${z6}${Y.maximum.toString()} \u0648\u064A`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `\u0689\u06CC\u0631 \u06A9\u0648\u0686\u0646\u06CC: ${Y.origin} \u0628\u0627\u06CC\u062F ${z6}${Y.minimum.toString()} ${W.unit} \u0648\u0644\u0631\u064A`; + return `\u0689\u06CC\u0631 \u06A9\u0648\u0686\u0646\u06CC: ${Y.origin} \u0628\u0627\u06CC\u062F ${z6}${Y.minimum.toString()} \u0648\u064A`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F \u062F "${z6.prefix}" \u0633\u0631\u0647 \u067E\u06CC\u0644 \u0634\u064A`; + if (z6.format === "ends_with") return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F \u062F "${z6.suffix}" \u0633\u0631\u0647 \u067E\u0627\u06CC \u062A\u0647 \u0648\u0631\u0633\u064A\u0696\u064A`; + if (z6.format === "includes") return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F "${z6.includes}" \u0648\u0644\u0631\u064A`; + if (z6.format === "regex") return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F \u062F ${z6.pattern} \u0633\u0631\u0647 \u0645\u0637\u0627\u0628\u0642\u062A \u0648\u0644\u0631\u064A`; + return `${(_d = Q[z6.format]) != null ? _d : Y.format} \u0646\u0627\u0633\u0645 \u062F\u06CC`; + } + case "not_multiple_of": + return `\u0646\u0627\u0633\u0645 \u0639\u062F\u062F: \u0628\u0627\u06CC\u062F \u062F ${Y.divisor} \u0645\u0636\u0631\u0628 \u0648\u064A`; + case "unrecognized_keys": + return `\u0646\u0627\u0633\u0645 ${Y.keys.length > 1 ? "\u06A9\u0644\u06CC\u0689\u0648\u0646\u0647" : "\u06A9\u0644\u06CC\u0689"}: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `\u0646\u0627\u0633\u0645 \u06A9\u0644\u06CC\u0689 \u067E\u0647 ${Y.origin} \u06A9\u06D0`; + case "invalid_union": + return "\u0646\u0627\u0633\u0645\u0647 \u0648\u0631\u0648\u062F\u064A"; + case "invalid_element": + return `\u0646\u0627\u0633\u0645 \u0639\u0646\u0635\u0631 \u067E\u0647 ${Y.origin} \u06A9\u06D0`; + default: + return "\u0646\u0627\u0633\u0645\u0647 \u0648\u0631\u0648\u062F\u064A"; + } + }; +}; +function gW() { + return { localeError: lA() }; +} +var cA = () => { + let $ = { string: { unit: "znak\xF3w", verb: "mie\u0107" }, file: { unit: "bajt\xF3w", verb: "mie\u0107" }, array: { unit: "element\xF3w", verb: "mie\u0107" }, set: { unit: "element\xF3w", verb: "mie\u0107" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "liczba"; + case "object": { + if (Array.isArray(Y)) return "tablica"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "wyra\u017Cenie", email: "adres email", url: "URL", emoji: "emoji", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "data i godzina w formacie ISO", date: "data w formacie ISO", time: "godzina w formacie ISO", duration: "czas trwania ISO", ipv4: "adres IPv4", ipv6: "adres IPv6", cidrv4: "zakres IPv4", cidrv6: "zakres IPv6", base64: "ci\u0105g znak\xF3w zakodowany w formacie base64", base64url: "ci\u0105g znak\xF3w zakodowany w formacie base64url", json_string: "ci\u0105g znak\xF3w w formacie JSON", e164: "liczba E.164", jwt: "JWT", template_literal: "wej\u015Bcie" }; + return (Y) => { + var _a3, _b2, _c, _d, _e, _f, _g; + switch (Y.code) { + case "invalid_type": + return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano ${Y.expected}, otrzymano ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano ${S(Y.values[0])}`; + return `Nieprawid\u0142owa opcja: oczekiwano jednej z warto\u015Bci ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `Za du\u017Ca warto\u015B\u0107: oczekiwano, \u017Ce ${(_a3 = Y.origin) != null ? _a3 : "warto\u015B\u0107"} b\u0119dzie mie\u0107 ${z6}${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "element\xF3w"}`; + return `Zbyt du\u017C(y/a/e): oczekiwano, \u017Ce ${(_c = Y.origin) != null ? _c : "warto\u015B\u0107"} b\u0119dzie wynosi\u0107 ${z6}${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `Za ma\u0142a warto\u015B\u0107: oczekiwano, \u017Ce ${(_d = Y.origin) != null ? _d : "warto\u015B\u0107"} b\u0119dzie mie\u0107 ${z6}${Y.minimum.toString()} ${(_e = W.unit) != null ? _e : "element\xF3w"}`; + return `Zbyt ma\u0142(y/a/e): oczekiwano, \u017Ce ${(_f = Y.origin) != null ? _f : "warto\u015B\u0107"} b\u0119dzie wynosi\u0107 ${z6}${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi zaczyna\u0107 si\u0119 od "${z6.prefix}"`; + if (z6.format === "ends_with") return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi ko\u0144czy\u0107 si\u0119 na "${z6.suffix}"`; + if (z6.format === "includes") return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi zawiera\u0107 "${z6.includes}"`; + if (z6.format === "regex") return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi odpowiada\u0107 wzorcowi ${z6.pattern}`; + return `Nieprawid\u0142ow(y/a/e) ${(_g = Q[z6.format]) != null ? _g : Y.format}`; + } + case "not_multiple_of": + return `Nieprawid\u0142owa liczba: musi by\u0107 wielokrotno\u015Bci\u0105 ${Y.divisor}`; + case "unrecognized_keys": + return `Nierozpoznane klucze${Y.keys.length > 1 ? "s" : ""}: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `Nieprawid\u0142owy klucz w ${Y.origin}`; + case "invalid_union": + return "Nieprawid\u0142owe dane wej\u015Bciowe"; + case "invalid_element": + return `Nieprawid\u0142owa warto\u015B\u0107 w ${Y.origin}`; + default: + return "Nieprawid\u0142owe dane wej\u015Bciowe"; + } + }; +}; +function hW() { + return { localeError: cA() }; +} +var pA = () => { + let $ = { string: { unit: "caracteres", verb: "ter" }, file: { unit: "bytes", verb: "ter" }, array: { unit: "itens", verb: "ter" }, set: { unit: "itens", verb: "ter" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "n\xFAmero"; + case "object": { + if (Array.isArray(Y)) return "array"; + if (Y === null) return "nulo"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "padr\xE3o", email: "endere\xE7o de e-mail", url: "URL", emoji: "emoji", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "data e hora ISO", date: "data ISO", time: "hora ISO", duration: "dura\xE7\xE3o ISO", ipv4: "endere\xE7o IPv4", ipv6: "endere\xE7o IPv6", cidrv4: "faixa de IPv4", cidrv6: "faixa de IPv6", base64: "texto codificado em base64", base64url: "URL codificada em base64", json_string: "texto JSON", e164: "n\xFAmero E.164", jwt: "JWT", template_literal: "entrada" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `Tipo inv\xE1lido: esperado ${Y.expected}, recebido ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `Entrada inv\xE1lida: esperado ${S(Y.values[0])}`; + return `Op\xE7\xE3o inv\xE1lida: esperada uma das ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `Muito grande: esperado que ${(_a3 = Y.origin) != null ? _a3 : "valor"} tivesse ${z6}${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "elementos"}`; + return `Muito grande: esperado que ${(_c = Y.origin) != null ? _c : "valor"} fosse ${z6}${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `Muito pequeno: esperado que ${Y.origin} tivesse ${z6}${Y.minimum.toString()} ${W.unit}`; + return `Muito pequeno: esperado que ${Y.origin} fosse ${z6}${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `Texto inv\xE1lido: deve come\xE7ar com "${z6.prefix}"`; + if (z6.format === "ends_with") return `Texto inv\xE1lido: deve terminar com "${z6.suffix}"`; + if (z6.format === "includes") return `Texto inv\xE1lido: deve incluir "${z6.includes}"`; + if (z6.format === "regex") return `Texto inv\xE1lido: deve corresponder ao padr\xE3o ${z6.pattern}`; + return `${(_d = Q[z6.format]) != null ? _d : Y.format} inv\xE1lido`; + } + case "not_multiple_of": + return `N\xFAmero inv\xE1lido: deve ser m\xFAltiplo de ${Y.divisor}`; + case "unrecognized_keys": + return `Chave${Y.keys.length > 1 ? "s" : ""} desconhecida${Y.keys.length > 1 ? "s" : ""}: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `Chave inv\xE1lida em ${Y.origin}`; + case "invalid_union": + return "Entrada inv\xE1lida"; + case "invalid_element": + return `Valor inv\xE1lido em ${Y.origin}`; + default: + return "Campo inv\xE1lido"; + } + }; +}; +function uW() { + return { localeError: pA() }; +} +function EN($, X, J, Q) { + let Y = Math.abs($), z6 = Y % 10, W = Y % 100; + if (W >= 11 && W <= 19) return Q; + if (z6 === 1) return X; + if (z6 >= 2 && z6 <= 4) return J; + return Q; +} +var iA = () => { + let $ = { string: { unit: { one: "\u0441\u0438\u043C\u0432\u043E\u043B", few: "\u0441\u0438\u043C\u0432\u043E\u043B\u0430", many: "\u0441\u0438\u043C\u0432\u043E\u043B\u043E\u0432" }, verb: "\u0438\u043C\u0435\u0442\u044C" }, file: { unit: { one: "\u0431\u0430\u0439\u0442", few: "\u0431\u0430\u0439\u0442\u0430", many: "\u0431\u0430\u0439\u0442" }, verb: "\u0438\u043C\u0435\u0442\u044C" }, array: { unit: { one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442", few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430", many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u043E\u0432" }, verb: "\u0438\u043C\u0435\u0442\u044C" }, set: { unit: { one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442", few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430", many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u043E\u0432" }, verb: "\u0438\u043C\u0435\u0442\u044C" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "\u0447\u0438\u0441\u043B\u043E"; + case "object": { + if (Array.isArray(Y)) return "\u043C\u0430\u0441\u0441\u0438\u0432"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "\u0432\u0432\u043E\u0434", email: "email \u0430\u0434\u0440\u0435\u0441", url: "URL", emoji: "\u044D\u043C\u043E\u0434\u0437\u0438", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "ISO \u0434\u0430\u0442\u0430 \u0438 \u0432\u0440\u0435\u043C\u044F", date: "ISO \u0434\u0430\u0442\u0430", time: "ISO \u0432\u0440\u0435\u043C\u044F", duration: "ISO \u0434\u043B\u0438\u0442\u0435\u043B\u044C\u043D\u043E\u0441\u0442\u044C", ipv4: "IPv4 \u0430\u0434\u0440\u0435\u0441", ipv6: "IPv6 \u0430\u0434\u0440\u0435\u0441", cidrv4: "IPv4 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D", cidrv6: "IPv6 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D", base64: "\u0441\u0442\u0440\u043E\u043A\u0430 \u0432 \u0444\u043E\u0440\u043C\u0430\u0442\u0435 base64", base64url: "\u0441\u0442\u0440\u043E\u043A\u0430 \u0432 \u0444\u043E\u0440\u043C\u0430\u0442\u0435 base64url", json_string: "JSON \u0441\u0442\u0440\u043E\u043A\u0430", e164: "\u043D\u043E\u043C\u0435\u0440 E.164", jwt: "JWT", template_literal: "\u0432\u0432\u043E\u0434" }; + return (Y) => { + var _a3, _b2, _c; + switch (Y.code) { + case "invalid_type": + return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C ${Y.expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C ${S(Y.values[0])}`; + return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0430\u0440\u0438\u0430\u043D\u0442: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C \u043E\u0434\u043D\u043E \u0438\u0437 ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) { + let G = Number(Y.maximum), U = EN(G, W.unit.one, W.unit.few, W.unit.many); + return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u0431\u043E\u043B\u044C\u0448\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${(_a3 = Y.origin) != null ? _a3 : "\u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435"} \u0431\u0443\u0434\u0435\u0442 \u0438\u043C\u0435\u0442\u044C ${z6}${Y.maximum.toString()} ${U}`; + } + return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u0431\u043E\u043B\u044C\u0448\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${(_b2 = Y.origin) != null ? _b2 : "\u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435"} \u0431\u0443\u0434\u0435\u0442 ${z6}${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) { + let G = Number(Y.minimum), U = EN(G, W.unit.one, W.unit.few, W.unit.many); + return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u043C\u0430\u043B\u0435\u043D\u044C\u043A\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${Y.origin} \u0431\u0443\u0434\u0435\u0442 \u0438\u043C\u0435\u0442\u044C ${z6}${Y.minimum.toString()} ${U}`; + } + return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u043C\u0430\u043B\u0435\u043D\u044C\u043A\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${Y.origin} \u0431\u0443\u0434\u0435\u0442 ${z6}${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u043D\u0430\u0447\u0438\u043D\u0430\u0442\u044C\u0441\u044F \u0441 "${z6.prefix}"`; + if (z6.format === "ends_with") return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0437\u0430\u043A\u0430\u043D\u0447\u0438\u0432\u0430\u0442\u044C\u0441\u044F \u043D\u0430 "${z6.suffix}"`; + if (z6.format === "includes") return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0441\u043E\u0434\u0435\u0440\u0436\u0430\u0442\u044C "${z6.includes}"`; + if (z6.format === "regex") return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0441\u043E\u043E\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u043E\u0432\u0430\u0442\u044C \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${z6.pattern}`; + return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 ${(_c = Q[z6.format]) != null ? _c : Y.format}`; + } + case "not_multiple_of": + return `\u041D\u0435\u0432\u0435\u0440\u043D\u043E\u0435 \u0447\u0438\u0441\u043B\u043E: \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043A\u0440\u0430\u0442\u043D\u044B\u043C ${Y.divisor}`; + case "unrecognized_keys": + return `\u041D\u0435\u0440\u0430\u0441\u043F\u043E\u0437\u043D\u0430\u043D\u043D${Y.keys.length > 1 ? "\u044B\u0435" : "\u044B\u0439"} \u043A\u043B\u044E\u0447${Y.keys.length > 1 ? "\u0438" : ""}: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u043A\u043B\u044E\u0447 \u0432 ${Y.origin}`; + case "invalid_union": + return "\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0435 \u0432\u0445\u043E\u0434\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435"; + case "invalid_element": + return `\u041D\u0435\u0432\u0435\u0440\u043D\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u0432 ${Y.origin}`; + default: + return "\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0435 \u0432\u0445\u043E\u0434\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435"; + } + }; +}; +function mW() { + return { localeError: iA() }; +} +var nA = () => { + let $ = { string: { unit: "znakov", verb: "imeti" }, file: { unit: "bajtov", verb: "imeti" }, array: { unit: "elementov", verb: "imeti" }, set: { unit: "elementov", verb: "imeti" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "\u0161tevilo"; + case "object": { + if (Array.isArray(Y)) return "tabela"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "vnos", email: "e-po\u0161tni naslov", url: "URL", emoji: "emoji", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "ISO datum in \u010Das", date: "ISO datum", time: "ISO \u010Das", duration: "ISO trajanje", ipv4: "IPv4 naslov", ipv6: "IPv6 naslov", cidrv4: "obseg IPv4", cidrv6: "obseg IPv6", base64: "base64 kodiran niz", base64url: "base64url kodiran niz", json_string: "JSON niz", e164: "E.164 \u0161tevilka", jwt: "JWT", template_literal: "vnos" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `Neveljaven vnos: pri\u010Dakovano ${Y.expected}, prejeto ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `Neveljaven vnos: pri\u010Dakovano ${S(Y.values[0])}`; + return `Neveljavna mo\u017Enost: pri\u010Dakovano eno izmed ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `Preveliko: pri\u010Dakovano, da bo ${(_a3 = Y.origin) != null ? _a3 : "vrednost"} imelo ${z6}${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "elementov"}`; + return `Preveliko: pri\u010Dakovano, da bo ${(_c = Y.origin) != null ? _c : "vrednost"} ${z6}${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `Premajhno: pri\u010Dakovano, da bo ${Y.origin} imelo ${z6}${Y.minimum.toString()} ${W.unit}`; + return `Premajhno: pri\u010Dakovano, da bo ${Y.origin} ${z6}${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `Neveljaven niz: mora se za\u010Deti z "${z6.prefix}"`; + if (z6.format === "ends_with") return `Neveljaven niz: mora se kon\u010Dati z "${z6.suffix}"`; + if (z6.format === "includes") return `Neveljaven niz: mora vsebovati "${z6.includes}"`; + if (z6.format === "regex") return `Neveljaven niz: mora ustrezati vzorcu ${z6.pattern}`; + return `Neveljaven ${(_d = Q[z6.format]) != null ? _d : Y.format}`; + } + case "not_multiple_of": + return `Neveljavno \u0161tevilo: mora biti ve\u010Dkratnik ${Y.divisor}`; + case "unrecognized_keys": + return `Neprepoznan${Y.keys.length > 1 ? "i klju\u010Di" : " klju\u010D"}: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `Neveljaven klju\u010D v ${Y.origin}`; + case "invalid_union": + return "Neveljaven vnos"; + case "invalid_element": + return `Neveljavna vrednost v ${Y.origin}`; + default: + return "Neveljaven vnos"; + } + }; +}; +function lW() { + return { localeError: nA() }; +} +var dA = () => { + let $ = { string: { unit: "tecken", verb: "att ha" }, file: { unit: "bytes", verb: "att ha" }, array: { unit: "objekt", verb: "att inneh\xE5lla" }, set: { unit: "objekt", verb: "att inneh\xE5lla" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "antal"; + case "object": { + if (Array.isArray(Y)) return "lista"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "regulj\xE4rt uttryck", email: "e-postadress", url: "URL", emoji: "emoji", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "ISO-datum och tid", date: "ISO-datum", time: "ISO-tid", duration: "ISO-varaktighet", ipv4: "IPv4-intervall", ipv6: "IPv6-intervall", cidrv4: "IPv4-spektrum", cidrv6: "IPv6-spektrum", base64: "base64-kodad str\xE4ng", base64url: "base64url-kodad str\xE4ng", json_string: "JSON-str\xE4ng", e164: "E.164-nummer", jwt: "JWT", template_literal: "mall-literal" }; + return (Y) => { + var _a3, _b2, _c, _d, _e, _f, _g, _h; + switch (Y.code) { + case "invalid_type": + return `Ogiltig inmatning: f\xF6rv\xE4ntat ${Y.expected}, fick ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `Ogiltig inmatning: f\xF6rv\xE4ntat ${S(Y.values[0])}`; + return `Ogiltigt val: f\xF6rv\xE4ntade en av ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `F\xF6r stor(t): f\xF6rv\xE4ntade ${(_a3 = Y.origin) != null ? _a3 : "v\xE4rdet"} att ha ${z6}${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "element"}`; + return `F\xF6r stor(t): f\xF6rv\xE4ntat ${(_c = Y.origin) != null ? _c : "v\xE4rdet"} att ha ${z6}${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `F\xF6r lite(t): f\xF6rv\xE4ntade ${(_d = Y.origin) != null ? _d : "v\xE4rdet"} att ha ${z6}${Y.minimum.toString()} ${W.unit}`; + return `F\xF6r lite(t): f\xF6rv\xE4ntade ${(_e = Y.origin) != null ? _e : "v\xE4rdet"} att ha ${z6}${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `Ogiltig str\xE4ng: m\xE5ste b\xF6rja med "${z6.prefix}"`; + if (z6.format === "ends_with") return `Ogiltig str\xE4ng: m\xE5ste sluta med "${z6.suffix}"`; + if (z6.format === "includes") return `Ogiltig str\xE4ng: m\xE5ste inneh\xE5lla "${z6.includes}"`; + if (z6.format === "regex") return `Ogiltig str\xE4ng: m\xE5ste matcha m\xF6nstret "${z6.pattern}"`; + return `Ogiltig(t) ${(_f = Q[z6.format]) != null ? _f : Y.format}`; + } + case "not_multiple_of": + return `Ogiltigt tal: m\xE5ste vara en multipel av ${Y.divisor}`; + case "unrecognized_keys": + return `${Y.keys.length > 1 ? "Ok\xE4nda nycklar" : "Ok\xE4nd nyckel"}: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `Ogiltig nyckel i ${(_g = Y.origin) != null ? _g : "v\xE4rdet"}`; + case "invalid_union": + return "Ogiltig input"; + case "invalid_element": + return `Ogiltigt v\xE4rde i ${(_h = Y.origin) != null ? _h : "v\xE4rdet"}`; + default: + return "Ogiltig input"; + } + }; +}; +function cW() { + return { localeError: dA() }; +} +var rA = () => { + let $ = { string: { unit: "\u0B8E\u0BB4\u0BC1\u0BA4\u0BCD\u0BA4\u0BC1\u0B95\u0BCD\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" }, file: { unit: "\u0BAA\u0BC8\u0B9F\u0BCD\u0B9F\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" }, array: { unit: "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" }, set: { unit: "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "\u0B8E\u0BA3\u0BCD \u0B85\u0BB2\u0BCD\u0BB2\u0BBE\u0BA4\u0BA4\u0BC1" : "\u0B8E\u0BA3\u0BCD"; + case "object": { + if (Array.isArray(Y)) return "\u0B85\u0BA3\u0BBF"; + if (Y === null) return "\u0BB5\u0BC6\u0BB1\u0BC1\u0BAE\u0BC8"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "\u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1", email: "\u0BAE\u0BBF\u0BA9\u0BCD\u0BA9\u0B9E\u0BCD\u0B9A\u0BB2\u0BCD \u0BAE\u0BC1\u0B95\u0BB5\u0BB0\u0BBF", url: "URL", emoji: "emoji", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "ISO \u0BA4\u0BC7\u0BA4\u0BBF \u0BA8\u0BC7\u0BB0\u0BAE\u0BCD", date: "ISO \u0BA4\u0BC7\u0BA4\u0BBF", time: "ISO \u0BA8\u0BC7\u0BB0\u0BAE\u0BCD", duration: "ISO \u0B95\u0BBE\u0BB2 \u0B85\u0BB3\u0BB5\u0BC1", ipv4: "IPv4 \u0BAE\u0BC1\u0B95\u0BB5\u0BB0\u0BBF", ipv6: "IPv6 \u0BAE\u0BC1\u0B95\u0BB5\u0BB0\u0BBF", cidrv4: "IPv4 \u0BB5\u0BB0\u0BAE\u0BCD\u0BAA\u0BC1", cidrv6: "IPv6 \u0BB5\u0BB0\u0BAE\u0BCD\u0BAA\u0BC1", base64: "base64-encoded \u0B9A\u0BB0\u0BAE\u0BCD", base64url: "base64url-encoded \u0B9A\u0BB0\u0BAE\u0BCD", json_string: "JSON \u0B9A\u0BB0\u0BAE\u0BCD", e164: "E.164 \u0B8E\u0BA3\u0BCD", jwt: "JWT", template_literal: "input" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${Y.expected}, \u0BAA\u0BC6\u0BB1\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${S(Y.values[0])}`; + return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0BB5\u0BBF\u0BB0\u0BC1\u0BAA\u0BCD\u0BAA\u0BAE\u0BCD: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${M(Y.values, "|")} \u0B87\u0BB2\u0BCD \u0B92\u0BA9\u0BCD\u0BB1\u0BC1`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `\u0BAE\u0BBF\u0B95 \u0BAA\u0BC6\u0BB0\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${(_a3 = Y.origin) != null ? _a3 : "\u0BAE\u0BA4\u0BBF\u0BAA\u0BCD\u0BAA\u0BC1"} ${z6}${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD"} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`; + return `\u0BAE\u0BBF\u0B95 \u0BAA\u0BC6\u0BB0\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${(_c = Y.origin) != null ? _c : "\u0BAE\u0BA4\u0BBF\u0BAA\u0BCD\u0BAA\u0BC1"} ${z6}${Y.maximum.toString()} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `\u0BAE\u0BBF\u0B95\u0B9A\u0BCD \u0B9A\u0BBF\u0BB1\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${Y.origin} ${z6}${Y.minimum.toString()} ${W.unit} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`; + return `\u0BAE\u0BBF\u0B95\u0B9A\u0BCD \u0B9A\u0BBF\u0BB1\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${Y.origin} ${z6}${Y.minimum.toString()} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: "${z6.prefix}" \u0B87\u0BB2\u0BCD \u0BA4\u0BCA\u0B9F\u0B99\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`; + if (z6.format === "ends_with") return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: "${z6.suffix}" \u0B87\u0BB2\u0BCD \u0BAE\u0BC1\u0B9F\u0BBF\u0BB5\u0B9F\u0BC8\u0BAF \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`; + if (z6.format === "includes") return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: "${z6.includes}" \u0B90 \u0B89\u0BB3\u0BCD\u0BB3\u0B9F\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`; + if (z6.format === "regex") return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: ${z6.pattern} \u0BAE\u0BC1\u0BB1\u0BC8\u0BAA\u0BBE\u0B9F\u0BCD\u0B9F\u0BC1\u0B9F\u0BA9\u0BCD \u0BAA\u0BCA\u0BB0\u0BC1\u0BA8\u0BCD\u0BA4 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`; + return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 ${(_d = Q[z6.format]) != null ? _d : Y.format}`; + } + case "not_multiple_of": + return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B8E\u0BA3\u0BCD: ${Y.divisor} \u0B87\u0BA9\u0BCD \u0BAA\u0BB2\u0BAE\u0BBE\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`; + case "unrecognized_keys": + return `\u0B85\u0B9F\u0BC8\u0BAF\u0BBE\u0BB3\u0BAE\u0BCD \u0BA4\u0BC6\u0BB0\u0BBF\u0BAF\u0BBE\u0BA4 \u0BB5\u0BBF\u0B9A\u0BC8${Y.keys.length > 1 ? "\u0B95\u0BB3\u0BCD" : ""}: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `${Y.origin} \u0B87\u0BB2\u0BCD \u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0BB5\u0BBF\u0B9A\u0BC8`; + case "invalid_union": + return "\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1"; + case "invalid_element": + return `${Y.origin} \u0B87\u0BB2\u0BCD \u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0BAE\u0BA4\u0BBF\u0BAA\u0BCD\u0BAA\u0BC1`; + default: + return "\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1"; + } + }; +}; +function pW() { + return { localeError: rA() }; +} +var oA = () => { + let $ = { string: { unit: "\u0E15\u0E31\u0E27\u0E2D\u0E31\u0E01\u0E29\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" }, file: { unit: "\u0E44\u0E1A\u0E15\u0E4C", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" }, array: { unit: "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" }, set: { unit: "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "\u0E44\u0E21\u0E48\u0E43\u0E0A\u0E48\u0E15\u0E31\u0E27\u0E40\u0E25\u0E02 (NaN)" : "\u0E15\u0E31\u0E27\u0E40\u0E25\u0E02"; + case "object": { + if (Array.isArray(Y)) return "\u0E2D\u0E32\u0E23\u0E4C\u0E40\u0E23\u0E22\u0E4C (Array)"; + if (Y === null) return "\u0E44\u0E21\u0E48\u0E21\u0E35\u0E04\u0E48\u0E32 (null)"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E17\u0E35\u0E48\u0E1B\u0E49\u0E2D\u0E19", email: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48\u0E2D\u0E35\u0E40\u0E21\u0E25", url: "URL", emoji: "\u0E2D\u0E34\u0E42\u0E21\u0E08\u0E34", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "\u0E27\u0E31\u0E19\u0E17\u0E35\u0E48\u0E40\u0E27\u0E25\u0E32\u0E41\u0E1A\u0E1A ISO", date: "\u0E27\u0E31\u0E19\u0E17\u0E35\u0E48\u0E41\u0E1A\u0E1A ISO", time: "\u0E40\u0E27\u0E25\u0E32\u0E41\u0E1A\u0E1A ISO", duration: "\u0E0A\u0E48\u0E27\u0E07\u0E40\u0E27\u0E25\u0E32\u0E41\u0E1A\u0E1A ISO", ipv4: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48 IPv4", ipv6: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48 IPv6", cidrv4: "\u0E0A\u0E48\u0E27\u0E07 IP \u0E41\u0E1A\u0E1A IPv4", cidrv6: "\u0E0A\u0E48\u0E27\u0E07 IP \u0E41\u0E1A\u0E1A IPv6", base64: "\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E41\u0E1A\u0E1A Base64", base64url: "\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E41\u0E1A\u0E1A Base64 \u0E2A\u0E33\u0E2B\u0E23\u0E31\u0E1A URL", json_string: "\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E41\u0E1A\u0E1A JSON", e164: "\u0E40\u0E1A\u0E2D\u0E23\u0E4C\u0E42\u0E17\u0E23\u0E28\u0E31\u0E1E\u0E17\u0E4C\u0E23\u0E30\u0E2B\u0E27\u0E48\u0E32\u0E07\u0E1B\u0E23\u0E30\u0E40\u0E17\u0E28 (E.164)", jwt: "\u0E42\u0E17\u0E40\u0E04\u0E19 JWT", template_literal: "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E17\u0E35\u0E48\u0E1B\u0E49\u0E2D\u0E19" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `\u0E1B\u0E23\u0E30\u0E40\u0E20\u0E17\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 ${Y.expected} \u0E41\u0E15\u0E48\u0E44\u0E14\u0E49\u0E23\u0E31\u0E1A ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `\u0E04\u0E48\u0E32\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 ${S(Y.values[0])}`; + return `\u0E15\u0E31\u0E27\u0E40\u0E25\u0E37\u0E2D\u0E01\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19\u0E2B\u0E19\u0E36\u0E48\u0E07\u0E43\u0E19 ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "\u0E44\u0E21\u0E48\u0E40\u0E01\u0E34\u0E19" : "\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32", W = X(Y.origin); + if (W) return `\u0E40\u0E01\u0E34\u0E19\u0E01\u0E33\u0E2B\u0E19\u0E14: ${(_a3 = Y.origin) != null ? _a3 : "\u0E04\u0E48\u0E32"} \u0E04\u0E27\u0E23\u0E21\u0E35${z6} ${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23"}`; + return `\u0E40\u0E01\u0E34\u0E19\u0E01\u0E33\u0E2B\u0E19\u0E14: ${(_c = Y.origin) != null ? _c : "\u0E04\u0E48\u0E32"} \u0E04\u0E27\u0E23\u0E21\u0E35${z6} ${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? "\u0E2D\u0E22\u0E48\u0E32\u0E07\u0E19\u0E49\u0E2D\u0E22" : "\u0E21\u0E32\u0E01\u0E01\u0E27\u0E48\u0E32", W = X(Y.origin); + if (W) return `\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32\u0E01\u0E33\u0E2B\u0E19\u0E14: ${Y.origin} \u0E04\u0E27\u0E23\u0E21\u0E35${z6} ${Y.minimum.toString()} ${W.unit}`; + return `\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32\u0E01\u0E33\u0E2B\u0E19\u0E14: ${Y.origin} \u0E04\u0E27\u0E23\u0E21\u0E35${z6} ${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E15\u0E49\u0E2D\u0E07\u0E02\u0E36\u0E49\u0E19\u0E15\u0E49\u0E19\u0E14\u0E49\u0E27\u0E22 "${z6.prefix}"`; + if (z6.format === "ends_with") return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E15\u0E49\u0E2D\u0E07\u0E25\u0E07\u0E17\u0E49\u0E32\u0E22\u0E14\u0E49\u0E27\u0E22 "${z6.suffix}"`; + if (z6.format === "includes") return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E15\u0E49\u0E2D\u0E07\u0E21\u0E35 "${z6.includes}" \u0E2D\u0E22\u0E39\u0E48\u0E43\u0E19\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21`; + if (z6.format === "regex") return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E15\u0E49\u0E2D\u0E07\u0E15\u0E23\u0E07\u0E01\u0E31\u0E1A\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E17\u0E35\u0E48\u0E01\u0E33\u0E2B\u0E19\u0E14 ${z6.pattern}`; + return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: ${(_d = Q[z6.format]) != null ? _d : Y.format}`; + } + case "not_multiple_of": + return `\u0E15\u0E31\u0E27\u0E40\u0E25\u0E02\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E15\u0E49\u0E2D\u0E07\u0E40\u0E1B\u0E47\u0E19\u0E08\u0E33\u0E19\u0E27\u0E19\u0E17\u0E35\u0E48\u0E2B\u0E32\u0E23\u0E14\u0E49\u0E27\u0E22 ${Y.divisor} \u0E44\u0E14\u0E49\u0E25\u0E07\u0E15\u0E31\u0E27`; + case "unrecognized_keys": + return `\u0E1E\u0E1A\u0E04\u0E35\u0E22\u0E4C\u0E17\u0E35\u0E48\u0E44\u0E21\u0E48\u0E23\u0E39\u0E49\u0E08\u0E31\u0E01: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `\u0E04\u0E35\u0E22\u0E4C\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07\u0E43\u0E19 ${Y.origin}`; + case "invalid_union": + return "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E44\u0E21\u0E48\u0E15\u0E23\u0E07\u0E01\u0E31\u0E1A\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E22\u0E39\u0E40\u0E19\u0E35\u0E22\u0E19\u0E17\u0E35\u0E48\u0E01\u0E33\u0E2B\u0E19\u0E14\u0E44\u0E27\u0E49"; + case "invalid_element": + return `\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07\u0E43\u0E19 ${Y.origin}`; + default: + return "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07"; + } + }; +}; +function iW() { + return { localeError: oA() }; +} +var tA = ($) => { + let X = typeof $; + switch (X) { + case "number": + return Number.isNaN($) ? "NaN" : "number"; + case "object": { + if (Array.isArray($)) return "array"; + if ($ === null) return "null"; + if (Object.getPrototypeOf($) !== Object.prototype && $.constructor) return $.constructor.name; + } + } + return X; +}; +var aA = () => { + let $ = { string: { unit: "karakter", verb: "olmal\u0131" }, file: { unit: "bayt", verb: "olmal\u0131" }, array: { unit: "\xF6\u011Fe", verb: "olmal\u0131" }, set: { unit: "\xF6\u011Fe", verb: "olmal\u0131" } }; + function X(Q) { + var _a3; + return (_a3 = $[Q]) != null ? _a3 : null; + } + let J = { regex: "girdi", email: "e-posta adresi", url: "URL", emoji: "emoji", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "ISO tarih ve saat", date: "ISO tarih", time: "ISO saat", duration: "ISO s\xFCre", ipv4: "IPv4 adresi", ipv6: "IPv6 adresi", cidrv4: "IPv4 aral\u0131\u011F\u0131", cidrv6: "IPv6 aral\u0131\u011F\u0131", base64: "base64 ile \u015Fifrelenmi\u015F metin", base64url: "base64url ile \u015Fifrelenmi\u015F metin", json_string: "JSON dizesi", e164: "E.164 say\u0131s\u0131", jwt: "JWT", template_literal: "\u015Eablon dizesi" }; + return (Q) => { + var _a3, _b2, _c, _d; + switch (Q.code) { + case "invalid_type": + return `Ge\xE7ersiz de\u011Fer: beklenen ${Q.expected}, al\u0131nan ${tA(Q.input)}`; + case "invalid_value": + if (Q.values.length === 1) return `Ge\xE7ersiz de\u011Fer: beklenen ${S(Q.values[0])}`; + return `Ge\xE7ersiz se\xE7enek: a\u015Fa\u011F\u0131dakilerden biri olmal\u0131: ${M(Q.values, "|")}`; + case "too_big": { + let Y = Q.inclusive ? "<=" : "<", z6 = X(Q.origin); + if (z6) return `\xC7ok b\xFCy\xFCk: beklenen ${(_a3 = Q.origin) != null ? _a3 : "de\u011Fer"} ${Y}${Q.maximum.toString()} ${(_b2 = z6.unit) != null ? _b2 : "\xF6\u011Fe"}`; + return `\xC7ok b\xFCy\xFCk: beklenen ${(_c = Q.origin) != null ? _c : "de\u011Fer"} ${Y}${Q.maximum.toString()}`; + } + case "too_small": { + let Y = Q.inclusive ? ">=" : ">", z6 = X(Q.origin); + if (z6) return `\xC7ok k\xFC\xE7\xFCk: beklenen ${Q.origin} ${Y}${Q.minimum.toString()} ${z6.unit}`; + return `\xC7ok k\xFC\xE7\xFCk: beklenen ${Q.origin} ${Y}${Q.minimum.toString()}`; + } + case "invalid_format": { + let Y = Q; + if (Y.format === "starts_with") return `Ge\xE7ersiz metin: "${Y.prefix}" ile ba\u015Flamal\u0131`; + if (Y.format === "ends_with") return `Ge\xE7ersiz metin: "${Y.suffix}" ile bitmeli`; + if (Y.format === "includes") return `Ge\xE7ersiz metin: "${Y.includes}" i\xE7ermeli`; + if (Y.format === "regex") return `Ge\xE7ersiz metin: ${Y.pattern} desenine uymal\u0131`; + return `Ge\xE7ersiz ${(_d = J[Y.format]) != null ? _d : Q.format}`; + } + case "not_multiple_of": + return `Ge\xE7ersiz say\u0131: ${Q.divisor} ile tam b\xF6l\xFCnebilmeli`; + case "unrecognized_keys": + return `Tan\u0131nmayan anahtar${Q.keys.length > 1 ? "lar" : ""}: ${M(Q.keys, ", ")}`; + case "invalid_key": + return `${Q.origin} i\xE7inde ge\xE7ersiz anahtar`; + case "invalid_union": + return "Ge\xE7ersiz de\u011Fer"; + case "invalid_element": + return `${Q.origin} i\xE7inde ge\xE7ersiz de\u011Fer`; + default: + return "Ge\xE7ersiz de\u011Fer"; + } + }; +}; +function nW() { + return { localeError: aA() }; +} +var sA = () => { + let $ = { string: { unit: "\u0441\u0438\u043C\u0432\u043E\u043B\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" }, file: { unit: "\u0431\u0430\u0439\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" }, array: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" }, set: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "\u0447\u0438\u0441\u043B\u043E"; + case "object": { + if (Array.isArray(Y)) return "\u043C\u0430\u0441\u0438\u0432"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "\u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456", email: "\u0430\u0434\u0440\u0435\u0441\u0430 \u0435\u043B\u0435\u043A\u0442\u0440\u043E\u043D\u043D\u043E\u0457 \u043F\u043E\u0448\u0442\u0438", url: "URL", emoji: "\u0435\u043C\u043E\u0434\u0437\u0456", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "\u0434\u0430\u0442\u0430 \u0442\u0430 \u0447\u0430\u0441 ISO", date: "\u0434\u0430\u0442\u0430 ISO", time: "\u0447\u0430\u0441 ISO", duration: "\u0442\u0440\u0438\u0432\u0430\u043B\u0456\u0441\u0442\u044C ISO", ipv4: "\u0430\u0434\u0440\u0435\u0441\u0430 IPv4", ipv6: "\u0430\u0434\u0440\u0435\u0441\u0430 IPv6", cidrv4: "\u0434\u0456\u0430\u043F\u0430\u0437\u043E\u043D IPv4", cidrv6: "\u0434\u0456\u0430\u043F\u0430\u0437\u043E\u043D IPv6", base64: "\u0440\u044F\u0434\u043E\u043A \u0443 \u043A\u043E\u0434\u0443\u0432\u0430\u043D\u043D\u0456 base64", base64url: "\u0440\u044F\u0434\u043E\u043A \u0443 \u043A\u043E\u0434\u0443\u0432\u0430\u043D\u043D\u0456 base64url", json_string: "\u0440\u044F\u0434\u043E\u043A JSON", e164: "\u043D\u043E\u043C\u0435\u0440 E.164", jwt: "JWT", template_literal: "\u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F ${Y.expected}, \u043E\u0442\u0440\u0438\u043C\u0430\u043D\u043E ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F ${S(Y.values[0])}`; + return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0430 \u043E\u043F\u0446\u0456\u044F: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F \u043E\u0434\u043D\u0435 \u0437 ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u0432\u0435\u043B\u0438\u043A\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${(_a3 = Y.origin) != null ? _a3 : "\u0437\u043D\u0430\u0447\u0435\u043D\u043D\u044F"} ${W.verb} ${z6}${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432"}`; + return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u0432\u0435\u043B\u0438\u043A\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${(_c = Y.origin) != null ? _c : "\u0437\u043D\u0430\u0447\u0435\u043D\u043D\u044F"} \u0431\u0443\u0434\u0435 ${z6}${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u043C\u0430\u043B\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${Y.origin} ${W.verb} ${z6}${Y.minimum.toString()} ${W.unit}`; + return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u043C\u0430\u043B\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${Y.origin} \u0431\u0443\u0434\u0435 ${z6}${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u043F\u043E\u0447\u0438\u043D\u0430\u0442\u0438\u0441\u044F \u0437 "${z6.prefix}"`; + if (z6.format === "ends_with") return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u0437\u0430\u043A\u0456\u043D\u0447\u0443\u0432\u0430\u0442\u0438\u0441\u044F \u043D\u0430 "${z6.suffix}"`; + if (z6.format === "includes") return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u043C\u0456\u0441\u0442\u0438\u0442\u0438 "${z6.includes}"`; + if (z6.format === "regex") return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u0432\u0456\u0434\u043F\u043E\u0432\u0456\u0434\u0430\u0442\u0438 \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${z6.pattern}`; + return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 ${(_d = Q[z6.format]) != null ? _d : Y.format}`; + } + case "not_multiple_of": + return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0435 \u0447\u0438\u0441\u043B\u043E: \u043F\u043E\u0432\u0438\u043D\u043D\u043E \u0431\u0443\u0442\u0438 \u043A\u0440\u0430\u0442\u043D\u0438\u043C ${Y.divisor}`; + case "unrecognized_keys": + return `\u041D\u0435\u0440\u043E\u0437\u043F\u0456\u0437\u043D\u0430\u043D\u0438\u0439 \u043A\u043B\u044E\u0447${Y.keys.length > 1 ? "\u0456" : ""}: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u043A\u043B\u044E\u0447 \u0443 ${Y.origin}`; + case "invalid_union": + return "\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456"; + case "invalid_element": + return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u043D\u044F \u0443 ${Y.origin}`; + default: + return "\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456"; + } + }; +}; +function dW() { + return { localeError: sA() }; +} +var eA = () => { + let $ = { string: { unit: "\u062D\u0631\u0648\u0641", verb: "\u06C1\u0648\u0646\u0627" }, file: { unit: "\u0628\u0627\u0626\u0679\u0633", verb: "\u06C1\u0648\u0646\u0627" }, array: { unit: "\u0622\u0626\u0679\u0645\u0632", verb: "\u06C1\u0648\u0646\u0627" }, set: { unit: "\u0622\u0626\u0679\u0645\u0632", verb: "\u06C1\u0648\u0646\u0627" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "\u0646\u0645\u0628\u0631"; + case "object": { + if (Array.isArray(Y)) return "\u0622\u0631\u06D2"; + if (Y === null) return "\u0646\u0644"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "\u0627\u0646 \u067E\u0679", email: "\u0627\u06CC \u0645\u06CC\u0644 \u0627\u06CC\u0688\u0631\u06CC\u0633", url: "\u06CC\u0648 \u0622\u0631 \u0627\u06CC\u0644", emoji: "\u0627\u06CC\u0645\u0648\u062C\u06CC", uuid: "\u06CC\u0648 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC", uuidv4: "\u06CC\u0648 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC \u0648\u06CC 4", uuidv6: "\u06CC\u0648 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC \u0648\u06CC 6", nanoid: "\u0646\u06CC\u0646\u0648 \u0622\u0626\u06CC \u0688\u06CC", guid: "\u062C\u06CC \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC", cuid: "\u0633\u06CC \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC", cuid2: "\u0633\u06CC \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC 2", ulid: "\u06CC\u0648 \u0627\u06CC\u0644 \u0622\u0626\u06CC \u0688\u06CC", xid: "\u0627\u06CC\u06A9\u0633 \u0622\u0626\u06CC \u0688\u06CC", ksuid: "\u06A9\u06D2 \u0627\u06CC\u0633 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC", datetime: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u0688\u06CC\u0679 \u0679\u0627\u0626\u0645", date: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u062A\u0627\u0631\u06CC\u062E", time: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u0648\u0642\u062A", duration: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u0645\u062F\u062A", ipv4: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 4 \u0627\u06CC\u0688\u0631\u06CC\u0633", ipv6: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 6 \u0627\u06CC\u0688\u0631\u06CC\u0633", cidrv4: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 4 \u0631\u06CC\u0646\u062C", cidrv6: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 6 \u0631\u06CC\u0646\u062C", base64: "\u0628\u06CC\u0633 64 \u0627\u0646 \u06A9\u0648\u0688\u0688 \u0633\u0679\u0631\u0646\u06AF", base64url: "\u0628\u06CC\u0633 64 \u06CC\u0648 \u0622\u0631 \u0627\u06CC\u0644 \u0627\u0646 \u06A9\u0648\u0688\u0688 \u0633\u0679\u0631\u0646\u06AF", json_string: "\u062C\u06D2 \u0627\u06CC\u0633 \u0627\u0648 \u0627\u06CC\u0646 \u0633\u0679\u0631\u0646\u06AF", e164: "\u0627\u06CC 164 \u0646\u0645\u0628\u0631", jwt: "\u062C\u06D2 \u0688\u0628\u0644\u06CC\u0648 \u0679\u06CC", template_literal: "\u0627\u0646 \u067E\u0679" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: ${Y.expected} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627\u060C ${J(Y.input)} \u0645\u0648\u0635\u0648\u0644 \u06C1\u0648\u0627`; + case "invalid_value": + if (Y.values.length === 1) return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: ${S(Y.values[0])} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`; + return `\u063A\u0644\u0637 \u0622\u067E\u0634\u0646: ${M(Y.values, "|")} \u0645\u06CC\u06BA \u0633\u06D2 \u0627\u06CC\u06A9 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `\u0628\u06C1\u062A \u0628\u0691\u0627: ${(_a3 = Y.origin) != null ? _a3 : "\u0648\u06CC\u0644\u06CC\u0648"} \u06A9\u06D2 ${z6}${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "\u0639\u0646\u0627\u0635\u0631"} \u06C1\u0648\u0646\u06D2 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u06D2`; + return `\u0628\u06C1\u062A \u0628\u0691\u0627: ${(_c = Y.origin) != null ? _c : "\u0648\u06CC\u0644\u06CC\u0648"} \u06A9\u0627 ${z6}${Y.maximum.toString()} \u06C1\u0648\u0646\u0627 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `\u0628\u06C1\u062A \u0686\u06BE\u0648\u0679\u0627: ${Y.origin} \u06A9\u06D2 ${z6}${Y.minimum.toString()} ${W.unit} \u06C1\u0648\u0646\u06D2 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u06D2`; + return `\u0628\u06C1\u062A \u0686\u06BE\u0648\u0679\u0627: ${Y.origin} \u06A9\u0627 ${z6}${Y.minimum.toString()} \u06C1\u0648\u0646\u0627 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: "${z6.prefix}" \u0633\u06D2 \u0634\u0631\u0648\u0639 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`; + if (z6.format === "ends_with") return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: "${z6.suffix}" \u067E\u0631 \u062E\u062A\u0645 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`; + if (z6.format === "includes") return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: "${z6.includes}" \u0634\u0627\u0645\u0644 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`; + if (z6.format === "regex") return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: \u067E\u06CC\u0679\u0631\u0646 ${z6.pattern} \u0633\u06D2 \u0645\u06CC\u0686 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`; + return `\u063A\u0644\u0637 ${(_d = Q[z6.format]) != null ? _d : Y.format}`; + } + case "not_multiple_of": + return `\u063A\u0644\u0637 \u0646\u0645\u0628\u0631: ${Y.divisor} \u06A9\u0627 \u0645\u0636\u0627\u0639\u0641 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`; + case "unrecognized_keys": + return `\u063A\u06CC\u0631 \u062A\u0633\u0644\u06CC\u0645 \u0634\u062F\u06C1 \u06A9\u06CC${Y.keys.length > 1 ? "\u0632" : ""}: ${M(Y.keys, "\u060C ")}`; + case "invalid_key": + return `${Y.origin} \u0645\u06CC\u06BA \u063A\u0644\u0637 \u06A9\u06CC`; + case "invalid_union": + return "\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679"; + case "invalid_element": + return `${Y.origin} \u0645\u06CC\u06BA \u063A\u0644\u0637 \u0648\u06CC\u0644\u06CC\u0648`; + default: + return "\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679"; + } + }; +}; +function rW() { + return { localeError: eA() }; +} +var $2 = () => { + let $ = { string: { unit: "k\xFD t\u1EF1", verb: "c\xF3" }, file: { unit: "byte", verb: "c\xF3" }, array: { unit: "ph\u1EA7n t\u1EED", verb: "c\xF3" }, set: { unit: "ph\u1EA7n t\u1EED", verb: "c\xF3" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "s\u1ED1"; + case "object": { + if (Array.isArray(Y)) return "m\u1EA3ng"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "\u0111\u1EA7u v\xE0o", email: "\u0111\u1ECBa ch\u1EC9 email", url: "URL", emoji: "emoji", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "ng\xE0y gi\u1EDD ISO", date: "ng\xE0y ISO", time: "gi\u1EDD ISO", duration: "kho\u1EA3ng th\u1EDDi gian ISO", ipv4: "\u0111\u1ECBa ch\u1EC9 IPv4", ipv6: "\u0111\u1ECBa ch\u1EC9 IPv6", cidrv4: "d\u1EA3i IPv4", cidrv6: "d\u1EA3i IPv6", base64: "chu\u1ED7i m\xE3 h\xF3a base64", base64url: "chu\u1ED7i m\xE3 h\xF3a base64url", json_string: "chu\u1ED7i JSON", e164: "s\u1ED1 E.164", jwt: "JWT", template_literal: "\u0111\u1EA7u v\xE0o" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i ${Y.expected}, nh\u1EADn \u0111\u01B0\u1EE3c ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i ${S(Y.values[0])}`; + return `T\xF9y ch\u1ECDn kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i m\u1ED9t trong c\xE1c gi\xE1 tr\u1ECB ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `Qu\xE1 l\u1EDBn: mong \u0111\u1EE3i ${(_a3 = Y.origin) != null ? _a3 : "gi\xE1 tr\u1ECB"} ${W.verb} ${z6}${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "ph\u1EA7n t\u1EED"}`; + return `Qu\xE1 l\u1EDBn: mong \u0111\u1EE3i ${(_c = Y.origin) != null ? _c : "gi\xE1 tr\u1ECB"} ${z6}${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `Qu\xE1 nh\u1ECF: mong \u0111\u1EE3i ${Y.origin} ${W.verb} ${z6}${Y.minimum.toString()} ${W.unit}`; + return `Qu\xE1 nh\u1ECF: mong \u0111\u1EE3i ${Y.origin} ${z6}${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i b\u1EAFt \u0111\u1EA7u b\u1EB1ng "${z6.prefix}"`; + if (z6.format === "ends_with") return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i k\u1EBFt th\xFAc b\u1EB1ng "${z6.suffix}"`; + if (z6.format === "includes") return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i bao g\u1ED3m "${z6.includes}"`; + if (z6.format === "regex") return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i kh\u1EDBp v\u1EDBi m\u1EABu ${z6.pattern}`; + return `${(_d = Q[z6.format]) != null ? _d : Y.format} kh\xF4ng h\u1EE3p l\u1EC7`; + } + case "not_multiple_of": + return `S\u1ED1 kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i l\xE0 b\u1ED9i s\u1ED1 c\u1EE7a ${Y.divisor}`; + case "unrecognized_keys": + return `Kh\xF3a kh\xF4ng \u0111\u01B0\u1EE3c nh\u1EADn d\u1EA1ng: ${M(Y.keys, ", ")}`; + case "invalid_key": + return `Kh\xF3a kh\xF4ng h\u1EE3p l\u1EC7 trong ${Y.origin}`; + case "invalid_union": + return "\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7"; + case "invalid_element": + return `Gi\xE1 tr\u1ECB kh\xF4ng h\u1EE3p l\u1EC7 trong ${Y.origin}`; + default: + return "\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7"; + } + }; +}; +function oW() { + return { localeError: $2() }; +} +var X2 = () => { + let $ = { string: { unit: "\u5B57\u7B26", verb: "\u5305\u542B" }, file: { unit: "\u5B57\u8282", verb: "\u5305\u542B" }, array: { unit: "\u9879", verb: "\u5305\u542B" }, set: { unit: "\u9879", verb: "\u5305\u542B" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "\u975E\u6570\u5B57(NaN)" : "\u6570\u5B57"; + case "object": { + if (Array.isArray(Y)) return "\u6570\u7EC4"; + if (Y === null) return "\u7A7A\u503C(null)"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "\u8F93\u5165", email: "\u7535\u5B50\u90AE\u4EF6", url: "URL", emoji: "\u8868\u60C5\u7B26\u53F7", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "ISO\u65E5\u671F\u65F6\u95F4", date: "ISO\u65E5\u671F", time: "ISO\u65F6\u95F4", duration: "ISO\u65F6\u957F", ipv4: "IPv4\u5730\u5740", ipv6: "IPv6\u5730\u5740", cidrv4: "IPv4\u7F51\u6BB5", cidrv6: "IPv6\u7F51\u6BB5", base64: "base64\u7F16\u7801\u5B57\u7B26\u4E32", base64url: "base64url\u7F16\u7801\u5B57\u7B26\u4E32", json_string: "JSON\u5B57\u7B26\u4E32", e164: "E.164\u53F7\u7801", jwt: "JWT", template_literal: "\u8F93\u5165" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B ${Y.expected}\uFF0C\u5B9E\u9645\u63A5\u6536 ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B ${S(Y.values[0])}`; + return `\u65E0\u6548\u9009\u9879\uFF1A\u671F\u671B\u4EE5\u4E0B\u4E4B\u4E00 ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `\u6570\u503C\u8FC7\u5927\uFF1A\u671F\u671B ${(_a3 = Y.origin) != null ? _a3 : "\u503C"} ${z6}${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "\u4E2A\u5143\u7D20"}`; + return `\u6570\u503C\u8FC7\u5927\uFF1A\u671F\u671B ${(_c = Y.origin) != null ? _c : "\u503C"} ${z6}${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `\u6570\u503C\u8FC7\u5C0F\uFF1A\u671F\u671B ${Y.origin} ${z6}${Y.minimum.toString()} ${W.unit}`; + return `\u6570\u503C\u8FC7\u5C0F\uFF1A\u671F\u671B ${Y.origin} ${z6}${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u4EE5 "${z6.prefix}" \u5F00\u5934`; + if (z6.format === "ends_with") return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u4EE5 "${z6.suffix}" \u7ED3\u5C3E`; + if (z6.format === "includes") return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u5305\u542B "${z6.includes}"`; + if (z6.format === "regex") return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u6EE1\u8DB3\u6B63\u5219\u8868\u8FBE\u5F0F ${z6.pattern}`; + return `\u65E0\u6548${(_d = Q[z6.format]) != null ? _d : Y.format}`; + } + case "not_multiple_of": + return `\u65E0\u6548\u6570\u5B57\uFF1A\u5FC5\u987B\u662F ${Y.divisor} \u7684\u500D\u6570`; + case "unrecognized_keys": + return `\u51FA\u73B0\u672A\u77E5\u7684\u952E(key): ${M(Y.keys, ", ")}`; + case "invalid_key": + return `${Y.origin} \u4E2D\u7684\u952E(key)\u65E0\u6548`; + case "invalid_union": + return "\u65E0\u6548\u8F93\u5165"; + case "invalid_element": + return `${Y.origin} \u4E2D\u5305\u542B\u65E0\u6548\u503C(value)`; + default: + return "\u65E0\u6548\u8F93\u5165"; + } + }; +}; +function tW() { + return { localeError: X2() }; +} +var J2 = () => { + let $ = { string: { unit: "\u5B57\u5143", verb: "\u64C1\u6709" }, file: { unit: "\u4F4D\u5143\u7D44", verb: "\u64C1\u6709" }, array: { unit: "\u9805\u76EE", verb: "\u64C1\u6709" }, set: { unit: "\u9805\u76EE", verb: "\u64C1\u6709" } }; + function X(Y) { + var _a3; + return (_a3 = $[Y]) != null ? _a3 : null; + } + let J = (Y) => { + let z6 = typeof Y; + switch (z6) { + case "number": + return Number.isNaN(Y) ? "NaN" : "number"; + case "object": { + if (Array.isArray(Y)) return "array"; + if (Y === null) return "null"; + if (Object.getPrototypeOf(Y) !== Object.prototype && Y.constructor) return Y.constructor.name; + } + } + return z6; + }, Q = { regex: "\u8F38\u5165", email: "\u90F5\u4EF6\u5730\u5740", url: "URL", emoji: "emoji", uuid: "UUID", uuidv4: "UUIDv4", uuidv6: "UUIDv6", nanoid: "nanoid", guid: "GUID", cuid: "cuid", cuid2: "cuid2", ulid: "ULID", xid: "XID", ksuid: "KSUID", datetime: "ISO \u65E5\u671F\u6642\u9593", date: "ISO \u65E5\u671F", time: "ISO \u6642\u9593", duration: "ISO \u671F\u9593", ipv4: "IPv4 \u4F4D\u5740", ipv6: "IPv6 \u4F4D\u5740", cidrv4: "IPv4 \u7BC4\u570D", cidrv6: "IPv6 \u7BC4\u570D", base64: "base64 \u7DE8\u78BC\u5B57\u4E32", base64url: "base64url \u7DE8\u78BC\u5B57\u4E32", json_string: "JSON \u5B57\u4E32", e164: "E.164 \u6578\u503C", jwt: "JWT", template_literal: "\u8F38\u5165" }; + return (Y) => { + var _a3, _b2, _c, _d; + switch (Y.code) { + case "invalid_type": + return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA ${Y.expected}\uFF0C\u4F46\u6536\u5230 ${J(Y.input)}`; + case "invalid_value": + if (Y.values.length === 1) return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA ${S(Y.values[0])}`; + return `\u7121\u6548\u7684\u9078\u9805\uFF1A\u9810\u671F\u70BA\u4EE5\u4E0B\u5176\u4E2D\u4E4B\u4E00 ${M(Y.values, "|")}`; + case "too_big": { + let z6 = Y.inclusive ? "<=" : "<", W = X(Y.origin); + if (W) return `\u6578\u503C\u904E\u5927\uFF1A\u9810\u671F ${(_a3 = Y.origin) != null ? _a3 : "\u503C"} \u61C9\u70BA ${z6}${Y.maximum.toString()} ${(_b2 = W.unit) != null ? _b2 : "\u500B\u5143\u7D20"}`; + return `\u6578\u503C\u904E\u5927\uFF1A\u9810\u671F ${(_c = Y.origin) != null ? _c : "\u503C"} \u61C9\u70BA ${z6}${Y.maximum.toString()}`; + } + case "too_small": { + let z6 = Y.inclusive ? ">=" : ">", W = X(Y.origin); + if (W) return `\u6578\u503C\u904E\u5C0F\uFF1A\u9810\u671F ${Y.origin} \u61C9\u70BA ${z6}${Y.minimum.toString()} ${W.unit}`; + return `\u6578\u503C\u904E\u5C0F\uFF1A\u9810\u671F ${Y.origin} \u61C9\u70BA ${z6}${Y.minimum.toString()}`; + } + case "invalid_format": { + let z6 = Y; + if (z6.format === "starts_with") return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u4EE5 "${z6.prefix}" \u958B\u982D`; + if (z6.format === "ends_with") return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u4EE5 "${z6.suffix}" \u7D50\u5C3E`; + if (z6.format === "includes") return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u5305\u542B "${z6.includes}"`; + if (z6.format === "regex") return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u7B26\u5408\u683C\u5F0F ${z6.pattern}`; + return `\u7121\u6548\u7684 ${(_d = Q[z6.format]) != null ? _d : Y.format}`; + } + case "not_multiple_of": + return `\u7121\u6548\u7684\u6578\u5B57\uFF1A\u5FC5\u9808\u70BA ${Y.divisor} \u7684\u500D\u6578`; + case "unrecognized_keys": + return `\u7121\u6CD5\u8B58\u5225\u7684\u9375\u503C${Y.keys.length > 1 ? "\u5011" : ""}\uFF1A${M(Y.keys, "\u3001")}`; + case "invalid_key": + return `${Y.origin} \u4E2D\u6709\u7121\u6548\u7684\u9375\u503C`; + case "invalid_union": + return "\u7121\u6548\u7684\u8F38\u5165\u503C"; + case "invalid_element": + return `${Y.origin} \u4E2D\u6709\u7121\u6548\u7684\u503C`; + default: + return "\u7121\u6548\u7684\u8F38\u5165\u503C"; + } + }; +}; +function aW() { + return { localeError: J2() }; +} +var eY = /* @__PURE__ */ Symbol("ZodOutput"); +var $7 = /* @__PURE__ */ Symbol("ZodInput"); +var I8 = class { + constructor() { + this._map = /* @__PURE__ */ new WeakMap(), this._idmap = /* @__PURE__ */ new Map(); + } + add($, ...X) { + let J = X[0]; + if (this._map.set($, J), J && typeof J === "object" && "id" in J) { + if (this._idmap.has(J.id)) throw Error(`ID ${J.id} already exists in the registry`); + this._idmap.set(J.id, $); + } + return this; + } + remove($) { + return this._map.delete($), this; + } + get($) { + var _a3; + let X = $._zod.parent; + if (X) { + let J = { ...(_a3 = this.get(X)) != null ? _a3 : {} }; + return delete J.id, { ...J, ...this._map.get($) }; + } + return this._map.get($); + } + has($) { + return this._map.has($); + } +}; +function A8() { + return new I8(); +} +var X6 = A8(); +function X7($, X) { + return new $({ type: "string", ...Z(X) }); +} +function sW($, X) { + return new $({ type: "string", coerce: true, ...Z(X) }); +} +function b8($, X) { + return new $({ type: "string", format: "email", check: "string_format", abort: false, ...Z(X) }); +} +function I0($, X) { + return new $({ type: "string", format: "guid", check: "string_format", abort: false, ...Z(X) }); +} +function P8($, X) { + return new $({ type: "string", format: "uuid", check: "string_format", abort: false, ...Z(X) }); +} +function Z8($, X) { + return new $({ type: "string", format: "uuid", check: "string_format", abort: false, version: "v4", ...Z(X) }); +} +function E8($, X) { + return new $({ type: "string", format: "uuid", check: "string_format", abort: false, version: "v6", ...Z(X) }); +} +function R8($, X) { + return new $({ type: "string", format: "uuid", check: "string_format", abort: false, version: "v7", ...Z(X) }); +} +function S8($, X) { + return new $({ type: "string", format: "url", check: "string_format", abort: false, ...Z(X) }); +} +function v8($, X) { + return new $({ type: "string", format: "emoji", check: "string_format", abort: false, ...Z(X) }); +} +function C8($, X) { + return new $({ type: "string", format: "nanoid", check: "string_format", abort: false, ...Z(X) }); +} +function k8($, X) { + return new $({ type: "string", format: "cuid", check: "string_format", abort: false, ...Z(X) }); +} +function _8($, X) { + return new $({ type: "string", format: "cuid2", check: "string_format", abort: false, ...Z(X) }); +} +function x8($, X) { + return new $({ type: "string", format: "ulid", check: "string_format", abort: false, ...Z(X) }); +} +function T8($, X) { + return new $({ type: "string", format: "xid", check: "string_format", abort: false, ...Z(X) }); +} +function y8($, X) { + return new $({ type: "string", format: "ksuid", check: "string_format", abort: false, ...Z(X) }); +} +function f8($, X) { + return new $({ type: "string", format: "ipv4", check: "string_format", abort: false, ...Z(X) }); +} +function g8($, X) { + return new $({ type: "string", format: "ipv6", check: "string_format", abort: false, ...Z(X) }); +} +function h8($, X) { + return new $({ type: "string", format: "cidrv4", check: "string_format", abort: false, ...Z(X) }); +} +function u8($, X) { + return new $({ type: "string", format: "cidrv6", check: "string_format", abort: false, ...Z(X) }); +} +function m8($, X) { + return new $({ type: "string", format: "base64", check: "string_format", abort: false, ...Z(X) }); +} +function l8($, X) { + return new $({ type: "string", format: "base64url", check: "string_format", abort: false, ...Z(X) }); +} +function c8($, X) { + return new $({ type: "string", format: "e164", check: "string_format", abort: false, ...Z(X) }); +} +function p8($, X) { + return new $({ type: "string", format: "jwt", check: "string_format", abort: false, ...Z(X) }); +} +var J7 = { Any: null, Minute: -1, Second: 0, Millisecond: 3, Microsecond: 6 }; +function eW($, X) { + return new $({ type: "string", format: "datetime", check: "string_format", offset: false, local: false, precision: null, ...Z(X) }); +} +function $G($, X) { + return new $({ type: "string", format: "date", check: "string_format", ...Z(X) }); +} +function XG($, X) { + return new $({ type: "string", format: "time", check: "string_format", precision: null, ...Z(X) }); +} +function JG($, X) { + return new $({ type: "string", format: "duration", check: "string_format", ...Z(X) }); +} +function Y7($, X) { + return new $({ type: "number", checks: [], ...Z(X) }); +} +function YG($, X) { + return new $({ type: "number", coerce: true, checks: [], ...Z(X) }); +} +function Q7($, X) { + return new $({ type: "number", check: "number_format", abort: false, format: "safeint", ...Z(X) }); +} +function z7($, X) { + return new $({ type: "number", check: "number_format", abort: false, format: "float32", ...Z(X) }); +} +function W7($, X) { + return new $({ type: "number", check: "number_format", abort: false, format: "float64", ...Z(X) }); +} +function G7($, X) { + return new $({ type: "number", check: "number_format", abort: false, format: "int32", ...Z(X) }); +} +function U7($, X) { + return new $({ type: "number", check: "number_format", abort: false, format: "uint32", ...Z(X) }); +} +function H7($, X) { + return new $({ type: "boolean", ...Z(X) }); +} +function QG($, X) { + return new $({ type: "boolean", coerce: true, ...Z(X) }); +} +function K7($, X) { + return new $({ type: "bigint", ...Z(X) }); +} +function zG($, X) { + return new $({ type: "bigint", coerce: true, ...Z(X) }); +} +function N7($, X) { + return new $({ type: "bigint", check: "bigint_format", abort: false, format: "int64", ...Z(X) }); +} +function V7($, X) { + return new $({ type: "bigint", check: "bigint_format", abort: false, format: "uint64", ...Z(X) }); +} +function O7($, X) { + return new $({ type: "symbol", ...Z(X) }); +} +function w7($, X) { + return new $({ type: "undefined", ...Z(X) }); +} +function B7($, X) { + return new $({ type: "null", ...Z(X) }); +} +function q7($) { + return new $({ type: "any" }); +} +function A1($) { + return new $({ type: "unknown" }); +} +function D7($, X) { + return new $({ type: "never", ...Z(X) }); +} +function L7($, X) { + return new $({ type: "void", ...Z(X) }); +} +function j7($, X) { + return new $({ type: "date", ...Z(X) }); +} +function WG($, X) { + return new $({ type: "date", coerce: true, ...Z(X) }); +} +function F7($, X) { + return new $({ type: "nan", ...Z(X) }); +} +function K4($, X) { + return new sJ({ check: "less_than", ...Z(X), value: $, inclusive: false }); +} +function I6($, X) { + return new sJ({ check: "less_than", ...Z(X), value: $, inclusive: true }); +} +function N4($, X) { + return new eJ({ check: "greater_than", ...Z(X), value: $, inclusive: false }); +} +function J6($, X) { + return new eJ({ check: "greater_than", ...Z(X), value: $, inclusive: true }); +} +function GG($) { + return N4(0, $); +} +function UG($) { + return K4(0, $); +} +function HG($) { + return I6(0, $); +} +function KG($) { + return J6(0, $); +} +function b1($, X) { + return new c5({ check: "multiple_of", ...Z(X), value: $ }); +} +function A0($, X) { + return new n5({ check: "max_size", ...Z(X), maximum: $ }); +} +function P1($, X) { + return new d5({ check: "min_size", ...Z(X), minimum: $ }); +} +function i8($, X) { + return new r5({ check: "size_equals", ...Z(X), size: $ }); +} +function b0($, X) { + return new o5({ check: "max_length", ...Z(X), maximum: $ }); +} +function f4($, X) { + return new t5({ check: "min_length", ...Z(X), minimum: $ }); +} +function P0($, X) { + return new a5({ check: "length_equals", ...Z(X), length: $ }); +} +function n8($, X) { + return new s5({ check: "string_format", format: "regex", ...Z(X), pattern: $ }); +} +function d8($) { + return new e5({ check: "string_format", format: "lowercase", ...Z($) }); +} +function r8($) { + return new $W({ check: "string_format", format: "uppercase", ...Z($) }); +} +function o8($, X) { + return new XW({ check: "string_format", format: "includes", ...Z(X), includes: $ }); +} +function t8($, X) { + return new JW({ check: "string_format", format: "starts_with", ...Z(X), prefix: $ }); +} +function a8($, X) { + return new YW({ check: "string_format", format: "ends_with", ...Z(X), suffix: $ }); +} +function NG($, X, J) { + return new QW({ check: "property", property: $, schema: X, ...Z(J) }); +} +function s8($, X) { + return new zW({ check: "mime_type", mime: $, ...Z(X) }); +} +function V4($) { + return new WW({ check: "overwrite", tx: $ }); +} +function e8($) { + return V4((X) => X.normalize($)); +} +function $9() { + return V4(($) => $.trim()); +} +function X9() { + return V4(($) => $.toLowerCase()); +} +function J9() { + return V4(($) => $.toUpperCase()); +} +function Y9($, X, J) { + return new $({ type: "array", element: X, ...Z(J) }); +} +function Y2($, X, J) { + return new $({ type: "union", options: X, ...Z(J) }); +} +function Q2($, X, J, Q) { + return new $({ type: "union", options: J, discriminator: X, ...Z(Q) }); +} +function z2($, X, J) { + return new $({ type: "intersection", left: X, right: J }); +} +function VG($, X, J, Q) { + let Y = J instanceof i; + return new $({ type: "tuple", items: X, rest: Y ? J : null, ...Z(Y ? Q : J) }); +} +function W2($, X, J, Q) { + return new $({ type: "record", keyType: X, valueType: J, ...Z(Q) }); +} +function G2($, X, J, Q) { + return new $({ type: "map", keyType: X, valueType: J, ...Z(Q) }); +} +function U2($, X, J) { + return new $({ type: "set", valueType: X, ...Z(J) }); +} +function H2($, X, J) { + let Q = Array.isArray(X) ? Object.fromEntries(X.map((Y) => [Y, Y])) : X; + return new $({ type: "enum", entries: Q, ...Z(J) }); +} +function K2($, X, J) { + return new $({ type: "enum", entries: X, ...Z(J) }); +} +function N2($, X, J) { + return new $({ type: "literal", values: Array.isArray(X) ? X : [X], ...Z(J) }); +} +function M7($, X) { + return new $({ type: "file", ...Z(X) }); +} +function V2($, X) { + return new $({ type: "transform", transform: X }); +} +function O2($, X) { + return new $({ type: "optional", innerType: X }); +} +function w2($, X) { + return new $({ type: "nullable", innerType: X }); +} +function B2($, X, J) { + return new $({ type: "default", innerType: X, get defaultValue() { + return typeof J === "function" ? J() : J; + } }); +} +function q2($, X, J) { + return new $({ type: "nonoptional", innerType: X, ...Z(J) }); +} +function D2($, X) { + return new $({ type: "success", innerType: X }); +} +function L2($, X, J) { + return new $({ type: "catch", innerType: X, catchValue: typeof J === "function" ? J : () => J }); +} +function j2($, X, J) { + return new $({ type: "pipe", in: X, out: J }); +} +function F2($, X) { + return new $({ type: "readonly", innerType: X }); +} +function M2($, X, J) { + return new $({ type: "template_literal", parts: X, ...Z(J) }); +} +function I2($, X) { + return new $({ type: "lazy", getter: X }); +} +function A2($, X) { + return new $({ type: "promise", innerType: X }); +} +function I7($, X, J) { + var _a3; + let Q = Z(J); + return (_a3 = Q.abort) != null ? _a3 : Q.abort = true, new $({ type: "custom", check: "custom", fn: X, ...Q }); +} +function A7($, X, J) { + return new $({ type: "custom", check: "custom", fn: X, ...Z(J) }); +} +function b7($, X) { + var _a3, _b2, _c, _d, _e, _f; + let J = Z(X), Q = (_a3 = J.truthy) != null ? _a3 : ["true", "1", "yes", "on", "y", "enabled"], Y = (_b2 = J.falsy) != null ? _b2 : ["false", "0", "no", "off", "n", "disabled"]; + if (J.case !== "sensitive") Q = Q.map((w) => typeof w === "string" ? w.toLowerCase() : w), Y = Y.map((w) => typeof w === "string" ? w.toLowerCase() : w); + let z6 = new Set(Q), W = new Set(Y), G = (_c = $.Pipe) != null ? _c : F0, U = (_d = $.Boolean) != null ? _d : D0, H = (_e = $.String) != null ? _e : T4, V = new ((_f = $.Transform) != null ? _f : j0)({ type: "transform", transform: (w, B) => { + let L = w; + if (J.case !== "sensitive") L = L.toLowerCase(); + if (z6.has(L)) return true; + else if (W.has(L)) return false; + else return B.issues.push({ code: "invalid_value", expected: "stringbool", values: [...z6, ...W], input: B.value, inst: V }), {}; + }, error: J.error }), O = new G({ type: "pipe", in: new H({ type: "string", error: J.error }), out: V, error: J.error }); + return new G({ type: "pipe", in: O, out: new U({ type: "boolean", error: J.error }), error: J.error }); +} +function P7($, X, J, Q = {}) { + let Y = Z(Q), z6 = { ...Z(Q), check: "string_format", type: "string", format: X, fn: typeof J === "function" ? J : (G) => J.test(G), ...Y }; + if (J instanceof RegExp) z6.pattern = J; + return new $(z6); +} +var OG = class { + constructor($) { + this._def = $, this.def = $; + } + implement($) { + if (typeof $ !== "function") throw Error("implement() must be called with a function"); + let X = (...J) => { + let Q = this._def.input ? j1(this._def.input, J, void 0, { callee: X }) : J; + if (!Array.isArray(Q)) throw Error("Invalid arguments schema: not an array or tuple schema."); + let Y = $(...Q); + return this._def.output ? j1(this._def.output, Y, void 0, { callee: X }) : Y; + }; + return X; + } + implementAsync($) { + if (typeof $ !== "function") throw Error("implement() must be called with a function"); + let X = async (...J) => { + let Q = this._def.input ? await F1(this._def.input, J, void 0, { callee: X }) : J; + if (!Array.isArray(Q)) throw Error("Invalid arguments schema: not an array or tuple schema."); + let Y = await $(...Q); + return this._def.output ? F1(this._def.output, Y, void 0, { callee: X }) : Y; + }; + return X; + } + input(...$) { + let X = this.constructor; + if (Array.isArray($[0])) return new X({ type: "function", input: new y4({ type: "tuple", items: $[0], rest: $[1] }), output: this._def.output }); + return new X({ type: "function", input: $[0], output: this._def.output }); + } + output($) { + return new this.constructor({ type: "function", input: this._def.input, output: $ }); + } +}; +function Z7($) { + var _a3, _b2; + return new OG({ type: "function", input: Array.isArray($ == null ? void 0 : $.input) ? VG(y4, $ == null ? void 0 : $.input) : (_a3 = $ == null ? void 0 : $.input) != null ? _a3 : Y9(L0, A1(I1)), output: (_b2 = $ == null ? void 0 : $.output) != null ? _b2 : A1(I1) }); +} +var E7 = class { + constructor($) { + var _a3, _b2, _c, _d, _e; + this.counter = 0, this.metadataRegistry = (_a3 = $ == null ? void 0 : $.metadata) != null ? _a3 : X6, this.target = (_b2 = $ == null ? void 0 : $.target) != null ? _b2 : "draft-2020-12", this.unrepresentable = (_c = $ == null ? void 0 : $.unrepresentable) != null ? _c : "throw", this.override = (_d = $ == null ? void 0 : $.override) != null ? _d : (() => { + }), this.io = (_e = $ == null ? void 0 : $.io) != null ? _e : "output", this.seen = /* @__PURE__ */ new Map(); + } + process($, X = { path: [], schemaPath: [] }) { + var _a3, _b2, _c, _d, _e; + var J; + let Q = $._zod.def, Y = { guid: "uuid", url: "uri", datetime: "date-time", json_string: "json-string", regex: "" }, z6 = this.seen.get($); + if (z6) { + if (z6.count++, X.schemaPath.includes($)) z6.cycle = X.path; + return z6.schema; + } + let W = { schema: {}, count: 1, cycle: void 0, path: X.path }; + this.seen.set($, W); + let G = (_b2 = (_a3 = $._zod).toJSONSchema) == null ? void 0 : _b2.call(_a3); + if (G) W.schema = G; + else { + let K = { ...X, schemaPath: [...X.schemaPath, $], path: X.path }, V = $._zod.parent; + if (V) W.ref = V, this.process(V, K), this.seen.get(V).isParent = true; + else { + let O = W.schema; + switch (Q.type) { + case "string": { + let N = O; + N.type = "string"; + let { minimum: w, maximum: B, format: L, patterns: j, contentEncoding: I } = $._zod.bag; + if (typeof w === "number") N.minLength = w; + if (typeof B === "number") N.maxLength = B; + if (L) { + if (N.format = (_c = Y[L]) != null ? _c : L, N.format === "") delete N.format; + } + if (I) N.contentEncoding = I; + if (j && j.size > 0) { + let b = [...j]; + if (b.length === 1) N.pattern = b[0].source; + else if (b.length > 1) W.schema.allOf = [...b.map((x) => ({ ...this.target === "draft-7" ? { type: "string" } : {}, pattern: x.source }))]; + } + break; + } + case "number": { + let N = O, { minimum: w, maximum: B, format: L, multipleOf: j, exclusiveMaximum: I, exclusiveMinimum: b } = $._zod.bag; + if (typeof L === "string" && L.includes("int")) N.type = "integer"; + else N.type = "number"; + if (typeof b === "number") N.exclusiveMinimum = b; + if (typeof w === "number") { + if (N.minimum = w, typeof b === "number") if (b >= w) delete N.minimum; + else delete N.exclusiveMinimum; + } + if (typeof I === "number") N.exclusiveMaximum = I; + if (typeof B === "number") { + if (N.maximum = B, typeof I === "number") if (I <= B) delete N.maximum; + else delete N.exclusiveMaximum; + } + if (typeof j === "number") N.multipleOf = j; + break; + } + case "boolean": { + let N = O; + N.type = "boolean"; + break; + } + case "bigint": { + if (this.unrepresentable === "throw") throw Error("BigInt cannot be represented in JSON Schema"); + break; + } + case "symbol": { + if (this.unrepresentable === "throw") throw Error("Symbols cannot be represented in JSON Schema"); + break; + } + case "null": { + O.type = "null"; + break; + } + case "any": + break; + case "unknown": + break; + case "undefined": + case "never": { + O.not = {}; + break; + } + case "void": { + if (this.unrepresentable === "throw") throw Error("Void cannot be represented in JSON Schema"); + break; + } + case "date": { + if (this.unrepresentable === "throw") throw Error("Date cannot be represented in JSON Schema"); + break; + } + case "array": { + let N = O, { minimum: w, maximum: B } = $._zod.bag; + if (typeof w === "number") N.minItems = w; + if (typeof B === "number") N.maxItems = B; + N.type = "array", N.items = this.process(Q.element, { ...K, path: [...K.path, "items"] }); + break; + } + case "object": { + let N = O; + N.type = "object", N.properties = {}; + let w = Q.shape; + for (let j in w) N.properties[j] = this.process(w[j], { ...K, path: [...K.path, "properties", j] }); + let B = new Set(Object.keys(w)), L = new Set([...B].filter((j) => { + let I = Q.shape[j]._zod; + if (this.io === "input") return I.optin === void 0; + else return I.optout === void 0; + })); + if (L.size > 0) N.required = Array.from(L); + if (((_d = Q.catchall) == null ? void 0 : _d._zod.def.type) === "never") N.additionalProperties = false; + else if (!Q.catchall) { + if (this.io === "output") N.additionalProperties = false; + } else if (Q.catchall) N.additionalProperties = this.process(Q.catchall, { ...K, path: [...K.path, "additionalProperties"] }); + break; + } + case "union": { + let N = O; + N.anyOf = Q.options.map((w, B) => this.process(w, { ...K, path: [...K.path, "anyOf", B] })); + break; + } + case "intersection": { + let N = O, w = this.process(Q.left, { ...K, path: [...K.path, "allOf", 0] }), B = this.process(Q.right, { ...K, path: [...K.path, "allOf", 1] }), L = (I) => "allOf" in I && Object.keys(I).length === 1, j = [...L(w) ? w.allOf : [w], ...L(B) ? B.allOf : [B]]; + N.allOf = j; + break; + } + case "tuple": { + let N = O; + N.type = "array"; + let w = Q.items.map((j, I) => this.process(j, { ...K, path: [...K.path, "prefixItems", I] })); + if (this.target === "draft-2020-12") N.prefixItems = w; + else N.items = w; + if (Q.rest) { + let j = this.process(Q.rest, { ...K, path: [...K.path, "items"] }); + if (this.target === "draft-2020-12") N.items = j; + else N.additionalItems = j; + } + if (Q.rest) N.items = this.process(Q.rest, { ...K, path: [...K.path, "items"] }); + let { minimum: B, maximum: L } = $._zod.bag; + if (typeof B === "number") N.minItems = B; + if (typeof L === "number") N.maxItems = L; + break; + } + case "record": { + let N = O; + N.type = "object", N.propertyNames = this.process(Q.keyType, { ...K, path: [...K.path, "propertyNames"] }), N.additionalProperties = this.process(Q.valueType, { ...K, path: [...K.path, "additionalProperties"] }); + break; + } + case "map": { + if (this.unrepresentable === "throw") throw Error("Map cannot be represented in JSON Schema"); + break; + } + case "set": { + if (this.unrepresentable === "throw") throw Error("Set cannot be represented in JSON Schema"); + break; + } + case "enum": { + let N = O, w = K8(Q.entries); + if (w.every((B) => typeof B === "number")) N.type = "number"; + if (w.every((B) => typeof B === "string")) N.type = "string"; + N.enum = w; + break; + } + case "literal": { + let N = O, w = []; + for (let B of Q.values) if (B === void 0) { + if (this.unrepresentable === "throw") throw Error("Literal `undefined` cannot be represented in JSON Schema"); + } else if (typeof B === "bigint") if (this.unrepresentable === "throw") throw Error("BigInt literals cannot be represented in JSON Schema"); + else w.push(Number(B)); + else w.push(B); + if (w.length === 0) ; + else if (w.length === 1) { + let B = w[0]; + N.type = B === null ? "null" : typeof B, N.const = B; + } else { + if (w.every((B) => typeof B === "number")) N.type = "number"; + if (w.every((B) => typeof B === "string")) N.type = "string"; + if (w.every((B) => typeof B === "boolean")) N.type = "string"; + if (w.every((B) => B === null)) N.type = "null"; + N.enum = w; + } + break; + } + case "file": { + let N = O, w = { type: "string", format: "binary", contentEncoding: "binary" }, { minimum: B, maximum: L, mime: j } = $._zod.bag; + if (B !== void 0) w.minLength = B; + if (L !== void 0) w.maxLength = L; + if (j) if (j.length === 1) w.contentMediaType = j[0], Object.assign(N, w); + else N.anyOf = j.map((I) => { + return { ...w, contentMediaType: I }; + }); + else Object.assign(N, w); + break; + } + case "transform": { + if (this.unrepresentable === "throw") throw Error("Transforms cannot be represented in JSON Schema"); + break; + } + case "nullable": { + let N = this.process(Q.innerType, K); + O.anyOf = [N, { type: "null" }]; + break; + } + case "nonoptional": { + this.process(Q.innerType, K), W.ref = Q.innerType; + break; + } + case "success": { + let N = O; + N.type = "boolean"; + break; + } + case "default": { + this.process(Q.innerType, K), W.ref = Q.innerType, O.default = JSON.parse(JSON.stringify(Q.defaultValue)); + break; + } + case "prefault": { + if (this.process(Q.innerType, K), W.ref = Q.innerType, this.io === "input") O._prefault = JSON.parse(JSON.stringify(Q.defaultValue)); + break; + } + case "catch": { + this.process(Q.innerType, K), W.ref = Q.innerType; + let N; + try { + N = Q.catchValue(void 0); + } catch (e3) { + throw Error("Dynamic catch values are not supported in JSON Schema"); + } + O.default = N; + break; + } + case "nan": { + if (this.unrepresentable === "throw") throw Error("NaN cannot be represented in JSON Schema"); + break; + } + case "template_literal": { + let N = O, w = $._zod.pattern; + if (!w) throw Error("Pattern not found in template literal"); + N.type = "string", N.pattern = w.source; + break; + } + case "pipe": { + let N = this.io === "input" ? Q.in._zod.def.type === "transform" ? Q.out : Q.in : Q.out; + this.process(N, K), W.ref = N; + break; + } + case "readonly": { + this.process(Q.innerType, K), W.ref = Q.innerType, O.readOnly = true; + break; + } + case "promise": { + this.process(Q.innerType, K), W.ref = Q.innerType; + break; + } + case "optional": { + this.process(Q.innerType, K), W.ref = Q.innerType; + break; + } + case "lazy": { + let N = $._zod.innerType; + this.process(N, K), W.ref = N; + break; + } + case "custom": { + if (this.unrepresentable === "throw") throw Error("Custom types cannot be represented in JSON Schema"); + break; + } + default: + } + } + } + let U = this.metadataRegistry.get($); + if (U) Object.assign(W.schema, U); + if (this.io === "input" && k$($)) delete W.schema.examples, delete W.schema.default; + if (this.io === "input" && W.schema._prefault) (_e = (J = W.schema).default) != null ? _e : J.default = W.schema._prefault; + return delete W.schema._prefault, this.seen.get($).schema; + } + emit($, X) { + var _a3, _b2, _c, _d, _e, _f, _g, _h; + let J = { cycles: (_a3 = X == null ? void 0 : X.cycles) != null ? _a3 : "ref", reused: (_b2 = X == null ? void 0 : X.reused) != null ? _b2 : "inline", external: (_c = X == null ? void 0 : X.external) != null ? _c : void 0 }, Q = this.seen.get($); + if (!Q) throw Error("Unprocessed schema. This is a bug in Zod."); + let Y = (H) => { + var _a4, _b3, _c2, _d2; + let K = this.target === "draft-2020-12" ? "$defs" : "definitions"; + if (J.external) { + let w = (_a4 = J.external.registry.get(H[0])) == null ? void 0 : _a4.id; + if (w) return { ref: J.external.uri(w) }; + let B = (_c2 = (_b3 = H[1].defId) != null ? _b3 : H[1].schema.id) != null ? _c2 : `schema${this.counter++}`; + return H[1].defId = B, { defId: B, ref: `${J.external.uri("__shared")}#/${K}/${B}` }; + } + if (H[1] === Q) return { ref: "#" }; + let O = `${"#"}/${K}/`, N = (_d2 = H[1].schema.id) != null ? _d2 : `__schema${this.counter++}`; + return { defId: N, ref: O + N }; + }, z6 = (H) => { + if (H[1].schema.$ref) return; + let K = H[1], { ref: V, defId: O } = Y(H); + if (K.def = { ...K.schema }, O) K.defId = O; + let N = K.schema; + for (let w in N) delete N[w]; + N.$ref = V; + }; + for (let H of this.seen.entries()) { + let K = H[1]; + if ($ === H[0]) { + z6(H); + continue; + } + if (J.external) { + let O = (_d = J.external.registry.get(H[0])) == null ? void 0 : _d.id; + if ($ !== H[0] && O) { + z6(H); + continue; + } + } + if ((_e = this.metadataRegistry.get(H[0])) == null ? void 0 : _e.id) { + z6(H); + continue; + } + if (K.cycle) { + if (J.cycles === "throw") throw Error(`Cycle detected: #/${(_f = K.cycle) == null ? void 0 : _f.join("/")}/ + +Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`); + else if (J.cycles === "ref") z6(H); + continue; + } + if (K.count > 1) { + if (J.reused === "ref") { + z6(H); + continue; + } + } + } + let W = (H, K) => { + var _a4, _b3, _c2; + let V = this.seen.get(H), O = (_a4 = V.def) != null ? _a4 : V.schema, N = { ...O }; + if (V.ref === null) return; + let w = V.ref; + if (V.ref = null, w) { + W(w, K); + let B = this.seen.get(w).schema; + if (B.$ref && K.target === "draft-7") O.allOf = (_b3 = O.allOf) != null ? _b3 : [], O.allOf.push(B); + else Object.assign(O, B), Object.assign(O, N); + } + if (!V.isParent) this.override({ zodSchema: H, jsonSchema: O, path: (_c2 = V.path) != null ? _c2 : [] }); + }; + for (let H of [...this.seen.entries()].reverse()) W(H[0], { target: this.target }); + let G = {}; + if (this.target === "draft-2020-12") G.$schema = "https://json-schema.org/draft/2020-12/schema"; + else if (this.target === "draft-7") G.$schema = "http://json-schema.org/draft-07/schema#"; + else console.warn(`Invalid target: ${this.target}`); + Object.assign(G, Q.def); + let U = (_h = (_g = J.external) == null ? void 0 : _g.defs) != null ? _h : {}; + for (let H of this.seen.entries()) { + let K = H[1]; + if (K.def && K.defId) U[K.defId] = K.def; + } + if (!J.external && Object.keys(U).length > 0) if (this.target === "draft-2020-12") G.$defs = U; + else G.definitions = U; + try { + return JSON.parse(JSON.stringify(G)); + } catch (H) { + throw Error("Error converting schema to JSON."); + } + } +}; +function Z0($, X) { + if ($ instanceof I8) { + let Q = new E7(X), Y = {}; + for (let G of $._idmap.entries()) { + let [U, H] = G; + Q.process(H); + } + let z6 = {}, W = { registry: $, uri: (X == null ? void 0 : X.uri) || ((G) => G), defs: Y }; + for (let G of $._idmap.entries()) { + let [U, H] = G; + z6[U] = Q.emit(H, { ...X, external: W }); + } + if (Object.keys(Y).length > 0) { + let G = Q.target === "draft-2020-12" ? "$defs" : "definitions"; + z6.__shared = { [G]: Y }; + } + return { schemas: z6 }; + } + let J = new E7(X); + return J.process($), J.emit($, X); +} +function k$($, X) { + let J = X != null ? X : { seen: /* @__PURE__ */ new Set() }; + if (J.seen.has($)) return false; + J.seen.add($); + let Y = $._zod.def; + switch (Y.type) { + case "string": + case "number": + case "bigint": + case "boolean": + case "date": + case "symbol": + case "undefined": + case "null": + case "any": + case "unknown": + case "never": + case "void": + case "literal": + case "enum": + case "nan": + case "file": + case "template_literal": + return false; + case "array": + return k$(Y.element, J); + case "object": { + for (let z6 in Y.shape) if (k$(Y.shape[z6], J)) return true; + return false; + } + case "union": { + for (let z6 of Y.options) if (k$(z6, J)) return true; + return false; + } + case "intersection": + return k$(Y.left, J) || k$(Y.right, J); + case "tuple": { + for (let z6 of Y.items) if (k$(z6, J)) return true; + if (Y.rest && k$(Y.rest, J)) return true; + return false; + } + case "record": + return k$(Y.keyType, J) || k$(Y.valueType, J); + case "map": + return k$(Y.keyType, J) || k$(Y.valueType, J); + case "set": + return k$(Y.valueType, J); + case "promise": + case "optional": + case "nonoptional": + case "nullable": + case "readonly": + return k$(Y.innerType, J); + case "lazy": + return k$(Y.getter(), J); + case "default": + return k$(Y.innerType, J); + case "prefault": + return k$(Y.innerType, J); + case "custom": + return false; + case "transform": + return true; + case "pipe": + return k$(Y.in, J) || k$(Y.out, J); + case "success": + return false; + case "catch": + return false; + default: + } + throw Error(`Unknown schema type: ${Y.type}`); +} +var RN = {}; +var P2 = q("ZodMiniType", ($, X) => { + if (!$._zod) throw Error("Uninitialized schema in ZodMiniType."); + i.init($, X), $.def = X, $.parse = (J, Q) => j1($, J, Q, { callee: $.parse }), $.safeParse = (J, Q) => k4($, J, Q), $.parseAsync = async (J, Q) => F1($, J, Q, { callee: $.parseAsync }), $.safeParseAsync = async (J, Q) => _4($, J, Q), $.check = (...J) => { + var _a3; + return $.clone({ ...X, checks: [...(_a3 = X.checks) != null ? _a3 : [], ...J.map((Q) => typeof Q === "function" ? { _zod: { check: Q, def: { check: "custom" }, onattach: [] } } : Q)] }); + }, $.clone = (J, Q) => m$($, J, Q), $.brand = () => $, $.register = (J, Q) => { + return J.add($, Q), $; + }; +}); +var Z2 = q("ZodMiniObject", ($, X) => { + j8.init($, X), P2.init($, X), E.defineLazy($, "shape", () => X.shape); +}); +var u4 = {}; +$1(u4, { xid: () => c2, void: () => Kb, uuidv7: () => y2, uuidv6: () => T2, uuidv4: () => x2, uuid: () => _2, url: () => f2, uppercase: () => r8, unknown: () => D$, union: () => U$, undefined: () => Ub, ulid: () => l2, uint64: () => Wb, uint32: () => Yb, tuple: () => wb, trim: () => $9, treeifyError: () => iJ, transform: () => nG, toUpperCase: () => J9, toLowerCase: () => X9, toJSONSchema: () => Z0, templateLiteral: () => Ab, symbol: () => Gb, superRefine: () => OV, success: () => Mb, stringbool: () => Zb, stringFormat: () => e2, string: () => F, strictObject: () => Ob, startsWith: () => t8, size: () => i8, setErrorMap: () => Sb, set: () => Db, safeParseAsync: () => IG, safeParse: () => MG, registry: () => A8, regexes: () => x4, regex: () => n8, refine: () => VV, record: () => w$, readonly: () => WV, property: () => NG, promise: () => bb, prettifyError: () => nJ, preprocess: () => c7, prefault: () => eN, positive: () => GG, pipe: () => f7, partialRecord: () => Bb, parseAsync: () => FG, parse: () => jG, overwrite: () => V4, optional: () => L$, object: () => _, number: () => G$, nullish: () => Fb, nullable: () => y7, null: () => H9, normalize: () => e8, nonpositive: () => HG, nonoptional: () => $V, nonnegative: () => KG, never: () => g7, negative: () => UG, nativeEnum: () => Lb, nanoid: () => h2, nan: () => Ib, multipleOf: () => b1, minSize: () => P1, minLength: () => f4, mime: () => s8, maxSize: () => A0, maxLength: () => b0, map: () => qb, lte: () => I6, lt: () => K4, lowercase: () => d8, looseObject: () => l$, locales: () => M0, literal: () => f, length: () => P0, lazy: () => HV, ksuid: () => p2, keyof: () => Vb, jwt: () => s2, json: () => Eb, iso: () => R0, ipv6: () => n2, ipv4: () => i2, intersection: () => K9, int64: () => zb, int32: () => Jb, int: () => AG, instanceof: () => Pb, includes: () => o8, guid: () => k2, gte: () => J6, gt: () => N4, globalRegistry: () => X6, getErrorMap: () => vb, function: () => Z7, formatError: () => B0, float64: () => Xb, float32: () => $b, flattenError: () => w0, file: () => jb, enum: () => d$, endsWith: () => a8, emoji: () => g2, email: () => C2, e164: () => a2, discriminatedUnion: () => m7, date: () => Nb, custom: () => tG, cuid2: () => m2, cuid: () => u2, core: () => C6, config: () => E$, coerce: () => aG, clone: () => m$, cidrv6: () => r2, cidrv4: () => d2, check: () => NV, catch: () => YV, boolean: () => S$, bigint: () => Qb, base64url: () => t2, base64: () => o2, array: () => $$, any: () => Hb, _default: () => aN, _ZodString: () => bG, ZodXID: () => kG, ZodVoid: () => uN, ZodUnknown: () => gN, ZodUnion: () => cG, ZodUndefined: () => TN, ZodUUID: () => O4, ZodURL: () => ZG, ZodULID: () => CG, ZodType: () => s, ZodTuple: () => pN, ZodTransform: () => iG, ZodTemplateLiteral: () => GV, ZodSymbol: () => xN, ZodSuccess: () => XV, ZodStringFormat: () => O$, ZodString: () => z9, ZodSet: () => nN, ZodRecord: () => pG, ZodRealError: () => S0, ZodReadonly: () => zV, ZodPromise: () => KV, ZodPrefault: () => sN, ZodPipe: () => oG, ZodOptional: () => dG, ZodObject: () => u7, ZodNumberFormat: () => v0, ZodNumber: () => W9, ZodNullable: () => oN, ZodNull: () => yN, ZodNonOptional: () => rG, ZodNever: () => hN, ZodNanoID: () => RG, ZodNaN: () => QV, ZodMap: () => iN, ZodLiteral: () => dN, ZodLazy: () => UV, ZodKSUID: () => _G, ZodJWT: () => mG, ZodIssueCode: () => Rb, ZodIntersection: () => cN, ZodISOTime: () => _7, ZodISODuration: () => x7, ZodISODateTime: () => C7, ZodISODate: () => k7, ZodIPv6: () => TG, ZodIPv4: () => xG, ZodGUID: () => T7, ZodFile: () => rN, ZodError: () => S2, ZodEnum: () => Q9, ZodEmoji: () => EG, ZodEmail: () => PG, ZodE164: () => uG, ZodDiscriminatedUnion: () => lN, ZodDefault: () => tN, ZodDate: () => h7, ZodCustomStringFormat: () => _N, ZodCustom: () => l7, ZodCatch: () => JV, ZodCUID2: () => vG, ZodCUID: () => SG, ZodCIDRv6: () => fG, ZodCIDRv4: () => yG, ZodBoolean: () => G9, ZodBigIntFormat: () => lG, ZodBigInt: () => U9, ZodBase64URL: () => hG, ZodBase64: () => gG, ZodArray: () => mN, ZodAny: () => fN, TimePrecision: () => J7, NEVER: () => lJ, $output: () => eY, $input: () => $7, $brand: () => cJ }); +var R0 = {}; +$1(R0, { time: () => DG, duration: () => LG, datetime: () => BG, date: () => qG, ZodISOTime: () => _7, ZodISODuration: () => x7, ZodISODateTime: () => C7, ZodISODate: () => k7 }); +var C7 = q("ZodISODateTime", ($, X) => { + HW.init($, X), O$.init($, X); +}); +function BG($) { + return eW(C7, $); +} +var k7 = q("ZodISODate", ($, X) => { + KW.init($, X), O$.init($, X); +}); +function qG($) { + return $G(k7, $); +} +var _7 = q("ZodISOTime", ($, X) => { + NW.init($, X), O$.init($, X); +}); +function DG($) { + return XG(_7, $); +} +var x7 = q("ZodISODuration", ($, X) => { + VW.init($, X), O$.init($, X); +}); +function LG($) { + return JG(x7, $); +} +var kN = ($, X) => { + q8.init($, X), $.name = "ZodError", Object.defineProperties($, { format: { value: (J) => B0($, J) }, flatten: { value: (J) => w0($, J) }, addIssue: { value: (J) => $.issues.push(J) }, addIssues: { value: (J) => $.issues.push(...J) }, isEmpty: { get() { + return $.issues.length === 0; + } } }); +}; +var S2 = q("ZodError", kN); +var S0 = q("ZodError", kN, { Parent: Error }); +var jG = dJ(S0); +var FG = rJ(S0); +var MG = oJ(S0); +var IG = tJ(S0); +var s = q("ZodType", ($, X) => { + return i.init($, X), $.def = X, Object.defineProperty($, "_def", { value: X }), $.check = (...J) => { + var _a3; + return $.clone({ ...X, checks: [...(_a3 = X.checks) != null ? _a3 : [], ...J.map((Q) => typeof Q === "function" ? { _zod: { check: Q, def: { check: "custom" }, onattach: [] } } : Q)] }); + }, $.clone = (J, Q) => m$($, J, Q), $.brand = () => $, $.register = (J, Q) => { + return J.add($, Q), $; + }, $.parse = (J, Q) => jG($, J, Q, { callee: $.parse }), $.safeParse = (J, Q) => MG($, J, Q), $.parseAsync = async (J, Q) => FG($, J, Q, { callee: $.parseAsync }), $.safeParseAsync = async (J, Q) => IG($, J, Q), $.spa = $.safeParseAsync, $.refine = (J, Q) => $.check(VV(J, Q)), $.superRefine = (J) => $.check(OV(J)), $.overwrite = (J) => $.check(V4(J)), $.optional = () => L$($), $.nullable = () => y7($), $.nullish = () => L$(y7($)), $.nonoptional = (J) => $V($, J), $.array = () => $$($), $.or = (J) => U$([$, J]), $.and = (J) => K9($, J), $.transform = (J) => f7($, nG(J)), $.default = (J) => aN($, J), $.prefault = (J) => eN($, J), $.catch = (J) => YV($, J), $.pipe = (J) => f7($, J), $.readonly = () => WV($), $.describe = (J) => { + let Q = $.clone(); + return X6.add(Q, { description: J }), Q; + }, Object.defineProperty($, "description", { get() { + var _a3; + return (_a3 = X6.get($)) == null ? void 0 : _a3.description; + }, configurable: true }), $.meta = (...J) => { + if (J.length === 0) return X6.get($); + let Q = $.clone(); + return X6.add(Q, J[0]), Q; + }, $.isOptional = () => $.safeParse(void 0).success, $.isNullable = () => $.safeParse(null).success, $; +}); +var bG = q("_ZodString", ($, X) => { + var _a3, _b2, _c; + T4.init($, X), s.init($, X); + let J = $._zod.bag; + $.format = (_a3 = J.format) != null ? _a3 : null, $.minLength = (_b2 = J.minimum) != null ? _b2 : null, $.maxLength = (_c = J.maximum) != null ? _c : null, $.regex = (...Q) => $.check(n8(...Q)), $.includes = (...Q) => $.check(o8(...Q)), $.startsWith = (...Q) => $.check(t8(...Q)), $.endsWith = (...Q) => $.check(a8(...Q)), $.min = (...Q) => $.check(f4(...Q)), $.max = (...Q) => $.check(b0(...Q)), $.length = (...Q) => $.check(P0(...Q)), $.nonempty = (...Q) => $.check(f4(1, ...Q)), $.lowercase = (Q) => $.check(d8(Q)), $.uppercase = (Q) => $.check(r8(Q)), $.trim = () => $.check($9()), $.normalize = (...Q) => $.check(e8(...Q)), $.toLowerCase = () => $.check(X9()), $.toUpperCase = () => $.check(J9()); +}); +var z9 = q("ZodString", ($, X) => { + T4.init($, X), bG.init($, X), $.email = (J) => $.check(b8(PG, J)), $.url = (J) => $.check(S8(ZG, J)), $.jwt = (J) => $.check(p8(mG, J)), $.emoji = (J) => $.check(v8(EG, J)), $.guid = (J) => $.check(I0(T7, J)), $.uuid = (J) => $.check(P8(O4, J)), $.uuidv4 = (J) => $.check(Z8(O4, J)), $.uuidv6 = (J) => $.check(E8(O4, J)), $.uuidv7 = (J) => $.check(R8(O4, J)), $.nanoid = (J) => $.check(C8(RG, J)), $.guid = (J) => $.check(I0(T7, J)), $.cuid = (J) => $.check(k8(SG, J)), $.cuid2 = (J) => $.check(_8(vG, J)), $.ulid = (J) => $.check(x8(CG, J)), $.base64 = (J) => $.check(m8(gG, J)), $.base64url = (J) => $.check(l8(hG, J)), $.xid = (J) => $.check(T8(kG, J)), $.ksuid = (J) => $.check(y8(_G, J)), $.ipv4 = (J) => $.check(f8(xG, J)), $.ipv6 = (J) => $.check(g8(TG, J)), $.cidrv4 = (J) => $.check(h8(yG, J)), $.cidrv6 = (J) => $.check(u8(fG, J)), $.e164 = (J) => $.check(c8(uG, J)), $.datetime = (J) => $.check(BG(J)), $.date = (J) => $.check(qG(J)), $.time = (J) => $.check(DG(J)), $.duration = (J) => $.check(LG(J)); +}); +function F($) { + return X7(z9, $); +} +var O$ = q("ZodStringFormat", ($, X) => { + H$.init($, X), bG.init($, X); +}); +var PG = q("ZodEmail", ($, X) => { + zY.init($, X), O$.init($, X); +}); +function C2($) { + return b8(PG, $); +} +var T7 = q("ZodGUID", ($, X) => { + YY.init($, X), O$.init($, X); +}); +function k2($) { + return I0(T7, $); +} +var O4 = q("ZodUUID", ($, X) => { + QY.init($, X), O$.init($, X); +}); +function _2($) { + return P8(O4, $); +} +function x2($) { + return Z8(O4, $); +} +function T2($) { + return E8(O4, $); +} +function y2($) { + return R8(O4, $); +} +var ZG = q("ZodURL", ($, X) => { + WY.init($, X), O$.init($, X); +}); +function f2($) { + return S8(ZG, $); +} +var EG = q("ZodEmoji", ($, X) => { + GY.init($, X), O$.init($, X); +}); +function g2($) { + return v8(EG, $); +} +var RG = q("ZodNanoID", ($, X) => { + UY.init($, X), O$.init($, X); +}); +function h2($) { + return C8(RG, $); +} +var SG = q("ZodCUID", ($, X) => { + HY.init($, X), O$.init($, X); +}); +function u2($) { + return k8(SG, $); +} +var vG = q("ZodCUID2", ($, X) => { + KY.init($, X), O$.init($, X); +}); +function m2($) { + return _8(vG, $); +} +var CG = q("ZodULID", ($, X) => { + NY.init($, X), O$.init($, X); +}); +function l2($) { + return x8(CG, $); +} +var kG = q("ZodXID", ($, X) => { + VY.init($, X), O$.init($, X); +}); +function c2($) { + return T8(kG, $); +} +var _G = q("ZodKSUID", ($, X) => { + OY.init($, X), O$.init($, X); +}); +function p2($) { + return y8(_G, $); +} +var xG = q("ZodIPv4", ($, X) => { + wY.init($, X), O$.init($, X); +}); +function i2($) { + return f8(xG, $); +} +var TG = q("ZodIPv6", ($, X) => { + BY.init($, X), O$.init($, X); +}); +function n2($) { + return g8(TG, $); +} +var yG = q("ZodCIDRv4", ($, X) => { + qY.init($, X), O$.init($, X); +}); +function d2($) { + return h8(yG, $); +} +var fG = q("ZodCIDRv6", ($, X) => { + DY.init($, X), O$.init($, X); +}); +function r2($) { + return u8(fG, $); +} +var gG = q("ZodBase64", ($, X) => { + LY.init($, X), O$.init($, X); +}); +function o2($) { + return m8(gG, $); +} +var hG = q("ZodBase64URL", ($, X) => { + jY.init($, X), O$.init($, X); +}); +function t2($) { + return l8(hG, $); +} +var uG = q("ZodE164", ($, X) => { + FY.init($, X), O$.init($, X); +}); +function a2($) { + return c8(uG, $); +} +var mG = q("ZodJWT", ($, X) => { + MY.init($, X), O$.init($, X); +}); +function s2($) { + return p8(mG, $); +} +var _N = q("ZodCustomStringFormat", ($, X) => { + IY.init($, X), O$.init($, X); +}); +function e2($, X, J = {}) { + return P7(_N, $, X, J); +} +var W9 = q("ZodNumber", ($, X) => { + var _a3, _b2, _c, _d, _e, _f, _g, _h, _i; + D8.init($, X), s.init($, X), $.gt = (Q, Y) => $.check(N4(Q, Y)), $.gte = (Q, Y) => $.check(J6(Q, Y)), $.min = (Q, Y) => $.check(J6(Q, Y)), $.lt = (Q, Y) => $.check(K4(Q, Y)), $.lte = (Q, Y) => $.check(I6(Q, Y)), $.max = (Q, Y) => $.check(I6(Q, Y)), $.int = (Q) => $.check(AG(Q)), $.safe = (Q) => $.check(AG(Q)), $.positive = (Q) => $.check(N4(0, Q)), $.nonnegative = (Q) => $.check(J6(0, Q)), $.negative = (Q) => $.check(K4(0, Q)), $.nonpositive = (Q) => $.check(I6(0, Q)), $.multipleOf = (Q, Y) => $.check(b1(Q, Y)), $.step = (Q, Y) => $.check(b1(Q, Y)), $.finite = () => $; + let J = $._zod.bag; + $.minValue = (_c = Math.max((_a3 = J.minimum) != null ? _a3 : Number.NEGATIVE_INFINITY, (_b2 = J.exclusiveMinimum) != null ? _b2 : Number.NEGATIVE_INFINITY)) != null ? _c : null, $.maxValue = (_f = Math.min((_d = J.maximum) != null ? _d : Number.POSITIVE_INFINITY, (_e = J.exclusiveMaximum) != null ? _e : Number.POSITIVE_INFINITY)) != null ? _f : null, $.isInt = ((_g = J.format) != null ? _g : "").includes("int") || Number.isSafeInteger((_h = J.multipleOf) != null ? _h : 0.5), $.isFinite = true, $.format = (_i = J.format) != null ? _i : null; +}); +function G$($) { + return Y7(W9, $); +} +var v0 = q("ZodNumberFormat", ($, X) => { + AY.init($, X), W9.init($, X); +}); +function AG($) { + return Q7(v0, $); +} +function $b($) { + return z7(v0, $); +} +function Xb($) { + return W7(v0, $); +} +function Jb($) { + return G7(v0, $); +} +function Yb($) { + return U7(v0, $); +} +var G9 = q("ZodBoolean", ($, X) => { + D0.init($, X), s.init($, X); +}); +function S$($) { + return H7(G9, $); +} +var U9 = q("ZodBigInt", ($, X) => { + var _a3, _b2, _c; + L8.init($, X), s.init($, X), $.gte = (Q, Y) => $.check(J6(Q, Y)), $.min = (Q, Y) => $.check(J6(Q, Y)), $.gt = (Q, Y) => $.check(N4(Q, Y)), $.gte = (Q, Y) => $.check(J6(Q, Y)), $.min = (Q, Y) => $.check(J6(Q, Y)), $.lt = (Q, Y) => $.check(K4(Q, Y)), $.lte = (Q, Y) => $.check(I6(Q, Y)), $.max = (Q, Y) => $.check(I6(Q, Y)), $.positive = (Q) => $.check(N4(BigInt(0), Q)), $.negative = (Q) => $.check(K4(BigInt(0), Q)), $.nonpositive = (Q) => $.check(I6(BigInt(0), Q)), $.nonnegative = (Q) => $.check(J6(BigInt(0), Q)), $.multipleOf = (Q, Y) => $.check(b1(Q, Y)); + let J = $._zod.bag; + $.minValue = (_a3 = J.minimum) != null ? _a3 : null, $.maxValue = (_b2 = J.maximum) != null ? _b2 : null, $.format = (_c = J.format) != null ? _c : null; +}); +function Qb($) { + return K7(U9, $); +} +var lG = q("ZodBigIntFormat", ($, X) => { + bY.init($, X), U9.init($, X); +}); +function zb($) { + return N7(lG, $); +} +function Wb($) { + return V7(lG, $); +} +var xN = q("ZodSymbol", ($, X) => { + PY.init($, X), s.init($, X); +}); +function Gb($) { + return O7(xN, $); +} +var TN = q("ZodUndefined", ($, X) => { + ZY.init($, X), s.init($, X); +}); +function Ub($) { + return w7(TN, $); +} +var yN = q("ZodNull", ($, X) => { + EY.init($, X), s.init($, X); +}); +function H9($) { + return B7(yN, $); +} +var fN = q("ZodAny", ($, X) => { + RY.init($, X), s.init($, X); +}); +function Hb() { + return q7(fN); +} +var gN = q("ZodUnknown", ($, X) => { + I1.init($, X), s.init($, X); +}); +function D$() { + return A1(gN); +} +var hN = q("ZodNever", ($, X) => { + SY.init($, X), s.init($, X); +}); +function g7($) { + return D7(hN, $); +} +var uN = q("ZodVoid", ($, X) => { + vY.init($, X), s.init($, X); +}); +function Kb($) { + return L7(uN, $); +} +var h7 = q("ZodDate", ($, X) => { + CY.init($, X), s.init($, X), $.min = (Q, Y) => $.check(J6(Q, Y)), $.max = (Q, Y) => $.check(I6(Q, Y)); + let J = $._zod.bag; + $.minDate = J.minimum ? new Date(J.minimum) : null, $.maxDate = J.maximum ? new Date(J.maximum) : null; +}); +function Nb($) { + return j7(h7, $); +} +var mN = q("ZodArray", ($, X) => { + L0.init($, X), s.init($, X), $.element = X.element, $.min = (J, Q) => $.check(f4(J, Q)), $.nonempty = (J) => $.check(f4(1, J)), $.max = (J, Q) => $.check(b0(J, Q)), $.length = (J, Q) => $.check(P0(J, Q)), $.unwrap = () => $.element; +}); +function $$($, X) { + return Y9(mN, $, X); +} +function Vb($) { + let X = $._zod.def.shape; + return f(Object.keys(X)); +} +var u7 = q("ZodObject", ($, X) => { + j8.init($, X), s.init($, X), E.defineLazy($, "shape", () => X.shape), $.keyof = () => d$(Object.keys($._zod.def.shape)), $.catchall = (J) => $.clone({ ...$._zod.def, catchall: J }), $.passthrough = () => $.clone({ ...$._zod.def, catchall: D$() }), $.loose = () => $.clone({ ...$._zod.def, catchall: D$() }), $.strict = () => $.clone({ ...$._zod.def, catchall: g7() }), $.strip = () => $.clone({ ...$._zod.def, catchall: void 0 }), $.extend = (J) => { + return E.extend($, J); + }, $.merge = (J) => E.merge($, J), $.pick = (J) => E.pick($, J), $.omit = (J) => E.omit($, J), $.partial = (...J) => E.partial(dG, $, J[0]), $.required = (...J) => E.required(rG, $, J[0]); +}); +function _($, X) { + let J = { type: "object", get shape() { + return E.assignProp(this, "shape", { ...$ }), this.shape; + }, ...E.normalizeParams(X) }; + return new u7(J); +} +function Ob($, X) { + return new u7({ type: "object", get shape() { + return E.assignProp(this, "shape", { ...$ }), this.shape; + }, catchall: g7(), ...E.normalizeParams(X) }); +} +function l$($, X) { + return new u7({ type: "object", get shape() { + return E.assignProp(this, "shape", { ...$ }), this.shape; + }, catchall: D$(), ...E.normalizeParams(X) }); +} +var cG = q("ZodUnion", ($, X) => { + F8.init($, X), s.init($, X), $.options = X.options; +}); +function U$($, X) { + return new cG({ type: "union", options: $, ...E.normalizeParams(X) }); +} +var lN = q("ZodDiscriminatedUnion", ($, X) => { + cG.init($, X), kY.init($, X); +}); +function m7($, X, J) { + return new lN({ type: "union", options: X, discriminator: $, ...E.normalizeParams(J) }); +} +var cN = q("ZodIntersection", ($, X) => { + _Y.init($, X), s.init($, X); +}); +function K9($, X) { + return new cN({ type: "intersection", left: $, right: X }); +} +var pN = q("ZodTuple", ($, X) => { + y4.init($, X), s.init($, X), $.rest = (J) => $.clone({ ...$._zod.def, rest: J }); +}); +function wb($, X, J) { + let Q = X instanceof i, Y = Q ? J : X; + return new pN({ type: "tuple", items: $, rest: Q ? X : null, ...E.normalizeParams(Y) }); +} +var pG = q("ZodRecord", ($, X) => { + xY.init($, X), s.init($, X), $.keyType = X.keyType, $.valueType = X.valueType; +}); +function w$($, X, J) { + return new pG({ type: "record", keyType: $, valueType: X, ...E.normalizeParams(J) }); +} +function Bb($, X, J) { + return new pG({ type: "record", keyType: U$([$, g7()]), valueType: X, ...E.normalizeParams(J) }); +} +var iN = q("ZodMap", ($, X) => { + TY.init($, X), s.init($, X), $.keyType = X.keyType, $.valueType = X.valueType; +}); +function qb($, X, J) { + return new iN({ type: "map", keyType: $, valueType: X, ...E.normalizeParams(J) }); +} +var nN = q("ZodSet", ($, X) => { + yY.init($, X), s.init($, X), $.min = (...J) => $.check(P1(...J)), $.nonempty = (J) => $.check(P1(1, J)), $.max = (...J) => $.check(A0(...J)), $.size = (...J) => $.check(i8(...J)); +}); +function Db($, X) { + return new nN({ type: "set", valueType: $, ...E.normalizeParams(X) }); +} +var Q9 = q("ZodEnum", ($, X) => { + fY.init($, X), s.init($, X), $.enum = X.entries, $.options = Object.values(X.entries); + let J = new Set(Object.keys(X.entries)); + $.extract = (Q, Y) => { + let z6 = {}; + for (let W of Q) if (J.has(W)) z6[W] = X.entries[W]; + else throw Error(`Key ${W} not found in enum`); + return new Q9({ ...X, checks: [], ...E.normalizeParams(Y), entries: z6 }); + }, $.exclude = (Q, Y) => { + let z6 = { ...X.entries }; + for (let W of Q) if (J.has(W)) delete z6[W]; + else throw Error(`Key ${W} not found in enum`); + return new Q9({ ...X, checks: [], ...E.normalizeParams(Y), entries: z6 }); + }; +}); +function d$($, X) { + let J = Array.isArray($) ? Object.fromEntries($.map((Q) => [Q, Q])) : $; + return new Q9({ type: "enum", entries: J, ...E.normalizeParams(X) }); +} +function Lb($, X) { + return new Q9({ type: "enum", entries: $, ...E.normalizeParams(X) }); +} +var dN = q("ZodLiteral", ($, X) => { + gY.init($, X), s.init($, X), $.values = new Set(X.values), Object.defineProperty($, "value", { get() { + if (X.values.length > 1) throw Error("This schema contains multiple valid literal values. Use `.values` instead."); + return X.values[0]; + } }); +}); +function f($, X) { + return new dN({ type: "literal", values: Array.isArray($) ? $ : [$], ...E.normalizeParams(X) }); +} +var rN = q("ZodFile", ($, X) => { + hY.init($, X), s.init($, X), $.min = (J, Q) => $.check(P1(J, Q)), $.max = (J, Q) => $.check(A0(J, Q)), $.mime = (J, Q) => $.check(s8(Array.isArray(J) ? J : [J], Q)); +}); +function jb($) { + return M7(rN, $); +} +var iG = q("ZodTransform", ($, X) => { + j0.init($, X), s.init($, X), $._zod.parse = (J, Q) => { + J.addIssue = (z6) => { + var _a3, _b2, _c, _d; + if (typeof z6 === "string") J.issues.push(E.issue(z6, J.value, X)); + else { + let W = z6; + if (W.fatal) W.continue = false; + (_a3 = W.code) != null ? _a3 : W.code = "custom", (_b2 = W.input) != null ? _b2 : W.input = J.value, (_c = W.inst) != null ? _c : W.inst = $, (_d = W.continue) != null ? _d : W.continue = true, J.issues.push(E.issue(W)); + } + }; + let Y = X.transform(J.value, J); + if (Y instanceof Promise) return Y.then((z6) => { + return J.value = z6, J; + }); + return J.value = Y, J; + }; +}); +function nG($) { + return new iG({ type: "transform", transform: $ }); +} +var dG = q("ZodOptional", ($, X) => { + uY.init($, X), s.init($, X), $.unwrap = () => $._zod.def.innerType; +}); +function L$($) { + return new dG({ type: "optional", innerType: $ }); +} +var oN = q("ZodNullable", ($, X) => { + mY.init($, X), s.init($, X), $.unwrap = () => $._zod.def.innerType; +}); +function y7($) { + return new oN({ type: "nullable", innerType: $ }); +} +function Fb($) { + return L$(y7($)); +} +var tN = q("ZodDefault", ($, X) => { + lY.init($, X), s.init($, X), $.unwrap = () => $._zod.def.innerType, $.removeDefault = $.unwrap; +}); +function aN($, X) { + return new tN({ type: "default", innerType: $, get defaultValue() { + return typeof X === "function" ? X() : X; + } }); +} +var sN = q("ZodPrefault", ($, X) => { + cY.init($, X), s.init($, X), $.unwrap = () => $._zod.def.innerType; +}); +function eN($, X) { + return new sN({ type: "prefault", innerType: $, get defaultValue() { + return typeof X === "function" ? X() : X; + } }); +} +var rG = q("ZodNonOptional", ($, X) => { + pY.init($, X), s.init($, X), $.unwrap = () => $._zod.def.innerType; +}); +function $V($, X) { + return new rG({ type: "nonoptional", innerType: $, ...E.normalizeParams(X) }); +} +var XV = q("ZodSuccess", ($, X) => { + iY.init($, X), s.init($, X), $.unwrap = () => $._zod.def.innerType; +}); +function Mb($) { + return new XV({ type: "success", innerType: $ }); +} +var JV = q("ZodCatch", ($, X) => { + nY.init($, X), s.init($, X), $.unwrap = () => $._zod.def.innerType, $.removeCatch = $.unwrap; +}); +function YV($, X) { + return new JV({ type: "catch", innerType: $, catchValue: typeof X === "function" ? X : () => X }); +} +var QV = q("ZodNaN", ($, X) => { + dY.init($, X), s.init($, X); +}); +function Ib($) { + return F7(QV, $); +} +var oG = q("ZodPipe", ($, X) => { + F0.init($, X), s.init($, X), $.in = X.in, $.out = X.out; +}); +function f7($, X) { + return new oG({ type: "pipe", in: $, out: X }); +} +var zV = q("ZodReadonly", ($, X) => { + rY.init($, X), s.init($, X); +}); +function WV($) { + return new zV({ type: "readonly", innerType: $ }); +} +var GV = q("ZodTemplateLiteral", ($, X) => { + oY.init($, X), s.init($, X); +}); +function Ab($, X) { + return new GV({ type: "template_literal", parts: $, ...E.normalizeParams(X) }); +} +var UV = q("ZodLazy", ($, X) => { + aY.init($, X), s.init($, X), $.unwrap = () => $._zod.def.getter(); +}); +function HV($) { + return new UV({ type: "lazy", getter: $ }); +} +var KV = q("ZodPromise", ($, X) => { + tY.init($, X), s.init($, X), $.unwrap = () => $._zod.def.innerType; +}); +function bb($) { + return new KV({ type: "promise", innerType: $ }); +} +var l7 = q("ZodCustom", ($, X) => { + sY.init($, X), s.init($, X); +}); +function NV($, X) { + let J = new M$({ check: "custom", ...E.normalizeParams(X) }); + return J._zod.check = $, J; +} +function tG($, X) { + return I7(l7, $ != null ? $ : (() => true), X); +} +function VV($, X = {}) { + return A7(l7, $, X); +} +function OV($, X) { + let J = NV((Q) => { + return Q.addIssue = (Y) => { + var _a3, _b2, _c, _d; + if (typeof Y === "string") Q.issues.push(E.issue(Y, Q.value, J._zod.def)); + else { + let z6 = Y; + if (z6.fatal) z6.continue = false; + (_a3 = z6.code) != null ? _a3 : z6.code = "custom", (_b2 = z6.input) != null ? _b2 : z6.input = Q.value, (_c = z6.inst) != null ? _c : z6.inst = J, (_d = z6.continue) != null ? _d : z6.continue = !J._zod.def.abort, Q.issues.push(E.issue(z6)); + } + }, $(Q.value, Q); + }, X); + return J; +} +function Pb($, X = { error: `Input not instance of ${$.name}` }) { + let J = new l7({ type: "custom", check: "custom", fn: (Q) => Q instanceof $, abort: true, ...E.normalizeParams(X) }); + return J._zod.bag.Class = $, J; +} +var Zb = (...$) => b7({ Pipe: oG, Boolean: G9, String: z9, Transform: iG }, ...$); +function Eb($) { + let X = HV(() => { + return U$([F($), G$(), S$(), H9(), $$(X), w$(F(), X)]); + }); + return X; +} +function c7($, X) { + return f7(nG($), X); +} +var Rb = { invalid_type: "invalid_type", too_big: "too_big", too_small: "too_small", invalid_format: "invalid_format", not_multiple_of: "not_multiple_of", unrecognized_keys: "unrecognized_keys", invalid_union: "invalid_union", invalid_key: "invalid_key", invalid_element: "invalid_element", invalid_value: "invalid_value", custom: "custom" }; +function Sb($) { + E$({ customError: $ }); +} +function vb() { + return E$().customError; +} +var aG = {}; +$1(aG, { string: () => Cb, number: () => kb, date: () => Tb, boolean: () => _b, bigint: () => xb }); +function Cb($) { + return sW(z9, $); +} +function kb($) { + return YG(W9, $); +} +function _b($) { + return QG(G9, $); +} +function xb($) { + return zG(U9, $); +} +function Tb($) { + return WG(h7, $); +} +E$(M8()); +var m4 = "io.modelcontextprotocol/related-task"; +var i7 = "2.0"; +var y$ = tG(($) => $ !== null && (typeof $ === "object" || typeof $ === "function")); +var BV = U$([F(), G$().int()]); +var qV = F(); +var Yn = l$({ ttl: U$([G$(), H9()]).optional(), pollInterval: G$().optional() }); +var yb = _({ ttl: G$().optional() }); +var fb = _({ taskId: F() }); +var eG = l$({ progressToken: BV.optional(), [m4]: fb.optional() }); +var w6 = _({ _meta: eG.optional() }); +var N9 = w6.extend({ task: yb.optional() }); +var f$ = _({ method: F(), params: w6.loose().optional() }); +var b6 = _({ _meta: eG.optional() }); +var P6 = _({ method: F(), params: b6.loose().optional() }); +var g$ = l$({ _meta: eG.optional() }); +var n7 = U$([F(), G$().int()]); +var LV = _({ jsonrpc: f(i7), id: n7, ...f$.shape }).strict(); +var jV = _({ jsonrpc: f(i7), ...P6.shape }).strict(); +var X3 = _({ jsonrpc: f(i7), id: n7, result: g$ }).strict(); +var m; +(function($) { + $[$.ConnectionClosed = -32e3] = "ConnectionClosed", $[$.RequestTimeout = -32001] = "RequestTimeout", $[$.ParseError = -32700] = "ParseError", $[$.InvalidRequest = -32600] = "InvalidRequest", $[$.MethodNotFound = -32601] = "MethodNotFound", $[$.InvalidParams = -32602] = "InvalidParams", $[$.InternalError = -32603] = "InternalError", $[$.UrlElicitationRequired = -32042] = "UrlElicitationRequired"; +})(m || (m = {})); +var J3 = _({ jsonrpc: f(i7), id: n7.optional(), error: _({ code: G$().int(), message: F(), data: D$().optional() }) }).strict(); +var Qn = U$([LV, jV, X3, J3]); +var zn = U$([X3, J3]); +var d7 = g$.strict(); +var gb = b6.extend({ requestId: n7.optional(), reason: F().optional() }); +var r7 = P6.extend({ method: f("notifications/cancelled"), params: gb }); +var hb = _({ src: F(), mimeType: F().optional(), sizes: $$(F()).optional(), theme: d$(["light", "dark"]).optional() }); +var O9 = _({ icons: $$(hb).optional() }); +var C0 = _({ name: F(), title: F().optional() }); +var IV = C0.extend({ ...C0.shape, ...O9.shape, version: F(), websiteUrl: F().optional(), description: F().optional() }); +var ub = K9(_({ applyDefaults: S$().optional() }), w$(F(), D$())); +var mb = c7(($) => { + if ($ && typeof $ === "object" && !Array.isArray($)) { + if (Object.keys($).length === 0) return { form: {} }; + } + return $; +}, K9(_({ form: ub.optional(), url: y$.optional() }), w$(F(), D$()).optional())); +var lb = l$({ list: y$.optional(), cancel: y$.optional(), requests: l$({ sampling: l$({ createMessage: y$.optional() }).optional(), elicitation: l$({ create: y$.optional() }).optional() }).optional() }); +var cb = l$({ list: y$.optional(), cancel: y$.optional(), requests: l$({ tools: l$({ call: y$.optional() }).optional() }).optional() }); +var pb = _({ experimental: w$(F(), y$).optional(), sampling: _({ context: y$.optional(), tools: y$.optional() }).optional(), elicitation: mb.optional(), roots: _({ listChanged: S$().optional() }).optional(), tasks: lb.optional() }); +var ib = w6.extend({ protocolVersion: F(), capabilities: pb, clientInfo: IV }); +var Y3 = f$.extend({ method: f("initialize"), params: ib }); +var nb = _({ experimental: w$(F(), y$).optional(), logging: y$.optional(), completions: y$.optional(), prompts: _({ listChanged: S$().optional() }).optional(), resources: _({ subscribe: S$().optional(), listChanged: S$().optional() }).optional(), tools: _({ listChanged: S$().optional() }).optional(), tasks: cb.optional() }); +var db = g$.extend({ protocolVersion: F(), capabilities: nb, serverInfo: IV, instructions: F().optional() }); +var Q3 = P6.extend({ method: f("notifications/initialized"), params: b6.optional() }); +var o7 = f$.extend({ method: f("ping"), params: w6.optional() }); +var rb = _({ progress: G$(), total: L$(G$()), message: L$(F()) }); +var ob = _({ ...b6.shape, ...rb.shape, progressToken: BV }); +var t7 = P6.extend({ method: f("notifications/progress"), params: ob }); +var tb = w6.extend({ cursor: qV.optional() }); +var w9 = f$.extend({ params: tb.optional() }); +var B9 = g$.extend({ nextCursor: qV.optional() }); +var ab = d$(["working", "input_required", "completed", "failed", "cancelled"]); +var q9 = _({ taskId: F(), status: ab, ttl: U$([G$(), H9()]), createdAt: F(), lastUpdatedAt: F(), pollInterval: L$(G$()), statusMessage: L$(F()) }); +var k0 = g$.extend({ task: q9 }); +var sb = b6.merge(q9); +var D9 = P6.extend({ method: f("notifications/tasks/status"), params: sb }); +var a7 = f$.extend({ method: f("tasks/get"), params: w6.extend({ taskId: F() }) }); +var s7 = g$.merge(q9); +var e7 = f$.extend({ method: f("tasks/result"), params: w6.extend({ taskId: F() }) }); +var Wn = g$.loose(); +var $Q = w9.extend({ method: f("tasks/list") }); +var XQ = B9.extend({ tasks: $$(q9) }); +var JQ = f$.extend({ method: f("tasks/cancel"), params: w6.extend({ taskId: F() }) }); +var AV = g$.merge(q9); +var bV = _({ uri: F(), mimeType: L$(F()), _meta: w$(F(), D$()).optional() }); +var PV = bV.extend({ text: F() }); +var z3 = F().refine(($) => { + try { + return atob($), true; + } catch (e3) { + return false; + } +}, { message: "Invalid Base64 string" }); +var ZV = bV.extend({ blob: z3 }); +var L9 = d$(["user", "assistant"]); +var _0 = _({ audience: $$(L9).optional(), priority: G$().min(0).max(1).optional(), lastModified: R0.datetime({ offset: true }).optional() }); +var EV = _({ ...C0.shape, ...O9.shape, uri: F(), description: L$(F()), mimeType: L$(F()), annotations: _0.optional(), _meta: L$(l$({})) }); +var eb = _({ ...C0.shape, ...O9.shape, uriTemplate: F(), description: L$(F()), mimeType: L$(F()), annotations: _0.optional(), _meta: L$(l$({})) }); +var YQ = w9.extend({ method: f("resources/list") }); +var $P = B9.extend({ resources: $$(EV) }); +var QQ = w9.extend({ method: f("resources/templates/list") }); +var XP = B9.extend({ resourceTemplates: $$(eb) }); +var W3 = w6.extend({ uri: F() }); +var JP = W3; +var zQ = f$.extend({ method: f("resources/read"), params: JP }); +var YP = g$.extend({ contents: $$(U$([PV, ZV])) }); +var QP = P6.extend({ method: f("notifications/resources/list_changed"), params: b6.optional() }); +var zP = W3; +var WP = f$.extend({ method: f("resources/subscribe"), params: zP }); +var GP = W3; +var UP = f$.extend({ method: f("resources/unsubscribe"), params: GP }); +var HP = b6.extend({ uri: F() }); +var KP = P6.extend({ method: f("notifications/resources/updated"), params: HP }); +var NP = _({ name: F(), description: L$(F()), required: L$(S$()) }); +var VP = _({ ...C0.shape, ...O9.shape, description: L$(F()), arguments: L$($$(NP)), _meta: L$(l$({})) }); +var WQ = w9.extend({ method: f("prompts/list") }); +var OP = B9.extend({ prompts: $$(VP) }); +var wP = w6.extend({ name: F(), arguments: w$(F(), F()).optional() }); +var GQ = f$.extend({ method: f("prompts/get"), params: wP }); +var G3 = _({ type: f("text"), text: F(), annotations: _0.optional(), _meta: w$(F(), D$()).optional() }); +var U3 = _({ type: f("image"), data: z3, mimeType: F(), annotations: _0.optional(), _meta: w$(F(), D$()).optional() }); +var H3 = _({ type: f("audio"), data: z3, mimeType: F(), annotations: _0.optional(), _meta: w$(F(), D$()).optional() }); +var BP = _({ type: f("tool_use"), name: F(), id: F(), input: w$(F(), D$()), _meta: w$(F(), D$()).optional() }); +var qP = _({ type: f("resource"), resource: U$([PV, ZV]), annotations: _0.optional(), _meta: w$(F(), D$()).optional() }); +var DP = EV.extend({ type: f("resource_link") }); +var K3 = U$([G3, U3, H3, DP, qP]); +var LP = _({ role: L9, content: K3 }); +var jP = g$.extend({ description: F().optional(), messages: $$(LP) }); +var FP = P6.extend({ method: f("notifications/prompts/list_changed"), params: b6.optional() }); +var MP = _({ title: F().optional(), readOnlyHint: S$().optional(), destructiveHint: S$().optional(), idempotentHint: S$().optional(), openWorldHint: S$().optional() }); +var IP = _({ taskSupport: d$(["required", "optional", "forbidden"]).optional() }); +var RV = _({ ...C0.shape, ...O9.shape, description: F().optional(), inputSchema: _({ type: f("object"), properties: w$(F(), y$).optional(), required: $$(F()).optional() }).catchall(D$()), outputSchema: _({ type: f("object"), properties: w$(F(), y$).optional(), required: $$(F()).optional() }).catchall(D$()).optional(), annotations: MP.optional(), execution: IP.optional(), _meta: w$(F(), D$()).optional() }); +var UQ = w9.extend({ method: f("tools/list") }); +var AP = B9.extend({ tools: $$(RV) }); +var HQ = g$.extend({ content: $$(K3).default([]), structuredContent: w$(F(), D$()).optional(), isError: S$().optional() }); +var Gn = HQ.or(g$.extend({ toolResult: D$() })); +var bP = N9.extend({ name: F(), arguments: w$(F(), D$()).optional() }); +var x0 = f$.extend({ method: f("tools/call"), params: bP }); +var PP = P6.extend({ method: f("notifications/tools/list_changed"), params: b6.optional() }); +var Un = _({ autoRefresh: S$().default(true), debounceMs: G$().int().nonnegative().default(300) }); +var j9 = d$(["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"]); +var ZP = w6.extend({ level: j9 }); +var N3 = f$.extend({ method: f("logging/setLevel"), params: ZP }); +var EP = b6.extend({ level: j9, logger: F().optional(), data: D$() }); +var RP = P6.extend({ method: f("notifications/message"), params: EP }); +var SP = _({ name: F().optional() }); +var vP = _({ hints: $$(SP).optional(), costPriority: G$().min(0).max(1).optional(), speedPriority: G$().min(0).max(1).optional(), intelligencePriority: G$().min(0).max(1).optional() }); +var CP = _({ mode: d$(["auto", "required", "none"]).optional() }); +var kP = _({ type: f("tool_result"), toolUseId: F().describe("The unique identifier for the corresponding tool call."), content: $$(K3).default([]), structuredContent: _({}).loose().optional(), isError: S$().optional(), _meta: w$(F(), D$()).optional() }); +var _P = m7("type", [G3, U3, H3]); +var p7 = m7("type", [G3, U3, H3, BP, kP]); +var xP = _({ role: L9, content: U$([p7, $$(p7)]), _meta: w$(F(), D$()).optional() }); +var TP = N9.extend({ messages: $$(xP), modelPreferences: vP.optional(), systemPrompt: F().optional(), includeContext: d$(["none", "thisServer", "allServers"]).optional(), temperature: G$().optional(), maxTokens: G$().int(), stopSequences: $$(F()).optional(), metadata: y$.optional(), tools: $$(RV).optional(), toolChoice: CP.optional() }); +var yP = f$.extend({ method: f("sampling/createMessage"), params: TP }); +var F9 = g$.extend({ model: F(), stopReason: L$(d$(["endTurn", "stopSequence", "maxTokens"]).or(F())), role: L9, content: _P }); +var V3 = g$.extend({ model: F(), stopReason: L$(d$(["endTurn", "stopSequence", "maxTokens", "toolUse"]).or(F())), role: L9, content: U$([p7, $$(p7)]) }); +var fP = _({ type: f("boolean"), title: F().optional(), description: F().optional(), default: S$().optional() }); +var gP = _({ type: f("string"), title: F().optional(), description: F().optional(), minLength: G$().optional(), maxLength: G$().optional(), format: d$(["email", "uri", "date", "date-time"]).optional(), default: F().optional() }); +var hP = _({ type: d$(["number", "integer"]), title: F().optional(), description: F().optional(), minimum: G$().optional(), maximum: G$().optional(), default: G$().optional() }); +var uP = _({ type: f("string"), title: F().optional(), description: F().optional(), enum: $$(F()), default: F().optional() }); +var mP = _({ type: f("string"), title: F().optional(), description: F().optional(), oneOf: $$(_({ const: F(), title: F() })), default: F().optional() }); +var lP = _({ type: f("string"), title: F().optional(), description: F().optional(), enum: $$(F()), enumNames: $$(F()).optional(), default: F().optional() }); +var cP = U$([uP, mP]); +var pP = _({ type: f("array"), title: F().optional(), description: F().optional(), minItems: G$().optional(), maxItems: G$().optional(), items: _({ type: f("string"), enum: $$(F()) }), default: $$(F()).optional() }); +var iP = _({ type: f("array"), title: F().optional(), description: F().optional(), minItems: G$().optional(), maxItems: G$().optional(), items: _({ anyOf: $$(_({ const: F(), title: F() })) }), default: $$(F()).optional() }); +var nP = U$([pP, iP]); +var dP = U$([lP, cP, nP]); +var rP = U$([dP, fP, gP, hP]); +var oP = N9.extend({ mode: f("form").optional(), message: F(), requestedSchema: _({ type: f("object"), properties: w$(F(), rP), required: $$(F()).optional() }) }); +var tP = N9.extend({ mode: f("url"), message: F(), elicitationId: F(), url: F().url() }); +var aP = U$([oP, tP]); +var sP = f$.extend({ method: f("elicitation/create"), params: aP }); +var eP = b6.extend({ elicitationId: F() }); +var $Z = P6.extend({ method: f("notifications/elicitation/complete"), params: eP }); +var T0 = g$.extend({ action: d$(["accept", "decline", "cancel"]), content: c7(($) => $ === null ? void 0 : $, w$(F(), U$([F(), G$(), S$(), $$(F())])).optional()) }); +var XZ = _({ type: f("ref/resource"), uri: F() }); +var JZ = _({ type: f("ref/prompt"), name: F() }); +var YZ = w6.extend({ ref: U$([JZ, XZ]), argument: _({ name: F(), value: F() }), context: _({ arguments: w$(F(), F()).optional() }).optional() }); +var KQ = f$.extend({ method: f("completion/complete"), params: YZ }); +var QZ = g$.extend({ completion: l$({ values: $$(F()).max(100), total: L$(G$().int()), hasMore: L$(S$()) }) }); +var zZ = _({ uri: F().startsWith("file://"), name: F().optional(), _meta: w$(F(), D$()).optional() }); +var WZ = f$.extend({ method: f("roots/list"), params: w6.optional() }); +var O3 = g$.extend({ roots: $$(zZ) }); +var GZ = P6.extend({ method: f("notifications/roots/list_changed"), params: b6.optional() }); +var Hn = U$([o7, Y3, KQ, N3, GQ, WQ, YQ, QQ, zQ, WP, UP, x0, UQ, a7, e7, $Q, JQ]); +var Kn = U$([r7, t7, Q3, GZ, D9]); +var Nn = U$([d7, F9, V3, T0, O3, s7, XQ, k0]); +var Vn = U$([o7, yP, sP, WZ, a7, e7, $Q, JQ]); +var On = U$([r7, t7, RP, KP, QP, PP, FP, D9, $Z]); +var wn = U$([d7, db, QZ, jP, OP, $P, XP, YP, HQ, AP, s7, XQ, k0]); +var KZ = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789"); +var rD = uU(BU(), 1); +var oD = uU(dD(), 1); +var sD; +(function($) { + $.Completable = "McpCompletable"; +})(sD || (sD = {})); +function QL($) { + let X; + return () => X != null ? X : X = $(); +} +var yx = QL(() => u4.object({ session_id: u4.string(), ws_url: u4.string(), work_dir: u4.string().optional(), session_key: u4.string().optional() })); +function HL($, X) { + var _a3; + let { systemPrompt: J, settings: Q, settingSources: Y, sandbox: z6, ...W } = $ != null ? $ : {}, G, U; + if (J === void 0) G = ""; + else if (typeof J === "string") G = J; + else if (J.type === "preset") U = J.append; + let H = W.pathToClaudeCodeExecutable; + if (!H) { + let r9 = (0, import_url.fileURLToPath)(import_meta.url), T1 = (0, import_path5.join)(r9, ".."); + H = (0, import_path5.join)(T1, "cli.js"); + } + process.env.CLAUDE_AGENT_SDK_VERSION = "0.2.92"; + let { abortController: K = y1(), additionalDirectories: V = [], agent: O, agents: N, allowedTools: w = [], betas: B, canUseTool: L, continue: j, cwd: I, debug: b, debugFile: x, disallowedTools: h = [], tools: B$, env: x$, executable: G6 = f1() ? "bun" : "node", executableArgs: o6 = [], extraArgs: u6 = {}, fallbackModel: a4, enableFileCheckpointing: _1, toolConfig: t6, forkSession: r0, hooks: p, includeHookEvents: n9, includePartialMessages: aQ, onElicitation: o0, persistSession: t0, thinking: s4, effort: d9, maxThinkingTokens: x1, maxTurns: p$, maxBudgetUsd: j4, taskBudget: a0, mcpServers: _U, model: NL, outputFormat: xU, permissionMode: VL = "default", allowDangerouslySkipPermissions: OL = false, permissionPromptToolName: wL, plugins: BL, workload: TU, resume: qL, resumeSessionAt: DL, sessionId: LL, stderr: jL, strictMcpConfig: FL } = W, yU = (xU == null ? void 0 : xU.type) === "json_schema" ? xU.schema : void 0, e4 = x$; + if (!e4) e4 = { ...process.env }; + if (!e4.CLAUDE_CODE_ENTRYPOINT) e4.CLAUDE_CODE_ENTRYPOINT = "sdk-ts"; + if (_1) e4.CLAUDE_CODE_ENABLE_SDK_FILE_CHECKPOINTING = "true"; + if ((_a3 = t6 == null ? void 0 : t6.askUserQuestion) == null ? void 0 : _a3.previewFormat) e4.CLAUDE_CODE_QUESTION_PREVIEW_FORMAT = t6.askUserQuestion.previewFormat; + let fU = {}, gU = /* @__PURE__ */ new Map(); + if (_U) for (let [r9, T1] of Object.entries(_U)) if (T1.type === "sdk" && T1.instance) gU.set(r9, T1.instance); + else fU[r9] = T1; + let s0; + if (s4) switch (s4.type) { + case "adaptive": + s0 = { type: "adaptive" }; + break; + case "enabled": + s0 = { type: "enabled", budgetTokens: s4.budgetTokens }; + break; + case "disabled": + s0 = { type: "disabled" }; + break; + } + else if (x1 !== void 0) s0 = x1 === 0 ? { type: "disabled" } : { type: "enabled", budgetTokens: x1 }; + let hU = new cX({ abortController: K, additionalDirectories: V, agent: O, betas: B, cwd: I, debug: b, debugFile: x, executable: G6, executableArgs: o6, extraArgs: TU ? { ...u6, workload: TU } : u6, pathToClaudeCodeExecutable: H, env: e4, forkSession: r0, stderr: jL, thinkingConfig: s0, effort: d9, maxTurns: p$, maxBudgetUsd: j4, taskBudget: a0, model: NL, fallbackModel: a4, jsonSchema: yU, permissionMode: VL, allowDangerouslySkipPermissions: OL, permissionPromptToolName: wL, continueConversation: j, resume: qL, resumeSessionAt: DL, sessionId: LL, settings: typeof Q === "object" ? q$(Q) : Q, settingSources: Y, allowedTools: w, disallowedTools: h, tools: B$, mcpServers: fU, strictMcpConfig: FL, canUseTool: !!L, hooks: !!p, includeHookEvents: n9, includePartialMessages: aQ, persistSession: t0, plugins: BL, sandbox: z6, spawnClaudeCodeProcess: W.spawnClaudeCodeProcess }), ML = { systemPrompt: G, appendSystemPrompt: U, agents: N, promptSuggestions: W.promptSuggestions, agentProgressSummaries: W.agentProgressSummaries }; + return { queryInstance: new pX(hU, X, L, p, K, gU, yU, ML, o0), transport: hU, abortController: K }; +} +function KL($, X, J, Q) { + if (typeof J === "string") X.write(q$({ type: "user", session_id: "", message: { role: "user", content: [{ type: "text", text: J }] }, parent_tool_use_id: null }) + ` +`); + else $.streamInput(J).catch((Y) => Q.abort(Y)); +} +function Qs({ prompt: $, options: X }) { + let { queryInstance: J, transport: Q, abortController: Y } = HL(X, typeof $ === "string"); + return KL(J, Q, $, Y), J; +} + +// src/providers/claude/runtime/claudeColdStartQuery.ts +init_env(); +init_path(); + +// src/providers/claude/aux/extractAssistantText.ts +function extractAssistantText(message) { + var _a3; + const content = (_a3 = message.message) == null ? void 0 : _a3.content; + if (message.type !== "assistant" || !Array.isArray(content)) { + return ""; + } + return content.filter( + (block) => !!block && typeof block === "object" && "type" in block && "text" in block && block.type === "text" && typeof block.text === "string" + ).map((block) => block.text).join(""); +} + +// src/providers/claude/types/models.ts +var DEFAULT_CLAUDE_MODELS = [ + { value: "haiku", label: "Haiku", description: "Fast and efficient" }, + { value: "sonnet", label: "Sonnet", description: "Balanced performance" }, + { value: "sonnet[1m]", label: "Sonnet 1M", description: "Balanced performance (1M context window)" }, + { value: "opus", label: "Opus", description: "Most capable" }, + { value: "opus[1m]", label: "Opus 1M", description: "Most capable (1M context window)" } +]; +var THINKING_BUDGETS = [ + { value: "off", label: "Off", tokens: 0 }, + { value: "low", label: "Low", tokens: 4e3 }, + { value: "medium", label: "Med", tokens: 8e3 }, + { value: "high", label: "High", tokens: 16e3 }, + { value: "xhigh", label: "Ultra", tokens: 32e3 } +]; +var EFFORT_LEVELS = [ + { value: "low", label: "Low" }, + { value: "medium", label: "Med" }, + { value: "high", label: "High" }, + { value: "max", label: "Max" } +]; +var DEFAULT_EFFORT_LEVEL = { + "haiku": "high", + "sonnet": "high", + "sonnet[1m]": "high", + "opus": "high", + "opus[1m]": "high" +}; +var DEFAULT_THINKING_BUDGET = { + "haiku": "off", + "sonnet": "low", + "sonnet[1m]": "low", + "opus": "medium", + "opus[1m]": "medium" +}; +var DEFAULT_MODEL_VALUES = new Set(DEFAULT_CLAUDE_MODELS.map((m3) => m3.value)); +function isAdaptiveThinkingModel(model) { + if (DEFAULT_MODEL_VALUES.has(model)) return true; + return /claude-(haiku|sonnet|opus)-/.test(model); +} +var CONTEXT_WINDOW_STANDARD = 2e5; +var CONTEXT_WINDOW_1M = 1e6; +function filterVisibleModelOptions(models, enableOpus1M, enableSonnet1M) { + return models.filter((model) => { + if (model.value === "opus" || model.value === "opus[1m]") { + return enableOpus1M ? model.value === "opus[1m]" : model.value === "opus"; + } + if (model.value === "sonnet" || model.value === "sonnet[1m]") { + return enableSonnet1M ? model.value === "sonnet[1m]" : model.value === "sonnet"; + } + return true; + }); +} +function normalizeVisibleModelVariant(model, enableOpus1M, enableSonnet1M) { + if (model === "opus" || model === "opus[1m]") { + return enableOpus1M ? "opus[1m]" : "opus"; + } + if (model === "sonnet" || model === "sonnet[1m]") { + return enableSonnet1M ? "sonnet[1m]" : "sonnet"; + } + return model; +} +function getContextWindowSize(model, customLimits) { + if (customLimits && model in customLimits) { + const limit = customLimits[model]; + if (typeof limit === "number" && limit > 0 && !isNaN(limit) && isFinite(limit)) { + return limit; + } + } + if (model.endsWith("[1m]")) { + return CONTEXT_WINDOW_1M; + } + return CONTEXT_WINDOW_STANDARD; +} + +// src/providers/claude/runtime/customSpawn.ts +var import_child_process3 = require("child_process"); +init_env(); +function createCustomSpawnFunction(enhancedPath) { + return (options) => { + let { command } = options; + const { args, cwd, env, signal } = options; + const shouldPipeStderr = !!(env == null ? void 0 : env.DEBUG_CLAUDE_AGENT_SDK); + if (command === "node") { + const nodeFullPath = findNodeExecutable(enhancedPath); + if (nodeFullPath) { + command = nodeFullPath; + } + } + const child = (0, import_child_process3.spawn)(command, args, { + cwd, + env, + stdio: ["pipe", "pipe", shouldPipeStderr ? "pipe" : "ignore"], + windowsHide: true + }); + if (signal) { + if (signal.aborted) { + child.kill(); + } else { + signal.addEventListener("abort", () => child.kill(), { once: true }); + } + } + if (shouldPipeStderr && child.stderr && typeof child.stderr.on === "function") { + child.stderr.on("data", () => { + }); + } + if (!child.stdin || !child.stdout) { + throw new Error("Failed to create process streams"); + } + return child; + }; +} + +// src/providers/claude/runtime/claudeColdStartQuery.ts +async function runColdStartQuery(config2, prompt) { + var _a3, _b2, _c, _d, _e; + const vaultPath = getVaultPath(config2.plugin.app); + if (!vaultPath) { + throw new Error("Could not determine vault path"); + } + const resolvedClaudePath = config2.plugin.getResolvedProviderCliPath("claude"); + if (!resolvedClaudePath) { + throw new Error("Claude CLI not found"); + } + const customEnv = parseEnvironmentVariables( + config2.plugin.getActiveEnvironmentVariables("claude") + ); + const enhancedPath = getEnhancedPath(customEnv.PATH, resolvedClaudePath); + const missingNodeError = getMissingNodeError(resolvedClaudePath, enhancedPath); + if (missingNodeError) { + throw new Error(missingNodeError); + } + const settings11 = (_a3 = config2.providerSettings) != null ? _a3 : ProviderSettingsCoordinator.getProviderSettingsSnapshot( + config2.plugin.settings, + "claude" + ); + const claudeSettings = getClaudeProviderSettings(settings11); + const selectedModel = (_b2 = config2.model) != null ? _b2 : settings11.model; + const options = { + cwd: vaultPath, + systemPrompt: config2.systemPrompt, + model: selectedModel, + abortController: config2.abortController, + pathToClaudeCodeExecutable: resolvedClaudePath, + env: { + ...process.env, + ...customEnv, + PATH: enhancedPath + }, + permissionMode: "bypassPermissions", + allowDangerouslySkipPermissions: true, + settingSources: claudeSettings.loadUserSettings ? ["user", "project"] : ["project"], + spawnClaudeCodeProcess: createCustomSpawnFunction(enhancedPath) + }; + if (config2.tools !== void 0) { + options.tools = config2.tools; + } + if (config2.hooks) { + options.hooks = config2.hooks; + } + if (config2.persistSession === false) { + options.persistSession = false; + } + if (config2.resumeSessionId) { + options.resume = config2.resumeSessionId; + } + if (!((_c = config2.thinking) == null ? void 0 : _c.disabled)) { + if (isAdaptiveThinkingModel(selectedModel)) { + options.thinking = { type: "adaptive" }; + options.effort = settings11.effortLevel; + } else { + const budgetConfig = THINKING_BUDGETS.find( + (b) => b.value === settings11.thinkingBudget + ); + if (budgetConfig && budgetConfig.tokens > 0) { + options.maxThinkingTokens = budgetConfig.tokens; + } + } + } + const response = Qs({ prompt, options }); + let responseText = ""; + let sessionId = null; + for await (const message of response) { + if ((_d = config2.abortController) == null ? void 0 : _d.signal.aborted) { + await response.interrupt(); + throw new Error("Cancelled"); + } + if (message.type === "system" && message.subtype === "init" && message.session_id) { + sessionId = message.session_id; + } + const text = extractAssistantText(message); + if (text) { + responseText += text; + (_e = config2.onTextChunk) == null ? void 0 : _e.call(config2, responseText); + } + } + return { text: responseText, sessionId }; +} + +// src/providers/claude/aux/ClaudeInlineEditService.ts +function createReadOnlyHook() { + return { + hooks: [ + async (hookInput) => { + const input = hookInput; + const toolName = input.tool_name; + if (isReadOnlyTool(toolName)) { + return { continue: true }; + } + return { + continue: false, + hookSpecificOutput: { + hookEventName: "PreToolUse", + permissionDecision: "deny", + permissionDecisionReason: `Inline edit mode: tool "${toolName}" is not allowed (read-only)` + } + }; + } + ] + }; +} +var InlineEditService = class { + constructor(plugin) { + this.abortController = null; + this.sessionId = null; + this.plugin = plugin; + } + getScopedSettings() { + return ProviderSettingsCoordinator.getProviderSettingsSnapshot( + this.plugin.settings, + "claude" + ); + } + resetConversation() { + this.sessionId = null; + } + async editText(request) { + this.sessionId = null; + const prompt = buildInlineEditPrompt(request); + return this.sendMessage(prompt); + } + async continueConversation(message, contextFiles) { + if (!this.sessionId) { + return { success: false, error: "No active conversation to continue" }; + } + let prompt = message; + if (contextFiles && contextFiles.length > 0) { + prompt = appendContextFiles(message, contextFiles); + } + return this.sendMessage(prompt); + } + async sendMessage(prompt) { + var _a3; + const settings11 = this.getScopedSettings(); + this.abortController = new AbortController(); + const hooks = { + PreToolUse: [createReadOnlyHook()] + }; + try { + const result = await runColdStartQuery({ + plugin: this.plugin, + systemPrompt: getInlineEditSystemPrompt(), + tools: [...READ_ONLY_TOOLS], + hooks, + resumeSessionId: (_a3 = this.sessionId) != null ? _a3 : void 0, + abortController: this.abortController, + providerSettings: settings11 + }, prompt); + this.sessionId = result.sessionId; + return parseInlineEditResponse(result.text); + } catch (error48) { + const msg = error48 instanceof Error ? error48.message : "Unknown error"; + return { success: false, error: msg }; + } finally { + this.abortController = null; + } + } + cancel() { + if (this.abortController) { + this.abortController.abort(); + } + } +}; + +// src/core/prompt/instructionRefine.ts +function buildRefineSystemPrompt(existingInstructions) { + const existingSection = existingInstructions.trim() ? ` + +EXISTING INSTRUCTIONS (already in the user's system prompt): +\`\`\` +${existingInstructions.trim()} +\`\`\` + +When refining the new instruction: +- Consider how it fits with existing instructions +- Avoid duplicating existing instructions +- If the new instruction conflicts with an existing one, refine it to be complementary or note the conflict +- Match the format of existing instructions (section, heading, bullet points, style, etc.)` : ""; + return `You are an expert Prompt Engineer. You help users craft precise, effective system instructions for their AI assistant. + +**Your Goal**: Transform vague or simple user requests into **high-quality, actionable, and non-conflicting** system prompt instructions. + +**Process**: +1. **Analyze Intent**: What behavior does the user want to enforce or change? +2. **Check Context**: Does this conflict with existing instructions? + - *No Conflict*: Add as new. + - *Conflict*: Propose a **merged instruction** that resolves the contradiction (or ask if unsure). +3. **Refine**: Draft a clear, positive instruction (e.g., "Do X" instead of "Don't do Y"). +4. **Format**: Return *only* the Markdown snippet wrapped in \`\` tags. + +**Guidelines**: +- **Clarity**: Use precise language. Avoid ambiguity. +- **Scope**: Keep it focused. Don't add unrelated rules. +- **Format**: Valid Markdown (bullets \`-\` or sections \`##\`). +- **No Header**: Do NOT include a top-level header like \`# Custom Instructions\`. +- **Conflict Handling**: If the new rule directly contradicts an existing one, rewrite the *new* one to override specific cases or ask for clarification. + +**Output Format**: +- **Success**: \`...markdown content...\` +- **Ambiguity**: Plain text question. + +${existingSection} + +**Examples**: + +Input: "typescript for code" +Output: - **Code Language**: Always use TypeScript for code examples. Include proper type annotations and interfaces. + +Input: "be concise" +Output: - **Conciseness**: Provide brief, direct responses. Omit conversational filler and unnecessary explanations. + +Input: "organize coding style rules" +Output: ## Coding Standards + +- **Language**: Use TypeScript. +- **Style**: Prefer functional patterns. +- **Review**: Keep diffs small. + +Input: "use that thing from before" +Output: I'm not sure what you're referring to. Could you please clarify?`; +} + +// src/providers/claude/aux/ClaudeInstructionRefineService.ts +var InstructionRefineService = class { + constructor(plugin) { + this.abortController = null; + this.sessionId = null; + this.existingInstructions = ""; + this.plugin = plugin; + } + resetConversation() { + this.sessionId = null; + } + async refineInstruction(rawInstruction, existingInstructions, onProgress) { + this.sessionId = null; + this.existingInstructions = existingInstructions; + const prompt = `Please refine this instruction: "${rawInstruction}"`; + return this.sendMessage(prompt, onProgress); + } + async continueConversation(message, onProgress) { + if (!this.sessionId) { + return { success: false, error: "No active conversation to continue" }; + } + return this.sendMessage(message, onProgress); + } + cancel() { + if (this.abortController) { + this.abortController.abort(); + this.abortController = null; + } + } + async sendMessage(prompt, onProgress) { + var _a3; + this.abortController = new AbortController(); + try { + const result = await runColdStartQuery({ + plugin: this.plugin, + systemPrompt: buildRefineSystemPrompt(this.existingInstructions), + tools: [], + resumeSessionId: (_a3 = this.sessionId) != null ? _a3 : void 0, + abortController: this.abortController, + onTextChunk: onProgress ? (accumulatedText) => onProgress(this.parseResponse(accumulatedText)) : void 0 + }, prompt); + this.sessionId = result.sessionId; + return this.parseResponse(result.text); + } catch (error48) { + const msg = error48 instanceof Error ? error48.message : "Unknown error"; + return { success: false, error: msg }; + } finally { + this.abortController = null; + } + } + parseResponse(responseText) { + const instructionMatch = responseText.match(/([\s\S]*?)<\/instruction>/); + if (instructionMatch) { + return { success: true, refinedInstruction: instructionMatch[1].trim() }; + } + const trimmed = responseText.trim(); + if (trimmed) { + return { success: true, clarification: trimmed }; + } + return { success: false, error: "Empty response" }; + } +}; + +// src/core/prompt/titleGeneration.ts +var TITLE_GENERATION_SYSTEM_PROMPT = `You are a specialist in summarizing user intent. + +**Task**: Generate a **concise, descriptive title** (max 50 chars) summarizing the user's task/request. + +**Rules**: +1. **Format**: Sentence case. No periods/quotes. +2. **Structure**: Start with a **strong verb** (e.g., Create, Fix, Debug, Explain, Analyze). +3. **Forbidden**: "Conversation with...", "Help me...", "Question about...", "I need...". +4. **Tech Context**: Detect and include the primary language/framework if code is present (e.g., "Debug Python script", "Refactor React hook"). + +**Output**: Return ONLY the raw title text.`; + +// src/providers/claude/aux/ClaudeTitleGenerationService.ts +init_env(); +var TitleGenerationService = class { + constructor(plugin) { + this.activeGenerations = /* @__PURE__ */ new Map(); + this.plugin = plugin; + } + async generateTitle(conversationId, userMessage, callback) { + const existingController = this.activeGenerations.get(conversationId); + if (existingController) { + existingController.abort(); + } + const abortController = new AbortController(); + this.activeGenerations.set(conversationId, abortController); + const truncatedUser = this.truncateText(userMessage, 500); + const prompt = `User's request: +""" +${truncatedUser} +""" + +Generate a title for this conversation:`; + try { + const result = await runColdStartQuery({ + plugin: this.plugin, + systemPrompt: TITLE_GENERATION_SYSTEM_PROMPT, + tools: [], + model: this.resolveTitleModel(), + thinking: { disabled: true }, + persistSession: false, + abortController + }, prompt); + const title = this.parseTitle(result.text); + if (title) { + await this.safeCallback(callback, conversationId, { success: true, title }); + } else { + await this.safeCallback(callback, conversationId, { + success: false, + error: "Failed to parse title from response" + }); + } + } catch (error48) { + const msg = error48 instanceof Error ? error48.message : "Unknown error"; + await this.safeCallback(callback, conversationId, { success: false, error: msg }); + } finally { + this.activeGenerations.delete(conversationId); + } + } + cancel() { + for (const controller of this.activeGenerations.values()) { + controller.abort(); + } + this.activeGenerations.clear(); + } + resolveTitleModel() { + const envVars = parseEnvironmentVariables( + this.plugin.getActiveEnvironmentVariables("claude") + ); + return this.plugin.settings.titleGenerationModel || envVars.ANTHROPIC_DEFAULT_HAIKU_MODEL || "claude-haiku-4-5"; + } + truncateText(text, maxLength) { + if (text.length <= maxLength) return text; + return text.substring(0, maxLength) + "..."; + } + parseTitle(responseText) { + const trimmed = responseText.trim(); + if (!trimmed) return null; + let title = trimmed; + if (title.startsWith('"') && title.endsWith('"') || title.startsWith("'") && title.endsWith("'")) { + title = title.slice(1, -1); + } + title = title.replace(/[.!?:;,]+$/, ""); + if (title.length > 50) { + title = title.substring(0, 47) + "..."; + } + return title || null; + } + async safeCallback(callback, conversationId, result) { + try { + await callback(conversationId, result); + } catch (e3) { + } + } +}; + +// src/providers/claude/capabilities.ts +var CLAUDE_PROVIDER_CAPABILITIES = Object.freeze({ + providerId: "claude", + supportsPersistentRuntime: true, + supportsNativeHistory: true, + supportsPlanMode: true, + supportsRewind: true, + supportsFork: true, + supportsProviderCommands: true, + supportsImageAttachments: true, + supportsInstructionMode: true, + supportsMcpTools: true, + supportsTurnSteer: false, + reasoningControl: "effort", + planPathPrefix: "/.claude/plans/" +}); + +// src/providers/claude/env/ClaudeSettingsReconciler.ts +init_env(); + +// src/providers/claude/env/claudeModelEnv.ts +var CUSTOM_MODEL_ENV_KEYS = [ + "ANTHROPIC_MODEL", + "ANTHROPIC_DEFAULT_OPUS_MODEL", + "ANTHROPIC_DEFAULT_SONNET_MODEL", + "ANTHROPIC_DEFAULT_HAIKU_MODEL" +]; +function getModelTypeFromEnvKey(envKey) { + if (envKey === "ANTHROPIC_MODEL") return "model"; + const match = envKey.match(/ANTHROPIC_DEFAULT_(\w+)_MODEL/); + return match ? match[1].toLowerCase() : envKey; +} +function getModelsFromEnvironment(envVars) { + const modelMap = /* @__PURE__ */ new Map(); + for (const envKey of CUSTOM_MODEL_ENV_KEYS) { + const type = getModelTypeFromEnvKey(envKey); + const modelValue = envVars[envKey]; + if (modelValue) { + const label = modelValue.includes("/") ? modelValue.split("/").pop() || modelValue : modelValue.replace(/-/g, " ").replace(/\b\w/g, (l3) => l3.toUpperCase()); + if (!modelMap.has(modelValue)) { + modelMap.set(modelValue, { types: [type], label }); + } else { + modelMap.get(modelValue).types.push(type); + } + } + } + const models = []; + const typePriority = { "model": 4, "haiku": 3, "sonnet": 2, "opus": 1 }; + const sortedEntries = Array.from(modelMap.entries()).sort(([, aInfo], [, bInfo]) => { + const aPriority = Math.max(...aInfo.types.map((t3) => typePriority[t3] || 0)); + const bPriority = Math.max(...bInfo.types.map((t3) => typePriority[t3] || 0)); + return bPriority - aPriority; + }); + for (const [modelValue, info] of sortedEntries) { + const sortedTypes = info.types.sort( + (a3, b) => (typePriority[b] || 0) - (typePriority[a3] || 0) + ); + models.push({ + value: modelValue, + label: info.label, + description: `Custom model (${sortedTypes.join(", ")})` + }); + } + return models; +} +function getCurrentModelFromEnvironment(envVars) { + if (envVars.ANTHROPIC_MODEL) { + return envVars.ANTHROPIC_MODEL; + } + if (envVars.ANTHROPIC_DEFAULT_HAIKU_MODEL) { + return envVars.ANTHROPIC_DEFAULT_HAIKU_MODEL; + } + if (envVars.ANTHROPIC_DEFAULT_SONNET_MODEL) { + return envVars.ANTHROPIC_DEFAULT_SONNET_MODEL; + } + if (envVars.ANTHROPIC_DEFAULT_OPUS_MODEL) { + return envVars.ANTHROPIC_DEFAULT_OPUS_MODEL; + } + return null; +} +function getCustomModelIds(envVars) { + const modelIds = /* @__PURE__ */ new Set(); + for (const envKey of CUSTOM_MODEL_ENV_KEYS) { + const modelId = envVars[envKey]; + if (modelId) { + modelIds.add(modelId); + } + } + return modelIds; +} + +// src/providers/claude/env/ClaudeSettingsReconciler.ts +var ENV_HASH_MODEL_KEYS = [ + "ANTHROPIC_MODEL", + "ANTHROPIC_DEFAULT_OPUS_MODEL", + "ANTHROPIC_DEFAULT_SONNET_MODEL", + "ANTHROPIC_DEFAULT_HAIKU_MODEL" +]; +var ENV_HASH_PROVIDER_KEYS = ["ANTHROPIC_BASE_URL"]; +function computeEnvHash(envText) { + const envVars = parseEnvironmentVariables(envText || ""); + const allKeys = [...ENV_HASH_MODEL_KEYS, ...ENV_HASH_PROVIDER_KEYS]; + return allKeys.filter((key) => envVars[key]).map((key) => `${key}=${envVars[key]}`).sort().join("|"); +} +var claudeSettingsReconciler = { + reconcileModelWithEnvironment(settings11, conversations) { + const envText = getRuntimeEnvironmentText(settings11, "claude"); + const currentHash = computeEnvHash(envText); + const savedHash = getClaudeProviderSettings(settings11).environmentHash; + if (currentHash === savedHash) { + return { changed: false, invalidatedConversations: [] }; + } + const invalidatedConversations = []; + for (const conv of conversations) { + if (conv.sessionId) { + conv.sessionId = null; + invalidatedConversations.push(conv); + } + } + const envVars = parseEnvironmentVariables(envText || ""); + const customModels = getModelsFromEnvironment(envVars); + if (customModels.length > 0) { + const envPreferred = getCurrentModelFromEnvironment(envVars); + if (envPreferred && customModels.some((m3) => m3.value === envPreferred)) { + settings11.model = envPreferred; + } else { + settings11.model = customModels[0].value; + } + } else { + settings11.model = DEFAULT_CLAUDE_MODELS[0].value; + } + updateClaudeProviderSettings(settings11, { environmentHash: currentHash }); + return { changed: true, invalidatedConversations }; + }, + normalizeModelVariantSettings(settings11) { + const claudeSettings = getClaudeProviderSettings(settings11); + let changed = false; + const normalize3 = (model2) => normalizeVisibleModelVariant( + model2, + claudeSettings.enableOpus1M, + claudeSettings.enableSonnet1M + ); + const model = settings11.model; + const normalizedModel = normalize3(model); + if (model !== normalizedModel) { + settings11.model = normalizedModel; + changed = true; + } + const titleModel = settings11.titleGenerationModel; + if (titleModel) { + const normalizedTitleModel = normalize3(titleModel); + if (titleModel !== normalizedTitleModel) { + settings11.titleGenerationModel = normalizedTitleModel; + changed = true; + } + } + const lastClaudeModel = claudeSettings.lastModel; + if (lastClaudeModel) { + const normalizedLastClaudeModel = normalize3(lastClaudeModel); + if (lastClaudeModel !== normalizedLastClaudeModel) { + updateClaudeProviderSettings(settings11, { lastModel: normalizedLastClaudeModel }); + changed = true; + } + } + return changed; + } +}; + +// src/providers/claude/types/providerState.ts +function getClaudeState(providerState) { + return providerState != null ? providerState : {}; +} + +// src/providers/claude/history/sdkAsyncSubagent.ts +function extractAgentIdFromToolUseResult(toolUseResult) { + var _a3, _b2; + if (!toolUseResult || typeof toolUseResult !== "object") { + return null; + } + const record2 = toolUseResult; + const directAgentId = (_a3 = record2.agentId) != null ? _a3 : record2.agent_id; + if (typeof directAgentId === "string" && directAgentId.length > 0) { + return directAgentId; + } + const data = record2.data; + if (data && typeof data === "object") { + const nested = data; + const nestedAgentId = (_b2 = nested.agent_id) != null ? _b2 : nested.agentId; + if (typeof nestedAgentId === "string" && nestedAgentId.length > 0) { + return nestedAgentId; + } + } + return null; +} +function resolveToolUseResultStatus(toolUseResult, fallbackStatus) { + var _a3; + if (!toolUseResult || typeof toolUseResult !== "object") { + return fallbackStatus; + } + const record2 = toolUseResult; + const rawStatus = (_a3 = record2.retrieval_status) != null ? _a3 : record2.status; + const status = typeof rawStatus === "string" ? rawStatus.toLowerCase() : ""; + if (status === "error") { + return "error"; + } + if (status === "completed" || status === "success") { + return "completed"; + } + if (record2.isAsync === true || status === "async_launched") { + return "running"; + } + return fallbackStatus; +} +function buildAsyncSubagentInfo(toolCall, toolUseResult, asyncResults) { + var _a3, _b2, _c; + const agentId = extractAgentIdFromToolUseResult(toolUseResult); + if (!agentId) { + return null; + } + const queueResult = asyncResults.get(agentId); + const description = ((_a3 = toolCall.input) == null ? void 0 : _a3.description) || "Background task"; + const prompt = ((_b2 = toolCall.input) == null ? void 0 : _b2.prompt) || ""; + const finalResult = (_c = queueResult == null ? void 0 : queueResult.result) != null ? _c : toolCall.result; + let toolCallFallback = "running"; + if (toolCall.status === "error") { + toolCallFallback = "error"; + } else if (toolCall.status === "completed") { + toolCallFallback = "completed"; + } + const status = queueResult ? resolveToolUseResultStatus({ status: queueResult.status }, "completed") : resolveToolUseResultStatus(toolUseResult, toolCallFallback); + const taskStatus = status === "orphaned" ? "error" : status; + return { + id: toolCall.id, + description, + prompt, + mode: "async", + isExpanded: false, + status: taskStatus, + toolCalls: [], + asyncStatus: status, + agentId, + result: finalResult + }; +} + +// src/providers/claude/history/sdkBranchFilter.ts +function filterActiveBranch(entries, resumeAtMessageId) { + var _a3, _b2; + if (entries.length === 0) { + return []; + } + function isRealUserBranchChild(entry) { + return !!entry && entry.type === "user" && !("toolUseResult" in entry) && !entry.isMeta && !("sourceToolUseID" in entry); + } + function isDirectRealUserBranchChild(parentUuid, entry) { + return !!entry && entry.parentUuid === parentUuid && isRealUserBranchChild(entry); + } + const seen = /* @__PURE__ */ new Set(); + const deduped = []; + for (const entry of entries) { + if (entry.uuid) { + if (seen.has(entry.uuid)) { + continue; + } + seen.add(entry.uuid); + } + deduped.push(entry); + } + const progressUuids = /* @__PURE__ */ new Set(); + const progressParentOf = /* @__PURE__ */ new Map(); + for (const entry of deduped) { + if (entry.type === "progress" && entry.uuid) { + progressUuids.add(entry.uuid); + progressParentOf.set(entry.uuid, (_a3 = entry.parentUuid) != null ? _a3 : null); + } + } + function resolveParent(parentUuid) { + var _a4; + if (!parentUuid) { + return parentUuid; + } + let current2 = parentUuid; + let guard = progressUuids.size + 1; + while (current2 && progressUuids.has(current2)) { + if (--guard < 0) { + break; + } + current2 = (_a4 = progressParentOf.get(current2)) != null ? _a4 : null; + } + return current2; + } + const conversationEntries = deduped.filter((entry) => entry.type !== "progress"); + const byUuid = /* @__PURE__ */ new Map(); + const childrenOf = /* @__PURE__ */ new Map(); + for (const entry of conversationEntries) { + if (entry.uuid) { + byUuid.set(entry.uuid, entry); + } + const effectiveParent = (_b2 = resolveParent(entry.parentUuid)) != null ? _b2 : null; + if (effectiveParent && entry.uuid) { + let children = childrenOf.get(effectiveParent); + if (!children) { + children = /* @__PURE__ */ new Set(); + childrenOf.set(effectiveParent, children); + } + children.add(entry.uuid); + } + } + function findLatestLeaf() { + for (let i3 = conversationEntries.length - 1; i3 >= 0; i3--) { + const uuid3 = conversationEntries[i3].uuid; + if (uuid3 && !childrenOf.has(uuid3)) { + return conversationEntries[i3]; + } + } + return void 0; + } + const latestLeaf = findLatestLeaf(); + const latestBranchUuids = /* @__PURE__ */ new Set(); + const activeChildOf = /* @__PURE__ */ new Map(); + let latestCurrent = latestLeaf; + while (latestCurrent == null ? void 0 : latestCurrent.uuid) { + latestBranchUuids.add(latestCurrent.uuid); + const parent = resolveParent(latestCurrent.parentUuid); + if (parent) { + activeChildOf.set(parent, latestCurrent.uuid); + } + latestCurrent = parent ? byUuid.get(parent) : void 0; + } + const conversationContentCache = /* @__PURE__ */ new Map(); + function hasConversationContent(uuid3) { + const cached2 = conversationContentCache.get(uuid3); + if (cached2 !== void 0) { + return cached2; + } + const entry = byUuid.get(uuid3); + let result = false; + if ((entry == null ? void 0 : entry.type) === "assistant") { + result = true; + } else if ((entry == null ? void 0 : entry.type) === "user" && !entry.isMeta && !("sourceToolUseID" in entry)) { + result = true; + } else { + const children = childrenOf.get(uuid3); + if (children) { + for (const childUuid of children) { + if (hasConversationContent(childUuid)) { + result = true; + break; + } + } + } + } + conversationContentCache.set(uuid3, result); + return result; + } + const hasBranching = [...latestBranchUuids].some((uuid3) => { + const children = childrenOf.get(uuid3); + if (!children || children.size <= 1) { + return false; + } + const activeChildUuid = activeChildOf.get(uuid3); + let sawRealUserChild = false; + let sawAlternateConversationChild = false; + for (const childUuid of children) { + const child = byUuid.get(childUuid); + if (isDirectRealUserBranchChild(uuid3, child)) { + sawRealUserChild = true; + } + if (childUuid !== activeChildUuid && hasConversationContent(childUuid)) { + sawAlternateConversationChild = true; + } + if (sawRealUserChild && sawAlternateConversationChild) { + return true; + } + } + return false; + }); + let leaf; + if (hasBranching) { + leaf = latestLeaf; + if (resumeAtMessageId && (leaf == null ? void 0 : leaf.uuid) && byUuid.has(resumeAtMessageId)) { + let current2 = leaf; + while (current2 == null ? void 0 : current2.uuid) { + if (current2.uuid === resumeAtMessageId) { + leaf = current2; + break; + } + const parent = resolveParent(current2.parentUuid); + current2 = parent ? byUuid.get(parent) : void 0; + } + } + } else if (resumeAtMessageId) { + leaf = byUuid.get(resumeAtMessageId); + } else { + return conversationEntries; + } + if (!(leaf == null ? void 0 : leaf.uuid)) { + return conversationEntries; + } + const activeUuids = /* @__PURE__ */ new Set(); + let current = leaf; + while (current == null ? void 0 : current.uuid) { + activeUuids.add(current.uuid); + const parent = resolveParent(current.parentUuid); + current = parent ? byUuid.get(parent) : void 0; + } + if (hasBranching) { + const ancestorUuids = [...activeUuids]; + const pending = []; + for (const uuid3 of ancestorUuids) { + const children = childrenOf.get(uuid3); + if (!children || children.size <= 1) { + continue; + } + const activeChildUuid = activeChildOf.get(uuid3); + if (activeChildUuid && isDirectRealUserBranchChild(uuid3, byUuid.get(activeChildUuid))) { + continue; + } + for (const childUuid of children) { + if (activeUuids.has(childUuid)) { + continue; + } + const child = byUuid.get(childUuid); + if (!child || isRealUserBranchChild(child)) { + continue; + } + activeUuids.add(childUuid); + pending.push(childUuid); + } + } + while (pending.length > 0) { + const parentUuid = pending.pop(); + const children = childrenOf.get(parentUuid); + if (!children) { + continue; + } + for (const childUuid of children) { + if (activeUuids.has(childUuid)) { + continue; + } + const child = byUuid.get(childUuid); + if (!child || isRealUserBranchChild(child)) { + continue; + } + activeUuids.add(childUuid); + pending.push(childUuid); + } + } + } + const entryCount = conversationEntries.length; + const prevIsActive = new Array(entryCount); + const nextIsActive = new Array(entryCount); + let lastPrevActive = false; + for (let i3 = 0; i3 < entryCount; i3++) { + if (conversationEntries[i3].uuid) { + lastPrevActive = activeUuids.has(conversationEntries[i3].uuid); + } + prevIsActive[i3] = lastPrevActive; + } + let lastNextActive = false; + for (let i3 = entryCount - 1; i3 >= 0; i3--) { + if (conversationEntries[i3].uuid) { + lastNextActive = activeUuids.has(conversationEntries[i3].uuid); + } + nextIsActive[i3] = lastNextActive; + } + return conversationEntries.filter((entry, idx) => { + if (entry.uuid) { + return activeUuids.has(entry.uuid); + } + return prevIsActive[idx] && nextIsActive[idx]; + }); +} + +// src/core/tools/toolInput.ts +function extractResolvedAnswers(toolUseResult) { + if (typeof toolUseResult !== "object" || toolUseResult === null) return void 0; + const r3 = toolUseResult; + return normalizeAnswersObject(r3.answers); +} +function normalizeAnswerValue(value) { + if (typeof value === "string") return value; + if (Array.isArray(value)) { + const normalized = value.map((item) => typeof item === "string" ? item : String(item)).filter(Boolean).filter((item) => item.length > 0); + if (normalized.length === 0) return void 0; + return normalized.length === 1 ? normalized[0] : normalized; + } + if (typeof value === "object" && value !== null) { + const record2 = value; + if ("answers" in record2) return normalizeAnswerValue(record2.answers); + if ("answer" in record2) return normalizeAnswerValue(record2.answer); + if ("value" in record2) return normalizeAnswerValue(record2.value); + } + if (typeof value === "number" || typeof value === "boolean") return String(value); + return void 0; +} +function normalizeAnswersObject(value) { + if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0; + const answers = {}; + for (const [question, rawValue] of Object.entries(value)) { + const normalized = normalizeAnswerValue(rawValue); + if (normalized) { + answers[question] = normalized; + } + } + return Object.keys(answers).length > 0 ? answers : void 0; +} +function parseAnswersFromJsonObject(resultText) { + var _a3; + const start = resultText.indexOf("{"); + const end = resultText.lastIndexOf("}"); + if (start < 0 || end <= start) return void 0; + try { + const parsed = JSON.parse(resultText.slice(start, end + 1)); + if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) { + const record2 = parsed; + return (_a3 = normalizeAnswersObject(record2.answers)) != null ? _a3 : normalizeAnswersObject(parsed); + } + return normalizeAnswersObject(parsed); + } catch (e3) { + return void 0; + } +} +function parseAnswersFromQuotedPairs(resultText) { + var _a3, _b2; + const answers = {}; + const pattern = /"([^"]+)"="([^"]*)"/g; + for (const match of resultText.matchAll(pattern)) { + const question = (_a3 = match[1]) == null ? void 0 : _a3.trim(); + if (!question) continue; + answers[question] = (_b2 = match[2]) != null ? _b2 : ""; + } + return Object.keys(answers).length > 0 ? answers : void 0; +} +function extractResolvedAnswersFromResultText(result) { + var _a3; + if (typeof result !== "string") return void 0; + const trimmed = result.trim(); + if (!trimmed) return void 0; + return (_a3 = parseAnswersFromJsonObject(trimmed)) != null ? _a3 : parseAnswersFromQuotedPairs(trimmed); +} + +// src/utils/diff.ts +function structuredPatchToDiffLines(hunks) { + const result = []; + for (const hunk of hunks) { + let oldLineNum = hunk.oldStart; + let newLineNum = hunk.newStart; + for (const line of hunk.lines) { + const prefix = line[0]; + const text = line.slice(1); + if (prefix === "+") { + result.push({ type: "insert", text, newLineNum: newLineNum++ }); + } else if (prefix === "-") { + result.push({ type: "delete", text, oldLineNum: oldLineNum++ }); + } else { + result.push({ type: "equal", text, oldLineNum: oldLineNum++, newLineNum: newLineNum++ }); + } + } + } + return result; +} +function countLineChanges(diffLines) { + let added = 0; + let removed = 0; + for (const line of diffLines) { + if (line.type === "insert") added++; + else if (line.type === "delete") removed++; + } + return { added, removed }; +} +function parseApplyPatchDiffs(patchText) { + if (!patchText.trim()) return []; + const fileDiffs = []; + const lines = patchText.split(/\r?\n/); + let current = null; + const flushCurrent = () => { + if (!current) return; + fileDiffs.push(buildApplyPatchFileDiff(current)); + current = null; + }; + for (const line of lines) { + if (line.startsWith("*** Begin Patch") || line.startsWith("*** End Patch")) { + continue; + } + if (line.startsWith("*** Add File: ")) { + flushCurrent(); + current = { + filePath: line.slice("*** Add File: ".length).trim(), + operation: "add", + rawLines: [] + }; + continue; + } + if (line.startsWith("*** Update File: ")) { + flushCurrent(); + current = { + filePath: line.slice("*** Update File: ".length).trim(), + operation: "update", + rawLines: [] + }; + continue; + } + if (line.startsWith("*** Delete File: ")) { + flushCurrent(); + fileDiffs.push({ + filePath: line.slice("*** Delete File: ".length).trim(), + operation: "delete", + diffLines: [], + stats: { added: 0, removed: 0 } + }); + continue; + } + if (!current) continue; + if (line.startsWith("*** Move to: ")) { + current.movedTo = line.slice("*** Move to: ".length).trim(); + continue; + } + if (line === "*** End of File" || line.startsWith("@@") || line.startsWith("--- ") || line.startsWith("+++ ")) { + continue; + } + const prefix = line[0]; + if (prefix === "+" || prefix === "-" || prefix === " ") { + current.rawLines.push(line); + } + } + flushCurrent(); + return fileDiffs; +} +function extractDiffData(toolUseResult, toolCall) { + const filePath = toolCall.input.file_path || "file"; + if (toolUseResult && typeof toolUseResult === "object") { + const result = toolUseResult; + if (Array.isArray(result.structuredPatch) && result.structuredPatch.length > 0) { + const resultFilePath = (typeof result.filePath === "string" ? result.filePath : null) || filePath; + const hunks = result.structuredPatch; + const diffLines = structuredPatchToDiffLines(hunks); + const stats = countLineChanges(diffLines); + return { filePath: resultFilePath, diffLines, stats }; + } + } + return diffFromToolInput(toolCall, filePath); +} +function diffFromToolInput(toolCall, filePath) { + if (toolCall.name === "Edit") { + const oldStr = toolCall.input.old_string; + const newStr = toolCall.input.new_string; + if (typeof oldStr === "string" && typeof newStr === "string") { + const diffLines = []; + const oldLines = oldStr.split("\n"); + const newLines = newStr.split("\n"); + let oldLineNum = 1; + for (const line of oldLines) { + diffLines.push({ type: "delete", text: line, oldLineNum: oldLineNum++ }); + } + let newLineNum = 1; + for (const line of newLines) { + diffLines.push({ type: "insert", text: line, newLineNum: newLineNum++ }); + } + return { filePath, diffLines, stats: countLineChanges(diffLines) }; + } + } + if (toolCall.name === "Write") { + const content = toolCall.input.content; + if (typeof content === "string") { + const newLines = content.split("\n"); + const diffLines = newLines.map((text, i3) => ({ + type: "insert", + text, + newLineNum: i3 + 1 + })); + return { filePath, diffLines, stats: { added: newLines.length, removed: 0 } }; + } + } + return void 0; +} +function buildApplyPatchFileDiff(current) { + const diffLines = []; + let oldLineNum = 1; + let newLineNum = 1; + for (const line of current.rawLines) { + const prefix = line[0]; + const text = line.slice(1); + if (prefix === "+") { + diffLines.push({ type: "insert", text, newLineNum: newLineNum++ }); + continue; + } + if (prefix === "-") { + diffLines.push({ type: "delete", text, oldLineNum: oldLineNum++ }); + continue; + } + diffLines.push({ type: "equal", text, oldLineNum: oldLineNum++, newLineNum: newLineNum++ }); + } + const result = { + filePath: current.filePath, + operation: current.operation, + diffLines, + stats: countLineChanges(diffLines) + }; + if (current.movedTo) result.movedTo = current.movedTo; + return result; +} + +// src/utils/interrupt.ts +var INTERRUPT_MARKERS = /* @__PURE__ */ new Set([ + "[Request interrupted by user]", + "[Request interrupted by user for tool use]" +]); +var COMPACTION_CANCELED_STDERR_PATTERN = /^\s*Error:\s*Compaction canceled\.?\s*<\/local-command-stderr>$/i; +function normalize2(text) { + return text.trim(); +} +function isBracketInterruptText(text) { + return INTERRUPT_MARKERS.has(normalize2(text)); +} +function isCompactionCanceledStderr(text) { + return COMPACTION_CANCELED_STDERR_PATTERN.test(normalize2(text)); +} +function isInterruptSignalText(text) { + return isBracketInterruptText(text) || isCompactionCanceledStderr(text); +} + +// src/providers/claude/sdk/toolResultContent.ts +function extractToolResultContent(content, options) { + if (typeof content === "string") return content; + if (content == null) return ""; + if (Array.isArray(content)) { + const textParts = content.filter(isTextBlock).map((block) => block.text); + if (textParts.length > 0) return textParts.join("\n"); + if (content.length > 0) return JSON.stringify(content, null, options == null ? void 0 : options.fallbackIndent); + return ""; + } + return JSON.stringify(content, null, options == null ? void 0 : options.fallbackIndent); +} +function isTextBlock(block) { + if (!block || typeof block !== "object") return false; + const record2 = block; + return record2.type === "text" && typeof record2.text === "string"; +} + +// src/providers/claude/history/sdkMessageParsing.ts +function extractTextContent(content) { + if (!content) { + return ""; + } + if (typeof content === "string") { + return content; + } + return content.filter((block) => block.type === "text" && typeof block.text === "string" && block.text.trim() !== "(no content)").map((block) => block.text).join("\n"); +} +function isRebuiltContextContent(textContent) { + if (!/^(User|Assistant):\s/.test(textContent)) { + return false; + } + return textContent.includes("\n\nUser:") || textContent.includes("\n\nAssistant:") || textContent.includes("\n\nA:"); +} +function extractDisplayContent(textContent) { + return extractContentBeforeXmlContext(textContent); +} +function extractImages(content) { + if (!content || typeof content === "string") { + return void 0; + } + const imageBlocks = content.filter( + (block) => { + var _a3; + return block.type === "image" && !!((_a3 = block.source) == null ? void 0 : _a3.data); + } + ); + if (imageBlocks.length === 0) { + return void 0; + } + return imageBlocks.map((block, index) => ({ + id: `sdk-img-${Date.now()}-${index}`, + name: `image-${index + 1}`, + mediaType: block.source.media_type, + data: block.source.data, + size: Math.ceil(block.source.data.length * 0.75), + source: "paste" + })); +} +function extractToolCalls(content, toolResults) { + var _a3; + if (!content || typeof content === "string") { + return void 0; + } + const toolUses = content.filter( + (block) => block.type === "tool_use" && !!block.id && !!block.name + ); + if (toolUses.length === 0) { + return void 0; + } + const results = toolResults != null ? toolResults : /* @__PURE__ */ new Map(); + if (!toolResults) { + for (const block of content) { + if (block.type === "tool_result" && block.tool_use_id) { + results.set(block.tool_use_id, { + content: extractToolResultContent(block.content), + isError: (_a3 = block.is_error) != null ? _a3 : false + }); + } + } + } + return toolUses.map((block) => { + var _a4; + const result = results.get(block.id); + return { + id: block.id, + name: block.name, + input: (_a4 = block.input) != null ? _a4 : {}, + status: result ? result.isError ? "error" : "completed" : "running", + result: result == null ? void 0 : result.content, + isExpanded: false + }; + }); +} +function mapContentBlocks(content) { + if (!content || typeof content === "string") { + return void 0; + } + const blocks = []; + for (const block of content) { + switch (block.type) { + case "text": { + const text = block.text; + const trimmed = text == null ? void 0 : text.trim(); + if (text && trimmed && trimmed !== "(no content)") { + blocks.push({ type: "text", content: text }); + } + break; + } + case "thinking": + if (block.thinking) { + blocks.push({ type: "thinking", content: block.thinking }); + } + break; + case "tool_use": + if (block.id) { + blocks.push({ type: "tool_use", toolId: block.id }); + } + break; + default: + break; + } + } + return blocks.length > 0 ? blocks : void 0; +} +function parseSDKMessageToChat(sdkMsg, toolResults) { + var _a3; + if (sdkMsg.type === "file-history-snapshot") { + return null; + } + if (sdkMsg.type === "system") { + if (sdkMsg.subtype === "compact_boundary") { + const timestamp2 = sdkMsg.timestamp ? new Date(sdkMsg.timestamp).getTime() : Date.now(); + return { + id: sdkMsg.uuid || `compact-${timestamp2}-${Math.random().toString(36).slice(2)}`, + role: "assistant", + content: "", + timestamp: timestamp2, + contentBlocks: [{ type: "context_compacted" }] + }; + } + return null; + } + if (sdkMsg.type === "result") { + return null; + } + if (sdkMsg.type !== "user" && sdkMsg.type !== "assistant") { + return null; + } + const content = (_a3 = sdkMsg.message) == null ? void 0 : _a3.content; + const textContent = extractTextContent(content); + const images = sdkMsg.type === "user" ? extractImages(content) : void 0; + const hasToolUse = Array.isArray(content) && content.some((block) => block.type === "tool_use"); + const hasImages = !!images && images.length > 0; + if (!textContent && !hasToolUse && !hasImages && (!content || typeof content === "string")) { + return null; + } + const timestamp = sdkMsg.timestamp ? new Date(sdkMsg.timestamp).getTime() : Date.now(); + const commandNameMatch = sdkMsg.type === "user" ? textContent.match(/(\/[^<]+)<\/command-name>/) : null; + let displayContent; + if (sdkMsg.type === "user") { + displayContent = commandNameMatch ? commandNameMatch[1] : extractDisplayContent(textContent); + } + const isInterrupt = sdkMsg.type === "user" && isInterruptSignalText(textContent); + const isRebuiltContext = sdkMsg.type === "user" && isRebuiltContextContent(textContent); + return { + id: sdkMsg.uuid || `sdk-${timestamp}-${Math.random().toString(36).slice(2)}`, + role: sdkMsg.type, + content: textContent, + displayContent, + timestamp, + toolCalls: sdkMsg.type === "assistant" ? extractToolCalls(content, toolResults) : void 0, + contentBlocks: sdkMsg.type === "assistant" ? mapContentBlocks(content) : void 0, + images, + ...sdkMsg.type === "user" && sdkMsg.uuid && { userMessageId: sdkMsg.uuid }, + ...sdkMsg.type === "assistant" && sdkMsg.uuid && { assistantMessageId: sdkMsg.uuid }, + ...isInterrupt && { isInterrupt: true }, + ...isRebuiltContext && { isRebuiltContext: true } + }; +} +function collectToolResults(sdkMessages) { + var _a3, _b2; + const results = /* @__PURE__ */ new Map(); + for (const sdkMsg of sdkMessages) { + const content = (_a3 = sdkMsg.message) == null ? void 0 : _a3.content; + if (!content || typeof content === "string") { + continue; + } + for (const block of content) { + if (block.type === "tool_result" && block.tool_use_id) { + results.set(block.tool_use_id, { + content: extractToolResultContent(block.content), + isError: (_b2 = block.is_error) != null ? _b2 : false + }); + } + } + } + return results; +} +function collectStructuredPatchResults(sdkMessages) { + var _a3; + const results = /* @__PURE__ */ new Map(); + for (const sdkMsg of sdkMessages) { + if (sdkMsg.type !== "user" || !sdkMsg.toolUseResult) { + continue; + } + const content = (_a3 = sdkMsg.message) == null ? void 0 : _a3.content; + if (!content || typeof content === "string") { + continue; + } + for (const block of content) { + if (block.type === "tool_result" && block.tool_use_id) { + results.set(block.tool_use_id, sdkMsg.toolUseResult); + } + } + } + return results; +} +function collectAsyncSubagentResults(sdkMessages) { + const results = /* @__PURE__ */ new Map(); + for (const sdkMsg of sdkMessages) { + if (sdkMsg.type !== "queue-operation") { + continue; + } + if (sdkMsg.operation !== "enqueue") { + continue; + } + if (typeof sdkMsg.content !== "string") { + continue; + } + if (!sdkMsg.content.includes("")) { + continue; + } + const taskId = extractXmlTag(sdkMsg.content, "task-id"); + const status = extractXmlTag(sdkMsg.content, "status"); + const result = extractXmlTag(sdkMsg.content, "result"); + if (!taskId || !result) { + continue; + } + results.set(taskId, { + result, + status: status != null ? status : "completed" + }); + } + return results; +} +function extractXmlTag(content, tagName) { + const regex = new RegExp(`<${tagName}>\\s*([\\s\\S]*?)\\s*`, "i"); + const match = content.match(regex); + if (!match || !match[1]) { + return null; + } + const trimmed = match[1].trim(); + return trimmed.length > 0 ? trimmed : null; +} +function isSystemInjectedMessage(sdkMsg) { + var _a3; + if (sdkMsg.type !== "user") { + return false; + } + if ("toolUseResult" in sdkMsg || "sourceToolUseID" in sdkMsg || !!sdkMsg.isMeta) { + return true; + } + const text = extractTextContent((_a3 = sdkMsg.message) == null ? void 0 : _a3.content); + if (!text) { + return false; + } + if (text.includes("") && text.includes("")) { + return false; + } + if (isCompactionCanceledStderr(text)) { + return false; + } + if (text.startsWith("This session is being continued from a previous conversation")) { + return true; + } + if (text.includes("")) { + return true; + } + if (text.includes("") || text.includes("")) { + return true; + } + if (text.includes("")) { + return true; + } + return false; +} +function mergeAssistantMessage(target, source) { + if (source.content) { + target.content = target.content ? `${target.content} + +${source.content}` : source.content; + } + if (source.toolCalls) { + target.toolCalls = [...target.toolCalls || [], ...source.toolCalls]; + } + if (source.contentBlocks) { + target.contentBlocks = [...target.contentBlocks || [], ...source.contentBlocks]; + } + if (source.assistantMessageId) { + target.assistantMessageId = source.assistantMessageId; + } +} +function hydrateStructuredToolResults(messages, toolUseResults) { + var _a3; + if (toolUseResults.size === 0) { + return; + } + for (const msg of messages) { + if (msg.role !== "assistant" || !msg.toolCalls) { + continue; + } + for (const toolCall of msg.toolCalls) { + const toolUseResult = toolUseResults.get(toolCall.id); + if (!toolUseResult) { + continue; + } + if (!toolCall.diffData) { + toolCall.diffData = extractDiffData(toolUseResult, toolCall); + } + if (toolCall.name === TOOL_ASK_USER_QUESTION) { + const answers = (_a3 = extractResolvedAnswers(toolUseResult)) != null ? _a3 : extractResolvedAnswersFromResultText(toolCall.result); + if (answers) { + toolCall.resolvedAnswers = answers; + } + } + } + } +} +function hydrateFallbackAskUserAnswers(messages) { + for (const msg of messages) { + if (msg.role !== "assistant" || !msg.toolCalls) { + continue; + } + for (const toolCall of msg.toolCalls) { + if (toolCall.name !== TOOL_ASK_USER_QUESTION || toolCall.resolvedAnswers) { + continue; + } + const answers = extractResolvedAnswersFromResultText(toolCall.result); + if (answers) { + toolCall.resolvedAnswers = answers; + } + } + } +} + +// src/providers/claude/history/sdkSessionPaths.ts +var import_fs3 = require("fs"); +var fs9 = __toESM(require("fs/promises")); +var os7 = __toESM(require("os")); +var path7 = __toESM(require("path")); +function encodeVaultPathForSDK(vaultPath) { + const absolutePath = path7.resolve(vaultPath); + return absolutePath.replace(/[^a-zA-Z0-9]/g, "-"); +} +function getSDKProjectsPath() { + return path7.join(os7.homedir(), ".claude", "projects"); +} +function isPathSafeId(value) { + if (!value || value.length === 0 || value.length > 128) { + return false; + } + if (value.includes("..") || value.includes("/") || value.includes("\\")) { + return false; + } + return /^[a-zA-Z0-9_-]+$/.test(value); +} +function isValidSessionId(sessionId) { + return isPathSafeId(sessionId); +} +function getSDKSessionPath(vaultPath, sessionId) { + if (!isValidSessionId(sessionId)) { + throw new Error(`Invalid session ID: ${sessionId}`); + } + const projectsPath = getSDKProjectsPath(); + const encodedVault = encodeVaultPathForSDK(vaultPath); + return path7.join(projectsPath, encodedVault, `${sessionId}.jsonl`); +} +function sdkSessionExists(vaultPath, sessionId) { + try { + const sessionPath = getSDKSessionPath(vaultPath, sessionId); + return (0, import_fs3.existsSync)(sessionPath); + } catch (e3) { + return false; + } +} +async function deleteSDKSession(vaultPath, sessionId) { + try { + const sessionPath = getSDKSessionPath(vaultPath, sessionId); + if (!(0, import_fs3.existsSync)(sessionPath)) { + return; + } + await fs9.unlink(sessionPath); + } catch (e3) { + } +} +async function readSDKSession(vaultPath, sessionId) { + try { + const sessionPath = getSDKSessionPath(vaultPath, sessionId); + if (!(0, import_fs3.existsSync)(sessionPath)) { + return { messages: [], skippedLines: 0 }; + } + const content = await fs9.readFile(sessionPath, "utf-8"); + const lines = content.split("\n").filter((line) => line.trim()); + const messages = []; + let skippedLines = 0; + for (const line of lines) { + try { + const msg = JSON.parse(line); + messages.push(msg); + } catch (e3) { + skippedLines++; + } + } + return { messages, skippedLines }; + } catch (error48) { + const errorMsg = error48 instanceof Error ? error48.message : String(error48); + return { messages: [], skippedLines: 0, error: errorMsg }; + } +} + +// src/providers/claude/history/sdkSubagentSidecar.ts +var import_fs4 = require("fs"); +var fs10 = __toESM(require("fs/promises")); +var path8 = __toESM(require("path")); + +// src/utils/subagentJsonl.ts +function extractFinalResultFromSubagentJsonl(content) { + var _a3; + const lines = content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && line.startsWith("{")); + let lastAssistantText = null; + let lastResultText = null; + for (const line of lines) { + let raw; + try { + raw = JSON.parse(line); + } catch (e3) { + continue; + } + if (!raw || typeof raw !== "object") { + continue; + } + const record2 = raw; + if (typeof record2.result === "string" && record2.result.trim().length > 0) { + lastResultText = record2.result.trim(); + } + if (((_a3 = record2.message) == null ? void 0 : _a3.role) !== "assistant" || !Array.isArray(record2.message.content)) { + continue; + } + for (const blockRaw of record2.message.content) { + if (!blockRaw || typeof blockRaw !== "object") { + continue; + } + const block = blockRaw; + if (block.type === "text" && typeof block.text === "string" && block.text.trim().length > 0) { + lastAssistantText = block.text.trim(); + } + } + } + return lastAssistantText != null ? lastAssistantText : lastResultText; +} + +// src/providers/claude/history/sdkSubagentSidecar.ts +function isValidAgentId(agentId) { + return isPathSafeId(agentId); +} +function parseTimestampMs(raw) { + if (typeof raw !== "string") { + return Date.now(); + } + const parsed = Date.parse(raw); + return Number.isNaN(parsed) ? Date.now() : parsed; +} +function parseSubagentEvents(entry) { + var _a3; + if (!entry || typeof entry !== "object") { + return []; + } + const record2 = entry; + const content = (_a3 = record2.message) == null ? void 0 : _a3.content; + if (!Array.isArray(content)) { + return []; + } + const timestamp = parseTimestampMs(record2.timestamp); + const events = []; + for (const blockRaw of content) { + if (!blockRaw || typeof blockRaw !== "object") { + continue; + } + const block = blockRaw; + if (block.type === "tool_use") { + if (typeof block.id !== "string" || typeof block.name !== "string") { + continue; + } + events.push({ + type: "tool_use", + toolUseId: block.id, + toolName: block.name, + toolInput: block.input && typeof block.input === "object" ? block.input : {}, + timestamp + }); + continue; + } + if (block.type === "tool_result") { + if (typeof block.tool_use_id !== "string") { + continue; + } + events.push({ + type: "tool_result", + toolUseId: block.tool_use_id, + content: extractToolResultContent(block.content), + isError: block.is_error === true, + timestamp + }); + } + } + return events; +} +function buildToolCallsFromSubagentEvents(events) { + const toolsById = /* @__PURE__ */ new Map(); + for (const event of events) { + const existing = toolsById.get(event.toolUseId); + if (event.type === "tool_use") { + if (!existing) { + toolsById.set(event.toolUseId, { + toolCall: { + id: event.toolUseId, + name: event.toolName, + input: { ...event.toolInput }, + status: "running", + isExpanded: false + }, + hasToolUse: true, + hasToolResult: false, + timestamp: event.timestamp + }); + } else { + existing.toolCall.name = event.toolName; + existing.toolCall.input = { ...event.toolInput }; + existing.hasToolUse = true; + existing.timestamp = event.timestamp; + } + continue; + } + if (!existing) { + toolsById.set(event.toolUseId, { + toolCall: { + id: event.toolUseId, + name: "Unknown", + input: {}, + status: event.isError ? "error" : "completed", + result: event.content, + isExpanded: false + }, + hasToolUse: false, + hasToolResult: true, + timestamp: event.timestamp + }); + continue; + } + existing.toolCall.status = event.isError ? "error" : "completed"; + existing.toolCall.result = event.content; + existing.hasToolResult = true; + } + return Array.from(toolsById.values()).filter((entry) => entry.hasToolUse).sort((a3, b) => a3.timestamp - b.timestamp).map((entry) => entry.toolCall); +} +function getSubagentSidecarPath(vaultPath, sessionId, agentId) { + if (!isValidSessionId(sessionId) || !isValidAgentId(agentId)) { + return null; + } + const encodedVault = encodeVaultPathForSDK(vaultPath); + return path8.join( + getSDKProjectsPath(), + encodedVault, + sessionId, + "subagents", + `agent-${agentId}.jsonl` + ); +} +async function loadSubagentToolCalls(vaultPath, sessionId, agentId) { + const subagentFilePath = getSubagentSidecarPath(vaultPath, sessionId, agentId); + if (!subagentFilePath) { + return []; + } + try { + if (!(0, import_fs4.existsSync)(subagentFilePath)) { + return []; + } + const content = await fs10.readFile(subagentFilePath, "utf-8"); + const lines = content.split("\n").filter((line) => line.trim()); + const events = []; + const seen = /* @__PURE__ */ new Set(); + for (const line of lines) { + let raw; + try { + raw = JSON.parse(line); + } catch (e3) { + continue; + } + for (const event of parseSubagentEvents(raw)) { + const key = `${event.type}:${event.toolUseId}`; + if (seen.has(key)) { + continue; + } + seen.add(key); + events.push(event); + } + } + if (events.length === 0) { + return []; + } + return buildToolCallsFromSubagentEvents(events); + } catch (e3) { + return []; + } +} +async function loadSubagentFinalResult(vaultPath, sessionId, agentId) { + const subagentFilePath = getSubagentSidecarPath(vaultPath, sessionId, agentId); + if (!subagentFilePath) { + return null; + } + try { + if (!(0, import_fs4.existsSync)(subagentFilePath)) { + return null; + } + const content = await fs10.readFile(subagentFilePath, "utf-8"); + return extractFinalResultFromSubagentJsonl(content); + } catch (e3) { + return null; + } +} + +// src/providers/claude/history/ClaudeHistoryStore.ts +async function loadSDKSessionMessages(vaultPath, sessionId, resumeAtMessageId) { + var _a3, _b2, _c; + const result = await readSDKSession(vaultPath, sessionId); + if (result.error) { + return { messages: [], skippedLines: result.skippedLines, error: result.error }; + } + const filteredEntries = filterActiveBranch(result.messages, resumeAtMessageId); + const toolResults = collectToolResults(filteredEntries); + const toolUseResults = collectStructuredPatchResults(filteredEntries); + const asyncSubagentResults = collectAsyncSubagentResults(filteredEntries); + const chatMessages = []; + let pendingAssistant = null; + for (const sdkMsg of filteredEntries) { + if (isSystemInjectedMessage(sdkMsg)) continue; + if (sdkMsg.type === "assistant" && ((_a3 = sdkMsg.message) == null ? void 0 : _a3.model) === "") continue; + const chatMsg = parseSDKMessageToChat(sdkMsg, toolResults); + if (!chatMsg) continue; + if (chatMsg.role === "assistant") { + const isCompactBoundary = (_b2 = chatMsg.contentBlocks) == null ? void 0 : _b2.some((b) => b.type === "context_compacted"); + if (isCompactBoundary) { + if (pendingAssistant) { + chatMessages.push(pendingAssistant); + } + chatMessages.push(chatMsg); + pendingAssistant = null; + } else if (pendingAssistant) { + mergeAssistantMessage(pendingAssistant, chatMsg); + } else { + pendingAssistant = chatMsg; + } + } else { + if (pendingAssistant) { + chatMessages.push(pendingAssistant); + pendingAssistant = null; + } + chatMessages.push(chatMsg); + } + } + if (pendingAssistant) { + chatMessages.push(pendingAssistant); + } + hydrateStructuredToolResults(chatMessages, toolUseResults); + hydrateFallbackAskUserAnswers(chatMessages); + if (toolUseResults.size > 0 || asyncSubagentResults.size > 0) { + const sidecarLoads = []; + for (const msg of chatMessages) { + if (msg.role !== "assistant" || !msg.toolCalls) continue; + for (const toolCall of msg.toolCalls) { + if (!isSubagentToolName(toolCall.name)) continue; + if (toolCall.subagent) continue; + if (((_c = toolCall.input) == null ? void 0 : _c.run_in_background) !== true) continue; + const toolUseResult = toolUseResults.get(toolCall.id); + const subagent = buildAsyncSubagentInfo( + toolCall, + toolUseResult, + asyncSubagentResults + ); + if (subagent) { + toolCall.subagent = subagent; + if (subagent.result !== void 0) { + toolCall.result = subagent.result; + } + toolCall.status = subagent.status; + if (subagent.agentId && isValidAgentId(subagent.agentId)) { + sidecarLoads.push({ + subagent, + promise: loadSubagentToolCalls(vaultPath, sessionId, subagent.agentId) + }); + } + } + } + } + if (sidecarLoads.length > 0) { + const results = await Promise.all(sidecarLoads.map((s3) => s3.promise)); + for (let i3 = 0; i3 < sidecarLoads.length; i3++) { + const toolCalls = results[i3]; + if (toolCalls.length > 0) { + sidecarLoads[i3].subagent.toolCalls = toolCalls; + } + } + } + } + chatMessages.sort((a3, b) => a3.timestamp - b.timestamp); + return { messages: chatMessages, skippedLines: result.skippedLines }; +} + +// src/providers/claude/history/ClaudeConversationHistoryService.ts +function chooseRicherResult(sdkResult, cachedResult) { + const sdkText = typeof sdkResult === "string" ? sdkResult.trim() : ""; + const cachedText = typeof cachedResult === "string" ? cachedResult.trim() : ""; + if (sdkText.length === 0 && cachedText.length === 0) return void 0; + if (sdkText.length === 0) return cachedResult; + if (cachedText.length === 0) return sdkResult; + return sdkText.length >= cachedText.length ? sdkResult : cachedResult; +} +function chooseRicherToolCalls(sdkToolCalls = [], cachedToolCalls = []) { + if (sdkToolCalls.length >= cachedToolCalls.length) { + return sdkToolCalls; + } + return cachedToolCalls; +} +function normalizeAsyncStatus(subagent, modeOverride) { + var _a3; + if (!subagent) return void 0; + const mode = modeOverride != null ? modeOverride : subagent.mode; + if (mode === "sync") return void 0; + if (mode === "async") return (_a3 = subagent.asyncStatus) != null ? _a3 : subagent.status; + return subagent.asyncStatus; +} +function isTerminalAsyncStatus(status) { + return status === "completed" || status === "error" || status === "orphaned"; +} +function mergeSubagentInfo(taskToolCall, cachedSubagent) { + var _a3, _b2, _c, _d, _e, _f, _g, _h; + const sdkSubagent = taskToolCall.subagent; + const cachedAsyncStatus = normalizeAsyncStatus(cachedSubagent); + if (!sdkSubagent) { + return { + ...cachedSubagent, + asyncStatus: cachedAsyncStatus, + result: chooseRicherResult(taskToolCall.result, cachedSubagent.result) + }; + } + const sdkAsyncStatus = normalizeAsyncStatus(sdkSubagent); + const sdkIsTerminal = isTerminalAsyncStatus(sdkAsyncStatus); + const cachedIsTerminal = isTerminalAsyncStatus(cachedAsyncStatus); + const sdkResult = (_a3 = taskToolCall.result) != null ? _a3 : sdkSubagent.result; + const preferred = !sdkIsTerminal && cachedIsTerminal ? cachedSubagent : sdkSubagent; + const mergedMode = (_d = (_b2 = sdkSubagent.mode) != null ? _b2 : cachedSubagent.mode) != null ? _d : ((_c = taskToolCall.input) == null ? void 0 : _c.run_in_background) === true ? "async" : void 0; + const fallbackResult = chooseRicherResult(sdkResult, cachedSubagent.result); + const mergedResult = preferred === cachedSubagent ? (_e = cachedSubagent.result) != null ? _e : fallbackResult : fallbackResult; + const mergedAsyncStatus = normalizeAsyncStatus(preferred, mergedMode); + return { + ...cachedSubagent, + ...sdkSubagent, + description: sdkSubagent.description || cachedSubagent.description, + prompt: sdkSubagent.prompt || cachedSubagent.prompt, + mode: mergedMode, + status: preferred.status, + asyncStatus: mergedAsyncStatus, + result: mergedResult, + toolCalls: chooseRicherToolCalls(sdkSubagent.toolCalls, cachedSubagent.toolCalls), + agentId: sdkSubagent.agentId || cachedSubagent.agentId, + outputToolId: sdkSubagent.outputToolId || cachedSubagent.outputToolId, + startedAt: (_f = sdkSubagent.startedAt) != null ? _f : cachedSubagent.startedAt, + completedAt: (_g = sdkSubagent.completedAt) != null ? _g : cachedSubagent.completedAt, + isExpanded: (_h = sdkSubagent.isExpanded) != null ? _h : cachedSubagent.isExpanded + }; +} +function ensureTaskToolCall(msg, subagentId, subagent) { + msg.toolCalls = msg.toolCalls || []; + let taskToolCall = msg.toolCalls.find( + (tc) => tc.id === subagentId && isSubagentToolName(tc.name) + ); + if (!taskToolCall) { + taskToolCall = { + id: subagentId, + name: TOOL_TASK, + input: { + description: subagent.description, + prompt: subagent.prompt || "", + ...subagent.mode === "async" ? { run_in_background: true } : {} + }, + status: subagent.status, + result: subagent.result, + isExpanded: false, + subagent + }; + msg.toolCalls.push(taskToolCall); + return taskToolCall; + } + if (!taskToolCall.input.description) { + taskToolCall.input.description = subagent.description; + } + if (!taskToolCall.input.prompt) { + taskToolCall.input.prompt = subagent.prompt || ""; + } + if (subagent.mode === "async") { + taskToolCall.input.run_in_background = true; + } + const mergedSubagent = mergeSubagentInfo(taskToolCall, subagent); + taskToolCall.status = mergedSubagent.status; + if (mergedSubagent.mode === "async") { + taskToolCall.input.run_in_background = true; + } + if (mergedSubagent.result !== void 0) { + taskToolCall.result = mergedSubagent.result; + } + taskToolCall.subagent = mergedSubagent; + return taskToolCall; +} +function dedupeMessages(messages) { + const seen = /* @__PURE__ */ new Set(); + const result = []; + for (const message of messages) { + if (seen.has(message.id)) continue; + seen.add(message.id); + result.push(message); + } + return result; +} +async function enrichAsyncSubagentToolCalls(subagentData, vaultPath, sessionIds) { + var _a3, _b2; + const uniqueSessionIds = [...new Set(sessionIds)]; + if (uniqueSessionIds.length === 0) return; + const loaderCache = /* @__PURE__ */ new Map(); + for (const subagent of Object.values(subagentData)) { + if (subagent.mode !== "async") continue; + if (!subagent.agentId) continue; + if (((_b2 = (_a3 = subagent.toolCalls) == null ? void 0 : _a3.length) != null ? _b2 : 0) > 0) continue; + for (const sessionId of uniqueSessionIds) { + const cacheKey = `${sessionId}:${subagent.agentId}`; + let loader = loaderCache.get(cacheKey); + if (!loader) { + loader = loadSubagentToolCalls(vaultPath, sessionId, subagent.agentId); + loaderCache.set(cacheKey, loader); + } + const recoveredToolCalls = await loader; + if (recoveredToolCalls.length === 0) continue; + subagent.toolCalls = recoveredToolCalls.map((toolCall) => ({ + ...toolCall, + input: { ...toolCall.input } + })); + break; + } + } +} +function applySubagentData(messages, subagentData) { + var _a3, _b2, _c, _d, _e; + const attachedSubagentIds = /* @__PURE__ */ new Set(); + for (const msg of messages) { + if (msg.role !== "assistant") continue; + for (const [subagentId, subagent] of Object.entries(subagentData)) { + const hasSubagentBlock = (_a3 = msg.contentBlocks) == null ? void 0 : _a3.some( + (block) => block.type === "subagent" && block.subagentId === subagentId || block.type === "tool_use" && block.toolId === subagentId + ); + const hasTaskToolCall = (_c = (_b2 = msg.toolCalls) == null ? void 0 : _b2.some((tc) => tc.id === subagentId)) != null ? _c : false; + if (!hasSubagentBlock && !hasTaskToolCall) continue; + ensureTaskToolCall(msg, subagentId, subagent); + if (!msg.contentBlocks) { + msg.contentBlocks = []; + } + let hasNormalizedSubagentBlock = false; + for (let i3 = 0; i3 < msg.contentBlocks.length; i3++) { + const block = msg.contentBlocks[i3]; + if (block.type === "tool_use" && block.toolId === subagentId) { + msg.contentBlocks[i3] = { + type: "subagent", + subagentId, + mode: subagent.mode + }; + hasNormalizedSubagentBlock = true; + } else if (block.type === "subagent" && block.subagentId === subagentId && !block.mode) { + block.mode = subagent.mode; + hasNormalizedSubagentBlock = true; + } else if (block.type === "subagent" && block.subagentId === subagentId) { + hasNormalizedSubagentBlock = true; + } + } + if (!hasNormalizedSubagentBlock && hasTaskToolCall) { + msg.contentBlocks.push({ + type: "subagent", + subagentId, + mode: subagent.mode + }); + } + attachedSubagentIds.add(subagentId); + } + } + for (const [subagentId, subagent] of Object.entries(subagentData)) { + if (attachedSubagentIds.has(subagentId)) continue; + let anchor = [...messages].reverse().find((msg) => msg.role === "assistant"); + if (!anchor) { + anchor = { + id: `subagent-recovery-${subagentId}`, + role: "assistant", + content: "", + timestamp: (_e = (_d = subagent.completedAt) != null ? _d : subagent.startedAt) != null ? _e : Date.now(), + contentBlocks: [] + }; + messages.push(anchor); + } + ensureTaskToolCall(anchor, subagentId, subagent); + anchor.contentBlocks = anchor.contentBlocks || []; + const hasSubagentBlock = anchor.contentBlocks.some( + (block) => block.type === "subagent" && block.subagentId === subagentId + ); + if (!hasSubagentBlock) { + anchor.contentBlocks.push({ + type: "subagent", + subagentId, + mode: subagent.mode + }); + } + } +} +function buildPersistedSubagentData(messages) { + const result = {}; + for (const msg of messages) { + if (msg.role !== "assistant" || !msg.toolCalls) continue; + for (const toolCall of msg.toolCalls) { + if (!isSubagentToolName(toolCall.name) || !toolCall.subagent) continue; + result[toolCall.subagent.id] = toolCall.subagent; + } + } + return result; +} +function sanitizeProviderState(providerState) { + const sanitizedEntries = Object.entries(providerState).filter(([, value]) => value !== void 0); + if (sanitizedEntries.length === 0) { + return void 0; + } + return Object.fromEntries(sanitizedEntries); +} +var ClaudeConversationHistoryService = class { + constructor() { + this.hydratedConversationIds = /* @__PURE__ */ new Set(); + } + isPendingForkConversation(conversation) { + const state = getClaudeState(conversation.providerState); + return !!state.forkSource && !state.providerSessionId && !conversation.sessionId; + } + resolveSessionIdForConversation(conversation) { + var _a3, _b2, _c, _d; + if (!conversation) return null; + const state = getClaudeState(conversation.providerState); + return (_d = (_c = (_a3 = state.providerSessionId) != null ? _a3 : conversation.sessionId) != null ? _c : (_b2 = state.forkSource) == null ? void 0 : _b2.sessionId) != null ? _d : null; + } + buildForkProviderState(sourceSessionId, resumeAt, _sourceProviderState) { + const state = { + forkSource: { sessionId: sourceSessionId, resumeAt } + }; + return state; + } + buildPersistedProviderState(conversation) { + const providerState = { + ...getClaudeState(conversation.providerState) + }; + const subagentData = buildPersistedSubagentData(conversation.messages); + if (Object.keys(subagentData).length > 0) { + providerState.subagentData = subagentData; + } else { + delete providerState.subagentData; + } + return sanitizeProviderState(providerState); + } + async hydrateConversationHistory(conversation, vaultPath) { + var _a3, _b2; + if (!vaultPath || this.hydratedConversationIds.has(conversation.id)) { + return; + } + const state = getClaudeState(conversation.providerState); + const isPendingFork = this.isPendingForkConversation(conversation); + const allSessionIds = isPendingFork ? [state.forkSource.sessionId] : [ + ...state.previousProviderSessionIds || [], + (_a3 = state.providerSessionId) != null ? _a3 : conversation.sessionId + ].filter((id) => !!id); + if (allSessionIds.length === 0) { + return; + } + const allSdkMessages = []; + let missingSessionCount = 0; + let errorCount = 0; + let successCount = 0; + const currentSessionId = isPendingFork ? state.forkSource.sessionId : (_b2 = state.providerSessionId) != null ? _b2 : conversation.sessionId; + for (const sessionId of allSessionIds) { + if (!sdkSessionExists(vaultPath, sessionId)) { + missingSessionCount++; + continue; + } + const isCurrentSession = sessionId === currentSessionId; + const truncateAt = isCurrentSession ? isPendingFork ? state.forkSource.resumeAt : conversation.resumeAtMessageId : void 0; + const result = await loadSDKSessionMessages(vaultPath, sessionId, truncateAt); + if (result.error) { + errorCount++; + continue; + } + successCount++; + allSdkMessages.push(...result.messages); + } + const allSessionsMissing = missingSessionCount === allSessionIds.length; + const hasLoadErrors = errorCount > 0 && successCount === 0 && !allSessionsMissing; + if (hasLoadErrors) { + return; + } + const filteredSdkMessages = allSdkMessages.filter((msg) => !msg.isRebuiltContext); + const merged = dedupeMessages([ + ...conversation.messages, + ...filteredSdkMessages + ]).sort((a3, b) => a3.timestamp - b.timestamp); + if (state.subagentData) { + await enrichAsyncSubagentToolCalls( + state.subagentData, + vaultPath, + allSessionIds + ); + applySubagentData(merged, state.subagentData); + } + conversation.messages = merged; + this.hydratedConversationIds.add(conversation.id); + } + async deleteConversationSession(conversation, vaultPath) { + var _a3; + const state = getClaudeState(conversation.providerState); + const sessionId = (_a3 = state.providerSessionId) != null ? _a3 : conversation.sessionId; + if (!vaultPath || !sessionId) { + return; + } + await deleteSDKSession(vaultPath, sessionId); + } +}; + +// src/providers/claude/runtime/ClaudeChatRuntime.ts +var import_obsidian14 = require("obsidian"); +init_env(); +init_path(); + +// src/utils/session.ts +var SESSION_ERROR_PATTERNS = [ + "session expired", + "session not found", + "invalid session", + "session invalid", + "process exited with code" +]; +var SESSION_ERROR_COMPOUND_PATTERNS = [ + { includes: ["session", "expired"] }, + { includes: ["resume", "failed"] }, + { includes: ["resume", "error"] } +]; +function isSessionExpiredError(error48) { + const msg = error48 instanceof Error ? error48.message.toLowerCase() : ""; + for (const pattern of SESSION_ERROR_PATTERNS) { + if (msg.includes(pattern)) { + return true; + } + } + for (const { includes } of SESSION_ERROR_COMPOUND_PATTERNS) { + if (includes.every((part) => msg.includes(part))) { + return true; + } + } + return false; +} +function formatToolInput(input, maxLength = 200) { + if (!input || Object.keys(input).length === 0) return ""; + try { + const parts = []; + for (const [key, value] of Object.entries(input)) { + if (value === void 0 || value === null) continue; + let valueStr; + if (typeof value === "string") { + valueStr = value.length > 100 ? `${value.slice(0, 100)}...` : value; + } else if (typeof value === "object") { + valueStr = "[object]"; + } else { + valueStr = String(value); + } + parts.push(`${key}=${valueStr}`); + } + const result = parts.join(", "); + return result.length > maxLength ? `${result.slice(0, maxLength)}...` : result; + } catch (e3) { + return "[input formatting error]"; + } +} +function formatToolCallForContext(toolCall, maxErrorLength = 500) { + var _a3; + const status = (_a3 = toolCall.status) != null ? _a3 : "completed"; + const isFailed = status === "error" || status === "blocked"; + const inputStr = formatToolInput(toolCall.input); + const inputPart = inputStr ? ` input: ${inputStr}` : ""; + if (!isFailed) { + return `[Tool ${toolCall.name}${inputPart} status=${status}]`; + } + const hasResult = typeof toolCall.result === "string" && toolCall.result.trim().length > 0; + if (!hasResult) { + return `[Tool ${toolCall.name}${inputPart} status=${status}]`; + } + const errorMsg = truncateToolResult(toolCall.result, maxErrorLength); + return `[Tool ${toolCall.name}${inputPart} status=${status}] error: ${errorMsg}`; +} +function truncateToolResult(result, maxLength = 500) { + if (result.length > maxLength) { + return `${result.slice(0, maxLength)}... (truncated)`; + } + return result; +} +function formatContextLine(message) { + if (!message.currentNote) { + return null; + } + return formatCurrentNote(message.currentNote); +} +function formatThinkingBlocks(message) { + if (!message.contentBlocks) return []; + const thinkingBlocks = message.contentBlocks.filter( + (block) => block.type === "thinking" + ); + if (thinkingBlocks.length === 0) return []; + const totalDuration = thinkingBlocks.reduce( + (sum, block) => { + var _a3; + return sum + ((_a3 = block.durationSeconds) != null ? _a3 : 0); + }, + 0 + ); + const durationPart = totalDuration > 0 ? `, ${totalDuration.toFixed(1)}s total` : ""; + return [`[Thinking: ${thinkingBlocks.length} block(s)${durationPart}]`]; +} +function buildContextFromHistory(messages) { + var _a3, _b2, _c; + const parts = []; + for (const message of messages) { + if (message.role !== "user" && message.role !== "assistant") { + continue; + } + if (message.isInterrupt) { + continue; + } + if (message.role === "assistant") { + const hasContent = message.content && message.content.trim().length > 0; + const hasToolCalls = message.toolCalls && message.toolCalls.length > 0; + const hasThinking = (_a3 = message.contentBlocks) == null ? void 0 : _a3.some((b) => b.type === "thinking"); + if (!hasContent && !hasToolCalls && !hasThinking) { + continue; + } + } + const role = message.role === "user" ? "User" : "Assistant"; + const lines = []; + const content = (_b2 = message.content) == null ? void 0 : _b2.trim(); + const contextLine = formatContextLine(message); + const userPayload = contextLine ? content ? `${contextLine} + +${content}` : contextLine : content; + lines.push(userPayload ? `${role}: ${userPayload}` : `${role}:`); + if (message.role === "assistant") { + const thinkingLines = formatThinkingBlocks(message); + if (thinkingLines.length > 0) { + lines.push(...thinkingLines); + } + } + if (message.role === "assistant" && ((_c = message.toolCalls) == null ? void 0 : _c.length)) { + const toolLines = message.toolCalls.map((tc) => formatToolCallForContext(tc)).filter(Boolean); + if (toolLines.length > 0) { + lines.push(...toolLines); + } + } + parts.push(lines.join("\n")); + } + return parts.join("\n\n"); +} +function getLastUserMessage(messages) { + for (let i3 = messages.length - 1; i3 >= 0; i3--) { + if (messages[i3].role === "user") { + return messages[i3]; + } + } + return void 0; +} +function buildPromptWithHistoryContext(historyContext, prompt, actualPrompt, conversationHistory) { + var _a3, _b2; + if (!historyContext) return prompt; + const lastUserMessage = getLastUserMessage(conversationHistory); + const lastUserQuery = (_b2 = lastUserMessage == null ? void 0 : lastUserMessage.displayContent) != null ? _b2 : extractUserQuery((_a3 = lastUserMessage == null ? void 0 : lastUserMessage.content) != null ? _a3 : ""); + const currentUserQuery = extractUserQuery(actualPrompt); + const shouldAppendPrompt = !lastUserMessage || lastUserQuery.trim() !== currentUserQuery.trim(); + return shouldAppendPrompt ? `${historyContext} + +User: ${prompt}` : historyContext; +} + +// src/providers/claude/hooks/SubagentHooks.ts +var STOP_BLOCK_REASON = 'Background subagents are still running. Use `TaskOutput task_id="..." block=true` to wait for their results before ending your turn.'; +function createStopSubagentHook(getState) { + return { + hooks: [ + async () => { + let hasRunning; + try { + hasRunning = getState().hasRunning; + } catch (e3) { + hasRunning = true; + } + if (hasRunning) { + return { decision: "block", reason: STOP_BLOCK_REASON }; + } + return {}; + } + ] + }; +} + +// src/utils/browser.ts +function escapeXmlAttribute(value) { + return value.replace(/&/g, "&").replace(/"/g, """).replace(//g, ">"); +} +function buildAttributeList(context) { + var _a3, _b2; + const attrs = []; + const source = context.source.trim() || "unknown"; + attrs.push(`source="${escapeXmlAttribute(source)}"`); + if ((_a3 = context.title) == null ? void 0 : _a3.trim()) { + attrs.push(`title="${escapeXmlAttribute(context.title.trim())}"`); + } + if ((_b2 = context.url) == null ? void 0 : _b2.trim()) { + attrs.push(`url="${escapeXmlAttribute(context.url.trim())}"`); + } + return attrs.join(" "); +} +function escapeXmlBody(text) { + return text.replace(/<\/browser_selection>/gi, "</browser_selection>"); +} +function formatBrowserContext(context) { + const selectedText = context.selectedText.trim(); + if (!selectedText) return ""; + const attrs = buildAttributeList(context); + return ` +${escapeXmlBody(selectedText)} +`; +} +function appendBrowserContext(prompt, context) { + const formatted = formatBrowserContext(context); + return formatted ? `${prompt} + +${formatted}` : prompt; +} + +// src/utils/canvas.ts +function formatCanvasContext(context) { + if (context.nodeIds.length === 0) return ""; + return ` +${context.nodeIds.join(", ")} +`; +} +function appendCanvasContext(prompt, context) { + const formatted = formatCanvasContext(context); + return formatted ? `${prompt} + +${formatted}` : prompt; +} + +// src/utils/editor.ts +function getEditorView(editor) { + return editor.cm; +} +function findNearestNonEmptyLine(getLine, lineCount, startLine, direction) { + const step = direction === "before" ? -1 : 1; + for (let i3 = startLine + step; i3 >= 0 && i3 < lineCount; i3 += step) { + const content = getLine(i3); + if (content.trim().length > 0) { + return content; + } + } + return ""; +} +function buildCursorContext(getLine, lineCount, line, column) { + const lineContent = getLine(line); + const beforeCursor = lineContent.substring(0, column); + const afterCursor = lineContent.substring(column); + const lineIsEmpty = lineContent.trim().length === 0; + const nothingBefore = beforeCursor.trim().length === 0; + const nothingAfter = afterCursor.trim().length === 0; + const isInbetween = lineIsEmpty || nothingBefore && nothingAfter; + let contextBefore = beforeCursor; + let contextAfter = afterCursor; + if (isInbetween) { + contextBefore = findNearestNonEmptyLine(getLine, lineCount, line, "before"); + contextAfter = findNearestNonEmptyLine(getLine, lineCount, line, "after"); + } + return { beforeCursor: contextBefore, afterCursor: contextAfter, isInbetween, line, column }; +} +function formatEditorContext(context) { + if (context.mode === "selection" && context.selectedText) { + const lineAttr = context.startLine && context.lineCount ? ` lines="${context.startLine}-${context.startLine + context.lineCount - 1}"` : ""; + return ` +${context.selectedText} +`; + } else if (context.mode === "cursor" && context.cursorContext) { + const ctx = context.cursorContext; + let content; + if (ctx.isInbetween) { + const parts = []; + if (ctx.beforeCursor) parts.push(ctx.beforeCursor); + parts.push("| #inbetween"); + if (ctx.afterCursor) parts.push(ctx.afterCursor); + content = parts.join("\n"); + } else { + content = `${ctx.beforeCursor}|${ctx.afterCursor} #inline`; + } + return ` +${content} +`; + } + return ""; +} +function appendEditorContext(prompt, context) { + const formatted = formatEditorContext(context); + return formatted ? `${prompt} + +${formatted}` : prompt; +} + +// src/providers/claude/prompt/ClaudeTurnEncoder.ts +function isCompactCommand(text) { + return /^\/compact(\s|$)/i.test(text); +} +function encodeClaudeTurn(request, mcpManager) { + const isCompact = isCompactCommand(request.text); + let persistedContent = request.text; + if (!isCompact) { + if (request.currentNotePath) { + persistedContent = appendCurrentNote(persistedContent, request.currentNotePath); + } + if (request.editorSelection) { + persistedContent = appendEditorContext(persistedContent, request.editorSelection); + } + if (request.browserSelection) { + persistedContent = appendBrowserContext(persistedContent, request.browserSelection); + } + if (request.canvasSelection) { + persistedContent = appendCanvasContext(persistedContent, request.canvasSelection); + } + } + const mcpMentions = mcpManager.extractMentions(persistedContent); + return { + request, + persistedContent, + prompt: mcpManager.transformMentions(persistedContent), + isCompact, + mcpMentions + }; +} + +// src/providers/claude/sdk/typeGuards.ts +function isSessionInitEvent(event) { + return event.type === "session_init"; +} +function isContextWindowEvent(event) { + return event.type === "context_window"; +} +function isStreamChunk(event) { + return event.type !== "session_init" && event.type !== "context_window"; +} + +// src/providers/claude/sdk/messages.ts +function isBlockedMessage(message) { + return message.type === "user" && "_blocked" in message && message._blocked === true && "_blockReason" in message; +} + +// src/providers/claude/stream/transformClaudeMessage.ts +function getToolInput(input) { + if (!input || typeof input !== "object" || Array.isArray(input)) { + return {}; + } + return input; +} +function emitToolUse(parentToolUseId, fields) { + if (parentToolUseId === null) { + return { type: "tool_use", ...fields }; + } + return { type: "subagent_tool_use", subagentId: parentToolUseId, ...fields }; +} +function emitToolResult(parentToolUseId, fields) { + if (parentToolUseId === null) { + return { type: "tool_result", ...fields }; + } + return { type: "subagent_tool_result", subagentId: parentToolUseId, ...fields }; +} +function isResultError(message) { + return !!message.subtype && message.subtype !== "success"; +} +function getBuiltInModelSignature(model) { + const normalized = model.trim().toLowerCase(); + if (normalized === "haiku") { + return { family: "haiku", is1M: false }; + } + if (normalized === "sonnet" || normalized === "sonnet[1m]") { + return { family: "sonnet", is1M: normalized.endsWith("[1m]") }; + } + if (normalized === "opus" || normalized === "opus[1m]") { + return { family: "opus", is1M: normalized.endsWith("[1m]") }; + } + return null; +} +function getModelUsageSignature(model) { + const normalized = model.trim().toLowerCase(); + if (normalized.includes("haiku")) { + return { family: "haiku", is1M: false }; + } + if (normalized.includes("sonnet")) { + return { family: "sonnet", is1M: normalized.endsWith("[1m]") }; + } + if (normalized.includes("opus")) { + return { family: "opus", is1M: normalized.endsWith("[1m]") }; + } + return null; +} +function selectContextWindowEntry(modelUsage, intendedModel) { + const entries = Object.entries(modelUsage).flatMap( + ([model, usage]) => typeof (usage == null ? void 0 : usage.contextWindow) === "number" && usage.contextWindow > 0 ? [{ model, contextWindow: usage.contextWindow }] : [] + ); + if (entries.length === 0) { + return null; + } + if (entries.length === 1) { + return entries[0]; + } + if (!intendedModel) { + return null; + } + const exactMatches = entries.filter((entry) => entry.model === intendedModel); + if (exactMatches.length === 1) { + return exactMatches[0]; + } + const intendedSignature = getBuiltInModelSignature(intendedModel); + if (!intendedSignature) { + return null; + } + const signatureMatches = entries.filter((entry) => { + const entrySignature = getModelUsageSignature(entry.model); + return (entrySignature == null ? void 0 : entrySignature.family) === intendedSignature.family && entrySignature.is1M === intendedSignature.is1M; + }); + return signatureMatches.length === 1 ? signatureMatches[0] : null; +} +function* transformSDKMessage(message, options) { + var _a3, _b2, _c, _d, _e, _f, _g, _h, _i, _j2, _k, _l, _m, _n, _o, _p, _q; + switch (message.type) { + case "system": + if (message.subtype === "init" && message.session_id) { + yield { + type: "session_init", + sessionId: message.session_id, + agents: message.agents, + permissionMode: message.permissionMode + }; + } else if (message.subtype === "compact_boundary") { + yield { type: "context_compacted" }; + } + break; + case "assistant": { + const parentToolUseId = (_a3 = message.parent_tool_use_id) != null ? _a3 : null; + if (message.error) { + yield { type: "error", content: message.error }; + } + if (((_b2 = message.message) == null ? void 0 : _b2.content) && Array.isArray(message.message.content)) { + for (const block of message.message.content) { + if (block.type === "thinking" && block.thinking) { + if (parentToolUseId === null) { + yield { type: "thinking", content: block.thinking }; + } + } else if (block.type === "text" && block.text && block.text.trim() !== "(no content)") { + if (parentToolUseId === null) { + yield { type: "text", content: block.text }; + } + } else if (block.type === "tool_use") { + yield emitToolUse(parentToolUseId, { + id: block.id || `tool-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`, + name: block.name || "unknown", + input: getToolInput(block.input) + }); + } + } + } + const usage = (_c = message.message) == null ? void 0 : _c.usage; + if (parentToolUseId === null && usage) { + const inputTokens = (_d = usage.input_tokens) != null ? _d : 0; + const cacheCreationInputTokens = (_e = usage.cache_creation_input_tokens) != null ? _e : 0; + const cacheReadInputTokens = (_f = usage.cache_read_input_tokens) != null ? _f : 0; + const contextTokens = inputTokens + cacheCreationInputTokens + cacheReadInputTokens; + const model = (_g = options == null ? void 0 : options.intendedModel) != null ? _g : "sonnet"; + const contextWindow = getContextWindowSize(model, options == null ? void 0 : options.customContextLimits); + const percentage = Math.min(100, Math.max(0, Math.round(contextTokens / contextWindow * 100))); + const usageInfo = { + model, + inputTokens, + cacheCreationInputTokens, + cacheReadInputTokens, + contextWindow, + contextTokens, + percentage + }; + yield { type: "usage", usage: usageInfo }; + } + break; + } + case "user": { + const parentToolUseId = (_h = message.parent_tool_use_id) != null ? _h : null; + if (isBlockedMessage(message)) { + yield { + type: "notice", + content: message._blockReason, + level: "warning" + }; + break; + } + if (message.tool_use_result !== void 0 && message.parent_tool_use_id) { + const toolUseResult = (_i = message.tool_use_result) != null ? _i : void 0; + yield emitToolResult(parentToolUseId, { + id: message.parent_tool_use_id, + content: extractToolResultContent(message.tool_use_result, { fallbackIndent: 2 }), + isError: false, + ...toolUseResult !== void 0 ? { toolUseResult } : {} + }); + } + if (((_j2 = message.message) == null ? void 0 : _j2.content) && Array.isArray(message.message.content)) { + for (const block of message.message.content) { + if (block.type === "tool_result") { + const toolUseResult = (_k = message.tool_use_result) != null ? _k : void 0; + yield emitToolResult(parentToolUseId, { + id: block.tool_use_id || message.parent_tool_use_id || "", + content: extractToolResultContent(block.content, { fallbackIndent: 2 }), + isError: block.is_error || false, + ...toolUseResult !== void 0 ? { toolUseResult } : {} + }); + } + } + } + break; + } + case "stream_event": { + const parentToolUseId = (_l = message.parent_tool_use_id) != null ? _l : null; + const event = message.event; + if ((event == null ? void 0 : event.type) === "content_block_start" && ((_m = event.content_block) == null ? void 0 : _m.type) === "tool_use") { + yield emitToolUse(parentToolUseId, { + id: event.content_block.id || `tool-${Date.now()}`, + name: event.content_block.name || "unknown", + input: getToolInput(event.content_block.input) + }); + } else if ((event == null ? void 0 : event.type) === "content_block_start" && ((_n = event.content_block) == null ? void 0 : _n.type) === "thinking") { + if (parentToolUseId === null && event.content_block.thinking) { + yield { type: "thinking", content: event.content_block.thinking }; + } + } else if ((event == null ? void 0 : event.type) === "content_block_start" && ((_o = event.content_block) == null ? void 0 : _o.type) === "text") { + if (parentToolUseId === null && event.content_block.text) { + yield { type: "text", content: event.content_block.text }; + } + } else if ((event == null ? void 0 : event.type) === "content_block_delta") { + if (parentToolUseId === null && ((_p = event.delta) == null ? void 0 : _p.type) === "thinking_delta" && event.delta.thinking) { + yield { type: "thinking", content: event.delta.thinking }; + } else if (parentToolUseId === null && ((_q = event.delta) == null ? void 0 : _q.type) === "text_delta" && event.delta.text) { + yield { type: "text", content: event.delta.text }; + } + } + break; + } + case "result": + if (isResultError(message)) { + const content = message.errors.filter((e3) => e3.trim().length > 0).join("\n"); + yield { + type: "error", + content: content || `Result error: ${message.subtype}` + }; + } + if ("modelUsage" in message && message.modelUsage) { + const modelUsage = message.modelUsage; + const selectedEntry = selectContextWindowEntry(modelUsage, options == null ? void 0 : options.intendedModel); + if (selectedEntry) { + yield { type: "context_window", contextWindow: selectedEntry.contextWindow }; + } + } + break; + default: + break; + } +} + +// src/core/security/ApprovalManager.ts +function getActionPattern(toolName, input) { + switch (toolName) { + case TOOL_BASH: + return typeof input.command === "string" ? input.command.trim() : ""; + case TOOL_READ: + case TOOL_WRITE: + case TOOL_EDIT: + return typeof input.file_path === "string" && input.file_path ? input.file_path : null; + case TOOL_NOTEBOOK_EDIT: + if (typeof input.notebook_path === "string" && input.notebook_path) { + return input.notebook_path; + } + return typeof input.file_path === "string" && input.file_path ? input.file_path : null; + case TOOL_GLOB: + return typeof input.pattern === "string" && input.pattern ? input.pattern : null; + case TOOL_GREP: + return typeof input.pattern === "string" && input.pattern ? input.pattern : null; + default: + return JSON.stringify(input); + } +} +function getActionDescription(toolName, input) { + var _a3; + const pattern = (_a3 = getActionPattern(toolName, input)) != null ? _a3 : "(unknown)"; + switch (toolName) { + case TOOL_BASH: + return `Run command: ${pattern}`; + case TOOL_READ: + return `Read file: ${pattern}`; + case TOOL_WRITE: + return `Write to file: ${pattern}`; + case TOOL_EDIT: + return `Edit file: ${pattern}`; + case TOOL_GLOB: + return `Search files matching: ${pattern}`; + case TOOL_GREP: + return `Search content matching: ${pattern}`; + default: + return `${toolName}: ${pattern}`; + } +} + +// src/providers/claude/security/ClaudePermissionUpdates.ts +function buildPermissionUpdates(toolName, input, decision, suggestions) { + const destination = decision === "allow-always" ? "projectSettings" : "session"; + const processed = []; + let hasRuleUpdate = false; + if (suggestions) { + for (const suggestion of suggestions) { + if (suggestion.type === "addRules" || suggestion.type === "replaceRules") { + hasRuleUpdate = true; + processed.push({ ...suggestion, behavior: "allow", destination }); + } else { + processed.push(suggestion); + } + } + } + if (!hasRuleUpdate) { + const pattern = getActionPattern(toolName, input); + const ruleValue = { toolName }; + if (pattern && !pattern.startsWith("{")) { + ruleValue.ruleContent = pattern; + } + processed.unshift({ + type: "addRules", + behavior: "allow", + rules: [ruleValue], + destination + }); + } + return processed; +} + +// src/providers/claude/runtime/ClaudeApprovalHandler.ts +function createClaudeApprovalCallback(deps) { + return async (toolName, input, options) => { + const currentAllowedTools = deps.getAllowedTools(); + if (currentAllowedTools !== null) { + if (!currentAllowedTools.includes(toolName) && toolName !== TOOL_SKILL) { + const allowedList = currentAllowedTools.length > 0 ? ` Allowed tools: ${currentAllowedTools.join(", ")}.` : " No tools are allowed for this query type."; + return { + behavior: "deny", + message: `Tool "${toolName}" is not allowed for this query.${allowedList}` + }; + } + } + const exitPlanModeCallback = deps.getExitPlanModeCallback(); + if (toolName === TOOL_EXIT_PLAN_MODE && exitPlanModeCallback) { + try { + const decision = await exitPlanModeCallback(input, options.signal); + if (decision === null) { + return { behavior: "deny", message: "User cancelled.", interrupt: true }; + } + if (decision.type === "feedback") { + return { behavior: "deny", message: decision.text, interrupt: false }; + } + const permissionMode = deps.getPermissionMode(); + const sdkMode = deps.resolveSDKPermissionMode(permissionMode); + deps.syncPermissionMode(permissionMode, sdkMode); + return { + behavior: "allow", + updatedInput: input, + updatedPermissions: [ + { type: "setMode", mode: sdkMode, destination: "session" } + ] + }; + } catch (error48) { + return { + behavior: "deny", + message: `Failed to handle plan mode exit: ${error48 instanceof Error ? error48.message : "Unknown error"}`, + interrupt: true + }; + } + } + const askUserQuestionCallback = deps.getAskUserQuestionCallback(); + if (toolName === TOOL_ASK_USER_QUESTION && askUserQuestionCallback) { + try { + const answers = await askUserQuestionCallback(input, options.signal); + if (answers === null) { + return { behavior: "deny", message: "User declined to answer.", interrupt: true }; + } + return { behavior: "allow", updatedInput: { ...input, answers } }; + } catch (error48) { + return { + behavior: "deny", + message: `Failed to get user answers: ${error48 instanceof Error ? error48.message : "Unknown error"}`, + interrupt: true + }; + } + } + const approvalCallback = deps.getApprovalCallback(); + if (!approvalCallback) { + return { behavior: "deny", message: "No approval handler available." }; + } + try { + const { decisionReason, blockedPath, agentID } = options; + const description = getActionDescription(toolName, input); + const decision = await approvalCallback( + toolName, + input, + description, + { decisionReason, blockedPath, agentID } + ); + if (decision === "cancel") { + return { behavior: "deny", message: "User interrupted.", interrupt: true }; + } + if (decision === "allow" || decision === "allow-always") { + const updatedPermissions = buildPermissionUpdates( + toolName, + input, + decision, + options.suggestions + ); + return { behavior: "allow", updatedInput: input, updatedPermissions }; + } + return { behavior: "deny", message: "User denied this action.", interrupt: false }; + } catch (error48) { + return { + behavior: "deny", + message: `Approval request failed: ${error48 instanceof Error ? error48.message : "Unknown error"}`, + interrupt: false + }; + } + }; +} + +// src/providers/claude/runtime/ClaudeDynamicUpdates.ts +async function applyClaudeDynamicUpdates(deps, queryOptions, restartOptions, allowRestart = true) { + var _a3, _b2, _c, _d; + const persistentQuery = deps.getPersistentQuery(); + if (!persistentQuery) { + return; + } + const vaultPath = deps.getVaultPath(); + if (!vaultPath) { + return; + } + const cliPath = deps.getCliPath(); + if (!cliPath) { + return; + } + const settings11 = deps.getScopedSettings(); + const selectedModel = (queryOptions == null ? void 0 : queryOptions.model) || settings11.model; + const permissionMode = deps.getPermissionMode(); + const currentConfig = deps.getCurrentConfig(); + if (currentConfig && selectedModel !== currentConfig.model) { + try { + await persistentQuery.setModel(selectedModel); + deps.mutateCurrentConfig((config2) => { + config2.model = selectedModel; + }); + } catch (e3) { + deps.notifyFailure("Failed to update model"); + } + } + if (!isAdaptiveThinkingModel(selectedModel)) { + const budgetConfig = THINKING_BUDGETS.find((b) => b.value === settings11.thinkingBudget); + const thinkingTokens = (_a3 = budgetConfig == null ? void 0 : budgetConfig.tokens) != null ? _a3 : null; + const currentThinking = (_c = (_b2 = deps.getCurrentConfig()) == null ? void 0 : _b2.thinkingTokens) != null ? _c : null; + if (thinkingTokens !== currentThinking) { + try { + await persistentQuery.setMaxThinkingTokens(thinkingTokens); + deps.mutateCurrentConfig((config2) => { + config2.thinkingTokens = thinkingTokens; + }); + } catch (e3) { + deps.notifyFailure("Failed to update thinking budget"); + } + } + } + const configBeforePermissionUpdate = deps.getCurrentConfig(); + if (configBeforePermissionUpdate) { + const sdkMode = deps.resolveSDKPermissionMode(permissionMode); + const currentSdkMode = (_d = configBeforePermissionUpdate.sdkPermissionMode) != null ? _d : null; + if (sdkMode !== currentSdkMode) { + try { + await persistentQuery.setPermissionMode(sdkMode); + deps.mutateCurrentConfig((config2) => { + config2.permissionMode = permissionMode; + config2.sdkPermissionMode = sdkMode; + }); + } catch (e3) { + deps.notifyFailure("Failed to update permission mode"); + } + } else { + deps.mutateCurrentConfig((config2) => { + config2.permissionMode = permissionMode; + config2.sdkPermissionMode = sdkMode; + }); + } + } + const mcpMentions = (queryOptions == null ? void 0 : queryOptions.mcpMentions) || /* @__PURE__ */ new Set(); + const uiEnabledServers = (queryOptions == null ? void 0 : queryOptions.enabledMcpServers) || /* @__PURE__ */ new Set(); + const combinedMentions = /* @__PURE__ */ new Set([...mcpMentions, ...uiEnabledServers]); + const mcpServers = deps.mcpManager.getActiveServers(combinedMentions); + const mcpServersKey = JSON.stringify(mcpServers); + if (deps.getCurrentConfig() && mcpServersKey !== deps.getCurrentConfig().mcpServersKey) { + const serverConfigs = {}; + for (const [name, config2] of Object.entries(mcpServers)) { + serverConfigs[name] = config2; + } + try { + await persistentQuery.setMcpServers(serverConfigs); + deps.mutateCurrentConfig((config2) => { + config2.mcpServersKey = mcpServersKey; + }); + } catch (e3) { + deps.notifyFailure("Failed to update MCP servers"); + } + } + const newExternalContextPaths = (queryOptions == null ? void 0 : queryOptions.externalContextPaths) || []; + deps.setCurrentExternalContextPaths(newExternalContextPaths); + if (!allowRestart) { + return; + } + const newConfig = deps.buildPersistentQueryConfig(vaultPath, cliPath, newExternalContextPaths); + if (!deps.needsRestart(newConfig)) { + return; + } + const restarted = await deps.ensureReady({ + externalContextPaths: newExternalContextPaths, + preserveHandlers: restartOptions == null ? void 0 : restartOptions.preserveHandlers, + force: true + }); + if (restarted && deps.getPersistentQuery()) { + await applyClaudeDynamicUpdates(deps, queryOptions, restartOptions, false); + } +} + +// src/providers/claude/runtime/types.ts +var MESSAGE_CHANNEL_CONFIG = { + MAX_QUEUED_MESSAGES: 8, + // Memory protection from rapid user input + MAX_MERGED_CHARS: 12e3 + // ~3k tokens — batch size under context limits +}; +function createResponseHandler(options) { + let _sawStreamText = false; + let _sawAnyChunk = false; + return { + id: options.id, + onChunk: options.onChunk, + onDone: options.onDone, + onError: options.onError, + get sawStreamText() { + return _sawStreamText; + }, + get sawAnyChunk() { + return _sawAnyChunk; + }, + markStreamTextSeen() { + _sawStreamText = true; + }, + resetStreamText() { + _sawStreamText = false; + }, + markChunkSeen() { + _sawAnyChunk = true; + } + }; +} +var UNSUPPORTED_SDK_TOOLS = []; +var DISABLED_BUILTIN_SUBAGENTS = [ + "Task(statusline-setup)" +]; +function isTurnCompleteMessage(message) { + return message.type === "result"; +} + +// src/providers/claude/runtime/ClaudeMessageChannel.ts +var MessageChannel = class { + constructor(onWarning = () => { + }) { + this.queue = []; + this.turnActive = false; + this.closed = false; + this.resolveNext = null; + this.currentSessionId = null; + this.onWarning = onWarning; + } + setSessionId(sessionId) { + this.currentSessionId = sessionId; + } + isTurnActive() { + return this.turnActive; + } + isClosed() { + return this.closed; + } + /** + * Enqueue a message. If a turn is active: + * - Text-only: merge with queued text (up to MAX_MERGED_CHARS) + * - With attachments: replace any existing queued attachment (one at a time) + */ + enqueue(message) { + if (this.closed) { + throw new Error("MessageChannel is closed"); + } + const hasAttachments = this.messageHasAttachments(message); + if (!this.turnActive) { + if (this.resolveNext) { + this.turnActive = true; + const resolve5 = this.resolveNext; + this.resolveNext = null; + resolve5({ value: message, done: false }); + } else { + if (this.queue.length >= MESSAGE_CHANNEL_CONFIG.MAX_QUEUED_MESSAGES) { + this.onWarning(`[MessageChannel] Queue full (${MESSAGE_CHANNEL_CONFIG.MAX_QUEUED_MESSAGES}), dropping newest`); + return; + } + if (hasAttachments) { + this.queue.push({ type: "attachment", message }); + } else { + this.queue.push({ type: "text", content: this.extractTextContent(message) }); + } + } + return; + } + if (hasAttachments) { + const existingIdx = this.queue.findIndex((m3) => m3.type === "attachment"); + if (existingIdx >= 0) { + this.queue[existingIdx] = { type: "attachment", message }; + this.onWarning("[MessageChannel] Attachment message replaced (only one can be queued)"); + } else { + this.queue.push({ type: "attachment", message }); + } + return; + } + const textContent = this.extractTextContent(message); + const existingTextIdx = this.queue.findIndex((m3) => m3.type === "text"); + if (existingTextIdx >= 0) { + const existing = this.queue[existingTextIdx]; + const mergedContent = existing.content + "\n\n" + textContent; + if (mergedContent.length > MESSAGE_CHANNEL_CONFIG.MAX_MERGED_CHARS) { + this.onWarning(`[MessageChannel] Merged content exceeds ${MESSAGE_CHANNEL_CONFIG.MAX_MERGED_CHARS} chars, dropping newest`); + return; + } + existing.content = mergedContent; + } else { + if (this.queue.length >= MESSAGE_CHANNEL_CONFIG.MAX_QUEUED_MESSAGES) { + this.onWarning(`[MessageChannel] Queue full (${MESSAGE_CHANNEL_CONFIG.MAX_QUEUED_MESSAGES}), dropping newest`); + return; + } + this.queue.push({ type: "text", content: textContent }); + } + } + onTurnComplete() { + this.turnActive = false; + if (this.queue.length > 0 && this.resolveNext) { + const pending = this.queue.shift(); + this.turnActive = true; + const resolve5 = this.resolveNext; + this.resolveNext = null; + resolve5({ value: this.pendingToMessage(pending), done: false }); + } + } + close() { + this.closed = true; + this.queue = []; + if (this.resolveNext) { + const resolve5 = this.resolveNext; + this.resolveNext = null; + resolve5({ value: void 0, done: true }); + } + } + reset() { + this.queue = []; + this.turnActive = false; + this.closed = false; + this.resolveNext = null; + } + getQueueLength() { + return this.queue.length; + } + [Symbol.asyncIterator]() { + return { + next: () => { + if (this.closed) { + return Promise.resolve({ value: void 0, done: true }); + } + if (this.queue.length > 0 && !this.turnActive) { + const pending = this.queue.shift(); + this.turnActive = true; + return Promise.resolve({ value: this.pendingToMessage(pending), done: false }); + } + return new Promise((resolve5) => { + this.resolveNext = resolve5; + }); + } + }; + } + messageHasAttachments(message) { + var _a3; + if (!((_a3 = message.message) == null ? void 0 : _a3.content)) return false; + if (typeof message.message.content === "string") return false; + return message.message.content.some((block) => block.type === "image"); + } + extractTextContent(message) { + var _a3; + if (!((_a3 = message.message) == null ? void 0 : _a3.content)) return ""; + if (typeof message.message.content === "string") return message.message.content; + return message.message.content.filter((block) => block.type === "text").map((block) => block.text).join("\n\n"); + } + pendingToMessage(pending) { + if (pending.type === "attachment") { + return pending.message; + } + return { + type: "user", + message: { + role: "user", + content: pending.content + }, + parent_tool_use_id: null, + session_id: this.currentSessionId || "" + }; + } +}; + +// src/core/prompt/mainAgent.ts +function getPathRules(vaultPath) { + return `## Path Conventions + +| Location | Access | Path Format | Example | +|----------|--------|-------------|---------| +| **Vault** | Read/Write | Relative from vault root | \`notes/my-note.md\`, \`.\` | +| **External contexts** | Full access | Absolute path | \`/Users/me/Workspace/file.ts\` | + +**Vault files** (default working directory): +- \u2713 Correct: \`notes/my-note.md\`, \`my-note.md\`, \`folder/subfolder/file.md\`, \`.\` +- \u2717 WRONG: \`/notes/my-note.md\`, \`${vaultPath || "/absolute/path"}/file.md\` +- A leading slash or absolute path will FAIL for vault operations. + +**External context paths**: When external directories are selected, use absolute paths to access files there. These directories are explicitly granted for the current session.`; +} +function getBaseSystemPrompt(vaultPath, userName) { + const vaultInfo = vaultPath ? ` + +Vault absolute path: ${vaultPath}` : ""; + const trimmedUserName = userName == null ? void 0 : userName.trim(); + const userContext = trimmedUserName ? `## User Context + +You are collaborating with **${trimmedUserName}**. + +` : ""; + const pathRules = getPathRules(vaultPath); + return `${userContext}## Time Context + +- **Current Date**: ${getTodayDate()} +- **Knowledge Status**: You possess extensive internal knowledge up to your training cutoff. You do not know the exact date of your cutoff, but you must assume that your internal weights are static and "past," while the Current Date is "present." + +## Identity & Role + +You are **Claudian**, an expert AI assistant specialized in Obsidian vault management, knowledge organization, and code analysis. You operate directly inside the user's Obsidian vault. + +**Core Principles:** +1. **Obsidian Native**: You understand Markdown, YAML frontmatter, Wiki-links, and the "second brain" philosophy. +2. **Safety First**: You never overwrite data without understanding context. You always use relative paths. +3. **Proactive Thinking**: You do not just execute; you *plan* and *verify*. You anticipate potential issues (like broken links or missing files). +4. **Clarity**: Your changes are precise, minimizing "noise" in the user's notes or code. + +The current working directory is the user's vault root.${vaultInfo} + +${pathRules} + +## User Message Format + +User messages have the query first, followed by optional XML context tags: + +\`\`\` +User's question or request here + + +path/to/note.md + + + +selected text content + + + +selected content from an Obsidian browser view + +\`\`\` + +- The user's query/instruction always comes first in the message. +- \`\`: The note the user is currently viewing/focused on. Read this to understand context. +- \`\`: Text currently selected in the editor, with file path and line numbers. +- \`\`: Text selected in an Obsidian browser/web view (for example Surfing), including optional source/title/url metadata. +- \`@filename.md\`: Files mentioned with @ in the query. Read these files when referenced. + +## Obsidian Context + +- **Structure**: Files are Markdown (.md). Folders organize content. +- **Frontmatter**: YAML at the top of files (metadata). Respect existing fields. +- **Links**: Internal Wiki-links \`[[note-name]]\` or \`[[folder/note-name]]\`. External links \`[text](url)\`. + - When reading a note with wikilinks, consider reading linked notes; they often contain related context that helps understand the current note. +- **Tags**: #tag-name for categorization. +- **Dataview**: You may encounter Dataview queries (in \`\`\`dataview\`\`\` blocks). Do not break them unless asked. +- **Vault Config**: \`.obsidian/\` contains internal config. Touch only if you know what you are doing. + +**File References in Responses:** +When mentioning vault files in your responses, use wikilink format so users can click to open them: +- \u2713 Use: \`[[folder/note.md]]\` or \`[[note]]\` +- \u2717 Avoid: plain paths like \`folder/note.md\` (not clickable) + +**Image embeds:** Use \`![[image.png]]\` to display images directly in chat. Images render visually, making it easy to show diagrams, screenshots, or visual content you're discussing. + +Examples: +- "I found your notes in [[30.areas/finance/Investment lessons/2024.Current trading lessons.md]]" +- "See [[daily notes/2024-01-15]] for more details" +- "Here's the diagram: ![[attachments/architecture.png]]" + +## Selection Context + +User messages may include an \`\` tag showing text the user selected: + +\`\`\`xml + +selected text here +possibly multiple lines + +\`\`\` + +User messages may also include a \`\` tag when selection comes from an Obsidian browser view: + +\`\`\`xml + +selected webpage content + +\`\`\` + +**When present:** The user selected this text before sending their message. Use this context to understand what they're referring to.`; +} +function getImageInstructions(mediaFolder) { + const folder = mediaFolder.trim(); + const mediaPath = folder ? `./${folder}` : "."; + const examplePath = folder ? `${folder}/` : ""; + return ` + +## Embedded Images in Notes + +**Proactive image reading**: When reading a note with embedded images, read them alongside text for full context. Images often contain critical information (diagrams, screenshots, charts). + +**Local images** (\`![[image.jpg]]\`): +- Located in media folder: \`${mediaPath}\` +- Read with: \`Read file_path="${examplePath}image.jpg"\` +- Formats: PNG, JPG/JPEG, GIF, WebP + +**External images** (\`![alt](url)\`): +- WebFetch does NOT support images +- Download to media folder -> Read -> Replace URL with wiki-link: + +\`\`\`bash +# Download to media folder with descriptive name +mkdir -p ${mediaPath} +img_name="downloaded_\\$(date +%s).png" +curl -sfo "${examplePath}$img_name" 'URL' +\`\`\` + +Then read with \`Read file_path="${examplePath}$img_name"\`, and replace the markdown link \`![alt](url)\` with \`![[${examplePath}$img_name]]\` in the note. + +**Benefits**: Image becomes a permanent vault asset, works offline, and uses Obsidian's native embed syntax.`; +} +function getAppendixSections(appendices) { + if (!appendices || appendices.length === 0) { + return ""; + } + const sections = appendices.map((appendix) => appendix.trim()).filter(Boolean); + if (sections.length === 0) { + return ""; + } + return ` + +${sections.join("\n\n")}`; +} +function buildSystemPrompt(settings11 = {}, options = {}) { + var _a3; + let prompt = getBaseSystemPrompt(settings11.vaultPath, settings11.userName); + prompt += getImageInstructions(settings11.mediaFolder || ""); + prompt += getAppendixSections(options.appendices); + if ((_a3 = settings11.customPrompt) == null ? void 0 : _a3.trim()) { + prompt += ` + +## Custom Instructions + +${settings11.customPrompt.trim()}`; + } + return prompt; +} +function computeSystemPromptKey(settings11, options = {}) { + const appendixKey = (options.appendices || []).map((appendix) => appendix.trim()).filter(Boolean).join("||"); + const parts = [ + settings11.mediaFolder || "", + settings11.customPrompt || "", + settings11.vaultPath || "", + (settings11.userName || "").trim() + ]; + if (appendixKey) { + parts.push(appendixKey); + } + return parts.join("::"); +} + +// src/providers/claude/runtime/ClaudeQueryOptionsBuilder.ts +var QueryOptionsBuilder = class _QueryOptionsBuilder { + static needsRestart(currentConfig, newConfig) { + if (!currentConfig) return true; + if (currentConfig.systemPromptKey !== newConfig.systemPromptKey) return true; + if (currentConfig.disallowedToolsKey !== newConfig.disallowedToolsKey) return true; + if (currentConfig.pluginsKey !== newConfig.pluginsKey) return true; + if (currentConfig.settingSources !== newConfig.settingSources) return true; + if (currentConfig.claudeCliPath !== newConfig.claudeCliPath) return true; + if (currentConfig.enableChrome !== newConfig.enableChrome) return true; + if (currentConfig.effortLevel !== newConfig.effortLevel) return true; + if (_QueryOptionsBuilder.pathsChanged(currentConfig.externalContextPaths, newConfig.externalContextPaths)) { + return true; + } + return false; + } + static buildPersistentQueryConfig(ctx, externalContextPaths) { + var _a3; + const claudeSettings = getClaudeProviderSettings(ctx.settings); + const systemPromptSettings = { + mediaFolder: ctx.settings.mediaFolder, + customPrompt: ctx.settings.systemPrompt, + vaultPath: ctx.vaultPath, + userName: ctx.settings.userName + }; + const budgetSetting = ctx.settings.thinkingBudget; + const budgetConfig = THINKING_BUDGETS.find((b) => b.value === budgetSetting); + const thinkingTokens = (_a3 = budgetConfig == null ? void 0 : budgetConfig.tokens) != null ? _a3 : null; + const sdkPermissionMode = _QueryOptionsBuilder.resolveClaudeSdkPermissionMode( + ctx.settings.permissionMode, + claudeSettings.safeMode + ); + const disallowedToolsKey = ctx.mcpManager.getAllDisallowedMcpTools().join("|"); + const pluginsKey = ctx.pluginManager.getPluginsKey(); + return { + model: ctx.settings.model, + thinkingTokens: thinkingTokens && thinkingTokens > 0 ? thinkingTokens : null, + effortLevel: isAdaptiveThinkingModel(ctx.settings.model) ? ctx.settings.effortLevel : null, + permissionMode: ctx.settings.permissionMode, + sdkPermissionMode, + systemPromptKey: computeSystemPromptKey(systemPromptSettings), + disallowedToolsKey, + mcpServersKey: "", + // Dynamic via setMcpServers, not tracked for restart + pluginsKey, + externalContextPaths: externalContextPaths || [], + settingSources: claudeSettings.loadUserSettings ? "user,project" : "project", + claudeCliPath: ctx.cliPath, + enableChrome: claudeSettings.enableChrome + }; + } + static buildPersistentQueryOptions(ctx) { + const { options, claudeSettings } = _QueryOptionsBuilder.buildBaseOptions( + ctx, + ctx.settings.model, + ctx.abortController + ); + options.disallowedTools = [ + ...ctx.mcpManager.getAllDisallowedMcpTools(), + ...UNSUPPORTED_SDK_TOOLS, + ...DISABLED_BUILTIN_SUBAGENTS + ]; + _QueryOptionsBuilder.applyPermissionMode( + options, + ctx.settings.permissionMode, + claudeSettings.safeMode, + ctx.canUseTool + ); + _QueryOptionsBuilder.applyThinking(options, ctx.settings, ctx.settings.model); + options.hooks = ctx.hooks; + options.enableFileCheckpointing = true; + if (ctx.resume) { + options.resume = ctx.resume.sessionId; + if (ctx.resume.sessionAt) { + options.resumeSessionAt = ctx.resume.sessionAt; + } + if (ctx.resume.fork) { + options.forkSession = true; + } + } + if (ctx.externalContextPaths && ctx.externalContextPaths.length > 0) { + options.additionalDirectories = ctx.externalContextPaths; + } + return options; + } + static buildColdStartQueryOptions(ctx) { + var _a3, _b2; + const selectedModel = (_a3 = ctx.modelOverride) != null ? _a3 : ctx.settings.model; + const { options, claudeSettings } = _QueryOptionsBuilder.buildBaseOptions( + ctx, + selectedModel, + ctx.abortController + ); + const mcpMentions = ctx.mcpMentions || /* @__PURE__ */ new Set(); + const uiEnabledServers = ctx.enabledMcpServers || /* @__PURE__ */ new Set(); + const combinedMentions = /* @__PURE__ */ new Set([...mcpMentions, ...uiEnabledServers]); + const mcpServers = ctx.mcpManager.getActiveServers(combinedMentions); + if (Object.keys(mcpServers).length > 0) { + options.mcpServers = mcpServers; + } + const disallowedMcpTools = ctx.mcpManager.getDisallowedMcpTools(combinedMentions); + options.disallowedTools = [ + ...disallowedMcpTools, + ...UNSUPPORTED_SDK_TOOLS, + ...DISABLED_BUILTIN_SUBAGENTS + ]; + _QueryOptionsBuilder.applyPermissionMode( + options, + ctx.settings.permissionMode, + claudeSettings.safeMode, + ctx.canUseTool + ); + options.hooks = ctx.hooks; + _QueryOptionsBuilder.applyThinking(options, ctx.settings, (_b2 = ctx.modelOverride) != null ? _b2 : ctx.settings.model); + if (ctx.allowedTools !== void 0 && ctx.allowedTools.length > 0) { + options.tools = ctx.allowedTools; + } + if (ctx.sessionId) { + options.resume = ctx.sessionId; + } + if (ctx.externalContextPaths && ctx.externalContextPaths.length > 0) { + options.additionalDirectories = ctx.externalContextPaths; + } + return options; + } + static resolveClaudeSdkPermissionMode(permissionMode, claudeSafeMode = "acceptEdits") { + if (permissionMode === "yolo") return "bypassPermissions"; + if (permissionMode === "plan") return "plan"; + return claudeSafeMode; + } + static applyPermissionMode(options, permissionMode, claudeSafeMode, canUseTool) { + options.allowDangerouslySkipPermissions = true; + if (canUseTool) { + options.canUseTool = canUseTool; + } + options.permissionMode = _QueryOptionsBuilder.resolveClaudeSdkPermissionMode( + permissionMode, + claudeSafeMode + ); + } + static applyExtraArgs(options, enableChrome) { + if (enableChrome) { + options.extraArgs = { ...options.extraArgs, chrome: null }; + } + } + static buildBaseOptions(ctx, model, abortController) { + const claudeSettings = getClaudeProviderSettings(ctx.settings); + const systemPromptSettings = { + mediaFolder: ctx.settings.mediaFolder, + customPrompt: ctx.settings.systemPrompt, + vaultPath: ctx.vaultPath, + userName: ctx.settings.userName + }; + const options = { + cwd: ctx.vaultPath, + systemPrompt: buildSystemPrompt(systemPromptSettings), + model, + abortController, + pathToClaudeCodeExecutable: ctx.cliPath, + settingSources: claudeSettings.loadUserSettings ? ["user", "project"] : ["project"], + env: { + ...process.env, + ...ctx.customEnv, + PATH: ctx.enhancedPath + }, + includePartialMessages: true + }; + _QueryOptionsBuilder.applyExtraArgs(options, claudeSettings.enableChrome); + options.spawnClaudeCodeProcess = createCustomSpawnFunction(ctx.enhancedPath); + return { options, claudeSettings }; + } + static applyThinking(options, settings11, model) { + if (isAdaptiveThinkingModel(model)) { + options.thinking = { type: "adaptive" }; + options.effort = settings11.effortLevel; + } else { + const budgetConfig = THINKING_BUDGETS.find((b) => b.value === settings11.thinkingBudget); + if (budgetConfig && budgetConfig.tokens > 0) { + options.maxThinkingTokens = budgetConfig.tokens; + } + } + } + static pathsChanged(a3, b) { + const aKey = [...a3 || []].sort().join("|"); + const bKey = [...b || []].sort().join("|"); + return aKey !== bKey; + } +}; + +// src/providers/claude/runtime/ClaudeRewindService.ts +var fs11 = __toESM(require("fs/promises")); +var os8 = __toESM(require("os")); +var path9 = __toESM(require("path")); +function resolveRewindFilePath(filePath, vaultPath) { + if (path9.isAbsolute(filePath)) { + return filePath; + } + if (vaultPath) { + return path9.join(vaultPath, filePath); + } + return filePath; +} +async function copyDir(from, to) { + await fs11.mkdir(to, { recursive: true }); + const dirents = await fs11.readdir(from, { withFileTypes: true }); + for (const dirent of dirents) { + const srcPath = path9.join(from, dirent.name); + const destPath = path9.join(to, dirent.name); + if (dirent.isDirectory()) { + await copyDir(srcPath, destPath); + continue; + } + if (dirent.isSymbolicLink()) { + const target = await fs11.readlink(srcPath); + await fs11.symlink(target, destPath); + continue; + } + if (dirent.isFile()) { + await fs11.copyFile(srcPath, destPath); + } + } +} +async function createClaudeRewindBackup(filesChanged, vaultPath) { + if (!filesChanged || filesChanged.length === 0) { + return null; + } + const backupRoot = await fs11.mkdtemp(path9.join(os8.tmpdir(), "claudian-rewind-")); + const entries = []; + const backupPathForIndex = (index) => path9.join(backupRoot, String(index)); + for (let i3 = 0; i3 < filesChanged.length; i3++) { + const originalPath = resolveRewindFilePath(filesChanged[i3], vaultPath); + try { + const stats = await fs11.lstat(originalPath); + if (stats.isSymbolicLink()) { + const target = await fs11.readlink(originalPath); + entries.push({ originalPath, existedBefore: true, kind: "symlink", symlinkTarget: target }); + continue; + } + const backupPath = backupPathForIndex(i3); + if (stats.isDirectory()) { + await copyDir(originalPath, backupPath); + entries.push({ originalPath, existedBefore: true, kind: "dir", backupPath }); + continue; + } + if (stats.isFile()) { + await fs11.copyFile(originalPath, backupPath); + entries.push({ originalPath, existedBefore: true, kind: "file", backupPath }); + continue; + } + entries.push({ originalPath, existedBefore: false }); + } catch (error48) { + const err = error48; + if (err.code === "ENOENT") { + entries.push({ originalPath, existedBefore: false }); + continue; + } + await fs11.rm(backupRoot, { recursive: true, force: true }); + throw error48; + } + } + const restore = async () => { + const errors = []; + for (const entry of entries) { + try { + if (!entry.existedBefore) { + await fs11.rm(entry.originalPath, { recursive: true, force: true }); + continue; + } + await fs11.rm(entry.originalPath, { recursive: true, force: true }); + await fs11.mkdir(path9.dirname(entry.originalPath), { recursive: true }); + if (entry.kind === "symlink") { + await fs11.symlink(entry.symlinkTarget, entry.originalPath); + continue; + } + if (entry.kind === "dir") { + await copyDir(entry.backupPath, entry.originalPath); + continue; + } + await fs11.copyFile(entry.backupPath, entry.originalPath); + } catch (error48) { + errors.push(error48); + } + } + if (errors.length > 0) { + throw new Error(`Failed to restore ${errors.length} file(s) after rewind failure.`); + } + }; + const cleanup = async () => { + await fs11.rm(backupRoot, { recursive: true, force: true }); + }; + return { restore, cleanup }; +} +async function executeClaudeRewind(userMessageId, deps) { + const preview = await deps.rewindFiles(userMessageId, true); + if (!preview.canRewind) { + return preview; + } + const backup = await createClaudeRewindBackup(preview.filesChanged, deps.vaultPath); + try { + const result = await deps.rewindFiles(userMessageId); + if (!result.canRewind) { + await (backup == null ? void 0 : backup.restore()); + deps.closePersistentQuery("rewind failed"); + return result; + } + deps.setPendingResumeAt(deps.assistantMessageId); + deps.closePersistentQuery("rewind"); + return { + ...result, + filesChanged: preview.filesChanged, + insertions: preview.insertions, + deletions: preview.deletions + }; + } catch (error48) { + try { + await (backup == null ? void 0 : backup.restore()); + } catch (rollbackError) { + deps.closePersistentQuery("rewind failed"); + throw new Error( + `Rewind failed and files could not be fully restored: ${rollbackError instanceof Error ? rollbackError.message : "Unknown error"}`, + { cause: rollbackError } + ); + } + deps.closePersistentQuery("rewind failed"); + throw new Error( + `Rewind failed but files were restored: ${error48 instanceof Error ? error48.message : "Unknown error"}`, + { cause: error48 } + ); + } finally { + await (backup == null ? void 0 : backup.cleanup()); + } +} + +// src/providers/claude/runtime/ClaudeSessionManager.ts +var SessionManager = class { + constructor() { + this.state = { + sessionId: null, + sessionModel: null, + pendingSessionModel: null, + wasInterrupted: false, + needsHistoryRebuild: false, + sessionInvalidated: false + }; + } + getSessionId() { + return this.state.sessionId; + } + setSessionId(id, defaultModel) { + this.state.sessionId = id; + this.state.sessionModel = id ? defaultModel != null ? defaultModel : null : null; + this.state.needsHistoryRebuild = false; + this.state.sessionInvalidated = false; + } + wasInterrupted() { + return this.state.wasInterrupted; + } + markInterrupted() { + this.state.wasInterrupted = true; + } + clearInterrupted() { + this.state.wasInterrupted = false; + } + setPendingModel(model) { + this.state.pendingSessionModel = model; + } + clearPendingModel() { + this.state.pendingSessionModel = null; + } + captureSession(sessionId) { + const hadSession = this.state.sessionId !== null; + const isDifferent = this.state.sessionId !== sessionId; + if (hadSession && isDifferent) { + this.state.needsHistoryRebuild = true; + } + this.state.sessionId = sessionId; + this.state.sessionModel = this.state.pendingSessionModel; + this.state.pendingSessionModel = null; + this.state.sessionInvalidated = false; + } + needsHistoryRebuild() { + return this.state.needsHistoryRebuild; + } + clearHistoryRebuild() { + this.state.needsHistoryRebuild = false; + } + invalidateSession() { + this.state.sessionId = null; + this.state.sessionModel = null; + this.state.sessionInvalidated = true; + } + /** Consume the invalidation flag (returns true once). */ + consumeInvalidation() { + const wasInvalidated = this.state.sessionInvalidated; + this.state.sessionInvalidated = false; + return wasInvalidated; + } + reset() { + this.state = { + sessionId: null, + sessionModel: null, + pendingSessionModel: null, + wasInterrupted: false, + needsHistoryRebuild: false, + sessionInvalidated: false + }; + } +}; + +// src/providers/claude/runtime/ClaudeUserMessageFactory.ts +var import_crypto4 = require("crypto"); +function buildUserContentBlocks(prompt, images) { + const content = []; + for (const image of images != null ? images : []) { + content.push({ + type: "image", + source: { + type: "base64", + media_type: image.mediaType, + data: image.data + } + }); + } + if (prompt.trim()) { + content.push({ + type: "text", + text: prompt + }); + } + return content; +} +function buildClaudeSDKUserMessage(prompt, sessionId, images) { + if (!images || images.length === 0) { + return { + type: "user", + message: { + role: "user", + content: prompt + }, + parent_tool_use_id: null, + session_id: sessionId, + uuid: (0, import_crypto4.randomUUID)() + }; + } + return { + type: "user", + message: { + role: "user", + content: buildUserContentBlocks(prompt, images) + }, + parent_tool_use_id: null, + session_id: sessionId, + uuid: (0, import_crypto4.randomUUID)() + }; +} +function buildClaudePromptWithImages(prompt, images) { + if (!images || images.length === 0) { + return prompt; + } + const content = buildUserContentBlocks(prompt, images); + async function* messageGenerator() { + yield { + type: "user", + message: { + role: "user", + content + } + }; + } + return messageGenerator(); +} + +// src/providers/claude/runtime/ClaudeChatRuntime.ts +function isChatMessageArray(value) { + return Array.isArray(value) && value.length > 0 && !!value[0] && typeof value[0] === "object" && "role" in value[0] && "content" in value[0]; +} +function isImageAttachmentArray(value) { + return Array.isArray(value) && value.length > 0 && !!value[0] && typeof value[0] === "object" && "mediaType" in value[0] && "data" in value[0]; +} +var ClaudianService = class { + constructor(plugin, services) { + this.providerId = CLAUDE_PROVIDER_CAPABILITIES.providerId; + this.abortController = null; + this.approvalCallback = null; + this.approvalDismisser = null; + this.askUserQuestionCallback = null; + this.exitPlanModeCallback = null; + this.permissionModeSyncCallback = null; + this.vaultPath = null; + this.currentExternalContextPaths = []; + this.readyStateListeners = /* @__PURE__ */ new Set(); + // Modular components + this.sessionManager = new SessionManager(); + this.persistentQuery = null; + this.messageChannel = null; + this.queryAbortController = null; + this.responseHandlers = []; + this.responseConsumerRunning = false; + this.responseConsumerPromise = null; + this.shuttingDown = false; + // Tracked configuration for detecting changes that require restart + this.currentConfig = null; + // Current allowed tools for canUseTool enforcement (null = no restriction) + this.currentAllowedTools = null; + this.pendingForkSession = false; + // Last sent message for crash recovery (Phase 1.3) + this.lastSentMessage = null; + this.lastSentQueryOptions = null; + this.crashRecoveryAttempted = false; + this.coldStartInProgress = false; + // Prevent consumer error restarts during cold-start + // Subagent hook state provider (set from feature layer to avoid core→feature dependency) + this._subagentStateProvider = null; + // Auto-triggered turn handling (e.g., task-notification delivery by the SDK) + this._autoTurnBuffer = []; + this._autoTurnSawStreamText = false; + this._autoTurnCallback = null; + this.turnMetadata = {}; + this.bufferedUsageChunk = null; + var _a3, _b2, _c, _d, _e, _f; + this.plugin = plugin; + const legacyPlugin = this.getLegacyPluginDeps(); + if ("mcpManager" in services) { + this.mcpManager = services.mcpManager; + this.pluginManager = (_b2 = (_a3 = services.pluginManager) != null ? _a3 : legacyPlugin.pluginManager) != null ? _b2 : null; + this.agentManager = (_d = (_c = services.agentManager) != null ? _c : legacyPlugin.agentManager) != null ? _d : null; + return; + } + this.mcpManager = services; + this.pluginManager = (_e = legacyPlugin.pluginManager) != null ? _e : null; + this.agentManager = (_f = legacyPlugin.agentManager) != null ? _f : null; + } + getLegacyPluginDeps() { + return this.plugin; + } + getCapabilities() { + return CLAUDE_PROVIDER_CAPABILITIES; + } + prepareTurn(request) { + return encodeClaudeTurn(request, this.mcpManager); + } + consumeTurnMetadata() { + const metadata = { ...this.turnMetadata }; + this.turnMetadata = {}; + this.bufferedUsageChunk = null; + return metadata; + } + onReadyStateChange(listener) { + this.readyStateListeners.add(listener); + try { + listener(this.isReady()); + } catch (e3) { + } + return () => { + this.readyStateListeners.delete(listener); + }; + } + notifyReadyStateChange() { + if (this.readyStateListeners.size === 0) { + return; + } + const isReady = this.isReady(); + for (const listener of this.readyStateListeners) { + try { + listener(isReady); + } catch (e3) { + } + } + } + resetTurnMetadata() { + this.turnMetadata = {}; + this.bufferedUsageChunk = null; + } + recordTurnMetadata(update) { + this.turnMetadata = { + ...this.turnMetadata, + ...update + }; + } + bufferUsageChunk(chunk) { + this.bufferedUsageChunk = chunk; + return chunk; + } + updateBufferedUsageContextWindow(contextWindow) { + if (!this.bufferedUsageChunk || contextWindow <= 0) { + return null; + } + const usage = this.bufferedUsageChunk.usage; + const percentage = Math.min( + 100, + Math.max(0, Math.round(usage.contextTokens / contextWindow * 100)) + ); + const nextChunk = { + ...this.bufferedUsageChunk, + usage: { + ...usage, + contextWindow, + contextWindowIsAuthoritative: true, + percentage + } + }; + this.bufferedUsageChunk = nextChunk; + return nextChunk; + } + setPendingResumeAt(uuid3) { + this.pendingResumeAt = uuid3; + } + setResumeCheckpoint(checkpointId) { + this.setPendingResumeAt(checkpointId); + } + /** One-shot: consumed on the next query, then cleared by routeMessage on session init. */ + applyForkState(conv) { + var _a3, _b2, _c; + const state = getClaudeState(conv.providerState); + const isPending = !conv.sessionId && !state.providerSessionId && !!state.forkSource; + this.pendingForkSession = isPending; + if (isPending) { + this.pendingResumeAt = state.forkSource.resumeAt; + } else { + this.pendingResumeAt = void 0; + } + return (_c = (_b2 = conv.sessionId) != null ? _b2 : (_a3 = state.forkSource) == null ? void 0 : _a3.sessionId) != null ? _c : null; + } + syncConversationState(conversation, externalContextPaths) { + if (!conversation) { + this.pendingForkSession = false; + this.pendingResumeAt = void 0; + this.setSessionId(null, externalContextPaths); + return; + } + const resolvedSessionId = this.applyForkState(conversation); + this.setSessionId(resolvedSessionId, externalContextPaths); + } + buildSessionUpdates({ conversation, sessionInvalidated }) { + var _a3, _b2; + const sessionId = this.getSessionId(); + const existingState = getClaudeState(conversation == null ? void 0 : conversation.providerState); + const oldSdkSessionId = existingState.providerSessionId; + const sessionChanged = sessionId && oldSdkSessionId && sessionId !== oldSdkSessionId; + const previousProviderSessionIds = sessionChanged ? [.../* @__PURE__ */ new Set([...existingState.previousProviderSessionIds || [], oldSdkSessionId])] : existingState.previousProviderSessionIds; + const isForkSourceOnly = !!existingState.forkSource && !existingState.providerSessionId && sessionId === existingState.forkSource.sessionId; + let resolvedSessionId; + if (sessionInvalidated) { + resolvedSessionId = null; + } else if (isForkSourceOnly) { + resolvedSessionId = (_a3 = conversation == null ? void 0 : conversation.sessionId) != null ? _a3 : null; + } else { + resolvedSessionId = (_b2 = sessionId != null ? sessionId : conversation == null ? void 0 : conversation.sessionId) != null ? _b2 : null; + } + const newProviderState = { + ...existingState, + providerSessionId: sessionId && !isForkSourceOnly ? sessionId : existingState.providerSessionId, + previousProviderSessionIds + }; + if (existingState.forkSource && sessionId && sessionId !== existingState.forkSource.sessionId) { + delete newProviderState.forkSource; + } + return { + updates: { + sessionId: resolvedSessionId, + providerState: newProviderState + } + }; + } + resolveSessionIdForFork(conversation) { + var _a3, _b2, _c, _d; + const sessionId = this.getSessionId(); + if (sessionId) return sessionId; + if (!conversation) return null; + const state = getClaudeState(conversation.providerState); + return (_d = (_c = (_a3 = state.providerSessionId) != null ? _a3 : conversation.sessionId) != null ? _c : (_b2 = state.forkSource) == null ? void 0 : _b2.sessionId) != null ? _d : null; + } + async loadSubagentToolCalls(agentId) { + const sessionId = this.getSessionId(); + const vaultPath = getVaultPath(this.plugin.app); + if (!sessionId || !vaultPath) return []; + return loadSubagentToolCalls(vaultPath, sessionId, agentId); + } + async loadSubagentFinalResult(agentId) { + const sessionId = this.getSessionId(); + const vaultPath = getVaultPath(this.plugin.app); + if (!sessionId || !vaultPath) return null; + return loadSubagentFinalResult(vaultPath, sessionId, agentId); + } + async reloadMcpServers() { + await this.mcpManager.loadServers(); + } + /** + * Ensures the persistent query is running with current configuration. + * Unified API that replaces preWarm() and restartPersistentQuery(). + * + * Behavior: + * - If not running → start (if paths available) + * - If running and force=true → close and restart + * - If running and config changed → close and restart + * - If running and config unchanged → no-op + * + * Note: When restart is needed, the query is closed BEFORE checking if we can + * start a new one. This ensures fallback to cold-start if CLI becomes unavailable. + * + * @returns true if the query was (re)started, false otherwise + */ + async ensureReady(options) { + var _a3, _b2, _c; + const vaultPath = getVaultPath(this.plugin.app); + if (options && options.externalContextPaths !== void 0) { + this.currentExternalContextPaths = options.externalContextPaths; + } + const effectiveSessionId = (_b2 = (_a3 = options == null ? void 0 : options.sessionId) != null ? _a3 : this.sessionManager.getSessionId()) != null ? _b2 : void 0; + const externalContextPaths = (_c = options == null ? void 0 : options.externalContextPaths) != null ? _c : this.currentExternalContextPaths; + if (!this.persistentQuery) { + if (!vaultPath) return false; + const cliPath2 = this.plugin.getResolvedProviderCliPath("claude"); + if (!cliPath2) return false; + await this.startPersistentQuery(vaultPath, cliPath2, effectiveSessionId, externalContextPaths); + return true; + } + if (options == null ? void 0 : options.force) { + this.closePersistentQuery("forced restart", { preserveHandlers: options.preserveHandlers }); + if (!vaultPath) return false; + const cliPath2 = this.plugin.getResolvedProviderCliPath("claude"); + if (!cliPath2) return false; + await this.startPersistentQuery(vaultPath, cliPath2, effectiveSessionId, externalContextPaths); + return true; + } + if (!vaultPath) return false; + const cliPath = this.plugin.getResolvedProviderCliPath("claude"); + if (!cliPath) return false; + const newConfig = this.buildPersistentQueryConfig(vaultPath, cliPath, externalContextPaths); + if (this.needsRestart(newConfig)) { + this.closePersistentQuery("config changed", { preserveHandlers: options == null ? void 0 : options.preserveHandlers }); + const cliPathAfterClose = this.plugin.getResolvedProviderCliPath("claude"); + if (cliPathAfterClose) { + await this.startPersistentQuery(vaultPath, cliPathAfterClose, effectiveSessionId, externalContextPaths); + return true; + } + return false; + } + return false; + } + /** + * Starts the persistent query for the active chat conversation. + */ + async startPersistentQuery(vaultPath, cliPath, resumeSessionId, externalContextPaths) { + if (this.persistentQuery) { + return; + } + this.shuttingDown = false; + this.vaultPath = vaultPath; + this.messageChannel = new MessageChannel(); + if (resumeSessionId) { + this.messageChannel.setSessionId(resumeSessionId); + this.sessionManager.setSessionId(resumeSessionId, this.getScopedSettings().model); + } + this.queryAbortController = new AbortController(); + const config2 = this.buildPersistentQueryConfig(vaultPath, cliPath, externalContextPaths); + this.currentConfig = config2; + const resumeAtMessageId = this.pendingResumeAt; + const options = await this.buildPersistentQueryOptions( + vaultPath, + cliPath, + resumeSessionId, + resumeAtMessageId, + externalContextPaths + ); + this.persistentQuery = Qs({ + prompt: this.messageChannel, + options + }); + if (this.pendingResumeAt === resumeAtMessageId) { + this.pendingResumeAt = void 0; + } + this.attachPersistentQueryStdinErrorHandler(this.persistentQuery); + this.startResponseConsumer(); + this.notifyReadyStateChange(); + } + attachPersistentQueryStdinErrorHandler(query) { + var _a3; + const stdin = (_a3 = query.transport) == null ? void 0 : _a3.processStdin; + if (!stdin || typeof stdin.on !== "function" || typeof stdin.once !== "function") { + return; + } + const handler = (error48) => { + if (this.shuttingDown || this.isPipeError(error48)) { + return; + } + this.closePersistentQuery("stdin error"); + }; + stdin.on("error", handler); + stdin.once("close", () => { + stdin.removeListener("error", handler); + }); + } + isPipeError(error48) { + if (!error48 || typeof error48 !== "object") return false; + const e3 = error48; + return e3.code === "EPIPE" || typeof e3.message === "string" && e3.message.includes("EPIPE"); + } + /** + * Closes the persistent query and cleans up resources. + */ + closePersistentQuery(_reason, options) { + var _a3, _b2, _c; + if (!this.persistentQuery) { + return; + } + const preserveHandlers = (_a3 = options == null ? void 0 : options.preserveHandlers) != null ? _a3 : false; + this.shuttingDown = true; + (_b2 = this.messageChannel) == null ? void 0 : _b2.close(); + void this.persistentQuery.interrupt().catch(() => { + }); + (_c = this.queryAbortController) == null ? void 0 : _c.abort(); + if (!preserveHandlers) { + for (const handler of this.responseHandlers) { + handler.onDone(); + } + } + this.shuttingDown = false; + this.notifyReadyStateChange(); + this.persistentQuery = null; + this.messageChannel = null; + this.queryAbortController = null; + this.responseConsumerRunning = false; + this.responseConsumerPromise = null; + this.currentConfig = null; + this._autoTurnBuffer = []; + this._autoTurnSawStreamText = false; + if (!preserveHandlers) { + this.responseHandlers = []; + this.currentAllowedTools = null; + } + } + /** + * Checks if the persistent query needs to be restarted based on configuration changes. + */ + needsRestart(newConfig) { + return QueryOptionsBuilder.needsRestart(this.currentConfig, newConfig); + } + /** + * Builds configuration object for tracking changes. + */ + buildPersistentQueryConfig(vaultPath, cliPath, externalContextPaths) { + return QueryOptionsBuilder.buildPersistentQueryConfig( + this.buildQueryOptionsContext(vaultPath, cliPath), + externalContextPaths + ); + } + /** + * Builds the base query options context from current state. + */ + getScopedSettings() { + return ProviderSettingsCoordinator.getProviderSettingsSnapshot( + this.plugin.settings, + this.providerId + ); + } + buildQueryOptionsContext(vaultPath, cliPath) { + const customEnv = parseEnvironmentVariables(this.plugin.getActiveEnvironmentVariables(this.providerId)); + const enhancedPath = getEnhancedPath(customEnv.PATH, cliPath); + return { + vaultPath, + cliPath, + settings: this.getScopedSettings(), + customEnv, + enhancedPath, + mcpManager: this.mcpManager, + pluginManager: this.requirePluginManager() + }; + } + requirePluginManager() { + var _a3, _b2; + const pluginManager = (_b2 = (_a3 = this.pluginManager) != null ? _a3 : this.getLegacyPluginDeps().pluginManager) != null ? _b2 : null; + if (!pluginManager) { + throw new Error("Claude plugin manager is unavailable."); + } + return pluginManager; + } + getAgentManager() { + var _a3, _b2; + return (_b2 = (_a3 = this.agentManager) != null ? _a3 : this.getLegacyPluginDeps().agentManager) != null ? _b2 : null; + } + /** + * Builds SDK options for the persistent query. + */ + buildPersistentQueryOptions(vaultPath, cliPath, resumeSessionId, resumeAtMessageId, externalContextPaths) { + var _a3; + const baseContext = this.buildQueryOptionsContext(vaultPath, cliPath); + const hooks = this.buildHooks(); + const ctx = { + ...baseContext, + abortController: (_a3 = this.queryAbortController) != null ? _a3 : void 0, + resume: resumeSessionId ? { sessionId: resumeSessionId, sessionAt: resumeAtMessageId, fork: this.pendingForkSession || void 0 } : void 0, + canUseTool: this.createApprovalCallback(), + hooks, + externalContextPaths + }; + return QueryOptionsBuilder.buildPersistentQueryOptions(ctx); + } + /** + * Builds the hooks for SDK options. + * Hooks need access to `this` for dynamic settings, so they're built here. + */ + buildHooks() { + const hooks = {}; + hooks.Stop = [createStopSubagentHook( + () => { + var _a3, _b2; + return (_b2 = (_a3 = this._subagentStateProvider) == null ? void 0 : _a3.call(this)) != null ? _b2 : { hasRunning: false }; + } + )]; + return hooks; + } + /** + * Starts the background consumer loop that routes chunks to handlers. + */ + startResponseConsumer() { + if (this.responseConsumerRunning) { + return; + } + this.responseConsumerRunning = true; + const queryForThisConsumer = this.persistentQuery; + this.responseConsumerPromise = (async () => { + var _a3; + if (!this.persistentQuery) return; + try { + for await (const message of this.persistentQuery) { + if (this.shuttingDown) break; + await this.routeMessage(message); + } + } catch (error48) { + if (this.persistentQuery !== queryForThisConsumer && this.persistentQuery !== null) { + return; + } + if (!this.shuttingDown && !this.coldStartInProgress) { + const handler = this.responseHandlers[this.responseHandlers.length - 1]; + const errorInstance = error48 instanceof Error ? error48 : new Error(String(error48)); + const messageToReplay = this.lastSentMessage; + if (!this.crashRecoveryAttempted && messageToReplay && handler && !handler.sawAnyChunk) { + this.crashRecoveryAttempted = true; + try { + await this.ensureReady({ force: true, preserveHandlers: true }); + if (!this.messageChannel) { + throw new Error("Persistent query restart did not create message channel", { + cause: error48 + }); + } + await this.applyDynamicUpdates((_a3 = this.lastSentQueryOptions) != null ? _a3 : void 0, { preserveHandlers: true }); + this.messageChannel.enqueue(messageToReplay); + return; + } catch (restartError) { + if (isSessionExpiredError(restartError)) { + this.sessionManager.invalidateSession(); + } + handler.onError(errorInstance); + return; + } + } + if (handler) { + handler.onError(errorInstance); + } + if (!this.crashRecoveryAttempted) { + this.crashRecoveryAttempted = true; + try { + await this.ensureReady({ force: true }); + } catch (restartError) { + if (isSessionExpiredError(restartError)) { + this.sessionManager.invalidateSession(); + } + } + } + } + } finally { + if (this.persistentQuery === queryForThisConsumer || this.persistentQuery === null) { + this.responseConsumerRunning = false; + } + } + })(); + } + /** @param modelOverride - Optional model override for cold-start queries */ + getTransformOptions(modelOverride) { + const settings11 = this.getScopedSettings(); + return { + intendedModel: modelOverride != null ? modelOverride : settings11.model, + customContextLimits: settings11.customContextLimits + }; + } + /** + * Routes an SDK message to the active response handler. + * + * Design: Only one handler exists at a time because MessageChannel enforces + * single-turn processing. When a turn is active, new messages are queued/merged. + * The next message only dequeues after onTurnComplete(), which calls onDone() + * on the current handler. A new handler is registered only when the next query starts. + */ + async routeMessage(message) { + var _a3, _b2, _c, _d; + const handler = this.responseHandlers[this.responseHandlers.length - 1]; + if (this.isStreamTextEvent(message)) { + if (handler) { + handler.markStreamTextSeen(); + } else { + this._autoTurnSawStreamText = true; + } + } + for (const event of transformSDKMessage(message, this.getTransformOptions())) { + if (isSessionInitEvent(event)) { + const wasFork = this.pendingForkSession; + this.sessionManager.captureSession(event.sessionId); + if (wasFork) { + this.sessionManager.clearHistoryRebuild(); + this.pendingForkSession = false; + } + (_a3 = this.messageChannel) == null ? void 0 : _a3.setSessionId(event.sessionId); + if (event.agents) { + try { + (_b2 = this.getAgentManager()) == null ? void 0 : _b2.setBuiltinAgentNames(event.agents); + } catch (e3) { + } + } + if (event.permissionMode && this.permissionModeSyncCallback) { + try { + this.permissionModeSyncCallback(event.permissionMode); + } catch (e3) { + } + } + } else if (isContextWindowEvent(event)) { + const usageChunk = this.updateBufferedUsageContextWindow(event.contextWindow); + if (!usageChunk) { + continue; + } + if (handler) { + handler.onChunk(usageChunk); + } else { + this._autoTurnBuffer.push(usageChunk); + } + } else if (isStreamChunk(event)) { + if (message.type === "assistant" && event.type === "text") { + if ((handler == null ? void 0 : handler.sawStreamText) || !handler && this._autoTurnSawStreamText) { + continue; + } + } + if (event.type === "tool_use" && event.name === TOOL_ENTER_PLAN_MODE) { + if (this.currentConfig) { + this.currentConfig.permissionMode = "plan"; + this.currentConfig.sdkPermissionMode = "plan"; + } + if (this.permissionModeSyncCallback) { + try { + this.permissionModeSyncCallback("plan"); + } catch (e3) { + } + } + } + const normalizedChunk = event.type === "usage" ? this.bufferUsageChunk({ ...event, sessionId: this.sessionManager.getSessionId() }) : event; + if (handler) { + handler.onChunk(normalizedChunk); + } else { + this._autoTurnBuffer.push(normalizedChunk); + } + } + } + if (message.type === "assistant" && message.uuid) { + this.recordTurnMetadata({ assistantMessageId: message.uuid }); + } + if (isTurnCompleteMessage(message)) { + (_c = this.messageChannel) == null ? void 0 : _c.onTurnComplete(); + if (handler) { + handler.resetStreamText(); + handler.onDone(); + } else { + this._autoTurnSawStreamText = false; + if (this._autoTurnBuffer.length === 0) { + return; + } + const chunks = [...this._autoTurnBuffer]; + const metadata = this.consumeTurnMetadata(); + this._autoTurnBuffer = []; + try { + (_d = this._autoTurnCallback) == null ? void 0 : _d.call(this, { chunks, metadata }); + } catch (e3) { + new import_obsidian14.Notice("Background task completed, but the result could not be rendered."); + } + } + } + } + registerResponseHandler(handler) { + this.responseHandlers.push(handler); + } + unregisterResponseHandler(handlerId) { + const idx = this.responseHandlers.findIndex((h) => h.id === handlerId); + if (idx >= 0) { + this.responseHandlers.splice(idx, 1); + } + } + buildLegacyTurnRequest(prompt, images, queryOptions) { + return { + text: prompt, + images, + externalContextPaths: queryOptions == null ? void 0 : queryOptions.externalContextPaths, + enabledMcpServers: queryOptions == null ? void 0 : queryOptions.enabledMcpServers + }; + } + buildQueryOptionsFromTurnRequest(request, encodedTurn, legacyQueryOptions) { + var _a3, _b2, _c, _d; + const mcpMentions = (legacyQueryOptions == null ? void 0 : legacyQueryOptions.mcpMentions) ? /* @__PURE__ */ new Set([...legacyQueryOptions.mcpMentions, ...encodedTurn.mcpMentions]) : encodedTurn.mcpMentions; + const effectiveQueryOptions = { + allowedTools: legacyQueryOptions == null ? void 0 : legacyQueryOptions.allowedTools, + model: legacyQueryOptions == null ? void 0 : legacyQueryOptions.model, + mcpMentions, + enabledMcpServers: (_a3 = request.enabledMcpServers) != null ? _a3 : legacyQueryOptions == null ? void 0 : legacyQueryOptions.enabledMcpServers, + forceColdStart: legacyQueryOptions == null ? void 0 : legacyQueryOptions.forceColdStart, + externalContextPaths: (_b2 = request.externalContextPaths) != null ? _b2 : legacyQueryOptions == null ? void 0 : legacyQueryOptions.externalContextPaths + }; + if (effectiveQueryOptions.allowedTools === void 0 && effectiveQueryOptions.model === void 0 && effectiveQueryOptions.enabledMcpServers === void 0 && effectiveQueryOptions.forceColdStart === void 0 && effectiveQueryOptions.externalContextPaths === void 0 && ((_d = (_c = effectiveQueryOptions.mcpMentions) == null ? void 0 : _c.size) != null ? _d : 0) === 0) { + return void 0; + } + return effectiveQueryOptions; + } + normalizeTurnInvocation(turnOrPrompt, imagesOrHistory, conversationHistoryOrQueryOptions, legacyQueryOptions) { + if (typeof turnOrPrompt !== "string") { + const turn = turnOrPrompt; + const conversationHistory2 = isChatMessageArray(imagesOrHistory) ? imagesOrHistory : void 0; + const explicitQueryOptions = isChatMessageArray(conversationHistoryOrQueryOptions) ? void 0 : conversationHistoryOrQueryOptions; + return { + request: turn.request, + encodedTurn: turn, + conversationHistory: conversationHistory2, + queryOptions: this.buildQueryOptionsFromTurnRequest(turn.request, turn, explicitQueryOptions) + }; + } + const images = isImageAttachmentArray(imagesOrHistory) ? imagesOrHistory : void 0; + const conversationHistory = isChatMessageArray(conversationHistoryOrQueryOptions) ? conversationHistoryOrQueryOptions : void 0; + const queryOptions = isChatMessageArray(conversationHistoryOrQueryOptions) ? legacyQueryOptions : conversationHistoryOrQueryOptions != null ? conversationHistoryOrQueryOptions : legacyQueryOptions; + const request = this.buildLegacyTurnRequest(turnOrPrompt, images, queryOptions); + const encodedTurn = this.prepareTurn(request); + return { + request, + encodedTurn, + conversationHistory, + queryOptions: this.buildQueryOptionsFromTurnRequest(request, encodedTurn, queryOptions) + }; + } + isPersistentQueryActive() { + return this.persistentQuery !== null && !this.shuttingDown; + } + async *query(turnOrPrompt, imagesOrHistory, conversationHistoryOrQueryOptions, legacyQueryOptions) { + var _a3; + const normalized = this.normalizeTurnInvocation( + turnOrPrompt, + imagesOrHistory, + conversationHistoryOrQueryOptions, + legacyQueryOptions + ); + const prompt = normalized.encodedTurn.prompt; + const images = normalized.request.images; + const conversationHistory = normalized.conversationHistory; + const queryOptions = normalized.queryOptions; + const vaultPath = getVaultPath(this.plugin.app); + if (!vaultPath) { + yield { type: "error", content: "Could not determine vault path" }; + return; + } + const resolvedClaudePath = this.plugin.getResolvedProviderCliPath("claude"); + if (!resolvedClaudePath) { + yield { type: "error", content: "Claude CLI not found. Please install Claude Code CLI." }; + return; + } + const customEnv = parseEnvironmentVariables(this.plugin.getActiveEnvironmentVariables(this.providerId)); + const enhancedPath = getEnhancedPath(customEnv.PATH, resolvedClaudePath); + const missingNodeError = getMissingNodeError(resolvedClaudePath, enhancedPath); + if (missingNodeError) { + yield { type: "error", content: missingNodeError }; + return; + } + let promptToSend = prompt; + let forceColdStart = false; + if (this.sessionManager.wasInterrupted()) { + this.sessionManager.clearInterrupted(); + } + if (this.sessionManager.needsHistoryRebuild() && conversationHistory && conversationHistory.length > 0) { + const historyContext = buildContextFromHistory(conversationHistory); + const actualPrompt = stripCurrentNoteContext(prompt); + promptToSend = buildPromptWithHistoryContext(historyContext, prompt, actualPrompt, conversationHistory); + this.sessionManager.clearHistoryRebuild(); + } + const noSessionButHasHistory = !this.sessionManager.getSessionId() && conversationHistory && conversationHistory.length > 0; + if (noSessionButHasHistory) { + const historyContext = buildContextFromHistory(conversationHistory); + const actualPrompt = stripCurrentNoteContext(prompt); + promptToSend = buildPromptWithHistoryContext(historyContext, prompt, actualPrompt, conversationHistory); + forceColdStart = true; + } + const effectiveQueryOptions = forceColdStart ? { ...queryOptions, forceColdStart: true } : queryOptions; + if (forceColdStart) { + this.coldStartInProgress = true; + this.closePersistentQuery("session invalidated"); + } + const shouldUsePersistent = !(effectiveQueryOptions == null ? void 0 : effectiveQueryOptions.forceColdStart); + if (shouldUsePersistent) { + if (!this.persistentQuery && !this.shuttingDown) { + await this.startPersistentQuery( + vaultPath, + resolvedClaudePath, + (_a3 = this.sessionManager.getSessionId()) != null ? _a3 : void 0 + ); + } + if (this.persistentQuery && !this.shuttingDown) { + try { + yield* this.queryViaPersistent(promptToSend, images, vaultPath, resolvedClaudePath, effectiveQueryOptions); + return; + } catch (error48) { + if (isSessionExpiredError(error48) && conversationHistory && conversationHistory.length > 0) { + this.sessionManager.invalidateSession(); + const retryRequest = this.buildHistoryRebuildRequest(prompt, conversationHistory); + this.coldStartInProgress = true; + this.abortController = new AbortController(); + try { + yield* this.queryViaSDK( + retryRequest.prompt, + vaultPath, + resolvedClaudePath, + // Use current message's images, fallback to history images + images != null ? images : retryRequest.images, + effectiveQueryOptions + ); + } catch (retryError) { + const msg = retryError instanceof Error ? retryError.message : "Unknown error"; + yield { type: "error", content: msg }; + } finally { + this.coldStartInProgress = false; + this.abortController = null; + } + return; + } + throw error48; + } + } + } + this.coldStartInProgress = true; + this.abortController = new AbortController(); + try { + yield* this.queryViaSDK(promptToSend, vaultPath, resolvedClaudePath, images, effectiveQueryOptions); + } catch (error48) { + if (isSessionExpiredError(error48) && conversationHistory && conversationHistory.length > 0) { + this.sessionManager.invalidateSession(); + const retryRequest = this.buildHistoryRebuildRequest(prompt, conversationHistory); + try { + yield* this.queryViaSDK( + retryRequest.prompt, + vaultPath, + resolvedClaudePath, + // Use current message's images, fallback to history images + images != null ? images : retryRequest.images, + effectiveQueryOptions + ); + } catch (retryError) { + const msg2 = retryError instanceof Error ? retryError.message : "Unknown error"; + yield { type: "error", content: msg2 }; + } + return; + } + const msg = error48 instanceof Error ? error48.message : "Unknown error"; + yield { type: "error", content: msg }; + } finally { + this.coldStartInProgress = false; + this.abortController = null; + } + } + buildHistoryRebuildRequest(prompt, conversationHistory) { + const historyContext = buildContextFromHistory(conversationHistory); + const actualPrompt = stripCurrentNoteContext(prompt); + const fullPrompt = buildPromptWithHistoryContext(historyContext, prompt, actualPrompt, conversationHistory); + const lastUserMessage = getLastUserMessage(conversationHistory); + return { + prompt: fullPrompt, + images: lastUserMessage == null ? void 0 : lastUserMessage.images + }; + } + /** + * Query via persistent query (Phase 1.5). + * Uses the message channel to send messages without cold-start latency. + */ + async *queryViaPersistent(prompt, images, vaultPath, cliPath, queryOptions) { + var _a3; + this.resetTurnMetadata(); + if (!this.persistentQuery || !this.messageChannel) { + yield* this.queryViaSDK(prompt, vaultPath, cliPath, images, queryOptions); + return; + } + if ((queryOptions == null ? void 0 : queryOptions.allowedTools) !== void 0) { + this.currentAllowedTools = queryOptions.allowedTools.length > 0 ? [...queryOptions.allowedTools, TOOL_SKILL] : []; + } else { + this.currentAllowedTools = null; + } + const savedAllowedTools = this.currentAllowedTools; + await this.applyDynamicUpdates(queryOptions); + this.currentAllowedTools = savedAllowedTools; + if (!this.persistentQuery || !this.messageChannel) { + yield* this.queryViaSDK(prompt, vaultPath, cliPath, images, queryOptions); + return; + } + if (!this.responseConsumerRunning) { + yield* this.queryViaSDK(prompt, vaultPath, cliPath, images, queryOptions); + return; + } + const message = this.buildSDKUserMessage(prompt, images); + const state = { + chunks: [], + resolveChunk: null, + done: false, + error: null + }; + const handlerId = `handler-${Date.now()}-${Math.random().toString(36).slice(2)}`; + const handler = createResponseHandler({ + id: handlerId, + onChunk: (chunk) => { + handler.markChunkSeen(); + if (state.resolveChunk) { + state.resolveChunk(chunk); + state.resolveChunk = null; + } else { + state.chunks.push(chunk); + } + }, + onDone: () => { + state.done = true; + if (state.resolveChunk) { + state.resolveChunk(null); + state.resolveChunk = null; + } + }, + onError: (err) => { + state.error = err; + state.done = true; + if (state.resolveChunk) { + state.resolveChunk(null); + state.resolveChunk = null; + } + } + }); + this.registerResponseHandler(handler); + try { + this.lastSentMessage = message; + this.lastSentQueryOptions = queryOptions != null ? queryOptions : null; + this.crashRecoveryAttempted = false; + try { + this.messageChannel.enqueue(message); + } catch (error48) { + if (error48 instanceof Error && error48.message.includes("closed")) { + yield* this.queryViaSDK(prompt, vaultPath, cliPath, images, queryOptions); + return; + } + throw error48; + } + this.recordTurnMetadata({ + userMessageId: (_a3 = message.uuid) != null ? _a3 : void 0, + wasSent: true + }); + while (!state.done) { + if (state.chunks.length > 0) { + yield state.chunks.shift(); + } else { + const chunk = await new Promise((resolve5) => { + state.resolveChunk = resolve5; + }); + if (chunk) { + yield chunk; + } + } + } + while (state.chunks.length > 0) { + yield state.chunks.shift(); + } + if (state.error) { + if (isSessionExpiredError(state.error)) { + throw state.error; + } + yield { type: "error", content: state.error.message }; + } + this.lastSentMessage = null; + this.lastSentQueryOptions = null; + yield { type: "done" }; + } finally { + this.unregisterResponseHandler(handlerId); + this.currentAllowedTools = null; + } + } + buildSDKUserMessage(prompt, images) { + return buildClaudeSDKUserMessage( + prompt, + this.sessionManager.getSessionId() || "", + images + ); + } + /** + * Apply dynamic updates to the persistent query before sending a message (Phase 1.6). + */ + async applyDynamicUpdates(queryOptions, restartOptions, allowRestart = true) { + await applyClaudeDynamicUpdates( + { + getPersistentQuery: () => this.persistentQuery, + getCurrentConfig: () => this.currentConfig, + mutateCurrentConfig: (mutate) => { + if (this.currentConfig) { + mutate(this.currentConfig); + } + }, + getVaultPath: () => this.vaultPath, + getCliPath: () => this.plugin.getResolvedProviderCliPath("claude"), + getScopedSettings: () => this.getScopedSettings(), + getPermissionMode: () => this.plugin.settings.permissionMode, + resolveSDKPermissionMode: (mode) => this.resolveSDKPermissionMode(mode), + mcpManager: this.mcpManager, + buildPersistentQueryConfig: (vaultPath, cliPath, externalContextPaths) => this.buildPersistentQueryConfig(vaultPath, cliPath, externalContextPaths), + needsRestart: (newConfig) => this.needsRestart(newConfig), + ensureReady: (options) => this.ensureReady(options), + setCurrentExternalContextPaths: (paths) => { + this.currentExternalContextPaths = paths; + }, + notifyFailure: (message) => { + new import_obsidian14.Notice(message); + } + }, + queryOptions, + restartOptions, + allowRestart + ); + } + isStreamTextEvent(message) { + var _a3, _b2; + if (message.type !== "stream_event") return false; + const event = message.event; + if (!event) return false; + if (event.type === "content_block_start") { + return ((_a3 = event.content_block) == null ? void 0 : _a3.type) === "text"; + } + if (event.type === "content_block_delta") { + return ((_b2 = event.delta) == null ? void 0 : _b2.type) === "text_delta"; + } + return false; + } + buildPromptWithImages(prompt, images) { + return buildClaudePromptWithImages(prompt, images); + } + async *queryViaSDK(prompt, cwd, cliPath, images, queryOptions) { + var _a3, _b2, _c; + this.resetTurnMetadata(); + const selectedModel = (queryOptions == null ? void 0 : queryOptions.model) || this.getScopedSettings().model; + this.sessionManager.setPendingModel(selectedModel); + this.vaultPath = cwd; + const queryPrompt = this.buildPromptWithImages(prompt, images); + const baseContext = this.buildQueryOptionsContext(cwd, cliPath); + const externalContextPaths = (queryOptions == null ? void 0 : queryOptions.externalContextPaths) || []; + const hooks = this.buildHooks(); + const hasEditorContext = prompt.includes(" 0) { + const toolSet = /* @__PURE__ */ new Set([...queryOptions.allowedTools, TOOL_SKILL]); + allowedTools = [...toolSet]; + } + const ctx = { + ...baseContext, + abortController: (_a3 = this.abortController) != null ? _a3 : void 0, + sessionId: (_b2 = this.sessionManager.getSessionId()) != null ? _b2 : void 0, + modelOverride: queryOptions == null ? void 0 : queryOptions.model, + canUseTool: this.createApprovalCallback(), + hooks, + mcpMentions: queryOptions == null ? void 0 : queryOptions.mcpMentions, + enabledMcpServers: queryOptions == null ? void 0 : queryOptions.enabledMcpServers, + allowedTools, + hasEditorContext, + externalContextPaths + }; + const options = QueryOptionsBuilder.buildColdStartQueryOptions(ctx); + let sawStreamText = false; + try { + const response = Qs({ prompt: queryPrompt, options }); + this.recordTurnMetadata({ wasSent: true }); + let streamSessionId = this.sessionManager.getSessionId(); + for await (const message of response) { + if (this.isStreamTextEvent(message)) { + sawStreamText = true; + } + if ((_c = this.abortController) == null ? void 0 : _c.signal.aborted) { + await response.interrupt(); + break; + } + for (const event of transformSDKMessage(message, this.getTransformOptions(selectedModel))) { + if (isSessionInitEvent(event)) { + this.sessionManager.captureSession(event.sessionId); + streamSessionId = event.sessionId; + } else if (isContextWindowEvent(event)) { + const usageChunk = this.updateBufferedUsageContextWindow(event.contextWindow); + if (usageChunk) { + yield usageChunk; + } + } else if (isStreamChunk(event)) { + if (message.type === "assistant" && sawStreamText && event.type === "text") { + continue; + } + if (event.type === "usage") { + yield this.bufferUsageChunk({ ...event, sessionId: streamSessionId }); + } else { + yield event; + } + } + } + if (message.type === "assistant" && message.uuid) { + this.recordTurnMetadata({ assistantMessageId: message.uuid }); + } + if (message.type === "result") { + sawStreamText = false; + } + } + } catch (error48) { + if (isSessionExpiredError(error48)) { + throw error48; + } + const msg = error48 instanceof Error ? error48.message : "Unknown error"; + yield { type: "error", content: msg }; + } finally { + this.sessionManager.clearPendingModel(); + this.currentAllowedTools = null; + } + yield { type: "done" }; + } + cancel() { + var _a3; + (_a3 = this.approvalDismisser) == null ? void 0 : _a3.call(this); + if (this.abortController) { + this.abortController.abort(); + this.sessionManager.markInterrupted(); + } + if (this.persistentQuery && !this.shuttingDown) { + void this.persistentQuery.interrupt().catch(() => { + }); + } + } + /** + * Reset the conversation session. + * Closes the persistent query since session is changing. + */ + resetSession() { + this.closePersistentQuery("session reset"); + this.crashRecoveryAttempted = false; + this.sessionManager.reset(); + } + getSessionId() { + return this.sessionManager.getSessionId(); + } + /** Consume session invalidation flag for persistence updates. */ + consumeSessionInvalidation() { + return this.sessionManager.consumeInvalidation(); + } + /** + * Check if the service is ready (persistent query is active). + * Used to determine if SDK skills are available. + */ + isReady() { + return this.isPersistentQueryActive(); + } + /** + * Get supported commands (SDK skills) from the persistent query. + * Returns an empty array if the query is not ready. + */ + async getSupportedCommands() { + if (!this.persistentQuery) { + return []; + } + try { + const sdkCommands = await this.persistentQuery.supportedCommands(); + return sdkCommands.map((cmd) => ({ + id: `sdk:${cmd.name}`, + name: cmd.name, + description: cmd.description, + argumentHint: cmd.argumentHint, + content: "", + // SDK skills don't need content - they're handled by the SDK + source: "sdk" + })); + } catch (e3) { + return []; + } + } + /** + * Set the session ID (for restoring from saved conversation). + * Closes persistent query synchronously if session is changing, then ensures query is ready. + * + * @param id - Session ID to restore, or null for new session + * @param externalContextPaths - External context paths for the session (prevents stale contexts) + */ + setSessionId(id, externalContextPaths) { + const currentId = this.sessionManager.getSessionId(); + const sessionChanged = currentId !== id; + if (sessionChanged) { + this.closePersistentQuery("session switch"); + this.crashRecoveryAttempted = false; + } + this.sessionManager.setSessionId(id, this.getScopedSettings().model); + if (externalContextPaths !== void 0) { + this.currentExternalContextPaths = externalContextPaths; + } + } + /** + * Cleanup resources (Phase 5). + * Called on plugin unload to close persistent query and abort any cold-start query. + */ + cleanup() { + this.closePersistentQuery("plugin cleanup"); + this.cancel(); + this.resetSession(); + } + async rewindFiles(userMessageId, dryRun) { + if (!this.persistentQuery) throw new Error("No active query"); + if (this.shuttingDown) throw new Error("Service is shutting down"); + return this.persistentQuery.rewindFiles(userMessageId, { dryRun }); + } + async rewind(userMessageId, assistantMessageId) { + return executeClaudeRewind(userMessageId, { + assistantMessageId, + rewindFiles: this.rewindFiles.bind(this), + closePersistentQuery: (reason) => this.closePersistentQuery(reason), + setPendingResumeAt: (resumeAt) => { + this.pendingResumeAt = resumeAt; + }, + vaultPath: this.vaultPath + }); + } + setApprovalCallback(callback) { + this.approvalCallback = callback; + } + setApprovalDismisser(dismisser) { + this.approvalDismisser = dismisser; + } + setAskUserQuestionCallback(callback) { + this.askUserQuestionCallback = callback; + } + setExitPlanModeCallback(callback) { + this.exitPlanModeCallback = callback; + } + setPermissionModeSyncCallback(callback) { + this.permissionModeSyncCallback = callback; + } + setSubagentHookProvider(getState) { + this._subagentStateProvider = getState; + } + setAutoTurnCallback(callback) { + this._autoTurnCallback = callback; + } + createApprovalCallback() { + return createClaudeApprovalCallback({ + getAllowedTools: () => this.currentAllowedTools, + getApprovalCallback: () => this.approvalCallback, + getAskUserQuestionCallback: () => this.askUserQuestionCallback, + getExitPlanModeCallback: () => this.exitPlanModeCallback, + getPermissionMode: () => this.plugin.settings.permissionMode, + resolveSDKPermissionMode: (mode) => this.resolveSDKPermissionMode(mode), + syncPermissionMode: (mode, sdkMode) => { + if (this.currentConfig) { + this.currentConfig.permissionMode = mode; + this.currentConfig.sdkPermissionMode = sdkMode; + } + } + }); + } + resolveSDKPermissionMode(mode) { + return QueryOptionsBuilder.resolveClaudeSdkPermissionMode( + mode, + getClaudeProviderSettings(this.plugin.settings).safeMode + ); + } +}; + +// src/providers/claude/runtime/ClaudeTaskResultInterpreter.ts +function extractAgentIdFromString(value) { + const regexPatterns = [ + /"agent_id"\s*:\s*"([^"]+)"/, + /"agentId"\s*:\s*"([^"]+)"/, + /agent_id[=:]\s*"?([a-zA-Z0-9_-]+)"?/i, + /agentId[=:]\s*"?([a-zA-Z0-9_-]+)"?/i + ]; + for (const pattern of regexPatterns) { + const match = value.match(pattern); + if (match && match[1]) { + return match[1]; + } + } + return null; +} +function extractResultFromTaskObject(task) { + if (!task || typeof task !== "object") { + return null; + } + const record2 = task; + const result = typeof record2.result === "string" ? record2.result.trim() : ""; + if (result.length > 0) { + return result; + } + const output = typeof record2.output === "string" ? record2.output.trim() : ""; + return output.length > 0 ? output : null; +} +function extractTextFromContentBlocks(content) { + if (!Array.isArray(content)) { + return null; + } + const firstTextBlock = content.find((block) => block && typeof block === "object" && block.type === "text" && typeof block.text === "string"); + if (!firstTextBlock || typeof firstTextBlock.text !== "string") { + return null; + } + const text = firstTextBlock.text.trim(); + return text.length > 0 ? text : null; +} +var ClaudeTaskResultInterpreter = class { + hasAsyncLaunchMarker(toolUseResult) { + var _a3; + if (!toolUseResult || typeof toolUseResult !== "object") { + return false; + } + const record2 = toolUseResult; + if (record2.isAsync === true) { + return true; + } + if (this.extractAgentId(toolUseResult)) { + return true; + } + const rawStatus = (_a3 = record2.retrieval_status) != null ? _a3 : record2.status; + if (typeof rawStatus === "string" && rawStatus.toLowerCase() === "async_launched") { + return true; + } + return typeof record2.outputFile === "string" && record2.outputFile.length > 0; + } + extractAgentId(toolUseResult) { + const directId = extractAgentIdFromToolUseResult(toolUseResult); + if (directId) { + return directId; + } + if (!toolUseResult || typeof toolUseResult !== "object") { + return null; + } + const record2 = toolUseResult; + if (Array.isArray(record2.content)) { + for (const block of record2.content) { + if (typeof block === "string") { + const extracted2 = extractAgentIdFromString(block); + if (extracted2) { + return extracted2; + } + continue; + } + if (!block || typeof block !== "object") { + continue; + } + const text = block.text; + if (typeof text !== "string") { + continue; + } + const extracted = extractAgentIdFromString(text); + if (extracted) { + return extracted; + } + } + } + if (typeof record2.content === "string") { + return extractAgentIdFromString(record2.content); + } + return null; + } + extractStructuredResult(toolUseResult) { + if (!toolUseResult || typeof toolUseResult !== "object") { + return null; + } + const record2 = toolUseResult; + if (record2.retrieval_status === "error") { + const errorMsg = typeof record2.error === "string" ? record2.error : "Task retrieval failed"; + return `Error: ${errorMsg}`; + } + const taskResult = extractResultFromTaskObject(record2.task); + if (taskResult) { + return taskResult; + } + const result = typeof record2.result === "string" ? record2.result.trim() : ""; + if (result.length > 0) { + return result; + } + const output = typeof record2.output === "string" ? record2.output.trim() : ""; + if (output.length > 0) { + return output; + } + return extractTextFromContentBlocks(record2.content); + } + resolveTerminalStatus(toolUseResult, fallbackStatus) { + const resolved = resolveToolUseResultStatus(toolUseResult, fallbackStatus); + if (resolved === "error") { + return "error"; + } + if (resolved === "completed") { + return "completed"; + } + return fallbackStatus; + } + extractTagValue(payload, tagName) { + return extractXmlTag(payload, tagName); + } +}; + +// src/providers/claude/ui/ClaudeChatUIConfig.ts +var CLAUDE_ICON = { + viewBox: "0 -.01 39.5 39.53", + path: "m7.75 26.27 7.77-4.36.13-.38-.13-.21h-.38l-1.3-.08-4.44-.12-3.85-.16-3.73-.2-.94-.2-.88-1.16.09-.58.79-.53 1.13.1 2.5.17 3.75.26 2.72.16 4.03.42h.64l.09-.26-.22-.16-.17-.16-3.88-2.63-4.2-2.78-2.2-1.6-1.19-.81-.6-.76-.26-1.66 1.08-1.19 1.45.1.37.1 1.47 1.13 3.14 2.43 4.1 3.02.6.5.24-.17.03-.12-.27-.45-2.23-4.03-2.38-4.1-1.06-1.7-.28-1.02c-.1-.42-.17-.77-.17-1.2l1.23-1.67.68-.22 1.64.22.69.6 1.02 2.33 1.65 3.67 2.56 4.99.75 1.48.4 1.37.15.42h.26v-.24l.21-2.81.39-3.45.38-4.44.13-1.25.62-1.5 1.23-.81.96.46.79 1.13-.11.73-.47 3.05-.92 4.78-.6 3.2h.35l.4-.4 1.62-2.15 2.72-3.4 1.2-1.35 1.4-1.49.9-.71h1.7l1.25 1.86-.56 1.92-1.75 2.22-1.45 1.88-2.08 2.8-1.3 2.24.12.18.31-.03 4.7-1 2.54-.46 3.03-.52 1.37.64.15.65-.54 1.33-3.24.8-3.8.76-5.66 1.34-.07.05.08.1 2.55.24 1.09.06h2.67l4.97.37 1.3.86.78 1.05-.13.8-2 1.02-2.7-.64-6.3-1.5-2.16-.54h-.3v.18l1.8 1.76 3.3 2.98 4.13 3.84.21.95-.53.75-.56-.08-3.63-2.73-1.4-1.23-3.17-2.67h-.21v.28l.73 1.07 3.86 5.8.2 1.78-.28.58-1 .35-1.1-.2-2.26-3.17-2.33-3.57-1.88-3.2-.23.13-1.11 11.95-.52.61-1.2.46-1-.76-.53-1.23.53-2.43.64-3.17.52-2.52.47-3.13.28-1.04-.02-.07-.23.03-2.36 3.24-3.59 4.85-2.84 3.04-.68.27-1.18-.61.11-1.09.66-.97 3.93-5 2.37-3.1 1.53-1.79-.01-.26h-.09l-10.44 6.78-1.86.24-.8-.75.1-1.23.38-.4 3.14-2.16z" +}; +var CLAUDE_PERMISSION_MODE_TOGGLE = { + inactiveValue: "normal", + inactiveLabel: "Safe", + activeValue: "yolo", + activeLabel: "YOLO", + planValue: "plan", + planLabel: "PLAN" +}; +var claudeChatUIConfig = { + getModelOptions(settings11) { + const customModels = getModelsFromEnvironment( + getRuntimeEnvironmentVariables(settings11, "claude") + ); + if (customModels.length > 0) { + return customModels; + } + const models = [...DEFAULT_CLAUDE_MODELS]; + const claudeSettings = getClaudeProviderSettings(settings11); + return filterVisibleModelOptions( + models, + claudeSettings.enableOpus1M, + claudeSettings.enableSonnet1M + ); + }, + ownsModel(model, settings11) { + return this.getModelOptions(settings11).some((option) => option.value === model); + }, + isAdaptiveReasoningModel(model) { + return isAdaptiveThinkingModel(model); + }, + getReasoningOptions(model) { + if (isAdaptiveThinkingModel(model)) { + return EFFORT_LEVELS.map((e3) => ({ value: e3.value, label: e3.label })); + } + return THINKING_BUDGETS.map((b) => ({ value: b.value, label: b.label, tokens: b.tokens })); + }, + getDefaultReasoningValue(model) { + var _a3, _b2; + if (isAdaptiveThinkingModel(model)) { + return (_a3 = DEFAULT_EFFORT_LEVEL[model]) != null ? _a3 : "high"; + } + return (_b2 = DEFAULT_THINKING_BUDGET[model]) != null ? _b2 : "off"; + }, + getContextWindowSize(model, customLimits) { + return getContextWindowSize(model, customLimits); + }, + isDefaultModel(model) { + return DEFAULT_CLAUDE_MODELS.some((m3) => m3.value === model); + }, + applyModelDefaults(model, settings11) { + var _a3; + if (DEFAULT_CLAUDE_MODELS.some((m3) => m3.value === model)) { + const target = settings11; + target.thinkingBudget = DEFAULT_THINKING_BUDGET[model]; + if (isAdaptiveThinkingModel(model)) { + target.effortLevel = (_a3 = DEFAULT_EFFORT_LEVEL[model]) != null ? _a3 : "high"; + } + updateClaudeProviderSettings(target, { lastModel: model }); + } else { + settings11.lastCustomModel = model; + } + }, + normalizeModelVariant(model, settings11) { + const claudeSettings = getClaudeProviderSettings(settings11); + return normalizeVisibleModelVariant( + model, + claudeSettings.enableOpus1M, + claudeSettings.enableSonnet1M + ); + }, + getCustomModelIds(envVars) { + return getCustomModelIds(envVars); + }, + getPermissionModeToggle() { + return CLAUDE_PERMISSION_MODE_TOGGLE; + }, + isBangBashEnabled(settings11) { + return getClaudeProviderSettings(settings11).enableBangBash; + }, + getProviderIcon() { + return CLAUDE_ICON; + } +}; + +// src/providers/claude/registration.ts +var claudeProviderRegistration = { + displayName: "Claude", + blankTabOrder: 20, + isEnabled: () => true, + capabilities: CLAUDE_PROVIDER_CAPABILITIES, + environmentKeyPatterns: [/^ANTHROPIC_/i, /^CLAUDE_/i], + chatUIConfig: claudeChatUIConfig, + settingsReconciler: claudeSettingsReconciler, + createRuntime: ({ plugin }) => { + const workspace = getClaudeWorkspaceServices(); + const resolvedMcpManager = workspace == null ? void 0 : workspace.mcpManager; + if (!resolvedMcpManager) { + throw new Error("Claude workspace services are not initialized."); + } + return new ClaudianService(plugin, { + mcpManager: resolvedMcpManager, + pluginManager: workspace == null ? void 0 : workspace.pluginManager, + agentManager: workspace == null ? void 0 : workspace.agentManager + }); + }, + createTitleGenerationService: (plugin) => new TitleGenerationService(plugin), + createInstructionRefineService: (plugin) => new InstructionRefineService(plugin), + createInlineEditService: (plugin) => new InlineEditService(plugin), + historyService: new ClaudeConversationHistoryService(), + taskResultInterpreter: new ClaudeTaskResultInterpreter() +}; + +// src/providers/codex/app/CodexWorkspaceServices.ts +init_path(); + +// src/providers/codex/agents/CodexAgentMentionProvider.ts +var CodexAgentMentionProvider = class { + constructor(storage) { + this.storage = storage; + this.agents = []; + } + async loadAgents() { + this.agents = await this.storage.loadAll(); + } + searchAgents(query) { + const q3 = query.toLowerCase(); + return this.agents.filter( + (a3) => a3.name.toLowerCase().includes(q3) || a3.description.toLowerCase().includes(q3) + ).map((a3) => ({ + id: a3.name, + name: a3.name, + description: a3.description, + source: "vault" + })); + } +}; + +// src/providers/codex/runtime/CodexAppServerProcess.ts +var import_child_process4 = require("child_process"); +var SIGKILL_TIMEOUT_MS = 3e3; +var CodexAppServerProcess = class { + constructor(launchSpec) { + this.launchSpec = launchSpec; + this.proc = null; + this.alive = false; + this.exitCallbacks = []; + } + start() { + this.proc = (0, import_child_process4.spawn)(this.launchSpec.command, this.launchSpec.args, { + stdio: ["pipe", "pipe", "pipe"], + cwd: this.launchSpec.spawnCwd, + env: this.launchSpec.env + }); + this.alive = true; + this.proc.on("exit", (code, signal) => { + this.alive = false; + for (const cb2 of this.exitCallbacks) { + cb2(code, signal); + } + }); + this.proc.on("error", () => { + this.alive = false; + }); + } + get stdin() { + var _a3; + if (!((_a3 = this.proc) == null ? void 0 : _a3.stdin)) throw new Error("Process not started"); + return this.proc.stdin; + } + get stdout() { + var _a3; + if (!((_a3 = this.proc) == null ? void 0 : _a3.stdout)) throw new Error("Process not started"); + return this.proc.stdout; + } + get stderr() { + var _a3; + if (!((_a3 = this.proc) == null ? void 0 : _a3.stderr)) throw new Error("Process not started"); + return this.proc.stderr; + } + isAlive() { + return this.alive; + } + onExit(callback) { + this.exitCallbacks.push(callback); + } + offExit(callback) { + const idx = this.exitCallbacks.indexOf(callback); + if (idx !== -1) this.exitCallbacks.splice(idx, 1); + } + async shutdown() { + if (!this.proc || !this.alive) return; + return new Promise((resolve5) => { + const onExit = () => { + clearTimeout(killTimer); + resolve5(); + }; + this.proc.once("exit", onExit); + this.proc.kill("SIGTERM"); + const killTimer = setTimeout(() => { + if (this.alive) { + this.proc.kill("SIGKILL"); + } + }, SIGKILL_TIMEOUT_MS); + }); + } +}; + +// src/providers/codex/runtime/codexAppServerSupport.ts +init_env(); +init_path(); + +// src/providers/codex/runtime/CodexExecutionTargetResolver.ts +var import_child_process5 = require("child_process"); +function resolveHostPlatformOs(hostPlatform) { + if (hostPlatform === "win32") { + return "windows"; + } + if (hostPlatform === "darwin") { + return "macos"; + } + return "linux"; +} +function resolveHostPlatformFamily(hostPlatform) { + return hostPlatform === "win32" ? "windows" : "unix"; +} +function inferWslDistroFromWindowsPath(hostPath) { + if (!hostPath) { + return void 0; + } + const normalized = hostPath.replace(/\//g, "\\"); + const match = normalized.match(/^\\\\wsl\$\\([^\\]+)(?:\\|$)/i); + return (match == null ? void 0 : match[1]) || void 0; +} +function parseDefaultWslDistroListOutput(output) { + var _a3; + for (const line of output.replace(/\uFEFF/g, "").split(/\r?\n/)) { + const trimmed = line.trimStart(); + if (!trimmed.startsWith("*")) { + continue; + } + const candidate = (_a3 = trimmed.slice(1).trimStart().split(/\s{2,}/)[0]) == null ? void 0 : _a3.trim(); + if (candidate) { + return candidate; + } + } + return void 0; +} +function resolveDefaultWslDistroName() { + try { + const output = (0, import_child_process5.execFileSync)("wsl.exe", ["--list", "--verbose"], { + encoding: "utf8", + stdio: ["ignore", "pipe", "ignore"], + windowsHide: true + }); + return parseDefaultWslDistroListOutput(output); + } catch (e3) { + return void 0; + } +} +function resolveCodexExecutionTarget(options) { + var _a3, _b2; + const hostPlatform = (_a3 = options.hostPlatform) != null ? _a3 : process.platform; + if (hostPlatform !== "win32") { + return { + method: "host-native", + platformFamily: resolveHostPlatformFamily(hostPlatform), + platformOs: resolveHostPlatformOs(hostPlatform) + }; + } + const codexSettings = getCodexProviderSettings(options.settings); + if (codexSettings.installationMethod === "wsl") { + const distroName = codexSettings.wslDistroOverride || inferWslDistroFromWindowsPath(options.hostVaultPath) || ((_b2 = options.resolveDefaultWslDistro) == null ? void 0 : _b2.call(options)) || resolveDefaultWslDistroName(); + return { + method: "wsl", + platformFamily: "unix", + platformOs: "linux", + distroName + }; + } + return { + method: "native-windows", + platformFamily: "windows", + platformOs: "windows" + }; +} + +// src/providers/codex/runtime/CodexPathMapper.ts +var path10 = __toESM(require("path")); +function normalizeWindowsPath(value) { + if (!value) { + return ""; + } + let normalized = value.replace(/\//g, "\\"); + if (normalized.startsWith("\\\\?\\UNC\\")) { + normalized = `\\\\${normalized.slice("\\\\?\\UNC\\".length)}`; + } else if (normalized.startsWith("\\\\?\\")) { + normalized = normalized.slice("\\\\?\\".length); + } + return path10.win32.normalize(normalized); +} +function normalizePosixPath(value) { + if (!value) { + return ""; + } + const normalized = path10.posix.normalize(value.replace(/\\/g, "/")); + return normalized === "/" ? normalized : normalized.replace(/\/+$/, ""); +} +function maybeMapWindowsDriveToWsl(hostPath) { + var _a3; + const normalized = normalizeWindowsPath(hostPath); + const match = normalized.match(/^([A-Za-z]):(?:\\(.*))?$/); + if (!match) { + return null; + } + const drive = match[1].toLowerCase(); + const tail = ((_a3 = match[2]) != null ? _a3 : "").replace(/\\/g, "/"); + return tail ? `/mnt/${drive}/${tail}` : `/mnt/${drive}`; +} +function maybeMapWslUncToLinux(hostPath, distroName) { + const normalized = normalizeWindowsPath(hostPath); + const match = normalized.match(/^\\\\wsl\$\\([^\\]+)(?:\\(.*))?$/i); + if (!match) { + return null; + } + const uncDistro = match[1]; + if (distroName && uncDistro.toLowerCase() !== distroName.toLowerCase()) { + return null; + } + const tail = match[2] ? match[2].replace(/\\/g, "/") : ""; + return tail ? `/${tail}` : "/"; +} +function maybeMapLinuxToWindowsDrive(targetPath) { + const normalized = normalizePosixPath(targetPath); + const match = normalized.match(/^\/mnt\/([a-zA-Z])(?:\/(.*))?$/); + if (!match) { + return null; + } + const drive = match[1].toUpperCase(); + const tail = match[2] ? match[2].replace(/\//g, "\\") : ""; + return tail ? `${drive}:\\${tail}` : `${drive}:\\`; +} +function maybeMapLinuxToWslUnc(targetPath, distroName) { + if (!distroName) { + return null; + } + const normalized = normalizePosixPath(targetPath); + if (!normalized.startsWith("/")) { + return null; + } + const tail = normalized === "/" ? "" : normalized.slice(1).replace(/\//g, "\\"); + return tail ? `\\\\wsl$\\${distroName}\\${tail}` : `\\\\wsl$\\${distroName}`; +} +function createIdentityMapper(target) { + return { + target, + toTargetPath(hostPath) { + if (!hostPath) { + return null; + } + return target.platformFamily === "windows" ? normalizeWindowsPath(hostPath) : normalizePosixPath(hostPath); + }, + toHostPath(targetPath) { + if (!targetPath) { + return null; + } + return target.platformFamily === "windows" ? normalizeWindowsPath(targetPath) : normalizePosixPath(targetPath); + }, + mapTargetPathList(hostPaths) { + return hostPaths.map((hostPath) => this.toTargetPath(hostPath)).filter((value) => typeof value === "string" && value.length > 0); + }, + canRepresentHostPath(hostPath) { + return this.toTargetPath(hostPath) !== null; + } + }; +} +function createWslPathMapper(target) { + return { + target, + toTargetPath(hostPath) { + var _a3; + if (!hostPath) { + return null; + } + return (_a3 = maybeMapWslUncToLinux(hostPath, target.distroName)) != null ? _a3 : maybeMapWindowsDriveToWsl(hostPath); + }, + toHostPath(targetPath) { + var _a3; + if (!targetPath) { + return null; + } + return (_a3 = maybeMapLinuxToWindowsDrive(targetPath)) != null ? _a3 : maybeMapLinuxToWslUnc(targetPath, target.distroName); + }, + mapTargetPathList(hostPaths) { + return hostPaths.map((hostPath) => this.toTargetPath(hostPath)).filter((value) => typeof value === "string" && value.length > 0); + }, + canRepresentHostPath(hostPath) { + return this.toTargetPath(hostPath) !== null; + } + }; +} +function createCodexPathMapper(target) { + return target.method === "wsl" ? createWslPathMapper(target) : createIdentityMapper(target); +} + +// src/providers/codex/runtime/CodexLaunchSpecBuilder.ts +var CODEX_APP_SERVER_ARGS = Object.freeze(["app-server", "--listen", "stdio://"]); +function buildCodexLaunchSpec(options) { + var _a3, _b2; + const target = resolveCodexExecutionTarget({ + settings: options.settings, + hostPlatform: options.hostPlatform, + hostVaultPath: options.hostVaultPath, + resolveDefaultWslDistro: options.resolveDefaultWslDistro + }); + const pathMapper = createCodexPathMapper(target); + const spawnCwd = (_a3 = options.hostVaultPath) != null ? _a3 : process.cwd(); + const workspaceDistro = inferWslDistroFromWindowsPath(options.hostVaultPath); + if (target.method === "wsl" && target.distroName && workspaceDistro && target.distroName.toLowerCase() !== workspaceDistro.toLowerCase()) { + throw new Error( + `WSL distro override "${target.distroName}" does not match workspace distro "${workspaceDistro}"` + ); + } + if (target.method === "wsl" && !target.distroName) { + throw new Error( + "Unable to determine the WSL distro. Set WSL distro override or configure a default WSL distro." + ); + } + const targetCwd = pathMapper.toTargetPath(spawnCwd); + if (!targetCwd) { + throw new Error("WSL mode only supports Windows drive paths and \\\\wsl$ workspace paths"); + } + const resolvedCliCommand = ((_b2 = options.resolvedCliCommand) == null ? void 0 : _b2.trim()) || "codex"; + if (target.method === "wsl") { + const args = [ + ...target.distroName ? ["--distribution", target.distroName] : [], + "--cd", + targetCwd, + resolvedCliCommand, + ...CODEX_APP_SERVER_ARGS + ]; + return { + target, + command: "wsl.exe", + args, + spawnCwd, + targetCwd, + env: options.env, + pathMapper + }; + } + return { + target, + command: resolvedCliCommand, + args: [...CODEX_APP_SERVER_ARGS], + spawnCwd, + targetCwd, + env: options.env, + pathMapper + }; +} + +// src/providers/codex/runtime/codexAppServerSupport.ts +var CODEX_APP_SERVER_CLIENT_INFO = Object.freeze({ + name: "claudian", + version: "1.0.0" +}); +function getCodexAppServerWorkingDirectory(plugin) { + var _a3; + return (_a3 = getVaultPath(plugin.app)) != null ? _a3 : process.cwd(); +} +function buildCodexAppServerEnvironment(plugin, providerId = "codex") { + const customEnv = parseEnvironmentVariables(plugin.getActiveEnvironmentVariables(providerId)); + const baseEnv = Object.fromEntries( + Object.entries(process.env).filter((entry) => entry[1] !== void 0) + ); + const enhancedPath = getEnhancedPath(customEnv.PATH); + return { + ...baseEnv, + ...customEnv, + PATH: enhancedPath + }; +} +function resolveCodexAppServerLaunchSpec(plugin, providerId = "codex") { + return buildCodexLaunchSpec({ + settings: plugin.settings, + resolvedCliCommand: plugin.getResolvedProviderCliPath(providerId), + hostVaultPath: getCodexAppServerWorkingDirectory(plugin), + env: buildCodexAppServerEnvironment(plugin, providerId) + }); +} +async function initializeCodexAppServerTransport(transport) { + const result = await transport.request("initialize", { + clientInfo: CODEX_APP_SERVER_CLIENT_INFO, + capabilities: { experimentalApi: true } + }); + transport.notify("initialized"); + return result; +} + +// src/providers/codex/runtime/CodexRpcTransport.ts +var import_readline2 = require("readline"); +var DEFAULT_TIMEOUT_MS = 3e4; +var CodexRpcTransport = class { + constructor(proc) { + this.proc = proc; + this.nextId = 1; + this.pending = /* @__PURE__ */ new Map(); + this.notificationHandlers = /* @__PURE__ */ new Map(); + this.serverRequestHandlers = /* @__PURE__ */ new Map(); + this.disposed = false; + } + start() { + const rl2 = (0, import_readline2.createInterface)({ input: this.proc.stdout }); + rl2.on("line", (line) => this.handleLine(line)); + this.proc.onExit(() => { + this.rejectAllPending(new Error("App-server process exited")); + }); + } + request(method, params, timeoutMs = DEFAULT_TIMEOUT_MS) { + const id = this.nextId++; + const msg = { jsonrpc: "2.0", id, method, params }; + return new Promise((resolve5, reject) => { + const timer = timeoutMs > 0 ? setTimeout(() => { + this.pending.delete(id); + reject(new Error(`Request timeout: ${method} (${timeoutMs}ms)`)); + }, timeoutMs) : null; + this.pending.set(id, { + resolve: resolve5, + reject, + timer + }); + this.sendRaw(msg); + }); + } + notify(method, params) { + const msg = { jsonrpc: "2.0", method }; + if (params !== void 0) msg.params = params; + this.sendRaw(msg); + } + onNotification(method, handler) { + this.notificationHandlers.set(method, handler); + } + onServerRequest(method, handler) { + this.serverRequestHandlers.set(method, handler); + } + dispose() { + this.disposed = true; + this.rejectAllPending(new Error("Transport disposed")); + } + // ----------------------------------------------------------------------- + // Private + // ----------------------------------------------------------------------- + sendRaw(msg) { + if (this.disposed) return; + this.proc.stdin.write(JSON.stringify(msg) + "\n"); + } + handleLine(line) { + let msg; + try { + msg = JSON.parse(line); + } catch (e3) { + return; + } + const id = msg.id; + const method = msg.method; + if (typeof id === "number" && !method) { + this.handleResponse(id, msg); + return; + } + if (method && id === void 0) { + this.handleNotification(method, msg.params); + return; + } + if (method && id !== void 0) { + this.handleServerRequest(id, method, msg.params); + return; + } + } + handleResponse(id, msg) { + const pending = this.pending.get(id); + if (!pending) return; + this.pending.delete(id); + if (pending.timer) clearTimeout(pending.timer); + if (msg.error) { + const err = msg.error; + pending.reject(new Error(err.message)); + } else { + pending.resolve(msg.result); + } + } + handleNotification(method, params) { + const handler = this.notificationHandlers.get(method); + if (handler) handler(params); + } + handleServerRequest(id, method, params) { + const handler = this.serverRequestHandlers.get(method); + if (!handler) { + this.sendRaw({ + jsonrpc: "2.0", + id, + error: { code: -32601, message: `Unhandled server request: ${method}` } + }); + return; + } + handler(id, params).then( + (result) => { + this.sendRaw({ jsonrpc: "2.0", id, result }); + }, + (err) => { + this.sendRaw({ + jsonrpc: "2.0", + id, + error: { code: -32603, message: err instanceof Error ? err.message : "Internal error" } + }); + } + ); + } + rejectAllPending(error48) { + for (const [, pending] of this.pending) { + if (pending.timer) clearTimeout(pending.timer); + pending.reject(error48); + } + this.pending.clear(); + } +}; + +// src/providers/codex/runtime/CodexRuntimeContext.ts +var path11 = __toESM(require("path")); +function normalizeTargetPath(launchSpec, value) { + return launchSpec.target.platformFamily === "windows" ? path11.win32.normalize(value) : path11.posix.normalize(value.replace(/\\/g, "/")); +} +function joinTargetPath(launchSpec, ...parts) { + return launchSpec.target.platformFamily === "windows" ? path11.win32.join(...parts) : path11.posix.join(...parts.map((part) => part.replace(/\\/g, "/"))); +} +function validateInitializeTarget(launchSpec, initializeResult) { + if (initializeResult.platformOs !== launchSpec.target.platformOs) { + throw new Error( + `Codex target mismatch: expected ${launchSpec.target.platformOs}, received ${initializeResult.platformOs}` + ); + } + if (initializeResult.platformFamily !== launchSpec.target.platformFamily) { + throw new Error( + `Codex target mismatch: expected ${launchSpec.target.platformFamily}, received ${initializeResult.platformFamily}` + ); + } +} +function createCodexRuntimeContext(launchSpec, initializeResult) { + validateInitializeTarget(launchSpec, initializeResult); + const codexHomeTarget = normalizeTargetPath(launchSpec, initializeResult.codexHome); + const sessionsDirTarget = joinTargetPath(launchSpec, codexHomeTarget, "sessions"); + const memoriesDirTarget = joinTargetPath(launchSpec, codexHomeTarget, "memories"); + return { + launchSpec, + initializeResult, + codexHomeTarget, + codexHomeHost: launchSpec.pathMapper.toHostPath(codexHomeTarget), + sessionsDirTarget, + sessionsDirHost: launchSpec.pathMapper.toHostPath(sessionsDirTarget), + memoriesDirTarget + }; +} + +// src/providers/codex/skills/CodexSkillListingService.ts +var DEFAULT_SKILL_LIST_TTL_MS = 5e3; +var SKILL_SCOPE_PRIORITY = { + repo: 0, + user: 1, + system: 2, + admin: 3 +}; +function compareCodexSkillPriority(left, right) { + const scopeDelta = SKILL_SCOPE_PRIORITY[left.scope] - SKILL_SCOPE_PRIORITY[right.scope]; + if (scopeDelta !== 0) { + return scopeDelta; + } + const nameDelta = left.name.localeCompare(right.name); + if (nameDelta !== 0) { + return nameDelta; + } + return left.path.localeCompare(right.path); +} +function extractExplicitCodexSkillNames(text) { + const matches = text.matchAll(/(^|\s)\$([A-Za-z0-9_-]+)/g); + const names = []; + const seen = /* @__PURE__ */ new Set(); + for (const match of matches) { + const name = match[2]; + if (!name) { + continue; + } + const normalized = name.toLowerCase(); + if (seen.has(normalized)) { + continue; + } + seen.add(normalized); + names.push(name); + } + return names; +} +function getCodexSkillDescription(skill) { + var _a3, _b2, _c, _d; + return (_d = (_c = (_b2 = (_a3 = skill.interface) == null ? void 0 : _a3.shortDescription) != null ? _b2 : skill.shortDescription) != null ? _c : skill.description) != null ? _d : void 0; +} +function findPreferredCodexSkillByName(skills, name) { + var _a3; + const normalized = name.toLowerCase(); + const candidates = skills.filter((skill) => skill.enabled && skill.name.toLowerCase() === normalized).sort(compareCodexSkillPriority); + return (_a3 = candidates[0]) != null ? _a3 : null; +} +var CodexSkillListingService = class { + constructor(plugin, options = {}) { + this.plugin = plugin; + this.cache = null; + this.cacheExpiresAt = 0; + this.pending = null; + var _a3, _b2; + this.ttlMs = (_a3 = options.ttlMs) != null ? _a3 : DEFAULT_SKILL_LIST_TTL_MS; + this.now = (_b2 = options.now) != null ? _b2 : (() => Date.now()); + } + async listSkills(options) { + if (options == null ? void 0 : options.forceReload) { + const skills = await this.fetchSkills(true); + this.storeCache(skills); + return skills; + } + if (this.cache && this.now() < this.cacheExpiresAt) { + return this.cache; + } + if (this.pending) { + return this.pending; + } + this.pending = this.fetchSkills(false).then((skills) => { + this.storeCache(skills); + return skills; + }).finally(() => { + this.pending = null; + }); + return this.pending; + } + invalidate() { + this.cache = null; + this.cacheExpiresAt = 0; + } + async fetchSkills(forceReload) { + var _a3, _b2; + const launchSpec = resolveCodexAppServerLaunchSpec(this.plugin, "codex"); + const process4 = new CodexAppServerProcess(launchSpec); + process4.start(); + const transport = new CodexRpcTransport(process4); + transport.start(); + try { + const initializeResult = await initializeCodexAppServerTransport(transport); + createCodexRuntimeContext(launchSpec, initializeResult); + const result = await transport.request("skills/list", { + cwds: [launchSpec.targetCwd], + ...forceReload ? { forceReload: true } : {} + }); + const entry = (_a3 = result.data.find((candidate) => candidate.cwd === launchSpec.targetCwd)) != null ? _a3 : result.data[0]; + return ((_b2 = entry == null ? void 0 : entry.skills) != null ? _b2 : []).map((skill) => { + var _a4; + return { + ...skill, + path: (_a4 = launchSpec.pathMapper.toHostPath(skill.path)) != null ? _a4 : skill.path + }; + }); + } finally { + transport.dispose(); + await process4.shutdown(); + } + } + storeCache(skills) { + this.cache = skills; + this.cacheExpiresAt = this.now() + this.ttlMs; + } +}; + +// src/providers/codex/storage/CodexSkillStorage.ts +var path12 = __toESM(require("path")); +var CODEX_VAULT_SKILLS_PATH = ".codex/skills"; +var AGENTS_VAULT_SKILLS_PATH = ".agents/skills"; +var CODEX_SKILL_ROOT_OPTIONS = [ + { id: "vault-codex", label: CODEX_VAULT_SKILLS_PATH }, + { id: "vault-agents", label: AGENTS_VAULT_SKILLS_PATH } +]; +var ROOT_PATH_BY_ID = { + "vault-codex": CODEX_VAULT_SKILLS_PATH, + "vault-agents": AGENTS_VAULT_SKILLS_PATH +}; +var ROOT_ID_BY_PATH = new Map( + Object.entries(ROOT_PATH_BY_ID).map(([rootId, rootPath]) => [rootPath, rootId]) +); +var ALL_SCAN_ROOTS = ["vault-codex", "vault-agents"]; +var SKILL_PERSISTENCE_PREFIX = "codex-skill"; +function createCodexSkillPersistenceKey(state) { + const parts = [SKILL_PERSISTENCE_PREFIX, state.rootId]; + if (state.currentName) { + parts.push(encodeURIComponent(state.currentName)); + } + return parts.join(":"); +} +function parseCodexSkillPersistenceKey(persistenceKey) { + if (!persistenceKey) { + return null; + } + const legacyRootId = ROOT_ID_BY_PATH.get(persistenceKey); + if (legacyRootId) { + return { rootId: legacyRootId }; + } + const [prefix, rootId, encodedName] = persistenceKey.split(":"); + if (prefix !== SKILL_PERSISTENCE_PREFIX) { + return null; + } + if (rootId !== "vault-codex" && rootId !== "vault-agents") { + return null; + } + return { + rootId, + ...encodedName ? { currentName: decodeURIComponent(encodedName) } : {} + }; +} +function resolveCodexSkillLocationFromPath(skillPath, vaultPath) { + const usesWindowsPathSemantics = /^[A-Za-z]:[\\/]/.test(skillPath) || /^[A-Za-z]:[\\/]/.test(vaultPath) || skillPath.startsWith("\\\\") || vaultPath.startsWith("\\\\"); + const pathApi = usesWindowsPathSemantics ? path12.win32 : path12.posix; + const normalizedSkillPath = pathApi.normalize(skillPath); + const normalizedVaultPath = pathApi.normalize(vaultPath); + for (const [rootId, rootPath] of Object.entries(ROOT_PATH_BY_ID)) { + const rootDir = pathApi.normalize(pathApi.join(normalizedVaultPath, rootPath)); + const relative3 = pathApi.relative(rootDir, normalizedSkillPath); + if (!relative3 || relative3.startsWith(`..${pathApi.sep}`) || relative3 === "..") { + continue; + } + const parts = relative3.split(pathApi.sep); + if (parts.length !== 2 || parts[1] !== "SKILL.md" || !parts[0]) { + continue; + } + return { + name: parts[0], + rootId + }; + } + return null; +} +var CodexSkillStorage = class { + constructor(vaultAdapter, homeAdapter) { + this.vaultAdapter = vaultAdapter; + this.homeAdapter = homeAdapter; + } + async scanAll() { + const vaultSkills = await this.scanRoots(this.vaultAdapter, ALL_SCAN_ROOTS, "vault"); + const homeSkills = this.homeAdapter ? await this.scanRoots(this.homeAdapter, ALL_SCAN_ROOTS, "home") : []; + const seen = new Set(vaultSkills.map((s3) => s3.name.toLowerCase())); + const deduped = homeSkills.filter((s3) => !seen.has(s3.name.toLowerCase())); + return [...vaultSkills, ...deduped]; + } + async scanVault() { + return this.scanRoots(this.vaultAdapter, ALL_SCAN_ROOTS, "vault"); + } + async save(input) { + var _a3; + const targetRootId = (_a3 = input.rootId) != null ? _a3 : "vault-codex"; + const targetLocation = { rootId: targetRootId, name: input.name }; + const { dirPath, filePath } = this.buildLocationPaths(targetLocation); + const previousLocation = input.previousLocation; + await this.vaultAdapter.ensureFolder(dirPath); + const markdown = serializeSlashCommandMarkdown( + { name: input.name, description: input.description }, + input.content + ); + await this.vaultAdapter.write(filePath, markdown); + if (previousLocation && (previousLocation.rootId !== targetRootId || previousLocation.name !== input.name)) { + await this.delete(previousLocation); + } + } + async delete(location) { + const { dirPath, filePath } = this.buildLocationPaths(location); + await this.vaultAdapter.delete(filePath); + await this.vaultAdapter.deleteFolder(dirPath); + } + async load(location) { + const { filePath } = this.buildLocationPaths(location); + try { + const content = await this.vaultAdapter.read(filePath); + const parsed = parseSlashCommandContent(content); + return { + name: location.name, + description: parsed.description, + content: parsed.promptContent, + provenance: "vault", + rootId: location.rootId + }; + } catch (e3) { + return null; + } + } + async scanRoots(adapter, roots, provenance) { + const results = []; + for (const rootId of roots) { + const rootPath = ROOT_PATH_BY_ID[rootId]; + try { + const folders = await adapter.listFolders(rootPath); + for (const folder of folders) { + const skillName = folder.split("/").pop(); + const skillPath = `${rootPath}/${skillName}/SKILL.md`; + try { + const content = await adapter.read(skillPath); + const parsed = parseSlashCommandContent(content); + results.push({ + name: skillName, + description: parsed.description, + content: parsed.promptContent, + provenance, + rootId + }); + } catch (e3) { + } + } + } catch (e3) { + } + } + return results; + } + buildLocationPaths(location) { + const rootPath = ROOT_PATH_BY_ID[location.rootId]; + const dirPath = `${rootPath}/${location.name}`; + return { + dirPath, + filePath: `${dirPath}/SKILL.md` + }; + } +}; + +// src/providers/codex/commands/CodexSkillCatalog.ts +var CODEX_SKILL_ID_PREFIX = "codex-skill-"; +var CODEX_COMPACT_COMMAND = { + id: "codex-builtin-compact", + providerId: "codex", + kind: "command", + name: "compact", + description: "Compact conversation history", + content: "", + scope: "system", + source: "builtin", + isEditable: false, + isDeletable: false, + displayPrefix: "/", + insertPrefix: "/" +}; +function buildSkillId(skill, location) { + if (location) { + return `${CODEX_SKILL_ID_PREFIX}${location.rootId}-${location.name}`; + } + const encodedPath = encodeURIComponent(skill.path); + return `${CODEX_SKILL_ID_PREFIX}${skill.scope}-${encodedPath}`; +} +function listedSkillToProviderEntry(skill, vaultPath) { + const location = vaultPath ? resolveCodexSkillLocationFromPath(skill.path, vaultPath) : null; + const isVault = skill.scope === "repo" && location !== null; + return { + id: buildSkillId(skill, isVault ? location : null), + providerId: "codex", + kind: "skill", + name: skill.name, + description: getCodexSkillDescription(skill), + content: "", + scope: isVault ? "vault" : "user", + source: "user", + isEditable: isVault, + isDeletable: isVault, + displayPrefix: "$", + insertPrefix: "$", + ...isVault ? { + persistenceKey: createCodexSkillPersistenceKey({ + rootId: location.rootId, + currentName: location.name + }) + } : {} + }; +} +var CodexSkillCatalog = class { + constructor(storage, listProvider, vaultPath) { + this.storage = storage; + this.listProvider = listProvider; + this.vaultPath = vaultPath; + } + setRuntimeCommands(_commands) { + } + async listDropdownEntries(context) { + const skills = (await this.listProvider.listSkills()).filter((skill) => skill.enabled).sort(compareCodexSkillPriority); + const entries = skills.map((skill) => listedSkillToProviderEntry(skill, this.vaultPath)); + return context.includeBuiltIns ? [CODEX_COMPACT_COMMAND, ...entries] : entries; + } + async listVaultEntries() { + var _a3; + if (!this.vaultPath) { + return []; + } + const listedSkills = (await this.listProvider.listSkills()).filter((skill) => skill.scope === "repo").sort(compareCodexSkillPriority); + const entries = []; + for (const listedSkill of listedSkills) { + const location = resolveCodexSkillLocationFromPath(listedSkill.path, this.vaultPath); + if (!location) { + continue; + } + const storedSkill = await this.storage.load(location); + if (!storedSkill) { + continue; + } + entries.push({ + id: `${CODEX_SKILL_ID_PREFIX}${location.rootId}-${storedSkill.name}`, + providerId: "codex", + kind: "skill", + name: storedSkill.name, + description: (_a3 = storedSkill.description) != null ? _a3 : getCodexSkillDescription(listedSkill), + content: storedSkill.content, + scope: "vault", + source: "user", + isEditable: true, + isDeletable: true, + displayPrefix: "$", + insertPrefix: "$", + persistenceKey: createCodexSkillPersistenceKey({ + rootId: location.rootId, + currentName: location.name + }) + }); + } + return entries; + } + async saveVaultEntry(entry) { + const persistenceState = parseCodexSkillPersistenceKey(entry.persistenceKey); + await this.storage.save({ + name: entry.name, + description: entry.description, + content: entry.content, + rootId: persistenceState == null ? void 0 : persistenceState.rootId, + previousLocation: (persistenceState == null ? void 0 : persistenceState.currentName) ? { rootId: persistenceState.rootId, name: persistenceState.currentName } : void 0 + }); + this.listProvider.invalidate(); + } + async deleteVaultEntry(entry) { + var _a3, _b2; + const persistenceState = parseCodexSkillPersistenceKey(entry.persistenceKey); + await this.storage.delete({ + name: (_a3 = persistenceState == null ? void 0 : persistenceState.currentName) != null ? _a3 : entry.name, + rootId: (_b2 = persistenceState == null ? void 0 : persistenceState.rootId) != null ? _b2 : "vault-codex" + }); + this.listProvider.invalidate(); + } + getDropdownConfig() { + return { + providerId: "codex", + triggerChars: ["/", "$"], + builtInPrefix: "/", + skillPrefix: "$", + commandPrefix: "/" + }; + } + async refresh() { + this.listProvider.invalidate(); + await this.listProvider.listSkills({ forceReload: true }); + } +}; + +// src/providers/codex/runtime/CodexCliResolver.ts +init_env(); + +// src/providers/codex/runtime/CodexBinaryLocator.ts +var fs12 = __toESM(require("fs")); +var path13 = __toESM(require("path")); +init_env(); +init_path(); +function isExistingFile2(filePath) { + try { + return fs12.statSync(filePath).isFile(); + } catch (e3) { + return false; + } +} +function resolveConfiguredPath2(configuredPath) { + const trimmed = (configuredPath != null ? configuredPath : "").trim(); + if (!trimmed) { + return null; + } + try { + const expandedPath = expandHomePath(trimmed); + return isExistingFile2(expandedPath) ? expandedPath : null; + } catch (e3) { + return null; + } +} +function isWindowsStyleCliReference(value) { + const trimmed = (value != null ? value : "").trim(); + if (!trimmed) { + return false; + } + return /^[A-Za-z]:[\\/]/.test(trimmed) || trimmed.startsWith("\\\\") || /\.(?:exe|cmd|bat|ps1)$/i.test(trimmed); +} +function findCodexBinaryPath(additionalPath, platform = process.platform) { + const binaryNames = platform === "win32" ? ["codex.exe", "codex"] : ["codex"]; + const searchEntries = parsePathEntries(getEnhancedPath(additionalPath)); + for (const dir of searchEntries) { + if (!dir) continue; + for (const binaryName of binaryNames) { + const candidate = path13.join(dir, binaryName); + if (isExistingFile2(candidate)) { + return candidate; + } + } + } + return null; +} +function resolveCodexCliPath(hostnamePath, legacyPath, envText, options = {}) { + var _a3; + const hostPlatform = (_a3 = options.hostPlatform) != null ? _a3 : process.platform; + if (hostPlatform === "win32" && options.installationMethod === "wsl") { + const configuredCommand = [hostnamePath, legacyPath].map((value) => (value != null ? value : "").trim()).find((value) => value.length > 0 && !isWindowsStyleCliReference(value)); + return configuredCommand || "codex"; + } + const configuredHostnamePath = resolveConfiguredPath2(hostnamePath); + if (configuredHostnamePath) { + return configuredHostnamePath; + } + const configuredLegacyPath = resolveConfiguredPath2(legacyPath); + if (configuredLegacyPath) { + return configuredLegacyPath; + } + const customEnv = parseEnvironmentVariables(envText || ""); + return findCodexBinaryPath(customEnv.PATH, hostPlatform); +} + +// src/providers/codex/runtime/CodexCliResolver.ts +var CodexCliResolver = class { + constructor() { + this.resolvedPath = null; + this.lastHostnamePath = ""; + this.lastLegacyPath = ""; + this.lastEnvText = ""; + this.lastInstallationMethod = ""; + this.cachedHostname = getHostnameKey(); + } + resolveFromSettings(settings11) { + var _a3; + const codexSettings = getCodexProviderSettings(settings11); + const hostnamePath = ((_a3 = codexSettings.cliPathsByHost[this.cachedHostname]) != null ? _a3 : "").trim(); + const legacyPath = codexSettings.cliPath.trim(); + const envText = getRuntimeEnvironmentText(settings11, "codex"); + const installationMethod = codexSettings.installationMethod; + if (this.resolvedPath && hostnamePath === this.lastHostnamePath && legacyPath === this.lastLegacyPath && envText === this.lastEnvText && installationMethod === this.lastInstallationMethod) { + return this.resolvedPath; + } + this.lastHostnamePath = hostnamePath; + this.lastLegacyPath = legacyPath; + this.lastEnvText = envText; + this.lastInstallationMethod = installationMethod; + this.resolvedPath = resolveCodexCliPath(hostnamePath, legacyPath, envText, { + installationMethod + }); + return this.resolvedPath; + } + resolve(hostnamePaths, legacyPath, envText, options = {}) { + var _a3; + const hostnamePath = ((_a3 = hostnamePaths == null ? void 0 : hostnamePaths[this.cachedHostname]) != null ? _a3 : "").trim(); + const normalizedLegacyPath = (legacyPath != null ? legacyPath : "").trim(); + return resolveCodexCliPath(hostnamePath, normalizedLegacyPath, envText, options); + } + reset() { + this.resolvedPath = null; + this.lastHostnamePath = ""; + this.lastLegacyPath = ""; + this.lastEnvText = ""; + this.lastInstallationMethod = ""; + } +}; + +// node_modules/smol-toml/dist/error.js +function getLineColFromPtr(string5, ptr) { + let lines = string5.slice(0, ptr).split(/\r\n|\n|\r/g); + return [lines.length, lines.pop().length + 1]; +} +function makeCodeBlock(string5, line, column) { + let lines = string5.split(/\r\n|\n|\r/g); + let codeblock = ""; + let numberLen = (Math.log10(line + 1) | 0) + 1; + for (let i3 = line - 1; i3 <= line + 1; i3++) { + let l3 = lines[i3 - 1]; + if (!l3) + continue; + codeblock += i3.toString().padEnd(numberLen, " "); + codeblock += ": "; + codeblock += l3; + codeblock += "\n"; + if (i3 === line) { + codeblock += " ".repeat(numberLen + column + 2); + codeblock += "^\n"; + } + } + return codeblock; +} +var TomlError = class extends Error { + constructor(message, options) { + const [line, column] = getLineColFromPtr(options.toml, options.ptr); + const codeblock = makeCodeBlock(options.toml, line, column); + super(`Invalid TOML document: ${message} + +${codeblock}`, options); + __publicField(this, "line"); + __publicField(this, "column"); + __publicField(this, "codeblock"); + this.line = line; + this.column = column; + this.codeblock = codeblock; + } +}; + +// node_modules/smol-toml/dist/util.js +function isEscaped(str, ptr) { + let i3 = 0; + while (str[ptr - ++i3] === "\\") + ; + return --i3 && i3 % 2; +} +function indexOfNewline(str, start = 0, end = str.length) { + let idx = str.indexOf("\n", start); + if (str[idx - 1] === "\r") + idx--; + return idx <= end ? idx : -1; +} +function skipComment(str, ptr) { + for (let i3 = ptr; i3 < str.length; i3++) { + let c = str[i3]; + if (c === "\n") + return i3; + if (c === "\r" && str[i3 + 1] === "\n") + return i3 + 1; + if (c < " " && c !== " " || c === "\x7F") { + throw new TomlError("control characters are not allowed in comments", { + toml: str, + ptr + }); + } + } + return str.length; +} +function skipVoid(str, ptr, banNewLines, banComments) { + let c; + while (1) { + while ((c = str[ptr]) === " " || c === " " || !banNewLines && (c === "\n" || c === "\r" && str[ptr + 1] === "\n")) + ptr++; + if (banComments || c !== "#") + break; + ptr = skipComment(str, ptr); + } + return ptr; +} +function skipUntil(str, ptr, sep2, end, banNewLines = false) { + if (!end) { + ptr = indexOfNewline(str, ptr); + return ptr < 0 ? str.length : ptr; + } + for (let i3 = ptr; i3 < str.length; i3++) { + let c = str[i3]; + if (c === "#") { + i3 = indexOfNewline(str, i3); + } else if (c === sep2) { + return i3 + 1; + } else if (c === end || banNewLines && (c === "\n" || c === "\r" && str[i3 + 1] === "\n")) { + return i3; + } + } + throw new TomlError("cannot find end of structure", { + toml: str, + ptr + }); +} +function getStringEnd(str, seek) { + let first = str[seek]; + let target = first === str[seek + 1] && str[seek + 1] === str[seek + 2] ? str.slice(seek, seek + 3) : first; + seek += target.length - 1; + do + seek = str.indexOf(target, ++seek); + while (seek > -1 && first !== "'" && isEscaped(str, seek)); + if (seek > -1) { + seek += target.length; + if (target.length > 1) { + if (str[seek] === first) + seek++; + if (str[seek] === first) + seek++; + } + } + return seek; +} + +// node_modules/smol-toml/dist/date.js +var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[-+]\d{2}:\d{2})?$/i; +var _hasDate, _hasTime, _offset; +var _TomlDate = class _TomlDate extends Date { + constructor(date7) { + let hasDate = true; + let hasTime = true; + let offset = "Z"; + if (typeof date7 === "string") { + let match = date7.match(DATE_TIME_RE); + if (match) { + if (!match[1]) { + hasDate = false; + date7 = `0000-01-01T${date7}`; + } + hasTime = !!match[2]; + hasTime && date7[10] === " " && (date7 = date7.replace(" ", "T")); + if (match[2] && +match[2] > 23) { + date7 = ""; + } else { + offset = match[3] || null; + date7 = date7.toUpperCase(); + if (!offset && hasTime) + date7 += "Z"; + } + } else { + date7 = ""; + } + } + super(date7); + __privateAdd(this, _hasDate, false); + __privateAdd(this, _hasTime, false); + __privateAdd(this, _offset, null); + if (!isNaN(this.getTime())) { + __privateSet(this, _hasDate, hasDate); + __privateSet(this, _hasTime, hasTime); + __privateSet(this, _offset, offset); + } + } + isDateTime() { + return __privateGet(this, _hasDate) && __privateGet(this, _hasTime); + } + isLocal() { + return !__privateGet(this, _hasDate) || !__privateGet(this, _hasTime) || !__privateGet(this, _offset); + } + isDate() { + return __privateGet(this, _hasDate) && !__privateGet(this, _hasTime); + } + isTime() { + return __privateGet(this, _hasTime) && !__privateGet(this, _hasDate); + } + isValid() { + return __privateGet(this, _hasDate) || __privateGet(this, _hasTime); + } + toISOString() { + let iso = super.toISOString(); + if (this.isDate()) + return iso.slice(0, 10); + if (this.isTime()) + return iso.slice(11, 23); + if (__privateGet(this, _offset) === null) + return iso.slice(0, -1); + if (__privateGet(this, _offset) === "Z") + return iso; + let offset = +__privateGet(this, _offset).slice(1, 3) * 60 + +__privateGet(this, _offset).slice(4, 6); + offset = __privateGet(this, _offset)[0] === "-" ? offset : -offset; + let offsetDate = new Date(this.getTime() - offset * 6e4); + return offsetDate.toISOString().slice(0, -1) + __privateGet(this, _offset); + } + static wrapAsOffsetDateTime(jsDate, offset = "Z") { + let date7 = new _TomlDate(jsDate); + __privateSet(date7, _offset, offset); + return date7; + } + static wrapAsLocalDateTime(jsDate) { + let date7 = new _TomlDate(jsDate); + __privateSet(date7, _offset, null); + return date7; + } + static wrapAsLocalDate(jsDate) { + let date7 = new _TomlDate(jsDate); + __privateSet(date7, _hasTime, false); + __privateSet(date7, _offset, null); + return date7; + } + static wrapAsLocalTime(jsDate) { + let date7 = new _TomlDate(jsDate); + __privateSet(date7, _hasDate, false); + __privateSet(date7, _offset, null); + return date7; + } +}; +_hasDate = new WeakMap(); +_hasTime = new WeakMap(); +_offset = new WeakMap(); +var TomlDate = _TomlDate; + +// node_modules/smol-toml/dist/primitive.js +var INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/; +var FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/; +var LEADING_ZERO = /^[+-]?0[0-9_]/; +var ESCAPE_REGEX = /^[0-9a-f]{2,8}$/i; +var ESC_MAP = { + b: "\b", + t: " ", + n: "\n", + f: "\f", + r: "\r", + e: "\x1B", + '"': '"', + "\\": "\\" +}; +function parseString(str, ptr = 0, endPtr = str.length) { + let isLiteral = str[ptr] === "'"; + let isMultiline = str[ptr++] === str[ptr] && str[ptr] === str[ptr + 1]; + if (isMultiline) { + endPtr -= 2; + if (str[ptr += 2] === "\r") + ptr++; + if (str[ptr] === "\n") + ptr++; + } + let tmp = 0; + let isEscape; + let parsed = ""; + let sliceStart = ptr; + while (ptr < endPtr - 1) { + let c = str[ptr++]; + if (c === "\n" || c === "\r" && str[ptr] === "\n") { + if (!isMultiline) { + throw new TomlError("newlines are not allowed in strings", { + toml: str, + ptr: ptr - 1 + }); + } + } else if (c < " " && c !== " " || c === "\x7F") { + throw new TomlError("control characters are not allowed in strings", { + toml: str, + ptr: ptr - 1 + }); + } + if (isEscape) { + isEscape = false; + if (c === "x" || c === "u" || c === "U") { + let code = str.slice(ptr, ptr += c === "x" ? 2 : c === "u" ? 4 : 8); + if (!ESCAPE_REGEX.test(code)) { + throw new TomlError("invalid unicode escape", { + toml: str, + ptr: tmp + }); + } + try { + parsed += String.fromCodePoint(parseInt(code, 16)); + } catch (e3) { + throw new TomlError("invalid unicode escape", { + toml: str, + ptr: tmp + }); + } + } else if (isMultiline && (c === "\n" || c === " " || c === " " || c === "\r")) { + ptr = skipVoid(str, ptr - 1, true); + if (str[ptr] !== "\n" && str[ptr] !== "\r") { + throw new TomlError("invalid escape: only line-ending whitespace may be escaped", { + toml: str, + ptr: tmp + }); + } + ptr = skipVoid(str, ptr); + } else if (c in ESC_MAP) { + parsed += ESC_MAP[c]; + } else { + throw new TomlError("unrecognized escape sequence", { + toml: str, + ptr: tmp + }); + } + sliceStart = ptr; + } else if (!isLiteral && c === "\\") { + tmp = ptr - 1; + isEscape = true; + parsed += str.slice(sliceStart, tmp); + } + } + return parsed + str.slice(sliceStart, endPtr - 1); +} +function parseValue(value, toml, ptr, integersAsBigInt) { + if (value === "true") + return true; + if (value === "false") + return false; + if (value === "-inf") + return -Infinity; + if (value === "inf" || value === "+inf") + return Infinity; + if (value === "nan" || value === "+nan" || value === "-nan") + return NaN; + if (value === "-0") + return integersAsBigInt ? /* @__PURE__ */ BigInt("0") : 0; + let isInt = INT_REGEX.test(value); + if (isInt || FLOAT_REGEX.test(value)) { + if (LEADING_ZERO.test(value)) { + throw new TomlError("leading zeroes are not allowed", { + toml, + ptr + }); + } + value = value.replace(/_/g, ""); + let numeric = +value; + if (isNaN(numeric)) { + throw new TomlError("invalid number", { + toml, + ptr + }); + } + if (isInt) { + if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) { + throw new TomlError("integer value cannot be represented losslessly", { + toml, + ptr + }); + } + if (isInt || integersAsBigInt === true) + numeric = BigInt(value); + } + return numeric; + } + const date7 = new TomlDate(value); + if (!date7.isValid()) { + throw new TomlError("invalid value", { + toml, + ptr + }); + } + return date7; +} + +// node_modules/smol-toml/dist/extract.js +function sliceAndTrimEndOf(str, startPtr, endPtr) { + let value = str.slice(startPtr, endPtr); + let commentIdx = value.indexOf("#"); + if (commentIdx > -1) { + skipComment(str, commentIdx); + value = value.slice(0, commentIdx); + } + return [value.trimEnd(), commentIdx]; +} +function extractValue(str, ptr, end, depth, integersAsBigInt) { + if (depth === 0) { + throw new TomlError("document contains excessively nested structures. aborting.", { + toml: str, + ptr + }); + } + let c = str[ptr]; + if (c === "[" || c === "{") { + let [value, endPtr2] = c === "[" ? parseArray(str, ptr, depth, integersAsBigInt) : parseInlineTable(str, ptr, depth, integersAsBigInt); + if (end) { + endPtr2 = skipVoid(str, endPtr2); + if (str[endPtr2] === ",") + endPtr2++; + else if (str[endPtr2] !== end) { + throw new TomlError("expected comma or end of structure", { + toml: str, + ptr: endPtr2 + }); + } + } + return [value, endPtr2]; + } + let endPtr; + if (c === '"' || c === "'") { + endPtr = getStringEnd(str, ptr); + let parsed = parseString(str, ptr, endPtr); + if (end) { + endPtr = skipVoid(str, endPtr); + if (str[endPtr] && str[endPtr] !== "," && str[endPtr] !== end && str[endPtr] !== "\n" && str[endPtr] !== "\r") { + throw new TomlError("unexpected character encountered", { + toml: str, + ptr: endPtr + }); + } + endPtr += +(str[endPtr] === ","); + } + return [parsed, endPtr]; + } + endPtr = skipUntil(str, ptr, ",", end); + let slice = sliceAndTrimEndOf(str, ptr, endPtr - +(str[endPtr - 1] === ",")); + if (!slice[0]) { + throw new TomlError("incomplete key-value declaration: no value specified", { + toml: str, + ptr + }); + } + if (end && slice[1] > -1) { + endPtr = skipVoid(str, ptr + slice[1]); + endPtr += +(str[endPtr] === ","); + } + return [ + parseValue(slice[0], str, ptr, integersAsBigInt), + endPtr + ]; +} + +// node_modules/smol-toml/dist/struct.js +var KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/; +function parseKey(str, ptr, end = "=") { + let dot = ptr - 1; + let parsed = []; + let endPtr = str.indexOf(end, ptr); + if (endPtr < 0) { + throw new TomlError("incomplete key-value: cannot find end of key", { + toml: str, + ptr + }); + } + do { + let c = str[ptr = ++dot]; + if (c !== " " && c !== " ") { + if (c === '"' || c === "'") { + if (c === str[ptr + 1] && c === str[ptr + 2]) { + throw new TomlError("multiline strings are not allowed in keys", { + toml: str, + ptr + }); + } + let eos = getStringEnd(str, ptr); + if (eos < 0) { + throw new TomlError("unfinished string encountered", { + toml: str, + ptr + }); + } + dot = str.indexOf(".", eos); + let strEnd = str.slice(eos, dot < 0 || dot > endPtr ? endPtr : dot); + let newLine = indexOfNewline(strEnd); + if (newLine > -1) { + throw new TomlError("newlines are not allowed in keys", { + toml: str, + ptr: ptr + dot + newLine + }); + } + if (strEnd.trimStart()) { + throw new TomlError("found extra tokens after the string part", { + toml: str, + ptr: eos + }); + } + if (endPtr < eos) { + endPtr = str.indexOf(end, eos); + if (endPtr < 0) { + throw new TomlError("incomplete key-value: cannot find end of key", { + toml: str, + ptr + }); + } + } + parsed.push(parseString(str, ptr, eos)); + } else { + dot = str.indexOf(".", ptr); + let part = str.slice(ptr, dot < 0 || dot > endPtr ? endPtr : dot); + if (!KEY_PART_RE.test(part)) { + throw new TomlError("only letter, numbers, dashes and underscores are allowed in keys", { + toml: str, + ptr + }); + } + parsed.push(part.trimEnd()); + } + } + } while (dot + 1 && dot < endPtr); + return [parsed, skipVoid(str, endPtr + 1, true, true)]; +} +function parseInlineTable(str, ptr, depth, integersAsBigInt) { + let res = {}; + let seen = /* @__PURE__ */ new Set(); + let c; + ptr++; + while ((c = str[ptr++]) !== "}" && c) { + if (c === ",") { + throw new TomlError("expected value, found comma", { + toml: str, + ptr: ptr - 1 + }); + } else if (c === "#") + ptr = skipComment(str, ptr); + else if (c !== " " && c !== " " && c !== "\n" && c !== "\r") { + let k3; + let t3 = res; + let hasOwn = false; + let [key, keyEndPtr] = parseKey(str, ptr - 1); + for (let i3 = 0; i3 < key.length; i3++) { + if (i3) + t3 = hasOwn ? t3[k3] : t3[k3] = {}; + k3 = key[i3]; + if ((hasOwn = Object.hasOwn(t3, k3)) && (typeof t3[k3] !== "object" || seen.has(t3[k3]))) { + throw new TomlError("trying to redefine an already defined value", { + toml: str, + ptr + }); + } + if (!hasOwn && k3 === "__proto__") { + Object.defineProperty(t3, k3, { enumerable: true, configurable: true, writable: true }); + } + } + if (hasOwn) { + throw new TomlError("trying to redefine an already defined value", { + toml: str, + ptr + }); + } + let [value, valueEndPtr] = extractValue(str, keyEndPtr, "}", depth - 1, integersAsBigInt); + seen.add(value); + t3[k3] = value; + ptr = valueEndPtr; + } + } + if (!c) { + throw new TomlError("unfinished table encountered", { + toml: str, + ptr + }); + } + return [res, ptr]; +} +function parseArray(str, ptr, depth, integersAsBigInt) { + let res = []; + let c; + ptr++; + while ((c = str[ptr++]) !== "]" && c) { + if (c === ",") { + throw new TomlError("expected value, found comma", { + toml: str, + ptr: ptr - 1 + }); + } else if (c === "#") + ptr = skipComment(str, ptr); + else if (c !== " " && c !== " " && c !== "\n" && c !== "\r") { + let e3 = extractValue(str, ptr - 1, "]", depth - 1, integersAsBigInt); + res.push(e3[0]); + ptr = e3[1]; + } + } + if (!c) { + throw new TomlError("unfinished array encountered", { + toml: str, + ptr + }); + } + return [res, ptr]; +} + +// node_modules/smol-toml/dist/parse.js +function peekTable(key, table, meta3, type) { + var _a3, _b2; + let t3 = table; + let m3 = meta3; + let k3; + let hasOwn = false; + let state; + for (let i3 = 0; i3 < key.length; i3++) { + if (i3) { + t3 = hasOwn ? t3[k3] : t3[k3] = {}; + m3 = (state = m3[k3]).c; + if (type === 0 && (state.t === 1 || state.t === 2)) { + return null; + } + if (state.t === 2) { + let l3 = t3.length - 1; + t3 = t3[l3]; + m3 = m3[l3].c; + } + } + k3 = key[i3]; + if ((hasOwn = Object.hasOwn(t3, k3)) && ((_a3 = m3[k3]) == null ? void 0 : _a3.t) === 0 && ((_b2 = m3[k3]) == null ? void 0 : _b2.d)) { + return null; + } + if (!hasOwn) { + if (k3 === "__proto__") { + Object.defineProperty(t3, k3, { enumerable: true, configurable: true, writable: true }); + Object.defineProperty(m3, k3, { enumerable: true, configurable: true, writable: true }); + } + m3[k3] = { + t: i3 < key.length - 1 && type === 2 ? 3 : type, + d: false, + i: 0, + c: {} + }; + } + } + state = m3[k3]; + if (state.t !== type && !(type === 1 && state.t === 3)) { + return null; + } + if (type === 2) { + if (!state.d) { + state.d = true; + t3[k3] = []; + } + t3[k3].push(t3 = {}); + state.c[state.i++] = state = { t: 1, d: false, i: 0, c: {} }; + } + if (state.d) { + return null; + } + state.d = true; + if (type === 1) { + t3 = hasOwn ? t3[k3] : t3[k3] = {}; + } else if (type === 0 && hasOwn) { + return null; + } + return [k3, t3, state.c]; +} +function parse3(toml, { maxDepth = 1e3, integersAsBigInt } = {}) { + let res = {}; + let meta3 = {}; + let tbl = res; + let m3 = meta3; + for (let ptr = skipVoid(toml, 0); ptr < toml.length; ) { + if (toml[ptr] === "[") { + let isTableArray = toml[++ptr] === "["; + let k3 = parseKey(toml, ptr += +isTableArray, "]"); + if (isTableArray) { + if (toml[k3[1] - 1] !== "]") { + throw new TomlError("expected end of table declaration", { + toml, + ptr: k3[1] - 1 + }); + } + k3[1]++; + } + let p = peekTable( + k3[0], + res, + meta3, + isTableArray ? 2 : 1 + /* Type.EXPLICIT */ + ); + if (!p) { + throw new TomlError("trying to redefine an already defined table or value", { + toml, + ptr + }); + } + m3 = p[2]; + tbl = p[1]; + ptr = k3[1]; + } else { + let k3 = parseKey(toml, ptr); + let p = peekTable( + k3[0], + tbl, + m3, + 0 + /* Type.DOTTED */ + ); + if (!p) { + throw new TomlError("trying to redefine an already defined table or value", { + toml, + ptr + }); + } + let v2 = extractValue(toml, k3[1], void 0, maxDepth, integersAsBigInt); + p[1][p[0]] = v2[0]; + ptr = v2[1]; + } + ptr = skipVoid(toml, ptr, true); + if (toml[ptr] && toml[ptr] !== "\n" && toml[ptr] !== "\r") { + throw new TomlError("each key-value declaration must be followed by an end-of-line", { + toml, + ptr + }); + } + ptr = skipVoid(toml, ptr); + } + return res; +} + +// node_modules/smol-toml/dist/stringify.js +var BARE_KEY = /^[a-z0-9-_]+$/i; +function extendedTypeOf(obj) { + let type = typeof obj; + if (type === "object") { + if (Array.isArray(obj)) + return "array"; + if (obj instanceof Date) + return "date"; + } + return type; +} +function isArrayOfTables(obj) { + for (let i3 = 0; i3 < obj.length; i3++) { + if (extendedTypeOf(obj[i3]) !== "object") + return false; + } + return obj.length != 0; +} +function formatString(s3) { + return JSON.stringify(s3).replace(/\x7f/g, "\\u007f"); +} +function stringifyValue(val, type, depth, numberAsFloat) { + if (depth === 0) { + throw new Error("Could not stringify the object: maximum object depth exceeded"); + } + if (type === "number") { + if (isNaN(val)) + return "nan"; + if (val === Infinity) + return "inf"; + if (val === -Infinity) + return "-inf"; + if (numberAsFloat && Number.isInteger(val)) + return val.toFixed(1); + return val.toString(); + } + if (type === "bigint" || type === "boolean") { + return val.toString(); + } + if (type === "string") { + return formatString(val); + } + if (type === "date") { + if (isNaN(val.getTime())) { + throw new TypeError("cannot serialize invalid date"); + } + return val.toISOString(); + } + if (type === "object") { + return stringifyInlineTable(val, depth, numberAsFloat); + } + if (type === "array") { + return stringifyArray(val, depth, numberAsFloat); + } +} +function stringifyInlineTable(obj, depth, numberAsFloat) { + let keys = Object.keys(obj); + if (keys.length === 0) + return "{}"; + let res = "{ "; + for (let i3 = 0; i3 < keys.length; i3++) { + let k3 = keys[i3]; + if (i3) + res += ", "; + res += BARE_KEY.test(k3) ? k3 : formatString(k3); + res += " = "; + res += stringifyValue(obj[k3], extendedTypeOf(obj[k3]), depth - 1, numberAsFloat); + } + return res + " }"; +} +function stringifyArray(array2, depth, numberAsFloat) { + if (array2.length === 0) + return "[]"; + let res = "[ "; + for (let i3 = 0; i3 < array2.length; i3++) { + if (i3) + res += ", "; + if (array2[i3] === null || array2[i3] === void 0) { + throw new TypeError("arrays cannot contain null or undefined values"); + } + res += stringifyValue(array2[i3], extendedTypeOf(array2[i3]), depth - 1, numberAsFloat); + } + return res + " ]"; +} +function stringifyArrayTable(array2, key, depth, numberAsFloat) { + if (depth === 0) { + throw new Error("Could not stringify the object: maximum object depth exceeded"); + } + let res = ""; + for (let i3 = 0; i3 < array2.length; i3++) { + res += `${res && "\n"}[[${key}]] +`; + res += stringifyTable(0, array2[i3], key, depth, numberAsFloat); + } + return res; +} +function stringifyTable(tableKey, obj, prefix, depth, numberAsFloat) { + if (depth === 0) { + throw new Error("Could not stringify the object: maximum object depth exceeded"); + } + let preamble = ""; + let tables = ""; + let keys = Object.keys(obj); + for (let i3 = 0; i3 < keys.length; i3++) { + let k3 = keys[i3]; + if (obj[k3] !== null && obj[k3] !== void 0) { + let type = extendedTypeOf(obj[k3]); + if (type === "symbol" || type === "function") { + throw new TypeError(`cannot serialize values of type '${type}'`); + } + let key = BARE_KEY.test(k3) ? k3 : formatString(k3); + if (type === "array" && isArrayOfTables(obj[k3])) { + tables += (tables && "\n") + stringifyArrayTable(obj[k3], prefix ? `${prefix}.${key}` : key, depth - 1, numberAsFloat); + } else if (type === "object") { + let tblKey = prefix ? `${prefix}.${key}` : key; + tables += (tables && "\n") + stringifyTable(tblKey, obj[k3], tblKey, depth - 1, numberAsFloat); + } else { + preamble += key; + preamble += " = "; + preamble += stringifyValue(obj[k3], type, depth, numberAsFloat); + preamble += "\n"; + } + } + } + if (tableKey && (preamble || !tables)) + preamble = preamble ? `[${tableKey}] +${preamble}` : `[${tableKey}]`; + return preamble && tables ? `${preamble} +${tables}` : preamble || tables; +} +function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) { + if (extendedTypeOf(obj) !== "object") { + throw new TypeError("stringify can only be called with an object"); + } + let str = stringifyTable(0, obj, "", maxDepth, numbersAsFloat); + if (str[str.length - 1] !== "\n") + return str + "\n"; + return str; +} + +// src/providers/codex/types/subagent.ts +var CODEX_SUBAGENT_KNOWN_KEYS = /* @__PURE__ */ new Set([ + "name", + "description", + "developer_instructions", + "nickname_candidates", + "model", + "model_reasoning_effort", + "sandbox_mode" +]); + +// src/providers/codex/storage/CodexSubagentStorage.ts +var CODEX_AGENTS_PATH = ".codex/agents"; +var SUBAGENT_PERSISTENCE_PREFIX = "codex-subagent"; +function createCodexSubagentPersistenceKey(location) { + return `${SUBAGENT_PERSISTENCE_PREFIX}:${encodeURIComponent(location.fileName)}`; +} +function parseCodexSubagentPersistenceKey(persistenceKey) { + if (!persistenceKey) { + return null; + } + if (persistenceKey.startsWith(`${CODEX_AGENTS_PATH}/`) && persistenceKey.endsWith(".toml")) { + return { fileName: persistenceKey.slice(CODEX_AGENTS_PATH.length + 1) }; + } + const [prefix, encodedFileName] = persistenceKey.split(":"); + if (prefix !== SUBAGENT_PERSISTENCE_PREFIX || !encodedFileName) { + return null; + } + const fileName = decodeURIComponent(encodedFileName); + return fileName.endsWith(".toml") ? { fileName } : null; +} +var CodexSubagentStorage = class { + constructor(vaultAdapter) { + this.vaultAdapter = vaultAdapter; + } + async loadAll() { + return this.scanAdapter(this.vaultAdapter); + } + async load(agent) { + const filePath = this.resolveCurrentPath(agent); + try { + if (!await this.vaultAdapter.exists(filePath)) return null; + const content = await this.vaultAdapter.read(filePath); + return parseSubagentToml(content, filePath); + } catch (e3) { + return null; + } + } + async save(agent, previous) { + const filePath = this.resolveTargetPath(agent, previous); + const previousPath = previous ? this.resolveCurrentPath(previous) : null; + await this.vaultAdapter.ensureFolder(CODEX_AGENTS_PATH); + const content = serializeSubagentToml(agent); + await this.vaultAdapter.write(filePath, content); + if (previousPath && previousPath !== filePath) { + await this.vaultAdapter.delete(previousPath); + } + } + async delete(agent) { + const filePath = this.resolveCurrentPath(agent); + await this.vaultAdapter.delete(filePath); + } + resolveCurrentPath(agent) { + const persistedLocation = parseCodexSubagentPersistenceKey(agent.persistenceKey); + if (persistedLocation) { + return `${CODEX_AGENTS_PATH}/${persistedLocation.fileName}`; + } + return `${CODEX_AGENTS_PATH}/${agent.name}.toml`; + } + resolveTargetPath(agent, previous) { + if (previous && previous.name === agent.name) { + return this.resolveCurrentPath(previous); + } + return `${CODEX_AGENTS_PATH}/${agent.name}.toml`; + } + async scanAdapter(adapter) { + const results = []; + try { + const files = await adapter.listFiles(CODEX_AGENTS_PATH); + for (const filePath of files) { + if (!filePath.endsWith(".toml")) continue; + try { + const content = await adapter.read(filePath); + const agent = parseSubagentToml(content, filePath); + if (agent) results.push(agent); + } catch (e3) { + } + } + } catch (e3) { + } + return results; + } +}; +function parseSubagentToml(content, filePath) { + var _a3; + let parsed; + try { + parsed = parse3(content); + } catch (e3) { + return null; + } + const name = typeof parsed.name === "string" ? parsed.name : void 0; + const description = typeof parsed.description === "string" ? parsed.description : void 0; + const developerInstructions = typeof parsed.developer_instructions === "string" ? parsed.developer_instructions : void 0; + if (!name || !description || !developerInstructions) return null; + const result = { + name, + description, + developerInstructions, + persistenceKey: createCodexSubagentPersistenceKey({ + fileName: filePath.startsWith(`${CODEX_AGENTS_PATH}/`) ? filePath.slice(CODEX_AGENTS_PATH.length + 1) : (_a3 = filePath.split("/").pop()) != null ? _a3 : filePath + }) + }; + if (typeof parsed.model === "string") { + result.model = parsed.model; + } + if (typeof parsed.model_reasoning_effort === "string") { + result.modelReasoningEffort = parsed.model_reasoning_effort; + } + if (typeof parsed.sandbox_mode === "string") { + result.sandboxMode = parsed.sandbox_mode; + } + if (Array.isArray(parsed.nickname_candidates)) { + const candidates = parsed.nickname_candidates.filter( + (v2) => typeof v2 === "string" + ); + if (candidates.length > 0) result.nicknameCandidates = candidates; + } + const extraFields = {}; + for (const [key, value] of Object.entries(parsed)) { + if (!CODEX_SUBAGENT_KNOWN_KEYS.has(key)) { + extraFields[key] = value; + } + } + if (Object.keys(extraFields).length > 0) { + result.extraFields = extraFields; + } + return result; +} +function serializeSubagentToml(agent) { + const doc = { + name: agent.name, + description: agent.description, + developer_instructions: agent.developerInstructions + }; + if (agent.nicknameCandidates && agent.nicknameCandidates.length > 0) { + doc.nickname_candidates = agent.nicknameCandidates; + } + if (agent.model) { + doc.model = agent.model; + } + if (agent.modelReasoningEffort) { + doc.model_reasoning_effort = agent.modelReasoningEffort; + } + if (agent.sandboxMode) { + doc.sandbox_mode = agent.sandboxMode; + } + if (agent.extraFields) { + for (const [key, value] of Object.entries(agent.extraFields)) { + doc[key] = value; + } + } + return stringify(doc); +} + +// src/providers/codex/ui/CodexSettingsTab.ts +var fs13 = __toESM(require("fs")); +var import_obsidian17 = require("obsidian"); +init_env(); +init_path(); + +// src/providers/codex/ui/CodexSkillSettings.ts +var import_obsidian15 = require("obsidian"); +var CodexSkillModal = class extends import_obsidian15.Modal { + constructor(app, existing, onSave) { + var _a3, _b2; + super(app); + this.existing = existing; + this.onSave = onSave; + this._selectedRootId = (_b2 = (_a3 = parseCodexSkillPersistenceKey(existing == null ? void 0 : existing.persistenceKey)) == null ? void 0 : _a3.rootId) != null ? _b2 : "vault-codex"; + } + /** Exposed for unit tests only. */ + getTestInputs() { + return { + nameInput: this._nameInput, + descInput: this._descInput, + contentArea: this._contentArea, + setDirectory: (rootId) => { + this._selectedRootId = rootId; + }, + triggerSave: this._triggerSave + }; + } + onOpen() { + var _a3; + this.setTitle(this.existing ? "Edit Codex Skill" : "Add Codex Skill"); + this.modalEl.addClass("claudian-sp-modal"); + const { contentEl } = this; + new import_obsidian15.Setting(contentEl).setName("Directory").setDesc("Where to store the skill").addDropdown((dropdown) => { + for (const opt of CODEX_SKILL_ROOT_OPTIONS) { + dropdown.addOption(opt.id, opt.label); + } + dropdown.setValue(this._selectedRootId); + dropdown.onChange((value) => { + this._selectedRootId = value; + }); + }); + new import_obsidian15.Setting(contentEl).setName("Skill name").setDesc('The name used after $ (e.g., "analyze" for $analyze)').addText((text) => { + var _a4; + this._nameInput = text.inputEl; + text.setValue(((_a4 = this.existing) == null ? void 0 : _a4.name) || "").setPlaceholder("analyze-code"); + }); + new import_obsidian15.Setting(contentEl).setName("Description").setDesc("Optional description shown in dropdown").addText((text) => { + var _a4; + this._descInput = text.inputEl; + text.setValue(((_a4 = this.existing) == null ? void 0 : _a4.description) || ""); + }); + new import_obsidian15.Setting(contentEl).setName("Instructions").setDesc("The skill instructions (SKILL.md content)"); + const contentArea = contentEl.createEl("textarea", { + cls: "claudian-sp-content-area", + attr: { rows: "10", placeholder: "Analyze the code for..." } + }); + contentArea.value = ((_a3 = this.existing) == null ? void 0 : _a3.content) || ""; + this._contentArea = contentArea; + const doSave = async () => { + var _a4, _b2; + const name = this._nameInput.value.trim(); + const nameError = validateCommandName(name); + if (nameError) { + new import_obsidian15.Notice(nameError); + return; + } + const content = this._contentArea.value; + if (!content.trim()) { + new import_obsidian15.Notice("Instructions are required"); + return; + } + const entry = { + id: ((_a4 = this.existing) == null ? void 0 : _a4.id) || `codex-skill-${name}`, + providerId: "codex", + kind: "skill", + name, + description: this._descInput.value.trim() || void 0, + content, + scope: "vault", + source: "user", + isEditable: true, + isDeletable: true, + displayPrefix: "$", + insertPrefix: "$", + persistenceKey: createCodexSkillPersistenceKey({ + rootId: this._selectedRootId, + ...((_b2 = this.existing) == null ? void 0 : _b2.name) ? { currentName: this.existing.name } : {} + }) + }; + try { + await this.onSave(entry); + } catch (e3) { + new import_obsidian15.Notice("Failed to save Codex skill"); + return; + } + this.close(); + }; + this._triggerSave = doSave; + const buttonContainer = contentEl.createDiv({ cls: "claudian-sp-modal-buttons" }); + const cancelBtn = buttonContainer.createEl("button", { + text: "Cancel", + cls: "claudian-cancel-btn" + }); + cancelBtn.addEventListener("click", () => this.close()); + const saveBtn = buttonContainer.createEl("button", { + text: "Save", + cls: "claudian-save-btn" + }); + saveBtn.addEventListener("click", doSave); + } + onClose() { + this.contentEl.empty(); + } +}; +var CodexSkillSettings = class { + constructor(containerEl, catalog, app) { + this.entries = []; + this.containerEl = containerEl; + this.catalog = catalog; + this.app = app; + this.render(); + } + async deleteEntry(entry) { + await this.catalog.deleteVaultEntry(entry); + await this.render(); + } + async refresh() { + await this.catalog.refresh(); + await this.render(); + } + async render() { + this.containerEl.empty(); + try { + this.entries = await this.catalog.listVaultEntries(); + } catch (e3) { + this.entries = []; + } + const headerEl = this.containerEl.createDiv({ cls: "claudian-sp-header" }); + headerEl.createSpan({ text: "Codex Skills", cls: "claudian-sp-label" }); + const actionsEl = headerEl.createDiv({ cls: "claudian-sp-header-actions" }); + const refreshBtn = actionsEl.createEl("button", { + cls: "claudian-settings-action-btn", + attr: { "aria-label": "Refresh" } + }); + (0, import_obsidian15.setIcon)(refreshBtn, "refresh-cw"); + refreshBtn.addEventListener("click", () => { + void this.refresh(); + }); + const addBtn = actionsEl.createEl("button", { + cls: "claudian-settings-action-btn", + attr: { "aria-label": "Add" } + }); + (0, import_obsidian15.setIcon)(addBtn, "plus"); + addBtn.addEventListener("click", () => this.openModal(null)); + if (this.entries.length === 0) { + const emptyEl = this.containerEl.createDiv({ cls: "claudian-sp-empty-state" }); + emptyEl.setText("No Codex skills in vault. Click + to create one."); + return; + } + const listEl = this.containerEl.createDiv({ cls: "claudian-sp-list" }); + for (const entry of this.entries) { + this.renderItem(listEl, entry); + } + } + renderItem(listEl, entry) { + const itemEl = listEl.createDiv({ cls: "claudian-sp-item" }); + const infoEl = itemEl.createDiv({ cls: "claudian-sp-info" }); + const headerRow = infoEl.createDiv({ cls: "claudian-sp-item-header" }); + const nameEl = headerRow.createSpan({ cls: "claudian-sp-item-name" }); + nameEl.setText(`$${entry.name}`); + headerRow.createSpan({ text: "skill", cls: "claudian-slash-item-badge" }); + if (entry.description) { + const descEl = infoEl.createDiv({ cls: "claudian-sp-item-desc" }); + descEl.setText(entry.description); + } + const actionsEl = itemEl.createDiv({ cls: "claudian-sp-item-actions" }); + if (entry.isEditable) { + const editBtn = actionsEl.createEl("button", { + cls: "claudian-settings-action-btn", + attr: { "aria-label": "Edit" } + }); + (0, import_obsidian15.setIcon)(editBtn, "pencil"); + editBtn.addEventListener("click", () => this.openModal(entry)); + } + if (entry.isDeletable) { + const deleteBtn = actionsEl.createEl("button", { + cls: "claudian-settings-action-btn claudian-settings-delete-btn", + attr: { "aria-label": "Delete" } + }); + (0, import_obsidian15.setIcon)(deleteBtn, "trash-2"); + deleteBtn.addEventListener("click", async () => { + try { + await this.deleteEntry(entry); + new import_obsidian15.Notice(`Codex skill "$${entry.name}" deleted`); + } catch (e3) { + new import_obsidian15.Notice("Failed to delete Codex skill"); + } + }); + } + } + openModal(existing) { + if (!this.app) return; + const modal = new CodexSkillModal( + this.app, + existing, + async (entry) => { + await this.catalog.saveVaultEntry(entry); + await this.render(); + new import_obsidian15.Notice(`Codex skill "$${entry.name}" ${existing ? "updated" : "created"}`); + } + ); + modal.open(); + } +}; + +// src/providers/codex/ui/CodexSubagentSettings.ts +var import_obsidian16 = require("obsidian"); +var REASONING_EFFORT_OPTIONS = [ + { value: "", label: "Inherit" }, + { value: "low", label: "Low" }, + { value: "medium", label: "Medium" }, + { value: "high", label: "High" }, + { value: "xhigh", label: "Extra High" } +]; +var SANDBOX_MODE_OPTIONS = [ + { value: "", label: "Inherit" }, + { value: "read-only", label: "Read-only" }, + { value: "danger-full-access", label: "Danger full access" }, + { value: "workspace-write", label: "Workspace write" } +]; +var MAX_NAME_LENGTH = 64; +var CODEX_AGENT_NAME_PATTERN = /^[a-z0-9_-]+$/; +var CODEX_NICKNAME_PATTERN = /^[A-Za-z0-9 _-]+$/; +function validateCodexSubagentName(name) { + if (!name) return "Subagent name is required"; + if (name.length > MAX_NAME_LENGTH) return `Subagent name must be ${MAX_NAME_LENGTH} characters or fewer`; + if (!CODEX_AGENT_NAME_PATTERN.test(name)) return "Subagent name can only contain lowercase letters, numbers, hyphens, and underscores"; + return null; +} +function validateCodexNicknameCandidates(candidates) { + const normalized = candidates.map((candidate) => candidate.trim()).filter(Boolean); + if (normalized.length === 0) return null; + const seen = /* @__PURE__ */ new Set(); + for (const candidate of normalized) { + if (!CODEX_NICKNAME_PATTERN.test(candidate)) { + return "Nickname candidates can only contain ASCII letters, numbers, spaces, hyphens, and underscores"; + } + const dedupeKey = candidate.toLowerCase(); + if (seen.has(dedupeKey)) { + return "Nickname candidates must be unique"; + } + seen.add(dedupeKey); + } + return null; +} +var CodexSubagentModal = class extends import_obsidian16.Modal { + constructor(app, existing, allAgents, onSave) { + var _a3, _b2; + super(app); + this._reasoningEffort = ""; + this._sandboxMode = ""; + this.existing = existing; + this.allAgents = allAgents; + this.onSave = onSave; + this._reasoningEffort = (_a3 = existing == null ? void 0 : existing.modelReasoningEffort) != null ? _a3 : ""; + this._sandboxMode = (_b2 = existing == null ? void 0 : existing.sandboxMode) != null ? _b2 : ""; + } + getTestInputs() { + return { + nameInput: this._nameInput, + descInput: this._descInput, + instructionsArea: this._instructionsArea, + nicknamesInput: this._nicknamesInput, + modelInput: this._modelInput, + setReasoningEffort: (v2) => { + this._reasoningEffort = v2; + }, + setSandboxMode: (v2) => { + this._sandboxMode = v2; + }, + triggerSave: this._triggerSave + }; + } + onOpen() { + var _a3, _b2, _c, _d, _e, _f, _g; + this.setTitle(this.existing ? "Edit Codex Subagent" : "Add Codex Subagent"); + this.modalEl.addClass("claudian-sp-modal"); + const { contentEl } = this; + new import_obsidian16.Setting(contentEl).setName("Name").setDesc("Agent name Codex uses when spawning (lowercase, hyphens, underscores)").addText((text) => { + var _a4, _b3; + this._nameInput = text.inputEl; + text.setValue((_b3 = (_a4 = this.existing) == null ? void 0 : _a4.name) != null ? _b3 : "").setPlaceholder("code_reviewer"); + }); + new import_obsidian16.Setting(contentEl).setName("Description").setDesc("When Codex should use this agent").addText((text) => { + var _a4, _b3; + this._descInput = text.inputEl; + text.setValue((_b3 = (_a4 = this.existing) == null ? void 0 : _a4.description) != null ? _b3 : "").setPlaceholder("Reviews code for correctness and security"); + }); + const details = contentEl.createEl("details", { cls: "claudian-sp-advanced-section" }); + details.createEl("summary", { + text: "Advanced options", + cls: "claudian-sp-advanced-summary" + }); + if (((_a3 = this.existing) == null ? void 0 : _a3.model) || ((_b2 = this.existing) == null ? void 0 : _b2.modelReasoningEffort) || ((_c = this.existing) == null ? void 0 : _c.sandboxMode) || ((_e = (_d = this.existing) == null ? void 0 : _d.nicknameCandidates) == null ? void 0 : _e.length)) { + details.open = true; + } + new import_obsidian16.Setting(details).setName("Model").setDesc("Model override (leave empty to inherit)").addText((text) => { + var _a4, _b3; + this._modelInput = text.inputEl; + text.setValue((_b3 = (_a4 = this.existing) == null ? void 0 : _a4.model) != null ? _b3 : "").setPlaceholder("gpt-5.4"); + }); + new import_obsidian16.Setting(details).setName("Reasoning effort").setDesc("Model reasoning effort level").addDropdown((dropdown) => { + for (const opt of REASONING_EFFORT_OPTIONS) { + dropdown.addOption(opt.value, opt.label); + } + dropdown.setValue(this._reasoningEffort); + dropdown.onChange((v2) => { + this._reasoningEffort = v2; + }); + }); + new import_obsidian16.Setting(details).setName("Sandbox mode").setDesc("Sandbox restriction for this agent").addDropdown((dropdown) => { + for (const opt of SANDBOX_MODE_OPTIONS) { + dropdown.addOption(opt.value, opt.label); + } + dropdown.setValue(this._sandboxMode); + dropdown.onChange((v2) => { + this._sandboxMode = v2; + }); + }); + new import_obsidian16.Setting(details).setName("Nickname candidates").setDesc("Comma-separated display nicknames (e.g., Atlas, Delta, Echo)").addText((text) => { + var _a4, _b3, _c2; + this._nicknamesInput = text.inputEl; + text.setValue((_c2 = (_b3 = (_a4 = this.existing) == null ? void 0 : _a4.nicknameCandidates) == null ? void 0 : _b3.join(", ")) != null ? _c2 : ""); + }); + new import_obsidian16.Setting(contentEl).setName("Developer instructions").setDesc("Core instructions that define the agent's behavior"); + const instructionsArea = contentEl.createEl("textarea", { + cls: "claudian-sp-content-area", + attr: { + rows: "10", + placeholder: "Review code like an owner.\nPrioritize correctness, security, and missing test coverage." + } + }); + instructionsArea.value = (_g = (_f = this.existing) == null ? void 0 : _f.developerInstructions) != null ? _g : ""; + this._instructionsArea = instructionsArea; + const doSave = async () => { + var _a4, _b3; + const name = this._nameInput.value.trim(); + const nameError = validateCodexSubagentName(name); + if (nameError) { + new import_obsidian16.Notice(nameError); + return; + } + const description = this._descInput.value.trim(); + if (!description) { + new import_obsidian16.Notice("Description is required"); + return; + } + const developerInstructions = this._instructionsArea.value; + if (!developerInstructions.trim()) { + new import_obsidian16.Notice("Developer instructions are required"); + return; + } + const nicknameCandidates = this._nicknamesInput.value.split(",").map((s3) => s3.trim()).filter(Boolean); + const nicknameError = validateCodexNicknameCandidates(nicknameCandidates); + if (nicknameError) { + new import_obsidian16.Notice(nicknameError); + return; + } + const duplicate = this.allAgents.find( + (a3) => { + var _a5; + return a3.name.toLowerCase() === name.toLowerCase() && a3.persistenceKey !== ((_a5 = this.existing) == null ? void 0 : _a5.persistenceKey); + } + ); + if (duplicate) { + new import_obsidian16.Notice(`A subagent named "${name}" already exists`); + return; + } + const agent = { + name, + description, + developerInstructions, + nicknameCandidates: nicknameCandidates.length > 0 ? nicknameCandidates : void 0, + model: this._modelInput.value.trim() || void 0, + modelReasoningEffort: this._reasoningEffort || void 0, + sandboxMode: this._sandboxMode || void 0, + persistenceKey: (_a4 = this.existing) == null ? void 0 : _a4.persistenceKey, + extraFields: (_b3 = this.existing) == null ? void 0 : _b3.extraFields + }; + try { + await this.onSave(agent); + } catch (err) { + const message = err instanceof Error ? err.message : "Unknown error"; + new import_obsidian16.Notice(`Failed to save subagent: ${message}`); + return; + } + this.close(); + }; + this._triggerSave = doSave; + const buttonContainer = contentEl.createDiv({ cls: "claudian-sp-modal-buttons" }); + const cancelBtn = buttonContainer.createEl("button", { + text: "Cancel", + cls: "claudian-cancel-btn" + }); + cancelBtn.addEventListener("click", () => this.close()); + const saveBtn = buttonContainer.createEl("button", { + text: "Save", + cls: "claudian-save-btn" + }); + saveBtn.addEventListener("click", doSave); + } + onClose() { + this.contentEl.empty(); + } +}; +var CodexSubagentSettings = class { + constructor(containerEl, storage, app, onChanged) { + this.agents = []; + this.containerEl = containerEl; + this.storage = storage; + this.app = app; + this.onChanged = onChanged; + this.render(); + } + async render() { + this.containerEl.empty(); + try { + this.agents = await this.storage.loadAll(); + } catch (e3) { + this.agents = []; + } + const headerEl = this.containerEl.createDiv({ cls: "claudian-sp-header" }); + headerEl.createSpan({ text: "Codex Subagents", cls: "claudian-sp-label" }); + const actionsEl = headerEl.createDiv({ cls: "claudian-sp-header-actions" }); + const refreshBtn = actionsEl.createEl("button", { + cls: "claudian-settings-action-btn", + attr: { "aria-label": "Refresh" } + }); + (0, import_obsidian16.setIcon)(refreshBtn, "refresh-cw"); + refreshBtn.addEventListener("click", () => { + void this.render(); + }); + const addBtn = actionsEl.createEl("button", { + cls: "claudian-settings-action-btn", + attr: { "aria-label": "Add" } + }); + (0, import_obsidian16.setIcon)(addBtn, "plus"); + addBtn.addEventListener("click", () => this.openModal(null)); + if (this.agents.length === 0) { + const emptyEl = this.containerEl.createDiv({ cls: "claudian-sp-empty-state" }); + emptyEl.setText("No Codex subagents in vault. Click + to create one."); + return; + } + const listEl = this.containerEl.createDiv({ cls: "claudian-sp-list" }); + for (const agent of this.agents) { + this.renderItem(listEl, agent); + } + } + renderItem(listEl, agent) { + const itemEl = listEl.createDiv({ cls: "claudian-sp-item" }); + const infoEl = itemEl.createDiv({ cls: "claudian-sp-info" }); + const headerRow = infoEl.createDiv({ cls: "claudian-sp-item-header" }); + const nameEl = headerRow.createSpan({ cls: "claudian-sp-item-name" }); + nameEl.setText(agent.name); + if (agent.model) { + headerRow.createSpan({ text: agent.model, cls: "claudian-slash-item-badge" }); + } + if (agent.description) { + const descEl = infoEl.createDiv({ cls: "claudian-sp-item-desc" }); + descEl.setText(agent.description); + } + const actionsEl = itemEl.createDiv({ cls: "claudian-sp-item-actions" }); + const editBtn = actionsEl.createEl("button", { + cls: "claudian-settings-action-btn", + attr: { "aria-label": "Edit" } + }); + (0, import_obsidian16.setIcon)(editBtn, "pencil"); + editBtn.addEventListener("click", () => this.openModal(agent)); + const deleteBtn = actionsEl.createEl("button", { + cls: "claudian-settings-action-btn claudian-settings-delete-btn", + attr: { "aria-label": "Delete" } + }); + (0, import_obsidian16.setIcon)(deleteBtn, "trash-2"); + deleteBtn.addEventListener("click", async () => { + var _a3; + if (!this.app) return; + const confirmed = await confirmDelete( + this.app, + `Delete subagent "${agent.name}"?` + ); + if (!confirmed) return; + try { + await this.storage.delete(agent); + await this.render(); + (_a3 = this.onChanged) == null ? void 0 : _a3.call(this); + new import_obsidian16.Notice(`Subagent "${agent.name}" deleted`); + } catch (e3) { + new import_obsidian16.Notice("Failed to delete subagent"); + } + }); + } + openModal(existing) { + if (!this.app) return; + const modal = new CodexSubagentModal( + this.app, + existing, + this.agents, + async (agent) => { + var _a3; + await this.storage.save(agent, existing); + await this.render(); + (_a3 = this.onChanged) == null ? void 0 : _a3.call(this); + new import_obsidian16.Notice( + existing ? `Subagent "${agent.name}" updated` : `Subagent "${agent.name}" created` + ); + } + ); + modal.open(); + } +}; + +// src/providers/codex/ui/CodexSettingsTab.ts +var codexSettingsTabRenderer = { + render(container, context) { + const codexWorkspace = getCodexWorkspaceServices(); + const settingsBag = context.plugin.settings; + const codexSettings = getCodexProviderSettings(settingsBag); + const hostnameKey = getHostnameKey(); + let installationMethod = codexSettings.installationMethod; + new import_obsidian17.Setting(container).setName(t("settings.setup")).setHeading(); + new import_obsidian17.Setting(container).setName("Enable Codex provider").setDesc("When enabled, Codex models appear in the model selector for new conversations. Existing Codex sessions are preserved.").addToggle( + (toggle) => toggle.setValue(codexSettings.enabled).onChange(async (value) => { + updateCodexProviderSettings(settingsBag, { enabled: value }); + await context.plugin.saveSettings(); + context.refreshModelSelectors(); + }) + ); + new import_obsidian17.Setting(container).setName("Installation method").setDesc("How Claudian should launch Codex on Windows. Native Windows uses a Windows executable path. WSL launches the Linux CLI inside a selected distro.").addDropdown((dropdown) => { + dropdown.addOption("native-windows", "Native Windows").addOption("wsl", "WSL").setValue(installationMethod).onChange(async (value) => { + installationMethod = value === "wsl" ? "wsl" : "native-windows"; + updateCodexProviderSettings(settingsBag, { installationMethod }); + refreshInstallationMethodUI(); + await context.plugin.saveSettings(); + }); + }); + const getCliPathCopy = () => { + if (installationMethod === "wsl") { + return { + desc: "Linux-side Codex command or absolute path to run inside WSL. Leave empty for PATH lookup inside the selected distro.", + placeholder: "codex" + }; + } + return { + desc: "Custom path to the local Codex CLI. Leave empty for auto-detection from PATH. Use the native Windows executable path, usually `codex.exe`.", + placeholder: "C:\\Users\\you\\AppData\\Roaming\\npm\\codex.exe" + }; + }; + const shouldValidateCliPathAsFile = () => installationMethod !== "wsl"; + const cliPathSetting = new import_obsidian17.Setting(container).setName(`Codex CLI path (${hostnameKey})`).setDesc(getCliPathCopy().desc); + const validationEl = container.createDiv({ cls: "claudian-cli-path-validation" }); + validationEl.style.color = "var(--text-error)"; + validationEl.style.fontSize = "0.85em"; + validationEl.style.marginTop = "-0.5em"; + validationEl.style.marginBottom = "0.5em"; + validationEl.style.display = "none"; + const validatePath = (value) => { + const trimmed = value.trim(); + if (!trimmed) return null; + if (!shouldValidateCliPathAsFile()) { + if (isWindowsStyleCliReference(trimmed)) { + return "WSL mode expects a Linux command or Linux absolute path, not a Windows executable path."; + } + return null; + } + const expandedPath = expandHomePath(trimmed); + if (!fs13.existsSync(expandedPath)) { + return t("settings.cliPath.validation.notExist"); + } + const stat = fs13.statSync(expandedPath); + if (!stat.isFile()) { + return t("settings.cliPath.validation.isDirectory"); + } + return null; + }; + const updateCliPathValidation = (value, inputEl) => { + const error48 = validatePath(value); + if (error48) { + validationEl.setText(error48); + validationEl.style.display = "block"; + if (inputEl) { + inputEl.style.borderColor = "var(--text-error)"; + } + return false; + } + validationEl.style.display = "none"; + if (inputEl) { + inputEl.style.borderColor = ""; + } + return true; + }; + const cliPathsByHost = { ...codexSettings.cliPathsByHost }; + let cliPathInputEl = null; + let wslDistroSettingEl = null; + let wslDistroInputEl = null; + const refreshInstallationMethodUI = () => { + const cliCopy = getCliPathCopy(); + cliPathSetting.setDesc(cliCopy.desc); + if (cliPathInputEl) { + cliPathInputEl.placeholder = cliCopy.placeholder; + updateCliPathValidation(cliPathInputEl.value, cliPathInputEl); + } + if (wslDistroSettingEl) { + wslDistroSettingEl.style.display = installationMethod === "wsl" ? "" : "none"; + } + if (wslDistroInputEl) { + wslDistroInputEl.disabled = installationMethod !== "wsl"; + } + }; + const persistCliPath = async (value) => { + var _a3; + const isValid2 = updateCliPathValidation(value, cliPathInputEl != null ? cliPathInputEl : void 0); + if (!isValid2) { + return false; + } + const trimmed = value.trim(); + if (trimmed) { + cliPathsByHost[hostnameKey] = trimmed; + } else { + delete cliPathsByHost[hostnameKey]; + } + updateCodexProviderSettings(settingsBag, { cliPathsByHost: { ...cliPathsByHost } }); + await context.plugin.saveSettings(); + const view = context.plugin.getView(); + await ((_a3 = view == null ? void 0 : view.getTabManager()) == null ? void 0 : _a3.broadcastToAllTabs( + (service) => Promise.resolve(service.cleanup()) + )); + return true; + }; + const currentValue = codexSettings.cliPathsByHost[hostnameKey] || ""; + cliPathSetting.addText((text) => { + text.setPlaceholder(getCliPathCopy().placeholder).setValue(currentValue).onChange(async (value) => { + await persistCliPath(value); + }); + text.inputEl.addClass("claudian-settings-cli-path-input"); + text.inputEl.style.width = "100%"; + cliPathInputEl = text.inputEl; + updateCliPathValidation(currentValue, text.inputEl); + }); + const wslDistroSetting = new import_obsidian17.Setting(container).setName("WSL distro override").setDesc("Optional advanced override. Leave empty to infer the distro from a \\\\wsl$ workspace path when possible, otherwise use the default WSL distro."); + wslDistroSettingEl = wslDistroSetting.settingEl; + wslDistroSetting.addText((text) => { + text.setPlaceholder("Ubuntu").setValue(codexSettings.wslDistroOverride).onChange(async (value) => { + updateCodexProviderSettings(settingsBag, { wslDistroOverride: value }); + await context.plugin.saveSettings(); + }); + text.inputEl.addClass("claudian-settings-cli-path-input"); + text.inputEl.style.width = "100%"; + text.inputEl.disabled = installationMethod !== "wsl"; + wslDistroInputEl = text.inputEl; + }); + refreshInstallationMethodUI(); + new import_obsidian17.Setting(container).setName(t("settings.safety")).setHeading(); + new import_obsidian17.Setting(container).setName(t("settings.codexSafeMode.name")).setDesc(t("settings.codexSafeMode.desc")).addDropdown((dropdown) => { + dropdown.addOption("workspace-write", "workspace-write").addOption("read-only", "read-only").setValue(codexSettings.safeMode).onChange(async (value) => { + updateCodexProviderSettings( + settingsBag, + { safeMode: value } + ); + await context.plugin.saveSettings(); + }); + }); + new import_obsidian17.Setting(container).setName(t("settings.models")).setHeading(); + const SUMMARY_OPTIONS = [ + { value: "auto", label: "Auto" }, + { value: "concise", label: "Concise" }, + { value: "detailed", label: "Detailed" }, + { value: "none", label: "Off" } + ]; + new import_obsidian17.Setting(container).setName("Reasoning summary").setDesc("Show a summary of the model's reasoning process in the thinking block.").addDropdown((dropdown) => { + for (const opt of SUMMARY_OPTIONS) { + dropdown.addOption(opt.value, opt.label); + } + dropdown.setValue(codexSettings.reasoningSummary); + dropdown.onChange(async (value) => { + updateCodexProviderSettings( + settingsBag, + { reasoningSummary: value } + ); + await context.plugin.saveSettings(); + }); + }); + const codexCatalog = codexWorkspace.commandCatalog; + if (codexCatalog) { + new import_obsidian17.Setting(container).setName("Codex Skills").setHeading(); + const skillsDesc = container.createDiv({ cls: "claudian-sp-settings-desc" }); + skillsDesc.createEl("p", { + cls: "setting-item-description", + text: "Manage vault-level Codex skills stored in .codex/skills/ or .agents/skills/. Home-level skills are excluded here." + }); + const skillsContainer = container.createDiv({ cls: "claudian-slash-commands-container" }); + new CodexSkillSettings(skillsContainer, codexCatalog, context.plugin.app); + } + context.renderHiddenProviderCommandSetting(container, "codex", { + name: "Hidden Skills", + desc: "Hide specific Codex skills from the dropdown. Enter skill names without the leading $, one per line.", + placeholder: "analyze\nexplain\nfix" + }); + new import_obsidian17.Setting(container).setName("Codex Subagents").setHeading(); + const subagentDesc = container.createDiv({ cls: "claudian-sp-settings-desc" }); + subagentDesc.createEl("p", { + cls: "setting-item-description", + text: "Manage vault-level Codex subagents stored in .codex/agents/. Each TOML file defines one custom agent." + }); + const subagentContainer = container.createDiv({ cls: "claudian-slash-commands-container" }); + new CodexSubagentSettings(subagentContainer, codexWorkspace.subagentStorage, context.plugin.app, () => { + var _a3; + void ((_a3 = codexWorkspace.refreshAgentMentions) == null ? void 0 : _a3.call(codexWorkspace)); + }); + new import_obsidian17.Setting(container).setName(t("settings.mcpServers.name")).setHeading(); + const mcpNotice = container.createDiv({ cls: "claudian-mcp-settings-desc" }); + const mcpDesc = mcpNotice.createEl("p", { cls: "setting-item-description" }); + mcpDesc.appendText("Codex manages MCP servers via its own CLI. Configure with "); + mcpDesc.createEl("code", { text: "codex mcp" }); + mcpDesc.appendText(" and they will be available in Claudian. "); + mcpDesc.createEl("a", { + text: "Learn more", + href: "https://developers.openai.com/codex/mcp" + }); + renderEnvironmentSettingsSection({ + container, + plugin: context.plugin, + scope: "provider:codex", + heading: t("settings.environment"), + name: "Codex environment", + desc: "Codex-owned runtime variables only. Use this for OPENAI_* and CODEX_* settings. If Codex auto-detection needs help, add its install directory to shared PATH instead of this provider section.", + placeholder: "OPENAI_API_KEY=your-key\nOPENAI_BASE_URL=https://api.openai.com/v1\nOPENAI_MODEL=gpt-5.4\nCODEX_SANDBOX=workspace-write", + renderCustomContextLimits: (target) => context.renderCustomContextLimits(target, "codex") + }); + } +}; + +// src/providers/codex/app/CodexWorkspaceServices.ts +function createCodexCliResolver() { + return new CodexCliResolver(); +} +async function createCodexWorkspaceServices(plugin, vaultAdapter, homeAdapter) { + const subagentStorage = new CodexSubagentStorage(vaultAdapter); + const agentMentionProvider = new CodexAgentMentionProvider(subagentStorage); + await agentMentionProvider.loadAgents(); + const skillListProvider = new CodexSkillListingService(plugin); + const commandCatalog = new CodexSkillCatalog( + new CodexSkillStorage( + vaultAdapter, + homeAdapter + ), + skillListProvider, + getVaultPath(plugin.app) + ); + return { + subagentStorage, + commandCatalog, + agentMentionProvider, + cliResolver: createCodexCliResolver(), + settingsTabRenderer: codexSettingsTabRenderer, + refreshAgentMentions: async () => { + await agentMentionProvider.loadAgents(); + } + }; +} +var codexWorkspaceRegistration = { + initialize: async ({ plugin, vaultAdapter, homeAdapter }) => createCodexWorkspaceServices( + plugin, + vaultAdapter, + homeAdapter + ) +}; +function getCodexWorkspaceServices() { + return ProviderWorkspaceRegistry.requireServices("codex"); +} + +// src/providers/codex/runtime/CodexAuxQueryRunner.ts +var CodexAuxQueryRunner = class { + constructor(plugin) { + this.plugin = plugin; + this.process = null; + this.transport = null; + this.threadId = null; + this.launchSpec = null; + } + async query(config2, prompt) { + var _a3, _b2, _c, _d, _e, _f, _g, _h, _i; + if (!this.process || !this.transport) { + await this.startProcess(); + } + if (!this.threadId) { + const model = (_a3 = config2.model) != null ? _a3 : this.resolveProviderModel(); + const result = await this.transport.request("thread/start", { + model, + cwd: (_c = (_b2 = this.launchSpec) == null ? void 0 : _b2.targetCwd) != null ? _c : process.cwd(), + approvalPolicy: "never", + sandbox: "read-only", + baseInstructions: config2.systemPrompt, + experimentalRawEvents: false, + persistExtendedHistory: false + }); + this.threadId = result.thread.id; + } + let accumulatedText = ""; + let turnError = null; + let resolveWait = null; + const donePromise = new Promise((resolve5) => { + resolveWait = resolve5; + }); + this.transport.onNotification("item/agentMessage/delta", (params) => { + var _a4; + const p = params; + accumulatedText += p.delta; + (_a4 = config2.onTextChunk) == null ? void 0 : _a4.call(config2, accumulatedText); + }); + this.transport.onNotification("turn/completed", (params) => { + const p = params; + if (p.turn.status === "failed" && p.turn.error) { + turnError = p.turn.error.message; + } + resolveWait == null ? void 0 : resolveWait(); + }); + this.transport.onNotification("error", (params) => { + const p = params; + if (!p.willRetry) { + turnError = p.error.message; + resolveWait == null ? void 0 : resolveWait(); + } + }); + const exitHandler = () => { + if (!turnError) turnError = "Codex app-server process exited unexpectedly"; + resolveWait == null ? void 0 : resolveWait(); + }; + this.process.onExit(exitHandler); + let turnId = null; + const abortHandler = () => { + if (this.transport && this.threadId && turnId) { + this.transport.request("turn/interrupt", { + threadId: this.threadId, + turnId + }).catch(() => { + }); + } + resolveWait == null ? void 0 : resolveWait(); + }; + (_d = config2.abortController) == null ? void 0 : _d.signal.addEventListener("abort", abortHandler, { once: true }); + if ((_e = config2.abortController) == null ? void 0 : _e.signal.aborted) { + config2.abortController.signal.removeEventListener("abort", abortHandler); + (_f = this.process) == null ? void 0 : _f.offExit(exitHandler); + throw new Error("Cancelled"); + } + const turnResult = await this.transport.request("turn/start", { + threadId: this.threadId, + input: [{ type: "text", text: prompt }], + model: config2.model + }); + turnId = turnResult.turn.id; + try { + await donePromise; + } finally { + (_g = config2.abortController) == null ? void 0 : _g.signal.removeEventListener("abort", abortHandler); + (_h = this.process) == null ? void 0 : _h.offExit(exitHandler); + } + if ((_i = config2.abortController) == null ? void 0 : _i.signal.aborted) { + throw new Error("Cancelled"); + } + if (turnError) { + throw new Error(turnError); + } + return accumulatedText; + } + reset() { + this.threadId = null; + this.launchSpec = null; + if (this.transport) { + this.transport.dispose(); + this.transport = null; + } + if (this.process) { + this.process.shutdown().catch(() => { + }); + this.process = null; + } + } + resolveProviderModel() { + var _a3; + const providerSettings = ProviderSettingsCoordinator.getProviderSettingsSnapshot( + this.plugin.settings, + "codex" + ); + return (_a3 = providerSettings.model) != null ? _a3 : "gpt-5.4"; + } + async startProcess() { + this.launchSpec = resolveCodexAppServerLaunchSpec(this.plugin, "codex"); + this.process = new CodexAppServerProcess(this.launchSpec); + this.process.start(); + this.transport = new CodexRpcTransport(this.process); + this.transport.start(); + const initializeResult = await this.transport.request("initialize", { + clientInfo: { name: "claudian-aux", version: "1.0.0" }, + capabilities: { experimentalApi: true } + }); + createCodexRuntimeContext(this.launchSpec, initializeResult); + this.transport.notify("initialized"); + } +}; + +// src/providers/codex/aux/CodexInlineEditService.ts +var CodexInlineEditService = class { + constructor(plugin) { + this.abortController = null; + this.hasThread = false; + this.plugin = plugin; + this.runner = new CodexAuxQueryRunner(plugin); + } + resetConversation() { + this.runner.reset(); + this.hasThread = false; + } + async editText(request) { + this.resetConversation(); + const prompt = buildInlineEditPrompt(request); + return this.sendMessage(prompt); + } + async continueConversation(message, contextFiles) { + if (!this.hasThread) { + return { success: false, error: "No active conversation to continue" }; + } + let prompt = message; + if (contextFiles && contextFiles.length > 0) { + prompt = appendContextFiles(message, contextFiles); + } + return this.sendMessage(prompt); + } + cancel() { + if (this.abortController) { + this.abortController.abort(); + this.abortController = null; + } + } + async sendMessage(prompt) { + this.abortController = new AbortController(); + try { + const text = await this.runner.query({ + systemPrompt: getInlineEditSystemPrompt(), + abortController: this.abortController + }, prompt); + this.hasThread = true; + return parseInlineEditResponse(text); + } catch (error48) { + const msg = error48 instanceof Error ? error48.message : "Unknown error"; + return { success: false, error: msg }; + } finally { + this.abortController = null; + } + } +}; + +// src/providers/codex/aux/CodexInstructionRefineService.ts +var CodexInstructionRefineService = class { + constructor(plugin) { + this.abortController = null; + this.existingInstructions = ""; + this.hasThread = false; + this.runner = new CodexAuxQueryRunner(plugin); + } + resetConversation() { + this.runner.reset(); + this.hasThread = false; + } + async refineInstruction(rawInstruction, existingInstructions, onProgress) { + this.resetConversation(); + this.existingInstructions = existingInstructions; + const prompt = `Please refine this instruction: "${rawInstruction}"`; + return this.sendMessage(prompt, onProgress); + } + async continueConversation(message, onProgress) { + if (!this.hasThread) { + return { success: false, error: "No active conversation to continue" }; + } + return this.sendMessage(message, onProgress); + } + cancel() { + if (this.abortController) { + this.abortController.abort(); + this.abortController = null; + } + } + async sendMessage(prompt, onProgress) { + this.abortController = new AbortController(); + try { + const text = await this.runner.query({ + systemPrompt: buildRefineSystemPrompt(this.existingInstructions), + abortController: this.abortController, + onTextChunk: onProgress ? (accumulated) => onProgress(this.parseResponse(accumulated)) : void 0 + }, prompt); + this.hasThread = true; + return this.parseResponse(text); + } catch (error48) { + const msg = error48 instanceof Error ? error48.message : "Unknown error"; + return { success: false, error: msg }; + } finally { + this.abortController = null; + } + } + parseResponse(text) { + const match = text.match(/([\s\S]*?)<\/instruction>/); + if (match) { + return { success: true, refinedInstruction: match[1].trim() }; + } + const trimmed = text.trim(); + if (trimmed) { + return { success: true, clarification: trimmed }; + } + return { success: false, error: "Empty response" }; + } +}; + +// src/providers/codex/aux/CodexTaskResultInterpreter.ts +var CodexTaskResultInterpreter = class { + hasAsyncLaunchMarker(_toolUseResult) { + return false; + } + extractAgentId(_toolUseResult) { + return null; + } + extractStructuredResult(_toolUseResult) { + return null; + } + resolveTerminalStatus(_toolUseResult, fallbackStatus) { + return fallbackStatus; + } + extractTagValue(_payload, _tagName) { + return null; + } +}; + +// src/providers/codex/aux/CodexTitleGenerationService.ts +var CodexTitleGenerationService = class { + constructor(plugin) { + this.activeGenerations = /* @__PURE__ */ new Map(); + this.plugin = plugin; + } + async generateTitle(conversationId, userMessage, callback) { + const existing = this.activeGenerations.get(conversationId); + if (existing) existing.abort(); + const abortController = new AbortController(); + this.activeGenerations.set(conversationId, abortController); + const truncated = userMessage.length > 500 ? userMessage.substring(0, 500) + "..." : userMessage; + const prompt = `User's request: +""" +${truncated} +""" + +Generate a title for this conversation:`; + const runner = new CodexAuxQueryRunner(this.plugin); + try { + const text = await runner.query({ + systemPrompt: TITLE_GENERATION_SYSTEM_PROMPT, + model: this.resolveTitleModel(), + abortController + }, prompt); + const title = this.parseTitle(text); + if (title) { + await this.safeCallback(callback, conversationId, { success: true, title }); + } else { + await this.safeCallback(callback, conversationId, { + success: false, + error: "Failed to parse title from response" + }); + } + } catch (error48) { + const msg = error48 instanceof Error ? error48.message : "Unknown error"; + await this.safeCallback(callback, conversationId, { success: false, error: msg }); + } finally { + runner.reset(); + this.activeGenerations.delete(conversationId); + } + } + cancel() { + for (const controller of this.activeGenerations.values()) { + controller.abort(); + } + this.activeGenerations.clear(); + } + resolveTitleModel() { + return this.plugin.settings.titleGenerationModel || void 0; + } + parseTitle(responseText) { + const trimmed = responseText.trim(); + if (!trimmed) return null; + let title = trimmed; + if (title.startsWith('"') && title.endsWith('"') || title.startsWith("'") && title.endsWith("'")) { + title = title.slice(1, -1); + } + title = title.replace(/[.!?:;,]+$/, ""); + if (title.length > 50) { + title = title.substring(0, 47) + "..."; + } + return title || null; + } + async safeCallback(callback, conversationId, result) { + try { + await callback(conversationId, result); + } catch (e3) { + } + } +}; + +// src/providers/codex/capabilities.ts +var CODEX_PROVIDER_CAPABILITIES = Object.freeze({ + providerId: "codex", + supportsPersistentRuntime: true, + supportsNativeHistory: true, + supportsPlanMode: true, + supportsRewind: false, + supportsFork: true, + supportsProviderCommands: false, + supportsImageAttachments: true, + supportsInstructionMode: true, + supportsMcpTools: false, + supportsTurnSteer: true, + reasoningControl: "effort" +}); + +// src/providers/codex/env/CodexSettingsReconciler.ts +init_env(); + +// src/providers/codex/types/index.ts +function getCodexState(providerState) { + return providerState != null ? providerState : {}; +} + +// src/providers/codex/ui/CodexChatUIConfig.ts +var OPENAI_ICON = { + viewBox: "-1 -.1 949.1 959.8", + path: "m925.8 456.3c10.4 23.2 17 48 19.7 73.3 2.6 25.3 1.3 50.9-4.1 75.8-5.3 24.9-14.5 48.8-27.3 70.8-8.4 14.7-18.3 28.5-29.7 41.2-11.3 12.6-23.9 24-37.6 34-13.8 10-28.5 18.4-44.1 25.3-15.5 6.8-31.7 12-48.3 15.4-7.8 24.2-19.4 47.1-34.4 67.7-14.9 20.6-33 38.7-53.6 53.6-20.6 15-43.4 26.6-67.6 34.4-24.2 7.9-49.5 11.8-75 11.8-16.9.1-33.9-1.7-50.5-5.1-16.5-3.5-32.7-8.8-48.2-15.7s-30.2-15.5-43.9-25.5c-13.6-10-26.2-21.5-37.4-34.2-25 5.4-50.6 6.7-75.9 4.1-25.3-2.7-50.1-9.3-73.4-19.7-23.2-10.3-44.7-24.3-63.6-41.4s-35-37.1-47.7-59.1c-8.5-14.7-15.5-30.2-20.8-46.3s-8.8-32.7-10.6-49.6c-1.8-16.8-1.7-33.8.1-50.7 1.8-16.8 5.5-33.4 10.8-49.5-17-18.9-31-40.4-41.4-63.6-10.3-23.3-17-48-19.6-73.3-2.7-25.3-1.3-50.9 4-75.8s14.5-48.8 27.3-70.8c8.4-14.7 18.3-28.6 29.6-41.2s24-24 37.7-34 28.5-18.5 44-25.3c15.6-6.9 31.8-12 48.4-15.4 7.8-24.3 19.4-47.1 34.3-67.7 15-20.6 33.1-38.7 53.7-53.7 20.6-14.9 43.4-26.5 67.6-34.4 24.2-7.8 49.5-11.8 75-11.7 16.9-.1 33.9 1.6 50.5 5.1s32.8 8.7 48.3 15.6c15.5 7 30.2 15.5 43.9 25.5 13.7 10.1 26.3 21.5 37.5 34.2 24.9-5.3 50.5-6.6 75.8-4s50 9.3 73.3 19.6c23.2 10.4 44.7 24.3 63.6 41.4 18.9 17 35 36.9 47.7 59 8.5 14.6 15.5 30.1 20.8 46.3 5.3 16.1 8.9 32.7 10.6 49.6 1.8 16.9 1.8 33.9-.1 50.8-1.8 16.9-5.5 33.5-10.8 49.6 17.1 18.9 31 40.3 41.4 63.6zm-333.2 426.9c21.8-9 41.6-22.3 58.3-39s30-36.5 39-58.4c9-21.8 13.7-45.2 13.7-68.8v-223q-.1-.3-.2-.7-.1-.3-.3-.6-.2-.3-.5-.5-.3-.3-.6-.4l-80.7-46.6v269.4c0 2.7-.4 5.5-1.1 8.1-.7 2.7-1.7 5.2-3.1 7.6s-3 4.6-5 6.5a32.1 32.1 0 0 1-6.5 5l-191.1 110.3c-1.6 1-4.3 2.4-5.7 3.2 7.9 6.7 16.5 12.6 25.5 17.8 9.1 5.2 18.5 9.6 28.3 13.2 9.8 3.5 19.9 6.2 30.1 8 10.3 1.8 20.7 2.7 31.1 2.7 23.6 0 47-4.7 68.8-13.8zm-455.1-151.4c11.9 20.5 27.6 38.3 46.3 52.7 18.8 14.4 40.1 24.9 62.9 31s46.6 7.7 70 4.6 45.9-10.7 66.4-22.5l193.2-111.5.5-.5q.2-.2.3-.6.2-.3.3-.6v-94l-233.2 134.9c-2.4 1.4-4.9 2.4-7.5 3.2-2.7.7-5.4 1-8.2 1-2.7 0-5.4-.3-8.1-1-2.6-.8-5.2-1.8-7.6-3.2l-191.1-110.4c-1.7-1-4.2-2.5-5.6-3.4-1.8 10.3-2.7 20.7-2.7 31.1s1 20.8 2.8 31.1c1.8 10.2 4.6 20.3 8.1 30.1 3.6 9.8 8 19.2 13.2 28.2zm-50.2-417c-11.8 20.5-19.4 43.1-22.5 66.5s-1.5 47.1 4.6 70c6.1 22.8 16.6 44.1 31 62.9 14.4 18.7 32.3 34.4 52.7 46.2l193.1 111.6q.3.1.7.2h.7q.4 0 .7-.2.3-.1.6-.3l81-46.8-233.2-134.6c-2.3-1.4-4.5-3.1-6.5-5a32.1 32.1 0 0 1-5-6.5c-1.3-2.4-2.4-4.9-3.1-7.6-.7-2.6-1.1-5.3-1-8.1v-227.1c-9.8 3.6-19.3 8-28.3 13.2-9 5.3-17.5 11.3-25.5 18-7.9 6.7-15.3 14.1-22 22.1-6.7 7.9-12.6 16.5-17.8 25.5zm663.3 154.4c2.4 1.4 4.6 3 6.6 5 1.9 1.9 3.6 4.1 5 6.5 1.3 2.4 2.4 5 3.1 7.6.6 2.7 1 5.4.9 8.2v227.1c32.1-11.8 60.1-32.5 80.8-59.7 20.8-27.2 33.3-59.7 36.2-93.7s-3.9-68.2-19.7-98.5-39.9-55.5-69.5-72.5l-193.1-111.6q-.3-.1-.7-.2h-.7q-.3.1-.7.2-.3.1-.6.3l-80.6 46.6 233.2 134.7zm80.5-121h-.1v.1zm-.1-.1c5.8-33.6 1.9-68.2-11.3-99.7-13.1-31.5-35-58.6-63-78.2-28-19.5-61-30.7-95.1-32.2-34.2-1.4-68 6.9-97.6 23.9l-193.1 111.5q-.3.2-.5.5l-.4.6q-.1.3-.2.7-.1.3-.1.7v93.2l233.2-134.7c2.4-1.4 5-2.4 7.6-3.2 2.7-.7 5.4-1 8.1-1 2.8 0 5.5.3 8.2 1 2.6.8 5.1 1.8 7.5 3.2l191.1 110.4c1.7 1 4.2 2.4 5.6 3.3zm-505.3-103.2c0-2.7.4-5.4 1.1-8.1.7-2.6 1.7-5.2 3.1-7.6 1.4-2.3 3-4.5 5-6.5 1.9-1.9 4.1-3.6 6.5-4.9l191.1-110.3c1.8-1.1 4.3-2.5 5.7-3.2-26.2-21.9-58.2-35.9-92.1-40.2-33.9-4.4-68.3 1-99.2 15.5-31 14.5-57.2 37.6-75.5 66.4-18.3 28.9-28 62.3-28 96.5v223q.1.4.2.7.1.3.3.6.2.3.5.6.2.2.6.4l80.7 46.6zm43.8 294.7 103.9 60 103.9-60v-119.9l-103.8-60-103.9 60z" +}; +var CODEX_MODELS = [ + { value: "gpt-5.4-mini", label: "GPT-5.4 Mini", description: "Fast" }, + { value: "gpt-5.4", label: "GPT-5.4", description: "Latest" } +]; +var CODEX_MODEL_SET = new Set(CODEX_MODELS.map((m3) => m3.value)); +var EFFORT_LEVELS2 = [ + { value: "low", label: "Low" }, + { value: "medium", label: "Medium" }, + { value: "high", label: "High" }, + { value: "xhigh", label: "XHigh" } +]; +var CODEX_PERMISSION_MODE_TOGGLE = { + inactiveValue: "normal", + inactiveLabel: "Safe", + activeValue: "yolo", + activeLabel: "YOLO", + planValue: "plan", + planLabel: "Plan" +}; +var CODEX_SERVICE_TIER_TOGGLE = { + inactiveValue: "default", + inactiveLabel: "Standard", + activeValue: "fast", + activeLabel: "Fast", + description: "Enable GPT-5.4 fast mode for this conversation. Faster responses use more credits." +}; +var DEFAULT_CONTEXT_WINDOW = 2e5; +function looksLikeCodexModel(model) { + return /^gpt-/i.test(model) || /^o\d/i.test(model); +} +var codexChatUIConfig = { + getModelOptions(settings11) { + const envVars = getRuntimeEnvironmentVariables(settings11, "codex"); + if (envVars.OPENAI_MODEL) { + const customModel = envVars.OPENAI_MODEL; + if (!CODEX_MODEL_SET.has(customModel)) { + return [ + { value: customModel, label: customModel, description: "Custom (env)" }, + ...CODEX_MODELS + ]; + } + } + return [...CODEX_MODELS]; + }, + ownsModel(model, settings11) { + if (this.getModelOptions(settings11).some((option) => option.value === model)) { + return true; + } + return looksLikeCodexModel(model); + }, + isAdaptiveReasoningModel() { + return true; + }, + getReasoningOptions() { + return [...EFFORT_LEVELS2]; + }, + getDefaultReasoningValue() { + return "medium"; + }, + getContextWindowSize() { + return DEFAULT_CONTEXT_WINDOW; + }, + isDefaultModel(model) { + return CODEX_MODEL_SET.has(model); + }, + applyModelDefaults() { + }, + normalizeModelVariant(model) { + return model; + }, + getCustomModelIds(envVars) { + const ids = /* @__PURE__ */ new Set(); + if (envVars.OPENAI_MODEL && !CODEX_MODEL_SET.has(envVars.OPENAI_MODEL)) { + ids.add(envVars.OPENAI_MODEL); + } + return ids; + }, + getPermissionModeToggle() { + return CODEX_PERMISSION_MODE_TOGGLE; + }, + getServiceTierToggle(settings11) { + return settings11.model === "gpt-5.4" ? CODEX_SERVICE_TIER_TOGGLE : null; + }, + getProviderIcon() { + return OPENAI_ICON; + } +}; + +// src/providers/codex/env/CodexSettingsReconciler.ts +var ENV_HASH_KEYS = ["OPENAI_MODEL", "OPENAI_BASE_URL", "OPENAI_API_KEY"]; +function computeCodexEnvHash(envText) { + const envVars = parseEnvironmentVariables(envText || ""); + return ENV_HASH_KEYS.filter((key) => envVars[key]).map((key) => `${key}=${envVars[key]}`).sort().join("|"); +} +var codexSettingsReconciler = { + reconcileModelWithEnvironment(settings11, conversations) { + var _a3, _b2; + const envText = getRuntimeEnvironmentText(settings11, "codex"); + const currentHash = computeCodexEnvHash(envText); + const savedHash = getCodexProviderSettings(settings11).environmentHash; + if (currentHash === savedHash) { + return { changed: false, invalidatedConversations: [] }; + } + const invalidatedConversations = []; + for (const conv of conversations) { + const state = getCodexState(conv.providerState); + if (conv.providerId === "codex" && (conv.sessionId || state.threadId)) { + conv.sessionId = null; + conv.providerState = void 0; + invalidatedConversations.push(conv); + } + } + const envVars = parseEnvironmentVariables(envText || ""); + if (envVars.OPENAI_MODEL) { + settings11.model = envVars.OPENAI_MODEL; + } else if (typeof settings11.model === "string" && settings11.model.length > 0 && !codexChatUIConfig.isDefaultModel(settings11.model)) { + settings11.model = (_b2 = (_a3 = codexChatUIConfig.getModelOptions({})[0]) == null ? void 0 : _a3.value) != null ? _b2 : "gpt-5.4"; + } + updateCodexProviderSettings(settings11, { environmentHash: currentHash }); + return { changed: true, invalidatedConversations }; + }, + normalizeModelVariantSettings() { + return false; + } +}; + +// src/providers/codex/history/CodexHistoryStore.ts +var fs14 = __toESM(require("fs")); +var os9 = __toESM(require("os")); +var path14 = __toESM(require("path")); + +// src/providers/codex/normalization/codexToolNormalization.ts +var TOOL_NAME_MAP = { + command_execution: "Bash", + shell_command: "Bash", + shell: "Bash", + exec_command: "Bash", + update_plan: "TodoWrite", + request_user_input: "AskUserQuestion", + view_image: "Read", + web_search: "WebSearch", + web_search_call: "WebSearch", + file_change: "apply_patch" +}; +var NATIVE_TOOLS = /* @__PURE__ */ new Set([ + "apply_patch", + "write_stdin", + "spawn_agent", + "send_input", + "wait", + "wait_agent", + "resume_agent", + "close_agent" +]); +function normalizeCodexToolName(rawName) { + var _a3; + if (!rawName) return "tool"; + if (NATIVE_TOOLS.has(rawName)) return rawName; + return (_a3 = TOOL_NAME_MAP[rawName]) != null ? _a3 : rawName; +} +function normalizeCodexToolInput(rawName, input) { + var _a3, _b2, _c, _d; + switch (rawName) { + case "command_execution": + case "shell_command": + case "shell": + case "exec_command": + return { command: normalizeCommandValue((_b2 = (_a3 = input.command) != null ? _a3 : input.cmd) != null ? _b2 : "") }; + case "update_plan": + return { todos: normalizeUpdatePlanTodos(input) }; + case "request_user_input": + return { questions: normalizeQuestions(input) }; + case "view_image": + return { + ...input, + file_path: (_d = (_c = input.path) != null ? _c : input.file_path) != null ? _d : "" + }; + case "web_search": + case "web_search_call": + return normalizeWebSearchInput(input); + case "apply_patch": + return normalizeApplyPatchInput(input); + default: + return input; + } +} +function normalizeUpdatePlanTodos(input) { + const plan = input.plan; + if (!Array.isArray(plan)) return []; + return plan.map((entry) => { + var _a3, _b2, _c, _d, _e; + if (!entry || typeof entry !== "object") return { id: "", title: "", status: "pending" }; + const item = entry; + const text = String((_c = (_b2 = (_a3 = item.step) != null ? _a3 : item.title) != null ? _b2 : item.content) != null ? _c : ""); + return { + id: String((_d = item.id) != null ? _d : ""), + content: text, + activeForm: text, + status: String((_e = item.status) != null ? _e : "pending") + }; + }); +} +function normalizeQuestions(input) { + const questions = input.questions; + if (!Array.isArray(questions)) return []; + return questions.map((entry, index) => { + var _a3, _b2; + if (!entry || typeof entry !== "object") { + return { + question: `Question ${index + 1}`, + header: `Q${index + 1}`, + options: [], + multiSelect: false + }; + } + const item = entry; + const options = Array.isArray(item.options) ? item.options.map((option) => { + if (typeof option === "string") { + return { label: option, description: "" }; + } + if (!option || typeof option !== "object") { + return null; + } + const raw = option; + const label = typeof raw.label === "string" ? raw.label : ""; + const description = typeof raw.description === "string" ? raw.description : ""; + if (!label) return null; + return { label, description }; + }).filter((option) => option !== null) : []; + return { + question: String((_a3 = item.question) != null ? _a3 : `Question ${index + 1}`), + ...item.id ? { id: String(item.id) } : {}, + header: typeof item.header === "string" && item.header.trim() ? String(item.header) : `Q${index + 1}`, + options, + multiSelect: Boolean((_b2 = item.multiSelect) != null ? _b2 : item.multi_select) + }; + }); +} +function normalizeCommandValue(value) { + if (typeof value === "string") return value; + if (Array.isArray(value)) { + return value.map((entry) => typeof entry === "string" ? entry : String(entry)).join(" ").trim(); + } + return value == null ? "" : String(value); +} +function normalizeWebSearchInput(input) { + var _a3; + const action = input.action && typeof input.action === "object" ? input.action : {}; + const queries = normalizeStringArray2((_a3 = action.queries) != null ? _a3 : input.queries); + const query = firstNonEmptyString(action.query, input.query, queries[0]); + const url2 = firstNonEmptyString(action.url, input.url); + const pattern = firstNonEmptyString(action.pattern, input.pattern); + const explicitType = firstNonEmptyString(action.type, input.actionType, input.action_type); + const actionType = explicitType || (url2 && pattern ? "find_in_page" : url2 ? "open_page" : query || queries.length > 0 ? "search" : ""); + const normalized = {}; + if (actionType) normalized.actionType = actionType; + if (query) normalized.query = query; + if (queries.length > 0) normalized.queries = queries; + if (url2) normalized.url = url2; + if (pattern) normalized.pattern = pattern; + return normalized; +} +function normalizeApplyPatchInput(input) { + const patch = firstNonEmptyString(input.patch, input.raw, input.value); + if (!patch) return input; + const normalized = { ...input, patch }; + delete normalized.raw; + delete normalized.value; + return normalized; +} +function firstNonEmptyString(...values) { + for (const value of values) { + if (typeof value === "string" && value.trim()) { + return value; + } + } + return ""; +} +function normalizeStringArray2(value) { + if (!Array.isArray(value)) return []; + const uniqueValues = /* @__PURE__ */ new Set(); + for (const entry of value) { + if (typeof entry !== "string") continue; + const trimmed = entry.trim(); + if (!trimmed) continue; + uniqueValues.add(trimmed); + } + return [...uniqueValues]; +} +function normalizeCodexMcpToolName(server, tool) { + const serverName = typeof server === "string" ? server : ""; + const toolName = typeof tool === "string" ? tool : ""; + if (!serverName && !toolName) return "tool"; + return `mcp__${serverName}__${toolName}`; +} +function normalizeCodexMcpToolInput(rawArguments) { + if (typeof rawArguments === "string") { + return parseCodexArguments(rawArguments); + } + if (rawArguments && typeof rawArguments === "object" && !Array.isArray(rawArguments)) { + return rawArguments; + } + return {}; +} +function normalizeCodexMcpToolState(rawStatus, resultPayload, rawError) { + const status = typeof rawStatus === "string" ? rawStatus : ""; + const error48 = typeof rawError === "string" ? rawError : ""; + const resultText = extractCodexMcpResultText(resultPayload); + const isTerminalStatus = status === "completed" || status === "failed" || status === "error" || status === "cancelled"; + const isTerminal2 = isTerminalStatus || Boolean(error48) || Boolean(resultText); + const isError = Boolean(error48) || status === "failed" || status === "error" || status === "cancelled"; + let result = error48 || resultText; + if (!result && isTerminalStatus) { + result = status === "completed" ? "Completed" : "Failed"; + } + return { + isTerminal: isTerminal2, + isError, + status: isTerminal2 ? isError ? "error" : "completed" : "running", + ...result ? { result } : {} + }; +} +function extractCodexMcpResultText(resultPayload) { + if (!resultPayload || typeof resultPayload !== "object") return ""; + const content = resultPayload.content; + if (!Array.isArray(content)) return ""; + return content.map((item) => typeof (item == null ? void 0 : item.text) === "string" ? item.text : "").filter(Boolean).join("\n"); +} +var TERMINAL_RESULT_TOOLS = /* @__PURE__ */ new Set([ + "Bash", + "write_stdin" +]); +function normalizeCodexToolResult(normalizedName, rawResult) { + if (!rawResult) return rawResult; + if (!TERMINAL_RESULT_TOOLS.has(normalizedName)) return rawResult; + return unwrapTerminalResult(rawResult); +} +function unwrapTerminalResult(raw) { + let result = raw; + const trimmed = result.trim(); + if (trimmed.startsWith("{")) { + try { + const parsed = JSON.parse(trimmed); + if (typeof parsed.output === "string") { + result = parsed.output; + } + } catch (e3) { + } + } + const outputMarker = "Output:\n"; + const markerIndex = result.indexOf(outputMarker); + if (markerIndex >= 0) { + result = result.slice(markerIndex + outputMarker.length); + } + return result; +} +function isCodexToolOutputError(output) { + const exitCodeMatch = output.match(/(?:Exit code:|Process exited with code)\s*(\d+)/i); + if (exitCodeMatch) { + return Number(exitCodeMatch[1]) !== 0; + } + const trimmed = output.trim(); + if (/^[Ee]rror:/.test(trimmed)) return true; + if (trimmed.startsWith("{")) { + try { + const parsed = JSON.parse(trimmed); + if ("error" in parsed) return true; + } catch (e3) { + } + } + return false; +} +function parseCodexArguments(raw) { + if (!raw) return {}; + try { + const parsed = JSON.parse(raw); + if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) { + return parsed; + } + return { value: parsed }; + } catch (e3) { + return { raw }; + } +} + +// src/providers/codex/history/CodexHistoryStore.ts +function newBubble(timestamp) { + return { + contentChunks: [], + thinkingChunks: [], + toolCalls: [], + toolIndexesById: /* @__PURE__ */ new Map(), + contentBlocks: [], + startedAt: timestamp, + lastEventAt: timestamp, + interrupted: false + }; +} +function newTurnState(id, timestamp) { + return { + id, + startedAt: timestamp, + lastEventAt: timestamp, + userChunks: [], + assistantBubbles: [], + activeBubbleIndex: null + }; +} +function createPersistedParseContext() { + return { + turns: /* @__PURE__ */ new Map(), + turnOrder: [], + currentTurnId: null, + toolCallToTurn: /* @__PURE__ */ new Map(), + turnCounter: 0 + }; +} +function ensureTurn(turns, turnOrder, preferredTurnId, currentTurnId, timestamp) { + const id = currentTurnId != null ? currentTurnId : preferredTurnId; + const existing = turns.get(id); + if (existing) { + if (timestamp > 0 && timestamp > existing.lastEventAt) { + existing.lastEventAt = timestamp; + } + return existing; + } + const turn = newTurnState(id, timestamp); + turns.set(id, turn); + turnOrder.push(id); + return turn; +} +function ensureAssistantBubble(turn, timestamp) { + if (turn.activeBubbleIndex !== null) { + const bubble2 = turn.assistantBubbles[turn.activeBubbleIndex]; + if (timestamp > 0 && timestamp > bubble2.lastEventAt) { + bubble2.lastEventAt = timestamp; + } + return bubble2; + } + const bubble = newBubble(timestamp); + turn.assistantBubbles.push(bubble); + turn.activeBubbleIndex = turn.assistantBubbles.length - 1; + return bubble; +} +function closeAssistantBubble(turn) { + turn.activeBubbleIndex = null; +} +function pushToolInvocation(bubble, toolCall) { + const existingIndex = bubble.toolIndexesById.get(toolCall.id); + if (existingIndex !== void 0) { + bubble.toolCalls[existingIndex] = toolCall; + return; + } + bubble.toolIndexesById.set(toolCall.id, bubble.toolCalls.length); + bubble.toolCalls.push(toolCall); + bubble.contentBlocks.push({ type: "tool_use", toolId: toolCall.id }); +} +function appendUniqueChunk(chunks, value) { + const trimmed = value.trim(); + if (!trimmed) return; + if (chunks[chunks.length - 1] === trimmed) return; + chunks.push(trimmed); +} +function replaceLatestChunk(chunks, value) { + const trimmed = value.trim(); + if (!trimmed) return; + chunks.length = 0; + chunks.push(trimmed); +} +function appendUserChunk(turn, value, timestamp) { + const chunkCountBefore = turn.userChunks.length; + appendUniqueChunk(turn.userChunks, value); + if (turn.userChunks.length > chunkCountBefore && !turn.userTimestamp && timestamp > 0) { + turn.userTimestamp = timestamp; + } +} +function newTurn(timestamp = 0) { + return { + assistantText: "", + thinkingText: "", + toolCalls: [], + contentBlocks: [], + interrupted: false, + timestamp + }; +} +function flushTurn(turn, messages, msgIndex) { + if (!turn.assistantText && !turn.thinkingText && turn.toolCalls.length === 0) { + return msgIndex; + } + const msg = { + id: `codex-msg-${msgIndex}`, + role: "assistant", + content: turn.assistantText, + timestamp: turn.timestamp || Date.now(), + toolCalls: turn.toolCalls.length > 0 ? turn.toolCalls : void 0, + contentBlocks: turn.contentBlocks.length > 0 ? turn.contentBlocks : void 0 + }; + if (turn.interrupted) { + msg.isInterrupt = true; + } + messages.push(msg); + return msgIndex + 1; +} +function setTextBlock(turn, content) { + const index = turn.contentBlocks.findIndex((block) => block.type === "text"); + if (index === -1) { + turn.contentBlocks.push({ type: "text", content }); + return; + } + turn.contentBlocks[index] = { type: "text", content }; +} +function setThinkingBlock(turn, content) { + const normalized = content.trim(); + if (!normalized) { + return; + } + turn.thinkingText = normalized; + const index = turn.contentBlocks.findIndex((block) => block.type === "thinking"); + if (index === -1) { + turn.contentBlocks.push({ type: "thinking", content: normalized }); + return; + } + turn.contentBlocks[index] = { type: "thinking", content: normalized }; +} +function parseTimestamp(value) { + if (typeof value !== "string") { + return 0; + } + const parsed = Date.parse(value); + return Number.isFinite(parsed) ? parsed : 0; +} +function parseSessionRecord(line) { + let parsed; + try { + parsed = JSON.parse(line); + } catch (e3) { + return null; + } + return { + timestamp: parseTimestamp(parsed.timestamp), + type: parsed.type, + event: parsed.event, + payload: parsed.payload + }; +} +var CODEX_SYSTEM_MESSAGE_PREFIXES = [ + "# AGENTS.md instructions", + "", + "", + "" +]; +var CODEX_BRACKET_CONTEXT_PATTERN = /\n\[(?:Current note|Editor selection from|Browser selection from|Canvas selection from)\b/; +function isCodexSystemMessage(text) { + const trimmed = text.trimStart(); + return CODEX_SYSTEM_MESSAGE_PREFIXES.some((prefix) => trimmed.startsWith(prefix)); +} +function extractCodexDisplayContent(text) { + if (!text) return void 0; + const bracketMatch = text.match(CODEX_BRACKET_CONTEXT_PATTERN); + if ((bracketMatch == null ? void 0 : bracketMatch.index) !== void 0) { + return text.substring(0, bracketMatch.index).trim(); + } + return void 0; +} +function extractMessageText(content) { + if (!Array.isArray(content)) { + return ""; + } + return content.map((part) => typeof (part == null ? void 0 : part.text) === "string" ? part.text : "").join(""); +} +function joinTextParts(parts) { + return parts.map((part) => { + if (typeof part === "string") return part; + return typeof (part == null ? void 0 : part.text) === "string" ? part.text : ""; + }).map((part) => part.trim()).filter(Boolean).join("\n\n").trim(); +} +function extractReasoningText(payload) { + if ("summary" in payload && Array.isArray(payload.summary) && payload.summary.length > 0) { + return joinTextParts(payload.summary); + } + if ("content" in payload && Array.isArray(payload.content) && payload.content.length > 0) { + return joinTextParts(payload.content); + } + return typeof payload.text === "string" ? payload.text.trim() : ""; +} +function processLegacyItem(eventType, item, turn) { + var _a3, _b2, _c, _d, _e, _f; + switch (item.type) { + case "agent_message": + if (eventType === "item.completed" || eventType === "item.updated") { + if (item.text) { + turn.assistantText = item.text; + setTextBlock(turn, item.text); + } + } + break; + case "reasoning": + if (eventType === "item.completed" || eventType === "item.updated") { + if (item.text) { + setThinkingBlock(turn, item.text); + } + } + break; + case "command_execution": + if (eventType === "item.started") { + turn.toolCalls.push({ + id: item.id, + name: normalizeCodexToolName(item.type), + input: normalizeCodexToolInput(item.type, { command: (_a3 = item.command) != null ? _a3 : "" }), + status: "running" + }); + turn.contentBlocks.push({ type: "tool_use", toolId: item.id }); + } else if (eventType === "item.completed") { + const tc = turn.toolCalls.find((tool) => tool.id === item.id); + if (tc) { + const rawOutput = (_b2 = item.aggregated_output) != null ? _b2 : ""; + tc.result = normalizeCodexToolResult(tc.name, rawOutput); + tc.status = item.exit_code === 0 ? "completed" : "error"; + } + } + break; + case "file_change": { + const changes = (_c = item.changes) != null ? _c : []; + if (eventType === "item.started" || eventType === "item.completed") { + const existing = turn.toolCalls.find((tool) => tool.id === item.id); + if (!existing) { + const paths = changes.map((change) => `${change.kind}: ${change.path}`).join(", "); + turn.toolCalls.push({ + id: item.id, + name: normalizeCodexToolName("file_change"), + input: { changes }, + status: item.status === "completed" ? "completed" : "error", + result: paths ? `Applied: ${paths}` : "Applied" + }); + turn.contentBlocks.push({ type: "tool_use", toolId: item.id }); + } else if (eventType === "item.completed") { + existing.status = item.status === "completed" ? "completed" : "error"; + } + } + break; + } + case "web_search": + if (eventType === "item.started") { + turn.toolCalls.push({ + id: item.id, + name: normalizeCodexToolName(item.type), + input: normalizeCodexToolInput(item.type, { query: (_d = item.query) != null ? _d : "" }), + status: "running" + }); + turn.contentBlocks.push({ type: "tool_use", toolId: item.id }); + } else if (eventType === "item.completed") { + const tc = turn.toolCalls.find((tool) => tool.id === item.id); + if (tc) { + tc.result = "Search complete"; + tc.status = "completed"; + } + } + break; + case "mcp_tool_call": + if (eventType === "item.started") { + const server = (_e = item.server) != null ? _e : ""; + const tool = (_f = item.tool) != null ? _f : ""; + turn.toolCalls.push({ + id: item.id, + name: `mcp__${server}__${tool}`, + input: {}, + status: "running" + }); + turn.contentBlocks.push({ type: "tool_use", toolId: item.id }); + } else if (eventType === "item.completed") { + const tc = turn.toolCalls.find((tool) => tool.id === item.id); + if (tc) { + tc.status = item.status === "completed" ? "completed" : "error"; + tc.result = item.status === "completed" ? "Completed" : "Failed"; + } + } + break; + default: + break; + } +} +function nextTurnId(ctx) { + ctx.turnCounter += 1; + return `turn-${ctx.turnCounter}`; +} +function processPersistedToolCall(payload, timestamp, ctx) { + var _a3; + const callId = payload.call_id; + if (!callId) return; + const turn = ensureTurn(ctx.turns, ctx.turnOrder, nextTurnId(ctx), ctx.currentTurnId, timestamp); + const bubble = ensureAssistantBubble(turn, timestamp); + const rawArgs = (_a3 = payload.arguments) != null ? _a3 : payload.input; + const parsedArgs = parseCodexArguments(rawArgs); + const normalizedName = normalizeCodexToolName(payload.name); + const normalizedInput = normalizeCodexToolInput(payload.name, parsedArgs); + const toolCall = { + id: callId, + name: normalizedName, + input: normalizedInput, + status: "running" + }; + pushToolInvocation(bubble, toolCall); + ctx.toolCallToTurn.set(callId, { + turnId: turn.id, + bubbleIndex: turn.activeBubbleIndex + }); +} +function processPersistedToolOutput(payload, timestamp, ctx) { + const callId = payload.call_id; + if (!callId) return; + const rawOutput = typeof payload.output === "string" ? payload.output : Array.isArray(payload.output) ? JSON.stringify(payload.output) : ""; + const origin = ctx.toolCallToTurn.get(callId); + if (origin) { + const originTurn = ctx.turns.get(origin.turnId); + if (originTurn && origin.bubbleIndex < originTurn.assistantBubbles.length) { + const originBubble = originTurn.assistantBubbles[origin.bubbleIndex]; + const existing = originBubble.toolCalls.find((tool) => tool.id === callId); + if (existing) { + existing.result = normalizePersistedToolOutput(existing, payload.output, rawOutput); + existing.status = isCodexToolOutputError(rawOutput) ? "error" : "completed"; + return; + } + } + } + const turn = ensureTurn(ctx.turns, ctx.turnOrder, nextTurnId(ctx), ctx.currentTurnId, timestamp); + const bubble = ensureAssistantBubble(turn, timestamp); + const normalizedResult = normalizeCodexToolResult("tool", rawOutput); + pushToolInvocation(bubble, { + id: callId, + name: "tool", + input: {}, + status: isCodexToolOutputError(rawOutput) ? "error" : "completed", + result: normalizedResult + }); +} +function normalizePersistedToolOutput(toolCall, rawOutputValue, rawOutputText) { + if (Array.isArray(rawOutputValue) && toolCall.name === "Read") { + const filePath = toolCall.input.file_path; + if (typeof filePath === "string" && filePath) { + return filePath; + } + } + return normalizeCodexToolResult(toolCall.name, rawOutputText); +} +function processPersistedWebSearchCall(payload, timestamp, lineIndex, ctx) { + var _a3; + const turn = ensureTurn(ctx.turns, ctx.turnOrder, nextTurnId(ctx), ctx.currentTurnId, timestamp); + const bubble = ensureAssistantBubble(turn, timestamp); + const callId = payload.call_id || `tail-ws-${lineIndex}`; + if (bubble.toolIndexesById.has(callId)) return; + const input = normalizeCodexToolInput("web_search_call", { + action: (_a3 = payload.action) != null ? _a3 : {} + }); + const isTerminal2 = payload.status === "completed" || payload.status === "failed" || payload.status === "error" || payload.status === "cancelled"; + const toolCall = { + id: callId, + name: "WebSearch", + input, + status: isTerminal2 ? payload.status === "completed" ? "completed" : "error" : "running", + ...isTerminal2 ? { result: "Search complete" } : {} + }; + pushToolInvocation(bubble, toolCall); + ctx.toolCallToTurn.set(callId, { + turnId: turn.id, + bubbleIndex: turn.assistantBubbles.indexOf(bubble) + }); +} +function processPersistedMcpToolCall(payload, timestamp, ctx) { + const callId = payload.call_id; + if (!callId) return; + const turn = ensureTurn(ctx.turns, ctx.turnOrder, nextTurnId(ctx), ctx.currentTurnId, timestamp); + const bubble = ensureAssistantBubble(turn, timestamp); + if (bubble.toolIndexesById.has(callId)) return; + const normalizedInput = normalizeCodexMcpToolInput(payload.arguments); + const normalizedState = normalizeCodexMcpToolState(payload.status, payload.result, payload.error); + const toolCall = { + id: callId, + name: normalizeCodexMcpToolName(payload.server, payload.tool), + input: normalizedInput, + status: normalizedState.status, + ...normalizedState.result ? { result: normalizedState.result } : {} + }; + pushToolInvocation(bubble, toolCall); + ctx.toolCallToTurn.set(callId, { + turnId: turn.id, + bubbleIndex: turn.activeBubbleIndex + }); +} +function processPersistedPayload(payload, timestamp, lineIndex, ctx) { + if (!(payload == null ? void 0 : payload.type)) { + return; + } + switch (payload.type) { + case "message": { + const messagePayload = payload; + const text = extractMessageText(messagePayload.content); + if (messagePayload.role === "user") { + if (isCodexSystemMessage(text)) break; + if (ctx.currentTurnId) { + const prevTurn = ctx.turns.get(ctx.currentTurnId); + if (prevTurn) closeAssistantBubble(prevTurn); + } + ctx.currentTurnId = null; + const turn = ensureTurn(ctx.turns, ctx.turnOrder, nextTurnId(ctx), null, timestamp); + ctx.currentTurnId = turn.id; + if (text) { + appendUserChunk(turn, text, timestamp); + } + } else if (messagePayload.role === "assistant") { + const turn = ensureTurn(ctx.turns, ctx.turnOrder, nextTurnId(ctx), ctx.currentTurnId, timestamp); + const bubble = ensureAssistantBubble(turn, timestamp); + if (text) { + appendUniqueChunk(bubble.contentChunks, text); + } + } + break; + } + case "reasoning": { + const reasoningPayload = payload; + const text = extractReasoningText(reasoningPayload); + if (!text) break; + const turn = ensureTurn(ctx.turns, ctx.turnOrder, nextTurnId(ctx), ctx.currentTurnId, timestamp); + const bubble = ensureAssistantBubble(turn, timestamp); + appendUniqueChunk(bubble.thinkingChunks, text); + break; + } + case "function_call": + case "custom_tool_call": + processPersistedToolCall(payload, timestamp, ctx); + break; + case "function_call_output": + case "custom_tool_call_output": + processPersistedToolOutput(payload, timestamp, ctx); + break; + case "web_search_call": + processPersistedWebSearchCall(payload, timestamp, lineIndex, ctx); + break; + case "mcp_tool_call": + processPersistedMcpToolCall(payload, timestamp, ctx); + break; + case "compaction": + break; + default: + break; + } +} +function applyCompactedReplacementHistory(payload, timestamp, ctx) { + ctx.turns.clear(); + ctx.turnOrder.length = 0; + ctx.currentTurnId = null; + ctx.toolCallToTurn.clear(); + ctx.turnCounter = 0; + const replacementHistory = Array.isArray(payload == null ? void 0 : payload.replacement_history) ? payload.replacement_history : []; + for (const [index, item] of replacementHistory.entries()) { + processPersistedPayload(item, timestamp + index, index, ctx); + } + if (ctx.currentTurnId) { + const turn = ctx.turns.get(ctx.currentTurnId); + if (turn) { + closeAssistantBubble(turn); + } + ctx.currentTurnId = null; + } +} +function extractServerTurnId(payload) { + const turnId = payload.turn_id; + return typeof turnId === "string" ? turnId : void 0; +} +function processEventMsg(payload, timestamp, ctx) { + if (!(payload == null ? void 0 : payload.type)) return; + switch (payload.type) { + case "task_started": { + const serverTurnId = extractServerTurnId(payload); + const id = nextTurnId(ctx); + const turn = ensureTurn(ctx.turns, ctx.turnOrder, id, null, timestamp); + turn.startedAt = timestamp; + if (serverTurnId) turn.serverTurnId = serverTurnId; + ctx.currentTurnId = turn.id; + break; + } + case "task_complete": { + if (ctx.currentTurnId) { + const turn = ctx.turns.get(ctx.currentTurnId); + if (turn) { + turn.completedAt = timestamp; + turn.completed = true; + closeAssistantBubble(turn); + const serverTurnId = extractServerTurnId(payload); + if (serverTurnId && !turn.serverTurnId) turn.serverTurnId = serverTurnId; + } + } + ctx.currentTurnId = null; + break; + } + case "turn_aborted": { + if (ctx.currentTurnId) { + const turn = ctx.turns.get(ctx.currentTurnId); + if (turn) { + const bubble = ensureAssistantBubble(turn, timestamp); + bubble.interrupted = true; + closeAssistantBubble(turn); + turn.completedAt = timestamp; + } + } + ctx.currentTurnId = null; + break; + } + case "user_message": { + const turn = ensureTurn(ctx.turns, ctx.turnOrder, nextTurnId(ctx), ctx.currentTurnId, timestamp); + const msg = payload.message; + if (typeof msg === "string" && msg.trim()) { + appendUserChunk(turn, msg, timestamp); + } + break; + } + case "agent_message": { + const turn = ensureTurn(ctx.turns, ctx.turnOrder, nextTurnId(ctx), ctx.currentTurnId, timestamp); + const bubble = ensureAssistantBubble(turn, timestamp); + const msg = payload.message; + if (typeof msg === "string") { + appendUniqueChunk(bubble.contentChunks, msg); + } + break; + } + case "agent_reasoning": { + const text = extractReasoningText(payload); + if (!text) break; + const turn = ensureTurn(ctx.turns, ctx.turnOrder, nextTurnId(ctx), ctx.currentTurnId, timestamp); + const bubble = ensureAssistantBubble(turn, timestamp); + appendUniqueChunk(bubble.thinkingChunks, text); + break; + } + case "context_compacted": { + if (ctx.currentTurnId) { + const prevTurn = ctx.turns.get(ctx.currentTurnId); + if (prevTurn) closeAssistantBubble(prevTurn); + } + const id = nextTurnId(ctx); + const turn = ensureTurn(ctx.turns, ctx.turnOrder, id, null, timestamp); + const bubble = ensureAssistantBubble(turn, timestamp); + bubble.contentBlocks.push({ type: "context_compacted" }); + closeAssistantBubble(turn); + ctx.currentTurnId = null; + break; + } + default: + break; + } +} +function flushBubbleTurnMessages(turn, msgIndex) { + const messages = []; + const userText = turn.userChunks.join("\n").trim(); + if (userText && !isCodexSystemMessage(userText)) { + const displayContent = extractCodexDisplayContent(userText); + messages.push({ + id: `codex-msg-${msgIndex}`, + role: "user", + content: userText, + ...displayContent !== void 0 ? { displayContent } : {}, + ...turn.serverTurnId ? { userMessageId: turn.serverTurnId } : {}, + timestamp: turn.userTimestamp || turn.startedAt || Date.now() + }); + msgIndex += 1; + } + let lastAssistantTimestamp = 0; + const assistantMessages = []; + for (const bubble of turn.assistantBubbles) { + const contentText = bubble.contentChunks.join("\n\n"); + const thinkingText = bubble.thinkingChunks.join("\n\n"); + const hasContent = contentText.trim().length > 0; + const hasThinking = thinkingText.trim().length > 0; + const hasToolCalls = bubble.toolCalls.length > 0; + const hasCompactBoundary = bubble.contentBlocks.some((b) => b.type === "context_compacted"); + if (!hasContent && !hasThinking && !hasToolCalls && !hasCompactBoundary) { + if (bubble.interrupted) { + messages.push({ + id: `codex-msg-${msgIndex}`, + role: "assistant", + content: "", + timestamp: bubble.startedAt || turn.startedAt || Date.now(), + isInterrupt: true + }); + msgIndex += 1; + } + continue; + } + const contentBlocks = []; + if (hasThinking) { + contentBlocks.push({ type: "thinking", content: thinkingText.trim() }); + } + contentBlocks.push(...bubble.contentBlocks); + if (hasContent) { + contentBlocks.push({ type: "text", content: contentText.trim() }); + } + const msg = { + id: `codex-msg-${msgIndex}`, + role: "assistant", + content: contentText.trim(), + timestamp: bubble.startedAt || turn.startedAt || Date.now(), + toolCalls: hasToolCalls ? bubble.toolCalls : void 0, + contentBlocks: contentBlocks.length > 0 ? contentBlocks : void 0 + }; + if (bubble.interrupted) { + msg.isInterrupt = true; + } + if (bubble.lastEventAt > lastAssistantTimestamp) { + lastAssistantTimestamp = bubble.lastEventAt; + } + assistantMessages.push(msg); + messages.push(msg); + msgIndex += 1; + } + if (assistantMessages.length > 0 && turn.userTimestamp && lastAssistantTimestamp > turn.userTimestamp) { + const durationMs = lastAssistantTimestamp - turn.userTimestamp; + const lastMsg = assistantMessages[assistantMessages.length - 1]; + lastMsg.durationSeconds = Math.round(durationMs / 1e3); + } + if (turn.serverTurnId && turn.completed && assistantMessages.length > 0) { + const lastNonInterrupt = [...assistantMessages].reverse().find((m3) => !m3.isInterrupt); + if (lastNonInterrupt) { + lastNonInterrupt.assistantMessageId = turn.serverTurnId; + } + } + return { messages, nextMsgIndex: msgIndex }; +} +var SAFE_SESSION_ID_PATTERN = /^[A-Za-z0-9_-]+$/; +function findCodexSessionFile(threadId, root = path14.join(os9.homedir(), ".codex", "sessions")) { + if (!threadId || !SAFE_SESSION_ID_PATTERN.test(threadId) || !fs14.existsSync(root)) { + return null; + } + const directPath = path14.join(root, `${threadId}.jsonl`); + if (fs14.existsSync(directPath)) { + return directPath; + } + const stack = [root]; + while (stack.length > 0) { + const current = stack.pop(); + if (!current) { + continue; + } + let entries; + try { + entries = fs14.readdirSync(current, { withFileTypes: true }); + } catch (e3) { + continue; + } + for (const entry of entries) { + const fullPath = path14.join(current, entry.name); + if (entry.isDirectory()) { + stack.push(fullPath); + continue; + } + if (entry.isFile() && entry.name.endsWith(`-${threadId}.jsonl`)) { + return fullPath; + } + } + } + return null; +} +function parseCodexSessionFile(filePath) { + let content; + try { + content = fs14.readFileSync(filePath, "utf-8"); + } catch (e3) { + return []; + } + return parseCodexSessionContent(content); +} +function parseCodexSessionContent(content) { + const turns = parseCodexSessionTurns(content); + return turns.flatMap((t3) => t3.messages); +} +function parseCodexSessionTurns(content) { + const records = content.split("\n").filter((line) => line.trim()).map(parseSessionRecord).filter((record2) => record2 !== null); + let hasLegacy = false; + let hasModern = false; + for (const record2 of records) { + if (record2.type === "event") hasLegacy = true; + else if (record2.type === "event_msg" || record2.type === "response_item" || record2.type === "compacted") hasModern = true; + if (hasLegacy && hasModern) break; + } + if (hasLegacy && !hasModern) { + const messages = parseLegacySession(records); + return messages.length > 0 ? [{ turnId: null, messages }] : []; + } + return parseModernSessionTurns(records); +} +function parseLegacySession(records) { + const messages = []; + let turn = newTurn(); + let msgIndex = 0; + for (const parsed of records) { + if (parsed.type === "event" && parsed.event) { + const event = parsed.event; + switch (event.type) { + case "turn.started": + if (turn.assistantText || turn.thinkingText || turn.toolCalls.length > 0) { + msgIndex = flushTurn(turn, messages, msgIndex); + } + turn = newTurn(); + break; + case "item.started": + case "item.updated": + case "item.completed": + if (event.item) { + processLegacyItem(event.type, event.item, turn); + } + break; + case "turn.completed": + msgIndex = flushTurn(turn, messages, msgIndex); + turn = newTurn(); + break; + case "turn.failed": + turn.interrupted = true; + msgIndex = flushTurn(turn, messages, msgIndex); + turn = newTurn(); + break; + default: + break; + } + } + } + flushTurn(turn, messages, msgIndex); + return messages; +} +function parseModernSessionTurns(records) { + const ctx = createPersistedParseContext(); + for (const [lineIndex, parsed] of records.entries()) { + const timestamp = parsed.timestamp; + if (parsed.type === "event" && parsed.event) { + processLegacyEventInModernContext(parsed.event, timestamp, ctx); + continue; + } + if (parsed.type === "event_msg") { + processEventMsg(parsed.payload, timestamp, ctx); + continue; + } + if (parsed.type === "compacted") { + applyCompactedReplacementHistory(parsed.payload, timestamp, ctx); + continue; + } + if (parsed.type === "response_item") { + processPersistedPayload(parsed.payload, timestamp, lineIndex, ctx); + } + } + return flushBubbleTurnsGrouped(ctx.turns, ctx.turnOrder); +} +function flushBubbleTurnsGrouped(turns, turnOrder) { + var _a3; + const result = []; + let messageOffset = 0; + for (const turnId of turnOrder) { + const turn = turns.get(turnId); + if (!turn) continue; + const { messages: turnMessages, nextMsgIndex } = flushBubbleTurnMessages(turn, messageOffset); + if (turnMessages.length === 0) continue; + messageOffset = nextMsgIndex; + result.push({ + turnId: (_a3 = turn.serverTurnId) != null ? _a3 : null, + messages: turnMessages + }); + } + return result; +} +function findToolCallOrigin(ctx, callId) { + var _a3; + const origin = ctx.toolCallToTurn.get(callId); + if (!origin) { + return null; + } + const turn = ctx.turns.get(origin.turnId); + if (!turn || origin.bubbleIndex >= turn.assistantBubbles.length) { + return null; + } + return (_a3 = turn.assistantBubbles[origin.bubbleIndex].toolCalls.find((tool) => tool.id === callId)) != null ? _a3 : null; +} +function trackToolCallOrigin(ctx, callId, turn) { + ctx.toolCallToTurn.set(callId, { + turnId: turn.id, + bubbleIndex: turn.activeBubbleIndex + }); +} +function ensureModernLegacyToolCall(ctx, timestamp, item, build) { + const existing = findToolCallOrigin(ctx, item.id); + if (existing) { + return existing; + } + const turn = ensureTurn(ctx.turns, ctx.turnOrder, nextTurnId(ctx), ctx.currentTurnId, timestamp); + const bubble = ensureAssistantBubble(turn, timestamp); + const toolCall = build(); + pushToolInvocation(bubble, toolCall); + trackToolCallOrigin(ctx, item.id, turn); + return toolCall; +} +function processLegacyItemInModernContext(eventType, item, timestamp, ctx) { + var _a3, _b2; + switch (item.type) { + case "agent_message": { + if ((eventType === "item.updated" || eventType === "item.completed") && item.text) { + const turn = ensureTurn(ctx.turns, ctx.turnOrder, nextTurnId(ctx), ctx.currentTurnId, timestamp); + const bubble = ensureAssistantBubble(turn, timestamp); + replaceLatestChunk(bubble.contentChunks, item.text); + } + break; + } + case "reasoning": { + if ((eventType === "item.updated" || eventType === "item.completed") && item.text) { + const turn = ensureTurn(ctx.turns, ctx.turnOrder, nextTurnId(ctx), ctx.currentTurnId, timestamp); + const bubble = ensureAssistantBubble(turn, timestamp); + replaceLatestChunk(bubble.thinkingChunks, item.text); + } + break; + } + case "command_execution": { + if (eventType === "item.started") { + ensureModernLegacyToolCall(ctx, timestamp, item, () => { + var _a4; + return { + id: item.id, + name: normalizeCodexToolName(item.type), + input: normalizeCodexToolInput(item.type, { command: (_a4 = item.command) != null ? _a4 : "" }), + status: "running" + }; + }); + break; + } + if (eventType === "item.completed") { + const toolCall = ensureModernLegacyToolCall(ctx, timestamp, item, () => { + var _a4; + return { + id: item.id, + name: normalizeCodexToolName(item.type), + input: normalizeCodexToolInput(item.type, { command: (_a4 = item.command) != null ? _a4 : "" }), + status: "running" + }; + }); + const rawOutput = (_a3 = item.aggregated_output) != null ? _a3 : ""; + toolCall.result = normalizeCodexToolResult(toolCall.name, rawOutput); + toolCall.status = item.exit_code === 0 ? "completed" : "error"; + } + break; + } + case "file_change": { + if (eventType !== "item.started" && eventType !== "item.completed") { + break; + } + const changes = (_b2 = item.changes) != null ? _b2 : []; + const toolCall = ensureModernLegacyToolCall(ctx, timestamp, item, () => ({ + id: item.id, + name: normalizeCodexToolName("file_change"), + input: { changes }, + status: "running" + })); + if (eventType === "item.completed") { + const paths = changes.map((change) => `${change.kind}: ${change.path}`).join(", "); + toolCall.result = paths ? `Applied: ${paths}` : "Applied"; + toolCall.status = item.status === "completed" ? "completed" : "error"; + } + break; + } + case "web_search": { + if (eventType === "item.started") { + ensureModernLegacyToolCall(ctx, timestamp, item, () => { + var _a4; + return { + id: item.id, + name: normalizeCodexToolName(item.type), + input: normalizeCodexToolInput(item.type, { query: (_a4 = item.query) != null ? _a4 : "" }), + status: "running" + }; + }); + break; + } + if (eventType === "item.completed") { + const toolCall = ensureModernLegacyToolCall(ctx, timestamp, item, () => { + var _a4; + return { + id: item.id, + name: normalizeCodexToolName(item.type), + input: normalizeCodexToolInput(item.type, { query: (_a4 = item.query) != null ? _a4 : "" }), + status: "running" + }; + }); + toolCall.result = "Search complete"; + toolCall.status = "completed"; + } + break; + } + case "mcp_tool_call": { + if (eventType === "item.started") { + ensureModernLegacyToolCall(ctx, timestamp, item, () => { + var _a4, _b3; + return { + id: item.id, + name: `mcp__${(_a4 = item.server) != null ? _a4 : ""}__${(_b3 = item.tool) != null ? _b3 : ""}`, + input: {}, + status: "running" + }; + }); + break; + } + if (eventType === "item.completed") { + const toolCall = ensureModernLegacyToolCall(ctx, timestamp, item, () => { + var _a4, _b3; + return { + id: item.id, + name: `mcp__${(_a4 = item.server) != null ? _a4 : ""}__${(_b3 = item.tool) != null ? _b3 : ""}`, + input: {}, + status: "running" + }; + }); + toolCall.status = item.status === "completed" ? "completed" : "error"; + toolCall.result = item.status === "completed" ? "Completed" : "Failed"; + } + break; + } + default: + break; + } +} +function processLegacyEventInModernContext(event, timestamp, ctx) { + switch (event.type) { + case "turn.started": { + if (ctx.currentTurnId) { + const previousTurn = ctx.turns.get(ctx.currentTurnId); + if (previousTurn) { + closeAssistantBubble(previousTurn); + } + } + const id = nextTurnId(ctx); + ensureTurn(ctx.turns, ctx.turnOrder, id, null, timestamp); + ctx.currentTurnId = id; + break; + } + case "turn.completed": { + if (ctx.currentTurnId) { + const turn = ctx.turns.get(ctx.currentTurnId); + if (turn) closeAssistantBubble(turn); + } + ctx.currentTurnId = null; + break; + } + case "turn.failed": { + if (ctx.currentTurnId) { + const turn = ctx.turns.get(ctx.currentTurnId); + if (turn) { + const bubble = ensureAssistantBubble(turn, timestamp); + bubble.interrupted = true; + closeAssistantBubble(turn); + } + } + ctx.currentTurnId = null; + break; + } + case "item.started": + case "item.updated": + case "item.completed": + if (event.item) { + processLegacyItemInModernContext(event.type, event.item, timestamp, ctx); + } + break; + default: + break; + } +} + +// src/providers/codex/history/CodexConversationHistoryService.ts +function readSessionTurns(sessionFilePath) { + let content; + try { + content = require("fs").readFileSync(sessionFilePath, "utf-8"); + } catch (e3) { + return []; + } + return parseCodexSessionTurns(content); +} +var CodexConversationHistoryService = class { + constructor() { + this.hydratedConversationPaths = /* @__PURE__ */ new Map(); + } + async hydrateConversationHistory(conversation, _vaultPath) { + var _a3, _b2, _c, _d, _e; + const state = getCodexState(conversation.providerState); + if (this.isPendingForkConversation(conversation) && conversation.messages.length > 0) { + return; + } + if (this.isPendingForkConversation(conversation)) { + const sourceSessionFile = this.resolveSourceSessionFile(state); + if (!sourceSessionFile) return; + const turns = readSessionTurns(sourceSessionFile); + const resumeAt = state.forkSource.resumeAt; + const truncated = this.truncateTurnsAtCheckpoint(turns, resumeAt); + if (!truncated) { + this.hydratedConversationPaths.delete(conversation.id); + return; + } + conversation.messages = truncated.flatMap((t3) => t3.messages); + return; + } + if (state.forkSource && state.threadId) { + const sourceSessionFile = this.resolveSourceSessionFile(state); + const forkSessionFile = (_a3 = state.sessionFilePath) != null ? _a3 : state.threadId ? findCodexSessionFile(state.threadId, state.transcriptRootPath) : null; + if (sourceSessionFile && forkSessionFile) { + const sourceTurns = readSessionTurns(sourceSessionFile); + const forkTurns = readSessionTurns(forkSessionFile); + const resumeAt = state.forkSource.resumeAt; + const sourcePrefix = this.truncateTurnsAtCheckpoint(sourceTurns, resumeAt); + if (!sourcePrefix) { + this.hydratedConversationPaths.delete(conversation.id); + return; + } + const sourceTurnIds = new Set(sourceTurns.map((t3) => t3.turnId).filter(Boolean)); + const forkOnlyTurns = forkTurns.filter((t3) => !t3.turnId || !sourceTurnIds.has(t3.turnId)); + const messages = [ + ...sourcePrefix.flatMap((t3) => t3.messages), + ...forkOnlyTurns.flatMap((t3) => t3.messages) + ]; + if (messages.length === 0) { + this.hydratedConversationPaths.delete(conversation.id); + return; + } + conversation.messages = messages; + this.hydratedConversationPaths.set(conversation.id, `fork::${state.threadId}`); + return; + } + } + const threadId = (_c = (_b2 = state.threadId) != null ? _b2 : conversation.sessionId) != null ? _c : null; + const sessionFilePath = (_d = state.sessionFilePath) != null ? _d : threadId ? findCodexSessionFile(threadId, state.transcriptRootPath) : null; + if (!sessionFilePath) { + this.hydratedConversationPaths.delete(conversation.id); + return; + } + const hydrationKey = `${threadId != null ? threadId : ""}::${sessionFilePath}`; + if (conversation.messages.length > 0 && this.hydratedConversationPaths.get(conversation.id) === hydrationKey) { + return; + } + if (sessionFilePath !== state.sessionFilePath) { + conversation.providerState = { + ...(_e = conversation.providerState) != null ? _e : {}, + ...threadId ? { threadId } : {}, + sessionFilePath + }; + } + const sdkMessages = parseCodexSessionFile(sessionFilePath); + if (sdkMessages.length === 0) { + this.hydratedConversationPaths.delete(conversation.id); + return; + } + conversation.messages = sdkMessages; + this.hydratedConversationPaths.set(conversation.id, hydrationKey); + } + async deleteConversationSession(_conversation, _vaultPath) { + } + resolveSessionIdForConversation(conversation) { + var _a3, _b2, _c, _d; + if (!conversation) return null; + const state = getCodexState(conversation.providerState); + return (_d = (_c = (_a3 = state.threadId) != null ? _a3 : conversation.sessionId) != null ? _c : (_b2 = state.forkSource) == null ? void 0 : _b2.sessionId) != null ? _d : null; + } + isPendingForkConversation(conversation) { + const state = getCodexState(conversation.providerState); + return !!state.forkSource && !state.threadId && !conversation.sessionId; + } + buildForkProviderState(sourceSessionId, resumeAt, sourceProviderState) { + const sourceState = getCodexState(sourceProviderState); + const providerState = { + forkSource: { sessionId: sourceSessionId, resumeAt }, + ...sourceState.sessionFilePath ? { forkSourceSessionFilePath: sourceState.sessionFilePath } : {}, + ...sourceState.transcriptRootPath ? { forkSourceTranscriptRootPath: sourceState.transcriptRootPath } : {} + }; + return providerState; + } + buildPersistedProviderState(conversation) { + const entries = Object.entries(getCodexState(conversation.providerState)).filter(([, value]) => value !== void 0); + return entries.length > 0 ? Object.fromEntries(entries) : void 0; + } + // --------------------------------------------------------------------------- + // Private helpers + // --------------------------------------------------------------------------- + resolveSourceSessionFile(state) { + var _a3; + if (!state.forkSource) return null; + return (_a3 = state.forkSourceSessionFilePath) != null ? _a3 : findCodexSessionFile(state.forkSource.sessionId, state.forkSourceTranscriptRootPath); + } + truncateTurnsAtCheckpoint(turns, resumeAt) { + const checkpointIndex = turns.findIndex((turn) => turn.turnId === resumeAt); + if (checkpointIndex < 0) { + return null; + } + return turns.slice(0, checkpointIndex + 1); + } +}; + +// src/providers/codex/normalization/codexSubagentNormalization.ts +function parseJsonObject(raw) { + if (!raw) return null; + try { + const parsed = JSON.parse(raw); + if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) { + return parsed; + } + } catch (e3) { + return null; + } + return null; +} +function extractCodexSpawnResult(raw) { + const parsed = parseJsonObject(raw); + if (!parsed) return {}; + return { + agentId: typeof parsed.agent_id === "string" ? parsed.agent_id : void 0, + nickname: typeof parsed.nickname === "string" ? parsed.nickname : void 0 + }; +} +function extractCodexWaitResult(raw) { + const parsed = parseJsonObject(raw); + if (!parsed) { + return { statuses: {}, timedOut: false }; + } + const rawStatuses = parsed.status; + const statuses = {}; + if (rawStatuses && typeof rawStatuses === "object" && !Array.isArray(rawStatuses)) { + for (const [agentId, value] of Object.entries(rawStatuses)) { + if (!value || typeof value !== "object" || Array.isArray(value)) continue; + const status = value; + statuses[agentId] = { + completed: typeof status.completed === "string" ? status.completed : void 0, + error: typeof status.error === "string" ? status.error : void 0, + failed: typeof status.failed === "string" ? status.failed : void 0 + }; + } + } + return { + statuses, + timedOut: parsed.timed_out === true + }; +} +function getCodexSubagentPrompt(input) { + return typeof input.message === "string" ? input.message : ""; +} +function getCodexSubagentModel(input) { + return typeof input.model === "string" ? input.model : ""; +} +function getCodexSubagentDescription(nickname, model) { + if (nickname && model) return `${nickname} (${model})`; + if (nickname) return nickname; + if (model) return `Codex subagent (${model})`; + return "Codex subagent"; +} +function resolveCodexWaitCompletion(spawnResult, siblingToolCalls) { + var _a3; + for (const toolCall of siblingToolCalls) { + if (toolCall.name !== TOOL_WAIT && toolCall.name !== TOOL_WAIT_AGENT) { + continue; + } + const waitResult = extractCodexWaitResult(toolCall.result); + const statusEntries = Object.entries(waitResult.statuses); + if (statusEntries.length === 0 && !waitResult.timedOut) { + continue; + } + let agentStatus; + if (spawnResult.agentId) { + agentStatus = waitResult.statuses[spawnResult.agentId]; + } else if (statusEntries.length === 1) { + agentStatus = statusEntries[0][1]; + } + if (agentStatus == null ? void 0 : agentStatus.completed) { + return { status: "completed", result: agentStatus.completed }; + } + const failure = (_a3 = agentStatus == null ? void 0 : agentStatus.error) != null ? _a3 : agentStatus == null ? void 0 : agentStatus.failed; + if (failure) { + return { status: "error", result: failure }; + } + if (waitResult.timedOut) { + return { status: "error", result: "Timed out" }; + } + } + return { status: "running" }; +} +function buildCodexSubagentInfo(spawnToolCall, siblingToolCalls = []) { + const prompt = getCodexSubagentPrompt(spawnToolCall.input); + const model = getCodexSubagentModel(spawnToolCall.input); + const spawnResult = extractCodexSpawnResult(spawnToolCall.result); + const description = getCodexSubagentDescription(spawnResult.nickname, model); + if (spawnToolCall.status === "error") { + return { + id: spawnToolCall.id, + description, + prompt, + mode: "sync", + isExpanded: false, + status: "error", + result: spawnToolCall.result, + toolCalls: [] + }; + } + const completion = resolveCodexWaitCompletion(spawnResult, siblingToolCalls); + return { + id: spawnToolCall.id, + description, + prompt, + mode: "sync", + isExpanded: false, + status: completion.status, + result: completion.result, + toolCalls: [], + ...spawnResult.agentId ? { agentId: spawnResult.agentId } : {} + }; +} +var codexSubagentLifecycleAdapter = { + isHiddenTool(name) { + return name === TOOL_WAIT || name === TOOL_WAIT_AGENT || name === TOOL_CLOSE_AGENT; + }, + isSpawnTool(name) { + return name === TOOL_SPAWN_AGENT; + }, + isWaitTool(name) { + return name === TOOL_WAIT || name === TOOL_WAIT_AGENT; + }, + isCloseTool(name) { + return name === TOOL_CLOSE_AGENT; + }, + resolveSpawnToolIds(waitToolCall, agentIdToSpawnId) { + const spawnIds = /* @__PURE__ */ new Set(); + const waitResult = extractCodexWaitResult(waitToolCall.result); + for (const agentId of Object.keys(waitResult.statuses)) { + const spawnId = agentIdToSpawnId.get(agentId); + if (spawnId) { + spawnIds.add(spawnId); + } + } + const targets = Array.isArray(waitToolCall.input.targets) ? waitToolCall.input.targets : Array.isArray(waitToolCall.input.ids) ? waitToolCall.input.ids : []; + for (const target of targets) { + if (typeof target !== "string") continue; + const spawnId = agentIdToSpawnId.get(target); + if (spawnId) { + spawnIds.add(spawnId); + } + } + return [...spawnIds]; + }, + buildSubagentInfo(spawnToolCall, siblingToolCalls = []) { + return buildCodexSubagentInfo(spawnToolCall, siblingToolCalls); + }, + extractSpawnResult(raw) { + return extractCodexSpawnResult(raw); + }, + extractWaitResult(raw) { + return extractCodexWaitResult(raw); + } +}; + +// src/providers/codex/runtime/CodexChatRuntime.ts +var fs16 = __toESM(require("fs")); +var os10 = __toESM(require("os")); +var path15 = __toESM(require("path")); +init_path(); + +// src/providers/codex/prompt/encodeCodexTurn.ts +function isCompactCommand2(text) { + return /^\/compact(\s|$)/i.test(text); +} +function encodeCodexTurn(request) { + var _a3, _b2, _c; + const isCompact = isCompactCommand2(request.text); + if (isCompact) { + return { + request, + persistedContent: request.text, + prompt: request.text, + isCompact: true, + mcpMentions: /* @__PURE__ */ new Set() + }; + } + const sections = []; + sections.push(request.text); + if (request.currentNotePath) { + sections.push(` +[Current note: ${request.currentNotePath}]`); + } + if ((_a3 = request.editorSelection) == null ? void 0 : _a3.selectedText) { + sections.push( + ` +[Editor selection from ${request.editorSelection.notePath || "current note"}: +${request.editorSelection.selectedText} +]` + ); + } + if ((_b2 = request.browserSelection) == null ? void 0 : _b2.selectedText) { + sections.push( + ` +[Browser selection from ${(_c = request.browserSelection.url) != null ? _c : "unknown page"}: +${request.browserSelection.selectedText} +]` + ); + } + if (request.canvasSelection) { + const nodeList = request.canvasSelection.nodeIds.join(", "); + if (nodeList) { + sections.push( + ` +[Canvas selection from ${request.canvasSelection.canvasPath}: +${nodeList} +]` + ); + } + } + const prompt = sections.join(""); + return { + request, + persistedContent: request.text, + prompt, + isCompact: false, + mcpMentions: /* @__PURE__ */ new Set() + }; +} + +// src/providers/codex/runtime/CodexNotificationRouter.ts +var COLLAB_AGENT_TOOL_MAP = { + spawnAgent: "spawn_agent", + wait: "wait", + sendInput: "send_input", + resumeAgent: "resume_agent", + closeAgent: "close_agent" +}; +var CodexNotificationRouter = class { + constructor(emit, onTurnMetadata) { + this.emit = emit; + this.onTurnMetadata = onTurnMetadata; + this.seenWebSearchIds = /* @__PURE__ */ new Set(); + this.planUpdateCounter = 0; + this.isPlanTurn = false; + this.sawPlanDelta = false; + this.startedUserMessageIds = /* @__PURE__ */ new Set(); + this.startedAgentMessageIds = /* @__PURE__ */ new Set(); + this.agentMessageDeltaIds = /* @__PURE__ */ new Set(); + } + beginTurn(params) { + this.isPlanTurn = params.isPlanTurn; + this.sawPlanDelta = false; + this.startedUserMessageIds.clear(); + this.startedAgentMessageIds.clear(); + this.agentMessageDeltaIds.clear(); + } + endTurn() { + this.isPlanTurn = false; + this.sawPlanDelta = false; + this.startedUserMessageIds.clear(); + this.startedAgentMessageIds.clear(); + this.agentMessageDeltaIds.clear(); + } + handleNotification(method, params) { + switch (method) { + case "item/agentMessage/delta": + this.onAgentMessageDelta(params); + break; + case "item/started": + this.onItemStarted(params); + break; + case "item/completed": + this.onItemCompleted(params); + break; + case "item/reasoning/summaryTextDelta": + this.onReasoningSummaryDelta(params); + break; + case "item/reasoning/textDelta": + this.onReasoningTextDelta(params); + break; + case "item/reasoning/summaryPartAdded": + break; + case "item/plan/delta": + this.onPlanDelta(params); + break; + case "item/commandExecution/outputDelta": + case "item/fileChange/outputDelta": + this.onOutputDelta(params); + break; + case "thread/tokenUsage/updated": + this.onTokenUsageUpdated(params); + break; + case "turn/plan/updated": + this.onPlanUpdated(params); + break; + case "turn/completed": + this.onTurnCompleted(params); + break; + case "error": + this.onError(params); + break; + default: + break; + } + } + onAgentMessageDelta(params) { + this.agentMessageDeltaIds.add(params.itemId); + this.emit({ type: "text", content: params.delta }); + } + onReasoningSummaryDelta(params) { + this.emit({ type: "thinking", content: params.delta }); + } + onReasoningTextDelta(params) { + this.emit({ type: "thinking", content: params.delta }); + } + onPlanDelta(params) { + this.sawPlanDelta = true; + this.emit({ type: "text", content: params.delta }); + } + onItemStarted(params) { + const item = params.item; + switch (item.type) { + case "userMessage": + this.emitUserMessageBoundary(item); + break; + case "agentMessage": + this.emitAgentMessageBoundary(item); + break; + case "reasoning": + break; + case "commandExecution": + this.emitToolUseFromCommand(item); + break; + case "fileChange": + this.emitToolUseFromFileChange(item); + break; + case "imageView": + this.emitToolUseFromImageView(item); + break; + case "webSearch": + this.emitToolUseFromWebSearch(item); + break; + case "collabAgentToolCall": + this.emitToolUseFromCollabAgent(item); + break; + case "mcpToolCall": + this.emitToolUseFromMcp(item); + break; + default: + break; + } + } + onItemCompleted(params) { + const item = params.item; + switch (item.type) { + case "userMessage": + if (!this.startedUserMessageIds.has(item.id)) { + this.emitUserMessageBoundary(item); + } + break; + case "agentMessage": + this.completeAgentMessage(item); + break; + case "commandExecution": + this.emitToolResultFromCommand(item); + break; + case "fileChange": + this.emitToolResultFromFileChange(item); + break; + case "imageView": + this.emitToolResultFromImageView(item); + break; + case "webSearch": + this.emitToolResultFromWebSearch(item); + break; + case "collabAgentToolCall": + this.emitToolResultFromCollabAgent(item); + break; + case "mcpToolCall": + this.emitToolResultFromMcp(item); + break; + case "contextCompaction": + this.emitContextCompactionBoundary(item); + break; + default: + break; + } + } + // -- commandExecution ------------------------------------------------------- + emitToolUseFromCommand(item) { + var _a3, _b2, _c; + const rawAction = (_c = (_b2 = (_a3 = item.commandActions) == null ? void 0 : _a3[0]) == null ? void 0 : _b2.command) != null ? _c : item.command; + const normalizedName = normalizeCodexToolName("command_execution"); + const input = normalizeCodexToolInput("command_execution", { command: rawAction }); + this.emit({ type: "tool_use", id: item.id, name: normalizedName, input }); + } + emitToolResultFromCommand(item) { + var _a3; + const output = (_a3 = item.aggregatedOutput) != null ? _a3 : ""; + const normalizedName = normalizeCodexToolName("command_execution"); + const content = normalizeCodexToolResult(normalizedName, output); + const isError = item.exitCode !== null && item.exitCode !== 0; + this.emit({ type: "tool_result", id: item.id, content, isError }); + } + // -- fileChange ------------------------------------------------------------- + emitToolUseFromFileChange(item) { + var _a3; + this.emit({ + type: "tool_use", + id: item.id, + name: normalizeCodexToolName("file_change"), + input: { changes: (_a3 = item.changes) != null ? _a3 : [] } + }); + } + emitToolResultFromFileChange(item) { + var _a3; + const paths = ((_a3 = item.changes) != null ? _a3 : []).map((c) => c.path).join(", "); + this.emit({ + type: "tool_result", + id: item.id, + content: paths || "File change completed", + isError: false + }); + } + // -- imageView -------------------------------------------------------------- + emitToolUseFromImageView(item) { + this.emit({ + type: "tool_use", + id: item.id, + name: normalizeCodexToolName("view_image"), + input: normalizeCodexToolInput("view_image", { path: item.path }) + }); + } + emitToolResultFromImageView(item) { + this.emit({ type: "tool_result", id: item.id, content: item.path, isError: false }); + } + // -- webSearch -------------------------------------------------------------- + emitToolUseFromWebSearch(item) { + var _a3, _b2, _c, _d, _e; + if (this.seenWebSearchIds.has(item.id)) return; + this.seenWebSearchIds.add(item.id); + this.emit({ + type: "tool_use", + id: item.id, + name: "WebSearch", + input: normalizeCodexToolInput("web_search", { + query: (_a3 = item.query) != null ? _a3 : "", + queries: (_b2 = item.queries) != null ? _b2 : [], + url: (_c = item.url) != null ? _c : "", + pattern: (_d = item.pattern) != null ? _d : "", + action: (_e = item.action) != null ? _e : {} + }) + }); + } + emitToolResultFromWebSearch(item) { + this.emit({ + type: "tool_result", + id: item.id, + content: "Search complete", + isError: item.status === "failed" || item.status === "error" + }); + } + // -- collabAgentToolCall ---------------------------------------------------- + emitToolUseFromCollabAgent(item) { + var _a3, _b2; + const toolName = (_a3 = COLLAB_AGENT_TOOL_MAP[item.tool]) != null ? _a3 : item.tool; + this.emit({ + type: "tool_use", + id: item.id, + name: toolName, + input: (_b2 = item.arguments) != null ? _b2 : {} + }); + } + emitToolResultFromCollabAgent(item) { + var _a3; + const resultText = item.result && typeof item.result === "object" ? JSON.stringify(item.result) : item.status === "completed" ? "Completed" : (_a3 = item.status) != null ? _a3 : "Done"; + this.emit({ + type: "tool_result", + id: item.id, + content: resultText, + isError: item.status === "failed" || item.status === "error" + }); + } + // -- mcpToolCall ------------------------------------------------------------ + emitToolUseFromMcp(item) { + var _a3; + this.emit({ + type: "tool_use", + id: item.id, + name: `mcp__${item.server}__${item.tool}`, + input: (_a3 = item.arguments) != null ? _a3 : {} + }); + } + emitToolResultFromMcp(item) { + var _a3; + let content = ""; + if (item.error) { + content = item.error; + } else if ((_a3 = item.result) == null ? void 0 : _a3.content) { + content = item.result.content.map((c) => { + var _a4; + return (_a4 = c.text) != null ? _a4 : ""; + }).filter(Boolean).join("\n"); + } + if (!content) { + content = item.status === "completed" ? "Completed" : "Failed"; + } + this.emit({ + type: "tool_result", + id: item.id, + content, + isError: item.status === "failed" || item.status === "error" + }); + } + emitContextCompactionBoundary(_item) { + this.emit({ type: "context_compacted" }); + } + emitUserMessageBoundary(item) { + if (this.startedUserMessageIds.has(item.id)) { + return; + } + this.startedUserMessageIds.add(item.id); + this.emit({ + type: "user_message_start", + itemId: item.id, + content: this.extractUserMessageText(item.content) + }); + } + emitAgentMessageBoundary(item) { + if (this.startedAgentMessageIds.has(item.id)) { + return; + } + this.startedAgentMessageIds.add(item.id); + this.emit({ type: "assistant_message_start", itemId: item.id }); + } + completeAgentMessage(item) { + if (!this.startedAgentMessageIds.has(item.id)) { + this.emitAgentMessageBoundary(item); + } + if (this.agentMessageDeltaIds.has(item.id) || !item.text) { + return; + } + this.emit({ type: "text", content: item.text }); + } + extractUserMessageText(content) { + return content.map((part) => part.type === "text" ? part.text : "").filter((text) => text.length > 0).join("\n\n"); + } + // -- turn/plan/updated (update_plan) ---------------------------------------- + onPlanUpdated(params) { + var _a3; + this.planUpdateCounter += 1; + const syntheticId = `plan-update-${(_a3 = params.turnId) != null ? _a3 : this.planUpdateCounter}`; + const PLAN_STATUS_MAP = { + inProgress: "in_progress", + in_progress: "in_progress" + }; + const todos = params.plan.map((item) => { + var _a4; + return { + id: "", + content: item.step, + activeForm: item.step, + status: (_a4 = PLAN_STATUS_MAP[item.status]) != null ? _a4 : item.status + }; + }); + this.emit({ type: "tool_use", id: syntheticId, name: "TodoWrite", input: { todos } }); + this.emit({ type: "tool_result", id: syntheticId, content: "Plan updated", isError: false }); + } + // -- outputDelta (commandExecution + fileChange) ---------------------------- + onOutputDelta(params) { + this.emit({ type: "tool_output", id: params.itemId, content: params.delta }); + } + // -- tokenUsage / turnCompleted / error ------------------------------------- + onTokenUsageUpdated(params) { + const last = params.tokenUsage.last; + const contextTokens = last.inputTokens; + const contextWindow = params.tokenUsage.modelContextWindow; + const usage = { + inputTokens: last.inputTokens, + cacheCreationInputTokens: 0, + cacheReadInputTokens: last.cachedInputTokens, + contextWindow, + contextWindowIsAuthoritative: contextWindow > 0, + contextTokens, + percentage: contextWindow > 0 ? Math.min(100, Math.max(0, Math.round(contextTokens / contextWindow * 100))) : 0 + }; + this.emit({ type: "usage", usage, sessionId: params.threadId }); + } + onTurnCompleted(params) { + var _a3; + const turn = params.turn; + if (turn.status === "failed" && turn.error) { + this.emit({ type: "error", content: turn.error.message }); + } + if (turn.status === "completed") { + (_a3 = this.onTurnMetadata) == null ? void 0 : _a3.call(this, { + assistantMessageId: turn.id, + ...this.isPlanTurn && this.sawPlanDelta ? { planCompleted: true } : {} + }); + } + this.emit({ type: "done" }); + } + onError(params) { + if (params.willRetry) return; + this.emit({ type: "error", content: params.error.message }); + } +}; + +// src/providers/codex/runtime/CodexServerRequestRouter.ts +var CodexServerRequestRouter = class { + constructor() { + this.approvalCallback = null; + this.askUserCallback = null; + this.pendingApprovalRequests = /* @__PURE__ */ new Map(); + this.askUserAbortController = null; + this.pendingAskUserRequestId = null; + this.pendingAskUserThreadId = null; + } + setApprovalCallback(callback) { + this.approvalCallback = callback; + } + setAskUserCallback(callback) { + this.askUserCallback = callback; + } + async handleServerRequest(requestIdOrMethod, methodOrParams, maybeParams) { + const hasExplicitRequestId = maybeParams !== void 0; + const requestId = hasExplicitRequestId ? requestIdOrMethod : void 0; + const method = hasExplicitRequestId ? methodOrParams : requestIdOrMethod; + const params = hasExplicitRequestId ? maybeParams : methodOrParams; + switch (method) { + case "item/commandExecution/requestApproval": + return this.handleCommandApproval(requestId, params); + case "item/fileChange/requestApproval": + return this.handleFileChangeApproval(requestId, params); + case "item/permissions/requestApproval": + return this.handlePermissionsApproval(requestId, params); + case "item/tool/requestUserInput": + return this.handleUserInputRequest(requestId, params); + default: + throw new Error(`Unsupported server request: ${method}`); + } + } + hasPendingApprovalRequest(requestId, threadId) { + return this.pendingApprovalRequests.get(requestId) === threadId; + } + async handleCommandApproval(requestId, params) { + var _a3, _b2, _c, _d, _e, _f, _g, _h, _i, _j2; + if (!this.approvalCallback) return { decision: "decline" }; + const command = (_a3 = params.command) != null ? _a3 : ""; + const toolName = normalizeCodexToolName("command_execution"); + const input = { + command, + cwd: (_b2 = params.cwd) != null ? _b2 : null, + reason: (_c = params.reason) != null ? _c : null, + commandActions: (_d = params.commandActions) != null ? _d : null, + approvalId: (_e = params.approvalId) != null ? _e : null, + networkApprovalContext: (_f = params.networkApprovalContext) != null ? _f : null, + additionalPermissions: (_g = params.additionalPermissions) != null ? _g : null, + skillMetadata: (_h = params.skillMetadata) != null ? _h : null, + proposedExecpolicyAmendment: (_i = params.proposedExecpolicyAmendment) != null ? _i : null, + proposedNetworkPolicyAmendments: (_j2 = params.proposedNetworkPolicyAmendments) != null ? _j2 : null + }; + const description = describeCommandApproval(params); + if (requestId !== void 0) { + this.pendingApprovalRequests.set(requestId, params.threadId); + } + try { + const decision = await this.approvalCallback(toolName, input, description, { + ...params.reason ? { decisionReason: params.reason } : {}, + ...params.networkApprovalContext ? { networkApprovalContext: params.networkApprovalContext } : {}, + ...params.additionalPermissions ? { additionalPermissions: params.additionalPermissions } : {}, + decisionOptions: buildCommandApprovalDecisionOptions(params) + }); + return { decision: mapCommandApprovalDecision(decision) }; + } finally { + if (requestId !== void 0) { + this.pendingApprovalRequests.delete(requestId); + } + } + } + async handleFileChangeApproval(requestId, params) { + var _a3; + if (!this.approvalCallback) return { decision: "decline" }; + const reason = (_a3 = params.reason) != null ? _a3 : void 0; + const toolName = normalizeCodexToolName("file_change"); + const input = { reason: reason != null ? reason : null }; + const description = reason ? `File change: ${reason}` : "File change"; + if (requestId !== void 0) { + this.pendingApprovalRequests.set(requestId, params.threadId); + } + try { + const decision = await this.approvalCallback(toolName, input, description, {}); + return { decision: mapFileChangeApprovalDecision(decision) }; + } finally { + if (requestId !== void 0) { + this.pendingApprovalRequests.delete(requestId); + } + } + } + async handlePermissionsApproval(requestId, params) { + var _a3, _b2; + if (!this.approvalCallback) return { permissions: {}, scope: "turn" }; + const requestedPermissions = (_a3 = params.permissions) != null ? _a3 : {}; + const reason = (_b2 = params.reason) != null ? _b2 : void 0; + const toolName = "permissions"; + const description = reason ? `Permission request: ${reason}` : "Permission request"; + if (requestId !== void 0) { + this.pendingApprovalRequests.set(requestId, params.threadId); + } + let decision; + try { + decision = await this.approvalCallback(toolName, requestedPermissions, description, {}); + } finally { + if (requestId !== void 0) { + this.pendingApprovalRequests.delete(requestId); + } + } + if (decision === "allow") { + return { permissions: requestedPermissions, scope: "turn" }; + } + if (decision === "allow-always") { + return { permissions: requestedPermissions, scope: "session" }; + } + return { permissions: {}, scope: "turn" }; + } + abortPendingAskUser(requestId, threadId) { + if (!this.askUserAbortController) { + return false; + } + if (requestId !== void 0 && requestId !== this.pendingAskUserRequestId) { + return false; + } + if (threadId !== void 0 && threadId !== this.pendingAskUserThreadId) { + return false; + } + this.askUserAbortController.abort(); + this.askUserAbortController = null; + this.pendingAskUserRequestId = null; + this.pendingAskUserThreadId = null; + return true; + } + async handleUserInputRequest(requestId, params) { + var _a3; + if (!this.askUserCallback) return { answers: {} }; + const questions = (_a3 = params.questions) != null ? _a3 : []; + const input = { questions }; + this.askUserAbortController = new AbortController(); + this.pendingAskUserRequestId = requestId != null ? requestId : null; + this.pendingAskUserThreadId = params.threadId; + let userAnswers; + try { + userAnswers = await this.askUserCallback(input, this.askUserAbortController.signal); + } finally { + this.askUserAbortController = null; + this.pendingAskUserRequestId = null; + this.pendingAskUserThreadId = null; + } + if (!userAnswers) return { answers: {} }; + const answers = {}; + for (const [key, value] of Object.entries(userAnswers)) { + answers[key] = { answers: normalizeAnswers(value) }; + } + return { answers }; + } +}; +function describeCommandApproval(params) { + var _a3; + const networkContext = params.networkApprovalContext; + if (networkContext) { + return `Allow ${networkContext.protocol} access to ${networkContext.host}`; + } + const command = (_a3 = params.command) != null ? _a3 : ""; + return command ? `Execute: ${command}` : "Execute command"; +} +function buildCommandApprovalDecisionOptions(params) { + var _a3; + const availableDecisions = (_a3 = params.availableDecisions) != null ? _a3 : ["accept", "acceptForSession", "decline"]; + return availableDecisions.map((decision) => mapDecisionOption(decision, params)); +} +function mapDecisionOption(decision, params) { + var _a3; + if (decision === "accept") { + return { label: "Allow once", value: "allow-once", decision: "allow" }; + } + if (decision === "acceptForSession") { + return { label: "Always allow", value: "allow-always", decision: "allow-always" }; + } + if (decision === "decline") { + return { label: "Deny", value: "deny", decision: "deny" }; + } + if (decision === "cancel") { + return { label: "Cancel", value: "cancel", decision: "cancel" }; + } + if ("acceptWithExecpolicyAmendment" in decision) { + return { + label: "Allow similar commands", + description: "Approve and store an exec policy amendment.", + value: encodeCommandApprovalDecision(decision) + }; + } + const networkPolicyAmendment = decision.applyNetworkPolicyAmendment.network_policy_amendment; + const host = networkPolicyAmendment.host || ((_a3 = params.networkApprovalContext) == null ? void 0 : _a3.host) || "host"; + const action = networkPolicyAmendment.action === "deny" ? "Deny" : "Allow"; + return { + label: `${action} ${host} for this session`, + description: `Apply a ${networkPolicyAmendment.action} rule for ${host}.`, + value: encodeCommandApprovalDecision(decision) + }; +} +function normalizeAnswers(value) { + if (Array.isArray(value)) { + return value.map((item) => typeof item === "string" ? item : String(item)).filter((item) => item.trim().length > 0); + } + return [value]; +} +function mapCommandApprovalDecision(decision) { + switch (decision) { + case "allow": + return "accept"; + case "allow-always": + return "acceptForSession"; + case "deny": + return "decline"; + case "cancel": + return "cancel"; + default: + if (typeof decision === "object" && decision !== null && decision.type === "select-option") { + const decoded = decodeCommandApprovalDecision(decision.value); + if (decoded) { + return decoded; + } + } + return "decline"; + } +} +function mapFileChangeApprovalDecision(decision) { + switch (decision) { + case "allow": + return "accept"; + case "allow-always": + return "acceptForSession"; + case "deny": + return "decline"; + case "cancel": + return "cancel"; + default: + return "decline"; + } +} +function encodeCommandApprovalDecision(decision) { + return JSON.stringify(decision); +} +function decodeCommandApprovalDecision(value) { + try { + return JSON.parse(value); + } catch (e3) { + return null; + } +} + +// src/providers/codex/runtime/CodexSessionFileTail.ts +var fs15 = __toESM(require("fs")); +var DEFAULT_CONTEXT_WINDOW2 = 2e5; +function getNonEmptyString(value, fallback) { + return typeof value === "string" && value.length > 0 ? value : fallback; +} +function isRecord3(value) { + return value !== null && typeof value === "object" && !Array.isArray(value); +} +function stringifyPayloadValue(raw) { + try { + const result = JSON.stringify(raw); + return typeof result === "string" ? result : String(raw); + } catch (e3) { + return String(raw); + } +} +function extractResponseItemMessageText(raw) { + if (!Array.isArray(raw)) return ""; + return raw.map((part) => isRecord3(part) && typeof part.text === "string" ? part.text : "").join(""); +} +function extractTextFromParts(parts) { + return parts.map((part) => { + if (typeof part === "string") return part; + return isRecord3(part) && typeof part.text === "string" ? part.text : ""; + }).join(""); +} +function extractResponseItemReasoningText(raw) { + if (Array.isArray(raw.summary) && raw.summary.length > 0) { + return extractTextFromParts(raw.summary); + } + if (Array.isArray(raw.content) && raw.content.length > 0) { + return extractTextFromParts(raw.content); + } + return typeof raw.text === "string" ? raw.text : ""; +} +function createSessionTailState(fallbackContextWindow = DEFAULT_CONTEXT_WINDOW2) { + return { + responseItemState: { + emittedToolUseIds: /* @__PURE__ */ new Set(), + emittedToolResultIds: /* @__PURE__ */ new Set(), + knownCalls: /* @__PURE__ */ new Map() + }, + currentTurnId: null, + syntheticTurnCounter: 0, + modelContextWindow: fallbackContextWindow, + modelContextWindowIsAuthoritative: false, + lastTextByTurn: /* @__PURE__ */ new Map(), + lastThinkingByTurn: /* @__PURE__ */ new Map(), + pendingUsageByTurn: /* @__PURE__ */ new Map(), + emittedDoneByTurn: /* @__PURE__ */ new Set(), + emittedUsageByTurn: /* @__PURE__ */ new Set(), + callEnrichment: /* @__PURE__ */ new Map() + }; +} +function emitDelta(fullText, lastSeenMap, turnId, chunkType) { + var _a3; + if (!fullText) return []; + const lastSeen = (_a3 = lastSeenMap.get(turnId)) != null ? _a3 : ""; + if (fullText.length <= lastSeen.length) return []; + const delta = fullText.slice(lastSeen.length); + lastSeenMap.set(turnId, fullText); + return [{ type: chunkType, content: delta }]; +} +function resolveTurnId(state, preferredTurnId) { + if (preferredTurnId) return preferredTurnId; + if (state.currentTurnId) return state.currentTurnId; + const id = `synthetic-turn-${state.syntheticTurnCounter}`; + state.syntheticTurnCounter += 1; + return id; +} +var reportedUnhandledSessionEventTypes = /* @__PURE__ */ new Set(); +function mapSessionFileEvent(event, sessionId, lineIndex, state) { + var _a3; + const eventType = event.type; + if (eventType === "event_msg") { + const payload = (_a3 = event.payload) != null ? _a3 : event; + return mapEventMsgEvent(payload, sessionId, state); + } + if (eventType === "response_item") { + return mapResponseItemEvent(event, sessionId, lineIndex, state); + } + if (eventType && !reportedUnhandledSessionEventTypes.has(eventType)) { + reportedUnhandledSessionEventTypes.add(eventType); + } + return []; +} +function mapEventMsgEvent(payload, sessionId, state) { + const payloadType = payload.type; + const info = isRecord3(payload.info) ? payload.info : {}; + switch (payloadType) { + case "task_started": { + const turnId = getNonEmptyString( + info.id, + getNonEmptyString(payload.turn_id, `synthetic-turn-${state.syntheticTurnCounter++}`) + ); + state.currentTurnId = turnId; + state.modelContextWindowIsAuthoritative = false; + if (typeof payload.model_context_window === "number" && payload.model_context_window > 0) { + state.modelContextWindow = payload.model_context_window; + state.modelContextWindowIsAuthoritative = true; + } + return []; + } + case "task_complete": { + const turnId = resolveTurnId(state, void 0); + const chunks = []; + if (!state.emittedUsageByTurn.has(turnId)) { + const pending = state.pendingUsageByTurn.get(turnId); + if (pending) { + const usage = buildUsageInfo( + pending.contextTokens, + pending.contextWindow, + pending.contextWindowIsAuthoritative + ); + chunks.push({ type: "usage", usage, sessionId }); + state.emittedUsageByTurn.add(turnId); + } + } + if (!state.emittedDoneByTurn.has(turnId)) { + chunks.push({ type: "done" }); + state.emittedDoneByTurn.add(turnId); + } + return chunks; + } + case "turn_aborted": { + const turnId = resolveTurnId(state, void 0); + const chunks = []; + if (!state.emittedDoneByTurn.has(turnId)) { + chunks.push({ type: "done" }); + state.emittedDoneByTurn.add(turnId); + } + return chunks; + } + case "user_message": + return []; + case "agent_message": { + const turnId = resolveTurnId(state, void 0); + const fullText = typeof payload.text === "string" ? payload.text : typeof payload.message === "string" ? payload.message : ""; + return emitDelta(fullText, state.lastTextByTurn, turnId, "text"); + } + case "agent_reasoning": { + const turnId = resolveTurnId(state, void 0); + const fullText = typeof payload.text === "string" ? payload.text : ""; + return emitDelta(fullText, state.lastThinkingByTurn, turnId, "thinking"); + } + case "token_count": { + const turnId = resolveTurnId(state, void 0); + const lastTokenUsage = isRecord3(info.last_token_usage) ? info.last_token_usage : {}; + const inputTokens = typeof lastTokenUsage.input_tokens === "number" ? lastTokenUsage.input_tokens : typeof lastTokenUsage.input === "number" ? lastTokenUsage.input : 0; + state.pendingUsageByTurn.set(turnId, { + contextTokens: inputTokens, + contextWindow: state.modelContextWindow, + contextWindowIsAuthoritative: state.modelContextWindowIsAuthoritative + }); + return []; + } + case "exec_command_end": { + const callId = typeof payload.call_id === "string" ? payload.call_id : ""; + if (callId) { + const exitCode = typeof payload.exit_code === "number" ? payload.exit_code : void 0; + state.callEnrichment.set(callId, { + ...state.callEnrichment.get(callId), + exitCode + }); + } + return []; + } + case "patch_apply_end": { + const callId = typeof payload.call_id === "string" ? payload.call_id : ""; + if (callId && typeof payload.success === "boolean" && !payload.success) { + state.callEnrichment.set(callId, { + ...state.callEnrichment.get(callId), + exitCode: 1 + }); + } + return []; + } + case "mcp_tool_call_end": { + const callId = typeof payload.call_id === "string" ? payload.call_id : ""; + const invocation = isRecord3(payload.invocation) ? payload.invocation : {}; + if (callId && typeof invocation.server === "string" && typeof invocation.tool === "string") { + state.callEnrichment.set(callId, { + ...state.callEnrichment.get(callId), + mcpServer: invocation.server, + mcpTool: invocation.tool + }); + const known = state.responseItemState.knownCalls.get(callId); + if (known) { + known.toolName = `mcp__${invocation.server}__${invocation.tool}`; + } + } + return []; + } + case "web_search_end": + case "view_image_tool_call": + case "collab_agent_spawn_end": + case "collab_waiting_end": + case "collab_close_end": + return []; + default: + return []; + } +} +function mapResponseItemEvent(event, sessionId, lineIndex, state) { + var _a3, _b2, _c; + const payload = isRecord3(event.payload) ? event.payload : {}; + const payloadType = payload.type; + const riState = state.responseItemState; + switch (payloadType) { + case "message": { + if (payload.role !== "assistant") return []; + const turnId = resolveTurnId(state, void 0); + const fullText = extractResponseItemMessageText(payload.content); + return emitDelta(fullText, state.lastTextByTurn, turnId, "text"); + } + case "reasoning": { + const turnId = resolveTurnId(state, void 0); + const fullText = extractResponseItemReasoningText(payload); + return emitDelta(fullText, state.lastThinkingByTurn, turnId, "thinking"); + } + case "function_call": + case "custom_tool_call": { + const callId = getNonEmptyString(payload.call_id, `tail-call-${lineIndex}`); + if (riState.emittedToolUseIds.has(callId)) return []; + riState.emittedToolUseIds.add(callId); + const rawName = typeof payload.name === "string" ? payload.name : void 0; + const rawArgs = typeof payload.arguments === "string" ? payload.arguments : typeof payload.input === "string" ? payload.input : void 0; + const parsedArgs = parseCodexArguments(rawArgs); + const enrichment = state.callEnrichment.get(callId); + const normalizedName = (enrichment == null ? void 0 : enrichment.mcpServer) && (enrichment == null ? void 0 : enrichment.mcpTool) ? `mcp__${enrichment.mcpServer}__${enrichment.mcpTool}` : normalizeCodexToolName(rawName); + const normalizedInput = normalizeCodexToolInput(rawName, parsedArgs); + riState.knownCalls.set(callId, { toolName: normalizedName, toolInput: normalizedInput }); + return [{ + type: "tool_use", + id: callId, + name: normalizedName, + input: normalizedInput + }]; + } + case "web_search_call": { + const callId = getNonEmptyString(payload.call_id, `tail-ws-${lineIndex}`); + if (riState.emittedToolUseIds.has(callId)) return []; + riState.emittedToolUseIds.add(callId); + const input = normalizeCodexToolInput("web_search_call", { + action: (_a3 = payload.action) != null ? _a3 : {} + }); + riState.knownCalls.set(callId, { toolName: "WebSearch", toolInput: input }); + const chunks = [{ + type: "tool_use", + id: callId, + name: "WebSearch", + input + }]; + if (payload.status) { + riState.emittedToolResultIds.add(callId); + chunks.push({ + type: "tool_result", + id: callId, + content: "Search complete", + isError: payload.status === "failed" || payload.status === "error" + }); + } + return chunks; + } + case "mcp_tool_call": { + const callId = getNonEmptyString(payload.call_id, `tail-mcp-${lineIndex}`); + const normalizedName = normalizeCodexMcpToolName(payload.server, payload.tool); + const normalizedInput = normalizeCodexMcpToolInput(payload.arguments); + const normalizedState = normalizeCodexMcpToolState(payload.status, payload.result, payload.error); + const chunks = []; + riState.knownCalls.set(callId, { toolName: normalizedName, toolInput: normalizedInput }); + if (!riState.emittedToolUseIds.has(callId)) { + riState.emittedToolUseIds.add(callId); + chunks.push({ + type: "tool_use", + id: callId, + name: normalizedName, + input: normalizedInput + }); + } + if (normalizedState.isTerminal && !riState.emittedToolResultIds.has(callId)) { + riState.emittedToolResultIds.add(callId); + chunks.push({ + type: "tool_result", + id: callId, + content: (_b2 = normalizedState.result) != null ? _b2 : normalizedState.isError ? "Failed" : "Completed", + isError: normalizedState.isError + }); + } + return chunks; + } + case "function_call_output": + case "custom_tool_call_output": { + const callId = getNonEmptyString(payload.call_id, `tail-out-${lineIndex}`); + if (riState.emittedToolResultIds.has(callId)) return []; + riState.emittedToolResultIds.add(callId); + const known = riState.knownCalls.get(callId); + const normalizedName = (_c = known == null ? void 0 : known.toolName) != null ? _c : "tool"; + const enrichment = state.callEnrichment.get(callId); + if (Array.isArray(payload.output)) { + const imagePath = (known == null ? void 0 : known.toolInput) && typeof known.toolInput.file_path === "string" ? known.toolInput.file_path : "Image loaded"; + return [{ + type: "tool_result", + id: callId, + content: imagePath, + isError: false + }]; + } + const rawOutput = typeof payload.output === "string" ? payload.output : stringifyPayloadValue(payload.output); + const content = normalizeCodexToolResult(normalizedName, rawOutput); + const isError = (enrichment == null ? void 0 : enrichment.exitCode) !== void 0 ? enrichment.exitCode !== 0 : isCodexToolOutputError(rawOutput); + return [{ + type: "tool_result", + id: callId, + content, + isError + }]; + } + default: + return []; + } +} +function buildUsageInfo(contextTokens, contextWindow, contextWindowIsAuthoritative) { + return { + inputTokens: contextTokens, + cacheCreationInputTokens: 0, + cacheReadInputTokens: 0, + contextWindow, + contextWindowIsAuthoritative, + contextTokens, + percentage: contextWindow > 0 ? Math.min(100, Math.max(0, Math.round(contextTokens / contextWindow * 100))) : 0 + }; +} +function sleep(ms) { + return new Promise((resolve5) => setTimeout(resolve5, ms)); +} +var CodexFileTailEngine = class { + constructor(sessionsDir, defaultContextWindow) { + this.sessionsDir = sessionsDir; + this.defaultContextWindow = defaultContextWindow; + this.tailSessionFile = null; + this.tailLineCursor = 0; + this.pendingEvents = []; + this.pollingActive = false; + this.pollPromise = null; + this.pollingError = null; + this.lastEventAt = 0; + this.lastPollAt = 0; + this.consecutiveReadFailures = 0; + this._turnCompleteEmitted = false; + this._usageEmitted = false; + this.tailState = createSessionTailState(defaultContextWindow); + } + get turnCompleteEmitted() { + return this._turnCompleteEmitted; + } + get usageEmitted() { + return this._usageEmitted; + } + async primeCursor(sessionId, sessionFilePath) { + const filePath = this.findSessionFile(sessionId, sessionFilePath); + if (!filePath) return false; + const lines = this.readFileLines(filePath); + this.tailLineCursor = lines.length; + return true; + } + startPolling(sessionId, sessionFilePath) { + const filePath = this.findSessionFile(sessionId, sessionFilePath); + if (!filePath) { + return false; + } + this.tailSessionFile = filePath; + this.pollingActive = true; + this.pollingError = null; + this.pollPromise = this.pollLoop(sessionId); + return true; + } + async stopPolling() { + this.pollingActive = false; + if (this.pollPromise) { + await this.pollPromise; + this.pollPromise = null; + } + } + async waitForSettle() { + const maxWait = 2500; + const checkInterval = 80; + const idleThreshold = 500; + const pollRecencyThreshold = 250; + const start = Date.now(); + while (Date.now() - start < maxWait) { + const now = Date.now(); + const idle = this.lastEventAt > 0 ? now - this.lastEventAt : now - start; + const pollRecent = this.lastPollAt > 0 && now - this.lastPollAt < pollRecencyThreshold; + if (idle >= idleThreshold && pollRecent) { + return; + } + await sleep(checkInterval); + } + } + collectPendingEvents() { + const events = this.pendingEvents; + this.pendingEvents = []; + return events; + } + consumePollingError() { + const error48 = this.pollingError; + this.pollingError = null; + return error48; + } + resetForNewTurn() { + this.tailState = createSessionTailState(this.defaultContextWindow); + this.pendingEvents = []; + this._turnCompleteEmitted = false; + this._usageEmitted = false; + this.pollingError = null; + this.lastEventAt = 0; + this.lastPollAt = 0; + this.consecutiveReadFailures = 0; + } + // ----------------------------------------------------------------------- + // Private + // ----------------------------------------------------------------------- + async pollLoop(sessionId) { + try { + while (this.pollingActive) { + const events = this.drainSessionFileEvents(sessionId); + if (events.length > 0) { + this.pendingEvents.push(...events); + this.lastEventAt = Date.now(); + this.trackTailFlags(events); + } + this.lastPollAt = Date.now(); + await sleep(100); + } + const finalEvents = this.drainSessionFileEvents(sessionId); + if (finalEvents.length > 0) { + this.pendingEvents.push(...finalEvents); + this.trackTailFlags(finalEvents); + } + } catch (error48) { + this.pollingError = error48 instanceof Error ? error48 : new Error(String(error48)); + this.pollingActive = false; + } finally { + this.lastPollAt = Date.now(); + } + } + drainSessionFileEvents(sessionId) { + if (!sessionId) return []; + const filePath = this.findSessionFile(sessionId); + if (!filePath) return []; + let lines; + try { + lines = this.readFileLines(filePath); + this.consecutiveReadFailures = 0; + } catch (e3) { + this.consecutiveReadFailures += 1; + if (this.consecutiveReadFailures >= 5) { + throw new Error(`CodexFileTailEngine: 5 consecutive read failures for ${filePath}`); + } + return []; + } + if (this.tailLineCursor > lines.length) { + this.tailLineCursor = 0; + } + if (this.tailLineCursor >= lines.length) return []; + const newLines = lines.slice(this.tailLineCursor); + const startIndex = this.tailLineCursor; + this.tailLineCursor = lines.length; + const chunks = []; + for (let i3 = 0; i3 < newLines.length; i3++) { + const line = newLines[i3]; + if (!line.trim()) continue; + let parsed; + try { + parsed = JSON.parse(line); + } catch (e3) { + continue; + } + const mapped = mapSessionFileEvent(parsed, sessionId, startIndex + i3, this.tailState); + chunks.push(...mapped); + } + return chunks; + } + findSessionFile(sessionId, sessionFilePath) { + if (sessionFilePath && fs15.existsSync(sessionFilePath)) { + this.tailSessionFile = sessionFilePath; + return sessionFilePath; + } + if (this.tailSessionFile) { + try { + if (fs15.existsSync(this.tailSessionFile)) { + return this.tailSessionFile; + } + } catch (e3) { + } + this.tailSessionFile = null; + } + const filePath = findCodexSessionFile(sessionId, this.sessionsDir); + if (filePath) { + this.tailSessionFile = filePath; + } + return filePath; + } + readFileLines(filePath) { + const content = fs15.readFileSync(filePath, "utf-8"); + return content.split("\n").filter((line) => line.trim()); + } + trackTailFlags(events) { + for (const event of events) { + if (event.type === "done") { + this._turnCompleteEmitted = true; + } + if (event.type === "usage") { + this._usageEmitted = true; + } + } + } +}; + +// src/providers/codex/runtime/CodexSessionManager.ts +var CodexSessionManager = class { + constructor() { + this.threadId = null; + this.sessionFilePath = null; + this.sessionInvalidated = false; + } + getThreadId() { + return this.threadId; + } + getSessionFilePath() { + return this.sessionFilePath; + } + setThread(threadId, sessionFilePath) { + const threadChanged = this.threadId !== threadId; + this.threadId = threadId; + if (sessionFilePath) { + this.sessionFilePath = sessionFilePath; + } else if (threadChanged) { + this.sessionFilePath = null; + } + } + reset() { + this.threadId = null; + this.sessionFilePath = null; + this.sessionInvalidated = false; + } + invalidateSession() { + this.sessionInvalidated = true; + } + consumeInvalidation() { + const was = this.sessionInvalidated; + this.sessionInvalidated = false; + return was; + } +}; + +// src/providers/codex/runtime/CodexChatRuntime.ts +function resolveCodexSandboxConfig(permissionMode, codexSafeMode = "workspace-write") { + if (permissionMode === "yolo") { + return { approvalPolicy: "never", sandbox: "danger-full-access" }; + } + if (permissionMode === "plan") { + return { approvalPolicy: "on-request", sandbox: "workspace-write" }; + } + return { approvalPolicy: "on-request", sandbox: codexSafeMode }; +} +function resolveCodexServiceTier(serviceTier, model) { + if (model !== "gpt-5.4") { + return null; + } + return serviceTier === "fast" ? "fast" : null; +} +var EFFORT_MAP = { + low: "low", + medium: "medium", + high: "high", + xhigh: "xhigh" +}; +var CodexChatRuntime = class { + constructor(plugin) { + this.providerId = "codex"; + this.session = new CodexSessionManager(); + this.process = null; + this.transport = null; + this.launchSpec = null; + this.runtimeContext = null; + this.notificationRouter = null; + this.serverRequestRouter = new CodexServerRequestRouter(); + this.ready = false; + this.readyListeners = /* @__PURE__ */ new Set(); + this.clientConfigKey = null; + this.currentTurnId = null; + this.currentQueryThreadId = null; + this.loadedThreadId = null; + this.currentThreadPath = null; + this.pendingTurnNotifications = []; + // Chunk buffer: notifications push here, query() drains + this.chunkBuffer = []; + this.chunkResolve = null; + this.approvalCallback = null; + this.approvalDismisser = null; + this.askUserCallback = null; + this.exitPlanModeCallback = null; + this.permissionModeSyncCallback = null; + this.subagentHookProvider = null; + this.autoTurnCallback = null; + this.activeInputBundles = /* @__PURE__ */ new Set(); + // Fork state + this.pendingFork = null; + // Cancellation + this.canceled = false; + this.turnMetadata = {}; + this.plugin = plugin; + } + getCapabilities() { + return CODEX_PROVIDER_CAPABILITIES; + } + prepareTurn(request) { + return encodeCodexTurn(request); + } + consumeTurnMetadata() { + const metadata = { ...this.turnMetadata }; + this.turnMetadata = {}; + return metadata; + } + onReadyStateChange(listener) { + this.readyListeners.add(listener); + return () => { + this.readyListeners.delete(listener); + }; + } + setResumeCheckpoint(checkpointId) { + this.resumeCheckpoint = checkpointId; + } + syncConversationState(conversation, _externalContextPaths) { + var _a3, _b2; + if (!conversation) { + this.session.reset(); + this.loadedThreadId = null; + this.currentThreadPath = null; + this.pendingFork = null; + return; + } + const state = getCodexState(conversation.providerState); + if (state.forkSource && !state.threadId && !conversation.sessionId) { + this.pendingFork = state.forkSource; + this.session.reset(); + this.loadedThreadId = null; + this.currentThreadPath = null; + return; + } + this.pendingFork = null; + const threadId = (_b2 = (_a3 = state.threadId) != null ? _a3 : conversation.sessionId) != null ? _b2 : null; + if (!threadId) { + this.session.reset(); + this.loadedThreadId = null; + this.currentThreadPath = null; + return; + } + this.session.setThread(threadId, state.sessionFilePath); + } + async reloadMcpServers() { + } + async ensureReady(options) { + const promptSettings = this.getSystemPromptSettings(); + const promptKey = computeSystemPromptKey(promptSettings); + const launchSpec = resolveCodexAppServerLaunchSpec(this.plugin, this.providerId); + const clientConfigKey = [promptKey, JSON.stringify({ + command: launchSpec.command, + args: launchSpec.args, + spawnCwd: launchSpec.spawnCwd, + targetCwd: launchSpec.targetCwd, + target: launchSpec.target + })].join("::"); + const shouldRebuild = !this.process || !this.transport || !this.process.isAlive() || (options == null ? void 0 : options.force) === true || this.clientConfigKey !== clientConfigKey; + if (shouldRebuild) { + await this.shutdownProcess(); + await this.startAppServer(launchSpec, clientConfigKey); + } + this.setReady(true); + return shouldRebuild; + } + async *query(originalTurn, _conversationHistory, queryOptions) { + var _a3, _b2, _c, _d, _e, _f, _g, _h, _i, _j2, _k, _l, _m, _n; + this.resetTurnMetadata(); + let turn = originalTurn; + await this.ensureReady(); + this.canceled = false; + this.cleanupActiveInputBundles(); + this.chunkBuffer = []; + this.chunkResolve = null; + this.currentQueryThreadId = null; + this.pendingTurnNotifications = []; + let tailEngine = null; + let tailDrainInterval = null; + let toolSourceMode = "fallback"; + let tailDonePromise = null; + let transcriptSessionFilePath; + const model = this.resolveModel(queryOptions); + const promptSettings = this.getSystemPromptSettings(); + const promptText = buildSystemPrompt(promptSettings); + const enqueueChunk = (chunk) => { + this.chunkBuffer.push(chunk); + if (this.chunkResolve) { + this.chunkResolve(); + this.chunkResolve = null; + } + }; + const switchToLiveToolFallback = () => { + if (toolSourceMode === "fallback") { + return; + } + toolSourceMode = "fallback"; + if (tailDrainInterval) { + clearInterval(tailDrainInterval); + tailDrainInterval = null; + } + if (tailEngine) { + void tailEngine.stopPolling().catch(() => { + }); + } + }; + const syncTailPollingState = () => { + if (!tailEngine) return null; + const tailError = tailEngine.consumePollingError(); + if (tailError) { + switchToLiveToolFallback(); + return tailError; + } + return null; + }; + const drainTailToolChunks = () => { + if (!tailEngine) return; + if (toolSourceMode !== "transcript") return; + if (syncTailPollingState()) return; + const toolChunks = tailEngine.collectPendingEvents().filter( + (chunk) => chunk.type === "tool_use" || chunk.type === "tool_result" + ); + for (const chunk of toolChunks) { + enqueueChunk(chunk); + } + }; + const stopTailToolPolling = async () => { + if (tailDrainInterval) { + clearInterval(tailDrainInterval); + tailDrainInterval = null; + } + if (tailEngine) { + await tailEngine.stopPolling(); + } + }; + const flushTailToolsBeforeDone = () => { + if (toolSourceMode !== "transcript" || !tailEngine) { + enqueueChunk({ type: "done" }); + return; + } + if (tailDonePromise) { + return; + } + tailDonePromise = (async () => { + try { + await tailEngine.waitForSettle(); + if (syncTailPollingState()) { + return; + } + drainTailToolChunks(); + } finally { + await stopTailToolPolling(); + enqueueChunk({ type: "done" }); + } + })(); + }; + this.notificationRouter = new CodexNotificationRouter( + (chunk) => { + syncTailPollingState(); + if (toolSourceMode === "transcript") { + if (chunk.type === "tool_use" || chunk.type === "tool_result") { + return; + } + if (chunk.type === "done") { + flushTailToolsBeforeDone(); + return; + } + } + enqueueChunk(chunk); + }, + (update) => this.recordTurnMetadata(update) + ); + this.wireTransportHandlers(); + const compactValidationError = this.validateCompactTurn(originalTurn); + if (compactValidationError) { + yield { type: "error", content: compactValidationError }; + yield { type: "done" }; + return; + } + try { + const existingThreadId = this.session.getThreadId(); + let threadId; + let threadPath = null; + let completedPendingFork = false; + if (this.pendingFork) { + const fork = this.pendingFork; + const forkResult = await this.transport.request("thread/fork", { + threadId: fork.sessionId + }); + threadId = forkResult.thread.id; + threadPath = this.toHostSessionPath(forkResult.thread.path); + const forkTurns = (_a3 = forkResult.thread.turns) != null ? _a3 : []; + const checkpointIndex = forkTurns.findIndex((t3) => t3.id === fork.resumeAt); + if (checkpointIndex < 0) { + throw new Error(`Fork checkpoint not found: ${fork.resumeAt}`); + } + const numTurnsToRollback = forkTurns.length - checkpointIndex - 1; + const permissionMode = this.resolveSandboxConfig(); + await this.transport.request("thread/resume", { + threadId, + model: model != null ? model : "gpt-5.4", + approvalPolicy: permissionMode.approvalPolicy, + sandbox: permissionMode.sandbox, + serviceTier: resolveCodexServiceTier(this.getProviderSettings().serviceTier, model != null ? model : "gpt-5.4"), + baseInstructions: promptText, + persistExtendedHistory: true + }); + if (numTurnsToRollback > 0) { + await this.transport.request("thread/rollback", { + threadId, + numTurns: numTurnsToRollback + }); + } + this.loadedThreadId = threadId; + completedPendingFork = true; + if (_conversationHistory && _conversationHistory.length > 0) { + const checkpointIdx = _conversationHistory.findIndex( + (m3) => m3.assistantMessageId === fork.resumeAt + ); + if (checkpointIdx >= 0 && checkpointIdx < _conversationHistory.length - 1) { + const suffix = _conversationHistory.slice(checkpointIdx + 1); + const replayContext = buildContextFromHistory(suffix); + if (replayContext.trim()) { + turn = { + ...turn, + prompt: `${replayContext} + +User: ${turn.prompt}` + }; + } + } + } + } else if (existingThreadId && existingThreadId !== this.loadedThreadId) { + const permissionMode = this.resolveSandboxConfig(); + const resumeResult = await this.transport.request("thread/resume", { + threadId: existingThreadId, + model: model != null ? model : "gpt-5.4", + approvalPolicy: permissionMode.approvalPolicy, + sandbox: permissionMode.sandbox, + serviceTier: resolveCodexServiceTier(this.getProviderSettings().serviceTier, model != null ? model : "gpt-5.4"), + baseInstructions: promptText, + persistExtendedHistory: true + }); + threadId = resumeResult.thread.id; + threadPath = this.toHostSessionPath(resumeResult.thread.path); + this.loadedThreadId = threadId; + } else if (existingThreadId && existingThreadId === this.loadedThreadId) { + threadId = existingThreadId; + } else { + const permissionMode = this.resolveSandboxConfig(); + const startResult = await this.transport.request("thread/start", { + model: model != null ? model : "gpt-5.4", + cwd: (_d = (_c = (_b2 = this.launchSpec) == null ? void 0 : _b2.targetCwd) != null ? _c : getVaultPath(this.plugin.app)) != null ? _d : void 0, + approvalPolicy: permissionMode.approvalPolicy, + sandbox: permissionMode.sandbox, + serviceTier: resolveCodexServiceTier(this.getProviderSettings().serviceTier, model != null ? model : "gpt-5.4"), + baseInstructions: promptText, + experimentalRawEvents: false, + persistExtendedHistory: true + }); + threadId = startResult.thread.id; + threadPath = this.toHostSessionPath(startResult.thread.path); + this.loadedThreadId = threadId; + } + this.session.setThread(threadId, (_e = threadPath != null ? threadPath : this.currentThreadPath) != null ? _e : void 0); + if (threadPath) this.currentThreadPath = threadPath; + this.currentQueryThreadId = threadId; + if (completedPendingFork) { + this.pendingFork = null; + } + if (turn.isCompact) { + (_f = this.notificationRouter) == null ? void 0 : _f.beginTurn({ isPlanTurn: false }); + await this.transport.request( + "thread/compact/start", + { threadId } + ); + this.recordTurnMetadata({ wasSent: true }); + } else { + tailEngine = new CodexFileTailEngine( + (_h = (_g = this.runtimeContext) == null ? void 0 : _g.sessionsDirHost) != null ? _h : path15.join(os10.homedir(), ".codex", "sessions"), + 2e5 + ); + tailEngine.resetForNewTurn(); + transcriptSessionFilePath = (_i = threadPath != null ? threadPath : this.session.getSessionFilePath()) != null ? _i : null; + const transcriptReady = await tailEngine.primeCursor( + threadId, + transcriptSessionFilePath != null ? transcriptSessionFilePath : void 0 + ); + if (transcriptReady) { + toolSourceMode = "transcript"; + } + const skillInputs = await this.resolveSkillInputs(turn.request.text); + const turnInputBundle = this.buildInput(turn.prompt, turn.request.images, skillInputs); + this.registerActiveInputBundle(turnInputBundle); + const providerSettings = this.getProviderSettings(); + const effort = (_j2 = EFFORT_MAP[providerSettings.effortLevel]) != null ? _j2 : "medium"; + const resolvedModel = model != null ? model : "gpt-5.4"; + const isPlanMode = providerSettings.permissionMode === "plan"; + const externalContextPaths = this.resolveExternalContextPaths(turn, queryOptions); + const permissionMode = this.resolveSandboxConfig(); + const sandboxPolicy = this.buildTurnSandboxPolicy(externalContextPaths, permissionMode.sandbox); + const collaborationMode = isPlanMode ? { + mode: "plan", + settings: { + model: resolvedModel, + reasoning_effort: effort, + developer_instructions: null + } + } : void 0; + const summary = getCodexProviderSettings(providerSettings).reasoningSummary; + const serviceTier = resolveCodexServiceTier(providerSettings.serviceTier, resolvedModel); + (_k = this.notificationRouter) == null ? void 0 : _k.beginTurn({ isPlanTurn: isPlanMode }); + const turnResult = await this.transport.request("turn/start", { + threadId, + input: turnInputBundle.input, + approvalPolicy: permissionMode.approvalPolicy, + model: resolvedModel, + serviceTier, + effort, + summary, + sandboxPolicy, + ...collaborationMode ? { collaborationMode } : {} + }); + this.currentTurnId = turnResult.turn.id; + this.recordTurnMetadata({ + userMessageId: turnResult.turn.id, + wasSent: true + }); + this.flushPendingTurnNotifications(); + if (toolSourceMode === "transcript" && tailEngine) { + const transcriptPollingStarted = tailEngine.startPolling( + threadId, + transcriptSessionFilePath != null ? transcriptSessionFilePath : void 0 + ); + if (transcriptPollingStarted) { + tailDrainInterval = setInterval(() => { + drainTailToolChunks(); + }, 50); + } else { + switchToLiveToolFallback(); + } + } + } + while (true) { + if (this.canceled) { + while (this.chunkBuffer.length > 0) { + const chunk = this.chunkBuffer.shift(); + yield chunk; + if (chunk.type === "done") return; + } + yield { type: "done" }; + return; + } + if (this.chunkBuffer.length === 0) { + await new Promise((resolve5) => { + this.chunkResolve = resolve5; + if (this.chunkBuffer.length > 0 || this.canceled) { + resolve5(); + this.chunkResolve = null; + } + }); + } + while (this.chunkBuffer.length > 0) { + const chunk = this.chunkBuffer.shift(); + yield chunk; + if (chunk.type === "done") { + return; + } + } + } + } catch (err) { + if (this.canceled) { + yield { type: "done" }; + return; + } + const message = err instanceof Error ? err.message : "Unknown Codex error"; + yield { type: "error", content: message }; + yield { type: "done" }; + return; + } finally { + (_l = this.notificationRouter) == null ? void 0 : _l.endTurn(); + if (!tailDonePromise) { + await stopTailToolPolling().catch(() => { + }); + } + this.cleanupActiveInputBundles(); + this.currentTurnId = null; + this.currentQueryThreadId = null; + this.pendingTurnNotifications = []; + if (!this.session.getSessionFilePath()) { + const threadId = this.session.getThreadId(); + if (threadId) { + const sessionFilePath = findCodexSessionFile( + threadId, + (_n = (_m = this.runtimeContext) == null ? void 0 : _m.sessionsDirHost) != null ? _n : void 0 + ); + if (sessionFilePath) { + this.session.setThread(threadId, sessionFilePath); + } + } + } + } + } + async steer(turn) { + if (turn.isCompact || this.canceled) { + return false; + } + const transport = this.transport; + const threadId = this.currentQueryThreadId; + const turnId = this.currentTurnId; + if (!transport || !threadId || !turnId) { + return false; + } + const skillInputs = await this.resolveSkillInputs(turn.request.text); + const inputBundle = this.buildInput(turn.prompt, turn.request.images, skillInputs); + this.registerActiveInputBundle(inputBundle); + try { + const result = await transport.request("turn/steer", { + threadId, + input: inputBundle.input, + expectedTurnId: turnId + }); + if (result.turnId !== turnId) { + return false; + } + return this.currentQueryThreadId === threadId && this.currentTurnId === turnId && !this.canceled; + } catch (error48) { + this.disposeInputBundle(inputBundle); + throw error48; + } + } + cancel() { + this.canceled = true; + this.dismissAllPendingPrompts(); + const threadId = this.session.getThreadId(); + const turnId = this.currentTurnId; + if (this.transport && threadId && turnId) { + this.transport.request("turn/interrupt", { threadId, turnId }).catch(() => { + }); + } + if (this.chunkResolve) { + this.chunkResolve(); + this.chunkResolve = null; + } + } + resetSession() { + this.teardownState(); + } + getSessionId() { + return this.session.getThreadId(); + } + consumeSessionInvalidation() { + return this.session.consumeInvalidation(); + } + isReady() { + return this.ready; + } + resetTurnMetadata() { + this.turnMetadata = {}; + } + recordTurnMetadata(update) { + this.turnMetadata = { + ...this.turnMetadata, + ...update + }; + } + async getSupportedCommands() { + return []; + } + cleanup() { + this.cancel(); + this.teardownState(); + this.readyListeners.clear(); + } + async rewind(_userMessageId, _assistantMessageId) { + return { canRewind: false, error: "Codex does not support rewind" }; + } + setApprovalCallback(callback) { + this.approvalCallback = callback; + this.serverRequestRouter.setApprovalCallback(callback); + } + setApprovalDismisser(dismisser) { + this.approvalDismisser = dismisser; + } + setAskUserQuestionCallback(callback) { + this.askUserCallback = callback; + this.serverRequestRouter.setAskUserCallback(callback); + } + setExitPlanModeCallback(callback) { + this.exitPlanModeCallback = callback; + } + setPermissionModeSyncCallback(callback) { + this.permissionModeSyncCallback = callback; + } + setSubagentHookProvider(getState) { + this.subagentHookProvider = getState; + } + setAutoTurnCallback(callback) { + this.autoTurnCallback = callback; + } + buildSessionUpdates(params) { + var _a3, _b2, _c, _d; + const threadId = this.session.getThreadId(); + const sessionFilePath = (_a3 = this.session.getSessionFilePath()) != null ? _a3 : this.currentThreadPath; + const existingState = params.conversation ? getCodexState(params.conversation.providerState) : null; + const providerState = { + ...threadId ? { threadId } : {}, + ...sessionFilePath ? { sessionFilePath } : {}, + ...((_b2 = this.runtimeContext) == null ? void 0 : _b2.sessionsDirHost) || (existingState == null ? void 0 : existingState.transcriptRootPath) ? { transcriptRootPath: (_d = (_c = this.runtimeContext) == null ? void 0 : _c.sessionsDirHost) != null ? _d : existingState == null ? void 0 : existingState.transcriptRootPath } : {}, + ...(existingState == null ? void 0 : existingState.forkSource) ? { forkSource: existingState.forkSource } : {}, + ...(existingState == null ? void 0 : existingState.forkSourceSessionFilePath) ? { forkSourceSessionFilePath: existingState.forkSourceSessionFilePath } : {}, + ...(existingState == null ? void 0 : existingState.forkSourceTranscriptRootPath) ? { forkSourceTranscriptRootPath: existingState.forkSourceTranscriptRootPath } : {} + }; + const updates = { + sessionId: threadId, + providerState + }; + if (params.sessionInvalidated && params.conversation) { + updates.sessionId = null; + updates.providerState = void 0; + } + return { updates }; + } + resolveSessionIdForFork(conversation) { + var _a3, _b2, _c, _d; + const threadId = this.session.getThreadId(); + if (threadId) return threadId; + if (!conversation) return null; + const state = getCodexState(conversation.providerState); + return (_d = (_c = (_a3 = state.threadId) != null ? _a3 : conversation.sessionId) != null ? _c : (_b2 = state.forkSource) == null ? void 0 : _b2.sessionId) != null ? _d : null; + } + // ----------------------------------------------------------------------- + // Private helpers + // ----------------------------------------------------------------------- + teardownState() { + this.cleanupActiveInputBundles(); + this.session.reset(); + this.launchSpec = null; + this.runtimeContext = null; + this.loadedThreadId = null; + this.currentThreadPath = null; + this.currentTurnId = null; + this.currentQueryThreadId = null; + this.pendingTurnNotifications = []; + this.pendingFork = null; + this.clientConfigKey = null; + this.shutdownProcess().catch(() => { + }); + this.setReady(false); + } + dismissApprovalUI() { + if (this.approvalDismisser) { + this.approvalDismisser(); + } + } + dismissAllPendingPrompts() { + this.dismissApprovalUI(); + this.serverRequestRouter.abortPendingAskUser(); + } + registerActiveInputBundle(bundle) { + this.activeInputBundles.add(bundle); + } + disposeInputBundle(bundle) { + if (this.activeInputBundles.delete(bundle)) { + bundle.cleanup(); + return; + } + bundle.cleanup(); + } + cleanupActiveInputBundles() { + for (const bundle of this.activeInputBundles) { + bundle.cleanup(); + } + this.activeInputBundles.clear(); + } + setReady(ready) { + this.ready = ready; + for (const listener of this.readyListeners) { + listener(ready); + } + } + getSystemPromptSettings() { + var _a3; + const settings11 = this.plugin.settings; + return { + mediaFolder: settings11.mediaFolder, + customPrompt: settings11.systemPrompt, + vaultPath: (_a3 = getVaultPath(this.plugin.app)) != null ? _a3 : void 0, + userName: settings11.userName + }; + } + getProviderSettings() { + return ProviderSettingsCoordinator.getProviderSettingsSnapshot( + this.plugin.settings, + this.providerId + ); + } + resolveModel(queryOptions) { + var _a3; + const providerSettings = this.getProviderSettings(); + return (_a3 = queryOptions == null ? void 0 : queryOptions.model) != null ? _a3 : providerSettings.model; + } + resolveSandboxConfig() { + const providerSettings = this.getProviderSettings(); + return resolveCodexSandboxConfig( + providerSettings.permissionMode, + getCodexProviderSettings(providerSettings).safeMode + ); + } + async startAppServer(launchSpec, clientConfigKey) { + this.launchSpec = launchSpec; + this.process = new CodexAppServerProcess(launchSpec); + this.process.start(); + this.transport = new CodexRpcTransport(this.process); + this.transport.start(); + const initializeResult = await initializeCodexAppServerTransport(this.transport); + this.runtimeContext = createCodexRuntimeContext(launchSpec, initializeResult); + this.clientConfigKey = clientConfigKey; + } + wireTransportHandlers() { + if (!this.transport || !this.notificationRouter) return; + const router = this.notificationRouter; + const methods = [ + "item/agentMessage/delta", + "item/started", + "item/completed", + "item/plan/delta", + "item/reasoning/textDelta", + "item/reasoning/summaryTextDelta", + "item/reasoning/summaryPartAdded", + "thread/tokenUsage/updated", + "turn/plan/updated", + "turn/completed", + "error", + "thread/started", + "thread/status/changed", + "turn/started", + "serverRequest/resolved", + "item/commandExecution/outputDelta", + "item/fileChange/outputDelta" + ]; + for (const method of methods) { + this.transport.onNotification(method, (params) => { + if (method === "serverRequest/resolved") { + this.handleServerRequestResolved(params); + return; + } + if (!this.routeNotification(method, params)) { + return; + } + router.handleNotification(method, params); + }); + } + const requestMethods = [ + "item/commandExecution/requestApproval", + "item/fileChange/requestApproval", + "item/permissions/requestApproval", + "item/tool/requestUserInput" + ]; + for (const method of requestMethods) { + this.transport.onServerRequest(method, (requestId, params) => { + return this.serverRequestRouter.handleServerRequest(requestId, method, params); + }); + } + } + async shutdownProcess() { + if (this.transport) { + this.transport.dispose(); + this.transport = null; + } + if (this.process) { + await this.process.shutdown(); + this.process = null; + } + this.launchSpec = null; + this.runtimeContext = null; + this.notificationRouter = null; + this.currentTurnId = null; + this.currentQueryThreadId = null; + this.pendingTurnNotifications = []; + this.loadedThreadId = null; + } + resolveExternalContextPaths(turn, queryOptions) { + var _a3, _b2; + const externalContextPaths = (_b2 = (_a3 = turn.request.externalContextPaths) != null ? _a3 : queryOptions == null ? void 0 : queryOptions.externalContextPaths) != null ? _b2 : []; + return [...new Set(externalContextPaths.filter((value) => typeof value === "string" && value.trim().length > 0))]; + } + buildTurnSandboxPolicy(externalContextPaths, sandboxMode) { + var _a3, _b2, _c, _d, _e; + if (sandboxMode === "danger-full-access") { + return { type: "dangerFullAccess" }; + } + if (sandboxMode === "read-only") { + return { + type: "readOnly", + access: { type: "fullAccess" }, + networkAccess: false + }; + } + if (sandboxMode !== "workspace-write") { + return void 0; + } + const mappedExternalContextPaths = this.mapRequiredHostPathsToTarget( + externalContextPaths, + "external context path" + ); + const writableRoots = [ + (_b2 = (_a3 = this.launchSpec) == null ? void 0 : _a3.targetCwd) != null ? _b2 : getVaultPath(this.plugin.app), + ...mappedExternalContextPaths, + (_d = (_c = this.runtimeContext) == null ? void 0 : _c.memoriesDirTarget) != null ? _d : path15.join(os10.homedir(), ".codex", "memories"), + this.mapHostPathToTarget(os10.tmpdir()), + ((_e = this.launchSpec) == null ? void 0 : _e.target.platformFamily) === "unix" ? "/tmp" : null, + this.mapHostPathToTarget(process.env.TMPDIR) + ].filter((value) => typeof value === "string" && value.trim().length > 0); + return { + type: "workspaceWrite", + writableRoots: [...new Set(writableRoots)], + readOnlyAccess: { type: "fullAccess" }, + networkAccess: false, + excludeTmpdirEnvVar: false, + excludeSlashTmp: false + }; + } + handleServerRequestResolved(params) { + if (this.serverRequestRouter.hasPendingApprovalRequest(params.requestId, params.threadId)) { + this.dismissApprovalUI(); + return; + } + this.serverRequestRouter.abortPendingAskUser(params.requestId, params.threadId); + } + routeNotification(method, params) { + if (method === "turn/started") { + this.handleTurnStartedNotification(params); + return false; + } + const scope = this.extractNotificationScope(method, params); + if (!scope) { + return true; + } + if (!this.currentQueryThreadId || scope.threadId !== this.currentQueryThreadId) { + return false; + } + if (!this.currentTurnId) { + this.pendingTurnNotifications.push({ method, params }); + return false; + } + if (scope.turnId !== this.currentTurnId) { + return false; + } + return true; + } + handleTurnStartedNotification(params) { + var _a3; + if (!params || typeof params !== "object") return; + const notification = params; + const threadId = notification.threadId; + const turnId = (_a3 = notification.turn) == null ? void 0 : _a3.id; + if (!threadId || !turnId) return; + if (threadId !== this.currentQueryThreadId) return; + if (!this.currentTurnId) { + this.currentTurnId = turnId; + this.flushPendingTurnNotifications(); + } + } + validateCompactTurn(turn) { + if (!turn.isCompact) { + return null; + } + if (turn.request.text.trim() !== "/compact") { + return "/compact does not accept arguments"; + } + return null; + } + flushPendingTurnNotifications() { + if (!this.notificationRouter || !this.currentTurnId) { + this.pendingTurnNotifications = []; + return; + } + const pending = this.pendingTurnNotifications; + this.pendingTurnNotifications = []; + for (const notification of pending) { + const scope = this.extractNotificationScope(notification.method, notification.params); + if (!scope) { + this.notificationRouter.handleNotification(notification.method, notification.params); + continue; + } + if (scope.threadId === this.currentQueryThreadId && scope.turnId === this.currentTurnId) { + this.notificationRouter.handleNotification(notification.method, notification.params); + } + } + } + extractNotificationScope(method, params) { + if (!params || typeof params !== "object") { + return null; + } + const notification = params; + const threadId = typeof notification.threadId === "string" ? notification.threadId : null; + if (method === "turn/completed") { + const turn = notification.turn; + const turnId2 = turn && typeof turn === "object" && typeof turn.id === "string" ? turn.id : null; + return threadId && turnId2 ? { threadId, turnId: turnId2 } : null; + } + const turnId = typeof notification.turnId === "string" ? notification.turnId : null; + return threadId && turnId ? { threadId, turnId } : null; + } + async resolveSkillInputs(text) { + var _a3, _b2, _c, _d, _e, _f, _g; + const skillNames = extractExplicitCodexSkillNames(text); + if (skillNames.length === 0 || !this.transport) { + return []; + } + try { + const cwd = (_c = (_b2 = (_a3 = this.launchSpec) == null ? void 0 : _a3.targetCwd) != null ? _b2 : getVaultPath(this.plugin.app)) != null ? _c : process.cwd(); + const result = await this.transport.request("skills/list", { + cwds: [cwd] + }); + const skills = (_g = (_f = (_d = result.data.find((entry) => entry.cwd === cwd)) == null ? void 0 : _d.skills) != null ? _f : (_e = result.data[0]) == null ? void 0 : _e.skills) != null ? _g : []; + const resolvedInputs = []; + for (const skillName of skillNames) { + const resolvedSkill = findPreferredCodexSkillByName(skills, skillName); + if (!resolvedSkill) { + continue; + } + resolvedInputs.push({ + type: "skill", + name: resolvedSkill.name, + path: resolvedSkill.path + }); + } + return resolvedInputs; + } catch (e3) { + return []; + } + } + buildInput(text, images, skills) { + const input = []; + let tempDir = null; + const cleanup = () => { + if (!tempDir) { + return; + } + try { + fs16.rmSync(tempDir, { recursive: true, force: true }); + } catch (e3) { + } + }; + try { + if (images && images.length > 0) { + tempDir = fs16.mkdtempSync(path15.join(os10.tmpdir(), "claudian-codex-images-")); + for (let i3 = 0; i3 < images.length; i3++) { + const img = images[i3]; + if (!img.mediaType.startsWith("image/")) continue; + const filename = toAttachmentFilename(img, i3); + const filePath = path15.join(tempDir, `${i3 + 1}-${filename}`); + fs16.writeFileSync(filePath, Buffer.from(img.data, "base64")); + const targetFilePath = this.mapHostPathToTarget(filePath); + if (!targetFilePath) { + throw new Error(`Codex cannot access image attachment path from the selected target: ${filePath}`); + } + input.push({ type: "localImage", path: targetFilePath }); + } + } + if (text) { + input.push({ type: "text", text, text_elements: [] }); + } + if (skills && skills.length > 0) { + input.push(...skills); + } + return { input, cleanup }; + } catch (error48) { + cleanup(); + throw error48; + } + } + toHostSessionPath(targetPath) { + var _a3, _b2; + if (!targetPath) { + return null; + } + return (_b2 = (_a3 = this.launchSpec) == null ? void 0 : _a3.pathMapper.toHostPath(targetPath)) != null ? _b2 : targetPath; + } + mapHostPathToTarget(hostPath) { + var _a3, _b2; + if (!hostPath) { + return null; + } + return (_b2 = (_a3 = this.launchSpec) == null ? void 0 : _a3.pathMapper.toTargetPath(hostPath)) != null ? _b2 : hostPath; + } + mapRequiredHostPathsToTarget(hostPaths, label) { + if (!this.launchSpec) { + return hostPaths; + } + return hostPaths.map((hostPath) => { + const targetPath = this.launchSpec.pathMapper.toTargetPath(hostPath); + if (!targetPath) { + throw new Error(`Codex cannot access ${label} from the selected target: ${hostPath}`); + } + return targetPath; + }); + } +}; +function toAttachmentFilename(attachment, index) { + var _a3, _b2; + const base = ((_a3 = attachment.filename) != null ? _a3 : "").trim().replace(/[^A-Za-z0-9._-]/g, "_") || `image-${index + 1}`; + if (base.includes(".")) return base; + const subtype = (_b2 = attachment.mediaType.split("/")[1]) != null ? _b2 : "img"; + const extension = subtype === "jpeg" ? "jpg" : subtype; + return `${base}.${extension}`; +} + +// src/providers/codex/registration.ts +var codexProviderRegistration = { + displayName: "Codex", + blankTabOrder: 10, + isEnabled: (settings11) => getCodexProviderSettings(settings11).enabled, + capabilities: CODEX_PROVIDER_CAPABILITIES, + environmentKeyPatterns: [/^OPENAI_/i, /^CODEX_/i], + chatUIConfig: codexChatUIConfig, + settingsReconciler: codexSettingsReconciler, + createRuntime: ({ plugin }) => new CodexChatRuntime(plugin), + createTitleGenerationService: (plugin) => new CodexTitleGenerationService(plugin), + createInstructionRefineService: (plugin) => new CodexInstructionRefineService(plugin), + createInlineEditService: (plugin) => new CodexInlineEditService(plugin), + historyService: new CodexConversationHistoryService(), + taskResultInterpreter: new CodexTaskResultInterpreter(), + subagentLifecycleAdapter: codexSubagentLifecycleAdapter +}; + +// src/providers/index.ts +var builtInProvidersRegistered = false; +function registerBuiltInProviders() { + if (builtInProvidersRegistered) { + return; + } + ProviderRegistry.register("claude", claudeProviderRegistration); + ProviderRegistry.register("codex", codexProviderRegistration); + ProviderWorkspaceRegistry.register("claude", claudeWorkspaceRegistration); + ProviderWorkspaceRegistry.register("codex", codexWorkspaceRegistration); + builtInProvidersRegistered = true; +} +registerBuiltInProviders(); + +// src/main.ts +var import_obsidian45 = require("obsidian"); + +// src/app/storage/SharedStorageService.ts +var import_obsidian18 = require("obsidian"); +var SharedStorageService = class { + constructor(plugin) { + this.plugin = plugin; + this.adapter = new VaultFileAdapter(plugin.app); + this.claudianSettings = new ClaudianSettingsStorage(this.adapter); + this.sessions = new SessionStorage(this.adapter); + } + async initialize() { + await this.ensureDirectories(); + const claudian = await this.claudianSettings.load(); + return { claudian }; + } + async saveClaudianSettings(settings11) { + await this.claudianSettings.save(settings11); + } + async setTabManagerState(state) { + try { + const data = await this.plugin.loadData() || {}; + data.tabManagerState = state; + await this.plugin.saveData(data); + } catch (e3) { + new import_obsidian18.Notice("Failed to save tab layout"); + } + } + async getTabManagerState() { + try { + const data = await this.plugin.loadData(); + if (!(data == null ? void 0 : data.tabManagerState)) { + return null; + } + return this.validateTabManagerState(data.tabManagerState); + } catch (e3) { + return null; + } + } + getAdapter() { + return this.adapter; + } + async ensureDirectories() { + await this.adapter.ensureFolder(CLAUDIAN_STORAGE_PATH); + await this.adapter.ensureFolder(SESSIONS_PATH); + } + validateTabManagerState(data) { + if (!data || typeof data !== "object") { + return null; + } + const state = data; + if (!Array.isArray(state.openTabs)) { + return null; + } + const validatedTabs = []; + for (const tab of state.openTabs) { + if (!tab || typeof tab !== "object") { + continue; + } + const tabObj = tab; + if (typeof tabObj.tabId !== "string") { + continue; + } + validatedTabs.push({ + tabId: tabObj.tabId, + conversationId: typeof tabObj.conversationId === "string" ? tabObj.conversationId : null + }); + } + return { + openTabs: validatedTabs, + activeTabId: typeof state.activeTabId === "string" ? state.activeTabId : null + }; + } +}; + +// src/features/chat/ClaudianView.ts +var import_obsidian42 = require("obsidian"); + +// src/features/chat/tabs/Tab.ts +var import_obsidian39 = require("obsidian"); + +// src/core/providers/modelRouting.ts +function getProviderForModel(model, settings11) { + return ProviderRegistry.resolveProviderForModel(model, settings11); +} + +// src/core/commands/builtInCommands.ts +var BUILT_IN_COMMANDS = [ + { + name: "clear", + aliases: ["new"], + description: "Start a new conversation", + action: "clear" + }, + { + name: "add-dir", + description: "Add external context directory", + action: "add-dir", + hasArgs: true, + argumentHint: "[path/to/directory]" + }, + { + name: "resume", + description: "Resume a previous conversation", + action: "resume", + requiredCapability: "supportsNativeHistory" + }, + { + name: "fork", + description: "Fork entire conversation to new session", + action: "fork", + requiredCapability: "supportsFork" + } +]; +var commandMap = /* @__PURE__ */ new Map(); +for (const cmd of BUILT_IN_COMMANDS) { + commandMap.set(cmd.name.toLowerCase(), cmd); + if (cmd.aliases) { + for (const alias of cmd.aliases) { + commandMap.set(alias.toLowerCase(), cmd); + } + } +} +function resolveCapabilities(context) { + if (typeof context !== "string") { + return context; + } + try { + return ProviderRegistry.getCapabilities(context); + } catch (e3) { + return null; + } +} +function isBuiltInCommandSupported(command, context) { + if (!command.requiredCapability || !context) { + return true; + } + const capabilities = resolveCapabilities(context); + return capabilities ? capabilities[command.requiredCapability] : false; +} +function detectBuiltInCommand(input) { + const trimmed = input.trim(); + if (!trimmed.startsWith("/")) return null; + const match = trimmed.match(/^\/([a-zA-Z0-9_-]+)(?:\s(.*))?$/); + if (!match) return null; + const cmdName = match[1].toLowerCase(); + const command = commandMap.get(cmdName); + if (!command) return null; + const args = (match[2] || "").trim(); + return { command, args }; +} +function getBuiltInCommandsForDropdown(context) { + return BUILT_IN_COMMANDS.filter((cmd) => isBuiltInCommandSupported(cmd, context)).map((cmd) => ({ + id: `builtin:${cmd.name}`, + name: cmd.name, + description: cmd.description, + content: "", + // Built-in commands don't have prompt content + argumentHint: cmd.argumentHint + })); +} + +// src/shared/components/SlashCommandDropdown.ts +var SlashCommandDropdown = class { + constructor(containerEl, inputEl, callbacks, options = {}) { + this.dropdownEl = null; + this.enabled = true; + this.triggerStartIndex = -1; + this.activeTriggerChar = "/"; + this.selectedIndex = 0; + this.filteredItems = []; + this.cachedProviderEntries = []; + this.providerEntriesFetched = false; + this.requestId = 0; + var _a3, _b2, _c, _d; + this.containerEl = containerEl; + this.inputEl = inputEl; + this.callbacks = callbacks; + this.isFixed = (_a3 = options.fixed) != null ? _a3 : false; + this.hiddenCommands = (_b2 = options.hiddenCommands) != null ? _b2 : /* @__PURE__ */ new Set(); + this.providerConfig = (_c = options.providerConfig) != null ? _c : null; + this.getProviderEntries = (_d = options.getProviderEntries) != null ? _d : null; + this.onInput = () => this.handleInputChange(); + this.inputEl.addEventListener("input", this.onInput); + } + setEnabled(enabled) { + this.enabled = enabled; + if (!enabled) { + this.hide(); + } + } + setHiddenCommands(commands) { + this.hiddenCommands = commands; + } + setProviderCatalog(config2, getEntries) { + this.providerConfig = config2; + this.getProviderEntries = getEntries; + this.cachedProviderEntries = []; + this.providerEntriesFetched = false; + this.requestId = 0; + } + handleInputChange() { + var _a3, _b2; + if (!this.enabled) return; + const text = this.getInputValue(); + const cursorPos = this.getCursorPosition(); + const textBeforeCursor = text.substring(0, cursorPos); + const triggerChars = (_b2 = (_a3 = this.providerConfig) == null ? void 0 : _a3.triggerChars) != null ? _b2 : ["/"]; + let triggerIndex = -1; + let triggerChar = ""; + for (let i3 = cursorPos - 1; i3 >= 0; i3--) { + const ch = textBeforeCursor.charAt(i3); + if (/\s/.test(ch)) break; + if (triggerChars.includes(ch)) { + if (i3 === 0 || /\s/.test(textBeforeCursor.charAt(i3 - 1))) { + triggerIndex = i3; + triggerChar = ch; + } + break; + } + } + if (triggerIndex === -1) { + this.hide(); + return; + } + const searchText = textBeforeCursor.substring(triggerIndex + 1); + if (/\s/.test(searchText)) { + this.hide(); + return; + } + this.triggerStartIndex = triggerIndex; + this.activeTriggerChar = triggerChar; + const isAtPosition0 = triggerIndex === 0; + this.showDropdown(searchText, isAtPosition0); + } + handleKeydown(e3) { + if (!this.enabled || !this.isVisible()) return false; + switch (e3.key) { + case "ArrowDown": + e3.preventDefault(); + this.navigate(1); + return true; + case "ArrowUp": + e3.preventDefault(); + this.navigate(-1); + return true; + case "Enter": + case "Tab": + if (this.filteredItems.length > 0) { + e3.preventDefault(); + this.selectItem(); + return true; + } + return false; + case "Escape": + e3.preventDefault(); + this.hide(); + return true; + } + return false; + } + isVisible() { + var _a3, _b2; + return (_b2 = (_a3 = this.dropdownEl) == null ? void 0 : _a3.hasClass("visible")) != null ? _b2 : false; + } + hide() { + if (this.dropdownEl) { + this.dropdownEl.removeClass("visible"); + } + this.triggerStartIndex = -1; + this.callbacks.onHide(); + } + destroy() { + this.inputEl.removeEventListener("input", this.onInput); + if (this.dropdownEl) { + this.dropdownEl.remove(); + this.dropdownEl = null; + } + } + resetSdkSkillsCache() { + this.cachedProviderEntries = []; + this.providerEntriesFetched = false; + this.requestId = 0; + } + getInputValue() { + return this.inputEl.value; + } + getCursorPosition() { + return this.inputEl.selectionStart || 0; + } + setInputValue(value) { + this.inputEl.value = value; + } + setCursorPosition(pos) { + this.inputEl.selectionStart = pos; + this.inputEl.selectionEnd = pos; + } + async showDropdown(searchText, isAtPosition0 = true) { + const currentRequest = ++this.requestId; + const searchLower = searchText.toLowerCase(); + await this.fetchProviderEntries(currentRequest); + if (currentRequest !== this.requestId) return; + const includeBuiltIns = isAtPosition0 && this.activeTriggerChar === "/"; + const allItems = this.buildItemList(includeBuiltIns); + this.filteredItems = allItems.filter( + (item) => { + var _a3; + return item.name.toLowerCase().includes(searchLower) || ((_a3 = item.description) == null ? void 0 : _a3.toLowerCase().includes(searchLower)); + } + ).sort((a3, b) => a3.name.localeCompare(b.name)); + if (currentRequest !== this.requestId) return; + if (searchText.length > 0 && this.filteredItems.length === 0) { + this.hide(); + return; + } + this.selectedIndex = 0; + this.render(); + } + async fetchProviderEntries(currentRequest) { + if (this.providerEntriesFetched || !this.getProviderEntries) return; + try { + const entries = await this.getProviderEntries(); + if (currentRequest !== this.requestId) return; + if (entries.length > 0) { + this.cachedProviderEntries = entries; + this.providerEntriesFetched = true; + } + } catch (e3) { + if (currentRequest !== this.requestId) return; + } + } + buildItemList(includeBuiltIns) { + var _a3; + const seenNames = /* @__PURE__ */ new Set(); + const items = []; + if (includeBuiltIns) { + const builtIns = getBuiltInCommandsForDropdown((_a3 = this.providerConfig) == null ? void 0 : _a3.providerId); + for (const cmd of builtIns) { + const nameLower = cmd.name.toLowerCase(); + if (!seenNames.has(nameLower)) { + seenNames.add(nameLower); + items.push({ + name: cmd.name, + description: cmd.description, + argumentHint: cmd.argumentHint, + content: cmd.content, + displayPrefix: "/", + insertPrefix: "/", + isBuiltIn: true, + slashCommand: cmd + }); + } + } + } + for (const entry of this.cachedProviderEntries) { + const nameLower = entry.name.toLowerCase(); + if (seenNames.has(nameLower) || this.hiddenCommands.has(nameLower)) { + continue; + } + seenNames.add(nameLower); + items.push({ + name: entry.name, + description: entry.description, + argumentHint: entry.argumentHint, + content: entry.content, + displayPrefix: entry.displayPrefix, + insertPrefix: entry.insertPrefix, + isBuiltIn: false, + providerEntry: entry, + slashCommand: { + id: entry.id, + name: entry.name, + description: entry.description, + content: entry.content, + argumentHint: entry.argumentHint, + allowedTools: entry.allowedTools, + model: entry.model, + source: entry.source, + kind: entry.kind, + disableModelInvocation: entry.disableModelInvocation, + userInvocable: entry.userInvocable, + context: entry.context, + agent: entry.agent, + hooks: entry.hooks + } + }); + } + return items; + } + render() { + if (!this.dropdownEl) { + this.dropdownEl = this.createDropdownElement(); + } + this.dropdownEl.empty(); + if (this.filteredItems.length === 0) { + const emptyEl = this.dropdownEl.createDiv({ cls: "claudian-slash-empty" }); + emptyEl.setText("No matching commands"); + } else { + for (let i3 = 0; i3 < this.filteredItems.length; i3++) { + const item = this.filteredItems[i3]; + const itemEl = this.dropdownEl.createDiv({ cls: "claudian-slash-item" }); + if (i3 === this.selectedIndex) { + itemEl.addClass("selected"); + } + const nameEl = itemEl.createSpan({ cls: "claudian-slash-name" }); + nameEl.setText(`${item.displayPrefix}${item.name}`); + if (item.argumentHint) { + const hintEl = itemEl.createSpan({ cls: "claudian-slash-hint" }); + hintEl.setText(normalizeArgumentHint(item.argumentHint)); + } + if (item.description) { + const descEl = itemEl.createDiv({ cls: "claudian-slash-desc" }); + descEl.setText(item.description); + } + itemEl.addEventListener("click", () => { + this.selectedIndex = i3; + this.selectItem(); + }); + itemEl.addEventListener("mouseenter", () => { + this.selectedIndex = i3; + this.updateSelection(); + }); + } + } + this.dropdownEl.addClass("visible"); + if (this.isFixed) { + this.positionFixed(); + } + } + createDropdownElement() { + if (this.isFixed) { + return this.containerEl.createDiv({ + cls: "claudian-slash-dropdown claudian-slash-dropdown-fixed" + }); + } else { + return this.containerEl.createDiv({ cls: "claudian-slash-dropdown" }); + } + } + positionFixed() { + if (!this.dropdownEl || !this.isFixed) return; + const inputRect = this.inputEl.getBoundingClientRect(); + this.dropdownEl.style.position = "fixed"; + this.dropdownEl.style.bottom = `${window.innerHeight - inputRect.top + 4}px`; + this.dropdownEl.style.left = `${inputRect.left}px`; + this.dropdownEl.style.right = "auto"; + this.dropdownEl.style.width = `${Math.max(inputRect.width, 280)}px`; + this.dropdownEl.style.zIndex = "10001"; + } + navigate(direction) { + const maxIndex = this.filteredItems.length - 1; + this.selectedIndex = Math.max(0, Math.min(maxIndex, this.selectedIndex + direction)); + this.updateSelection(); + } + updateSelection() { + var _a3; + const items = (_a3 = this.dropdownEl) == null ? void 0 : _a3.querySelectorAll(".claudian-slash-item"); + items == null ? void 0 : items.forEach((item, index) => { + if (index === this.selectedIndex) { + item.addClass("selected"); + item.scrollIntoView({ block: "nearest" }); + } else { + item.removeClass("selected"); + } + }); + } + selectItem() { + if (this.filteredItems.length === 0) return; + const selected = this.filteredItems[this.selectedIndex]; + if (!selected) return; + const text = this.getInputValue(); + const beforeTrigger = text.substring(0, this.triggerStartIndex); + const afterCursor = text.substring(this.getCursorPosition()); + const replacement = `${selected.insertPrefix}${selected.name} `; + this.setInputValue(beforeTrigger + replacement + afterCursor); + this.setCursorPosition(beforeTrigger.length + replacement.length); + this.hide(); + if (selected.slashCommand) { + this.callbacks.onSelect(selected.slashCommand); + } + this.inputEl.focus(); + } +}; + +// src/features/chat/tabs/Tab.ts +init_env(); +init_path(); + +// src/features/chat/controllers/contextRowVisibility.ts +function updateContextRowHasContent(contextRowEl) { + const editorIndicator = contextRowEl.querySelector(".claudian-selection-indicator"); + const browserIndicator = contextRowEl.querySelector(".claudian-browser-selection-indicator"); + const canvasIndicator = contextRowEl.querySelector(".claudian-canvas-indicator"); + const fileIndicator = contextRowEl.querySelector(".claudian-file-indicator"); + const imagePreview = contextRowEl.querySelector(".claudian-image-preview"); + const hasEditorSelection = (editorIndicator == null ? void 0 : editorIndicator.style.display) === "block"; + const hasBrowserSelection = browserIndicator !== null && browserIndicator.style.display === "block"; + const hasCanvasSelection = (canvasIndicator == null ? void 0 : canvasIndicator.style.display) === "block"; + const hasFileChips = (fileIndicator == null ? void 0 : fileIndicator.style.display) === "flex"; + const hasImageChips = (imagePreview == null ? void 0 : imagePreview.style.display) === "flex"; + contextRowEl.classList.toggle( + "has-content", + hasEditorSelection || hasBrowserSelection || hasCanvasSelection || hasFileChips || hasImageChips + ); +} + +// src/features/chat/controllers/BrowserSelectionController.ts +var BROWSER_SELECTION_POLL_INTERVAL = 250; +var BrowserSelectionController = class { + constructor(app, indicatorEl, inputEl, contextRowEl, onVisibilityChange) { + this.storedSelection = null; + this.pollInterval = null; + this.pollInFlight = false; + this.app = app; + this.indicatorEl = indicatorEl; + this.inputEl = inputEl; + this.contextRowEl = contextRowEl; + this.onVisibilityChange = onVisibilityChange != null ? onVisibilityChange : null; + } + start() { + if (this.pollInterval) return; + this.pollInterval = setInterval(() => { + void this.poll(); + }, BROWSER_SELECTION_POLL_INTERVAL); + } + stop() { + if (this.pollInterval) { + clearInterval(this.pollInterval); + this.pollInterval = null; + } + this.clear(); + } + async poll() { + if (this.pollInFlight) return; + this.pollInFlight = true; + try { + const browserView = this.getActiveBrowserView(); + if (!browserView) { + this.clearWhenInputIsNotFocused(); + return; + } + const selectedText = await this.extractSelectedText(browserView.containerEl); + if (selectedText) { + const nextContext = this.buildContext(browserView.view, browserView.viewType, browserView.containerEl, selectedText); + if (!this.isSameSelection(nextContext, this.storedSelection)) { + this.storedSelection = nextContext; + this.updateIndicator(); + } + } else { + this.clearWhenInputIsNotFocused(); + } + } catch (e3) { + } finally { + this.pollInFlight = false; + } + } + getActiveBrowserView() { + var _a3, _b2, _c, _d, _e; + const activeLeaf = (_c = this.app.workspace.activeLeaf) != null ? _c : (_b2 = (_a3 = this.app.workspace).getMostRecentLeaf) == null ? void 0 : _b2.call(_a3); + const activeView = activeLeaf == null ? void 0 : activeLeaf.view; + const containerEl = activeView.containerEl; + if (!activeView || !containerEl) return null; + const viewType = (_e = (_d = activeView.getViewType) == null ? void 0 : _d.call(activeView)) != null ? _e : ""; + if (!this.isBrowserLikeView(viewType, containerEl)) return null; + return { view: activeView, viewType, containerEl }; + } + isBrowserLikeView(viewType, containerEl) { + const normalized = viewType.toLowerCase(); + if (normalized.includes("surfing") || normalized.includes("browser") || normalized.includes("webview")) { + return true; + } + return Boolean(containerEl.querySelector("iframe, webview")); + } + async extractSelectedText(containerEl) { + const ownerDoc = containerEl.ownerDocument; + const docSelection = this.extractSelectionFromDocument(ownerDoc, containerEl); + if (docSelection) return docSelection; + const frameSelection = this.extractSelectionFromIframes(containerEl); + if (frameSelection) return frameSelection; + return await this.extractSelectionFromWebviews(containerEl); + } + extractSelectionFromDocument(doc, scopeEl) { + const selection = doc.getSelection(); + const selectedText = selection == null ? void 0 : selection.toString().trim(); + if (selectedText) { + const anchorNode = selection == null ? void 0 : selection.anchorNode; + const focusNode = selection == null ? void 0 : selection.focusNode; + if (anchorNode && scopeEl.contains(anchorNode) || focusNode && scopeEl.contains(focusNode)) { + return selectedText; + } + } + return this.extractSelectionFromActiveInput(doc, scopeEl); + } + extractSelectionFromActiveInput(doc, scopeEl) { + const activeEl = doc.activeElement; + if (!activeEl || !scopeEl.contains(activeEl)) return null; + if (activeEl instanceof HTMLTextAreaElement || activeEl instanceof HTMLInputElement) { + const { value, selectionStart, selectionEnd } = activeEl; + if (typeof selectionStart !== "number" || typeof selectionEnd !== "number" || selectionStart === selectionEnd) return null; + return value.slice(selectionStart, selectionEnd).trim() || null; + } + return null; + } + extractSelectionFromIframes(containerEl) { + var _a3, _b2; + const iframes = Array.from(containerEl.querySelectorAll("iframe")); + for (const iframe of iframes) { + try { + const frameDoc = (_b2 = iframe.contentDocument) != null ? _b2 : (_a3 = iframe.contentWindow) == null ? void 0 : _a3.document; + if (!frameDoc || !frameDoc.body) continue; + const frameSelection = this.extractSelectionFromDocument(frameDoc, frameDoc.body); + if (frameSelection) return frameSelection; + } catch (e3) { + } + } + return null; + } + async extractSelectionFromWebviews(containerEl) { + const webviews = Array.from(containerEl.querySelectorAll("webview")); + for (const webview of webviews) { + if (typeof webview.executeJavaScript !== "function") continue; + try { + const result = await webview.executeJavaScript( + 'window.getSelection ? window.getSelection().toString() : ""', + true + ); + if (typeof result === "string" && result.trim()) { + return result.trim(); + } + } catch (e3) { + } + } + return null; + } + buildContext(view, viewType, containerEl, selectedText) { + const title = this.extractViewTitle(view); + const url2 = this.extractViewUrl(view, containerEl); + const source = url2 ? `browser:${url2}` : `browser:${viewType || "unknown"}`; + return { + source, + selectedText, + title, + url: url2 + }; + } + extractViewTitle(view) { + var _a3; + const displayText = (_a3 = view.getDisplayText) == null ? void 0 : _a3.call(view); + if (displayText == null ? void 0 : displayText.trim()) return displayText.trim(); + const title = view.title; + return typeof title === "string" && title.trim() ? title.trim() : void 0; + } + extractViewUrl(view, containerEl) { + const rawView = view; + const directCandidates = [ + rawView.url, + rawView.currentUrl, + rawView.currentURL, + rawView.src + ]; + for (const candidate of directCandidates) { + if (typeof candidate === "string" && candidate.trim()) { + return candidate.trim(); + } + } + const embeddableEl = containerEl.querySelector("iframe[src], webview[src]"); + const embeddedSrc = embeddableEl == null ? void 0 : embeddableEl.getAttribute("src"); + if (embeddedSrc == null ? void 0 : embeddedSrc.trim()) { + return embeddedSrc.trim(); + } + return void 0; + } + isSameSelection(left, right) { + if (!left || !right) return false; + return left.source === right.source && left.selectedText === right.selectedText && left.title === right.title && left.url === right.url; + } + clearWhenInputIsNotFocused() { + if (document.activeElement === this.inputEl) return; + if (this.storedSelection) { + this.storedSelection = null; + this.updateIndicator(); + } + } + updateIndicator() { + if (!this.indicatorEl) return; + if (this.storedSelection) { + const lineCount = this.storedSelection.selectedText.split(/\r?\n/).length; + const lineLabel = lineCount === 1 ? "line" : "lines"; + this.indicatorEl.textContent = `${lineCount} ${lineLabel} selected`; + this.indicatorEl.setAttribute("title", this.buildIndicatorTitle()); + this.indicatorEl.style.display = "block"; + } else { + this.indicatorEl.style.display = "none"; + this.indicatorEl.textContent = ""; + this.indicatorEl.removeAttribute("title"); + } + this.updateContextRowVisibility(); + } + buildIndicatorTitle() { + if (!this.storedSelection) return ""; + const charCount = this.storedSelection.selectedText.length; + const charLabel = charCount === 1 ? "char" : "chars"; + const lines = [`${charCount} ${charLabel} selected`, `source=${this.storedSelection.source}`]; + if (this.storedSelection.title) { + lines.push(`title=${this.storedSelection.title}`); + } + if (this.storedSelection.url) { + lines.push(this.storedSelection.url); + } + return lines.join("\n"); + } + updateContextRowVisibility() { + var _a3; + if (!this.contextRowEl) return; + updateContextRowHasContent(this.contextRowEl); + (_a3 = this.onVisibilityChange) == null ? void 0 : _a3.call(this); + } + getContext() { + return this.storedSelection; + } + hasSelection() { + return this.storedSelection !== null; + } + clear() { + this.storedSelection = null; + this.updateIndicator(); + } +}; + +// src/features/chat/controllers/CanvasSelectionController.ts +var CANVAS_POLL_INTERVAL = 250; +var CanvasSelectionController = class { + constructor(app, indicatorEl, inputEl, contextRowEl, onVisibilityChange) { + this.storedSelection = null; + this.pollInterval = null; + this.app = app; + this.indicatorEl = indicatorEl; + this.inputEl = inputEl; + this.contextRowEl = contextRowEl; + this.onVisibilityChange = onVisibilityChange != null ? onVisibilityChange : null; + } + start() { + if (this.pollInterval) return; + this.pollInterval = setInterval(() => this.poll(), CANVAS_POLL_INTERVAL); + } + stop() { + if (this.pollInterval) { + clearInterval(this.pollInterval); + this.pollInterval = null; + } + this.clear(); + } + poll() { + var _a3; + const canvasView = this.getCanvasView(); + if (!canvasView) return; + const canvas = canvasView.canvas; + if (!(canvas == null ? void 0 : canvas.selection)) return; + const selection = canvas.selection; + const canvasPath = (_a3 = canvasView.file) == null ? void 0 : _a3.path; + if (!canvasPath) return; + const nodeIds = [...selection].map((node) => node.id).filter(Boolean); + if (nodeIds.length > 0) { + const sameSelection = this.storedSelection && this.storedSelection.canvasPath === canvasPath && this.storedSelection.nodeIds.length === nodeIds.length && this.storedSelection.nodeIds.every((id) => nodeIds.includes(id)); + if (!sameSelection) { + this.storedSelection = { canvasPath, nodeIds }; + this.updateIndicator(); + } + } else if (document.activeElement !== this.inputEl) { + if (this.storedSelection) { + this.storedSelection = null; + this.updateIndicator(); + } + } + } + getCanvasView() { + var _a3, _b2, _c, _d; + const activeLeaf = (_c = this.app.workspace.activeLeaf) != null ? _c : (_b2 = (_a3 = this.app.workspace).getMostRecentLeaf) == null ? void 0 : _b2.call(_a3); + const activeView = activeLeaf == null ? void 0 : activeLeaf.view; + if (((_d = activeView == null ? void 0 : activeView.getViewType) == null ? void 0 : _d.call(activeView)) === "canvas" && activeView.file) { + return activeView; + } + const leaves = this.app.workspace.getLeavesOfType("canvas"); + if (leaves.length === 0) return null; + const leaf = leaves.find((l3) => l3.view.file); + return leaf ? leaf.view : null; + } + updateIndicator() { + if (!this.indicatorEl) return; + if (this.storedSelection) { + const { nodeIds } = this.storedSelection; + this.indicatorEl.textContent = nodeIds.length === 1 ? `node "${nodeIds[0]}" selected` : `${nodeIds.length} nodes selected`; + this.indicatorEl.style.display = "block"; + } else { + this.indicatorEl.style.display = "none"; + } + this.updateContextRowVisibility(); + } + updateContextRowVisibility() { + var _a3; + if (!this.contextRowEl) return; + updateContextRowHasContent(this.contextRowEl); + (_a3 = this.onVisibilityChange) == null ? void 0 : _a3.call(this); + } + getContext() { + if (!this.storedSelection) return null; + return { + canvasPath: this.storedSelection.canvasPath, + nodeIds: [...this.storedSelection.nodeIds] + }; + } + hasSelection() { + return this.storedSelection !== null; + } + clear() { + this.storedSelection = null; + this.updateIndicator(); + } +}; + +// src/features/chat/controllers/ConversationController.ts +var import_obsidian19 = require("obsidian"); + +// src/features/chat/rendering/collapsible.ts +function setupCollapsible(wrapperEl, headerEl, contentEl, state, options = {}) { + const { initiallyExpanded = false, onToggle, baseAriaLabel } = options; + const updateAriaLabel = (isExpanded) => { + if (baseAriaLabel) { + const action = isExpanded ? "click to collapse" : "click to expand"; + headerEl.setAttribute("aria-label", `${baseAriaLabel} - ${action}`); + } + }; + state.isExpanded = initiallyExpanded; + if (initiallyExpanded) { + wrapperEl.addClass("expanded"); + contentEl.style.display = "block"; + headerEl.setAttribute("aria-expanded", "true"); + } else { + contentEl.style.display = "none"; + headerEl.setAttribute("aria-expanded", "false"); + } + updateAriaLabel(initiallyExpanded); + const toggleExpand = () => { + state.isExpanded = !state.isExpanded; + if (state.isExpanded) { + wrapperEl.addClass("expanded"); + contentEl.style.display = "block"; + headerEl.setAttribute("aria-expanded", "true"); + } else { + wrapperEl.removeClass("expanded"); + contentEl.style.display = "none"; + headerEl.setAttribute("aria-expanded", "false"); + } + updateAriaLabel(state.isExpanded); + onToggle == null ? void 0 : onToggle(state.isExpanded); + }; + headerEl.addEventListener("click", toggleExpand); + headerEl.addEventListener("keydown", (e3) => { + if (e3.key === "Enter" || e3.key === " ") { + e3.preventDefault(); + toggleExpand(); + } + }); +} +function collapseElement(wrapperEl, headerEl, contentEl, state) { + state.isExpanded = false; + wrapperEl.removeClass("expanded"); + contentEl.style.display = "none"; + headerEl.setAttribute("aria-expanded", "false"); +} + +// src/features/chat/rendering/ThinkingBlockRenderer.ts +function createThinkingBlock(parentEl, renderContent) { + const wrapperEl = parentEl.createDiv({ cls: "claudian-thinking-block" }); + const header = wrapperEl.createDiv({ cls: "claudian-thinking-header" }); + header.setAttribute("tabindex", "0"); + header.setAttribute("role", "button"); + header.setAttribute("aria-expanded", "false"); + header.setAttribute("aria-label", "Extended thinking - click to expand"); + const labelEl = header.createSpan({ cls: "claudian-thinking-label" }); + const startTime = Date.now(); + labelEl.setText("Thinking 0s..."); + const timerInterval = setInterval(() => { + const elapsed = Math.floor((Date.now() - startTime) / 1e3); + labelEl.setText(`Thinking ${elapsed}s...`); + }, 1e3); + const contentEl = wrapperEl.createDiv({ cls: "claudian-thinking-content" }); + const state = { + wrapperEl, + contentEl, + labelEl, + content: "", + startTime, + timerInterval, + isExpanded: false + }; + setupCollapsible(wrapperEl, header, contentEl, state); + return state; +} +async function appendThinkingContent(state, content, renderContent) { + state.content += content; + await renderContent(state.contentEl, state.content); +} +function finalizeThinkingBlock(state) { + if (state.timerInterval) { + clearInterval(state.timerInterval); + state.timerInterval = null; + } + const durationSeconds = Math.floor((Date.now() - state.startTime) / 1e3); + state.labelEl.setText(`Thought for ${durationSeconds}s`); + const header = state.wrapperEl.querySelector(".claudian-thinking-header"); + if (header) { + collapseElement(state.wrapperEl, header, state.contentEl, state); + } + return durationSeconds; +} +function cleanupThinkingBlock(state) { + if (state == null ? void 0 : state.timerInterval) { + clearInterval(state.timerInterval); + } +} +function renderStoredThinkingBlock(parentEl, content, durationSeconds, renderContent) { + const wrapperEl = parentEl.createDiv({ cls: "claudian-thinking-block" }); + const header = wrapperEl.createDiv({ cls: "claudian-thinking-header" }); + header.setAttribute("tabindex", "0"); + header.setAttribute("role", "button"); + header.setAttribute("aria-label", "Extended thinking - click to expand"); + const labelEl = header.createSpan({ cls: "claudian-thinking-label" }); + const labelText = durationSeconds !== void 0 ? `Thought for ${durationSeconds}s` : "Thought"; + labelEl.setText(labelText); + const contentEl = wrapperEl.createDiv({ cls: "claudian-thinking-content" }); + renderContent(contentEl, content); + const state = { isExpanded: false }; + setupCollapsible(wrapperEl, header, contentEl, state); + return wrapperEl; +} + +// src/features/chat/rewind.ts +function findRewindContext(messages, userIndex) { + let prevAssistantUuid; + for (let i3 = userIndex - 1; i3 >= 0; i3--) { + if (messages[i3].role === "assistant" && messages[i3].assistantMessageId) { + prevAssistantUuid = messages[i3].assistantMessageId; + break; + } + } + let hasResponse = false; + for (let i3 = userIndex + 1; i3 < messages.length; i3++) { + if (messages[i3].role === "user") break; + if (messages[i3].role === "assistant" && messages[i3].assistantMessageId) { + hasResponse = true; + break; + } + } + return { prevAssistantUuid, hasResponse }; +} + +// src/features/chat/controllers/ConversationController.ts +var ConversationController = class { + constructor(deps, callbacks = {}) { + this.deps = deps; + this.callbacks = callbacks; + } + getAgentService() { + var _a3, _b2, _c; + return (_c = (_b2 = (_a3 = this.deps).getAgentService) == null ? void 0 : _b2.call(_a3)) != null ? _c : null; + } + // ============================================ + // Conversation Lifecycle + // ============================================ + /** + * Resets to entry point state (New Chat). + * + * Entry point is a blank UI state - no conversation is created until the + * first message is sent. This prevents empty conversations cluttering history. + */ + async createNew(options = {}) { + var _a3, _b2, _c, _d, _e, _f, _g, _h, _i, _j2, _k; + const { plugin, state, subagentManager } = this.deps; + const force = !!options.force; + if (state.isStreaming && !force) return; + if (state.isCreatingConversation) return; + if (state.isSwitchingConversation) return; + state.isCreatingConversation = true; + try { + (_b2 = (_a3 = this.deps).dismissPendingInlinePrompts) == null ? void 0 : _b2.call(_a3); + if (force && state.isStreaming) { + state.cancelRequested = true; + state.bumpStreamGeneration(); + (_c = this.getAgentService()) == null ? void 0 : _c.cancel(); + } + if (state.currentConversationId && state.messages.length > 0) { + await this.save(); + } + subagentManager.orphanAllActive(); + subagentManager.clear(); + cleanupThinkingBlock(state.currentThinkingState); + state.currentContentEl = null; + state.currentTextEl = null; + state.currentTextContent = ""; + state.currentThinkingState = null; + state.toolCallElements.clear(); + state.writeEditStates.clear(); + state.isStreaming = false; + state.currentConversationId = null; + state.clearMessages(); + state.usage = null; + state.currentTodos = null; + state.pendingNewSessionPlan = null; + state.planFilePath = null; + state.prePlanPermissionMode = null; + state.autoScrollEnabled = (_d = plugin.settings.enableAutoScroll) != null ? _d : true; + (_e = this.getAgentService()) == null ? void 0 : _e.syncConversationState( + null, + plugin.settings.persistentExternalContextPaths || [] + ); + const messagesEl = this.deps.getMessagesEl(); + messagesEl.empty(); + const welcomeEl = messagesEl.createDiv({ cls: "claudian-welcome" }); + welcomeEl.createDiv({ cls: "claudian-welcome-greeting", text: this.getGreeting() }); + this.deps.setWelcomeEl(welcomeEl); + (_f = this.deps.getStatusPanel()) == null ? void 0 : _f.remount(); + this.deps.getInputEl().value = ""; + const fileCtx = this.deps.getFileContextManager(); + fileCtx == null ? void 0 : fileCtx.resetForNewConversation(); + fileCtx == null ? void 0 : fileCtx.autoAttachActiveFile(); + (_g = this.deps.getImageContextManager()) == null ? void 0 : _g.clearImages(); + (_h = this.deps.getMcpServerSelector()) == null ? void 0 : _h.clearEnabled(); + (_i = this.deps.getExternalContextSelector()) == null ? void 0 : _i.clearExternalContexts( + plugin.settings.persistentExternalContextPaths || [] + ); + this.deps.clearQueuedMessage(); + (_k = (_j2 = this.callbacks).onNewConversation) == null ? void 0 : _k.call(_j2); + } finally { + state.isCreatingConversation = false; + } + } + /** + * Loads the current tab conversation, or starts at entry point if none. + * + * Entry point (no conversation) shows welcome screen without + * creating a conversation. Conversation is created lazily on first message. + */ + async loadActive() { + var _a3, _b2, _c, _d, _e, _f, _g, _h, _i, _j2; + const { plugin, state, renderer } = this.deps; + const conversationId = state.currentConversationId; + const conversation = conversationId ? await plugin.getConversationById(conversationId) : null; + if (!conversation) { + state.currentConversationId = null; + state.clearMessages(); + state.usage = null; + state.currentTodos = null; + state.pendingNewSessionPlan = null; + state.planFilePath = null; + state.prePlanPermissionMode = null; + state.autoScrollEnabled = (_a3 = plugin.settings.enableAutoScroll) != null ? _a3 : true; + (_b2 = this.getAgentService()) == null ? void 0 : _b2.syncConversationState( + null, + plugin.settings.persistentExternalContextPaths || [] + ); + const fileCtx = this.deps.getFileContextManager(); + fileCtx == null ? void 0 : fileCtx.resetForNewConversation(); + fileCtx == null ? void 0 : fileCtx.autoAttachActiveFile(); + (_c = this.deps.getExternalContextSelector()) == null ? void 0 : _c.clearExternalContexts( + plugin.settings.persistentExternalContextPaths || [] + ); + (_d = this.deps.getMcpServerSelector()) == null ? void 0 : _d.clearEnabled(); + const welcomeEl = renderer.renderMessages( + [], + () => this.getGreeting() + ); + this.deps.setWelcomeEl(welcomeEl); + this.updateWelcomeVisibility(); + (_f = (_e = this.callbacks).onConversationLoaded) == null ? void 0 : _f.call(_e); + return; + } + await ((_h = (_g = this.deps).ensureServiceForConversation) == null ? void 0 : _h.call(_g, conversation)); + this.restoreConversation(conversation, { autoAttachFile: true }); + this.updateWelcomeVisibility(); + (_j2 = (_i = this.callbacks).onConversationLoaded) == null ? void 0 : _j2.call(_i); + } + /** Switches to a different conversation. */ + async switchTo(id) { + var _a3, _b2, _c, _d, _e, _f, _g; + const { plugin, state, subagentManager } = this.deps; + if (id === state.currentConversationId) return; + if (state.isStreaming) return; + if (state.isSwitchingConversation) return; + if (state.isCreatingConversation) return; + state.isSwitchingConversation = true; + try { + (_b2 = (_a3 = this.deps).dismissPendingInlinePrompts) == null ? void 0 : _b2.call(_a3); + await this.save(); + subagentManager.orphanAllActive(); + subagentManager.clear(); + const conversation = await plugin.switchConversation(id); + if (!conversation) { + return; + } + await ((_d = (_c = this.deps).ensureServiceForConversation) == null ? void 0 : _d.call(_c, conversation)); + this.deps.getInputEl().value = ""; + this.deps.clearQueuedMessage(); + this.restoreConversation(conversation); + (_e = this.deps.getHistoryDropdown()) == null ? void 0 : _e.removeClass("visible"); + this.updateWelcomeVisibility(); + (_g = (_f = this.callbacks).onConversationSwitched) == null ? void 0 : _g.call(_f); + } finally { + state.isSwitchingConversation = false; + } + } + async rewind(userMessageId) { + var _a3, _b2, _c; + const { plugin, state, renderer } = this.deps; + const agentServiceForCheck = this.getAgentService(); + if (agentServiceForCheck && !agentServiceForCheck.getCapabilities().supportsRewind) { + new import_obsidian19.Notice(t("chat.rewind.failed", { error: "Rewind is not supported by this provider." })); + return; + } + if (state.isStreaming) { + new import_obsidian19.Notice(t("chat.rewind.unavailableStreaming")); + return; + } + const msgs = state.messages; + const userIdx = msgs.findIndex((m3) => m3.id === userMessageId); + if (userIdx === -1) { + new import_obsidian19.Notice(t("chat.rewind.failed", { error: "Message not found" })); + return; + } + const userMsg = msgs[userIdx]; + if (!userMsg.userMessageId) { + new import_obsidian19.Notice(t("chat.rewind.unavailableNoUuid")); + return; + } + const rewindCtx = findRewindContext(msgs, userIdx); + if (!rewindCtx.hasResponse || !rewindCtx.prevAssistantUuid) { + new import_obsidian19.Notice(t("chat.rewind.unavailableNoUuid")); + return; + } + const prevAssistantUuid = rewindCtx.prevAssistantUuid; + const confirmed = await confirm2( + plugin.app, + t("chat.rewind.confirmMessage"), + t("chat.rewind.confirmButton") + ); + if (!confirmed) return; + if (state.isStreaming) { + new import_obsidian19.Notice(t("chat.rewind.unavailableStreaming")); + return; + } + const agentService = this.getAgentService(); + if (!agentService) { + new import_obsidian19.Notice(t("chat.rewind.failed", { error: "Agent service not available" })); + return; + } + let result; + try { + result = await agentService.rewind(userMsg.userMessageId, prevAssistantUuid); + } catch (e3) { + new import_obsidian19.Notice(t("chat.rewind.failed", { error: e3 instanceof Error ? e3.message : "Unknown error" })); + return; + } + if (!result.canRewind) { + new import_obsidian19.Notice(t("chat.rewind.cannot", { error: (_a3 = result.error) != null ? _a3 : "Unknown error" })); + return; + } + state.truncateAt(userMessageId); + const inputEl = this.deps.getInputEl(); + inputEl.value = userMsg.content; + inputEl.focus(); + const welcomeEl = renderer.renderMessages(state.messages, () => this.getGreeting()); + this.deps.setWelcomeEl(welcomeEl); + this.updateWelcomeVisibility(); + const filesChanged = (_c = (_b2 = result.filesChanged) == null ? void 0 : _b2.length) != null ? _c : 0; + let saveError = null; + try { + await this.save(false, { resumeAtMessageId: prevAssistantUuid }); + } catch (e3) { + saveError = e3 instanceof Error ? e3.message : "Failed to save"; + } + if (saveError) { + new import_obsidian19.Notice(t("chat.rewind.noticeSaveFailed", { count: String(filesChanged), error: saveError })); + return; + } + new import_obsidian19.Notice(t("chat.rewind.notice", { count: String(filesChanged) })); + } + /** + * Saves the current conversation. + * + * If we're at an entry point (no conversation yet) and have messages, + * creates a new conversation first (lazy creation). + * + * For native sessions (new conversations with sessionId from SDK), + * only metadata is saved - the SDK handles message persistence. + */ + async save(updateLastResponse = false, options) { + var _a3, _b2, _c, _d, _e; + const { plugin, state } = this.deps; + if (!state.currentConversationId && state.messages.length === 0) { + return; + } + const agentService = this.getAgentService(); + const sessionInvalidated = (_b2 = (_a3 = agentService == null ? void 0 : agentService.consumeSessionInvalidation) == null ? void 0 : _a3.call(agentService)) != null ? _b2 : false; + if (!state.currentConversationId && state.messages.length > 0) { + const initialSessionId = (_c = agentService == null ? void 0 : agentService.getSessionId()) != null ? _c : void 0; + const conversation2 = await plugin.createConversation({ + providerId: agentService == null ? void 0 : agentService.providerId, + sessionId: initialSessionId + }); + state.currentConversationId = conversation2.id; + } + const fileCtx = this.deps.getFileContextManager(); + const currentNote = (fileCtx == null ? void 0 : fileCtx.getCurrentNotePath()) || void 0; + const externalContextSelector = this.deps.getExternalContextSelector(); + const externalContextPaths = (_d = externalContextSelector == null ? void 0 : externalContextSelector.getExternalContexts()) != null ? _d : []; + const mcpServerSelector = this.deps.getMcpServerSelector(); + const enabledMcpServers = mcpServerSelector ? Array.from(mcpServerSelector.getEnabledServers()) : []; + const conversation = plugin.getConversationSync(state.currentConversationId); + const { updates: sessionUpdates } = agentService ? agentService.buildSessionUpdates({ conversation, sessionInvalidated }) : { updates: {} }; + const updates = { + ...sessionUpdates, + messages: state.messages, + currentNote, + externalContextPaths: externalContextPaths.length > 0 ? externalContextPaths : void 0, + usage: (_e = state.usage) != null ? _e : void 0, + enabledMcpServers: enabledMcpServers.length > 0 ? enabledMcpServers : void 0 + }; + if (updateLastResponse) { + updates.lastResponseAt = Date.now(); + } + if (options) { + updates.resumeAtMessageId = options.resumeAtMessageId; + } + await plugin.updateConversation(state.currentConversationId, updates); + } + /** + * Shared logic for restoring a conversation into the current tab. + * Used by both loadActive() and switchTo() to avoid duplication. + */ + restoreConversation(conversation, options) { + var _a3, _b2, _c; + const { plugin, state, renderer } = this.deps; + state.currentConversationId = conversation.id; + state.messages = [...conversation.messages]; + state.usage = (_a3 = conversation.usage) != null ? _a3 : null; + state.autoScrollEnabled = (_b2 = plugin.settings.enableAutoScroll) != null ? _b2 : true; + state.currentTodos = null; + const hasMessages = state.messages.length > 0; + const externalContextPaths = hasMessages ? conversation.externalContextPaths || [] : plugin.settings.persistentExternalContextPaths || []; + (_c = this.getAgentService()) == null ? void 0 : _c.syncConversationState(conversation, externalContextPaths); + const fileCtx = this.deps.getFileContextManager(); + fileCtx == null ? void 0 : fileCtx.resetForLoadedConversation(hasMessages); + if (conversation.currentNote) { + fileCtx == null ? void 0 : fileCtx.setCurrentNote(conversation.currentNote); + } else if (!hasMessages && (options == null ? void 0 : options.autoAttachFile)) { + fileCtx == null ? void 0 : fileCtx.autoAttachActiveFile(); + } + this.restoreExternalContextPaths(conversation.externalContextPaths, !hasMessages); + const mcpServerSelector = this.deps.getMcpServerSelector(); + if (conversation.enabledMcpServers && conversation.enabledMcpServers.length > 0) { + mcpServerSelector == null ? void 0 : mcpServerSelector.setEnabledServers(conversation.enabledMcpServers); + } else { + mcpServerSelector == null ? void 0 : mcpServerSelector.clearEnabled(); + } + const welcomeEl = renderer.renderMessages( + state.messages, + () => this.getGreeting() + ); + this.deps.setWelcomeEl(welcomeEl); + } + /** + * Restores external context paths based on session state. + * New or empty sessions get current persistent paths from settings. + * Sessions with messages restore exactly what was saved. + */ + restoreExternalContextPaths(savedPaths, isEmptySession) { + const { plugin } = this.deps; + const externalContextSelector = this.deps.getExternalContextSelector(); + if (!externalContextSelector) { + return; + } + if (isEmptySession) { + externalContextSelector.clearExternalContexts( + plugin.settings.persistentExternalContextPaths || [] + ); + } else { + externalContextSelector.setExternalContexts(savedPaths || []); + } + } + // ============================================ + // History Dropdown + // ============================================ + toggleHistoryDropdown() { + const dropdown = this.deps.getHistoryDropdown(); + if (!dropdown) return; + const isVisible = dropdown.hasClass("visible"); + if (isVisible) { + dropdown.removeClass("visible"); + } else { + this.updateHistoryDropdown(); + dropdown.addClass("visible"); + } + } + updateHistoryDropdown() { + const dropdown = this.deps.getHistoryDropdown(); + if (!dropdown) return; + this.renderHistoryItems(dropdown, { + onSelectConversation: (id) => this.switchTo(id), + onRerender: () => this.updateHistoryDropdown() + }); + } + /** + * Renders history dropdown items to a container. + * Shared implementation for updateHistoryDropdown() and renderHistoryDropdown(). + */ + renderHistoryItems(container, options) { + var _a3; + const { plugin, state } = this.deps; + container.empty(); + const dropdownHeader = container.createDiv({ cls: "claudian-history-header" }); + dropdownHeader.createSpan({ text: "Conversations" }); + const list = container.createDiv({ cls: "claudian-history-list" }); + const allConversations = plugin.getConversationList(); + if (allConversations.length === 0) { + list.createDiv({ cls: "claudian-history-empty", text: "No conversations" }); + return; + } + const conversations = [...allConversations].sort((a3, b) => { + var _a4, _b2; + return ((_a4 = b.lastResponseAt) != null ? _a4 : b.createdAt) - ((_b2 = a3.lastResponseAt) != null ? _b2 : a3.createdAt); + }); + for (const conv of conversations) { + const isCurrent = conv.id === state.currentConversationId; + const item = list.createDiv({ + cls: `claudian-history-item${isCurrent ? " active" : ""}` + }); + const iconEl = item.createDiv({ cls: "claudian-history-item-icon" }); + (0, import_obsidian19.setIcon)(iconEl, isCurrent ? "message-square-dot" : "message-square"); + const content = item.createDiv({ cls: "claudian-history-item-content" }); + const titleEl = content.createDiv({ cls: "claudian-history-item-title", text: conv.title }); + titleEl.setAttribute("title", conv.title); + content.createDiv({ + cls: "claudian-history-item-date", + text: isCurrent ? "Current session" : this.formatDate((_a3 = conv.lastResponseAt) != null ? _a3 : conv.createdAt) + }); + if (!isCurrent) { + content.addEventListener("click", async (e3) => { + e3.stopPropagation(); + try { + await options.onSelectConversation(conv.id); + } catch (e4) { + new import_obsidian19.Notice("Failed to load conversation"); + } + }); + } + const actions = item.createDiv({ cls: "claudian-history-item-actions" }); + if (conv.titleGenerationStatus === "pending") { + const loadingEl = actions.createEl("span", { cls: "claudian-action-btn claudian-action-loading" }); + (0, import_obsidian19.setIcon)(loadingEl, "loader-2"); + loadingEl.setAttribute("aria-label", "Generating title..."); + } else if (conv.titleGenerationStatus === "failed") { + const regenerateBtn = actions.createEl("button", { cls: "claudian-action-btn" }); + (0, import_obsidian19.setIcon)(regenerateBtn, "refresh-cw"); + regenerateBtn.setAttribute("aria-label", "Regenerate title"); + regenerateBtn.addEventListener("click", async (e3) => { + e3.stopPropagation(); + try { + await this.regenerateTitle(conv.id); + } catch (e4) { + new import_obsidian19.Notice("Failed to regenerate response"); + } + }); + } + const renameBtn = actions.createEl("button", { cls: "claudian-action-btn" }); + (0, import_obsidian19.setIcon)(renameBtn, "pencil"); + renameBtn.setAttribute("aria-label", "Rename"); + renameBtn.addEventListener("click", (e3) => { + e3.stopPropagation(); + this.showRenameInput(item, conv.id, conv.title); + }); + const deleteBtn = actions.createEl("button", { cls: "claudian-action-btn claudian-delete-btn" }); + (0, import_obsidian19.setIcon)(deleteBtn, "trash-2"); + deleteBtn.setAttribute("aria-label", "Delete"); + deleteBtn.addEventListener("click", async (e3) => { + e3.stopPropagation(); + if (state.isStreaming) return; + try { + await plugin.deleteConversation(conv.id); + options.onRerender(); + if (conv.id === state.currentConversationId) { + await this.loadActive(); + } + } catch (e4) { + new import_obsidian19.Notice("Failed to delete conversation"); + } + }); + } + } + /** Shows inline rename input for a conversation. */ + showRenameInput(item, convId, currentTitle) { + const titleEl = item.querySelector(".claudian-history-item-title"); + if (!titleEl) return; + const input = document.createElement("input"); + input.type = "text"; + input.className = "claudian-rename-input"; + input.value = currentTitle; + titleEl.replaceWith(input); + input.focus(); + input.select(); + const finishRename = async () => { + try { + const newTitle = input.value.trim() || currentTitle; + await this.deps.plugin.renameConversation(convId, newTitle); + this.updateHistoryDropdown(); + } catch (e3) { + new import_obsidian19.Notice("Failed to rename conversation"); + } + }; + input.addEventListener("blur", finishRename); + input.addEventListener("keydown", async (e3) => { + if (e3.key === "Enter" && !e3.isComposing) { + input.blur(); + } else if (e3.key === "Escape" && !e3.isComposing) { + input.value = currentTitle; + input.blur(); + } + }); + } + // ============================================ + // Welcome & Greeting + // ============================================ + /** Generates a dynamic greeting based on time/day. */ + getGreeting() { + var _a3; + const now = /* @__PURE__ */ new Date(); + const hour = now.getHours(); + const day = now.getDay(); + const name = (_a3 = this.deps.plugin.settings.userName) == null ? void 0 : _a3.trim(); + const personalize = (base, noNameFallback) => name ? `${base}, ${name}` : noNameFallback != null ? noNameFallback : base; + const dayGreetings = { + 0: [personalize("Happy Sunday"), "Sunday session?", "Welcome to the weekend"], + 1: [personalize("Happy Monday"), personalize("Back at it", "Back at it!")], + 2: [personalize("Happy Tuesday")], + 3: [personalize("Happy Wednesday")], + 4: [personalize("Happy Thursday")], + 5: [personalize("Happy Friday"), personalize("That Friday feeling")], + 6: [personalize("Happy Saturday", "Happy Saturday!"), personalize("Welcome to the weekend")] + }; + const getTimeGreetings = () => { + if (hour >= 5 && hour < 12) { + return [personalize("Good morning"), "Coffee and Claudian time?"]; + } else if (hour >= 12 && hour < 18) { + return [personalize("Good afternoon"), personalize("Hey there"), personalize("How's it going") + "?"]; + } else if (hour >= 18 && hour < 22) { + return [personalize("Good evening"), personalize("Evening"), personalize("How was your day") + "?"]; + } else { + return ["Hello, night owl", personalize("Evening")]; + } + }; + const generalGreetings = [ + personalize("Hey there"), + name ? `Hi ${name}, how are you?` : "Hi, how are you?", + personalize("How's it going") + "?", + personalize("Welcome back") + "!", + personalize("What's new") + "?", + ...name ? [`${name} returns!`] : [], + "You are absolutely right!" + ]; + const allGreetings = [ + ...dayGreetings[day] || [], + ...getTimeGreetings(), + ...generalGreetings + ]; + return allGreetings[Math.floor(Math.random() * allGreetings.length)]; + } + /** Updates welcome element visibility based on message count. */ + updateWelcomeVisibility() { + const welcomeEl = this.deps.getWelcomeEl(); + if (!welcomeEl) return; + if (this.deps.state.messages.length === 0) { + welcomeEl.style.display = ""; + } else { + welcomeEl.style.display = "none"; + } + } + /** + * Initializes the welcome greeting for a new tab without a conversation. + * Called when a new tab is activated and has no conversation loaded. + */ + initializeWelcome() { + const welcomeEl = this.deps.getWelcomeEl(); + if (!welcomeEl) return; + const fileCtx = this.deps.getFileContextManager(); + fileCtx == null ? void 0 : fileCtx.resetForNewConversation(); + fileCtx == null ? void 0 : fileCtx.autoAttachActiveFile(); + if (!welcomeEl.querySelector(".claudian-welcome-greeting")) { + welcomeEl.createDiv({ cls: "claudian-welcome-greeting", text: this.getGreeting() }); + } + this.updateWelcomeVisibility(); + } + // ============================================ + // Utilities + // ============================================ + /** Generates a fallback title from the first message (used when AI fails). */ + generateFallbackTitle(firstMessage) { + const firstSentence = firstMessage.split(/[.!?\n]/)[0].trim(); + const autoTitle = firstSentence.substring(0, 50); + const suffix = firstSentence.length > 50 ? "..." : ""; + return `${autoTitle}${suffix}`; + } + /** Regenerates AI title for a conversation. */ + async regenerateTitle(conversationId) { + const { plugin } = this.deps; + if (!plugin.settings.enableAutoTitleGeneration) return; + const fullConv = await plugin.getConversationById(conversationId); + if (!fullConv || fullConv.messages.length < 1) return; + const titleService = this.deps.getTitleGenerationService(); + if (!titleService) return; + const firstUserMsg = fullConv.messages.find((m3) => m3.role === "user"); + if (!firstUserMsg) return; + const userContent = firstUserMsg.displayContent || firstUserMsg.content; + const expectedTitle = fullConv.title; + await plugin.updateConversation(conversationId, { titleGenerationStatus: "pending" }); + this.updateHistoryDropdown(); + await titleService.generateTitle( + conversationId, + userContent, + async (convId, result) => { + const currentConv = await plugin.getConversationById(convId); + if (!currentConv) return; + const userManuallyRenamed = currentConv.title !== expectedTitle; + if (result.success && !userManuallyRenamed) { + await plugin.renameConversation(convId, result.title); + await plugin.updateConversation(convId, { titleGenerationStatus: "success" }); + } else if (!userManuallyRenamed) { + await plugin.updateConversation(convId, { titleGenerationStatus: "failed" }); + } else { + await plugin.updateConversation(convId, { titleGenerationStatus: void 0 }); + } + this.updateHistoryDropdown(); + } + ); + } + /** Formats a timestamp for display. */ + formatDate(timestamp) { + const date7 = new Date(timestamp); + const now = /* @__PURE__ */ new Date(); + if (date7.toDateString() === now.toDateString()) { + return date7.toLocaleTimeString(void 0, { hour: "2-digit", minute: "2-digit", hour12: false }); + } + return date7.toLocaleDateString(void 0, { month: "short", day: "numeric" }); + } + // ============================================ + // History Dropdown Rendering (for ClaudianView) + // ============================================ + /** + * Renders the history dropdown content to a provided container. + * Used by ClaudianView to render the dropdown with custom selection callback. + */ + renderHistoryDropdown(container, options) { + this.renderHistoryItems(container, { + onSelectConversation: options.onSelectConversation, + onRerender: () => this.renderHistoryDropdown(container, options) + }); + } +}; + +// src/features/chat/controllers/InputController.ts +var import_obsidian24 = require("obsidian"); + +// src/shared/components/ResumeSessionDropdown.ts +var import_obsidian20 = require("obsidian"); +var ResumeSessionDropdown = class { + constructor(containerEl, inputEl, conversations, currentConversationId, callbacks) { + this.selectedIndex = 0; + this.containerEl = containerEl; + this.inputEl = inputEl; + this.conversations = this.sortConversations(conversations); + this.currentConversationId = currentConversationId; + this.callbacks = callbacks; + this.dropdownEl = this.containerEl.createDiv({ cls: "claudian-resume-dropdown" }); + this.render(); + this.dropdownEl.addClass("visible"); + this.onInput = () => this.dismiss(); + this.inputEl.addEventListener("input", this.onInput); + } + handleKeydown(e3) { + if (!this.isVisible()) return false; + switch (e3.key) { + case "ArrowDown": + e3.preventDefault(); + this.navigate(1); + return true; + case "ArrowUp": + e3.preventDefault(); + this.navigate(-1); + return true; + case "Enter": + case "Tab": + if (this.conversations.length > 0) { + e3.preventDefault(); + this.selectItem(); + return true; + } + return false; + case "Escape": + e3.preventDefault(); + this.dismiss(); + return true; + } + return false; + } + isVisible() { + var _a3, _b2; + return (_b2 = (_a3 = this.dropdownEl) == null ? void 0 : _a3.hasClass("visible")) != null ? _b2 : false; + } + destroy() { + var _a3; + this.inputEl.removeEventListener("input", this.onInput); + (_a3 = this.dropdownEl) == null ? void 0 : _a3.remove(); + } + dismiss() { + this.dropdownEl.removeClass("visible"); + this.callbacks.onDismiss(); + } + selectItem() { + if (this.conversations.length === 0) return; + const selected = this.conversations[this.selectedIndex]; + if (!selected) return; + if (selected.id === this.currentConversationId) { + this.dismiss(); + return; + } + this.callbacks.onSelect(selected.id); + } + navigate(direction) { + const maxIndex = this.conversations.length - 1; + this.selectedIndex = Math.max(0, Math.min(maxIndex, this.selectedIndex + direction)); + this.updateSelection(); + } + updateSelection() { + const items = this.dropdownEl.querySelectorAll(".claudian-resume-item"); + items == null ? void 0 : items.forEach((item, index) => { + if (index === this.selectedIndex) { + item.addClass("selected"); + item.scrollIntoView({ block: "nearest" }); + } else { + item.removeClass("selected"); + } + }); + } + sortConversations(conversations) { + return [...conversations].sort((a3, b) => { + var _a3, _b2; + return ((_a3 = b.lastResponseAt) != null ? _a3 : b.createdAt) - ((_b2 = a3.lastResponseAt) != null ? _b2 : a3.createdAt); + }); + } + render() { + var _a3; + this.dropdownEl.empty(); + const header = this.dropdownEl.createDiv({ cls: "claudian-resume-header" }); + header.createSpan({ text: "Resume conversation" }); + if (this.conversations.length === 0) { + this.dropdownEl.createDiv({ cls: "claudian-resume-empty", text: "No conversations" }); + return; + } + const list = this.dropdownEl.createDiv({ cls: "claudian-resume-list" }); + for (let i3 = 0; i3 < this.conversations.length; i3++) { + const conv = this.conversations[i3]; + const isCurrent = conv.id === this.currentConversationId; + const item = list.createDiv({ cls: "claudian-resume-item" }); + if (isCurrent) item.addClass("current"); + if (i3 === this.selectedIndex) item.addClass("selected"); + const iconEl = item.createDiv({ cls: "claudian-resume-item-icon" }); + (0, import_obsidian20.setIcon)(iconEl, isCurrent ? "message-square-dot" : "message-square"); + const content = item.createDiv({ cls: "claudian-resume-item-content" }); + const titleEl = content.createDiv({ cls: "claudian-resume-item-title", text: conv.title }); + titleEl.setAttribute("title", conv.title); + content.createDiv({ + cls: "claudian-resume-item-date", + text: isCurrent ? "Current session" : this.formatDate((_a3 = conv.lastResponseAt) != null ? _a3 : conv.createdAt) + }); + item.addEventListener("click", () => { + if (isCurrent) { + this.dismiss(); + return; + } + this.callbacks.onSelect(conv.id); + }); + item.addEventListener("mouseenter", () => { + this.selectedIndex = i3; + this.updateSelection(); + }); + } + } + formatDate(timestamp) { + const date7 = new Date(timestamp); + const now = /* @__PURE__ */ new Date(); + if (date7.toDateString() === now.toDateString()) { + return date7.toLocaleTimeString(void 0, { hour: "2-digit", minute: "2-digit", hour12: false }); + } + return date7.toLocaleDateString(void 0, { month: "short", day: "numeric" }); + } +}; + +// src/shared/modals/InstructionConfirmModal.ts +var import_obsidian21 = require("obsidian"); +var InstructionModal = class extends import_obsidian21.Modal { + constructor(app, rawInstruction, callbacks) { + super(app); + this.state = "loading"; + this.resolved = false; + // UI elements + this.contentSectionEl = null; + this.loadingEl = null; + this.clarificationEl = null; + this.confirmationEl = null; + this.buttonsEl = null; + // Clarification state + this.clarificationTextEl = null; + this.responseTextarea = null; + this.isSubmitting = false; + // Confirmation state + this.refinedInstruction = ""; + this.editTextarea = null; + this.isEditing = false; + this.refinedDisplayEl = null; + this.editContainerEl = null; + this.editBtnEl = null; + this.rawInstruction = rawInstruction; + this.callbacks = callbacks; + } + onOpen() { + const { contentEl } = this; + contentEl.addClass("claudian-instruction-modal"); + this.setTitle("Add Custom Instruction"); + const inputSection = contentEl.createDiv({ cls: "claudian-instruction-section" }); + const inputLabel = inputSection.createDiv({ cls: "claudian-instruction-label" }); + inputLabel.setText("Your input:"); + const inputText = inputSection.createDiv({ cls: "claudian-instruction-original" }); + inputText.setText(this.rawInstruction); + this.contentSectionEl = contentEl.createDiv({ cls: "claudian-instruction-content-section" }); + this.loadingEl = this.contentSectionEl.createDiv({ cls: "claudian-instruction-loading" }); + this.loadingEl.createDiv({ cls: "claudian-instruction-spinner" }); + this.loadingEl.createSpan({ text: "Processing your instruction..." }); + this.clarificationEl = this.contentSectionEl.createDiv({ cls: "claudian-instruction-clarification-section" }); + this.clarificationEl.style.display = "none"; + this.clarificationTextEl = this.clarificationEl.createDiv({ cls: "claudian-instruction-clarification" }); + const responseSection = this.clarificationEl.createDiv({ cls: "claudian-instruction-section" }); + const responseLabel = responseSection.createDiv({ cls: "claudian-instruction-label" }); + responseLabel.setText("Your response:"); + this.responseTextarea = new import_obsidian21.TextAreaComponent(responseSection); + this.responseTextarea.inputEl.addClass("claudian-instruction-response-textarea"); + this.responseTextarea.inputEl.rows = 3; + this.responseTextarea.inputEl.placeholder = "Provide more details..."; + this.responseTextarea.inputEl.addEventListener("keydown", (e3) => { + if (e3.key === "Enter" && !e3.shiftKey && !e3.isComposing && !this.isSubmitting) { + e3.preventDefault(); + this.submitClarification(); + } + }); + this.confirmationEl = this.contentSectionEl.createDiv({ cls: "claudian-instruction-confirmation-section" }); + this.confirmationEl.style.display = "none"; + const refinedSection = this.confirmationEl.createDiv({ cls: "claudian-instruction-section" }); + const refinedLabel = refinedSection.createDiv({ cls: "claudian-instruction-label" }); + refinedLabel.setText("Refined snippet:"); + this.refinedDisplayEl = refinedSection.createDiv({ cls: "claudian-instruction-refined" }); + this.editContainerEl = refinedSection.createDiv({ cls: "claudian-instruction-edit-container" }); + this.editContainerEl.style.display = "none"; + this.editTextarea = new import_obsidian21.TextAreaComponent(this.editContainerEl); + this.editTextarea.inputEl.addClass("claudian-instruction-edit-textarea"); + this.editTextarea.inputEl.rows = 4; + this.buttonsEl = contentEl.createDiv({ cls: "claudian-instruction-buttons" }); + this.updateButtons(); + this.showState("loading"); + } + showClarification(clarification) { + var _a3; + if (this.clarificationTextEl) { + this.clarificationTextEl.setText(clarification); + } + if (this.responseTextarea) { + this.responseTextarea.setValue(""); + } + this.isSubmitting = false; + this.showState("clarification"); + (_a3 = this.responseTextarea) == null ? void 0 : _a3.inputEl.focus(); + } + showConfirmation(refinedInstruction) { + this.refinedInstruction = refinedInstruction; + if (this.refinedDisplayEl) { + this.refinedDisplayEl.setText(refinedInstruction); + } + if (this.editTextarea) { + this.editTextarea.setValue(refinedInstruction); + } + this.showState("confirmation"); + } + showError(error48) { + this.resolved = true; + this.close(); + } + showClarificationLoading() { + this.isSubmitting = true; + if (this.loadingEl) { + this.loadingEl.querySelector(".claudian-instruction-spinner"); + const text = this.loadingEl.querySelector("span"); + if (text) text.textContent = "Processing..."; + } + this.showState("loading"); + } + showState(state) { + this.state = state; + if (this.loadingEl) { + this.loadingEl.style.display = state === "loading" ? "flex" : "none"; + } + if (this.clarificationEl) { + this.clarificationEl.style.display = state === "clarification" ? "block" : "none"; + } + if (this.confirmationEl) { + this.confirmationEl.style.display = state === "confirmation" ? "block" : "none"; + } + this.updateButtons(); + } + updateButtons() { + if (!this.buttonsEl) return; + this.buttonsEl.empty(); + const cancelBtn = this.buttonsEl.createEl("button", { + text: "Cancel", + cls: "claudian-instruction-btn claudian-instruction-reject-btn", + attr: { "aria-label": "Cancel" } + }); + cancelBtn.addEventListener("click", () => this.handleReject()); + if (this.state === "clarification") { + const submitBtn = this.buttonsEl.createEl("button", { + text: "Submit", + cls: "claudian-instruction-btn claudian-instruction-accept-btn", + attr: { "aria-label": "Submit response" } + }); + submitBtn.addEventListener("click", () => this.submitClarification()); + } else if (this.state === "confirmation") { + this.editBtnEl = this.buttonsEl.createEl("button", { + text: "Edit", + cls: "claudian-instruction-btn claudian-instruction-edit-btn", + attr: { "aria-label": "Edit instruction" } + }); + this.editBtnEl.addEventListener("click", () => this.toggleEdit()); + const acceptBtn = this.buttonsEl.createEl("button", { + text: "Accept", + cls: "claudian-instruction-btn claudian-instruction-accept-btn", + attr: { "aria-label": "Accept instruction" } + }); + acceptBtn.addEventListener("click", () => this.handleAccept()); + acceptBtn.focus(); + } + } + async submitClarification() { + var _a3; + const response = (_a3 = this.responseTextarea) == null ? void 0 : _a3.getValue().trim(); + if (!response || this.isSubmitting) return; + this.showClarificationLoading(); + try { + await this.callbacks.onClarificationSubmit(response); + } catch (e3) { + this.isSubmitting = false; + this.showState("clarification"); + } + } + toggleEdit() { + var _a3, _b2; + this.isEditing = !this.isEditing; + if (this.isEditing) { + if (this.refinedDisplayEl) this.refinedDisplayEl.style.display = "none"; + if (this.editContainerEl) this.editContainerEl.style.display = "block"; + if (this.editBtnEl) this.editBtnEl.setText("Preview"); + (_a3 = this.editTextarea) == null ? void 0 : _a3.inputEl.focus(); + } else { + const edited = ((_b2 = this.editTextarea) == null ? void 0 : _b2.getValue()) || this.refinedInstruction; + this.refinedInstruction = edited; + if (this.refinedDisplayEl) { + this.refinedDisplayEl.setText(edited); + this.refinedDisplayEl.style.display = "block"; + } + if (this.editContainerEl) this.editContainerEl.style.display = "none"; + if (this.editBtnEl) this.editBtnEl.setText("Edit"); + } + } + handleAccept() { + var _a3; + if (this.resolved) return; + this.resolved = true; + const finalInstruction = this.isEditing ? ((_a3 = this.editTextarea) == null ? void 0 : _a3.getValue()) || this.refinedInstruction : this.refinedInstruction; + this.callbacks.onAccept(finalInstruction); + this.close(); + } + handleReject() { + if (this.resolved) return; + this.resolved = true; + this.callbacks.onReject(); + this.close(); + } + onClose() { + if (!this.resolved) { + this.resolved = true; + this.callbacks.onReject(); + } + this.contentEl.empty(); + } +}; + +// src/utils/markdown.ts +function appendMarkdownSnippet(existingPrompt, snippet) { + const trimmedSnippet = snippet.trim(); + if (!trimmedSnippet) { + return existingPrompt; + } + if (!existingPrompt.trim()) { + return trimmedSnippet; + } + const separator = existingPrompt.endsWith("\n\n") ? "" : existingPrompt.endsWith("\n") ? "\n" : "\n\n"; + return existingPrompt + separator + trimmedSnippet; +} + +// src/features/chat/constants.ts +var COMPLETION_FLAVOR_WORDS = [ + "Baked", + "Cooked", + "Crunched", + "Brewed", + "Crafted", + "Forged", + "Conjured", + "Whipped up", + "Stirred", + "Simmered", + "Toasted", + "Saut\xE9ed", + "Finagled", + "Marinated", + "Distilled", + "Fermented", + "Percolated", + "Steeped", + "Roasted", + "Cured", + "Smoked", + "Cogitated" +]; +var FLAVOR_TEXTS = [ + // Classic + "Thinking...", + "Pondering...", + "Processing...", + "Analyzing...", + "Considering...", + "Working on it...", + "Vibing...", + "One moment...", + "On it...", + // Thoughtful + "Ruminating...", + "Contemplating...", + "Reflecting...", + "Mulling it over...", + "Let me think...", + "Hmm...", + "Cogitating...", + "Deliberating...", + "Weighing options...", + "Gathering thoughts...", + // Playful + "Brewing ideas...", + "Connecting dots...", + "Assembling thoughts...", + "Spinning up neurons...", + "Loading brilliance...", + "Consulting the oracle...", + "Summoning knowledge...", + "Crunching thoughts...", + "Dusting off neurons...", + "Wrangling ideas...", + "Herding thoughts...", + "Juggling concepts...", + "Untangling this...", + "Piecing it together...", + // Cozy + "Sipping coffee...", + "Warming up...", + "Getting cozy with this...", + "Settling in...", + "Making tea...", + "Grabbing a snack...", + // Technical + "Parsing...", + "Compiling thoughts...", + "Running inference...", + "Querying the void...", + "Defragmenting brain...", + "Allocating memory...", + "Optimizing...", + "Indexing...", + "Syncing neurons...", + // Zen + "Breathing...", + "Finding clarity...", + "Channeling focus...", + "Centering...", + "Aligning chakras...", + "Meditating on this...", + // Whimsical + "Asking the stars...", + "Reading tea leaves...", + "Shaking the magic 8-ball...", + "Consulting ancient scrolls...", + "Decoding the matrix...", + "Communing with the ether...", + "Peering into the abyss...", + "Channeling the cosmos...", + // Action + "Diving in...", + "Rolling up sleeves...", + "Getting to work...", + "Tackling this...", + "On the case...", + "Investigating...", + "Exploring...", + "Digging deeper...", + // Casual + "Bear with me...", + "Hang tight...", + "Just a sec...", + "Working my magic...", + "Almost there...", + "Give me a moment..." +]; + +// src/features/chat/rendering/InlineAskUserQuestion.ts +var HINTS_TEXT = "Enter to select \xB7 Tab/Arrow keys to navigate \xB7 Esc to cancel"; +var HINTS_TEXT_IMMEDIATE = "Enter to select \xB7 Arrow keys to navigate \xB7 Esc to cancel"; +var InlineAskUserQuestion = class { + constructor(containerEl, input, resolve5, signal, config2) { + this.resolved = false; + this.questions = []; + this.answers = /* @__PURE__ */ new Map(); + this.customInputs = /* @__PURE__ */ new Map(); + this.activeTabIndex = 0; + this.focusedItemIndex = 0; + this.isInputFocused = false; + this.tabElements = []; + this.currentItems = []; + this.abortHandler = null; + var _a3, _b2, _c; + this.containerEl = containerEl; + this.input = input; + this.resolveCallback = resolve5; + this.signal = signal; + this.config = { + title: (_a3 = config2 == null ? void 0 : config2.title) != null ? _a3 : "Question", + headerEl: config2 == null ? void 0 : config2.headerEl, + showCustomInput: (_b2 = config2 == null ? void 0 : config2.showCustomInput) != null ? _b2 : true, + immediateSelect: (_c = config2 == null ? void 0 : config2.immediateSelect) != null ? _c : false + }; + this.boundKeyDown = this.handleKeyDown.bind(this); + } + render() { + this.rootEl = this.containerEl.createDiv({ cls: "claudian-ask-question-inline" }); + const titleEl = this.rootEl.createDiv({ cls: "claudian-ask-inline-title" }); + titleEl.setText(this.config.title); + if (this.config.headerEl) { + this.rootEl.appendChild(this.config.headerEl); + } + this.questions = this.parseQuestions(); + if (this.questions.length === 0) { + this.handleResolve(null); + return; + } + if (this.config.immediateSelect && this.questions.length !== 1) { + this.config.immediateSelect = false; + } + for (let i3 = 0; i3 < this.questions.length; i3++) { + this.answers.set(i3, /* @__PURE__ */ new Set()); + this.customInputs.set(i3, ""); + } + if (!this.config.immediateSelect) { + this.tabBar = this.rootEl.createDiv({ cls: "claudian-ask-tab-bar" }); + this.renderTabBar(); + } + this.contentArea = this.rootEl.createDiv({ cls: "claudian-ask-content" }); + this.renderTabContent(); + this.rootEl.setAttribute("tabindex", "0"); + this.rootEl.addEventListener("keydown", this.boundKeyDown); + requestAnimationFrame(() => { + this.rootEl.focus(); + this.rootEl.scrollIntoView({ block: "nearest", behavior: "smooth" }); + }); + if (this.signal) { + this.abortHandler = () => this.handleResolve(null); + this.signal.addEventListener("abort", this.abortHandler, { once: true }); + } + } + destroy() { + this.handleResolve(null); + } + parseQuestions() { + const raw = this.input.questions; + if (!Array.isArray(raw)) return []; + return raw.filter( + (q3) => typeof q3 === "object" && q3 !== null && typeof q3.question === "string" && (Array.isArray(q3.options) && q3.options.length > 0 || q3.isOther === true) + ).map((q3, idx) => { + var _a3; + return { + question: q3.question, + id: typeof q3.id === "string" ? q3.id : void 0, + header: typeof q3.header === "string" ? q3.header.slice(0, 12) : `Q${idx + 1}`, + options: this.deduplicateOptions(((_a3 = q3.options) != null ? _a3 : []).map((o3) => this.coerceOption(o3))), + multiSelect: q3.multiSelect === true, + isOther: q3.isOther === true, + isSecret: q3.isSecret === true + }; + }); + } + coerceOption(opt) { + if (typeof opt === "object" && opt !== null) { + const obj = opt; + const label = this.extractLabel(obj); + const description = typeof obj.description === "string" ? obj.description : ""; + const value = this.extractValue(obj, label); + return { label, description, ...value !== label ? { value } : {} }; + } + return { label: typeof opt === "string" ? opt : String(opt), description: "" }; + } + deduplicateOptions(options) { + const seen = /* @__PURE__ */ new Set(); + return options.filter((o3) => { + if (seen.has(o3.label)) return false; + seen.add(o3.label); + return true; + }); + } + extractLabel(obj) { + if (typeof obj.label === "string") return obj.label; + if (typeof obj.value === "string") return obj.value; + if (typeof obj.text === "string") return obj.text; + if (typeof obj.name === "string") return obj.name; + return String(obj); + } + extractValue(obj, fallback) { + if (typeof obj.value === "string") return obj.value; + if (typeof obj.id === "string") return obj.id; + return fallback; + } + renderTabBar() { + this.tabBar.empty(); + this.tabElements = []; + for (let idx = 0; idx < this.questions.length; idx++) { + const answered = this.isQuestionAnswered(idx); + const tab = this.tabBar.createSpan({ cls: "claudian-ask-tab" }); + tab.createSpan({ text: this.questions[idx].header, cls: "claudian-ask-tab-label" }); + tab.createSpan({ text: answered ? " \u2713" : "", cls: "claudian-ask-tab-tick" }); + tab.setAttribute("title", this.questions[idx].question); + if (idx === this.activeTabIndex) tab.addClass("is-active"); + if (answered) tab.addClass("is-answered"); + tab.addEventListener("click", () => this.switchTab(idx)); + this.tabElements.push(tab); + } + const allAnswered = this.questions.every((_3, i3) => this.isQuestionAnswered(i3)); + const submitTab = this.tabBar.createSpan({ cls: "claudian-ask-tab" }); + submitTab.createSpan({ text: allAnswered ? "\u2713 " : "", cls: "claudian-ask-tab-submit-check" }); + submitTab.createSpan({ text: "Submit", cls: "claudian-ask-tab-label" }); + if (this.activeTabIndex === this.questions.length) submitTab.addClass("is-active"); + submitTab.addEventListener("click", () => this.switchTab(this.questions.length)); + this.tabElements.push(submitTab); + } + isQuestionAnswered(idx) { + return this.answers.get(idx).size > 0 || this.customInputs.get(idx).trim().length > 0; + } + switchTab(index) { + const clamped = Math.max(0, Math.min(index, this.questions.length)); + if (clamped === this.activeTabIndex) return; + this.activeTabIndex = clamped; + this.focusedItemIndex = 0; + this.isInputFocused = false; + if (!this.config.immediateSelect) { + this.renderTabBar(); + } + this.renderTabContent(); + this.rootEl.focus(); + } + renderTabContent() { + this.contentArea.empty(); + this.currentItems = []; + if (this.activeTabIndex < this.questions.length) { + this.renderQuestionTab(this.activeTabIndex); + } else { + this.renderSubmitTab(); + } + } + renderQuestionTab(idx) { + var _a3; + const q3 = this.questions[idx]; + const isMulti = q3.multiSelect; + const selected = this.answers.get(idx); + this.contentArea.createDiv({ + text: q3.question, + cls: "claudian-ask-question-text" + }); + const listEl = this.contentArea.createDiv({ cls: "claudian-ask-list" }); + for (let optIdx = 0; optIdx < q3.options.length; optIdx++) { + const option = q3.options[optIdx]; + const isFocused = optIdx === this.focusedItemIndex; + const optionValue = this.getOptionValue(option); + const isSelected = selected.has(optionValue); + const row = listEl.createDiv({ cls: "claudian-ask-item" }); + if (isFocused) row.addClass("is-focused"); + if (isSelected) row.addClass("is-selected"); + row.createSpan({ text: isFocused ? "\u203A" : "\xA0", cls: "claudian-ask-cursor" }); + row.createSpan({ text: `${optIdx + 1}. `, cls: "claudian-ask-item-num" }); + if (isMulti) { + this.renderMultiSelectCheckbox(row, isSelected); + } + const labelBlock = row.createDiv({ cls: "claudian-ask-item-content" }); + const labelRow = labelBlock.createDiv({ cls: "claudian-ask-label-row" }); + labelRow.createSpan({ text: option.label, cls: "claudian-ask-item-label" }); + if (!isMulti && isSelected) { + labelRow.createSpan({ text: " \u2713", cls: "claudian-ask-check-mark" }); + } + if (option.description) { + labelBlock.createDiv({ text: option.description, cls: "claudian-ask-item-desc" }); + } + row.addEventListener("click", () => { + this.focusedItemIndex = optIdx; + this.updateFocusIndicator(); + this.selectOption(idx, option); + }); + this.currentItems.push(row); + } + if (this.canShowCustomInputForQuestion(q3)) { + const customIdx = q3.options.length; + const customFocused = customIdx === this.focusedItemIndex; + const customText = (_a3 = this.customInputs.get(idx)) != null ? _a3 : ""; + const hasCustomText = customText.trim().length > 0; + const customRow = listEl.createDiv({ cls: "claudian-ask-item claudian-ask-custom-item" }); + if (customFocused) customRow.addClass("is-focused"); + customRow.createSpan({ text: customFocused ? "\u203A" : "\xA0", cls: "claudian-ask-cursor" }); + customRow.createSpan({ text: `${customIdx + 1}. `, cls: "claudian-ask-item-num" }); + if (isMulti) { + this.renderMultiSelectCheckbox(customRow, hasCustomText); + } + const inputEl = customRow.createEl("input", { + cls: "claudian-ask-custom-text", + value: customText + }); + inputEl.setAttribute("type", q3.isSecret ? "password" : "text"); + inputEl.setAttribute("placeholder", q3.isSecret ? "Enter secret." : "Type something."); + inputEl.addEventListener("input", () => { + this.customInputs.set(idx, inputEl.value); + if (!isMulti && inputEl.value.trim()) { + selected.clear(); + this.updateOptionVisuals(idx); + } + this.updateTabIndicators(); + }); + inputEl.addEventListener("focus", () => { + this.isInputFocused = true; + }); + inputEl.addEventListener("blur", () => { + this.isInputFocused = false; + }); + this.currentItems.push(customRow); + } + this.contentArea.createDiv({ + text: this.config.immediateSelect ? HINTS_TEXT_IMMEDIATE : HINTS_TEXT, + cls: "claudian-ask-hints" + }); + } + renderSubmitTab() { + this.contentArea.createDiv({ + text: "Review your answers", + cls: "claudian-ask-review-title" + }); + const reviewEl = this.contentArea.createDiv({ cls: "claudian-ask-review" }); + for (let idx = 0; idx < this.questions.length; idx++) { + const q3 = this.questions[idx]; + const answerText = this.getAnswerText(idx); + const pairEl = reviewEl.createDiv({ cls: "claudian-ask-review-pair" }); + pairEl.createDiv({ text: `${idx + 1}.`, cls: "claudian-ask-review-num" }); + const bodyEl = pairEl.createDiv({ cls: "claudian-ask-review-body" }); + bodyEl.createDiv({ text: q3.question, cls: "claudian-ask-review-q-text" }); + bodyEl.createDiv({ + text: answerText || "Not answered", + cls: answerText ? "claudian-ask-review-a-text" : "claudian-ask-review-empty" + }); + pairEl.addEventListener("click", () => this.switchTab(idx)); + } + this.contentArea.createDiv({ + text: "Ready to submit your answers?", + cls: "claudian-ask-review-prompt" + }); + const actionsEl = this.contentArea.createDiv({ cls: "claudian-ask-list" }); + const allAnswered = this.questions.every((_3, i3) => this.isQuestionAnswered(i3)); + const submitRow = actionsEl.createDiv({ cls: "claudian-ask-item" }); + if (this.focusedItemIndex === 0) submitRow.addClass("is-focused"); + if (!allAnswered) submitRow.addClass("is-disabled"); + submitRow.createSpan({ text: this.focusedItemIndex === 0 ? "\u203A" : "\xA0", cls: "claudian-ask-cursor" }); + submitRow.createSpan({ text: "1. ", cls: "claudian-ask-item-num" }); + submitRow.createSpan({ text: "Submit answers", cls: "claudian-ask-item-label" }); + submitRow.addEventListener("click", () => { + this.focusedItemIndex = 0; + this.updateFocusIndicator(); + this.handleSubmit(); + }); + this.currentItems.push(submitRow); + const cancelRow = actionsEl.createDiv({ cls: "claudian-ask-item" }); + if (this.focusedItemIndex === 1) cancelRow.addClass("is-focused"); + cancelRow.createSpan({ text: this.focusedItemIndex === 1 ? "\u203A" : "\xA0", cls: "claudian-ask-cursor" }); + cancelRow.createSpan({ text: "2. ", cls: "claudian-ask-item-num" }); + cancelRow.createSpan({ text: "Cancel", cls: "claudian-ask-item-label" }); + cancelRow.addEventListener("click", () => { + this.focusedItemIndex = 1; + this.handleResolve(null); + }); + this.currentItems.push(cancelRow); + this.contentArea.createDiv({ + text: HINTS_TEXT, + cls: "claudian-ask-hints" + }); + } + getAnswerText(idx) { + const selected = this.getSelectedLabels(idx); + const custom2 = this.customInputs.get(idx); + const parts = []; + if (selected.length > 0) parts.push(selected.join(", ")); + if (custom2.trim()) parts.push(custom2.trim()); + return parts.join(", "); + } + selectOption(qIdx, option) { + var _a3; + const q3 = this.questions[qIdx]; + const selected = this.answers.get(qIdx); + const isMulti = q3.multiSelect; + const optionValue = this.getOptionValue(option); + if (isMulti) { + if (selected.has(optionValue)) { + selected.delete(optionValue); + } else { + selected.add(optionValue); + } + } else { + selected.clear(); + selected.add(optionValue); + this.customInputs.set(qIdx, ""); + } + this.updateOptionVisuals(qIdx); + if (this.config.immediateSelect) { + const key = (_a3 = q3.id) != null ? _a3 : q3.question; + const result = {}; + result[key] = optionValue; + this.handleResolve(result); + return; + } + this.updateTabIndicators(); + if (!isMulti) { + this.switchTab(this.activeTabIndex + 1); + } + } + renderMultiSelectCheckbox(parent, checked) { + parent.createSpan({ + text: checked ? "[\u2713] " : "[ ] ", + cls: `claudian-ask-check${checked ? " is-checked" : ""}` + }); + } + updateOptionVisuals(qIdx) { + const q3 = this.questions[qIdx]; + const selected = this.answers.get(qIdx); + const isMulti = q3.multiSelect; + for (let i3 = 0; i3 < q3.options.length; i3++) { + const item = this.currentItems[i3]; + const isSelected = selected.has(this.getOptionValue(q3.options[i3])); + item.toggleClass("is-selected", isSelected); + if (isMulti) { + const checkSpan = item.querySelector(".claudian-ask-check"); + if (checkSpan) { + checkSpan.textContent = isSelected ? "[\u2713] " : "[ ] "; + checkSpan.toggleClass("is-checked", isSelected); + } + } else { + const labelRow = item.querySelector(".claudian-ask-label-row"); + const existingMark = item.querySelector(".claudian-ask-check-mark"); + if (isSelected && !existingMark && labelRow) { + labelRow.createSpan({ text: " \u2713", cls: "claudian-ask-check-mark" }); + } else if (!isSelected && existingMark) { + existingMark.remove(); + } + } + } + } + updateFocusIndicator() { + for (let i3 = 0; i3 < this.currentItems.length; i3++) { + const item = this.currentItems[i3]; + const cursor = item.querySelector(".claudian-ask-cursor"); + if (i3 === this.focusedItemIndex) { + item.addClass("is-focused"); + if (cursor) cursor.textContent = "\u203A"; + item.scrollIntoView({ block: "nearest" }); + if (item.hasClass("claudian-ask-custom-item")) { + const input = item.querySelector(".claudian-ask-custom-text"); + if (input) { + input.focus(); + this.isInputFocused = true; + } + } + } else { + item.removeClass("is-focused"); + if (cursor) cursor.textContent = "\xA0"; + if (item.hasClass("claudian-ask-custom-item")) { + const input = item.querySelector(".claudian-ask-custom-text"); + if (input && document.activeElement === input) { + input.blur(); + this.isInputFocused = false; + } + } + } + } + } + updateTabIndicators() { + for (let idx = 0; idx < this.questions.length; idx++) { + const tab = this.tabElements[idx]; + const tick = tab.querySelector(".claudian-ask-tab-tick"); + const answered = this.isQuestionAnswered(idx); + tab.toggleClass("is-answered", answered); + if (tick) tick.textContent = answered ? " \u2713" : ""; + } + const submitTab = this.tabElements[this.questions.length]; + if (submitTab) { + const submitCheck = submitTab.querySelector(".claudian-ask-tab-submit-check"); + const allAnswered = this.questions.every((_3, i3) => this.isQuestionAnswered(i3)); + if (submitCheck) submitCheck.textContent = allAnswered ? "\u2713 " : ""; + } + } + handleNavigationKey(e3, maxFocusIndex) { + switch (e3.key) { + case "ArrowDown": + e3.preventDefault(); + e3.stopPropagation(); + this.focusedItemIndex = Math.min(this.focusedItemIndex + 1, maxFocusIndex); + this.updateFocusIndicator(); + return true; + case "ArrowUp": + e3.preventDefault(); + e3.stopPropagation(); + this.focusedItemIndex = Math.max(this.focusedItemIndex - 1, 0); + this.updateFocusIndicator(); + return true; + case "ArrowLeft": + if (this.config.immediateSelect) return false; + e3.preventDefault(); + e3.stopPropagation(); + this.switchTab(this.activeTabIndex - 1); + return true; + case "Tab": + if (this.config.immediateSelect) return false; + e3.preventDefault(); + e3.stopPropagation(); + if (e3.shiftKey) { + this.switchTab(this.activeTabIndex - 1); + } else { + this.switchTab(this.activeTabIndex + 1); + } + return true; + case "Escape": + e3.preventDefault(); + e3.stopPropagation(); + this.handleResolve(null); + return true; + default: + return false; + } + } + handleKeyDown(e3) { + var _a3, _b2; + if (this.isInputFocused) { + if (e3.key === "Escape") { + e3.preventDefault(); + e3.stopPropagation(); + this.isInputFocused = false; + (_a3 = document.activeElement) == null ? void 0 : _a3.blur(); + this.rootEl.focus(); + return; + } + if (e3.key === "Tab" || e3.key === "Enter") { + e3.preventDefault(); + e3.stopPropagation(); + this.isInputFocused = false; + (_b2 = document.activeElement) == null ? void 0 : _b2.blur(); + if (e3.key === "Tab" && e3.shiftKey) { + this.switchTab(this.activeTabIndex - 1); + } else { + this.switchTab(this.activeTabIndex + 1); + } + return; + } + return; + } + if (this.config.immediateSelect) { + const q4 = this.questions[this.activeTabIndex]; + const maxIdx = q4.options.length - 1; + if (this.handleNavigationKey(e3, maxIdx)) return; + if (e3.key === "Enter") { + e3.preventDefault(); + e3.stopPropagation(); + if (this.focusedItemIndex <= maxIdx) { + this.selectOption(this.activeTabIndex, q4.options[this.focusedItemIndex]); + } + } + return; + } + const isSubmitTab = this.activeTabIndex === this.questions.length; + const q3 = this.questions[this.activeTabIndex]; + const maxFocusIndex = isSubmitTab ? 1 : this.canShowCustomInputForQuestion(q3) ? q3.options.length : q3.options.length - 1; + if (this.handleNavigationKey(e3, maxFocusIndex)) return; + if (isSubmitTab) { + if (e3.key === "Enter") { + e3.preventDefault(); + e3.stopPropagation(); + if (this.focusedItemIndex === 0) this.handleSubmit(); + else this.handleResolve(null); + } + return; + } + switch (e3.key) { + case "ArrowRight": + e3.preventDefault(); + e3.stopPropagation(); + this.switchTab(this.activeTabIndex + 1); + break; + case "Enter": + e3.preventDefault(); + e3.stopPropagation(); + if (this.focusedItemIndex < q3.options.length) { + this.selectOption(this.activeTabIndex, q3.options[this.focusedItemIndex]); + } else if (this.canShowCustomInputForQuestion(q3)) { + this.isInputFocused = true; + const input = this.contentArea.querySelector( + ".claudian-ask-custom-text" + ); + input == null ? void 0 : input.focus(); + } + break; + } + } + handleSubmit() { + var _a3; + const allAnswered = this.questions.every((_3, i3) => this.isQuestionAnswered(i3)); + if (!allAnswered) return; + const result = {}; + for (let i3 = 0; i3 < this.questions.length; i3++) { + const question = this.questions[i3]; + const key = (_a3 = question.id) != null ? _a3 : question.question; + const selectedValues = [...this.answers.get(i3)]; + const customInput = this.customInputs.get(i3).trim(); + if (question.multiSelect) { + const answers = [...selectedValues]; + if (customInput) { + answers.push(customInput); + } + result[key] = answers; + continue; + } + result[key] = customInput || selectedValues[0] || ""; + } + this.handleResolve(result); + } + canShowCustomInputForQuestion(question) { + return this.config.showCustomInput && question.isOther === true; + } + getOptionValue(option) { + var _a3; + return (_a3 = option.value) != null ? _a3 : option.label; + } + getSelectedLabels(idx) { + const selected = this.answers.get(idx); + const question = this.questions[idx]; + return question.options.filter((option) => selected.has(this.getOptionValue(option))).map((option) => option.label); + } + handleResolve(result) { + var _a3, _b2; + if (!this.resolved) { + this.resolved = true; + (_a3 = this.rootEl) == null ? void 0 : _a3.removeEventListener("keydown", this.boundKeyDown); + if (this.signal && this.abortHandler) { + this.signal.removeEventListener("abort", this.abortHandler); + this.abortHandler = null; + } + (_b2 = this.rootEl) == null ? void 0 : _b2.remove(); + this.resolveCallback(result); + } + } +}; + +// src/features/chat/rendering/InlineExitPlanMode.ts +var nodePath = __toESM(require("path")); +var HINTS_TEXT2 = "Arrow keys to navigate \xB7 Enter to select \xB7 Esc to cancel"; +var InlineExitPlanMode = class { + constructor(containerEl, input, resolve5, signal, renderContent, planPathPrefix) { + this.resolved = false; + this.planContent = null; + this.planReadError = null; + this.focusedIndex = 0; + this.items = []; + this.isInputFocused = false; + this.abortHandler = null; + this.containerEl = containerEl; + this.input = input; + this.resolveCallback = resolve5; + this.signal = signal; + this.renderContent = renderContent; + this.planPathPrefix = planPathPrefix; + this.boundKeyDown = this.handleKeyDown.bind(this); + } + render() { + this.rootEl = this.containerEl.createDiv({ cls: "claudian-plan-approval-inline" }); + const titleEl = this.rootEl.createDiv({ cls: "claudian-plan-inline-title" }); + titleEl.setText("Plan complete"); + this.planContent = this.readPlanContent(); + if (this.planContent) { + const contentEl = this.rootEl.createDiv({ cls: "claudian-plan-content-preview" }); + if (this.renderContent) { + void this.renderContent(contentEl, this.planContent); + } else { + contentEl.createDiv({ cls: "claudian-plan-content-text", text: this.planContent }); + } + } else if (this.planReadError) { + this.rootEl.createDiv({ + cls: "claudian-plan-content-preview claudian-plan-read-error", + text: `Could not read plan file: ${this.planReadError}. "Approve (new session)" will not include plan details.` + }); + } + const allowedPrompts = this.input.allowedPrompts; + if (allowedPrompts && Array.isArray(allowedPrompts) && allowedPrompts.length > 0) { + const permEl = this.rootEl.createDiv({ cls: "claudian-plan-permissions" }); + permEl.createDiv({ text: "Requested permissions:", cls: "claudian-plan-permissions-label" }); + const listEl = permEl.createEl("ul", { cls: "claudian-plan-permissions-list" }); + for (const perm of allowedPrompts) { + listEl.createEl("li", { text: perm.prompt }); + } + } + const actionsEl = this.rootEl.createDiv({ cls: "claudian-ask-list" }); + const newSessionRow = actionsEl.createDiv({ cls: "claudian-ask-item" }); + newSessionRow.addClass("is-focused"); + newSessionRow.createSpan({ text: "\u203A", cls: "claudian-ask-cursor" }); + newSessionRow.createSpan({ text: "1. ", cls: "claudian-ask-item-num" }); + newSessionRow.createSpan({ text: "Approve (new session)", cls: "claudian-ask-item-label" }); + newSessionRow.addEventListener("click", () => { + this.focusedIndex = 0; + this.updateFocus(); + this.handleResolve({ + type: "approve-new-session", + planContent: this.extractPlanContent() + }); + }); + this.items.push(newSessionRow); + const approveRow = actionsEl.createDiv({ cls: "claudian-ask-item" }); + approveRow.createSpan({ text: "\xA0", cls: "claudian-ask-cursor" }); + approveRow.createSpan({ text: "2. ", cls: "claudian-ask-item-num" }); + approveRow.createSpan({ text: "Approve (current session)", cls: "claudian-ask-item-label" }); + approveRow.addEventListener("click", () => { + this.focusedIndex = 1; + this.updateFocus(); + this.handleResolve({ type: "approve" }); + }); + this.items.push(approveRow); + const feedbackRow = actionsEl.createDiv({ cls: "claudian-ask-item claudian-ask-custom-item" }); + feedbackRow.createSpan({ text: "\xA0", cls: "claudian-ask-cursor" }); + feedbackRow.createSpan({ text: "3. ", cls: "claudian-ask-item-num" }); + this.feedbackInput = feedbackRow.createEl("input", { + type: "text", + cls: "claudian-ask-custom-text", + placeholder: "Enter feedback to continue planning..." + }); + this.feedbackInput.addEventListener("focus", () => { + this.isInputFocused = true; + }); + this.feedbackInput.addEventListener("blur", () => { + this.isInputFocused = false; + }); + feedbackRow.addEventListener("click", () => { + this.focusedIndex = 2; + this.updateFocus(); + }); + this.items.push(feedbackRow); + this.rootEl.createDiv({ text: HINTS_TEXT2, cls: "claudian-ask-hints" }); + this.rootEl.setAttribute("tabindex", "0"); + this.rootEl.addEventListener("keydown", this.boundKeyDown); + requestAnimationFrame(() => { + this.rootEl.focus(); + this.rootEl.scrollIntoView({ block: "nearest", behavior: "smooth" }); + }); + if (this.signal) { + this.abortHandler = () => this.handleResolve(null); + this.signal.addEventListener("abort", this.abortHandler, { once: true }); + } + } + destroy() { + this.handleResolve(null); + } + readPlanContent() { + const planFilePath = this.input.planFilePath; + if (!planFilePath) return null; + const resolved = nodePath.resolve(planFilePath).replace(/\\/g, "/"); + if (!this.planPathPrefix || !resolved.includes(this.planPathPrefix)) { + this.planReadError = "path outside allowed plan directory"; + return null; + } + try { + const fs19 = require("fs"); + const content = fs19.readFileSync(planFilePath, "utf-8"); + return content.trim() || null; + } catch (err) { + this.planReadError = err instanceof Error ? err.message : "unknown error"; + return null; + } + } + extractPlanContent() { + if (this.planContent) { + return `Implement this plan: + +${this.planContent}`; + } + return "Implement the approved plan."; + } + handleKeyDown(e3) { + if (this.isInputFocused) { + if (e3.key === "Escape") { + e3.preventDefault(); + e3.stopPropagation(); + this.isInputFocused = false; + this.feedbackInput.blur(); + this.rootEl.focus(); + return; + } + if (e3.key === "Enter" && this.feedbackInput.value.trim()) { + e3.preventDefault(); + e3.stopPropagation(); + this.handleResolve({ type: "feedback", text: this.feedbackInput.value.trim() }); + return; + } + return; + } + switch (e3.key) { + case "ArrowDown": + e3.preventDefault(); + e3.stopPropagation(); + this.focusedIndex = Math.min(this.focusedIndex + 1, this.items.length - 1); + this.updateFocus(); + break; + case "ArrowUp": + e3.preventDefault(); + e3.stopPropagation(); + this.focusedIndex = Math.max(this.focusedIndex - 1, 0); + this.updateFocus(); + break; + case "Enter": + e3.preventDefault(); + e3.stopPropagation(); + if (this.focusedIndex === 0) { + this.handleResolve({ + type: "approve-new-session", + planContent: this.extractPlanContent() + }); + } else if (this.focusedIndex === 1) { + this.handleResolve({ type: "approve" }); + } else if (this.focusedIndex === 2) { + this.feedbackInput.focus(); + } + break; + case "Escape": + e3.preventDefault(); + e3.stopPropagation(); + this.handleResolve(null); + break; + } + } + updateFocus() { + for (let i3 = 0; i3 < this.items.length; i3++) { + const item = this.items[i3]; + const cursor = item.querySelector(".claudian-ask-cursor"); + if (i3 === this.focusedIndex) { + item.addClass("is-focused"); + if (cursor) cursor.textContent = "\u203A"; + item.scrollIntoView({ block: "nearest" }); + if (item.hasClass("claudian-ask-custom-item")) { + const input = item.querySelector(".claudian-ask-custom-text"); + if (input) { + input.focus(); + this.isInputFocused = true; + } + } + } else { + item.removeClass("is-focused"); + if (cursor) cursor.textContent = "\xA0"; + if (item.hasClass("claudian-ask-custom-item")) { + const input = item.querySelector(".claudian-ask-custom-text"); + if (input && document.activeElement === input) { + input.blur(); + this.isInputFocused = false; + } + } + } + } + } + handleResolve(decision) { + var _a3, _b2; + if (!this.resolved) { + this.resolved = true; + (_a3 = this.rootEl) == null ? void 0 : _a3.removeEventListener("keydown", this.boundKeyDown); + if (this.signal && this.abortHandler) { + this.signal.removeEventListener("abort", this.abortHandler); + this.abortHandler = null; + } + (_b2 = this.rootEl) == null ? void 0 : _b2.remove(); + this.resolveCallback(decision); + } + } +}; + +// src/features/chat/rendering/InlinePlanApproval.ts +var HINTS_TEXT3 = "Arrow keys to navigate \xB7 Enter to select \xB7 Esc to cancel"; +var InlinePlanApproval = class { + constructor(containerEl, resolve5) { + this.resolved = false; + this.focusedIndex = 0; + this.items = []; + this.isInputFocused = false; + this.containerEl = containerEl; + this.resolveCallback = resolve5; + this.boundKeyDown = this.handleKeyDown.bind(this); + } + render() { + this.rootEl = this.containerEl.createDiv({ cls: "claudian-plan-approval-inline" }); + this.rootEl.createDiv({ cls: "claudian-plan-inline-title", text: "Plan complete" }); + const actionsEl = this.rootEl.createDiv({ cls: "claudian-ask-list" }); + const implementRow = actionsEl.createDiv({ cls: "claudian-ask-item" }); + implementRow.addClass("is-focused"); + implementRow.createSpan({ text: "\u203A", cls: "claudian-ask-cursor" }); + implementRow.createSpan({ text: "1. ", cls: "claudian-ask-item-num" }); + implementRow.createSpan({ text: "Implement", cls: "claudian-ask-item-label" }); + implementRow.addEventListener("click", () => { + this.focusedIndex = 0; + this.updateFocus(); + this.handleResolve({ type: "implement" }); + }); + this.items.push(implementRow); + const reviseRow = actionsEl.createDiv({ cls: "claudian-ask-item claudian-ask-custom-item" }); + reviseRow.createSpan({ text: "\xA0", cls: "claudian-ask-cursor" }); + reviseRow.createSpan({ text: "2. ", cls: "claudian-ask-item-num" }); + this.feedbackInput = reviseRow.createEl("input", { + type: "text", + cls: "claudian-ask-custom-text", + placeholder: "Enter feedback to revise plan..." + }); + this.feedbackInput.addEventListener("focus", () => { + this.isInputFocused = true; + }); + this.feedbackInput.addEventListener("blur", () => { + this.isInputFocused = false; + }); + reviseRow.addEventListener("click", () => { + this.focusedIndex = 1; + this.updateFocus(); + }); + this.items.push(reviseRow); + const cancelRow = actionsEl.createDiv({ cls: "claudian-ask-item" }); + cancelRow.createSpan({ text: "\xA0", cls: "claudian-ask-cursor" }); + cancelRow.createSpan({ text: "3. ", cls: "claudian-ask-item-num" }); + cancelRow.createSpan({ text: "Cancel", cls: "claudian-ask-item-label" }); + cancelRow.addEventListener("click", () => { + this.focusedIndex = 2; + this.updateFocus(); + this.handleResolve({ type: "cancel" }); + }); + this.items.push(cancelRow); + this.rootEl.createDiv({ text: HINTS_TEXT3, cls: "claudian-ask-hints" }); + this.rootEl.setAttribute("tabindex", "0"); + this.rootEl.addEventListener("keydown", this.boundKeyDown); + requestAnimationFrame(() => { + this.rootEl.focus(); + this.rootEl.scrollIntoView({ block: "nearest", behavior: "smooth" }); + }); + } + destroy() { + this.handleResolve(null); + } + handleKeyDown(e3) { + if (this.isInputFocused) { + if (e3.key === "Escape") { + e3.preventDefault(); + e3.stopPropagation(); + this.isInputFocused = false; + this.feedbackInput.blur(); + this.rootEl.focus(); + return; + } + if (e3.key === "Enter" && this.feedbackInput.value.trim()) { + e3.preventDefault(); + e3.stopPropagation(); + this.handleResolve({ type: "revise", text: this.feedbackInput.value.trim() }); + return; + } + return; + } + switch (e3.key) { + case "ArrowDown": + e3.preventDefault(); + e3.stopPropagation(); + this.focusedIndex = Math.min(this.focusedIndex + 1, this.items.length - 1); + this.updateFocus(); + break; + case "ArrowUp": + e3.preventDefault(); + e3.stopPropagation(); + this.focusedIndex = Math.max(this.focusedIndex - 1, 0); + this.updateFocus(); + break; + case "Enter": + e3.preventDefault(); + e3.stopPropagation(); + if (this.focusedIndex === 0) { + this.handleResolve({ type: "implement" }); + } else if (this.focusedIndex === 1) { + this.feedbackInput.focus(); + } else if (this.focusedIndex === 2) { + this.handleResolve({ type: "cancel" }); + } + break; + case "Escape": + e3.preventDefault(); + e3.stopPropagation(); + this.handleResolve(null); + break; + } + } + updateFocus() { + for (let i3 = 0; i3 < this.items.length; i3++) { + const item = this.items[i3]; + const cursor = item.querySelector(".claudian-ask-cursor"); + if (i3 === this.focusedIndex) { + item.addClass("is-focused"); + if (cursor) cursor.textContent = "\u203A"; + item.scrollIntoView({ block: "nearest" }); + if (item.hasClass("claudian-ask-custom-item")) { + const input = item.querySelector(".claudian-ask-custom-text"); + if (input) { + input.focus(); + this.isInputFocused = true; + } + } + } else { + item.removeClass("is-focused"); + if (cursor) cursor.textContent = "\xA0"; + if (item.hasClass("claudian-ask-custom-item") && this.isInputFocused) { + const input = item.querySelector(".claudian-ask-custom-text"); + if (input) { + input.blur(); + this.isInputFocused = false; + } + } + } + } + } + handleResolve(decision) { + var _a3, _b2; + if (!this.resolved) { + this.resolved = true; + (_a3 = this.rootEl) == null ? void 0 : _a3.removeEventListener("keydown", this.boundKeyDown); + (_b2 = this.rootEl) == null ? void 0 : _b2.remove(); + this.resolveCallback(decision); + } + } +}; + +// src/features/chat/rendering/ToolCallRenderer.ts +var import_obsidian23 = require("obsidian"); + +// src/core/tools/toolIcons.ts +var TOOL_ICONS = { + [TOOL_READ]: "file-text", + [TOOL_WRITE]: "file-plus", + [TOOL_EDIT]: "file-pen", + [TOOL_NOTEBOOK_EDIT]: "file-pen", + [TOOL_BASH]: "terminal", + [TOOL_BASH_OUTPUT]: "terminal", + [TOOL_KILL_SHELL]: "terminal", + [TOOL_GLOB]: "folder-search", + [TOOL_GREP]: "search", + [TOOL_LS]: "list", + [TOOL_TODO_WRITE]: "list-checks", + [TOOL_TASK]: "bot", + [TOOL_SUBAGENT_LEGACY]: "bot", + [TOOL_LIST_MCP_RESOURCES]: "list", + [TOOL_READ_MCP_RESOURCE]: "file-text", + [TOOL_MCP]: "wrench", + [TOOL_WEB_SEARCH]: "globe", + [TOOL_WEB_FETCH]: "download", + [TOOL_AGENT_OUTPUT]: "bot", + [TOOL_ASK_USER_QUESTION]: "help-circle", + [TOOL_SKILL]: "zap", + [TOOL_TOOL_SEARCH]: "search-check", + [TOOL_ENTER_PLAN_MODE]: "map", + [TOOL_EXIT_PLAN_MODE]: "check-circle", + // Runtime-managed tools + [TOOL_APPLY_PATCH]: "file-pen", + [TOOL_WRITE_STDIN]: "terminal", + [TOOL_SPAWN_AGENT]: "bot", + [TOOL_SEND_INPUT]: "bot", + [TOOL_WAIT]: "clock", + [TOOL_WAIT_AGENT]: "clock", + [TOOL_RESUME_AGENT]: "bot", + [TOOL_CLOSE_AGENT]: "bot" +}; +var MCP_ICON_MARKER = "__mcp_icon__"; +function getToolIcon(toolName) { + if (toolName.startsWith("mcp__")) { + return MCP_ICON_MARKER; + } + return TOOL_ICONS[toolName] || "wrench"; +} + +// src/shared/icons.ts +var MCP_ICON_SVG = `MCP`; +var CHECK_ICON_SVG = ``; + +// src/features/chat/rendering/DiffRenderer.ts +function splitIntoHunks(diffLines, contextLines = 3) { + if (diffLines.length === 0) return []; + const changedIndices = []; + for (let i3 = 0; i3 < diffLines.length; i3++) { + if (diffLines[i3].type !== "equal") { + changedIndices.push(i3); + } + } + if (changedIndices.length === 0) return []; + const ranges = []; + for (const idx of changedIndices) { + const start = Math.max(0, idx - contextLines); + const end = Math.min(diffLines.length - 1, idx + contextLines); + if (ranges.length > 0 && start <= ranges[ranges.length - 1].end + 1) { + ranges[ranges.length - 1].end = end; + } else { + ranges.push({ start, end }); + } + } + const hunks = []; + for (const range of ranges) { + const lines = diffLines.slice(range.start, range.end + 1); + let oldStart = 1; + let newStart = 1; + for (let i3 = 0; i3 < range.start; i3++) { + const line = diffLines[i3]; + if (line.type === "equal" || line.type === "delete") oldStart++; + if (line.type === "equal" || line.type === "insert") newStart++; + } + hunks.push({ lines, oldStart, newStart }); + } + return hunks; +} +var NEW_FILE_DISPLAY_CAP = 20; +function renderDiffContent(containerEl, diffLines, contextLines = 3) { + containerEl.empty(); + const allInserts = diffLines.length > 0 && diffLines.every((l3) => l3.type === "insert"); + if (allInserts && diffLines.length > NEW_FILE_DISPLAY_CAP) { + const hunkEl = containerEl.createDiv({ cls: "claudian-diff-hunk" }); + for (const line of diffLines.slice(0, NEW_FILE_DISPLAY_CAP)) { + const lineEl = hunkEl.createDiv({ cls: "claudian-diff-line claudian-diff-insert" }); + const prefixEl = lineEl.createSpan({ cls: "claudian-diff-prefix" }); + prefixEl.setText("+"); + const contentEl = lineEl.createSpan({ cls: "claudian-diff-text" }); + contentEl.setText(line.text || " "); + } + const remaining = diffLines.length - NEW_FILE_DISPLAY_CAP; + const separator = containerEl.createDiv({ cls: "claudian-diff-separator" }); + separator.setText(`... ${remaining} more lines`); + return; + } + const hunks = splitIntoHunks(diffLines, contextLines); + if (hunks.length === 0) { + const noChanges = containerEl.createDiv({ cls: "claudian-diff-no-changes" }); + noChanges.setText("No changes"); + return; + } + hunks.forEach((hunk, hunkIndex) => { + if (hunkIndex > 0) { + const separator = containerEl.createDiv({ cls: "claudian-diff-separator" }); + separator.setText("..."); + } + const hunkEl = containerEl.createDiv({ cls: "claudian-diff-hunk" }); + for (const line of hunk.lines) { + const lineEl = hunkEl.createDiv({ cls: `claudian-diff-line claudian-diff-${line.type}` }); + const prefix = line.type === "insert" ? "+" : line.type === "delete" ? "-" : " "; + const prefixEl = lineEl.createSpan({ cls: "claudian-diff-prefix" }); + prefixEl.setText(prefix); + const contentEl = lineEl.createSpan({ cls: "claudian-diff-text" }); + contentEl.setText(line.text || " "); + } + }); +} + +// src/features/chat/rendering/todoUtils.ts +var import_obsidian22 = require("obsidian"); +function getTodoStatusIcon(status) { + return status === "completed" ? "check" : "dot"; +} +function getTodoDisplayText(todo) { + return todo.status === "in_progress" ? todo.activeForm : todo.content; +} +function renderTodoItems(container, todos) { + container.empty(); + for (const todo of todos) { + const item = container.createDiv({ cls: `claudian-todo-item claudian-todo-${todo.status}` }); + const icon = item.createSpan({ cls: "claudian-todo-status-icon" }); + icon.setAttribute("aria-hidden", "true"); + (0, import_obsidian22.setIcon)(icon, getTodoStatusIcon(todo.status)); + const text = item.createSpan({ cls: "claudian-todo-text" }); + text.setText(getTodoDisplayText(todo)); + } +} + +// src/features/chat/rendering/ToolCallRenderer.ts +function setToolIcon(el2, name) { + const icon = getToolIcon(name); + if (icon === MCP_ICON_MARKER) { + el2.innerHTML = MCP_ICON_SVG; + } else { + (0, import_obsidian23.setIcon)(el2, icon); + } +} +function getToolName(name, input) { + switch (name) { + case TOOL_TODO_WRITE: { + const todos = input.todos; + if (todos && Array.isArray(todos) && todos.length > 0) { + const completed = todos.filter((t3) => t3.status === "completed").length; + return `Tasks ${completed}/${todos.length}`; + } + return "Tasks"; + } + case TOOL_ENTER_PLAN_MODE: + return "Entering plan mode"; + case TOOL_EXIT_PLAN_MODE: + return "Plan complete"; + default: + return name; + } +} +function getToolSummary(name, input) { + switch (name) { + case TOOL_READ: + case TOOL_WRITE: + case TOOL_EDIT: { + const filePath = input.file_path || ""; + return fileNameOnly(filePath); + } + case TOOL_BASH: { + const cmd = input.command || ""; + return truncateText(cmd, 60); + } + case TOOL_GLOB: + case TOOL_GREP: + return input.pattern || ""; + case TOOL_WEB_SEARCH: + return getWebSearchSummary(input, 60); + case TOOL_WEB_FETCH: + return truncateText(input.url || "", 60); + case TOOL_LS: + return fileNameOnly(input.path || "."); + case TOOL_SKILL: + return input.skill || ""; + case TOOL_TOOL_SEARCH: + return truncateText(parseToolSearchQuery(input.query), 60); + case TOOL_TODO_WRITE: + return ""; + case TOOL_APPLY_PATCH: + return getApplyPatchSummary(input); + case TOOL_WRITE_STDIN: + return getWriteStdinSummary(input); + default: + if (isAgentLifecycleTool(name)) { + return getAgentLifecycleSummary(name, input); + } + return ""; + } +} +function getToolLabel(name, input) { + switch (name) { + case TOOL_READ: + return `Read: ${shortenPath(input.file_path) || "file"}`; + case TOOL_WRITE: + return `Write: ${shortenPath(input.file_path) || "file"}`; + case TOOL_EDIT: + return `Edit: ${shortenPath(input.file_path) || "file"}`; + case TOOL_BASH: { + const cmd = input.command || "command"; + return `Bash: ${cmd.length > 40 ? cmd.substring(0, 40) + "..." : cmd}`; + } + case TOOL_GLOB: + return `Glob: ${input.pattern || "files"}`; + case TOOL_GREP: + return `Grep: ${input.pattern || "pattern"}`; + case TOOL_WEB_SEARCH: { + return getWebSearchLabel(input, 40); + } + case TOOL_WEB_FETCH: { + const url2 = input.url || "url"; + return `WebFetch: ${url2.length > 40 ? url2.substring(0, 40) + "..." : url2}`; + } + case TOOL_LS: + return `LS: ${shortenPath(input.path) || "."}`; + case TOOL_TODO_WRITE: { + const todos = input.todos; + if (todos && Array.isArray(todos)) { + const completed = todos.filter((t3) => t3.status === "completed").length; + return `Tasks (${completed}/${todos.length})`; + } + return "Tasks"; + } + case TOOL_SKILL: { + const skillName = input.skill || "skill"; + return `Skill: ${skillName}`; + } + case TOOL_TOOL_SEARCH: { + const tools = parseToolSearchQuery(input.query); + return `ToolSearch: ${tools || "tools"}`; + } + case TOOL_ENTER_PLAN_MODE: + return "Entering plan mode"; + case TOOL_EXIT_PLAN_MODE: + return "Plan complete"; + case TOOL_APPLY_PATCH: { + const summary = getApplyPatchSummary(input); + return summary ? `apply_patch: ${summary}` : "apply_patch"; + } + case TOOL_WRITE_STDIN: { + const summary = getWriteStdinSummary(input); + return summary ? `write_stdin: ${summary}` : "write_stdin"; + } + default: + if (isAgentLifecycleTool(name)) { + const summary = getAgentLifecycleSummary(name, input); + return summary ? `${name}: ${summary}` : name; + } + return name; + } +} +function fileNameOnly(filePath) { + var _a3; + if (!filePath) return ""; + const normalized = filePath.replace(/\\/g, "/"); + return (_a3 = normalized.split("/").pop()) != null ? _a3 : normalized; +} +function getApplyPatchSummary(input) { + const patchText = typeof input.patch === "string" ? input.patch : ""; + const patchFiles = [...patchText.matchAll(/^\*\*\* (?:Add|Update|Delete) File: (.+)$/gm)].map((m3) => { + var _a3, _b2; + return (_b2 = (_a3 = m3[1]) == null ? void 0 : _a3.trim()) != null ? _b2 : ""; + }); + const changes = input.changes; + const changeFiles = Array.isArray(changes) ? changes.map((c) => c.path).filter((p) => !!p) : []; + const files = [.../* @__PURE__ */ new Set([...patchFiles, ...changeFiles])]; + if (files.length === 0) return patchText ? "patch" : ""; + if (files.length === 1) return fileNameOnly(files[0]); + return `${files.length} files`; +} +function getWriteStdinSummary(input) { + var _a3; + const sessionId = (_a3 = input.session_id) != null ? _a3 : input.sessionId; + const chars = typeof input.chars === "string" ? input.chars.replace(/\n/g, "\\n") : ""; + if (chars) { + const preview = chars.length > 24 ? `${chars.slice(0, 24)}...` : chars; + return sessionId ? `#${String(sessionId)} ${preview}` : preview; + } + return sessionId ? `#${String(sessionId)}` : ""; +} +function getAgentLifecycleSummary(name, input) { + switch (name) { + case "spawn_agent": { + const msg = typeof input.message === "string" ? input.message : ""; + return msg.length > 50 ? `${msg.slice(0, 50)}...` : msg; + } + case "send_input": { + const msg = typeof input.message === "string" ? input.message : ""; + return msg.length > 40 ? `${msg.slice(0, 40)}...` : msg; + } + case "wait": { + const ids = Array.isArray(input.ids) ? input.ids.length : 0; + const timeoutMs = typeof input.timeout_ms === "number" ? input.timeout_ms : void 0; + const parts = []; + if (ids > 0) parts.push(`${ids} agent${ids === 1 ? "" : "s"}`); + if (timeoutMs !== void 0) parts.push(`${Math.round(timeoutMs / 1e3)}s`); + return parts.join(", "); + } + case "resume_agent": + case "close_agent": + return ""; + default: + return ""; + } +} +function shortenPath(filePath) { + if (!filePath) return ""; + const normalized = filePath.replace(/\\/g, "/"); + const parts = normalized.split("/"); + if (parts.length <= 3) return normalized; + return ".../" + parts.slice(-2).join("/"); +} +function truncateText(text, maxLength) { + if (text.length <= maxLength) return text; + return text.substring(0, maxLength) + "..."; +} +function parseToolSearchQuery(query) { + if (!query) return ""; + const selectPrefix = "select:"; + const body = query.startsWith(selectPrefix) ? query.slice(selectPrefix.length) : query; + return body.split(",").map((s3) => s3.trim()).filter(Boolean).join(", "); +} +function normalizeWebSearchDisplayData(input) { + var _a3; + const queries = Array.isArray(input.queries) ? input.queries.filter((entry) => typeof entry === "string" && entry.trim().length > 0).map((entry) => entry.trim()) : []; + const query = typeof input.query === "string" && input.query.trim() ? input.query.trim() : (_a3 = queries[0]) != null ? _a3 : ""; + const url2 = typeof input.url === "string" && input.url.trim() ? input.url.trim() : ""; + const pattern = typeof input.pattern === "string" && input.pattern.trim() ? input.pattern.trim() : ""; + const explicitActionType = typeof input.actionType === "string" && input.actionType.trim() ? input.actionType.trim() : ""; + const actionType = explicitActionType || (url2 && pattern ? "find_in_page" : url2 ? "open_page" : query || queries.length > 0 ? "search" : ""); + return { actionType, query, queries, url: url2, pattern }; +} +function getWebSearchSummary(input, maxLength) { + const data = normalizeWebSearchDisplayData(input); + switch (data.actionType) { + case "open_page": + return truncateText(`Open ${data.url || "page"}`, maxLength); + case "find_in_page": { + const target = data.pattern ? `Find "${data.pattern}"` : "Find in page"; + const suffix = data.url ? ` in ${data.url}` : ""; + return truncateText(target + suffix, maxLength); + } + case "search": + return truncateText(data.query || data.queries[0] || "", maxLength); + default: + return truncateText(data.query || data.url || data.pattern || "", maxLength); + } +} +function getWebSearchLabel(input, maxLength) { + const summary = getWebSearchSummary(input, maxLength); + return `WebSearch: ${summary || "search"}`; +} +function appendToolLink(parent, title, url2) { + const linkEl = parent.createEl("a", { cls: "claudian-tool-link" }); + linkEl.setAttribute("href", url2); + linkEl.setAttribute("target", "_blank"); + linkEl.setAttribute("rel", "noopener noreferrer"); + const iconEl = linkEl.createSpan({ cls: "claudian-tool-link-icon" }); + (0, import_obsidian23.setIcon)(iconEl, "external-link"); + linkEl.createSpan({ cls: "claudian-tool-link-title", text: title }); +} +function isPlaceholderWebSearchResult(result) { + if (!result) return true; + const normalized = result.trim().toLowerCase(); + return normalized === "" || normalized === "search complete"; +} +function parseWebSearchResult(result) { + const linksMatch = result.match(/Links:\s*(\[[\s\S]*?\])(?:\n|$)/); + if (!linksMatch) return null; + try { + const parsed = JSON.parse(linksMatch[1]); + if (!Array.isArray(parsed) || parsed.length === 0) return null; + const linksEndIndex = result.indexOf(linksMatch[0]) + linksMatch[0].length; + const summary = result.slice(linksEndIndex).trim(); + return { links: parsed.filter((l3) => l3.title && l3.url), summary }; + } catch (e3) { + return null; + } +} +function renderWebSearchActionExpanded(container, input) { + const data = normalizeWebSearchDisplayData(input); + const hasStructuredData = Boolean(data.actionType || data.query || data.queries.length || data.url || data.pattern); + if (!hasStructuredData) { + return false; + } + const linesEl = container.createDiv({ cls: "claudian-tool-lines" }); + switch (data.actionType) { + case "open_page": + linesEl.createDiv({ cls: "claudian-tool-line", text: "Open page" }); + if (data.url) { + appendToolLink(linesEl, data.url, data.url); + } else { + linesEl.createDiv({ cls: "claudian-tool-line", text: "URL unavailable" }); + } + return true; + case "find_in_page": + linesEl.createDiv({ cls: "claudian-tool-line", text: "Find in page" }); + if (data.url) { + appendToolLink(linesEl, data.url, data.url); + } else { + linesEl.createDiv({ cls: "claudian-tool-line", text: "URL unavailable" }); + } + if (data.pattern) { + linesEl.createDiv({ cls: "claudian-tool-line", text: `Pattern: ${data.pattern}` }); + } + return true; + case "search": + default: { + const primaryQuery = data.query || data.queries[0]; + linesEl.createDiv({ + cls: "claudian-tool-line", + text: primaryQuery ? `Query: ${primaryQuery}` : "Search web" + }); + const alternateQueries = data.queries.filter((query) => query !== primaryQuery); + for (const query of alternateQueries.slice(0, 4)) { + linesEl.createDiv({ cls: "claudian-tool-line", text: `Alt query: ${query}` }); + } + if (alternateQueries.length > 4) { + linesEl.createDiv({ + cls: "claudian-tool-truncated", + text: `... ${alternateQueries.length - 4} more queries` + }); + } + return true; + } + } +} +function renderWebSearchExpanded(container, input, result) { + const parsed = result ? parseWebSearchResult(result) : null; + if (parsed && parsed.links.length > 0) { + const linksEl = container.createDiv({ cls: "claudian-tool-lines" }); + for (const link of parsed.links) { + appendToolLink(linksEl, link.title, link.url); + } + if (parsed.summary) { + const summaryEl = container.createDiv({ cls: "claudian-tool-web-summary" }); + summaryEl.setText(parsed.summary.length > 800 ? parsed.summary.slice(0, 800) + "..." : parsed.summary); + } + return; + } + const data = normalizeWebSearchDisplayData(input); + const shouldRenderAction = Boolean(data.actionType || data.query || data.queries.length || data.url || data.pattern) && (!result || isPlaceholderWebSearchResult(result) || data.actionType === "open_page" || data.actionType === "find_in_page"); + if (shouldRenderAction && renderWebSearchActionExpanded(container, input)) { + if (result && !isPlaceholderWebSearchResult(result)) { + renderLinesExpanded(container, result, 12); + } + return; + } + if (result) { + renderLinesExpanded(container, result, 20); + return; + } + if (renderWebSearchActionExpanded(container, input)) { + return; + } + container.createDiv({ cls: "claudian-tool-empty", text: "No result" }); +} +function renderFileSearchExpanded(container, result) { + const lines = result.split(/\r?\n/).filter((line) => line.trim()); + if (lines.length === 0) { + container.createDiv({ cls: "claudian-tool-empty", text: "No matches found" }); + return; + } + renderLinesExpanded(container, result, 15, true); +} +function renderLinesExpanded(container, result, maxLines, hoverable = false) { + const lines = result.split(/\r?\n/); + const truncated = lines.length > maxLines; + const displayLines = truncated ? lines.slice(0, maxLines) : lines; + const linesEl = container.createDiv({ cls: "claudian-tool-lines" }); + for (const line of displayLines) { + const stripped = line.replace(/^\s*\d+→/, ""); + const lineEl = linesEl.createDiv({ cls: "claudian-tool-line" }); + if (hoverable) lineEl.addClass("hoverable"); + lineEl.setText(stripped || " "); + } + if (truncated) { + linesEl.createDiv({ + cls: "claudian-tool-truncated", + text: `... ${lines.length - maxLines} more lines` + }); + } +} +function renderToolSearchExpanded(container, result) { + let toolNames = []; + try { + const parsed = JSON.parse(result); + if (Array.isArray(parsed)) { + toolNames = parsed.filter((item) => item.type === "tool_reference" && item.tool_name).map((item) => item.tool_name); + } + } catch (e3) { + } + if (toolNames.length === 0) { + renderLinesExpanded(container, result, 20); + return; + } + for (const name of toolNames) { + const lineEl = container.createDiv({ cls: "claudian-tool-search-item" }); + const iconEl = lineEl.createSpan({ cls: "claudian-tool-search-icon" }); + setToolIcon(iconEl, name); + lineEl.createSpan({ text: name }); + } +} +function renderWebFetchExpanded(container, result) { + const maxChars = 500; + const linesEl = container.createDiv({ cls: "claudian-tool-lines" }); + const lineEl = linesEl.createDiv({ cls: "claudian-tool-line" }); + lineEl.style.whiteSpace = "pre-wrap"; + lineEl.style.wordBreak = "break-word"; + if (result.length > maxChars) { + lineEl.setText(result.slice(0, maxChars)); + linesEl.createDiv({ + cls: "claudian-tool-truncated", + text: `... ${result.length - maxChars} more characters` + }); + } else { + lineEl.setText(result); + } +} +function renderApplyPatchExpanded(container, input, result) { + var _a3; + const patchText = typeof input.patch === "string" ? input.patch : ""; + const parsedDiffs = patchText ? parseApplyPatchDiffs(patchText) : []; + if (result && /verification failed|^[Ee]rror:/.test(result.trim())) { + renderLinesExpanded(container, result, 20); + } + if (parsedDiffs.length > 0) { + for (const fileDiff of parsedDiffs) { + const sectionEl = container.createDiv({ cls: "claudian-tool-patch-section" }); + const statsSuffix = fileDiff.stats.added || fileDiff.stats.removed ? ` (+${fileDiff.stats.added} -${fileDiff.stats.removed})` : ""; + const pathText = fileDiff.movedTo ? `${fileDiff.filePath} -> ${fileDiff.movedTo}` : fileDiff.filePath; + sectionEl.createDiv({ + cls: "claudian-tool-patch-header", + text: `${fileDiff.operation}: ${pathText}${statsSuffix}` + }); + if (fileDiff.operation === "delete" && fileDiff.diffLines.length === 0) { + sectionEl.createDiv({ cls: "claudian-tool-empty", text: "File deleted" }); + continue; + } + if (fileDiff.diffLines.length === 0) { + sectionEl.createDiv({ cls: "claudian-tool-empty", text: "No textual diff available" }); + continue; + } + const diffRow = sectionEl.createDiv({ cls: "claudian-write-edit-diff-row" }); + const diffEl = diffRow.createDiv({ cls: "claudian-write-edit-diff" }); + renderDiffContent(diffEl, fileDiff.diffLines); + } + return; + } + const changes = Array.isArray(input.changes) ? input.changes : []; + if (changes.length > 0) { + const linesEl = container.createDiv({ cls: "claudian-tool-lines" }); + for (const change of changes) { + if (!change || typeof change !== "object") continue; + const path19 = typeof change.path === "string" ? change.path : ""; + const kind = typeof change.kind === "string" ? change.kind : "change"; + if (!path19) continue; + linesEl.createDiv({ cls: "claudian-tool-line", text: `${kind}: ${path19}` }); + } + return; + } + if (patchText) { + renderLinesExpanded(container, patchText, 80); + return; + } + if (result) { + const fileMatches = [...result.matchAll(/(?:update|add|delete|create|modify|Applied:\s*)(?:\w+:\s*)?([^\n,]+)/gi)]; + if (fileMatches.length > 0) { + const linesEl = container.createDiv({ cls: "claudian-tool-lines" }); + for (const match of fileMatches) { + const filePath = (_a3 = match[1]) == null ? void 0 : _a3.trim(); + if (filePath) { + const lineEl = linesEl.createDiv({ cls: "claudian-tool-line" }); + lineEl.setText(filePath); + } + } + return; + } + renderLinesExpanded(container, result, 20); + return; + } + container.createDiv({ cls: "claudian-tool-empty", text: "No result" }); +} +function renderAgentLifecycleExpanded(container, result) { + const trimmed = result.trim(); + if (trimmed.startsWith("{")) { + try { + const parsed = JSON.parse(trimmed); + const linesEl = container.createDiv({ cls: "claudian-tool-lines" }); + for (const [key, value] of Object.entries(parsed)) { + const lineEl = linesEl.createDiv({ cls: "claudian-tool-line" }); + const displayValue = typeof value === "object" ? JSON.stringify(value) : String(value); + lineEl.setText(`${key}: ${displayValue}`); + } + return; + } catch (e3) { + } + } + renderLinesExpanded(container, result, 20); +} +function renderExpandedContent(container, toolName, result, input = {}) { + if (!result && toolName !== TOOL_WEB_SEARCH) { + container.createDiv({ cls: "claudian-tool-empty", text: "No result" }); + return; + } + const resolvedResult = result != null ? result : ""; + if (isAgentLifecycleTool(toolName)) { + renderAgentLifecycleExpanded(container, resolvedResult); + return; + } + switch (toolName) { + case TOOL_BASH: + case TOOL_WRITE_STDIN: + renderLinesExpanded(container, resolvedResult, 20); + break; + case TOOL_READ: + renderLinesExpanded(container, resolvedResult, 15); + break; + case TOOL_GLOB: + case TOOL_GREP: + case TOOL_LS: + renderFileSearchExpanded(container, resolvedResult); + break; + case TOOL_WEB_SEARCH: + renderWebSearchExpanded(container, input, result); + break; + case TOOL_WEB_FETCH: + renderWebFetchExpanded(container, resolvedResult); + break; + case TOOL_TOOL_SEARCH: + renderToolSearchExpanded(container, resolvedResult); + break; + case TOOL_APPLY_PATCH: + renderApplyPatchExpanded(container, input, result); + break; + default: + renderLinesExpanded(container, resolvedResult, 20); + break; + } +} +function getTodos(input) { + const todos = input.todos; + if (!todos || !Array.isArray(todos)) return void 0; + return todos; +} +function getCurrentTask(input) { + const todos = getTodos(input); + if (!todos) return void 0; + return todos.find((t3) => t3.status === "in_progress"); +} +function areAllTodosCompleted(input) { + const todos = getTodos(input); + if (!todos || todos.length === 0) return false; + return todos.every((t3) => t3.status === "completed"); +} +function resetStatusElement(statusEl, statusClass, ariaLabel) { + statusEl.className = "claudian-tool-status"; + statusEl.empty(); + statusEl.addClass(statusClass); + statusEl.setAttribute("aria-label", ariaLabel); +} +var STATUS_ICONS = { + completed: "check", + error: "x", + blocked: "shield-off" +}; +function setTodoWriteStatus(statusEl, input) { + const isComplete = areAllTodosCompleted(input); + const status = isComplete ? "completed" : "running"; + const ariaLabel = isComplete ? "Status: completed" : "Status: in progress"; + resetStatusElement(statusEl, `status-${status}`, ariaLabel); + if (isComplete) (0, import_obsidian23.setIcon)(statusEl, "check"); +} +function setToolStatus(statusEl, status) { + resetStatusElement(statusEl, `status-${status}`, `Status: ${status}`); + const icon = STATUS_ICONS[status]; + if (icon) (0, import_obsidian23.setIcon)(statusEl, icon); +} +function renderTodoWriteResult(container, input) { + container.empty(); + container.addClass("claudian-todo-panel-content"); + container.addClass("claudian-todo-list-container"); + const todos = input.todos; + if (!todos || !Array.isArray(todos)) { + const item = container.createSpan({ cls: "claudian-tool-result-item" }); + item.setText("Tasks updated"); + return; + } + renderTodoItems(container, todos); +} +function isBlockedToolResult(content, isError) { + const lower = content.toLowerCase(); + if (lower.includes("outside the vault")) return true; + if (lower.includes("access denied")) return true; + if (lower.includes("user denied")) return true; + if (lower.includes("approval")) return true; + if (isError && lower.includes("deny")) return true; + return false; +} +function createToolElementStructure(parentEl, toolCall) { + const toolEl = parentEl.createDiv({ cls: "claudian-tool-call" }); + const header = toolEl.createDiv({ cls: "claudian-tool-header" }); + header.setAttribute("tabindex", "0"); + header.setAttribute("role", "button"); + const iconEl = header.createSpan({ cls: "claudian-tool-icon" }); + iconEl.setAttribute("aria-hidden", "true"); + setToolIcon(iconEl, toolCall.name); + const nameEl = header.createSpan({ cls: "claudian-tool-name" }); + nameEl.setText(getToolName(toolCall.name, toolCall.input)); + const summaryEl = header.createSpan({ cls: "claudian-tool-summary" }); + summaryEl.setText(getToolSummary(toolCall.name, toolCall.input)); + const currentTaskEl = toolCall.name === TOOL_TODO_WRITE ? createCurrentTaskPreview(header, toolCall.input) : null; + const statusEl = header.createSpan({ cls: "claudian-tool-status" }); + const content = toolEl.createDiv({ cls: "claudian-tool-content" }); + return { toolEl, header, iconEl, nameEl, summaryEl, statusEl, content, currentTaskEl }; +} +function formatAnswer(raw) { + if (Array.isArray(raw)) return raw.join(", "); + if (typeof raw === "string") return raw; + return ""; +} +function resolveAskUserAnswers(toolCall) { + if (toolCall.resolvedAnswers) return toolCall.resolvedAnswers; + const parsed = extractResolvedAnswersFromResultText(toolCall.result); + if (parsed) { + toolCall.resolvedAnswers = parsed; + return parsed; + } + return void 0; +} +function renderAskUserQuestionResult(container, toolCall) { + var _a3; + container.empty(); + const questions = toolCall.input.questions; + const answers = resolveAskUserAnswers(toolCall); + if (!questions || !Array.isArray(questions) || !answers) return false; + const reviewEl = container.createDiv({ cls: "claudian-ask-review" }); + for (let i3 = 0; i3 < questions.length; i3++) { + const q3 = questions[i3]; + const answer = formatAnswer( + (_a3 = q3.id ? answers[q3.id] : void 0) != null ? _a3 : answers[q3.question] + ); + const pairEl = reviewEl.createDiv({ cls: "claudian-ask-review-pair" }); + pairEl.createDiv({ text: `${i3 + 1}.`, cls: "claudian-ask-review-num" }); + const bodyEl = pairEl.createDiv({ cls: "claudian-ask-review-body" }); + bodyEl.createDiv({ text: q3.question, cls: "claudian-ask-review-q-text" }); + bodyEl.createDiv({ + text: answer || "Not answered", + cls: answer ? "claudian-ask-review-a-text" : "claudian-ask-review-empty" + }); + } + return true; +} +function renderAskUserQuestionFallback(container, toolCall, initialText) { + container.empty(); + const questions = Array.isArray(toolCall.input.questions) ? toolCall.input.questions : []; + if (questions.length === 0) { + contentFallback(container, initialText || toolCall.result || "Waiting for answer..."); + return; + } + if (initialText || toolCall.result) { + container.createDiv({ + cls: "claudian-ask-review-prompt", + text: initialText || toolCall.result || "Waiting for answer..." + }); + } + for (let questionIndex = 0; questionIndex < questions.length; questionIndex++) { + const question = questions[questionIndex]; + const reviewEl = container.createDiv({ cls: "claudian-ask-review" }); + const pairEl = reviewEl.createDiv({ cls: "claudian-ask-review-pair" }); + pairEl.createDiv({ text: `${questionIndex + 1}.`, cls: "claudian-ask-review-num" }); + const bodyEl = pairEl.createDiv({ cls: "claudian-ask-review-body" }); + bodyEl.createDiv({ text: question.question, cls: "claudian-ask-review-q-text" }); + if (!Array.isArray(question.options) || question.options.length === 0) { + bodyEl.createDiv({ cls: "claudian-ask-review-empty", text: "No options recorded" }); + continue; + } + const listEl = bodyEl.createDiv({ cls: "claudian-ask-list" }); + question.options.forEach((option, optionIndex) => { + renderAskUserQuestionOption(listEl, option, optionIndex, question.multiSelect === true); + }); + } +} +function renderAskUserQuestionOption(parentEl, option, optionIndex, isMultiSelect) { + const itemEl = parentEl.createDiv({ cls: "claudian-ask-item is-disabled" }); + if (isMultiSelect) { + itemEl.createDiv({ cls: "claudian-ask-check", text: "[ ] " }); + } else { + itemEl.createDiv({ cls: "claudian-ask-item-num", text: `${optionIndex + 1}. ` }); + } + const contentEl = itemEl.createDiv({ cls: "claudian-ask-item-content" }); + const labelRowEl = contentEl.createDiv({ cls: "claudian-ask-label-row" }); + labelRowEl.createDiv({ cls: "claudian-ask-item-label", text: option.label }); + if (option.description) { + contentEl.createDiv({ cls: "claudian-ask-item-desc", text: option.description }); + } +} +function contentFallback(container, text) { + const resultRow = container.createDiv({ cls: "claudian-tool-result-row" }); + const resultText = resultRow.createSpan({ cls: "claudian-tool-result-text" }); + resultText.setText(text); +} +function createCurrentTaskPreview(header, input) { + const currentTaskEl = header.createSpan({ cls: "claudian-tool-current" }); + const currentTask = getCurrentTask(input); + if (currentTask) { + currentTaskEl.setText(currentTask.activeForm); + } + return currentTaskEl; +} +function createTodoToggleHandler(currentTaskEl, statusEl, onExpandChange) { + return (expanded) => { + if (onExpandChange) onExpandChange(expanded); + if (currentTaskEl) { + currentTaskEl.style.display = expanded ? "none" : ""; + } + if (statusEl) { + statusEl.style.display = expanded ? "none" : ""; + } + }; +} +function renderToolContent(content, toolCall, initialText) { + if (toolCall.name === TOOL_TODO_WRITE) { + content.addClass("claudian-tool-content-todo"); + renderTodoWriteResult(content, toolCall.input); + } else if (toolCall.name === TOOL_ASK_USER_QUESTION) { + content.addClass("claudian-tool-content-ask"); + if (initialText) { + renderAskUserQuestionFallback(content, toolCall, "Waiting for answer..."); + } else if (!renderAskUserQuestionResult(content, toolCall)) { + renderAskUserQuestionFallback(content, toolCall); + } + } else if (initialText) { + contentFallback(content, initialText); + } else { + renderExpandedContent(content, toolCall.name, toolCall.result, toolCall.input); + } +} +function renderToolCall(parentEl, toolCall, toolCallElements) { + const { toolEl, header, statusEl, content, currentTaskEl } = createToolElementStructure(parentEl, toolCall); + toolEl.dataset.toolId = toolCall.id; + toolCallElements.set(toolCall.id, toolEl); + statusEl.addClass(`status-${toolCall.status}`); + statusEl.setAttribute("aria-label", `Status: ${toolCall.status}`); + renderToolContent(content, toolCall, "Running..."); + const state = { isExpanded: false }; + toolCall.isExpanded = false; + const todoStatusEl = toolCall.name === TOOL_TODO_WRITE ? statusEl : null; + setupCollapsible(toolEl, header, content, state, { + initiallyExpanded: false, + onToggle: createTodoToggleHandler(currentTaskEl, todoStatusEl, (expanded) => { + toolCall.isExpanded = expanded; + }), + baseAriaLabel: getToolLabel(toolCall.name, toolCall.input) + }); + return toolEl; +} +function updateToolCallResult(toolId, toolCall, toolCallElements) { + const toolEl = toolCallElements.get(toolId); + if (!toolEl) return; + if (toolCall.name === TOOL_TODO_WRITE) { + const statusEl2 = toolEl.querySelector(".claudian-tool-status"); + if (statusEl2) { + setTodoWriteStatus(statusEl2, toolCall.input); + } + const content2 = toolEl.querySelector(".claudian-tool-content"); + if (content2) { + renderTodoWriteResult(content2, toolCall.input); + } + const nameEl = toolEl.querySelector(".claudian-tool-name"); + if (nameEl) { + nameEl.setText(getToolName(toolCall.name, toolCall.input)); + } + const currentTaskEl = toolEl.querySelector(".claudian-tool-current"); + if (currentTaskEl) { + const currentTask = getCurrentTask(toolCall.input); + currentTaskEl.setText(currentTask ? currentTask.activeForm : ""); + } + return; + } + const statusEl = toolEl.querySelector(".claudian-tool-status"); + if (statusEl) { + setToolStatus(statusEl, toolCall.status); + } + if (toolCall.name === TOOL_ASK_USER_QUESTION) { + const content2 = toolEl.querySelector(".claudian-tool-content"); + if (content2) { + content2.addClass("claudian-tool-content-ask"); + if (!renderAskUserQuestionResult(content2, toolCall)) { + renderAskUserQuestionFallback(content2, toolCall); + } + } + return; + } + const content = toolEl.querySelector(".claudian-tool-content"); + if (content) { + content.empty(); + renderExpandedContent(content, toolCall.name, toolCall.result, toolCall.input); + } +} +function renderStoredToolCall(parentEl, toolCall) { + const { toolEl, header, statusEl, content, currentTaskEl } = createToolElementStructure(parentEl, toolCall); + if (toolCall.name === TOOL_TODO_WRITE) { + setTodoWriteStatus(statusEl, toolCall.input); + } else { + setToolStatus(statusEl, toolCall.status); + } + renderToolContent(content, toolCall); + const state = { isExpanded: false }; + const todoStatusEl = toolCall.name === TOOL_TODO_WRITE ? statusEl : null; + setupCollapsible(toolEl, header, content, state, { + initiallyExpanded: false, + onToggle: createTodoToggleHandler(currentTaskEl, todoStatusEl), + baseAriaLabel: getToolLabel(toolCall.name, toolCall.input) + }); + return toolEl; +} + +// src/features/chat/controllers/InputController.ts +var APPROVAL_OPTION_MAP = { + "Deny": "deny", + "Allow once": "allow", + "Always allow": "allow-always" +}; +var DEFAULT_APPROVAL_DECISION_OPTIONS = Object.entries(APPROVAL_OPTION_MAP).map(([label, decision]) => ({ + label, + value: label, + decision +})); +var InputController = class { + constructor(deps) { + this.pendingApprovalInline = null; + this.pendingAskInline = null; + this.pendingExitPlanModeInline = null; + this.pendingPlanApproval = null; + this.pendingPlanApprovalInvalidated = false; + this.activeResumeDropdown = null; + this.inputContainerHideDepth = 0; + this.steerInFlight = false; + this.pendingSteerMessage = null; + this.activeStreamingAssistantMessage = null; + this.pendingProviderUserMessages = []; + this.sawInitialProviderUserMessage = false; + this.awaitingProviderAssistantStart = false; + this.deps = deps; + } + getAgentService() { + var _a3, _b2, _c; + return (_c = (_b2 = (_a3 = this.deps).getAgentService) == null ? void 0 : _b2.call(_a3)) != null ? _c : null; + } + getActiveProviderId() { + var _a3, _b2, _c, _d, _e, _f; + const agentService = this.getAgentService(); + const conversationId = this.deps.state.currentConversationId; + if (!conversationId) { + return (_d = (_c = (_b2 = (_a3 = this.deps).getTabProviderId) == null ? void 0 : _b2.call(_a3)) != null ? _c : agentService == null ? void 0 : agentService.providerId) != null ? _d : DEFAULT_CHAT_PROVIDER_ID; + } + if (agentService == null ? void 0 : agentService.providerId) { + return agentService.providerId; + } + return (_f = (_e = this.deps.plugin.getConversationSync(conversationId)) == null ? void 0 : _e.providerId) != null ? _f : DEFAULT_CHAT_PROVIDER_ID; + } + getActiveCapabilities() { + const providerId = this.getActiveProviderId(); + const agentService = this.getAgentService(); + if ((agentService == null ? void 0 : agentService.providerId) === providerId) { + return agentService.getCapabilities(); + } + return ProviderRegistry.getCapabilities(providerId); + } + isResumeSessionAtStillNeeded(resumeUuid, previousMessages) { + for (let i3 = previousMessages.length - 1; i3 >= 0; i3--) { + if (previousMessages[i3].role === "assistant" && previousMessages[i3].assistantMessageId === resumeUuid) { + return i3 === previousMessages.length - 1; + } + } + return false; + } + // ============================================ + // Message Sending + // ============================================ + async sendMessage(options) { + var _a3, _b2, _c, _d, _e, _f, _g, _h, _i, _j2, _k, _l; + const { + plugin, + state, + renderer, + streamController, + selectionController, + browserSelectionController, + canvasSelectionController, + conversationController + } = this.deps; + if (state.isCreatingConversation || state.isSwitchingConversation) return; + const inputEl = this.deps.getInputEl(); + const imageContextManager = this.deps.getImageContextManager(); + const fileContextManager = this.deps.getFileContextManager(); + const contentOverride = options == null ? void 0 : options.content; + const shouldUseInput = contentOverride === void 0; + const content = (contentOverride != null ? contentOverride : inputEl.value).trim(); + const hasImages = (_a3 = imageContextManager == null ? void 0 : imageContextManager.hasImages()) != null ? _a3 : false; + if (!content && !hasImages) return; + const builtInCmd = detectBuiltInCommand(content); + if (builtInCmd) { + if (shouldUseInput) { + inputEl.value = ""; + this.deps.resetInputHeight(); + } + await this.executeBuiltInCommand(builtInCmd.command, builtInCmd.args); + return; + } + if (state.isStreaming) { + const images2 = hasImages ? [...(imageContextManager == null ? void 0 : imageContextManager.getAttachedImages()) || []] : void 0; + const editorContext = selectionController.getContext(); + const browserContext = (_b2 = browserSelectionController == null ? void 0 : browserSelectionController.getContext()) != null ? _b2 : null; + const canvasContext = canvasSelectionController.getContext(); + state.queuedMessage = this.mergeQueuedMessages(state.queuedMessage, { + content, + images: images2, + editorContext, + browserContext, + canvasContext + }); + if (shouldUseInput) { + inputEl.value = ""; + this.deps.resetInputHeight(); + } + imageContextManager == null ? void 0 : imageContextManager.clearImages(); + this.updateQueueIndicator(); + return; + } + if (shouldUseInput) { + inputEl.value = ""; + this.deps.resetInputHeight(); + } + state.isStreaming = true; + state.cancelRequested = false; + state.ignoreUsageUpdates = false; + this.deps.getSubagentManager().resetSpawnedCount(); + state.autoScrollEnabled = (_c = plugin.settings.enableAutoScroll) != null ? _c : true; + const streamGeneration = state.bumpStreamGeneration(); + const welcomeEl = this.deps.getWelcomeEl(); + if (welcomeEl) { + welcomeEl.style.display = "none"; + } + fileContextManager == null ? void 0 : fileContextManager.startSession(); + const images = (imageContextManager == null ? void 0 : imageContextManager.getAttachedImages()) || []; + const imagesForMessage = images.length > 0 ? [...images] : void 0; + const isCompact = /^\/compact(\s|$)/i.test(content); + if (shouldUseInput) { + imageContextManager == null ? void 0 : imageContextManager.clearImages(); + } + const { displayContent, turnRequest } = this.buildTurnSubmission({ + content, + images: imagesForMessage, + editorContextOverride: options == null ? void 0 : options.editorContextOverride, + browserContextOverride: options == null ? void 0 : options.browserContextOverride, + canvasContextOverride: options == null ? void 0 : options.canvasContextOverride + }); + fileContextManager == null ? void 0 : fileContextManager.markCurrentNoteSent(); + const userMsg = { + id: this.deps.generateId(), + role: "user", + content: displayContent, + displayContent, + // Original user input (for UI display) + timestamp: Date.now(), + images: imagesForMessage + }; + state.addMessage(userMsg); + renderer.addMessage(userMsg); + await this.triggerTitleGeneration(); + const assistantMsg = { + id: this.deps.generateId(), + role: "assistant", + content: "", + timestamp: Date.now(), + toolCalls: [], + contentBlocks: [] + }; + state.addMessage(assistantMsg); + this.activeStreamingAssistantMessage = assistantMsg; + this.activateStreamingAssistantMessage(assistantMsg); + this.pendingProviderUserMessages = [{ + displayContent, + images: imagesForMessage + }]; + this.sawInitialProviderUserMessage = false; + this.awaitingProviderAssistantStart = true; + streamController.showThinkingIndicator( + isCompact ? "Compacting..." : void 0, + isCompact ? "claudian-thinking--compact" : void 0 + ); + state.responseStartTime = performance.now(); + let wasInterrupted = false; + let wasInvalidated = false; + let didEnqueueToSdk = false; + let planCompleted = false; + if (this.deps.ensureServiceInitialized) { + const ready = await this.deps.ensureServiceInitialized(); + if (!ready) { + new import_obsidian24.Notice("Failed to initialize agent service. Please try again."); + streamController.hideThinkingIndicator(); + state.isStreaming = false; + this.activeStreamingAssistantMessage = null; + this.resetProviderMessageBoundaryState(); + return; + } + } + const agentService = this.getAgentService(); + if (!agentService) { + new import_obsidian24.Notice("Agent service not available. Please reload the plugin."); + this.activeStreamingAssistantMessage = null; + this.resetProviderMessageBoundaryState(); + return; + } + const conversationIdForSend = state.currentConversationId; + if (conversationIdForSend) { + const conv = plugin.getConversationSync(conversationIdForSend); + if (conv == null ? void 0 : conv.resumeAtMessageId) { + if (this.isResumeSessionAtStillNeeded(conv.resumeAtMessageId, state.messages.slice(0, -2))) { + agentService.setResumeCheckpoint(conv.resumeAtMessageId); + } else { + try { + await plugin.updateConversation(conversationIdForSend, { resumeAtMessageId: void 0 }); + } catch (e3) { + } + } + } + } + try { + const preparedTurn = agentService.prepareTurn(turnRequest); + userMsg.content = preparedTurn.persistedContent; + userMsg.currentNote = preparedTurn.isCompact ? void 0 : preparedTurn.request.currentNotePath; + const previousMessages = state.messages.slice(0, -2); + for await (const chunk of agentService.query(preparedTurn, previousMessages)) { + if (state.streamGeneration !== streamGeneration) { + wasInvalidated = true; + break; + } + if (state.cancelRequested) { + wasInterrupted = true; + break; + } + if (this.handleProviderMessageBoundaryChunk(chunk)) { + continue; + } + await streamController.handleStreamChunk( + chunk, + (_d = this.activeStreamingAssistantMessage) != null ? _d : assistantMsg + ); + } + } catch (error48) { + const errorMsg = error48 instanceof Error ? error48.message : "Unknown error"; + await streamController.appendText(` + +**Error:** ${errorMsg}`); + } finally { + const finalAssistantMsg = (_e = this.activeStreamingAssistantMessage) != null ? _e : assistantMsg; + const turnMetadata = agentService.consumeTurnMetadata(); + userMsg.userMessageId = (_f = turnMetadata.userMessageId) != null ? _f : userMsg.userMessageId; + finalAssistantMsg.assistantMessageId = (_g = turnMetadata.assistantMessageId) != null ? _g : finalAssistantMsg.assistantMessageId; + didEnqueueToSdk = didEnqueueToSdk || turnMetadata.wasSent === true; + planCompleted = planCompleted || turnMetadata.planCompleted === true; + state.clearFlavorTimerInterval(); + if (!wasInvalidated && state.streamGeneration === streamGeneration) { + const didCancelThisTurn = wasInterrupted || state.cancelRequested; + if (didCancelThisTurn && !state.pendingNewSessionPlan) { + await streamController.appendText('\n\nInterrupted \xB7 What should Claudian do instead?'); + } + streamController.hideThinkingIndicator(); + state.isStreaming = false; + state.cancelRequested = false; + this.restorePendingSteerMessageToQueue(); + const hasCompactBoundary = (_h = finalAssistantMsg.contentBlocks) == null ? void 0 : _h.some((b) => b.type === "context_compacted"); + if (!didCancelThisTurn && !hasCompactBoundary) { + const durationSeconds = state.responseStartTime ? Math.floor((performance.now() - state.responseStartTime) / 1e3) : 0; + if (durationSeconds > 0) { + const flavorWord = COMPLETION_FLAVOR_WORDS[Math.floor(Math.random() * COMPLETION_FLAVOR_WORDS.length)]; + finalAssistantMsg.durationSeconds = durationSeconds; + finalAssistantMsg.durationFlavorWord = flavorWord; + if (state.currentContentEl) { + const footerEl = state.currentContentEl.createDiv({ cls: "claudian-response-footer" }); + footerEl.createSpan({ + text: `* ${flavorWord} for ${formatDurationMmSs(durationSeconds)}`, + cls: "claudian-baked-duration" + }); + } + } + } + state.currentContentEl = null; + streamController.finalizeCurrentThinkingBlock(finalAssistantMsg); + streamController.finalizeCurrentTextBlock(finalAssistantMsg); + this.deps.getSubagentManager().resetStreamingState(); + if (state.currentTodos && state.currentTodos.every((t3) => t3.status === "completed")) { + state.currentTodos = null; + } + this.syncScrollToBottomAfterRenderUpdates(); + if (state.pendingNewSessionPlan && finalAssistantMsg.toolCalls) { + for (const tc of finalAssistantMsg.toolCalls) { + if (tc.name === TOOL_EXIT_PLAN_MODE && !tc.result) { + tc.status = "completed"; + tc.result = "User approved the plan and started a new session."; + updateToolCallResult(tc.id, tc, state.toolCallElements); + } + } + } + let planAutoSendContent = null; + let planApprovalInvalidated = false; + let shouldProcessQueuedMessage = true; + if (planCompleted && !didCancelThisTurn) { + const { decision, invalidated } = await this.showPlanApproval(); + if (state.streamGeneration !== streamGeneration || invalidated) { + planApprovalInvalidated = true; + } else if ((decision == null ? void 0 : decision.type) === "implement") { + (_j2 = (_i = this.deps).restorePrePlanPermissionModeIfNeeded) == null ? void 0 : _j2.call(_i); + planAutoSendContent = "Implement the plan."; + } else if ((decision == null ? void 0 : decision.type) === "revise") { + this.deps.getInputEl().value = decision.text; + shouldProcessQueuedMessage = false; + } else { + (_l = (_k = this.deps).restorePrePlanPermissionModeIfNeeded) == null ? void 0 : _l.call(_k); + } + } + if (!planApprovalInvalidated) { + const saveExtras = didEnqueueToSdk ? { resumeAtMessageId: void 0 } : void 0; + await conversationController.save(true, saveExtras); + const userMsgIndex = state.messages.indexOf(userMsg); + renderer.refreshActionButtons(userMsg, state.messages, userMsgIndex >= 0 ? userMsgIndex : void 0); + if (planAutoSendContent) { + this.deps.getInputEl().value = planAutoSendContent; + this.sendMessage().catch(() => { + }); + } else { + const planContent = state.pendingNewSessionPlan; + if (planContent) { + state.pendingNewSessionPlan = null; + await conversationController.createNew(); + this.deps.getInputEl().value = planContent; + this.sendMessage().catch(() => { + }); + } else if (shouldProcessQueuedMessage) { + this.processQueuedMessage(); + } + } + } + } + if (wasInvalidated) { + this.clearPendingSteerState(); + this.updateQueueIndicator(); + } + this.activeStreamingAssistantMessage = null; + this.resetProviderMessageBoundaryState(); + } + } + // ============================================ + // Queue Management + // ============================================ + updateQueueIndicator() { + var _a3; + const { state } = this.deps; + const indicatorEl = state.queueIndicatorEl; + if (!indicatorEl) return; + indicatorEl.empty(); + const visibleQueuedMessage = (_a3 = state.queuedMessage) != null ? _a3 : this.pendingSteerMessage; + if (visibleQueuedMessage) { + const isPendingSteerOnly = !state.queuedMessage && !!this.pendingSteerMessage; + indicatorEl.createSpan({ + cls: "claudian-queue-indicator-text", + text: `${isPendingSteerOnly ? "\u2319 Steering: " : "\u2319 Queued: "}${this.getQueuedMessageDisplay(visibleQueuedMessage)}` + }); + if (state.queuedMessage && this.canSteerQueuedMessage()) { + const steerButton = indicatorEl.createEl("button", { + cls: "claudian-queue-indicator-action", + text: this.steerInFlight ? "Steering..." : "Steer Now" + }); + steerButton.setAttribute("type", "button"); + if (this.steerInFlight) { + steerButton.setAttribute("disabled", "true"); + } else { + steerButton.addEventListener("click", (event) => { + event.stopPropagation(); + void this.steerQueuedMessage(); + }); + } + } + indicatorEl.style.display = "flex"; + return; + } + indicatorEl.style.display = "none"; + } + clearQueuedMessage() { + const { state } = this.deps; + state.queuedMessage = null; + this.updateQueueIndicator(); + } + restoreMessageToInput(message) { + var _a3; + if (!message) return; + const { content, images } = message; + const inputEl = this.deps.getInputEl(); + inputEl.value = content; + if (images && images.length > 0) { + (_a3 = this.deps.getImageContextManager()) == null ? void 0 : _a3.setImages(images); + } + } + restorePendingMessagesToInput() { + const { state } = this.deps; + const combinedMessage = this.mergePendingMessages( + this.pendingSteerMessage, + state.queuedMessage + ); + this.restoreMessageToInput(combinedMessage); + state.queuedMessage = null; + this.clearPendingSteerState(); + this.updateQueueIndicator(); + } + processQueuedMessage() { + var _a3; + const { state } = this.deps; + if (!state.queuedMessage) return; + const { content, images, editorContext, browserContext, canvasContext } = state.queuedMessage; + state.queuedMessage = null; + this.updateQueueIndicator(); + const inputEl = this.deps.getInputEl(); + inputEl.value = content; + if (images && images.length > 0) { + (_a3 = this.deps.getImageContextManager()) == null ? void 0 : _a3.setImages(images); + } + setTimeout( + () => this.sendMessage({ + editorContextOverride: editorContext, + browserContextOverride: browserContext != null ? browserContext : null, + canvasContextOverride: canvasContext + }), + 0 + ); + } + buildTurnSubmission(options) { + var _a3, _b2; + const { + selectionController, + browserSelectionController, + canvasSelectionController + } = this.deps; + const fileContextManager = this.deps.getFileContextManager(); + const mcpServerSelector = this.deps.getMcpServerSelector(); + const externalContextSelector = this.deps.getExternalContextSelector(); + const currentNotePath = (fileContextManager == null ? void 0 : fileContextManager.getCurrentNotePath()) || null; + const shouldSendCurrentNote = (_a3 = fileContextManager == null ? void 0 : fileContextManager.shouldSendCurrentNote(currentNotePath)) != null ? _a3 : false; + const editorContext = options.editorContextOverride !== void 0 ? options.editorContextOverride : selectionController.getContext(); + const browserContext = options.browserContextOverride !== void 0 ? options.browserContextOverride : (_b2 = browserSelectionController == null ? void 0 : browserSelectionController.getContext()) != null ? _b2 : null; + const canvasContext = options.canvasContextOverride !== void 0 ? options.canvasContextOverride : canvasSelectionController.getContext(); + const externalContextPaths = externalContextSelector == null ? void 0 : externalContextSelector.getExternalContexts(); + const isCompact = /^\/compact(\s|$)/i.test(options.content); + const transformedText = !isCompact && fileContextManager ? fileContextManager.transformContextMentions(options.content) : options.content; + const enabledMcpServers = mcpServerSelector == null ? void 0 : mcpServerSelector.getEnabledServers(); + return { + displayContent: options.content, + turnRequest: { + text: transformedText, + images: options.images, + currentNotePath: shouldSendCurrentNote && currentNotePath ? currentNotePath : void 0, + editorSelection: editorContext, + browserSelection: browserContext, + canvasSelection: canvasContext, + externalContextPaths: externalContextPaths && externalContextPaths.length > 0 ? externalContextPaths : void 0, + enabledMcpServers: enabledMcpServers && enabledMcpServers.size > 0 ? enabledMcpServers : void 0 + } + }; + } + getQueuedMessageDisplay(message) { + var _a3, _b2; + if (!message) { + return ""; + } + const rawContent = message.content.trim(); + const preview = rawContent.length > 40 ? rawContent.slice(0, 40) + "..." : rawContent; + const hasImages = ((_b2 = (_a3 = message.images) == null ? void 0 : _a3.length) != null ? _b2 : 0) > 0; + if (hasImages) { + return preview ? `${preview} [images]` : "[images]"; + } + return preview; + } + canSteerQueuedMessage() { + const agentService = this.getAgentService(); + return this.deps.state.isStreaming && this.getActiveCapabilities().supportsTurnSteer === true && typeof (agentService == null ? void 0 : agentService.steer) === "function"; + } + cloneQueuedMessage(message) { + return { + ...message, + images: message.images ? [...message.images] : void 0 + }; + } + mergePendingMessages(first, second) { + if (first && second) { + return this.mergeQueuedMessages(first, second); + } + if (first) { + return this.cloneQueuedMessage(first); + } + if (second) { + return this.cloneQueuedMessage(second); + } + return null; + } + clearPendingSteerState() { + this.pendingSteerMessage = null; + this.steerInFlight = false; + } + restorePendingSteerMessageToQueue() { + if (!this.pendingSteerMessage) { + return; + } + const { state } = this.deps; + const pendingSteerMessage = this.cloneQueuedMessage(this.pendingSteerMessage); + this.clearPendingSteerState(); + state.queuedMessage = state.queuedMessage ? this.mergeQueuedMessages(pendingSteerMessage, state.queuedMessage) : pendingSteerMessage; + this.updateQueueIndicator(); + } + mergeQueuedMessages(existing, incoming) { + if (!existing) { + return { + ...incoming, + images: incoming.images ? [...incoming.images] : void 0 + }; + } + const contentParts = [existing.content, incoming.content].filter((part) => part.length > 0); + return { + content: contentParts.join("\n\n"), + images: [...existing.images || [], ...incoming.images || []].filter(Boolean).length > 0 ? [...existing.images || [], ...incoming.images || []] : void 0, + editorContext: incoming.editorContext, + browserContext: incoming.browserContext, + canvasContext: incoming.canvasContext + }; + } + async steerQueuedMessage() { + var _a3, _b2; + if (this.steerInFlight) { + return; + } + const { state } = this.deps; + const agentService = this.getAgentService(); + if (!state.queuedMessage || !this.canSteerQueuedMessage() || !(agentService == null ? void 0 : agentService.steer)) { + return; + } + const queuedMessage = this.cloneQueuedMessage(state.queuedMessage); + state.queuedMessage = null; + this.pendingSteerMessage = queuedMessage; + this.steerInFlight = true; + this.updateQueueIndicator(); + try { + const { displayContent, turnRequest } = this.buildTurnSubmission({ + content: queuedMessage.content, + images: queuedMessage.images, + editorContextOverride: queuedMessage.editorContext, + browserContextOverride: (_a3 = queuedMessage.browserContext) != null ? _a3 : null, + canvasContextOverride: queuedMessage.canvasContext + }); + const preparedTurn = agentService.prepareTurn(turnRequest); + const accepted = await agentService.steer(preparedTurn); + if (state.cancelRequested || !this.pendingSteerMessage) { + return; + } + if (!accepted) { + this.restoreQueuedMessageAfterSteerFailure(queuedMessage); + return; + } + (_b2 = this.deps.getFileContextManager()) == null ? void 0 : _b2.markCurrentNoteSent(); + this.pendingProviderUserMessages.push({ + displayContent, + persistedContent: preparedTurn.persistedContent, + currentNote: preparedTurn.isCompact ? void 0 : preparedTurn.request.currentNotePath, + images: queuedMessage.images + }); + } catch (e3) { + this.restoreQueuedMessageAfterSteerFailure(queuedMessage); + new import_obsidian24.Notice("Failed to steer the queued Codex message. It is still available."); + } + } + restoreQueuedMessageAfterSteerFailure(message) { + const { state } = this.deps; + this.clearPendingSteerState(); + if (state.cancelRequested) { + this.updateQueueIndicator(); + return; + } + if (state.isStreaming) { + state.queuedMessage = state.queuedMessage ? this.mergeQueuedMessages(message, state.queuedMessage) : message; + this.updateQueueIndicator(); + return; + } + this.restoreMessageToInput(message); + this.updateQueueIndicator(); + } + activateStreamingAssistantMessage(message) { + const { state, renderer } = this.deps; + const msgEl = renderer.addMessage(message); + const contentEl = msgEl.querySelector(".claudian-message-content"); + if (!contentEl) { + return; + } + if (!state.currentContentEl) { + state.toolCallElements.clear(); + } + state.currentContentEl = contentEl; + state.currentTextEl = null; + state.currentTextContent = ""; + state.currentThinkingState = null; + } + resetProviderMessageBoundaryState() { + this.pendingProviderUserMessages = []; + this.sawInitialProviderUserMessage = false; + this.awaitingProviderAssistantStart = false; + } + handleProviderMessageBoundaryChunk(chunk) { + switch (chunk.type) { + case "user_message_start": + this.handleProviderUserMessageStart(chunk); + return true; + case "assistant_message_start": + this.handleProviderAssistantMessageStart(); + return true; + default: + return false; + } + } + handleProviderUserMessageStart(chunk) { + var _a3, _b2, _c; + const expected = this.pendingProviderUserMessages.shift(); + if (!this.sawInitialProviderUserMessage) { + this.sawInitialProviderUserMessage = true; + return; + } + this.clearPendingSteerState(); + this.updateQueueIndicator(); + const previousAssistant = this.activeStreamingAssistantMessage; + const shouldDiscardPlaceholder = this.shouldDiscardPendingAssistantPlaceholder(previousAssistant); + if (previousAssistant) { + if (shouldDiscardPlaceholder) { + this.discardStreamingAssistantMessage(previousAssistant.id); + } else { + this.deps.streamController.finalizeCurrentThinkingBlock(previousAssistant); + this.deps.streamController.finalizeCurrentTextBlock(previousAssistant); + } + } + this.deps.streamController.hideThinkingIndicator(); + const displayContent = (_a3 = expected == null ? void 0 : expected.displayContent) != null ? _a3 : chunk.content; + const persistedContent = (_b2 = expected == null ? void 0 : expected.persistedContent) != null ? _b2 : displayContent; + const images = expected == null ? void 0 : expected.images; + if (displayContent || ((_c = images == null ? void 0 : images.length) != null ? _c : 0) > 0) { + const userMessage = { + id: this.deps.generateId(), + role: "user", + content: persistedContent, + displayContent, + timestamp: Date.now(), + currentNote: expected == null ? void 0 : expected.currentNote, + images + }; + this.deps.state.addMessage(userMessage); + this.deps.renderer.addMessage(userMessage); + } + const assistantMessage = { + id: this.deps.generateId(), + role: "assistant", + content: "", + timestamp: Date.now(), + toolCalls: [], + contentBlocks: [] + }; + this.deps.state.addMessage(assistantMessage); + this.activeStreamingAssistantMessage = assistantMessage; + this.activateStreamingAssistantMessage(assistantMessage); + this.deps.streamController.showThinkingIndicator(); + this.deps.state.responseStartTime = performance.now(); + this.awaitingProviderAssistantStart = true; + } + handleProviderAssistantMessageStart() { + if (this.awaitingProviderAssistantStart) { + this.awaitingProviderAssistantStart = false; + return; + } + const previousAssistant = this.activeStreamingAssistantMessage; + if (previousAssistant) { + this.deps.streamController.finalizeCurrentThinkingBlock(previousAssistant); + this.deps.streamController.finalizeCurrentTextBlock(previousAssistant); + } + const assistantMessage = { + id: this.deps.generateId(), + role: "assistant", + content: "", + timestamp: Date.now(), + toolCalls: [], + contentBlocks: [] + }; + this.deps.state.addMessage(assistantMessage); + this.activeStreamingAssistantMessage = assistantMessage; + this.activateStreamingAssistantMessage(assistantMessage); + this.deps.streamController.showThinkingIndicator(); + } + shouldDiscardPendingAssistantPlaceholder(message) { + var _a3, _b2, _c, _d; + return this.awaitingProviderAssistantStart && !!message && !message.content.trim() && ((_b2 = (_a3 = message.toolCalls) == null ? void 0 : _a3.length) != null ? _b2 : 0) === 0 && ((_d = (_c = message.contentBlocks) == null ? void 0 : _c.length) != null ? _d : 0) === 0; + } + discardStreamingAssistantMessage(messageId) { + const { state, renderer } = this.deps; + state.messages = state.messages.filter((message) => message.id !== messageId); + renderer.removeMessage(messageId); + state.currentContentEl = null; + state.currentTextEl = null; + state.currentTextContent = ""; + state.currentThinkingState = null; + } + // ============================================ + // Title Generation + // ============================================ + /** + * Triggers AI title generation after first user message. + * Handles setting fallback title, firing async generation, and updating UI. + */ + async triggerTitleGeneration() { + var _a3, _b2; + const { plugin, state, conversationController } = this.deps; + if (state.messages.length !== 1) { + return; + } + if (!state.currentConversationId) { + const sessionId = (_b2 = (_a3 = this.getAgentService()) == null ? void 0 : _a3.getSessionId()) != null ? _b2 : void 0; + const conversation = await plugin.createConversation({ + providerId: this.getActiveProviderId(), + sessionId + }); + state.currentConversationId = conversation.id; + } + const firstUserMsg = state.messages.find((m3) => m3.role === "user"); + if (!firstUserMsg) { + return; + } + const userContent = firstUserMsg.displayContent || firstUserMsg.content; + const fallbackTitle = conversationController.generateFallbackTitle(userContent); + await plugin.renameConversation(state.currentConversationId, fallbackTitle); + if (!plugin.settings.enableAutoTitleGeneration) { + return; + } + const titleService = this.deps.getTitleGenerationService(); + if (!titleService) { + return; + } + await plugin.updateConversation(state.currentConversationId, { titleGenerationStatus: "pending" }); + conversationController.updateHistoryDropdown(); + const convId = state.currentConversationId; + const expectedTitle = fallbackTitle; + titleService.generateTitle( + convId, + userContent, + async (conversationId, result) => { + const currentConv = await plugin.getConversationById(conversationId); + if (!currentConv) return; + const userManuallyRenamed = currentConv.title !== expectedTitle; + if (result.success && !userManuallyRenamed) { + await plugin.renameConversation(conversationId, result.title); + await plugin.updateConversation(conversationId, { titleGenerationStatus: "success" }); + } else if (!userManuallyRenamed) { + await plugin.updateConversation(conversationId, { titleGenerationStatus: "failed" }); + } else { + await plugin.updateConversation(conversationId, { titleGenerationStatus: void 0 }); + } + conversationController.updateHistoryDropdown(); + } + ).catch(() => { + }); + } + // ============================================ + // Streaming Control + // ============================================ + cancelStreaming() { + var _a3; + const { state, streamController } = this.deps; + if (!state.isStreaming) return; + state.cancelRequested = true; + this.restorePendingMessagesToInput(); + (_a3 = this.getAgentService()) == null ? void 0 : _a3.cancel(); + streamController.hideThinkingIndicator(); + } + syncScrollToBottomAfterRenderUpdates() { + var _a3; + const { plugin, state } = this.deps; + if (!((_a3 = plugin.settings.enableAutoScroll) != null ? _a3 : true)) return; + if (!state.autoScrollEnabled) return; + requestAnimationFrame(() => { + var _a4; + if (!((_a4 = this.deps.plugin.settings.enableAutoScroll) != null ? _a4 : true)) return; + if (!this.deps.state.autoScrollEnabled) return; + const messagesEl = this.deps.getMessagesEl(); + messagesEl.scrollTop = messagesEl.scrollHeight; + }); + } + // ============================================ + // Instruction Mode + // ============================================ + async handleInstructionSubmit(rawInstruction) { + const { plugin } = this.deps; + const instructionRefineService = this.deps.getInstructionRefineService(); + const instructionModeManager = this.deps.getInstructionModeManager(); + if (!instructionRefineService) return; + const existingPrompt = plugin.settings.systemPrompt; + let modal = null; + let wasCancelled = false; + try { + modal = new InstructionModal( + plugin.app, + rawInstruction, + { + onAccept: async (finalInstruction) => { + const currentPrompt = plugin.settings.systemPrompt; + plugin.settings.systemPrompt = appendMarkdownSnippet(currentPrompt, finalInstruction); + await plugin.saveSettings(); + new import_obsidian24.Notice("Instruction added to custom system prompt"); + instructionModeManager == null ? void 0 : instructionModeManager.clear(); + }, + onReject: () => { + wasCancelled = true; + instructionRefineService.cancel(); + instructionModeManager == null ? void 0 : instructionModeManager.clear(); + }, + onClarificationSubmit: async (response) => { + const result2 = await instructionRefineService.continueConversation(response); + if (wasCancelled) { + return; + } + if (!result2.success) { + if (result2.error === "Cancelled") { + return; + } + new import_obsidian24.Notice(result2.error || "Failed to process response"); + modal == null ? void 0 : modal.showError(result2.error || "Failed to process response"); + return; + } + if (result2.clarification) { + modal == null ? void 0 : modal.showClarification(result2.clarification); + } else if (result2.refinedInstruction) { + modal == null ? void 0 : modal.showConfirmation(result2.refinedInstruction); + } + } + } + ); + modal.open(); + instructionRefineService.resetConversation(); + const result = await instructionRefineService.refineInstruction( + rawInstruction, + existingPrompt + ); + if (wasCancelled) { + return; + } + if (!result.success) { + if (result.error === "Cancelled") { + instructionModeManager == null ? void 0 : instructionModeManager.clear(); + return; + } + new import_obsidian24.Notice(result.error || "Failed to refine instruction"); + modal.showError(result.error || "Failed to refine instruction"); + instructionModeManager == null ? void 0 : instructionModeManager.clear(); + return; + } + if (result.clarification) { + modal.showClarification(result.clarification); + } else if (result.refinedInstruction) { + modal.showConfirmation(result.refinedInstruction); + } else { + new import_obsidian24.Notice("No instruction received"); + modal.showError("No instruction received"); + instructionModeManager == null ? void 0 : instructionModeManager.clear(); + } + } catch (error48) { + const errorMsg = error48 instanceof Error ? error48.message : "Unknown error"; + new import_obsidian24.Notice(`Error: ${errorMsg}`); + modal == null ? void 0 : modal.showError(errorMsg); + instructionModeManager == null ? void 0 : instructionModeManager.clear(); + } + } + // ============================================ + // Approval Dialogs + // ============================================ + async handleApprovalRequest(toolName, _input, description, approvalOptions) { + var _a3; + const inputContainerEl = this.deps.getInputContainerEl(); + const parentEl = inputContainerEl.parentElement; + if (!parentEl) { + throw new Error("Input container is detached from DOM"); + } + const headerEl = parentEl.createDiv({ cls: "claudian-ask-approval-info" }); + headerEl.remove(); + const toolEl = headerEl.createDiv({ cls: "claudian-ask-approval-tool" }); + const iconEl = toolEl.createSpan({ cls: "claudian-ask-approval-icon" }); + iconEl.setAttribute("aria-hidden", "true"); + setToolIcon(iconEl, toolName); + toolEl.createSpan({ text: toolName, cls: "claudian-ask-approval-tool-name" }); + if (approvalOptions == null ? void 0 : approvalOptions.decisionReason) { + headerEl.createDiv({ text: approvalOptions.decisionReason, cls: "claudian-ask-approval-reason" }); + } + if (approvalOptions == null ? void 0 : approvalOptions.blockedPath) { + headerEl.createDiv({ text: approvalOptions.blockedPath, cls: "claudian-ask-approval-blocked-path" }); + } + if (approvalOptions == null ? void 0 : approvalOptions.agentID) { + headerEl.createDiv({ text: `Agent: ${approvalOptions.agentID}`, cls: "claudian-ask-approval-agent" }); + } + headerEl.createDiv({ text: description, cls: "claudian-ask-approval-desc" }); + const decisionOptions = (_a3 = approvalOptions == null ? void 0 : approvalOptions.decisionOptions) != null ? _a3 : DEFAULT_APPROVAL_DECISION_OPTIONS; + const optionDecisionMap = /* @__PURE__ */ new Map(); + const questionOptions = decisionOptions.map((option, index) => { + var _a4; + const value = option.value || `approval-option-${index}`; + if (option.decision) { + optionDecisionMap.set(value, option.decision); + } + return { + label: option.label, + description: (_a4 = option.description) != null ? _a4 : "", + value + }; + }); + const input = { + questions: [{ + question: "Allow this action?", + options: questionOptions, + isOther: false, + isSecret: false + }] + }; + const result = await this.showInlineQuestion( + parentEl, + inputContainerEl, + input, + (inline) => { + this.pendingApprovalInline = inline; + }, + void 0, + { title: "Permission required", headerEl, showCustomInput: false, immediateSelect: true } + ); + if (!result) return "cancel"; + const selected = Object.values(result)[0]; + const selectedValue = Array.isArray(selected) ? selected[0] : selected; + if (typeof selectedValue !== "string") { + new import_obsidian24.Notice(`Unexpected approval selection: "${String(selectedValue)}"`); + return "cancel"; + } + const decision = optionDecisionMap.get(selectedValue); + if (decision) { + return decision; + } + return { + type: "select-option", + value: selectedValue + }; + } + async handleAskUserQuestion(input, signal) { + const inputContainerEl = this.deps.getInputContainerEl(); + const parentEl = inputContainerEl.parentElement; + if (!parentEl) { + throw new Error("Input container is detached from DOM"); + } + return this.showInlineQuestion( + parentEl, + inputContainerEl, + input, + (inline) => { + this.pendingAskInline = inline; + }, + signal + ); + } + showInlineQuestion(parentEl, inputContainerEl, input, setPending, signal, config2) { + this.deps.streamController.hideThinkingIndicator(); + this.hideInputContainer(inputContainerEl); + return new Promise((resolve5, reject) => { + const inline = new InlineAskUserQuestion( + parentEl, + input, + (result) => { + setPending(null); + this.restoreInputContainer(inputContainerEl); + resolve5(result); + }, + signal, + config2 + ); + setPending(inline); + try { + inline.render(); + } catch (err) { + setPending(null); + this.restoreInputContainer(inputContainerEl); + reject(err); + } + }); + } + async handleExitPlanMode(input, signal) { + const { state, streamController } = this.deps; + const inputContainerEl = this.deps.getInputContainerEl(); + const parentEl = inputContainerEl.parentElement; + if (!parentEl) { + throw new Error("Input container is detached from DOM"); + } + streamController.hideThinkingIndicator(); + this.hideInputContainer(inputContainerEl); + const enrichedInput = state.planFilePath ? { ...input, planFilePath: state.planFilePath } : input; + const renderContent = (el2, markdown) => this.deps.renderer.renderContent(el2, markdown); + const planPathPrefix = this.getActiveCapabilities().planPathPrefix; + return new Promise((resolve5, reject) => { + const inline = new InlineExitPlanMode( + parentEl, + enrichedInput, + (decision) => { + this.pendingExitPlanModeInline = null; + this.restoreInputContainer(inputContainerEl); + resolve5(decision); + }, + signal, + renderContent, + planPathPrefix + ); + this.pendingExitPlanModeInline = inline; + try { + inline.render(); + } catch (err) { + this.pendingExitPlanModeInline = null; + this.restoreInputContainer(inputContainerEl); + reject(err); + } + }); + } + dismissPendingApprovalPrompt() { + if (this.pendingApprovalInline) { + this.pendingApprovalInline.destroy(); + this.pendingApprovalInline = null; + } + } + dismissPendingApproval() { + this.dismissPendingApprovalPrompt(); + if (this.pendingAskInline) { + this.pendingAskInline.destroy(); + this.pendingAskInline = null; + } + if (this.pendingExitPlanModeInline) { + this.pendingExitPlanModeInline.destroy(); + this.pendingExitPlanModeInline = null; + } + this.dismissPendingPlanApproval(true); + this.resetInputContainerVisibility(); + } + showPlanApproval() { + const inputContainerEl = this.deps.getInputContainerEl(); + const parentEl = inputContainerEl.parentElement; + if (!parentEl) { + return Promise.resolve({ decision: null, invalidated: false }); + } + this.hideInputContainer(inputContainerEl); + this.pendingPlanApprovalInvalidated = false; + return new Promise((resolve5, reject) => { + const inline = new InlinePlanApproval( + parentEl, + (decision) => { + const invalidated = this.pendingPlanApprovalInvalidated; + this.pendingPlanApprovalInvalidated = false; + this.pendingPlanApproval = null; + this.restoreInputContainer(inputContainerEl); + resolve5({ decision, invalidated }); + } + ); + this.pendingPlanApproval = inline; + try { + inline.render(); + } catch (err) { + this.pendingPlanApproval = null; + this.pendingPlanApprovalInvalidated = false; + this.restoreInputContainer(inputContainerEl); + reject(err); + } + }); + } + dismissPendingPlanApproval(invalidated) { + if (!this.pendingPlanApproval) { + return; + } + if (invalidated) { + this.pendingPlanApprovalInvalidated = true; + } + this.pendingPlanApproval.destroy(); + this.pendingPlanApproval = null; + } + hideInputContainer(inputContainerEl) { + this.inputContainerHideDepth++; + inputContainerEl.style.display = "none"; + } + restoreInputContainer(inputContainerEl) { + if (this.inputContainerHideDepth <= 0) return; + this.inputContainerHideDepth--; + if (this.inputContainerHideDepth === 0) { + inputContainerEl.style.display = ""; + } + } + resetInputContainerVisibility() { + if (this.inputContainerHideDepth > 0) { + this.inputContainerHideDepth = 0; + this.deps.getInputContainerEl().style.display = ""; + } + } + // ============================================ + // Built-in Commands + // ============================================ + async executeBuiltInCommand(command, args) { + const { conversationController } = this.deps; + const capabilities = this.getActiveCapabilities(); + if (!isBuiltInCommandSupported(command, capabilities)) { + new import_obsidian24.Notice(`/${command.name} is not supported by this provider.`); + return; + } + switch (command.action) { + case "clear": + await conversationController.createNew(); + break; + case "add-dir": { + const externalContextSelector = this.deps.getExternalContextSelector(); + if (!externalContextSelector) { + new import_obsidian24.Notice("External context selector not available."); + return; + } + const result = externalContextSelector.addExternalContext(args); + if (result.success) { + new import_obsidian24.Notice(`Added external context: ${result.normalizedPath}`); + } else { + new import_obsidian24.Notice(result.error); + } + break; + } + case "resume": + this.showResumeDropdown(); + break; + case "fork": { + if (!this.getActiveCapabilities().supportsFork) { + new import_obsidian24.Notice("Fork is not supported by this provider."); + return; + } + if (!this.deps.onForkAll) { + new import_obsidian24.Notice("Fork not available."); + return; + } + await this.deps.onForkAll(); + break; + } + default: + new import_obsidian24.Notice(`Unknown command: ${command.action}`); + } + } + // ============================================ + // Resume Session Dropdown + // ============================================ + handleResumeKeydown(e3) { + var _a3; + if (!((_a3 = this.activeResumeDropdown) == null ? void 0 : _a3.isVisible())) return false; + return this.activeResumeDropdown.handleKeydown(e3); + } + isResumeDropdownVisible() { + var _a3, _b2; + return (_b2 = (_a3 = this.activeResumeDropdown) == null ? void 0 : _a3.isVisible()) != null ? _b2 : false; + } + destroyResumeDropdown() { + if (this.activeResumeDropdown) { + this.activeResumeDropdown.destroy(); + this.activeResumeDropdown = null; + } + } + showResumeDropdown() { + var _a3; + const { plugin, state, conversationController } = this.deps; + this.destroyResumeDropdown(); + const conversations = plugin.getConversationList(); + if (conversations.length === 0) { + new import_obsidian24.Notice("No conversations to resume"); + return; + } + const openConversation = (_a3 = this.deps.openConversation) != null ? _a3 : ((id) => conversationController.switchTo(id)); + this.activeResumeDropdown = new ResumeSessionDropdown( + this.deps.getInputContainerEl(), + this.deps.getInputEl(), + conversations, + state.currentConversationId, + { + onSelect: (id) => { + this.destroyResumeDropdown(); + openConversation(id).catch((err) => { + const msg = err instanceof Error ? err.message : String(err); + new import_obsidian24.Notice(`Failed to open conversation: ${msg}`); + }); + }, + onDismiss: () => { + this.destroyResumeDropdown(); + } + } + ); + } +}; + +// src/features/chat/controllers/NavigationController.ts +var SCROLL_SPEED = 8; +var NavigationController = class { + constructor(deps) { + this.scrollDirection = null; + this.animationFrameId = null; + this.initialized = false; + this.disposed = false; + this.scrollLoop = () => { + if (this.scrollDirection === null || this.disposed) return; + const messagesEl = this.deps.getMessagesEl(); + if (!messagesEl) { + this.stopScrolling(); + return; + } + const scrollAmount = this.scrollDirection === "up" ? -SCROLL_SPEED : SCROLL_SPEED; + messagesEl.scrollTop += scrollAmount; + this.animationFrameId = requestAnimationFrame(this.scrollLoop); + }; + this.deps = deps; + this.boundMessagesKeydown = this.handleMessagesKeydown.bind(this); + this.boundKeyup = this.handleKeyup.bind(this); + this.boundInputKeydown = this.handleInputKeydown.bind(this); + } + initialize() { + if (this.initialized || this.disposed) return; + const messagesEl = this.deps.getMessagesEl(); + const inputEl = this.deps.getInputEl(); + if (!messagesEl || !inputEl) return; + messagesEl.setAttribute("tabindex", "0"); + messagesEl.addClass("claudian-messages-focusable"); + messagesEl.addEventListener("keydown", this.boundMessagesKeydown); + document.addEventListener("keyup", this.boundKeyup); + inputEl.addEventListener("keydown", this.boundInputKeydown, { capture: true }); + this.initialized = true; + } + /** Cleans up event listeners and animation frames. */ + dispose() { + if (this.disposed) return; + this.disposed = true; + this.stopScrolling(); + document.removeEventListener("keyup", this.boundKeyup); + const messagesEl = this.deps.getMessagesEl(); + messagesEl == null ? void 0 : messagesEl.removeEventListener("keydown", this.boundMessagesKeydown); + messagesEl == null ? void 0 : messagesEl.removeClass("claudian-messages-focusable"); + const inputEl = this.deps.getInputEl(); + inputEl == null ? void 0 : inputEl.removeEventListener("keydown", this.boundInputKeydown, { capture: true }); + } + // ============================================ + // Messages Panel Keyboard Handling + // ============================================ + handleMessagesKeydown(e3) { + if (e3.ctrlKey || e3.metaKey || e3.altKey || e3.shiftKey) return; + const settings11 = this.deps.getSettings(); + const key = e3.key.toLowerCase(); + if (key === settings11.scrollUpKey.toLowerCase()) { + e3.preventDefault(); + this.startScrolling("up"); + return; + } + if (key === settings11.scrollDownKey.toLowerCase()) { + e3.preventDefault(); + this.startScrolling("down"); + return; + } + if (key === settings11.focusInputKey.toLowerCase()) { + e3.preventDefault(); + this.deps.getInputEl().focus(); + return; + } + } + handleKeyup(e3) { + const settings11 = this.deps.getSettings(); + const key = e3.key.toLowerCase(); + if (key === settings11.scrollUpKey.toLowerCase() || key === settings11.scrollDownKey.toLowerCase()) { + this.stopScrolling(); + } + } + // ============================================ + // Input Keyboard Handling (Escape) + // ============================================ + handleInputKeydown(e3) { + var _a3, _b2; + if (e3.key !== "Escape") return; + if (e3.isComposing) return; + if (this.deps.isStreaming()) { + return; + } + if ((_b2 = (_a3 = this.deps).shouldSkipEscapeHandling) == null ? void 0 : _b2.call(_a3)) { + return; + } + e3.preventDefault(); + e3.stopPropagation(); + this.deps.getInputEl().blur(); + this.deps.getMessagesEl().focus(); + } + // ============================================ + // Continuous Scrolling with requestAnimationFrame + // ============================================ + startScrolling(direction) { + if (this.scrollDirection === direction) { + return; + } + this.scrollDirection = direction; + this.scrollLoop(); + } + stopScrolling() { + this.scrollDirection = null; + if (this.animationFrameId !== null) { + cancelAnimationFrame(this.animationFrameId); + this.animationFrameId = null; + } + } + // ============================================ + // Public API + // ============================================ + /** Focuses the messages panel. */ + focusMessages() { + this.deps.getMessagesEl().focus(); + } + /** Focuses the input. */ + focusInput() { + this.deps.getInputEl().focus(); + } +}; + +// src/features/chat/controllers/SelectionController.ts +var import_obsidian25 = require("obsidian"); + +// src/shared/components/SelectionHighlight.ts +var import_state = require("@codemirror/state"); +var import_view = require("@codemirror/view"); +function createSelectionHighlighter() { + const showHighlight = import_state.StateEffect.define(); + const hideHighlight = import_state.StateEffect.define(); + const selectionHighlightField = import_state.StateField.define({ + create: () => import_view.Decoration.none, + update: (deco, tr) => { + for (const e3 of tr.effects) { + if (e3.is(showHighlight)) { + const builder = new import_state.RangeSetBuilder(); + builder.add(e3.value.from, e3.value.to, import_view.Decoration.mark({ + class: "claudian-selection-highlight" + })); + return builder.finish(); + } else if (e3.is(hideHighlight)) { + return import_view.Decoration.none; + } + } + return deco.map(tr.changes); + }, + provide: (f6) => import_view.EditorView.decorations.from(f6) + }); + const installedEditors2 = /* @__PURE__ */ new WeakSet(); + function ensureHighlightField(editorView) { + if (!installedEditors2.has(editorView)) { + editorView.dispatch({ + effects: import_state.StateEffect.appendConfig.of(selectionHighlightField) + }); + installedEditors2.add(editorView); + } + } + function show(editorView, from, to) { + ensureHighlightField(editorView); + editorView.dispatch({ + effects: showHighlight.of({ from, to }) + }); + } + function hide(editorView) { + if (installedEditors2.has(editorView)) { + editorView.dispatch({ + effects: hideHighlight.of(null) + }); + } + } + return { show, hide }; +} +var defaultHighlighter = createSelectionHighlighter(); +function showSelectionHighlight(editorView, from, to) { + defaultHighlighter.show(editorView, from, to); +} +function hideSelectionHighlight(editorView) { + defaultHighlighter.hide(editorView); +} + +// src/features/chat/controllers/SelectionController.ts +var SELECTION_POLL_INTERVAL = 250; +var INPUT_HANDOFF_GRACE_MS = 1500; +var HIGHLIGHT_KEY = "claudian-selection"; +var SelectionController = class { + constructor(app, indicatorEl, inputEl, contextRowEl, onVisibilityChange, focusScopeEl) { + this.storedSelection = null; + this.inputHandoffGraceUntil = null; + this.pollInterval = null; + this.focusScopePointerDownHandler = () => { + if (!this.storedSelection) return; + this.inputHandoffGraceUntil = Date.now() + INPUT_HANDOFF_GRACE_MS; + }; + this.app = app; + this.indicatorEl = indicatorEl; + this.inputEl = inputEl; + this.focusScopeEl = focusScopeEl != null ? focusScopeEl : inputEl; + this.contextRowEl = contextRowEl; + this.onVisibilityChange = onVisibilityChange != null ? onVisibilityChange : null; + } + start() { + if (this.pollInterval) return; + this.inputEl.addEventListener("pointerdown", this.focusScopePointerDownHandler); + if (this.focusScopeEl !== this.inputEl) { + this.focusScopeEl.addEventListener("pointerdown", this.focusScopePointerDownHandler); + } + this.pollInterval = setInterval(() => this.poll(), SELECTION_POLL_INTERVAL); + } + stop() { + if (this.pollInterval) { + clearInterval(this.pollInterval); + this.pollInterval = null; + } + this.inputEl.removeEventListener("pointerdown", this.focusScopePointerDownHandler); + if (this.focusScopeEl !== this.inputEl) { + this.focusScopeEl.removeEventListener("pointerdown", this.focusScopePointerDownHandler); + } + this.clear(); + } + dispose() { + this.stop(); + } + // ============================================ + // Selection Polling + // ============================================ + poll() { + var _a3; + const view = this.app.workspace.getActiveViewOfType(import_obsidian25.MarkdownView); + if (!view) { + this.clearWhenMarkdownContextIsUnavailable(); + return; + } + if (view.getMode() === "preview") { + this.pollReadingMode(view); + return; + } + const editor = view.editor; + const editorView = getEditorView(editor); + if (!editorView) { + this.clearWhenMarkdownContextIsUnavailable(); + return; + } + const selectedText = editor.getSelection(); + if (selectedText.trim()) { + this.inputHandoffGraceUntil = null; + const fromPos = editor.getCursor("from"); + const toPos = editor.getCursor("to"); + const from = editor.posToOffset(fromPos); + const to = editor.posToOffset(toPos); + const startLine = fromPos.line + 1; + const notePath = ((_a3 = view.file) == null ? void 0 : _a3.path) || "unknown"; + const lineCount = selectedText.split(/\r?\n/).length; + const s3 = this.storedSelection; + const sameRange = s3 && s3.editorView === editorView && s3.from === from && s3.to === to && s3.notePath === notePath; + const unchanged = sameRange && s3.selectedText === selectedText && s3.lineCount === lineCount && s3.startLine === startLine; + if (!unchanged) { + if (s3 && !sameRange) { + this.clearHighlight(); + } + this.storedSelection = { notePath, selectedText, lineCount, startLine, from, to, editorView }; + this.updateIndicator(); + } + } else { + this.handleDeselection(); + } + } + pollReadingMode(view) { + var _a3, _b2; + const containerEl = view.containerEl; + if (!containerEl) { + this.clearWhenMarkdownContextIsUnavailable(); + return; + } + const selection = document.getSelection(); + const selectedText = (_a3 = selection == null ? void 0 : selection.toString()) != null ? _a3 : ""; + if (selectedText.trim()) { + const anchorNode = selection == null ? void 0 : selection.anchorNode; + const focusNode = selection == null ? void 0 : selection.focusNode; + if ((!anchorNode || !containerEl.contains(anchorNode)) && (!focusNode || !containerEl.contains(focusNode))) { + this.handleDeselection(); + return; + } + this.inputHandoffGraceUntil = null; + const notePath = ((_b2 = view.file) == null ? void 0 : _b2.path) || "unknown"; + const lineCount = selectedText.split(/\r?\n/).length; + const domRanges = this.cloneDOMRanges(selection); + const unchanged = this.storedSelection && this.storedSelection.editorView === void 0 && this.storedSelection.notePath === notePath && this.storedSelection.selectedText === selectedText && this.storedSelection.lineCount === lineCount && this.rangeListsMatch(this.storedSelection.domRanges, domRanges); + if (!unchanged) { + this.clearHighlight(); + this.storedSelection = { notePath, selectedText, lineCount, domRanges }; + this.updateIndicator(); + } + } else { + this.handleDeselection(); + } + } + get cssHighlights() { + return typeof CSS !== "undefined" && CSS.highlights ? CSS.highlights : null; + } + rangesMatch(a3, b) { + return a3.startContainer === b.startContainer && a3.startOffset === b.startOffset && a3.endContainer === b.endContainer && a3.endOffset === b.endOffset; + } + rangeListsMatch(left, right) { + return left !== void 0 && left.length === right.length && left.every((range, index) => this.rangesMatch(range, right[index])); + } + selectionMatchesRanges(selection, ranges) { + if (!selection || selection.rangeCount !== ranges.length) return false; + for (let i3 = 0; i3 < ranges.length; i3++) { + if (!this.rangesMatch(selection.getRangeAt(i3), ranges[i3])) { + return false; + } + } + return true; + } + cloneDOMRanges(selection) { + if (!selection) return []; + const ranges = []; + for (let i3 = 0; i3 < selection.rangeCount; i3++) { + ranges.push(selection.getRangeAt(i3).cloneRange()); + } + return ranges; + } + isFocusWithinChatSidebar() { + const activeElement = document.activeElement; + return activeElement !== null && (activeElement === this.focusScopeEl || this.focusScopeEl.contains(activeElement)); + } + clearWhenMarkdownContextIsUnavailable() { + if (!this.storedSelection) return; + if (this.isFocusWithinChatSidebar()) { + this.inputHandoffGraceUntil = null; + return; + } + if (this.inputHandoffGraceUntil !== null && Date.now() <= this.inputHandoffGraceUntil) { + return; + } + this.inputHandoffGraceUntil = null; + this.clearHighlight(); + this.storedSelection = null; + this.updateIndicator(); + } + handleDeselection() { + if (!this.storedSelection) return; + if (this.isFocusWithinChatSidebar()) { + this.inputHandoffGraceUntil = null; + return; + } + if (this.inputHandoffGraceUntil !== null && Date.now() <= this.inputHandoffGraceUntil) { + return; + } + this.inputHandoffGraceUntil = null; + this.clearHighlight(); + this.storedSelection = null; + this.updateIndicator(); + } + // ============================================ + // Highlight Management + // ============================================ + showHighlight() { + var _a3, _b2, _c; + const sel = this.storedSelection; + if (!sel) return; + if (sel.editorView && sel.from !== void 0 && sel.to !== void 0) { + const cmSel = sel.editorView.state.selection.main; + const nativeVisible = document.activeElement !== this.inputEl && cmSel.from === sel.from && cmSel.to === sel.to; + if (nativeVisible) { + hideSelectionHighlight(sel.editorView); + return; + } + showSelectionHighlight(sel.editorView, sel.from, sel.to); + return; + } + if ((_a3 = sel.domRanges) == null ? void 0 : _a3.length) { + const nativeSel = document.getSelection(); + const nativeVisible = document.activeElement !== this.inputEl && this.selectionMatchesRanges(nativeSel, sel.domRanges); + if (nativeVisible) { + (_b2 = this.cssHighlights) == null ? void 0 : _b2.delete(HIGHLIGHT_KEY); + return; + } + const validRanges = sel.domRanges.filter((r3) => r3.startContainer.isConnected); + if (validRanges.length) { + (_c = this.cssHighlights) == null ? void 0 : _c.set(HIGHLIGHT_KEY, new Highlight(...validRanges)); + } + } + } + clearHighlight() { + var _a3, _b2; + if ((_a3 = this.storedSelection) == null ? void 0 : _a3.editorView) { + hideSelectionHighlight(this.storedSelection.editorView); + } + (_b2 = this.cssHighlights) == null ? void 0 : _b2.delete(HIGHLIGHT_KEY); + } + // ============================================ + // Indicator + // ============================================ + updateIndicator() { + if (!this.indicatorEl) return; + if (this.storedSelection) { + const lineText = this.storedSelection.lineCount === 1 ? "line" : "lines"; + this.indicatorEl.textContent = `${this.storedSelection.lineCount} ${lineText} selected`; + this.indicatorEl.style.display = "block"; + } else { + this.indicatorEl.style.display = "none"; + } + this.updateContextRowVisibility(); + } + updateContextRowVisibility() { + var _a3; + if (!this.contextRowEl) return; + updateContextRowHasContent(this.contextRowEl); + (_a3 = this.onVisibilityChange) == null ? void 0 : _a3.call(this); + } + // ============================================ + // Context Access + // ============================================ + getContext() { + if (!this.storedSelection) return null; + return { + notePath: this.storedSelection.notePath, + mode: "selection", + selectedText: this.storedSelection.selectedText, + lineCount: this.storedSelection.lineCount, + ...this.storedSelection.startLine !== void 0 && { startLine: this.storedSelection.startLine } + }; + } + hasSelection() { + return this.storedSelection !== null; + } + // ============================================ + // Clear + // ============================================ + clear() { + this.inputHandoffGraceUntil = null; + this.clearHighlight(); + this.storedSelection = null; + this.updateIndicator(); + } +}; + +// src/features/chat/controllers/StreamController.ts +var import_obsidian28 = require("obsidian"); + +// src/core/tools/todo.ts +function isValidTodoItem(item) { + if (typeof item !== "object" || item === null) return false; + const record2 = item; + return typeof record2.content === "string" && record2.content.length > 0 && typeof record2.activeForm === "string" && record2.activeForm.length > 0 && typeof record2.status === "string" && ["pending", "in_progress", "completed"].includes(record2.status); +} +function parseTodoInput(input) { + if (!input.todos || !Array.isArray(input.todos)) { + return null; + } + const validTodos = []; + for (const item of input.todos) { + if (isValidTodoItem(item)) { + validTodos.push(item); + } + } + return validTodos.length > 0 ? validTodos : null; +} + +// src/features/chat/controllers/StreamController.ts +init_path(); + +// src/features/chat/rendering/subagentLifecycleResolution.ts +function resolveSubagentLifecycleAdapter(activeProviderId, toolName) { + const activeAdapter = ProviderRegistry.getSubagentLifecycleAdapter(activeProviderId); + if (!toolName) { + return activeAdapter; + } + return activeAdapter && adapterOwnsTool(activeAdapter, toolName) ? activeAdapter : null; +} +function adapterOwnsTool(adapter, toolName) { + return adapter.isSpawnTool(toolName) || adapter.isHiddenTool(toolName) || adapter.isWaitTool(toolName) || adapter.isCloseTool(toolName); +} + +// src/features/chat/rendering/SubagentRenderer.ts +var import_obsidian26 = require("obsidian"); +var SUBAGENT_TOOL_STATUS_ICONS = { + completed: "check", + error: "x", + blocked: "shield-off" +}; +function extractTaskDescription(input) { + return input.description || "Subagent task"; +} +function extractTaskPrompt(input) { + return input.prompt || ""; +} +function truncateDescription(description, maxLength = 40) { + if (description.length <= maxLength) return description; + return description.substring(0, maxLength) + "..."; +} +function createSection(parentEl, title, bodyClass) { + const wrapperEl = parentEl.createDiv({ cls: "claudian-subagent-section" }); + const headerEl = wrapperEl.createDiv({ cls: "claudian-subagent-section-header" }); + headerEl.setAttribute("tabindex", "0"); + headerEl.setAttribute("role", "button"); + const titleEl = headerEl.createDiv({ cls: "claudian-subagent-section-title" }); + titleEl.setText(title); + const bodyEl = wrapperEl.createDiv({ cls: "claudian-subagent-section-body" }); + if (bodyClass) bodyEl.addClass(bodyClass); + const state = { isExpanded: false }; + setupCollapsible(wrapperEl, headerEl, bodyEl, state, { + baseAriaLabel: title + }); + return { wrapperEl, bodyEl }; +} +function setPromptText(promptBodyEl, prompt) { + promptBodyEl.empty(); + const textEl = promptBodyEl.createDiv({ cls: "claudian-subagent-prompt-text" }); + textEl.setText(prompt || "No prompt provided"); +} +function updateSyncHeaderAria(state) { + const toolCount = state.info.toolCalls.length; + state.headerEl.setAttribute( + "aria-label", + `Subagent task: ${truncateDescription(state.info.description)} - ${toolCount} tool uses - Status: ${state.info.status} - click to expand` + ); + state.statusEl.setAttribute("aria-label", `Status: ${state.info.status}`); +} +function renderSubagentToolContent(contentEl, toolCall) { + contentEl.empty(); + if (!toolCall.result && toolCall.status === "running") { + const emptyEl = contentEl.createDiv({ cls: "claudian-subagent-tool-empty" }); + emptyEl.setText("Running..."); + return; + } + renderExpandedContent(contentEl, toolCall.name, toolCall.result, toolCall.input); +} +function setSubagentToolStatus(view, status) { + view.statusEl.className = "claudian-subagent-tool-status"; + view.statusEl.addClass(`status-${status}`); + view.statusEl.empty(); + view.statusEl.setAttribute("aria-label", `Status: ${status}`); + const statusIcon = SUBAGENT_TOOL_STATUS_ICONS[status]; + if (statusIcon) { + (0, import_obsidian26.setIcon)(view.statusEl, statusIcon); + } +} +function updateSubagentToolView(view, toolCall) { + view.wrapperEl.className = `claudian-subagent-tool-item claudian-subagent-tool-${toolCall.status}`; + view.nameEl.setText(getToolName(toolCall.name, toolCall.input)); + view.summaryEl.setText(getToolSummary(toolCall.name, toolCall.input)); + setSubagentToolStatus(view, toolCall.status); + renderSubagentToolContent(view.contentEl, toolCall); +} +function createSubagentToolView(parentEl, toolCall) { + var _a3, _b2; + const wrapperEl = parentEl.createDiv({ + cls: `claudian-subagent-tool-item claudian-subagent-tool-${toolCall.status}` + }); + wrapperEl.dataset.toolId = toolCall.id; + const headerEl = wrapperEl.createDiv({ cls: "claudian-subagent-tool-header" }); + headerEl.setAttribute("tabindex", "0"); + headerEl.setAttribute("role", "button"); + const iconEl = headerEl.createDiv({ cls: "claudian-subagent-tool-icon" }); + iconEl.setAttribute("aria-hidden", "true"); + setToolIcon(iconEl, toolCall.name); + const nameEl = headerEl.createDiv({ cls: "claudian-subagent-tool-name" }); + const summaryEl = headerEl.createDiv({ cls: "claudian-subagent-tool-summary" }); + const statusEl = headerEl.createDiv({ cls: "claudian-subagent-tool-status" }); + const contentEl = wrapperEl.createDiv({ cls: "claudian-subagent-tool-content" }); + const collapseState = { isExpanded: (_a3 = toolCall.isExpanded) != null ? _a3 : false }; + setupCollapsible(wrapperEl, headerEl, contentEl, collapseState, { + initiallyExpanded: (_b2 = toolCall.isExpanded) != null ? _b2 : false, + onToggle: (expanded) => { + toolCall.isExpanded = expanded; + }, + baseAriaLabel: getToolLabel(toolCall.name, toolCall.input) + }); + const view = { + wrapperEl, + nameEl, + summaryEl, + statusEl, + contentEl + }; + updateSubagentToolView(view, toolCall); + return view; +} +function ensureResultSection(state) { + if (state.resultSectionEl && state.resultBodyEl) { + return { wrapperEl: state.resultSectionEl, bodyEl: state.resultBodyEl }; + } + const section = createSection(state.contentEl, "Result", "claudian-subagent-result-body"); + section.wrapperEl.addClass("claudian-subagent-section-result"); + state.resultSectionEl = section.wrapperEl; + state.resultBodyEl = section.bodyEl; + return section; +} +function setResultText(state, text) { + const section = ensureResultSection(state); + section.bodyEl.empty(); + const resultEl = section.bodyEl.createDiv({ cls: "claudian-subagent-result-output" }); + resultEl.setText(text); +} +function hydrateSyncSubagentStateFromStored(state, subagent) { + state.info.description = subagent.description; + state.info.prompt = subagent.prompt; + state.info.mode = subagent.mode; + state.info.status = subagent.status; + state.info.result = subagent.result; + state.labelEl.setText(truncateDescription(subagent.description)); + setPromptText(state.promptBodyEl, subagent.prompt || ""); + for (const originalToolCall of subagent.toolCalls) { + const toolCall = { + ...originalToolCall, + input: { ...originalToolCall.input } + }; + addSubagentToolCall(state, toolCall); + if (toolCall.status !== "running" || toolCall.result) { + updateSubagentToolResult(state, toolCall.id, toolCall); + } + } + if (subagent.status === "completed" || subagent.status === "error") { + const fallback = subagent.status === "error" ? "ERROR" : "DONE"; + finalizeSubagentBlock(state, subagent.result || fallback, subagent.status === "error"); + } else { + state.statusEl.className = "claudian-subagent-status status-running"; + state.statusEl.empty(); + updateSyncHeaderAria(state); + } +} +function createSubagentBlock(parentEl, taskToolId, taskInput) { + const description = extractTaskDescription(taskInput); + const prompt = extractTaskPrompt(taskInput); + const info = { + id: taskToolId, + description, + prompt, + status: "running", + toolCalls: [], + isExpanded: false + }; + const wrapperEl = parentEl.createDiv({ cls: "claudian-subagent-list" }); + wrapperEl.dataset.subagentId = taskToolId; + const headerEl = wrapperEl.createDiv({ cls: "claudian-subagent-header" }); + headerEl.setAttribute("tabindex", "0"); + headerEl.setAttribute("role", "button"); + const iconEl = headerEl.createDiv({ cls: "claudian-subagent-icon" }); + iconEl.setAttribute("aria-hidden", "true"); + (0, import_obsidian26.setIcon)(iconEl, getToolIcon(TOOL_TASK)); + const labelEl = headerEl.createDiv({ cls: "claudian-subagent-label" }); + labelEl.setText(truncateDescription(description)); + const countEl = headerEl.createDiv({ cls: "claudian-subagent-count" }); + countEl.setText("0 tool uses"); + const statusEl = headerEl.createDiv({ cls: "claudian-subagent-status status-running" }); + statusEl.setAttribute("aria-label", "Status: running"); + const contentEl = wrapperEl.createDiv({ cls: "claudian-subagent-content" }); + const promptSection = createSection(contentEl, "Prompt", "claudian-subagent-prompt-body"); + promptSection.wrapperEl.addClass("claudian-subagent-section-prompt"); + setPromptText(promptSection.bodyEl, prompt); + const toolsContainerEl = contentEl.createDiv({ cls: "claudian-subagent-tools" }); + setupCollapsible(wrapperEl, headerEl, contentEl, info); + const state = { + wrapperEl, + contentEl, + headerEl, + labelEl, + countEl, + statusEl, + promptSectionEl: promptSection.wrapperEl, + promptBodyEl: promptSection.bodyEl, + toolsContainerEl, + resultSectionEl: null, + resultBodyEl: null, + toolElements: /* @__PURE__ */ new Map(), + info + }; + updateSyncHeaderAria(state); + return state; +} +function addSubagentToolCall(state, toolCall) { + state.info.toolCalls.push(toolCall); + const toolCount = state.info.toolCalls.length; + state.countEl.setText(`${toolCount} tool uses`); + const toolView = createSubagentToolView(state.toolsContainerEl, toolCall); + state.toolElements.set(toolCall.id, toolView); + updateSyncHeaderAria(state); +} +function updateSubagentToolResult(state, toolId, toolCall) { + const idx = state.info.toolCalls.findIndex((tc) => tc.id === toolId); + if (idx !== -1) { + state.info.toolCalls[idx] = toolCall; + } + const toolView = state.toolElements.get(toolId); + if (!toolView) { + return; + } + updateSubagentToolView(toolView, toolCall); +} +function finalizeSubagentBlock(state, result, isError) { + state.info.status = isError ? "error" : "completed"; + state.info.result = result; + state.labelEl.setText(truncateDescription(state.info.description)); + state.countEl.setText(`${state.info.toolCalls.length} tool uses`); + state.statusEl.className = "claudian-subagent-status"; + state.statusEl.addClass(`status-${state.info.status}`); + state.statusEl.empty(); + if (state.info.status === "completed") { + (0, import_obsidian26.setIcon)(state.statusEl, "check"); + state.wrapperEl.removeClass("error"); + state.wrapperEl.addClass("done"); + } else { + (0, import_obsidian26.setIcon)(state.statusEl, "x"); + state.wrapperEl.removeClass("done"); + state.wrapperEl.addClass("error"); + } + const finalText = (result == null ? void 0 : result.trim()) ? result : isError ? "ERROR" : "DONE"; + setResultText(state, finalText); + updateSyncHeaderAria(state); +} +function renderStoredSubagent(parentEl, subagent) { + const state = createSubagentBlock(parentEl, subagent.id, { + description: subagent.description, + prompt: subagent.prompt + }); + hydrateSyncSubagentStateFromStored(state, subagent); + return state.wrapperEl; +} +function setAsyncWrapperStatus(wrapperEl, status) { + const classes = ["pending", "running", "awaiting", "completed", "error", "orphaned", "async"]; + classes.forEach((cls) => wrapperEl.removeClass(cls)); + wrapperEl.addClass("async"); + wrapperEl.addClass(status); +} +function getAsyncDisplayStatus(asyncStatus) { + switch (asyncStatus) { + case "completed": + return "completed"; + case "error": + return "error"; + case "orphaned": + return "orphaned"; + default: + return "running"; + } +} +function getAsyncStatusText(asyncStatus) { + switch (asyncStatus) { + case "pending": + return "Initializing"; + case "completed": + return ""; + // Just show tick icon, no text + case "error": + return "Error"; + case "orphaned": + return "Orphaned"; + default: + return "Running in background"; + } +} +function getAsyncStatusAriaLabel(asyncStatus) { + switch (asyncStatus) { + case "pending": + return "Initializing"; + case "completed": + return "Completed"; + case "error": + return "Error"; + case "orphaned": + return "Orphaned"; + default: + return "Running in background"; + } +} +function updateAsyncLabel(state) { + state.labelEl.setText(truncateDescription(state.info.description)); + const statusLabel = getAsyncStatusAriaLabel(state.info.asyncStatus); + state.headerEl.setAttribute( + "aria-label", + `Background task: ${truncateDescription(state.info.description)} - ${statusLabel} - click to expand` + ); +} +function renderAsyncContentLikeSync(contentEl, subagent, displayStatus) { + var _a3; + contentEl.empty(); + const promptSection = createSection(contentEl, "Prompt", "claudian-subagent-prompt-body"); + promptSection.wrapperEl.addClass("claudian-subagent-section-prompt"); + setPromptText(promptSection.bodyEl, subagent.prompt || ""); + const toolsContainerEl = contentEl.createDiv({ cls: "claudian-subagent-tools" }); + for (const originalToolCall of subagent.toolCalls) { + const toolCall = { + ...originalToolCall, + input: { ...originalToolCall.input } + }; + createSubagentToolView(toolsContainerEl, toolCall); + } + if (displayStatus === "running") { + return; + } + const resultSection = createSection(contentEl, "Result", "claudian-subagent-result-body"); + resultSection.wrapperEl.addClass("claudian-subagent-section-result"); + const resultEl = resultSection.bodyEl.createDiv({ cls: "claudian-subagent-result-output" }); + if (displayStatus === "orphaned") { + resultEl.setText(subagent.result || "Conversation ended before task completed"); + return; + } + const fallback = displayStatus === "error" ? "ERROR" : "DONE"; + const finalText = ((_a3 = subagent.result) == null ? void 0 : _a3.trim()) ? subagent.result : fallback; + resultEl.setText(finalText); +} +function createAsyncSubagentBlock(parentEl, taskToolId, taskInput) { + const description = taskInput.description || "Background task"; + const prompt = taskInput.prompt || ""; + const info = { + id: taskToolId, + description, + prompt, + mode: "async", + status: "running", + toolCalls: [], + isExpanded: false, + asyncStatus: "pending" + }; + const wrapperEl = parentEl.createDiv({ cls: "claudian-subagent-list" }); + setAsyncWrapperStatus(wrapperEl, "pending"); + wrapperEl.dataset.asyncSubagentId = taskToolId; + const headerEl = wrapperEl.createDiv({ cls: "claudian-subagent-header" }); + headerEl.setAttribute("tabindex", "0"); + headerEl.setAttribute("role", "button"); + headerEl.setAttribute("aria-expanded", "false"); + headerEl.setAttribute("aria-label", `Background task: ${description} - Initializing - click to expand`); + const iconEl = headerEl.createDiv({ cls: "claudian-subagent-icon" }); + iconEl.setAttribute("aria-hidden", "true"); + (0, import_obsidian26.setIcon)(iconEl, getToolIcon(TOOL_TASK)); + const labelEl = headerEl.createDiv({ cls: "claudian-subagent-label" }); + labelEl.setText(truncateDescription(description)); + const statusTextEl = headerEl.createDiv({ cls: "claudian-subagent-status-text" }); + statusTextEl.setText("Initializing"); + const statusEl = headerEl.createDiv({ cls: "claudian-subagent-status status-running" }); + statusEl.setAttribute("aria-label", "Status: running"); + const contentEl = wrapperEl.createDiv({ cls: "claudian-subagent-content" }); + renderAsyncContentLikeSync(contentEl, info, "running"); + setupCollapsible(wrapperEl, headerEl, contentEl, info); + return { + wrapperEl, + contentEl, + headerEl, + labelEl, + statusTextEl, + statusEl, + info + }; +} +function updateAsyncSubagentRunning(state, agentId) { + state.info.asyncStatus = "running"; + state.info.agentId = agentId; + setAsyncWrapperStatus(state.wrapperEl, "running"); + updateAsyncLabel(state); + state.statusTextEl.setText("Running in background"); + renderAsyncContentLikeSync(state.contentEl, state.info, "running"); +} +function finalizeAsyncSubagent(state, result, isError) { + state.info.asyncStatus = isError ? "error" : "completed"; + state.info.status = isError ? "error" : "completed"; + state.info.result = result; + setAsyncWrapperStatus(state.wrapperEl, isError ? "error" : "completed"); + updateAsyncLabel(state); + state.statusTextEl.setText(isError ? "Error" : ""); + state.statusEl.className = "claudian-subagent-status"; + state.statusEl.addClass(`status-${isError ? "error" : "completed"}`); + state.statusEl.empty(); + if (isError) { + (0, import_obsidian26.setIcon)(state.statusEl, "x"); + } else { + (0, import_obsidian26.setIcon)(state.statusEl, "check"); + } + if (isError) { + state.wrapperEl.addClass("error"); + } else { + state.wrapperEl.addClass("done"); + } + renderAsyncContentLikeSync(state.contentEl, state.info, isError ? "error" : "completed"); +} +function markAsyncSubagentOrphaned(state) { + state.info.asyncStatus = "orphaned"; + state.info.status = "error"; + state.info.result = "Conversation ended before task completed"; + setAsyncWrapperStatus(state.wrapperEl, "orphaned"); + updateAsyncLabel(state); + state.statusTextEl.setText("Orphaned"); + state.statusEl.className = "claudian-subagent-status status-error"; + state.statusEl.empty(); + (0, import_obsidian26.setIcon)(state.statusEl, "alert-circle"); + state.wrapperEl.addClass("error"); + state.wrapperEl.addClass("orphaned"); + renderAsyncContentLikeSync(state.contentEl, state.info, "orphaned"); +} +function renderStoredAsyncSubagent(parentEl, subagent) { + const wrapperEl = parentEl.createDiv({ cls: "claudian-subagent-list" }); + const displayStatus = getAsyncDisplayStatus(subagent.asyncStatus); + setAsyncWrapperStatus(wrapperEl, displayStatus); + if (displayStatus === "completed") { + wrapperEl.addClass("done"); + } else if (displayStatus === "error" || displayStatus === "orphaned") { + wrapperEl.addClass("error"); + } + wrapperEl.dataset.asyncSubagentId = subagent.id; + const statusText = getAsyncStatusText(subagent.asyncStatus); + const statusAriaLabel = getAsyncStatusAriaLabel(subagent.asyncStatus); + const headerEl = wrapperEl.createDiv({ cls: "claudian-subagent-header" }); + headerEl.setAttribute("tabindex", "0"); + headerEl.setAttribute("role", "button"); + headerEl.setAttribute("aria-expanded", "false"); + headerEl.setAttribute( + "aria-label", + `Background task: ${subagent.description} - ${statusAriaLabel} - click to expand` + ); + const iconEl = headerEl.createDiv({ cls: "claudian-subagent-icon" }); + iconEl.setAttribute("aria-hidden", "true"); + (0, import_obsidian26.setIcon)(iconEl, getToolIcon(TOOL_TASK)); + const labelEl = headerEl.createDiv({ cls: "claudian-subagent-label" }); + labelEl.setText(truncateDescription(subagent.description)); + const statusTextEl = headerEl.createDiv({ cls: "claudian-subagent-status-text" }); + statusTextEl.setText(statusText); + let statusIconClass; + switch (displayStatus) { + case "error": + case "orphaned": + statusIconClass = "status-error"; + break; + case "completed": + statusIconClass = "status-completed"; + break; + default: + statusIconClass = "status-running"; + } + const statusEl = headerEl.createDiv({ cls: `claudian-subagent-status ${statusIconClass}` }); + statusEl.setAttribute("aria-label", `Status: ${statusAriaLabel}`); + switch (displayStatus) { + case "completed": + (0, import_obsidian26.setIcon)(statusEl, "check"); + break; + case "error": + (0, import_obsidian26.setIcon)(statusEl, "x"); + break; + case "orphaned": + (0, import_obsidian26.setIcon)(statusEl, "alert-circle"); + break; + } + const contentEl = wrapperEl.createDiv({ cls: "claudian-subagent-content" }); + renderAsyncContentLikeSync(contentEl, subagent, displayStatus); + const state = { isExpanded: false }; + setupCollapsible(wrapperEl, headerEl, contentEl, state); + return wrapperEl; +} + +// src/features/chat/rendering/WriteEditRenderer.ts +var import_obsidian27 = require("obsidian"); +function shortenPath2(filePath, maxLength = 40) { + if (!filePath) return "file"; + const normalized = filePath.replace(/\\/g, "/"); + if (normalized.length <= maxLength) return normalized; + const parts = normalized.split("/"); + if (parts.length <= 2) { + return "..." + normalized.slice(-maxLength + 3); + } + const filename = parts[parts.length - 1]; + const firstDir = parts[0]; + const available = maxLength - firstDir.length - filename.length - 5; + if (available < 0) { + return "..." + filename.slice(-maxLength + 3); + } + return `${firstDir}/.../${filename}`; +} +function renderDiffStats(statsEl, stats) { + if (stats.added > 0) { + const addedEl = statsEl.createSpan({ cls: "added" }); + addedEl.setText(`+${stats.added}`); + } + if (stats.removed > 0) { + if (stats.added > 0) { + statsEl.createSpan({ text: " " }); + } + const removedEl = statsEl.createSpan({ cls: "removed" }); + removedEl.setText(`-${stats.removed}`); + } +} +function createWriteEditBlock(parentEl, toolCall) { + const filePath = toolCall.input.file_path || "file"; + const toolName = toolCall.name; + const wrapperEl = parentEl.createDiv({ cls: "claudian-write-edit-block" }); + wrapperEl.dataset.toolId = toolCall.id; + const headerEl = wrapperEl.createDiv({ cls: "claudian-write-edit-header" }); + headerEl.setAttribute("tabindex", "0"); + headerEl.setAttribute("role", "button"); + headerEl.setAttribute("aria-label", `${toolName}: ${shortenPath2(filePath)} - click to expand`); + const iconEl = headerEl.createDiv({ cls: "claudian-write-edit-icon" }); + iconEl.setAttribute("aria-hidden", "true"); + (0, import_obsidian27.setIcon)(iconEl, getToolIcon(toolName)); + const nameEl = headerEl.createDiv({ cls: "claudian-write-edit-name" }); + nameEl.setText(toolName); + const summaryEl = headerEl.createDiv({ cls: "claudian-write-edit-summary" }); + summaryEl.setText(fileNameOnly(filePath) || "file"); + const statsEl = headerEl.createDiv({ cls: "claudian-write-edit-stats" }); + const statusEl = headerEl.createDiv({ cls: "claudian-write-edit-status status-running" }); + statusEl.setAttribute("aria-label", "Status: running"); + const contentEl = wrapperEl.createDiv({ cls: "claudian-write-edit-content" }); + const loadingRow = contentEl.createDiv({ cls: "claudian-write-edit-diff-row" }); + const loadingEl = loadingRow.createDiv({ cls: "claudian-write-edit-loading" }); + loadingEl.setText("Writing..."); + const state = { + wrapperEl, + contentEl, + headerEl, + nameEl, + summaryEl, + statsEl, + statusEl, + toolCall, + isExpanded: false + }; + setupCollapsible(wrapperEl, headerEl, contentEl, state); + return state; +} +function updateWriteEditWithDiff(state, diffData) { + state.statsEl.empty(); + state.contentEl.empty(); + const { diffLines, stats } = diffData; + state.diffLines = diffLines; + renderDiffStats(state.statsEl, stats); + const row = state.contentEl.createDiv({ cls: "claudian-write-edit-diff-row" }); + const diffEl = row.createDiv({ cls: "claudian-write-edit-diff" }); + renderDiffContent(diffEl, diffLines); +} +function finalizeWriteEditBlock(state, isError) { + state.statusEl.className = "claudian-write-edit-status"; + state.statusEl.empty(); + if (isError) { + state.statusEl.addClass("status-error"); + (0, import_obsidian27.setIcon)(state.statusEl, "x"); + state.statusEl.setAttribute("aria-label", "Status: error"); + if (!state.diffLines) { + state.contentEl.empty(); + const row = state.contentEl.createDiv({ cls: "claudian-write-edit-diff-row" }); + const errorEl = row.createDiv({ cls: "claudian-write-edit-error" }); + errorEl.setText(state.toolCall.result || "Error"); + } + } else if (!state.diffLines) { + state.contentEl.empty(); + const row = state.contentEl.createDiv({ cls: "claudian-write-edit-diff-row" }); + const doneEl = row.createDiv({ cls: "claudian-write-edit-done-text" }); + doneEl.setText("DONE"); + } + if (isError) { + state.wrapperEl.addClass("error"); + } else { + state.wrapperEl.addClass("done"); + } +} +function renderStoredWriteEdit(parentEl, toolCall) { + const filePath = toolCall.input.file_path || "file"; + const toolName = toolCall.name; + const isError = toolCall.status === "error" || toolCall.status === "blocked"; + const wrapperEl = parentEl.createDiv({ cls: "claudian-write-edit-block" }); + if (isError) { + wrapperEl.addClass("error"); + } else if (toolCall.status === "completed") { + wrapperEl.addClass("done"); + } + wrapperEl.dataset.toolId = toolCall.id; + const headerEl = wrapperEl.createDiv({ cls: "claudian-write-edit-header" }); + headerEl.setAttribute("tabindex", "0"); + headerEl.setAttribute("role", "button"); + const iconEl = headerEl.createDiv({ cls: "claudian-write-edit-icon" }); + iconEl.setAttribute("aria-hidden", "true"); + (0, import_obsidian27.setIcon)(iconEl, getToolIcon(toolName)); + const nameEl = headerEl.createDiv({ cls: "claudian-write-edit-name" }); + nameEl.setText(toolName); + const summaryEl = headerEl.createDiv({ cls: "claudian-write-edit-summary" }); + summaryEl.setText(fileNameOnly(filePath) || "file"); + const statsEl = headerEl.createDiv({ cls: "claudian-write-edit-stats" }); + if (toolCall.diffData) { + renderDiffStats(statsEl, toolCall.diffData.stats); + } + const statusEl = headerEl.createDiv({ cls: "claudian-write-edit-status" }); + if (isError) { + statusEl.addClass("status-error"); + (0, import_obsidian27.setIcon)(statusEl, "x"); + } + const contentEl = wrapperEl.createDiv({ cls: "claudian-write-edit-content" }); + const row = contentEl.createDiv({ cls: "claudian-write-edit-diff-row" }); + if (toolCall.diffData && toolCall.diffData.diffLines.length > 0) { + const diffEl = row.createDiv({ cls: "claudian-write-edit-diff" }); + renderDiffContent(diffEl, toolCall.diffData.diffLines); + } else if (isError && toolCall.result) { + const errorEl = row.createDiv({ cls: "claudian-write-edit-error" }); + errorEl.setText(toolCall.result); + } else { + const doneEl = row.createDiv({ cls: "claudian-write-edit-done-text" }); + doneEl.setText(isError ? "ERROR" : "DONE"); + } + const state = { isExpanded: false }; + setupCollapsible(wrapperEl, headerEl, contentEl, state); + return wrapperEl; +} + +// src/features/chat/controllers/StreamController.ts +var _StreamController = class _StreamController { + // agentId → spawn callId + constructor(deps) { + // Provider lifecycle agent tracking (spawn → wait/close lifecycle) + this.lifecycleSubagentStates = /* @__PURE__ */ new Map(); + // spawn callId → SubagentState + this.lifecycleAgentIdToSpawnId = /* @__PURE__ */ new Map(); + this.deps = deps; + } + getActiveProviderId() { + var _a3, _b2, _c, _d; + return (_d = (_c = (_b2 = (_a3 = this.deps).getAgentService) == null ? void 0 : _b2.call(_a3)) == null ? void 0 : _c.providerId) != null ? _d : DEFAULT_CHAT_PROVIDER_ID; + } + getSubagentLifecycleAdapter(toolName) { + return resolveSubagentLifecycleAdapter(this.getActiveProviderId(), toolName); + } + // ============================================ + // Stream Chunk Handling + // ============================================ + async handleStreamChunk(chunk, msg) { + var _a3, _b2, _c, _d, _e; + const { state } = this.deps; + switch (chunk.type) { + case "thinking": + this.flushPendingTools(); + if (state.currentTextEl) { + this.finalizeCurrentTextBlock(msg); + } + await this.appendThinking(chunk.content); + break; + case "text": + this.flushPendingTools(); + if (state.currentThinkingState) { + this.finalizeCurrentThinkingBlock(msg); + } + msg.content += chunk.content; + await this.appendText(chunk.content); + break; + case "tool_use": { + if (state.currentThinkingState) { + this.finalizeCurrentThinkingBlock(msg); + } + this.finalizeCurrentTextBlock(msg); + if (isSubagentToolName(chunk.name)) { + this.flushPendingTools(); + this.handleTaskToolUseViaManager(chunk, msg); + break; + } + if (chunk.name === TOOL_AGENT_OUTPUT) { + this.handleAgentOutputToolUse(chunk, msg); + break; + } + const subagentLifecycleAdapter = this.getSubagentLifecycleAdapter(chunk.name); + if (subagentLifecycleAdapter == null ? void 0 : subagentLifecycleAdapter.isSpawnTool(chunk.name)) { + this.handleProviderSubagentSpawn(chunk, msg, subagentLifecycleAdapter); + break; + } + if (subagentLifecycleAdapter == null ? void 0 : subagentLifecycleAdapter.isHiddenTool(chunk.name)) { + this.handleProviderHiddenSubagentTool(chunk, msg); + break; + } + this.handleRegularToolUse(chunk, msg); + break; + } + case "tool_result": { + await this.handleToolResult(chunk, msg); + break; + } + case "subagent_tool_use": + case "subagent_tool_result": + await this.handleSubagentChunk(chunk, msg); + break; + case "tool_output": + this.handleToolOutput(chunk, msg); + break; + case "notice": + this.flushPendingTools(); + await this.appendText(` + +\u26A0\uFE0F **${chunk.level === "warning" ? "Blocked" : "Notice"}:** ${chunk.content}`); + break; + case "error": + this.flushPendingTools(); + await this.appendText(` + +\u274C **Error:** ${chunk.content}`); + break; + case "done": + this.flushPendingTools(); + break; + case "context_compacted": { + this.flushPendingTools(); + if (state.currentThinkingState) { + this.finalizeCurrentThinkingBlock(msg); + } + this.finalizeCurrentTextBlock(msg); + msg.contentBlocks = msg.contentBlocks || []; + msg.contentBlocks.push({ type: "context_compacted" }); + this.renderCompactBoundary(); + break; + } + case "usage": { + const currentSessionId = (_d = (_c = (_b2 = (_a3 = this.deps).getAgentService) == null ? void 0 : _b2.call(_a3)) == null ? void 0 : _c.getSessionId()) != null ? _d : null; + const chunkSessionId = (_e = chunk.sessionId) != null ? _e : null; + if (chunkSessionId && currentSessionId && chunkSessionId !== currentSessionId || chunkSessionId && !currentSessionId) { + break; + } + if (this.deps.subagentManager.subagentsSpawnedThisStream > 0) { + break; + } + if (!state.ignoreUsageUpdates) { + const activeModel = this.getActiveProviderModel(); + state.usage = activeModel && !chunk.usage.model ? { ...chunk.usage, model: activeModel } : chunk.usage; + } + break; + } + default: + break; + } + this.scrollToBottom(); + } + // ============================================ + // Tool Use Handling + // ============================================ + /** + * Handles regular tool_use chunks by buffering them. + * Tools are rendered when flushPendingTools is called (on next content type or tool_result). + */ + handleRegularToolUse(chunk, msg) { + var _a3, _b2, _c; + const { state } = this.deps; + const existingToolCall = (_a3 = msg.toolCalls) == null ? void 0 : _a3.find((tc) => tc.id === chunk.id); + if (existingToolCall) { + const newInput = chunk.input || {}; + if (Object.keys(newInput).length > 0) { + existingToolCall.input = { ...existingToolCall.input, ...newInput }; + if (existingToolCall.name === TOOL_TODO_WRITE) { + const todos = parseTodoInput(existingToolCall.input); + if (todos) { + this.deps.state.currentTodos = todos; + } + } + if (existingToolCall.name === TOOL_WRITE) { + this.capturePlanFilePath(existingToolCall.input); + } + const toolEl = state.toolCallElements.get(chunk.id); + if (toolEl) { + const nameEl = (_b2 = toolEl.querySelector(".claudian-tool-name")) != null ? _b2 : toolEl.querySelector(".claudian-write-edit-name"); + if (nameEl) { + nameEl.setText(getToolName(existingToolCall.name, existingToolCall.input)); + } + const summaryEl = (_c = toolEl.querySelector(".claudian-tool-summary")) != null ? _c : toolEl.querySelector(".claudian-write-edit-summary"); + if (summaryEl) { + summaryEl.setText(getToolSummary(existingToolCall.name, existingToolCall.input)); + } + } + } + return; + } + const toolCall = { + id: chunk.id, + name: chunk.name, + input: chunk.input, + status: "running", + isExpanded: false + }; + msg.toolCalls = msg.toolCalls || []; + msg.toolCalls.push(toolCall); + msg.contentBlocks = msg.contentBlocks || []; + msg.contentBlocks.push({ type: "tool_use", toolId: chunk.id }); + if (chunk.name === TOOL_TODO_WRITE) { + const todos = parseTodoInput(chunk.input); + if (todos) { + this.deps.state.currentTodos = todos; + } + } + if (chunk.name === TOOL_WRITE) { + this.capturePlanFilePath(chunk.input); + } + if (state.currentContentEl) { + state.pendingTools.set(chunk.id, { + toolCall, + parentEl: state.currentContentEl + }); + this.showThinkingIndicator(); + } + } + getActiveProviderModel() { + var _a3, _b2, _c; + const providerId = (_c = (_b2 = (_a3 = this.deps).getAgentService) == null ? void 0 : _b2.call(_a3)) == null ? void 0 : _c.providerId; + if (!providerId) { + return void 0; + } + const settings11 = ProviderSettingsCoordinator.getProviderSettingsSnapshot( + this.deps.plugin.settings, + providerId + ); + return typeof settings11.model === "string" ? settings11.model : void 0; + } + capturePlanFilePath(input) { + var _a3, _b2, _c; + const filePath = input.file_path; + if (!filePath) return; + const planPathPrefix = (_c = (_b2 = (_a3 = this.deps).getAgentService) == null ? void 0 : _b2.call(_a3)) == null ? void 0 : _c.getCapabilities().planPathPrefix; + if (planPathPrefix && filePath.replace(/\\/g, "/").includes(planPathPrefix)) { + this.deps.state.planFilePath = filePath; + } + } + /** + * Flushes all pending tool calls by rendering them. + * Called when a different content type arrives or stream ends. + */ + flushPendingTools() { + const { state } = this.deps; + if (state.pendingTools.size === 0) { + return; + } + for (const toolId of state.pendingTools.keys()) { + this.renderPendingTool(toolId); + } + state.pendingTools.clear(); + } + /** + * Renders a single pending tool call and moves it from pending to rendered state. + */ + renderPendingTool(toolId) { + const { state } = this.deps; + const pending = state.pendingTools.get(toolId); + if (!pending) return; + const { toolCall, parentEl } = pending; + if (!parentEl) return; + if (isWriteEditTool(toolCall.name)) { + const writeEditState = createWriteEditBlock(parentEl, toolCall); + state.writeEditStates.set(toolId, writeEditState); + state.toolCallElements.set(toolId, writeEditState.wrapperEl); + } else { + renderToolCall(parentEl, toolCall, state.toolCallElements); + } + state.pendingTools.delete(toolId); + } + handleToolOutput(chunk, msg) { + var _a3, _b2; + const { state } = this.deps; + if (state.pendingTools.has(chunk.id)) { + this.renderPendingTool(chunk.id); + } + const existingToolCall = (_a3 = msg.toolCalls) == null ? void 0 : _a3.find((tc) => tc.id === chunk.id); + if (!existingToolCall) { + return; + } + existingToolCall.result = ((_b2 = existingToolCall.result) != null ? _b2 : "") + chunk.content; + updateToolCallResult(chunk.id, existingToolCall, state.toolCallElements); + this.showThinkingIndicator(); + } + // ============================================ + // Provider lifecycle subagents (spawn → wait/close) + // ============================================ + handleProviderSubagentSpawn(chunk, msg, adapter) { + const { state } = this.deps; + const toolCall = { + id: chunk.id, + name: chunk.name, + input: chunk.input, + status: "running", + isExpanded: false + }; + msg.toolCalls = msg.toolCalls || []; + msg.toolCalls.push(toolCall); + msg.contentBlocks = msg.contentBlocks || []; + msg.contentBlocks.push({ type: "tool_use", toolId: chunk.id }); + if (state.currentContentEl) { + this.flushPendingTools(); + const subagentInfo = adapter.buildSubagentInfo(toolCall, msg.toolCalls); + const subagentState = createSubagentBlock(state.currentContentEl, chunk.id, { + description: subagentInfo.description, + prompt: subagentInfo.prompt + }); + this.lifecycleSubagentStates.set(chunk.id, subagentState); + } + } + handleProviderHiddenSubagentTool(chunk, msg) { + const toolCall = { + id: chunk.id, + name: chunk.name, + input: chunk.input, + status: "running", + isExpanded: false + }; + msg.toolCalls = msg.toolCalls || []; + msg.toolCalls.push(toolCall); + } + /** + * Handles tool_result for provider lifecycle subagent tools. + * Returns true if the result was consumed (caller should return early). + */ + handleProviderSubagentResult(chunk, msg) { + var _a3, _b2, _c, _d; + const existingToolCall = (_a3 = msg.toolCalls) == null ? void 0 : _a3.find((tc) => tc.id === chunk.id); + if (!existingToolCall) return false; + const adapter = this.getSubagentLifecycleAdapter(existingToolCall.name); + if (!adapter) return false; + if (adapter.isSpawnTool(existingToolCall.name)) { + existingToolCall.status = chunk.isError ? "error" : "completed"; + existingToolCall.result = chunk.content; + const spawnResult = adapter.extractSpawnResult(chunk.content); + if (spawnResult.agentId) { + this.lifecycleAgentIdToSpawnId.set(spawnResult.agentId, chunk.id); + } + const subagentInfo = adapter.buildSubagentInfo(existingToolCall, (_b2 = msg.toolCalls) != null ? _b2 : []); + const subagentState = this.lifecycleSubagentStates.get(chunk.id); + if (subagentState) { + subagentState.info.description = subagentInfo.description; + subagentState.info.prompt = subagentInfo.prompt; + subagentState.labelEl.setText( + subagentInfo.description.length > 40 ? subagentInfo.description.substring(0, 40) + "..." : subagentInfo.description + ); + } + if (chunk.isError) { + if (subagentState) { + finalizeSubagentBlock(subagentState, chunk.content || "Error", true); + } + } + return true; + } + if (adapter.isWaitTool(existingToolCall.name)) { + existingToolCall.status = chunk.isError ? "error" : "completed"; + existingToolCall.result = chunk.content; + for (const spawnId of adapter.resolveSpawnToolIds( + existingToolCall, + this.lifecycleAgentIdToSpawnId + )) { + const spawnToolCall = (_c = msg.toolCalls) == null ? void 0 : _c.find((tc) => tc.id === spawnId); + const subagentState = this.lifecycleSubagentStates.get(spawnId); + if (!spawnToolCall || !subagentState) continue; + const subagentInfo = adapter.buildSubagentInfo(spawnToolCall, (_d = msg.toolCalls) != null ? _d : []); + subagentState.info.description = subagentInfo.description; + subagentState.info.prompt = subagentInfo.prompt; + if (subagentInfo.status === "completed" || subagentInfo.status === "error") { + finalizeSubagentBlock( + subagentState, + subagentInfo.result || (subagentInfo.status === "error" ? "Error" : "DONE"), + subagentInfo.status === "error" + ); + } + } + return true; + } + if (adapter.isCloseTool(existingToolCall.name)) { + existingToolCall.status = chunk.isError ? "error" : "completed"; + existingToolCall.result = chunk.content; + return true; + } + return false; + } + async handleToolResult(chunk, msg) { + var _a3, _b2; + const { state, subagentManager } = this.deps; + if (subagentManager.hasPendingTask(chunk.id)) { + this.renderPendingTaskFromTaskResultViaManager(chunk, msg); + } + const subagentState = subagentManager.getSyncSubagent(chunk.id); + if (subagentState) { + this.finalizeSubagent(chunk, msg); + return; + } + if (this.handleAsyncTaskToolResult(chunk)) { + this.showThinkingIndicator(); + return; + } + if (await this.handleAgentOutputToolResult(chunk)) { + this.showThinkingIndicator(); + return; + } + if (this.handleProviderSubagentResult(chunk, msg)) { + this.showThinkingIndicator(); + return; + } + if (state.pendingTools.has(chunk.id)) { + this.renderPendingTool(chunk.id); + } + const existingToolCall = (_a3 = msg.toolCalls) == null ? void 0 : _a3.find((tc) => tc.id === chunk.id); + const isBlocked = isBlockedToolResult(chunk.content, chunk.isError); + if (existingToolCall) { + if (chunk.isError) { + existingToolCall.status = "error"; + } else if (!skipsBlockedDetection(existingToolCall.name) && isBlocked) { + existingToolCall.status = "blocked"; + } else { + existingToolCall.status = "completed"; + } + existingToolCall.result = chunk.content; + if (existingToolCall.name === TOOL_ASK_USER_QUESTION) { + const answers = (_b2 = extractResolvedAnswers(chunk.toolUseResult)) != null ? _b2 : extractResolvedAnswersFromResultText(chunk.content); + if (answers) existingToolCall.resolvedAnswers = answers; + } + const writeEditState = state.writeEditStates.get(chunk.id); + if (writeEditState && isWriteEditTool(existingToolCall.name)) { + if (!chunk.isError && !isBlocked) { + const diffData = extractDiffData(chunk.toolUseResult, existingToolCall); + if (diffData) { + existingToolCall.diffData = diffData; + updateWriteEditWithDiff(writeEditState, diffData); + } + } + finalizeWriteEditBlock(writeEditState, chunk.isError || isBlocked); + } else { + updateToolCallResult(chunk.id, existingToolCall, state.toolCallElements); + } + if (!chunk.isError && !isBlocked && isEditTool(existingToolCall.name)) { + this.notifyVaultFileChange(existingToolCall.input); + } + if (!chunk.isError && !isBlocked && existingToolCall.name === TOOL_APPLY_PATCH) { + this.notifyApplyPatchFileChanges(existingToolCall.input); + } + } + this.showThinkingIndicator(); + } + // ============================================ + // Text Block Management + // ============================================ + async appendText(text) { + const { state, renderer } = this.deps; + if (!state.currentContentEl) return; + this.hideThinkingIndicator(); + if (!state.currentTextEl) { + state.currentTextEl = state.currentContentEl.createDiv({ cls: "claudian-text-block" }); + state.currentTextContent = ""; + } + state.currentTextContent += text; + await renderer.renderContent(state.currentTextEl, state.currentTextContent); + } + finalizeCurrentTextBlock(msg) { + const { state, renderer } = this.deps; + if (msg && state.currentTextContent) { + msg.contentBlocks = msg.contentBlocks || []; + msg.contentBlocks.push({ type: "text", content: state.currentTextContent }); + if (state.currentTextEl) { + renderer.addTextCopyButton(state.currentTextEl, state.currentTextContent); + } + } + state.currentTextEl = null; + state.currentTextContent = ""; + } + // ============================================ + // Thinking Block Management + // ============================================ + async appendThinking(content) { + const { state, renderer } = this.deps; + if (!state.currentContentEl) return; + this.hideThinkingIndicator(); + if (!state.currentThinkingState) { + state.currentThinkingState = createThinkingBlock( + state.currentContentEl, + (el2, md) => renderer.renderContent(el2, md) + ); + } + await appendThinkingContent(state.currentThinkingState, content, (el2, md) => renderer.renderContent(el2, md)); + } + finalizeCurrentThinkingBlock(msg) { + const { state } = this.deps; + if (!state.currentThinkingState) return; + const durationSeconds = finalizeThinkingBlock(state.currentThinkingState); + if (msg && state.currentThinkingState.content) { + msg.contentBlocks = msg.contentBlocks || []; + msg.contentBlocks.push({ + type: "thinking", + content: state.currentThinkingState.content, + durationSeconds + }); + } + state.currentThinkingState = null; + } + // ============================================ + // Subagent Tool Handling (via SubagentManager) + // ============================================ + /** Delegates Agent tool_use to SubagentManager and updates message based on result. */ + handleTaskToolUseViaManager(chunk, msg) { + const { state, subagentManager } = this.deps; + this.ensureTaskToolCall(msg, chunk.id, chunk.input); + const result = subagentManager.handleTaskToolUse(chunk.id, chunk.input, state.currentContentEl); + switch (result.action) { + case "created_sync": + this.recordSubagentInMessage(msg, result.subagentState.info, chunk.id); + this.showThinkingIndicator(); + break; + case "created_async": + this.recordSubagentInMessage(msg, result.info, chunk.id, "async"); + this.showThinkingIndicator(); + break; + case "buffered": + this.showThinkingIndicator(); + break; + case "label_updated": + break; + } + } + /** Renders a pending Agent tool call via SubagentManager and updates message. */ + renderPendingTaskViaManager(toolId, msg) { + const result = this.deps.subagentManager.renderPendingTask(toolId, this.deps.state.currentContentEl); + if (!result) return; + if (result.mode === "sync") { + this.recordSubagentInMessage(msg, result.subagentState.info, toolId); + } else { + this.recordSubagentInMessage(msg, result.info, toolId, "async"); + } + } + /** Resolves a pending Agent tool call when its own tool_result arrives. */ + renderPendingTaskFromTaskResultViaManager(chunk, msg) { + const result = this.deps.subagentManager.renderPendingTaskFromTaskResult( + chunk.id, + chunk.content, + chunk.isError || false, + this.deps.state.currentContentEl, + chunk.toolUseResult + ); + if (!result) return; + if (result.mode === "sync") { + this.recordSubagentInMessage(msg, result.subagentState.info, chunk.id); + } else { + this.recordSubagentInMessage(msg, result.info, chunk.id, "async"); + } + } + recordSubagentInMessage(msg, info, toolId, mode) { + const taskToolCall = this.ensureTaskToolCall(msg, toolId); + this.applySubagentToTaskToolCall(taskToolCall, info); + msg.contentBlocks = msg.contentBlocks || []; + const existingBlock = msg.contentBlocks.find( + (block) => block.type === "subagent" && block.subagentId === toolId + ); + if (existingBlock && mode && existingBlock.type === "subagent") { + existingBlock.mode = mode; + } else if (!existingBlock) { + msg.contentBlocks.push( + mode ? { type: "subagent", subagentId: toolId, mode } : { type: "subagent", subagentId: toolId } + ); + } + } + async handleSubagentChunk(chunk, msg) { + const parentToolUseId = chunk.subagentId; + const { subagentManager } = this.deps; + if (subagentManager.hasPendingTask(parentToolUseId)) { + this.renderPendingTaskViaManager(parentToolUseId, msg); + } + const subagentState = subagentManager.getSyncSubagent(parentToolUseId); + if (!subagentState) { + return; + } + switch (chunk.type) { + case "subagent_tool_use": { + const toolCall = { + id: chunk.id, + name: chunk.name, + input: chunk.input, + status: "running", + isExpanded: false + }; + subagentManager.addSyncToolCall(parentToolUseId, toolCall); + this.showThinkingIndicator(); + break; + } + case "subagent_tool_result": { + const toolCall = subagentState.info.toolCalls.find((tc) => tc.id === chunk.id); + if (toolCall) { + const isBlocked = isBlockedToolResult(chunk.content, chunk.isError); + toolCall.status = isBlocked ? "blocked" : chunk.isError ? "error" : "completed"; + toolCall.result = chunk.content; + subagentManager.updateSyncToolResult(parentToolUseId, chunk.id, toolCall); + } + break; + } + default: + break; + } + } + /** Finalizes a sync subagent when its Agent tool_result is received. */ + finalizeSubagent(chunk, msg) { + var _a3; + const isError = chunk.isError || false; + const finalized = this.deps.subagentManager.finalizeSyncSubagent( + chunk.id, + chunk.content, + isError, + chunk.toolUseResult + ); + const extractedResult = (_a3 = finalized == null ? void 0 : finalized.result) != null ? _a3 : chunk.content; + const taskToolCall = this.ensureTaskToolCall(msg, chunk.id); + taskToolCall.status = isError ? "error" : "completed"; + taskToolCall.result = extractedResult; + if (taskToolCall.subagent) { + taskToolCall.subagent.status = isError ? "error" : "completed"; + taskToolCall.subagent.result = extractedResult; + } + if (finalized) { + this.applySubagentToTaskToolCall(taskToolCall, finalized); + } + this.showThinkingIndicator(); + } + // ============================================ + // Async Subagent Handling + // ============================================ + /** Handles TaskOutput tool_use (invisible, links to async subagent). */ + handleAgentOutputToolUse(chunk, _msg) { + const toolCall = { + id: chunk.id, + name: chunk.name, + input: chunk.input, + status: "running", + isExpanded: false + }; + this.deps.subagentManager.handleAgentOutputToolUse(toolCall); + this.showThinkingIndicator(); + } + handleAsyncTaskToolResult(chunk) { + const { subagentManager } = this.deps; + if (!subagentManager.isPendingAsyncTask(chunk.id)) { + return false; + } + subagentManager.handleTaskToolResult(chunk.id, chunk.content, chunk.isError, chunk.toolUseResult); + return true; + } + /** Handles TaskOutput result to finalize async subagent. */ + async handleAgentOutputToolResult(chunk) { + const { subagentManager } = this.deps; + const isLinked = subagentManager.isLinkedAgentOutputTool(chunk.id); + const handled = subagentManager.handleAgentOutputToolResult( + chunk.id, + chunk.content, + chunk.isError || false, + chunk.toolUseResult + ); + await this.hydrateAsyncSubagentToolCalls(handled); + return isLinked || handled !== void 0; + } + async hydrateAsyncSubagentToolCalls(subagent) { + var _a3, _b2, _c; + if (!subagent) return; + if (subagent.mode !== "async") return; + if (!subagent.agentId) return; + const asyncStatus = (_a3 = subagent.asyncStatus) != null ? _a3 : subagent.status; + if (asyncStatus !== "completed" && asyncStatus !== "error") return; + const runtime = (_c = (_b2 = this.deps).getAgentService) == null ? void 0 : _c.call(_b2); + if (!runtime) return; + const { hasHydrated, finalResultHydrated } = await this.tryHydrateAsyncSubagent( + subagent, + runtime, + true + ); + if (hasHydrated) { + this.deps.subagentManager.refreshAsyncSubagent(subagent); + } + if (!finalResultHydrated) { + this.scheduleAsyncSubagentResultRetry(subagent, runtime, 0); + } + } + async tryHydrateAsyncSubagent(subagent, runtime, hydrateToolCalls) { + var _a3, _b2, _c, _d, _e; + let hasHydrated = false; + let finalResultHydrated = false; + if (hydrateToolCalls && !((_a3 = subagent.toolCalls) == null ? void 0 : _a3.length)) { + const recoveredToolCalls = (_c = await ((_b2 = runtime.loadSubagentToolCalls) == null ? void 0 : _b2.call( + runtime, + subagent.agentId || "" + ))) != null ? _c : []; + if (recoveredToolCalls.length > 0) { + subagent.toolCalls = recoveredToolCalls.map((toolCall) => ({ + ...toolCall, + input: { ...toolCall.input } + })); + hasHydrated = true; + } + } + const recoveredFinalResult = (_e = await ((_d = runtime.loadSubagentFinalResult) == null ? void 0 : _d.call( + runtime, + subagent.agentId || "" + ))) != null ? _e : null; + if (recoveredFinalResult && recoveredFinalResult.trim().length > 0) { + finalResultHydrated = true; + if (recoveredFinalResult !== subagent.result) { + subagent.result = recoveredFinalResult; + hasHydrated = true; + } + } + return { hasHydrated, finalResultHydrated }; + } + scheduleAsyncSubagentResultRetry(subagent, runtime, attempt) { + if (!subagent.agentId) return; + if (attempt >= _StreamController.ASYNC_SUBAGENT_RESULT_RETRY_DELAYS_MS.length) return; + const delay = _StreamController.ASYNC_SUBAGENT_RESULT_RETRY_DELAYS_MS[attempt]; + setTimeout(() => { + void this.retryAsyncSubagentResult(subagent, runtime, attempt); + }, delay); + } + async retryAsyncSubagentResult(subagent, runtime, attempt) { + var _a3; + if (!subagent.agentId) return; + const asyncStatus = (_a3 = subagent.asyncStatus) != null ? _a3 : subagent.status; + if (asyncStatus !== "completed" && asyncStatus !== "error") return; + const { hasHydrated, finalResultHydrated } = await this.tryHydrateAsyncSubagent( + subagent, + runtime, + false + ); + if (hasHydrated) { + this.deps.subagentManager.refreshAsyncSubagent(subagent); + } + if (!finalResultHydrated) { + this.scheduleAsyncSubagentResultRetry(subagent, runtime, attempt + 1); + } + } + /** Callback from SubagentManager when async state changes. Updates messages only (DOM handled by manager). */ + onAsyncSubagentStateChange(subagent) { + this.updateSubagentInMessages(subagent); + this.scrollToBottom(); + } + updateSubagentInMessages(subagent) { + const { state } = this.deps; + for (let i3 = state.messages.length - 1; i3 >= 0; i3--) { + const msg = state.messages[i3]; + if (msg.role !== "assistant") continue; + if (this.linkTaskToolCallToSubagent(msg, subagent)) { + return; + } + } + } + ensureTaskToolCall(msg, toolId, input) { + msg.toolCalls = msg.toolCalls || []; + const existing = msg.toolCalls.find( + (tc) => tc.id === toolId && isSubagentToolName(tc.name) + ); + if (existing) { + if (input && Object.keys(input).length > 0) { + existing.input = { ...existing.input, ...input }; + } + return existing; + } + const taskToolCall = { + id: toolId, + name: TOOL_TASK, + input: input ? { ...input } : {}, + status: "running", + isExpanded: false + }; + msg.toolCalls.push(taskToolCall); + return taskToolCall; + } + applySubagentToTaskToolCall(taskToolCall, subagent) { + taskToolCall.subagent = subagent; + if (subagent.status === "completed") taskToolCall.status = "completed"; + else if (subagent.status === "error") taskToolCall.status = "error"; + else taskToolCall.status = "running"; + if (subagent.result !== void 0) { + taskToolCall.result = subagent.result; + } + } + linkTaskToolCallToSubagent(msg, subagent) { + var _a3; + const taskToolCall = (_a3 = msg.toolCalls) == null ? void 0 : _a3.find( + (tc) => tc.id === subagent.id && isSubagentToolName(tc.name) + ); + if (!taskToolCall) return false; + this.applySubagentToTaskToolCall(taskToolCall, subagent); + return true; + } + /** + * Schedules showing the thinking indicator after a delay. + * If content arrives before the delay, the indicator won't show. + * This prevents the indicator from appearing during active streaming. + * Note: Flavor text is hidden when model thinking block is active (thinking takes priority). + */ + showThinkingIndicator(overrideText, overrideCls) { + const { state } = this.deps; + if (!state.currentContentEl) return; + if (state.thinkingIndicatorTimeout) { + clearTimeout(state.thinkingIndicatorTimeout); + state.thinkingIndicatorTimeout = null; + } + if (state.currentThinkingState) { + return; + } + if (state.thinkingEl) { + state.currentContentEl.appendChild(state.thinkingEl); + this.deps.updateQueueIndicator(); + return; + } + state.thinkingIndicatorTimeout = setTimeout(() => { + state.thinkingIndicatorTimeout = null; + if (!state.currentContentEl || state.thinkingEl || state.currentThinkingState) return; + const cls = overrideCls ? `claudian-thinking ${overrideCls}` : "claudian-thinking"; + state.thinkingEl = state.currentContentEl.createDiv({ cls }); + const text = overrideText || FLAVOR_TEXTS[Math.floor(Math.random() * FLAVOR_TEXTS.length)]; + state.thinkingEl.createSpan({ text }); + const timerSpan = state.thinkingEl.createSpan({ cls: "claudian-thinking-hint" }); + const updateTimer = () => { + if (!state.responseStartTime) return; + if (!timerSpan.isConnected) { + if (state.flavorTimerInterval) { + clearInterval(state.flavorTimerInterval); + state.flavorTimerInterval = null; + } + return; + } + const elapsedSeconds = Math.floor((performance.now() - state.responseStartTime) / 1e3); + timerSpan.setText(` (esc to interrupt \xB7 ${formatDurationMmSs(elapsedSeconds)})`); + }; + updateTimer(); + if (state.flavorTimerInterval) { + clearInterval(state.flavorTimerInterval); + } + state.flavorTimerInterval = setInterval(updateTimer, 1e3); + }, _StreamController.THINKING_INDICATOR_DELAY); + } + /** Hides the thinking indicator and cancels any pending show timeout. */ + hideThinkingIndicator() { + const { state } = this.deps; + if (state.thinkingIndicatorTimeout) { + clearTimeout(state.thinkingIndicatorTimeout); + state.thinkingIndicatorTimeout = null; + } + state.clearFlavorTimerInterval(); + if (state.thinkingEl) { + state.thinkingEl.remove(); + state.thinkingEl = null; + } + } + // ============================================ + // Compact Boundary + // ============================================ + renderCompactBoundary() { + const { state } = this.deps; + if (!state.currentContentEl) return; + this.hideThinkingIndicator(); + const el2 = state.currentContentEl.createDiv({ cls: "claudian-compact-boundary" }); + el2.createSpan({ cls: "claudian-compact-boundary-label", text: "Conversation compacted" }); + } + // ============================================ + // Utilities + // ============================================ + /** + * Nudges Obsidian's vault after a Write/Edit/NotebookEdit so the file tree + * refreshes. Direct `fs` writes bypass the Vault API, and macOS + iCloud + * FSWatcher often misses the event. + */ + notifyVaultFileChange(input) { + var _a3; + const rawPath = (_a3 = input.file_path) != null ? _a3 : input.notebook_path; + const vaultPath = getVaultPath(this.deps.plugin.app); + const relativePath = normalizePathForVault(rawPath, vaultPath); + if (!relativePath || relativePath.startsWith("/")) return; + setTimeout(() => { + const { vault } = this.deps.plugin.app; + const file2 = vault.getAbstractFileByPath(relativePath); + if (file2 instanceof import_obsidian28.TFile) { + vault.trigger("modify", file2); + } else { + const parentDir = relativePath.includes("/") ? relativePath.substring(0, relativePath.lastIndexOf("/")) : ""; + vault.adapter.list(parentDir).catch(() => { + }); + } + }, 200); + } + /** Refreshes vault for each file path in an apply_patch changes array or patch text. */ + notifyApplyPatchFileChanges(input) { + var _a3; + const notified = /* @__PURE__ */ new Set(); + const changes = input.changes; + if (Array.isArray(changes)) { + for (const change of changes) { + if (change && typeof change === "object" && typeof change.path === "string") { + notified.add(change.path); + this.notifyVaultFileChange({ file_path: change.path }); + } + } + } + const patchText = typeof input.patch === "string" ? input.patch : ""; + if (patchText) { + for (const match of patchText.matchAll(/^\*\*\* (?:Add|Update|Delete) File: (.+)$/gm)) { + const filePath = (_a3 = match[1]) == null ? void 0 : _a3.trim(); + if (filePath && !notified.has(filePath)) { + this.notifyVaultFileChange({ file_path: filePath }); + } + } + } + } + /** Scrolls messages to bottom if auto-scroll is enabled. */ + scrollToBottom() { + var _a3; + const { state, plugin } = this.deps; + if (!((_a3 = plugin.settings.enableAutoScroll) != null ? _a3 : true)) return; + if (!state.autoScrollEnabled) return; + const messagesEl = this.deps.getMessagesEl(); + messagesEl.scrollTop = messagesEl.scrollHeight; + } + resetStreamingState() { + const { state } = this.deps; + this.hideThinkingIndicator(); + state.currentContentEl = null; + state.currentTextEl = null; + state.currentTextContent = ""; + state.currentThinkingState = null; + this.deps.subagentManager.resetStreamingState(); + state.pendingTools.clear(); + state.responseStartTime = null; + } +}; +_StreamController.ASYNC_SUBAGENT_RESULT_RETRY_DELAYS_MS = [200, 600, 1500]; +// ============================================ +// Thinking Indicator +// ============================================ +/** Debounce delay before showing thinking indicator (ms). */ +_StreamController.THINKING_INDICATOR_DELAY = 400; +var StreamController = _StreamController; + +// src/features/chat/rendering/MessageRenderer.ts +var import_obsidian29 = require("obsidian"); + +// src/utils/fileLink.ts +var WIKILINK_PATTERN_SOURCE = "(?= 0 ? inner.slice(0, pipeIndex) : inner; +} +function findWikilinks(app, text) { + const pattern = createWikilinkPattern(); + const matches = []; + let match; + while ((match = pattern.exec(text)) !== null) { + const fullMatch = match[0]; + const linkPath = match[1]; + const linkTarget = extractLinkTarget(fullMatch); + if (!fileExistsInVault(app, linkPath)) continue; + const pipeIndex = fullMatch.lastIndexOf("|"); + const displayText = pipeIndex > 0 ? fullMatch.slice(pipeIndex + 1, -2) : linkPath; + matches.push({ index: match.index, fullMatch, linkPath, linkTarget, displayText }); + } + return matches.sort((a3, b) => b.index - a3.index); +} +function fileExistsInVault(app, linkPath) { + const file2 = app.metadataCache.getFirstLinkpathDest(linkPath, ""); + if (file2) { + return true; + } + const directFile = app.vault.getFileByPath(linkPath); + if (directFile) { + return true; + } + if (!linkPath.endsWith(".md")) { + const withExt = app.vault.getFileByPath(linkPath + ".md"); + if (withExt) { + return true; + } + } + return false; +} +function createWikilink(linkTarget, displayText) { + const link = document.createElement("a"); + link.className = "claudian-file-link internal-link"; + link.textContent = displayText; + link.setAttribute("data-href", linkTarget); + link.setAttribute("href", linkTarget); + return link; +} +function registerFileLinkHandler(app, container, component) { + component.registerDomEvent(container, "click", (event) => { + const target = event.target; + const link = target.closest(".claudian-file-link, .internal-link"); + if (link) { + event.preventDefault(); + const linkTarget = link.dataset.href || link.getAttribute("href"); + if (linkTarget) { + void app.workspace.openLinkText(linkTarget, "", "tab"); + } + } + }); +} +function buildFragmentWithLinks(text, matches) { + const fragment = document.createDocumentFragment(); + let currentIndex = text.length; + for (const { index, fullMatch, linkTarget, displayText } of matches) { + const endIndex = index + fullMatch.length; + if (endIndex < currentIndex) { + fragment.insertBefore( + document.createTextNode(text.slice(endIndex, currentIndex)), + fragment.firstChild + ); + } + fragment.insertBefore(createWikilink(linkTarget, displayText), fragment.firstChild); + currentIndex = index; + } + if (currentIndex > 0) { + fragment.insertBefore( + document.createTextNode(text.slice(0, currentIndex)), + fragment.firstChild + ); + } + return fragment; +} +function processTextNode(app, node) { + var _a3; + const text = node.textContent; + if (!text || !text.includes("[[")) return false; + const matches = findWikilinks(app, text); + if (matches.length === 0) return false; + (_a3 = node.parentNode) == null ? void 0 : _a3.replaceChild(buildFragmentWithLinks(text, matches), node); + return true; +} +function processFileLinks(app, container) { + if (!app || !container) return; + container.querySelectorAll("code").forEach((codeEl) => { + var _a3; + if (((_a3 = codeEl.parentElement) == null ? void 0 : _a3.tagName) === "PRE") return; + const text = codeEl.textContent; + if (!text || !text.includes("[[")) return; + const matches = findWikilinks(app, text); + if (matches.length === 0) return; + codeEl.textContent = ""; + codeEl.appendChild(buildFragmentWithLinks(text, matches)); + }); + const walker = document.createTreeWalker( + container, + NodeFilter.SHOW_TEXT, + { + acceptNode(node2) { + const parent = node2.parentElement; + if (!parent) return NodeFilter.FILTER_REJECT; + const tagName = parent.tagName.toUpperCase(); + if (tagName === "PRE" || tagName === "CODE" || tagName === "A") { + return NodeFilter.FILTER_REJECT; + } + if (parent.closest("pre, code, a, .claudian-file-link, .internal-link")) { + return NodeFilter.FILTER_REJECT; + } + return NodeFilter.FILTER_ACCEPT; + } + } + ); + const textNodes = []; + let node; + while (node = walker.nextNode()) { + textNodes.push(node); + } + for (const textNode of textNodes) { + processTextNode(app, textNode); + } +} + +// src/utils/inlineEdit.ts +function normalizeInsertionText(text) { + return text.replace(/^(?:\r?\n)+|(?:\r?\n)+$/g, ""); +} +function escapeHtml(text) { + return text.replace(/&/g, "&").replace(//g, ">").replace(/"/g, """); +} + +// src/utils/imageEmbed.ts +var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([ + "png", + "jpg", + "jpeg", + "gif", + "webp", + "svg", + "bmp", + "ico" +]); +var IMAGE_EMBED_PATTERN = /!\[\[([^\]|]+)(?:\|([^\]]+))?\]\]/g; +function isImagePath(path19) { + var _a3; + const ext = (_a3 = path19.split(".").pop()) == null ? void 0 : _a3.toLowerCase(); + return ext ? IMAGE_EXTENSIONS.has(ext) : false; +} +function resolveImageFile(app, imagePath, mediaFolder) { + let file2 = app.vault.getFileByPath(imagePath); + if (file2) return file2; + if (mediaFolder) { + const withFolder = `${mediaFolder}/${imagePath}`; + file2 = app.vault.getFileByPath(withFolder); + if (file2) return file2; + } + const resolved = app.metadataCache.getFirstLinkpathDest(imagePath, ""); + if (resolved) return resolved; + return null; +} +function buildStyleAttribute(altText) { + if (!altText) return ""; + const dimMatch = altText.match(/^(\d+)(?:x(\d+))?$/); + if (!dimMatch) return ""; + const width = dimMatch[1]; + const height = dimMatch[2]; + if (height) { + return ` style="width: ${width}px; height: ${height}px;"`; + } + return ` style="width: ${width}px;"`; +} +function createImageHtml(app, file2, altText) { + const src = app.vault.getResourcePath(file2); + const alt = escapeHtml(altText || file2.basename); + const style = buildStyleAttribute(altText); + return `${alt}`; +} +function createFallbackHtml(wikilink) { + return `${escapeHtml(wikilink)}`; +} +function replaceImageEmbedsWithHtml(markdown, app, mediaFolder = "") { + if (!(app == null ? void 0 : app.vault) || !(app == null ? void 0 : app.metadataCache)) { + return markdown; + } + IMAGE_EMBED_PATTERN.lastIndex = 0; + return markdown.replace( + IMAGE_EMBED_PATTERN, + (match, imagePath, altText) => { + try { + if (!isImagePath(imagePath)) { + return match; + } + const file2 = resolveImageFile(app, imagePath, mediaFolder); + if (!file2) { + return createFallbackHtml(match); + } + return createImageHtml(app, file2, altText); + } catch (e3) { + return createFallbackHtml(match); + } + } + ); +} + +// src/features/chat/rendering/MessageRenderer.ts +var _MessageRenderer = class _MessageRenderer { + constructor(plugin, component, messagesEl, rewindCallback, forkCallback, getCapabilities) { + this.liveMessageEls = /* @__PURE__ */ new Map(); + this.app = plugin.app; + this.plugin = plugin; + this.component = component; + this.messagesEl = messagesEl; + this.rewindCallback = rewindCallback; + this.forkCallback = forkCallback; + this.getCapabilities = getCapabilities != null ? getCapabilities : (() => ({ + providerId: DEFAULT_CHAT_PROVIDER_ID, + supportsPersistentRuntime: false, + supportsNativeHistory: false, + supportsPlanMode: false, + supportsRewind: false, + supportsFork: false, + supportsProviderCommands: false, + supportsImageAttachments: false, + supportsInstructionMode: false, + supportsMcpTools: false, + supportsTurnSteer: false, + reasoningControl: "none" + })); + registerFileLinkHandler(this.app, this.messagesEl, this.component); + } + /** Sets the messages container element. */ + setMessagesEl(el2) { + this.messagesEl = el2; + } + getSubagentLifecycleAdapter(toolName) { + return resolveSubagentLifecycleAdapter(this.getCapabilities().providerId, toolName); + } + // ============================================ + // Streaming Message Rendering + // ============================================ + /** + * Adds a new message to the chat during streaming. + * Returns the message element for content updates. + */ + addMessage(msg) { + var _a3, _b2; + if (msg.role === "user" && msg.images && msg.images.length > 0) { + this.renderMessageImages(this.messagesEl, msg.images); + } + if (msg.role === "user") { + const textToShow = (_a3 = msg.displayContent) != null ? _a3 : msg.content; + if (!textToShow) { + this.scrollToBottom(); + const lastChild = this.messagesEl.lastElementChild; + return lastChild != null ? lastChild : this.messagesEl; + } + } + const msgEl = this.messagesEl.createDiv({ + cls: `claudian-message claudian-message-${msg.role}`, + attr: { + "data-message-id": msg.id, + "data-role": msg.role + } + }); + const contentEl = msgEl.createDiv({ cls: "claudian-message-content", attr: { dir: "auto" } }); + if (msg.role === "user") { + const textToShow = (_b2 = msg.displayContent) != null ? _b2 : msg.content; + if (textToShow) { + const textEl = contentEl.createDiv({ cls: "claudian-text-block" }); + void this.renderContent(textEl, textToShow); + this.addUserCopyButton(msgEl, textToShow); + } + if (this.rewindCallback || this.forkCallback) { + this.liveMessageEls.set(msg.id, msgEl); + } + } + this.scrollToBottom(); + return msgEl; + } + updateLiveUserMessage(msg) { + var _a3, _b2; + if (msg.role !== "user") { + return; + } + const msgEl = (_a3 = this.liveMessageEls.get(msg.id)) != null ? _a3 : this.messagesEl.querySelector(`[data-message-id="${msg.id}"]`); + if (!msgEl) { + return; + } + const contentEl = msgEl.querySelector(".claudian-message-content"); + if (!contentEl) { + return; + } + contentEl.empty(); + const textToShow = (_b2 = msg.displayContent) != null ? _b2 : msg.content; + if (textToShow) { + const textEl = contentEl.createDiv({ cls: "claudian-text-block" }); + void this.renderContent(textEl, textToShow); + } + const toolbar = msgEl.querySelector(".claudian-user-msg-actions"); + if (toolbar) { + toolbar.querySelectorAll(".claudian-user-msg-copy-btn").forEach((el2) => el2.remove()); + } + if (textToShow) { + this.addUserCopyButton(msgEl, textToShow); + } + } + removeMessage(messageId) { + var _a3; + const msgEl = (_a3 = this.liveMessageEls.get(messageId)) != null ? _a3 : this.messagesEl.querySelector(`[data-message-id="${messageId}"]`); + if (!msgEl) { + return; + } + msgEl.remove(); + this.liveMessageEls.delete(messageId); + } + // ============================================ + // Stored Message Rendering (Batch/Replay) + // ============================================ + /** + * Renders all messages for conversation load/switch. + * @param messages Array of messages to render + * @param getGreeting Function to get greeting text + * @returns The newly created welcome element + */ + renderMessages(messages, getGreeting) { + this.messagesEl.empty(); + this.liveMessageEls.clear(); + const newWelcomeEl = this.messagesEl.createDiv({ cls: "claudian-welcome" }); + newWelcomeEl.createDiv({ cls: "claudian-welcome-greeting", text: getGreeting() }); + for (let i3 = 0; i3 < messages.length; i3++) { + this.renderStoredMessage(messages[i3], messages, i3); + } + this.scrollToBottom(); + return newWelcomeEl; + } + renderStoredMessage(msg, allMessages, index) { + var _a3, _b2; + if (msg.isInterrupt && (msg.role === "user" || !this.hasVisibleContent(msg))) { + this.renderInterruptMessage(); + return; + } + if (msg.isRebuiltContext) { + return; + } + if (msg.role === "user" && msg.images && msg.images.length > 0) { + this.renderMessageImages(this.messagesEl, msg.images); + } + if (msg.role === "user") { + const textToShow = (_a3 = msg.displayContent) != null ? _a3 : msg.content; + if (!textToShow) { + return; + } + } + const msgEl = this.messagesEl.createDiv({ + cls: `claudian-message claudian-message-${msg.role}`, + attr: { + "data-message-id": msg.id, + "data-role": msg.role + } + }); + const contentEl = msgEl.createDiv({ cls: "claudian-message-content", attr: { dir: "auto" } }); + if (msg.role === "user") { + const textToShow = (_b2 = msg.displayContent) != null ? _b2 : msg.content; + if (textToShow) { + const textEl = contentEl.createDiv({ cls: "claudian-text-block" }); + void this.renderContent(textEl, textToShow); + this.addUserCopyButton(msgEl, textToShow); + } + if (msg.userMessageId && this.isRewindEligible(allMessages, index)) { + if (this.rewindCallback) { + this.addRewindButton(msgEl, msg.id); + } + if (this.forkCallback) { + this.addForkButton(msgEl, msg.id); + } + } + } else if (msg.role === "assistant") { + this.renderAssistantContent(msg, contentEl); + if (msg.isInterrupt) { + this.appendInterruptIndicator(contentEl); + } + } + } + hasVisibleContent(msg) { + if (msg.content && msg.content.trim().length > 0) return true; + if (msg.toolCalls && msg.toolCalls.length > 0) return true; + if (msg.contentBlocks && msg.contentBlocks.length > 0) return true; + return false; + } + isRewindEligible(allMessages, index) { + if (!allMessages || index === void 0) return false; + const ctx = findRewindContext(allMessages, index); + return !!ctx.prevAssistantUuid && ctx.hasResponse; + } + renderInterruptMessage() { + const msgEl = this.messagesEl.createDiv({ cls: "claudian-message claudian-message-assistant" }); + const contentEl = msgEl.createDiv({ cls: "claudian-message-content", attr: { dir: "auto" } }); + this.appendInterruptIndicator(contentEl); + } + appendInterruptIndicator(contentEl) { + const textEl = contentEl.createDiv({ cls: "claudian-text-block" }); + textEl.innerHTML = 'Interrupted \xB7 What should Claudian do instead?'; + } + /** + * Renders assistant message content (content blocks or fallback). + */ + renderAssistantContent(msg, contentEl) { + var _a3, _b2, _c; + if (msg.contentBlocks && msg.contentBlocks.length > 0) { + const renderedToolIds = /* @__PURE__ */ new Set(); + for (const block of msg.contentBlocks) { + if (block.type === "thinking") { + renderStoredThinkingBlock( + contentEl, + block.content, + block.durationSeconds, + (el2, md) => this.renderContent(el2, md) + ); + } else if (block.type === "text") { + if (!block.content || !block.content.trim()) { + continue; + } + const textEl = contentEl.createDiv({ cls: "claudian-text-block" }); + void this.renderContent(textEl, block.content); + this.addTextCopyButton(textEl, block.content); + } else if (block.type === "tool_use") { + const toolCall = (_a3 = msg.toolCalls) == null ? void 0 : _a3.find((tc) => tc.id === block.toolId); + if (toolCall) { + this.renderToolCall(contentEl, toolCall, msg); + renderedToolIds.add(toolCall.id); + } + } else if (block.type === "context_compacted") { + const boundaryEl = contentEl.createDiv({ cls: "claudian-compact-boundary" }); + boundaryEl.createSpan({ cls: "claudian-compact-boundary-label", text: "Conversation compacted" }); + } else if (block.type === "subagent") { + const taskToolCall = (_b2 = msg.toolCalls) == null ? void 0 : _b2.find( + (tc) => tc.id === block.subagentId && isSubagentToolName(tc.name) + ); + if (!taskToolCall) continue; + this.renderTaskSubagent(contentEl, taskToolCall, block.mode); + renderedToolIds.add(taskToolCall.id); + } + } + if (msg.toolCalls && msg.toolCalls.length > 0) { + for (const toolCall of msg.toolCalls) { + if (renderedToolIds.has(toolCall.id)) continue; + this.renderToolCall(contentEl, toolCall, msg); + renderedToolIds.add(toolCall.id); + } + } + } else { + if (msg.content) { + const textEl = contentEl.createDiv({ cls: "claudian-text-block" }); + void this.renderContent(textEl, msg.content); + this.addTextCopyButton(textEl, msg.content); + } + if (msg.toolCalls) { + for (const toolCall of msg.toolCalls) { + this.renderToolCall(contentEl, toolCall, msg); + } + } + } + const hasCompactBoundary = (_c = msg.contentBlocks) == null ? void 0 : _c.some((b) => b.type === "context_compacted"); + if (msg.durationSeconds && msg.durationSeconds > 0 && !hasCompactBoundary) { + const flavorWord = msg.durationFlavorWord || "Baked"; + const footerEl = contentEl.createDiv({ cls: "claudian-response-footer" }); + footerEl.createSpan({ + text: `* ${flavorWord} for ${formatDurationMmSs(msg.durationSeconds)}`, + cls: "claudian-baked-duration" + }); + } + } + /** + * Renders a tool call with special handling for Write/Edit, Agent (subagent), + * and Codex collab agent lifecycle tools. + */ + renderToolCall(contentEl, toolCall, msg) { + const subagentLifecycleAdapter = this.getSubagentLifecycleAdapter(toolCall.name); + if (toolCall.name === TOOL_AGENT_OUTPUT) return; + if (subagentLifecycleAdapter == null ? void 0 : subagentLifecycleAdapter.isHiddenTool(toolCall.name)) return; + if (isWriteEditTool(toolCall.name)) { + renderStoredWriteEdit(contentEl, toolCall); + } else if (isSubagentToolName(toolCall.name)) { + this.renderTaskSubagent(contentEl, toolCall); + } else if ((subagentLifecycleAdapter == null ? void 0 : subagentLifecycleAdapter.isSpawnTool(toolCall.name)) && msg) { + this.renderProviderLifecycleSubagent(contentEl, toolCall, msg); + } else { + renderStoredToolCall(contentEl, toolCall); + } + } + renderTaskSubagent(contentEl, toolCall, modeHint) { + const subagentInfo = this.resolveTaskSubagent(toolCall, modeHint); + if (subagentInfo.mode === "async") { + renderStoredAsyncSubagent(contentEl, subagentInfo); + return; + } + renderStoredSubagent(contentEl, subagentInfo); + } + /** + * Consolidates provider lifecycle tools (spawn + wait/close) + * into a single subagent block with prompt and result. + */ + renderProviderLifecycleSubagent(contentEl, spawnToolCall, msg) { + var _a3; + const subagentLifecycleAdapter = this.getSubagentLifecycleAdapter(spawnToolCall.name); + if (!subagentLifecycleAdapter) { + renderStoredToolCall(contentEl, spawnToolCall); + return; + } + const subagentInfo = subagentLifecycleAdapter.buildSubagentInfo( + spawnToolCall, + (_a3 = msg.toolCalls) != null ? _a3 : [] + ); + renderStoredSubagent(contentEl, subagentInfo); + } + resolveTaskSubagent(toolCall, modeHint) { + var _a3, _b2, _c; + if (toolCall.subagent) { + if (!modeHint || toolCall.subagent.mode === modeHint) { + return toolCall.subagent; + } + return { + ...toolCall.subagent, + mode: modeHint + }; + } + const description = ((_a3 = toolCall.input) == null ? void 0 : _a3.description) || "Subagent task"; + const prompt = ((_b2 = toolCall.input) == null ? void 0 : _b2.prompt) || ""; + const mode = modeHint != null ? modeHint : ((_c = toolCall.input) == null ? void 0 : _c.run_in_background) === true ? "async" : "sync"; + if (mode !== "async") { + return { + id: toolCall.id, + description, + prompt, + status: this.mapToolStatusToSubagentStatus(toolCall.status), + toolCalls: [], + isExpanded: false, + result: toolCall.result + }; + } + const asyncStatus = this.inferAsyncStatusFromTaskTool(toolCall); + return { + id: toolCall.id, + description, + prompt, + mode: "async", + status: asyncStatus, + asyncStatus, + toolCalls: [], + isExpanded: false, + result: toolCall.result + }; + } + mapToolStatusToSubagentStatus(status) { + switch (status) { + case "completed": + return "completed"; + case "error": + case "blocked": + return "error"; + default: + return "running"; + } + } + inferAsyncStatusFromTaskTool(toolCall) { + if (toolCall.status === "error" || toolCall.status === "blocked") return "error"; + if (toolCall.status === "running") return "running"; + const lowerResult = (toolCall.result || "").toLowerCase(); + if (lowerResult.includes("not_ready") || lowerResult.includes("not ready") || lowerResult.includes('"status":"running"') || lowerResult.includes('"status":"pending"') || lowerResult.includes('"retrieval_status":"running"') || lowerResult.includes('"retrieval_status":"not_ready"')) { + return "running"; + } + return "completed"; + } + // ============================================ + // Image Rendering + // ============================================ + /** + * Renders image attachments above a message. + */ + renderMessageImages(containerEl, images) { + const imagesEl = containerEl.createDiv({ cls: "claudian-message-images" }); + for (const image of images) { + const imageWrapper = imagesEl.createDiv({ cls: "claudian-message-image" }); + const imgEl = imageWrapper.createEl("img", { + attr: { + alt: image.name + } + }); + void this.setImageSrc(imgEl, image); + imgEl.addEventListener("click", () => { + void this.showFullImage(image); + }); + } + } + /** + * Shows full-size image in modal overlay. + */ + showFullImage(image) { + const dataUri = `data:${image.mediaType};base64,${image.data}`; + const overlay = document.body.createDiv({ cls: "claudian-image-modal-overlay" }); + const modal = overlay.createDiv({ cls: "claudian-image-modal" }); + modal.createEl("img", { + attr: { + src: dataUri, + alt: image.name + } + }); + const closeBtn = modal.createDiv({ cls: "claudian-image-modal-close" }); + closeBtn.setText("\xD7"); + const handleEsc = (e3) => { + if (e3.key === "Escape") { + close(); + } + }; + const close = () => { + document.removeEventListener("keydown", handleEsc); + overlay.remove(); + }; + closeBtn.addEventListener("click", close); + overlay.addEventListener("click", (e3) => { + if (e3.target === overlay) close(); + }); + document.addEventListener("keydown", handleEsc); + } + /** + * Sets image src from attachment data. + */ + setImageSrc(imgEl, image) { + const dataUri = `data:${image.mediaType};base64,${image.data}`; + imgEl.setAttribute("src", dataUri); + } + // ============================================ + // Content Rendering + // ============================================ + /** + * Renders markdown content with code block enhancements. + */ + async renderContent(el2, markdown) { + el2.empty(); + try { + const processedMarkdown = replaceImageEmbedsWithHtml( + markdown, + this.app, + this.plugin.settings.mediaFolder + ); + await import_obsidian29.MarkdownRenderer.renderMarkdown(processedMarkdown, el2, "", this.component); + el2.querySelectorAll("pre").forEach((pre) => { + var _a3, _b2; + if ((_a3 = pre.parentElement) == null ? void 0 : _a3.classList.contains("claudian-code-wrapper")) return; + const wrapper = createEl("div", { cls: "claudian-code-wrapper" }); + (_b2 = pre.parentElement) == null ? void 0 : _b2.insertBefore(wrapper, pre); + wrapper.appendChild(pre); + const code = pre.querySelector('code[class*="language-"]'); + if (code) { + const match = code.className.match(/language-(\w+)/); + if (match) { + wrapper.classList.add("has-language"); + const label = createEl("span", { + cls: "claudian-code-lang-label", + text: match[1] + }); + wrapper.appendChild(label); + label.addEventListener("click", async () => { + try { + await navigator.clipboard.writeText(code.textContent || ""); + label.setText("copied!"); + setTimeout(() => label.setText(match[1]), 1500); + } catch (e3) { + } + }); + } + } + const copyBtn = pre.querySelector(".copy-code-button"); + if (copyBtn) { + wrapper.appendChild(copyBtn); + } + }); + processFileLinks(this.app, el2); + } catch (e3) { + el2.createDiv({ + cls: "claudian-render-error", + text: "Failed to render message content." + }); + } + } + /** + * Adds a copy button to a text block. + * Button shows clipboard icon on hover, changes to "copied!" on click. + * @param textEl The rendered text element + * @param markdown The original markdown content to copy + */ + addTextCopyButton(textEl, markdown) { + const copyBtn = textEl.createSpan({ cls: "claudian-text-copy-btn" }); + copyBtn.innerHTML = _MessageRenderer.COPY_ICON; + let feedbackTimeout = null; + copyBtn.addEventListener("click", async (e3) => { + e3.stopPropagation(); + try { + await navigator.clipboard.writeText(markdown); + } catch (e4) { + return; + } + if (feedbackTimeout) { + clearTimeout(feedbackTimeout); + } + copyBtn.innerHTML = ""; + copyBtn.setText("copied!"); + copyBtn.classList.add("copied"); + feedbackTimeout = setTimeout(() => { + copyBtn.innerHTML = _MessageRenderer.COPY_ICON; + copyBtn.classList.remove("copied"); + feedbackTimeout = null; + }, 1500); + }); + } + refreshActionButtons(msg, allMessages, index) { + if (!msg.userMessageId) return; + if (!this.isRewindEligible(allMessages, index)) return; + const msgEl = this.liveMessageEls.get(msg.id); + if (!msgEl) return; + if (this.rewindCallback && !msgEl.querySelector(".claudian-message-rewind-btn")) { + this.addRewindButton(msgEl, msg.id); + } + if (this.forkCallback && !msgEl.querySelector(".claudian-message-fork-btn")) { + this.addForkButton(msgEl, msg.id); + } + this.cleanupLiveMessageEl(msg.id, msgEl); + } + cleanupLiveMessageEl(msgId, msgEl) { + const needsRewind = this.rewindCallback && !msgEl.querySelector(".claudian-message-rewind-btn"); + const needsFork = this.forkCallback && !msgEl.querySelector(".claudian-message-fork-btn"); + if (!needsRewind && !needsFork) { + this.liveMessageEls.delete(msgId); + } + } + getOrCreateActionsToolbar(msgEl) { + const existing = msgEl.querySelector(".claudian-user-msg-actions"); + if (existing) return existing; + return msgEl.createDiv({ cls: "claudian-user-msg-actions" }); + } + addUserCopyButton(msgEl, content) { + const toolbar = this.getOrCreateActionsToolbar(msgEl); + const copyBtn = toolbar.createSpan({ cls: "claudian-user-msg-copy-btn" }); + copyBtn.innerHTML = _MessageRenderer.COPY_ICON; + copyBtn.setAttribute("aria-label", "Copy message"); + let feedbackTimeout = null; + copyBtn.addEventListener("click", async (e3) => { + e3.stopPropagation(); + try { + await navigator.clipboard.writeText(content); + } catch (e4) { + return; + } + if (feedbackTimeout) clearTimeout(feedbackTimeout); + copyBtn.innerHTML = ""; + copyBtn.setText("copied!"); + copyBtn.classList.add("copied"); + feedbackTimeout = setTimeout(() => { + copyBtn.innerHTML = _MessageRenderer.COPY_ICON; + copyBtn.classList.remove("copied"); + feedbackTimeout = null; + }, 1500); + }); + } + addRewindButton(msgEl, messageId) { + if (!this.getCapabilities().supportsRewind) return; + const toolbar = this.getOrCreateActionsToolbar(msgEl); + const btn = toolbar.createSpan({ cls: "claudian-message-rewind-btn" }); + if (toolbar.firstChild !== btn) toolbar.insertBefore(btn, toolbar.firstChild); + btn.innerHTML = _MessageRenderer.REWIND_ICON; + btn.setAttribute("aria-label", t("chat.rewind.ariaLabel")); + btn.addEventListener("click", async (e3) => { + var _a3; + e3.stopPropagation(); + try { + await ((_a3 = this.rewindCallback) == null ? void 0 : _a3.call(this, messageId)); + } catch (err) { + new import_obsidian29.Notice(t("chat.rewind.failed", { error: err instanceof Error ? err.message : "Unknown error" })); + } + }); + } + addForkButton(msgEl, messageId) { + if (!this.getCapabilities().supportsFork) return; + const toolbar = this.getOrCreateActionsToolbar(msgEl); + const btn = toolbar.createSpan({ cls: "claudian-message-fork-btn" }); + if (toolbar.firstChild !== btn) toolbar.insertBefore(btn, toolbar.firstChild); + btn.innerHTML = _MessageRenderer.FORK_ICON; + btn.setAttribute("aria-label", t("chat.fork.ariaLabel")); + btn.addEventListener("click", async (e3) => { + var _a3; + e3.stopPropagation(); + try { + await ((_a3 = this.forkCallback) == null ? void 0 : _a3.call(this, messageId)); + } catch (err) { + new import_obsidian29.Notice(t("chat.fork.failed", { error: err instanceof Error ? err.message : "Unknown error" })); + } + }); + } + // ============================================ + // Utilities + // ============================================ + /** Scrolls messages container to bottom. */ + scrollToBottom() { + this.messagesEl.scrollTop = this.messagesEl.scrollHeight; + } + /** Scrolls to bottom if already near bottom (within threshold). */ + scrollToBottomIfNeeded(threshold = 100) { + const { scrollTop, scrollHeight, clientHeight } = this.messagesEl; + const isNearBottom = scrollHeight - scrollTop - clientHeight < threshold; + if (isNearBottom) { + requestAnimationFrame(() => { + this.messagesEl.scrollTop = this.messagesEl.scrollHeight; + }); + } + } +}; +_MessageRenderer.REWIND_ICON = ``; +_MessageRenderer.FORK_ICON = ``; +// ============================================ +// Copy Button +// ============================================ +/** Clipboard icon SVG for copy button. */ +_MessageRenderer.COPY_ICON = ``; +var MessageRenderer = _MessageRenderer; + +// src/features/chat/services/BangBashService.ts +var import_child_process6 = require("child_process"); +var TIMEOUT_MS = 3e4; +var MAX_BUFFER = 1024 * 1024; +var BangBashService = class { + constructor(cwd, enhancedPath) { + this.cwd = cwd; + this.enhancedPath = enhancedPath; + } + execute(command) { + return new Promise((resolve5) => { + (0, import_child_process6.exec)(command, { + cwd: this.cwd, + env: { ...process.env, PATH: this.enhancedPath }, + timeout: TIMEOUT_MS, + maxBuffer: MAX_BUFFER, + shell: process.platform === "win32" ? "cmd.exe" : "/bin/bash" + }, (error48, stdout, stderr) => { + if (error48 && "killed" in error48 && error48.killed) { + const isMaxBuffer = "code" in error48 && error48.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER"; + resolve5({ + command, + stdout: stdout != null ? stdout : "", + stderr: stderr != null ? stderr : "", + exitCode: 124, + error: isMaxBuffer ? "Output exceeded maximum buffer size (1MB)" : `Command timed out after ${TIMEOUT_MS / 1e3}s` + }); + return; + } + resolve5({ + command, + stdout: stdout != null ? stdout : "", + stderr: stderr != null ? stderr : "", + exitCode: typeof (error48 == null ? void 0 : error48.code) === "number" ? error48.code : error48 ? 1 : 0 + }); + }); + }); + } +}; + +// src/features/chat/services/SubagentManager.ts +var import_fs5 = require("fs"); +var import_os2 = require("os"); +var import_path23 = require("path"); +var _SubagentManager = class _SubagentManager { + constructor(onStateChange, taskResultInterpreter = ProviderRegistry.getTaskResultInterpreter()) { + this.syncSubagents = /* @__PURE__ */ new Map(); + this.pendingTasks = /* @__PURE__ */ new Map(); + this._spawnedThisStream = 0; + this.activeAsyncSubagents = /* @__PURE__ */ new Map(); + this.pendingAsyncSubagents = /* @__PURE__ */ new Map(); + this.taskIdToAgentId = /* @__PURE__ */ new Map(); + this.outputToolIdToAgentId = /* @__PURE__ */ new Map(); + this.asyncDomStates = /* @__PURE__ */ new Map(); + this.onStateChange = onStateChange; + this.taskResultInterpreter = taskResultInterpreter; + } + setCallback(callback) { + this.onStateChange = callback; + } + setTaskResultInterpreter(interpreter) { + this.taskResultInterpreter = interpreter; + } + // ============================================ + // Unified Subagent Entry Point + // ============================================ + /** + * Handles an Agent tool_use chunk with minimal buffering to determine sync vs async. + * Returns a typed result so StreamController can update messages accordingly. + */ + handleTaskToolUse(taskToolId, taskInput, currentContentEl) { + const existingSyncState = this.syncSubagents.get(taskToolId); + if (existingSyncState) { + this.updateSubagentLabel(existingSyncState.wrapperEl, existingSyncState.info, taskInput); + return { action: "label_updated" }; + } + const existingAsyncState = this.asyncDomStates.get(taskToolId); + if (existingAsyncState) { + this.updateSubagentLabel(existingAsyncState.wrapperEl, existingAsyncState.info, taskInput); + const canonical = this.getByTaskId(taskToolId); + if (canonical && canonical !== existingAsyncState.info) { + if (taskInput.description) canonical.description = taskInput.description; + if (taskInput.prompt) canonical.prompt = taskInput.prompt; + } + return { action: "label_updated" }; + } + const pending = this.pendingTasks.get(taskToolId); + if (pending) { + const newInput = taskInput || {}; + if (Object.keys(newInput).length > 0) { + pending.toolCall.input = { ...pending.toolCall.input, ...newInput }; + } + if (currentContentEl) { + pending.parentEl = currentContentEl; + } + if (this.resolveTaskMode(pending.toolCall.input)) { + const result = this.renderPendingTask(taskToolId, currentContentEl); + if (result) { + return result.mode === "sync" ? { action: "created_sync", subagentState: result.subagentState } : { action: "created_async", info: result.info, domState: result.domState }; + } + } + return { action: "buffered" }; + } + if (!currentContentEl) { + const toolCall = { + id: taskToolId, + name: TOOL_TASK, + input: taskInput || {}, + status: "running", + isExpanded: false + }; + this.pendingTasks.set(taskToolId, { toolCall, parentEl: null }); + return { action: "buffered" }; + } + const mode = this.resolveTaskMode(taskInput); + if (!mode) { + const toolCall = { + id: taskToolId, + name: TOOL_TASK, + input: taskInput || {}, + status: "running", + isExpanded: false + }; + this.pendingTasks.set(taskToolId, { toolCall, parentEl: currentContentEl }); + return { action: "buffered" }; + } + this._spawnedThisStream++; + if (mode === "async") { + return this.createAsyncTask(taskToolId, taskInput, currentContentEl); + } + return this.createSyncTask(taskToolId, taskInput, currentContentEl); + } + // ============================================ + // Pending Task Resolution + // ============================================ + hasPendingTask(toolId) { + return this.pendingTasks.has(toolId); + } + /** + * Renders a buffered pending task. Called when a child chunk or tool_result + * confirms the task is sync, or when run_in_background becomes known. + * Uses the optional parentEl override, falling back to the stored parentEl. + */ + renderPendingTask(toolId, parentElOverride) { + const pending = this.pendingTasks.get(toolId); + if (!pending) return null; + const input = pending.toolCall.input; + const targetEl = parentElOverride != null ? parentElOverride : pending.parentEl; + if (!targetEl) return null; + this.pendingTasks.delete(toolId); + try { + if (input.run_in_background === true) { + const result = this.createAsyncTask(pending.toolCall.id, input, targetEl); + if (result.action === "created_async") { + this._spawnedThisStream++; + return { mode: "async", info: result.info, domState: result.domState }; + } + } else { + const result = this.createSyncTask(pending.toolCall.id, input, targetEl); + if (result.action === "created_sync") { + this._spawnedThisStream++; + return { mode: "sync", subagentState: result.subagentState }; + } + } + } catch (e3) { + } + return null; + } + /** + * Resolves a pending Task when its own tool_result arrives. + * If mode is still unknown, infer async from task result shape (agent_id/agentId), + * otherwise fall back to sync so it never remains pending indefinitely. + */ + renderPendingTaskFromTaskResult(toolId, taskResult, isError, parentElOverride, taskToolUseResult) { + const pending = this.pendingTasks.get(toolId); + if (!pending) return null; + const input = pending.toolCall.input; + const targetEl = parentElOverride != null ? parentElOverride : pending.parentEl; + if (!targetEl) return null; + const explicitMode = this.resolveTaskMode(input); + const inferredMode = explicitMode != null ? explicitMode : this.inferModeFromTaskResult(taskResult, isError, taskToolUseResult); + this.pendingTasks.delete(toolId); + try { + if (inferredMode === "async") { + const result = this.createAsyncTask(pending.toolCall.id, input, targetEl); + if (result.action === "created_async") { + this._spawnedThisStream++; + return { mode: "async", info: result.info, domState: result.domState }; + } + } else { + const result = this.createSyncTask(pending.toolCall.id, input, targetEl); + if (result.action === "created_sync") { + this._spawnedThisStream++; + return { mode: "sync", subagentState: result.subagentState }; + } + } + } catch (e3) { + } + return null; + } + // ============================================ + // Sync Subagent Operations + // ============================================ + getSyncSubagent(toolId) { + return this.syncSubagents.get(toolId); + } + addSyncToolCall(parentToolUseId, toolCall) { + const subagentState = this.syncSubagents.get(parentToolUseId); + if (!subagentState) return; + addSubagentToolCall(subagentState, toolCall); + } + updateSyncToolResult(parentToolUseId, toolId, toolCall) { + const subagentState = this.syncSubagents.get(parentToolUseId); + if (!subagentState) return; + updateSubagentToolResult(subagentState, toolId, toolCall); + } + finalizeSyncSubagent(toolId, result, isError, toolUseResult) { + const subagentState = this.syncSubagents.get(toolId); + if (!subagentState) return null; + const extractedResult = this.extractAgentResult(result, "", toolUseResult); + finalizeSubagentBlock(subagentState, extractedResult, isError); + this.syncSubagents.delete(toolId); + return subagentState.info; + } + // ============================================ + // Async Subagent Lifecycle + // ============================================ + handleTaskToolResult(taskToolId, result, isError, toolUseResult) { + var _a3; + const subagent = this.pendingAsyncSubagents.get(taskToolId); + if (!subagent) return; + if (isError) { + this.transitionToError(subagent, taskToolId, result || "Task failed to start"); + return; + } + const agentId = (_a3 = this.taskResultInterpreter.extractAgentId(toolUseResult)) != null ? _a3 : this.parseAgentId(result); + if (!agentId) { + const truncatedResult = result.length > 100 ? result.substring(0, 100) + "..." : result; + this.transitionToError(subagent, taskToolId, `Failed to parse agent_id. Result: ${truncatedResult}`); + return; + } + subagent.asyncStatus = "running"; + subagent.agentId = agentId; + subagent.startedAt = Date.now(); + this.pendingAsyncSubagents.delete(taskToolId); + this.activeAsyncSubagents.set(agentId, subagent); + this.taskIdToAgentId.set(taskToolId, agentId); + this.updateAsyncDomState(subagent); + this.onStateChange(subagent); + } + handleAgentOutputToolUse(toolCall) { + const agentId = this.extractAgentIdFromInput(toolCall.input); + if (!agentId) return; + const subagent = this.activeAsyncSubagents.get(agentId); + if (!subagent) return; + subagent.outputToolId = toolCall.id; + this.outputToolIdToAgentId.set(toolCall.id, agentId); + } + handleAgentOutputToolResult(toolId, result, isError, toolUseResult) { + let agentId = this.outputToolIdToAgentId.get(toolId); + let subagent = agentId ? this.activeAsyncSubagents.get(agentId) : void 0; + if (!subagent) { + const inferredAgentId = this.inferAgentIdFromResult(result); + if (inferredAgentId) { + agentId = inferredAgentId; + subagent = this.activeAsyncSubagents.get(inferredAgentId); + } + } + if (!subagent) return void 0; + if (agentId) { + subagent.agentId = subagent.agentId || agentId; + this.outputToolIdToAgentId.set(toolId, agentId); + } + if (subagent.asyncStatus !== "running") { + return void 0; + } + const stillRunning = this.isStillRunningResult(result, isError); + if (stillRunning) { + this.outputToolIdToAgentId.delete(toolId); + return subagent; + } + const extractedResult = this.extractAgentResult(result, agentId != null ? agentId : "", toolUseResult); + const finalStatus = this.taskResultInterpreter.resolveTerminalStatus( + toolUseResult, + isError ? "error" : "completed" + ); + subagent.asyncStatus = finalStatus; + subagent.status = finalStatus; + subagent.result = extractedResult; + subagent.completedAt = Date.now(); + if (agentId) this.activeAsyncSubagents.delete(agentId); + this.outputToolIdToAgentId.delete(toolId); + this.updateAsyncDomState(subagent); + this.onStateChange(subagent); + return subagent; + } + isPendingAsyncTask(taskToolId) { + return this.pendingAsyncSubagents.has(taskToolId); + } + isLinkedAgentOutputTool(toolId) { + return this.outputToolIdToAgentId.has(toolId); + } + getByTaskId(taskToolId) { + const pending = this.pendingAsyncSubagents.get(taskToolId); + if (pending) return pending; + const agentId = this.taskIdToAgentId.get(taskToolId); + if (agentId) { + return this.activeAsyncSubagents.get(agentId); + } + return void 0; + } + /** + * Re-renders an async subagent after data-only updates (for example, + * hydrating tool calls from SDK sidecar files) without changing lifecycle state. + */ + refreshAsyncSubagent(subagent) { + this.updateAsyncDomState(subagent); + this.onStateChange(subagent); + } + // ============================================ + // Hook State + // ============================================ + hasRunningSubagents() { + return this.pendingAsyncSubagents.size > 0 || this.activeAsyncSubagents.size > 0; + } + // ============================================ + // Lifecycle + // ============================================ + get subagentsSpawnedThisStream() { + return this._spawnedThisStream; + } + resetSpawnedCount() { + this._spawnedThisStream = 0; + } + resetStreamingState() { + this.syncSubagents.clear(); + this.pendingTasks.clear(); + } + orphanAllActive() { + const orphaned = []; + for (const subagent of this.pendingAsyncSubagents.values()) { + this.markOrphaned(subagent); + orphaned.push(subagent); + } + for (const subagent of this.activeAsyncSubagents.values()) { + if (subagent.asyncStatus === "running") { + this.markOrphaned(subagent); + orphaned.push(subagent); + } + } + this.pendingAsyncSubagents.clear(); + this.activeAsyncSubagents.clear(); + this.taskIdToAgentId.clear(); + this.outputToolIdToAgentId.clear(); + return orphaned; + } + clear() { + this.syncSubagents.clear(); + this.pendingTasks.clear(); + this.pendingAsyncSubagents.clear(); + this.activeAsyncSubagents.clear(); + this.taskIdToAgentId.clear(); + this.outputToolIdToAgentId.clear(); + this.asyncDomStates.clear(); + } + // ============================================ + // Private: State Transitions + // ============================================ + markOrphaned(subagent) { + subagent.asyncStatus = "orphaned"; + subagent.status = "error"; + subagent.result = "Conversation ended before task completed"; + subagent.completedAt = Date.now(); + this.updateAsyncDomState(subagent); + this.onStateChange(subagent); + } + transitionToError(subagent, taskToolId, errorResult) { + subagent.asyncStatus = "error"; + subagent.status = "error"; + subagent.result = errorResult; + subagent.completedAt = Date.now(); + this.pendingAsyncSubagents.delete(taskToolId); + this.updateAsyncDomState(subagent); + this.onStateChange(subagent); + } + // ============================================ + // Private: Task Creation + // ============================================ + createSyncTask(taskToolId, taskInput, parentEl) { + const subagentState = createSubagentBlock(parentEl, taskToolId, taskInput); + this.syncSubagents.set(taskToolId, subagentState); + return { action: "created_sync", subagentState }; + } + createAsyncTask(taskToolId, taskInput, parentEl) { + const description = taskInput.description || "Background task"; + const prompt = taskInput.prompt || ""; + const info = { + id: taskToolId, + description, + prompt, + mode: "async", + isExpanded: false, + status: "running", + toolCalls: [], + asyncStatus: "pending" + }; + this.pendingAsyncSubagents.set(taskToolId, info); + const domState = createAsyncSubagentBlock(parentEl, taskToolId, taskInput); + this.asyncDomStates.set(taskToolId, domState); + return { action: "created_async", info, domState }; + } + // ============================================ + // Private: Label Update + // ============================================ + updateSubagentLabel(wrapperEl, info, newInput) { + if (!newInput || Object.keys(newInput).length === 0) return; + const description = newInput.description || ""; + if (description) { + info.description = description; + const labelEl = wrapperEl.querySelector(".claudian-subagent-label"); + if (labelEl) { + const truncated = description.length > 40 ? description.substring(0, 40) + "..." : description; + labelEl.setText(truncated); + } + } + const prompt = newInput.prompt || ""; + if (prompt) { + info.prompt = prompt; + const promptEl = wrapperEl.querySelector(".claudian-subagent-prompt-text"); + if (promptEl) { + promptEl.setText(prompt); + } + } + } + resolveTaskMode(taskInput) { + if (!Object.prototype.hasOwnProperty.call(taskInput, "run_in_background")) { + return null; + } + if (taskInput.run_in_background === true) { + return "async"; + } + if (taskInput.run_in_background === false) { + return "sync"; + } + return null; + } + inferModeFromTaskResult(taskResult, isError, taskToolUseResult) { + if (isError) { + return "sync"; + } + if (this.taskResultInterpreter.hasAsyncLaunchMarker(taskToolUseResult)) { + return "async"; + } + return this.parseAgentIdStrict(taskResult) ? "async" : "sync"; + } + parseAgentIdStrict(result) { + var _a3; + const fromRaw = this.extractAgentIdFromString(result); + if (fromRaw) return fromRaw; + const payload = this.unwrapTextPayload(result); + const fromPayload = this.extractAgentIdFromString(payload); + if (fromPayload) return fromPayload; + try { + const parsed = JSON.parse(result); + if (Array.isArray(parsed)) { + for (const block of parsed) { + if (block && typeof block === "object" && typeof block.text === "string") { + const fromText = this.extractAgentIdFromString(block.text); + if (fromText) return fromText; + } + } + } + const agentId = parsed.agent_id || parsed.agentId || ((_a3 = parsed == null ? void 0 : parsed.data) == null ? void 0 : _a3.agent_id); + if (typeof agentId === "string" && agentId.length > 0) { + return agentId; + } + } catch (e3) { + } + return null; + } + extractAgentIdFromString(value) { + const regexPatterns = [ + /"agent_id"\s*:\s*"([^"]+)"/, + /"agentId"\s*:\s*"([^"]+)"/, + /agent_id[=:]\s*"?([a-zA-Z0-9_-]+)"?/i, + /agentId[=:]\s*"?([a-zA-Z0-9_-]+)"?/i + ]; + for (const pattern of regexPatterns) { + const match = value.match(pattern); + if (match && match[1]) { + return match[1]; + } + } + return null; + } + // ============================================ + // Private: Async DOM State Updates + // ============================================ + updateAsyncDomState(subagent) { + let asyncState = this.asyncDomStates.get(subagent.id); + if (!asyncState) { + for (const s3 of this.asyncDomStates.values()) { + if (s3.info.agentId === subagent.agentId) { + asyncState = s3; + break; + } + } + if (!asyncState) return; + } + asyncState.info = subagent; + switch (subagent.asyncStatus) { + case "running": + updateAsyncSubagentRunning(asyncState, subagent.agentId || ""); + break; + case "completed": + case "error": + finalizeAsyncSubagent(asyncState, subagent.result || "", subagent.asyncStatus === "error"); + break; + case "orphaned": + markAsyncSubagentOrphaned(asyncState); + break; + } + } + // ============================================ + // Private: Async Parsing Logic + // ============================================ + isStillRunningResult(result, isError) { + const trimmed = (result == null ? void 0 : result.trim()) || ""; + const payload = this.unwrapTextPayload(trimmed); + if (isError) return false; + if (!trimmed) return false; + try { + const parsed = JSON.parse(payload); + const status = parsed.retrieval_status || parsed.status; + const hasAgents = parsed.agents && Object.keys(parsed.agents).length > 0; + if (status === "not_ready" || status === "running" || status === "pending") { + return true; + } + if (hasAgents) { + const agentStatuses = Object.values(parsed.agents).map((a3) => a3 && typeof a3 === "object" && "status" in a3 && typeof a3.status === "string" ? a3.status.toLowerCase() : ""); + const anyRunning = agentStatuses.some( + (s3) => s3 === "running" || s3 === "pending" || s3 === "not_ready" + ); + if (anyRunning) return true; + return false; + } + if (status === "success" || status === "completed") { + return false; + } + return false; + } catch (e3) { + } + const lowerResult = payload.toLowerCase(); + if (lowerResult.includes("not_ready") || lowerResult.includes("not ready")) { + return true; + } + const xmlStatusMatch = lowerResult.match(/([^<]+)<\/status>/); + if (xmlStatusMatch) { + const status = xmlStatusMatch[1].trim(); + if (status === "running" || status === "pending" || status === "not_ready") { + return true; + } + } + return false; + } + extractAgentResult(result, agentId, toolUseResult) { + const structuredResult = this.taskResultInterpreter.extractStructuredResult(toolUseResult); + const normalizedStructuredResult = this.extractResultFromCandidateString(structuredResult); + if (normalizedStructuredResult) { + return normalizedStructuredResult; + } + if (structuredResult) { + return structuredResult; + } + const payload = this.unwrapTextPayload(result); + try { + const parsed = JSON.parse(payload); + const taskResult = this.extractResultFromTaskObject(parsed.task); + if (taskResult) { + return taskResult; + } + if (parsed.agents && agentId && parsed.agents[agentId]) { + const agentData = parsed.agents[agentId]; + const parsedResult2 = this.extractResultFromCandidateString(agentData == null ? void 0 : agentData.result); + if (parsedResult2) { + return parsedResult2; + } + const parsedOutput2 = this.extractResultFromCandidateString(agentData == null ? void 0 : agentData.output); + if (parsedOutput2) { + return parsedOutput2; + } + return JSON.stringify(agentData, null, 2); + } + if (parsed.agents) { + const agentIds = Object.keys(parsed.agents); + if (agentIds.length > 0) { + const firstAgent = parsed.agents[agentIds[0]]; + const parsedResult2 = this.extractResultFromCandidateString(firstAgent == null ? void 0 : firstAgent.result); + if (parsedResult2) { + return parsedResult2; + } + const parsedOutput2 = this.extractResultFromCandidateString(firstAgent == null ? void 0 : firstAgent.output); + if (parsedOutput2) { + return parsedOutput2; + } + return JSON.stringify(firstAgent, null, 2); + } + } + const parsedResult = this.extractResultFromCandidateString(parsed.result); + if (parsedResult) { + return parsedResult; + } + const parsedOutput = this.extractResultFromCandidateString(parsed.output); + if (parsedOutput) { + return parsedOutput; + } + } catch (e3) { + } + const taggedResult = this.extractResultFromTaggedPayload(payload); + if (taggedResult) { + return taggedResult; + } + return payload; + } + extractResultFromTaskObject(task) { + var _a3; + if (!task || typeof task !== "object") { + return null; + } + const taskRecord = task; + return (_a3 = this.extractResultFromCandidateString(taskRecord.result)) != null ? _a3 : this.extractResultFromCandidateString(taskRecord.output); + } + extractResultFromCandidateString(candidate) { + if (typeof candidate !== "string") { + return null; + } + const trimmed = candidate.trim(); + if (!trimmed) { + return null; + } + const taggedResult = this.extractResultFromTaggedPayload(trimmed); + if (taggedResult) { + return taggedResult; + } + const jsonlResult = this.extractResultFromOutputJsonl(trimmed); + if (jsonlResult) { + return jsonlResult; + } + return trimmed; + } + parseAgentId(result) { + var _a3; + const regexPatterns = [ + /"agent_id"\s*:\s*"([^"]+)"/, + /"agentId"\s*:\s*"([^"]+)"/, + /agent_id[=:]\s*"?([a-zA-Z0-9_-]+)"?/i, + /agentId[=:]\s*"?([a-zA-Z0-9_-]+)"?/i, + /\b([a-f0-9]{8})\b/ + ]; + for (const pattern of regexPatterns) { + const match = result.match(pattern); + if (match && match[1]) { + return match[1]; + } + } + try { + const parsed = JSON.parse(result); + const agentId = parsed.agent_id || parsed.agentId; + if (typeof agentId === "string" && agentId.length > 0) { + return agentId; + } + if ((_a3 = parsed.data) == null ? void 0 : _a3.agent_id) { + return parsed.data.agent_id; + } + if (parsed.id && typeof parsed.id === "string") { + return parsed.id; + } + } catch (e3) { + } + return null; + } + inferAgentIdFromResult(result) { + try { + const parsed = JSON.parse(result); + if (parsed.agents && typeof parsed.agents === "object") { + const keys = Object.keys(parsed.agents); + if (keys.length > 0) { + return keys[0]; + } + } + } catch (e3) { + } + return null; + } + unwrapTextPayload(raw) { + try { + const parsed = JSON.parse(raw); + if (Array.isArray(parsed)) { + const textBlock = parsed.find((b) => b && typeof b.text === "string"); + if (textBlock == null ? void 0 : textBlock.text) return textBlock.text; + } else if (parsed && typeof parsed === "object" && typeof parsed.text === "string") { + return parsed.text; + } + } catch (e3) { + } + return raw; + } + extractResultFromTaggedPayload(payload) { + const directResult = this.taskResultInterpreter.extractTagValue(payload, "result"); + if (directResult) return directResult; + const outputContent = this.taskResultInterpreter.extractTagValue(payload, "output"); + if (!outputContent) return null; + const extractedFromJsonl = this.extractResultFromOutputJsonl(outputContent); + if (extractedFromJsonl) return extractedFromJsonl; + const nestedResult = this.taskResultInterpreter.extractTagValue(outputContent, "result"); + if (nestedResult) return nestedResult; + const trimmed = outputContent.trim(); + return trimmed.length > 0 ? trimmed : null; + } + extractResultFromOutputJsonl(outputContent) { + const inlineResult = extractFinalResultFromSubagentJsonl(outputContent); + if (inlineResult) { + return inlineResult; + } + const fullOutputPath = this.extractFullOutputPath(outputContent); + if (!fullOutputPath) { + return null; + } + const fullOutput = this.readFullOutputFile(fullOutputPath); + if (!fullOutput) { + return null; + } + return extractFinalResultFromSubagentJsonl(fullOutput); + } + extractFullOutputPath(content) { + const truncatedPattern = /\[Truncated\.\s*Full output:\s*([^\]\n]+)\]/i; + const match = content.match(truncatedPattern); + if (!match || !match[1]) { + return null; + } + const outputPath = match[1].trim(); + return outputPath.length > 0 ? outputPath : null; + } + readFullOutputFile(fullOutputPath) { + try { + if (!this.isTrustedOutputPath(fullOutputPath)) { + return null; + } + if (!(0, import_fs5.existsSync)(fullOutputPath)) { + return null; + } + const fileContent = (0, import_fs5.readFileSync)(fullOutputPath, "utf-8"); + const trimmed = fileContent.trim(); + return trimmed.length > 0 ? trimmed : null; + } catch (e3) { + return null; + } + } + extractAgentIdFromInput(input) { + const agentId = input.task_id || input.agentId || input.agent_id; + return agentId || null; + } + static resolveTrustedTmpRoots() { + const roots = /* @__PURE__ */ new Set(); + const candidates = [(0, import_os2.tmpdir)(), "/tmp", "/private/tmp"]; + for (const candidate of candidates) { + try { + roots.add((0, import_fs5.realpathSync)(candidate)); + } catch (e3) { + } + } + return Array.from(roots); + } + isTrustedOutputPath(fullOutputPath) { + if (!(0, import_path23.isAbsolute)(fullOutputPath)) { + return false; + } + if (!fullOutputPath.toLowerCase().endsWith(_SubagentManager.TRUSTED_OUTPUT_EXT)) { + return false; + } + let resolvedPath; + try { + resolvedPath = (0, import_fs5.realpathSync)(fullOutputPath); + } catch (e3) { + return false; + } + return _SubagentManager.TRUSTED_TMP_ROOTS.some( + (root) => resolvedPath === root || resolvedPath.startsWith(`${root}${import_path23.sep}`) + ); + } +}; +_SubagentManager.TRUSTED_OUTPUT_EXT = ".output"; +_SubagentManager.TRUSTED_TMP_ROOTS = _SubagentManager.resolveTrustedTmpRoots(); +var SubagentManager = _SubagentManager; + +// src/features/chat/state/ChatState.ts +function createInitialState() { + return { + messages: [], + isStreaming: false, + cancelRequested: false, + streamGeneration: 0, + isCreatingConversation: false, + isSwitchingConversation: false, + currentConversationId: null, + queuedMessage: null, + currentContentEl: null, + currentTextEl: null, + currentTextContent: "", + currentThinkingState: null, + thinkingEl: null, + queueIndicatorEl: null, + thinkingIndicatorTimeout: null, + toolCallElements: /* @__PURE__ */ new Map(), + writeEditStates: /* @__PURE__ */ new Map(), + pendingTools: /* @__PURE__ */ new Map(), + usage: null, + ignoreUsageUpdates: false, + currentTodos: null, + needsAttention: false, + autoScrollEnabled: true, + // Default; controllers will override based on settings + responseStartTime: null, + flavorTimerInterval: null, + pendingNewSessionPlan: null, + planFilePath: null, + prePlanPermissionMode: null + }; +} +var ChatState = class { + constructor(callbacks = {}) { + this.state = createInitialState(); + this._callbacks = callbacks; + } + get callbacks() { + return this._callbacks; + } + set callbacks(value) { + this._callbacks = value; + } + // ============================================ + // Messages + // ============================================ + get messages() { + return [...this.state.messages]; + } + set messages(value) { + var _a3, _b2; + this.state.messages = value; + (_b2 = (_a3 = this._callbacks).onMessagesChanged) == null ? void 0 : _b2.call(_a3); + } + addMessage(msg) { + var _a3, _b2; + this.state.messages.push(msg); + (_b2 = (_a3 = this._callbacks).onMessagesChanged) == null ? void 0 : _b2.call(_a3); + } + clearMessages() { + var _a3, _b2; + this.state.messages = []; + (_b2 = (_a3 = this._callbacks).onMessagesChanged) == null ? void 0 : _b2.call(_a3); + } + truncateAt(messageId) { + var _a3, _b2; + const idx = this.state.messages.findIndex((m3) => m3.id === messageId); + if (idx === -1) return 0; + const removed = this.state.messages.length - idx; + this.state.messages = this.state.messages.slice(0, idx); + (_b2 = (_a3 = this._callbacks).onMessagesChanged) == null ? void 0 : _b2.call(_a3); + return removed; + } + // ============================================ + // Streaming Control + // ============================================ + get isStreaming() { + return this.state.isStreaming; + } + set isStreaming(value) { + var _a3, _b2; + this.state.isStreaming = value; + (_b2 = (_a3 = this._callbacks).onStreamingStateChanged) == null ? void 0 : _b2.call(_a3, value); + } + get cancelRequested() { + return this.state.cancelRequested; + } + set cancelRequested(value) { + this.state.cancelRequested = value; + } + get streamGeneration() { + return this.state.streamGeneration; + } + bumpStreamGeneration() { + this.state.streamGeneration += 1; + return this.state.streamGeneration; + } + get isCreatingConversation() { + return this.state.isCreatingConversation; + } + set isCreatingConversation(value) { + this.state.isCreatingConversation = value; + } + get isSwitchingConversation() { + return this.state.isSwitchingConversation; + } + set isSwitchingConversation(value) { + this.state.isSwitchingConversation = value; + } + // ============================================ + // Conversation + // ============================================ + get currentConversationId() { + return this.state.currentConversationId; + } + set currentConversationId(value) { + var _a3, _b2; + this.state.currentConversationId = value; + (_b2 = (_a3 = this._callbacks).onConversationChanged) == null ? void 0 : _b2.call(_a3, value); + } + // ============================================ + // Queued Message + // ============================================ + get queuedMessage() { + return this.state.queuedMessage; + } + set queuedMessage(value) { + this.state.queuedMessage = value; + } + // ============================================ + // Streaming DOM State + // ============================================ + get currentContentEl() { + return this.state.currentContentEl; + } + set currentContentEl(value) { + this.state.currentContentEl = value; + } + get currentTextEl() { + return this.state.currentTextEl; + } + set currentTextEl(value) { + this.state.currentTextEl = value; + } + get currentTextContent() { + return this.state.currentTextContent; + } + set currentTextContent(value) { + this.state.currentTextContent = value; + } + get currentThinkingState() { + return this.state.currentThinkingState; + } + set currentThinkingState(value) { + this.state.currentThinkingState = value; + } + get thinkingEl() { + return this.state.thinkingEl; + } + set thinkingEl(value) { + this.state.thinkingEl = value; + } + get queueIndicatorEl() { + return this.state.queueIndicatorEl; + } + set queueIndicatorEl(value) { + this.state.queueIndicatorEl = value; + } + get thinkingIndicatorTimeout() { + return this.state.thinkingIndicatorTimeout; + } + set thinkingIndicatorTimeout(value) { + this.state.thinkingIndicatorTimeout = value; + } + // ============================================ + // Tool Tracking Maps (mutable references) + // ============================================ + get toolCallElements() { + return this.state.toolCallElements; + } + get writeEditStates() { + return this.state.writeEditStates; + } + get pendingTools() { + return this.state.pendingTools; + } + // ============================================ + // Usage State + // ============================================ + get usage() { + return this.state.usage; + } + set usage(value) { + var _a3, _b2; + this.state.usage = value; + (_b2 = (_a3 = this._callbacks).onUsageChanged) == null ? void 0 : _b2.call(_a3, value); + } + get ignoreUsageUpdates() { + return this.state.ignoreUsageUpdates; + } + set ignoreUsageUpdates(value) { + this.state.ignoreUsageUpdates = value; + } + // ============================================ + // Current Todos (for persistent bottom panel) + // ============================================ + get currentTodos() { + return this.state.currentTodos ? [...this.state.currentTodos] : null; + } + set currentTodos(value) { + var _a3, _b2; + const normalizedValue = value && value.length > 0 ? value : null; + this.state.currentTodos = normalizedValue; + (_b2 = (_a3 = this._callbacks).onTodosChanged) == null ? void 0 : _b2.call(_a3, normalizedValue); + } + // ============================================ + // Attention State (approval pending, error, etc.) + // ============================================ + get needsAttention() { + return this.state.needsAttention; + } + set needsAttention(value) { + var _a3, _b2; + this.state.needsAttention = value; + (_b2 = (_a3 = this._callbacks).onAttentionChanged) == null ? void 0 : _b2.call(_a3, value); + } + // ============================================ + // Auto-Scroll Control + // ============================================ + get autoScrollEnabled() { + return this.state.autoScrollEnabled; + } + set autoScrollEnabled(value) { + var _a3, _b2; + const changed = this.state.autoScrollEnabled !== value; + this.state.autoScrollEnabled = value; + if (changed) { + (_b2 = (_a3 = this._callbacks).onAutoScrollChanged) == null ? void 0 : _b2.call(_a3, value); + } + } + // ============================================ + // Response Timer State + // ============================================ + get responseStartTime() { + return this.state.responseStartTime; + } + set responseStartTime(value) { + this.state.responseStartTime = value; + } + get flavorTimerInterval() { + return this.state.flavorTimerInterval; + } + set flavorTimerInterval(value) { + this.state.flavorTimerInterval = value; + } + get pendingNewSessionPlan() { + return this.state.pendingNewSessionPlan; + } + set pendingNewSessionPlan(value) { + this.state.pendingNewSessionPlan = value; + } + get planFilePath() { + return this.state.planFilePath; + } + set planFilePath(value) { + this.state.planFilePath = value; + } + get prePlanPermissionMode() { + return this.state.prePlanPermissionMode; + } + set prePlanPermissionMode(value) { + this.state.prePlanPermissionMode = value; + } + // ============================================ + // Reset Methods + // ============================================ + clearFlavorTimerInterval() { + if (this.state.flavorTimerInterval) { + clearInterval(this.state.flavorTimerInterval); + this.state.flavorTimerInterval = null; + } + } + resetStreamingState() { + this.state.currentContentEl = null; + this.state.currentTextEl = null; + this.state.currentTextContent = ""; + this.state.currentThinkingState = null; + this.state.isStreaming = false; + this.state.cancelRequested = false; + if (this.state.thinkingIndicatorTimeout) { + clearTimeout(this.state.thinkingIndicatorTimeout); + this.state.thinkingIndicatorTimeout = null; + } + this.clearFlavorTimerInterval(); + this.state.responseStartTime = null; + } + clearMaps() { + this.state.toolCallElements.clear(); + this.state.writeEditStates.clear(); + this.state.pendingTools.clear(); + } + resetForNewConversation() { + this.clearMessages(); + this.resetStreamingState(); + this.clearMaps(); + this.state.queuedMessage = null; + this.usage = null; + this.currentTodos = null; + this.autoScrollEnabled = true; + } + getPersistedMessages() { + return this.state.messages; + } +}; + +// src/features/chat/ui/BangBashModeManager.ts +var import_obsidian30 = require("obsidian"); +var BangBashModeManager = class { + constructor(inputEl, callbacks) { + this.state = { active: false, rawCommand: "" }; + this.isSubmitting = false; + this.originalPlaceholder = ""; + this.inputEl = inputEl; + this.callbacks = callbacks; + this.originalPlaceholder = inputEl.placeholder; + } + handleTriggerKey(e3) { + if (!this.state.active && this.inputEl.value === "" && e3.key === "!") { + if (this.enterMode()) { + e3.preventDefault(); + return true; + } + } + return false; + } + handleInputChange() { + if (!this.state.active) return; + this.state.rawCommand = this.inputEl.value; + } + enterMode() { + const wrapper = this.callbacks.getInputWrapper(); + if (!wrapper) return false; + wrapper.addClass("claudian-input-bang-bash-mode"); + this.state = { active: true, rawCommand: "" }; + this.inputEl.placeholder = t("chat.bangBash.placeholder"); + return true; + } + exitMode() { + const wrapper = this.callbacks.getInputWrapper(); + if (wrapper) { + wrapper.removeClass("claudian-input-bang-bash-mode"); + } + this.state = { active: false, rawCommand: "" }; + this.inputEl.placeholder = this.originalPlaceholder; + } + handleKeydown(e3) { + if (!this.state.active) return false; + if (e3.key === "Enter" && !e3.shiftKey && !e3.isComposing) { + e3.preventDefault(); + if (this.state.rawCommand.trim()) { + this.submit(); + } + return true; + } + if (e3.key === "Escape" && !e3.isComposing) { + e3.preventDefault(); + this.clear(); + return true; + } + return false; + } + isActive() { + return this.state.active; + } + getRawCommand() { + return this.state.rawCommand; + } + async submit() { + if (this.isSubmitting) return; + const rawCommand = this.state.rawCommand.trim(); + if (!rawCommand) return; + this.isSubmitting = true; + try { + this.clear(); + await this.callbacks.onSubmit(rawCommand); + } catch (e3) { + new import_obsidian30.Notice(`Command failed: ${e3 instanceof Error ? e3.message : String(e3)}`); + } finally { + this.isSubmitting = false; + } + } + clear() { + var _a3, _b2; + this.inputEl.value = ""; + this.exitMode(); + (_b2 = (_a3 = this.callbacks).resetInputHeight) == null ? void 0 : _b2.call(_a3); + } + destroy() { + this.exitMode(); + } +}; + +// src/features/chat/ui/FileContext.ts +var import_obsidian34 = require("obsidian"); + +// src/shared/mention/MentionDropdownController.ts +var import_obsidian31 = require("obsidian"); + +// src/utils/externalContext.ts +var fs17 = __toESM(require("fs")); +init_path(); +function normalizePathForComparison3(p) { + return normalizePathForComparison2(p); +} +function normalizePathForDisplay(p) { + if (!p) return ""; + return p.replace(/\\/g, "/").replace(/\/+$/, ""); +} +function findConflictingPath(newPath, existingPaths) { + const normalizedNew = normalizePathForComparison3(newPath); + for (const existing of existingPaths) { + const normalizedExisting = normalizePathForComparison3(existing); + if (normalizedNew.startsWith(normalizedExisting + "/")) { + return { path: existing, type: "parent" }; + } + if (normalizedExisting.startsWith(normalizedNew + "/")) { + return { path: existing, type: "child" }; + } + } + return null; +} +function getFolderName(p) { + const normalized = normalizePathForDisplay(p); + const segments = normalized.split("/"); + return segments[segments.length - 1] || normalized; +} +function getContextDisplayName(normalizedPath, folderName, needsDisambiguation) { + if (!needsDisambiguation) return folderName; + const segments = normalizedPath.split("/").filter(Boolean); + if (segments.length < 2) return folderName; + const parent = segments[segments.length - 2]; + if (!parent) return folderName; + return `${parent}/${folderName}`; +} +function buildExternalContextDisplayEntries(externalContexts) { + var _a3; + const counts = /* @__PURE__ */ new Map(); + const normalizedPaths = /* @__PURE__ */ new Map(); + for (const contextPath of externalContexts) { + const normalized = normalizePathForComparison3(contextPath); + normalizedPaths.set(contextPath, normalized); + const folderName = getFolderName(normalized); + counts.set(folderName, ((_a3 = counts.get(folderName)) != null ? _a3 : 0) + 1); + } + return externalContexts.map((contextRoot) => { + var _a4, _b2; + const normalized = (_a4 = normalizedPaths.get(contextRoot)) != null ? _a4 : normalizePathForComparison3(contextRoot); + const folderName = getFolderName(contextRoot); + const needsDisambiguation = ((_b2 = counts.get(folderName)) != null ? _b2 : 0) > 1; + const displayName = getContextDisplayName(normalized, folderName, needsDisambiguation); + return { + contextRoot, + displayName, + displayNameLower: displayName.toLowerCase() + }; + }); +} +function validateDirectoryPath(p) { + try { + const stats = fs17.statSync(p); + if (!stats.isDirectory()) { + return { valid: false, error: "Path exists but is not a directory" }; + } + return { valid: true }; + } catch (err) { + const error48 = err; + if (error48.code === "ENOENT") { + return { valid: false, error: "Path does not exist" }; + } + if (error48.code === "EACCES") { + return { valid: false, error: "Permission denied" }; + } + return { valid: false, error: `Cannot access path: ${error48.message}` }; + } +} +function isValidDirectoryPath(p) { + return validateDirectoryPath(p).valid; +} +function filterValidPaths(paths) { + return paths.filter(isValidDirectoryPath); +} +function isDuplicatePath(newPath, existingPaths) { + const normalizedNew = normalizePathForComparison3(newPath); + return existingPaths.some((existing) => normalizePathForComparison3(existing) === normalizedNew); +} + +// src/utils/externalContextScanner.ts +var fs18 = __toESM(require("fs")); +var path16 = __toESM(require("path")); +init_path(); +var CACHE_TTL_MS = 3e4; +var MAX_FILES_PER_PATH = 1e3; +var MAX_DEPTH = 10; +var SKIP_DIRECTORIES = /* @__PURE__ */ new Set([ + "node_modules", + "__pycache__", + "venv", + ".venv", + ".git", + ".svn", + ".hg", + "dist", + "build", + "out", + ".next", + ".nuxt", + "target", + "vendor", + "Pods" +]); +var ExternalContextScanner = class { + constructor() { + this.cache = /* @__PURE__ */ new Map(); + } + scanPaths(externalContextPaths) { + const allFiles = []; + const now = Date.now(); + for (const contextPath of externalContextPaths) { + const expandedPath = normalizePathForFilesystem(contextPath); + const cached2 = this.cache.get(expandedPath); + if (cached2 && now - cached2.timestamp < CACHE_TTL_MS) { + allFiles.push(...cached2.files); + continue; + } + const files = this.scanDirectory(expandedPath, expandedPath, 0); + this.cache.set(expandedPath, { files, timestamp: now }); + allFiles.push(...files); + } + return allFiles; + } + scanDirectory(dir, contextRoot, depth) { + if (depth > MAX_DEPTH) return []; + const files = []; + try { + if (!fs18.existsSync(dir)) return []; + const stat = fs18.statSync(dir); + if (!stat.isDirectory()) return []; + const entries = fs18.readdirSync(dir, { withFileTypes: true }); + for (const entry of entries) { + if (entry.name.startsWith(".")) continue; + if (SKIP_DIRECTORIES.has(entry.name)) continue; + if (entry.isSymbolicLink()) continue; + const fullPath = path16.join(dir, entry.name); + if (entry.isDirectory()) { + const subFiles = this.scanDirectory(fullPath, contextRoot, depth + 1); + files.push(...subFiles); + } else if (entry.isFile()) { + try { + const fileStat = fs18.statSync(fullPath); + files.push({ + path: fullPath, + name: entry.name, + relativePath: path16.relative(contextRoot, fullPath), + contextRoot, + mtime: fileStat.mtimeMs + }); + } catch (e3) { + } + } + if (files.length >= MAX_FILES_PER_PATH) break; + } + } catch (e3) { + } + return files; + } + invalidateCache() { + this.cache.clear(); + } + invalidatePath(contextPath) { + const expandedPath = normalizePathForFilesystem(contextPath); + this.cache.delete(expandedPath); + } +}; +var externalContextScanner = new ExternalContextScanner(); + +// src/shared/components/SelectableDropdown.ts +var SelectableDropdown = class { + constructor(containerEl, options) { + this.dropdownEl = null; + this.items = []; + this.itemEls = []; + this.selectedIndex = 0; + this.containerEl = containerEl; + this.options = options; + } + isVisible() { + var _a3, _b2; + return (_b2 = (_a3 = this.dropdownEl) == null ? void 0 : _a3.hasClass("visible")) != null ? _b2 : false; + } + getElement() { + return this.dropdownEl; + } + getSelectedIndex() { + return this.selectedIndex; + } + getSelectedItem() { + var _a3; + return (_a3 = this.items[this.selectedIndex]) != null ? _a3 : null; + } + getItems() { + return this.items; + } + hide() { + if (this.dropdownEl) { + this.dropdownEl.removeClass("visible"); + } + } + destroy() { + if (this.dropdownEl) { + this.dropdownEl.remove(); + this.dropdownEl = null; + } + } + render(options) { + var _a3; + this.items = options.items; + this.selectedIndex = options.selectedIndex; + if (!this.dropdownEl) { + this.dropdownEl = this.createDropdownElement(); + } + this.dropdownEl.empty(); + this.itemEls = []; + if (options.items.length === 0) { + const emptyEl = this.dropdownEl.createDiv({ cls: this.options.emptyClassName }); + emptyEl.setText(options.emptyText); + } else { + for (let i3 = 0; i3 < options.items.length; i3++) { + const item = options.items[i3]; + const itemEl = this.dropdownEl.createDiv({ cls: this.options.itemClassName }); + const extraClass = (_a3 = options.getItemClass) == null ? void 0 : _a3.call(options, item); + if (Array.isArray(extraClass)) { + extraClass.forEach((cls) => itemEl.addClass(cls)); + } else if (extraClass) { + itemEl.addClass(extraClass); + } + if (i3 === this.selectedIndex) { + itemEl.addClass("selected"); + } + options.renderItem(item, itemEl); + itemEl.addEventListener("click", (e3) => { + var _a4; + this.selectedIndex = i3; + this.updateSelection(); + (_a4 = options.onItemClick) == null ? void 0 : _a4.call(options, item, i3, e3); + }); + itemEl.addEventListener("mouseenter", () => { + var _a4; + this.selectedIndex = i3; + this.updateSelection(); + (_a4 = options.onItemHover) == null ? void 0 : _a4.call(options, item, i3); + }); + this.itemEls.push(itemEl); + } + } + this.dropdownEl.addClass("visible"); + } + updateSelection() { + this.itemEls.forEach((itemEl, index) => { + if (index === this.selectedIndex) { + itemEl.addClass("selected"); + itemEl.scrollIntoView({ block: "nearest" }); + } else { + itemEl.removeClass("selected"); + } + }); + } + moveSelection(delta) { + const maxIndex = this.items.length - 1; + this.selectedIndex = Math.max(0, Math.min(maxIndex, this.selectedIndex + delta)); + this.updateSelection(); + } + createDropdownElement() { + const className = this.options.fixed && this.options.fixedClassName ? `${this.options.listClassName} ${this.options.fixedClassName}` : this.options.listClassName; + return this.containerEl.createDiv({ cls: className }); + } +}; + +// src/shared/mention/MentionDropdownController.ts +var MentionDropdownController = class { + constructor(containerEl, inputEl, callbacks, options = {}) { + this.mentionStartIndex = -1; + this.selectedMentionIndex = 0; + this.filteredMentionItems = []; + this.filteredContextFiles = []; + this.activeContextFilter = null; + this.activeAgentFilter = false; + this.mcpManager = null; + this.agentService = null; + this.debounceTimer = null; + var _a3; + this.containerEl = containerEl; + this.inputEl = inputEl; + this.callbacks = callbacks; + this.fixed = (_a3 = options.fixed) != null ? _a3 : false; + this.dropdown = new SelectableDropdown(this.containerEl, { + listClassName: "claudian-mention-dropdown", + itemClassName: "claudian-mention-item", + emptyClassName: "claudian-mention-empty", + fixed: this.fixed, + fixedClassName: "claudian-mention-dropdown-fixed" + }); + } + setMcpManager(manager) { + this.mcpManager = manager; + } + setAgentService(service) { + if (this.agentService !== service && this.dropdown.isVisible()) { + this.hide(); + } + this.agentService = service; + } + preScanExternalContexts() { + const externalContexts = this.callbacks.getExternalContexts() || []; + if (externalContexts.length === 0) return; + setTimeout(() => { + try { + externalContextScanner.scanPaths(externalContexts); + } catch (e3) { + } + }, 0); + } + isVisible() { + return this.dropdown.isVisible(); + } + hide() { + this.dropdown.hide(); + this.mentionStartIndex = -1; + } + containsElement(el2) { + var _a3, _b2; + return (_b2 = (_a3 = this.dropdown.getElement()) == null ? void 0 : _a3.contains(el2)) != null ? _b2 : false; + } + destroy() { + if (this.debounceTimer !== null) { + clearTimeout(this.debounceTimer); + } + this.dropdown.destroy(); + } + updateMcpMentionsFromText(text) { + var _a3, _b2; + if (!this.mcpManager) return; + const validNames = new Set( + this.mcpManager.getContextSavingServers().map((s3) => s3.name) + ); + const newMentions = extractMcpMentions(text, validNames); + const changed = this.callbacks.setMentionedMcpServers(newMentions); + if (changed) { + (_b2 = (_a3 = this.callbacks).onMcpMentionChange) == null ? void 0 : _b2.call(_a3, newMentions); + } + } + handleInputChange() { + if (this.debounceTimer !== null) { + clearTimeout(this.debounceTimer); + } + this.debounceTimer = setTimeout(() => { + const text = this.inputEl.value; + this.updateMcpMentionsFromText(text); + const cursorPos = this.inputEl.selectionStart || 0; + const textBeforeCursor = text.substring(0, cursorPos); + const lastAtIndex = textBeforeCursor.lastIndexOf("@"); + if (lastAtIndex === -1) { + this.hide(); + return; + } + const charBeforeAt = lastAtIndex > 0 ? textBeforeCursor[lastAtIndex - 1] : " "; + if (!/\s/.test(charBeforeAt) && lastAtIndex !== 0) { + this.hide(); + return; + } + const searchText = textBeforeCursor.substring(lastAtIndex + 1); + if (/\s/.test(searchText)) { + this.hide(); + return; + } + this.mentionStartIndex = lastAtIndex; + this.showMentionDropdown(searchText); + }, 200); + } + handleKeydown(e3) { + if (!this.dropdown.isVisible()) return false; + if (e3.key === "ArrowDown") { + e3.preventDefault(); + this.dropdown.moveSelection(1); + this.selectedMentionIndex = this.dropdown.getSelectedIndex(); + return true; + } + if (e3.key === "ArrowUp") { + e3.preventDefault(); + this.dropdown.moveSelection(-1); + this.selectedMentionIndex = this.dropdown.getSelectedIndex(); + return true; + } + if ((e3.key === "Enter" || e3.key === "Tab") && !e3.isComposing) { + e3.preventDefault(); + this.selectMentionItem(); + return true; + } + if (e3.key === "Escape" && !e3.isComposing) { + e3.preventDefault(); + if (this.activeContextFilter || this.activeAgentFilter) { + this.returnToFirstLevel(); + return true; + } + this.hide(); + return true; + } + return false; + } + showMentionDropdown(searchText) { + const searchLower = searchText.toLowerCase(); + this.filteredMentionItems = []; + this.filteredContextFiles = []; + const externalContexts = this.callbacks.getExternalContexts() || []; + const contextEntries = buildExternalContextDisplayEntries(externalContexts); + const isFilterSearch = searchText.includes("/"); + let fileSearchText = searchLower; + if (isFilterSearch && searchLower.startsWith("agents/")) { + this.activeAgentFilter = true; + this.activeContextFilter = null; + const agentSearchText = searchText.substring("agents/".length).toLowerCase(); + if (this.agentService) { + const matchingAgents = this.agentService.searchAgents(agentSearchText); + for (const agent of matchingAgents) { + this.filteredMentionItems.push({ + type: "agent", + id: agent.id, + name: agent.name, + description: agent.description, + source: agent.source + }); + } + } + this.selectedMentionIndex = 0; + this.renderMentionDropdown(); + return; + } + if (isFilterSearch) { + const matchingContext = contextEntries.filter((entry) => searchLower.startsWith(`${entry.displayNameLower}/`)).sort((a3, b) => b.displayNameLower.length - a3.displayNameLower.length)[0]; + if (matchingContext) { + const prefixLength = matchingContext.displayName.length + 1; + fileSearchText = searchText.substring(prefixLength).toLowerCase(); + this.activeContextFilter = { + folderName: matchingContext.displayName, + contextRoot: matchingContext.contextRoot + }; + } else { + this.activeContextFilter = null; + } + } + if (this.activeContextFilter && isFilterSearch) { + const contextFiles = externalContextScanner.scanPaths([this.activeContextFilter.contextRoot]); + this.filteredContextFiles = contextFiles.filter((file2) => { + const relativePath = file2.relativePath.replace(/\\/g, "/"); + const pathLower = relativePath.toLowerCase(); + const nameLower = file2.name.toLowerCase(); + return pathLower.includes(fileSearchText) || nameLower.includes(fileSearchText); + }).sort((a3, b) => { + const aNameMatch = a3.name.toLowerCase().startsWith(fileSearchText); + const bNameMatch = b.name.toLowerCase().startsWith(fileSearchText); + if (aNameMatch && !bNameMatch) return -1; + if (!aNameMatch && bNameMatch) return 1; + return b.mtime - a3.mtime; + }); + for (const file2 of this.filteredContextFiles) { + const relativePath = file2.relativePath.replace(/\\/g, "/"); + this.filteredMentionItems.push({ + type: "context-file", + name: relativePath, + absolutePath: file2.path, + contextRoot: file2.contextRoot, + folderName: this.activeContextFilter.folderName + }); + } + const firstVaultItemIndex2 = this.filteredMentionItems.length; + const vaultItemCount2 = this.appendVaultItems(searchLower); + if (this.filteredContextFiles.length === 0 && vaultItemCount2 > 0) { + this.selectedMentionIndex = firstVaultItemIndex2; + } else { + this.selectedMentionIndex = 0; + } + this.renderMentionDropdown(); + return; + } + this.activeContextFilter = null; + this.activeAgentFilter = false; + if (this.mcpManager) { + const mcpServers = this.mcpManager.getContextSavingServers(); + for (const server of mcpServers) { + if (server.name.toLowerCase().includes(searchLower)) { + this.filteredMentionItems.push({ + type: "mcp-server", + name: server.name + }); + } + } + } + if (this.agentService) { + const hasAgents = this.agentService.searchAgents("").length > 0; + if (hasAgents && "agents".includes(searchLower)) { + this.filteredMentionItems.push({ + type: "agent-folder", + name: "Agents" + }); + } + } + if (contextEntries.length > 0) { + const matchingFolders = /* @__PURE__ */ new Set(); + for (const entry of contextEntries) { + if (entry.displayNameLower.includes(searchLower) && !matchingFolders.has(entry.displayName)) { + matchingFolders.add(entry.displayName); + this.filteredMentionItems.push({ + type: "context-folder", + name: entry.displayName, + contextRoot: entry.contextRoot, + folderName: entry.displayName + }); + } + } + } + const firstVaultItemIndex = this.filteredMentionItems.length; + const vaultItemCount = this.appendVaultItems(searchLower); + this.selectedMentionIndex = vaultItemCount > 0 ? firstVaultItemIndex : 0; + this.renderMentionDropdown(); + } + appendVaultItems(searchLower) { + var _a3; + const compare = (a3, b) => { + if (a3.startsWithQuery !== b.startsWithQuery) return a3.startsWithQuery ? -1 : 1; + if (a3.mtime !== b.mtime) return b.mtime - a3.mtime; + if (a3.type !== b.type) return a3.type === "file" ? -1 : 1; + return a3.path.localeCompare(b.path); + }; + const allFiles = this.callbacks.getCachedVaultFiles(); + const folderMtimeMap = /* @__PURE__ */ new Map(); + for (const f6 of allFiles) { + const parts = f6.path.split("/"); + for (let i3 = 1; i3 < parts.length; i3++) { + const folderPath = parts.slice(0, i3).join("/"); + const existing = (_a3 = folderMtimeMap.get(folderPath)) != null ? _a3 : 0; + if (f6.stat.mtime > existing) { + folderMtimeMap.set(folderPath, f6.stat.mtime); + } + } + } + const scoredFolders = this.callbacks.getCachedVaultFolders().map((f6) => ({ + name: f6.name, + path: f6.path.replace(/\\/g, "/").replace(/\/+$/, "") + })).filter( + (f6) => f6.path.length > 0 && (f6.path.toLowerCase().includes(searchLower) || f6.name.toLowerCase().includes(searchLower)) + ).map((f6) => { + var _a4; + return { + type: "folder", + name: f6.name, + path: f6.path, + startsWithQuery: f6.name.toLowerCase().startsWith(searchLower), + mtime: (_a4 = folderMtimeMap.get(f6.path)) != null ? _a4 : 0 + }; + }).sort(compare).slice(0, 50); + const scoredFiles = allFiles.filter( + (f6) => f6.path.toLowerCase().includes(searchLower) || f6.name.toLowerCase().includes(searchLower) + ).map((f6) => ({ + type: "file", + name: f6.name, + path: f6.path, + file: f6, + startsWithQuery: f6.name.toLowerCase().startsWith(searchLower), + mtime: f6.stat.mtime + })).sort(compare).slice(0, 100); + const merged = [...scoredFolders, ...scoredFiles].sort(compare); + for (const item of merged) { + if (item.type === "folder") { + this.filteredMentionItems.push({ type: "folder", name: item.name, path: item.path }); + } else { + this.filteredMentionItems.push({ type: "file", name: item.name, path: item.path, file: item.file }); + } + } + return merged.length; + } + renderMentionDropdown() { + this.dropdown.render({ + items: this.filteredMentionItems, + selectedIndex: this.selectedMentionIndex, + emptyText: "No matches", + getItemClass: (item) => { + switch (item.type) { + case "mcp-server": + return "mcp-server"; + case "folder": + return "vault-folder"; + case "agent": + return "agent"; + case "agent-folder": + return "agent-folder"; + case "context-file": + return "context-file"; + case "context-folder": + return "context-folder"; + default: + return void 0; + } + }, + renderItem: (item, itemEl) => { + const iconEl = itemEl.createSpan({ cls: "claudian-mention-icon" }); + switch (item.type) { + case "mcp-server": + iconEl.innerHTML = MCP_ICON_SVG; + break; + case "agent": + case "agent-folder": + (0, import_obsidian31.setIcon)(iconEl, "bot"); + break; + case "context-file": + (0, import_obsidian31.setIcon)(iconEl, "folder-open"); + break; + case "folder": + case "context-folder": + (0, import_obsidian31.setIcon)(iconEl, "folder"); + break; + default: + (0, import_obsidian31.setIcon)(iconEl, "file-text"); + } + const textEl = itemEl.createSpan({ cls: "claudian-mention-text" }); + switch (item.type) { + case "mcp-server": + textEl.createSpan({ cls: "claudian-mention-name" }).setText(`@${item.name}`); + break; + case "agent-folder": + textEl.createSpan({ + cls: "claudian-mention-name claudian-mention-name-agent-folder" + }).setText(`@${item.name}/`); + break; + case "agent": { + textEl.createSpan({ + cls: "claudian-mention-name claudian-mention-name-agent" + }).setText(`@${item.id}`); + if (item.description) { + textEl.createSpan({ cls: "claudian-mention-agent-desc" }).setText(item.description); + } + break; + } + case "context-folder": + textEl.createSpan({ + cls: "claudian-mention-name claudian-mention-name-folder" + }).setText(`@${item.name}/`); + break; + case "context-file": + textEl.createSpan({ + cls: "claudian-mention-name claudian-mention-name-context" + }).setText(item.name); + break; + case "folder": + textEl.createSpan({ + cls: "claudian-mention-name claudian-mention-name-folder" + }).setText(`@${item.path}/`); + break; + default: + textEl.createSpan({ cls: "claudian-mention-path" }).setText(item.path || item.name); + } + }, + onItemClick: (item, index, e3) => { + if (item.type === "context-folder" || item.type === "agent-folder") { + e3.stopPropagation(); + } + this.selectedMentionIndex = index; + this.selectMentionItem(); + }, + onItemHover: (_item, index) => { + this.selectedMentionIndex = index; + } + }); + if (this.fixed) { + this.positionFixed(); + } + } + positionFixed() { + const dropdownEl = this.dropdown.getElement(); + if (!dropdownEl) return; + const inputRect = this.inputEl.getBoundingClientRect(); + dropdownEl.style.position = "fixed"; + dropdownEl.style.bottom = `${window.innerHeight - inputRect.top + 4}px`; + dropdownEl.style.left = `${inputRect.left}px`; + dropdownEl.style.right = "auto"; + dropdownEl.style.width = `${Math.max(inputRect.width, 280)}px`; + dropdownEl.style.zIndex = "10001"; + } + insertReplacement(beforeAt, replacement, afterCursor) { + this.inputEl.value = beforeAt + replacement + afterCursor; + this.inputEl.selectionStart = this.inputEl.selectionEnd = beforeAt.length + replacement.length; + } + returnToFirstLevel() { + const text = this.inputEl.value; + const beforeAt = text.substring(0, this.mentionStartIndex); + const cursorPos = this.inputEl.selectionStart || 0; + const afterCursor = text.substring(cursorPos); + this.inputEl.value = beforeAt + "@" + afterCursor; + this.inputEl.selectionStart = this.inputEl.selectionEnd = beforeAt.length + 1; + this.activeContextFilter = null; + this.activeAgentFilter = false; + this.showMentionDropdown(""); + } + selectMentionItem() { + var _a3, _b2, _c, _d, _e, _f; + if (this.filteredMentionItems.length === 0) return; + const selectedIndex = this.dropdown.getSelectedIndex(); + this.selectedMentionIndex = selectedIndex; + const selectedItem = this.filteredMentionItems[selectedIndex]; + if (!selectedItem) return; + const text = this.inputEl.value; + const beforeAt = text.substring(0, this.mentionStartIndex); + const cursorPos = this.inputEl.selectionStart || 0; + const afterCursor = text.substring(cursorPos); + switch (selectedItem.type) { + case "mcp-server": { + const replacement = `@${selectedItem.name} `; + this.insertReplacement(beforeAt, replacement, afterCursor); + this.callbacks.addMentionedMcpServer(selectedItem.name); + (_b2 = (_a3 = this.callbacks).onMcpMentionChange) == null ? void 0 : _b2.call(_a3, this.callbacks.getMentionedMcpServers()); + break; + } + case "agent-folder": + this.activeAgentFilter = true; + this.inputEl.focus(); + this.showMentionDropdown("Agents/"); + return; + case "agent": { + const replacement = `@${selectedItem.id} (agent) `; + this.insertReplacement(beforeAt, replacement, afterCursor); + (_d = (_c = this.callbacks).onAgentMentionSelect) == null ? void 0 : _d.call(_c, selectedItem.id); + break; + } + case "context-folder": { + const replacement = `@${selectedItem.name}/`; + this.insertReplacement(beforeAt, replacement, afterCursor); + this.inputEl.focus(); + this.handleInputChange(); + return; + } + case "context-file": { + const displayName = selectedItem.folderName ? `@${selectedItem.folderName}/${selectedItem.name}` : `@${selectedItem.name}`; + if (selectedItem.absolutePath) { + this.callbacks.onAttachFile(selectedItem.absolutePath); + } + this.insertReplacement(beforeAt, `${displayName} `, afterCursor); + break; + } + case "folder": { + const normalizedPath = this.callbacks.normalizePathForVault(selectedItem.path); + this.insertReplacement(beforeAt, `@${normalizedPath != null ? normalizedPath : selectedItem.path}/ `, afterCursor); + break; + } + default: { + const rawPath = (_f = (_e = selectedItem.file) == null ? void 0 : _e.path) != null ? _f : selectedItem.path; + const normalizedPath = this.callbacks.normalizePathForVault(rawPath); + if (normalizedPath) { + this.callbacks.onAttachFile(normalizedPath); + } + this.insertReplacement(beforeAt, `@${normalizedPath != null ? normalizedPath : selectedItem.name} `, afterCursor); + break; + } + } + this.hide(); + this.inputEl.focus(); + } +}; + +// src/shared/mention/VaultMentionCache.ts +var import_obsidian32 = require("obsidian"); +var VaultFileCache = class { + constructor(app, options = {}) { + this.app = app; + this.options = options; + this.cachedFiles = []; + this.dirty = true; + this.isInitialized = false; + } + initializeInBackground() { + if (this.isInitialized) return; + setTimeout(() => { + this.tryRefreshFiles(); + }, 0); + } + markDirty() { + this.dirty = true; + } + getFiles() { + if (this.dirty || !this.isInitialized) { + this.tryRefreshFiles(); + } + return this.cachedFiles; + } + tryRefreshFiles() { + var _a3, _b2; + try { + this.cachedFiles = this.app.vault.getFiles(); + this.dirty = false; + } catch (error48) { + (_b2 = (_a3 = this.options).onLoadError) == null ? void 0 : _b2.call(_a3, error48); + if (this.cachedFiles.length > 0) { + this.dirty = false; + } + } finally { + this.isInitialized = true; + } + } +}; +function isVisibleFolder(folder) { + const normalizedPath = folder.path.replace(/\\/g, "/").replace(/\/+$/, ""); + if (!normalizedPath) return false; + return !normalizedPath.split("/").some((segment) => segment.startsWith(".")); +} +var VaultFolderCache = class { + constructor(app) { + this.app = app; + this.cachedFolders = []; + this.dirty = true; + this.isInitialized = false; + } + initializeInBackground() { + if (this.isInitialized) return; + setTimeout(() => { + this.tryRefreshFolders(); + }, 0); + } + markDirty() { + this.dirty = true; + } + getFolders() { + if (this.dirty || !this.isInitialized) { + this.tryRefreshFolders(); + } + return this.cachedFolders; + } + tryRefreshFolders() { + try { + this.cachedFolders = this.loadFolders(); + this.dirty = false; + } catch (e3) { + if (this.cachedFolders.length > 0) { + this.dirty = false; + } + } finally { + this.isInitialized = true; + } + } + loadFolders() { + return this.app.vault.getAllLoadedFiles().filter((file2) => file2 instanceof import_obsidian32.TFolder && isVisibleFolder(file2)); + } +}; + +// src/shared/mention/VaultMentionDataProvider.ts +var VaultMentionDataProvider = class { + constructor(app, options = {}) { + this.hasReportedFileLoadError = false; + this.fileCache = new VaultFileCache(app, { + onLoadError: () => { + var _a3; + if (this.hasReportedFileLoadError) return; + this.hasReportedFileLoadError = true; + (_a3 = options.onFileLoadError) == null ? void 0 : _a3.call(options); + } + }); + this.folderCache = new VaultFolderCache(app); + } + initializeInBackground() { + this.fileCache.initializeInBackground(); + this.folderCache.initializeInBackground(); + } + markFilesDirty() { + this.fileCache.markDirty(); + } + markFoldersDirty() { + this.folderCache.markDirty(); + } + getCachedVaultFiles() { + return this.fileCache.getFiles(); + } + getCachedVaultFolders() { + return this.folderCache.getFolders().map((folder) => ({ + name: folder.name, + path: folder.path + })); + } +}; + +// src/utils/contextMentionResolver.ts +var TRAILING_PUNCTUATION_REGEX = /[),.!?:;]+$/; +var BOUNDARY_PUNCTUATION = /* @__PURE__ */ new Set([",", ")", "!", "?", ":", ";"]); +function isWhitespace(char) { + return /\s/.test(char); +} +function collectMentionEndCandidates(text, pathStart) { + const candidates = /* @__PURE__ */ new Set(); + for (let index = pathStart; index < text.length; index++) { + const char = text[index]; + if (isWhitespace(char)) { + candidates.add(index); + continue; + } + if (BOUNDARY_PUNCTUATION.has(char)) { + candidates.add(index + 1); + } + } + candidates.add(text.length); + return Array.from(candidates).sort((a3, b) => b - a3); +} +function isMentionStart(text, index) { + if (text[index] !== "@") return false; + if (index === 0) return true; + return isWhitespace(text[index - 1]); +} +function normalizeMentionPath(pathText) { + return pathText.replace(/\\/g, "/").replace(/^\.?\//, "").replace(/\/+/g, "/").replace(/\/+$/, ""); +} +function normalizeForPlatformLookup(value) { + return process.platform === "win32" ? value.toLowerCase() : value; +} +function buildExternalContextLookup(files) { + const lookup = /* @__PURE__ */ new Map(); + for (const file2 of files) { + const normalized = normalizeMentionPath(file2.relativePath); + if (!normalized) continue; + const key = normalizeForPlatformLookup(normalized); + if (!lookup.has(key)) { + lookup.set(key, file2.path); + } + } + return lookup; +} +function resolveExternalMentionAtIndex(text, mentionStart, contextEntries, getContextLookup) { + const mentionBodyStart = mentionStart + 1; + let bestMatch = null; + for (const entry of contextEntries) { + const displayNameEnd = mentionBodyStart + entry.displayName.length; + if (displayNameEnd >= text.length) continue; + const mentionDisplayName = text.slice(mentionBodyStart, displayNameEnd).toLowerCase(); + if (mentionDisplayName !== entry.displayNameLower) continue; + const separator = text[displayNameEnd]; + if (separator !== "/" && separator !== "\\") continue; + const lookup = getContextLookup(entry.contextRoot); + const match = findBestMentionLookupMatch( + text, + displayNameEnd + 1, + lookup, + normalizeMentionPath, + normalizeForPlatformLookup + ); + if (!match) continue; + if (!bestMatch || match.endIndex > bestMatch.endIndex) { + bestMatch = match; + } + } + return bestMatch; +} +function findBestMentionLookupMatch(text, pathStart, pathLookup, normalizePath, normalizeLookupKey) { + var _a3, _b2; + if (pathLookup.size === 0 || pathStart >= text.length) return null; + const endCandidates = collectMentionEndCandidates(text, pathStart); + for (const endIndex of endCandidates) { + if (endIndex <= pathStart) continue; + const rawPath = text.slice(pathStart, endIndex); + const trailingPunctuation = (_b2 = (_a3 = rawPath.match(TRAILING_PUNCTUATION_REGEX)) == null ? void 0 : _a3[0]) != null ? _b2 : ""; + const rawPathWithoutPunctuation = trailingPunctuation ? rawPath.slice(0, -trailingPunctuation.length) : rawPath; + const normalizedPath = normalizePath(rawPathWithoutPunctuation); + if (!normalizedPath) continue; + const resolvedPath = pathLookup.get(normalizeLookupKey(normalizedPath)); + if (resolvedPath) { + return { + resolvedPath, + endIndex, + trailingPunctuation + }; + } + } + return null; +} +function createExternalContextLookupGetter(getContextFiles) { + const lookupCache = /* @__PURE__ */ new Map(); + return (contextRoot) => { + const cached2 = lookupCache.get(contextRoot); + if (cached2) return cached2; + const lookup = buildExternalContextLookup(getContextFiles(contextRoot)); + lookupCache.set(contextRoot, lookup); + return lookup; + }; +} + +// src/features/chat/ui/FileContext.ts +init_path(); + +// src/features/chat/ui/file-context/state/FileContextState.ts +var FileContextState = class { + constructor() { + this.attachedFiles = /* @__PURE__ */ new Set(); + this.sessionStarted = false; + this.mentionedMcpServers = /* @__PURE__ */ new Set(); + this.currentNoteSent = false; + } + getAttachedFiles() { + return new Set(this.attachedFiles); + } + hasSentCurrentNote() { + return this.currentNoteSent; + } + markCurrentNoteSent() { + this.currentNoteSent = true; + } + isSessionStarted() { + return this.sessionStarted; + } + startSession() { + this.sessionStarted = true; + } + resetForNewConversation() { + this.sessionStarted = false; + this.currentNoteSent = false; + this.attachedFiles.clear(); + this.clearMcpMentions(); + } + resetForLoadedConversation(hasMessages) { + this.currentNoteSent = hasMessages; + this.attachedFiles.clear(); + this.sessionStarted = hasMessages; + this.clearMcpMentions(); + } + setAttachedFiles(files) { + this.attachedFiles.clear(); + for (const file2 of files) { + this.attachedFiles.add(file2); + } + } + attachFile(path19) { + this.attachedFiles.add(path19); + } + detachFile(path19) { + this.attachedFiles.delete(path19); + } + clearAttachments() { + this.attachedFiles.clear(); + } + getMentionedMcpServers() { + return new Set(this.mentionedMcpServers); + } + clearMcpMentions() { + this.mentionedMcpServers.clear(); + } + setMentionedMcpServers(mentions) { + const changed = mentions.size !== this.mentionedMcpServers.size || [...mentions].some((name) => !this.mentionedMcpServers.has(name)); + if (changed) { + this.mentionedMcpServers = new Set(mentions); + } + return changed; + } + addMentionedMcpServer(name) { + this.mentionedMcpServers.add(name); + } +}; + +// src/features/chat/ui/file-context/view/FileChipsView.ts +var import_obsidian33 = require("obsidian"); +var FileChipsView = class { + constructor(containerEl, callbacks) { + this.containerEl = containerEl; + this.callbacks = callbacks; + const firstChild = this.containerEl.firstChild; + this.fileIndicatorEl = this.containerEl.createDiv({ cls: "claudian-file-indicator" }); + if (firstChild) { + this.containerEl.insertBefore(this.fileIndicatorEl, firstChild); + } + } + destroy() { + this.fileIndicatorEl.remove(); + } + renderCurrentNote(filePath) { + this.fileIndicatorEl.empty(); + if (!filePath) { + this.fileIndicatorEl.style.display = "none"; + return; + } + this.fileIndicatorEl.style.display = "flex"; + this.renderFileChip(filePath, () => { + this.callbacks.onRemoveAttachment(filePath); + }); + } + renderFileChip(filePath, onRemove) { + const chipEl = this.fileIndicatorEl.createDiv({ cls: "claudian-file-chip" }); + const iconEl = chipEl.createSpan({ cls: "claudian-file-chip-icon" }); + (0, import_obsidian33.setIcon)(iconEl, "file-text"); + const normalizedPath = filePath.replace(/\\/g, "/"); + const filename = normalizedPath.split("/").pop() || filePath; + const nameEl = chipEl.createSpan({ cls: "claudian-file-chip-name" }); + nameEl.setText(filename); + nameEl.setAttribute("title", filePath); + const removeEl = chipEl.createSpan({ cls: "claudian-file-chip-remove" }); + removeEl.setText("\xD7"); + removeEl.setAttribute("aria-label", "Remove"); + chipEl.addEventListener("click", (e3) => { + if (!e3.target.closest(".claudian-file-chip-remove")) { + this.callbacks.onOpenFile(filePath); + } + }); + removeEl.addEventListener("click", () => { + onRemove(); + }); + } +}; + +// src/features/chat/ui/FileContext.ts +var FileContextManager = class { + constructor(app, chipsContainerEl, inputEl, callbacks, dropdownContainerEl) { + this.deleteEventRef = null; + this.renameEventRef = null; + // Current note (shown as chip) + this.currentNotePath = null; + // MCP server support + this.onMcpMentionChange = null; + this.app = app; + this.chipsContainerEl = chipsContainerEl; + this.dropdownContainerEl = dropdownContainerEl != null ? dropdownContainerEl : chipsContainerEl; + this.inputEl = inputEl; + this.callbacks = callbacks; + this.state = new FileContextState(); + this.mentionDataProvider = new VaultMentionDataProvider(this.app); + this.mentionDataProvider.initializeInBackground(); + this.chipsView = new FileChipsView(this.chipsContainerEl, { + onRemoveAttachment: (filePath) => { + if (filePath === this.currentNotePath) { + this.currentNotePath = null; + this.state.detachFile(filePath); + this.refreshCurrentNoteChip(); + } + }, + onOpenFile: async (filePath) => { + const file2 = this.app.vault.getAbstractFileByPath(filePath); + if (!(file2 instanceof import_obsidian34.TFile)) { + new import_obsidian34.Notice(`Could not open file: ${filePath}`); + return; + } + try { + await this.app.workspace.getLeaf().openFile(file2); + } catch (error48) { + new import_obsidian34.Notice(`Failed to open file: ${error48 instanceof Error ? error48.message : String(error48)}`); + } + } + }); + this.mentionDropdown = new MentionDropdownController( + this.dropdownContainerEl, + this.inputEl, + { + onAttachFile: (filePath) => this.state.attachFile(filePath), + onMcpMentionChange: (servers) => { + var _a3; + return (_a3 = this.onMcpMentionChange) == null ? void 0 : _a3.call(this, servers); + }, + onAgentMentionSelect: (agentId) => { + var _a3, _b2; + return (_b2 = (_a3 = this.callbacks).onAgentMentionSelect) == null ? void 0 : _b2.call(_a3, agentId); + }, + getMentionedMcpServers: () => this.state.getMentionedMcpServers(), + setMentionedMcpServers: (mentions) => this.state.setMentionedMcpServers(mentions), + addMentionedMcpServer: (name) => this.state.addMentionedMcpServer(name), + getExternalContexts: () => { + var _a3, _b2; + return ((_b2 = (_a3 = this.callbacks).getExternalContexts) == null ? void 0 : _b2.call(_a3)) || []; + }, + getCachedVaultFolders: () => this.mentionDataProvider.getCachedVaultFolders(), + getCachedVaultFiles: () => this.mentionDataProvider.getCachedVaultFiles(), + normalizePathForVault: (rawPath) => this.normalizePathForVault(rawPath) + } + ); + this.deleteEventRef = this.app.vault.on("delete", (file2) => { + if (file2 instanceof import_obsidian34.TFile) this.handleFileDeleted(file2.path); + }); + this.renameEventRef = this.app.vault.on("rename", (file2, oldPath) => { + if (file2 instanceof import_obsidian34.TFile) this.handleFileRenamed(oldPath, file2.path); + }); + } + /** Returns the current note path (shown as chip). */ + getCurrentNotePath() { + return this.currentNotePath; + } + getAttachedFiles() { + return this.state.getAttachedFiles(); + } + /** Checks whether current note should be sent for this session. */ + shouldSendCurrentNote(notePath) { + const resolvedPath = notePath != null ? notePath : this.currentNotePath; + return !!resolvedPath && !this.state.hasSentCurrentNote(); + } + /** Marks current note as sent (call after sending a message). */ + markCurrentNoteSent() { + this.state.markCurrentNoteSent(); + } + isSessionStarted() { + return this.state.isSessionStarted(); + } + startSession() { + this.state.startSession(); + } + /** Resets state for a new conversation. */ + resetForNewConversation() { + this.currentNotePath = null; + this.state.resetForNewConversation(); + this.refreshCurrentNoteChip(); + } + /** Resets state for loading an existing conversation. */ + resetForLoadedConversation(hasMessages) { + this.currentNotePath = null; + this.state.resetForLoadedConversation(hasMessages); + this.refreshCurrentNoteChip(); + } + /** Sets current note (for restoring persisted state). */ + setCurrentNote(notePath) { + this.currentNotePath = notePath; + if (notePath) { + this.state.attachFile(notePath); + } + this.refreshCurrentNoteChip(); + } + /** Auto-attaches the currently focused file (for new sessions). */ + autoAttachActiveFile() { + const activeFile = this.app.workspace.getActiveFile(); + if (activeFile && !this.hasExcludedTag(activeFile)) { + const normalizedPath = this.normalizePathForVault(activeFile.path); + if (normalizedPath) { + this.currentNotePath = normalizedPath; + this.state.attachFile(normalizedPath); + this.refreshCurrentNoteChip(); + } + } + } + /** Handles file open event. */ + handleFileOpen(file2) { + const normalizedPath = this.normalizePathForVault(file2.path); + if (!normalizedPath) return; + if (!this.state.isSessionStarted()) { + this.state.clearAttachments(); + if (!this.hasExcludedTag(file2)) { + this.currentNotePath = normalizedPath; + this.state.attachFile(normalizedPath); + } else { + this.currentNotePath = null; + } + this.refreshCurrentNoteChip(); + } + } + markFileCacheDirty() { + this.mentionDataProvider.markFilesDirty(); + } + markFolderCacheDirty() { + this.mentionDataProvider.markFoldersDirty(); + } + /** Handles input changes to detect @ mentions. */ + handleInputChange() { + this.mentionDropdown.handleInputChange(); + } + /** Handles keyboard navigation in mention dropdown. Returns true if handled. */ + handleMentionKeydown(e3) { + return this.mentionDropdown.handleKeydown(e3); + } + isMentionDropdownVisible() { + return this.mentionDropdown.isVisible(); + } + hideMentionDropdown() { + this.mentionDropdown.hide(); + } + containsElement(el2) { + return this.mentionDropdown.containsElement(el2); + } + transformContextMentions(text) { + var _a3, _b2; + const externalContexts = ((_b2 = (_a3 = this.callbacks).getExternalContexts) == null ? void 0 : _b2.call(_a3)) || []; + if (externalContexts.length === 0 || !text.includes("@")) return text; + const contextEntries = buildExternalContextDisplayEntries(externalContexts).sort((a3, b) => b.displayNameLower.length - a3.displayNameLower.length); + const getContextLookup = createExternalContextLookupGetter( + (contextRoot) => externalContextScanner.scanPaths([contextRoot]) + ); + let replaced = false; + let cursor = 0; + const chunks = []; + for (let index = 0; index < text.length; index++) { + if (!isMentionStart(text, index)) continue; + const resolved = resolveExternalMentionAtIndex(text, index, contextEntries, getContextLookup); + if (!resolved) continue; + chunks.push(text.slice(cursor, index)); + chunks.push(`${resolved.resolvedPath}${resolved.trailingPunctuation}`); + cursor = resolved.endIndex; + index = resolved.endIndex - 1; + replaced = true; + } + if (!replaced) return text; + chunks.push(text.slice(cursor)); + return chunks.join(""); + } + /** Cleans up event listeners (call on view close). */ + destroy() { + if (this.deleteEventRef) this.app.vault.offref(this.deleteEventRef); + if (this.renameEventRef) this.app.vault.offref(this.renameEventRef); + this.mentionDropdown.destroy(); + this.chipsView.destroy(); + } + /** Normalizes a file path to be vault-relative with forward slashes. */ + normalizePathForVault(rawPath) { + const vaultPath = getVaultPath(this.app); + return normalizePathForVault(rawPath, vaultPath); + } + refreshCurrentNoteChip() { + var _a3, _b2; + this.chipsView.renderCurrentNote(this.currentNotePath); + (_b2 = (_a3 = this.callbacks).onChipsChanged) == null ? void 0 : _b2.call(_a3); + } + handleFileRenamed(oldPath, newPath) { + const normalizedOld = this.normalizePathForVault(oldPath); + const normalizedNew = this.normalizePathForVault(newPath); + if (!normalizedOld) return; + let needsUpdate = false; + if (this.currentNotePath === normalizedOld) { + this.currentNotePath = normalizedNew; + needsUpdate = true; + } + if (this.state.getAttachedFiles().has(normalizedOld)) { + this.state.detachFile(normalizedOld); + if (normalizedNew) { + this.state.attachFile(normalizedNew); + } + needsUpdate = true; + } + if (needsUpdate) { + this.refreshCurrentNoteChip(); + } + } + handleFileDeleted(deletedPath) { + const normalized = this.normalizePathForVault(deletedPath); + if (!normalized) return; + let needsUpdate = false; + if (this.currentNotePath === normalized) { + this.currentNotePath = null; + needsUpdate = true; + } + if (this.state.getAttachedFiles().has(normalized)) { + this.state.detachFile(normalized); + needsUpdate = true; + } + if (needsUpdate) { + this.refreshCurrentNoteChip(); + } + } + // ======================================== + // MCP Server Support + // ======================================== + setMcpManager(manager) { + this.mentionDropdown.setMcpManager(manager); + } + setAgentService(agentService) { + this.mentionDropdown.setAgentService(agentService); + } + setOnMcpMentionChange(callback) { + this.onMcpMentionChange = callback; + } + /** + * Pre-scans external context paths in the background to warm the cache. + * Should be called when external context paths are added/changed. + */ + preScanExternalContexts() { + this.mentionDropdown.preScanExternalContexts(); + } + getMentionedMcpServers() { + return this.state.getMentionedMcpServers(); + } + clearMcpMentions() { + this.state.clearMcpMentions(); + } + updateMcpMentionsFromText(text) { + this.mentionDropdown.updateMcpMentionsFromText(text); + } + hasExcludedTag(file2) { + var _a3; + const excludedTags = this.callbacks.getExcludedTags(); + if (excludedTags.length === 0) return false; + const cache = this.app.metadataCache.getFileCache(file2); + if (!cache) return false; + const fileTags = []; + if ((_a3 = cache.frontmatter) == null ? void 0 : _a3.tags) { + const fmTags = cache.frontmatter.tags; + if (Array.isArray(fmTags)) { + fileTags.push(...fmTags.map((t3) => t3.replace(/^#/, ""))); + } else if (typeof fmTags === "string") { + fileTags.push(fmTags.replace(/^#/, "")); + } + } + if (cache.tags) { + fileTags.push(...cache.tags.map((t3) => t3.tag.replace(/^#/, ""))); + } + return fileTags.some((tag) => excludedTags.includes(tag)); + } +}; + +// src/features/chat/ui/ImageContext.ts +var import_obsidian35 = require("obsidian"); +var path17 = __toESM(require("path")); +var MAX_IMAGE_SIZE = 5 * 1024 * 1024; +var IMAGE_EXTENSIONS2 = { + ".jpg": "image/jpeg", + ".jpeg": "image/jpeg", + ".png": "image/png", + ".gif": "image/gif", + ".webp": "image/webp" +}; +var ImageContextManager = class { + constructor(containerEl, inputEl, callbacks, previewContainerEl) { + this.dropOverlay = null; + this.attachedImages = /* @__PURE__ */ new Map(); + this.enabled = true; + this.containerEl = containerEl; + this.previewContainerEl = previewContainerEl != null ? previewContainerEl : containerEl; + this.inputEl = inputEl; + this.callbacks = callbacks; + const fileIndicator = this.previewContainerEl.querySelector(".claudian-file-indicator"); + this.imagePreviewEl = this.previewContainerEl.createDiv({ cls: "claudian-image-preview" }); + if (fileIndicator && fileIndicator.parentElement === this.previewContainerEl) { + this.previewContainerEl.insertBefore(this.imagePreviewEl, fileIndicator); + } + this.setupDragAndDrop(); + this.setupPasteHandler(); + } + setEnabled(enabled) { + this.enabled = enabled; + if (!enabled && this.attachedImages.size > 0) { + this.clearImages(); + } + } + getAttachedImages() { + return Array.from(this.attachedImages.values()); + } + hasImages() { + return this.attachedImages.size > 0; + } + clearImages() { + this.attachedImages.clear(); + this.updateImagePreview(); + this.callbacks.onImagesChanged(); + } + /** Sets images directly (used for queued messages). */ + setImages(images) { + this.attachedImages.clear(); + for (const image of images) { + this.attachedImages.set(image.id, image); + } + this.updateImagePreview(); + this.callbacks.onImagesChanged(); + } + setupDragAndDrop() { + const inputWrapper = this.containerEl.querySelector(".claudian-input-wrapper"); + if (!inputWrapper) return; + this.dropOverlay = inputWrapper.createDiv({ cls: "claudian-drop-overlay" }); + const dropContent = this.dropOverlay.createDiv({ cls: "claudian-drop-content" }); + const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg"); + svg.setAttribute("viewBox", "0 0 24 24"); + svg.setAttribute("width", "32"); + svg.setAttribute("height", "32"); + svg.setAttribute("fill", "none"); + svg.setAttribute("stroke", "currentColor"); + svg.setAttribute("stroke-width", "2"); + const pathEl = document.createElementNS("http://www.w3.org/2000/svg", "path"); + pathEl.setAttribute("d", "M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"); + const polyline = document.createElementNS("http://www.w3.org/2000/svg", "polyline"); + polyline.setAttribute("points", "17 8 12 3 7 8"); + const line = document.createElementNS("http://www.w3.org/2000/svg", "line"); + line.setAttribute("x1", "12"); + line.setAttribute("y1", "3"); + line.setAttribute("x2", "12"); + line.setAttribute("y2", "15"); + svg.appendChild(pathEl); + svg.appendChild(polyline); + svg.appendChild(line); + dropContent.appendChild(svg); + dropContent.createSpan({ text: "Drop image here" }); + const dropZone = inputWrapper; + dropZone.addEventListener("dragenter", (e3) => this.handleDragEnter(e3)); + dropZone.addEventListener("dragover", (e3) => this.handleDragOver(e3)); + dropZone.addEventListener("dragleave", (e3) => this.handleDragLeave(e3)); + dropZone.addEventListener("drop", (e3) => this.handleDrop(e3)); + } + handleDragEnter(e3) { + var _a3, _b2; + e3.preventDefault(); + e3.stopPropagation(); + if ((_a3 = e3.dataTransfer) == null ? void 0 : _a3.types.includes("Files")) { + (_b2 = this.dropOverlay) == null ? void 0 : _b2.addClass("visible"); + } + } + handleDragOver(e3) { + e3.preventDefault(); + e3.stopPropagation(); + } + handleDragLeave(e3) { + var _a3, _b2; + e3.preventDefault(); + e3.stopPropagation(); + const inputWrapper = this.containerEl.querySelector(".claudian-input-wrapper"); + if (!inputWrapper) { + (_a3 = this.dropOverlay) == null ? void 0 : _a3.removeClass("visible"); + return; + } + const rect = inputWrapper.getBoundingClientRect(); + if (e3.clientX <= rect.left || e3.clientX >= rect.right || e3.clientY <= rect.top || e3.clientY >= rect.bottom) { + (_b2 = this.dropOverlay) == null ? void 0 : _b2.removeClass("visible"); + } + } + async handleDrop(e3) { + var _a3, _b2; + e3.preventDefault(); + e3.stopPropagation(); + (_a3 = this.dropOverlay) == null ? void 0 : _a3.removeClass("visible"); + const files = (_b2 = e3.dataTransfer) == null ? void 0 : _b2.files; + if (!files) return; + for (let i3 = 0; i3 < files.length; i3++) { + const file2 = files[i3]; + if (this.isImageFile(file2)) { + await this.addImageFromFile(file2, "drop"); + } + } + } + setupPasteHandler() { + this.inputEl.addEventListener("paste", async (e3) => { + var _a3; + const items = (_a3 = e3.clipboardData) == null ? void 0 : _a3.items; + if (!items) return; + for (let i3 = 0; i3 < items.length; i3++) { + const item = items[i3]; + if (item.type.startsWith("image/")) { + e3.preventDefault(); + const file2 = item.getAsFile(); + if (file2) { + await this.addImageFromFile(file2, "paste"); + } + return; + } + } + }); + } + isImageFile(file2) { + return file2.type.startsWith("image/") && this.getMediaType(file2.name) !== null; + } + getMediaType(filename) { + const ext = path17.extname(filename).toLowerCase(); + return IMAGE_EXTENSIONS2[ext] || null; + } + async addImageFromFile(file2, source) { + if (!this.enabled) { + new import_obsidian35.Notice("Image attachments are not supported by this provider."); + return false; + } + if (file2.size > MAX_IMAGE_SIZE) { + this.notifyImageError(`Image exceeds ${this.formatSize(MAX_IMAGE_SIZE)} limit.`); + return false; + } + const mediaType = this.getMediaType(file2.name) || file2.type; + if (!mediaType) { + this.notifyImageError("Unsupported image type."); + return false; + } + try { + const base643 = await this.fileToBase64(file2); + const attachment = { + id: this.generateId(), + name: file2.name || `image-${Date.now()}.${mediaType.split("/")[1]}`, + mediaType, + data: base643, + size: file2.size, + source + }; + this.attachedImages.set(attachment.id, attachment); + this.updateImagePreview(); + this.callbacks.onImagesChanged(); + return true; + } catch (error48) { + this.notifyImageError("Failed to attach image.", error48); + return false; + } + } + async fileToBase64(file2) { + const arrayBuffer = await file2.arrayBuffer(); + const buffer = Buffer.from(arrayBuffer); + return buffer.toString("base64"); + } + // ============================================ + // Private: Image Preview + // ============================================ + updateImagePreview() { + this.imagePreviewEl.empty(); + if (this.attachedImages.size === 0) { + this.imagePreviewEl.style.display = "none"; + return; + } + this.imagePreviewEl.style.display = "flex"; + for (const [id, image] of this.attachedImages) { + this.renderImagePreview(id, image); + } + } + renderImagePreview(id, image) { + const previewEl = this.imagePreviewEl.createDiv({ cls: "claudian-image-chip" }); + const thumbEl = previewEl.createDiv({ cls: "claudian-image-thumb" }); + thumbEl.createEl("img", { + attr: { + src: `data:${image.mediaType};base64,${image.data}`, + alt: image.name + } + }); + const infoEl = previewEl.createDiv({ cls: "claudian-image-info" }); + const nameEl = infoEl.createSpan({ cls: "claudian-image-name" }); + nameEl.setText(this.truncateName(image.name, 20)); + nameEl.setAttribute("title", image.name); + const sizeEl = infoEl.createSpan({ cls: "claudian-image-size" }); + sizeEl.setText(this.formatSize(image.size)); + const removeEl = previewEl.createSpan({ cls: "claudian-image-remove" }); + removeEl.setText("\xD7"); + removeEl.setAttribute("aria-label", "Remove image"); + removeEl.addEventListener("click", (e3) => { + e3.stopPropagation(); + this.attachedImages.delete(id); + this.updateImagePreview(); + this.callbacks.onImagesChanged(); + }); + thumbEl.addEventListener("click", () => { + this.showFullImage(image); + }); + } + showFullImage(image) { + const overlay = document.body.createDiv({ cls: "claudian-image-modal-overlay" }); + const modal = overlay.createDiv({ cls: "claudian-image-modal" }); + modal.createEl("img", { + attr: { + src: `data:${image.mediaType};base64,${image.data}`, + alt: image.name + } + }); + const closeBtn = modal.createDiv({ cls: "claudian-image-modal-close" }); + closeBtn.setText("\xD7"); + const handleEsc = (e3) => { + if (e3.key === "Escape") { + close(); + } + }; + const close = () => { + document.removeEventListener("keydown", handleEsc); + overlay.remove(); + }; + closeBtn.addEventListener("click", close); + overlay.addEventListener("click", (e3) => { + if (e3.target === overlay) close(); + }); + document.addEventListener("keydown", handleEsc); + } + generateId() { + return `img-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`; + } + truncateName(name, maxLen) { + if (name.length <= maxLen) return name; + const ext = path17.extname(name); + const base = name.slice(0, name.length - ext.length); + const truncatedBase = base.slice(0, maxLen - ext.length - 3); + return `${truncatedBase}...${ext}`; + } + formatSize(bytes) { + if (bytes < 1024) return `${bytes} B`; + if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`; + return `${(bytes / (1024 * 1024)).toFixed(1)} MB`; + } + notifyImageError(message, error48) { + let userMessage = message; + if (error48 instanceof Error) { + if (error48.message.includes("ENOENT") || error48.message.includes("no such file")) { + userMessage = `${message} (File not found)`; + } else if (error48.message.includes("EACCES") || error48.message.includes("permission denied")) { + userMessage = `${message} (Permission denied)`; + } + } + new import_obsidian35.Notice(userMessage); + } +}; + +// src/features/chat/ui/InputToolbar.ts +var import_obsidian36 = require("obsidian"); +var path18 = __toESM(require("path")); +init_path(); +var ModelSelector = class { + constructor(parentEl, callbacks) { + this.buttonEl = null; + this.dropdownEl = null; + this.callbacks = callbacks; + this.container = parentEl.createDiv({ cls: "claudian-model-selector" }); + this.render(); + } + getAvailableModels() { + var _a3, _b2; + const settings11 = this.callbacks.getSettings(); + const uiConfig = this.callbacks.getUIConfig(); + return uiConfig.getModelOptions({ + ...settings11, + environmentVariables: (_b2 = (_a3 = this.callbacks).getEnvironmentVariables) == null ? void 0 : _b2.call(_a3) + }); + } + render() { + this.container.empty(); + this.buttonEl = this.container.createDiv({ cls: "claudian-model-btn" }); + this.updateDisplay(); + this.dropdownEl = this.container.createDiv({ cls: "claudian-model-dropdown" }); + this.renderOptions(); + } + updateDisplay() { + if (!this.buttonEl) return; + const currentModel = this.callbacks.getSettings().model; + const models = this.getAvailableModels(); + const modelInfo = models.find((m3) => m3.value === currentModel); + const displayModel = modelInfo || models[0]; + this.buttonEl.empty(); + const labelEl = this.buttonEl.createSpan({ cls: "claudian-model-label" }); + labelEl.setText((displayModel == null ? void 0 : displayModel.label) || "Unknown"); + } + renderOptions() { + var _a3, _b2, _c; + if (!this.dropdownEl) return; + this.dropdownEl.empty(); + const currentModel = this.callbacks.getSettings().model; + const models = this.getAvailableModels(); + const reversed = [...models].reverse(); + let lastGroup; + for (const model of reversed) { + if (model.group && model.group !== lastGroup) { + const separator = this.dropdownEl.createDiv({ cls: "claudian-model-group" }); + separator.setText(model.group); + lastGroup = model.group; + } + const option = this.dropdownEl.createDiv({ cls: "claudian-model-option" }); + if (model.value === currentModel) { + option.addClass("selected"); + } + const icon = (_c = model.providerIcon) != null ? _c : (_b2 = (_a3 = this.callbacks.getUIConfig()).getProviderIcon) == null ? void 0 : _b2.call(_a3); + if (icon) { + option.appendChild(createProviderIconSvg(icon)); + } + option.createSpan({ text: model.label }); + if (model.description) { + option.setAttribute("title", model.description); + } + option.addEventListener("click", async (e3) => { + e3.stopPropagation(); + await this.callbacks.onModelChange(model.value); + this.updateDisplay(); + this.renderOptions(); + }); + } + } +}; +function createProviderIconSvg(icon) { + const NS = "http://www.w3.org/2000/svg"; + const svg = document.createElementNS(NS, "svg"); + svg.setAttribute("viewBox", icon.viewBox); + svg.setAttribute("width", "12"); + svg.setAttribute("height", "12"); + svg.classList.add("claudian-model-provider-icon"); + const path19 = document.createElementNS(NS, "path"); + path19.setAttribute("d", icon.path); + path19.setAttribute("fill", "currentColor"); + svg.appendChild(path19); + return svg; +} +var ThinkingBudgetSelector = class { + constructor(parentEl, callbacks) { + this.effortEl = null; + this.effortGearsEl = null; + this.budgetEl = null; + this.budgetGearsEl = null; + this.callbacks = callbacks; + this.container = parentEl.createDiv({ cls: "claudian-thinking-selector" }); + this.render(); + } + render() { + this.container.empty(); + this.effortEl = this.container.createDiv({ cls: "claudian-thinking-effort" }); + const effortLabel = this.effortEl.createSpan({ cls: "claudian-thinking-label-text" }); + effortLabel.setText("Effort:"); + this.effortGearsEl = this.effortEl.createDiv({ cls: "claudian-thinking-gears" }); + this.budgetEl = this.container.createDiv({ cls: "claudian-thinking-budget" }); + const budgetLabel = this.budgetEl.createSpan({ cls: "claudian-thinking-label-text" }); + budgetLabel.setText("Thinking:"); + this.budgetGearsEl = this.budgetEl.createDiv({ cls: "claudian-thinking-gears" }); + this.updateDisplay(); + } + renderEffortGears() { + if (!this.effortGearsEl) return; + this.effortGearsEl.empty(); + const currentEffort = this.callbacks.getSettings().effortLevel; + const uiConfig = this.callbacks.getUIConfig(); + const model = this.callbacks.getSettings().model; + const options = uiConfig.getReasoningOptions(model); + const currentInfo = options.find((e3) => e3.value === currentEffort); + const currentEl = this.effortGearsEl.createDiv({ cls: "claudian-thinking-current" }); + currentEl.setText((currentInfo == null ? void 0 : currentInfo.label) || "High"); + const optionsEl = this.effortGearsEl.createDiv({ cls: "claudian-thinking-options" }); + for (const effort of [...options].reverse()) { + const gearEl = optionsEl.createDiv({ cls: "claudian-thinking-gear" }); + gearEl.setText(effort.label); + if (effort.value === currentEffort) { + gearEl.addClass("selected"); + } + gearEl.addEventListener("click", async (e3) => { + e3.stopPropagation(); + await this.callbacks.onEffortLevelChange(effort.value); + this.updateDisplay(); + }); + } + } + renderBudgetGears() { + var _a3; + if (!this.budgetGearsEl) return; + this.budgetGearsEl.empty(); + const currentBudget = this.callbacks.getSettings().thinkingBudget; + const uiConfig = this.callbacks.getUIConfig(); + const model = this.callbacks.getSettings().model; + const options = uiConfig.getReasoningOptions(model); + const currentBudgetInfo = options.find((b) => b.value === currentBudget); + const currentEl = this.budgetGearsEl.createDiv({ cls: "claudian-thinking-current" }); + currentEl.setText((currentBudgetInfo == null ? void 0 : currentBudgetInfo.label) || "Off"); + const optionsEl = this.budgetGearsEl.createDiv({ cls: "claudian-thinking-options" }); + for (const budget of [...options].reverse()) { + const gearEl = optionsEl.createDiv({ cls: "claudian-thinking-gear" }); + gearEl.setText(budget.label); + const tokens = (_a3 = budget.tokens) != null ? _a3 : 0; + gearEl.setAttribute("title", tokens > 0 ? `${tokens.toLocaleString()} tokens` : "Disabled"); + if (budget.value === currentBudget) { + gearEl.addClass("selected"); + } + gearEl.addEventListener("click", async (e3) => { + e3.stopPropagation(); + await this.callbacks.onThinkingBudgetChange(budget.value); + this.updateDisplay(); + }); + } + } + updateDisplay() { + const capabilities = this.callbacks.getCapabilities(); + if (capabilities.reasoningControl === "none") { + if (this.effortEl) this.effortEl.style.display = "none"; + if (this.budgetEl) this.budgetEl.style.display = "none"; + return; + } + const model = this.callbacks.getSettings().model; + const uiConfig = this.callbacks.getUIConfig(); + const adaptive = uiConfig.isAdaptiveReasoningModel(model); + if (this.effortEl) { + this.effortEl.style.display = adaptive ? "" : "none"; + } + if (this.budgetEl) { + this.budgetEl.style.display = adaptive ? "none" : ""; + } + if (adaptive) { + this.renderEffortGears(); + } else { + this.renderBudgetGears(); + } + } +}; +var PermissionToggle = class { + constructor(parentEl, callbacks) { + this.toggleEl = null; + this.labelEl = null; + this.callbacks = callbacks; + this.container = parentEl.createDiv({ cls: "claudian-permission-toggle" }); + this.render(); + } + render() { + this.container.empty(); + this.labelEl = this.container.createSpan({ cls: "claudian-permission-label" }); + this.toggleEl = this.container.createDiv({ cls: "claudian-toggle-switch" }); + this.updateDisplay(); + this.toggleEl.addEventListener("click", () => this.toggle()); + } + getToggleConfig() { + var _a3, _b2; + const uiConfig = this.callbacks.getUIConfig(); + return (_b2 = (_a3 = uiConfig.getPermissionModeToggle) == null ? void 0 : _a3.call(uiConfig)) != null ? _b2 : null; + } + updateDisplay() { + var _a3; + if (!this.toggleEl || !this.labelEl) return; + const toggleConfig = this.getToggleConfig(); + const capabilities = this.callbacks.getCapabilities(); + if (!toggleConfig) { + this.container.style.display = "none"; + return; + } + this.container.style.display = ""; + const mode = this.callbacks.getSettings().permissionMode; + const planValue = toggleConfig.planValue; + const planLabel = (_a3 = toggleConfig.planLabel) != null ? _a3 : "PLAN"; + const canShowPlan = Boolean(planValue) && capabilities.supportsPlanMode; + if (canShowPlan && planValue && mode === planValue) { + this.toggleEl.style.display = "none"; + this.labelEl.setText(planLabel); + this.labelEl.addClass("plan-active"); + } else { + this.toggleEl.style.display = ""; + this.labelEl.removeClass("plan-active"); + if (mode === toggleConfig.activeValue) { + this.toggleEl.addClass("active"); + this.labelEl.setText(toggleConfig.activeLabel); + } else { + this.toggleEl.removeClass("active"); + this.labelEl.setText(toggleConfig.inactiveLabel); + } + } + } + async toggle() { + const toggleConfig = this.getToggleConfig(); + if (!toggleConfig) return; + const current = this.callbacks.getSettings().permissionMode; + const newMode = current === toggleConfig.activeValue ? toggleConfig.inactiveValue : toggleConfig.activeValue; + await this.callbacks.onPermissionModeChange(newMode); + this.updateDisplay(); + } +}; +var ServiceTierToggle = class { + constructor(parentEl, callbacks) { + this.buttonEl = null; + this.iconEl = null; + this.callbacks = callbacks; + this.container = parentEl.createDiv({ cls: "claudian-service-tier-toggle" }); + this.render(); + } + render() { + this.container.empty(); + this.buttonEl = this.container.createDiv({ cls: "claudian-service-tier-button" }); + this.iconEl = this.buttonEl.createSpan({ cls: "claudian-service-tier-icon" }); + (0, import_obsidian36.setIcon)(this.iconEl, "zap"); + this.updateDisplay(); + this.buttonEl.addEventListener("click", () => this.toggle()); + } + getToggleConfig() { + var _a3, _b2; + const uiConfig = this.callbacks.getUIConfig(); + return (_b2 = (_a3 = uiConfig.getServiceTierToggle) == null ? void 0 : _a3.call(uiConfig, this.callbacks.getSettings())) != null ? _b2 : null; + } + updateDisplay() { + if (!this.buttonEl || !this.iconEl) return; + const toggleConfig = this.getToggleConfig(); + if (!toggleConfig) { + this.container.style.display = "none"; + return; + } + this.container.style.display = ""; + const current = this.callbacks.getSettings().serviceTier; + const isActive = current === toggleConfig.activeValue; + if (isActive) { + this.buttonEl.addClass("active"); + } else { + this.buttonEl.removeClass("active"); + } + this.container.setAttribute("title", "Toggle on/off fast mode"); + } + async toggle() { + const toggleConfig = this.getToggleConfig(); + if (!toggleConfig) return; + const current = this.callbacks.getSettings().serviceTier; + const next = current === toggleConfig.activeValue ? toggleConfig.inactiveValue : toggleConfig.activeValue; + await this.callbacks.onServiceTierChange(next); + this.updateDisplay(); + } +}; +var ExternalContextSelector = class { + constructor(parentEl, callbacks) { + this.iconEl = null; + this.badgeEl = null; + this.dropdownEl = null; + /** + * Current external context paths. May contain: + * - Persistent paths only (new sessions via clearExternalContexts) + * - Restored session paths (loaded sessions via setExternalContexts) + * - Mixed paths during active sessions + */ + this.externalContextPaths = []; + /** Paths that persist across all sessions (stored in settings). */ + this.persistentPaths = /* @__PURE__ */ new Set(); + this.onChangeCallback = null; + this.onPersistenceChangeCallback = null; + this.callbacks = callbacks; + this.container = parentEl.createDiv({ cls: "claudian-external-context-selector" }); + this.render(); + } + setOnChange(callback) { + this.onChangeCallback = callback; + } + setOnPersistenceChange(callback) { + this.onPersistenceChangeCallback = callback; + } + getExternalContexts() { + return [...this.externalContextPaths]; + } + getPersistentPaths() { + return [...this.persistentPaths]; + } + setPersistentPaths(paths) { + var _a3; + const validPaths = filterValidPaths(paths); + const invalidPaths = paths.filter((p) => !validPaths.includes(p)); + this.persistentPaths = new Set(validPaths); + this.mergePersistentPaths(); + this.updateDisplay(); + this.renderDropdown(); + if (invalidPaths.length > 0) { + const pathNames = invalidPaths.map((p) => this.shortenPath(p)).join(", "); + new import_obsidian36.Notice(`Removed ${invalidPaths.length} invalid external context path(s): ${pathNames}`, 5e3); + (_a3 = this.onPersistenceChangeCallback) == null ? void 0 : _a3.call(this, [...this.persistentPaths]); + } + } + togglePersistence(path19) { + var _a3; + if (this.persistentPaths.has(path19)) { + this.persistentPaths.delete(path19); + } else { + if (!isValidDirectoryPath(path19)) { + new import_obsidian36.Notice(`Cannot persist "${this.shortenPath(path19)}" - directory no longer exists`, 4e3); + return; + } + this.persistentPaths.add(path19); + } + (_a3 = this.onPersistenceChangeCallback) == null ? void 0 : _a3.call(this, [...this.persistentPaths]); + this.renderDropdown(); + } + mergePersistentPaths() { + const pathSet = new Set(this.externalContextPaths); + for (const path19 of this.persistentPaths) { + pathSet.add(path19); + } + this.externalContextPaths = [...pathSet]; + } + /** + * Restore exact external context paths from a saved conversation. + * Does NOT merge with persistent paths - preserves the session's historical state. + * Use clearExternalContexts() for new sessions to start with current persistent paths. + */ + setExternalContexts(paths) { + this.externalContextPaths = [...paths]; + this.updateDisplay(); + this.renderDropdown(); + } + /** + * Remove a path from external contexts (and persistent paths if applicable). + * Exposed for testing the remove button behavior. + */ + removePath(pathStr) { + var _a3, _b2; + this.externalContextPaths = this.externalContextPaths.filter((p) => p !== pathStr); + if (this.persistentPaths.has(pathStr)) { + this.persistentPaths.delete(pathStr); + (_a3 = this.onPersistenceChangeCallback) == null ? void 0 : _a3.call(this, [...this.persistentPaths]); + } + (_b2 = this.onChangeCallback) == null ? void 0 : _b2.call(this, this.externalContextPaths); + this.updateDisplay(); + this.renderDropdown(); + } + /** + * Add an external context path programmatically (e.g., from /add-dir command). + * Validates the path and handles duplicates/conflicts. + * @param pathInput - Path string (supports ~/ expansion) + * @returns Result with success status and normalized path, or error message on failure + */ + addExternalContext(pathInput) { + var _a3; + const trimmed = pathInput == null ? void 0 : pathInput.trim(); + if (!trimmed) { + return { success: false, error: "No path provided. Usage: /add-dir /absolute/path" }; + } + let cleanPath = trimmed; + if (cleanPath.startsWith('"') && cleanPath.endsWith('"') || cleanPath.startsWith("'") && cleanPath.endsWith("'")) { + cleanPath = cleanPath.slice(1, -1); + } + const expandedPath = expandHomePath(cleanPath); + const normalizedPath = normalizePathForFilesystem(expandedPath); + if (!path18.isAbsolute(normalizedPath)) { + return { success: false, error: "Path must be absolute. Usage: /add-dir /absolute/path" }; + } + const validation = validateDirectoryPath(normalizedPath); + if (!validation.valid) { + return { success: false, error: `${validation.error}: ${pathInput}` }; + } + if (isDuplicatePath(normalizedPath, this.externalContextPaths)) { + return { success: false, error: "This folder is already added as an external context." }; + } + const conflict = findConflictingPath(normalizedPath, this.externalContextPaths); + if (conflict) { + return { success: false, error: this.formatConflictMessage(normalizedPath, conflict) }; + } + this.externalContextPaths = [...this.externalContextPaths, normalizedPath]; + (_a3 = this.onChangeCallback) == null ? void 0 : _a3.call(this, this.externalContextPaths); + this.updateDisplay(); + this.renderDropdown(); + return { success: true, normalizedPath }; + } + /** + * Clear session-only external context paths (call on new conversation). + * Uses persistent paths from settings if provided, otherwise falls back to local cache. + * Validates paths before using them (silently filters invalid during session init). + */ + clearExternalContexts(persistentPathsFromSettings) { + if (persistentPathsFromSettings) { + const validPaths = filterValidPaths(persistentPathsFromSettings); + this.persistentPaths = new Set(validPaths); + } + this.externalContextPaths = [...this.persistentPaths]; + this.updateDisplay(); + this.renderDropdown(); + } + render() { + this.container.empty(); + const iconWrapper = this.container.createDiv({ cls: "claudian-external-context-icon-wrapper" }); + this.iconEl = iconWrapper.createDiv({ cls: "claudian-external-context-icon" }); + (0, import_obsidian36.setIcon)(this.iconEl, "folder"); + this.badgeEl = iconWrapper.createDiv({ cls: "claudian-external-context-badge" }); + this.updateDisplay(); + iconWrapper.addEventListener("click", (e3) => { + e3.stopPropagation(); + this.openFolderPicker(); + }); + this.dropdownEl = this.container.createDiv({ cls: "claudian-external-context-dropdown" }); + this.renderDropdown(); + } + async openFolderPicker() { + var _a3; + try { + const { remote } = require("electron"); + const result = await remote.dialog.showOpenDialog({ + properties: ["openDirectory"], + title: "Select External Context" + }); + if (!result.canceled && result.filePaths.length > 0) { + const selectedPath = result.filePaths[0]; + if (isDuplicatePath(selectedPath, this.externalContextPaths)) { + new import_obsidian36.Notice("This folder is already added as an external context.", 3e3); + return; + } + const conflict = findConflictingPath(selectedPath, this.externalContextPaths); + if (conflict) { + new import_obsidian36.Notice(this.formatConflictMessage(selectedPath, conflict), 5e3); + return; + } + this.externalContextPaths = [...this.externalContextPaths, selectedPath]; + (_a3 = this.onChangeCallback) == null ? void 0 : _a3.call(this, this.externalContextPaths); + this.updateDisplay(); + this.renderDropdown(); + } + } catch (e3) { + new import_obsidian36.Notice("Unable to open folder picker.", 5e3); + } + } + /** Formats a conflict error message for display. */ + formatConflictMessage(newPath, conflict) { + const shortNew = this.shortenPath(newPath); + const shortExisting = this.shortenPath(conflict.path); + return conflict.type === "parent" ? `Cannot add "${shortNew}" - it's inside existing path "${shortExisting}"` : `Cannot add "${shortNew}" - it contains existing path "${shortExisting}"`; + } + renderDropdown() { + if (!this.dropdownEl) return; + this.dropdownEl.empty(); + const headerEl = this.dropdownEl.createDiv({ cls: "claudian-external-context-header" }); + headerEl.setText("External Contexts"); + const listEl = this.dropdownEl.createDiv({ cls: "claudian-external-context-list" }); + if (this.externalContextPaths.length === 0) { + const emptyEl = listEl.createDiv({ cls: "claudian-external-context-empty" }); + emptyEl.setText("Click folder icon to add"); + } else { + for (const pathStr of this.externalContextPaths) { + const itemEl = listEl.createDiv({ cls: "claudian-external-context-item" }); + const pathTextEl = itemEl.createSpan({ cls: "claudian-external-context-text" }); + const displayPath = this.shortenPath(pathStr); + pathTextEl.setText(displayPath); + pathTextEl.setAttribute("title", pathStr); + const isPersistent = this.persistentPaths.has(pathStr); + const lockBtn = itemEl.createSpan({ cls: "claudian-external-context-lock" }); + if (isPersistent) { + lockBtn.addClass("locked"); + } + (0, import_obsidian36.setIcon)(lockBtn, isPersistent ? "lock" : "unlock"); + lockBtn.setAttribute("title", isPersistent ? "Persistent (click to make session-only)" : "Session-only (click to persist)"); + lockBtn.addEventListener("click", (e3) => { + e3.stopPropagation(); + this.togglePersistence(pathStr); + }); + const removeBtn = itemEl.createSpan({ cls: "claudian-external-context-remove" }); + (0, import_obsidian36.setIcon)(removeBtn, "x"); + removeBtn.setAttribute("title", "Remove path"); + removeBtn.addEventListener("click", (e3) => { + e3.stopPropagation(); + this.removePath(pathStr); + }); + } + } + } + /** Shorten path for display (replace home dir with ~) */ + shortenPath(fullPath) { + try { + const os11 = require("os"); + const homeDir = os11.homedir(); + const normalize3 = (value) => value.replace(/\\/g, "/"); + const normalizedFull = normalize3(fullPath); + const normalizedHome = normalize3(homeDir); + const compareFull = process.platform === "win32" ? normalizedFull.toLowerCase() : normalizedFull; + const compareHome = process.platform === "win32" ? normalizedHome.toLowerCase() : normalizedHome; + if (compareFull.startsWith(compareHome)) { + const remainder = normalizedFull.slice(normalizedHome.length); + return "~" + remainder; + } + } catch (e3) { + } + return fullPath; + } + updateDisplay() { + if (!this.iconEl || !this.badgeEl) return; + const count = this.externalContextPaths.length; + if (count > 0) { + this.iconEl.addClass("active"); + this.iconEl.setAttribute("title", `${count} external context${count > 1 ? "s" : ""} (click to add more)`); + if (count > 1) { + this.badgeEl.setText(String(count)); + this.badgeEl.addClass("visible"); + } else { + this.badgeEl.removeClass("visible"); + } + } else { + this.iconEl.removeClass("active"); + this.iconEl.setAttribute("title", "Add external contexts (click)"); + this.badgeEl.removeClass("visible"); + } + } +}; +var McpServerSelector = class { + constructor(parentEl) { + this.iconEl = null; + this.badgeEl = null; + this.dropdownEl = null; + this.mcpManager = null; + this.enabledServers = /* @__PURE__ */ new Set(); + this.onChangeCallback = null; + this.visible = true; + this.container = parentEl.createDiv({ cls: "claudian-mcp-selector" }); + this.render(); + } + setVisible(visible) { + this.visible = visible; + if (!visible) { + this.container.style.display = "none"; + } else { + this.updateDisplay(); + } + } + setMcpManager(manager) { + var _a3; + this.mcpManager = manager; + if (!manager && this.enabledServers.size > 0) { + this.enabledServers.clear(); + (_a3 = this.onChangeCallback) == null ? void 0 : _a3.call(this, this.enabledServers); + } + this.pruneEnabledServers(); + this.updateDisplay(); + this.renderDropdown(); + } + setOnChange(callback) { + this.onChangeCallback = callback; + } + getEnabledServers() { + return new Set(this.enabledServers); + } + addMentionedServers(names) { + let changed = false; + for (const name of names) { + if (!this.enabledServers.has(name)) { + this.enabledServers.add(name); + changed = true; + } + } + if (changed) { + this.updateDisplay(); + this.renderDropdown(); + } + } + clearEnabled() { + this.enabledServers.clear(); + this.updateDisplay(); + this.renderDropdown(); + } + setEnabledServers(names) { + this.enabledServers = new Set(names); + this.pruneEnabledServers(); + this.updateDisplay(); + this.renderDropdown(); + } + pruneEnabledServers() { + var _a3; + if (!this.mcpManager) return; + const activeNames = new Set(this.mcpManager.getServers().filter((s3) => s3.enabled).map((s3) => s3.name)); + let changed = false; + for (const name of this.enabledServers) { + if (!activeNames.has(name)) { + this.enabledServers.delete(name); + changed = true; + } + } + if (changed) { + (_a3 = this.onChangeCallback) == null ? void 0 : _a3.call(this, this.enabledServers); + } + } + render() { + this.container.empty(); + const iconWrapper = this.container.createDiv({ cls: "claudian-mcp-selector-icon-wrapper" }); + this.iconEl = iconWrapper.createDiv({ cls: "claudian-mcp-selector-icon" }); + this.iconEl.innerHTML = MCP_ICON_SVG; + this.badgeEl = iconWrapper.createDiv({ cls: "claudian-mcp-selector-badge" }); + this.updateDisplay(); + this.dropdownEl = this.container.createDiv({ cls: "claudian-mcp-selector-dropdown" }); + this.renderDropdown(); + this.container.addEventListener("mouseenter", () => { + this.renderDropdown(); + }); + } + renderDropdown() { + var _a3; + if (!this.dropdownEl) return; + this.pruneEnabledServers(); + this.dropdownEl.empty(); + const headerEl = this.dropdownEl.createDiv({ cls: "claudian-mcp-selector-header" }); + headerEl.setText("MCP Servers"); + const listEl = this.dropdownEl.createDiv({ cls: "claudian-mcp-selector-list" }); + const allServers = ((_a3 = this.mcpManager) == null ? void 0 : _a3.getServers()) || []; + const servers = allServers.filter((s3) => s3.enabled); + if (servers.length === 0) { + const emptyEl = listEl.createDiv({ cls: "claudian-mcp-selector-empty" }); + emptyEl.setText(allServers.length === 0 ? "No MCP servers configured" : "All MCP servers disabled"); + return; + } + for (const server of servers) { + this.renderServerItem(listEl, server); + } + } + renderServerItem(listEl, server) { + const itemEl = listEl.createDiv({ cls: "claudian-mcp-selector-item" }); + itemEl.dataset.serverName = server.name; + const isEnabled = this.enabledServers.has(server.name); + if (isEnabled) { + itemEl.addClass("enabled"); + } + const checkEl = itemEl.createDiv({ cls: "claudian-mcp-selector-check" }); + if (isEnabled) { + checkEl.innerHTML = CHECK_ICON_SVG; + } + const infoEl = itemEl.createDiv({ cls: "claudian-mcp-selector-item-info" }); + const nameEl = infoEl.createSpan({ cls: "claudian-mcp-selector-item-name" }); + nameEl.setText(server.name); + if (server.contextSaving) { + const csEl = infoEl.createSpan({ cls: "claudian-mcp-selector-cs-badge" }); + csEl.setText("@"); + csEl.setAttribute("title", "Context-saving: can also enable via @" + server.name); + } + itemEl.addEventListener("mousedown", (e3) => { + e3.preventDefault(); + e3.stopPropagation(); + this.toggleServer(server.name, itemEl); + }); + } + toggleServer(name, itemEl) { + var _a3; + if (this.enabledServers.has(name)) { + this.enabledServers.delete(name); + } else { + this.enabledServers.add(name); + } + const isEnabled = this.enabledServers.has(name); + const checkEl = itemEl.querySelector(".claudian-mcp-selector-check"); + if (isEnabled) { + itemEl.addClass("enabled"); + if (checkEl) checkEl.innerHTML = CHECK_ICON_SVG; + } else { + itemEl.removeClass("enabled"); + if (checkEl) checkEl.innerHTML = ""; + } + this.updateDisplay(); + (_a3 = this.onChangeCallback) == null ? void 0 : _a3.call(this, this.enabledServers); + } + updateDisplay() { + var _a3; + this.pruneEnabledServers(); + if (!this.iconEl || !this.badgeEl) return; + const count = this.enabledServers.size; + const hasServers = (((_a3 = this.mcpManager) == null ? void 0 : _a3.getServers().length) || 0) > 0; + if (!hasServers || !this.visible) { + this.container.style.display = "none"; + return; + } + this.container.style.display = ""; + if (count > 0) { + this.iconEl.addClass("active"); + this.iconEl.setAttribute("title", `${count} MCP server${count > 1 ? "s" : ""} enabled (click to manage)`); + if (count > 1) { + this.badgeEl.setText(String(count)); + this.badgeEl.addClass("visible"); + } else { + this.badgeEl.removeClass("visible"); + } + } else { + this.iconEl.removeClass("active"); + this.iconEl.setAttribute("title", "MCP servers (click to enable)"); + this.badgeEl.removeClass("visible"); + } + } +}; +var ContextUsageMeter = class { + constructor(parentEl) { + this.fillPath = null; + this.percentEl = null; + this.circumference = 0; + this.container = parentEl.createDiv({ cls: "claudian-context-meter" }); + this.render(); + this.container.style.display = "none"; + } + setVisible(visible) { + this.container.style.display = visible ? "" : "none"; + } + render() { + const size = 16; + const strokeWidth = 2; + const radius = (size - strokeWidth) / 2; + const cx = size / 2; + const cy = size / 2; + const startAngle = 150; + const endAngle = 390; + const arcDegrees = endAngle - startAngle; + const arcRadians = arcDegrees * Math.PI / 180; + this.circumference = radius * arcRadians; + const startRad = startAngle * Math.PI / 180; + const endRad = endAngle * Math.PI / 180; + const x1 = cx + radius * Math.cos(startRad); + const y12 = cy + radius * Math.sin(startRad); + const x22 = cx + radius * Math.cos(endRad); + const y22 = cy + radius * Math.sin(endRad); + const gaugeEl = this.container.createDiv({ cls: "claudian-context-meter-gauge" }); + gaugeEl.innerHTML = ` + + + + + `; + this.fillPath = gaugeEl.querySelector(".claudian-meter-fill"); + this.percentEl = this.container.createSpan({ cls: "claudian-context-meter-percent" }); + } + update(usage) { + if (!usage || usage.contextTokens <= 0) { + this.container.style.display = "none"; + return; + } + this.container.style.display = "flex"; + const fillLength = usage.percentage / 100 * this.circumference; + if (this.fillPath) { + this.fillPath.style.strokeDashoffset = String(this.circumference - fillLength); + } + if (this.percentEl) { + this.percentEl.setText(`${usage.percentage}%`); + } + if (usage.percentage > 80) { + this.container.addClass("warning"); + } else { + this.container.removeClass("warning"); + } + let tooltip = `${this.formatTokens(usage.contextTokens)} / ${this.formatTokens(usage.contextWindow)}`; + if (usage.percentage > 80) { + tooltip += " (Approaching limit, run `/compact` to continue)"; + } + this.container.setAttribute("data-tooltip", tooltip); + } + formatTokens(tokens) { + if (tokens >= 1e3) { + return `${Math.round(tokens / 1e3)}k`; + } + return String(tokens); + } +}; +function createInputToolbar(parentEl, callbacks) { + const modelSelector = new ModelSelector(parentEl, callbacks); + const thinkingBudgetSelector = new ThinkingBudgetSelector(parentEl, callbacks); + const serviceTierToggle = new ServiceTierToggle(parentEl, callbacks); + const contextUsageMeter = new ContextUsageMeter(parentEl); + const externalContextSelector = new ExternalContextSelector(parentEl, callbacks); + const mcpServerSelector = new McpServerSelector(parentEl); + const permissionToggle = new PermissionToggle(parentEl, callbacks); + return { + modelSelector, + thinkingBudgetSelector, + serviceTierToggle, + contextUsageMeter, + externalContextSelector, + mcpServerSelector, + permissionToggle + }; +} + +// src/features/chat/ui/InstructionModeManager.ts +var INSTRUCTION_MODE_PLACEHOLDER = "# Save in custom system prompt"; +var InstructionModeManager = class { + constructor(inputEl, callbacks) { + this.state = { active: false, rawInstruction: "" }; + this.isSubmitting = false; + this.originalPlaceholder = ""; + this.inputEl = inputEl; + this.callbacks = callbacks; + this.originalPlaceholder = inputEl.placeholder; + } + /** + * Handles keydown to detect # trigger. + * Returns true if the event was consumed (should prevent default). + */ + handleTriggerKey(e3) { + if (!this.state.active && this.inputEl.value === "" && e3.key === "#") { + if (this.enterMode()) { + e3.preventDefault(); + return true; + } + } + return false; + } + /** Handles input changes to track instruction text. */ + handleInputChange() { + if (!this.state.active) return; + const text = this.inputEl.value; + if (text === "") { + this.exitMode(); + } else { + this.state.rawInstruction = text; + } + } + /** + * Enters instruction mode. + * Only enters if the indicator can be successfully shown. + * Returns true if mode was entered, false otherwise. + */ + enterMode() { + const wrapper = this.callbacks.getInputWrapper(); + if (!wrapper) return false; + wrapper.addClass("claudian-input-instruction-mode"); + this.state = { active: true, rawInstruction: "" }; + this.inputEl.placeholder = INSTRUCTION_MODE_PLACEHOLDER; + return true; + } + /** Exits instruction mode, restoring original state. */ + exitMode() { + const wrapper = this.callbacks.getInputWrapper(); + if (wrapper) { + wrapper.removeClass("claudian-input-instruction-mode"); + } + this.state = { active: false, rawInstruction: "" }; + this.inputEl.placeholder = this.originalPlaceholder; + } + /** Handles keydown events. Returns true if handled. */ + handleKeydown(e3) { + if (!this.state.active) return false; + if (e3.key === "Enter" && !e3.shiftKey && !e3.isComposing) { + if (!this.state.rawInstruction.trim()) { + return false; + } + e3.preventDefault(); + this.submit(); + return true; + } + if (e3.key === "Escape" && !e3.isComposing) { + e3.preventDefault(); + this.cancel(); + return true; + } + return false; + } + /** Checks if instruction mode is active. */ + isActive() { + return this.state.active; + } + /** Gets the current raw instruction text. */ + getRawInstruction() { + return this.state.rawInstruction; + } + /** Submits the instruction for refinement. */ + async submit() { + if (this.isSubmitting) return; + const rawInstruction = this.state.rawInstruction.trim(); + if (!rawInstruction) return; + this.isSubmitting = true; + try { + await this.callbacks.onSubmit(rawInstruction); + } finally { + this.isSubmitting = false; + } + } + /** Cancels instruction mode and clears input. */ + cancel() { + var _a3, _b2; + this.inputEl.value = ""; + this.exitMode(); + (_b2 = (_a3 = this.callbacks).resetInputHeight) == null ? void 0 : _b2.call(_a3); + } + /** Clears the input and resets state (called after successful submission). */ + clear() { + var _a3, _b2; + this.inputEl.value = ""; + this.exitMode(); + (_b2 = (_a3 = this.callbacks).resetInputHeight) == null ? void 0 : _b2.call(_a3); + } + /** Cleans up event listeners. */ + destroy() { + const wrapper = this.callbacks.getInputWrapper(); + if (wrapper) { + wrapper.removeClass("claudian-input-instruction-mode"); + } + this.inputEl.placeholder = this.originalPlaceholder; + } +}; + +// src/features/chat/ui/NavigationSidebar.ts +var import_obsidian37 = require("obsidian"); +var NavigationSidebar = class { + constructor(parentEl, messagesEl) { + this.parentEl = parentEl; + this.messagesEl = messagesEl; + this.scrollHandler = () => { + }; + this.container = this.parentEl.createDiv({ cls: "claudian-nav-sidebar" }); + this.topBtn = this.createButton("claudian-nav-btn-top", "chevrons-up", "Scroll to top"); + this.prevBtn = this.createButton("claudian-nav-btn-prev", "chevron-up", "Previous message"); + this.nextBtn = this.createButton("claudian-nav-btn-next", "chevron-down", "Next message"); + this.bottomBtn = this.createButton("claudian-nav-btn-bottom", "chevrons-down", "Scroll to bottom"); + this.setupEventListeners(); + this.updateVisibility(); + } + createButton(cls, icon, label) { + const btn = this.container.createDiv({ cls: `claudian-nav-btn ${cls}` }); + (0, import_obsidian37.setIcon)(btn, icon); + btn.setAttribute("aria-label", label); + return btn; + } + setupEventListeners() { + this.scrollHandler = () => this.updateVisibility(); + this.messagesEl.addEventListener("scroll", this.scrollHandler, { passive: true }); + this.topBtn.addEventListener("click", () => { + this.messagesEl.scrollTo({ top: 0, behavior: "smooth" }); + }); + this.bottomBtn.addEventListener("click", () => { + this.messagesEl.scrollTo({ top: this.messagesEl.scrollHeight, behavior: "smooth" }); + }); + this.prevBtn.addEventListener("click", () => this.scrollToMessage("prev")); + this.nextBtn.addEventListener("click", () => this.scrollToMessage("next")); + } + /** + * Updates visibility of the sidebar based on scroll state. + * Visible if content overflows. + */ + updateVisibility() { + const { scrollHeight, clientHeight } = this.messagesEl; + const isScrollable = scrollHeight > clientHeight + 50; + this.container.classList.toggle("visible", isScrollable); + } + /** + * Scrolls to previous or next user message, skipping assistant messages. + */ + scrollToMessage(direction) { + const messages = Array.from(this.messagesEl.querySelectorAll(".claudian-message-user")); + if (messages.length === 0) return; + const scrollTop = this.messagesEl.scrollTop; + const threshold = 30; + if (direction === "prev") { + for (let i3 = messages.length - 1; i3 >= 0; i3--) { + if (messages[i3].offsetTop < scrollTop - threshold) { + this.messagesEl.scrollTo({ top: messages[i3].offsetTop - 10, behavior: "smooth" }); + return; + } + } + this.messagesEl.scrollTo({ top: 0, behavior: "smooth" }); + } else { + for (let i3 = 0; i3 < messages.length; i3++) { + if (messages[i3].offsetTop > scrollTop + threshold) { + this.messagesEl.scrollTo({ top: messages[i3].offsetTop - 10, behavior: "smooth" }); + return; + } + } + this.messagesEl.scrollTo({ top: this.messagesEl.scrollHeight, behavior: "smooth" }); + } + } + destroy() { + this.messagesEl.removeEventListener("scroll", this.scrollHandler); + this.container.remove(); + } +}; + +// src/features/chat/ui/StatusPanel.ts +var import_obsidian38 = require("obsidian"); +var MAX_BASH_OUTPUTS = 50; +var StatusPanel = class { + constructor() { + this.containerEl = null; + this.panelEl = null; + // Bash output section + this.bashOutputContainerEl = null; + this.bashHeaderEl = null; + this.bashContentEl = null; + this.isBashExpanded = true; + this.currentBashOutputs = /* @__PURE__ */ new Map(); + this.bashEntryExpanded = /* @__PURE__ */ new Map(); + // Todo section + this.todoContainerEl = null; + this.todoHeaderEl = null; + this.todoContentEl = null; + this.isTodoExpanded = false; + this.currentTodos = null; + // Event handler references for cleanup + this.todoClickHandler = null; + this.todoKeydownHandler = null; + this.bashClickHandler = null; + this.bashKeydownHandler = null; + } + /** + * Mount the panel into the messages container. + * Appends to the end of the messages area. + */ + mount(containerEl) { + this.containerEl = containerEl; + this.createPanel(); + } + /** + * Remount the panel to restore state after conversation changes. + * Re-creates the panel structure and re-renders current state. + */ + remount() { + if (!this.containerEl) { + return; + } + if (this.todoHeaderEl) { + if (this.todoClickHandler) { + this.todoHeaderEl.removeEventListener("click", this.todoClickHandler); + } + if (this.todoKeydownHandler) { + this.todoHeaderEl.removeEventListener("keydown", this.todoKeydownHandler); + } + } + this.todoClickHandler = null; + this.todoKeydownHandler = null; + if (this.bashHeaderEl) { + if (this.bashClickHandler) { + this.bashHeaderEl.removeEventListener("click", this.bashClickHandler); + } + if (this.bashKeydownHandler) { + this.bashHeaderEl.removeEventListener("keydown", this.bashKeydownHandler); + } + } + this.bashClickHandler = null; + this.bashKeydownHandler = null; + if (this.panelEl) { + this.panelEl.remove(); + } + this.panelEl = null; + this.bashOutputContainerEl = null; + this.bashHeaderEl = null; + this.bashContentEl = null; + this.todoContainerEl = null; + this.todoHeaderEl = null; + this.todoContentEl = null; + this.createPanel(); + this.renderBashOutputs(); + if (this.currentTodos && this.currentTodos.length > 0) { + this.updateTodos(this.currentTodos); + } + } + /** + * Create the panel structure. + */ + createPanel() { + if (!this.containerEl) { + return; + } + this.panelEl = document.createElement("div"); + this.panelEl.className = "claudian-status-panel"; + this.bashOutputContainerEl = document.createElement("div"); + this.bashOutputContainerEl.className = "claudian-status-panel-bash"; + this.bashOutputContainerEl.style.display = "none"; + this.bashHeaderEl = document.createElement("div"); + this.bashHeaderEl.className = "claudian-tool-header claudian-status-panel-bash-header"; + this.bashHeaderEl.setAttribute("tabindex", "0"); + this.bashHeaderEl.setAttribute("role", "button"); + this.bashClickHandler = () => this.toggleBashSection(); + this.bashKeydownHandler = (e3) => { + if (e3.key === "Enter" || e3.key === " ") { + e3.preventDefault(); + this.toggleBashSection(); + } + }; + this.bashHeaderEl.addEventListener("click", this.bashClickHandler); + this.bashHeaderEl.addEventListener("keydown", this.bashKeydownHandler); + this.bashContentEl = document.createElement("div"); + this.bashContentEl.className = "claudian-status-panel-bash-content"; + this.bashOutputContainerEl.appendChild(this.bashHeaderEl); + this.bashOutputContainerEl.appendChild(this.bashContentEl); + this.panelEl.appendChild(this.bashOutputContainerEl); + this.todoContainerEl = document.createElement("div"); + this.todoContainerEl.className = "claudian-status-panel-todos"; + this.todoContainerEl.style.display = "none"; + this.panelEl.appendChild(this.todoContainerEl); + this.todoHeaderEl = document.createElement("div"); + this.todoHeaderEl.className = "claudian-status-panel-header"; + this.todoHeaderEl.setAttribute("tabindex", "0"); + this.todoHeaderEl.setAttribute("role", "button"); + this.todoClickHandler = () => this.toggleTodos(); + this.todoKeydownHandler = (e3) => { + if (e3.key === "Enter" || e3.key === " ") { + e3.preventDefault(); + this.toggleTodos(); + } + }; + this.todoHeaderEl.addEventListener("click", this.todoClickHandler); + this.todoHeaderEl.addEventListener("keydown", this.todoKeydownHandler); + this.todoContainerEl.appendChild(this.todoHeaderEl); + this.todoContentEl = document.createElement("div"); + this.todoContentEl.className = "claudian-status-panel-content claudian-todo-list-container"; + this.todoContentEl.style.display = "none"; + this.todoContainerEl.appendChild(this.todoContentEl); + this.containerEl.appendChild(this.panelEl); + } + /** + * Update the panel with new todo items. + * Called by ChatState.onTodosChanged callback when TodoWrite tool is used. + * Passing null or empty array hides the panel. + */ + updateTodos(todos) { + if (!this.todoContainerEl || !this.todoHeaderEl || !this.todoContentEl) { + return; + } + this.currentTodos = todos; + if (!todos || todos.length === 0) { + this.todoContainerEl.style.display = "none"; + this.todoHeaderEl.empty(); + this.todoContentEl.empty(); + return; + } + this.todoContainerEl.style.display = "block"; + const completedCount = todos.filter((t3) => t3.status === "completed").length; + const totalCount = todos.length; + const currentTask = todos.find((t3) => t3.status === "in_progress"); + this.renderTodoHeader(completedCount, totalCount, currentTask); + this.renderTodoContent(todos); + this.updateTodoAriaLabel(completedCount, totalCount); + this.scrollToBottom(); + } + /** + * Render the todo collapsed header. + */ + renderTodoHeader(completedCount, totalCount, currentTask) { + if (!this.todoHeaderEl) return; + this.todoHeaderEl.empty(); + const icon = document.createElement("span"); + icon.className = "claudian-status-panel-icon"; + (0, import_obsidian38.setIcon)(icon, getToolIcon(TOOL_TODO_WRITE)); + this.todoHeaderEl.appendChild(icon); + const label = document.createElement("span"); + label.className = "claudian-status-panel-label"; + label.textContent = `Tasks (${completedCount}/${totalCount})`; + this.todoHeaderEl.appendChild(label); + if (!this.isTodoExpanded) { + if (completedCount === totalCount && totalCount > 0) { + const status = document.createElement("span"); + status.className = "claudian-status-panel-status status-completed"; + (0, import_obsidian38.setIcon)(status, "check"); + this.todoHeaderEl.appendChild(status); + } + if (currentTask) { + const current = document.createElement("span"); + current.className = "claudian-status-panel-current"; + current.textContent = currentTask.activeForm; + this.todoHeaderEl.appendChild(current); + } + } + } + /** + * Render the expanded todo content. + */ + renderTodoContent(todos) { + if (!this.todoContentEl) return; + renderTodoItems(this.todoContentEl, todos); + } + /** + * Toggle todo expanded/collapsed state. + */ + toggleTodos() { + this.isTodoExpanded = !this.isTodoExpanded; + this.updateTodoDisplay(); + } + /** + * Update todo display based on expanded state. + */ + updateTodoDisplay() { + if (!this.todoContentEl || !this.todoHeaderEl) return; + this.todoContentEl.style.display = this.isTodoExpanded ? "block" : "none"; + if (this.currentTodos && this.currentTodos.length > 0) { + const completedCount = this.currentTodos.filter((t3) => t3.status === "completed").length; + const totalCount = this.currentTodos.length; + const currentTask = this.currentTodos.find((t3) => t3.status === "in_progress"); + this.renderTodoHeader(completedCount, totalCount, currentTask); + this.updateTodoAriaLabel(completedCount, totalCount); + } + this.scrollToBottom(); + } + /** + * Update todo ARIA label. + */ + updateTodoAriaLabel(completedCount, totalCount) { + if (!this.todoHeaderEl) return; + const action = this.isTodoExpanded ? "Collapse" : "Expand"; + this.todoHeaderEl.setAttribute( + "aria-label", + `${action} task list - ${completedCount} of ${totalCount} completed` + ); + this.todoHeaderEl.setAttribute("aria-expanded", String(this.isTodoExpanded)); + } + /** + * Scroll messages container to bottom. + */ + scrollToBottom() { + if (this.containerEl) { + this.containerEl.scrollTop = this.containerEl.scrollHeight; + } + } + // ============================================ + // Bash Output Methods + // ============================================ + truncateDescription(description, maxLength = 50) { + if (description.length <= maxLength) return description; + return description.substring(0, maxLength) + "..."; + } + addBashOutput(info) { + this.currentBashOutputs.set(info.id, info); + while (this.currentBashOutputs.size > MAX_BASH_OUTPUTS) { + const oldest = this.currentBashOutputs.keys().next().value; + if (!oldest) break; + this.currentBashOutputs.delete(oldest); + this.bashEntryExpanded.delete(oldest); + } + this.renderBashOutputs(); + } + updateBashOutput(id, updates) { + const existing = this.currentBashOutputs.get(id); + if (!existing) return; + this.currentBashOutputs.set(id, { ...existing, ...updates }); + this.renderBashOutputs(); + } + clearBashOutputs() { + this.currentBashOutputs.clear(); + this.bashEntryExpanded.clear(); + this.renderBashOutputs(); + } + renderBashOutputs(options = {}) { + var _a3; + if (!this.bashOutputContainerEl || !this.bashHeaderEl || !this.bashContentEl) return; + const scroll = (_a3 = options.scroll) != null ? _a3 : true; + if (this.currentBashOutputs.size === 0) { + this.bashOutputContainerEl.style.display = "none"; + return; + } + this.bashOutputContainerEl.style.display = "block"; + this.bashHeaderEl.empty(); + this.bashContentEl.empty(); + const headerIconEl = document.createElement("span"); + headerIconEl.className = "claudian-tool-icon"; + headerIconEl.setAttribute("aria-hidden", "true"); + (0, import_obsidian38.setIcon)(headerIconEl, "terminal"); + this.bashHeaderEl.appendChild(headerIconEl); + const latest = Array.from(this.currentBashOutputs.values()).at(-1); + const headerLabelEl = document.createElement("span"); + headerLabelEl.className = "claudian-tool-label"; + if (this.isBashExpanded) { + headerLabelEl.textContent = t("chat.bangBash.commandPanel"); + } else { + headerLabelEl.textContent = latest ? this.truncateDescription(latest.command, 60) : t("chat.bangBash.commandPanel"); + } + this.bashHeaderEl.appendChild(headerLabelEl); + const previewEl = document.createElement("span"); + previewEl.className = "claudian-tool-current"; + previewEl.style.display = this.isBashExpanded ? "" : "none"; + this.bashHeaderEl.appendChild(previewEl); + const summaryStatusEl = document.createElement("span"); + summaryStatusEl.className = "claudian-tool-status"; + if (!this.isBashExpanded && latest) { + summaryStatusEl.classList.add(`status-${latest.status}`); + summaryStatusEl.setAttribute("aria-label", t("chat.bangBash.statusLabel", { status: latest.status })); + if (latest.status === "completed") (0, import_obsidian38.setIcon)(summaryStatusEl, "check"); + if (latest.status === "error") (0, import_obsidian38.setIcon)(summaryStatusEl, "x"); + } else { + summaryStatusEl.style.display = "none"; + } + this.bashHeaderEl.appendChild(summaryStatusEl); + this.bashHeaderEl.setAttribute("aria-expanded", String(this.isBashExpanded)); + const actionsEl = document.createElement("span"); + actionsEl.className = "claudian-status-panel-bash-actions"; + this.appendActionButton(actionsEl, "copy", t("chat.bangBash.copyAriaLabel"), "copy", () => { + void this.copyLatestBashOutput(); + }); + this.appendActionButton(actionsEl, "clear", t("chat.bangBash.clearAriaLabel"), "trash", () => { + this.clearBashOutputs(); + }); + this.bashHeaderEl.appendChild(actionsEl); + this.bashContentEl.style.display = this.isBashExpanded ? "block" : "none"; + if (!this.isBashExpanded) { + return; + } + for (const info of this.currentBashOutputs.values()) { + this.bashContentEl.appendChild(this.renderBashEntry(info)); + } + if (scroll) { + this.bashContentEl.scrollTop = this.bashContentEl.scrollHeight; + this.scrollToBottom(); + } + } + renderBashEntry(info) { + var _a3; + const entryEl = document.createElement("div"); + entryEl.className = "claudian-tool-call claudian-status-panel-bash-entry"; + const entryHeaderEl = document.createElement("div"); + entryHeaderEl.className = "claudian-tool-header"; + entryHeaderEl.setAttribute("tabindex", "0"); + entryHeaderEl.setAttribute("role", "button"); + const entryIconEl = document.createElement("span"); + entryIconEl.className = "claudian-tool-icon"; + entryIconEl.setAttribute("aria-hidden", "true"); + (0, import_obsidian38.setIcon)(entryIconEl, "dollar-sign"); + entryHeaderEl.appendChild(entryIconEl); + const entryLabelEl = document.createElement("span"); + entryLabelEl.className = "claudian-tool-label"; + entryLabelEl.textContent = t("chat.bangBash.commandLabel", { command: this.truncateDescription(info.command, 60) }); + entryHeaderEl.appendChild(entryLabelEl); + const entryStatusEl = document.createElement("span"); + entryStatusEl.className = "claudian-tool-status"; + entryStatusEl.classList.add(`status-${info.status}`); + entryStatusEl.setAttribute("aria-label", t("chat.bangBash.statusLabel", { status: info.status })); + if (info.status === "completed") (0, import_obsidian38.setIcon)(entryStatusEl, "check"); + if (info.status === "error") (0, import_obsidian38.setIcon)(entryStatusEl, "x"); + entryHeaderEl.appendChild(entryStatusEl); + entryEl.appendChild(entryHeaderEl); + const contentEl = document.createElement("div"); + contentEl.className = "claudian-tool-content"; + const isEntryExpanded = (_a3 = this.bashEntryExpanded.get(info.id)) != null ? _a3 : true; + contentEl.style.display = isEntryExpanded ? "block" : "none"; + entryHeaderEl.setAttribute("aria-expanded", String(isEntryExpanded)); + entryHeaderEl.setAttribute("aria-label", isEntryExpanded ? t("chat.bangBash.collapseOutput") : t("chat.bangBash.expandOutput")); + entryHeaderEl.addEventListener("click", () => { + this.bashEntryExpanded.set(info.id, !isEntryExpanded); + this.renderBashOutputs({ scroll: false }); + }); + entryHeaderEl.addEventListener("keydown", (e3) => { + if (e3.key === "Enter" || e3.key === " ") { + e3.preventDefault(); + this.bashEntryExpanded.set(info.id, !isEntryExpanded); + this.renderBashOutputs({ scroll: false }); + } + }); + const rowEl = document.createElement("div"); + rowEl.className = "claudian-tool-result-row"; + const textEl = document.createElement("span"); + textEl.className = "claudian-tool-result-text"; + if (info.status === "running" && !info.output) { + textEl.textContent = t("chat.bangBash.running"); + } else if (info.output) { + textEl.textContent = info.output; + } + rowEl.appendChild(textEl); + contentEl.appendChild(rowEl); + entryEl.appendChild(contentEl); + return entryEl; + } + async copyLatestBashOutput() { + var _a3; + const latest = Array.from(this.currentBashOutputs.values()).at(-1); + if (!latest) return; + const output = ((_a3 = latest.output) == null ? void 0 : _a3.trim()) || (latest.status === "running" ? t("chat.bangBash.running") : ""); + const text = output ? `$ ${latest.command} +${output}` : `$ ${latest.command}`; + try { + await navigator.clipboard.writeText(text); + } catch (e3) { + new import_obsidian38.Notice(t("chat.bangBash.copyFailed")); + } + } + appendActionButton(parent, name, ariaLabel, icon, action) { + const el2 = document.createElement("span"); + el2.className = `claudian-status-panel-bash-action claudian-status-panel-bash-action-${name}`; + el2.setAttribute("role", "button"); + el2.setAttribute("tabindex", "0"); + el2.setAttribute("aria-label", ariaLabel); + (0, import_obsidian38.setIcon)(el2, icon); + el2.addEventListener("click", (e3) => { + e3.stopPropagation(); + action(); + }); + el2.addEventListener("keydown", (e3) => { + if (e3.key === "Enter" || e3.key === " ") { + e3.preventDefault(); + e3.stopPropagation(); + action(); + } + }); + parent.appendChild(el2); + } + toggleBashSection() { + this.isBashExpanded = !this.isBashExpanded; + this.renderBashOutputs({ scroll: false }); + } + // ============================================ + // Cleanup + // ============================================ + /** + * Destroy the panel. + */ + destroy() { + if (this.todoHeaderEl) { + if (this.todoClickHandler) { + this.todoHeaderEl.removeEventListener("click", this.todoClickHandler); + } + if (this.todoKeydownHandler) { + this.todoHeaderEl.removeEventListener("keydown", this.todoKeydownHandler); + } + } + this.todoClickHandler = null; + this.todoKeydownHandler = null; + if (this.bashHeaderEl) { + if (this.bashClickHandler) { + this.bashHeaderEl.removeEventListener("click", this.bashClickHandler); + } + if (this.bashKeydownHandler) { + this.bashHeaderEl.removeEventListener("keydown", this.bashKeydownHandler); + } + } + this.bashClickHandler = null; + this.bashKeydownHandler = null; + this.currentBashOutputs.clear(); + if (this.panelEl) { + this.panelEl.remove(); + this.panelEl = null; + } + this.bashOutputContainerEl = null; + this.bashHeaderEl = null; + this.bashContentEl = null; + this.todoContainerEl = null; + this.todoHeaderEl = null; + this.todoContentEl = null; + this.containerEl = null; + this.currentTodos = null; + } +}; + +// src/features/chat/utils/usageInfo.ts +function calculateUsagePercentage(contextTokens, contextWindow) { + return contextWindow > 0 ? Math.min(100, Math.max(0, Math.round(contextTokens / contextWindow * 100))) : 0; +} +function recalculateUsageForModel(usage, model, fallbackContextWindow) { + const preserveAuthoritativeWindow = usage.contextWindowIsAuthoritative === true && usage.contextWindow > 0 && usage.model === model; + const contextWindow = preserveAuthoritativeWindow ? usage.contextWindow : fallbackContextWindow; + return { + ...usage, + model, + contextWindow, + contextWindowIsAuthoritative: preserveAuthoritativeWindow, + percentage: calculateUsagePercentage(usage.contextTokens, contextWindow) + }; +} + +// src/features/chat/tabs/providerResolution.ts +function getStoredConversationProviderId(tab, plugin) { + var _a3, _b2; + if (tab.conversationId) { + const conversation = plugin.getConversationSync(tab.conversationId); + if (conversation == null ? void 0 : conversation.providerId) { + return conversation.providerId; + } + } + if (tab.lifecycleState === "blank" && tab.draftModel) { + return getProviderForModel( + tab.draftModel, + plugin.settings + ); + } + return (_b2 = (_a3 = tab.service) == null ? void 0 : _a3.providerId) != null ? _b2 : tab.providerId; +} +function getTabProviderId(tab, plugin, conversation) { + var _a3; + return (_a3 = conversation == null ? void 0 : conversation.providerId) != null ? _a3 : getStoredConversationProviderId(tab, plugin); +} + +// src/features/chat/tabs/types.ts +var DEFAULT_MAX_TABS = 3; +var MIN_TABS = 3; +var MAX_TABS = 10; +var TEXTAREA_MIN_MAX_HEIGHT = 150; +var TEXTAREA_MAX_HEIGHT_PERCENT = 0.55; +function generateTabId() { + return `tab-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`; +} + +// src/features/chat/tabs/Tab.ts +function getBlankTabModelOptions(settings11) { + return ProviderRegistry.getEnabledProviderIds(settings11).flatMap((providerId) => { + var _a3, _b2; + const uiConfig = ProviderRegistry.getChatUIConfig(providerId); + const providerIcon = (_b2 = (_a3 = uiConfig.getProviderIcon) == null ? void 0 : _a3.call(uiConfig)) != null ? _b2 : void 0; + const group = ProviderRegistry.getProviderDisplayName(providerId); + return uiConfig.getModelOptions(settings11).map((model) => ({ ...model, group, providerIcon })); + }); +} +function resolveBlankTabModel(plugin, providerId) { + const settings11 = plugin.settings; + if (providerId) { + const snapshot = ProviderSettingsCoordinator.getProviderSettingsSnapshot(settings11, providerId); + return snapshot.model; + } + return settings11.model; +} +function getTabCapabilities(tab, plugin, conversation) { + var _a3; + const providerId = getTabProviderId(tab, plugin, conversation); + if (((_a3 = tab.service) == null ? void 0 : _a3.providerId) === providerId) { + return tab.service.getCapabilities(); + } + return ProviderRegistry.getCapabilities(providerId); +} +function getTabChatUIConfig(tab, plugin, conversation) { + return ProviderRegistry.getChatUIConfig(getTabProviderId(tab, plugin, conversation)); +} +function getTabSettingsSnapshot(tab, plugin) { + return ProviderSettingsCoordinator.getProviderSettingsSnapshot( + plugin.settings, + getTabProviderId(tab, plugin) + ); +} +function getTabHiddenCommands(tab, plugin, conversation) { + return getHiddenProviderCommandSet( + plugin.settings, + getTabProviderId(tab, plugin, conversation) + ); +} +function getRegistryProviderCatalogInfo(providerId) { + const catalog = ProviderWorkspaceRegistry.getCommandCatalog(providerId); + if (!catalog) { + return null; + } + return { + config: catalog.getDropdownConfig(), + getEntries: () => catalog.listDropdownEntries({ includeBuiltIns: false }) + }; +} +function getProviderMcpManager(providerId) { + return ProviderWorkspaceRegistry.getMcpServerManager(providerId); +} +function syncSlashCommandDropdownForProvider(tab, plugin, getProviderCatalogConfig, conversation) { + var _a3, _b2; + const dropdown = tab.ui.slashCommandDropdown; + if (!dropdown) { + return; + } + const catalogInfo = (_a3 = getProviderCatalogConfig == null ? void 0 : getProviderCatalogConfig()) != null ? _a3 : getRegistryProviderCatalogInfo(getTabProviderId(tab, plugin, conversation)); + if (catalogInfo) { + (_b2 = dropdown.setProviderCatalog) == null ? void 0 : _b2.call(dropdown, catalogInfo.config, catalogInfo.getEntries); + } else { + dropdown.resetSdkSkillsCache(); + } + dropdown.setHiddenCommands(getTabHiddenCommands(tab, plugin, conversation)); +} +async function updateTabProviderSettings(tab, plugin, update) { + const providerId = getTabProviderId(tab, plugin); + const snapshot = getTabSettingsSnapshot(tab, plugin); + update(snapshot); + ProviderSettingsCoordinator.commitProviderSettingsSnapshot( + plugin.settings, + providerId, + snapshot + ); + await plugin.saveSettings(); + return snapshot; +} +function refreshTabProviderUI(tab, plugin) { + var _a3, _b2, _c, _d, _e; + const capabilities = getTabCapabilities(tab, plugin); + (_a3 = tab.ui.modelSelector) == null ? void 0 : _a3.updateDisplay(); + (_b2 = tab.ui.modelSelector) == null ? void 0 : _b2.renderOptions(); + (_c = tab.ui.thinkingBudgetSelector) == null ? void 0 : _c.updateDisplay(); + (_d = tab.ui.permissionToggle) == null ? void 0 : _d.updateDisplay(); + (_e = tab.ui.serviceTierToggle) == null ? void 0 : _e.updateDisplay(); + tab.dom.inputWrapper.toggleClass( + "claudian-input-plan-mode", + plugin.settings.permissionMode === "plan" && capabilities.supportsPlanMode + ); +} +function applyProviderUIGating(tab, plugin) { + var _a3, _b2, _c, _d, _e, _f; + const capabilities = getTabCapabilities(tab, plugin); + const mcpManager = capabilities.supportsMcpTools ? getProviderMcpManager(capabilities.providerId) : null; + if (!capabilities.supportsMcpTools) { + (_a3 = tab.ui.mcpServerSelector) == null ? void 0 : _a3.clearEnabled(); + } + (_b2 = tab.ui.mcpServerSelector) == null ? void 0 : _b2.setVisible(capabilities.supportsMcpTools); + (_c = tab.ui.fileContextManager) == null ? void 0 : _c.setMcpManager(mcpManager); + (_d = tab.ui.fileContextManager) == null ? void 0 : _d.setAgentService( + ProviderWorkspaceRegistry.getAgentMentionProvider(capabilities.providerId) + ); + (_e = tab.ui.imageContextManager) == null ? void 0 : _e.setEnabled(capabilities.supportsImageAttachments); + (_f = tab.ui.contextUsageMeter) == null ? void 0 : _f.update(tab.state.usage); +} +function syncTabProviderServices(tab, plugin) { + var _a3, _b2, _c, _d, _e; + (_a3 = tab.services.instructionRefineService) == null ? void 0 : _a3.cancel(); + (_b2 = tab.services.instructionRefineService) == null ? void 0 : _b2.resetConversation(); + (_c = tab.services.titleGenerationService) == null ? void 0 : _c.cancel(); + tab.services.instructionRefineService = ProviderRegistry.createInstructionRefineService(plugin, tab.providerId); + tab.services.titleGenerationService = ProviderRegistry.createTitleGenerationService(plugin, tab.providerId); + (_e = (_d = tab.services.subagentManager).setTaskResultInterpreter) == null ? void 0 : _e.call( + _d, + ProviderRegistry.getTaskResultInterpreter(tab.providerId) + ); +} +function cleanupTabRuntime(tab) { + if (tab.service && typeof tab.service.cleanup === "function") { + tab.service.cleanup(); + } + tab.service = null; + tab.serviceInitialized = false; +} +function onProviderAvailabilityChanged(tab, plugin) { + var _a3, _b2, _c, _d, _e; + if (tab.lifecycleState !== "blank") return; + const settingsSnapshot = plugin.settings; + const enabledProviderIds = ProviderRegistry.getEnabledProviderIds(settingsSnapshot); + if (tab.draftModel) { + const draftProvider = getProviderForModel(tab.draftModel, settingsSnapshot); + if (!enabledProviderIds.includes(draftProvider)) { + const fallbackProviderId = (_a3 = enabledProviderIds[0]) != null ? _a3 : DEFAULT_CHAT_PROVIDER_ID; + const fallbackModels = ProviderRegistry.getChatUIConfig(fallbackProviderId).getModelOptions(settingsSnapshot); + tab.draftModel = (_c = (_b2 = fallbackModels[0]) == null ? void 0 : _b2.value) != null ? _c : tab.draftModel; + tab.providerId = fallbackProviderId; + } + } + if (tab.service && tab.draftModel && tab.service.providerId !== getProviderForModel(tab.draftModel, plugin.settings)) { + tab.service.cleanup(); + tab.service = null; + tab.serviceInitialized = false; + } + syncTabProviderServices(tab, plugin); + (_d = tab.ui.slashCommandDropdown) == null ? void 0 : _d.setHiddenCommands(getTabHiddenCommands(tab, plugin)); + (_e = tab.ui.slashCommandDropdown) == null ? void 0 : _e.resetSdkSkillsCache(); + refreshTabProviderUI(tab, plugin); + applyProviderUIGating(tab, plugin); +} +function createTab(options) { + var _a3, _b2; + const { + plugin, + containerEl, + conversation, + tabId, + onStreamingChanged, + onAttentionChanged, + onConversationIdChanged + } = options; + const id = tabId != null ? tabId : generateTabId(); + const contentEl = containerEl.createDiv({ cls: "claudian-tab-content" }); + contentEl.style.display = "none"; + const state = new ChatState({ + onStreamingStateChanged: onStreamingChanged, + onAttentionChanged, + onConversationChanged: onConversationIdChanged + }); + const subagentManager = new SubagentManager(() => { + }); + const dom = buildTabDOM(contentEl); + state.queueIndicatorEl = dom.queueIndicatorEl; + const isBound = !!(conversation == null ? void 0 : conversation.id); + const draftModel = isBound ? null : resolveBlankTabModel(plugin, options.defaultProviderId); + const initialProviderId = (_a3 = conversation == null ? void 0 : conversation.providerId) != null ? _a3 : draftModel ? getProviderForModel(draftModel, plugin.settings) : DEFAULT_CHAT_PROVIDER_ID; + const tab = { + id, + lifecycleState: isBound ? "bound_cold" : "blank", + draftModel, + providerId: initialProviderId, + conversationId: (_b2 = conversation == null ? void 0 : conversation.id) != null ? _b2 : null, + service: null, + serviceInitialized: false, + state, + controllers: { + selectionController: null, + browserSelectionController: null, + canvasSelectionController: null, + conversationController: null, + streamController: null, + inputController: null, + navigationController: null + }, + services: { + subagentManager, + instructionRefineService: null, + titleGenerationService: null + }, + ui: { + fileContextManager: null, + imageContextManager: null, + modelSelector: null, + thinkingBudgetSelector: null, + externalContextSelector: null, + mcpServerSelector: null, + permissionToggle: null, + serviceTierToggle: null, + slashCommandDropdown: null, + instructionModeManager: null, + bangBashModeManager: null, + contextUsageMeter: null, + statusPanel: null, + navigationSidebar: null + }, + dom, + renderer: null + }; + return tab; +} +function autoResizeTextarea(textarea) { + var _a3, _b2; + textarea.style.minHeight = ""; + const viewHeight = (_b2 = (_a3 = textarea.closest(".claudian-container")) == null ? void 0 : _a3.clientHeight) != null ? _b2 : window.innerHeight; + const maxHeight = Math.max(TEXTAREA_MIN_MAX_HEIGHT, viewHeight * TEXTAREA_MAX_HEIGHT_PERCENT); + const flexAllocatedHeight = textarea.offsetHeight; + const contentHeight = Math.min(textarea.scrollHeight, maxHeight); + if (contentHeight > flexAllocatedHeight) { + textarea.style.minHeight = `${contentHeight}px`; + } + textarea.style.maxHeight = `${maxHeight}px`; +} +function buildTabDOM(contentEl) { + const messagesWrapperEl = contentEl.createDiv({ cls: "claudian-messages-wrapper" }); + const messagesEl = messagesWrapperEl.createDiv({ cls: "claudian-messages" }); + const welcomeEl = messagesEl.createDiv({ cls: "claudian-welcome" }); + const statusPanelContainerEl = contentEl.createDiv({ cls: "claudian-status-panel-container" }); + const inputContainerEl = contentEl.createDiv({ cls: "claudian-input-container" }); + const queueIndicatorEl = inputContainerEl.createDiv({ cls: "claudian-input-queue-row" }); + const navRowEl = inputContainerEl.createDiv({ cls: "claudian-input-nav-row" }); + const inputWrapper = inputContainerEl.createDiv({ cls: "claudian-input-wrapper" }); + const contextRowEl = inputWrapper.createDiv({ cls: "claudian-context-row" }); + const inputEl = inputWrapper.createEl("textarea", { + cls: "claudian-input", + attr: { + placeholder: "How can I help you today?", + rows: "3", + dir: "auto" + } + }); + return { + contentEl, + messagesEl, + welcomeEl, + statusPanelContainerEl, + inputContainerEl, + queueIndicatorEl, + inputWrapper, + inputEl, + navRowEl, + contextRowEl, + selectionIndicatorEl: null, + browserIndicatorEl: null, + canvasIndicatorEl: null, + eventCleanups: [] + }; +} +async function initializeTabService(tab, plugin, argOrOverride, maybeOverride) { + var _a3; + if (tab.lifecycleState === "closing") { + return; + } + const conversationOverride = isConversationLike(argOrOverride) ? argOrOverride : argOrOverride === null ? null : maybeOverride; + const conversation = conversationOverride != null ? conversationOverride : tab.conversationId ? await plugin.getConversationById(tab.conversationId) : null; + const providerId = getTabProviderId(tab, plugin, conversation); + if (tab.serviceInitialized && ((_a3 = tab.service) == null ? void 0 : _a3.providerId) === providerId) { + return; + } + let service = null; + let unsubscribeReadyState = null; + const previousService = tab.service; + try { + if (typeof (previousService == null ? void 0 : previousService.cleanup) === "function") { + previousService.cleanup(); + } + tab.service = null; + tab.serviceInitialized = false; + const runtime = ProviderRegistry.createChatRuntime({ plugin, providerId }); + service = runtime; + unsubscribeReadyState = runtime.onReadyStateChange(() => { + }); + tab.dom.eventCleanups.push(() => unsubscribeReadyState == null ? void 0 : unsubscribeReadyState()); + if (conversation) { + const hasMessages = conversation.messages.length > 0; + const externalContextPaths = hasMessages ? conversation.externalContextPaths || [] : plugin.settings.persistentExternalContextPaths || []; + runtime.syncConversationState(conversation, externalContextPaths); + } + if (tab.lifecycleState === "closing") { + unsubscribeReadyState == null ? void 0 : unsubscribeReadyState(); + service == null ? void 0 : service.cleanup(); + return; + } + tab.providerId = providerId; + tab.service = service; + tab.serviceInitialized = true; + if (tab.lifecycleState === "blank") { + tab.draftModel = null; + } + tab.lifecycleState = "bound_active"; + } catch (error48) { + unsubscribeReadyState == null ? void 0 : unsubscribeReadyState(); + service == null ? void 0 : service.cleanup(); + tab.service = null; + tab.serviceInitialized = false; + throw error48; + } +} +function isConversationLike(value) { + return !!value && typeof value === "object" && typeof value.id === "string" && Array.isArray(value.messages); +} +function initializeContextManagers(tab, plugin) { + const { dom } = tab; + const app = plugin.app; + tab.ui.fileContextManager = new FileContextManager( + app, + dom.contextRowEl, + dom.inputEl, + { + getExcludedTags: () => plugin.settings.excludedTags, + onChipsChanged: () => { + var _a3, _b2, _c, _d; + (_a3 = tab.controllers.selectionController) == null ? void 0 : _a3.updateContextRowVisibility(); + (_b2 = tab.controllers.browserSelectionController) == null ? void 0 : _b2.updateContextRowVisibility(); + (_c = tab.controllers.canvasSelectionController) == null ? void 0 : _c.updateContextRowVisibility(); + autoResizeTextarea(dom.inputEl); + (_d = tab.renderer) == null ? void 0 : _d.scrollToBottomIfNeeded(); + }, + getExternalContexts: () => { + var _a3; + return ((_a3 = tab.ui.externalContextSelector) == null ? void 0 : _a3.getExternalContexts()) || []; + } + }, + dom.inputContainerEl + ); + tab.ui.fileContextManager.setMcpManager(getProviderMcpManager(getTabProviderId(tab, plugin))); + tab.ui.imageContextManager = new ImageContextManager( + dom.inputContainerEl, + dom.inputEl, + { + onImagesChanged: () => { + var _a3, _b2, _c, _d; + (_a3 = tab.controllers.selectionController) == null ? void 0 : _a3.updateContextRowVisibility(); + (_b2 = tab.controllers.browserSelectionController) == null ? void 0 : _b2.updateContextRowVisibility(); + (_c = tab.controllers.canvasSelectionController) == null ? void 0 : _c.updateContextRowVisibility(); + autoResizeTextarea(dom.inputEl); + (_d = tab.renderer) == null ? void 0 : _d.scrollToBottomIfNeeded(); + } + }, + dom.contextRowEl + ); +} +function initializeSlashCommands(tab, getHiddenCommands, catalogInfo) { + var _a3; + const { dom } = tab; + tab.ui.slashCommandDropdown = new SlashCommandDropdown( + dom.inputContainerEl, + dom.inputEl, + { + onSelect: () => { + }, + onHide: () => { + } + }, + { + hiddenCommands: (_a3 = getHiddenCommands == null ? void 0 : getHiddenCommands()) != null ? _a3 : /* @__PURE__ */ new Set(), + providerConfig: catalogInfo == null ? void 0 : catalogInfo.config, + getProviderEntries: catalogInfo == null ? void 0 : catalogInfo.getEntries + } + ); +} +function initializeInstructionAndTodo(tab, plugin) { + const { dom } = tab; + syncTabProviderServices(tab, plugin); + tab.ui.instructionModeManager = new InstructionModeManager( + dom.inputEl, + { + onSubmit: async (rawInstruction) => { + var _a3; + await ((_a3 = tab.controllers.inputController) == null ? void 0 : _a3.handleInstructionSubmit(rawInstruction)); + }, + getInputWrapper: () => dom.inputWrapper + } + ); + if (isBangBashEnabled(plugin.settings)) { + const vaultPath = getVaultPath(plugin.app); + if (vaultPath) { + const enhancedPath = getEnhancedPath(); + const bashService = new BangBashService(vaultPath, enhancedPath); + tab.ui.bangBashModeManager = new BangBashModeManager( + dom.inputEl, + { + onSubmit: async (command) => { + const statusPanel = tab.ui.statusPanel; + if (!statusPanel) return; + const id = `bash-${Date.now()}`; + statusPanel.addBashOutput({ id, command, status: "running", output: "" }); + const result = await bashService.execute(command); + const output = [result.stdout, result.stderr, result.error].filter(Boolean).join("\n").trim(); + const status = result.exitCode === 0 ? "completed" : "error"; + statusPanel.updateBashOutput(id, { status, output, exitCode: result.exitCode }); + }, + getInputWrapper: () => dom.inputWrapper + } + ); + } + } + tab.ui.statusPanel = new StatusPanel(); + tab.ui.statusPanel.mount(dom.statusPanelContainerEl); +} +function isBangBashEnabled(settings11) { + return ProviderRegistry.getEnabledProviderIds(settings11).some((providerId) => { + var _a3, _b2, _c; + return (_c = (_b2 = (_a3 = ProviderRegistry.getChatUIConfig(providerId)).isBangBashEnabled) == null ? void 0 : _b2.call(_a3, settings11)) != null ? _c : false; + }); +} +function initializeInputToolbar(tab, plugin, getProviderCatalogConfig, onProviderChanged) { + var _a3; + const { dom } = tab; + const inputToolbar = dom.inputWrapper.createDiv({ cls: "claudian-input-toolbar" }); + const blankTabUIConfigProxy = () => { + const draftProvider = tab.draftModel ? getProviderForModel(tab.draftModel, plugin.settings) : DEFAULT_CHAT_PROVIDER_ID; + const baseConfig = ProviderRegistry.getChatUIConfig(draftProvider); + return { + ...baseConfig, + getModelOptions: (settings11) => getBlankTabModelOptions(settings11) + }; + }; + const toolbarComponents = createInputToolbar(inputToolbar, { + getUIConfig: () => { + if (tab.lifecycleState === "blank") { + return blankTabUIConfigProxy(); + } + return getTabChatUIConfig(tab, plugin); + }, + getCapabilities: () => getTabCapabilities(tab, plugin), + getSettings: () => getTabSettingsSnapshot(tab, plugin), + getEnvironmentVariables: () => plugin.getActiveEnvironmentVariables(), + onModelChange: async (model) => { + var _a4, _b2, _c, _d, _e, _f, _g, _h, _i; + if (tab.lifecycleState === "blank") { + const previousProvider = tab.providerId; + tab.draftModel = model; + const newProvider = getProviderForModel(model, plugin.settings); + if (tab.service) { + cleanupTabRuntime(tab); + } + tab.providerId = newProvider; + if (newProvider !== previousProvider) { + syncTabProviderServices(tab, plugin); + } + syncSlashCommandDropdownForProvider(tab, plugin, getProviderCatalogConfig); + onProviderChanged == null ? void 0 : onProviderChanged(newProvider); + const uiConfig2 = ProviderRegistry.getChatUIConfig(newProvider); + await updateTabProviderSettings(tab, plugin, (settings11) => { + settings11.model = model; + uiConfig2.applyModelDefaults(model, settings11); + }); + (_a4 = tab.ui.thinkingBudgetSelector) == null ? void 0 : _a4.updateDisplay(); + (_b2 = tab.ui.serviceTierToggle) == null ? void 0 : _b2.updateDisplay(); + (_c = tab.ui.modelSelector) == null ? void 0 : _c.updateDisplay(); + (_d = tab.ui.modelSelector) == null ? void 0 : _d.renderOptions(); + applyProviderUIGating(tab, plugin); + return; + } + const boundProvider = tab.providerId; + const modelProvider = getProviderForModel(model, plugin.settings); + if (modelProvider !== boundProvider) { + new import_obsidian39.Notice("Cannot switch provider on a bound session. Start a new tab instead."); + (_e = tab.ui.modelSelector) == null ? void 0 : _e.updateDisplay(); + return; + } + const uiConfig = getTabChatUIConfig(tab, plugin); + const providerSettings = await updateTabProviderSettings(tab, plugin, (settings11) => { + settings11.model = model; + uiConfig.applyModelDefaults(model, settings11); + }); + (_f = tab.ui.thinkingBudgetSelector) == null ? void 0 : _f.updateDisplay(); + (_g = tab.ui.serviceTierToggle) == null ? void 0 : _g.updateDisplay(); + (_h = tab.ui.modelSelector) == null ? void 0 : _h.updateDisplay(); + (_i = tab.ui.modelSelector) == null ? void 0 : _i.renderOptions(); + const currentUsage = tab.state.usage; + if (currentUsage) { + const newContextWindow = uiConfig.getContextWindowSize( + model, + providerSettings.customContextLimits + ); + tab.state.usage = recalculateUsageForModel(currentUsage, model, newContextWindow); + } + }, + onThinkingBudgetChange: async (budget) => { + await updateTabProviderSettings(tab, plugin, (settings11) => { + settings11.thinkingBudget = budget; + }); + }, + onEffortLevelChange: async (effort) => { + await updateTabProviderSettings(tab, plugin, (settings11) => { + settings11.effortLevel = effort; + }); + }, + onServiceTierChange: async (serviceTier) => { + var _a4; + await updateTabProviderSettings(tab, plugin, (settings11) => { + settings11.serviceTier = serviceTier; + }); + (_a4 = tab.ui.serviceTierToggle) == null ? void 0 : _a4.updateDisplay(); + }, + onPermissionModeChange: async (mode) => { + plugin.settings.permissionMode = mode; + await plugin.saveSettings(); + dom.inputWrapper.toggleClass( + "claudian-input-plan-mode", + mode === "plan" && getTabCapabilities(tab, plugin).supportsPlanMode + ); + } + }); + tab.ui.modelSelector = toolbarComponents.modelSelector; + tab.ui.thinkingBudgetSelector = toolbarComponents.thinkingBudgetSelector; + tab.ui.contextUsageMeter = toolbarComponents.contextUsageMeter; + tab.ui.externalContextSelector = toolbarComponents.externalContextSelector; + tab.ui.mcpServerSelector = toolbarComponents.mcpServerSelector; + tab.ui.permissionToggle = toolbarComponents.permissionToggle; + tab.ui.serviceTierToggle = toolbarComponents.serviceTierToggle; + tab.ui.mcpServerSelector.setMcpManager(getProviderMcpManager(getTabProviderId(tab, plugin))); + (_a3 = tab.ui.fileContextManager) == null ? void 0 : _a3.setOnMcpMentionChange((servers) => { + var _a4; + (_a4 = tab.ui.mcpServerSelector) == null ? void 0 : _a4.addMentionedServers(servers); + }); + tab.ui.externalContextSelector.setOnChange(() => { + var _a4; + (_a4 = tab.ui.fileContextManager) == null ? void 0 : _a4.preScanExternalContexts(); + }); + tab.ui.externalContextSelector.setPersistentPaths( + plugin.settings.persistentExternalContextPaths || [] + ); + tab.ui.externalContextSelector.setOnPersistenceChange(async (paths) => { + plugin.settings.persistentExternalContextPaths = paths; + await plugin.saveSettings(); + }); + refreshTabProviderUI(tab, plugin); + applyProviderUIGating(tab, plugin); +} +function initializeTabUI(tab, plugin, options = {}) { + var _a3, _b2; + const { dom, state } = tab; + initializeContextManagers(tab, plugin); + dom.selectionIndicatorEl = dom.contextRowEl.createDiv({ cls: "claudian-selection-indicator" }); + dom.selectionIndicatorEl.style.display = "none"; + dom.browserIndicatorEl = dom.contextRowEl.createDiv({ cls: "claudian-browser-selection-indicator" }); + dom.browserIndicatorEl.style.display = "none"; + dom.canvasIndicatorEl = dom.contextRowEl.createDiv({ cls: "claudian-canvas-indicator" }); + dom.canvasIndicatorEl.style.display = "none"; + const catalogInfo = (_b2 = (_a3 = options.getProviderCatalogConfig) == null ? void 0 : _a3.call(options)) != null ? _b2 : null; + initializeSlashCommands( + tab, + () => getTabHiddenCommands(tab, plugin), + catalogInfo + ); + if (dom.messagesEl.parentElement) { + tab.ui.navigationSidebar = new NavigationSidebar( + dom.messagesEl.parentElement, + dom.messagesEl + ); + } + initializeInstructionAndTodo(tab, plugin); + initializeInputToolbar(tab, plugin, options.getProviderCatalogConfig, options.onProviderChanged); + state.callbacks = { + ...state.callbacks, + onUsageChanged: (usage) => { + var _a4; + (_a4 = tab.ui.contextUsageMeter) == null ? void 0 : _a4.update(usage); + }, + onTodosChanged: (todos) => { + var _a4; + return (_a4 = tab.ui.statusPanel) == null ? void 0 : _a4.updateTodos(todos); + }, + onAutoScrollChanged: () => { + var _a4; + return (_a4 = tab.ui.navigationSidebar) == null ? void 0 : _a4.updateVisibility(); + } + }; + const resizeObserver = new ResizeObserver(() => { + var _a4; + (_a4 = tab.ui.navigationSidebar) == null ? void 0 : _a4.updateVisibility(); + }); + resizeObserver.observe(dom.messagesEl); + dom.eventCleanups.push(() => resizeObserver.disconnect()); +} +function deepCloneMessages(messages) { + const sc = globalThis.structuredClone; + if (typeof sc === "function") { + return sc(messages); + } + return JSON.parse(JSON.stringify(messages)); +} +function countUserMessagesForForkTitle(messages) { + return messages.filter((m3) => m3.role === "user" && !m3.isInterrupt && !m3.isRebuiltContext).length; +} +function resolveForkSource(tab, plugin) { + var _a3; + const conversation = tab.conversationId ? plugin.getConversationSync(tab.conversationId) : null; + const sourceSessionId = tab.service ? tab.service.resolveSessionIdForFork(conversation != null ? conversation : null) : ProviderRegistry.getConversationHistoryService((_a3 = conversation == null ? void 0 : conversation.providerId) != null ? _a3 : tab.providerId).resolveSessionIdForConversation(conversation); + if (!sourceSessionId) { + new import_obsidian39.Notice(t("chat.fork.failed", { error: t("chat.fork.errorNoSession") })); + return null; + } + return { + providerId: getTabProviderId(tab, plugin, conversation), + sourceSessionId, + sourceProviderState: conversation == null ? void 0 : conversation.providerState, + sourceTitle: conversation == null ? void 0 : conversation.title, + currentNote: conversation == null ? void 0 : conversation.currentNote + }; +} +async function handleForkRequest(tab, plugin, userMessageId, forkRequestCallback) { + const { state } = tab; + if (!getTabCapabilities(tab, plugin).supportsFork) { + new import_obsidian39.Notice("Fork is not supported by this provider."); + return; + } + if (state.isStreaming) { + new import_obsidian39.Notice(t("chat.fork.unavailableStreaming")); + return; + } + const msgs = state.messages; + const userIdx = msgs.findIndex((m3) => m3.id === userMessageId); + if (userIdx === -1) { + new import_obsidian39.Notice(t("chat.fork.failed", { error: t("chat.fork.errorMessageNotFound") })); + return; + } + if (!msgs[userIdx].userMessageId) { + new import_obsidian39.Notice(t("chat.fork.unavailableNoUuid")); + return; + } + const rewindCtx = findRewindContext(msgs, userIdx); + if (!rewindCtx.hasResponse || !rewindCtx.prevAssistantUuid) { + new import_obsidian39.Notice(t("chat.fork.unavailableNoResponse")); + return; + } + const source = resolveForkSource(tab, plugin); + if (!source) return; + await forkRequestCallback({ + messages: deepCloneMessages(msgs.slice(0, userIdx)), + providerId: source.providerId, + sourceSessionId: source.sourceSessionId, + sourceProviderState: source.sourceProviderState, + resumeAt: rewindCtx.prevAssistantUuid, + sourceTitle: source.sourceTitle, + forkAtUserMessage: countUserMessagesForForkTitle(msgs.slice(0, userIdx + 1)), + currentNote: source.currentNote + }); +} +async function handleForkAll(tab, plugin, forkRequestCallback) { + const { state } = tab; + if (!getTabCapabilities(tab, plugin).supportsFork) { + new import_obsidian39.Notice("Fork is not supported by this provider."); + return; + } + if (state.isStreaming) { + new import_obsidian39.Notice(t("chat.fork.unavailableStreaming")); + return; + } + const msgs = state.messages; + if (msgs.length === 0) { + new import_obsidian39.Notice(t("chat.fork.commandNoMessages")); + return; + } + let lastAssistantUuid; + for (let i3 = msgs.length - 1; i3 >= 0; i3--) { + if (msgs[i3].role === "assistant" && msgs[i3].assistantMessageId) { + lastAssistantUuid = msgs[i3].assistantMessageId; + break; + } + } + if (!lastAssistantUuid) { + new import_obsidian39.Notice(t("chat.fork.commandNoAssistantUuid")); + return; + } + const source = resolveForkSource(tab, plugin); + if (!source) return; + await forkRequestCallback({ + messages: deepCloneMessages(msgs), + providerId: source.providerId, + sourceSessionId: source.sourceSessionId, + sourceProviderState: source.sourceProviderState, + resumeAt: lastAssistantUuid, + sourceTitle: source.sourceTitle, + forkAtUserMessage: countUserMessagesForForkTitle(msgs) + 1, + currentNote: source.currentNote + }); +} +function initializeTabControllers(tab, plugin, component, arg4, arg5, arg6, arg7) { + const isLegacy = arg4 !== void 0 && typeof arg4 !== "function"; + const forkRequestCallback = isLegacy ? arg5 : arg4; + const openConversation = isLegacy ? arg6 : arg5; + const getProviderCatalogConfig = isLegacy ? arg7 : arg6; + const { dom, state, services, ui } = tab; + tab.renderer = new MessageRenderer( + plugin, + component, + dom.messagesEl, + (id) => tab.controllers.conversationController.rewind(id), + forkRequestCallback ? (id) => handleForkRequest(tab, plugin, id, forkRequestCallback) : void 0, + () => getTabCapabilities(tab, plugin) + ); + tab.controllers.selectionController = new SelectionController( + plugin.app, + dom.selectionIndicatorEl, + dom.inputEl, + dom.contextRowEl, + () => autoResizeTextarea(dom.inputEl), + dom.contentEl + ); + tab.controllers.browserSelectionController = new BrowserSelectionController( + plugin.app, + dom.browserIndicatorEl, + dom.inputEl, + dom.contextRowEl, + () => autoResizeTextarea(dom.inputEl) + ); + tab.controllers.canvasSelectionController = new CanvasSelectionController( + plugin.app, + dom.canvasIndicatorEl, + dom.inputEl, + dom.contextRowEl, + () => autoResizeTextarea(dom.inputEl) + ); + tab.controllers.streamController = new StreamController({ + plugin, + state, + renderer: tab.renderer, + subagentManager: services.subagentManager, + getMessagesEl: () => dom.messagesEl, + getFileContextManager: () => ui.fileContextManager, + updateQueueIndicator: () => { + var _a3; + return (_a3 = tab.controllers.inputController) == null ? void 0 : _a3.updateQueueIndicator(); + }, + getAgentService: () => tab.service + }); + services.subagentManager.setCallback( + (subagent) => { + var _a3, _b2; + (_a3 = tab.controllers.streamController) == null ? void 0 : _a3.onAsyncSubagentStateChange(subagent); + if (!tab.state.isStreaming && tab.state.currentConversationId) { + void ((_b2 = tab.controllers.conversationController) == null ? void 0 : _b2.save(false).catch(() => { + })); + } + } + ); + tab.controllers.conversationController = new ConversationController( + { + plugin, + state, + renderer: tab.renderer, + subagentManager: services.subagentManager, + getHistoryDropdown: () => null, + // Tab doesn't have its own history dropdown + getWelcomeEl: () => dom.welcomeEl, + setWelcomeEl: (el2) => { + dom.welcomeEl = el2; + }, + getMessagesEl: () => dom.messagesEl, + getInputEl: () => dom.inputEl, + getFileContextManager: () => ui.fileContextManager, + getImageContextManager: () => ui.imageContextManager, + getMcpServerSelector: () => ui.mcpServerSelector, + getExternalContextSelector: () => ui.externalContextSelector, + clearQueuedMessage: () => { + var _a3; + return (_a3 = tab.controllers.inputController) == null ? void 0 : _a3.clearQueuedMessage(); + }, + getTitleGenerationService: () => services.titleGenerationService, + getStatusPanel: () => ui.statusPanel, + getAgentService: () => tab.service, + // Use tab's service instead of plugin's + dismissPendingInlinePrompts: () => { + var _a3; + return (_a3 = tab.controllers.inputController) == null ? void 0 : _a3.dismissPendingApproval(); + }, + ensureServiceForConversation: async (conversation) => { + var _a3; + const nextProviderId = getTabProviderId(tab, plugin, conversation); + const providerChanged = tab.providerId !== nextProviderId; + tab.providerId = nextProviderId; + if (providerChanged) { + syncTabProviderServices(tab, plugin); + } + tab.conversationId = (_a3 = conversation == null ? void 0 : conversation.id) != null ? _a3 : null; + tab.draftModel = null; + tab.lifecycleState = conversation ? "bound_cold" : "blank"; + syncSlashCommandDropdownForProvider(tab, plugin, getProviderCatalogConfig, conversation); + if (tab.service && tab.service.providerId === nextProviderId && conversation) { + const hasMessages = conversation.messages.length > 0; + const externalContextPaths = hasMessages ? conversation.externalContextPaths || [] : plugin.settings.persistentExternalContextPaths || []; + tab.service.syncConversationState(conversation, externalContextPaths); + } + refreshTabProviderUI(tab, plugin); + applyProviderUIGating(tab, plugin); + } + }, + { + onNewConversation: () => { + const previousProviderId = tab.providerId; + cleanupTabRuntime(tab); + tab.lifecycleState = "blank"; + tab.draftModel = resolveBlankTabModel(plugin, previousProviderId); + tab.conversationId = null; + tab.providerId = getTabProviderId(tab, plugin); + if (tab.providerId !== previousProviderId) { + syncTabProviderServices(tab, plugin); + } + refreshTabProviderUI(tab, plugin); + applyProviderUIGating(tab, plugin); + syncSlashCommandDropdownForProvider(tab, plugin, getProviderCatalogConfig); + }, + onConversationLoaded: () => { + var _a3; + return (_a3 = ui.slashCommandDropdown) == null ? void 0 : _a3.resetSdkSkillsCache(); + }, + onConversationSwitched: () => { + var _a3; + return (_a3 = ui.slashCommandDropdown) == null ? void 0 : _a3.resetSdkSkillsCache(); + } + } + ); + tab.controllers.inputController = new InputController({ + plugin, + state, + renderer: tab.renderer, + streamController: tab.controllers.streamController, + selectionController: tab.controllers.selectionController, + browserSelectionController: tab.controllers.browserSelectionController, + canvasSelectionController: tab.controllers.canvasSelectionController, + conversationController: tab.controllers.conversationController, + getInputEl: () => dom.inputEl, + getInputContainerEl: () => dom.inputContainerEl, + getWelcomeEl: () => dom.welcomeEl, + getMessagesEl: () => dom.messagesEl, + getFileContextManager: () => ui.fileContextManager, + getImageContextManager: () => ui.imageContextManager, + getMcpServerSelector: () => ui.mcpServerSelector, + getExternalContextSelector: () => ui.externalContextSelector, + getInstructionModeManager: () => ui.instructionModeManager, + getInstructionRefineService: () => services.instructionRefineService, + getTitleGenerationService: () => services.titleGenerationService, + getStatusPanel: () => ui.statusPanel, + generateId: generateMessageId, + resetInputHeight: () => { + }, + getAgentService: () => tab.service, + getSubagentManager: () => services.subagentManager, + getTabProviderId: () => getTabProviderId(tab, plugin), + ensureServiceInitialized: async () => { + if (tab.serviceInitialized && tab.lifecycleState === "bound_active") { + return true; + } + try { + if (tab.lifecycleState === "blank" && tab.draftModel) { + const derivedProvider = getProviderForModel(tab.draftModel, plugin.settings); + tab.providerId = derivedProvider; + } + await initializeTabService(tab, plugin); + setupServiceCallbacks(tab, plugin); + refreshTabProviderUI(tab, plugin); + applyProviderUIGating(tab, plugin); + return true; + } catch (error48) { + new import_obsidian39.Notice(error48 instanceof Error ? error48.message : "Failed to initialize chat service"); + return false; + } + }, + openConversation, + onForkAll: forkRequestCallback ? () => handleForkAll(tab, plugin, forkRequestCallback) : void 0, + restorePrePlanPermissionModeIfNeeded: () => { + var _a3; + if (plugin.settings.permissionMode === "plan") { + const restoreMode = (_a3 = tab.state.prePlanPermissionMode) != null ? _a3 : "normal"; + tab.state.prePlanPermissionMode = null; + updatePlanModeUI(tab, plugin, restoreMode); + } + } + }); + tab.controllers.navigationController = new NavigationController({ + getMessagesEl: () => dom.messagesEl, + getInputEl: () => dom.inputEl, + getSettings: () => plugin.settings.keyboardNavigation, + isStreaming: () => state.isStreaming, + shouldSkipEscapeHandling: () => { + var _a3, _b2, _c, _d, _e; + if ((_a3 = ui.instructionModeManager) == null ? void 0 : _a3.isActive()) return true; + if ((_b2 = ui.bangBashModeManager) == null ? void 0 : _b2.isActive()) return true; + if ((_c = tab.controllers.inputController) == null ? void 0 : _c.isResumeDropdownVisible()) return true; + if ((_d = ui.slashCommandDropdown) == null ? void 0 : _d.isVisible()) return true; + if ((_e = ui.fileContextManager) == null ? void 0 : _e.isMentionDropdownVisible()) return true; + return false; + } + }); + tab.controllers.navigationController.initialize(); +} +function wireTabInputEvents(tab, plugin) { + var _a3, _b2; + const { dom, ui, state, controllers } = tab; + let wasBangBashActive = (_b2 = (_a3 = ui.bangBashModeManager) == null ? void 0 : _a3.isActive()) != null ? _b2 : false; + const syncBangBashSuppression = () => { + var _a4, _b3, _c, _d; + const isActive = (_b3 = (_a4 = ui.bangBashModeManager) == null ? void 0 : _a4.isActive()) != null ? _b3 : false; + if (isActive === wasBangBashActive) return; + wasBangBashActive = isActive; + (_c = ui.slashCommandDropdown) == null ? void 0 : _c.setEnabled(!isActive); + if (isActive) { + (_d = ui.fileContextManager) == null ? void 0 : _d.hideMentionDropdown(); + } + }; + const keydownHandler = (e3) => { + var _a4, _b3, _c, _d, _e, _f, _g, _h, _i; + if ((_a4 = ui.bangBashModeManager) == null ? void 0 : _a4.isActive()) { + ui.bangBashModeManager.handleKeydown(e3); + syncBangBashSuppression(); + return; + } + if (getTabCapabilities(tab, plugin).supportsInstructionMode && ((_b3 = ui.instructionModeManager) == null ? void 0 : _b3.handleTriggerKey(e3))) { + return; + } + if ((_c = ui.bangBashModeManager) == null ? void 0 : _c.handleTriggerKey(e3)) { + syncBangBashSuppression(); + return; + } + if (getTabCapabilities(tab, plugin).supportsInstructionMode && ((_d = ui.instructionModeManager) == null ? void 0 : _d.handleKeydown(e3))) { + return; + } + if ((_e = controllers.inputController) == null ? void 0 : _e.handleResumeKeydown(e3)) { + return; + } + if ((_f = ui.slashCommandDropdown) == null ? void 0 : _f.handleKeydown(e3)) { + return; + } + if ((_g = ui.fileContextManager) == null ? void 0 : _g.handleMentionKeydown(e3)) { + return; + } + if (e3.key === "Escape" && !e3.isComposing && state.isStreaming) { + e3.preventDefault(); + (_h = controllers.inputController) == null ? void 0 : _h.cancelStreaming(); + return; + } + if (e3.key === "Enter" && !e3.shiftKey && !e3.isComposing) { + e3.preventDefault(); + void ((_i = controllers.inputController) == null ? void 0 : _i.sendMessage()); + } + }; + dom.inputEl.addEventListener("keydown", keydownHandler); + dom.eventCleanups.push(() => dom.inputEl.removeEventListener("keydown", keydownHandler)); + const inputHandler = () => { + var _a4, _b3, _c, _d; + if (!((_a4 = ui.bangBashModeManager) == null ? void 0 : _a4.isActive())) { + (_b3 = ui.fileContextManager) == null ? void 0 : _b3.handleInputChange(); + } + (_c = ui.instructionModeManager) == null ? void 0 : _c.handleInputChange(); + (_d = ui.bangBashModeManager) == null ? void 0 : _d.handleInputChange(); + syncBangBashSuppression(); + autoResizeTextarea(dom.inputEl); + }; + dom.inputEl.addEventListener("input", inputHandler); + dom.eventCleanups.push(() => dom.inputEl.removeEventListener("input", inputHandler)); + const focusHandler = (e3) => { + var _a4; + if (e3.relatedTarget && dom.contentEl.contains(e3.relatedTarget)) return; + (_a4 = controllers.selectionController) == null ? void 0 : _a4.showHighlight(); + }; + dom.contentEl.addEventListener("focusin", focusHandler); + dom.eventCleanups.push(() => dom.contentEl.removeEventListener("focusin", focusHandler)); + const SCROLL_THRESHOLD = 20; + const RE_ENABLE_DELAY = 150; + let reEnableTimeout = null; + const isAutoScrollAllowed = () => { + var _a4; + return (_a4 = plugin.settings.enableAutoScroll) != null ? _a4 : true; + }; + const scrollHandler = () => { + if (!isAutoScrollAllowed()) { + if (reEnableTimeout) { + clearTimeout(reEnableTimeout); + reEnableTimeout = null; + } + state.autoScrollEnabled = false; + return; + } + const { scrollTop, scrollHeight, clientHeight } = dom.messagesEl; + const isAtBottom = scrollHeight - scrollTop - clientHeight <= SCROLL_THRESHOLD; + if (!isAtBottom) { + if (reEnableTimeout) { + clearTimeout(reEnableTimeout); + reEnableTimeout = null; + } + state.autoScrollEnabled = false; + } else if (!state.autoScrollEnabled) { + if (!reEnableTimeout) { + reEnableTimeout = setTimeout(() => { + reEnableTimeout = null; + const { scrollTop: scrollTop2, scrollHeight: scrollHeight2, clientHeight: clientHeight2 } = dom.messagesEl; + if (scrollHeight2 - scrollTop2 - clientHeight2 <= SCROLL_THRESHOLD) { + state.autoScrollEnabled = true; + } + }, RE_ENABLE_DELAY); + } + } + }; + dom.messagesEl.addEventListener("scroll", scrollHandler, { passive: true }); + dom.eventCleanups.push(() => { + dom.messagesEl.removeEventListener("scroll", scrollHandler); + if (reEnableTimeout) clearTimeout(reEnableTimeout); + }); +} +function activateTab(tab) { + var _a3, _b2, _c, _d; + tab.dom.contentEl.style.display = "flex"; + (_a3 = tab.controllers.selectionController) == null ? void 0 : _a3.start(); + (_b2 = tab.controllers.browserSelectionController) == null ? void 0 : _b2.start(); + (_c = tab.controllers.canvasSelectionController) == null ? void 0 : _c.start(); + (_d = tab.ui.navigationSidebar) == null ? void 0 : _d.updateVisibility(); +} +function deactivateTab(tab) { + var _a3, _b2, _c; + tab.dom.contentEl.style.display = "none"; + (_a3 = tab.controllers.selectionController) == null ? void 0 : _a3.stop(); + (_b2 = tab.controllers.browserSelectionController) == null ? void 0 : _b2.stop(); + (_c = tab.controllers.canvasSelectionController) == null ? void 0 : _c.stop(); +} +async function destroyTab(tab) { + var _a3, _b2, _c, _d, _e, _f, _g, _h, _i, _j2, _k, _l, _m, _n, _o, _p, _q, _r, _s; + tab.lifecycleState = "closing"; + (_a3 = tab.controllers.selectionController) == null ? void 0 : _a3.stop(); + (_b2 = tab.controllers.selectionController) == null ? void 0 : _b2.clear(); + (_c = tab.controllers.browserSelectionController) == null ? void 0 : _c.stop(); + (_d = tab.controllers.browserSelectionController) == null ? void 0 : _d.clear(); + (_e = tab.controllers.canvasSelectionController) == null ? void 0 : _e.stop(); + (_f = tab.controllers.canvasSelectionController) == null ? void 0 : _f.clear(); + (_g = tab.controllers.navigationController) == null ? void 0 : _g.dispose(); + cleanupThinkingBlock(tab.state.currentThinkingState); + tab.state.currentThinkingState = null; + (_h = tab.controllers.inputController) == null ? void 0 : _h.dismissPendingApproval(); + (_i = tab.controllers.inputController) == null ? void 0 : _i.destroyResumeDropdown(); + (_j2 = tab.ui.fileContextManager) == null ? void 0 : _j2.destroy(); + (_k = tab.ui.slashCommandDropdown) == null ? void 0 : _k.destroy(); + tab.ui.slashCommandDropdown = null; + (_l = tab.ui.instructionModeManager) == null ? void 0 : _l.destroy(); + tab.ui.instructionModeManager = null; + (_m = tab.ui.bangBashModeManager) == null ? void 0 : _m.destroy(); + tab.ui.bangBashModeManager = null; + (_n = tab.services.instructionRefineService) == null ? void 0 : _n.cancel(); + (_o = tab.services.instructionRefineService) == null ? void 0 : _o.resetConversation(); + tab.services.instructionRefineService = null; + (_p = tab.services.titleGenerationService) == null ? void 0 : _p.cancel(); + tab.services.titleGenerationService = null; + (_q = tab.ui.statusPanel) == null ? void 0 : _q.destroy(); + tab.ui.statusPanel = null; + (_r = tab.ui.navigationSidebar) == null ? void 0 : _r.destroy(); + tab.ui.navigationSidebar = null; + tab.services.subagentManager.orphanAllActive(); + tab.services.subagentManager.clear(); + for (const cleanup of tab.dom.eventCleanups) { + cleanup(); + } + tab.dom.eventCleanups.length = 0; + (_s = tab.service) == null ? void 0 : _s.cleanup(); + tab.service = null; + tab.dom.contentEl.remove(); +} +function getTabTitle(tab, plugin) { + if (tab.conversationId) { + const conversation = plugin.getConversationSync(tab.conversationId); + if (conversation == null ? void 0 : conversation.title) { + return conversation.title; + } + } + return "New Chat"; +} +function setupServiceCallbacks(tab, plugin) { + if (tab.service && tab.controllers.inputController) { + tab.service.setApprovalCallback( + async (toolName, input, description, options) => { + var _a3, _b2; + return (_b2 = await ((_a3 = tab.controllers.inputController) == null ? void 0 : _a3.handleApprovalRequest(toolName, input, description, options))) != null ? _b2 : "cancel"; + } + ); + tab.service.setApprovalDismisser( + () => { + var _a3; + return (_a3 = tab.controllers.inputController) == null ? void 0 : _a3.dismissPendingApprovalPrompt(); + } + ); + tab.service.setAskUserQuestionCallback( + async (input, signal) => { + var _a3, _b2; + return (_b2 = await ((_a3 = tab.controllers.inputController) == null ? void 0 : _a3.handleAskUserQuestion(input, signal))) != null ? _b2 : null; + } + ); + tab.service.setExitPlanModeCallback( + async (input, signal) => { + var _a3, _b2, _c; + const decision = (_b2 = await ((_a3 = tab.controllers.inputController) == null ? void 0 : _a3.handleExitPlanMode(input, signal))) != null ? _b2 : null; + if (decision !== null && decision.type !== "feedback") { + if (plugin.settings.permissionMode === "plan") { + const restoreMode = (_c = tab.state.prePlanPermissionMode) != null ? _c : "normal"; + tab.state.prePlanPermissionMode = null; + updatePlanModeUI(tab, plugin, restoreMode); + } + if (decision.type === "approve-new-session") { + tab.state.pendingNewSessionPlan = decision.planContent; + tab.state.cancelRequested = true; + } + } + return decision; + } + ); + tab.service.setSubagentHookProvider( + () => ({ + hasRunning: tab.services.subagentManager.hasRunningSubagents() + }) + ); + tab.service.setAutoTurnCallback((result) => { + renderAutoTriggeredTurn(tab, result); + }); + tab.service.setPermissionModeSyncCallback((sdkMode) => { + let mode; + if (sdkMode === "bypassPermissions") mode = "yolo"; + else if (sdkMode === "plan") mode = "plan"; + else mode = "normal"; + if (plugin.settings.permissionMode !== mode) { + if (mode === "plan" && tab.state.prePlanPermissionMode === null) { + tab.state.prePlanPermissionMode = plugin.settings.permissionMode; + } + updatePlanModeUI(tab, plugin, mode); + } + }); + } +} +function generateMessageId() { + return `msg-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`; +} +function renderAutoTriggeredTurn(tab, result) { + var _a3, _b2, _c; + if (!tab.dom.contentEl.isConnected) { + return; + } + const { chunks, metadata } = result; + const hasToolActivity = chunks.some( + (chunk) => chunk.type === "tool_use" || chunk.type === "tool_result" + ); + let textContent = ""; + for (const chunk of chunks) { + if (chunk.type === "text") { + textContent += chunk.content; + } + } + if (!textContent.trim() && !hasToolActivity) return; + const content = textContent.trim() || "(background task completed)"; + const assistantMsg = { + id: (_a3 = metadata.assistantMessageId) != null ? _a3 : generateMessageId(), + role: "assistant", + content, + timestamp: Date.now(), + contentBlocks: [{ type: "text", content }], + ...metadata.assistantMessageId && { assistantMessageId: metadata.assistantMessageId } + }; + tab.state.addMessage(assistantMsg); + (_b2 = tab.renderer) == null ? void 0 : _b2.renderStoredMessage(assistantMsg); + (_c = tab.renderer) == null ? void 0 : _c.scrollToBottom(); +} +function updatePlanModeUI(tab, plugin, mode) { + var _a3; + plugin.settings.permissionMode = mode; + void plugin.saveSettings(); + (_a3 = tab.ui.permissionToggle) == null ? void 0 : _a3.updateDisplay(); + tab.dom.inputWrapper.toggleClass( + "claudian-input-plan-mode", + mode === "plan" && getTabCapabilities(tab, plugin).supportsPlanMode + ); +} + +// src/features/chat/tabs/TabBar.ts +var TabBar = class { + constructor(containerEl, callbacks) { + this.containerEl = containerEl; + this.callbacks = callbacks; + this.build(); + } + /** Builds the tab bar UI. */ + build() { + this.containerEl.addClass("claudian-tab-badges"); + } + /** + * Updates the tab bar with new tab data. + * @param items Tab items to render. + */ + update(items) { + this.containerEl.empty(); + for (const item of items) { + this.renderBadge(item); + } + } + /** Renders a single tab badge. */ + renderBadge(item) { + let stateClass = "claudian-tab-badge-idle"; + if (item.isActive) { + stateClass = "claudian-tab-badge-active"; + } else if (item.needsAttention) { + stateClass = "claudian-tab-badge-attention"; + } else if (item.isStreaming) { + stateClass = "claudian-tab-badge-streaming"; + } + const badgeEl = this.containerEl.createDiv({ + cls: `claudian-tab-badge ${stateClass}`, + text: String(item.index) + }); + badgeEl.setAttribute("aria-label", item.title); + badgeEl.setAttribute("title", item.title); + badgeEl.addEventListener("click", () => { + this.callbacks.onTabClick(item.id); + }); + if (item.canClose) { + badgeEl.addEventListener("contextmenu", (e3) => { + e3.preventDefault(); + this.callbacks.onTabClose(item.id); + }); + } + } + /** Destroys the tab bar. */ + destroy() { + this.containerEl.empty(); + this.containerEl.removeClass("claudian-tab-badges"); + } +}; + +// src/features/chat/tabs/TabManager.ts +var import_obsidian41 = require("obsidian"); + +// src/shared/modals/ForkTargetModal.ts +var import_obsidian40 = require("obsidian"); +function chooseForkTarget(app) { + return new Promise((resolve5) => { + new ForkTargetModal(app, resolve5).open(); + }); +} +var ForkTargetModal = class extends import_obsidian40.Modal { + constructor(app, resolve5) { + super(app); + this.resolved = false; + this.resolve = resolve5; + } + onOpen() { + this.setTitle(t("chat.fork.chooseTarget")); + this.modalEl.addClass("claudian-fork-target-modal"); + const list = this.contentEl.createDiv({ cls: "claudian-fork-target-list" }); + this.createOption(list, "current-tab", t("chat.fork.targetCurrentTab")); + this.createOption(list, "new-tab", t("chat.fork.targetNewTab")); + } + createOption(container, target, label) { + const item = container.createDiv({ cls: "claudian-fork-target-option", text: label }); + item.addEventListener("click", () => { + this.resolved = true; + this.resolve(target); + this.close(); + }); + } + onClose() { + if (!this.resolved) { + this.resolve(null); + } + this.contentEl.empty(); + } +}; + +// src/features/chat/tabs/TabManager.ts +function isTabManagerViewHost(value) { + return !!value && typeof value === "object" && "getTabManager" in value; +} +var TabManager = class { + constructor(plugin, arg2, arg3, arg4, arg5 = {}) { + this.tabs = /* @__PURE__ */ new Map(); + this.activeTabId = null; + /** Guard to prevent concurrent tab switches. */ + this.isSwitchingTab = false; + this.plugin = plugin; + if (isTabManagerViewHost(arg3)) { + this.containerEl = arg2; + this.view = arg3; + this.callbacks = arg4 != null ? arg4 : {}; + return; + } + this.containerEl = arg3; + this.view = arg4; + this.callbacks = arg5; + } + /** + * Gets the current max tabs limit from settings. + * Clamps to MIN_TABS and MAX_TABS bounds. + */ + getMaxTabs() { + var _a3; + const settingsValue = (_a3 = this.plugin.settings.maxTabs) != null ? _a3 : DEFAULT_MAX_TABS; + return Math.max(MIN_TABS, Math.min(MAX_TABS, settingsValue)); + } + // ============================================ + // Tab Lifecycle + // ============================================ + /** + * Creates a new tab. + * @param conversationId Optional conversation to load into the tab. + * @param tabId Optional tab ID (for restoration). + * @returns The created tab, or null if max tabs reached. + */ + async createTab(conversationId, tabId) { + var _a3, _b2; + const maxTabs = this.getMaxTabs(); + if (this.tabs.size >= maxTabs) { + return null; + } + const conversation = conversationId ? await this.plugin.getConversationById(conversationId) : void 0; + const activeTab = this.getActiveTab(); + const defaultProviderId = conversation ? void 0 : activeTab ? getTabProviderId(activeTab, this.plugin) : void 0; + const tab = createTab({ + plugin: this.plugin, + containerEl: this.containerEl, + conversation: conversation != null ? conversation : void 0, + tabId, + defaultProviderId, + onStreamingChanged: (isStreaming) => { + var _a4, _b3; + (_b3 = (_a4 = this.callbacks).onTabStreamingChanged) == null ? void 0 : _b3.call(_a4, tab.id, isStreaming); + }, + onTitleChanged: (title) => { + var _a4, _b3; + (_b3 = (_a4 = this.callbacks).onTabTitleChanged) == null ? void 0 : _b3.call(_a4, tab.id, title); + }, + onAttentionChanged: (needsAttention) => { + var _a4, _b3; + (_b3 = (_a4 = this.callbacks).onTabAttentionChanged) == null ? void 0 : _b3.call(_a4, tab.id, needsAttention); + }, + onConversationIdChanged: (conversationId2) => { + var _a4, _b3; + tab.conversationId = conversationId2; + (_b3 = (_a4 = this.callbacks).onTabConversationChanged) == null ? void 0 : _b3.call(_a4, tab.id, conversationId2); + } + }); + initializeTabUI(tab, this.plugin, { + getProviderCatalogConfig: () => this.getProviderCatalogConfig(tab), + onProviderChanged: (providerId) => { + var _a4, _b3; + (_b3 = (_a4 = this.callbacks).onTabProviderChanged) == null ? void 0 : _b3.call(_a4, tab.id, providerId); + } + }); + initializeTabControllers( + tab, + this.plugin, + this.view, + (forkContext) => this.handleForkRequest(forkContext), + (conversationId2) => this.openConversation(conversationId2), + () => this.getProviderCatalogConfig(tab) + ); + wireTabInputEvents(tab, this.plugin); + this.tabs.set(tab.id, tab); + (_b2 = (_a3 = this.callbacks).onTabCreated) == null ? void 0 : _b2.call(_a3, tab); + await this.switchToTab(tab.id); + return tab; + } + /** + * Switches to a different tab. + * @param tabId The tab to switch to. + */ + async switchToTab(tabId) { + var _a3, _b2, _c, _d; + const tab = this.tabs.get(tabId); + if (!tab) { + return; + } + if (this.isSwitchingTab) { + return; + } + this.isSwitchingTab = true; + const previousTabId = this.activeTabId; + try { + if (previousTabId && previousTabId !== tabId) { + const currentTab = this.tabs.get(previousTabId); + if (currentTab) { + deactivateTab(currentTab); + } + } + this.activeTabId = tabId; + activateTab(tab); + if (tab.conversationId && tab.state.messages.length === 0) { + await ((_a3 = tab.controllers.conversationController) == null ? void 0 : _a3.switchTo(tab.conversationId)); + } else if (tab.conversationId && tab.state.messages.length > 0 && tab.service) { + const conversation = this.plugin.getConversationSync(tab.conversationId); + if (conversation) { + const hasMessages = conversation.messages.length > 0; + const externalContextPaths = hasMessages ? conversation.externalContextPaths || [] : this.plugin.settings.persistentExternalContextPaths || []; + tab.service.syncConversationState(conversation, externalContextPaths); + } + } else if (!tab.conversationId && tab.state.messages.length === 0) { + (_b2 = tab.controllers.conversationController) == null ? void 0 : _b2.initializeWelcome(); + } + (_d = (_c = this.callbacks).onTabSwitched) == null ? void 0 : _d.call(_c, previousTabId, tabId); + } finally { + this.isSwitchingTab = false; + } + } + /** + * Closes a tab. + * @param tabId The tab to close. + * @param force If true, close even if streaming. + * @returns True if the tab was closed. + */ + async closeTab(tabId, force = false) { + var _a3, _b2, _c; + const tab = this.tabs.get(tabId); + if (!tab) { + return false; + } + if (tab.state.isStreaming && !force) { + return false; + } + if (this.tabs.size === 1 && !tab.conversationId && tab.state.messages.length === 0) { + return false; + } + await ((_a3 = tab.controllers.conversationController) == null ? void 0 : _a3.save()); + const tabIdsBefore = Array.from(this.tabs.keys()); + const closingIndex = tabIdsBefore.indexOf(tabId); + await destroyTab(tab); + this.tabs.delete(tabId); + (_c = (_b2 = this.callbacks).onTabClosed) == null ? void 0 : _c.call(_b2, tabId); + if (this.activeTabId === tabId) { + this.activeTabId = null; + if (this.tabs.size > 0) { + const fallbackTabId = closingIndex === 0 ? tabIdsBefore[1] : tabIdsBefore[closingIndex - 1]; + if (fallbackTabId && this.tabs.has(fallbackTabId)) { + await this.switchToTab(fallbackTabId); + } + } else { + await this.createTab(); + } + } + return true; + } + // ============================================ + // Tab Queries + // ============================================ + /** Gets the currently active tab. */ + getActiveTab() { + var _a3; + return this.activeTabId ? (_a3 = this.tabs.get(this.activeTabId)) != null ? _a3 : null : null; + } + /** Gets the active tab ID. */ + getActiveTabId() { + return this.activeTabId; + } + /** Gets a tab by ID. */ + getTab(tabId) { + var _a3; + return (_a3 = this.tabs.get(tabId)) != null ? _a3 : null; + } + /** Gets all tabs. */ + getAllTabs() { + return Array.from(this.tabs.values()); + } + /** Gets the number of tabs. */ + getTabCount() { + return this.tabs.size; + } + /** Checks if more tabs can be created. */ + canCreateTab() { + return this.tabs.size < this.getMaxTabs(); + } + // ============================================ + // Tab Bar Data + // ============================================ + /** Gets data for rendering the tab bar. */ + getTabBarItems() { + const items = []; + let index = 1; + for (const tab of this.tabs.values()) { + items.push({ + id: tab.id, + index: index++, + title: getTabTitle(tab, this.plugin), + isActive: tab.id === this.activeTabId, + isStreaming: tab.state.isStreaming, + needsAttention: tab.state.needsAttention, + canClose: this.tabs.size > 1 || !tab.state.isStreaming + }); + } + return items; + } + // ============================================ + // Conversation Management + // ============================================ + /** + * Opens a conversation in a new tab or existing tab. + * @param conversationId The conversation to open. + * @param preferNewTab If true, prefer opening in a new tab. + */ + async openConversation(conversationId, preferNewTab = false) { + var _a3, _b2; + for (const tab of this.tabs.values()) { + if (tab.conversationId === conversationId) { + await this.switchToTab(tab.id); + return; + } + } + const crossViewResult = this.plugin.findConversationAcrossViews(conversationId); + const isSameView = (crossViewResult == null ? void 0 : crossViewResult.view) === this.view; + if (crossViewResult && !isSameView) { + this.plugin.app.workspace.revealLeaf(crossViewResult.view.leaf); + await ((_a3 = crossViewResult.view.getTabManager()) == null ? void 0 : _a3.switchToTab(crossViewResult.tabId)); + return; + } + if (preferNewTab && this.canCreateTab()) { + await this.createTab(conversationId); + } else { + const activeTab = this.getActiveTab(); + if (activeTab) { + await ((_b2 = activeTab.controllers.conversationController) == null ? void 0 : _b2.switchTo(conversationId)); + } + } + } + /** + * Creates a new conversation in the active tab. + */ + async createNewConversation() { + var _a3; + const activeTab = this.getActiveTab(); + if (activeTab) { + await ((_a3 = activeTab.controllers.conversationController) == null ? void 0 : _a3.createNew()); + activeTab.conversationId = activeTab.state.currentConversationId; + } + } + // ============================================ + // Fork + // ============================================ + async handleForkRequest(context) { + const target = await chooseForkTarget(this.plugin.app); + if (!target) return; + if (target === "new-tab") { + const tab = await this.forkToNewTab(context); + if (!tab) { + const maxTabs = this.getMaxTabs(); + new import_obsidian41.Notice(t("chat.fork.maxTabsReached", { count: String(maxTabs) })); + return; + } + new import_obsidian41.Notice(t("chat.fork.notice")); + } else { + const success2 = await this.forkInCurrentTab(context); + if (!success2) { + new import_obsidian41.Notice(t("chat.fork.failed", { error: t("chat.fork.errorNoActiveTab") })); + return; + } + new import_obsidian41.Notice(t("chat.fork.noticeCurrentTab")); + } + } + async forkToNewTab(context) { + const maxTabs = this.getMaxTabs(); + if (this.tabs.size >= maxTabs) { + return null; + } + const conversationId = await this.createForkConversation(context); + try { + return await this.createTab(conversationId); + } catch (error48) { + await this.plugin.deleteConversation(conversationId).catch(() => { + }); + throw error48; + } + } + async forkInCurrentTab(context) { + const activeTab = this.getActiveTab(); + if (!(activeTab == null ? void 0 : activeTab.controllers.conversationController)) return false; + const conversationId = await this.createForkConversation(context); + try { + await activeTab.controllers.conversationController.switchTo(conversationId); + } catch (error48) { + await this.plugin.deleteConversation(conversationId).catch(() => { + }); + throw error48; + } + return true; + } + async createForkConversation(context) { + const conversation = await this.plugin.createConversation({ + providerId: context.providerId + }); + const title = context.sourceTitle ? this.buildForkTitle(context.sourceTitle, context.forkAtUserMessage) : void 0; + const forkProviderState = ProviderRegistry.getConversationHistoryService(conversation.providerId).buildForkProviderState( + context.sourceSessionId, + context.resumeAt, + context.sourceProviderState + ); + await this.plugin.updateConversation(conversation.id, { + messages: context.messages, + providerState: forkProviderState, + ...title && { title }, + ...context.currentNote && { currentNote: context.currentNote } + }); + return conversation.id; + } + buildForkTitle(sourceTitle, forkAtUserMessage) { + const MAX_TITLE_LENGTH = 50; + const forkSuffix = forkAtUserMessage ? ` (#${forkAtUserMessage})` : ""; + const forkPrefix = "Fork: "; + const maxSourceLength = MAX_TITLE_LENGTH - forkPrefix.length - forkSuffix.length; + const truncatedSource = sourceTitle.length > maxSourceLength ? sourceTitle.slice(0, maxSourceLength - 1) + "\u2026" : sourceTitle; + let title = forkPrefix + truncatedSource + forkSuffix; + const existingTitles = new Set(this.plugin.getConversationList().map((c) => c.title)); + if (existingTitles.has(title)) { + let n3 = 2; + while (existingTitles.has(`${title} ${n3}`)) n3++; + title = `${title} ${n3}`; + } + return title; + } + // ============================================ + // Persistence + // ============================================ + /** Gets the state to persist. */ + getPersistedState() { + const openTabs = []; + for (const tab of this.tabs.values()) { + openTabs.push({ + tabId: tab.id, + conversationId: tab.conversationId + }); + } + return { + openTabs, + activeTabId: this.activeTabId + }; + } + /** Restores state from persisted data. */ + async restoreState(state) { + for (const tabState of state.openTabs) { + try { + await this.createTab(tabState.conversationId, tabState.tabId); + } catch (e3) { + } + } + if (state.activeTabId && this.tabs.has(state.activeTabId)) { + try { + await this.switchToTab(state.activeTabId); + } catch (e3) { + } + } + if (this.tabs.size === 0) { + await this.createTab(); + } + } + // ============================================ + // SDK Commands (Shared) + // ============================================ + /** + * Gets provider-scoped SDK supported commands for a tab. + * Reuses a ready runtime from the same provider when available to avoid + * leaking commands across providers in mixed-provider workspaces. + * @returns Array of SDK commands, or empty array if no service is ready. + */ + async getSdkCommands(tabId) { + var _a3, _b2; + const targetTab = (_a3 = tabId ? this.tabs.get(tabId) : this.getActiveTab()) != null ? _a3 : null; + if (!targetTab) { + return []; + } + const providerId = getTabProviderId(targetTab, this.plugin); + const staticCapabilities = ProviderRegistry.getCapabilities(providerId); + if (!staticCapabilities.supportsProviderCommands) { + return []; + } + let sdkCommands = []; + const targetService = targetTab.service; + if ((targetService == null ? void 0 : targetService.providerId) === providerId && targetService.isReady()) { + sdkCommands = await targetService.getSupportedCommands(); + } else { + for (const tab of this.tabs.values()) { + if (tab.id === targetTab.id) { + continue; + } + if (((_b2 = tab.service) == null ? void 0 : _b2.providerId) === providerId && tab.service.isReady()) { + sdkCommands = await tab.service.getSupportedCommands(); + break; + } + } + } + const catalog = ProviderWorkspaceRegistry.getCommandCatalog(providerId); + if (catalog) { + catalog.setRuntimeCommands(sdkCommands); + } + return sdkCommands; + } + // ============================================ + // Provider Command Catalog + // ============================================ + getProviderCatalogConfig(tab) { + const providerId = getTabProviderId(tab, this.plugin); + const catalog = ProviderWorkspaceRegistry.getCommandCatalog(providerId); + if (!catalog) return null; + return { + config: catalog.getDropdownConfig(), + getEntries: async () => { + await this.getSdkCommands(tab.id); + return catalog.listDropdownEntries({ includeBuiltIns: false }); + } + }; + } + // ============================================ + // Broadcast + // ============================================ + /** + * Broadcasts a function call to all initialized tab runtimes. + * Used by settings managers to apply configuration changes to all tabs. + * @param fn Function to call on each runtime. + */ + async broadcastToAllTabs(fn) { + const promises2 = []; + for (const tab of this.tabs.values()) { + if (tab.service && tab.serviceInitialized) { + promises2.push( + fn(tab.service).catch(() => { + }) + ); + } + } + await Promise.all(promises2); + } + // ============================================ + // Cleanup + // ============================================ + /** Destroys all tabs and cleans up resources. */ + async destroy() { + await Promise.all( + Array.from(this.tabs.values()).map( + (tab) => { + var _a3, _b2; + return (_b2 = (_a3 = tab.controllers.conversationController) == null ? void 0 : _a3.save()) != null ? _b2 : Promise.resolve(); + } + ) + ); + await Promise.all(Array.from(this.tabs.values()).map((tab) => destroyTab(tab))); + this.tabs.clear(); + this.activeTabId = null; + } +}; + +// src/features/chat/ClaudianView.ts +var ClaudianView = class extends import_obsidian42.ItemView { + constructor(leaf, plugin) { + super(leaf); + // Tab management + this.tabManager = null; + this.tabBar = null; + this.tabBarContainerEl = null; + this.tabContentEl = null; + this.navRowContent = null; + // DOM Elements + this.viewContainerEl = null; + this.headerEl = null; + this.titleSlotEl = null; + this.logoEl = null; + this.titleTextEl = null; + this.headerActionsEl = null; + this.headerActionsContent = null; + // Header elements + this.historyDropdown = null; + // Event refs for cleanup + this.eventRefs = []; + // Debouncing for tab bar updates + this.pendingTabBarUpdate = null; + // Debouncing for tab state persistence + this.pendingPersist = null; + this.plugin = plugin; + const originalLoad = Object.getPrototypeOf(this).load.bind(this); + Object.defineProperty(this, "load", { + value: async () => { + if (!this.containerEl) { + this.containerEl = createDiv({ cls: "view-content" }); + } + try { + return await originalLoad(); + } catch (e3) { + } + }, + writable: false, + configurable: false + }); + } + getViewType() { + return VIEW_TYPE_CLAUDIAN; + } + getDisplayText() { + return "Claudian"; + } + getIcon() { + return "bot"; + } + /** Refreshes model-dependent UI across all tabs (used after settings/env changes). */ + refreshModelSelector() { + var _a3, _b2, _c, _d, _e, _f, _g; + for (const tab of (_b2 = (_a3 = this.tabManager) == null ? void 0 : _a3.getAllTabs()) != null ? _b2 : []) { + onProviderAvailabilityChanged(tab, this.plugin); + const providerId = getTabProviderId(tab, this.plugin); + const providerSettings = ProviderSettingsCoordinator.getProviderSettingsSnapshot( + this.plugin.settings, + providerId + ); + const model = providerSettings.model; + const uiConfig = ProviderRegistry.getChatUIConfig(providerId); + const capabilities = ProviderRegistry.getCapabilities(providerId); + const contextWindow = uiConfig.getContextWindowSize( + model, + providerSettings.customContextLimits + ); + if (tab.state.usage) { + tab.state.usage = recalculateUsageForModel(tab.state.usage, model, contextWindow); + } + (_c = tab.ui.modelSelector) == null ? void 0 : _c.updateDisplay(); + (_d = tab.ui.modelSelector) == null ? void 0 : _d.renderOptions(); + (_e = tab.ui.thinkingBudgetSelector) == null ? void 0 : _e.updateDisplay(); + (_f = tab.ui.permissionToggle) == null ? void 0 : _f.updateDisplay(); + (_g = tab.ui.serviceTierToggle) == null ? void 0 : _g.updateDisplay(); + tab.dom.inputWrapper.toggleClass( + "claudian-input-plan-mode", + this.plugin.settings.permissionMode === "plan" && capabilities.supportsPlanMode + ); + } + } + /** Updates provider-scoped hidden commands on all tabs after settings changes. */ + updateHiddenProviderCommands() { + var _a3, _b2, _c; + for (const tab of (_b2 = (_a3 = this.tabManager) == null ? void 0 : _a3.getAllTabs()) != null ? _b2 : []) { + (_c = tab.ui.slashCommandDropdown) == null ? void 0 : _c.setHiddenCommands( + getHiddenProviderCommandSet(this.plugin.settings, getTabProviderId(tab, this.plugin)) + ); + } + } + async onOpen() { + var _a3; + if (!this.containerEl) { + return; + } + let container = (_a3 = this.contentEl) != null ? _a3 : this.containerEl.children[1]; + if (!container) { + container = this.containerEl.createDiv(); + } + this.viewContainerEl = container; + this.viewContainerEl.empty(); + this.viewContainerEl.addClass("claudian-container"); + const header = this.viewContainerEl.createDiv({ cls: "claudian-header" }); + this.buildHeader(header); + this.navRowContent = this.buildNavRowContent(); + this.tabContentEl = this.viewContainerEl.createDiv({ cls: "claudian-tab-content-container" }); + this.tabManager = new TabManager( + this.plugin, + this.tabContentEl, + this, + { + onTabCreated: () => { + this.updateTabBar(); + this.updateNavRowLocation(); + this.persistTabState(); + this.syncProviderBrandColor(); + }, + onTabSwitched: () => { + this.updateTabBar(); + this.updateHistoryDropdown(); + this.updateNavRowLocation(); + this.persistTabState(); + this.syncProviderBrandColor(); + }, + onTabClosed: () => { + this.updateTabBar(); + this.persistTabState(); + }, + onTabStreamingChanged: () => this.updateTabBar(), + onTabTitleChanged: () => this.updateTabBar(), + onTabAttentionChanged: () => this.updateTabBar(), + onTabConversationChanged: () => { + this.persistTabState(); + this.syncProviderBrandColor(); + }, + onTabProviderChanged: () => { + this.syncProviderBrandColor(); + } + } + ); + this.wireEventHandlers(); + await this.restoreOrCreateTabs(); + this.syncProviderBrandColor(); + this.updateLayoutForPosition(); + } + async onClose() { + var _a3, _b2; + if (this.pendingTabBarUpdate !== null) { + cancelAnimationFrame(this.pendingTabBarUpdate); + this.pendingTabBarUpdate = null; + } + for (const ref of this.eventRefs) { + this.plugin.app.vault.offref(ref); + } + this.eventRefs = []; + await this.persistTabStateImmediate(); + await ((_a3 = this.tabManager) == null ? void 0 : _a3.destroy()); + this.tabManager = null; + (_b2 = this.tabBar) == null ? void 0 : _b2.destroy(); + this.tabBar = null; + } + // ============================================ + // UI Building + // ============================================ + buildHeader(header) { + this.headerEl = header; + this.titleSlotEl = header.createDiv({ cls: "claudian-title-slot" }); + this.logoEl = this.titleSlotEl.createSpan({ cls: "claudian-logo" }); + this.syncHeaderLogo(DEFAULT_CHAT_PROVIDER_ID); + this.titleTextEl = this.titleSlotEl.createEl("h4", { text: "Claudian", cls: "claudian-title-text" }); + this.headerActionsEl = header.createDiv({ cls: "claudian-header-actions claudian-header-actions-slot" }); + this.headerActionsEl.style.display = "none"; + } + /** + * Builds the nav row content (tab badges + header actions). + * This is called once and the content is moved between locations. + */ + buildNavRowContent() { + const fragment = document.createDocumentFragment(); + this.tabBarContainerEl = document.createElement("div"); + this.tabBarContainerEl.className = "claudian-tab-bar-container"; + this.tabBar = new TabBar(this.tabBarContainerEl, { + onTabClick: (tabId) => this.handleTabClick(tabId), + onTabClose: (tabId) => this.handleTabClose(tabId), + onNewTab: () => this.handleNewTab() + }); + fragment.appendChild(this.tabBarContainerEl); + this.headerActionsContent = document.createElement("div"); + this.headerActionsContent.className = "claudian-header-actions"; + const newTabBtn = this.headerActionsContent.createDiv({ cls: "claudian-header-btn claudian-new-tab-btn" }); + (0, import_obsidian42.setIcon)(newTabBtn, "square-plus"); + newTabBtn.setAttribute("aria-label", "New tab"); + newTabBtn.addEventListener("click", async () => { + await this.handleNewTab(); + }); + const newBtn = this.headerActionsContent.createDiv({ cls: "claudian-header-btn" }); + (0, import_obsidian42.setIcon)(newBtn, "square-pen"); + newBtn.setAttribute("aria-label", "New conversation"); + newBtn.addEventListener("click", async () => { + var _a3; + await ((_a3 = this.tabManager) == null ? void 0 : _a3.createNewConversation()); + this.updateHistoryDropdown(); + }); + const historyContainer = this.headerActionsContent.createDiv({ cls: "claudian-history-container" }); + const historyBtn = historyContainer.createDiv({ cls: "claudian-header-btn" }); + (0, import_obsidian42.setIcon)(historyBtn, "history"); + historyBtn.setAttribute("aria-label", "Chat history"); + this.historyDropdown = historyContainer.createDiv({ cls: "claudian-history-menu" }); + historyBtn.addEventListener("click", (e3) => { + e3.stopPropagation(); + this.toggleHistoryDropdown(); + }); + fragment.appendChild(this.headerActionsContent); + const wrapper = document.createElement("div"); + wrapper.style.display = "contents"; + wrapper.appendChild(fragment); + return wrapper; + } + /** + * Moves nav row content based on tabBarPosition setting. + * - 'input' mode: Both tab badges and actions go to active tab's navRowEl + * - 'header' mode: Tab badges go to title slot (after logo), actions go to header right side + */ + updateNavRowLocation() { + var _a3; + if (!this.tabBarContainerEl || !this.headerActionsContent) return; + const isHeaderMode = this.plugin.settings.tabBarPosition === "header"; + if (isHeaderMode) { + if (this.titleSlotEl) { + this.titleSlotEl.appendChild(this.tabBarContainerEl); + } + if (this.headerActionsEl) { + this.headerActionsEl.appendChild(this.headerActionsContent); + this.headerActionsEl.style.display = "flex"; + } + } else { + const activeTab = (_a3 = this.tabManager) == null ? void 0 : _a3.getActiveTab(); + if (activeTab && this.navRowContent) { + this.navRowContent.appendChild(this.tabBarContainerEl); + this.navRowContent.appendChild(this.headerActionsContent); + activeTab.dom.navRowEl.appendChild(this.navRowContent); + } + if (this.headerActionsEl) { + this.headerActionsEl.style.display = "none"; + } + } + } + /** + * Updates layout when tabBarPosition setting changes. + * Called from settings when user changes the tab bar position. + */ + updateLayoutForPosition() { + if (!this.viewContainerEl) return; + const isHeaderMode = this.plugin.settings.tabBarPosition === "header"; + this.viewContainerEl.toggleClass("claudian-container--header-mode", isHeaderMode); + this.updateNavRowLocation(); + this.updateTabBarVisibility(); + } + // ============================================ + // Tab Management + // ============================================ + handleTabClick(tabId) { + var _a3; + (_a3 = this.tabManager) == null ? void 0 : _a3.switchToTab(tabId); + } + async handleTabClose(tabId) { + var _a3, _b2, _c; + const tab = (_a3 = this.tabManager) == null ? void 0 : _a3.getTab(tabId); + const force = (_b2 = tab == null ? void 0 : tab.state.isStreaming) != null ? _b2 : false; + await ((_c = this.tabManager) == null ? void 0 : _c.closeTab(tabId, force)); + this.updateTabBarVisibility(); + } + async handleNewTab() { + var _a3, _b2; + const tab = await ((_a3 = this.tabManager) == null ? void 0 : _a3.createTab()); + if (!tab) { + const maxTabs = (_b2 = this.plugin.settings.maxTabs) != null ? _b2 : 3; + new import_obsidian42.Notice(`Maximum ${maxTabs} tabs allowed`); + return; + } + this.updateTabBarVisibility(); + } + updateTabBar() { + if (!this.tabManager || !this.tabBar) return; + if (this.pendingTabBarUpdate !== null) { + cancelAnimationFrame(this.pendingTabBarUpdate); + } + this.pendingTabBarUpdate = requestAnimationFrame(() => { + this.pendingTabBarUpdate = null; + if (!this.tabManager || !this.tabBar) return; + const items = this.tabManager.getTabBarItems(); + this.tabBar.update(items); + this.updateTabBarVisibility(); + }); + } + updateTabBarVisibility() { + if (!this.tabBarContainerEl || !this.tabManager) return; + const tabCount = this.tabManager.getTabCount(); + const showTabBar = tabCount >= 2; + const isHeaderMode = this.plugin.settings.tabBarPosition === "header"; + this.tabBarContainerEl.style.display = showTabBar ? "flex" : "none"; + const hideBranding = showTabBar && isHeaderMode; + if (this.logoEl) { + this.logoEl.style.display = hideBranding ? "none" : ""; + } + if (this.titleTextEl) { + this.titleTextEl.style.display = hideBranding ? "none" : ""; + } + } + /** Sets `data-provider` on the root container so CSS brand color follows the active provider. */ + syncProviderBrandColor() { + var _a3; + if (!this.viewContainerEl) return; + const activeTab = (_a3 = this.tabManager) == null ? void 0 : _a3.getActiveTab(); + const providerId = activeTab ? getTabProviderId(activeTab, this.plugin) : DEFAULT_CHAT_PROVIDER_ID; + this.viewContainerEl.dataset.provider = providerId; + this.syncHeaderLogo(providerId); + } + /** Rebuilds the header logo SVG to match the given provider. */ + syncHeaderLogo(providerId) { + var _a3, _b2; + if (!this.logoEl) return; + const icon = (_b2 = (_a3 = ProviderRegistry.getChatUIConfig(providerId)).getProviderIcon) == null ? void 0 : _b2.call(_a3); + if (!icon) return; + const existing = this.logoEl.querySelector("svg"); + if ((existing == null ? void 0 : existing.getAttribute("data-provider")) === providerId) return; + this.logoEl.empty(); + const NS = "http://www.w3.org/2000/svg"; + const svg = document.createElementNS(NS, "svg"); + svg.setAttribute("viewBox", icon.viewBox); + svg.setAttribute("width", "18"); + svg.setAttribute("height", "18"); + svg.setAttribute("fill", "none"); + svg.setAttribute("data-provider", providerId); + const path19 = document.createElementNS(NS, "path"); + path19.setAttribute("d", icon.path); + path19.setAttribute("fill", "currentColor"); + svg.appendChild(path19); + this.logoEl.appendChild(svg); + } + // ============================================ + // History Dropdown + // ============================================ + toggleHistoryDropdown() { + if (!this.historyDropdown) return; + const isVisible = this.historyDropdown.hasClass("visible"); + if (isVisible) { + this.historyDropdown.removeClass("visible"); + } else { + this.updateHistoryDropdown(); + this.historyDropdown.addClass("visible"); + } + } + updateHistoryDropdown() { + var _a3; + if (!this.historyDropdown) return; + this.historyDropdown.empty(); + const activeTab = (_a3 = this.tabManager) == null ? void 0 : _a3.getActiveTab(); + const conversationController = activeTab == null ? void 0 : activeTab.controllers.conversationController; + if (conversationController) { + conversationController.renderHistoryDropdown(this.historyDropdown, { + onSelectConversation: async (conversationId) => { + var _a4, _b2, _c, _d, _e, _f; + const existingTab = this.findTabWithConversation(conversationId); + if (existingTab) { + await ((_a4 = this.tabManager) == null ? void 0 : _a4.switchToTab(existingTab.id)); + (_b2 = this.historyDropdown) == null ? void 0 : _b2.removeClass("visible"); + return; + } + const crossViewResult = this.plugin.findConversationAcrossViews(conversationId); + if (crossViewResult && crossViewResult.view !== this) { + this.plugin.app.workspace.revealLeaf(crossViewResult.view.leaf); + await ((_c = crossViewResult.view.getTabManager()) == null ? void 0 : _c.switchToTab(crossViewResult.tabId)); + (_d = this.historyDropdown) == null ? void 0 : _d.removeClass("visible"); + return; + } + await ((_e = this.tabManager) == null ? void 0 : _e.openConversation(conversationId)); + (_f = this.historyDropdown) == null ? void 0 : _f.removeClass("visible"); + } + }); + } + } + findTabWithConversation(conversationId) { + var _a3, _b2, _c; + const tabs = (_b2 = (_a3 = this.tabManager) == null ? void 0 : _a3.getAllTabs()) != null ? _b2 : []; + return (_c = tabs.find((tab) => tab.conversationId === conversationId)) != null ? _c : null; + } + // ============================================ + // Event Wiring + // ============================================ + wireEventHandlers() { + this.registerDomEvent(document, "click", () => { + var _a3; + (_a3 = this.historyDropdown) == null ? void 0 : _a3.removeClass("visible"); + }); + this.registerDomEvent(this.containerEl, "keydown", (e3) => { + var _a3, _b2; + if (e3.key === "Tab" && e3.shiftKey && !e3.isComposing) { + e3.preventDefault(); + const activeTab = (_a3 = this.tabManager) == null ? void 0 : _a3.getActiveTab(); + if (!activeTab) return; + const providerId = getTabProviderId(activeTab, this.plugin); + if (!ProviderRegistry.getCapabilities(providerId).supportsPlanMode) return; + const current = this.plugin.settings.permissionMode; + if (current === "plan") { + const restoreMode = (_b2 = activeTab.state.prePlanPermissionMode) != null ? _b2 : "normal"; + activeTab.state.prePlanPermissionMode = null; + updatePlanModeUI(activeTab, this.plugin, restoreMode); + } else { + activeTab.state.prePlanPermissionMode = current; + updatePlanModeUI(activeTab, this.plugin, "plan"); + } + } + }); + this.scope = new import_obsidian42.Scope(this.app.scope); + this.scope.register([], "Escape", () => { + var _a3, _b2; + const activeTab = (_a3 = this.tabManager) == null ? void 0 : _a3.getActiveTab(); + if (activeTab == null ? void 0 : activeTab.state.isStreaming) { + (_b2 = activeTab.controllers.inputController) == null ? void 0 : _b2.cancelStreaming(); + } + return false; + }); + const markCacheDirty = (includesFolders) => { + var _a3, _b2; + const mgr = (_b2 = (_a3 = this.tabManager) == null ? void 0 : _a3.getActiveTab()) == null ? void 0 : _b2.ui.fileContextManager; + if (!mgr) return; + mgr.markFileCacheDirty(); + if (includesFolders) mgr.markFolderCacheDirty(); + }; + this.eventRefs.push( + this.plugin.app.vault.on("create", () => markCacheDirty(true)), + this.plugin.app.vault.on("delete", () => markCacheDirty(true)), + this.plugin.app.vault.on("rename", () => markCacheDirty(true)), + this.plugin.app.vault.on("modify", () => markCacheDirty(false)) + ); + this.registerEvent( + this.plugin.app.workspace.on("file-open", (file2) => { + var _a3, _b2, _c; + if (file2) { + (_c = (_b2 = (_a3 = this.tabManager) == null ? void 0 : _a3.getActiveTab()) == null ? void 0 : _b2.ui.fileContextManager) == null ? void 0 : _c.handleFileOpen(file2); + } + }) + ); + this.registerDomEvent(document, "click", (e3) => { + var _a3; + const activeTab = (_a3 = this.tabManager) == null ? void 0 : _a3.getActiveTab(); + if (activeTab) { + const fcm = activeTab.ui.fileContextManager; + if (fcm && !fcm.containsElement(e3.target) && e3.target !== activeTab.dom.inputEl) { + fcm.hideMentionDropdown(); + } + } + }); + } + // ============================================ + // Persistence + // ============================================ + async restoreOrCreateTabs() { + if (!this.tabManager) return; + const persistedState = await this.plugin.storage.getTabManagerState(); + if (persistedState && persistedState.openTabs.length > 0) { + await this.tabManager.restoreState(persistedState); + return; + } + await this.tabManager.createTab(); + } + persistTabState() { + if (this.pendingPersist !== null) { + clearTimeout(this.pendingPersist); + } + this.pendingPersist = setTimeout(() => { + this.pendingPersist = null; + if (!this.tabManager) return; + const state = this.tabManager.getPersistedState(); + this.plugin.storage.setTabManagerState(state).catch(() => { + }); + }, 300); + } + /** Force immediate persistence (for onClose/onunload). */ + async persistTabStateImmediate() { + if (this.pendingPersist !== null) { + clearTimeout(this.pendingPersist); + this.pendingPersist = null; + } + if (!this.tabManager) return; + const state = this.tabManager.getPersistedState(); + await this.plugin.storage.setTabManagerState(state); + } + // ============================================ + // Public API + // ============================================ + /** Gets the currently active tab. */ + getActiveTab() { + var _a3, _b2; + return (_b2 = (_a3 = this.tabManager) == null ? void 0 : _a3.getActiveTab()) != null ? _b2 : null; + } + /** Gets the tab manager. */ + getTabManager() { + return this.tabManager; + } +}; + +// src/features/inline-edit/ui/InlineEditModal.ts +var import_state2 = require("@codemirror/state"); +var import_view2 = require("@codemirror/view"); +var import_obsidian43 = require("obsidian"); +init_path(); +var showInlineEdit = import_state2.StateEffect.define(); +var showDiff = import_state2.StateEffect.define(); +var showInsertion = import_state2.StateEffect.define(); +var hideInlineEdit = import_state2.StateEffect.define(); +var activeController = null; +var DiffWidget = class extends import_view2.WidgetType { + constructor(diffHtml, controller) { + super(); + this.diffHtml = diffHtml; + this.controller = controller; + } + toDOM() { + const span = document.createElement("span"); + span.className = "claudian-inline-diff-replace"; + span.innerHTML = this.diffHtml; + const btns = document.createElement("span"); + btns.className = "claudian-inline-diff-buttons"; + const rejectBtn = document.createElement("button"); + rejectBtn.className = "claudian-inline-diff-btn reject"; + rejectBtn.textContent = "\u2715"; + rejectBtn.title = "Reject (Esc)"; + rejectBtn.onclick = () => this.controller.reject(); + const acceptBtn = document.createElement("button"); + acceptBtn.className = "claudian-inline-diff-btn accept"; + acceptBtn.textContent = "\u2713"; + acceptBtn.title = "Accept (Enter)"; + acceptBtn.onclick = () => this.controller.accept(); + btns.appendChild(rejectBtn); + btns.appendChild(acceptBtn); + span.appendChild(btns); + return span; + } + eq(other) { + return this.diffHtml === other.diffHtml; + } + ignoreEvent() { + return true; + } +}; +var InputWidget = class extends import_view2.WidgetType { + constructor(controller) { + super(); + this.controller = controller; + } + toDOM() { + return this.controller.createInputDOM(); + } + eq() { + return false; + } + ignoreEvent() { + return true; + } +}; +var inlineEditField = import_state2.StateField.define({ + create: () => import_view2.Decoration.none, + update: (deco, tr) => { + var _a3; + deco = deco.map(tr.changes); + for (const e3 of tr.effects) { + if (e3.is(showInlineEdit)) { + const builder = new import_state2.RangeSetBuilder(); + const isInbetween = (_a3 = e3.value.isInbetween) != null ? _a3 : false; + builder.add(e3.value.inputPos, e3.value.inputPos, import_view2.Decoration.widget({ + widget: new InputWidget(e3.value.widget), + block: !isInbetween, + side: isInbetween ? 1 : -1 + })); + deco = builder.finish(); + } else if (e3.is(showDiff)) { + const builder = new import_state2.RangeSetBuilder(); + builder.add(e3.value.from, e3.value.to, import_view2.Decoration.replace({ + widget: new DiffWidget(e3.value.diffHtml, e3.value.widget) + })); + deco = builder.finish(); + } else if (e3.is(showInsertion)) { + const builder = new import_state2.RangeSetBuilder(); + builder.add(e3.value.pos, e3.value.pos, import_view2.Decoration.widget({ + widget: new DiffWidget(e3.value.diffHtml, e3.value.widget), + side: 1 + // After the position + })); + deco = builder.finish(); + } else if (e3.is(hideInlineEdit)) { + deco = import_view2.Decoration.none; + } + } + return deco; + }, + provide: (f6) => import_view2.EditorView.decorations.from(f6) +}); +var installedEditors = /* @__PURE__ */ new WeakSet(); +function computeDiff(oldText, newText) { + const oldWords = oldText.split(/(\s+)/); + const newWords = newText.split(/(\s+)/); + const m3 = oldWords.length, n3 = newWords.length; + const dp = Array(m3 + 1).fill(null).map(() => Array(n3 + 1).fill(0)); + for (let i4 = 1; i4 <= m3; i4++) { + for (let j3 = 1; j3 <= n3; j3++) { + dp[i4][j3] = oldWords[i4 - 1] === newWords[j3 - 1] ? dp[i4 - 1][j3 - 1] + 1 : Math.max(dp[i4 - 1][j3], dp[i4][j3 - 1]); + } + } + const ops = []; + let i3 = m3, j = n3; + const temp = []; + while (i3 > 0 || j > 0) { + if (i3 > 0 && j > 0 && oldWords[i3 - 1] === newWords[j - 1]) { + temp.push({ type: "equal", text: oldWords[i3 - 1] }); + i3--; + j--; + } else if (j > 0 && (i3 === 0 || dp[i3][j - 1] >= dp[i3 - 1][j])) { + temp.push({ type: "insert", text: newWords[j - 1] }); + j--; + } else { + temp.push({ type: "delete", text: oldWords[i3 - 1] }); + i3--; + } + } + temp.reverse(); + for (const op of temp) { + if (ops.length > 0 && ops[ops.length - 1].type === op.type) { + ops[ops.length - 1].text += op.text; + } else { + ops.push({ ...op }); + } + } + return ops; +} +function diffToHtml(ops) { + return ops.map((op) => { + const escaped = escapeHtml(op.text); + switch (op.type) { + case "delete": + return `${escaped}`; + case "insert": + return `${escaped}`; + default: + return escaped; + } + }).join(""); +} +var InlineEditModal = class { + constructor(app, plugin, editor, view, editContext, notePath, getExternalContexts = () => []) { + this.app = app; + this.plugin = plugin; + this.editor = editor; + this.view = view; + this.editContext = editContext; + this.notePath = notePath; + this.getExternalContexts = getExternalContexts; + this.controller = null; + } + async openAndWait() { + if (activeController) { + activeController.reject(); + return { decision: "reject" }; + } + let editor = this.editor; + let editorView = getEditorView(editor); + if (!editorView) { + editor = this.view.editor; + editorView = getEditorView(editor); + } + if (!editorView) { + new import_obsidian43.Notice("Inline edit unavailable: could not access the active editor. Try reopening the note."); + return { decision: "reject" }; + } + return new Promise((resolve5) => { + this.controller = new InlineEditController( + this.app, + this.plugin, + editorView, + editor, + this.editContext, + this.notePath, + this.getExternalContexts, + resolve5 + ); + activeController = this.controller; + this.controller.show(); + }); + } +}; +var InlineEditController = class { + constructor(app, plugin, editorView, editor, editContext, notePath, getExternalContexts, resolve5) { + this.app = app; + this.plugin = plugin; + this.editorView = editorView; + this.editor = editor; + this.notePath = notePath; + this.getExternalContexts = getExternalContexts; + this.resolve = resolve5; + this.inputEl = null; + this.spinnerEl = null; + this.agentReplyEl = null; + this.containerEl = null; + this.editedText = null; + this.insertedText = null; + this.selFrom = 0; + this.selTo = 0; + this.startLine = 0; + this.cursorContext = null; + this.escHandler = null; + this.selectionListener = null; + this.isConversing = false; + this.slashCommandDropdown = null; + this.mentionDropdown = null; + var _a3, _b2, _c, _d; + const activeView = typeof plugin.getView === "function" ? plugin.getView() : null; + const activeTab = activeView == null ? void 0 : activeView.getActiveTab(); + const conversation = (activeTab == null ? void 0 : activeTab.conversationId) ? plugin.getConversationSync(activeTab.conversationId) : null; + const providerId = (_d = (_c = (_b2 = conversation == null ? void 0 : conversation.providerId) != null ? _b2 : (_a3 = activeTab == null ? void 0 : activeTab.service) == null ? void 0 : _a3.providerId) != null ? _c : activeTab == null ? void 0 : activeTab.providerId) != null ? _d : DEFAULT_CHAT_PROVIDER_ID; + this.inlineEditService = ProviderRegistry.createInlineEditService(plugin, providerId); + this.resolvedProviderId = providerId; + this.mentionDataProvider = new VaultMentionDataProvider(this.app, { + onFileLoadError: () => { + new import_obsidian43.Notice("Failed to load vault files. Vault @-mentions may be unavailable."); + } + }); + this.mentionDataProvider.initializeInBackground(); + this.mode = editContext.mode; + if (editContext.mode === "cursor") { + this.cursorContext = editContext.cursorContext; + this.selectedText = ""; + } else { + this.selectedText = editContext.selectedText; + } + this.updatePositionsFromEditor(); + } + updatePositionsFromEditor() { + const doc = this.editorView.state.doc; + if (this.mode === "cursor") { + const ctx = this.cursorContext; + const line = doc.line(ctx.line + 1); + this.selFrom = line.from + ctx.column; + this.selTo = this.selFrom; + } else { + const from = this.editor.getCursor("from"); + const to = this.editor.getCursor("to"); + const fromLine = doc.line(from.line + 1); + const toLine = doc.line(to.line + 1); + this.selFrom = fromLine.from + from.ch; + this.selTo = toLine.from + to.ch; + this.selectedText = this.editor.getSelection() || this.selectedText; + this.startLine = from.line + 1; + } + } + show() { + if (!installedEditors.has(this.editorView)) { + this.editorView.dispatch({ + effects: import_state2.StateEffect.appendConfig.of(inlineEditField) + }); + installedEditors.add(this.editorView); + } + this.updateHighlight(); + if (this.mode === "selection") { + this.attachSelectionListeners(); + } + this.escHandler = (e3) => { + if (e3.key === "Escape" && !e3.isComposing) { + this.reject(); + } + }; + document.addEventListener("keydown", this.escHandler); + } + updateHighlight() { + var _a3; + const doc = this.editorView.state.doc; + const line = doc.lineAt(this.selFrom); + const isInbetween = this.mode === "cursor" && ((_a3 = this.cursorContext) == null ? void 0 : _a3.isInbetween); + this.editorView.dispatch({ + effects: showInlineEdit.of({ + inputPos: isInbetween ? this.selFrom : line.from, + selFrom: this.selFrom, + selTo: this.selTo, + widget: this, + isInbetween + }) + }); + this.updateSelectionHighlight(); + } + updateSelectionHighlight() { + if (this.mode === "selection" && this.selFrom !== this.selTo) { + showSelectionHighlight(this.editorView, this.selFrom, this.selTo); + } else { + hideSelectionHighlight(this.editorView); + } + } + attachSelectionListeners() { + this.removeSelectionListeners(); + this.selectionListener = (e3) => { + const target = e3.target; + if (target && this.inputEl && (target === this.inputEl || this.inputEl.contains(target))) { + return; + } + const prevFrom = this.selFrom; + const prevTo = this.selTo; + const newSelection = this.editor.getSelection(); + if (newSelection && newSelection.length > 0) { + this.updatePositionsFromEditor(); + if (prevFrom !== this.selFrom || prevTo !== this.selTo) { + this.updateHighlight(); + } + } + }; + this.editorView.dom.addEventListener("mouseup", this.selectionListener); + this.editorView.dom.addEventListener("keyup", this.selectionListener); + } + createInputDOM() { + const container = document.createElement("div"); + container.className = "claudian-inline-input-container"; + this.containerEl = container; + this.agentReplyEl = document.createElement("div"); + this.agentReplyEl.className = "claudian-inline-agent-reply"; + this.agentReplyEl.style.display = "none"; + container.appendChild(this.agentReplyEl); + const inputWrap = document.createElement("div"); + inputWrap.className = "claudian-inline-input-wrap"; + container.appendChild(inputWrap); + this.inputEl = document.createElement("input"); + this.inputEl.type = "text"; + this.inputEl.className = "claudian-inline-input"; + this.inputEl.placeholder = this.mode === "cursor" ? "Insert instructions..." : "Edit instructions..."; + this.inputEl.spellcheck = false; + inputWrap.appendChild(this.inputEl); + this.spinnerEl = document.createElement("div"); + this.spinnerEl.className = "claudian-inline-spinner"; + this.spinnerEl.style.display = "none"; + inputWrap.appendChild(this.spinnerEl); + const inlineCatalog = ProviderWorkspaceRegistry.getCommandCatalog(this.resolvedProviderId); + this.slashCommandDropdown = new SlashCommandDropdown( + document.body, + this.inputEl, + { + onSelect: () => { + }, + onHide: () => { + } + }, + { + fixed: true, + hiddenCommands: getHiddenProviderCommandSet(this.plugin.settings, this.resolvedProviderId), + ...inlineCatalog ? { + providerConfig: inlineCatalog.getDropdownConfig(), + getProviderEntries: () => inlineCatalog.listDropdownEntries({ includeBuiltIns: false }) + } : {} + } + ); + this.mentionDropdown = new MentionDropdownController( + document.body, + this.inputEl, + { + // Inline-edit resolves @mentions at send time from input text. + onAttachFile: () => { + }, + onMcpMentionChange: () => { + }, + getMentionedMcpServers: () => /* @__PURE__ */ new Set(), + setMentionedMcpServers: () => false, + addMentionedMcpServer: () => { + }, + getExternalContexts: this.getExternalContexts, + getCachedVaultFolders: () => this.mentionDataProvider.getCachedVaultFolders(), + getCachedVaultFiles: () => this.mentionDataProvider.getCachedVaultFiles(), + normalizePathForVault: (rawPath) => this.normalizePathForVault(rawPath) + }, + { fixed: true } + ); + this.inputEl.addEventListener("keydown", (e3) => this.handleKeydown(e3)); + this.inputEl.addEventListener("input", () => { + var _a3; + return (_a3 = this.mentionDropdown) == null ? void 0 : _a3.handleInputChange(); + }); + setTimeout(() => { + var _a3; + return (_a3 = this.inputEl) == null ? void 0 : _a3.focus(); + }, 50); + return container; + } + async generate() { + if (!this.inputEl || !this.spinnerEl) return; + const userMessage = this.inputEl.value.trim(); + if (!userMessage) return; + this.removeSelectionListeners(); + this.inputEl.disabled = true; + this.spinnerEl.style.display = "block"; + const contextFiles = this.resolveContextFilesFromMessage(userMessage); + let result; + if (this.isConversing) { + result = await this.inlineEditService.continueConversation(userMessage, contextFiles); + } else { + if (this.mode === "cursor") { + result = await this.inlineEditService.editText({ + mode: "cursor", + instruction: userMessage, + notePath: this.notePath, + cursorContext: this.cursorContext, + contextFiles + }); + } else { + const lineCount = this.selectedText.split(/\r?\n/).length; + result = await this.inlineEditService.editText({ + mode: "selection", + instruction: userMessage, + notePath: this.notePath, + selectedText: this.selectedText, + startLine: this.startLine, + lineCount, + contextFiles + }); + } + } + this.spinnerEl.style.display = "none"; + if (result.success) { + if (result.editedText !== void 0) { + this.editedText = result.editedText; + this.showDiffInPlace(); + } else if (result.insertedText !== void 0) { + this.insertedText = result.insertedText; + this.showInsertionInPlace(); + } else if (result.clarification) { + this.showAgentReply(result.clarification); + this.isConversing = true; + this.inputEl.disabled = false; + this.inputEl.value = ""; + this.inputEl.placeholder = "Reply to continue..."; + this.inputEl.focus(); + } else { + this.handleError("No response from agent"); + } + } else { + this.handleError(result.error || "Error - try again"); + } + } + showAgentReply(message) { + if (!this.agentReplyEl || !this.containerEl) return; + this.agentReplyEl.style.display = "block"; + this.agentReplyEl.textContent = message; + this.containerEl.classList.add("has-agent-reply"); + } + handleError(errorMessage) { + if (!this.inputEl) return; + this.inputEl.disabled = false; + this.inputEl.placeholder = errorMessage; + this.updatePositionsFromEditor(); + this.updateHighlight(); + this.attachSelectionListeners(); + this.inputEl.focus(); + } + showDiffInPlace() { + if (this.editedText === null) return; + hideSelectionHighlight(this.editorView); + const diffOps = computeDiff(this.selectedText, this.editedText); + const diffHtml = diffToHtml(diffOps); + this.editorView.dispatch({ + effects: showDiff.of({ + from: this.selFrom, + to: this.selTo, + diffHtml, + widget: this + }) + }); + this.installAcceptRejectHandler(); + } + showInsertionInPlace() { + if (this.insertedText === null) return; + hideSelectionHighlight(this.editorView); + const trimmedText = normalizeInsertionText(this.insertedText); + this.insertedText = trimmedText; + const escaped = escapeHtml(trimmedText); + const diffHtml = `${escaped}`; + this.editorView.dispatch({ + effects: showInsertion.of({ + pos: this.selFrom, + diffHtml, + widget: this + }) + }); + this.installAcceptRejectHandler(); + } + installAcceptRejectHandler() { + if (this.escHandler) { + document.removeEventListener("keydown", this.escHandler); + } + this.escHandler = (e3) => { + if (e3.key === "Escape" && !e3.isComposing) { + this.reject(); + } else if (e3.key === "Enter" && !e3.isComposing) { + this.accept(); + } + }; + document.addEventListener("keydown", this.escHandler); + } + accept() { + var _a3; + const textToInsert = (_a3 = this.editedText) != null ? _a3 : this.insertedText; + if (textToInsert !== null) { + const doc = this.editorView.state.doc; + const fromLine = doc.lineAt(this.selFrom); + const toLine = doc.lineAt(this.selTo); + const from = { line: fromLine.number - 1, ch: this.selFrom - fromLine.from }; + const to = { line: toLine.number - 1, ch: this.selTo - toLine.from }; + this.cleanup(); + this.editor.replaceRange(textToInsert, from, to); + this.resolve({ decision: "accept", editedText: textToInsert }); + } else { + this.cleanup(); + this.resolve({ decision: "reject" }); + } + } + reject() { + this.cleanup({ keepSelectionHighlight: true }); + this.restoreSelectionHighlight(); + this.resolve({ decision: "reject" }); + } + removeSelectionListeners() { + if (this.selectionListener) { + this.editorView.dom.removeEventListener("mouseup", this.selectionListener); + this.editorView.dom.removeEventListener("keyup", this.selectionListener); + this.selectionListener = null; + } + } + cleanup(options) { + var _a3, _b2; + this.inlineEditService.cancel(); + this.inlineEditService.resetConversation(); + this.isConversing = false; + this.removeSelectionListeners(); + if (this.escHandler) { + document.removeEventListener("keydown", this.escHandler); + } + (_a3 = this.slashCommandDropdown) == null ? void 0 : _a3.destroy(); + this.slashCommandDropdown = null; + (_b2 = this.mentionDropdown) == null ? void 0 : _b2.destroy(); + this.mentionDropdown = null; + if (activeController === this) { + activeController = null; + } + this.editorView.dispatch({ + effects: hideInlineEdit.of(null) + }); + if (!(options == null ? void 0 : options.keepSelectionHighlight)) { + hideSelectionHighlight(this.editorView); + } + } + restoreSelectionHighlight() { + if (this.mode !== "selection" || this.selFrom === this.selTo) { + return; + } + showSelectionHighlight(this.editorView, this.selFrom, this.selTo); + } + handleKeydown(e3) { + var _a3, _b2; + if ((_a3 = this.mentionDropdown) == null ? void 0 : _a3.handleKeydown(e3)) { + return; + } + if ((_b2 = this.slashCommandDropdown) == null ? void 0 : _b2.handleKeydown(e3)) { + return; + } + if (e3.key === "Enter" && !e3.isComposing) { + e3.preventDefault(); + this.generate(); + } + } + normalizePathForVault(rawPath) { + try { + const vaultPath = getVaultPath(this.app); + return normalizePathForVault(rawPath, vaultPath); + } catch (e3) { + new import_obsidian43.Notice("Failed to attach file: invalid path"); + return null; + } + } + resolveContextFilesFromMessage(message) { + if (!message.includes("@")) return []; + const vaultFiles = this.mentionDataProvider.getCachedVaultFiles(); + const pathLookup = /* @__PURE__ */ new Map(); + for (const file2 of vaultFiles) { + const normalized = this.normalizePathForVault(file2.path); + if (!normalized) continue; + const lookupKey = normalizeForPlatformLookup(normalizeMentionPath(normalized)); + if (!pathLookup.has(lookupKey)) { + pathLookup.set(lookupKey, normalized); + } + } + const resolved = /* @__PURE__ */ new Set(); + const externalEntries = buildExternalContextDisplayEntries(this.getExternalContexts()).sort((a3, b) => b.displayNameLower.length - a3.displayNameLower.length); + const getExternalLookup = createExternalContextLookupGetter( + (contextRoot) => externalContextScanner.scanPaths([contextRoot]) + ); + for (let index = 0; index < message.length; index++) { + if (!isMentionStart(message, index)) continue; + const externalMatch = resolveExternalMentionAtIndex( + message, + index, + externalEntries, + getExternalLookup + ); + if (externalMatch) { + resolved.add(externalMatch.resolvedPath); + index = externalMatch.endIndex - 1; + continue; + } + const vaultMatch = findBestMentionLookupMatch( + message, + index + 1, + pathLookup, + normalizeMentionPath, + normalizeForPlatformLookup + ); + if (vaultMatch) { + resolved.add(vaultMatch.resolvedPath); + index = vaultMatch.endIndex - 1; + } + } + return [...resolved]; + } +}; + +// src/features/settings/ClaudianSettings.ts +var import_obsidian44 = require("obsidian"); +init_env(); + +// src/features/settings/keyboardNavigation.ts +var NAV_ACTIONS = ["scrollUp", "scrollDown", "focusInput"]; +var buildNavMappingText = (settings11) => { + return [ + `map ${settings11.scrollUpKey} scrollUp`, + `map ${settings11.scrollDownKey} scrollDown`, + `map ${settings11.focusInputKey} focusInput` + ].join("\n"); +}; +var parseNavMappings = (value) => { + const parsed = {}; + const usedKeys = /* @__PURE__ */ new Map(); + const lines = value.split("\n"); + for (const rawLine of lines) { + const line = rawLine.trim(); + if (!line) continue; + const parts = line.split(/\s+/); + if (parts.length !== 3 || parts[0] !== "map") { + return { error: 'Each line must follow "map "' }; + } + const key = parts[1]; + const action = parts[2]; + if (!NAV_ACTIONS.includes(action)) { + return { error: `Unknown action: ${parts[2]}` }; + } + if (key.length !== 1) { + return { error: `Key must be a single character for ${action}` }; + } + const normalizedKey = key.toLowerCase(); + if (usedKeys.has(normalizedKey)) { + return { error: "Navigation keys must be unique" }; + } + if (parsed[action]) { + return { error: `Duplicate mapping for ${action}` }; + } + usedKeys.set(normalizedKey, action); + parsed[action] = key; + } + const missing = NAV_ACTIONS.filter((action) => !parsed[action]); + if (missing.length > 0) { + return { error: `Missing mapping for ${missing.join(", ")}` }; + } + return { settings: parsed }; +}; + +// src/features/settings/ClaudianSettings.ts +function formatHotkey(hotkey) { + const isMac = navigator.platform.includes("Mac"); + const modMap = isMac ? { Mod: "\u2318", Ctrl: "\u2303", Alt: "\u2325", Shift: "\u21E7", Meta: "\u2318" } : { Mod: "Ctrl", Ctrl: "Ctrl", Alt: "Alt", Shift: "Shift", Meta: "Win" }; + const mods = hotkey.modifiers.map((modifier) => modMap[modifier] || modifier); + const key = hotkey.key.length === 1 ? hotkey.key.toUpperCase() : hotkey.key; + return isMac ? [...mods, key].join("") : [...mods, key].join("+"); +} +function openHotkeySettings(app) { + const setting = app.setting; + setting.open(); + setting.openTabById("hotkeys"); + setTimeout(() => { + var _a3, _b2, _c; + const tab = setting.activeTab; + if (!tab) { + return; + } + const searchEl = (_b2 = tab.searchInputEl) != null ? _b2 : (_a3 = tab.searchComponent) == null ? void 0 : _a3.inputEl; + if (!searchEl) { + return; + } + searchEl.value = "Claudian"; + (_c = tab.updateHotkeyVisibility) == null ? void 0 : _c.call(tab); + }, 100); +} +function getHotkeyForCommand(app, commandId) { + var _a3, _b2; + const hotkeyManager = app.hotkeyManager; + if (!hotkeyManager) return null; + const customHotkeys = (_a3 = hotkeyManager.customKeys) == null ? void 0 : _a3[commandId]; + const defaultHotkeys = (_b2 = hotkeyManager.defaultKeys) == null ? void 0 : _b2[commandId]; + const hotkeys = (customHotkeys == null ? void 0 : customHotkeys.length) > 0 ? customHotkeys : defaultHotkeys; + if (!hotkeys || hotkeys.length === 0) return null; + return hotkeys.map(formatHotkey).join(", "); +} +function addHotkeySettingRow(containerEl, app, commandId, translationPrefix) { + const hotkey = getHotkeyForCommand(app, commandId); + const item = containerEl.createDiv({ cls: "claudian-hotkey-item" }); + item.createSpan({ + cls: "claudian-hotkey-name", + text: t(`${translationPrefix}.name`) + }); + if (hotkey) { + item.createSpan({ cls: "claudian-hotkey-badge", text: hotkey }); + } + item.addEventListener("click", () => openHotkeySettings(app)); +} +var ClaudianSettingTab = class extends import_obsidian44.PluginSettingTab { + constructor(app, plugin) { + super(app, plugin); + this.activeTab = "general"; + this.plugin = plugin; + } + display() { + var _a3; + const { containerEl } = this; + containerEl.empty(); + containerEl.addClass("claudian-settings"); + setLocale(this.plugin.settings.locale); + const providerTabs = ProviderRegistry.getRegisteredProviderIds(); + const tabIds = ["general", ...providerTabs]; + if (!tabIds.includes(this.activeTab)) { + this.activeTab = "general"; + } + const tabBar = containerEl.createDiv({ cls: "claudian-settings-tabs" }); + const tabButtons = /* @__PURE__ */ new Map(); + const tabContents = /* @__PURE__ */ new Map(); + for (const id of tabIds) { + const label = id === "general" ? t("settings.tabs.general") : ProviderRegistry.getProviderDisplayName(id); + const button = tabBar.createEl("button", { + cls: `claudian-settings-tab${id === this.activeTab ? " claudian-settings-tab--active" : ""}`, + text: label + }); + button.addEventListener("click", () => { + var _a4, _b2; + this.activeTab = id; + for (const tabId of tabIds) { + (_a4 = tabButtons.get(tabId)) == null ? void 0 : _a4.toggleClass("claudian-settings-tab--active", tabId === id); + (_b2 = tabContents.get(tabId)) == null ? void 0 : _b2.toggleClass("claudian-settings-tab-content--active", tabId === id); + } + }); + tabButtons.set(id, button); + } + for (const id of tabIds) { + const content = containerEl.createDiv({ + cls: `claudian-settings-tab-content${id === this.activeTab ? " claudian-settings-tab-content--active" : ""}` + }); + tabContents.set(id, content); + } + this.renderGeneralTab(tabContents.get("general")); + for (const providerId of providerTabs) { + const content = tabContents.get(providerId); + if (!content) { + continue; + } + (_a3 = ProviderWorkspaceRegistry.getSettingsTabRenderer(providerId)) == null ? void 0 : _a3.render(content, { + plugin: this.plugin, + renderHiddenProviderCommandSetting: (target, targetProviderId, copy) => this.renderHiddenProviderCommandSetting(target, targetProviderId, copy), + refreshModelSelectors: () => { + for (const view of this.plugin.getAllViews()) { + view.refreshModelSelector(); + } + }, + renderCustomContextLimits: (target, providerId2) => this.renderCustomContextLimits(target, providerId2) + }); + } + } + renderGeneralTab(container) { + new import_obsidian44.Setting(container).setName(t("settings.language.name")).setDesc(t("settings.language.desc")).addDropdown((dropdown) => { + const locales = getAvailableLocales(); + for (const locale of locales) { + dropdown.addOption(locale, getLocaleDisplayName(locale)); + } + dropdown.setValue(this.plugin.settings.locale).onChange(async (value) => { + const locale = value; + if (!setLocale(locale)) { + dropdown.setValue(this.plugin.settings.locale); + return; + } + this.plugin.settings.locale = locale; + await this.plugin.saveSettings(); + this.display(); + }); + }); + new import_obsidian44.Setting(container).setName(t("settings.display")).setHeading(); + new import_obsidian44.Setting(container).setName(t("settings.tabBarPosition.name")).setDesc(t("settings.tabBarPosition.desc")).addDropdown((dropdown) => { + var _a3; + dropdown.addOption("input", t("settings.tabBarPosition.input")).addOption("header", t("settings.tabBarPosition.header")).setValue((_a3 = this.plugin.settings.tabBarPosition) != null ? _a3 : "input").onChange(async (value) => { + this.plugin.settings.tabBarPosition = value; + await this.plugin.saveSettings(); + for (const view of this.plugin.getAllViews()) { + view.updateLayoutForPosition(); + } + }); + }); + const maxTabsSetting = new import_obsidian44.Setting(container).setName(t("settings.maxTabs.name")).setDesc(t("settings.maxTabs.desc")); + const maxTabsWarningEl = container.createDiv({ cls: "claudian-max-tabs-warning" }); + maxTabsWarningEl.style.color = "var(--text-warning)"; + maxTabsWarningEl.style.fontSize = "0.85em"; + maxTabsWarningEl.style.marginTop = "-0.5em"; + maxTabsWarningEl.style.marginBottom = "0.5em"; + maxTabsWarningEl.style.display = "none"; + maxTabsWarningEl.setText(t("settings.maxTabs.warning")); + const updateMaxTabsWarning = (value) => { + maxTabsWarningEl.style.display = value > 5 ? "block" : "none"; + }; + maxTabsSetting.addSlider((slider) => { + var _a3, _b2; + slider.setLimits(3, 10, 1).setValue((_a3 = this.plugin.settings.maxTabs) != null ? _a3 : 3).setDynamicTooltip().onChange(async (value) => { + this.plugin.settings.maxTabs = value; + await this.plugin.saveSettings(); + updateMaxTabsWarning(value); + }); + updateMaxTabsWarning((_b2 = this.plugin.settings.maxTabs) != null ? _b2 : 3); + }); + new import_obsidian44.Setting(container).setName(t("settings.openInMainTab.name")).setDesc(t("settings.openInMainTab.desc")).addToggle( + (toggle) => toggle.setValue(this.plugin.settings.openInMainTab).onChange(async (value) => { + this.plugin.settings.openInMainTab = value; + await this.plugin.saveSettings(); + }) + ); + new import_obsidian44.Setting(container).setName(t("settings.enableAutoScroll.name")).setDesc(t("settings.enableAutoScroll.desc")).addToggle( + (toggle) => { + var _a3; + return toggle.setValue((_a3 = this.plugin.settings.enableAutoScroll) != null ? _a3 : true).onChange(async (value) => { + this.plugin.settings.enableAutoScroll = value; + await this.plugin.saveSettings(); + }); + } + ); + new import_obsidian44.Setting(container).setName(t("settings.conversations")).setHeading(); + new import_obsidian44.Setting(container).setName(t("settings.autoTitle.name")).setDesc(t("settings.autoTitle.desc")).addToggle( + (toggle) => toggle.setValue(this.plugin.settings.enableAutoTitleGeneration).onChange(async (value) => { + this.plugin.settings.enableAutoTitleGeneration = value; + await this.plugin.saveSettings(); + this.display(); + }) + ); + if (this.plugin.settings.enableAutoTitleGeneration) { + new import_obsidian44.Setting(container).setName(t("settings.titleModel.name")).setDesc(t("settings.titleModel.desc")).addDropdown((dropdown) => { + dropdown.addOption("", t("settings.titleModel.auto")); + const settingsBag = this.plugin.settings; + const seenValues = /* @__PURE__ */ new Set(); + for (const providerId of ProviderRegistry.getRegisteredProviderIds()) { + const uiConfig = ProviderRegistry.getChatUIConfig(providerId); + for (const model of uiConfig.getModelOptions(settingsBag)) { + if (!seenValues.has(model.value)) { + seenValues.add(model.value); + dropdown.addOption(model.value, model.label); + } + } + } + dropdown.setValue(this.plugin.settings.titleGenerationModel || "").onChange(async (value) => { + this.plugin.settings.titleGenerationModel = value; + await this.plugin.saveSettings(); + }); + }); + } + new import_obsidian44.Setting(container).setName(t("settings.content")).setHeading(); + new import_obsidian44.Setting(container).setName(t("settings.userName.name")).setDesc(t("settings.userName.desc")).addText((text) => { + text.setPlaceholder(t("settings.userName.name")).setValue(this.plugin.settings.userName).onChange(async (value) => { + this.plugin.settings.userName = value; + await this.plugin.saveSettings(); + }); + text.inputEl.addEventListener("blur", () => this.restartServiceForPromptChange()); + }); + new import_obsidian44.Setting(container).setName(t("settings.systemPrompt.name")).setDesc(t("settings.systemPrompt.desc")).addTextArea((text) => { + text.setPlaceholder(t("settings.systemPrompt.name")).setValue(this.plugin.settings.systemPrompt).onChange(async (value) => { + this.plugin.settings.systemPrompt = value; + await this.plugin.saveSettings(); + }); + text.inputEl.rows = 6; + text.inputEl.cols = 50; + text.inputEl.addEventListener("blur", () => this.restartServiceForPromptChange()); + }); + new import_obsidian44.Setting(container).setName(t("settings.excludedTags.name")).setDesc(t("settings.excludedTags.desc")).addTextArea((text) => { + text.setPlaceholder("system\nprivate\ndraft").setValue(this.plugin.settings.excludedTags.join("\n")).onChange(async (value) => { + this.plugin.settings.excludedTags = value.split(/\r?\n/).map((entry) => entry.trim().replace(/^#/, "")).filter((entry) => entry.length > 0); + await this.plugin.saveSettings(); + }); + text.inputEl.rows = 4; + text.inputEl.cols = 30; + }); + new import_obsidian44.Setting(container).setName(t("settings.mediaFolder.name")).setDesc(t("settings.mediaFolder.desc")).addText((text) => { + text.setPlaceholder("attachments").setValue(this.plugin.settings.mediaFolder).onChange(async (value) => { + this.plugin.settings.mediaFolder = value.trim(); + await this.plugin.saveSettings(); + }); + text.inputEl.addClass("claudian-settings-media-input"); + text.inputEl.addEventListener("blur", () => this.restartServiceForPromptChange()); + }); + new import_obsidian44.Setting(container).setName(t("settings.input")).setHeading(); + new import_obsidian44.Setting(container).setName(t("settings.navMappings.name")).setDesc(t("settings.navMappings.desc")).addTextArea((text) => { + let pendingValue = buildNavMappingText(this.plugin.settings.keyboardNavigation); + let saveTimeout = null; + const commitValue = async (showError) => { + if (saveTimeout !== null) { + window.clearTimeout(saveTimeout); + saveTimeout = null; + } + const result = parseNavMappings(pendingValue); + if (!result.settings) { + if (showError) { + new import_obsidian44.Notice(`${t("common.error")}: ${result.error}`); + pendingValue = buildNavMappingText(this.plugin.settings.keyboardNavigation); + text.setValue(pendingValue); + } + return; + } + this.plugin.settings.keyboardNavigation.scrollUpKey = result.settings.scrollUp; + this.plugin.settings.keyboardNavigation.scrollDownKey = result.settings.scrollDown; + this.plugin.settings.keyboardNavigation.focusInputKey = result.settings.focusInput; + await this.plugin.saveSettings(); + pendingValue = buildNavMappingText(this.plugin.settings.keyboardNavigation); + text.setValue(pendingValue); + }; + const scheduleSave = () => { + if (saveTimeout !== null) { + window.clearTimeout(saveTimeout); + } + saveTimeout = window.setTimeout(() => { + void commitValue(false); + }, 500); + }; + text.setPlaceholder("map w scrollUp\nmap s scrollDown\nmap i focusInput").setValue(pendingValue).onChange((value) => { + pendingValue = value; + scheduleSave(); + }); + text.inputEl.rows = 3; + text.inputEl.addEventListener("blur", async () => { + await commitValue(true); + }); + }); + new import_obsidian44.Setting(container).setName(t("settings.hotkeys")).setHeading(); + const hotkeyGrid = container.createDiv({ cls: "claudian-hotkey-grid" }); + addHotkeySettingRow(hotkeyGrid, this.app, "claudian:inline-edit", "settings.inlineEditHotkey"); + addHotkeySettingRow(hotkeyGrid, this.app, "claudian:open-view", "settings.openChatHotkey"); + addHotkeySettingRow(hotkeyGrid, this.app, "claudian:new-session", "settings.newSessionHotkey"); + addHotkeySettingRow(hotkeyGrid, this.app, "claudian:new-tab", "settings.newTabHotkey"); + addHotkeySettingRow(hotkeyGrid, this.app, "claudian:close-current-tab", "settings.closeTabHotkey"); + renderEnvironmentSettingsSection({ + container, + plugin: this.plugin, + scope: "shared", + heading: t("settings.environment"), + name: "Shared environment", + desc: "Provider-neutral runtime variables shared across all providers. Use this for PATH, proxy, cert, and temp variables.", + placeholder: "PATH=/opt/homebrew/bin:/usr/local/bin\nHTTPS_PROXY=http://proxy.example.com:8080\nSSL_CERT_FILE=/path/to/cert.pem", + renderCustomContextLimits: (target) => this.renderCustomContextLimits(target) + }); + } + renderHiddenProviderCommandSetting(container, providerId, copy) { + new import_obsidian44.Setting(container).setName(copy.name).setDesc(copy.desc).addTextArea((text) => { + text.setPlaceholder(copy.placeholder).setValue(getHiddenProviderCommands(this.plugin.settings, providerId).join("\n")).onChange(async (value) => { + var _a3; + this.plugin.settings.hiddenProviderCommands = { + ...this.plugin.settings.hiddenProviderCommands, + [providerId]: normalizeHiddenCommandList(value.split(/\r?\n/)) + }; + await this.plugin.saveSettings(); + (_a3 = this.plugin.getView()) == null ? void 0 : _a3.updateHiddenProviderCommands(); + }); + text.inputEl.rows = 4; + text.inputEl.cols = 30; + }); + } + renderCustomContextLimits(container, providerId) { + var _a3; + container.empty(); + const uniqueModelIds = /* @__PURE__ */ new Set(); + const providerIds = providerId ? [providerId] : ProviderRegistry.getRegisteredProviderIds(); + for (const targetProviderId of providerIds) { + const envVars = parseEnvironmentVariables( + this.plugin.getActiveEnvironmentVariables(targetProviderId) + ); + for (const modelId of ProviderRegistry.getChatUIConfig(targetProviderId).getCustomModelIds(envVars)) { + uniqueModelIds.add(modelId); + } + } + if (uniqueModelIds.size === 0) { + return; + } + const headerEl = container.createDiv({ cls: "claudian-context-limits-header" }); + headerEl.createSpan({ + text: t("settings.customContextLimits.name"), + cls: "claudian-context-limits-label" + }); + const descEl = container.createDiv({ cls: "claudian-context-limits-desc" }); + descEl.setText(t("settings.customContextLimits.desc")); + const listEl = container.createDiv({ cls: "claudian-context-limits-list" }); + for (const modelId of uniqueModelIds) { + const currentValue = (_a3 = this.plugin.settings.customContextLimits) == null ? void 0 : _a3[modelId]; + const itemEl = listEl.createDiv({ cls: "claudian-context-limits-item" }); + const nameEl = itemEl.createDiv({ cls: "claudian-context-limits-model" }); + nameEl.setText(modelId); + const inputWrapper = itemEl.createDiv({ cls: "claudian-context-limits-input-wrapper" }); + const inputEl = inputWrapper.createEl("input", { + type: "text", + placeholder: "200k", + cls: "claudian-context-limits-input", + value: currentValue ? formatContextLimit(currentValue) : "" + }); + const validationEl = inputWrapper.createDiv({ cls: "claudian-context-limit-validation" }); + inputEl.addEventListener("input", async () => { + const trimmed = inputEl.value.trim(); + if (!this.plugin.settings.customContextLimits) { + this.plugin.settings.customContextLimits = {}; + } + if (!trimmed) { + delete this.plugin.settings.customContextLimits[modelId]; + validationEl.style.display = "none"; + inputEl.classList.remove("claudian-input-error"); + } else { + const parsed = parseContextLimit(trimmed); + if (parsed === null) { + validationEl.setText(t("settings.customContextLimits.invalid")); + validationEl.style.display = "block"; + inputEl.classList.add("claudian-input-error"); + return; + } + this.plugin.settings.customContextLimits[modelId] = parsed; + validationEl.style.display = "none"; + inputEl.classList.remove("claudian-input-error"); + } + await this.plugin.saveSettings(); + }); + } + } + async restartServiceForPromptChange() { + const view = this.plugin.getView(); + const tabManager = view == null ? void 0 : view.getTabManager(); + if (!tabManager) return; + try { + await tabManager.broadcastToAllTabs( + async (service) => { + await service.ensureReady({ force: true }); + } + ); + } catch (e3) { + } + } +}; + +// src/main.ts +init_path(); +patchSetMaxListenersForElectron(); +var ClaudianPlugin = class extends import_obsidian45.Plugin { + constructor() { + super(...arguments); + this.conversations = []; + } + async onload() { + await this.loadSettings(); + await ProviderWorkspaceRegistry.initializeAll(this); + this.registerView( + VIEW_TYPE_CLAUDIAN, + (leaf) => new ClaudianView(leaf, this) + ); + this.addRibbonIcon("bot", "Open Claudian", () => { + this.activateView(); + }); + this.addCommand({ + id: "open-view", + name: "Open chat view", + callback: () => { + this.activateView(); + } + }); + this.addCommand({ + id: "inline-edit", + name: "Inline edit", + editorCallback: async (editor, ctx) => { + var _a3; + const view = ctx instanceof import_obsidian45.MarkdownView ? ctx : this.app.workspace.getActiveViewOfType(import_obsidian45.MarkdownView); + if (!view) { + new import_obsidian45.Notice("Inline edit unavailable: could not access the active markdown view."); + return; + } + const selectedText = editor.getSelection(); + const notePath = ((_a3 = view.file) == null ? void 0 : _a3.path) || "unknown"; + let editContext; + if (selectedText.trim()) { + editContext = { mode: "selection", selectedText }; + } else { + const cursor = editor.getCursor(); + const cursorContext = buildCursorContext( + (line) => editor.getLine(line), + editor.lineCount(), + cursor.line, + cursor.ch + ); + editContext = { mode: "cursor", cursorContext }; + } + const modal = new InlineEditModal( + this.app, + this, + editor, + view, + editContext, + notePath, + () => { + var _a4, _b2, _c, _d; + return (_d = (_c = (_b2 = (_a4 = this.getView()) == null ? void 0 : _a4.getActiveTab()) == null ? void 0 : _b2.ui.externalContextSelector) == null ? void 0 : _c.getExternalContexts()) != null ? _d : []; + } + ); + const result = await modal.openAndWait(); + if (result.decision === "accept" && result.editedText !== void 0) { + new import_obsidian45.Notice(editContext.mode === "cursor" ? "Inserted" : "Edit applied"); + } + } + }); + this.addCommand({ + id: "new-tab", + name: "New tab", + checkCallback: (checking) => { + const leaf = this.app.workspace.getLeavesOfType(VIEW_TYPE_CLAUDIAN)[0]; + if (!leaf) return false; + const view = leaf.view; + const tabManager = view.getTabManager(); + if (!tabManager) return false; + if (!tabManager.canCreateTab()) return false; + if (!checking) { + tabManager.createTab(); + } + return true; + } + }); + this.addCommand({ + id: "new-session", + name: "New session (in current tab)", + checkCallback: (checking) => { + const leaf = this.app.workspace.getLeavesOfType(VIEW_TYPE_CLAUDIAN)[0]; + if (!leaf) return false; + const view = leaf.view; + const tabManager = view.getTabManager(); + if (!tabManager) return false; + const activeTab = tabManager.getActiveTab(); + if (!activeTab) return false; + if (activeTab.state.isStreaming) return false; + if (!checking) { + tabManager.createNewConversation(); + } + return true; + } + }); + this.addCommand({ + id: "close-current-tab", + name: "Close current tab", + checkCallback: (checking) => { + const leaf = this.app.workspace.getLeavesOfType(VIEW_TYPE_CLAUDIAN)[0]; + if (!leaf) return false; + const view = leaf.view; + const tabManager = view.getTabManager(); + if (!tabManager) return false; + if (!checking) { + const activeTabId = tabManager.getActiveTabId(); + if (activeTabId) { + tabManager.closeTab(activeTabId); + } + } + return true; + } + }); + this.addSettingTab(new ClaudianSettingTab(this.app, this)); + } + async onunload() { + for (const view of this.getAllViews()) { + const tabManager = view.getTabManager(); + if (tabManager) { + const state = tabManager.getPersistedState(); + await this.storage.setTabManagerState(state); + } + } + } + async activateView() { + const { workspace } = this.app; + let leaf = workspace.getLeavesOfType(VIEW_TYPE_CLAUDIAN)[0]; + if (!leaf) { + const newLeaf = this.settings.openInMainTab ? workspace.getLeaf("tab") : workspace.getRightLeaf(false); + if (newLeaf) { + await newLeaf.setViewState({ + type: VIEW_TYPE_CLAUDIAN, + active: true + }); + leaf = newLeaf; + } + } + if (leaf) { + workspace.revealLeaf(leaf); + } + } + async loadSettings() { + this.storage = new SharedStorageService(this); + const { claudian } = await this.storage.initialize(); + this.settings = { + ...DEFAULT_CLAUDIAN_SETTINGS, + ...claudian + }; + if (this.settings.permissionMode === "plan") { + this.settings.permissionMode = "normal"; + } + const didNormalizeProviderSelection = ProviderSettingsCoordinator.normalizeProviderSelection( + this.settings + ); + const didNormalizeModelVariants = this.normalizeModelVariantSettings(); + const allMetadata = await this.storage.sessions.listMetadata(); + this.conversations = allMetadata.map((meta3) => { + var _a3; + const resumeSessionId = meta3.sessionId !== void 0 ? meta3.sessionId : meta3.id; + return { + id: meta3.id, + providerId: (_a3 = meta3.providerId) != null ? _a3 : DEFAULT_CHAT_PROVIDER_ID, + title: meta3.title, + createdAt: meta3.createdAt, + updatedAt: meta3.updatedAt, + lastResponseAt: meta3.lastResponseAt, + sessionId: resumeSessionId, + providerState: meta3.providerState, + messages: [], + currentNote: meta3.currentNote, + externalContextPaths: meta3.externalContextPaths, + enabledMcpServers: meta3.enabledMcpServers, + usage: meta3.usage, + titleGenerationStatus: meta3.titleGenerationStatus, + resumeAtMessageId: meta3.resumeAtMessageId + }; + }).sort( + (a3, b) => { + var _a3, _b2; + return ((_a3 = b.lastResponseAt) != null ? _a3 : b.updatedAt) - ((_b2 = a3.lastResponseAt) != null ? _b2 : a3.updatedAt); + } + ); + setLocale(this.settings.locale); + const backfilledConversations = this.backfillConversationResponseTimestamps(); + const { changed, invalidatedConversations } = this.reconcileModelWithEnvironment(); + ProviderSettingsCoordinator.projectActiveProviderState( + this.settings + ); + if (changed || didNormalizeModelVariants || didNormalizeProviderSelection) { + await this.saveSettings(); + } + const conversationsToSave = /* @__PURE__ */ new Set([...backfilledConversations, ...invalidatedConversations]); + for (const conv of conversationsToSave) { + await this.storage.sessions.saveMetadata( + this.storage.sessions.toSessionMetadata(conv) + ); + } + } + backfillConversationResponseTimestamps() { + const updated = []; + for (const conv of this.conversations) { + if (conv.lastResponseAt != null) continue; + if (!conv.messages || conv.messages.length === 0) continue; + for (let i3 = conv.messages.length - 1; i3 >= 0; i3--) { + const msg = conv.messages[i3]; + if (msg.role === "assistant") { + conv.lastResponseAt = msg.timestamp; + updated.push(conv); + break; + } + } + } + return updated; + } + normalizeModelVariantSettings() { + return ProviderSettingsCoordinator.normalizeAllModelVariants( + this.settings + ); + } + async saveSettings() { + ProviderSettingsCoordinator.normalizeProviderSelection( + this.settings + ); + ProviderSettingsCoordinator.persistProjectedProviderState( + this.settings + ); + await this.storage.saveClaudianSettings(this.settings); + } + /** Updates and persists environment variables, restarting processes to apply changes. */ + async applyEnvironmentVariables(scope, envText) { + await this.applyEnvironmentVariablesBatch([{ scope, envText }]); + } + async applyEnvironmentVariablesBatch(updates) { + var _a3, _b2, _c; + const settingsBag = this.settings; + const nextEnvironmentByScope = /* @__PURE__ */ new Map(); + for (const update of updates) { + nextEnvironmentByScope.set(update.scope, update.envText); + } + const changedScopes = []; + for (const [scope, envText] of nextEnvironmentByScope) { + const currentValue = getEnvironmentVariablesForScope(settingsBag, scope); + if (currentValue !== envText) { + changedScopes.push(scope); + } + setEnvironmentVariablesForScope(settingsBag, scope, envText); + } + if (changedScopes.length === 0) { + await this.saveSettings(); + return; + } + const affectedProviderIds = this.getAffectedEnvironmentProviders(changedScopes); + const { changed, invalidatedConversations } = this.reconcileModelWithEnvironment(affectedProviderIds); + await this.saveSettings(); + if (invalidatedConversations.length > 0) { + for (const conv of invalidatedConversations) { + await this.storage.sessions.saveMetadata( + this.storage.sessions.toSessionMetadata(conv) + ); + } + } + const view = this.getView(); + const tabManager = view == null ? void 0 : view.getTabManager(); + if (tabManager) { + const affectedTabs = tabManager.getAllTabs().filter((tab) => { + var _a4; + return affectedProviderIds.includes((_a4 = tab.providerId) != null ? _a4 : DEFAULT_CHAT_PROVIDER_ID); + }); + for (const tab of affectedTabs) { + if (tab.state.isStreaming) { + (_a3 = tab.controllers.inputController) == null ? void 0 : _a3.cancelStreaming(); + } + } + let failedTabs = 0; + if (changed) { + for (const tab of affectedTabs) { + if (!tab.service || !tab.serviceInitialized) { + continue; + } + try { + const externalContextPaths = (_c = (_b2 = tab.ui.externalContextSelector) == null ? void 0 : _b2.getExternalContexts()) != null ? _c : []; + tab.service.resetSession(); + await tab.service.ensureReady({ externalContextPaths }); + } catch (e3) { + failedTabs++; + } + } + } else { + for (const tab of affectedTabs) { + if (!tab.service || !tab.serviceInitialized) { + continue; + } + try { + await tab.service.ensureReady({ force: true }); + } catch (e3) { + failedTabs++; + } + } + } + if (failedTabs > 0) { + new import_obsidian45.Notice(`Environment changes applied, but ${failedTabs} affected tab(s) failed to restart.`); + } + } + for (const openView of this.getAllViews()) { + openView.refreshModelSelector(); + } + const noticeText = changed ? "Environment variables applied. Sessions will be rebuilt on next message." : "Environment variables applied."; + new import_obsidian45.Notice(noticeText); + } + /** Returns the runtime environment variables (fixed at plugin load). */ + getActiveEnvironmentVariables(providerId = ProviderRegistry.resolveSettingsProviderId( + this.settings + )) { + return getRuntimeEnvironmentText( + this.settings, + providerId + ); + } + getEnvironmentVariablesForScope(scope) { + return getEnvironmentVariablesForScope( + this.settings, + scope + ); + } + getResolvedProviderCliPath(providerId) { + const cliResolver = ProviderWorkspaceRegistry.getCliResolver(providerId); + if (!cliResolver) { + return null; + } + return cliResolver.resolveFromSettings(this.settings); + } + reconcileModelWithEnvironment(providerIds = ProviderRegistry.getRegisteredProviderIds()) { + return ProviderSettingsCoordinator.reconcileProviders( + this.settings, + this.conversations, + providerIds + ); + } + getAffectedEnvironmentProviders(scopes) { + const registeredProviderIds = new Set(ProviderRegistry.getRegisteredProviderIds()); + const affectedProviderIds = /* @__PURE__ */ new Set(); + for (const scope of scopes) { + if (scope === "shared") { + for (const providerId2 of registeredProviderIds) { + affectedProviderIds.add(providerId2); + } + continue; + } + const providerId = scope.slice("provider:".length); + if (registeredProviderIds.has(providerId)) { + affectedProviderIds.add(providerId); + } + } + return Array.from(affectedProviderIds); + } + generateConversationId() { + return `conv-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`; + } + generateDefaultTitle() { + const now = /* @__PURE__ */ new Date(); + return now.toLocaleString(void 0, { + month: "short", + day: "numeric", + hour: "2-digit", + minute: "2-digit" + }); + } + getConversationPreview(conv) { + const firstUserMsg = conv.messages.find((m3) => m3.role === "user"); + if (!firstUserMsg) { + return "New conversation"; + } + return firstUserMsg.content.substring(0, 50) + (firstUserMsg.content.length > 50 ? "..." : ""); + } + async loadSdkMessagesForConversation(conversation) { + await ProviderRegistry.getConversationHistoryService(conversation.providerId).hydrateConversationHistory(conversation, getVaultPath(this.app)); + } + async createConversation(options) { + var _a3; + const providerId = (_a3 = options == null ? void 0 : options.providerId) != null ? _a3 : DEFAULT_CHAT_PROVIDER_ID; + const sessionId = options == null ? void 0 : options.sessionId; + const conversationId = sessionId != null ? sessionId : this.generateConversationId(); + const conversation = { + id: conversationId, + providerId, + title: this.generateDefaultTitle(), + createdAt: Date.now(), + updatedAt: Date.now(), + sessionId: sessionId != null ? sessionId : null, + messages: [] + }; + this.conversations.unshift(conversation); + await this.storage.sessions.saveMetadata( + this.storage.sessions.toSessionMetadata(conversation) + ); + return conversation; + } + async switchConversation(id) { + const conversation = this.conversations.find((c) => c.id === id); + if (!conversation) return null; + await this.loadSdkMessagesForConversation(conversation); + return conversation; + } + async deleteConversation(id) { + var _a3, _b2; + const index = this.conversations.findIndex((c) => c.id === id); + if (index === -1) return; + const conversation = this.conversations[index]; + this.conversations.splice(index, 1); + await ProviderRegistry.getConversationHistoryService(conversation.providerId).deleteConversationSession(conversation, getVaultPath(this.app)); + await this.storage.sessions.deleteMetadata(id); + for (const view of this.getAllViews()) { + const tabManager = view.getTabManager(); + if (!tabManager) continue; + for (const tab of tabManager.getAllTabs()) { + if (tab.conversationId === id) { + (_a3 = tab.controllers.inputController) == null ? void 0 : _a3.cancelStreaming(); + await ((_b2 = tab.controllers.conversationController) == null ? void 0 : _b2.createNew({ force: true })); + } + } + } + } + async renameConversation(id, title) { + const conversation = this.conversations.find((c) => c.id === id); + if (!conversation) return; + conversation.title = title.trim() || this.generateDefaultTitle(); + conversation.updatedAt = Date.now(); + await this.storage.sessions.saveMetadata( + this.storage.sessions.toSessionMetadata(conversation) + ); + } + async updateConversation(id, updates) { + const conversation = this.conversations.find((c) => c.id === id); + if (!conversation) return; + const { providerId: _3, ...safeUpdates } = updates; + Object.assign(conversation, safeUpdates, { updatedAt: Date.now() }); + await this.storage.sessions.saveMetadata( + this.storage.sessions.toSessionMetadata(conversation) + ); + if (!ProviderRegistry.getConversationHistoryService(conversation.providerId).isPendingForkConversation(conversation)) { + for (const msg of conversation.messages) { + if (msg.images) { + for (const img of msg.images) { + img.data = ""; + } + } + } + } + } + async getConversationById(id) { + const conversation = this.conversations.find((c) => c.id === id) || null; + if (conversation) { + await this.loadSdkMessagesForConversation(conversation); + } + return conversation; + } + getConversationSync(id) { + return this.conversations.find((c) => c.id === id) || null; + } + findEmptyConversation() { + return this.conversations.find((c) => c.messages.length === 0) || null; + } + getConversationList() { + return this.conversations.map((c) => ({ + id: c.id, + providerId: c.providerId, + title: c.title, + createdAt: c.createdAt, + updatedAt: c.updatedAt, + lastResponseAt: c.lastResponseAt, + messageCount: c.messages.length, + preview: this.getConversationPreview(c), + titleGenerationStatus: c.titleGenerationStatus + })); + } + getView() { + const leaves = this.app.workspace.getLeavesOfType(VIEW_TYPE_CLAUDIAN); + if (leaves.length > 0) { + return leaves[0].view; + } + return null; + } + getAllViews() { + const leaves = this.app.workspace.getLeavesOfType(VIEW_TYPE_CLAUDIAN); + return leaves.map((leaf) => leaf.view); + } + findConversationAcrossViews(conversationId) { + for (const view of this.getAllViews()) { + const tabManager = view.getTabManager(); + if (!tabManager) continue; + const tabs = tabManager.getAllTabs(); + for (const tab of tabs) { + if (tab.conversationId === conversationId) { + return { view, tabId: tab.id }; + } + } + } + return null; + } +}; +/*! Bundled license information: + +smol-toml/dist/error.js: +smol-toml/dist/util.js: +smol-toml/dist/date.js: +smol-toml/dist/primitive.js: +smol-toml/dist/extract.js: +smol-toml/dist/struct.js: +smol-toml/dist/parse.js: +smol-toml/dist/stringify.js: +smol-toml/dist/index.js: + (*! + * Copyright (c) Squirrel Chat et al., All rights reserved. + * SPDX-License-Identifier: BSD-3-Clause + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the copyright holder nor the names of its contributors + * may be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *) +*/ diff --git a/.obsidian/plugins/claudian/manifest.json b/.obsidian/plugins/claudian/manifest.json new file mode 100644 index 0000000..f209f68 --- /dev/null +++ b/.obsidian/plugins/claudian/manifest.json @@ -0,0 +1,10 @@ +{ + "id": "claudian", + "name": "Claudian", + "version": "2.0.2", + "minAppVersion": "1.4.5", + "description": "Embeds Claude Code as an AI collaborator in your vault. Your vault becomes Claude's working directory, giving it full agentic capabilities: file read/write, search, bash commands, and multi-step workflows.", + "author": "Yishen Tu", + "authorUrl": "https://github.com/YishenTu", + "isDesktopOnly": true +} diff --git a/.obsidian/plugins/claudian/styles.css b/.obsidian/plugins/claudian/styles.css new file mode 100644 index 0000000..c243ecd --- /dev/null +++ b/.obsidian/plugins/claudian/styles.css @@ -0,0 +1,5699 @@ +/* Claudian Plugin Styles */ +/* Built from src/style/ modules */ + + +/* ============================================ + base/variables.css + ============================================ */ +/* Brand & semantic color tokens */ +.claudian-container { + --claudian-brand: #D97757; + --claudian-brand-rgb: 217, 119, 87; + --claudian-error: #dc3545; + --claudian-error-rgb: 220, 53, 69; + --claudian-compact: #5bc0de; +} + +/* Provider-specific brand overrides */ +body.theme-dark .claudian-container[data-provider="codex"] { + --claudian-brand: #d0d0d0; + --claudian-brand-rgb: 208, 208, 208; +} + +body.theme-light .claudian-container[data-provider="codex"] { + --claudian-brand: #000000; + --claudian-brand-rgb: 0, 0, 0; +} + + +/* ============================================ + base/container.css + ============================================ */ +.claudian-container { + display: flex; + flex-direction: column; + height: 100%; + padding: 0; + overflow: hidden; + font-family: var(--font-text); +} + + +/* ============================================ + base/animations.css + ============================================ */ +@keyframes thinking-pulse { + 0%, + 100% { + opacity: 0.5; + } + + 50% { + opacity: 1; + } +} + +@keyframes spin { + to { + transform: rotate(360deg); + } +} + +@keyframes external-context-glow { + 0%, + 100% { + filter: drop-shadow(0 0 2px rgba(var(--claudian-brand-rgb), 0.4)); + } + + 50% { + filter: drop-shadow(0 0 6px rgba(var(--claudian-brand-rgb), 0.8)); + } +} + +@keyframes mcp-glow { + 0%, + 100% { + filter: drop-shadow(0 0 2px rgba(124, 58, 237, 0.4)); + } + + 50% { + filter: drop-shadow(0 0 8px rgba(124, 58, 237, 0.9)); + } +} + +@keyframes claudian-spin { + to { + transform: rotate(360deg); + } +} + + +/* ============================================ + components/header.css + ============================================ */ +/* Header - logo, title/tabs slot, and actions */ +.claudian-header { + display: flex; + align-items: center; + padding: 0 12px 12px 12px; +} + +/* Title slot: contains logo + title (or tabs in header mode) */ +.claudian-title-slot { + display: flex; + align-items: center; + gap: 8px; + flex: 1; + min-width: 0; /* Allow flex item to shrink below content size */ +} + +/* Legacy class for backwards compatibility */ +.claudian-title { + display: flex; + align-items: center; + gap: 8px; + flex-shrink: 0; +} + +.claudian-title-text { + margin: 0; + font-size: 14px; + font-weight: 600; +} + +.claudian-logo { + display: flex; + align-items: center; + color: var(--claudian-brand); +} + +/* Header actions (end side - always stays at end via margin-inline-start: auto) */ +.claudian-header-actions { + display: flex; + align-items: center; + gap: 12px; + flex-shrink: 0; + margin-inline-start: auto; +} + +.claudian-header-actions-slot { + /* No margin-inline-start: auto here; it's set by the base .claudian-header-actions */ +} + +.claudian-header .claudian-tab-bar-container { + display: flex; + gap: 4px; +} + +.claudian-header-btn { + display: flex; + align-items: center; + justify-content: center; + cursor: pointer; + color: var(--text-faint); + transition: color 0.15s ease; +} + +.claudian-header-btn:hover { + color: var(--text-normal); +} + +.claudian-header-btn svg { + width: 16px; + height: 16px; +} + +.claudian-new-tab-btn svg { + width: 16.8px; + height: 16.8px; +} + +/* ============================================ + components/tabs.css + ============================================ */ +.claudian-tab-bar-container { + display: flex; + align-items: center; + gap: 4px; +} + +.claudian-tab-badges { + display: flex; + align-items: center; + gap: 4px; +} + +.claudian-tab-badge { + display: flex; + align-items: center; + justify-content: center; + width: 24px; + height: 24px; + border-radius: 4px; + border: 2px solid var(--background-modifier-border); + font-size: 12px; + font-weight: 500; + cursor: pointer; + color: var(--text-muted); + background: var(--background-primary); + transition: border-color 0.15s ease, color 0.15s ease, background 0.15s ease; +} + +.claudian-tab-badge:hover { + background: var(--background-modifier-hover); + color: var(--text-normal); +} + +.claudian-tab-badge-active { + border-color: var(--interactive-accent); + color: var(--text-normal); +} + +.claudian-tab-badge-streaming { + border-color: var(--claudian-brand, #da7756); +} + +.claudian-tab-badge-attention { + border-color: var(--text-error); +} + +.claudian-tab-badge-idle { + border-color: var(--background-modifier-border); +} + +.claudian-tab-content-container { + display: flex; + flex-direction: column; + flex: 1; + min-height: 0; + overflow: hidden; +} + +.claudian-tab-content { + position: relative; /* For scroll-to-bottom button positioning */ + display: flex; + flex-direction: column; + flex: 1; + min-height: 0; + overflow: hidden; +} + + +/* ============================================ + components/history.css + ============================================ */ +.claudian-history-container { + position: relative; +} + +/* History dropup menu (opens upward since it's at bottom of view) */ +.claudian-history-menu { + display: none; + position: absolute; + bottom: 100%; + inset-inline-end: 0; + margin-bottom: 4px; + background: var(--background-secondary); + backdrop-filter: blur(20px); + -webkit-backdrop-filter: blur(20px); + border: 1px solid var(--background-modifier-border); + border-radius: 6px; + box-shadow: 0 -4px 16px rgba(0, 0, 0, 0.25); + z-index: 1000; + max-height: 400px; + overflow: hidden; + width: 280px; +} + +.claudian-history-menu.visible { + display: block; +} + +/* Header mode: dropdown instead of dropup */ +.claudian-container--header-mode .claudian-history-menu { + bottom: auto; + top: 100%; + margin-bottom: 0; + margin-top: 4px; + box-shadow: 0 4px 16px rgba(0, 0, 0, 0.25); +} + +.claudian-history-header { + padding: 8px 12px; + font-size: 12px; + font-weight: 600; + color: var(--text-muted); + text-transform: uppercase; + letter-spacing: 0.5px; + border-bottom: 1px solid var(--background-modifier-border); +} + +.claudian-history-list { + max-height: 350px; + overflow-y: auto; +} + +.claudian-history-empty { + padding: 16px; + text-align: center; + color: var(--text-muted); + font-size: 13px; +} + +.claudian-history-item { + display: flex; + align-items: center; + gap: 10px; + padding: 8px 12px; + border-bottom: 1px solid var(--background-modifier-border); + transition: background 0.15s ease; +} + +.claudian-history-item-icon { + display: flex; + align-items: center; + color: var(--text-muted); + flex-shrink: 0; +} + +.claudian-history-item-icon svg { + width: 16px; + height: 16px; +} + +.claudian-history-item:last-child { + border-bottom: none; +} + +.claudian-history-item:hover { + background: var(--background-modifier-hover); +} + +.claudian-history-item.active { + background: var(--background-secondary); + border-inline-start: 2px solid var(--interactive-accent); + padding-inline-start: 10px; +} + +.claudian-history-item.active .claudian-history-item-icon { + color: var(--interactive-accent); +} + +.claudian-history-item.active .claudian-history-item-content { + cursor: default; +} + +.claudian-history-item.active .claudian-history-item-date { + color: var(--text-faint); +} + +.claudian-history-item-content { + flex: 1; + min-width: 0; + cursor: pointer; +} + +.claudian-history-item-title { + font-size: 13px; + font-weight: 500; + color: var(--text-normal); + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; +} + +.claudian-history-item-date { + font-size: 11px; + color: var(--text-faint); + margin-top: 2px; +} + +.claudian-history-item-actions { + display: flex; + gap: 4px; + margin-inline-start: 8px; + opacity: 0; + transition: opacity 0.15s ease; +} + +.claudian-history-item:hover .claudian-history-item-actions { + opacity: 1; +} + +.claudian-action-btn { + background: transparent; + border: none; + cursor: pointer; + padding: 4px; + border-radius: 4px; + color: var(--text-muted); + transition: background 0.15s ease, color 0.15s ease; +} + +.claudian-action-btn:hover { + background: var(--background-modifier-hover); + color: var(--text-normal); +} + +.claudian-action-btn svg { + width: 14px; + height: 14px; +} + +.claudian-delete-btn:hover { + color: var(--color-red); +} + +.claudian-rename-input { + width: 100%; + padding: 2px 4px; + font-size: 13px; + font-weight: 500; + border: 1px solid var(--interactive-accent); + border-radius: 4px; + background: var(--background-primary); + color: var(--text-normal); +} + +.claudian-rename-input:focus { + outline: none; + box-shadow: 0 0 0 2px var(--interactive-accent-hover); +} + +/* Loading indicator for title generation */ +.claudian-action-loading { + display: flex; + align-items: center; + justify-content: center; + animation: spin 1s linear infinite; + opacity: 0.6; + cursor: default; +} + + +/* ============================================ + components/messages.css + ============================================ */ +/* Messages wrapper (for scroll-to-bottom button positioning) */ +.claudian-messages-wrapper { + position: relative; + flex: 1; + min-height: 0; + display: flex; + flex-direction: column; + overflow: hidden; +} + +.claudian-messages { + flex: 1; + overflow-y: auto; + padding: 12px 0; + display: flex; + flex-direction: column; + gap: 12px; +} + +/* Focusable messages panel for vim-style navigation */ +.claudian-messages-focusable:focus { + outline: none; +} + +/* Welcome message - claude.ai style */ +.claudian-welcome { + flex: 1; + display: flex; + flex-direction: column; + align-items: center; + justify-content: center; + text-align: center; + padding: 20px; + min-height: 200px; +} + +.claudian-welcome-greeting { + font-family: 'Copernicus', 'Tiempos Headline', 'Tiempos', Georgia, 'Times New Roman', serif; + font-size: 28px; + font-weight: 300; + color: var(--text-muted); + letter-spacing: -0.01em; +} + +.claudian-message { + padding: 10px 14px; + border-radius: 8px; + max-width: 95%; + word-wrap: break-word; +} + +.claudian-message-user { + position: relative; + background: rgba(0, 0, 0, 0.3); + align-self: flex-end; + border-end-end-radius: 4px; +} + +/* Text selection in user messages - visible highlight */ +.claudian-message-user ::selection { + background: rgba(255, 255, 255, 0.35); + color: inherit; +} + +.claudian-message-assistant { + background: transparent; + align-self: stretch; + width: 100%; + max-width: 100%; + border-end-start-radius: 4px; + text-align: start; +} + +.claudian-message-content { + line-height: 1.5; + user-select: text; + -webkit-user-select: text; + unicode-bidi: plaintext; /* Proper BiDi text handling for mixed RTL/LTR */ +} + +.claudian-interrupted { + color: #d45d5d; +} + +.claudian-interrupted-hint { + color: var(--text-muted); +} + +.claudian-text-block { + position: relative; + margin: 0; +} + +.claudian-text-copy-btn { + position: absolute; + bottom: 0; + inset-inline-end: 0; + border: none; + color: var(--text-faint); + cursor: pointer; + opacity: 0; + transition: opacity 0.15s ease, color 0.15s ease; + z-index: 2; + display: flex; + align-items: center; + gap: 4px; +} + +.claudian-text-copy-btn svg { + width: 16px; + height: 16px; +} + +.claudian-text-block:hover .claudian-text-copy-btn { + opacity: 1; +} + +.claudian-text-copy-btn:hover { + color: var(--text-normal); +} + +.claudian-text-copy-btn.copied { + color: var(--text-accent); + font-size: 11px; + font-family: var(--font-monospace); +} + +.claudian-text-block+.claudian-tool-call { + margin-top: 8px; +} + +.claudian-tool-call+.claudian-text-block { + margin-top: 8px; +} + +.claudian-message-content p { + margin: 0 0 8px 0; +} + +.claudian-message-content p:last-child { + margin-bottom: 0; +} + +.claudian-message-content ul, +.claudian-message-content ol { + margin: 8px 0; + padding-inline-start: 20px; +} + +/* Full-width tables */ +.claudian-message-content table { + width: 100%; + border-collapse: collapse; + margin: 8px 0; +} + +.claudian-message-content th, +.claudian-message-content td { + border: 1px solid var(--background-modifier-border); + padding: 6px 10px; + text-align: start; +} + +.claudian-message-content th { + background: var(--background-secondary); + font-weight: 600; +} + +.claudian-message-content tr:hover { + background: var(--background-secondary-alt); +} + +.claudian-messages::-webkit-scrollbar { + width: 6px; +} + +.claudian-messages::-webkit-scrollbar-track { + background: transparent; +} + +.claudian-messages::-webkit-scrollbar-thumb { + background: var(--background-modifier-border); + border-radius: 3px; +} + +.claudian-messages::-webkit-scrollbar-thumb:hover { + background: var(--background-modifier-border-hover); +} + +/* Response duration footer - styled as another line of content */ +.claudian-response-footer { + margin-top: 8px; +} + +.claudian-baked-duration { + color: var(--text-muted); + font-size: 12px; + font-weight: 500; + font-style: italic; +} + +/* Action buttons toolbar below user messages */ +.claudian-user-msg-actions { + position: absolute; + bottom: -20px; + right: 0; + display: flex; + gap: 12px; + opacity: 0; + transition: opacity 0.15s; + z-index: 1; +} + +.claudian-message-user:hover .claudian-user-msg-actions { + opacity: 1; +} + +.claudian-user-msg-actions span { + cursor: pointer; + display: flex; + align-items: center; + justify-content: center; + color: var(--text-faint); + transition: color 0.15s; +} + +.claudian-user-msg-actions span svg { + width: 16px; + height: 16px; +} + +.claudian-user-msg-actions span:hover { + color: var(--text-normal); +} + +.claudian-user-msg-actions span.copied { + color: var(--text-accent); + font-size: 11px; + font-family: var(--font-monospace); +} + +/* Compact boundary indicator */ +.claudian-compact-boundary { + display: flex; + align-items: center; + gap: 10px; + margin: 12px 0; +} + +.claudian-compact-boundary::before, +.claudian-compact-boundary::after { + content: ''; + flex: 1; + height: 1px; + background: var(--background-modifier-border); +} + +.claudian-compact-boundary-label { + color: var(--text-muted); + font-size: 11px; + white-space: nowrap; +} + + +/* ============================================ + components/nav-sidebar.css + ============================================ */ +/* Navigation Sidebar */ +.claudian-nav-sidebar { + position: absolute; + right: 2px; + top: 50%; + transform: translateY(-50%); + display: flex; + flex-direction: column; + gap: 4px; + z-index: 100; + opacity: 0; + pointer-events: none; + transition: opacity 0.2s ease; +} + +.claudian-nav-sidebar.visible { + opacity: 0.15; + pointer-events: auto; +} + +.claudian-nav-sidebar.visible:hover { + opacity: 1; +} + +.claudian-nav-btn { + width: 32px; + height: 32px; + border-radius: 16px; + background: var(--background-primary); + border: 1px solid var(--background-modifier-border); + color: var(--text-muted); + display: flex; + align-items: center; + justify-content: center; + cursor: pointer; + box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1); + transition: all 0.2s ease; +} + +.claudian-nav-btn:hover { + background: var(--background-secondary); + color: var(--text-normal); + transform: scale(1.05); +} + +.claudian-nav-btn svg { + width: 18px; + height: 18px; +} + +/* Specific button spacing/grouping if needed */ +.claudian-nav-btn-top { + margin-bottom: 4px; +} + +.claudian-nav-btn-bottom { + margin-top: 4px; +} + + +/* ============================================ + components/code.css + ============================================ */ +/* Code block wrapper - contains pre + button outside scroll area */ +.claudian-code-wrapper { + position: relative; + margin: 8px 0; +} + +/* Code blocks in chat messages */ +.claudian-code-wrapper pre, +.claudian-message-content pre { + background: rgba(0, 0, 0, 0.2); + padding: 8px 12px; + border-radius: 6px; + overflow-x: auto; + margin: 0; +} + +/* Light mode: use a lighter background so hljs comment colors stay readable */ +body.theme-light .claudian-code-wrapper pre, +body.theme-light .claudian-message-content pre { + background: rgba(0, 0, 0, 0.08); +} + +/* Code blocks without language - wrap content */ +.claudian-code-wrapper:not(.has-language) pre { + white-space: pre-wrap; + word-wrap: break-word; + overflow-x: hidden; +} + +/* Unwrapped pre still needs margin */ +.claudian-message-content>pre { + margin: 8px 0; +} + +.claudian-message-content code { + font-family: var(--font-monospace); + font-size: 13px; +} + +/* Clickable language label - positioned outside scroll area */ +.claudian-code-wrapper .claudian-code-lang-label { + position: absolute; + top: 6px; + inset-inline-end: 6px; + padding: 2px 8px; + font-size: 12px; + font-family: var(--font-monospace); + color: var(--text-faint); + background: var(--background-primary); + border-radius: 3px; + cursor: pointer; + z-index: 2; + transition: color 0.15s ease, background 0.15s ease; +} + +.claudian-code-wrapper .claudian-code-lang-label:hover { + color: var(--text-normal); + background: var(--background-modifier-hover); +} + +/* Hide default copy button when language label exists */ +.claudian-code-wrapper.has-language .copy-code-button { + display: none; +} + +/* Copy button - positioned outside scroll area */ +.claudian-code-wrapper .copy-code-button { + position: absolute; + top: 6px; + inset-inline-end: 6px; + padding: 4px 8px; + font-size: 11px; + background: var(--background-primary); + border: none; + color: var(--text-muted); + cursor: pointer; + opacity: 0; + transition: opacity 0.15s ease, color 0.15s ease, background 0.15s ease; + border-radius: 3px; + z-index: 2; +} + +/* If copy button uses an icon (svg) */ +.claudian-code-wrapper .copy-code-button svg { + width: 14px; + height: 14px; +} + +/* Show copy button on hover */ +.claudian-code-wrapper:not(.has-language):hover .copy-code-button { + opacity: 1; +} + +.claudian-code-wrapper .copy-code-button:hover { + background: var(--background-modifier-hover); + color: var(--text-normal); +} + +/* ============================================ + components/thinking.css + ============================================ */ +.claudian-thinking { + color: var(--claudian-brand); + font-style: italic; + padding: 4px 0; + text-align: start; + animation: thinking-pulse 1.5s ease-in-out infinite; +} + +.claudian-thinking.claudian-thinking--compact { + color: var(--claudian-compact); +} + +.claudian-thinking-hint { + color: var(--text-muted); + font-style: normal; + font-variant-numeric: tabular-nums; +} + +.claudian-thinking-block { + margin: 8px 0; +} + +.claudian-text-block+.claudian-thinking-block { + margin-top: 8px; +} + +.claudian-thinking-block+.claudian-text-block { + margin-top: 8px; +} + +.claudian-thinking-block+.claudian-tool-call { + margin-top: 8px; +} + +.claudian-tool-call+.claudian-thinking-block { + margin-top: 8px; +} + +.claudian-thinking-header { + display: flex; + align-items: center; + gap: 8px; + padding: 4px 0; + cursor: pointer; + overflow: hidden; +} + +.claudian-thinking-label { + flex: 1; + font-size: 13px; + font-weight: 500; + color: var(--claudian-brand); +} + +/* Thinking block content - tree-branch style */ +.claudian-thinking-content { + padding: 4px 0; + padding-inline-start: 24px; + font-size: 13px; + line-height: 1.5; + color: var(--text-muted); + max-height: 400px; + overflow-y: auto; + border-inline-start: 2px solid var(--background-modifier-border); + margin-inline-start: 7px; +} + +.claudian-thinking-content p { + margin: 0 0 8px 0; +} + +.claudian-thinking-content p:last-child { + margin-bottom: 0; +} + +.claudian-thinking-content .claudian-code-wrapper { + margin: 8px 0; +} + +.claudian-thinking-content .claudian-code-wrapper pre { + padding: 8px 10px; + border-radius: 4px; +} + +.claudian-thinking-content code { + font-family: var(--font-monospace); + font-size: 12px; +} + + +/* ============================================ + components/toolcalls.css + ============================================ */ +.claudian-tool-call { + margin: 8px 0; +} + +.claudian-tool-header { + display: flex; + align-items: center; + gap: 8px; + padding: 4px 0; + cursor: pointer; + overflow: hidden; +} + +.claudian-tool-header:hover { + opacity: 0.85; +} + +.claudian-tool-icon { + display: flex; + align-items: center; + color: var(--text-accent); + flex-shrink: 0; +} + +.claudian-tool-icon svg { + width: 16px; + height: 16px; +} + +.claudian-tool-name { + font-family: var(--font-monospace); + font-size: 13px; + font-weight: 400; + color: var(--text-normal); + white-space: nowrap; + flex-shrink: 0; +} + +.claudian-tool-summary { + font-family: var(--font-monospace); + font-size: 13px; + color: var(--text-muted); + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; + flex: 1; + min-width: 0; +} + +.claudian-tool-summary:empty { + display: none; +} + +/* Legacy: StatusPanel bash entries still use claudian-tool-label */ +.claudian-tool-label { + font-family: var(--font-monospace); + font-size: 13px; + font-weight: 400; + color: var(--text-normal); + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; +} + +.claudian-tool-current { + font-family: var(--font-monospace); + font-size: 13px; + color: var(--text-muted); + white-space: nowrap; +} + +.claudian-tool-current:empty { + display: none; +} + +.claudian-tool-status { + display: flex; + align-items: center; + flex-shrink: 0; + margin-left: auto; +} + +.claudian-tool-status svg { + width: 14px; + height: 14px; +} + +.claudian-tool-status.status-running { + color: var(--text-accent); +} + +.claudian-tool-status.status-completed { + color: var(--color-green); +} + +.claudian-tool-status.status-error { + color: var(--color-red); +} + +.claudian-tool-status.status-blocked { + color: var(--color-orange); +} + +/* Tool call content - border style (like thinking block) */ +.claudian-tool-content { + padding: 4px 0; + padding-inline-start: 16px; + margin-inline-start: 7px; + border-inline-start: 2px solid var(--background-modifier-border); +} + +/* Tool content variants that render inline widgets instead of bordered results */ +.claudian-tool-content-todo, +.claudian-tool-content-ask { + border-inline-start: none; + margin-inline-start: 0; + padding-inline-start: 0; +} + +/* Expanded content: per-line rendering */ +.claudian-tool-lines { + font-family: var(--font-monospace); + font-size: 12px; + line-height: 1.4; + overflow-x: auto; +} + +.claudian-tool-line { + padding: 1px 0; + color: var(--text-muted); + white-space: pre; +} + +/* Hover highlight for file search results */ +.claudian-tool-line.hoverable:hover { + background: var(--background-modifier-hover); +} + +/* Truncation indicator: "... N more lines" */ +.claudian-tool-truncated { + color: var(--text-faint); + font-style: italic; + padding: 4px 0; + font-family: var(--font-monospace); + font-size: 12px; +} + +/* ToolSearch expanded: icon + tool name rows */ +.claudian-tool-search-item { + display: flex; + align-items: center; + gap: 4px; + padding: 2px 0; + font-family: var(--font-monospace); + font-size: 12px; + color: var(--text-muted); +} + +.claudian-tool-search-icon { + display: flex; + align-items: center; + flex-shrink: 0; + width: 14px; + height: 14px; + color: var(--text-faint); +} + +.claudian-tool-search-icon svg { + width: 14px; + height: 14px; +} + +/* Web search links */ +.claudian-tool-link { + display: flex; + align-items: flex-start; + gap: 6px; + padding: 3px 0; + color: var(--text-muted); + text-decoration: none; + cursor: pointer; + font-family: var(--font-monospace); + font-size: 12px; + line-height: 1.4; +} + +.claudian-tool-link:hover { + color: var(--text-accent); +} + +.claudian-tool-link-icon { + flex-shrink: 0; + width: 12px; + height: 12px; + margin-top: 2px; + color: var(--text-faint); +} + +.claudian-tool-link-icon svg { + width: 12px; + height: 12px; +} + +.claudian-tool-link-title { + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +/* Web search summary section */ +.claudian-tool-web-summary { + font-family: var(--font-monospace); + font-size: 12px; + color: var(--text-muted); + padding-top: 4px; + border-top: 1px solid var(--background-modifier-border); + margin-top: 4px; + white-space: pre-wrap; + word-break: break-word; + max-height: 200px; + overflow-y: auto; +} + +/* Empty state for file search */ +.claudian-tool-empty { + color: var(--text-faint); + font-style: italic; + font-family: var(--font-monospace); + font-size: 12px; + padding: 4px 0; +} + +.claudian-tool-result-row { + display: flex; + align-items: flex-start; +} + +.claudian-tool-result-text { + font-family: var(--font-monospace); + font-size: 12px; + color: var(--text-muted); + line-height: 1.4; + white-space: pre-wrap; + overflow: hidden; + flex: 1; +} + +.claudian-tool-result-item { + display: block; + margin-bottom: 2px; +} + +.claudian-tool-patch-section + .claudian-tool-patch-section { + margin-top: 10px; +} + +.claudian-tool-patch-header { + font-family: var(--font-monospace); + font-size: 12px; + color: var(--text-muted); + margin-bottom: 4px; +} + +.claudian-tool-result-item:last-child { + margin-bottom: 0; +} + + +/* ============================================ + components/status-panel.css + ============================================ */ +/* Status Panel - persistent bottom panel for todos and command output */ + +.claudian-status-panel-container { + flex-shrink: 0; + padding: 0 14px; +} + +.claudian-status-panel { + padding-top: 12px; +} + +/* Todo Section */ + +.claudian-status-panel-todos { + margin-top: 4px; +} + +.claudian-status-panel-header { + display: flex; + align-items: center; + gap: 8px; + padding: 4px 0; + cursor: pointer; + border-radius: 4px; + transition: background 0.15s ease; + overflow: hidden; +} + +.claudian-status-panel-header:hover { + background: var(--background-modifier-hover); +} + +.claudian-status-panel-header:focus-visible { + outline: 2px solid var(--interactive-accent); + outline-offset: 2px; +} + +.claudian-status-panel-icon { + display: flex; + align-items: center; + color: var(--text-accent); + flex-shrink: 0; +} + +.claudian-status-panel-icon svg { + width: 16px; + height: 16px; +} + +.claudian-status-panel-label { + font-family: var(--font-monospace); + font-size: 13px; + font-weight: 500; + color: var(--text-normal); +} + +.claudian-status-panel-current { + flex: 1; + font-family: var(--font-monospace); + font-size: 13px; + color: var(--text-muted); + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.claudian-status-panel-status { + display: flex; + align-items: center; + flex-shrink: 0; +} + +.claudian-status-panel-status svg { + width: 14px; + height: 14px; +} + +.claudian-status-panel-status.status-completed { + color: var(--color-green); +} + +.claudian-status-panel-content { + padding: 2px 0; +} + +/* Individual todo item - shared by status panel and inline tool via .claudian-todo-list-container */ +.claudian-todo-list-container .claudian-todo-item { + display: flex; + align-items: flex-start; + padding: 1px 0; +} + +.claudian-todo-list-container .claudian-todo-status-icon { + display: flex; + align-items: center; + flex-shrink: 0; +} + +.claudian-todo-list-container .claudian-todo-status-icon svg { + width: 12px; + height: 12px; +} + +.claudian-todo-list-container .claudian-todo-text { + font-family: var(--font-monospace); + font-size: 12px; + line-height: 1.4; + flex: 1; + padding-left: 12px; +} + +.claudian-todo-list-container .claudian-todo-pending .claudian-todo-status-icon { + color: var(--text-normal); +} + +.claudian-todo-list-container .claudian-todo-pending .claudian-todo-status-icon svg { + transform: scale(2); +} + +.claudian-todo-list-container .claudian-todo-pending .claudian-todo-text { + color: var(--text-normal); +} + +.claudian-todo-list-container .claudian-todo-in_progress .claudian-todo-status-icon { + color: var(--interactive-accent); +} + +.claudian-todo-list-container .claudian-todo-in_progress .claudian-todo-status-icon svg { + transform: scale(2); +} + +.claudian-todo-list-container .claudian-todo-in_progress .claudian-todo-text { + color: var(--text-normal); +} + +.claudian-todo-list-container .claudian-todo-completed .claudian-todo-status-icon { + color: var(--color-green); +} + +.claudian-todo-list-container .claudian-todo-completed .claudian-todo-text { + color: var(--text-muted); +} + +/* Bash Output Section */ + +.claudian-status-panel-bash { + margin-bottom: 4px; +} + +.claudian-status-panel-bash-header { + padding: 4px 0; +} + +.claudian-status-panel-bash-actions { + display: flex; + align-items: center; + gap: 6px; +} + +.claudian-status-panel-bash-action { + display: inline-flex; + align-items: center; + justify-content: center; + width: 22px; + height: 22px; + border-radius: 4px; + color: var(--text-muted); +} + +.claudian-status-panel-bash-action:hover { + background: var(--background-modifier-hover); + color: var(--text-normal); +} + +.claudian-status-panel-bash-content { + padding-top: 2px; + max-height: 320px; + max-height: min(40vh, 320px); + overflow-y: auto; + overscroll-behavior: contain; +} + +.claudian-status-panel-bash-entry { + margin: 4px 0; +} + +.claudian-status-panel-bash-entry .claudian-tool-icon svg { + width: 14px; + height: 14px; + position: relative; + top: -1px; +} + +.claudian-status-panel-bash-entry .claudian-tool-call { + margin: 0; +} + +/* Keep bash output blocks from growing without bound */ +.claudian-status-panel-bash-entry .claudian-tool-result-text { + max-height: 200px; + overflow-y: auto; + word-break: break-word; +} + + +/* ============================================ + components/subagent.css + ============================================ */ +.claudian-subagent-list { + margin: 8px 0; +} + +.claudian-text-block+.claudian-subagent-list { + margin-top: 8px; +} + +.claudian-subagent-list+.claudian-text-block { + margin-top: 8px; +} + +.claudian-tool-call+.claudian-subagent-list { + margin-top: 8px; +} + +.claudian-subagent-list+.claudian-tool-call { + margin-top: 8px; +} + +.claudian-subagent-header { + display: flex; + align-items: center; + gap: 8px; + padding: 4px 0; + cursor: pointer; + overflow: hidden; +} + +.claudian-subagent-icon { + display: flex; + align-items: center; + color: var(--interactive-accent); + flex-shrink: 0; +} + +.claudian-subagent-icon svg { + width: 16px; + height: 16px; +} + +.claudian-subagent-label { + flex: 1; + font-family: var(--font-monospace); + font-size: 13px; + font-weight: 400; + color: var(--text-normal); +} + +.claudian-subagent-count { + font-size: 11px; + color: var(--text-muted); + flex-shrink: 0; +} + +.claudian-subagent-status { + display: flex; + align-items: center; + flex-shrink: 0; +} + +.claudian-subagent-status svg { + width: 14px; + height: 14px; +} + +.claudian-subagent-status.status-running { + color: var(--text-accent); +} + +.claudian-subagent-status.status-completed { + color: var(--color-green); +} + +.claudian-subagent-status.status-error { + color: var(--color-red); +} + +.claudian-subagent-content { + padding: 4px 0; + padding-inline-start: 16px; + margin-inline-start: 7px; + border-inline-start: 2px solid var(--background-modifier-border); +} + +.claudian-subagent-section { + margin: 2px 0 6px; +} + +.claudian-subagent-section-header { + display: flex; + align-items: center; + gap: 6px; + cursor: pointer; + user-select: none; + font-family: var(--font-monospace); + font-size: 12px; + color: var(--text-muted); + padding: 2px 0; +} + +.claudian-subagent-section-header:hover { + color: var(--text-normal); +} + +.claudian-subagent-section-title { + flex: 1; + min-width: 0; +} + +.claudian-subagent-section-body { + padding-inline-start: 6px; +} + +.claudian-subagent-prompt-text, +.claudian-subagent-result-output { + font-family: var(--font-monospace); + font-size: 12px; + line-height: 1.4; + color: var(--text-muted); + white-space: pre-wrap; + word-break: break-word; +} + +.claudian-subagent-result-output { + max-height: 220px; + overflow-y: auto; +} + +.claudian-subagent-tools { + display: flex; + flex-direction: column; + gap: 4px; +} + +.claudian-subagent-tool-item { + display: block; +} + +.claudian-subagent-tool-header { + display: flex; + align-items: center; + gap: 6px; + cursor: pointer; + overflow: hidden; + padding: 2px 0; +} + +.claudian-subagent-tool-header:hover { + opacity: 0.85; +} + +.claudian-subagent-tool-icon { + display: flex; + align-items: center; + color: var(--text-accent); + flex-shrink: 0; +} + +.claudian-subagent-tool-icon svg { + width: 13px; + height: 13px; +} + +.claudian-subagent-tool-name { + font-family: var(--font-monospace); + font-size: 12px; + color: var(--text-normal); + white-space: nowrap; + flex-shrink: 0; +} + +.claudian-subagent-tool-summary { + font-family: var(--font-monospace); + font-size: 12px; + color: var(--text-muted); + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; + flex: 1; + min-width: 0; +} + +.claudian-subagent-tool-status { + display: flex; + align-items: center; + flex-shrink: 0; +} + +.claudian-subagent-tool-status svg { + width: 12px; + height: 12px; +} + +.claudian-subagent-tool-status.status-running { + color: var(--text-accent); +} + +.claudian-subagent-tool-status.status-completed { + color: var(--color-green); +} + +.claudian-subagent-tool-status.status-error, +.claudian-subagent-tool-status.status-blocked { + color: var(--color-red); +} + +.claudian-subagent-tool-content { + padding: 2px 0 2px 16px; +} + +.claudian-subagent-tool-empty { + color: var(--text-faint); + font-style: italic; + font-family: var(--font-monospace); + font-size: 12px; + padding: 2px 0; +} + +.claudian-subagent-status-text { + font-size: 11px; + font-family: var(--font-monospace); + color: var(--text-muted); + margin-inline-start: auto; + padding-inline-start: 8px; +} + +.claudian-subagent-list.async .claudian-subagent-icon { + color: var(--interactive-accent); +} + +.claudian-subagent-list.async.pending .claudian-subagent-status-text { + color: var(--text-muted); +} + +.claudian-subagent-list.async.running .claudian-subagent-status-text { + color: var(--text-accent); +} + +.claudian-subagent-list.async.awaiting .claudian-subagent-status-text { + color: var(--color-yellow); +} + +.claudian-subagent-list.async.completed .claudian-subagent-status-text { + color: var(--color-green); +} + +.claudian-subagent-list.async.error .claudian-subagent-status-text { + color: var(--color-red); +} + +.claudian-subagent-list.async.orphaned .claudian-subagent-status-text { + color: var(--color-orange); +} + + +/* ============================================ + components/input.css + ============================================ */ +/* Input area */ +.claudian-input-container { + position: relative; + padding: 12px 0 0 0; +} + +/* Input wrapper (border container) - flex column so textarea expands when no chips */ +/* Height calculation: context row (36px) + textarea min (60px) + toolbar (38px) + border (2px) = 136px */ +.claudian-input-wrapper { + position: relative; + display: flex; + flex-direction: column; + min-height: 140px; + border: 1px solid var(--background-modifier-border); + border-radius: 6px; + background: var(--background-primary); +} + +/* Context row (file chip start, selection indicator end) - inside input wrapper at top */ +/* Collapsed by default; expanded via .has-content class; textarea fills remaining space */ +.claudian-context-row { + display: none; + align-items: flex-start; + justify-content: flex-start; + flex-shrink: 0; + padding: 6px 10px 0 10px; + gap: 8px; +} + +/* Show context row when it has visible content */ +.claudian-context-row.has-content { + display: flex; +} + +/* Nav row (tab badges start, header icons end) - above input wrapper */ +.claudian-input-nav-row { + display: flex; + align-items: center; + justify-content: space-between; + padding: 0 0 8px 0; + min-height: 0; +} + +/* Header mode: hide nav row above input (content moved to header) */ +.claudian-container--header-mode .claudian-input-nav-row { + display: none; +} + +/* Selection indicator (shown when text is selected in editor) */ +/* Match file chip height (24px): chip has 16px remove button + 6px padding + 2px border */ +/* Indicator: 12px text + 10px padding (5+5) + 2px border = 24px */ +.claudian-selection-indicator, +.claudian-browser-selection-indicator, +.claudian-canvas-indicator { + color: #7abaff; + font-size: 12px; + line-height: 1; + opacity: 0.9; + pointer-events: none; + white-space: nowrap; + padding: 5px 6px; + border: 1px solid transparent; + border-radius: 4px; + margin-inline-start: auto; + flex-shrink: 0; + order: 4; + max-width: min(100%, clamp(220px, 64vw, 560px)); + overflow: hidden; + text-overflow: ellipsis; +} + +.claudian-input { + width: 100%; + flex: 1 1 0; + min-height: 60px; + /* max-height dynamically set by JS: max(150px, 55% of view height) */ + resize: none; + padding: 8px 10px 10px 10px; + border: none !important; + border-radius: 6px; + background: transparent !important; + color: var(--text-normal); + font-family: inherit; + font-size: 14px; + line-height: 1.4; + box-shadow: none !important; + overflow-y: auto; + unicode-bidi: plaintext; /* Proper BiDi text handling for mixed RTL/LTR */ +} + +.claudian-input:hover, +.claudian-input:focus { + outline: none !important; + border: none !important; + background: transparent !important; + box-shadow: none !important; +} + +.claudian-input::placeholder { + color: var(--text-muted); +} + +/* Input toolbar */ +.claudian-input-toolbar { + display: flex; + align-items: center; + justify-content: flex-start; + flex-shrink: 0; + padding: 4px 6px 6px 6px; +} + +/* File indicator (attached files) */ +.claudian-file-indicator { + display: none; + flex-wrap: wrap; + gap: 6px; +} + +.claudian-file-chip { + display: inline-flex; + align-items: center; + gap: 4px; + padding: 3px 6px 3px 8px; + background: var(--background-primary); + border: 1px solid var(--background-modifier-border); + border-radius: 12px; + font-size: 12px; + line-height: 1; + max-width: 200px; + cursor: pointer; +} + +.claudian-file-chip-icon { + display: flex; + align-items: center; + color: var(--text-muted); + flex-shrink: 0; +} + +.claudian-file-chip-icon svg { + width: 12px; + height: 12px; +} + +.claudian-file-chip-name { + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; + color: var(--text-normal); +} + +.claudian-file-chip-remove { + display: flex; + align-items: center; + justify-content: center; + width: 16px; + height: 16px; + border-radius: 50%; + cursor: pointer; + color: var(--text-muted); + font-size: 14px; + line-height: 1; + transition: background 0.15s ease, color 0.15s ease; +} + +.claudian-file-chip-remove:hover { + background: var(--background-modifier-hover); + color: var(--text-normal); +} + +.claudian-file-chip:hover { + background: var(--background-modifier-hover); +} + +/* Composer queue status row (queued follow-up preview + steer action) */ +.claudian-input-queue-row { + display: none; + font-size: 12px; + color: var(--text-muted); + font-style: normal; + align-items: center; + gap: 8px; + padding: 0 2px 8px 2px; +} + +.claudian-queue-indicator-text { + min-width: 0; + flex: 1 1 auto; + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; +} + +.claudian-queue-indicator-action { + flex: 0 0 auto; + padding: 1px 8px; + border: 0; + background: transparent; + color: var(--interactive-accent); + font: inherit; + cursor: pointer; +} + +.claudian-queue-indicator-action:hover { + text-decoration: underline; +} + +.claudian-queue-indicator-action[disabled] { + color: var(--text-faint); + cursor: default; + text-decoration: none; +} + +/* Light blue border when instruction mode is active */ +.claudian-input-instruction-mode { + border-color: #60a5fa !important; + box-shadow: 0 0 0 1px #60a5fa; +} + +/* Pink border when bash mode is active */ +.claudian-input-bang-bash-mode { + border-color: #f472b6 !important; + box-shadow: 0 0 0 1px #f472b6; +} + +/* Monospace input while in bash mode */ +.claudian-input-wrapper.claudian-input-bang-bash-mode .claudian-input { + font-family: var(--font-monospace); +} + + +/* ============================================ + components/context-footer.css + ============================================ */ +/* Context usage meter (inline in toolbar) */ + +.claudian-context-meter { + position: relative; + display: flex; + align-items: center; + gap: 4px; + margin-inline-start: 8px; + cursor: default; +} + +/* Custom tooltip */ +.claudian-context-meter::after { + content: attr(data-tooltip); + position: absolute; + bottom: 100%; + left: 50%; + transform: translateX(-50%); + margin-bottom: 6px; + padding: 4px 8px; + font-size: 11px; + color: var(--text-normal); + background: var(--background-secondary); + border: 1px solid var(--background-modifier-border); + border-radius: 4px; + white-space: nowrap; + opacity: 0; + visibility: hidden; + transition: opacity 0.15s ease, visibility 0.15s ease; + pointer-events: none; + z-index: 100; +} + +.claudian-context-meter:hover::after { + opacity: 1; + visibility: visible; +} + +.claudian-context-meter-gauge { + display: flex; + align-items: center; + justify-content: center; + width: 24px; + height: 24px; +} + +.claudian-context-meter-gauge svg { + width: 16px; + height: 16px; +} + +.claudian-meter-bg { + stroke: var(--background-modifier-border); +} + +.claudian-meter-fill { + stroke: var(--claudian-brand); + transition: stroke-dashoffset 0.3s ease, stroke 0.3s ease; +} + +.claudian-context-meter-percent { + font-size: 11px; + color: var(--claudian-brand); + min-width: 24px; + text-align: end; + transition: color 0.3s ease; +} + +/* Warning state (> 80%) - pale red */ +.claudian-context-meter.warning .claudian-meter-fill { + stroke: #E57373; +} + +.claudian-context-meter.warning .claudian-context-meter-percent { + color: #E57373; +} + + +/* ============================================ + toolbar/model-selector.css + ============================================ */ +/* Model selector */ +.claudian-model-selector { + position: relative; +} + +.claudian-model-btn { + display: flex; + align-items: center; + gap: 4px; + padding: 4px 8px; + border-radius: 4px; + cursor: pointer; + color: var(--claudian-brand); + font-size: 12px; +} + +.claudian-model-label { + font-weight: 500; +} + +.claudian-model-chevron { + display: flex; + align-items: center; +} + +.claudian-model-chevron svg { + width: 12px; + height: 12px; +} + +.claudian-model-dropdown { + position: absolute; + bottom: 100%; + left: 0; + margin-bottom: 0; + display: flex; + flex-direction: column; + gap: 2px; + background: var(--background-secondary); + border: 1px solid var(--background-modifier-border); + border-radius: 4px; + box-shadow: 0 -2px 8px rgba(0, 0, 0, 0.15); + z-index: 1000; + width: max-content; + padding: 4px; + opacity: 0; + visibility: hidden; + transition: opacity 0.15s ease, visibility 0.15s ease; +} + +.claudian-model-selector:hover .claudian-model-dropdown { + opacity: 1; + visibility: visible; +} + +.claudian-model-group { + padding: 3px 8px; + font-size: 8px; + font-weight: 600; + color: var(--text-faint); + text-transform: uppercase; + letter-spacing: 0.05em; + pointer-events: none; +} + +.claudian-model-group:not(:first-child) { + margin-top: 4px; + border-top: 1px solid var(--background-modifier-border); + padding-top: 6px; +} + +.claudian-model-provider-icon { + flex-shrink: 0; + opacity: 0.7; +} + +.claudian-model-option { + display: flex; + align-items: center; + gap: 5px; + padding: 4px 8px; + cursor: pointer; + font-size: 12px; + color: var(--text-muted); + border-radius: 3px; + transition: background 0.1s ease, color 0.1s ease; + white-space: nowrap; +} + +.claudian-model-option:hover { + background: var(--background-modifier-hover); + color: var(--text-normal); +} + +.claudian-model-option.selected { + background: rgba(var(--claudian-brand-rgb), 0.15); + color: var(--claudian-brand); + font-weight: 500; +} + + +/* ============================================ + toolbar/thinking-selector.css + ============================================ */ +/* Thinking selector (effort for adaptive models, token budget for custom) */ +.claudian-thinking-selector { + display: flex; + align-items: center; + gap: 6px; +} + +/* Effort / budget container (shared layout) */ +.claudian-thinking-effort, +.claudian-thinking-budget { + display: flex; + align-items: center; + gap: 6px; +} + +.claudian-thinking-label-text { + font-size: 11px; + color: var(--text-muted); +} + +.claudian-thinking-gears { + position: relative; + display: flex; + align-items: center; + border-radius: 4px; +} + +/* Current selection (visible when collapsed) */ +.claudian-thinking-current { + padding: 3px 8px; + font-size: 11px; + color: var(--claudian-brand); + font-weight: 500; + cursor: pointer; + border-radius: 3px; + white-space: nowrap; + background: transparent; +} + +/* Options container - expands vertically upward */ +.claudian-thinking-options { + position: absolute; + left: 0; + bottom: 100%; + margin-bottom: 0; + display: flex; + flex-direction: column; + gap: 2px; + background: var(--background-secondary); + border: 1px solid var(--background-modifier-border); + border-radius: 4px; + padding: 4px; + opacity: 0; + visibility: hidden; + transition: opacity 0.15s ease, visibility 0.15s ease; +} + +/* Expand on hover */ +.claudian-thinking-gears:hover .claudian-thinking-options { + opacity: 1; + visibility: visible; +} + +.claudian-thinking-gear { + padding: 3px 8px; + font-size: 11px; + color: var(--text-muted); + cursor: pointer; + border-radius: 3px; + transition: background 0.1s ease, color 0.1s ease; + white-space: nowrap; +} + +.claudian-thinking-gear:hover { + background: var(--background-modifier-hover); + color: var(--text-normal); +} + +.claudian-thinking-gear.selected { + background: rgba(var(--claudian-brand-rgb), 0.15); + color: var(--claudian-brand); + font-weight: 500; +} + + +/* ============================================ + toolbar/permission-toggle.css + ============================================ */ +/* Permission Mode Toggle */ +.claudian-permission-toggle { + display: flex; + align-items: center; + gap: 6px; + margin-left: auto; + padding-left: 12px; + padding-right: 8px; +} + +.claudian-permission-label { + font-size: 11px; + color: var(--text-muted); + min-width: 28px; +} + +.claudian-permission-label.plan-active { + color: rgb(92, 148, 140); + font-weight: 600; +} + +.claudian-toggle-switch { + width: 32px; + height: 18px; + border-radius: 9px; + background: var(--background-modifier-border); + cursor: pointer; + position: relative; + transition: background 0.2s ease; + flex-shrink: 0; +} + +.claudian-toggle-switch::after { + content: ''; + position: absolute; + width: 14px; + height: 14px; + border-radius: 50%; + background: var(--text-muted); + top: 2px; + left: 2px; + transition: transform 0.2s ease, background 0.2s ease; +} + +.claudian-toggle-switch:hover { + background: var(--background-modifier-hover); +} + +.claudian-toggle-switch.active { + background: rgba(var(--claudian-brand-rgb), 0.3); +} + +.claudian-toggle-switch.active::after { + transform: translateX(14px); + background: var(--claudian-brand); +} + + +/* ============================================ + toolbar/service-tier-toggle.css + ============================================ */ +/* Codex fast-mode / service-tier toggle */ +.claudian-service-tier-toggle { + display: flex; + align-items: center; + padding-left: 2px; +} + +.claudian-service-tier-button { + display: inline-flex; + align-items: center; + justify-content: center; + width: 22px; + height: 22px; + border-radius: 4px; + color: var(--text-muted); + background: transparent; + cursor: pointer; + transition: color 0.15s ease, background 0.15s ease; + flex-shrink: 0; +} + +.claudian-service-tier-icon { + display: inline-flex; + align-items: center; + justify-content: center; +} + +.claudian-service-tier-icon svg { + width: 14px; + height: 14px; +} + +.claudian-service-tier-button:hover { + background: var(--background-modifier-hover); +} + +.claudian-service-tier-button.active { + color: var(--claudian-brand); +} + + +/* ============================================ + toolbar/external-context.css + ============================================ */ +/* External Context Selector */ +.claudian-external-context-selector { + position: relative; + display: flex; + align-items: center; + margin-left: 8px; +} + +.claudian-external-context-icon-wrapper { + position: relative; + display: flex; + align-items: center; + justify-content: center; + cursor: pointer; +} + +.claudian-external-context-icon { + display: flex; + align-items: center; + justify-content: center; + width: 24px; + height: 24px; + color: var(--text-faint); + transition: color 0.15s ease; +} + +.claudian-external-context-icon-wrapper:hover .claudian-external-context-icon { + color: var(--text-normal); +} + +.claudian-external-context-icon.active { + color: var(--claudian-brand); + animation: external-context-glow 2s ease-in-out infinite; +} + +.claudian-external-context-icon svg { + width: 16px; + height: 16px; +} + +.claudian-external-context-badge { + position: absolute; + top: 0; + right: 0; + font-size: 9px; + font-weight: 600; + color: var(--claudian-brand); + opacity: 0; + transition: opacity 0.15s ease; + pointer-events: none; +} + +.claudian-external-context-badge.visible { + opacity: 1; +} + +.claudian-external-context-dropdown { + position: absolute; + left: 50%; + transform: translateX(-50%); + bottom: 100%; + margin-bottom: 4px; + min-width: 260px; + max-width: 320px; + background: var(--background-secondary); + border: 1px solid var(--background-modifier-border); + border-radius: 8px; + box-shadow: 0 4px 16px rgba(0, 0, 0, 0.25); + opacity: 0; + visibility: hidden; + transition: opacity 0.15s ease, visibility 0.15s ease; + z-index: 100; +} + +.claudian-external-context-selector:hover .claudian-external-context-dropdown { + opacity: 1; + visibility: visible; +} + +.claudian-external-context-header { + padding: 10px 12px; + font-size: 12px; + font-weight: 600; + color: var(--text-muted); + border-bottom: 1px solid var(--background-modifier-border); +} + +.claudian-external-context-list { + max-height: 200px; + overflow-y: auto; +} + +.claudian-external-context-empty { + padding: 16px 12px; + text-align: center; + color: var(--text-muted); + font-size: 12px; + font-style: italic; +} + +.claudian-external-context-item { + display: flex; + align-items: center; + padding: 8px 12px; + gap: 8px; + border-bottom: 1px solid var(--background-modifier-border-focus); +} + +.claudian-external-context-item:last-child { + border-bottom: none; +} + +.claudian-external-context-text { + flex: 1; + font-size: 12px; + font-family: var(--font-monospace); + color: var(--text-normal); + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.claudian-external-context-lock { + display: flex; + align-items: center; + justify-content: center; + width: 20px; + height: 20px; + border-radius: 4px; + cursor: pointer; + color: var(--text-muted); + opacity: 0.4; + transition: all 0.15s ease; +} + +.claudian-external-context-lock:hover { + background: var(--background-modifier-hover); + opacity: 0.8; +} + +.claudian-external-context-lock.locked { + color: var(--claudian-brand); + opacity: 0.9; +} + +.claudian-external-context-lock.locked:hover { + opacity: 1; +} + +.claudian-external-context-lock svg { + width: 12px; + height: 12px; +} + +.claudian-external-context-remove { + display: flex; + align-items: center; + justify-content: center; + width: 20px; + height: 20px; + border-radius: 4px; + cursor: pointer; + color: var(--text-muted); + opacity: 0.6; + transition: all 0.15s ease; +} + +.claudian-external-context-remove:hover { + background: rgba(var(--claudian-error-rgb), 0.15); + color: var(--claudian-error); + opacity: 1; +} + +.claudian-external-context-remove svg { + width: 14px; + height: 14px; +} + + +/* ============================================ + toolbar/mcp-selector.css + ============================================ */ +/* MCP Server Selector */ +.claudian-mcp-selector { + position: relative; + display: flex; + align-items: center; + margin-left: 8px; +} + +.claudian-mcp-selector-icon-wrapper { + position: relative; + display: flex; + align-items: center; + justify-content: center; + cursor: pointer; +} + +.claudian-mcp-selector-icon { + display: flex; + align-items: center; + justify-content: center; + width: 24px; + height: 24px; + color: var(--text-faint); + transition: color 0.15s ease; +} + +.claudian-mcp-selector-icon-wrapper:hover .claudian-mcp-selector-icon { + color: var(--text-normal); +} + +.claudian-mcp-selector-icon.active { + color: var(--claudian-brand); + animation: mcp-glow 2s ease-in-out infinite; +} + +.claudian-mcp-selector-icon svg { + width: 16px; + height: 16px; +} + +.claudian-mcp-selector-badge { + position: absolute; + top: 0; + right: 0; + font-size: 9px; + font-weight: 600; + color: var(--claudian-brand); + opacity: 0; + transition: opacity 0.15s ease; + pointer-events: none; +} + +.claudian-mcp-selector-badge.visible { + opacity: 1; +} + +.claudian-mcp-selector-dropdown { + position: absolute; + left: 50%; + transform: translateX(-50%); + bottom: 100%; + margin-bottom: 4px; + min-width: 200px; + max-width: 280px; + background: var(--background-secondary); + border: 1px solid var(--background-modifier-border); + border-radius: 8px; + box-shadow: 0 4px 16px rgba(0, 0, 0, 0.25); + opacity: 0; + visibility: hidden; + transition: opacity 0.15s ease, visibility 0.15s ease; + z-index: 100; +} + +/* Bridge the gap between icon and dropdown to prevent hover breaks */ +.claudian-mcp-selector-dropdown::after { + content: ''; + position: absolute; + left: 0; + right: 0; + bottom: -8px; + height: 8px; +} + +.claudian-mcp-selector-dropdown.visible, +.claudian-mcp-selector:hover .claudian-mcp-selector-dropdown { + opacity: 1; + visibility: visible; +} + +.claudian-mcp-selector-header { + padding: 10px 12px; + font-size: 12px; + font-weight: 600; + color: var(--text-muted); + border-bottom: 1px solid var(--background-modifier-border); +} + +.claudian-mcp-selector-list { + max-height: 200px; + overflow-y: auto; +} + +.claudian-mcp-selector-empty { + padding: 16px 12px; + text-align: center; + color: var(--text-muted); + font-size: 12px; + font-style: italic; +} + +.claudian-mcp-selector-item { + display: flex; + align-items: center; + padding: 8px 12px; + gap: 8px; + cursor: pointer; + transition: background 0.15s ease; +} + +.claudian-mcp-selector-item:hover { + background: var(--background-modifier-hover); +} + +.claudian-mcp-selector-item.enabled { + background: rgba(var(--claudian-brand-rgb), 0.1); +} + +.claudian-mcp-selector-check { + display: flex; + align-items: center; + justify-content: center; + width: 16px; + height: 16px; + border: 1px solid var(--background-modifier-border); + border-radius: 3px; + color: var(--claudian-brand); +} + +.claudian-mcp-selector-item.enabled .claudian-mcp-selector-check { + background: rgba(var(--claudian-brand-rgb), 0.2); + border-color: var(--claudian-brand); +} + +.claudian-mcp-selector-check svg { + width: 12px; + height: 12px; +} + +.claudian-mcp-selector-item-info { + display: flex; + align-items: center; + justify-content: space-between; + gap: 6px; + flex: 1; + overflow: hidden; +} + +.claudian-mcp-selector-item-name { + font-size: 12px; + color: var(--text-normal); + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.claudian-mcp-selector-cs-badge { + font-size: 10px; + font-weight: 600; + padding: 1px 4px; + border-radius: 3px; + background: rgba(var(--claudian-brand-rgb), 0.2); + color: var(--claudian-brand); + flex-shrink: 0; + margin-left: auto; +} + + +/* ============================================ + features/file-context.css + ============================================ */ +/* @ Mention dropdown */ +.claudian-mention-dropdown { + display: none; + position: absolute; + bottom: 100%; + left: 0; + right: 0; + margin-bottom: 4px; + background: var(--background-secondary); + backdrop-filter: blur(20px); + -webkit-backdrop-filter: blur(20px); + border: 1px solid var(--background-modifier-border); + border-radius: 6px; + box-shadow: 0 -4px 16px rgba(0, 0, 0, 0.2); + z-index: 1000; + max-height: 250px; + overflow-y: auto; +} + +.claudian-mention-dropdown.visible { + display: block; +} + +/* Fixed positioning for inline editor */ +.claudian-mention-dropdown-fixed { + position: fixed; + z-index: 10001; +} + +.claudian-mention-item { + display: flex; + align-items: center; + gap: 8px; + padding: 8px 12px; + cursor: pointer; + transition: background 0.1s ease; +} + +.claudian-mention-item:hover, +.claudian-mention-item.selected { + background: var(--background-modifier-hover); +} + +.claudian-mention-icon { + display: flex; + align-items: center; + color: var(--text-muted); + flex-shrink: 0; +} + +.claudian-mention-icon svg { + width: 14px; + height: 14px; +} + +.claudian-mention-path { + font-size: 13px; + color: var(--text-normal); + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.claudian-mention-empty { + padding: 12px; + text-align: center; + color: var(--text-muted); + font-size: 13px; +} + +/* Scrollbar for mention dropdown */ +.claudian-mention-dropdown::-webkit-scrollbar { + width: 6px; +} + +.claudian-mention-dropdown::-webkit-scrollbar-track { + background: transparent; +} + +.claudian-mention-dropdown::-webkit-scrollbar-thumb { + background: var(--background-modifier-border); + border-radius: 3px; +} + +/* MCP items in @-mention dropdown */ +.claudian-mention-item.mcp-server .claudian-mention-icon { + color: var(--interactive-accent); +} + +.claudian-mention-item.vault-folder .claudian-mention-icon { + color: var(--text-muted); +} + +.claudian-mention-text { + display: flex; + flex-direction: column; + gap: 2px; + min-width: 0; + flex: 1; +} + +.claudian-mention-name { + font-size: 13px; + font-weight: 500; + color: var(--interactive-accent); +} + +.claudian-mention-desc { + font-size: 11px; + color: var(--text-muted); + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +/* Context file items in @-mention dropdown */ +.claudian-mention-item.context-file .claudian-mention-icon { + color: var(--claudian-brand); +} + +.claudian-mention-item.context-file .claudian-mention-text { + flex-direction: row; + overflow: hidden; + white-space: nowrap; +} + +.claudian-mention-item.context-file .claudian-mention-name-context { + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; + min-width: 0; +} + +/* Context folder filter items in @-mention dropdown */ +.claudian-mention-item.context-folder .claudian-mention-icon { + color: var(--text-muted); +} + +.claudian-mention-name-folder { + color: var(--text-normal); + font-weight: 500; +} + +.claudian-mention-name-context { + color: var(--text-normal); +} + +/* Agent folder items in @-mention dropdown */ +.claudian-mention-item.agent-folder .claudian-mention-icon { + color: var(--link-color); +} + +.claudian-mention-name-agent-folder { + color: var(--link-color); + font-weight: 600; +} + +/* Agent items in @-mention dropdown (inside @Agents/) */ +.claudian-mention-item.agent .claudian-mention-icon { + color: var(--link-color); +} + +.claudian-mention-item.agent .claudian-mention-text { + flex-direction: row; + align-items: baseline; + gap: 6px; + overflow: hidden; + white-space: nowrap; +} + +.claudian-mention-item.agent .claudian-mention-name-agent { + color: var(--text-normal); + font-size: 13px; + flex-shrink: 0; +} + +.claudian-mention-item.agent .claudian-mention-agent-desc { + font-size: 11px; + color: var(--text-muted); + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; + min-width: 0; +} + + +/* ============================================ + features/file-link.css + ============================================ */ +/* Clickable file links that open files in Obsidian */ +.claudian-file-link { + color: var(--text-accent); + text-decoration: none; + cursor: pointer; + border-radius: 3px; + transition: color 0.15s ease; +} + +.claudian-file-link:hover { + color: var(--text-accent-hover); + text-decoration: underline; +} + +/* File link inside inline code */ +code .claudian-file-link { + color: var(--text-accent); +} + +code .claudian-file-link:hover { + color: var(--text-accent-hover); +} + + +/* ============================================ + features/image-context.css + ============================================ */ +/* Image Context - Preview & Attachments */ + +/* Image preview container (in input area) */ +.claudian-image-preview { + display: none; + flex-wrap: wrap; + gap: 8px; + padding: 8px 0; + margin-bottom: 4px; +} + +/* Individual image preview chip */ +.claudian-image-chip { + display: flex; + align-items: center; + gap: 8px; + padding: 6px 8px; + background: var(--background-primary); + border: 1px solid var(--background-modifier-border); + border-radius: 8px; + max-width: 200px; +} + +.claudian-image-chip:hover { + border-color: var(--interactive-accent); +} + +/* Image thumbnail */ +.claudian-image-thumb { + width: 40px; + height: 40px; + border-radius: 4px; + overflow: hidden; + flex-shrink: 0; + cursor: pointer; +} + +.claudian-image-thumb img { + width: 100%; + height: 100%; + object-fit: cover; +} + +/* Image info */ +.claudian-image-info { + display: flex; + flex-direction: column; + min-width: 0; + flex: 1; +} + +.claudian-image-name { + font-size: 12px; + color: var(--text-normal); + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.claudian-image-size { + font-size: 10px; + color: var(--text-muted); +} + +/* Remove button */ +.claudian-image-remove { + position: relative; + width: 20px; + height: 20px; + border-radius: 50%; + cursor: pointer; + transition: background 0.15s ease; + flex-shrink: 0; + font-size: 0; /* Hide text character */ +} + +.claudian-image-remove::before, +.claudian-image-remove::after { + content: ''; + position: absolute; + top: 50%; + left: 50%; + width: 10px; + height: 2px; + background: var(--text-muted); + border-radius: 1px; + transition: background 0.15s ease; +} + +.claudian-image-remove::before { + transform: translate(-50%, -50%) rotate(45deg); +} + +.claudian-image-remove::after { + transform: translate(-50%, -50%) rotate(-45deg); +} + +.claudian-image-remove:hover { + background: var(--background-modifier-error); +} + +.claudian-image-remove:hover::before, +.claudian-image-remove:hover::after { + background: var(--text-on-accent); +} + +/* Drop overlay - inside input wrapper */ +.claudian-drop-overlay { + position: absolute; + top: 0; + left: 0; + right: 0; + bottom: 0; + background: rgba(var(--claudian-brand-rgb), 0.08); + border: 2px dashed var(--claudian-brand); + border-radius: 6px; + display: none; + align-items: center; + justify-content: center; + z-index: 100; + pointer-events: none; +} + +.claudian-drop-overlay.visible { + display: flex; +} + +.claudian-drop-content { + display: flex; + flex-direction: column; + align-items: center; + gap: 4px; + color: var(--claudian-brand); +} + +.claudian-drop-content svg { + opacity: 0.7; +} + +.claudian-drop-content span { + font-size: 12px; + font-weight: 500; +} + +/* Images in Messages (displayed above user bubble) */ + +/* Images container - right-aligned above user message */ +.claudian-message-images { + display: flex; + flex-wrap: wrap; + gap: 6px; + justify-content: flex-end; + margin-bottom: 6px; + padding-right: 4px; +} + +/* Individual image in message - standardized size */ +.claudian-message-image { + width: 120px; + height: 120px; + border-radius: 8px; + overflow: hidden; + cursor: pointer; + transition: transform 0.15s ease, box-shadow 0.15s ease; + background: var(--background-secondary); + border: 1px solid var(--background-modifier-border); +} + +.claudian-message-image:hover { + transform: scale(1.03); + box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15); +} + +.claudian-message-image img { + width: 100%; + height: 100%; + object-fit: cover; + display: block; +} + + +/* ============================================ + features/image-embed.css + ============================================ */ +/* Image embed styles - displays ![[image.png]] wikilinks as actual images */ + +.claudian-embedded-image { + display: inline-block; + max-width: 100%; + margin: 0.5em 0; + vertical-align: middle; +} + +.claudian-embedded-image img { + max-width: 100%; + height: auto; + border-radius: var(--radius-s); + cursor: pointer; + transition: opacity 0.2s ease; +} + +.claudian-embedded-image img:hover { + opacity: 0.9; +} + +/* When image is inline with text */ +.claudian-text-block p .claudian-embedded-image { + margin: 0.25em 0; +} + +/* Block-level image (standalone on its own line) */ +.claudian-text-block p > .claudian-embedded-image:only-child { + display: block; + margin: 0.75em 0; +} + +/* Fallback when image file not found */ +.claudian-embedded-image-fallback { + color: var(--text-muted); + font-style: italic; + background: var(--background-modifier-hover); + padding: 0.1em 0.4em; + border-radius: var(--radius-s); +} + + +/* ============================================ + features/image-modal.css + ============================================ */ +/* Full-size Image Modal */ +.claudian-image-modal-overlay { + position: fixed; + top: 0; + left: 0; + right: 0; + bottom: 0; + background: rgba(0, 0, 0, 0.85); + display: flex; + align-items: center; + justify-content: center; + z-index: 10000; + cursor: pointer; +} + +.claudian-image-modal { + position: relative; + max-width: 90vw; + max-height: 90vh; + cursor: default; +} + +.claudian-image-modal img { + max-width: 90vw; + max-height: 90vh; + object-fit: contain; + border-radius: 8px; + box-shadow: 0 8px 32px rgba(0, 0, 0, 0.5); +} + +.claudian-image-modal-close { + position: absolute; + top: -12px; + right: -12px; + width: 32px; + height: 32px; + display: flex; + align-items: center; + justify-content: center; + background: var(--background-secondary); + border-radius: 50%; + cursor: pointer; + font-size: 20px; + color: var(--text-muted); + box-shadow: 0 2px 8px rgba(0, 0, 0, 0.3); + transition: background 0.15s ease, color 0.15s ease; +} + +.claudian-image-modal-close:hover { + background: var(--background-modifier-error); + color: var(--text-on-accent); +} + + +/* ============================================ + features/inline-edit.css + ============================================ */ +/* Inline Edit (CM6 decorations) */ + +/* Selection highlight (shared by inline edit and chat) */ +.cm-line .claudian-selection-highlight, +.claudian-selection-highlight { + background: var(--text-selection) !important; + border-radius: 2px; + padding: 3px 0; + margin: -3px 0; +} + +/* Preview mode selection highlight via CSS Custom Highlight API */ +::highlight(claudian-selection) { + background: var(--text-selection); +} + +/* CM6 widget container - ensure transparent background */ +.cm-widgetBuffer, +.cm-line:has(.claudian-inline-input-container) { + background: transparent !important; +} + +/* Input container - fully transparent */ +.claudian-inline-input-container { + display: flex; + flex-direction: column; + gap: 0; + padding: 2px 0; + background: transparent !important; +} + +/* Input wrapper - contains input and spinner */ +.claudian-inline-input-wrap { + flex: 1; + position: relative; + background: transparent !important; + overflow: visible; +} + +/* Input - fully transparent */ +.claudian-inline-input { + width: 100%; + padding: 4px 8px; + padding-inline-end: 30px; + border-width: 1px !important; + border-style: solid !important; + border-color: var(--background-modifier-border) !important; + border-radius: 8px !important; + background: transparent !important; + color: var(--text-normal); + font-family: var(--font-interface, -apple-system, BlinkMacSystemFont, sans-serif) !important; + font-size: var(--font-ui-small, 13px) !important; +} + +.claudian-inline-input:focus, +.claudian-inline-input:focus-visible { + outline: none !important; + box-shadow: none !important; +} + +.claudian-inline-input::placeholder { + color: var(--text-faint); +} + +.claudian-inline-input:disabled { + opacity: 0.6; +} + +/* Spinner - inside input box on end side */ +.claudian-inline-spinner { + position: absolute; + inset-inline-end: 8px; + top: 50%; + width: 14px; + height: 14px; + margin-top: -7px; + border: 2px solid var(--background-modifier-border); + border-top-color: var(--claudian-brand); + border-radius: 50%; + box-sizing: border-box; + animation: claudian-spin 0.8s linear infinite; +} + +/* Agent reply - shown when agent asks clarifying question */ +.claudian-inline-agent-reply { + padding: 8px; + margin-bottom: 4px; + background: transparent; + border-width: 1px; + border-style: solid; + border-color: var(--background-modifier-border); + border-radius: 8px; + font-family: var(--font-interface, -apple-system, BlinkMacSystemFont, sans-serif); + font-size: var(--font-ui-small, 13px); + line-height: 1.4; + color: var(--text-muted); + white-space: pre-wrap; + word-wrap: break-word; +} + +/* Inline Diff - replaces selection in place */ +.claudian-inline-diff-replace { + /* Inherit all font properties from document */ + font-size: inherit; + font-family: inherit; + line-height: inherit; + font-weight: inherit; +} + +/* Deleted text - red strikethrough */ +.claudian-diff-del { + background: rgba(255, 80, 80, 0.2); + text-decoration: line-through; + color: var(--text-muted); +} + +/* Inserted text - green background */ +.claudian-diff-ins { + background: rgba(80, 200, 80, 0.2); +} + +/* Accept/Reject buttons inline with diff */ +.claudian-inline-diff-buttons { + display: inline-flex; + gap: 8px; + margin-inline-start: 6px; + background: none !important; +} + +.claudian-inline-diff-btn { + padding: 4px 6px; + border: none !important; + background: none !important; + box-shadow: none !important; + outline: none !important; + font-size: 16px; + cursor: pointer; +} + +.claudian-inline-diff-btn.reject { + color: var(--color-red); +} + +.claudian-inline-diff-btn.accept { + color: var(--color-green); +} + + +/* ============================================ + features/diff.css + ============================================ */ +/* Write/Edit Diff Block - Subagent style */ +.claudian-write-edit-block { + margin: 4px 0; + background: transparent; + overflow: hidden; +} + +.claudian-text-block+.claudian-write-edit-block { + margin-top: 8px; +} + +.claudian-write-edit-block+.claudian-text-block { + margin-top: 8px; +} + +.claudian-write-edit-header { + display: flex; + align-items: center; + gap: 8px; + padding: 4px 0; + cursor: pointer; + user-select: none; + background: transparent; + overflow: hidden; +} + +.claudian-write-edit-icon { + width: 16px; + height: 16px; + color: var(--text-accent); + flex-shrink: 0; +} + +.claudian-write-edit-icon svg { + width: 16px; + height: 16px; +} + +/* Two-part header: name (fixed) + summary (flexible) */ +.claudian-write-edit-name { + font-family: var(--font-monospace); + font-size: 13px; + font-weight: 400; + color: var(--text-normal); + white-space: nowrap; + flex-shrink: 0; +} + +.claudian-write-edit-summary { + font-family: var(--font-monospace); + font-size: 13px; + color: var(--text-muted); + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; + flex: 1; + min-width: 0; +} + +.claudian-write-edit-stats { + font-family: var(--font-monospace); + font-size: 11px; + flex-shrink: 0; +} + +.claudian-write-edit-stats .added { + color: var(--color-green); +} + +.claudian-write-edit-stats .removed { + color: var(--color-red); + margin-left: 4px; +} + +.claudian-write-edit-status { + width: 16px; + height: 16px; + flex-shrink: 0; +} + +/* Hide empty status on successful completion so stats align to right edge */ +.claudian-write-edit-block.done .claudian-write-edit-status:empty { + display: none; +} + +.claudian-write-edit-status svg { + width: 16px; + height: 16px; +} + +.claudian-write-edit-status.status-completed { + color: var(--color-green); +} + +.claudian-write-edit-status.status-error, +.claudian-write-edit-status.status-blocked { + color: var(--color-red); +} + +.claudian-write-edit-content { + padding: 0; + background: transparent; + overflow: hidden; +} + +.claudian-write-edit-diff-row { + display: flex; +} + +.claudian-write-edit-diff { + flex: 1; + font-family: var(--font-monospace); + font-size: 12px; + line-height: 1.5; + background: transparent; + max-height: 300px; + overflow-y: auto; + overflow-x: auto; +} + +.claudian-write-edit-loading, +.claudian-write-edit-binary, +.claudian-write-edit-error, +.claudian-write-edit-done-text { + font-family: var(--font-monospace); + font-size: 12px; + color: var(--text-muted); +} + +.claudian-write-edit-error { + color: var(--color-red); +} + +/* Diff line styling */ +.claudian-diff-hunk { + margin-bottom: 4px; +} + +.claudian-diff-line { + display: flex; + white-space: pre-wrap; + word-break: break-all; +} + +.claudian-diff-prefix { + flex-shrink: 0; + width: 16px; + text-align: center; + color: var(--text-muted); + user-select: none; +} + +.claudian-diff-text { + flex: 1; + min-width: 0; +} + +/* Diff colors - NO strikethrough for Write/Edit blocks */ +.claudian-diff-equal { + color: var(--text-muted); +} + +.claudian-diff-delete { + background: rgba(255, 80, 80, 0.25); + color: var(--text-normal); +} + +.claudian-diff-delete .claudian-diff-prefix { + color: var(--color-red); +} + +.claudian-diff-insert { + background: rgba(80, 200, 80, 0.25); + color: var(--text-normal); +} + +.claudian-diff-insert .claudian-diff-prefix { + color: var(--color-green); +} + +/* Hunk separator */ +.claudian-diff-separator { + color: var(--text-muted); + text-align: center; + padding: 4px 0; + font-style: italic; + border-top: 1px dashed var(--background-modifier-border); + border-bottom: 1px dashed var(--background-modifier-border); + margin: 8px 0; + font-size: 11px; +} + +.claudian-diff-no-changes { + color: var(--text-muted); + font-style: italic; + padding: 8px; +} + + +/* ============================================ + features/slash-commands.css + ============================================ */ +/* Slash Command Dropdown */ +.claudian-slash-dropdown { + display: none; + position: absolute; + bottom: 100%; + left: 0; + right: 0; + margin-bottom: 4px; + background: var(--background-secondary); + backdrop-filter: blur(20px); + -webkit-backdrop-filter: blur(20px); + border: 1px solid var(--background-modifier-border); + border-radius: 6px; + box-shadow: 0 -4px 16px rgba(0, 0, 0, 0.2); + z-index: 1000; + max-height: 300px; + overflow-y: auto; +} + +.claudian-slash-dropdown.visible { + display: block; +} + +/* Fixed positioning for inline editor */ +.claudian-slash-dropdown-fixed { + position: fixed; + z-index: 10001; +} + +.claudian-slash-item { + padding: 8px 12px; + cursor: pointer; + transition: background 0.1s ease; + border-bottom: 1px solid var(--background-modifier-border); +} + +.claudian-slash-item:last-child { + border-bottom: none; +} + +.claudian-slash-item:hover, +.claudian-slash-item.selected { + background: var(--background-modifier-hover); +} + +.claudian-slash-name { + font-size: 12px; + font-weight: 500; + color: var(--text-normal); + font-family: var(--font-monospace); +} + +.claudian-slash-hint { + font-size: 12px; + color: var(--text-muted); + margin-left: 8px; +} + +.claudian-slash-desc { + font-size: 11px; + color: var(--text-muted); + margin-top: 2px; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.claudian-slash-empty { + padding: 16px; + text-align: center; + color: var(--text-muted); + font-size: 13px; +} + +/* Scrollbar */ +.claudian-slash-dropdown::-webkit-scrollbar { + width: 6px; +} + +.claudian-slash-dropdown::-webkit-scrollbar-track { + background: transparent; +} + +.claudian-slash-dropdown::-webkit-scrollbar-thumb { + background: var(--background-modifier-border); + border-radius: 3px; +} + + +/* ============================================ + features/resume-session.css + ============================================ */ +/* Resume Session Dropdown */ +.claudian-resume-dropdown { + display: none; + position: absolute; + bottom: 100%; + left: 0; + right: 0; + margin-bottom: 4px; + background: var(--background-secondary); + backdrop-filter: blur(20px); + -webkit-backdrop-filter: blur(20px); + border: 1px solid var(--background-modifier-border); + border-radius: 6px; + box-shadow: 0 -4px 16px rgba(0, 0, 0, 0.2); + z-index: 1000; + max-height: 400px; + overflow: hidden; +} + +.claudian-resume-dropdown.visible { + display: block; +} + +.claudian-resume-header { + padding: 8px 12px; + font-size: 12px; + font-weight: 600; + color: var(--text-muted); + text-transform: uppercase; + letter-spacing: 0.5px; + border-bottom: 1px solid var(--background-modifier-border); +} + +.claudian-resume-list { + max-height: 350px; + overflow-y: auto; +} + +.claudian-resume-empty { + padding: 16px; + text-align: center; + color: var(--text-muted); + font-size: 13px; +} + +.claudian-resume-item { + display: flex; + align-items: center; + gap: 10px; + padding: 8px 12px; + cursor: pointer; + border-bottom: 1px solid var(--background-modifier-border); + transition: background 0.1s ease; +} + +.claudian-resume-item:last-child { + border-bottom: none; +} + +.claudian-resume-item:hover, +.claudian-resume-item.selected { + background: var(--background-modifier-hover); +} + +.claudian-resume-item.current { + background: var(--background-secondary); + border-inline-start: 2px solid var(--interactive-accent); + padding-inline-start: 10px; +} + +.claudian-resume-item-icon { + display: flex; + align-items: center; + color: var(--text-muted); + flex-shrink: 0; +} + +.claudian-resume-item-icon svg { + width: 16px; + height: 16px; +} + +.claudian-resume-item.current .claudian-resume-item-icon { + color: var(--interactive-accent); +} + +.claudian-resume-item-content { + flex: 1; + min-width: 0; +} + +.claudian-resume-item-title { + font-size: 13px; + font-weight: 500; + color: var(--text-normal); + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; +} + +.claudian-resume-item-date { + font-size: 11px; + color: var(--text-faint); + margin-top: 2px; +} + +/* Scrollbar */ +.claudian-resume-list::-webkit-scrollbar { + width: 6px; +} + +.claudian-resume-list::-webkit-scrollbar-track { + background: transparent; +} + +.claudian-resume-list::-webkit-scrollbar-thumb { + background: var(--background-modifier-border); + border-radius: 3px; +} + + +/* ============================================ + features/ask-user-question.css + ============================================ */ +/* AskUserQuestion - inline widget rendered in chat panel */ + +.claudian-ask-question-inline { + font-family: var(--font-monospace); + font-size: 12px; + outline: none; +} + +.claudian-ask-inline-title { + font-weight: 700; + color: var(--text-muted); + padding: 6px 10px 0; +} + +/* ── Tab bar ─────────────────────────────────── */ + +.claudian-ask-tab-bar { + display: flex; + align-items: center; + gap: 6px; + padding: 4px 10px; + border-bottom: 1px solid var(--background-modifier-border); + line-height: 1.4; +} + +.claudian-ask-tab { + display: inline-flex; + align-items: center; + padding: 2px 10px; + border-radius: 3px; + cursor: pointer; + user-select: none; + color: var(--text-muted); + transition: + background 0.15s ease, + color 0.15s ease; +} + +.claudian-ask-tab:hover { + color: var(--text-normal); +} + +.claudian-ask-tab.is-active { + background: hsla(55, 30%, 50%, 0.18); + color: var(--text-normal); +} + +.claudian-ask-tab-label { + font-weight: 600; + max-width: 14ch; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.claudian-ask-tab-tick { + color: var(--color-green); + font-weight: 700; +} + +.claudian-ask-tab-submit-check { + color: var(--color-green); + white-space: pre; +} + +/* ── Content area ────────────────────────────── */ + +.claudian-ask-content { + padding: 8px 10px; +} + +.claudian-ask-question-text { + font-weight: 700; + color: var(--text-normal); + margin-bottom: 8px; + line-height: 1.4; +} + +/* ── Item list ───────────────────────────────── */ + +.claudian-ask-list { + display: flex; + flex-direction: column; + gap: 2px; + margin-bottom: 8px; +} + +.claudian-ask-item { + display: flex; + align-items: flex-start; + padding: 3px 4px; + cursor: pointer; + line-height: 1.4; + color: var(--text-normal); + border-radius: 3px; +} + +.claudian-ask-item:hover { + background: var(--background-modifier-hover); +} + +.claudian-ask-cursor { + display: inline-block; + width: 2ch; + flex-shrink: 0; + color: var(--text-accent); + font-weight: 700; +} + +.claudian-ask-item-num { + color: var(--text-muted); + flex-shrink: 0; +} + +.claudian-ask-item-content { + display: flex; + flex-direction: column; + flex: 1; + min-width: 0; +} + +.claudian-ask-label-row { + display: flex; + align-items: baseline; +} + +.claudian-ask-item-label { + font-weight: 600; +} + +.claudian-ask-item-desc { + color: var(--text-muted); + font-weight: 400; + line-height: 1.4; + margin-top: 1px; +} + +/* Selected items: green text */ +.claudian-ask-item.is-selected .claudian-ask-item-label { + color: var(--color-green); +} + +/* Disabled items: muted text */ +.claudian-ask-item.is-disabled .claudian-ask-item-label { + color: var(--text-faint); +} + +/* ── Multi-select brackets ───────────────────── */ + +.claudian-ask-check { + color: var(--text-faint); + flex-shrink: 0; + white-space: pre; +} + +.claudian-ask-check.is-checked { + color: var(--color-green); +} + +/* ── Single-select check mark ────────────────── */ + +.claudian-ask-check-mark { + color: var(--color-green); + font-weight: 700; +} + +/* ── Custom input ────────────────────────────── */ + +.claudian-ask-item input.claudian-ask-custom-text, +.claudian-ask-item input.claudian-ask-custom-text:hover, +.claudian-ask-item input.claudian-ask-custom-text:focus { + border: none; + border-radius: 0; + background: transparent; + box-shadow: none; + font-family: var(--font-monospace); + font-size: inherit; + color: var(--text-normal); + outline: none; + padding: 0; + width: 0; + height: auto; + min-height: 0; + line-height: 1.4; + flex: 1 1 0; + min-width: 0; +} + +.claudian-ask-custom-text::placeholder { + color: var(--text-faint); +} + +/* ── Submit review tab ───────────────────────── */ + +.claudian-ask-review-title { + font-weight: 700; + color: var(--text-normal); + margin-bottom: 6px; +} + +.claudian-ask-review { + font-family: var(--font-monospace); + margin-bottom: 16px; +} + +.claudian-tool-content .claudian-ask-review { + font-size: 12px; +} + +.claudian-ask-review:last-child { + margin-bottom: 0; +} + +.claudian-ask-review-pair { + display: flex; + gap: 6px; + margin-bottom: 4px; +} + +.claudian-ask-review-pair:last-child { + margin-bottom: 0; +} + +.claudian-ask-review-num { + color: var(--text-muted); + flex-shrink: 0; +} + +.claudian-ask-review-body { + min-width: 0; +} + +.claudian-ask-review-q-text { + color: var(--text-muted); +} + +.claudian-ask-review-a-text { + color: var(--text-normal); +} + +.claudian-ask-review-empty { + color: var(--text-faint); + font-style: italic; +} + +.claudian-ask-review-prompt { + color: var(--text-muted); + margin-bottom: 6px; +} + +/* ── Hints ───────────────────────────────────── */ + +.claudian-ask-hints { + color: var(--text-faint); + padding-top: 6px; + border-top: 1px solid var(--background-modifier-border); +} + +/* ── Approval header (inline permission request) ── */ + +.claudian-ask-approval-info { + padding: 8px 10px; +} + +.claudian-ask-approval-tool { + display: flex; + align-items: center; + gap: 8px; + padding: 6px 10px; + background: var(--background-secondary); + border-radius: 6px; + margin-bottom: 8px; +} + +.claudian-ask-approval-icon { + color: var(--claudian-brand); +} + +.claudian-ask-approval-tool-name { + font-weight: 600; + color: var(--text-normal); +} + +.claudian-ask-approval-reason { + color: var(--text-muted); + font-size: 12px; + margin-bottom: 6px; +} + +.claudian-ask-approval-blocked-path { + font-family: var(--font-monospace); + font-size: 11px; + color: var(--text-muted); + padding: 3px 6px; + background: var(--background-primary-alt); + border-radius: 4px; + margin-bottom: 6px; + word-break: break-all; +} + +.claudian-ask-approval-agent { + color: var(--text-muted); + font-size: 12px; + margin-bottom: 6px; +} + +.claudian-ask-approval-desc { + padding: 8px 10px; + background: var(--background-primary-alt); + border-radius: 6px; + font-family: var(--font-monospace); + font-size: 12px; + color: var(--text-normal); + word-break: break-all; +} + + +/* ============================================ + features/plan-mode.css + ============================================ */ +/* Plan Mode - inline cards for EnterPlanMode / ExitPlanMode */ + +.claudian-plan-approval-inline { + font-family: var(--font-monospace); + font-size: 12px; + outline: none; +} + +.claudian-plan-inline-title { + font-weight: 700; + color: var(--text-muted); + padding: 6px 10px 0; +} + +/* ── Plan content preview ────────────────────────── */ + +.claudian-plan-content-preview { + max-height: 300px; + overflow-y: auto; + margin: 6px 10px 8px; + padding: 8px 10px; + border: 1px solid var(--background-modifier-border); + border-radius: 4px; + background: var(--background-primary); + font-size: 12px; + line-height: 1.5; + color: var(--text-normal); +} + +.claudian-plan-content-preview::-webkit-scrollbar { + width: 4px; +} + +.claudian-plan-content-preview::-webkit-scrollbar-thumb { + background: var(--background-modifier-border); + border-radius: 2px; +} + +.claudian-plan-content-preview p { + margin: 0 0 6px; +} + +.claudian-plan-content-preview p:last-child { + margin-bottom: 0; +} + +.claudian-plan-content-preview h1, +.claudian-plan-content-preview h2, +.claudian-plan-content-preview h3, +.claudian-plan-content-preview h4 { + margin: 8px 0 4px; + font-size: 13px; +} + +.claudian-plan-content-preview ul, +.claudian-plan-content-preview ol { + margin: 2px 0 6px; + padding-left: 18px; +} + +.claudian-plan-content-preview li { + margin: 0; +} + +.claudian-plan-content-preview code { + font-size: 11px; +} + +.claudian-plan-content-text { + white-space: pre-wrap; + word-break: break-word; + font-family: var(--font-monospace); +} + +/* ── Permissions list ──────────────────────────── */ + +.claudian-plan-permissions { + padding: 4px 10px 8px; +} + +.claudian-plan-permissions-label { + color: var(--text-muted); + font-weight: 600; + margin-bottom: 4px; +} + +.claudian-plan-permissions-list { + margin: 0; + padding-left: 18px; + color: var(--text-normal); + line-height: 1.5; +} + +.claudian-plan-permissions-list li { + margin: 0; +} + +/* ── Plan mode input border ──────────────────────── */ + +.claudian-input-wrapper.claudian-input-plan-mode { + border-color: rgb(92, 148, 140) !important; + box-shadow: 0 0 0 1px rgb(92, 148, 140); +} + + +/* ============================================ + modals/instruction.css + ============================================ */ +/* Instruction Mode */ + +/* Instruction Confirm Modal */ +.claudian-instruction-modal { + max-width: 500px; +} + +.claudian-instruction-section { + margin-bottom: 16px; +} + +.claudian-instruction-label { + font-size: 12px; + font-weight: 500; + color: var(--text-muted); + margin-bottom: 6px; +} + +.claudian-instruction-original { + padding: 10px 12px; + background: var(--background-secondary); + border-radius: 6px; + font-size: 13px; + color: var(--text-muted); + font-style: italic; + white-space: pre-wrap; +} + +.claudian-instruction-refined { + padding: 12px; + background: var(--background-primary-alt); + border: 1px solid var(--background-modifier-border); + border-radius: 6px; + font-size: 14px; + color: var(--text-normal); + line-height: 1.5; + white-space: pre-wrap; +} + +.claudian-instruction-clarification { + padding: 12px; + background: var(--background-primary-alt); + border: 1px solid var(--background-modifier-border); + border-radius: 6px; + font-size: 14px; + color: var(--text-normal); + line-height: 1.5; + white-space: pre-wrap; +} + +.claudian-instruction-edit-container { + margin-top: 6px; +} + +.claudian-instruction-edit-textarea { + width: 100%; + padding: 10px 12px; + font-size: 14px; + line-height: 1.5; + border: 1px solid var(--background-modifier-border); + border-radius: 6px; + background: var(--background-primary); + color: var(--text-normal); + resize: vertical; + min-height: 80px; +} + +.claudian-instruction-edit-textarea:focus { + outline: none; + border-color: var(--interactive-accent); +} + +.claudian-instruction-response-textarea { + width: 100%; + padding: 10px 12px; + font-size: 14px; + line-height: 1.5; + border: 1px solid var(--background-modifier-border); + border-radius: 6px; + background: var(--background-primary); + color: var(--text-normal); + resize: vertical; + min-height: 60px; +} + +.claudian-instruction-response-textarea:focus { + outline: none; + border-color: var(--interactive-accent); +} + +.claudian-instruction-buttons { + display: flex; + gap: 8px; + justify-content: flex-end; + margin-top: 16px; +} + +.claudian-instruction-btn { + padding: 8px 16px; + font-size: 13px; + border: none; + border-radius: 6px; + cursor: pointer; + font-weight: 500; +} + +.claudian-instruction-reject-btn { + background: var(--background-modifier-border); + color: var(--text-normal); +} + +.claudian-instruction-reject-btn:hover { + background: var(--background-modifier-border-hover); +} + +.claudian-instruction-edit-btn { + background: var(--background-modifier-border); + color: var(--text-normal); +} + +.claudian-instruction-edit-btn:hover { + background: var(--background-modifier-border-hover); +} + +.claudian-instruction-accept-btn { + background: var(--interactive-accent); + color: var(--text-on-accent); +} + +.claudian-instruction-accept-btn:hover { + opacity: 0.9; +} + +/* Instruction loading state */ +.claudian-instruction-loading { + display: flex; + align-items: center; + justify-content: center; + gap: 10px; + padding: 20px; + color: var(--text-muted); +} + +.claudian-instruction-spinner { + width: 18px; + height: 18px; + border: 2px solid var(--background-modifier-border); + border-top-color: var(--interactive-accent); + border-radius: 50%; + animation: claudian-spin 0.8s linear infinite; +} + +/* Instruction modal content sections */ +.claudian-instruction-content-section { + margin: 8px 0; +} + +.claudian-instruction-clarification-section, +.claudian-instruction-confirmation-section { + margin-top: 8px; +} + + +/* ============================================ + modals/mcp-modal.css + ============================================ */ +/* MCP Server Modal */ +.claudian-mcp-modal .modal-content { + width: 480px; + max-width: 90vw; +} + +.claudian-mcp-type-fields { + margin: 12px 0; + padding: 12px; + background: var(--background-secondary); + border-radius: 6px; +} + +.claudian-mcp-type-fields .setting-item { + padding: 8px 0; + border-top: none; +} + +.claudian-mcp-type-fields .setting-item:first-child { + padding-top: 0; +} + +.claudian-mcp-cmd-setting, +.claudian-mcp-env-setting { + flex-direction: column; + align-items: flex-start; +} + +.claudian-mcp-cmd-setting .setting-item-control, +.claudian-mcp-env-setting .setting-item-control { + width: 100%; + margin-top: 8px; +} + +.claudian-mcp-cmd-textarea, +.claudian-mcp-env-textarea { + width: 100%; + min-height: 50px; + resize: vertical; + font-family: var(--font-monospace); + font-size: 12px; + padding: 8px; + border-radius: 4px; + border: 1px solid var(--background-modifier-border); + background: var(--background-primary); +} + +.claudian-mcp-cmd-textarea:focus, +.claudian-mcp-env-textarea:focus { + border-color: var(--interactive-accent); + outline: none; +} + +.claudian-mcp-buttons { + display: flex; + justify-content: flex-end; + gap: 8px; + margin-top: 16px; +} + +/* MCP Test Modal */ +.claudian-mcp-test-modal { + width: 500px; + max-width: 90vw; +} + +.claudian-mcp-test-modal .modal-content { + padding: 0 20px 20px 20px; +} + +.claudian-mcp-test-modal .modal-title { + padding: 20px 20px 12px 20px; + margin: 0 -20px; +} + +.claudian-mcp-test-loading { + display: flex; + align-items: center; + justify-content: center; + gap: 12px; + padding: 32px; + color: var(--text-muted); +} + +.claudian-mcp-test-spinner { + width: 20px; + height: 20px; + animation: claudian-spin 1s linear infinite; +} + +.claudian-mcp-test-spinner svg { + width: 100%; + height: 100%; +} + +.claudian-mcp-test-status { + display: flex; + align-items: center; + gap: 10px; + padding: 12px; + background: var(--background-secondary); + border-radius: 6px; + margin-bottom: 12px; +} + +.claudian-mcp-test-icon { + display: flex; + align-items: center; +} + +.claudian-mcp-test-icon svg { + width: 20px; + height: 20px; +} + +.claudian-mcp-test-icon.success { + color: var(--color-green); +} + +.claudian-mcp-test-icon.error { + color: var(--text-error); +} + +.claudian-mcp-test-text { + font-weight: 500; +} + +.claudian-mcp-test-error { + padding: 10px 12px; + background: rgba(var(--color-red-rgb), 0.1); + border: 1px solid var(--text-error); + border-radius: 6px; + color: var(--text-error); + font-size: 12px; + margin-bottom: 12px; +} + +.claudian-mcp-test-tools { + margin-bottom: 16px; +} + +.claudian-mcp-test-tools-header { + font-weight: 600; + font-size: 13px; + margin-bottom: 8px; + color: var(--text-muted); +} + +.claudian-mcp-test-tools-list { + display: flex; + flex-direction: column; + gap: 8px; + max-height: 300px; + overflow-y: auto; +} + +.claudian-mcp-test-tool { + padding: 10px 12px; + background: var(--background-secondary); + border-radius: 6px; +} + +.claudian-mcp-test-tool-header { + display: flex; + align-items: center; + gap: 8px; +} + +.claudian-mcp-test-tool-icon { + display: flex; + align-items: center; + color: var(--text-muted); +} + +.claudian-mcp-test-tool-icon svg { + width: 14px; + height: 14px; +} + +.claudian-mcp-test-tool-name { + font-weight: 500; + font-size: 13px; +} + +.claudian-mcp-test-tool-toggle { + margin-left: auto; +} + +.claudian-mcp-test-tool-toggle .checkbox-container { + display: flex; + align-items: center; +} + +.claudian-mcp-test-tool-disabled { + opacity: 0.75; +} + +.claudian-mcp-test-tool-disabled .claudian-mcp-test-tool-name { + text-decoration: line-through; + color: var(--text-muted); +} + +.claudian-mcp-toggle-all-btn { + margin-right: 8px; +} + +.claudian-mcp-toggle-all-btn.is-destructive { + background: rgba(var(--color-red-rgb), 0.1); + border-color: rgba(var(--color-red-rgb), 0.3); + color: var(--text-error); +} + +.claudian-mcp-toggle-all-btn.is-destructive:hover { + background: rgba(var(--color-red-rgb), 0.2); +} + +.claudian-mcp-test-tool-desc { + font-size: 12px; + color: var(--text-muted); + margin-top: 4px; + display: -webkit-box; + -webkit-line-clamp: 3; + -webkit-box-orient: vertical; + overflow: hidden; +} + +.claudian-mcp-test-no-tools { + padding: 16px; + text-align: center; + color: var(--text-muted); + font-size: 13px; + background: var(--background-secondary); + border-radius: 6px; + margin-bottom: 16px; +} + +.claudian-mcp-test-buttons { + display: flex; + justify-content: center; + margin-top: 16px; +} + + +/* ============================================ + modals/fork-target.css + ============================================ */ +/* Fork Target Modal */ +.claudian-fork-target-modal { + max-width: 340px; +} + +.claudian-fork-target-list { + display: flex; + flex-direction: column; +} + +.claudian-fork-target-option { + padding: 10px 12px; + border-radius: 6px; + cursor: pointer; + color: var(--text-normal); + font-size: 14px; +} + +.claudian-fork-target-option:hover { + background: var(--background-modifier-hover); +} + + +/* ============================================ + settings/base.css + ============================================ */ +/* ── Settings tab navigation ── */ + +.claudian-settings-tabs { + display: flex; + gap: 2px; + border-bottom: 1px solid var(--background-modifier-border); + margin-bottom: 16px; +} + +.claudian-settings-tab { + padding: 8px 16px; + border: none; + background: transparent; + color: var(--text-muted); + font-size: var(--font-ui-small); + font-weight: var(--font-medium); + cursor: pointer; + border-bottom: 2px solid transparent; + transition: color 0.15s ease, border-color 0.15s ease; + margin-bottom: -1px; +} + +.claudian-settings-tab:hover { + color: var(--text-normal); +} + +.claudian-settings-tab--active { + color: var(--text-normal); + border-bottom-color: var(--interactive-accent); +} + +.claudian-settings-tab-content { + display: none; +} + +.claudian-settings-tab-content--active { + display: block; +} + +/* Codex placeholder */ +.claudian-settings-codex-placeholder { + padding: 40px 20px; + text-align: center; + color: var(--text-muted); + font-size: var(--font-ui-small); +} + +/* Settings page - remove separator lines from setting items */ +.claudian-settings .setting-item { + border-top: none; +} + +/* Settings section headings (via setHeading()) */ +.claudian-settings .setting-item-heading { + padding-top: 18px; + margin-top: 12px; + border-top: 1px solid var(--background-modifier-border); +} + +.claudian-settings .setting-item-heading:first-child { + padding-top: 0; + margin-top: 0; + border-top: none; +} + +.claudian-settings .setting-item-heading .setting-item-name { + font-size: var(--font-ui-medium); + font-weight: var(--font-semibold); + color: var(--text-normal); +} + +/* Custom section descriptions - align with items */ +.claudian-sp-settings-desc, +.claudian-mcp-settings-desc, +.claudian-plugin-settings-desc, +.claudian-approved-desc { + padding: 0 12px; +} + +/* Unified icon action buttons for settings */ +.claudian-settings-action-btn { + display: flex; + align-items: center; + justify-content: center; + width: 28px; + height: 28px; + padding: 0; + border: none; + background: transparent; + border-radius: 4px; + cursor: pointer; + color: var(--text-muted); + transition: background 0.15s ease, color 0.15s ease; +} + +.claudian-settings-action-btn:hover { + background: var(--background-modifier-hover); + color: var(--text-normal); +} + +.claudian-settings-action-btn svg { + width: 14px; + height: 14px; +} + +.claudian-settings-delete-btn:hover { + color: var(--text-error); +} + +/* Hotkey grid - 3 columns */ +.claudian-hotkey-grid { + display: grid; + grid-template-columns: repeat(3, 1fr); + gap: 4px 12px; + padding: 4px 0; +} + +.claudian-hotkey-item { + display: flex; + align-items: center; + gap: 8px; + padding: 6px 12px; + cursor: pointer; + border-radius: 6px; +} + +.claudian-hotkey-item:hover { + background: var(--background-modifier-hover); +} + +.claudian-hotkey-name { + flex: 1; + color: var(--text-normal); + font-size: var(--font-ui-small); +} + +.claudian-hotkey-badge { + color: var(--text-muted); + font-size: var(--font-ui-smaller); + background: var(--background-modifier-hover); + padding: 2px 6px; + border-radius: 4px; + font-family: var(--font-monospace); +} + +/* Media folder input width */ +.claudian-settings-media-input { + width: 200px; +} + +/* ── Shared settings panel layout (used by slash-settings + agent-settings) ── */ + +.claudian-sp-header { + display: flex; + justify-content: space-between; + align-items: center; + margin-bottom: 12px; + padding: 0 12px; +} + +.claudian-sp-label { + font-size: var(--font-ui-small); + color: var(--text-muted); + font-weight: var(--font-medium); +} + +.claudian-sp-header-actions { + display: flex; + gap: 4px; +} + +.claudian-sp-empty-state { + padding: 20px; + text-align: center; + color: var(--text-muted); + background: var(--background-secondary); + border-radius: 6px; + margin-top: 8px; +} + +.claudian-sp-list { + display: flex; + flex-direction: column; + gap: 8px; + margin-top: 8px; +} + +.claudian-sp-item { + display: flex; + align-items: flex-start; + justify-content: space-between; + padding: 12px; + background: var(--background-secondary); + border-radius: 6px; +} + +.claudian-sp-item:hover { + background: var(--background-modifier-hover); +} + +.claudian-sp-info { + flex: 1; + min-width: 0; +} + +.claudian-sp-item-header { + display: flex; + align-items: baseline; + gap: 8px; +} + +.claudian-sp-item-name { + font-weight: 600; + font-family: var(--font-monospace); + color: var(--text-normal); +} + +.claudian-sp-item-desc { + font-size: 13px; + color: var(--text-muted); + margin-top: 2px; +} + +.claudian-sp-item-actions { + display: flex; + gap: 4px; + margin-left: 16px; + flex-shrink: 0; +} + +.claudian-sp-advanced-section { + border: 1px solid var(--background-modifier-border); + border-radius: 6px; + padding: 0 12px; + margin: 8px 0; +} + +.claudian-sp-advanced-summary { + cursor: pointer; + padding: 8px 0; + font-size: var(--font-ui-small); + color: var(--text-muted); + font-weight: var(--font-medium); +} + +.claudian-sp-advanced-section[open] .claudian-sp-advanced-summary { + margin-bottom: 4px; +} + +.claudian-sp-modal .modal-content { + max-width: 600px; + width: auto; +} + +.claudian-sp-content-area { + width: 100%; + font-family: var(--font-monospace); + font-size: 13px; + padding: 8px; + border: 1px solid var(--background-modifier-border); + border-radius: 4px; + background: var(--background-primary); + color: var(--text-normal); + resize: vertical; + margin-top: 8px; +} + +.claudian-sp-content-area:focus { + outline: none; + border-color: var(--interactive-accent); +} + +.claudian-sp-modal-buttons { + display: flex; + gap: 8px; + margin-top: 16px; + justify-content: flex-end; +} + + +/* ============================================ + settings/env-snippets.css + ============================================ */ +/* Context Limits Styles */ +.claudian-context-limits-container { + margin-top: 16px; +} + +.claudian-context-limits-header { + display: flex; + justify-content: space-between; + align-items: center; + margin-bottom: 8px; + margin-top: 16px; + padding: 0 12px; +} + +.claudian-context-limits-label { + font-size: var(--font-ui-small); + color: var(--text-muted); + font-weight: var(--font-medium); +} + +.claudian-context-limits-desc { + font-size: var(--font-ui-smaller); + color: var(--text-muted); + padding: 0 12px; + margin-bottom: 8px; +} + +.claudian-context-limits-list { + display: flex; + flex-direction: column; + gap: 8px; + margin-top: 8px; +} + +.claudian-context-limits-item { + display: flex; + align-items: center; + justify-content: space-between; + padding: 12px; + background: var(--background-secondary); + border-radius: 6px; + transition: background-color 0.2s; +} + +.claudian-context-limits-item:hover { + background: var(--background-modifier-hover); +} + +.claudian-context-limits-model { + font-family: var(--font-monospace); + font-size: var(--font-ui-small); + color: var(--text-normal); + flex: 1; + min-width: 0; + word-break: break-all; +} + +.claudian-context-limits-input-wrapper { + display: flex; + flex-direction: column; + align-items: flex-end; + margin-left: 16px; + flex-shrink: 0; +} + +.claudian-context-limits-input { + width: 80px; + padding: 4px 8px; + font-size: var(--font-ui-small); + border: 1px solid var(--background-modifier-border); + border-radius: 4px; + background: var(--background-primary); + color: var(--text-normal); +} + +.claudian-context-limits-input:focus { + border-color: var(--interactive-accent); + outline: none; +} + +.claudian-context-limits-input.claudian-input-error { + border-color: var(--text-error); +} + +.claudian-context-limit-validation { + display: none; + font-size: var(--font-ui-smaller); + color: var(--text-error); + margin-top: 4px; +} + +/* Environment Snippets Styles */ +.claudian-env-snippets-container { + margin-top: 16px; +} + +.claudian-snippet-header { + display: flex; + justify-content: space-between; + align-items: center; + margin-bottom: 12px; + margin-top: 16px; + padding: 0 12px; +} + +.claudian-snippet-label { + font-size: var(--font-ui-small); + color: var(--text-muted); + font-weight: var(--font-medium); +} + +.claudian-save-env-btn { + padding: 6px 16px; + font-size: 13px; + background: var(--interactive-accent); + color: var(--text-on-accent); + border: none; + border-radius: 4px; + cursor: pointer; + transition: opacity 0.2s; +} + +.claudian-save-env-btn:hover { + opacity: 0.9; +} + +.claudian-snippet-empty { + padding: 20px; + text-align: center; + color: var(--text-muted); + background: var(--background-secondary); + border-radius: 6px; + margin-top: 8px; +} + +.claudian-snippet-list { + display: flex; + flex-direction: column; + gap: 8px; + margin-top: 8px; +} + +.claudian-snippet-item { + display: flex; + align-items: center; + justify-content: space-between; + padding: 12px; + background: var(--background-secondary); + border-radius: 6px; + transition: background-color 0.2s; +} + +.claudian-snippet-item:hover { + background: var(--background-modifier-hover); +} + +.claudian-snippet-info { + flex: 1; + min-width: 0; +} + +.claudian-snippet-name { + font-weight: 600; + margin-bottom: 4px; + word-break: break-word; +} + +.claudian-snippet-description { + font-size: 13px; + color: var(--text-muted); +} + +.claudian-snippet-actions { + display: flex; + gap: 4px; + margin-left: 16px; + flex-shrink: 0; +} + +.claudian-restore-snippet-btn { + padding: 4px 12px; + font-size: 12px; + background: var(--interactive-accent); + color: var(--text-on-accent); + border: none; + border-radius: 4px; + cursor: pointer; +} + +.claudian-restore-snippet-btn:hover { + opacity: 0.9; +} + +.claudian-edit-snippet-btn { + padding: 4px 12px; + font-size: 12px; + background: var(--background-modifier-border); + color: var(--text-normal); + border: none; + border-radius: 4px; + cursor: pointer; +} + +.claudian-edit-snippet-btn:hover { + background: var(--background-modifier-border-hover); +} + +.claudian-delete-snippet-btn { + padding: 4px 12px; + font-size: 12px; + background: var(--background-modifier-error); + color: var(--text-on-accent); + border: none; + border-radius: 4px; + cursor: pointer; +} + +.claudian-delete-snippet-btn:hover { + opacity: 0.9; +} + +/* Env Snippet Modal */ +.claudian-env-snippet-modal .modal-content { + max-width: 550px; + width: 550px; + padding: 16px; +} + +.claudian-env-snippet-modal h2 { + margin: 0 0 16px 0; +} + +.claudian-env-snippet-modal .setting-item { + padding: 8px 0; + margin: 0; +} + +.claudian-env-snippet-modal .setting-item-info { + margin-bottom: 4px; +} + +/* Full-width env vars textarea setting */ +.claudian-env-snippet-setting { + flex-direction: column; + align-items: flex-start; +} + +.claudian-env-snippet-setting .setting-item-info { + width: 100%; + margin-bottom: 8px; +} + +.claudian-env-snippet-control { + width: 100%; +} + +.claudian-env-snippet-control textarea { + width: 100%; + min-width: 100%; + font-family: var(--font-monospace); + font-size: 12px; + resize: vertical; +} + +.claudian-snippet-preview { + margin: 8px 0; + padding: 6px; + background: var(--background-secondary); + border-radius: 6px; +} + +.claudian-env-preview { + background: var(--background-primary); + padding: 6px; + border-radius: 4px; + font-family: var(--font-monospace); + font-size: 11px; + line-height: 1.3; + white-space: pre-wrap; + word-break: break-all; + color: var(--text-muted); + max-height: 120px; + overflow-y: auto; + margin: 0; +} + +.claudian-snippet-buttons { + display: flex; + gap: 8px; + margin-top: 16px; + justify-content: flex-end; +} + +.claudian-cancel-btn, +.claudian-save-btn { + padding: 6px 16px; + font-size: 13px; + border: none; + border-radius: 4px; + cursor: pointer; +} + +.claudian-cancel-btn { + background: var(--background-modifier-border); + color: var(--text-normal); +} + +.claudian-cancel-btn:hover { + background: var(--background-modifier-border-hover); +} + +.claudian-save-btn { + background: var(--interactive-accent); + color: var(--text-on-accent); +} + +.claudian-save-btn:hover { + opacity: 0.9; +} + +/* Context limits section in snippet modal */ +.claudian-snippet-context-limits { + margin-top: 1em; +} + +.claudian-snippet-context-limits .setting-item-description { + margin-bottom: 0.5em; +} + +.claudian-snippet-limit-row { + display: flex; + align-items: center; + gap: 0.5em; + margin-bottom: 0.25em; +} + +.claudian-snippet-limit-model { + font-family: var(--font-monospace); + font-size: var(--font-ui-small); +} + +.claudian-snippet-limit-spacer { + flex: 1; +} + +.claudian-snippet-limit-input { + width: 80px; +} + + +/* ============================================ + settings/slash-settings.css + ============================================ */ +/* Slash Command Settings — unique rules only (shared layout in base.css .claudian-sp-*) */ + +.claudian-slash-item-hint { + font-size: 12px; + color: var(--text-muted); + font-style: italic; +} + +.claudian-slash-item-badge { + font-size: 10px; + padding: 2px 6px; + background: var(--background-modifier-border); + border-radius: 4px; + color: var(--text-muted); + text-transform: uppercase; +} + + +/* ============================================ + settings/mcp-settings.css + ============================================ */ +/* MCP Server Settings */ +.claudian-mcp-settings-desc { + margin-bottom: 12px; +} + +.claudian-mcp-container { + margin-top: 8px; +} + +.claudian-mcp-header { + display: flex; + justify-content: space-between; + align-items: center; + margin-bottom: 12px; + padding: 0 12px; +} + +.claudian-mcp-label { + font-size: var(--font-ui-small); + color: var(--text-muted); + font-weight: var(--font-medium); +} + +.claudian-mcp-add-container { + position: relative; +} + +.claudian-add-mcp-btn { + padding: 4px 12px; + border-radius: 4px; + background: var(--interactive-accent); + color: var(--text-on-accent); + font-size: 12px; + cursor: pointer; + border: none; +} + +.claudian-add-mcp-btn:hover { + background: var(--interactive-accent-hover); +} + +.claudian-mcp-add-dropdown { + display: none; + position: absolute; + top: 100%; + right: 0; + margin-top: 4px; + min-width: 180px; + background-color: var(--modal-background, var(--background-primary)); + border: 1px solid var(--background-modifier-border); + border-radius: 6px; + box-shadow: 0 4px 12px rgba(0, 0, 0, 0.2); + z-index: 100; + overflow: hidden; +} + +.claudian-mcp-add-dropdown.is-visible { + display: block; +} + +.claudian-mcp-add-option { + display: flex; + align-items: center; + gap: 8px; + padding: 8px 12px; + cursor: pointer; + font-size: 13px; + color: var(--text-normal); +} + +.claudian-mcp-add-option:hover { + background: var(--background-modifier-hover); +} + +.claudian-mcp-add-option-icon { + display: flex; + align-items: center; + color: var(--text-muted); +} + +.claudian-mcp-add-option-icon svg { + width: 16px; + height: 16px; +} + +.claudian-mcp-empty { + padding: 16px; + text-align: center; + color: var(--text-muted); + font-size: 13px; + background: var(--background-secondary); + border-radius: 6px; +} + +.claudian-mcp-list { + display: flex; + flex-direction: column; + gap: 8px; +} + +.claudian-mcp-item { + display: flex; + align-items: flex-start; + gap: 10px; + padding: 10px 12px; + background: var(--background-secondary); + border-radius: 6px; + transition: background 0.15s ease; +} + +.claudian-mcp-item:hover { + background: var(--background-modifier-hover); +} + +.claudian-mcp-item-disabled { + opacity: 0.6; +} + +.claudian-mcp-status { + width: 8px; + height: 8px; + border-radius: 50%; + margin-top: 6px; + flex-shrink: 0; +} + +.claudian-mcp-status-enabled { + background: var(--color-green); +} + +.claudian-mcp-status-disabled { + background: var(--text-muted); +} + +.claudian-mcp-info { + flex: 1; + min-width: 0; +} + +.claudian-mcp-name-row { + display: flex; + align-items: center; + gap: 8px; + flex-wrap: wrap; +} + +.claudian-mcp-name { + font-weight: 600; +} + +.claudian-mcp-type-badge { + font-size: 10px; + padding: 2px 6px; + background: var(--background-modifier-border); + border-radius: 4px; + color: var(--text-muted); + text-transform: uppercase; +} + +.claudian-mcp-context-saving-badge { + font-size: 11px; + padding: 2px 6px; + background: var(--interactive-accent); + color: var(--text-on-accent); + border-radius: 4px; + font-weight: 600; +} + +.claudian-mcp-preview { + font-size: 12px; + color: var(--text-muted); + margin-top: 4px; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.claudian-mcp-actions { + display: flex; + gap: 4px; + flex-shrink: 0; +} + +.claudian-mcp-action-btn { + display: flex; + align-items: center; + justify-content: center; + width: 28px; + height: 28px; + padding: 0; + border: none; + background: transparent; + border-radius: 4px; + cursor: pointer; + color: var(--text-muted); + transition: background 0.15s ease, color 0.15s ease; +} + +.claudian-mcp-action-btn:hover { + background: var(--background-modifier-hover); + color: var(--text-normal); +} + +.claudian-mcp-action-btn svg { + width: 14px; + height: 14px; +} + +.claudian-mcp-delete-btn:hover { + color: var(--text-error); +} + + +/* ============================================ + settings/plugin-settings.css + ============================================ */ +/* Plugin Settings */ +.claudian-plugin-settings-desc { + margin-bottom: 12px; +} + +.claudian-plugins-container { + margin-top: 8px; +} + +.claudian-plugin-header { + display: flex; + justify-content: space-between; + align-items: center; + margin-bottom: 12px; + padding: 0 12px; +} + +.claudian-plugin-label { + font-size: var(--font-ui-small); + color: var(--text-muted); + font-weight: var(--font-medium); +} + +.claudian-plugin-empty { + padding: 16px; + text-align: center; + color: var(--text-muted); + font-size: 13px; + background: var(--background-secondary); + border-radius: 6px; +} + +.claudian-plugin-list { + display: flex; + flex-direction: column; + gap: 8px; +} + +.claudian-plugin-section-header { + font-size: 11px; + color: var(--text-muted); + text-transform: uppercase; + padding: 8px 12px 4px; + font-weight: 600; +} + +.claudian-plugin-item { + display: flex; + align-items: flex-start; + gap: 10px; + padding: 10px 12px; + background: var(--background-secondary); + border-radius: 6px; + transition: background 0.15s ease; +} + +.claudian-plugin-item:hover { + background: var(--background-modifier-hover); +} + +.claudian-plugin-item-disabled { + opacity: 0.6; +} + +.claudian-plugin-item-error { + opacity: 0.8; +} + +.claudian-plugin-status { + width: 8px; + height: 8px; + border-radius: 50%; + margin-top: 6px; + flex-shrink: 0; +} + +.claudian-plugin-status-enabled { + background: var(--color-green); +} + +.claudian-plugin-status-disabled { + background: var(--text-muted); +} + +.claudian-plugin-status-error { + background: var(--text-error); +} + +.claudian-plugin-info { + flex: 1; + min-width: 0; +} + +.claudian-plugin-name-row { + display: flex; + align-items: center; + gap: 8px; + flex-wrap: wrap; +} + +.claudian-plugin-name { + font-weight: 600; +} + +.claudian-plugin-version-badge { + font-size: 10px; + padding: 2px 6px; + background: var(--background-modifier-border); + border-radius: 4px; + color: var(--text-muted); +} + +.claudian-plugin-error-badge { + font-size: 10px; + padding: 2px 6px; + background: var(--text-error); + color: var(--text-on-accent); + border-radius: 4px; + text-transform: uppercase; +} + +.claudian-plugin-preview { + font-size: 12px; + color: var(--text-muted); + margin-top: 4px; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.claudian-plugin-preview-error { + color: var(--text-error); +} + +.claudian-plugin-actions { + display: flex; + gap: 4px; + flex-shrink: 0; +} + +.claudian-plugin-action-btn { + display: flex; + align-items: center; + justify-content: center; + width: 28px; + height: 28px; + padding: 0; + border: none; + background: transparent; + border-radius: 4px; + cursor: pointer; + color: var(--text-muted); + transition: background 0.15s ease, color 0.15s ease; +} + +.claudian-plugin-action-btn:hover { + background: var(--background-modifier-hover); + color: var(--text-normal); +} + +.claudian-plugin-action-btn svg { + width: 14px; + height: 14px; +} + + +/* ============================================ + settings/agent-settings.css + ============================================ */ +/* Agent Settings — all structural rules live in base.css .claudian-sp-* */ +/* This file is kept as a placeholder for future agent-specific overrides. */ + + +/* ============================================ + accessibility.css + ============================================ */ +/* Accessibility - Focus Visible Styles */ + +/* outline + offset + border-radius */ +.claudian-tool-header:focus-visible, +.claudian-thinking-header:focus-visible, +.claudian-subagent-header:focus-visible, +.claudian-header-btn:focus-visible, +.claudian-model-btn:focus-visible, +.claudian-thinking-current:focus-visible { + outline: 2px solid var(--interactive-accent); + outline-offset: 2px; + border-radius: 4px; +} + +/* outline + offset only */ +.claudian-action-btn:focus-visible, +.claudian-toggle-switch:focus-visible, +.claudian-file-chip:focus-visible, +.claudian-image-chip:focus-visible, +.claudian-file-chip-remove:focus-visible, +.claudian-image-remove:focus-visible, +.claudian-image-modal-close:focus-visible, +.claudian-approved-remove-btn:focus-visible, +.claudian-save-env-btn:focus-visible, +.claudian-restore-snippet-btn:focus-visible, +.claudian-edit-snippet-btn:focus-visible, +.claudian-delete-snippet-btn:focus-visible, +.claudian-cancel-btn:focus-visible, +.claudian-save-btn:focus-visible, +.claudian-code-lang-label:focus-visible { + outline: 2px solid var(--interactive-accent); + outline-offset: 2px; +} + +/* outline + negative offset + border-radius */ +.claudian-history-item-content:focus-visible { + outline: 2px solid var(--interactive-accent); + outline-offset: -2px; + border-radius: 4px; +} diff --git a/.obsidian/plugins/various-complements/histories.json b/.obsidian/plugins/various-complements/histories.json index ecd1d23..1414994 100644 --- a/.obsidian/plugins/various-complements/histories.json +++ b/.obsidian/plugins/various-complements/histories.json @@ -1 +1 @@ -{"截帧并且返回结果。":{"截帧并且返回结果。":{"currentFile":{"count":1,"lastUpdated":1770709439590}}},"Maya CMake笔记":{"Maya CMake笔记":{"internalLink":{"count":1,"lastUpdated":1770716829521}}},"MCP商店":{"MCP商店":{"currentFile":{"count":1,"lastUpdated":1770718675186}}},"Simplegen":{"Simplegen":{"currentFile":{"count":1,"lastUpdated":1770720333062}}},"README":{"README":{"internalLink":{"count":1,"lastUpdated":1770818577089}}},"Notification":{"Notification":{"currentFile":{"count":1,"lastUpdated":1770818619712}}},"ServiceRequest":{"ServiceRequest":{"internalLink":{"count":1,"lastUpdated":1772077751440}}},"skills":{"skills":{"currentFile":{"count":1,"lastUpdated":1772100003535}}},"Bilibili":{"Bilibili":{"currentFile":{"count":1,"lastUpdated":1772112409334}}},"using-superpowers":{"using-superpowers":{"currentFile":{"count":1,"lastUpdated":1772348498708}}},"添加新的护城河：引擎相关MCP&Skill、AITA资产库":{"添加新的护城河：引擎相关MCP&Skill、AITA资产库":{"currentFile":{"count":1,"lastUpdated":1772891664291}}}} \ No newline at end of file +{"Agent":{"Agent":{"internalLink":{"count":2,"lastUpdated":1773554273209}}},"要解决这个问题，得对记忆进行合理规划与维护：":{"要解决这个问题，得对记忆进行合理规划与维护：":{"currentFile":{"count":1,"lastUpdated":1774938677236}}},"Openclaw-workspace":{"Openclaw-workspace":{"currentFile":{"count":1,"lastUpdated":1774938879095}}},"workflow":{"workflow":{"currentFile":{"count":1,"lastUpdated":1775020352083}}},"\\AI\\Skill\\MatrixAITA-POPODocs-Skill、D":{"\\AI\\Skill\\MatrixAITA-POPODocs-Skill、D":{"currentFile":{"count":1,"lastUpdated":1776242568663}}},"推荐加在仓库内已有的标准元数据文件中，例如：":{"推荐加在仓库内已有的标准元数据文件中，例如：":{"currentFile":{"count":1,"lastUpdated":1776242909075}}},"推荐加在仓库内已有的标准元数据文件中，":{"推荐加在仓库内已有的标准元数据文件中，":{"currentFile":{"count":1,"lastUpdated":1776242914868}}}} \ No newline at end of file diff --git a/.obsidian/plugins/workspaces-plus/data.json b/.obsidian/plugins/workspaces-plus/data.json index 8b41768..e13be0f 100644 --- a/.obsidian/plugins/workspaces-plus/data.json +++ b/.obsidian/plugins/workspaces-plus/data.json @@ -6,7 +6,7 @@ "workspaceSettings": false, "systemDarkMode": false, "globalSettings": {}, - "activeWorkspaceDesktop": "阅读模式", + "activeWorkspaceDesktop": "编辑模式", "activeWorkspaceMobile": "", "reloadLivePreview": false, "workspaceSwitcherRibbon": false, diff --git a/.obsidian/workspaces.json b/.obsidian/workspaces.json index 9b4444a..4d043f2 100644 --- a/.obsidian/workspaces.json +++ b/.obsidian/workspaces.json @@ -368,5 +368,5 @@ "workspaces-plus:settings-v1": {} } }, - "active": "阅读模式" + "active": "编辑模式" } \ No newline at end of file diff --git a/01-Diary/本周事务/未命名.md b/01-Diary/本周事务/未命名.md new file mode 100644 index 0000000..5584146 --- /dev/null +++ b/01-Diary/本周事务/未命名.md @@ -0,0 +1,20 @@ +--- +title: 未命名 +date: 2026-04-02 20:19:19 +excerpt: +tags: +rating: ⭐ +status: inprogress +destination: +share: false +obsidianUIMode: source +--- + +武林有2个方向: +1. 第一天（西湖 Or 运河） + 1. 往北可以坐地铁到香积寺，参观香积寺以及边上的大兜路特色街区，之后可以到乐堤港综合体吃个饭啥；之后可以坐地铁到拱宸桥看一下运河公园以及边上的街区。 + 2. 往南可以坐地铁到凤起路，那边有一家抹茶店可以去体验一下（得早点去要排队），之后可以去往西湖边走，到西湖后继续往南，走到龙翔桥附近，可以考虑逛 银泰（吃饭啥）。之后继续往南 + 1. 可以考虑去柳浪闻莺公园 => 坐观光车 => 游西湖 => 太子湾公园 => 苏堤 => 断桥 + 2. 可以考虑去吴山广场 => 河坊街 => 胡雪岩故居 => 鼓楼附近吃饭啥的。去附近的候潮门 地铁站 (或者打车）=> 市民中心（附近有来福士、万象城综合体） => 走到城市阳台 看杭州的灯光秀（记得是18:30结束）。 +2. 第二天(西溪湿地) + 1. 做地铁到 天目里 => 西溪天堂 => 西溪湿地南部小路 => 高庄 => 福堤 => 西溪龙湖天街 \ No newline at end of file diff --git a/02-Note/WY/MatrixAITA团队服务部署/OSS+图床.md b/02-Note/WY/MatrixAITA团队服务部署/OSS+图床.md new file mode 100644 index 0000000..07a0e88 --- /dev/null +++ b/02-Note/WY/MatrixAITA团队服务部署/OSS+图床.md @@ -0,0 +1,70 @@ +# 部署 +```bash +mkdir -p /home/matriaita_docker/oss/minio +mkdir -p /home/matriaita_docker/oss/alist + +``` + + +```yml +version: '3.8' + +services: + minio: + image: pgsty/minio:latest + container_name: minio + restart: always + ports: + - "9000:9000" # S3 API + - "9001:9001" # 管理后台 + environment: + MINIO_ROOT_USER: admin + MINIO_ROOT_PASSWORD: mataita@666 + # --- 新增以下配置 --- + # 1. 解决分享链接打不开的问题（设为你的 API 访问地址） + MINIO_SERVER_URL: "http://ta.netease.com:9000" + # 2. 解决管理后台登录跳转地址不对的问题 + MINIO_BROWSER_REDIRECT_URL: "http://ta.netease.com:9001" + # 3. 解决跨域问题（允许来自 ta.netease.com 的请求，或者设为 * 允许所有） + MINIO_API_CORS_ALLOW_ORIGIN: "http://ta.netease.com,http://ta.netease.com:5244" + volumes: + - ./minio:/data + command: server /data --console-address ":9001" + + alist: + image: xhofe/alist:latest + container_name: alist + restart: always + ports: + - "5244:5244" + volumes: + - ./alist:/opt/alist/data + environment: + - PUID=1000 + - PGID=1000 + - UMASK=022 + depends_on: + - minio +``` + +## 配置步骤 +- 启动：`docker-compose up -d` +- 获取 AList 密码：`docker exec -it alist ./alist admin` +- **配置 MinIO**： + - 访问 `http://服务器IP:9001`。 + - 创建一个 Bucket（如 `obsidian-assets`）。 + - 在 Access Keys 中创建一个 Key，记下 `Access Key` 和 `Secret Key`。 +- **配置 AList**： + - 访问 `http://服务器IP:5244`。 + - 进入“管理” -> “存储” -> “添加”。驱动选 **MinIO**。 + - **挂载路径**填 `/assets`。 + - **Endpoint** 填 `http://minio:9000`（如果 AList 和 MinIO 在同一台服务器的 Docker 网络中）。 + - 填入刚才 MinIO 的 Bucket 和 Key。 + +## 相关信息 +1. MinIO + 1. `Access Key`：r9uq0TP7ZbF5BA41Gb6E + 2. `Secret Key`：DstYixNcDnumg5qZPRg4XxMfVZb2XFwH92ow0SbP +2. AList + 1. admin + 2. NEW_PASSWORD \ No newline at end of file diff --git a/03-UnrealEngine/Gameplay/PuerTS/Puerts Quick Start.md b/03-UnrealEngine/Gameplay/PuerTS/Puerts Quick Start.md index cf4d66f..5b00206 100644 --- a/03-UnrealEngine/Gameplay/PuerTS/Puerts Quick Start.md +++ b/03-UnrealEngine/Gameplay/PuerTS/Puerts Quick Start.md @@ -16,6 +16,7 @@ rating: ⭐ - https://github.com/Tencent/puerts/issues - https://github.com/Tencent/puerts/discussions # QuickStart +- Puerts AI初始化Skill: https://github.com/noobGuaTai/ue5-puerts-init-skill ## Setup 1. 安装Nodejs v22.17.1。 2. 通过安装全局typeScrpit模块。 @@ -35,7 +36,7 @@ npm install -g typescript "dependencies": { "@types/mocha": "^10.0.10" } - ``` +``` 5. 打开工程，在引擎中点击 ue.d.ts 。 该功能用于生成项目、引擎符号信息，生成之后就能找到相关符号了。如果想在ts文件中调用新增的蓝图&C++方法，也需要点击ue.d.ts才能找到对应符号。可以阅读该文了解详细信息 https://puerts.github.io/docs/puerts/unreal/script_call_uclass ![[Puerts_UE_D_TS.png]] 6. 在`ProjectSettings - Packaging - Additional Not-Asset Directories to Package`中添加`Content/javaScript`。 diff --git a/03-UnrealEngine/逆向/魔改RenderDoc截帧PC端《鸣潮》.md b/03-UnrealEngine/逆向/魔改RenderDoc截帧PC端《鸣潮》.md new file mode 100644 index 0000000..ae7dea5 --- /dev/null +++ b/03-UnrealEngine/逆向/魔改RenderDoc截帧PC端《鸣潮》.md @@ -0,0 +1,187 @@ +--- +title: 未命名 +date: 2026-03-25 21:43:14 +excerpt: +tags: +rating: ⭐ +--- +![](https://pic4.zhimg.com/v2-c88b1dc29371ae1cfb4a788f6cd5fee3_1440w.jpg) + +## 前言 + +之前写过一些截帧的文章，主要是通过模拟器来绕过加密系统，但是现在想想有可能两个游戏在移动端和PC端上用的Shader不一样，现在想用[RenderDoc](https://zhida.zhihu.com/search?content_id=271977473&content_type=Article&match_order=1&q=RenderDoc&zhida_source=entity)来截取PC环境下两个游戏的Shader + +![](https://pic2.zhimg.com/v2-4a50acd406d90146397cda94ce7eac1f_1440w.jpg) + +## 《鸣潮》是如何检测到RenderDoc的？ + +如果你是直接下载的打包好的RenderDoc，那么无论你是否从RenderDoc启动游戏还是是否有任何注入，都会显示启用了黑客工具 + +![](https://pic1.zhimg.com/v2-3e8c32ba0d80dcf93e3e067553f032e8_1440w.jpg) + +此外，《鸣潮》采用了[CrashSight](https://zhida.zhihu.com/search?content_id=271977473&content_type=Article&match_order=1&q=CrashSight&zhida_source=entity) 检测，所以在做的时候不但要修改RenderDoc的特征码，还需要修改注入方式 + +## 前期准备 + +RenderDoc的工具集是[VS2015](https://zhida.zhihu.com/search?content_id=271977473&content_type=Article&match_order=1&q=VS2015&zhida_source=entity)的[v140](https://zhida.zhihu.com/search?content_id=271977473&content_type=Article&match_order=1&q=v140&zhida_source=entity)版本，我用的是VS2022所以需要额外下载v140组件，或者是可以到源码里面手动更新平台工具集 + +[https://github.com/baldurk/renderdoc/tree/v1.xgithub.com/baldurk/renderdoc/tree/v1.x](https://link.zhihu.com/?target=https%3A//github.com/baldurk/renderdoc/tree/v1.x) + +## 一，修改RenderDoc的特征来绕过第一步检测 + +### 核心 DLL — [Replay Marker](https://zhida.zhihu.com/search?content_id=271977473&content_type=Article&match_order=1&q=Replay+Marker&zhida_source=entity) 符号 + + + +|文件路径|行号|修改类型|修改前|修改后| +|---|---|---|---|---| +|renderdoc/api/replay/renderdoc_replay.h|52|函数名修改|renderdoc__replay__marker()|rendertest__replay__marker()| + + + +> _说明：这是最核心的修改。`REPLAY_PROGRAM_MARKER()`_ _宏定义所有 RenderDoc 可执行文件导出的符号，DLL 通过动态查找该符号判断当前是 replay 环境还是目标游戏进程。若 DLL 期望_ _`rendertest__replay__marker`_ _但 EXE 导出的是_ _`renderdoc__replay__marker`，DLL 将误判为游戏进程并注入 GPU 钩子，导致 UI 崩溃。_ + +### 进程创建与注入 — 可执行文件路径硬编码 + + + +|文件路径|行号|修改类型|修改前|修改后| +|---|---|---|---|---| +|renderdoc/os/win32/win32_process.cpp|933|字符串替换|L"\\Win32\\Development\\renderdoccmd.exe"|L"\\Win32\\Development\\rendertestcmd.exe"| +|renderdoc/os/win32/win32_process.cpp|946|字符串替换|L"\\Win32\\Release\\renderdoccmd.exe"|L"\\Win32\\Release\\rendertestcmd.exe"| +|renderdoc/os/win32/win32_process.cpp|961|字符串替换|L"\\x86\\renderdoccmd.exe"|L"\\x86\\rendertestcmd.exe"| +|renderdoc/os/win32/win32_process.cpp|973|字符串替换|L"\\x64\\Development\\renderdoccmd.exe"|L"\\x64\\Development\\rendertestcmd.exe"| +|renderdoc/os/win32/win32_process.cpp|986|字符串替换|L"\\x64\\Release\\renderdoccmd.exe"|L"\\x64\\Release\\rendertestcmd.exe"| +|renderdoc/os/win32/win32_process.cpp|1006|字符串替换|L"\\renderdoccmd.exe"|L"\\rendertestcmd.exe"| + + +## [Shim DLL](https://zhida.zhihu.com/search?content_id=271977473&content_type=Article&match_order=1&q=Shim+DLL&zhida_source=entity) 路径硬编码 + +### Shim DLL 路径硬编码 + + + +|文件路径|行号|修改类型|修改前|修改后| +|---|---|---|---|---| +|renderdoc/os/win32/win32_process.cpp|1783|字符串拼接|"\\renderdocshim64.dll"|"\\rendertestshim64.dll"| +|renderdoc/os/win32/win32_process.cpp|1792|字符串拼接|"\\Win32\\Development\\renderdocshim32.dll"|"\\Win32\\Development\\rendertestshim32.dll"| +|renderdoc/os/win32/win32_process.cpp|1803|字符串拼接|"\\Win32\\Release\\renderdocshim32.dll"|"\\Win32\\Release\\rendertestshim32.dll"| +|renderdoc/os/win32/win32_process.cpp|1811|字符串拼接|"\\x86\\renderdocshim32.dll"|"\\x86\\rendertestshim32.dll"| +|renderdoc/os/win32/win32_process.cpp|1818|字符串拼接|"\\renderdocshim32.dll"| + + + +### [进程白名单](https://zhida.zhihu.com/search?content_id=271977473&content_type=Article&match_order=1&q=%E8%BF%9B%E7%A8%8B%E7%99%BD%E5%90%8D%E5%8D%95&zhida_source=entity) — 避免注入到 RenderTest 自身 + + + +|文件路径|行号|修改类型|修改前|修改后| +|---|---|---|---|---| +|renderdoc/os/win32/sys_win32_hooks.cpp|342|字符串替换|"renderdoccmd.exe" \| app.contains("qrenderdoc.exe")|"rendertestcmd.exe" \| app.contains("qrendertest.exe")| +|renderdoc/os/win32/sys_win32_hooks.cpp|351|字符串替换|"renderdoccmd.exe" \| cmd.contains("qrenderdoc.exe")|"rendertestcmd.exe" \| cmd.contains("qrendertest.exe")| + + + +### 崩溃处理 — 命名内核对象 + + + +|文件路径|行号|修改类型|修改前|修改后| +|---|---|---|---|---| +|renderdoccmd/renderdoccmd_win32.cpp|603|字符串替换|"RENDERDOC_CRASHHANDLE"|"RENDERTEST_CRASHHANDLE"| +|renderdoccmd/renderdoccmd_win32.cpp|818|字符串替换|GetModuleHandleA("renderdoc.dll")|GetModuleHandleA("rendertest.dll")| +|core/crash_handler.h|62|字符串拼接|"RenderDoc\\dumps\\a"|"RenderTest\\dumps\\a"| +|core/crash_handler.h|168|字符串拼接|"RenderDocBreakpadServer%llu"|"RenderTestBreakpadServer%llu"| + + + +### 表格 6：文件路径与注册表 + + + +|文件路径|行号|修改类型|修改前|修改后| +|---|---|---|---|---| +|renderdoc/os/win32/win32_stringio.cpp|289|字符串拼接|"/qrenderdoc.exe"|"/qrendertest.exe"| +|renderdoc/os/win32/win32_stringio.cpp|300|字符串拼接|"/../qrenderdoc.exe"|"/../qrendertest.exe"| +|renderdoc/os/win32/win32_stringio.cpp|316|注册表路径|L"RenderDoc.RDCCapture.1\\DefaultIcon"|L"RenderTest.RDCCapture.1\\DefaultIcon"| +|renderdoc/os/win32/win32_stringio.cpp|358|日志路径|L"RenderDoc\\%ls_..."|L"RenderTest\\%ls_..."| +|renderdoc/os/win32/win32_stringio.cpp|367|日志路径|L"RenderDoc\\%ls_..."|L"RenderTest\\%ls_..."| + + + +### OpenGL 窗口类名 + + + +|文件路径|行号|修改类型|修改前|修改后| +|---|---|---|---|---| +|driver/gl/wgl_platform.cpp|28|宏定义|L"renderdocGLclass"|L"rendertestGLclass"| + + + +### [全局 Hook 共享内存名称](https://zhida.zhihu.com/search?content_id=271977473&content_type=Article&match_order=1&q=%E5%85%A8%E5%B1%80+Hook+%E5%85%B1%E4%BA%AB%E5%86%85%E5%AD%98%E5%90%8D%E7%A7%B0&zhida_source=entity) + + + +|文件路径|行号|修改类型|修改前|修改后| +|---|---|---|---|---| +|renderdocshim/renderdocshim.h|36|宏定义|"RenderDocGlobalHookData64"|"RenderTestGlobalHookData64"| +|renderdocshim/renderdocshim.h|39|宏定义|"RenderDocGlobalHookData32"|"RenderTestGlobalHookData32"| + + + +### 资源文件 + + + +|文件路径|行号|修改类型|修改前|修改后| +|---|---|---|---|---| +|data/renderdoc.rc|87|资源字符串|"Core DLL for RenderDoc"|"Core DLL for RenderTest"| +|data/renderdoc.rc|92|资源字符串|"ProductName", "RenderDoc"|"ProductName", "RenderTest"| + + + +### Qt UI 层 + + + +|文件路径|行号|修改类型|修改前|修改后| +|---|---|---|---|---| +|qrenderdoc/renderdocui_stub.cpp|62|字符串拼接|L"qrenderdoc.exe"|L"qrendertest.exe"| +|qrenderdoc/Code/qrenderdoc.cpp|173|Qt 翻译上下文|"qrenderdoc"|"qrendertest"| +|qrenderdoc/Code/qrenderdoc.cpp|198|日志输出|"QRenderDoc initialising."|"QRenderTest initialising."| +|qrenderdoc/Code/qrenderdoc.cpp|267|会话名|"QRenderDoc"|"QRenderTest"| +|qrenderdoc/Code/qrenderdoc.cpp|330|描述文本|"Qt UI for RenderDoc"|"Qt UI for RenderTest"| +|qrenderdoc/Code/qrenderdoc.cpp|393|版本输出|"QRenderDoc v%s"|"QRenderTest v%s"| +|qrenderdoc/Windows/MainWindow.cpp|1217|窗口标题|"RenderDoc "|"RenderTest "| + + + +### VS 项目文件（编译输出名 + UAC 提权） + + + +|文件路径|属性|修改类型|修改前|修改后| +|---|---|---|---|---| +|qrenderdoc/renderdocui_stub.vcxproj|RootNamespace|修改|renderdocui_stub|rendertestui_stub| +|qrenderdoc/renderdocui_stub.vcxproj|ProjectName|修改|renderdocui_stub|rendertestui_stub| +|qrenderdoc/renderdocui_stub.vcxproj|PrimaryOutput|新增|(无)|rendertestui| +|qrenderdoc/renderdocui_stub.vcxproj|TargetName|新增|(无)|rendertestui| +|qrenderdoc/renderdocui_stub.vcxproj|UACExecutionLevel|新增|(无)|RequireAdmini| + + + +## CrashSight检测 + +这里可以在Hook的时候采用SetThreadContext注入 + +修改文件:renderdoc/os/win32/win32_process.cpp + +```text + uintptr_t loc = FindRemoteDLL(pi.dwProcessId, STRINGIZE(RDOC_BASE_NAME) ".dll"); + CloseHandle(hProcess); + hProcess = NULL; + if(loc != 0) +``` + +编辑于 2026-03-25 11:37・重庆 \ No newline at end of file diff --git a/07-Other/AI/AI Agent/Agent.md b/07-Other/AI/AI Agent/Agent.md new file mode 100644 index 0000000..5ef1c8e --- /dev/null +++ b/07-Other/AI/AI Agent/Agent.md @@ -0,0 +1,2 @@ +# 前言 +- [ ] https://www.bilibili.com/video/BV1VzfoBFE5w/?spm_id_from=333.1387.homepage.video_card.click&vd_source=a5a1507212662f8883c096200c37b6bd \ No newline at end of file diff --git a/07-Other/AI/AI Agent/Claude & CodeX.md b/07-Other/AI/AI Agent/Claude & CodeX.md index d438dcf..208bac8 100644 --- a/07-Other/AI/AI Agent/Claude & CodeX.md +++ b/07-Other/AI/AI Agent/Claude & CodeX.md @@ -404,4 +404,5 @@ remaining-fix (4 Agent) 剩余问题并行修复 │ 完成 → 销毁 ``` -每支团队拥有独立的 TaskList 和成员列表，团队之间通过**共享文件系统**传递成果（上一支团队的代码产出是下一支团队的评审/修复输入）。Team Lead 的主会话贯穿全程，是唯一跨团队的持久上下文。 \ No newline at end of file +每支团队拥有独立的 TaskList 和成员列表，团队之间通过**共享文件系统**传递成果（上一支团队的代码产出是下一支团队的评审/修复输入）。Team Lead 的主会话贯穿全程，是唯一跨团队的持久上下文。 + diff --git a/07-Other/AI/AI Agent/ClaudeCode/AI Agent 联调提示词.md b/07-Other/AI/AI Agent/ClaudeCode/AI Agent 联调提示词.md new file mode 100644 index 0000000..773d8f7 --- /dev/null +++ b/07-Other/AI/AI Agent/ClaudeCode/AI Agent 联调提示词.md @@ -0,0 +1,42 @@ +```markdown +──────────────── +B｜背景 +──────────────── +我是[XX身份，如：老师/作者]，正在进行[XX项目] +我们即将结束当前对话，需要保存完整上下文 + +──────────────── +T｜任务 +──────────────── +在我们继续之前，请先完成以下动作： +生成【记忆胶囊】，记录项目全貌和当前状态 +确保一个全新对话能凭此文档无损接续工作 + +──────────────── +C｜约束 +──────────────── +短句优先，每条1~2句话，动词开头，信息密度最大化 +不确定或未提及的信息，标注【待确认】。 +禁止补充推测、美化或编造内容。 +token意识：区分信息密度，避免废话，但不牺牲关键细节 +总字数控制在2000字以内（约500~1500 tokens） + +输出结构（严格遵守）： +1. 对话主题：正在做什么项目、讨论什么 +2. 关键演化：按"最初想法 → 转折/拆解 → 当前焦点"时间线记录 +3. 核心观点：已达成的关键共识（按时间顺序，≥3条） +4. 进度节点：已完成的阶段 + 当前进度（≥2个） +5. 待办事项：下一步要做什么 + 阻塞项（≥1条） +6. 特殊说明：需注意的细节、约定、偏好， + +输出格式： +输出为一个完整的 Markdown 文档，便于复制保存。 +文件名格式：记忆胶囊-[项目名]-[日期]-[序号].md +（如有文件系统权限，直接保存为文件；否则输出代码块由用户手动保存） + +──────────────── +A｜验收（必须执行） +──────────────── +输出前：逐一核对6大要素是否齐全。 +输出后：标注 ✓完整 / ✗缺项：[原因] +``` \ No newline at end of file diff --git a/07-Other/AI/AI Agent/ClaudeCode/在 GitLab CICD 中部署 Claude Code 自动修复 Issue Bug.md b/07-Other/AI/AI Agent/ClaudeCode/在 GitLab CICD 中部署 Claude Code 自动修复 Issue Bug.md new file mode 100644 index 0000000..98298a2 --- /dev/null +++ b/07-Other/AI/AI Agent/ClaudeCode/在 GitLab CICD 中部署 Claude Code 自动修复 Issue Bug.md @@ -0,0 +1,690 @@ + + +> 本文记录了在 GitLab 项目中集成 Claude Code CLI，实现"给 Issue 打标签即可自动修复 Bug"的完整方案与实践过程。 + +--- + +## 目录 + +- [方案概述](#方案概述) +- [整体架构](#整体架构) +- [前置条件](#前置条件) +- [第一步：配置 CI/CD Variables](#第一步配置-cicd-variables) +- [第二步：创建 Pipeline Trigger Token](#第二步创建-pipeline-trigger-token) +- [第三步：编写 .gitlab-ci.yml](#第三步编写-gitlab-ciyml) + - [Job 1: claude:scan-issues — 扫描 Issue](#job-1-claudescan-issues--扫描-issue) + - [Job 2: claude:fix-issue — 执行修复](#job-2-claudefix-issue--执行修复) +- [第四步：创建定时调度](#第四步创建定时调度) +- [第五步：编写 CLAUDE.md 项目指南](#第五步编写-claudemd-项目指南) +- [使用流程](#使用流程) +- [手动触发脚本](#手动触发脚本) +- [关键设计细节](#关键设计细节) +- [踩坑记录与调试经验](#踩坑记录与调试经验) +- [完整 .gitlab-ci.yml 参考](#完整-gitlab-ciyml-参考) + +--- + +## 方案概述 + +核心思路：利用 GitLab CI/CD 的 **Schedule（定时调度）** + **Trigger（触发器）** 机制，定时扫描带有 `auto-fix` 标签的 Issue，自动启动 Claude Code CLI 分析代码、修复 Bug、提交代码并在 Issue 上回复修复摘要。 + +**一句话流程**：开发者给 Issue 打上 `auto-fix` 标签 → 定时任务自动触发 → Claude Code 读取 Issue、分析代码、实施修复 → 自动 commit & push → 在 Issue 评论中报告结果。 + +--- + +## 整体架构 + +``` +┌─────────────────────────────────────────────────────────────────┐ +│ GitLab 项目 │ +│ │ +│ ┌──────────┐ ┌──────────────────┐ ┌───────────────────┐ │ +│ │ Issue │ │ Schedule (定时) │ │ Trigger Pipeline │ │ +│ │ auto-fix │───▶│ claude:scan-issues│───▶│ claude:fix-issue │ │ +│ │ 标签 │ │ (alpine:3.19) │ │ (node:20) │ │ +│ └──────────┘ └──────────────────┘ └─────────┬─────────┘ │ +│ │ │ +│ ┌───────────▼─────────┐ │ +│ │ Claude Code CLI │ │ +│ │ (npm i -g 安装) │ │ +│ │ │ │ +│ │ 1. 读取 Issue 详情 │ │ +│ │ 2. 分析项目代码 │ │ +│ │ 3. 实施修复 │ │ +│ │ 4. 验证类型检查 │ │ +│ │ 5. 提交 & 推送 │ │ +│ │ 6. 评论 Issue │ │ +│ └─────────────────────┘ │ +└─────────────────────────────────────────────────────────────────┘ +``` + +### 标签状态机 + +Issue 通过标签流转追踪处理状态，确保不会被重复处理： + +``` +auto-fix ──▶ claude-processing ──▶ claude-done +(用户添加) (扫描时切换) (修复完成后设置) +``` + +--- + +## 前置条件 + +| 条件 | 说明 | +|------|------| +| GitLab 实例 | 需要支持 CI/CD Schedules 和 Pipeline Triggers | +| Runner | 可执行 Docker 镜像的 GitLab Runner | +| Anthropic API 访问 | 直接使用 Anthropic API 或通过内部代理 | +| GitLab Personal Access Token | 需要 `api` scope，用于操作 Issue 和推送代码 | + +--- + +## 第一步：配置 CI/CD Variables + +进入 GitLab 项目 → **Settings → CI/CD → Variables**，添加以下变量： + +| 变量名 | 类型 | 说明 | +|--------|------|------| +| `GITLAB_ACCESS_TOKEN` | Masked | Personal Access Token（api scope），扫描 Job 使用 | +| `ANTHROPIC_AUTH_TOKEN` | Masked | Anthropic API Key（或内部代理的 auth token） | +| `TRIGGER_TOKEN` | 见下一步 | Pipeline 触发器 Token | + +> **安全提示**：`GITLAB_ACCESS_TOKEN` 和 `ANTHROPIC_AUTH_TOKEN` 务必勾选 **Masked**，防止在日志中泄露。 + +### 关于 Anthropic API 访问 + +如果你直接使用 Anthropic 官方 API，需要设置： +- `ANTHROPIC_AUTH_TOKEN` = 你的 Anthropic API Key + +如果使用内部代理（如本项目使用 `openai.nie.netease.com`），则在 CI Job 中通过环境变量指定： + +```yaml +variables: + ANTHROPIC_BASE_URL: "https://openai.nie.netease.com" # 内部代理地址 +``` + +--- + +## 第二步：创建 Pipeline Trigger Token + +进入 **Settings → CI/CD → Pipeline trigger tokens**，点击 **Add trigger** 创建一个触发器。 + +创建后会得到一个 Token，将其记录下来。扫描 Job 将用此 Token 触发修复 Pipeline。 + +将该 Token 设置为 CI/CD Variable `TRIGGER_TOKEN`。 + +--- + +## 第三步：编写 .gitlab-ci.yml + +在 `.gitlab-ci.yml` 中添加 `ai_fix` Stage 和两个 Job。 + +### Job 1: claude:scan-issues — 扫描 Issue + +这是一个轻量级 Job，使用 `alpine:3.19` 镜像，只做 API 调用： + +```yaml +stages: + - ai_fix + +claude:scan-issues: + stage: ai_fix + image: alpine:3.19 + before_script: + - apk add --no-cache curl jq + script: + - | + echo "Scanning for Issues with label 'auto-fix'..." + + # 校验必要变量 + for var in GITLAB_ACCESS_TOKEN TRIGGER_TOKEN ANTHROPIC_AUTH_TOKEN; do + eval "val=\$$var" + if [ -z "$val" ]; then + echo "ERROR: $var is not set." + exit 1 + fi + done + + # 查询带 auto-fix 标签的 Issue，排除已处理的 + ISSUES=$(curl -s --header "PRIVATE-TOKEN: $GITLAB_ACCESS_TOKEN" \ + "$CI_API_V4_URL/projects/$CI_PROJECT_ID/issues?labels=auto-fix¬%5Blabels%5D=claude-processing,claude-done&state=opened&per_page=10") + + COUNT=$(echo "$ISSUES" | jq 'length') + echo "Found $COUNT issue(s) with 'auto-fix' label." + + if [ "$COUNT" -eq 0 ] || [ "$COUNT" = "null" ]; then + echo "Nothing to do." + exit 0 + fi + + # 逐个处理 + echo "$ISSUES" | jq -r '.[].iid' | while read -r IID; do + TITLE=$(echo "$ISSUES" | jq -r ".[] | select(.iid == $IID) | .title") + echo ">>> Triggering fix for Issue #${IID}: ${TITLE}" + + # 1) 切换标签: auto-fix → claude-processing + curl -s --request PUT \ + --header "PRIVATE-TOKEN: $GITLAB_ACCESS_TOKEN" \ + --header "Content-Type: application/json" \ + --data "{\"remove_labels\": \"auto-fix\", \"add_labels\": \"claude-processing\"}" \ + "$CI_API_V4_URL/projects/$CI_PROJECT_ID/issues/$IID" > /dev/null + + # 2) 通过 Trigger API 触发修复 Pipeline + curl -s -X POST \ + --form "token=${TRIGGER_TOKEN}" \ + --form "ref=${CI_DEFAULT_BRANCH}" \ + --form "variables[ISSUE_IID]=${IID}" \ + --form "variables[GITLAB_TOKEN]=${GITLAB_ACCESS_TOKEN}" \ + --form "variables[ANTHROPIC_AUTH_TOKEN]=${ANTHROPIC_AUTH_TOKEN}" \ + "https://${CI_SERVER_HOST}/api/v4/projects/${CI_PROJECT_ID}/trigger/pipeline" + done + rules: + - if: '$CI_PIPELINE_SOURCE == "schedule"' # 定时触发 + - if: '$CI_PIPELINE_SOURCE == "web"' # 手动触发 + when: manual + allow_failure: true + timeout: 5m +``` + +**核心逻辑**： +1. 通过 GitLab Issues API 查询 `labels=auto-fix` 且排除 `claude-processing` 和 `claude-done` 的 Issue +2. 对每个 Issue 切换标签（防止重复处理） +3. 通过 Pipeline Trigger API 启动独立的修复 Pipeline，传入 `ISSUE_IID`、`GITLAB_TOKEN`、`ANTHROPIC_AUTH_TOKEN` + +### Job 2: claude:fix-issue — 执行修复 + +这是核心修复 Job，使用 `node:20` 镜像，安装并运行 Claude Code： + +```yaml +claude:fix-issue: + stage: ai_fix + image: node:20 + variables: + GIT_STRATEGY: clone + GIT_DEPTH: 0 # 完整克隆，Claude 需要完整历史 + ANTHROPIC_BASE_URL: "https://api.anthropic.com" # 或内部代理地址 + ANTHROPIC_MODEL: "claude-sonnet-4-6" + DISABLE_AUTOUPDATER: "1" # 禁止 Claude Code 自动更新 + DISABLE_PROMPT_CACHING: "1" + before_script: + - apt-get update && apt-get install -y git curl jq + - npm install -g @anthropic-ai/claude-code + - git config --global user.email "claude-bot@example.com" + - git config --global user.name "Claude AI Bot" + script: + - | + # Step 1: 获取 Issue 详情 + if [ -z "$ISSUE_IID" ]; then + echo "ERROR: ISSUE_IID variable is required." + exit 1 + fi + + ISSUE_JSON=$(curl -s --header "PRIVATE-TOKEN: $GITLAB_TOKEN" \ + "$CI_API_V4_URL/projects/$CI_PROJECT_ID/issues/$ISSUE_IID") + + ISSUE_TITLE=$(echo "$ISSUE_JSON" | jq -r '.title // empty') + ISSUE_DESCRIPTION=$(echo "$ISSUE_JSON" | jq -r '.description // empty') + + if [ -z "$ISSUE_TITLE" ]; then + echo "ERROR: Could not fetch Issue #$ISSUE_IID" + exit 1 + fi + echo "Processing Issue #${ISSUE_IID}: ${ISSUE_TITLE}" + - | + # Step 2: 切换到主分支 + git checkout "$CI_DEFAULT_BRANCH" + git pull origin "$CI_DEFAULT_BRANCH" + - | + # Step 3: 运行 Claude Code + export ANTHROPIC_API_KEY="${ANTHROPIC_AUTH_TOKEN}" + + PROMPT="你是一个代码修复助手。请分析并修复以下 GitLab Issue： + + ## Issue #${ISSUE_IID}: ${ISSUE_TITLE} + + ${ISSUE_DESCRIPTION} + + 请： + 1. 分析项目代码，定位问题根因 + 2. 实施修复 + 3. 确保代码能通过类型检查（TypeScript 项目运行 npx tsc --noEmit） + 4. 用中文输出修复摘要（包括修改了哪些文件、改了什么、为什么这样改） + + 项目根目录已准备就绪。" + + RESULT=$(claude -p "$PROMPT" \ + --bare \ + --permission-mode acceptEdits \ + --allowedTools "Bash,Read,Edit,Write,Glob,Grep" \ + --max-turns 30 \ + --output-format text \ + 2>&1) || true + + echo "$RESULT" > repair_summary.txt + - | + # Step 4: 提交并推送 + git add -A + git reset -- repair_summary.txt claude_stderr.txt 2>/dev/null || true + + if git diff --cached --quiet; then + echo "No file changes detected." + COMMIT_STATUS="no_changes" + else + git commit -m "fix(auto): resolve Issue #${ISSUE_IID} - ${ISSUE_TITLE} [skip ci]" + git push "https://oauth2:${GITLAB_TOKEN}@${CI_SERVER_HOST}/${CI_PROJECT_PATH}.git" \ + HEAD:"$CI_DEFAULT_BRANCH" + COMMIT_STATUS="pushed" + fi + - | + # Step 5: 在 Issue 上发表评论 + SUMMARY=$(cat repair_summary.txt | head -200 | \ + sed 's/\\/\\\\/g' | sed 's/"/\\"/g' | sed ':a;N;$!ba;s/\n/\\n/g') + + if [ "$COMMIT_STATUS" = "pushed" ]; then + BODY="## ✅ Claude Code 自动修复完成\n\n修复已推送到 \`${CI_DEFAULT_BRANCH}\`。\n\nPipeline: ${CI_PIPELINE_URL}\n\n
修复详情\n\n\`\`\`\n${SUMMARY}\n\`\`\`\n
" + else + BODY="## ⚠️ Claude Code 分析完成\n\n未检测到需要变更的文件。\n\nPipeline: ${CI_PIPELINE_URL}\n\n
分析详情\n\n\`\`\`\n${SUMMARY}\n\`\`\`\n
" + fi + + curl -s --request POST \ + --header "PRIVATE-TOKEN: $GITLAB_TOKEN" \ + --header "Content-Type: application/json" \ + --data "{\"body\": \"${BODY}\"}" \ + "$CI_API_V4_URL/projects/$CI_PROJECT_ID/issues/$ISSUE_IID/notes" + - | + # Step 6: 更新标签为 claude-done + curl -s --request PUT \ + --header "PRIVATE-TOKEN: $GITLAB_TOKEN" \ + --header "Content-Type: application/json" \ + --data "{\"remove_labels\": \"claude-processing\", \"add_labels\": \"claude-done\"}" \ + "$CI_API_V4_URL/projects/$CI_PROJECT_ID/issues/$ISSUE_IID" > /dev/null + rules: + - if: '$CI_PIPELINE_SOURCE == "trigger" && $ISSUE_IID' # 被 scan-issues 触发 + - if: '$CI_PIPELINE_SOURCE == "web" && $ISSUE_IID' # 手动触发（需提供 ISSUE_IID） + when: manual + allow_failure: true + timeout: 30m +``` + +**Claude Code CLI 关键参数说明**： + +| 参数 | 说明 | +|------|------| +| `-p "$PROMPT"` | 非交互模式，直接传入提示词 | +| `--bare` | 精简输出，去掉装饰性格式 | +| `--permission-mode acceptEdits` | 自动接受文件编辑（CI 环境必需） | +| `--allowedTools "Bash,Read,Edit,Write,Glob,Grep"` | 限制可用工具，仅保留文件系统操作 | +| `--max-turns 30` | 最大对话轮次，防止无限循环 | +| `--output-format text` | 纯文本输出 | + +--- + +## 第四步：创建定时调度 + +进入 **CI/CD → Schedules**，创建定时任务： + +| 配置项 | 建议值 | 说明 | +|--------|--------|------| +| Description | Auto-fix Issue Scanner | 任务描述 | +| Interval Pattern | `*/5 * * * *` | 每 5 分钟扫描一次 | +| Cron Timezone | 你的时区 | 例如 Asia/Shanghai | +| Target branch | `main` | 主分支 | + +保存后，Schedule 会按设定频率运行 `claude:scan-issues` Job。 + +--- + +## 第五步：编写 CLAUDE.md 项目指南 + +在项目根目录创建 `CLAUDE.md`，Claude Code 在 CI 中运行时会自动读取此文件作为上下文指导： + +```markdown +# Project Guidelines + +## 项目结构 +- `src/` — 主要源码 +- `tests/` — 测试文件 + +## 开发规范 +- 修改 TypeScript 代码后运行 `npx tsc --noEmit` 验证类型 +- 不要修改 `.gitlab-ci.yml`（除非 Issue 明确要求） + +## 关键技术 +- 描述项目使用的框架、库、协议等 +``` + +这个文件非常重要，它相当于给 Claude Code 提供了"项目知识"，让 AI 了解项目结构和约束，从而做出更合理的修复。 + +--- + +## 使用流程 + +### 自动模式 + +1. 在 GitLab 上创建一个 Issue，描述清楚 Bug 的现象、复现步骤、期望行为 +2. 给该 Issue 添加标签 **`auto-fix`** +3. 等待定时调度运行（默认每 5 分钟扫描一次） +4. 标签自动变为 `claude-processing`（正在处理） +5. 修复完成后标签变为 `claude-done`，Issue 评论中会出现修复摘要 +6. 如果有代码变更，commit 会自动推送到 `main` 分支 + +### 手动模式（命令行触发） + +项目提供了便捷脚本 `scripts/trigger-fix.sh`： + +```bash +# 设置环境变量 +export TRIGGER_TOKEN="你的 Trigger Token" +export PROJECT_ID="项目 ID" # Settings → General 可查看 +export GITLAB_TOKEN="你的 PAT" +export ANTHROPIC_AUTH_TOKEN="你的 API Key" + +# 触发修复 +./scripts/trigger-fix.sh 42 # 42 是 Issue 的 IID +``` + +脚本内容很简洁，直接调用 GitLab Pipeline Trigger API： + +```bash +curl -X POST \ + --form "token=${TRIGGER_TOKEN}" \ + --form "ref=main" \ + --form "variables[ISSUE_IID]=${ISSUE_IID}" \ + --form "variables[GITLAB_TOKEN]=${GITLAB_TOKEN}" \ + --form "variables[ANTHROPIC_AUTH_TOKEN]=${ANTHROPIC_AUTH_TOKEN}" \ + "https://${GITLAB_HOST}/api/v4/projects/${PROJECT_ID}/trigger/pipeline" +``` + +--- + +## 关键设计细节 + +### 1. 为什么用两个 Job + Trigger 而非一个 Job？ + +- **隔离性**：扫描和修复在不同 Pipeline 中运行，一个 Issue 修复失败不影响其他 Issue +- **并行**：多个 Issue 可以同时被触发修复（各自独立的 Pipeline） +- **可追溯**：每个修复有独立的 Pipeline 记录 + +### 2. 标签状态机防重复 + +``` +auto-fix → claude-processing → claude-done +``` + +- 扫描 Query 排除 `claude-processing` 和 `claude-done` +- 保证每个 Issue **只被处理一次** + +### 3. `[skip ci]` 避免递归触发 + +commit message 中包含 `[skip ci]`，防止修复 commit 触发新的 Pipeline，形成无限循环。 + +### 4. 临时文件排除 + +`repair_summary.txt` 和 `claude_stderr.txt` 通过 `git reset` 排除暂存区，通过 `.gitignore` 排除版本控制： + +```gitignore +repair_summary.txt +claude_stderr.txt +``` + +### 5. Upload Job 与 Fix Job 互不干扰 + +Upload Job 的 rules 中明确排除 `schedule` 和 `trigger` 来源： + +```yaml +rules: + - if: '$CI_PIPELINE_SOURCE == "schedule"' + when: never + - if: '$CI_PIPELINE_SOURCE == "trigger"' + when: never +``` + +### 6. 完整克隆 + +```yaml +variables: + GIT_STRATEGY: clone + GIT_DEPTH: 0 +``` + +Claude Code 需要完整的仓库来分析代码，不能使用浅克隆。 + +--- + +## 踩坑记录与调试经验 + +### 1. Anthropic API 配置 + +**问题**：Claude Code CLI 的环境变量名是 `ANTHROPIC_API_KEY`，但 CI 变量传递时用了别的名字。 + +**解决**：在 script 中显式映射： + +```bash +export ANTHROPIC_API_KEY="${ANTHROPIC_AUTH_TOKEN}" +``` + +如果使用内部代理，还需设置 `ANTHROPIC_BASE_URL`。额外的 `ANTHROPIC_MODEL` 和 `ANTHROPIC_CUSTOM_MODEL_OPTION` 变量用于指定模型。 + +### 2. Claude Code 自动更新 + +**问题**：CI 环境中 Claude Code 尝试自动更新，导致超时或失败。 + +**解决**：设置环境变量禁用： + +```yaml +DISABLE_AUTOUPDATER: "1" +``` + +### 3. Issue 查询排除已处理的 Issue + +**问题**：早期版本未排除 `claude-processing`/`claude-done`，导致同一 Issue 被反复触发。 + +**解决**：使用 GitLab API 的 `not[labels]` 参数： + +``` +?labels=auto-fix¬%5Blabels%5D=claude-processing,claude-done&state=opened +``` + +### 4. Git Push 认证 + +**问题**：CI 环境默认的 git remote 可能不支持 push。 + +**解决**：使用 OAuth2 Token 方式构建 push URL： + +```bash +git push "https://oauth2:${GITLAB_TOKEN}@${CI_SERVER_HOST}/${CI_PROJECT_PATH}.git" HEAD:main +``` + +### 5. 中文输出 + +**问题**：Claude Code 默认可能以英文回复。 + +**解决**：在 Prompt 中明确要求 "请使用中文回复"，确保修复摘要和 Issue 评论为中文。 + +### 6. 评论中的特殊字符转义 + +**问题**：Claude 的输出可能包含 `"`、`\`、换行等字符，直接放入 JSON 会破坏格式。 + +**解决**：通过 `sed` 链式转义： + +```bash +SUMMARY=$(cat repair_summary.txt | head -200 | \ + sed 's/\\/\\\\/g' | sed 's/"/\\"/g' | sed ':a;N;$!ba;s/\n/\\n/g') +``` + +--- + +## 完整 .gitlab-ci.yml 参考 + +以下是 `ai_fix` Stage 的完整配置，可直接复制到你的 `.gitlab-ci.yml` 中： + +```yaml +stages: + # ... 你的其他 stages + - ai_fix + +# ============================================================ +# AI Fix Stage - Auto-fix GitLab Issues with Claude Code +# ============================================================ +# Required CI/CD Variables: +# - GITLAB_ACCESS_TOKEN: Personal Access Token (api scope) +# - ANTHROPIC_AUTH_TOKEN: Anthropic API Key +# - TRIGGER_TOKEN: Pipeline trigger token +# +# Setup: +# 1. Create a Schedule (CI/CD → Schedules), e.g. every 5 min +# 2. Add label "auto-fix" to an Issue → auto triggers fix + +claude:scan-issues: + stage: ai_fix + image: alpine:3.19 + before_script: + - apk add --no-cache curl jq + script: + - | + for var in GITLAB_ACCESS_TOKEN TRIGGER_TOKEN ANTHROPIC_AUTH_TOKEN; do + eval "val=\$$var" + if [ -z "$val" ]; then echo "ERROR: $var not set."; exit 1; fi + done + + ISSUES=$(curl -s --header "PRIVATE-TOKEN: $GITLAB_ACCESS_TOKEN" \ + "$CI_API_V4_URL/projects/$CI_PROJECT_ID/issues?labels=auto-fix¬%5Blabels%5D=claude-processing,claude-done&state=opened&per_page=10") + + COUNT=$(echo "$ISSUES" | jq 'length') + echo "Found $COUNT issue(s)." + [ "$COUNT" -eq 0 ] || [ "$COUNT" = "null" ] && exit 0 + + echo "$ISSUES" | jq -r '.[].iid' | while read -r IID; do + TITLE=$(echo "$ISSUES" | jq -r ".[] | select(.iid == $IID) | .title") + echo ">>> Issue #${IID}: ${TITLE}" + + curl -s --request PUT \ + --header "PRIVATE-TOKEN: $GITLAB_ACCESS_TOKEN" \ + --header "Content-Type: application/json" \ + --data "{\"remove_labels\": \"auto-fix\", \"add_labels\": \"claude-processing\"}" \ + "$CI_API_V4_URL/projects/$CI_PROJECT_ID/issues/$IID" > /dev/null + + curl -s -X POST \ + --form "token=${TRIGGER_TOKEN}" \ + --form "ref=${CI_DEFAULT_BRANCH}" \ + --form "variables[ISSUE_IID]=${IID}" \ + --form "variables[GITLAB_TOKEN]=${GITLAB_ACCESS_TOKEN}" \ + --form "variables[ANTHROPIC_AUTH_TOKEN]=${ANTHROPIC_AUTH_TOKEN}" \ + "https://${CI_SERVER_HOST}/api/v4/projects/${CI_PROJECT_ID}/trigger/pipeline" + done + rules: + - if: '$CI_PIPELINE_SOURCE == "schedule"' + - if: '$CI_PIPELINE_SOURCE == "web"' + when: manual + allow_failure: true + timeout: 5m + +claude:fix-issue: + stage: ai_fix + image: node:20 + variables: + GIT_STRATEGY: clone + GIT_DEPTH: 0 + ANTHROPIC_BASE_URL: "https://api.anthropic.com" + ANTHROPIC_MODEL: "claude-sonnet-4-6" + DISABLE_AUTOUPDATER: "1" + DISABLE_PROMPT_CACHING: "1" + before_script: + - apt-get update && apt-get install -y git curl jq + - npm install -g @anthropic-ai/claude-code + - git config --global user.email "claude-bot@example.com" + - git config --global user.name "Claude AI Bot" + script: + - | + [ -z "$ISSUE_IID" ] && echo "ERROR: ISSUE_IID required." && exit 1 + [ -z "$GITLAB_TOKEN" ] && echo "ERROR: GITLAB_TOKEN required." && exit 1 + + ISSUE_JSON=$(curl -s --header "PRIVATE-TOKEN: $GITLAB_TOKEN" \ + "$CI_API_V4_URL/projects/$CI_PROJECT_ID/issues/$ISSUE_IID") + ISSUE_TITLE=$(echo "$ISSUE_JSON" | jq -r '.title // empty') + ISSUE_DESCRIPTION=$(echo "$ISSUE_JSON" | jq -r '.description // empty') + [ -z "$ISSUE_TITLE" ] && echo "ERROR: Cannot fetch Issue" && exit 1 + - | + git checkout "$CI_DEFAULT_BRANCH" && git pull origin "$CI_DEFAULT_BRANCH" + - | + export ANTHROPIC_API_KEY="${ANTHROPIC_AUTH_TOKEN}" + + PROMPT="你是一个代码修复助手。请使用中文回复。请分析并修复以下 GitLab Issue： + + ## Issue #${ISSUE_IID}: ${ISSUE_TITLE} + + ${ISSUE_DESCRIPTION} + + 请： + 1. 分析项目代码，定位问题根因 + 2. 实施修复 + 3. 确保代码能通过类型检查（TypeScript 项目运行 npx tsc --noEmit） + 4. 用中文输出修复摘要 + + 项目根目录已准备就绪。" + + RESULT=$(claude -p "$PROMPT" \ + --bare \ + --permission-mode acceptEdits \ + --allowedTools "Bash,Read,Edit,Write,Glob,Grep" \ + --max-turns 30 \ + --output-format text \ + 2>&1) || true + + echo "$RESULT" > repair_summary.txt + - | + git add -A + git reset -- repair_summary.txt claude_stderr.txt 2>/dev/null || true + if git diff --cached --quiet; then + COMMIT_STATUS="no_changes" + else + git commit -m "fix(auto): resolve Issue #${ISSUE_IID} - ${ISSUE_TITLE} [skip ci]" + git push "https://oauth2:${GITLAB_TOKEN}@${CI_SERVER_HOST}/${CI_PROJECT_PATH}.git" \ + HEAD:"$CI_DEFAULT_BRANCH" + COMMIT_STATUS="pushed" + fi + - | + SUMMARY=$(cat repair_summary.txt | head -200 | \ + sed 's/\\/\\\\/g' | sed 's/"/\\"/g' | sed ':a;N;$!ba;s/\n/\\n/g') + + if [ "$COMMIT_STATUS" = "pushed" ]; then + BODY="## ✅ Claude Code 自动修复完成\n\n修复已推送到 \`${CI_DEFAULT_BRANCH}\`。\nPipeline: ${CI_PIPELINE_URL}\n\n
修复详情\n\n\`\`\`\n${SUMMARY}\n\`\`\`\n
" + else + BODY="## ⚠️ Claude Code 分析完成\n\n未检测到需要变更的文件。\nPipeline: ${CI_PIPELINE_URL}\n\n
分析详情\n\n\`\`\`\n${SUMMARY}\n\`\`\`\n
" + fi + + curl -s --request POST \ + --header "PRIVATE-TOKEN: $GITLAB_TOKEN" \ + --header "Content-Type: application/json" \ + --data "{\"body\": \"${BODY}\"}" \ + "$CI_API_V4_URL/projects/$CI_PROJECT_ID/issues/$ISSUE_IID/notes" + - | + curl -s --request PUT \ + --header "PRIVATE-TOKEN: $GITLAB_TOKEN" \ + --header "Content-Type: application/json" \ + --data "{\"remove_labels\": \"claude-processing\", \"add_labels\": \"claude-done\"}" \ + "$CI_API_V4_URL/projects/$CI_PROJECT_ID/issues/$ISSUE_IID" > /dev/null + rules: + - if: '$CI_PIPELINE_SOURCE == "trigger" && $ISSUE_IID' + - if: '$CI_PIPELINE_SOURCE == "web" && $ISSUE_IID' + when: manual + allow_failure: true + timeout: 30m +``` + +--- + +## 总结 + +| 特性 | 实现方式 | +|------|----------| +| 触发机制 | GitLab Schedule 定时扫描 + Pipeline Trigger 触发修复 | +| AI 引擎 | Claude Code CLI (`@anthropic-ai/claude-code`) | +| 权限控制 | `--permission-mode acceptEdits` + `--allowedTools` 白名单 | +| 防重复 | 标签状态机 `auto-fix → claude-processing → claude-done` | +| 防递归 | commit message 中 `[skip ci]` | +| 结果反馈 | 自动在 Issue 上发表评论，含修复摘要 | +| 项目上下文 | `CLAUDE.md` 项目指南文件 | + +这套方案已在实际项目中运行，成功自动修复了多个 Bug Issue。核心优势是**零人工介入**——开发者只需写好 Issue 描述并打上标签，AI 自动完成从分析到修复到提交的全流程。 diff --git a/07-Other/AI/AI Agent/MCP & Skill.md b/07-Other/AI/AI Agent/MCP & Skill.md index 93cf610..3a62654 100644 --- a/07-Other/AI/AI Agent/MCP & Skill.md +++ b/07-Other/AI/AI Agent/MCP & Skill.md @@ -4,21 +4,17 @@ # MCP - WY MCP市场:https://modelspace.netease.com/mcphub - DeepWiki MCP - - POPO MCP - - 易协作 MCP Server -- OpenClaw:https://clawhub.ai/ + - ~~POPO MCP~~ + - ~~易协作 MCP Server~~ - 开发类 - - Chrome DevTools MCP。 + - [ ] **Chrome DevTools MCP**。 - BrowerMCP：Chrome浏览器专用前端视觉MCP。需要在Chrome安装对应插件。 - - 搜索类 - **DuckDuckGo Search**：无需 API Key 的隐私保护搜索，支持网页和新闻检索。`claude mcp add duckduckgo-search -- npx -y duckduckgo-mcp-server` - Sacred Scriptures：宗教典籍（如大藏经）精准检索。 `claude mcp add sacred-scriptures -- npx -y @traves-theberge/sacred-scriptures-mcp` - **Open Library**：全球书籍元数据与原著检索。 `claude mcp add open-library -- npx -y @8ensmith/mcp-open-library` - **Paper Search**：现代哲学与认知科学论文检索。 `claude mcp add paper-search -- npx -y @openags/paper-search-mcp` - OpenEnded Philosophy：非公理化逻辑推演与哲学思辨增强。 `claude mcp add openended-philosophy -- npx -y @openended/philosophy-mcp` -- 存储类 - - **Mem0 (OpenMemory)**：用户观点长期记忆与思想进化追踪。 `claude mcp add mem0 -- npx -y @mem0/mcp-server` - 笔记类 - Obsidian MCP：本地哲学笔记库同步与知识图谱构建。 `claude mcp add obsidian -- npx -y @obsidian-mcp/server` ## MCP案例代码 @@ -371,13 +367,13 @@ app.use("/mcp", async (c, next) => { 3. https://skills.sh/ 1. https://skills.sh/hairyf/skills/create-skill-from-repo +- MCP + - [x] **Chrome DevTools MCP**。 - 基础Skill - [x] ***find-skills***：在20万+Skills里自动找到所需工具。 #导航员 - - [ ] skill-creator：把你的工作流打包成可复用能力。 #工厂 + - [x] skill-creator：把你的工作流打包成可复用能力。 #工厂 - [ ] mcp-builder：搭建服务器，连接私人数据和外部工具。 #桥梁 - - [x] using-superpowers：强制Agent真正发挥高级能力。 #优化器 - - [ ] subagent-driven-dev：把子任务委派给其他AI并审核。 #管理者 - - [ ] agent-tools：数字瑞士军刀，处理日常事务。 #工具箱 + - [ ] ~~agent-tools~~：数字瑞士军刀，处理日常事务。 #工具箱 - 搜索相关 - [x] GitHub 官方 MCP:claude mcp add github -- npx -y @modelcontextprotocol/server-github - [x] 搜索引擎类：输出的结果质量以及Token消耗量都不理想。 @@ -389,11 +385,16 @@ app.use("/mcp", async (c, next) => { - https://skills.sh/tavily-ai/skills/research: `npx skills add https://github.com/tavily-ai/skills --skill research` - https://skills.sh/tavily-ai/skills/extract: `npx skills add https://github.com/tavily-ai/skills --skill extract` - https://skills.sh/veithly/tavily-search/tavily-search: `npx skills add https://github.com/veithly/tavily-search --skill tavily-search` +- 编程类 + - [x] ***using-superpowers***：强制Agent真正发挥高级能力。 #优化器 + - [x] acpx：外部工具桥接器，可以用来控制ClaudeCode等编程工具，还需要额外配置。 #编程 +- 沟通类 + - [x] [openclaw-a2a-gateway](https://github.com/win4r/openclaw-a2a-gateway):多物理实例Agent沟通工具，**缺点：无有上一次对话的上下文**。 - 进阶工具 - - [ ] brainstorming：一个关键词生成几十个独特角度和多种假设场景。 #创意生成器 + - [ ] brainstorming：一个关键词生成几十个独特角度和多种假设场景。 #0创意生成器 - [ ] copywriting：优化表达、打磨语调，不依赖老掉牙的一键生成模板。 #文字工匠 - [ ] reflection：增加自我纠正循环，让Agent审核并在过程中修复错误。 #秘密武器 - - [ ] writing-plans：先构建结构大纲，确保长文不跑偏。 #架构师 + - [ ] ~~writing-plans~~：先构建结构大纲，确保长文不跑偏。 #架构师 - [ ] social-content：为X、TikTok、小红书专属优化，止住下滑的手指。 #运营经理 - [ ] marketing-ideas：生成病毒式噱头和活动概念，远超简单广告水平。 #创意总监 - [ ] copy-editing：打磨语调、收紧流程，保留你独特的人性声音。 #高级编辑 diff --git a/07-Other/AI/AI Agent/NeoX/MatrixAITA-XEditor-Messiah.md b/07-Other/AI/AI Agent/NeoX/MatrixAITA-XEditor-Messiah.md new file mode 100644 index 0000000..8cf1bcb --- /dev/null +++ b/07-Other/AI/AI Agent/NeoX/MatrixAITA-XEditor-Messiah.md @@ -0,0 +1,51 @@ +--- +title: 未命名 +date: 2026-04-02 17:18:06 +excerpt: +tags: +rating: ⭐ +status: inprogress +destination: +share: false +obsidianUIMode: source +--- + +NeoX与UnrealEngine（简称UE）是2个游戏引擎，XEditor是NeoX引擎的编辑器，我希望能编写一个Skill让Agent同时操作这2个引擎进行一些资产优化工作。 + +## 前置检查工作。 +1. 用户输入NeoX目录与UnrealEngine目录。 +2. Agent补充绝对目录并验证Mcp可用后提示用户Mcp已经可以工作了。 + +## 项目情况 +1. NeoX目录美术表路径：./Doc/X_导入数据/超炫酷3D鹈鹕镇 + 1. 场景表.xlsx + 2. 模型表.xlsx + 1. 场景模型 + 2. 角色模型：无需关注 + 3. 3D面片：无需关注 + 4. 模型ID与分类： + 3. 动作表.xlsx + 4. 模型动画表.xlsx + 5. 特效表.xlsx +2. NeoX目录策划表：./Doc/X_导入数据/精灵们今天非常开心！ + 1. 道具表.xlsx：每个子表中的模型标号对应模型表中模型的ID。 +3. NeoX资产路径： + 1. UE资产导入后的：res\ue_export_common + +# 资产优化操作步骤说明 +1. 控制XEditor Mcp + 1. 检索模型表、场景表。 + 1. 模型表 查询 场景模型子表内的所有的模型。 + 2. 场景表 遍历所有表中场景所使用的模型。 + 2. 分别对这2个表引用的模型资产进行检查。 + 1. 模型信息：模型面数、模型LOD 数量 级别 ScreenSize 或 CameraDistance 信息、模型数量。 + 2. 模型所用材质的贴图信息：贴图分辨率。 + 3. 检查逻辑可以参考： D:\Project\H78_New\.claude\skills\item-resource-analyzer\SKILL.md + 3. 在NeoX目录的./Outputs 先输入2个报告文件 日期戳-场景报告.xlsx、日期戳-模型表报告.xlsx，模型项需要去重。 + 1. 模型表报告需要根据道具表中对模型分类，将信息分到对应子表中（子表与道具表中的子表分类同名） +2. 控制UE Mcp 在UE中寻找对应的模型资产。 + 1. XEditor路径：ue_export_common/ProjectCoral/Art/Debris/Ores/SM_CopperOreVein.gim；UE路径：/Game/ProjectCoral/Art/Debris/Ores/SM_CopperOreVein.gim。 + 2. 提示用户哪些模型XEditor里有，但UE没有，需要用户手动导入到UE，再进行处理。 +3. 新建一个带有基础光照的关卡，将这些模型都放到关卡中。 + 1. 模型按照BoundingBox大小进行排序。 + 2. 模型按照BoundingBox调整间隔，BoundingBox为1m的，间距1M，BoundingBox为10M的，间距10M。 \ No newline at end of file diff --git a/07-Other/AI/AI Agent/NeoX/资产分析提示词.md b/07-Other/AI/AI Agent/NeoX/资产分析提示词.md new file mode 100644 index 0000000..73b1cca --- /dev/null +++ b/07-Other/AI/AI Agent/NeoX/资产分析提示词.md @@ -0,0 +1,23 @@ + +# 0 +整理当前项目组所有贴图信息，信息包括贴图分辨率，体积，相对路径，贴图名字，按照体积从大到小，整理成一个excel 你直接在NXAI对话框里输入这个就能得到有信息的excel了。 + + +# 1 +请分析./scene/下所有场景文件，对每个场景分别进行分析，分析所引用的模型资产以及模型材质所引用的贴图，主要有模型面数、材质数目、所用材质引用贴图的分辨率。 + +要求： +1. 按照模型面数进行主排序。次级排序使用材质数目。 +2. 贴图分辨率超过1024 将该单元格标注为黄色，超过2048标注为红色。 + +分别出一个excel格式的分析文件。 + + +# 2 +请帮我revert掉svn中./res/目录下所有针对贴图与材质的修改，只保留LOD相关的修改（带有_lod、_lod1、_lod2、_lod3后缀的gim以及这个gim的同名json与mesh文件）。 + + +./Doc\X_导入数据\超炫酷3D鹈鹕镇\ 模型表.xlsx 以及 场景表.xlsx中所有场景引用的模型， + +将LOD级别数目大于等于4的，将最后一级设置为隐藏。 +LOD等于3的，添加一个级别设置为隐藏。 \ No newline at end of file diff --git a/07-Other/AI/AI Agent/OpenClaw.md b/07-Other/AI/AI Agent/OpenClaw.md index d543003..ce66c58 100644 --- a/07-Other/AI/AI Agent/OpenClaw.md +++ b/07-Other/AI/AI Agent/OpenClaw.md @@ -26,117 +26,164 @@ # OpenClaw架构构思 https://clawhub.ai/ Skill推荐： - Common - - [x] ***find-skills***：在20万+Skills里自动找到所需工具。 + - [x] ***find-skills***：在20万+Skills里自动找到所需工具。 #导航员 + - [x] skill-creator：把你的工作流打包成可复用能力。 #工厂 - [x] ***self-improving-agent***： 记录经验教训、错误和纠正措施，以实现持续改进。 - [x] Summarize：使用 summarize CLI 对 URL 或文件进行汇总（网页、PDF、图像、音频、YouTube）。 +- 文档类 + - [x] pdf：合并、拆分、提取复杂PDF，无手动头疼。 #文档专家 + - [x] pptx：生成完整专业幻灯片，再也不用移动文本框。 #演示专家 + - [x] docx：创建结构化Word文档，直接用于官方用途。 #文书 + - [x] xlsx：带复杂公式和图表的Excel文件。 #数据分析师 +- 搜索相关 + - [x] GitHub 官方 MCP:claude mcp add github -- npx -y @modelcontextprotocol/server-github + - [x] 搜索引擎类：输出的结果质量以及Token消耗量都不理想。 + - jina-reader: + - https://clawhub.ai/ericsantos/jina-reader + - https://skills.sh/sundial-org/awesome-openclaw-skills/jina-reader + - Tavily + - https://skills.sh/tavily-ai/skills/search: `npx skills add https://github.com/tavily-ai/skills --skill search` + - https://skills.sh/tavily-ai/skills/research: `npx skills add https://github.com/tavily-ai/skills --skill research` + - https://skills.sh/tavily-ai/skills/extract: `npx skills add https://github.com/tavily-ai/skills --skill extract` + - https://skills.sh/veithly/tavily-search/tavily-search: `npx skills add https://github.com/veithly/tavily-search --skill tavily-search` +- 编程类 + - [x] ***using-superpowers***：强制Agent真正发挥高级能力。 #优化器 + - [x] **acpx**：外部工具桥接器，可以用来控制ClaudeCode等编程工具，还需要额外配置。 #编程 + - 优化类 + - [ ] [openclaw-workspace](https://github.com/win4r/openclaw-workspace)：优化OpenClaw工作区。提示词：帮我用 openclaw-workspace 这个 skill 做一次 workspace审计/精简 AGENTS.md/ 优化 TOOLS.md"等。可以创建定时任务让他每周执行。 +- 控制中心(都处于质量存疑阶段) + - [ ] https://github.com/TianyiDataScience/openclaw-control-center + - [ ] https://github.com/abhi1693/openclaw-mission-control ## Agent & Memory 在默认工作区可以到以下文件，这些都是Agent提示词的主程部分： -| **文件名** | **角色定位** | **详细作用描述** | -| ---------------- | ------------- | --------------------------------------------------------- | -| **Bootstrap.md** | **引导程序/总纲** | 整个系统的入口。它负责协调其他模块，定义系统初始化的逻辑，并告诉 LLM 如何“读取”这一系列文件。 | -| **SYSTEM.md** | **物理规则/底层协议** | 定义 AI 的基本运行准则。包含技术约束、输出格式要求（如必须使用 JSON）、安全边界和思考框架。 | -| **IDENTITY.md** | **身份设定** | 定义“我是谁”。包含姓名、职业背景、专业领域和语气风格（Tone of Voice）。这是 AI 表层人格的来源。 | -| **SOUL.md** | **核心价值观/灵魂** | 定义“我的底层逻辑”。包含道德准则、动机、偏好、情绪反应模型以及对待冲突的态度。它比 Identity 更深层。 | -| **USER.md** | **用户画像/上下文** | 记录“你是谁”。包含用户偏好、当前任务背景、历史互动关键点。确保 AI 的响应具有针对性。 | -| **TOOLS.md** | **能力清单/技能树** | 定义 AI 可以调用的外部函数或工具（如搜索、绘图、计算）。明确调用参数和返回格式。 | -| **AGENTS.md** | **协作协议** | 定义多智能体协作逻辑。如果 AI 需要召唤“副手”或与其他代理交互，这里规定了沟通协议。 | +| 文件 | 用途 | 加载时机 | 子 Agent 可见？ | +| ---------------------- | ------------------------------------- | ----------------------- | ----------- | +| `AGENTS.md` | 启动序列、操作清单、行为规则 | 每次轮次（所有 Agent） | 是 | +| `SOUL.md` | 人格、语气、价值观、连续性哲学 | 每次轮次（所有 Agent） | 是 | +| `TOOLS.md` | 环境特定信息（SSH、TTS、摄像头、设备） | 每次轮次（主 Agent + 子 Agent） | 是 | +| `USER.md` | 用户画像、偏好、关系背景 | 每次轮次（仅主会话） | 否 | +| `IDENTITY.md` | 名称、Emoji、头像、自我描述 | 每次轮次 | 是 | +| `HEARTBEAT.md` | 周期性检查任务和健康例程 | 每次心跳轮次 | 视情况而定 | +| `BOOT.md` | 启动时执行的操作（需要 `hooks.internal.enabled`） | 网关启动时 | 否 | +| `BOOTSTRAP.md` | 首次初始化脚本——用完即删 | 仅新工作区 | 否 | +| `MEMORY.md` | 长期精华事实与铁律规则 | 仅主会话 | **永不** | +| `memory/YYYY-MM-DD.md` | 每日会话日志 | 按 AGENTS.md 启动序列加载 | 否 | +| `checklists/*.md` | 高风险操作的逐步指南 | 按需加载（从 AGENTS.md 引用） | 否 | +### 各文件详解 +#### AGENTS.md — 操作手册 +这是每次会话中最先塑造 Agent 行为的文件（基础系统提示词之后）。它包含： +- **启动序列**：有序列出需要在会话开始时读取的文件（SOUL → USER → MEMORY → 日志） +- **清单路由表**：高风险操作 → 对应清单文件路径的映射 +- **安全规则**：哪些操作需要确认、哪些可以自主执行 +- **群聊规则**：在群聊中不应分享什么 +**注意**：AGENTS.md 是规程文件，不是身份文件。人格和价值观属于 SOUL.md。 + +#### SOUL.md — 灵魂 +用第二人称书写（"你不是一个聊天机器人，你正在成为某个人"），Agent 读取后将其内化为自我描述。 +包含：核心价值观、边界与底线、语气风格、关于连续性的哲学（每次会话都是全新开始，工作区文件就是记忆）。 + +#### TOOLS.md — 本地环境备忘录 +这是工作区中最容易被误用的文件。它应该是**当前机器的环境专属速查表**：SSH 主机、TTS 声音 ID、摄像头设备名称等。 +子 Agent 也会收到此文件——这是它们唯一的环境知识来源。请保持简洁，50 行以内为佳。 + +#### USER.md — 用户画像 +包含影响每次对话的人物相关事实：姓名、时区、语言偏好、沟通风格。 +仅在主会话中加载——绝不在群聊或子 Agent 会话中加载。 + +#### MEMORY.md — 铁律规则 +只保存"遗忘了就会出严重问题"的规则。每条规则要短且原子化，具有明确的行动指导意义。 +定期精炼（每月一次）。已经几个月没有出过问题的规则，可以考虑迁移到技能的 `SKILL.md` 文件中（更合适的归宿）。 + +#### checklists / * .md — 操作清单 +高风险操作（部署、网关重启、配置变更）的逐步指南。Agent 执行操作前主动读取对应清单。 + **正确模式** ：AGENTS.md 只保留一行路由表条目，完整清单放在 `checklists/` 目录中（按需加载，不占用每轮 Token 预算）。 --- -## 2. 调用逻辑与顺序 - - - -**逻辑顺序如下：** -1. **加载 `Bootstrap.md`**：确定系统引导协议，LLM 开始意识到自己是一个遵循 OpenClaw 协议的 Agent。 -2. **注入 `SYSTEM.md`**：建立底层规则。在产生任何性格之前，必须先确定“不能做什么”和“必须怎么思考”。 -3. **构建 `IDENTITY.md` 与 `SOUL.md`**：赋予生命力。LLM 此时从“纯粹的工具”转变为“具备特定性格的专家”。 -4. **读取 `USER.md`**：注入外部变量。AI 了解了交互对象，调整自己的姿态。 -5. **激活 `TOOLS.md` 与 `AGENTS.md`**：最后加载执行层。当 AI 明确了身份和规则后，再根据需要调用具体的手段。 - - - -1. Bootstrap 文件注入（新会话首个 turn） +### 2. 调用逻辑与顺序 按优先级读取顺序： AGENTS.md → SOUL.md → TOOLS.md → IDENTITY.md → USER.md - - - - -2️⃣ 记忆文件读取 -• MEMORY.md — 长期记忆（仅私聊会话加载，群聊不加载） -• memory/今天.md + memory/昨天.md — 日志（会话开始时读取） - -3️⃣ Skill 加载（SKILL.md 注入） +#### Skill 加载（SKILL.md 注入） 三个来源，优先级从高到低： ① < workspace >/skills（agent 独有） ② ~/.openclaw/skills（全局共享） ③ bundled skills（内置） 同名 skill 高优先级覆盖低优先级 - - -4️⃣ 会话历史 -已有的对话上下文（JSONL 存储） - - - -5️⃣ 语义搜索（按需） -agent 调用 memory_search 时，向量检索 MEMORY.md + memory/* .md - - - - - - - - -💡 建议： - +#### 建议： 如果你想把记忆用法精炼，推荐这样分层： - - - 1. 通用行为规范 → AGENTS.md / SOUL.md（所有会话都加载） - 2. 工具使用指南 → Skill 的 SKILL.md（按需触发加载） - 3. 持久事实/偏好 → MEMORY.md（长期记忆） - 4. 需要代码逻辑的 → Plugin（如自动 Token 管理、MCP 代理） - - 以 Redmine 为例的最佳实践： - • Skill：SKILL.md 写"怎么调用、什么时候触发、参数格式" - • Plugin：如果要做自动 Token 刷新、webhook 监听等，写成 Plugin - • MEMORY.md：只存"loujiajie 有权限的项目是 H78"这种事实 - - 不建议把所有东西都塞进 MEMORY.md， -### EmbeddingModel - ### 记忆移植方法 ### 将记忆移植到Skill 【Skill】= 教 agent "怎么做某件事" - • 本质是 SKILL.md（Markdown 指令）+ 可选脚本 - • 注入到 agent 的上下文中，agent 按指令执行 - • 适合：工具使用说明、操作流程、触发规则 - • 例：RedmineSkill 告诉 agent 如何调用 MCP 查工单 ## Muti-Agent 按照日常功能分出几个额外Agent，并让他们使用不同的Workspace。 +## Subagent铁律案例 + +把这段放入 AGENTS.md 中 +### Sub-Agent 编排规则 + +#### 模型选择策略 +根据任务复杂度自动选择模型，优化成本与质量的平衡： + +| 级别 | 适用场景 | 模型 | Thinking | +|------|---------|------|----------| +| 简单 | 天气、日历、状态检查、单项数据获取 | minimax-portal/MiniMax-M2.1 | off | +| 中等 | 搜索总结、文档摘要、内容起草、多步信息整理 | openai-codex/gpt-5.2 | low | +| 复杂 | 代码审查、架构分析、安全审计、多维度对比决策 | openai-codex/gpt-5.2 | high | +原则： +- 默认从最便宜的模型开始，只在任务明确需要更强推理时升级 +- 不确定时选中等 + +#### 常用工作流 +**每日简报** — 当用户说"每日简报"或在早晨心跳时： +1. 并行 spawn 4 个 Sub-Agent（级别：简单）： + - 天气：上海未来 24 小时 + - 日历：今天的会议和待办 + - 邮件：未读紧急邮件摘要 + - 新闻：AI / Agent 领域最新动态（最多 5 条） +2. 全部完成后汇总成结构化简报 +3. 通过当前频道发送 + +**技术调研** — 当用户要求调研多个主题时： +1. 每个主题 spawn 一个 Sub-Agent（级别：中等） +2. 每个 Sub-Agent 搜索 3-5 篇最新文章，总结关键观点，300 字以内 +3. 全部完成后汇总对比 + +**代码审查** — 当用户说"审查代码"或"review"时： +1. spawn 一个 Sub-Agent（级别：复杂），超时 5 分钟 +2. 检查项：安全漏洞、类型安全、错误处理、架构合理性 +3. 返回：问题列表 + 严重度 + 修复建议 + +**批量文档处理** — 当用户需要处理多个文档时： +1. 每个文档 spawn 一个 Sub-Agent（级别：根据文档复杂度判断） +2. 提取关键信息，返回结构化 JSON +3. 全部完成后汇总对比 +#### 通用约束 + +- 并行 Sub-Agent 不超过 5 个，避免速率限制 +- 每个 Sub-Agent 的 task prompt 必须自包含所有必要上下文（Sub-Agent 看不到 SOUL.md 和 USER.md） +- 简单任务超时 60 秒，中等任务超时 180 秒，复杂任务超时 600 秒 +- 完成后默认 cleanup: "delete"，除非用户要求保留日志 + # ~~Docker 部署~~(推荐虚拟机部署) 1. https://docs.openclaw.ai/install/docker 2. git clone https://github.com/openclaw/openclaw.git @@ -350,14 +397,6 @@ https://cloud.tencent.com/developer/article/2626310 - https://km.netease.com/v4/detail/blog/258877 - 插件文档:https://docs.popo.netease.com/lingxi/173a627a791b4372aa50318bfdfb5204 -需要安装插件之后，重启，再填写机器人事件订阅的token 秘钥相关信息。 - -[https://open-dev.popo.netease.com/mp/detail/184955194/devManage](https://open-dev.popo.netease.com/robot/detail/363265944/devManage) -http://10.219.32.29:6666/popo/callback -KyePDRbMN3j1bHEhxktBMbcJtehpxmYW - -https://km.netease.com/v4/detail/blog/258877 - ## 企业微信 - https://github.com/pawastation/wechat-kf - Token信息 diff --git a/07-Other/AI/AI Agent/OpenClaw/OpenClaw ACPX配置.md b/07-Other/AI/AI Agent/OpenClaw/OpenClaw ACPX配置.md new file mode 100644 index 0000000..caa6e62 --- /dev/null +++ b/07-Other/AI/AI Agent/OpenClaw/OpenClaw ACPX配置.md @@ -0,0 +1,146 @@ +# 配置参数 +## ACPX核心配置 +```json +{ + "acp": { + "enabled": true, + "dispatch": { "enabled": true }, + "backend": "acpx", + "defaultAgent": "claude", + "allowedAgents": ["claude", "codex", "pi", "opencode", "gemini"], + "maxConcurrentSessions": 8 + } +} +``` +## 权限配置： +```bash +openclaw config set plugins.entries.acpx.config.permissionMode approve-all +openclaw config set plugins.entries.acpx.config.nonInteractivePermissions fail + +``` + +## 重启并验证 +```bash +openclaw restart +/acp doctor +``` + +# 启动命令 +```bash +/acp spawn claude --mode oneshot --thread auto --cwd /Users/yuyue07/Desktop/openclaw +``` + + + + + +这是一份专为 AI 智能体（如 OpenClaw）设计的**技术部署协议文档**。你可以将其直接发送给 OpenClaw A，它将理解如何通过局域网协议接管并在 Windows 环境下的 OpenClaw B 中执行任务。 + +--- + +# 🤖 嵌套智能体架构部署协议：LAN-ACP 控制流 + +## 1. 架构概述 (Architecture Overview) + +本方案采用**“指挥官—操作员”**模式，通过局域网实现远程代码编排与自动化执行。 + +- **OpenClaw A (Orchestrator):** 运行于高性能控制端（Mac Studio），负责任务拆解与逻辑审计。 + +- **OpenClaw B (Operator):** 运行于 Windows 执行端，通过 ACP 协议直接驱动 Claude Code。 + +- **通信协议:** 基于 JSON-RPC 的 **Agent Client Protocol (ACP)** 与 OpenClaw P2P 对等连接。 + + +--- + +## 2. 受控端环境预设 (OpenClaw B - Windows) + +### 2.1 基础依赖 + +- **Shell:** Windows PowerShell 7+ 或系统自带 PowerShell。 + +- **工具链:** Node.js (LTS), Claude Code CLI (`@anthropic-ai/claude-code`)。 + +- **权限:** 已开启 OpenSSH Server，并配置 `ANTHROPIC_API_KEY` 为系统环境变量。 + + +### 2.2 OpenClaw Gateway 配置 + +在 `%USERPROFILE%\.openclaw\config.json` 中配置以下核心参数： + +JSON + +``` +{ + "node_id": "executor-win-01", + "networking": { + "host": "0.0.0.0", + "port": 8080, + "allow_lan": true + }, + "runtime": { + "shell": "powershell.exe", + "encoding": "utf-8" + }, + "acp": { + "enabled": true, + "provider": "claude-code", + "auto_approve_tools": ["list_files","read_file","grep_search","file_edit","bash","ls","cat"] + } +} +``` + +--- + +## 3. 控制端对接协议 (OpenClaw A - macOS) + +### 3.1 身份注册 (Identity Mapping) + +OpenClaw A 需通过以下逻辑识别并绑定远程 Peer： + +1. **连接指令:** `peer connect --target :8080 --token ` + +2. **角色定义:** 将 `executor-win-01` 标记为 `Technical_Executor`。 + + +### 3.2 指令封装 (Instruction Wrapping) + +当 A 需要执行代码任务时，必须将任务封装为 ACP 标准请求发送至 B。 + +> **逻辑模版:** `Invoke-RemoteAgent -Target "executor-win-01" -Action "ACP_SPAWN" -Harness "claude" -Prompt ""` + +--- + +## 4. 自动化执行工作流 (Standard Operating Procedure) + +1. **意图解析:** OpenClaw A 接收用户需求（如：修复 Vue 3 组件 Bug）。 + +2. **任务路由:** A 检查局域网内 B 的在线状态。 + +3. **ACP 激活:** A 向 B 发送 `/acp spawn claude` 指令。 + +4. **实时会话:** * B 启动 Claude Code 进程。 + + - Claude Code 通过 B 的文件系统进行 `ls`, `cat`, `sed` 等操作。 + + - B 将执行过程的增量日志（Incremental Logs）实时推送到 A 的控制台。 + +5. **结果审计:** 任务完成后，A 要求 B 运行本地测试（如 `npm run test`），并根据输出判定是否交付。 + + +--- + +## 5. 关键安全与优化指令 (Security & Optimization) + +- **路径规范:** 在 Windows 环境下，所有指令中的路径需使用双斜杠 `\\` 或标准 POSIX 斜杠 `/`，避免转义错误。 + +- **状态同步:** 强制要求 B 在每一步关键操作后返回状态码。 + +- **超时处理:** ACP 会话默认心跳间隔设为 30s，防止长耗时编译任务导致连接断开。 + +- **防火墙策略:** * `New-NetFirewallRule -DisplayName "OpenClaw-B" -LocalPort 8080 -Protocol TCP -Action Allow` + + +--- + +> **给 OpenClaw 的执行提示:** “请按照上述协议，首先自检局域网连通性，然后建立与远程 Windows Peer 的持久化 ACP 会话。在执行代码修改时，优先使用 `claude-code` 的文件操作能力，并在完成后返回 Diff 报告。” \ No newline at end of file diff --git a/07-Other/AI/AI Agent/OpenClaw/OpenClaw Multi Agent Prompt.md b/07-Other/AI/AI Agent/OpenClaw/OpenClaw Multi Agent Prompt.md index cb21693..fcd4251 100644 --- a/07-Other/AI/AI Agent/OpenClaw/OpenClaw Multi Agent Prompt.md +++ b/07-Other/AI/AI Agent/OpenClaw/OpenClaw Multi Agent Prompt.md @@ -72,4 +72,21 @@ @ Wendy 你是一个超人气的虚拟偶像，绑定Agent Wendy_Idol，以亲切、充满魅力且拟人化的口吻进行情感陪伴。 @ Wendy 你是是一个提示词工程大师，绑定Agent Wendy_Art，将用户语言转化为高精度的图像描述词，并且使用图片模型生成图片。 -@ Wendy 这个群首先使用Wendy_Quick与用户沟通，之后请根据用户需求切换成Wendy_Code、Wendy_Search、Wendy_Quick、Wendy_Think。 \ No newline at end of file +@ Wendy 这个群首先使用Wendy_Quick与用户沟通，之后请根据用户需求切换成Wendy_Code、Wendy_Search、Wendy_Quick、Wendy_Think。 + + +# H78提示词 +请根据以下表格信息来创建OpenClaw独立Agent，模型都使用 netease/claude-opus-4-6 ： + +| 用户名 | 身份 | WorkSpace | +| -------- | ---- | ------------------------------------------------ | +| Wendy_PM | 产品经理 | /Users/yuyue07/.openclaw/agentworkspace/wendy_pm | +| air | 游戏策划 | /Users/yuyue07/.openclaw/agentworkspace/air | +| | | | +1. 创建`SYSTEM.md`、`IDENTITY.md`、`USER.md`、`TOOLS.md` 、`AGENTS.md`、`MEMORY.md`以及memory文件夹结构。 +2. 模型使用 netease/claude-opus-4-6。 +3. 修改相关设置。 + +## Workspace设置 +1. 请将 POPO群8212751 绑定 agent mozhixin，之后 lijun17@corp.netease.com 在这个群提出任何修改属于她工作区的请求都接受，比如`SYSTEM.md`、`USER.md`、`TOOLS.md` 、`AGENTS.md`这些。 +2. \ No newline at end of file diff --git a/07-Other/AI/AI Agent/OpenClaw/OpenClaw自动部署提示词.md b/07-Other/AI/AI Agent/OpenClaw/OpenClaw自动部署提示词.md new file mode 100644 index 0000000..d2f4ad0 --- /dev/null +++ b/07-Other/AI/AI Agent/OpenClaw/OpenClaw自动部署提示词.md @@ -0,0 +1,145 @@ +请先阅读OpenClaw官方文档了解OpenClaw的部署和配置方式：https://docs.openclaw.ai/zh-CN/install/docker#docker + +然后通过ssh为我的服务器配置OpenClaw,用minimax的api(国内版),模型选择MiniMax M2.1. +并实现和bot配对，bot的token： +8772808265:AAFivjcbwtD7wHBSPNjIJELyFe9vaXp8XmQ +MiniMax API key:sk-cp-IBXnYjQtPf-yg8UptEJwhJuwLFQLNbKtcT6p9qHXmCGBN6JuuBhMVedYVPTCLILWE8ws8egDXYkxTsCWUMkXkmpLZJRSCDe76iFzpxD_YjtCl_ZbbkDP9jY + +服务器ip:64.247.196.47 +用户名：Ubuntu +密码:75fdb19b-f396-44b6-8b58-be064e19ce87 + +# Docker +## MAC +请先阅读OpenClaw官方文档了解OpenClaw的部署和配置方式：https://docs.openclaw.ai/install/docker#docker，以及本机配置。 +请先编写Docker-Compose Yaml文件，以下是详细信息： + +- Default Agent + - 名称：XiaoXian_PM +- 保证OpenClaw端口不会与现有OpenClaw冲突。 +- 相关文件映射到/Users/yuyue07/Desktop/openclaw/XiaoXian_PM目录下 +- Model：模型相关配置与本地相同。 +- moltbot-popo + - + + + +```bash +services: + openclaw: + image: ghcr.io/openclaw/openclaw:latest + ports: + - "127.0.0.1:8080:8080" + environment: + - OPENCLAW_GATEWAY_TOKEN=你的强密码 + - BROWSER_CDP_URL=http://browser:9223 + volumes: + - ./data:/home/node/.openclaw + - ./workspace:/workspace + depends_on: + - browser + + browser: + image: coollabsio/openclaw-browser:latest + # 无需暴露端口到宿主机，内部通信即可 + cap_add: + - SYS_ADMIN +``` + + +```yaml +services: + xiaoxian-pm-gateway: + image: ghcr.io/openclaw/openclaw:latest + container_name: xiaoxian-pm-gateway + environment: + HOME: /home/node + TERM: xterm-256color + OPENCLAW_GATEWAY_TOKEN: ${OPENCLAW_GATEWAY_TOKEN:-} + TZ: Asia/Shanghai + volumes: + # OpenClaw 配置目录（首次启动前需放入 openclaw.json） + - ./config:/home/node/.openclaw + # Agent workspace + - ./workspace:/home/node/.openclaw/workspace + ports: + # 使用 28789 避免与现有 OpenClaw (18789) 冲突 + - "28789:28789" + - "28790:28790" + init: true + restart: unless-stopped + command: + [ + "node", + "dist/index.js", + "gateway", + "--bind", + "lan", + "--port", + "28789", + ] + healthcheck: + test: + [ + "CMD", + "node", + "-e", + "fetch('http://127.0.0.1:28789/healthz').then((r)=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))", + ] + interval: 30s + timeout: 5s + retries: 5 + start_period: 20s + + xiaoxian-pm-cli: + image: ghcr.io/openclaw/openclaw:latest + container_name: xiaoxian-pm-cli + network_mode: "service:xiaoxian-pm-gateway" + cap_drop: + - NET_RAW + - NET_ADMIN + security_opt: + - no-new-privileges:true + environment: + HOME: /home/node + TERM: xterm-256color + OPENCLAW_GATEWAY_TOKEN: ${OPENCLAW_GATEWAY_TOKEN:-} + BROWSER: echo + TZ: Asia/Shanghai + volumes: + - ./config:/home/node/.openclaw + - ./workspace:/home/node/.openclaw/workspace + stdin_open: true + tty: true + init: true + entrypoint: ["node", "dist/index.js"] + depends_on: + - xiaoxian-pm-gateway +``` + +```yml +services: + openclaw: + image: ghcr.io/openclaw/openclaw:laster + restart: always + ports: + - "18789:18789" #保留原始端口映射 + environment: + - TZ=Asia/Chengdu #保留原始时区配置 + # LM Studio核心配置(指定模型+地址) + - OPENAI API BASE=http://192.168.1.5:5001/v1#补充/v1话配OpenAl接口规范 + - OPENAI-API-KEY-Imstudio # LM Studio默认无需密钥,占位即可 + - DEFAULT-MODEL=Qwen3.5-35B-A3B-heretic-v2-Q6-K #你的指定模型 + volumes: + -/data:/home/node/data #保留原始数据挂載 + -/openclaw config:/home/node/.openclaw#保留原始配E挂载 + user: root # 保留root用户启动 + +``` + +最终输出相关信息。 +# Ubuntu + + + + diff --git a/07-Other/AI/AI Agent/OpenClaw/实验结果/一些实验结果.md b/07-Other/AI/AI Agent/OpenClaw/实验结果/一些实验结果.md new file mode 100644 index 0000000..59b5ead --- /dev/null +++ b/07-Other/AI/AI Agent/OpenClaw/实验结果/一些实验结果.md @@ -0,0 +1,200 @@ +# 前言 +- 搜索类 + - [[#OpenClaw原生方案/Jina / TinySearch 测试结果]] +- +# OpenClaw原生方案/Jina / TinySearch 测试结果 + +已获取足够信息，下面是总结： +Tavily vs Jina Reader API 对比 +**Jina Reader** +**优点：** +- 极简使用：只需在 URL 前加 r.jina.ai/ 即可获取干净 Markdown +- 提供搜索端点（s.jina.ai）和事实验证端点（g.jina.ai） +- 免费额度可用，上手零门槛 +- 输出 LLM 友好的 Markdown，适合快速内容提取 +**缺点：** +- 只能处理单页，无法爬取整站 +- 输出为原始 Markdown，无结构化 JSON 提取 +- 无 schema 验证 / 类型安全 +- 免费层有速率限制，付费定价不够透明 +- 缺少 LangChain 等 AI Agent 框架的原生集成 + +**Tavily** +**优点：** +- 专为 AI/RAG 场景设计的搜索 API，返回带来源引用的结果 +- 与 LangChain、LlamaIndex 等框架原生集成 +- 结果包含摘要和来源 URL，适合需要 citation 的场景 +- 搜索质量针对 AI Agent 优化 +**缺点：** +- 侧重"搜索发现"，不擅长深度网页内容提取 +- 不提供将网页转为干净 Markdown 的能力（需配合其他工具） +- 免费额度有限，重度使用成本较高 + +| | | | +| -------- | -------------- | --------------- | +| 维度 | Jina Reader | Tavily | +| 核心能力 | 网页→Markdown 转换 | AI 搜索引擎 | +| 适用场景 | 单页内容提取、RAG 输入 | 搜索发现、带引用的问答 | +| 结构化输出 | ❌ | ✅（JSON） | +| Agent 集成 | 弱 | 强（LangChain 原生） | +| 内容提取深度 | 强 | 弱 | +选择建议： 需要提取网页内容用 Jina Reader；需要搜索互联网并获取带引用的答案用 Tavily。两者互补，常一起使用。 + +## 测试 +测试题目（3个场景） + +| | | | +|---|---|---| +|#|场景|问题| +|T1|简单事实搜索|"2026年3月最新的AI行业大事件有哪些？列出3个"| +|T2|深度内容提取|"提取 https://github.com/anthropics/claude-code 页面的主要功能介绍"| +|T3|多源聚合研究|"对比 Tavily 和 Jina Reader 这两个搜索API的优缺点"| +对比方案（每题3种） + +| | | +| ------ | ------------------------------------ | +| 方案 | 工具 | +| 默认 | webfetch / websearch（内置工具） | +| Tavily | tavily-search / tavily-extract skill | +| Jina | jina-reader skill | +共 9 个子任务 + +### 结果 +所有 9 个子任务都已完成，现在发送汇总报告： +- Tavily最省 token（总计 30,360），速度也最快 +- 🥈 默认 web_fetch 居中（33,407），单页提取场景最优 +- 🥉 Jina Reader token 消耗最高（46,544），因为返回完整页面内容导致 input tokens 过大。 + +搜索/爬虫方案 Token 消耗对比报告 +- 模型: netease/claude-opus-4-6 +- 方案: 默认(web_fetch) / Tavily / Jina Reader +- 测试时间: 2026-03-10 15:15~15:22 + +📊 **Token 消耗数据** +T1: 简单事实搜索 — "2026年3月最新AI行业大事件，列出3个" + +| | | | | +| -------------- | ------------ | --- | ------- | +| 方案 | Total Tokens | 耗时 | 相对消耗 | +| 默认 (web_fetch) | 10,588 | 21s | 基准 | +| Tavily | 8,340 | 20s | ⬇️ -21% | +| Jina Reader | 17,969 | 47s | ⬆️ +70% | +T2: 深度内容提取 — "提取 claude-code GitHub 页面功能介绍" + +| | | | | +| -------------- | ------------ | --- | ------- | +| 方案 | Total Tokens | 耗时 | 相对消耗 | +| 默认 (web_fetch) | 9,171 | 14s | 基准 | +| Tavily | 10,897 | 14s | ⬆️ +19% | +| Jina Reader | 16,507 | 18s | ⬆️ +80% | +T3: 多源聚合研究 — "对比 Tavily 和 Jina Reader 的优缺点" + +| | | | | +|---|---|---|---| +|方案|Total Tokens|耗时|相对消耗| +|默认 (web_fetch)|13,648|37s|基准| +|Tavily|11,123|32s|⬇️ -19%| +|Jina Reader|12,068|62s|⬇️ -12%| +📈 汇总统计 + +| | | | | | +| -------------- | ------- | ----------- | ---- | --- | +| 方案 | 总 Token | 平均 Token/任务 | 平均耗时 | 排名 | +| Tavily | 30,360 | 10,120 | 22s | 🥇 | +| 默认 (web_fetch) | 33,407 | 11,136 | 24s | 🥈 | +| Jina Reader | 46,544 | 15,515 | 42s | 🥉 | +💡 结论与建议 +1. Token 效率: Tavily 最省 token（比默认少 9%，比 Jina 少 35%） +2. 速度: Tavily ≈ 默认 > Jina（Jina 平均耗时近 2 倍） +3. Jina token 高的原因: Jina 返回完整页面 Markdown 内容，数据量大，导致 LLM 处理的 input tokens 显著增多 +4. Tavily token 低的原因: 返回精炼的摘要+结构化 JSON，LLM 无需处理大量原始内容 + +推荐策略 +1. 搜索场景 → 优先用 Tavily（token 省、速度快） +2. 单页提取 → 默认 web_fetch 已够用（最低 token） +3. JS 渲染页面 / IP 保护 → 用 Jina Reader（能力更强但 token 消耗更高） +4. 深度研究 → Tavily research API（一次调用搞定多角度分析） + +根据之前 9 个子任务的实际输出，我来评估各方案的内容质量。ch 质量最高**（平均 4.7/5）— 尤其在时效性和深度研究场景表现最好 +💰 Tavily 性价比最高 — token 最省且结构化提取能力最强 +📄 Jina Reader 适合特殊场景 — 质量和效率都偏低，但在 JS 渲染和反爬场景有独特价值 +最佳策略：Tavily 搜索发现 + web_fetch 深度提取，按需用 Jina 处理特殊页面。 + +``` +质量高 │ ✅默认 + │ ✅Tavily + │ +质量低 │ ✅Jina + └────────────────── + Token少 Token多 +``` + + +# A2A协议测试 +## 本机Agent讨论测试 +OpenClaw 自带方案 vs A2A 方案 Token 消耗对比 +三方讨论：Wendy(主持) + Wendy_PM + mozhixin +主题：「AI Agent 在游戏开发中的最佳实践」| 三轮对话 +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +🔹**方案一：OpenClaw 自带方案** +**第1轮：AI Agent 在策划文档编写中的价值** +• Wendy_PM：「效率杠杆——碎片化想法→结构化文档、配表和验收标准，自动一致性检查」 +→ input=30,413 | output=92 | total=30,505 | 5.1s +• mozhixin：「结构化提效——模糊想法→规范格式，省去排版和查漏补缺体力活」 +→ input=27,071 | output=105 | total=27,176 | 6.0s + +**第2轮：AI Agent 在 QA 测试自动化中的应用** +• Wendy_PM：「自动生成测试用例、模拟玩家行为、版本回归、日志分析、数值校验」 +→ input=30,610 | output=145 | total=30,755 | 8.5s +• mozhixin：「配表校验、用例生成、回归检测、日志分析」 +→ input=27,346 | output=178 | total=27,524 | 8.3s + +**第3轮：落地最大挑战** +• Wendy_PM：「信任校准——建立人机协作SOP，AI负责草稿校验，人负责决策把关」 +→ input=30,923 | output=124 | total=31,047 | 7.8s +• mozhixin：「信任与容错——关键是建立人机协作的安全网」 +→ input=27,615 | output=160 | total=27,775 | 7.4s +✅ 方案一总计：input=174,978 | output=804 | total=175,782 +PM 小计：91,946+361=92,307 | MZ 小计：82,032+443=82,475 +特点：同一 session 三轮连续对话，上下文累积 + +🔸 **方案二：A2A 方案** +**第1轮：AI Agent 在策划文档编写中的价值** +• Wendy_PM：「结构化提效——口语化想法→配表结构、验收标准和边界条件」 +→ input=29,305 | output=107 | total=29,412 +• mozhixin：「结构化和一致性——人出脑子，猫出爪子🐱」 +→ input=27,071 | output=115 | total=27,186 + +**第2轮：AI Agent 在 QA 测试自动化中的应用** +• Wendy_PM：「测试用例生成、回归自动化、视觉识别UI异常、压力测试、崩溃日志分类」 +→ input=29,347 | output=132 | total=29,479 +• mozhixin：「自动生成测试用例、回归脚本维护、日志异常检测、数值平衡验证」 +→ input=27,108 | output=209 | total=27,317 + +**第3轮：落地最大挑战** +• Wendy_PM：「信任校准——明确Agent能力边界，建立人机协作质检标准」 +→ input=29,334 | output=104 | total=29,438 +• mozhixin：「信任与容错——出错时能秒回滚，安全网比AI能力更关键」 +→ input=27,119 | output=141 | total=27,260 +✅ 方案二总计：input=169,284 | output=808 | total=170,092 +PM 小计：87,986+343=88,329 | MZ 小计：81,298+465=81,763 +特点：每轮独立 session，无上下文累积 +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +📈 最终对比 + +| | | | | +|---|---|---|---| +|指标|自带方案|A2A方案|差异| +|总 Token|175,782|170,092|A2A 少 5,690 (3.2%)| +|PM Input|91,946|87,986|A2A 少 3,960 (4.3%)| +|MZ Input|82,032|81,298|A2A 少 734 (0.9%)| +|总 Output|804|808|基本持平| +|会话连续性|✅ 有|❌ 无|| +|跨服务器|❌|✅|| +关键结论： +1. Token 消耗差异很小（约3%），底层调用同一 agent，系统提示词是大头 +2. 自带方案的 input 略多是因为会话历史累积（每轮多几百 token 的上下文） +3. A2A 每轮是独立 session，没有历史累积所以 input 稳定 +4. 但 A2A 也因此丢失了多轮上下文——agent 看不到之前的讨论 +5. A2A 的真正价值不在省 Token，而在跨机器/跨网络的 Agent 互联 +6. 如果需要多轮连续讨论，自带方案更优（有上下文）；如果是跨服务器单次请求，A2A 更合适 \ No newline at end of file diff --git a/07-Other/AI/AI Agent/OpenClaw/未命名.md b/07-Other/AI/AI Agent/OpenClaw/未命名.md new file mode 100644 index 0000000..220ff91 --- /dev/null +++ b/07-Other/AI/AI Agent/OpenClaw/未命名.md @@ -0,0 +1,53 @@ +1. 龙虾机器人的权限锁问题 + 1. 龙虾权限很高，记忆来设定权限都是不稳定。只有95%能正常运行，主要涉及到OpenClaw的记忆管理，这点下面会说。 + 2. 如果你们的需求只是保证Skill不会被随意篡改，其实可以使用git来对Skill以及OpenClaw.json进行管理。让OpenClaw定时恢复Skill即可。 +2. skill越装越多，记忆可能存在冲突问题 + 1. 要解决这个问题，得对记忆进行合理规划与维护： + 1. 定期清理垃圾记忆：将记忆根据类型分类整合到合适的MD中。这边推荐先试用[Openclaw-workspace ](https://github.com/win4r/openclaw-workspace)进行整理，并且设定每周执行审查（建议经过确认后再进行清理），保证记忆清洁干净。这样也可以减少不必要的Token消耗并且降低降智的问题。 + 2. 使用向量数据库建立长期记忆：让OpenClaw记住一些大家都在用的规则，从而使它变得更加“聪明”。这边推荐使用[memory-lancedb-pro](https://github.com/CortexReach/memory-lancedb-pro)以及相关Skill，模型我推荐使用Qwen Embedding 8B模型以及Qwen Reranker模型。 + 3. 构建一个Skill管理技能，用于指示当什么情况去哪个目录找Skill。 + 4. 配合self-improving-agent Skill，效果会更好。 + 5. 针对记忆的结构化处理，这边推荐使用Obsidian+AI将你们的数据、方案整理成一个结构化的文档，Memory.md中只填写几个重要信息去这边查询即可。 +3. 同一个人对话的上下文污染问题 + 1. OpenClaw目前不同对话（私聊、群聊）不同上下文。 + 2. 你们遇到污染问题，我认为可能是没有使用最强的模型（Claude4.6opus）造成，我本人是没有遇到过。也有可能是你们只使用了默认的记忆系统。 + 3. 及时使用/Clear、/New可以减少模型降智问题，减少上下文污染。 + 4. 另一个使用技巧就是对小型任务使用Subagent来执行。也可以根据需求建立多个Agent，与单个或者多个机器人绑定。以此分割上下文。 + 5. 目前OpenClaw还没有语义切换Agent功能，所以可以根据执行任务分几个独立Agent出来。 + + +哈喽哈喽~还想请教一下关于AI agent推广相关的经验： +1. 中台主要维护哪些内容，是怎样推广给所有项目的同事安装\配置到自己的工作流程中的？ +2. 交付项目的同事有哪些提反馈、自由发挥和参与开发的方式呢？ + +--- +1. 中台主要维护哪些内容，是怎样推广给所有项目的同事安装\配置到自己的工作流程中的？ + 1. 我们的Agent技术都已交给技术中心了，可以找技术中心的 陈康来部署。 + 2. 主要靠老板来推广，比如他让蛋仔组来抄作业。 +2. 我这边参与的是H78，给他们搞一个易协作自动开单、查询、排期功能，他们感觉不错。其他团队的情况，得问我领导Freddy。 + +--- + +美术那边是给大家都配了openclaw来使用的吗？在一些使用体验上，codemaker、有道龙虾、openclaw还是有区别的 + +有道龙虾感觉还在不断完善中，一些im机器人指令其实是没生效的![{"anchor_href":"","base_size":"20,20","disable_copy_":false,"expected_size":"20,20","external_info":"{\"emotion_info\":{\"emotion_id_\":0,\"emotion_path_\":\"C:\\\\Program Files\\\\Netease\\\\POPO\\\\popo\\\\emoticon\\\\default\\\\emoji_gif_129.gif\",\"emotion_tag_\":\"[emts]_popo_emoticon_sys_00129_\\r\\n捂脸\\r\\n[捂脸][/emts]\",\"is_store_emotion_\":false,\"is_system_emotion_\":true,\"store_emotion_cid_\":0,\"store_emotion_url_\":\"\"}}","font_size_type_change_aware_":false,"id":"","image_margin":0,"image_url":"","is_link_icon":false,"original_name":"","original_path":"C:\\Program Files\\Netease\\POPO\\popo\\emoticon\\default\\emoji_gif_129.gif","original_size":"-1,-1","press_can_drag":true,"show_in_image_viewer":false}](C:/Program%20Files/Netease/POPO/popo/emoticon/default/emoji_gif_129.gif)比如/new，/model + +--- + +1. 首先说明一点OpenClaw是一个可配置强大记忆系统的多面手Agent，适合做一个中间衔接、数据传递的事。但一些固定或者专门的事，用龙虾比较费token。 +2. 我个人推荐使用非OpenClaw的龙虾，因为生态跟不上。你有何德何能能与全球开发者抗衡，而且这些开发者AI用得远比我们6。 +3. codemaker、有道龙虾、openclaw还是有区别： + 1. 龙虾的记忆系统更加强大。 + 2. CodeMaker每月5000元额度。 + 3. 如果ClaudeCode 模型免费，我推荐你们用这个代替CodeMaker。 + +--- + +目前我们是TA来维护定制的MCP和一些通用的skill（作为模版），包括一些鉴权和CI相关的指引技能。 +项目强相关的那些流程，每个项目都有些区别，所以目前是设计师在日常工作中跑通了新流程，用团队的模版skill来做成skill（自动传git+CI发布skillhub） +设计师使用和开发中遇到问题时，AI总结提issue或MR，值班TA或定时任务来处理issue，合并MR +不过就是TA和技术向同事比较喜欢用codemaker cli+OMO插件、codex&claude；设计师比较倾向有道龙虾+im机器人的交互形式。这其实也导致了相同模型和skill，使用体验和效果的一些偏差! + + +1. 我建议使用ClaudeCode提炼核心Skill，之后添加OpenClaw、CodeMaker Cli、CodeX的额外文档，让这些Agent多读一些。推荐使用Obsidian构建结构文档。 +2. 强制所有人使用ClaudeCode 4.6模型。 \ No newline at end of file diff --git a/07-Other/AI/AI Agent/Unreal Mcp & Agent.md b/07-Other/AI/AI Agent/Unreal Mcp & Agent.md index fdf5daf..c79c134 100644 --- a/07-Other/AI/AI Agent/Unreal Mcp & Agent.md +++ b/07-Other/AI/AI Agent/Unreal Mcp & Agent.md @@ -20,6 +20,9 @@ - **[unreal-mcp](https://github.com/runreal/unreal-mcp)** 70star 8个月前 - **[unreal-mcp](https://github.com/runeape-sats/unreal-mcp)** 36star 11个月前 - **[UnrealMCPBridge](https://github.com/appleweed/UnrealMCPBridge)** 28 star 12个月前 + - https://www.fab.com/listings/aa699a85-04b1-4746-a29c-962fc3a78f55?tab=%3ARi5adm5%3A +- UI Figma2UE + - https://www.figma.com/community/plugin/1368487806996965174/figma2umg-unreal-importer - Unity MCP - [CoplayDev](https://github.com/CoplayDev)/ [unity-mcp](https://github.com/CoplayDev/unity-mcp) 5800star 高频更新 - RenderDoc MCP diff --git a/07-Other/AI/AI Agent/UnrealEngine/Graphify 知识图谱.md b/07-Other/AI/AI Agent/UnrealEngine/Graphify 知识图谱.md new file mode 100644 index 0000000..a8ce057 --- /dev/null +++ b/07-Other/AI/AI Agent/UnrealEngine/Graphify 知识图谱.md @@ -0,0 +1,319 @@ +# 前言 +- https://github.com/safishamsi/graphify +- 安装:pip install graphifyy && graphify install + +**一个面向 AI 编码助手的技能。** 在 Claude Code、Codex、OpenCode、OpenClaw、Factory Droid 或 Trae 中输入 `/graphify`，它会读取你的文件、构建知识图谱，并把原本不明显的结构关系还给你。更快理解代码库，找到架构决策背后的"为什么"。 + +完全多模态。你可以直接丢进去代码、PDF、Markdown、截图、流程图、白板照片，甚至其他语言的图片 —— graphify 会用 Claude vision 从这些内容中提取概念和关系，并把它们连接到同一张图里。 + +> Andrej Karpathy 会维护一个 `/raw` 文件夹，把论文、推文、截图和笔记都丢进去。graphify 就是在解决这类问题 —— 相比直接读取原始文件，每次查询的 token 消耗可降低 **71.5 倍**，结果还能跨会话持久保存，并且会明确区分哪些内容是实际发现的，哪些只是合理推断。 + +# 安装 +## 平台支持 + +| 平台 | 安装命令 | +| ------------- | -------------------------------------- | +| Claude Code | `graphify install` | +| Codex | `graphify install --platform codex` | +| OpenCode | `graphify install --platform opencode` | +| OpenClaw | `graphify install --platform claw` | +| Factory Droid | `graphify install --platform droid` | +| Trae | `graphify install --platform trae` | +| Trae CN | `graphify install --platform trae-cn` | + +Codex 用户还需要在 `~/.codex/config.toml` 的 `[features]` 下打开 `multi_agent = true`，这样才能并行提取。OpenClaw 目前的并行 agent 支持还比较早期，所以使用顺序提取。Trae 使用 Agent 工具进行并行子代理调度，**不支持** PreToolUse hook，因此 AGENTS.md 是其常驻机制。 + +然后打开你的 AI 编码助手，输入： + +``` +/graphify . +``` + +## 让助手始终优先使用图谱（推荐） + +图构建完成后，在项目里运行一次： + +| 平台 | 命令 | +|------|------| +| Claude Code | `graphify claude install` | +| Codex | `graphify codex install` | +| OpenCode | `graphify opencode install` | +| OpenClaw | `graphify claw install` | +| Factory Droid | `graphify droid install` | +| Trae | `graphify trae install` | +| Trae CN | `graphify trae-cn install` | + +**Claude Code** 会做两件事： +1. 在 `CLAUDE.md` 中写入一段规则，告诉 Claude 在回答架构问题前先读 `graphify-out/GRAPH_REPORT.md` +2. 安装一个 **PreToolUse hook**（写入 `settings.json`），在每次 `Glob` 和 `Grep` 前触发 + +如果知识图谱存在，Claude 会先看到：_"graphify: Knowledge graph exists. Read graphify-out/GRAPH_REPORT.md for god nodes and community structure before searching raw files."_ —— 这样 Claude 会优先按图谱导航，而不是一上来就 grep 整个项目。 + +**Codex、OpenCode、OpenClaw、Factory Droid、Trae** 会把同样的规则写进项目根目录的 `AGENTS.md`。这些平台没有 PreToolUse hook，所以 `AGENTS.md` 是它们的常驻机制。 + +卸载时使用对应平台的 uninstall 命令即可（例如 `graphify claude uninstall`）。 + +**常驻模式和显式触发有什么区别？** + +常驻 hook 会优先暴露 `GRAPH_REPORT.md` —— 这是一页式总结，包含 god nodes、社区结构和意外连接。你的助手在搜索文件前会先读它，因此会按结构导航，而不是按关键字乱搜。这已经能覆盖大部分日常问题。 + +`/graphify query`、`/graphify path` 和 `/graphify explain` 会更深入：它们会逐跳遍历底层 `graph.json`，追踪节点之间的精确路径，并展示边级别细节（关系类型、置信度、源位置）。当你想从图谱里精确回答某个问题，而不仅仅是获得整体感知时，就该用这些命令。 + +可以这样理解：常驻 hook 是先给助手一张地图，`/graphify` 这几个命令则是让它沿着地图精确导航。 + +
+手动安装（curl） + +```bash +mkdir -p ~/.claude/skills/graphify +curl -fsSL https://raw.githubusercontent.com/safishamsi/graphify/v3/graphify/skill.md \ + > ~/.claude/skills/graphify/SKILL.md +``` + +把下面内容加到 `~/.claude/CLAUDE.md`： + +``` +- **graphify** (`~/.claude/skills/graphify/SKILL.md`) - any input to knowledge graph. Trigger: `/graphify` +When the user types `/graphify`, invoke the Skill tool with `skill: "graphify"` before doing anything else. +``` + +
+ +# 用法 + +``` +/graphify # 对当前目录运行 +/graphify ./raw # 对指定目录运行 +/graphify ./raw --mode deep # 更激进地抽取 INFERRED 边 +/graphify ./raw --update # 只重新提取变更文件，并合并到已有图谱 +/graphify ./raw --cluster-only # 只重新聚类已有图谱，不重新提取 +/graphify ./raw --no-viz # 跳过 HTML，只生成 report + JSON +/graphify ./raw --obsidian # 额外生成 Obsidian vault（可选） + +/graphify add https://arxiv.org/abs/1706.03762 # 拉取论文、保存并更新图谱 +/graphify add https://x.com/karpathy/status/... # 拉取推文 +/graphify add https://... --author "Name" # 标记原作者 +/graphify add https://... --contributor "Name" # 标记是谁把它加入语料库的 + +/graphify query "what connects attention to the optimizer?" +/graphify query "what connects attention to the optimizer?" --dfs # 追踪一条具体路径 +/graphify query "what connects attention to the optimizer?" --budget 1500 # 把预算限制在 N tokens +/graphify path "DigestAuth" "Response" +/graphify explain "SwinTransformer" + +/graphify ./raw --watch # 文件变更时自动同步图谱（代码：立即更新；文档：提醒你） +/graphify ./raw --wiki # 构建可供 agent 抓取的 wiki（index.md + 每个 community 一篇文章） +/graphify ./raw --svg # 导出 graph.svg +/graphify ./raw --graphml # 导出 graph.graphml（Gephi、yEd） +/graphify ./raw --neo4j # 生成给 Neo4j 用的 cypher.txt +/graphify ./raw --neo4j-push bolt://localhost:7687 # 直接推送到运行中的 Neo4j +/graphify ./raw --mcp # 启动 MCP stdio server + +# git hooks - 跨平台，在 commit 和切分支后重建图谱 +graphify hook install +graphify hook uninstall +graphify hook status + +# 常驻助手规则 - 按平台区分 +graphify claude install # CLAUDE.md + PreToolUse hook（Claude Code） +graphify claude uninstall +graphify codex install # AGENTS.md（Codex） +graphify opencode install # AGENTS.md（OpenCode） +graphify claw install # AGENTS.md（OpenClaw） +graphify droid install # AGENTS.md（Factory Droid） +graphify trae install # AGENTS.md（Trae） +graphify trae uninstall +graphify trae-cn install # AGENTS.md（Trae CN） +graphify trae-cn uninstall +``` + +支持混合文件类型： + +| 类型 | 扩展名 | 提取方式 | +|------|--------|----------| +| 代码 | `.py .ts .js .go .rs .java .c .cpp .rb .cs .kt .scala .php` | tree-sitter AST + 调用图 + docstring / 注释中的 rationale | +| 文档 | `.md .txt .rst` | 通过 Claude 提取概念、关系和设计动机 | +| 论文 | `.pdf` | 引文挖掘 + 概念提取 | +| 图片 | `.png .jpg .webp .gif` | Claude vision —— 截图、图表、任意语言都可以 | + +# 你会得到什么 +- **God nodes** —— 度最高的概念节点（整个系统最容易汇聚到的地方） +- **意外连接** —— 按综合得分排序。代码-论文之间的边会比代码-代码边权重更高。每条结果都会附带一段人话解释。 +- **建议提问** —— 图谱特别擅长回答的 4 到 5 个问题。 +- **“为什么”** —— docstring、行内注释（`# NOTE:`、`# IMPORTANT:`、`# HACK:`、`# WHY:`）以及文档里的设计动机都会被抽取成 `rationale_for` 节点。不只是知道代码“做了什么”，还能知道“为什么要这么写”。 +- **置信度分数** —— 每条 `INFERRED` 边都有 `confidence_score`（0.0-1.0）。你不只知道哪些是猜出来的，还知道模型对这个猜测有多有把握。`EXTRACTED` 边恒为 1.0。 +- **语义相似边** —— 跨文件的概念连接，即使结构上没有直接依赖也能建立关联。比如两个函数做的是同一类问题但彼此没有调用，或者某个代码类和某篇论文里的算法概念本质相同。 +- **超边（Hyperedges）** —— 用来表达 3 个以上节点的群组关系，这是普通两两边表达不出来的。比如：一组类共同实现一个协议、认证链路里的一组函数、同一篇论文某一节里的多个概念共同组成一个想法。 +- **Token 基准** —— 每次运行后都会自动打印。对混合语料（Karpathy 的仓库 + 论文 + 图片），每次查询的 token 消耗可以比直接读原文件少 **71.5 倍**。第一次运行需要先提取并建图，这一步会花 token；后续查询直接读取压缩后的图谱，节省会越来越明显。SHA256 缓存保证重复运行时只重新处理变更文件。 +- **自动同步**（`--watch`）—— 在后台终端里跑着，代码库一变化，图谱就会跟着更新。代码文件保存会立刻触发重建（只走 AST，不用 LLM）；文档/图片变更则会提醒你跑 `--update` 进行 LLM 再提取。 +- **Git hooks**（`graphify hook install`）—— 安装 `post-commit` 和 `post-checkout` hook。每次 commit 后、每次切分支后都会自动重建图谱，不需要额外开一个后台进程。 +- **Wiki**（`--wiki`）—— 为每个 community 和 god node 生成类似维基百科的 Markdown 文章，并提供 `index.md` 作为入口。任何 agent 只要读 `index.md`，就能通过普通文件导航整个知识库，而不必直接解析 JSON。 + +## Worked examples + +| 语料 | 文件数 | 压缩比 | 输出 | +|------|--------|--------|------| +| Karpathy 的仓库 + 5 篇论文 + 4 张图片 | 52 | **71.5x** | [`worked/karpathy-repos/`](worked/karpathy-repos/) | +| graphify 源码 + Transformer 论文 | 4 | **5.4x** | [`worked/mixed-corpus/`](worked/mixed-corpus/) | +| httpx（合成 Python 库） | 6 | ~1x | [`worked/httpx/`](worked/httpx/) | + +Token 压缩效果会随着语料规模增大而更明显。6 个文件本来就塞得进上下文窗口，所以 graphify 在这种场景里的价值更多是结构清晰度，而不是 token 压缩。到了 52 个文件（代码 + 论文 + 图片）这种规模，就能做到 71x+。每个 `worked/` 目录里都带了原始输入和真实输出（`GRAPH_REPORT.md`、`graph.json`），你可以自己跑一遍核对数字。 + +# 针对UE开发的使用方式 +### 具体的实施路线图 +1. **安装 Graphify 并配置 ClaudeCode 技能：** 在你的项目根目录运行： +``` +graphify install # 自动向 CLAUDE.md 注入架构索引规则 +/graphify . # 生成初始代码图 +``` +2. **编写 `CLAUDE.md` 引导：** 在项目根目录创建或修改 `CLAUDE.md`： +> **Architecture Context:** Always read `graphify-out/GRAPH_REPORT.md` before answering architecture questions. **UE Standards:** Follow Unreal Engine 5.x coding standards (PascalCase, U-Prefixes). +3. **开发 MCP 插件：** 如果你有能力，实现一个简单的 MCP Server，能够通过命令行搜索 UE 的 `Reflection Database`。 + +### 总结建议 +- **如果你追求立即理解代码逻辑：** 优先配置 **Graphify**。它能让 Claude 从“逐行看代码”进化到“看地图写代码”。 +- **如果你在进行长期复杂的特性开发：** 引入 **Graphiti** 作为 Claude 的“开发日志”，防止它忘记你之前的架构决策。 + +--- + +# 具体执行方案 +--- + +实现这一方案的关键在于将 `graphify` 从一个“傻瓜式扫描器”转变为一个“受控的提取引擎”。针对 Unreal Engine 的庞大规模，我们需要通过精确的路径控制和排除规则来实施。 + +以下是具体的执行方法与命令： +### 1\. 离线构建 Engine 基础图谱 (The Static Atlas) + +由于引擎源码几乎不变量，我们只需构建一次。 + +**执行策略：** 只索引 `Public` 接口，忽略所有实现（`.cpp` ）和私有目录。 +**具体命令：** +``` +# 进入引擎 Source 目录 +cd /d D:/UnrealEngine/UE_5.7/Engine/Source + +claude --dangerously-skip-permissions + +# 执行 graphify 扫描 +# --include: 仅包含 Public 文件夹下的头文件，这是剪枝的核心 +# --ignore: 排除掉极其庞大的第三方库和中间件 +/graphify index . \ + --output D:/MatrixTA/AIGameDev/AIDM0/Docs/Graphify/UE5.7_Header.graph \ + --include "**/Public/**/*.h" \ + --ignore "ThirdParty/**,Developer/**,Programs/**,Intermediate/**,**/Private/**" +``` + +**提示：** 这一步在 M1 Ultra 上可能仍需数十分钟。建议通过 `--max-depth` 限制继承链的抓取深度，通常设置为 5 已经能覆盖 90% 的关键基类（如 `UObject` -> `AActor` -> `APawn` -> `ACharacter` ）。 + +--- + +### 2\. ~~针对 UE 的“剪枝”策略配置文件~~ + +为了避免长命令，建议在项目根目录创建一个 `.graphifyconfig` (或工具支持的配置文件)。 + +**精细化剪枝逻辑：** + +- **反射优先：** 重点提取带有 `GENERATED_BODY()` 的类。 +- **模块白名单：** 如果你主要做游戏逻辑，只包含以下核心模块： + - `Runtime/Engine` + - `Runtime/Core` + - `Runtime/CoreUObject` + - `Runtime/InputCore` + +**自动化剪枝脚本示例 (Python)：** 如果你发现 `graphify` 无法过滤细碎路径，可以用这个脚本生成一个“干净”的临时符号链接目录供其索引： +```python +import os +from pathlib import Path + +source_dir = Path("/Users/Shared/Epic Games/UE_5.4/Engine/Source/Runtime") +target_dir = Path("./UE_Thin_Source") + +# 仅挑选核心模块的 Public 目录建立软链接 +core_modules = ['Engine', 'Core', 'CoreUObject', 'RenderCore'] + +for module in core_modules: + pub_path = source_dir / module / "Public" + if pub_path.exists(): + os.makedirs(target_dir / module, exist_ok=True) + os.symlink(pub_path, target_dir / module / "Public") +``` + +然后对 `UE_Thin_Source` 运行 `/graphify` 。 + +--- + +### 3\. 实时构建 Project 业务图谱 (The Dynamic Layer) +业务代码变动频繁，需要更轻量、更高频的更新。 +**执行命令：** +``` +# 在你的项目根目录执行，排除插件和中间文件 +/graphify index ./Source \ + --output ./project_current.graph \ + --ignore "**/Intermediate/**,**/Binaries/**" \ + --watch +``` + +**进阶：结合 ClaudeCode 的 `CLAUDE.md`** 在项目根目录的 `CLAUDE.md` 中添加指令，让 Claude 意识到有两个图谱存在： +``` +### Knowledge Graph Context +- **Static Engine Graph:** \`~/ue_engine_full.graph\` (Read-only, contains UE5 API) +- **Project Graph:** \`./project_current.graph\` (Updated on save, contains business logic) +- **Rule:** When a class is prefixed with 'U' or 'A' and not in Project Graph, query Engine Graph via \`mcp-graph-tool\`. +``` + +#### C++ & Puerts代码图谱 +```bash +# 同时指定项目路径和外部引擎路径 +# TODO:添加Index Plugins +/graphify index ./Source ./TypeScript \ + --output ./Docs/Graphify/Project/Project.graph \ + --include "*.cpp,*.h,*.hpp,*.ts" \ + --ignore "**/Intermediate/**,**/ThirdParty/**" +``` + +#### 增量更新模式（逻辑合并 - 推荐方案） +这是最符合工程实践的方法。先建立基础图谱，再将其他目录的内容“追随”进去。`graphify` 的 `--update` 标志会自动处理节点冲突并合并新的关系。 + +**执行命令：** +```bash +# 第一步：索引引擎（静态基础） +/graphify index /path/to/ue_engine/Source/Runtime \ + --output ./ue_workspace.graph \ + --include "**/Public/**/*.h" + +# 第二步：将项目目录合并到同一个图谱中 +/graphify index ./MyProject/Source \ + --output ./ue_workspace.graph \ + --update # 关键参数：在现有图谱基础上合并 +``` + + + + +--- + +### 4\. 实施 Multi-Graph 挂载的 MCP 方案 +要让 ClaudeCode 真正理解这两个图谱，你需要一个简单的 MCP Server 来做中转。 + +**开发建议：** +1. **加载：** 启动时同时 Load 两个 `.graph` 文件到内存。 +2. **查询逻辑：** + ``` + async function searchClass(className) { + // 1. 先查项目图谱 + let result = projectGraph.find(className); + if (!result) { + // 2. 如果没找到，且符合 UE 命名规范，查引擎图谱 + result = engineGraph.find(className); + } + return result; + } + ``` + +### 总结执行清单： +1. **环境准备：** 确定 UE 引擎路径。 +2. **首次索引：** 使用上述“剪枝命令”生成 `ue_engine_full.graph` ，存放在家目录作为持久缓存。 +3. **项目配置：** 在项目内运行带有 `--watch` 的 `graphify` 。 +4. **注入 Claude：** 编写 MCP Server 将两个图谱的查询接口暴露给 ClaudeCode。 + +这种“重引擎索引 + 轻业务监控”的模式，能保证在 64GB 内存的本地环境下，ClaudeCode 既能秒回 API 调用问题，又能深刻理解你的业务代码耦合。你想尝试编写这个 MCP 路由器的代码吗？ \ No newline at end of file diff --git a/07-Other/AI/AI Agent/UnrealEngine/Hardness Game Development.md b/07-Other/AI/AI Agent/UnrealEngine/Hardness Game Development.md new file mode 100644 index 0000000..65557cd --- /dev/null +++ b/07-Other/AI/AI Agent/UnrealEngine/Hardness Game Development.md @@ -0,0 +1,25 @@ +# 目录结构 +- docs + - Netease_AITA_AssetMaker.md：项目技术、设计细节入口文档，方便Agent来寻找 + - +- Projects：UE工程目录。 + + +# 相关技术与容器 +- UE + - UnrealMcp + - Puerts + - Puerts Editor + - uecli + - Readme的材质都是agent调用uecli做的 帮我生产材质 排版材质节点 帮我场景截图，帮我材质蓝图截图 帮我写readme 帮我提交仓库。 https://github.com/wlxklyh/UECLI + - 通过蓝图转c++功能，让AI读懂蓝图 + - IDE Debug MCP + - https://km.netease.com/v4/section/aigc/detail/blog/263683 + - cpp-debugger-cli +- Docker + - Gitea：工单以及版本管理。 + - OpenClaw：子节点部署，通过父节点进行控制。 + - SMB服务。 +- Obsidian Cli：文档管理。 + +## UE测试技术 \ No newline at end of file diff --git a/07-Other/AI/AI Agent/WY/AI全生命周期构思.md b/07-Other/AI/AI Agent/WY/AI全生命周期构思.md new file mode 100644 index 0000000..805cb50 --- /dev/null +++ b/07-Other/AI/AI Agent/WY/AI全生命周期构思.md @@ -0,0 +1,60 @@ +# 前言 +现阶段其他部门都关注于自己工作领域，而忽视了项目全生命周期流程，一些问题往往会在领域交接时产生，之后的章节会逐步展开。在这之前我说这几点： +- 主Agent与从Agent +- 项目知识管理 +- 文档&提示词的质量 +- 记忆系统管理 与 Skill + +## OpenClaw与多Agent +现阶段因为各种限制不会出现全能性AI，所以建议使用主Agent与多个从Agent的方案。但对于公司而言，All In One的方案并不是最好选择，除了考虑避免All In Boom，还有就有就是记忆、上下文、方便迭代方面的考量。 + +>***另据我所知原生提供Node远程控制方案并且可以自己部署节点的只有OpenClaw。*** 除此之外全球的开源力量使得迭代速度指数级上升，似乎有可能成为新的linux，成为AI时代的agent 中继 Bridge。 + +基于以上几点我选择OpenClaw，以下是我个人建议架构： +![[主Agent与从Agent.canvas]] +项目组主要产出文档以及代码，使用主Agent的使用目的主要集中精炼文档、记忆、Skills、沟通其他Agent。 +其他点： +1. Agent之间的沟通存在token消耗。目前已经我已经找到解决方案准备测试。 +2. 一些相关信息也建议汇总到主Agent中进行汇总，但需要注意使用分层结构，避免出现降智问题。 + +## 知识管理 +现阶段Markdown（之后简称MD） 因为高可读性、高信息密度、纯文本成为AI Agent的文档首选，。我个人推荐Obsidian作为MD的编辑与查看工具，且已有现成的MCP与CLI工具。（还有看板、数据表、画板、导图、流程图等功能）另外个人推荐使用使用git+oss的方式来做版本管理与协作，想简单可以使用SMB。 + +推荐使用多层结构进行管理，避免Context爆炸。这个技巧也可以使用在Skill中。结构参考： +- AI策划助手_使用说明.md +- 表结构 + - 道具表说明书.md + - 道具表说明书_耕种畜牧.md + - 道具表说明书_加工品消耗品.md + - 道具表说明书_设施与建筑.md +- 配表流程 + - skill_开单说明.md + - skill_配表.md + +## 记忆系统 +目前已知大致有下面3个流派： +- 结构化知识图谱派：Evolver +- 向量检索派：MemorySearch +- 生成式摘要派：self-improving-agent + +实际上记忆系统都是混合方案。面向多人的企业级方案才是焦点。 + +### “精耕细作” 式管理记忆 +多人使用场景下，往往会有堆积大量 “噪音”以及错误记忆，尽管有一些工具可以自动优化，但依然建议人工介入，让记忆（经验）更快“收敛”。 + +## 文档&提示词的质量 +某专家策划曾提出以下几个问题： +1. 能力不同的人，编写的文档，是否会对AI的理解与执行产生较大影响？ +2. 程序需要多加限制还是少加限制？ +3. 什么样的文档适合AI来阅读？ + +我个人认为逻辑清晰认知高的人编写的文档与提示词，AI更容易理解意图并且能够更好的执行； +程序应该关注每个功能（维度从function => Module)的输入与输出是否正确，所以应该让AI自己发挥除了硬杠杠与主要方向。 +AI写的文档往往比人写的更加简练，更高复用性，所以更适合AI阅读。 + +--- +# 策划 +TODO + +# 程序 +TODO diff --git a/07-Other/AI/AI Agent/WY/MCP&Skill/H78 XEditor-弥赛亚-NeoX-Skill.md b/07-Other/AI/AI Agent/WY/MCP&Skill/H78 XEditor-弥赛亚-NeoX-Skill.md new file mode 100644 index 0000000..298cc29 --- /dev/null +++ b/07-Other/AI/AI Agent/WY/MCP&Skill/H78 XEditor-弥赛亚-NeoX-Skill.md @@ -0,0 +1,32 @@ +| 分类 | 方案/工具名称 | 相关方 | 方案成熟度 | 完成度 | 验证状态 | 备注/说明 | +| --------- | --------------------------- | ------------------ | ------ | ---- | ------ | -------------------------------------------------- | +| 资源检查工具 | neoXassessor | 程序, 雷鹅, QA, 美术 | 互娱成熟方案 | 25% | 整合验证通过 | 说明 | +| 模型缩减工具 | UE/Simplygon | 程序, 美术 | 第三方方案 | 0% | 整合验证通过 | ue/simplygon常规方案 | +| 模型生产 | MATRIX AITA 炼丹炉 | 美术 | 互娱成熟方案 | 75% | 整合验证通过 | 说明 | +| 资源转换 | UE4/5导NEOX工具 \| FBX, GLTF支持 | 美术 | 互娱成熟方案 | 25% | 整合验证通过 | 说明 | +| (天空/光照) | UE UltraDynamicSky | 程序, 美术 | 第三方方案 | 0% | 整合验证通过 | 请填写需求设计链接 | +| 反射 | 离线SSR | 程序, 美术 | 互娱成熟方案 | 0% | 调研或推进中 | 说明 | +| (全局光照) | Lumen | 程序, 美术 | 引擎自带方案 | 0% | 调研或推进中 | 说明 | +| (全局光照) | 引擎内置SSR | 程序, 美术 | 引擎自带方案 | 0% | 调研或推进中 | 说明 | +| (全局光照) | Planar Reflections | 程序, 美术 | 引擎自带方案 | 0% | 调研或推进中 | 说明 | +| (全局光照) | Cubemap | 程序, 美术 | 引擎自带方案 | 0% | 调研或推进中 | 说明 | +| 后处理 | 项目自定义 | 程序, 美术 | 项目定制开发 | 100% | 调研或推进中 | 说明 | +| 头发、布料模拟 | Hair与Groom系统 | 美术 | 引擎自带方案 | 0% | 调研或推进中 | 说明 | +| 头发、布料模拟 | Chaos布料系统 | 美术 | 引擎自带方案 | 0% | 调研或推进中 | 说明 | +| 高级物理系统 | ABC缓存 (Alembic Ca...) | 程序, 美术 | 引擎自带方案 | 0% | 调研或推进中 | 说明 | +| 高级物理系统 | VAT顶点动画纹理 | 程序, 美术 | 引擎自带方案 | 0% | 调研或推进中 | 说明 | +| 高级物理系统 | Physics Constraint | 程序, 美术 | - | - | 整合验证通过 | 说明 | +| 场景物理破坏 | Chaos物理系统 | 程序 | 引擎自带方案 | - | 调研或推进中 | 说明 | +| 场景寻路 | UE5寻路导出插件 | 程序 | 互娱成熟方案 | 0% | 调研或推进中 | 说明 | +| 场景寻路 | 内置寻路系统 (Naviga...) | 程序 | 引擎自带方案 | 0% | 调研或推进中 | 说明 | +| 数字资产版本化管理 | Perforce | 策划, 程序, 雷鹅, QA, 美术 | 互娱成熟方案 | 0% | 调研或推进中 | 说明 | +| 数字资产版本化管理 | UniSVN - 自研加速版TortoiseSVN | 策划, 程序, 雷鹅, QA, 美术 | 互娱成熟方案 | 0% | 整合验证通过 | 说明 | +| 数字资产版本化管理 | 互娱Gitlab研发效率工具 | 策划, 程序, 雷鹅, QA, 美术 | 互娱成熟方案 | 0% | 调研或推进中 | 说明 | +| 剧情编辑器工具 | 过场动画编辑器 (Seq...) | 策划, 美术 | 引擎自带方案 | 0% | 调研或推进中 | 说明 | +| 剧情编辑器工具 | Dialogue Plugin (官) | 策划, 美术 | 引擎自带方案 | 0% | 调研或推进中 | 通过数据兼容性评估/支持分支 | +| 动画压缩 | ACL | 策划, 美术 | 引擎自带方案 | 0% | 调研或推进中 | - | +| 开放大世界RPG | ShaderWorld | 美术, 程序 | 第三方方案 | - | 整合验证通过 | [https://lo.host/UWpWbN/](https://lo.host/UWpWbN/) | +| 模型LOD | Imposter | 美术 | 引擎自带方案 | 0% | 整合验证通过 | 说明 | +| 模型LOD | UE自有LOD功能 | 美术 | 引擎自带方案 | 0% | 整合验证通过 | 说明 | +| 可见性剔除 | 剔除距离体积 (Cull Di...) | 程序, 美术 | 引擎自带方案 | 0% | 调研或推进中 | 说明 | +| 可见性剔除 | 预计算可视体积功能 | 程序, 美术 | 引擎自带方案 | 0% | 调研或推进中 | 说明 | diff --git a/07-Other/AI/AI Agent/WY/MCP&Skill/POPO 云文档MCP&Skill.md b/07-Other/AI/AI Agent/WY/MCP&Skill/POPO 云文档MCP&Skill.md new file mode 100644 index 0000000..b9c45af --- /dev/null +++ b/07-Other/AI/AI Agent/WY/MCP&Skill/POPO 云文档MCP&Skill.md @@ -0,0 +1,96 @@ +# 简介 +**MATRIX-AITA POPO 云文档操作 Skill** 是公司内部首个公开的云文档编辑Skill。它彻底解决了以往 AI Agent “只能看、不能写”的痛点，通过强大的自动化能力，让 AI 助手真正拥有了替你处理文档、整理表格、甚至管理多维数据的“双手”，是提升团队办公效率的硬核神器。 + +## 功能介绍 +- 📄 **文档（深度创作与排版）** 你可以指挥 AI 从零开始撰写项目建议书或会议纪要，它不仅能生成文字，还精通排版逻辑。它支持自动插入 1 到 5 级标题、符号列表以及有序列表，让文档结构层次分明。除了创建新文档，你还可以让它在现有文档末尾追加灵感，或者随时远程重命名文档，让文档管理变得动动嘴就能搞定。 +- 📊 **表格（智能数据录入）** 繁琐的数据录入和报表更新现在可以全权交给 AI 处理，它能精准地在指定的单元格中填入内容。你可以要求它为关键数据标记背景色以示提醒，或者批量修改某一区域的字体格式，快速生成美观的进度表。即便面对海量数据，它也能通过“精准定位”修改特定数值，再也不用在大表中拉动滚动条寻找目标了。 +- 📝 **Markdown（专业技术文档生成）** 这是为开发者和技术同学准备的排版利器，AI 可以为你生成包含代码块、数学公式以及 Mermaid 流程图的高质量内容。它支持标准的 Markdown 语法，能够完美处理复杂的引用、分割线和链接，确保技术文档既专业又易读。无论是编写 README 还是整理技术方案，它都能确保输出的内容格式工整、开箱即用。 +- **🗄️ 多维表格（自动化数据中心）** 你可以把复杂的任务追踪、资产管理或人员名单交给 AI 来打理，它支持多维表格的各项核心操作。无论是新增一条任务记录，还是修改某个单选、日期字段的状态，AI 都能像数据库管理员一样精准执行。它还能帮你快速查询表内的现有记录，并根据逻辑自动汇总信息，让你的多维表格真正变成一个能自我更新的智能系统。 +- **👥 团队空间（无缝跨部门协作）** 该 Skill 突破了个人文档的限制，能够直接在公司各级“团队空间”中大显身手。它能自动识别团队的目录结构，在指定的页面或文件夹下创建子文档，并自动处理复杂的协作权限验证。这意味着你可以授权 AI 自动更新团队周报、维护公共知识库，让所有团队成员都能实时共享到 AI 辅助生成的最新成果。 + +--- + +## 操作步骤介绍 +### 1. 安装Skill +进入 https://skills.netease.com/skills/skill_b67793104fac +复制安装命令给Agent或者下载该Skill，最后让Agent帮你安装。 +### 2. 自动化授权（获取 Cookie） +无需手动查代码，直接运行我们提供的脚本即可（也可让Agent帮忙运行）： +- **双击运行**：在 `tools` 目录中找到 `collect-cookies_GBK.bat` 并双击。 +- **告知 Agent**：登录完成后，回到对话窗口对 Agent 说 **“我登录了”**，它将自动完成后续的 Token 采集与保存。 + +### 3. 开始使用 +授权完成后，你就可以尝试给 Agent 下达类似下方的指令了： +- _“把这个表格里 A1 到 D1 的背景色改成黄色。”_ +- _“读取多维表格‘项目进展’中所有状态为‘进行中’的记录。”_ + +## 备注 +该Skill现阶段仍处于开发阶段，如果遇到问题请加入 群号：7271072，@楼嘉杰来解决。 + + +--- + +Gitlab Token：uunSQeYYhBCAn2a5C55H +ANTHROPIC_API_KEY +CI/CD Trigger 8b84579d3405f7a16f86ac2f2bcb59 + +--- + + + +以下是修改后的 `.gitlab-ci.yml` 示例以及关键配置步骤： +### 1. 准备工作（CI/CD 变量设置） +在 GitLab 项目的 **Settings -> CI/CD -> Variables** 中，请确保已配置以下变量： +- **`ANTHROPIC_API_KEY`**: 你的内部接口授权 Token。 +- **`GITLAB_TOKEN`**: 具有 API 写入权限的 Personal Access Token（用于回帖）。 +- **`ANTHROPIC_BASE_URL`**: 设置为 `https://openai.nie.netease.com/v1`（注意添加 `/v1` 后缀）。 + +### 2. 修改后的 `.gitlab-ci.yml` 脚本 +这个脚本会在 Issue 触发时运行，使用 Claude Code 尝试修复，并利用 GitLab API 将结果反馈到 Issue 讨论区。 +```yml +claude_main_fix: + stage: ai_fix + image: node:20 + variables: + GIT_STRATEGY: clone + GIT_DEPTH: 0 + script: + - npm install -g @anthropic-ai/claude-code + - export ANTHROPIC_BASE_URL="https://openai.nie.netease.com/v1" + + # 1. 配置 Git 机器人身份（必须，否则无法 commit） + - git config --global user.email "claude-bot@yourcompany.com" + - git config --global user.name "Claude AI Bot" + + # 2. 切换到主分支并确保是最新状态 + # 注意：$CI_DEFAULT_BRANCH 通常是 main 或 master + - git checkout $CI_DEFAULT_BRANCH + - git pull origin $CI_DEFAULT_BRANCH + + # 3. 运行 Claude Code 进行直接修复 + # 删除了“创建新分支”的指令，明确要求“直接修改” + - | + claude --yes "你现在处于项目根目录的主分支。请分析项目结构，直接修复 Issue #$ISSUE_IID。 + Issue 描述：$ISSUE_DESCRIPTION + 修复完成后，请直接保存文件，不要创建新分支。" + + # 4. 提交并推送回主分支 + # 使用包含 Token 的 URL 进行推送，确保有权限 + - | + git add . + if git commit -m "fix(auto): 自动修复 Issue #$ISSUE_IID [skip ci]"; then + git push "https://project_${CI_PROJECT_ID}_bot:${GITLAB_TOKEN}@${CI_SERVER_HOST}/${CI_PROJECT_PATH}.git" HEAD:$CI_DEFAULT_BRANCH + echo "代码已直接推送到主分支。" + else + echo "没有发现需要修复的更改或提交失败。" + fi + allow_failure: true +``` + +### 3. 核心改进说明 +- **接口重定向**：通过 `export ANTHROPIC_BASE_URL` 强制 CLI 访问网易内部代理接口。 +- **非交互式处理**：在 CI 环境中，Claude Code 会尝试直接执行指令。建议在指令中明确要求它“创建新分支”而非直接推送到主分支，以保证代码安全。 +- **自动回帖流**： + - 脚本捕获了 Claude Code 的输出并存入 `repair_summary.txt`。 + - 使用 `curl` 调用 GitLab 的 `/notes` API。`$CI_API_V4_URL` 和 `$CI_PROJECT_ID` 是 GitLab CI 内置的变量，无需手动配置。 +- **上下文读取**：为了让修复更准确，你可以在指令中加入 `Check CLAUDE.md for project guidelines`，确保 AI 遵循你在项目中定义的规范。 \ No newline at end of file diff --git a/07-Other/AI/AI Agent/WY/MCP&Skill/易协作MCP & Skill.md b/07-Other/AI/AI Agent/WY/MCP&Skill/易协作MCP & Skill.md new file mode 100644 index 0000000..d5197d3 --- /dev/null +++ b/07-Other/AI/AI Agent/WY/MCP&Skill/易协作MCP & Skill.md @@ -0,0 +1 @@ +http://redmineapi.nie.netease.com/ \ No newline at end of file diff --git a/07-Other/AI/AI Agent/WY/WY MCP&Skill.md b/07-Other/AI/AI Agent/WY/WY MCP&Skill.md deleted file mode 100644 index 8899008..0000000 --- a/07-Other/AI/AI Agent/WY/WY MCP&Skill.md +++ /dev/null @@ -1,232 +0,0 @@ -# 前言 - -# 易协作 -- 相关网址 - - [Redmine MCP Server (易协作)](https://modelspace.netease.com/mcphub?detail=redmine-mcp-server&namespace=public) - - Auth & Token - - https://console-auth.nie.netease.com/mymessage/mymessage - - https://sa.nie.netease.com/docs/auth/%E8%BF%90%E7%BB%B4%E6%94%AF%E6%92%91/Auth/06-%E7%94%A8%E6%88%B7%E6%89%8B%E5%86%8C/04%E5%BC%80%E5%8F%91%E8%80%85%E5%B7%A5%E5%85%B7/API%20%E6%96%87%E6%A1%A3/02%20Auth%20API%20v2%20%E6%96%87%E6%A1%A3.md#%E8%83%8C%E6%99%AF - - -# Redmine MCP Server (易协作) -易协作工单管理的 MCP (Model Context Protocol) Server 实现，提供工单查询、详情查看、工单更新、项目管理等功能。 - -## [](https://mcp-ui.netease.com/server/redmine-mcp-server?namespace=public#%E5%8A%9F%E8%83%BD%E7%89%B9%E6%80%A7)功能特性 -### [](https://mcp-ui.netease.com/server/redmine-mcp-server?namespace=public#-%E5%B7%A5%E5%85%B7-tools)🔧 工具 (Tools) -- **query_issues**: 搜索/查询易协作工单，支持多种过滤条件（状态、指派人、时间范围、自定义字段等） -- **get_issue_detail**: 获取单个工单的完整详情，包括描述内容和图片 -- **update_issue**: 更新/修改工单信息（状态、指派人、主题、描述、备注等），支持人名、邮箱前缀等多种指派人格式 -- **get_user_projects**: 获取用户有权限访问的易协作项目列表 - -### [](https://mcp-ui.netease.com/server/redmine-mcp-server?namespace=public#-%E8%B5%84%E6%BA%90-resources)📚 资源 (Resources) -- **redmine://config**: 服务器配置信息 -- **redmine://hosts**: 所有易协作实例及有权限的项目列表 - -### [](https://mcp-ui.netease.com/server/redmine-mcp-server?namespace=public#%EF%B8%8F-%E8%B5%84%E6%BA%90%E6%A8%A1%E6%9D%BF-resource-templates)🗂️ 资源模板 (Resource Templates) -- **redmine://host/{host_name}**: 获取指定易协作实例的详细信息 -- **redmine://host/{host_name}/{project_name}**: 获取指定项目的详细信息（版本、状态、跟踪标签等） -- **redmine://project/{project_name}**: 获取默认实例中项目的详细信息（需配置默认实例） - -### [](https://mcp-ui.netease.com/server/redmine-mcp-server?namespace=public#-%E6%8F%90%E7%A4%BA-prompts)💬 提示 (Prompts) -- **issue_analysis**: 易协作工单助手，支持状态、优先级、指派人、趋势分析 - -## [](https://mcp-ui.netease.com/server/redmine-mcp-server?namespace=public#%E4%BD%BF%E7%94%A8%E6%96%B9%E5%BC%8F)使用方式 -### [](https://mcp-ui.netease.com/server/redmine-mcp-server?namespace=public#streamablehttp-%E6%8E%A8%E8%8D%90)StreamableHTTP (推荐) -```json -{ - "mcpServers": { - "redmine-mcp-server": { - "type": "streamableHttp", - "url": "https://mcp.netease.com/servers/redmine-mcp-server/mcp/" - } - } -} -``` - -#### [](https://mcp-ui.netease.com/server/redmine-mcp-server?namespace=public#%E6%8C%87%E5%AE%9A%E9%BB%98%E8%AE%A4%E6%98%93%E5%8D%8F%E4%BD%9C%E5%AE%9E%E4%BE%8B%E5%8F%AF%E9%80%89)指定默认易协作实例（可选） -如果有多个易协作实例，可通过 `redmine-host` 参数指定默认实例，后续调用工具时可省略 `redmine_host` 参数： -```json -{ - "mcpServers": { - "redmine-mcp-server": { - "type": "streamableHttp", - "url": "https://mcp.netease.com/servers/redmine-mcp-server/mcp/", - "headers": { - "redmine-host": "dap-v4.pm.netease.com" - } - } - } -} -``` - -## [](https://mcp-ui.netease.com/server/redmine-mcp-server?namespace=public#%E8%AE%A4%E8%AF%81%E4%B8%8E%E9%89%B4%E6%9D%83)认证与鉴权 -### [](https://mcp-ui.netease.com/server/redmine-mcp-server?namespace=public#%E8%AE%A4%E8%AF%81%E6%96%B9%E5%BC%8F)认证方式 -- 通过请求头 `X-Access-Token` 提供用户Token（若在 Codemaker 中使用，无需自行设置） -- 系统会验证Token的有效性并获取用户信息 -- Auth 文档（使用 Auth Key 换取 Token）：[https://g.126.fm/04nIr8l](https://g.126.fm/04nIr8l) -- Auth 平台：[https://console-auth.nie.netease.com/mymessage/mymessage](https://console-auth.nie.netease.com/mymessage/mymessage) - -### [](https://mcp-ui.netease.com/server/redmine-mcp-server?namespace=public#%E9%89%B4%E6%9D%83%E8%A7%84%E5%88%99)鉴权规则 -- 用户只能访问其有权限的易协作实例和项目 -- 权限判断基于用户邮箱是否在项目成员列表中 - -## [](https://mcp-ui.netease.com/server/redmine-mcp-server?namespace=public#%E5%B7%A5%E5%85%B7%E8%AF%A6%E7%BB%86%E8%AF%B4%E6%98%8E)工具详细说明 -### [](https://mcp-ui.netease.com/server/redmine-mcp-server?namespace=public#query_issues---%E6%9F%A5%E8%AF%A2%E5%B7%A5%E5%8D%95)query_issues - 查询工单 -搜索/查询易协作工单信息，支持丰富的过滤条件。 -**参数：** - -|参数|类型|必填|说明| -|---|---|---|---| -|`redmine_host`|string|视配置|易协作实例域名，已配置默认实例时可省略| -|`project`|string|是|项目名称| -|`filters`|object|否|过滤条件，详见过滤器说明| -|`page`|integer|否|页码，默认 1| -|`per_page`|integer|否|每页条数，默认 20，最大 100| - -**支持的过滤器：** - -|过滤器字段|操作符|说明| -|---|---|---| -|`issues_id`|`=`, `!`|工单ID，支持多个ID| -|`subject`|`~`, `=`, `!`|主题关键词| -|`status`|`=`, `!`, `o`, `c`|状态名称| -|`assigned_to_id`|`=`, `!`|指派人（邮箱前缀或 `me`）| -|`assigned_to_name`|`=`, `!`|指派人中文名称| -|`tracker_id`|`=`, `!`|跟踪标签（名称或ID）| -|`fixed_version_id`|`=`, `!`, `o`, `c`|目标版本（名称或ID）| -|`updated_on`|`><`, `>=`, `<=`|更新时间| -|`created_on`|`><`, `>=`, `<=`|创建时间| -|`start_date`|`><`, `>=`, `<=`|开始日期| -|`due_date`|`><`, `>=`, `<=`|截止日期| -|`done_ratio`|`=`, `!`, `>=`, `<=`|完成度 (0-100)| -|`estimated_hours`|`=`, `!`, `>=`, `<=`|预估工时| -|`cf`|对象|自定义字段，键为字段ID| - -**操作符说明：** `~` 模糊匹配，`=` 等于，`!` 不等于，`o` 开放状态，`c` 关闭状态，`><` 范围，`>=` 大于等于，`<=` 小于等于 - -**过滤器示例：** - -```json -{ - "subject": {"op": "~", "value": ["bug"]}, - "status": {"op": "=", "value": ["开发中"]}, - "assigned_to_id": {"op": "=", "value": ["me"]} -} -``` - -### [](https://mcp-ui.netease.com/server/redmine-mcp-server?namespace=public#get_issue_detail---%E8%8E%B7%E5%8F%96%E5%B7%A5%E5%8D%95%E8%AF%A6%E6%83%85)get_issue_detail - 获取工单详情 -获取单个易协作工单的完整详情，包括基本信息、自定义字段、描述内容及图片。 -**参数：** - -|参数|类型|必填|说明| -|---|---|---|---| -|`redmine_host`|string|视配置|易协作实例域名| -|`issue_id`|integer|是|工单ID（如 #12278，传参时传数字 12278）| - -### [](https://mcp-ui.netease.com/server/redmine-mcp-server?namespace=public#update_issue---%E6%9B%B4%E6%96%B0%E5%B7%A5%E5%8D%95)update_issue - 更新工单 -更新/修改易协作工单信息。更新成功后会返回更新后的工单详情。 -系统会自动获取工单所属项目用于API安全校验，无需手动指定项目。 -**参数：** - -|参数|类型|必填|说明| -|---|---|---|---| -|`redmine_host`|string|视配置|易协作实例域名| -|`issue_id`|integer|是|工单ID| -|`status`|string|否|工单状态名称，如: 新建/开发中/已解决/关闭| -|`subject`|string|否|工单主题| -|`description`|string|否|工单描述| -|`notes`|string|否|工单备注/说明，追加到工单评论中| -|`assigned_to_mail`|string|否|指派人，支持多种格式（见下方说明）| -|`tracker`|string|否|跟踪标签名称，如: BUG/任务/需求| -|`version`|string|否|目标版本号名称| -|`start_date`|string|否|开始日期，格式: YYYY-MM-DD| -|`due_date`|string|否|完成日期，格式: YYYY-MM-DD| -|`estimated_hours`|number|否|预估工作量（小时）| -|`author_mail`|string|否|提单作者，格式同指派人| -|`follows`|string/array|否|跟进QA，支持单个字符串(逗号分隔多人)或数组| -|`watcher_user_ids`|array|否|跟踪者用户ID列表，如: [386, 387]| -|`custom_field`|object|否|自定义字段，格式: {"字段ID": "值"}| - -**指派人格式兼容（`assigned_to_mail` / `author_mail` / `follows`）：** - -|输入格式|示例|处理方式| -|---|---|---| -|完整邮箱|`lien02@corp.netease.com`|直接使用| -|邮箱前缀|`lien02`|自动补全为 `lien02@corp.netease.com`| -|中文名|`李恩`|从项目成员缓存中匹配对应邮箱| -|首字母+中文名|`L李恩`|去除首字母前缀后按中文名匹配| - -**更新示例：** -```json -{ - "issue_id": 1509, - "status": "开发中", - "assigned_to_mail": "李恩", - "notes": "已开始开发" -} -``` - -### [](https://mcp-ui.netease.com/server/redmine-mcp-server?namespace=public#get_user_projects---%E8%8E%B7%E5%8F%96%E9%A1%B9%E7%9B%AE%E5%88%97%E8%A1%A8)get_user_projects - 获取项目列表 -获取当前用户有权限访问的所有易协作项目列表，按实例分组返回。 -**参数：** 无 - - -## [](https://mcp-ui.netease.com/server/redmine-mcp-server?namespace=public#%E4%B8%BB%E8%A6%81%E5%8A%9F%E8%83%BD)主要功能 - -### [](https://mcp-ui.netease.com/server/redmine-mcp-server?namespace=public#%E5%B7%A5%E5%8D%95%E6%9F%A5%E8%AF%A2)工单查询 -支持多种过滤条件： -- 主题关键词搜索 -- 状态筛选（新建/开发中/关闭等） -- 指派人筛选（支持邮箱前缀、中文名、`me`） -- 跟踪标签/目标版本筛选（支持名称和ID） -- 时间范围筛选（创建/更新/开始/截止日期） -- 自定义字段筛选 - -### [](https://mcp-ui.netease.com/server/redmine-mcp-server?namespace=public#%E5%B7%A5%E5%8D%95%E8%AF%A6%E6%83%85)工单详情 -- 查看工单完整信息（基本字段、自定义字段） -- 支持描述内容中的图片展示 -- 显示跟踪者、关注者等协作信息 - -### [](https://mcp-ui.netease.com/server/redmine-mcp-server?namespace=public#%E5%B7%A5%E5%8D%95%E6%9B%B4%E6%96%B0)工单更新 -- 修改工单状态、指派人、主题、描述等字段 -- 添加备注/评论 -- 修改目标版本、跟踪标签、日期、工时等 -- 设置跟进QA、跟踪者、自定义字段 -- 指派人支持中文名/邮箱前缀/完整邮箱等多种输入格式 -- 更新成功后自动返回更新后的工单详情 - -### [](https://mcp-ui.netease.com/server/redmine-mcp-server?namespace=public#%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86)项目管理 -- 获取用户有权限的项目列表 -- 查看项目元数据（状态、跟踪标签、版本等） -- 支持多实例管理 - -### [](https://mcp-ui.netease.com/server/redmine-mcp-server?namespace=public#%E6%95%B0%E6%8D%AE%E7%BC%93%E5%AD%98)数据缓存 -- 自动数据更新机制 -- 本地缓存提升性能 -- 实时流式日志输出 - -## 工具 - -| 工具名称 | 工具描述 | 工具参数 | -| ----------------- | ----------------------------------- | --------------------------------------------------------- | -| query_issues | 搜索/查询获取易协作工单信息 | #redmine_host #project #filterspageper_page | -| get_user_projects | 获取用户有权限访问的易协作项目列表 | 暂无参数 | -| get_issue_detail | 获取单个易协作工单详情 | redmine_host*issue_id* | -| update_issue | 更新/修改易协作工单信息，支持修改状态、指派人、主题、描述、备注等字段 | redmine_host*issue_id*statussubjectdescriptionnotes+10 更多 | -## 资源 - -|资源名称|URI|描述|MIME类型| -|---|---|---|---| -|服务器配置|`redmine://config`|获取易协作 MCP 服务器的配置信息|application/json| -|易协作实例-项目列表|`redmine://hosts`|获取所有易协作实例列表及有权限的项目列表|application/json| - -## 模版资源 - -|模板名称|URI模板|描述|MIME类型| -|---|---|---|---| -|易协作实例详情|`redmine://host/{host_name}`|获取指定易协作实例的详细信息|application/json| -|易协作项目详情|`redmine://host/{host_name}/{project_name}`|获取指定易协作实例中特定项目的详细信息，包括项目可用的版本、状态和跟踪标签|application/json| -## 提示 -| | | | -| -------------- | ------- | ------------------------------------- | -| issue_analysis | 易协作工单助手 | #redmine_host #project #analysis_type | \ No newline at end of file diff --git a/07-Other/AI/AI Agent/WY/Website/Netease AITA ArtLib.md b/07-Other/AI/AI Agent/WY/Website/Netease AITA ArtLib.md index 28bbf26..c5c9459 100644 --- a/07-Other/AI/AI Agent/WY/Website/Netease AITA ArtLib.md +++ b/07-Other/AI/AI Agent/WY/Website/Netease AITA ArtLib.md @@ -17,4 +17,193 @@ https://www.fab.com/listings/bb7df0df-a2e7-430f-a382-7c3b121bf767 ## 部署方式 1. 该网站项目使用gitea托管，使用CI/CD进行生成与部署。 -2. 部署到同IP Nodejs Docker容器中。 \ No newline at end of file +2. 部署到同IP Nodejs Docker容器中。 + +# 资产批量下载方式 +将 https://github.com/legendary-gl/legendary 下载到./docs/legendary，之后学习里面的代码。这是一个第三方开源客户端，可以用来下载fab中的资产。 +1. 将相关内容写到./docs/legendary，并在skill.md添加引用。 +2. 检查这个项目是否存在安全问题。 +3. 尝试运行legendary来下载我的资产库，我会告诉你账号密码。 +4. 先下载10个按照Clouderve的结构将下载资产库上传到clouderve。 + +clouderve的目录结构： +- Fab + - UnrealEngine + - Plugins + - ProInstanceToolPlugin + - UE5.5 + - UE5.6 + - UE5.7 + +--- + +在使用 **Claude Code** 或类似的 AI 开发工具编写爬取脚本时，绕过 Cloudflare 的核心在于**“去自动化特征”**。Cloudflare 的防护（如 5 秒盾、Turnstile）不仅检查你的 IP，还会深入分析你的浏览器指纹、TLS 握手以及行为模式。 + +以下是针对 2026 年技术环境，在 Claude Code 中实现避开风控的实战策略： + +### 1. 使用具备“隐身”能力的浏览器框架 + +传统的 Selenium 或普通的 Puppeteer 极易被识别。你应该指示 Claude Code 使用以下增强库： + +- **Playwright + Stealth 插件**：目前最主流的选择。 + +- **SeleniumBase (UC Mode)**：这是目前绕过 Cloudflare 最强的工具之一，其 `undetected-chromedriver` 模式能有效隐藏自动化痕迹。 + +- **npx Claude Code 提示词示例**： + + > "请使用 Python 的 SeleniumBase 库，并开启 UC Mode（Undetected Mode）编写爬取脚本，以绕过目标的 Cloudflare 检测。" + + +### 2. 模拟真实浏览器的指纹 + +Cloudflare 会检查你的 HTTP 请求头是否与底层的 TLS 握手特征匹配（例如，如果你自称是 Chrome 但 TLS 握手特征是 Python-requests，会被秒封）。 + +- **TLS 指纹模拟**：使用 `curl_cffi` 库，它可以模拟真实浏览器（如 Chrome 120+）的 TLS 握手特征。 + +- **请求头伪造**：确保 `User-Agent`、`Accept-Language`、`Sec-Ch-Ua` 等字段与真实浏览器完全一致。 + + +### 3. IP 质量与地理位置 + +即使代码再完美，数据中心的 IP（如 AWS, Google Cloud）也是 Cloudflare 的重点监控对象。 + +- **使用住宅代理（Residential Proxies）**：这些 IP 看起来像普通家庭用户。 + +- **轮换代理**：每次请求或每隔几次操作更换一次 IP。 + +- **IPv6 优先**：2026 年很多防护系统对 IPv6 的限制相对宽松，且资源更丰富。 + + +### 4. 绕过交互挑战 (CAPTCHA/Turnstile) + +当 Cloudflare 弹出验证码时，纯代码通常无法处理。 + +- **验证码识别服务**：在代码中集成如 CapSolver 或 2Captcha 的 API。 + +- **Cloudflare Workers 代理**：有时通过部署在 Cloudflare 内部的 Workers 作为跳板（利用其内部信任机制）会有奇效，但这取决于目标的具体配置。 + + +--- + +### 综合架构建议 + +|**维度**|**推荐技术栈**|**作用**| +|---|---|---| +|**底层驱动**|`SeleniumBase (UC Mode)` 或 `Playwright`|隐藏 WebDriver 特征| +|**网络请求**|`curl_cffi` (Python)|解决 TLS 指纹识别问题| +|**IP 资源**|动态住宅代理 (Residential Proxies)|绕过 IP 频率限制和黑名单| +|**行为模拟**|`B-Splines` 曲线模拟鼠标移动|模拟真人操作轨迹| + +### Claude Code 实战操作小贴士： + +在 Claude Code 终端中，你可以这样引导它： + +1. **第一步：环境检查**。先让它写一个简单的脚本访问 `https://nowsecure.nl`（这是一个专门测试 Cloudflare 绕过程度的网站）并截图。 + +2. **第二步：迭代优化**。如果截图显示被拦截，要求它：“目前的脚本被拦截了，请尝试集成 `stealth` 插件并随机化延迟时间。” + +3. **第三步：添加随机性**。 + + Python + + ``` + import time + import random + # 绝不要使用固定的 sleep(5) + time.sleep(random.uniform(2.5, 7.8)) + ``` + + +**重要提醒：** 爬取数据请务必遵守目标网站的 `robots.txt` 协议及当地法律法规。过度高频的爬取不仅会被封禁，还可能面临法律风险。 + + +# Clouderve +我部署了一个Clouderve http://10.145.96.67:5212/ 用于提供artlib具体的资产下载。请学习 API以及相关文档，之后进行构建。 + +## 主要逻辑 +1. 构建一个工具使用fab的账号密码登录并下载资产（暂缓开发，目前手工下载，并上传到clouderve上） +2. Artlib每过一年就对Clouderve进行扫描，之后将数据库中的项目与Clouderve项对应。确保用户可以下载到指定引擎版本的资产， +3. 用户进入资产详细页面后，如果该资产在Clouderve上存在，页面按钮就是 下载，点击后显示下拉菜单，显示可现在的版本，选择版本后进行下载；如果没有则显示访问Fab，点击后跳转到fab资产的原界面。 +4. +## Clouderve目录说明 +clouderve的目录结构： +- Fab + - UnrealEngine + - Plugins + - ProInstanceToolPlugin + - UE5.5 + - UE5.6 + - UE5.7 + +说明 +1. UnrealEngine层级目录为资产种类，除此之外还可以是Unity、MetaHuman等。 +2. Plugins为资产类型与Fab资产分类有关，除此之外还可以Decal、Material、Texture。 +3. ProInstanceToolPlugin层级为具体的资产名文件夹，我这边上传了ProInstanceToolPlugin作为案例。 +4. UE5.5层级目录为引擎版本，目前我只打算托管UE4.27、UE5.0~最新版本。 + +## API文档 +- API + - https://docs.cloudreve.org/zh/api/overview + - [https://docs.cloudreve.org/zh/api/overview](https://cloudrevev4.apifox.cn/) + +--- + +# Artlib的意义&提效 +1. 收集公司已经采购的资产包（Fab、Artstation等），方便团队以及公司其他美术同学快速找到资产包。使用RAG技术将Fab资产介绍信息整合成知识库，以进行更加精准的资产检索。 + 1. 解决Muse非常难用的问题。ShareStore资产不够多的问题。 + 2. 尽可能做到一次收集完所有资产，避免去Muse、ShareStore上来回搜索。 + 3. 多网站资产汇总，只需要一个网站就能检索其他所有资源站的信息。 + 4. Fab的资产信息具备高准确性，制作的知识库检索资产的准确性远超Muse、ShareStore。 +2. 资产包资产原子化管理，做到检索单个资产的同时，只需下载所需资产，无需下载整个资产包。 + 1. 将下载的原子资产进行归类摆放，比如： /Plugins/ArtLib/Models/目录下，放置Foliage、Building、Prop等。 +3. 给之后的AI开发游戏流程提供弹药，AI可以快速找到合适的模型与资产。 +4. 维护团队封样库以及材质库信息，方便在工作时能及时察觉复用可能性，来进行复用。比如：李双在SVN上整理的各种分好类的资产库。 +5. 给林海开发的插件提供资产包资源 ，让用户可以直接在UE找到合适资产并直接使用。 +6. 给海量模型进行分类，为公司未来的生成模型AI提供训练数据。 +7. 提供资产点赞窗口，之后学习Muse每天采购点赞最多的资产，以此吸引用户来该平台抢占Muse空间。 + +# 开发计划 +1. Web开发 + 1. 修复一些交互Bug。 + 2. 资产点赞功能，机器人信息推送。 + 3. Artstation等网站数据接入。 + 4. 在服务端部署UE Editor，每个资产（模型、贴图……)进行视觉判断，打上合理标签。 + 1. AI模型部署。 + 2. UE Editor 群集方案实现。 + 5. 借到财务账号，并使用爬虫爬取Fab资产。 + 6. 服务器扩容，申请2个服务器用于存储数据，并且部署对象存储服务，保证数据不会嗝屁。 +2. UE插件开发 + 1. 实现网页点击下载就能直接安装到UE目录。 + 2. 实现资产包资产批量修改引用，实现资产整理功能。 + 3. 林海Runtime Load资产插件接入Artlib服务。 + 4. Plugin云端加载方案探索（通过网盘系统构建虚拟目录，再通过Webdav接入UE，可能会不稳定） +3. 开发类似普罗米修斯的资产库客户端（WebApp） + +--- + +# 启动器 +## 提示词 +我想制作一个类似Fab启动器，用于显示Artlib中的内容、另一个网站内容、以及连接UnrealEngine进行一些资产相关的操作（待实现） + +### 主要功能 +1. 使用Netease OIDC进行身份验证。 +2. 显示Artlib内容，需要做好交互。启动器验证之后，会自动帮Artlib验证。 +3. 显示另一个网站AssetMaker的内容，需要做好交互。启动器验证之后，会自动帮Artlib验证。 +4. 连接UnrealEngine进行一些资产相关的操作（待实现） + +### UI参考 +相关UI参考./docs/screenshots +- 左边是一个可折叠的侧边导航栏，点击左下角的折叠按钮后，可以折叠。 + - 左边侧边栏方面放置3个按钮即可，Fab、角色生成 按钮、知识技能库 + - 折叠效果参考 + - fab_reference1.png + - fab_reference1.5.png +- Fab 按钮：点击后显示网站 D:\AI\Website\NeteaseAITA_Artlib，使用软连接获取对应的前端文件。 +- 角色生成 按钮：点击后显示外部网站。参考 LaunchHub_1.png +- 知识技能库 按钮：点击后显示外部网站 https://ta.netease.com 。参考 LaunchHub_2.png + +## 技术栈 +- WebApp框架：Electron、Electron-vite + - 使用 npm create @quick-start/electron@latest 来建立脚手架。 +- 前端技术：TypeScript、Vue 3、Vite；Vue Router、Pinia；前端组件请使用Element Plus，使用pnpm install element-plus 进行安装；除此之外还有Lucide Icons, Tailwind CSS。 +- 工具函数：Axios、VueUse、pnpm diff --git a/07-Other/AI/AI Agent/WY/Website/Netease AITA AssetMaker.md b/07-Other/AI/AI Agent/WY/Website/Netease AITA AssetMaker.md new file mode 100644 index 0000000..63305c3 --- /dev/null +++ b/07-Other/AI/AI Agent/WY/Website/Netease AITA AssetMaker.md @@ -0,0 +1,445 @@ +# 提示词 +请你说中文，并使用中文编写文档。 + +我需要你发挥卓越的前端开发能力，对我指定的网站进行全方位的“像素级复刻”。这个复刻不仅包括静态页面的排版、配色和字体，还需要涵盖所有的交互细节、动画效果和响应式适配。我们将使用 **Vue 3** 框架和 **Vite** 构建工具。 + +我想制作一个AI 提示词 => 2D原画 => 参考图 => 3D模型生成的WorkFlow网站，功能与风格样式进行像素级复刻： +- https://app.assethub.io/ +- https://app.assethub.io/inventory +- https://app.assethub.io/workflow +- https://app.assethub.io/texturing +- https://app.assethub.io/image +- https://app.assethub.io/settings/team/4430d872-b40f-4374-bfd0-936205e155aa +- 视频 + - https://www.youtube.com/watch?v=h8fKTZDQ90s + - https://www.youtube.com/watch?v=i95-KHATaEY +## 迭代方式 +1. 你可以使用浏览器打开这个网站，我会帮你登录。 +2. 依次打开左边侧边按钮，读取各个页面的HTML结构、CSS信息。将截图存储在Screenshots，使用中文名。视频在github上寻找合适工具给我下载下来作为参考。 +3. 下载网站都用的图片的，并在复刻网站时用上。 +4. 搭建完前后端基础代码之后，先进行前端框架与效果迭代，之后反复对照截图、原始站点进行迭代，保证网站与原站点效果完全一致。 +5. 使用ObsidianCli 维护docs下的文档。 + +## 主要功能 +1. 该网站的主要功能是通过一套完整流程来生成3D模型，大致流程如下： + 1. 用户输入的参考图与提示来生成模型原画。 + 2. 通过原画生成三视图。 + 3. 使用三视图来生成3D模型。 + 4. 3DMesh重拓扑。 + 5. UV Unwrap + 6. auto texture +2. 具备3D渲染功能，请根据参考原站点使用方案。 +3. 具备节点工作流，请使用合适的节点框架，可以考虑使用 https://github.com/comfy-org/ComfyUI 中的节点渲染与流程控制逻辑。 + 1. 节点工作在线共同预览与编辑功能，实现协同工作。 +4. 简单的账户登录机制， 并且提供OpenID登录方式。 +## 技术选型 +我打算使用： +前端技术：TypeScript、Vue 3、Vite；前端组件请使用Element Plus，使用pnpm install element-plus 进行安装。 +后端技术：nodejs、Fastify、Mongoose、fastify-jwt +数据库：MongoDB、MySQL。 +工具函数：Axios、VueUse、pnpm +文档管理：Obsidian Cli + +## 文档目录结构 +- docs + - Netease_AITA_AssetMaker.md：项目技术、设计细节入口文档，方便Agent来寻找 + - Screenshots：存放截图。 + - Videos：视频参考。 + - WebsiteSource：存放HTML、CSS相关信息。 + - Web：前端相关文档。 + - Server：后端相关文档。 + +## 复刻流程提示词 +### 0. 准备阶段：安装必要 Skills (工具) + +为了精准地感知和复刻目标网站，请优先完成以下工具的安装和配置。如果尚未安装，请在本地环境中执行相关命令： + +1. **视觉感知工具 (视觉分析核心)** + * **Skill (依赖)**: `playwright` (用于 headless 浏览器截图、DOM 分析) + * **安装命令**: `npm install playwright && npx playwright install` + +2. **资源处理工具 (资产抓取核心)** + * **Skill (依赖)**: `axios`, `mime-types` (用于下载图片、字体) + * **安装命令**: `npm install axios mime-types` + +3. **开发工具 (Vue 3 + Vite)** + * **Skill (依赖)**: `@vitejs/plugin-vue` (如果在 Vite 项目中未配置) + +--- + +### 1. 执行阶段：网站复刻工作流 + +请按照以下详细步骤执行任务。每完成一步，请向我反馈进度。 + +**目标网站 URL: [在此处替换为您要复刻的网站 URL，例如：https://example.com]** + +#### 第一步：全面观察与分析 (Observation) +1. **高清截图**: 使用 Playwright 对目标网站进行全长（Full Page）高清截图。同时，抓取以下状态的截图： + * 特定组件（如 Button, Nav Item）的 `Hover` 状态。 + * 移动端（如 iPhone 12 Pro）的截图。 +2. **配色提取**: 分析截图，生成一份完整的 JSON 格式色板（Palette），包括主色、辅助色、文本色、背景色、边框色以及渐变色参数。 +3. **字体分析**: 确定目标网站使用的主要 WebFonts、字体大小（Font Size）、行高（Line Height）和字重（Font Weight）。 +4. **结构分析**: 使用 Playwright 导出核心 DOM 树的计算后样式（Computed Styles），特别是关键组件的 `padding`, `margin`, `display` (Flex/Grid) 属性和 `border-radius`。 + +#### 第二步：静态资源抓取 (Asset Collection) +1. **文件下载**: 自动下载目标网站的所有： + * SVG 图标 + * 图片资源（PNG/JPEG/WEBP） + * 字体文件（WOFF2/WOFF） +2. **目录整理**: 将下载的资产按照以下结构有序存入您的项目目录中（例如：`src/assets/images`, `src/assets/icons`, `src/assets/fonts`）。 + +#### 第三步：代码生成 (Vue 3 Component Generation) +1. **项目脚手架**: 如果尚未在当前目录创建 Vite + Vue 3 项目，请创建一个：`npm init vite@latest . -- --template vue`。 +2. **组件拆解**: 将目标网页拆解为可复用的 Vue 组件（例如：`Header.vue`, `HeroSection.vue`, `Card.vue`, `Footer.vue`）。 +3. **样式复刻 (全都要)**: + * 使用全局样式文件（如 `src/style.css`）定义色板变量和字体定义。 + * 在 Vue 组件中，使用 `