API tools faq
paste
xiaomianao666

插件名：global_Javlibrary-首页一站式影片预览

xiaomianao666
May 18th, 2024
270
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 199.14 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：网页插件￥js_url￥global_Javlibrary-首页一站式影片预览@base64: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
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!