facebook-comments-client 0.1.4

package/dist/cli.js

@@ -0,0 +1,1608 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { existsSync as existsSync2 } from "fs";
+
+// src/client/FacebookCommentsClient.ts
+import { mkdir } from "fs/promises";
+import { dirname } from "path";
+import { existsSync } from "fs";
+import { chromium as chromium2 } from "playwright";
+
+// src/browser/BrowserManager.ts
+import { chromium } from "playwright";
+var BrowserManager = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  options;
+  browser = null;
+  currentHeadless = null;
+  async launch(headless = this.options.headless ?? true) {
+    if (this.browser?.isConnected() && this.currentHeadless === headless) {
+      return this.browser;
+    }
+    await this.close();
+    this.browser = await chromium.launch({
+      headless,
+      executablePath: this.options.executablePath,
+      args: this.options.args
+    });
+    this.currentHeadless = headless;
+    return this.browser;
+  }
+  async close() {
+    if (this.browser) {
+      await this.browser.close().catch(() => {
+      });
+      this.browser = null;
+      this.currentHeadless = null;
+    }
+  }
+};
+
+// src/browser/ContextFactory.ts
+function toStrictCookie(cookie) {
+  return {
+    name: cookie.name,
+    value: cookie.value,
+    domain: cookie.domain,
+    path: cookie.path ?? "/",
+    expires: cookie.expires ?? -1,
+    httpOnly: cookie.httpOnly ?? false,
+    secure: cookie.secure ?? true,
+    sameSite: cookie.sameSite ?? "Lax"
+  };
+}
+async function createLoggedInContext(browser, options) {
+  const storageState = options.storageState ? {
+    cookies: options.storageState.cookies.filter((cookie) => cookie.name && cookie.value && cookie.domain).map(toStrictCookie),
+    origins: options.storageState.origins ?? []
+  } : void 0;
+  const context = await browser.newContext({
+    storageState,
+    // Wide desktop viewport: Facebook serves its full layout (comments sidebar
+    // on reels/videos) rather than collapsed theater mode.
+    viewport: { width: 1680, height: 1050 }
+  });
+  context.setDefaultTimeout(options.timeoutMs ?? 3e4);
+  context.setDefaultNavigationTimeout(options.timeoutMs ?? 3e4);
+  return context;
+}
+
+// src/browser/SessionManager.ts
+var AUTH_COOKIE_NAMES = ["c_user", "xs"];
+function hasAuthCookies(state) {
+  if (!state) return false;
+  const names = new Set(state.cookies.map((cookie) => cookie.name));
+  return AUTH_COOKIE_NAMES.every((name) => names.has(name));
+}
+async function checkAuthenticatedOnPage(context, page) {
+  await page.goto("https://www.facebook.com/", { waitUntil: "domcontentloaded" });
+  const url = page.url();
+  if (/(?:^|\/)login(?:\.php)?(?:[/?#]|$)/i.test(url)) return false;
+  if (/(?:^|\/)recover(?:[/?#]|$)/i.test(url)) return false;
+  const cookies = await context.cookies("https://www.facebook.com");
+  const names = new Set(cookies.map((cookie) => cookie.name));
+  return AUTH_COOKIE_NAMES.every((name) => names.has(name));
+}
+
+// src/errors/FacebookClientError.ts
+var FacebookClientError = class extends Error {
+  code;
+  retryable;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = new.target.name;
+    this.code = options.code ?? "FB_CLIENT";
+    this.retryable = options.retryable ?? false;
+    if (options.cause !== void 0) {
+      this.cause = options.cause;
+    }
+  }
+};
+
+// src/errors/FacebookAuthenticationError.ts
+var FacebookAuthenticationError = class extends FacebookClientError {
+  constructor(message, options = {}) {
+    super(message, { ...options, code: "FB_AUTH" });
+  }
+};
+
+// src/errors/FacebookSessionExpiredError.ts
+var FacebookSessionExpiredError = class extends FacebookClientError {
+  constructor(message, options = {}) {
+    super(message, { ...options, code: "FB_SESSION_EXPIRED" });
+  }
+};
+
+// src/errors/FacebookPostNotFoundError.ts
+var FacebookPostNotFoundError = class extends FacebookClientError {
+  constructor(message, options = {}) {
+    super(message, { ...options, code: "FB_POST_NOT_FOUND" });
+  }
+};
+
+// src/errors/FacebookAccessDeniedError.ts
+var FacebookAccessDeniedError = class extends FacebookClientError {
+  constructor(message, options = {}) {
+    super(message, { ...options, code: "FB_ACCESS_DENIED" });
+  }
+};
+
+// src/errors/FacebookExtractionError.ts
+var FacebookExtractionError = class extends FacebookClientError {
+  constructor(message, options = {}) {
+    super(message, { ...options, code: "FB_EXTRACTION", retryable: options.retryable ?? true });
+  }
+};
+
+// src/session/StorageStateProvider.ts
+import { z } from "zod";
+var CookieSchema = z.object({
+  name: z.string(),
+  value: z.string(),
+  domain: z.string().optional(),
+  path: z.string().optional(),
+  expires: z.number().optional(),
+  httpOnly: z.boolean().optional(),
+  secure: z.boolean().optional(),
+  sameSite: z.enum(["Strict", "Lax", "None"]).optional()
+}).passthrough();
+var StorageStateSchema = z.object({
+  cookies: z.array(CookieSchema).default([]),
+  origins: z.array(
+    z.object({
+      origin: z.string(),
+      localStorage: z.array(z.object({ name: z.string(), value: z.string() })).default([])
+    }).passthrough()
+  ).default([])
+});
+function validateStorageState(input, source) {
+  const result = StorageStateSchema.safeParse(input);
+  if (!result.success) {
+    const paths = result.error.issues.map((issue) => issue.path.join(".")).slice(0, 5);
+    throw new FacebookAuthenticationError(
+      `Session data from ${source} is not a valid storage state (invalid: ${paths.join(", ")})`,
+      { cause: void 0 }
+    );
+  }
+  const cookies = [];
+  for (const cookie of result.data.cookies) {
+    if (!cookie.name || !cookie.value || !cookie.domain) continue;
+    cookies.push({ ...cookie, domain: cookie.domain, path: cookie.path ?? "/" });
+  }
+  return { cookies, origins: result.data.origins };
+}
+var StorageStateProvider = class {
+  constructor(state) {
+    this.state = state;
+  }
+  state;
+  type = "state";
+  async resolve() {
+    return validateStorageState(this.state, "inline session config");
+  }
+};
+
+// src/session/FileSessionProvider.ts
+import { readFile } from "fs/promises";
+var FileSessionProvider = class {
+  constructor(path) {
+    this.path = path;
+  }
+  path;
+  type = "file";
+  async resolve() {
+    let raw;
+    try {
+      raw = await readFile(this.path, "utf8");
+    } catch (error) {
+      const code = error.code;
+      if (code === "ENOENT") {
+        throw new FacebookAuthenticationError(
+          `Session file not found: ${this.path}. Run \`fb-comments login --output ${this.path}\` first.`
+        );
+      }
+      throw new FacebookAuthenticationError(`Could not read session file: ${this.path} (${code})`);
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      throw new FacebookAuthenticationError(`Session file is not valid JSON: ${this.path}`);
+    }
+    return validateStorageState(parsed, `file ${this.path}`);
+  }
+};
+
+// src/session/EnvSessionProvider.ts
+var EnvSessionProvider = class {
+  constructor(envKey) {
+    this.envKey = envKey;
+  }
+  envKey;
+  type = "env";
+  async resolve() {
+    const encoded = process.env[this.envKey];
+    if (!encoded) {
+      throw new FacebookAuthenticationError(
+        `Environment variable ${this.envKey} is not set. Encode a storage state with: Buffer.from(JSON.stringify(storageState)).toString("base64")`
+      );
+    }
+    const normalized = encoded.replace(/-/g, "+").replace(/_/g, "/");
+    let decoded;
+    try {
+      decoded = Buffer.from(normalized, "base64").toString("utf8");
+    } catch {
+      throw new FacebookAuthenticationError(
+        `Environment variable ${this.envKey} is not valid base64.`
+      );
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(decoded);
+    } catch {
+      throw new FacebookAuthenticationError(
+        `Environment variable ${this.envKey} does not contain valid JSON after base64 decoding.`
+      );
+    }
+    return validateStorageState(parsed, `env ${this.envKey}`);
+  }
+};
+
+// src/session/CookieProvider.ts
+var CookieProvider = class {
+  constructor(cookies) {
+    this.cookies = cookies;
+  }
+  cookies;
+  type = "cookies";
+  async resolve() {
+    const result = CookieSchema.array().safeParse(this.cookies);
+    if (!result.success) {
+      throw new FacebookAuthenticationError(
+        "Cookie session config contains invalid cookies (each needs at least name, value, domain)"
+      );
+    }
+    const cookies = [];
+    for (const cookie of result.data) {
+      if (!cookie.name || !cookie.value || !cookie.domain) continue;
+      cookies.push({
+        ...cookie,
+        domain: cookie.domain,
+        path: cookie.path ?? "/",
+        expires: cookie.expires ?? -1
+      });
+    }
+    return { cookies, origins: [] };
+  }
+};
+
+// src/session/SessionProvider.ts
+function createSessionProvider(config) {
+  switch (config.type) {
+    case "file":
+    case "storage":
+      return new FileSessionProvider(config.path);
+    case "env":
+      return new EnvSessionProvider(config.envKey);
+    case "cookies":
+      return new CookieProvider(config.cookies);
+    case "state":
+      return new StorageStateProvider(config.state);
+    default:
+      throw new FacebookClientError(
+        `Unknown session type: ${JSON.stringify(config.type)}`
+      );
+  }
+}
+
+// src/extractors/ExtractorPipeline.ts
+var ExtractorPipeline = class {
+  constructor(extractors) {
+    this.extractors = extractors;
+  }
+  extractors;
+  async extract(page, options, scope) {
+    const attempted = [];
+    for (const extractor of this.extractors) {
+      try {
+        if (!await extractor.canHandle(page, scope)) continue;
+        attempted.push(extractor.name);
+        const raw = await extractor.extract(page, options, scope);
+        if (raw.length > 0) return raw;
+      } catch {
+      }
+    }
+    throw new FacebookExtractionError(
+      attempted.length > 0 ? `No extractor produced comments (tried: ${attempted.join(", ")}). Facebook markup may have changed \u2014 see src/config/selectors.ts.` : "No extractor could handle this page. Facebook markup may have changed \u2014 see src/config/selectors.ts."
+    );
+  }
+};
+
+// src/config/selectors.ts
+var selectors = {
+  /** Each comment renders as an aria article. The post itself is also an article —
+   *  CommentParser distinguishes comments via reply affordances and aria-labels. */
+  commentArticle: '[role="article"]',
+  /** Real comment articles only (top-level "Comment by" + nested "Reply by");
+   *  excludes post/feed wrapper articles. */
+  commentCandidate: '[role="article"][aria-label*="comment by" i], [role="article"][aria-label*="reply by" i]',
+  /** Foreground permalink modal — group/photo/video permalinks open the post in
+   *  a dialog while the logged-in feed stays mounted behind it. Comment
+   *  interactions and extraction must be scoped to this dialog, or background
+   *  feed comments leak into results. Plain [role="dialog"] wrappers (without
+   *  aria-modal) are the nesting chrome, not the boundary. */
+  foregroundModal: '[role="dialog"][aria-modal="true"]',
+  /** Profile links inside a comment (author avatar/name). */
+  authorLink: 'a[href*="/people/"], a[href^="/"], a[href*="facebook.com/"]',
+  /** Elements that expand more comments (button or link). Matched by text, see textPatterns.moreComments. */
+  commentExpander: '[role="button"], [role="link"], a[href="#"]',
+  /** Elements that expand reply threads. Matched by text, see textPatterns.viewMoreReplies. */
+  replyExpander: '[role="button"], [role="link"], a[href="#"]',
+  /** Embedded structured data blobs (opportunistic structured extractor). */
+  structuredDataScripts: 'script[type="application/json"]',
+  /** Looser comment containers for the fallback extractor. */
+  fallbackCommentContainer: '[aria-label*="comment by" i], [data-testid*="comment" i]',
+  /** Icon-only comment openers on reels/videos: aria-label carries "comment" ("Comment",
+   *  "Comments", "Comment, 5"), while the button text may be empty. */
+  commentOpenerControls: '[role="button"][aria-label*="comment" i], [role="link"][aria-label*="comment" i], [aria-label^="comment" i]'
+};
+var textPatterns = {
+  /** aria-label of a comment article, e.g. "Comment by John Doe" or "John Doe · 2h". */
+  commentBy: /(?:^|\b)comment(?:ed)? by\s+(.+)$/i,
+  /** aria-label of a reply article: "Reply by X to Y's comment 3 days ago".
+   *  Group modals render replies as flat sibling articles — group 1 is the
+   *  reply author, group 2 the parent comment's author. */
+  replyBy: /\breply by\s+(.+?)\s+to\s+(.+?)'s comment\b/i,
+  /** aria-label of a reply article without the parent attribution. */
+  replyByFallback: /\breply by\s+(.+)$/i,
+  /** Author · timestamp header, e.g. "John Doe · 2h". */
+  authorTime: /^(.+?)\s*·\s*(?:.*?\d)/,
+  /** Reply action affordance. */
+  reply: /^\s*(reply|antworten|r\u00e9pondere|responder)\s*$/i,
+  /** "View more replies", "View 2 replies", "Load more replies", "Show N previous replies". */
+  viewMoreReplies: /\b\d*\s*(?:view|see|show|load)\s*(?:\d+\s*)?(?:more\s*)?(?:previous\s*)?repl(?:y|ies)\b|^\s*\d+\s+repl(?:y|ies)\s*$/i,
+  /** "View more comments", "View 12 comments", "Load 25 more comments", "View previous comments". */
+  moreComments: /\b(?:view|see|show|load)\s*(?:\d+\s*)?(?:more\s*)?(?:previous\s*)?comments?\b/i,
+  /** Comment-panel opener on reels/videos ("Comments", "View comments", "View 12 comments"). */
+  commentOpener: /^(?:view\s+)?comments?\b/i,
+  /** Composer boxes ("Write a comment") also contain "comment" — never click those. */
+  commentComposer: /^(write|leave|reply\s+to)\b/i,
+  /** Reaction counts, e.g. "5", "5 reactions", "1.2K". */
+  reactions: /^(?:[\d.,]+\s*[KkMm]?|[\d.,]+\s*[KkMm]?\s*(?:reactions?|likes?))$/,
+  /** Post unavailable / deleted. */
+  unavailable: /this content isn'?t (?:available|viewable)|content you requested cannot|page isn'?t available|this page isn'?t available/i,
+  /** Private group wall the account has not joined. */
+  joinGroup: /ask to join|join (?:this )?group|this group is private|join to see/i,
+  /** Login wall shown to logged-out visitors. */
+  loginWall: /log ?in (?:to continue|to see|or sign up)|you must log in to continue/i,
+  /** Relative timestamps: "2h", "5m", "3d", "12w", "2y", "just now", "5 hours ago",
+   *  "a day ago", "Yesterday at 3:04 PM". */
+  relativeTime: /\b(?:\d+\s*[smhdyw]\b|\d+\s+(?:seconds?|minutes?|hours?|days?|weeks?|months?|years?)\b(?:\s+ago)?|an?\s+(?:second|minute|hour|day|week|month|year)\s+ago|just now|yesterday(?:\s+at\s+[\d:]+\s*(?:am|pm)?)?)/i,
+  /** Timestamp glued onto the end of an author name in an aria-label
+   *  ("Comment by Mjac Cabildo 5 hours ago") — strip it from the name. */
+  trailingTimestamp: /\s*[·-]?\s*(?:just now|yesterday(?:\s+at\s+\d{1,2}:\d{2}\s*(?:am|pm))?|(?:an?|\d+)\s+(?:s|secs?|m|mins?|min(?:utes?)?|h|hrs?|h(?:ours?)?|d|days?|w|wks?|w(?:eeks?)?|mo|months?|y|yrs?|y(?:ears?)?)\s*(?:ago\b)?|\d+\s*[smhdyw]\b|\d{1,2}:\d{2}\s*(?:am|pm)?)$/i,
+  /** Absolute dates as Facebook renders them in comment headers:
+   *  "Wednesday, August 26, 2026 at 2:38 PM", "August 26, 2026 at 2:38 PM",
+   *  "August 26 at 2:38 PM". */
+  absoluteTime: /^(?:[a-z]+day,\s*)?(?:jan(?:uary)?|feb(?:ruary)?|mar(?:ch)?|apr(?:il)?|may|jun(?:e)?|jul(?:y)?|aug(?:ust)?|sept?(?:ember)?|oct(?:ober)?|nov(?:ember)?|dec(?:ember)?)\s+\d{1,2}(?:,\s*\d{4})?(?:\s+at\s+\d{1,2}:\d{2}\s*(?:am|pm)?)?$/i,
+  /** Per-comment truncation expander ("See more" at the end of long comments). */
+  seeMore: /^\s*see more\s*$/i,
+  /** Author badges rendered inside comment articles. */
+  badge: /^(?:verified account|top fan|new member|founding member|active member|rising fan|contributor|admin|moderator|analyst)$/i,
+  /** Separator-only text lines ("·", "•", "…", "!") left between header and body. */
+  noiseLine: /^[·•|,!?:;.…\-–—\s]+$/
+};
+var loadMoreLimits = {
+  commentExpansions: 40,
+  replyExpansions: 60,
+  clicksPerRound: 5,
+  settleMs: 800
+};
+
+// src/parsers/FacebookResponseParser.ts
+function safeJsonParse(input) {
+  try {
+    return JSON.parse(input);
+  } catch {
+    return null;
+  }
+}
+function walkJson(root, visit, options) {
+  let visited = 0;
+  const walk = (node, depth) => {
+    if (depth > options.maxDepth || visited > options.maxNodes) return;
+    if (!node || typeof node !== "object") return;
+    visited++;
+    visit(node);
+    for (const value of Object.values(node)) {
+      walk(value, depth + 1);
+    }
+  };
+  walk(root, 0);
+}
+
+// src/extractors/StructuredDataExtractor.ts
+function isCommentNode(node) {
+  if (!node || typeof node !== "object") return false;
+  const candidate = node;
+  return typeof candidate.message?.text === "string" && typeof candidate.author?.name === "string";
+}
+function mapNode(node) {
+  const created = typeof node.created_time === "number" ? node.created_time : null;
+  const reactions = typeof node.reaction_count === "number" ? node.reaction_count : typeof node.reactions?.summary?.total_count === "number" ? node.reactions.summary.total_count : null;
+  return {
+    authorId: typeof node.author?.id === "string" ? node.author.id : null,
+    authorName: typeof node.author?.name === "string" ? node.author.name : null,
+    authorProfileUrl: typeof node.author?.profile_url === "string" ? node.author.profile_url : null,
+    message: String(node.message?.text ?? ""),
+    createdAtRaw: created !== null && created > 0 ? new Date(created * 1e3).toISOString() : null,
+    reactionsTotal: reactions,
+    replies: []
+  };
+}
+var StructuredDataExtractor = class {
+  name = "structured-data";
+  async canHandle(page) {
+    return page.evaluate(
+      ({ scriptSelector }) => Array.from(document.querySelectorAll(scriptSelector)).some((script) => {
+        const text = script.textContent ?? "";
+        return text.includes('"message"') && text.includes('"author"');
+      }),
+      { scriptSelector: selectors.structuredDataScripts }
+    );
+  }
+  async extract(page, options) {
+    const blobs = await page.evaluate(
+      (scriptSelector) => Array.from(document.querySelectorAll(scriptSelector)).map((script) => script.textContent ?? "").filter((text) => text.length > 2 && text.length < 5e6).slice(0, 100),
+      selectors.structuredDataScripts
+    );
+    const out = [];
+    const cap = Math.max(options.maxComments * 3, 100);
+    for (const blob of blobs) {
+      const json = safeJsonParse(blob);
+      if (!json) continue;
+      walkJson(
+        json,
+        (node) => {
+          if (out.length < cap && isCommentNode(node)) out.push(mapNode(node));
+        },
+        { maxNodes: 2e5, maxDepth: 40 }
+      );
+      if (out.length >= cap) break;
+    }
+    return out;
+  }
+};
+
+// src/comments/DiscussionScope.ts
+var DiscussionScope = class _DiscussionScope {
+  constructor(page, root) {
+    this.page = page;
+    this.root = root;
+  }
+  page;
+  root;
+  static wholePage(page) {
+    return new _DiscussionScope(page, null);
+  }
+  /** Coalesce an optional scope into a whole-page scope. */
+  static of(page, scope) {
+    return scope ?? _DiscussionScope.wholePage(page);
+  }
+  /**
+   * Resolve the discussion scope for the loaded page. Modal permalinks hydrate
+   * their dialog shortly after load, so wait briefly before deciding.
+   *
+   * Preference order:
+   * 1. visible foreground modal containing a permalink/link to the requested post
+   * 2. the single visible foreground modal
+   * 3. the whole page (non-modal layouts, or ambiguous nesting)
+   */
+  static async resolve(page, postId) {
+    await page.waitForSelector(selectors.foregroundModal, { state: "attached", timeout: 5e3 }).catch(() => null);
+    const modals = page.locator(selectors.foregroundModal);
+    const count = await modals.count().catch(() => 0);
+    if (count === 0) return _DiscussionScope.wholePage(page);
+    const visible = [];
+    for (let i = 0; i < count; i++) {
+      if (await modals.nth(i).isVisible().catch(() => false)) {
+        visible.push(modals.nth(i));
+      }
+    }
+    if (postId && /^\d+$/.test(postId) && visible.length > 0) {
+      const paths = [`/posts/${postId}/`, `/permalink/${postId}/`];
+      for (const modal of visible) {
+        const hasPostLink = await modal.evaluate(
+          (el, wanted) => Array.from(el.querySelectorAll("a[href]")).some((anchor) => {
+            try {
+              const pathname = new URL(anchor.href, window.location.href).pathname;
+              return wanted.some((segment) => pathname.includes(segment));
+            } catch {
+              return false;
+            }
+          }),
+          paths
+        ).catch(() => false);
+        if (hasPostLink) return new _DiscussionScope(page, modal);
+      }
+    }
+    if (visible.length === 1) return new _DiscussionScope(page, visible[0]);
+    return _DiscussionScope.wholePage(page);
+  }
+  /** Locator scoped to the modal when present, else page-wide. */
+  locator(selector) {
+    return this.root ? this.root.locator(selector) : this.page.locator(selector);
+  }
+  /** The modal element itself, for root-scoped page.evaluate calls. */
+  async rootElementHandle() {
+    return this.root ? await this.root.elementHandle().catch(() => null) : null;
+  }
+  /** True when interactions are scoped to a foreground modal. */
+  get isModal() {
+    return this.root !== null;
+  }
+};
+
+// src/extractors/domDump.ts
+async function buildArticleDumps(page, options, scope) {
+  try {
+    const root = scope?.isModal ? await scope.rootElementHandle() : null;
+    const dumps = await page.evaluate(
+      ({ containerSelector, maxArticles, root: root2 }) => {
+        const scopeRoot = root2 ?? document;
+        const dump = (el) => {
+          const links = [];
+          const images = [];
+          let ownText = "";
+          let avatarUrl = null;
+          const walk = (node, inLink) => {
+            let linkContext = inLink;
+            if (node.nodeType === Node.ELEMENT_NODE) {
+              const elem = node;
+              if (elem !== el && elem.getAttribute("role") === "article") return;
+              if (elem.tagName === "A") {
+                linkContext = true;
+                const label = (elem.getAttribute("aria-label") ?? elem.textContent ?? "").trim() || null;
+                links.push({ href: elem.getAttribute("href") ?? "", label });
+                const hasImage = Boolean(elem.querySelector("img, image"));
+                if (label && !hasImage) ownText += label + "\n";
+                if (!hasImage) return;
+              }
+              const tag = elem.tagName.toUpperCase();
+              if (tag === "IMG" || tag === "IMAGE") {
+                const image = elem;
+                const rawUrl = image.currentSrc || elem.getAttribute("src") || elem.getAttribute("href") || elem.getAttribute("xlink:href") || "";
+                const alt = (elem.getAttribute("alt") ?? elem.getAttribute("aria-label") ?? "").trim() || null;
+                let attachment = false;
+                try {
+                  const url = new URL(rawUrl, document.baseURI);
+                  const host = url.hostname.toLowerCase();
+                  const allowed = url.protocol === "https:" && (host === "fbcdn.net" || host.endsWith(".fbcdn.net"));
+                  attachment = allowed && Boolean(alt) && (image.naturalWidth >= 120 || image.naturalHeight >= 120 || image.width >= 120 || image.height >= 120) && !/^(?:subscribe to|profile picture|avatar)/i.test(alt ?? "");
+                  if (attachment) {
+                    images.push({
+                      url: url.toString(),
+                      alt,
+                      width: image.naturalWidth || image.width || null,
+                      height: image.naturalHeight || image.height || null
+                    });
+                  }
+                  if (!avatarUrl && linkContext && allowed && (!alt || /^(?:profile picture|avatar)/i.test(alt))) {
+                    avatarUrl = url.toString();
+                  }
+                } catch {
+                }
+                if (!attachment && alt && !/^https?:/i.test(alt) && !/^(?:subscribe to|profile picture|avatar)/i.test(alt)) {
+                  ownText += alt + "\n";
+                }
+                return;
+              }
+            }
+            if (node.nodeType === Node.TEXT_NODE) {
+              ownText += (node.textContent ?? "") + "\n";
+              return;
+            }
+            for (const child of Array.from(node.childNodes)) walk(child, linkContext);
+          };
+          walk(el, false);
+          const children = [];
+          const findArticles = (node) => {
+            if (node !== el && node.getAttribute("role") === "article") {
+              const child = dump(node);
+              if (child) children.push(child);
+              return;
+            }
+            for (const child of Array.from(node.children)) findArticles(child);
+          };
+          findArticles(el);
+          return {
+            ariaLabel: el.getAttribute("aria-label"),
+            domId: el.id || null,
+            ownText: ownText.trim(),
+            fullText: el.innerText ?? ownText.trim(),
+            links: links.slice(0, 12),
+            images: images.slice(0, 12),
+            avatarUrl,
+            children
+          };
+        };
+        const all = Array.from(scopeRoot.querySelectorAll(containerSelector));
+        const tops = all.filter((el) => {
+          const parent = el.parentElement?.closest(containerSelector) ?? null;
+          return !parent || !scopeRoot.contains(parent);
+        });
+        return tops.slice(0, maxArticles).map(dump).filter((d) => d !== null);
+      },
+      { containerSelector: options.containerSelector, maxArticles: options.maxArticles, root }
+    );
+    return dumps ?? [];
+  } catch {
+    return [];
+  }
+}
+
+// src/comments/CommentParser.ts
+var NON_PROFILE_SEGMENTS = /* @__PURE__ */ new Set([
+  "groups",
+  "help",
+  "policies",
+  "login",
+  "photo",
+  "photos",
+  "reel",
+  "share",
+  "watch",
+  "marketplace",
+  "hashtag",
+  "events",
+  "gaming",
+  "stories",
+  "video",
+  "videos",
+  "posts",
+  "permalink.php",
+  "settings",
+  "privacy",
+  "legal",
+  "notes",
+  "login.php",
+  "recover",
+  "pages",
+  "bookmarks",
+  "friends",
+  "feed",
+  "notifications",
+  "helpcenter"
+]);
+var ACTION_LINE = /^(?:like|reply|share|hide|report|delete|edit|see translation|view translation|most relevant|all comments|see more|show more|by author|liked by author|top sticker|giphy|via giphy|click to view attachment|\d+\s*(?:reactions?|likes?|replies?|comments?)|liked by .*|reply\s*·\s*.*)$/i;
+function parseReactionCount(input) {
+  const match = input.trim().match(/^([\d.,]+)\s*([KkMm])?/);
+  if (!match) return null;
+  const base = Number.parseFloat(match[1]?.replace(/,/g, "") ?? "");
+  if (!Number.isFinite(base)) return null;
+  const suffix = match[2]?.toLowerCase();
+  if (suffix === "k") return Math.round(base * 1e3);
+  if (suffix === "m") return Math.round(base * 1e6);
+  return Math.round(base);
+}
+function isProfileUrl(href) {
+  if (!href || href.startsWith("#") || href.startsWith("javascript:")) return false;
+  try {
+    const url = new URL(href, "https://www.facebook.com");
+    if (!/(?:^|\.)facebook\.com$/i.test(url.hostname.replace(/^www\./i, ""))) return false;
+    if (url.pathname.startsWith("/people/")) return true;
+    if (url.pathname.startsWith("/profile.php")) return true;
+    const first = url.pathname.split("/").filter(Boolean)[0];
+    if (!first || NON_PROFILE_SEGMENTS.has(first.toLowerCase())) return false;
+    return url.pathname.split("/").filter(Boolean).length === 1;
+  } catch {
+    return false;
+  }
+}
+function absoluteUrl(href) {
+  if (!href) return null;
+  try {
+    return new URL(href, "https://www.facebook.com").toString();
+  } catch {
+    return null;
+  }
+}
+function authorIdFromProfileUrl(href) {
+  if (!href) return null;
+  try {
+    const url = new URL(href);
+    const people = url.pathname.match(/^\/people\/[^/]+\/(\d+)/);
+    if (people?.[1]) return people[1];
+    const queryId = url.searchParams.get("id");
+    if (queryId) return queryId;
+  } catch {
+  }
+  return null;
+}
+function stripTrailingTimestamp(name) {
+  let out = name.trim();
+  for (let i = 0; i < 2; i++) {
+    out = out.replace(textPatterns.trailingTimestamp, "").trim();
+  }
+  return out;
+}
+function commentRefFromProfileUrl(href) {
+  if (!href) return null;
+  try {
+    const url = new URL(href);
+    const encoded = url.searchParams.get("comment_id") ?? url.searchParams.get("reply_id");
+    if (!encoded) return null;
+    const decoded = Buffer.from(
+      encoded.replace(/-/g, "+").replace(/_/g, "/"),
+      "base64"
+    ).toString("utf8");
+    const match = decoded.match(/^(?:comment|reply):(\d+)_(\d+)/);
+    if (!match?.[1] || !match[2]) return null;
+    return { postRefId: match[1], commentId: match[2] };
+  } catch {
+    return null;
+  }
+}
+function timestampFrom(lines, ariaLabel) {
+  for (const line of lines) {
+    if (textPatterns.absoluteTime.test(line)) {
+      return line.replace(/^[a-z]+day,\s*/i, "").trim();
+    }
+  }
+  for (const line of lines) {
+    if (textPatterns.relativeTime.test(line)) {
+      const matched = line.match(textPatterns.trailingTimestamp)?.[0] ?? line;
+      return matched.replace(/^[·\s-]+/, "").trim();
+    }
+  }
+  const ariaTime = ariaLabel.split("\xB7").map((part) => part.trim()).find(Boolean);
+  if (ariaTime && textPatterns.relativeTime.test(ariaTime)) {
+    return ariaTime.match(textPatterns.trailingTimestamp)?.[0]?.trim() ?? ariaTime;
+  }
+  return null;
+}
+function parseArticleDump(dump) {
+  const ariaLabel = dump.ariaLabel ?? "";
+  const commentByMatch = ariaLabel.match(textPatterns.commentBy);
+  const replyByMatch = ariaLabel.match(textPatterns.replyBy) ?? ariaLabel.match(textPatterns.replyByFallback);
+  const authorTimeMatch = ariaLabel.match(textPatterns.authorTime);
+  const hasReplyLink = dump.links.some(
+    (link) => link.label !== null && textPatterns.reply.test(link.label)
+  );
+  const profileLink = dump.links.find((link) => isProfileUrl(link.href));
+  const profileUrl = profileLink ? absoluteUrl(profileLink.href) : null;
+  const commentRef = commentRefFromProfileUrl(profileUrl);
+  const lines = dump.ownText.split(/\n+/).map((line) => line.trim()).filter(Boolean);
+  const contentLines = [];
+  const droppedLines = [];
+  let headerSkipped = false;
+  for (const line of lines) {
+    const authorName2 = stripTrailingTimestamp(
+      replyByMatch?.[1] ?? commentByMatch?.[1] ?? authorTimeMatch?.[1] ?? ""
+    );
+    if (!headerSkipped && authorName2 && (line.startsWith(authorName2) || textPatterns.authorTime.test(line))) {
+      headerSkipped = true;
+      continue;
+    }
+    if (ACTION_LINE.test(line) || textPatterns.noiseLine.test(line) || textPatterns.badge.test(line) || textPatterns.reactions.test(line) || textPatterns.relativeTime.test(line) || textPatterns.absoluteTime.test(line)) {
+      droppedLines.push(line);
+      continue;
+    }
+    contentLines.push(line);
+  }
+  const message = contentLines.join("\n").trim();
+  const attachments = dump.images.map((image) => ({
+    type: /sticker/i.test(image.alt ?? "") ? "sticker" : "image",
+    ...image
+  }));
+  const looksLikeComment = (message.length > 0 || attachments.length > 0) && message.length < 3e3 && (hasReplyLink || commentByMatch !== null || replyByMatch !== null || authorTimeMatch !== null) && !(dump.children.length > 0 && contentLines.length > 40);
+  if (!looksLikeComment) return null;
+  const authorName = (profileLink?.label ?? "").trim() || stripTrailingTimestamp(
+    replyByMatch?.[1] ?? commentByMatch?.[1] ?? authorTimeMatch?.[1] ?? ""
+  ) || null;
+  const reactionLine = droppedLines.find((line) => textPatterns.reactions.test(line));
+  return {
+    id: commentRef?.commentId ?? (dump.domId || null),
+    postRefId: commentRef?.postRefId ?? null,
+    authorId: authorIdFromProfileUrl(profileUrl),
+    authorName,
+    authorProfileUrl: profileUrl,
+    authorAvatarUrl: dump.avatarUrl ?? null,
+    message,
+    attachments: attachments.length > 0 ? attachments : void 0,
+    createdAtRaw: timestampFrom([...lines], ariaLabel),
+    reactionsTotal: reactionLine ? parseReactionCount(reactionLine) : null,
+    isReply: replyByMatch !== null || void 0,
+    parentAuthorName: replyByMatch?.[2]?.trim() || null,
+    replies: []
+  };
+}
+function parseArticleTree(dump, parentId) {
+  const parsed = parseArticleDump(dump);
+  if (parsed) {
+    parsed.parentId = parentId;
+    const replies = [];
+    for (const child of dump.children) {
+      replies.push(...parseArticleTree(child, parsed.id ?? null));
+    }
+    parsed.replies = replies;
+    return [parsed];
+  }
+  return dump.children.flatMap((child) => parseArticleTree(child, null));
+}
+function attachFlatReplies(comments) {
+  const tops = [];
+  for (const comment of comments) {
+    if (comment.isReply) {
+      const parent = [...tops].reverse().find((top) => !top.isReply && top.authorName === comment.parentAuthorName);
+      if (parent) {
+        comment.parentId = parent.id ?? comment.parentId ?? null;
+        parent.replies = [...parent.replies ?? [], comment];
+        continue;
+      }
+    }
+    tops.push(comment);
+  }
+  return tops;
+}
+
+// src/extractors/AccessibleDomExtractor.ts
+var AccessibleDomExtractor = class {
+  name = "accessible-dom";
+  async canHandle(page, scope) {
+    return await DiscussionScope.of(page, scope).locator(selectors.commentArticle).count() > 0;
+  }
+  async extract(page, options, scope) {
+    const dumps = await buildArticleDumps(
+      page,
+      {
+        containerSelector: selectors.commentArticle,
+        // Headroom for the post wrapper plus reply threads.
+        maxArticles: Math.max(options.maxComments * 3, 50)
+      },
+      scope
+    );
+    const perRoot = dumps.map((dump) => parseArticleTree(dump, null));
+    const counts = perRoot.map((comments) => comments.length).sort((a, b) => b - a);
+    const max = counts[0] ?? 0;
+    const second = counts[1] ?? 0;
+    if (max >= 2 * second && max > 0) {
+      const best = perRoot.filter((comments) => comments.length === max);
+      if (best.length === 1) return attachFlatReplies(best[0] ?? []);
+    }
+    return attachFlatReplies(perRoot.flat());
+  }
+};
+
+// src/extractors/FallbackDomExtractor.ts
+var FallbackDomExtractor = class {
+  name = "fallback-dom";
+  async canHandle(page, scope) {
+    return await DiscussionScope.of(page, scope).locator(selectors.fallbackCommentContainer).count() > 0;
+  }
+  async extract(page, options, scope) {
+    const dumps = await buildArticleDumps(
+      page,
+      {
+        containerSelector: selectors.fallbackCommentContainer,
+        maxArticles: Math.max(options.maxComments * 3, 50)
+      },
+      scope
+    );
+    return attachFlatReplies(dumps.flatMap((dump) => parseArticleTree(dump, null)));
+  }
+};
+
+// src/comments/ReplyFetcher.ts
+async function expandReplies(scope) {
+  const rounds = Math.ceil(loadMoreLimits.replyExpansions / loadMoreLimits.clicksPerRound);
+  for (let round = 0; round < rounds; round++) {
+    const expanders = scope.locator(selectors.replyExpander).filter({ hasText: textPatterns.viewMoreReplies });
+    const count = Math.min(await expanders.count().catch(() => 0), loadMoreLimits.clicksPerRound);
+    if (count === 0) return;
+    for (let i = 0; i < count; i++) {
+      await expanders.nth(i).click({ timeout: 3e3 }).catch(() => {
+      });
+    }
+    await scope.page.waitForTimeout(loadMoreLimits.settleMs).catch(() => {
+    });
+  }
+}
+
+// src/comments/CommentFetcher.ts
+async function detectPageProblem(page) {
+  const url = page.url();
+  if (/(?:^|\/)login(?:\.php)?(?:[/?#]|$)/i.test(url)) {
+    return new FacebookSessionExpiredError(
+      "Facebook redirected to a login page \u2014 the session is no longer accepted. Re-run `fb-comments login` to refresh it."
+    );
+  }
+  let bodyText = "";
+  try {
+    bodyText = (await page.evaluate(() => document.body?.innerText ?? "")).slice(0, 2e4);
+  } catch {
+    return null;
+  }
+  if (textPatterns.unavailable.test(bodyText)) {
+    return new FacebookPostNotFoundError(
+      "This content is not available. The post may have been deleted or is not visible to this account."
+    );
+  }
+  if (textPatterns.joinGroup.test(bodyText)) {
+    return new FacebookAccessDeniedError(
+      "Access denied: this group is private and the account has not joined it."
+    );
+  }
+  if (textPatterns.loginWall.test(bodyText)) {
+    return new FacebookSessionExpiredError(
+      "Facebook is showing a login wall \u2014 the session appears expired. Re-run `fb-comments login`."
+    );
+  }
+  return null;
+}
+async function commentCount(scope) {
+  return scope.locator(selectors.commentCandidate).count().catch(() => 0);
+}
+async function waitForCommentGrowth(scope, previous, timeoutMs = 5e3) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const count = await commentCount(scope);
+    if (count > previous) return count;
+    await scope.page.waitForTimeout(250).catch(() => {
+    });
+  }
+  return commentCount(scope);
+}
+async function expandComments(scope, target) {
+  let lastCount = await commentCount(scope);
+  for (let round = 0; round < loadMoreLimits.commentExpansions; round++) {
+    if (lastCount >= target) return true;
+    const expanders = scope.locator(selectors.commentExpander).filter({ hasText: textPatterns.moreComments });
+    const count = Math.min(
+      await expanders.count().catch(() => 0),
+      loadMoreLimits.clicksPerRound
+    );
+    if (count === 0) return false;
+    for (let i = 0; i < count; i++) {
+      await expanders.nth(i).click({ timeout: 3e3 }).catch(() => {
+      });
+    }
+    const nextCount = await waitForCommentGrowth(scope, lastCount);
+    if (nextCount <= lastCount) return false;
+    lastCount = nextCount;
+  }
+  return false;
+}
+async function openCommentsPanel(scope) {
+  if (await commentCount(scope) > 0) return;
+  await scope.locator(selectors.commentOpenerControls).first().waitFor({ timeout: 8e3 }).catch(() => null);
+  const groups = [
+    scope.locator(selectors.commentExpander).filter({ hasText: textPatterns.commentOpener }),
+    scope.locator(selectors.commentOpenerControls)
+  ];
+  for (let attempt = 0; attempt < 3; attempt++) {
+    if (await commentCount(scope) > 0) return;
+    let clicked = false;
+    for (const group of groups) {
+      const count = Math.min(await group.count().catch(() => 0), 8);
+      for (let i = 0; i < count && !clicked; i++) {
+        const el = group.nth(i);
+        const label = await el.getAttribute("aria-label").catch(() => null) ?? "";
+        if (textPatterns.commentComposer.test(label)) continue;
+        if (!await el.isVisible().catch(() => false)) continue;
+        clicked = true;
+        await el.click({ timeout: 3e3 }).catch(() => {
+        });
+      }
+      if (clicked) break;
+    }
+    if (!clicked) return;
+    await scope.locator(selectors.commentArticle).first().waitFor({ timeout: 6e3 }).catch(() => null);
+    await scope.page.waitForTimeout(loadMoreLimits.settleMs).catch(() => {
+    });
+  }
+}
+async function waitForStableArticles(scope, maxWaitMs = 8e3) {
+  const start = Date.now();
+  let last = -1;
+  let stablePolls = 0;
+  while (Date.now() - start < maxWaitMs) {
+    const count = await commentCount(scope).catch(() => 0);
+    if (count === last) {
+      stablePolls++;
+      if (stablePolls >= 2 && count > 0) return;
+    } else {
+      stablePolls = 0;
+      last = count;
+    }
+    await scope.page.waitForTimeout(700).catch(() => {
+    });
+  }
+}
+async function expandSeeMore(scope) {
+  for (let round = 0; round < 3; round++) {
+    const buttons = scope.locator(selectors.commentExpander).filter({ hasText: textPatterns.seeMore });
+    const count = Math.min(await buttons.count().catch(() => 0), 25);
+    if (count === 0) return;
+    for (let i = 0; i < count; i++) {
+      await buttons.nth(i).click({ timeout: 1500 }).catch(() => {
+      });
+    }
+    await scope.page.waitForTimeout(loadMoreLimits.settleMs).catch(() => {
+    });
+  }
+}
+var CommentFetcher = class {
+  constructor(pipeline) {
+    this.pipeline = pipeline;
+  }
+  pipeline;
+  async fetch(page, params) {
+    const scope = await DiscussionScope.resolve(page, params.postId);
+    await openCommentsPanel(scope);
+    await waitForStableArticles(scope);
+    const target = params.skipped + params.maxComments;
+    await expandComments(scope, target);
+    await expandSeeMore(scope);
+    if (params.includeReplies) {
+      await expandReplies(scope);
+    }
+    const extracted = await this.pipeline.extract(
+      page,
+      {
+        maxComments: params.maxComments,
+        includeReplies: params.includeReplies,
+        maxReplies: params.includeReplies ? params.maxReplies : 0
+      },
+      scope
+    );
+    const loaderCount = await scope.locator(selectors.commentExpander).filter({ hasText: textPatterns.moreComments }).count().catch(() => 0);
+    const raw = filterWrongPost(extracted, params.postId);
+    return { raw, loaderPresent: loaderCount > 0 };
+  }
+};
+function dedupeComments(comments) {
+  const seenIds = /* @__PURE__ */ new Set();
+  const seenIdlessContent = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const comment of comments) {
+    const message = comment.message ?? "";
+    const mediaKey = (comment.attachments ?? []).map((attachment) => attachment.url).join("
");
+    const contentKey = `${comment.authorName ?? ""}\0${message}\0${mediaKey}` + (message.length < 30 && !mediaKey ? `\0${comment.createdAtRaw ?? ""}` : "");
+    if (comment.id != null) {
+      if (seenIds.has(comment.id)) continue;
+      seenIds.add(comment.id);
+    } else {
+      if (seenIdlessContent.has(contentKey)) continue;
+      seenIdlessContent.add(contentKey);
+    }
+    out.push(comment.replies?.length ? { ...comment, replies: dedupeComments(comment.replies) } : comment);
+  }
+  return out;
+}
+function filterWrongPost(comments, postId) {
+  const deduped = dedupeComments(comments);
+  const counts = /* @__PURE__ */ new Map();
+  for (const comment of deduped) {
+    if (!comment.postRefId) continue;
+    counts.set(comment.postRefId, (counts.get(comment.postRefId) ?? 0) + 1);
+  }
+  if (counts.size === 0) return deduped;
+  const urlId = postId && /^\d+$/.test(postId) ? postId : null;
+  let best = urlId && counts.has(urlId) ? urlId : null;
+  if (!best) {
+    let bestCount = 0;
+    let tie = false;
+    for (const [id, count] of counts) {
+      if (count > bestCount) {
+        best = id;
+        bestCount = count;
+        tie = false;
+      } else if (count === bestCount) {
+        tie = true;
+      }
+    }
+    if (tie || !best) {
+      if (urlId && counts.has(urlId)) best = urlId;
+      else return deduped;
+    }
+  }
+  const belongs = (c) => !c.postRefId || c.postRefId === best;
+  return deduped.filter(belongs).map((c) => ({ ...c, replies: c.replies?.filter(belongs) }));
+}
+
+// src/comments/PaginationHandler.ts
+var encodeBase64Url = (input) => Buffer.from(input, "utf8").toString("base64url");
+function encodeCursor(payload) {
+  return encodeBase64Url(JSON.stringify(payload));
+}
+function decodeCursor(cursor) {
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+  } catch {
+    throw new FacebookClientError("Invalid pagination cursor.");
+  }
+  const payload = parsed;
+  if (payload.v !== 1 || typeof payload.skipped !== "number" || payload.skipped < 0) {
+    throw new FacebookClientError("Invalid pagination cursor.");
+  }
+  return { v: 1, skipped: payload.skipped, lastId: payload.lastId ?? null };
+}
+var initialCursor = () => ({ v: 1, skipped: 0, lastId: null });
+function paginate(all, cursor, max, sourceHasMore) {
+  const page = all.slice(cursor.skipped, cursor.skipped + max);
+  const remaining = all.length - (cursor.skipped + page.length);
+  const hasMore = remaining > 0 || sourceHasMore && all.length >= cursor.skipped + max;
+  return {
+    comments: page,
+    hasMore,
+    nextCursor: hasMore ? encodeCursor({
+      v: 1,
+      skipped: cursor.skipped + page.length,
+      lastId: page.length > 0 ? page[page.length - 1]?.id ?? null : cursor.lastId
+    }) : null
+  };
+}
+
+// src/parsers/CommentNormalizer.ts
+var RELATIVE_UNITS = [
+  { pattern: /^(\d+)\s*s(econds?)?$/i, unit: 1e3 },
+  { pattern: /^(\d+)\s*m(in(utes?)?)?$/i, unit: 6e4 },
+  { pattern: /^(\d+)\s*h(ours?)?$/i, unit: 36e5 },
+  { pattern: /^(\d+)\s*d(ays?)?$/i, unit: 864e5 },
+  { pattern: /^(\d+)\s*w(eeks?)?$/i, unit: 6048e5 },
+  { pattern: /^(\d+)\s*(months?)$/i, unit: 2592e6 },
+  { pattern: /^(\d+)\s*y(ea?rs?)?$/i, unit: 31536e6 }
+];
+function parseTimestamp(input, now = /* @__PURE__ */ new Date()) {
+  if (!input) return null;
+  const raw = input.trim().replace(/\s+ago$/i, "").replace(/^(an?)\s+/i, "1 ").replace(/^[a-z]+day,\s*/i, "").trim();
+  if (!raw) return null;
+  if (/\d{4}-\d{2}-\d{2}/.test(raw)) {
+    const iso = new Date(raw);
+    if (!Number.isNaN(iso.getTime())) return iso.toISOString();
+  }
+  if (/^\d{10}$/.test(raw)) return new Date(Number(raw) * 1e3).toISOString();
+  if (/^just now$/i.test(raw)) return now.toISOString();
+  if (/^yesterday/i.test(raw)) {
+    const timeMatch = raw.match(/(\d{1,2}):(\d{2})\s*(am|pm)?/i);
+    const date = new Date(now);
+    date.setDate(date.getDate() - 1);
+    if (timeMatch) {
+      let hours = Number(timeMatch[1]);
+      const minutes = Number(timeMatch[2]);
+      const meridiem = timeMatch[3]?.toLowerCase();
+      if (meridiem === "pm" && hours < 12) hours += 12;
+      if (meridiem === "am" && hours === 12) hours = 0;
+      date.setHours(hours, minutes, 0, 0);
+    }
+    return date.toISOString();
+  }
+  for (const { pattern, unit } of RELATIVE_UNITS) {
+    const match = raw.match(pattern);
+    if (match?.[1]) {
+      return new Date(now.getTime() - Number(match[1]) * unit).toISOString();
+    }
+  }
+  const monthAt = raw.match(
+    /^([A-Za-z]+)\s+(\d{1,2})(?:,?\s+(\d{4}))?(?:\s+(?:at\s+)?(\d{1,2}):(\d{2})\s*(am|pm)?)?/i
+  );
+  if (monthAt) {
+    const month = (/* @__PURE__ */ new Date(`${monthAt[1]} 1, 2000`)).getMonth();
+    if (!Number.isNaN(month)) {
+      const year = monthAt[3] ? Number(monthAt[3]) : now.getFullYear();
+      const date = new Date(year, month, Number(monthAt[2]), 0, 0, 0, 0);
+      if (monthAt[4]) {
+        let hours = Number(monthAt[4]);
+        const meridiem = monthAt[6]?.toLowerCase();
+        if (meridiem === "pm" && hours < 12) hours += 12;
+        if (meridiem === "am" && hours === 12) hours = 0;
+        date.setHours(hours, Number(monthAt[5] ?? 0), 0, 0);
+      }
+      if (!monthAt[3] && date.getTime() > now.getTime()) date.setFullYear(year - 1);
+      return date.toISOString();
+    }
+  }
+  const dayMonth = raw.match(
+    /^(\d{1,2})\s+([A-Za-z]+),?\s+(\d{4})(?:\s+(?:at\s+)?(\d{1,2}):(\d{2})\s*(am|pm)?)?/i
+  );
+  if (dayMonth) {
+    const month = (/* @__PURE__ */ new Date(`${dayMonth[2]} 1, 2000`)).getMonth();
+    if (!Number.isNaN(month)) {
+      let hours = Number(dayMonth[4] ?? 0);
+      const meridiem = dayMonth[6]?.toLowerCase();
+      if (meridiem === "pm" && hours < 12) hours += 12;
+      if (meridiem === "am" && hours === 12) hours = 0;
+      const date = new Date(
+        Number(dayMonth[3]),
+        month,
+        Number(dayMonth[1]),
+        hours,
+        Number(dayMonth[5] ?? 0)
+      );
+      if (!Number.isNaN(date.getTime())) return date.toISOString();
+    }
+  }
+  return null;
+}
+function normalizeComment(raw, parentId = null, now = /* @__PURE__ */ new Date()) {
+  const replies = (raw.replies ?? []).map((reply) => normalizeComment(reply, raw.id ?? null, now));
+  return {
+    id: raw.id ?? null,
+    author: {
+      id: raw.authorId ?? null,
+      name: raw.authorName ?? null,
+      profileUrl: raw.authorProfileUrl ?? null,
+      avatarUrl: raw.authorAvatarUrl ?? null
+    },
+    message: raw.message ?? "",
+    createdAt: parseTimestamp(raw.createdAtRaw, now),
+    ...raw.attachments?.length ? { attachments: raw.attachments } : {},
+    reactions: { total: raw.reactionsTotal ?? null },
+    parentId,
+    ...replies.length > 0 ? { replies } : {}
+  };
+}
+
+// src/utils/url.ts
+var FB_HOST = /^(?:[a-z0-9-]+\.)*(?:facebook\.com|fb\.com|fb\.watch)$/i;
+function parseFacebookPostUrl(input) {
+  let parsed;
+  try {
+    parsed = new URL(input.trim());
+  } catch {
+    throw new FacebookClientError(`Invalid URL: "${input.trim()}"`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new FacebookClientError(`URL must use http or https: "${parsed.protocol}"`);
+  }
+  if (!FB_HOST.test(parsed.hostname)) {
+    throw new FacebookClientError(`Not a Facebook URL: "${parsed.hostname}"`);
+  }
+  const path = parsed.pathname;
+  const segments = path.split("/").filter(Boolean);
+  let postId = null;
+  let groupId = null;
+  if (segments[0] === "groups" && segments.length >= 4) {
+    groupId = segments[1] ?? null;
+    const kindIndex = segments.findIndex((s) => s === "posts" || s === "permalink");
+    if (kindIndex !== -1 && segments.length > kindIndex + 1) {
+      postId = segments[kindIndex + 1] ?? null;
+    }
+  } else if (segments.length >= 2) {
+    const kind = segments[segments.length - 2];
+    if (kind && ["posts", "videos", "reel", "reels", "p", "photo", "comments", "share", "v", "r"].includes(
+      kind
+    )) {
+      postId = segments[segments.length - 1] ?? null;
+    } else if (segments[0] === "permalink.php") {
+      postId = null;
+    } else {
+      const last = segments[segments.length - 1];
+      if (last && /^(?:pfbid|\d{6,})/i.test(last)) postId = last;
+    }
+  }
+  if (parsed.searchParams.has("story_fbid")) {
+    postId = parsed.searchParams.get("story_fbid");
+  }
+  const fbid = parsed.searchParams.get("fbid");
+  if (!postId && fbid) postId = fbid;
+  const videoId = parsed.searchParams.get("v");
+  if (!postId && videoId) postId = videoId;
+  return { url: parsed.toString(), postId, groupId };
+}
+
+// src/parsers/PostParser.ts
+function parsePost(page, requestedUrl) {
+  const source = page.url().startsWith("http") ? page.url() : requestedUrl;
+  try {
+    const parsed = parseFacebookPostUrl(source);
+    return { id: parsed.postId, url: parsed.url };
+  } catch {
+    return { id: null, url: requestedUrl };
+  }
+}
+
+// src/utils/logger.ts
+var SENSITIVE_KEY = /cookie|token|secret|password|passwd|storage.?state|authorization|\bxs\b|\bc_user\b|\bsb\b|\bfr\b/i;
+var MAX_DEPTH = 6;
+function redact(value, depth = 0) {
+  if (depth > MAX_DEPTH) return "[TRUNCATED]";
+  if (Array.isArray(value)) return value.map((item) => redact(item, depth + 1));
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [key, val] of Object.entries(value)) {
+      out[key] = SENSITIVE_KEY.test(key) ? "[REDACTED]" : redact(val, depth + 1);
+    }
+    return out;
+  }
+  if (typeof value === "string" && value.length > 2e3) {
+    return `${value.slice(0, 2e3)}...[truncated]`;
+  }
+  return value;
+}
+var LEVEL_ORDER = {
+  silent: 0,
+  error: 1,
+  warn: 2,
+  info: 3,
+  debug: 4
+};
+function createConsoleLogger(level = "warn") {
+  const threshold = LEVEL_ORDER[level];
+  const emit = (allowed, sink, args) => {
+    if (threshold >= allowed) sink(args.map((arg) => redact(arg)));
+  };
+  return {
+    debug: (msg, ...args) => emit(LEVEL_ORDER.debug, console.debug, [msg, ...args]),
+    info: (msg, ...args) => emit(LEVEL_ORDER.info, console.info, [msg, ...args]),
+    warn: (msg, ...args) => emit(LEVEL_ORDER.warn, console.warn, [msg, ...args]),
+    error: (msg, ...args) => emit(LEVEL_ORDER.error, console.error, [msg, ...args])
+  };
+}
+
+// src/client/FacebookCommentsClient.ts
+var DEFAULT_MAX_COMMENTS = 50;
+var DEFAULT_MAX_REPLIES = 20;
+function trimReplies(comment, maxReplies) {
+  if (!comment.replies || comment.replies.length === 0) return comment;
+  const replies = comment.replies.slice(0, maxReplies).map((reply) => trimReplies(reply, maxReplies));
+  return { ...comment, replies };
+}
+var FacebookCommentsClient = class {
+  constructor(options) {
+    this.options = options;
+    this.logger = options.logger ?? createConsoleLogger("warn");
+    this.browserManager = new BrowserManager(options.browser);
+  }
+  options;
+  browserManager;
+  logger;
+  /**
+   * Interactive login helper: opens a visible browser, waits for you to log in
+   * manually, then exports the storage state. Never enters credentials for you.
+   */
+  static async login(loginOptions) {
+    const timeoutMs = loginOptions.timeoutMs ?? 3e5;
+    const browser = await chromium2.launch({ headless: false });
+    try {
+      const context = await browser.newContext();
+      const page = await context.newPage();
+      await page.goto("https://www.facebook.com/", { waitUntil: "domcontentloaded" });
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() < deadline) {
+        const cookies = await context.cookies("https://www.facebook.com");
+        if (cookies.some((cookie) => cookie.name === "c_user")) {
+          const targetDir = dirname(loginOptions.outputPath);
+          if (targetDir && !existsSync(targetDir)) {
+            await mkdir(targetDir, { recursive: true });
+          }
+          await context.storageState({ path: loginOptions.outputPath });
+          return;
+        }
+        await page.waitForTimeout(1500);
+      }
+      throw new FacebookAuthenticationError(
+        `Login timed out after ${Math.round(timeoutMs / 1e3)}s \u2014 no Facebook session was established. Try again and finish logging in within the window.`
+      );
+    } finally {
+      await browser.close().catch(() => {
+      });
+    }
+  }
+  /** Fetch and normalize comments for one post URL. */
+  async getComments(options) {
+    const parsedUrl = parseFacebookPostUrl(options.url);
+    const maxComments = options.maxComments ?? DEFAULT_MAX_COMMENTS;
+    const maxReplies = options.maxReplies ?? DEFAULT_MAX_REPLIES;
+    const includeReplies = options.includeReplies ?? false;
+    const cursor = options.cursor ? decodeCursor(options.cursor) : initialCursor();
+    const timeoutMs = options.timeout ?? this.options.browser?.timeoutMs ?? 3e4;
+    const provider = createSessionProvider(this.options.session);
+    const storageState = await provider.resolve();
+    if (!hasAuthCookies(storageState)) {
+      throw new FacebookAuthenticationError(
+        "The configured session contains no Facebook auth cookies (c_user/xs). Capture a fresh session with `fb-comments login`."
+      );
+    }
+    const headless = options.headless ?? this.options.browser?.headless ?? true;
+    const browser = await this.browserManager.launch(headless);
+    const context = await createLoggedInContext(browser, { storageState, timeoutMs });
+    try {
+      const page = await context.newPage();
+      this.logger.debug(`Navigating to ${parsedUrl.url}`);
+      await page.goto(parsedUrl.url, { waitUntil: "domcontentloaded", timeout: timeoutMs });
+      const problem = await detectPageProblem(page);
+      if (problem) throw problem;
+      await page.waitForSelector(`${selectors.commentArticle}, ${selectors.commentOpenerControls}`, {
+        timeout: Math.min(1e4, timeoutMs)
+      }).catch(() => null);
+      const fetcher = new CommentFetcher(
+        new ExtractorPipeline([
+          new AccessibleDomExtractor(),
+          new StructuredDataExtractor(),
+          new FallbackDomExtractor()
+        ])
+      );
+      const outcome = await fetcher.fetch(page, {
+        maxComments,
+        includeReplies,
+        maxReplies,
+        skipped: cursor.skipped,
+        postId: parsedUrl.postId
+      });
+      const all = outcome.raw.map((raw) => normalizeComment(raw));
+      const pageResult = paginate(all, cursor, maxComments, outcome.loaderPresent);
+      this.logger.info(
+        `Extracted ${pageResult.comments.length} comments (hasMore: ${pageResult.hasMore})`
+      );
+      return {
+        post: parsePost(page, parsedUrl.url),
+        comments: includeReplies ? pageResult.comments.map((comment) => trimReplies(comment, maxReplies)) : pageResult.comments,
+        pagination: pageResult
+      };
+    } finally {
+      await context.close().catch(() => {
+      });
+    }
+  }
+  /**
+   * Cheap session check: resolves the session, verifies auth cookies, and
+   * confirms Facebook still accepts them. Never throws for session problems —
+   * inspect the returned flags instead.
+   */
+  async validateSession() {
+    let storageState;
+    try {
+      storageState = await createSessionProvider(this.options.session).resolve();
+    } catch (error) {
+      if (error instanceof FacebookClientError) {
+        return { valid: false, authenticated: false };
+      }
+      throw error;
+    }
+    if (!hasAuthCookies(storageState)) {
+      return { valid: true, authenticated: false };
+    }
+    const browser = await this.browserManager.launch(
+      this.options.browser?.headless ?? true
+    );
+    const context = await createLoggedInContext(browser, {
+      storageState,
+      timeoutMs: this.options.browser?.timeoutMs ?? 3e4
+    });
+    try {
+      const page = await context.newPage();
+      const authenticated = await checkAuthenticatedOnPage(context, page);
+      return {
+        valid: true,
+        authenticated,
+        user: { name: null }
+      };
+    } finally {
+      await context.close().catch(() => {
+      });
+    }
+  }
+  async close() {
+    await this.browserManager.close();
+  }
+};
+
+// src/cli.ts
+var USAGE = `fb-comments \u2014 fetch Facebook post comments with an authorized session
+
+Usage:
+  fb-comments login [--output <path>]          Interactive login (manual, headed browser)
+  fb-comments comments <post-url> [flags]      Fetch comments
+
+Flags:
+  --session <path>    Storage-state file (default: ./facebook-session.json or $FACEBOOK_STORAGE_STATE)
+  --replies           Include reply threads
+  --limit <n>         Max top-level comments (default 50)
+  --max-replies <n>   Max replies per comment (default 20)
+  --timeout <ms>      Navigation timeout (default 30000)
+  --headless          Run headless even if the client default says otherwise
+  --json              Print raw JSON result
+  -h, --help          Show this help
+`;
+function flagValue(args, name) {
+  const index = args.indexOf(name);
+  return index !== -1 ? args[index + 1] : void 0;
+}
+function hasFlag(args, name) {
+  return args.includes(name);
+}
+function resolveSession(cliSessionPath) {
+  if (cliSessionPath) return { type: "file", path: cliSessionPath };
+  if (process.env.FACEBOOK_STORAGE_STATE) {
+    return { type: "env", envKey: "FACEBOOK_STORAGE_STATE" };
+  }
+  if (existsSync2("facebook-session.json")) {
+    return { type: "file", path: "facebook-session.json" };
+  }
+  console.error(
+    "No session found. Run `fb-comments login` or set FACEBOOK_STORAGE_STATE."
+  );
+  process.exit(1);
+}
+function printHuman(comments, hasMore) {
+  if (comments.length === 0) {
+    console.log("No comments found.");
+    return;
+  }
+  for (const comment of comments) {
+    const author = comment.author.name ?? "unknown";
+    const time = comment.createdAt ?? "unknown time";
+    const reactions = comment.reactions.total !== null ? ` [${comment.reactions.total} reactions]` : "";
+    console.log(`
+${author} (${time})${reactions}
+  ${comment.message.replace(/\n/g, "\n  ")}`);
+    for (const reply of comment.replies ?? []) {
+      const replyAuthor = reply.author.name ?? "unknown";
+      console.log(`    > ${replyAuthor}: ${reply.message.replace(/\n/g, "\n      ")}`);
+    }
+  }
+  console.log(`
+${comments.length} comment(s)${hasMore ? " \u2014 more available, use the next cursor" : ""}`);
+}
+async function run() {
+  const argv = process.argv.slice(2);
+  const [command, ...rest] = argv;
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    console.log(USAGE);
+    return;
+  }
+  if (command === "login") {
+    const output = flagValue(rest, "--output") ?? "./facebook-session.json";
+    console.log(`Opening Facebook for manual login. Session will be saved to: ${output}`);
+    await FacebookCommentsClient.login({ outputPath: output });
+    console.log("Session saved.");
+    return;
+  }
+  if (command === "comments") {
+    const url = rest.find((arg) => arg.startsWith("http"));
+    if (!url) {
+      console.error("A post URL is required:\n  fb-comments comments <post-url>");
+      process.exit(1);
+    }
+    const session = resolveSession(flagValue(rest, "--session"));
+    const client = new FacebookCommentsClient({ session });
+    try {
+      const result = await client.getComments({
+        url,
+        includeReplies: hasFlag(rest, "--replies"),
+        maxComments: Number(flagValue(rest, "--limit") ?? 50),
+        maxReplies: Number(flagValue(rest, "--max-replies") ?? 20),
+        timeout: Number(flagValue(rest, "--timeout") ?? 3e4),
+        headless: true
+      });
+      if (hasFlag(rest, "--json")) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        printHuman(result.comments, result.pagination.hasMore);
+      }
+    } finally {
+      await client.close().catch(() => {
+      });
+    }
+    return;
+  }
+  console.error(`Unknown command: ${command}
+`);
+  console.log(USAGE);
+  process.exit(1);
+}
+run().catch((error) => {
+  if (error instanceof FacebookClientError) {
+    console.error(`${error.name}: ${error.message}`);
+  } else {
+    console.error(error);
+  }
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map