@tdesign-react/chat 1.0.0-beta.4 → 1.0.1

package/es/chatbot/core/store/reactiveState.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"reactiveState.js","sources":["../../../../../../node_modules/.pnpm/immer@10.1.1/node_modules/immer/dist/immer.mjs","../../../../../pro-components/chat/chatbot/core/store/reactiveState.ts"],"sourcesContent":["// src/utils/env.ts\nvar NOTHING = Symbol.for(\"immer-nothing\");\nvar DRAFTABLE = Symbol.for(\"immer-draftable\");\nvar DRAFT_STATE = Symbol.for(\"immer-state\");\n\n// src/utils/errors.ts\nvar errors = process.env.NODE_ENV !== \"production\" ? [\n  // All error codes, starting by 0:\n  function(plugin) {\n    return `The plugin for '${plugin}' has not been loaded into Immer. To enable the plugin, import and call \\`enable${plugin}()\\` when initializing your application.`;\n  },\n  function(thing) {\n    return `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${thing}'`;\n  },\n  \"This object has been frozen and should not be mutated\",\n  function(data) {\n    return \"Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? \" + data;\n  },\n  \"An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.\",\n  \"Immer forbids circular references\",\n  \"The first or second argument to `produce` must be a function\",\n  \"The third argument to `produce` must be a function or undefined\",\n  \"First argument to `createDraft` must be a plain object, an array, or an immerable object\",\n  \"First argument to `finishDraft` must be a draft returned by `createDraft`\",\n  function(thing) {\n    return `'current' expects a draft, got: ${thing}`;\n  },\n  \"Object.defineProperty() cannot be used on an Immer draft\",\n  \"Object.setPrototypeOf() cannot be used on an Immer draft\",\n  \"Immer only supports deleting array indices\",\n  \"Immer only supports setting array indices and the 'length' property\",\n  function(thing) {\n    return `'original' expects a draft, got: ${thing}`;\n  }\n  // Note: if more errors are added, the errorOffset in Patches.ts should be increased\n  // See Patches.ts for additional errors\n] : [];\nfunction die(error, ...args) {\n  if (process.env.NODE_ENV !== \"production\") {\n    const e = errors[error];\n    const msg = typeof e === \"function\" ? e.apply(null, args) : e;\n    throw new Error(`[Immer] ${msg}`);\n  }\n  throw new Error(\n    `[Immer] minified error nr: ${error}. Full error at: https://bit.ly/3cXEKWf`\n  );\n}\n\n// src/utils/common.ts\nvar getPrototypeOf = Object.getPrototypeOf;\nfunction isDraft(value) {\n  return !!value && !!value[DRAFT_STATE];\n}\nfunction isDraftable(value) {\n  if (!value)\n    return false;\n  return isPlainObject(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!value.constructor?.[DRAFTABLE] || isMap(value) || isSet(value);\n}\nvar objectCtorString = Object.prototype.constructor.toString();\nfunction isPlainObject(value) {\n  if (!value || typeof value !== \"object\")\n    return false;\n  const proto = getPrototypeOf(value);\n  if (proto === null) {\n    return true;\n  }\n  const Ctor = Object.hasOwnProperty.call(proto, \"constructor\") && proto.constructor;\n  if (Ctor === Object)\n    return true;\n  return typeof Ctor == \"function\" && Function.toString.call(Ctor) === objectCtorString;\n}\nfunction original(value) {\n  if (!isDraft(value))\n    die(15, value);\n  return value[DRAFT_STATE].base_;\n}\nfunction each(obj, iter) {\n  if (getArchtype(obj) === 0 /* Object */) {\n    Reflect.ownKeys(obj).forEach((key) => {\n      iter(key, obj[key], obj);\n    });\n  } else {\n    obj.forEach((entry, index) => iter(index, entry, obj));\n  }\n}\nfunction getArchtype(thing) {\n  const state = thing[DRAFT_STATE];\n  return state ? state.type_ : Array.isArray(thing) ? 1 /* Array */ : isMap(thing) ? 2 /* Map */ : isSet(thing) ? 3 /* Set */ : 0 /* Object */;\n}\nfunction has(thing, prop) {\n  return getArchtype(thing) === 2 /* Map */ ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop);\n}\nfunction get(thing, prop) {\n  return getArchtype(thing) === 2 /* Map */ ? thing.get(prop) : thing[prop];\n}\nfunction set(thing, propOrOldValue, value) {\n  const t = getArchtype(thing);\n  if (t === 2 /* Map */)\n    thing.set(propOrOldValue, value);\n  else if (t === 3 /* Set */) {\n    thing.add(value);\n  } else\n    thing[propOrOldValue] = value;\n}\nfunction is(x, y) {\n  if (x === y) {\n    return x !== 0 || 1 / x === 1 / y;\n  } else {\n    return x !== x && y !== y;\n  }\n}\nfunction isMap(target) {\n  return target instanceof Map;\n}\nfunction isSet(target) {\n  return target instanceof Set;\n}\nfunction latest(state) {\n  return state.copy_ || state.base_;\n}\nfunction shallowCopy(base, strict) {\n  if (isMap(base)) {\n    return new Map(base);\n  }\n  if (isSet(base)) {\n    return new Set(base);\n  }\n  if (Array.isArray(base))\n    return Array.prototype.slice.call(base);\n  const isPlain = isPlainObject(base);\n  if (strict === true || strict === \"class_only\" && !isPlain) {\n    const descriptors = Object.getOwnPropertyDescriptors(base);\n    delete descriptors[DRAFT_STATE];\n    let keys = Reflect.ownKeys(descriptors);\n    for (let i = 0; i < keys.length; i++) {\n      const key = keys[i];\n      const desc = descriptors[key];\n      if (desc.writable === false) {\n        desc.writable = true;\n        desc.configurable = true;\n      }\n      if (desc.get || desc.set)\n        descriptors[key] = {\n          configurable: true,\n          writable: true,\n          // could live with !!desc.set as well here...\n          enumerable: desc.enumerable,\n          value: base[key]\n        };\n    }\n    return Object.create(getPrototypeOf(base), descriptors);\n  } else {\n    const proto = getPrototypeOf(base);\n    if (proto !== null && isPlain) {\n      return { ...base };\n    }\n    const obj = Object.create(proto);\n    return Object.assign(obj, base);\n  }\n}\nfunction freeze(obj, deep = false) {\n  if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj))\n    return obj;\n  if (getArchtype(obj) > 1) {\n    obj.set = obj.add = obj.clear = obj.delete = dontMutateFrozenCollections;\n  }\n  Object.freeze(obj);\n  if (deep)\n    Object.entries(obj).forEach(([key, value]) => freeze(value, true));\n  return obj;\n}\nfunction dontMutateFrozenCollections() {\n  die(2);\n}\nfunction isFrozen(obj) {\n  return Object.isFrozen(obj);\n}\n\n// src/utils/plugins.ts\nvar plugins = {};\nfunction getPlugin(pluginKey) {\n  const plugin = plugins[pluginKey];\n  if (!plugin) {\n    die(0, pluginKey);\n  }\n  return plugin;\n}\nfunction loadPlugin(pluginKey, implementation) {\n  if (!plugins[pluginKey])\n    plugins[pluginKey] = implementation;\n}\n\n// src/core/scope.ts\nvar currentScope;\nfunction getCurrentScope() {\n  return currentScope;\n}\nfunction createScope(parent_, immer_) {\n  return {\n    drafts_: [],\n    parent_,\n    immer_,\n    // Whenever the modified draft contains a draft from another scope, we\n    // need to prevent auto-freezing so the unowned draft can be finalized.\n    canAutoFreeze_: true,\n    unfinalizedDrafts_: 0\n  };\n}\nfunction usePatchesInScope(scope, patchListener) {\n  if (patchListener) {\n    getPlugin(\"Patches\");\n    scope.patches_ = [];\n    scope.inversePatches_ = [];\n    scope.patchListener_ = patchListener;\n  }\n}\nfunction revokeScope(scope) {\n  leaveScope(scope);\n  scope.drafts_.forEach(revokeDraft);\n  scope.drafts_ = null;\n}\nfunction leaveScope(scope) {\n  if (scope === currentScope) {\n    currentScope = scope.parent_;\n  }\n}\nfunction enterScope(immer2) {\n  return currentScope = createScope(currentScope, immer2);\n}\nfunction revokeDraft(draft) {\n  const state = draft[DRAFT_STATE];\n  if (state.type_ === 0 /* Object */ || state.type_ === 1 /* Array */)\n    state.revoke_();\n  else\n    state.revoked_ = true;\n}\n\n// src/core/finalize.ts\nfunction processResult(result, scope) {\n  scope.unfinalizedDrafts_ = scope.drafts_.length;\n  const baseDraft = scope.drafts_[0];\n  const isReplaced = result !== void 0 && result !== baseDraft;\n  if (isReplaced) {\n    if (baseDraft[DRAFT_STATE].modified_) {\n      revokeScope(scope);\n      die(4);\n    }\n    if (isDraftable(result)) {\n      result = finalize(scope, result);\n      if (!scope.parent_)\n        maybeFreeze(scope, result);\n    }\n    if (scope.patches_) {\n      getPlugin(\"Patches\").generateReplacementPatches_(\n        baseDraft[DRAFT_STATE].base_,\n        result,\n        scope.patches_,\n        scope.inversePatches_\n      );\n    }\n  } else {\n    result = finalize(scope, baseDraft, []);\n  }\n  revokeScope(scope);\n  if (scope.patches_) {\n    scope.patchListener_(scope.patches_, scope.inversePatches_);\n  }\n  return result !== NOTHING ? result : void 0;\n}\nfunction finalize(rootScope, value, path) {\n  if (isFrozen(value))\n    return value;\n  const state = value[DRAFT_STATE];\n  if (!state) {\n    each(\n      value,\n      (key, childValue) => finalizeProperty(rootScope, state, value, key, childValue, path)\n    );\n    return value;\n  }\n  if (state.scope_ !== rootScope)\n    return value;\n  if (!state.modified_) {\n    maybeFreeze(rootScope, state.base_, true);\n    return state.base_;\n  }\n  if (!state.finalized_) {\n    state.finalized_ = true;\n    state.scope_.unfinalizedDrafts_--;\n    const result = state.copy_;\n    let resultEach = result;\n    let isSet2 = false;\n    if (state.type_ === 3 /* Set */) {\n      resultEach = new Set(result);\n      result.clear();\n      isSet2 = true;\n    }\n    each(\n      resultEach,\n      (key, childValue) => finalizeProperty(rootScope, state, result, key, childValue, path, isSet2)\n    );\n    maybeFreeze(rootScope, result, false);\n    if (path && rootScope.patches_) {\n      getPlugin(\"Patches\").generatePatches_(\n        state,\n        path,\n        rootScope.patches_,\n        rootScope.inversePatches_\n      );\n    }\n  }\n  return state.copy_;\n}\nfunction finalizeProperty(rootScope, parentState, targetObject, prop, childValue, rootPath, targetIsSet) {\n  if (process.env.NODE_ENV !== \"production\" && childValue === targetObject)\n    die(5);\n  if (isDraft(childValue)) {\n    const path = rootPath && parentState && parentState.type_ !== 3 /* Set */ && // Set objects are atomic since they have no keys.\n    !has(parentState.assigned_, prop) ? rootPath.concat(prop) : void 0;\n    const res = finalize(rootScope, childValue, path);\n    set(targetObject, prop, res);\n    if (isDraft(res)) {\n      rootScope.canAutoFreeze_ = false;\n    } else\n      return;\n  } else if (targetIsSet) {\n    targetObject.add(childValue);\n  }\n  if (isDraftable(childValue) && !isFrozen(childValue)) {\n    if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) {\n      return;\n    }\n    finalize(rootScope, childValue);\n    if ((!parentState || !parentState.scope_.parent_) && typeof prop !== \"symbol\" && Object.prototype.propertyIsEnumerable.call(targetObject, prop))\n      maybeFreeze(rootScope, childValue);\n  }\n}\nfunction maybeFreeze(scope, value, deep = false) {\n  if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) {\n    freeze(value, deep);\n  }\n}\n\n// src/core/proxy.ts\nfunction createProxyProxy(base, parent) {\n  const isArray = Array.isArray(base);\n  const state = {\n    type_: isArray ? 1 /* Array */ : 0 /* Object */,\n    // Track which produce call this is associated with.\n    scope_: parent ? parent.scope_ : getCurrentScope(),\n    // True for both shallow and deep changes.\n    modified_: false,\n    // Used during finalization.\n    finalized_: false,\n    // Track which properties have been assigned (true) or deleted (false).\n    assigned_: {},\n    // The parent draft state.\n    parent_: parent,\n    // The base state.\n    base_: base,\n    // The base proxy.\n    draft_: null,\n    // set below\n    // The base copy with any updated values.\n    copy_: null,\n    // Called by the `produce` function.\n    revoke_: null,\n    isManual_: false\n  };\n  let target = state;\n  let traps = objectTraps;\n  if (isArray) {\n    target = [state];\n    traps = arrayTraps;\n  }\n  const { revoke, proxy } = Proxy.revocable(target, traps);\n  state.draft_ = proxy;\n  state.revoke_ = revoke;\n  return proxy;\n}\nvar objectTraps = {\n  get(state, prop) {\n    if (prop === DRAFT_STATE)\n      return state;\n    const source = latest(state);\n    if (!has(source, prop)) {\n      return readPropFromProto(state, source, prop);\n    }\n    const value = source[prop];\n    if (state.finalized_ || !isDraftable(value)) {\n      return value;\n    }\n    if (value === peek(state.base_, prop)) {\n      prepareCopy(state);\n      return state.copy_[prop] = createProxy(value, state);\n    }\n    return value;\n  },\n  has(state, prop) {\n    return prop in latest(state);\n  },\n  ownKeys(state) {\n    return Reflect.ownKeys(latest(state));\n  },\n  set(state, prop, value) {\n    const desc = getDescriptorFromProto(latest(state), prop);\n    if (desc?.set) {\n      desc.set.call(state.draft_, value);\n      return true;\n    }\n    if (!state.modified_) {\n      const current2 = peek(latest(state), prop);\n      const currentState = current2?.[DRAFT_STATE];\n      if (currentState && currentState.base_ === value) {\n        state.copy_[prop] = value;\n        state.assigned_[prop] = false;\n        return true;\n      }\n      if (is(value, current2) && (value !== void 0 || has(state.base_, prop)))\n        return true;\n      prepareCopy(state);\n      markChanged(state);\n    }\n    if (state.copy_[prop] === value && // special case: handle new props with value 'undefined'\n    (value !== void 0 || prop in state.copy_) || // special case: NaN\n    Number.isNaN(value) && Number.isNaN(state.copy_[prop]))\n      return true;\n    state.copy_[prop] = value;\n    state.assigned_[prop] = true;\n    return true;\n  },\n  deleteProperty(state, prop) {\n    if (peek(state.base_, prop) !== void 0 || prop in state.base_) {\n      state.assigned_[prop] = false;\n      prepareCopy(state);\n      markChanged(state);\n    } else {\n      delete state.assigned_[prop];\n    }\n    if (state.copy_) {\n      delete state.copy_[prop];\n    }\n    return true;\n  },\n  // Note: We never coerce `desc.value` into an Immer draft, because we can't make\n  // the same guarantee in ES5 mode.\n  getOwnPropertyDescriptor(state, prop) {\n    const owner = latest(state);\n    const desc = Reflect.getOwnPropertyDescriptor(owner, prop);\n    if (!desc)\n      return desc;\n    return {\n      writable: true,\n      configurable: state.type_ !== 1 /* Array */ || prop !== \"length\",\n      enumerable: desc.enumerable,\n      value: owner[prop]\n    };\n  },\n  defineProperty() {\n    die(11);\n  },\n  getPrototypeOf(state) {\n    return getPrototypeOf(state.base_);\n  },\n  setPrototypeOf() {\n    die(12);\n  }\n};\nvar arrayTraps = {};\neach(objectTraps, (key, fn) => {\n  arrayTraps[key] = function() {\n    arguments[0] = arguments[0][0];\n    return fn.apply(this, arguments);\n  };\n});\narrayTraps.deleteProperty = function(state, prop) {\n  if (process.env.NODE_ENV !== \"production\" && isNaN(parseInt(prop)))\n    die(13);\n  return arrayTraps.set.call(this, state, prop, void 0);\n};\narrayTraps.set = function(state, prop, value) {\n  if (process.env.NODE_ENV !== \"production\" && prop !== \"length\" && isNaN(parseInt(prop)))\n    die(14);\n  return objectTraps.set.call(this, state[0], prop, value, state[0]);\n};\nfunction peek(draft, prop) {\n  const state = draft[DRAFT_STATE];\n  const source = state ? latest(state) : draft;\n  return source[prop];\n}\nfunction readPropFromProto(state, source, prop) {\n  const desc = getDescriptorFromProto(source, prop);\n  return desc ? `value` in desc ? desc.value : (\n    // This is a very special case, if the prop is a getter defined by the\n    // prototype, we should invoke it with the draft as context!\n    desc.get?.call(state.draft_)\n  ) : void 0;\n}\nfunction getDescriptorFromProto(source, prop) {\n  if (!(prop in source))\n    return void 0;\n  let proto = getPrototypeOf(source);\n  while (proto) {\n    const desc = Object.getOwnPropertyDescriptor(proto, prop);\n    if (desc)\n      return desc;\n    proto = getPrototypeOf(proto);\n  }\n  return void 0;\n}\nfunction markChanged(state) {\n  if (!state.modified_) {\n    state.modified_ = true;\n    if (state.parent_) {\n      markChanged(state.parent_);\n    }\n  }\n}\nfunction prepareCopy(state) {\n  if (!state.copy_) {\n    state.copy_ = shallowCopy(\n      state.base_,\n      state.scope_.immer_.useStrictShallowCopy_\n    );\n  }\n}\n\n// src/core/immerClass.ts\nvar Immer2 = class {\n  constructor(config) {\n    this.autoFreeze_ = true;\n    this.useStrictShallowCopy_ = false;\n    /**\n     * The `produce` function takes a value and a \"recipe function\" (whose\n     * return value often depends on the base state). The recipe function is\n     * free to mutate its first argument however it wants. All mutations are\n     * only ever applied to a __copy__ of the base state.\n     *\n     * Pass only a function to create a \"curried producer\" which relieves you\n     * from passing the recipe function every time.\n     *\n     * Only plain objects and arrays are made mutable. All other objects are\n     * considered uncopyable.\n     *\n     * Note: This function is __bound__ to its `Immer` instance.\n     *\n     * @param {any} base - the initial state\n     * @param {Function} recipe - function that receives a proxy of the base state as first argument and which can be freely modified\n     * @param {Function} patchListener - optional function that will be called with all the patches produced here\n     * @returns {any} a new state, or the initial state if nothing was modified\n     */\n    this.produce = (base, recipe, patchListener) => {\n      if (typeof base === \"function\" && typeof recipe !== \"function\") {\n        const defaultBase = recipe;\n        recipe = base;\n        const self = this;\n        return function curriedProduce(base2 = defaultBase, ...args) {\n          return self.produce(base2, (draft) => recipe.call(this, draft, ...args));\n        };\n      }\n      if (typeof recipe !== \"function\")\n        die(6);\n      if (patchListener !== void 0 && typeof patchListener !== \"function\")\n        die(7);\n      let result;\n      if (isDraftable(base)) {\n        const scope = enterScope(this);\n        const proxy = createProxy(base, void 0);\n        let hasError = true;\n        try {\n          result = recipe(proxy);\n          hasError = false;\n        } finally {\n          if (hasError)\n            revokeScope(scope);\n          else\n            leaveScope(scope);\n        }\n        usePatchesInScope(scope, patchListener);\n        return processResult(result, scope);\n      } else if (!base || typeof base !== \"object\") {\n        result = recipe(base);\n        if (result === void 0)\n          result = base;\n        if (result === NOTHING)\n          result = void 0;\n        if (this.autoFreeze_)\n          freeze(result, true);\n        if (patchListener) {\n          const p = [];\n          const ip = [];\n          getPlugin(\"Patches\").generateReplacementPatches_(base, result, p, ip);\n          patchListener(p, ip);\n        }\n        return result;\n      } else\n        die(1, base);\n    };\n    this.produceWithPatches = (base, recipe) => {\n      if (typeof base === \"function\") {\n        return (state, ...args) => this.produceWithPatches(state, (draft) => base(draft, ...args));\n      }\n      let patches, inversePatches;\n      const result = this.produce(base, recipe, (p, ip) => {\n        patches = p;\n        inversePatches = ip;\n      });\n      return [result, patches, inversePatches];\n    };\n    if (typeof config?.autoFreeze === \"boolean\")\n      this.setAutoFreeze(config.autoFreeze);\n    if (typeof config?.useStrictShallowCopy === \"boolean\")\n      this.setUseStrictShallowCopy(config.useStrictShallowCopy);\n  }\n  createDraft(base) {\n    if (!isDraftable(base))\n      die(8);\n    if (isDraft(base))\n      base = current(base);\n    const scope = enterScope(this);\n    const proxy = createProxy(base, void 0);\n    proxy[DRAFT_STATE].isManual_ = true;\n    leaveScope(scope);\n    return proxy;\n  }\n  finishDraft(draft, patchListener) {\n    const state = draft && draft[DRAFT_STATE];\n    if (!state || !state.isManual_)\n      die(9);\n    const { scope_: scope } = state;\n    usePatchesInScope(scope, patchListener);\n    return processResult(void 0, scope);\n  }\n  /**\n   * Pass true to automatically freeze all copies created by Immer.\n   *\n   * By default, auto-freezing is enabled.\n   */\n  setAutoFreeze(value) {\n    this.autoFreeze_ = value;\n  }\n  /**\n   * Pass true to enable strict shallow copy.\n   *\n   * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.\n   */\n  setUseStrictShallowCopy(value) {\n    this.useStrictShallowCopy_ = value;\n  }\n  applyPatches(base, patches) {\n    let i;\n    for (i = patches.length - 1; i >= 0; i--) {\n      const patch = patches[i];\n      if (patch.path.length === 0 && patch.op === \"replace\") {\n        base = patch.value;\n        break;\n      }\n    }\n    if (i > -1) {\n      patches = patches.slice(i + 1);\n    }\n    const applyPatchesImpl = getPlugin(\"Patches\").applyPatches_;\n    if (isDraft(base)) {\n      return applyPatchesImpl(base, patches);\n    }\n    return this.produce(\n      base,\n      (draft) => applyPatchesImpl(draft, patches)\n    );\n  }\n};\nfunction createProxy(value, parent) {\n  const draft = isMap(value) ? getPlugin(\"MapSet\").proxyMap_(value, parent) : isSet(value) ? getPlugin(\"MapSet\").proxySet_(value, parent) : createProxyProxy(value, parent);\n  const scope = parent ? parent.scope_ : getCurrentScope();\n  scope.drafts_.push(draft);\n  return draft;\n}\n\n// src/core/current.ts\nfunction current(value) {\n  if (!isDraft(value))\n    die(10, value);\n  return currentImpl(value);\n}\nfunction currentImpl(value) {\n  if (!isDraftable(value) || isFrozen(value))\n    return value;\n  const state = value[DRAFT_STATE];\n  let copy;\n  if (state) {\n    if (!state.modified_)\n      return state.base_;\n    state.finalized_ = true;\n    copy = shallowCopy(value, state.scope_.immer_.useStrictShallowCopy_);\n  } else {\n    copy = shallowCopy(value, true);\n  }\n  each(copy, (key, childValue) => {\n    set(copy, key, currentImpl(childValue));\n  });\n  if (state) {\n    state.finalized_ = false;\n  }\n  return copy;\n}\n\n// src/plugins/patches.ts\nfunction enablePatches() {\n  const errorOffset = 16;\n  if (process.env.NODE_ENV !== \"production\") {\n    errors.push(\n      'Sets cannot have \"replace\" patches.',\n      function(op) {\n        return \"Unsupported patch operation: \" + op;\n      },\n      function(path) {\n        return \"Cannot apply patch, path doesn't resolve: \" + path;\n      },\n      \"Patching reserved attributes like __proto__, prototype and constructor is not allowed\"\n    );\n  }\n  const REPLACE = \"replace\";\n  const ADD = \"add\";\n  const REMOVE = \"remove\";\n  function generatePatches_(state, basePath, patches, inversePatches) {\n    switch (state.type_) {\n      case 0 /* Object */:\n      case 2 /* Map */:\n        return generatePatchesFromAssigned(\n          state,\n          basePath,\n          patches,\n          inversePatches\n        );\n      case 1 /* Array */:\n        return generateArrayPatches(state, basePath, patches, inversePatches);\n      case 3 /* Set */:\n        return generateSetPatches(\n          state,\n          basePath,\n          patches,\n          inversePatches\n        );\n    }\n  }\n  function generateArrayPatches(state, basePath, patches, inversePatches) {\n    let { base_, assigned_ } = state;\n    let copy_ = state.copy_;\n    if (copy_.length < base_.length) {\n      ;\n      [base_, copy_] = [copy_, base_];\n      [patches, inversePatches] = [inversePatches, patches];\n    }\n    for (let i = 0; i < base_.length; i++) {\n      if (assigned_[i] && copy_[i] !== base_[i]) {\n        const path = basePath.concat([i]);\n        patches.push({\n          op: REPLACE,\n          path,\n          // Need to maybe clone it, as it can in fact be the original value\n          // due to the base/copy inversion at the start of this function\n          value: clonePatchValueIfNeeded(copy_[i])\n        });\n        inversePatches.push({\n          op: REPLACE,\n          path,\n          value: clonePatchValueIfNeeded(base_[i])\n        });\n      }\n    }\n    for (let i = base_.length; i < copy_.length; i++) {\n      const path = basePath.concat([i]);\n      patches.push({\n        op: ADD,\n        path,\n        // Need to maybe clone it, as it can in fact be the original value\n        // due to the base/copy inversion at the start of this function\n        value: clonePatchValueIfNeeded(copy_[i])\n      });\n    }\n    for (let i = copy_.length - 1; base_.length <= i; --i) {\n      const path = basePath.concat([i]);\n      inversePatches.push({\n        op: REMOVE,\n        path\n      });\n    }\n  }\n  function generatePatchesFromAssigned(state, basePath, patches, inversePatches) {\n    const { base_, copy_ } = state;\n    each(state.assigned_, (key, assignedValue) => {\n      const origValue = get(base_, key);\n      const value = get(copy_, key);\n      const op = !assignedValue ? REMOVE : has(base_, key) ? REPLACE : ADD;\n      if (origValue === value && op === REPLACE)\n        return;\n      const path = basePath.concat(key);\n      patches.push(op === REMOVE ? { op, path } : { op, path, value });\n      inversePatches.push(\n        op === ADD ? { op: REMOVE, path } : op === REMOVE ? { op: ADD, path, value: clonePatchValueIfNeeded(origValue) } : { op: REPLACE, path, value: clonePatchValueIfNeeded(origValue) }\n      );\n    });\n  }\n  function generateSetPatches(state, basePath, patches, inversePatches) {\n    let { base_, copy_ } = state;\n    let i = 0;\n    base_.forEach((value) => {\n      if (!copy_.has(value)) {\n        const path = basePath.concat([i]);\n        patches.push({\n          op: REMOVE,\n          path,\n          value\n        });\n        inversePatches.unshift({\n          op: ADD,\n          path,\n          value\n        });\n      }\n      i++;\n    });\n    i = 0;\n    copy_.forEach((value) => {\n      if (!base_.has(value)) {\n        const path = basePath.concat([i]);\n        patches.push({\n          op: ADD,\n          path,\n          value\n        });\n        inversePatches.unshift({\n          op: REMOVE,\n          path,\n          value\n        });\n      }\n      i++;\n    });\n  }\n  function generateReplacementPatches_(baseValue, replacement, patches, inversePatches) {\n    patches.push({\n      op: REPLACE,\n      path: [],\n      value: replacement === NOTHING ? void 0 : replacement\n    });\n    inversePatches.push({\n      op: REPLACE,\n      path: [],\n      value: baseValue\n    });\n  }\n  function applyPatches_(draft, patches) {\n    patches.forEach((patch) => {\n      const { path, op } = patch;\n      let base = draft;\n      for (let i = 0; i < path.length - 1; i++) {\n        const parentType = getArchtype(base);\n        let p = path[i];\n        if (typeof p !== \"string\" && typeof p !== \"number\") {\n          p = \"\" + p;\n        }\n        if ((parentType === 0 /* Object */ || parentType === 1 /* Array */) && (p === \"__proto__\" || p === \"constructor\"))\n          die(errorOffset + 3);\n        if (typeof base === \"function\" && p === \"prototype\")\n          die(errorOffset + 3);\n        base = get(base, p);\n        if (typeof base !== \"object\")\n          die(errorOffset + 2, path.join(\"/\"));\n      }\n      const type = getArchtype(base);\n      const value = deepClonePatchValue(patch.value);\n      const key = path[path.length - 1];\n      switch (op) {\n        case REPLACE:\n          switch (type) {\n            case 2 /* Map */:\n              return base.set(key, value);\n            case 3 /* Set */:\n              die(errorOffset);\n            default:\n              return base[key] = value;\n          }\n        case ADD:\n          switch (type) {\n            case 1 /* Array */:\n              return key === \"-\" ? base.push(value) : base.splice(key, 0, value);\n            case 2 /* Map */:\n              return base.set(key, value);\n            case 3 /* Set */:\n              return base.add(value);\n            default:\n              return base[key] = value;\n          }\n        case REMOVE:\n          switch (type) {\n            case 1 /* Array */:\n              return base.splice(key, 1);\n            case 2 /* Map */:\n              return base.delete(key);\n            case 3 /* Set */:\n              return base.delete(patch.value);\n            default:\n              return delete base[key];\n          }\n        default:\n          die(errorOffset + 1, op);\n      }\n    });\n    return draft;\n  }\n  function deepClonePatchValue(obj) {\n    if (!isDraftable(obj))\n      return obj;\n    if (Array.isArray(obj))\n      return obj.map(deepClonePatchValue);\n    if (isMap(obj))\n      return new Map(\n        Array.from(obj.entries()).map(([k, v]) => [k, deepClonePatchValue(v)])\n      );\n    if (isSet(obj))\n      return new Set(Array.from(obj).map(deepClonePatchValue));\n    const cloned = Object.create(getPrototypeOf(obj));\n    for (const key in obj)\n      cloned[key] = deepClonePatchValue(obj[key]);\n    if (has(obj, DRAFTABLE))\n      cloned[DRAFTABLE] = obj[DRAFTABLE];\n    return cloned;\n  }\n  function clonePatchValueIfNeeded(obj) {\n    if (isDraft(obj)) {\n      return deepClonePatchValue(obj);\n    } else\n      return obj;\n  }\n  loadPlugin(\"Patches\", {\n    applyPatches_,\n    generatePatches_,\n    generateReplacementPatches_\n  });\n}\n\n// src/plugins/mapset.ts\nfunction enableMapSet() {\n  class DraftMap extends Map {\n    constructor(target, parent) {\n      super();\n      this[DRAFT_STATE] = {\n        type_: 2 /* Map */,\n        parent_: parent,\n        scope_: parent ? parent.scope_ : getCurrentScope(),\n        modified_: false,\n        finalized_: false,\n        copy_: void 0,\n        assigned_: void 0,\n        base_: target,\n        draft_: this,\n        isManual_: false,\n        revoked_: false\n      };\n    }\n    get size() {\n      return latest(this[DRAFT_STATE]).size;\n    }\n    has(key) {\n      return latest(this[DRAFT_STATE]).has(key);\n    }\n    set(key, value) {\n      const state = this[DRAFT_STATE];\n      assertUnrevoked(state);\n      if (!latest(state).has(key) || latest(state).get(key) !== value) {\n        prepareMapCopy(state);\n        markChanged(state);\n        state.assigned_.set(key, true);\n        state.copy_.set(key, value);\n        state.assigned_.set(key, true);\n      }\n      return this;\n    }\n    delete(key) {\n      if (!this.has(key)) {\n        return false;\n      }\n      const state = this[DRAFT_STATE];\n      assertUnrevoked(state);\n      prepareMapCopy(state);\n      markChanged(state);\n      if (state.base_.has(key)) {\n        state.assigned_.set(key, false);\n      } else {\n        state.assigned_.delete(key);\n      }\n      state.copy_.delete(key);\n      return true;\n    }\n    clear() {\n      const state = this[DRAFT_STATE];\n      assertUnrevoked(state);\n      if (latest(state).size) {\n        prepareMapCopy(state);\n        markChanged(state);\n        state.assigned_ = /* @__PURE__ */ new Map();\n        each(state.base_, (key) => {\n          state.assigned_.set(key, false);\n        });\n        state.copy_.clear();\n      }\n    }\n    forEach(cb, thisArg) {\n      const state = this[DRAFT_STATE];\n      latest(state).forEach((_value, key, _map) => {\n        cb.call(thisArg, this.get(key), key, this);\n      });\n    }\n    get(key) {\n      const state = this[DRAFT_STATE];\n      assertUnrevoked(state);\n      const value = latest(state).get(key);\n      if (state.finalized_ || !isDraftable(value)) {\n        return value;\n      }\n      if (value !== state.base_.get(key)) {\n        return value;\n      }\n      const draft = createProxy(value, state);\n      prepareMapCopy(state);\n      state.copy_.set(key, draft);\n      return draft;\n    }\n    keys() {\n      return latest(this[DRAFT_STATE]).keys();\n    }\n    values() {\n      const iterator = this.keys();\n      return {\n        [Symbol.iterator]: () => this.values(),\n        next: () => {\n          const r = iterator.next();\n          if (r.done)\n            return r;\n          const value = this.get(r.value);\n          return {\n            done: false,\n            value\n          };\n        }\n      };\n    }\n    entries() {\n      const iterator = this.keys();\n      return {\n        [Symbol.iterator]: () => this.entries(),\n        next: () => {\n          const r = iterator.next();\n          if (r.done)\n            return r;\n          const value = this.get(r.value);\n          return {\n            done: false,\n            value: [r.value, value]\n          };\n        }\n      };\n    }\n    [(DRAFT_STATE, Symbol.iterator)]() {\n      return this.entries();\n    }\n  }\n  function proxyMap_(target, parent) {\n    return new DraftMap(target, parent);\n  }\n  function prepareMapCopy(state) {\n    if (!state.copy_) {\n      state.assigned_ = /* @__PURE__ */ new Map();\n      state.copy_ = new Map(state.base_);\n    }\n  }\n  class DraftSet extends Set {\n    constructor(target, parent) {\n      super();\n      this[DRAFT_STATE] = {\n        type_: 3 /* Set */,\n        parent_: parent,\n        scope_: parent ? parent.scope_ : getCurrentScope(),\n        modified_: false,\n        finalized_: false,\n        copy_: void 0,\n        base_: target,\n        draft_: this,\n        drafts_: /* @__PURE__ */ new Map(),\n        revoked_: false,\n        isManual_: false\n      };\n    }\n    get size() {\n      return latest(this[DRAFT_STATE]).size;\n    }\n    has(value) {\n      const state = this[DRAFT_STATE];\n      assertUnrevoked(state);\n      if (!state.copy_) {\n        return state.base_.has(value);\n      }\n      if (state.copy_.has(value))\n        return true;\n      if (state.drafts_.has(value) && state.copy_.has(state.drafts_.get(value)))\n        return true;\n      return false;\n    }\n    add(value) {\n      const state = this[DRAFT_STATE];\n      assertUnrevoked(state);\n      if (!this.has(value)) {\n        prepareSetCopy(state);\n        markChanged(state);\n        state.copy_.add(value);\n      }\n      return this;\n    }\n    delete(value) {\n      if (!this.has(value)) {\n        return false;\n      }\n      const state = this[DRAFT_STATE];\n      assertUnrevoked(state);\n      prepareSetCopy(state);\n      markChanged(state);\n      return state.copy_.delete(value) || (state.drafts_.has(value) ? state.copy_.delete(state.drafts_.get(value)) : (\n        /* istanbul ignore next */\n        false\n      ));\n    }\n    clear() {\n      const state = this[DRAFT_STATE];\n      assertUnrevoked(state);\n      if (latest(state).size) {\n        prepareSetCopy(state);\n        markChanged(state);\n        state.copy_.clear();\n      }\n    }\n    values() {\n      const state = this[DRAFT_STATE];\n      assertUnrevoked(state);\n      prepareSetCopy(state);\n      return state.copy_.values();\n    }\n    entries() {\n      const state = this[DRAFT_STATE];\n      assertUnrevoked(state);\n      prepareSetCopy(state);\n      return state.copy_.entries();\n    }\n    keys() {\n      return this.values();\n    }\n    [(DRAFT_STATE, Symbol.iterator)]() {\n      return this.values();\n    }\n    forEach(cb, thisArg) {\n      const iterator = this.values();\n      let result = iterator.next();\n      while (!result.done) {\n        cb.call(thisArg, result.value, result.value, this);\n        result = iterator.next();\n      }\n    }\n  }\n  function proxySet_(target, parent) {\n    return new DraftSet(target, parent);\n  }\n  function prepareSetCopy(state) {\n    if (!state.copy_) {\n      state.copy_ = /* @__PURE__ */ new Set();\n      state.base_.forEach((value) => {\n        if (isDraftable(value)) {\n          const draft = createProxy(value, state);\n          state.drafts_.set(value, draft);\n          state.copy_.add(draft);\n        } else {\n          state.copy_.add(value);\n        }\n      });\n    }\n  }\n  function assertUnrevoked(state) {\n    if (state.revoked_)\n      die(3, JSON.stringify(latest(state)));\n  }\n  loadPlugin(\"MapSet\", { proxyMap_, proxySet_ });\n}\n\n// src/immer.ts\nvar immer = new Immer2();\nvar produce = immer.produce;\nvar produceWithPatches = immer.produceWithPatches.bind(\n  immer\n);\nvar setAutoFreeze = immer.setAutoFreeze.bind(immer);\nvar setUseStrictShallowCopy = immer.setUseStrictShallowCopy.bind(immer);\nvar applyPatches = immer.applyPatches.bind(immer);\nvar createDraft = immer.createDraft.bind(immer);\nvar finishDraft = immer.finishDraft.bind(immer);\nfunction castDraft(value) {\n  return value;\n}\nfunction castImmutable(value) {\n  return value;\n}\nexport {\n  Immer2 as Immer,\n  applyPatches,\n  castDraft,\n  castImmutable,\n  createDraft,\n  current,\n  enableMapSet,\n  enablePatches,\n  finishDraft,\n  freeze,\n  DRAFTABLE as immerable,\n  isDraft,\n  isDraftable,\n  NOTHING as nothing,\n  original,\n  produce,\n  produceWithPatches,\n  setAutoFreeze,\n  setUseStrictShallowCopy\n};\n//# sourceMappingURL=immer.mjs.map","import { enablePatches, produceWithPatches } from 'immer';\n\n/**\n * 状态订阅者回调函数类型\n * @template T 状态类型\n * @param state 只读的最新状态\n * @param changes 发生变更的路径数组（只读）\n */\nexport type Subscriber<T> = (state: Readonly<T>, changes: readonly string[]) => void;\n\n// 启用immer的patch支持，用于追踪状态变更路径\nenablePatches();\n\n/**\n * 响应式状态管理类，提供高效的状态管理和变更追踪功能\n * @template T 状态对象类型，必须为object类型\n */\nexport default class ReactiveState<T extends object> {\n  private currentState: T; // 当前状态（始终为冻结对象）\n\n  private subscribers = new Set<{ handler: Subscriber<T>; paths?: string[] }>(); // 订阅者集合（包含路径过滤条件）\n\n  private pendingChanges: string[] = []; // 待处理的变更路径（自动去重）\n\n  private notificationScheduled = false; // 通知调度锁（防止重复调度）\n\n  private pathSubscribers = new Map<string, Set<{ handler: Subscriber<T> }>>(); // 增加订阅者分组缓存\n\n  /**\n   * 初始化响应式状态\n   * @param initialState 初始状态（会自动冻结）\n   */\n  public initialize(initialState: T) {\n    this.currentState = Object.freeze(initialState);\n  }\n\n  /**\n   * 更新状态方法\n   * @param updater 状态更新函数（使用immer的draft机制）\n   * @param paths 可选的手动指定变更路径（自动模式会从immer patches中提取）\n   */\n  public setState(updater: (draft: T) => void, paths?: string[]): void {\n    // 使用produceWithPatches来获取变更路径，生成新状态和变更记录\n    const [nextState, patches] = produceWithPatches(this.currentState, updater);\n\n    // 处理变更路径：优先使用手动指定路径，否则从patches中提取\n    const changes =\n      paths || patches.filter((p) => ['replace', 'add', 'remove'].includes(p.op)).map((p) => p.path.join('.'));\n\n    if (changes.length > 0) {\n      this.pendingChanges.push(...changes);\n      this.currentState = Object.freeze(nextState) as T;\n      this.scheduleNotification();\n    }\n  }\n\n  /**\n   * 获取当前状态\n   * @param cloned 是否返回克隆副本（默认false）\n   * @returns 当前状态的只读引用或克隆副本\n   */\n  public getState(cloned = false): Readonly<T> {\n    return cloned ? structuredClone(this.currentState) : this.currentState;\n  }\n\n  /**\n   * 订阅状态变更（支持路径过滤），订阅时维护路径索引\n   * @param subscriber 订阅回调函数\n   * @param paths 可选的要监听的属性路径数组\n   * @returns 取消订阅的函数\n   */\n  public subscribe(subscriber: Subscriber<T>, paths?: string[]): () => void {\n    const subscription = { handler: subscriber, paths };\n    this.subscribers.add(subscription);\n    // 维护路径索引\n    paths?.forEach((path) => {\n      if (!this.pathSubscribers.has(path)) {\n        this.pathSubscribers.set(path, new Set());\n      }\n      this.pathSubscribers.get(path)?.add(subscription);\n    });\n\n    return () => {\n      this.subscribers.delete(subscription);\n      paths?.forEach((path) => {\n        this.pathSubscribers.get(path)?.delete(subscription);\n      });\n    };\n  }\n\n  /**\n   * 调度通知（使用微任务批量处理）\n   */\n  private scheduleNotification() {\n    if (this.notificationScheduled) return;\n    this.notificationScheduled = true;\n\n    // 使用微任务进行批处理，确保在同一个事件循环内的多次更新只会触发一次通知\n    queueMicrotask(() => {\n      // 去重变更路径并重置待处理队列\n      const changedPaths = [...new Set(this.pendingChanges)];\n      this.pendingChanges = [];\n      this.notificationScheduled = false;\n\n      // 冻结状态和路径数组，防止订阅者意外修改\n      const frozenState = Object.freeze(this.currentState);\n      const frozenPaths = Object.freeze(changedPaths);\n\n      // 安全通知所有订阅者\n      this.subscribers.forEach(({ handler, paths }) => {\n        try {\n          // 如果没有设置监听路径，或变更路径中有匹配项，则触发回调\n          if (\n            !paths ||\n            frozenPaths.some((p) =>\n              paths.some((target) => {\n                const targetParts = target.split('.');\n                const pathParts = p.split('.');\n                return targetParts.every((part, i) => pathParts[i] === part);\n              }),\n            )\n          ) {\n            handler(frozenState, frozenPaths);\n          }\n        } catch (error) {\n          console.error('Subscriber error:', error);\n        }\n      });\n    });\n  }\n\n  /**\n   * 调试方法（开发时使用）\n   * @param label 调试标签（默认'State'）\n   * @returns 当前实例（支持链式调用）\n   */\n  public debug(label = 'State'): this {\n    this.subscribe((state, paths) => {\n      console.groupCollapsed(`%c${label} Update`, 'color: #4CAF50; font-weight: bold;');\n      console.log('Changed Paths:', paths);\n      console.log('New State:', state);\n      console.groupEnd();\n    });\n    return this;\n  }\n}\n"],"names":["NOTHING","Symbol","DRAFTABLE","DRAFT_STATE","enablePatches","ReactiveState","_classCallCheck","_defineProperty","Set","Map","_createClass","key","value","initialize","initialState","currentState","Object","freeze","setState","updater","paths","_produceWithPatches","produceWithPatches","_produceWithPatches2","_slicedToArray","nextState","patches","changes","filter","p","includes","op","map","path","join","length","_this$pendingChanges","pendingChanges","push","apply","_toConsumableArray","scheduleNotification","getState","cloned","structuredClone","subscribe","subscriber","_this","subscription","handler","subscribers","add","forEach","_this$pathSubscribers","pathSubscribers","has","set","get","_this$pathSubscribers2","_this2","notificationScheduled","queueMicrotask","changedPaths","frozenState","frozenPaths","_ref","some","target","targetParts","split","pathParts","every","part","i","error","console","debug","label","state","groupCollapsed","concat","log","groupEnd"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAKO,IAAMA,OAAA,GAAyBC,MAAA,CAAA,KAAA,CAAO,CAAI,eAAe,CAAA,CAAA;AAUzD,IAAMC,SAAA,GAA2BD,MAAA,CAAA,KAAA,CAAO,CAAI,iBAAiB,CAAA,CAAA;AAE7D,IAAME,WAAA,GAA6BF,MAAA,CAAA,KAAA,CAAO,CAAI,aAAa,CAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACNlEG,aAAc,EAAA,CAAA;AAAA,IAMOC,aAAgC,gBAAA,YAAA;AAAA,EAAA,SAAAA,aAAA,GAAA;AAAAC,IAAAA,eAAA,OAAAD,aAAA,CAAA,CAAA;AAAAE,IAAAA,eAAA,CAG7B,IAAA,EAAA,aAAA,qBAAIC,GAAkD,EAAA,CAAA,CAAA;AAAAD,IAAAA,eAAA,yBAEzC,EAAC,CAAA,CAAA;AAAAA,IAAAA,eAAA,gCAEJ,KAAA,CAAA,CAAA;AAAAA,IAAAA,eAAA,CAEN,IAAA,EAAA,iBAAA,qBAAIE,GAA6C,EAAA,CAAA,CAAA;AAAA,GAAA;EAAA,OAAAC,YAAA,CAAAL,aAAA,EAAA,CAAA;IAAAM,GAAA,EAAA,YAAA;AAAAC,IAAAA,KAAA,EAMpE,SAAAC,WAAWC,YAAiB,EAAA;MAC5B,IAAA,CAAAC,YAAA,GAAeC,MAAO,CAAAC,MAAA,CAAOH,YAAY,CAAA,CAAA;AAChD,KAAA;AAAA,GAAA,EAAA;IAAAH,GAAA,EAAA,UAAA;AAAAC,IAAAA,KAAA,EAOO,SAAAM,QAAAA,CAASC,SAA6BC,KAAwB,EAAA;MAEnE,IAAAC,mBAAA,GAA6BC,kBAAmB,CAAA,IAAA,CAAKP,cAAcI,OAAO,CAAA;QAAAI,oBAAA,GAAAC,cAAA,CAAAH,mBAAA,EAAA,CAAA,CAAA;AAAnEI,QAAAA,SAAW,GAAAF,oBAAA,CAAA,CAAA,CAAA;AAAAG,QAAAA,OAAO,GAAAH,oBAAA,CAAA,CAAA,CAAA,CAAA;MAGnB,IAAAI,OAAA,GACJP,SAASM,OAAQ,CAAAE,MAAA,CAAO,UAACC,CAAM,EAAA;AAAA,QAAA,OAAA,CAAC,SAAW,EAAA,KAAA,EAAO,QAAQ,CAAA,CAAEC,SAASD,CAAE,CAAAE,EAAE,CAAC,CAAA;AAAA,OAAA,CAAA,CAAEC,GAAI,CAAA,UAACH;eAAMA,CAAE,CAAAI,IAAA,CAAKC,IAAK,CAAA,GAAG,CAAC,CAAA;OAAA,CAAA,CAAA;AAErG,MAAA,IAAAP,OAAA,CAAQQ,SAAS,CAAG,EAAA;AAAA,QAAA,IAAAC,oBAAA,CAAA;AACjB,QAAA,CAAAA,oBAAA,GAAA,IAAA,CAAAC,cAAA,EAAeC,IAAK,CAAAC,KAAA,CAAAH,oBAAA,EAAAI,kBAAA,CAAGb,OAAO,CAAA,CAAA,CAAA;QAC9B,IAAA,CAAAZ,YAAA,GAAeC,MAAO,CAAAC,MAAA,CAAOQ,SAAS,CAAA,CAAA;QAC3C,IAAA,CAAKgB,oBAAqB,EAAA,CAAA;AAC5B,OAAA;AACF,KAAA;AAAA,GAAA,EAAA;IAAA9B,GAAA,EAAA,UAAA;AAAAC,IAAAA,KAAA,EAOO,SAAA8B,QAAAA,GAAsC;AAAA,MAAA,IAA7BC,6EAAS,KAAoB,CAAA;MAC3C,OAAOA,MAAS,GAAAC,eAAA,CAAgB,IAAK,CAAA7B,YAAY,IAAI,IAAK,CAAAA,YAAA,CAAA;AAC5D,KAAA;AAAA,GAAA,EAAA;IAAAJ,GAAA,EAAA,WAAA;AAAAC,IAAAA,KAAA,EAQO,SAAAiC,SAAAA,CAAUC,YAA2B1B,KAA8B,EAAA;AAAA,MAAA,IAAA2B,KAAA,GAAA,IAAA,CAAA;AACxE,MAAA,IAAMC,YAAe,GAAA;AAAEC,QAAAA,OAAS,EAAAH,UAAA;AAAY1B,QAAAA,KAAM,EAANA,KAAAA;OAAM,CAAA;AAC7C,MAAA,IAAA,CAAA8B,WAAA,CAAYC,IAAIH,YAAY,CAAA,CAAA;MAE1B5B,KAAA,KAAA,IAAA,IAAAA,KAAA,KAAAA,KAAAA,CAAAA,IAAAA,KAAA,CAAAgC,OAAA,CAAQ,UAACnB,IAAS,EAAA;AAAA,QAAA,IAAAoB,qBAAA,CAAA;QACvB,IAAI,CAACN,KAAA,CAAKO,eAAgB,CAAAC,GAAA,CAAItB,IAAI,CAAG,EAAA;AACnCc,UAAAA,KAAA,CAAKO,eAAgB,CAAAE,GAAA,CAAIvB,IAAM,iBAAA,IAAIzB,KAAK,CAAA,CAAA;AAC1C,SAAA;AACA,QAAA,CAAA6C,qBAAA,GAAAN,KAAA,CAAKO,eAAgB,CAAAG,GAAA,CAAIxB,IAAI,CAAA,MAAA,IAAA,IAAAoB,qBAAA,KAA7BA,KAAAA,CAAAA,IAAAA,qBAAA,CAAgCF,IAAIH,YAAY,CAAA,CAAA;AAClD,OAAC,CAAA,CAAA;AAED,MAAA,OAAO,YAAM;AACND,QAAAA,KAAA,CAAAG,WAAA,WAAmBF,YAAY,CAAA,CAAA;QAC7B5B,KAAA,KAAA,IAAA,IAAAA,KAAA,KAAAA,KAAAA,CAAAA,IAAAA,KAAA,CAAAgC,OAAA,CAAQ,UAACnB,IAAS,EAAA;AAAA,UAAA,IAAAyB,sBAAA,CAAA;AACvB,UAAA,CAAAA,sBAAA,GAAAX,KAAA,CAAKO,eAAgB,CAAAG,GAAA,CAAIxB,IAAI,CAAA,cAAAyB,sBAAA,KAAA,KAAA,CAAA,IAA7BA,sBAAA,WAAuCV,YAAY,CAAA,CAAA;AACrD,SAAC,CAAA,CAAA;OACH,CAAA;AACF,KAAA;AAAA,GAAA,EAAA;IAAArC,GAAA,EAAA,sBAAA;AAAAC,IAAAA,KAAA,EAKQ,SAAA6B,oBAAuBA,GAAA;AAAA,MAAA,IAAAkB,MAAA,GAAA,IAAA,CAAA;MAC7B,IAAI,IAAK,CAAAC,qBAAA,EAAuB,OAAA;MAChC,IAAA,CAAKA,qBAAwB,GAAA,IAAA,CAAA;AAG7BC,MAAAA,cAAA,CAAe,YAAM;QAEnB,IAAMC,kCAAmB,IAAItD,GAAI,CAAAmD,MAAA,CAAKtB,cAAc,CAAC,CAAA,CAAA;QACrDsB,MAAA,CAAKtB,iBAAiB,EAAC,CAAA;QACvBsB,MAAA,CAAKC,qBAAwB,GAAA,KAAA,CAAA;QAG7B,IAAMG,WAAc,GAAA/C,MAAA,CAAOC,MAAO,CAAA0C,MAAA,CAAK5C,YAAY,CAAA,CAAA;AAC7C,QAAA,IAAAiD,WAAA,GAAchD,MAAO,CAAAC,MAAA,CAAO6C,YAAY,CAAA,CAAA;AAG9CH,QAAAA,MAAA,CAAKT,YAAYE,OAAQ,CAAA,UAAAa,IAAA,EAAwB;AAAA,UAAA,IAArBhB,OAAA,GAAAgB,IAAA,CAAAhB,OAAA;YAAS7B,aAAAA;UAC/B,IAAA;YAGA,IAAA,CAACA,SACD4C,WAAY,CAAAE,IAAA,CAAK,UAACrC,CAAA,EAAA;AAAA,cAAA,OAChBT,KAAM,CAAA8C,IAAA,CAAK,UAACC,MAAW,EAAA;AACf,gBAAA,IAAAC,WAAA,GAAcD,MAAO,CAAAE,KAAA,CAAM,GAAG,CAAA,CAAA;AAC9B,gBAAA,IAAAC,SAAA,GAAYzC,CAAE,CAAAwC,KAAA,CAAM,GAAG,CAAA,CAAA;AAC7B,gBAAA,OAAOD,YAAYG,KAAM,CAAA,UAACC,MAAMC,CAAM,EAAA;AAAA,kBAAA,OAAAH,SAAA,CAAUG,OAAOD,IAAI,CAAA;iBAAA,CAAA,CAAA;AAC7D,eAAC,CAAA,CAAA;AAAA,aACH,CACA,EAAA;AACAvB,cAAAA,OAAA,CAAQc,aAAaC,WAAW,CAAA,CAAA;AAClC,aAAA;mBACOU,KAAP,EAAA;AACQC,YAAAA,OAAA,CAAAD,KAAA,CAAM,qBAAqBA,KAAK,CAAA,CAAA;AAC1C,WAAA;AACF,SAAC,CAAA,CAAA;AACH,OAAC,CAAA,CAAA;AACH,KAAA;AAAA,GAAA,EAAA;IAAA/D,GAAA,EAAA,OAAA;AAAAC,IAAAA,KAAA,EAOO,SAAAgE,KAAAA,GAA6B;AAAA,MAAA,IAAvBC,4EAAQ,OAAe,CAAA;AAC7B,MAAA,IAAA,CAAAhC,SAAA,CAAU,UAACiC,KAAA,EAAO1D,KAAU,EAAA;QACvBuD,OAAA,CAAAI,cAAA,CAAAC,IAAAA,CAAAA,MAAA,CAAoBH,KAAA,EAAA,SAAA,CAAA,EAAgB,oCAAoC,CAAA,CAAA;AACxEF,QAAAA,OAAA,CAAAM,GAAA,CAAI,kBAAkB7D,KAAK,CAAA,CAAA;AAC3BuD,QAAAA,OAAA,CAAAM,GAAA,CAAI,cAAcH,KAAK,CAAA,CAAA;QAC/BH,OAAA,CAAQO,QAAS,EAAA,CAAA;AACnB,OAAC,CAAA,CAAA;AACM,MAAA,OAAA,IAAA,CAAA;AACT,KAAA;AAAA,GAAA,CAAA,CAAA,CAAA;AAAA,CAAA;;;;"}

package/es/chatbot/core/type.d.ts

@@ -1,238 +0,0 @@
-import type { ToolCallEventType } from './adapters/agui/events';
-export type ChatMessageRole = 'user' | 'assistant' | 'system';
-export type ChatMessageStatus = 'pending' | 'streaming' | 'complete' | 'stop' | 'error';
-export type ChatStatus = 'idle' | ChatMessageStatus;
-export type ChatContentType = 'text' | 'markdown' | 'search' | 'attachment' | 'thinking' | 'image' | 'audio' | 'video' | 'suggestion' | 'reasoning' | 'toolcall';
-export type AttachmentType = 'image' | 'video' | 'audio' | 'pdf' | 'doc' | 'ppt' | 'txt';
-export interface ChatBaseContent<T extends string, TData> {
-    type: T;
-    data: TData;
-    status?: ChatMessageStatus;
-    id?: string;
-    strategy?: 'merge' | 'append';
-    ext?: Record<string, any>;
-}
-export type TextContent = ChatBaseContent<'text', string>;
-export type MarkdownContent = ChatBaseContent<'markdown', string>;
-export type ImageContent = ChatBaseContent<'image', {
-    name?: string;
-    url?: string;
-    width?: number;
-    height?: number;
-}>;
-export type ReferenceItem = {
-    title: string;
-    icon?: string;
-    type?: string;
-    url?: string;
-    content?: string;
-    site?: string;
-    date?: string;
-};
-export type SearchContent = ChatBaseContent<'search', {
-    title?: string;
-    references?: ReferenceItem[];
-}>;
-export type SuggestionItem = {
-    title: string;
-    prompt?: string;
-};
-export type SuggestionContent = ChatBaseContent<'suggestion', SuggestionItem[]>;
-export type ReasoningContent = ChatBaseContent<'reasoning', AIMessageContent[]>;
-export type AttachmentItem = {
-    fileType: AttachmentType;
-    size?: number;
-    name?: string;
-    url?: string;
-    isReference?: boolean;
-    width?: number;
-    height?: number;
-    extension?: string;
-    metadata?: Record<string, any>;
-};
-export type AttachmentContent = ChatBaseContent<'attachment', AttachmentItem[]>;
-export type ThinkingContent = ChatBaseContent<'thinking', {
-    text?: string;
-    title?: string;
-}>;
-export type ToolCall = {
-    toolCallId: string;
-    toolCallName: string;
-    eventType?: ToolCallEventType;
-    parentMessageId?: string;
-    args?: string;
-    chunk?: string;
-    result?: string;
-};
-export type ToolCallContent = ChatBaseContent<'toolcall', ToolCall>;
-export interface ChatBaseMessage {
-    id: string;
-    status?: ChatMessageStatus;
-    datetime?: string;
-    ext?: any;
-}
-declare global {
-    interface AIContentTypeOverrides {
-    }
-}
-type AIContentTypeMap = {
-    text: TextContent;
-    markdown: MarkdownContent;
-    thinking: ThinkingContent;
-    image: ImageContent;
-    search: SearchContent;
-    suggestion: SuggestionContent;
-    reasoning: ReasoningContent;
-    toolcall: ToolCallContent;
-} & AIContentTypeOverrides;
-export type AIContentType = keyof AIContentTypeMap;
-export type AIMessageContent = AIContentTypeMap[AIContentType];
-export type UserMessageContent = TextContent | AttachmentContent;
-export interface UserMessage extends ChatBaseMessage {
-    role: 'user';
-    content: UserMessageContent[];
-}
-export type ChatComment = 'good' | 'bad' | '';
-export interface AIMessage extends ChatBaseMessage {
-    role: 'assistant';
-    content?: AIMessageContent[];
-    history?: AIMessageContent[][];
-    /** 点赞点踩 */
-    comment?: ChatComment;
-}
-export interface SystemMessage extends ChatBaseMessage {
-    role: 'system';
-    content: TextContent[];
-}
-export type ChatMessagesData = UserMessage | AIMessage | SystemMessage;
-export type SSEChunkData = {
-    event?: string;
-    data: any;
-};
-export interface ChatRequestParams {
-    prompt?: string;
-    messageID?: string;
-    attachments?: AttachmentContent['data'];
-    [key: string]: any;
-}
-export type AIContentChunkUpdate = AIMessageContent;
-export interface ChatNetworkConfig {
-    /** 请求端点 */
-    endpoint?: string;
-    /** 是否启用流式传输 */
-    stream?: boolean;
-    /** 重试间隔（毫秒） */
-    retryInterval?: number;
-    /** 最大重试次数 */
-    maxRetries?: number;
-    /** 请求超时时间（毫秒） */
-    timeout?: number;
-    /** 协议类型 */
-    protocol?: 'default' | 'agui';
-}
-export interface DefaultEngineCallbacks {
-    /** 请求发送前配置 */
-    onRequest?: (params: ChatRequestParams) => (ChatRequestParams & RequestInit) | Promise<ChatRequestParams & RequestInit>;
-    onStart?: (chunk: string) => void;
-    /** 接收到消息数据块 - 用于解析和处理聊天内容 */
-    onMessage?: (chunk: SSEChunkData, message?: ChatMessagesData, parsedResult?: AIMessageContent | AIMessageContent[] | null) => AIMessageContent | AIMessageContent[] | null;
-    onComplete?: (isAborted: boolean, params?: ChatRequestParams, result?: any) => AIMessageContent | AIMessageContent[] | void;
-    onAbort?: () => Promise<void>;
-    /** 错误处理 */
-    onError?: (err: Error | Response) => void;
-}
-export interface ChatServiceConfig extends ChatNetworkConfig, DefaultEngineCallbacks {
-}
-export type ChatServiceConfigSetter = ChatServiceConfig | ((params?: any) => ChatServiceConfig);
-export interface IChatEngine {
-    /**
-     * 初始化聊天引擎
-     * @param config 聊天服务配置或配置生成函数，包含网络请求配置和回调函数
-     * @param messages 初始消息列表，用于恢复历史对话
-     * @description 必须在使用其他方法前调用此方法进行初始化
-     */
-    init(config?: any, messages?: ChatMessagesData[]): void;
-    /**
-     * 发送用户消息并获取AI回复
-     * @param params 请求参数，包含用户输入的文本和附件
-     * @description 创建用户消息和AI消息，并发送请求获取AI回复
-     */
-    sendUserMessage(params: ChatRequestParams): Promise<void>;
-    /**
-     * 重新生成AI回复
-     * @param keepVersion 是否保留历史版本，默认为false
-     * @description
-     * - 当keepVersion=false时：删除最后一条AI消息，创建新消息并重新请求
-     * - 当keepVersion=true时：保留旧消息，创建分支消息并重新请求
-     */
-    regenerateAIMessage(keepVersion?: boolean): Promise<void>;
-    /**
-     * 中止当前进行中的聊天请求
-     * @description 停止接收流式响应，关闭连接，并调用配置的onAbort回调
-     */
-    abortChat(): Promise<void>;
-    /**
-     * 设置消息列表
-     * @param messages 要设置的消息数组
-     * @param mode 设置模式：'replace'(替换)、'prepend'(前置)、'append'(追加)，默认为'replace'
-     * @description 用于批量更新消息，如加载历史消息或重置对话
-     */
-    setMessages(messages: ChatMessagesData[], mode?: ChatMessageSetterMode): void;
-    /**
-     * 清空所有消息
-     * @description 清除消息存储中的所有历史记录
-     */
-    clearMessages(): void;
-    /**
-     * 注册内容块合并策略
-     * @param type 内容类型，如'text'、'markdown'等
-     * @param handler 合并处理函数，接收新块和现有块，返回合并后的内容块
-     * @description 用于自定义不同类型内容的增量更新逻辑
-     */
-    registerMergeStrategy<T extends AIMessageContent>(type: T['type'], handler: (chunk: T, existing?: T) => T): void;
-    /**
-     * 获取当前所有消息
-     * @returns 消息数组
-     */
-    get messages(): ChatMessagesData[];
-    /**
-     * 获取当前聊天状态
-     * @returns 聊天状态：'idle'、'pending'、'streaming'、'complete'、'stop'或'error'
-     */
-    get status(): ChatStatus;
-    /**
-     * 获取消息存储实例
-     * @returns 消息存储对象
-     */
-    get messageStore(): any;
-    /**
-     * 销毁聊天引擎实例
-     * @description 中止请求，清理消息存储和适配器，释放资源
-     */
-    destroy(): void;
-}
-export interface ChatMessageStore {
-    messageIds: string[];
-    messages: ChatMessagesData[];
-}
-export interface ModelParams {
-    model?: string;
-    useThink?: boolean;
-    useSearch?: boolean;
-}
-export interface ModelServiceState extends ModelParams {
-    config: ChatServiceConfig;
-}
-export interface ChatState {
-    message: ChatMessageStore;
-    model: ModelServiceState;
-}
-export type ChatMessageSetterMode = 'replace' | 'prepend' | 'append';
-export type AIContentHandler<T extends ChatBaseContent<any, any>> = (chunk: T, existing?: T) => T;
-export interface ContentTypeDefinition<T extends string = string, D = any> {
-    type: T;
-    handler?: AIContentHandler<ChatBaseContent<T, D>>;
-    renderer?: ContentRenderer<ChatBaseContent<T, D>>;
-}
-export type ContentRenderer<T extends ChatBaseContent<any, any>> = (content: T) => unknown;
-export {};

package/es/chatbot/core/type.js

@@ -1,7 +0,0 @@
-/**
- * tdesign v1.0.0-beta.3
- * (c) 2025 tdesign
- * @license MIT
- */
-
-//# sourceMappingURL=type.js.map

package/es/chatbot/core/type.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"type.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;"}

