ccjk 12.3.5 → 13.3.3

package/dist/shared/ccjk.UIvifqNE.mjs

@@ -1,1486 +0,0 @@
-const LogLevels = {
-  fatal: 0,
-  error: 0,
-  warn: 1,
-  log: 2,
-  info: 3,
-  success: 3,
-  fail: 3,
-  debug: 4,
-  trace: 5,
-  verbose: Number.POSITIVE_INFINITY
-};
-const LogTypes = {
-  // Silent
-  silent: {
-    level: -1
-  },
-  // Level 0
-  fatal: {
-    level: LogLevels.fatal
-  },
-  error: {
-    level: LogLevels.error
-  },
-  // Level 1
-  warn: {
-    level: LogLevels.warn
-  },
-  // Level 2
-  log: {
-    level: LogLevels.log
-  },
-  // Level 3
-  info: {
-    level: LogLevels.info
-  },
-  success: {
-    level: LogLevels.success
-  },
-  fail: {
-    level: LogLevels.fail
-  },
-  ready: {
-    level: LogLevels.info
-  },
-  start: {
-    level: LogLevels.info
-  },
-  box: {
-    level: LogLevels.info
-  },
-  // Level 4
-  debug: {
-    level: LogLevels.debug
-  },
-  // Level 5
-  trace: {
-    level: LogLevels.trace
-  },
-  // Verbose
-  verbose: {
-    level: LogLevels.verbose
-  }
-};
-
-function isPlainObject$1(value) {
-  if (value === null || typeof value !== "object") {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
-    return false;
-  }
-  if (Symbol.iterator in value) {
-    return false;
-  }
-  if (Symbol.toStringTag in value) {
-    return Object.prototype.toString.call(value) === "[object Module]";
-  }
-  return true;
-}
-
-function _defu(baseObject, defaults, namespace = ".", merger) {
-  if (!isPlainObject$1(defaults)) {
-    return _defu(baseObject, {}, namespace);
-  }
-  const object = Object.assign({}, defaults);
-  for (const key in baseObject) {
-    if (key === "__proto__" || key === "constructor") {
-      continue;
-    }
-    const value = baseObject[key];
-    if (value === null || value === void 0) {
-      continue;
-    }
-    if (Array.isArray(value) && Array.isArray(object[key])) {
-      object[key] = [...value, ...object[key]];
-    } else if (isPlainObject$1(value) && isPlainObject$1(object[key])) {
-      object[key] = _defu(
-        value,
-        object[key],
-        (namespace ? `${namespace}.` : "") + key.toString());
-    } else {
-      object[key] = value;
-    }
-  }
-  return object;
-}
-function createDefu(merger) {
-  return (...arguments_) => (
-    // eslint-disable-next-line unicorn/no-array-reduce
-    arguments_.reduce((p, c) => _defu(p, c, ""), {})
-  );
-}
-const defu = createDefu();
-
-function isPlainObject(obj) {
-  return Object.prototype.toString.call(obj) === "[object Object]";
-}
-function isLogObj(arg) {
-  if (!isPlainObject(arg)) {
-    return false;
-  }
-  if (!arg.message && !arg.args) {
-    return false;
-  }
-  if (arg.stack) {
-    return false;
-  }
-  return true;
-}
-
-let paused = false;
-const queue = [];
-class Consola {
-  options;
-  _lastLog;
-  _mockFn;
-  /**
-   * Creates an instance of Consola with specified options or defaults.
-   *
-   * @param {Partial<ConsolaOptions>} [options={}] - Configuration options for the Consola instance.
-   */
-  constructor(options = {}) {
-    const types = options.types || LogTypes;
-    this.options = defu(
-      {
-        ...options,
-        defaults: { ...options.defaults },
-        level: _normalizeLogLevel(options.level, types),
-        reporters: [...options.reporters || []]
-      },
-      {
-        types: LogTypes,
-        throttle: 1e3,
-        throttleMin: 5,
-        formatOptions: {
-          date: true,
-          colors: false,
-          compact: true
-        }
-      }
-    );
-    for (const type in types) {
-      const defaults = {
-        type,
-        ...this.options.defaults,
-        ...types[type]
-      };
-      this[type] = this._wrapLogFn(defaults);
-      this[type].raw = this._wrapLogFn(
-        defaults,
-        true
-      );
-    }
-    if (this.options.mockFn) {
-      this.mockTypes();
-    }
-    this._lastLog = {};
-  }
-  /**
-   * Gets the current log level of the Consola instance.
-   *
-   * @returns {number} The current log level.
-   */
-  get level() {
-    return this.options.level;
-  }
-  /**
-   * Sets the minimum log level that will be output by the instance.
-   *
-   * @param {number} level - The new log level to set.
-   */
-  set level(level) {
-    this.options.level = _normalizeLogLevel(
-      level,
-      this.options.types,
-      this.options.level
-    );
-  }
-  /**
-   * Displays a prompt to the user and returns the response.
-   * Throw an error if `prompt` is not supported by the current configuration.
-   *
-   * @template T
-   * @param {string} message - The message to display in the prompt.
-   * @param {T} [opts] - Optional options for the prompt. See {@link PromptOptions}.
-   * @returns {promise<T>} A promise that infer with the prompt options. See {@link PromptOptions}.
-   */
-  prompt(message, opts) {
-    if (!this.options.prompt) {
-      throw new Error("prompt is not supported!");
-    }
-    return this.options.prompt(message, opts);
-  }
-  /**
-   * Creates a new instance of Consola, inheriting options from the current instance, with possible overrides.
-   *
-   * @param {Partial<ConsolaOptions>} options - Optional overrides for the new instance. See {@link ConsolaOptions}.
-   * @returns {ConsolaInstance} A new Consola instance. See {@link ConsolaInstance}.
-   */
-  create(options) {
-    const instance = new Consola({
-      ...this.options,
-      ...options
-    });
-    if (this._mockFn) {
-      instance.mockTypes(this._mockFn);
-    }
-    return instance;
-  }
-  /**
-   * Creates a new Consola instance with the specified default log object properties.
-   *
-   * @param {InputLogObject} defaults - Default properties to include in any log from the new instance. See {@link InputLogObject}.
-   * @returns {ConsolaInstance} A new Consola instance. See {@link ConsolaInstance}.
-   */
-  withDefaults(defaults) {
-    return this.create({
-      ...this.options,
-      defaults: {
-        ...this.options.defaults,
-        ...defaults
-      }
-    });
-  }
-  /**
-   * Creates a new Consola instance with a specified tag, which will be included in every log.
-   *
-   * @param {string} tag - The tag to include in each log of the new instance.
-   * @returns {ConsolaInstance} A new Consola instance. See {@link ConsolaInstance}.
-   */
-  withTag(tag) {
-    return this.withDefaults({
-      tag: this.options.defaults.tag ? this.options.defaults.tag + ":" + tag : tag
-    });
-  }
-  /**
-   * Adds a custom reporter to the Consola instance.
-   * Reporters will be called for each log message, depending on their implementation and log level.
-   *
-   * @param {ConsolaReporter} reporter - The reporter to add. See {@link ConsolaReporter}.
-   * @returns {Consola} The current Consola instance.
-   */
-  addReporter(reporter) {
-    this.options.reporters.push(reporter);
-    return this;
-  }
-  /**
-   * Removes a custom reporter from the Consola instance.
-   * If no reporter is specified, all reporters will be removed.
-   *
-   * @param {ConsolaReporter} reporter - The reporter to remove. See {@link ConsolaReporter}.
-   * @returns {Consola} The current Consola instance.
-   */
-  removeReporter(reporter) {
-    if (reporter) {
-      const i = this.options.reporters.indexOf(reporter);
-      if (i !== -1) {
-        return this.options.reporters.splice(i, 1);
-      }
-    } else {
-      this.options.reporters.splice(0);
-    }
-    return this;
-  }
-  /**
-   * Replaces all reporters of the Consola instance with the specified array of reporters.
-   *
-   * @param {ConsolaReporter[]} reporters - The new reporters to set. See {@link ConsolaReporter}.
-   * @returns {Consola} The current Consola instance.
-   */
-  setReporters(reporters) {
-    this.options.reporters = Array.isArray(reporters) ? reporters : [reporters];
-    return this;
-  }
-  wrapAll() {
-    this.wrapConsole();
-    this.wrapStd();
-  }
-  restoreAll() {
-    this.restoreConsole();
-    this.restoreStd();
-  }
-  /**
-   * Overrides console methods with Consola logging methods for consistent logging.
-   */
-  wrapConsole() {
-    for (const type in this.options.types) {
-      if (!console["__" + type]) {
-        console["__" + type] = console[type];
-      }
-      console[type] = this[type].raw;
-    }
-  }
-  /**
-   * Restores the original console methods, removing Consola overrides.
-   */
-  restoreConsole() {
-    for (const type in this.options.types) {
-      if (console["__" + type]) {
-        console[type] = console["__" + type];
-        delete console["__" + type];
-      }
-    }
-  }
-  /**
-   * Overrides standard output and error streams to redirect them through Consola.
-   */
-  wrapStd() {
-    this._wrapStream(this.options.stdout, "log");
-    this._wrapStream(this.options.stderr, "log");
-  }
-  _wrapStream(stream, type) {
-    if (!stream) {
-      return;
-    }
-    if (!stream.__write) {
-      stream.__write = stream.write;
-    }
-    stream.write = (data) => {
-      this[type].raw(String(data).trim());
-    };
-  }
-  /**
-   * Restores the original standard output and error streams, removing the Consola redirection.
-   */
-  restoreStd() {
-    this._restoreStream(this.options.stdout);
-    this._restoreStream(this.options.stderr);
-  }
-  _restoreStream(stream) {
-    if (!stream) {
-      return;
-    }
-    if (stream.__write) {
-      stream.write = stream.__write;
-      delete stream.__write;
-    }
-  }
-  /**
-   * Pauses logging, queues incoming logs until resumed.
-   */
-  pauseLogs() {
-    paused = true;
-  }
-  /**
-   * Resumes logging, processing any queued logs.
-   */
-  resumeLogs() {
-    paused = false;
-    const _queue = queue.splice(0);
-    for (const item of _queue) {
-      item[0]._logFn(item[1], item[2]);
-    }
-  }
-  /**
-   * Replaces logging methods with mocks if a mock function is provided.
-   *
-   * @param {ConsolaOptions["mockFn"]} mockFn - The function to use for mocking logging methods. See {@link ConsolaOptions["mockFn"]}.
-   */
-  mockTypes(mockFn) {
-    const _mockFn = mockFn || this.options.mockFn;
-    this._mockFn = _mockFn;
-    if (typeof _mockFn !== "function") {
-      return;
-    }
-    for (const type in this.options.types) {
-      this[type] = _mockFn(type, this.options.types[type]) || this[type];
-      this[type].raw = this[type];
-    }
-  }
-  _wrapLogFn(defaults, isRaw) {
-    return (...args) => {
-      if (paused) {
-        queue.push([this, defaults, args, isRaw]);
-        return;
-      }
-      return this._logFn(defaults, args, isRaw);
-    };
-  }
-  _logFn(defaults, args, isRaw) {
-    if ((defaults.level || 0) > this.level) {
-      return false;
-    }
-    const logObj = {
-      date: /* @__PURE__ */ new Date(),
-      args: [],
-      ...defaults,
-      level: _normalizeLogLevel(defaults.level, this.options.types)
-    };
-    if (!isRaw && args.length === 1 && isLogObj(args[0])) {
-      Object.assign(logObj, args[0]);
-    } else {
-      logObj.args = [...args];
-    }
-    if (logObj.message) {
-      logObj.args.unshift(logObj.message);
-      delete logObj.message;
-    }
-    if (logObj.additional) {
-      if (!Array.isArray(logObj.additional)) {
-        logObj.additional = logObj.additional.split("\n");
-      }
-      logObj.args.push("\n" + logObj.additional.join("\n"));
-      delete logObj.additional;
-    }
-    logObj.type = typeof logObj.type === "string" ? logObj.type.toLowerCase() : "log";
-    logObj.tag = typeof logObj.tag === "string" ? logObj.tag : "";
-    const resolveLog = (newLog = false) => {
-      const repeated = (this._lastLog.count || 0) - this.options.throttleMin;
-      if (this._lastLog.object && repeated > 0) {
-        const args2 = [...this._lastLog.object.args];
-        if (repeated > 1) {
-          args2.push(`(repeated ${repeated} times)`);
-        }
-        this._log({ ...this._lastLog.object, args: args2 });
-        this._lastLog.count = 1;
-      }
-      if (newLog) {
-        this._lastLog.object = logObj;
-        this._log(logObj);
-      }
-    };
-    clearTimeout(this._lastLog.timeout);
-    const diffTime = this._lastLog.time && logObj.date ? logObj.date.getTime() - this._lastLog.time.getTime() : 0;
-    this._lastLog.time = logObj.date;
-    if (diffTime < this.options.throttle) {
-      try {
-        const serializedLog = JSON.stringify([
-          logObj.type,
-          logObj.tag,
-          logObj.args
-        ]);
-        const isSameLog = this._lastLog.serialized === serializedLog;
-        this._lastLog.serialized = serializedLog;
-        if (isSameLog) {
-          this._lastLog.count = (this._lastLog.count || 0) + 1;
-          if (this._lastLog.count > this.options.throttleMin) {
-            this._lastLog.timeout = setTimeout(
-              resolveLog,
-              this.options.throttle
-            );
-            return;
-          }
-        }
-      } catch {
-      }
-    }
-    resolveLog(true);
-  }
-  _log(logObj) {
-    for (const reporter of this.options.reporters) {
-      reporter.log(logObj, {
-        options: this.options
-      });
-    }
-  }
-}
-function _normalizeLogLevel(input, types = {}, defaultLevel = 3) {
-  if (input === void 0) {
-    return defaultLevel;
-  }
-  if (typeof input === "number") {
-    return input;
-  }
-  if (types[input] && types[input].level !== void 0) {
-    return types[input].level;
-  }
-  return defaultLevel;
-}
-Consola.prototype.add = Consola.prototype.addReporter;
-Consola.prototype.remove = Consola.prototype.removeReporter;
-Consola.prototype.clear = Consola.prototype.removeReporter;
-Consola.prototype.withScope = Consola.prototype.withTag;
-Consola.prototype.mock = Consola.prototype.mockTypes;
-Consola.prototype.pause = Consola.prototype.pauseLogs;
-Consola.prototype.resume = Consola.prototype.resumeLogs;
-function createConsola$1(options = {}) {
-  return new Consola(options);
-}
-
-class BrowserReporter {
-  options;
-  defaultColor;
-  levelColorMap;
-  typeColorMap;
-  constructor(options) {
-    this.options = { ...options };
-    this.defaultColor = "#7f8c8d";
-    this.levelColorMap = {
-      0: "#c0392b",
-      // Red
-      1: "#f39c12",
-      // Yellow
-      3: "#00BCD4"
-      // Cyan
-    };
-    this.typeColorMap = {
-      success: "#2ecc71"
-      // Green
-    };
-  }
-  _getLogFn(level) {
-    if (level < 1) {
-      return console.__error || console.error;
-    }
-    if (level === 1) {
-      return console.__warn || console.warn;
-    }
-    return console.__log || console.log;
-  }
-  log(logObj) {
-    const consoleLogFn = this._getLogFn(logObj.level);
-    const type = logObj.type === "log" ? "" : logObj.type;
-    const tag = logObj.tag || "";
-    const color = this.typeColorMap[logObj.type] || this.levelColorMap[logObj.level] || this.defaultColor;
-    const style = `
-      background: ${color};
-      border-radius: 0.5em;
-      color: white;
-      font-weight: bold;
-      padding: 2px 0.5em;
-    `;
-    const badge = `%c${[tag, type].filter(Boolean).join(":")}`;
-    if (typeof logObj.args[0] === "string") {
-      consoleLogFn(
-        `${badge}%c ${logObj.args[0]}`,
-        style,
-        // Empty string as style resets to default console style
-        "",
-        ...logObj.args.slice(1)
-      );
-    } else {
-      consoleLogFn(badge, style, ...logObj.args);
-    }
-  }
-}
-
-function createConsola(options = {}) {
-  const consola2 = createConsola$1({
-    reporters: options.reporters || [new BrowserReporter({})],
-    prompt(message, options2 = {}) {
-      if (options2.type === "confirm") {
-        return Promise.resolve(confirm(message));
-      }
-      return Promise.resolve(prompt(message));
-    },
-    ...options
-  });
-  return consola2;
-}
-const consola = createConsola();
-
-const suspectProtoRx = /"(?:_|\\u0{2}5[Ff]){2}(?:p|\\u0{2}70)(?:r|\\u0{2}72)(?:o|\\u0{2}6[Ff])(?:t|\\u0{2}74)(?:o|\\u0{2}6[Ff])(?:_|\\u0{2}5[Ff]){2}"\s*:/;
-const suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
-const JsonSigRx = /^\s*["[{]|^\s*-?\d{1,16}(\.\d{1,17})?([Ee][+-]?\d+)?\s*$/;
-function jsonParseTransform(key, value) {
-  if (key === "__proto__" || key === "constructor" && value && typeof value === "object" && "prototype" in value) {
-    warnKeyDropped(key);
-    return;
-  }
-  return value;
-}
-function warnKeyDropped(key) {
-  console.warn(`[destr] Dropping "${key}" key to prevent prototype pollution.`);
-}
-function destr(value, options = {}) {
-  if (typeof value !== "string") {
-    return value;
-  }
-  if (value[0] === '"' && value[value.length - 1] === '"' && value.indexOf("\\") === -1) {
-    return value.slice(1, -1);
-  }
-  const _value = value.trim();
-  if (_value.length <= 9) {
-    switch (_value.toLowerCase()) {
-      case "true": {
-        return true;
-      }
-      case "false": {
-        return false;
-      }
-      case "undefined": {
-        return void 0;
-      }
-      case "null": {
-        return null;
-      }
-      case "nan": {
-        return Number.NaN;
-      }
-      case "infinity": {
-        return Number.POSITIVE_INFINITY;
-      }
-      case "-infinity": {
-        return Number.NEGATIVE_INFINITY;
-      }
-    }
-  }
-  if (!JsonSigRx.test(value)) {
-    if (options.strict) {
-      throw new SyntaxError("[destr] Invalid JSON");
-    }
-    return value;
-  }
-  try {
-    if (suspectProtoRx.test(value) || suspectConstructorRx.test(value)) {
-      if (options.strict) {
-        throw new Error("[destr] Possible prototype pollution");
-      }
-      return JSON.parse(value, jsonParseTransform);
-    }
-    return JSON.parse(value);
-  } catch (error) {
-    if (options.strict) {
-      throw error;
-    }
-    return value;
-  }
-}
-
-const HASH_RE = /#/g;
-const AMPERSAND_RE = /&/g;
-const SLASH_RE = /\//g;
-const EQUAL_RE = /=/g;
-const PLUS_RE = /\+/g;
-const ENC_CARET_RE = /%5e/gi;
-const ENC_BACKTICK_RE = /%60/gi;
-const ENC_PIPE_RE = /%7c/gi;
-const ENC_SPACE_RE = /%20/gi;
-function encode(text) {
-  return encodeURI("" + text).replace(ENC_PIPE_RE, "|");
-}
-function encodeQueryValue(input) {
-  return encode(typeof input === "string" ? input : JSON.stringify(input)).replace(PLUS_RE, "%2B").replace(ENC_SPACE_RE, "+").replace(HASH_RE, "%23").replace(AMPERSAND_RE, "%26").replace(ENC_BACKTICK_RE, "`").replace(ENC_CARET_RE, "^").replace(SLASH_RE, "%2F");
-}
-function encodeQueryKey(text) {
-  return encodeQueryValue(text).replace(EQUAL_RE, "%3D");
-}
-function decode(text = "") {
-  try {
-    return decodeURIComponent("" + text);
-  } catch {
-    return "" + text;
-  }
-}
-function decodeQueryKey(text) {
-  return decode(text.replace(PLUS_RE, " "));
-}
-function decodeQueryValue(text) {
-  return decode(text.replace(PLUS_RE, " "));
-}
-
-function parseQuery(parametersString = "") {
-  const object = /* @__PURE__ */ Object.create(null);
-  if (parametersString[0] === "?") {
-    parametersString = parametersString.slice(1);
-  }
-  for (const parameter of parametersString.split("&")) {
-    const s = parameter.match(/([^=]+)=?(.*)/) || [];
-    if (s.length < 2) {
-      continue;
-    }
-    const key = decodeQueryKey(s[1]);
-    if (key === "__proto__" || key === "constructor") {
-      continue;
-    }
-    const value = decodeQueryValue(s[2] || "");
-    if (object[key] === void 0) {
-      object[key] = value;
-    } else if (Array.isArray(object[key])) {
-      object[key].push(value);
-    } else {
-      object[key] = [object[key], value];
-    }
-  }
-  return object;
-}
-function encodeQueryItem(key, value) {
-  if (typeof value === "number" || typeof value === "boolean") {
-    value = String(value);
-  }
-  if (!value) {
-    return encodeQueryKey(key);
-  }
-  if (Array.isArray(value)) {
-    return value.map(
-      (_value) => `${encodeQueryKey(key)}=${encodeQueryValue(_value)}`
-    ).join("&");
-  }
-  return `${encodeQueryKey(key)}=${encodeQueryValue(value)}`;
-}
-function stringifyQuery(query) {
-  return Object.keys(query).filter((k) => query[k] !== void 0).map((k) => encodeQueryItem(k, query[k])).filter(Boolean).join("&");
-}
-
-const PROTOCOL_STRICT_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{1,2})/;
-const PROTOCOL_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{2})?/;
-const PROTOCOL_RELATIVE_REGEX = /^([/\\]\s*){2,}[^/\\]/;
-const JOIN_LEADING_SLASH_RE = /^\.?\//;
-function hasProtocol(inputString, opts = {}) {
-  if (typeof opts === "boolean") {
-    opts = { acceptRelative: opts };
-  }
-  if (opts.strict) {
-    return PROTOCOL_STRICT_REGEX.test(inputString);
-  }
-  return PROTOCOL_REGEX.test(inputString) || (opts.acceptRelative ? PROTOCOL_RELATIVE_REGEX.test(inputString) : false);
-}
-function hasTrailingSlash(input = "", respectQueryAndFragment) {
-  {
-    return input.endsWith("/");
-  }
-}
-function withoutTrailingSlash(input = "", respectQueryAndFragment) {
-  {
-    return (hasTrailingSlash(input) ? input.slice(0, -1) : input) || "/";
-  }
-}
-function withTrailingSlash(input = "", respectQueryAndFragment) {
-  {
-    return input.endsWith("/") ? input : input + "/";
-  }
-}
-function withBase(input, base) {
-  if (isEmptyURL(base) || hasProtocol(input)) {
-    return input;
-  }
-  const _base = withoutTrailingSlash(base);
-  if (input.startsWith(_base)) {
-    return input;
-  }
-  return joinURL(_base, input);
-}
-function withQuery(input, query) {
-  const parsed = parseURL(input);
-  const mergedQuery = { ...parseQuery(parsed.search), ...query };
-  parsed.search = stringifyQuery(mergedQuery);
-  return stringifyParsedURL(parsed);
-}
-function isEmptyURL(url) {
-  return !url || url === "/";
-}
-function isNonEmptyURL(url) {
-  return url && url !== "/";
-}
-function joinURL(base, ...input) {
-  let url = base || "";
-  for (const segment of input.filter((url2) => isNonEmptyURL(url2))) {
-    if (url) {
-      const _segment = segment.replace(JOIN_LEADING_SLASH_RE, "");
-      url = withTrailingSlash(url) + _segment;
-    } else {
-      url = segment;
-    }
-  }
-  return url;
-}
-
-const protocolRelative = Symbol.for("ufo:protocolRelative");
-function parseURL(input = "", defaultProto) {
-  const _specialProtoMatch = input.match(
-    /^[\s\0]*(blob:|data:|javascript:|vbscript:)(.*)/i
-  );
-  if (_specialProtoMatch) {
-    const [, _proto, _pathname = ""] = _specialProtoMatch;
-    return {
-      protocol: _proto.toLowerCase(),
-      pathname: _pathname,
-      href: _proto + _pathname,
-      auth: "",
-      host: "",
-      search: "",
-      hash: ""
-    };
-  }
-  if (!hasProtocol(input, { acceptRelative: true })) {
-    return parsePath(input);
-  }
-  const [, protocol = "", auth, hostAndPath = ""] = input.replace(/\\/g, "/").match(/^[\s\0]*([\w+.-]{2,}:)?\/\/([^/@]+@)?(.*)/) || [];
-  let [, host = "", path = ""] = hostAndPath.match(/([^#/?]*)(.*)?/) || [];
-  if (protocol === "file:") {
-    path = path.replace(/\/(?=[A-Za-z]:)/, "");
-  }
-  const { pathname, search, hash } = parsePath(path);
-  return {
-    protocol: protocol.toLowerCase(),
-    auth: auth ? auth.slice(0, Math.max(0, auth.length - 1)) : "",
-    host,
-    pathname,
-    search,
-    hash,
-    [protocolRelative]: !protocol
-  };
-}
-function parsePath(input = "") {
-  const [pathname = "", search = "", hash = ""] = (input.match(/([^#?]*)(\?[^#]*)?(#.*)?/) || []).splice(1);
-  return {
-    pathname,
-    search,
-    hash
-  };
-}
-function stringifyParsedURL(parsed) {
-  const pathname = parsed.pathname || "";
-  const search = parsed.search ? (parsed.search.startsWith("?") ? "" : "?") + parsed.search : "";
-  const hash = parsed.hash || "";
-  const auth = parsed.auth ? parsed.auth + "@" : "";
-  const host = parsed.host || "";
-  const proto = parsed.protocol || parsed[protocolRelative] ? (parsed.protocol || "") + "//" : "";
-  return proto + auth + host + pathname + search + hash;
-}
-
-class FetchError extends Error {
-  constructor(message, opts) {
-    super(message, opts);
-    this.name = "FetchError";
-    if (opts?.cause && !this.cause) {
-      this.cause = opts.cause;
-    }
-  }
-}
-function createFetchError(ctx) {
-  const errorMessage = ctx.error?.message || ctx.error?.toString() || "";
-  const method = ctx.request?.method || ctx.options?.method || "GET";
-  const url = ctx.request?.url || String(ctx.request) || "/";
-  const requestStr = `[${method}] ${JSON.stringify(url)}`;
-  const statusStr = ctx.response ? `${ctx.response.status} ${ctx.response.statusText}` : "<no response>";
-  const message = `${requestStr}: ${statusStr}${errorMessage ? ` ${errorMessage}` : ""}`;
-  const fetchError = new FetchError(
-    message,
-    ctx.error ? { cause: ctx.error } : void 0
-  );
-  for (const key of ["request", "options", "response"]) {
-    Object.defineProperty(fetchError, key, {
-      get() {
-        return ctx[key];
-      }
-    });
-  }
-  for (const [key, refKey] of [
-    ["data", "_data"],
-    ["status", "status"],
-    ["statusCode", "status"],
-    ["statusText", "statusText"],
-    ["statusMessage", "statusText"]
-  ]) {
-    Object.defineProperty(fetchError, key, {
-      get() {
-        return ctx.response && ctx.response[refKey];
-      }
-    });
-  }
-  return fetchError;
-}
-
-const payloadMethods = new Set(
-  Object.freeze(["PATCH", "POST", "PUT", "DELETE"])
-);
-function isPayloadMethod(method = "GET") {
-  return payloadMethods.has(method.toUpperCase());
-}
-function isJSONSerializable(value) {
-  if (value === void 0) {
-    return false;
-  }
-  const t = typeof value;
-  if (t === "string" || t === "number" || t === "boolean" || t === null) {
-    return true;
-  }
-  if (t !== "object") {
-    return false;
-  }
-  if (Array.isArray(value)) {
-    return true;
-  }
-  if (value.buffer) {
-    return false;
-  }
-  if (value instanceof FormData || value instanceof URLSearchParams) {
-    return false;
-  }
-  return value.constructor && value.constructor.name === "Object" || typeof value.toJSON === "function";
-}
-const textTypes = /* @__PURE__ */ new Set([
-  "image/svg",
-  "application/xml",
-  "application/xhtml",
-  "application/html"
-]);
-const JSON_RE = /^application\/(?:[\w!#$%&*.^`~-]*\+)?json(;.+)?$/i;
-function detectResponseType(_contentType = "") {
-  if (!_contentType) {
-    return "json";
-  }
-  const contentType = _contentType.split(";").shift() || "";
-  if (JSON_RE.test(contentType)) {
-    return "json";
-  }
-  if (contentType === "text/event-stream") {
-    return "stream";
-  }
-  if (textTypes.has(contentType) || contentType.startsWith("text/")) {
-    return "text";
-  }
-  return "blob";
-}
-function resolveFetchOptions(request, input, defaults, Headers) {
-  const headers = mergeHeaders(
-    input?.headers ?? request?.headers,
-    defaults?.headers,
-    Headers
-  );
-  let query;
-  if (defaults?.query || defaults?.params || input?.params || input?.query) {
-    query = {
-      ...defaults?.params,
-      ...defaults?.query,
-      ...input?.params,
-      ...input?.query
-    };
-  }
-  return {
-    ...defaults,
-    ...input,
-    query,
-    params: query,
-    headers
-  };
-}
-function mergeHeaders(input, defaults, Headers) {
-  if (!defaults) {
-    return new Headers(input);
-  }
-  const headers = new Headers(defaults);
-  if (input) {
-    for (const [key, value] of Symbol.iterator in input || Array.isArray(input) ? input : new Headers(input)) {
-      headers.set(key, value);
-    }
-  }
-  return headers;
-}
-async function callHooks(context, hooks) {
-  if (hooks) {
-    if (Array.isArray(hooks)) {
-      for (const hook of hooks) {
-        await hook(context);
-      }
-    } else {
-      await hooks(context);
-    }
-  }
-}
-
-const retryStatusCodes = /* @__PURE__ */ new Set([
-  408,
-  // Request Timeout
-  409,
-  // Conflict
-  425,
-  // Too Early (Experimental)
-  429,
-  // Too Many Requests
-  500,
-  // Internal Server Error
-  502,
-  // Bad Gateway
-  503,
-  // Service Unavailable
-  504
-  // Gateway Timeout
-]);
-const nullBodyResponses = /* @__PURE__ */ new Set([101, 204, 205, 304]);
-function createFetch(globalOptions = {}) {
-  const {
-    fetch = globalThis.fetch,
-    Headers = globalThis.Headers,
-    AbortController = globalThis.AbortController
-  } = globalOptions;
-  async function onError(context) {
-    const isAbort = context.error && context.error.name === "AbortError" && !context.options.timeout || false;
-    if (context.options.retry !== false && !isAbort) {
-      let retries;
-      if (typeof context.options.retry === "number") {
-        retries = context.options.retry;
-      } else {
-        retries = isPayloadMethod(context.options.method) ? 0 : 1;
-      }
-      const responseCode = context.response && context.response.status || 500;
-      if (retries > 0 && (Array.isArray(context.options.retryStatusCodes) ? context.options.retryStatusCodes.includes(responseCode) : retryStatusCodes.has(responseCode))) {
-        const retryDelay = typeof context.options.retryDelay === "function" ? context.options.retryDelay(context) : context.options.retryDelay || 0;
-        if (retryDelay > 0) {
-          await new Promise((resolve) => setTimeout(resolve, retryDelay));
-        }
-        return $fetchRaw(context.request, {
-          ...context.options,
-          retry: retries - 1
-        });
-      }
-    }
-    const error = createFetchError(context);
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(error, $fetchRaw);
-    }
-    throw error;
-  }
-  const $fetchRaw = async function $fetchRaw2(_request, _options = {}) {
-    const context = {
-      request: _request,
-      options: resolveFetchOptions(
-        _request,
-        _options,
-        globalOptions.defaults,
-        Headers
-      ),
-      response: void 0,
-      error: void 0
-    };
-    if (context.options.method) {
-      context.options.method = context.options.method.toUpperCase();
-    }
-    if (context.options.onRequest) {
-      await callHooks(context, context.options.onRequest);
-      if (!(context.options.headers instanceof Headers)) {
-        context.options.headers = new Headers(
-          context.options.headers || {}
-          /* compat */
-        );
-      }
-    }
-    if (typeof context.request === "string") {
-      if (context.options.baseURL) {
-        context.request = withBase(context.request, context.options.baseURL);
-      }
-      if (context.options.query) {
-        context.request = withQuery(context.request, context.options.query);
-        delete context.options.query;
-      }
-      if ("query" in context.options) {
-        delete context.options.query;
-      }
-      if ("params" in context.options) {
-        delete context.options.params;
-      }
-    }
-    if (context.options.body && isPayloadMethod(context.options.method)) {
-      if (isJSONSerializable(context.options.body)) {
-        const contentType = context.options.headers.get("content-type");
-        if (typeof context.options.body !== "string") {
-          context.options.body = contentType === "application/x-www-form-urlencoded" ? new URLSearchParams(
-            context.options.body
-          ).toString() : JSON.stringify(context.options.body);
-        }
-        if (!contentType) {
-          context.options.headers.set("content-type", "application/json");
-        }
-        if (!context.options.headers.has("accept")) {
-          context.options.headers.set("accept", "application/json");
-        }
-      } else if (
-        // ReadableStream Body
-        "pipeTo" in context.options.body && typeof context.options.body.pipeTo === "function" || // Node.js Stream Body
-        typeof context.options.body.pipe === "function"
-      ) {
-        if (!("duplex" in context.options)) {
-          context.options.duplex = "half";
-        }
-      }
-    }
-    let abortTimeout;
-    if (!context.options.signal && context.options.timeout) {
-      const controller = new AbortController();
-      abortTimeout = setTimeout(() => {
-        const error = new Error(
-          "[TimeoutError]: The operation was aborted due to timeout"
-        );
-        error.name = "TimeoutError";
-        error.code = 23;
-        controller.abort(error);
-      }, context.options.timeout);
-      context.options.signal = controller.signal;
-    }
-    try {
-      context.response = await fetch(
-        context.request,
-        context.options
-      );
-    } catch (error) {
-      context.error = error;
-      if (context.options.onRequestError) {
-        await callHooks(
-          context,
-          context.options.onRequestError
-        );
-      }
-      return await onError(context);
-    } finally {
-      if (abortTimeout) {
-        clearTimeout(abortTimeout);
-      }
-    }
-    const hasBody = (context.response.body || // https://github.com/unjs/ofetch/issues/324
-    // https://github.com/unjs/ofetch/issues/294
-    // https://github.com/JakeChampion/fetch/issues/1454
-    context.response._bodyInit) && !nullBodyResponses.has(context.response.status) && context.options.method !== "HEAD";
-    if (hasBody) {
-      const responseType = (context.options.parseResponse ? "json" : context.options.responseType) || detectResponseType(context.response.headers.get("content-type") || "");
-      switch (responseType) {
-        case "json": {
-          const data = await context.response.text();
-          const parseFunction = context.options.parseResponse || destr;
-          context.response._data = parseFunction(data);
-          break;
-        }
-        case "stream": {
-          context.response._data = context.response.body || context.response._bodyInit;
-          break;
-        }
-        default: {
-          context.response._data = await context.response[responseType]();
-        }
-      }
-    }
-    if (context.options.onResponse) {
-      await callHooks(
-        context,
-        context.options.onResponse
-      );
-    }
-    if (!context.options.ignoreResponseError && context.response.status >= 400 && context.response.status < 600) {
-      if (context.options.onResponseError) {
-        await callHooks(
-          context,
-          context.options.onResponseError
-        );
-      }
-      return await onError(context);
-    }
-    return context.response;
-  };
-  const $fetch = async function $fetch2(request, options) {
-    const r = await $fetchRaw(request, options);
-    return r._data;
-  };
-  $fetch.raw = $fetchRaw;
-  $fetch.native = (...args) => fetch(...args);
-  $fetch.create = (defaultOptions = {}, customGlobalOptions = {}) => createFetch({
-    ...globalOptions,
-    ...customGlobalOptions,
-    defaults: {
-      ...globalOptions.defaults,
-      ...customGlobalOptions.defaults,
-      ...defaultOptions
-    }
-  });
-  return $fetch;
-}
-
-const _globalThis = (function() {
-  if (typeof globalThis !== "undefined") {
-    return globalThis;
-  }
-  if (typeof self !== "undefined") {
-    return self;
-  }
-  if (typeof window !== "undefined") {
-    return window;
-  }
-  if (typeof global !== "undefined") {
-    return global;
-  }
-  throw new Error("unable to locate global object");
-})();
-const fetch = _globalThis.fetch ? (...args) => _globalThis.fetch(...args) : () => Promise.reject(new Error("[ofetch] global.fetch is not supported!"));
-const Headers = _globalThis.Headers;
-const AbortController = _globalThis.AbortController;
-const ofetch = createFetch({ fetch, Headers, AbortController });
-
-class TemplatesClient {
-  fetch;
-  baseURL;
-  language;
-  logger = consola.withTag("templates-client");
-  constructor(config = {}) {
-    this.baseURL = config.baseURL || "https://api.claudehome.cn";
-    this.language = config.language || "en";
-    this.fetch = ofetch.create({
-      baseURL: this.baseURL,
-      timeout: config.timeout || 1e4,
-      headers: {
-        "User-Agent": "CCJK/8.2.0"
-      },
-      retry: 2
-    });
-  }
-  // ==========================================================================
-  // Single Template
-  // ==========================================================================
-  /**
-   * Get a single template by ID
-   */
-  async getTemplate(templateId) {
-    try {
-      this.logger.debug(`Fetching template: ${templateId}`);
-      const response = await this.fetch(
-        `/api/v8/templates/${encodeURIComponent(templateId)}`
-      );
-      if (response.code === 200 && response.data) {
-        return response.data;
-      }
-      return null;
-    } catch (error) {
-      this.logger.warn(`Failed to fetch template ${templateId}:`, error);
-      return null;
-    }
-  }
-  // ==========================================================================
-  // Batch Templates
-  // ==========================================================================
-  /**
-   * Batch get templates by IDs
-   */
-  async getTemplates(ids, language) {
-    try {
-      this.logger.debug(`Batch fetching ${ids.length} templates`);
-      const response = await this.fetch(
-        "/api/v8/templates/batch",
-        {
-          method: "POST",
-          body: {
-            ids,
-            language: language || this.language,
-            includeStats: true
-          }
-        }
-      );
-      return {
-        requestId: response.requestId || "",
-        templates: response.templates || {},
-        notFound: response.notFound || [],
-        stats: response.stats
-      };
-    } catch (error) {
-      this.logger.warn("Failed to batch fetch templates:", error);
-      return {
-        requestId: "",
-        templates: {},
-        notFound: ids
-      };
-    }
-  }
-  // ==========================================================================
-  // Search & List
-  // ==========================================================================
-  /**
-   * Search templates
-   */
-  async searchTemplates(query, params = {}) {
-    try {
-      this.logger.debug(`Searching templates: ${query}`);
-      const searchParams = this.buildSearchParams({ ...params, query });
-      const response = await this.fetch(
-        `/api/v8/templates/search?${searchParams}`
-      );
-      if (response.code === 200 && response.data) {
-        return response.data;
-      }
-      return { items: [], total: 0, limit: 20, offset: 0 };
-    } catch (error) {
-      this.logger.warn("Failed to search templates:", error);
-      return { items: [], total: 0, limit: 20, offset: 0 };
-    }
-  }
-  /**
-   * List templates with filters
-   */
-  async listTemplates(params = {}) {
-    try {
-      this.logger.debug("Listing templates with params:", params);
-      const searchParams = this.buildSearchParams(params);
-      const response = await this.fetch(
-        `/api/v8/templates?${searchParams}`
-      );
-      if (response.code === 200 && response.data) {
-        return response.data;
-      }
-      return { items: [], total: 0, limit: 20, offset: 0 };
-    } catch (error) {
-      this.logger.warn("Failed to list templates:", error);
-      return { items: [], total: 0, limit: 20, offset: 0 };
-    }
-  }
-  // ==========================================================================
-  // Type-specific Methods
-  // ==========================================================================
-  /**
-   * Get templates by type
-   */
-  async getTemplatesByType(type, options = {}) {
-    const { items } = await this.listTemplates({
-      type,
-      category: options.category,
-      limit: options.limit || 50,
-      is_official: options.is_official
-    });
-    return items;
-  }
-  /**
-   * Get specialist agents
-   */
-  async getSpecialistAgents(category) {
-    return this.getTemplatesByType("agent", { category, limit: 50 });
-  }
-  /**
-   * Get official MCP servers
-   */
-  async getOfficialMcpServers() {
-    return this.getTemplatesByType("mcp", { is_official: true, limit: 50 });
-  }
-  /**
-   * Get skills by category
-   */
-  async getSkills(category) {
-    return this.getTemplatesByType("skill", { category, limit: 50 });
-  }
-  /**
-   * Get hooks by category
-   */
-  async getHooks(category) {
-    return this.getTemplatesByType("hook", { category, limit: 50 });
-  }
-  // ==========================================================================
-  // Featured & Popular
-  // ==========================================================================
-  /**
-   * Get featured templates
-   */
-  async getFeaturedTemplates(limit = 10) {
-    try {
-      const response = await this.fetch(
-        `/api/v8/templates/featured?limit=${limit}`
-      );
-      if (response.code === 200 && response.data) {
-        return response.data;
-      }
-      return [];
-    } catch (error) {
-      this.logger.warn("Failed to fetch featured templates:", error);
-      return [];
-    }
-  }
-  /**
-   * Get popular templates
-   */
-  async getPopularTemplates(limit = 20) {
-    try {
-      const response = await this.fetch(
-        `/api/v8/templates/popular?limit=${limit}`
-      );
-      if (response.code === 200 && response.data) {
-        return response.data;
-      }
-      return [];
-    } catch (error) {
-      this.logger.warn("Failed to fetch popular templates:", error);
-      return [];
-    }
-  }
-  // ==========================================================================
-  // Categories
-  // ==========================================================================
-  /**
-   * Get all categories
-   */
-  async getCategories() {
-    try {
-      const response = await this.fetch(
-        "/api/v8/templates/categories"
-      );
-      if (response.code === 200 && response.data) {
-        return response.data;
-      }
-      return [];
-    } catch (error) {
-      this.logger.warn("Failed to fetch categories:", error);
-      return [];
-    }
-  }
-  // ==========================================================================
-  // Download Tracking
-  // ==========================================================================
-  /**
-   * Track template download
-   */
-  async trackDownload(templateId) {
-    try {
-      const response = await this.fetch(
-        `/api/v8/templates/${encodeURIComponent(templateId)}/download`,
-        { method: "POST" }
-      );
-      return response.code === 200;
-    } catch (error) {
-      this.logger.warn(`Failed to track download for ${templateId}:`, error);
-      return false;
-    }
-  }
-  // ==========================================================================
-  // Helpers
-  // ==========================================================================
-  /**
-   * Build search params string
-   */
-  buildSearchParams(params) {
-    const searchParams = new URLSearchParams();
-    if (params.query)
-      searchParams.set("query", params.query);
-    if (params.type)
-      searchParams.set("type", params.type);
-    if (params.category)
-      searchParams.set("category", params.category);
-    if (params.tags?.length)
-      searchParams.set("tags", params.tags.join(","));
-    if (params.is_official !== void 0)
-      searchParams.set("is_official", String(params.is_official));
-    if (params.is_featured !== void 0)
-      searchParams.set("is_featured", String(params.is_featured));
-    if (params.is_verified !== void 0)
-      searchParams.set("is_verified", String(params.is_verified));
-    if (params.sortBy)
-      searchParams.set("sortBy", params.sortBy);
-    if (params.order)
-      searchParams.set("order", params.order);
-    if (params.limit)
-      searchParams.set("limit", String(params.limit));
-    if (params.offset)
-      searchParams.set("offset", String(params.offset));
-    return searchParams.toString();
-  }
-  /**
-   * Extract localized name from template
-   */
-  getLocalizedName(template, lang) {
-    const language = lang || this.language;
-    return language === "zh-CN" && template.name_zh_cn ? template.name_zh_cn : template.name_en;
-  }
-  /**
-   * Extract localized description from template
-   */
-  getLocalizedDescription(template, lang) {
-    const language = lang || this.language;
-    return language === "zh-CN" && template.description_zh_cn ? template.description_zh_cn : template.description_en || "";
-  }
-}
-let templatesClientInstance = null;
-function getTemplatesClient(config) {
-  if (!templatesClientInstance) {
-    templatesClientInstance = new TemplatesClient(config);
-  }
-  return templatesClientInstance;
-}
-function createTemplatesClient(config) {
-  return new TemplatesClient(config);
-}
-
-export { TemplatesClient as T, createTemplatesClient as a, consola as c, getTemplatesClient as g, ofetch as o };