lxns-rhythm-api 0.1.8 → 0.1.9

package/dist/index.cjs

@@ -0,0 +1,1336 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ChunithmModels: () => models_exports,
+  LxnsApiClient: () => LxnsApiClient,
+  LxnsApiError: () => LxnsApiError,
+  MaimaiModels: () => models_exports2,
+  isAuthError: () => isAuthError,
+  isLxnsApiError: () => isLxnsApiError,
+  isNotFoundError: () => isNotFoundError,
+  isRateLimitError: () => isRateLimitError,
+  isServerError: () => isServerError
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/api/chunithm/models.ts
+var models_exports = {};
+__export(models_exports, {
+  LevelIndex: () => LevelIndex
+});
+var LevelIndex = /* @__PURE__ */ ((LevelIndex3) => {
+  LevelIndex3[LevelIndex3["BASIC"] = 0] = "BASIC";
+  LevelIndex3[LevelIndex3["ADVANCED"] = 1] = "ADVANCED";
+  LevelIndex3[LevelIndex3["EXPERT"] = 2] = "EXPERT";
+  LevelIndex3[LevelIndex3["MASTER"] = 3] = "MASTER";
+  LevelIndex3[LevelIndex3["ULTIMA"] = 4] = "ULTIMA";
+  LevelIndex3[LevelIndex3["WORLDS_END"] = 5] = "WORLDS_END";
+  return LevelIndex3;
+})(LevelIndex || {});
+
+// src/api/maimai/models.ts
+var models_exports2 = {};
+__export(models_exports2, {
+  LevelIndex: () => LevelIndex2
+});
+var LevelIndex2 = /* @__PURE__ */ ((LevelIndex3) => {
+  LevelIndex3[LevelIndex3["BASIC"] = 0] = "BASIC";
+  LevelIndex3[LevelIndex3["ADVANCED"] = 1] = "ADVANCED";
+  LevelIndex3[LevelIndex3["EXPERT"] = 2] = "EXPERT";
+  LevelIndex3[LevelIndex3["MASTER"] = 3] = "MASTER";
+  LevelIndex3[LevelIndex3["RE_MASTER"] = 4] = "RE_MASTER";
+  return LevelIndex3;
+})(LevelIndex2 || {});
+
+// node_modules/.pnpm/ky@1.10.0/node_modules/ky/distribution/errors/HTTPError.js
+var HTTPError = class extends Error {
+  response;
+  request;
+  options;
+  constructor(response, request, options) {
+    const code = response.status || response.status === 0 ? response.status : "";
+    const title = response.statusText || "";
+    const status = `${code} ${title}`.trim();
+    const reason = status ? `status code ${status}` : "an unknown error";
+    super(`Request failed with ${reason}: ${request.method} ${request.url}`);
+    this.name = "HTTPError";
+    this.response = response;
+    this.request = request;
+    this.options = options;
+  }
+};
+
+// node_modules/.pnpm/ky@1.10.0/node_modules/ky/distribution/errors/TimeoutError.js
+var TimeoutError = class extends Error {
+  request;
+  constructor(request) {
+    super(`Request timed out: ${request.method} ${request.url}`);
+    this.name = "TimeoutError";
+    this.request = request;
+  }
+};
+
+// node_modules/.pnpm/ky@1.10.0/node_modules/ky/distribution/core/constants.js
+var supportsRequestStreams = (() => {
+  let duplexAccessed = false;
+  let hasContentType = false;
+  const supportsReadableStream = typeof globalThis.ReadableStream === "function";
+  const supportsRequest = typeof globalThis.Request === "function";
+  if (supportsReadableStream && supportsRequest) {
+    try {
+      hasContentType = new globalThis.Request("https://empty.invalid", {
+        body: new globalThis.ReadableStream(),
+        method: "POST",
+        // @ts-expect-error - Types are outdated.
+        get duplex() {
+          duplexAccessed = true;
+          return "half";
+        }
+      }).headers.has("Content-Type");
+    } catch (error) {
+      if (error instanceof Error && error.message === "unsupported BodyInit type") {
+        return false;
+      }
+      throw error;
+    }
+  }
+  return duplexAccessed && !hasContentType;
+})();
+var supportsAbortController = typeof globalThis.AbortController === "function";
+var supportsAbortSignal = typeof globalThis.AbortSignal === "function" && typeof globalThis.AbortSignal.any === "function";
+var supportsResponseStreams = typeof globalThis.ReadableStream === "function";
+var supportsFormData = typeof globalThis.FormData === "function";
+var requestMethods = ["get", "post", "put", "patch", "head", "delete"];
+var validate = () => void 0;
+validate();
+var responseTypes = {
+  json: "application/json",
+  text: "text/*",
+  formData: "multipart/form-data",
+  arrayBuffer: "*/*",
+  blob: "*/*",
+  // Supported in modern Fetch implementations (for example, browsers and recent Node.js/undici).
+  // We still feature-check at runtime before exposing the shortcut.
+  bytes: "*/*"
+};
+var maxSafeTimeout = 2147483647;
+var usualFormBoundarySize = new TextEncoder().encode("------WebKitFormBoundaryaxpyiPgbbPti10Rw").length;
+var stop = Symbol("stop");
+var kyOptionKeys = {
+  json: true,
+  parseJson: true,
+  stringifyJson: true,
+  searchParams: true,
+  prefixUrl: true,
+  retry: true,
+  timeout: true,
+  hooks: true,
+  throwHttpErrors: true,
+  onDownloadProgress: true,
+  onUploadProgress: true,
+  fetch: true
+};
+var requestOptionsRegistry = {
+  method: true,
+  headers: true,
+  body: true,
+  mode: true,
+  credentials: true,
+  cache: true,
+  redirect: true,
+  referrer: true,
+  referrerPolicy: true,
+  integrity: true,
+  keepalive: true,
+  signal: true,
+  window: true,
+  dispatcher: true,
+  duplex: true,
+  priority: true
+};
+
+// node_modules/.pnpm/ky@1.10.0/node_modules/ky/distribution/utils/body.js
+var getBodySize = (body) => {
+  if (!body) {
+    return 0;
+  }
+  if (body instanceof FormData) {
+    let size = 0;
+    for (const [key, value] of body) {
+      size += usualFormBoundarySize;
+      size += new TextEncoder().encode(`Content-Disposition: form-data; name="${key}"`).length;
+      size += typeof value === "string" ? new TextEncoder().encode(value).length : value.size;
+    }
+    return size;
+  }
+  if (body instanceof Blob) {
+    return body.size;
+  }
+  if (body instanceof ArrayBuffer) {
+    return body.byteLength;
+  }
+  if (typeof body === "string") {
+    return new TextEncoder().encode(body).length;
+  }
+  if (body instanceof URLSearchParams) {
+    return new TextEncoder().encode(body.toString()).length;
+  }
+  if ("byteLength" in body) {
+    return body.byteLength;
+  }
+  if (typeof body === "object" && body !== null) {
+    try {
+      const jsonString = JSON.stringify(body);
+      return new TextEncoder().encode(jsonString).length;
+    } catch {
+      return 0;
+    }
+  }
+  return 0;
+};
+var streamResponse = (response, onDownloadProgress) => {
+  const totalBytes = Number(response.headers.get("content-length")) || 0;
+  let transferredBytes = 0;
+  if (response.status === 204) {
+    if (onDownloadProgress) {
+      onDownloadProgress({ percent: 1, totalBytes, transferredBytes }, new Uint8Array());
+    }
+    return new Response(null, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  }
+  return new Response(new ReadableStream({
+    async start(controller) {
+      const reader = response.body.getReader();
+      if (onDownloadProgress) {
+        onDownloadProgress({ percent: 0, transferredBytes: 0, totalBytes }, new Uint8Array());
+      }
+      async function read() {
+        const { done, value } = await reader.read();
+        if (done) {
+          controller.close();
+          return;
+        }
+        if (onDownloadProgress) {
+          transferredBytes += value.byteLength;
+          const percent = totalBytes === 0 ? 0 : transferredBytes / totalBytes;
+          onDownloadProgress({ percent, transferredBytes, totalBytes }, value);
+        }
+        controller.enqueue(value);
+        await read();
+      }
+      await read();
+    }
+  }), {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+};
+var streamRequest = (request, onUploadProgress, originalBody) => {
+  const totalBytes = getBodySize(originalBody ?? request.body);
+  let transferredBytes = 0;
+  return new Request(request, {
+    // @ts-expect-error - Types are outdated.
+    duplex: "half",
+    body: new ReadableStream({
+      async start(controller) {
+        const reader = request.body instanceof ReadableStream ? request.body.getReader() : new Response("").body.getReader();
+        async function read() {
+          const { done, value } = await reader.read();
+          if (done) {
+            if (onUploadProgress) {
+              onUploadProgress({ percent: 1, transferredBytes, totalBytes: Math.max(totalBytes, transferredBytes) }, new Uint8Array());
+            }
+            controller.close();
+            return;
+          }
+          transferredBytes += value.byteLength;
+          let percent = totalBytes === 0 ? 0 : transferredBytes / totalBytes;
+          if (totalBytes < transferredBytes || percent === 1) {
+            percent = 0.99;
+          }
+          if (onUploadProgress) {
+            onUploadProgress({ percent: Number(percent.toFixed(2)), transferredBytes, totalBytes }, value);
+          }
+          controller.enqueue(value);
+          await read();
+        }
+        await read();
+      }
+    })
+  });
+};
+
+// node_modules/.pnpm/ky@1.10.0/node_modules/ky/distribution/utils/is.js
+var isObject = (value) => value !== null && typeof value === "object";
+
+// node_modules/.pnpm/ky@1.10.0/node_modules/ky/distribution/utils/merge.js
+var validateAndMerge = (...sources) => {
+  for (const source of sources) {
+    if ((!isObject(source) || Array.isArray(source)) && source !== void 0) {
+      throw new TypeError("The `options` argument must be an object");
+    }
+  }
+  return deepMerge({}, ...sources);
+};
+var mergeHeaders = (source1 = {}, source2 = {}) => {
+  const result = new globalThis.Headers(source1);
+  const isHeadersInstance = source2 instanceof globalThis.Headers;
+  const source = new globalThis.Headers(source2);
+  for (const [key, value] of source.entries()) {
+    if (isHeadersInstance && value === "undefined" || value === void 0) {
+      result.delete(key);
+    } else {
+      result.set(key, value);
+    }
+  }
+  return result;
+};
+function newHookValue(original, incoming, property) {
+  return Object.hasOwn(incoming, property) && incoming[property] === void 0 ? [] : deepMerge(original[property] ?? [], incoming[property] ?? []);
+}
+var mergeHooks = (original = {}, incoming = {}) => ({
+  beforeRequest: newHookValue(original, incoming, "beforeRequest"),
+  beforeRetry: newHookValue(original, incoming, "beforeRetry"),
+  afterResponse: newHookValue(original, incoming, "afterResponse"),
+  beforeError: newHookValue(original, incoming, "beforeError")
+});
+var deepMerge = (...sources) => {
+  let returnValue = {};
+  let headers = {};
+  let hooks = {};
+  for (const source of sources) {
+    if (Array.isArray(source)) {
+      if (!Array.isArray(returnValue)) {
+        returnValue = [];
+      }
+      returnValue = [...returnValue, ...source];
+    } else if (isObject(source)) {
+      for (let [key, value] of Object.entries(source)) {
+        if (isObject(value) && key in returnValue) {
+          value = deepMerge(returnValue[key], value);
+        }
+        returnValue = { ...returnValue, [key]: value };
+      }
+      if (isObject(source.hooks)) {
+        hooks = mergeHooks(hooks, source.hooks);
+        returnValue.hooks = hooks;
+      }
+      if (isObject(source.headers)) {
+        headers = mergeHeaders(headers, source.headers);
+        returnValue.headers = headers;
+      }
+    }
+  }
+  return returnValue;
+};
+
+// node_modules/.pnpm/ky@1.10.0/node_modules/ky/distribution/utils/normalize.js
+var normalizeRequestMethod = (input) => requestMethods.includes(input) ? input.toUpperCase() : input;
+var retryMethods = ["get", "put", "head", "delete", "options", "trace"];
+var retryStatusCodes = [408, 413, 429, 500, 502, 503, 504];
+var retryAfterStatusCodes = [413, 429, 503];
+var defaultRetryOptions = {
+  limit: 2,
+  methods: retryMethods,
+  statusCodes: retryStatusCodes,
+  afterStatusCodes: retryAfterStatusCodes,
+  maxRetryAfter: Number.POSITIVE_INFINITY,
+  backoffLimit: Number.POSITIVE_INFINITY,
+  delay: (attemptCount) => 0.3 * 2 ** (attemptCount - 1) * 1e3
+};
+var normalizeRetryOptions = (retry = {}) => {
+  if (typeof retry === "number") {
+    return {
+      ...defaultRetryOptions,
+      limit: retry
+    };
+  }
+  if (retry.methods && !Array.isArray(retry.methods)) {
+    throw new Error("retry.methods must be an array");
+  }
+  if (retry.statusCodes && !Array.isArray(retry.statusCodes)) {
+    throw new Error("retry.statusCodes must be an array");
+  }
+  return {
+    ...defaultRetryOptions,
+    ...retry
+  };
+};
+
+// node_modules/.pnpm/ky@1.10.0/node_modules/ky/distribution/utils/timeout.js
+async function timeout(request, init, abortController, options) {
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      if (abortController) {
+        abortController.abort();
+      }
+      reject(new TimeoutError(request));
+    }, options.timeout);
+    void options.fetch(request, init).then(resolve).catch(reject).then(() => {
+      clearTimeout(timeoutId);
+    });
+  });
+}
+
+// node_modules/.pnpm/ky@1.10.0/node_modules/ky/distribution/utils/delay.js
+async function delay(ms, { signal }) {
+  return new Promise((resolve, reject) => {
+    if (signal) {
+      signal.throwIfAborted();
+      signal.addEventListener("abort", abortHandler, { once: true });
+    }
+    function abortHandler() {
+      clearTimeout(timeoutId);
+      reject(signal.reason);
+    }
+    const timeoutId = setTimeout(() => {
+      signal?.removeEventListener("abort", abortHandler);
+      resolve();
+    }, ms);
+  });
+}
+
+// node_modules/.pnpm/ky@1.10.0/node_modules/ky/distribution/utils/options.js
+var findUnknownOptions = (request, options) => {
+  const unknownOptions = {};
+  for (const key in options) {
+    if (!(key in requestOptionsRegistry) && !(key in kyOptionKeys) && !(key in request)) {
+      unknownOptions[key] = options[key];
+    }
+  }
+  return unknownOptions;
+};
+var hasSearchParameters = (search) => {
+  if (search === void 0) {
+    return false;
+  }
+  if (Array.isArray(search)) {
+    return search.length > 0;
+  }
+  if (search instanceof URLSearchParams) {
+    return search.size > 0;
+  }
+  if (typeof search === "object") {
+    return Object.keys(search).length > 0;
+  }
+  if (typeof search === "string") {
+    return search.trim().length > 0;
+  }
+  return Boolean(search);
+};
+
+// node_modules/.pnpm/ky@1.10.0/node_modules/ky/distribution/core/Ky.js
+var Ky = class _Ky {
+  static create(input, options) {
+    const ky2 = new _Ky(input, options);
+    const function_ = async () => {
+      if (typeof ky2._options.timeout === "number" && ky2._options.timeout > maxSafeTimeout) {
+        throw new RangeError(`The \`timeout\` option cannot be greater than ${maxSafeTimeout}`);
+      }
+      await Promise.resolve();
+      let response = await ky2._fetch();
+      for (const hook of ky2._options.hooks.afterResponse) {
+        const modifiedResponse = await hook(ky2.request, ky2._options, ky2._decorateResponse(response.clone()));
+        if (modifiedResponse instanceof globalThis.Response) {
+          response = modifiedResponse;
+        }
+      }
+      ky2._decorateResponse(response);
+      if (!response.ok && ky2._options.throwHttpErrors) {
+        let error = new HTTPError(response, ky2.request, ky2._options);
+        for (const hook of ky2._options.hooks.beforeError) {
+          error = await hook(error);
+        }
+        throw error;
+      }
+      if (ky2._options.onDownloadProgress) {
+        if (typeof ky2._options.onDownloadProgress !== "function") {
+          throw new TypeError("The `onDownloadProgress` option must be a function");
+        }
+        if (!supportsResponseStreams) {
+          throw new Error("Streams are not supported in your environment. `ReadableStream` is missing.");
+        }
+        return streamResponse(response.clone(), ky2._options.onDownloadProgress);
+      }
+      return response;
+    };
+    const isRetriableMethod = ky2._options.retry.methods.includes(ky2.request.method.toLowerCase());
+    const result = (isRetriableMethod ? ky2._retry(function_) : function_()).finally(async () => {
+      if (!ky2.request.bodyUsed) {
+        await ky2.request.body?.cancel();
+      }
+    });
+    for (const [type, mimeType] of Object.entries(responseTypes)) {
+      if (type === "bytes" && typeof globalThis.Response?.prototype?.bytes !== "function") {
+        continue;
+      }
+      result[type] = async () => {
+        ky2.request.headers.set("accept", ky2.request.headers.get("accept") || mimeType);
+        const response = await result;
+        if (type === "json") {
+          if (response.status === 204) {
+            return "";
+          }
+          const text = await response.text();
+          if (text === "") {
+            return "";
+          }
+          if (options.parseJson) {
+            return options.parseJson(text);
+          }
+          return JSON.parse(text);
+        }
+        return response[type]();
+      };
+    }
+    return result;
+  }
+  // eslint-disable-next-line unicorn/prevent-abbreviations
+  static #normalizeSearchParams(searchParams) {
+    if (searchParams && typeof searchParams === "object" && !Array.isArray(searchParams) && !(searchParams instanceof URLSearchParams)) {
+      return Object.fromEntries(Object.entries(searchParams).filter(([, value]) => value !== void 0));
+    }
+    return searchParams;
+  }
+  request;
+  abortController;
+  _retryCount = 0;
+  _input;
+  _options;
+  // eslint-disable-next-line complexity
+  constructor(input, options = {}) {
+    this._input = input;
+    this._options = {
+      ...options,
+      headers: mergeHeaders(this._input.headers, options.headers),
+      hooks: mergeHooks({
+        beforeRequest: [],
+        beforeRetry: [],
+        beforeError: [],
+        afterResponse: []
+      }, options.hooks),
+      method: normalizeRequestMethod(options.method ?? this._input.method ?? "GET"),
+      // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+      prefixUrl: String(options.prefixUrl || ""),
+      retry: normalizeRetryOptions(options.retry),
+      throwHttpErrors: options.throwHttpErrors !== false,
+      timeout: options.timeout ?? 1e4,
+      fetch: options.fetch ?? globalThis.fetch.bind(globalThis)
+    };
+    if (typeof this._input !== "string" && !(this._input instanceof URL || this._input instanceof globalThis.Request)) {
+      throw new TypeError("`input` must be a string, URL, or Request");
+    }
+    if (this._options.prefixUrl && typeof this._input === "string") {
+      if (this._input.startsWith("/")) {
+        throw new Error("`input` must not begin with a slash when using `prefixUrl`");
+      }
+      if (!this._options.prefixUrl.endsWith("/")) {
+        this._options.prefixUrl += "/";
+      }
+      this._input = this._options.prefixUrl + this._input;
+    }
+    if (supportsAbortController && supportsAbortSignal) {
+      const originalSignal = this._options.signal ?? this._input.signal;
+      this.abortController = new globalThis.AbortController();
+      this._options.signal = originalSignal ? AbortSignal.any([originalSignal, this.abortController.signal]) : this.abortController.signal;
+    }
+    if (supportsRequestStreams) {
+      this._options.duplex = "half";
+    }
+    if (this._options.json !== void 0) {
+      this._options.body = this._options.stringifyJson?.(this._options.json) ?? JSON.stringify(this._options.json);
+      this._options.headers.set("content-type", this._options.headers.get("content-type") ?? "application/json");
+    }
+    this.request = new globalThis.Request(this._input, this._options);
+    if (hasSearchParameters(this._options.searchParams)) {
+      const textSearchParams = typeof this._options.searchParams === "string" ? this._options.searchParams.replace(/^\?/, "") : new URLSearchParams(_Ky.#normalizeSearchParams(this._options.searchParams)).toString();
+      const searchParams = "?" + textSearchParams;
+      const url = this.request.url.replace(/(?:\?.*?)?(?=#|$)/, searchParams);
+      if ((supportsFormData && this._options.body instanceof globalThis.FormData || this._options.body instanceof URLSearchParams) && !(this._options.headers && this._options.headers["content-type"])) {
+        this.request.headers.delete("content-type");
+      }
+      this.request = new globalThis.Request(new globalThis.Request(url, { ...this.request }), this._options);
+    }
+    if (this._options.onUploadProgress) {
+      if (typeof this._options.onUploadProgress !== "function") {
+        throw new TypeError("The `onUploadProgress` option must be a function");
+      }
+      if (!supportsRequestStreams) {
+        throw new Error("Request streams are not supported in your environment. The `duplex` option for `Request` is not available.");
+      }
+      const originalBody = this.request.body;
+      if (originalBody) {
+        this.request = streamRequest(this.request, this._options.onUploadProgress, this._options.body);
+      }
+    }
+  }
+  _calculateRetryDelay(error) {
+    this._retryCount++;
+    if (this._retryCount > this._options.retry.limit || error instanceof TimeoutError) {
+      throw error;
+    }
+    if (error instanceof HTTPError) {
+      if (!this._options.retry.statusCodes.includes(error.response.status)) {
+        throw error;
+      }
+      const retryAfter = error.response.headers.get("Retry-After") ?? error.response.headers.get("RateLimit-Reset") ?? error.response.headers.get("X-RateLimit-Reset") ?? error.response.headers.get("X-Rate-Limit-Reset");
+      if (retryAfter && this._options.retry.afterStatusCodes.includes(error.response.status)) {
+        let after = Number(retryAfter) * 1e3;
+        if (Number.isNaN(after)) {
+          after = Date.parse(retryAfter) - Date.now();
+        } else if (after >= Date.parse("2024-01-01")) {
+          after -= Date.now();
+        }
+        const max = this._options.retry.maxRetryAfter ?? after;
+        return after < max ? after : max;
+      }
+      if (error.response.status === 413) {
+        throw error;
+      }
+    }
+    const retryDelay = this._options.retry.delay(this._retryCount);
+    return Math.min(this._options.retry.backoffLimit, retryDelay);
+  }
+  _decorateResponse(response) {
+    if (this._options.parseJson) {
+      response.json = async () => this._options.parseJson(await response.text());
+    }
+    return response;
+  }
+  async _retry(function_) {
+    try {
+      return await function_();
+    } catch (error) {
+      const ms = Math.min(this._calculateRetryDelay(error), maxSafeTimeout);
+      if (this._retryCount < 1) {
+        throw error;
+      }
+      await delay(ms, { signal: this._options.signal });
+      for (const hook of this._options.hooks.beforeRetry) {
+        const hookResult = await hook({
+          request: this.request,
+          options: this._options,
+          error,
+          retryCount: this._retryCount
+        });
+        if (hookResult === stop) {
+          return;
+        }
+      }
+      return this._retry(function_);
+    }
+  }
+  async _fetch() {
+    for (const hook of this._options.hooks.beforeRequest) {
+      const result = await hook(this.request, this._options);
+      if (result instanceof Request) {
+        this.request = result;
+        break;
+      }
+      if (result instanceof Response) {
+        return result;
+      }
+    }
+    const nonRequestOptions = findUnknownOptions(this.request, this._options);
+    const mainRequest = this.request;
+    this.request = mainRequest.clone();
+    if (this._options.timeout === false) {
+      return this._options.fetch(mainRequest, nonRequestOptions);
+    }
+    return timeout(mainRequest, nonRequestOptions, this.abortController, this._options);
+  }
+};
+
+// node_modules/.pnpm/ky@1.10.0/node_modules/ky/distribution/index.js
+var createInstance = (defaults) => {
+  const ky2 = (input, options) => Ky.create(input, validateAndMerge(defaults, options));
+  for (const method of requestMethods) {
+    ky2[method] = (input, options) => Ky.create(input, validateAndMerge(defaults, options, { method }));
+  }
+  ky2.create = (newDefaults) => createInstance(validateAndMerge(newDefaults));
+  ky2.extend = (newDefaults) => {
+    if (typeof newDefaults === "function") {
+      newDefaults = newDefaults(defaults ?? {});
+    }
+    return createInstance(validateAndMerge(defaults, newDefaults));
+  };
+  ky2.stop = stop;
+  return ky2;
+};
+var ky = createInstance();
+var distribution_default = ky;
+
+// src/api/chunithm/dev.ts
+var ChunithmDevApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * 创建或修改玩家信息
+   */
+  async postPlayer(body) {
+    return this.http.post("player", { json: body }).json();
+  }
+  /**
+   * 获取玩家信息（通过好友码）
+   */
+  async getPlayer(friendCode) {
+    return this.http.get(`player/${friendCode}`).json();
+  }
+  /**
+   * 获取玩家信息（通过 QQ 号）
+   */
+  async getPlayerByQQ(qq) {
+    return this.http.get(`player/qq/${qq}`).json();
+  }
+  /**
+   * 获取 Best 30（old 15 + new 15）
+   */
+  async getBests(friendCode) {
+    return this.http.get(`player/${friendCode}/bests`).json();
+  }
+  /**
+   * 获取玩家缓存谱面的最佳成绩
+   */
+  async getBest(friendCode, options) {
+    return this.http.get(`player/${friendCode}/best`, {
+      searchParams: {
+        song_id: options.songId,
+        song_name: options.songName,
+        level_index: options.levelIndex
+      }
+    }).json();
+  }
+  /**
+   * 获取玩家缓存的所有最佳成绩（简化）
+   */
+  async getAllBestScores(friendCode) {
+    return this.http.get(`player/${friendCode}/scores`).json();
+  }
+  /**
+   * 获取 Recent 50
+   */
+  async getRecents(friendCode) {
+    return this.http.get(`player/${friendCode}/recents`).json();
+  }
+  /**
+   * 获取成绩游玩历史记录
+   */
+  async getScoreHistory(friendCode, options) {
+    return this.http.get(`player/${friendCode}/score/history`, {
+      searchParams: {
+        song_id: options?.songId,
+        level_index: options?.levelIndex
+      }
+    }).json();
+  }
+  /**
+   * 成绩上传热力图
+   */
+  async getHeatmap(friendCode) {
+    return this.http.get(`player/${friendCode}/heatmap`).json();
+  }
+  /**
+   * Rating 趋势
+   */
+  async getTrend(friendCode, version) {
+    return this.http.get(`player/${friendCode}/trend`, { searchParams: { version } }).json();
+  }
+  /**
+   * 获取玩家收藏品进度
+   */
+  async getCollectionProgress(friendCode, collectionType, collectionId) {
+    return this.http.get(`player/${friendCode}/${collectionType}/${collectionId}`).json();
+  }
+  /**
+   * 上传玩家成绩
+   */
+  async postScores(friendCode, scores) {
+    const body = { scores };
+    return this.http.post(`player/${friendCode}/scores`, { json: body }).json();
+  }
+  /**
+   * 通过 NET 的 HTML 源代码上传玩家数据
+   */
+  async postHtml(friendCode, htmlSource) {
+    return this.http.post(`player/${friendCode}/html`, {
+      body: htmlSource,
+      headers: { "content-type": "text/plain" }
+    }).json();
+  }
+};
+
+// src/api/chunithm/personal.ts
+var ChunithmPersonalApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * 获取玩家信息
+   * GET /api/v0/user/chunithm/player
+   */
+  async getPlayer() {
+    return this.http.get("player").json();
+  }
+  /**
+   * 获取玩家所有成绩
+   * GET /api/v0/user/chunithm/player/scores
+   */
+  async getScores() {
+    return this.http.get("scores").json();
+  }
+  /**
+   * 上传玩家成绩
+   * POST /api/v0/user/chunithm/player/scores
+   */
+  async postScores(scores) {
+    const body = { scores };
+    return this.http.post("scores", { json: body }).json();
+  }
+};
+
+// src/api/chunithm/public.ts
+var ChunithmPublicApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * 获取歌曲列表
+   */
+  async getSongList(version, notes) {
+    return this.http.get("song/list", { searchParams: { version, notes } }).json();
+  }
+  /**
+   * 获取歌曲信息
+   */
+  async getSong(id, version) {
+    return this.http.get(`song/${id}`, { searchParams: { version } }).json();
+  }
+  /**
+   * 获取歌曲别名列表
+   */
+  async getAliasList() {
+    return this.http.get("alias/list").json();
+  }
+  /**
+   * 获取收藏品列表
+   */
+  async getCollectionList(collectionType, version) {
+    const collectionMap = {
+      trophy: "trophies",
+      character: "characters",
+      plate: "plates",
+      icon: "icons"
+    };
+    return this.http.get(`${collectionType}/list`, { searchParams: { version } }).json().then((res) => res[collectionMap[collectionType]]);
+  }
+  /**
+   * 获取收藏品信息
+   */
+  async getCollectionInfo(collectionType, id, version) {
+    return this.http.get(`${collectionType}/${id}`, { searchParams: { version } }).json();
+  }
+};
+
+// src/api/maimai/dev.ts
+var MaimaiDevApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * 创建或修改玩家信息
+   * @param body 玩家信息
+   * @returns 玩家信息
+   */
+  async postPlayer(body) {
+    return this.http.post("player", { json: body }).json();
+  }
+  /**
+   * 获取玩家信息（通过好友码）
+   * @param friendCode 好友码
+   * @returns 玩家信息
+   */
+  async getPlayer(friendCode) {
+    return this.http.get(`player/${friendCode}`).json();
+  }
+  /**
+   * 获取玩家信息（通过 QQ 号）
+   * @param qq QQ 号
+   * @returns 玩家信息
+   */
+  async getPlayerByQQ(qq) {
+    return this.http.get(`player/qq/${qq}`).json();
+  }
+  /**
+   * 获取 Best 50（standard 35 + dx 15）
+   * @param friendCode 好友码
+   * @returns Best 50
+   */
+  async getBests(friendCode) {
+    return this.http.get(`player/${friendCode}/bests`).json();
+  }
+  /**
+   * 获取 AP 50
+   * @param friendCode 好友码
+   * @returns AP 50
+   */
+  async getApBests(friendCode) {
+    return this.http.get(`player/${friendCode}/bests/ap`).json();
+  }
+  /**
+   * 获取 Recent 50（仅增量爬取可用）
+   * @param friendCode 好友码
+   * @returns Recent 50
+   */
+  async getRecents(friendCode) {
+    return this.http.get(`player/${friendCode}/recents`).json();
+  }
+  /**
+   * 获取玩家缓存的所有最佳成绩（简化）
+   * @param friendCode 好友码
+   * @returns BestScoreList
+   */
+  async getAllBestScores(friendCode) {
+    return this.http.get(`player/${friendCode}/scores`).json();
+  }
+  /**
+   * 成绩上传热力图（YYYY-MM-DD -> 数量）
+   * @param friendCode 好友码
+   * @returns Heatmap
+   */
+  async getHeatmap(friendCode) {
+    return this.http.get(`player/${friendCode}/heatmap`).json();
+  }
+  /**
+   * DX Rating 趋势
+   * @param friendCode 好友码
+   * @returns TrendList
+   */
+  async getTrend(friendCode) {
+    return this.http.get(`player/${friendCode}/trend`).json();
+  }
+  /**
+   * 成绩游玩历史记录（仅返回带有 play_time 的成绩）
+   * @param friendCode 好友码
+   * @returns 游玩历史记录
+   */
+  async getScoreHistory(friendCode) {
+    return this.http.get(`player/${friendCode}/score/history`).json();
+  }
+  /**
+   * 获取玩家收藏品进度
+   * @param friendCode 好友码
+   * @param collectionType 收藏品类型
+   * @param collectionId 收藏品 ID
+   * @returns 收藏品进度
+   */
+  async getCollectionProgress(friendCode, collectionType, collectionId) {
+    return this.http.get(`player/${friendCode}/${collectionType}/${collectionId}`).json();
+  }
+  /**
+   * 上传玩家成绩
+   * @param friendCode 好友码
+   * @param scores 成绩列表
+   * @returns 上传结果
+   */
+  async postScores(friendCode, scores) {
+    const body = { scores };
+    return this.http.post(`player/${friendCode}/scores`, { json: body }).json();
+  }
+  /**
+   * 通过 NET 的 HTML 源代码上传玩家数据
+   * @param friendCode 好友码
+   * @param htmlSource HTML 源代码
+   * @returns 上传结果
+   */
+  async postHtml(friendCode, htmlSource) {
+    return this.http.post(`player/${friendCode}/html`, {
+      body: htmlSource,
+      headers: { "content-type": "text/plain" }
+    }).json();
+  }
+};
+
+// src/api/maimai/personal.ts
+var MaimaiPersonalApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * 获取玩家信息
+   * GET /api/v0/user/maimai/player
+   * @returns PlayerInfo
+   */
+  async getPlayer() {
+    return this.http.get("player").json();
+  }
+  /**
+   * 获取玩家所有成绩
+   * GET /api/v0/user/maimai/player/scores
+   * @returns PlayerScores
+   */
+  async getScores() {
+    return this.http.get("scores").json();
+  }
+  /**
+   * 上传玩家成绩
+   * POST /api/v0/user/maimai/player/scores
+   * @param scores 成绩列表
+   * @returns 上传结果
+   */
+  async postScores(scores) {
+    const body = { scores };
+    return this.http.post("scores", { json: body }).json();
+  }
+};
+
+// src/api/maimai/entities/song.ts
+var LevelArray = [
+  "basic",
+  "advanced",
+  "expert",
+  "master",
+  "remaster"
+];
+function convertDifficulty(difficulty) {
+  const sortedDifficulty = [...difficulty].sort(
+    (a, b) => a.difficulty - b.difficulty
+  );
+  return sortedDifficulty.reduce(
+    (acc, cur) => {
+      acc[cur.difficulty] = cur;
+      acc[LevelArray[cur.difficulty]] = cur;
+      return acc;
+    },
+    {}
+  );
+}
+var Song = class {
+  id;
+  title;
+  artist;
+  genre;
+  version;
+  bpm;
+  difficulties;
+  locked;
+  disabled;
+  rights;
+  constructor(song) {
+    this.id = song.id;
+    this.title = song.title;
+    this.artist = song.artist;
+    this.genre = song.genre;
+    this.version = song.version;
+    this.bpm = song.bpm;
+    this.difficulties = song.difficulties;
+    this.locked = song.locked ?? false;
+    this.disabled = song.disabled ?? false;
+    this.rights = song.rights;
+  }
+  get standard() {
+    if (this.difficulties.standard.length === 0) return null;
+    return convertDifficulty(this.difficulties.standard);
+  }
+  get dx() {
+    if (this.difficulties.dx.length === 0) return null;
+    return convertDifficulty(this.difficulties.dx);
+  }
+  get utage() {
+    if (!this.difficulties.utage || this.difficulties.utage.length === 0) {
+      return null;
+    }
+    return this.difficulties.utage;
+  }
+};
+
+// src/api/maimai/public.ts
+var MaimaiPublicApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * 获取歌曲列表
+   * @param version 版本，不填写遵循api默认行为
+   * @param notes 是否包含谱面信息，不填写遵循api默认行为
+   * @returns 歌曲列表
+   */
+  async getSongList(version, notes) {
+    return this.http.get("song/list?", { searchParams: { version, notes } }).json();
+  }
+  /**
+   * 获取歌曲信息
+   * @param id 歌曲 ID
+   * @returns 歌曲信息
+   */
+  async getSong(id) {
+    const songInfo = await this.http.get(`song/${id}`).json();
+    return new Song(songInfo);
+  }
+  /**
+   * 获取歌曲别名列表
+   * @returns 歌曲别名列表
+   */
+  async getAliasList() {
+    return this.http.get("alias/list").json();
+  }
+  /**
+   * 获取收藏品列表
+   * @param collectionType trophy | icon | plate | frame
+   * @param options.version 版本，不填写遵循api默认行为
+   * @param options.required 是否包含曲目需求，默认值为 false
+   * @returns 收藏品列表
+   */
+  async getCollectionList(collectionType, options) {
+    const collectionMap = {
+      trophy: "trophies",
+      icon: "icons",
+      plate: "plates",
+      frame: "frames"
+    };
+    return this.http.get(`${collectionType}/list`, { searchParams: { ...options } }).json().then((res) => res[collectionMap[collectionType]]);
+  }
+  /**
+   * 获取收藏品信息
+   * @param collectionType trophy | icon | plate | frame
+   * @param id 收藏品 ID
+   * @param options.version 版本，不填写遵循api默认行为
+   * @returns 收藏品信息
+   */
+  async getCollectionInfo(collectionType, id, options) {
+    return this.http.get(`${collectionType}/${id}`, { searchParams: { ...options } }).json();
+  }
+  /**
+   * 获取收藏品分类列表
+   * @param options.version 版本，不填写遵循api默认行为
+   * @returns 收藏品分类列表
+   */
+  async getCollectionGenreList(options) {
+    return this.http.get("collection-genre/list", { searchParams: { ...options } }).json();
+  }
+  /**
+   * 获取收藏品分类信息
+   * @param id 收藏品分类 ID
+   * @param options.version 版本，不填写遵循api默认行为
+   * @returns 收藏品分类信息
+   */
+  async getCollectionGenreInfo(id, options) {
+    return this.http.get(`collection-genre/${id}`, { searchParams: { ...options } }).json();
+  }
+};
+
+// src/lxns-api-error.ts
+var LxnsApiError = class extends Error {
+  code;
+  status;
+  success;
+  data;
+  constructor(payload, status) {
+    super(payload.message ?? `Lxns API unknown error (code: ${payload.code})`);
+    this.name = "LxnsApiError";
+    this.code = payload.code;
+    this.status = status;
+    this.success = payload.success;
+    this.data = payload.data;
+  }
+};
+function isLxnsApiError(error) {
+  return error instanceof LxnsApiError;
+}
+function isNotFoundError(error) {
+  return isLxnsApiError(error) && (error.status ?? error.code) === 404;
+}
+function isAuthError(error) {
+  const code = isLxnsApiError(error) ? error.status ?? error.code : void 0;
+  return code === 401 || code === 403;
+}
+function isRateLimitError(error) {
+  return isLxnsApiError(error) && (error.status ?? error.code) === 429;
+}
+function isServerError(error) {
+  const code = isLxnsApiError(error) ? error.status ?? error.code : void 0;
+  return typeof code === "number" && code >= 500;
+}
+
+// src/client/lxns-api-client.ts
+function parseLxnsJson(text) {
+  const payload = JSON.parse(text);
+  if (payload.success === false) {
+    throw new LxnsApiError(payload);
+  }
+  if (payload.success === true) {
+    return payload.data;
+  }
+  return payload;
+}
+async function wrapKyError(error) {
+  const status = error.response.status;
+  try {
+    const payload = await error.response.clone().json();
+    if (typeof payload.success === "boolean") {
+      throw new LxnsApiError(
+        {
+          success: payload.success,
+          code: payload.code ?? status,
+          message: payload.message ?? error.message,
+          data: payload.data
+        },
+        status
+      );
+    }
+  } catch {
+  }
+  throw new LxnsApiError(
+    {
+      success: false,
+      code: status,
+      message: error.message
+    },
+    status
+  );
+}
+var LxnsApiClient = class _LxnsApiClient {
+  config;
+  /**
+   * maimai API
+   */
+  maimai;
+  /**
+   * chunithm API
+   */
+  chunithm;
+  static BASE_OPTIONS = {
+    parseJson: parseLxnsJson,
+    throwHttpErrors: true,
+    hooks: {
+      beforeError: [wrapKyError]
+    }
+  };
+  mountGameApi({
+    public: publicApi,
+    dev,
+    personal,
+    extra
+  }) {
+    const namespace = {
+      public: publicApi,
+      ...extra ?? {}
+    };
+    if (dev) {
+      namespace.dev = dev;
+    }
+    if (personal) {
+      namespace.personal = personal;
+    }
+    return namespace;
+  }
+  constructor(config) {
+    this.config = {
+      ...config,
+      baseURL: config?.baseURL ?? "https://maimai.lxns.net/api/v0/"
+    };
+    const { baseURL, devAccessToken, personalAccessToken } = this.config;
+    const maimaiHttpPublic = distribution_default.create({
+      prefixUrl: new URL("maimai/", baseURL),
+      ..._LxnsApiClient.BASE_OPTIONS
+    });
+    const maimaiHttpDev = devAccessToken ? distribution_default.create({
+      prefixUrl: new URL("maimai/", baseURL),
+      headers: {
+        Authorization: devAccessToken
+      },
+      ..._LxnsApiClient.BASE_OPTIONS
+    }) : void 0;
+    const maimaiHttpPersonal = personalAccessToken ? distribution_default.create({
+      prefixUrl: new URL("user/maimai/", baseURL),
+      headers: {
+        "X-User-Token": personalAccessToken
+      },
+      ..._LxnsApiClient.BASE_OPTIONS
+    }) : void 0;
+    this.maimai = this.mountGameApi({
+      public: new MaimaiPublicApi(maimaiHttpPublic),
+      dev: maimaiHttpDev ? new MaimaiDevApi(maimaiHttpDev) : void 0,
+      personal: maimaiHttpPersonal ? new MaimaiPersonalApi(maimaiHttpPersonal) : void 0,
+      extra: {
+        getAsset: async (type, id) => {
+          return new Uint8Array(
+            await distribution_default.get(
+              `https://assets2.lxns.net/maimai/${type}/${id + (type === "music" ? ".mp3" : ".png")}`
+            ).arrayBuffer()
+          );
+        }
+      }
+    });
+    const chunithmHttpPublic = distribution_default.create({
+      prefixUrl: new URL("chunithm/", baseURL),
+      ..._LxnsApiClient.BASE_OPTIONS
+    });
+    const chunithmHttpDev = devAccessToken ? distribution_default.create({
+      prefixUrl: new URL("chunithm/", baseURL),
+      headers: {
+        Authorization: devAccessToken
+      },
+      ..._LxnsApiClient.BASE_OPTIONS
+    }) : void 0;
+    const chunithmHttpPersonal = personalAccessToken ? distribution_default.create({
+      prefixUrl: new URL("user/chunithm/", baseURL),
+      headers: {
+        "X-User-Token": personalAccessToken
+      },
+      ..._LxnsApiClient.BASE_OPTIONS
+    }) : void 0;
+    this.chunithm = this.mountGameApi({
+      public: new ChunithmPublicApi(chunithmHttpPublic),
+      dev: chunithmHttpDev ? new ChunithmDevApi(chunithmHttpDev) : void 0,
+      personal: chunithmHttpPersonal ? new ChunithmPersonalApi(chunithmHttpPersonal) : void 0,
+      extra: {
+        getAsset: async (type, id) => {
+          return new Uint8Array(
+            await distribution_default.get(`https://assets2.lxns.net/chunithm/${type}/${id}.png`).arrayBuffer()
+          );
+        }
+      }
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChunithmModels,
+  LxnsApiClient,
+  LxnsApiError,
+  MaimaiModels,
+  isAuthError,
+  isLxnsApiError,
+  isNotFoundError,
+  isRateLimitError,
+  isServerError
+});
+/*! Bundled license information:
+
+ky/distribution/index.js:
+  (*! MIT License © Sindre Sorhus *)
+*/

package/dist/index.d.ts

@@ -727,6 +727,18 @@ declare class MaimaiPersonalApi {
     postScores(scores: Score[]): Promise<unknown>;
 }
 
+type DifficultyMap<T> = {
+    0: T;
+    1: T;
+    2: T;
+    3: T;
+    4?: T;
+    basic: T;
+    advanced: T;
+    expert: T;
+    master: T;
+    remaster?: T;
+};
 declare class Song implements Song$1 {
     readonly id: Song$1["id"];
     readonly title: Song$1["title"];
@@ -739,9 +751,9 @@ declare class Song implements Song$1 {
     readonly disabled: boolean;
     readonly rights: Song$1["rights"];
     constructor(song: Song$1);
-    get standard(): Record<"basic" | "advanced" | "expert" | "master" | "remaster", SongDifficulty> | null;
-    get dx(): Record<"basic" | "advanced" | "expert" | "master" | "remaster", SongDifficulty> | null;
-    get utage(): Record<"basic" | "advanced" | "expert" | "master" | "remaster", SongDifficultyUtage> | null;
+    get standard(): DifficultyMap<SongDifficulty> | null;
+    get dx(): DifficultyMap<SongDifficulty> | null;
+    get utage(): SongDifficultyUtage[] | null;
 }
 
 interface SongList {

package/dist/index.js

@@ -369,8 +369,12 @@ var LevelArray = [
   "remaster"
 ];
 function convertDifficulty(difficulty) {
-  return difficulty.reduce(
+  const sortedDifficulty = [...difficulty].sort(
+    (a, b) => a.difficulty - b.difficulty
+  );
+  return sortedDifficulty.reduce(
     (acc, cur) => {
+      acc[cur.difficulty] = cur;
       acc[LevelArray[cur.difficulty]] = cur;
       return acc;
     },
@@ -409,8 +413,10 @@ var Song = class {
     return convertDifficulty(this.difficulties.dx);
   }
   get utage() {
-    if (!this.difficulties.utage) return null;
-    return convertDifficulty(this.difficulties.utage);
+    if (!this.difficulties.utage || this.difficulties.utage.length === 0) {
+      return null;
+    }
+    return this.difficulties.utage;
   }
 };
 

package/package.json

@@ -12,7 +12,7 @@
     "api-client"
   ],
   "author": "amatsuka <amatsukamao@qq.com>",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -20,7 +20,9 @@
   },
   "exports": {
     ".": {
-      "import": "./dist/index.js"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
     },
     "./package.json": "./package.json"
   },
@@ -32,7 +34,7 @@
   ],
   "packageManager": "pnpm@10.16.1",
   "type": "module",
-  "main": "./dist/index.js",
+  "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {