epg-grabber 0.44.0 → 0.45.0

package/dist/index-CHTSs3QX.js

@@ -0,0 +1,857 @@
+import utc from 'dayjs/plugin/utc.js';
+import dayjs from 'dayjs';
+import { URL } from 'node:url';
+import path from 'node:path';
+import AxiosMockAdapter from 'axios-mock-adapter';
+import padStart from 'lodash.padstart';
+import axios from 'axios';
+import { setupCache } from 'axios-cache-interceptor';
+import merge from 'lodash.merge';
+import xmlJs from 'xml-js';
+
+dayjs.extend(utc);
+function toUnix(date) {
+  return dayjs.utc(date).valueOf();
+}
+function parseProxy(string) {
+  const parsed = new URL(string);
+  const proxy = {
+    protocol: parsed.protocol.replace(":", ""),
+    host: parsed.hostname,
+    port: parsed.port ? parseInt(parsed.port) : 8080
+  };
+  if (parsed.username || parsed.password) {
+    proxy.auth = { username: parsed.username, password: parsed.password };
+  }
+  return proxy;
+}
+async function loadJs(filepath) {
+  const absPath = path.resolve(filepath);
+  return (await import(absPath)).default;
+}
+function parseNumber(value) {
+  return parseInt(value);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isDate(date) {
+  return dayjs(date).isValid();
+}
+function isObject(value) {
+  return !!value && value.constructor === Object;
+}
+function isPromise(promise) {
+  return promise instanceof Promise;
+}
+function getUTCDate(date) {
+  if (dayjs.isDayjs(date) && date.isUTC()) return date;
+  return dayjs.utc(date).startOf("d");
+}
+function getAbsPath(filepath, rootDir) {
+  if (path.isAbsolute(filepath)) return filepath;
+  return path.resolve(rootDir, filepath);
+}
+function escapeString(value, defaultValue = "") {
+  if (!value) return defaultValue;
+  if (typeof value === "number") value = value.toString();
+  const regex = new RegExp(
+    "((?:[\0-\b\v\f-\uFFFD\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]))|([\\x7F-\\x84]|[\\x86-\\x9F]|[\\uFDD0-\\uFDEF]|(?:\\uD83F[\\uDFFE\\uDFFF])|(?:\\uD87F[\\uDFFE\\uDFFF])|(?:\\uD8BF[\\uDFFE\\uDFFF])|(?:\\uD8FF[\\uDFFE\\uDFFF])|(?:\\uD93F[\\uDFFE\\uDFFF])|(?:\\uD97F[\\uDFFE\\uDFFF])|(?:\\uD9BF[\\uDFFE\\uDFFF])|(?:\\uD9FF[\\uDFFE\\uDFFF])|(?:\\uDA3F[\\uDFFE\\uDFFF])|(?:\\uDA7F[\\uDFFE\\uDFFF])|(?:\\uDABF[\\uDFFE\\uDFFF])|(?:\\uDAFF[\\uDFFE\\uDFFF])|(?:\\uDB3F[\\uDFFE\\uDFFF])|(?:\\uDB7F[\\uDFFE\\uDFFF])|(?:\\uDBBF[\\uDFFE\\uDFFF])|(?:\\uDBFF[\\uDFFE\\uDFFF])(?:[\\0-\\t\\x0B\\f\\x0E-\\u2027\\u202A-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]))",
+    "g"
+  );
+  value = String(value || "").replace(regex, "");
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;").replace(/\n|\r/g, " ").replace(/  +/g, " ").trim();
+}
+function formatDate(date, format) {
+  return date ? dayjs.utc(date).format(format) : "";
+}
+function toURL(domain) {
+  return domain ? `https://${domain}` : "";
+}
+function createXMLElement(name, attrs, children) {
+  return convertXMLElementToString({ name, attrs, children });
+}
+function convertXMLElementToString(elem) {
+  if (!elem) return "";
+  if (typeof elem === "string") return elem;
+  if (typeof elem === "number") return elem.toString();
+  if (!elem.attrs && !elem.children) return `<${elem.name}/>`;
+  let attrs = "";
+  for (const key in elem.attrs) {
+    const value = elem.attrs[key];
+    if (value) {
+      attrs += ` ${key}="${escapeString(value)}"`;
+    }
+  }
+  const children = elem.children || [];
+  if (children.filter(Boolean).length) {
+    let _children = "";
+    children.forEach((childElem) => {
+      if (!childElem) return;
+      _children += convertXMLElementToString(childElem);
+    });
+    return `<${elem.name}${attrs}>${_children}</${elem.name}>`;
+  }
+  if (!attrs && !["previously-shown"].includes(elem.name)) return "";
+  return `<${elem.name}${attrs}/>`;
+}
+function toArray(value) {
+  if (value === null || value === void 0) return [];
+  if (Array.isArray(value)) return value.filter(Boolean);
+  return [value].filter(Boolean);
+}
+
+var name = "epg-grabber";
+var version = "0.45.0";
+var description = "Node.js CLI tool for grabbing EPG from different sites";
+var homepage = "https://github.com/freearhey/epg-grabber";
+
+var defaultConfig = {
+  days: 1,
+  delay: 3e3,
+  output: "guide.xml",
+  channels: [],
+  request: {
+    method: "GET",
+    maxContentLength: 5 * 1024 * 1024,
+    timeout: 5e3,
+    withCredentials: true,
+    responseType: "arraybuffer",
+    cache: false,
+    headers: {
+      "User-Agent": `EPGGrabber/${version} (${homepage})`
+    }
+  },
+  maxConnections: 1,
+  curl: false,
+  debug: false,
+  gzip: false
+};
+
+class Channel {
+  xmltv_id;
+  name;
+  site;
+  site_id;
+  lang;
+  logo;
+  url;
+  lcn;
+  index;
+  constructor(data) {
+    this.xmltv_id = data.xmltv_id;
+    this.name = data.name;
+    this.site = data.site;
+    this.site_id = data.site_id;
+    this.lang = data.lang;
+    this.logo = data.logo;
+    this.url = data.url || toURL(data.site);
+    this.lcn = data.lcn;
+    this.index = data.index !== void 0 ? data.index : -1;
+  }
+  static fromXmlJsElement(site, element, index) {
+    if (!element.elements) return;
+    const textElement = element.elements.find((element2) => element2.type === "text");
+    if (!textElement || !textElement.text) return;
+    const attributes = element.attributes;
+    if (!attributes) return;
+    const channel = new Channel({
+      xmltv_id: attributes.xmltv_id ? attributes.xmltv_id.toString() : "",
+      name: textElement.text.toString(),
+      site: attributes.site ? attributes.site.toString() : site,
+      site_id: attributes.site_id ? attributes.site_id.toString() : "",
+      lang: attributes.lang ? attributes.lang.toString() : null,
+      logo: attributes.logo ? attributes.logo.toString() : null,
+      url: attributes.url ? attributes.url.toString() : null,
+      lcn: attributes.lcn ? attributes.lcn.toString() : null,
+      index
+    });
+    return channel;
+  }
+  toXML() {
+    const el = createXMLElement;
+    const children = [el("display-name", {}, [escapeString(this.name)])];
+    if (this.logo) children.push(el("icon", { src: this.logo }, []));
+    if (this.url) children.push(el("url", {}, [escapeString(this.url)]));
+    if (this.lcn) children.push(el("lcn", {}, [escapeString(this.lcn)]));
+    return el("channel", { id: this.xmltv_id }, children);
+  }
+  toObject() {
+    return {
+      xmltv_id: this.xmltv_id,
+      name: this.name,
+      site: this.site,
+      site_id: this.site_id,
+      lang: this.lang,
+      logo: this.logo,
+      url: this.url,
+      lcn: this.lcn,
+      index: this.index
+    };
+  }
+}
+
+dayjs.extend(utc);
+class Program {
+  site;
+  start;
+  stop;
+  channel;
+  titles;
+  subTitles;
+  descriptions;
+  date;
+  categories;
+  keywords;
+  languages;
+  origLanguages;
+  length;
+  urls;
+  countries;
+  episodeNumbers;
+  video;
+  audio;
+  previouslyShown;
+  premiere;
+  lastChance;
+  new;
+  subtitles;
+  ratings;
+  starRatings;
+  reviews;
+  directors;
+  actors;
+  writers;
+  adapters;
+  producers;
+  composers;
+  editors;
+  presenters;
+  commentators;
+  guests;
+  images;
+  icons;
+  constructor(data) {
+    if (typeof data.site !== "string")
+      throw new Error('The "site" property must be of type "string"');
+    if (typeof data.start !== "number")
+      throw new Error('The "start" property must be of type "number"');
+    if (typeof data.stop !== "number")
+      throw new Error('The "stop" property must be of type "number"');
+    if (typeof data.channel !== "string")
+      throw new Error('The "channel" property must be of type "string"');
+    if (!Array.isArray(data.titles)) throw new Error('The "start" property must be of type "array"');
+    this.site = data.site;
+    this.channel = data.channel;
+    this.start = data.start;
+    this.stop = data.stop;
+    this.titles = data.titles;
+    this.subTitles = Array.isArray(data.subTitles) ? data.subTitles : [];
+    this.descriptions = Array.isArray(data.descriptions) ? data.descriptions : [];
+    this.date = typeof data.date === "number" ? data.date : null;
+    this.categories = Array.isArray(data.categories) ? data.categories : [];
+    this.keywords = Array.isArray(data.keywords) ? data.keywords : [];
+    this.languages = Array.isArray(data.languages) ? data.languages : [];
+    this.origLanguages = Array.isArray(data.origLanguages) ? data.origLanguages : [];
+    this.length = Array.isArray(data.length) ? data.length : [];
+    this.urls = Array.isArray(data.urls) ? data.urls : [];
+    this.countries = Array.isArray(data.countries) ? data.countries : [];
+    this.episodeNumbers = Array.isArray(data.episodeNumbers) ? data.episodeNumbers : [];
+    this.video = typeof data.video === "object" ? data.video : null;
+    this.audio = typeof data.audio === "object" ? data.audio : null;
+    this.previouslyShown = Array.isArray(data.previouslyShown) ? data.previouslyShown : [];
+    this.premiere = Array.isArray(data.premiere) ? data.premiere : [];
+    this.lastChance = Array.isArray(data.lastChance) ? data.lastChance : [];
+    this.new = typeof data.new === "boolean" ? data.new : false;
+    this.subtitles = Array.isArray(data.subtitles) ? data.subtitles : [];
+    this.ratings = Array.isArray(data.ratings) ? data.ratings : [];
+    this.starRatings = Array.isArray(data.starRatings) ? data.starRatings : [];
+    this.reviews = Array.isArray(data.reviews) ? data.reviews : [];
+    this.directors = Array.isArray(data.directors) ? data.directors : [];
+    this.actors = Array.isArray(data.actors) ? data.actors : [];
+    this.writers = Array.isArray(data.writers) ? data.writers : [];
+    this.adapters = Array.isArray(data.adapters) ? data.adapters : [];
+    this.producers = Array.isArray(data.producers) ? data.producers : [];
+    this.composers = Array.isArray(data.composers) ? data.composers : [];
+    this.editors = Array.isArray(data.editors) ? data.editors : [];
+    this.presenters = Array.isArray(data.presenters) ? data.presenters : [];
+    this.commentators = Array.isArray(data.commentators) ? data.commentators : [];
+    this.guests = Array.isArray(data.guests) ? data.guests : [];
+    this.images = Array.isArray(data.images) ? data.images : [];
+    this.icons = Array.isArray(data.icons) ? data.icons : [];
+  }
+  static fromParserResult(data, channel) {
+    function toTextObject(value, lang2 = "") {
+      if (!value) return { value: "", lang: lang2 };
+      if (typeof value === "string") return { value, lang: lang2 };
+      return {
+        value: typeof value.value === "string" ? value.value : "",
+        lang: typeof value.lang === "string" ? value.lang : ""
+      };
+    }
+    function toPersonObject(value) {
+      if (!value) return { value: "", urls: [], images: [] };
+      if (typeof value === "string") return { value, urls: [], images: [] };
+      return {
+        value: value.value,
+        urls: toArray(value.urls || value.url).map(toUrlObject),
+        images: toArray(value.images || value.image).map(toImageObject)
+      };
+    }
+    function toSubtitlesObject(value) {
+      if (!value) return { type: "", language: [] };
+      return {
+        type: typeof value.type === "string" ? value.type : "",
+        language: toArray(value.language).map((text) => toTextObject(text))
+      };
+    }
+    function toImageObject(value) {
+      if (!value) return { type: "", size: "", orient: "", system: "", value: "" };
+      if (typeof value === "string") return { type: "", size: "", orient: "", system: "", value };
+      return {
+        type: typeof value.type === "string" ? value.type : "",
+        size: typeof value.size === "string" ? value.size : "",
+        orient: typeof value.orient === "string" ? value.orient : "",
+        system: typeof value.system === "string" ? value.system : "",
+        value: typeof value.value === "string" ? value.value : ""
+      };
+    }
+    function toRatingObject(value) {
+      if (!value) return { system: "", icons: [], value: "" };
+      if (typeof value === "string") return { system: "", icons: [], value };
+      return {
+        system: typeof value.system === "string" ? value.system : "",
+        icons: toArray(value.icons || value.icon).map(toIconObject),
+        value: typeof value.value === "string" ? value.value : ""
+      };
+    }
+    function toLengthObject(value) {
+      if (!value) return { units: "", value: "" };
+      if (typeof value === "string") return { units: "", value };
+      if (typeof value === "number") return { units: "", value: value.toString() };
+      return {
+        units: typeof value.units === "string" ? value.units : "",
+        value: typeof value.value === "string" ? value.value : ""
+      };
+    }
+    function toUrlObject(value) {
+      if (!value) return { system: "", value: "" };
+      if (typeof value === "string") return { system: "", value };
+      return {
+        system: typeof value.system === "string" ? value.system : "",
+        value: typeof value.value === "string" ? value.value : ""
+      };
+    }
+    function toVideoObject(value) {
+      if (!value) return { present: "", colour: "", aspect: "", quality: "" };
+      return {
+        present: typeof value.present === "string" ? value.present : "",
+        colour: typeof value.colour === "string" ? value.colour : "",
+        aspect: typeof value.aspect === "string" ? value.aspect : "",
+        quality: typeof value.quality === "string" ? value.quality : ""
+      };
+    }
+    function toAudioObject(value) {
+      if (!value) return { present: "", stereo: "" };
+      return {
+        present: typeof value.present === "string" ? value.present : "",
+        stereo: typeof value.stereo === "string" ? value.stereo : ""
+      };
+    }
+    function toReviewObject(value) {
+      if (!value) return { type: "", source: "", reviewer: "", lang: "", value: "" };
+      return {
+        type: typeof value.type === "string" ? value.type : "",
+        source: typeof value.source === "string" ? value.source : "",
+        reviewer: typeof value.reviewer === "string" ? value.reviewer : "",
+        lang: typeof value.lang === "string" ? value.lang : "",
+        value: typeof value.value === "string" ? value.value : ""
+      };
+    }
+    function toPreviouslyShownObject(value) {
+      if (!value) return { start: "", channel: "" };
+      return {
+        start: typeof value.start === "string" ? value.start : "",
+        channel: typeof value.channel === "string" ? value.channel : ""
+      };
+    }
+    function toIconObject(value) {
+      if (!value) return { src: "", width: "", height: "" };
+      if (typeof value === "string") return { src: value, width: "", height: "" };
+      return {
+        src: typeof value.src === "string" ? value.src : "",
+        width: typeof value.width === "string" ? value.width : typeof value.width === "number" ? value.width.toString() : "",
+        height: typeof value.height === "string" ? value.height : typeof value.height === "number" ? value.height.toString() : ""
+      };
+    }
+    function makeEpisodeNumberObjects(seasonNumberAny, episodeNumberAny) {
+      if (!seasonNumberAny) seasonNumberAny = 1;
+      if (!episodeNumberAny) return [];
+      const seasonNumber = typeof seasonNumberAny === "number" ? seasonNumberAny : parseInt(seasonNumberAny);
+      const episodeNumber = typeof episodeNumberAny === "number" ? episodeNumberAny : parseInt(episodeNumberAny);
+      return [
+        createXMLTVNS(seasonNumber, episodeNumber),
+        createOnScreen(seasonNumber, episodeNumber)
+      ].filter((value) => value !== null);
+    }
+    function toEpisodeNumberObject(value) {
+      if (!value) return { system: "", value: "" };
+      return {
+        system: typeof value.system === "string" ? value.system : "",
+        value: typeof value.value === "string" ? value.value : ""
+      };
+    }
+    function createXMLTVNS(seasonNumber, episodeNumber) {
+      if (!episodeNumber) return null;
+      seasonNumber = seasonNumber || 1;
+      return {
+        system: "xmltv_ns",
+        value: `${seasonNumber - 1}.${episodeNumber - 1}.0/1`
+      };
+    }
+    function createOnScreen(seasonNumber, episodeNumber) {
+      if (!episodeNumber) return null;
+      seasonNumber = seasonNumber || 1;
+      const seasonNumberString = padStart(seasonNumber.toString(), 2, "0");
+      const episodeNumberString = padStart(episodeNumber.toString(), 2, "0");
+      return {
+        system: "onscreen",
+        value: `S${seasonNumberString}E${episodeNumberString}`
+      };
+    }
+    const lang = channel.lang || void 0;
+    const program = new Program({
+      site: channel.site,
+      start: data.start ? toUnix(data.start) : 0,
+      stop: data.stop ? toUnix(data.stop) : 0,
+      channel: channel.xmltv_id || "",
+      titles: toArray(data.titles || data.title).map((value) => toTextObject(value, lang)),
+      subTitles: toArray(data.subTitles || data.subTitle || data.sub_titles || data.sub_title).map(
+        (value) => toTextObject(value, lang)
+      ),
+      descriptions: toArray(data.descriptions || data.description || data.desc).map(
+        (value) => toTextObject(value, lang)
+      ),
+      date: data.date ? toUnix(data.date) : 0,
+      categories: toArray(data.categories || data.category).map((value) => toTextObject(value, lang)),
+      keywords: toArray(data.keywords || data.keyword).map((value) => toTextObject(value, lang)),
+      languages: toArray(data.languages || data.language).map((value) => toTextObject(value, lang)),
+      origLanguages: toArray(data.origLanguages || data.origLanguage).map(
+        (value) => toTextObject(value, lang)
+      ),
+      length: toArray(data.length).map(toLengthObject),
+      urls: toArray(data.urls || data.url).map(toUrlObject),
+      countries: toArray(data.countries || data.country).map((value) => toTextObject(value, lang)),
+      episodeNumbers: toArray(
+        data.episodeNum || data.episodeNumber || data.episodeNumbers || makeEpisodeNumberObjects(data.season, data.episode)
+      ).map(toEpisodeNumberObject),
+      video: toVideoObject(data.video),
+      audio: toAudioObject(data.audio),
+      previouslyShown: toArray(data.previouslyShown).map(toPreviouslyShownObject),
+      premiere: toArray(data.premiere).map((value) => toTextObject(value, lang)),
+      lastChance: toArray(data.lastChance).map((value) => toTextObject(value, lang)),
+      new: data.new || false,
+      subtitles: toArray(data.subtitles).map(toSubtitlesObject),
+      ratings: toArray(data.ratings || data.rating).map(toRatingObject),
+      starRatings: toArray(data.starRatings || data.starRating).map(toRatingObject),
+      reviews: toArray(data.reviews || data.review).map(toReviewObject),
+      directors: toArray(data.directors || data.director).map(toPersonObject),
+      actors: toArray(data.actors || data.actor).map(toPersonObject),
+      writers: toArray(data.writers || data.writer).map(toPersonObject),
+      adapters: toArray(data.adapters || data.adapter).map(toPersonObject),
+      producers: toArray(data.producers || data.producer).map(toPersonObject),
+      composers: toArray(data.composers || data.composer).map(toPersonObject),
+      editors: toArray(data.editors || data.editor).map(toPersonObject),
+      presenters: toArray(data.presenters || data.presenter).map(toPersonObject),
+      commentators: toArray(data.commentators || data.commentator).map(toPersonObject),
+      guests: toArray(data.guests || data.guest).map(toPersonObject),
+      images: toArray(data.images || data.image).map(toImageObject),
+      icons: toArray(data.icons || data.icon).map(toIconObject)
+    });
+    return program;
+  }
+  toXML() {
+    const el = createXMLElement;
+    function createCastMember(position, person) {
+      return el(position, {}, [
+        escapeString(person.value),
+        ...person.urls.map(createURLElement),
+        ...person.images.map(createImageElement)
+      ]);
+    }
+    function createImageElement(image) {
+      return el(
+        "image",
+        {
+          type: image.type,
+          size: image.size,
+          orient: image.orient,
+          system: image.system
+        },
+        [escapeString(image.value)]
+      );
+    }
+    function createURLElement(url) {
+      return el("url", { system: url.system }, [escapeString(url.value)]);
+    }
+    const children = [
+      ...this.titles.map((title) => el("title", { lang: title.lang }, [escapeString(title.value)])),
+      ...this.subTitles.map(
+        (subTitle) => el("sub-title", { lang: subTitle.lang }, [escapeString(subTitle.value)])
+      ),
+      ...this.descriptions.map((desc) => el("desc", { lang: desc.lang }, [escapeString(desc.value)])),
+      el("credits", {}, [
+        ...this.directors.map((data) => createCastMember("director", data)),
+        ...this.actors.map((data) => createCastMember("actor", data)),
+        ...this.writers.map((data) => createCastMember("writer", data)),
+        ...this.adapters.map((data) => createCastMember("adapter", data)),
+        ...this.producers.map((data) => createCastMember("producer", data)),
+        ...this.composers.map((data) => createCastMember("composer", data)),
+        ...this.editors.map((data) => createCastMember("editor", data)),
+        ...this.presenters.map((data) => createCastMember("presenter", data)),
+        ...this.commentators.map((data) => createCastMember("commentator", data)),
+        ...this.guests.map((data) => createCastMember("guest", data))
+      ]),
+      el("date", {}, [formatDate(this.date, "YYYYMMDD")]),
+      ...this.categories.map(
+        (category) => el("category", { lang: category.lang }, [escapeString(category.value)])
+      ),
+      ...this.keywords.map(
+        (keyword) => el("keyword", { lang: keyword.lang }, [escapeString(keyword.value)])
+      ),
+      ...this.languages.map(
+        (language) => el("language", { lang: language.lang }, [escapeString(language.value)])
+      ),
+      ...this.origLanguages.map(
+        (origLanguage) => el("orig-language", { lang: origLanguage.lang }, [escapeString(origLanguage.value)])
+      ),
+      ...this.length.map(
+        (length) => el("length", { units: length.units }, [escapeString(length.value)])
+      ),
+      ...this.countries.map(
+        (country) => el("country", { lang: country.lang }, [escapeString(country.value)])
+      ),
+      ...this.urls.map(createURLElement),
+      ...this.episodeNumbers.map(
+        (episode) => el("episode-num", { system: episode.system }, [escapeString(episode.value)])
+      ),
+      this.video ? el("video", {}, [
+        el("present", {}, typeof this.video.present === "string" ? [this.video.present] : []),
+        el("colour", {}, typeof this.video.colour === "string" ? [this.video.colour] : []),
+        el("aspect", {}, typeof this.video.aspect === "string" ? [this.video.aspect] : []),
+        el("quality", {}, typeof this.video.quality === "string" ? [this.video.quality] : [])
+      ]) : null,
+      this.audio ? el("audio", {}, [
+        el("present", {}, typeof this.audio.present === "string" ? [this.audio.present] : []),
+        el("stereo", {}, typeof this.audio.stereo === "string" ? [this.audio.stereo] : [])
+      ]) : null,
+      ...this.previouslyShown.map(
+        (previouslyShown) => el(
+          "previously-shown",
+          {
+            start: previouslyShown.start,
+            channel: previouslyShown.channel
+          },
+          []
+        )
+      ),
+      ...this.premiere.map(
+        (premiere) => el("premiere", { lang: premiere.lang }, [escapeString(premiere.value)])
+      ),
+      ...this.lastChance.map(
+        (lastChance) => el("last-chance", { lang: lastChance.lang }, [escapeString(lastChance.value)])
+      ),
+      this.new ? el("new") : "",
+      ...this.subtitles.map(
+        (subtitles) => el(
+          "subtitles",
+          { type: subtitles.type },
+          subtitles.language.map(
+            (language) => el("language", { lang: language.lang }, [escapeString(language.value)])
+          )
+        )
+      ),
+      ...this.ratings.map(
+        (rating) => el("rating", { system: rating.system }, [
+          el("value", {}, [escapeString(rating.value)]),
+          ...rating.icons.map(
+            (icon) => el("icon", { src: icon.src, width: icon.width, height: icon.height })
+          )
+        ])
+      ),
+      ...this.starRatings.map(
+        (rating) => el("star-rating", { system: rating.system }, [
+          el("value", {}, [escapeString(rating.value)]),
+          ...rating.icons.map(
+            (icon) => el("icon", { src: icon.src, width: icon.width, height: icon.height })
+          )
+        ])
+      ),
+      ...this.reviews.map(
+        (review) => el(
+          "review",
+          {
+            type: review.type,
+            source: review.source,
+            reviewer: review.reviewer,
+            lang: review.lang
+          },
+          [escapeString(review.value || "")]
+        )
+      ),
+      ...this.images.map(createImageElement),
+      ...this.icons.map(
+        (icon) => el("icon", { src: icon.src, width: icon.width, height: icon.height })
+      )
+    ];
+    return el(
+      "programme",
+      {
+        start: formatDate(this.start, "YYYYMMDDHHmmss ZZ"),
+        stop: formatDate(this.stop, "YYYYMMDDHHmmss ZZ"),
+        channel: this.channel
+      },
+      children
+    );
+  }
+  toObject() {
+    return {
+      site: this.site,
+      start: this.start,
+      stop: this.stop,
+      channel: this.channel,
+      titles: this.titles,
+      subTitles: this.subTitles,
+      descriptions: this.descriptions,
+      date: this.date,
+      categories: this.categories,
+      keywords: this.keywords,
+      languages: this.languages,
+      origLanguages: this.origLanguages,
+      length: this.length,
+      urls: this.urls,
+      countries: this.countries,
+      episodeNumbers: this.episodeNumbers,
+      video: this.video,
+      audio: this.audio,
+      previouslyShown: this.previouslyShown,
+      premiere: this.premiere,
+      lastChance: this.lastChance,
+      new: this.new,
+      subtitles: this.subtitles,
+      ratings: this.ratings,
+      starRatings: this.starRatings,
+      reviews: this.reviews,
+      directors: this.directors,
+      actors: this.actors,
+      writers: this.writers,
+      adapters: this.adapters,
+      producers: this.producers,
+      composers: this.composers,
+      editors: this.editors,
+      presenters: this.presenters,
+      commentators: this.commentators,
+      guests: this.guests,
+      images: this.images,
+      icons: this.icons
+    };
+  }
+}
+
+class Client {
+  instance;
+  constructor() {
+    this.instance = setupCache(axios.create());
+  }
+  static async buildRequest(context) {
+    async function getRequestHeaders(requestContext) {
+      const config = requestContext.config;
+      if (config.request && typeof config.request.headers === "function") {
+        if (typeof config.request.headers === "function") {
+          const headers = config.request.headers(requestContext);
+          if (isPromise(headers)) {
+            return await headers;
+          }
+          return headers;
+        }
+      }
+      return typeof config.request?.headers === "object" ? config.request?.headers : void 0;
+    }
+    async function getRequestData(requestContext) {
+      const config = requestContext.config;
+      if (!config.request) return void 0;
+      if (typeof config.request.data === "function") {
+        const data = config.request.data(requestContext);
+        if (isPromise(data)) {
+          return await data;
+        }
+        return data;
+      }
+      return config.request?.data;
+    }
+    async function getRequestUrl(requestContext) {
+      const config = requestContext.config;
+      if (typeof config.url === "function") {
+        const url = config.url(requestContext);
+        if (isPromise(url)) {
+          return await url;
+        }
+        return url;
+      }
+      return config.url;
+    }
+    const request = context.config.request;
+    request.headers = await getRequestHeaders(context);
+    request.url = await getRequestUrl(context);
+    request.data = await getRequestData(context);
+    return request;
+  }
+  async sendRequest(request) {
+    const response = await this.instance(request);
+    return this.parseResponse(response);
+  }
+  parseResponse(response) {
+    return {
+      content: response.data.toString(),
+      buffer: response.data,
+      headers: response.headers,
+      request: response.request,
+      cached: response.cached
+    };
+  }
+}
+
+class EPGGrabber {
+  globalConfig = {};
+  client;
+  constructor(config = {}) {
+    this.globalConfig = merge(defaultConfig, config);
+    this.client = new Client();
+  }
+  async loadLogo(channel, date, config = {}) {
+    if (!(channel instanceof Channel))
+      throw new Error('The first argument must be the "Channel" class');
+    config = merge(config, this.globalConfig);
+    if (typeof config.logo !== "function") return null;
+    const requestContext = { channel, date: getUTCDate(date), config };
+    const logo = config.logo(requestContext);
+    if (isPromise(logo)) {
+      return await logo;
+    }
+    return logo;
+  }
+  async grab(channel, date, config = {}, callback = () => {
+  }) {
+    if (!(channel instanceof Channel))
+      throw new Error('The first argument must be the "Channel" class');
+    if (typeof config === "function") {
+      callback = config;
+      config = {};
+    }
+    const utcDate = getUTCDate(date);
+    const requestContext = { channel, date: utcDate, config };
+    config = merge(config, this.globalConfig);
+    if (!config.parser) throw new Error("Could not find parser() in the config file");
+    if (!config.site) throw new Error("The required 'site' property is missing");
+    if (!config.url) throw new Error("The required 'url' property is missing");
+    if (typeof config.url !== "function" && typeof config.url !== "string")
+      throw new Error("The 'url' property should return the function or string");
+    if (!config.parser) throw new Error("The required 'parser' function is missing");
+    if (typeof config.parser !== "function")
+      throw new Error("The 'parser' property should return the function");
+    if (config.logo && typeof config.logo !== "function")
+      throw new Error("The 'logo' property should return the function");
+    try {
+      if (typeof config.delay === "number") await sleep(config.delay);
+      const request = await Client.buildRequest(requestContext);
+      const response = await this.client.sendRequest(request);
+      const parserContext = {
+        ...response,
+        channel,
+        date: utcDate,
+        config
+      };
+      let parsedPrograms = config.parser(parserContext);
+      if (isPromise(parsedPrograms)) {
+        parsedPrograms = await parsedPrograms;
+      }
+      const programs = parsedPrograms.filter(Boolean).map((data) => Program.fromParserResult(data, channel));
+      callback({ channel, date: utcDate, programs }, null);
+      return programs;
+    } catch (error) {
+      callback({ channel, date: utcDate, programs: [] }, error);
+      return [];
+    }
+  }
+  static parseChannelsXML(xml) {
+    const result = xmlJs.xml2js(xml);
+    const siteTag = result.elements.find((element) => element.name === "site") || {};
+    const channelsTag = siteTag && Array.isArray(siteTag.elements) ? siteTag.elements.find((element) => element.name === "channels") : result.elements.find((element) => element.name === "channels");
+    if (!channelsTag || !channelsTag.elements) return [];
+    let site = "";
+    if (siteTag && siteTag.attributes && siteTag.attributes.site) {
+      site = siteTag.attributes.site;
+    } else if (channelsTag && channelsTag.attributes && channelsTag.attributes.site) {
+      site = channelsTag.attributes.site;
+    }
+    const channels = channelsTag.elements.filter((element) => element.name === "channel").map(
+      (element, index) => Channel.fromXmlJsElement(site, element, index)
+    ).filter(Boolean);
+    return channels;
+  }
+  static generateXMLTV(channels, programs, date = getUTCDate()) {
+    if (!channels.every((channel) => channel instanceof Channel)) {
+      throw new Error('"channels" must be an array of Channels');
+    }
+    if (!programs.every((program) => program instanceof Program)) {
+      throw new Error('"programs" must be an array of Programs');
+    }
+    if (!isDate(date)) {
+      throw new Error('"date" must be a valid date');
+    }
+    let output = `<?xml version="1.0" encoding="UTF-8" ?>`;
+    output += createXMLElement("tv", { date: formatDate(date, "YYYYMMDD") }, [
+      ...channels.map((channel) => "\r\n" + channel.toXML()),
+      ...programs.map((program) => "\r\n" + program.toXML()),
+      "\r\n"
+    ]);
+    return output;
+  }
+}
+class EPGGrabberMock extends EPGGrabber {
+  async grab(channel, date, config = {}, callback = () => {
+  }) {
+    if (typeof config === "function") {
+      callback = config;
+      config = {};
+    }
+    const utcDate = getUTCDate(date);
+    config = merge(config, this.globalConfig);
+    if (!config.parser) throw new Error("Could not find parser() in the config file");
+    const requestContext = { channel, date: utcDate, config };
+    try {
+      const request = await Client.buildRequest(requestContext);
+      const mock = new AxiosMockAdapter(this.client.instance);
+      mock.onAny().reply(200, Buffer.from(JSON.stringify([]), "utf8"));
+      const response = await this.client.sendRequest(request);
+      const parserContext = {
+        ...response,
+        channel,
+        date: utcDate,
+        config
+      };
+      let parsedPrograms = config.parser(parserContext);
+      if (isPromise(parsedPrograms)) {
+        parsedPrograms = await parsedPrograms;
+      }
+      const programs = parsedPrograms.filter(Boolean).map((data) => Program.fromParserResult(data, channel));
+      callback({ channel, date: utcDate, programs }, null);
+      return programs;
+    } catch (error) {
+      callback({ channel, date: utcDate, programs: [] }, error);
+      return [];
+    }
+  }
+}
+
+export { Channel as C, EPGGrabberMock as E, Program as P, parseProxy as a, EPGGrabber as b, getUTCDate as c, description as d, getAbsPath as g, isObject as i, loadJs as l, name as n, parseNumber as p, version as v };