fastbrowser_cli 1.0.37 → 1.0.39

package/dist/contribs/linkedin_cli/src/libs/linkedin_recent_posts_helper.js

@@ -0,0 +1,885 @@
+// npm imports
+import { A11yQuery, A11yTree } from 'a11y_parse';
+const TIMESTAMP_SHORT_REGEXP = /^(\d+[smhdw]|\d+\s+(?:second|minute|hour|day|week|month|year)s?)\s*•/i;
+const TIMESTAMP_LONG_REGEXP = /^\d+\s+(?:second|minute|hour|day|week|month|year)s?\s+ago\b/i;
+const ACTIVITY_ID_REGEXP = /urn:li:activity:(\d+)/;
+const COUNT_LEADING_REGEXP = /^(\d+(?:[.,]\d+)?)/;
+const ANALYTICS_LINK_NAME_REGEXP = /^(\d+(?:[.,]\d+)?)\s+impressions/i;
+const NOISE_LITERALS = new Set([
+    '·',
+    '•',
+    'Like',
+    'Comment',
+    'Repost',
+    'Send',
+    'Boost',
+    'Follow',
+    'hashtag',
+    'Activate to view larger image,',
+    'See content credentials',
+    '…more',
+    '…',
+    'Show translation',
+    'reposted this',
+    '• You',
+    '• 1st',
+    '• 2nd',
+    '• 3rd',
+    '• 3rd+',
+    'Verified',
+    'Premium',
+    'graphical user interface',
+    'graphical user interface, application',
+    'No alternative text description for this image',
+]);
+const NOISE_PREFIXES = [
+    'Promote this post to reach people',
+    'Activate to view larger image',
+    'Verified •',
+    'Premium •',
+    '• ',
+    'Visible to anyone',
+    'Translated from ',
+    'This post is not eligible',
+    'Open control menu',
+    'View ',
+    'Loaded ',
+];
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+export class LinkedinRecentPostsHelper {
+    ///////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////
+    //
+    ///////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////
+    static parsePosts(rawSnapshot, viewingSlug) {
+        const treeText = LinkedinRecentPostsHelper.extractAxTreeText(rawSnapshot);
+        if (treeText.length === 0) {
+            return [];
+        }
+        const root = A11yTree.parse(treeText);
+        const headings = A11yQuery.querySelectorAll(root, 'heading[level="2"]');
+        const seen = new Set();
+        const posts = [];
+        for (const heading of headings) {
+            if (heading.name === undefined) {
+                continue;
+            }
+            if (heading.name.startsWith('Feed post number ') === false) {
+                continue;
+            }
+            const container = LinkedinRecentPostsHelper.walkUpToPostContainer(heading);
+            if (container === undefined) {
+                continue;
+            }
+            if (seen.has(container.uid) === true) {
+                continue;
+            }
+            seen.add(container.uid);
+            posts.push(LinkedinRecentPostsHelper.extractPost(container, heading, viewingSlug));
+        }
+        return posts;
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////
+    //
+    ///////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////
+    static formatMarkdown(posts) {
+        if (posts.length === 0) {
+            return '_no posts found_';
+        }
+        const sections = [];
+        for (const post of posts) {
+            sections.push(LinkedinRecentPostsHelper.formatPostMarkdown(post));
+        }
+        return sections.join('\n\n---\n\n');
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////
+    //	Tree filtering / post container walk
+    ///////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////
+    static extractAxTreeText(rawOutput) {
+        const lines = [];
+        for (const line of rawOutput.split('\n')) {
+            if (/^\s*uid=/.test(line) === true) {
+                lines.push(line);
+            }
+        }
+        return lines.join('\n');
+    }
+    static walkUpToPostContainer(heading) {
+        let cursor = heading.parent;
+        for (let depth = 0; depth < 16; depth++) {
+            if (cursor === undefined) {
+                break;
+            }
+            if (cursor.role === 'listitem') {
+                return cursor;
+            }
+            cursor = cursor.parent;
+        }
+        return undefined;
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////
+    //	Per-post extraction
+    ///////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////
+    static extractPost(container, heading, viewingSlug) {
+        const repost = LinkedinRecentPostsHelper.detectRepost(container);
+        const author = LinkedinRecentPostsHelper.extractAuthor(container);
+        const timestamp = LinkedinRecentPostsHelper.extractTimestamp(container);
+        const activity = LinkedinRecentPostsHelper.extractActivity(container);
+        const counts = LinkedinRecentPostsHelper.extractCounts(container);
+        const mediaTypes = LinkedinRecentPostsHelper.extractMedia(container);
+        const text = LinkedinRecentPostsHelper.extractBodyText(container, heading, {
+            authorDisplayName: author.displayName,
+            authorHeadline: author.headline,
+        });
+        return {
+            url: activity !== null ? activity.url : null,
+            activityId: activity !== null ? activity.activityId : null,
+            authorSlug: author.slug,
+            authorDisplayName: author.displayName,
+            authorHeadline: author.headline,
+            timestamp: timestamp.timestamp,
+            isEdited: timestamp.isEdited,
+            text,
+            isRepost: repost.isRepost,
+            repostedBy: repost.isRepost === true ? (repost.repostedBy ?? viewingSlug) : null,
+            reactionCount: counts.reactionCount,
+            commentCount: counts.commentCount,
+            repostCount: counts.repostCount,
+            impressionCount: counts.impressionCount,
+            hasMedia: mediaTypes.length > 0,
+            mediaTypes,
+        };
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////
+    //	Repost detection
+    ///////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////
+    static detectRepost(container) {
+        const repostedNode = LinkedinRecentPostsHelper.findRepostedThis(container);
+        if (repostedNode === undefined) {
+            return { isRepost: false, repostedBy: null };
+        }
+        let repostedBy = null;
+        let cursor = repostedNode.parent;
+        for (let depth = 0; depth < 4; depth++) {
+            if (cursor === undefined) {
+                break;
+            }
+            const link = A11yQuery.querySelector(cursor, 'link[url^="/in/"]');
+            if (link !== undefined) {
+                const url = link.attributes['url'];
+                if (url !== undefined) {
+                    repostedBy = LinkedinRecentPostsHelper.slugFromInUrl(url);
+                }
+                break;
+            }
+            cursor = cursor.parent;
+        }
+        return { isRepost: true, repostedBy };
+    }
+    static findRepostedThis(container) {
+        for (const node of A11yTree.walk(container)) {
+            if (node.role !== 'StaticText') {
+                continue;
+            }
+            if (node.name === undefined) {
+                continue;
+            }
+            if (node.name.trim() === 'reposted this') {
+                return node;
+            }
+        }
+        return undefined;
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////
+    //	Author extraction
+    ///////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////
+    static extractAuthor(container) {
+        const authorLink = LinkedinRecentPostsHelper.findAuthorLink(container);
+        if (authorLink === undefined) {
+            return { slug: null, displayName: null, headline: null };
+        }
+        const url = authorLink.attributes['url'];
+        const slug = url !== undefined ? LinkedinRecentPostsHelper.slugFromMiniProfileUrl(url) : null;
+        const headerScope = LinkedinRecentPostsHelper.findAuthorHeaderScope(authorLink);
+        const values = LinkedinRecentPostsHelper.collectGenericValues(headerScope);
+        const dedup = LinkedinRecentPostsHelper.dedupeAdjacent(values);
+        const filtered = LinkedinRecentPostsHelper.filterAuthorValues(dedup);
+        const displayName = filtered.length >= 1 ? filtered[0] : null;
+        const headline = filtered.length >= 2 ? filtered[1] : null;
+        return { slug, displayName, headline };
+    }
+    static findAuthorLink(container) {
+        const links = A11yQuery.querySelectorAll(container, 'link[url*="miniProfileUrn"]');
+        for (const link of links) {
+            const name = link.name;
+            if (name === undefined) {
+                continue;
+            }
+            if (name.startsWith('View ') === true && name.endsWith('graphic link') === true) {
+                return link;
+            }
+        }
+        if (links.length > 0) {
+            return links[0];
+        }
+        return undefined;
+    }
+    static findAuthorHeaderScope(authorLink) {
+        // The author's display name, connection indicator, headline, and timestamp all
+        // live in a sibling generic of the profile link. Walk up two levels — the
+        // profile link is wrapped twice — to land on the generic that contains all of them.
+        let cursor = authorLink.parent;
+        for (let depth = 0; depth < 3; depth++) {
+            if (cursor === undefined) {
+                break;
+            }
+            cursor = cursor.parent;
+        }
+        return cursor ?? authorLink;
+    }
+    static collectGenericValues(node) {
+        const out = [];
+        for (const descendant of A11yTree.walk(node)) {
+            if (descendant.role !== 'generic') {
+                continue;
+            }
+            const value = descendant.attributes['value'];
+            if (value === undefined) {
+                continue;
+            }
+            const trimmed = value.trim();
+            if (trimmed.length === 0) {
+                continue;
+            }
+            out.push(trimmed);
+        }
+        return out;
+    }
+    static dedupeAdjacent(values) {
+        const out = [];
+        for (const value of values) {
+            if (out.length > 0 && out[out.length - 1] === value) {
+                continue;
+            }
+            out.push(value);
+        }
+        return out;
+    }
+    static filterAuthorValues(values) {
+        const out = [];
+        for (const value of values) {
+            if (LinkedinRecentPostsHelper.isAuthorNoiseValue(value) === true) {
+                continue;
+            }
+            out.push(value);
+        }
+        return out;
+    }
+    static isAuthorNoiseValue(value) {
+        if (value.startsWith('•') === true) {
+            return true;
+        }
+        if (value.startsWith('Verified •') === true) {
+            return true;
+        }
+        if (value.startsWith('Premium •') === true) {
+            return true;
+        }
+        if (TIMESTAMP_SHORT_REGEXP.test(value) === true) {
+            return true;
+        }
+        if (TIMESTAMP_LONG_REGEXP.test(value) === true) {
+            return true;
+        }
+        if (value === 'Visit my website') {
+            return true;
+        }
+        if (value === 'Follow') {
+            return true;
+        }
+        if (value === 'You') {
+            return true;
+        }
+        if (/^\d+\s+followers$/.test(value) === true) {
+            return true;
+        }
+        // Connection-degree indicators: "1st", "2nd", "3rd", "3rd+".
+        if (/^\d+(st|nd|rd|th)\+?$/.test(value) === true) {
+            return true;
+        }
+        return false;
+    }
+    static slugFromMiniProfileUrl(url) {
+        const match = url.match(/\/in\/([^/?#]+)/);
+        if (match === null) {
+            return null;
+        }
+        return match[1];
+    }
+    static slugFromInUrl(url) {
+        const match = url.match(/^\/in\/([^/?#]+)/);
+        if (match === null) {
+            return null;
+        }
+        return match[1];
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////
+    //	Timestamp extraction
+    ///////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////
+    static extractTimestamp(container) {
+        // Prefer the short StaticText (e.g. "1d •" / "12h • Edited •"); fall back to
+        // the long generic value (e.g. "1 day ago • Visible to anyone…").
+        for (const node of A11yTree.walk(container)) {
+            if (node.role !== 'StaticText') {
+                continue;
+            }
+            if (node.name === undefined) {
+                continue;
+            }
+            const trimmed = node.name.trim();
+            if (TIMESTAMP_SHORT_REGEXP.test(trimmed) === false) {
+                continue;
+            }
+            return LinkedinRecentPostsHelper.normalizeTimestamp(trimmed);
+        }
+        for (const node of A11yTree.walk(container)) {
+            if (node.role !== 'generic') {
+                continue;
+            }
+            const value = node.attributes['value'];
+            if (value === undefined) {
+                continue;
+            }
+            const trimmed = value.trim();
+            if (TIMESTAMP_LONG_REGEXP.test(trimmed) === false) {
+                continue;
+            }
+            return LinkedinRecentPostsHelper.normalizeTimestamp(trimmed);
+        }
+        return { timestamp: null, isEdited: false };
+    }
+    static normalizeTimestamp(raw) {
+        const isEdited = /\bEdited\b/.test(raw);
+        // Drop the trailing " • Edited • Visible…" segment — keep just the time portion.
+        const segments = raw.split('•').map((s) => s.trim()).filter((s) => s.length > 0);
+        let timestamp = segments.length > 0 ? segments[0] : raw.trim();
+        // If long form ("1 day ago"), keep as-is. If short form ("1d"), keep as-is.
+        timestamp = timestamp.replace(/\s+/g, ' ').trim();
+        return { timestamp, isEdited };
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////
+    //	Activity URL / id extraction
+    ///////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////
+    static extractActivity(container) {
+        const analyticsLink = A11yQuery.querySelector(container, 'link[url^="/analytics/post-summary/urn:li:activity:"]');
+        if (analyticsLink !== undefined) {
+            const result = LinkedinRecentPostsHelper.activityFromUrl(analyticsLink.attributes['url']);
+            if (result !== null) {
+                return result;
+            }
+        }
+        const updateLinks = A11yQuery.querySelectorAll(container, 'link[url^="/feed/update/urn:li:activity:"]');
+        for (const link of updateLinks) {
+            const result = LinkedinRecentPostsHelper.activityFromUrl(link.attributes['url']);
+            if (result !== null) {
+                return result;
+            }
+        }
+        return null;
+    }
+    static activityFromUrl(url) {
+        if (url === undefined) {
+            return null;
+        }
+        const match = url.match(ACTIVITY_ID_REGEXP);
+        if (match === null) {
+            return null;
+        }
+        const activityId = match[1];
+        return {
+            activityId,
+            url: `https://www.linkedin.com/feed/update/urn:li:activity:${activityId}/`,
+        };
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////
+    //	Counts
+    ///////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////
+    static extractCounts(container) {
+        return {
+            reactionCount: LinkedinRecentPostsHelper.extractReactionCount(container),
+            commentCount: LinkedinRecentPostsHelper.extractCommentCount(container),
+            repostCount: LinkedinRecentPostsHelper.extractRepostCount(container),
+            impressionCount: LinkedinRecentPostsHelper.extractImpressionCount(container),
+        };
+    }
+    static extractReactionCount(container) {
+        // The reactions list is `list > listitem > button` where the count lives in a
+        // nested `generic[value]` matching /^\d+$/ (e.g. button > generic > generic[value="4"]).
+        // Pick the first one. The button's name (e.g. "1 reaction" or "Julien and 3 others")
+        // is also a fallback when the value isn't present.
+        const buttons = A11yQuery.querySelectorAll(container, 'list > listitem > button');
+        for (const button of buttons) {
+            for (const descendant of A11yTree.walk(button)) {
+                if (descendant.uid === button.uid) {
+                    continue;
+                }
+                if (descendant.role !== 'generic') {
+                    continue;
+                }
+                const value = descendant.attributes['value'];
+                if (value === undefined) {
+                    continue;
+                }
+                const trimmed = value.trim();
+                if (/^\d+$/.test(trimmed) === false) {
+                    continue;
+                }
+                const parsed = parseInt(trimmed, 10);
+                if (Number.isNaN(parsed) === true) {
+                    continue;
+                }
+                return parsed;
+            }
+            if (button.name !== undefined) {
+                const match = button.name.match(/^(\d+)\s+reactions?$/i);
+                if (match !== null) {
+                    const parsed = parseInt(match[1], 10);
+                    if (Number.isNaN(parsed) === false) {
+                        return parsed;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    static extractCommentCount(container) {
+        return LinkedinRecentPostsHelper.findLeadingCount(container, /\bcomments?\s+on\b/i);
+    }
+    static extractRepostCount(container) {
+        return LinkedinRecentPostsHelper.findLeadingCount(container, /\breposts?\s+of\b/i);
+    }
+    static findLeadingCount(container, namePattern) {
+        for (const node of A11yTree.walk(container)) {
+            if (node.role !== 'button') {
+                continue;
+            }
+            if (node.name === undefined) {
+                continue;
+            }
+            if (namePattern.test(node.name) === false) {
+                continue;
+            }
+            const match = node.name.match(COUNT_LEADING_REGEXP);
+            if (match === null) {
+                continue;
+            }
+            const cleaned = match[1].replace(/[.,]/g, '');
+            const parsed = parseInt(cleaned, 10);
+            if (Number.isNaN(parsed) === true) {
+                continue;
+            }
+            return parsed;
+        }
+        return null;
+    }
+    static extractImpressionCount(container) {
+        const link = A11yQuery.querySelector(container, 'link[url^="/analytics/post-summary/urn:li:activity:"]');
+        if (link === undefined) {
+            return null;
+        }
+        if (link.name === undefined) {
+            return null;
+        }
+        const match = link.name.match(ANALYTICS_LINK_NAME_REGEXP);
+        if (match === null) {
+            return null;
+        }
+        const cleaned = match[1].replace(/[.,]/g, '');
+        const parsed = parseInt(cleaned, 10);
+        if (Number.isNaN(parsed) === true) {
+            return null;
+        }
+        return parsed;
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////
+    //	Media detection
+    ///////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////
+    static extractMedia(container) {
+        const media = [];
+        const hasImage = A11yQuery.querySelector(container, 'button[name^="Activate to view larger image"]') !== undefined;
+        if (hasImage === true) {
+            media.push('image');
+        }
+        const hasDocument = LinkedinRecentPostsHelper.detectDocumentCarousel(container);
+        if (hasDocument === true) {
+            media.push('document');
+        }
+        const hasVideo = LinkedinRecentPostsHelper.detectVideo(container);
+        if (hasVideo === true) {
+            media.push('video');
+        }
+        const hasArticle = LinkedinRecentPostsHelper.detectArticleShare(container);
+        if (hasArticle === true) {
+            media.push('article');
+        }
+        return media;
+    }
+    static detectDocumentCarousel(container) {
+        for (const node of A11yTree.walk(container)) {
+            if (node.role !== 'iframe') {
+                continue;
+            }
+            const progress = A11yQuery.querySelector(node, 'progressbar');
+            if (progress !== undefined) {
+                return true;
+            }
+        }
+        return false;
+    }
+    static detectVideo(container) {
+        for (const node of A11yTree.walk(container)) {
+            if (node.role !== 'button') {
+                continue;
+            }
+            if (node.name === undefined) {
+                continue;
+            }
+            if (/play\s+video/i.test(node.name) === true) {
+                return true;
+            }
+        }
+        return false;
+    }
+    static detectArticleShare(container) {
+        // LinkedIn renders article previews two ways:
+        //   (a) a nested `article` element (long-form post / pulse article)
+        //   (b) an outbound `link[url^="http"]` paired with a sibling `generic[value]`
+        //       containing the publisher domain (newsletter / blog share)
+        const outerArticle = A11yQuery.querySelector(container, 'article');
+        const articles = A11yQuery.querySelectorAll(container, 'article');
+        for (const article of articles) {
+            if (outerArticle !== undefined && article.uid === outerArticle.uid) {
+                continue;
+            }
+            return true;
+        }
+        const links = A11yQuery.querySelectorAll(container, 'link');
+        for (const link of links) {
+            const url = link.attributes['url'];
+            if (url === undefined) {
+                continue;
+            }
+            if (url.startsWith('http://') === false && url.startsWith('https://') === false) {
+                continue;
+            }
+            if (LinkedinRecentPostsHelper.isInternalUrl(url) === true) {
+                continue;
+            }
+            if (LinkedinRecentPostsHelper.linkLooksLikeShareCard(link) === true) {
+                return true;
+            }
+        }
+        return false;
+    }
+    static isInternalUrl(url) {
+        if (url.startsWith('https://www.linkedin.com/') === true) {
+            return true;
+        }
+        if (url.startsWith('https://lnkd.in/') === true) {
+            return true;
+        }
+        return false;
+    }
+    static linkLooksLikeShareCard(link) {
+        for (const child of link.children) {
+            if (child.role !== 'generic') {
+                continue;
+            }
+            for (const grand of child.children) {
+                if (grand.role !== 'generic') {
+                    continue;
+                }
+                const value = grand.attributes['value'];
+                if (value === undefined) {
+                    continue;
+                }
+                if (/^[a-z0-9-]+(?:\.[a-z0-9-]+)+$/i.test(value.trim()) === true) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////
+    //	Body text extraction
+    ///////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////
+    static extractBodyText(container, heading, header) {
+        const skipUids = LinkedinRecentPostsHelper.collectBodySkipUids(container, heading);
+        const noise = new Set(NOISE_LITERALS);
+        if (header.authorDisplayName !== null) {
+            noise.add(header.authorDisplayName);
+        }
+        if (header.authorHeadline !== null) {
+            noise.add(header.authorHeadline);
+        }
+        const fragments = [];
+        for (const node of A11yTree.walk(container)) {
+            if (skipUids.has(node.uid) === true) {
+                continue;
+            }
+            const fragment = LinkedinRecentPostsHelper.fragmentForNode(node);
+            if (fragment === null) {
+                continue;
+            }
+            if (noise.has(fragment) === true) {
+                continue;
+            }
+            if (LinkedinRecentPostsHelper.matchesNoisePrefix(fragment) === true) {
+                continue;
+            }
+            fragments.push(fragment);
+        }
+        const deduped = LinkedinRecentPostsHelper.dedupeAdjacent(fragments);
+        return deduped.join(' ').replace(/\s+/g, ' ').trim();
+    }
+    static collectBodySkipUids(container, heading) {
+        const skipRoots = [];
+        // Skip the heading subtree itself.
+        skipRoots.push(heading);
+        // Skip the author header block — it's the second child of the heading's parent.
+        const headingParent = heading.parent;
+        if (headingParent !== undefined) {
+            const headingIdx = headingParent.children.indexOf(heading);
+            if (headingIdx !== -1) {
+                const next = headingParent.children[headingIdx + 1];
+                if (next !== undefined && next.children.length > 0) {
+                    const headerBlock = next.children[0];
+                    skipRoots.push(headerBlock);
+                }
+            }
+        }
+        // Repost banner — the StaticText "reposted this" sits in a generic that
+        // includes the page-owner's profile link. Skip the surrounding generic so the
+        // link name doesn't leak into the body text.
+        const repostedNode = LinkedinRecentPostsHelper.findRepostedThis(container);
+        if (repostedNode !== undefined) {
+            let cursor = repostedNode.parent;
+            for (let depth = 0; depth < 3; depth++) {
+                if (cursor === undefined) {
+                    break;
+                }
+                const ownerLink = A11yQuery.querySelector(cursor, 'link[url^="/in/"]');
+                const photoLink = A11yQuery.querySelector(cursor, 'link[url*="miniProfileUrn"]');
+                if (ownerLink !== undefined && photoLink !== undefined) {
+                    skipRoots.push(cursor);
+                    break;
+                }
+                cursor = cursor.parent;
+            }
+        }
+        // Skip subtrees rooted at any button, list, iframe, or nested article.
+        const outerArticle = A11yQuery.querySelector(container, 'article');
+        for (const node of A11yTree.walk(container)) {
+            if (node.role === 'button') {
+                skipRoots.push(node);
+                continue;
+            }
+            if (node.role === 'list') {
+                skipRoots.push(node);
+                continue;
+            }
+            if (node.role === 'iframe') {
+                skipRoots.push(node);
+                continue;
+            }
+            if (node.role === 'alert') {
+                skipRoots.push(node);
+                continue;
+            }
+            if (node.role === 'article' && outerArticle !== undefined && node.uid !== outerArticle.uid) {
+                skipRoots.push(node);
+                continue;
+            }
+            // Profile graphic-link inside the post body (author header was already
+            // skipped, but inline mentions like `link "Benoit Raphael" url="/in/.../"`
+            // should be kept — so don't skip those).
+            if (node.role === 'link' && node.attributes['url'] !== undefined) {
+                const url = node.attributes['url'];
+                if (url.startsWith('/analytics/post-summary/') === true) {
+                    skipRoots.push(node);
+                    continue;
+                }
+            }
+        }
+        const skipUids = new Set();
+        for (const root of skipRoots) {
+            for (const descendant of A11yTree.walk(root)) {
+                skipUids.add(descendant.uid);
+            }
+        }
+        return skipUids;
+    }
+    static fragmentForNode(node) {
+        if (node.role === 'StaticText' && node.name !== undefined) {
+            const trimmed = node.name.trim();
+            if (trimmed.length === 0) {
+                return null;
+            }
+            return trimmed;
+        }
+        const value = node.attributes['value'];
+        if (value !== undefined) {
+            const trimmed = value.trim();
+            if (trimmed.length === 0) {
+                return null;
+            }
+            // Hashtag links wrap a generic value="hashtag" + generic value="#X" — keep
+            // only the # variant.
+            if (trimmed === 'hashtag') {
+                return null;
+            }
+            return trimmed;
+        }
+        if (node.role === 'link' && node.name !== undefined) {
+            const trimmed = node.name.trim();
+            if (trimmed.length === 0) {
+                return null;
+            }
+            // If the link wraps a hashtag (its first descendant is generic value="hashtag"),
+            // rely on the inner generic value="#X" instead — return null here.
+            if (LinkedinRecentPostsHelper.linkIsHashtag(node) === true) {
+                return null;
+            }
+            // If the link has any text descendants (StaticText / generic[value]), they will
+            // emit their own fragments — skip the link's own name to avoid duplicates.
+            if (LinkedinRecentPostsHelper.linkHasTextDescendant(node) === true) {
+                return null;
+            }
+            return trimmed;
+        }
+        return null;
+    }
+    static linkIsHashtag(link) {
+        for (const child of link.children) {
+            if (child.role !== 'generic') {
+                continue;
+            }
+            const value = child.attributes['value'];
+            if (value === undefined) {
+                continue;
+            }
+            if (value.trim() === 'hashtag') {
+                return true;
+            }
+        }
+        return false;
+    }
+    static linkHasTextDescendant(link) {
+        for (const descendant of A11yTree.walk(link)) {
+            if (descendant.uid === link.uid) {
+                continue;
+            }
+            if (descendant.role === 'StaticText' && descendant.name !== undefined && descendant.name.trim().length > 0) {
+                return true;
+            }
+            const value = descendant.attributes['value'];
+            if (value !== undefined && value.trim().length > 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+    static matchesNoisePrefix(fragment) {
+        for (const prefix of NOISE_PREFIXES) {
+            if (fragment.startsWith(prefix) === true) {
+                return true;
+            }
+        }
+        return false;
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////
+    //	Markdown rendering
+    ///////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////
+    static formatPostMarkdown(post) {
+        const headerName = post.authorDisplayName !== null
+            ? post.authorDisplayName
+            : (post.authorSlug !== null ? post.authorSlug : 'unknown');
+        const slugSuffix = post.authorSlug !== null ? ` (${post.authorSlug})` : '';
+        const headerParts = [`${headerName}${slugSuffix}`];
+        if (post.timestamp !== null) {
+            headerParts.push(post.timestamp);
+        }
+        if (post.isEdited === true) {
+            headerParts.push('edited');
+        }
+        if (post.isRepost === true && post.repostedBy !== null) {
+            headerParts.push(`reposted by ${post.repostedBy}`);
+        }
+        const lines = [];
+        lines.push(`## ${headerParts.join(' · ')}`);
+        if (post.authorHeadline !== null) {
+            lines.push(`_${post.authorHeadline}_`);
+        }
+        lines.push('');
+        if (post.text.length === 0) {
+            lines.push('_(no text)_');
+        }
+        else {
+            lines.push(post.text);
+        }
+        if (post.mediaTypes.length > 0) {
+            lines.push('');
+            lines.push(`media: ${post.mediaTypes.join(', ')}`);
+        }
+        const countParts = [];
+        if (post.reactionCount !== null) {
+            countParts.push(`reactions: ${post.reactionCount}`);
+        }
+        if (post.commentCount !== null) {
+            countParts.push(`comments: ${post.commentCount}`);
+        }
+        if (post.repostCount !== null) {
+            countParts.push(`reposts: ${post.repostCount}`);
+        }
+        if (post.impressionCount !== null) {
+            countParts.push(`impressions: ${post.impressionCount}`);
+        }
+        if (countParts.length > 0) {
+            lines.push('');
+            lines.push(countParts.join(' · '));
+        }
+        if (post.url !== null) {
+            lines.push('');
+            lines.push(post.url);
+        }
+        return lines.join('\n');
+    }
+}
+//# sourceMappingURL=linkedin_recent_posts_helper.js.map