@prefetchru/prefetch 1.0.10 → 1.1.1

package/prefetch.esm.js

@@ -1,209 +1,258 @@
-/*!
- * prefetch.ru v1.0.10 (ESM) - Мгновенная загрузка страниц
+/*!
+ * prefetch.ru v1.1.1 (ESM) - Мгновенная загрузка страниц
  * © 2026 Сергей Макаров | MIT License
  * https://prefetch.ru | https://github.com/prefetch-ru
  */
-function createPrefetch(importMetaUrl) {
-  'use strict'
+/**
+ * Core prefetch logic - shared between IIFE and ESM builds.
+ * @param {Object} options
+ * @param {function(): string|null} options.getNonce - Function to get CSP nonce
+ * @param {boolean} options.isBrowser - Whether running in browser environment
+ * @returns {Object} Prefetch API
+ */
+function createPrefetchCore(options) {
+
+  var getNonce = options && options.getNonce;
+  var isBrowser = options ? options.isBrowser : true;
 
   // SSR/Non-browser guard
-  if (typeof window === 'undefined' || typeof document === 'undefined') {
-    return { __prefetchRu: true, version: '1.0.10', preload: function () {} }
+  if (!isBrowser || typeof window === 'undefined' || typeof document === 'undefined') {
+    return {
+      __prefetchRu: true,
+      version: '1.1.1',
+      preload: function () {},
+      destroy: function () {},
+      refresh: function () {}
+    }
   }
 
   // Состояние
-  var preloaded = new Set()
-  var hoverTimers = new WeakMap()
+  var preloaded = new Set();
+  var hoverTimers = new WeakMap();
+  var disabled = false;
+
+  // v1.0.11: in-flight лимит (макс. параллельных запросов)
+  var inFlight = 0;
+  var maxInFlight = 4;
+  var queue = [];
+  var maxQueue = 50; // v1.0.11: лимит очереди (защита от переполнения)
 
-  var lastTouchTime = 0
-  var touchTimer = 0
-  var touchCancel = null
+  // v1.0.13: Set активных AbortController для корректного destroy()
+  var activeControllers = new Set();
 
-  var isMobile = false
-  var isIOS = false
-  var chromiumVer = null
-  var platform = null
-  var saveData = false
-  var connType = null
+  // v1.0.13: буфер для Speculation Rules (группируем URL и вставляем одним JSON)
+  var specBuffer = { prefetch: [], prerender: [], crossOrigin: [] };
+  var specFlushTimer = 0;
+
+  // v1.0.11: кэш ключа текущей страницы (избегаем new URL() в горячих местах)
+  var currentKey = '';
+
+  var lastTouchTime = 0;
+  var touchTimer = 0;
+  var touchCancel = null;
+
+  var isMobile = false;
+  var isIOS = false;
+  var platform = null;
+  var saveData = false;
+  var connType = null;
 
   // CSP / поддержка
-  var scriptNonce = null
-  var supportsLinkPrefetch = false
+  var scriptNonce = null;
+  var supportsLinkPrefetch = false;
 
   // Настройки
-  var hoverDelay = 65
-  var touchDelay = 80
-  var maxPreloads = 50
-  var allowQuery = false
-  var allowExternal = false
-  var whitelist = false
-
-  var useSpecRules = false
-  var specMode = 'none' // 'none' | 'prefetch' | 'prerender'
-  var prerenderAll = false
-
-  var mousedownMode = false
-  var viewportMode = false
-  var observeDom = false
-
-  function detectNonceFromImportMeta(metaUrl) {
-    try {
-      if (!metaUrl) return null
-      // script.src и import.meta.url обычно оба абсолютные → можно сравнивать напрямую
-      var scripts = document.getElementsByTagName('script')
-      for (var i = 0; i < scripts.length; i++) {
-        var s = scripts[i]
-        if (!s || !s.src) continue
-        if (s.src === metaUrl) {
-          var n = s.nonce || s.getAttribute('nonce') || null
-          if (n) return n
-          break
-        }
-      }
-    } catch (e) {}
-    return null
-  }
+  var hoverDelay = 65;
+  var touchDelay = 80;
+  var maxPreloads = 50;
+  var allowQuery = false;
+  var allowExternal = false;
+  var whitelist = false;
+
+  var useSpecRules = false;
+  var specMode = 'none'; // 'none' | 'prefetch' | 'prerender'
+  var specRulesFallback = false; // v1.0.11: fallback при SpecRules (по умолчанию отключён)
+  var prerenderAll = false;
+
+  var mousedownMode = false;
+  var viewportMode = false;
+  var observeDom = false;
+
+  // v1.0.11: regex вынесены в верхний scope (perf — не создавать на каждый вызов)
+  var DANGEROUS_PATH_RE = /(^|\/)(login|logout|auth|register|cart|basket|add|delete|remove)(\/|$|\.)/i;
+  var FILE_EXT_RE = /\.(pdf|doc|docx|xls|xlsx|zip|rar|exe)($|\?)/i
 
   // Инициализация
   ;(function init() {
-    // CSP nonce (ESM): через import.meta.url → находим <script type="module" src="..."> и читаем nonce
-    scriptNonce = detectNonceFromImportMeta(importMetaUrl)
-
-    // fallback: на случай окружений, где currentScript всё же доступен
-    if (!scriptNonce) {
+    // CSP nonce через переданную функцию
+    if (getNonce) {
       try {
-        var cs = document.currentScript
-        if (cs && cs.nonce) scriptNonce = cs.nonce
+        scriptNonce = getNonce();
       } catch (e) {}
     }
 
     // rel=prefetch support
     try {
-      var l = document.createElement('link')
+      var l = document.createElement('link');
       if (l.relList && typeof l.relList.supports === 'function') {
-        supportsLinkPrefetch = l.relList.supports('prefetch')
+        supportsLinkPrefetch = l.relList.supports('prefetch');
       }
     } catch (e) {}
 
-    var ua = navigator.userAgent
+    var ua = navigator.userAgent;
+    var uaData = navigator.userAgentData; // v1.0.12: UA-CH API (более надёжно в долгосрочной перспективе)
 
     // Определяем устройство
-    isIOS =
-      /iPad|iPhone/.test(ua) ||
-      (navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1)
-    var isAndroid = /Android/.test(ua)
-    isMobile = (isIOS || isAndroid) && Math.min(screen.width, screen.height) < 768
-    if (isMobile) maxPreloads = 20
-
-    // Chromium версия (для внешних ссылок)
-    var cm = ua.match(/Chrome\/(\d+)/)
-    if (cm) chromiumVer = parseInt(cm[1], 10)
+    // v1.0.12: используем userAgentData если доступен, иначе fallback на UA
+    if (uaData) {
+      // UA-CH API: https://developer.mozilla.org/en-US/docs/Web/API/NavigatorUAData
+      isIOS = false; // UA-CH пока не поддерживается на iOS
+      var isAndroid = uaData.platform === 'Android';
+      isMobile = uaData.mobile || false;
+      // Chromium версия через brands
+      var brands = uaData.brands || [];
+      for (var i = 0; i < brands.length; i++) {
+        var b = brands[i];
+        if (b.brand === 'Chromium' || b.brand === 'Google Chrome') {
+          parseInt(b.version, 10);
+          break
+        }
+      }
+    } else {
+      // Fallback на традиционный UA sniffing
+      isIOS =
+        /iPad|iPhone/.test(ua) ||
+        (navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1);
+      var isAndroid = /Android/.test(ua);
+      isMobile = (isIOS || isAndroid) && Math.min(screen.width, screen.height) < 768;
+      // Chromium версия из UA
+      var cm = ua.match(/Chrome\/(\d+)/);
+      if (cm) parseInt(cm[1], 10);
+    }
+    if (isMobile) maxPreloads = 20;
 
     // Сеть
-    var conn = navigator.connection
+    var conn = navigator.connection;
     if (conn) {
-      connType = conn.effectiveType
-      saveData = conn.saveData || false
+      connType = conn.effectiveType;
+      saveData = conn.saveData || false;
     }
 
     // Ждём DOM
     if (document.readyState === 'loading') {
-      document.addEventListener('DOMContentLoaded', setup)
+      document.addEventListener('DOMContentLoaded', setup);
     } else {
-      setup()
+      setup();
     }
-  })()
+  })();
 
   function setup() {
-    var body = document.body
+    // v1.0.11: защита от вызова после destroy()
+    if (disabled) return
+
+    var body = document.body;
     if (!body) return
 
-    platform = detectPlatform()
+    // v1.0.11: кэшируем ключ текущей страницы
+    currentKey = location.origin + location.pathname + location.search;
+
+    platform = detectPlatform();
 
     // Читаем конфигурацию
-    var ds = body.dataset
-    allowQuery = 'prefetchAllowQueryString' in ds || 'instantAllowQueryString' in ds
-    allowExternal = 'prefetchAllowExternalLinks' in ds || 'instantAllowExternalLinks' in ds
-    whitelist = 'prefetchWhitelist' in ds || 'instantWhitelist' in ds
+    var ds = body.dataset;
+    allowQuery = 'prefetchAllowQueryString' in ds || 'instantAllowQueryString' in ds;
+    allowExternal = 'prefetchAllowExternalLinks' in ds || 'instantAllowExternalLinks' in ds;
+    whitelist = 'prefetchWhitelist' in ds || 'instantWhitelist' in ds;
 
     // CSP nonce override через data-*
     // <body data-prefetch-nonce="...">
-    if (ds.prefetchNonce) scriptNonce = ds.prefetchNonce
-    if (!scriptNonce && ds.instantNonce) scriptNonce = ds.instantNonce
+    if (ds.prefetchNonce) scriptNonce = ds.prefetchNonce;
+    if (!scriptNonce && ds.instantNonce) scriptNonce = ds.instantNonce;
 
     // Speculation Rules — opt-in по наличию атрибута:
     // <body data-prefetch-specrules> (prefetch)
     // <body data-prefetch-specrules="prerender">
     // <body data-prefetch-specrules="no">
-    var hasSr = 'prefetchSpecrules' in ds || 'instantSpecrules' in ds
+    var hasSr = 'prefetchSpecrules' in ds || 'instantSpecrules' in ds;
     if (
       !isIOS &&
       hasSr &&
       HTMLScriptElement.supports &&
       HTMLScriptElement.supports('speculationrules')
     ) {
-      var sr = ds.prefetchSpecrules || ds.instantSpecrules
+      var sr = ds.prefetchSpecrules || ds.instantSpecrules;
       if (sr === 'prerender') {
-        specMode = 'prerender'
-        useSpecRules = true
+        specMode = 'prerender';
+        useSpecRules = true;
       } else if (sr !== 'no') {
-        specMode = 'prefetch'
-        useSpecRules = true
+        specMode = 'prefetch';
+        useSpecRules = true;
       }
     }
 
+    // v1.0.11: fallback при Speculation Rules (по умолчанию отключён для избежания двойного трафика)
+    // <body data-prefetch-specrules-fallback>
+    specRulesFallback = 'prefetchSpecrulesFallback' in ds || 'instantSpecrulesFallback' in ds;
+
     // Разрешить "глобальный" prerender без whitelist (не рекомендуется, но бывает нужно)
     // <body data-prefetch-prerender-all>
-    prerenderAll = 'prefetchPrerenderAll' in ds || 'instantPrerenderAll' in ds
+    prerenderAll = 'prefetchPrerenderAll' in ds || 'instantPrerenderAll' in ds;
 
     // Интенсивность
-    var intensity = ds.prefetchIntensity || ds.instantIntensity
+    var intensity = ds.prefetchIntensity || ds.instantIntensity;
     if (intensity === 'mousedown') {
-      mousedownMode = true
+      mousedownMode = true;
     } else if (intensity === 'viewport' || intensity === 'viewport-all') {
       if (intensity === 'viewport-all' || (isMobile && isNetworkOk())) {
-        viewportMode = true
+        viewportMode = true;
       }
     } else if (intensity) {
-      var d = parseInt(intensity, 10)
-      if (!isNaN(d) && d >= 0) hoverDelay = d
+      var d = parseInt(intensity, 10);
+      if (!isNaN(d) && d >= 0) hoverDelay = d;
     }
 
     // На мобильных делаем touch-предзагрузку менее агрессивной
     if (isMobile) {
-      touchDelay = Math.max(60, Math.min(hoverDelay || 0, 150))
+      touchDelay = Math.max(60, Math.min(hoverDelay || 0, 150));
     }
 
     // DOM observer для SPA
-    observeDom = 'prefetchObserveDom' in ds
+    // v1.0.11: добавлен алиас instantObserveDom
+    observeDom = 'prefetchObserveDom' in ds || 'instantObserveDom' in ds;
     if (!observeDom && (platform === 'bitrix' || platform === 'tilda')) {
-      observeDom = true
+      observeDom = true;
     }
 
+    // v1.0.11: обновляем currentKey при навигации (pushState, popstate, hashchange)
+    window.addEventListener('popstate', updateCurrentKey);
+    window.addEventListener('hashchange', updateCurrentKey);
+    // v1.0.12: pageshow для bfcache restore (popstate не всегда срабатывает при возврате из bfcache)
+    window.addEventListener('pageshow', onPageShow);
+
     // Tilda — увеличиваем задержку из-за popup-ов
-    if (platform === 'tilda' && hoverDelay < 100) hoverDelay = 100
+    if (platform === 'tilda' && hoverDelay < 100) hoverDelay = 100;
 
     // События
-    var opts = { capture: true, passive: true }
-    document.addEventListener('touchstart', onTouchStart, opts)
+    var opts = { capture: true, passive: true };
+    document.addEventListener('touchstart', onTouchStart, opts);
     if (!mousedownMode) {
-      document.addEventListener('mouseover', onMouseOver, opts)
+      document.addEventListener('mouseover', onMouseOver, opts);
     } else {
-      document.addEventListener('mousedown', onMouseDown, opts)
+      document.addEventListener('mousedown', onMouseDown, opts);
     }
 
     // Viewport observer
     // v1.0.10: feature-detection — если IntersectionObserver недоступен, отключаем viewport режим
-    if (viewportMode && typeof IntersectionObserver === 'undefined') viewportMode = false
+    if (viewportMode && typeof IntersectionObserver === 'undefined') viewportMode = false;
 
     if (viewportMode) {
-      var rIC = window.requestIdleCallback || function (cb) { setTimeout(cb, 1) }
-      rIC(startViewportObserver, { timeout: 1500 })
+      var rIC = window.requestIdleCallback || function (cb) { setTimeout(cb, 1); };
+      rIC(startViewportObserver, { timeout: 1500 });
     }
 
     // v1.0.9: MutationObserver нужен только для viewport режима (отслеживать новые ссылки)
     // v1.0.10: feature-detection — если MutationObserver недоступен, не запускаем
-    if (observeDom && viewportMode && typeof MutationObserver !== 'undefined') startMutationObserver()
+    if (observeDom && viewportMode && typeof MutationObserver !== 'undefined') startMutationObserver();
   }
 
   function detectPlatform() {
@@ -215,108 +264,136 @@ function createPrefetch(importMetaUrl) {
 
   function isNetworkOk() {
     if (saveData) return false
-    if (connType === 'slow-2g' || connType === '2g') return false
+    if (connType === 'slow-2g' || connType === '2g' || connType === '3g') return false
     return true
   }
 
+  // v1.0.11: обновление currentKey при навигации (SPA-гибриды, pushState)
+  function updateCurrentKey() {
+    currentKey = location.origin + location.pathname + location.search;
+  }
+
+  // v1.0.12: pageshow для bfcache restore
+  function onPageShow(e) {
+    // persisted === true означает восстановление из bfcache
+    if (e && e.persisted) {
+      updateCurrentKey();
+    }
+  }
+
   function getAnchorFromEventTarget(t) {
     if (!t) return null
-    if (t.nodeType && t.nodeType !== 1) t = t.parentElement
+    if (t.nodeType && t.nodeType !== 1) t = t.parentElement;
     if (!t || typeof t.closest !== 'function') return null
     return t.closest('a')
   }
 
   function onTouchStart(e) {
+    // v1.0.11: защита от синтетических событий и disabled режим
+    if (disabled) return
+    if (e && e.isTrusted === false) return
+
     // v1.0.9: используем Date.now() для единой шкалы времени
-    lastTouchTime = Date.now()
+    lastTouchTime = Date.now();
 
-    var a = getAnchorFromEventTarget(e.target)
+    var a = getAnchorFromEventTarget(e.target);
     if (!canPreload(a)) return
 
     // задержка + отмена на scroll/touchmove
     if (touchTimer) {
-      clearTimeout(touchTimer)
-      touchTimer = 0
+      clearTimeout(touchTimer);
+      touchTimer = 0;
     }
     if (touchCancel) {
-      document.removeEventListener('touchmove', touchCancel, true)
-      document.removeEventListener('scroll', touchCancel, true)
-      touchCancel = null
+      document.removeEventListener('touchmove', touchCancel, true);
+      document.removeEventListener('scroll', touchCancel, true);
+      touchCancel = null;
     }
 
-    var cancelled = false
+    var cancelled = false;
     touchCancel = function () {
-      cancelled = true
+      cancelled = true;
       if (touchTimer) {
-        clearTimeout(touchTimer)
-        touchTimer = 0
+        clearTimeout(touchTimer);
+        touchTimer = 0;
       }
-      document.removeEventListener('touchmove', touchCancel, true)
-      document.removeEventListener('scroll', touchCancel, true)
-      touchCancel = null
-    }
+      document.removeEventListener('touchmove', touchCancel, true);
+      document.removeEventListener('scroll', touchCancel, true);
+      touchCancel = null;
+    };
 
-    document.addEventListener('touchmove', touchCancel, { capture: true, passive: true, once: true })
-    document.addEventListener('scroll', touchCancel, { capture: true, passive: true, once: true })
+    document.addEventListener('touchmove', touchCancel, { capture: true, passive: true, once: true });
+    document.addEventListener('scroll', touchCancel, { capture: true, passive: true, once: true });
 
     touchTimer = setTimeout(function () {
       if (touchCancel) {
-        document.removeEventListener('touchmove', touchCancel, true)
-        document.removeEventListener('scroll', touchCancel, true)
-        touchCancel = null
+        document.removeEventListener('touchmove', touchCancel, true);
+        document.removeEventListener('scroll', touchCancel, true);
+        touchCancel = null;
       }
-      touchTimer = 0
-      if (!cancelled) preload(a.href, a)
-    }, touchDelay)
+      touchTimer = 0;
+      if (!cancelled) preload(a.href, a);
+    }, touchDelay);
   }
 
   function onMouseOver(e) {
+    // v1.0.11: защита от синтетических событий и disabled режим
+    if (disabled) return
+    if (e && e.isTrusted === false) return
+
     // v1.0.9: единая шкала времени Date.now()
     if (lastTouchTime && Date.now() - lastTouchTime < 2500) return
 
-    var a = getAnchorFromEventTarget(e.target)
-    if (!canPreload(a)) return
+    var a = getAnchorFromEventTarget(e.target);
+    if (!a) return
 
-    // v1.0.7: защита от множественных mouseover по вложенным элементам (не плодим таймеры)
+    // v1.0.11: проверяем таймер ДО canPreload (perf — mouseover очень шумный)
     if (hoverTimers.has(a)) return
 
+    if (!canPreload(a)) return
+
     // mouseleave не срабатывает при перемещении внутри ссылки (в отличие от mouseout)
-    a.addEventListener('mouseleave', onMouseLeave, { passive: true, once: true })
+    a.addEventListener('mouseleave', onMouseLeave, { passive: true, once: true });
 
     var t = setTimeout(function () {
-      preload(a.href, a)
-      hoverTimers.delete(a)
-    }, hoverDelay)
-    hoverTimers.set(a, t)
+      preload(a.href, a);
+      hoverTimers.delete(a);
+    }, hoverDelay);
+    hoverTimers.set(a, t);
   }
 
   function onMouseLeave(e) {
-    var a = e.currentTarget
+    var a = e.currentTarget;
     if (!a) return
 
-    var t = hoverTimers.get(a)
+    var t = hoverTimers.get(a);
     if (t) {
-      clearTimeout(t)
-      hoverTimers.delete(a)
+      clearTimeout(t);
+      hoverTimers.delete(a);
     }
   }
 
   function onMouseDown(e) {
-    if (typeof e.button === 'number' && e.button === 2) return
+    // v1.0.11: защита от синтетических событий и disabled режим
+    if (disabled) return
+    if (e && e.isTrusted === false) return
+
+    // v1.0.12: button===1 (middle click) тоже открывает новую вкладку — префетч бессмысленен
+    if (typeof e.button === 'number' && (e.button === 1 || e.button === 2)) return
     // v1.0.10: при модификаторах (Ctrl/Meta/Shift/Alt) открывается новая вкладка — префетч бессмысленен
     if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return
     // v1.0.9: единая шкала времени Date.now()
     if (lastTouchTime && Date.now() - lastTouchTime < 2500) return
 
-    var a = getAnchorFromEventTarget(e.target)
-    if (canPreload(a)) preload(a.href, a)
+    var a = getAnchorFromEventTarget(e.target);
+    if (canPreload(a)) preload(a.href, a);
   }
 
   function canPreload(a) {
     if (!a) return false
 
     // v1.0.7: исключаем <a href=""> и <a> без href (часто используются как кнопки)
-    var hrefAttr = a.getAttribute('href')
+    var hrefAttr = a.getAttribute('href');
     if (hrefAttr === null || hrefAttr.trim() === '') return false
 
     if (!a.href) return false
@@ -338,7 +415,7 @@ function createPrefetch(importMetaUrl) {
     // Внешние ссылки
     if (a.origin !== location.origin) {
       if (!allowExternal && !('prefetch' in a.dataset) && !('instant' in a.dataset)) return false
-      if (!chromiumVer) return false
+      // v1.1.1: убрано ограничение chromiumVer — Firefox и Safari тоже поддерживают cross-origin prefetch
     }
 
     // Query string
@@ -347,11 +424,11 @@ function createPrefetch(importMetaUrl) {
     // Якорь на той же странице
     if (a.hash && a.pathname + a.search === location.pathname + location.search) return false
 
-    // v1.0.7: не префетчим текущую страницу (в т.ч. для случаев вроде href="")
-    if (urlKey(a.href) === urlKey(location.href)) return false
+    // v1.0.11: используем свойства <a> напрямую вместо new URL() (perf)
+    var key = a.origin + a.pathname + a.search;
+    if (key === currentKey) return false
 
-    // Уже загружено (ключ НЕ модифицирует реальный URL запроса!)
-    var key = urlKey(a.href)
+    // Уже загружено
     if (preloaded.has(key)) return false
 
     if (!checkPlatform(a)) return false
@@ -361,19 +438,11 @@ function createPrefetch(importMetaUrl) {
   }
 
   function checkPlatform(a) {
-    var href = a.href
+    var href = a.href;
 
-    // v1.0.7: для точных проверок /add /delete /remove используем pathname
-    var pathname = ''
-    var hash = ''
-    try {
-      var u = new URL(href, location.href)
-      pathname = u.pathname || ''
-      hash = u.hash || ''
-    } catch (e) {
-      pathname = ''
-      hash = ''
-    }
+    // v1.0.11: используем свойства <a> напрямую вместо new URL() (perf)
+    var pathname = a.pathname || '';
+    var hash = a.hash || '';
 
     if (platform === 'bitrix' || platform === 'bitrix24') {
       if (href.indexOf('/bitrix/') !== -1 || href.indexOf('sessid=') !== -1) return false
@@ -381,27 +450,24 @@ function createPrefetch(importMetaUrl) {
     }
 
     if (platform === 'tilda') {
+      // Можно проверять и по href, но hash надёжнее/дешевле
       if (hash.indexOf('#popup:') !== -1 || hash.indexOf('#rec') !== -1) return false
     }
 
     // v1.0.9: все опасные пути проверяем по сегментам pathname, не по подстроке href
-    // Это исправляет ложные блокировки /author, /cartoon, /authentication и т.д.
-    var isDangerousPath = /(^|\/)(login|logout|auth|register|cart|basket|add|delete|remove)(\/|$|\.)/i.test(pathname)
-
-    if (isDangerousPath) return false
-
-    if (/\.(pdf|doc|docx|xls|xlsx|zip|rar|exe)($|\?)/i.test(href)) return false
+    // v1.0.11: regex вынесены в верхний scope (perf)
+    if (DANGEROUS_PATH_RE.test(pathname)) return false
+    // v1.0.11: проверяем расширение по pathname (href может содержать #hash)
+    if (FILE_EXT_RE.test(pathname)) return false
 
     return true
   }
 
   function checkAnalytics(a) {
-    var href = a.href
-    var cls = a.className || ''
+    var cls = a.className || '';
 
-    // Извлекаем hostname для проверки доменов аналитики
-    var host = ''
-    try { host = new URL(href, location.href).hostname } catch (e) { host = '' }
+    // v1.0.11: используем свойства <a> напрямую вместо new URL() (perf)
+    var host = a.hostname || '';
 
     if (cls.indexOf('ym-') !== -1) return false
     if (host === 'mc.yandex.ru' || host === 'metrika.yandex.ru') return false
@@ -421,24 +487,16 @@ function createPrefetch(importMetaUrl) {
     return true
   }
 
-  // Ключ для дедупликации: НЕ трогаем pathname (включая / на конце), только убираем hash
-  function urlKey(url) {
-    try {
-      var u = new URL(url, location.href)
-      return u.origin + u.pathname + u.search
-    } catch (e) {
-      return url
-    }
-  }
-
-  // URL для реального запроса: абсолютный, без hash, без "улучшений"
-  function urlForRequest(url) {
+  // v1.0.12: объединённая функция — парсим URL один раз вместо двух
+  // Возвращает { requestUrl, key } для preload()
+  function parseUrl(url) {
     try {
-      var u = new URL(url, location.href)
-      u.hash = ''
-      return u.href
+      var u = new URL(url, location.href);
+      var key = u.origin + u.pathname + u.search;
+      u.hash = '';
+      return { requestUrl: u.href, key: key }
     } catch (e) {
-      return url
+      return { requestUrl: url, key: url }
     }
   }
 
@@ -458,171 +516,470 @@ function createPrefetch(importMetaUrl) {
   }
 
   function preload(url, a) {
+    if (disabled) return
     if (!isNetworkOk()) return
 
-    var requestUrl = urlForRequest(url)
-    var key = urlKey(requestUrl)
+    // v1.0.12: парсим URL один раз вместо двух
+    var parsed = parseUrl(url);
+    var requestUrl = parsed.requestUrl;
+    var key = parsed.key;
 
     if (preloaded.has(key)) return
     if (preloaded.size >= maxPreloads) {
-      preloaded.delete(preloaded.values().next().value)
+      preloaded.delete(preloaded.values().next().value);
     }
-    preloaded.add(key)
+    preloaded.add(key);
 
-    var mode = resolveSpecMode(a)
+    var mode = resolveSpecMode(a);
 
+    // v1.0.11: in-flight лимит — ставим в очередь если превышен
+    if (inFlight >= maxInFlight) {
+      // v1.0.11: лимит очереди — отбрасываем новые при переполнении
+      // v1.0.11: при drop удаляем ключ (иначе URL "навсегда" считается прогретым)
+      if (queue.length >= maxQueue) { preloaded.delete(key); return }
+      queue.push({ url: requestUrl, key: key, mode: mode });
+      return
+    }
+
+    doPreload(requestUrl, key, mode);
+  }
+
+  function doPreload(requestUrl, key, mode) {
     if (mode !== 'none') {
-      preloadSpec(requestUrl, mode)
+      // v1.0.11: try/catch для preloadSpec — при строгом CSP/Trusted Types может выбросить исключение
+      var specOk = false;
+      try {
+        preloadSpec(requestUrl, mode);
+        specOk = true;
+      } catch (e) {
+        // Ошибка в Speculation Rules — fallback обязателен
+      }
 
-      // Страховка: обычный prefetch (чтобы под CSP/ограничениями SpecRules всё равно грелся кэш)
-      if (isIOS || !supportsLinkPrefetch) preloadFetch(requestUrl, key)
-      else preloadLink(requestUrl, key)
+      // v1.0.11: fallback только если явно включён ИЛИ если SpecRules не удался
+      // По умолчанию fallback отключён для избежания двойного трафика
+      if (specRulesFallback || !specOk) {
+        if (isIOS || !supportsLinkPrefetch) preloadFetch(requestUrl, key);
+        else preloadLink(requestUrl, key);
+      }
       return
     }
 
-    if (isIOS || !supportsLinkPrefetch) preloadFetch(requestUrl, key)
-    else preloadLink(requestUrl, key)
+    if (isIOS || !supportsLinkPrefetch) preloadFetch(requestUrl, key);
+    else preloadLink(requestUrl, key);
+  }
+
+  function processQueue() {
+    while (queue.length > 0 && inFlight < maxInFlight) {
+      var item = queue.shift();
+      doPreload(item.url, item.key, item.mode);
+    }
   }
 
   function preloadSpec(url, mode) {
-    var head = document.head
+    // v1.0.13: для cross-origin проверяем и модифицируем правила
+    var isCrossOrigin = false;
+    try {
+      var u = new URL(url, location.href);
+      isCrossOrigin = u.origin !== location.origin;
+    } catch (e) {}
+
+    // v1.0.13: для cross-origin никогда не делаем prerender (только prefetch)
+    if (isCrossOrigin && mode === 'prerender') {
+      mode = 'prefetch';
+    }
+
+    // v1.0.13: буферизуем URL — вставляем одним JSON за idle tick
+    if (isCrossOrigin) {
+      specBuffer.crossOrigin.push(url);
+    } else if (mode === 'prerender') {
+      specBuffer.prerender.push(url);
+    } else {
+      specBuffer.prefetch.push(url);
+    }
+
+    // Планируем flush если ещё не запланирован
+    if (!specFlushTimer) {
+      var rIC = window.requestIdleCallback || function (cb) { setTimeout(cb, 1); };
+      specFlushTimer = rIC(flushSpecBuffer, { timeout: 50 });
+    }
+  }
+
+  // v1.0.13: вставляем все накопленные URL одним JSON
+  function flushSpecBuffer() {
+    specFlushTimer = 0;
+
+    // v1.0.13: проверяем disabled (flush может быть вызван после destroy())
+    if (disabled) return
+
+    var head = document.head;
     if (!head) return
 
-    var s = document.createElement('script')
-    s.type = 'speculationrules'
-    if (scriptNonce) s.nonce = scriptNonce
+    var rules = {};
 
-    var rules = {}
-    rules[mode] = [{ source: 'list', urls: [url] }]
-    s.textContent = JSON.stringify(rules)
-    head.appendChild(s)
+    // Same-origin prefetch
+    if (specBuffer.prefetch.length > 0) {
+      rules.prefetch = rules.prefetch || [];
+      rules.prefetch.push({ source: 'list', urls: specBuffer.prefetch.slice() });
+      specBuffer.prefetch.length = 0;
+    }
+
+    // Same-origin prerender
+    if (specBuffer.prerender.length > 0) {
+      rules.prerender = rules.prerender || [];
+      rules.prerender.push({ source: 'list', urls: specBuffer.prerender.slice() });
+      specBuffer.prerender.length = 0;
+    }
+
+    // Cross-origin (только prefetch, с privacy requirements)
+    if (specBuffer.crossOrigin.length > 0) {
+      rules.prefetch = rules.prefetch || [];
+      rules.prefetch.push({
+        source: 'list',
+        urls: specBuffer.crossOrigin.slice(),
+        referrer_policy: 'no-referrer',
+        requires: ['anonymous-client-ip-when-cross-origin']
+      });
+      specBuffer.crossOrigin.length = 0;
+    }
+
+    // Если нет правил — выходим
+    if (!rules.prefetch && !rules.prerender) return
+
+    var s = document.createElement('script');
+    s.type = 'speculationrules';
+    if (scriptNonce) s.nonce = scriptNonce;
+    s.textContent = JSON.stringify(rules);
+    head.appendChild(s);
+    // v1.0.11: удаляем после вставки — браузер применяет правила на appendChild
+    head.removeChild(s);
   }
 
   function preloadLink(url, key) {
-    var head = document.head
+    var head = document.head;
     // v1.0.10: если head недоступен, откатываем ключ
     if (!head) { preloaded.delete(key); return }
 
-    var l = document.createElement('link')
-    l.rel = 'prefetch'
-    l.href = url
-    l.as = 'document'
-    try { l.fetchPriority = 'low' } catch (e) {}
+    inFlight++;
+
+    var l = document.createElement('link');
+    l.rel = 'prefetch';
+    l.href = url;
+    l.as = 'document';
+    try { l.fetchPriority = 'low'; } catch (e) {}
+
+    // v1.0.11: для cross-origin: referrerPolicy + crossOrigin
+    try {
+      var u = new URL(url, location.href);
+      if (u.origin !== location.origin) {
+        l.referrerPolicy = 'no-referrer';
+        l.crossOrigin = 'anonymous'; // не отправлять cookies на внешние домены
+      }
+    } catch (e) {}
+
+    // v1.0.13: safety timeout — предохранитель если onload/onerror не сработают
+    // (экзотические браузеры, сетевые ошибки без событий)
+    var safetyTimer = setTimeout(function () {
+      safetyTimer = 0;
+      // v1.0.13: при safety timeout считаем попытку неуспешной — удаляем key
+      preloaded.delete(key);
+      cleanup();
+    }, 30000);
 
-    // v1.0.9: удаляем link после загрузки, чтобы не раздувать DOM
     function cleanup() {
-      l.onload = l.onerror = null
-      if (l.parentNode) l.parentNode.removeChild(l)
+      if (safetyTimer) { clearTimeout(safetyTimer); safetyTimer = 0; }
+      l.onload = l.onerror = null;
+      if (l.parentNode) l.parentNode.removeChild(l);
+      inFlight--;
+      processQueue();
     }
 
-    l.onload = cleanup
-    l.onerror = function () { preloaded.delete(key); cleanup() }
-    head.appendChild(l)
+    l.onload = cleanup;
+    l.onerror = function () { preloaded.delete(key); cleanup(); };
+    head.appendChild(l);
   }
 
   function preloadFetch(url, key) {
     // v1.0.10: если fetch недоступен, откатываем ключ
     if (typeof fetch !== 'function') { preloaded.delete(key); return }
 
-    var ctrl = null
-    var tid = 0
+    inFlight++;
+
+    // v1.0.11: settled флаг — защита от двойного вызова done() при abort+catch
+    var settled = false;
+    var ctrl = null;
+    var tid = 0;
+
+    function done(success) {
+      if (settled) return
+      settled = true;
+
+      if (tid) clearTimeout(tid);
+      // v1.0.13: удаляем контроллер из активных
+      if (ctrl) activeControllers.delete(ctrl);
+      if (!success) preloaded.delete(key);
+      inFlight--;
+      processQueue();
+    }
 
     if (typeof AbortController !== 'undefined') {
-      ctrl = new AbortController()
+      ctrl = new AbortController();
+      // v1.0.13: добавляем в Set для возможности abort при destroy()
+      activeControllers.add(ctrl);
       tid = setTimeout(function () {
-        try { ctrl.abort() } catch (e) {}
-      }, 5000)
+        try { ctrl.abort(); } catch (e) {}
+        done(false);
+      }, 5000);
     }
 
+    // v1.0.13: определяем cross-origin для корректных настроек fetch
+    var isCrossOrigin = false;
+    try {
+      isCrossOrigin = new URL(url, location.href).origin !== location.origin;
+    } catch (e) {}
+
     var opts = {
       method: 'GET',
-      credentials: 'same-origin',
       cache: 'force-cache',
-      headers: { Purpose: 'prefetch' }
+      // v1.0.13: для cross-origin: omit credentials, no-referrer (избегаем CORS preflight и утечки referrer)
+      credentials: isCrossOrigin ? 'omit' : 'same-origin',
+      // v1.1.1: для cross-origin используем no-cors mode (opaque response, но кэш прогревается)
+      mode: isCrossOrigin ? 'no-cors' : 'cors'
+    };
+
+    // v1.1.1: headers только для same-origin (no-cors не позволяет кастомные headers)
+    if (!isCrossOrigin) {
+      opts.headers = {
+        Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+        Purpose: 'prefetch'
+      };
     }
-    if (ctrl) opts.signal = ctrl.signal
+
+    // v1.0.13: referrerPolicy для cross-origin (приватность)
+    if (isCrossOrigin) {
+      opts.referrerPolicy = 'no-referrer';
+    }
+
+    if (ctrl) opts.signal = ctrl.signal;
 
     try {
       fetch(url, opts)
         .then(function (r) {
-          if (tid) clearTimeout(tid)
-          if (!r || !r.ok) preloaded.delete(key)
+          // v1.1.1: для no-cors mode response.type === 'opaque', r.ok === false, но кэш прогрет
+          // v1.0.12: 304 Not Modified тоже считаем успехом
+          done(r && (r.ok || r.status === 304 || r.type === 'opaque'));
         })
         .catch(function () {
-          if (tid) clearTimeout(tid)
-          preloaded.delete(key)
-        })
+          done(false);
+        });
     } catch (e) {
-      if (tid) clearTimeout(tid)
-      preloaded.delete(key)
+      done(false);
     }
   }
 
   // Viewport Observer
-  var vpObserver = null
+  var vpObserver = null;
 
   function startViewportObserver() {
+    // v1.0.11: защита от вызова после destroy()
+    if (disabled) return
     if (vpObserver) return
     vpObserver = new IntersectionObserver(
       function (entries) {
         entries.forEach(function (entry) {
           if (entry.isIntersecting) {
-            vpObserver.unobserve(entry.target)
-            if (canPreload(entry.target)) preload(entry.target.href, entry.target)
+            vpObserver.unobserve(entry.target);
+            if (canPreload(entry.target)) preload(entry.target.href, entry.target);
           }
-        })
+        });
       },
       { rootMargin: isMobile ? '100px' : '200px' }
-    )
-    observeLinks()
+    );
+    observeLinks();
   }
 
   function observeLinks() {
     if (!vpObserver) return
     document.querySelectorAll('a').forEach(function (a) {
-      if (canPreload(a)) vpObserver.observe(a)
-    })
+      if (canPreload(a)) vpObserver.observe(a);
+    });
   }
 
   // Mutation Observer