package/es/chatbot/core/utils/eventEmitter.d.ts

@@ -1,10 +0,0 @@
-/**
- * 简单的 EventEmitter 实现，用于浏览器环境
- */
-export default class SimpleEventEmitter {
-    private events;
-    on(event: string, listener: (...args: any[]) => void): void;
-    off(event: string, listener: (...args: any[]) => void): void;
-    emit(event: string, ...args: any[]): boolean;
-    removeAllListeners(event?: string): void;
-}

package/es/chatbot/core/utils/eventEmitter.js

@@ -1,67 +0,0 @@
-/**
- * tdesign v1.0.0-beta.3
- * (c) 2025 tdesign
- * @license MIT
- */
-
-import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
-import _createClass from '@babel/runtime/helpers/createClass';
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-
-var SimpleEventEmitter = /*#__PURE__*/function () {
-  function SimpleEventEmitter() {
-    _classCallCheck(this, SimpleEventEmitter);
-    _defineProperty(this, "events", /* @__PURE__ */new Map());
-  }
-  return _createClass(SimpleEventEmitter, [{
-    key: "on",
-    value: function on(event, listener) {
-      if (!this.events.has(event)) {
-        this.events.set(event, []);
-      }
-      this.events.get(event).push(listener);
-    }
-  }, {
-    key: "off",
-    value: function off(event, listener) {
-      var listeners = this.events.get(event);
-      if (listeners) {
-        var index = listeners.indexOf(listener);
-        if (index !== -1) {
-          listeners.splice(index, 1);
-        }
-      }
-    }
-  }, {
-    key: "emit",
-    value: function emit(event) {
-      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-        args[_key - 1] = arguments[_key];
-      }
-      var listeners = this.events.get(event);
-      if (listeners && listeners.length > 0) {
-        listeners.forEach(function (listener) {
-          try {
-            listener.apply(void 0, args);
-          } catch (error) {
-            console.error("EventEmitter listener error:", error);
-          }
-        });
-        return true;
-      }
-      return false;
-    }
-  }, {
-    key: "removeAllListeners",
-    value: function removeAllListeners(event) {
-      if (event) {
-        this.events["delete"](event);
-      } else {
-        this.events.clear();
-      }
-    }
-  }]);
-}();
-
-export { SimpleEventEmitter as default };
-//# sourceMappingURL=eventEmitter.js.map

