@book000/pixivts 0.60.0-beta.3 → 0.60.0-beta.5

package/dist/index.cjs

@@ -1,1524 +1,1605 @@
-'use strict';
-
-// src/result.ts
-var OkResultImpl = class _OkResultImpl {
-  constructor(value) {
-    this.value = value;
-  }
-  value;
-  isOk = true;
-  isErr = false;
-  map(fn) {
-    return new _OkResultImpl(fn(this.value));
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters, @typescript-eslint/no-unused-vars -- F is part of the public API contract; _fn is intentionally unused (OkResult.mapErr is a no-op)
-  mapErr(_fn) {
-    return this;
-  }
-  andThen(fn) {
-    return fn(this.value);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars -- _onErr is intentionally unused: OkResult.match always calls onOk
-  match(onOk, _onErr) {
-    return onOk(this.value);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars -- _fallback is intentionally unused: OkResult.unwrapOr always returns value
-  unwrapOr(_fallback) {
-    return this.value;
-  }
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/result.ts
+var OkResultImpl = class OkResultImpl {
+	value;
+	isOk = true;
+	isErr = false;
+	constructor(value) {
+		this.value = value;
+	}
+	map(fn) {
+		return new OkResultImpl(fn(this.value));
+	}
+	mapErr(_fn) {
+		return this;
+	}
+	andThen(fn) {
+		return fn(this.value);
+	}
+	match(onOk, _onErr) {
+		return onOk(this.value);
+	}
+	unwrapOr(_fallback) {
+		return this.value;
+	}
 };
-var ErrResultImpl = class _ErrResultImpl {
-  // eslint-disable-next-line n/handle-callback-err -- 'error' is a stored value, not a Node.js callback error parameter
-  constructor(error) {
-    this.error = error;
-  }
-  error;
-  isOk = false;
-  isErr = true;
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters, @typescript-eslint/no-unused-vars -- U is part of the public API contract; _fn is intentionally unused (ErrResult.map is a no-op)
-  map(_fn) {
-    return this;
-  }
-  mapErr(fn) {
-    return new _ErrResultImpl(fn(this.error));
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars -- _fn is intentionally unused: ErrResult.andThen is a no-op (the success path does not apply)
-  andThen(_fn) {
-    return this;
-  }
-  match(_onOk, onErr) {
-    return onErr(this.error);
-  }
-  unwrapOr(fallback) {
-    return fallback;
-  }
+var ErrResultImpl = class ErrResultImpl {
+	error;
+	isOk = false;
+	isErr = true;
+	constructor(error) {
+		this.error = error;
+	}
+	map(_fn) {
+		return this;
+	}
+	mapErr(fn) {
+		return new ErrResultImpl(fn(this.error));
+	}
+	andThen(_fn) {
+		return this;
+	}
+	match(_onOk, onErr) {
+		return onErr(this.error);
+	}
+	unwrapOr(fallback) {
+		return fallback;
+	}
 };
+/**
+* Creates a successful `Result<T, never>`.
+*
+* @param value - The success value
+*/
 function ok(value) {
-  return new OkResultImpl(value);
+	return new OkResultImpl(value);
 }
+/**
+* Creates a failed `Result<never, E>`.
+*
+* @param error - The error value
+*/
 function err(error) {
-  return new ErrResultImpl(error);
+	return new ErrResultImpl(error);
 }
-var ResultAsync = class _ResultAsync {
-  _promise;
-  constructor(promise) {
-    this._promise = promise;
-  }
-  // PromiseLike contract — makes `await resultAsync` work
-  // eslint-disable-next-line unicorn/no-thenable -- ResultAsync intentionally implements PromiseLike to be directly awaitable
-  then(onfulfilled, onrejected) {
-    return this._promise.then(onfulfilled, onrejected);
-  }
-  /**
-   * Wraps a `Promise<T>` into a `ResultAsync<T, E>`.
-   *
-   * If the promise rejects, `onError` maps the rejection reason to `E`.
-   *
-   * @param promise - The promise to wrap
-   * @param onError - Error mapper
-   */
-  static fromPromise(promise, onError) {
-    return new _ResultAsync(
-      promise.then(
-        (v) => ok(v),
-        (error) => err(onError(error))
-      )
-    );
-  }
-  /**
-   * Wraps an already-resolved `Result<T, E>` into a `ResultAsync<T, E>`.
-   *
-   * @param result - The result to wrap
-   */
-  static fromResult(result) {
-    return new _ResultAsync(Promise.resolve(result));
-  }
-  /**
-   * Transforms the success value.
-   *
-   * If the inner result is `Err`, `fn` is not called.
-   *
-   * @param fn - Synchronous mapper
-   */
-  map(fn) {
-    return new _ResultAsync(
-      // eslint-disable-next-line unicorn/no-array-callback-reference -- r.map(fn) is safe here; fn is a user-supplied mapper, not a DOM/Array method reference
-      this._promise.then((r) => r.map(fn))
-    );
-  }
-  /**
-   * Transforms the error value.
-   *
-   * If the inner result is `Ok`, `fn` is not called.
-   *
-   * @param fn - Synchronous error mapper
-   */
-  mapErr(fn) {
-    return new _ResultAsync(
-      this._promise.then((r) => r.mapErr(fn))
-    );
-  }
-  /**
-   * Chains another async operation that may fail.
-   *
-   * If the inner result is `Err`, `fn` is not called.
-   *
-   * @param fn - Async mapper that returns a `ResultAsync<U, F>`
-   */
-  andThen(fn) {
-    return new _ResultAsync(
-      this._promise.then(async (r) => {
-        if (r.isErr) return r;
-        const next = fn(r.value);
-        if (next instanceof _ResultAsync) {
-          return next._promise;
-        }
-        return next;
-      })
-    );
-  }
-  /**
-   * Pattern-matches on success / failure.
-   *
-   * @param onOk - Called with the success value
-   * @param onErr - Called with the error value
-   * @returns A `Promise<U>`
-   */
-  async match(onOk, onErr) {
-    const r = await this._promise;
-    if (r.isOk) return onOk(r.value);
-    return onErr(r.error);
-  }
-  /**
-   * Returns the success value, or `fallback` if the result is `Err`.
-   *
-   * @param fallback - The fallback value
-   */
-  async unwrapOr(fallback) {
-    const r = await this._promise;
-    if (r.isOk) return r.value;
-    return fallback;
-  }
+/**
+* A `PromiseLike<Result<T, E>>` that is directly `await`-able and supports
+* chainable `map / mapErr / andThen` operators.
+*
+* @example
+* ```ts
+* const result = await ResultAsync.fromPromise(fetch('/api'), networkError)
+*   .andThen((res) =>
+*     ResultAsync.fromPromise(res.json() as Promise<unknown>, networkError)
+*   )
+* ```
+*/
+var ResultAsync = class ResultAsync {
+	_promise;
+	constructor(promise) {
+		this._promise = promise;
+	}
+	then(onfulfilled, onrejected) {
+		return this._promise.then(onfulfilled, onrejected);
+	}
+	/**
+	* Wraps a `Promise<T>` into a `ResultAsync<T, E>`.
+	*
+	* If the promise rejects, `onError` maps the rejection reason to `E`.
+	*
+	* @param promise - The promise to wrap
+	* @param onError - Error mapper
+	*/
+	static fromPromise(promise, onError) {
+		return new ResultAsync(promise.then((v) => ok(v), (error) => err(onError(error))));
+	}
+	/**
+	* Wraps an already-resolved `Result<T, E>` into a `ResultAsync<T, E>`.
+	*
+	* @param result - The result to wrap
+	*/
+	static fromResult(result) {
+		return new ResultAsync(Promise.resolve(result));
+	}
+	/**
+	* Transforms the success value.
+	*
+	* If the inner result is `Err`, `fn` is not called.
+	*
+	* @param fn - Synchronous mapper
+	*/
+	map(fn) {
+		return new ResultAsync(this._promise.then((r) => r.map(fn)));
+	}
+	/**
+	* Transforms the error value.
+	*
+	* If the inner result is `Ok`, `fn` is not called.
+	*
+	* @param fn - Synchronous error mapper
+	*/
+	mapErr(fn) {
+		return new ResultAsync(this._promise.then((r) => r.mapErr(fn)));
+	}
+	/**
+	* Chains another async operation that may fail.
+	*
+	* If the inner result is `Err`, `fn` is not called.
+	*
+	* @param fn - Async mapper that returns a `ResultAsync<U, F>`
+	*/
+	andThen(fn) {
+		return new ResultAsync(this._promise.then(async (r) => {
+			if (r.isErr) return r;
+			const next = fn(r.value);
+			if (next instanceof ResultAsync) return next._promise;
+			return next;
+		}));
+	}
+	/**
+	* Pattern-matches on success / failure.
+	*
+	* @param onOk - Called with the success value
+	* @param onErr - Called with the error value
+	* @returns A `Promise<U>`
+	*/
+	async match(onOk, onErr) {
+		const r = await this._promise;
+		if (r.isOk) return onOk(r.value);
+		return onErr(r.error);
+	}
+	/**
+	* Returns the success value, or `fallback` if the result is `Err`.
+	*
+	* @param fallback - The fallback value
+	*/
+	async unwrapOr(fallback) {
+		const r = await this._promise;
+		if (r.isOk) return r.value;
+		return fallback;
+	}
 };
-
-// src/errors.ts
+//#endregion
+//#region src/errors.ts
+/**
+* An `Error` subclass that wraps a `PixivError` for use in thrown contexts
+* (e.g. async generators that must throw proper `Error` objects).
+*
+* All `PixivError` properties are spread directly onto this instance so that
+* callers can use `instanceof PixivFetchError` or access `error.type` etc.
+*
+* @example
+* ```ts
+* try {
+*   for await (const page of result.pages()) { ... }
+* } catch (e) {
+*   if (e instanceof PixivFetchError) {
+*     console.error(e.pixivError.type)
+*   }
+* }
+* ```
+*/
 var PixivFetchError = class extends Error {
-  /** The underlying structured `PixivError`. */
-  pixivError;
-  constructor(pixivError) {
-    super(`pixiv API error: ${pixivError.type}`);
-    this.name = "PixivFetchError";
-    this.pixivError = pixivError;
-    Object.assign(this, pixivError);
-  }
+	/** The underlying structured `PixivError`. */
+	pixivError;
+	constructor(pixivError) {
+		super(`pixiv API error: ${pixivError.type}`);
+		this.name = "PixivFetchError";
+		this.pixivError = pixivError;
+		Object.assign(this, pixivError);
+	}
 };
+/** Creates a rate-limit error. */
 function rateLimitError(retryAfter) {
-  return { type: "rate_limit", retryAfter };
+	return {
+		type: "rate_limit",
+		retryAfter
+	};
 }
+/** Creates an auth-failed error. */
 function authFailedError(status) {
-  return { type: "auth_failed", status };
+	return {
+		type: "auth_failed",
+		status
+	};
 }
+/** Creates a network error. */
 function networkError(cause) {
-  return { type: "network", cause };
+	return {
+		type: "network",
+		cause
+	};
 }
+/** Creates an API error. */
 function apiError(status, body) {
-  return { type: "api_error", status, body };
+	return {
+		type: "api_error",
+		status,
+		body
+	};
 }
-
-// src/paginated.ts
-var PaginatedResultAsync = class _PaginatedResultAsync extends ResultAsync {
-  #http;
-  #getItems;
-  constructor(promise, http, getItems) {
-    super(promise);
-    this.#http = http;
-    this.#getItems = getItems;
-  }
-  /**
-   * Creates a `PaginatedResultAsync` from a `ResultAsync`.
-   *
-   * @param inner - The first-page result
-   * @param http - HTTP client for fetching subsequent pages
-   * @param getItems - Extracts item array from a page
-   */
-  static fromResultAsync(inner, http, getItems) {
-    const promise = Promise.resolve(inner);
-    return new _PaginatedResultAsync(promise, http, getItems);
-  }
-  /**
-   * Async generator that yields each page starting from the first.
-   *
-   * If any page fetch fails, the generator throws a `PixivFetchError`.
-   *
-   * @example
-   * ```ts
-   * for await (const page of client.illusts.search({ word: 'cat' }).pages()) {
-   *   console.log(page.illusts.length)
-   * }
-   * ```
-   */
-  async *pages() {
-    const first = await Promise.resolve(this);
-    if (first.isErr) throw new PixivFetchError(first.error);
-    yield first.value;
-    let nextUrl = first.value.nextUrl;
-    while (nextUrl !== null) {
-      const pageResult = await this.#http.getAbsolute(nextUrl);
-      if (pageResult.isErr) throw new PixivFetchError(pageResult.error);
-      yield pageResult.value;
-      nextUrl = pageResult.value.nextUrl;
-    }
-  }
-  /**
-   * Async generator that yields individual items across all pages.
-   *
-   * If any page fetch fails, the generator throws a `PixivFetchError`.
-   *
-   * @example
-   * ```ts
-   * for await (const illust of client.illusts.search({ word: 'cat' }).items()) {
-   *   console.log(illust.title)
-   * }
-   * ```
-   */
-  async *items() {
-    for await (const page of this.pages()) {
-      for (const item of this.#getItems(page)) {
-        yield item;
-      }
-    }
-  }
+//#endregion
+//#region src/paginated.ts
+/**
+* A `ResultAsync<TPage, PixivError>` with additional `.pages()` / `.items()`
+* async generators for consuming paginated pixiv list responses.
+*
+* Returned by all resource methods that produce a `nextUrl` field.
+*/
+var PaginatedResultAsync = class PaginatedResultAsync extends ResultAsync {
+	#http;
+	#getItems;
+	constructor(promise, http, getItems) {
+		super(promise);
+		this.#http = http;
+		this.#getItems = getItems;
+	}
+	/**
+	* Creates a `PaginatedResultAsync` from a `ResultAsync`.
+	*
+	* @param inner - The first-page result
+	* @param http - HTTP client for fetching subsequent pages
+	* @param getItems - Extracts item array from a page
+	*/
+	static fromResultAsync(inner, http, getItems) {
+		return new PaginatedResultAsync(Promise.resolve(inner), http, getItems);
+	}
+	/**
+	* Async generator that yields each page starting from the first.
+	*
+	* If any page fetch fails, the generator throws a `PixivFetchError`.
+	*
+	* @example
+	* ```ts
+	* for await (const page of client.illusts.search({ word: 'cat' }).pages()) {
+	*   console.log(page.illusts.length)
+	* }
+	* ```
+	*/
+	async *pages() {
+		const first = await Promise.resolve(this);
+		if (first.isErr) throw new PixivFetchError(first.error);
+		yield first.value;
+		let nextUrl = first.value.nextUrl;
+		while (nextUrl !== null) {
+			const pageResult = await this.#http.getAbsolute(nextUrl);
+			if (pageResult.isErr) throw new PixivFetchError(pageResult.error);
+			yield pageResult.value;
+			nextUrl = pageResult.value.nextUrl;
+		}
+	}
+	/**
+	* Async generator that yields individual items across all pages.
+	*
+	* If any page fetch fails, the generator throws a `PixivFetchError`.
+	*
+	* @example
+	* ```ts
+	* for await (const illust of client.illusts.search({ word: 'cat' }).items()) {
+	*   console.log(illust.title)
+	* }
+	* ```
+	*/
+	async *items() {
+		for await (const page of this.pages()) for (const item of this.#getItems(page)) yield item;
+	}
 };
+/**
+* Creates an immediately-failed `PaginatedResultAsync`.
+*
+* Useful when validation or auth fails before any HTTP request is made.
+*
+* @param error - The error to return
+* @param http - HTTP client (used for signature compatibility)
+* @param getItems - Item extractor (used for signature compatibility)
+*/
 function failedPaginated(error, http, getItems) {
-  return new PaginatedResultAsync(
-    Promise.resolve(err(error)),
-    http,
-    getItems
-  );
+	return new PaginatedResultAsync(Promise.resolve(err(error)), http, getItems);
 }
-
-// src/params.ts
+//#endregion
+//#region src/params.ts
+/**
+* Parameter building utilities.
+*
+* Provides camelCase → snake_case conversion and a URLSearchParams builder
+* that replicates the behaviour of the `qs` library used in the legacy code
+* (without the `qs` runtime dependency).
+*/
+/**
+* Converts a camelCase string to snake_case.
+*
+* @example
+* camelToSnake('illustId')  // 'illust_id'
+* camelToSnake('searchAiType') // 'search_ai_type'
+*
+* @param key - camelCase string
+* @returns snake_case string
+*/
 function camelToSnake(key) {
-  return key.replaceAll(/([A-Z])/g, (m) => `_${m.toLowerCase()}`);
+	return key.replaceAll(/([A-Z])/g, (m) => `_${m.toLowerCase()}`);
 }
+/**
+* Converts all keys of a plain object from camelCase to snake_case, shallow.
+*
+* Values are preserved as-is; nested objects are NOT recursed into.
+*
+* @param obj - Object with camelCase keys
+* @returns New object with snake_case keys
+*/
 function toSnakeKeys(obj) {
-  const out = {};
-  for (const key of Object.keys(obj)) {
-    out[camelToSnake(key)] = obj[key];
-  }
-  return out;
+	const out = {};
+	for (const key of Object.keys(obj)) out[camelToSnake(key)] = obj[key];
+	return out;
 }
+/**
+* Serialises a record of query parameters into a `URLSearchParams` instance.
+*
+* Rules:
+* - `null` / `undefined` values are skipped.
+* - Arrays are appended with a `[]` suffix: `foo[]=1&foo[]=2` (Rails/pixiv convention).
+* - Booleans are serialised as `'true'` / `'false'`.
+* - Numbers are serialised via `.toString()`.
+*
+* @param params - Key/value pairs to serialise
+* @returns Populated `URLSearchParams`
+*/
 function buildSearchParams(params) {
-  const usp = new URLSearchParams();
-  for (const [key, value] of Object.entries(params)) {
-    if (value === null || value === void 0) continue;
-    if (Array.isArray(value)) {
-      for (const item of value) usp.append(`${key}[]`, String(item));
-    } else {
-      usp.set(key, String(value));
-    }
-  }
-  return usp;
+	const usp = new URLSearchParams();
+	for (const [key, value] of Object.entries(params)) {
+		if (value === null || value === void 0) continue;
+		if (Array.isArray(value)) for (const item of value) usp.append(`${key}[]`, String(item));
+		else usp.set(key, String(value));
+	}
+	return usp;
 }
+/**
+* Merges camelCase→snake_case conversion with URLSearchParams building.
+*
+* Convenience wrapper used by resource methods.
+*
+* @param params - camelCase record
+* @returns Populated `URLSearchParams` with snake_case keys
+*/
 function buildParams(params) {
-  return buildSearchParams(toSnakeKeys(params));
+	return buildSearchParams(toSnakeKeys(params));
 }
+/**
+* Converts a snake_case string to lowerCamelCase.
+*
+* Already-camelCase keys pass through unchanged (idempotent).
+*
+* @example
+* snakeToCamel('image_urls')   // 'imageUrls'
+* snakeToCamel('x_restrict')   // 'xRestrict'
+* snakeToCamel('imageUrls')    // 'imageUrls'  (no-op)
+*
+* @param key - snake_case string
+* @returns lowerCamelCase string
+*/
 function snakeToCamel(key) {
-  return key.replaceAll(/_([a-z0-9])/g, (_m, c) => c.toUpperCase());
+	return key.replaceAll(/_([a-z0-9])/g, (_m, c) => c.toUpperCase());
 }
+/**
+* Recursively converts all object keys from snake_case to lowerCamelCase.
+*
+* - Plain objects: keys are converted, values are recursed.
+* - Arrays: each element is recursed.
+* - Primitives / null: returned as-is.
+*
+* All keys are converted uniformly — no path-based exclusions.
+*
+* @param value - Any JSON-compatible value
+* @returns Deep copy with all object keys in lowerCamelCase
+*/
 function camelizeKeys(value) {
-  if (value === null || typeof value !== "object") return value;
-  if (Array.isArray(value)) return value.map((v) => camelizeKeys(v));
-  const out = {};
-  for (const [k, v] of Object.entries(value)) {
-    out[snakeToCamel(k)] = camelizeKeys(v);
-  }
-  return out;
+	if (value === null || typeof value !== "object") return value;
+	if (Array.isArray(value)) return value.map((v) => camelizeKeys(v));
+	const out = {};
+	for (const [k, v] of Object.entries(value)) out[snakeToCamel(k)] = camelizeKeys(v);
+	return out;
 }
+/**
+* Parses a pixiv `next_url` into a typed cursor object.
+*
+* Pass the `next_url` field from any paginated response to extract the
+* cursor parameters needed to resume pagination from a saved position.
+*
+* @example
+* ```ts
+* const page = await client.users.bookmarks.illusts({ userId: client.userId })
+* if (page.isOk && page.value.nextUrl) {
+*   const cursor = parseNextUrl(page.value.nextUrl)
+*   // Resume later:
+*   const next = await client.users.bookmarks.illusts({
+*     userId: client.userId,
+*     maxBookmarkId: cursor.maxBookmarkId,
+*   })
+* }
+* ```
+*
+* @param url - The `next_url` string returned by a pixiv list endpoint
+* @returns Typed cursor parameters; fields absent in the URL are `undefined`
+*/
 function parseNextUrl(url) {
-  const usp = new URL(url).searchParams;
-  const result = {};
-  const toNum = (key) => {
-    const v = usp.get(key);
-    if (v === null || v === "") return void 0;
-    const n = Number(v);
-    return Number.isNaN(n) ? void 0 : n;
-  };
-  const maxBookmarkId = toNum("max_bookmark_id");
-  if (maxBookmarkId !== void 0) result.maxBookmarkId = maxBookmarkId;
-  const maxBookmarkIdForRecommend = toNum("max_bookmark_id_for_recommend");
-  if (maxBookmarkIdForRecommend !== void 0)
-    result.maxBookmarkIdForRecommend = maxBookmarkIdForRecommend;
-  const minBookmarkIdForRecentIllust = toNum("min_bookmark_id_for_recent_illust");
-  if (minBookmarkIdForRecentIllust !== void 0)
-    result.minBookmarkIdForRecentIllust = minBookmarkIdForRecentIllust;
-  const offset = toNum("offset");
-  if (offset !== void 0) result.offset = offset;
-  const lastOrder = toNum("last_order");
-  if (lastOrder !== void 0) result.lastOrder = lastOrder;
-  return result;
+	const usp = new URL(url).searchParams;
+	const result = {};
+	const toNum = (key) => {
+		const v = usp.get(key);
+		if (v === null || v === "") return void 0;
+		const n = Number(v);
+		return Number.isNaN(n) ? void 0 : n;
+	};
+	const maxBookmarkId = toNum("max_bookmark_id");
+	if (maxBookmarkId !== void 0) result.maxBookmarkId = maxBookmarkId;
+	const maxBookmarkIdForRecommend = toNum("max_bookmark_id_for_recommend");
+	if (maxBookmarkIdForRecommend !== void 0) result.maxBookmarkIdForRecommend = maxBookmarkIdForRecommend;
+	const minBookmarkIdForRecentIllust = toNum("min_bookmark_id_for_recent_illust");
+	if (minBookmarkIdForRecentIllust !== void 0) result.minBookmarkIdForRecentIllust = minBookmarkIdForRecentIllust;
+	const offset = toNum("offset");
+	if (offset !== void 0) result.offset = offset;
+	const lastOrder = toNum("last_order");
+	if (lastOrder !== void 0) result.lastOrder = lastOrder;
+	return result;
 }
-
-// src/options.ts
-var SearchTarget = {
-  PARTIAL_MATCH_FOR_TAGS: "partial_match_for_tags",
-  EXACT_MATCH_FOR_TAGS: "exact_match_for_tags",
-  TITLE_AND_CAPTION: "title_and_caption",
-  KEYWORD: "keyword"
+//#endregion
+//#region src/options.ts
+/**
+* Public option constants for @book000/pixivts.
+*
+* Each option is exported as a runtime `const` object for enum-like access
+* (e.g. `BookmarkRestrict.PUBLIC`). Plain string literals are also accepted
+* wherever these values are used as parameters.
+*
+* @example
+* ```ts
+* // Enum-like usage
+* await client.illusts.bookmarkAdd({ illustId: 123, restrict: BookmarkRestrict.PUBLIC })
+*
+* // Plain string literal — also valid
+* await client.illusts.bookmarkAdd({ illustId: 123, restrict: 'public' })
+* ```
+*/
+/**
+* Search match target for illust / novel searches.
+*
+* - `partial_match_for_tags` — tags contain the word (default)
+* - `exact_match_for_tags` — tags exactly equal the word
+* - `title_and_caption` — title or caption contains the word
+* - `keyword` — general keyword search (novel only)
+*/
+const SearchTarget = {
+	PARTIAL_MATCH_FOR_TAGS: "partial_match_for_tags",
+	EXACT_MATCH_FOR_TAGS: "exact_match_for_tags",
+	TITLE_AND_CAPTION: "title_and_caption",
+	KEYWORD: "keyword"
 };
-var SearchSort = {
-  DATE_DESC: "date_desc",
-  DATE_ASC: "date_asc",
-  POPULAR_DESC: "popular_desc"
+/**
+* Sort order for search results.
+*
+* - `date_desc` — newest first (default)
+* - `date_asc` — oldest first
+* - `popular_desc` — most bookmarks first (premium only)
+*/
+const SearchSort = {
+	DATE_DESC: "date_desc",
+	DATE_ASC: "date_asc",
+	POPULAR_DESC: "popular_desc"
 };
-var SearchDuration = {
-  WITHIN_LAST_DAY: "within_last_day",
-  WITHIN_LAST_WEEK: "within_last_week",
-  WITHIN_LAST_MONTH: "within_last_month"
+/**
+* Date range filter for search results.
+*
+* - `within_last_day` — past 24 hours
+* - `within_last_week` — past 7 days
+* - `within_last_month` — past 30 days
+*/
+const SearchDuration = {
+	WITHIN_LAST_DAY: "within_last_day",
+	WITHIN_LAST_WEEK: "within_last_week",
+	WITHIN_LAST_MONTH: "within_last_month"
 };
-var RankingMode = {
-  DAY: "day",
-  DAY_MALE: "day_male",
-  DAY_FEMALE: "day_female",
-  WEEK_ORIGINAL: "week_original",
-  WEEK_ROOKIE: "week_rookie",
-  WEEK: "week",
-  MONTH: "month",
-  DAY_AI: "day_ai",
-  DAY_R18: "day_r18",
-  WEEK_R18: "week_r18",
-  DAY_MALE_R18: "day_male_r18",
-  DAY_FEMALE_R18: "day_female_r18",
-  DAY_R18_AI: "day_r18_ai"
+/**
+* Ranking mode for illust rankings.
+*
+* R-18 modes require a premium account with R-18 content enabled.
+*/
+const RankingMode = {
+	DAY: "day",
+	DAY_MALE: "day_male",
+	DAY_FEMALE: "day_female",
+	WEEK_ORIGINAL: "week_original",
+	WEEK_ROOKIE: "week_rookie",
+	WEEK: "week",
+	MONTH: "month",
+	DAY_AI: "day_ai",
+	DAY_R18: "day_r18",
+	WEEK_R18: "week_r18",
+	DAY_MALE_R18: "day_male_r18",
+	DAY_FEMALE_R18: "day_female_r18",
+	DAY_R18_AI: "day_r18_ai"
 };
-var NovelRankingMode = {
-  DAY: "day",
-  WEEK: "week",
-  DAY_MALE: "day_male",
-  DAY_FEMALE: "day_female",
-  WEEK_ROOKIE: "week_rookie",
-  DAY_R18: "day_r18",
-  WEEK_R18: "week_r18",
-  DAY_R18_AI: "day_r18_ai"
+/**
+* Ranking mode for novel rankings.
+*
+* R-18 modes require a premium account with R-18 content enabled.
+*/
+const NovelRankingMode = {
+	DAY: "day",
+	WEEK: "week",
+	DAY_MALE: "day_male",
+	DAY_FEMALE: "day_female",
+	WEEK_ROOKIE: "week_rookie",
+	DAY_R18: "day_r18",
+	WEEK_R18: "week_r18",
+	DAY_R18_AI: "day_r18_ai"
 };
-var BookmarkRestrict = {
-  PUBLIC: "public",
-  PRIVATE: "private"
+/**
+* Visibility restriction for bookmarks.
+*
+* - `public` — publicly visible (default)
+* - `private` — visible only to the owner
+*/
+const BookmarkRestrict = {
+	PUBLIC: "public",
+	PRIVATE: "private"
 };
-var FollowRestrict = {
-  PUBLIC: "public",
-  PRIVATE: "private"
+/**
+* Visibility restriction for follows.
+*
+* - `public` — publicly visible (default)
+* - `private` — visible only to the owner
+*/
+const FollowRestrict = {
+	PUBLIC: "public",
+	PRIVATE: "private"
 };
-var OSFilter = {
-  FOR_IOS: "for_ios",
-  FOR_ANDROID: "for_android"
+/**
+* OS filter used to request works compatible with the given platform.
+*
+* - `for_ios` — iOS-compatible works (default)
+* - `for_android` — Android-compatible works
+*/
+const OSFilter = {
+	FOR_IOS: "for_ios",
+	FOR_ANDROID: "for_android"
 };
-var UserIllustType = {
-  ILLUST: "illust",
-  MANGA: "manga"
+/**
+* Work type filter for user illust listings.
+*
+* - `illust` — illustrations only
+* - `manga` — manga only
+*/
+const UserIllustType = {
+	ILLUST: "illust",
+	MANGA: "manga"
 };
-
-// src/auth.ts
-var T = Array.from(
-  { length: 64 },
-  (_, i) => Math.floor(Math.abs(Math.sin(i + 1)) * 2 ** 32)
-);
-var S = [
-  7,
-  12,
-  17,
-  22,
-  7,
-  12,
-  17,
-  22,
-  7,
-  12,
-  17,
-  22,
-  7,
-  12,
-  17,
-  22,
-  5,
-  9,
-  14,
-  20,
-  5,
-  9,
-  14,
-  20,
-  5,
-  9,
-  14,
-  20,
-  5,
-  9,
-  14,
-  20,
-  4,
-  11,
-  16,
-  23,
-  4,
-  11,
-  16,
-  23,
-  4,
-  11,
-  16,
-  23,
-  4,
-  11,
-  16,
-  23,
-  6,
-  10,
-  15,
-  21,
-  6,
-  10,
-  15,
-  21,
-  6,
-  10,
-  15,
-  21,
-  6,
-  10,
-  15,
-  21
+//#endregion
+//#region src/auth.ts
+const T = Array.from({ length: 64 }, (_, i) => Math.floor(Math.abs(Math.sin(i + 1)) * 2 ** 32));
+const S = [
+	7,
+	12,
+	17,
+	22,
+	7,
+	12,
+	17,
+	22,
+	7,
+	12,
+	17,
+	22,
+	7,
+	12,
+	17,
+	22,
+	5,
+	9,
+	14,
+	20,
+	5,
+	9,
+	14,
+	20,
+	5,
+	9,
+	14,
+	20,
+	5,
+	9,
+	14,
+	20,
+	4,
+	11,
+	16,
+	23,
+	4,
+	11,
+	16,
+	23,
+	4,
+	11,
+	16,
+	23,
+	4,
+	11,
+	16,
+	23,
+	6,
+	10,
+	15,
+	21,
+	6,
+	10,
+	15,
+	21,
+	6,
+	10,
+	15,
+	21,
+	6,
+	10,
+	15,
+	21
 ];
 function md5Bytes(bytes) {
-  const len = bytes.length;
-  bytes.push(128);
-  while (bytes.length % 64 !== 56) bytes.push(0);
-  const bitLen = len * 8;
-  for (let i = 0; i < 8; i++) {
-    bytes.push(i < 4 ? bitLen >>> i * 8 & 255 : 0);
-  }
-  let a = 1732584193;
-  let b = 4023233417;
-  let c = 2562383102;
-  let d = 271733878;
-  for (let chunk = 0; chunk < bytes.length; chunk += 64) {
-    const M = [];
-    for (let w = 0; w < 16; w++) {
-      const off = chunk + w * 4;
-      M.push(
-        bytes[off] | bytes[off + 1] << 8 | bytes[off + 2] << 16 | bytes[off + 3] << 24
-      );
-    }
-    let aa = a;
-    let bb = b;
-    let cc = c;
-    let dd = d;
-    for (let i = 0; i < 64; i++) {
-      let f;
-      let g;
-      if (i < 16) {
-        f = bb & cc | ~bb & dd;
-        g = i;
-      } else if (i < 32) {
-        f = dd & bb | ~dd & cc;
-        g = (5 * i + 1) % 16;
-      } else if (i < 48) {
-        f = bb ^ cc ^ dd;
-        g = (3 * i + 5) % 16;
-      } else {
-        f = cc ^ (bb | ~dd);
-        g = 7 * i % 16;
-      }
-      const tmp = dd;
-      dd = cc;
-      cc = bb;
-      const sum = Math.trunc(aa + f + M[g] + T[i]);
-      const rotated = sum << S[i] | sum >>> 32 - S[i];
-      bb = Math.trunc(bb + rotated);
-      aa = tmp;
-    }
-    a = Math.trunc(a + aa);
-    b = Math.trunc(b + bb);
-    c = Math.trunc(c + cc);
-    d = Math.trunc(d + dd);
-  }
-  return [a, b, c, d].map(
-    (n) => [n & 255, n >>> 8 & 255, n >>> 16 & 255, n >>> 24 & 255].map((byte) => byte.toString(16).padStart(2, "0")).join("")
-  ).join("");
+	const len = bytes.length;
+	bytes.push(128);
+	while (bytes.length % 64 !== 56) bytes.push(0);
+	const bitLen = len * 8;
+	for (let i = 0; i < 8; i++) bytes.push(i < 4 ? bitLen >>> i * 8 & 255 : 0);
+	let a = 1732584193;
+	let b = 4023233417;
+	let c = 2562383102;
+	let d = 271733878;
+	for (let chunk = 0; chunk < bytes.length; chunk += 64) {
+		const M = [];
+		for (let w = 0; w < 16; w++) {
+			const off = chunk + w * 4;
+			M.push(bytes[off] | bytes[off + 1] << 8 | bytes[off + 2] << 16 | bytes[off + 3] << 24);
+		}
+		let aa = a;
+		let bb = b;
+		let cc = c;
+		let dd = d;
+		for (let i = 0; i < 64; i++) {
+			let f;
+			let g;
+			if (i < 16) {
+				f = bb & cc | ~bb & dd;
+				g = i;
+			} else if (i < 32) {
+				f = dd & bb | ~dd & cc;
+				g = (5 * i + 1) % 16;
+			} else if (i < 48) {
+				f = bb ^ cc ^ dd;
+				g = (3 * i + 5) % 16;
+			} else {
+				f = cc ^ (bb | ~dd);
+				g = 7 * i % 16;
+			}
+			const tmp = dd;
+			dd = cc;
+			cc = bb;
+			const sum = Math.trunc(aa + f + M[g] + T[i]);
+			const rotated = sum << S[i] | sum >>> 32 - S[i];
+			bb = Math.trunc(bb + rotated);
+			aa = tmp;
+		}
+		a = Math.trunc(a + aa);
+		b = Math.trunc(b + bb);
+		c = Math.trunc(c + cc);
+		d = Math.trunc(d + dd);
+	}
+	return [
+		a,
+		b,
+		c,
+		d
+	].map((n) => [
+		n & 255,
+		n >>> 8 & 255,
+		n >>> 16 & 255,
+		n >>> 24 & 255
+	].map((byte) => byte.toString(16).padStart(2, "0")).join("")).join("");
 }
+/**
+* Produces a hex-encoded MD5 digest of `input`.
+*
+* This is a minimal, spec-compliant implementation (RFC 1321) that avoids
+* any runtime platform dependency.
+*
+* @param input - UTF-8 string to hash
+* @returns Lowercase hex-encoded MD5 digest
+*/
 function md5(input) {
-  const bytes = [];
-  for (let i = 0; i < input.length; i++) {
-    const code = input.codePointAt(i) ?? 0;
-    if (code < 128) {
-      bytes.push(code);
-    } else if (code < 2048) {
-      bytes.push(192 | code >> 6, 128 | code & 63);
-    } else {
-      bytes.push(
-        224 | code >> 12,
-        128 | code >> 6 & 63,
-        128 | code & 63
-      );
-    }
-  }
-  return md5Bytes(bytes);
+	const bytes = [];
+	for (let i = 0; i < input.length; i++) {
+		const code = input.codePointAt(i) ?? 0;
+		if (code < 128) bytes.push(code);
+		else if (code < 2048) bytes.push(192 | code >> 6, 128 | code & 63);
+		else bytes.push(224 | code >> 12, 128 | code >> 6 & 63, 128 | code & 63);
+	}
+	return md5Bytes(bytes);
 }
-var CLIENT_ID = "MOBrBDS8blbauoSck0ZfDbtuzpyT";
-var CLIENT_SECRET = "lsACyCD94FhDUtGTXi3QzcFE2uU1hqtDaKeqrdwj";
-var HASH_SECRET = "28c1fdd170a5204386cb1313c7077b34f83e4aaf4aa829ce78c231e05b0bae2c";
-var AUTH_URL = "https://oauth.secure.pixiv.net/auth/token";
+const CLIENT_ID = "MOBrBDS8blbauoSck0ZfDbtuzpyT";
+const CLIENT_SECRET = "lsACyCD94FhDUtGTXi3QzcFE2uU1hqtDaKeqrdwj";
+const HASH_SECRET = "28c1fdd170a5204386cb1313c7077b34f83e4aaf4aa829ce78c231e05b0bae2c";
+const AUTH_URL = "https://oauth.secure.pixiv.net/auth/token";
+/** Builds the x-client-hash header value for a given UTC timestamp string. */
 function buildClientHash(localTime) {
-  return md5(localTime + HASH_SECRET);
+	return md5(localTime + HASH_SECRET);
 }
-var AuthManager = class _AuthManager {
-  #accessToken;
-  #refreshToken;
-  userId;
-  constructor(credentials) {
-    this.#accessToken = credentials.accessToken;
-    this.#refreshToken = credentials.refreshToken;
-    this.userId = credentials.userId;
-  }
-  /** Returns the current access token. */
-  get accessToken() {
-    return this.#accessToken;
-  }
-  /** Returns the current refresh token. */
-  get refreshToken() {
-    return this.#refreshToken;
-  }
-  /**
-   * Exchanges the stored refresh token for a fresh access token.
-   *
-   * Updates the internal credentials on success.
-   * Throws if the token endpoint returns a non-200 response.
-   */
-  async refresh() {
-    const localTime = (/* @__PURE__ */ new Date()).toISOString().replace(/Z$/, "+00:00");
-    const headers = {
-      "x-client-time": localTime,
-      "x-client-hash": buildClientHash(localTime),
-      "app-os": "ios",
-      "app-os-version": "16.4.1",
-      "user-agent": "PixivIOSApp/7.16.9 (iOS 16.4.1; iPad13,4)",
-      "Content-Type": "application/x-www-form-urlencoded"
-    };
-    const body = new URLSearchParams({
-      client_id: CLIENT_ID,
-      client_secret: CLIENT_SECRET,
-      get_secure_url: "1",
-      grant_type: "refresh_token",
-      refresh_token: this.#refreshToken
-    }).toString();
-    const response = await fetch(AUTH_URL, {
-      method: "POST",
-      headers,
-      body
-    });
-    if (response.status !== 200) {
-      throw new Error(
-        `Failed to refresh pixiv token: HTTP ${response.status}`
-      );
-    }
-    const data = await response.json();
-    this.#accessToken = data.response.access_token;
-    this.#refreshToken = data.response.refresh_token;
-    this.userId = data.user.id;
-  }
-  /**
-   * Creates an `AuthManager` by performing the initial token refresh.
-   *
-   * @param refreshToken - Pixiv refresh token
-   * @returns Initialized `AuthManager`
-   */
-  static async login(refreshToken) {
-    const manager = new _AuthManager({
-      userId: "",
-      accessToken: "",
-      refreshToken
-    });
-    await manager.refresh();
-    return manager;
-  }
+/**
+* Manages access tokens for the pixiv API.
+*
+* Holds the current access token and refresh token in memory.
+* The refresh() method exchanges the refresh token for a new access token
+* via the pixiv OAuth endpoint.
+*/
+var AuthManager = class AuthManager {
+	#accessToken;
+	#refreshToken;
+	userId;
+	constructor(credentials) {
+		this.#accessToken = credentials.accessToken;
+		this.#refreshToken = credentials.refreshToken;
+		this.userId = credentials.userId;
+	}
+	/** Returns the current access token. */
+	get accessToken() {
+		return this.#accessToken;
+	}
+	/** Returns the current refresh token. */
+	get refreshToken() {
+		return this.#refreshToken;
+	}
+	/**
+	* Exchanges the stored refresh token for a fresh access token.
+	*
+	* Updates the internal credentials on success.
+	* Throws if the token endpoint returns a non-200 response.
+	*/
+	async refresh() {
+		const localTime = (/* @__PURE__ */ new Date()).toISOString().replace(/Z$/, "+00:00");
+		const headers = {
+			"x-client-time": localTime,
+			"x-client-hash": buildClientHash(localTime),
+			"app-os": "ios",
+			"app-os-version": "16.4.1",
+			"user-agent": "PixivIOSApp/7.16.9 (iOS 16.4.1; iPad13,4)",
+			"Content-Type": "application/x-www-form-urlencoded"
+		};
+		const body = new URLSearchParams({
+			client_id: CLIENT_ID,
+			client_secret: CLIENT_SECRET,
+			get_secure_url: "1",
+			grant_type: "refresh_token",
+			refresh_token: this.#refreshToken
+		}).toString();
+		const response = await fetch(AUTH_URL, {
+			method: "POST",
+			headers,
+			body
+		});
+		if (response.status !== 200) throw new Error(`Failed to refresh pixiv token: HTTP ${response.status}`);
+		const data = await response.json();
+		this.#accessToken = data.response.access_token;
+		this.#refreshToken = data.response.refresh_token;
+		this.userId = data.user.id;
+	}
+	/**
+	* Creates an `AuthManager` by performing the initial token refresh.
+	*
+	* @param refreshToken - Pixiv refresh token
+	* @returns Initialized `AuthManager`
+	*/
+	static async login(refreshToken) {
+		const manager = new AuthManager({
+			userId: "",
+			accessToken: "",
+			refreshToken
+		});
+		await manager.refresh();
+		return manager;
+	}
 };
-
-// src/http.ts
-var DEFAULT_RETRY = { maxRetries: 3, waitMs: 1e4 };
-var BASE_URL = "https://app-api.pixiv.net";
-var DEFAULT_HEADERS = {
-  Host: "app-api.pixiv.net",
-  "App-OS": "ios",
-  "App-OS-Version": "14.6",
-  "User-Agent": "PixivIOSApp/7.13.3 (iOS 14.6; iPhone13,2)",
-  "Accept-Language": "ja"
+//#endregion
+//#region src/http.ts
+const DEFAULT_RETRY = {
+	maxRetries: 3,
+	waitMs: 1e4
 };
+const BASE_URL = "https://app-api.pixiv.net";
+const DEFAULT_HEADERS = {
+	Host: "app-api.pixiv.net",
+	"App-OS": "ios",
+	"App-OS-Version": "14.6",
+	"User-Agent": "PixivIOSApp/7.13.3 (iOS 14.6; iPhone13,2)",
+	"Accept-Language": "ja"
+};
+/**
+* Parses the `Retry-After` header value into milliseconds.
+*
+* Supports delay-seconds format and HTTP-date format.
+* Falls back to `defaultMs` if the header is absent or unparseable.
+*
+* @param retryAfter - Header value (null if not present)
+* @param defaultMs - Fallback wait time in milliseconds
+* @returns Wait time in milliseconds (clamped to ≥ 0)
+*/
 function parseRetryAfter(retryAfter, defaultMs) {
-  if (!retryAfter) return defaultMs;
-  if (/^\d+$/.test(retryAfter.trim())) {
-    return Number.parseInt(retryAfter, 10) * 1e3;
-  }
-  const retryDate = Date.parse(retryAfter);
-  if (!Number.isNaN(retryDate)) {
-    return Math.max(0, retryDate - Date.now());
-  }
-  return defaultMs;
+	if (!retryAfter) return defaultMs;
+	if (/^\d+$/.test(retryAfter.trim())) return Number.parseInt(retryAfter, 10) * 1e3;
+	const retryDate = Date.parse(retryAfter);
+	if (!Number.isNaN(retryDate)) return Math.max(0, retryDate - Date.now());
+	return defaultMs;
 }
 function headersToRecord(headers) {
-  const result = {};
-  for (const [key, value] of headers) {
-    result[key] = value;
-  }
-  return result;
+	const result = {};
+	for (const [key, value] of headers) result[key] = value;
+	return result;
 }
+/**
+* HTTP client for the pixiv API.
+*
+* All methods return `ResultAsync<T, PixivError>` — no throws.
+* A 429 → retry loop and a 401 → refresh → retry are handled internally.
+*/
 var HttpClient = class {
-  #auth;
-  #retry;
-  #interceptor;
-  constructor(auth, options) {
-    this.#auth = auth;
-    this.#retry = {
-      maxRetries: options?.retry?.maxRetries ?? DEFAULT_RETRY.maxRetries,
-      waitMs: options?.retry?.waitMs ?? DEFAULT_RETRY.waitMs
-    };
-    this.#interceptor = options?.onResponse;
-  }
-  /**
-   * Sends a GET request to the pixiv API.
-   *
-   * @param path - API endpoint path (e.g. "/v1/illust/detail")
-   * @param params - Query parameters as a URLSearchParams instance
-   * @returns `ResultAsync<T, PixivError>`
-   */
-  get(path, params) {
-    const qs = params ? `?${params.toString()}` : "";
-    const url = `${BASE_URL}${path}${qs}`;
-    return this.#send(url, "GET", path, void 0);
-  }
-  /**
-   * Sends a POST request to the pixiv API.
-   *
-   * @param path - API endpoint path (e.g. "/v2/illust/bookmark/add")
-   * @param body - URL-encoded request body string
-   * @returns `ResultAsync<T, PixivError>`
-   */
-  post(path, body) {
-    const url = `${BASE_URL}${path}`;
-    return this.#send(url, "POST", path, body);
-  }
-  /**
-   * Fetches a pixiv image URL without an Authorization header.
-   *
-   * Uses a browser User-Agent and the pixiv Referer, which are required for
-   * image CDN access. Retry and interceptor are not applied here.
-   *
-   * @param imageUrl - Full image URL
-   * @returns `ResultAsync<Response, PixivError>`
-   */
-  fetchImage(imageUrl) {
-    return ResultAsync.fromPromise(
-      fetch(imageUrl, {
-        headers: {
-          "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36",
-          Referer: "https://www.pixiv.net/"
-        }
-      }),
-      networkError
-    ).andThen((response) => {
-      if (!response.ok) {
-        return ResultAsync.fromResult(
-          err(apiError(response.status, null))
-        );
-      }
-      return ResultAsync.fromResult(ok(response));
-    });
-  }
-  /**
-   * Sends a request to an absolute URL returned in a `next_url` field.
-   *
-   * Applies the same retry / interceptor / auth logic as `get()`.
-   *
-   * @param absoluteUrl - Full URL including query string
-   * @returns `ResultAsync<T, PixivError>`
-   */
-  getAbsolute(absoluteUrl) {
-    let endpoint;
-    try {
-      endpoint = new URL(absoluteUrl).pathname;
-    } catch {
-      endpoint = absoluteUrl;
-    }
-    return this.#send(absoluteUrl, "GET", endpoint, void 0);
-  }
-  // ---------------------------------------------------------------------------
-  // Private helpers
-  // ---------------------------------------------------------------------------
-  #send(url, method, endpoint, body) {
-    return new ResultAsync(this.#sendWithRetry(url, method, endpoint, body));
-  }
-  async #sendWithRetry(url, method, endpoint, body, allowRefresh = true) {
-    const maxRetries = Math.max(0, this.#retry.maxRetries);
-    const waitMs = Math.max(0, this.#retry.waitMs);
-    let lastRetryAfterMs = 0;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      const requestHeaders = {
-        ...DEFAULT_HEADERS,
-        Authorization: `Bearer ${this.#auth.accessToken}`,
-        ...method === "POST" ? { "Content-Type": "application/x-www-form-urlencoded" } : {}
-      };
-      let response;
-      try {
-        response = await fetch(url, {
-          method,
-          headers: requestHeaders,
-          body: method === "POST" ? body : void 0
-        });
-      } catch (fetchError) {
-        return err(networkError(fetchError));
-      }
-      if (response.status === 429) {
-        await response.body?.cancel();
-        const retryAfterMs = parseRetryAfter(
-          response.headers.get("Retry-After"),
-          waitMs
-        );
-        lastRetryAfterMs = retryAfterMs;
-        if (attempt < maxRetries) {
-          await new Promise((resolve) => setTimeout(resolve, retryAfterMs));
-          continue;
-        }
-        return err(rateLimitError(lastRetryAfterMs));
-      }
-      if (response.status === 401) {
-        await response.body?.cancel();
-        if (allowRefresh) {
-          try {
-            await this.#auth.refresh();
-          } catch {
-            return err(authFailedError(401));
-          }
-          return this.#sendWithRetry(url, method, endpoint, body, false);
-        }
-        return err(authFailedError(401));
-      }
-      const contentType = response.headers.get("content-type") ?? "";
-      const text = await response.text();
-      let data;
-      const isJson = contentType.includes("application/json");
-      if (isJson) {
-        try {
-          data = camelizeKeys(JSON.parse(text));
-        } catch {
-          data = text;
-        }
-      } else {
-        data = text;
-      }
-      const responseHeaders = headersToRecord(response.headers);
-      if (!response.ok) {
-        return err(apiError(response.status, data));
-      }
-      const httpResponse = {
-        data,
-        status: response.status,
-        responseUrl: response.url || void 0};
-      if (this.#interceptor) {
-        const record = {
-          method,
-          endpoint,
-          url: response.url || url,
-          requestHeaders: JSON.stringify(requestHeaders),
-          requestBody: body ?? null,
-          responseType: isJson ? "JSON" : "TEXT",
-          statusCode: response.status,
-          responseHeaders: JSON.stringify(responseHeaders),
-          responseBody: text
-        };
-        Promise.resolve(this.#interceptor(record)).catch(() => void 0);
-      }
-      return ok(httpResponse.data);
-    }
-    return err(rateLimitError(lastRetryAfterMs));
-  }
+	#auth;
+	#retry;
+	#interceptor;
+	constructor(auth, options) {
+		this.#auth = auth;
+		this.#retry = {
+			maxRetries: options?.retry?.maxRetries ?? DEFAULT_RETRY.maxRetries,
+			waitMs: options?.retry?.waitMs ?? DEFAULT_RETRY.waitMs
+		};
+		this.#interceptor = options?.onResponse;
+	}
+	/**
+	* Sends a GET request to the pixiv API.
+	*
+	* @param path - API endpoint path (e.g. "/v1/illust/detail")
+	* @param params - Query parameters as a URLSearchParams instance
+	* @returns `ResultAsync<T, PixivError>`
+	*/
+	get(path, params) {
+		const url = `${BASE_URL}${path}${params ? `?${params.toString()}` : ""}`;
+		return this.#send(url, "GET", path, void 0);
+	}
+	/**
+	* Sends a POST request to the pixiv API.
+	*
+	* @param path - API endpoint path (e.g. "/v2/illust/bookmark/add")
+	* @param body - URL-encoded request body string
+	* @returns `ResultAsync<T, PixivError>`
+	*/
+	post(path, body) {
+		const url = `${BASE_URL}${path}`;
+		return this.#send(url, "POST", path, body);
+	}
+	/**
+	* Fetches a pixiv image URL without an Authorization header.
+	*
+	* Uses a browser User-Agent and the pixiv Referer, which are required for
+	* image CDN access. Retry and interceptor are not applied here.
+	*
+	* @param imageUrl - Full image URL
+	* @returns `ResultAsync<Response, PixivError>`
+	*/
+	fetchImage(imageUrl) {
+		return ResultAsync.fromPromise(fetch(imageUrl, { headers: {
+			"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36",
+			Referer: "https://www.pixiv.net/"
+		} }), networkError).andThen((response) => {
+			if (!response.ok) return ResultAsync.fromResult(err(apiError(response.status, null)));
+			return ResultAsync.fromResult(ok(response));
+		});
+	}
+	/**
+	* Sends a request to an absolute URL returned in a `next_url` field.
+	*
+	* Applies the same retry / interceptor / auth logic as `get()`.
+	*
+	* @param absoluteUrl - Full URL including query string
+	* @returns `ResultAsync<T, PixivError>`
+	*/
+	getAbsolute(absoluteUrl) {
+		let endpoint;
+		try {
+			endpoint = new URL(absoluteUrl).pathname;
+		} catch {
+			endpoint = absoluteUrl;
+		}
+		return this.#send(absoluteUrl, "GET", endpoint, void 0);
+	}
+	#send(url, method, endpoint, body) {
+		return new ResultAsync(this.#sendWithRetry(url, method, endpoint, body));
+	}
+	async #sendWithRetry(url, method, endpoint, body, allowRefresh = true) {
+		const maxRetries = Math.max(0, this.#retry.maxRetries);
+		const waitMs = Math.max(0, this.#retry.waitMs);
+		let lastRetryAfterMs = 0;
+		for (let attempt = 0; attempt <= maxRetries; attempt++) {
+			const requestHeaders = {
+				...DEFAULT_HEADERS,
+				Authorization: `Bearer ${this.#auth.accessToken}`,
+				...method === "POST" ? { "Content-Type": "application/x-www-form-urlencoded" } : {}
+			};
+			let response;
+			try {
+				response = await fetch(url, {
+					method,
+					headers: requestHeaders,
+					body: method === "POST" ? body : void 0
+				});
+			} catch (fetchError) {
+				return err(networkError(fetchError));
+			}
+			if (response.status === 429) {
+				await response.body?.cancel();
+				const retryAfterMs = parseRetryAfter(response.headers.get("Retry-After"), waitMs);
+				lastRetryAfterMs = retryAfterMs;
+				if (attempt < maxRetries) {
+					await new Promise((resolve) => setTimeout(resolve, retryAfterMs));
+					continue;
+				}
+				return err(rateLimitError(lastRetryAfterMs));
+			}
+			if (response.status === 401) {
+				await response.body?.cancel();
+				if (allowRefresh) {
+					try {
+						await this.#auth.refresh();
+					} catch {
+						return err(authFailedError(401));
+					}
+					return this.#sendWithRetry(url, method, endpoint, body, false);
+				}
+				return err(authFailedError(401));
+			}
+			const contentType = response.headers.get("content-type") ?? "";
+			const text = await response.text();
+			let data;
+			const isJson = contentType.includes("application/json");
+			if (isJson) try {
+				data = camelizeKeys(JSON.parse(text));
+			} catch {
+				data = text;
+			}
+			else data = text;
+			const responseHeaders = headersToRecord(response.headers);
+			if (!response.ok) return err(apiError(response.status, data));
+			const httpResponse = {
+				data,
+				status: response.status,
+				headers: responseHeaders,
+				requestHeaders,
+				requestBody: body ?? null,
+				responseUrl: response.url || void 0,
+				endpoint
+			};
+			if (this.#interceptor) {
+				const record = {
+					method,
+					endpoint,
+					url: response.url || url,
+					requestHeaders: JSON.stringify(requestHeaders),
+					requestBody: body ?? null,
+					responseType: isJson ? "JSON" : "TEXT",
+					statusCode: response.status,
+					responseHeaders: JSON.stringify(responseHeaders),
+					responseBody: text
+				};
+				Promise.resolve(this.#interceptor(record)).catch(() => void 0);
+			}
+			return ok(httpResponse.data);
+		}
+		return err(rateLimitError(lastRetryAfterMs));
+	}
 };
-
-// src/resources/illusts.ts
+//#endregion
+//#region src/resources/illusts.ts
+/** Methods for the illust API namespace. */
 var IllustResource = class {
-  #http;
-  constructor(http) {
-    this.#http = http;
-  }
-  /**
-   * Fetches a single illust by ID.
-   * GET /v1/illust/detail
-   *
-   * @param params - Request parameters
-   *
-   * @example
-   * ```ts
-   * const result = await client.illusts.detail({ illustId: 12345 })
-   * if (result.isOk) {
-   *   console.log(result.value.illust.title)
-   * } else {
-   *   console.error(result.error)
-   * }
-   * ```
-   */
-  detail(params) {
-    return this.#http.get(
-      "/v1/illust/detail",
-      buildParams({ illustId: params.illustId, filter: params.filter ?? "for_ios" })
-    );
-  }
-  /**
-   * Fetches related illusts for a given illust.
-   * GET /v2/illust/related
-   *
-   * @param params - Request parameters
-   */
-  related(params) {
-    return PaginatedResultAsync.fromResultAsync(
-      this.#http.get(
-        "/v2/illust/related",
-        buildParams({
-          illustId: params.illustId,
-          filter: params.filter ?? "for_ios",
-          ...params.seedIllustIds ? { seedIllustIds: params.seedIllustIds } : {}
-        })
-      ),
-      this.#http,
-      (page) => page.illusts
-    );
-  }
-  /**
-   * Searches for illusts.
-   * GET /v1/search/illust
-   *
-   * @param params - Request parameters
-   *
-   * @example
-   * ```ts
-   * // Iterate all results across pages
-   * for await (const illust of client.illusts.search({ word: 'cat' }).items()) {
-   *   console.log(illust.title)
-   * }
-   *
-   * // Fetch only the first page
-   * const page = await client.illusts.search({ word: 'cat' })
-   * if (page.isOk) {
-   *   console.log(page.value.illusts.length)
-   * }
-   * ```
-   */
-  search(params) {
-    return PaginatedResultAsync.fromResultAsync(
-      this.#http.get(
-        "/v1/search/illust",
-        buildParams({
-          word: params.word,
-          searchTarget: params.searchTarget ?? "partial_match_for_tags",
-          sort: params.sort ?? "date_desc",
-          filter: params.filter ?? "for_ios",
-          duration: params.duration,
-          startDate: params.startDate,
-          endDate: params.endDate,
-          searchAiType: params.searchAiType,
-          offset: params.offset
-        })
-      ),
-      this.#http,
-      (page) => page.illusts
-    );
-  }
-  /**
-   * Fetches the illust ranking.
-   * GET /v1/illust/ranking
-   *
-   * @param params - Request parameters
-   */
-  ranking(params = {}) {
-    return PaginatedResultAsync.fromResultAsync(
-      this.#http.get(
-        "/v1/illust/ranking",
-        buildParams({
-          mode: params.mode ?? "day",
-          filter: params.filter ?? "for_ios",
-          date: params.date,
-          offset: params.offset
-        })
-      ),
-      this.#http,
-      (page) => page.illusts
-    );
-  }
-  /**
-   * Fetches recommended illusts.
-   * GET /v1/illust/recommended
-   *
-   * @param params - Request parameters
-   */
-  recommended(params = {}) {
-    return PaginatedResultAsync.fromResultAsync(
-      this.#http.get(
-        "/v1/illust/recommended",
-        buildParams({
-          filter: params.filter ?? "for_ios",
-          includeRankingLabel: true,
-          includeRankingIllusts: true,
-          includePrivacyPolicy: true,
-          offset: params.offset,
-          maxBookmarkIdForRecommend: params.maxBookmarkIdForRecommend,
-          minBookmarkIdForRecentIllust: params.minBookmarkIdForRecentIllust
-        })
-      ),
-      this.#http,
-      (page) => page.illusts
-    );
-  }
-  /**
-   * Fetches an illust series.
-   * GET /v1/illust/series
-   *
-   * @param params - Request parameters
-   */
-  series(params) {
-    return PaginatedResultAsync.fromResultAsync(
-      this.#http.get(
-        "/v1/illust/series",
-        buildParams({
-          illustSeriesId: params.illustSeriesId,
-          filter: params.filter ?? "for_ios"
-        })
-      ),
-      this.#http,
-      (page) => page.illusts
-    );
-  }
-  /**
-   * Adds an illust bookmark.
-   * POST /v2/illust/bookmark/add
-   *
-   * @param params - Request parameters
-   */
-  bookmarkAdd(params) {
-    const body = buildParams({
-      illustId: params.illustId,
-      restrict: params.restrict ?? "public",
-      ...params.tags ? { tags: params.tags } : {}
-    });
-    return this.#http.post(
-      "/v2/illust/bookmark/add",
-      body.toString()
-    );
-  }
-  /**
-   * Removes an illust bookmark.
-   * POST /v1/illust/bookmark/delete
-   *
-   * @param params - Request parameters
-   */
-  bookmarkDelete(params) {
-    const body = buildParams({ illustId: String(params.illustId) });
-    return this.#http.post(
-      "/v1/illust/bookmark/delete",
-      body.toString()
-    );
-  }
+	#http;
+	constructor(http) {
+		this.#http = http;
+	}
+	/**
+	* Fetches a single illust by ID.
+	* GET /v1/illust/detail
+	*
+	* @param params - Request parameters
+	*
+	* @example
+	* ```ts
+	* const result = await client.illusts.detail({ illustId: 12345 })
+	* if (result.isOk) {
+	*   console.log(result.value.illust.title)
+	* } else {
+	*   console.error(result.error)
+	* }
+	* ```
+	*/
+	detail(params) {
+		return this.#http.get("/v1/illust/detail", buildParams({
+			illustId: params.illustId,
+			filter: params.filter ?? "for_ios"
+		}));
+	}
+	/**
+	* Fetches related illusts for a given illust.
+	* GET /v2/illust/related
+	*
+	* @param params - Request parameters
+	*/
+	related(params) {
+		return PaginatedResultAsync.fromResultAsync(this.#http.get("/v2/illust/related", buildParams({
+			illustId: params.illustId,
+			filter: params.filter ?? "for_ios",
+			...params.seedIllustIds ? { seedIllustIds: params.seedIllustIds } : {}
+		})), this.#http, (page) => page.illusts);
+	}
+	/**
+	* Searches for illusts.
+	* GET /v1/search/illust
+	*
+	* @param params - Request parameters
+	*
+	* @example
+	* ```ts
+	* // Iterate all results across pages
+	* for await (const illust of client.illusts.search({ word: 'cat' }).items()) {
+	*   console.log(illust.title)
+	* }
+	*
+	* // Fetch only the first page
+	* const page = await client.illusts.search({ word: 'cat' })
+	* if (page.isOk) {
+	*   console.log(page.value.illusts.length)
+	* }
+	* ```
+	*/
+	search(params) {
+		return PaginatedResultAsync.fromResultAsync(this.#http.get("/v1/search/illust", buildParams({
+			word: params.word,
+			searchTarget: params.searchTarget ?? "partial_match_for_tags",
+			sort: params.sort ?? "date_desc",
+			filter: params.filter ?? "for_ios",
+			duration: params.duration,
+			startDate: params.startDate,
+			endDate: params.endDate,
+			searchAiType: params.searchAiType,
+			offset: params.offset
+		})), this.#http, (page) => page.illusts);
+	}
+	/**
+	* Fetches the illust ranking.
+	* GET /v1/illust/ranking
+	*
+	* @param params - Request parameters
+	*/
+	ranking(params = {}) {
+		return PaginatedResultAsync.fromResultAsync(this.#http.get("/v1/illust/ranking", buildParams({
+			mode: params.mode ?? "day",
+			filter: params.filter ?? "for_ios",
+			date: params.date,
+			offset: params.offset
+		})), this.#http, (page) => page.illusts);
+	}
+	/**
+	* Fetches recommended illusts.
+	* GET /v1/illust/recommended
+	*
+	* @param params - Request parameters
+	*/
+	recommended(params = {}) {
+		return PaginatedResultAsync.fromResultAsync(this.#http.get("/v1/illust/recommended", buildParams({
+			filter: params.filter ?? "for_ios",
+			includeRankingLabel: true,
+			includeRankingIllusts: true,
+			includePrivacyPolicy: true,
+			offset: params.offset,
+			maxBookmarkIdForRecommend: params.maxBookmarkIdForRecommend,
+			minBookmarkIdForRecentIllust: params.minBookmarkIdForRecentIllust
+		})), this.#http, (page) => page.illusts);
+	}
+	/**
+	* Fetches an illust series.
+	* GET /v1/illust/series
+	*
+	* @param params - Request parameters
+	*/
+	series(params) {
+		return PaginatedResultAsync.fromResultAsync(this.#http.get("/v1/illust/series", buildParams({
+			illustSeriesId: params.illustSeriesId,
+			filter: params.filter ?? "for_ios"
+		})), this.#http, (page) => page.illusts);
+	}
+	/**
+	* Adds an illust bookmark.
+	* POST /v2/illust/bookmark/add
+	*
+	* @param params - Request parameters
+	*/
+	bookmarkAdd(params) {
+		const body = buildParams({
+			illustId: params.illustId,
+			restrict: params.restrict ?? "public",
+			...params.tags ? { tags: params.tags } : {}
+		});
+		return this.#http.post("/v2/illust/bookmark/add", body.toString());
+	}
+	/**
+	* Removes an illust bookmark.
+	* POST /v1/illust/bookmark/delete
+	*
+	* @param params - Request parameters
+	*/
+	bookmarkDelete(params) {
+		const body = buildParams({ illustId: String(params.illustId) });
+		return this.#http.post("/v1/illust/bookmark/delete", body.toString());
+	}
 };
-
-// src/resources/novels.ts
+//#endregion
+//#region src/resources/novels.ts
+/** Methods for the novel API namespace. */
 var NovelResource = class {
-  #http;
-  constructor(http) {
-    this.#http = http;
-  }
-  /**
-   * Fetches a single novel by ID.
-   * GET /v2/novel/detail
-   *
-   * @param params - Request parameters
-   *
-   * @example
-   * ```ts
-   * const result = await client.novels.detail({ novelId: 67890 })
-   * if (result.isOk) {
-   *   console.log(result.value.novel.title)
-   * } else {
-   *   console.error(result.error)
-   * }
-   * ```
-   */
-  detail(params) {
-    return this.#http.get(
-      "/v2/novel/detail",
-      buildParams({ novelId: params.novelId })
-    );
-  }
-  /**
-   * Fetches the WebView HTML for a novel.
-   * GET /webview/v2/novel
-   *
-   * Returns the raw HTML page that the pixiv app renders in a WebView.
-   * To extract the plain text, parse the returned HTML (e.g. strip tags).
-   *
-   * @param params - Request parameters
-   */
-  text(params) {
-    return this.#http.get(
-      "/webview/v2/novel",
-      // The webview endpoint uses the query parameter 'id', not 'novel_id'
-      buildParams({ id: params.novelId })
-    );
-  }
-  /**
-   * Fetches related novels for a given novel.
-   * GET /v1/novel/related
-   *
-   * @param params - Request parameters
-   */
-  related(params) {
-    return PaginatedResultAsync.fromResultAsync(
-      this.#http.get(
-        "/v1/novel/related",
-        buildParams({ novelId: params.novelId })
-      ),
-      this.#http,
-      (page) => page.novels
-    );
-  }
-  /**
-   * Searches for novels.
-   * GET /v1/search/novel
-   *
-   * @param params - Request parameters
-   *
-   * @example
-   * ```ts
-   * // Iterate all results across pages
-   * for await (const novel of client.novels.search({ word: 'fantasy' }).items()) {
-   *   console.log(novel.title)
-   * }
-   *
-   * // Fetch only the first page
-   * const page = await client.novels.search({ word: 'fantasy' })
-   * if (page.isOk) {
-   *   console.log(page.value.novels.length)
-   * }
-   * ```
-   */
-  search(params) {
-    return PaginatedResultAsync.fromResultAsync(
-      this.#http.get(
-        "/v1/search/novel",
-        buildParams({
-          word: params.word,
-          searchTarget: params.searchTarget ?? "partial_match_for_tags",
-          sort: params.sort ?? "date_desc",
-          filter: params.filter ?? "for_ios",
-          duration: params.duration,
-          startDate: params.startDate,
-          endDate: params.endDate,
-          searchAiType: params.searchAiType,
-          offset: params.offset
-        })
-      ),
-      this.#http,
-      (page) => page.novels
-    );
-  }
-  /**
-   * Fetches the novel ranking.
-   * GET /v1/novel/ranking
-   *
-   * @param params - Request parameters
-   */
-  ranking(params = {}) {
-    return PaginatedResultAsync.fromResultAsync(
-      this.#http.get(
-        "/v1/novel/ranking",
-        buildParams({
-          mode: params.mode ?? "day",
-          filter: params.filter ?? "for_ios",
-          date: params.date,
-          offset: params.offset
-        })
-      ),
-      this.#http,
-      (page) => page.novels
-    );
-  }
-  /**
-   * Fetches recommended novels.
-   * GET /v1/novel/recommended
-   *
-   * @param params - Request parameters
-   */
-  recommended(params = {}) {
-    return PaginatedResultAsync.fromResultAsync(
-      this.#http.get(
-        "/v1/novel/recommended",
-        buildParams({
-          filter: params.filter ?? "for_ios",
-          includeRankingNovels: true,
-          includePrivacyPolicy: true,
-          offset: params.offset,
-          maxBookmarkIdForRecommend: params.maxBookmarkIdForRecommend
-        })
-      ),
-      this.#http,
-      (page) => page.novels
-    );
-  }
-  /**
-   * Fetches a novel series.
-   * GET /v2/novel/series
-   *
-   * @param params - Request parameters
-   */
-  series(params) {
-    return PaginatedResultAsync.fromResultAsync(
-      this.#http.get(
-        "/v2/novel/series",
-        buildParams({ seriesId: params.seriesId, lastOrder: params.lastOrder })
-      ),
-      this.#http,
-      (page) => page.novels
-    );
-  }
-  /**
-   * Adds a novel bookmark.
-   * POST /v2/novel/bookmark/add
-   *
-   * @param params - Request parameters
-   */
-  bookmarkAdd(params) {
-    const body = buildParams({
-      novelId: params.novelId,
-      restrict: params.restrict ?? "public",
-      ...params.tags ? { tags: params.tags } : {}
-    });
-    return this.#http.post(
-      "/v2/novel/bookmark/add",
-      body.toString()
-    );
-  }
-  /**
-   * Removes a novel bookmark.
-   * POST /v1/novel/bookmark/delete
-   *
-   * @param params - Request parameters
-   */
-  bookmarkDelete(params) {
-    const body = buildParams({ novelId: String(params.novelId) });
-    return this.#http.post(
-      "/v1/novel/bookmark/delete",
-      body.toString()
-    );
-  }
+	#http;
+	constructor(http) {
+		this.#http = http;
+	}
+	/**
+	* Fetches a single novel by ID.
+	* GET /v2/novel/detail
+	*
+	* @param params - Request parameters
+	*
+	* @example
+	* ```ts
+	* const result = await client.novels.detail({ novelId: 67890 })
+	* if (result.isOk) {
+	*   console.log(result.value.novel.title)
+	* } else {
+	*   console.error(result.error)
+	* }
+	* ```
+	*/
+	detail(params) {
+		return this.#http.get("/v2/novel/detail", buildParams({ novelId: params.novelId }));
+	}
+	/**
+	* Fetches the WebView HTML for a novel.
+	* GET /webview/v2/novel
+	*
+	* Returns the raw HTML page that the pixiv app renders in a WebView.
+	* To extract the plain text, parse the returned HTML (e.g. strip tags).
+	*
+	* @param params - Request parameters
+	*/
+	text(params) {
+		return this.#http.get("/webview/v2/novel", buildParams({ id: params.novelId }));
+	}
+	/**
+	* Fetches related novels for a given novel.
+	* GET /v1/novel/related
+	*
+	* @param params - Request parameters
+	*/
+	related(params) {
+		return PaginatedResultAsync.fromResultAsync(this.#http.get("/v1/novel/related", buildParams({ novelId: params.novelId })), this.#http, (page) => page.novels);
+	}
+	/**
+	* Searches for novels.
+	* GET /v1/search/novel
+	*
+	* @param params - Request parameters
+	*
+	* @example
+	* ```ts
+	* // Iterate all results across pages
+	* for await (const novel of client.novels.search({ word: 'fantasy' }).items()) {
+	*   console.log(novel.title)
+	* }
+	*
+	* // Fetch only the first page
+	* const page = await client.novels.search({ word: 'fantasy' })
+	* if (page.isOk) {
+	*   console.log(page.value.novels.length)
+	* }
+	* ```
+	*/
+	search(params) {
+		return PaginatedResultAsync.fromResultAsync(this.#http.get("/v1/search/novel", buildParams({
+			word: params.word,
+			searchTarget: params.searchTarget ?? "partial_match_for_tags",
+			sort: params.sort ?? "date_desc",
+			filter: params.filter ?? "for_ios",
+			duration: params.duration,
+			startDate: params.startDate,
+			endDate: params.endDate,
+			searchAiType: params.searchAiType,
+			offset: params.offset
+		})), this.#http, (page) => page.novels);
+	}
+	/**
+	* Fetches the novel ranking.
+	* GET /v1/novel/ranking
+	*
+	* @param params - Request parameters
+	*/
+	ranking(params = {}) {
+		return PaginatedResultAsync.fromResultAsync(this.#http.get("/v1/novel/ranking", buildParams({
+			mode: params.mode ?? "day",
+			filter: params.filter ?? "for_ios",
+			date: params.date,
+			offset: params.offset
+		})), this.#http, (page) => page.novels);
+	}
+	/**
+	* Fetches recommended novels.
+	* GET /v1/novel/recommended
+	*
+	* @param params - Request parameters
+	*/
+	recommended(params = {}) {
+		return PaginatedResultAsync.fromResultAsync(this.#http.get("/v1/novel/recommended", buildParams({
+			filter: params.filter ?? "for_ios",
+			includeRankingNovels: true,
+			includePrivacyPolicy: true,
+			offset: params.offset,
+			maxBookmarkIdForRecommend: params.maxBookmarkIdForRecommend
+		})), this.#http, (page) => page.novels);
+	}
+	/**
+	* Fetches a novel series.
+	* GET /v2/novel/series
+	*
+	* @param params - Request parameters
+	*/
+	series(params) {
+		return PaginatedResultAsync.fromResultAsync(this.#http.get("/v2/novel/series", buildParams({
+			seriesId: params.seriesId,
+			lastOrder: params.lastOrder
+		})), this.#http, (page) => page.novels);
+	}
+	/**
+	* Adds a novel bookmark.
+	* POST /v2/novel/bookmark/add
+	*
+	* @param params - Request parameters
+	*/
+	bookmarkAdd(params) {
+		const body = buildParams({
+			novelId: params.novelId,
+			restrict: params.restrict ?? "public",
+			...params.tags ? { tags: params.tags } : {}
+		});
+		return this.#http.post("/v2/novel/bookmark/add", body.toString());
+	}
+	/**
+	* Removes a novel bookmark.
+	* POST /v1/novel/bookmark/delete
+	*
+	* @param params - Request parameters
+	*/
+	bookmarkDelete(params) {
+		const body = buildParams({ novelId: String(params.novelId) });
+		return this.#http.post("/v1/novel/bookmark/delete", body.toString());
+	}
 };
-
-// src/resources/users.ts
+//#endregion
+//#region src/resources/users.ts
+/** Methods for the user bookmarks sub-namespace. */
 var UserBookmarksResource = class {
-  #http;
-  constructor(http) {
-    this.#http = http;
-  }
-  /**
-   * Fetches a user's bookmarked illusts.
-   * GET /v1/user/bookmarks/illust
-   *
-   * @param params - Request parameters
-   *
-   * @example
-   * ```ts
-   * // Iterate all bookmarked illusts across pages
-   * for await (const illust of client.users.bookmarks.illusts({ userId: client.userId }).items()) {
-   *   console.log(illust.title)
-   * }
-   *
-   * // Resume from a saved cursor
-   * import { parseNextUrl } from '@book000/pixivts'
-   * const page = await client.users.bookmarks.illusts({ userId: client.userId })
-   * if (page.isOk && page.value.nextUrl) {
-   *   const cursor = parseNextUrl(page.value.nextUrl)
-   *   const next = await client.users.bookmarks.illusts({
-   *     userId: client.userId,
-   *     maxBookmarkId: cursor.maxBookmarkId,
-   *   })
-   * }
-   * ```
-   */
-  illusts(params) {
-    return PaginatedResultAsync.fromResultAsync(
-      this.#http.get(
-        "/v1/user/bookmarks/illust",
-        buildParams({
-          userId: params.userId,
-          restrict: params.restrict ?? "public",
-          filter: params.filter ?? "for_ios",
-          tag: params.tag,
-          maxBookmarkId: params.maxBookmarkId,
-          offset: params.offset
-        })
-      ),
-      this.#http,
-      (page) => page.illusts
-    );
-  }
-  /**
-   * Fetches a user's bookmarked novels.
-   * GET /v1/user/bookmarks/novel
-   *
-   * @param params - Request parameters
-   *
-   * @example
-   * ```ts
-   * // Iterate all bookmarked novels across pages
-   * for await (const novel of client.users.bookmarks.novels({ userId: client.userId }).items()) {
-   *   console.log(novel.title)
-   * }
-   * ```
-   */
-  novels(params) {
-    return PaginatedResultAsync.fromResultAsync(
-      this.#http.get(
-        "/v1/user/bookmarks/novel",
-        buildParams({
-          userId: params.userId,
-          restrict: params.restrict ?? "public",
-          filter: params.filter ?? "for_ios",
-          tag: params.tag,
-          maxBookmarkId: params.maxBookmarkId,
-          offset: params.offset
-        })
-      ),
-      this.#http,
-      (page) => page.novels
-    );
-  }
+	#http;
+	constructor(http) {
+		this.#http = http;
+	}
+	/**
+	* Fetches a user's bookmarked illusts.
+	* GET /v1/user/bookmarks/illust
+	*
+	* @param params - Request parameters
+	*
+	* @example
+	* ```ts
+	* // Iterate all bookmarked illusts across pages
+	* for await (const illust of client.users.bookmarks.illusts({ userId: client.userId }).items()) {
+	*   console.log(illust.title)
+	* }
+	*
+	* // Resume from a saved cursor
+	* import { parseNextUrl } from '@book000/pixivts'
+	* const page = await client.users.bookmarks.illusts({ userId: client.userId })
+	* if (page.isOk && page.value.nextUrl) {
+	*   const cursor = parseNextUrl(page.value.nextUrl)
+	*   const next = await client.users.bookmarks.illusts({
+	*     userId: client.userId,
+	*     maxBookmarkId: cursor.maxBookmarkId,
+	*   })
+	* }
+	* ```
+	*/
+	illusts(params) {
+		return PaginatedResultAsync.fromResultAsync(this.#http.get("/v1/user/bookmarks/illust", buildParams({
+			userId: params.userId,
+			restrict: params.restrict ?? "public",
+			filter: params.filter ?? "for_ios",
+			tag: params.tag,
+			maxBookmarkId: params.maxBookmarkId,
+			offset: params.offset
+		})), this.#http, (page) => page.illusts);
+	}
+	/**
+	* Fetches a user's bookmarked novels.
+	* GET /v1/user/bookmarks/novel
+	*
+	* @param params - Request parameters
+	*
+	* @example
+	* ```ts
+	* // Iterate all bookmarked novels across pages
+	* for await (const novel of client.users.bookmarks.novels({ userId: client.userId }).items()) {
+	*   console.log(novel.title)
+	* }
+	* ```
+	*/
+	novels(params) {
+		return PaginatedResultAsync.fromResultAsync(this.#http.get("/v1/user/bookmarks/novel", buildParams({
+			userId: params.userId,
+			restrict: params.restrict ?? "public",
+			filter: params.filter ?? "for_ios",
+			tag: params.tag,
+			maxBookmarkId: params.maxBookmarkId,
+			offset: params.offset
+		})), this.#http, (page) => page.novels);
+	}
 };
+/** Methods for the user API namespace. */
 var UserResource = class {
-  /** User bookmarks sub-namespace. */
-  bookmarks;
-  #http;
-  constructor(http) {
-    this.#http = http;
-    this.bookmarks = new UserBookmarksResource(http);
-  }
-  /**
-   * Fetches detailed profile information for a user.
-   * GET /v1/user/detail
-   *
-   * @param params - Request parameters
-   */
-  detail(params) {
-    return this.#http.get(
-      "/v1/user/detail",
-      buildParams({ userId: params.userId, filter: params.filter ?? "for_ios" })
-    );
-  }
-  /**
-   * Fetches illusts posted by a user.
-   * GET /v1/user/illusts
-   *
-   * @param params - Request parameters
-   */
-  illusts(params) {
-    return PaginatedResultAsync.fromResultAsync(
-      this.#http.get(
-        "/v1/user/illusts",
-        buildParams({
-          userId: params.userId,
-          type: params.type,
-          filter: params.filter ?? "for_ios",
-          offset: params.offset
-        })
-      ),
-      this.#http,
-      (page) => page.illusts
-    );
-  }
-  /**
-   * Fetches novels posted by a user.
-   * GET /v1/user/novels
-   *
-   * @param params - Request parameters
-   */
-  novels(params) {
-    return PaginatedResultAsync.fromResultAsync(
-      this.#http.get(
-        "/v1/user/novels",
-        buildParams({
-          userId: params.userId,
-          filter: params.filter ?? "for_ios",
-          offset: params.offset
-        })
-      ),
-      this.#http,
-      (page) => page.novels
-    );
-  }
-  /**
-   * Fetches the list of users that a user is following.
-   * GET /v1/user/following
-   *
-   * @param params - Request parameters
-   */
-  following(params) {
-    return PaginatedResultAsync.fromResultAsync(
-      this.#http.get(
-        "/v1/user/following",
-        buildParams({
-          userId: params.userId,
-          restrict: params.restrict ?? "public",
-          offset: params.offset
-        })
-      ),
-      this.#http,
-      (page) => page.userPreviews
-    );
-  }
-  /**
-   * Follows a user.
-   * POST /v1/user/follow/add
-   *
-   * @param params - Request parameters
-   */
-  followAdd(params) {
-    const body = buildParams({
-      userId: params.userId,
-      restrict: params.restrict ?? "public"
-    });
-    return this.#http.post(
-      "/v1/user/follow/add",
-      body.toString()
-    );
-  }
-  /**
-   * Unfollows a user.
-   * POST /v1/user/follow/delete
-   *
-   * @param params - Request parameters
-   */
-  followDelete(params) {
-    const body = buildParams({ userId: String(params.userId) });
-    return this.#http.post(
-      "/v1/user/follow/delete",
-      body.toString()
-    );
-  }
+	/** User bookmarks sub-namespace. */
+	bookmarks;
+	#http;
+	constructor(http) {
+		this.#http = http;
+		this.bookmarks = new UserBookmarksResource(http);
+	}
+	/**
+	* Fetches detailed profile information for a user.
+	* GET /v1/user/detail
+	*
+	* @param params - Request parameters
+	*/
+	detail(params) {
+		return this.#http.get("/v1/user/detail", buildParams({
+			userId: params.userId,
+			filter: params.filter ?? "for_ios"
+		}));
+	}
+	/**
+	* Fetches illusts posted by a user.
+	* GET /v1/user/illusts
+	*
+	* @param params - Request parameters
+	*/
+	illusts(params) {
+		return PaginatedResultAsync.fromResultAsync(this.#http.get("/v1/user/illusts", buildParams({
+			userId: params.userId,
+			type: params.type,
+			filter: params.filter ?? "for_ios",
+			offset: params.offset
+		})), this.#http, (page) => page.illusts);
+	}
+	/**
+	* Fetches novels posted by a user.
+	* GET /v1/user/novels
+	*
+	* @param params - Request parameters
+	*/
+	novels(params) {
+		return PaginatedResultAsync.fromResultAsync(this.#http.get("/v1/user/novels", buildParams({
+			userId: params.userId,
+			filter: params.filter ?? "for_ios",
+			offset: params.offset
+		})), this.#http, (page) => page.novels);
+	}
+	/**
+	* Fetches the list of users that a user is following.
+	* GET /v1/user/following
+	*
+	* @param params - Request parameters
+	*/
+	following(params) {
+		return PaginatedResultAsync.fromResultAsync(this.#http.get("/v1/user/following", buildParams({
+			userId: params.userId,
+			restrict: params.restrict ?? "public",
+			offset: params.offset
+		})), this.#http, (page) => page.userPreviews);
+	}
+	/**
+	* Follows a user.
+	* POST /v1/user/follow/add
+	*
+	* @param params - Request parameters
+	*/
+	followAdd(params) {
+		const body = buildParams({
+			userId: params.userId,
+			restrict: params.restrict ?? "public"
+		});
+		return this.#http.post("/v1/user/follow/add", body.toString());
+	}
+	/**
+	* Unfollows a user.
+	* POST /v1/user/follow/delete
+	*
+	* @param params - Request parameters
+	*/
+	followDelete(params) {
+		const body = buildParams({ userId: String(params.userId) });
+		return this.#http.post("/v1/user/follow/delete", body.toString());
+	}
 };