-  var mutObserver = null
-  var mutTimer = null
+  var mutObserver = null;
+  var mutTimer = null;
 
   function startMutationObserver() {
+    // v1.0.11: защита от вызова после destroy()
+    if (disabled) return
     if (mutObserver) return
     mutObserver = new MutationObserver(function (muts) {
-      var hasLinks = muts.some(function (m) {
-        return Array.from(m.addedNodes).some(function (n) {
-          return (
-            n.nodeType === 1 &&
-            (n.tagName === 'A' || (n.querySelectorAll && n.querySelectorAll('a').length))
-          )
-        })
-      })
+      // v1.0.13: оптимизация — обычный цикл вместо Array.from + querySelector вместо querySelectorAll
+      var hasLinks = false;
+      outer: for (var i = 0; i < muts.length; i++) {
+        var nodes = muts[i].addedNodes;
+        for (var j = 0; j < nodes.length; j++) {
+          var n = nodes[j];
+          if (n.nodeType === 1) {
+            if (n.tagName === 'A' || (n.querySelector && n.querySelector('a'))) {
+              hasLinks = true;
+              break outer
+            }
+          }
+        }
+      }
       if (hasLinks && vpObserver) {
-        clearTimeout(mutTimer)
-        mutTimer = setTimeout(observeLinks, 100)
+        clearTimeout(mutTimer);
+        mutTimer = setTimeout(observeLinks, 100);
       }
-    })
-    mutObserver.observe(document.body, { childList: true, subtree: true })
+    });
+    mutObserver.observe(document.body, { childList: true, subtree: true });
+  }
+
+  // v1.0.11: валидация URL для публичного API (усилена)
+  function isValidPrefetchUrl(url) {
+    if (!url || typeof url !== 'string') return false
+    url = url.trim(); // v1.0.11: trim для защиты от ' javascript:...'
+    if (!url) return false
+    // v1.0.11: блокируем protocol-relative URLs (//evil.com)
+    if (/^\/\//.test(url)) return false
+    // Блокируем опасные протоколы
+    if (/^(javascript|data|vbscript|file):/i.test(url)) return false
+    // Разрешаем только http(s) или относительные URL
+    if (!/^https?:\/\//i.test(url) && !/^\//.test(url) && !/^\./.test(url)) {
+      // Проверяем, что это не протокол
+      if (/^[a-z][a-z0-9+.-]*:/i.test(url)) return false
+    }
+    return true
+  }
+
+  // v1.0.11: destroy() — отключает библиотеку, снимает обработчики
+  function destroy() {
+    disabled = true;
+    queue.length = 0;
+
+    // v1.0.13: очищаем touch-таймер
+    if (touchTimer) {
+      clearTimeout(touchTimer);
+      touchTimer = 0;
+    }
+
+    // v1.0.13: удаляем touchCancel listener если есть
+    if (touchCancel) {
+      document.removeEventListener('touchmove', touchCancel, true);
+      document.removeEventListener('scroll', touchCancel, true);
+      touchCancel = null;
+    }
+
+    // v1.0.13: прерываем все активные fetch-запросы
+    activeControllers.forEach(function (ctrl) {
+      try { ctrl.abort(); } catch (e) {}
+    });
+    activeControllers.clear();
+
+    // v1.0.13: отменяем отложенный flush Speculation Rules
+    if (specFlushTimer) {
+      var cancelIC = window.cancelIdleCallback || clearTimeout;
+      cancelIC(specFlushTimer);
+      specFlushTimer = 0;
+    }
+    // Очищаем буфер
+    specBuffer.prefetch.length = specBuffer.prerender.length = specBuffer.crossOrigin.length = 0;
+
+    var opts = { capture: true, passive: true };
+    document.removeEventListener('touchstart', onTouchStart, opts);
+    document.removeEventListener('mouseover', onMouseOver, opts);
+    document.removeEventListener('mousedown', onMouseDown, opts);
+
+    // v1.0.11: снимаем слушатели навигации
+    window.removeEventListener('popstate', updateCurrentKey);
+    window.removeEventListener('hashchange', updateCurrentKey);
+    // v1.0.12: снимаем pageshow listener
+    window.removeEventListener('pageshow', onPageShow);
+
+    if (vpObserver) {
+      vpObserver.disconnect();
+      vpObserver = null;
+    }
+    if (mutObserver) {
+      mutObserver.disconnect();
+      mutObserver = null;
+    }
   }
 
-  // Минимальный публичный API
+  // Публичный API
   var api = {
     __prefetchRu: true,
-    version: '1.0.10',
-    preload: function (url) { preload(url) }
-  }
+    version: '1.1.1',
+    preload: function (url) {
+      // v1.0.11: валидация URL + прогон через canPreload() (консистентность с авто-режимом)
+      if (!isValidPrefetchUrl(url)) return
+      // v1.0.11: создаём временный <a> для проверки через canPreload()
+      var a = document.createElement('a');
+      a.setAttribute('href', url.trim());
+      if (!canPreload(a)) return
+      preload(a.href, a);
+    },
+    destroy: destroy,
+    // v1.0.11: публичный метод для ручного обновления currentKey (SPA)
+    refresh: updateCurrentKey
+  };
 