package/es/chatbot/core/utils/eventEmitter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"eventEmitter.js","sources":["../../../../../pro-components/chat/chatbot/core/utils/eventEmitter.ts"],"sourcesContent":["/**\n * 简单的 EventEmitter 实现，用于浏览器环境\n */\nexport default class SimpleEventEmitter {\n  private events: Map<string, Array<(...args: any[]) => void>> = new Map();\n\n  on(event: string, listener: (...args: any[]) => void): void {\n    if (!this.events.has(event)) {\n      this.events.set(event, []);\n    }\n    this.events.get(event)!.push(listener);\n  }\n\n  off(event: string, listener: (...args: any[]) => void): void {\n    const listeners = this.events.get(event);\n    if (listeners) {\n      const index = listeners.indexOf(listener);\n      if (index !== -1) {\n        listeners.splice(index, 1);\n      }\n    }\n  }\n\n  emit(event: string, ...args: any[]): boolean {\n    const listeners = this.events.get(event);\n    if (listeners && listeners.length > 0) {\n      listeners.forEach((listener) => {\n        try {\n          listener(...args);\n        } catch (error) {\n          console.error('EventEmitter listener error:', error);\n        }\n      });\n      return true;\n    }\n    return false;\n  }\n\n  removeAllListeners(event?: string): void {\n    if (event) {\n      this.events.delete(event);\n    } else {\n      this.events.clear();\n    }\n  }\n}\n"],"names":["SimpleEventEmitter","_classCallCheck","_defineProperty","Map","_createClass","key","value","on","event","listener","events","has","set","get","push","off","listeners","index","indexOf","splice","emit","_len","arguments","length","args","Array","_key","forEach","apply","error","console","removeAllListeners","clear"],"mappings":";;;;;;;;;;IAGqBA,kBAAmB,gBAAA,YAAA;AAAA,EAAA,SAAAA,kBAAA,GAAA;AAAAC,IAAAA,eAAA,OAAAD,kBAAA,CAAA,CAAA;AAAAE,IAAAA,eAAA,CACyB,IAAA,EAAA,QAAA,qBAAIC,GAAI,EAAA,CAAA,CAAA;AAAA,GAAA;EAAA,OAAAC,YAAA,CAAAJ,kBAAA,EAAA,CAAA;IAAAK,GAAA,EAAA,IAAA;AAAAC,IAAAA,KAAA,EAEvE,SAAAC,EAAAA,CAAGC,OAAeC,QAA0C,EAAA;MAC1D,IAAI,CAAC,IAAA,CAAKC,MAAO,CAAAC,GAAA,CAAIH,KAAK,CAAG,EAAA;QAC3B,IAAA,CAAKE,MAAO,CAAAE,GAAA,CAAIJ,KAAO,EAAA,EAAE,CAAA,CAAA;AAC3B,OAAA;MACA,IAAA,CAAKE,MAAO,CAAAG,GAAA,CAAIL,KAAK,CAAA,CAAGM,KAAKL,QAAQ,CAAA,CAAA;AACvC,KAAA;AAAA,GAAA,EAAA;IAAAJ,GAAA,EAAA,KAAA;AAAAC,IAAAA,KAAA,EAEA,SAAAS,GAAAA,CAAIP,OAAeC,QAA0C,EAAA;MAC3D,IAAMO,SAAY,GAAA,IAAA,CAAKN,MAAO,CAAAG,GAAA,CAAIL,KAAK,CAAA,CAAA;AACvC,MAAA,IAAIQ,SAAW,EAAA;AACP,QAAA,IAAAC,KAAA,GAAQD,SAAU,CAAAE,OAAA,CAAQT,QAAQ,CAAA,CAAA;AACxC,QAAA,IAAIQ,UAAU,CAAI,CAAA,EAAA;AACND,UAAAA,SAAA,CAAAG,MAAA,CAAOF,OAAO,CAAC,CAAA,CAAA;AAC3B,SAAA;AACF,OAAA;AACF,KAAA;AAAA,GAAA,EAAA;IAAAZ,GAAA,EAAA,MAAA;AAAAC,IAAAA,KAAA,EAEA,SAAAc,IAAAA,CAAKZ,OAAwC;MAAA,KAAAa,IAAAA,IAAA,GAAAC,SAAA,CAAAC,MAAA,EAAtBC,IAAsB,OAAAC,KAAA,CAAAJ,IAAA,GAAAA,CAAAA,GAAAA,IAAA,WAAAK,IAAA,GAAA,CAAA,EAAAA,IAAA,GAAAL,IAAA,EAAAK,IAAA,EAAA,EAAA;AAAtBF,QAAAA,IAAsB,CAAAE,IAAA,GAAAJ,CAAAA,CAAAA,GAAAA,SAAA,CAAAI,IAAA,CAAA,CAAA;AAAA,OAAA;MAC3C,IAAMV,SAAY,GAAA,IAAA,CAAKN,MAAO,CAAAG,GAAA,CAAIL,KAAK,CAAA,CAAA;AACnC,MAAA,IAAAQ,SAAA,IAAaA,SAAU,CAAAO,MAAA,GAAS,CAAG,EAAA;AAC3BP,QAAAA,SAAA,CAAAW,OAAA,CAAQ,UAAClB,QAAa,EAAA;UAC1B,IAAA;AACFA,YAAAA,QAAA,CAAAmB,KAAA,CAAYJ,KAAAA,CAAAA,EAAAA,IAAI,CAAA,CAAA;mBACTK,KAAP,EAAA;AACQC,YAAAA,OAAA,CAAAD,KAAA,CAAM,gCAAgCA,KAAK,CAAA,CAAA;AACrD,WAAA;AACF,SAAC,CAAA,CAAA;AACM,QAAA,OAAA,IAAA,CAAA;AACT,OAAA;AACO,MAAA,OAAA,KAAA,CAAA;AACT,KAAA;AAAA,GAAA,EAAA;IAAAxB,GAAA,EAAA,oBAAA;AAAAC,IAAAA,KAAA,EAEA,SAAAyB,mBAAmBvB,KAAsB,EAAA;AACvC,MAAA,IAAIA,KAAO,EAAA;AACJ,QAAA,IAAA,CAAAE,MAAA,WAAcF,KAAK,CAAA,CAAA;AAC1B,OAAO,MAAA;AACL,QAAA,IAAA,CAAKE,OAAOsB,KAAM,EAAA,CAAA;AACpB,OAAA;AACF,KAAA;AAAA,GAAA,CAAA,CAAA,CAAA;AAAA,CAAA;;;;"}

