pervert-monkey 1.0.0

package/src/userscripts/scripts/xhamster.ts

@@ -0,0 +1,179 @@
+import type { MonkeyUserScript } from 'vite-plugin-monkey';
+import { unsafeWindow } from '$';
+import { RulesGlobal } from '../../core/rules';
+import {
+  exterminateVideo,
+  getCommonParents,
+  instantiateTemplate,
+  parseHtml,
+  waitForElementToAppear,
+  watchElementChildrenCount,
+} from '../../utils/dom';
+import { onPointerOverAndLeave } from '../../utils/events';
+import { fetchJson } from '../../utils/fetch';
+import { Observer } from '../../utils/observers';
+
+export const meta: MonkeyUserScript = {
+  name: 'Xhamster Improved',
+  version: '5.0.0',
+  description: 'Infinite scroll [optional], Filter by Title and Duration',
+  match: ['https://*.xhamster.*/*', 'https://*.xhamster.com/*'],
+  exclude: 'https://*.xhamster.com/embed*',
+  icon: 'https://www.google.com/s2/favicons?sz=64&domain=xhamster.com',
+};
+
+const IS_VIDEO_PAGE = /^\/videos|moments\//.test(location.pathname);
+const IS_PLAYLIST = /^\/my\/favorites\/videos\/\w+/.test(location.pathname);
+
+function createThumb(data: Record<string, string>): string {
+  const attrsToReplace = {
+    href: data.pageURL,
+    'data-previewvideo': data.trailerURL,
+    'data-previewvideo-fallback': data.trailerFallbackUrl,
+    'data-sprite': data.spriteURL,
+    title: data.title,
+    'data-video-id': data.id,
+    srcset: data.thumbURL,
+    src: data.imageURL,
+  };
+
+  const text = {
+    '.video-thumb-views': data.views,
+    '[title]': data.title,
+    '[data-role="video-duration"] div': data.duration,
+  };
+
+  return instantiateTemplate('.video-thumb', attrsToReplace, text);
+}
+
+const getPaginationData: RulesGlobal['getPaginationData'] = !IS_PLAYLIST
+  ? undefined
+  : async (url: string): Promise<HTMLElement> => {
+      const data = await fetchJson(url);
+      const thumbsHtml = (data as any).list
+        .map((e: Record<string, string>) => createThumb(e))
+        .join('\n');
+      return parseHtml(`<div>${thumbsHtml}</div>`);
+    };
+
+function createPlaylistPaginationStrategy() {
+  const collectionId = location.pathname
+    .split('/my/favorites/videos/')[1]
+    .split('-')[0] as string;
+  const data = (unsafeWindow as any).initials;
+  const paginationLast = data.favoritesVideoPaging.maxPages;
+  const paginationOffset = data.favoritesVideoPaging.active;
+
+  const playlistPaginationStrategy: RulesGlobal['paginationStrategyOptions'] = {
+    paginationSelector: 'nav[class *= "pagination"]',
+    getPaginationLast: () => paginationLast,
+    getPaginationOffset: () => paginationOffset,
+    getPaginationUrlGenerator: () => (offset: number) => {
+      return `https://xhamster.com/api/front/favorite/get-playlist?id=${collectionId}&perPage=60&page=${offset}`;
+    },
+  };
+
+  return playlistPaginationStrategy;
+}
+
+const paginationStrategyOptionsDefault: RulesGlobal['paginationStrategyOptions'] = {
+  paginationSelector: '.prev-next-list, .test-pager',
+};
+
+const paginationStrategyOptions = IS_PLAYLIST
+  ? createPlaylistPaginationStrategy()
+  : paginationStrategyOptionsDefault;
+
+const rules = new RulesGlobal({
+  paginationStrategyOptions,
+  getPaginationData,
+  containerSelectorLast: '.thumb-list',
+  thumbsSelector: '.video-thumb',
+  titleSelector: '.video-thumb-info__name,.video-thumb-info>a',
+  durationSelector: '.thumb-image-container__duration',
+  gropeStrategy: 'all-in-all',
+  getThumbImgDataStrategy: 'auto',
+  getThumbImgDataAttrDelete: '[loading]',
+  customThumbDataSelectors: {
+    watched: {
+      type: 'boolean',
+      selector: '[data-role="video-watched',
+    },
+  },
+  customDataSelectorFns: [
+    'filterInclude',
+    'filterExclude',
+    'filterDuration',
+    {
+      filterWatched: (el, state) => !!(state.filterWatched && el.watched),
+    },
+    {
+      filterUnwatched: (el, state) => !!(state.filterUnwatched && !el.watched),
+    },
+  ],
+  schemeOptions: [
+    'Text Filter',
+    'Badge',
+    {
+      title: 'Filter Watched',
+      content: [
+        { filterWatched: false, label: 'watched' },
+        { filterUnwatched: false, label: 'unwatched' },
+      ],
+    },
+    'Duration Filter',
+    'Advanced',
+  ],
+  animatePreview,
+});
+
+function animatePreview() {
+  function createPreviewVideoElement(src: string, mount: HTMLElement) {
+    const video = document.createElement('video');
+    video.playsInline = true;
+    video.autoplay = true;
+    video.loop = true;
+    video.classList.add('thumb-image-container__video');
+    video.src = src;
+    video.addEventListener(
+      'loadeddata',
+      () => {
+        mount.before(video);
+      },
+      false,
+    );
+    return () => exterminateVideo(video);
+  }
+
+  onPointerOverAndLeave(
+    document.body,
+    (e) => e.classList.contains('thumb-image-container__image'),
+    (e) => {
+      const videoSrc = e.parentElement?.getAttribute('data-previewvideo') as string;
+      const onOverCallback = createPreviewVideoElement(videoSrc, e);
+      const leaveTarget = e.parentElement?.parentElement as HTMLElement;
+      return { leaveTarget, onOverCallback };
+    },
+  );
+}
+
+function expandMoreVideoPage() {
+  watchElementChildrenCount(rules.container, () => setTimeout(parseThumbs, 1800));
+  waitForElementToAppear(document.body, 'button[data-role="show-more-next"]', (el) => {
+    const observer = new Observer((target) => {
+      (target as HTMLButtonElement).click();
+    });
+    observer.observe(el);
+  });
+}
+
+function parseThumbs() {
+  const containers = getCommonParents(rules.getThumbs(document.body));
+  containers.forEach((c) => {
+    rules.dataManager.parseData(c, c);
+  });
+}
+
+if (IS_VIDEO_PAGE) {
+  expandMoreVideoPage();
+}

