qidian-vue-ui 1.0.81 → 1.0.83

package/dist/{index-BlJoQteI.js → index-LWHwXGdo.js}

@@ -1351,6 +1351,8 @@ const isPromise = (val) => {
 const identifyType = (val) => {
   return toTypeStr(val).replace("[object ", "").replace("]", "").toLowerCase();
 };
+function noop() {
+}
 function isEmpty(val) {
   if (val == null) return true;
   if (typeof val === "string" && val.trim() === "") return true;
@@ -11650,6 +11652,673 @@ var __extends = /* @__PURE__ */ (function() {
 })(RSAKey);
 var _a;
 typeof process !== "undefined" ? (_a = __vite_import_meta_env__1) === null || _a === void 0 ? void 0 : _a.npm_package_version : void 0;
+class JSONRepairError extends Error {
+  constructor(message, position) {
+    super(`${message} at position ${position}`);
+    this.position = position;
+  }
+}
+const codeSpace = 32;
+const codeNewline = 10;
+const codeTab = 9;
+const codeReturn = 13;
+const codeNonBreakingSpace = 160;
+const codeEnQuad = 8192;
+const codeHairSpace = 8202;
+const codeNarrowNoBreakSpace = 8239;
+const codeMediumMathematicalSpace = 8287;
+const codeIdeographicSpace = 12288;
+function isHex(char) {
+  return /^[0-9A-Fa-f]$/.test(char);
+}
+function isDigit(char) {
+  return char >= "0" && char <= "9";
+}
+function isValidStringCharacter(char) {
+  return char >= " ";
+}
+function isDelimiter(char) {
+  return ",:[]/{}()\n+".includes(char);
+}
+function isFunctionNameCharStart(char) {
+  return char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char === "_" || char === "$";
+}
+function isFunctionNameChar(char) {
+  return char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char === "_" || char === "$" || char >= "0" && char <= "9";
+}
+const regexUrlStart = /^(http|https|ftp|mailto|file|data|irc):\/\/$/;
+const regexUrlChar = /^[A-Za-z0-9-._~:/?#@!$&'()*+;=]$/;
+function isUnquotedStringDelimiter(char) {
+  return ",[]/{}\n+".includes(char);
+}
+function isStartOfValue(char) {
+  return isQuote(char) || regexStartOfValue.test(char);
+}
+const regexStartOfValue = /^[[{\w-]$/;
+function isControlCharacter(char) {
+  return char === "\n" || char === "\r" || char === "	" || char === "\b" || char === "\f";
+}
+function isWhitespace(text, index2) {
+  const code = text.charCodeAt(index2);
+  return code === codeSpace || code === codeNewline || code === codeTab || code === codeReturn;
+}
+function isWhitespaceExceptNewline(text, index2) {
+  const code = text.charCodeAt(index2);
+  return code === codeSpace || code === codeTab || code === codeReturn;
+}
+function isSpecialWhitespace(text, index2) {
+  const code = text.charCodeAt(index2);
+  return code === codeNonBreakingSpace || code >= codeEnQuad && code <= codeHairSpace || code === codeNarrowNoBreakSpace || code === codeMediumMathematicalSpace || code === codeIdeographicSpace;
+}
+function isQuote(char) {
+  return isDoubleQuoteLike(char) || isSingleQuoteLike(char);
+}
+function isDoubleQuoteLike(char) {
+  return char === '"' || char === "“" || char === "”";
+}
+function isDoubleQuote(char) {
+  return char === '"';
+}
+function isSingleQuoteLike(char) {
+  return char === "'" || char === "‘" || char === "’" || char === "`" || char === "´";
+}
+function isSingleQuote(char) {
+  return char === "'";
+}
+function stripLastOccurrence(text, textToStrip) {
+  let stripRemainingText = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+  const index2 = text.lastIndexOf(textToStrip);
+  return index2 !== -1 ? text.substring(0, index2) + (stripRemainingText ? "" : text.substring(index2 + 1)) : text;
+}
+function insertBeforeLastWhitespace(text, textToInsert) {
+  let index2 = text.length;
+  if (!isWhitespace(text, index2 - 1)) {
+    return text + textToInsert;
+  }
+  while (isWhitespace(text, index2 - 1)) {
+    index2--;
+  }
+  return text.substring(0, index2) + textToInsert + text.substring(index2);
+}
+function removeAtIndex(text, start, count) {
+  return text.substring(0, start) + text.substring(start + count);
+}
+function endsWithCommaOrNewline(text) {
+  return /[,\n][ \t\r]*$/.test(text);
+}
+const controlCharacters = {
+  "\b": "\\b",
+  "\f": "\\f",
+  "\n": "\\n",
+  "\r": "\\r",
+  "	": "\\t"
+};
+const escapeCharacters = {
+  '"': '"',
+  "\\": "\\",
+  "/": "/",
+  b: "\b",
+  f: "\f",
+  n: "\n",
+  r: "\r",
+  t: "	"
+  // note that \u is handled separately in parseString()
+};
+function jsonrepair(text) {
+  let i = 0;
+  let output = "";
+  parseMarkdownCodeBlock(["```", "[```", "{```"]);
+  const processed = parseValue();
+  if (!processed) {
+    throwUnexpectedEnd();
+  }
+  parseMarkdownCodeBlock(["```", "```]", "```}"]);
+  const processedComma = parseCharacter(",");
+  if (processedComma) {
+    parseWhitespaceAndSkipComments();
+  }
+  if (isStartOfValue(text[i]) && endsWithCommaOrNewline(output)) {
+    if (!processedComma) {
+      output = insertBeforeLastWhitespace(output, ",");
+    }
+    parseNewlineDelimitedJSON();
+  } else if (processedComma) {
+    output = stripLastOccurrence(output, ",");
+  }
+  while (text[i] === "}" || text[i] === "]") {
+    i++;
+    parseWhitespaceAndSkipComments();
+  }
+  if (i >= text.length) {
+    return output;
+  }
+  throwUnexpectedCharacter();
+  function parseValue() {
+    parseWhitespaceAndSkipComments();
+    const processed2 = parseObject() || parseArray() || parseString() || parseNumber() || parseKeywords() || parseUnquotedString(false) || parseRegex();
+    parseWhitespaceAndSkipComments();
+    return processed2;
+  }
+  function parseWhitespaceAndSkipComments() {
+    let skipNewline = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+    const start = i;
+    let changed = parseWhitespace(skipNewline);
+    do {
+      changed = parseComment();
+      if (changed) {
+        changed = parseWhitespace(skipNewline);
+      }
+    } while (changed);
+    return i > start;
+  }
+  function parseWhitespace(skipNewline) {
+    const _isWhiteSpace = skipNewline ? isWhitespace : isWhitespaceExceptNewline;
+    let whitespace = "";
+    while (true) {
+      if (_isWhiteSpace(text, i)) {
+        whitespace += text[i];
+        i++;
+      } else if (isSpecialWhitespace(text, i)) {
+        whitespace += " ";
+        i++;
+      } else {
+        break;
+      }
+    }
+    if (whitespace.length > 0) {
+      output += whitespace;
+      return true;
+    }
+    return false;
+  }
+  function parseComment() {
+    if (text[i] === "/" && text[i + 1] === "*") {
+      while (i < text.length && !atEndOfBlockComment(text, i)) {
+        i++;
+      }
+      i += 2;
+      return true;
+    }
+    if (text[i] === "/" && text[i + 1] === "/") {
+      while (i < text.length && text[i] !== "\n") {
+        i++;
+      }
+      return true;
+    }
+    return false;
+  }
+  function parseMarkdownCodeBlock(blocks) {
+    if (skipMarkdownCodeBlock(blocks)) {
+      if (isFunctionNameCharStart(text[i])) {
+        while (i < text.length && isFunctionNameChar(text[i])) {
+          i++;
+        }
+      }
+      parseWhitespaceAndSkipComments();
+      return true;
+    }
+    return false;
+  }
+  function skipMarkdownCodeBlock(blocks) {
+    parseWhitespace(true);
+    for (const block of blocks) {
+      const end = i + block.length;
+      if (text.slice(i, end) === block) {
+        i = end;
+        return true;
+      }
+    }
+    return false;
+  }
+  function parseCharacter(char) {
+    if (text[i] === char) {
+      output += text[i];
+      i++;
+      return true;
+    }
+    return false;
+  }
+  function skipCharacter(char) {
+    if (text[i] === char) {
+      i++;
+      return true;
+    }
+    return false;
+  }
+  function skipEscapeCharacter() {
+    return skipCharacter("\\");
+  }
+  function skipEllipsis() {
+    parseWhitespaceAndSkipComments();
+    if (text[i] === "." && text[i + 1] === "." && text[i + 2] === ".") {
+      i += 3;
+      parseWhitespaceAndSkipComments();
+      skipCharacter(",");
+      return true;
+    }
+    return false;
+  }
+  function parseObject() {
+    if (text[i] === "{") {
+      output += "{";
+      i++;
+      parseWhitespaceAndSkipComments();
+      if (skipCharacter(",")) {
+        parseWhitespaceAndSkipComments();
+      }
+      let initial = true;
+      while (i < text.length && text[i] !== "}") {
+        let processedComma2;
+        if (!initial) {
+          processedComma2 = parseCharacter(",");
+          if (!processedComma2) {
+            output = insertBeforeLastWhitespace(output, ",");
+          }
+          parseWhitespaceAndSkipComments();
+        } else {
+          processedComma2 = true;
+          initial = false;
+        }
+        skipEllipsis();
+        const processedKey = parseString() || parseUnquotedString(true);
+        if (!processedKey) {
+          if (text[i] === "}" || text[i] === "{" || text[i] === "]" || text[i] === "[" || text[i] === void 0) {
+            output = stripLastOccurrence(output, ",");
+          } else {
+            throwObjectKeyExpected();
+          }
+          break;
+        }
+        parseWhitespaceAndSkipComments();
+        const processedColon = parseCharacter(":");
+        const truncatedText = i >= text.length;
+        if (!processedColon) {
+          if (isStartOfValue(text[i]) || truncatedText) {
+            output = insertBeforeLastWhitespace(output, ":");
+          } else {
+            throwColonExpected();
+          }
+        }
+        const processedValue = parseValue();
+        if (!processedValue) {
+          if (processedColon || truncatedText) {
+            output += "null";
+          } else {
+            throwColonExpected();
+          }
+        }
+      }
+      if (text[i] === "}") {
+        output += "}";
+        i++;
+      } else {
+        output = insertBeforeLastWhitespace(output, "}");
+      }
+      return true;
+    }
+    return false;
+  }
+  function parseArray() {
+    if (text[i] === "[") {
+      output += "[";
+      i++;
+      parseWhitespaceAndSkipComments();
+      if (skipCharacter(",")) {
+        parseWhitespaceAndSkipComments();
+      }
+      let initial = true;
+      while (i < text.length && text[i] !== "]") {
+        if (!initial) {
+          const processedComma2 = parseCharacter(",");
+          if (!processedComma2) {
+            output = insertBeforeLastWhitespace(output, ",");
+          }
+        } else {
+          initial = false;
+        }
+        skipEllipsis();
+        const processedValue = parseValue();
+        if (!processedValue) {
+          output = stripLastOccurrence(output, ",");
+          break;
+        }
+      }
+      if (text[i] === "]") {
+        output += "]";
+        i++;
+      } else {
+        output = insertBeforeLastWhitespace(output, "]");
+      }
+      return true;
+    }
+    return false;
+  }
+  function parseNewlineDelimitedJSON() {
+    let initial = true;
+    let processedValue = true;
+    while (processedValue) {
+      if (!initial) {
+        const processedComma2 = parseCharacter(",");
+        if (!processedComma2) {
+          output = insertBeforeLastWhitespace(output, ",");
+        }
+      } else {
+        initial = false;
+      }
+      processedValue = parseValue();
+    }
+    if (!processedValue) {
+      output = stripLastOccurrence(output, ",");
+    }
+    output = `[
+${output}
+]`;
+  }
+  function parseString() {
+    let stopAtDelimiter = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : false;
+    let stopAtIndex = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : -1;
+    let skipEscapeChars = text[i] === "\\";
+    if (skipEscapeChars) {
+      i++;
+      skipEscapeChars = true;
+    }
+    if (isQuote(text[i])) {
+      const isEndQuote = isDoubleQuote(text[i]) ? isDoubleQuote : isSingleQuote(text[i]) ? isSingleQuote : isSingleQuoteLike(text[i]) ? isSingleQuoteLike : isDoubleQuoteLike;
+      const iBefore = i;
+      const oBefore = output.length;
+      let str = '"';
+      i++;
+      while (true) {
+        if (i >= text.length) {
+          const iPrev = prevNonWhitespaceIndex(i - 1);
+          if (!stopAtDelimiter && isDelimiter(text.charAt(iPrev))) {
+            i = iBefore;
+            output = output.substring(0, oBefore);
+            return parseString(true);
+          }
+          str = insertBeforeLastWhitespace(str, '"');
+          output += str;
+          return true;
+        }
+        if (i === stopAtIndex) {
+          str = insertBeforeLastWhitespace(str, '"');
+          output += str;
+          return true;
+        }
+        if (isEndQuote(text[i])) {
+          const iQuote = i;
+          const oQuote = str.length;
+          str += '"';
+          i++;
+          output += str;
+          parseWhitespaceAndSkipComments(false);
+          if (stopAtDelimiter || i >= text.length || isDelimiter(text[i]) || isQuote(text[i]) || isDigit(text[i])) {
+            parseConcatenatedString();
+            return true;
+          }
+          const iPrevChar = prevNonWhitespaceIndex(iQuote - 1);
+          const prevChar = text.charAt(iPrevChar);
+          if (prevChar === ",") {
+            i = iBefore;
+            output = output.substring(0, oBefore);
+            return parseString(false, iPrevChar);
+          }
+          if (isDelimiter(prevChar)) {
+            i = iBefore;
+            output = output.substring(0, oBefore);
+            return parseString(true);
+          }
+          output = output.substring(0, oBefore);
+          i = iQuote + 1;
+          str = `${str.substring(0, oQuote)}\\${str.substring(oQuote)}`;
+        } else if (stopAtDelimiter && isUnquotedStringDelimiter(text[i])) {
+          if (text[i - 1] === ":" && regexUrlStart.test(text.substring(iBefore + 1, i + 2))) {
+            while (i < text.length && regexUrlChar.test(text[i])) {
+              str += text[i];
+              i++;
+            }
+          }
+          str = insertBeforeLastWhitespace(str, '"');
+          output += str;
+          parseConcatenatedString();
+          return true;
+        } else if (text[i] === "\\") {
+          const char = text.charAt(i + 1);
+          const escapeChar = escapeCharacters[char];
+          if (escapeChar !== void 0) {
+            str += text.slice(i, i + 2);
+            i += 2;
+          } else if (char === "u") {
+            let j = 2;
+            while (j < 6 && isHex(text[i + j])) {
+              j++;
+            }
+            if (j === 6) {
+              str += text.slice(i, i + 6);
+              i += 6;
+            } else if (i + j >= text.length) {
+              i = text.length;
+            } else {
+              throwInvalidUnicodeCharacter();
+            }
+          } else {
+            str += char;
+            i += 2;
+          }
+        } else {
+          const char = text.charAt(i);
+          if (char === '"' && text[i - 1] !== "\\") {
+            str += `\\${char}`;
+            i++;
+          } else if (isControlCharacter(char)) {
+            str += controlCharacters[char];
+            i++;
+          } else {
+            if (!isValidStringCharacter(char)) {
+              throwInvalidCharacter(char);
+            }
+            str += char;
+            i++;
+          }
+        }
+        if (skipEscapeChars) {
+          skipEscapeCharacter();
+        }
+      }
+    }
+    return false;
+  }
+  function parseConcatenatedString() {
+    let processed2 = false;
+    parseWhitespaceAndSkipComments();
+    while (text[i] === "+") {
+      processed2 = true;
+      i++;
+      parseWhitespaceAndSkipComments();
+      output = stripLastOccurrence(output, '"', true);
+      const start = output.length;
+      const parsedStr = parseString();
+      if (parsedStr) {
+        output = removeAtIndex(output, start, 1);
+      } else {
+        output = insertBeforeLastWhitespace(output, '"');
+      }
+    }
+    return processed2;
+  }
+  function parseNumber() {
+    const start = i;
+    if (text[i] === "-") {
+      i++;
+      if (atEndOfNumber()) {
+        repairNumberEndingWithNumericSymbol(start);
+        return true;
+      }
+      if (!isDigit(text[i])) {
+        i = start;
+        return false;
+      }
+    }
+    while (isDigit(text[i])) {
+      i++;
+    }
+    if (text[i] === ".") {
+      i++;
+      if (atEndOfNumber()) {
+        repairNumberEndingWithNumericSymbol(start);
+        return true;
+      }
+      if (!isDigit(text[i])) {
+        i = start;
+        return false;
+      }
+      while (isDigit(text[i])) {
+        i++;
+      }
+    }
+    if (text[i] === "e" || text[i] === "E") {
+      i++;
+      if (text[i] === "-" || text[i] === "+") {
+        i++;
+      }
+      if (atEndOfNumber()) {
+        repairNumberEndingWithNumericSymbol(start);
+        return true;
+      }
+      if (!isDigit(text[i])) {
+        i = start;
+        return false;
+      }
+      while (isDigit(text[i])) {
+        i++;
+      }
+    }
+    if (!atEndOfNumber()) {
+      i = start;
+      return false;
+    }
+    if (i > start) {
+      const num = text.slice(start, i);
+      const hasInvalidLeadingZero = /^0\d/.test(num);
+      output += hasInvalidLeadingZero ? `"${num}"` : num;
+      return true;
+    }
+    return false;
+  }
+  function parseKeywords() {
+    return parseKeyword("true", "true") || parseKeyword("false", "false") || parseKeyword("null", "null") || // repair Python keywords True, False, None
+    parseKeyword("True", "true") || parseKeyword("False", "false") || parseKeyword("None", "null");
+  }
+  function parseKeyword(name, value) {
+    if (text.slice(i, i + name.length) === name) {
+      output += value;
+      i += name.length;
+      return true;
+    }
+    return false;
+  }
+  function parseUnquotedString(isKey2) {
+    const start = i;
+    if (isFunctionNameCharStart(text[i])) {
+      while (i < text.length && isFunctionNameChar(text[i])) {
+        i++;
+      }
+      let j = i;
+      while (isWhitespace(text, j)) {
+        j++;
+      }
+      if (text[j] === "(") {
+        i = j + 1;
+        parseValue();
+        if (text[i] === ")") {
+          i++;
+          if (text[i] === ";") {
+            i++;
+          }
+        }
+        return true;
+      }
+    }
+    while (i < text.length && !isUnquotedStringDelimiter(text[i]) && !isQuote(text[i]) && (!isKey2 || text[i] !== ":")) {
+      i++;
+    }
+    if (text[i - 1] === ":" && regexUrlStart.test(text.substring(start, i + 2))) {
+      while (i < text.length && regexUrlChar.test(text[i])) {
+        i++;
+      }
+    }
+    if (i > start) {
+      while (isWhitespace(text, i - 1) && i > 0) {
+        i--;
+      }
+      const symbol = text.slice(start, i);
+      output += symbol === "undefined" ? "null" : JSON.stringify(symbol);
+      if (text[i] === '"') {
+        i++;
+      }
+      return true;
+    }
+  }
+  function parseRegex() {
+    if (text[i] === "/") {
+      const start = i;
+      i++;
+      while (i < text.length && (text[i] !== "/" || text[i - 1] === "\\")) {
+        i++;
+      }
+      i++;
+      output += `"${text.substring(start, i)}"`;
+      return true;
+    }
+  }
+  function prevNonWhitespaceIndex(start) {
+    let prev = start;
+    while (prev > 0 && isWhitespace(text, prev)) {
+      prev--;
+    }
+    return prev;
+  }
+  function atEndOfNumber() {
+    return i >= text.length || isDelimiter(text[i]) || isWhitespace(text, i);
+  }
+  function repairNumberEndingWithNumericSymbol(start) {
+    output += `${text.slice(start, i)}0`;
+  }
+  function throwInvalidCharacter(char) {
+    throw new JSONRepairError(`Invalid character ${JSON.stringify(char)}`, i);
+  }
+  function throwUnexpectedCharacter() {
+    throw new JSONRepairError(`Unexpected character ${JSON.stringify(text[i])}`, i);
+  }
+  function throwUnexpectedEnd() {
+    throw new JSONRepairError("Unexpected end of json string", text.length);
+  }
+  function throwObjectKeyExpected() {
+    throw new JSONRepairError("Object key expected", i);
+  }
+  function throwColonExpected() {
+    throw new JSONRepairError("Colon expected", i);
+  }
+  function throwInvalidUnicodeCharacter() {
+    const chars = text.slice(i, i + 6);
+    throw new JSONRepairError(`Invalid unicode character "${chars}"`, i);
+  }
+}
+function atEndOfBlockComment(text, i) {
+  return text[i] === "*" && text[i + 1] === "/";
+}
+function parseRelaxedJSON(str, options) {
+  const startObj = str.indexOf("{");
+  const endObj = str.lastIndexOf("}");
+  const startArr = str.indexOf("[");
+  const endArr = str.lastIndexOf("]");
+  if (startObj > -1 && endObj > -1 && endObj > startObj) {
+    str = str.slice(startObj, endObj + 1);
+  } else if (startArr > -1 && endArr > -1 && endArr > startArr) {
+    str = str.slice(startArr, endArr + 1);
+  }
+  return JSON.parse(jsonrepair(str));
+}
 function to(promise, errorExt) {
   return promise.then((data) => [null, data]).catch((err) => {
     return [err ?? true, void 0];
@@ -11939,7 +12608,42 @@ function useServicePagination({
   };
 }
 const __vite_import_meta_env__ = {};
-__vite_import_meta_env__1?.NODE_ENV !== "production" || __vite_import_meta_env__ && false;
+const cslType = ["log", "warn", "error"];
+const isDev = __vite_import_meta_env__1?.NODE_ENV !== "production" || __vite_import_meta_env__ && false;
+function useCsl(module2) {
+  const toStr = (data) => {
+    if (typeof data === "object") return data.join(".");
+    if (typeof data === "number") return data.toString();
+    return data;
+  };
+  module2 = toStr(module2);
+  const getModule = (childModule) => {
+    if (isEmpty(childModule)) return `[${module2}]`;
+    childModule = toStr(childModule);
+    if (childModule) childModule = "." + childModule;
+    return `[${module2}${childModule}]`;
+  };
+  const core2 = (type = "log", childModule, ...rest) => {
+    if (isEmpty(rest)) {
+      console[type](getModule(), childModule);
+      return;
+    }
+    console[type](getModule(childModule), ...rest);
+  };
+  const csl2 = {
+    useNext(childModule) {
+      return useCsl(getModule(childModule).replace(/\[|\]/g, ""));
+    }
+  };
+  cslType.forEach((item) => {
+    const temp = (childModule, ...rest) => {
+      core2(item, childModule, ...rest);
+    };
+    temp.dev = isDev ? temp : noop;
+    csl2[item] = temp;
+  });
+  return csl2;
+}
 function useTimer(type = "timeout") {
   const timer = vue.ref(null);
   const clearTimer = () => {
@@ -11989,6 +12693,10 @@ const QdConfigProvider = vue.defineComponent({
       type: Object,
       default: void 0
     },
+    agentChat: {
+      type: Object,
+      default: void 0
+    },
     globalConfig: {
       type: Object,
       default: void 0
@@ -12006,24 +12714,22 @@ const QdConfigProvider = vue.defineComponent({
     vue.provide(PROVIDE_DICT, props.dict);
     vue.provide(PROVIDE_UPLOAD, props.upload);
     vue.provide(PROVIDE_GLOBAL_CONFIG, mergedGlobalConfig);
-    if (typeof window !== "undefined") {
-      window.__QIDIAN_USER__ = props.user;
-      window.__QIDIAN_DICT__ = props.dict;
-    }
     vue.watch(
-      () => [props.user, props.dict],
-      ([newUser, newDict]) => {
+      () => [props.user, props.dict, props.agentChat],
+      ([newUser, newDict, newAgentChat]) => {
         if (typeof window !== "undefined") {
           window.__QIDIAN_USER__ = newUser;
           window.__QIDIAN_DICT__ = newDict;
+          window.__QIDIAN_AGENT_CHAT__ = newAgentChat;
         }
-      }
+      },
+      { immediate: true }
     );
     vue.watchEffect(async () => {
       const localeMap = {
         "zh-CN": () => Promise.resolve().then(() => zhCN$1),
-        "zh-TW": () => Promise.resolve().then(() => require("./zh-TW-cICAXa5I.js")),
-        "en-US": () => Promise.resolve().then(() => require("./en-US-VDFbyOjk.js"))
+        "zh-TW": () => Promise.resolve().then(() => require("./zh-TW-1dtDvCc9.js")),
+        "en-US": () => Promise.resolve().then(() => require("./en-US-_vWm0Hkp.js"))
       };
       const loadLocale = localeMap[props.locale] || localeMap["zh-CN"];
       const [err, res] = await to(
@@ -16497,6 +17203,330 @@ const _sfc_main$7 = /* @__PURE__ */ vue.defineComponent({
   }
 });
 const QdCrudSearch = /* @__PURE__ */ _export_sfc(_sfc_main$7, [["__scopeId", "data-v-13ddedb2"]]);
+async function getBytes(stream, onChunk) {
+  const reader = stream.getReader();
+  let result;
+  while (!(result = await reader.read()).done) {
+    onChunk(result.value);
+  }
+}
+function getLines(onLine) {
+  let buffer;
+  let position;
+  let fieldLength;
+  let discardTrailingNewline = false;
+  return function onChunk(arr) {
+    if (buffer === void 0) {
+      buffer = arr;
+      position = 0;
+      fieldLength = -1;
+    } else {
+      buffer = concat(buffer, arr);
+    }
+    const bufLength = buffer.length;
+    let lineStart = 0;
+    while (position < bufLength) {
+      if (discardTrailingNewline) {
+        if (buffer[position] === 10) {
+          lineStart = ++position;
+        }
+        discardTrailingNewline = false;
+      }
+      let lineEnd = -1;
+      for (; position < bufLength && lineEnd === -1; ++position) {
+        switch (buffer[position]) {
+          case 58:
+            if (fieldLength === -1) {
+              fieldLength = position - lineStart;
+            }
+            break;
+          case 13:
+            discardTrailingNewline = true;
+          case 10:
+            lineEnd = position;
+            break;
+        }
+      }
+      if (lineEnd === -1) {
+        break;
+      }
+      onLine(buffer.subarray(lineStart, lineEnd), fieldLength);
+      lineStart = position;
+      fieldLength = -1;
+    }
+    if (lineStart === bufLength) {
+      buffer = void 0;
+    } else if (lineStart !== 0) {
+      buffer = buffer.subarray(lineStart);
+      position -= lineStart;
+    }
+  };
+}
+function getMessages(onId, onRetry, onMessage) {
+  let message = newMessage();
+  const decoder2 = new TextDecoder();
+  return function onLine(line, fieldLength) {
+    if (line.length === 0) {
+      onMessage === null || onMessage === void 0 ? void 0 : onMessage(message);
+      message = newMessage();
+    } else if (fieldLength > 0) {
+      const field = decoder2.decode(line.subarray(0, fieldLength));
+      const valueOffset = fieldLength + (line[fieldLength + 1] === 32 ? 2 : 1);
+      const value = decoder2.decode(line.subarray(valueOffset));
+      switch (field) {
+        case "data":
+          message.data = message.data ? message.data + "\n" + value : value;
+          break;
+        case "event":
+          message.event = value;
+          break;
+        case "id":
+          onId(message.id = value);
+          break;
+        case "retry":
+          const retry = parseInt(value, 10);
+          if (!isNaN(retry)) {
+            onRetry(message.retry = retry);
+          }
+          break;
+      }
+    }
+  };
+}
+function concat(a, b) {
+  const res = new Uint8Array(a.length + b.length);
+  res.set(a);
+  res.set(b, a.length);
+  return res;
+}
+function newMessage() {
+  return {
+    data: "",
+    event: "",
+    id: "",
+    retry: void 0
+  };
+}
+var __rest = function(s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+    t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+        t[p[i]] = s[p[i]];
+    }
+  return t;
+};
+const EventStreamContentType = "text/event-stream";
+const DefaultRetryInterval = 1e3;
+const LastEventId = "last-event-id";
+function fetchEventSource(input, _a2) {
+  var { signal: inputSignal, headers: inputHeaders, onopen: inputOnOpen, onmessage, onclose, onerror, openWhenHidden, fetch: inputFetch } = _a2, rest = __rest(_a2, ["signal", "headers", "onopen", "onmessage", "onclose", "onerror", "openWhenHidden", "fetch"]);
+  return new Promise((resolve, reject) => {
+    const headers = Object.assign({}, inputHeaders);
+    if (!headers.accept) {
+      headers.accept = EventStreamContentType;
+    }
+    let curRequestController;
+    function onVisibilityChange() {
+      curRequestController.abort();
+      if (!document.hidden) {
+        create();
+      }
+    }
+    if (!openWhenHidden) {
+      document.addEventListener("visibilitychange", onVisibilityChange);
+    }
+    let retryInterval = DefaultRetryInterval;
+    let retryTimer = 0;
+    function dispose() {
+      document.removeEventListener("visibilitychange", onVisibilityChange);
+      window.clearTimeout(retryTimer);
+      curRequestController.abort();
+    }
+    inputSignal === null || inputSignal === void 0 ? void 0 : inputSignal.addEventListener("abort", () => {
+      dispose();
+      resolve();
+    });
+    const fetch = inputFetch !== null && inputFetch !== void 0 ? inputFetch : window.fetch;
+    const onopen = inputOnOpen !== null && inputOnOpen !== void 0 ? inputOnOpen : defaultOnOpen;
+    async function create() {
+      var _a3;
+      curRequestController = new AbortController();
+      try {
+        const response = await fetch(input, Object.assign(Object.assign({}, rest), { headers, signal: curRequestController.signal }));
+        await onopen(response);
+        await getBytes(response.body, getLines(getMessages((id) => {
+          if (id) {
+            headers[LastEventId] = id;
+          } else {
+            delete headers[LastEventId];
+          }
+        }, (retry) => {
+          retryInterval = retry;
+        }, onmessage)));
+        onclose === null || onclose === void 0 ? void 0 : onclose();
+        dispose();
+        resolve();
+      } catch (err) {
+        if (!curRequestController.signal.aborted) {
+          try {
+            const interval = (_a3 = onerror === null || onerror === void 0 ? void 0 : onerror(err)) !== null && _a3 !== void 0 ? _a3 : retryInterval;
+            window.clearTimeout(retryTimer);
+            retryTimer = window.setTimeout(create, interval);
+          } catch (innerErr) {
+            dispose();
+            reject(innerErr);
+          }
+        }
+      }
+    }
+    create();
+  });
+}
+function defaultOnOpen(response) {
+  const contentType = response.headers.get("content-type");
+  if (!(contentType === null || contentType === void 0 ? void 0 : contentType.startsWith(EventStreamContentType))) {
+    throw new Error(`Expected content-type to be ${EventStreamContentType}, Actual: ${contentType}`);
+  }
+}
+const csl = useCsl("useAgentChat");
+function useAgentChat(options) {
+  const globalOpt = window.__QIDIAN_AGENT_CHAT__ || {};
+  const mergeOpt = { ...globalOpt, ...options };
+  const loading = vue.ref(false);
+  const agentId = vue.ref(mergeOpt.agentId);
+  const apiKey = vue.ref(mergeOpt.apiKey);
+  const sessionId = vue.ref("");
+  let abortController;
+  async function send({
+    prompt,
+    files,
+    reSend,
+    extParams,
+    refreshSessionId,
+    onOpen,
+    onMessage,
+    onClose,
+    onError
+  }) {
+    const allData = { content: "", reasoning: "" };
+    if (!prompt && isEmpty(files) && isEmpty(extParams)) return allData;
+    loading.value = true;
+    const agInfo = await getAgentInfo();
+    if (!agInfo) {
+      loading.value = false;
+      return allData;
+    }
+    const sId = await getSessionId({ ...agInfo, refreshSessionId });
+    if (!sId) {
+      loading.value = false;
+      return allData;
+    }
+    const getUrl = mergeOpt.getUrl;
+    if (!getUrl) {
+      loading.value = false;
+      console.error("[useAgentChat.getUrl] 必须配置 getUrl 函数");
+      return allData;
+    }
+    abortController = new AbortController();
+    csl.log.dev("send", { ...agInfo, sessionId: sId });
+    return new Promise((resolve, reject) => {
+      fetchEventSource(getUrl(agInfo.agentId, sId), {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json;charset=UTF-8",
+          Authorization: `Bearer ${agInfo.apiKey}`
+        },
+        signal: abortController?.signal,
+        openWhenHidden: true,
+        body: JSON.stringify({
+          message: prompt || "",
+          re_chat: reSend ?? false,
+          document_list: files,
+          client_id: agInfo.apiKey,
+          client_type: "API_KEY",
+          ...extParams
+        }),
+        onopen: async (res) => {
+          csl.log.dev("onOpen", res);
+          await onOpen?.(res);
+        },
+        onmessage: (res) => {
+          const { data } = res;
+          let reData = { content: "", reasoning: "" };
+          try {
+            reData = parseRelaxedJSON(data);
+            if (reData.content) allData.content += reData.content;
+            if (reData.reasoning) allData.reasoning += reData.reasoning;
+          } catch (err) {
+            console.warn("[useAgentChat.send.onMessage]", err);
+          }
+          csl.log.dev("onMessage", reData);
+          onMessage?.({ data: reData, allData });
+        },
+        onclose: () => {
+          csl.log.dev("onClose", allData);
+          loading.value = false;
+          onClose?.(allData);
+          resolve(allData);
+        },
+        onerror: (err) => {
+          csl.log.dev("onError", err);
+          loading.value = false;
+          onError?.(err);
+          reject(err);
+          throw err;
+        }
+      });
+    });
+  }
+  function stop() {
+    abortController?.abort();
+  }
+  async function getAgentInfo() {
+    if (agentId.value && apiKey.value) {
+      return { agentId: agentId.value, apiKey: apiKey.value };
+    }
+    const getFn = mergeOpt.getAgentInfo;
+    if (!getFn) {
+      console.warn("[useAgentChat.getAgentInfo] 必须配置 agentId、apiKey 或者 getAgentInfo 函数");
+      return;
+    }
+    const [err, res] = await suspectedWrapperPromise(getFn());
+    if (err) return;
+    if (!res?.agentId || !res.apiKey) {
+      console.warn("[useAgentChat.getAgentInfo] 未获取到 agentId、apiKey", res);
+      return;
+    }
+    return res;
+  }
+  async function getSessionId({
+    agentId: agentId2,
+    apiKey: apiKey2,
+    refreshSessionId
+  }) {
+    if (sessionId.value && !refreshSessionId) return sessionId.value;
+    const getFn = mergeOpt.getSessionId;
+    if (!getFn) {
+      console.warn("[useAgentChat.getSessionId] 必须配置 getSessionId 函数");
+      return;
+    }
+    const [err, res] = await suspectedWrapperPromise(getFn(agentId2, apiKey2));
+    if (err) return;
+    sessionId.value = res;
+    return res;
+  }
+  return {
+    loading,
+    agentId,
+    apiKey,
+    sessionId,
+    send,
+    stop
+  };
+}
 const dictCache = /* @__PURE__ */ new Map();
 const dictPromiseCache = /* @__PURE__ */ new Map();
 function useDict(...args) {
@@ -18534,7 +19564,7 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
     onWaitingUploadFilesChange: { type: Function }
   }, qdUploadProps),
   emits: ["update:modelValue", "update:files"],
-  setup(__props, { emit: __emit }) {
+  setup(__props, { expose: __expose, emit: __emit }) {
     const props = __props;
     const emit = __emit;
     const { modelValue, files: fileList } = /* @__PURE__ */ useVModels(props, emit, {
@@ -18861,6 +19891,7 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
     vue.onMounted(() => {
       Object.assign(expose, uploadRef.value, { uploadFiles });
     });
+    __expose(expose);
     return (_ctx, _cache) => {
       return vue.openBlock(), vue.createBlock(vue.unref(tdesignVueNext.Upload), vue.mergeProps({
         ref: "upload",
@@ -18952,7 +19983,7 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
     };
   }
 });
-const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-12f87975"]]);
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-49e8a4e0"]]);
 exports.PROVIDE_FORM_ADD_BEFORE_SUBMIT_QUEUE = PROVIDE_FORM_ADD_BEFORE_SUBMIT_QUEUE;
 exports.PROVIDE_GRID_ITEM_PROPS_KEY = PROVIDE_GRID_ITEM_PROPS_KEY;
 exports.PROVIDE_GRID_WIDTH_KEY = PROVIDE_GRID_WIDTH_KEY;
@@ -18995,9 +20026,10 @@ exports.select = select;
 exports.setValueByPath = setValueByPath;
 exports.table = table;
 exports.tag = tag;
+exports.useAgentChat = useAgentChat;
 exports.useDict = useDict;
 exports.useDictDynamic = useDictDynamic;
 exports.useDisabled = useDisabled;
 exports.useModal = useModal;
 exports.useReadonly = useReadonly;
-//# sourceMappingURL=index-BlJoQteI.js.map
+//# sourceMappingURL=index-LWHwXGdo.js.map