-
-// src/resources/manga.ts
+//#endregion
+//#region src/resources/manga.ts
+/** Methods for the manga API namespace. */
 var MangaResource = class {
-  #http;
-  constructor(http) {
-    this.#http = http;
-  }
-  /**
-   * Fetches recommended manga.
-   * GET /v1/manga/recommended
-   *
-   * @param params - Request parameters
-   */
-  recommended(params = {}) {
-    return PaginatedResultAsync.fromResultAsync(
-      this.#http.get(
-        "/v1/manga/recommended",
-        buildParams({
-          filter: params.filter ?? "for_ios",
-          includeRankingIllusts: true,
-          includePrivacyPolicy: true,
-          offset: params.offset
-        })
-      ),
-      this.#http,
-      (page) => page.illusts
-    );
-  }
+	#http;
+	constructor(http) {
+		this.#http = http;
+	}
+	/**
+	* Fetches recommended manga.
+	* GET /v1/manga/recommended
+	*
+	* @param params - Request parameters
+	*/
+	recommended(params = {}) {
+		return PaginatedResultAsync.fromResultAsync(this.#http.get("/v1/manga/recommended", buildParams({
+			filter: params.filter ?? "for_ios",
+			includeRankingIllusts: true,
+			includePrivacyPolicy: true,
+			offset: params.offset
+		})), this.#http, (page) => page.illusts);
+	}
 };
