jowork 0.1.0

package/dist/chunk-3NMLDZBL.js

@@ -0,0 +1,4031 @@
+// ../../packages/core/src/types/engine.ts
+var ENGINE_CLAUDE_CODE = "claude-code";
+var ENGINE_OPENCLAW = "openclaw";
+var ENGINE_NEMOCLAW = "nemoclaw";
+var ENGINE_CLOUD = "jowork-cloud";
+
+// ../../packages/core/src/db/schema.ts
+import { sqliteTable, text, integer, primaryKey } from "drizzle-orm/sqlite-core";
+var sessions = sqliteTable("sessions", {
+  id: text("id").primaryKey(),
+  title: text("title").notNull(),
+  engineId: text("engine_id").notNull(),
+  mode: text("mode").notNull().default("personal"),
+  messageCount: integer("message_count").default(0),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull()
+});
+var messages = sqliteTable("messages", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull().references(() => sessions.id),
+  role: text("role").notNull(),
+  content: text("content").notNull(),
+  toolName: text("tool_name"),
+  tokens: integer("tokens"),
+  cost: integer("cost"),
+  createdAt: integer("created_at").notNull()
+});
+var engineSessionMappings = sqliteTable("engine_session_mappings", {
+  sessionId: text("session_id").notNull().references(() => sessions.id),
+  engineId: text("engine_id").notNull(),
+  engineSessionId: text("engine_session_id").notNull(),
+  createdAt: integer("created_at").notNull()
+}, (t2) => [primaryKey({ columns: [t2.sessionId, t2.engineId] })]);
+var settings = sqliteTable("settings", {
+  key: text("key").primaryKey(),
+  value: text("value").notNull(),
+  updatedAt: integer("updated_at").notNull()
+});
+var connectorConfigs = sqliteTable("connector_configs", {
+  id: text("id").primaryKey(),
+  type: text("type").notNull(),
+  name: text("name").notNull(),
+  status: text("status").notNull().default("disconnected"),
+  config: text("config").notNull().default("{}"),
+  lastSyncAt: integer("last_sync_at"),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull()
+});
+var objects = sqliteTable("objects", {
+  id: text("id").primaryKey(),
+  source: text("source").notNull(),
+  sourceType: text("source_type").notNull(),
+  uri: text("uri").notNull().unique(),
+  title: text("title"),
+  summary: text("summary"),
+  tags: text("tags"),
+  docMap: text("doc_map"),
+  contentHash: text("content_hash"),
+  lastSyncedAt: integer("last_synced_at"),
+  createdAt: integer("created_at")
+});
+var objectBodies = sqliteTable("object_bodies", {
+  objectId: text("object_id").primaryKey().references(() => objects.id),
+  content: text("content").notNull(),
+  contentType: text("content_type"),
+  fetchedAt: integer("fetched_at")
+});
+var syncCursors = sqliteTable("sync_cursors", {
+  connectorId: text("connector_id").primaryKey(),
+  cursor: text("cursor"),
+  lastSyncedAt: integer("last_synced_at")
+});
+var objectChunks = sqliteTable("object_chunks", {
+  id: text("id").primaryKey(),
+  objectId: text("object_id").notNull().references(() => objects.id),
+  idx: integer("idx").notNull(),
+  heading: text("heading"),
+  content: text("content").notNull(),
+  tokens: integer("tokens")
+});
+var memories = sqliteTable("memories", {
+  id: text("id").primaryKey(),
+  title: text("title").notNull(),
+  content: text("content").notNull(),
+  tags: text("tags"),
+  scope: text("scope").notNull(),
+  pinned: integer("pinned").default(0),
+  source: text("source"),
+  accessCount: integer("access_count").notNull().default(0),
+  lastUsedAt: integer("last_used_at"),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull()
+});
+var contextDocs = sqliteTable("context_docs", {
+  id: text("id").primaryKey(),
+  title: text("title").notNull(),
+  content: text("content").notNull(),
+  scope: text("scope").notNull(),
+  category: text("category"),
+  priority: integer("priority").default(0),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull()
+});
+var scheduledTasks = sqliteTable("scheduled_tasks", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  cronExpression: text("cron_expression").notNull(),
+  timezone: text("timezone").default("Asia/Shanghai"),
+  type: text("type").notNull(),
+  // 'scan' | 'skill' | 'notify'
+  config: text("config"),
+  // JSON
+  enabled: integer("enabled").default(1),
+  lastRunAt: integer("last_run_at"),
+  nextRunAt: integer("next_run_at"),
+  cloudSync: integer("cloud_sync").default(0),
+  createdAt: integer("created_at").notNull()
+});
+var taskExecutions = sqliteTable("task_executions", {
+  id: text("id").primaryKey(),
+  taskId: text("task_id").notNull().references(() => scheduledTasks.id),
+  status: text("status").notNull(),
+  // 'success' | 'failure' | 'skipped'
+  result: text("result"),
+  error: text("error"),
+  durationMs: integer("duration_ms"),
+  executedAt: integer("executed_at").notNull()
+});
+
+// ../../packages/core/src/db/migrate.ts
+async function runMigrations(_dbPath) {
+}
+
+// ../../node_modules/.pnpm/i18next@25.8.18_typescript@5.9.3/node_modules/i18next/dist/esm/i18next.js
+var isString = (obj) => typeof obj === "string";
+var defer = () => {
+  let res;
+  let rej;
+  const promise = new Promise((resolve, reject) => {
+    res = resolve;
+    rej = reject;
+  });
+  promise.resolve = res;
+  promise.reject = rej;
+  return promise;
+};
+var makeString = (object) => {
+  if (object == null) return "";
+  return "" + object;
+};
+var copy = (a, s, t2) => {
+  a.forEach((m) => {
+    if (s[m]) t2[m] = s[m];
+  });
+};
+var lastOfPathSeparatorRegExp = /###/g;
+var cleanKey = (key) => key && key.indexOf("###") > -1 ? key.replace(lastOfPathSeparatorRegExp, ".") : key;
+var canNotTraverseDeeper = (object) => !object || isString(object);
+var getLastOfPath = (object, path, Empty) => {
+  const stack = !isString(path) ? path : path.split(".");
+  let stackIndex = 0;
+  while (stackIndex < stack.length - 1) {
+    if (canNotTraverseDeeper(object)) return {};
+    const key = cleanKey(stack[stackIndex]);
+    if (!object[key] && Empty) object[key] = new Empty();
+    if (Object.prototype.hasOwnProperty.call(object, key)) {
+      object = object[key];
+    } else {
+      object = {};
+    }
+    ++stackIndex;
+  }
+  if (canNotTraverseDeeper(object)) return {};
+  return {
+    obj: object,
+    k: cleanKey(stack[stackIndex])
+  };
+};
+var setPath = (object, path, newValue) => {
+  const {
+    obj,
+    k
+  } = getLastOfPath(object, path, Object);
+  if (obj !== void 0 || path.length === 1) {
+    obj[k] = newValue;
+    return;
+  }
+  let e = path[path.length - 1];
+  let p = path.slice(0, path.length - 1);
+  let last = getLastOfPath(object, p, Object);
+  while (last.obj === void 0 && p.length) {
+    e = `${p[p.length - 1]}.${e}`;
+    p = p.slice(0, p.length - 1);
+    last = getLastOfPath(object, p, Object);
+    if (last?.obj && typeof last.obj[`${last.k}.${e}`] !== "undefined") {
+      last.obj = void 0;
+    }
+  }
+  last.obj[`${last.k}.${e}`] = newValue;
+};
+var pushPath = (object, path, newValue, concat) => {
+  const {
+    obj,
+    k
+  } = getLastOfPath(object, path, Object);
+  obj[k] = obj[k] || [];
+  obj[k].push(newValue);
+};
+var getPath = (object, path) => {
+  const {
+    obj,
+    k
+  } = getLastOfPath(object, path);
+  if (!obj) return void 0;
+  if (!Object.prototype.hasOwnProperty.call(obj, k)) return void 0;
+  return obj[k];
+};
+var getPathWithDefaults = (data, defaultData, key) => {
+  const value = getPath(data, key);
+  if (value !== void 0) {
+    return value;
+  }
+  return getPath(defaultData, key);
+};
+var deepExtend = (target, source, overwrite) => {
+  for (const prop in source) {
+    if (prop !== "__proto__" && prop !== "constructor") {
+      if (prop in target) {
+        if (isString(target[prop]) || target[prop] instanceof String || isString(source[prop]) || source[prop] instanceof String) {
+          if (overwrite) target[prop] = source[prop];
+        } else {
+          deepExtend(target[prop], source[prop], overwrite);
+        }
+      } else {
+        target[prop] = source[prop];
+      }
+    }
+  }
+  return target;
+};
+var regexEscape = (str) => str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
+var _entityMap = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;",
+  "/": "&#x2F;"
+};
+var escape = (data) => {
+  if (isString(data)) {
+    return data.replace(/[&<>"'\/]/g, (s) => _entityMap[s]);
+  }
+  return data;
+};
+var RegExpCache = class {
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.regExpMap = /* @__PURE__ */ new Map();
+    this.regExpQueue = [];
+  }
+  getRegExp(pattern) {
+    const regExpFromCache = this.regExpMap.get(pattern);
+    if (regExpFromCache !== void 0) {
+      return regExpFromCache;
+    }
+    const regExpNew = new RegExp(pattern);
+    if (this.regExpQueue.length === this.capacity) {
+      this.regExpMap.delete(this.regExpQueue.shift());
+    }
+    this.regExpMap.set(pattern, regExpNew);
+    this.regExpQueue.push(pattern);
+    return regExpNew;
+  }
+};
+var chars = [" ", ",", "?", "!", ";"];
+var looksLikeObjectPathRegExpCache = new RegExpCache(20);
+var looksLikeObjectPath = (key, nsSeparator, keySeparator) => {
+  nsSeparator = nsSeparator || "";
+  keySeparator = keySeparator || "";
+  const possibleChars = chars.filter((c) => nsSeparator.indexOf(c) < 0 && keySeparator.indexOf(c) < 0);
+  if (possibleChars.length === 0) return true;
+  const r = looksLikeObjectPathRegExpCache.getRegExp(`(${possibleChars.map((c) => c === "?" ? "\\?" : c).join("|")})`);
+  let matched = !r.test(key);
+  if (!matched) {
+    const ki = key.indexOf(keySeparator);
+    if (ki > 0 && !r.test(key.substring(0, ki))) {
+      matched = true;
+    }
+  }
+  return matched;
+};
+var deepFind = (obj, path, keySeparator = ".") => {
+  if (!obj) return void 0;
+  if (obj[path]) {
+    if (!Object.prototype.hasOwnProperty.call(obj, path)) return void 0;
+    return obj[path];
+  }
+  const tokens = path.split(keySeparator);
+  let current = obj;
+  for (let i = 0; i < tokens.length; ) {
+    if (!current || typeof current !== "object") {
+      return void 0;
+    }
+    let next;
+    let nextPath = "";
+    for (let j = i; j < tokens.length; ++j) {
+      if (j !== i) {
+        nextPath += keySeparator;
+      }
+      nextPath += tokens[j];
+      next = current[nextPath];
+      if (next !== void 0) {
+        if (["string", "number", "boolean"].indexOf(typeof next) > -1 && j < tokens.length - 1) {
+          continue;
+        }
+        i += j - i + 1;
+        break;
+      }
+    }
+    current = next;
+  }
+  return current;
+};
+var getCleanedCode = (code) => code?.replace(/_/g, "-");
+var consoleLogger = {
+  type: "logger",
+  log(args) {
+    this.output("log", args);
+  },
+  warn(args) {
+    this.output("warn", args);
+  },
+  error(args) {
+    this.output("error", args);
+  },
+  output(type, args) {
+    console?.[type]?.apply?.(console, args);
+  }
+};
+var Logger = class _Logger {
+  constructor(concreteLogger, options = {}) {
+    this.init(concreteLogger, options);
+  }
+  init(concreteLogger, options = {}) {
+    this.prefix = options.prefix || "i18next:";
+    this.logger = concreteLogger || consoleLogger;
+    this.options = options;
+    this.debug = options.debug;
+  }
+  log(...args) {
+    return this.forward(args, "log", "", true);
+  }
+  warn(...args) {
+    return this.forward(args, "warn", "", true);
+  }
+  error(...args) {
+    return this.forward(args, "error", "");
+  }
+  deprecate(...args) {
+    return this.forward(args, "warn", "WARNING DEPRECATED: ", true);
+  }
+  forward(args, lvl, prefix, debugOnly) {
+    if (debugOnly && !this.debug) return null;
+    if (isString(args[0])) args[0] = `${prefix}${this.prefix} ${args[0]}`;
+    return this.logger[lvl](args);
+  }
+  create(moduleName) {
+    return new _Logger(this.logger, {
+      ...{
+        prefix: `${this.prefix}:${moduleName}:`
+      },
+      ...this.options
+    });
+  }
+  clone(options) {
+    options = options || this.options;
+    options.prefix = options.prefix || this.prefix;
+    return new _Logger(this.logger, options);
+  }
+};
+var baseLogger = new Logger();
+var EventEmitter = class {
+  constructor() {
+    this.observers = {};
+  }
+  on(events, listener) {
+    events.split(" ").forEach((event) => {
+      if (!this.observers[event]) this.observers[event] = /* @__PURE__ */ new Map();
+      const numListeners = this.observers[event].get(listener) || 0;
+      this.observers[event].set(listener, numListeners + 1);
+    });
+    return this;
+  }
+  off(event, listener) {
+    if (!this.observers[event]) return;
+    if (!listener) {
+      delete this.observers[event];
+      return;
+    }
+    this.observers[event].delete(listener);
+  }
+  emit(event, ...args) {
+    if (this.observers[event]) {
+      const cloned = Array.from(this.observers[event].entries());
+      cloned.forEach(([observer, numTimesAdded]) => {
+        for (let i = 0; i < numTimesAdded; i++) {
+          observer(...args);
+        }
+      });
+    }
+    if (this.observers["*"]) {
+      const cloned = Array.from(this.observers["*"].entries());
+      cloned.forEach(([observer, numTimesAdded]) => {
+        for (let i = 0; i < numTimesAdded; i++) {
+          observer.apply(observer, [event, ...args]);
+        }
+      });
+    }
+  }
+};
+var ResourceStore = class extends EventEmitter {
+  constructor(data, options = {
+    ns: ["translation"],
+    defaultNS: "translation"
+  }) {
+    super();
+    this.data = data || {};
+    this.options = options;
+    if (this.options.keySeparator === void 0) {
+      this.options.keySeparator = ".";
+    }
+    if (this.options.ignoreJSONStructure === void 0) {
+      this.options.ignoreJSONStructure = true;
+    }
+  }
+  addNamespaces(ns) {
+    if (this.options.ns.indexOf(ns) < 0) {
+      this.options.ns.push(ns);
+    }
+  }
+  removeNamespaces(ns) {
+    const index = this.options.ns.indexOf(ns);
+    if (index > -1) {
+      this.options.ns.splice(index, 1);
+    }
+  }
+  getResource(lng, ns, key, options = {}) {
+    const keySeparator = options.keySeparator !== void 0 ? options.keySeparator : this.options.keySeparator;
+    const ignoreJSONStructure = options.ignoreJSONStructure !== void 0 ? options.ignoreJSONStructure : this.options.ignoreJSONStructure;
+    let path;
+    if (lng.indexOf(".") > -1) {
+      path = lng.split(".");
+    } else {
+      path = [lng, ns];
+      if (key) {
+        if (Array.isArray(key)) {
+          path.push(...key);
+        } else if (isString(key) && keySeparator) {
+          path.push(...key.split(keySeparator));
+        } else {
+          path.push(key);
+        }
+      }
+    }
+    const result = getPath(this.data, path);
+    if (!result && !ns && !key && lng.indexOf(".") > -1) {
+      lng = path[0];
+      ns = path[1];
+      key = path.slice(2).join(".");
+    }
+    if (result || !ignoreJSONStructure || !isString(key)) return result;
+    return deepFind(this.data?.[lng]?.[ns], key, keySeparator);
+  }
+  addResource(lng, ns, key, value, options = {
+    silent: false
+  }) {
+    const keySeparator = options.keySeparator !== void 0 ? options.keySeparator : this.options.keySeparator;
+    let path = [lng, ns];
+    if (key) path = path.concat(keySeparator ? key.split(keySeparator) : key);
+    if (lng.indexOf(".") > -1) {
+      path = lng.split(".");
+      value = ns;
+      ns = path[1];
+    }
+    this.addNamespaces(ns);
+    setPath(this.data, path, value);
+    if (!options.silent) this.emit("added", lng, ns, key, value);
+  }
+  addResources(lng, ns, resources, options = {
+    silent: false
+  }) {
+    for (const m in resources) {
+      if (isString(resources[m]) || Array.isArray(resources[m])) this.addResource(lng, ns, m, resources[m], {
+        silent: true
+      });
+    }
+    if (!options.silent) this.emit("added", lng, ns, resources);
+  }
+  addResourceBundle(lng, ns, resources, deep, overwrite, options = {
+    silent: false,
+    skipCopy: false
+  }) {
+    let path = [lng, ns];
+    if (lng.indexOf(".") > -1) {
+      path = lng.split(".");
+      deep = resources;
+      resources = ns;
+      ns = path[1];
+    }
+    this.addNamespaces(ns);
+    let pack = getPath(this.data, path) || {};
+    if (!options.skipCopy) resources = JSON.parse(JSON.stringify(resources));
+    if (deep) {
+      deepExtend(pack, resources, overwrite);
+    } else {
+      pack = {
+        ...pack,
+        ...resources
+      };
+    }
+    setPath(this.data, path, pack);
+    if (!options.silent) this.emit("added", lng, ns, resources);
+  }
+  removeResourceBundle(lng, ns) {
+    if (this.hasResourceBundle(lng, ns)) {
+      delete this.data[lng][ns];
+    }
+    this.removeNamespaces(ns);
+    this.emit("removed", lng, ns);
+  }
+  hasResourceBundle(lng, ns) {
+    return this.getResource(lng, ns) !== void 0;
+  }
+  getResourceBundle(lng, ns) {
+    if (!ns) ns = this.options.defaultNS;
+    return this.getResource(lng, ns);
+  }
+  getDataByLanguage(lng) {
+    return this.data[lng];
+  }
+  hasLanguageSomeTranslations(lng) {
+    const data = this.getDataByLanguage(lng);
+    const n = data && Object.keys(data) || [];
+    return !!n.find((v) => data[v] && Object.keys(data[v]).length > 0);
+  }
+  toJSON() {
+    return this.data;
+  }
+};
+var postProcessor = {
+  processors: {},
+  addPostProcessor(module) {
+    this.processors[module.name] = module;
+  },
+  handle(processors, value, key, options, translator) {
+    processors.forEach((processor) => {
+      value = this.processors[processor]?.process(value, key, options, translator) ?? value;
+    });
+    return value;
+  }
+};
+var PATH_KEY = /* @__PURE__ */ Symbol("i18next/PATH_KEY");
+function createProxy() {
+  const state = [];
+  const handler = /* @__PURE__ */ Object.create(null);
+  let proxy;
+  handler.get = (target, key) => {
+    proxy?.revoke?.();
+    if (key === PATH_KEY) return state;
+    state.push(key);
+    proxy = Proxy.revocable(target, handler);
+    return proxy.proxy;
+  };
+  return Proxy.revocable(/* @__PURE__ */ Object.create(null), handler).proxy;
+}
+function keysFromSelector(selector, opts) {
+  const {
+    [PATH_KEY]: path
+  } = selector(createProxy());
+  const keySeparator = opts?.keySeparator ?? ".";
+  const nsSeparator = opts?.nsSeparator ?? ":";
+  if (path.length > 1 && nsSeparator) {
+    const ns = opts?.ns;
+    const namespaces = ns ? Array.isArray(ns) ? ns : [ns] : [];
+    if (namespaces.includes(path[0])) {
+      return `${path[0]}${nsSeparator}${path.slice(1).join(keySeparator)}`;
+    }
+  }
+  return path.join(keySeparator);
+}
+var checkedLoadedFor = {};
+var shouldHandleAsObject = (res) => !isString(res) && typeof res !== "boolean" && typeof res !== "number";
+var Translator = class _Translator extends EventEmitter {
+  constructor(services, options = {}) {
+    super();
+    copy(["resourceStore", "languageUtils", "pluralResolver", "interpolator", "backendConnector", "i18nFormat", "utils"], services, this);
+    this.options = options;
+    if (this.options.keySeparator === void 0) {
+      this.options.keySeparator = ".";
+    }
+    this.logger = baseLogger.create("translator");
+  }
+  changeLanguage(lng) {
+    if (lng) this.language = lng;
+  }
+  exists(key, o = {
+    interpolation: {}
+  }) {
+    const opt = {
+      ...o
+    };
+    if (key == null) return false;
+    const resolved = this.resolve(key, opt);
+    if (resolved?.res === void 0) return false;
+    const isObject = shouldHandleAsObject(resolved.res);
+    if (opt.returnObjects === false && isObject) {
+      return false;
+    }
+    return true;
+  }
+  extractFromKey(key, opt) {
+    let nsSeparator = opt.nsSeparator !== void 0 ? opt.nsSeparator : this.options.nsSeparator;
+    if (nsSeparator === void 0) nsSeparator = ":";
+    const keySeparator = opt.keySeparator !== void 0 ? opt.keySeparator : this.options.keySeparator;
+    let namespaces = opt.ns || this.options.defaultNS || [];
+    const wouldCheckForNsInKey = nsSeparator && key.indexOf(nsSeparator) > -1;
+    const seemsNaturalLanguage = !this.options.userDefinedKeySeparator && !opt.keySeparator && !this.options.userDefinedNsSeparator && !opt.nsSeparator && !looksLikeObjectPath(key, nsSeparator, keySeparator);
+    if (wouldCheckForNsInKey && !seemsNaturalLanguage) {
+      const m = key.match(this.interpolator.nestingRegexp);
+      if (m && m.length > 0) {
+        return {
+          key,
+          namespaces: isString(namespaces) ? [namespaces] : namespaces
+        };
+      }
+      const parts = key.split(nsSeparator);
+      if (nsSeparator !== keySeparator || nsSeparator === keySeparator && this.options.ns.indexOf(parts[0]) > -1) namespaces = parts.shift();
+      key = parts.join(keySeparator);
+    }
+    return {
+      key,
+      namespaces: isString(namespaces) ? [namespaces] : namespaces
+    };
+  }
+  translate(keys, o, lastKey) {
+    let opt = typeof o === "object" ? {
+      ...o
+    } : o;
+    if (typeof opt !== "object" && this.options.overloadTranslationOptionHandler) {
+      opt = this.options.overloadTranslationOptionHandler(arguments);
+    }
+    if (typeof opt === "object") opt = {
+      ...opt
+    };
+    if (!opt) opt = {};
+    if (keys == null) return "";
+    if (typeof keys === "function") keys = keysFromSelector(keys, {
+      ...this.options,
+      ...opt
+    });
+    if (!Array.isArray(keys)) keys = [String(keys)];
+    keys = keys.map((k) => typeof k === "function" ? keysFromSelector(k, {
+      ...this.options,
+      ...opt
+    }) : String(k));
+    const returnDetails = opt.returnDetails !== void 0 ? opt.returnDetails : this.options.returnDetails;
+    const keySeparator = opt.keySeparator !== void 0 ? opt.keySeparator : this.options.keySeparator;
+    const {
+      key,
+      namespaces
+    } = this.extractFromKey(keys[keys.length - 1], opt);
+    const namespace = namespaces[namespaces.length - 1];
+    let nsSeparator = opt.nsSeparator !== void 0 ? opt.nsSeparator : this.options.nsSeparator;
+    if (nsSeparator === void 0) nsSeparator = ":";
+    const lng = opt.lng || this.language;
+    const appendNamespaceToCIMode = opt.appendNamespaceToCIMode || this.options.appendNamespaceToCIMode;
+    if (lng?.toLowerCase() === "cimode") {
+      if (appendNamespaceToCIMode) {
+        if (returnDetails) {
+          return {
+            res: `${namespace}${nsSeparator}${key}`,
+            usedKey: key,
+            exactUsedKey: key,
+            usedLng: lng,
+            usedNS: namespace,
+            usedParams: this.getUsedParamsDetails(opt)
+          };
+        }
+        return `${namespace}${nsSeparator}${key}`;
+      }
+      if (returnDetails) {
+        return {
+          res: key,
+          usedKey: key,
+          exactUsedKey: key,
+          usedLng: lng,
+          usedNS: namespace,
+          usedParams: this.getUsedParamsDetails(opt)
+        };
+      }
+      return key;
+    }
+    const resolved = this.resolve(keys, opt);
+    let res = resolved?.res;
+    const resUsedKey = resolved?.usedKey || key;
+    const resExactUsedKey = resolved?.exactUsedKey || key;
+    const noObject = ["[object Number]", "[object Function]", "[object RegExp]"];
+    const joinArrays = opt.joinArrays !== void 0 ? opt.joinArrays : this.options.joinArrays;
+    const handleAsObjectInI18nFormat = !this.i18nFormat || this.i18nFormat.handleAsObject;
+    const needsPluralHandling = opt.count !== void 0 && !isString(opt.count);
+    const hasDefaultValue = _Translator.hasDefaultValue(opt);
+    const defaultValueSuffix = needsPluralHandling ? this.pluralResolver.getSuffix(lng, opt.count, opt) : "";
+    const defaultValueSuffixOrdinalFallback = opt.ordinal && needsPluralHandling ? this.pluralResolver.getSuffix(lng, opt.count, {
+      ordinal: false
+    }) : "";
+    const needsZeroSuffixLookup = needsPluralHandling && !opt.ordinal && opt.count === 0;
+    const defaultValue = needsZeroSuffixLookup && opt[`defaultValue${this.options.pluralSeparator}zero`] || opt[`defaultValue${defaultValueSuffix}`] || opt[`defaultValue${defaultValueSuffixOrdinalFallback}`] || opt.defaultValue;
+    let resForObjHndl = res;
+    if (handleAsObjectInI18nFormat && !res && hasDefaultValue) {
+      resForObjHndl = defaultValue;
+    }
+    const handleAsObject = shouldHandleAsObject(resForObjHndl);
+    const resType = Object.prototype.toString.apply(resForObjHndl);
+    if (handleAsObjectInI18nFormat && resForObjHndl && handleAsObject && noObject.indexOf(resType) < 0 && !(isString(joinArrays) && Array.isArray(resForObjHndl))) {
+      if (!opt.returnObjects && !this.options.returnObjects) {
+        if (!this.options.returnedObjectHandler) {
+          this.logger.warn("accessing an object - but returnObjects options is not enabled!");
+        }
+        const r = this.options.returnedObjectHandler ? this.options.returnedObjectHandler(resUsedKey, resForObjHndl, {
+          ...opt,
+          ns: namespaces
+        }) : `key '${key} (${this.language})' returned an object instead of string.`;
+        if (returnDetails) {
+          resolved.res = r;
+          resolved.usedParams = this.getUsedParamsDetails(opt);
+          return resolved;
+        }
+        return r;
+      }
+      if (keySeparator) {
+        const resTypeIsArray = Array.isArray(resForObjHndl);
+        const copy2 = resTypeIsArray ? [] : {};
+        const newKeyToUse = resTypeIsArray ? resExactUsedKey : resUsedKey;
+        for (const m in resForObjHndl) {
+          if (Object.prototype.hasOwnProperty.call(resForObjHndl, m)) {
+            const deepKey = `${newKeyToUse}${keySeparator}${m}`;
+            if (hasDefaultValue && !res) {
+              copy2[m] = this.translate(deepKey, {
+                ...opt,
+                defaultValue: shouldHandleAsObject(defaultValue) ? defaultValue[m] : void 0,
+                ...{
+                  joinArrays: false,
+                  ns: namespaces
+                }
+              });
+            } else {
+              copy2[m] = this.translate(deepKey, {
+                ...opt,
+                ...{
+                  joinArrays: false,
+                  ns: namespaces
+                }
+              });
+            }
+            if (copy2[m] === deepKey) copy2[m] = resForObjHndl[m];
+          }
+        }
+        res = copy2;
+      }
+    } else if (handleAsObjectInI18nFormat && isString(joinArrays) && Array.isArray(res)) {
+      res = res.join(joinArrays);
+      if (res) res = this.extendTranslation(res, keys, opt, lastKey);
+    } else {
+      let usedDefault = false;
+      let usedKey = false;
+      if (!this.isValidLookup(res) && hasDefaultValue) {
+        usedDefault = true;
+        res = defaultValue;
+      }
+      if (!this.isValidLookup(res)) {
+        usedKey = true;
+        res = key;
+      }
+      const missingKeyNoValueFallbackToKey = opt.missingKeyNoValueFallbackToKey || this.options.missingKeyNoValueFallbackToKey;
+      const resForMissing = missingKeyNoValueFallbackToKey && usedKey ? void 0 : res;
+      const updateMissing = hasDefaultValue && defaultValue !== res && this.options.updateMissing;
+      if (usedKey || usedDefault || updateMissing) {
+        this.logger.log(updateMissing ? "updateKey" : "missingKey", lng, namespace, key, updateMissing ? defaultValue : res);
+        if (keySeparator) {
+          const fk = this.resolve(key, {
+            ...opt,
+            keySeparator: false
+          });
+          if (fk && fk.res) this.logger.warn("Seems the loaded translations were in flat JSON format instead of nested. Either set keySeparator: false on init or make sure your translations are published in nested format.");
+        }
+        let lngs = [];
+        const fallbackLngs = this.languageUtils.getFallbackCodes(this.options.fallbackLng, opt.lng || this.language);
+        if (this.options.saveMissingTo === "fallback" && fallbackLngs && fallbackLngs[0]) {
+          for (let i = 0; i < fallbackLngs.length; i++) {
+            lngs.push(fallbackLngs[i]);
+          }
+        } else if (this.options.saveMissingTo === "all") {
+          lngs = this.languageUtils.toResolveHierarchy(opt.lng || this.language);
+        } else {
+          lngs.push(opt.lng || this.language);
+        }
+        const send = (l, k, specificDefaultValue) => {
+          const defaultForMissing = hasDefaultValue && specificDefaultValue !== res ? specificDefaultValue : resForMissing;
+          if (this.options.missingKeyHandler) {
+            this.options.missingKeyHandler(l, namespace, k, defaultForMissing, updateMissing, opt);
+          } else if (this.backendConnector?.saveMissing) {
+            this.backendConnector.saveMissing(l, namespace, k, defaultForMissing, updateMissing, opt);
+          }
+          this.emit("missingKey", l, namespace, k, res);
+        };
+        if (this.options.saveMissing) {
+          if (this.options.saveMissingPlurals && needsPluralHandling) {
+            lngs.forEach((language) => {
+              const suffixes = this.pluralResolver.getSuffixes(language, opt);
+              if (needsZeroSuffixLookup && opt[`defaultValue${this.options.pluralSeparator}zero`] && suffixes.indexOf(`${this.options.pluralSeparator}zero`) < 0) {
+                suffixes.push(`${this.options.pluralSeparator}zero`);
+              }
+              suffixes.forEach((suffix) => {
+                send([language], key + suffix, opt[`defaultValue${suffix}`] || defaultValue);
+              });
+            });
+          } else {
+            send(lngs, key, defaultValue);
+          }
+        }
+      }
+      res = this.extendTranslation(res, keys, opt, resolved, lastKey);
+      if (usedKey && res === key && this.options.appendNamespaceToMissingKey) {
+        res = `${namespace}${nsSeparator}${key}`;
+      }
+      if ((usedKey || usedDefault) && this.options.parseMissingKeyHandler) {
+        res = this.options.parseMissingKeyHandler(this.options.appendNamespaceToMissingKey ? `${namespace}${nsSeparator}${key}` : key, usedDefault ? res : void 0, opt);
+      }
+    }
+    if (returnDetails) {
+      resolved.res = res;
+      resolved.usedParams = this.getUsedParamsDetails(opt);
+      return resolved;
+    }
+    return res;
+  }
+  extendTranslation(res, key, opt, resolved, lastKey) {
+    if (this.i18nFormat?.parse) {
+      res = this.i18nFormat.parse(res, {
+        ...this.options.interpolation.defaultVariables,
+        ...opt
+      }, opt.lng || this.language || resolved.usedLng, resolved.usedNS, resolved.usedKey, {
+        resolved
+      });
+    } else if (!opt.skipInterpolation) {
+      if (opt.interpolation) this.interpolator.init({
+        ...opt,
+        ...{
+          interpolation: {
+            ...this.options.interpolation,
+            ...opt.interpolation
+          }
+        }
+      });
+      const skipOnVariables = isString(res) && (opt?.interpolation?.skipOnVariables !== void 0 ? opt.interpolation.skipOnVariables : this.options.interpolation.skipOnVariables);
+      let nestBef;
+      if (skipOnVariables) {
+        const nb = res.match(this.interpolator.nestingRegexp);
+        nestBef = nb && nb.length;
+      }
+      let data = opt.replace && !isString(opt.replace) ? opt.replace : opt;
+      if (this.options.interpolation.defaultVariables) data = {
+        ...this.options.interpolation.defaultVariables,
+        ...data
+      };
+      res = this.interpolator.interpolate(res, data, opt.lng || this.language || resolved.usedLng, opt);
+      if (skipOnVariables) {
+        const na = res.match(this.interpolator.nestingRegexp);
+        const nestAft = na && na.length;
+        if (nestBef < nestAft) opt.nest = false;
+      }
+      if (!opt.lng && resolved && resolved.res) opt.lng = this.language || resolved.usedLng;
+      if (opt.nest !== false) res = this.interpolator.nest(res, (...args) => {
+        if (lastKey?.[0] === args[0] && !opt.context) {
+          this.logger.warn(`It seems you are nesting recursively key: ${args[0]} in key: ${key[0]}`);
+          return null;
+        }
+        return this.translate(...args, key);
+      }, opt);
+      if (opt.interpolation) this.interpolator.reset();
+    }
+    const postProcess = opt.postProcess || this.options.postProcess;
+    const postProcessorNames = isString(postProcess) ? [postProcess] : postProcess;
+    if (res != null && postProcessorNames?.length && opt.applyPostProcessor !== false) {
+      res = postProcessor.handle(postProcessorNames, res, key, this.options && this.options.postProcessPassResolved ? {
+        i18nResolved: {
+          ...resolved,
+          usedParams: this.getUsedParamsDetails(opt)
+        },
+        ...opt
+      } : opt, this);
+    }
+    return res;
+  }
+  resolve(keys, opt = {}) {
+    let found;
+    let usedKey;
+    let exactUsedKey;
+    let usedLng;
+    let usedNS;
+    if (isString(keys)) keys = [keys];
+    if (Array.isArray(keys)) keys = keys.map((k) => typeof k === "function" ? keysFromSelector(k, {
+      ...this.options,
+      ...opt
+    }) : k);
+    keys.forEach((k) => {
+      if (this.isValidLookup(found)) return;
+      const extracted = this.extractFromKey(k, opt);
+      const key = extracted.key;
+      usedKey = key;
+      let namespaces = extracted.namespaces;
+      if (this.options.fallbackNS) namespaces = namespaces.concat(this.options.fallbackNS);
+      const needsPluralHandling = opt.count !== void 0 && !isString(opt.count);
+      const needsZeroSuffixLookup = needsPluralHandling && !opt.ordinal && opt.count === 0;
+      const needsContextHandling = opt.context !== void 0 && (isString(opt.context) || typeof opt.context === "number") && opt.context !== "";
+      const codes = opt.lngs ? opt.lngs : this.languageUtils.toResolveHierarchy(opt.lng || this.language, opt.fallbackLng);
+      namespaces.forEach((ns) => {
+        if (this.isValidLookup(found)) return;
+        usedNS = ns;
+        if (!checkedLoadedFor[`${codes[0]}-${ns}`] && this.utils?.hasLoadedNamespace && !this.utils?.hasLoadedNamespace(usedNS)) {
+          checkedLoadedFor[`${codes[0]}-${ns}`] = true;
+          this.logger.warn(`key "${usedKey}" for languages "${codes.join(", ")}" won't get resolved as namespace "${usedNS}" was not yet loaded`, "This means something IS WRONG in your setup. You access the t function before i18next.init / i18next.loadNamespace / i18next.changeLanguage was done. Wait for the callback or Promise to resolve before accessing it!!!");
+        }
+        codes.forEach((code) => {
+          if (this.isValidLookup(found)) return;
+          usedLng = code;
+          const finalKeys = [key];
+          if (this.i18nFormat?.addLookupKeys) {
+            this.i18nFormat.addLookupKeys(finalKeys, key, code, ns, opt);
+          } else {
+            let pluralSuffix;
+            if (needsPluralHandling) pluralSuffix = this.pluralResolver.getSuffix(code, opt.count, opt);
+            const zeroSuffix = `${this.options.pluralSeparator}zero`;
+            const ordinalPrefix = `${this.options.pluralSeparator}ordinal${this.options.pluralSeparator}`;
+            if (needsPluralHandling) {
+              if (opt.ordinal && pluralSuffix.indexOf(ordinalPrefix) === 0) {
+                finalKeys.push(key + pluralSuffix.replace(ordinalPrefix, this.options.pluralSeparator));
+              }
+              finalKeys.push(key + pluralSuffix);
+              if (needsZeroSuffixLookup) {
+                finalKeys.push(key + zeroSuffix);
+              }
+            }
+            if (needsContextHandling) {
+              const contextKey = `${key}${this.options.contextSeparator || "_"}${opt.context}`;
+              finalKeys.push(contextKey);
+              if (needsPluralHandling) {
+                if (opt.ordinal && pluralSuffix.indexOf(ordinalPrefix) === 0) {
+                  finalKeys.push(contextKey + pluralSuffix.replace(ordinalPrefix, this.options.pluralSeparator));
+                }
+                finalKeys.push(contextKey + pluralSuffix);
+                if (needsZeroSuffixLookup) {
+                  finalKeys.push(contextKey + zeroSuffix);
+                }
+              }
+            }
+          }
+          let possibleKey;
+          while (possibleKey = finalKeys.pop()) {
+            if (!this.isValidLookup(found)) {
+              exactUsedKey = possibleKey;
+              found = this.getResource(code, ns, possibleKey, opt);
+            }
+          }
+        });
+      });
+    });
+    return {
+      res: found,
+      usedKey,
+      exactUsedKey,
+      usedLng,
+      usedNS
+    };
+  }
+  isValidLookup(res) {
+    return res !== void 0 && !(!this.options.returnNull && res === null) && !(!this.options.returnEmptyString && res === "");
+  }
+  getResource(code, ns, key, options = {}) {
+    if (this.i18nFormat?.getResource) return this.i18nFormat.getResource(code, ns, key, options);
+    return this.resourceStore.getResource(code, ns, key, options);
+  }
+  getUsedParamsDetails(options = {}) {
+    const optionsKeys = ["defaultValue", "ordinal", "context", "replace", "lng", "lngs", "fallbackLng", "ns", "keySeparator", "nsSeparator", "returnObjects", "returnDetails", "joinArrays", "postProcess", "interpolation"];
+    const useOptionsReplaceForData = options.replace && !isString(options.replace);
+    let data = useOptionsReplaceForData ? options.replace : options;
+    if (useOptionsReplaceForData && typeof options.count !== "undefined") {
+      data.count = options.count;
+    }
+    if (this.options.interpolation.defaultVariables) {
+      data = {
+        ...this.options.interpolation.defaultVariables,
+        ...data
+      };
+    }
+    if (!useOptionsReplaceForData) {
+      data = {
+        ...data
+      };
+      for (const key of optionsKeys) {
+        delete data[key];
+      }
+    }
+    return data;
+  }
+  static hasDefaultValue(options) {
+    const prefix = "defaultValue";
+    for (const option in options) {
+      if (Object.prototype.hasOwnProperty.call(options, option) && prefix === option.substring(0, prefix.length) && void 0 !== options[option]) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+var LanguageUtil = class {
+  constructor(options) {
+    this.options = options;
+    this.supportedLngs = this.options.supportedLngs || false;
+    this.logger = baseLogger.create("languageUtils");
+  }
+  getScriptPartFromCode(code) {
+    code = getCleanedCode(code);
+    if (!code || code.indexOf("-") < 0) return null;
+    const p = code.split("-");
+    if (p.length === 2) return null;
+    p.pop();
+    if (p[p.length - 1].toLowerCase() === "x") return null;
+    return this.formatLanguageCode(p.join("-"));
+  }
+  getLanguagePartFromCode(code) {
+    code = getCleanedCode(code);
+    if (!code || code.indexOf("-") < 0) return code;
+    const p = code.split("-");
+    return this.formatLanguageCode(p[0]);
+  }
+  formatLanguageCode(code) {
+    if (isString(code) && code.indexOf("-") > -1) {
+      let formattedCode;
+      try {
+        formattedCode = Intl.getCanonicalLocales(code)[0];
+      } catch (e) {
+      }
+      if (formattedCode && this.options.lowerCaseLng) {
+        formattedCode = formattedCode.toLowerCase();
+      }
+      if (formattedCode) return formattedCode;
+      if (this.options.lowerCaseLng) {
+        return code.toLowerCase();
+      }
+      return code;
+    }
+    return this.options.cleanCode || this.options.lowerCaseLng ? code.toLowerCase() : code;
+  }
+  isSupportedCode(code) {
+    if (this.options.load === "languageOnly" || this.options.nonExplicitSupportedLngs) {
+      code = this.getLanguagePartFromCode(code);
+    }
+    return !this.supportedLngs || !this.supportedLngs.length || this.supportedLngs.indexOf(code) > -1;
+  }
+  getBestMatchFromCodes(codes) {
+    if (!codes) return null;
+    let found;
+    codes.forEach((code) => {
+      if (found) return;
+      const cleanedLng = this.formatLanguageCode(code);
+      if (!this.options.supportedLngs || this.isSupportedCode(cleanedLng)) found = cleanedLng;
+    });
+    if (!found && this.options.supportedLngs) {
+      codes.forEach((code) => {
+        if (found) return;
+        const lngScOnly = this.getScriptPartFromCode(code);
+        if (this.isSupportedCode(lngScOnly)) return found = lngScOnly;
+        const lngOnly = this.getLanguagePartFromCode(code);
+        if (this.isSupportedCode(lngOnly)) return found = lngOnly;
+        found = this.options.supportedLngs.find((supportedLng) => {
+          if (supportedLng === lngOnly) return supportedLng;
+          if (supportedLng.indexOf("-") < 0 && lngOnly.indexOf("-") < 0) return;
+          if (supportedLng.indexOf("-") > 0 && lngOnly.indexOf("-") < 0 && supportedLng.substring(0, supportedLng.indexOf("-")) === lngOnly) return supportedLng;
+          if (supportedLng.indexOf(lngOnly) === 0 && lngOnly.length > 1) return supportedLng;
+        });
+      });
+    }
+    if (!found) found = this.getFallbackCodes(this.options.fallbackLng)[0];
+    return found;
+  }
+  getFallbackCodes(fallbacks, code) {
+    if (!fallbacks) return [];
+    if (typeof fallbacks === "function") fallbacks = fallbacks(code);
+    if (isString(fallbacks)) fallbacks = [fallbacks];
+    if (Array.isArray(fallbacks)) return fallbacks;
+    if (!code) return fallbacks.default || [];
+    let found = fallbacks[code];
+    if (!found) found = fallbacks[this.getScriptPartFromCode(code)];
+    if (!found) found = fallbacks[this.formatLanguageCode(code)];
+    if (!found) found = fallbacks[this.getLanguagePartFromCode(code)];
+    if (!found) found = fallbacks.default;
+    return found || [];
+  }
+  toResolveHierarchy(code, fallbackCode) {
+    const fallbackCodes = this.getFallbackCodes((fallbackCode === false ? [] : fallbackCode) || this.options.fallbackLng || [], code);
+    const codes = [];
+    const addCode = (c) => {
+      if (!c) return;
+      if (this.isSupportedCode(c)) {
+        codes.push(c);
+      } else {
+        this.logger.warn(`rejecting language code not found in supportedLngs: ${c}`);
+      }
+    };
+    if (isString(code) && (code.indexOf("-") > -1 || code.indexOf("_") > -1)) {
+      if (this.options.load !== "languageOnly") addCode(this.formatLanguageCode(code));
+      if (this.options.load !== "languageOnly" && this.options.load !== "currentOnly") addCode(this.getScriptPartFromCode(code));
+      if (this.options.load !== "currentOnly") addCode(this.getLanguagePartFromCode(code));
+    } else if (isString(code)) {
+      addCode(this.formatLanguageCode(code));
+    }
+    fallbackCodes.forEach((fc) => {
+      if (codes.indexOf(fc) < 0) addCode(this.formatLanguageCode(fc));
+    });
+    return codes;
+  }
+};
+var suffixesOrder = {
+  zero: 0,
+  one: 1,
+  two: 2,
+  few: 3,
+  many: 4,
+  other: 5
+};
+var dummyRule = {
+  select: (count) => count === 1 ? "one" : "other",
+  resolvedOptions: () => ({
+    pluralCategories: ["one", "other"]
+  })
+};
+var PluralResolver = class {
+  constructor(languageUtils, options = {}) {
+    this.languageUtils = languageUtils;
+    this.options = options;
+    this.logger = baseLogger.create("pluralResolver");
+    this.pluralRulesCache = {};
+  }
+  clearCache() {
+    this.pluralRulesCache = {};
+  }
+  getRule(code, options = {}) {
+    const cleanedCode = getCleanedCode(code === "dev" ? "en" : code);
+    const type = options.ordinal ? "ordinal" : "cardinal";
+    const cacheKey = JSON.stringify({
+      cleanedCode,
+      type
+    });
+    if (cacheKey in this.pluralRulesCache) {
+      return this.pluralRulesCache[cacheKey];
+    }
+    let rule;
+    try {
+      rule = new Intl.PluralRules(cleanedCode, {
+        type
+      });
+    } catch (err) {
+      if (typeof Intl === "undefined") {
+        this.logger.error("No Intl support, please use an Intl polyfill!");
+        return dummyRule;
+      }
+      if (!code.match(/-|_/)) return dummyRule;
+      const lngPart = this.languageUtils.getLanguagePartFromCode(code);
+      rule = this.getRule(lngPart, options);
+    }
+    this.pluralRulesCache[cacheKey] = rule;
+    return rule;
+  }
+  needsPlural(code, options = {}) {
+    let rule = this.getRule(code, options);
+    if (!rule) rule = this.getRule("dev", options);
+    return rule?.resolvedOptions().pluralCategories.length > 1;
+  }
+  getPluralFormsOfKey(code, key, options = {}) {
+    return this.getSuffixes(code, options).map((suffix) => `${key}${suffix}`);
+  }
+  getSuffixes(code, options = {}) {
+    let rule = this.getRule(code, options);
+    if (!rule) rule = this.getRule("dev", options);
+    if (!rule) return [];
+    return rule.resolvedOptions().pluralCategories.sort((pluralCategory1, pluralCategory2) => suffixesOrder[pluralCategory1] - suffixesOrder[pluralCategory2]).map((pluralCategory) => `${this.options.prepend}${options.ordinal ? `ordinal${this.options.prepend}` : ""}${pluralCategory}`);
+  }
+  getSuffix(code, count, options = {}) {
+    const rule = this.getRule(code, options);
+    if (rule) {
+      return `${this.options.prepend}${options.ordinal ? `ordinal${this.options.prepend}` : ""}${rule.select(count)}`;
+    }
+    this.logger.warn(`no plural rule found for: ${code}`);
+    return this.getSuffix("dev", count, options);
+  }
+};
+var deepFindWithDefaults = (data, defaultData, key, keySeparator = ".", ignoreJSONStructure = true) => {
+  let path = getPathWithDefaults(data, defaultData, key);
+  if (!path && ignoreJSONStructure && isString(key)) {
+    path = deepFind(data, key, keySeparator);
+    if (path === void 0) path = deepFind(defaultData, key, keySeparator);
+  }
+  return path;
+};
+var regexSafe = (val) => val.replace(/\$/g, "$$$$");
+var Interpolator = class {
+  constructor(options = {}) {
+    this.logger = baseLogger.create("interpolator");
+    this.options = options;
+    this.format = options?.interpolation?.format || ((value) => value);
+    this.init(options);
+  }
+  init(options = {}) {
+    if (!options.interpolation) options.interpolation = {
+      escapeValue: true
+    };
+    const {
+      escape: escape$1,
+      escapeValue,
+      useRawValueToEscape,
+      prefix,
+      prefixEscaped,
+      suffix,
+      suffixEscaped,
+      formatSeparator,
+      unescapeSuffix,
+      unescapePrefix,
+      nestingPrefix,
+      nestingPrefixEscaped,
+      nestingSuffix,
+      nestingSuffixEscaped,
+      nestingOptionsSeparator,
+      maxReplaces,
+      alwaysFormat
+    } = options.interpolation;
+    this.escape = escape$1 !== void 0 ? escape$1 : escape;
+    this.escapeValue = escapeValue !== void 0 ? escapeValue : true;
+    this.useRawValueToEscape = useRawValueToEscape !== void 0 ? useRawValueToEscape : false;
+    this.prefix = prefix ? regexEscape(prefix) : prefixEscaped || "{{";
+    this.suffix = suffix ? regexEscape(suffix) : suffixEscaped || "}}";
+    this.formatSeparator = formatSeparator || ",";
+    this.unescapePrefix = unescapeSuffix ? "" : unescapePrefix || "-";
+    this.unescapeSuffix = this.unescapePrefix ? "" : unescapeSuffix || "";
+    this.nestingPrefix = nestingPrefix ? regexEscape(nestingPrefix) : nestingPrefixEscaped || regexEscape("$t(");
+    this.nestingSuffix = nestingSuffix ? regexEscape(nestingSuffix) : nestingSuffixEscaped || regexEscape(")");
+    this.nestingOptionsSeparator = nestingOptionsSeparator || ",";
+    this.maxReplaces = maxReplaces || 1e3;
+    this.alwaysFormat = alwaysFormat !== void 0 ? alwaysFormat : false;
+    this.resetRegExp();
+  }
+  reset() {
+    if (this.options) this.init(this.options);
+  }
+  resetRegExp() {
+    const getOrResetRegExp = (existingRegExp, pattern) => {
+      if (existingRegExp?.source === pattern) {
+        existingRegExp.lastIndex = 0;
+        return existingRegExp;
+      }
+      return new RegExp(pattern, "g");
+    };
+    this.regexp = getOrResetRegExp(this.regexp, `${this.prefix}(.+?)${this.suffix}`);
+    this.regexpUnescape = getOrResetRegExp(this.regexpUnescape, `${this.prefix}${this.unescapePrefix}(.+?)${this.unescapeSuffix}${this.suffix}`);
+    this.nestingRegexp = getOrResetRegExp(this.nestingRegexp, `${this.nestingPrefix}((?:[^()"']+|"[^"]*"|'[^']*'|\\((?:[^()]|"[^"]*"|'[^']*')*\\))*?)${this.nestingSuffix}`);
+  }
+  interpolate(str, data, lng, options) {
+    let match;
+    let value;
+    let replaces;
+    const defaultData = this.options && this.options.interpolation && this.options.interpolation.defaultVariables || {};
+    const handleFormat = (key) => {
+      if (key.indexOf(this.formatSeparator) < 0) {
+        const path = deepFindWithDefaults(data, defaultData, key, this.options.keySeparator, this.options.ignoreJSONStructure);
+        return this.alwaysFormat ? this.format(path, void 0, lng, {
+          ...options,
+          ...data,
+          interpolationkey: key
+        }) : path;
+      }
+      const p = key.split(this.formatSeparator);
+      const k = p.shift().trim();
+      const f = p.join(this.formatSeparator).trim();
+      return this.format(deepFindWithDefaults(data, defaultData, k, this.options.keySeparator, this.options.ignoreJSONStructure), f, lng, {
+        ...options,
+        ...data,
+        interpolationkey: k
+      });
+    };
+    this.resetRegExp();
+    const missingInterpolationHandler = options?.missingInterpolationHandler || this.options.missingInterpolationHandler;
+    const skipOnVariables = options?.interpolation?.skipOnVariables !== void 0 ? options.interpolation.skipOnVariables : this.options.interpolation.skipOnVariables;
+    const todos = [{
+      regex: this.regexpUnescape,
+      safeValue: (val) => regexSafe(val)
+    }, {
+      regex: this.regexp,
+      safeValue: (val) => this.escapeValue ? regexSafe(this.escape(val)) : regexSafe(val)
+    }];
+    todos.forEach((todo) => {
+      replaces = 0;
+      while (match = todo.regex.exec(str)) {
+        const matchedVar = match[1].trim();
+        value = handleFormat(matchedVar);
+        if (value === void 0) {
+          if (typeof missingInterpolationHandler === "function") {
+            const temp = missingInterpolationHandler(str, match, options);
+            value = isString(temp) ? temp : "";
+          } else if (options && Object.prototype.hasOwnProperty.call(options, matchedVar)) {
+            value = "";
+          } else if (skipOnVariables) {
+            value = match[0];
+            continue;
+          } else {
+            this.logger.warn(`missed to pass in variable ${matchedVar} for interpolating ${str}`);
+            value = "";
+          }
+        } else if (!isString(value) && !this.useRawValueToEscape) {
+          value = makeString(value);
+        }
+        const safeValue = todo.safeValue(value);
+        str = str.replace(match[0], safeValue);
+        if (skipOnVariables) {
+          todo.regex.lastIndex += value.length;
+          todo.regex.lastIndex -= match[0].length;
+        } else {
+          todo.regex.lastIndex = 0;
+        }
+        replaces++;
+        if (replaces >= this.maxReplaces) {
+          break;
+        }
+      }
+    });
+    return str;
+  }
+  nest(str, fc, options = {}) {
+    let match;
+    let value;
+    let clonedOptions;
+    const handleHasOptions = (key, inheritedOptions) => {
+      const sep = this.nestingOptionsSeparator;
+      if (key.indexOf(sep) < 0) return key;
+      const c = key.split(new RegExp(`${regexEscape(sep)}[ ]*{`));
+      let optionsString = `{${c[1]}`;
+      key = c[0];
+      optionsString = this.interpolate(optionsString, clonedOptions);
+      const matchedSingleQuotes = optionsString.match(/'/g);
+      const matchedDoubleQuotes = optionsString.match(/"/g);
+      if ((matchedSingleQuotes?.length ?? 0) % 2 === 0 && !matchedDoubleQuotes || (matchedDoubleQuotes?.length ?? 0) % 2 !== 0) {
+        optionsString = optionsString.replace(/'/g, '"');
+      }
+      try {
+        clonedOptions = JSON.parse(optionsString);
+        if (inheritedOptions) clonedOptions = {
+          ...inheritedOptions,
+          ...clonedOptions
+        };
+      } catch (e) {
+        this.logger.warn(`failed parsing options string in nesting for key ${key}`, e);
+        return `${key}${sep}${optionsString}`;
+      }
+      if (clonedOptions.defaultValue && clonedOptions.defaultValue.indexOf(this.prefix) > -1) delete clonedOptions.defaultValue;
+      return key;
+    };
+    while (match = this.nestingRegexp.exec(str)) {
+      let formatters = [];
+      clonedOptions = {
+        ...options
+      };
+      clonedOptions = clonedOptions.replace && !isString(clonedOptions.replace) ? clonedOptions.replace : clonedOptions;
+      clonedOptions.applyPostProcessor = false;
+      delete clonedOptions.defaultValue;
+      const keyEndIndex = /{.*}/.test(match[1]) ? match[1].lastIndexOf("}") + 1 : match[1].indexOf(this.formatSeparator);
+      if (keyEndIndex !== -1) {
+        formatters = match[1].slice(keyEndIndex).split(this.formatSeparator).map((elem) => elem.trim()).filter(Boolean);
+        match[1] = match[1].slice(0, keyEndIndex);
+      }
+      value = fc(handleHasOptions.call(this, match[1].trim(), clonedOptions), clonedOptions);
+      if (value && match[0] === str && !isString(value)) return value;
+      if (!isString(value)) value = makeString(value);
+      if (!value) {
+        this.logger.warn(`missed to resolve ${match[1]} for nesting ${str}`);
+        value = "";
+      }
+      if (formatters.length) {
+        value = formatters.reduce((v, f) => this.format(v, f, options.lng, {
+          ...options,
+          interpolationkey: match[1].trim()
+        }), value.trim());
+      }
+      str = str.replace(match[0], value);
+      this.regexp.lastIndex = 0;
+    }
+    return str;
+  }
+};
+var parseFormatStr = (formatStr) => {
+  let formatName = formatStr.toLowerCase().trim();
+  const formatOptions = {};
+  if (formatStr.indexOf("(") > -1) {
+    const p = formatStr.split("(");
+    formatName = p[0].toLowerCase().trim();
+    const optStr = p[1].substring(0, p[1].length - 1);
+    if (formatName === "currency" && optStr.indexOf(":") < 0) {
+      if (!formatOptions.currency) formatOptions.currency = optStr.trim();
+    } else if (formatName === "relativetime" && optStr.indexOf(":") < 0) {
+      if (!formatOptions.range) formatOptions.range = optStr.trim();
+    } else {
+      const opts = optStr.split(";");
+      opts.forEach((opt) => {
+        if (opt) {
+          const [key, ...rest] = opt.split(":");
+          const val = rest.join(":").trim().replace(/^'+|'+$/g, "");
+          const trimmedKey = key.trim();
+          if (!formatOptions[trimmedKey]) formatOptions[trimmedKey] = val;
+          if (val === "false") formatOptions[trimmedKey] = false;
+          if (val === "true") formatOptions[trimmedKey] = true;
+          if (!isNaN(val)) formatOptions[trimmedKey] = parseInt(val, 10);
+        }
+      });
+    }
+  }
+  return {
+    formatName,
+    formatOptions
+  };
+};
+var createCachedFormatter = (fn) => {
+  const cache = {};
+  return (v, l, o) => {
+    let optForCache = o;
+    if (o && o.interpolationkey && o.formatParams && o.formatParams[o.interpolationkey] && o[o.interpolationkey]) {
+      optForCache = {
+        ...optForCache,
+        [o.interpolationkey]: void 0
+      };
+    }
+    const key = l + JSON.stringify(optForCache);
+    let frm = cache[key];
+    if (!frm) {
+      frm = fn(getCleanedCode(l), o);
+      cache[key] = frm;
+    }
+    return frm(v);
+  };
+};
+var createNonCachedFormatter = (fn) => (v, l, o) => fn(getCleanedCode(l), o)(v);
+var Formatter = class {
+  constructor(options = {}) {
+    this.logger = baseLogger.create("formatter");
+    this.options = options;
+    this.init(options);
+  }
+  init(services, options = {
+    interpolation: {}
+  }) {
+    this.formatSeparator = options.interpolation.formatSeparator || ",";
+    const cf = options.cacheInBuiltFormats ? createCachedFormatter : createNonCachedFormatter;
+    this.formats = {
+      number: cf((lng, opt) => {
+        const formatter = new Intl.NumberFormat(lng, {
+          ...opt
+        });
+        return (val) => formatter.format(val);
+      }),
+      currency: cf((lng, opt) => {
+        const formatter = new Intl.NumberFormat(lng, {
+          ...opt,
+          style: "currency"
+        });
+        return (val) => formatter.format(val);
+      }),
+      datetime: cf((lng, opt) => {
+        const formatter = new Intl.DateTimeFormat(lng, {
+          ...opt
+        });
+        return (val) => formatter.format(val);
+      }),
+      relativetime: cf((lng, opt) => {
+        const formatter = new Intl.RelativeTimeFormat(lng, {
+          ...opt
+        });
+        return (val) => formatter.format(val, opt.range || "day");
+      }),
+      list: cf((lng, opt) => {
+        const formatter = new Intl.ListFormat(lng, {
+          ...opt
+        });
+        return (val) => formatter.format(val);
+      })
+    };
+  }
+  add(name, fc) {
+    this.formats[name.toLowerCase().trim()] = fc;
+  }
+  addCached(name, fc) {
+    this.formats[name.toLowerCase().trim()] = createCachedFormatter(fc);
+  }
+  format(value, format, lng, options = {}) {
+    const formats = format.split(this.formatSeparator);
+    if (formats.length > 1 && formats[0].indexOf("(") > 1 && formats[0].indexOf(")") < 0 && formats.find((f) => f.indexOf(")") > -1)) {
+      const lastIndex = formats.findIndex((f) => f.indexOf(")") > -1);
+      formats[0] = [formats[0], ...formats.splice(1, lastIndex)].join(this.formatSeparator);
+    }
+    const result = formats.reduce((mem, f) => {
+      const {
+        formatName,
+        formatOptions
+      } = parseFormatStr(f);
+      if (this.formats[formatName]) {
+        let formatted = mem;
+        try {
+          const valOptions = options?.formatParams?.[options.interpolationkey] || {};
+          const l = valOptions.locale || valOptions.lng || options.locale || options.lng || lng;
+          formatted = this.formats[formatName](mem, l, {
+            ...formatOptions,
+            ...options,
+            ...valOptions
+          });
+        } catch (error) {
+          this.logger.warn(error);
+        }
+        return formatted;
+      } else {
+        this.logger.warn(`there was no format function for ${formatName}`);
+      }
+      return mem;
+    }, value);
+    return result;
+  }
+};
+var removePending = (q, name) => {
+  if (q.pending[name] !== void 0) {
+    delete q.pending[name];
+    q.pendingCount--;
+  }
+};
+var Connector = class extends EventEmitter {
+  constructor(backend, store, services, options = {}) {
+    super();
+    this.backend = backend;
+    this.store = store;
+    this.services = services;
+    this.languageUtils = services.languageUtils;
+    this.options = options;
+    this.logger = baseLogger.create("backendConnector");
+    this.waitingReads = [];
+    this.maxParallelReads = options.maxParallelReads || 10;
+    this.readingCalls = 0;
+    this.maxRetries = options.maxRetries >= 0 ? options.maxRetries : 5;
+    this.retryTimeout = options.retryTimeout >= 1 ? options.retryTimeout : 350;
+    this.state = {};
+    this.queue = [];
+    this.backend?.init?.(services, options.backend, options);
+  }
+  queueLoad(languages, namespaces, options, callback) {
+    const toLoad = {};
+    const pending = {};
+    const toLoadLanguages = {};
+    const toLoadNamespaces = {};
+    languages.forEach((lng) => {
+      let hasAllNamespaces = true;
+      namespaces.forEach((ns) => {
+        const name = `${lng}|${ns}`;
+        if (!options.reload && this.store.hasResourceBundle(lng, ns)) {
+          this.state[name] = 2;
+        } else if (this.state[name] < 0) ;
+        else if (this.state[name] === 1) {
+          if (pending[name] === void 0) pending[name] = true;
+        } else {
+          this.state[name] = 1;
+          hasAllNamespaces = false;
+          if (pending[name] === void 0) pending[name] = true;
+          if (toLoad[name] === void 0) toLoad[name] = true;
+          if (toLoadNamespaces[ns] === void 0) toLoadNamespaces[ns] = true;
+        }
+      });
+      if (!hasAllNamespaces) toLoadLanguages[lng] = true;
+    });
+    if (Object.keys(toLoad).length || Object.keys(pending).length) {
+      this.queue.push({
+        pending,
+        pendingCount: Object.keys(pending).length,
+        loaded: {},
+        errors: [],
+        callback
+      });
+    }
+    return {
+      toLoad: Object.keys(toLoad),
+      pending: Object.keys(pending),
+      toLoadLanguages: Object.keys(toLoadLanguages),
+      toLoadNamespaces: Object.keys(toLoadNamespaces)
+    };
+  }
+  loaded(name, err, data) {
+    const s = name.split("|");
+    const lng = s[0];
+    const ns = s[1];
+    if (err) this.emit("failedLoading", lng, ns, err);
+    if (!err && data) {
+      this.store.addResourceBundle(lng, ns, data, void 0, void 0, {
+        skipCopy: true
+      });
+    }
+    this.state[name] = err ? -1 : 2;
+    if (err && data) this.state[name] = 0;
+    const loaded = {};
+    this.queue.forEach((q) => {
+      pushPath(q.loaded, [lng], ns);
+      removePending(q, name);
+      if (err) q.errors.push(err);
+      if (q.pendingCount === 0 && !q.done) {
+        Object.keys(q.loaded).forEach((l) => {
+          if (!loaded[l]) loaded[l] = {};
+          const loadedKeys = q.loaded[l];
+          if (loadedKeys.length) {
+            loadedKeys.forEach((n) => {
+              if (loaded[l][n] === void 0) loaded[l][n] = true;
+            });
+          }
+        });
+        q.done = true;
+        if (q.errors.length) {
+          q.callback(q.errors);
+        } else {
+          q.callback();
+        }
+      }
+    });
+    this.emit("loaded", loaded);
+    this.queue = this.queue.filter((q) => !q.done);
+  }
+  read(lng, ns, fcName, tried = 0, wait = this.retryTimeout, callback) {
+    if (!lng.length) return callback(null, {});
+    if (this.readingCalls >= this.maxParallelReads) {
+      this.waitingReads.push({
+        lng,
+        ns,
+        fcName,
+        tried,
+        wait,
+        callback
+      });
+      return;
+    }
+    this.readingCalls++;
+    const resolver = (err, data) => {
+      this.readingCalls--;
+      if (this.waitingReads.length > 0) {
+        const next = this.waitingReads.shift();
+        this.read(next.lng, next.ns, next.fcName, next.tried, next.wait, next.callback);
+      }
+      if (err && data && tried < this.maxRetries) {
+        setTimeout(() => {
+          this.read.call(this, lng, ns, fcName, tried + 1, wait * 2, callback);
+        }, wait);
+        return;
+      }
+      callback(err, data);
+    };
+    const fc = this.backend[fcName].bind(this.backend);
+    if (fc.length === 2) {
+      try {
+        const r = fc(lng, ns);
+        if (r && typeof r.then === "function") {
+          r.then((data) => resolver(null, data)).catch(resolver);
+        } else {
+          resolver(null, r);
+        }
+      } catch (err) {
+        resolver(err);
+      }
+      return;
+    }
+    return fc(lng, ns, resolver);
+  }
+  prepareLoading(languages, namespaces, options = {}, callback) {
+    if (!this.backend) {
+      this.logger.warn("No backend was added via i18next.use. Will not load resources.");
+      return callback && callback();
+    }
+    if (isString(languages)) languages = this.languageUtils.toResolveHierarchy(languages);
+    if (isString(namespaces)) namespaces = [namespaces];
+    const toLoad = this.queueLoad(languages, namespaces, options, callback);
+    if (!toLoad.toLoad.length) {
+      if (!toLoad.pending.length) callback();
+      return null;
+    }
+    toLoad.toLoad.forEach((name) => {
+      this.loadOne(name);
+    });
+  }
+  load(languages, namespaces, callback) {
+    this.prepareLoading(languages, namespaces, {}, callback);
+  }
+  reload(languages, namespaces, callback) {
+    this.prepareLoading(languages, namespaces, {
+      reload: true
+    }, callback);
+  }
+  loadOne(name, prefix = "") {
+    const s = name.split("|");
+    const lng = s[0];
+    const ns = s[1];
+    this.read(lng, ns, "read", void 0, void 0, (err, data) => {
+      if (err) this.logger.warn(`${prefix}loading namespace ${ns} for language ${lng} failed`, err);
+      if (!err && data) this.logger.log(`${prefix}loaded namespace ${ns} for language ${lng}`, data);
+      this.loaded(name, err, data);
+    });
+  }
+  saveMissing(languages, namespace, key, fallbackValue, isUpdate, options = {}, clb = () => {
+  }) {
+    if (this.services?.utils?.hasLoadedNamespace && !this.services?.utils?.hasLoadedNamespace(namespace)) {
+      this.logger.warn(`did not save key "${key}" as the namespace "${namespace}" was not yet loaded`, "This means something IS WRONG in your setup. You access the t function before i18next.init / i18next.loadNamespace / i18next.changeLanguage was done. Wait for the callback or Promise to resolve before accessing it!!!");
+      return;
+    }
+    if (key === void 0 || key === null || key === "") return;
+    if (this.backend?.create) {
+      const opts = {
+        ...options,
+        isUpdate
+      };
+      const fc = this.backend.create.bind(this.backend);
+      if (fc.length < 6) {
+        try {
+          let r;
+          if (fc.length === 5) {
+            r = fc(languages, namespace, key, fallbackValue, opts);
+          } else {
+            r = fc(languages, namespace, key, fallbackValue);
+          }
+          if (r && typeof r.then === "function") {
+            r.then((data) => clb(null, data)).catch(clb);
+          } else {
+            clb(null, r);
+          }
+        } catch (err) {
+          clb(err);
+        }
+      } else {
+        fc(languages, namespace, key, fallbackValue, clb, opts);
+      }
+    }
+    if (!languages || !languages[0]) return;
+    this.store.addResource(languages[0], namespace, key, fallbackValue);
+  }
+};
+var get = () => ({
+  debug: false,
+  initAsync: true,
+  ns: ["translation"],
+  defaultNS: ["translation"],
+  fallbackLng: ["dev"],
+  fallbackNS: false,
+  supportedLngs: false,
+  nonExplicitSupportedLngs: false,
+  load: "all",
+  preload: false,
+  simplifyPluralSuffix: true,
+  keySeparator: ".",
+  nsSeparator: ":",
+  pluralSeparator: "_",
+  contextSeparator: "_",
+  partialBundledLanguages: false,
+  saveMissing: false,
+  updateMissing: false,
+  saveMissingTo: "fallback",
+  saveMissingPlurals: true,
+  missingKeyHandler: false,
+  missingInterpolationHandler: false,
+  postProcess: false,
+  postProcessPassResolved: false,
+  returnNull: false,
+  returnEmptyString: true,
+  returnObjects: false,
+  joinArrays: false,
+  returnedObjectHandler: false,
+  parseMissingKeyHandler: false,
+  appendNamespaceToMissingKey: false,
+  appendNamespaceToCIMode: false,
+  overloadTranslationOptionHandler: (args) => {
+    let ret = {};
+    if (typeof args[1] === "object") ret = args[1];
+    if (isString(args[1])) ret.defaultValue = args[1];
+    if (isString(args[2])) ret.tDescription = args[2];
+    if (typeof args[2] === "object" || typeof args[3] === "object") {
+      const options = args[3] || args[2];
+      Object.keys(options).forEach((key) => {
+        ret[key] = options[key];
+      });
+    }
+    return ret;
+  },
+  interpolation: {
+    escapeValue: true,
+    format: (value) => value,
+    prefix: "{{",
+    suffix: "}}",
+    formatSeparator: ",",
+    unescapePrefix: "-",
+    nestingPrefix: "$t(",
+    nestingSuffix: ")",
+    nestingOptionsSeparator: ",",
+    maxReplaces: 1e3,
+    skipOnVariables: true
+  },
+  cacheInBuiltFormats: true
+});
+var transformOptions = (options) => {
+  if (isString(options.ns)) options.ns = [options.ns];
+  if (isString(options.fallbackLng)) options.fallbackLng = [options.fallbackLng];
+  if (isString(options.fallbackNS)) options.fallbackNS = [options.fallbackNS];
+  if (options.supportedLngs?.indexOf?.("cimode") < 0) {
+    options.supportedLngs = options.supportedLngs.concat(["cimode"]);
+  }
+  if (typeof options.initImmediate === "boolean") options.initAsync = options.initImmediate;
+  return options;
+};
+var noop = () => {
+};
+var bindMemberFunctions = (inst) => {
+  const mems = Object.getOwnPropertyNames(Object.getPrototypeOf(inst));
+  mems.forEach((mem) => {
+    if (typeof inst[mem] === "function") {
+      inst[mem] = inst[mem].bind(inst);
+    }
+  });
+};
+var SUPPORT_NOTICE_KEY = "__i18next_supportNoticeShown";
+var getSupportNoticeShown = () => typeof globalThis !== "undefined" && !!globalThis[SUPPORT_NOTICE_KEY];
+var setSupportNoticeShown = () => {
+  if (typeof globalThis !== "undefined") globalThis[SUPPORT_NOTICE_KEY] = true;
+};
+var usesLocize = (inst) => {
+  if (inst?.modules?.backend?.name?.indexOf("Locize") > 0) return true;
+  if (inst?.modules?.backend?.constructor?.name?.indexOf("Locize") > 0) return true;
+  if (inst?.options?.backend?.backends) {
+    if (inst.options.backend.backends.some((b) => b?.name?.indexOf("Locize") > 0 || b?.constructor?.name?.indexOf("Locize") > 0)) return true;
+  }
+  if (inst?.options?.backend?.projectId) return true;
+  if (inst?.options?.backend?.backendOptions) {
+    if (inst.options.backend.backendOptions.some((b) => b?.projectId)) return true;
+  }
+  return false;
+};
+var I18n = class _I18n extends EventEmitter {
+  constructor(options = {}, callback) {
+    super();
+    this.options = transformOptions(options);
+    this.services = {};
+    this.logger = baseLogger;
+    this.modules = {
+      external: []
+    };
+    bindMemberFunctions(this);
+    if (callback && !this.isInitialized && !options.isClone) {
+      if (!this.options.initAsync) {
+        this.init(options, callback);
+        return this;
+      }
+      setTimeout(() => {
+        this.init(options, callback);
+      }, 0);
+    }
+  }
+  init(options = {}, callback) {
+    this.isInitializing = true;
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    }
+    if (options.defaultNS == null && options.ns) {
+      if (isString(options.ns)) {
+        options.defaultNS = options.ns;
+      } else if (options.ns.indexOf("translation") < 0) {
+        options.defaultNS = options.ns[0];
+      }
+    }
+    const defOpts = get();
+    this.options = {
+      ...defOpts,
+      ...this.options,
+      ...transformOptions(options)
+    };
+    this.options.interpolation = {
+      ...defOpts.interpolation,
+      ...this.options.interpolation
+    };
+    if (options.keySeparator !== void 0) {
+      this.options.userDefinedKeySeparator = options.keySeparator;
+    }
+    if (options.nsSeparator !== void 0) {
+      this.options.userDefinedNsSeparator = options.nsSeparator;
+    }
+    if (typeof this.options.overloadTranslationOptionHandler !== "function") {
+      this.options.overloadTranslationOptionHandler = defOpts.overloadTranslationOptionHandler;
+    }
+    if (this.options.showSupportNotice !== false && !usesLocize(this) && !getSupportNoticeShown()) {
+      if (typeof console !== "undefined" && typeof console.info !== "undefined") console.info("\u{1F310} i18next is made possible by our own product, Locize \u2014 consider powering your project with managed localization (AI, CDN, integrations): https://locize.com \u{1F499}");
+      setSupportNoticeShown();
+    }
+    const createClassOnDemand = (ClassOrObject) => {
+      if (!ClassOrObject) return null;
+      if (typeof ClassOrObject === "function") return new ClassOrObject();
+      return ClassOrObject;
+    };
+    if (!this.options.isClone) {
+      if (this.modules.logger) {
+        baseLogger.init(createClassOnDemand(this.modules.logger), this.options);
+      } else {
+        baseLogger.init(null, this.options);
+      }
+      let formatter;
+      if (this.modules.formatter) {
+        formatter = this.modules.formatter;
+      } else {
+        formatter = Formatter;
+      }
+      const lu = new LanguageUtil(this.options);
+      this.store = new ResourceStore(this.options.resources, this.options);
+      const s = this.services;
+      s.logger = baseLogger;
+      s.resourceStore = this.store;
+      s.languageUtils = lu;
+      s.pluralResolver = new PluralResolver(lu, {
+        prepend: this.options.pluralSeparator,
+        simplifyPluralSuffix: this.options.simplifyPluralSuffix
+      });
+      const usingLegacyFormatFunction = this.options.interpolation.format && this.options.interpolation.format !== defOpts.interpolation.format;
+      if (usingLegacyFormatFunction) {
+        this.logger.deprecate(`init: you are still using the legacy format function, please use the new approach: https://www.i18next.com/translation-function/formatting`);
+      }
+      if (formatter && (!this.options.interpolation.format || this.options.interpolation.format === defOpts.interpolation.format)) {
+        s.formatter = createClassOnDemand(formatter);
+        if (s.formatter.init) s.formatter.init(s, this.options);
+        this.options.interpolation.format = s.formatter.format.bind(s.formatter);
+      }
+      s.interpolator = new Interpolator(this.options);
+      s.utils = {
+        hasLoadedNamespace: this.hasLoadedNamespace.bind(this)
+      };
+      s.backendConnector = new Connector(createClassOnDemand(this.modules.backend), s.resourceStore, s, this.options);
+      s.backendConnector.on("*", (event, ...args) => {
+        this.emit(event, ...args);
+      });
+      if (this.modules.languageDetector) {
+        s.languageDetector = createClassOnDemand(this.modules.languageDetector);
+        if (s.languageDetector.init) s.languageDetector.init(s, this.options.detection, this.options);
+      }
+      if (this.modules.i18nFormat) {
+        s.i18nFormat = createClassOnDemand(this.modules.i18nFormat);
+        if (s.i18nFormat.init) s.i18nFormat.init(this);
+      }
+      this.translator = new Translator(this.services, this.options);
+      this.translator.on("*", (event, ...args) => {
+        this.emit(event, ...args);
+      });
+      this.modules.external.forEach((m) => {
+        if (m.init) m.init(this);
+      });
+    }
+    this.format = this.options.interpolation.format;
+    if (!callback) callback = noop;
+    if (this.options.fallbackLng && !this.services.languageDetector && !this.options.lng) {
+      const codes = this.services.languageUtils.getFallbackCodes(this.options.fallbackLng);
+      if (codes.length > 0 && codes[0] !== "dev") this.options.lng = codes[0];
+    }
+    if (!this.services.languageDetector && !this.options.lng) {
+      this.logger.warn("init: no languageDetector is used and no lng is defined");
+    }
+    const storeApi = ["getResource", "hasResourceBundle", "getResourceBundle", "getDataByLanguage"];
+    storeApi.forEach((fcName) => {
+      this[fcName] = (...args) => this.store[fcName](...args);
+    });
+    const storeApiChained = ["addResource", "addResources", "addResourceBundle", "removeResourceBundle"];
+    storeApiChained.forEach((fcName) => {
+      this[fcName] = (...args) => {
+        this.store[fcName](...args);
+        return this;
+      };
+    });
+    const deferred = defer();
+    const load = () => {
+      const finish = (err, t2) => {
+        this.isInitializing = false;
+        if (this.isInitialized && !this.initializedStoreOnce) this.logger.warn("init: i18next is already initialized. You should call init just once!");
+        this.isInitialized = true;
+        if (!this.options.isClone) this.logger.log("initialized", this.options);
+        this.emit("initialized", this.options);
+        deferred.resolve(t2);
+        callback(err, t2);
+      };
+      if (this.languages && !this.isInitialized) return finish(null, this.t.bind(this));
+      this.changeLanguage(this.options.lng, finish);
+    };
+    if (this.options.resources || !this.options.initAsync) {
+      load();
+    } else {
+      setTimeout(load, 0);
+    }
+    return deferred;
+  }
+  loadResources(language, callback = noop) {
+    let usedCallback = callback;
+    const usedLng = isString(language) ? language : this.language;
+    if (typeof language === "function") usedCallback = language;
+    if (!this.options.resources || this.options.partialBundledLanguages) {
+      if (usedLng?.toLowerCase() === "cimode" && (!this.options.preload || this.options.preload.length === 0)) return usedCallback();
+      const toLoad = [];
+      const append = (lng) => {
+        if (!lng) return;
+        if (lng === "cimode") return;
+        const lngs = this.services.languageUtils.toResolveHierarchy(lng);
+        lngs.forEach((l) => {
+          if (l === "cimode") return;
+          if (toLoad.indexOf(l) < 0) toLoad.push(l);
+        });
+      };
+      if (!usedLng) {
+        const fallbacks = this.services.languageUtils.getFallbackCodes(this.options.fallbackLng);
+        fallbacks.forEach((l) => append(l));
+      } else {
+        append(usedLng);
+      }
+      this.options.preload?.forEach?.((l) => append(l));
+      this.services.backendConnector.load(toLoad, this.options.ns, (e) => {
+        if (!e && !this.resolvedLanguage && this.language) this.setResolvedLanguage(this.language);
+        usedCallback(e);
+      });
+    } else {
+      usedCallback(null);
+    }
+  }
+  reloadResources(lngs, ns, callback) {
+    const deferred = defer();
+    if (typeof lngs === "function") {
+      callback = lngs;
+      lngs = void 0;
+    }
+    if (typeof ns === "function") {
+      callback = ns;
+      ns = void 0;
+    }
+    if (!lngs) lngs = this.languages;
+    if (!ns) ns = this.options.ns;
+    if (!callback) callback = noop;
+    this.services.backendConnector.reload(lngs, ns, (err) => {
+      deferred.resolve();
+      callback(err);
+    });
+    return deferred;
+  }
+  use(module) {
+    if (!module) throw new Error("You are passing an undefined module! Please check the object you are passing to i18next.use()");
+    if (!module.type) throw new Error("You are passing a wrong module! Please check the object you are passing to i18next.use()");
+    if (module.type === "backend") {
+      this.modules.backend = module;
+    }
+    if (module.type === "logger" || module.log && module.warn && module.error) {
+      this.modules.logger = module;
+    }
+    if (module.type === "languageDetector") {
+      this.modules.languageDetector = module;
+    }
+    if (module.type === "i18nFormat") {
+      this.modules.i18nFormat = module;
+    }
+    if (module.type === "postProcessor") {
+      postProcessor.addPostProcessor(module);
+    }
+    if (module.type === "formatter") {
+      this.modules.formatter = module;
+    }
+    if (module.type === "3rdParty") {
+      this.modules.external.push(module);
+    }
+    return this;
+  }
+  setResolvedLanguage(l) {
+    if (!l || !this.languages) return;
+    if (["cimode", "dev"].indexOf(l) > -1) return;
+    for (let li = 0; li < this.languages.length; li++) {
+      const lngInLngs = this.languages[li];
+      if (["cimode", "dev"].indexOf(lngInLngs) > -1) continue;
+      if (this.store.hasLanguageSomeTranslations(lngInLngs)) {
+        this.resolvedLanguage = lngInLngs;
+        break;
+      }
+    }
+    if (!this.resolvedLanguage && this.languages.indexOf(l) < 0 && this.store.hasLanguageSomeTranslations(l)) {
+      this.resolvedLanguage = l;
+      this.languages.unshift(l);
+    }
+  }
+  changeLanguage(lng, callback) {
+    this.isLanguageChangingTo = lng;
+    const deferred = defer();
+    this.emit("languageChanging", lng);
+    const setLngProps = (l) => {
+      this.language = l;
+      this.languages = this.services.languageUtils.toResolveHierarchy(l);
+      this.resolvedLanguage = void 0;
+      this.setResolvedLanguage(l);
+    };
+    const done = (err, l) => {
+      if (l) {
+        if (this.isLanguageChangingTo === lng) {
+          setLngProps(l);
+          this.translator.changeLanguage(l);
+          this.isLanguageChangingTo = void 0;
+          this.emit("languageChanged", l);
+          this.logger.log("languageChanged", l);
+        }
+      } else {
+        this.isLanguageChangingTo = void 0;
+      }
+      deferred.resolve((...args) => this.t(...args));
+      if (callback) callback(err, (...args) => this.t(...args));
+    };
+    const setLng = (lngs) => {
+      if (!lng && !lngs && this.services.languageDetector) lngs = [];
+      const fl = isString(lngs) ? lngs : lngs && lngs[0];
+      const l = this.store.hasLanguageSomeTranslations(fl) ? fl : this.services.languageUtils.getBestMatchFromCodes(isString(lngs) ? [lngs] : lngs);
+      if (l) {
+        if (!this.language) {
+          setLngProps(l);
+        }
+        if (!this.translator.language) this.translator.changeLanguage(l);
+        this.services.languageDetector?.cacheUserLanguage?.(l);
+      }
+      this.loadResources(l, (err) => {
+        done(err, l);
+      });
+    };
+    if (!lng && this.services.languageDetector && !this.services.languageDetector.async) {
+      setLng(this.services.languageDetector.detect());
+    } else if (!lng && this.services.languageDetector && this.services.languageDetector.async) {
+      if (this.services.languageDetector.detect.length === 0) {
+        this.services.languageDetector.detect().then(setLng);
+      } else {
+        this.services.languageDetector.detect(setLng);
+      }
+    } else {
+      setLng(lng);
+    }
+    return deferred;
+  }
+  getFixedT(lng, ns, keyPrefix) {
+    const fixedT = (key, opts, ...rest) => {
+      let o;
+      if (typeof opts !== "object") {
+        o = this.options.overloadTranslationOptionHandler([key, opts].concat(rest));
+      } else {
+        o = {
+          ...opts
+        };
+      }
+      o.lng = o.lng || fixedT.lng;
+      o.lngs = o.lngs || fixedT.lngs;
+      o.ns = o.ns || fixedT.ns;
+      if (o.keyPrefix !== "") o.keyPrefix = o.keyPrefix || keyPrefix || fixedT.keyPrefix;
+      const keySeparator = this.options.keySeparator || ".";
+      let resultKey;
+      if (o.keyPrefix && Array.isArray(key)) {
+        resultKey = key.map((k) => {
+          if (typeof k === "function") k = keysFromSelector(k, {
+            ...this.options,
+            ...opts
+          });
+          return `${o.keyPrefix}${keySeparator}${k}`;
+        });
+      } else {
+        if (typeof key === "function") key = keysFromSelector(key, {
+          ...this.options,
+          ...opts
+        });
+        resultKey = o.keyPrefix ? `${o.keyPrefix}${keySeparator}${key}` : key;
+      }
+      return this.t(resultKey, o);
+    };
+    if (isString(lng)) {
+      fixedT.lng = lng;
+    } else {
+      fixedT.lngs = lng;
+    }
+    fixedT.ns = ns;
+    fixedT.keyPrefix = keyPrefix;
+    return fixedT;
+  }
+  t(...args) {
+    return this.translator?.translate(...args);
+  }
+  exists(...args) {
+    return this.translator?.exists(...args);
+  }
+  setDefaultNamespace(ns) {
+    this.options.defaultNS = ns;
+  }
+  hasLoadedNamespace(ns, options = {}) {
+    if (!this.isInitialized) {
+      this.logger.warn("hasLoadedNamespace: i18next was not initialized", this.languages);
+      return false;
+    }
+    if (!this.languages || !this.languages.length) {
+      this.logger.warn("hasLoadedNamespace: i18n.languages were undefined or empty", this.languages);
+      return false;
+    }
+    const lng = options.lng || this.resolvedLanguage || this.languages[0];
+    const fallbackLng = this.options ? this.options.fallbackLng : false;
+    const lastLng = this.languages[this.languages.length - 1];
+    if (lng.toLowerCase() === "cimode") return true;
+    const loadNotPending = (l, n) => {
+      const loadState = this.services.backendConnector.state[`${l}|${n}`];
+      return loadState === -1 || loadState === 0 || loadState === 2;
+    };
+    if (options.precheck) {
+      const preResult = options.precheck(this, loadNotPending);
+      if (preResult !== void 0) return preResult;
+    }
+    if (this.hasResourceBundle(lng, ns)) return true;
+    if (!this.services.backendConnector.backend || this.options.resources && !this.options.partialBundledLanguages) return true;
+    if (loadNotPending(lng, ns) && (!fallbackLng || loadNotPending(lastLng, ns))) return true;
+    return false;
+  }
+  loadNamespaces(ns, callback) {
+    const deferred = defer();
+    if (!this.options.ns) {
+      if (callback) callback();
+      return Promise.resolve();
+    }
+    if (isString(ns)) ns = [ns];
+    ns.forEach((n) => {
+      if (this.options.ns.indexOf(n) < 0) this.options.ns.push(n);
+    });
+    this.loadResources((err) => {
+      deferred.resolve();
+      if (callback) callback(err);
+    });
+    return deferred;
+  }
+  loadLanguages(lngs, callback) {
+    const deferred = defer();
+    if (isString(lngs)) lngs = [lngs];
+    const preloaded = this.options.preload || [];
+    const newLngs = lngs.filter((lng) => preloaded.indexOf(lng) < 0 && this.services.languageUtils.isSupportedCode(lng));
+    if (!newLngs.length) {
+      if (callback) callback();
+      return Promise.resolve();
+    }
+    this.options.preload = preloaded.concat(newLngs);
+    this.loadResources((err) => {
+      deferred.resolve();
+      if (callback) callback(err);
+    });
+    return deferred;
+  }
+  dir(lng) {
+    if (!lng) lng = this.resolvedLanguage || (this.languages?.length > 0 ? this.languages[0] : this.language);
+    if (!lng) return "rtl";
+    try {
+      const l = new Intl.Locale(lng);
+      if (l && l.getTextInfo) {
+        const ti = l.getTextInfo();
+        if (ti && ti.direction) return ti.direction;
+      }
+    } catch (e) {
+    }
+    const rtlLngs = ["ar", "shu", "sqr", "ssh", "xaa", "yhd", "yud", "aao", "abh", "abv", "acm", "acq", "acw", "acx", "acy", "adf", "ads", "aeb", "aec", "afb", "ajp", "apc", "apd", "arb", "arq", "ars", "ary", "arz", "auz", "avl", "ayh", "ayl", "ayn", "ayp", "bbz", "pga", "he", "iw", "ps", "pbt", "pbu", "pst", "prp", "prd", "ug", "ur", "ydd", "yds", "yih", "ji", "yi", "hbo", "men", "xmn", "fa", "jpr", "peo", "pes", "prs", "dv", "sam", "ckb"];
+    const languageUtils = this.services?.languageUtils || new LanguageUtil(get());
+    if (lng.toLowerCase().indexOf("-latn") > 1) return "ltr";
+    return rtlLngs.indexOf(languageUtils.getLanguagePartFromCode(lng)) > -1 || lng.toLowerCase().indexOf("-arab") > 1 ? "rtl" : "ltr";
+  }
+  static createInstance(options = {}, callback) {
+    const instance2 = new _I18n(options, callback);
+    instance2.createInstance = _I18n.createInstance;
+    return instance2;
+  }
+  cloneInstance(options = {}, callback = noop) {
+    const forkResourceStore = options.forkResourceStore;
+    if (forkResourceStore) delete options.forkResourceStore;
+    const mergedOptions = {
+      ...this.options,
+      ...options,
+      ...{
+        isClone: true
+      }
+    };
+    const clone = new _I18n(mergedOptions);
+    if (options.debug !== void 0 || options.prefix !== void 0) {
+      clone.logger = clone.logger.clone(options);
+    }
+    const membersToCopy = ["store", "services", "language"];
+    membersToCopy.forEach((m) => {
+      clone[m] = this[m];
+    });
+    clone.services = {
+      ...this.services
+    };
+    clone.services.utils = {
+      hasLoadedNamespace: clone.hasLoadedNamespace.bind(clone)
+    };
+    if (forkResourceStore) {
+      const clonedData = Object.keys(this.store.data).reduce((prev, l) => {
+        prev[l] = {
+          ...this.store.data[l]
+        };
+        prev[l] = Object.keys(prev[l]).reduce((acc, n) => {
+          acc[n] = {
+            ...prev[l][n]
+          };
+          return acc;
+        }, prev[l]);
+        return prev;
+      }, {});
+      clone.store = new ResourceStore(clonedData, mergedOptions);
+      clone.services.resourceStore = clone.store;
+    }
+    if (options.interpolation) {
+      const defOpts = get();
+      const mergedInterpolation = {
+        ...defOpts.interpolation,
+        ...this.options.interpolation,
+        ...options.interpolation
+      };
+      const mergedForInterpolator = {
+        ...mergedOptions,
+        interpolation: mergedInterpolation
+      };
+      clone.services.interpolator = new Interpolator(mergedForInterpolator);
+    }
+    clone.translator = new Translator(clone.services, mergedOptions);
+    clone.translator.on("*", (event, ...args) => {
+      clone.emit(event, ...args);
+    });
+    clone.init(mergedOptions, callback);
+    clone.translator.options = mergedOptions;
+    clone.translator.backendConnector.services.utils = {
+      hasLoadedNamespace: clone.hasLoadedNamespace.bind(clone)
+    };
+    return clone;
+  }
+  toJSON() {
+    return {
+      options: this.options,
+      store: this.store,
+      language: this.language,
+      languages: this.languages,
+      resolvedLanguage: this.resolvedLanguage
+    };
+  }
+};
+var instance = I18n.createInstance();
+var createInstance = instance.createInstance;
+var dir = instance.dir;
+var init = instance.init;
+var loadResources = instance.loadResources;
+var reloadResources = instance.reloadResources;
+var use = instance.use;
+var changeLanguage = instance.changeLanguage;
+var getFixedT = instance.getFixedT;
+var t = instance.t;
+var exists = instance.exists;
+var setDefaultNamespace = instance.setDefaultNamespace;
+var hasLoadedNamespace = instance.hasLoadedNamespace;
+var loadNamespaces = instance.loadNamespaces;
+var loadLanguages = instance.loadLanguages;
+
+// ../../packages/core/src/i18n/locales/zh/common.json
+var common_default = {
+  app: { name: "JoWork" },
+  save: "\u4FDD\u5B58",
+  cancel: "\u53D6\u6D88",
+  create: "\u521B\u5EFA",
+  update: "\u66F4\u65B0",
+  delete: "\u5220\u9664",
+  edit: "\u7F16\u8F91",
+  close: "\u5173\u95ED",
+  confirm: "\u786E\u8BA4",
+  loading: "\u52A0\u8F7D\u4E2D...",
+  saving: "\u4FDD\u5B58\u4E2D...",
+  search: "\u641C\u7D22",
+  filter: "\u7B5B\u9009",
+  noResults: "\u65E0\u7ED3\u679C",
+  retry: "\u91CD\u8BD5",
+  back: "\u8FD4\u56DE",
+  next: "\u4E0B\u4E00\u6B65",
+  done: "\u5B8C\u6210",
+  enable: "\u542F\u7528",
+  disable: "\u7981\u7528",
+  personal: "\u4E2A\u4EBA",
+  teamLabel: "\u56E2\u961F",
+  online: "\u5728\u7EBF",
+  offline: "\u79BB\u7EBF",
+  syncing: "\u540C\u6B65\u4E2D",
+  syncComplete: "\u540C\u6B65\u5B8C\u6210",
+  version: "\u7248\u672C",
+  skipToMainContent: "\u8DF3\u8F6C\u5230\u4E3B\u8981\u5185\u5BB9",
+  contextConnectors: "\u8FDE\u63A5\u5668",
+  contextNoConnectors: "\u6682\u65E0\u6D3B\u8DC3\u8FDE\u63A5\u5668",
+  contextInactive: "\u672A\u6FC0\u6D3B",
+  contextPinnedMemories: "\u7F6E\u9876\u8BB0\u5FC6",
+  contextNoMemories: "\u6682\u65E0\u7F6E\u9876\u8BB0\u5FC6",
+  contextRecent: "\u6700\u8FD1",
+  teamMode: "\u56E2\u961F: {{name}}",
+  somethingWentWrong: "\u51FA\u4E86\u70B9\u95EE\u9898",
+  unexpectedError: "\u53D1\u751F\u4E86\u610F\u5916\u9519\u8BEF\u3002",
+  tryAgain: "\u91CD\u8BD5",
+  featureError: "{{name}} \u51FA\u9519",
+  dismissNotification: "\u5173\u95ED\u901A\u77E5",
+  menuFile: "\u6587\u4EF6",
+  menuView: "\u89C6\u56FE",
+  trayShow: "\u663E\u793A JoWork",
+  trayQuickChat: "\u5FEB\u6377\u63D0\u95EE",
+  trayQuit: "\u9000\u51FA",
+  goHome: "\u8FD4\u56DE\u9996\u9875",
+  searchPlaceholder: "\u8F93\u5165\u5173\u952E\u8BCD\u641C\u7D22...",
+  searching: "\u641C\u7D22\u4E2D...",
+  noResultsFound: "\u672A\u627E\u5230\u7ED3\u679C",
+  pages: "\u9875\u9762",
+  conversations: "\u5BF9\u8BDD",
+  messages: "\u6D88\u606F",
+  confirmDelete: "\u786E\u8BA4\u5220\u9664",
+  deleteWarning: "\u6B64\u64CD\u4F5C\u4E0D\u53EF\u64A4\u9500\u3002",
+  savedSuccessfully: "\u4FDD\u5B58\u6210\u529F",
+  deletedSuccessfully: "\u5220\u9664\u6210\u529F",
+  operationFailed: "\u64CD\u4F5C\u5931\u8D25",
+  connectedSuccessfully: "\u8FDE\u63A5\u6210\u529F",
+  disconnectedSuccessfully: "\u5DF2\u65AD\u5F00\u8FDE\u63A5",
+  installedSuccessfully: "\u5B89\u88C5\u6210\u529F",
+  installFailed: "\u5B89\u88C5\u5931\u8D25",
+  copyFailed: "\u590D\u5236\u5931\u8D25",
+  settingsSaved: "\u8BBE\u7F6E\u5DF2\u4FDD\u5B58",
+  v2: "v2",
+  localFirst: "\u672C\u5730\u4F18\u5148",
+  detected: "\u5DF2\u68C0\u6D4B\u5230",
+  notDetected: "\u672A\u68C0\u6D4B\u5230",
+  copy: "\u590D\u5236",
+  copied: "\u5DF2\u590D\u5236\uFF01",
+  error: "\u53D1\u751F\u4E86\u9519\u8BEF"
+};
+
+// ../../packages/core/src/i18n/locales/zh/sidebar.json
+var sidebar_default = {
+  conversation: "AI \u52A9\u624B",
+  dashboard: "\u4EEA\u8868\u76D8",
+  connectors: "\u8FDE\u63A5\u5668",
+  memories: "\u8BB0\u5FC6",
+  skills: "\u6280\u80FD",
+  workstyle: "\u5DE5\u4F5C\u98CE\u683C",
+  scheduler: "\u5B9A\u65F6\u4EFB\u52A1",
+  notifications: "\u901A\u77E5",
+  terminal: "\u7EC8\u7AEF",
+  settings: "\u8BBE\u7F6E",
+  billing: "\u8BA1\u8D39",
+  personal: "\u4E2A\u4EBA\u7248",
+  team: "\u56E2\u961F\u7248",
+  search: "\u641C\u7D22",
+  hideSidebar: "\u9690\u85CF\u4FA7\u8FB9\u680F",
+  showSidebar: "\u663E\u793A\u4FA7\u8FB9\u680F",
+  hidePanel: "\u9690\u85CF\u9762\u677F",
+  showPanel: "\u663E\u793A\u9762\u677F",
+  hideContext: "\u9690\u85CF\u4E0A\u4E0B\u6587",
+  showContext: "\u663E\u793A\u4E0A\u4E0B\u6587",
+  collapse: "\u6536\u8D77",
+  expand: "\u5C55\u5F00",
+  expandNav: "\u5C55\u5F00\u5BFC\u822A",
+  collapseNav: "\u6536\u8D77\u5BFC\u822A",
+  credits: "\u989D\u5EA6",
+  newConversation: "\u53D1\u8D77\u65B0\u5BF9\u8BDD",
+  searchPlaceholder: "\u641C\u7D22 (\u2318K)"
+};
+
+// ../../packages/core/src/i18n/locales/zh/chat.json
+var chat_default = {
+  title: "JoWork AI \u52A9\u624B",
+  placeholder: "\u8F93\u5165\u6D88\u606F... (Enter \u53D1\u9001)",
+  send: "\u53D1\u9001",
+  stop: "\u505C\u6B62",
+  emptyTitle: "\u5F00\u59CB\u65B0\u5BF9\u8BDD",
+  emptyDescription: "\u4E0E AI \u52A9\u624B\u5BF9\u8BDD\uFF0C\u5B83\u53EF\u4EE5\u5E2E\u4F60\u7F16\u7801\u3001\u5206\u6790\u6570\u636E\u7B49\u3002",
+  noConversations: "\u8FD8\u6CA1\u6709\u5BF9\u8BDD",
+  detectingEngines: "\u6B63\u5728\u68C0\u6D4B\u5F15\u64CE...",
+  thinking: "\u601D\u8003\u4E2D...",
+  toolCall: "\u5DE5\u5177\u8C03\u7528",
+  toolResult: "\u5DE5\u5177\u7ED3\u679C",
+  toolsUsed: "\u4F7F\u7528\u4E86 {{count}} \u4E2A\u5DE5\u5177",
+  conversations: "\u5BF9\u8BDD",
+  newConversation: "\u65B0\u5BF9\u8BDD",
+  deleteConversation: "\u5220\u9664\u5BF9\u8BDD",
+  renameConversation: "\u91CD\u547D\u540D\u5BF9\u8BDD",
+  searchConversations: "\u641C\u7D22\u5BF9\u8BDD...",
+  export: "\u5BFC\u51FA",
+  exportConversation: "\u5BFC\u51FA\u5BF9\u8BDD",
+  exportMarkdown: "Markdown (.md)",
+  exportJson: "JSON (.json)",
+  loadOlder: "\u52A0\u8F7D\u66F4\u65E9\u6D88\u606F",
+  loadingOlder: "\u52A0\u8F7D\u4E2D...",
+  noMatchingConversations: "\u6CA1\u6709\u5339\u914D\u7684\u5BF9\u8BDD",
+  dropFilesHere: "\u62D6\u653E\u6587\u4EF6\u5230\u6B64\u5904...",
+  inputAriaLabel: "\u804A\u5929\u6D88\u606F\u8F93\u5165",
+  stopAriaLabel: "\u505C\u6B62 AI \u56DE\u590D",
+  sendAriaLabel: "\u53D1\u9001\u6D88\u606F",
+  actionConfirmation: "\u64CD\u4F5C\u786E\u8BA4",
+  riskLow: "\u4F4E\u98CE\u9669",
+  riskMedium: "\u4E2D\u7B49\u98CE\u9669",
+  riskHigh: "\u9AD8\u98CE\u9669",
+  alwaysAllow: "\u59CB\u7EC8\u5141\u8BB8\u6B64\u64CD\u4F5C",
+  deny: "\u62D2\u7EDD",
+  allow: "\u5141\u8BB8",
+  notInstalled: "\u672A\u5B89\u88C5",
+  engineClaudeCode: "Claude Code",
+  engineOpenClaw: "OpenClaw",
+  engineCodex: "Codex",
+  engineNemoClaw: "NemoClaw",
+  engineJoworkCloud: "JoWork \u4E91\u7AEF",
+  launcherPlaceholder: "\u5411 JoWork \u63D0\u95EE...",
+  recent: "\u6700\u8FD1",
+  launcherHint: "\u6309 Enter \u63D0\u95EE\uFF0CEsc \u5173\u95ED",
+  skillsLabel: "\u53EF\u7528\u6280\u80FD",
+  engineCrashed: "AI \u5F15\u64CE\u5D29\u6E83\uFF0C\u6B63\u5728\u91CD\u542F... (\u7B2C {{retries}} \u6B21)",
+  engineCrashFatal: "AI \u5F15\u64CE\u5728 {{max}} \u6B21\u91CD\u542F\u540E\u4ECD\u7136\u5931\u8D25\uFF0C\u8BF7\u5728\u8BBE\u7F6E\u4E2D\u5207\u6362\u5F15\u64CE\u3002",
+  engineRestartReady: "AI \u5F15\u64CE\u5DF2\u91CD\u65B0\u542F\u52A8\u3002",
+  launcherTitle: "JoWork \u5FEB\u6377\u63D0\u95EE",
+  launcherClose: "\u5173\u95ED",
+  launcherOpenMain: "\u6253\u5F00\u4E3B\u7A97\u53E3",
+  launcherModes: "\u6A21\u5F0F",
+  launcherAskAI: "AI \u95EE\u7B54",
+  launcherRunCommand: "\u6267\u884C\u547D\u4EE4",
+  launcherJumpToPage: "\u8DF3\u8F6C\u9875\u9762",
+  timeJustNow: "\u521A\u521A",
+  timeMinutesAgo: "{{count}}\u5206\u949F\u524D",
+  engineError: "\u5F15\u64CE\u9519\u8BEF",
+  retryMessage: "\u91CD\u8BD5",
+  scrollToBottom: "\u8DF3\u5230\u6700\u65B0",
+  exportSuccess: "\u5BF9\u8BDD\u5DF2\u5BFC\u51FA",
+  exportFailed: "\u5BFC\u51FA\u5931\u8D25",
+  deleteSuccess: "\u5BF9\u8BDD\u5DF2\u5220\u9664",
+  deleteConfirmTitle: "\u5220\u9664\u5BF9\u8BDD\uFF1F",
+  deleteConfirmMessage: "\u6B64\u64CD\u4F5C\u4E0D\u53EF\u64A4\u9500\u3002",
+  expand: "\u5C55\u5F00",
+  collapse: "\u6536\u8D77",
+  toolConfirmation: "\u5DE5\u5177\u786E\u8BA4",
+  renameSession: "\u91CD\u547D\u540D",
+  saveAsSkill: "\u4FDD\u5B58\u4E3A\u6280\u80FD",
+  generatingSkill: "\u751F\u6210\u4E2D\u2026",
+  skillGenerateFailed: "\u6280\u80FD\u751F\u6210\u5931\u8D25",
+  deleteConfirm: "\u5220\u9664\uFF1F",
+  paramsCount: "{{count}} \u4E2A\u53C2\u6570",
+  starterPrompt1: "\u5E2E\u6211\u89C4\u5212\u4ECA\u5929\uFF0C\u6211\u5E94\u8BE5\u5148\u505A\u4EC0\u4E48\uFF1F",
+  starterPrompt2: "\u6211\u6709\u4E2A\u7C97\u7565\u7684\u60F3\u6CD5\uFF0C\u5E2E\u6211\u68B3\u7406\u6E05\u695A\uFF0C\u53D8\u6210\u53EF\u6267\u884C\u7684\u65B9\u6848\u3002",
+  starterPrompt3: "\u4EC0\u4E48\u5728\u963B\u788D\u6211\u7684\u8FDB\u5C55\uFF1F\u5E2E\u6211\u627E\u51FA\u771F\u6B63\u7684\u74F6\u9888\u3002",
+  quotaExhaustedTitle: "\u4ECA\u65E5\u514D\u8D39\u5BF9\u8BDD\u5DF2\u7528\u5B8C",
+  quotaExhaustedDesc: "\u660E\u5929 00:00 UTC \u91CD\u7F6E\uFF0C\u6216\u5347\u7EA7 Pro \u7EE7\u7EED\u4F7F\u7528",
+  upgradePro: "\u5347\u7EA7 Pro",
+  waitUntilTomorrow: "\u7B49\u5230\u660E\u5929",
+  switchEngine: "\u5207\u6362\u5F15\u64CE",
+  showSidebar: "\u663E\u793A\u9762\u677F",
+  hideSidebar: "\u9690\u85CF\u9762\u677F"
+};
+
+// ../../packages/core/src/i18n/locales/zh/connectors.json
+var connectors_default = {
+  title: "\u8FDE\u63A5\u5668",
+  description: "\u8FDE\u63A5\u4F60\u7684\u5DE5\u5177\u548C\u6570\u636E\u6E90\u5230 JoWork\u3002",
+  connected: "\u5DF2\u8FDE\u63A5",
+  connectedCount: "{{count}} \u4E2A\u5DF2\u8FDE\u63A5",
+  all: "\u5168\u90E8",
+  available: "\u53EF\u7528\u6570\u636E\u6E90",
+  noConnected: "\u5C1A\u672A\u8FDE\u63A5\u4EFB\u4F55\u6570\u636E\u6E90\uFF0C\u4ECE\u4E0B\u65B9\u9009\u62E9\u4E00\u4E2A\u5F00\u59CB\u914D\u7F6E\u3002",
+  credentialStored: "\u51ED\u636E\u5DF2\u4FDD\u5B58",
+  needsAuth: "\u9700\u8981\u6388\u6743",
+  core: "\u6838\u5FC3\u8FDE\u63A5\u5668",
+  more: "\u66F4\u591A\u8FDE\u63A5\u5668",
+  configure: "\u914D\u7F6E",
+  connect: "\u8FDE\u63A5",
+  disconnect: "\u65AD\u5F00",
+  loading: "\u52A0\u8F7D\u8FDE\u63A5\u5668...",
+  loadingDescription: "\u6B63\u5728\u68C0\u67E5\u6570\u636E\u6E90\u72B6\u6001...",
+  tokenPlaceholder: "Access Token \u6216 API Key",
+  health: "\u5065\u5EB7\u72B6\u6001",
+  healthy: "\u6B63\u5E38",
+  unhealthy: "\u5F02\u5E38",
+  lastSync: "\u4E0A\u6B21\u540C\u6B65",
+  authorize: "\u6388\u6743",
+  revoke: "\u64A4\u9500\u6388\u6743",
+  tierBeta: "\u6D4B\u8BD5\u7248",
+  tierPlanned: "\u8BA1\u5212\u4E2D",
+  authorizeTitle: "\u6388\u6743 {{name}}",
+  authorizeDescription: "\u5C06\u6253\u5F00\u6D4F\u89C8\u5668\u7A97\u53E3\uFF0C\u6388\u6743 JoWork \u8BBF\u95EE\u4F60\u7684 {{name}} \u6570\u636E\u3002",
+  noHealthData: "\u6682\u65E0\u5065\u5EB7\u6570\u636E\u3002",
+  status: "\u72B6\u6001",
+  syncedData: "\u5DF2\u540C\u6B65\u6570\u636E",
+  noSyncedData: "\u6682\u65E0\u540C\u6B65\u6570\u636E\u3002",
+  syncLog: "\u540C\u6B65\u65E5\u5FD7",
+  noSyncActivity: "\u6682\u65E0\u540C\u6B65\u6D3B\u52A8\u3002",
+  disconnectConfirmTitle: "\u65AD\u5F00 {{name}}\uFF1F",
+  disconnectConfirmMessage: "\u5C06\u79FB\u9664\u8FDE\u63A5\u5E76\u64A4\u9500\u8BBF\u95EE\u6743\u9650\u3002",
+  authorization: "\u6388\u6743",
+  comingSoon: "\u5373\u5C06\u63A8\u51FA",
+  saveAndConnect: "\u4FDD\u5B58\u5E76\u8FDE\u63A5",
+  signIn: "\u767B\u5F55",
+  authorizing: "\u767B\u5F55\u4E2D\u2026",
+  connecting: "\u8FDE\u63A5\u4E2D\u2026",
+  cat_code: "\u4EE3\u7801",
+  cat_design: "\u8BBE\u8BA1",
+  cat_communication: "\u901A\u8BAF",
+  cat_docs: "\u6587\u6863",
+  cat_local: "\u672C\u5730",
+  cat_analytics: "\u641C\u7D22",
+  c_github_name: "GitHub",
+  c_github_desc: "\u4EE3\u7801\u4ED3\u5E93\u3001Issues\u3001Pull Requests",
+  c_gitlab_name: "GitLab",
+  c_gitlab_desc: "\u9879\u76EE\u3001\u5408\u5E76\u8BF7\u6C42\u3001Issues",
+  c_figma_name: "Figma",
+  c_figma_desc: "\u8BBE\u8BA1\u6587\u4EF6\u548C\u7EC4\u4EF6",
+  "c_local-folder_name": "\u672C\u5730\u9879\u76EE",
+  "c_local-folder_desc": "\u8BA9 Claude \u8BBF\u95EE\u672C\u5730\u6587\u4EF6\u5939",
+  c_feishu_name: "\u98DE\u4E66 \xB7 \u7EC4\u7EC7\u6570\u636E",
+  c_feishu_desc: "\u7FA4\u6D88\u606F\u3001\u7EC4\u7EC7\u6587\u6863\u3001\u65E5\u5386\uFF08\u9700\u8981 Bot App \u51ED\u8BC1\uFF09",
+  c_notion_name: "Notion",
+  c_notion_desc: "\u9875\u9762\u3001\u6570\u636E\u5E93\u3001\u5DE5\u4F5C\u533A\u77E5\u8BC6",
+  c_slack_name: "Slack",
+  c_slack_desc: "\u9891\u9053\u3001\u6D88\u606F\u3001\u56E2\u961F\u6C9F\u901A",
+  "c_brave-search_name": "\u7F51\u9875\u641C\u7D22",
+  "c_brave-search_desc": "\u901A\u8FC7 Brave Search API \u8FDB\u884C\u5B9E\u65F6\u7F51\u9875\u641C\u7D22",
+  c_posthog_name: "PostHog",
+  c_posthog_desc: "\u4EA7\u54C1\u5206\u6790\u3001\u529F\u80FD\u5F00\u5173\u3001\u4F1A\u8BDD\u5F55\u5236",
+  c_linear_name: "Linear",
+  c_linear_desc: "Issue \u7BA1\u7406\u3001\u9879\u76EE\u3001\u8FED\u4EE3\u3001\u8DEF\u7EBF\u56FE",
+  "c_feishu-personal_name": "\u98DE\u4E66 \xB7 \u4E2A\u4EBA\u6570\u636E",
+  "c_feishu-personal_desc": "\u4E2A\u4EBA\u6587\u6863\u3001\u79C1\u804A\u6D88\u606F\u3001\u65E5\u5386\u3001\u90AE\u4EF6\uFF08\u767B\u5F55 JoWork Cloud \u540E\u4E00\u952E\u6388\u6743\uFF09",
+  feishuPersonalRequiresLogin: "\u8BF7\u5148\u767B\u5F55 JoWork Cloud \u4EE5\u8FDE\u63A5\u98DE\u4E66\u4E2A\u4EBA\u6570\u636E",
+  type_local: "\u672C\u673A\u6570\u636E",
+  type_local_desc: "\u8BA9 AI \u76F4\u63A5\u8BBF\u95EE\u672C\u5730\u6587\u4EF6\u548C\u6587\u4EF6\u5939",
+  type_sync: "\u7EBF\u4E0A\u6570\u636E",
+  type_sync_desc: "\u5B9A\u65F6\u589E\u91CF\u540C\u6B65\u5230\u672C\u5730\uFF0C\u652F\u6301\u5FEB\u901F\u641C\u7D22",
+  type_mcp: "MCP \u5DE5\u5177",
+  type_mcp_desc: "\u6309\u9700\u8BF7\u6C42\uFF0C\u7528\u65F6\u83B7\u53D6\u6570\u636E",
+  addFolder: "\u6DFB\u52A0\u6587\u4EF6\u5939",
+  folderName: "\u663E\u793A\u540D\u79F0",
+  folderPath: "\u6587\u4EF6\u5939\u8DEF\u5F84",
+  removeInstance: "\u79FB\u9664",
+  removeInstanceConfirm: "\u79FB\u9664\u6B64\u6587\u4EF6\u5939\uFF1F"
+};
+
+// ../../packages/core/src/i18n/locales/zh/settings.json
+var settings_default = {
+  title: "\u8BBE\u7F6E",
+  general: "\u901A\u7528",
+  appearance: "\u5916\u89C2",
+  engines: "AI \u5F15\u64CE",
+  about: "\u5173\u4E8E",
+  themeLight: "\u6D45\u8272",
+  themeDark: "\u6DF1\u8272",
+  themeSystem: "\u8DDF\u968F\u7CFB\u7EDF",
+  language: "\u8BED\u8A00",
+  update: "\u66F4\u65B0",
+  checkUpdate: "\u68C0\u67E5\u66F4\u65B0",
+  updateAvailable: "\u6709\u65B0\u7248\u672C\u53EF\u7528",
+  updateDownloaded: "\u66F4\u65B0\u5DF2\u4E0B\u8F7D\uFF0C\u91CD\u542F\u540E\u5B89\u88C5",
+  restartToUpdate: "\u7ACB\u5373\u91CD\u542F\u66F4\u65B0",
+  upToDate: "\u5DF2\u662F\u6700\u65B0\u7248\u672C",
+  checking: "\u68C0\u67E5\u4E2D...",
+  keyboardShortcuts: "\u952E\u76D8\u5FEB\u6377\u952E",
+  shortcutHint: "\u5728 Windows/Linux \u4E0A\uFF0C\u8BF7\u7528 Ctrl \u66FF\u4EE3 Cmd\u3002",
+  shortcutNewConversation: "\u65B0\u5EFA\u5BF9\u8BDD",
+  shortcutGlobalSearch: "\u5168\u5C40\u641C\u7D22",
+  shortcutQuickLauncher: "\u5FEB\u6377\u542F\u52A8\u5668",
+  shortcutExport: "\u5BFC\u51FA\u5BF9\u8BDD",
+  shortcutSettings: "\u8BBE\u7F6E",
+  shortcutSend: "\u53D1\u9001\u6D88\u606F",
+  shortcutStop: "\u505C\u6B62 / \u5173\u95ED",
+  shortcutTerminal: "\u6253\u5F00\u7EC8\u7AEF",
+  shortcutCloseWindow: "\u5173\u95ED\u7A97\u53E3",
+  workstyleTitle: "\u5DE5\u4F5C\u98CE\u683C",
+  workstyleDescription: "\u5B9A\u4E49 AI \u5982\u4F55\u914D\u5408\u4F60\u5DE5\u4F5C\u3002\u6B64\u5185\u5BB9\u4F1A\u6CE8\u5165\u6BCF\u6B21\u5BF9\u8BDD\u3002",
+  workstylePlaceholder: "\u7528 Markdown \u7F16\u5199\u4F60\u7684\u5DE5\u4F5C\u98CE\u683C\u6307\u5357...",
+  workstyleHint: "\u652F\u6301 Markdown\u3002\u6B64\u6587\u6863\u4F1A\u4F5C\u4E3A\u4E0A\u4E0B\u6587\u6CE8\u5165\u6BCF\u6B21 AI \u5BF9\u8BDD\u3002",
+  saved: "\u5DF2\u4FDD\u5B58\uFF01",
+  workstyleTemplate: "# \u6211\u7684\u5DE5\u4F5C\u98CE\u683C\n\n## \u89D2\u8272\n[\u4F60\u7684\u804C\u4F4D\u548C\u804C\u8D23]\n\n## \u6C9F\u901A\u504F\u597D\n- \u56DE\u590D\u98CE\u683C: [\u7B80\u6D01/\u8BE6\u7EC6]\n- \u8BED\u8A00: [\u4E2D\u6587/\u82F1\u6587/\u53CC\u8BED]\n\n## \u5DE5\u4F5C\u4E60\u60EF\n[\u4F60\u7684\u65E5\u5E38\u5DE5\u4F5C\u6D41\u7A0B]\n\n## \u91CD\u8981\u89C4\u5219\n[AI \u5FC5\u987B\u9075\u5B88\u7684\u89C4\u5219]\n",
+  terminalTitle: "\u7EC8\u7AEF",
+  terminalTab: "\u7EC8\u7AEF {{n}}",
+  stylePrompt: "\u98CE\u683C\u63D0\u793A\u8BCD",
+  quickAccess: "\u5FEB\u6377\u5165\u53E3"
+};
+
+// ../../packages/core/src/i18n/locales/zh/billing.json
+var billing_default = {
+  title: "\u8BA1\u8D39",
+  credits: "\u79EF\u5206",
+  remaining: "\u5269\u4F59",
+  used: "\u672C\u5468\u671F\u5DF2\u7528",
+  wallet: "\u94B1\u5305\u4F59\u989D",
+  buyCredits: "\u8D2D\u4E70\u79EF\u5206",
+  plans: "\u65B9\u6848",
+  currentPlan: "\u5F53\u524D\u65B9\u6848",
+  upgrade: "\u5347\u7EA7",
+  manageSubscription: "\u7BA1\u7406\u8BA2\u9605",
+  signInRequired: "\u767B\u5F55\u540E\u53EF\u4F7F\u7528\u8BA1\u8D39\u548C\u4E91\u79EF\u5206\u529F\u80FD\u3002",
+  buyAmount: "\u8D2D\u4E70 {{amount}} \u79EF\u5206",
+  free: "\u514D\u8D39",
+  pro: "\u4E13\u4E1A\u7248",
+  teamPlan: "\u56E2\u961F\u7248",
+  perMonth: "/\u6708",
+  usageChart: "\u7528\u91CF\u7EDF\u8BA1",
+  dailyUsage: "\u6BCF\u65E5\u7528\u91CF\uFF087\u5929\uFF09",
+  creditsLeft: "\u5269\u4F59 {{count}}",
+  walletBalance: "+{{count}} \u94B1\u5305",
+  creditsPerMonth: "{{count}} \u79EF\u5206/\u6708",
+  downgrade: "\u964D\u7EA7",
+  dailyLimit: "\u9650\u989D\uFF1A{{limit}}/\u5929",
+  usageHistory: "\u7528\u91CF\u5386\u53F2",
+  creditOverview: "\u989D\u5EA6\u6982\u89C8"
+};
+
+// ../../packages/core/src/i18n/locales/zh/team.json
+var team_default = {
+  title: "\u56E2\u961F",
+  members: "\u6210\u5458",
+  invite: "\u9080\u8BF7\u6210\u5458",
+  createTeam: "\u521B\u5EFA\u56E2\u961F",
+  settings: "\u56E2\u961F\u8BBE\u7F6E",
+  signInRequired: "\u767B\u5F55\u540E\u53EF\u521B\u5EFA\u6216\u52A0\u5165\u56E2\u961F\u5DE5\u4F5C\u533A\u3002",
+  yourTeams: "\u4F60\u7684\u56E2\u961F",
+  switch: "\u5207\u6362",
+  owner: "\u6240\u6709\u8005",
+  admin: "\u7BA1\u7406\u5458",
+  member: "\u6210\u5458",
+  teamName: "\u56E2\u961F\u540D\u79F0",
+  memberCount: "{{count}} \u4F4D\u6210\u5458",
+  creating: "\u521B\u5EFA\u4E2D...",
+  inviteLink: "\u9080\u8BF7\u94FE\u63A5",
+  copyLink: "\u590D\u5236\u94FE\u63A5",
+  linkCopied: "\u5DF2\u590D\u5236",
+  removeMember: "\u79FB\u9664\u6210\u5458",
+  changeRole: "\u66F4\u6539\u89D2\u8272",
+  leaveTeam: "\u79BB\u5F00\u56E2\u961F",
+  inviteTitle: "\u9080\u8BF7\u56E2\u961F\u6210\u5458",
+  inviteDescription: "\u751F\u6210\u9080\u8BF7\u94FE\u63A5\u5E76\u5206\u4EAB\u7ED9\u4F60\u7684\u56E2\u961F\u6210\u5458\u3002",
+  generating: "\u751F\u6210\u4E2D...",
+  generateInviteLink: "\u751F\u6210\u9080\u8BF7\u94FE\u63A5",
+  inviteUrl: "\u9080\u8BF7\u94FE\u63A5",
+  inviteExpiry: "\u6B64\u94FE\u63A5 7 \u5929\u540E\u8FC7\u671F\u3002\u4EFB\u4F55\u4EBA\u90FD\u53EF\u4EE5\u901A\u8FC7\u6B64\u94FE\u63A5\u52A0\u5165\u56E2\u961F\u3002",
+  teamId: "\u56E2\u961F ID",
+  remove: "\u79FB\u9664",
+  createTeamDescription: "\u4E3A\u4F60\u7684\u7EC4\u7EC7\u521B\u5EFA\u4E00\u4E2A\u65B0\u7684\u534F\u4F5C\u7A7A\u95F4\u3002",
+  removeConfirmTitle: "\u79FB\u9664\u6210\u5458\uFF1F",
+  removeConfirmMessage: "\u8BE5\u6210\u5458\u5C06\u5931\u53BB\u56E2\u961F\u8D44\u6E90\u7684\u8BBF\u95EE\u6743\u9650\u3002",
+  noTeams: "\u4F60\u8FD8\u6CA1\u6709\u52A0\u5165\u4EFB\u4F55\u56E2\u961F\u3002",
+  inviteError: "\u751F\u6210\u9080\u8BF7\u94FE\u63A5\u5931\u8D25"
+};
+
+// ../../packages/core/src/i18n/locales/zh/memory.json
+var memory_default = {
+  title: "\u8BB0\u5FC6",
+  description: "AI \u8DE8\u5BF9\u8BDD\u8BB0\u4F4F\u7684\u5173\u4E8E\u4F60\u7684\u4FE1\u606F\u3002",
+  new: "\u65B0\u5EFA",
+  editMemory: "\u7F16\u8F91\u8BB0\u5FC6",
+  newMemory: "\u65B0\u5EFA\u8BB0\u5FC6",
+  titlePlaceholder: "\u8BB0\u5FC6\u6807\u9898",
+  contentPlaceholder: "\u8BB0\u5FC6\u5185\u5BB9...",
+  tagsPlaceholder: "\u6807\u7B7E\uFF08\u9017\u53F7\u5206\u9694\uFF09",
+  pinned: "\u5DF2\u7F6E\u9876",
+  allMemories: "\u6240\u6709\u8BB0\u5FC6",
+  noMemories: "\u8FD8\u6CA1\u6709\u8BB0\u5FC6\u3002",
+  noMemoriesHint: "\u624B\u52A8\u521B\u5EFA\u6216\u8BA9 AI \u4ECE\u5BF9\u8BDD\u4E2D\u5B66\u4E60\u3002",
+  pin: "\u7F6E\u9876",
+  unpin: "\u53D6\u6D88\u7F6E\u9876",
+  searchMemories: "\u641C\u7D22\u8BB0\u5FC6...",
+  sourceAuto: "\u81EA\u52A8",
+  sourceManual: "\u624B\u52A8",
+  scope: "\u8303\u56F4",
+  scopePersonal: "\u4E2A\u4EBA",
+  scopeTeam: "\u56E2\u961F",
+  deleteConfirmTitle: "\u5220\u9664\u8BB0\u5FC6\uFF1F",
+  deleteConfirmMessage: "\u6B64\u8BB0\u5FC6\u5C06\u88AB\u6C38\u4E45\u5220\u9664\u3002"
+};
+
+// ../../packages/core/src/i18n/locales/zh/skills.json
+var skills_default = {
+  title: "\u6280\u80FD",
+  description: "\u6765\u81EA\u591A\u4E2A\u6765\u6E90\u7684\u53EF\u590D\u7528\u63D0\u793A\u8BCD\u548C\u5DE5\u4F5C\u6D41\u3002",
+  filterPlaceholder: "\u7B5B\u9009\u6280\u80FD...",
+  noSkills: "\u672A\u627E\u5230\u6280\u80FD\u3002",
+  noSkillsHint: "\u6DFB\u52A0 .md \u6587\u4EF6\u5230 ~/.claude/commands/ \u6216 ~/.claude/skills/",
+  sourceClaudeCode: "Claude Code",
+  sourceJowork: "JoWork",
+  sourceOpenclaw: "OpenClaw",
+  sourceCommunity: "\u793E\u533A",
+  loading: "\u52A0\u8F7D\u6280\u80FD...",
+  run: "\u8FD0\u884C",
+  details: "\u8BE6\u60C5",
+  marketplace: "\u6280\u80FD\u5E02\u573A",
+  createSkill: "\u521B\u5EFA",
+  variableCount: "{{count}} \u4E2A\u53D8\u91CF",
+  variableCount_one: "{{count}} \u4E2A\u53D8\u91CF",
+  runSkill: "\u8FD0\u884C\u6280\u80FD",
+  running: "\u8FD0\u884C\u4E2D...",
+  selectPlaceholder: "\u9009\u62E9...",
+  createCustomSkill: "\u521B\u5EFA\u81EA\u5B9A\u4E49\u6280\u80FD",
+  skillName: "\u540D\u79F0",
+  skillTrigger: "\u89E6\u53D1\u5668",
+  skillDescription: "\u63CF\u8FF0",
+  promptTemplate: "\u63D0\u793A\u8BCD\u6A21\u677F",
+  promptPlaceholder: "\u4F7F\u7528 {{variable_name}} \u63D2\u5165\u52A8\u6001\u503C...",
+  variables: "\u53D8\u91CF",
+  addVariable: "+ \u6DFB\u52A0\u53D8\u91CF",
+  varLabel: "\u6807\u7B7E",
+  varTypeText: "\u6587\u672C",
+  varTypeMultiline: "\u591A\u884C",
+  varTypeSelect: "\u9009\u62E9",
+  varRequired: "\u5FC5\u586B",
+  saveSkill: "\u4FDD\u5B58\u6280\u80FD",
+  skillMarketplace: "\u6280\u80FD\u5E02\u573A",
+  browseSkills: "\u6D4F\u89C8\u548C\u5B89\u88C5\u793E\u533A\u6280\u80FD",
+  searchSkills: "\u641C\u7D22\u6280\u80FD...",
+  installCount: "{{count}} \u6B21\u5B89\u88C5",
+  install: "\u5B89\u88C5",
+  installed: "\u5DF2\u5B89\u88C5",
+  noSkillsMatch: "\u6CA1\u6709\u5339\u914D\u7684\u6280\u80FD\u3002",
+  skillLibrary: "\u6280\u80FD\u5E93",
+  customSkillLabel: "\u81EA\u5B9A\u4E49\u6280\u80FD",
+  fromConversation: "\u4ECE\u5BF9\u8BDD\u521B\u5EFA",
+  reviewAndSaveSkill: "\u5BA1\u67E5\u5E76\u4FDD\u5B58\u6280\u80FD",
+  skillType: "\u7C7B\u578B",
+  typeSimple: "\u7B80\u5355",
+  typeWorkflow: "\u5DE5\u4F5C\u6D41",
+  workflowSteps: "\u6B65\u9AA4",
+  addStep: "\u6DFB\u52A0\u6B65\u9AA4",
+  noStepsYet: "\u6682\u65E0\u6B65\u9AA4\uFF0C\u6DFB\u52A0\u6B65\u9AA4\u6765\u5B9A\u4E49\u5DE5\u4F5C\u6D41\u3002",
+  step: "\u6B65\u9AA4",
+  stepPromptPlaceholder: "\u6B65\u9AA4\u63D0\u793A\u8BCD\u2026",
+  outputVar: "\u8F93\u51FA\u53D8\u91CF\uFF08\u53EF\u9009\uFF09",
+  stepCondition: "\u6267\u884C\u6761\u4EF6\uFF08\u53EF\u9009\uFF09",
+  namePlaceholder: "\u6211\u7684\u6280\u80FD",
+  triggerPlaceholder: "/\u6211\u7684\u6280\u80FD",
+  varNamePlaceholder: "\u53D8\u91CF\u540D"
+};
+
+// ../../packages/core/src/i18n/locales/zh/scheduler.json
+var scheduler_default = {
+  title: "\u5B9A\u65F6\u4EFB\u52A1",
+  description: "\u81EA\u52A8\u5316\u6570\u636E\u626B\u63CF\u3001\u6280\u80FD\u6267\u884C\u548C\u901A\u77E5\u7B49\u5468\u671F\u6027\u4EFB\u52A1\u3002",
+  newTask: "\u65B0\u5EFA\u4EFB\u52A1",
+  editTask: "\u7F16\u8F91\u4EFB\u52A1",
+  namePlaceholder: "\u4EFB\u52A1\u540D\u79F0",
+  cronPlaceholder: "Cron \u8868\u8FBE\u5F0F (\u5982 0 10 * * *)",
+  cloudExecution: "\u79BB\u7EBF\u65F6\u542F\u7528\u4E91\u7AEF\u6267\u884C",
+  noTasks: "\u8FD8\u6CA1\u6709\u5B9A\u65F6\u4EFB\u52A1\u3002",
+  noTasksHint: "\u521B\u5EFA\u4E00\u4E2A\u6765\u81EA\u52A8\u5316\u4F60\u7684\u5DE5\u4F5C\u6D41\u3002",
+  enabled: "\u5DF2\u542F\u7528",
+  disabled: "\u5DF2\u7981\u7528",
+  lastRun: "\u4E0A\u6B21\u6267\u884C",
+  nextRun: "\u4E0B\u6B21\u6267\u884C",
+  history: "\u6267\u884C\u5386\u53F2",
+  typeScan: "\u626B\u63CF",
+  typeSkill: "\u6280\u80FD",
+  typeNotify: "\u901A\u77E5",
+  cloud: "\u4E91\u7AEF",
+  lastRunShort: "\u4E0A\u6B21:",
+  nextRunShort: "\u4E0B\u6B21:",
+  executionHistory: "\u6267\u884C\u5386\u53F2",
+  noExecutions: "\u6682\u65E0\u6267\u884C\u8BB0\u5F55\u3002",
+  timezonePlaceholder: "\u65F6\u533A (\u5982 Asia/Shanghai)",
+  presets: "\u9884\u8BBE",
+  hidePresets: "\u6536\u8D77",
+  customSchedule: "\u81EA\u5B9A\u4E49\u8C03\u5EA6",
+  everyMinute: "\u6BCF\u5206\u949F",
+  presetEveryHour: "\u6BCF\u5C0F\u65F6",
+  presetEvery2Hours: "\u6BCF 2 \u5C0F\u65F6",
+  presetMorning9: "\u6BCF\u5929\u65E9\u4E0A 9 \u70B9",
+  presetMorning10: "\u6BCF\u5929\u65E9\u4E0A 10 \u70B9",
+  presetEvening6: "\u6BCF\u5929\u665A\u4E0A 6 \u70B9",
+  presetTwiceDaily: "\u6BCF\u5929\u4E24\u6B21 (9am, 6pm)",
+  presetWeekdays9: "\u5DE5\u4F5C\u65E5 9 \u70B9",
+  presetMonday9: "\u6BCF\u5468\u4E00 9 \u70B9",
+  presetEvery15Min: "\u6BCF 15 \u5206\u949F",
+  presetEvery30Min: "\u6BCF 30 \u5206\u949F",
+  descEveryHour: "\u6BCF\u5C0F\u65F6\u6574\u70B9",
+  descEvery2Hours: "\u6BCF 2 \u5C0F\u65F6\u6574\u70B9",
+  descMorning9: "\u6BCF\u5929 09:00",
+  descMorning10: "\u6BCF\u5929 10:00",
+  descEvening6: "\u6BCF\u5929 18:00",
+  descTwiceDaily: "09:00 \u548C 18:00",
+  descWeekdays9: "\u5468\u4E00\u81F3\u5468\u4E94 09:00",
+  descMonday9: "\u6BCF\u5468\u4E00 09:00",
+  descEvery15Min: "\u6BCF\u5C0F\u65F6 :00, :15, :30, :45",
+  descEvery30Min: "\u6BCF\u5C0F\u65F6 :00 \u548C :30",
+  cronMin: "\u5206",
+  cronHour: "\u65F6",
+  cronDay: "\u65E5",
+  cronMonth: "\u6708",
+  cronDow: "\u5468",
+  daySun: "\u65E5",
+  dayMon: "\u4E00",
+  dayTue: "\u4E8C",
+  dayWed: "\u4E09",
+  dayThu: "\u56DB",
+  dayFri: "\u4E94",
+  daySat: "\u516D",
+  invalidCron: "\u65E0\u6548\u7684 Cron \u8868\u8FBE\u5F0F\uFF08\u9700\u8981 5 \u4E2A\u5B57\u6BB5\uFF1A\u5206 \u65F6 \u65E5 \u6708 \u5468\uFF09",
+  nlPlaceholder: "\u81EA\u7136\u8BED\u8A00\u63CF\u8FF0 (\u5982\u300C\u6BCF\u5929\u65E9\u4E0A10\u70B9\u300D\u300C\u6BCF30\u5206\u949F\u300D)",
+  nlNoMatch: "\u65E0\u6CD5\u8BC6\u522B\uFF0C\u8BF7\u4F7F\u7528\u4E0B\u65B9 Cron \u8868\u8FBE\u5F0F\u6216\u9884\u8BBE",
+  applyNl: "\u5E94\u7528",
+  deleteConfirmTitle: "\u5220\u9664\u4EFB\u52A1\uFF1F",
+  deleteConfirmMessage: "\u6B64\u5B9A\u65F6\u4EFB\u52A1\u5C06\u88AB\u6C38\u4E45\u5220\u9664\u3002",
+  taskType: "\u4EFB\u52A1\u7C7B\u578B",
+  statusSuccess: "\u6210\u529F",
+  statusFailure: "\u5931\u8D25",
+  statusSkipped: "\u5DF2\u8DF3\u8FC7"
+};
+
+// ../../packages/core/src/i18n/locales/zh/onboarding.json
+var onboarding_default = {
+  welcome: "\u6B22\u8FCE\u4F7F\u7528 JoWork",
+  welcomeTitle: "\u8BA9 JoWork \u5148\u8BA4\u8BC6\u4F60\u7684\u5DE5\u4F5C\u65B9\u5F0F\u3002",
+  welcomeDescription: "\u4F60\u7684 AI \u5DE5\u4F5C\u52A9\u624B\uFF0C\u672C\u5730\u4F18\u5148\u3001\u9690\u79C1\u5B89\u5168\u3002",
+  loginTitle: "\u4E91\u7AEF & \u56E2\u961F\u529F\u80FD",
+  loginDescription: "\u767B\u5F55\u4EE5\u89E3\u9501\u4E91\u7AEF AI\u3001\u56E2\u961F\u534F\u4F5C\u548C\u8DE8\u8BBE\u5907\u540C\u6B65\u3002",
+  step1Title: "\u9009\u62E9 AI \u5F15\u64CE",
+  step1Description: "JoWork \u652F\u6301\u591A\u79CD AI \u5F15\u64CE\u3002\u9009\u62E9\u4E00\u4E2A\u5F00\u59CB\u4F7F\u7528\u3002",
+  step2Title: "\u8FDE\u63A5\u6570\u636E\u6E90",
+  step2Description: "\u8FDE\u63A5\u4F60\u5E38\u7528\u7684\u5DE5\u5177\uFF0C\u8BA9 AI \u66F4\u597D\u5730\u5E2E\u52A9\u4F60\u3002",
+  profileTitle: "\u4ECB\u7ECD\u4F60\u81EA\u5DF1",
+  profileDescription: "\u5E2E\u52A9 AI \u4E86\u89E3\u5982\u4F55\u66F4\u597D\u5730\u534F\u52A9\u4F60\u3002",
+  step3Title: "\u7ACB\u5373\u4F53\u9A8C\uFF01",
+  step3Description: "\u4E00\u5207\u5C31\u7EEA\uFF01\u5F00\u59CB\u548C AI \u52A9\u624B\u534F\u4F5C\u5427\u3002",
+  skip: "\u8DF3\u8FC7",
+  getStarted: "\u5F00\u59CB\u4F7F\u7528",
+  yourRole: "\u4F60\u7684\u89D2\u8272",
+  communicationStyle: "\u6C9F\u901A\u98CE\u683C",
+  concise: "\u7B80\u6D01",
+  detailed: "\u8BE6\u7EC6",
+  rulesLabel: "AI \u5FC5\u987B\u9075\u5B88\u7684\u89C4\u5219\uFF08\u53EF\u9009\uFF09",
+  rulesPlaceholder: "\u4F8B\u5982\uFF1A\u56DE\u7B54\u7528\u4E2D\u6587\uFF0C\u4EE3\u7801\u6CE8\u91CA\u7528\u82F1\u6587",
+  roleEngineer: "\u5DE5\u7A0B\u5E08",
+  rolePm: "\u4EA7\u54C1\u7ECF\u7406",
+  roleDesigner: "\u8BBE\u8BA1\u5E08",
+  roleOps: "\u8FD0\u8425",
+  roleFounder: "\u521B\u59CB\u4EBA",
+  roleOther: "\u5176\u4ED6",
+  responseGenerated: "\u56DE\u7B54\u5DF2\u751F\u6210\u3002",
+  engineUnavailable: "\u5F15\u64CE\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u5B8C\u6210\u8BBE\u7F6E\u540E\u518D\u8BD5\u3002",
+  cloudFallback: "\u672C\u5730\u5F15\u64CE\u4E0D\u53EF\u7528\uFF0C\u5DF2\u5207\u6362\u5230\u4E91\u7AEF\u5F15\u64CE\u3002",
+  loginForCloud: "\u672C\u5730\u5F15\u64CE\u4E0D\u53EF\u7528\u3002\u767B\u5F55\u5373\u53EF\u4F7F\u7528\u4E91\u7AEF AI \u5F15\u64CE\u3002",
+  defaultQ1: "\u5E2E\u6211\u5199\u4E00\u6BB5 README.md",
+  defaultQ2: "\u89E3\u91CA\u4E00\u4E0B\u4EC0\u4E48\u662F MCP Server",
+  defaultQ3: "\u5E2E\u6211\u89C4\u5212\u4E00\u4E2A\u65B0\u9879\u76EE\u7684\u67B6\u6784",
+  qGithub: "\u5E2E\u6211\u770B\u770B\u8FD9\u5468\u6709\u54EA\u4E9B PR \u9700\u8981 review",
+  qFeishu: "\u603B\u7ED3\u4E00\u4E0B\u98DE\u4E66\u7FA4\u4ECA\u5929\u7684\u91CD\u70B9",
+  qLocalFolder: "\u8FD9\u4E2A\u9879\u76EE\u6700\u8FD1\u6700\u503C\u5F97\u5173\u6CE8\u7684\u6587\u4EF6\u662F\u4EC0\u4E48\uFF1F",
+  qFigma: "\u770B\u770B Figma \u91CC\u6700\u65B0\u7684\u8BBE\u8BA1\u66F4\u65B0",
+  qGitlab: "\u603B\u7ED3\u4E00\u4E0B GitLab \u4E0A\u6700\u8FD1\u7684 merge requests",
+  connectorLocalProject: "\u672C\u5730\u9879\u76EE",
+  eyebrowWelcome: "\u6B22\u8FCE",
+  eyebrowAccount: "\u8D26\u53F7",
+  eyebrowEngine: "\u5F15\u64CE",
+  eyebrowConnectors: "\u8FDE\u63A5\u5668",
+  eyebrowProfile: "\u4E2A\u4EBA\u8D44\u6599",
+  eyebrowAhaMoment: "\u521D\u4F53\u9A8C",
+  infoLanguage: "\u8BED\u8A00",
+  infoPromise: "\u627F\u8BFA",
+  promiseContent: "\u672C\u5730\u4F18\u5148\u3001\u53EF\u63A5\u4E91\u7AEF\u3001\u53EF\u63A5\u771F\u5B9E\u5DE5\u4F5C\u6570\u636E\u3002\u9996\u542F\u53EA\u505A\u5FC5\u8981\u8BBE\u7F6E\uFF0C\u4E0D\u628A\u4F60\u56F0\u5728\u4E00\u5806 marketing \u6587\u6848\u91CC\u3002",
+  featureLocalData: "\u672C\u5730\u6570\u636E\u8FDE\u63A5",
+  featureMcpRole: "\u672C\u5730\u6570\u636E\u8FDE\u63A5\u5668",
+  featureMcpQuote: "JoWork \u901A\u8FC7 MCP \u534F\u8BAE\u6DF1\u5EA6\u8FDE\u63A5\u4F60\u7684\u672C\u5730\u4EE3\u7801\u5E93\u3001\u6587\u4EF6\u548C\u6570\u636E\u5E93\uFF0C\u8BA9 AI \u771F\u6B63\u61C2\u4F60\u7684\u5DE5\u4F5C\u6D41\u3002",
+  featureMultiEngine: "\u591A\u5F15\u64CE\u8C03\u5EA6",
+  featureEngineRole: "\u591A\u6A21\u578B\u8C03\u5EA6\u5F15\u64CE",
+  featureEngineQuote: "\u652F\u6301 Claude\u3001GPT\u3001DeepSeek \u53CA\u672C\u5730 Ollama \u6A21\u578B\uFF0C\u6839\u636E\u4EFB\u52A1\u590D\u6742\u5EA6\u81EA\u52A8\u9009\u62E9\u6700\u4F73\u5F15\u64CE\u3002",
+  badgeLocalFirst: "Local-first",
+  badgeSecure: "\u5B89\u5168",
+  badgeIntelligent: "\u667A\u80FD",
+  badgeFast: "\u5FEB\u901F",
+  infoWhySignIn: "\u4E3A\u4EC0\u4E48\u8981\u767B\u5F55",
+  whySignInContent: "\u767B\u5F55\u540E\u53EF\u4EE5\u4F7F\u7528\u4E91\u5F15\u64CE\u3001\u540C\u6B65\u56E2\u961F\u6570\u636E\u3001\u8D2D\u4E70\u79EF\u5206\uFF0C\u5E76\u5728\u672C\u5730\u5F15\u64CE\u672A\u5B89\u88C5\u65F6\u81EA\u52A8\u56DE\u9000\u5230\u4E91\u7AEF\u6267\u884C\u3002",
+  infoPrivacy: "\u9690\u79C1",
+  privacyContent: "\u51ED\u636E\u9ED8\u8BA4\u4ECD\u4EE5\u672C\u5730\u4F18\u5148\u4FDD\u5B58",
+  googleSignIn: "Google \u767B\u5F55",
+  googleSignInDesc: "\u9002\u5408\u76F4\u63A5\u8FDB\u5165\u5B8C\u6574\u4EA7\u54C1\u4F53\u9A8C\uFF0C\u5305\u542B\u4E91\u80FD\u529B\u3001\u56E2\u961F\u529F\u80FD\u548C\u8DE8\u8BBE\u5907\u4F1A\u8BDD\u3002",
+  skipForNow: "\u6682\u65F6\u8DF3\u8FC7",
+  skipForNowDesc: "\u5982\u679C\u4F60\u53EA\u60F3\u5148\u7528\u672C\u5730\u6A21\u5F0F\uFF0C\u4E5F\u53EF\u4EE5\u7EE7\u7EED\u3002\u540E\u9762\u4ECD\u7136\u53EF\u4EE5\u5728\u8BBE\u7F6E\u6216\u8BA1\u8D39\u9875\u767B\u5F55\u3002",
+  infoDetection: "\u68C0\u6D4B",
+  detectionContent: "\u8FD9\u91CC\u4F1A\u68C0\u6D4B\u672C\u673A\u53EF\u7528\u5F15\u64CE\u3002\u540E\u7EED\u5982\u679C\u672C\u5730\u5F15\u64CE\u4E0D\u53EF\u7528\u4F46\u4F60\u5DF2\u767B\u5F55\uFF0C\u7CFB\u7EDF\u4F1A\u4F18\u5148\u56DE\u9000\u5230\u4E91\u5F15\u64CE\u3002",
+  infoRecommended: "\u63A8\u8350",
+  recommendedContent: "Claude Code \u9002\u5408\u9AD8\u8D28\u91CF\u7F16\u7801\u534F\u4F5C\uFF1BCloud \u9002\u5408\u5FEB\u901F\u5F00\u59CB\uFF1B\u540E\u7EED\u53EF\u5728\u8BBE\u7F6E\u9875\u968F\u65F6\u5207\u6362\u3002",
+  installLater: "\u7A0D\u540E\u5B89\u88C5",
+  notDetected: "\u672A\u68C0\u6D4B\u5230",
+  infoCoreSet: "\u6838\u5FC3\u5957\u4EF6",
+  coreSetContent: "\u9996\u53D1\u6838\u5FC3\u8FDE\u63A5\u5668\u662F GitHub\u3001GitLab\u3001Figma\u3001Feishu \u548C\u672C\u5730\u9879\u76EE\u6587\u4EF6\u5939\u3002\u8FD9\u91CC\u4F18\u5148\u8FDE\u63A5\u4F60\u6700\u5E38\u7528\u7684\u4E00\u4E24\u4E2A\u3002",
+  infoTip: "\u63D0\u793A",
+  tipContent: "\u4E0D\u5FC5\u4E00\u6B21\u8FDE\u5B8C\u3002\u771F\u6B63\u91CD\u8981\u7684\u662F\u8BA9\u540E\u9762\u7684\u9996\u4E2A\u5BF9\u8BDD\u80FD\u62FF\u5230\u81F3\u5C11\u4E00\u4E2A\u771F\u5B9E\u4E0A\u4E0B\u6587\u6E90\u3002",
+  connected: "\u5DF2\u8FDE\u63A5",
+  infoHowUsed: "\u5982\u4F55\u4F7F\u7528",
+  howUsedContent: "\u8FD9\u4E9B\u504F\u597D\u4F1A\u5199\u5165\u672C\u5730 profile \u548C workstyle\uFF0C\u5F71\u54CD\u9ED8\u8BA4\u56DE\u7B54\u98CE\u683C\u3001\u7C92\u5EA6\u548C\u6267\u884C\u7EA6\u675F\u3002",
+  infoGoal: "\u76EE\u6807",
+  goalContent: "\u7528\u4E00\u4E2A\u771F\u5B9E\u95EE\u9898\u8DD1\u51FA\u7B2C\u4E00\u6761\u56DE\u7B54\u3002\u8FD9\u4E2A\u6B65\u9AA4\u7684\u76EE\u7684\u4E0D\u662F\u6F14\u793A UI\uFF0C\u800C\u662F\u786E\u8BA4\u4E0A\u4E0B\u6587\u3001\u5F15\u64CE\u548C\u56DE\u7B54\u94FE\u8DEF\u90FD\u80FD\u5B9E\u9645\u5DE5\u4F5C\u3002",
+  infoEngineFallback: "\u5F15\u64CE\u56DE\u9000",
+  askQuestion: "\u63D0\u95EE",
+  onboardingBadge: "\u5F15\u5BFC\u8BBE\u7F6E",
+  setupTitle: "\u50CF\u771F\u6B63\u7684\u5DE5\u4F5C\u7A7A\u95F4\u4E00\u6837\u8BBE\u7F6E JoWork\u3002",
+  stepLabel: "\u7B2C {{step}} \u6B65",
+  progress: "\u8FDB\u5EA6",
+  stepProgress: "\u7B2C {{current}} \u6B65 / \u5171 {{total}} \u6B65",
+  onboardingDescription: "\u4E00\u6B21\u914D\u7F6E\u8D26\u6237\u3001\u5F15\u64CE\u3001\u8FDE\u63A5\u5668\u548C\u5DE5\u4F5C\u504F\u597D\u3002"
+};
+
+// ../../packages/core/src/i18n/locales/zh/auth.json
+var auth_default = {
+  signIn: "\u4F7F\u7528 Google \u767B\u5F55",
+  signOut: "\u9000\u51FA\u767B\u5F55"
+};
+
+// ../../packages/core/src/i18n/locales/zh/notifications.json
+var notifications_default = {
+  title: "\u901A\u77E5",
+  inbox: "\u6536\u4EF6\u7BB1",
+  rules: "\u89C4\u5219",
+  markAllRead: "\u5168\u90E8\u6807\u4E3A\u5DF2\u8BFB",
+  clearAll: "\u6E05\u7A7A\u5168\u90E8",
+  confirmClearAll: "\u6E05\u7A7A\u6240\u6709\u901A\u77E5\uFF1F",
+  noNotifications: "\u6682\u65E0\u901A\u77E5\u3002",
+  noNotificationsHint: "\u542F\u7528\u901A\u77E5\u89C4\u5219\uFF0C\u5F00\u59CB\u63A5\u6536\u8FDE\u63A5\u5668\u7684\u66F4\u65B0\u63A8\u9001\u3002",
+  rulesDescription: "\u914D\u7F6E\u4F55\u65F6\u4EE5\u53CA\u5982\u4F55\u63A5\u6536\u8FDE\u63A5\u5668\u7684\u901A\u77E5\u3002",
+  newRule: "+ \u65B0\u5EFA\u89C4\u5219",
+  noRules: "\u5C1A\u672A\u914D\u7F6E\u901A\u77E5\u89C4\u5219\u3002",
+  noRulesHint: "\u521B\u5EFA\u89C4\u5219\u4EE5\u63A5\u6536\u8FDE\u63A5\u5668\u4E8B\u4EF6\u901A\u77E5\u3002",
+  editRule: "\u7F16\u8F91\u89C4\u5219",
+  newRuleTitle: "\u65B0\u5EFA\u901A\u77E5\u89C4\u5219",
+  connectorId: "\u8FDE\u63A5\u5668 ID",
+  connectorIdPlaceholder: "\u5982 github, gitlab, feishu",
+  condition: "\u6761\u4EF6",
+  condMentionMe: "\u63D0\u53CA\u6211",
+  condP0Issue: "P0 \u95EE\u9898\u521B\u5EFA",
+  condPrReview: "PR \u5BA1\u67E5\u8BF7\u6C42",
+  condCustom: "\u81EA\u5B9A\u4E49\u7B5B\u9009",
+  customFilterExpression: "\u81EA\u5B9A\u4E49\u7B5B\u9009\u8868\u8FBE\u5F0F",
+  customFilterPlaceholder: '\u5982 title contains "urgent"',
+  deliveryChannels: "\u901A\u77E5\u6E20\u9053",
+  channelSystem: "\u7CFB\u7EDF\u901A\u77E5",
+  channelApp: "\u5E94\u7528\u5185\u901A\u77E5",
+  channelFeishu: "\u98DE\u4E66\u6D88\u606F",
+  silentHours: "\u514D\u6253\u6270\u65F6\u6BB5",
+  silentTo: "\u81F3",
+  aiSummary: "\u6295\u9012\u524D AI \u6458\u8981",
+  createRule: "\u521B\u5EFA\u89C4\u5219",
+  channels: "\u901A\u77E5\u6E20\u9053",
+  silent: "\u514D\u6253\u6270"
+};
+
+// ../../packages/core/src/i18n/locales/en/common.json
+var common_default2 = {
+  app: { name: "JoWork" },
+  save: "Save",
+  cancel: "Cancel",
+  create: "Create",
+  update: "Update",
+  delete: "Delete",
+  edit: "Edit",
+  close: "Close",
+  confirm: "Confirm",
+  loading: "Loading...",
+  saving: "Saving...",
+  search: "Search",
+  filter: "Filter",
+  noResults: "No results",
+  retry: "Retry",
+  back: "Back",
+  next: "Next",
+  done: "Done",
+  enable: "Enable",
+  disable: "Disable",
+  personal: "Personal",
+  teamLabel: "Team",
+  online: "Online",
+  offline: "Offline",
+  syncing: "Syncing",
+  syncComplete: "Sync complete",
+  version: "Version",
+  skipToMainContent: "Skip to main content",
+  contextConnectors: "Connectors",
+  contextNoConnectors: "No active connectors",
+  contextInactive: "inactive",
+  contextPinnedMemories: "Pinned Memories",
+  contextNoMemories: "No pinned memories",
+  contextRecent: "Recent",
+  teamMode: "Team: {{name}}",
+  somethingWentWrong: "Something went wrong",
+  unexpectedError: "An unexpected error occurred.",
+  tryAgain: "Try Again",
+  featureError: "{{name}} error",
+  dismissNotification: "Dismiss notification",
+  menuFile: "File",
+  menuView: "View",
+  trayShow: "Show JoWork",
+  trayQuickChat: "Quick Chat",
+  trayQuit: "Quit",
+  goHome: "Go Home",
+  searchPlaceholder: "Type to search...",
+  searching: "Searching...",
+  noResultsFound: "No results found",
+  pages: "Pages",
+  conversations: "Conversations",
+  messages: "Messages",
+  confirmDelete: "Confirm Delete",
+  deleteWarning: "This action cannot be undone.",
+  savedSuccessfully: "Saved successfully",
+  deletedSuccessfully: "Deleted successfully",
+  operationFailed: "Operation failed",
+  connectedSuccessfully: "Connected successfully",
+  disconnectedSuccessfully: "Disconnected successfully",
+  installedSuccessfully: "Installed successfully",
+  installFailed: "Install failed",
+  copyFailed: "Copy failed",
+  settingsSaved: "Settings saved",
+  v2: "v2",
+  localFirst: "Local First",
+  detected: "Detected",
+  notDetected: "Not detected",
+  copy: "Copy",
+  copied: "Copied!",
+  error: "An error occurred"
+};
+
+// ../../packages/core/src/i18n/locales/en/sidebar.json
+var sidebar_default2 = {
+  conversation: "AI Assistant",
+  dashboard: "Dashboard",
+  connectors: "Connectors",
+  memories: "Memories",
+  skills: "Skills",
+  workstyle: "Work Style",
+  scheduler: "Scheduler",
+  notifications: "Notifications",
+  terminal: "Terminal",
+  settings: "Settings",
+  billing: "Billing",
+  personal: "Personal",
+  team: "Team",
+  search: "Search",
+  hideSidebar: "Hide sidebar",
+  showSidebar: "Show sidebar",
+  hidePanel: "Hide panel",
+  showPanel: "Show panel",
+  hideContext: "Hide context",
+  showContext: "Show context",
+  collapse: "Collapse",
+  expand: "Expand",
+  expandNav: "Expand navigation",
+  collapseNav: "Collapse navigation",
+  credits: "Credits",
+  newConversation: "New conversation",
+  searchPlaceholder: "Search (\u2318K)"
+};
+
+// ../../packages/core/src/i18n/locales/en/chat.json
+var chat_default2 = {
+  title: "JoWork AI Assistant",
+  placeholder: "Type a message... (Enter to send)",
+  send: "Send",
+  stop: "Stop",
+  emptyTitle: "Start a conversation",
+  emptyDescription: "Start a conversation with your AI assistant. It can help you with code, analysis, and more.",
+  noConversations: "No conversations yet",
+  detectingEngines: "Detecting engines...",
+  thinking: "Thinking...",
+  toolCall: "Tool call",
+  toolResult: "Tool result",
+  toolsUsed_one: "{{count}} tool used",
+  toolsUsed_other: "{{count}} tools used",
+  conversations: "Conversations",
+  newConversation: "New conversation",
+  deleteConversation: "Delete conversation",
+  renameConversation: "Rename conversation",
+  searchConversations: "Search conversations...",
+  export: "Export",
+  exportConversation: "Export conversation",
+  exportMarkdown: "Markdown (.md)",
+  exportJson: "JSON (.json)",
+  loadOlder: "Load older messages",
+  loadingOlder: "Loading older messages...",
+  noMatchingConversations: "No matching conversations",
+  dropFilesHere: "Drop files here...",
+  inputAriaLabel: "Chat message input",
+  stopAriaLabel: "Stop AI response",
+  sendAriaLabel: "Send message",
+  actionConfirmation: "Action Confirmation",
+  riskLow: "Low risk",
+  riskMedium: "Medium risk",
+  riskHigh: "High risk",
+  alwaysAllow: "Always allow this action",
+  deny: "Deny",
+  allow: "Allow",
+  notInstalled: "not installed",
+  engineClaudeCode: "Claude Code",
+  engineOpenClaw: "OpenClaw",
+  engineCodex: "Codex",
+  engineNemoClaw: "NemoClaw",
+  engineJoworkCloud: "JoWork Cloud",
+  launcherPlaceholder: "Ask JoWork anything...",
+  recent: "Recent",
+  launcherHint: "Press Enter to ask, Esc to close",
+  skillsLabel: "Available Skills",
+  engineCrashed: "AI engine crashed, restarting... (attempt {{retries}})",
+  engineCrashFatal: "AI engine failed after {{max}} restart attempts. Try switching engines in Settings.",
+  engineRestartReady: "AI engine restarted successfully.",
+  launcherTitle: "JoWork Quick Ask",
+  launcherClose: "close",
+  launcherOpenMain: "open main",
+  launcherModes: "Modes",
+  launcherAskAI: "Ask AI",
+  launcherRunCommand: "Run command",
+  launcherJumpToPage: "Jump to page",
+  timeJustNow: "Just now",
+  timeMinutesAgo: "{{count}}m ago",
+  engineError: "Engine error",
+  retryMessage: "Retry",
+  scrollToBottom: "Jump to latest",
+  exportSuccess: "Conversation exported",
+  exportFailed: "Export failed",
+  deleteSuccess: "Conversation deleted",
+  deleteConfirmTitle: "Delete conversation?",
+  deleteConfirmMessage: "This action cannot be undone.",
+  expand: "Expand",
+  collapse: "Collapse",
+  toolConfirmation: "Tool confirmation",
+  renameSession: "Rename",
+  saveAsSkill: "Save as Skill",
+  generatingSkill: "Generating\u2026",
+  skillGenerateFailed: "Failed to generate skill",
+  deleteConfirm: "Delete?",
+  paramsCount: "{{count}} params",
+  starterPrompt1: "Help me plan today \u2014 what should I focus on first?",
+  starterPrompt2: "I have a rough idea. Help me think it through and make it actionable.",
+  starterPrompt3: "What's blocking my progress? Help me find the real bottleneck.",
+  quotaExhaustedTitle: "Free conversations used up today",
+  quotaExhaustedDesc: "Resets at 00:00 UTC tomorrow, or upgrade Pro to continue",
+  upgradePro: "Upgrade Pro",
+  waitUntilTomorrow: "Wait until tomorrow",
+  switchEngine: "Switch engine",
+  showSidebar: "Show panel",
+  hideSidebar: "Hide panel"
+};
+
+// ../../packages/core/src/i18n/locales/en/connectors.json
+var connectors_default2 = {
+  title: "Connectors",
+  description: "Connect your tools and data sources to JoWork.",
+  connected: "Connected",
+  connectedCount: "{{count}} connected",
+  all: "All",
+  available: "Available Data Sources",
+  noConnected: "No data sources connected yet. Configure one below to get started.",
+  credentialStored: "Credential stored",
+  needsAuth: "Needs authorization",
+  core: "Core Connectors",
+  more: "More Connectors",
+  configure: "Configure",
+  connect: "Connect",
+  disconnect: "Disconnect",
+  loading: "Loading connectors...",
+  loadingDescription: "Checking data source status...",
+  tokenPlaceholder: "Access token or API key",
+  health: "Health status",
+  healthy: "Healthy",
+  unhealthy: "Unhealthy",
+  lastSync: "Last sync",
+  authorize: "Authorize",
+  revoke: "Revoke",
+  tierBeta: "Beta",
+  tierPlanned: "Planned",
+  authorizeTitle: "Authorize {{name}}",
+  authorizeDescription: "A browser window will open for you to authorize JoWork to access your {{name}} data.",
+  noHealthData: "No health data available.",
+  status: "Status",
+  syncedData: "Synced Data",
+  noSyncedData: "No data synced yet.",
+  syncLog: "Sync Log",
+  noSyncActivity: "No sync activity.",
+  disconnectConfirmTitle: "Disconnect {{name}}?",
+  disconnectConfirmMessage: "This will remove the connection and revoke access.",
+  authorization: "Authorization",
+  comingSoon: "Coming Soon",
+  saveAndConnect: "Save & Connect",
+  signIn: "Sign in",
+  authorizing: "Signing in\u2026",
+  connecting: "Connecting\u2026",
+  cat_code: "Code",
+  cat_design: "Design",
+  cat_communication: "Communication",
+  cat_docs: "Documents",
+  cat_local: "Local",
+  cat_analytics: "Analytics",
+  c_github_name: "GitHub",
+  c_github_desc: "Repositories, issues, pull requests",
+  c_gitlab_name: "GitLab",
+  c_gitlab_desc: "Projects, merge requests, issues",
+  c_figma_name: "Figma",
+  c_figma_desc: "Design files and components",
+  "c_local-folder_name": "Local Project",
+  "c_local-folder_desc": "Give Claude access to a local folder",
+  c_feishu_name: "Feishu / Lark \xB7 Org",
+  c_feishu_desc: "Group messages, org docs, calendar (requires Bot App credentials)",
+  c_notion_name: "Notion",
+  c_notion_desc: "Pages, databases, workspace knowledge",
+  c_slack_name: "Slack",
+  c_slack_desc: "Channels, messages, team communication",
+  "c_brave-search_name": "Web Search",
+  "c_brave-search_desc": "Real-time web search via Brave Search API",
+  c_posthog_name: "PostHog",
+  c_posthog_desc: "Product analytics, feature flags, session recordings",
+  c_linear_name: "Linear",
+  c_linear_desc: "Issues, projects, cycles, roadmaps",
+  "c_feishu-personal_name": "Feishu / Lark \xB7 Personal",
+  "c_feishu-personal_desc": "Personal docs, DMs, calendar, email (sign in to JoWork Cloud first)",
+  feishuPersonalRequiresLogin: "Sign in to JoWork Cloud to connect your Feishu personal data",
+  type_local: "Local Data",
+  type_local_desc: "Give the AI direct access to local files and folders",
+  type_sync: "Online Data",
+  type_sync_desc: "Periodically syncs to local for fast search",
+  type_mcp: "MCP Tools",
+  type_mcp_desc: "Fetches data on demand when needed",
+  addFolder: "Add Folder",
+  folderName: "Display Name",
+  folderPath: "Folder Path",
+  removeInstance: "Remove",
+  removeInstanceConfirm: "Remove this folder?"
+};
+
+// ../../packages/core/src/i18n/locales/en/settings.json
+var settings_default2 = {
+  title: "Settings",
+  general: "General",
+  appearance: "Appearance",
+  engines: "AI Engines",
+  about: "About",
+  themeLight: "Light",
+  themeDark: "Dark",
+  themeSystem: "System",
+  language: "Language",
+  update: "Update",
+  checkUpdate: "Check for updates",
+  updateAvailable: "New version available",
+  updateDownloaded: "Update downloaded, restart to install",
+  restartToUpdate: "Restart to update",
+  upToDate: "Up to date",
+  checking: "Checking...",
+  keyboardShortcuts: "Keyboard Shortcuts",
+  shortcutHint: "On Windows/Linux, replace Cmd with Ctrl.",
+  shortcutNewConversation: "New conversation",
+  shortcutGlobalSearch: "Global search",
+  shortcutQuickLauncher: "Quick launcher",
+  shortcutExport: "Export conversation",
+  shortcutSettings: "Settings",
+  shortcutSend: "Send message",
+  shortcutStop: "Stop / close",
+  shortcutTerminal: "Open terminal",
+  shortcutCloseWindow: "Close window",
+  workstyleTitle: "Work Style",
+  workstyleDescription: "Define how the AI should work with you. This is injected into every conversation.",
+  workstylePlaceholder: "Write your work style guide in Markdown...",
+  workstyleHint: "Supports Markdown. This document is included in every AI conversation as context.",
+  saved: "Saved!",
+  workstyleTemplate: "# My Work Style\n\n## Role\n[Your title and responsibilities]\n\n## Communication Preferences\n- Reply style: [concise/detailed]\n- Language: [Chinese/English/bilingual]\n\n## Work Habits\n[Your daily workflow]\n\n## Important Rules\n[Rules the AI must follow]\n",
+  terminalTitle: "Terminal",
+  terminalTab: "Terminal {{n}}",
+  stylePrompt: "Style prompt",
+  quickAccess: "Quick Access"
+};
+
+// ../../packages/core/src/i18n/locales/en/billing.json
+var billing_default2 = {
+  title: "Billing",
+  credits: "Credits",
+  remaining: "Remaining",
+  used: "Used this period",
+  wallet: "Wallet Balance",
+  buyCredits: "Buy Credits",
+  plans: "Plans",
+  currentPlan: "Current Plan",
+  upgrade: "Upgrade",
+  manageSubscription: "Manage Subscription",
+  signInRequired: "Sign in to access billing and cloud credits.",
+  buyAmount: "Buy {{amount}} credits",
+  free: "Free",
+  pro: "Pro",
+  teamPlan: "Team",
+  perMonth: "/mo",
+  usageChart: "Usage",
+  dailyUsage: "Daily Usage (7 days)",
+  creditsLeft: "{{count}} left",
+  walletBalance: "+{{count}} wallet",
+  creditsPerMonth: "{{count}} credits/month",
+  downgrade: "Downgrade",
+  dailyLimit: "Limit: {{limit}}/day",
+  usageHistory: "Usage History",
+  creditOverview: "Credit overview"
+};
+
+// ../../packages/core/src/i18n/locales/en/team.json
+var team_default2 = {
+  title: "Team",
+  members: "Members",
+  invite: "Invite Members",
+  createTeam: "Create a Team",
+  settings: "Team Settings",
+  signInRequired: "Sign in to create or join a team workspace.",
+  yourTeams: "Your Teams",
+  switch: "Switch",
+  owner: "Owner",
+  admin: "Admin",
+  member: "Member",
+  teamName: "Team name",
+  memberCount: "{{count}} members",
+  creating: "Creating...",
+  inviteLink: "Invite link",
+  copyLink: "Copy link",
+  linkCopied: "Copied",
+  removeMember: "Remove member",
+  changeRole: "Change role",
+  leaveTeam: "Leave team",
+  inviteTitle: "Invite Team Members",
+  inviteDescription: "Generate an invite link to share with your team members.",
+  generating: "Generating...",
+  generateInviteLink: "Generate Invite Link",
+  inviteUrl: "Invite URL",
+  inviteExpiry: "This link expires in 7 days. Anyone with this link can join the team.",
+  teamId: "Team ID",
+  remove: "Remove",
+  createTeamDescription: "Create a new workspace for your organization.",
+  removeConfirmTitle: "Remove member?",
+  removeConfirmMessage: "They will lose access to team resources.",
+  noTeams: "You haven't joined any teams yet.",
+  inviteError: "Failed to generate invite link"
+};
+
+// ../../packages/core/src/i18n/locales/en/memory.json
+var memory_default2 = {
+  title: "Memories",
+  description: "Things the AI remembers about you across conversations.",
+  new: "New",
+  editMemory: "Edit Memory",
+  newMemory: "New Memory",
+  titlePlaceholder: "Memory title",
+  contentPlaceholder: "Memory content...",
+  tagsPlaceholder: "Tags (comma-separated)",
+  pinned: "Pinned",
+  allMemories: "All Memories",
+  noMemories: "No memories yet.",
+  noMemoriesHint: "Create one manually or let AI learn from conversations.",
+  pin: "Pin",
+  unpin: "Unpin",
+  searchMemories: "Search memories...",
+  sourceAuto: "Auto",
+  sourceManual: "Manual",
+  scope: "Scope",
+  scopePersonal: "Personal",
+  scopeTeam: "Team",
+  deleteConfirmTitle: "Delete memory?",
+  deleteConfirmMessage: "This memory will be permanently removed."
+};
+
+// ../../packages/core/src/i18n/locales/en/skills.json
+var skills_default2 = {
+  title: "Skills",
+  description: "Reusable prompts and workflows from multiple sources.",
+  filterPlaceholder: "Filter skills...",
+  noSkills: "No skills found.",
+  noSkillsHint: "Add .md files to ~/.claude/commands/ or ~/.claude/skills/",
+  sourceClaudeCode: "Claude Code",
+  sourceJowork: "JoWork",
+  sourceOpenclaw: "OpenClaw",
+  sourceCommunity: "Community",
+  loading: "Loading skills...",
+  run: "Run",
+  details: "Details",
+  marketplace: "Marketplace",
+  createSkill: "Create",
+  variableCount: "{{count}} vars",
+  variableCount_one: "{{count}} var",
+  runSkill: "Run Skill",
+  running: "Running...",
+  selectPlaceholder: "Select...",
+  createCustomSkill: "Create Custom Skill",
+  skillName: "Name",
+  skillTrigger: "Trigger",
+  skillDescription: "Description",
+  promptTemplate: "Prompt Template",
+  promptPlaceholder: "Use {{variable_name}} for dynamic values...",
+  variables: "Variables",
+  addVariable: "+ Add Variable",
+  varLabel: "Label",
+  varTypeText: "Text",
+  varTypeMultiline: "Multiline",
+  varTypeSelect: "Select",
+  varRequired: "Req",
+  saveSkill: "Save Skill",
+  skillMarketplace: "Skill Marketplace",
+  browseSkills: "Browse and install community skills",
+  searchSkills: "Search skills...",
+  installCount: "{{count}} installs",
+  install: "Install",
+  installed: "Installed",
+  noSkillsMatch: "No skills match your search.",
+  skillLibrary: "Skill library",
+  customSkillLabel: "Custom skill",
+  fromConversation: "From Conversation",
+  reviewAndSaveSkill: "Review & Save Skill",
+  skillType: "Type",
+  typeSimple: "Simple",
+  typeWorkflow: "Workflow",
+  workflowSteps: "Steps",
+  addStep: "Add Step",
+  noStepsYet: "No steps yet. Add a step to define the workflow.",
+  step: "Step",
+  stepPromptPlaceholder: "Step prompt\u2026",
+  outputVar: "Output variable (optional)",
+  stepCondition: "Condition to run (optional)",
+  namePlaceholder: "My Skill",
+  triggerPlaceholder: "/my-skill",
+  varNamePlaceholder: "var_name"
+};
+
+// ../../packages/core/src/i18n/locales/en/scheduler.json
+var scheduler_default2 = {
+  title: "Scheduled Tasks",
+  description: "Automate recurring tasks like data scans, skill execution, and notifications.",
+  newTask: "New Task",
+  editTask: "Edit Task",
+  namePlaceholder: "Task name",
+  cronPlaceholder: "Cron expression (e.g. 0 10 * * *)",
+  cloudExecution: "Enable cloud execution when offline",
+  noTasks: "No scheduled tasks yet.",
+  noTasksHint: "Create one to automate your workflow.",
+  enabled: "Enabled",
+  disabled: "Disabled",
+  lastRun: "Last run",
+  nextRun: "Next run",
+  history: "Run history",
+  typeScan: "Scan",
+  typeSkill: "Skill",
+  typeNotify: "Notify",
+  cloud: "Cloud",
+  lastRunShort: "Last:",
+  nextRunShort: "Next:",
+  executionHistory: "Execution History",
+  noExecutions: "No executions yet.",
+  timezonePlaceholder: "Timezone (e.g. Asia/Shanghai)",
+  presets: "Presets",
+  hidePresets: "Hide",
+  customSchedule: "Custom schedule",
+  everyMinute: "Every minute",
+  presetEveryHour: "Every hour",
+  presetEvery2Hours: "Every 2 hours",
+  presetMorning9: "Every morning (9am)",
+  presetMorning10: "Every morning (10am)",
+  presetEvening6: "Every evening (6pm)",
+  presetTwiceDaily: "Twice daily (9am, 6pm)",
+  presetWeekdays9: "Weekdays at 9am",
+  presetMonday9: "Every Monday 9am",
+  presetEvery15Min: "Every 15 minutes",
+  presetEvery30Min: "Every 30 minutes",
+  descEveryHour: "At minute 0 of every hour",
+  descEvery2Hours: "At minute 0, every 2 hours",
+  descMorning9: "Every day at 09:00",
+  descMorning10: "Every day at 10:00",
+  descEvening6: "Every day at 18:00",
+  descTwiceDaily: "At 09:00 and 18:00",
+  descWeekdays9: "Mon-Fri at 09:00",
+  descMonday9: "Every Monday at 09:00",
+  descEvery15Min: "At :00, :15, :30, :45",
+  descEvery30Min: "At :00 and :30",
+  cronMin: "min",
+  cronHour: "hour",
+  cronDay: "day",
+  cronMonth: "month",
+  cronDow: "dow",
+  daySun: "Sun",
+  dayMon: "Mon",
+  dayTue: "Tue",
+  dayWed: "Wed",
+  dayThu: "Thu",
+  dayFri: "Fri",
+  daySat: "Sat",
+  invalidCron: "Invalid cron expression (requires 5 fields: min hour day month dow)",
+  nlPlaceholder: 'Natural language (e.g. "every morning at 10", "every 30 minutes")',
+  nlNoMatch: "Unrecognized. Use the cron field or presets below.",
+  applyNl: "Apply",
+  deleteConfirmTitle: "Delete task?",
+  deleteConfirmMessage: "This scheduled task will be permanently removed.",
+  taskType: "Task type",
+  statusSuccess: "Success",
+  statusFailure: "Failed",
+  statusSkipped: "Skipped"
+};
+
+// ../../packages/core/src/i18n/locales/en/onboarding.json
+var onboarding_default2 = {
+  welcome: "Welcome to JoWork",
+  welcomeTitle: "Let JoWork learn your workflow.",
+  welcomeDescription: "Your AI work assistant. Local-first, privacy-safe.",
+  loginTitle: "Cloud & Team Features",
+  loginDescription: "Sign in to unlock cloud AI, team collaboration, and cross-device sync.",
+  step1Title: "Choose an AI Engine",
+  step1Description: "JoWork supports multiple AI engines. Choose one to get started.",
+  step2Title: "Connect Data Sources",
+  step2Description: "Connect your tools so the AI can better assist you.",
+  profileTitle: "Tell JoWork About You",
+  profileDescription: "Help AI understand how to assist you better.",
+  step3Title: "Try It Now!",
+  step3Description: "All set! Start collaborating with your AI assistant.",
+  skip: "Skip",
+  getStarted: "Get Started",
+  yourRole: "Your Role",
+  communicationStyle: "Communication Style",
+  concise: "Concise",
+  detailed: "Detailed",
+  rulesLabel: "Rules for AI (optional)",
+  rulesPlaceholder: "e.g., Always respond in English",
+  roleEngineer: "Engineer",
+  rolePm: "Product Manager",
+  roleDesigner: "Designer",
+  roleOps: "Operations",
+  roleFounder: "Founder",
+  roleOther: "Other",
+  responseGenerated: "Response generated.",
+  engineUnavailable: "Engine unavailable right now. Try again after setup.",
+  cloudFallback: "Local engine unavailable. Switched to cloud engine.",
+  loginForCloud: "Local engine unavailable. Sign in to use the cloud AI engine.",
+  defaultQ1: "Help me write a README.md",
+  defaultQ2: "Explain what an MCP Server is",
+  defaultQ3: "Help me plan a new project architecture",
+  qGithub: "Show me PRs that need review this week",
+  qFeishu: "Summarize today's highlights from Feishu group",
+  qLocalFolder: "What files in this project are most worth my attention?",
+  qFigma: "Show me the latest design updates in Figma",
+  qGitlab: "Summarize recent merge requests on GitLab",
+  connectorLocalProject: "Local Project",
+  eyebrowWelcome: "Welcome",
+  eyebrowAccount: "Account",
+  eyebrowEngine: "Engine",
+  eyebrowConnectors: "Connectors",
+  eyebrowProfile: "Profile",
+  eyebrowAhaMoment: "Aha moment",
+  infoLanguage: "Language",
+  infoPromise: "Promise",
+  promiseContent: "Local-first, cloud-optional, with real work data. Setup does only what's necessary \u2014 no marketing fluff.",
+  featureLocalData: "Local data access",
+  featureMcpRole: "Local Data Connector",
+  featureMcpQuote: "Connect seamlessly with local files, repos and DBs via MCP protocol.",
+  featureMultiEngine: "Multi-engine dispatch",
+  featureEngineRole: "Multi-Engine Dispatch",
+  featureEngineQuote: "Native support for Claude, GPT, DeepSeek and Ollama. Auto-switches based on task complexity.",
+  badgeLocalFirst: "Local-first",
+  badgeSecure: "Secure",
+  badgeIntelligent: "Intelligent",
+  badgeFast: "Fast",
+  infoWhySignIn: "Why sign in",
+  whySignInContent: "After signing in, you can use cloud engines, sync team data, purchase credits, and auto-fallback to cloud when local engine isn't installed.",
+  infoPrivacy: "Privacy",
+  privacyContent: "Credentials are stored locally by default.",
+  googleSignIn: "Google sign-in",
+  googleSignInDesc: "Best for the full product experience including cloud capabilities, team features, and cross-device sessions.",
+  skipForNow: "Skip for now",
+  skipForNowDesc: "If you just want to try local mode first, you can continue. You can always sign in later from Settings or Billing.",
+  infoDetection: "Detection",
+  detectionContent: "We detect available engines on your machine. If a local engine is unavailable but you're signed in, the system will fallback to cloud.",
+  infoRecommended: "Recommended",
+  recommendedContent: "Claude Code is ideal for high-quality coding. Cloud is great for quick start. You can switch anytime in Settings.",
+  installLater: "Install later",
+  notDetected: "Not detected",
+  infoCoreSet: "Core set",
+  coreSetContent: "The core connectors are GitHub, GitLab, Figma, Feishu, and Local Folder. Connect the one or two you use most here.",
+  infoTip: "Tip",
+  tipContent: "No need to connect everything at once. What matters most is having at least one real context source for your first conversation.",
+  connected: "Connected",
+  infoHowUsed: "How it is used",
+  howUsedContent: "These preferences are saved to your local profile and workstyle. They affect the default response style, granularity, and execution constraints.",
+  infoGoal: "Goal",
+  goalContent: "Run a real question to get your first answer. This step confirms that context, engine, and response pipeline actually work.",
+  infoEngineFallback: "Engine fallback",
+  askQuestion: "Ask",
+  onboardingBadge: "Onboarding",
+  setupTitle: "Set up JoWork like a real workspace.",
+  stepLabel: "Step {{step}}",
+  progress: "Progress",
+  stepProgress: "Step {{current}} / {{total}}",
+  onboardingDescription: "Configure your account, engine, connectors and work preferences in one go."
+};
+
+// ../../packages/core/src/i18n/locales/en/auth.json
+var auth_default2 = {
+  signIn: "Sign in with Google",
+  signOut: "Sign out"
+};
+
+// ../../packages/core/src/i18n/locales/en/notifications.json
+var notifications_default2 = {
+  title: "Notifications",
+  inbox: "Inbox",
+  rules: "Rules",
+  markAllRead: "Mark all read",
+  clearAll: "Clear all",
+  confirmClearAll: "Clear all notifications?",
+  noNotifications: "No notifications.",
+  noNotificationsHint: "Enable notification rules to start receiving updates from your connectors.",
+  rulesDescription: "Configure when and how you receive notifications from connectors.",
+  newRule: "+ New Rule",
+  noRules: "No notification rules configured.",
+  noRulesHint: "Create a rule to get notified about connector events.",
+  editRule: "Edit Rule",
+  newRuleTitle: "New Notification Rule",
+  connectorId: "Connector ID",
+  connectorIdPlaceholder: "e.g. github, gitlab, feishu",
+  condition: "Condition",
+  condMentionMe: "Mention me",
+  condP0Issue: "P0 issue created",
+  condPrReview: "PR review requested",
+  condCustom: "Custom filter",
+  customFilterExpression: "Custom Filter Expression",
+  customFilterPlaceholder: 'e.g. title contains "urgent"',
+  deliveryChannels: "Delivery Channels",
+  channelSystem: "System notification",
+  channelApp: "In-app notification",
+  channelFeishu: "Feishu message",
+  silentHours: "Silent hours",
+  silentTo: "to",
+  aiSummary: "AI-powered summary before delivery",
+  createRule: "Create Rule",
+  channels: "Channels",
+  silent: "Silent"
+};
+
+// ../../packages/core/src/i18n/index.ts
+var i18nNamespaces = [
+  "common",
+  "sidebar",
+  "chat",
+  "connectors",
+  "settings",
+  "billing",
+  "team",
+  "memory",
+  "skills",
+  "scheduler",
+  "onboarding",
+  "auth",
+  "notifications"
+];
+var SUPPORTED_LANGS = ["zh", "en"];
+function detectLanguage() {
+  if (typeof navigator !== "undefined" && navigator.language) {
+    const tag = navigator.language.toLowerCase();
+    if (SUPPORTED_LANGS.includes(tag)) return tag;
+    const prefix = tag.split("-")[0];
+    if (SUPPORTED_LANGS.includes(prefix)) return prefix;
+  }
+  if (typeof process !== "undefined" && process.env?.LANG) {
+    const lang = process.env.LANG.toLowerCase();
+    if (lang.startsWith("zh")) return "zh";
+    if (lang.startsWith("en")) return "en";
+  }
+  return "zh";
+}
+var i18n = instance.createInstance();
+i18n.init({
+  lng: detectLanguage(),
+  fallbackLng: "zh",
+  supportedLngs: [...SUPPORTED_LANGS],
+  ns: [...i18nNamespaces],
+  defaultNS: "common",
+  interpolation: { escapeValue: false },
+  showSupportNotice: false,
+  resources: {
+    zh: {
+      common: common_default,
+      sidebar: sidebar_default,
+      chat: chat_default,
+      connectors: connectors_default,
+      settings: settings_default,
+      billing: billing_default,
+      team: team_default,
+      memory: memory_default,
+      skills: skills_default,
+      scheduler: scheduler_default,
+      onboarding: onboarding_default,
+      auth: auth_default,
+      notifications: notifications_default
+    },
+    en: {
+      common: common_default2,
+      sidebar: sidebar_default2,
+      chat: chat_default2,
+      connectors: connectors_default2,
+      settings: settings_default2,
+      billing: billing_default2,
+      team: team_default2,
+      memory: memory_default2,
+      skills: skills_default2,
+      scheduler: scheduler_default2,
+      onboarding: onboarding_default2,
+      auth: auth_default2,
+      notifications: notifications_default2
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/index.js
+import { webcrypto as crypto } from "crypto";
+var POOL_SIZE_MULTIPLIER = 128;
+var pool;
+var poolOffset;
+function fillPool(bytes) {
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+    crypto.getRandomValues(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    crypto.getRandomValues(pool);
+    poolOffset = 0;
+  }
+  poolOffset += bytes;
+}
+function random(bytes) {
+  fillPool(bytes |= 0);
+  return pool.subarray(poolOffset - bytes, poolOffset);
+}
+function customRandom(alphabet2, defaultSize, getRandom) {
+  let mask = (2 << 31 - Math.clz32(alphabet2.length - 1 | 1)) - 1;
+  let step = Math.ceil(1.6 * mask * defaultSize / alphabet2.length);
+  return (size = defaultSize) => {
+    if (!size) return "";
+    let id = "";
+    while (true) {
+      let bytes = getRandom(step);
+      let i = step;
+      while (i--) {
+        id += alphabet2[bytes[i] & mask] || "";
+        if (id.length >= size) return id;
+      }
+    }
+  };
+}
+function customAlphabet(alphabet2, size = 21) {
+  return customRandom(alphabet2, size, random);
+}
+
+// ../../packages/core/src/utils/id.ts
+var alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-";
+var generate = customAlphabet(alphabet, 12);
+var createId = (prefix) => prefix ? `${prefix}_${generate()}` : generate();
+
+// ../../packages/core/src/utils/logger.ts
+import pino from "pino";
+var logger = pino({ name: "jowork" });
+
+// ../../packages/core/src/utils/tokens.ts
+function estimateTokens(text2) {
+  const cjkChars = (text2.match(/[\u4e00-\u9fff\u3000-\u303f\uff00-\uffef]/g) || []).length;
+  const otherChars = text2.length - cjkChars;
+  return Math.ceil(cjkChars / 2 + otherChars / 4);
+}
+
+// ../../packages/core/src/utils/compaction.ts
+function shouldCompact(messages2, opts = {}) {
+  const contextWindow = opts.contextWindow ?? 1e5;
+  const reserveTokens = opts.reserveTokens ?? 16e3;
+  const totalTokens = messages2.reduce((sum, m) => sum + estimateTokens(m.content), 0);
+  return totalTokens > contextWindow - reserveTokens;
+}
+function findCutPoint(messages2, keepRecentTokens) {
+  let recentTokens = 0;
+  for (let i = messages2.length - 1; i >= 0; i--) {
+    recentTokens += estimateTokens(messages2[i].content);
+    if (recentTokens >= keepRecentTokens) {
+      for (let j = i; j >= 0; j--) {
+        if (messages2[j].role === "user" || messages2[j].role === "assistant") return j;
+      }
+      return i;
+    }
+  }
+  return 0;
+}
+function compactMessages(messages2, opts = {}) {
+  const keepRecentTokens = opts.keepRecentTokens ?? 2e4;
+  const cutPoint = findCutPoint(messages2, keepRecentTokens);
+  if (cutPoint <= 0) {
+    return { summary: "", keptMessages: messages2, compactedCount: 0, tokensSaved: 0 };
+  }
+  const toCompact = messages2.slice(0, cutPoint);
+  const toKeep = messages2.slice(cutPoint);
+  const summary = buildExtractiveSummary(toCompact);
+  const tokensSaved = toCompact.reduce((sum, m) => sum + estimateTokens(m.content), 0) - estimateTokens(summary);
+  return { summary, keptMessages: toKeep, compactedCount: toCompact.length, tokensSaved: Math.max(0, tokensSaved) };
+}
+function buildExtractiveSummary(messages2) {
+  const userMessages = messages2.filter((m) => m.role === "user");
+  const assistantMessages = messages2.filter((m) => m.role === "assistant");
+  const toolMessages = messages2.filter((m) => m.role === "tool" || m.toolName);
+  const sections = ["## \u5BF9\u8BDD\u5386\u53F2\u6458\u8981\n"];
+  if (userMessages.length > 0) {
+    sections.push("### \u7528\u6237\u76EE\u6807");
+    sections.push(userMessages.slice(0, 3).map(
+      (m) => `- ${m.content.slice(0, 200).replace(/\n/g, " ")}${m.content.length > 200 ? "\u2026" : ""}`
+    ).join("\n"));
+    sections.push("");
+  }
+  const decisionPatterns = /决定|选择|方案|采用|使用|confirmed|decided|chose|approach|strategy/i;
+  const decisions = assistantMessages.filter((m) => decisionPatterns.test(m.content)).slice(0, 5).map((m) => `- ${m.content.slice(0, 200).replace(/\n/g, " ")}${m.content.length > 200 ? "\u2026" : ""}`);
+  if (decisions.length > 0) {
+    sections.push("### \u5173\u952E\u51B3\u7B56");
+    sections.push(decisions.join("\n"));
+    sections.push("");
+  }
+  if (toolMessages.length > 0) {
+    const toolNames = [...new Set(toolMessages.map((m) => m.toolName).filter(Boolean))];
+    if (toolNames.length > 0) sections.push(`### \u5DF2\u4F7F\u7528\u7684\u5DE5\u5177
+- ${toolNames.join("\u3001")}
+`);
+  }
+  const lastExchanges = messages2.slice(-4);
+  if (lastExchanges.length > 0) {
+    sections.push("### \u6700\u8FD1\u8FDB\u5C55");
+    for (const msg of lastExchanges) {
+      const prefix = msg.role === "user" ? "\u7528\u6237" : msg.role === "assistant" ? "AI" : msg.role;
+      sections.push(`- [${prefix}] ${msg.content.slice(0, 150).replace(/\n/g, " ")}${msg.content.length > 150 ? "\u2026" : ""}`);
+    }
+    sections.push("");
+  }
+  return sections.join("\n");
+}
+function mergeSummaries(existing, newSummary) {
+  if (!existing) return newSummary;
+  return `${newSummary}
+
+### \u66F4\u65E9\u7684\u5386\u53F2
+
+${existing.replace(/^## 对话历史摘要\n/, "").trim()}`;
+}
+
+// ../../packages/core/src/utils/fts.ts
+var CJK_RANGES = "\\u4e00-\\u9fff\\u3400-\\u4dbf\\uf900-\\ufaff\\u3000-\\u303f\\uff00-\\uffef";
+var CJK_RE = new RegExp(`[${CJK_RANGES}]`);
+var CJK_THEN_LATIN = new RegExp(`([${CJK_RANGES}])([a-zA-Z0-9])`, "g");
+var LATIN_THEN_CJK = new RegExp(`([a-zA-Z0-9])([${CJK_RANGES}])`, "g");
+function ftsNormalize(text2) {
+  return text2.replace(CJK_THEN_LATIN, "$1 $2").replace(LATIN_THEN_CJK, "$1 $2");
+}
+function buildFtsQuery(input) {
+  const parts = input.split(/[\s,.:;!?()[\]{}<>'"、。，！？（）【】《》""''·\-/\\|]+/).filter(Boolean);
+  const latinTokens = [];
+  let hasCjk = false;
+  for (const part of parts) {
+    if (CJK_RE.test(part)) {
+      hasCjk = true;
+      const latinParts = part.split(new RegExp(`[${CJK_RANGES}]+`)).filter((p) => p.length >= 2);
+      latinTokens.push(...latinParts);
+    } else if (part.length >= 2) {
+      latinTokens.push(part.replace(/['"(){}*:^~\-+[\]]/g, ""));
+    }
+  }
+  if (hasCjk && latinTokens.length === 0) return null;
+  if (latinTokens.length === 0) return null;
+  return latinTokens.join(" OR ");
+}
+function detectSourceFromQuery(query) {
+  const lower = query.toLowerCase();
+  if (/飞书|feishu|lark/.test(lower)) return "feishu";
+  if (/\bgithub\b/.test(lower)) return "github";
+  if (/\bgitlab\b/.test(lower)) return "gitlab";
+  if (/\bnotion\b/.test(lower)) return "notion";
+  if (/\bslack\b/.test(lower)) return "slack";
+  return null;
+}
+var SOURCE_ALIASES = {
+  feishu: "feishu \u98DE\u4E66 lark",
+  github: "github",
+  gitlab: "gitlab",
+  notion: "notion",
+  slack: "slack",
+  local: "local \u672C\u5730"
+};
+function ftsEnrichSource(source) {
+  return SOURCE_ALIASES[source] ?? source;
+}
+
+export {
+  ENGINE_CLAUDE_CODE,
+  ENGINE_OPENCLAW,
+  ENGINE_NEMOCLAW,
+  ENGINE_CLOUD,
+  sessions,
+  messages,
+  engineSessionMappings,
+  settings,
+  connectorConfigs,
+  objects,
+  objectBodies,
+  syncCursors,
+  objectChunks,
+  memories,
+  contextDocs,
+  scheduledTasks,
+  taskExecutions,
+  runMigrations,
+  i18nNamespaces,
+  i18n,
+  createId,
+  logger,
+  estimateTokens,
+  shouldCompact,
+  compactMessages,
+  mergeSummaries,
+  CJK_RE,
+  ftsNormalize,
+  buildFtsQuery,
+  detectSourceFromQuery,
+  ftsEnrichSource
+};