gm-extra/dist/index.mjs

gm-extra

// src/async_query.ts
async function querySelector(root, selectors, options) {
  const node = root.querySelector(selectors);
  if (node) {
    return node;
  }
  return new Promise((res) => {
    let task = void 0;
    const observer = new MutationObserver((mutationList) => {
      for (const mutation of mutationList) {
        if (mutation.target instanceof Element) {
          const node2 = mutation.target.querySelector(selectors);
          if (node2) {
            observer.disconnect();
            window.clearTimeout(task);
            return res(node2);
          }
        }
      }
    });
    observer.observe(root, {
      attributes: true,
      childList: true,
      subtree: true
    });
    if (options?.timeout !== void 0) {
      task = window.setTimeout(
        () => {
          observer.disconnect();
          res(null);
        },
        options?.timeout
      );
    }
  });
}
async function querySelectorAll(root, selectors, options) {
  const nodes = root.querySelectorAll(selectors);
  if (nodes.length > 0) {
    return nodes;
  }
  return new Promise((res) => {
    let task = void 0;
    const observer = new MutationObserver((mutationList) => {
      for (const mutation of mutationList) {
        if (mutation.target instanceof Element) {
          const nodes2 = mutation.target.querySelectorAll(selectors);
          nodes2.length;
          if (nodes2.length > 0) {
            observer.disconnect();
            window.clearTimeout(task);
            return res(nodes2);
          }
        }
      }
    });
    observer.observe(root, {
      attributes: true,
      childList: true,
      subtree: true
    });
    if (options?.timeout !== void 0) {
      task = window.setTimeout(
        () => {
          observer.disconnect();
          const nodes2 = document.createDocumentFragment().childNodes;
          res(nodes2);
        },
        options?.timeout
      );
    }
  });
}

// src/axios.ts
import { GM_xmlhttpRequest } from "vite-plugin-monkey/dist/client";

// src/util.ts
import { GM_info } from "vite-plugin-monkey/dist/client";
var delay = async (n = 0) => new Promise((res) => {
  setTimeout(res, n);
});
var lazy = (fn) => {
  let temp = void 0;
  let o = {
    get k() {
      if (temp === void 0) {
        temp = fn();
      }
      return temp;
    }
  };
  const wm = lazyValue(() => /* @__PURE__ */ new WeakMap());
  return new Proxy({}, {
    get(_, p, receiver) {
      const v = Reflect.get(o.k, p, receiver);
      if (typeof v == "function") {
        const f = v;
        let fBind = wm.value.get(f);
        if (fBind === void 0) {
          fBind = f.bind(o.k);
          wm.value.set(f, fBind);
        }
        return fBind;
      }
      return v;
    },
    set(_, p, newValue, receiver) {
      return Reflect.set(o.k, p, newValue, receiver);
    },
    has(_, p) {
      return Reflect.has(o.k, p);
    },
    ownKeys() {
      return Reflect.ownKeys(o.k);
    },
    isExtensible() {
      return Reflect.isExtensible(o.k);
    },
    deleteProperty(_, p) {
      return Reflect.deleteProperty(o.k, p);
    },
    setPrototypeOf(_, v) {
      return Reflect.setPrototypeOf(o.k, v);
    },
    getOwnPropertyDescriptor(_, p) {
      return Reflect.getOwnPropertyDescriptor(o.k, p);
    },
    defineProperty(_, property, attributes) {
      return Reflect.defineProperty(o.k, property, attributes);
    },
    getPrototypeOf() {
      return Reflect.getPrototypeOf(o.k);
    },
    preventExtensions() {
      return Reflect.preventExtensions(o.k);
    },
    apply(_, thisArg, argArray) {
      return Reflect.apply(o.k, thisArg, argArray);
    },
    construct(_, argArray, newTarget) {
      return Reflect.construct(o.k, argArray, newTarget);
    }
  });
};
var lazyValuePlaceholder = {};
var lazyValue = (fn) => {
  let temp = lazyValuePlaceholder;
  return {
    get value() {
      if (temp === lazyValuePlaceholder) {
        temp = fn();
      }
      return temp;
    }
  };
};
var parseHeaders = (rawHeaders = "") => {
  const headers = new Headers();
  const preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, " ");
  preProcessedHeaders.split("\r").map(function(header) {
    return header.startsWith(`
`) ? header.substring(1) : header;
  }).forEach(function(line) {
    let parts = line.split(":");
    let key = parts.shift()?.trim();
    if (key) {
      let value = parts.join(":").trim();
      headers.append(key, value);
    }
  });
  return headers;
};
var fixUrl = (url = "") => {
  try {
    return url === "" && location.href ? location.href : url;
  } catch {
    return url;
  }
};
var headersToObj = (headers) => {
  const obj = {};
  headers.forEach((value, key) => {
    obj[key] = value;
  });
  return obj;
};
var reverseForm = (formData) => {
  const reversedForm = new FormData();
  const reversedList = [];
  formData.forEach((v, k) => {
    reversedList.push([k, v]);
  });
  reversedList.reverse().forEach(([k, v]) => {
    reversedForm.append(k, v);
  });
  return reversedForm;
};
var compatForm = (formData, headers) => {
  headers.delete(`content-type`);
  if (GM_info.scriptHandler == `Tampermonkey`) {
    return reverseForm(formData);
  }
  return formData;
};

