@ukwhatn/wikidot 1.0.10 → 4.0.2

package/dist/shared/index-ytknx2hn.js

@@ -0,0 +1,980 @@
+import {
+  User
+} from "./index-kka6e8cb.js";
+import {
+  LoginRequiredError,
+  NoElementError,
+  UnexpectedError,
+  __legacyDecorateClassTS,
+  fromPromise,
+  wdErrAsync
+} from "./index-7dqqxq7x.js";
+
+// src/module/forum/forum-category.ts
+import * as cheerio3 from "cheerio";
+
+// src/common/decorators.ts
+function getClientRef(obj) {
+  if (obj.client)
+    return obj.client;
+  if (obj.site?.client)
+    return obj.site.client;
+  if (obj.thread?.site?.client)
+    return obj.thread.site.client;
+  return null;
+}
+function RequireLogin(target, _context) {
+  return function(...args) {
+    const clientRef = getClientRef(this);
+    if (!clientRef) {
+      return wdErrAsync(new LoginRequiredError("Client reference not found"));
+    }
+    const loginResult = clientRef.requireLogin();
+    if (loginResult.isErr()) {
+      return fromPromise(Promise.reject(loginResult.error), () => new LoginRequiredError("Login required"));
+    }
+    return target.call(this, ...args);
+  };
+}
+
+// src/module/forum/forum-thread.ts
+import * as cheerio2 from "cheerio";
+
+// src/common/logger.ts
+var LOG_LEVEL_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var nullHandler = () => {};
+var consoleHandler = (level, name, message, ...args) => {
+  const timestamp = new Date().toISOString();
+  const formattedMessage = `${timestamp} [${name}/${level.toUpperCase()}] ${message}`;
+  switch (level) {
+    case "debug":
+      console.debug(formattedMessage, ...args);
+      break;
+    case "info":
+      console.info(formattedMessage, ...args);
+      break;
+    case "warn":
+      console.warn(formattedMessage, ...args);
+      break;
+    case "error":
+      console.error(formattedMessage, ...args);
+      break;
+  }
+};
+
+class Logger {
+  name;
+  handler;
+  level;
+  constructor(name, handler = nullHandler, level = "warn") {
+    this.name = name;
+    this.handler = handler;
+    this.level = level;
+  }
+  setHandler(handler) {
+    this.handler = handler;
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  shouldLog(level) {
+    return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.level];
+  }
+  log(level, message, ...args) {
+    if (this.shouldLog(level)) {
+      this.handler(level, this.name, message, ...args);
+    }
+  }
+  debug(message, ...args) {
+    this.log("debug", message, ...args);
+  }
+  info(message, ...args) {
+    this.log("info", message, ...args);
+  }
+  warn(message, ...args) {
+    this.log("warn", message, ...args);
+  }
+  error(message, ...args) {
+    this.log("error", message, ...args);
+  }
+}
+function getLogger(name = "wikidot") {
+  return new Logger(name);
+}
+function setupConsoleHandler(logger, level = "warn") {
+  logger.setHandler(consoleHandler);
+  logger.setLevel(level);
+}
+var logger = getLogger();
+
+// src/module/user/anonymous-user.ts
+class AnonymousUser {
+  client;
+  id = 0;
+  name = "Anonymous";
+  unixName = "anonymous";
+  avatarUrl = null;
+  ip;
+  userType = "anonymous";
+  constructor(client, ip) {
+    this.client = client;
+    this.ip = ip;
+  }
+  isUser() {
+    return false;
+  }
+  isDeletedUser() {
+    return false;
+  }
+  isAnonymousUser() {
+    return true;
+  }
+  isGuestUser() {
+    return false;
+  }
+  isWikidotUser() {
+    return false;
+  }
+  toString() {
+    return `AnonymousUser(name=${this.name}, unixName=${this.unixName}, ip=${this.ip})`;
+  }
+}
+// src/module/user/deleted-user.ts
+class DeletedUser {
+  client;
+  id;
+  name = "account deleted";
+  unixName = "account_deleted";
+  avatarUrl = null;
+  ip = null;
+  userType = "deleted";
+  constructor(client, id) {
+    this.client = client;
+    this.id = id;
+  }
+  isUser() {
+    return false;
+  }
+  isDeletedUser() {
+    return true;
+  }
+  isAnonymousUser() {
+    return false;
+  }
+  isGuestUser() {
+    return false;
+  }
+  isWikidotUser() {
+    return false;
+  }
+  toString() {
+    return `DeletedUser(id=${this.id}, name=${this.name}, unixName=${this.unixName})`;
+  }
+}
+// src/module/user/guest-user.ts
+class GuestUser {
+  client;
+  id = 0;
+  name;
+  unixName = null;
+  avatarUrl;
+  ip = null;
+  userType = "guest";
+  constructor(client, name, avatarUrl = null) {
+    this.client = client;
+    this.name = name;
+    this.avatarUrl = avatarUrl;
+  }
+  isUser() {
+    return false;
+  }
+  isDeletedUser() {
+    return false;
+  }
+  isAnonymousUser() {
+    return false;
+  }
+  isGuestUser() {
+    return true;
+  }
+  isWikidotUser() {
+    return false;
+  }
+  toString() {
+    return `GuestUser(name=${this.name})`;
+  }
+}
+// src/module/user/wikidot-user.ts
+class WikidotUser {
+  client;
+  id = 0;
+  name = "Wikidot";
+  unixName = "wikidot";
+  avatarUrl = null;
+  ip = null;
+  userType = "wikidot";
+  constructor(client) {
+    this.client = client;
+  }
+  isUser() {
+    return false;
+  }
+  isDeletedUser() {
+    return false;
+  }
+  isAnonymousUser() {
+    return false;
+  }
+  isGuestUser() {
+    return false;
+  }
+  isWikidotUser() {
+    return true;
+  }
+  toString() {
+    return `WikidotUser(name=${this.name}, unixName=${this.unixName})`;
+  }
+}
+// src/util/parser/user.ts
+function parseUser(client, elem) {
+  const classAttr = elem.attr("class") ?? "";
+  const classes = classAttr.split(/\s+/);
+  if (classes.includes("deleted")) {
+    const dataId = elem.attr("data-id");
+    const userId2 = dataId ? Number.parseInt(dataId, 10) : 0;
+    return new DeletedUser(client, userId2);
+  }
+  const text = elem.text().trim();
+  if (text === "(user deleted)") {
+    return new DeletedUser(client, 0);
+  }
+  if (classes.includes("anonymous")) {
+    const ipElem = elem.find("span.ip");
+    if (ipElem.length > 0) {
+      const ip = ipElem.text().replace(/[()]/g, "").trim();
+      return new AnonymousUser(client, ip);
+    }
+    return new AnonymousUser(client, "");
+  }
+  const imgElem = elem.find("img");
+  if (imgElem.length > 0) {
+    const src = imgElem.attr("src") ?? "";
+    if (src.includes("gravatar.com")) {
+      const guestName = text.split(" ")[0] ?? "Guest";
+      return new GuestUser(client, guestName, src);
+    }
+  }
+  if (text === "Wikidot") {
+    return new WikidotUser(client);
+  }
+  const links = elem.find("a");
+  if (links.length === 0) {
+    return new DeletedUser(client, 0);
+  }
+  const userLink = links.last();
+  const userName = userLink.text().trim();
+  const href = userLink.attr("href") ?? "";
+  const onclick = userLink.attr("onclick") ?? "";
+  const unixName = href.replace(/^.*\/user:info\//, "").replace(/\/$/, "");
+  const userIdMatch = onclick.match(/userInfo\((\d+)\)/);
+  const userId = userIdMatch?.[1] ? Number.parseInt(userIdMatch[1], 10) : 0;
+  const avatarUrl = userId > 0 ? `http://www.wikidot.com/avatar.php?userid=${userId}` : undefined;
+  return new User(client, {
+    id: userId,
+    name: userName,
+    unixName,
+    avatarUrl
+  });
+}
+function parseOdate(elem) {
+  const classAttr = elem.attr("class") ?? "";
+  const timeMatch = classAttr.match(/time_(\d+)/);
+  if (timeMatch?.[1]) {
+    const unixTime = Number.parseInt(timeMatch[1], 10);
+    return new Date(unixTime * 1000);
+  }
+  const text = elem.text().trim();
+  const parsed = Date.parse(text);
+  if (!Number.isNaN(parsed)) {
+    return new Date(parsed);
+  }
+  logger.warn(`Failed to parse odate element: class="${classAttr}", text="${text}"`);
+  return null;
+}
+// src/module/forum/forum-post.ts
+import * as cheerio from "cheerio";
+class ForumPost {
+  thread;
+  id;
+  title;
+  text;
+  element;
+  createdBy;
+  createdAt;
+  editedBy;
+  editedAt;
+  _parentId;
+  _source = null;
+  constructor(data) {
+    this.thread = data.thread;
+    this.id = data.id;
+    this.title = data.title;
+    this.text = data.text;
+    this.element = data.element;
+    this.createdBy = data.createdBy;
+    this.createdAt = data.createdAt;
+    this.editedBy = data.editedBy ?? null;
+    this.editedAt = data.editedAt ?? null;
+    this._parentId = data.parentId ?? null;
+  }
+  get parentId() {
+    return this._parentId;
+  }
+  getSource() {
+    if (this._source !== null) {
+      return fromPromise(Promise.resolve(this._source), (e) => new UnexpectedError(String(e)));
+    }
+    return fromPromise((async () => {
+      const result = await this.thread.site.amcRequest([
+        {
+          moduleName: "forum/sub/ForumEditPostFormModule",
+          threadId: this.thread.id,
+          postId: this.id
+        }
+      ]);
+      if (result.isErr()) {
+        throw result.error;
+      }
+      const response = result.value[0];
+      if (!response) {
+        throw new NoElementError("Empty response");
+      }
+      const $ = cheerio.load(String(response.body ?? ""));
+      const sourceElem = $("textarea[name='source']");
+      if (sourceElem.length === 0) {
+        throw new NoElementError("Source textarea not found");
+      }
+      this._source = sourceElem.text();
+      return this._source;
+    })(), (error) => {
+      if (error instanceof NoElementError)
+        return error;
+      return new UnexpectedError(`Failed to get post source: ${String(error)}`);
+    });
+  }
+  edit(source, title) {
+    return fromPromise((async () => {
+      const formResult = await this.thread.site.amcRequest([
+        {
+          moduleName: "forum/sub/ForumEditPostFormModule",
+          threadId: this.thread.id,
+          postId: this.id
+        }
+      ]);
+      if (formResult.isErr()) {
+        throw formResult.error;
+      }
+      const formResponse = formResult.value[0];
+      if (!formResponse) {
+        throw new NoElementError("Empty form response");
+      }
+      const $ = cheerio.load(String(formResponse.body ?? ""));
+      const revisionInput = $("input[name='currentRevisionId']");
+      if (revisionInput.length === 0) {
+        throw new NoElementError("Current revision ID input not found");
+      }
+      const revisionValue = revisionInput.val();
+      const currentRevisionId = Number.parseInt(String(revisionValue ?? ""), 10);
+      if (Number.isNaN(currentRevisionId)) {
+        throw new NoElementError("Invalid revision ID value");
+      }
+      const editResult = await this.thread.site.amcRequest([
+        {
+          action: "ForumAction",
+          event: "saveEditPost",
+          moduleName: "Empty",
+          postId: this.id,
+          currentRevisionId,
+          title: title ?? this.title,
+          source
+        }
+      ]);
+      if (editResult.isErr()) {
+        throw editResult.error;
+      }
+      if (title !== undefined) {
+        this.title = title;
+      }
+      this._source = source;
+    })(), (error) => {
+      if (error instanceof NoElementError || error instanceof LoginRequiredError) {
+        return error;
+      }
+      return new UnexpectedError(`Failed to edit post: ${String(error)}`);
+    });
+  }
+  toString() {
+    return `ForumPost(id=${this.id}, title=${this.title})`;
+  }
+}
+__legacyDecorateClassTS([
+  RequireLogin
+], ForumPost.prototype, "edit", null);
+
+class ForumPostCollection extends Array {
+  thread;
+  constructor(thread, posts) {
+    super();
+    this.thread = thread;
+    if (posts) {
+      this.push(...posts);
+    }
+  }
+  findById(id) {
+    return this.find((post) => post.id === id);
+  }
+  static _parse(thread, $) {
+    const posts = [];
+    $("div.post").each((_i, postElem) => {
+      const $post = $(postElem);
+      const postIdAttr = $post.attr("id");
+      if (!postIdAttr)
+        return;
+      const postId = Number.parseInt(postIdAttr.replace("post-", ""), 10);
+      if (Number.isNaN(postId))
+        return;
+      let parentId = null;
+      const $parentContainer = $post.parent();
+      if ($parentContainer.length > 0) {
+        const $grandparent = $parentContainer.parent();
+        if ($grandparent.length > 0 && $grandparent[0]?.name !== "body") {
+          const grandparentClasses = $grandparent.attr("class") ?? "";
+          if (grandparentClasses.includes("post-container")) {
+            const $parentPost = $grandparent.find("> div.post");
+            if ($parentPost.length > 0) {
+              const parentPostIdAttr = $parentPost.attr("id");
+              if (parentPostIdAttr) {
+                parentId = Number.parseInt(parentPostIdAttr.replace("post-", ""), 10);
+              }
+            }
+          }
+        }
+      }
+      const $wrapper = $post.find("div.long");
+      if ($wrapper.length === 0)
+        return;
+      const $head = $wrapper.find("div.head");
+      if ($head.length === 0)
+        return;
+      const $title = $head.find("div.title");
+      const title = $title.text().trim();
+      const $content = $wrapper.find("div.content");
+      const text = $content.html() ?? "";
+      const $info = $head.find("div.info");
+      if ($info.length === 0)
+        return;
+      const $userElem = $info.find("span.printuser");
+      if ($userElem.length === 0)
+        return;
+      const createdBy = parseUser(thread.site.client, $userElem);
+      const $odateElem = $info.find("span.odate");
+      if ($odateElem.length === 0)
+        return;
+      const createdAt = parseOdate($odateElem) ?? new Date;
+      let editedBy = null;
+      let editedAt = null;
+      const $changes = $wrapper.find("div.changes");
+      if ($changes.length > 0) {
+        const $editUserElem = $changes.find("span.printuser");
+        const $editOdateElem = $changes.find("span.odate");
+        if ($editUserElem.length > 0 && $editOdateElem.length > 0) {
+          editedBy = parseUser(thread.site.client, $editUserElem);
+          editedAt = parseOdate($editOdateElem);
+        }
+      }
+      posts.push(new ForumPost({
+        thread,
+        id: postId,
+        title,
+        text,
+        element: postElem,
+        createdBy,
+        createdAt,
+        editedBy,
+        editedAt,
+        parentId
+      }));
+    });
+    return posts;
+  }
+  static acquireAllInThread(thread) {
+    return fromPromise((async () => {
+      const posts = [];
+      const firstResult = await thread.site.amcRequest([
+        {
+          moduleName: "forum/ForumViewThreadPostsModule",
+          pageNo: "1",
+          t: String(thread.id)
+        }
+      ]);
+      if (firstResult.isErr()) {
+        throw firstResult.error;
+      }
+      const firstResponse = firstResult.value[0];
+      if (!firstResponse) {
+        throw new NoElementError("Empty response");
+      }
+      const firstBody = String(firstResponse.body ?? "");
+      const $first = cheerio.load(firstBody);
+      posts.push(...ForumPostCollection._parse(thread, $first));
+      const $pager = $first("div.pager");
+      if ($pager.length === 0) {
+        return new ForumPostCollection(thread, posts);
+      }
+      const $pagerTargets = $pager.find("span.target");
+      if ($pagerTargets.length < 2) {
+        return new ForumPostCollection(thread, posts);
+      }
+      const lastPageText = $pagerTargets.eq($pagerTargets.length - 2).text().trim();
+      const lastPage = Number.parseInt(lastPageText, 10);
+      if (Number.isNaN(lastPage) || lastPage <= 1) {
+        return new ForumPostCollection(thread, posts);
+      }
+      const bodies = [];
+      for (let page = 2;page <= lastPage; page++) {
+        bodies.push({
+          moduleName: "forum/ForumViewThreadPostsModule",
+          pageNo: String(page),
+          t: String(thread.id)
+        });
+      }
+      const additionalResults = await thread.site.amcRequest(bodies);
+      if (additionalResults.isErr()) {
+        throw additionalResults.error;
+      }
+      for (const response of additionalResults.value) {
+        const body = String(response?.body ?? "");
+        const $ = cheerio.load(body);
+        posts.push(...ForumPostCollection._parse(thread, $));
+      }
+      return new ForumPostCollection(thread, posts);
+    })(), (error) => {
+      if (error instanceof NoElementError)
+        return error;
+      return new UnexpectedError(`Failed to acquire posts: ${String(error)}`);
+    });
+  }
+}
+
+// src/module/forum/forum-thread.ts
+class ForumThread {
+  site;
+  id;
+  title;
+  description;
+  createdBy;
+  createdAt;
+  postCount;
+  category;
+  _posts = null;
+  constructor(data) {
+    this.site = data.site;
+    this.id = data.id;
+    this.title = data.title;
+    this.description = data.description;
+    this.createdBy = data.createdBy;
+    this.createdAt = data.createdAt;
+    this.postCount = data.postCount;
+    this.category = data.category ?? null;
+  }
+  getUrl() {
+    return `${this.site.getBaseUrl()}/forum/t-${this.id}/`;
+  }
+  getPosts() {
+    if (this._posts !== null) {
+      return fromPromise(Promise.resolve(this._posts), (e) => new UnexpectedError(String(e)));
+    }
+    return ForumPostCollection.acquireAllInThread(this);
+  }
+  reply(source, title = "", parentPostId = null) {
+    return fromPromise((async () => {
+      const result = await this.site.amcRequest([
+        {
+          threadId: String(this.id),
+          parentId: parentPostId !== null ? String(parentPostId) : "",
+          title,
+          source,
+          action: "ForumAction",
+          event: "savePost",
+          moduleName: "Empty"
+        }
+      ]);
+      if (result.isErr()) {
+        throw result.error;
+      }
+      this._posts = null;
+      this.postCount += 1;
+      return this;
+    })(), (error) => new UnexpectedError(`Failed to reply: ${String(error)}`));
+  }
+  toString() {
+    return `ForumThread(id=${this.id}, title=${this.title})`;
+  }
+  static getFromId(site, threadId, category = null) {
+    return fromPromise((async () => {
+      const result = await ForumThreadCollection.acquireFromThreadIds(site, [threadId], category);
+      if (result.isErr()) {
+        throw result.error;
+      }
+      const thread = result.value[0];
+      if (!thread) {
+        throw new NoElementError(`Thread not found: ${threadId}`);
+      }
+      return thread;
+    })(), (error) => {
+      if (error instanceof NoElementError)
+        return error;
+      return new UnexpectedError(`Failed to get thread: ${String(error)}`);
+    });
+  }
+}
+__legacyDecorateClassTS([
+  RequireLogin
+], ForumThread.prototype, "reply", null);
+
+class ForumThreadCollection extends Array {
+  site;
+  constructor(site, threads) {
+    super();
+    this.site = site;
+    if (threads) {
+      this.push(...threads);
+    }
+  }
+  findById(id) {
+    return this.find((thread) => thread.id === id);
+  }
+  static acquireAllInCategory(category) {
+    return fromPromise((async () => {
+      const threads = [];
+      const firstResult = await category.site.amcRequest([
+        {
+          p: 1,
+          c: category.id,
+          moduleName: "forum/ForumViewCategoryModule"
+        }
+      ]);
+      if (firstResult.isErr()) {
+        throw firstResult.error;
+      }
+      const firstResponse = firstResult.value[0];
+      if (!firstResponse) {
+        throw new NoElementError("Empty response");
+      }
+      const firstBody = String(firstResponse.body ?? "");
+      const $first = cheerio2.load(firstBody);
+      $first("table.table tr.head~tr").each((_i, elem) => {
+        const $row = $first(elem);
+        const titleElem = $row.find("div.title a");
+        const href = titleElem.attr("href") ?? "";
+        const threadIdMatch = href.match(/t-(\d+)/);
+        if (!threadIdMatch?.[1])
+          return;
+        const threadId = Number.parseInt(threadIdMatch[1], 10);
+        const title = titleElem.text().trim();
+        const description = $row.find("div.description").text().trim();
+        const postCount = Number.parseInt($row.find("td.posts").text().trim(), 10) || 0;
+        const $userElem = $row.find("td.started span.printuser");
+        const $odateElem = $row.find("td.started span.odate");
+        const createdBy = $userElem.length > 0 ? parseUser(category.site.client, $userElem) : null;
+        const createdAt = $odateElem.length > 0 ? parseOdate($odateElem) ?? new Date : new Date;
+        threads.push(new ForumThread({
+          site: category.site,
+          id: threadId,
+          title,
+          description,
+          createdBy,
+          createdAt,
+          postCount,
+          category
+        }));
+      });
+      const pager = $first("div.pager");
+      if (pager.length === 0) {
+        return new ForumThreadCollection(category.site, threads);
+      }
+      const pagerLinks = pager.find("a");
+      if (pagerLinks.length < 2) {
+        return new ForumThreadCollection(category.site, threads);
+      }
+      const lastPageLink = pagerLinks[pagerLinks.length - 2];
+      const lastPageText = lastPageLink ? $first(lastPageLink).text().trim() : "1";
+      const lastPage = Number.parseInt(lastPageText, 10) || 1;
+      if (lastPage <= 1) {
+        return new ForumThreadCollection(category.site, threads);
+      }
+      const bodies = [];
+      for (let page = 2;page <= lastPage; page++) {
+        bodies.push({
+          p: page,
+          c: category.id,
+          moduleName: "forum/ForumViewCategoryModule"
+        });
+      }
+      const additionalResults = await category.site.amcRequest(bodies);
+      if (additionalResults.isErr()) {
+        throw additionalResults.error;
+      }
+      for (const response of additionalResults.value) {
+        const body = String(response?.body ?? "");
+        const $ = cheerio2.load(body);
+        $("table.table tr.head~tr").each((_i, elem) => {
+          const $row = $(elem);
+          const titleElem = $row.find("div.title a");
+          const href = titleElem.attr("href") ?? "";
+          const threadIdMatch = href.match(/t-(\d+)/);
+          if (!threadIdMatch?.[1])
+            return;
+          const threadId = Number.parseInt(threadIdMatch[1], 10);
+          const title = titleElem.text().trim();
+          const description = $row.find("div.description").text().trim();
+          const postCount = Number.parseInt($row.find("td.posts").text().trim(), 10) || 0;
+          const $userElem = $row.find("td.started span.printuser");
+          const $odateElem = $row.find("td.started span.odate");
+          const createdBy = $userElem.length > 0 ? parseUser(category.site.client, $userElem) : null;
+          const createdAt = $odateElem.length > 0 ? parseOdate($odateElem) ?? new Date : new Date;
+          threads.push(new ForumThread({
+            site: category.site,
+            id: threadId,
+            title,
+            description,
+            createdBy,
+            createdAt,
+            postCount,
+            category
+          }));
+        });
+      }
+      return new ForumThreadCollection(category.site, threads);
+    })(), (error) => {
+      if (error instanceof NoElementError)
+        return error;
+      return new UnexpectedError(`Failed to acquire threads: ${String(error)}`);
+    });
+  }
+  static fromId(site, threadId) {
+    return fromPromise((async () => {
+      const result = await ForumThreadCollection.acquireFromThreadIds(site, [threadId]);
+      if (result.isErr()) {
+        throw result.error;
+      }
+      const thread = result.value[0];
+      if (!thread) {
+        throw new NoElementError(`Thread not found: ${threadId}`);
+      }
+      return thread;
+    })(), (error) => {
+      if (error instanceof NoElementError)
+        return error;
+      return new UnexpectedError(`Failed to get thread: ${String(error)}`);
+    });
+  }
+  static acquireFromThreadIds(site, threadIds, category = null) {
+    return fromPromise((async () => {
+      const result = await site.amcRequest(threadIds.map((threadId) => ({
+        t: threadId,
+        moduleName: "forum/ForumViewThreadModule"
+      })));
+      if (result.isErr()) {
+        throw result.error;
+      }
+      const threads = [];
+      for (let i = 0;i < threadIds.length; i++) {
+        const response = result.value[i];
+        const threadId = threadIds[i];
+        if (!response || !threadId)
+          continue;
+        const body = String(response.body ?? "");
+        const $ = cheerio2.load(body);
+        const bcElem = $("div.forum-breadcrumbs");
+        if (bcElem.length === 0) {
+          throw new NoElementError("Breadcrumbs not found");
+        }
+        const bcParts = bcElem.text().split("»");
+        const title = bcParts.length > 0 ? bcParts[bcParts.length - 1]?.trim() ?? "" : "";
+        const descBlockElem = $("div.description-block");
+        const description = descBlockElem.text().trim();
+        const postCountMatch = $("div.statistics").text().match(/(\d+)/);
+        const postCount = postCountMatch?.[1] ? Number.parseInt(postCountMatch[1], 10) : 0;
+        threads.push(new ForumThread({
+          site,
+          id: threadId,
+          title,
+          description,
+          createdBy: null,
+          createdAt: new Date,
+          postCount,
+          category
+        }));
+      }
+      return new ForumThreadCollection(site, threads);
+    })(), (error) => {
+      if (error instanceof NoElementError)
+        return error;
+      return new UnexpectedError(`Failed to acquire threads: ${String(error)}`);
+    });
+  }
+}
+
+// src/module/forum/forum-category.ts
+class ForumCategory {
+  site;
+  id;
+  title;
+  description;
+  threadsCount;
+  postsCount;
+  _threads = null;
+  constructor(data) {
+    this.site = data.site;
+    this.id = data.id;
+    this.title = data.title;
+    this.description = data.description;
+    this.threadsCount = data.threadsCount;
+    this.postsCount = data.postsCount;
+  }
+  getThreads() {
+    if (this._threads !== null) {
+      return fromPromise(Promise.resolve(this._threads), (e) => new UnexpectedError(String(e)));
+    }
+    return fromPromise((async () => {
+      const result = await ForumThreadCollection.acquireAllInCategory(this);
+      if (result.isErr()) {
+        throw result.error;
+      }
+      this._threads = result.value;
+      return this._threads;
+    })(), (error) => new UnexpectedError(`Failed to get threads: ${String(error)}`));
+  }
+  reloadThreads() {
+    this._threads = null;
+    return this.getThreads();
+  }
+  createThread(title, description, source) {
+    return fromPromise((async () => {
+      const result = await this.site.amcRequest([
+        {
+          moduleName: "Empty",
+          action: "ForumAction",
+          event: "newThread",
+          category_id: this.id,
+          title,
+          description,
+          source
+        }
+      ]);
+      if (result.isErr()) {
+        throw result.error;
+      }
+      const response = result.value[0];
+      if (!response || typeof response.threadId !== "number") {
+        throw new NoElementError("Thread ID not found in response");
+      }
+      const threadId = response.threadId;
+      const threadResult = await ForumThread.getFromId(this.site, threadId, this);
+      if (threadResult.isErr()) {
+        throw threadResult.error;
+      }
+      return threadResult.value;
+    })(), (error) => {
+      if (error instanceof NoElementError || error instanceof LoginRequiredError) {
+        return error;
+      }
+      return new UnexpectedError(`Failed to create thread: ${String(error)}`);
+    });
+  }
+  toString() {
+    return `ForumCategory(id=${this.id}, title=${this.title})`;
+  }
+}
+__legacyDecorateClassTS([
+  RequireLogin
+], ForumCategory.prototype, "createThread", null);
+
+class ForumCategoryCollection extends Array {
+  site;
+  constructor(site, categories) {
+    super();
+    this.site = site;
+    if (categories) {
+      this.push(...categories);
+    }
+  }
+  findById(id) {
+    return this.find((category) => category.id === id);
+  }
+  static acquireAll(site) {
+    return fromPromise((async () => {
+      const result = await site.amcRequest([
+        {
+          moduleName: "forum/ForumStartModule",
+          hidden: "true"
+        }
+      ]);
+      if (result.isErr()) {
+        throw result.error;
+      }
+      const response = result.value[0];
+      if (!response) {
+        throw new NoElementError("Empty response");
+      }
+      const body = String(response.body ?? "");
+      const $ = cheerio3.load(body);
+      const categories = [];
+      $("table tr.head~tr").each((_i, row) => {
+        const $row = $(row);
+        const nameElem = $row.find("td.name");
+        const nameLinkElem = nameElem.find("a");
+        const href = nameLinkElem.attr("href") ?? "";
+        const categoryIdMatch = href.match(/c-(\d+)/);
+        if (!categoryIdMatch?.[1])
+          return;
+        const categoryId = Number.parseInt(categoryIdMatch[1], 10);
+        const title = nameLinkElem.text().trim();
+        const description = nameElem.find("div.description").text().trim();
+        const threadsCount = Number.parseInt($row.find("td.threads").text().trim(), 10) || 0;
+        const postsCount = Number.parseInt($row.find("td.posts").text().trim(), 10) || 0;
+        categories.push(new ForumCategory({
+          site,
+          id: categoryId,
+          title,
+          description,
+          threadsCount,
+          postsCount
+        }));
+      });
+      return new ForumCategoryCollection(site, categories);
+    })(), (error) => {
+      if (error instanceof NoElementError)
+        return error;
+      return new UnexpectedError(`Failed to acquire categories: ${String(error)}`);
+    });
+  }
+}
+export {
+  ForumThreadCollection,
+  ForumThread,
+  ForumPostCollection,
+  ForumPost,
+  ForumCategoryCollection,
+  ForumCategory
+};
+export { nullHandler, consoleHandler, Logger, getLogger, setupConsoleHandler, logger, AnonymousUser, DeletedUser, GuestUser, WikidotUser, parseUser, parseOdate, RequireLogin, ForumPost, ForumPostCollection, ForumThread, ForumThreadCollection, ForumCategory, ForumCategoryCollection };
+
+//# debugId=B1748EA576F96A3164756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/module/forum/forum-category.ts", "src/common/decorators.ts", "src/module/forum/forum-thread.ts", "src/common/logger.ts", "src/module/user/anonymous-user.ts", "src/module/user/deleted-user.ts", "src/module/user/guest-user.ts", "src/module/user/wikidot-user.ts", "src/util/parser/user.ts", "src/module/forum/forum-post.ts"],
  "sourcesContent": [
    "import * as cheerio from 'cheerio';\nimport { RequireLogin } from '../../common/decorators';\nimport { LoginRequiredError, NoElementError, UnexpectedError } from '../../common/errors';\nimport { fromPromise, type WikidotResultAsync } from '../../common/types';\nimport type { Site } from '../site';\nimport { ForumThread, ForumThreadCollection } from './forum-thread';\n\n/**\n * フォーラムカテゴリデータ\n */\nexport interface ForumCategoryData {\n  site: Site;\n  id: number;\n  title: string;\n  description: string;\n  threadsCount: number;\n  postsCount: number;\n}\n\n/**\n * フォーラムカテゴリ\n */\nexport class ForumCategory {\n  public readonly site: Site;\n  public readonly id: number;\n  public readonly title: string;\n  public readonly description: string;\n  public readonly threadsCount: number;\n  public readonly postsCount: number;\n  private _threads: ForumThreadCollection | null = null;\n\n  constructor(data: ForumCategoryData) {\n    this.site = data.site;\n    this.id = data.id;\n    this.title = data.title;\n    this.description = data.description;\n    this.threadsCount = data.threadsCount;\n    this.postsCount = data.postsCount;\n  }\n\n  /**\n   * スレッド一覧を取得\n   */\n  getThreads(): WikidotResultAsync<ForumThreadCollection> {\n    if (this._threads !== null) {\n      return fromPromise(Promise.resolve(this._threads), (e) => new UnexpectedError(String(e)));\n    }\n\n    return fromPromise(\n      (async () => {\n        const result = await ForumThreadCollection.acquireAllInCategory(this);\n        if (result.isErr()) {\n          throw result.error;\n        }\n        this._threads = result.value;\n        return this._threads;\n      })(),\n      (error) => new UnexpectedError(`Failed to get threads: ${String(error)}`)\n    );\n  }\n\n  /**\n   * スレッド一覧を再取得\n   */\n  reloadThreads(): WikidotResultAsync<ForumThreadCollection> {\n    this._threads = null;\n    return this.getThreads();\n  }\n\n  /**\n   * スレッドを作成\n   */\n  @RequireLogin\n  createThread(\n    title: string,\n    description: string,\n    source: string\n  ): WikidotResultAsync<ForumThread> {\n    return fromPromise(\n      (async () => {\n        const result = await this.site.amcRequest([\n          {\n            moduleName: 'Empty',\n            action: 'ForumAction',\n            event: 'newThread',\n            category_id: this.id,\n            title,\n            description,\n            source,\n          },\n        ]);\n\n        if (result.isErr()) {\n          throw result.error;\n        }\n\n        const response = result.value[0];\n        if (!response || typeof response.threadId !== 'number') {\n          throw new NoElementError('Thread ID not found in response');\n        }\n\n        const threadId = response.threadId as number;\n        const threadResult = await ForumThread.getFromId(this.site, threadId, this);\n        if (threadResult.isErr()) {\n          throw threadResult.error;\n        }\n        return threadResult.value;\n      })(),\n      (error) => {\n        if (error instanceof NoElementError || error instanceof LoginRequiredError) {\n          return error;\n        }\n        return new UnexpectedError(`Failed to create thread: ${String(error)}`);\n      }\n    );\n  }\n\n  toString(): string {\n    return `ForumCategory(id=${this.id}, title=${this.title})`;\n  }\n}\n\n/**\n * フォーラムカテゴリコレクション\n */\nexport class ForumCategoryCollection extends Array<ForumCategory> {\n  public readonly site: Site;\n\n  constructor(site: Site, categories?: ForumCategory[]) {\n    super();\n    this.site = site;\n    if (categories) {\n      this.push(...categories);\n    }\n  }\n\n  /**\n   * IDで検索\n   */\n  findById(id: number): ForumCategory | undefined {\n    return this.find((category) => category.id === id);\n  }\n\n  /**\n   * サイトの全カテゴリを取得\n   */\n  static acquireAll(site: Site): WikidotResultAsync<ForumCategoryCollection> {\n    return fromPromise(\n      (async () => {\n        const result = await site.amcRequest([\n          {\n            moduleName: 'forum/ForumStartModule',\n            hidden: 'true',\n          },\n        ]);\n\n        if (result.isErr()) {\n          throw result.error;\n        }\n\n        const response = result.value[0];\n        if (!response) {\n          throw new NoElementError('Empty response');\n        }\n\n        const body = String(response.body ?? '');\n        const $ = cheerio.load(body);\n\n        const categories: ForumCategory[] = [];\n\n        $('table tr.head~tr').each((_i, row) => {\n          const $row = $(row);\n          const nameElem = $row.find('td.name');\n          const nameLinkElem = nameElem.find('a');\n          const href = nameLinkElem.attr('href') ?? '';\n\n          const categoryIdMatch = href.match(/c-(\\d+)/);\n          if (!categoryIdMatch?.[1]) return;\n\n          const categoryId = Number.parseInt(categoryIdMatch[1], 10);\n          const title = nameLinkElem.text().trim();\n          const description = nameElem.find('div.description').text().trim();\n          const threadsCount = Number.parseInt($row.find('td.threads').text().trim(), 10) || 0;\n          const postsCount = Number.parseInt($row.find('td.posts').text().trim(), 10) || 0;\n\n          categories.push(\n            new ForumCategory({\n              site,\n              id: categoryId,\n              title,\n              description,\n              threadsCount,\n              postsCount,\n            })\n          );\n        });\n\n        return new ForumCategoryCollection(site, categories);\n      })(),\n      (error) => {\n        if (error instanceof NoElementError) return error;\n        return new UnexpectedError(`Failed to acquire categories: ${String(error)}`);\n      }\n    );\n  }\n}\n",
    "/**\n * デコレータユーティリティ\n */\n\nimport { LoginRequiredError } from './errors';\nimport { fromPromise, type WikidotResultAsync, wdErrAsync } from './types';\n\n/**\n * クライアント参照を持つオブジェクトの型\n */\ninterface HasClient {\n  client?: { requireLogin(): { isErr(): boolean; error?: Error } };\n  site?: { client: { requireLogin(): { isErr(): boolean; error?: Error } } };\n  thread?: { site: { client: { requireLogin(): { isErr(): boolean; error?: Error } } } };\n}\n\n/**\n * オブジェクトからクライアント参照を取得する\n */\nfunction getClientRef(\n  obj: HasClient\n): { requireLogin(): { isErr(): boolean; error?: Error } } | null {\n  if (obj.client) return obj.client;\n  if (obj.site?.client) return obj.site.client;\n  if (obj.thread?.site?.client) return obj.thread.site.client;\n  return null;\n}\n\n/**\n * ログイン必須メソッドデコレータ\n *\n * このデコレータを適用したメソッドは、実行前にログイン状態をチェックする。\n * ログインしていない場合は LoginRequiredError を返す。\n *\n * @example\n * class Page {\n *   @RequireLogin\n *   destroy(): WikidotResultAsync<void> {\n *     return fromPromise(async () => { ... }, (e) => new UnexpectedError(...));\n *   }\n * }\n */\nexport function RequireLogin<\n  This extends HasClient,\n  Args extends unknown[],\n  Return extends WikidotResultAsync<unknown>,\n>(\n  target: (this: This, ...args: Args) => Return,\n  _context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>\n): (this: This, ...args: Args) => Return {\n  return function (this: This, ...args: Args): Return {\n    const clientRef = getClientRef(this);\n    if (!clientRef) {\n      return wdErrAsync(new LoginRequiredError('Client reference not found')) as unknown as Return;\n    }\n\n    const loginResult = clientRef.requireLogin();\n    if (loginResult.isErr()) {\n      return fromPromise(\n        Promise.reject(loginResult.error),\n        () => new LoginRequiredError('Login required')\n      ) as unknown as Return;\n    }\n\n    return target.call(this, ...args);\n  };\n}\n",
    "import type { Cheerio } from 'cheerio';\nimport * as cheerio from 'cheerio';\nimport type { AnyNode } from 'domhandler';\nimport { RequireLogin } from '../../common/decorators';\nimport { NoElementError, UnexpectedError } from '../../common/errors';\nimport { fromPromise, type WikidotResultAsync } from '../../common/types';\nimport { parseOdate, parseUser } from '../../util/parser';\nimport type { Site } from '../site';\nimport type { AbstractUser } from '../user';\nimport type { ForumCategory } from './forum-category';\nimport { ForumPostCollection } from './forum-post';\n\n/**\n * フォーラムスレッドデータ\n */\nexport interface ForumThreadData {\n  site: Site;\n  id: number;\n  title: string;\n  description: string;\n  createdBy: AbstractUser | null;\n  createdAt: Date;\n  postCount: number;\n  category?: ForumCategory | null;\n}\n\n/**\n * フォーラムスレッド\n */\nexport class ForumThread {\n  public readonly site: Site;\n  public readonly id: number;\n  public readonly title: string;\n  public readonly description: string;\n  public readonly createdBy: AbstractUser | null;\n  public readonly createdAt: Date;\n  public postCount: number;\n  public readonly category: ForumCategory | null;\n  private _posts: ForumPostCollection | null = null;\n\n  constructor(data: ForumThreadData) {\n    this.site = data.site;\n    this.id = data.id;\n    this.title = data.title;\n    this.description = data.description;\n    this.createdBy = data.createdBy;\n    this.createdAt = data.createdAt;\n    this.postCount = data.postCount;\n    this.category = data.category ?? null;\n  }\n\n  /**\n   * スレッドURL\n   */\n  getUrl(): string {\n    return `${this.site.getBaseUrl()}/forum/t-${this.id}/`;\n  }\n\n  /**\n   * 投稿一覧を取得\n   */\n  getPosts(): WikidotResultAsync<ForumPostCollection> {\n    if (this._posts !== null) {\n      return fromPromise(Promise.resolve(this._posts), (e) => new UnexpectedError(String(e)));\n    }\n\n    return ForumPostCollection.acquireAllInThread(this);\n  }\n\n  /**\n   * スレッドに返信\n   */\n  @RequireLogin\n  reply(\n    source: string,\n    title = '',\n    parentPostId: number | null = null\n  ): WikidotResultAsync<ForumThread> {\n    return fromPromise(\n      (async () => {\n        const result = await this.site.amcRequest([\n          {\n            threadId: String(this.id),\n            parentId: parentPostId !== null ? String(parentPostId) : '',\n            title,\n            source,\n            action: 'ForumAction',\n            event: 'savePost',\n            moduleName: 'Empty',\n          },\n        ]);\n        if (result.isErr()) {\n          throw result.error;\n        }\n        this._posts = null;\n        this.postCount += 1;\n        return this;\n      })(),\n      (error) => new UnexpectedError(`Failed to reply: ${String(error)}`)\n    );\n  }\n\n  toString(): string {\n    return `ForumThread(id=${this.id}, title=${this.title})`;\n  }\n\n  /**\n   * IDからスレッドを取得\n   */\n  static getFromId(\n    site: Site,\n    threadId: number,\n    category: ForumCategory | null = null\n  ): WikidotResultAsync<ForumThread> {\n    return fromPromise(\n      (async () => {\n        const result = await ForumThreadCollection.acquireFromThreadIds(site, [threadId], category);\n        if (result.isErr()) {\n          throw result.error;\n        }\n        const thread = result.value[0];\n        if (!thread) {\n          throw new NoElementError(`Thread not found: ${threadId}`);\n        }\n        return thread;\n      })(),\n      (error) => {\n        if (error instanceof NoElementError) return error;\n        return new UnexpectedError(`Failed to get thread: ${String(error)}`);\n      }\n    );\n  }\n}\n\n/**\n * フォーラムスレッドコレクション\n */\nexport class ForumThreadCollection extends Array<ForumThread> {\n  public readonly site: Site;\n\n  constructor(site: Site, threads?: ForumThread[]) {\n    super();\n    this.site = site;\n    if (threads) {\n      this.push(...threads);\n    }\n  }\n\n  /**\n   * IDで検索\n   */\n  findById(id: number): ForumThread | undefined {\n    return this.find((thread) => thread.id === id);\n  }\n\n  /**\n   * カテゴリ内の全スレッドを取得\n   */\n  static acquireAllInCategory(category: ForumCategory): WikidotResultAsync<ForumThreadCollection> {\n    return fromPromise(\n      (async () => {\n        const threads: ForumThread[] = [];\n\n        const firstResult = await category.site.amcRequest([\n          {\n            p: 1,\n            c: category.id,\n            moduleName: 'forum/ForumViewCategoryModule',\n          },\n        ]);\n\n        if (firstResult.isErr()) {\n          throw firstResult.error;\n        }\n\n        const firstResponse = firstResult.value[0];\n        if (!firstResponse) {\n          throw new NoElementError('Empty response');\n        }\n\n        const firstBody = String(firstResponse.body ?? '');\n        const $first = cheerio.load(firstBody);\n\n        $first('table.table tr.head~tr').each((_i, elem) => {\n          const $row = $first(elem);\n          const titleElem = $row.find('div.title a');\n          const href = titleElem.attr('href') ?? '';\n          const threadIdMatch = href.match(/t-(\\d+)/);\n          if (!threadIdMatch?.[1]) return;\n\n          const threadId = Number.parseInt(threadIdMatch[1], 10);\n          const title = titleElem.text().trim();\n          const description = $row.find('div.description').text().trim();\n          const postCount = Number.parseInt($row.find('td.posts').text().trim(), 10) || 0;\n\n          // ユーザーと日時のパース\n          const $userElem = $row.find('td.started span.printuser');\n          const $odateElem = $row.find('td.started span.odate');\n\n          const createdBy =\n            $userElem.length > 0\n              ? parseUser(category.site.client, $userElem as Cheerio<AnyNode>)\n              : null;\n          const createdAt =\n            $odateElem.length > 0\n              ? (parseOdate($odateElem as Cheerio<AnyNode>) ?? new Date())\n              : new Date();\n\n          threads.push(\n            new ForumThread({\n              site: category.site,\n              id: threadId,\n              title,\n              description,\n              createdBy,\n              createdAt,\n              postCount,\n              category,\n            })\n          );\n        });\n\n        // Check pagination\n        const pager = $first('div.pager');\n        if (pager.length === 0) {\n          return new ForumThreadCollection(category.site, threads);\n        }\n\n        const pagerLinks = pager.find('a');\n        if (pagerLinks.length < 2) {\n          return new ForumThreadCollection(category.site, threads);\n        }\n\n        const lastPageLink = pagerLinks[pagerLinks.length - 2];\n        const lastPageText = lastPageLink ? $first(lastPageLink).text().trim() : '1';\n        const lastPage = Number.parseInt(lastPageText, 10) || 1;\n\n        if (lastPage <= 1) {\n          return new ForumThreadCollection(category.site, threads);\n        }\n\n        // Fetch remaining pages\n        const bodies: { p: number; c: number; moduleName: string }[] = [];\n        for (let page = 2; page <= lastPage; page++) {\n          bodies.push({\n            p: page,\n            c: category.id,\n            moduleName: 'forum/ForumViewCategoryModule',\n          });\n        }\n\n        const additionalResults = await category.site.amcRequest(bodies);\n        if (additionalResults.isErr()) {\n          throw additionalResults.error;\n        }\n\n        for (const response of additionalResults.value) {\n          const body = String(response?.body ?? '');\n          const $ = cheerio.load(body);\n\n          $('table.table tr.head~tr').each((_i, elem) => {\n            const $row = $(elem);\n            const titleElem = $row.find('div.title a');\n            const href = titleElem.attr('href') ?? '';\n            const threadIdMatch = href.match(/t-(\\d+)/);\n            if (!threadIdMatch?.[1]) return;\n\n            const threadId = Number.parseInt(threadIdMatch[1], 10);\n            const title = titleElem.text().trim();\n            const description = $row.find('div.description').text().trim();\n            const postCount = Number.parseInt($row.find('td.posts').text().trim(), 10) || 0;\n\n            // ユーザーと日時のパース\n            const $userElem = $row.find('td.started span.printuser');\n            const $odateElem = $row.find('td.started span.odate');\n\n            const createdBy =\n              $userElem.length > 0\n                ? parseUser(category.site.client, $userElem as Cheerio<AnyNode>)\n                : null;\n            const createdAt =\n              $odateElem.length > 0\n                ? (parseOdate($odateElem as Cheerio<AnyNode>) ?? new Date())\n                : new Date();\n\n            threads.push(\n              new ForumThread({\n                site: category.site,\n                id: threadId,\n                title,\n                description,\n                createdBy,\n                createdAt,\n                postCount,\n                category,\n              })\n            );\n          });\n        }\n\n        return new ForumThreadCollection(category.site, threads);\n      })(),\n      (error) => {\n        if (error instanceof NoElementError) return error;\n        return new UnexpectedError(`Failed to acquire threads: ${String(error)}`);\n      }\n    );\n  }\n\n  /**\n   * スレッドIDから単一のスレッドを取得\n   * @param site - サイト\n   * @param threadId - スレッドID\n   */\n  static fromId(site: Site, threadId: number): WikidotResultAsync<ForumThread> {\n    return fromPromise(\n      (async () => {\n        const result = await ForumThreadCollection.acquireFromThreadIds(site, [threadId]);\n        if (result.isErr()) {\n          throw result.error;\n        }\n        const thread = result.value[0];\n        if (!thread) {\n          throw new NoElementError(`Thread not found: ${threadId}`);\n        }\n        return thread;\n      })(),\n      (error) => {\n        if (error instanceof NoElementError) return error;\n        return new UnexpectedError(`Failed to get thread: ${String(error)}`);\n      }\n    );\n  }\n\n  /**\n   * スレッドIDからスレッドを取得\n   */\n  static acquireFromThreadIds(\n    site: Site,\n    threadIds: number[],\n    category: ForumCategory | null = null\n  ): WikidotResultAsync<ForumThreadCollection> {\n    return fromPromise(\n      (async () => {\n        const result = await site.amcRequest(\n          threadIds.map((threadId) => ({\n            t: threadId,\n            moduleName: 'forum/ForumViewThreadModule',\n          }))\n        );\n\n        if (result.isErr()) {\n          throw result.error;\n        }\n\n        const threads: ForumThread[] = [];\n\n        for (let i = 0; i < threadIds.length; i++) {\n          const response = result.value[i];\n          const threadId = threadIds[i];\n          if (!response || !threadId) continue;\n\n          const body = String(response.body ?? '');\n          const $ = cheerio.load(body);\n\n          // Parse thread info from page\n          const bcElem = $('div.forum-breadcrumbs');\n          if (bcElem.length === 0) {\n            throw new NoElementError('Breadcrumbs not found');\n          }\n          const bcParts = bcElem.text().split('»');\n          const title = bcParts.length > 0 ? (bcParts[bcParts.length - 1]?.trim() ?? '') : '';\n\n          const descBlockElem = $('div.description-block');\n          const description = descBlockElem.text().trim();\n\n          const postCountMatch = $('div.statistics').text().match(/(\\d+)/);\n          const postCount = postCountMatch?.[1] ? Number.parseInt(postCountMatch[1], 10) : 0;\n\n          threads.push(\n            new ForumThread({\n              site,\n              id: threadId,\n              title,\n              description,\n              createdBy: null,\n              createdAt: new Date(),\n              postCount,\n              category,\n            })\n          );\n        }\n\n        return new ForumThreadCollection(site, threads);\n      })(),\n      (error) => {\n        if (error instanceof NoElementError) return error;\n        return new UnexpectedError(`Failed to acquire threads: ${String(error)}`);\n      }\n    );\n  }\n}\n",
    "/**\n * ロギング機能を提供するモジュール\n *\n * このモジュールは、ライブラリ全体で使用されるロガーを設定し、提供する。\n * デフォルトでは出力を行わず、アプリケーション側でのログ制御を可能にする。\n */\n\n/**\n * ログレベル\n */\nexport type LogLevel = 'debug' | 'info' | 'warn' | 'error';\n\n/**\n * ログレベルの優先度（数値が大きいほど重要）\n */\nconst LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {\n  debug: 0,\n  info: 1,\n  warn: 2,\n  error: 3,\n};\n\n/**\n * ロガーハンドラー\n */\nexport type LogHandler = (\n  level: LogLevel,\n  name: string,\n  message: string,\n  ...args: unknown[]\n) => void;\n\n/**\n * NullHandler: 何も出力しない（デフォルト）\n */\nexport const nullHandler: LogHandler = () => {\n  // 何もしない\n};\n\n/**\n * ConsoleHandler: コンソールに出力する\n */\nexport const consoleHandler: LogHandler = (\n  level: LogLevel,\n  name: string,\n  message: string,\n  ...args: unknown[]\n) => {\n  const timestamp = new Date().toISOString();\n  const formattedMessage = `${timestamp} [${name}/${level.toUpperCase()}] ${message}`;\n\n  switch (level) {\n    case 'debug':\n      console.debug(formattedMessage, ...args);\n      break;\n    case 'info':\n      console.info(formattedMessage, ...args);\n      break;\n    case 'warn':\n      console.warn(formattedMessage, ...args);\n      break;\n    case 'error':\n      console.error(formattedMessage, ...args);\n      break;\n  }\n};\n\n/**\n * ロガークラス\n */\nexport class Logger {\n  private readonly name: string;\n  private handler: LogHandler;\n  private level: LogLevel;\n\n  constructor(name: string, handler: LogHandler = nullHandler, level: LogLevel = 'warn') {\n    this.name = name;\n    this.handler = handler;\n    this.level = level;\n  }\n\n  /**\n   * ハンドラーを設定\n   */\n  setHandler(handler: LogHandler): void {\n    this.handler = handler;\n  }\n\n  /**\n   * ログレベルを設定\n   */\n  setLevel(level: LogLevel): void {\n    this.level = level;\n  }\n\n  /**\n   * 指定レベルがログ出力対象かどうか\n   */\n  private shouldLog(level: LogLevel): boolean {\n    return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.level];\n  }\n\n  /**\n   * ログ出力\n   */\n  private log(level: LogLevel, message: string, ...args: unknown[]): void {\n    if (this.shouldLog(level)) {\n      this.handler(level, this.name, message, ...args);\n    }\n  }\n\n  debug(message: string, ...args: unknown[]): void {\n    this.log('debug', message, ...args);\n  }\n\n  info(message: string, ...args: unknown[]): void {\n    this.log('info', message, ...args);\n  }\n\n  warn(message: string, ...args: unknown[]): void {\n    this.log('warn', message, ...args);\n  }\n\n  error(message: string, ...args: unknown[]): void {\n    this.log('error', message, ...args);\n  }\n}\n\n/**\n * ロガーを取得\n * @param name - ロガー名（デフォルト: \"wikidot\"）\n * @returns ロガーインスタンス\n */\nexport function getLogger(name = 'wikidot'): Logger {\n  return new Logger(name);\n}\n\n/**\n * コンソール出力用ハンドラを設定\n * @param logger - 設定するロガー\n * @param level - ログレベル（デフォルト: \"warn\"）\n */\nexport function setupConsoleHandler(logger: Logger, level: LogLevel = 'warn'): void {\n  logger.setHandler(consoleHandler);\n  logger.setLevel(level);\n}\n\n/**\n * パッケージ全体で使用されるデフォルトロガー\n */\nexport const logger: Logger = getLogger();\n",
    "import type { ClientRef } from '../types';\nimport type { AbstractUser, UserType } from './abstract-user';\n\n/**\n * 匿名ユーザー\n */\nexport class AnonymousUser implements AbstractUser {\n  public readonly client: ClientRef;\n\n  /** ユーザーID（匿名は0） */\n  public readonly id: number = 0;\n\n  /** ユーザー名（匿名は\"Anonymous\"） */\n  public readonly name: string = 'Anonymous';\n\n  /** UNIX形式のユーザー名 */\n  public readonly unixName: string = 'anonymous';\n\n  /** アバターURL（匿名はnull） */\n  public readonly avatarUrl: string | null = null;\n\n  /** IPアドレス */\n  public readonly ip: string;\n\n  /** ユーザー種別 */\n  public readonly userType: UserType = 'anonymous';\n\n  constructor(client: ClientRef, ip: string) {\n    this.client = client;\n    this.ip = ip;\n  }\n\n  // AbstractUser実装\n  isUser(): boolean {\n    return false;\n  }\n  isDeletedUser(): boolean {\n    return false;\n  }\n  isAnonymousUser(): boolean {\n    return true;\n  }\n  isGuestUser(): boolean {\n    return false;\n  }\n  isWikidotUser(): boolean {\n    return false;\n  }\n\n  toString(): string {\n    return `AnonymousUser(name=${this.name}, unixName=${this.unixName}, ip=${this.ip})`;\n  }\n}\n",
    "import type { ClientRef } from '../types';\nimport type { AbstractUser, UserType } from './abstract-user';\n\n/**\n * 削除済みユーザー\n */\nexport class DeletedUser implements AbstractUser {\n  public readonly client: ClientRef;\n\n  /** 削除済みユーザーID */\n  public readonly id: number;\n\n  /** ユーザー名（削除済みは\"account deleted\"） */\n  public readonly name: string = 'account deleted';\n\n  /** UNIX形式のユーザー名 */\n  public readonly unixName: string = 'account_deleted';\n\n  /** アバターURL（削除済みはnull） */\n  public readonly avatarUrl: string | null = null;\n\n  /** IPアドレス（削除済みはnull） */\n  public readonly ip: string | null = null;\n\n  /** ユーザー種別 */\n  public readonly userType: UserType = 'deleted';\n\n  constructor(client: ClientRef, id: number) {\n    this.client = client;\n    this.id = id;\n  }\n\n  // AbstractUser実装\n  isUser(): boolean {\n    return false;\n  }\n  isDeletedUser(): boolean {\n    return true;\n  }\n  isAnonymousUser(): boolean {\n    return false;\n  }\n  isGuestUser(): boolean {\n    return false;\n  }\n  isWikidotUser(): boolean {\n    return false;\n  }\n\n  toString(): string {\n    return `DeletedUser(id=${this.id}, name=${this.name}, unixName=${this.unixName})`;\n  }\n}\n",
    "import type { ClientRef } from '../types';\nimport type { AbstractUser, UserType } from './abstract-user';\n\n/**\n * ゲストユーザー\n */\nexport class GuestUser implements AbstractUser {\n  public readonly client: ClientRef;\n\n  /** ユーザーID（ゲストは0） */\n  public readonly id: number = 0;\n\n  /** ゲスト名 */\n  public readonly name: string;\n\n  /** UNIX形式のユーザー名（ゲストはnull） */\n  public readonly unixName: string | null = null;\n\n  /** アバターURL（Gravatarの場合あり） */\n  public readonly avatarUrl: string | null;\n\n  /** IPアドレス（ゲストはnull） */\n  public readonly ip: string | null = null;\n\n  /** ユーザー種別 */\n  public readonly userType: UserType = 'guest';\n\n  constructor(client: ClientRef, name: string, avatarUrl: string | null = null) {\n    this.client = client;\n    this.name = name;\n    this.avatarUrl = avatarUrl;\n  }\n\n  // AbstractUser実装\n  isUser(): boolean {\n    return false;\n  }\n  isDeletedUser(): boolean {\n    return false;\n  }\n  isAnonymousUser(): boolean {\n    return false;\n  }\n  isGuestUser(): boolean {\n    return true;\n  }\n  isWikidotUser(): boolean {\n    return false;\n  }\n\n  toString(): string {\n    return `GuestUser(name=${this.name})`;\n  }\n}\n",
    "import type { ClientRef } from '../types';\nimport type { AbstractUser, UserType } from './abstract-user';\n\n/**\n * Wikidotシステムユーザー\n */\nexport class WikidotUser implements AbstractUser {\n  public readonly client: ClientRef;\n\n  /** ユーザーID（Wikidotシステムは0） */\n  public readonly id: number = 0;\n\n  /** ユーザー名 */\n  public readonly name: string = 'Wikidot';\n\n  /** UNIX形式のユーザー名 */\n  public readonly unixName: string = 'wikidot';\n\n  /** アバターURL（システムユーザーはnull） */\n  public readonly avatarUrl: string | null = null;\n\n  /** IPアドレス（システムユーザーはnull） */\n  public readonly ip: string | null = null;\n\n  /** ユーザー種別 */\n  public readonly userType: UserType = 'wikidot';\n\n  constructor(client: ClientRef) {\n    this.client = client;\n  }\n\n  // AbstractUser実装\n  isUser(): boolean {\n    return false;\n  }\n  isDeletedUser(): boolean {\n    return false;\n  }\n  isAnonymousUser(): boolean {\n    return false;\n  }\n  isGuestUser(): boolean {\n    return false;\n  }\n  isWikidotUser(): boolean {\n    return true;\n  }\n\n  toString(): string {\n    return `WikidotUser(name=${this.name}, unixName=${this.unixName})`;\n  }\n}\n",
    "import type * as cheerio from 'cheerio';\nimport type { AnyNode } from 'domhandler';\nimport { logger } from '../../common/logger';\nimport type { ClientRef } from '../../module/types';\nimport type { AbstractUser } from '../../module/user';\nimport { AnonymousUser, DeletedUser, GuestUser, User, WikidotUser } from '../../module/user';\n\n/**\n * printuser要素をパースし、ユーザーオブジェクトを返す\n *\n * @param client - Wikidotクライアント\n * @param elem - パース対象の要素（printuserクラスがついた要素）\n * @returns パースされて得られたユーザーオブジェクト\n */\nexport function parseUser(client: ClientRef, elem: cheerio.Cheerio<AnyNode>): AbstractUser {\n  const classAttr = elem.attr('class') ?? '';\n  const classes = classAttr.split(/\\s+/);\n\n  // 削除済みユーザー判定\n  if (classes.includes('deleted')) {\n    const dataId = elem.attr('data-id');\n    const userId = dataId ? Number.parseInt(dataId, 10) : 0;\n    return new DeletedUser(client, userId);\n  }\n\n  // テキストが \"(user deleted)\" の場合\n  const text = elem.text().trim();\n  if (text === '(user deleted)') {\n    return new DeletedUser(client, 0);\n  }\n\n  // 匿名ユーザー判定\n  if (classes.includes('anonymous')) {\n    const ipElem = elem.find('span.ip');\n    if (ipElem.length > 0) {\n      const ip = ipElem.text().replace(/[()]/g, '').trim();\n      return new AnonymousUser(client, ip);\n    }\n    return new AnonymousUser(client, '');\n  }\n\n  // ゲストユーザー判定（Gravatarアバターを持つ）\n  const imgElem = elem.find('img');\n  if (imgElem.length > 0) {\n    const src = imgElem.attr('src') ?? '';\n    if (src.includes('gravatar.com')) {\n      const guestName = text.split(' ')[0] ?? 'Guest';\n      return new GuestUser(client, guestName, src);\n    }\n  }\n\n  // Wikidotシステムユーザー判定\n  if (text === 'Wikidot') {\n    return new WikidotUser(client);\n  }\n\n  // 通常ユーザー\n  const links = elem.find('a');\n  if (links.length === 0) {\n    // リンクがない場合はDeletedUserとして扱う\n    return new DeletedUser(client, 0);\n  }\n\n  // 最後のリンクがユーザーリンク\n  const userLink = links.last();\n  const userName = userLink.text().trim();\n  const href = userLink.attr('href') ?? '';\n  const onclick = userLink.attr('onclick') ?? '';\n\n  // unix_nameをhrefから抽出\n  const unixName = href.replace(/^.*\\/user:info\\//, '').replace(/\\/$/, '');\n\n  // user_idをonclickから抽出\n  // パターン: \"WIKIDOT.page.listeners.userInfo(123456); return false;\"\n  const userIdMatch = onclick.match(/userInfo\\((\\d+)\\)/);\n  const userId = userIdMatch?.[1] ? Number.parseInt(userIdMatch[1], 10) : 0;\n\n  // アバターURLを生成\n  const avatarUrl = userId > 0 ? `http://www.wikidot.com/avatar.php?userid=${userId}` : undefined;\n\n  return new User(client, {\n    id: userId,\n    name: userName,\n    unixName,\n    avatarUrl,\n  });\n}\n\n/**\n * odate要素から日時をパースする\n *\n * @param elem - パース対象の要素（odate要素）\n * @returns パースされたDate、パース失敗時はnull\n */\nexport function parseOdate(elem: cheerio.Cheerio<AnyNode>): Date | null {\n  const classAttr = elem.attr('class') ?? '';\n\n  // クラスから Unix タイムスタンプを抽出\n  // パターン: \"odate time_1234567890 format_...\" のような形式\n  const timeMatch = classAttr.match(/time_(\\d+)/);\n  if (timeMatch?.[1]) {\n    const unixTime = Number.parseInt(timeMatch[1], 10);\n    return new Date(unixTime * 1000);\n  }\n\n  // フォールバック: テキストからパース\n  const text = elem.text().trim();\n  const parsed = Date.parse(text);\n  if (!Number.isNaN(parsed)) {\n    return new Date(parsed);\n  }\n\n  // パースできない場合はnullを返却し、警告をログ出力\n  logger.warn(`Failed to parse odate element: class=\"${classAttr}\", text=\"${text}\"`);\n  return null;\n}\n",
    "import type { Cheerio, CheerioAPI } from 'cheerio';\nimport * as cheerio from 'cheerio';\nimport type { AnyNode, Element } from 'domhandler';\nimport { RequireLogin } from '../../common/decorators';\nimport { LoginRequiredError, NoElementError, UnexpectedError } from '../../common/errors';\nimport { fromPromise, type WikidotResultAsync } from '../../common/types';\nimport { parseOdate, parseUser } from '../../util/parser';\nimport type { Client } from '../client';\nimport type { ForumThreadRef } from '../types';\nimport type { AbstractUser } from '../user';\n\n/**\n * フォーラム投稿データ\n */\nexport interface ForumPostData {\n  thread: ForumThreadRef;\n  id: number;\n  title: string;\n  text: string;\n  element: Element;\n  createdBy: AbstractUser;\n  createdAt: Date;\n  editedBy?: AbstractUser | null;\n  editedAt?: Date | null;\n  parentId?: number | null;\n}\n\n/**\n * フォーラム投稿\n */\nexport class ForumPost {\n  public readonly thread: ForumThreadRef;\n  public readonly id: number;\n  public title: string;\n  public readonly text: string;\n  public readonly element: Element;\n  public readonly createdBy: AbstractUser;\n  public readonly createdAt: Date;\n  public readonly editedBy: AbstractUser | null;\n  public readonly editedAt: Date | null;\n  private _parentId: number | null;\n  private _source: string | null = null;\n\n  constructor(data: ForumPostData) {\n    this.thread = data.thread;\n    this.id = data.id;\n    this.title = data.title;\n    this.text = data.text;\n    this.element = data.element;\n    this.createdBy = data.createdBy;\n    this.createdAt = data.createdAt;\n    this.editedBy = data.editedBy ?? null;\n    this.editedAt = data.editedAt ?? null;\n    this._parentId = data.parentId ?? null;\n  }\n\n  /**\n   * 親投稿ID\n   */\n  get parentId(): number | null {\n    return this._parentId;\n  }\n\n  /**\n   * ソースコード（Wikidot記法）を取得\n   */\n  getSource(): WikidotResultAsync<string> {\n    if (this._source !== null) {\n      return fromPromise(Promise.resolve(this._source), (e) => new UnexpectedError(String(e)));\n    }\n\n    return fromPromise(\n      (async () => {\n        const result = await this.thread.site.amcRequest([\n          {\n            moduleName: 'forum/sub/ForumEditPostFormModule',\n            threadId: this.thread.id,\n            postId: this.id,\n          },\n        ]);\n\n        if (result.isErr()) {\n          throw result.error;\n        }\n\n        const response = result.value[0];\n        if (!response) {\n          throw new NoElementError('Empty response');\n        }\n\n        const $ = cheerio.load(String(response.body ?? ''));\n        const sourceElem = $(\"textarea[name='source']\");\n        if (sourceElem.length === 0) {\n          throw new NoElementError('Source textarea not found');\n        }\n        this._source = sourceElem.text();\n        return this._source;\n      })(),\n      (error) => {\n        if (error instanceof NoElementError) return error;\n        return new UnexpectedError(`Failed to get post source: ${String(error)}`);\n      }\n    );\n  }\n\n  /**\n   * 投稿を編集する\n   * @param source - 新しいソース（Wikidot記法）\n   * @param title - 新しいタイトル（省略時は現在のタイトルを維持）\n   */\n  @RequireLogin\n  edit(source: string, title?: string): WikidotResultAsync<void> {\n    return fromPromise(\n      (async () => {\n        // 現在のリビジョンIDを取得\n        const formResult = await this.thread.site.amcRequest([\n          {\n            moduleName: 'forum/sub/ForumEditPostFormModule',\n            threadId: this.thread.id,\n            postId: this.id,\n          },\n        ]);\n\n        if (formResult.isErr()) {\n          throw formResult.error;\n        }\n\n        const formResponse = formResult.value[0];\n        if (!formResponse) {\n          throw new NoElementError('Empty form response');\n        }\n\n        const $ = cheerio.load(String(formResponse.body ?? ''));\n        const revisionInput = $(\"input[name='currentRevisionId']\");\n        if (revisionInput.length === 0) {\n          throw new NoElementError('Current revision ID input not found');\n        }\n\n        const revisionValue = revisionInput.val();\n        const currentRevisionId = Number.parseInt(String(revisionValue ?? ''), 10);\n        if (Number.isNaN(currentRevisionId)) {\n          throw new NoElementError('Invalid revision ID value');\n        }\n\n        // 編集を保存\n        const editResult = await this.thread.site.amcRequest([\n          {\n            action: 'ForumAction',\n            event: 'saveEditPost',\n            moduleName: 'Empty',\n            postId: this.id,\n            currentRevisionId,\n            title: title ?? this.title,\n            source,\n          },\n        ]);\n\n        if (editResult.isErr()) {\n          throw editResult.error;\n        }\n\n        // ローカル状態を更新\n        if (title !== undefined) {\n          this.title = title;\n        }\n        this._source = source;\n      })(),\n      (error) => {\n        if (error instanceof NoElementError || error instanceof LoginRequiredError) {\n          return error;\n        }\n        return new UnexpectedError(`Failed to edit post: ${String(error)}`);\n      }\n    );\n  }\n\n  toString(): string {\n    return `ForumPost(id=${this.id}, title=${this.title})`;\n  }\n}\n\n/**\n * フォーラム投稿コレクション\n */\nexport class ForumPostCollection extends Array<ForumPost> {\n  public readonly thread: ForumThreadRef;\n\n  constructor(thread: ForumThreadRef, posts?: ForumPost[]) {\n    super();\n    this.thread = thread;\n    if (posts) {\n      this.push(...posts);\n    }\n  }\n\n  /**\n   * IDで検索\n   * @param id - 投稿ID\n   * @returns 投稿（存在しない場合はundefined）\n   */\n  findById(id: number): ForumPost | undefined {\n    return this.find((post) => post.id === id);\n  }\n\n  /**\n   * HTMLから投稿をパースする（内部メソッド）\n   */\n  private static _parse(thread: ForumThreadRef, $: CheerioAPI): ForumPost[] {\n    const posts: ForumPost[] = [];\n\n    $('div.post').each((_i, postElem) => {\n      const $post = $(postElem);\n      const postIdAttr = $post.attr('id');\n      if (!postIdAttr) return;\n\n      const postId = Number.parseInt(postIdAttr.replace('post-', ''), 10);\n      if (Number.isNaN(postId)) return;\n\n      // 親投稿IDの取得\n      let parentId: number | null = null;\n      const $parentContainer = $post.parent();\n      if ($parentContainer.length > 0) {\n        const $grandparent = $parentContainer.parent();\n        if ($grandparent.length > 0 && $grandparent[0]?.name !== 'body') {\n          const grandparentClasses = $grandparent.attr('class') ?? '';\n          if (grandparentClasses.includes('post-container')) {\n            const $parentPost = $grandparent.find('> div.post');\n            if ($parentPost.length > 0) {\n              const parentPostIdAttr = $parentPost.attr('id');\n              if (parentPostIdAttr) {\n                parentId = Number.parseInt(parentPostIdAttr.replace('post-', ''), 10);\n              }\n            }\n          }\n        }\n      }\n\n      // タイトルと本文の取得\n      const $wrapper = $post.find('div.long');\n      if ($wrapper.length === 0) return;\n\n      const $head = $wrapper.find('div.head');\n      if ($head.length === 0) return;\n\n      const $title = $head.find('div.title');\n      const title = $title.text().trim();\n\n      const $content = $wrapper.find('div.content');\n      const text = $content.html() ?? '';\n\n      // 投稿者と日時\n      const $info = $head.find('div.info');\n      if ($info.length === 0) return;\n\n      const $userElem = $info.find('span.printuser');\n      if ($userElem.length === 0) return;\n\n      const createdBy = parseUser(thread.site.client as Client, $userElem as Cheerio<AnyNode>);\n\n      const $odateElem = $info.find('span.odate');\n      if ($odateElem.length === 0) return;\n\n      const createdAt = parseOdate($odateElem as Cheerio<AnyNode>) ?? new Date();\n\n      // 編集情報（存在する場合）\n      let editedBy: AbstractUser | null = null;\n      let editedAt: Date | null = null;\n      const $changes = $wrapper.find('div.changes');\n      if ($changes.length > 0) {\n        const $editUserElem = $changes.find('span.printuser');\n        const $editOdateElem = $changes.find('span.odate');\n        if ($editUserElem.length > 0 && $editOdateElem.length > 0) {\n          editedBy = parseUser(thread.site.client as Client, $editUserElem as Cheerio<AnyNode>);\n          editedAt = parseOdate($editOdateElem as Cheerio<AnyNode>);\n        }\n      }\n\n      posts.push(\n        new ForumPost({\n          thread,\n          id: postId,\n          title,\n          text,\n          element: postElem as Element,\n          createdBy,\n          createdAt,\n          editedBy,\n          editedAt,\n          parentId,\n        })\n      );\n    });\n\n    return posts;\n  }\n\n  /**\n   * スレッド内の全投稿を取得\n   */\n  static acquireAllInThread(thread: ForumThreadRef): WikidotResultAsync<ForumPostCollection> {\n    return fromPromise(\n      (async () => {\n        const posts: ForumPost[] = [];\n\n        const firstResult = await thread.site.amcRequest([\n          {\n            moduleName: 'forum/ForumViewThreadPostsModule',\n            pageNo: '1',\n            t: String(thread.id),\n          },\n        ]);\n\n        if (firstResult.isErr()) {\n          throw firstResult.error;\n        }\n\n        const firstResponse = firstResult.value[0];\n        if (!firstResponse) {\n          throw new NoElementError('Empty response');\n        }\n\n        const firstBody = String(firstResponse.body ?? '');\n        const $first = cheerio.load(firstBody);\n\n        posts.push(...ForumPostCollection._parse(thread, $first));\n\n        // ページネーション確認\n        const $pager = $first('div.pager');\n        if ($pager.length === 0) {\n          return new ForumPostCollection(thread, posts);\n        }\n\n        const $pagerTargets = $pager.find('span.target');\n        if ($pagerTargets.length < 2) {\n          return new ForumPostCollection(thread, posts);\n        }\n\n        // 最後から2番目のページリンクから最終ページ番号を取得\n        const lastPageText = $pagerTargets\n          .eq($pagerTargets.length - 2)\n          .text()\n          .trim();\n        const lastPage = Number.parseInt(lastPageText, 10);\n        if (Number.isNaN(lastPage) || lastPage <= 1) {\n          return new ForumPostCollection(thread, posts);\n        }\n\n        // 残りのページを取得\n        const bodies: { moduleName: string; pageNo: string; t: string }[] = [];\n        for (let page = 2; page <= lastPage; page++) {\n          bodies.push({\n            moduleName: 'forum/ForumViewThreadPostsModule',\n            pageNo: String(page),\n            t: String(thread.id),\n          });\n        }\n\n        const additionalResults = await thread.site.amcRequest(bodies);\n        if (additionalResults.isErr()) {\n          throw additionalResults.error;\n        }\n\n        for (const response of additionalResults.value) {\n          const body = String(response?.body ?? '');\n          const $ = cheerio.load(body);\n          posts.push(...ForumPostCollection._parse(thread, $));\n        }\n\n        return new ForumPostCollection(thread, posts);\n      })(),\n      (error) => {\n        if (error instanceof NoElementError) return error;\n        return new UnexpectedError(`Failed to acquire posts: ${String(error)}`);\n      }\n    );\n  }\n}\n"
  ],
  "mappings": "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",
  "debugId": "B1748EA576F96A3164756E2164756E21",
  "names": []
}