dominds 1.0.2 → 1.1.1

package/dist/dialog.js

@@ -23,6 +23,7 @@ const runtime_language_1 = require("./shared/runtime-language");
 const id_1 = require("./shared/utils/id");
 const inter_dialog_format_1 = require("./shared/utils/inter-dialog-format");
 const time_1 = require("./shared/utils/time");
+const tool_1 = require("./tool");
 const id_2 = require("./utils/id");
 class DialogID {
     constructor(selfId, rootId) {
@@ -313,8 +314,13 @@ class Dialog {
     // should continue generating next llm messages immediately;
     //
     // Reminder management methods
-    addReminder(content, owner, meta, position) {
-        const reminder = { content, owner, meta };
+    addReminder(content, owner, meta, position, options) {
+        const reminder = {
+            content,
+            owner,
+            meta,
+            echoback: options?.echoback,
+        };
         const insertIndex = position !== undefined ? position : this.reminders.length;
         if (insertIndex < 0 || insertIndex > this.reminders.length) {
             throw new Error(`Invalid reminder position ${insertIndex}. Valid range: 0-${this.reminders.length}`);
@@ -334,7 +340,7 @@ class Dialog {
         this._remindersVer++;
         return deleted;
     }
-    updateReminder(index, content, meta) {
+    updateReminder(index, content, meta, options) {
         if (index < 0 || index >= this.reminders.length) {
             throw new Error(`Reminder index ${index} does not exist. Available reminders: 0-${this.reminders.length - 1}`);
         }
@@ -343,6 +349,7 @@ class Dialog {
             content,
             owner: oldReminder.owner,
             meta: meta !== undefined ? meta : oldReminder.meta,
+            echoback: options?.echoback ?? oldReminder.echoback,
         };
         this.reminders[index] = updatedReminder;
         this._updatedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
@@ -381,6 +388,7 @@ class Dialog {
                                 content: result.updatedContent,
                                 owner: reminder.owner,
                                 meta: result.updatedMeta !== undefined ? result.updatedMeta : reminder.meta,
+                                echoback: reminder.echoback,
                             };
                             this.reminders[i] = updatedReminder;
                         }
@@ -410,9 +418,12 @@ class Dialog {
         catch (err) {
             log_1.log.warn('Failed to persist reminders', err, { dialogId: this.id.valueOf() });
         }
-        const reminders = this.reminders.map((r) => ({
+        const reminderNoByIndex = (0, tool_1.computeReminderNoByIndex)(this.reminders);
+        const reminders = this.reminders.map((r, index) => ({
             content: r.content,
             meta: r.meta,
+            reminder_no: reminderNoByIndex.get(index),
+            echoback: (0, tool_1.reminderEchoBackEnabled)(r),
         }));
         // Emit full_reminders_update event with complete reminder list including metadata
         const fullRemindersEvt = {
@@ -652,7 +663,7 @@ class Dialog {
     async receiveFuncResult(result) {
         return await this.dlgStore.receiveFuncResult(this, result);
     }
-    async notifyGeneratingStart() {
+    async notifyGeneratingStart(msgId) {
         // Capture the generation's starting course so any events emitted during this generation
         // remain attributed to the correct course even if a tool mutates dialog.currentCourse
         // mid-generation (e.g., clear_mind).
@@ -668,7 +679,7 @@ class Dialog {
         // Mark generation as started with the actual genseq
         // This ensures subdialog_final_response_evt waits for both user_text and generating_start_evt
         this.markGenerationStarted();
-        await this.dlgStore.notifyGeneratingStart(this);
+        await this.dlgStore.notifyGeneratingStart(this, msgId);
     }
     async notifyGeneratingFinish(contextHealth, llmGenModel) {
         if (contextHealth) {
@@ -1070,7 +1081,7 @@ class DialogStore {
     /**
      * Notify start of LLM generation lifecycle (generating_start_evt)
      */
-    async notifyGeneratingStart(_dialog) { }
+    async notifyGeneratingStart(_dialog, _msgId) { }
     /**
      * Notify end of LLM generation lifecycle (generating_finish_evt)
      */

package/dist/llm/gen/anthropic.js

@@ -576,8 +576,8 @@ function validateReconstructedContext(messages) {
 }
 async function consumeAnthropicStream(stream, receiver, abortSignal, forcedJsonToolName) {
     // Stream lifecycle management using SDK start/stop events
-    let currentContentBlock = null;
-    let currentToolUse = null;
+    const activeContentBlocks = new Map();
+    const activeToolUses = new Map();
     let sayingStarted = false;
     let thinkingStarted = false;
     let usage = { kind: 'unavailable' };
@@ -588,23 +588,35 @@ async function consumeAnthropicStream(stream, receiver, abortSignal, forcedJsonT
         }
         switch (event.type) {
             case 'content_block_start': {
+                const blockIndex = event.index;
                 const contentBlock = event.content_block;
+                const existingBlock = activeContentBlocks.get(blockIndex);
+                if (existingBlock) {
+                    log.warn('ANTH content_block_start replacing active content block at index', new Error('content_block_start_without_stop'), {
+                        index: blockIndex,
+                        prevType: existingBlock.type,
+                        nextType: contentBlock.type,
+                    });
+                }
+                activeContentBlocks.set(blockIndex, contentBlock);
                 // Track tool use so we can emit function calls once JSON is complete
                 if (contentBlock.type === 'tool_use') {
-                    currentToolUse = {
+                    activeToolUses.set(blockIndex, {
                         id: contentBlock.id,
                         name: contentBlock.name,
                         inputJson: '',
                         initialInput: contentBlock.input,
-                    };
+                    });
                 }
-                currentContentBlock = contentBlock;
                 break;
             }
             case 'content_block_delta': {
+                const blockIndex = event.index;
+                const activeContentBlock = activeContentBlocks.get(blockIndex);
                 // Only process deltas for known content blocks
-                if (!currentContentBlock) {
+                if (!activeContentBlock) {
                     log.warn('ANTH unexpected content_block_delta without active content block', new Error('Delta received before content_block_start'), {
+                        index: blockIndex,
                         deltaType: event.delta.type,
                     });
                     break;
@@ -657,37 +669,44 @@ async function consumeAnthropicStream(stream, receiver, abortSignal, forcedJsonT
                 }
                 else if (delta.type === 'input_json_delta') {
                     const partialJson = delta.partial_json;
-                    if (currentToolUse) {
-                        applyInputJsonDelta(currentToolUse, partialJson);
+                    const activeToolUse = activeToolUses.get(blockIndex);
+                    if (activeToolUse) {
+                        applyInputJsonDelta(activeToolUse, partialJson);
                     }
                     else if (partialJson.length > 0) {
                         log.warn('ANTH input_json_delta without active tool_use', new Error('Input JSON delta received without active tool_use block'), {
-                            hasCurrentBlock: currentContentBlock !== null,
-                            blockType: currentContentBlock ? currentContentBlock.type : 'none',
+                            hasCurrentBlock: true,
+                            blockIndex,
+                            blockType: activeContentBlock.type,
                         });
                     }
                 }
                 break;
             }
             case 'content_block_stop': {
-                if (!currentContentBlock) {
+                const blockIndex = event.index;
+                const activeContentBlock = activeContentBlocks.get(blockIndex);
+                if (!activeContentBlock) {
                     break;
                 }
                 // Close thinking as soon as the thinking block ends so downstream UI/persistence reflects
                 // strict generation order (thinking first, then saying). This also avoids emitting
                 // thinking_finish after the main message has already completed.
-                if (currentContentBlock.type === 'thinking' && thinkingStarted) {
+                if (activeContentBlock.type === 'thinking' && thinkingStarted) {
                     await receiver.thinkingFinish();
                     thinkingStarted = false;
                 }
-                if (currentContentBlock.type === 'tool_use') {
-                    if (!currentToolUse) {
-                        log.warn('ANTH tool_use stop without active tool_use', new Error('Tool_use block stopped without active tool tracking'));
+                if (activeContentBlock.type === 'tool_use') {
+                    const activeToolUse = activeToolUses.get(blockIndex);
+                    if (!activeToolUse) {
+                        log.warn('ANTH tool_use stop without active tool_use', new Error('Tool_use block stopped without active tool tracking'), {
+                            blockIndex,
+                        });
                     }
                     else {
-                        if (forcedJsonToolName && currentToolUse.name === forcedJsonToolName) {
-                            const forcedInput = parseForcedJsonToolInput(currentToolUse.inputJson, currentToolUse.initialInput, `tool_use:${currentToolUse.id}:${currentToolUse.name}`);
-                            const jsonText = serializeAnthropicForcedJsonObject(forcedInput, `tool_use:${currentToolUse.id}:${currentToolUse.name}`);
+                        if (forcedJsonToolName && activeToolUse.name === forcedJsonToolName) {
+                            const forcedInput = parseForcedJsonToolInput(activeToolUse.inputJson, activeToolUse.initialInput, `tool_use:${activeToolUse.id}:${activeToolUse.name}`);
+                            const jsonText = serializeAnthropicForcedJsonObject(forcedInput, `tool_use:${activeToolUse.id}:${activeToolUse.name}`);
                             if (!sayingStarted) {
                                 sayingStarted = true;
                                 await receiver.sayingStart();
@@ -698,20 +717,20 @@ async function consumeAnthropicStream(stream, receiver, abortSignal, forcedJsonT
                         }
                         else {
                             let argsJson = '';
-                            if (currentToolUse.inputJson.trim().length > 0) {
-                                argsJson = currentToolUse.inputJson;
+                            if (activeToolUse.inputJson.trim().length > 0) {
+                                argsJson = activeToolUse.inputJson;
                             }
                             else {
-                                const stringified = JSON.stringify(currentToolUse.initialInput);
+                                const stringified = JSON.stringify(activeToolUse.initialInput);
                                 argsJson =
                                     typeof stringified === 'string' && stringified.length > 0 ? stringified : '{}';
                             }
-                            await receiver.funcCall(currentToolUse.id, currentToolUse.name, argsJson);
+                            await receiver.funcCall(activeToolUse.id, activeToolUse.name, argsJson);
                         }
                     }
-                    currentToolUse = null;
+                    activeToolUses.delete(blockIndex);
                 }
-                currentContentBlock = null;
+                activeContentBlocks.delete(blockIndex);
                 break;
             }
             case 'message_start': {
@@ -767,8 +786,8 @@ async function consumeAnthropicStream(stream, receiver, abortSignal, forcedJsonT
                 break;
             }
             case 'message_stop': {
-                currentContentBlock = null;
-                currentToolUse = null;
+                activeContentBlocks.clear();
+                activeToolUses.clear();
                 if (thinkingStarted) {
                     await receiver.thinkingFinish();
                     thinkingStarted = false;

package/dist/llm/gen/openai-compatible.js

@@ -627,7 +627,16 @@ class OpenAiCompatibleGen {
                 const toolCalls = delta.tool_calls;
                 if (Array.isArray(toolCalls)) {
                     for (const call of toolCalls) {
-                        const index = call.index;
+                        const rawIndex = call.index;
+                        if (typeof rawIndex !== 'number' || !Number.isInteger(rawIndex) || rawIndex < 0) {
+                            const detail = `OPENAI-COMPATIBLE invalid tool call index: ${JSON.stringify(rawIndex)}`;
+                            log.error(detail, new Error('openai_compatible_invalid_tool_call_index'));
+                            if (receiver.streamError) {
+                                await receiver.streamError(detail);
+                            }
+                            throw new Error(detail);
+                        }
+                        const index = rawIndex;
                         const existing = activeCallsByIndex.get(index);
                         const state = existing ??
                             {

package/dist/llm/kernel-driver/drive.js

@@ -12,6 +12,7 @@ const driver_messages_1 = require("../../shared/i18n/driver-messages");
 const runtime_language_1 = require("../../shared/runtime-language");
 const id_1 = require("../../shared/utils/id");
 const time_1 = require("../../shared/utils/time");
+const tool_1 = require("../../tool");
 const taskdoc_1 = require("../../utils/taskdoc");
 const client_1 = require("../client");
 const registry_1 = require("../gen/registry");
@@ -405,18 +406,30 @@ async function renderRemindersForContext(dlg) {
     if (dlg.reminders.length === 0)
         return [];
     const language = (0, runtime_language_1.getWorkLanguage)();
-    return await Promise.all(dlg.reminders.map(async (reminder, index) => {
+    const reminderNoByIndex = (0, tool_1.computeReminderNoByIndex)(dlg.reminders);
+    const rendered = [];
+    for (let index = 0; index < dlg.reminders.length; index += 1) {
+        const reminder = dlg.reminders[index];
+        if (!reminder || !(0, tool_1.reminderEchoBackEnabled)(reminder)) {
+            continue;
+        }
+        const reminderNo = reminderNoByIndex.get(index);
+        if (reminderNo === undefined) {
+            continue;
+        }
         if (reminder.owner) {
-            return await reminder.owner.renderReminder(dlg, reminder, index);
+            rendered.push(await reminder.owner.renderReminder(dlg, reminder, reminderNo - 1));
+            continue;
         }
-        return {
+        rendered.push({
             type: 'environment_msg',
             role: 'user',
-            content: (0, driver_messages_1.formatReminderItemGuide)(language, index + 1, reminder.content, {
+            content: (0, driver_messages_1.formatReminderItemGuide)(language, reminderNo, reminder.content, {
                 meta: reminder.meta,
             }),
-        };
-    }));
+        });
+    }
+    return rendered;
 }
 function parseUnifiedTimestampMs(ts) {
     const normalized = ts.trim();
@@ -1052,10 +1065,10 @@ async function driveDialogStreamCore(dlg, humanPrompt, driveOptions, callbacks)
             let contextHealthForGen;
             let llmGenModelForGen = model;
             let suspendForHuman = false;
-            await dlg.notifyGeneratingStart();
+            const currentPrompt = pendingPrompt;
+            pendingPrompt = undefined;
+            await dlg.notifyGeneratingStart(currentPrompt?.msgId);
             try {
-                const currentPrompt = pendingPrompt;
-                pendingPrompt = undefined;
                 if (currentPrompt) {
                     const origin = currentPrompt.origin ?? 'user';
                     if (origin === 'diligence_push' &&

package/dist/minds/system-prompt-parts.js

@@ -144,7 +144,7 @@ function getMemoryPromptCopy(ctx) {
             progressLine: '- 其中 `progress` 是全队共享公告牌：用于“阶段性进度快照”（关键决策/当前状态/下一步），不是流水账。',
             injectedTaskdocLine: '- 重要：差遣牒内容会被系统以内联形式注入到上下文中（本轮生成视角下即为最新；注入内容不包括全局约束）。需要回顾时请直接基于上下文里的差遣牒内容回顾与决策，不要试图用通用文件工具读取 `*.tsk/` 下的文件（会被拒绝）。',
             constraintsLine: '- 约定：`constraints` 只写任务特有的硬要求，不得写入系统提示/工具文档里已明确且由系统强制执行的通用规则（例如 `*.tsk/` 封装禁止通用文件工具）。一经发现重复，必须删除并告知用户。',
-            remindersLine: '- 提醒项（工作集）：当前对话的高频工作记录/关键细节（偏私有，不作为全队公告）；保持少量（常见 1–3 条），优先 `update_reminder` 压缩/合并，不再需要就 `delete_reminder`。',
+            remindersLine: '- 提醒项（即编号提醒，工作集）：当前对话的高频工作记录/关键细节（偏私有，不作为全队公告）；保持少量（常见 1–3 条），优先 `update_reminder` 压缩/合并，不再需要就 `delete_reminder`。',
             teamMemoryLine: '- 团队记忆：稳定的团队约定/工程规约（跨任务共享）。',
             personalMemoryLine: '- 个人记忆：稳定的个人习惯/偏好与职责域知识；可维护你职责范围内的“rtws 索引”（关键文档/代码的准确路径 + 必要要点），以减少重复读文件；不要记录具体任务状态。',
             subdialogDutyLine: `你当前处于支线对话：此处不允许 \`change_mind\`。当你判断需要更新差遣牒（尤其是 progress 公告牌）时，请在合适时机直接诉请差遣牒维护人 \`@${ctx.taskdocMaintainerId}\` 执行更新，并给出你已合并好的“新全文/替换稿”（用于替换对应章节全文）。不要声称已更新，除非看到回执。`,
@@ -166,7 +166,7 @@ function getMemoryPromptCopy(ctx) {
         progressLine: '- Taskdoc `progress` is the team’s shared bulletin board: distilled milestone snapshots (key decisions/current status/next steps), not raw logs.',
         injectedTaskdocLine: '- Important: the Taskdoc content is injected inline into the context (the latest as of this generation; injected content excludes global constraints). Review the injected Taskdoc instead of trying to read files under `*.tsk/` via general file tools (they will be rejected).',
         constraintsLine: '- Convention: Taskdoc `constraints` must contain task-specific requirements only; do not include global, system-enforced rules already stated in system prompt/tool docs (e.g. `.tsk/` encapsulation bans general file tools). If duplication is found, you MUST remove it and notify the user.',
-        remindersLine: '- Reminders (working set): your high-frequency per-dialog worklog + critical details (not a team bulletin board); keep it small (often 1–3 items), prefer `update_reminder` to compress/merge; delete when obsolete.',
+        remindersLine: '- Reminders (i.e. numbered reminders, working set): your high-frequency per-dialog worklog + critical details (not a team bulletin board); keep it small (often 1–3 items), prefer `update_reminder` to compress/merge; delete when obsolete.',
         teamMemoryLine: '- Team memory: stable shared conventions (cross-task).',
         personalMemoryLine: '- Personal memory: stable personal habits/preferences and responsibility-scope knowledge. Maintain a compact responsibility-area rtws index (exact key doc/code paths + minimal key facts) to reduce repeat file reads; do not store per-task state.',
         subdialogDutyLine: `You are currently in a subdialog: \`change_mind\` is not allowed here. When Taskdoc should be updated (especially the shared progress bulletin board), tellask the Taskdoc maintainer \`@${ctx.taskdocMaintainerId}\` with a fully merged replacement draft (full-section replacement). Do not claim it is updated until you see a receipt.`,

package/dist/persistence.js

@@ -819,7 +819,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
      * CRITICAL: This must be called BEFORE any substream events (thinking_start, markdown_start, etc.)
      * to ensure proper event ordering on the frontend.
      */
-    async notifyGeneratingStart(dialog) {
+    async notifyGeneratingStart(dialog, msgId) {
         const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
         const genseq = dialog.activeGenSeq;
         try {
@@ -837,6 +837,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 type: 'generating_start_evt',
                 course,
                 genseq: genseq,
+                msgId: typeof msgId === 'string' && msgId.trim() !== '' ? msgId : undefined,
             };
             (0, evt_registry_1.postDialogEvent)(dialog, genStartEvt);
             // Update generating flag in latest.yaml
@@ -1460,11 +1461,14 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             }
             // Rehydrate reminders from dialog state
             const dialogState = await DialogPersistence.restoreDialog(dialog.id, status);
-            const rehydrated = (dialogState?.reminders ?? []).map((r) => {
-                return { content: r.content, owner: r.owner, meta: r.meta };
-            });
+            if (!dialogState) {
+                throw new Error(`Dialog state missing during direct event replay: ${dialog.id.valueOf()} (${status})`);
+            }
+            // Keep typed reminder objects as-is instead of field-picking rehydrate.
+            // This prevents accidental field loss (e.g. echoback) when Reminder shape evolves.
+            const restoredReminders = dialogState.reminders;
             dialog.reminders.length = 0;
-            dialog.reminders.push(...rehydrated);
+            dialog.reminders.push(...restoredReminders);
         }
         catch (error) {
             log_1.log.error(`Failed to send dialog events directly for ${dialog.id.selfId}:`, error);
@@ -2641,6 +2645,7 @@ class DialogPersistence {
                     content: r.content,
                     ownerName: r.owner ? r.owner.name : undefined,
                     meta: r.meta,
+                    echoback: r.echoback,
                     createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
                     priority: 'medium',
                 })),
@@ -2675,6 +2680,7 @@ class DialogPersistence {
                         content: r.content,
                         owner,
                         meta: r.meta,
+                        echoback: r.echoback,
                         createdAt: r.createdAt,
                         priority: r.priority,
                     };

package/dist/server/websocket-handler.js

@@ -82,6 +82,39 @@ function resolveUserLanguageCode(ws, raw, fallbackDialog) {
         return fallbackDialog.getLastUserLanguageCode();
     return (0, runtime_language_1.getWorkLanguage)();
 }
+async function queueUserSupplementAtGenerationBoundary(dialog, prompt) {
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialog.id, 'running');
+    const runStateKind = latest?.runState?.kind;
+    if (runStateKind !== 'proceeding') {
+        return false;
+    }
+    if (!dialog.isLocked()) {
+        return false;
+    }
+    if (dialog.hasUpNext()) {
+        throw new Error(`Dialog already has pending upNext prompt; cannot queue supplement now (dialog=${dialog.id.valueOf()} incomingMsgId=${prompt.msgId})`);
+    }
+    dialog.queueUpNextPrompt({
+        prompt: prompt.content,
+        msgId: prompt.msgId,
+        grammar: prompt.grammar,
+        userLanguageCode: prompt.userLanguageCode,
+    });
+    (0, evt_registry_1.postDialogEvent)(dialog, {
+        type: 'queue_user_msg_evt',
+        course: dialog.currentCourse,
+        msgId: prompt.msgId,
+        content: prompt.content,
+        grammar: prompt.grammar,
+        userLanguageCode: prompt.userLanguageCode,
+    });
+    log.debug('Queued user supplement for next generation boundary', undefined, {
+        rootId: dialog.id.rootId,
+        selfId: dialog.id.selfId,
+        msgId: prompt.msgId,
+    });
+    return true;
+}
 /**
  * Get error code from unknown error
  */
@@ -948,6 +981,10 @@ async function handleUserMsg2Dlg(ws, packet) {
             existingDialog.status === 'running' &&
             existingSub &&
             existingSub.dialogKey === existingDialog.id.valueOf()) {
+            const queuedAtBoundary = await queueUserSupplementAtGenerationBoundary(existingDialog, effectivePrompt);
+            if (queuedAtBoundary) {
+                return;
+            }
             await (0, kernel_driver_1.driveDialogStream)(existingDialog, {
                 content: effectivePrompt.content,
                 msgId: effectivePrompt.msgId,
@@ -974,6 +1011,10 @@ async function handleUserMsg2Dlg(ws, packet) {
                 return;
             }
             await setupWebSocketSubscription(ws, dialog);
+            const queuedAtBoundary = await queueUserSupplementAtGenerationBoundary(dialog, effectivePrompt);
+            if (queuedAtBoundary) {
+                return;
+            }
             await (0, kernel_driver_1.driveDialogStream)(dialog, {
                 content: effectivePrompt.content,
                 msgId: effectivePrompt.msgId,

package/dist/static/assets/_basePickBy-B82bRmTe.js

@@ -0,0 +1,196 @@
+import { e as isSymbol, c as baseFlatten, g as baseIteratee, k as keys, h as baseFindIndex, j as baseEach, l as arrayMap, m as hasPath, n as castPath, t as toKey, o as baseGet } from "./_baseUniq-BqskSet8.js";
+import { aR as isObject, aA as baseRest, aS as isIterateeCall, aT as keysIn, aU as eq, aV as isArrayLike, aW as isArray, aX as identity, aY as isIndex, aZ as assignValue } from "./index-C0pO-3BA.js";
+var reWhitespace = /\s/;
+function trimmedEndIndex(string) {
+  var index = string.length;
+  while (index-- && reWhitespace.test(string.charAt(index))) {
+  }
+  return index;
+}
+var reTrimStart = /^\s+/;
+function baseTrim(string) {
+  return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string;
+}
+var NAN = 0 / 0;
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+var reIsBinary = /^0b[01]+$/i;
+var reIsOctal = /^0o[0-7]+$/i;
+var freeParseInt = parseInt;
+function toNumber(value) {
+  if (typeof value == "number") {
+    return value;
+  }
+  if (isSymbol(value)) {
+    return NAN;
+  }
+  if (isObject(value)) {
+    var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+    value = isObject(other) ? other + "" : other;
+  }
+  if (typeof value != "string") {
+    return value === 0 ? value : +value;
+  }
+  value = baseTrim(value);
+  var isBinary = reIsBinary.test(value);
+  return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+}
+var INFINITY = 1 / 0, MAX_INTEGER = 17976931348623157e292;
+function toFinite(value) {
+  if (!value) {
+    return value === 0 ? value : 0;
+  }
+  value = toNumber(value);
+  if (value === INFINITY || value === -INFINITY) {
+    var sign = value < 0 ? -1 : 1;
+    return sign * MAX_INTEGER;
+  }
+  return value === value ? value : 0;
+}
+function toInteger(value) {
+  var result = toFinite(value), remainder = result % 1;
+  return result === result ? remainder ? result - remainder : result : 0;
+}
+function flatten(array) {
+  var length = array == null ? 0 : array.length;
+  return length ? baseFlatten(array) : [];
+}
+var objectProto$1 = Object.prototype;
+var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+var defaults = baseRest(function(object, sources) {
+  object = Object(object);
+  var index = -1;
+  var length = sources.length;
+  var guard = length > 2 ? sources[2] : void 0;
+  if (guard && isIterateeCall(sources[0], sources[1], guard)) {
+    length = 1;
+  }
+  while (++index < length) {
+    var source = sources[index];
+    var props = keysIn(source);
+    var propsIndex = -1;
+    var propsLength = props.length;
+    while (++propsIndex < propsLength) {
+      var key = props[propsIndex];
+      var value = object[key];
+      if (value === void 0 || eq(value, objectProto$1[key]) && !hasOwnProperty$1.call(object, key)) {
+        object[key] = source[key];
+      }
+    }
+  }
+  return object;
+});
+function last(array) {
+  var length = array == null ? 0 : array.length;
+  return length ? array[length - 1] : void 0;
+}
+function createFind(findIndexFunc) {
+  return function(collection, predicate, fromIndex) {
+    var iterable = Object(collection);
+    if (!isArrayLike(collection)) {
+      var iteratee = baseIteratee(predicate);
+      collection = keys(collection);
+      predicate = function(key) {
+        return iteratee(iterable[key], key, iterable);
+      };
+    }
+    var index = findIndexFunc(collection, predicate, fromIndex);
+    return index > -1 ? iterable[iteratee ? collection[index] : index] : void 0;
+  };
+}
+var nativeMax = Math.max;
+function findIndex(array, predicate, fromIndex) {
+  var length = array == null ? 0 : array.length;
+  if (!length) {
+    return -1;
+  }
+  var index = fromIndex == null ? 0 : toInteger(fromIndex);
+  if (index < 0) {
+    index = nativeMax(length + index, 0);
+  }
+  return baseFindIndex(array, baseIteratee(predicate), index);
+}
+var find = createFind(findIndex);
+function baseMap(collection, iteratee) {
+  var index = -1, result = isArrayLike(collection) ? Array(collection.length) : [];
+  baseEach(collection, function(value, key, collection2) {
+    result[++index] = iteratee(value, key, collection2);
+  });
+  return result;
+}
+function map(collection, iteratee) {
+  var func = isArray(collection) ? arrayMap : baseMap;
+  return func(collection, baseIteratee(iteratee));
+}
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+function baseHas(object, key) {
+  return object != null && hasOwnProperty.call(object, key);
+}
+function has(object, path) {
+  return object != null && hasPath(object, path, baseHas);
+}
+function baseLt(value, other) {
+  return value < other;
+}
+function baseExtremum(array, iteratee, comparator) {
+  var index = -1, length = array.length;
+  while (++index < length) {
+    var value = array[index], current = iteratee(value);
+    if (current != null && (computed === void 0 ? current === current && !isSymbol(current) : comparator(current, computed))) {
+      var computed = current, result = value;
+    }
+  }
+  return result;
+}
+function min(array) {
+  return array && array.length ? baseExtremum(array, identity, baseLt) : void 0;
+}
+function baseSet(object, path, value, customizer) {
+  if (!isObject(object)) {
+    return object;
+  }
+  path = castPath(path, object);
+  var index = -1, length = path.length, lastIndex = length - 1, nested = object;
+  while (nested != null && ++index < length) {
+    var key = toKey(path[index]), newValue = value;
+    if (key === "__proto__" || key === "constructor" || key === "prototype") {
+      return object;
+    }
+    if (index != lastIndex) {
+      var objValue = nested[key];
+      newValue = void 0;
+      if (newValue === void 0) {
+        newValue = isObject(objValue) ? objValue : isIndex(path[index + 1]) ? [] : {};
+      }
+    }
+    assignValue(nested, key, newValue);
+    nested = nested[key];
+  }
+  return object;
+}
+function basePickBy(object, paths, predicate) {
+  var index = -1, length = paths.length, result = {};
+  while (++index < length) {
+    var path = paths[index], value = baseGet(object, path);
+    if (predicate(value, path)) {
+      baseSet(result, castPath(path, object), value);
+    }
+  }
+  return result;
+}
+export {
+  baseLt as a,
+  baseExtremum as b,
+  baseMap as c,
+  basePickBy as d,
+  min as e,
+  flatten as f,
+  find as g,
+  has as h,
+  defaults as i,
+  toInteger as j,
+  last as l,
+  map as m,
+  toFinite as t
+};
+//# sourceMappingURL=_basePickBy-B82bRmTe.js.map