package/src/userscripts/scripts/xvideos.ts

@@ -0,0 +1,83 @@
+import type { MonkeyUserScript } from 'vite-plugin-monkey';
+import { unsafeWindow } from '$';
+import { RulesGlobal } from '../../core/rules';
+import { exterminateVideo, parseHtml } from '../../utils/dom';
+import { onPointerOverAndLeave } from '../../utils/events';
+
+export const meta: MonkeyUserScript = {
+  name: 'XVideos Improved',
+  version: '4.0.0',
+  description: 'Infinite scroll [optional], Filter by Title and Duration',
+  match: 'https://*.xvideos.com/*',
+  icon: 'https://www.google.com/s2/favicons?sz=64&domain=xvideos.com',
+};
+
+const xv = (unsafeWindow as any).xv;
+
+const rules = new RulesGlobal({
+  paginationStrategyOptions: {
+    paginationSelector: '#main .pagination:last-child',
+    searchParamSelector: 'p',
+  },
+  containerSelector: '#content > div',
+  thumbsSelector: 'div.thumb-block[id^=video_]:not(.thumb-ad)',
+  titleSelector: '[class*=title]',
+  uploaderSelector: '[class*=name]',
+  durationSelector: '[class*=duration]',
+  gropeStrategy: 'all-in-one',
+  customDataSelectorFns: ['filterInclude', 'filterExclude'],
+  schemeOptions: ['Text Filter', 'Duration Filter', 'Badge', 'Advanced'],
+  animatePreview,
+  getThumbDataCallback(thumb) {
+    setTimeout(() => {
+      const id = parseInt(thumb.getAttribute('data-id') as string);
+      xv.thumbs.prepareVideo(id);
+    }, 200);
+  },
+});
+
+function animatePreview(container: HTMLElement) {
+  function createPreviewElement(src: string, mount: HTMLElement) {
+    const elem = parseHtml(`
+    <div class="videopv" style="display: none;">
+        <video autoplay="autoplay" playsinline="playsinline" muted="muted"></video>
+    </div>`);
+    mount.after(elem);
+
+    const video = elem.querySelector('video') as HTMLVideoElement;
+    video.src = src;
+    video.addEventListener(
+      'loadeddata',
+      () => {
+        mount.style.opacity = '0';
+        elem.style.display = 'block';
+        elem.style.background = '#000';
+      },
+      false,
+    );
+
+    return () => {
+      exterminateVideo(video);
+      elem.remove();
+      mount.style.opacity = '1';
+    };
+  }
+
+  function getVideoURL(src: string) {
+    return src
+      .replace(/thumbs169l{1,}/, 'videopreview')
+      .replace(/\/\w+\.\d+\.\w+/, '_169.mp4')
+      .replace(/(-\d+)_169\.mp4/, (_, b) => `_169${b}.mp4`);
+  }
+
+  onPointerOverAndLeave(
+    container,
+    (target) => target.tagName === 'IMG' && target.id.includes('pic_'),
+    (target) => {
+      const videoSrc = getVideoURL((target as HTMLImageElement).src);
+      const onOverCallback = createPreviewElement(videoSrc, target);
+      const leaveTarget = target.closest('.thumb-inside') as HTMLElement;
+      return { leaveTarget, onOverCallback };
+    },
+  );
+}