package/es/chatbot/core/utils/index.d.ts

@@ -1,31 +0,0 @@
-import type { AIMessageContent, AttachmentContent, ChatMessagesData, ImageContent, MarkdownContent, SearchContent, SuggestionContent, TextContent, ThinkingContent, UserMessageContent, ToolCallContent } from '../type';
-/**
- * 应用JSON Patch操作到状态对象
- * 实现RFC6902规范的JSON Patch操作
- * @param state 原始状态对象
- * @param delta 包含patch操作的数组
- * @returns 更新后的新状态对象
- */
-export declare function applyJsonPatch(state: any, delta: any[]): any;
-/**
- * 安全解析JSON字符串的工具函数
- *
- * @param value 待解析的值，可能是字符串或已解析的对象
- * @param fallbackValue 解析失败时的回退值，默认为原值
- * @param errorContext 错误上下文，用于日志输出
- * @returns 解析后的值或回退值
- */
-export declare function safeParseJSON<T = any>(value: any, fallbackValue?: T, errorContext?: string): T;
-export declare function findTargetElement(event: MouseEvent, selector: string | string[]): HTMLElement | null;
-export declare function isUserMessage(message: ChatMessagesData): message is import("../type").UserMessage;
-export declare function isAIMessage(message: ChatMessagesData): message is import("../type").AIMessage;
-export declare function isThinkingContent(content: AIMessageContent): content is ThinkingContent;
-export declare function isTextContent(content: AIMessageContent): content is TextContent;
-export declare function isMarkdownContent(content: AIMessageContent): content is MarkdownContent;
-export declare function isImageContent(content: AIMessageContent): content is ImageContent;
-export declare function isSearchContent(content: AIMessageContent): content is SearchContent;
-export declare function isSuggestionContent(content: AIMessageContent): content is SuggestionContent;
-export declare function isAttachmentContent(content: UserMessageContent): content is AttachmentContent;
-export declare function isToolCallContent(content: AIMessageContent): content is ToolCallContent;
-/** 提取消息复制内容 */
-export declare function getMessageContentForCopy(message: ChatMessagesData): string;