Read the code before you install it.

macOS / Linux   shasum -a 256 auto-year-free/js/auto-year.js
Windows         certutil -hashfile auto-year-free\js\auto-year.js SHA256

grep -nE "fetch|XMLHttpRequest|sendBeacon|localStorage|sessionStorage|document\.cookie|innerHTML|eval\(|new Function|createElement" auto-year.js

/*!
 * YearAlert — standalone (no-backend) copyright-year updater.
 *
 * Drop-in <script> for any site (verified live on Tilda, nosandson.com): keeps the
 * copyright year fresh client-side with ZERO server calls and ZERO content edits.
 *
 * Rule: a 4-digit in-range year is updated to the current year only if it is either
 *   (a) in a COPYRIGHT context  — same text carries ©, "copyright" or "(c)", OR
 *   (b) in the BOTTOM BAND       — its element sits in the lowest `BAND` of the page
 *       (footers live at the bottom; mid-page years like "CROC 2020" are left alone).
 * Ranges (2019–2024) update only the END year, and only when the range really is one —
 * a phone written "3613-2018" is not. Nothing is rewritten when another group of digits
 * sits right beside the candidate: a footer's phone number is not a copyright year, and
 * breaking one on a customer's live site is worse than leaving a year stale (T-018).
 * Idempotent (never re-touches the current year). Opt-out: add data-ayu-ignore to any
 * element to exclude its subtree.
 *
 * Wrapped so it can NEVER throw into the host page. Tilda and other builders inject
 * footer blocks asynchronously, so we re-run on a short interval after first paint.
 */