-  window.Prefetch = api
   return api
 }
 
-// v1.0.9: Guard от двойной инициализации (проверяем маркер __prefetchRu)
+/**
+ * ESM entry point for prefetch.ru
+ * This file is bundled into prefetch.esm.js
+ */
+
+/**
+ * Detect CSP nonce from the script tag that loaded this module.
+ * ESM modules don't have document.currentScript, so we find by import.meta.url
+ */
+function detectNonceFromImportMeta(metaUrl) {
+  try {
+    if (!metaUrl) return null
+    // script.src и import.meta.url обычно оба абсолютные → можно сравнивать напрямую
+    var scripts = document.getElementsByTagName('script');
+    for (var i = 0; i < scripts.length; i++) {
+      var s = scripts[i];
+      if (!s || !s.src) continue
+      if (s.src === metaUrl) {
+        var n = s.nonce || s.getAttribute('nonce') || null;
+        if (n) return n
+        break
+      }
+    }
+  } catch (e) {}
+  return null
+}
+
+// Guard от двойной инициализации
 var Prefetch =
-  (typeof window !== 'undefined' && window.Prefetch && window.Prefetch.__prefetchRu)
-    ? window.Prefetch
-    : createPrefetch(import.meta.url)
+  (typeof window !== 'undefined' && window.PrefetchRu && window.PrefetchRu.__prefetchRu)
+    ? window.PrefetchRu
+    : (typeof window !== 'undefined' && window.Prefetch && window.Prefetch.__prefetchRu)
+      ? window.Prefetch
+      : createPrefetchCore({
+          isBrowser: typeof window !== 'undefined',
+          getNonce: function () {
+            // ESM: nonce через import.meta.url
+            var nonce = detectNonceFromImportMeta(import.meta.url);
+            if (nonce) return nonce
+
+            // fallback: на случай окружений, где currentScript всё же доступен
+            try {
+              var cs = document.currentScript;
+              if (cs && cs.nonce) return cs.nonce
+            } catch (e) {}
+            return null
+          }
+        });
+
+// Регистрируем в window (для совместимости)
+if (typeof window !== 'undefined') {
+  window.PrefetchRu = Prefetch;
+  if (!window.Prefetch) window.Prefetch = Prefetch;
+}
 
-export { Prefetch }
-export default Prefetch
+export { Prefetch, Prefetch as default };