/*!
 * ad-guard.js  v2.5.0
 * ด่านป้องกันโฆษณากวนคนอ่าน — ทำงานฝั่งหน้าเว็บล้วน
 *
 * ติดตั้ง: วางเป็นแท็กแรกสุดใน <head> ห้ามใส่ async / defer
 *   <script src="https://cdn.example.com/ad-guard.js"></script>
 *
 * ตรวจว่าโหลดแล้วจริงไหม: เปิด console พิมพ์  __adGuard
 */
(function () {
  'use strict';

  // ถ้าติดตั้งซ้ำในหน้าเดียวกัน ตัวหลังไม่ต้องทำอะไร
  // เกิดขึ้นจริงตอนสลับลิงก์ ถ้าแท็กเก่ากับแท็กใหม่อยู่พร้อมกันชั่วคราว
  // ถ้าไม่กันไว้ ตัวหลังจะไปเขียนทับ window.open ที่ตัวแรกล็อกไว้แล้ว
  // แล้วโยน TypeError ออกมากลางหน้าเว็บ (เจอมาแล้วตอนทดสอบ)
  // ใช้ชื่อกลาง ๆ ที่ไม่บอกว่าเป็นอะไร แทนชื่อเดิมที่ประกาศตัวเองว่าเป็นด่าน
  // สคริปต์โฆษณาที่มองหาตัวกันโฆษณาด้วยชื่อ จะไม่เจอจากการเดาชื่อ
  // เช็คชื่อเดิมด้วย เผื่อช่วงสลับแท็กมีเวอร์ชันเก่ารันอยู่ก่อน จะได้ไม่ patch ซ้อน
  if (window.__mgx || window.__adGuard) return;
  try { window.__mgx = 1; } catch (e) {}

  var VERSION = '2.9.30';

  var CFG = {
    // ---- แก้ตรงนี้พอ ------------------------------------------------

    // 'monitor' = ดูอย่างเดียว ไม่บล็อก (ใช้ตอนเทสต์รอบแรก)
    // 'block'   = บล็อกจริง
    mode: 'block',

    // สวิตช์ตัวที่สอง แยกจาก mode ตั้งใจ
    // false = บล็อกเฉพาะของที่ "ระบุตัวได้แน่นอน" คือ blockHosts / blockPatterns
    //         ส่วนกฎที่ใช้การเดาจากรูปร่าง (ลิงก์ล่องหน, ชั้นบัง, sandbox iframe)
    //         จะจดอย่างเดียวไม่ลงมือ
    // true  = บังคับใช้กฎเดาด้วย
    //
    // ตอนนี้ปิดไว้เพราะ log จากคนอ่านจริงยังมีการจับผิดค้างอยู่
    // ถ้าเปิดตอนนี้ โฆษณาที่มีรายได้บางตัวจะโดนถอด href ไปด้วย
    // เปิดเมื่อไหร่ค่อยดูจาก log ว่า bait-link เหลือแต่ของจริงแล้ว
    enforceHeuristics: false,

    // โดเมนดำ — บล็อกเสมอ ชนะทุกกฎ
    // wingsmob = ตัวที่รันสคริปต์อยู่บนหน้าเว็บและยัด preconnect ไปหา sowve
    // sowve = ปลายทางที่แท็บเด้งไป (จับได้จาก log คนอ่านจริง 24 ครั้ง)
    // dizzypiece = จับได้จาก log คนอ่านจริง 30 ก.ค. 2569 (สร้างชั้นบังทับหน้า)
    //   ไฟล์ www.dizzypiece.com/eda437/2af70056a83c.js ขนาด 103KB
    //   ตัวมันประกาศ window["BetterJsPop"] ตรง ๆ = ไลบรารีเด้งแท็บ (popunder) ล้วน
    //   บดโค้ดซ่อนไว้แบบ state machine (switch-case) เหมือนที่ wingsmob ทำ
    //   ไม่พบโดเมนหรือรหัสแคมเปญเดิมฝังอยู่ = คนละเจ้ากับสายที่เคยยืนยันแล้ว
    // weepylack = ตัวโหลดที่พา dizzypiece เข้ามา ผู้ใช้สั่งบล็อก 30 ก.ค. 2569 บ่าย
    //   ฟังก์ชัน appendElement() ของมันเป็นคนแทรก dizzypiece ~1,300 ครั้งใน 5 ชม.ครึ่ง
    //   ตัดที่ตัวโหลดจะหยุดได้ก่อนหนึ่งจังหวะ ไม่ต้องรอให้ปลายทางโหลด
    //   ผลที่ควรเห็นหลังบล็อก: script-blocked ของ weepylack โผล่ขึ้นมา
    //   และ script-blocked ของ dizzypiece ควรลดลงหรือหายไป เพราะคนแทรกไม่ได้รันแล้ว
    // shameful-farm + fickle-association = **สายเดิมย้ายโดเมนรอบที่สอง** (1 ส.ค. 2569 เย็น)
    //   ผู้ใช้ส่งโค้ดที่เจอมาให้ดู โครงเหมือน weepylack ทุกบรรทัด:
    //   (function(wou){...})({}) · d.scripts[d.scripts.length-1] + insertBefore
    //   · referrerPolicy='no-referrer-when-downgrade' · s.settings = wou||{}
    //   ต่างแค่โดเมนกับรหัส (XNVxs.djG_lM0IYGWWcP -> XWVLs.diGSl)
    //
    //   **หลักฐานว่าเจ้าเดียวกัน (ไม่ใช่การเดา)**
    //   nameserver ตรงกันทั้ง 6 ตัว: pdns73.ultradns.{co.uk,biz,com,net,org,info}
    //   เหมือน weepylack.com และ dizzypiece.com เป๊ะ
    //
    //   **หลักฐานว่ามันทำอะไร (ดึงไฟล์มาอ่านเอง 56KB)**
    //   window:{w:1001,h:800,type:"popunder"} = ค่าเดียวกันเป๊ะกับที่ถอดจาก weepylack
    //   freq:{qty:2,period:60*60*24} = เด้งได้ 2 ครั้ง/คนอ่าน/วัน
    //   ชื่อฟังก์ชันข้างใน cneckLoadBjs / otherBjs (Bjs = BetterJsPop)
    //   มีโค้ดเช็คว่า window.open ถูกตัวกันป๊อปอัปห่อไว้หรือยัง (pbWindowOpen)
    //   = ตั้งใจหลบการตรวจจับ ไม่ใช่โฆษณาปกติ
    //
    //   fickle-association.com คือตัวถัดไปในสาย (ตำแหน่งเดียวกับ dizzypiece เดิม)
    //   NS ชุดเดียวกันอีกเช่นกัน · ใส่ทั้งคู่เพราะตัดตัวโหลดอย่างเดียวเคยไม่พอมาแล้ว
    // phoroglopsu = ตัวรับรายงาน error ของ loader สายนี้ (`/jserr?msg=`)
    //   เจอ 3 ส.ค. 2569 ตอนผู้ใช้ทดลองใส่แบนเนอร์ตัวใหม่เข้ามาเอง
    //   ยืนยันว่าเจ้าเดียวกันด้วย NS: pdns73.ultradns.* ครบ 6 ตัว เหมือนกันทั้งสาย
    // bidvertex = **คนละเจ้ากับที่เหลือในรายการนี้** อย่าเหมารวมตอนอ่านย้อนหลัง
    //   NS เป็น dns13/14.hichina.com (Alibaba) ไม่ใช่ pdns73.ultradns.*
    //   และเข้ามาทางโปรแกรมมาติก schain=genieesspv.jp (Geniee ใต้การดูแลของ AnyMind)
    //   ไม่ได้มาจาก banner ใน imp.mgronline.com เหมือนตัวอื่น
    //   จับได้ 6 ส.ค. 2569 ด้วย nav-away ภายใน 4 นาทีหลัง 2.9.15 ขึ้น
    //   sg.bidvertex.top/fj -> safeJump() -> lazada://th/pdp?..&from_affiliate=1
    //   = พาคนอ่าน Android ออกจากบทความเข้าแอป Lazada กลางคัน ไม่ใช่แบนเนอร์
    //   ผู้ใช้สั่งบล็อก 6 ส.ค. 2569 ระหว่างรอ AnyMind ตอบ
    // thedirecthor = **เจ้าใหม่ จับได้ 20 ส.ค. 2569 จากล็อก nav-away**
    //   17 แพตเทิร์นใน 2.7 วัน (17-20 ส.ค.) ทั้งที่สุ่มดูแค่ 25% ของหน้า
    //   nav-away ยิงเฉพาะตอน e.userInitiated === false = คนอ่านไม่ได้กดอะไรเลย
    //   **ปลายทางไม่ซ้ำกันสักตัวใน 17 ครั้ง** (securedflowmode, shieldyourdevice,
    //   cloudprivacycore, panguxinxi, riscvboard, xws360, trackmyclickk, ...)
    //   แต่คนสั่งเป็นไฟล์เดียวกันเป๊ะ /16/84748a4203c512e64d26c49e9b8b0771
    //   และทุกปลายทางถือพารามิเตอร์ชุดเดียวกัน PLACEMENT_ID=29843857
    //   PUBLISHER_ID=1593076 ZONE_ID=3463677 = เจ้าเดียวเปลี่ยนหน้ากากไปเรื่อย ๆ
    //   **บล็อกที่ตัวสั่ง ไม่ใช่ที่ปลายทาง** เพราะปลายทางเปลี่ยนทุกครั้ง ไล่ตามไม่ทัน
    //
    //   **ดึงไฟล์มาอ่านเอง 9.6KB (ทำให้อ่านยาก)**
    //   ตั้งคุกกี้ uidm อายุ 10 ปี = ลายเซ็นเดียวกับ wingsmob สายแรกเป๊ะ
    //   string ข้างใน: redirectsNumber, placementKey, abPlacementSubId,
    //   impressionWinNotice, psidMode · path ก็รูปแบบเดียวกับสายเดิม
    //   (/16/ + hex 32 ตัว เทียบกับ wingsmob/9/ และ sowve/4/)
    //   **แต่ยืนยันด้วย NS ไม่ได้** ซ่อนหลัง Cloudflare (clint/ivy.ns.cloudflare.com)
    //   จึงเป็นหลักฐานแวดล้อม ห้ามเขียนว่าเป็นเจ้าเดียวกับสาย ultradns แน่นอน
    //
    //   คนอ่านไทย **ยังไม่โดนสักราย** ที่โดนคือ GB/US/AU/HU/FI/FR/MM/NZ/AE/BH/MY/MX
    //   = แคมเปญเลือกยิงนอกไทย ซึ่งเขาสลับกลับมาเมื่อไหร่ก็ได้ จึงไม่ใช่เหตุให้ปล่อยไว้
    blockHosts: ['sowve.com', 'wingsmob.com', 'nresystems.com', 'dizzypiece.com',
                 'weepylack.com', 'shameful-farm.com', 'fickle-association.com',
                 'phoroglopsu.com', 'bidvertex.top', 'thedirecthor.com'],

    // ข้อความที่ถ้าโผล่ใน URL ให้บล็อกทันที ไม่สนว่าอยู่โดเมนอะไร
    // มีไว้กันเขาย้ายโดเมนหนี — ของจริงที่เจอคือรหัสแคมเปญตัวเดียวกันเป๊ะ
    // โผล่ทั้ง wingsmob.com/9/<รหัส> และ sowve.com/4/<รหัส>
    // ถ้าพรุ่งนี้เขาเปลี่ยนเป็นโดเมนใหม่ แต่ยังใช้รหัสเดิม ก็ยังโดนกันอยู่
    // ตัวที่สอง: รหัส path ของ weepylack ที่ banner 13940 ยัดเข้ามา
    //   สืบครบสาย 30 ก.ค. 2569: imp.mgronline.com ch490 banner_id 13940
    //   (อ้างว่าเป็นแบนเนอร์ 300x250 น้ำหนัก 17) ยัดสคริปต์ผ่าน jQuery .append()
    //   ที่มี '<scr'+'ipt>' เขียนแยกคำเพื่อหลบการค้นหา แล้วโหลด weepylack -> dizzypiece
    //   ใส่รหัส path ไว้เพราะสายแรกเคยย้ายโดเมนแล้วใช้รหัสเดิม ถ้าย้ายอีกก็ยังโดนกัน
    // เทียบด้วย indexOf ตรงตัว ไม่ใช่ regex และไม่แปลงตัวพิมพ์
    // จุดกับขีดในรหัสจึงเป็นอักขระธรรมดา ส่วนตัวพิมพ์ใหญ่ต้องตรงเป๊ะ ห้ามแก้เป็นพิมพ์เล็ก
    blockPatterns: ['61f2d287abf80c144fcbcbf2cc085321',
                    'XNVxs.djG_lM0IYGWWcP',
                    'XWVLs.diGSl',           // รหัสของสายเดียวกันรอบย้ายโดเมนที่สอง
                    // รอบที่สาม 3 ส.ค. 2569 — โดเมนเดิม (shameful-farm) แต่รหัสใหม่
                    // ตัวแรกคือ loader ที่ ad server ยัดเข้าหน้าผ่าน jQuery globalEval
                    // ตัวที่สองคือขั้นถัดไปที่อยู่ในไฟล์นั้น (โดเมนเดียวกัน)
                    // ครีเอทีฟรอบนี้เป็นตัวเรนเดอร์แบนเนอร์ที่มีตัวเลือก fullscreen/blur
                    // = สายบังหน้าจอ คนละแบบกับ popunder เดิม แต่เจ้าเดียวกัน
                    'boXZVmsGd.GNlj0zYoWOcr',
                    'awWxZ-y.Pz2AQB9CM',
                    // รหัสแคมเปญของ thedirecthor (20 ส.ค. 2569)
                    // สายนี้เคยย้ายโดเมนแล้วใช้รหัสเดิมมาสามรอบ ใส่ไว้กันรอบต่อไป
                    '84748a4203c512e64d26c49e9b8b0771'],

    // เฝ้าดูอย่างเดียว ไม่บล็อกไม่ว่าโหมดไหน — มีไว้ตามหาว่า "ใครพามันเข้ามา"
    // highperformanceformat = ตัวที่เรียก wingsmob เข้ามาอีกที (จับได้จาก stack)
    // ไม่เอาไปใส่ blockHosts เพราะถ้าวันหนึ่งสลับเป็น block มันจะตัดทั้งเจ้าทันที
    // ซึ่งเป็นเรื่องรายได้ ต้องให้คนตัดสินใจเอง ไม่ใช่ให้โค้ดตัดสินแทน
    // วิธีใช้: ใส่โดเมนที่ยังไม่รู้ว่าทำอะไร แล้วปล่อยให้ log บอกเอง
    // ถ้ามันไปโหลดของต่อเป็นทอด ๆ แบบสายที่เคยเจอ stack จะฟ้องให้เห็นทันที
    watchHosts: [
      'highperformanceformat.com',  // ตัวที่พา wingsmob เข้ามา (ยืนยันแล้ว)
      'ocmthood.com',               // ht.js เป็น SDK ขอสิทธิ์ push notification
      'ocmtag.com',                 // ไฟล์ชื่อเป็นรหัส เนื้อหาแค่ 455 ไบต์ ยังไม่รู้ว่าทำอะไร
      '4dex.io',                    // เพิ่งโผล่มาในหน้าข่าวใหม่ ไม่เคยเห็นในรอบสำรวจแรก
      'anymind360.com',             // เพิ่งโผล่มาเหมือนกัน
      'creden.co',                  // detect_company_name.js อยู่บนเว็บข่าว ผิดที่ผิดทาง
      'r42tag.com',                 // ตัวจัดการแท็ก ถ้าโดนยึดจะยัดอะไรเข้ามาก็ได้
      'optad360.io',                // แพลตฟอร์มโฆษณา โผล่บางรอบไม่โผล่บางรอบ
      'imprezzer.com'               // เน็ตเวิร์กโฆษณา มีไฟล์ชื่อ bottompage/multisize
      // weepylack.com เคยอยู่ที่นี่ใน 2.6.3 — ย้ายไป blockHosts แล้วใน 2.6.4 ตามที่ผู้ใช้สั่ง
      // **ห้ามใส่ซ้ำกลับมาที่นี่** guardResource เช็ค watchHosts ก่อน blockHosts แล้ว return
      // ถ้าอยู่สองที่พร้อมกัน = ไม่ถูกบล็อกเลย และจะดูเหมือนว่าบล็อกแล้วแต่เงียบ ๆ ไม่ทำงาน
    ],

    // โดเมนที่ยอมให้เปิดแท็บใหม่ได้ (เทียบท้ายโดเมน ใส่ตัวแม่คลุมลูกทุกตัว)
    // รายชื่อชุดล่างมาจากการวัดหน้าข่าวจริง ห้ามตัดออกถ้ายังใช้ระบบโฆษณาเดิม
    // โดยเฉพาะ googlesyndication — safeframe คือกล่องที่โฆษณา Google เรนเดอร์อยู่
    // ถ้าไปใส่ sandbox ให้มัน คนอ่านคลิกโฆษณาจริงแล้วแท็บจะไม่เปิด = รายได้หาย
    allowHosts: ['mgronline.com', 'viewnews.co', 'facebook.com', 'youtube.com',
                 'googlesyndication.com',      // รวม safeframe ที่โฆษณาเรนเดอร์อยู่
                 'doubleclick.net',            // Google Ad Manager
                 'googleadservices.com',
                 'adtrafficquality.google',    // ตัวตรวจทราฟฟิกปลอมของ Google
                 'google.com',                 // recaptcha aframe
                 'googleapis.com',             // imasdk = ตัวเล่นโฆษณาวิดีโอของ Google
                 'taboola.com',
                 'twitter.com',
                 'line.me'],

    // ยกเว้น "เฉพาะเรื่อง sandbox ของ iframe" เท่านั้น ไม่ใช่ยกเว้นทุกเรื่อง
    // แยกออกมาจาก allowHosts ตั้งใจ — เจ้าพวกนี้คือช่องที่โฆษณาถูกยิงเข้ามา
    // เราเชื่อมันพอที่จะให้เรนเดอร์กล่องโฆษณาและเปิดแท็บตอนคนคลิกจริง (ไม่งั้นรายได้หาย)
    // แต่ "ไม่เชื่อ" ถึงขั้นให้เอาลิงก์ล่องหนมาปูทับข่าว — กฎ bait-link ยังจับเจ้าพวกนี้อยู่
    frameAllowHosts: ['gliastudios.com',
                      'adtarget.biz',
                      'rubiconproject.com',
                      'onetag-sys.com',
                      'imprezzer.com',
                      'optad360.io',
                      'optad360-video.com',
                      'popin.cc',
                      'criteo.com'],

    // true  = อนุญาตเฉพาะ allowHosts เท่านั้น (เข้มสุด แต่เสี่ยงบล็อกของดี)
    // false = ปล่อยหมด ยกเว้นที่อยู่ใน blockHosts  <-- แนะนำตอนเทสต์
    strict: false,

    // คอนเทนเนอร์โฆษณาของเราเอง จะไม่ถูกแตะ
    ownSlots: ['#ad-slot-1', '.mgr-ad', '.adsbygoogle'],

    // ---- คืนที่ให้คนอ่าน เมื่อกล่องโฆษณาจองที่ไว้แล้วไม่มีอะไรมาลง -------
    // อาการจริง 30 ก.ค. 2569: JS ของเว็บสร้าง #p-top-bar-ads + #bg-special-container
    // ตอนรัน (ไม่มีใน HTML ต้นทาง) แล้วยัด inline height 184px (มือถือ) / 371px (จอใหญ่)
    // ไว้จองที่รอโฆษณา พอไม่มีของมาลง gpt-ads.min.js จะ refresh ซ้ำจนครบ maxLoop
    // แล้วตกไปที่ houseAds ซึ่งไม่ได้ตั้งค่าไว้ จึงไม่มีอะไรเรนเดอร์
    // ความสูงที่จองไว้ค้างเป็นช่องขาวถาวร — นี่คือสิ่งที่คนอ่านเห็น
    //
    // ที่ทำอยู่นี้เป็นการแก้เฉพาะหน้าเพื่อคนอ่าน ต้นเหตุอยู่ในโค้ดโฆษณาของเว็บ
    // (ดู empty-ad-slot-report.md) ถ้าโปรแกรมเมอร์แก้ที่ต้นทางแล้ว ปิดตัวนี้ได้เลย
    //
    // ไม่ใช้ตัวจับเวลาและไม่เดารูปร่าง: ยุบตอนกวาดเจอว่าว่างจริง (รอบละ 3 วิ)
    // และคืนความสูงทันทีในจังหวะเดียวถ้าโฆษณามาทีหลัง — ช้าตอนหด เร็วตอนคืน
    collapseEmptyAdBoxes: true,

    // กล่องที่ยอมให้แตะ ระบุไว้ชัดเจนเป็นรายตัว ไม่ใช่กฎเดารูปร่าง
    // ห้ามใส่ selector กว้าง ๆ เด็ดขาด นี่คือของที่มีรายได้ผูกอยู่
    adBoxSelectors: ['.p-ads-content', '#bg-special-container'],

    // ใหญ่เกินกี่ % ของจอถึงนับว่า "บัง"
    coverRatio: 0.4,

    // ชั้นที่ position:fixed ใช้เกณฑ์ต่ำกว่า เพราะมันลอยตามจอไปทุกที่
    // ไม่มีเว็บไหนทำชั้น fixed ล่องหนกินจอเป็นสิบ % โดยไม่มีอะไรอยู่ข้างใน
    // มีไว้กันท่าจงใจทำให้ต่ำกว่าเกณฑ์นิดเดียว เช่น 39%
    coverRatioFixed: 0.15,

    // endpoint เก็บ log ตั้ง null ถ้าไม่อยากส่ง
    report: 'https://guard-log.mgronline.com',

    // ส่งเฉพาะเรื่องที่มีความหมายจริง ๆ ไม่ส่งทุกอย่าง
    // เหตุผล: ที่เก็บมีโควตาเขียนจำกัด ถ้าส่งพวก iframe-sandboxed ที่มี 10 ตัวต่อหน้า
    // โควตาจะหมดภายในไม่กี่ร้อยคนอ่าน แล้วของสำคัญจะไม่ถูกเก็บ
    // พวกที่ไม่ส่งยังดูได้ที่หน้าเว็บผ่าน __adGuard.dump() เหมือนเดิม
    reportKinds: ['bait-link', 'link-neutralized', 'link-blocked',
                  'preconnect-blocked', 'script-blocked', 'blocked-host',
                  'popup-blocked', 'popup-blocked-iframe',
                  'synthetic-click', 'overlay-touched', 'watch-script',
                  'vignette-blocked', 'blank-screen', 'ad-box-stalled',
                  'doc-write-late', 'body-wiped', 'body-revealed',
                  'body-recovered', 'wipe-stuck',
                  'nav-away', 'nav-forced', 'popup-seen', 'nav-blocked'],

    // ---- การสุ่มตัวอย่าง สำคัญมากกับเว็บทราฟฟิกสูง ----------------------
    // ของจริง: 500,000 pageview/วัน พีคมีคนออนไลน์พร้อมกัน 9,500 คน
    // ถ้าส่งทุกหน้า จะเป็น 1-3 ล้าน request/วัน ยิงใส่ Worker ตัวเดียว
    // เกินโควตาหลายเท่า ของสำคัญจะถูกทิ้งและมีค่าใช้จ่ายโดยไม่จำเป็น
    //
    // เราไม่ได้ต้องการนับให้ครบ เราต้องการ "เห็นว่ามีอะไรเกิดขึ้นบ้าง"
    // สุ่ม 2% ของ 500,000 = 10,000 หน้าต่อวัน เหลือเฟือสำหรับหาแพตเทิร์น
    // อยากรู้จำนวนจริงให้เอาที่นับได้หารด้วยอัตราสุ่ม
    //
    // สุ่มครั้งเดียวตอนเปิดหน้า ไม่ใช่สุ่มรายเหตุการณ์
    // เพื่อให้หน้าที่ถูกเลือกส่งข้อมูลครบทั้งหน้า จะได้เห็นภาพทั้งลำดับเหตุการณ์
    reportSample: 0.02,        // เรื่องทั่วไป
    reportSampleAlways: 0.1,   // เรื่องสำคัญ (กับดักถูกกัน) สุ่มถี่กว่าเพราะพลาดไม่ได้

    // ส่งได้กี่ครั้งต่อการเปิดหน้าหนึ่งครั้ง กันหน้าที่มีปัญหาซ้ำ ๆ ยิงจนโควตาหมด
    reportMax: 2,

    // เรื่องสำคัญที่ต้องได้ส่งเสมอ ไม่ต้องแย่งโควตากับเรื่องทั่วไป
    // เจอปัญหาจริง: watch-script กับ bait-link เกิดก่อนและเกิดบ่อย
    // กินโควตา 2 ครั้งจนหมดตั้งแต่ต้น ทำให้ script-blocked ซึ่งเป็นตัวชี้ขาด
    // ว่ากับดักยังยิงมาอยู่ไหม ไม่เคยถูกส่งเลย = อ่านผลผิดได้
    //
    // 2.9.1 ย้าย overlay-touched เข้ามาด้วย — กับดักเดิมซ้ำรอยเป๊ะ ๆ
    // วัดจากหน้าจริง 1 ส.ค. 2569: หน้าเดียวมี watch-script 11 รายการ
    // ยิงตั้งแต่ต้นจนโควตา 2 ครั้งหมดทันที ส่วน overlay-touched เกิดตอน "คนแตะ"
    // ซึ่งเป็นเหตุการณ์ท้ายสุดเสมอ = บนหน้าจริงมันไม่เคยถูกส่งเลยสักครั้ง
    // ไม่ใช่ "ส่งน้อย" แต่คือศูนย์ ทำให้เราตาบอดเรื่องหน้าขาวมาตลอด
    reportAlways: ['script-blocked', 'preconnect-blocked', 'link-neutralized',
                   'blocked-host', 'popup-blocked', 'popup-blocked-iframe',
                   'overlay-touched', 'blank-screen', 'doc-write-late',
                   'ad-box-stalled', 'body-revealed'],

    // ขยับตามจำนวนชนิดที่เพิ่มเข้ามา (4 → 5 ตอน 2.9.1 → 6 ตอน 2.9.5)
    // ถ้าไม่ขยับ = ย้ายจุดตาบอดไปทับ script-blocked แทน ซึ่งเป็นตัวชี้ขาดอีกตัว
    // ราคาที่จ่ายคืออย่างมาก 1 beacon ต่อหน้าที่ถูกสุ่ม ไม่ใช่ต่อทุกหน้า
    //
    // **ชนิดที่อยู่ในถังนี้ต้องยิงได้ไม่เกิน 1 ครั้งต่อหน้าเท่านั้น**
    // ทุกตัวมีตัวกันซ้ำของตัวเองอยู่แล้ว (blankDone, docWriteSeen, stallTold,
    // __agSeen, __agResSeen) ถ้าเพิ่มชนิดใหม่ที่ยิงรัวได้ มันจะกินโควตาจนตัวอื่นตกหมด
    // ซึ่งคือจุดตาบอดเดิมที่ย้ายที่ไปเฉย ๆ — เคยพลาดมาแล้วสองครั้งในวันเดียว
    reportAlwaysMax: 6,

    // true = ลบ node ทิ้ง, false = ซ่อน (โดน re-inject น้อยกว่า)
    removeNode: false,

    // ---- iframe ของบุคคลที่สาม --------------------------------------
    // โฆษณาส่วนใหญ่อยู่ใน iframe คนละโดเมน ซึ่งมี window.open เป็นของตัวเอง
    // ข้อ 3 ข้างล่างเอื้อมไปแตะไม่ถึง ต้องให้เบราว์เซอร์บังคับแทนผ่าน sandbox
    sandboxIframes: true,

    // สิทธิ์ที่ยังปล่อยให้ iframe บุคคลที่สามใช้ได้
    // ของสำคัญคือสิ่งที่ "ไม่มี" ในนี้ — allow-popups กับ allow-top-navigation
    // ถ้าโฆษณาของจริงพัง ให้เติมทีละอัน แต่ห้ามเติม allow-popups เด็ดขาด
    iframeSandbox: 'allow-scripts allow-same-origin allow-forms',

    // iframe ที่ไม่มี src / about:blank / srcdoc — พวกนี้อยู่โดเมนเดียวกับเรา
    // ค่านี้ตั้งให้เหมือนข้างบนไว้ก่อน เพราะไลบรารีสุจริตหลายตัว (รวมของ Google)
    // สร้าง about:blank แล้วเขียนเนื้อหาใส่เอง ถ้าตัด allow-same-origin จะพังทันที
    // ตัวที่โดเมนเดียวกันเรา patch window.open ตรง ๆ ได้อยู่แล้ว จึงพอกัน
    // ถ้ายังมี popup หลุด ให้เปลี่ยนเป็น 'allow-scripts allow-forms' (เข้มสุด แต่เสี่ยงพัง)
    iframeSandboxInline: 'allow-scripts allow-same-origin allow-forms',

    // ---- สกัดโฆษณาคั่นหน้าเต็มจอ (vignette / web interstitial) ----------
    // อาการจริงบนมือถือ 30 ก.ค. 2569: เนื้อหาโหลดเสร็จแล้วมีหน้าขาวเต็มจอมาทับ
    // ต้อง refresh ถึงหาย บางครั้ง 2-3 รอบ (ตรงกับการจำกัดความถี่ของ vignette)
    // ล็อกคนอ่านจริง 34 จาก 43 overlay เกิดบนหน้าที่ URL มี #google_vignette
    //
    // ผู้ใช้ตัดสินใจ: คนอ่านมาก่อนรายได้จากโฆษณาคั่นหน้า
    //
    // ทำไมสกัดตอนขอสร้างช่อง ไม่ใช่ซ่อนตอนมันโผล่:
    //   ถ้าปล่อยให้ Google เสิร์ฟมาแล้วเราซ่อนทิ้ง = โฆษณาถูกนับ impression แต่คนอ่านไม่เห็น
    //   ซึ่งเสี่ยงผิดนโยบายและกระทบบัญชี AdX/AdSense ทั้งบัญชี เสียหายกว่าตัว vignette เอง
    //   สกัดที่ต้นทางแล้วช่องไม่เกิด = ไม่มีการขอโฆษณา = ไม่มี impression = ไม่มีปัญหานโยบาย
    //
    // ปลอดภัยเพราะโค้ดของเว็บเช็คค่าที่คืนมาอยู่แล้ว (factory.min.js เขียนเป็น
    //   if (f = googletag.defineOutOfPageSlot(unit, INTERSTITIAL)) f.addService(...))
    // และ GPT ระบุไว้เองว่าฟังก์ชันนี้คืน null ได้เมื่อสร้างช่องไม่ได้ ผู้เรียกต้องรองรับ
    //
    // ต้นเหตุจริงอยู่ที่โค้ดของเว็บที่เรียกสร้างช่องนี้เอง (ไม่ใช่ Google เปิดอัตโนมัติ)
    // ถ้าโปรแกรมเมอร์เอาโค้ดตรงนั้นออกแล้ว ปิดสวิตช์นี้ได้เลย
    blockVignette: true,

    // กู้หน้าที่กลับมาจากแคชแล้วเนื้อหาหาย — ดูหัวข้อ 12 ท้ายไฟล์
    // ต้นเหตุคือ $(document.body).html("") ใน onbeforeunload ของ header.min.js
    // **ของที่แรงที่สุดที่ด่านเคยทำ (สั่งโหลดหน้าใหม่) กันวนลูปไว้สามชั้น**
    // โปรแกรมเมอร์แก้ที่ต้นทางแล้วปิดตัวนี้ได้เลย
    recoverFromCache: true,

    // เปิดหน้าที่เว็บซ่อนไว้ด้วย visibility:hidden แล้วไม่มีใครมาเปิดคืน
    // **ตัวเดียวในชุดนี้ที่แก้อาการทั้งหน้าขาวให้คนอ่านโดยตรง** ดูหัวข้อ 11 ท้ายไฟล์
    // เราเปิดได้อย่างเดียว ซ่อนไม่ได้ จึงไม่มีทางทำให้แย่ลง
    revealHiddenBody: true,

    // เฝ้าจังหวะที่เนื้อหาในหน้าหายไป — ดูเหตุผลที่หัวข้อ 10 ท้ายไฟล์
    // มีเพราะตัวดัก document.write (หัวข้อ 9) จับได้ 0 ครั้งทั้งวัน = ตัวการใช้วิธีอื่น
    watchBodyWipe: true,

    // นับอย่างเดียว ไม่แก้อะไรให้คนอ่าน — ดูหัวข้อ 14 ท้ายไฟล์
    // ตอบคำถามเดียว: "ใครพาคนอ่านออกจากหน้าไปโดยที่เขาไม่ได้กด"
    // มีเพราะด่านทุกจุดที่กันการพาออกจากหน้าตัดสินจาก isBlocked() คือรู้จักโดเมนก่อน
    // เจ้าใหม่ที่ยังไม่รู้จักจึงผ่านไปเงียบ ๆ โดยไม่มีร่องรอยในล็อกเลยสักบรรทัด
    watchForcedNav: true,

    // สุ่มว่าหน้านี้จะเฝ้าเรื่องนั้นไหม ตัดสินครั้งเดียวตอนเปิดหน้า
    // ตั้งไว้เพราะยังไม่รู้ความถี่จริง ถ้าปล่อยเต็ม 100% แล้วมันเกิดบ่อยกว่าที่คิด
    // เราจะยิง Worker ทะลุโควตาจนล็อกทั้งระบบใช้ไม่ได้ = เสียของทุกเรื่องพร้อมกัน
    // อ่านผลเสร็จแล้วปรับขึ้นหรือลงได้ตามความถี่ที่วัดได้จริง
    forcedNavSample: 0.25,

    // นับอย่างเดียว ไม่แก้อะไรให้คนอ่าน — ดูหัวข้อ 13 ท้ายไฟล์
    // วัดว่า "หน้าถูกล้างแล้วไม่ได้เปลี่ยนหน้าจริง" เกิดบ่อยแค่ไหน
    // หัวข้อ 10 มองไม่เห็นเคสนี้เพราะธง unloading ตัดทิ้งก่อน
    // ได้ตัวเลขพอแล้วปิดได้เลย ไม่มีอะไรพึ่งพามัน
    watchStuckWipe: true,

    // เรื่องที่ **ต้องส่งเสมอ ไม่ผ่านการสุ่ม**
    // เหตุผล: ผู้ใช้บอกว่าอาการนี้ "หายากมาก เราไม่ค่อยเจอแต่คนอื่นเจอ"
    // ถ้าสุ่มแค่ 10% แล้วอาการเกิด 1 ใน 500 หน้า เราจะเห็น 1 ใน 5,000 = พลาดแน่
    // ปลอดภัยเพราะแต่ละชนิดในนี้ยิงได้ครั้งเดียวต่อหน้า (มีตัวกันซ้ำของตัวเอง)
    // ปริมาณจึงเท่ากับจำนวนครั้งที่เกิดจริง ซึ่งน้อยมากอยู่แล้ว
    // nav-away / popup-seen อยู่ในนี้ด้วยเหตุผลเดียวกัน แต่มีเงื่อนไขเพิ่ม:
    // สองตัวนี้ **ไม่รู้ล่วงหน้าว่าเกิดบ่อยแค่ไหน** ต่างจากตัวอื่นที่วัดมาแล้วว่าหายาก
    // ถ้ามันดันเกิดบ่อย การส่งเสมอจะยิง Worker ทะลุโควตาฟรี 100,000 คำขอ/วัน
    // จึงกั้นด้วย forcedNavSample ที่ตัวหัวข้อ 14 แทน (สุ่มครั้งเดียวตอนเปิดหน้า)
    // = ได้ความแน่นอนว่าหน้าที่ถูกเลือกจะไม่พลาด โดยเพดานความเสี่ยงถูกล็อกไว้
    reportCritical: ['body-wiped', 'doc-write-late', 'body-recovered', 'wipe-stuck',
                     'nav-away', 'nav-forced', 'popup-seen', 'nav-blocked'],

    // หาตัวที่ล้าง body ทิ้ง — ห่อ document.write/open แบบดูอย่างเดียว
    // เรียกของเดิมต่อเสมอ ไม่ขวางอะไร ดูข้อควรระวังที่หัวข้อ 9 ท้ายไฟล์
    // ได้ชื่อคนร้ายแล้วปิดได้เลย ไม่ต้องเปิดค้างไว้
    watchDocWrite: true,

    // ยุบกล่อง AdSense ที่ "จองที่แล้วค้าง" — ดูเหตุผลที่หัวข้อ 8 ท้ายไฟล์
    // คนละเรื่องกับ collapseUnfilledAdSense ซึ่งจับกล่องที่ Google ตอบแล้วว่าไม่มีของ
    collapseStalledAdSense: true,

    // เฝ้าดูว่าคนอ่านเจอ "เลื่อนแล้วจอว่าง" ไหม — ดูอย่างเดียว ไม่ลงมือ
    // ดูเหตุผลและข้อควรระวังที่หัวข้อ 7 ท้ายไฟล์
    //
    // **ปิดแล้วเมื่อ 12 ส.ค. 2569 — ตั้งใจปิด ไม่ใช่ลืมเปิด**
    // อ่านผลสะสม 9-12 ส.ค. แล้ว: 56 จาก 105 แพตเทิร์น (53%) เป็นชนิดนี้
    // และไม่มีสักรายการที่เกิดจากของเรา — ค้นทั้งกองไม่เจอ p-ads / google_ads / ad-guard เลย
    // ที่ถูกชี้ว่าว่างคือเลย์เอาต์ของเว็บเอง (DIV เปล่า 29, SPAN.thumbBlock 4)
    // ฉากของ Taboola Explore More (tbl-em-backdrop) และ**ส่วนขยายในเบราว์เซอร์ของคนอ่านเอง**
    // (SINGLEFILE-MASK, chrome-extension://) ซึ่งเราไม่เกี่ยวและแก้อะไรไม่ได้
    // = ชนิดที่ไม่เคยพาไปสู่การลงมือ แต่กินหน้าต่างที่อ่านย้อนหลังได้ไปครึ่งหนึ่ง
    // ปิดแล้วจะอ่านย้อนหลังได้ไกลขึ้นราวเท่าตัว เห็นของจริงชัดขึ้น
    //
    // ปิดที่นี่หยุด**ทั้งการตรวจและการส่ง** = เลิกเรียก elementFromPoint 7 จุด
    // ทุก 2 วิที่คนอ่านเลื่อน (คูณ 500,000 pageview/วัน) ไม่ใช่แค่เงียบแต่ยังทำงานอยู่
    // จงใจไม่ถอดชื่อออกจาก reportKinds/reportAlways เพื่อให้เปิดกลับได้ด้วยการแก้คำเดียว
    watchBlankScreen: false,

    // ยุบกล่อง AdSense ที่ Google ติดป้าย data-ad-status="unfilled" ให้เอง
    // ดูเหตุผลและหลักฐานที่หัวข้อ 6 ท้ายไฟล์
    // ถ้าเว็บใส่กฎนี้ใน CSS ของตัวเองแล้ว ปิดตัวนี้ได้เลย
    collapseUnfilledAdSense: true,

    // ---- แทรกโฆษณาในเนื้อหาบทความยาว (มือถือ/แท็บเล็ตเท่านั้น) ----------
    //
    // ผู้ใช้ขอเอง 8 ก.ย. 2569 และส่งโค้ด AdSense แบบ in-article มาให้
    // เหตุผลของเขา: ข่าวบางเรื่องยาวมากบนมือถือ ของที่แทรกอยู่มีแต่ช่วงบน
    // ช่วงท้ายไม่มีเลย · "ไม่ต้องตำแหน่งดีที่สุด ขอแค่ไม่ทับกับตัวที่อยู่ด้านบน"
    //
    // **สิ่งที่วัดได้จากหน้าจริง 8 ก.ย. 2569 (iPhone 440px) ก่อนเขียนกฎนี้**
    // หน้า politics/9690000087853 · เนื้อหาจริงสูง 4,435px
    // แต่ `.m-detail-container` ถูกล็อก `max-height:2000px; overflow:hidden`
    // = **ซ่อนไป 2,435px หรือ 55% ของบทความ** หลังปุ่ม "แสดงเพิ่มเติม"
    //
    // ข้อนี้เปลี่ยนวิธีทำทั้งหมด ถ้าแทรก "ท้ายเนื้อหา" ตรง ๆ ตามที่ขอ
    // โฆษณาจะไปนอนอยู่ในส่วนที่ซ่อน = คนอ่านไม่เห็น viewability เป็นศูนย์
    // และผิดนโยบาย AdSense ที่ห้ามยิงโฆษณาลงพื้นที่ที่มองไม่เห็น
    // จึงวางไว้ "ท้ายสุดของโซนที่ยังมองเห็น" แทน ไม่ใช่ท้ายเนื้อหาจริง
    //
    // ช่องที่มีอยู่แล้วในเนื้อหาหน้านั้น (นับจากหัวเนื้อหา):
    //   +261px   ins.adsbygoogle 440px **มีของ**  ← ตัวที่ผู้ใช้บอกว่าอยู่ด้านบน
    //   +1,028px .p-ads-content สูง 0 **ว่าง**
    //   +1,750px เป็นต้นไป ไม่มีอะไรเลยจนถึงเส้นตัด
    //
    // เว้นระยะจากตัวที่ **มีของ** มากกว่าตัวที่ **ว่าง** ตั้งใจ —
    // ช่องว่างไม่ได้กินพื้นที่สายตาใคร จึงไม่ต้องเผื่อเท่ากัน
    // ถ้าเว้นเท่ากันหมด จะไม่เหลือที่พอวางบนบทความความยาวปกติเลย
    //
    // **มือถือกับแท็บเล็ตเท่านั้น** ผู้ใช้สั่ง 8 ก.ย. เดสก์ท็อปไม่ต้องแสดง
    inArticleAd: true,

    inArticleCfg: {
      client: 'ca-pub-6559056741388358',
      slot: '1107467108',

      // ที่อยู่ของเนื้อหาจริงกับกล่องที่ล็อกความสูงไว้
      bodySel: '.m-detail-container .detail',
      capSel:  '.m-detail-container',
      fadeSel: '.m-detail-readmore-lightbox',

      // ของที่นับว่า "มีโฆษณาอยู่แล้ว" ต้องเว้นระยะให้
      adSel: '.p-ads-wrapper,.p-ads,ins.adsbygoogle,.google-auto-placed',

      maxWidth: 1024,      // กว้างกว่านี้ = เดสก์ท็อป ไม่แสดง
      minBody: 2600,       // บทความสั้นกว่านี้ไม่แทรก ไม่ให้ดูอัด
      // ห้ามแทรกสูงกว่านี้เด็ดขาด — กันไม่ให้ไปโผล่ต้นบทความ
      // **ลดจาก 900 เหลือ 500 เมื่อ 8 ก.ย. 2569** ตอนใส่ 900 ยังไม่มีการเช็ค
      // ระยะห่างสองด้าน มันเลยทำหน้าที่กันชนหยาบ ๆ ไปก่อน · พอ fits() ดูทั้ง
      // บนและล่างแล้ว 900 กลายเป็นตัวบีบเปล่า ๆ · เจอจริงหน้า onlinesection/
      // 9690000088043 ช่วงที่วางได้เหลือ 900-905 (5px) แล้วไม่มีรอยต่อในนั้น
      // พอลดเป็น 500 ช่วงเปิดเป็น 636-905 ซึ่งมีรอยต่อที่ 832 พอดี
      minTop: 500,
      gapFilled: 600,      // ระยะห่างจากโฆษณาที่มีของจริง
      gapEmpty: 350,       // ระยะห่างจากช่องที่ว่างอยู่
      pad: 24,             // กันชนก่อนถึงแถบ "แสดงเพิ่มเติม"
      reserve: 250,        // จองความสูงไว้ก่อน กันหน้ากระตุก

      // ความสูงที่ **เผื่อไว้** ตอนคำนวณจุดวาง ไม่ใช่ความสูงที่จอง
      // โฆษณา in-article เป็น fluid ความสูงจริงแล้วแต่ครีเอทีฟ วัดได้ 250-400px
      // ถ้าใช้ reserve (250) มาคำนวณ พอเจอครีเอทีฟสูง 400 ท้ายกล่องจะจมลงไป
      // ใต้แถบ "แสดงเพิ่มเติม" · เจอตอนทดสอบหน้าจริง 8 ก.ย. 2569 (จม 72px)
      assume: 400,

      // รอให้ช่องของเว็บเองถูกยัดเข้ามาก่อน ไม่งั้นนับระยะห่างผิด
      firstWait: 2500,
      retryEvery: 1000,
      maxTries: 14,

      // **ห้ามตัดสินใจก่อนรอบนี้** — วัดจริง 8 ก.ย. 2569 พบว่าเลย์เอาต์มือถือ
      // ยังขยับต่อไปถึง ~9 วิ (โฆษณาของเว็บทยอยโหลด/ยุบ) การเช็ค "สูงเท่าเดิม
      // สองรอบ" ผ่านได้ตั้งแต่ 3.5 วิ เพราะบังเอิญนิ่งชั่วคราว แล้วตัดสินผิด
      // ผลจริง: หน้าที่มีที่ว่างพอดีถูกตอบว่า "ไม่มีรอยต่อในช่วงที่วางได้"
      minTries: 5,

      // ต้องอ่านความสูงได้เท่าเดิมติดกันกี่รอบถึงเชื่อว่านิ่งจริง
      settleNeed: 2,
      collapseAfter: 7000, // ไม่มีของมาลง ให้คืนที่ที่จองไว้

      // ---- จุด B: หลังคนอ่านกด "แสดงเพิ่มเติม" (ผู้ใช้สั่งเพิ่ม 8 ก.ย. 2569) ----
      //
      // คนที่กดปุ่มนี้คือคนที่ตั้งใจอ่านที่สุดในเว็บ และส่วนที่เปิดออกมา
      // ตอนนี้ไม่มีโฆษณาสักตัว · วัดจริงหน้า politics/9690000087853
      // ซ่อนอยู่ 2,435px หน้า local/9690000088061 ซ่อนอยู่ 873px
      //
      // **ยิงหลังกดเท่านั้น** ไม่โหลดล่วงหน้าลงพื้นที่ที่ยังมองไม่เห็น
      // ทั้งเพราะนโยบาย AdSense และเพราะ viewability จะเป็นศูนย์เปล่า ๆ
      afterExpand: true,
      expandMin: 800,      // เปิดออกมาน้อยกว่านี้ ไม่คุ้มที่จะแทรก
      expandGap: 400,      // เว้นจากเส้นตัดลงมาก่อน ไม่ให้ไปติดรอยต่อพอดี
      tailGap: 300         // เว้นท้ายบทความไว้ ตรงนั้นมีช่องของเว็บรออยู่แล้ว
    },

    // true = จับ stack trace ตอนดักได้ เพื่อดูว่า "ไฟล์ไหน" เป็นคนสร้างของชิ้นนั้น
    // ใช้ตอนสืบหาตัวการ เสร็จงานแล้วปิดได้ (เปลืองนิดหน่อยตอนมีรายการเข้า)
    trace: true,

    // true = กันลิงก์ปูทับด้วย "รูปร่าง" ไม่ต้องรู้จักโดเมนมาก่อน
    // มีไว้เพราะระบบโฆษณาเป็นแบบประมูล ยิงมาคนละเจ้าทุกครั้ง ไล่บล็อกโดเมนไม่มีวันจบ
    // แต่รูปร่างของกับดักไม่เปลี่ยน ต้องเข้าเงื่อนไขครบทุกข้อถึงจะนับว่าเป็นกับดัก
    baitLinks: true
  };

  // ---------------------------------------------------------------------

  CFG.allowHosts.push(location.hostname);

  // ---- สำเนาส่วนตัวของรายชื่อที่ใช้ตัดสินใจบล็อก -----------------------
  //
  // ทำไมต้องมี: ทดสอบจริง 31 ก.ค. 2569 พบว่าสคริปต์อื่นบนหน้าสั่ง
  //   __adGuard.config.blockHosts.length = 0
  // แล้วสคริปต์จากโดเมนดำผ่านได้ทันที = ปิดการป้องกันทั้งหมดด้วยโค้ดบรรทัดเดียว
  //
  // สำเนาพวกนี้อยู่ในขอบเขตปิดของฟังก์ชัน ไม่มีทางเข้าถึงจากภายนอก
  // ต่อให้ใครหา CFG เจอและแก้ได้ การตัดสินใจบล็อกก็ไม่เปลี่ยน
  // ต้องคัดลอกหลัง push โดเมนตัวเองเข้า allowHosts แล้วเท่านั้น
  var BLOCK_HOSTS   = CFG.blockHosts.slice();
  var BLOCK_PATTERN = CFG.blockPatterns.slice();
  var ALLOW_HOSTS   = CFG.allowHosts.slice();
  var WATCH_HOSTS   = CFG.watchHosts.slice();
  var FRAME_ALLOW   = CFG.frameAllowHosts.slice();
  var OWN_SLOTS     = CFG.ownSlots.slice();
  var STRICT        = CFG.strict === true;

  // แช่แข็งอีกชั้น กันการแก้ค่าอื่น ๆ เช่น mode หรือสวิตช์ต่าง ๆ
  // ไม่มีโค้ดส่วนไหนของเราแก้ CFG หลังจุดนี้ จึงแช่แข็งได้ปลอดภัย
  try {
    [CFG.blockHosts, CFG.blockPatterns, CFG.allowHosts, CFG.watchHosts,
     CFG.frameAllowHosts, CFG.ownSlots, CFG.reportKinds, CFG.reportAlways, CFG.reportCritical,
     CFG.adBoxSelectors].forEach(function (a) { try { Object.freeze(a); } catch (e) {} });
    Object.freeze(CFG);
  } catch (e) {}

  var LOG = [];
  var BLOCKING = CFG.mode === 'block';         // ลงมือกับของที่ระบุตัวได้แน่นอน
  var HEUR = BLOCKING && CFG.enforceHeuristics; // ลงมือกับกฎที่ใช้การเดารูปร่าง
  // ตัดสินครั้งเดียวตอนเปิดหน้าว่าหน้านี้จะส่ง log ไหม
  // หน้าที่ไม่ถูกเลือกจะไม่ยิงอะไรออกไปเลย = ไม่กินโควตา ไม่กินแบนด์วิดท์ของคนอ่าน
  // โหมดตรวจสอบสำหรับคนทำเว็บ — เปิดที่เบราว์เซอร์ตัวเองด้วย
  //   localStorage.adGuardDebug = '1'   แล้วรีเฟรช
  // เครื่องนั้นจะส่ง log ครบทุกครั้งและจับ stack เต็ม ไม่ต้องรอดวงว่าจะถูกสุ่มไหม
  // ใช้ตอนอยากไล่ปัญหาบนมือถือเครื่องจริง ปิดด้วย localStorage.removeItem('adGuardDebug')
  var DEBUG = false;
  try { DEBUG = !!localStorage.getItem('adGuardDebug'); } catch (e) {}

  var SEND = DEBUG || Math.random() < CFG.reportSample;
  var SEND_HI = DEBUG || Math.random() < CFG.reportSampleAlways;
  var sentHi = 0;                              // โควตาแยกของเรื่องสำคัญ
  var sent = 0;                                // ส่งออกไปกี่ครั้งแล้วในการเปิดหน้าครั้งนี้

  // หน้านี้จะเฝ้าเรื่อง "ถูกพาออกจากหน้า" ไหม — ตัดสินครั้งเดียวตรงนี้
  // ต้องอยู่ก่อนหัวข้อ 3 (ล็อก window.open) ซึ่งอ่านค่าพวกนี้ ดูเหตุผลที่หัวข้อ 14
  var NAV_WATCH = CFG.watchForcedNav &&
                  (DEBUG || Math.random() < CFG.forcedNavSample);
  var navTold = 0;                             // ยิงได้ครั้งเดียวต่อหน้า ทั้งสองชนิดรวมกัน
  var LAST_TOUCH = 0;                          // เวลาที่นิ้วแตะ "ตัวหน้าเว็บเอง" ครั้งล่าสุด (2.9.20)

  // ---- ระบบกันเว็บล่ม ---------------------------------------------------
  // หลักการ: ด่านนี้รันเป็นตัวแรกบนทุกหน้าของเว็บข่าวที่มีคนอ่านห้าแสนครั้งต่อวัน
  // ถ้ามันพัง ห้ามลากเว็บพังไปด้วยเด็ดขาด ยอมให้ด่านหยุดทำงานดีกว่าเว็บเสีย
  //
  // ทุกทางเข้าของโค้ดเราต้องห่อด้วย safe() ทั้งหมด
  // ถ้าเกิด error ซ้ำเกิน ERR_LIMIT ครั้ง ให้ปิดตัวเองทิ้งทันที
  // แล้วปล่อยหน้าเว็บทำงานต่อเหมือนไม่เคยมีด่านอยู่
  var wipeMo = null;            // observer ของหัวข้อ 10 ต้องให้ selfDisable ถอดได้
  var stuckTimers = [];         // timer ของหัวข้อ 13 ต้องให้ selfDisable ล้างได้
  var ERR_LIMIT = 25;
  var errCount = 0;
  var DEAD = false;

  function selfDisable(why) {
    if (DEAD) return;
    DEAD = true;
    try { if (mo) mo.disconnect(); } catch (e) {}
    try { if (wipeMo) wipeMo.disconnect(); } catch (e) {}
    try { if (sweepTimer) clearInterval(sweepTimer); } catch (e) {}
    try { stuckTimers.forEach(function (t) { clearTimeout(t); }); } catch (e) {}
    try {
      if (DEBUG) console.warn('[ad-guard] ปิดตัวเองแล้ว เพื่อไม่ให้กระทบหน้าเว็บ:', why);
      if (window.__adGuard) window.__adGuard.dead = why;
    } catch (e) {}
  }

  // ห่อฟังก์ชันให้ error ไม่มีวันหลุดออกไปถึงหน้าเว็บ
  function safe(fn, label) {
    return function () {
      if (DEAD) return;
      try {
        return fn.apply(this, arguments);
      } catch (e) {
        errCount++;
        if (DEBUG) { try { console.warn('[ad-guard] ข้าม error ที่', label, e && e.message); } catch (e2) {} }
        if (errCount >= ERR_LIMIT) selfDisable('error เกิน ' + ERR_LIMIT + ' ครั้ง');
      }
    };
  }

  function host(url) {
    try { return new URL(url, location.href).hostname; } catch (e) { return ''; }
  }
  function match(h, list) {
    return list.some(function (d) { return h === d || h.endsWith('.' + d); });
  }
  function isBlocked(url) {
    var u = String(url || '');
    for (var i = 0; i < BLOCK_PATTERN.length; i++) {
      if (u.indexOf(BLOCK_PATTERN[i]) !== -1) return true;
    }
    var h = host(url);
    if (!h) return false;
    if (match(h, BLOCK_HOSTS)) return true;
    return STRICT ? !match(h, ALLOW_HOSTS) : false;
  }

  // ปลายทางที่ควรจดไว้ตอนถูกพาออกจากหน้า — ใช้ร่วมกันระหว่างหัวข้อ 3 กับ 14
  // ข้ามของในบ้านและบัญชีขาวทิ้ง เหตุผลอยู่ที่หัวข้อ 14
  function navWorthTelling(u) {
    if (!NAV_WATCH || navTold || !u) return false;
    var h = host(u);
    if (!h || h === location.hostname) return false;
    return !match(h, ALLOW_HOSTS);
  }

  // ---- ร่องรอยว่าคนอ่านลงมือเองหรือเปล่า (2.9.20) ----------------------
  //
  // `e.userInitiated` เป็น false ได้สองแบบที่ต่างกันสิ้นเชิง แต่หน้าตาเหมือนกันในล็อก
  //   1. โฆษณาพาออกไปเอง คนอ่านไม่ได้ทำอะไรเลย       <- ของที่เราตามหา
  //   2. คนอ่านแตะโฆษณาที่อยู่ใน iframe ข้ามโดเมน      <- เรื่องปกติ ห้ามไปกัน
  // แยกไม่ออกจึงตัดสิน lenzmx ไม่ได้ (nav-away ~500 ครั้ง/3 วัน แต่ไม่รู้ว่าแบบไหน)
  //
  // ตัวแยกคือ `navigator.userActivation` — ตามสเปก การลงมือของคนอ่านจะถูกส่งต่อ
  // ขึ้นไปให้เฟรมแม่ทุกชั้นด้วย **แม้ต้นทางเป็น iframe ข้ามโดเมน**
  // แบบ 2 จึงควรได้ isActive = true ส่วนแบบ 1 ไม่มีร่องรอยอะไรเลย
  //
  // **ยังไม่ได้ยืนยันว่าสเปกข้อนี้จริงในเบราว์เซอร์ของคนอ่าน** (จำลองการแตะใน
  // iframe ข้ามโดเมนจากฝั่งเราไม่ได้) จึงเก็บดิบทั้งสามค่าแล้วใช้ **ตัวสอบทานที่รู้คำตอบอยู่แล้ว**:
  // รายการที่ stack เป็น `amp-ad-exit` พาไปหน้าโฆษณาจริงพร้อม gclid = คนกดเองแน่นอน
  //   ถ้าพวกนั้นลงเป็น `nav-away` (มีร่องรอยลงมือ) = วิธีวัดนี้ใช้ได้ อ่านผลต่อได้
  //   ถ้าพวกนั้นลงเป็น `nav-forced` ด้วย         = สเปกไม่เป็นจริง **ห้ามเอาไปตัดสินใจบล็อก**
  // ตรวจข้อนี้ก่อนเสมอ ก่อนจะสรุปอะไรจากตัวเลข nav-forced
  //
  // อ่านค่าเฉพาะตอนกำลังจะรายงานเท่านั้น = หน้าที่ไม่มีอะไรเกิดขึ้นไม่มีต้นทุนเพิ่มเลย
  function navEvidence() {
    var ua = null;
    try { ua = navigator.userActivation; } catch (e) {}
    var act = !ua ? 'เบราว์เซอร์ไม่บอก'
            : ua.isActive ? 'ลงมืออยู่'
            : ua.hasBeenActive ? 'เคยลงมือแต่ไม่ใช่ตอนนี้' : 'ไม่เคยลงมือเลยทั้งหน้า';

    // แตะที่ตัวหน้าเว็บเองจะมี LAST_TOUCH ส่วนแตะใน iframe ข้ามโดเมนจะไม่มี
    // 'ลงมืออยู่' + 'ไม่เคยแตะหน้าเว็บ' = ลายเซ็นของการแตะโฆษณาใน iframe
    var since = LAST_TOUCH ? (Date.now() - LAST_TOUCH) : -1;

    // ถ้าโฟกัสไปอยู่ที่ iframe ตัวไหน = ตัวนั้นคือของที่คนอ่านแตะ ชี้ตัวได้ทันที
    var el = null, focus = 'ไม่มี';
    try { el = document.activeElement; } catch (e) {}
    if (el && el.tagName) {
      focus = el.tagName;
      // **ต้องเช็ค src ว่างก่อนเรียก host()** — host('') จะไปเทียบกับ location
      // แล้วคืน mgronline.com ทำให้ iframe ที่ไม่มี src (เคสที่พักไว้ 12 ส.ค.)
      // ดูเหมือนเป็น iframe ของเว็บเอง = โทษผิดตัวในเคสที่อยากรู้ที่สุดพอดี
      if (el.tagName === 'IFRAME') {
        focus += ' ' + (el.src ? (host(el.src) || 'อ่าน src ไม่ได้') : 'ไม่มี src');
      }
    }
    return 'ลงมือ:' + act +
           ' · แตะหน้าเว็บเมื่อ:' + (since < 0 ? 'ไม่เคย' : since + 'ms') +
           ' · โฟกัส:' + focus;
  }

  // ไล่ stack ขึ้นไปหาว่าใครเป็นคนเรียก โดยตัดบรรทัดที่เป็นตัวด่านเองทิ้ง
  // บรรทัดแรกที่เหลือคือไฟล์ที่สร้างของชิ้นนั้นขึ้นมา = ตัวการ
  // ใช้ได้เฉพาะตอนที่เราดักแบบซิงโครนัส (hook ตอน insert / ตอนตั้ง href)
  // ถ้ามาจาก MutationObserver stack จะเหลือแต่ของด่านเอง เพราะมันทำงานคนละจังหวะ
  function stackOf() {
    try {
      return ((new Error()).stack || '').split('\n').filter(function (ln) {
        return ln.indexOf('ad-guard.js') === -1 && /https?:\/\//.test(ln);
      }).slice(0, 5).join('\n');
    } catch (e) { return ''; }
  }

  // URL ของเฟรมบนสุดใน stack = ไฟล์ที่เป็นคนสั่ง
  // ใช้ตอนต้องตัดสินจาก "ใครสั่ง" แทน "ปลายทางคืออะไร" — จำเป็นกับหัวข้อ 14
  // เพราะปลายทางเป็น lazada://th/pdp ซึ่งเป็นแอปสุจริต บัญชีดำจับไม่ได้
  // ตัวที่ผิดคือคนสั่ง ไม่ใช่ปลายทาง
  function firstFrameUrl(st) {
    var m = String(st || '').split('\n')[0].match(/(https?:\/\/[^\s)]+)/);
    return m ? m[1] : '';
  }

  function report(kind, detail) {
    // ปิดตัวเองแล้วต้องเงียบสนิท รวมถึงไม่ยิง beacon อีก
    // จำเป็นเพราะตัวที่ไป patch ของเบราว์เซอร์ (document.write, setter ของ document.body)
    // **ไม่ได้ห่อด้วย safe()** โดยตั้งใจ (safe() กลืน error แล้วไม่คืนค่าของเดิม)
    // มันจึงยังทำงานต่อหลัง selfDisable และจะเรียก report() ได้ถ้าไม่กันตรงนี้
    if (DEAD) return;
    var rec = { kind: kind, detail: String(detail).slice(0, 500), ts: Date.now() };

    // ตัดสินก่อนว่าหน้านี้จะส่งรายการนี้ออกไปไหม
    // แล้วค่อยจับ stack เฉพาะตอนที่จะส่งจริง
    // เดิมจับก่อนตัดสิน = 98% ของหน้าเสียแรงจับ stack ทิ้งเปล่า ๆ
    var isHi = CFG.reportAlways.indexOf(kind) !== -1;
    // เรื่องที่หายากจนการสุ่มทำให้พลาด — ส่งเสมอ ไม่กินโควตาของถังไหนด้วย
    var isCritical = CFG.reportCritical.indexOf(kind) !== -1;
    var willSend = !!CFG.report &&
      CFG.reportKinds.indexOf(kind) !== -1 &&
      (isCritical ||
        (isHi ? (SEND_HI && sentHi < CFG.reportAlwaysMax)
              : (SEND && sent < CFG.reportMax)));

    if (CFG.trace && (willSend || DEBUG)) rec.stack = stackOf();

    // จำกัดความยาว log ในหน้า กันหน้าที่ถูกเปิดค้างไว้นาน ๆ กินหน่วยความจำเพิ่มไม่หยุด
    if (LOG.length >= 500) LOG.shift();
    LOG.push(rec);
    // เดิมพิมพ์ทุกครั้งที่จับอะไรได้ = ประกาศให้ทุกคนที่เปิด console รู้ว่ามีด่าน
    // และรู้ด้วยว่าด่านจับอะไรได้บ้าง ซึ่งเป็นข้อมูลที่ใช้ออกแบบวิธีเลี่ยงได้
    if (DEBUG) console.warn('[ad-guard]', BLOCKING ? 'BLOCKED' : 'SEEN', kind, rec.detail);

    if (!willSend) return;
    if (!isCritical) { if (isHi) sentHi++; else sent++; }
    try {
      navigator.sendBeacon(CFG.report, JSON.stringify({
        kind: kind, detail: rec.detail, page: location.href, ts: rec.ts,
        mode: CFG.mode, version: VERSION, stack: rec.stack || '',
        screen: screen.width + 'x' + screen.height
      }));
    } catch (e) {}
  }

  // ตัวอักษรที่ "มองเห็นจริง" — ตัดพวกช่องว่างล่องหนออกก่อนนับ
  // ท่าหลบที่เจอตอนทดสอบ: ยัด zero-width space ไว้ตัวเดียว ทำให้ดูเหมือนมีข้อความ
  // แต่คนอ่านไม่เห็นอะไรเลย trim() ปกติไม่ตัดตัวพวกนี้ให้
  function visibleText(s) {
    return String(s || '').replace(/[\s­​-‏⁠﻿]/g, '');
  }

  // ข้างในมีอะไรที่ "คนอ่านมองเห็น" ไหม — ถ้ามี แปลว่าเป็นโฆษณาจริง ไม่ใช่ชั้นล่องหน
  // นับทั้งแท็กรูป และการวาดพื้นหลัง เพราะโฆษณาเนทีฟจำนวนมาก (เช่น Taboola)
  // ไม่ได้ใช้ <img> เลย แต่วาดรูปด้วย background-image ที่ span ข้างใน
  // เคสจริงที่เจอ: <a class="item-thumbnail-href"><div><span class="thumbBlock" style="background-image:...">
  // ถ้าไม่นับพื้นหลัง จะไปถอด href ของโฆษณาที่มีรายได้ทิ้ง
  //
  // สำคัญ: ดูแค่ตัวเองกับลูกหลาน ห้ามไต่ขึ้นไปดูกล่องแม่
  // เพราะท่าหลบที่เจอตอนทดสอบคือเอาพื้นหลังไปแปะที่กล่องแม่ ส่วนลิงก์ยังล่องหน
  function hasVisibleMedia(el) {
    var m = el.querySelectorAll('img,picture,svg,video,canvas');
    var i, r, cs;
    for (i = 0; i < m.length; i++) {
      r = m[i].getBoundingClientRect();
      if (r.width < 8 || r.height < 8) continue;
      cs = getComputedStyle(m[i]);
      if (cs.visibility === 'hidden' || cs.display === 'none') continue;
      if (parseFloat(cs.opacity) < 0.05) continue;
      return true;
    }
    // ตัวเอง + ลูกหลาน (จำกัดจำนวนไว้ ไม่ให้การกวาดทุก 3 วิหน่วงหน้าเว็บ)
    var nodes = [el], kids = el.querySelectorAll('*');
    for (i = 0; i < kids.length && i < 30; i++) nodes.push(kids[i]);
    for (i = 0; i < nodes.length; i++) {
      r = nodes[i].getBoundingClientRect();
      if (r.width < 8 || r.height < 8) continue;
      cs = getComputedStyle(nodes[i]);
      if (cs.visibility === 'hidden' || cs.display === 'none') continue;
      if (parseFloat(cs.opacity) < 0.05) continue;
      if (cs.backgroundImage !== 'none') return true;
      var alpha = /rgba?\(([^)]+)\)/.exec(cs.backgroundColor);
      if (alpha) {
        var parts = alpha[1].split(',');
        if (parts.length < 4 || parseFloat(parts[3]) >= 0.1) return true;
      }
    }
    return false;
  }

  // parent = พ่อแม่ที่กำลังจะถูกแทรกเข้าไป ใช้ตอนที่ node ยังไม่อยู่ใน DOM
  // (ตอนนั้น closest() ของตัวมันเองยังไต่ขึ้นไปหา ownSlots ไม่เจอ)
  function isOurs(el, parent) {
    return OWN_SLOTS.some(function (s) {
      try {
        return el.closest(s) || (parent && parent.closest && parent.closest(s));
      } catch (e) { return false; }
    });
  }

  // node นี้โหลดมาจากโดเมนดำหรือเปล่า — ไม่สนขนาด เจอคือจบ
  function fromBlockedHost(el) {
    var u = el.src || el.getAttribute && el.getAttribute('data-src');
    if (u && isBlocked(u)) return true;
    try {
      var inner = el.querySelector && el.querySelector('[src]');
      if (inner && inner.src && isBlocked(inner.src)) return true;
    } catch (e) {}
    return false;
  }

  // ชั้นบังที่มองไม่เห็น
  function isOverlay(el) {
    if (!el || el.nodeType !== 1) return false;
    if (el === document.body || el === document.documentElement) return false;
    if (isOurs(el)) return false;

    var cs = getComputedStyle(el);
    if (cs.position !== 'fixed' && cs.position !== 'absolute') return false;
    if (cs.display === 'none' || cs.visibility === 'hidden') return false;
    // แตะทะลุได้ = ดักนิ้วไม่ได้ตั้งแต่แรก ไม่ใช่กับดัก
    // ของจริงบนหน้าข่าวคือ div.border ที่วาดกรอบรูปทับไว้ 14 ตัว ถ้าไม่ยกเว้นจะโดนซ่อนหมด
    // ถ้ามันแอบสลับกลับเป็นแตะได้ทีหลัง observer ที่เฝ้า style จะจับได้เอง
    if (cs.pointerEvents === 'none') return false;
    // ตัวที่วาดภาพเองไม่ใช่ชั้นล่องหน คนอ่านเห็นมันอยู่
    // ข้อมูลจริงจับได้ว่าโดนคือ <video> ของเว็บเองกับ <img> รูปข่าว
    // ถ้าไม่ยกเว้น พอเปิด block คนอ่านแตะรูปข่าวแล้วรูปจะหายไปเลย
    // ยกเว้นตอนมันจางจนแทบมองไม่เห็น ตรงนั้นปล่อยให้ตรวจต่อตามปกติ
    if (/^(IMG|VIDEO|CANVAS|SVG|PICTURE|EMBED|OBJECT)$/.test(el.tagName) &&
        parseFloat(cs.opacity || '1') >= 0.15) return false;

    var r = el.getBoundingClientRect();
    if (r.width * r.height < innerWidth * innerHeight * CFG.coverRatio) return false;

    // ของที่กำลังค่อย ๆ จางเข้ามา ห้ามตัดสินจากความจางตอนนี้
    // เจอของจริง: รูปโฆษณา Taboola (span.thumbBlock) โดนจับตอน opacity ยังไต่ไม่ถึง 1
    var animating = cs.animationName !== 'none' ||
                    cs.transitionProperty === 'all' || /opacity/.test(cs.transitionProperty);
    var seeThrough = !animating && cs.opacity !== '' && parseFloat(cs.opacity) < 0.15;
    var noPaint = /rgba\(0,\s*0,\s*0,\s*0\)|transparent/.test(cs.backgroundColor)
                  && cs.backgroundImage === 'none';
    var noText = visibleText(el.innerText).length === 0;

    return seeThrough || (noPaint && noText);
  }

  // certain = true  -> มาจาก blockHosts/blockPatterns คือรู้แน่ว่าเป็นของไม่ดี
  // certain = false -> มาจากการเดารูปร่าง ต้องรอ enforceHeuristics ถึงจะลงมือ
  function kill(el, why, certain) {
    // จดครั้งเดียวต่อ node — โหมด monitor ไม่ได้ซ่อนอะไร ถ้าไม่กันไว้
    // การกวาดทุก 3 วิจะจดตัวเดิมซ้ำไม่หยุดจน log บวมใช้งานไม่ได้
    if (!el.__agSeen) {
      el.__agSeen = 1;
      report(why, el.tagName + ' ' + (el.src || el.className || '') +
                  ' | ' + (el.outerHTML || '').slice(0, 200));
    }
    if (!(certain ? BLOCKING : HEUR)) return;
    try {
      el.style.setProperty('pointer-events', 'none', 'important');
      el.style.setProperty('display', 'none', 'important');
      if (CFG.removeNode) el.remove();
    } catch (e) {}
  }

  // ---- ปิดปาก iframe บุคคลที่สาม --------------------------------------
  // token พวกนี้คือประตูที่โฆษณาใช้เด้งแท็บ/ยึดหน้า ถอดทิ้งเสมอ
  // ต่อให้ตัว iframe ใส่ sandbox มาเองแล้วแอบเปิดสิทธิ์ไว้ก็ตาม
  var UNSAFE_SANDBOX = [
    'allow-popups',
    'allow-popups-to-escape-sandbox',
    'allow-top-navigation',
    'allow-top-navigation-by-user-activation',
    'allow-top-navigation-to-custom-protocols'
  ];

  // iframe โดเมนเดียวกับเรา — sandbox ใส่ไม่ทัน เพราะ about:blank ถูกสร้างเสร็จ
  // ตั้งแต่จังหวะ insert แล้ว attribute ที่ใส่ทีหลังมีผลตอน navigate ครั้งถัดไปเท่านั้น
  // แต่ของโดเมนเดียวกันเราเอื้อมเข้าไป patch ตรง ๆ ได้ ซึ่งได้ผลกว่า
  function patchFrameWindow(el) {
    try {
      var w = el.contentWindow;
      if (!w || w.__adGuardPatched) return;
      var o = w.open;
      w.open = function (u) {
        if (u && isBlocked(u)) {
          report('popup-blocked-iframe', u);
          if (BLOCKING) return null;
        }
        return o.apply(w, arguments);
      };
      w.__adGuardPatched = 1;
    } catch (e) {}                             // คนละโดเมน = แตะไม่ได้ ปล่อย sandbox จัดการ
  }

  function guardIframe(el, parent) {
    if (!CFG.sandboxIframes || !el || el.tagName !== 'IFRAME') return;
    if (isOurs(el, parent)) return;            // ช่องโฆษณาของเราเอง ไม่แตะ

    var src = (el.getAttribute('src') || '').trim();
    var h = src ? host(src) : '';
    // ไม่มี src / about:blank / srcdoc / javascript: = อยู่โดเมนเดียวกับเรา
    var inline = !h || el.hasAttribute('srcdoc') ||
                 /^(javascript|data|blob|about):/i.test(src);

    // embed ของจริงจากโดเมนที่เชื่อได้ (โดเมนตัวเอง, youtube, facebook) ปล่อยผ่าน
    // frameAllowHosts = เจ้าที่ยกเว้นเฉพาะเรื่อง iframe เท่านั้น กฎลิงก์ยังจับมันอยู่
    if (!inline && (match(h, ALLOW_HOSTS) || match(h, FRAME_ALLOW))) return;

    if (inline) patchFrameWindow(el);
    if (!el.__agHooked) {                      // navigate ทีไร window ใหม่ ต้อง patch ซ้ำ
      el.__agHooked = 1;
      el.addEventListener('load', function () { patchFrameWindow(el); });
    }

    var cur = el.getAttribute('sandbox');
    var next;
    if (cur === null) {
      next = inline ? CFG.iframeSandboxInline : CFG.iframeSandbox;
    } else {
      // ของเดิมมี sandbox อยู่แล้ว เก็บสิทธิ์เดิมไว้ ถอดเฉพาะตัวอันตราย
      next = cur.split(/\s+/).filter(function (t) {
        t = t.toLowerCase();
        if (!t || UNSAFE_SANDBOX.indexOf(t) !== -1) return false;
        return !(inline && t === 'allow-same-origin');
      }).join(' ');
    }
    if (next === cur) return;                  // ตรงอยู่แล้ว ไม่ต้องแตะ

    if (!el.__agFrameSeen) {                   // จดครั้งเดียวต่อ node กัน log บวม
      el.__agFrameSeen = 1;
      report('iframe-sandboxed', (src || 'about:blank') + ' -> sandbox="' + next + '"');
    }
    if (!HEUR) return;                         // sandbox เป็นกฎเดา ต้องรอเปิดสวิตช์ที่สอง
    try { el.setAttribute('sandbox', next); } catch (e) {}

    // Chrome ตัดสินสิทธิ์ sandbox ตอน "สร้าง browsing context" คือจังหวะที่ iframe
    // ถูกแทรกเข้า DOM ใส่ทีหลังจะไม่มีผลกับตัวที่แทรกไปแล้ว (ทดสอบยืนยันแล้ว)
    // ทางเดียวคือสั่ง navigate ใหม่ ให้มันคิดสิทธิ์รอบสองโดยมี sandbox ติดอยู่แล้ว
    // ทำครั้งเดียวพอ และทำเฉพาะตัวที่มี src จริง — ตัว about:blank ห้ามแตะ
    // เพราะจะล้างของที่สคริปต์เขียนใส่ไว้ทิ้ง (พวกนั้นใช้ patchFrameWindow แทน)
    if (!inline && src && el.isConnected && !el.__agReloaded) {
      el.__agReloaded = 1;
      try { el.setAttribute('src', src); } catch (e) {}
    }
  }

  // MutationObserver ช้ากว่าโค้ดโฆษณาอยู่หนึ่งจังหวะเสมอ ถ้ามันเขียนติดกันแบบ
  //   f = createElement('iframe'); body.appendChild(f); f.contentWindow.open(...)
  // ทั้งหมดจบใน task เดียว เรารู้ตัวตอน observer ยิงก็สายไปแล้ว
  // เลยต้องดักที่จังหวะ insert ตรง ๆ ให้ guardIframe ทำงานก่อนบรรทัดถัดไปของมัน
  // <link rel=preconnect> / <script src> ที่ชี้ไปโดเมนดำ
  // เจอของจริงบนหน้าข่าว: มีสคริปต์ยัด <link rel="preconnect" href="https://sowve.com/">
  // เข้า <head> ตอนรัน (ไม่มีใน HTML ต้นทาง) = อุ่นเครื่องรอยิงโฆษณา
  // ดักตรงนี้ได้ 2 อย่าง — รู้ว่าไฟล์ไหนเป็นคนยัด (จาก stack) และตัดไฟตั้งแต่ยังไม่โหลด
  function guardResource(el) {
    var u = el.getAttribute && (el.getAttribute('href') || el.getAttribute('src'));
    if (!u) return;

    // เฝ้าดูอย่างเดียว จดว่าใครเป็นคนแทรกเข้ามา แล้วปล่อยผ่าน
    if (match(host(u), WATCH_HOSTS)) {
      if (!el.__agWatched) { el.__agWatched = 1; report('watch-script', u); }
      return;
    }
    if (!isBlocked(u)) return;
    if (!el.__agResSeen) {
      el.__agResSeen = 1;
      report(el.tagName === 'LINK' ? 'preconnect-blocked' : 'script-blocked', u);
    }
    if (!BLOCKING) return;
    try {
      if (el.tagName === 'SCRIPT') {
        // ต้องทำ "ก่อน" ถูกแทรกถึงจะหยุดได้จริง ซ่อนทีหลังไม่หยุดการรัน
        el.type = 'text/ad-guard-blocked';
        el.removeAttribute('src');
      } else {
        el.remove();
      }
    } catch (e) {}
  }

  function scanArgs(args, parent) {
    for (var i = 0; i < args.length; i++) {
      var n = args[i];
      if (!n || (n.nodeType !== 1 && n.nodeType !== 11)) continue;
      if (n.tagName === 'IFRAME') { guardIframe(n, parent); continue; }
      if (n.tagName === 'A') { guardLink(n); continue; }
      if (n.tagName === 'LINK' || n.tagName === 'SCRIPT') { guardResource(n); continue; }
      if (!n.querySelectorAll) continue;
      var kids = n.querySelectorAll('iframe, a[href], link[href], script[src]');
      for (var j = 0; j < kids.length; j++) {
        var t = kids[j].tagName;
        if (t === 'IFRAME') guardIframe(kids[j], parent);
        else if (t === 'A') guardLink(kids[j]);
        else guardResource(kids[j]);
      }
    }
  }

  function hookInsert(proto, name) {
    var orig = proto && proto[name];
    if (typeof orig !== 'function') return;
    proto[name] = function () {
      // สำคัญมาก: ต้องเรียกของเดิมให้ได้เสมอ ไม่ว่าโค้ดเราจะพังยังไง
      // ถ้าตรงนี้พลาด หน้าเว็บจะแทรก element ไม่ได้เลย = เว็บล่มทั้งเว็บ
      if (DEAD) return orig.apply(this, arguments);
      // รอบแรก "ก่อน" แทรก — จังหวะเดียวที่ใส่ sandbox แล้วมีผลจริง
      try { scanArgs(arguments, this); } catch (e) { errCount++; }
      var r = orig.apply(this, arguments);
      // รอบสอง "หลัง" แทรก — ตอนนี้ถึงจะมี contentWindow ให้ patch (เผื่อ sandbox ไม่ทัน)
      try { scanArgs(arguments, this); } catch (e) { errCount++; }
      if (errCount >= ERR_LIMIT) selfDisable('error เกินระหว่างแทรก element');
      return r;
    };
  }
  hookInsert(Node.prototype, 'appendChild');
  hookInsert(Node.prototype, 'insertBefore');
  hookInsert(Node.prototype, 'replaceChild');
  hookInsert(Element.prototype, 'append');
  hookInsert(Element.prototype, 'prepend');

  // ท่าที่เจอบ่อย: สร้าง <a> เปล่า แทรกลง DOM ก่อน แล้วค่อยยัด href ทีหลัง
  // ตอนแทรกยังไม่มี href ด่านจึงยังไม่เห็นอะไร ต้องดักตอนตั้ง href ด้วย
  // ดักทั้งสองทาง เพราะ a.href = '...' ไม่ได้วิ่งผ่าน setAttribute
  var _setAttr = Element.prototype.setAttribute;
  Element.prototype.setAttribute = function (n) {
    var r = _setAttr.apply(this, arguments);
    try {
      if (this.tagName === 'A' && String(n).toLowerCase() === 'href') guardLink(this);
    } catch (e) {}
    return r;
  };

  var hrefDesc = Object.getOwnPropertyDescriptor(HTMLAnchorElement.prototype, 'href');
  if (hrefDesc && hrefDesc.set && hrefDesc.configurable) {
    Object.defineProperty(HTMLAnchorElement.prototype, 'href', {
      configurable: true,
      enumerable: hrefDesc.enumerable,
      get: hrefDesc.get,
      set: function (v) {
        hrefDesc.set.call(this, v);
        try { guardLink(this); } catch (e) {}
      }
    });
  }

  // ---- ถอดเขี้ยวลิงก์ทับหน้า -------------------------------------------
  // ของจริงที่เจอหน้างานหน้าตาแบบนี้ — <a> เปล่า ๆ ปูทับเนื้อหาข่าว
  //   <a href="https://<โดเมนดำ>/..." target="_blank" style="display:block;height:inherit"></a>
  // ไม่มีข้อความ ไม่มีรูป มองไม่เห็น แต่กินพื้นที่เต็มกล่องแม่ แตะตรงไหนก็โดน
  // ตัวนี้ไม่ผ่าน window.open เลยหลุดด่านข้อ 3 ต้องถอด href ทิ้งตั้งแต่มันโผล่
  // ไม่ใช่รอไปกันตอนนิ้วแตะอย่างเดียว
  // ระบบโฆษณาเป็นแบบประมูล ยิงมาคนละเจ้าทุกครั้ง บล็อกทีละโดเมนไม่มีวันจบ
  // แต่ "รูปร่าง" ของกับดักไม่เปลี่ยน — ต้องเข้าครบทุกข้อถึงนับ ขาดข้อเดียวก็ปล่อย
  // เรียงจากเช็คถูกไปแพง เพื่อไม่ให้การกวาดทุก 3 วิหน่วงหน้าเว็บ
  function isBaitLink(el) {
    if (!CFG.baitLinks) return false;
    if (el.target !== '_blank') return false;              // ต้องตั้งใจเปิดแท็บใหม่
    var h = el.hostname;
    if (!h || h === location.hostname) return false;       // ลิงก์ในบ้านตัวเอง ไม่เกี่ยว
    if (match(h, ALLOW_HOSTS)) return false;
    if (visibleText(el.textContent)) return false;          // มีตัวหนังสือจริง = ลิงก์จริง
    if (hasVisibleMedia(el)) return false;                  // มีรูปที่เห็นได้ = แบนเนอร์จริง

    var rect = el.getBoundingClientRect();
    var area = rect.width * rect.height;
    var fixed = getComputedStyle(el).position === 'fixed';

    // ปกติใช้ขนาดของลิงก์เอง — ห้ามไปเอาขนาดกล่องแม่มาใช้พร่ำเพรื่อ
    // ข้อมูลจริงจากคนอ่านบอกว่าถ้าทำแบบนั้น ไอคอนอินสตาแกรมกับป้ายแอปสโตร์
    // ที่บังเอิญอยู่ในกล่องใหญ่ จะถูกนับเป็นของใหญ่ไปด้วยแล้วโดนถอด href
    // ไปดูกล่องแม่เฉพาะตอนที่ลิงก์วัดขนาดตัวเองแทบไม่ได้เลย
    // ซึ่งคือท่า height:inherit ของกับดักตัวจริงที่ต้องพึ่งกล่องแม่ยืดให้
    // ไต่ขึ้นไปดูกล่องแม่เสมอ เพื่อรู้ว่า "ลอยตามจอ" หรือเปล่า (มีผลกับเกณฑ์ขนาด)
    // แต่จะหยิบ "ขนาด" ของกล่องแม่มาใช้เฉพาะตอนที่ลิงก์วัดตัวเองแทบไม่ได้เท่านั้น
    var tiny = area < 100;
    var p = el.parentElement, n = 0;
    while (p && n++ < 3) {
      var pcs = getComputedStyle(p);
      if (pcs.position === 'fixed' || pcs.position === 'absolute') {
        if (pcs.position === 'fixed') fixed = true;
        if (tiny) {
          var pr = p.getBoundingClientRect();
          if (pr.width * pr.height > area) area = pr.width * pr.height;
        }
        break;
      }
      p = p.parentElement;
    }
    // ชั้นที่ลอยตามจอใช้เกณฑ์เข้มกว่า เพราะไอคอนโซเชียลปกติเล็กกว่านี้หลายสิบเท่า
    var need = fixed ? CFG.coverRatioFixed : CFG.coverRatio;
    if (area < innerWidth * innerHeight * need) return false;

    // มีพื้นหลังเป็นรูป = มองเห็นได้ ถือว่าเป็นโฆษณาจริง ไม่ใช่ชั้นล่องหน
    return getComputedStyle(el).backgroundImage === 'none';
  }

  function guardLink(el) {
    if (!el || el.tagName !== 'A' || !el.getAttribute('href')) return;
    if (isOurs(el)) return;

    var byHost = isBlocked(el.href);
    if (!byHost) {
      if (!isBaitLink(el)) { el.__agBaitFirst = 0; return; }

      // ต้องเข้าเงื่อนไขซ้ำอีกรอบห่างกันอย่างน้อย 2 วิ ถึงจะลงมือ
      // เพราะโฆษณาเนทีฟจำนวนมากโหลดรูปแบบ lazy — ตอนแรกกล่องยังว่าง หน้าตาเหมือนกับดักเป๊ะ
      // ข้อมูลจริงจากคนอ่านยืนยันแล้วว่าถ้าตัดสินทันที จะไปถอด href โฆษณา Taboola ทั้งเว็บ
      // ระหว่าง 2 วินาทีนี้ยังปลอดภัย เพราะด่านดักตอนนิ้วแตะยังทำงานเต็มที่
      var now = Date.now();
      if (!el.__agBaitFirst) { el.__agBaitFirst = now; return; }
      if (now - el.__agBaitFirst < 2000) return;
    }

    if (!el.__agLinkSeen) {                    // จดครั้งเดียวต่อ node กัน log บวม
      el.__agLinkSeen = 1;
      report(byHost ? 'link-neutralized' : 'bait-link', el.href);
    }
    if (!(byHost ? BLOCKING : HEUR)) return;
    try {
      el.removeAttribute('href');              // ไม่มี href = คลิกแล้วไม่ไปไหน
      el.removeAttribute('target');
      el.style.setProperty('pointer-events', 'none', 'important');
    } catch (e) {}
  }

  // ---- คืนที่ให้คนอ่าน เมื่อกล่องโฆษณาจองที่แล้วไม่มีของมาลง ------------
  // ใช้เกณฑ์ "มองเห็นได้จริง" ตัวเดียวกับกฎ bait-link ซึ่งจูนกับของจริงมาแล้ว
  // (นับพื้นหลังเป็นรูปด้วย เพราะโฆษณาเนทีฟหลายเจ้าไม่ใช้ <img> เลย)
  function adBoxEmpty(el) {
    if (visibleText(el.innerText)) return false;
    // สำคัญ: โฆษณา GPT/safeframe อยู่ใน iframe คนละโดเมน มองข้างในไม่ได้
    // hasVisibleMedia เช็คแค่ img/video/canvas จึงอ่านกล่องที่มีโฆษณาจริงว่า "ว่าง"
    // ทดสอบเจอของจริง: #header-ads (100px) กับ #detail-ads (250px) มีโฆษณาอยู่
    // แต่ถูกอ่านว่าว่าง ถ้าไม่ดักตรงนี้ = ซ่อนโฆษณาที่มีคนจ่ายเงิน
    var fr = el.querySelectorAll('iframe,embed,object');
    for (var i = 0; i < fr.length; i++) {
      var r = fr[i].getBoundingClientRect();
      if (r.width > 20 && r.height > 20) return false;
    }
    return !hasVisibleMedia(el);
  }

  var AD_BOX_SEL = CFG.adBoxSelectors.join(',');

  // กล่องนี้มีช่องโฆษณาของ Google ลงทะเบียนอยู่ข้างในหรือเปล่า
  //
  // เหตุผลที่ต้องมี: ตัวยุบกล่องเป็นการแก้เฉพาะหน้าแทนโค้ดโฆษณาของเว็บ
  // วันที่โปรแกรมเมอร์ต่อช่อง GPT ให้ตำแหน่งนั้นเสร็จ GAM จะดูแลเองได้ทั้งการเติมและการยุบ
  // ถ้าเรายังไปถอดความสูงที่ GAM จองไว้ก่อนโฆษณาเรนเดอร์ หน้าจะกระตุกทุกครั้งที่โฆษณามาลง
  //
  // เดิมกันด้วยการ "ให้คนมาบอกแล้วเราปิดสวิตช์" ซึ่งฝากความปลอดภัยไว้กับการสื่อสาร ลืมได้
  // เปลี่ยนเป็นให้ด่านถอนตัวเองทันทีที่เห็นว่ามีช่องลงทะเบียนแล้ว ไม่ต้องรอใครแจ้ง
  // และถ้าเขา rollback ตัวช่วยก็กลับมาทำงานเองเหมือนกัน
  //
  // อ่านค่าเฉย ๆ ไม่แตะอะไรของ googletag · ถ้า GPT ยังไม่พร้อมถือว่าไม่มีช่อง
  // (กรณีนั้นเราถอดแค่ inline height ไม่ได้บังคับเป็น 0 ของที่มาทีหลังยังดันกล่องออกได้)
  function hasGptSlot(el) {
    try {
      if (!window.googletag || !googletag.apiReady || !googletag.pubads) return false;
      var slots = googletag.pubads().getSlots();
      for (var i = 0; i < slots.length; i++) {
        var id = slots[i].getSlotElementId && slots[i].getSlotElementId();
        if (!id) continue;
        var d = document.getElementById(id);
        if (d && el.contains(d)) return true;
      }
    } catch (e) {}
    return false;
  }

  function collapseEmptyAdBox(el) {
    if (!CFG.collapseEmptyAdBoxes || !el || el.nodeType !== 1) return;
    // ด่านต้องกันตัวเองที่นี่ ห้ามไปพึ่งว่าคนเรียกจะกรองมาให้
    // บั๊กจริงใน 2.6.0/2.6.1: hook ของ observer เรียกฟังก์ชันนี้กับทุก element
    // ที่ attribute เปลี่ยน ทำให้ไปถอด inline height ของ google_ads_iframe,
    // p-lightbox-bg, twitter-widget, line-it-button, VIDEO รวม 23 ตัวที่ไม่เกี่ยวเลย
    if (!AD_BOX_SEL) return;
    try { if (!el.matches || !el.matches(AD_BOX_SEL)) return; } catch (e) { return; }
    if (isOurs(el)) return;
    var st = el.style;
    if (!st) return;
    // แตะเฉพาะตัวที่ถูกยัด inline ไว้จองที่ ถ้าไม่มีก็ไม่ใช่เรื่องของเรา
    // เช็คก่อนสองอย่างข้างล่างเพราะถูกกว่ามาก กรองทิ้งได้เกือบทั้งหมดตรงนี้
    if (!st.height && !st.paddingTop) return;
    // มีช่อง GPT ลงทะเบียนแล้ว = ต้นเหตุถูกแก้แล้ว ด่านถอนตัวเอง
    if (hasGptSlot(el)) {
      if (!el.__agStoodDown) {
        el.__agStoodDown = 1;
        report('ad-box-handover', (el.id || el.className || el.tagName) +
               ' มีช่อง GPT แล้ว ด่านถอนตัว ปล่อยให้ GAM จัดการ');
      }
      return;
    }
    if (!adBoxEmpty(el)) return;                 // มีโฆษณาอยู่จริง ห้ามแตะเด็ดขาด
    // เพดานกันการสู้กันไม่จบ — ต้องสูงกว่าลูปของเว็บ
    // header.min.js ใช้ ContentResize ที่ตั้ง loop_: 10 คือใส่ความสูงซ้ำได้ถึง 10 รอบ
    // **เคยตั้งไว้ 5 แล้วเราแพ้** พอครบเราหยุด รอบที่ 6 ของเว็บชนะ ช่องขาวกลับมา
    // เห็นอาการเฉพาะตอนโหลดเย็น (คนเข้าเว็บครั้งแรก = เคสมือถือที่ผู้ใช้เจอ)
    // รอบโหลดปกติจังหวะไม่ตรงกันจึงไม่เห็น — เจอเพราะบังเอิญ hard reload ตอนตรวจ 2.7.0
    //
    // ตั้ง 20 เพราะลูปของเว็บมีขอบเขตแน่นอนที่ 10 เราจึงชนะเสมอ
    // และยังกันการสู้กันไม่จบได้ ถ้าวันหนึ่งมีโค้ดที่ยัดกลับไม่หยุดจริง ๆ
    // ตัวนับขึ้นเฉพาะตอน "เว็บยัดกลับมา" เท่านั้น — การถอดของเราเองไม่นับ
    // เพราะรอบถัดไปจะเจอว่าไม่มี inline height แล้ว return ออกก่อน
    el.__agShrunkN = (el.__agShrunkN || 0) + 1;
    if (el.__agShrunkN > 20) return;
    try {
      var was = st.height || st.paddingTop;
      // ถอดทิ้ง ไม่ใช่บังคับเป็น 0 — ถ้าบังคับ 0 แบบ important
      // โฆษณาที่มาทีหลังจะดันกล่องออกไม่ได้ กลายเป็นซ่อนของที่มีคนจ่ายเงิน
      // ถอดออกแล้วกล่องว่างสูง 0 เอง และของที่มาทีหลังดันออกมาเองตามธรรมชาติ
      st.removeProperty('height');
      st.removeProperty('padding-top');
      if (!el.__agShrunk) {
        el.__agShrunk = 1;
        report('ad-box-collapsed', (el.id || el.className || el.tagName) + ' คืนที่ ' + was);
      }
    } catch (e) {}
  }

  // ไล่ขึ้นไปหากล่องโฆษณาที่ครอบอยู่ ใช้ตอนมี node ใหม่โผล่ข้างใน
  function adBoxOf(el) {
    if (!CFG.collapseEmptyAdBoxes || !AD_BOX_SEL) return null;
    var p = el, n = 0;
    while (p && p.nodeType === 1 && n++ < 6) {
      try { if (p.matches && p.matches(AD_BOX_SEL)) return p; } catch (e) { return null; }
      p = p.parentElement;
    }
    return null;
  }

  function sweepAdBoxes(root) {
    if (!CFG.collapseEmptyAdBoxes || !AD_BOX_SEL) return;
    var list;
    try { list = root.querySelectorAll(AD_BOX_SEL); } catch (e) { return; }
    for (var i = 0; i < list.length && i < 40; i++) collapseEmptyAdBox(list[i]);
  }

  function inspect(el, why) {
    if (fromBlockedHost(el)) { kill(el, 'blocked-host', true); return; }
    guardIframe(el);
    guardLink(el);
    if (isOverlay(el)) kill(el, why, false);
  }

  // ---- 1. เฝ้า DOM ----------------------------------------------------
  var mo = new MutationObserver(safe(function (muts) {
    for (var i = 0; i < muts.length; i++) {
      var m = muts[i];
      if (m.type === 'attributes') {
        inspect(m.target, 'overlay-restyled');
        // จังหวะที่โค้ดโฆษณายัด inline height เข้ามาจองที่ = จังหวะที่เราเห็นได้เร็วสุด
        // ถ้าตอนนั้นกล่องยังว่าง ยุบทันทีไม่ต้องรอรอบกวาด คนอ่านจะไม่เห็นช่องขาวเลย
        // ปลอดภัยเพราะเราแค่ถอด inline ทิ้ง ของที่มาทีหลังยังดันกล่องออกได้เอง
        collapseEmptyAdBox(m.target);
        continue;
      }
      for (var j = 0; j < m.addedNodes.length; j++) {
        var n = m.addedNodes[j];
        if (n.nodeType !== 1) continue;
        inspect(n, 'overlay-added');
        var adBox = adBoxOf(n);
        if (adBox) collapseEmptyAdBox(adBox);
        // ส่วนใหญ่โฆษณาแทรกมาเป็นก้อน <div><a></a></div> หรือ <div><iframe></div>
        // ตัว addedNodes เห็นแค่ div ต้องไล่ลงไปข้างในเองถึงจะเจอตัวจริง
        if (n.querySelectorAll) {
          var kids = n.querySelectorAll('iframe, a[href]');
          for (var k = 0; k < kids.length; k++) {
            if (kids[k].tagName === 'IFRAME') guardIframe(kids[k]);
            else guardLink(kids[k]);
          }
        }
      }
    }
  }, 'เฝ้า DOM'));

  var OBS = {
    childList: true, subtree: true,
    attributes: true,
    attributeFilter: ['style', 'class', 'src', 'sandbox', 'srcdoc', 'href', 'target']
  };

  // Shadow DOM เป็นห้องปิด — querySelectorAll ของหน้าหลักส่องเข้าไปไม่เห็น
  // และ MutationObserver ที่เกาะ documentElement ก็ไม่ได้ยินอะไรข้างใน
  // ทดสอบแล้วยืนยันว่าเป็นช่องหลบจริง ต้องดักตอนเปิดห้องแล้วตามเข้าไปเฝ้าเอง
  var shadows = [];
  var _attach = Element.prototype.attachShadow;
  if (typeof _attach === 'function') {
    Element.prototype.attachShadow = function () {
      var root = _attach.apply(this, arguments);
      try { shadows.push(root); mo.observe(root, OBS); } catch (e) {}
      return root;
    };
  }

  // เพดานจำนวน element ที่ยอมกวาดต่อรอบ
  // หน้าข่าวจริงมี element เป็นพัน ๆ การเรียก getComputedStyle ทุกตัวทุก 3 วิ
  // บังคับให้เบราว์เซอร์คำนวณ layout ใหม่ทั้งหน้า บนมือถือรุ่นเก่าจะกระตุกให้เห็น
  // ยอมกวาดไม่ครบดีกว่าทำให้คนอ่านสะดุด — ของที่ตกหล่นยังมี observer คอยจับอยู่
  var SWEEP_MAX = 1200;

  function sweepRoot(root) {
    var all = root.querySelectorAll('*');
    var n = Math.min(all.length, SWEEP_MAX);
    for (var i = 0; i < n; i++) inspect(all[i], 'overlay-sweep');
  }

  var sweepTimer = null;

  function boot() {
    mo.observe(document.documentElement, OBS);
    // iframe ที่มีอยู่ก่อนด่านจะตื่น (กรณีสคริปต์ถูกวางไม่ใช่แท็กแรก)
    var fr0 = document.querySelectorAll('iframe');
    for (var f = 0; f < fr0.length; f++) guardIframe(fr0[f]);

    // กวาดตอนเบราว์เซอร์ว่าง ไม่ไปแย่งจังหวะกับการเลื่อนหน้าหรือการวาดภาพ
    var runSweep = safe(function () {
      if (!document.body) return;
      sweepRoot(document.body);
      sweepAdBoxes(document);          // ตัวที่หลุดจาก observer ยังโดนเก็บที่นี่
      for (var i = shadows.length - 1; i >= 0; i--) {
        var h = shadows[i].host;
        if (!h || !h.isConnected) { shadows.splice(i, 1); continue; }   // ถูกถอดไปแล้ว
        sweepRoot(shadows[i]);
      }
    }, 'กวาดหน้า');

    sweepTimer = setInterval(function () {
      if (DEAD) return;
      if (typeof requestIdleCallback === 'function') requestIdleCallback(runSweep, { timeout: 2000 });
      else runSweep();
    }, 3000);
  }
  if (document.documentElement) boot();
  else document.addEventListener('DOMContentLoaded', boot);

  // ---- 2. ดักสัมผัสก่อนใคร -------------------------------------------
  ['pointerdown', 'touchstart', 'mousedown', 'click'].forEach(function (ev) {
    document.addEventListener(ev, safe(function (e) {
      // จดไว้ก่อนทำอย่างอื่น ใช้แยก "แตะที่ตัวหน้าเว็บ" ออกจาก "แตะใน iframe" ตอนหัวข้อ 14
      // อยู่ในตัวดักที่มีอยู่แล้ว = ไม่ได้เพิ่ม listener ให้หน้าเว็บ ต้นทุนคือ Date.now() ต่อการแตะ
      //
      // **ต้องเช็ค isTrusted** — ทดสอบบนหน้าจริง 1 ก.ย. 2569 พบว่ามีการแตะถูกบันทึก
      // 25.9 วินาทีก่อนหน้า ทั้งที่ไม่มีใครแตะจอเลย = สคริปต์บนหน้ายิง event ปลอมใส่
      // ถ้าไม่กรอง ค่า "แตะหน้าเว็บเมื่อ" จะปนของปลอมจนใช้แยกอะไรไม่ได้
      // (ของปลอมยังนับเป็น overlay-touched ตามเดิม ตรงนั้นตั้งใจให้จับทุกแบบ ไม่แตะ)
      if (e.isTrusted) LAST_TOUCH = Date.now();
      var p = (e.touches && e.touches[0]) || e;
      var t = document.elementFromPoint(p.clientX, p.clientY);
      // ถ้าใต้นิ้วเป็นประตูห้องปิด (shadow host) ต้องส่องเข้าไปข้างในต่อ
      // ไม่งั้นเห็นแค่กล่องเปล่า ๆ ของจริงซ่อนอยู่ข้างใน
      var hop = 0;
      while (t && t.shadowRoot && t.shadowRoot.elementFromPoint && hop++ < 4) {
        var inner = t.shadowRoot.elementFromPoint(p.clientX, p.clientY);
        if (!inner || inner === t) break;
        t = inner;
      }

      var badHost = t && fromBlockedHost(t);
      if (t && (badHost || isOverlay(t))) {
        report('overlay-touched', t.tagName + ' ' + (t.src || t.className || ''));
        if (badHost ? BLOCKING : HEUR) {
          e.preventDefault(); e.stopPropagation(); kill(t, 'overlay-touched', badHost);
        }
        return;
      }
      // เช็คตอนนิ้วแตะด้วย เพราะกฎรูปร่างต้องรอให้หน้าจัดวางเสร็จก่อนถึงวัดขนาดได้
      // ถ้ากับดักโผล่มาแล้วนิ้วแตะก่อนที่การกวาดรอบถัดไปจะมาถึง ตรงนี้คือด่านสุดท้าย
      var a = (t && t.closest && t.closest('a[href]')) || null;
      if (!a && e.composedPath) {                // ลิงก์ที่พาดข้ามขอบ shadow DOM
        var path = e.composedPath();
        for (var pi = 0; pi < path.length; pi++) {
          var el = path[pi];
          if (el && el.tagName === 'A' && el.getAttribute && el.getAttribute('href')) { a = el; break; }
        }
      }
      if (a && !isOurs(a)) {
        var sure = isBlocked(a.href);
        if (sure || isBaitLink(a)) {
          report('link-blocked', a.href);
          if (sure ? BLOCKING : HEUR) { e.preventDefault(); e.stopPropagation(); }
        }
      }
    }, 'ดักสัมผัส'), { capture: true, passive: false });
  });

  // ---- 3. ล็อก window.open ------------------------------------------
  var _open = window.open;
  function safeOpen(u) {
    // ตัวนี้ไป patch ของเบราว์เซอร์ จึงห้ามห่อด้วย safe() (safe() กลืน error
    // แล้วไม่คืนค่าของเดิม = หน้าเว็บเรียก window.open แล้วไม่ได้อะไรกลับ)
    // ต้องห่อเองด้วย try/catch เพื่อการันตีว่ายังไงก็ไปถึง _open.apply ข้างล่าง
    var blocked = false;
    try {
      if (u && isBlocked(u)) {
        blocked = true;
        report('popup-blocked', u);
      } else if (navWorthTelling(u)) {
        // เปิดแท็บใหม่ไปโดเมนที่เราไม่รู้จัก — **จดอย่างเดียว ไม่กัน**
        // ครึ่งหนึ่งของอาการที่คนอ่านรายงานคือ "เปิดหน้าใหม่" ซึ่งมาทางนี้
        // ของเดิมเห็นเฉพาะโดเมนที่รู้จักอยู่แล้ว = เจ้าใหม่ผ่านไปเงียบ ๆ
        navTold = 1;
        report('popup-seen', String(u));
      }
    } catch (e) {}
    if (blocked && BLOCKING) return null;
    return _open.apply(window, arguments);
  }
  try {
    Object.defineProperty(window, 'open', {
      value: safeOpen, writable: false, configurable: false
    });
  } catch (e) {
    // บางกรณีมีคนล็อก window.open ไว้ก่อนแล้ว เขียนทับไม่ได้
    // ต้องกันไว้อีกชั้น เพราะไฟล์นี้เป็น strict mode การเขียนทับที่ล้มเหลวจะโยน error
    try { window.open = safeOpen; } catch (e2) {}
  }

  // ---- 4. กันทริค a.click() ------------------------------------------
  var _click = HTMLElement.prototype.click;
  HTMLElement.prototype.click = function () {
    if (this.tagName === 'A' && this.href && isBlocked(this.href)) {
      report('synthetic-click', this.href);
      if (BLOCKING) return;
    }
    return _click.apply(this, arguments);
  };

  // ---- 5. สกัดโฆษณาคั่นหน้าเต็มจอ ------------------------------------
  // ด่านรันก่อน gpt.js เสมอ จึงจองคิวใน googletag.cmd ได้เป็นคิวแรก
  // พอ GPT พร้อม มันจะรันคิวตามลำดับ ของเราจึงได้ห่อ defineOutOfPageSlot
  // ก่อนที่โค้ดของเว็บจะเรียกใช้
  function patchVignette() {
    var gt = window.googletag;
    if (!gt || typeof gt.defineOutOfPageSlot !== 'function' || gt.__agVigPatched) return;
    var orig = gt.defineOutOfPageSlot;
    gt.defineOutOfPageSlot = function (unit, fmt) {
      try {
        var F = gt.enums && gt.enums.OutOfPageFormat;
        if (F && fmt === F.INTERSTITIAL) {
          report('vignette-blocked', String(unit).slice(0, 120));
          return null;                     // สัญญาของ GPT: null = สร้างช่องไม่ได้
        }
      } catch (e) { /* ตัดสินไม่ได้ = ปล่อยผ่าน ห้ามทำให้ของเดิมพัง */ }
      return orig.apply(gt, arguments);    // รูปแบบอื่น (anchor ฯลฯ) ไม่แตะ
    };
    gt.__agVigPatched = 1;
  }

  if (CFG.blockVignette) {
    try {
      window.googletag = window.googletag || { cmd: [] };
      if (window.googletag.cmd && typeof window.googletag.cmd.push === 'function') {
        window.googletag.cmd.push(safe(patchVignette, 'สกัด vignette'));
      }
    } catch (e) { /* ห้ามให้เรื่องนี้ทำให้ด่านหรือเว็บพัง */ }
  }

  // ---- 9. หาตัวที่ล้างหน้าเว็บทิ้ง — ดูอย่างเดียว ไม่ขวางอะไรทั้งสิ้น ----
  //
  // อาการ (ยืนยันจากสองทาง 1 ส.ค. 2569): `body.children.length = 0` บนหน้า server render
  // เนื้อหามากับ HTML แน่นอน แล้วถูกลบทีหลัง = ทั้งหน้าไม่เหลืออะไรเลย ต้องรีเฟรชสถานเดียว
  // ด่านเราจับได้เอง (จุดตรวจทั้ง 7 จุดเจอแต่ HTML/BODY) และมีคนนอกรายงานเข้ามาตรงกัน
  //
  // **ตัดออกไปแล้วสองราย**: ด่านเราเอง (ไม่มีโค้ดที่ทำได้ ตรวจครบทุกบรรทัด)
  // และครีเอทีฟทั้งหมดในระบบแบนเนอร์ของเว็บ (ไม่มี document.write สักตัว)
  //
  // ผู้ต้องสงสัยที่เหลือคือ `document.write()` ที่ถูกเรียก **หลังหน้าแจงเสร็จแล้ว**
  // ตอนนั้นเบราว์เซอร์จะสั่ง `document.open()` ให้เอง ซึ่ง **ล้างทั้งเอกสารทิ้ง**
  // เรียกตอนหน้ากำลังแจงอยู่ (readyState = 'loading') เป็นเรื่องปกติ ไม่ล้างอะไร
  // จึงรายงานเฉพาะตอน readyState ไม่ใช่ 'loading' = เฉพาะเคสที่อันตรายจริง
  //
  // **ข้อควรระวังที่สุดของทั้งไฟล์อยู่ตรงนี้**
  // นี่คือการไปห่อฟังก์ชันของเบราว์เซอร์ที่สคริปต์โฆษณาหลายเจ้าใช้จริง
  // ถ้าเราพลาด **สคริปต์ที่พึ่งมันจะพังทั้งเว็บ ไม่ใช่แค่ด่านพัง**
  // โครงจึงเขียนให้ส่วนที่จับหลักฐานอยู่ใน try/catch ของตัวเอง
  // และ **การเรียกของเดิมอยู่นอกทุกเงื่อนไข** — ต่อให้โค้ดเราพังยับ ของเดิมก็ยังถูกเรียกเสมอ
  // ไม่ใช้ safe() ตรงนี้โดยตั้งใจ เพราะ safe() จะกลืน error แล้ว **ไม่คืนค่าของเดิม**
  //
  // stackOf() กรองบรรทัดที่มี ad-guard.js ออกอยู่แล้ว เฟรมที่เหลือจึงเป็นของคนเรียกล้วน ๆ
  if (CFG.watchDocWrite) {
    var docWriteSeen = {};        // รายงานชนิดละครั้งเดียวต่อหน้า ไม่ยิงรัว
    ['write', 'writeln', 'open'].forEach(function (name) {
      var orig;
      try { orig = document[name]; } catch (e) { return; }
      if (typeof orig !== 'function') return;
      try {
        document[name] = function () {
          try {
            if (document.readyState !== 'loading' && !docWriteSeen[name]) {
              docWriteSeen[name] = 1;
              report('doc-write-late', 'document.' + name + '() ถูกเรียกตอน readyState=' +
                document.readyState + ' · body มีลูก ' +
                (document.body ? document.body.children.length : '-') + ' ตัว');
            }
          } catch (e) { /* จับหลักฐานไม่ได้ก็ช่างมัน ห้ามขวางของเดิม */ }
          return orig.apply(this || document, arguments);
        };
      } catch (e) { /* เขียนทับไม่ได้ก็ปล่อยไป ของเดิมยังทำงานปกติ */ }
    });
  }

  // ---- 6. ยุบกล่อง AdSense ที่ Google บอกเองว่าไม่มีโฆษณา ---------------
  //
  // หลักฐานจากหน้าจริง 31 ก.ค. 2569 (ผู้ใช้เปิด DevTools ดูข้างใน iframe ให้):
  //   ins.adsbygoogle มี data-ad-status="unfilled"
  //   ข้างใน iframe คือ <body></body> ว่างเปล่า ไม่มีอะไรเลย
  //   และ iframe ส่ง postMessage กลับมาว่า {"msg_type":"resize-me","r_nh":"0"}
  //   = Google ขอให้ย่อความสูงเหลือ 0 เอง แต่หน้าเว็บไม่ได้ทำให้
  // ผลคือกล่องค้างที่ 280px ต่อหน่วย · วัดจริงหน้าเดียวเจอ 2 หน่วย = 560px
  //
  // ทำไมปลอดภัย: เราไม่ได้ตัดสินใจแทน Google ว่ามีโฆษณาหรือไม่
  // กฎจับเฉพาะกล่องที่ **Google ติดป้าย unfilled ให้เอง** และขอให้ย่อเองอยู่แล้ว
  // ไม่มีการนับ impression เกิดขึ้น จึงไม่ใช่การซ่อนโฆษณาที่มีคนจ่ายเงิน
  //
  // และมันแก้ตัวเองอัตโนมัติ — ถ้าวันไหนกล่องนั้นได้โฆษณา Google เปลี่ยนป้ายเป็น filled
  // ตัวเลือก CSS จะเลิกจับทันทีโดยไม่ต้องมีใครทำอะไร
  //
  // เป็น CSS ล้วน ไม่ค้นหา element ไม่แก้ค่าอะไร ไม่จำสถานะ
  // (ต่างจากความผิดพลาดที่เคยทำในครีเอทีฟ ซึ่งค้นหาทั้งหน้าแล้วไปทำเครื่องหมาย
  //  ให้กล่องของตำแหน่งอื่น จนโฆษณาตำแหน่งนั้นหายไป — ห้ามทำแบบนั้นอีก)
  //
  // ทางแก้ที่ถูกที่สุดคือใส่ใน CSS ของเว็บเอง ถ้าวันหนึ่งทำแล้ว ปิดสวิตช์นี้ได้
  if (CFG.collapseUnfilledAdSense) {
    try {
      var agStyle = document.createElement('style');
      agStyle.textContent = 'ins.adsbygoogle[data-ad-status="unfilled"]{display:none!important}';
      (document.head || document.documentElement).appendChild(agStyle);
    } catch (e) { /* ห้ามให้เรื่องนี้ทำให้ด่านหรือเว็บพัง */ }
  }

  // ---- 8. ยุบกล่อง AdSense ที่จองที่แล้วค้างกลางทาง ---------------------
  //
  // **คนละอาการกับหัวข้อ 6** — หัวข้อ 6 จับกล่องที่ Google ตอบแล้วว่า `unfilled`
  // ส่วนอันนี้คือกล่องที่ Google **ไม่เคยตอบอะไรเลย** แล้วค้างกินที่ไว้เฉย ๆ
  //
  // วัดจากหน้าจริง 1 ส.ค. 2569: เจอ 3 ใน 7 หน้าบนเดสก์ท็อป กินที่หน้าละ 280px
  // (slot 1681732386 และ 3550561370 · innerHTML 279 ไบต์เท่ากันเป๊ะทุกตัว)
  //
  // ลายเซ็นที่ใช้ระบุตัว — ต้องครบทุกข้อ เทียบกับกล่องที่ทำงานปกติในหน้าเดียวกัน:
  //   ค้าง : DIV#aswift_1_host                      (กล่องเปล่า ลูก 0 ตัว)
  //   ปกติ : DIV#aswift_2_host[ IFRAME#aswift_2 ]   (มี iframe ครบ)
  //
  // **ทำไมปลอดภัย**: ไม่มี iframe = ไม่มีคำขอโฆษณาเกิดขึ้นจริง = ไม่มี impression
  // ไม่มีใครจ่ายเงินกับกล่องนี้ จึงไม่ใช่การซ่อนของที่มีคนจ่ายเงิน
  // และเราเช็ค iframe ก่อนเสมอ ถ้ามีของอยู่ข้างในจะไม่แตะเด็ดขาด
  //
  // **ถอด inline height ไม่ใช่บังคับ height:0** ตามกฎเดิมของโปรเจกต์
  // ถ้าวันไหนโฆษณามาช้าแล้วลงได้จริง AdSense จะตั้งความสูงของมันเองใหม่ กล่องเปิดได้ตามปกติ
  //
  // **กับดักที่เจอตอนทดสอบ ต้องถอดสองชั้น**: ลองถอดแค่ที่ `ins` แล้ว **ไม่ยุบเลย**
  // เพราะ `#aswift_N_host` ข้างในมี inline height ของตัวเองอีกชั้น (AdSense เป็นคนตั้ง)
  // ถอดครบสองชั้นแล้ววัดได้: 280px → 0 · ความสูงหน้า 8,875 → 8,595 · กล่องอื่นไม่ถูกกระทบ
  //
  // **เวลาที่ใช้รอ ตั้งจากการวัดจริง ไม่ใช่เดา** (หน้าธุรกิจ 1 ส.ค. 2569)
  //   กล่องที่ได้โฆษณาจริง ตอบที่ **0.7 วินาที** (filled 305px)
  //   กล่องที่ไม่มีโฆษณา   ตอบที่ **0.7 วินาที** (unfilled 0)
  //   กล่องที่ค้าง         **ยังไม่ตอบเลยที่ 39 วินาที** (280px, iframe 0 ตัว)
  // ของที่จะมา มาภายในไม่ถึงวินาที ส่วนที่ไม่มาคือไม่มาเลย
  // รอ 5 วิจึงเผื่อไว้ราว 7 เท่าของเวลาปกติ = แทบไม่มีทางไปตัดของที่กำลังจะมา
  //
  // ทำไมต้องรีบ: วัดหน้า local/9690000075363 บนมือถือ
  // **หน้าเว็บมีช่องว่างเปล่า 764px อยู่นาน 25 วินาที** ก่อน Google จะตอบว่า unfilled
  // (บางรอบใหญ่ถึง 2,746px = 22% ของทั้งหน้า) คนอ่านเลื่อนภายในช่วงนั้นแทบทุกคน
  // กฎ CSS ในหัวข้อ 6 ช่วยตรงนี้ไม่ได้เลย เพราะกว่าจะได้ป้าย unfilled ก็สายไปแล้ว
  //
  // นับเวลารอ **แยกรายกล่อง** ไม่ใช่นับจากตอนหน้าเปิด
  // เพราะ Auto Ads แทรกกล่องใหม่ระหว่างที่คนอ่านเลื่อนด้วย ตัวที่เพิ่งเกิดต้องได้เวลาของตัวเอง
  if (CFG.collapseStalledAdSense) {
    var STALL_WAIT = 5000;
    var stallSeen = (typeof WeakMap === 'function') ? new WeakMap() : null;
    var stallTimer = 0, stallRounds = 0;
    var stallCount = 0, stallPx = 0, stallTold = 0, stallSlots = [];

    var sweepStalledAds = safe(function () {
      var now = Date.now();
      var list = document.querySelectorAll('ins.adsbygoogle');
      for (var i = 0; i < list.length; i++) {
        var el = list[i];
        // AdSense ยังไม่ได้หยิบไปทำ = ยังไม่ถึงเวลาตัดสิน
        if (el.getAttribute('data-adsbygoogle-status') !== 'done') continue;
        // ตอบแล้ว ไม่ว่า filled หรือ unfilled = ไม่ใช่เคสนี้ ปล่อยไป
        if (el.getAttribute('data-ad-status')) continue;
        var host = el.querySelector('div[id^="aswift_"][id$="_host"]');
        if (!host) continue;                        // ยังไม่ได้จองที่ด้วยซ้ำ
        if (host.querySelector('iframe')) continue;  // มีของจริงอยู่ข้างใน ห้ามแตะ
        var before = Math.round(el.getBoundingClientRect().height);
        if (before < 30) continue;                   // ไม่ได้กินที่อยู่แล้ว

        // เจอครั้งแรก จดเวลาไว้เฉย ๆ ยังไม่ลงมือ
        var first = stallSeen ? stallSeen.get(el) : el.__agStall;
        if (!first) {
          if (stallSeen) stallSeen.set(el, now); else el.__agStall = now;
          continue;
        }
        if (now - first < STALL_WAIT) continue;

        // **ถอดสองชั้น** — ถอดแค่ที่ ins ไม่พอ ทดสอบแล้วไม่ยุบ
        // เพราะ #aswift_N_host มี inline height ของตัวเองอีกชั้นที่ AdSense ตั้งไว้
        try { el.style.removeProperty('height'); } catch (e) {}
        try { host.style.removeProperty('height'); } catch (e) {}

        // 2.9.6 — **รวมเป็นรายงานเดียวต่อหน้า ไม่ยิงทีละกล่อง**
        // หน้าเดียวเจอค้างได้ถึง 4 กล่อง ถ้ายิงทีละตัวจะกินโควตาถังสำคัญ
        // จนเบียด blank-screen กับ doc-write-late ตกไป = ซ้ำรอยจุดตาบอดเดิมอีกรอบ
        stallCount++; stallPx += before;
        var sid = el.getAttribute('data-ad-slot') || 'auto';
        if (stallSlots.indexOf(sid) === -1) stallSlots.push(sid);
        if (!stallTold) {
          stallTold = 1;
          setTimeout(safe(function () {
            // **2.9.8 — ลำดับของข้อความสำคัญมาก ห้ามสลับ**
            // ตัวเก็บ log จับกลุ่มด้วย "60 ตัวอักษรแรกของ detail" เท่านั้น
            // 2.9.6 เขียนขึ้นต้นด้วยตัวเลขที่เปลี่ยนทุกหน้า (จำนวน px ความสูงหน้า)
            // ผลคือทุกหน้ากลายเป็นแพตเทิร์นใหม่ = เขียน KV ใหม่ทุกครั้ง
            // วัดจริง 2 ส.ค.: 247 จาก 250 แพตเทิร์นเป็นตัวนี้ · ~206 แพตเทิร์น/ชม.
            // (เพดานตัวเก็บ 250/ชม.) และหน้าต่างที่อ่านย้อนได้เหลือ 1.2 ชม. จากเดิมเป็นวัน
            // ดัน blank-screen ที่เรากำลังตามหาออกจากหน้าต่างจนเกือบหมด
            //
            // แก้โดยเอา slot ขึ้นหน้า แล้วคั่นด้วยข้อความคงที่ยาวพอให้ตัวเลข
            // ทุกตัวไปอยู่หลังตัวอักษรที่ 60 → ยุบเหลือหนึ่งแพตเทิร์นต่อชุด slot
            //
            // **2.9.19 — ที่แก้ไปข้างบนได้แค่ครึ่งเดียว** ชุด slot เองก็เปลี่ยนไม่รู้จบ
            // (สลับทั้งลำดับและสมาชิก) พอมันอยู่ใน 60 ตัวแรก ทุกชุดจึงเป็นแพตเทิร์นใหม่
            // วัดจริง 1 ก.ย. 2569: **154 จาก 258 แพตเทิร์นเป็นตัวนี้ = กินหน้าต่างอ่านล็อก 60%**
            // ย้อนดูล็อกได้แค่ 6.8 วันทั้งที่ KV เก็บให้ 7 วัน และของสำคัญถูกดันตกขอบ
            //
            // คราวนี้เอา**ข้อความคงที่ขึ้นหน้าทั้งก้อน** (ยาว 72 ตัว > 60) แล้วให้ทั้ง
            // slot และตัวเลขทุกตัวไปอยู่ท้าย → เหลือแพตเทิร์นเดียวถาวร ไม่ว่าชุด slot จะเป็นอะไร
            // เรียง slot ก่อน slice ด้วย เผื่อวันหลังตัวเก็บเปลี่ยนวิธีจับกลุ่ม จะได้ยุบตามชุดจริง
            // (เรียงบนสำเนา ห้ามเรียงตัวจริง — stallSlots ถูกใช้ต่อในรอบกวาดถัดไป)
            report('ad-box-stalled',
              'กล่องโฆษณาที่จองที่ไว้ล่วงหน้าแล้วไม่มีของมาลง จึงยุบคืนพื้นที่ให้คนอ่าน' +
              ' | จำนวน ' + stallCount + ' กล่อง คืน ' + stallPx +
              'px หน้าสูง ' + document.documentElement.scrollHeight +
              ' | slot ' + stallSlots.slice().sort().slice(0, 4).join(','));
          }, 'รายงานกล่องค้าง'), 2500);   // รอเก็บให้ครบก่อนค่อยรายงานทีเดียว
        }
      }
    }, 'ยุบกล่องโฆษณาที่ค้าง');

    // ตรวจถี่ทุก 1 วิ เพราะช่วงต้นคือช่วงที่คนอ่านเจอช่องว่าง
    // เลิกเองที่ 3 นาที กันหน้าที่ถูกเปิดค้างไว้ทั้งวันเดินตัวจับเวลาไม่หยุด
    try {
      stallTimer = setInterval(function () {
        if (DEAD || ++stallRounds > 180) { clearInterval(stallTimer); return; }
        sweepStalledAds();
      }, 1000);
    } catch (e) { /* ห้ามให้เรื่องนี้ทำให้ด่านหรือเว็บพัง */ }
  }

  // ---- 14. นับอย่างเดียว: ถูกพาออกจากหน้าโดยคนอ่านไม่ได้กด --------------
  //
  // **หัวข้อนี้ไม่กันอะไรเลย ไม่เรียก preventDefault ไม่แตะ DOM มีไว้ตอบคำถามเดียว**
  // คือ "โดเมนไหนพาคนอ่านออกไป" เพราะตอนนี้เราตอบไม่ได้เลยแม้แต่นิดเดียว
  //
  // ที่มา: 6 ส.ค. 2569 มีรายงานจากคนอ่านว่ากำลังอ่านอยู่บนมือถือแล้วโดนพาไปหน้าอื่น
  // บางทีเปลี่ยนในแท็บเดิม บางทีเปิดหน้าใหม่ ปลายทางเป็นโฆษณา Lazada
  // ไล่ล็อกย้อนหลังสองวันแล้ว **ไม่มีร่องรอยสักบรรทัด** — ไม่ใช่เพราะไม่เกิด
  // แต่เพราะจุดที่กันการพาออกจากหน้าของเรามี 4 จุด (window.open, a.click() สังเคราะห์,
  // ตอนนิ้วแตะลิงก์, window.open ในไอเฟรม) และ **ทั้งสี่จุดตัดสินจาก isBlocked()**
  // = รู้จักโดเมนก่อนถึงจะเห็น เจ้าใหม่ผ่านฉลุยและไม่ทิ้งร่องรอย
  // ส่วนการรีไดเรกต์ในแท็บเดิมไม่เคยมีตัวดักเลยสักตัวตั้งแต่ต้น
  //
  // **ทำไมใช้ Navigation API ไม่ใช้ beforeunload**
  // beforeunload แยก "โฆษณาสั่งเปลี่ยนหน้า" ออกจาก "คนอ่านกดปุ่มย้อนกลับ" ไม่ได้
  // ทั้งสองกรณีไม่มี user gesture ค้างอยู่เหมือนกัน = ได้ของปลอมเต็มไปหมด
  // ซึ่งเป็นความผิดพลาดเดียวกับที่ทำให้ body-wiped ได้ของปลอม 64 รายการใน 2 ชม.
  // navigate event บอกมาตรง ๆ ทั้งสองอย่างที่ต้องใช้แยก:
  //   userInitiated  — เกิดจากการกดของคนอ่านหรือเปล่า
  //   navigationType — 'traverse' คือปุ่มย้อนกลับ/เดินหน้า, 'reload' คือรีเฟรช
  // และให้ **URL ปลายทาง** มาด้วย ซึ่งคือคำตอบที่เราต้องการทั้งหมด
  //
  // **จุดตาบอดที่ยังเหลือ ต้องรู้ก่อนอ่านผล**
  //   - navigate event ยิงเฉพาะการเปลี่ยนหน้าที่ "สคริปต์ในหน้านี้" เป็นคนสั่ง
  //     ถ้าสั่งมาจากในไอเฟรมโฆษณาให้พาหน้าบนสุดไป เราจะไม่เห็น
  //     ยอมรับได้เพราะสายที่เจอทุกรอบวิ่งผ่าน ad server เข้ามารันในหน้าเต็มสิทธิ์
  //   - เบราว์เซอร์ที่ไม่มี Navigation API (Safari/iOS) จะไม่ได้อะไรเลย เงียบไปเฉย ๆ
  //     ไม่พังและไม่รายงานผิด · รายงานที่ได้มาคือ Android เป็นหลัก
  //   - ข้าม ALLOW_HOSTS ทิ้ง เพื่อไม่ให้ปลายทางสุจริต (mgronline, google, line,
  //     facebook, taboola) มากินโควตาแพตเทิร์นที่ตอนนี้โดนบอตกินไป 79% อยู่แล้ว
  //     **แลกกับการมองไม่เห็นถ้าเขารีไดเรกต์ผ่านโดเมนในบัญชีขาว**
  //
  // detail ตั้งเป็น URL เปล่า ๆ ตัวเดียวโดยตั้งใจ ห้ามต่อข้อความอะไรเข้าไป
  // ตัวเก็บ log ลองแปลง detail เป็น URL ก่อน ถ้าได้จะจับกลุ่มด้วย "โดเมนหลัก"
  // ซึ่งคือสิ่งที่เราต้องการพอดี (สายนี้ใช้ path สุ่มทุกครั้ง ถ้าจับกลุ่มด้วย
  // 60 ตัวแรกของข้อความจะกลายเป็นแพตเทิร์นใหม่ทุกครั้ง = ระเบิดใส่เพดาน 120/ชม.)
  // **2.9.16 เพิ่มการกันจริง แต่กันเฉพาะ "คนสั่งที่อยู่ในบัญชีดำ" เท่านั้น**
  // เกณฑ์เดียวกับกฎบล็อกอื่นทั้งหมดของด่าน คือต้องระบุตัวได้แน่นอนถึงจะลงมือ
  //
  // **ตัดสินจาก "ใครสั่ง" ไม่ใช่ "ปลายทางคืออะไร"** — จุดสำคัญของหัวข้อนี้
  // ปลายทางคือ lazada://th/pdp ซึ่งเป็นแอปสุจริตที่คนไทยใช้กันจริง
  // บัญชีดำจับปลายทางไม่ได้และไม่ควรจับด้วย · ตัวที่ผิดคือคนสั่ง
  //
  // **ทำไมต้องดักที่นี่ ทั้งที่ blockHosts ควรกันสคริปต์ตั้งแต่ตอนโหลด**
  // guardResource ดักตอน element ถูกแทรกผ่าน Node.prototype ของ "หน้าบนสุด"
  // ถ้าครีเอทีฟรันอยู่ในไอเฟรมพี่น้อง (same-origin) มันใช้ Node.prototype ของไอเฟรมนั้น
  // = hook ของเราเอื้อมไม่ถึง สคริปต์โหลดได้ แต่ยังสั่งเปลี่ยนหน้าบนสุดได้อยู่
  // ชั้นนี้จึงเป็นตาข่ายรับท้ายที่ทำงานตอนมันลงมือแล้ว ไม่ต้องพึ่งว่าดักตอนโหลดทัน
  //
  // **การกันทำงาน 100% แต่การรายงานยังสุ่ม 25%** ตั้งใจแยกกัน
  // การกันไม่มีต้นทุน ส่วนการรายงานยิง beacon ทุกครั้ง = กินโควตา Worker
  if (CFG.watchForcedNav) {
    try {
      var nav = window.navigation;
      if (nav && typeof nav.addEventListener === 'function') {
        nav.addEventListener('navigate', safe(function (e) {
          if (e.userInitiated) return;                   // คนอ่านกดเอง = เรื่องปกติ
          var how = e.navigationType;
          if (how === 'traverse' || how === 'reload') return;   // ย้อนกลับ/รีเฟรช
          var u = e.destination && e.destination.url;
          if (!u) return;

          // navigate event ยิงแบบซิงโครนัสตอนการเปลี่ยนหน้าเริ่มต้น
          // stack จึงยังมีตัวสั่งอยู่จริง — ยืนยันแล้วจากคนอ่านจริง 6 ส.ค.
          // ที่ได้ 'at safeJump (https://sg.bidvertex.top/fj?...)' เป็นเฟรมแรก
          var by = firstFrameUrl(stackOf());
          if (by && isBlocked(by)) {
            // e.cancelable เป็น false ได้ในบางจังหวะ ต้องเช็คก่อนเสมอ
            if (BLOCKING && e.cancelable) {
              try { e.preventDefault(); } catch (e2) {}
            }
            if (NAV_WATCH && !navTold) { navTold = 1; report('nav-blocked', String(u)); }
            return;
          }

          // ไม่รู้จักคนสั่ง = จดไว้เฉย ๆ ไม่ลงมือ (เกณฑ์เดิมของ 2.9.15)
          if (!navWorthTelling(u)) return;
          navTold = 1;

          // **แยกเป็นคนละชนิด ไม่ใช่ต่อท้ายข้อความ** — ตัวเก็บ log จับกลุ่มด้วย
          // ชนิด + โดเมนปลายทาง ถ้าเอาไปต่อท้ายเฉย ๆ ทั้งสองแบบจะยุบเป็นเรกคอร์ดเดียวกัน
          // แล้วนับไม่ได้ว่าอย่างไหนกี่ครั้ง = วัดไปก็ตอบคำถามเดิมไม่ได้อยู่ดี
          // ไม่รู้จัก userActivation ให้ตกเป็น nav-away เหมือนเดิม (ไม่เดาแทนเบราว์เซอร์)
          //
          // **จำนวน beacon ไม่เพิ่มขึ้นเลย** — navTold ยังกั้นไว้ที่ 1 ครั้งต่อหน้าเหมือนเดิม
          // เปลี่ยนแค่ป้ายชื่อกับข้อความ ไม่ได้เพิ่มภาระให้ Worker หรือคนอ่าน
          var ua = null;
          try { ua = navigator.userActivation; } catch (e2) {}
          report((ua && !ua.isActive) ? 'nav-forced' : 'nav-away',
                 String(u) + ' | ' + navEvidence());
        }, 'ดักการพาออกจากหน้า'));
      }
    } catch (e) { /* ห้ามให้เรื่องนี้ทำให้ด่านหรือเว็บพัง */ }
  }

  // ---- 13. นับอย่างเดียว: หน้าถูกล้างแล้วไม่ได้เปลี่ยนหน้าจริง ----------
  //
  // **หัวข้อนี้ไม่แก้อะไรให้คนอ่านเลย ไม่รีโหลด ไม่แตะ DOM มีไว้นับอย่างเดียว**
  // ผู้ใช้เลือกให้ "วัดก่อนแก้" (4 ส.ค. 2569) ได้ตัวเลขแล้วค่อยตัดสินใจทางแก้
  //
  // ที่มา: `header.min.js` ตั้ง
  //   window.onbeforeunload = function(){ window.scrollTo(0,0); $(document.body).html(""); };
  // `beforeunload` ยิงตอน "กำลังจะไป" ไม่ใช่ "ไปแล้ว"
  // ถ้าการเปลี่ยนหน้าถูกยกเลิก เนื้อหาหายไปแล้วแต่คนอ่านยังอยู่หน้าเดิม = ขาวค้าง
  // ทดสอบยืนยันบนหน้าจริง 4 ส.ค.: ยิง beforeunload เปล่า ๆ โดยไม่เปลี่ยนหน้า
  // body จาก 37 ก้อน/8,069 ตัวอักษร เหลือ 0/0 ทันที URL ไม่ขยับ
  //
  // **ทำไมของเดิมมองไม่เห็นเคสนี้ — จุดสำคัญที่สุดของหัวข้อนี้**
  // หัวข้อ 10 (`body-wiped`) มีธง `unloading` ที่ตั้งจาก beforeunload/pagehide
  // แล้ว return ทิ้งทันที · ธงนั้นใส่ไว้ถูกแล้ว (กันของปลอม 64 รายการใน 2 ชม.
  // ตอนคนอ่านกดไปข่าวถัดไป) **แต่มันกลืนเคสนี้ไปด้วยทั้งหมด**
  // = `body-wiped` ที่เห็นแค่ 2 รายการ ไม่ได้แปลว่าเกิดน้อย แปลว่าเราปิดตาตัวเอง
  //
  // วิธีแยก "ค้างจริง" ออกจาก "กำลังเปลี่ยนหน้าอยู่ตามปกติ"
  //   - เปลี่ยนหน้าสำเร็จ -> `pagehide` ยิงเสมอ -> ไม่รายงาน
  //   - ถูกยกเลิก -> `pagehide` ไม่ยิงเลย และหน้าค้างอยู่อย่างนั้นไม่หายเอง
  // รอ 6 วิก่อนตัดสิน: สั้นกว่านี้จะปนกับการเปลี่ยนหน้าปกติที่เน็ตช้า
  // ยาวกว่านี้จะพลาดคนที่ทนไม่ไหวรีเฟรชหนีไปก่อน
  // เก็บสภาพตอน 2 วิไว้ในข้อความด้วย จะได้รู้ว่าขาวมาตั้งแต่เมื่อไหร่
  //
  // ไม่เพิ่ม listener ชนิดใหม่ให้หน้าเว็บ — หัวข้อ 10 ดัก beforeunload/pagehide
  // อยู่แล้ว และเว็บเองก็ตั้ง onbeforeunload ไว้ก่อนเรา สิทธิ์เข้า bfcache จึงไม่เปลี่ยน
  if (CFG.watchStuckWipe) {
    var stuckTold = 0, stuckArmed = 0, stuckLeft = 0, stuckAt2 = '';

    // เกณฑ์เดียวกับหัวข้อ 10 และ 12: ต้องทั้งลูกน้อยและไม่มีตัวหนังสือให้อ่าน
    var stuckBlank = function () {
      var b = document.body;
      if (!b) return false;
      if (b.children.length >= 5) return false;
      return !visibleText(b.innerText);
    };

    try {
      window.addEventListener('pagehide', function () { stuckLeft = 1; },
                              { capture: true });
    } catch (e) {}

    try {
      window.addEventListener('beforeunload', safe(function () {
        if (DEAD || stuckArmed) return;
        stuckArmed = 1;                       // ตั้งครั้งเดียวต่อหน้า

        stuckTimers.push(setTimeout(safe(function () {
          stuckAt2 = stuckBlank() ? 'ว่างแล้ว' : 'ยังมีเนื้อหาอยู่';
        }, 'วัดสภาพจอที่ 2 วิ'), 2000));

        stuckTimers.push(setTimeout(safe(function () {
          if (DEAD || stuckTold || stuckLeft) return;   // ไปจริงแล้ว = ไม่เกี่ยว
          if (document.visibilityState !== 'visible') return;
          if (!stuckBlank()) return;                    // เนื้อหายังอยู่ = ไม่ใช่อาการ
          stuckTold = 1;
          // ข้อความ 60 ตัวแรกต้องคงที่ ตัวเก็บ log จับกลุ่มด้วยช่วงนั้น
          report('wipe-stuck',
            'หน้าถูกล้างทิ้งแล้วไม่ได้เปลี่ยนหน้าจริง คนอ่านค้างอยู่กับหน้าขาว' +
            ' · ที่ 2 วิ ' + (stuckAt2 || 'ไม่ได้วัด') +
            ' · ตรวจซ้ำที่ 6 วิแล้วยังว่าง' + bodyLeftovers());
        }, 'วัดหน้าค้างหลัง beforeunload'), 6000));
      }, 'ตั้งตัววัดตอน beforeunload'), { capture: true });
    } catch (e) { /* ห้ามให้เรื่องนี้ทำให้ด่านหรือเว็บพัง */ }
  }

  // ---- 12. กู้หน้าที่กลับมาจากแคชแล้วเนื้อหาหาย -------------------------
  //
  // **ต้นเหตุอยู่ในโค้ดของเว็บเอง** เจอใน `header.min.js` (2 ส.ค. 2569)
  //   history.scrollRestoration = "manual";
  //   window.onbeforeunload = function () { window.scrollTo(0,0); $(document.body).html(""); };
  // และค้นทั้งไฟล์แล้ว **ไม่มี `pageshow` เลยสักจุด** = ไม่มีอะไรเอาเนื้อหากลับมา
  //
  // ลำดับที่ทำให้คนอ่านเห็นหน้าขาว
  //   1. กดลิงก์ไปข่าวถัดไป → beforeunload ล้าง body ทันที
  //   2. เน็ตช้า หน้าใหม่ยังไม่มา → คนอ่านมองหน้าขาวระหว่างรอ
  //   3. กดย้อนกลับ/ปัดกลับ → เบราว์เซอร์คืนหน้าเดิมจากแคช (bfcache)
  //      แต่ body ยังว่าง → **ขาวค้าง URL เป็นข่าวเดิม รีเฟรชถึงหาย**
  //
  // ตรงกับอาการที่คนอ่านรายงานมาทุกข้อ รวมถึงทำไมมือถือเจอมากกว่า
  // (เน็ตช้ากว่า และมีท่าปัดกลับ) และทำไมคนเน็ตเร็วแทบไม่เจอ
  //
  // **นี่คือของที่แรงที่สุดที่ด่านเคยทำ — สั่งโหลดหน้าใหม่ให้คนอ่าน**
  // จึงกันวนลูปไว้สามชั้น ทุกชั้นต้องผ่านหมดถึงจะลงมือ:
  //   1. `e.persisted === true` เท่านั้น = เฉพาะหน้าที่คืนจากแคชจริง
  //      หน้าที่โหลดใหม่จะไม่มีวันเข้าเงื่อนไขนี้ ลูปจึงเกิดไม่ได้ตั้งแต่ต้น
  //   2. body ต้องเหลือลูก < 5 **และ** ไม่มีตัวหนังสือให้อ่านเลย
  //      หน้าปกติที่กลับจากแคชมีลูก 30-40 ตัว จับผิดยากมาก
  //   3. `sessionStorage` จำแยกตาม URL — กู้ได้ครั้งเดียวต่อหน้าต่อแท็บ
  //      **ถ้าอ่าน/เขียน sessionStorage ไม่ได้ จะไม่กู้เลย** เพราะกันลูปไม่ได้
  //      ยอมให้คนอ่านเจอหน้าขาว ดีกว่าเสี่ยงรีโหลดวนบนเว็บห้าแสนหน้า/วัน
  //
  // รอ 300ms หลัง pageshow ก่อนวัด เผื่อมีอะไรเติมเนื้อหากลับ
  // แล้วรออีก 150ms หลังส่งรายงาน ให้ beacon ออกทันก่อนหน้าจะถูกโหลดใหม่
  //
  // **พอโปรแกรมเมอร์เอา `$(document.body).html("")` ออก ปิดสวิตช์นี้ได้เลย**
  if (CFG.recoverFromCache) {
    var recoverDone = 0;

    var maybeRecover = safe(function () {
      if (DEAD || recoverDone) return;
      var b = document.body;
      if (!b) return;
      if (b.children.length >= 5) return;          // ยังมีเนื้อหา ไม่ใช่อาการ
      if (visibleText(b.innerText)) return;        // ยังมีตัวหนังสือให้อ่าน
      recoverDone = 1;

      var key = '__agFixed:' + location.pathname + location.search;
      try {
        if (sessionStorage.getItem(key)) return;   // เคยกู้ให้หน้านี้แล้ว ไม่ทำซ้ำ
        sessionStorage.setItem(key, '1');
      } catch (e) { return; }                      // กันลูปไม่ได้ = ไม่กล้ากู้

      try {
        report('body-recovered', 'กลับมาจากแคชแล้วเนื้อหาหาย จึงโหลดหน้าใหม่ให้คนอ่าน' +
          ' · body เหลือ ' + b.children.length + ' ตัว' + bodyLeftovers());
      } catch (e) {}

      setTimeout(function () { try { location.reload(); } catch (e) {} }, 150);
    }, 'กู้หน้าจากแคช');

    try {
      window.addEventListener('pageshow', function (e) {
        if (!e || !e.persisted) return;            // ไม่ใช่หน้าที่คืนจากแคช = ไม่เกี่ยว
        setTimeout(maybeRecover, 300);
      });
    } catch (e) { /* ห้ามให้เรื่องนี้ทำให้ด่านหรือเว็บพัง */ }
  }

  // ---- 11. เปิดหน้าที่ถูกซ่อนไว้ให้คนอ่าน -------------------------------
  //
  // **นี่คือตัวเดียวในชุด 2.9.x ที่แก้อาการ "ทั้งหน้าขาว" ให้คนอ่านโดยตรง**
  //
  // ที่มา: HTML ที่เซิร์ฟเวอร์ส่งมามี `<body style="visibility: hidden;">` ติดมาด้วย
  // และคำว่า visibility ปรากฏ **ครั้งเดียวในทั้งหน้า** = ไม่มีโค้ดในหน้าที่เปิดคืนเลย
  // คนเปิดอยู่ในไฟล์ JS ภายนอกของเว็บ (ชุด libs/*.min.js ที่โหลดทีหลัง)
  //
  // แปลว่า **ทั้งหน้ามองไม่เห็นจนกว่าไฟล์นั้นจะมาถึงและรันสำเร็จ**
  // ถ้าไฟล์ 404 / เน็ตหลุดกลางคัน / มี error ก่อนถึงบรรทัดนั้น
  // คนอ่านจะเห็นขาวล้วน **ทั้งที่เนื้อหาอยู่ครบใน DOM แล้ว**
  //
  // ตรงกับทุกอย่างที่ผู้ใช้เล่า: รีเฟรชแล้วหาย (รอบสองไฟล์อยู่ในแคช) ·
  // มือถือเจอมากกว่า (เน็ตช้ากว่า) · เจ้าของเว็บไม่ค่อยเจอแต่คนอื่นเจอ (เน็ตดีกว่า)
  //
  // **ทำไมปลอดภัยกว่าทางเลือกอื่นมาก**
  // เราทำได้อย่างเดียวคือ "เปิดให้เห็น" ไม่มีทางไปซ่อนอะไรได้เลย
  // แย่ที่สุดคือคนอ่านเห็นหน้าเร็วกว่าที่เว็บตั้งใจ ซึ่งเป็นสิ่งที่เขาต้องการอยู่แล้ว
  // ไม่ต้องรีโหลด ไม่เสียตำแหน่งที่อ่านค้าง ไม่มีความเสี่ยงลูป
  // (เคยคิดจะใช้การรีโหลดแทน แล้วพบว่าเสี่ยงกว่าคนละชั้น)
  //
  // **รอ 3 วินาทีก่อนลงมือ** เพื่อให้เว็บได้เปิดเองตามปกติก่อน
  // ไม่งั้นจะไปแย่งเปิดตอนที่ยังจัดวางไม่เสร็จ = หน้ากะพริบโดยไม่จำเป็น
  // เฝ้าต่อจนถึง 30 วิ เผื่อมีอะไรมาซ่อนซ้ำทีหลัง
  //
  // **ต้นเหตุจริงยังอยู่ที่เว็บ** — การออกแบบให้ทั้งหน้ามองไม่เห็นจนกว่า JS จะมาเปิด
  // เปราะโดยตัวมันเอง ทางแก้ถาวรคือเอา visibility:hidden ออก
  // หรือใส่ตัวกันเวลาไว้ในหน้าเลย · ทำแล้วปิดสวิตช์นี้ได้
  if (CFG.revealHiddenBody) {
    var revealTold = 0, revealTries = 0, revealTimer = 0;

    var tryReveal = safe(function () {
      if (DEAD || ++revealTries > 60) { try { clearInterval(revealTimer); } catch (e) {} return; }
      var b = document.body;
      if (!b) return;
      var vis;
      try { vis = getComputedStyle(b).visibility; } catch (e) { return; }
      if (vis !== 'hidden') return;
      if (performance.now() < 3000) return;       // ให้เว็บได้เปิดเองก่อน

      try { b.style.visibility = 'visible'; } catch (e) {}
      // ถ้ายังไม่ขึ้น แปลว่ามีกฎใน stylesheet ทับอยู่ ต้องใช้ไม้แข็งขึ้น
      try {
        if (getComputedStyle(b).visibility === 'hidden') {
          b.style.setProperty('visibility', 'visible', 'important');
        }
      } catch (e) {}

      if (!revealTold) {
        revealTold = 1;
        report('body-revealed', 'หน้าถูกซ่อนด้วย visibility:hidden ค้างไว้ จึงเปิดให้คนอ่านเอง' +
          ' · เปิดที่วินาทีที่ ' + Math.round(performance.now() / 1000) +
          ' · readyState=' + document.readyState + bodyLeftovers());
      }
    }, 'เปิดหน้าที่ถูกซ่อน');

    try { revealTimer = setInterval(tryReveal, 500); } catch (e) {}
  }

  // ---- 10. จับจังหวะที่เนื้อหาในหน้าหายไป — ดูอย่างเดียว ---------------
  //
  // ทำไมต้องมี ทั้งที่หัวข้อ 9 ดัก document.write อยู่แล้ว:
  // ดักมาทั้งวัน 1 ส.ค. **ได้ 0 ครั้ง** และสแกนไฟล์ของ AnyMind (451KB) กับ
  // Adagio (62KB) แล้วก็ไม่มี document.write เลย = **ตัวการใช้วิธีอื่นล้างหน้า**
  //
  // เหลือทางล้างอีกสามทางที่ยังไม่ได้ดัก เอาเฉพาะสองทางที่เสี่ยงต่ำมาก่อน
  //   ก. `document.body = <ตัวใหม่>`  → ห่อ setter ได้ stack ชี้ตัวคนทำ · แทบไม่มีใครเรียก
  //   ข. ไล่ลบลูก / replaceChildren  → MutationObserver รู้ว่าเกิดตอนไหน แต่ไม่รู้ว่าใครทำ
  //   ค. `body.innerHTML = ''`        → **ยังไม่ทำ** ต้องห่อ setter บน Element.prototype
  //      ซึ่งถูกเรียกหลายพันครั้งต่อหน้าโดยสคริปต์ทุกตัว ถ้าพลาดคือเว็บพังทั้งเว็บ
  //      เก็บไว้เป็นทางสุดท้ายถ้า ก. กับ ข. ตอบไม่ได้
  //
  // เงื่อนไขรายงานตั้งให้แคบ: ต้องหายไปอย่างน้อย 3 ก้อน **และ** เหลือไม่เกิน 4 ตัว
  // หน้าข่าวปกติมีลูกใน body หลายสิบตัวและไม่ลบทิ้งเป็นก้อน จึงแทบไม่มีทางจับผิด
  //
  // เฝ้าทั้ง body (กรณีลูกถูกลบ) และ documentElement (กรณี body ทั้งก้อนถูกเปลี่ยน
  // ซึ่ง observer ที่เกาะ body เดิมจะไม่ได้ยินอะไรเลยเพราะตัวมันหลุดออกจากหน้าไปแล้ว)
  if (CFG.watchBodyWipe) {
    var wipeTold = 0;

    // **2.9.10 — กันของปลอมที่ท่วมล็อกไป 64 รายการใน 2 ชม.**
    // ทดสอบจริงแล้ว: ตอนคนอ่านกดไปข่าวถัดไป เบราว์เซอร์รื้อ DOM ทิ้งเป็นปกติ
    // observer จับได้ว่า "หายไป 39 ก้อน เหลือ 0 ตัว" และ sendBeacon ยังส่งได้ตอน unload
    // = เรานับ "คนอ่านเปลี่ยนหน้า" เป็น "หน้าขาว" ซึ่งเกิดแทบทุก pageview
    // ถ้าไม่กัน จะสรุปกันผิดทั้งกระดานว่าปัญหาเกิดถี่มาก
    var unloading = 0;
    try {
      ['pagehide', 'beforeunload'].forEach(function (ev) {
        window.addEventListener(ev, function () { unloading = 1; }, { capture: true });
      });
    } catch (e) {}

    // ของจริงต้อง "ว่างแล้วยังว่างอยู่" ไม่ใช่แค่ว่างชั่วขณะ
    // ยืนยันซ้ำอีกทีหลัง 1 วิ เพื่อตัดจังหวะที่กำลังเปลี่ยนของ
    var tellWipe = function (how, extra) {
      if (wipeTold || DEAD || unloading) return;
      if (document.visibilityState !== 'visible') return;   // แท็บถูกซ่อน/กำลังออก
      wipeTold = 1;                                          // จองไว้ก่อน กันยิงซ้ำระหว่างรอ
      setTimeout(safe(function () {
        if (DEAD || unloading) return;
        if (document.visibilityState !== 'visible') return;
        var b = document.body;
        if (!b) return;
        if (b.children.length > 4) return;                   // เนื้อหากลับมาแล้ว = ของปลอม
        if (visibleText(b.innerText)) return;                // ยังมีตัวหนังสือให้อ่าน = ไม่ใช่จอขาว
        report('body-wiped', how + ' · ' + (extra || '') +
          ' · หลังเปิดหน้ามาแล้ว ' + Math.round(performance.now() / 1000) + ' วิ' +
          ' · ยืนยันซ้ำที่ 1 วิแล้วยังว่าง' + bodyLeftovers() + wipeState());
      }, 'ยืนยันจอว่าง'), 1000);
    };

    // ก. ห่อ setter ของ document.body — ได้ stack ของคนเรียกตรง ๆ
    // เรียกของเดิมเสมอ ต่อให้ส่วนรายงานพัง (กฎเดียวกับหัวข้อ 9)
    try {
      var bodyDesc = Object.getOwnPropertyDescriptor(Document.prototype, 'body');
      if (bodyDesc && bodyDesc.set && bodyDesc.get) {
        Object.defineProperty(document, 'body', {
          configurable: true,
          get: function () { return bodyDesc.get.call(document); },
          set: function (v) {
            // **ลำดับสำคัญ — ต้องเรียกของเดิมก่อนแล้วค่อยรายงาน**
            // ถ้ารายงานก่อน bodyLeftovers() จะอ่าน body เดิมที่ยังมีเนื้อหาครบ
            // แล้วบันทึกว่า "เหลือ 40 ตัว" ทั้งที่กำลังจะถูกล้าง = ข้อมูลผิดในเคสที่เราสนใจที่สุด
            // stack ยังครบเหมือนเดิมเพราะยังอยู่ในเฟรมการเรียกเดียวกัน
            var out = bodyDesc.set.call(document, v);
            try { tellWipe('มีคนเขียนทับ document.body ทั้งก้อน', ''); } catch (e) {}
            return out;
          }
        });
      }
    } catch (e) { /* ห่อไม่ได้ก็ปล่อยไป ของเดิมยังทำงานปกติ */ }

    // ข. เฝ้าดูเฉย ๆ ไม่แตะฟังก์ชันของเบราว์เซอร์เลย
    var startWipeWatch = safe(function () {
      if (!document.body) return;
      var onMut = safe(function (muts) {
        if (wipeTold || DEAD) return;
        var gone = 0, i, j, bodyGone = false, goneNames = [], rn;
        // 2.9.29 — ถ้าชุดนี้มีโหนดทดสอบของ jQuery (id `sizzle<เวลา>` / `jQuery<เลข>`) ปนอยู่
        // ถือว่าทั้งชุดคือ jQuery ทดสอบฟีเจอร์เบราว์เซอร์ (สร้าง fieldset/div ใส่ body แล้วลบทิ้งทันที
        // ลบทีละหลายตัว โดยมีแค่ตัวเดียวที่มี id) ล็อก 8 ต.ค. 2569: 33/33 รายการที่ "ลบ"
        // เป็นชุดแบบนี้ล้วน ๆ ขณะที่ body ถูกซ่อน innerText จึงว่าง = นับหน้าปกติเป็นจอขาว
        // และ id ที่มีเวลาอยู่ต้นข้อความทำให้ตัวเก็บเห็นเป็นแพตเทิร์นใหม่ทุกครั้ง
        // ตัวตรวจ BODY ถูกถอดด้านล่างไม่โดนผลกระทบ เพราะเช็คแยกจากตัวนับนี้
        var jqTest = false, k;
        for (i = 0; i < muts.length && !jqTest; i++) {
          for (k = 0; k < muts[i].removedNodes.length; k++) {
            rn = muts[i].removedNodes[k];
            if (rn.id && /^(sizzle|jQuery)\d/.test(String(rn.id))) { jqTest = true; break; }
          }
        }
        for (i = 0; i < muts.length; i++) {
          for (j = 0; j < muts[i].removedNodes.length; j++) {
            rn = muts[i].removedNodes[j];
            if (!jqTest) gone++;
            // 2.9.28 — จดชื่อของที่ถูกลบ (ไม่เกิน 6) เพราะรายงานเดิมบอกแค่จำนวน
            // จึงตอบไม่ได้ว่าใครลบอะไร · อ่านแค่ชื่อแท็กกับ id ไม่แตะเนื้อหาในหน้า
            if (goneNames.length < 6) {
              goneNames.push((rn.nodeName || '?') + (rn.id ? '#' + String(rn.id).slice(0, 24) : ''));
            }
          }
          // ตัว <body> เองถูกถอดออก = ถูกเปลี่ยนทั้งก้อน นับเป็นอาการทันที
          // ถ้าไม่ดักไว้จะหลุด เพราะมันนับเป็น "หายไป 1 ก้อน" ซึ่งต่ำกว่าเกณฑ์ 3
          for (j = 0; j < muts[i].removedNodes.length; j++) {
            if (muts[i].removedNodes[j].tagName === 'BODY') bodyGone = true;
          }
        }
        var left = document.body ? document.body.children.length : 0;
        if (bodyGone) {
          // 2.9.10 — เดิมรายงานทันทีที่เห็น BODY ถูกถอด ซึ่งได้ของปลอม 14 รายการ
          // ที่หน้ายังมีเนื้อหาครบ (เหลือ 5-14 ตัว เป็น DIV#fb-root DIV#wrapper ของเว็บเอง)
          // ต้องผ่านเกณฑ์ "ว่างจริง" เหมือนกรณีอื่น แล้วให้ tellWipe ยืนยันซ้ำอีกชั้น
          if (left <= 4) tellWipe('body ทั้งก้อนถูกถอดออกจากหน้า', 'เหลือ ' + left + ' ตัว');
          return;
        }
        if (gone < 3) return;
        if (left > 4) return;                 // ยังมีเนื้อหาอยู่ ไม่ใช่อาการ
        // **ชื่อที่ถูกลบอยู่ต้นข้อความโดยตั้งใจ** 60 ตัวแรกคือคีย์จับกลุ่มของตัวเก็บ
        // ถ้าต่อท้าย เรกคอร์ดเดิม (~256 ครั้ง) จะกลืนรายงานใหม่ทั้งหมดเป็น dup
        // และเราจะไม่เห็นข้อมูลใหม่เลย · ใส่ไว้ต้นข้อความ = แยกกลุ่มตามชุดที่ถูกลบด้วย
        tellWipe('ลบ[' + goneNames.join(' ') + '] เนื้อหาใน body หายไป ' + gone + ' ก้อนรวดเดียว',
          'เหลือ ' + left + ' ตัว');
      }, 'เฝ้า body');
      try {
        wipeMo = new MutationObserver(onMut);
        wipeMo.observe(document.body, { childList: true });
        wipeMo.observe(document.documentElement, { childList: true });
      } catch (e) {}
    }, 'ตั้งตัวเฝ้า body');

    try {
      if (document.body) startWipeWatch();
      else document.addEventListener('DOMContentLoaded', startWipeWatch, { once: true });
    } catch (e) { /* ห้ามให้เรื่องนี้ทำให้ด่านหรือเว็บพัง */ }
  }

  // ---- ของเหลือใน body — ใช้ร่วมกันระหว่างหัวข้อ 7 กับ 10 --------------
  //
  // 2.9.8 — เพิ่มเพราะหลักฐานที่ผู้ใช้เปิด DevTools ให้ดู 1-2 ส.ค. 2569
  // ตอนหน้าขาว body ไม่ได้ว่างสนิท แต่เหลือ **ของกอง header bidding ล้วน ๆ**
  // `<img id="adg-2-sync">` `<img id="adg-3-sync">` (Adagio ผ่าน u.4dex.io)
  // ของพวกนี้ถูกใส่เข้าหน้าทีหลังสุด การที่มันเป็นสิ่งเดียวที่เหลือ
  // = หน้าถูกล้างก่อน แล้วมันค่อยมาเกาะบน body เปล่า
  //
  // เก็บ id ของสิ่งที่เหลือไว้ในรายงานด้วย จะได้รู้ว่าคนอ่านจริงเจอแบบเดียวกันไหม
  // **ต่อท้ายเสมอ ห้ามเอาไปไว้ต้นข้อความ** เพราะ 60 ตัวแรกคือคีย์จับกลุ่มของตัวเก็บ
  function bodyLeftovers() {
    try {
      var b = document.body;
      if (!b) return ' · ไม่มี body';
      var k = b.children, names = [], i;
      for (i = 0; i < k.length && i < 6; i++) {
        names.push(k[i].tagName + (k[i].id ? '#' + k[i].id : '') );
      }
      return ' · body เหลือ ' + k.length + ' ตัว: ' + names.join(' ');
    } catch (e) { return ''; }
  }

  // 2.9.28 — สถานะของหน้าตอนที่ถูกนับว่า "จอว่าง" ใช้แยกว่าว่างจริงหรือแค่ถูกซ่อน
  // body ที่ยังมี visibility:hidden จากไฟล์ HTML ทำให้ innerText ว่างได้ทั้งที่เนื้อหาอยู่ครบ
  // อ่านอย่างเดียว ต่อท้ายเสมอ (ห้ามไปไว้ต้นข้อความ ดูคอมเมนต์ bodyLeftovers)
  function wipeState() {
    try {
      var b = document.body, cs = getComputedStyle(b), w = document.getElementById('wrapper');
      return ' · สถานะ: body vis=' + cs.visibility + ' disp=' + cs.display +
        ' · wrapper=' + (w ? visibleText(w.innerText).length + 'ตัวอักษร ' +
          getComputedStyle(w).visibility : 'ไม่มี') +
        ' · readyState=' + document.readyState;
    } catch (e) { return ''; }
  }

  // ---- 7. เฝ้าดูจอว่างระหว่างเลื่อน — ดูอย่างเดียว ไม่ลงมืออะไรทั้งสิ้น ----
  //
  // อาการที่ผู้ใช้เจอเอง 1 ส.ค. 2569 บนมือถือ Android:
  //   โหลดมาเห็นเนื้อหาปกติ พอเอานิ้วเลื่อน หน้ากลายเป็นขาวไม่มีเนื้อหา
  //   URL ยังเป็นข่าวเดิม · รีเฟรชแล้วหาย · บางครั้งไม่หาย แล้วพอเลื่อนก็ขาวซ้ำอีก
  //   นาน ๆ เจอที
  //
  // ตามหาสาเหตุจากฝั่งเราจนตัน: กวาด 11 หน้าคนละหมวด ทั้งเดสก์ท็อปและ UA มือถือจริง
  // เลื่อนขึ้นลง 7 จุด ไม่เจอสักครั้ง ไม่มี vignette ไม่มีชั้นทับ
  // **เพราะฉะนั้นเลิกเดาสาเหตุ แล้วมาจับที่ "อาการ" ตรง ๆ แทน**
  // ไม่ว่าต้นเหตุจะเป็นโฆษณาคั่นหน้า เมนูที่ค้าง หรือหน้าเว็บวาดไม่ออก
  // สิ่งที่คนอ่านเจอเหมือนกันหมดคือ "เลื่อนแล้วใต้จอไม่มีอะไรให้ดู" — วัดอันนั้น
  //
  // วิธีวัด: สุ่มยิงจุดตรวจ 7 จุดทั่วจอ แล้วถามว่าใต้จุดนั้นมีอะไร
  //   ไม่เจออะไรเลยทุกจุด            = จอว่างจริง
  //   เจอแต่ body/html ทุกจุด        = เนื้อหาไม่ได้ถูกวาด
  //   เจอของชิ้นเดียวกันคลุมทุกจุด    = มีอะไรมาทับ (ถ้าข้างในไม่มีตัวหนังสือและไม่มีรูป)
  //
  // ที่ต้องระวังและกันไว้แล้ว:
  // - **ห้ามจับรูปเต็มจอของเว็บเองเป็นของปลอม** จึงเช็ค visibleText + hasVisibleMedia ก่อน
  //   ของที่มีตัวหนังสือหรือรูปอยู่ข้างใน = เนื้อหาจริง ไม่รายงาน
  // - iframe คลุมจอมองข้างในไม่ได้ (คนละโดเมน) ตัวนี้รายงานเสมอ เพราะเป็นเคสที่อยากรู้ที่สุด
  // - ทำเฉพาะหน้าที่ถูกสุ่มให้ส่งอยู่แล้ว = 90% ของคนอ่านไม่ต้องแบกงานนี้เลย
  // - ห่างกันอย่างน้อย 2 วิ และรอให้การเลื่อนนิ่ง 250ms ก่อนวัด (เลื่อนอยู่มันวัดไม่ตรง)
  // - รายงานได้ครั้งเดียวต่อหน้า ไม่ยิงรัว
  // - listener เป็น passive = ไม่หน่วงการเลื่อนของคนอ่านเด็ดขาด
  //
  // **ไม่มีการบล็อก ไม่มีการซ่อน ไม่แตะ DOM** ถ้าคิดผิดก็แค่ได้ log ที่ไม่มีประโยชน์
  if (CFG.watchBlankScreen && (DEBUG || SEND_HI)) {
    var blankDone = false;                  // รายงานครั้งเดียวพอ
    var blankLast = 0;
    var blankTimer = 0;
    var sawContent = false;                 // เคยเห็นเนื้อหาบนหน้านี้แล้วหรือยัง
    var BLANK_PTS = [[0.5, 0.15], [0.5, 0.35], [0.5, 0.5], [0.5, 0.65],
                     [0.5, 0.85], [0.2, 0.5], [0.8, 0.5]];

    // ลอยทับอยู่ไหม — ตัวมันเองหรือกล่องแม่ใกล้ ๆ เป็น fixed
    function isFloating(el) {
      var p = el;
      for (var k = 0; k < 4 && p && p.nodeType === 1; k++) {
        try { if (getComputedStyle(p).position === 'fixed') return true; } catch (e) { return false; }
        p = p.parentElement;
      }
      return false;
    }

    // "มีอะไรให้คนอ่านดูไหม" — ตั้งใจไม่ใช้ hasVisibleMedia ตัวเดิม
    // ตัวเดิมนับ **พื้นหลังทึบ** ว่าเป็นเนื้อหา เพราะมันมีไว้ตอบคำถามคนละข้อ
    // (ว่ากล่องนี้เป็นโฆษณาจริงหรือชั้นล่องหน)
    // แต่เรื่องนี้ "พื้นหลังขาวทึบล้วน ๆ ไม่มีอะไรเลย" คืออาการที่เรากำลังตามหาพอดี
    // ถ้าเผลอใช้ตัวเดิม จอขาวจะถูกอ่านว่ามีของอยู่ = ไม่รายงานเลยสักครั้ง
    // นับเฉพาะของที่คนอ่าน "อ่านหรือดูได้จริง": ตัวหนังสือ · รูป/วิดีโอ · ภาพพื้นหลัง
    function hasSomethingToRead(el) {
      if (visibleText(el.innerText)) return true;
      var i, r, cs;

      // 2.9.3 — **ตัวมันเองเป็นรูปหรือวิดีโอก็นับ**
      // ของเดิมมองแต่ "ลูกหลาน" ซึ่ง <img> ไม่มีลูกเลย
      // ผลจริงจากคนอ่าน 1 ส.ค.: รูปในข่าวและแบนเนอร์ที่กินเต็มจอบนมือถือจอเล็ก
      // ถูกรายงานว่าเป็นจอว่าง (mpics2.mgronline.com, ads.imprezzer.com)
      var tag = String(el.tagName).toUpperCase();
      if (tag === 'IMG' || tag === 'PICTURE' || tag === 'SVG' ||
          tag === 'VIDEO' || tag === 'CANVAS') {
        r = el.getBoundingClientRect();
        if (r.width >= 24 && r.height >= 24) return true;
      }

      var m = el.querySelectorAll('img,picture,svg,video,canvas,iframe');
      for (i = 0; i < m.length && i < 40; i++) {
        r = m[i].getBoundingClientRect();
        if (r.width < 24 || r.height < 24) continue;
        cs = getComputedStyle(m[i]);
        if (cs.visibility === 'hidden' || cs.display === 'none') continue;
        if (parseFloat(cs.opacity) < 0.05) continue;
        return true;
      }
      // 2.9.6 — **ดูภาพพื้นหลังของตัวมันเองด้วย ไม่ใช่แค่ลูกหลาน**
      // บั๊กชนิดเดียวกับเรื่อง <img> ที่แก้ไปใน 2.9.3 แต่ตอนนั้นแก้ไม่ครบ
      // ของจริงที่หลุดมาเป็นของปลอม: `DIV plyr__poster` = ภาพปกวิดีโอที่วาดด้วย
      // background-image บนตัวเอง ไม่มีลูกเลย จึงถูกอ่านว่า "ว่างเปล่า"
      try {
        cs = getComputedStyle(el);
        if (cs.backgroundImage !== 'none' && cs.visibility !== 'hidden') return true;
      } catch (e) {}

      var kids = el.querySelectorAll('*');
      for (i = 0; i < kids.length && i < 40; i++) {
        cs = getComputedStyle(kids[i]);
        if (cs.backgroundImage !== 'none' && cs.visibility !== 'hidden') return true;
      }
      return false;
    }

    var checkBlank = safe(function () {
      if (blankDone || DEAD) return;
      // หน้ายังสร้างไม่เสร็จ วัดไปก็ได้ของปลอม
      if (document.readyState !== 'complete') return;
      // 2.9.6 — คนอ่านกดดูวิดีโอเต็มจอเอง ไม่ใช่อาการเสีย
      // ของจริงที่หลุดมาเป็นของปลอม: iframe เต็มจอของ facebook/plugins/video.php
      try { if (document.fullscreenElement || document.webkitFullscreenElement) return; } catch (e) {}
      var w = window.innerWidth, h = window.innerHeight;
      if (!w || !h) return;

      var hits = [], misses = 0, i, el;
      for (i = 0; i < BLANK_PTS.length; i++) {
        el = document.elementFromPoint(Math.round(w * BLANK_PTS[i][0]),
                                       Math.round(h * BLANK_PTS[i][1]));
        if (el) hits.push(el); else misses++;
      }

      var why = '';
      if (misses === BLANK_PTS.length) {
        why = 'ไม่มีอะไรใต้จุดตรวจเลยทั้ง 7 จุด';
      } else if (hits.length && hits.every(function (e) {
        return e === document.body || e === document.documentElement;
      })) {
        why = 'เห็นแต่พื้นหน้าเว็บ ไม่มีเนื้อหาถูกวาด';
      } else if (hits.length === BLANK_PTS.length && hits.every(function (e) {
        return e === hits[0];
      })) {
        var one = hits[0];
        if (one.tagName === 'IFRAME') {
          // iframe คนละโดเมนมองข้างในไม่ได้ ตัดสินจากข้างในไม่ได้เลย
          // จึงรายงานเฉพาะตัวที่ "ลอยทับ" (fixed) เท่านั้น
          // iframe ที่อยู่ในสายเนื้อหาปกติ (เช่นกล่อง Taboola สูง ๆ) เลื่อนผ่านไปได้
          // ไม่ใช่อาการค้างที่เราตามหา ถ้าไม่กันไว้จะได้ของปลอมเต็มไปหมด
          if (isFloating(one)) why = 'iframe ลอยคลุมทั้งจอ';
        } else if (!hasSomethingToRead(one)) {
          why = 'ของว่างเปล่าคลุมทั้งจอ';
        }
      }
      // ปกติ — จำไว้ว่า "หน้านี้เคยมีเนื้อหาให้ดูจริง"
      if (!why) { sawContent = true; return; }

      // 2.9.3 — **รายงานเฉพาะของที่เคยเห็นแล้วหายไป**
      // ผู้ใช้เล่าชัดว่า "โหลดมาเห็นเนื้อหาปกติ แล้วค่อยกลายเป็นขาว"
      // ถ้าไม่เคยเห็นเนื้อหาเลยตั้งแต่ต้น = หน้าอาจแค่ยังสร้างไม่เสร็จ คนละเรื่องกัน
      // ผลจริง 1 ส.ค. ก่อนใส่กฎนี้: ได้ของปลอมที่ `ความสูงหน้า 783` = เท่าความสูงจอพอดี
      // แปลว่าคนอ่านเลื่อนตั้งแต่หน้ายังว่าง ไม่ใช่เนื้อหาหายไป
      if (!sawContent) return;

      blankDone = true;
      var t = hits[0];
      report('blank-screen', why +
        ' · ' + (t ? t.tagName + ' ' + String(t.src || t.className || '').slice(0, 60) : '-') +
        ' · เลื่อนมาแล้ว ' + Math.round(window.pageYOffset) +
        ' จากความสูง ' + document.documentElement.scrollHeight +
        bodyLeftovers());
    }, 'ตรวจจอว่าง');

    try {
      window.addEventListener('scroll', function () {
        if (DEAD || blankDone) return;
        var now = Date.now();
        if (now - blankLast < 2000) return;  // อย่างน้อย 2 วินาทีต่อครั้ง
        blankLast = now;
        if (blankTimer) clearTimeout(blankTimer);
        blankTimer = setTimeout(checkBlank, 250);   // รอให้นิ่งก่อนค่อยวัด
      }, { passive: true });
    } catch (e) { /* ห้ามให้เรื่องนี้ทำให้ด่านหรือเว็บพัง */ }

    // วัดครั้งแรกหลังหน้าโหลดเสร็จ เพื่อปักหมุดว่า "หน้านี้เคยมีเนื้อหา"
    // จำเป็นเพราะกฎ sawContent — ถ้าคนอ่านเลื่อนครั้งแรกตอนจอขาวพอดี
    // แล้วไม่เคยมีการวัดที่สำเร็จมาก่อน เคสนั้นจะหลุดไปทั้งที่เป็นของจริง
    try {
      var blankBaseline = function () { setTimeout(checkBlank, 1500); };
      if (document.readyState === 'complete') blankBaseline();
      else window.addEventListener('load', blankBaseline, { once: true });
    } catch (e) { /* ห้ามให้เรื่องนี้ทำให้ด่านหรือเว็บพัง */ }
  }

  // สถานะของหัวข้อ 15 — มีไว้ให้หน้าต่างส่องอาการอ่าน ว่าหน้านี้แทรกหรือไม่แทรกเพราะอะไร
  // เขียนเฉพาะตอนเปิดโหมดตรวจสอบ คนอ่านทั่วไปไม่เสียอะไร
  var IN_ARTICLE = {};

  // ---- 15. แทรกโฆษณาในเนื้อหาบทความยาว — มือถือ/แท็บเล็ตเท่านั้น --------
  //
  // ตัวเดียวในไฟล์นี้ที่ **เพิ่ม** โฆษณา ไม่ใช่กันหรือยุบ ผู้ใช้สั่งเอง 8 ก.ย. 2569
  // เหตุผลและตัวเลขที่วัดมาอยู่ในคอมเมนต์ของ CFG.inArticleCfg ด้านบน
  //
  // **แยกถังพลาดออกจากด่านโดยตั้งใจ** ผู้ใช้ขอไว้ตรง ๆ ว่ารายได้ต้องไม่ผูกชะตา
  // กับด่าน · ถ้าด่าน selfDisable ตัวเอง โฆษณาต้องไม่หายไปด้วย และในทางกลับกัน
  // ถ้าตัวแทรกพัง ด่านต้องไม่ตาย จึงไม่ใช้ safe() และไม่แตะ errCount ของด่าน
  //
  // **ไม่มี timer ค้าง** จงใจใช้ setInterval ที่ปิดตัวเองเมื่อสำเร็จหรือครบจำนวนครั้ง
  // (ไม่เกิน ~12 วิ) จึงไม่มีอะไรให้ selfDisable ต้องตามเก็บ ตามกฎของโปรเจกต์
  if (CFG.inArticleAd) {
    (function () {
      var C = CFG.inArticleCfg;
      var doneA = false, doneB = false, tries = 0, adErr = 0, timer = null;

      // **เส้นตัดตอนก่อนถูกเปิด** ต้องจำไว้ตั้งแต่ต้น
      // เพราะพอคนอ่านกด "แสดงเพิ่มเติม" เว็บถอด max-height ทิ้ง แล้ว capHeight()
      // จะคืน 0 · ถ้าจุด B ไปอ่านค่าตอนนั้นจะไม่รู้ว่าเส้นตัดเดิมอยู่ตรงไหน
      // แล้วอาจวางก้อนที่สองขึ้นไปอยู่เหนือเส้นตัด ชิดกับก้อนแรก
      // เจอตอนทดสอบจริง 8 ก.ย. 2569 (รอบนั้นรอดเพราะโฆษณาก้อนอื่นดันพื้นลงมาให้ = ฟลุก)
      var capPx0 = 0;

      function note(k, v) { if (DEBUG) IN_ARTICLE[k] = v; }

      // ความสูงเนื้อหาที่วัดได้รอบก่อน — ใช้ดูว่าเลย์เอาต์นิ่งหรือยัง
      var lastH = -1, settleHits = 0;

      function safeAd(fn) {
        return function () {
          if (adErr >= 5) return;
          try { return fn.apply(null, arguments); } catch (e) { adErr++; }
        };
      }

      function offTop(el, base) {
        var r = el.getBoundingClientRect();
        return r.top + (window.pageYOffset || 0) - base;
      }

      // มือถือกับแท็บเล็ตเท่านั้น — เดสก์ท็อปไม่แสดงตามที่ผู้ใช้สั่ง
      // เช็คสองชั้น: ความกว้าง **และ** ต้องเป็นจอสัมผัส
      // ความกว้างอย่างเดียวไม่พอ เพราะคนย่อหน้าต่างบนคอมจะได้โฆษณาไปด้วย
      function onTouchDevice() {
        try {
          if ((window.innerWidth || 0) > C.maxWidth) return false;
          var coarse = window.matchMedia &&
                       window.matchMedia('(pointer: coarse)').matches;
          var touch = (navigator.maxTouchPoints || 0) > 0 || ('ontouchstart' in window);
          return !!(coarse || touch);
        } catch (e) { return false; }
      }

      // ตัวโหลดของ AdSense มีอยู่แล้วเกือบทุกหน้า เติมให้เฉพาะตอนไม่มีจริง ๆ
      function ensureLoader() {
        try {
          if (document.querySelector('script[src*="adsbygoogle.js"]')) return;
          var sc = document.createElement('script');
          sc.async = true;
          sc.crossOrigin = 'anonymous';
          sc.src = 'https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=' + C.client;
          (document.head || document.documentElement).appendChild(sc);
        } catch (e) { adErr++; }
      }

      // ความสูงที่กล่องเนื้อหาถูกล็อกไว้ · 0 = ไม่ได้ล็อก (บทความสั้น/เว็บเปลี่ยนโครง)
      function capHeight() {
        var cap = document.querySelector(C.capSel);
        if (!cap) return 0;
        try { return parseFloat(getComputedStyle(cap).maxHeight) || 0; } catch (e) { return 0; }
      }

      // รายชื่อโฆษณาที่ต้องเว้นระยะให้ พร้อมระยะที่ต้องเว้นของแต่ละก้อน
      // limit = ของที่อยู่ต่ำกว่าเส้นนี้ไม่ต้องนับ เพราะคนอ่านยังมองไม่เห็น
      //
      // **ข้ามของที่อยู่ใต้เส้นตัด** — เจอตอนทดสอบบนหน้าจริง 8 ก.ย. 2569
      // หน้า politics/9690000087853 มีโฆษณาก้อน 440px อยู่ที่ +2,465px
      // ซึ่งอยู่ในส่วนที่ถูกซ่อน คนอ่านไม่มีวันเห็นจนกว่าจะกด "แสดงเพิ่มเติม"
      // แต่มันดันพื้นลงไปที่ 3,505 แล้วกฎสรุปว่า "ไม่มีที่พอ" ทั้งที่โซนที่
      // มองเห็นว่างสนิท = ไม่แทรกเลยบนบทความยาว ซึ่งเป็นเคสที่ตั้งใจทำมาเพื่อ
      //
      // เว้นระยะจากก้อนที่ **มีของ** มากกว่าก้อนที่ **ว่าง** ตั้งใจ —
      // ช่องว่างไม่ได้กินพื้นที่สายตาใคร ถ้าเว้นเท่ากันหมดจะไม่เหลือที่พอวางเลย
      function adsToAvoid(body, base, limit) {
        var out = [];
        var marks = body.querySelectorAll(C.adSel);
        for (var i = 0; i < marks.length; i++) {
          var mOff = offTop(marks[i], base);
          if (mOff >= limit) continue;
          var mr = marks[i].getBoundingClientRect();
          out.push({ top: mOff, bottom: mOff + mr.height,
                     gap: mr.height >= 30 ? C.gapFilled : C.gapEmpty });
        }
        return out;
      }

      // จุด p วางได้ไหม — **ดูทั้งด้านบนและด้านล่าง** (แก้ 8 ก.ย. 2569)
      //
      // เวอร์ชันก่อนคิดแค่ "ต้องอยู่ต่ำกว่าโฆษณาทุกก้อน" ซึ่งผิด
      // โฆษณาที่อยู่ **ต่ำกว่า** จุดที่เราจะวาง ต้องวัดระยะห่างจากด้านล่าง
      // ไม่ใช่บังคับให้เราลงไปอยู่ใต้มัน · ผลคือหน้าที่มีช่องของเว็บนั่งอยู่
      // แถวเพดานพอดี จะถูกตัดสินว่า "ไม่มีที่พอ" ทั้งที่ข้างบนยังว่าง
      // (เจอจริงหน้า south/9690000088080 พื้นถูกดันไป 2,663 ทั้งที่เพดาน 1,819)
      function fits(p, ads) {
        for (var i = 0; i < ads.length; i++) {
          var a = ads[i];
          if (a.bottom <= p) {                       // อยู่เหนือเรา
            if (p - a.bottom < a.gap) return false;
          } else if (a.top >= p + C.assume) {        // อยู่ใต้เรา
            if (a.top - (p + C.assume) < a.gap) return false;
          } else {
            return false;                            // ทับกันตรง ๆ
          }
        }
        return true;
      }

      // **เลือกบล็อกที่ท้ายของมันตกอยู่ในช่วง [พื้น, เป้า] แล้วเอาตัวที่ต่ำสุด**
      //
      // แทรก "ต่อท้ายบล็อกที่จบแล้ว" เสมอ จึงไม่มีทางไปผ่ากลางรูปหรือคลิป
      // และไม่ต้องมีกฎถอยพ้นสื่อ ซึ่งเวอร์ชันแรกมีแล้วพังจริงตอนทดสอบ 8 ก.ย. 2569:
      // ช่วงที่ควรแทรกเป็น รูป -> <br> -> คลิป -> <br> กฎถอยเลยไล่ทะลุขึ้นไป
      // จนชิดโฆษณาตัวบนแล้วยอมแพ้ ทั้งที่มีที่ว่างพอดีอยู่ตรงนั้น
      //
      // เนื้อหาเว็บนี้คั่นด้วย <br> ไม่ใช่ <p> ฉะนั้น <br> คือรอยต่อที่ใช้ได้จริง
      function anchorIn(body, base, lowest, target, ads) {
        var kids = body.children;
        for (var k = kids.length - 1; k >= 0; k--) {   // ไล่จากล่างขึ้นบน เอาตัวที่ต่ำสุดที่ผ่าน
          var kb = offTop(kids[k], base) + kids[k].getBoundingClientRect().height;
          if (kb > target || kb < lowest) continue;
          if (!fits(kb, ads)) continue;
          return kids[k];
        }
        return null;
      }

      function insertAd(at) {
        var wrap = document.createElement('div');
        wrap.className = 'ag-inart';
        wrap.style.cssText = 'display:block;clear:both;margin:18px 0;text-align:center;' +
                             'min-height:' + C.reserve + 'px';
        var ins = document.createElement('ins');
        ins.className = 'adsbygoogle';
        ins.style.cssText = 'display:block;text-align:center';
        ins.setAttribute('data-ad-layout', 'in-article');
        ins.setAttribute('data-ad-format', 'fluid');
        ins.setAttribute('data-ad-client', C.client);
        ins.setAttribute('data-ad-slot', C.slot);
        wrap.appendChild(ins);

        at.parentNode.insertBefore(wrap, at.nextSibling);

        ensureLoader();
        try { (window.adsbygoogle = window.adsbygoogle || []).push({}); } catch (e) { adErr++; }

        // ไม่มีของมาลง = คืนที่ที่จองไว้ ไม่ทิ้งช่องขาวไว้ให้คนอ่าน
        // (กฎ CSS ของหัวข้อ 6 ซ่อนตัว ins ให้แล้ว แต่ความสูงที่เราจองไว้ต้องคืนเอง)
        setTimeout(safeAd(function () {
          var st = ins.getAttribute('data-ad-status');
          if (st === 'unfilled' || ins.getBoundingClientRect().height < 30) {
            wrap.style.minHeight = '0px';
            wrap.style.margin = '0';
          }
        }), C.collapseAfter);
      }

      // ---- จุด A: ท้ายสุดของโซนที่คนอ่านเห็นอยู่แล้ว -----------------------
      function placeVisible() {
        if (doneA) return;
        var body = document.querySelector(C.bodySel);
        if (!body) return;                       // เนื้อหายังไม่มา รอรอบหน้า

        var base = (body.getBoundingClientRect().top + (window.pageYOffset || 0));
        var bodyH = body.getBoundingClientRect().height;

        // **อย่าตัดสินว่าสั้นตั้งแต่รอบแรก** เนื้อหายังพองได้อีกตอนโฆษณาลง
        if (bodyH < C.minBody) {
          if (tries >= C.maxTries) { doneA = true; note('why', 'บทความสั้น ' + Math.round(bodyH)); }
          else note('why', 'ยังสั้นอยู่ ' + Math.round(bodyH));
          return;
        }

        // **รอให้เลย์เอาต์นิ่งก่อนค่อยวาง** — เจอจริงหลัง deploy 2.9.22 (8 ก.ย. 2569)
        // โฆษณาของเว็บที่อยู่ **เหนือ** จุดแทรกโหลดเสร็จทีหลัง (ช่อง +260 พอง 0 -> 440px)
        // เนื้อหาทั้งก้อนถูกดันลง กล่องที่เราวางไว้ที่ 1,419 ไหลไปอยู่ที่ 1,718
        // = หลุดออกนอกโซนที่คำนวณไว้ แล้วไปทับแถบ "แสดงเพิ่มเติม"
        // ระยะเผื่อ assume ที่ตั้งไว้กันเรื่องนี้ไม่ได้ เพราะมันเกิดหลังวางไปแล้ว
        //
        // วัดที่ความสูงเนื้อหาแทนการรอเวลาตายตัว เพราะไม่ผูกกับว่าเจ้าไหนโหลดช้าแค่ไหน
        // สองรอบติดกันเท่ากัน = ของที่จะพองพองเสร็จแล้ว
        if (bodyH !== lastH) {
          lastH = bodyH; settleHits = 0;
          note('why', 'รอเลย์เอาต์นิ่ง ' + Math.round(bodyH));
          return;
        }
        settleHits++;
        if (settleHits < C.settleNeed || tries < C.minTries) {
          note('why', 'นิ่งแล้ว ' + settleHits + ' รอบ · รออีก');
          return;
        }

        // **ต้องเห็นช่องโฆษณาของเว็บก่อนด้วย** — เจอจริงหลัง deploy 2.9.22
        // เว็บยัดช่องเข้าเนื้อหาด้วย JS ทีหลัง ถ้าวางตอนยังไม่มีสักช่อง
        // ตัวนับระยะห่างจะเริ่มจากศูนย์แล้ววางชิดหัวบทความ (วางจริงที่ +962
        // ทั้งที่ช่องของเว็บมาโผล่ที่ +260 สูง 440 ทีหลัง เหลือห่างแค่ 262px)
        //
        // ถ้าครบจำนวนรอบแล้วยังไม่มีสักช่อง แปลว่าบทความนั้นไม่มีจริง ๆ ค่อยวางได้
        if (!body.querySelector(C.adSel) && tries < C.maxTries) { note('why', 'ยังไม่เห็นช่องของเว็บ'); return; }

        // **เพดาน** — ของที่อยู่ต่ำกว่าเส้นตัดคนอ่านไม่เห็นจนกว่าจะกด "แสดงเพิ่มเติม"
        // ยิงโฆษณาลงไปตรงนั้นคือยิงลงที่มืด ผิดนโยบายและไม่มีใครเห็น
        var ceil = bodyH;
        var mh = capHeight();
        if (mh > 0) {
          var fade = document.querySelector(C.fadeSel);
          var fadeH = fade ? fade.getBoundingClientRect().height : 0;
          ceil = Math.min(ceil, mh - fadeH - C.pad);
        }

        var ads = adsToAvoid(body, base, ceil);
        note('เพดาน', Math.round(ceil));
        note('ช่องที่ต้องเลี่ยง', ads.length);

        // เอาให้ท้ายที่สุดเท่าที่ยังอยู่ในโซนที่มองเห็น ตามที่ผู้ใช้ขอ
        // **เผื่อความสูงจริงของโฆษณา ไม่ใช่ความสูงที่จอง** ดูเหตุผลที่ CFG.assume
        var target = ceil - C.assume;
        if (target < C.minTop) { doneA = true; note('why', 'โซนที่มองเห็นแคบเกิน'); return; }

        var at = anchorIn(body, base, C.minTop, target, ads);
        if (!at || !at.parentNode) { doneA = true; note('why', 'ไม่มีรอยต่อในช่วงที่วางได้'); return; }

        doneA = true;
        note('why', 'แทรกแล้ว');
        note('A', Math.round(offTop(at, base) + at.getBoundingClientRect().height));
        insertAd(at);
      }

      // ---- จุด B: ในส่วนที่เพิ่งถูกเปิดออกมา ------------------------------
      function placeExpanded() {
        if (doneB) return;
        var body = document.querySelector(C.bodySel);
        if (!body) return;

        var base = (body.getBoundingClientRect().top + (window.pageYOffset || 0));
        var bodyH = body.getBoundingClientRect().height;
        if (!capPx0 || bodyH - capPx0 < C.expandMin) { doneB = true; note('whyB', 'เปิดออกมาน้อยไป'); return; }

        // ตอนนี้ไม่มีอะไรถูกซ่อนอีกแล้ว จึงนับโฆษณาทุกก้อนบนหน้า
        // (รวมก้อนของจุด A ด้วย มันมี ins.adsbygoogle อยู่ข้างในจึงถูกนับเอง)
        var ads = adsToAvoid(body, base, Infinity);
        var lowest = capPx0 + C.expandGap;
        var target = bodyH - C.assume - C.tailGap;
        if (target < lowest) { doneB = true; note('whyB', 'ไม่มีที่พอ'); return; }

        var at = anchorIn(body, base, lowest, target, ads);
        if (!at || !at.parentNode) { doneB = true; note('whyB', 'ไม่มีรอยต่อ'); return; }

        doneB = true;
        note('whyB', 'แทรกแล้ว');
        note('B', Math.round(offTop(at, base) + at.getBoundingClientRect().height));
        insertAd(at);
      }

      // เฝ้าการกด "แสดงเพิ่มเติม" — **ไม่ผูกกับปุ่มตัวใดตัวหนึ่ง**
      // ดูที่ผลลัพธ์แทน: กล่องเนื้อหาสูงขึ้นเกินเพดานเดิม = ถูกเปิดแล้ว
      // จะเปิดด้วยปุ่มนั้น ด้วยสคริปต์อื่น หรือด้วยวิธีไหนก็จับได้เหมือนกัน
      // และถอด observer ทิ้งทันทีที่ทำงานเสร็จ ไม่เหลืออะไรค้างไว้
      function watchExpand() {
        if (!C.afterExpand) return;
        capPx0 = capHeight();
        if (!capPx0) return;                     // ไม่ได้ล็อกความสูง = ไม่มีอะไรให้เปิด
        var cap = document.querySelector(C.capSel);
        if (!cap) return;

        var ro = null, fired = false;
        var check = safeAd(function () {
          if (fired || doneB) return;
          if (cap.getBoundingClientRect().height <= capPx0 + 100) return;
          fired = true;
          if (ro) { try { ro.disconnect(); } catch (e) {} ro = null; }
          setTimeout(safeAd(placeExpanded), 400);   // รอเลย์เอาต์นิ่งก่อนค่อยวัด
        });

        if (typeof ResizeObserver === 'function') {
          try { ro = new ResizeObserver(check); ro.observe(cap); } catch (e) { ro = null; }
        }
        if (!ro) {
          // เบราว์เซอร์เก่า — ผูกกับการแตะปุ่มแทน แล้วค่อยไปวัดผลทีหลัง
          var link = document.querySelector(C.fadeSel);
          if (link) link.addEventListener('click', safeAd(function () {
            setTimeout(check, 500); setTimeout(check, 1500);
          }), true);
        }
      }

      function start() {
        note('เป้า', C.slot);
        if (!onTouchDevice()) { note('why', 'ไม่ใช่มือถือ/แท็บเล็ต — จอ ' + (window.innerWidth || 0)); return; }
        note('why', 'เริ่มทำงาน');
        watchExpand();
        timer = setInterval(safeAd(function () {
          tries++;
          note('รอบ', tries);
          placeVisible();
          if (doneA || tries >= C.maxTries) { clearInterval(timer); timer = null; }
        }), C.retryEvery);
      }

      // รอให้ช่องโฆษณาของเว็บเองถูกยัดเข้ามาก่อน ไม่งั้นนับระยะห่างผิด
      setTimeout(safeAd(start), C.firstWait);
    })();
  }

  // ---- หน้าต่างส่องอาการ เปิดเฉพาะโหมดตรวจสอบ --------------------------
  //
  // เดิมเปิดให้ทุกคนเสมอ ทดสอบจริงแล้วพบว่าสคริปต์อื่นบนหน้าอ่านได้ทั้งหมด:
  // รายชื่อโดเมนที่บล็อก เกณฑ์ของกฎเดารูปร่าง ที่อยู่ตัวเก็บ log
  // และทุกอย่างที่ด่านจับได้บนหน้านั้น = แผนที่สำหรับออกแบบวิธีเลี่ยง
  //
  // เปิดด้วย localStorage.adGuardDebug = '1' แล้วรีเฟรช เมื่อต้องไล่ปัญหา
  if (DEBUG) {
  window.__adGuard = {
    version: VERSION,
    mode: CFG.mode,
    config: CFG,
    log: LOG,
    // หน้านี้เฝ้าเรื่อง "ถูกพาออกจากหน้า" อยู่ไหม (หัวข้อ 14)
    // ในโหมดตรวจสอบจะเป็น true เสมอ ไม่ต้องรอดวงจาก forcedNavSample
    // และบอกด้วยว่าเบราว์เซอร์เครื่องนี้มี Navigation API ให้ใช้หรือเปล่า
    navWatch: NAV_WATCH,

    // หัวข้อ 15 แทรกหรือไม่แทรกในหน้านี้ และถ้าไม่แทรกเพราะอะไร
    inArticle: IN_ARTICLE,

    navApi: (function () { try { return !!window.navigation; } catch (e) { return false; } })(),
    dump: function () { console.table(LOG); return LOG.length; },
    clear: function () { LOG.length = 0; },

    // สรุปว่า "ไฟล์ไหน" เป็นคนสร้างของที่ถูกดัก เรียงจากทำบ่อยสุด
    // ตัวที่โผล่ขึ้นมาคู่กับ link-neutralized คือคนพาลิงก์ปูทับเข้ามา
    who: function () {
      var by = {};
      LOG.forEach(function (r) {
        var m = ((r.stack || '').split('\n')[0] || '').match(/(https?:\/\/[^\s)]+)/);
        // ตัด :บรรทัด:คอลัมน์ ท้าย URL ออก แต่ต้องไม่ไปตัดพอร์ตของโดเมน
        var src = m ? m[1].replace(/:\d+(?::\d+)?$/, '')
                    : '(หาไม่เจอ — มาจากจังหวะที่ตามรอยไม่ได้)';
        var e = by[src] || (by[src] = { script: src, count: 0, kinds: {} });
        e.count++;
        e.kinds[r.kind] = (e.kinds[r.kind] || 0) + 1;
      });
      var rows = Object.keys(by).map(function (k) {
        return { script: by[k].script, count: by[k].count,
                 kinds: Object.keys(by[k].kinds).map(function (n) {
                   return n + ' x' + by[k].kinds[n];
                 }).join(', ') };
      }).sort(function (a, b) { return b.count - a.count; });
      console.table(rows);
      return rows;
    }
  };
  console.log('%c[ad-guard] v' + VERSION + ' • mode=' + CFG.mode +
              ' • block: ' + BLOCK_HOSTS.join(', '),
              'background:#222;color:#7f7;padding:2px 6px');
  }
})();