// src/axios.ts
var gmAxiosAdapter = async (config) => {
  const u = new URL(config.url ?? ``, config.baseURL);
  if (config.params) {
    for (const k in config.params) {
      const v = config.params[k];
      if (v !== void 0) {
        u.searchParams.set(k, String(v));
      }
    }
  }
  const headers = config.headers.toJSON(true);
  const event = await new Promise((res, rej) => {
    GM_xmlhttpRequest({
      method: config.method,
      url: u.href,
      headers,
      data: config.data,
      timeout: config.timeout,
      responseType: config.responseType,
      onload: res,
      onerror: rej
    });
  });
  return {
    status: event.status,
    statusText: event.statusText,
    headers: headersToObj(parseHeaders(event.responseHeaders)),
    data: event.response || event.responseText,
    config
  };
};

// src/fetch.ts
import {
  GM_xmlhttpRequest as GM_xmlhttpRequest2
} from "vite-plugin-monkey/dist/client";
var gmFetch = async (input, init = {}, xhrDetails = {}) => {
  const request = new Request(input, init);
  if (request.signal?.aborted) {
    throw new DOMException("Aborted", "AbortError");
  }
  const method = request.method.toUpperCase();
  const url = fixUrl(request.url);
  const sendHeaders = new Headers(request.headers);
  new Headers(init.headers).forEach((value, key) => {
    sendHeaders.set(key, value);
  });
  let binary = false;
  let data = void 0;
  if (method != "GET") {
    if (init.body) {
      if (init.body instanceof FormData) {
        data = compatForm(init.body, sendHeaders);
      } else if (typeof init.body == "string" || init.body instanceof URLSearchParams) {
        data = init.body;
      } else {
        binary = true;
        data = await request.blob();
      }
    } else {
      const formData = await request.clone().formData().catch(() => {
      });
      if (formData) {
        data = compatForm(formData, sendHeaders);
      }
    }
  }
  return new Promise((resolve, reject) => {
    let initXhrDetails = {
      method,
      url,
      headers: headersToObj(sendHeaders),
      data,
      binary,
      responseType: "blob",
      async onload(event) {
        let body = void 0;
        if (!(event.response instanceof Blob && event.response.size == 0)) {
          body = event.response ?? event.responseText;
        }
        await delay();
        const resp = new Response(body, {
          status: event.status,
          statusText: event.statusText,
          headers: parseHeaders(event.responseHeaders)
        });
        Object.defineProperty(resp, "url", { value: event.finalUrl });
        resolve(resp);
      },
      async onerror() {
        await delay();
        reject(new TypeError("Network request onerror failed"));
      },
      async ontimeout() {
        await delay();
        reject(new TypeError("Network request ontimeout failed"));
      },
      async onabort() {
        await delay();
        reject(new DOMException("Aborted", "AbortError"));
      },
      async onreadystatechange(event) {
        if (event.readyState === 4) {
          request.signal?.removeEventListener("abort", abortXhr);
        }
      }
    };
    if (typeof xhrDetails == "function") {
      initXhrDetails = xhrDetails(initXhrDetails);
    } else {
      initXhrDetails = { ...initXhrDetails, ...xhrDetails };
    }
    const handle = GM_xmlhttpRequest2(initXhrDetails);
    function abortXhr() {
      handle.abort();
    }
    request.signal?.addEventListener("abort", abortXhr);
  });
};