-
-// src/resources/ugoira.ts
+//#endregion
+//#region src/resources/ugoira.ts
+/** Methods for the ugoira API namespace. */
 var UgoiraResource = class {
-  #http;
-  constructor(http) {
-    this.#http = http;
-  }
-  /**
-   * Fetches ugoira metadata (ZIP URL and per-frame timings).
-   * GET /v1/ugoira/metadata
-   *
-   * @param params - Request parameters
-   */
-  metadata(params) {
-    return this.#http.get(
-      "/v1/ugoira/metadata",
-      buildParams({ illustId: params.illustId })
-    );
-  }
+	#http;
+	constructor(http) {
+		this.#http = http;
+	}
+	/**
+	* Fetches ugoira metadata (ZIP URL and per-frame timings).
+	* GET /v1/ugoira/metadata
+	*
+	* @param params - Request parameters
+	*/
+	metadata(params) {
+		return this.#http.get("/v1/ugoira/metadata", buildParams({ illustId: params.illustId }));
+	}
 };
-
-// src/resources/images.ts
+//#endregion
+//#region src/resources/images.ts
+/** Methods for fetching pixiv images. */
 var ImageResource = class {
-  #http;
-  constructor(http) {
-    this.#http = http;
-  }
-  /**
-   * Fetches a pixiv image.
-   *
-   * Uses a browser User-Agent and Referer (required for pixiv CDN).
-   * No Authorization header is sent.
-   *
-   * @param imageUrl - Full CDN image URL
-   */
-  fetch(imageUrl) {
-    return this.#http.fetchImage(imageUrl);
-  }
+	#http;
+	constructor(http) {
+		this.#http = http;
+	}
+	/**
+	* Fetches a pixiv image.
+	*
+	* Uses a browser User-Agent and Referer (required for pixiv CDN).
+	* No Authorization header is sent.
+	*
+	* @param imageUrl - Full CDN image URL
+	*/
+	fetch(imageUrl) {
+		return this.#http.fetchImage(imageUrl);
+	}
 };