(function () {
  'use strict';

  var MIN_YEAR = 1990;
  var DASH = '[\\-\\u2013\\u2014]'; // hyphen, en dash, em dash
  var BAND = 0.85;                  // bottom 15% of the page counts as "footer zone"
  var COPY = '©';
  // What may sit between two groups of a phone number. Deliberately NOT '.' or ',':
  // "Copyright 2019. 123 Main St" is a sentence stop and a street number, not a dial code.
  var PHONE_SEP = '[\\s\\u00a0\\-\\u2013\\u2014()/]';
  var SEP_BEFORE = new RegExp('\\d' + PHONE_SEP + '{0,2}$');
  var SEP_AFTER = new RegExp('^' + PHONE_SEP + '{0,2}\\d');

  function inRange(y, cur) { return y >= MIN_YEAR && y <= cur; }

  function hasCopyright(text) {
    if (!text) return false;
    var t = text.toLowerCase();
    return t.indexOf(COPY) !== -1 || t.indexOf('copyright') !== -1 || t.indexOf('(c)') !== -1;
  }

  /*
   * A 4-digit group with ANOTHER group of digits right beside it belongs to a phone
   * number, not to a copyright: "Llámanos: 33 3613 2018". The digit-run gate below only
   * protects digits welded into one run (ИНН, ОГРН) — a phone is written in groups, so
   * every other gate lets it through, and a footer carrying both a phone and a © is the
   * normal case in our market (see GO-TO-MARKET).
   *
   * The lead scanner hit the same bug from the other side and fixed it the same way
   * (`isPhoneFragment` in crm/server/src/checks/_year-detect.js). There a false positive
   * cost us one bad lead; here it rewrites a paying customer's phone number on their own
   * live site, silently. So this errs toward doing nothing: a year we skip is visible and
   * recoverable, a phone we break is neither.
   *
   * `start`/`end` bracket the candidate inside `text`.
   */
  function isPhoneFragment(text, start, end) {
    return SEP_BEFORE.test(text.slice(Math.max(0, start - 14), start))
        || SEP_AFTER.test(text.slice(end, end + 14));
  }

  // A dash between two 4-digit groups is only a year range when the FIRST group is itself
  // a plausible year — a copyright cannot begin in the future. That is what separates
  // "© 2019–2024" from "3613-2018", which the range path used to rewrite to "3613-2026".
  // Below MIN_YEAR the text must actually say copyright: "© 1985–2024" is a real footer,
  // a bare "1234-2018" is a phone number.
  function isYearRange(text, whole, first, index, cur) {
    var start = parseInt(first, 10);
    if (start > cur) return false;
    if (start < MIN_YEAR && !hasCopyright(text)) return false;
    return !isPhoneFragment(text, index, index + whole.length);
  }

  // True if the node's element sits within the bottom BAND of the document.
  function isBottom(node) {
    var el = node.parentElement;
    if (!el || !el.getBoundingClientRect) return false;
    var r = el.getBoundingClientRect();
    var absTop = r.top + (window.pageYOffset || window.scrollY || 0);
    var docH = document.documentElement.scrollHeight;
    return docH > 0 && absTop >= docH * BAND;
  }

  function isIgnored(node) {
    var el = node.parentElement;
    if (!el || !el.closest) return false;
    try { return !!el.closest('[data-ayu-ignore]'); } catch (e) { return false; }
  }

  // Core text-node transform. Exported for tests. `opts` lets tests force the gate
  // (copyright / bottom) without a real layout: { context: <string>, atBottom: <bool> }.
  function fixTextValue(text, cur, gateOpen) {
    if (!text || !/\d{4}/.test(text)) return { text: text, changed: false };
    if (!gateOpen) return { text: text, changed: false };
    var cy = String(cur);
    var changed = false;
    var rangeSrc = '(\\d{4})(\\s*' + DASH + '\\s*)(\\d{4})';

    // Does the text hold a range that is genuinely a range? A dash-separated phone is not
    // one, and must not send us down the range path — that path skips single years, so a
    // rejected phone would otherwise shadow the real copyright later in the same node.
    var scan = new RegExp(rangeSrc, 'g');
    var hit;
    var hasYearRange = false;
    while ((hit = scan.exec(text))) {
      if (isYearRange(text, hit[0], hit[1], hit.index, cur)) { hasYearRange = true; break; }
    }

    if (hasYearRange) {
      text = text.replace(new RegExp(rangeSrc, 'g'), function (m, a, s, b, offset, whole) {
        if (!isYearRange(whole, m, a, offset, cur)) return m;
        var e = parseInt(b, 10);
        if (inRange(e, cur) && e !== cur) { changed = true; return a + s + cy; }
        return m;
      });
    } else {
      // Single year. Require non-digit (or string edge) on BOTH sides so a 4-digit run
      // inside a longer number — Russian ИНН/ОГРН, phone, etc., which frequently share the
      // copyright text node — is never rewritten. No lookbehind (universal browser support).
      text = text.replace(/(\D|^)(\d{4})(?!\d)/g, function (m, pre, y, offset, whole) {
        var n = parseInt(y, 10);
        if (!inRange(n, cur) || n === cur) return m;
        var at = offset + pre.length;
        if (isPhoneFragment(whole, at, at + 4)) return m;
        changed = true;
        return pre + cy;
      });
    }
    return { text: text, changed: changed };
  }

  function fixNode(node, cur) {
    var raw = node.nodeValue;
    if (!raw || !/\d{4}/.test(raw)) return;
    if (isIgnored(node)) return;
    var ctx = raw + ' ' + (node.parentNode ? node.parentNode.textContent : '');
    var gateOpen = hasCopyright(ctx) || isBottom(node);
    var res = fixTextValue(raw, cur, gateOpen);
    if (res.changed) node.nodeValue = res.text;
  }

  function replaceYears(cur) {
    cur = cur || new Date().getFullYear();
    if (typeof document === 'undefined' || !document.body) return;
    var walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT, {
      acceptNode: function (nd) {
        var p = nd.parentNode;
        var tg = p && p.nodeName ? p.nodeName.toLowerCase() : '';
        return (tg === 'script' || tg === 'style')
          ? NodeFilter.FILTER_REJECT
          : NodeFilter.FILTER_ACCEPT;
      }
    }, false);
    var nd;
    while ((nd = walker.nextNode())) fixNode(nd, cur);
  }

  function run() { try { replaceYears(); } catch (e) { /* never throw into host */ } }

  // Re-run for ~10s: builder-injected footers (Tilda, etc.) appear after first paint.
  function boot() {
    run();
    var i = 0;
    var iv = setInterval(function () { run(); if (++i > 40) clearInterval(iv); }, 250);
  }

  // Browser auto-boot.
  try {
    if (typeof document !== 'undefined') {
      if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', boot);
      } else {
        boot();
      }
    }
  } catch (e) { /* ignore */ }

  // Node/test surface.
  if (typeof module !== 'undefined' && module.exports) {
    module.exports = { fixTextValue: fixTextValue, hasCopyright: hasCopyright, inRange: inRange, MIN_YEAR: MIN_YEAR, BAND: BAND };
  }
})();