extract-webpage 1.2.35 → 1.2.37

package/src/html-to-cite/extract-date/extract-date.ts

@@ -1,1049 +1,1049 @@
-/**
- * @fileoverview Comprehensive date extraction orchestrator for HTML documents.
- * Integrates pattern searching, JSON-LD parsing, and image metadata analysis.
- */
-import {
-  discard_unwanted,
-  extract_url_date,
-  idiosyncrasies_search,
-  img_search,
-  json_search,
-  regex_parse,
-  pattern_search,
-  try_date_expr,
-  DATE_EXPRESSIONS,
-  FAST_PREPEND,
-  SLOW_PREPEND,
-  FREE_TEXT_EXPRESSIONS,
-  MAX_SEGMENT_LEN,
-  MIN_SEGMENT_LEN,
-  YEAR_PATTERN,
-  YMD_PATTERN,
-  COPYRIGHT_PATTERN,
-  TIMESTAMP_PATTERN,
-  THREE_PATTERN,
-  THREE_CATCH,
-  THREE_LOOSE_PATTERN,
-  THREE_LOOSE_CATCH,
-  SELECT_YMD_PATTERN,
-  SELECT_YMD_YEAR,
-  YMD_YEAR,
-  DATESTRINGS_PATTERN,
-  DATESTRINGS_CATCH,
-  SLASHES_PATTERN,
-  SLASHES_YEAR,
-  YYYYMM_PATTERN,
-  YYYYMM_CATCH,
-  MMYYYY_PATTERN,
-  MMYYYY_YEAR,
-  SIMPLE_PATTERN,
-  THREE_COMP_REGEX_A,
-  THREE_COMP_REGEX_B,
-  TWO_COMP_REGEX,
-} from "./date-extractors";
-
-import {
-  check_extracted_reference,
-  compare_values,
-  filter_ymd_candidate,
-  get_min_date,
-  get_max_date,
-  is_valid_date,
-  is_valid_format,
-  plausible_year_filter,
-  convert_date,
-} from "./date-validators";
-
-/**
- * Format a date object into the desired output format
- */
-function format_date(date: Date, format: string): string {
-  return convert_date(date, "YYYY-MM-DD", format);
-}
-
-// Global debug flag
-let DEBUG = false;
-const LOGGER = {
-  debug: (...args) => DEBUG && console.log(...args),
-  warn: (...args) => DEBUG && console.warn(...args),
-  error: (...args) => console.error(...args),
-};
-
-var MAX_POSSIBLE_CANDIDATES = 1000;
-
-var CLEANING_LIST = [
-  "applet",
-  "audio",
-  "canvas",
-  "datalist",
-  "embed",
-  "frame",
-  "frameset",
-  "iframe",
-  "label",
-  "map",
-  "math",
-  "noframes",
-  "object",
-  "picture",
-  "rdf",
-  "svg",
-  "track",
-  "video",
-];
-
-// Date-related meta tag attributes
-const DATE_ATTRIBUTES = new Set([
-  "analyticsattributes.articledate",
-  "article.created",
-  "article_date_original",
-  "article:post_date",
-  "article.published",
-  "article:published",
-  "article:published_date",
-  "article:published_time",
-  "article:publicationdate",
-  "bt:pubdate",
-  "citation_date",
-  "citation_publication_date",
-  "content_create_date",
-  "created",
-  "cxenseparse:recs:publishtime",
-  "date",
-  "date_created",
-  "date_published",
-  "datecreated",
-  "dateposted",
-  "datepublished",
-  // Dublin Core
-  "dc.date",
-  "dc.created",
-  "dc.date.created",
-  "dc.date.issued",
-  "dc.date.publication",
-  "dcsext.articlefirstpublished",
-  "dcterms.created",
-  "dcterms.date",
-  "dcterms.issued",
-  "dc:created",
-  "dc:date",
-  "displaydate",
-  "doc_date",
-  "field-name-post-date",
-  "gentime",
-  "mediator_published_time",
-  "meta",
-  // Open Graph
-  "og:article:published",
-  "og:article:published_time",
-  "og:datepublished",
-  "og:pubdate",
-  "og:publish_date",
-  "og:published_time",
-  "og:question:published_time",
-  "og:regdate",
-  "originalpublicationdate",
-  "parsely-pub-date",
-  "pdate",
-  "ptime",
-  "pubdate",
-  "publishdate",
-  "publish_date",
-  "publish_time",
-  "publish-date",
-  "published-date",
-  "published_date",
-  "published_time",
-  "publisheddate",
-  "publication_date",
-  "rbpubdate",
-  "release_date",
-  "rnews:datepublished",
-  "sailthru.date",
-  "shareaholic:article_published_time",
-  "timestamp",
-  "twt-published-at",
-  "video:release_date",
-  "vr:published_time",
-]);
-
-// Modified date attributes
-const NAME_MODIFIED = new Set([
-  "lastdate",
-  "lastmod",
-  "lastmodified",
-  "last-modified",
-  "modified",
-  "utime",
-]);
-
-// Property modified attributes
-const PROPERTY_MODIFIED = new Set([
-  "article:modified",
-  "article:modified_date",
-  "article:modified_time",
-  "article:post_modified",
-  "bt:moddate",
-  "datemodified",
-  "dc.modified",
-  "dcterms.modified",
-  "lastmodified",
-  "modified_time",
-  "modificationdate",
-  "og:article:modified_time",
-  "og:modified_time",
-  "og:updated_time",
-  "release_date",
-  "revision_date",
-  "updated_time",
-]);
-
-// ItemProp attributes
-const ITEMPROP_ATTRS_ORIGINAL = new Set([
-  "datecreated",
-  "datepublished",
-  "pubyear",
-]);
-
-const ITEMPROP_ATTRS_MODIFIED = new Set(["datemodified", "dateupdate"]);
-
-// Combine ItemProp sets
-const ITEMPROP_ATTRS = new Set([
-  ...ITEMPROP_ATTRS_ORIGINAL,
-  ...ITEMPROP_ATTRS_MODIFIED,
-]);
-
-// Class attributes
-const CLASS_ATTRS = new Set(["date-published", "published", "time published"]);
-
-// Regular expressions
-const NON_DIGITS_REGEX = /\D+$/;
-
-// Note: THREE_PATTERN and THREE_CATCH would need to be defined
-const THREE_COMP_PATTERNS = [
-  [THREE_PATTERN, THREE_CATCH],
-  [THREE_LOOSE_PATTERN, THREE_LOOSE_CATCH],
-];
-
-// Export all constants
-export {
-  DATE_ATTRIBUTES,
-  NAME_MODIFIED,
-  PROPERTY_MODIFIED,
-  ITEMPROP_ATTRS_ORIGINAL,
-  ITEMPROP_ATTRS_MODIFIED,
-  ITEMPROP_ATTRS,
-  CLASS_ATTRS,
-  NON_DIGITS_REGEX,
-  // THREE_COMP_PATTERNS // Uncomment once patterns are defined
-};
-
-function examine_text(text, options) {
-  if (text.length <= MIN_SEGMENT_LEN) {
-    return null;
-  }
-
-  text = text.slice(0, MAX_SEGMENT_LEN).replace(NON_DIGITS_REGEX, "");
-  return try_date_expr(
-    text,
-    options.format,
-    options.extensive,
-    options.min,
-    options.max
-  );
-}
-
-function examine_date_elements(tree, expression, options) {
-  const elements = tree.querySelectorAll(expression);
-  if (!elements || elements.length > MAX_POSSIBLE_CANDIDATES) {
-    return null;
-  }
-
-  for (const elem of elements) {
-    for (const text of [elem.textContent, elem.getAttribute("title") || ""]) {
-      const attempt = examine_text(text, options);
-      if (attempt) {
-        return attempt;
-      }
-    }
-  }
-
-  return null;
-}
-
-function examine_header(tree, options) {
-  let headerdate = null;
-  let reserve = null;
-  const tryfunc = (content) =>
-    try_date_expr(
-      content,
-      options.format,
-      options.extensive,
-      options.min,
-      options.max
-    );
-
-  for (const elem of tree.querySelectorAll("meta")) {
-    if (
-      !elem.attributes.length ||
-      (!elem.getAttribute("content") && !elem.getAttribute("datetime"))
-    ) {
-      continue;
-    }
-
-    if (elem.hasAttribute("name")) {
-      const attribute = elem.getAttribute("name")?.toLowerCase();
-      if (attribute === "og:url") {
-        reserve = extract_url_date(elem.getAttribute("content"), options);
-      } else if (DATE_ATTRIBUTES.has(attribute)) {
-        LOGGER.debug(`examining meta name: ${elem.outerHTML}`);
-        headerdate = tryfunc(elem.getAttribute("content"));
-      } else if (NAME_MODIFIED.has(attribute)) {
-        LOGGER.debug(`examining meta name: ${elem.outerHTML}`);
-        if (!options.original) {
-          headerdate = tryfunc(elem.getAttribute("content"));
-        } else {
-          reserve = tryfunc(elem.getAttribute("content"));
-        }
-      }
-    } else if (elem.hasAttribute("property")) {
-      const attribute = elem.getAttribute("property").toLowerCase();
-      if (DATE_ATTRIBUTES.has(attribute) || PROPERTY_MODIFIED.has(attribute)) {
-        LOGGER.debug(`examining meta property: ${elem.outerHTML}`);
-        const attempt = tryfunc(elem.getAttribute("content"));
-        if (attempt !== null) {
-          if (
-            (DATE_ATTRIBUTES.has(attribute) && options.original) ||
-            (PROPERTY_MODIFIED.has(attribute) && !options.original)
-          ) {
-            headerdate = attempt;
-          } else {
-            reserve = attempt;
-          }
-        }
-      }
-    } else if (elem.hasAttribute("itemprop")) {
-      const attribute = elem.getAttribute("itemprop").toLowerCase();
-      if (ITEMPROP_ATTRS.has(attribute)) {
-        LOGGER.debug(`examining meta itemprop: ${elem.outerHTML}`);
-        const attempt = tryfunc(
-          elem.getAttribute("datetime") || elem.getAttribute("content")
-        );
-        if (attempt !== null) {
-          if (
-            (ITEMPROP_ATTRS_ORIGINAL.has(attribute) && options.original) ||
-            (ITEMPROP_ATTRS_MODIFIED.has(attribute) && !options.original)
-          ) {
-            headerdate = attempt;
-          }
-        }
-      } else if (attribute === "copyrightyear") {
-        LOGGER.debug(`examining meta itemprop: ${elem.outerHTML}`);
-        if (elem.hasAttribute("content")) {
-          const attempt = `${elem.getAttribute("content")}-01-01`;
-          if (is_valid_date(attempt, "%Y-%m-%d", options.min, options.max)) {
-            reserve = attempt;
-          }
-        }
-      }
-    } else if (elem.hasAttribute("pubdate")) {
-      if (elem.getAttribute("pubdate").toLowerCase() === "pubdate") {
-        LOGGER.debug(`examining meta pubdate: ${elem.outerHTML}`);
-        headerdate = tryfunc(elem.getAttribute("content"));
-      }
-    } else if (elem.hasAttribute("http-equiv")) {
-      const attribute = elem.getAttribute("http-equiv").toLowerCase();
-      if (attribute === "date") {
-        LOGGER.debug(`examining meta http-equiv: ${elem.outerHTML}`);
-        if (options.original) {
-          headerdate = tryfunc(elem.getAttribute("content"));
-        } else {
-          reserve = tryfunc(elem.getAttribute("content"));
-        }
-      } else if (attribute === "last-modified") {
-        LOGGER.debug(`examining meta http-equiv: ${elem.outerHTML}`);
-        if (!options.original) {
-          headerdate = tryfunc(elem.getAttribute("content"));
-        } else {
-          reserve = tryfunc(elem.getAttribute("content"));
-        }
-      }
-    }
-
-    if (headerdate !== null) {
-      break;
-    }
-  }
-
-  if (headerdate === null && reserve !== null) {
-    LOGGER.debug("opting for reserve date with less granularity");
-    headerdate = reserve;
-  }
-
-  return headerdate;
-}
-
-function select_candidate(occurrences, catch_regex, yearpat, options) {
-  if (!occurrences || occurrences.size > MAX_POSSIBLE_CANDIDATES) {
-    return null;
-  }
-
-  // console.log( JSON.stringify(occurrences) + " 444444444444" + occurrences + " 444444444444")
-
-  if (occurrences.size === 1) {
-    const pattern = occurrences.keys().next().value;
-    return catch_regex.exec(pattern);
-  }
-  ///if null
-  // if (occurrences.size === 0) {
-  return occurrences;
-  //todo fix
-  // }
-
-  const firstselect = Array.from(occurrences.entries())
-    .sort((a, b) => b[1] - a[1])
-    .slice(0, 10);
-  LOGGER.debug(`firstselect: ${JSON.stringify(firstselect)}`);
-
-  const bestones = firstselect
-    .sort((a, b) => (options.original ? a[1] - b[1] : b[1] - a[1]))
-    .slice(0, 2);
-  LOGGER.debug(`bestones: ${JSON.stringify(bestones)}`);
-
-  const patterns = bestones.map((item) => item[0]);
-  const counts = bestones.map((item) => item[1]);
-
-  const years = patterns
-    .map((pattern) => {
-      const year_match = yearpat.exec(pattern);
-      return year_match ? year_match[1] : null;
-    })
-    .filter((year) => year !== null);
-
-  const validation = years.map((year) =>
-    is_valid_date(
-      new Date(parseInt(year), 0, 1),
-      "%Y",
-      options.min,
-      options.max
-    )
-  );
-
-  let match = null;
-  if (validation.every((v) => v)) {
-    if (counts[0] === counts[1]) {
-      match = catch_regex.exec(patterns[0]);
-    } else if (years[1] !== years[0] && counts[1] / counts[0] > 0.5) {
-      match = catch_regex.exec(patterns[1]);
-    } else {
-      match = catch_regex.exec(patterns[0]);
-    }
-  } else if (validation.some((v) => v)) {
-    match = catch_regex.exec(patterns[validation.indexOf(true)]);
-  } else {
-    LOGGER.debug(`no suitable candidate: ${years[0]} ${years[1]}`);
-  }
-
-  return match;
-}
-
-function search_pattern(htmlstring, pattern, catch_regex, yearpat, options) {
-  const candidates = plausible_year_filter(
-    htmlstring,
-    pattern,
-    yearpat,
-    options.min,
-    options.max
-  );
-  return select_candidate(candidates, catch_regex, yearpat, options);
-}
-
-function compare_reference(reference, expression, options) {
-  const attempt = try_date_expr(
-    expression,
-    options.format,
-    options.extensive,
-    options.min,
-    options.max
-  );
-  if (attempt !== null) {
-    return compare_values(reference, attempt, options);
-  }
-  return reference;
-}
-
-function examine_abbr_elements(tree, options) {
-  const elements = tree.querySelectorAll("abbr");
-  if (elements.length > 0 && elements.length < MAX_POSSIBLE_CANDIDATES) {
-    let reference = 0;
-    for (const elem of elements) {
-      if (elem.hasAttribute("data-utime")) {
-        try {
-          const candidate = parseInt(elem.getAttribute("data-utime"));
-          LOGGER.debug(`data-utime found: ${candidate}`);
-          if (options.original && (reference === 0 || candidate < reference)) {
-            reference = candidate;
-          } else if (!options.original && candidate > reference) {
-            reference = candidate;
-          }
-        } catch (err) {
-          continue;
-        }
-      } else if (CLASS_ATTRS.has(elem.getAttribute("class"))) {
-        if (elem.hasAttribute("title")) {
-          const trytext = elem.getAttribute("title");
-          LOGGER.debug(`abbr published-title found: ${trytext}`);
-          if (options.original) {
-            const attempt = try_date_expr(
-              trytext,
-              options.format,
-              options.extensive,
-              options.min,
-              options.max
-            );
-            if (attempt !== null) {
-              return attempt;
-            }
-          } else {
-            reference = compare_reference(reference, trytext, options);
-            if (reference > 0) {
-              break;
-            }
-          }
-        } else if (elem.textContent && elem.textContent.length > 10) {
-          LOGGER.debug(`abbr published found: ${elem.textContent}`);
-          reference = compare_reference(reference, elem.textContent, options);
-        }
-      }
-    }
-    return (
-      check_extracted_reference(reference, options) ||
-      examine_date_elements(tree, "abbr", options)
-    );
-  }
-  return null;
-}
-
-function examine_time_elements(tree, options) {
-  const elements = tree.querySelectorAll("time");
-  if (elements.length > 0 && elements.length < MAX_POSSIBLE_CANDIDATES) {
-    let reference = 0;
-    for (const elem of elements) {
-      let shortcut_flag = false;
-      if (!elem || !elem.getAttribute) continue;
-
-      const datetime_attr = elem.getAttribute("datetime") || "";
-      if (datetime_attr.length > 6) {
-        if (
-          elem.hasAttribute("pubdate") &&
-          elem.getAttribute("pubdate") === "pubdate" &&
-          options.original
-        ) {
-          shortcut_flag = true;
-          LOGGER.debug(`shortcut for time pubdate found: ${datetime_attr}`);
-        } else if (elem.hasAttribute("class")) {
-          if (
-            options.original &&
-            (elem.getAttribute("class").startsWith("entry-date") ||
-              elem.getAttribute("class").startsWith("entry-time"))
-          ) {
-            shortcut_flag = true;
-            LOGGER.debug(`shortcut for time/datetime found: ${datetime_attr}`);
-          } else if (
-            !options.original &&
-            elem.getAttribute("class") === "updated"
-          ) {
-            shortcut_flag = true;
-            LOGGER.debug(
-              `shortcut for updated time/datetime found: ${datetime_attr}`
-            );
-          }
-        } else {
-          LOGGER.debug(`time/datetime found: ${datetime_attr}`);
-        }
-
-        if (shortcut_flag) {
-          const attempt = try_date_expr(
-            datetime_attr,
-            options.format,
-            options.extensive,
-            options.min,
-            options.max
-          );
-          if (attempt !== null) {
-            return attempt;
-          }
-        } else {
-          reference = compare_reference(reference, datetime_attr, options);
-        }
-      } else if (elem.textContent && elem.textContent.length > 6) {
-        LOGGER.debug(`time/datetime found in text: ${elem.textContent}`);
-        reference = compare_reference(reference, elem.textContent, options);
-      }
-    }
-    return check_extracted_reference(reference, options);
-  }
-  return null;
-}
-
-function normalize_match(match) {
-  if (!match) return null;
-  const groups = match.slice(1).filter((g) => g);
-  let [day, month, year] = groups.map((g) => g.padStart(2, "0"));
-  if (year.length === 2) {
-    year = year[0] === "9" ? `19${year}` : `20${year}`;
-  }
-  return `${year}-${month}-${day}`;
-}
-
-function search_page(htmlstring, options) {
-  LOGGER.debug("looking for copyright/footer information");
-  let copyear = 0;
-
-  let bestmatch = search_pattern(
-    htmlstring,
-    COPYRIGHT_PATTERN,
-    YEAR_PATTERN,
-    YEAR_PATTERN,
-    options
-  );
-  if (bestmatch) {
-    const year = parseInt(bestmatch[0]);
-    if (is_valid_date(new Date(year, 0, 1), "%Y", options.min, options.max)) {
-      LOGGER.debug(`copyright year/footer pattern found: ${year}`);
-      copyear = year;
-    }
-  }
-
-  LOGGER.debug("3 components");
-  for (const patterns of THREE_COMP_PATTERNS) {
-    bestmatch = search_pattern(
-      htmlstring,
-      patterns[0],
-      patterns[1],
-      YEAR_PATTERN,
-      options
-    );
-    let result = filter_ymd_candidate(
-      bestmatch,
-      patterns[0],
-      options.original,
-      copyear,
-      options.format,
-      options.min,
-      options.max
-    );
-    if (result !== null) {
-      return result;
-    }
-  }
-
-  let candidates = plausible_year_filter(
-    htmlstring,
-    SELECT_YMD_PATTERN,
-    SELECT_YMD_YEAR,
-    options.min,
-    options.max
-  );
-  let replacement = {};
-  for (const [item, count] of Object.entries(candidates)) {
-    const match = THREE_COMP_REGEX_A.exec(item);
-    if (match) {
-      const candidate = normalize_match(match);
-      replacement[candidate] = count;
-    }
-  }
-
-  bestmatch = select_candidate(
-    new Counter(replacement),
-    YMD_PATTERN,
-    YMD_YEAR,
-    options
-  );
-  let result = filter_ymd_candidate(
-    bestmatch,
-    SELECT_YMD_PATTERN,
-    options.original,
-    copyear,
-    options.format,
-    options.min,
-    options.max
-  );
-  if (result !== null) {
-    return result;
-  }
-
-  bestmatch = search_pattern(
-    htmlstring,
-    DATESTRINGS_PATTERN,
-    DATESTRINGS_CATCH,
-    YEAR_PATTERN,
-    options
-  );
-  result = filter_ymd_candidate(
-    bestmatch,
-    DATESTRINGS_PATTERN,
-    options.original,
-    copyear,
-    options.format,
-    options.min,
-    options.max
-  );
-  if (result !== null) {
-    return result;
-  }
-
-  LOGGER.debug("switching to two components");
-
-  // First option: YYYY-MM pattern
-  bestmatch = search_pattern(
-    htmlstring,
-    YYYYMM_PATTERN,
-    YYYYMM_CATCH,
-    YEAR_PATTERN,
-    options
-  );
-
-  if (bestmatch) {
-    const dateObject = new Date(
-      parseInt(bestmatch[1]),
-      parseInt(bestmatch[2]) - 1,
-      1
-    );
-    if (
-      is_valid_date(dateObject, "%Y-%m-%d", options.min, options.max) &&
-      (copyear === 0 || dateObject.getFullYear() >= copyear)
-    ) {
-      LOGGER.debug(
-        'date found for pattern "%s": %s, %s',
-        YYYYMM_PATTERN,
-        bestmatch[1],
-        bestmatch[2]
-      );
-      return format_date(dateObject, options.format);
-    }
-  }
-
-  // 2 components, second option: MM-YYYY pattern
-  candidates = plausible_year_filter(
-    htmlstring,
-    MMYYYY_PATTERN,
-    MMYYYY_YEAR,
-    options.min,
-    options.max,
-    options.original
-  );
-
-  // Revert DD-MM-YYYY patterns before sorting
-  replacement = {};
-  for (const [item, count] of Object.entries(candidates)) {
-    const match = item?.match(TWO_COMP_REGEX);
-    if (!match) continue;
-
-    let month = match[1];
-    if (month.length === 1) {
-      month = `0${month}`;
-    }
-    const candidate = `${match[2]}-${month}-01`;
-    replacement[candidate] = count;
-  }
-
-  candidates = new Counter(replacement);
-
-  // Select best candidate
-  bestmatch = select_candidate(candidates, YMD_PATTERN, YMD_YEAR, options);
-  result = filter_ymd_candidate(
-    bestmatch,
-    MMYYYY_PATTERN,
-    options.original,
-    copyear,
-    options.format,
-    options.min,
-    options.max
-  );
-
-  if (result !== null) {
-    return result;
-  }
-
-  // Try full-blown text regex on all HTML
-  const dateObject = regex_parse(htmlstring);
-
-  // Find all candidates and disambiguate
-  if (
-    dateObject &&
-    is_valid_date(dateObject, options.format, options.min, options.max) &&
-    (copyear === 0 || dateObject.getFullYear() >= copyear)
-  ) {
-    try {
-      LOGGER.debug("regex result on HTML: %s", dateObject);
-      return format_date(dateObject, options.format);
-    } catch (err) {
-      LOGGER.error("value error during conversion: %s %s", dateObject, err);
-    }
-  }
-
-  // Catchall: copyright mention
-  if (copyear !== 0) {
-    LOGGER.debug("using copyright year as default");
-    const dateObject = new Date(copyear, 0, 1); // Month is 0-based in JavaScript
-    return format_date(dateObject, options.format);
-  }
-
-  LOGGER.debug("switching to one component");
-  bestmatch = search_pattern(
-    htmlstring,
-    SIMPLE_PATTERN,
-    YEAR_PATTERN,
-    YEAR_PATTERN,
-    options
-  );
-  if (bestmatch) {
-    const dateobject = new Date(parseInt(bestmatch[0]), 0, 1);
-    if (
-      is_valid_date(dateobject, "%Y-%m-%d", options.min, options.max) &&
-      dateobject.getFullYear() >= copyear
-    ) {
-      LOGGER.debug(
-        `date found for pattern "${SIMPLE_PATTERN}": ${bestmatch[0]}`
-      );
-      return dateobject.toISOString().slice(0, 10);
-    }
-  }
-
-  return null;
-}
-
-class Extractor {
-  extensive: any;
-  format: any;
-  max: any;
-  min: any;
-  original: any;
-  constructor(
-    extensive_search,
-    max_date,
-    min_date,
-    original_date,
-    outputformat
-  ) {
-    this.extensive = extensive_search;
-    this.format = outputformat;
-    this.max = max_date;
-    this.min = min_date;
-    this.original = original_date;
-  }
-}
-class Counter extends Map {
-  constructor(iterable = null) {
-    super();
-    if (iterable === null) {
-      return;
-    }
-
-    // Handle string input
-    if (typeof iterable === "string") {
-      for (const char of iterable) {
-        this.set(char, (this.get(char) || 0) + 1);
-      }
-      return;
-    }
-
-    // Handle array input
-    if (Array.isArray(iterable)) {
-      for (const item of iterable) {
-        this.set(item, (this.get(item) || 0) + 1);
-      }
-      return;
-    }
-
-    // Handle object/mapping input
-    if (typeof iterable === "object") {
-      for (const [key, value] of Object.entries(iterable)) {
-        if (value !== 0) {
-          this.set(key, value);
-        }
-      }
-      return;
-    }
-  }
-
-  // Counter-specific methods
-
-  // Return n most common elements and their counts
-  most_common(n = null) {
-    const items = Array.from(this.entries());
-    items.sort((a, b) => b[1] - a[1]);
-    return n ? items.slice(0, n) : items;
-  }
-
-  // Return the total of all counts
-  total() {
-    return Array.from(this.values()).reduce((a, b) => a + b, 0);
-  }
-
-  // Return an iterator over elements, repeating each as many times as its count
-  *elements() {
-    for (const [item, count] of this.entries()) {
-      for (let i = 0; i < count; i++) {
-        yield item;
-      }
-    }
-  }
-
-  // Update counts from an iterable
-  update(iterable) {
-    const other =
-      iterable instanceof Counter ? iterable : new Counter(iterable);
-    for (const [key, value] of other.entries()) {
-      this.set(key, (this.get(key) || 0) + value);
-      if (this.get(key) === 0) {
-        this.delete(key);
-      }
-    }
-  }
-
-  // Subtract counts from an iterable
-  subtract(iterable) {
-    const other =
-      iterable instanceof Counter ? iterable : new Counter(iterable);
-    for (const [key, value] of other.entries()) {
-      this.set(key, (this.get(key) || 0) - value);
-      if (this.get(key) === 0) {
-        this.delete(key);
-      }
-    }
-  }
-}
-
-/**
- * Extract date from document using various methods
- *
- * @param {Document} htmlobject - DOM object with article content
- * @param {boolean} [extensive_search=true] - perform extensive search if true
- * @param {boolean} [original_date=false] - return original date if true
- * @param {string} [outputformat="%Y-%m-%d"] - output format
- * @param {string} [url=null] - URL of the page
- * @param {boolean} [verbose=false] - log debug messages if true
- * @param {Date} [min_date=null] - minimum date to consider
- * @param {Date} [max_date=null] - maximum date to consider
- * @param {boolean} [deferred_url_extractor=false] - if true, do not extract date from URL
- * @returns {string|null} Extracted date or null if not found
- * @author [vtempest (2025)](https://github.com/vtempest)
- * Based on [Barbaresi (2020)](https://github.com/adbar/htmldate/)
- */
-export function extractDate(
-  htmlobject,
-  extensive_search = true,
-  original_date = false,
-  outputformat = "%Y-%m-%d",
-  url = null,
-  verbose = false,
-  min_date = null,
-  max_date = null,
-  deferred_url_extractor = false
-) {
-  if (verbose) {
-    DEBUG = true;
-  }
-
-  const tree = htmlobject;
-
-  if (!tree) {
-    return null;
-  }
-  if (outputformat !== "%Y-%m-%d" && !is_valid_format(outputformat)) {
-    return null;
-  }
-
-  const options = new Extractor(
-    extensive_search,
-    get_max_date(max_date),
-    get_min_date(min_date),
-    original_date,
-    outputformat
-  );
-
-  let url_result = null;
-  if (!url) {
-    const urlelem = tree.querySelector('link[rel="canonical"]');
-    if (urlelem) {
-      url = urlelem.getAttribute("href");
-    }
-  }
-
-  url_result = extract_url_date(url, options);
-  if (url_result && !deferred_url_extractor) {
-    return url_result;
-  }
-
-  let result = examine_header(tree, options) || json_search(tree, options);
-  if (result) {
-    return result;
-  }
-
-  if (deferred_url_extractor && url_result) {
-    return url_result;
-  }
-
-  const abbr_result = examine_abbr_elements(tree, options);
-  if (abbr_result) {
-    return abbr_result;
-  }
-
-  let search_tree, discarded;
-  try {
-    [search_tree, discarded] = discard_unwanted(tree.cloneNode(true));
-  } catch (error) {
-    search_tree = tree;
-    LOGGER.error("DOM cleaner error");
-  }
-
-  const date_expr = extensive_search
-    ? SLOW_PREPEND + DATE_EXPRESSIONS
-    : FAST_PREPEND + DATE_EXPRESSIONS;
-
-  result =
-    examine_date_elements(search_tree, date_expr, options) ||
-    examine_date_elements(search_tree, "title,h1", options) ||
-    examine_time_elements(search_tree, options);
-  if (result) {
-    return result;
-  }
-
-  const htmlstring = search_tree.innerHTML;
-  // console.log(htmlstring)
-
-  result =
-    pattern_search(htmlstring, TIMESTAMP_PATTERN, options) ||
-    img_search(search_tree, options) ||
-    idiosyncrasies_search(htmlstring, options);
-  if (result) {
-    return result;
-  }
-
-  if (extensive_search) {
-    LOGGER.debug("extensive search started");
-    let reference = 0;
-
-    const textNodes = Array.from(search_tree.childNodes).filter(
-      (node: any) => node.nodeType === 3
-    );
-
-    // Now iterate through them
-    for (let i = 0; i < textNodes.length; i++) {
-      const segment = (textNodes[i] as any).textContent.trim();
-      if (
-        segment.length > MIN_SEGMENT_LEN &&
-        segment.length < MAX_SEGMENT_LEN
-      ) {
-        reference = compare_reference(reference, segment, options);
-      }
-    }
-
-    const converted = check_extracted_reference(reference, options);
-    return converted || search_page(htmlstring, options);
-  }
-
-  return null;
-}
+/**
+ * @fileoverview Comprehensive date extraction orchestrator for HTML documents.
+ * Integrates pattern searching, JSON-LD parsing, and image metadata analysis.
+ */
+import {
+  discard_unwanted,
+  extract_url_date,
+  idiosyncrasies_search,
+  img_search,
+  json_search,
+  regex_parse,
+  pattern_search,
+  try_date_expr,
+  DATE_EXPRESSIONS,
+  FAST_PREPEND,
+  SLOW_PREPEND,
+  FREE_TEXT_EXPRESSIONS,
+  MAX_SEGMENT_LEN,
+  MIN_SEGMENT_LEN,
+  YEAR_PATTERN,
+  YMD_PATTERN,
+  COPYRIGHT_PATTERN,
+  TIMESTAMP_PATTERN,
+  THREE_PATTERN,
+  THREE_CATCH,
+  THREE_LOOSE_PATTERN,
+  THREE_LOOSE_CATCH,
+  SELECT_YMD_PATTERN,
+  SELECT_YMD_YEAR,
+  YMD_YEAR,
+  DATESTRINGS_PATTERN,
+  DATESTRINGS_CATCH,
+  SLASHES_PATTERN,
+  SLASHES_YEAR,
+  YYYYMM_PATTERN,
+  YYYYMM_CATCH,
+  MMYYYY_PATTERN,
+  MMYYYY_YEAR,
+  SIMPLE_PATTERN,
+  THREE_COMP_REGEX_A,
+  THREE_COMP_REGEX_B,
+  TWO_COMP_REGEX,
+} from "./date-extractors";
+
+import {
+  check_extracted_reference,
+  compare_values,
+  filter_ymd_candidate,
+  get_min_date,
+  get_max_date,
+  is_valid_date,
+  is_valid_format,
+  plausible_year_filter,
+  convert_date,
+} from "./date-validators";
+
+/**
+ * Format a date object into the desired output format
+ */
+function format_date(date: Date, format: string): string {
+  return convert_date(date, "YYYY-MM-DD", format);
+}
+
+// Global debug flag
+let DEBUG = false;
+const LOGGER = {
+  debug: (...args) => DEBUG && console.log(...args),
+  warn: (...args) => DEBUG && console.warn(...args),
+  error: (...args) => console.error(...args),
+};
+
+var MAX_POSSIBLE_CANDIDATES = 1000;
+
+var CLEANING_LIST = [
+  "applet",
+  "audio",
+  "canvas",
+  "datalist",
+  "embed",
+  "frame",
+  "frameset",
+  "iframe",
+  "label",
+  "map",
+  "math",
+  "noframes",
+  "object",
+  "picture",
+  "rdf",
+  "svg",
+  "track",
+  "video",
+];
+
+// Date-related meta tag attributes
+const DATE_ATTRIBUTES = new Set([
+  "analyticsattributes.articledate",
+  "article.created",
+  "article_date_original",
+  "article:post_date",
+  "article.published",
+  "article:published",
+  "article:published_date",
+  "article:published_time",
+  "article:publicationdate",
+  "bt:pubdate",
+  "citation_date",
+  "citation_publication_date",
+  "content_create_date",
+  "created",
+  "cxenseparse:recs:publishtime",
+  "date",
+  "date_created",
+  "date_published",
+  "datecreated",
+  "dateposted",
+  "datepublished",
+  // Dublin Core
+  "dc.date",
+  "dc.created",
+  "dc.date.created",
+  "dc.date.issued",
+  "dc.date.publication",
+  "dcsext.articlefirstpublished",
+  "dcterms.created",
+  "dcterms.date",
+  "dcterms.issued",
+  "dc:created",
+  "dc:date",
+  "displaydate",
+  "doc_date",
+  "field-name-post-date",
+  "gentime",
+  "mediator_published_time",
+  "meta",
+  // Open Graph
+  "og:article:published",
+  "og:article:published_time",
+  "og:datepublished",
+  "og:pubdate",
+  "og:publish_date",
+  "og:published_time",
+  "og:question:published_time",
+  "og:regdate",
+  "originalpublicationdate",
+  "parsely-pub-date",
+  "pdate",
+  "ptime",
+  "pubdate",
+  "publishdate",
+  "publish_date",
+  "publish_time",
+  "publish-date",
+  "published-date",
+  "published_date",
+  "published_time",
+  "publisheddate",
+  "publication_date",
+  "rbpubdate",
+  "release_date",
+  "rnews:datepublished",
+  "sailthru.date",
+  "shareaholic:article_published_time",
+  "timestamp",
+  "twt-published-at",
+  "video:release_date",
+  "vr:published_time",
+]);
+
+// Modified date attributes
+const NAME_MODIFIED = new Set([
+  "lastdate",
+  "lastmod",
+  "lastmodified",
+  "last-modified",
+  "modified",
+  "utime",
+]);
+
+// Property modified attributes
+const PROPERTY_MODIFIED = new Set([
+  "article:modified",
+  "article:modified_date",
+  "article:modified_time",
+  "article:post_modified",
+  "bt:moddate",
+  "datemodified",
+  "dc.modified",
+  "dcterms.modified",
+  "lastmodified",
+  "modified_time",
+  "modificationdate",
+  "og:article:modified_time",
+  "og:modified_time",
+  "og:updated_time",
+  "release_date",
+  "revision_date",
+  "updated_time",
+]);
+
+// ItemProp attributes
+const ITEMPROP_ATTRS_ORIGINAL = new Set([
+  "datecreated",
+  "datepublished",
+  "pubyear",
+]);
+
+const ITEMPROP_ATTRS_MODIFIED = new Set(["datemodified", "dateupdate"]);
+
+// Combine ItemProp sets
+const ITEMPROP_ATTRS = new Set([
+  ...ITEMPROP_ATTRS_ORIGINAL,
+  ...ITEMPROP_ATTRS_MODIFIED,
+]);
+
+// Class attributes
+const CLASS_ATTRS = new Set(["date-published", "published", "time published"]);
+
+// Regular expressions
+const NON_DIGITS_REGEX = /\D+$/;
+
+// Note: THREE_PATTERN and THREE_CATCH would need to be defined
+const THREE_COMP_PATTERNS = [
+  [THREE_PATTERN, THREE_CATCH],
+  [THREE_LOOSE_PATTERN, THREE_LOOSE_CATCH],
+];
+
+// Export all constants
+export {
+  DATE_ATTRIBUTES,
+  NAME_MODIFIED,
+  PROPERTY_MODIFIED,
+  ITEMPROP_ATTRS_ORIGINAL,
+  ITEMPROP_ATTRS_MODIFIED,
+  ITEMPROP_ATTRS,
+  CLASS_ATTRS,
+  NON_DIGITS_REGEX,
+  // THREE_COMP_PATTERNS // Uncomment once patterns are defined
+};
+
+function examine_text(text, options) {
+  if (text.length <= MIN_SEGMENT_LEN) {
+    return null;
+  }
+
+  text = text.slice(0, MAX_SEGMENT_LEN).replace(NON_DIGITS_REGEX, "");
+  return try_date_expr(
+    text,
+    options.format,
+    options.extensive,
+    options.min,
+    options.max
+  );
+}
+
+function examine_date_elements(tree, expression, options) {
+  const elements = tree.querySelectorAll(expression);
+  if (!elements || elements.length > MAX_POSSIBLE_CANDIDATES) {
+    return null;
+  }
+
+  for (const elem of elements) {
+    for (const text of [elem.textContent, elem.getAttribute("title") || ""]) {
+      const attempt = examine_text(text, options);
+      if (attempt) {
+        return attempt;
+      }
+    }
+  }
+
+  return null;
+}
+
+function examine_header(tree, options) {
+  let headerdate = null;
+  let reserve = null;
+  const tryfunc = (content) =>
+    try_date_expr(
+      content,
+      options.format,
+      options.extensive,
+      options.min,
+      options.max
+    );
+
+  for (const elem of tree.querySelectorAll("meta")) {
+    if (
+      !elem.attributes.length ||
+      (!elem.getAttribute("content") && !elem.getAttribute("datetime"))
+    ) {
+      continue;
+    }
+
+    if (elem.hasAttribute("name")) {
+      const attribute = elem.getAttribute("name")?.toLowerCase();
+      if (attribute === "og:url") {
+        reserve = extract_url_date(elem.getAttribute("content"), options);
+      } else if (DATE_ATTRIBUTES.has(attribute)) {
+        LOGGER.debug(`examining meta name: ${elem.outerHTML}`);
+        headerdate = tryfunc(elem.getAttribute("content"));
+      } else if (NAME_MODIFIED.has(attribute)) {
+        LOGGER.debug(`examining meta name: ${elem.outerHTML}`);
+        if (!options.original) {
+          headerdate = tryfunc(elem.getAttribute("content"));
+        } else {
+          reserve = tryfunc(elem.getAttribute("content"));
+        }
+      }
+    } else if (elem.hasAttribute("property")) {
+      const attribute = elem.getAttribute("property").toLowerCase();
+      if (DATE_ATTRIBUTES.has(attribute) || PROPERTY_MODIFIED.has(attribute)) {
+        LOGGER.debug(`examining meta property: ${elem.outerHTML}`);
+        const attempt = tryfunc(elem.getAttribute("content"));
+        if (attempt !== null) {
+          if (
+            (DATE_ATTRIBUTES.has(attribute) && options.original) ||
+            (PROPERTY_MODIFIED.has(attribute) && !options.original)
+          ) {
+            headerdate = attempt;
+          } else {
+            reserve = attempt;
+          }
+        }
+      }
+    } else if (elem.hasAttribute("itemprop")) {
+      const attribute = elem.getAttribute("itemprop").toLowerCase();
+      if (ITEMPROP_ATTRS.has(attribute)) {
+        LOGGER.debug(`examining meta itemprop: ${elem.outerHTML}`);
+        const attempt = tryfunc(
+          elem.getAttribute("datetime") || elem.getAttribute("content")
+        );
+        if (attempt !== null) {
+          if (
+            (ITEMPROP_ATTRS_ORIGINAL.has(attribute) && options.original) ||
+            (ITEMPROP_ATTRS_MODIFIED.has(attribute) && !options.original)
+          ) {
+            headerdate = attempt;
+          }
+        }
+      } else if (attribute === "copyrightyear") {
+        LOGGER.debug(`examining meta itemprop: ${elem.outerHTML}`);
+        if (elem.hasAttribute("content")) {
+          const attempt = `${elem.getAttribute("content")}-01-01`;
+          if (is_valid_date(attempt, "%Y-%m-%d", options.min, options.max)) {
+            reserve = attempt;
+          }
+        }
+      }
+    } else if (elem.hasAttribute("pubdate")) {
+      if (elem.getAttribute("pubdate").toLowerCase() === "pubdate") {
+        LOGGER.debug(`examining meta pubdate: ${elem.outerHTML}`);
+        headerdate = tryfunc(elem.getAttribute("content"));
+      }
+    } else if (elem.hasAttribute("http-equiv")) {
+      const attribute = elem.getAttribute("http-equiv").toLowerCase();
+      if (attribute === "date") {
+        LOGGER.debug(`examining meta http-equiv: ${elem.outerHTML}`);
+        if (options.original) {
+          headerdate = tryfunc(elem.getAttribute("content"));
+        } else {
+          reserve = tryfunc(elem.getAttribute("content"));
+        }
+      } else if (attribute === "last-modified") {
+        LOGGER.debug(`examining meta http-equiv: ${elem.outerHTML}`);
+        if (!options.original) {
+          headerdate = tryfunc(elem.getAttribute("content"));
+        } else {
+          reserve = tryfunc(elem.getAttribute("content"));
+        }
+      }
+    }
+
+    if (headerdate !== null) {
+      break;
+    }
+  }
+
+  if (headerdate === null && reserve !== null) {
+    LOGGER.debug("opting for reserve date with less granularity");
+    headerdate = reserve;
+  }
+
+  return headerdate;
+}
+
+function select_candidate(occurrences, catch_regex, yearpat, options) {
+  if (!occurrences || occurrences.size > MAX_POSSIBLE_CANDIDATES) {
+    return null;
+  }
+
+  // console.log( JSON.stringify(occurrences) + " 444444444444" + occurrences + " 444444444444")
+
+  if (occurrences.size === 1) {
+    const pattern = occurrences.keys().next().value;
+    return catch_regex.exec(pattern);
+  }
+  ///if null
+  // if (occurrences.size === 0) {
+  return occurrences;
+  //todo fix
+  // }
+
+  const firstselect = Array.from(occurrences.entries())
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 10);
+  LOGGER.debug(`firstselect: ${JSON.stringify(firstselect)}`);
+
+  const bestones = firstselect
+    .sort((a, b) => (options.original ? a[1] - b[1] : b[1] - a[1]))
+    .slice(0, 2);
+  LOGGER.debug(`bestones: ${JSON.stringify(bestones)}`);
+
+  const patterns = bestones.map((item) => item[0]);
+  const counts = bestones.map((item) => item[1]);
+
+  const years = patterns
+    .map((pattern) => {
+      const year_match = yearpat.exec(pattern);
+      return year_match ? year_match[1] : null;
+    })
+    .filter((year) => year !== null);
+
+  const validation = years.map((year) =>
+    is_valid_date(
+      new Date(parseInt(year), 0, 1),
+      "%Y",
+      options.min,
+      options.max
+    )
+  );
+
+  let match = null;
+  if (validation.every((v) => v)) {
+    if (counts[0] === counts[1]) {
+      match = catch_regex.exec(patterns[0]);
+    } else if (years[1] !== years[0] && counts[1] / counts[0] > 0.5) {
+      match = catch_regex.exec(patterns[1]);
+    } else {
+      match = catch_regex.exec(patterns[0]);
+    }
+  } else if (validation.some((v) => v)) {
+    match = catch_regex.exec(patterns[validation.indexOf(true)]);
+  } else {
+    LOGGER.debug(`no suitable candidate: ${years[0]} ${years[1]}`);
+  }
+
+  return match;
+}
+
+function search_pattern(htmlstring, pattern, catch_regex, yearpat, options) {
+  const candidates = plausible_year_filter(
+    htmlstring,
+    pattern,
+    yearpat,
+    options.min,
+    options.max
+  );
+  return select_candidate(candidates, catch_regex, yearpat, options);
+}
+
+function compare_reference(reference, expression, options) {
+  const attempt = try_date_expr(
+    expression,
+    options.format,
+    options.extensive,
+    options.min,
+    options.max
+  );
+  if (attempt !== null) {
+    return compare_values(reference, attempt, options);
+  }
+  return reference;
+}
+
+function examine_abbr_elements(tree, options) {
+  const elements = tree.querySelectorAll("abbr");
+  if (elements.length > 0 && elements.length < MAX_POSSIBLE_CANDIDATES) {
+    let reference = 0;
+    for (const elem of elements) {
+      if (elem.hasAttribute("data-utime")) {
+        try {
+          const candidate = parseInt(elem.getAttribute("data-utime"));
+          LOGGER.debug(`data-utime found: ${candidate}`);
+          if (options.original && (reference === 0 || candidate < reference)) {
+            reference = candidate;
+          } else if (!options.original && candidate > reference) {
+            reference = candidate;
+          }
+        } catch (err) {
+          continue;
+        }
+      } else if (CLASS_ATTRS.has(elem.getAttribute("class"))) {
+        if (elem.hasAttribute("title")) {
+          const trytext = elem.getAttribute("title");
+          LOGGER.debug(`abbr published-title found: ${trytext}`);
+          if (options.original) {
+            const attempt = try_date_expr(
+              trytext,
+              options.format,
+              options.extensive,
+              options.min,
+              options.max
+            );
+            if (attempt !== null) {
+              return attempt;
+            }
+          } else {
+            reference = compare_reference(reference, trytext, options);
+            if (reference > 0) {
+              break;
+            }
+          }
+        } else if (elem.textContent && elem.textContent.length > 10) {
+          LOGGER.debug(`abbr published found: ${elem.textContent}`);
+          reference = compare_reference(reference, elem.textContent, options);
+        }
+      }
+    }
+    return (
+      check_extracted_reference(reference, options) ||
+      examine_date_elements(tree, "abbr", options)
+    );
+  }
+  return null;
+}
+
+function examine_time_elements(tree, options) {
+  const elements = tree.querySelectorAll("time");
+  if (elements.length > 0 && elements.length < MAX_POSSIBLE_CANDIDATES) {
+    let reference = 0;
+    for (const elem of elements) {
+      let shortcut_flag = false;
+      if (!elem || !elem.getAttribute) continue;
+
+      const datetime_attr = elem.getAttribute("datetime") || "";
+      if (datetime_attr.length > 6) {
+        if (
+          elem.hasAttribute("pubdate") &&
+          elem.getAttribute("pubdate") === "pubdate" &&
+          options.original
+        ) {
+          shortcut_flag = true;
+          LOGGER.debug(`shortcut for time pubdate found: ${datetime_attr}`);
+        } else if (elem.hasAttribute("class")) {
+          if (
+            options.original &&
+            (elem.getAttribute("class").startsWith("entry-date") ||
+              elem.getAttribute("class").startsWith("entry-time"))
+          ) {
+            shortcut_flag = true;
+            LOGGER.debug(`shortcut for time/datetime found: ${datetime_attr}`);
+          } else if (
+            !options.original &&
+            elem.getAttribute("class") === "updated"
+          ) {
+            shortcut_flag = true;
+            LOGGER.debug(
+              `shortcut for updated time/datetime found: ${datetime_attr}`
+            );
+          }
+        } else {
+          LOGGER.debug(`time/datetime found: ${datetime_attr}`);
+        }
+
+        if (shortcut_flag) {
+          const attempt = try_date_expr(
+            datetime_attr,
+            options.format,
+            options.extensive,
+            options.min,
+            options.max
+          );
+          if (attempt !== null) {
+            return attempt;
+          }
+        } else {
+          reference = compare_reference(reference, datetime_attr, options);
+        }
+      } else if (elem.textContent && elem.textContent.length > 6) {
+        LOGGER.debug(`time/datetime found in text: ${elem.textContent}`);
+        reference = compare_reference(reference, elem.textContent, options);
+      }
+    }
+    return check_extracted_reference(reference, options);
+  }
+  return null;
+}
+
+function normalize_match(match) {
+  if (!match) return null;
+  const groups = match.slice(1).filter((g) => g);
+  let [day, month, year] = groups.map((g) => g.padStart(2, "0"));
+  if (year.length === 2) {
+    year = year[0] === "9" ? `19${year}` : `20${year}`;
+  }
+  return `${year}-${month}-${day}`;
+}
+
+function search_page(htmlstring, options) {
+  LOGGER.debug("looking for copyright/footer information");
+  let copyear = 0;
+
+  let bestmatch = search_pattern(
+    htmlstring,
+    COPYRIGHT_PATTERN,
+    YEAR_PATTERN,
+    YEAR_PATTERN,
+    options
+  );
+  if (bestmatch) {
+    const year = parseInt(bestmatch[0]);
+    if (is_valid_date(new Date(year, 0, 1), "%Y", options.min, options.max)) {
+      LOGGER.debug(`copyright year/footer pattern found: ${year}`);
+      copyear = year;
+    }
+  }
+
+  LOGGER.debug("3 components");
+  for (const patterns of THREE_COMP_PATTERNS) {
+    bestmatch = search_pattern(
+      htmlstring,
+      patterns[0],
+      patterns[1],
+      YEAR_PATTERN,
+      options
+    );
+    let result = filter_ymd_candidate(
+      bestmatch,
+      patterns[0],
+      options.original,
+      copyear,
+      options.format,
+      options.min,
+      options.max
+    );
+    if (result !== null) {
+      return result;
+    }
+  }
+
+  let candidates = plausible_year_filter(
+    htmlstring,
+    SELECT_YMD_PATTERN,
+    SELECT_YMD_YEAR,
+    options.min,
+    options.max
+  );
+  let replacement = {};
+  for (const [item, count] of Object.entries(candidates)) {
+    const match = THREE_COMP_REGEX_A.exec(item);
+    if (match) {
+      const candidate = normalize_match(match);
+      replacement[candidate] = count;
+    }
+  }
+
+  bestmatch = select_candidate(
+    new Counter(replacement),
+    YMD_PATTERN,
+    YMD_YEAR,
+    options
+  );
+  let result = filter_ymd_candidate(
+    bestmatch,
+    SELECT_YMD_PATTERN,
+    options.original,
+    copyear,
+    options.format,
+    options.min,
+    options.max
+  );
+  if (result !== null) {
+    return result;
+  }
+
+  bestmatch = search_pattern(
+    htmlstring,
+    DATESTRINGS_PATTERN,
+    DATESTRINGS_CATCH,
+    YEAR_PATTERN,
+    options
+  );
+  result = filter_ymd_candidate(
+    bestmatch,
+    DATESTRINGS_PATTERN,
+    options.original,
+    copyear,
+    options.format,
+    options.min,
+    options.max
+  );
+  if (result !== null) {
+    return result;
+  }
+
+  LOGGER.debug("switching to two components");
+
+  // First option: YYYY-MM pattern
+  bestmatch = search_pattern(
+    htmlstring,
+    YYYYMM_PATTERN,
+    YYYYMM_CATCH,
+    YEAR_PATTERN,
+    options
+  );
+
+  if (bestmatch) {
+    const dateObject = new Date(
+      parseInt(bestmatch[1]),
+      parseInt(bestmatch[2]) - 1,
+      1
+    );
+    if (
+      is_valid_date(dateObject, "%Y-%m-%d", options.min, options.max) &&
+      (copyear === 0 || dateObject.getFullYear() >= copyear)
+    ) {
+      LOGGER.debug(
+        'date found for pattern "%s": %s, %s',
+        YYYYMM_PATTERN,
+        bestmatch[1],
+        bestmatch[2]
+      );
+      return format_date(dateObject, options.format);
+    }
+  }
+
+  // 2 components, second option: MM-YYYY pattern
+  candidates = plausible_year_filter(
+    htmlstring,
+    MMYYYY_PATTERN,
+    MMYYYY_YEAR,
+    options.min,
+    options.max,
+    options.original
+  );
+
+  // Revert DD-MM-YYYY patterns before sorting
+  replacement = {};
+  for (const [item, count] of Object.entries(candidates)) {
+    const match = item?.match(TWO_COMP_REGEX);
+    if (!match) continue;
+
+    let month = match[1];
+    if (month.length === 1) {
+      month = `0${month}`;
+    }
+    const candidate = `${match[2]}-${month}-01`;
+    replacement[candidate] = count;
+  }
+
+  candidates = new Counter(replacement);
+
+  // Select best candidate
+  bestmatch = select_candidate(candidates, YMD_PATTERN, YMD_YEAR, options);
+  result = filter_ymd_candidate(
+    bestmatch,
+    MMYYYY_PATTERN,
+    options.original,
+    copyear,
+    options.format,
+    options.min,
+    options.max
+  );
+
+  if (result !== null) {
+    return result;
+  }
+
+  // Try full-blown text regex on all HTML
+  const dateObject = regex_parse(htmlstring);
+
+  // Find all candidates and disambiguate
+  if (
+    dateObject &&
+    is_valid_date(dateObject, options.format, options.min, options.max) &&
+    (copyear === 0 || dateObject.getFullYear() >= copyear)
+  ) {
+    try {
+      LOGGER.debug("regex result on HTML: %s", dateObject);
+      return format_date(dateObject, options.format);
+    } catch (err) {
+      LOGGER.error("value error during conversion: %s %s", dateObject, err);
+    }
+  }
+
+  // Catchall: copyright mention
+  if (copyear !== 0) {
+    LOGGER.debug("using copyright year as default");
+    const dateObject = new Date(copyear, 0, 1); // Month is 0-based in JavaScript
+    return format_date(dateObject, options.format);
+  }
+
+  LOGGER.debug("switching to one component");
+  bestmatch = search_pattern(
+    htmlstring,
+    SIMPLE_PATTERN,
+    YEAR_PATTERN,
+    YEAR_PATTERN,
+    options
+  );
+  if (bestmatch) {
+    const dateobject = new Date(parseInt(bestmatch[0]), 0, 1);
+    if (
+      is_valid_date(dateobject, "%Y-%m-%d", options.min, options.max) &&
+      dateobject.getFullYear() >= copyear
+    ) {
+      LOGGER.debug(
+        `date found for pattern "${SIMPLE_PATTERN}": ${bestmatch[0]}`
+      );
+      return dateobject.toISOString().slice(0, 10);
+    }
+  }
+
+  return null;
+}
+
+class Extractor {
+  extensive: any;
+  format: any;
+  max: any;
+  min: any;
+  original: any;
+  constructor(
+    extensive_search,
+    max_date,
+    min_date,
+    original_date,
+    outputformat
+  ) {
+    this.extensive = extensive_search;
+    this.format = outputformat;
+    this.max = max_date;
+    this.min = min_date;
+    this.original = original_date;
+  }
+}
+class Counter extends Map {
+  constructor(iterable = null) {
+    super();
+    if (iterable === null) {
+      return;
+    }
+
+    // Handle string input
+    if (typeof iterable === "string") {
+      for (const char of iterable) {
+        this.set(char, (this.get(char) || 0) + 1);
+      }
+      return;
+    }
+
+    // Handle array input
+    if (Array.isArray(iterable)) {
+      for (const item of iterable) {
+        this.set(item, (this.get(item) || 0) + 1);
+      }
+      return;
+    }
+
+    // Handle object/mapping input
+    if (typeof iterable === "object") {
+      for (const [key, value] of Object.entries(iterable)) {
+        if (value !== 0) {
+          this.set(key, value);
+        }
+      }
+      return;
+    }
+  }
+
+  // Counter-specific methods
+
+  // Return n most common elements and their counts
+  most_common(n = null) {
+    const items = Array.from(this.entries());
+    items.sort((a, b) => b[1] - a[1]);
+    return n ? items.slice(0, n) : items;
+  }
+
+  // Return the total of all counts
+  total() {
+    return Array.from(this.values()).reduce((a, b) => a + b, 0);
+  }
+
+  // Return an iterator over elements, repeating each as many times as its count
+  *elements() {
+    for (const [item, count] of this.entries()) {
+      for (let i = 0; i < count; i++) {
+        yield item;
+      }
+    }
+  }
+
+  // Update counts from an iterable
+  update(iterable) {
+    const other =
+      iterable instanceof Counter ? iterable : new Counter(iterable);
+    for (const [key, value] of other.entries()) {
+      this.set(key, (this.get(key) || 0) + value);
+      if (this.get(key) === 0) {
+        this.delete(key);
+      }
+    }
+  }
+
+  // Subtract counts from an iterable
+  subtract(iterable) {
+    const other =
+      iterable instanceof Counter ? iterable : new Counter(iterable);
+    for (const [key, value] of other.entries()) {
+      this.set(key, (this.get(key) || 0) - value);
+      if (this.get(key) === 0) {
+        this.delete(key);
+      }
+    }
+  }
+}
+
+/**
+ * Extract date from document using various methods
+ *
+ * @param {Document} htmlobject - DOM object with article content
+ * @param {boolean} [extensive_search=true] - perform extensive search if true
+ * @param {boolean} [original_date=false] - return original date if true
+ * @param {string} [outputformat="%Y-%m-%d"] - output format
+ * @param {string} [url=null] - URL of the page
+ * @param {boolean} [verbose=false] - log debug messages if true
+ * @param {Date} [min_date=null] - minimum date to consider
+ * @param {Date} [max_date=null] - maximum date to consider
+ * @param {boolean} [deferred_url_extractor=false] - if true, do not extract date from URL
+ * @returns {string|null} Extracted date or null if not found
+ * @author [vtempest (2025)](https://github.com/vtempest)
+ * Based on [Barbaresi (2020)](https://github.com/adbar/htmldate/)
+ */
+export function extractDate(
+  htmlobject,
+  extensive_search = true,
+  original_date = false,
+  outputformat = "%Y-%m-%d",
+  url = null,
+  verbose = false,
+  min_date = null,
+  max_date = null,
+  deferred_url_extractor = false
+) {
+  if (verbose) {
+    DEBUG = true;
+  }
+
+  const tree = htmlobject;
+
+  if (!tree) {
+    return null;
+  }
+  if (outputformat !== "%Y-%m-%d" && !is_valid_format(outputformat)) {
+    return null;
+  }
+
+  const options = new Extractor(
+    extensive_search,
+    get_max_date(max_date),
+    get_min_date(min_date),
+    original_date,
+    outputformat
+  );
+
+  let url_result = null;
+  if (!url) {
+    const urlelem = tree.querySelector('link[rel="canonical"]');
+    if (urlelem) {
+      url = urlelem.getAttribute("href");
+    }
+  }
+
+  url_result = extract_url_date(url, options);
+  if (url_result && !deferred_url_extractor) {
+    return url_result;
+  }
+
+  let result = examine_header(tree, options) || json_search(tree, options);
+  if (result) {
+    return result;
+  }
+
+  if (deferred_url_extractor && url_result) {
+    return url_result;
+  }
+
+  const abbr_result = examine_abbr_elements(tree, options);
+  if (abbr_result) {
+    return abbr_result;
+  }
+
+  let search_tree, discarded;
+  try {
+    [search_tree, discarded] = discard_unwanted(tree.cloneNode(true));
+  } catch (error) {
+    search_tree = tree;
+    LOGGER.error("DOM cleaner error");
+  }
+
+  const date_expr = extensive_search
+    ? SLOW_PREPEND + DATE_EXPRESSIONS
+    : FAST_PREPEND + DATE_EXPRESSIONS;
+
+  result =
+    examine_date_elements(search_tree, date_expr, options) ||
+    examine_date_elements(search_tree, "title,h1", options) ||
+    examine_time_elements(search_tree, options);
+  if (result) {
+    return result;
+  }
+
+  const htmlstring = search_tree.innerHTML;
+  // console.log(htmlstring)
+
+  result =
+    pattern_search(htmlstring, TIMESTAMP_PATTERN, options) ||
+    img_search(search_tree, options) ||
+    idiosyncrasies_search(htmlstring, options);
+  if (result) {
+    return result;
+  }
+
+  if (extensive_search) {
+    LOGGER.debug("extensive search started");
+    let reference = 0;
+
+    const textNodes = Array.from(search_tree.childNodes).filter(
+      (node: any) => node.nodeType === 3
+    );
+
+    // Now iterate through them
+    for (let i = 0; i < textNodes.length; i++) {
+      const segment = (textNodes[i] as any).textContent.trim();
+      if (
+        segment.length > MIN_SEGMENT_LEN &&
+        segment.length < MAX_SEGMENT_LEN
+      ) {
+        reference = compare_reference(reference, segment, options);
+      }
+    }
+
+    const converted = check_extracted_reference(reference, options);
+    return converted || search_page(htmlstring, options);
+  }
+
+  return null;
+}