-
-// src/client.ts
-var PixivClient = class _PixivClient {
-  /** Illust API namespace. */
-  illusts;
-  /** Novel API namespace. */
-  novels;
-  /** User API namespace. */
-  users;
-  /** Manga API namespace. */
-  manga;
-  /** Ugoira API namespace. */
-  ugoira;
-  /** Image fetch helpers. */
-  images;
-  #auth;
-  constructor(auth, http) {
-    this.#auth = auth;
-    this.illusts = new IllustResource(http);
-    this.novels = new NovelResource(http);
-    this.users = new UserResource(http);
-    this.manga = new MangaResource(http);
-    this.ugoira = new UgoiraResource(http);
-    this.images = new ImageResource(http);
-  }
-  /**
-   * Numeric user ID of the authenticated account.
-   *
-   * Available immediately after {@link PixivClient.of} resolves.
-   * The pixiv OAuth endpoint returns the ID as a string; this getter
-   * normalises it to `number` for consistency with resource method params
-   * (e.g. `UserBookmarksIllustParams.userId`).
-   *
-   * @example
-   * ```ts
-   * const client = await PixivClient.of(refreshToken)
-   * const bookmarks = await client.users.bookmarks.illusts({ userId: client.userId })
-   * ```
-   */
-  get userId() {
-    const id = Number(this.#auth.userId);
-    if (Number.isNaN(id)) {
-      throw new TypeError(`Invalid userId: "${this.#auth.userId}"`);
-    }
-    return id;
-  }
-  /**
-   * Returns the current OAuth access token.
-   *
-   * The access token is short-lived and changes after each call to
-   * {@link PixivClient.of} and after each automatic token refresh triggered
-   * by a 401 response.
-   *
-   * @returns The current bearer access token string
-   */
-  getAccessToken() {
-    return this.#auth.accessToken;
-  }
-  /**
-   * Returns the current OAuth refresh token.
-   *
-   * The refresh token is long-lived and is used to obtain new access tokens.
-   * It may rotate after a successful token refresh.
-   *
-   * @returns The current refresh token string
-   */
-  getRefreshToken() {
-    return this.#auth.refreshToken;
-  }
-  /**
-   * Creates a PixivClient by refreshing the given token.
-   *
-   * @param refreshToken - Pixiv refresh token
-   * @param options - Optional retry and response interceptor configuration
-   * @returns A fully initialised {@link PixivClient}
-   */
-  static async of(refreshToken, options) {
-    const auth = await AuthManager.login(refreshToken);
-    const http = new HttpClient(auth, options);
-    return new _PixivClient(auth, http);
-  }
+//#endregion
+//#region src/client.ts
+/**
+* PixivClient — main entry point for the @book000/pixivts library.
+*
+* @example
+* ```ts
+* const client = await PixivClient.of(process.env.PIXIV_REFRESH_TOKEN!)
+* const result = await client.illusts.detail({ illustId: 12345 })
+* if (result.isOk) console.log(result.value.illust.title)
+* ```
+*/
+/**
+* Main client for the pixiv API.
+*
+* Create an instance via {@link PixivClient.of} — the constructor is private
+* because initialisation requires an async token refresh.
+*/
+var PixivClient = class PixivClient {
+	/** Illust API namespace. */
+	illusts;
+	/** Novel API namespace. */
+	novels;
+	/** User API namespace. */
+	users;
+	/** Manga API namespace. */
+	manga;
+	/** Ugoira API namespace. */
+	ugoira;
+	/** Image fetch helpers. */
+	images;
+	#auth;
+	constructor(auth, http) {
+		this.#auth = auth;
+		this.illusts = new IllustResource(http);
+		this.novels = new NovelResource(http);
+		this.users = new UserResource(http);
+		this.manga = new MangaResource(http);
+		this.ugoira = new UgoiraResource(http);
+		this.images = new ImageResource(http);
+	}
+	/**
+	* Numeric user ID of the authenticated account.
+	*
+	* Available immediately after {@link PixivClient.of} resolves.
+	* The pixiv OAuth endpoint returns the ID as a string; this getter
+	* normalises it to `number` for consistency with resource method params
+	* (e.g. `UserBookmarksIllustParams.userId`).
+	*
+	* @example
+	* ```ts
+	* const client = await PixivClient.of(refreshToken)
+	* const bookmarks = await client.users.bookmarks.illusts({ userId: client.userId })
+	* ```
+	*/
+	get userId() {
+		const id = Number(this.#auth.userId);
+		if (Number.isNaN(id)) throw new TypeError(`Invalid userId: "${this.#auth.userId}"`);
+		return id;
+	}
+	/**
+	* Returns the current OAuth access token.
+	*
+	* The access token is short-lived and changes after each call to
+	* {@link PixivClient.of} and after each automatic token refresh triggered
+	* by a 401 response.
+	*
+	* @returns The current bearer access token string
+	*/
+	getAccessToken() {
+		return this.#auth.accessToken;
+	}
+	/**
+	* Returns the current OAuth refresh token.
+	*
+	* The refresh token is long-lived and is used to obtain new access tokens.
+	* It may rotate after a successful token refresh.
+	*
+	* @returns The current refresh token string
+	*/
+	getRefreshToken() {
+		return this.#auth.refreshToken;
+	}
+	/**
+	* Creates a PixivClient by refreshing the given token.
+	*
+	* @param refreshToken - Pixiv refresh token
+	* @param options - Optional retry and response interceptor configuration
+	* @returns A fully initialised {@link PixivClient}
+	*/
+	static async of(refreshToken, options) {
+		const auth = await AuthManager.login(refreshToken);
+		return new PixivClient(auth, new HttpClient(auth, options));
+	}
 };
-
+//#endregion
 exports.BookmarkRestrict = BookmarkRestrict;
 exports.FollowRestrict = FollowRestrict;
 exports.NovelRankingMode = NovelRankingMode;