package/src/utils/arrays/index.ts

@@ -0,0 +1,15 @@
+export function chunks<T>(arr: T[], size: number): T[][] {
+  return Array.from({ length: Math.ceil(arr.length / size) }, (_, i) =>
+    arr.slice(i * size, i * size + size),
+  );
+}
+
+export function* irange(start: number = 1, step: number = 1) {
+  for (let i = start; ; i += step) {
+    yield i;
+  }
+}
+
+export function range(size: number, start: number = 1, step: number = 1): number[] {
+  return irange(start, step).take(size).toArray();
+}

package/src/utils/async/index.ts

@@ -0,0 +1,3 @@
+export function wait(milliseconds: number) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}

package/src/utils/dom/dom-observers.ts

@@ -0,0 +1,76 @@
+export function waitForElementToAppear(
+  parent: ParentNode,
+  selector: string,
+  callback: (el: Element) => void,
+) {
+  const observer = new MutationObserver((_mutations) => {
+    const el = parent.querySelector(selector);
+    if (el) {
+      observer.disconnect();
+      callback(el);
+    }
+  });
+
+  observer.observe(document.body, { childList: true, subtree: true });
+  return observer;
+}
+
+export function waitForElementToDisappear(observable: HTMLElement, callback: () => void) {
+  const observer = new MutationObserver((_mutations) => {
+    if (!observable.isConnected) {
+      observer.disconnect();
+      callback();
+    }
+  });
+
+  observer.observe(document.body, { childList: true, subtree: true });
+  return observer;
+}
+
+export function watchElementChildrenCount(
+  element: ParentNode,
+  callback: (observer: MutationObserver, count: number) => void,
+) {
+  let count = element.children.length;
+  const observer = new MutationObserver((mutationList, observer) => {
+    for (const mutation of mutationList) {
+      if (mutation.type === 'childList') {
+        if (count !== element.children.length) {
+          count = element.children.length;
+          callback(observer, count);
+        }
+      }
+    }
+  });
+
+  observer.observe(element, { childList: true });
+  return observer;
+}
+
+export function watchDomChangesWithThrottle(
+  element: HTMLElement,
+  callback: () => void,
+  throttle = 1000,
+  times = Infinity,
+  options: MutationObserverInit = { childList: true, subtree: true, attributes: true },
+) {
+  let lastMutationTime: number;
+  let timeout: number;
+  let times_ = times;
+  const observer = new MutationObserver((_mutationList, _observer) => {
+    if (times_ !== Infinity && times_ < 1) {
+      observer.disconnect();
+      return;
+    }
+    times_--;
+    const now = Date.now();
+    if (lastMutationTime && now - lastMutationTime < throttle) {
+      timeout && clearTimeout(timeout);
+    }
+    timeout = window.setTimeout(callback, throttle);
+    lastMutationTime = now;
+  });
+
+  observer.observe(element, options);
+  return observer;
+}

package/src/utils/dom/index.ts