// src/intercept_all.ts
var _TODO = void 0;

// src/intercept_fetch.ts
import { monkeyWindow } from "vite-plugin-monkey/dist/client";
var produceChain = (originalFetch, interceptors, request, index = 0) => {
  return {
    request,
    proceed: async (req = request) => {
      while (index < interceptors.length) {
        const target = interceptors[index];
        if (target) {
          const chain = produceChain(
            originalFetch,
            interceptors,
            req,
            index + 1
          );
          return await target(chain);
        }
        index++;
      }
      return originalFetch(req);
    }
  };
};
var buildFetchInterceptorManager = (originalFetch) => {
  const interceptors = [];
  const fakeFetch = async (input, init) => {
    return produceChain(
      originalFetch,
      [...interceptors],
      new Request(input, init)
    ).proceed();
  };
  return {
    originalFetch,
    fakeFetch,
    use: (interceptor) => {
      interceptors.push(interceptor);
      return interceptors.length - 1;
    },
    eject: (id) => {
      interceptors[id] = null;
    },
    clear: () => {
      for (let i = 0; i < interceptors.length; i++) {
        interceptors[i] = null;
      }
    }
  };
};
var UnsafeWindowInterceptorManager = /* @__PURE__ */ lazy(() => {
  const t = buildFetchInterceptorManager(monkeyWindow.unsafeWindow.fetch);
  monkeyWindow.unsafeWindow.fetch = t.fakeFetch;
  return t;
});

// src/intercept_xhr.ts
var fakeXhr = (XMLHttpRequestLike) => {
  return class FakeXMLHttpRequest extends XMLHttpRequestLike {
    _method = "GET";
    _url = new URL(location.origin);
    _reqHeaders = new Headers();
    open(method, url, async = true, username, password) {
      const u = new URL(url, location.pathname);
      if (username) {
        u.username = username;
      }
      if (password) {
        u.password = password;
      }
      this._url = u;
      this._method = method;
      return super.open(method, url, async, username, password);
    }
    setRequestHeader(name, value) {
      this._reqHeaders.append(name, value);
    }
    async send(body = null) {
      let bd = body;
      if (bd && bd instanceof Document) {
        bd = new Blob([new XMLSerializer().serializeToString(bd)], {
          type: bd.contentType
        });
      }
      let req = new Request(this._url, {
        headers: this._reqHeaders,
        method: this._method,
        body: bd,
        credentials: this.withCredentials ? `include` : `omit`
      });
      req.headers.forEach((value, key) => {
        this.setRequestHeader(key, value);
      });
      if (req.body) {
        return super.send(await req.blob());
      }
      return super.send();
    }
    // _responseType: XMLHttpRequestResponseType = '';
    // get responseType(): XMLHttpRequestResponseType {
    //   return 'blob';
    // }
    // set responseType(value: XMLHttpRequestResponseType) {
    //   this._responseType = value;
    // }
    _onreadystatechange = null;
    _onload = null;
    get onload() {
      return this._onload;
    }
    set onload(value) {
      if (value === null) {
        this._onload = null;
      } else {
        this._onload = async (ev) => {
          const resp = new Response(this.response ?? this.responseText, {
            status: this.status,
            statusText: this.statusText,
            headers: parseHeaders(this.getAllResponseHeaders() || ``)
          });
          Object.defineProperty(resp, "url", {
            value: this.responseURL ?? this.getResponseHeader(`X-Request-URL`)
          });
          const blob = await resp.blob();
          if (this.responseType == "text" || this.responseType == "") {
          } else if (this.responseType == "arraybuffer") {
          } else if (this.responseType == "blob") {
          } else if (this.responseType == "json") {
          } else if (this.responseType == "document") {
          }
          value.call(this, ev);
        };
      }
    }
  };
};
var buildXhrInterceptorManager = () => {
  fakeXhr.apply;
};
export {
  UnsafeWindowInterceptorManager,
  _TODO,
  buildFetchInterceptorManager,
  buildXhrInterceptorManager,
  gmAxiosAdapter,
  gmFetch,
  querySelector,
  querySelectorAll
};
//# sourceMappingURL=index.mjs.map