@ukwhatn/wikidot 1.0.10 → 4.0.2

package/dist/index.js

@@ -1,6 +1,2651 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Client = void 0;
-var client_1 = require("./module/client");
-Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_1.Client; } });
-//# sourceMappingURL=index.js.map
+import {
+  AnonymousUser,
+  DeletedUser,
+  ForumCategory,
+  ForumCategoryCollection,
+  ForumPost,
+  ForumPostCollection,
+  ForumThread,
+  ForumThreadCollection,
+  GuestUser,
+  Logger,
+  RequireLogin,
+  WikidotUser,
+  consoleHandler,
+  getLogger,
+  logger,
+  nullHandler,
+  parseOdate,
+  parseUser,
+  setupConsoleHandler
+} from "./shared/index-ytknx2hn.js";
+import {
+  PageRevision,
+  PageRevisionCollection
+} from "./shared/index-f2eh3ykk.js";
+import {
+  User,
+  UserCollection
+} from "./shared/index-kka6e8cb.js";
+import {
+  AMCError,
+  AMCHttpError,
+  ForbiddenError,
+  LoginRequiredError,
+  NoElementError,
+  NotFoundException,
+  ResponseDataError,
+  SessionCreateError,
+  SessionError,
+  TargetError,
+  TargetExistsError,
+  UnexpectedError,
+  WikidotError,
+  WikidotStatusError,
+  __legacyDecorateClassTS,
+  __require,
+  __toESM,
+  combineResults,
+  fromPromise,
+  wdErr,
+  wdErrAsync,
+  wdOk,
+  wdOkAsync
+} from "./shared/index-7dqqxq7x.js";
+// src/connector/amc-client.ts
+import ky from "ky";
+import pLimit from "p-limit";
+
+// src/connector/amc-config.ts
+var DEFAULT_AMC_CONFIG = {
+  timeout: 20000,
+  retryLimit: 3,
+  retryInterval: 1000,
+  maxBackoff: 60000,
+  backoffFactor: 2,
+  semaphoreLimit: 10
+};
+var WIKIDOT_TOKEN7 = "123456";
+var DEFAULT_HTTP_STATUS_CODE = 999;
+
+// src/connector/amc-header.ts
+class AMCHeader {
+  cookies;
+  contentType;
+  userAgent;
+  referer;
+  constructor(options) {
+    this.contentType = options?.contentType ?? "application/x-www-form-urlencoded; charset=UTF-8";
+    this.userAgent = options?.userAgent ?? "WikidotTS";
+    this.referer = options?.referer ?? "https://www.wikidot.com/";
+    this.cookies = new Map([["wikidot_token7", "123456"]]);
+  }
+  setCookie(name, value) {
+    this.cookies.set(name, value);
+  }
+  deleteCookie(name) {
+    this.cookies.delete(name);
+  }
+  getCookie(name) {
+    return this.cookies.get(name);
+  }
+  getHeaders() {
+    const cookieString = Array.from(this.cookies.entries()).map(([name, value]) => `${name}=${value}`).join("; ");
+    return {
+      "Content-Type": this.contentType,
+      "User-Agent": this.userAgent,
+      Referer: this.referer,
+      Cookie: cookieString
+    };
+  }
+}
+
+// src/connector/amc-types.ts
+import { z } from "zod";
+var baseSchema = z.object({
+  status: z.string(),
+  body: z.string().optional(),
+  message: z.string().optional()
+});
+var amcResponseSchema = baseSchema.passthrough();
+function isSuccessResponse(response) {
+  return response.status === "ok";
+}
+
+// src/connector/amc-client.ts
+function maskSensitiveData(body) {
+  const masked = { ...body };
+  const sensitiveKeys = ["password", "login", "WIKIDOT_SESSION_ID", "wikidot_token7"];
+  for (const key of sensitiveKeys) {
+    if (key in masked) {
+      masked[key] = "***MASKED***";
+    }
+  }
+  return masked;
+}
+function calculateBackoff(retryCount, baseInterval, backoffFactor, maxBackoff) {
+  const backoff = baseInterval * backoffFactor ** (retryCount - 1);
+  const jitter = Math.random() * backoff * 0.1;
+  return Math.min(backoff + jitter, maxBackoff);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+class AMCClient {
+  ky;
+  limit;
+  header;
+  config;
+  domain;
+  sslCache = new Map;
+  constructor(config = {}, domain = "wikidot.com") {
+    this.config = { ...DEFAULT_AMC_CONFIG, ...config };
+    this.domain = domain;
+    this.header = new AMCHeader;
+    this.limit = pLimit(this.config.semaphoreLimit);
+    this.ky = ky.create({
+      timeout: this.config.timeout,
+      retry: 0
+    });
+    this.sslCache.set("www", true);
+  }
+  checkSiteSSL(siteName) {
+    const cached = this.sslCache.get(siteName);
+    if (cached !== undefined) {
+      return wdOkAsync(cached);
+    }
+    if (siteName === "www") {
+      return wdOkAsync(true);
+    }
+    return fromPromise((async () => {
+      const response = await fetch(`http://${siteName}.${this.domain}`, {
+        method: "GET",
+        redirect: "manual"
+      });
+      if (response.status === 404) {
+        throw new NotFoundException(`Site is not found: ${siteName}.${this.domain}`);
+      }
+      const isSSL = response.status === 301 && response.headers.get("Location")?.startsWith("https") === true;
+      this.sslCache.set(siteName, isSSL);
+      return isSSL;
+    })(), (error) => {
+      if (error instanceof WikidotError) {
+        return error;
+      }
+      return new UnexpectedError(`Failed to check SSL for ${siteName}: ${String(error)}`);
+    });
+  }
+  request(bodies, siteName = "www", sslSupported) {
+    return this.requestWithOptions(bodies, {
+      siteName,
+      sslSupported,
+      returnExceptions: false
+    });
+  }
+  requestWithOptions(bodies, options = {}) {
+    const { siteName = "www", sslSupported, returnExceptions = false } = options;
+    return fromPromise((async () => {
+      let ssl = sslSupported;
+      if (ssl === undefined) {
+        const sslResult = await this.checkSiteSSL(siteName);
+        if (sslResult.isErr()) {
+          throw sslResult.error;
+        }
+        ssl = sslResult.value;
+      }
+      const protocol = ssl ? "https" : "http";
+      const url = `${protocol}://${siteName}.${this.domain}/ajax-module-connector.php`;
+      const results = await Promise.all(bodies.map((body) => this.limit(() => this.singleRequest(body, url))));
+      if (returnExceptions) {
+        return results.map((r) => {
+          if (r.isOk()) {
+            return r.value;
+          }
+          return r.error;
+        });
+      }
+      const firstError = results.find((r) => r.isErr());
+      if (firstError?.isErr()) {
+        throw firstError.error;
+      }
+      return results.map((r) => {
+        if (r.isOk()) {
+          return r.value;
+        }
+        throw new UnexpectedError("Unexpected error in result processing");
+      });
+    })(), (error) => {
+      if (error instanceof WikidotError) {
+        return error;
+      }
+      return new UnexpectedError(`AMC request failed: ${String(error)}`);
+    });
+  }
+  async singleRequest(body, url) {
+    let retryCount = 0;
+    while (true) {
+      try {
+        const requestBody = { ...body, wikidot_token7: WIKIDOT_TOKEN7 };
+        const formData = new URLSearchParams;
+        for (const [key, value] of Object.entries(requestBody)) {
+          if (value !== undefined) {
+            formData.append(key, String(value));
+          }
+        }
+        const response = await this.ky.post(url, {
+          headers: this.header.getHeaders(),
+          body: formData.toString()
+        });
+        let responseData;
+        try {
+          responseData = await response.json();
+        } catch {
+          return wdErrAsync(new ResponseDataError(`AMC responded with non-JSON data: ${await response.text()}`));
+        }
+        const parseResult = amcResponseSchema.safeParse(responseData);
+        if (!parseResult.success) {
+          return wdErrAsync(new ResponseDataError(`Invalid AMC response format: ${parseResult.error.message}`));
+        }
+        const amcResponse = parseResult.data;
+        if (amcResponse.status === "try_again") {
+          retryCount++;
+          if (retryCount >= this.config.retryLimit) {
+            return wdErrAsync(new WikidotStatusError("AMC responded with try_again", "try_again"));
+          }
+          const backoff = calculateBackoff(retryCount, this.config.retryInterval, this.config.backoffFactor, this.config.maxBackoff);
+          await sleep(backoff);
+          continue;
+        }
+        if (amcResponse.status === "no_permission") {
+          const targetStr = body.moduleName ? `moduleName: ${body.moduleName}` : body.action ? `action: ${body.action}/${body.event ?? ""}` : "unknown";
+          return wdErrAsync(new ForbiddenError(`Your account has no permission to perform this action: ${targetStr}`));
+        }
+        if (amcResponse.status !== "ok") {
+          return wdErrAsync(new WikidotStatusError(`AMC responded with error status: "${amcResponse.status}"`, amcResponse.status));
+        }
+        return wdOkAsync(amcResponse);
+      } catch (error) {
+        retryCount++;
+        if (retryCount >= this.config.retryLimit) {
+          const statusCode = error instanceof Error && "response" in error ? error.response?.status ?? DEFAULT_HTTP_STATUS_CODE : DEFAULT_HTTP_STATUS_CODE;
+          return wdErrAsync(new AMCHttpError(`AMC HTTP request failed: ${String(error)}`, statusCode));
+        }
+        const backoff = calculateBackoff(retryCount, this.config.retryInterval, this.config.backoffFactor, this.config.maxBackoff);
+        await sleep(backoff);
+      }
+    }
+  }
+}
+// src/connector/auth.ts
+var LOGIN_URL = "https://www.wikidot.com/default--flow/login__LoginPopupScreen";
+function login(client, username, password) {
+  return fromPromise((async () => {
+    const formData = new URLSearchParams({
+      login: username,
+      password,
+      action: "Login2Action",
+      event: "login"
+    });
+    const response = await fetch(LOGIN_URL, {
+      method: "POST",
+      headers: client.amcClient.header.getHeaders(),
+      body: formData.toString()
+    });
+    if (!response.ok) {
+      throw new SessionCreateError(`Login attempt failed due to HTTP status code: ${response.status}`);
+    }
+    const body = await response.text();
+    if (body.includes("The login and password do not match")) {
+      throw new SessionCreateError("Login attempt failed due to invalid username or password");
+    }
+    const cookies = response.headers.get("Set-Cookie");
+    if (!cookies) {
+      throw new SessionCreateError("Login attempt failed due to missing cookies");
+    }
+    const sessionIdMatch = cookies.match(/WIKIDOT_SESSION_ID=([^;]+)/);
+    if (!sessionIdMatch?.[1]) {
+      throw new SessionCreateError("Login attempt failed due to missing WIKIDOT_SESSION_ID cookie");
+    }
+    client.amcClient.header.setCookie("WIKIDOT_SESSION_ID", sessionIdMatch[1]);
+  })(), (error) => {
+    if (error instanceof SessionCreateError) {
+      return error;
+    }
+    return new SessionCreateError(`Login failed: ${String(error)}`);
+  });
+}
+function logout(client) {
+  return client.amcClient.request([
+    {
+      moduleName: "Empty",
+      action: "Login2Action",
+      event: "logout"
+    }
+  ]).map(() => {
+    client.amcClient.header.deleteCookie("WIKIDOT_SESSION_ID");
+    return;
+  }).orElse(() => {
+    client.amcClient.header.deleteCookie("WIKIDOT_SESSION_ID");
+    return wdOkAsync(undefined);
+  });
+}
+// src/module/private-message/private-message.ts
+import * as cheerio from "cheerio";
+class PrivateMessage {
+  client;
+  id;
+  sender;
+  recipient;
+  subject;
+  body;
+  createdAt;
+  constructor(data) {
+    this.client = data.client;
+    this.id = data.id;
+    this.sender = data.sender;
+    this.recipient = data.recipient;
+    this.subject = data.subject;
+    this.body = data.body;
+    this.createdAt = data.createdAt;
+  }
+  static fromId(client, messageId) {
+    return fromPromise((async () => {
+      const result = await PrivateMessageCollection.fromIds(client, [messageId]);
+      if (result.isErr()) {
+        throw result.error;
+      }
+      const message = result.value[0];
+      if (!message) {
+        throw new NoElementError(`Message not found: ${messageId}`);
+      }
+      return message;
+    })(), (error) => {
+      if (error instanceof ForbiddenError || error instanceof NoElementError) {
+        return error;
+      }
+      return new UnexpectedError(`Failed to get message: ${String(error)}`);
+    });
+  }
+  static send(client, recipient, subject, body) {
+    const loginResult = client.requireLogin();
+    if (loginResult.isErr()) {
+      return fromPromise(Promise.reject(loginResult.error), () => new LoginRequiredError("Login required to send message"));
+    }
+    return fromPromise((async () => {
+      const result = await client.amcClient.request([
+        {
+          source: body,
+          subject,
+          to_user_id: recipient.id,
+          action: "DashboardMessageAction",
+          event: "send",
+          moduleName: "Empty"
+        }
+      ]);
+      if (result.isErr()) {
+        throw result.error;
+      }
+    })(), (error) => new UnexpectedError(`Failed to send message: ${String(error)}`));
+  }
+  toString() {
+    return `PrivateMessage(id=${this.id}, sender=${this.sender}, recipient=${this.recipient}, subject=${this.subject})`;
+  }
+}
+
+class PrivateMessageCollection extends Array {
+  client;
+  constructor(client, messages) {
+    super();
+    this.client = client;
+    if (messages) {
+      this.push(...messages);
+    }
+  }
+  findById(id) {
+    return this.find((message) => message.id === id);
+  }
+  static fromIds(client, messageIds) {
+    const loginResult = client.requireLogin();
+    if (loginResult.isErr()) {
+      return fromPromise(Promise.reject(loginResult.error), () => new LoginRequiredError("Login required to get messages"));
+    }
+    return fromPromise((async () => {
+      const bodies = messageIds.map((messageId) => ({
+        item: messageId,
+        moduleName: "dashboard/messages/DMViewMessageModule"
+      }));
+      const result = await client.amcClient.request(bodies);
+      if (result.isErr()) {
+        throw result.error;
+      }
+      const messages = [];
+      for (let i = 0;i < messageIds.length; i++) {
+        const response = result.value[i];
+        const messageId = messageIds[i];
+        if (!response || messageId === undefined)
+          continue;
+        const html = String(response.body ?? "");
+        const $ = cheerio.load(html);
+        const printuserElems = $("div.pmessage div.header span.printuser");
+        if (printuserElems.length < 2) {
+          throw new ForbiddenError(`Failed to get message: ${messageId}`);
+        }
+        const senderElem = $(printuserElems[0]);
+        const recipientElem = $(printuserElems[1]);
+        const sender = parseUser(client, senderElem);
+        const recipient = parseUser(client, recipientElem);
+        const subjectElem = $("div.pmessage div.header span.subject");
+        const subject = subjectElem.text().trim();
+        const bodyElem = $("div.pmessage div.body");
+        const body = bodyElem.text().trim();
+        const odateElem = $("div.header span.odate");
+        const createdAt = odateElem.length > 0 ? parseOdate(odateElem) ?? new Date(0) : new Date(0);
+        messages.push(new PrivateMessage({
+          client,
+          id: messageId,
+          sender,
+          recipient,
+          subject,
+          body,
+          createdAt
+        }));
+      }
+      return new PrivateMessageCollection(client, messages);
+    })(), (error) => {
+      if (error instanceof ForbiddenError || error instanceof LoginRequiredError) {
+        return error;
+      }
+      return new UnexpectedError(`Failed to get messages: ${String(error)}`);
+    });
+  }
+  static acquireFromModule(client, moduleName) {
+    const loginResult = client.requireLogin();
+    if (loginResult.isErr()) {
+      return fromPromise(Promise.reject(loginResult.error), () => new LoginRequiredError("Login required to get messages"));
+    }
+    return fromPromise((async () => {
+      const firstResult = await client.amcClient.request([{ moduleName }]);
+      if (firstResult.isErr()) {
+        throw firstResult.error;
+      }
+      const firstResponse = firstResult.value[0];
+      if (!firstResponse) {
+        throw new NoElementError("Empty response");
+      }
+      const firstHtml = String(firstResponse.body ?? "");
+      const $first = cheerio.load(firstHtml);
+      const pagerTargets = $first("div.pager span.target");
+      let maxPage = 1;
+      if (pagerTargets.length > 2) {
+        const lastPageText = $first(pagerTargets[pagerTargets.length - 2]).text().trim();
+        maxPage = Number.parseInt(lastPageText, 10) || 1;
+      }
+      const messageIds = [];
+      if (maxPage > 1) {
+        const bodies = [];
+        for (let page = 1;page <= maxPage; page++) {
+          bodies.push({ page, moduleName });
+        }
+        const additionalResults = await client.amcClient.request(bodies);
+        if (additionalResults.isErr()) {
+          throw additionalResults.error;
+        }
+        for (const response of additionalResults.value) {
+          const html = String(response?.body ?? "");
+          const $ = cheerio.load(html);
+          $("tr.message").each((_i, elem) => {
+            const dataHref = $(elem).attr("data-href") ?? "";
+            const idMatch = dataHref.match(/\/(\d+)$/);
+            if (idMatch?.[1]) {
+              messageIds.push(Number.parseInt(idMatch[1], 10));
+            }
+          });
+        }
+      } else {
+        $first("tr.message").each((_i, elem) => {
+          const dataHref = $first(elem).attr("data-href") ?? "";
+          const idMatch = dataHref.match(/\/(\d+)$/);
+          if (idMatch?.[1]) {
+            messageIds.push(Number.parseInt(idMatch[1], 10));
+          }
+        });
+      }
+      const messagesResult = await PrivateMessageCollection.fromIds(client, messageIds);
+      if (messagesResult.isErr()) {
+        throw messagesResult.error;
+      }
+      return messagesResult.value;
+    })(), (error) => {
+      if (error instanceof ForbiddenError || error instanceof LoginRequiredError || error instanceof NoElementError) {
+        return error;
+      }
+      return new UnexpectedError(`Failed to acquire messages: ${String(error)}`);
+    });
+  }
+}
+
+class PrivateMessageInbox extends PrivateMessageCollection {
+  static acquire(client) {
+    return fromPromise((async () => {
+      const result = await PrivateMessageCollection.acquireFromModule(client, "dashboard/messages/DMInboxModule");
+      if (result.isErr()) {
+        throw result.error;
+      }
+      const inbox = new PrivateMessageInbox(client);
+      inbox.push(...result.value);
+      return inbox;
+    })(), (error) => {
+      if (error instanceof ForbiddenError || error instanceof LoginRequiredError) {
+        return error;
+      }
+      return new UnexpectedError(`Failed to acquire inbox: ${String(error)}`);
+    });
+  }
+}
+
+class PrivateMessageSentBox extends PrivateMessageCollection {
+  static acquire(client) {
+    return fromPromise((async () => {
+      const result = await PrivateMessageCollection.acquireFromModule(client, "dashboard/messages/DMSentModule");
+      if (result.isErr()) {
+        throw result.error;
+      }
+      const sentBox = new PrivateMessageSentBox(client);
+      sentBox.push(...result.value);
+      return sentBox;
+    })(), (error) => {
+      if (error instanceof ForbiddenError || error instanceof LoginRequiredError) {
+        return error;
+      }
+      return new UnexpectedError(`Failed to acquire sent box: ${String(error)}`);
+    });
+  }
+}
+// src/module/client/accessors/pm-accessor.ts
+class PrivateMessageAccessor {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  get(id) {
+    return PrivateMessage.fromId(this.client, id);
+  }
+  getMessages(ids) {
+    return PrivateMessageCollection.fromIds(this.client, ids);
+  }
+  inbox() {
+    return PrivateMessageInbox.acquire(this.client);
+  }
+  sentBox() {
+    return PrivateMessageSentBox.acquire(this.client);
+  }
+  send(recipient, subject, body) {
+    return PrivateMessage.send(this.client, recipient, subject, body);
+  }
+}
+// src/module/site/accessors/forum-accessor.ts
+class ForumAccessor {
+  site;
+  constructor(site) {
+    this.site = site;
+  }
+  getCategories() {
+    return ForumCategoryCollection.acquireAll(this.site);
+  }
+  getThread(threadId) {
+    return ForumThread.getFromId(this.site, threadId);
+  }
+  getThreads(threadIds) {
+    return ForumThreadCollection.acquireFromThreadIds(this.site, threadIds);
+  }
+}
+// src/util/quick-module.ts
+import { z as z2 } from "zod";
+var quickModuleUserResponseSchema = z2.object({
+  users: z2.union([
+    z2.array(z2.object({
+      user_id: z2.union([z2.string(), z2.number()]),
+      name: z2.string()
+    })),
+    z2.literal(false)
+  ])
+});
+var quickModulePageResponseSchema = z2.object({
+  pages: z2.union([
+    z2.array(z2.object({
+      title: z2.string(),
+      unix_name: z2.string()
+    })),
+    z2.literal(false)
+  ])
+});
+async function requestQuickModule(moduleName, siteId, query) {
+  const url = `https://www.wikidot.com/quickmodule.php?module=${moduleName}&s=${siteId}&q=${encodeURIComponent(query)}`;
+  const response = await fetch(url, {
+    method: "GET",
+    headers: {
+      Accept: "application/json"
+    }
+  });
+  if (response.status === 500) {
+    throw new NotFoundException(`Site not found: siteId=${siteId}`);
+  }
+  if (!response.ok) {
+    throw new UnexpectedError(`QuickModule request failed: ${response.status}`);
+  }
+  return response.json();
+}
+function memberLookup(siteId, query) {
+  return fromPromise((async () => {
+    const data = await requestQuickModule("MemberLookupQModule", siteId, query);
+    const parsed = quickModuleUserResponseSchema.parse(data);
+    if (parsed.users === false) {
+      return [];
+    }
+    return parsed.users.map((user) => ({
+      id: typeof user.user_id === "string" ? Number.parseInt(user.user_id, 10) : user.user_id,
+      name: user.name
+    }));
+  })(), (error) => {
+    if (error instanceof NotFoundException)
+      return error;
+    return new UnexpectedError(`Member lookup failed: ${String(error)}`);
+  });
+}
+function userLookup(siteId, query) {
+  return fromPromise((async () => {
+    const data = await requestQuickModule("UserLookupQModule", siteId, query);
+    const parsed = quickModuleUserResponseSchema.parse(data);
+    if (parsed.users === false) {
+      return [];
+    }
+    return parsed.users.map((user) => ({
+      id: typeof user.user_id === "string" ? Number.parseInt(user.user_id, 10) : user.user_id,
+      name: user.name
+    }));
+  })(), (error) => {
+    if (error instanceof NotFoundException)
+      return error;
+    return new UnexpectedError(`User lookup failed: ${String(error)}`);
+  });
+}
+function pageLookup(siteId, query) {
+  return fromPromise((async () => {
+    const data = await requestQuickModule("PageLookupQModule", siteId, query);
+    const parsed = quickModulePageResponseSchema.parse(data);
+    if (parsed.pages === false) {
+      return [];
+    }
+    return parsed.pages.map((page) => ({
+      title: page.title,
+      unixName: page.unix_name
+    }));
+  })(), (error) => {
+    if (error instanceof NotFoundException)
+      return error;
+    return new UnexpectedError(`Page lookup failed: ${String(error)}`);
+  });
+}
+var QuickModule = {
+  memberLookup,
+  userLookup,
+  pageLookup
+};
+
+// src/module/site/site-application.ts
+import * as cheerio2 from "cheerio";
+class SiteApplication {
+  site;
+  user;
+  text;
+  constructor(data) {
+    this.site = data.site;
+    this.user = data.user;
+    this.text = data.text;
+  }
+  static acquireAll(site) {
+    const loginResult = site.client.requireLogin();
+    if (loginResult.isErr()) {
+      return fromPromise(Promise.reject(loginResult.error), () => new LoginRequiredError("Login required to get applications"));
+    }
+    return fromPromise((async () => {
+      const result = await site.amcRequest([
+        { moduleName: "managesite/ManageSiteMembersApplicationsModule" }
+      ]);
+      if (result.isErr()) {
+        throw result.error;
+      }
+      const response = result.value[0];
+      if (!response) {
+        throw new UnexpectedError("Empty response");
+      }
+      const html = String(response.body ?? "");
+      if (html.includes("WIKIDOT.page.listeners.loginClick(event)")) {
+        throw new ForbiddenError("You are not allowed to access this page");
+      }
+      const $ = cheerio2.load(html);
+      const applications = [];
+      const userElements = $("h3 span.printuser").toArray();
+      const textWrapperElements = $("table").toArray();
+      if (userElements.length !== textWrapperElements.length) {
+        throw new UnexpectedError("Length of user_elements and text_wrapper_elements are different");
+      }
+      for (let i = 0;i < userElements.length; i++) {
+        const userElement = userElements[i];
+        const textWrapperElement = textWrapperElements[i];
+        if (!userElement || !textWrapperElement)
+          continue;
+        const user = parseUser(site.client, $(userElement));
+        const textElement = $(textWrapperElement).find("td").eq(1);
+        const text = textElement.text().trim();
+        applications.push(new SiteApplication({ site, user, text }));
+      }
+      return applications;
+    })(), (error) => {
+      if (error instanceof ForbiddenError || error instanceof LoginRequiredError) {
+        return error;
+      }
+      return new UnexpectedError(`Failed to get applications: ${String(error)}`);
+    });
+  }
+  process(action) {
+    return fromPromise((async () => {
+      const result = await this.site.amcRequest([
+        {
+          action: "ManageSiteMembershipAction",
+          event: "acceptApplication",
+          user_id: this.user.id,
+          text: `your application has been ${action}ed`,
+          type: action,
+          moduleName: "Empty"
+        }
+      ]);
+      if (result.isErr()) {
+        const error = result.error;
+        if (error instanceof WikidotStatusError && error.statusCode === "no_application") {
+          throw new NotFoundException(`Application not found: ${this.user.name}`);
+        }
+        throw error;
+      }
+    })(), (error) => {
+      if (error instanceof NotFoundException || error instanceof LoginRequiredError) {
+        return error;
+      }
+      return new UnexpectedError(`Failed to process application: ${String(error)}`);
+    });
+  }
+  accept() {
+    return this.process("accept");
+  }
+  decline() {
+    return this.process("decline");
+  }
+  toString() {
+    return `SiteApplication(user=${this.user.name}, site=${this.site.unixName}, text=${this.text})`;
+  }
+}
+__legacyDecorateClassTS([
+  RequireLogin
+], SiteApplication.prototype, "process", null);
+
+// src/module/site/site-member.ts
+import * as cheerio3 from "cheerio";
+class SiteMember {
+  site;
+  user;
+  joinedAt;
+  constructor(data) {
+    this.site = data.site;
+    this.user = data.user;
+    this.joinedAt = data.joinedAt;
+  }
+  static parse(site, html) {
+    const $ = cheerio3.load(html);
+    const members = [];
+    $("table tr").each((_i, row) => {
+      const tds = $(row).find("td");
+      const userElem = $(tds[0]).find(".printuser");
+      if (userElem.length === 0) {
+        return;
+      }
+      const user = parseUser(site.client, userElem);
+      let joinedAt = null;
+      if (tds.length >= 2) {
+        const odateElem = $(tds[1]).find(".odate");
+        if (odateElem.length > 0) {
+          joinedAt = parseOdate(odateElem);
+        }
+      }
+      members.push(new SiteMember({ site, user, joinedAt }));
+    });
+    return members;
+  }
+  static getMembers(site, group = "") {
+    return fromPromise((async () => {
+      const members = [];
+      const firstResult = await site.amcRequest([
+        {
+          moduleName: "membership/MembersListModule",
+          page: 1,
+          group
+        }
+      ]);
+      if (firstResult.isErr()) {
+        throw firstResult.error;
+      }
+      const firstResponse = firstResult.value[0];
+      if (!firstResponse) {
+        throw new UnexpectedError("Empty response");
+      }
+      const firstHtml = String(firstResponse.body ?? "");
+      members.push(...SiteMember.parse(site, firstHtml));
+      const $first = cheerio3.load(firstHtml);
+      const pagerLinks = $first("div.pager a");
+      if (pagerLinks.length < 2) {
+        return members;
+      }
+      const lastPageText = $first(pagerLinks[pagerLinks.length - 2]).text().trim();
+      const lastPage = Number.parseInt(lastPageText, 10) || 1;
+      if (lastPage <= 1) {
+        return members;
+      }
+      const bodies = [];
+      for (let page = 2;page <= lastPage; page++) {
+        bodies.push({
+          moduleName: "membership/MembersListModule",
+          page,
+          group
+        });
+      }
+      const additionalResults = await site.amcRequest(bodies);
+      if (additionalResults.isErr()) {
+        throw additionalResults.error;
+      }
+      for (const response of additionalResults.value) {
+        const html = String(response?.body ?? "");
+        members.push(...SiteMember.parse(site, html));
+      }
+      return members;
+    })(), (error) => new UnexpectedError(`Failed to get members: ${String(error)}`));
+  }
+  changeGroup(event) {
+    return fromPromise((async () => {
+      const result = await this.site.amcRequest([
+        {
+          action: "ManageSiteMembershipAction",
+          event,
+          user_id: this.user.id,
+          moduleName: ""
+        }
+      ]);
+      if (result.isErr()) {
+        const error = result.error;
+        if (error instanceof WikidotStatusError) {
+          if (error.statusCode === "not_already") {
+            throw new TargetError(`User is not moderator/admin: ${this.user.name}`);
+          }
+          if (error.statusCode === "already_admin" || error.statusCode === "already_moderator") {
+            throw new TargetError(`User is already ${error.statusCode.replace("already_", "")}: ${this.user.name}`);
+          }
+        }
+        throw error;
+      }
+    })(), (error) => {
+      if (error instanceof TargetError || error instanceof LoginRequiredError) {
+        return error;
+      }
+      return new UnexpectedError(`Failed to change member group: ${String(error)}`);
+    });
+  }
+  toModerator() {
+    return this.changeGroup("toModerators");
+  }
+  removeModerator() {
+    return this.changeGroup("removeModerator");
+  }
+  toAdmin() {
+    return this.changeGroup("toAdmins");
+  }
+  removeAdmin() {
+    return this.changeGroup("removeAdmin");
+  }
+  toString() {
+    return `SiteMember(user=${this.user.name}, site=${this.site.unixName})`;
+  }
+}
+__legacyDecorateClassTS([
+  RequireLogin
+], SiteMember.prototype, "changeGroup", null);
+
+// src/module/site/accessors/member-accessor.ts
+class MemberAccessor {
+  site;
+  constructor(site) {
+    this.site = site;
+  }
+  getAll() {
+    return SiteMember.getMembers(this.site, "");
+  }
+  getModerators() {
+    return SiteMember.getMembers(this.site, "moderators");
+  }
+  getAdmins() {
+    return SiteMember.getMembers(this.site, "admins");
+  }
+  getApplications() {
+    return SiteApplication.acquireAll(this.site);
+  }
+  lookup(query) {
+    return QuickModule.memberLookup(this.site.id, query);
+  }
+  invite(user, text) {
+    return fromPromise((async () => {
+      const result = await this.site.amcRequest([
+        {
+          action: "ManageSiteMembershipAction",
+          event: "inviteMember",
+          user_id: user.id,
+          text,
+          moduleName: "Empty"
+        }
+      ]);
+      if (result.isErr()) {
+        const error = result.error;
+        if (error instanceof WikidotStatusError) {
+          if (error.statusCode === "already_invited") {
+            throw new TargetError(`User is already invited to ${this.site.unixName}: ${user.name}`);
+          }
+          if (error.statusCode === "already_member") {
+            throw new TargetError(`User is already a member of ${this.site.unixName}: ${user.name}`);
+          }
+        }
+        throw error;
+      }
+    })(), (error) => {
+      if (error instanceof TargetError || error instanceof LoginRequiredError) {
+        return error;
+      }
+      return new UnexpectedError(`Failed to invite user: ${String(error)}`);
+    });
+  }
+}
+__legacyDecorateClassTS([
+  RequireLogin
+], MemberAccessor.prototype, "invite", null);
+// src/module/page/page.ts
+import * as cheerio6 from "cheerio";
+import { z as z3 } from "zod";
+
+// src/module/page/page-file.ts
+import * as cheerio4 from "cheerio";
+class PageFile {
+  page;
+  id;
+  name;
+  url;
+  mimeType;
+  size;
+  constructor(data) {
+    this.page = data.page;
+    this.id = data.id;
+    this.name = data.name;
+    this.url = data.url;
+    this.mimeType = data.mimeType;
+    this.size = data.size;
+  }
+  toString() {
+    return `PageFile(id=${this.id}, name=${this.name}, size=${this.size})`;
+  }
+}
+
+class PageFileCollection extends Array {
+  page;
+  constructor(page, files) {
+    super();
+    this.page = page;
+    if (files) {
+      this.push(...files);
+    }
+  }
+  findById(id) {
+    return this.find((file) => file.id === id);
+  }
+  findByName(name) {
+    return this.find((file) => file.name === name);
+  }
+  static parseSize(sizeText) {
+    const text = sizeText.trim();
+    if (text.includes("Bytes")) {
+      return Math.floor(Number.parseFloat(text.replace("Bytes", "").trim()));
+    }
+    if (text.includes("kB")) {
+      return Math.floor(Number.parseFloat(text.replace("kB", "").trim()) * 1000);
+    }
+    if (text.includes("MB")) {
+      return Math.floor(Number.parseFloat(text.replace("MB", "").trim()) * 1e6);
+    }
+    if (text.includes("GB")) {
+      return Math.floor(Number.parseFloat(text.replace("GB", "").trim()) * 1e9);
+    }
+    return 0;
+  }
+  static acquire(page) {
+    if (page.id === null) {
+      return fromPromise(Promise.reject(new Error("Page ID not acquired")), () => new UnexpectedError("Page ID must be acquired before getting files"));
+    }
+    const pageId = page.id;
+    return fromPromise((async () => {
+      const result = await page.site.amcRequest([
+        {
+          moduleName: "files/PageFilesModule",
+          page_id: pageId
+        }
+      ]);
+      if (result.isErr()) {
+        throw result.error;
+      }
+      const response = result.value[0];
+      if (!response) {
+        throw new UnexpectedError("Empty response");
+      }
+      const html = String(response.body ?? "");
+      const $ = cheerio4.load(html);
+      const filesTable = $("table.page-files");
+      if (filesTable.length === 0) {
+        return new PageFileCollection(page, []);
+      }
+      const files = [];
+      filesTable.find("tbody tr[id^='file-row-']").each((_i, row) => {
+        const rowId = $(row).attr("id");
+        if (!rowId)
+          return;
+        const fileId = Number.parseInt(rowId.replace("file-row-", ""), 10);
+        const tds = $(row).find("td");
+        if (tds.length < 3)
+          return;
+        const linkElem = $(tds[0]).find("a");
+        if (linkElem.length === 0)
+          return;
+        const name = linkElem.text().trim();
+        const href = linkElem.attr("href") ?? "";
+        const url = `${page.site.getBaseUrl()}${href}`;
+        const mimeElem = $(tds[1]).find("span");
+        const mimeType = mimeElem.attr("title") ?? "";
+        const sizeText = $(tds[2]).text().trim();
+        const size = PageFileCollection.parseSize(sizeText);
+        files.push(new PageFile({
+          page,
+          id: fileId,
+          name,
+          url,
+          mimeType,
+          size
+        }));
+      });
+      return new PageFileCollection(page, files);
+    })(), (error) => new UnexpectedError(`Failed to acquire files: ${String(error)}`));
+  }
+}
+
+// src/module/page/page-meta.ts
+import * as cheerio5 from "cheerio";
+class PageMeta {
+  page;
+  name;
+  content;
+  constructor(data) {
+    this.page = data.page;
+    this.name = data.name;
+    this.content = data.content;
+  }
+  update(content) {
+    return PageMetaCollection.setMeta(this.page, this.name, content);
+  }
+  delete() {
+    return PageMetaCollection.deleteMeta(this.page, this.name);
+  }
+  toString() {
+    return `PageMeta(name=${this.name}, content=${this.content})`;
+  }
+}
+
+class PageMetaCollection extends Array {
+  page;
+  constructor(page, metas) {
+    super();
+    this.page = page;
+    if (metas) {
+      this.push(...metas);
+    }
+  }
+  findByName(name) {
+    return this.find((meta) => meta.name === name);
+  }
+  static acquire(page) {
+    return fromPromise((async () => {
+      const result = await page.site.amcRequest([
+        {
+          moduleName: "edit/EditMetaModule",
+          page_id: page.id
+        }
+      ]);
+      if (result.isErr()) {
+        throw result.error;
+      }
+      const response = result.value[0];
+      if (!response) {
+        throw new NoElementError("Empty response");
+      }
+      const html = String(response.body ?? "");
+      const $ = cheerio5.load(html);
+      const metas = [];
+      $("table.meta-table tr").each((_i, elem) => {
+        const $row = $(elem);
+        const $cells = $row.find("td");
+        if ($cells.length < 2)
+          return;
+        const name = $($cells[0]).text().trim();
+        const content = $($cells[1]).text().trim();
+        if (name) {
+          metas.push(new PageMeta({
+            page,
+            name,
+            content
+          }));
+        }
+      });
+      return new PageMetaCollection(page, metas);
+    })(), (error) => {
+      if (error instanceof NoElementError) {
+        return error;
+      }
+      return new UnexpectedError(`Failed to acquire page metas: ${String(error)}`);
+    });
+  }
+  static setMeta(page, name, content) {
+    const loginResult = page.site.client.requireLogin();
+    if (loginResult.isErr()) {
+      return fromPromise(Promise.reject(loginResult.error), () => new LoginRequiredError("Login required to set meta tag"));
+    }
+    return fromPromise((async () => {
+      const result = await page.site.amcRequest([
+        {
+          action: "WikiPageAction",
+          event: "saveMetaTag",
+          moduleName: "Empty",
+          page_id: page.id,
+          meta_name: name,
+          meta_content: content
+        }
+      ]);
+      if (result.isErr()) {
+        throw result.error;
+      }
+    })(), (error) => {
+      if (error instanceof LoginRequiredError) {
+        return error;
+      }
+      return new UnexpectedError(`Failed to set meta tag: ${String(error)}`);
+    });
+  }
+  static deleteMeta(page, name) {
+    const loginResult = page.site.client.requireLogin();
+    if (loginResult.isErr()) {
+      return fromPromise(Promise.reject(loginResult.error), () => new LoginRequiredError("Login required to delete meta tag"));
+    }
+    return fromPromise((async () => {
+      const result = await page.site.amcRequest([
+        {
+          action: "WikiPageAction",
+          event: "deleteMetaTag",
+          moduleName: "Empty",
+          page_id: page.id,
+          meta_name: name
+        }
+      ]);
+      if (result.isErr()) {
+        throw result.error;
+      }
+    })(), (error) => {
+      if (error instanceof LoginRequiredError) {
+        return error;
+      }
+      return new UnexpectedError(`Failed to delete meta tag: ${String(error)}`);
+    });
+  }
+}
+
+// src/module/page/page-source.ts
+class PageSource {
+  page;
+  wikiText;
+  constructor(data) {
+    this.page = data.page;
+    this.wikiText = data.wikiText;
+  }
+  toString() {
+    return `PageSource(page=${this.page.fullname}, length=${this.wikiText.length})`;
+  }
+}
+
+// src/module/page/page-vote.ts
+class PageVote {
+  page;
+  user;
+  value;
+  constructor(data) {
+    this.page = data.page;
+    this.user = data.user;
+    this.value = data.value;
+  }
+  toString() {
+    return `PageVote(user=${this.user.name}, value=${this.value})`;
+  }
+}
+
+class PageVoteCollection extends Array {
+  page;
+  constructor(page, votes) {
+    super();
+    this.page = page;
+    if (votes) {
+      this.push(...votes);
+    }
+  }
+  findByUser(user) {
+    return this.find((vote) => vote.user.id === user.id);
+  }
+}
+
+// src/module/page/search-query.ts
+var DEFAULT_PER_PAGE = 250;
+var DEFAULT_MODULE_BODY = [
+  "fullname",
+  "category",
+  "name",
+  "title",
+  "created_at",
+  "created_by_linked",
+  "updated_at",
+  "updated_by_linked",
+  "commented_at",
+  "commented_by_linked",
+  "parent_fullname",
+  "comments",
+  "size",
+  "children",
+  "rating_votes",
+  "rating",
+  "rating_percent",
+  "revisions",
+  "tags",
+  "_tags"
+];
+
+class SearchPagesQuery {
+  pagetype;
+  category;
+  tags;
+  parent;
+  linkTo;
+  createdAt;
+  updatedAt;
+  createdBy;
+  rating;
+  votes;
+  name;
+  fullname;
+  range;
+  order;
+  offset;
+  limit;
+  perPage;
+  separate;
+  wrapper;
+  constructor(params = {}) {
+    this.pagetype = params.pagetype ?? "*";
+    this.category = params.category ?? "*";
+    this.tags = params.tags ?? null;
+    this.parent = params.parent ?? null;
+    this.linkTo = params.linkTo ?? null;
+    this.createdAt = params.createdAt ?? null;
+    this.updatedAt = params.updatedAt ?? null;
+    this.createdBy = params.createdBy ?? null;
+    this.rating = params.rating ?? null;
+    this.votes = params.votes ?? null;
+    this.name = params.name ?? null;
+    this.fullname = params.fullname ?? null;
+    this.range = params.range ?? null;
+    this.order = params.order ?? "created_at desc";
+    this.offset = params.offset ?? 0;
+    this.limit = params.limit ?? null;
+    this.perPage = params.perPage ?? DEFAULT_PER_PAGE;
+    this.separate = params.separate ?? "no";
+    this.wrapper = params.wrapper ?? "no";
+  }
+  asDict() {
+    const result = {};
+    if (this.pagetype !== "*")
+      result.pagetype = this.pagetype;
+    if (this.category !== "*")
+      result.category = this.category;
+    if (this.tags !== null) {
+      result.tags = Array.isArray(this.tags) ? this.tags.join(" ") : this.tags;
+    }
+    if (this.parent !== null)
+      result.parent = this.parent;
+    if (this.linkTo !== null)
+      result.link_to = this.linkTo;
+    if (this.createdAt !== null)
+      result.created_at = this.createdAt;
+    if (this.updatedAt !== null)
+      result.updated_at = this.updatedAt;
+    if (this.createdBy !== null) {
+      result.created_by = typeof this.createdBy === "string" ? this.createdBy : this.createdBy.name;
+    }
+    if (this.rating !== null)
+      result.rating = this.rating;
+    if (this.votes !== null)
+      result.votes = this.votes;
+    if (this.name !== null)
+      result.name = this.name;
+    if (this.fullname !== null)
+      result.fullname = this.fullname;
+    if (this.range !== null)
+      result.range = this.range;
+    result.order = this.order;
+    result.offset = this.offset;
+    if (this.limit !== null)
+      result.limit = this.limit;
+    result.perPage = this.perPage;
+    result.separate = this.separate;
+    result.wrapper = this.wrapper;
+    return result;
+  }
+}
+
+// src/module/page/page.ts
+var pageParamsSchema = z3.object({
+  fullname: z3.string().default(""),
+  name: z3.string().default(""),
+  category: z3.string().default(""),
+  title: z3.string().default(""),
+  children_count: z3.number().default(0),
+  comments_count: z3.number().default(0),
+  size: z3.number().default(0),
+  rating: z3.number().default(0),
+  votes_count: z3.number().default(0),
+  rating_percent: z3.number().nullable().default(null),
+  revisions_count: z3.number().default(0),
+  parent_fullname: z3.string().nullable().default(null),
+  tags: z3.array(z3.string()).default([]),
+  created_by: z3.custom().nullable().default(null),
+  created_at: z3.date().nullable().default(null),
+  updated_by: z3.custom().nullable().default(null),
+  updated_at: z3.date().nullable().default(null),
+  commented_by: z3.custom().nullable().default(null),
+  commented_at: z3.date().nullable().default(null)
+});
+
+class Page {
+  site;
+  fullname;
+  name;
+  category;
+  title;
+  childrenCount;
+  commentsCount;
+  size;
+  rating;
+  votesCount;
+  ratingPercent;
+  revisionsCount;
+  parentFullname;
+  tags;
+  createdBy;
+  createdAt;
+  updatedBy;
+  updatedAt;
+  commentedBy;
+  commentedAt;
+  _id = null;
+  _source = null;
+  _revisions = null;
+  _votes = null;
+  constructor(data) {
+    this.site = data.site;
+    this.fullname = data.fullname;
+    this.name = data.name;
+    this.category = data.category;
+    this.title = data.title;
+    this.childrenCount = data.childrenCount;
+    this.commentsCount = data.commentsCount;
+    this.size = data.size;
+    this.rating = data.rating;
+    this.votesCount = data.votesCount;
+    this.ratingPercent = data.ratingPercent;
+    this.revisionsCount = data.revisionsCount;
+    this.parentFullname = data.parentFullname;
+    this.tags = data.tags;
+    this.createdBy = data.createdBy;
+    this.createdAt = data.createdAt;
+    this.updatedBy = data.updatedBy;
+    this.updatedAt = data.updatedAt;
+    this.commentedBy = data.commentedBy;
+    this.commentedAt = data.commentedAt;
+  }
+  getUrl() {
+    return `${this.site.getBaseUrl()}/${this.fullname}`;
+  }
+  isIdAcquired() {
+    return this._id !== null;
+  }
+  get id() {
+    return this._id;
+  }
+  set id(value) {
+    this._id = value;
+  }
+  get source() {
+    return this._source;
+  }
+  set source(value) {
+    this._source = value;
+  }
+  get revisions() {
+    return this._revisions;
+  }
+  set revisions(value) {
+    this._revisions = value;
+  }
+  get votes() {
+    return this._votes;
+  }
+  set votes(value) {
+    this._votes = value;
+  }
+  get latestRevision() {
+    if (!this._revisions || this._revisions.length === 0)
+      return;
+    return this._revisions.reduce((max, rev) => rev.revNo > max.revNo ? rev : max);
+  }
+  requireId(operation) {
+    if (this._id === null) {
+      return {
+        ok: false,
+        error: fromPromise(Promise.reject(new Error("Page ID not acquired")), () => new UnexpectedError(`Page ID must be acquired before ${operation}`))
+      };
+    }
+    return { ok: true, id: this._id };
+  }
+  destroy() {
+    const idCheck = this.requireId("deletion");
+    if (!idCheck.ok)
+      return idCheck.error;
+    return fromPromise((async () => {
+      const result = await this.site.amcRequest([
+        {
+          action: "WikiPageAction",
+          event: "deletePage",
+          page_id: this._id,
+          moduleName: "Empty"
+        }
+      ]);
+      if (result.isErr()) {
+        throw result.error;
+      }
+    })(), (error) => new UnexpectedError(`Failed to delete page: ${String(error)}`));
+  }
+  commitTags() {
+    const idCheck = this.requireId("saving tags");
+    if (!idCheck.ok)
+      return idCheck.error;
+    return fromPromise((async () => {
+      const result = await this.site.amcRequest([
+        {
+          tags: this.tags.join(" "),
+          action: "WikiPageAction",
+          event: "saveTags",
+          pageId: this._id,
+          moduleName: "Empty"
+        }
+      ]);
+      if (result.isErr()) {
+        throw result.error;
+      }
+    })(), (error) => new UnexpectedError(`Failed to save tags: ${String(error)}`));
+  }
+  setParent(parentFullname) {
+    const idCheck = this.requireId("setting parent");
+    if (!idCheck.ok)
+      return idCheck.error;
+    return fromPromise((async () => {
+      const result = await this.site.amcRequest([
+        {
+          action: "WikiPageAction",
+          event: "setParentPage",
+          moduleName: "Empty",
+          pageId: String(this._id),
+          parentName: parentFullname ?? ""
+        }
+      ]);
+      if (result.isErr()) {
+        throw result.error;
+      }
+      this.parentFullname = parentFullname;
+    })(), (error) => new UnexpectedError(`Failed to set parent: ${String(error)}`));
+  }
+  vote(value) {
+    const idCheck = this.requireId("voting");
+    if (!idCheck.ok)
+      return idCheck.error;
+    return fromPromise((async () => {
+      const result = await this.site.amcRequest([
+        {
+          action: "RateAction",
+          event: "ratePage",
+          moduleName: "Empty",
+          pageId: this._id,
+          points: value,
+          force: "yes"
+        }
+      ]);
+      if (result.isErr()) {
+        throw result.error;
+      }
+      const response = result.value[0];
+      if (!response) {
+        throw new UnexpectedError("Empty response from vote request");
+      }
+      const newRating = Number.parseInt(String(response.points ?? this.rating), 10);
+      this.rating = newRating;
+      return newRating;
+    })(), (error) => new UnexpectedError(`Failed to vote: ${String(error)}`));
+  }
+  cancelVote() {
+    const idCheck = this.requireId("canceling vote");
+    if (!idCheck.ok)
+      return idCheck.error;
+    return fromPromise((async () => {
+      const result = await this.site.amcRequest([
+        {
+          action: "RateAction",
+          event: "cancelVote",
+          moduleName: "Empty",
+          pageId: this._id
+        }
+      ]);
+      if (result.isErr()) {
+        throw result.error;
+      }
+      const response = result.value[0];
+      if (!response) {
+        throw new UnexpectedError("Empty response from cancel vote request");
+      }
+      const newRating = Number.parseInt(String(response.points ?? this.rating), 10);
+      this.rating = newRating;
+      return newRating;
+    })(), (error) => new UnexpectedError(`Failed to cancel vote: ${String(error)}`));
+  }
+  edit(options) {
+    const idCheck = this.requireId("editing");
+    if (!idCheck.ok)
+      return idCheck.error;
+    const pageId = idCheck.id;
+    return fromPromise((async () => {
+      let currentSource = options.source;
+      if (currentSource === undefined) {
+        const existingSource = this._source;
+        if (existingSource !== null) {
+          currentSource = existingSource.wikiText;
+        } else {
+          const sourceResult = await PageCollection.acquirePageSources(this.site, [this]);
+          if (sourceResult.isErr()) {
+            throw sourceResult.error;
+          }
+          currentSource = this._source?.wikiText ?? "";
+        }
+      }
+      const result = await PageCollection.createOrEdit(this.site, this.fullname, {
+        pageId,
+        title: options.title ?? this.title,
+        source: currentSource,
+        comment: options.comment ?? "",
+        forceEdit: options.forceEdit ?? false
+      });
+      if (result.isErr()) {
+        throw result.error;
+      }
+    })(), (error) => {
+      if (error instanceof LoginRequiredError || error instanceof ForbiddenError) {
+        return error;
+      }
+      return new UnexpectedError(`Failed to edit page: ${String(error)}`);
+    });
+  }
+  rename(newFullname) {
+    const idCheck = this.requireId("renaming");
+    if (!idCheck.ok)
+      return idCheck.error;
+    return fromPromise((async () => {
+      const result = await this.site.amcRequest([
+        {
+          action: "WikiPageAction",
+          event: "renamePage",
+          moduleName: "Empty",
+          page_id: this._id,
+          new_name: newFullname
+        }
+      ]);
+      if (result.isErr()) {
+        throw result.error;
+      }
+      Object.assign(this, {
+        fullname: newFullname,
+        category: newFullname.includes(":") ? newFullname.split(":")[0] : "_default",
+        name: newFullname.includes(":") ? newFullname.split(":")[1] : newFullname
+      });
+    })(), (error) => new UnexpectedError(`Failed to rename page: ${String(error)}`));
+  }
+  getFiles() {
+    return PageFileCollection.acquire(this);
+  }
+  getDiscussion() {
+    const idCheck = this.requireId("getting discussion");
+    if (!idCheck.ok)
+      return idCheck.error;
+    const pageId = idCheck.id;
+    return fromPromise((async () => {
+      const result = await this.site.amcRequest([
+        {
+          moduleName: "forum/ForumCommentsListModule",
+          pageId
+        }
+      ]);
+      if (result.isErr()) {
+        throw result.error;
+      }
+      const response = result.value[0];
+      if (!response) {
+        return null;
+      }
+      const html = String(response.body ?? "");
+      const match = html.match(/WIKIDOT\.modules\.ForumViewThreadModule\.vars\.threadId\s*=\s*(\d+)/);
+      if (!match?.[1]) {
+        return null;
+      }
+      const threadId = Number.parseInt(match[1], 10);
+      const { ForumThread: ForumThread2 } = await import("./shared/index-ytknx2hn.js");
+      const threadResult = await ForumThread2.getFromId(this.site, threadId);
+      if (threadResult.isErr()) {
+        throw threadResult.error;
+      }
+      return threadResult.value;
+    })(), (error) => new UnexpectedError(`Failed to get discussion: ${String(error)}`));
+  }
+  getMetas() {
+    const idCheck = this.requireId("getting metas");
+    if (!idCheck.ok) {
+      return idCheck.error;
+    }
+    return PageMetaCollection.acquire(this);
+  }
+  setMeta(name, content) {
+    const idCheck = this.requireId("setting meta");
+    if (!idCheck.ok) {
+      return idCheck.error;
+    }
+    return PageMetaCollection.setMeta(this, name, content);
+  }
+  deleteMeta(name) {
+    const idCheck = this.requireId("deleting meta");
+    if (!idCheck.ok) {
+      return idCheck.error;
+    }
+    return PageMetaCollection.deleteMeta(this, name);
+  }
+  toString() {
+    return `Page(fullname=${this.fullname}, title=${this.title})`;
+  }
+}
+__legacyDecorateClassTS([
+  RequireLogin
+], Page.prototype, "destroy", null);
+__legacyDecorateClassTS([
+  RequireLogin
+], Page.prototype, "commitTags", null);
+__legacyDecorateClassTS([
+  RequireLogin
+], Page.prototype, "setParent", null);
+__legacyDecorateClassTS([
+  RequireLogin
+], Page.prototype, "vote", null);
+__legacyDecorateClassTS([
+  RequireLogin
+], Page.prototype, "cancelVote", null);
+__legacyDecorateClassTS([
+  RequireLogin
+], Page.prototype, "edit", null);
+__legacyDecorateClassTS([
+  RequireLogin
+], Page.prototype, "rename", null);
+
+class PageCollection extends Array {
+  site;
+  constructor(site, pages) {
+    super();
+    this.site = site;
+    if (pages) {
+      this.push(...pages);
+    }
+  }
+  findByFullname(fullname) {
+    return this.find((page) => page.fullname === fullname);
+  }
+  getPageIds() {
+    return PageCollection.acquirePageIds(this.site, this);
+  }
+  getPageSources() {
+    return PageCollection.acquirePageSources(this.site, this);
+  }
+  getPageRevisions() {
+    return PageCollection.acquirePageRevisions(this.site, this);
+  }
+  getPageVotes() {
+    return PageCollection.acquirePageVotes(this.site, this);
+  }
+  static acquirePageIds(site, pages) {
+    return fromPromise((async () => {
+      const targetPages = pages.filter((page) => !page.isIdAcquired());
+      if (targetPages.length === 0) {
+        return new PageCollection(site, pages);
+      }
+      const responses = await Promise.all(targetPages.map(async (page) => {
+        const url = `${page.getUrl()}/norender/true/noredirect/true`;
+        const response = await fetch(url, {
+          headers: site.client.amcClient.header.getHeaders()
+        });
+        return { page, response };
+      }));
+      for (const { page, response } of responses) {
+        const text = await response.text();
+        const match = text.match(/WIKIREQUEST\.info\.pageId\s*=\s*(\d+);/);
+        if (!match?.[1]) {
+          throw new NoElementError(`Cannot find page id: ${page.fullname}`);
+        }
+        page.id = Number.parseInt(match[1], 10);
+      }
+      return new PageCollection(site, pages);
+    })(), (error) => {
+      if (error instanceof NoElementError)
+        return error;
+      return new UnexpectedError(`Failed to acquire page IDs: ${String(error)}`);
+    });
+  }
+  static acquirePageSources(site, pages) {
+    return fromPromise((async () => {
+      const targetPages = pages.filter((page) => page.source === null && page.id !== null);
+      if (targetPages.length === 0) {
+        return new PageCollection(site, pages);
+      }
+      const result = await site.amcRequest(targetPages.map((page) => ({
+        moduleName: "viewsource/ViewSourceModule",
+        page_id: page.id
+      })));
+      if (result.isErr()) {
+        throw result.error;
+      }
+      for (let i = 0;i < targetPages.length; i++) {
+        const page = targetPages[i];
+        const response = result.value[i];
+        if (!page || !response)
+          continue;
+        const body = String(response.body ?? "").replace(/&nbsp;/g, " ");
+        const $ = cheerio6.load(body);
+        const sourceElement = $("div.page-source");
+        if (sourceElement.length === 0) {
+          throw new NoElementError(`Cannot find source element for page: ${page.fullname}`);
+        }
+        const wikiText = sourceElement.text().trim().replace(/^\t/, "");
+        page.source = new PageSource({ page, wikiText });
+      }
+      return new PageCollection(site, pages);
+    })(), (error) => {
+      if (error instanceof NoElementError)
+        return error;
+      return new UnexpectedError(`Failed to acquire page sources: ${String(error)}`);
+    });
+  }
+  static acquirePageRevisions(site, pages) {
+    return fromPromise((async () => {
+      const targetPages = pages.filter((page) => page.revisions === null && page.id !== null);
+      if (targetPages.length === 0) {
+        return new PageCollection(site, pages);
+      }
+      const result = await site.amcRequest(targetPages.map((page) => ({
+        moduleName: "history/PageRevisionListModule",
+        page_id: page.id,
+        options: { all: true },
+        perpage: 1e8
+      })));
+      if (result.isErr()) {
+        throw result.error;
+      }
+      const { PageRevision: PageRevision2 } = await import("./shared/index-f2eh3ykk.js");
+      for (let i = 0;i < targetPages.length; i++) {
+        const page = targetPages[i];
+        const response = result.value[i];
+        if (!page || !response)
+          continue;
+        const body = String(response.body ?? "");
+        const $ = cheerio6.load(body);
+        const revisions = [];
+        $("table.page-history > tr[id^=revision-row-]").each((_j, revElement) => {
+          const $rev = $(revElement);
+          const revIdAttr = $rev.attr("id");
+          if (!revIdAttr)
+            return;
+          const revId = Number.parseInt(revIdAttr.replace("revision-row-", ""), 10);
+          if (Number.isNaN(revId))
+            return;
+          const $tds = $rev.find("td");
+          if ($tds.length < 7)
+            return;
+          const revNoText = $tds.eq(0).text().trim().replace(/\.$/, "");
+          const revNo = Number.parseInt(revNoText, 10);
+          if (Number.isNaN(revNo))
+            return;
+          const $createdByElem = $tds.eq(4).find("span.printuser");
+          if ($createdByElem.length === 0)
+            return;
+          const createdBy = parseUser(site.client, $createdByElem);
+          const $createdAtElem = $tds.eq(5).find("span.odate");
+          if ($createdAtElem.length === 0)
+            return;
+          const createdAt = parseOdate($createdAtElem) ?? new Date;
+          const comment = $tds.eq(6).text().trim();
+          revisions.push(new PageRevision2({
+            page,
+            id: revId,
+            revNo,
+            createdBy,
+            createdAt,
+            comment
+          }));
+        });
+        page.revisions = new PageRevisionCollection(page, revisions);
+      }
+      return new PageCollection(site, pages);
+    })(), (error) => new UnexpectedError(`Failed to acquire page revisions: ${String(error)}`));
+  }
+  static acquirePageVotes(site, pages) {
+    return fromPromise((async () => {
+      const targetPages = pages.filter((page) => page.votes === null && page.id !== null);
+      if (targetPages.length === 0) {
+        return new PageCollection(site, pages);
+      }
+      const result = await site.amcRequest(targetPages.map((page) => ({
+        moduleName: "pagerate/WhoRatedPageModule",
+        pageId: page.id
+      })));
+      if (result.isErr()) {
+        throw result.error;
+      }
+      for (let i = 0;i < targetPages.length; i++) {
+        const page = targetPages[i];
+        const response = result.value[i];
+        if (!page || !response)
+          continue;
+        const body = String(response.body ?? "");
+        const $ = cheerio6.load(body);
+        const $userElems = $("span.printuser");
+        const $valueElems = $("span[style^='color']");
+        if ($userElems.length !== $valueElems.length) {
+          throw new UnexpectedError("User and value count mismatch in votes");
+        }
+        const votes = [];
+        $userElems.each((j, userElem) => {
+          const $user = $(userElem);
+          const $value = $valueElems.eq(j);
+          const user = parseUser(site.client, $user);
+          const valueText = $value.text().trim();
+          let value;
+          if (valueText === "+") {
+            value = 1;
+          } else if (valueText === "-") {
+            value = -1;
+          } else {
+            value = Number.parseInt(valueText, 10) || 0;
+          }
+          votes.push(new PageVote({ page, user, value }));
+        });
+        page.votes = new PageVoteCollection(page, votes);
+      }
+      return new PageCollection(site, pages);
+    })(), (error) => new UnexpectedError(`Failed to acquire page votes: ${String(error)}`));
+  }
+  static parse(site, htmlBody, _parseUser) {
+    const pages = [];
+    htmlBody("div.page").each((_i, pageElement) => {
+      const $page = htmlBody(pageElement);
+      const pageParams = {};
+      const is5StarRating = $page.find("span.rating span.page-rate-list-pages-start").length > 0;
+      $page.find("span.set").each((_j, setElement) => {
+        const $set = htmlBody(setElement);
+        const keyElement = $set.find("span.name");
+        if (keyElement.length === 0)
+          return;
+        let key = keyElement.text().trim();
+        const valueElement = $set.find("span.value");
+        let value = null;
+        if (valueElement.length === 0) {
+          value = null;
+        } else if (["created_at", "updated_at", "commented_at"].includes(key)) {
+          const odateElement = valueElement.find("span.odate");
+          if (odateElement.length > 0) {
+            const timestamp = odateElement.attr("class")?.match(/time_(\d+)/)?.[1];
+            value = timestamp ? new Date(Number.parseInt(timestamp, 10) * 1000) : null;
+          }
+        } else if (["created_by_linked", "updated_by_linked", "commented_by_linked"].includes(key)) {
+          const printuserElement = valueElement.find("span.printuser");
+          if (printuserElement.length > 0) {
+            value = _parseUser(printuserElement);
+          }
+        } else if (["tags", "_tags"].includes(key)) {
+          value = valueElement.text().split(/\s+/).filter(Boolean);
+        } else if (["rating_votes", "comments", "size", "revisions"].includes(key)) {
+          value = Number.parseInt(valueElement.text().trim(), 10) || 0;
+        } else if (key === "rating") {
+          const ratingText = valueElement.text().trim();
+          value = is5StarRating ? Number.parseFloat(ratingText) || 0 : Number.parseInt(ratingText, 10) || 0;
+        } else if (key === "rating_percent") {
+          if (is5StarRating) {
+            value = (Number.parseFloat(valueElement.text().trim()) || 0) / 100;
+          } else {
+            value = null;
+          }
+        } else {
+          value = valueElement.text().trim();
+        }
+        if (key.includes("_linked")) {
+          key = key.replace("_linked", "");
+        } else if (["comments", "children", "revisions"].includes(key)) {
+          key = `${key}_count`;
+        } else if (key === "rating_votes") {
+          key = "votes_count";
+        }
+        pageParams[key] = value;
+      });
+      const tags = Array.isArray(pageParams.tags) ? pageParams.tags : [];
+      const hiddenTags = Array.isArray(pageParams._tags) ? pageParams._tags : [];
+      pageParams.tags = [...tags, ...hiddenTags];
+      const parsed = pageParamsSchema.parse(pageParams);
+      pages.push(new Page({
+        site,
+        fullname: parsed.fullname,
+        name: parsed.name,
+        category: parsed.category,
+        title: parsed.title,
+        childrenCount: parsed.children_count,
+        commentsCount: parsed.comments_count,
+        size: parsed.size,
+        rating: parsed.rating,
+        votesCount: parsed.votes_count,
+        ratingPercent: parsed.rating_percent,
+        revisionsCount: parsed.revisions_count,
+        parentFullname: parsed.parent_fullname,
+        tags: parsed.tags,
+        createdBy: parsed.created_by,
+        createdAt: parsed.created_at ?? new Date,
+        updatedBy: parsed.updated_by,
+        updatedAt: parsed.updated_at ?? new Date,
+        commentedBy: parsed.commented_by,
+        commentedAt: parsed.commented_at
+      }));
+    });
+    return new PageCollection(site, pages);
+  }
+  static searchPages(site, parseUser2, query = null) {
+    return fromPromise((async () => {
+      const q = query ?? new SearchPagesQuery;
+      const queryDict = q.asDict();
+      const moduleBody = `[[div class="page"]]
+${DEFAULT_MODULE_BODY.map((key) => `[[span class="set ${key}"]][[span class="name"]] ${key} [[/span]][[span class="value"]] %%${key}%% [[/span]][[/span]]`).join("")}
+[[/div]]`;
+      const requestBody = {
+        ...queryDict,
+        moduleName: "list/ListPagesModule",
+        module_body: moduleBody
+      };
+      const result = await site.amcRequest([requestBody]);
+      if (result.isErr()) {
+        if (result.error.message.includes("not_ok")) {
+          throw new ForbiddenError("Failed to get pages, target site may be private");
+        }
+        throw result.error;
+      }
+      const firstResponse = result.value[0];
+      const body = String(firstResponse?.body ?? "");
+      const $first = cheerio6.load(body);
+      let total = 1;
+      const htmlBodies = [$first];
+      const pagerElement = $first("div.pager");
+      if (pagerElement.length > 0) {
+        const lastPagerElements = $first("div.pager span.target");
+        if (lastPagerElements.length >= 2) {
+          const secondLastPager = $first(lastPagerElements[lastPagerElements.length - 2]);
+          const lastPagerLink = secondLastPager.find("a");
+          if (lastPagerLink.length > 0) {
+            total = Number.parseInt(lastPagerLink.text().trim(), 10) || 1;
+          }
+        }
+      }
+      if (total > 1) {
+        const additionalBodies = [];
+        for (let i = 1;i < total; i++) {
+          additionalBodies.push({
+            ...queryDict,
+            moduleName: "list/ListPagesModule",
+            module_body: moduleBody,
+            offset: i * (q.perPage ?? DEFAULT_PER_PAGE)
+          });
+        }
+        const additionalResults = await site.amcRequest(additionalBodies);
+        if (additionalResults.isErr()) {
+          throw additionalResults.error;
+        }
+        for (const response of additionalResults.value) {
+          const respBody = String(response?.body ?? "");
+          htmlBodies.push(cheerio6.load(respBody));
+        }
+      }
+      const pages = [];
+      for (const $html of htmlBodies) {
+        const parsed = PageCollection.parse(site, $html, parseUser2);
+        pages.push(...parsed);
+      }
+      return new PageCollection(site, pages);
+    })(), (error) => {
+      if (error instanceof ForbiddenError || error instanceof NotFoundException) {
+        return error;
+      }
+      return new UnexpectedError(`Failed to search pages: ${String(error)}`);
+    });
+  }
+  static createOrEdit(site, fullname, options = {}) {
+    const loginResult = site.client.requireLogin();
+    if (loginResult.isErr()) {
+      return fromPromise(Promise.reject(loginResult.error), () => new LoginRequiredError("Login required to create/edit page"));
+    }
+    return fromPromise((async () => {
+      const {
+        pageId = null,
+        title = "",
+        source = "",
+        comment = "",
+        forceEdit = false,
+        raiseOnExists = false
+      } = options;
+      const lockRequestBody = {
+        mode: "page",
+        wiki_page: fullname,
+        moduleName: "edit/PageEditModule"
+      };
+      if (forceEdit) {
+        lockRequestBody.force_lock = "yes";
+      }
+      const lockResult = await site.amcRequest([lockRequestBody]);
+      if (lockResult.isErr()) {
+        throw lockResult.error;
+      }
+      const lockResponse = lockResult.value[0];
+      if (lockResponse?.locked || lockResponse?.other_locks) {
+        throw new UnexpectedError(`Page ${fullname} is locked or other locks exist`);
+      }
+      const isExist = "page_revision_id" in (lockResponse ?? {});
+      if (raiseOnExists && isExist) {
+        throw new TargetExistsError(`Page ${fullname} already exists`);
+      }
+      if (isExist && pageId === null) {
+        throw new UnexpectedError("page_id must be specified when editing existing page");
+      }
+      const lockId = String(lockResponse?.lock_id ?? "");
+      const lockSecret = String(lockResponse?.lock_secret ?? "");
+      const pageRevisionId = String(lockResponse?.page_revision_id ?? "");
+      const editRequestBody = {
+        action: "WikiPageAction",
+        event: "savePage",
+        moduleName: "Empty",
+        mode: "page",
+        lock_id: lockId,
+        lock_secret: lockSecret,
+        revision_id: pageRevisionId,
+        wiki_page: fullname,
+        page_id: pageId ?? "",
+        title,
+        source,
+        comments: comment
+      };
+      const editResult = await site.amcRequest([editRequestBody]);
+      if (editResult.isErr()) {
+        throw editResult.error;
+      }
+    })(), (error) => {
+      if (error instanceof TargetExistsError || error instanceof LoginRequiredError) {
+        return error;
+      }
+      return new UnexpectedError(`Failed to create/edit page: ${String(error)}`);
+    });
+  }
+}
+// src/module/page/site-change.ts
+import * as cheerio7 from "cheerio";
+class SiteChange {
+  site;
+  pageFullname;
+  pageTitle;
+  revisionNo;
+  changedBy;
+  changedAt;
+  flags;
+  comment;
+  constructor(data) {
+    this.site = data.site;
+    this.pageFullname = data.pageFullname;
+    this.pageTitle = data.pageTitle;
+    this.revisionNo = data.revisionNo;
+    this.changedBy = data.changedBy;
+    this.changedAt = data.changedAt;
+    this.flags = data.flags;
+    this.comment = data.comment;
+  }
+  getPageUrl() {
+    return `${this.site.getBaseUrl()}/${this.pageFullname}`;
+  }
+  toString() {
+    return `SiteChange(page=${this.pageFullname}, rev=${this.revisionNo}, by=${this.changedBy})`;
+  }
+}
+
+class SiteChangeCollection extends Array {
+  site;
+  constructor(site, changes) {
+    super();
+    this.site = site;
+    if (changes) {
+      this.push(...changes);
+    }
+  }
+  static acquire(site, options) {
+    const perPage = options?.perPage ?? 20;
+    const page = options?.page ?? 1;
+    const limit = options?.limit;
+    return fromPromise((async () => {
+      const result = await site.amcRequest([
+        {
+          moduleName: "changes/SiteChangesListModule",
+          perpage: perPage,
+          page
+        }
+      ]);
+      if (result.isErr()) {
+        throw result.error;
+      }
+      const response = result.value[0];
+      if (!response) {
+        throw new NoElementError("Empty response");
+      }
+      const html = String(response.body ?? "");
+      const $ = cheerio7.load(html);
+      const changes = [];
+      $("table.wiki-content-table tr").each((_i, elem) => {
+        const $row = $(elem);
+        const $cells = $row.find("td");
+        if ($cells.length < 4)
+          return;
+        const pageLink = $($cells[0]).find("a");
+        const href = pageLink.attr("href") ?? "";
+        const pageFullname = href.replace(/^\//, "").split("/")[0] ?? "";
+        const pageTitle = pageLink.text().trim();
+        const revText = $($cells[1]).text().trim();
+        const revMatch = revText.match(/(\d+)/);
+        const revisionNo = revMatch?.[1] ? Number.parseInt(revMatch[1], 10) : 0;
+        const flagsCell = $($cells[2]);
+        const flags = [];
+        flagsCell.find("span").each((_j, flagElem) => {
+          const flagClass = $(flagElem).attr("class") ?? "";
+          if (flagClass.includes("spantip")) {
+            const title = $(flagElem).attr("title") ?? "";
+            if (title)
+              flags.push(title);
+          }
+        });
+        const infoCell = $($cells[3]);
+        const userElem = infoCell.find("span.printuser");
+        const changedBy = userElem.length > 0 ? parseUser(site.client, userElem) : null;
+        const odateElem = infoCell.find("span.odate");
+        const changedAt = odateElem.length > 0 ? parseOdate(odateElem) : null;
+        const commentElem = infoCell.find("span.comments");
+        const comment = commentElem.text().trim().replace(/^[""]|[""]$/g, "");
+        changes.push(new SiteChange({
+          site,
+          pageFullname,
+          pageTitle,
+          revisionNo,
+          changedBy,
+          changedAt,
+          flags,
+          comment
+        }));
+      });
+      const limitedChanges = limit !== undefined ? changes.slice(0, limit) : changes;
+      return new SiteChangeCollection(site, limitedChanges);
+    })(), (error) => {
+      if (error instanceof NoElementError) {
+        return error;
+      }
+      return new UnexpectedError(`Failed to acquire site changes: ${String(error)}`);
+    });
+  }
+}
+// src/module/site/accessors/page-accessor.ts
+class PageAccessor {
+  site;
+  constructor(site) {
+    this.site = site;
+  }
+  get(unixName) {
+    return fromPromise((async () => {
+      const query = new SearchPagesQuery({ fullname: unixName });
+      const userParser = parseUser.bind(null, this.site.client);
+      const result = await PageCollection.searchPages(this.site, userParser, query);
+      if (result.isErr()) {
+        throw result.error;
+      }
+      return result.value.length > 0 ? result.value[0] ?? null : null;
+    })(), (error) => {
+      if (error instanceof NoElementError)
+        return error;
+      return new UnexpectedError(`Failed to get page: ${String(error)}`);
+    });
+  }
+  create(fullname, options = {}) {
+    return PageCollection.createOrEdit(this.site, fullname, {
+      title: options.title,
+      source: options.source,
+      comment: options.comment,
+      forceEdit: options.forceEdit
+    });
+  }
+}
+// src/module/site/accessors/pages-accessor.ts
+class PagesAccessor {
+  site;
+  constructor(site) {
+    this.site = site;
+  }
+  search(params) {
+    return fromPromise((async () => {
+      const query = new SearchPagesQuery(params);
+      const userParser = parseUser.bind(null, this.site.client);
+      const result = await PageCollection.searchPages(this.site, userParser, query);
+      if (result.isErr()) {
+        throw result.error;
+      }
+      return result.value;
+    })(), (error) => new UnexpectedError(`Failed to search pages: ${String(error)}`));
+  }
+  all() {
+    return this.search({});
+  }
+  getRecentChanges(options) {
+    return SiteChangeCollection.acquire(this.site, options);
+  }
+}
+// src/module/site/site.ts
+import * as cheerio8 from "cheerio";
+class Site {
+  client;
+  id;
+  title;
+  unixName;
+  domain;
+  sslSupported;
+  _page = null;
+  _pages = null;
+  _forum = null;
+  _member = null;
+  constructor(client, data) {
+    this.client = client;
+    this.id = data.id;
+    this.title = data.title;
+    this.unixName = data.unixName;
+    this.domain = data.domain;
+    this.sslSupported = data.sslSupported;
+  }
+  get page() {
+    if (!this._page) {
+      this._page = new PageAccessor(this);
+    }
+    return this._page;
+  }
+  get pages() {
+    if (!this._pages) {
+      this._pages = new PagesAccessor(this);
+    }
+    return this._pages;
+  }
+  get forum() {
+    if (!this._forum) {
+      this._forum = new ForumAccessor(this);
+    }
+    return this._forum;
+  }
+  get member() {
+    if (!this._member) {
+      this._member = new MemberAccessor(this);
+    }
+    return this._member;
+  }
+  getBaseUrl() {
+    const protocol = this.sslSupported ? "https" : "http";
+    return `${protocol}://${this.domain}`;
+  }
+  amcRequest(bodies) {
+    return this.client.amcClient.request(bodies, this.unixName, this.sslSupported);
+  }
+  amcRequestSingle(body) {
+    return fromPromise((async () => {
+      const result = await this.amcRequest([body]);
+      if (result.isErr()) {
+        throw result.error;
+      }
+      const response = result.value[0];
+      if (!response) {
+        throw new UnexpectedError("AMC request returned empty response");
+      }
+      return response;
+    })(), (error) => {
+      if (error instanceof UnexpectedError) {
+        return error;
+      }
+      return new UnexpectedError(`AMC request failed: ${String(error)}`);
+    });
+  }
+  static fromUnixName(client, unixName) {
+    return fromPromise((async () => {
+      const url = `https://${unixName}.wikidot.com`;
+      const response = await fetch(url, {
+        headers: client.amcClient.header.getHeaders()
+      });
+      if (!response.ok) {
+        if (response.status === 404) {
+          throw new NotFoundException(`Site not found: ${unixName}`);
+        }
+        throw new UnexpectedError(`Failed to fetch site: ${response.status}`);
+      }
+      const html = await response.text();
+      const $ = cheerio8.load(html);
+      const scripts = $("script").toArray();
+      let siteId = null;
+      let siteUnixName = null;
+      let domain = null;
+      let title = null;
+      for (const script of scripts) {
+        const content = $(script).html();
+        if (!content || !content.includes("WIKIREQUEST")) {
+          continue;
+        }
+        const siteIdMatch = content.match(/WIKIREQUEST\.info\.siteId\s*=\s*(\d+)/);
+        if (siteIdMatch?.[1]) {
+          siteId = Number.parseInt(siteIdMatch[1], 10);
+        }
+        const siteUnixNameMatch = content.match(/WIKIREQUEST\.info\.siteUnixName\s*=\s*["']([^"']+)["']/);
+        if (siteUnixNameMatch?.[1]) {
+          siteUnixName = siteUnixNameMatch[1];
+        }
+        const domainMatch = content.match(/WIKIREQUEST\.info\.domain\s*=\s*["']([^"']+)["']/);
+        if (domainMatch?.[1]) {
+          domain = domainMatch[1];
+        }
+      }
+      title = $("title").text().trim() || null;
+      if (title?.endsWith(" - Wikidot")) {
+        title = title.slice(0, -10).trim();
+      }
+      if (siteId === null) {
+        throw new NoElementError("Site ID not found in WIKIREQUEST");
+      }
+      if (siteUnixName === null) {
+        siteUnixName = unixName;
+      }
+      if (domain === null) {
+        domain = `${unixName}.wikidot.com`;
+      }
+      if (title === null) {
+        title = unixName;
+      }
+      const sslSupported = true;
+      return new Site(client, {
+        id: siteId,
+        title,
+        unixName: siteUnixName,
+        domain,
+        sslSupported
+      });
+    })(), (error) => {
+      if (error instanceof NotFoundException || error instanceof NoElementError) {
+        return error;
+      }
+      return new UnexpectedError(`Failed to get site: ${String(error)}`);
+    });
+  }
+  toString() {
+    return `Site(id=${this.id}, unixName=${this.unixName}, title=${this.title})`;
+  }
+}
+// src/module/client/accessors/site-accessor.ts
+class SiteAccessor {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  get(unixName) {
+    return Site.fromUnixName(this.client, unixName);
+  }
+}
+// src/module/client/accessors/user-accessor.ts
+class UserAccessor {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  get(name, options = {}) {
+    const { raiseWhenNotFound = false } = options;
+    return User.fromName(this.client, name).andThen((user) => {
+      if (user === null && raiseWhenNotFound) {
+        return wdErrAsync(new NotFoundException(`User not found: ${name}`));
+      }
+      return wdOkAsync(user);
+    });
+  }
+  getMany(names, options = {}) {
+    const { raiseWhenNotFound = false } = options;
+    return User.fromNames(this.client, names).andThen((collection) => {
+      if (raiseWhenNotFound) {
+        const notFoundNames = [];
+        for (let i = 0;i < names.length; i++) {
+          const name = names[i];
+          if (collection[i] === null && name !== undefined) {
+            notFoundNames.push(name);
+          }
+        }
+        if (notFoundNames.length > 0) {
+          return wdErrAsync(new NotFoundException(`Users not found: ${notFoundNames.join(", ")}`));
+        }
+      }
+      return wdOkAsync(collection);
+    });
+  }
+}
+// src/module/client/client.ts
+class Client {
+  amcClient;
+  domain;
+  user;
+  site;
+  privateMessage;
+  _username;
+  _me = null;
+  constructor(amcClient, domain, username = null) {
+    this.amcClient = amcClient;
+    this.domain = domain;
+    this._username = username;
+    this.user = new UserAccessor(this);
+    this.site = new SiteAccessor(this);
+    this.privateMessage = new PrivateMessageAccessor(this);
+  }
+  get username() {
+    return this._username;
+  }
+  get me() {
+    return this._me;
+  }
+  static create(options = {}) {
+    const { username, password, domain = "wikidot.com", amcConfig = {} } = options;
+    const amcClient = new AMCClient(amcConfig, domain);
+    if (username && password) {
+      return fromPromise((async () => {
+        const client = new Client(amcClient, domain, username);
+        const loginResult = await login(client, username, password);
+        if (loginResult.isErr()) {
+          throw loginResult.error;
+        }
+        const { User: User2 } = await import("./shared/index-kka6e8cb.js");
+        const userResult = await User2.fromName(client, username);
+        if (userResult.isOk() && userResult.value) {
+          client._me = userResult.value;
+        }
+        return client;
+      })(), (error) => {
+        if (error instanceof LoginRequiredError) {
+          return error;
+        }
+        return new LoginRequiredError(`Failed to create client: ${String(error)}`);
+      });
+    }
+    return wdOkAsync(new Client(amcClient, domain));
+  }
+  static createAnonymous(options = {}) {
+    const { domain = "wikidot.com", amcConfig = {} } = options;
+    const amcClient = new AMCClient(amcConfig, domain);
+    return new Client(amcClient, domain);
+  }
+  isLoggedIn() {
+    return this._username !== null;
+  }
+  requireLogin() {
+    if (!this.isLoggedIn()) {
+      return wdErr(new LoginRequiredError);
+    }
+    return wdOk(undefined);
+  }
+  close() {
+    if (this.isLoggedIn()) {
+      return logout(this).map(() => {
+        this._username = null;
+        return;
+      });
+    }
+    return wdOkAsync(undefined);
+  }
+}
+export {
+  wdOkAsync,
+  wdOk,
+  wdErrAsync,
+  wdErr,
+  userLookup,
+  setupConsoleHandler,
+  parseUser,
+  parseOdate,
+  pageLookup,
+  nullHandler,
+  memberLookup,
+  maskSensitiveData,
+  logout,
+  login,
+  logger,
+  isSuccessResponse,
+  getLogger,
+  fromPromise,
+  consoleHandler,
+  combineResults,
+  amcResponseSchema,
+  WikidotUser,
+  WikidotStatusError,
+  WikidotError,
+  UserCollection,
+  UserAccessor,
+  User,
+  UnexpectedError,
+  TargetExistsError,
+  TargetError,
+  SiteMember,
+  SiteChangeCollection,
+  SiteChange,
+  SiteApplication,
+  SiteAccessor,
+  Site,
+  SessionError,
+  SessionCreateError,
+  SearchPagesQuery,
+  ResponseDataError,
+  QuickModule,
+  PrivateMessageSentBox,
+  PrivateMessageInbox,
+  PrivateMessageCollection,
+  PrivateMessageAccessor,
+  PrivateMessage,
+  PagesAccessor,
+  PageVoteCollection,
+  PageVote,
+  PageSource,
+  PageRevisionCollection,
+  PageRevision,
+  PageMetaCollection,
+  PageMeta,
+  PageFileCollection,
+  PageFile,
+  PageCollection,
+  PageAccessor,
+  Page,
+  NotFoundException,
+  NoElementError,
+  MemberAccessor,
+  LoginRequiredError,
+  Logger,
+  GuestUser,
+  ForumThreadCollection,
+  ForumThread,
+  ForumPostCollection,
+  ForumPost,
+  ForumCategoryCollection,
+  ForumCategory,
+  ForumAccessor,
+  ForbiddenError,
+  DeletedUser,
+  DEFAULT_PER_PAGE,
+  DEFAULT_MODULE_BODY,
+  DEFAULT_AMC_CONFIG,
+  Client,
+  AnonymousUser,
+  AMCHttpError,
+  AMCHeader,
+  AMCError,
+  AMCClient
+};
+
+//# debugId=1A0AF3AA4D5CAB4D64756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/connector/amc-client.ts", "src/connector/amc-config.ts", "src/connector/amc-header.ts", "src/connector/amc-types.ts", "src/connector/auth.ts", "src/module/private-message/private-message.ts", "src/module/client/accessors/pm-accessor.ts", "src/module/site/accessors/forum-accessor.ts", "src/util/quick-module.ts", "src/module/site/site-application.ts", "src/module/site/site-member.ts", "src/module/site/accessors/member-accessor.ts", "src/module/page/page.ts", "src/module/page/page-file.ts", "src/module/page/page-meta.ts", "src/module/page/page-source.ts", "src/module/page/page-vote.ts", "src/module/page/search-query.ts", "src/module/page/site-change.ts", "src/module/site/accessors/page-accessor.ts", "src/module/site/accessors/pages-accessor.ts", "src/module/site/site.ts", "src/module/client/accessors/site-accessor.ts", "src/module/client/accessors/user-accessor.ts", "src/module/client/client.ts"],
  "sourcesContent": [
    "import ky, { type KyInstance } from 'ky';\nimport pLimit, { type LimitFunction } from 'p-limit';\nimport {\n  AMCHttpError,\n  ForbiddenError,\n  NotFoundException,\n  ResponseDataError,\n  UnexpectedError,\n  WikidotError,\n  WikidotStatusError,\n} from '../common/errors';\nimport { fromPromise, type WikidotResultAsync, wdErrAsync, wdOkAsync } from '../common/types';\nimport {\n  type AMCConfig,\n  DEFAULT_AMC_CONFIG,\n  DEFAULT_HTTP_STATUS_CODE,\n  WIKIDOT_TOKEN7,\n} from './amc-config';\nimport { AMCHeader } from './amc-header';\nimport { type AMCRequestBody, type AMCResponse, amcResponseSchema } from './amc-types';\n\n/**\n * 機密情報をマスクする（ログ出力用）\n * @param body - マスク対象のリクエストボディ\n * @returns マスクされたボディ\n */\nexport function maskSensitiveData(body: AMCRequestBody): Record<string, unknown> {\n  const masked = { ...body };\n  const sensitiveKeys = ['password', 'login', 'WIKIDOT_SESSION_ID', 'wikidot_token7'];\n  for (const key of sensitiveKeys) {\n    if (key in masked) {\n      masked[key] = '***MASKED***';\n    }\n  }\n  return masked;\n}\n\n/**\n * 指数バックオフ間隔を計算する（ジッター付き）\n * @param retryCount - 現在のリトライ回数（1から開始）\n * @param baseInterval - 基本間隔（ミリ秒）\n * @param backoffFactor - バックオフ係数\n * @param maxBackoff - 最大バックオフ間隔（ミリ秒）\n * @returns 計算されたバックオフ間隔（ミリ秒）\n */\nfunction calculateBackoff(\n  retryCount: number,\n  baseInterval: number,\n  backoffFactor: number,\n  maxBackoff: number\n): number {\n  const backoff = baseInterval * backoffFactor ** (retryCount - 1);\n  const jitter = Math.random() * backoff * 0.1;\n  return Math.min(backoff + jitter, maxBackoff);\n}\n\n/**\n * 指定時間待機する\n * @param ms - 待機時間（ミリ秒）\n */\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\n/**\n * AMCリクエストオプション\n */\nexport interface AMCRequestOptions {\n  /** サイト名（デフォルト: www） */\n  siteName?: string;\n  /** SSL対応（省略時は自動検出） */\n  sslSupported?: boolean;\n  /** エラーを例外として投げずに結果に含める（デフォルト: false） */\n  returnExceptions?: boolean;\n}\n\n/**\n * Ajax Module Connectorクライアント\n * Wikidot AMCエンドポイントへのリクエストを管理する\n */\nexport class AMCClient {\n  /** kyインスタンス */\n  private readonly ky: KyInstance;\n\n  /** 並列リクエスト制限 */\n  private readonly limit: LimitFunction;\n\n  /** ヘッダー管理 */\n  public readonly header: AMCHeader;\n\n  /** 設定 */\n  public readonly config: AMCConfig;\n\n  /** ベースドメイン */\n  public readonly domain: string;\n\n  /** SSL対応状況のキャッシュ */\n  private sslCache: Map<string, boolean> = new Map();\n\n  /**\n   * @param config - AMC設定（省略時はデフォルト値）\n   * @param domain - ベースドメイン（デフォルト: wikidot.com）\n   */\n  constructor(config: Partial<AMCConfig> = {}, domain = 'wikidot.com') {\n    this.config = { ...DEFAULT_AMC_CONFIG, ...config };\n    this.domain = domain;\n    this.header = new AMCHeader();\n    this.limit = pLimit(this.config.semaphoreLimit);\n\n    this.ky = ky.create({\n      timeout: this.config.timeout,\n      retry: 0, // 手動でリトライを制御\n    });\n\n    // wwwは常にSSL対応\n    this.sslCache.set('www', true);\n  }\n\n  /**\n   * サイトの存在とSSL対応状況を確認する\n   * @param siteName - サイト名\n   * @returns SSL対応状況（true: HTTPS、false: HTTP）\n   */\n  checkSiteSSL(siteName: string): WikidotResultAsync<boolean> {\n    // キャッシュに存在すればそれを返す\n    const cached = this.sslCache.get(siteName);\n    if (cached !== undefined) {\n      return wdOkAsync(cached);\n    }\n\n    // wwwは常にSSL対応\n    if (siteName === 'www') {\n      return wdOkAsync(true);\n    }\n\n    return fromPromise(\n      (async () => {\n        const response = await fetch(`http://${siteName}.${this.domain}`, {\n          method: 'GET',\n          redirect: 'manual',\n        });\n\n        // 404の場合はサイトが存在しない\n        if (response.status === 404) {\n          throw new NotFoundException(`Site is not found: ${siteName}.${this.domain}`);\n        }\n\n        // 301リダイレクトでhttpsに向かう場合はSSL対応\n        const isSSL =\n          response.status === 301 && response.headers.get('Location')?.startsWith('https') === true;\n\n        // キャッシュに保存\n        this.sslCache.set(siteName, isSSL);\n        return isSSL;\n      })(),\n      (error) => {\n        if (error instanceof WikidotError) {\n          return error;\n        }\n        return new UnexpectedError(`Failed to check SSL for ${siteName}: ${String(error)}`);\n      }\n    );\n  }\n\n  /**\n   * AMCリクエストを実行する\n   * @param bodies - リクエストボディ配列\n   * @param siteName - サイト名（省略時はwww）\n   * @param sslSupported - SSL対応（省略時は自動検出）\n   * @returns レスポンス配列\n   */\n  request(\n    bodies: AMCRequestBody[],\n    siteName = 'www',\n    sslSupported?: boolean\n  ): WikidotResultAsync<AMCResponse[]> {\n    return this.requestWithOptions(bodies, {\n      siteName,\n      sslSupported,\n      returnExceptions: false,\n    }) as WikidotResultAsync<AMCResponse[]>;\n  }\n\n  /**\n   * AMCリクエストを実行する（オプション指定版）\n   * @param bodies - リクエストボディ配列\n   * @param options - リクエストオプション\n   * @returns レスポンス配列（returnExceptionsがtrueの場合はエラーも含む）\n   */\n  requestWithOptions(\n    bodies: AMCRequestBody[],\n    options: AMCRequestOptions = {}\n  ): WikidotResultAsync<(AMCResponse | WikidotError)[]> {\n    const { siteName = 'www', sslSupported, returnExceptions = false } = options;\n\n    return fromPromise(\n      (async () => {\n        // SSL対応状況を取得\n        let ssl = sslSupported;\n        if (ssl === undefined) {\n          const sslResult = await this.checkSiteSSL(siteName);\n          if (sslResult.isErr()) {\n            throw sslResult.error;\n          }\n          ssl = sslResult.value;\n        }\n\n        const protocol = ssl ? 'https' : 'http';\n        const url = `${protocol}://${siteName}.${this.domain}/ajax-module-connector.php`;\n\n        // 並列でリクエストを実行\n        const results = await Promise.all(\n          bodies.map((body) => this.limit(() => this.singleRequest(body, url)))\n        );\n\n        if (returnExceptions) {\n          // エラーも含めてすべての結果を返す\n          return results.map((r) => {\n            if (r.isOk()) {\n              return r.value;\n            }\n            return r.error;\n          });\n        }\n\n        // エラーがあれば最初のエラーをスロー\n        const firstError = results.find((r) => r.isErr());\n        if (firstError?.isErr()) {\n          throw firstError.error;\n        }\n\n        return results.map((r) => {\n          if (r.isOk()) {\n            return r.value;\n          }\n          throw new UnexpectedError('Unexpected error in result processing');\n        });\n      })(),\n      (error) => {\n        if (error instanceof WikidotError) {\n          return error;\n        }\n        return new UnexpectedError(`AMC request failed: ${String(error)}`);\n      }\n    );\n  }\n\n  /**\n   * 単一リクエストを実行する内部メソッド\n   * @param body - リクエストボディ\n   * @param url - リクエストURL\n   * @returns レスポンス\n   */\n  private async singleRequest(\n    body: AMCRequestBody,\n    url: string\n  ): Promise<WikidotResultAsync<AMCResponse>> {\n    let retryCount = 0;\n\n    while (true) {\n      try {\n        // wikidot_token7を追加\n        const requestBody = { ...body, wikidot_token7: WIKIDOT_TOKEN7 };\n\n        // URLエンコードされたボディを作成\n        const formData = new URLSearchParams();\n        for (const [key, value] of Object.entries(requestBody)) {\n          if (value !== undefined) {\n            formData.append(key, String(value));\n          }\n        }\n\n        const response = await this.ky.post(url, {\n          headers: this.header.getHeaders(),\n          body: formData.toString(),\n        });\n\n        // JSONとしてパース\n        let responseData: unknown;\n        try {\n          responseData = await response.json();\n        } catch {\n          return wdErrAsync(\n            new ResponseDataError(`AMC responded with non-JSON data: ${await response.text()}`)\n          );\n        }\n\n        // zodでバリデーション\n        const parseResult = amcResponseSchema.safeParse(responseData);\n        if (!parseResult.success) {\n          return wdErrAsync(\n            new ResponseDataError(`Invalid AMC response format: ${parseResult.error.message}`)\n          );\n        }\n\n        const amcResponse = parseResult.data;\n\n        // try_againの場合はリトライ\n        if (amcResponse.status === 'try_again') {\n          retryCount++;\n          if (retryCount >= this.config.retryLimit) {\n            return wdErrAsync(new WikidotStatusError('AMC responded with try_again', 'try_again'));\n          }\n          const backoff = calculateBackoff(\n            retryCount,\n            this.config.retryInterval,\n            this.config.backoffFactor,\n            this.config.maxBackoff\n          );\n          await sleep(backoff);\n          continue;\n        }\n\n        // no_permissionの場合はForbiddenError\n        if (amcResponse.status === 'no_permission') {\n          const targetStr = body.moduleName\n            ? `moduleName: ${body.moduleName}`\n            : body.action\n              ? `action: ${body.action}/${body.event ?? ''}`\n              : 'unknown';\n          return wdErrAsync(\n            new ForbiddenError(\n              `Your account has no permission to perform this action: ${targetStr}`\n            )\n          );\n        }\n\n        // okでない場合はエラー\n        if (amcResponse.status !== 'ok') {\n          return wdErrAsync(\n            new WikidotStatusError(\n              `AMC responded with error status: \"${amcResponse.status}\"`,\n              amcResponse.status\n            )\n          );\n        }\n\n        return wdOkAsync(amcResponse);\n      } catch (error) {\n        // HTTPエラーの場合はリトライ\n        retryCount++;\n        if (retryCount >= this.config.retryLimit) {\n          const statusCode =\n            error instanceof Error && 'response' in error\n              ? ((error as { response?: { status?: number } }).response?.status ??\n                DEFAULT_HTTP_STATUS_CODE)\n              : DEFAULT_HTTP_STATUS_CODE;\n          return wdErrAsync(\n            new AMCHttpError(`AMC HTTP request failed: ${String(error)}`, statusCode)\n          );\n        }\n\n        const backoff = calculateBackoff(\n          retryCount,\n          this.config.retryInterval,\n          this.config.backoffFactor,\n          this.config.maxBackoff\n        );\n        await sleep(backoff);\n      }\n    }\n  }\n}\n",
    "/**\n * Ajax Module Connector設定\n */\nexport interface AMCConfig {\n  /** リクエストタイムアウト（ミリ秒） */\n  timeout: number;\n\n  /** リトライ上限回数 */\n  retryLimit: number;\n\n  /** リトライ基本間隔（ミリ秒） */\n  retryInterval: number;\n\n  /** 最大バックオフ（ミリ秒） */\n  maxBackoff: number;\n\n  /** バックオフ係数 */\n  backoffFactor: number;\n\n  /** 最大並列リクエスト数 */\n  semaphoreLimit: number;\n}\n\n/** デフォルトAMC設定 */\nexport const DEFAULT_AMC_CONFIG: AMCConfig = {\n  timeout: 20000,\n  retryLimit: 3,\n  retryInterval: 1000,\n  maxBackoff: 60000,\n  backoffFactor: 2.0,\n  semaphoreLimit: 10,\n};\n\n/**\n * Wikidotが要求する固定トークン値\n * これはWikidotのフロントエンドから取得される固定値で、\n * セキュリティトークンではなく単なる識別子として使用される\n */\nexport const WIKIDOT_TOKEN7 = '123456';\n\n/**\n * HTTPエラー時のフォールバックステータスコード\n * レスポンスからステータスコードを取得できない場合に使用\n */\nexport const DEFAULT_HTTP_STATUS_CODE = 999;\n",
    "/**\n * AMCリクエストヘッダーを管理するクラス\n */\nexport class AMCHeader {\n  private cookies: Map<string, string>;\n  private contentType: string;\n  private userAgent: string;\n  private referer: string;\n\n  /**\n   * @param options - ヘッダー初期化オプション\n   */\n  constructor(options?: { contentType?: string; userAgent?: string; referer?: string }) {\n    this.contentType = options?.contentType ?? 'application/x-www-form-urlencoded; charset=UTF-8';\n    this.userAgent = options?.userAgent ?? 'WikidotTS';\n    this.referer = options?.referer ?? 'https://www.wikidot.com/';\n    this.cookies = new Map([['wikidot_token7', '123456']]);\n  }\n\n  /**\n   * Cookieを設定する\n   * @param name - Cookie名\n   * @param value - Cookie値\n   */\n  setCookie(name: string, value: string): void {\n    this.cookies.set(name, value);\n  }\n\n  /**\n   * Cookieを削除する\n   * @param name - Cookie名\n   */\n  deleteCookie(name: string): void {\n    this.cookies.delete(name);\n  }\n\n  /**\n   * Cookieを取得する\n   * @param name - Cookie名\n   * @returns Cookie値、存在しない場合はundefined\n   */\n  getCookie(name: string): string | undefined {\n    return this.cookies.get(name);\n  }\n\n  /**\n   * HTTPヘッダーオブジェクトを取得する\n   * @returns ヘッダー辞書\n   */\n  getHeaders(): Record<string, string> {\n    const cookieString = Array.from(this.cookies.entries())\n      .map(([name, value]) => `${name}=${value}`)\n      .join('; ');\n\n    return {\n      'Content-Type': this.contentType,\n      'User-Agent': this.userAgent,\n      Referer: this.referer,\n      Cookie: cookieString,\n    };\n  }\n}\n",
    "import { z } from 'zod';\n\n/**\n * AMCリクエストボディの値型\n */\nexport type AMCRequestBodyValue =\n  | string\n  | number\n  | boolean\n  | null\n  | undefined\n  | Record<string, unknown>\n  | AMCRequestBodyValue[];\n\n/**\n * AMCリクエストボディの型定義\n */\nexport interface AMCRequestBody {\n  moduleName?: string;\n  action?: string;\n  event?: string;\n  [key: string]: AMCRequestBodyValue;\n}\n\n/**\n * AMCレスポンスのベーススキーマ\n */\nconst baseSchema: z.ZodObject<{\n  status: z.ZodString;\n  body: z.ZodOptional<z.ZodString>;\n  message: z.ZodOptional<z.ZodString>;\n}> = z.object({\n  status: z.string(),\n  body: z.string().optional(),\n  message: z.string().optional(),\n});\n\n/**\n * AMCレスポンススキーマ\n */\nexport const amcResponseSchema: z.ZodType<z.infer<typeof baseSchema> & Record<string, unknown>> =\n  baseSchema.passthrough();\n\n/**\n * AMCレスポンス型\n */\nexport type AMCResponse = z.infer<typeof amcResponseSchema>;\n\n/**\n * 成功したAMCレスポンス\n */\nexport interface AMCSuccessResponse {\n  status: 'ok';\n  body: string;\n  [key: string]: unknown;\n}\n\n/**\n * AMCレスポンスが成功かどうかを判定する型ガード\n * @param response - AMCレスポンス\n * @returns 成功レスポンスの場合true\n */\nexport function isSuccessResponse(response: AMCResponse): response is AMCSuccessResponse {\n  return response.status === 'ok';\n}\n",
    "import { SessionCreateError } from '../common/errors';\nimport { fromPromise, type WikidotResultAsync, wdOkAsync } from '../common/types';\nimport type { AuthClientContext } from '../module/types';\n\nconst LOGIN_URL = 'https://www.wikidot.com/default--flow/login__LoginPopupScreen';\n\n/**\n * ユーザー名とパスワードでWikidotにログインする\n * @param client - クライアントコンテキスト（AMCClientを持つオブジェクト）\n * @param username - ユーザー名\n * @param password - パスワード\n * @returns 成功時はvoid、失敗時はSessionCreateError\n */\nexport function login(\n  client: AuthClientContext,\n  username: string,\n  password: string\n): WikidotResultAsync<void> {\n  return fromPromise(\n    (async () => {\n      const formData = new URLSearchParams({\n        login: username,\n        password: password,\n        action: 'Login2Action',\n        event: 'login',\n      });\n\n      const response = await fetch(LOGIN_URL, {\n        method: 'POST',\n        headers: client.amcClient.header.getHeaders(),\n        body: formData.toString(),\n      });\n\n      // Check status code\n      if (!response.ok) {\n        throw new SessionCreateError(\n          `Login attempt failed due to HTTP status code: ${response.status}`\n        );\n      }\n\n      // Check body for error message\n      const body = await response.text();\n      if (body.includes('The login and password do not match')) {\n        throw new SessionCreateError('Login attempt failed due to invalid username or password');\n      }\n\n      // Check cookies\n      const cookies = response.headers.get('Set-Cookie');\n      if (!cookies) {\n        throw new SessionCreateError('Login attempt failed due to missing cookies');\n      }\n\n      // Extract WIKIDOT_SESSION_ID from cookies\n      const sessionIdMatch = cookies.match(/WIKIDOT_SESSION_ID=([^;]+)/);\n      if (!sessionIdMatch?.[1]) {\n        throw new SessionCreateError(\n          'Login attempt failed due to missing WIKIDOT_SESSION_ID cookie'\n        );\n      }\n\n      // Set session cookie\n      client.amcClient.header.setCookie('WIKIDOT_SESSION_ID', sessionIdMatch[1]);\n    })(),\n    (error) => {\n      if (error instanceof SessionCreateError) {\n        return error;\n      }\n      return new SessionCreateError(`Login failed: ${String(error)}`);\n    }\n  );\n}\n\n/**\n * ログアウトする\n * @param client - クライアントコンテキスト（AMCClientを持つオブジェクト）\n * @returns 成功時はvoid\n */\nexport function logout(client: AuthClientContext): WikidotResultAsync<void> {\n  // Try to logout via AMC, then always remove session cookie\n  return client.amcClient\n    .request([\n      {\n        moduleName: 'Empty',\n        action: 'Login2Action',\n        event: 'logout',\n      },\n    ])\n    .map(() => {\n      // Logout succeeded, remove session cookie\n      client.amcClient.header.deleteCookie('WIKIDOT_SESSION_ID');\n      return undefined;\n    })\n    .orElse(() => {\n      // Even if logout request fails, we still want to clear the session locally\n      client.amcClient.header.deleteCookie('WIKIDOT_SESSION_ID');\n      return wdOkAsync(undefined);\n    });\n}\n",
    "import * as cheerio from 'cheerio';\nimport {\n  ForbiddenError,\n  LoginRequiredError,\n  NoElementError,\n  UnexpectedError,\n} from '../../common/errors';\nimport { fromPromise, type WikidotResultAsync } from '../../common/types';\nimport { parseOdate, parseUser } from '../../util/parser';\nimport type { Client } from '../client';\nimport type { AbstractUser } from '../user';\nimport type { User } from '../user/user';\n\n/**\n * プライベートメッセージデータ\n */\nexport interface PrivateMessageData {\n  client: Client;\n  id: number;\n  sender: AbstractUser;\n  recipient: AbstractUser;\n  subject: string;\n  body: string;\n  createdAt: Date;\n}\n\n/**\n * プライベートメッセージ\n */\nexport class PrivateMessage {\n  public readonly client: Client;\n  public readonly id: number;\n  public readonly sender: AbstractUser;\n  public readonly recipient: AbstractUser;\n  public readonly subject: string;\n  public readonly body: string;\n  public readonly createdAt: Date;\n\n  constructor(data: PrivateMessageData) {\n    this.client = data.client;\n    this.id = data.id;\n    this.sender = data.sender;\n    this.recipient = data.recipient;\n    this.subject = data.subject;\n    this.body = data.body;\n    this.createdAt = data.createdAt;\n  }\n\n  /**\n   * メッセージIDからメッセージを取得する\n   * @param client - クライアント\n   * @param messageId - メッセージID\n   * @returns プライベートメッセージ\n   */\n  static fromId(client: Client, messageId: number): WikidotResultAsync<PrivateMessage> {\n    return fromPromise(\n      (async () => {\n        const result = await PrivateMessageCollection.fromIds(client, [messageId]);\n        if (result.isErr()) {\n          throw result.error;\n        }\n        const message = result.value[0];\n        if (!message) {\n          throw new NoElementError(`Message not found: ${messageId}`);\n        }\n        return message;\n      })(),\n      (error) => {\n        if (error instanceof ForbiddenError || error instanceof NoElementError) {\n          return error;\n        }\n        return new UnexpectedError(`Failed to get message: ${String(error)}`);\n      }\n    );\n  }\n\n  /**\n   * プライベートメッセージを送信する\n   * @param client - クライアント\n   * @param recipient - 受信者\n   * @param subject - 件名\n   * @param body - 本文\n   */\n  static send(\n    client: Client,\n    recipient: User,\n    subject: string,\n    body: string\n  ): WikidotResultAsync<void> {\n    const loginResult = client.requireLogin();\n    if (loginResult.isErr()) {\n      return fromPromise(\n        Promise.reject(loginResult.error),\n        () => new LoginRequiredError('Login required to send message')\n      );\n    }\n\n    return fromPromise(\n      (async () => {\n        const result = await client.amcClient.request([\n          {\n            source: body,\n            subject,\n            to_user_id: recipient.id,\n            action: 'DashboardMessageAction',\n            event: 'send',\n            moduleName: 'Empty',\n          },\n        ]);\n        if (result.isErr()) {\n          throw result.error;\n        }\n      })(),\n      (error) => new UnexpectedError(`Failed to send message: ${String(error)}`)\n    );\n  }\n\n  toString(): string {\n    return `PrivateMessage(id=${this.id}, sender=${this.sender}, recipient=${this.recipient}, subject=${this.subject})`;\n  }\n}\n\n/**\n * プライベートメッセージコレクション\n */\nexport class PrivateMessageCollection extends Array<PrivateMessage> {\n  public readonly client: Client;\n\n  constructor(client: Client, messages?: PrivateMessage[]) {\n    super();\n    this.client = client;\n    if (messages) {\n      this.push(...messages);\n    }\n  }\n\n  /**\n   * IDで検索\n   */\n  findById(id: number): PrivateMessage | undefined {\n    return this.find((message) => message.id === id);\n  }\n\n  /**\n   * メッセージIDのリストからメッセージを取得する\n   */\n  static fromIds(\n    client: Client,\n    messageIds: number[]\n  ): WikidotResultAsync<PrivateMessageCollection> {\n    const loginResult = client.requireLogin();\n    if (loginResult.isErr()) {\n      return fromPromise(\n        Promise.reject(loginResult.error),\n        () => new LoginRequiredError('Login required to get messages')\n      );\n    }\n\n    return fromPromise(\n      (async () => {\n        const bodies = messageIds.map((messageId) => ({\n          item: messageId,\n          moduleName: 'dashboard/messages/DMViewMessageModule',\n        }));\n\n        const result = await client.amcClient.request(bodies);\n        if (result.isErr()) {\n          throw result.error;\n        }\n\n        const messages: PrivateMessage[] = [];\n\n        for (let i = 0; i < messageIds.length; i++) {\n          const response = result.value[i];\n          const messageId = messageIds[i];\n          if (!response || messageId === undefined) continue;\n\n          const html = String(response.body ?? '');\n          const $ = cheerio.load(html);\n\n          // ユーザー情報を取得\n          const printuserElems = $('div.pmessage div.header span.printuser');\n          if (printuserElems.length < 2) {\n            throw new ForbiddenError(`Failed to get message: ${messageId}`);\n          }\n\n          const senderElem = $(printuserElems[0]);\n          const recipientElem = $(printuserElems[1]);\n\n          const sender = parseUser(client, senderElem);\n          const recipient = parseUser(client, recipientElem);\n\n          // 件名\n          const subjectElem = $('div.pmessage div.header span.subject');\n          const subject = subjectElem.text().trim();\n\n          // 本文\n          const bodyElem = $('div.pmessage div.body');\n          const body = bodyElem.text().trim();\n\n          // 日時\n          const odateElem = $('div.header span.odate');\n          const createdAt =\n            odateElem.length > 0 ? (parseOdate(odateElem) ?? new Date(0)) : new Date(0);\n\n          messages.push(\n            new PrivateMessage({\n              client,\n              id: messageId,\n              sender,\n              recipient,\n              subject,\n              body,\n              createdAt,\n            })\n          );\n        }\n\n        return new PrivateMessageCollection(client, messages);\n      })(),\n      (error) => {\n        if (error instanceof ForbiddenError || error instanceof LoginRequiredError) {\n          return error;\n        }\n        return new UnexpectedError(`Failed to get messages: ${String(error)}`);\n      }\n    );\n  }\n\n  /**\n   * モジュールからメッセージを取得する内部メソッド\n   */\n  protected static acquireFromModule(\n    client: Client,\n    moduleName: string\n  ): WikidotResultAsync<PrivateMessageCollection> {\n    const loginResult = client.requireLogin();\n    if (loginResult.isErr()) {\n      return fromPromise(\n        Promise.reject(loginResult.error),\n        () => new LoginRequiredError('Login required to get messages')\n      );\n    }\n\n    return fromPromise(\n      (async () => {\n        // ページャー取得\n        const firstResult = await client.amcClient.request([{ moduleName }]);\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 firstHtml = String(firstResponse.body ?? '');\n        const $first = cheerio.load(firstHtml);\n\n        // ページ数を取得\n        const pagerTargets = $first('div.pager span.target');\n        let maxPage = 1;\n        if (pagerTargets.length > 2) {\n          const lastPageText = $first(pagerTargets[pagerTargets.length - 2])\n            .text()\n            .trim();\n          maxPage = Number.parseInt(lastPageText, 10) || 1;\n        }\n\n        // 全ページからメッセージIDを取得\n        const messageIds: number[] = [];\n\n        if (maxPage > 1) {\n          const bodies = [];\n          for (let page = 1; page <= maxPage; page++) {\n            bodies.push({ page, moduleName });\n          }\n          const additionalResults = await client.amcClient.request(bodies);\n          if (additionalResults.isErr()) {\n            throw additionalResults.error;\n          }\n\n          for (const response of additionalResults.value) {\n            const html = String(response?.body ?? '');\n            const $ = cheerio.load(html);\n            $('tr.message').each((_i, elem) => {\n              const dataHref = $(elem).attr('data-href') ?? '';\n              const idMatch = dataHref.match(/\\/(\\d+)$/);\n              if (idMatch?.[1]) {\n                messageIds.push(Number.parseInt(idMatch[1], 10));\n              }\n            });\n          }\n        } else {\n          $first('tr.message').each((_i, elem) => {\n            const dataHref = $first(elem).attr('data-href') ?? '';\n            const idMatch = dataHref.match(/\\/(\\d+)$/);\n            if (idMatch?.[1]) {\n              messageIds.push(Number.parseInt(idMatch[1], 10));\n            }\n          });\n        }\n\n        // メッセージを取得\n        const messagesResult = await PrivateMessageCollection.fromIds(client, messageIds);\n        if (messagesResult.isErr()) {\n          throw messagesResult.error;\n        }\n\n        return messagesResult.value;\n      })(),\n      (error) => {\n        if (\n          error instanceof ForbiddenError ||\n          error instanceof LoginRequiredError ||\n          error instanceof NoElementError\n        ) {\n          return error;\n        }\n        return new UnexpectedError(`Failed to acquire messages: ${String(error)}`);\n      }\n    );\n  }\n}\n\n/**\n * 受信箱\n */\nexport class PrivateMessageInbox extends PrivateMessageCollection {\n  /**\n   * 受信箱のメッセージをすべて取得する\n   */\n  static acquire(client: Client): WikidotResultAsync<PrivateMessageInbox> {\n    return fromPromise(\n      (async () => {\n        const result = await PrivateMessageCollection.acquireFromModule(\n          client,\n          'dashboard/messages/DMInboxModule'\n        );\n        if (result.isErr()) {\n          throw result.error;\n        }\n        const inbox = new PrivateMessageInbox(client);\n        inbox.push(...result.value);\n        return inbox;\n      })(),\n      (error) => {\n        if (error instanceof ForbiddenError || error instanceof LoginRequiredError) {\n          return error;\n        }\n        return new UnexpectedError(`Failed to acquire inbox: ${String(error)}`);\n      }\n    );\n  }\n}\n\n/**\n * 送信箱\n */\nexport class PrivateMessageSentBox extends PrivateMessageCollection {\n  /**\n   * 送信箱のメッセージをすべて取得する\n   */\n  static acquire(client: Client): WikidotResultAsync<PrivateMessageSentBox> {\n    return fromPromise(\n      (async () => {\n        const result = await PrivateMessageCollection.acquireFromModule(\n          client,\n          'dashboard/messages/DMSentModule'\n        );\n        if (result.isErr()) {\n          throw result.error;\n        }\n        const sentBox = new PrivateMessageSentBox(client);\n        sentBox.push(...result.value);\n        return sentBox;\n      })(),\n      (error) => {\n        if (error instanceof ForbiddenError || error instanceof LoginRequiredError) {\n          return error;\n        }\n        return new UnexpectedError(`Failed to acquire sent box: ${String(error)}`);\n      }\n    );\n  }\n}\n",
    "import type { WikidotResultAsync } from '../../../common/types';\nimport {\n  PrivateMessage,\n  PrivateMessageCollection,\n  PrivateMessageInbox,\n  PrivateMessageSentBox,\n} from '../../private-message';\nimport type { User } from '../../user/user';\nimport type { Client } from '../client';\n\n/**\n * プライベートメッセージ操作アクセサ\n */\nexport class PrivateMessageAccessor {\n  public readonly client: Client;\n\n  constructor(client: Client) {\n    this.client = client;\n  }\n\n  /**\n   * メッセージIDからメッセージを取得する\n   * @param id - メッセージID\n   * @returns メッセージオブジェクト\n   */\n  get(id: number): WikidotResultAsync<PrivateMessage> {\n    return PrivateMessage.fromId(this.client, id);\n  }\n\n  /**\n   * 複数のメッセージIDからメッセージを取得する\n   * @param ids - メッセージID配列\n   * @returns メッセージコレクション\n   */\n  getMessages(ids: number[]): WikidotResultAsync<PrivateMessageCollection> {\n    return PrivateMessageCollection.fromIds(this.client, ids);\n  }\n\n  /**\n   * 受信箱のメッセージ一覧を取得する\n   * @returns 受信箱\n   */\n  inbox(): WikidotResultAsync<PrivateMessageInbox> {\n    return PrivateMessageInbox.acquire(this.client);\n  }\n\n  /**\n   * 送信箱のメッセージ一覧を取得する\n   * @returns 送信箱\n   */\n  sentBox(): WikidotResultAsync<PrivateMessageSentBox> {\n    return PrivateMessageSentBox.acquire(this.client);\n  }\n\n  /**\n   * プライベートメッセージを送信する\n   * @param recipient - 受信者\n   * @param subject - 件名\n   * @param body - 本文\n   */\n  send(recipient: User, subject: string, body: string): WikidotResultAsync<void> {\n    return PrivateMessage.send(this.client, recipient, subject, body);\n  }\n}\n\nexport { PrivateMessage, PrivateMessageCollection, PrivateMessageInbox, PrivateMessageSentBox };\n",
    "import type { WikidotResultAsync } from '../../../common/types';\nimport {\n  ForumCategory,\n  ForumCategoryCollection,\n  ForumPost,\n  ForumThread,\n  ForumThreadCollection,\n} from '../../forum';\nimport type { Site } from '../site';\n\n/**\n * フォーラム操作アクセサ\n */\nexport class ForumAccessor {\n  public readonly site: Site;\n\n  constructor(site: Site) {\n    this.site = site;\n  }\n\n  /**\n   * フォーラムカテゴリ一覧を取得\n   * @returns カテゴリ一覧\n   */\n  getCategories(): WikidotResultAsync<ForumCategoryCollection> {\n    return ForumCategoryCollection.acquireAll(this.site);\n  }\n\n  /**\n   * スレッドを取得\n   * @param threadId - スレッドID\n   * @returns スレッド\n   */\n  getThread(threadId: number): WikidotResultAsync<ForumThread> {\n    return ForumThread.getFromId(this.site, threadId);\n  }\n\n  /**\n   * 複数スレッドを取得\n   * @param threadIds - スレッドID配列\n   * @returns スレッドコレクション\n   */\n  getThreads(threadIds: number[]): WikidotResultAsync<ForumThreadCollection> {\n    return ForumThreadCollection.acquireFromThreadIds(this.site, threadIds);\n  }\n}\n\nexport { ForumCategory, ForumCategoryCollection, ForumThread, ForumThreadCollection, ForumPost };\n",
    "/**\n * QuickModule - Wikidot軽量API\n *\n * quickmodule.phpエンドポイントを使用した検索機能\n */\n\nimport { z } from 'zod';\nimport { NotFoundException, UnexpectedError } from '../common/errors';\nimport { fromPromise, type WikidotResultAsync } from '../common/types';\n\n/**\n * QuickModuleモジュール名\n */\nexport type QuickModuleName = 'MemberLookupQModule' | 'UserLookupQModule' | 'PageLookupQModule';\n\n/**\n * QuickModuleユーザー情報\n */\nexport interface QMCUser {\n  id: number;\n  name: string;\n}\n\n/**\n * QuickModuleページ情報\n */\nexport interface QMCPage {\n  title: string;\n  unixName: string;\n}\n\n/**\n * QuickModuleレスポンススキーマ\n */\nconst quickModuleUserResponseSchema = z.object({\n  users: z.union([\n    z.array(\n      z.object({\n        user_id: z.union([z.string(), z.number()]),\n        name: z.string(),\n      })\n    ),\n    z.literal(false),\n  ]),\n});\n\nconst quickModulePageResponseSchema = z.object({\n  pages: z.union([\n    z.array(\n      z.object({\n        title: z.string(),\n        unix_name: z.string(),\n      })\n    ),\n    z.literal(false),\n  ]),\n});\n\n/**\n * QuickModuleエンドポイントにリクエストを送信\n */\nasync function requestQuickModule(\n  moduleName: QuickModuleName,\n  siteId: number,\n  query: string\n): Promise<unknown> {\n  const url = `https://www.wikidot.com/quickmodule.php?module=${moduleName}&s=${siteId}&q=${encodeURIComponent(query)}`;\n\n  const response = await fetch(url, {\n    method: 'GET',\n    headers: {\n      Accept: 'application/json',\n    },\n  });\n\n  if (response.status === 500) {\n    throw new NotFoundException(`Site not found: siteId=${siteId}`);\n  }\n\n  if (!response.ok) {\n    throw new UnexpectedError(`QuickModule request failed: ${response.status}`);\n  }\n\n  return response.json();\n}\n\n/**\n * サイトメンバーを検索\n * @param siteId - サイトID\n * @param query - 検索クエリ（ユーザー名の一部）\n * @returns マッチしたユーザー一覧\n */\nexport function memberLookup(siteId: number, query: string): WikidotResultAsync<QMCUser[]> {\n  return fromPromise(\n    (async () => {\n      const data = await requestQuickModule('MemberLookupQModule', siteId, query);\n      const parsed = quickModuleUserResponseSchema.parse(data);\n\n      if (parsed.users === false) {\n        return [];\n      }\n\n      return parsed.users.map((user) => ({\n        id: typeof user.user_id === 'string' ? Number.parseInt(user.user_id, 10) : user.user_id,\n        name: user.name,\n      }));\n    })(),\n    (error) => {\n      if (error instanceof NotFoundException) return error;\n      return new UnexpectedError(`Member lookup failed: ${String(error)}`);\n    }\n  );\n}\n\n/**\n * Wikidot全体からユーザーを検索\n * @param siteId - サイトID（任意のサイトIDで可）\n * @param query - 検索クエリ（ユーザー名の一部）\n * @returns マッチしたユーザー一覧\n */\nexport function userLookup(siteId: number, query: string): WikidotResultAsync<QMCUser[]> {\n  return fromPromise(\n    (async () => {\n      const data = await requestQuickModule('UserLookupQModule', siteId, query);\n      const parsed = quickModuleUserResponseSchema.parse(data);\n\n      if (parsed.users === false) {\n        return [];\n      }\n\n      return parsed.users.map((user) => ({\n        id: typeof user.user_id === 'string' ? Number.parseInt(user.user_id, 10) : user.user_id,\n        name: user.name,\n      }));\n    })(),\n    (error) => {\n      if (error instanceof NotFoundException) return error;\n      return new UnexpectedError(`User lookup failed: ${String(error)}`);\n    }\n  );\n}\n\n/**\n * サイト内のページを検索\n * @param siteId - サイトID\n * @param query - 検索クエリ（ページ名の一部）\n * @returns マッチしたページ一覧\n */\nexport function pageLookup(siteId: number, query: string): WikidotResultAsync<QMCPage[]> {\n  return fromPromise(\n    (async () => {\n      const data = await requestQuickModule('PageLookupQModule', siteId, query);\n      const parsed = quickModulePageResponseSchema.parse(data);\n\n      if (parsed.pages === false) {\n        return [];\n      }\n\n      return parsed.pages.map((page) => ({\n        title: page.title,\n        unixName: page.unix_name,\n      }));\n    })(),\n    (error) => {\n      if (error instanceof NotFoundException) return error;\n      return new UnexpectedError(`Page lookup failed: ${String(error)}`);\n    }\n  );\n}\n\n/**\n * QuickModule API（後方互換性のため維持）\n * @deprecated 代わりに個別の関数（memberLookup, userLookup, pageLookup）を使用してください\n */\nexport const QuickModule: {\n  memberLookup: typeof memberLookup;\n  userLookup: typeof userLookup;\n  pageLookup: typeof pageLookup;\n} = {\n  memberLookup: memberLookup,\n  userLookup: userLookup,\n  pageLookup: pageLookup,\n};\n",
    "import * as cheerio from 'cheerio';\nimport { RequireLogin } from '../../common/decorators';\nimport {\n  ForbiddenError,\n  LoginRequiredError,\n  NotFoundException,\n  UnexpectedError,\n  WikidotStatusError,\n} from '../../common/errors';\nimport { fromPromise, type WikidotResultAsync } from '../../common/types';\nimport { parseUser } from '../../util/parser';\nimport type { AbstractUser } from '../user';\nimport type { Site } from './site';\n\n/**\n * サイト参加申請データ\n */\nexport interface SiteApplicationData {\n  site: Site;\n  user: AbstractUser;\n  text: string;\n}\n\n/**\n * サイト参加申請\n */\nexport class SiteApplication {\n  public readonly site: Site;\n  public readonly user: AbstractUser;\n  public readonly text: string;\n\n  constructor(data: SiteApplicationData) {\n    this.site = data.site;\n    this.user = data.user;\n    this.text = data.text;\n  }\n\n  /**\n   * 未処理の参加申請をすべて取得する\n   * @param site - 対象サイト\n   */\n  static acquireAll(site: Site): WikidotResultAsync<SiteApplication[]> {\n    const loginResult = site.client.requireLogin();\n    if (loginResult.isErr()) {\n      return fromPromise(\n        Promise.reject(loginResult.error),\n        () => new LoginRequiredError('Login required to get applications')\n      );\n    }\n\n    return fromPromise(\n      (async () => {\n        const result = await site.amcRequest([\n          { moduleName: 'managesite/ManageSiteMembersApplicationsModule' },\n        ]);\n\n        if (result.isErr()) {\n          throw result.error;\n        }\n\n        const response = result.value[0];\n        if (!response) {\n          throw new UnexpectedError('Empty response');\n        }\n\n        const html = String(response.body ?? '');\n\n        // 権限チェック\n        if (html.includes('WIKIDOT.page.listeners.loginClick(event)')) {\n          throw new ForbiddenError('You are not allowed to access this page');\n        }\n\n        const $ = cheerio.load(html);\n        const applications: SiteApplication[] = [];\n\n        const userElements = $('h3 span.printuser').toArray();\n        const textWrapperElements = $('table').toArray();\n\n        if (userElements.length !== textWrapperElements.length) {\n          throw new UnexpectedError(\n            'Length of user_elements and text_wrapper_elements are different'\n          );\n        }\n\n        for (let i = 0; i < userElements.length; i++) {\n          const userElement = userElements[i];\n          const textWrapperElement = textWrapperElements[i];\n\n          if (!userElement || !textWrapperElement) continue;\n\n          const user = parseUser(site.client, $(userElement));\n          const textElement = $(textWrapperElement).find('td').eq(1);\n          const text = textElement.text().trim();\n\n          applications.push(new SiteApplication({ site, user, text }));\n        }\n\n        return applications;\n      })(),\n      (error) => {\n        if (error instanceof ForbiddenError || error instanceof LoginRequiredError) {\n          return error;\n        }\n        return new UnexpectedError(`Failed to get applications: ${String(error)}`);\n      }\n    );\n  }\n\n  /**\n   * 申請を処理する内部メソッド\n   */\n  @RequireLogin\n  private process(action: 'accept' | 'decline'): WikidotResultAsync<void> {\n    return fromPromise(\n      (async () => {\n        const result = await this.site.amcRequest([\n          {\n            action: 'ManageSiteMembershipAction',\n            event: 'acceptApplication',\n            user_id: this.user.id,\n            text: `your application has been ${action}ed`,\n            type: action,\n            moduleName: 'Empty',\n          },\n        ]);\n        if (result.isErr()) {\n          const error = result.error;\n          if (error instanceof WikidotStatusError && error.statusCode === 'no_application') {\n            throw new NotFoundException(`Application not found: ${this.user.name}`);\n          }\n          throw error;\n        }\n      })(),\n      (error) => {\n        if (error instanceof NotFoundException || error instanceof LoginRequiredError) {\n          return error;\n        }\n        return new UnexpectedError(`Failed to process application: ${String(error)}`);\n      }\n    );\n  }\n\n  /**\n   * 参加申請を承認する\n   */\n  accept(): WikidotResultAsync<void> {\n    return this.process('accept');\n  }\n\n  /**\n   * 参加申請を拒否する\n   */\n  decline(): WikidotResultAsync<void> {\n    return this.process('decline');\n  }\n\n  toString(): string {\n    return `SiteApplication(user=${this.user.name}, site=${this.site.unixName}, text=${this.text})`;\n  }\n}\n",
    "import * as cheerio from 'cheerio';\nimport { RequireLogin } from '../../common/decorators';\nimport {\n  LoginRequiredError,\n  TargetError,\n  UnexpectedError,\n  WikidotStatusError,\n} from '../../common/errors';\nimport { fromPromise, type WikidotResultAsync } from '../../common/types';\nimport { parseOdate, parseUser } from '../../util/parser';\nimport type { AbstractUser } from '../user';\nimport type { Site } from './site';\n\n/**\n * サイトメンバーデータ\n */\nexport interface SiteMemberData {\n  site: Site;\n  user: AbstractUser;\n  joinedAt: Date | null;\n}\n\n/**\n * サイトメンバー\n */\nexport class SiteMember {\n  public readonly site: Site;\n  public readonly user: AbstractUser;\n  public readonly joinedAt: Date | null;\n\n  constructor(data: SiteMemberData) {\n    this.site = data.site;\n    this.user = data.user;\n    this.joinedAt = data.joinedAt;\n  }\n\n  /**\n   * HTMLからメンバー情報をパースする\n   */\n  private static parse(site: Site, html: string): SiteMember[] {\n    const $ = cheerio.load(html);\n    const members: SiteMember[] = [];\n\n    $('table tr').each((_i, row) => {\n      const tds = $(row).find('td');\n      const userElem = $(tds[0]).find('.printuser');\n\n      if (userElem.length === 0) {\n        return;\n      }\n\n      const user = parseUser(site.client, userElem);\n\n      // 2つ目のtdがあれば加入日時\n      let joinedAt: Date | null = null;\n      if (tds.length >= 2) {\n        const odateElem = $(tds[1]).find('.odate');\n        if (odateElem.length > 0) {\n          joinedAt = parseOdate(odateElem);\n        }\n      }\n\n      members.push(new SiteMember({ site, user, joinedAt }));\n    });\n\n    return members;\n  }\n\n  /**\n   * サイトメンバー一覧を取得する\n   * @param site - 対象サイト\n   * @param group - グループ（\"admins\", \"moderators\", または空文字で全メンバー）\n   */\n  static getMembers(\n    site: Site,\n    group: 'admins' | 'moderators' | '' = ''\n  ): WikidotResultAsync<SiteMember[]> {\n    return fromPromise(\n      (async () => {\n        const members: SiteMember[] = [];\n\n        // 最初のページを取得\n        const firstResult = await site.amcRequest([\n          {\n            moduleName: 'membership/MembersListModule',\n            page: 1,\n            group,\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 UnexpectedError('Empty response');\n        }\n\n        const firstHtml = String(firstResponse.body ?? '');\n        members.push(...SiteMember.parse(site, firstHtml));\n\n        // ページャーを確認\n        const $first = cheerio.load(firstHtml);\n        const pagerLinks = $first('div.pager a');\n        if (pagerLinks.length < 2) {\n          return members;\n        }\n\n        const lastPageText = $first(pagerLinks[pagerLinks.length - 2])\n          .text()\n          .trim();\n        const lastPage = Number.parseInt(lastPageText, 10) || 1;\n        if (lastPage <= 1) {\n          return members;\n        }\n\n        // 残りのページを取得\n        const bodies = [];\n        for (let page = 2; page <= lastPage; page++) {\n          bodies.push({\n            moduleName: 'membership/MembersListModule',\n            page,\n            group,\n          });\n        }\n\n        const additionalResults = await site.amcRequest(bodies);\n        if (additionalResults.isErr()) {\n          throw additionalResults.error;\n        }\n\n        for (const response of additionalResults.value) {\n          const html = String(response?.body ?? '');\n          members.push(...SiteMember.parse(site, html));\n        }\n\n        return members;\n      })(),\n      (error) => new UnexpectedError(`Failed to get members: ${String(error)}`)\n    );\n  }\n\n  /**\n   * グループ変更の内部メソッド\n   */\n  @RequireLogin\n  private changeGroup(\n    event: 'toModerators' | 'removeModerator' | 'toAdmins' | 'removeAdmin'\n  ): WikidotResultAsync<void> {\n    return fromPromise(\n      (async () => {\n        const result = await this.site.amcRequest([\n          {\n            action: 'ManageSiteMembershipAction',\n            event,\n            user_id: this.user.id,\n            moduleName: '',\n          },\n        ]);\n        if (result.isErr()) {\n          const error = result.error;\n          if (error instanceof WikidotStatusError) {\n            if (error.statusCode === 'not_already') {\n              throw new TargetError(`User is not moderator/admin: ${this.user.name}`);\n            }\n            if (error.statusCode === 'already_admin' || error.statusCode === 'already_moderator') {\n              throw new TargetError(\n                `User is already ${error.statusCode.replace('already_', '')}: ${this.user.name}`\n              );\n            }\n          }\n          throw error;\n        }\n      })(),\n      (error) => {\n        if (error instanceof TargetError || error instanceof LoginRequiredError) {\n          return error;\n        }\n        return new UnexpectedError(`Failed to change member group: ${String(error)}`);\n      }\n    );\n  }\n\n  /**\n   * モデレーターに昇格\n   */\n  toModerator(): WikidotResultAsync<void> {\n    return this.changeGroup('toModerators');\n  }\n\n  /**\n   * モデレーター権限を削除\n   */\n  removeModerator(): WikidotResultAsync<void> {\n    return this.changeGroup('removeModerator');\n  }\n\n  /**\n   * 管理者に昇格\n   */\n  toAdmin(): WikidotResultAsync<void> {\n    return this.changeGroup('toAdmins');\n  }\n\n  /**\n   * 管理者権限を削除\n   */\n  removeAdmin(): WikidotResultAsync<void> {\n    return this.changeGroup('removeAdmin');\n  }\n\n  toString(): string {\n    return `SiteMember(user=${this.user.name}, site=${this.site.unixName})`;\n  }\n}\n",
    "import { RequireLogin } from '../../../common/decorators';\nimport {\n  LoginRequiredError,\n  TargetError,\n  UnexpectedError,\n  WikidotStatusError,\n} from '../../../common/errors';\nimport { fromPromise, type WikidotResultAsync } from '../../../common/types';\nimport { type QMCUser, QuickModule } from '../../../util/quick-module';\nimport type { User } from '../../user/user';\nimport type { Site } from '../site';\nimport { SiteApplication } from '../site-application';\nimport { SiteMember } from '../site-member';\n\n/**\n * サイトメンバー操作アクセサ\n */\nexport class MemberAccessor {\n  public readonly site: Site;\n\n  constructor(site: Site) {\n    this.site = site;\n  }\n\n  /**\n   * 全メンバーを取得する\n   * @returns メンバー一覧\n   */\n  getAll(): WikidotResultAsync<SiteMember[]> {\n    return SiteMember.getMembers(this.site, '');\n  }\n\n  /**\n   * モデレーター一覧を取得する\n   * @returns モデレーター一覧\n   */\n  getModerators(): WikidotResultAsync<SiteMember[]> {\n    return SiteMember.getMembers(this.site, 'moderators');\n  }\n\n  /**\n   * 管理者一覧を取得する\n   * @returns 管理者一覧\n   */\n  getAdmins(): WikidotResultAsync<SiteMember[]> {\n    return SiteMember.getMembers(this.site, 'admins');\n  }\n\n  /**\n   * 未処理の参加申請を取得する\n   * @returns 参加申請一覧\n   */\n  getApplications(): WikidotResultAsync<SiteApplication[]> {\n    return SiteApplication.acquireAll(this.site);\n  }\n\n  /**\n   * メンバーを検索する\n   * @param query - 検索クエリ（ユーザー名の一部）\n   * @returns マッチしたユーザー一覧（QMCUser形式）\n   */\n  lookup(query: string): WikidotResultAsync<QMCUser[]> {\n    return QuickModule.memberLookup(this.site.id, query);\n  }\n\n  /**\n   * ユーザーをサイトに招待する\n   * @param user - 招待するユーザー\n   * @param text - 招待メッセージ\n   */\n  @RequireLogin\n  invite(user: User, text: string): WikidotResultAsync<void> {\n    return fromPromise(\n      (async () => {\n        const result = await this.site.amcRequest([\n          {\n            action: 'ManageSiteMembershipAction',\n            event: 'inviteMember',\n            user_id: user.id,\n            text,\n            moduleName: 'Empty',\n          },\n        ]);\n        if (result.isErr()) {\n          const error = result.error;\n          if (error instanceof WikidotStatusError) {\n            if (error.statusCode === 'already_invited') {\n              throw new TargetError(\n                `User is already invited to ${this.site.unixName}: ${user.name}`\n              );\n            }\n            if (error.statusCode === 'already_member') {\n              throw new TargetError(\n                `User is already a member of ${this.site.unixName}: ${user.name}`\n              );\n            }\n          }\n          throw error;\n        }\n      })(),\n      (error) => {\n        if (error instanceof TargetError || error instanceof LoginRequiredError) {\n          return error;\n        }\n        return new UnexpectedError(`Failed to invite user: ${String(error)}`);\n      }\n    );\n  }\n}\n\nexport { SiteMember, SiteApplication };\n",
    "import type { Cheerio } from 'cheerio';\nimport * as cheerio from 'cheerio';\nimport type { AnyNode } from 'domhandler';\nimport { z } from 'zod';\nimport { RequireLogin } from '../../common/decorators';\nimport {\n  ForbiddenError,\n  LoginRequiredError,\n  NoElementError,\n  NotFoundException,\n  TargetExistsError,\n  UnexpectedError,\n} from '../../common/errors';\nimport { fromPromise, type WikidotResultAsync } from '../../common/types';\nimport type { AMCRequestBody } from '../../connector';\nimport { parseOdate, parseUser } from '../../util/parser';\nimport type { Site } from '../site';\nimport type { AbstractUser } from '../user';\nimport { PageFileCollection } from './page-file';\nimport { PageMetaCollection } from './page-meta';\nimport { type PageRevision, PageRevisionCollection } from './page-revision';\nimport { PageSource } from './page-source';\nimport { PageVote, PageVoteCollection } from './page-vote';\nimport { DEFAULT_MODULE_BODY, DEFAULT_PER_PAGE, SearchPagesQuery } from './search-query';\n\n/**\n * ListPagesModuleパース結果のスキーマ\n * 型安全性のためにZodを使用してパース結果を検証\n */\nconst pageParamsSchema = z.object({\n  fullname: z.string().default(''),\n  name: z.string().default(''),\n  category: z.string().default(''),\n  title: z.string().default(''),\n  children_count: z.number().default(0),\n  comments_count: z.number().default(0),\n  size: z.number().default(0),\n  rating: z.number().default(0),\n  votes_count: z.number().default(0),\n  rating_percent: z.number().nullable().default(null),\n  revisions_count: z.number().default(0),\n  parent_fullname: z.string().nullable().default(null),\n  tags: z.array(z.string()).default([]),\n  created_by: z.custom<AbstractUser>().nullable().default(null),\n  created_at: z.date().nullable().default(null),\n  updated_by: z.custom<AbstractUser>().nullable().default(null),\n  updated_at: z.date().nullable().default(null),\n  commented_by: z.custom<AbstractUser>().nullable().default(null),\n  commented_at: z.date().nullable().default(null),\n});\n\n/**\n * ページデータ\n */\nexport interface PageData {\n  site: Site;\n  fullname: string;\n  name: string;\n  category: string;\n  title: string;\n  childrenCount: number;\n  commentsCount: number;\n  size: number;\n  rating: number;\n  votesCount: number;\n  ratingPercent: number | null;\n  revisionsCount: number;\n  parentFullname: string | null;\n  tags: string[];\n  createdBy: AbstractUser | null;\n  createdAt: Date;\n  updatedBy: AbstractUser | null;\n  updatedAt: Date;\n  commentedBy: AbstractUser | null;\n  commentedAt: Date | null;\n}\n\n/**\n * Wikidotページ\n */\nexport class Page {\n  public readonly site: Site;\n  public readonly fullname: string;\n  public readonly name: string;\n  public readonly category: string;\n  public title: string;\n  public childrenCount: number;\n  public commentsCount: number;\n  public size: number;\n  public rating: number;\n  public votesCount: number;\n  public ratingPercent: number | null;\n  public revisionsCount: number;\n  public parentFullname: string | null;\n  public tags: string[];\n  public readonly createdBy: AbstractUser | null;\n  public readonly createdAt: Date;\n  public updatedBy: AbstractUser | null;\n  public updatedAt: Date;\n  public commentedBy: AbstractUser | null;\n  public commentedAt: Date | null;\n\n  private _id: number | null = null;\n  private _source: PageSource | null = null;\n  private _revisions: PageRevisionCollection | null = null;\n  private _votes: PageVoteCollection | null = null;\n\n  constructor(data: PageData) {\n    this.site = data.site;\n    this.fullname = data.fullname;\n    this.name = data.name;\n    this.category = data.category;\n    this.title = data.title;\n    this.childrenCount = data.childrenCount;\n    this.commentsCount = data.commentsCount;\n    this.size = data.size;\n    this.rating = data.rating;\n    this.votesCount = data.votesCount;\n    this.ratingPercent = data.ratingPercent;\n    this.revisionsCount = data.revisionsCount;\n    this.parentFullname = data.parentFullname;\n    this.tags = data.tags;\n    this.createdBy = data.createdBy;\n    this.createdAt = data.createdAt;\n    this.updatedBy = data.updatedBy;\n    this.updatedAt = data.updatedAt;\n    this.commentedBy = data.commentedBy;\n    this.commentedAt = data.commentedAt;\n  }\n\n  /**\n   * ページURLを取得\n   */\n  getUrl(): string {\n    return `${this.site.getBaseUrl()}/${this.fullname}`;\n  }\n\n  /**\n   * ページIDが取得済みかどうか\n   */\n  isIdAcquired(): boolean {\n    return this._id !== null;\n  }\n\n  /**\n   * ページIDを取得\n   */\n  get id(): number | null {\n    return this._id;\n  }\n\n  /**\n   * ページIDを設定\n   */\n  set id(value: number | null) {\n    this._id = value;\n  }\n\n  /**\n   * ソースコードを取得\n   */\n  get source(): PageSource | null {\n    return this._source;\n  }\n\n  /**\n   * ソースコードを設定\n   */\n  set source(value: PageSource | null) {\n    this._source = value;\n  }\n\n  /**\n   * リビジョン履歴を取得\n   */\n  get revisions(): PageRevisionCollection | null {\n    return this._revisions;\n  }\n\n  /**\n   * リビジョン履歴を設定\n   */\n  set revisions(value: PageRevisionCollection | null) {\n    this._revisions = value;\n  }\n\n  /**\n   * 投票情報を取得\n   */\n  get votes(): PageVoteCollection | null {\n    return this._votes;\n  }\n\n  /**\n   * 投票情報を設定\n   */\n  set votes(value: PageVoteCollection | null) {\n    this._votes = value;\n  }\n\n  /**\n   * 最新リビジョンを取得\n   */\n  get latestRevision(): PageRevision | undefined {\n    if (!this._revisions || this._revisions.length === 0) return undefined;\n    return this._revisions.reduce((max, rev) => (rev.revNo > max.revNo ? rev : max));\n  }\n\n  /**\n   * ページIDが必須の操作で、IDがない場合にエラーを返すヘルパー\n   * @param operation - 操作名（エラーメッセージ用）\n   * @returns ページIDまたはエラーResult\n   */\n  private requireId(\n    operation: string\n  ): { ok: true; id: number } | { ok: false; error: WikidotResultAsync<never> } {\n    if (this._id === null) {\n      return {\n        ok: false,\n        error: fromPromise(\n          Promise.reject(new Error('Page ID not acquired')),\n          () => new UnexpectedError(`Page ID must be acquired before ${operation}`)\n        ),\n      };\n    }\n    return { ok: true, id: this._id };\n  }\n\n  /**\n   * ページを削除する\n   */\n  @RequireLogin\n  destroy(): WikidotResultAsync<void> {\n    const idCheck = this.requireId('deletion');\n    if (!idCheck.ok) return idCheck.error;\n\n    return fromPromise(\n      (async () => {\n        const result = await this.site.amcRequest([\n          {\n            action: 'WikiPageAction',\n            event: 'deletePage',\n            page_id: this._id,\n            moduleName: 'Empty',\n          },\n        ]);\n        if (result.isErr()) {\n          throw result.error;\n        }\n      })(),\n      (error) => new UnexpectedError(`Failed to delete page: ${String(error)}`)\n    );\n  }\n\n  /**\n   * タグを保存する\n   */\n  @RequireLogin\n  commitTags(): WikidotResultAsync<void> {\n    const idCheck = this.requireId('saving tags');\n    if (!idCheck.ok) return idCheck.error;\n\n    return fromPromise(\n      (async () => {\n        const result = await this.site.amcRequest([\n          {\n            tags: this.tags.join(' '),\n            action: 'WikiPageAction',\n            event: 'saveTags',\n            pageId: this._id,\n            moduleName: 'Empty',\n          },\n        ]);\n        if (result.isErr()) {\n          throw result.error;\n        }\n      })(),\n      (error) => new UnexpectedError(`Failed to save tags: ${String(error)}`)\n    );\n  }\n\n  /**\n   * 親ページを設定する\n   * @param parentFullname - 親ページのフルネーム（nullで解除）\n   */\n  @RequireLogin\n  setParent(parentFullname: string | null): WikidotResultAsync<void> {\n    const idCheck = this.requireId('setting parent');\n    if (!idCheck.ok) return idCheck.error;\n\n    return fromPromise(\n      (async () => {\n        const result = await this.site.amcRequest([\n          {\n            action: 'WikiPageAction',\n            event: 'setParentPage',\n            moduleName: 'Empty',\n            pageId: String(this._id),\n            parentName: parentFullname ?? '',\n          },\n        ]);\n        if (result.isErr()) {\n          throw result.error;\n        }\n        this.parentFullname = parentFullname;\n      })(),\n      (error) => new UnexpectedError(`Failed to set parent: ${String(error)}`)\n    );\n  }\n\n  /**\n   * ページに投票する\n   * @param value - 投票値\n   * @returns 新しいレーティング\n   */\n  @RequireLogin\n  vote(value: number): WikidotResultAsync<number> {\n    const idCheck = this.requireId('voting');\n    if (!idCheck.ok) return idCheck.error;\n\n    return fromPromise(\n      (async () => {\n        const result = await this.site.amcRequest([\n          {\n            action: 'RateAction',\n            event: 'ratePage',\n            moduleName: 'Empty',\n            pageId: this._id,\n            points: value,\n            force: 'yes',\n          },\n        ]);\n        if (result.isErr()) {\n          throw result.error;\n        }\n        const response = result.value[0];\n        if (!response) {\n          throw new UnexpectedError('Empty response from vote request');\n        }\n        const newRating = Number.parseInt(String(response.points ?? this.rating), 10);\n        this.rating = newRating;\n        return newRating;\n      })(),\n      (error) => new UnexpectedError(`Failed to vote: ${String(error)}`)\n    );\n  }\n\n  /**\n   * 投票をキャンセルする\n   * @returns 新しいレーティング\n   */\n  @RequireLogin\n  cancelVote(): WikidotResultAsync<number> {\n    const idCheck = this.requireId('canceling vote');\n    if (!idCheck.ok) return idCheck.error;\n\n    return fromPromise(\n      (async () => {\n        const result = await this.site.amcRequest([\n          {\n            action: 'RateAction',\n            event: 'cancelVote',\n            moduleName: 'Empty',\n            pageId: this._id,\n          },\n        ]);\n        if (result.isErr()) {\n          throw result.error;\n        }\n        const response = result.value[0];\n        if (!response) {\n          throw new UnexpectedError('Empty response from cancel vote request');\n        }\n        const newRating = Number.parseInt(String(response.points ?? this.rating), 10);\n        this.rating = newRating;\n        return newRating;\n      })(),\n      (error) => new UnexpectedError(`Failed to cancel vote: ${String(error)}`)\n    );\n  }\n\n  /**\n   * ページを編集する\n   * @param options - 編集オプション\n   */\n  @RequireLogin\n  edit(options: {\n    title?: string;\n    source?: string;\n    comment?: string;\n    forceEdit?: boolean;\n  }): WikidotResultAsync<void> {\n    const idCheck = this.requireId('editing');\n    if (!idCheck.ok) return idCheck.error;\n\n    const pageId = idCheck.id;\n\n    return fromPromise(\n      (async () => {\n        // 現在のソースを取得（指定がない場合）\n        let currentSource = options.source;\n        if (currentSource === undefined) {\n          const existingSource = this._source;\n          if (existingSource !== null) {\n            currentSource = existingSource.wikiText;\n          } else {\n            // ソースを取得\n            const sourceResult = await PageCollection.acquirePageSources(this.site, [this]);\n            if (sourceResult.isErr()) {\n              throw sourceResult.error;\n            }\n            // acquirePageSources後、this._sourceにセットされる\n            currentSource = this._source?.wikiText ?? '';\n          }\n        }\n\n        const result = await PageCollection.createOrEdit(this.site, this.fullname, {\n          pageId,\n          title: options.title ?? this.title,\n          source: currentSource,\n          comment: options.comment ?? '',\n          forceEdit: options.forceEdit ?? false,\n        });\n        if (result.isErr()) {\n          throw result.error;\n        }\n      })(),\n      (error) => {\n        if (error instanceof LoginRequiredError || error instanceof ForbiddenError) {\n          return error;\n        }\n        return new UnexpectedError(`Failed to edit page: ${String(error)}`);\n      }\n    );\n  }\n\n  /**\n   * ページ名を変更する\n   * @param newFullname - 新しいフルネーム\n   */\n  @RequireLogin\n  rename(newFullname: string): WikidotResultAsync<void> {\n    const idCheck = this.requireId('renaming');\n    if (!idCheck.ok) return idCheck.error;\n\n    return fromPromise(\n      (async () => {\n        const result = await this.site.amcRequest([\n          {\n            action: 'WikiPageAction',\n            event: 'renamePage',\n            moduleName: 'Empty',\n            page_id: this._id,\n            new_name: newFullname,\n          },\n        ]);\n        if (result.isErr()) {\n          throw result.error;\n        }\n        // プロパティを更新（readonlyなのでObject.assignで）\n        Object.assign(this, {\n          fullname: newFullname,\n          category: newFullname.includes(':') ? newFullname.split(':')[0] : '_default',\n          name: newFullname.includes(':') ? newFullname.split(':')[1] : newFullname,\n        });\n      })(),\n      (error) => new UnexpectedError(`Failed to rename page: ${String(error)}`)\n    );\n  }\n\n  /**\n   * ページに添付されたファイル一覧を取得する\n   */\n  getFiles(): WikidotResultAsync<PageFileCollection> {\n    return PageFileCollection.acquire(this);\n  }\n\n  /**\n   * ページのディスカッションスレッドを取得する\n   */\n  getDiscussion(): WikidotResultAsync<import('../forum').ForumThread | null> {\n    const idCheck = this.requireId('getting discussion');\n    if (!idCheck.ok) return idCheck.error;\n\n    const pageId = idCheck.id;\n\n    return fromPromise(\n      (async () => {\n        const result = await this.site.amcRequest([\n          {\n            moduleName: 'forum/ForumCommentsListModule',\n            pageId,\n          },\n        ]);\n\n        if (result.isErr()) {\n          throw result.error;\n        }\n\n        const response = result.value[0];\n        if (!response) {\n          return null;\n        }\n\n        const html = String(response.body ?? '');\n        // スレッドIDを抽出\n        const match = html.match(\n          /WIKIDOT\\.modules\\.ForumViewThreadModule\\.vars\\.threadId\\s*=\\s*(\\d+)/\n        );\n        if (!match?.[1]) {\n          return null;\n        }\n\n        const threadId = Number.parseInt(match[1], 10);\n\n        // ForumThreadを取得\n        const { ForumThread } = await import('../forum');\n        const threadResult = await ForumThread.getFromId(this.site, threadId);\n        if (threadResult.isErr()) {\n          throw threadResult.error;\n        }\n        return threadResult.value;\n      })(),\n      (error) => new UnexpectedError(`Failed to get discussion: ${String(error)}`)\n    );\n  }\n\n  /**\n   * ページのメタタグ一覧を取得する\n   * @returns メタタグコレクション\n   */\n  getMetas(): WikidotResultAsync<PageMetaCollection> {\n    const idCheck = this.requireId('getting metas');\n    if (!idCheck.ok) {\n      return idCheck.error;\n    }\n\n    return PageMetaCollection.acquire(this);\n  }\n\n  /**\n   * メタタグを設定する\n   * @param name - メタタグ名\n   * @param content - メタタグの値\n   */\n  setMeta(name: string, content: string): WikidotResultAsync<void> {\n    const idCheck = this.requireId('setting meta');\n    if (!idCheck.ok) {\n      return idCheck.error;\n    }\n\n    return PageMetaCollection.setMeta(this, name, content);\n  }\n\n  /**\n   * メタタグを削除する\n   * @param name - メタタグ名\n   */\n  deleteMeta(name: string): WikidotResultAsync<void> {\n    const idCheck = this.requireId('deleting meta');\n    if (!idCheck.ok) {\n      return idCheck.error;\n    }\n\n    return PageMetaCollection.deleteMeta(this, name);\n  }\n\n  toString(): string {\n    return `Page(fullname=${this.fullname}, title=${this.title})`;\n  }\n}\n\n/**\n * ページコレクション\n */\nexport class PageCollection extends Array<Page> {\n  public readonly site: Site;\n\n  constructor(site: Site, pages?: Page[]) {\n    super();\n    this.site = site;\n    if (pages) {\n      this.push(...pages);\n    }\n  }\n\n  /**\n   * フルネームで検索\n   * @param fullname - ページのフルネーム\n   * @returns ページ（存在しない場合はundefined）\n   */\n  findByFullname(fullname: string): Page | undefined {\n    return this.find((page) => page.fullname === fullname);\n  }\n\n  /**\n   * ページIDを一括取得\n   */\n  getPageIds(): WikidotResultAsync<PageCollection> {\n    return PageCollection.acquirePageIds(this.site, this);\n  }\n\n  /**\n   * ページソースを一括取得\n   */\n  getPageSources(): WikidotResultAsync<PageCollection> {\n    return PageCollection.acquirePageSources(this.site, this);\n  }\n\n  /**\n   * ページリビジョンを一括取得\n   */\n  getPageRevisions(): WikidotResultAsync<PageCollection> {\n    return PageCollection.acquirePageRevisions(this.site, this);\n  }\n\n  /**\n   * ページ投票を一括取得\n   */\n  getPageVotes(): WikidotResultAsync<PageCollection> {\n    return PageCollection.acquirePageVotes(this.site, this);\n  }\n\n  /**\n   * ページIDを一括取得する内部メソッド\n   */\n  static acquirePageIds(site: Site, pages: Page[]): WikidotResultAsync<PageCollection> {\n    return fromPromise(\n      (async () => {\n        const targetPages = pages.filter((page) => !page.isIdAcquired());\n\n        if (targetPages.length === 0) {\n          return new PageCollection(site, pages);\n        }\n\n        // norender, noredirectでアクセス\n        const responses = await Promise.all(\n          targetPages.map(async (page) => {\n            const url = `${page.getUrl()}/norender/true/noredirect/true`;\n            const response = await fetch(url, {\n              headers: site.client.amcClient.header.getHeaders(),\n            });\n            return { page, response };\n          })\n        );\n\n        for (const { page, response } of responses) {\n          const text = await response.text();\n          const match = text.match(/WIKIREQUEST\\.info\\.pageId\\s*=\\s*(\\d+);/);\n          if (!match?.[1]) {\n            throw new NoElementError(`Cannot find page id: ${page.fullname}`);\n          }\n          page.id = Number.parseInt(match[1], 10);\n        }\n\n        return new PageCollection(site, pages);\n      })(),\n      (error) => {\n        if (error instanceof NoElementError) return error;\n        return new UnexpectedError(`Failed to acquire page IDs: ${String(error)}`);\n      }\n    );\n  }\n\n  /**\n   * ページソースを一括取得する内部メソッド\n   */\n  static acquirePageSources(site: Site, pages: Page[]): WikidotResultAsync<PageCollection> {\n    return fromPromise(\n      (async () => {\n        const targetPages = pages.filter((page) => page.source === null && page.id !== null);\n\n        if (targetPages.length === 0) {\n          return new PageCollection(site, pages);\n        }\n\n        const result = await site.amcRequest(\n          targetPages.map((page) => ({\n            moduleName: 'viewsource/ViewSourceModule',\n            page_id: page.id,\n          }))\n        );\n\n        if (result.isErr()) {\n          throw result.error;\n        }\n\n        for (let i = 0; i < targetPages.length; i++) {\n          const page = targetPages[i];\n          const response = result.value[i];\n          if (!page || !response) continue;\n          const body = String(response.body ?? '').replace(/&nbsp;/g, ' ');\n          const $ = cheerio.load(body);\n          const sourceElement = $('div.page-source');\n          if (sourceElement.length === 0) {\n            throw new NoElementError(`Cannot find source element for page: ${page.fullname}`);\n          }\n          const wikiText = sourceElement.text().trim().replace(/^\\t/, '');\n          page.source = new PageSource({ page, wikiText });\n        }\n\n        return new PageCollection(site, pages);\n      })(),\n      (error) => {\n        if (error instanceof NoElementError) return error;\n        return new UnexpectedError(`Failed to acquire page sources: ${String(error)}`);\n      }\n    );\n  }\n\n  /**\n   * ページリビジョンを一括取得する内部メソッド\n   */\n  static acquirePageRevisions(site: Site, pages: Page[]): WikidotResultAsync<PageCollection> {\n    return fromPromise(\n      (async () => {\n        const targetPages = pages.filter((page) => page.revisions === null && page.id !== null);\n\n        if (targetPages.length === 0) {\n          return new PageCollection(site, pages);\n        }\n\n        const result = await site.amcRequest(\n          targetPages.map((page) => ({\n            moduleName: 'history/PageRevisionListModule',\n            page_id: page.id,\n            options: { all: true },\n            perpage: 100000000,\n          }))\n        );\n\n        if (result.isErr()) {\n          throw result.error;\n        }\n\n        // リビジョンをパース\n        const { PageRevision } = await import('./page-revision');\n        for (let i = 0; i < targetPages.length; i++) {\n          const page = targetPages[i];\n          const response = result.value[i];\n          if (!page || !response) continue;\n\n          const body = String(response.body ?? '');\n          const $ = cheerio.load(body);\n          const revisions: PageRevision[] = [];\n\n          $('table.page-history > tr[id^=revision-row-]').each((_j, revElement) => {\n            const $rev = $(revElement);\n            const revIdAttr = $rev.attr('id');\n            if (!revIdAttr) return;\n\n            const revId = Number.parseInt(revIdAttr.replace('revision-row-', ''), 10);\n            if (Number.isNaN(revId)) return;\n\n            const $tds = $rev.find('td');\n            if ($tds.length < 7) return;\n\n            const revNoText = $tds.eq(0).text().trim().replace(/\\.$/, '');\n            const revNo = Number.parseInt(revNoText, 10);\n            if (Number.isNaN(revNo)) return;\n\n            const $createdByElem = $tds.eq(4).find('span.printuser');\n            if ($createdByElem.length === 0) return;\n            const createdBy = parseUser(site.client, $createdByElem as Cheerio<AnyNode>);\n\n            const $createdAtElem = $tds.eq(5).find('span.odate');\n            if ($createdAtElem.length === 0) return;\n            const createdAt = parseOdate($createdAtElem as Cheerio<AnyNode>) ?? new Date();\n\n            const comment = $tds.eq(6).text().trim();\n\n            revisions.push(\n              new PageRevision({\n                page,\n                id: revId,\n                revNo,\n                createdBy,\n                createdAt,\n                comment,\n              })\n            );\n          });\n\n          page.revisions = new PageRevisionCollection(page, revisions);\n        }\n\n        return new PageCollection(site, pages);\n      })(),\n      (error) => new UnexpectedError(`Failed to acquire page revisions: ${String(error)}`)\n    );\n  }\n\n  /**\n   * ページ投票を一括取得する内部メソッド\n   */\n  static acquirePageVotes(site: Site, pages: Page[]): WikidotResultAsync<PageCollection> {\n    return fromPromise(\n      (async () => {\n        const targetPages = pages.filter((page) => page.votes === null && page.id !== null);\n\n        if (targetPages.length === 0) {\n          return new PageCollection(site, pages);\n        }\n\n        const result = await site.amcRequest(\n          targetPages.map((page) => ({\n            moduleName: 'pagerate/WhoRatedPageModule',\n            pageId: page.id,\n          }))\n        );\n\n        if (result.isErr()) {\n          throw result.error;\n        }\n\n        // 投票をパース\n        for (let i = 0; i < targetPages.length; i++) {\n          const page = targetPages[i];\n          const response = result.value[i];\n          if (!page || !response) continue;\n\n          const body = String(response.body ?? '');\n          const $ = cheerio.load(body);\n\n          const $userElems = $('span.printuser');\n          const $valueElems = $(\"span[style^='color']\");\n\n          if ($userElems.length !== $valueElems.length) {\n            throw new UnexpectedError('User and value count mismatch in votes');\n          }\n\n          const votes: PageVote[] = [];\n          $userElems.each((j, userElem) => {\n            const $user = $(userElem);\n            const $value = $valueElems.eq(j);\n\n            const user = parseUser(site.client, $user as Cheerio<AnyNode>);\n            const valueText = $value.text().trim();\n\n            let value: number;\n            if (valueText === '+') {\n              value = 1;\n            } else if (valueText === '-') {\n              value = -1;\n            } else {\n              value = Number.parseInt(valueText, 10) || 0;\n            }\n\n            votes.push(new PageVote({ page, user, value }));\n          });\n\n          page.votes = new PageVoteCollection(page, votes);\n        }\n\n        return new PageCollection(site, pages);\n      })(),\n      (error) => new UnexpectedError(`Failed to acquire page votes: ${String(error)}`)\n    );\n  }\n\n  /**\n   * ListPagesModuleレスポンスをパース\n   */\n  static parse(\n    site: Site,\n    htmlBody: cheerio.CheerioAPI,\n    _parseUser: (element: cheerio.Cheerio<AnyNode>) => AbstractUser\n  ): PageCollection {\n    const pages: Page[] = [];\n\n    htmlBody('div.page').each((_i, pageElement) => {\n      const $page = htmlBody(pageElement);\n      const pageParams: Record<string, unknown> = {};\n\n      // 5つ星レーティング判定\n      const is5StarRating = $page.find('span.rating span.page-rate-list-pages-start').length > 0;\n\n      // 各値を取得\n      $page.find('span.set').each((_j, setElement) => {\n        const $set = htmlBody(setElement);\n        const keyElement = $set.find('span.name');\n        if (keyElement.length === 0) return;\n\n        let key = keyElement.text().trim();\n        const valueElement = $set.find('span.value');\n\n        let value: unknown = null;\n\n        if (valueElement.length === 0) {\n          value = null;\n        } else if (['created_at', 'updated_at', 'commented_at'].includes(key)) {\n          const odateElement = valueElement.find('span.odate');\n          if (odateElement.length > 0) {\n            const timestamp = odateElement.attr('class')?.match(/time_(\\d+)/)?.[1];\n            value = timestamp ? new Date(Number.parseInt(timestamp, 10) * 1000) : null;\n          }\n        } else if (\n          ['created_by_linked', 'updated_by_linked', 'commented_by_linked'].includes(key)\n        ) {\n          const printuserElement = valueElement.find('span.printuser');\n          if (printuserElement.length > 0) {\n            value = _parseUser(printuserElement);\n          }\n        } else if (['tags', '_tags'].includes(key)) {\n          value = valueElement.text().split(/\\s+/).filter(Boolean);\n        } else if (['rating_votes', 'comments', 'size', 'revisions'].includes(key)) {\n          value = Number.parseInt(valueElement.text().trim(), 10) || 0;\n        } else if (key === 'rating') {\n          const ratingText = valueElement.text().trim();\n          value = is5StarRating\n            ? Number.parseFloat(ratingText) || 0\n            : Number.parseInt(ratingText, 10) || 0;\n        } else if (key === 'rating_percent') {\n          if (is5StarRating) {\n            value = (Number.parseFloat(valueElement.text().trim()) || 0) / 100;\n          } else {\n            value = null;\n          }\n        } else {\n          value = valueElement.text().trim();\n        }\n\n        // キー変換\n        if (key.includes('_linked')) {\n          key = key.replace('_linked', '');\n        } else if (['comments', 'children', 'revisions'].includes(key)) {\n          key = `${key}_count`;\n        } else if (key === 'rating_votes') {\n          key = 'votes_count';\n        }\n\n        pageParams[key] = value;\n      });\n\n      // タグ統合\n      const tags = Array.isArray(pageParams.tags) ? pageParams.tags : [];\n      const hiddenTags = Array.isArray(pageParams._tags) ? pageParams._tags : [];\n      pageParams.tags = [...tags, ...hiddenTags];\n\n      // Zodスキーマで検証・デフォルト値適用\n      const parsed = pageParamsSchema.parse(pageParams);\n\n      // Pageオブジェクト作成\n      pages.push(\n        new Page({\n          site,\n          fullname: parsed.fullname,\n          name: parsed.name,\n          category: parsed.category,\n          title: parsed.title,\n          childrenCount: parsed.children_count,\n          commentsCount: parsed.comments_count,\n          size: parsed.size,\n          rating: parsed.rating,\n          votesCount: parsed.votes_count,\n          ratingPercent: parsed.rating_percent,\n          revisionsCount: parsed.revisions_count,\n          parentFullname: parsed.parent_fullname,\n          tags: parsed.tags,\n          createdBy: parsed.created_by,\n          createdAt: parsed.created_at ?? new Date(),\n          updatedBy: parsed.updated_by,\n          updatedAt: parsed.updated_at ?? new Date(),\n          commentedBy: parsed.commented_by,\n          commentedAt: parsed.commented_at,\n        })\n      );\n    });\n\n    return new PageCollection(site, pages);\n  }\n\n  /**\n   * ページ検索\n   */\n  static searchPages(\n    site: Site,\n    parseUser: (element: cheerio.Cheerio<AnyNode>) => AbstractUser,\n    query: SearchPagesQuery | null = null\n  ): WikidotResultAsync<PageCollection> {\n    return fromPromise(\n      (async () => {\n        const q = query ?? new SearchPagesQuery();\n        const queryDict = q.asDict();\n\n        // モジュールボディ生成\n        const moduleBody = `[[div class=\"page\"]]\\n${DEFAULT_MODULE_BODY.map(\n          (key) =>\n            `[[span class=\"set ${key}\"]][[span class=\"name\"]] ${key} [[/span]][[span class=\"value\"]] %%${key}%% [[/span]][[/span]]`\n        ).join('')}\\n[[/div]]`;\n\n        const requestBody = {\n          ...queryDict,\n          moduleName: 'list/ListPagesModule',\n          module_body: moduleBody,\n        };\n\n        const result = await site.amcRequest([requestBody]);\n        if (result.isErr()) {\n          if (result.error.message.includes('not_ok')) {\n            throw new ForbiddenError('Failed to get pages, target site may be private');\n          }\n          throw result.error;\n        }\n\n        const firstResponse = result.value[0];\n        const body = String(firstResponse?.body ?? '');\n        const $first = cheerio.load(body);\n\n        let total = 1;\n        const htmlBodies: cheerio.CheerioAPI[] = [$first];\n\n        // ページネーション確認\n        const pagerElement = $first('div.pager');\n        if (pagerElement.length > 0) {\n          const lastPagerElements = $first('div.pager span.target');\n          if (lastPagerElements.length >= 2) {\n            const secondLastPager = $first(lastPagerElements[lastPagerElements.length - 2]);\n            const lastPagerLink = secondLastPager.find('a');\n            if (lastPagerLink.length > 0) {\n              total = Number.parseInt(lastPagerLink.text().trim(), 10) || 1;\n            }\n          }\n        }\n\n        // 追加ページ取得\n        if (total > 1) {\n          const additionalBodies: AMCRequestBody[] = [];\n          for (let i = 1; i < total; i++) {\n            additionalBodies.push({\n              ...queryDict,\n              moduleName: 'list/ListPagesModule',\n              module_body: moduleBody,\n              offset: i * (q.perPage ?? DEFAULT_PER_PAGE),\n            } as AMCRequestBody);\n          }\n\n          const additionalResults = await site.amcRequest(additionalBodies);\n          if (additionalResults.isErr()) {\n            throw additionalResults.error;\n          }\n\n          for (const response of additionalResults.value) {\n            const respBody = String(response?.body ?? '');\n            htmlBodies.push(cheerio.load(respBody));\n          }\n        }\n\n        // パース\n        const pages: Page[] = [];\n        for (const $html of htmlBodies) {\n          const parsed = PageCollection.parse(site, $html, parseUser);\n          pages.push(...parsed);\n        }\n\n        return new PageCollection(site, pages);\n      })(),\n      (error) => {\n        if (error instanceof ForbiddenError || error instanceof NotFoundException) {\n          return error;\n        }\n        return new UnexpectedError(`Failed to search pages: ${String(error)}`);\n      }\n    );\n  }\n\n  /**\n   * ページを作成または編集\n   */\n  static createOrEdit(\n    site: Site,\n    fullname: string,\n    options: {\n      pageId?: number | null;\n      title?: string;\n      source?: string;\n      comment?: string;\n      forceEdit?: boolean;\n      raiseOnExists?: boolean;\n    } = {}\n  ): WikidotResultAsync<void> {\n    const loginResult = site.client.requireLogin();\n    if (loginResult.isErr()) {\n      return fromPromise(\n        Promise.reject(loginResult.error),\n        () => new LoginRequiredError('Login required to create/edit page')\n      );\n    }\n\n    return fromPromise(\n      (async () => {\n        const {\n          pageId = null,\n          title = '',\n          source = '',\n          comment = '',\n          forceEdit = false,\n          raiseOnExists = false,\n        } = options;\n\n        // ページロック取得\n        const lockRequestBody: AMCRequestBody = {\n          mode: 'page',\n          wiki_page: fullname,\n          moduleName: 'edit/PageEditModule',\n        };\n        if (forceEdit) {\n          lockRequestBody.force_lock = 'yes';\n        }\n\n        const lockResult = await site.amcRequest([lockRequestBody]);\n        if (lockResult.isErr()) {\n          throw lockResult.error;\n        }\n\n        const lockResponse = lockResult.value[0];\n        if (lockResponse?.locked || lockResponse?.other_locks) {\n          throw new UnexpectedError(`Page ${fullname} is locked or other locks exist`);\n        }\n\n        const isExist = 'page_revision_id' in (lockResponse ?? {});\n\n        if (raiseOnExists && isExist) {\n          throw new TargetExistsError(`Page ${fullname} already exists`);\n        }\n\n        if (isExist && pageId === null) {\n          throw new UnexpectedError('page_id must be specified when editing existing page');\n        }\n\n        const lockId = String(lockResponse?.lock_id ?? '');\n        const lockSecret = String(lockResponse?.lock_secret ?? '');\n        const pageRevisionId = String(lockResponse?.page_revision_id ?? '');\n\n        // ページ保存\n        const editRequestBody: AMCRequestBody = {\n          action: 'WikiPageAction',\n          event: 'savePage',\n          moduleName: 'Empty',\n          mode: 'page',\n          lock_id: lockId,\n          lock_secret: lockSecret,\n          revision_id: pageRevisionId,\n          wiki_page: fullname,\n          page_id: pageId ?? '',\n          title,\n          source,\n          comments: comment,\n        };\n\n        const editResult = await site.amcRequest([editRequestBody]);\n        if (editResult.isErr()) {\n          throw editResult.error;\n        }\n      })(),\n      (error) => {\n        if (error instanceof TargetExistsError || error instanceof LoginRequiredError) {\n          return error;\n        }\n        return new UnexpectedError(`Failed to create/edit page: ${String(error)}`);\n      }\n    );\n  }\n}\n\nexport { SearchPagesQuery };\n",
    "import * as cheerio from 'cheerio';\nimport { UnexpectedError } from '../../common/errors';\nimport { fromPromise, type WikidotResultAsync } from '../../common/types';\nimport type { Page } from './page';\n\n/**\n * ページファイルデータ\n */\nexport interface PageFileData {\n  page: Page;\n  id: number;\n  name: string;\n  url: string;\n  mimeType: string;\n  size: number;\n}\n\n/**\n * ページ添付ファイル\n */\nexport class PageFile {\n  public readonly page: Page;\n  public readonly id: number;\n  public readonly name: string;\n  public readonly url: string;\n  public readonly mimeType: string;\n  public readonly size: number;\n\n  constructor(data: PageFileData) {\n    this.page = data.page;\n    this.id = data.id;\n    this.name = data.name;\n    this.url = data.url;\n    this.mimeType = data.mimeType;\n    this.size = data.size;\n  }\n\n  toString(): string {\n    return `PageFile(id=${this.id}, name=${this.name}, size=${this.size})`;\n  }\n}\n\n/**\n * ページファイルコレクション\n */\nexport class PageFileCollection extends Array<PageFile> {\n  public readonly page: Page;\n\n  constructor(page: Page, files?: PageFile[]) {\n    super();\n    this.page = page;\n    if (files) {\n      this.push(...files);\n    }\n  }\n\n  /**\n   * IDで検索\n   */\n  findById(id: number): PageFile | undefined {\n    return this.find((file) => file.id === id);\n  }\n\n  /**\n   * 名前で検索\n   */\n  findByName(name: string): PageFile | undefined {\n    return this.find((file) => file.name === name);\n  }\n\n  /**\n   * サイズ文字列をバイト数に変換\n   */\n  private static parseSize(sizeText: string): number {\n    const text = sizeText.trim();\n    if (text.includes('Bytes')) {\n      return Math.floor(Number.parseFloat(text.replace('Bytes', '').trim()));\n    }\n    if (text.includes('kB')) {\n      return Math.floor(Number.parseFloat(text.replace('kB', '').trim()) * 1000);\n    }\n    if (text.includes('MB')) {\n      return Math.floor(Number.parseFloat(text.replace('MB', '').trim()) * 1000000);\n    }\n    if (text.includes('GB')) {\n      return Math.floor(Number.parseFloat(text.replace('GB', '').trim()) * 1000000000);\n    }\n    return 0;\n  }\n\n  /**\n   * ページに添付されたファイル一覧を取得する\n   */\n  static acquire(page: Page): WikidotResultAsync<PageFileCollection> {\n    if (page.id === null) {\n      return fromPromise(\n        Promise.reject(new Error('Page ID not acquired')),\n        () => new UnexpectedError('Page ID must be acquired before getting files')\n      );\n    }\n\n    const pageId = page.id;\n\n    return fromPromise(\n      (async () => {\n        const result = await page.site.amcRequest([\n          {\n            moduleName: 'files/PageFilesModule',\n            page_id: pageId,\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 UnexpectedError('Empty response');\n        }\n\n        const html = String(response.body ?? '');\n        const $ = cheerio.load(html);\n\n        const filesTable = $('table.page-files');\n        if (filesTable.length === 0) {\n          return new PageFileCollection(page, []);\n        }\n\n        const files: PageFile[] = [];\n\n        filesTable.find(\"tbody tr[id^='file-row-']\").each((_i, row) => {\n          const rowId = $(row).attr('id');\n          if (!rowId) return;\n\n          const fileId = Number.parseInt(rowId.replace('file-row-', ''), 10);\n          const tds = $(row).find('td');\n          if (tds.length < 3) return;\n\n          const linkElem = $(tds[0]).find('a');\n          if (linkElem.length === 0) return;\n\n          const name = linkElem.text().trim();\n          const href = linkElem.attr('href') ?? '';\n          const url = `${page.site.getBaseUrl()}${href}`;\n\n          const mimeElem = $(tds[1]).find('span');\n          const mimeType = mimeElem.attr('title') ?? '';\n\n          const sizeText = $(tds[2]).text().trim();\n          const size = PageFileCollection.parseSize(sizeText);\n\n          files.push(\n            new PageFile({\n              page,\n              id: fileId,\n              name,\n              url,\n              mimeType,\n              size,\n            })\n          );\n        });\n\n        return new PageFileCollection(page, files);\n      })(),\n      (error) => new UnexpectedError(`Failed to acquire files: ${String(error)}`)\n    );\n  }\n}\n",
    "import * as cheerio from 'cheerio';\nimport { LoginRequiredError, NoElementError, UnexpectedError } from '../../common/errors';\nimport { fromPromise, type WikidotResultAsync } from '../../common/types';\nimport type { PageRef } from '../types';\n\n/**\n * ページメタタグデータ\n */\nexport interface PageMetaData {\n  page: PageRef;\n  name: string;\n  content: string;\n}\n\n/**\n * ページメタタグ\n */\nexport class PageMeta {\n  public readonly page: PageRef;\n  public readonly name: string;\n  public content: string;\n\n  constructor(data: PageMetaData) {\n    this.page = data.page;\n    this.name = data.name;\n    this.content = data.content;\n  }\n\n  /**\n   * メタタグの値を更新する\n   * @param content - 新しい値\n   */\n  update(content: string): WikidotResultAsync<void> {\n    return PageMetaCollection.setMeta(this.page, this.name, content);\n  }\n\n  /**\n   * メタタグを削除する\n   */\n  delete(): WikidotResultAsync<void> {\n    return PageMetaCollection.deleteMeta(this.page, this.name);\n  }\n\n  toString(): string {\n    return `PageMeta(name=${this.name}, content=${this.content})`;\n  }\n}\n\n/**\n * ページメタタグコレクション\n */\nexport class PageMetaCollection extends Array<PageMeta> {\n  public readonly page: PageRef;\n\n  constructor(page: PageRef, metas?: PageMeta[]) {\n    super();\n    this.page = page;\n    if (metas) {\n      this.push(...metas);\n    }\n  }\n\n  /**\n   * 名前で検索\n   * @param name - メタタグ名\n   * @returns メタタグ（存在しない場合はundefined）\n   */\n  findByName(name: string): PageMeta | undefined {\n    return this.find((meta) => meta.name === name);\n  }\n\n  /**\n   * ページのメタタグを取得する\n   * @param page - ページ参照\n   * @returns メタタグコレクション\n   */\n  static acquire(page: PageRef): WikidotResultAsync<PageMetaCollection> {\n    return fromPromise(\n      (async () => {\n        const result = await page.site.amcRequest([\n          {\n            moduleName: 'edit/EditMetaModule',\n            page_id: page.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 html = String(response.body ?? '');\n        const $ = cheerio.load(html);\n        const metas: PageMeta[] = [];\n\n        // メタタグテーブルをパース\n        $('table.meta-table tr').each((_i, elem) => {\n          const $row = $(elem);\n          const $cells = $row.find('td');\n          if ($cells.length < 2) return;\n\n          const name = $($cells[0]).text().trim();\n          const content = $($cells[1]).text().trim();\n\n          if (name) {\n            metas.push(\n              new PageMeta({\n                page,\n                name,\n                content,\n              })\n            );\n          }\n        });\n\n        return new PageMetaCollection(page, metas);\n      })(),\n      (error) => {\n        if (error instanceof NoElementError) {\n          return error;\n        }\n        return new UnexpectedError(`Failed to acquire page metas: ${String(error)}`);\n      }\n    );\n  }\n\n  /**\n   * メタタグを設定する\n   * @param page - ページ参照\n   * @param name - メタタグ名\n   * @param content - メタタグの値\n   */\n  static setMeta(page: PageRef, name: string, content: string): WikidotResultAsync<void> {\n    const loginResult = page.site.client.requireLogin();\n    if (loginResult.isErr()) {\n      return fromPromise(\n        Promise.reject(loginResult.error),\n        () => new LoginRequiredError('Login required to set meta tag')\n      );\n    }\n\n    return fromPromise(\n      (async () => {\n        const result = await page.site.amcRequest([\n          {\n            action: 'WikiPageAction',\n            event: 'saveMetaTag',\n            moduleName: 'Empty',\n            page_id: page.id,\n            meta_name: name,\n            meta_content: content,\n          },\n        ]);\n\n        if (result.isErr()) {\n          throw result.error;\n        }\n      })(),\n      (error) => {\n        if (error instanceof LoginRequiredError) {\n          return error;\n        }\n        return new UnexpectedError(`Failed to set meta tag: ${String(error)}`);\n      }\n    );\n  }\n\n  /**\n   * メタタグを削除する\n   * @param page - ページ参照\n   * @param name - メタタグ名\n   */\n  static deleteMeta(page: PageRef, name: string): WikidotResultAsync<void> {\n    const loginResult = page.site.client.requireLogin();\n    if (loginResult.isErr()) {\n      return fromPromise(\n        Promise.reject(loginResult.error),\n        () => new LoginRequiredError('Login required to delete meta tag')\n      );\n    }\n\n    return fromPromise(\n      (async () => {\n        const result = await page.site.amcRequest([\n          {\n            action: 'WikiPageAction',\n            event: 'deleteMetaTag',\n            moduleName: 'Empty',\n            page_id: page.id,\n            meta_name: name,\n          },\n        ]);\n\n        if (result.isErr()) {\n          throw result.error;\n        }\n      })(),\n      (error) => {\n        if (error instanceof LoginRequiredError) {\n          return error;\n        }\n        return new UnexpectedError(`Failed to delete meta tag: ${String(error)}`);\n      }\n    );\n  }\n}\n",
    "import type { Page } from './page';\n\n/**\n * ページソースデータ\n */\nexport interface PageSourceData {\n  page: Page;\n  wikiText: string;\n}\n\n/**\n * ページのソースコード（Wikidot記法）\n */\nexport class PageSource {\n  /** ソースが属するページ */\n  public readonly page: Page;\n\n  /** ソースコード（Wikidot記法） */\n  public readonly wikiText: string;\n\n  constructor(data: PageSourceData) {\n    this.page = data.page;\n    this.wikiText = data.wikiText;\n  }\n\n  toString(): string {\n    return `PageSource(page=${this.page.fullname}, length=${this.wikiText.length})`;\n  }\n}\n",
    "import type { AbstractUser } from '../user';\nimport type { Page } from './page';\n\n/**\n * ページ投票データ\n */\nexport interface PageVoteData {\n  page: Page;\n  user: AbstractUser;\n  value: number;\n}\n\n/**\n * ページへの投票（レーティング）\n */\nexport class PageVote {\n  /** 投票が属するページ */\n  public readonly page: Page;\n\n  /** 投票したユーザー */\n  public readonly user: AbstractUser;\n\n  /** 投票値（+1/-1 または 数値） */\n  public readonly value: number;\n\n  constructor(data: PageVoteData) {\n    this.page = data.page;\n    this.user = data.user;\n    this.value = data.value;\n  }\n\n  toString(): string {\n    return `PageVote(user=${this.user.name}, value=${this.value})`;\n  }\n}\n\n/**\n * ページ投票コレクション\n */\nexport class PageVoteCollection extends Array<PageVote> {\n  public readonly page: Page;\n\n  constructor(page: Page, votes?: PageVote[]) {\n    super();\n    this.page = page;\n    if (votes) {\n      this.push(...votes);\n    }\n  }\n\n  /**\n   * ユーザーで検索\n   * @param user - 検索するユーザー\n   * @returns 投票（存在しない場合はundefined）\n   */\n  findByUser(user: AbstractUser): PageVote | undefined {\n    return this.find((vote) => vote.user.id === user.id);\n  }\n}\n",
    "import type { AbstractUser } from '../user';\n\n/**\n * ページ検索クエリのパラメータ\n */\nexport interface SearchPagesQueryParams {\n  /** ページタイプ（例: 'normal', 'admin'） */\n  pagetype?: string;\n  /** カテゴリ名 */\n  category?: string;\n  /** 検索対象タグ（AND条件） */\n  tags?: string | string[];\n  /** 親ページ名 */\n  parent?: string;\n  /** リンク先ページ名 */\n  linkTo?: string;\n  /** 作成日時条件 */\n  createdAt?: string;\n  /** 更新日時条件 */\n  updatedAt?: string;\n  /** 作成者 */\n  createdBy?: AbstractUser | string;\n  /** レーティング条件 */\n  rating?: string;\n  /** 投票数条件 */\n  votes?: string;\n  /** ページ名条件 */\n  name?: string;\n  /** フルネーム（完全一致） */\n  fullname?: string;\n  /** 範囲指定 */\n  range?: string;\n  /** ソート順（例: 'created_at desc'） */\n  order?: string;\n  /** 取得開始位置 */\n  offset?: number;\n  /** 取得件数制限 */\n  limit?: number;\n  /** 1ページあたり件数 */\n  perPage?: number;\n  /** 個別表示 */\n  separate?: string;\n  /** ラッパー表示 */\n  wrapper?: string;\n}\n\n/**\n * デフォルトの1ページあたり件数\n */\nexport const DEFAULT_PER_PAGE = 250;\n\n/**\n * デフォルトのモジュールボディフィールド\n */\nexport const DEFAULT_MODULE_BODY = [\n  'fullname',\n  'category',\n  'name',\n  'title',\n  'created_at',\n  'created_by_linked',\n  'updated_at',\n  'updated_by_linked',\n  'commented_at',\n  'commented_by_linked',\n  'parent_fullname',\n  'comments',\n  'size',\n  'children',\n  'rating_votes',\n  'rating',\n  'rating_percent',\n  'revisions',\n  'tags',\n  '_tags',\n] as const;\n\n/**\n * ページ検索クエリ\n */\nexport class SearchPagesQuery {\n  /** ページタイプ */\n  pagetype: string;\n  /** カテゴリ */\n  category: string;\n  /** タグ */\n  tags: string | string[] | null;\n  /** 親ページ */\n  parent: string | null;\n  /** リンク先 */\n  linkTo: string | null;\n  /** 作成日時条件 */\n  createdAt: string | null;\n  /** 更新日時条件 */\n  updatedAt: string | null;\n  /** 作成者 */\n  createdBy: AbstractUser | string | null;\n  /** レーティング条件 */\n  rating: string | null;\n  /** 投票数条件 */\n  votes: string | null;\n  /** ページ名条件 */\n  name: string | null;\n  /** フルネーム条件 */\n  fullname: string | null;\n  /** 範囲 */\n  range: string | null;\n  /** ソート順 */\n  order: string;\n  /** オフセット */\n  offset: number;\n  /** 取得件数制限 */\n  limit: number | null;\n  /** 1ページあたり件数 */\n  perPage: number;\n  /** 個別表示 */\n  separate: string;\n  /** ラッパー表示 */\n  wrapper: string;\n\n  constructor(params: SearchPagesQueryParams = {}) {\n    this.pagetype = params.pagetype ?? '*';\n    this.category = params.category ?? '*';\n    this.tags = params.tags ?? null;\n    this.parent = params.parent ?? null;\n    this.linkTo = params.linkTo ?? null;\n    this.createdAt = params.createdAt ?? null;\n    this.updatedAt = params.updatedAt ?? null;\n    this.createdBy = params.createdBy ?? null;\n    this.rating = params.rating ?? null;\n    this.votes = params.votes ?? null;\n    this.name = params.name ?? null;\n    this.fullname = params.fullname ?? null;\n    this.range = params.range ?? null;\n    this.order = params.order ?? 'created_at desc';\n    this.offset = params.offset ?? 0;\n    this.limit = params.limit ?? null;\n    this.perPage = params.perPage ?? DEFAULT_PER_PAGE;\n    this.separate = params.separate ?? 'no';\n    this.wrapper = params.wrapper ?? 'no';\n  }\n\n  /**\n   * 辞書形式に変換\n   */\n  asDict(): Record<string, unknown> {\n    const result: Record<string, unknown> = {};\n\n    if (this.pagetype !== '*') result.pagetype = this.pagetype;\n    if (this.category !== '*') result.category = this.category;\n    if (this.tags !== null) {\n      result.tags = Array.isArray(this.tags) ? this.tags.join(' ') : this.tags;\n    }\n    if (this.parent !== null) result.parent = this.parent;\n    if (this.linkTo !== null) result.link_to = this.linkTo;\n    if (this.createdAt !== null) result.created_at = this.createdAt;\n    if (this.updatedAt !== null) result.updated_at = this.updatedAt;\n    if (this.createdBy !== null) {\n      result.created_by = typeof this.createdBy === 'string' ? this.createdBy : this.createdBy.name;\n    }\n    if (this.rating !== null) result.rating = this.rating;\n    if (this.votes !== null) result.votes = this.votes;\n    if (this.name !== null) result.name = this.name;\n    if (this.fullname !== null) result.fullname = this.fullname;\n    if (this.range !== null) result.range = this.range;\n\n    result.order = this.order;\n    result.offset = this.offset;\n    if (this.limit !== null) result.limit = this.limit;\n    result.perPage = this.perPage;\n    result.separate = this.separate;\n    result.wrapper = this.wrapper;\n\n    return result;\n  }\n}\n",
    "import * as cheerio from 'cheerio';\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';\n\n/**\n * サイト変更履歴データ\n */\nexport interface SiteChangeData {\n  site: Site;\n  pageFullname: string;\n  pageTitle: string;\n  revisionNo: number;\n  changedBy: AbstractUser | null;\n  changedAt: Date | null;\n  flags: string[];\n  comment: string;\n}\n\n/**\n * サイト変更履歴\n */\nexport class SiteChange {\n  public readonly site: Site;\n  public readonly pageFullname: string;\n  public readonly pageTitle: string;\n  public readonly revisionNo: number;\n  public readonly changedBy: AbstractUser | null;\n  public readonly changedAt: Date | null;\n  public readonly flags: string[];\n  public readonly comment: string;\n\n  constructor(data: SiteChangeData) {\n    this.site = data.site;\n    this.pageFullname = data.pageFullname;\n    this.pageTitle = data.pageTitle;\n    this.revisionNo = data.revisionNo;\n    this.changedBy = data.changedBy;\n    this.changedAt = data.changedAt;\n    this.flags = data.flags;\n    this.comment = data.comment;\n  }\n\n  /**\n   * ページURL\n   */\n  getPageUrl(): string {\n    return `${this.site.getBaseUrl()}/${this.pageFullname}`;\n  }\n\n  toString(): string {\n    return `SiteChange(page=${this.pageFullname}, rev=${this.revisionNo}, by=${this.changedBy})`;\n  }\n}\n\n/**\n * サイト変更履歴コレクション\n */\nexport class SiteChangeCollection extends Array<SiteChange> {\n  public readonly site: Site;\n\n  constructor(site: Site, changes?: SiteChange[]) {\n    super();\n    this.site = site;\n    if (changes) {\n      this.push(...changes);\n    }\n  }\n\n  /**\n   * 最近の変更履歴を取得する\n   * @param site - サイト\n   * @param options - オプション\n   * @returns 変更履歴コレクション\n   */\n  static acquire(\n    site: Site,\n    options?: { perPage?: number; page?: number; limit?: number }\n  ): WikidotResultAsync<SiteChangeCollection> {\n    const perPage = options?.perPage ?? 20;\n    const page = options?.page ?? 1;\n    const limit = options?.limit;\n\n    return fromPromise(\n      (async () => {\n        const result = await site.amcRequest([\n          {\n            moduleName: 'changes/SiteChangesListModule',\n            perpage: perPage,\n            page: page,\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 html = String(response.body ?? '');\n        const $ = cheerio.load(html);\n        const changes: SiteChange[] = [];\n\n        // テーブル行をパース\n        $('table.wiki-content-table tr').each((_i, elem) => {\n          const $row = $(elem);\n          const $cells = $row.find('td');\n          if ($cells.length < 4) return;\n\n          // ページリンク\n          const pageLink = $($cells[0]).find('a');\n          const href = pageLink.attr('href') ?? '';\n          const pageFullname = href.replace(/^\\//, '').split('/')[0] ?? '';\n          const pageTitle = pageLink.text().trim();\n\n          // リビジョン番号\n          const revText = $($cells[1]).text().trim();\n          const revMatch = revText.match(/(\\d+)/);\n          const revisionNo = revMatch?.[1] ? Number.parseInt(revMatch[1], 10) : 0;\n\n          // フラグ\n          const flagsCell = $($cells[2]);\n          const flags: string[] = [];\n          flagsCell.find('span').each((_j, flagElem) => {\n            const flagClass = $(flagElem).attr('class') ?? '';\n            if (flagClass.includes('spantip')) {\n              const title = $(flagElem).attr('title') ?? '';\n              if (title) flags.push(title);\n            }\n          });\n\n          // ユーザーと日時\n          const infoCell = $($cells[3]);\n          const userElem = infoCell.find('span.printuser');\n          const changedBy = userElem.length > 0 ? parseUser(site.client, userElem) : null;\n\n          const odateElem = infoCell.find('span.odate');\n          const changedAt = odateElem.length > 0 ? parseOdate(odateElem) : null;\n\n          // コメント\n          const commentElem = infoCell.find('span.comments');\n          const comment = commentElem\n            .text()\n            .trim()\n            .replace(/^[\"\"]|[\"\"]$/g, '');\n\n          changes.push(\n            new SiteChange({\n              site,\n              pageFullname,\n              pageTitle,\n              revisionNo,\n              changedBy,\n              changedAt,\n              flags,\n              comment,\n            })\n          );\n        });\n\n        // limitが指定されている場合は結果を制限\n        const limitedChanges = limit !== undefined ? changes.slice(0, limit) : changes;\n        return new SiteChangeCollection(site, limitedChanges);\n      })(),\n      (error) => {\n        if (error instanceof NoElementError) {\n          return error;\n        }\n        return new UnexpectedError(`Failed to acquire site changes: ${String(error)}`);\n      }\n    );\n  }\n}\n",
    "import { NoElementError, UnexpectedError } from '../../../common/errors';\nimport { fromPromise, type WikidotResultAsync } from '../../../common/types';\nimport { parseUser } from '../../../util/parser';\nimport { Page, PageCollection, SearchPagesQuery } from '../../page';\nimport type { Site } from '../site';\n\n/**\n * 単一ページ操作アクセサ\n */\nexport class PageAccessor {\n  public readonly site: Site;\n\n  constructor(site: Site) {\n    this.site = site;\n  }\n\n  /**\n   * UNIX名からページを取得する\n   * @param unixName - ページのUNIX名（例: 'scp-173'）\n   * @returns ページ（存在しない場合はnull）\n   */\n  get(unixName: string): WikidotResultAsync<Page | null> {\n    return fromPromise(\n      (async () => {\n        const query = new SearchPagesQuery({ fullname: unixName });\n        const userParser = parseUser.bind(null, this.site.client);\n\n        const result = await PageCollection.searchPages(this.site, userParser, query);\n        if (result.isErr()) {\n          throw result.error;\n        }\n\n        return result.value.length > 0 ? (result.value[0] ?? null) : null;\n      })(),\n      (error) => {\n        if (error instanceof NoElementError) return error;\n        return new UnexpectedError(`Failed to get page: ${String(error)}`);\n      }\n    );\n  }\n\n  /**\n   * ページを作成する\n   * @param fullname - ページのフルネーム（例: 'scp-173'）\n   * @param options - 作成オプション\n   * @returns void\n   */\n  create(\n    fullname: string,\n    options: {\n      title?: string;\n      source?: string;\n      comment?: string;\n      forceEdit?: boolean;\n    } = {}\n  ): WikidotResultAsync<void> {\n    return PageCollection.createOrEdit(this.site, fullname, {\n      title: options.title,\n      source: options.source,\n      comment: options.comment,\n      forceEdit: options.forceEdit,\n    });\n  }\n}\n\nexport { Page };\n",
    "import { UnexpectedError } from '../../../common/errors';\nimport { fromPromise, type WikidotResultAsync } from '../../../common/types';\nimport { parseUser } from '../../../util/parser';\nimport {\n  Page,\n  PageCollection,\n  SearchPagesQuery,\n  type SearchPagesQueryParams,\n  SiteChangeCollection,\n} from '../../page';\nimport type { Site } from '../site';\n\n/**\n * ページ一覧操作アクセサ\n */\nexport class PagesAccessor {\n  public readonly site: Site;\n\n  constructor(site: Site) {\n    this.site = site;\n  }\n\n  /**\n   * 条件に合うページを検索する\n   * @param params - 検索条件\n   * @returns ページコレクション\n   */\n  search(params?: SearchPagesQueryParams): WikidotResultAsync<PageCollection> {\n    return fromPromise(\n      (async () => {\n        const query = new SearchPagesQuery(params);\n        const userParser = parseUser.bind(null, this.site.client);\n\n        const result = await PageCollection.searchPages(this.site, userParser, query);\n        if (result.isErr()) {\n          throw result.error;\n        }\n\n        return result.value;\n      })(),\n      (error) => new UnexpectedError(`Failed to search pages: ${String(error)}`)\n    );\n  }\n\n  /**\n   * 全ページを取得する\n   * @returns ページコレクション\n   */\n  all(): WikidotResultAsync<PageCollection> {\n    return this.search({});\n  }\n\n  /**\n   * 最近の変更履歴を取得する\n   * @param options - オプション\n   * @param options.perPage - 1ページあたりの件数（デフォルト: 20）\n   * @param options.page - ページ番号（デフォルト: 1）\n   * @returns 変更履歴コレクション\n   */\n  getRecentChanges(options?: {\n    perPage?: number;\n    page?: number;\n  }): WikidotResultAsync<SiteChangeCollection> {\n    return SiteChangeCollection.acquire(this.site, options);\n  }\n}\n\nexport {\n  Page,\n  PageCollection,\n  SearchPagesQuery,\n  SiteChangeCollection,\n  type SearchPagesQueryParams,\n};\n",
    "import * as cheerio from 'cheerio';\nimport { NoElementError, NotFoundException, UnexpectedError } from '../../common/errors';\nimport { fromPromise, type WikidotResultAsync } from '../../common/types';\nimport type { AMCRequestBody, AMCResponse } from '../../connector';\nimport type { Client } from '../client/client';\nimport { ForumAccessor } from './accessors/forum-accessor';\nimport { MemberAccessor } from './accessors/member-accessor';\nimport { PageAccessor } from './accessors/page-accessor';\nimport { PagesAccessor } from './accessors/pages-accessor';\n\n/**\n * サイトデータ\n */\nexport interface SiteData {\n  id: number;\n  title: string;\n  unixName: string;\n  domain: string;\n  sslSupported: boolean;\n}\n\n/**\n * サイトクラス\n */\nexport class Site {\n  public readonly client: Client;\n\n  /** サイトID */\n  public readonly id: number;\n\n  /** サイトタイトル */\n  public readonly title: string;\n\n  /** UNIX名（例: scp-jp） */\n  public readonly unixName: string;\n\n  /** ドメイン */\n  public readonly domain: string;\n\n  /** SSL対応フラグ */\n  public readonly sslSupported: boolean;\n\n  /** ページアクセサ */\n  private _page: PageAccessor | null = null;\n\n  /** ページ一覧アクセサ */\n  private _pages: PagesAccessor | null = null;\n\n  /** フォーラムアクセサ */\n  private _forum: ForumAccessor | null = null;\n\n  /** メンバーアクセサ */\n  private _member: MemberAccessor | null = null;\n\n  constructor(client: Client, data: SiteData) {\n    this.client = client;\n    this.id = data.id;\n    this.title = data.title;\n    this.unixName = data.unixName;\n    this.domain = data.domain;\n    this.sslSupported = data.sslSupported;\n  }\n\n  /**\n   * ページアクセサを取得\n   */\n  get page(): PageAccessor {\n    if (!this._page) {\n      this._page = new PageAccessor(this);\n    }\n    return this._page;\n  }\n\n  /**\n   * ページ一覧アクセサを取得\n   */\n  get pages(): PagesAccessor {\n    if (!this._pages) {\n      this._pages = new PagesAccessor(this);\n    }\n    return this._pages;\n  }\n\n  /**\n   * フォーラムアクセサを取得\n   */\n  get forum(): ForumAccessor {\n    if (!this._forum) {\n      this._forum = new ForumAccessor(this);\n    }\n    return this._forum;\n  }\n\n  /**\n   * メンバーアクセサを取得\n   */\n  get member(): MemberAccessor {\n    if (!this._member) {\n      this._member = new MemberAccessor(this);\n    }\n    return this._member;\n  }\n\n  /**\n   * サイトのベースURLを取得\n   */\n  getBaseUrl(): string {\n    const protocol = this.sslSupported ? 'https' : 'http';\n    return `${protocol}://${this.domain}`;\n  }\n\n  /**\n   * サイトへのAMCリクエストを実行\n   * @param bodies - リクエストボディ配列\n   * @returns AMCレスポンス配列\n   */\n  amcRequest(bodies: AMCRequestBody[]): WikidotResultAsync<AMCResponse[]> {\n    return this.client.amcClient.request(bodies, this.unixName, this.sslSupported);\n  }\n\n  /**\n   * 単一のAMCリクエストを実行\n   * @param body - リクエストボディ\n   * @returns AMCレスポンス\n   */\n  amcRequestSingle(body: AMCRequestBody): WikidotResultAsync<AMCResponse> {\n    return fromPromise(\n      (async () => {\n        const result = await this.amcRequest([body]);\n        if (result.isErr()) {\n          throw result.error;\n        }\n        const response = result.value[0];\n        if (!response) {\n          throw new UnexpectedError('AMC request returned empty response');\n        }\n        return response;\n      })(),\n      (error) => {\n        if (error instanceof UnexpectedError) {\n          return error;\n        }\n        return new UnexpectedError(`AMC request failed: ${String(error)}`);\n      }\n    );\n  }\n\n  /**\n   * UNIX名からサイトを取得する\n   * @param client - クライアント\n   * @param unixName - サイトのUNIX名（例: 'scp-jp'）\n   * @returns サイト\n   */\n  static fromUnixName(client: Client, unixName: string): WikidotResultAsync<Site> {\n    return fromPromise(\n      (async () => {\n        // サイトページを取得\n        const url = `https://${unixName}.wikidot.com`;\n        const response = await fetch(url, {\n          headers: client.amcClient.header.getHeaders(),\n        });\n\n        if (!response.ok) {\n          if (response.status === 404) {\n            throw new NotFoundException(`Site not found: ${unixName}`);\n          }\n          throw new UnexpectedError(`Failed to fetch site: ${response.status}`);\n        }\n\n        const html = await response.text();\n        const $ = cheerio.load(html);\n\n        // WIKIREQUEST.info を解析\n        const scripts = $('script').toArray();\n        let siteId: number | null = null;\n        let siteUnixName: string | null = null;\n        let domain: string | null = null;\n        let title: string | null = null;\n\n        for (const script of scripts) {\n          const content = $(script).html();\n          if (!content || !content.includes('WIKIREQUEST')) {\n            continue;\n          }\n\n          // siteId\n          const siteIdMatch = content.match(/WIKIREQUEST\\.info\\.siteId\\s*=\\s*(\\d+)/);\n          if (siteIdMatch?.[1]) {\n            siteId = Number.parseInt(siteIdMatch[1], 10);\n          }\n\n          // siteUnixName\n          const siteUnixNameMatch = content.match(\n            /WIKIREQUEST\\.info\\.siteUnixName\\s*=\\s*[\"']([^\"']+)[\"']/\n          );\n          if (siteUnixNameMatch?.[1]) {\n            siteUnixName = siteUnixNameMatch[1];\n          }\n\n          // domain\n          const domainMatch = content.match(/WIKIREQUEST\\.info\\.domain\\s*=\\s*[\"']([^\"']+)[\"']/);\n          if (domainMatch?.[1]) {\n            domain = domainMatch[1];\n          }\n        }\n\n        // title from <title> tag\n        title = $('title').text().trim() || null;\n        // Remove \" - Wikidot\" suffix if present\n        if (title?.endsWith(' - Wikidot')) {\n          title = title.slice(0, -10).trim();\n        }\n\n        if (siteId === null) {\n          throw new NoElementError('Site ID not found in WIKIREQUEST');\n        }\n        if (siteUnixName === null) {\n          siteUnixName = unixName; // Fallback\n        }\n        if (domain === null) {\n          domain = `${unixName}.wikidot.com`; // Fallback\n        }\n        if (title === null) {\n          title = unixName; // Fallback\n        }\n\n        // SSL対応チェック（既にhttpsでアクセスできているので true）\n        const sslSupported = true;\n\n        return new Site(client, {\n          id: siteId,\n          title,\n          unixName: siteUnixName,\n          domain,\n          sslSupported,\n        });\n      })(),\n      (error) => {\n        if (error instanceof NotFoundException || error instanceof NoElementError) {\n          return error;\n        }\n        return new UnexpectedError(`Failed to get site: ${String(error)}`);\n      }\n    );\n  }\n\n  toString(): string {\n    return `Site(id=${this.id}, unixName=${this.unixName}, title=${this.title})`;\n  }\n}\n",
    "import type { WikidotResultAsync } from '../../../common/types';\nimport { Site } from '../../site';\nimport type { Client } from '../client';\n\n/**\n * サイト操作アクセサ\n */\nexport class SiteAccessor {\n  public readonly client: Client;\n\n  constructor(client: Client) {\n    this.client = client;\n  }\n\n  /**\n   * UNIX名からサイトを取得する\n   * @param unixName - サイトのUNIX名（例: 'scp-jp'）\n   * @returns サイトオブジェクト\n   */\n  get(unixName: string): WikidotResultAsync<Site> {\n    return Site.fromUnixName(this.client, unixName);\n  }\n}\n\nexport { Site };\n",
    "import { NotFoundException } from '../../../common/errors';\nimport { type WikidotResultAsync, wdErrAsync, wdOkAsync } from '../../../common/types';\nimport { User, type UserCollection } from '../../user';\nimport type { Client } from '../client';\n\n/**\n * ユーザー取得オプション\n */\nexport interface GetUserOptions {\n  /** ユーザーが見つからない場合にエラーを発生させる（デフォルト: false） */\n  raiseWhenNotFound?: boolean;\n}\n\n/**\n * ユーザー操作アクセサ\n */\nexport class UserAccessor {\n  public readonly client: Client;\n\n  constructor(client: Client) {\n    this.client = client;\n  }\n\n  /**\n   * ユーザー名からユーザーを取得する\n   * @param name - ユーザー名\n   * @param options - 取得オプション\n   * @returns ユーザー（存在しない場合はnull、raiseWhenNotFoundがtrueの場合はエラー）\n   */\n  get(name: string, options: GetUserOptions = {}): WikidotResultAsync<User | null> {\n    const { raiseWhenNotFound = false } = options;\n\n    return User.fromName(this.client, name).andThen((user) => {\n      if (user === null && raiseWhenNotFound) {\n        return wdErrAsync(new NotFoundException(`User not found: ${name}`));\n      }\n      return wdOkAsync(user);\n    });\n  }\n\n  /**\n   * 複数ユーザー名からユーザーを取得する\n   * @param names - ユーザー名配列\n   * @param options - 取得オプション\n   * @returns ユーザーコレクション（存在しないユーザーはnull、raiseWhenNotFoundがtrueの場合はエラー）\n   */\n  getMany(names: string[], options: GetUserOptions = {}): WikidotResultAsync<UserCollection> {\n    const { raiseWhenNotFound = false } = options;\n\n    return User.fromNames(this.client, names).andThen((collection) => {\n      if (raiseWhenNotFound) {\n        const notFoundNames: string[] = [];\n        for (let i = 0; i < names.length; i++) {\n          const name = names[i];\n          if (collection[i] === null && name !== undefined) {\n            notFoundNames.push(name);\n          }\n        }\n        if (notFoundNames.length > 0) {\n          return wdErrAsync(new NotFoundException(`Users not found: ${notFoundNames.join(', ')}`));\n        }\n      }\n      return wdOkAsync(collection);\n    });\n  }\n}\n",
    "import { LoginRequiredError } from '../../common/errors';\nimport {\n  fromPromise,\n  type WikidotResult,\n  type WikidotResultAsync,\n  wdErr,\n  wdOk,\n  wdOkAsync,\n} from '../../common/types';\nimport { AMCClient, type AMCConfig, login, logout } from '../../connector';\nimport type { User } from '../user/user';\nimport { PrivateMessageAccessor } from './accessors/pm-accessor';\nimport { SiteAccessor } from './accessors/site-accessor';\nimport { UserAccessor } from './accessors/user-accessor';\n\n/**\n * クライアント作成オプション\n */\nexport interface ClientOptions {\n  /** Wikidotユーザー名 */\n  username?: string;\n\n  /** Wikidotパスワード */\n  password?: string;\n\n  /** ベースドメイン（デフォルト: wikidot.com） */\n  domain?: string;\n\n  /** AMC設定オーバーライド */\n  amcConfig?: Partial<AMCConfig>;\n}\n\n/**\n * Wikidotクライアント\n * ライブラリのメインエントリポイント\n */\nexport class Client {\n  /** AMCクライアント */\n  public readonly amcClient: AMCClient;\n\n  /** ベースドメイン */\n  public readonly domain: string;\n\n  /** ユーザー操作アクセサ */\n  public readonly user: UserAccessor;\n\n  /** サイト操作アクセサ */\n  public readonly site: SiteAccessor;\n\n  /** プライベートメッセージ操作アクセサ */\n  public readonly privateMessage: PrivateMessageAccessor;\n\n  /** ログイン中のユーザー名 */\n  private _username: string | null;\n\n  /** ログイン中のユーザー */\n  private _me: User | null = null;\n\n  /**\n   * プライベートコンストラクタ\n   * createメソッドを使用してインスタンスを作成する\n   */\n  private constructor(amcClient: AMCClient, domain: string, username: string | null = null) {\n    this.amcClient = amcClient;\n    this.domain = domain;\n    this._username = username;\n\n    // アクセサを初期化\n    this.user = new UserAccessor(this);\n    this.site = new SiteAccessor(this);\n    this.privateMessage = new PrivateMessageAccessor(this);\n  }\n\n  /**\n   * ログイン中のユーザー名を取得\n   */\n  get username(): string | null {\n    return this._username;\n  }\n\n  /**\n   * ログイン中のユーザーを取得\n   * ログインしていない場合はnull\n   */\n  get me(): User | null {\n    return this._me;\n  }\n\n  /**\n   * クライアントを作成する\n   * @param options - クライアントオプション\n   * @returns クライアントインスタンス\n   */\n  static create(options: ClientOptions = {}): WikidotResultAsync<Client> {\n    const { username, password, domain = 'wikidot.com', amcConfig = {} } = options;\n\n    // AMCクライアントを作成\n    const amcClient = new AMCClient(amcConfig, domain);\n\n    // 認証情報がある場合はログイン\n    if (username && password) {\n      return fromPromise(\n        (async () => {\n          const client = new Client(amcClient, domain, username);\n          const loginResult = await login(client, username, password);\n          if (loginResult.isErr()) {\n            throw loginResult.error;\n          }\n\n          // ログイン中のユーザー情報を取得\n          const { User } = await import('../user/user');\n          const userResult = await User.fromName(client, username);\n          if (userResult.isOk() && userResult.value) {\n            client._me = userResult.value;\n          }\n\n          return client;\n        })(),\n        (error) => {\n          if (error instanceof LoginRequiredError) {\n            return error;\n          }\n          return new LoginRequiredError(`Failed to create client: ${String(error)}`);\n        }\n      );\n    }\n\n    // 認証なしのクライアントを返す\n    return wdOkAsync(new Client(amcClient, domain));\n  }\n\n  /**\n   * 未認証クライアントを作成する\n   * @param options - クライアントオプション（認証情報以外）\n   * @returns クライアントインスタンス\n   */\n  static createAnonymous(options: Omit<ClientOptions, 'username' | 'password'> = {}): Client {\n    const { domain = 'wikidot.com', amcConfig = {} } = options;\n    const amcClient = new AMCClient(amcConfig, domain);\n    return new Client(amcClient, domain);\n  }\n\n  /**\n   * ログイン状態を確認する\n   * @returns ログイン済みならtrue\n   */\n  isLoggedIn(): boolean {\n    return this._username !== null;\n  }\n\n  /**\n   * ログインを要求する\n   * ログイン済みでない場合はLoginRequiredErrorを返す\n   * @returns 成功時はvoid\n   */\n  requireLogin(): WikidotResult<void> {\n    if (!this.isLoggedIn()) {\n      return wdErr(new LoginRequiredError());\n    }\n    return wdOk(undefined);\n  }\n\n  /**\n   * クライアントをクローズする\n   * セッションがある場合はログアウトを試みる\n   */\n  close(): WikidotResultAsync<void> {\n    if (this.isLoggedIn()) {\n      return logout(this).map(() => {\n        this._username = null;\n        return undefined;\n      });\n    }\n    return wdOkAsync(undefined);\n  }\n}\n"
  ],
  "mappings": "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",
  "debugId": "1A0AF3AA4D5CAB4D64756E2164756E21",
  "names": []
}