@@ -0,0 +1,156 @@
+import { sanitizeStr } from '../strings';
+import { waitForElementToAppear } from './dom-observers';
+
+export {
+  waitForElementToAppear,
+  waitForElementToDisappear,
+  watchDomChangesWithThrottle,
+  watchElementChildrenCount,
+} from './dom-observers';
+
+export function querySelectorLast<T extends Element = HTMLElement>(
+  root: ParentNode = document,
+  selector: string,
+): T | undefined {
+  const nodes = root.querySelectorAll<T>(selector);
+  return nodes.length > 0 ? nodes[nodes.length - 1] : undefined;
+}
+
+export function querySelectorLastNumber(selector: string, e: ParentNode = document) {
+  const text = querySelectorText(e, selector);
+  return Number(text.match(/\d+/g)?.pop() || 0);
+}
+
+export function querySelectorText(e: ParentNode, selector?: string): string {
+  if (typeof selector !== 'string') return '';
+  const text = e.querySelector<HTMLElement>(selector)?.innerText || '';
+  return sanitizeStr(text);
+}
+
+export function parseHtml(html: string): HTMLElement {
+  const parsed = new DOMParser().parseFromString(html, 'text/html').body;
+  if (parsed.children.length > 1) return parsed;
+  return parsed.firstElementChild as HTMLElement;
+}
+
+export function copyAttributes<T extends Element = HTMLElement>(target: T, source: T) {
+  for (const attr of source.attributes) {
+    if (attr.nodeValue) {
+      target.setAttribute(attr.nodeName, attr.nodeValue);
+    }
+  }
+}
+
+export function replaceElementTag(e: HTMLElement, tagName: string) {
+  const newTagElement = document.createElement(tagName);
+  copyAttributes(newTagElement, e);
+
+  newTagElement.innerHTML = e.innerHTML;
+  e.parentNode?.replaceChild(newTagElement, e);
+
+  return newTagElement;
+}
+
+export function removeClassesAndDataAttributes(
+  element: HTMLElement,
+  keyword: string,
+): void {
+  Array.from(element.classList).forEach((className) => {
+    if (className.includes(keyword)) {
+      element.classList.remove(className);
+    }
+  });
+
+  Array.from(element.attributes).forEach((attr) => {
+    if (attr.name.startsWith('data-') && attr.name.includes(keyword)) {
+      element.removeAttribute(attr.name);
+    }
+  });
+}
+
+export function getCommonParents(elements: HTMLCollection | HTMLElement[]): HTMLElement[] {
+  const parents = Array.from(elements)
+    .map((el) => el.parentElement)
+    .filter((parent): parent is HTMLElement => parent !== null);
+
+  return [...new Set(parents)];
+}
+
+export function findNextSibling<T extends Element = HTMLElement>(e: T) {
+  if (e.nextElementSibling) return e.nextElementSibling;
+  if (e.parentElement) return findNextSibling(e.parentElement);
+  return null;
+}
+
+export function checkHomogenity<T extends HTMLElement>(
+  a: T,
+  b: T,
+  options: { id?: boolean; className?: boolean },
+) {
+  if (!a || !b) return false;
+
+  if (options.id) {
+    if (a.id !== b.id) return false;
+  }
+
+  if (options.className) {
+    const ca = a.className;
+    const cb = b.className;
+    if (!(ca.length > cb.length ? ca.includes(cb) : cb.includes(ca))) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+export function instantiateTemplate(
+  sourceSelector: string,
+  attributeUpdates: Record<string, string>,
+  contentUpdates: Record<string, string>,
+): string {
+  const source = document.querySelector(sourceSelector) as HTMLElement;
+
+  const wrapper = document.createElement('div');
+  const clone = source.cloneNode(true);
+  wrapper.append(clone);
+
+  Object.entries(attributeUpdates).forEach(([attrName, attrValue]) => {
+    wrapper.querySelectorAll(`[${attrName}]`).forEach((element) => {
+      element.setAttribute(attrName, attrValue);
+    });
+  });
+
+  Object.entries(contentUpdates).forEach(([childSelector, textValue]) => {
+    wrapper.querySelectorAll<HTMLElement>(childSelector).forEach((element) => {
+      element.innerText = textValue;
+    });
+  });
+
+  return wrapper.innerHTML;
+}
+
+export function exterminateVideo(video: HTMLVideoElement) {
+  video.removeAttribute('src');
+  video.load();
+  video.remove();
+}
+
+export function downloader(
+  options = { append: '', after: '', button: '', cbBefore: () => {} },
+) {
+  const btn = parseHtml(options.button);
+
+  if (options.append) document.querySelector(options.append)?.append(btn);
+  if (options.after) document.querySelector(options.after)?.after(btn);
+
+  btn.addEventListener('click', (e) => {
+    e.preventDefault();
+
+    if (options.cbBefore) options.cbBefore();
+
+    waitForElementToAppear(document.body, 'video', (video: Element) => {
+      window.location.href = video.getAttribute('src') as string;
+    });
+  });
+}

package/src/utils/events/index.ts

@@ -0,0 +1,2 @@
+export { onPointerOverAndLeave } from './on-pointer-over-and-leave';
+export { Tick } from './tick';

package/src/utils/events/on-pointer-over-and-leave.ts

@@ -0,0 +1,35 @@
+export function onPointerOverAndLeave(
+  container: HTMLElement,
+  subjectSelector: (target: HTMLElement) => boolean,
+  onOver: (
+    target: HTMLElement,
+  ) => { onOverCallback?: () => void; leaveTarget?: HTMLElement } | void,
+  onLeave?: (target: HTMLElement) => void,
+) {
+  let target: HTMLElement | undefined;
+  let onOverFinally: (() => void) | undefined;
+
+  function handleLeaveEvent() {
+    onLeave?.(target as HTMLElement);
+    onOverFinally?.();
+    target = undefined;
+  }
+
+  function handleEvent(e: PointerEvent) {
+    const currentTarget = e.target as HTMLElement;
+    if (!subjectSelector(currentTarget) || target === currentTarget) return;
+    target = currentTarget;
+
+    const result = onOver(target);
+
+    onOverFinally = result?.onOverCallback;
+    const leaveSubject = result?.leaveTarget || target;
+
+    leaveSubject.addEventListener('pointerleave', handleLeaveEvent, {
+      once: true,
+    });
+  }
+
+  container.addEventListener('pointerover', handleEvent);
+}
+

package/src/utils/events/tick.ts

@@ -0,0 +1,27 @@
+export class Tick {
+  private tick?: number;
+  private callbackFinal?: () => void;
+
+  constructor(
+    private delay: number,
+    private startImmediate: boolean = true,
+  ) {}
+
+  public start(callback: () => void, callbackFinal?: () => void): void {
+    this.stop();
+    this.callbackFinal = callbackFinal;
+    if (this.startImmediate) callback();
+    this.tick = window.setInterval(callback, this.delay);
+  }
+
+  public stop(): void {
+    if (this.tick !== undefined) {
+      clearInterval(this.tick);
+      this.tick = undefined;
+    }
+    if (this.callbackFinal) {
+      this.callbackFinal();
+      this.callbackFinal = undefined;
+    }
+  }
+}

package/src/utils/fetch/index.ts

@@ -0,0 +1,37 @@
+import { parseHtml } from '../dom';
+
+export const MOBILE_UA = {
+  'User-Agent': [
+    'Mozilla/5.0 (Linux; Android 10; K)',
+    'AppleWebKit/537.36 (KHTML, like Gecko)',
+    'Chrome/114.0.0.0 Mobile Safari/537.36',
+  ].join(' '),
+} as const;
+
+export async function fetchWith<T extends JSON | string | HTMLElement>(
+  input: RequestInfo | URL,
+  options: {
+    init?: RequestInit;
+    type: 'json' | 'html' | 'text';
+    mobile?: boolean;
+  },
+): Promise<T> {
+  const requestInit: RequestInit = options.init || {};
+
+  if (options.mobile) {
+    Object.assign(requestInit, { headers: new Headers(MOBILE_UA) });
+  }
+
+  const r = await fetch(input, requestInit).then((r) => r);
+
+  if (options.type === 'json') return (await r.json()) as T;
+  if (options.type === 'html') return parseHtml(await r.text()) as T;
+  return (await r.text()) as T;
+}
+
+export const fetchJson = (input: RequestInfo | URL) =>
+  fetchWith<JSON>(input, { type: 'json' });
+export const fetchHtml = (input: RequestInfo | URL) =>
+  fetchWith<HTMLElement>(input, { type: 'html' });
+export const fetchText = (input: RequestInfo | URL) =>
+  fetchWith<string>(input, { type: 'text' });

package/src/utils/math/index.ts

@@ -0,0 +1,3 @@
+export function circularShift(n: number, c = 6, s = 1): number {
+  return (n + s) % c || c;
+}

package/src/utils/objects/index.ts

@@ -0,0 +1,9 @@
+export { memoize } from './memoize';
+
+export function objectToFormData<T extends {}>(obj: T): FormData {
+  const formData = new FormData();
+  Object.entries(obj).forEach(([k, v]) => {
+    formData.append(k, v as string);
+  });
+  return formData;
+}

package/src/utils/objects/memoize.ts

@@ -0,0 +1,25 @@
+import type { AnyFunction } from '../../types';
+
+export interface MemoizedFunction<T extends AnyFunction> extends CallableFunction {
+  (...args: Parameters<T>): ReturnType<T>;
+  clear: () => void;
+}
+
+export function memoize<T extends AnyFunction>(fn: T): MemoizedFunction<T> {
+  const cache = new Map<string, ReturnType<T>>();
+
+  const memoizedFunction = ((...args: Parameters<T>): ReturnType<T> => {
+    const key = JSON.stringify(args);
+
+    if (cache.has(key)) {
+      return cache.get(key) as ReturnType<T>;
+    }
+
+    const result = fn(...args);
+    cache.set(key, result);
+
+    return result;
+  }) as MemoizedFunction<T>;
+
+  return memoizedFunction;
+}