AI Character Group Chat

education learning

technology software

documentation technical

forum community discussion

social media network

English

_ga_YJWJRNESS5

cf_clearance

_gid

Domain 'perchance.org' uses the non-profit oriented generic top-level domain (.org) while skipping any subdomain. Its registrable label 'perchance' stretches across 9 characters split between three vowels and six consonants. It segments into 1 word: perchance. Expect nine characters per word on average. No strong language cues emerged from the frequency lists.

html/98/39/9839f96e-893d-4fe3-9e0e-9cc114e89fbb.html.gz

script-src 'unsafe-eval' 'self' 'unsafe-inline' https://www.google.com https://apis.google.com https://ssl.gstatic.com https://www.gstatic.com https://www.googletagmanager.com https://www.google-analytics.com https://*.youtube.com https://*.google.com https://*.gstatic.com https://youtube.com https://www.youtube.com https://google.com https://*.doubleclick.net https://*.googleapis.com https://www.googleadservices.com https://tpc.googlesyndication.com https://www.youtubekids.com https://www.youtube-nocookie.com https://www.youtubeeducation.com https://www-onepick-opensocial.googleusercontent.com;report-uri https://csp.withgoogle.com/csp/youtube_other/allowlist
require-trusted-types-for 'script'

report-uri https://csp.withgoogle.com/csp/youtube_other/strict;base-uri 'self';object-src 'none';script-src 'report-sample' 'nonce-aEmC_wO9CkeW0lZpqEWemg' 'unsafe-inline' 'strict-dynamic' https: http: 'unsafe-eval'

require-trusted-types-for 'script'; report-uri https://csp.withgoogle.com/csp/youtube-main-app-web-scs-key

require-trusted-types-for 'script'; report-uri https://csp.withgoogle.com/csp/apps-themes

4b77eae349a8cbcea7133cf3640a64ebf1f69d54d8f6469d7be6fdc188ca4ca4

76462d894e5b6dcbc33a94a6ed321e7d2d6f1c581a5dc9ab3c73ec68336db928

971b7ad26e10f332e4907938befa63023fc55801c61873689aa549471da4a5f3

126548ba98f98cb7fdd87c945b6a6b6e4bf6091d1fdae640062ee8bb046289ed

23082641bffdaa0f85f53ad9fc7eaca7c509ad8b7066e4921c3bcfdb0c74c859

01d6517112ecb6339ff6726268a361aebdbbf9b27f27656f6db607f233d505b1

5fd8aab38aef5cca6f1f9d523ddff68557e6b60b7fd4744c732f7dfc9722d3ae

66e37ec6728c2a1bfd24d4c6b74f487a9575ae91bb631d5a671b602048a4ff33

7f74aea1299f79490ee9957befb8e4b7fe64ee0d42ec5378b58f00697806a271

f1a61277e3f902f50ab42015d8b07218db9b7601bb0967e54a52bfdcb4fa7e81

script-src 'none'; form-action 'none'; frame-src 'none'; report-uri https://csp.withgoogle.com/csp/scaffolding/ascnsrsgac:225:0

a7f4c4f90a2842bdb4d248cd7d6ca810ef59377dfa0f22ce7aa9a72213f1f48b

f3c3bc94577712579a987f2be70c26aa5890de625e181d8be898d1ced9f8eab4

9a243a7a644b4601b488b0f7fd81243baf8f9cc4674cc5f20dcf95d8843cb835

4da290a040e193cc9f58aea080e4f918a3697888239688238ad1824bf10bd653

c17c185c7afecadc6eee2a014952e536c1691cca9e5e6fdc50a71c15bd2175a0

1c6c3eecabae78f19caef41e17c72f334cdde3f2f7b9be37f348934c33022731

90f11f3a49f8e561e24379f73e3631e42f611b2fe75fc5434d6e512a59aa941d

b6b270100c27f2fb665d9e1b124b9de305f4ae045686d77969f76c9e5fc94a25

60652802eb9cea34477875b27876b6ae298adfd2a79a955d9367e2184749a345

d1313c2bf03f062b4c22557f456c144c5c64c607fe8257f13ab09496d32bb8c8

89a2c2c78a8693caa3251a9cc6d32e1644c87cccd245f3efdf265d95a23b6268

c034cc5f2734a6198503ba4f8262e03c71157e8f5569ac642288e0ad22b158c3

845ac82f787da523385c5a2ac204139733e7b8d1727e9e9a5e99038352014276

9a033b992507530ef3980b5eade658947bbb6d3d2c065df6d4f2e3c1c371bf71

856fc614ec19174f10963e9b690b862c641cab770804ee2989a4c34c6538162d

e5962a23de42707d8f9c4c44e28b6c9cf1ca9016279bb33e3214946fab000c4e

2b0a4ade95953008878986371028da810840b8334e4f06f4cc5be84a2a0c7d6d

e0a76087e0f00de94b5f7c483f04595622c49ad27d1931e7c41055769c3262b0

eade29fbda50fc390b7106b2ba9b7d5e157f08beb28c96c19dfa164a106e5713

9f5bf5b6aaa3edfee27aa31dd1f1571058f13df1992c809c347f809fe84b63d6

a4e319567946ec11ccf1ae907a8e4e348d33cbc3917a2b747a759b564b52ba58

b77c8d394959b303dfba97074bc5272cf1ca2efd6d4b4f54c181a6a03d25f384

41bef70bf2562159cbcbfb0de420b56b2feaea009ad086c43646d8c8f0c84fa9

c2332c458ae218accf0ef957a942ff84183afec1dc9e9269371cb2673ece1728

3f0e897b4dd6f6941d67f881e196efbe6688992e909f724101c493732c6c70d8

6278e984550417c07c7bddeb2388d714af25dbc67e4c8557d39ab666f103246d

3d284dece8032fcaa3e296385ab7775403e2ac8111223df49798af97fac292e6

a339ca3b85b502e5efacd4ecebd64a06f32ec801599f5a124481f6e85796b488

ed57bf07dfbf2b124dcee26b586afc46a1fb1eefaa2b7b8cca7096eceef75421

f1190a7ec6e515fdc6de3a239b97a451dd3cc25e694b1c828a47703409d65e13

ef44287cbf4cfc7b2e534dd2eb26cf659ff2d3b47d54af0dfc2312f83d53a486

22c6765df4e6fab92e520e2843f2a0ac57dc8ff381398f4e2d68015017f755d5

21c2f51f1e7fcf3b0d236a9d41c135490a88279cdde2a0fbe28b37e28f2d081b

2482c52c3093e9b38359f30ce5426a0a0523b72805b56528ae6c552b0eaf9217

3789a9b21b5cb91177fec06fb19eea622ca50b00ba92111bcccce6877d46f7f8

41302c9f6f5e73a95efb7c9a618592deb3f7371df20bfd6c59c8a1ea2e4d7a1f

f01b7648873e943899d6317ce3fd229fc99152ef0811c7aec0bb0e2c0f0d0de1

ae860ee60e0dfc471278de04a1f322cceeefc54d474310496c4d5acccc5ae734

753b9c0291a5d2f7177d65866fd7b334b545cbfeff657cc2508a1220a0d3751e

1812f071752827fb55f46b6ffdde0aac9e7aa4f9497d8dc072d2b65ae0fc6c27

a715339653fac24e8b5d9dc405241af8857d0673929b09e272544bb9e8fad80d

a54bfe80daa9fa0337d1767b3517bc9fc5d7b22e24bd932c6d097d1469fad050

2ae2d8b1874bf89e68a0174509105f38b05df51b3dc2504b5e4a826e6e272810

4e7dc4621cd2285a2e268185a63e23320f3ae5e37b4eecc0601f7dbe8fd8b3b3

b79e7f87119cc90c7d84a46f3dcc5548c0ddffd6bea86d6a219da5dc5a62dbe8

8676023a04cd8b9d5affe5c46594b1fe7cf72ba101b7b08601eb9d0e285e6667

8d07574a389d35b98162edde1bb6093e259698b3036e578902da368a04809938

be286b7da777668c6cc650f69a533a4f9d90a9e45242fc457947e8b318f22b25

db4b54ea8dbeb1f61a38422a109474659fc48dd11f75580f8d4d382d05df29f5

aec399d384e6d8f003fa22035a928aad310ff06dd0069bc22c2c40171e5e7bcf

75f1f37db27e40bde0a948b3aa5c8bff9d4c9993aa5c2d7657eb0be8c2d8e61f

cde55e3e340a704481170e36e76f0b73edd5f4ff914326d99ccc31c73631f0a1

1f6378cdc2dc146cd509765177924293ea9443ed2721e9add786e8a9b683692e

b4a94042448d3660012509022625eafcf5002257f4975f44f416598913cb059d

c463f085b6fdd8fd12e7fd896a6d6e5dc8b0d1657087e399b2de158fc192817a

6443464affeb5e5416a9d0e1b43dd1cf65e68aefb7a5d3c20a67964262ca83c0

db28b2c28554f3389a033eca6b608c85a6c55f1fd5137cf3b93360b618b647d5

696f47eb34501d49edd456061aa1978e90270aaa3241124aca569b844ddfcfa8

1dd4838679db1f8a3c7f0f9da93f81dffc2c0e28d00b87c75cbd8eefb29c42ed

14b1ca9e86717b9526e772bf58401382e35c0481615207a27c61fd8c1d0ec719

0a0f00e11941dde85f799a831102a97832eb04667cdba3d4e47f094330d62b3e

56bae198675479977766d1f494924d75a92d844bca3f24405feb1f570aaf788b

066d247d06d227e0cebe2e2b4cc0dcc64bd242a4d8517e1025ae67c69b1b1fcf

3cfc2136d1ac9265965866e13641fc5b3cdcce109808ec3bab70da42228368f2

Perchance AI Group Chat - completely free, online, no login, unlimited messages, unlimited AI-generated images. Chat with AI characters via this Character.AI (C.AI) chat alternative. Custom AI character creation. There's no filter - chats are SFW unless you prompt your character to not be (you are responsible for what you prompt - just like with a Google search, for example). Chat to the default Chloe character, or make your own AI character and talk to them freely - no limits, and no freemium gimicks that lure you to sign up. Completely unlimited. You can create characters that can send pictures/images/photos, roleplay chatbots, AI RPGs/D&D experiences, an AI Dungeon alternative, anime AI chat, and basically anything else you can think of. No restrictions on daily usage. Like ChatGPT, but for fictional character RPs and AI characters, with image generation in chat.

description

width=device-width, initial-scale=1, interactive-widget=resizes-content

viewport

color-scheme

html/98/39/9839f96e-893d-4fe3-9e0e-9cc114e89fbb_nodriver.html.gz

Just a moment...

Cloudflare, Inc.

perchance.org

Abuse

Google LLC

GOOGLE


          if(!Array.prototype.at) {
            window.addEventListener("error", function(message, url, linenumber) {
              console.warn(`JavaScript error: ${message} on line ${linenumber} for ${url}`, message, url, linenumber);
            });
          }
        


          window.TEST_NEW_EDITOR_1 = true; // localStorage.TEST_NEW_EDITOR_1; 

          // preload the editor bundle if we're going to need it
          if(window.TEST_NEW_EDITOR_1 && /^#edit($|:)/.test(window.location.hash)) {
            window.editorBundleImportPromise = import("/lib/editors.bundle.min.js?v=77");
          }
          
          setTimeout(() => {
            if(window.TEST_NEW_EDITOR_1 && !window.editorBundleImportPromise) window.editorBundleImportPromise = import("/lib/editors.bundle.min.js?v=77");
          }, 20*1000);
        


          {
            // attempt at solving virtual keyboard causing top-level scroll in mobile:
            // let viewport = document.querySelector("meta[name=viewport]");
            // viewport.setAttribute("content", viewport.content + `, height=${window.innerHeight}`);

            // window.visualViewport.addEventListener('resize', function (event) {
            // });

            // doesn't work properly - causes momentary screen jumping/flashing on keyboard close
            // if("virtualKeyboard" in navigator) {
            //   navigator.virtualKeyboard.overlaysContent = true;
            // }
          }
        


          window.name = window.location.pathname; // for Notification.onclick to not open a new window if that generator is open already
        


          {
            // let idbKeyval = await import("https://cdn.jsdelivr.net/npm/idb-keyval@6/+esm");
            let idbKeyval = (function() { // This is v6.2.1
              function e(e){return new Promise(((t,n)=>{e.oncomplete=e.onsuccess=()=>t(e.result),e.onabort=e.onerror=()=>n(e.error)}))}function t(t,n){const r=indexedDB.open(t);r.onupgradeneeded=()=>r.result.createObjectStore(n);const o=e(r);return(e,t)=>o.then((r=>t(r.transaction(n,e).objectStore(n))))}let n;function r(){return n||(n=t("keyval-store","keyval")),n}function o(t,n=r()){return n("readonly",(n=>e(n.get(t))))}function u(t,n,o=r()){return o("readwrite",(r=>(r.put(n,t),e(r.transaction))))}function c(t,n=r()){return n("readwrite",(n=>(t.forEach((e=>n.put(e[1],e[0]))),e(n.transaction))))}function s(t,n=r()){return n("readonly",(n=>Promise.all(t.map((t=>e(n.get(t)))))))}function a(t,n,o=r()){return o("readwrite",(r=>new Promise(((o,u)=>{r.get(t).onsuccess=function(){try{r.put(n(this.result),t),o(e(r.transaction))}catch(e){u(e)}}}))))}function i(t,n=r()){return n("readwrite",(n=>(n.delete(t),e(n.transaction))))}function l(t,n=r()){return n("readwrite",(n=>(t.forEach((e=>n.delete(e))),e(n.transaction))))}function f(t=r()){return t("readwrite",(t=>(t.clear(),e(t.transaction))))}function d(t,n){return t.openCursor().onsuccess=function(){this.result&&(n(this.result),this.result.continue())},e(t.transaction)}function h(t=r()){return t("readonly",(t=>{if(t.getAllKeys)return e(t.getAllKeys());const n=[];return d(t,(e=>n.push(e.key))).then((()=>n))}))}function y(t=r()){return t("readonly",(t=>{if(t.getAll)return e(t.getAll());const n=[];return d(t,(e=>n.push(e.value))).then((()=>n))}))}function p(t=r()){return t("readonly",(n=>{if(n.getAll&&n.getAllKeys)return Promise.all([e(n.getAllKeys()),e(n.getAll())]).then((([e,t])=>e.map(((e,n)=>[e,t[n]]))));const r=[];return t("readonly",(e=>d(e,(e=>r.push([e.key,e.value]))).then((()=>r))))}))}
              return {clear:f,createStore:t,del:i,delMany:l,entries:p,get:o,getMany:s,keys:h,set:u,setMany:c,update:a,values:y};
            })();
            const storeCache = {};
            window.kv = new Proxy(idbKeyval, { // so api is like: kv.myStoreName.get(...)
              get(target, prop, receiver) {
                if(!storeCache[prop]) storeCache[prop] = idbKeyval.createStore(`${prop}-db`, `${prop}-store`); // <-- creates only if it doesn't already exist
                const store = storeCache[prop];
                return {
                  get: (key) => idbKeyval.get(key, store),
                  set: (key, value) => idbKeyval.set(key, value, store),
                  delete: (key) => idbKeyval.del(key, store),
                  entries: () => idbKeyval.entries(store),
                  clear: () => idbKeyval.clear(store),
                };
              },
            });
          }
        


          // document.documentElement.style.height = controlHeightEl.clientHeight+"px";
          
          window.advertHeight = window.innerWidth > 700 ? 90 : 50; 

          // document.documentElement.style.height = `height:calc(100lvh + var(--menu-bar-height) + 1px)`;
          // function updateMainElHeight() {
          //   document.querySelector("#editorEl #main").style.height = `calc(100dvh - ${menuBarEl.offsetHeight - Math.abs(menuBarEl.getBoundingClientRect().top)}px - ${window.advertHeight+4+4}px)`;
          //   console.debug(document.querySelector("#editorEl #main").style.height)
          // }
          // window.addEventListener("scroll", updateMainElHeight);

          {
            const viewportMetaEl = document.querySelector('#viewportMetaEl');
            const originalViewportMetaContent = viewportMetaEl.getAttribute("content");
            let lastChangeTime = Date.now();
            const observer = new MutationObserver(mutations => {
              mutations.forEach(m => {
                if(m.type === 'attributes' && Date.now() - lastChangeTime > 2000) {
                  lastChangeTime = Date.now();
                  console.log("🚩🚩🚩 viewport meta tag content attribute was changed.");
                  viewportMetaEl.setAttribute("content", originalViewportMetaContent);
                  window.queuedStatCountKeys.add("viewport-mtc");
                }
              })
            });
            observer.observe(viewportMetaEl, { attributes: true, attributeFilter: ['content'] });
          }
        


          // 'polyfill' Safari's lack of support for interactive-widget=resizes-content on
          // EDIT: disabled because causes weird scroll jank issues
          // {
          //   let isTouchScreen = window.matchMedia("(pointer: coarse)").matches;
          //   if(isTouchScreen) {
          //     let shouldTriggerResizeBarrage = true;
          //     function handler() {
          //       if(!shouldTriggerResizeBarrage) return;
          //       shouldTriggerResizeBarrage = false;
          //       async function doResize() {
          //         // console.debug("doResize1", window.visualViewport.pageTop, window.visualViewport.height, document.documentElement.offsetHeight)
          //         shouldTriggerResizeBarrage = false; // just to be safe
          //         if(window.visualViewport.pageTop <= 1 && Math.abs(window.visualViewport.height - document.documentElement.offsetHeight) <= 2) return;
          //         console.debug("scrolling/resizing", window.visualViewport.pageTop, window.visualViewport.height, document.documentElement.offsetHeight);
          //         // for whatever reason, this is needed, since otherwise the scrollTo(0,0) doesn't work. Safari sucks.
          //         window.scrollTo(0,1);
          //         document.documentElement.style.height = window.visualViewport.height+"px";
          //         window.scrollTo(0,1);
          //       }
          //       let interval = setInterval(doResize, 100);
          //       doResize();
          //       setTimeout(() => {
          //         clearInterval(interval);
          //         doResize();
          //         setTimeout(() => shouldTriggerResizeBarrage=true, 50);
          //       }, 600);
          //     }
          //     window.addEventListener('scroll', handler);
          //     visualViewport.addEventListener('scroll', handler);
          //     visualViewport.addEventListener('resize', handler);
          //   }
          // }
        

window.mdded4sfef4dsedddse1d34344 = `Error: Ad blocker preventing proper page load?`;


          window.js0nparse = JSON.parse;
        


        // COMPATABILITY TESTING:
        window.canExecuteModernJavascript = true;
        try {

          var str = "";
          str += "\n(async () => { await new Promise(resolve => setTimeout(resolve, 500)); console.debug('async/await is supported'); })();";
          str += "\nlet arr = [1,2,3]; for(let a of arr) { arr[0]+=a; }; console.debug('let a of arr supported');";
          str += "\nvar m = [1,2,3].map(n => n+1);";
          str += "\nvar k = [...[1,2,3]];";
          str += "\nvar a = (function(a=3) { return a+1; })();";

          window.eval(str);

        } catch(e) {
          window.canExecuteModernJavascript = false;
          // var message = "<div style='overflow:hidden;height:0px;'><h1>Create a Random Generator</h1><p>Perhance is a platform that allows you to create your own custom random generators. You could use it to create your own random text generator for a tabletop RPG, or to make your own random name generator, or to simply create a generator which selects a random item from your list with different weights. You can also save your generator so it has a permalink that you can share with your friends.</p><p>Perchance is based around creating lists which reference other lists. You can adjust the odds of items in each list so that when you randomly select an item from that list, they all have the likelihoods that you've specified. If you'd like to learn how to make a random text generator with Perchance, you should check out the tutorial. It explains all the basic features of the Perchance engine and should get you up and running in only 10 or 20 minutes. Perchance has many powerful features that you don't need to learn from the start, but can learn later if you want to create particularly complex generators.</p><p>I created Perchance because most people are still creating random generators in excel. Those work all right, but excel and other spreadsheets aren't really made for that purpose, so there's a lot to be desired in terms of functionality and ease of use. Whatever you're using it for, I hope you find Perchance useful! You might like to check out our <a href='http://reddit.com/r/perchance'>community forum</a> where you can ask questions and share your random generator creations.</p></div>(」ﾟﾛﾟ)｣ Sorry! Perchance uses cutting edge browser features that are only available in the latest versions of Chrome and Firefox. All modern browsers will eventually be supported, but for now you'll need to use one of those two. Sorry again for the inconvenience!";
          // //window.alert(message);
          // document.body.innerHTML = message; 
        }
        

%7B%22name%22:%22tps-ai-character-chat-groupchat%22,%22modelText%22:%22aiTextPlugin%20=%20%7Bimport:ai-text-plugin%7D%5CntextToImagePlugin%20=%20%7Bimport:text-to-image-plugin%7D%5CncommentsPlugin%20=

%5B%7B%22name%22:%22ai-text-plugin%22,%22modelText%22:%22$output(inputData,%20extraOpts)%20=%3E%5Cn%5Cn%20%20const%20serverOrigin%20=%20%5C%22https://text-generation.perchance.org%5C%22;%5Cn%20%20%5Cn

%5B%22ai-text-plugin%22,%22bug-report-plugin%22,%22combine-emojis-plugin%22,%22comments-plugin%22,%22fullscreen-button-plugin%22,%22huge-emoji-list%22,%22super-fetch-plugin%22,%22tabbed-comments-plugin-v1%22,%22text-to-image-plugin%22,%22tps-ai-image-generator%22,%22tps-text-to-image-framework%22,%22upload-plugin%22,%22dynamic-import-plugin%22,%22animal%22,%22t2i-styles%22,%22prompt2-plugin%22,%22select-leaf-plugin%22,%22simple-gen-footer%22%5D

%7B%22title%22:%22AI%20Character%20Group%20Chat%22,%22description%22:%22Perchance%20AI%20Group%20Chat%20-%20completely%20free,%20online,%20no%20login,%20unlimited%20messages,%20unlimited%20AI-generated%20images.%20Chat%20with%20AI%20characters%20via%20this%20Character.AI%20(C.AI)%20chat%20alternative.%20Custom%20AI%20character%20creation.%20There's%20no%20filter%20-%20chats%20are%20SFW%20unless%20you%20prompt%20your%20character%20to%20not%20be%20(you%20are%20responsible%20for%20what%20you%20prompt%20-%20just%20like%20with%20a%20Google%20search,%20for%20example).%20Chat%20to%20the%20default%20Chloe%20character,%20or%20make%20your%20own%20AI%20character%20and%20talk%20to%20them%20freely%20-%20no%20limits,%20and%20no%20freemium%20gimicks%20that%20lure%20you%20to%20sign%20up.%20Completely%20unlimited.%20You%20can%20create%20characters%20that%20can%20send%20pictures/images/photos,%20roleplay%20chatbots,%20AI%20RPGs/D&D%20experiences,%20an%20AI%20Dungeon%20alternative,%20anime%20AI%20chat,%20and%20basically%20anything%20else%20you%20can%20think%20of.%20No%20restrictions%20on%20daily%20usage.%20Like%20ChatGPT,%20but%20for%20fictional%20character%20RPs%20and%20AI%20characters,%20with%20image%20generation%20in%20chat.%22,%22image%22:%22%22,%22header%22:%7B%22mode%22:%22minimal%22%7D,%22dynamic%22:%22async%20function%20dynamic(inputs)%20%20%7B%5Cn%20%20%20%20let%20defaults%20=%20%7B%5Cn%20%20%20%20%20%20title:%20%60AI%20Character%20Group%20Chat%60,%5Cn%20%20%20%20%20%20description:%20%60Perchance%20AI%20Group%20Chat%20-%20completely%20free,%20online,%20no%20login,%20unlimited%20messages,%20unlimited%20AI-generated%20images.%20Chat%20with%20AI%20characters%20via%20this%20Character.AI%20(C.AI)%20chat%20alternative.%20Custom%20AI%20character%20creation.%20There's%20no%20filter%20-%20chats%20are%20SFW%20unless%20you%20prompt%20your%20character%20to%20not%20be%20(you%20are%20responsible%20for%20what%20you%20prompt%20-%20just%20like%20with%20a%20Google%20search,%20for%20example).%20Chat%20to%20the%20default%20Chloe%20character,%20or%20make%20your%20own%20AI%20character%20and%20talk%20to%20them%20freely%20-%20no%20limits,%20and%20no%20freemium%20gimicks%20that%20lure%20you%20to%20sign%20up.%20Completely%20unlimited.%20You%20can%20create%20characters%20that%20can%20send%20pictures/images/photos,%20roleplay%20chatbots,%20AI%20RPGs/D&D%20experiences,%20an%20AI%20Dungeon%20alternative,%20anime%20AI%20chat,%20and%20basically%20anything%20else%20you%20can%20think%20of.%20No%20restrictions%20on%20daily%20usage.%20Like%20ChatGPT,%20but%20for%20fictional%20character%20RPs%20and%20AI%20characters,%20with%20image%20generation%20in%20chat.%60,%5Cn%20%20%20%20%7D;%5Cn%20%20%20%20let%20fileName;%5Cn%20%20%20%20if(inputs.urlParams.data%20&&%20inputs.urlParams.data.endsWith(%5C%22.gz%5C%22))%20%7B%5Cn%20%20%20%20%20%20fileName%20=%20inputs.urlParams.data.split(%5C%22~%5C%22).slice(-1)%5B0%5D;%5Cn%20%20%20%20%7D%20else%20if(inputs.urlParams.char)%20%7B%5Cn%20%20%20%20%20%20if(inputs.urlParams.char%20===%20%5C%22assistant%5C%22)%20%7B%5Cn%20%20%20%20%20%20%20%20return%20%7B%5Cn%20%20%20%20%20%20%20%20%20%20title:%20%60AI%20Character%20Group%20Chat%20(online,%20free,%20no%20sign-up,%20unlimited)%60,%5Cn%20%20%20%20%20%20%20%20%20%20description:%20%60AI%20Chat%20with%20characters%20for%20roleplaying%20or%20to%20get%20help%20with%20writing,%20language%20practice,%20creative%20tasks,%20coding%20questions,%20and%20lots%20more.%20Completely%20free,%20online,%20no%20login,%20unlimited%20messages,%20unlimited%20AI-generated%20images.%20Basically%20a%20more%20creative%20(and%20unfiltered/uncensored)%20ChatGPT%20alternative.%20Chat%20to%20the%20Chloe%20or%20make%20an%20AI%20assistant/character%20and%20talk%20to%20them%20freely%20-%20no%20limits%20on%20credits,%20and%20no%20freemium%20gimicks%20that%20lure%20you%20to%20sign%20up.%20Completely%20unlimited.%20You%20can%20create%20characters%20that%20can%20send%20pictures/images/photos,%20roleplay%20chatbots,%20AI%20RPGs/D&D%20game%20masters.%20Like%20ChatGPT,%20but%20better%20at%20fictional%20character%20RPs%20and%20AI%20characters,%20with%20image%20generation%20in%20chat.%60,%5Cn%20%20%20%20%20%20%20%20%7D;%5Cn%20%20%20%20%20%20%7D%5Cn%20%20%20%20%20%20let%20urlNamedCharacters%20=%20%7B%5Cn%20%20%20%20%20%20%20%20%5C%22ai-adventure%5C%22:%20%5C%226c2f68e41de41e75a51971487c97b2d9.gz%5C%22,%5Cn%20%20%20%20%20%20%20%20%5C%22coding-assistant%5C%22:%20%5C%22570b3c67b8ed9ed8f83ef652be549b1c.gz%5C%22,%5Cn%20%20%20%20%20%20%20%20%5C%22story-writer%5C%22:%20%5C%2276b20593b117ab083d746312df4df296.gz%5C%22,%5Cn%20%20%20%20%20%20%20%20%5C%22world-war-simulator%5C%22:%20%5C%22e1cf5213432a7eb9e310ec269fe38672.gz%5C%22,%5Cn%20%20%20%20%20%20%20%20%5C%22psychologist%5C%22:%20%5C%22615fdef95fa7e75cbbaf943dc44d72be.gz%5C%22,%5Cn%20%20%20%20%20%20%20%20%5C%22therapist%5C%22:%20%5C%225cdaa39f9aabc7424c3b2e1b780a1e29.gz%5C%22,%5Cn%20%20%20%20%20%20%7D;%5Cn%20%20%20%20%20%20fileName%20=%20urlNamedCharacters%5Binputs.urlParams.char%5D;%5Cn%20%20%20%20%7D%5Cn%20%20%20%20if(fileName)%20%7B%5Cn%20%20%20%20%20%20try%20%7B%5Cn%20%20%20%20%20%20%20%20let%20fileUrl%20=%20%5C%22https://user-uploads.perchance.org/file/%5C%22%20+%20%20fileName;%5Cn%20%20%20%20%20%20%20%20let%20blob%20=%20await%20fetch(fileUrl,%20%7Bsignal:AbortSignal.timeout%20?%20AbortSignal.timeout(8000)%20:%20null%7D).then(res%20=%3E%20res.blob());%5Cn%20%20%20%20%20%20%20%20const%20ds%20=%20new%20DecompressionStream(%5C%22gzip%5C%22);%5Cn%20%20%20%20%20%20%20%20const%20decompressedStream%20=%20blob.stream().pipeThrough(ds);%5Cn%20%20%20%20%20%20%20%20let%20decompressedBlob%20=%20await%20new%20Response(decompressedStream).blob();%5Cn%20%20%20%20%20%20%20%20let%20text%20=%20await%20decompressedBlob.text();%5Cn%20%20%20%20%20%20%20%20let%20data%20=%20JSON.parse(text);%5Cn%20%20%20%20%20%20%20%20let%20character%20=%20data.addCharacter;%5Cn%20%20%20%20%20%20%20%20return%20%7B%5Cn%20%20%20%20%20%20%20%20%20%20title:%20character.metaTitle%20?%20character.metaTitle%20:%20%60$%7Bcharacter.name.slice(0,%2040)%7D%20-%20AI%20Character%20Group%20Chat%20(free,%20no%20sign-up,%20unlimited)%60,%5Cn%20%20%20%20%20%20%20%20%20%20description:%20character.metaDescription%20?%20character.metaDescription%20:%20%60Chat%20with%20the%20$%7Bcharacter.name%7D%20AI%20character.%20Here's%20this%20character's%20description:%20$%7Bcharacter.roleInstruction.slice(0,%20450).replace(/%5C%5Cs+/g,%20%5C%22%20%5C%22)%7D%60,%5Cn%20%20%20%20%20%20%20%20%20%20image:%20character.metaImage%20?%20character.metaImage%20:%20character.avatarUrl,%5Cn%20%20%20%20%20%20%20%20%7D;%5Cn%20%20%20%20%20%20%7D%20catch(e)%20%7B%5Cn%20%20%20%20%20%20%20%20console.error(e);%5Cn%20%20%20%20%20%20%20%20return%20defaults;%5Cn%20%20%20%20%20%20%7D%5Cn%20%20%20%20%7D%20else%20%7B%5Cn%20%20%20%20%20%20return%20defaults;%5Cn%20%20%20%20%7D%5Cn%7D%22%7D

window.generatorPublicId = "0d6136c5bdc66d08149a2330f1567b5f";

window.generatorLastSaveTime = Number(`1770444284406`);

window.shouldLiftGeneratorHtmlFromEmbed = `true` === "true";


(function(global,factory){typeof exports==="object"&&typeof module!=="undefined"?module.exports=factory():typeof define==="function"&&define.amd?define(factory):(global=global||self,global.CodeMirror


// for playing about and testing: http://jsfiddle.net/TcqAf/529/

// newer version: http://jsbin.com/filalidobe/1/edit?html,output
// problem is, even if I do work out this: https://stackoverflow.com/questions/52160551/way-to-overlay-multiple-tokens-rules-with-codemirror-simple-mode
//   i'll still have to sort out this [a = [], "hello"] - probably need to write a proper mode (using same logic that breaks up square blocks)

// CodeMirror.defineSimpleMode("simplemode", {
//   // The start state contains the rules that are intially used
//   start: [
//       // You can embed other modes with the mode property. This rule
//     // causes all code between << and >> to be highlighted with the XML
//     // mode.
// //    {regex: /(?:^|[^\\])(?:\\\\)*(\[)/, token: "variable-3", mode: {spec: "javascript", end: /(?:^|[^\\])(?:\\\\)*(\])/}},
//     // The regex matches the token, the token property contains the type
//     //{regex: /"(?:[^\\]|\\.)*?(?:"|$)/, token: "string"},
//     // You can match multiple tokens at once. Note that the captured
//     // groups must span the whole string in this case
//     {regex: /([a-zA-Z][a-zA-Z0-9$_]+)(\s*)($)([^)]*)($)(\s*)(=>)/,
//      token: ["variable-2", null, "keyword", null, "keyword", null, "keyword"]},

//     // curly
//     {regex: /\{[a-zA-Z]-[a-zA-Z]\}/, token: "syntax-style1"},
//     {regex: /\{[0-9]+-[0-9]+\}/, token: "syntax-style1"},
//     {regex: /\{/, token: "syntax-style1"},
//     {regex: /\}/, token: "syntax-style1"},

//     // square
//     //{regex: /\[[^\]]+\]/, token: "variable-3"},
//     {regex: /\[/, token: "syntax-style2"},
//     {regex: /\]/, token: "syntax-style2"},

//     // equals
//     {regex: /=/, token: "keyword"},

//     // not sure
//     {regex: /\$output\b/, token: "variable-2"},
//     {regex: /\$preprocess\b/, token: "variable-2"},
    
//     //{regex: /true|false|null|undefined/, token: "atom"},
//     //{regex: /0x[a-f\d]+|[-+]?(?:\.\d+|\d+\.?\d*)(?:e[-+]?\d+)?/i,
//      //token: "number"},
//     {regex: /[\s](\/\/.*)/, token: "syntax-style3-comment"},
//     {regex: /(\/\/.*)/, token: "syntax-style3-comment", sol:true},
//     //{regex: /\/(?:[^\\]|\\.)*?\//, token: "variable-3"},
//     //{regex: /[-+\/*=<>!]+/, token: "operator"},
//     // indent and dedent properties guide autoindentation
//     //{regex: /=>/, indent: true},
//     //{regex: /[\}\]\)]/, dedent: true},
//     //{regex: /[a-z$][\w$]*/, token: "variable"},
//   ],
//   // The meta property contains global information about the mode. It
//   // can contain properties like lineComment, which are supported by
//   // all modes, and also directives like dontIndentStates, which are
//   // specific to simple modes.
//   meta: {
//     dontIndentStates: ["comment"],
//     lineComment: "//",
//     fold: "indent",
//   }
// });


// CodeMirror.defineMode("mustache", function(config, parserConfig) {
//   var mustacheOverlay = {
//     token: function(stream, state) {
//       var ch;
//       if (stream.match("{")) {
//         while ((ch = stream.next()) != null)
//           if (stream.next() == "}") {
//             stream.eat("}");
//             return "variable-2";
//           }
//       }
//       while (stream.next() != null && !stream.match("{", false)) {}
//       return null;
//     }
//   };
//   return CodeMirror.overlayMode(CodeMirror.getMode(config, parserConfig.backdrop || "text/html"), mustacheOverlay);
// });

try {

  CodeMirror.defineMode("perchancelists", function(config) {

    var jsMode = CodeMirror.getMode(config, "javascript");
  
    // this, in a sense, `trimStart`s the stream and then gets the next two characters
    function skipSpacesAndPeekTwo(stream) {
      let count = 0;
      let result = '';
      for (let i = stream.pos; i < stream.string.length; i++) {
        let char = stream.string.charAt(i);
        if (char !== ' ' && char !== '\t') {
          result += char;
          count++;
          if (count === 2) {
            return result;
          }
        }
      }
      return null;
    }
    
    function token(stream, state) {    
      if(state.inSquareBlock && state.inFunction) console.error("invalid state - cannot be both in function and square block at same time");
      if(stream.string.length > 50000) { // Consume the entire line if it's too long
        stream.skipToEnd();
        return null;  // No styling applied
      }
  
      if(stream.sol() && state.inSquareBlock) { // square blocks cannot span multiple lines
        state.bracketDepth = 0;
        state.inSquareBlock = false;
        state.localState = null;
        return null;
      }
  
      if(stream.sol() && state.inFunction && stream.indentation() <= state.functionIndent && skipSpacesAndPeekTwo(stream) !== "//") {
        state.inFunction = false;
        state.localState = null;
        stream.backUp(stream.current().length); // rewind to the beginning of the line (important)
        return null;
      }
    
      if(state.inSquareBlock || state.inFunction) {
        let style = jsMode.token(stream, state.localState);
        let current = stream.current();
    
        if(state.inFunction) {
          if(state.inSquareBlock) console.error("inSquareBlock while also inFunction");
          // note: we already early-exited in case of indentation-based function end, above, so we know we're still in the function here
          return style;
        } else if(state.inSquareBlock) {
          if(state.inFunction) console.error("inFunction while also inSquareBlock");
  
          // don't count square brackets that are in strings, regex, or comments:
          if(style !== "string" && style !== "string-2" && style !== "comment") {
            if(current === "]") {
              state.bracketDepth--;
              if (state.bracketDepth <= 0) {
                state.inSquareBlock = false;
                state.localState = null;
                return "square-bracket";
              }
            }
            if(current === "[") {
              state.bracketDepth++;
            }
            if(state.bracketDepth <= 0) {
              state.inSquareBlock = false;
              state.localState = null;
            }
          }
          
          return style;
        }
      } else {
        if(stream.sol() && stream.match(/\/\/.*/)) {
          return "comment";
        } else if (stream.match(/\s\/\/.*/)) {
          return "comment";
        }
        if(stream.peek() === "[") {
          state.bracketDepth = 1;
          state.inSquareBlock = true;
          state.localState = CodeMirror.startState(jsMode);
          stream.next();
          return "square-bracket";
        }
    
        // if(stream.match(/^\w*(?=$)/)) {
        //   return "def";
        // }
    
        if(stream.match(/^(async |)[a-zA-Z0-9$_]+ ?\([^$]*\) *=> */)) {
          state.localState = CodeMirror.startState(jsMode);
          state.inFunction = true;
          state.functionIndent = stream.indentation();
          return "def";
        }
    
        if(stream.match('\\[') || stream.match('\\]')) {
          return "escaped-char";
        }
        if(stream.match('{') || stream.match('}')) {
          return "curly-bracket";
        }
        if(stream.match(/\$output\b/) || stream.match(/\$preprocess\b/)) {
          return "special-list-name";
        }
        stream.next();
        return null;
      }
    }
    
    return {
      startState: function() {
        return {
          inSquareBlock: false,
          localState: null,
          bracketDepth: 0,
          inFunction: false,
          functionIndent: 0,
        };
      },
      token: token,
      lineComment: "//",
      fold: "indent",
    };
  });

  // let systemIsInDarkMode = !!(window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches);
  // window.codeMirrorModelTextEditor = CodeMirror.fromTextArea(document.body.querySelector("#input"), {
  //   lineNumbers: true,
  //   foldGutter: true,
  //   extraKeys: {
  //     //"Ctrl-Q": cm => cm.foldCode(cm.getCursor()),
  //     //"Ctrl-Y": cm => CodeMirror.commands.foldAll(cm),
  //     //"Ctrl-I": cm => CodeMirror.commands.unfoldAll(cm),
  //   },
  //   gutters: ["CodeMirror-linenumbers", "CodeMirror-foldgutter"],
  //   tabSize: 2,
  //   indentUnit: 2,
  //   indentWithTabs: false,
  //   matchBrackets: true,
  //   mode: "perchancelists",
  //   styleActiveLine: true,
  //   // mode: "text",
  //   lineWrapping:false,
  //   theme: systemIsInDarkMode ? "one-dark" : "one-light",
  //   keyMap: "sublime",
  // });
  // window.codeMirrorModelTextEditor.setOption("mode", "perchancelists");





  // OLD:
  // CodeMirror.defineMode("perchancelists", function(config) {

  //   var jsMode = CodeMirror.getMode(config, "javascript");

  //   function token(stream, state) {    
  //     if(state.inSquareBlock && state.inFunction) console.error("invalid state - cannot be both in function and square block at same time");
  //     if(stream.string.length > 50000) { // Consume the entire line if it's too long
  //       stream.skipToEnd();
  //       return null;  // No styling applied
  //     }

  //     if(state.inSquareBlock || state.inFunction) {
  //       var style = jsMode.token(stream, state.localState);
  //       if (style === "string" || style === "string-2" || style === "comment") {
  //         return style;
  //       }
  //       var current = stream.current();

  //       if(state.inFunction) {
  //         if(state.inSquareBlock) console.error("inSquareBlock while also inFunction");
          
  //         if(stream.indentation() <= state.functionIndent) {
  //           state.localState = null;
  //           state.inFunction = false;
  //           stream.backUp(stream.current().length); // Rewind to the beginning of the line (important)
  //           return null;
  //         }
  //       } else if(state.inSquareBlock) {
  //         if(state.inFunction) console.error("inFunction while also inSquareBlock");
    
  //         if (current === "]") { // note: this square bracket is not inside a string/regex, since we early-returned above in those cases
  //           state.bracketDepth--;
  //           if (state.bracketDepth <= 0) {
  //             state.inSquareBlock = false;
  //             state.localState = null;
  //             return "square-bracket";
  //           }
  //         }
    
  //         if(current === "[") {
  //           state.bracketDepth++;
  //         }

  //         if(state.bracketDepth <= 0) {
  //           state.inSquareBlock = false;
  //           state.localState = null;
  //         }
  //       }

  //       return style;
  //     } else {
  //       if(stream.match(/\$output\b/) || stream.match(/\$preprocess\b/)) {
  //         return "special-list-name";
  //       }
  //       if(stream.sol() && stream.match(/\/\/.*/)) {
  //         return "comment";
  //       } else if (stream.match(/\s\/\/.*/)) {
  //         return "comment";
  //       }
  //       if(stream.peek() === "[") {
  //         state.bracketDepth = 1;
  //         state.inSquareBlock = true;
  //         state.localState = CodeMirror.startState(jsMode);
  //         stream.next();
  //         return "square-bracket";
  //       }

  //       if(stream.match(/^[a-zA-Z0-9$_]\w*(?=$)/)) {
  //         return "def";
  //       }

  //       if(stream.match(/\([^$]*\) =>/)) {
  //         state.localState = CodeMirror.startState(jsMode);
  //         state.inFunction = true;
  //         state.functionIndent = stream.indentation();
  //         return "javascript";
  //       }

  //       if(stream.match('\\[') || stream.match('\\]')) {
  //         return "escaped-char";
  //       }
  //       if(stream.match('{') || stream.match('}')) {
  //         return "curly-bracket";
  //       }
  //       stream.next();
  //       return null;
  //     }
  //   }

  //   return {
  //     startState: function() {
  //       return {
  //         inSquareBlock: false,
  //         localState: null,
  //         bracketDepth: 0,
  //         inFunction: false,
  //         functionIndent: 0,
  //       };
  //     },
  //     token: token,
  //     lineComment: "//",
  //     fold: "indent",
  //   };
  // });

} catch(e) { console.error(e); }



/*! Split.js - v1.6.5 */
!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e="undefined"!=typeof globalThis?globalThis:e||self).Split=t()}(this,(function(){"use strict";var e="undefined"!=typeof window?window:null,t=null===e,n=t?void 0:e.document,i=function(){return!1},r=t?"calc":["","-webkit-","-moz-","-o-"].filter((function(e){var t=n.createElement("div");return t.style.cssText="width:"+e+"calc(9px)",!!t.style.length})).shift()+"calc",s=function(e){return"string"==typeof e||e instanceof String},o=function(e){if(s(e)){var t=n.querySelector(e);if(!t)throw new Error("Selector "+e+" did not match a DOM element");return t}return e},a=function(e,t,n){var i=e[t];return void 0!==i?i:n},u=function(e,t,n,i){if(t){if("end"===i)return 0;if("center"===i)return e/2}else if(n){if("start"===i)return 0;if("center"===i)return e/2}return e},l=function(e,t){var i=n.createElement("div");return i.className="gutter gutter-"+t,i},c=function(e,t,n){var i={};return s(t)?i[e]=t:i[e]=r+"("+t+"% - "+n+"px)",i},h=function(e,t){var n;return(n={})[e]=t+"px",n};return function(r,s){if(void 0===s&&(s={}),t)return{};var f,d,v,m,g,p,y=r;Array.from&&(y=Array.from(y));var z=o(y[0]).parentNode,S=getComputedStyle?getComputedStyle(z):null,b=S?S.flexDirection:null,E=a(s,"sizes")||y.map((function(){return 100/y.length})),_=a(s,"minSize",100),L=Array.isArray(_)?_:y.map((function(){return _})),w=a(s,"maxSize",1/0),x=Array.isArray(w)?w:y.map((function(){return w})),O=a(s,"expandToMin",!1),A=a(s,"gutterSize",10),k=a(s,"gutterAlign","center"),C=a(s,"snapOffset",30),M=Array.isArray(C)?C:y.map((function(){return C})),U=a(s,"dragInterval",1),D=a(s,"direction","horizontal"),B=a(s,"cursor","horizontal"===D?"col-resize":"row-resize"),T=a(s,"gutter",l),j=a(s,"elementStyle",c),F=a(s,"gutterStyle",h);function R(e,t,n,i){var r=j(f,t,n,i);Object.keys(r).forEach((function(t){e.style[t]=r[t]}))}function N(){return p.map((function(e){return e.size}))}function q(e){return"touches"in e?e.touches[0][d]:e[d]}function H(e){var t=p[this.a],n=p[this.b],i=t.size+n.size;t.size=e/this.size*i,n.size=i-e/this.size*i,R(t.element,t.size,this._b,t.i),R(n.element,n.size,this._c,n.i)}function I(e){var t,n=p[this.a],r=p[this.b];this.dragging&&(t=q(e)-this.start+(this._b-this.dragOffset),U>1&&(t=Math.round(t/U)*U),t<=n.minSize+n.snapOffset+this._b?t=n.minSize+this._b:t>=this.size-(r.minSize+r.snapOffset+this._c)&&(t=this.size-(r.minSize+this._c)),t>=n.maxSize-n.snapOffset+this._b?t=n.maxSize+this._b:t<=this.size-(r.maxSize-r.snapOffset+this._c)&&(t=this.size-(r.maxSize+this._c)),H.call(this,t),a(s,"onDrag",i)(N()))}function W(){var e=p[this.a].element,t=p[this.b].element,n=e.getBoundingClientRect(),i=t.getBoundingClientRect();this.size=n[f]+i[f]+this._b+this._c,this.start=n[v],this.end=n[m]}function X(e){var t=function(e){if(!getComputedStyle)return null;var t=getComputedStyle(e);if(!t)return null;var n=e[g];return 0===n?null:n-="horizontal"===D?parseFloat(t.paddingLeft)+parseFloat(t.paddingRight):parseFloat(t.paddingTop)+parseFloat(t.paddingBottom)}(z);if(null===t)return e;if(L.reduce((function(e,t){return e+t}),0)>t)return e;var n=0,i=[],r=e.map((function(r,s){var o=t*r/100,a=u(A,0===s,s===e.length-1,k),l=L[s]+a;return o<l?(n+=l-o,i.push(0),l):(i.push(o-l),o)}));return 0===n?e:r.map((function(e,r){var s=e;if(n>0&&i[r]-n>0){var o=Math.min(n,i[r]-n);n-=o,s=e-o}return s/t*100}))}function Y(){var t=p[this.a].element,r=p[this.b].element;this.dragging&&a(s,"onDragEnd",i)(N()),this.dragging=!1,e.removeEventListener("mouseup",this.stop),e.removeEventListener("touchend",this.stop),e.removeEventListener("touchcancel",this.stop),e.removeEventListener("mousemove",this.move),e.removeEventListener("touchmove",this.move),this.stop=null,this.move=null,t.removeEventListener("selectstart",i),t.removeEventListener("dragstart",i),r.removeEventListener("selectstart",i),r.removeEventListener("dragstart",i),t.style.userSelect="",t.style.webkitUserSelect="",t.style.MozUserSelect="",t.style.pointerEvents="",r.style.userSelect="",r.style.webkitUserSelect="",r.style.MozUserSelect="",r.style.pointerEvents="",this.gutter.style.cursor="",this.parent.style.cursor="",n.body.style.cursor=""}function G(t){if(!("button"in t)||0===t.button){var r=p[this.a].element,o=p[this.b].element;this.dragging||a(s,"onDragStart",i)(N()),t.preventDefault(),this.dragging=!0,this.move=I.bind(this),this.stop=Y.bind(this),e.addEventListener("mouseup",this.stop),e.addEventListener("touchend",this.stop),e.addEventListener("touchcancel",this.stop),e.addEventListener("mousemove",this.move),e.addEventListener("touchmove",this.move),r.addEventListener("selectstart",i),r.addEventListener("dragstart",i),o.addEventListener("selectstart",i),o.addEventListener("dragstart",i),r.style.userSelect="none",r.style.webkitUserSelect="none",r.style.MozUserSelect="none",r.style.pointerEvents="none",o.style.userSelect="none",o.style.webkitUserSelect="none",o.style.MozUserSelect="none",o.style.pointerEvents="none",this.gutter.style.cursor=B,this.parent.style.cursor=B,n.body.style.cursor=B,W.call(this),this.dragOffset=q(t)-this.end}}"horizontal"===D?(f="width",d="clientX",v="left",m="right",g="clientWidth"):"vertical"===D&&(f="height",d="clientY",v="top",m="bottom",g="clientHeight"),E=X(E);var J=[];function K(e){var t=e.i===J.length,n=t?J[e.i-1]:J[e.i];W.call(n);var i=t?n.size-e.minSize-n._c:e.minSize+n._b;H.call(n,i)}return(p=y.map((function(e,t){var n,i={element:o(e),size:E[t],minSize:L[t],maxSize:x[t],snapOffset:M[t],i:t};if(t>0&&((n={a:t-1,b:t,dragging:!1,direction:D,parent:z})._b=u(A,t-1==0,!1,k),n._c=u(A,!1,t===y.length-1,k),"row-reverse"===b||"column-reverse"===b)){var r=n.a;n.a=n.b,n.b=r}if(t>0){var s=T(t,D,i.element);!function(e,t,n){var i=F(f,t,n);Object.keys(i).forEach((function(t){e.style[t]=i[t]}))}(s,A,t),n._a=G.bind(n),s.addEventListener("mousedown",n._a),s.addEventListener("touchstart",n._a),z.insertBefore(s,i.element),n.gutter=s}return R(i.element,i.size,u(A,0===t,t===y.length-1,k),t),t>0&&J.push(n),i}))).forEach((function(e){var t=e.element.getBoundingClientRect()[f];t<e.minSize&&(O?K(e):e.minSize=t)})),{setSizes:function(e){var t=X(e);t.forEach((function(e,n){if(n>0){var i=J[n-1],r=p[i.a],s=p[i.b];r.size=t[n-1],s.size=e,R(r.element,r.size,i._b,r.i),R(s.element,s.size,i._c,s.i)}}))},getSizes:N,collapse:function(e){K(p[e])},destroy:function(e,t){J.forEach((function(n){if(!0!==t?n.parent.removeChild(n.gutter):(n.gutter.removeEventListener("mousedown",n._a),n.gutter.removeEventListener("touchstart",n._a)),!0!==e){var i=j(f,n.a.size,n._b);Object.keys(i).forEach((function(e){p[n.a].element.style[e]="",p[n.b].element.style[e]=""}))}}))},parent:z,pairs:J}}}));
//# sourceMappingURL=split.min.js.map



          let thisIsNotAnOldCachedPageResolver;
          window.thisIsNotAnOldCachedPagePromise = new Promise(r => thisIsNotAnOldCachedPageResolver=r);
          // CloudFlare sometimes has cache purging delays, and these can really mess things up (e.g. make it look like you've lost hours of work).
          // We check the `age` header of this document, and if it's older than the last save time of this generator, then we load a cache-busted URL
          // and then remove the added cacheBust string with history.replaceState
          (async function() {
            if(navigator.webdriver) return; // just in case this is what's confusing the Google crawler - RE the title bug
            if(window.location.href.includes("__cacheBust")) {
              thisIsNotAnOldCachedPageResolver(true);
              return; // no need to run this check if cache is already busted
            }

            let imports = window.js0nparse(decodeURI(document.querySelector("#imported-generator-names").textContent));
            let clientHtmlServerRenderTime = Number(document.querySelector("#this-html-server-render-time").textContent);
            
            await new Promise(r => setTimeout(r, 10)); // give the page a chance to load a bit before checking transferSize
            let transferSize = 1;
            try { transferSize = performance.getEntriesByType("navigation")[0].transferSize; } catch(e) {}
            console.debug("transferSize (likely partial):", transferSize);
            if(isNaN(transferSize)) transferSize = 1;
            // transferSize will be zero if it was loaded from browser cache, assuming the user's browser supports the API

            let checkStartTime = Date.now();
            let weHaveAnOldVersionOfThisGen = await fetch(`https://perchance.org/api/clearCacheIfGeneratorOrImportsHaveBeenUpdated?generatorName=${window.location.pathname.slice(1)}&importedGeneratorNames=${imports.join(",")}&clientHtmlServerRenderTime=${clientHtmlServerRenderTime}&transferSize=${transferSize}&queryParamString=${encodeURIComponent(window.location.search)}&__cacheBust=${Math.random()}`).then(r => r.json()).catch(e => { console.error(e); return "network-error"; });
            if(weHaveAnOldVersionOfThisGen === "network-error") {
              if(window.userOwnsThisGenerator) {
                alert("There was a network error while trying to determine whether the latest generator data has been loaded. You may be viewing/editing an older copy of the data. Try refreshing the page.");
              }
            } else if(weHaveAnOldVersionOfThisGen) {
              console.debug("This is an old version of this generator.");
              if(Date.now()-checkStartTime < 10000) {
                console.debug("Doing cache bust reload now...");
                let url = new URL(window.location.href);
                url.searchParams.set("__cacheBust", Math.random());
                window.location.href = url.href.replace(/(\?|&)%24csp=(&|$)/, "$1$csp$2");
              } else if(window.userOwnsThisGenerator) { 
                // don't want to disrupt them in case they're editing, but still need to let them know:
                alert("This is an old version of this generator. Please refresh the page to get the latest version.");
              }
            } else {
              thisIsNotAnOldCachedPageResolver(true);
            }
          })();
          if(location.href.includes("__cacheBust")) {
            window.needToBustCacheOfIframeOnInitialLoad = true;
            let url = new URL(window.location.href);
            url.searchParams.delete("__cacheBust");
            let newPath = url.href.replace(/^https:\/\/perchance\.org/, "").replace(/(\?|&)%24csp=(&|$)/, "$1$csp$2");
            history.replaceState({}, "", newPath);
          }
        


              if(window.generatorStaticMetaData.header?.mode === "minimal") { 
                menuBarEl.style.display = "none";
                minimalModeMenuBtn.style.display = "flex"; 
              }
              try {
                const mm = (q) => window.matchMedia(q).matches === true;
                if(mm("(display-mode: minimal-ui)") || mm("(display-mode: window-controls-overlay)") || mm("(display-mode: fullscreen)") || mm("(display-mode: standalone)") || window.navigator.standalone) {
                  menuBarEl.style.display = "none";
                  minimalModeMenuBtn.style.display = "flex"; 
                }
              } catch(e) {
                console.error(e);
              }
              function enableRobustBackdropFilter() { // this is more robust to e.g. background images, light backgrounds in dark mode, etc. - only enabling if background is actually set because IIRC some browsers currently have significant performance issues with backdrop-filter blur
                document.querySelector(':root').style.setProperty('--menu-bar-item-backdrop-filter', "brightness(0.9) blur(4px)");
                document.querySelector(':root').style.setProperty('--menu-bar-item-backdrop-filter-hover', "brightness(0.84) blur(4px)");
                document.querySelector(':root').style.setProperty('--menu-bar-item-backdrop-filter-dark', "brightness(0.75) blur(4px)");
                document.querySelector(':root').style.setProperty('--menu-bar-item-backdrop-filter-hover-dark', "brightness(0.6) blur(4px)");
              }  
              function colorIsDark(bgColorStr) {
                let a = document.createElement('div');
                a.style.color = bgColorStr;
                let rgb = window.getComputedStyle( document.body.appendChild(a) ).color.match(/\d+/g).map(function(a){ return parseInt(a,10); });
                document.body.removeChild(a);
                let r = rgb[0];
                let g = rgb[1];
                let b = rgb[2];
                let uicolors = [r / 255, g / 255, b / 255];
                let c = uicolors.map((col) => {
                  if (col <= 0.03928) {
                    return col / 12.92;
                  }
                  return Math.pow((col + 0.055) / 1.055, 2.4);
                });
                let L = (0.2126 * c[0]) + (0.7152 * c[1]) + (0.0722 * c[2]);
                return L < 0.179;
              }
              if(typeof window.generatorStaticMetaData.header?.background === "string") {
                if(CSS.supports("background", window.generatorStaticMetaData.header.background)) {
                  menuBarEl.style.background = window.generatorStaticMetaData.header.background;
                  enableRobustBackdropFilter();
                  if(CSS.supports("color", window.generatorStaticMetaData.header.background)) {
                    menuBarEl.style.color = colorIsDark(window.generatorStaticMetaData.header.background) ? "#e3e3e3" : "#050505";
                  }
                }
              }

              {
                let isTouchDevice = window.matchMedia("(pointer: coarse)").matches;
                let maxSeenViewportHeight = window.visualViewport.height;
                window.visualViewport.addEventListener('resize', () => {
                  if(!isTouchDevice) return;
                  if(window.visualViewport.height > maxSeenViewportHeight) maxSeenViewportHeight = window.visualViewport.height;
                  if(window.generatorStaticMetaData.header?.mode !== "minimal") {
                    menuBarEl.style.display = window.visualViewport.height < 0.8*maxSeenViewportHeight ? "none" : "flex"; 
                  }
                });
              }
            


            // check if click is in search field, and if so set data-last-search-textfield-interacted to 1 and set others to 0
            window.addEventListener("click", (e) => {
              if(e.target.className !== "cm-textfield") return;
              let searchPanel = document.querySelector(".cm-search.cm-panel");
              if(!searchPanel.contains(e.target)) return;
              let searchFields = searchPanel.querySelectorAll(".cm-search.cm-panel input.cm-textfield");
              for(let field of searchFields) {
                field.dataset.lastSearchTextfieldInteracted = field === e.target ? "1" : "0";
              }
            });
            // same for typing:
            window.addEventListener("keydown", (e) => {
              if(e.target.className !== "cm-textfield") return;
              let searchPanel = e.target.closest(".cm-search.cm-panel");
              if(!searchPanel) return;
              let searchFields = searchPanel.querySelectorAll(".cm-search.cm-panel input.cm-textfield");
              for(let field of searchFields) {
                field.dataset.lastSearchTextfieldInteracted = field === e.target ? "1" : "0";
              }
            });
            // and same for focusin:
            window.addEventListener("focusin", (e) => {
              if(e.target.className !== "cm-textfield") return;
              let searchPanel = e.target.closest(".cm-search.cm-panel");
              if(!searchPanel) return;
              let searchFields = searchPanel.querySelectorAll(".cm-search.cm-panel input.cm-textfield");
              for(let field of searchFields) {
                field.dataset.lastSearchTextfieldInteracted = field === e.target ? "1" : "0";
              }
            });
          


                      setTimeout(() => {
                        if(!window.perchanceOutputIframeFinishedFirstLoad) document.querySelector("#outputLoadSpinner").style.display = "flex";
                      }, 1500);
                      window.onNextOutputIframeReloadHandlers = [];
                      window.addEventListener("message", async (e) => {
                        let origin = e.origin || e.originalEvent.origin;
                        if(origin !== "https://null.perchance.org" && origin !== `https://${window.generatorPublicId}.perchance.org`) return;

                        if(e.data.type === "finishedLoading" || e.data.type === "failedToLoadDueToGeneratorErrors") {
                          window.perchanceOutputIframeFinishedFirstLoad = true;
                          document.querySelector("#outputLoadSpinner").style.display = "none";
                          for(let fn of window.onNextOutputIframeReloadHandlers) {
                            try { fn(); } catch(e) { console.error(e); }
                          }
                          window.onNextOutputIframeReloadHandlers = [];
                        }

                        if(e.data.type === "ensureEditorIsLoaded75383748") {
                          if(!/^#edit($|:)/.test(window.location.hash)) {
                            let tmp = window.hasBeenInEditModeAtLeastOnce;
                            await app.goToEditMode();
                            app.goToViewMode();
                            window.hasBeenInEditModeAtLeastOnce = tmp;
                          }
                          outputIframeEl.contentWindow.postMessage({type:"ensureEditorIsLoaded75383748_response"}, "*");
                        }
                      });
                    


                      // Must add query string to iframe if it has one, since generator code may rely on that:
                      {
                        let url = document.querySelector("#outputIframeEl").src;
                        let different = false;
                        if(window.location.search) {
                          if(url.includes("?")) url += "&"+window.location.search.slice(1);
                          else url += "?"+window.location.search.slice(1);
                          different = true;
                        }
                        if(window.location.hash) {
                          let hash = window.location.hash;
                          if(/^#edit($|:)/.test(hash)) hash = hash.split(":")[0]; // don't send e.g. collab key to iframe
                          url += hash;
                          different = true;
                        }
                        if(different) {
                          document.querySelector("#outputIframeEl").src = url;
                        }
                      }
                      {
                        const outputIframeEl = document.querySelector("#outputIframeEl");
                        
                        const originalLocationHash = window.location.hash;
                        window.addEventListener("hashchange", () => {
                          console.debug("hashchange event:", window.location.hash);
                          let hash = window.location.hash; 
                          if(/^#edit($|:)/.test(window.location.hash)) hash = "#edit"; // don't pass collab key and stuff to iframe
                          outputIframeEl.contentWindow.postMessage({type:"changeHash", hash}, "*");
                        });
                        
                        window.firstIframePageInteractionPromise = new Promise(r => window.firstIframePageInteractionResolver=r);
                        
                        window.addEventListener("message", async (e) => {
                          if(e.source !== outputIframeEl.contentWindow) return;
                          if(e.origin !== `https://${window.generatorPublicId}.perchance.org`) return;
                          
                          // If iframe hash changes, change the top-level hash too
                          if(e.data.type === "changeHash") { 
                            let newHash = e.data.hash;
                            if(typeof newHash !== "string") return;
                            if(/^#edit($|:)/.test(e.data.hash) && /^#edit($|:)/.test(window.location.hash)) return;
                            
                            // Restore original #edit hash if iframe tries to change it back to #edit hash:
                            if(/^#edit($|:)/.test(newHash)) newHash = /^#edit($|:)/.test(originalLocationHash) ? originalLocationHash : "#edit";
                            
                            console.debug("changeHash message:", `e.data.hash=${e.data.hash}  newHash=${newHash}  window.location.hash=${window.location.hash}`);
                            
                            if(window.location.hash !== newHash) { // to prevent possible infinite loops
                              window.location.hash = newHash;
                            }
                          }

                          // Respond to replaceState (*without* allowing path change):
                          if(e.data.type === "changeUrl") {
                            if(typeof e.data.search !== "string" || typeof e.data.hash !== "string") return;
                            history.replaceState({}, "", window.location.pathname+e.data.search+e.data.hash);
                          }

                          if(e.data.type === "changePageTitle") {
                            document.title = e.data.pageTitle;
                          }

                          if(e.data.type === "firstPageInteraction") {
                            window.firstIframePageInteractionResolver();
                          }
                          
                          if(e.data.type === "changeFavicon") {
                            if(typeof e.data.href !== "string") return;
                            if(navigator.webdriver) return;

                            await window.metaDataIsLoadedPromise;
                            if(window.forceDisableAds) await window.firstIframePageInteractionPromise; // require page interaction first

                            document.querySelectorAll("link[rel~='icon']").forEach(el => el.remove());
                            let link = document.createElement('link');
                            link.rel = 'icon';
                            document.head.appendChild(link);
                            link.href = e.data.href || "/favicon-32x32-white-bg.png";
                          }
                        });
                      }
                    

                    
                    (async function() {

                      async function compressText(str) {
                        const src = new Blob([str]).stream();
                        const gzStream = src.pipeThrough(new CompressionStream('gzip'));
                        const buf = await new Response(gzStream).arrayBuffer();
                        return btoa(String.fromCharCode(...new Uint8Array(buf)));
                      }
                      async function decompressText(b64) {
                        const bin = atob(b64);
                        const bytes = Uint8Array.from(bin, ch => ch.charCodeAt(0));
                        const src = new Blob([bytes]).stream();
                        const txt = await new Response(src.pipeThrough(new DecompressionStream('gzip'))).text();
                        return txt;
                      }
                      
                      let debounceTimeout;
                      aiHelperInputEl.addEventListener("input", function() {
                        clearTimeout(debounceTimeout);
                        debounceTimeout = setTimeout(async () => {
                          if(aiHelperInputEl.value.trim()) {
                            let instruction = await compressText(aiHelperInputEl.value.slice(0, 50000));
                            await kv.aiHelperInstructions.set(window.generatorName, {time:Date.now(), instruction});
                          } else {
                            await kv.aiHelperInstructions.delete(window.generatorName);
                          }
                        }, 1000);
                      });

                      // Clear very old instructions:
                      setTimeout(async () => {
                        const cutoffTime = Date.now() - 2*365*24*60*60*1000;
                        let entries = await kv.aiHelperInstructions.entries();
                        for(let [generatorName, data] of entries) {
                          try {
                            if(data.time < cutoffTime) await kv.aiHelperInstructions.delete(generatorName);
                          } catch {
                            await kv.aiHelperInstructions.delete(generatorName);
                          }
                        }
                      }, 1000*60*5);

                      let data = await kv.aiHelperInstructions.get(window.generatorName)
                      if(data) {
                        aiHelperInputEl.value = await decompressText(data.instruction);
                      }
                    })();
                  


                    if(localStorage.aiHelperCtnHidden) {
                      aiHelperCtn.hidden = true;
                      showAiHelperBtn.hidden = false;
                    } else {
                      aiHelperCtn.hidden = false;
                      showAiHelperBtn.hidden = true;
                    }

                    function getChangeHighlightMarks(original, updated) {
                      const diff = Diff.diffLines(original, updated);
                      const markers = [];
                      let lineNumber = 0;
                      diff.forEach((part) => {
                        const lines = part.value.split('\n');
                        if (part.added) {
                          lines.forEach((line, index) => {
                            if(line.length > 0 || index < lines.length - 1) {
                              markers.push({
                                from: { line: lineNumber, ch: 0 },
                                to: { line: lineNumber, ch: line.length },
                                className: 'cm-highlight-change'
                              });
                              lineNumber++;
                            }
                          });
                        } else if(!part.removed) {
                          lineNumber += lines.length - 1;
                          if (lines[lines.length - 1].length > 0) lineNumber++; 
                        }
                      });
                      return markers;
                    }
                    function clearChangeHighlightMarks() {
                      if(window.outputTemplateEditor._clearMarks) { 
                        window.outputTemplateEditor._clearMarks();
                      } else {
                        window.outputTemplateEditor.getAllMarks().forEach(mark => {
                          if(mark.className === 'cm-highlight-add' || mark.className === 'cm-highlight-change') {
                            mark.clear();
                          }
                        });
                      }
                    }
                    
                    async function executeAiHelper() {
                      let type = aiHelpTypeSelect.value;
                      let instruction = aiHelperInputEl.value; 
                      if(!instruction) return;

                      if(autoReloadCheckboxEl.checked) {
                        autoReloadCheckboxEl.checked = false;
                        updateToggleOutputAutoReloadOnEdits();
                      }

                      const submitButtonOriginalText = aiHelperSubmitBtn.textContent;
                      aiHelperSubmitBtn.innerHTML = `⏳ thinking…`;
                      let patienceLabelTimeout = setTimeout(() => {
                        aiHelperSubmitBtn.innerHTML = `⏳ (may take 10+ mins)`;
                      }, 2*60*1000);

                      aiHelperSubmitBtn.disabled = true;
                      aiHelpTypeSelect.disabled = true;

                      aiHelperUndoBtn.hidden = true;
                      aiHelperRedoBtn.hidden = true; 
                      
                      let requestId = Math.random().toString()+Math.random().toString() + "-" + (window.aiHelperRequestIdSuffix || ""); 
                      let data;
                      for(let i = 0; i < 12; i++) {
                        data = await fetch(`/api/aiHelper`, {
                          signal: window.AbortSignal?.timeout?.(5*60*1000),
                          method: "POST",
                          headers: { "Content-Type": "application/json" },
                          body: JSON.stringify({requestId, type, generatorName:window.generatorName, instruction, modelText:window.modelTextEditor.getValue(), outputTemplateText:window.outputTemplateEditor.getValue(), maybeLoggedIn:window[`localStorage`]["app-storage"].includes("sessionToken")}),
                        }).then(r => r.json()).catch(e => ({error:true, status:e.message}));
                        if(!data.error) break;
                      }

                      clearTimeout(patienceLabelTimeout);
                      aiHelperSubmitBtn.disabled = false;
                      aiHelpTypeSelect.disabled = false;
                      aiHelperSubmitBtn.textContent = submitButtonOriginalText;

                      if(data.status !== "success") {
                        alert(`Sorry, there was an error with the AI helper: ${data.status}${data.status === "too-many-requests" ? " (could be caused by VPN)" : ""}`);
                        return;
                      }

                      window.outputTemplateEditorBeforeAiHelper = window.outputTemplateEditor.getValue();
                      window.modelTextEditorBeforeAiHelper = window.modelTextEditor.getValue();

                      if(type === "new" || type === "edit") {
                        window.outputTemplateEditor.setValue(data.outputTemplateText); 

                        if(data.outputTemplateText.includes("commentsPlugin(") && !/commentsPlugin *= *\{import:comments-plugin\}/.test(window.modelTextEditor.getValue())) window.modelTextEditor.setValue(`commentsPlugin = {import:comments-plugin}\n${window.modelTextEditor.getValue()}`);
                        if(data.outputTemplateText.includes("generateImage(") && !/generateImage *= *\{import:text-to-image-plugin\}/.test(window.modelTextEditor.getValue())) window.modelTextEditor.setValue(`generateImage = {import:text-to-image-plugin}\n${window.modelTextEditor.getValue()}`);
                        if(data.outputTemplateText.includes("generateText(") && !/generateText *= *\{import:ai-text-plugin\}/.test(window.modelTextEditor.getValue())) window.modelTextEditor.setValue(`generateText = {import:ai-text-plugin}\n${window.modelTextEditor.getValue()}`);
                        if(data.outputTemplateText.includes("superFetch(") && !/superFetch *= *\{import:super-fetch-plugin\}/.test(window.modelTextEditor.getValue())) window.modelTextEditor.setValue(`superFetch = {import:super-fetch-plugin}\n${window.modelTextEditor.getValue()}`);
                        if(data.outputTemplateText.includes("uploadPlugin(") && !/uploadPlugin *= *\{import:upload-plugin\}/.test(window.modelTextEditor.getValue())) window.modelTextEditor.setValue(`uploadPlugin = {import:upload-plugin}\n${window.modelTextEditor.getValue()}`);
                        if(data.outputTemplateText.includes("secretPlugin(") && !/secretPlugin *= *\{import:secret-plugin\}/.test(window.modelTextEditor.getValue())) window.modelTextEditor.setValue(`secretPlugin = {import:secret-plugin}\n${window.modelTextEditor.getValue()}`);
                        if(/(\b|root\.)kv\./.test(data.outputTemplateText) && !/kv *= *\{import:kv-plugin\}/.test(window.modelTextEditor.getValue())) window.modelTextEditor.setValue(`kv = {import:kv-plugin}\n${window.modelTextEditor.getValue()}`);
                        
                        // check if we can remove generateImage and/or generateText imports:
                        let currentOutputTemplateText = window.outputTemplateEditor.getValue();
                        if(!currentOutputTemplateText.includes("generateImage(") && !window.modelTextEditor.getValue().replace(/generateImage *= *\{import:text-to-image-plugin\}/g, "").includes("generateImage(")) {
                          window.modelTextEditor.setValue(window.modelTextEditor.getValue().replace(/generateImage *= *\{import:text-to-image-plugin\}/g, ""));
                        }
                        if(!currentOutputTemplateText.includes("generateText(") && !window.modelTextEditor.getValue().replace(/generateText *= *\{import:ai-text-plugin\}/g, "").includes("generateText(")) {
                          window.modelTextEditor.setValue(window.modelTextEditor.getValue().replace(/generateText *= *\{import:ai-text-plugin\}/g, ""));
                        }

                        window.outputTemplateEditorAfterAiHelper = window.outputTemplateEditor.getValue();
                        window.modelTextEditorAfterAiHelper = window.modelTextEditor.getValue();

                        if(type === "edit") {
                          if(!window.Diff) {
                            let script = document.createElement('script');
                            script.src = "https://cdn.jsdelivr.net/npm/diff@7.0.0/dist/diff.min.js";
                            document.body.appendChild(script);
                            while(!window.Diff) await new Promise(r => setTimeout(r, 200));
                          }
                          if(!window.addedHighlightChangeStuff84783) {
                            window.addedHighlightChangeStuff84783 = true;
                            window.outputTemplateEditor.on('change', (instance, changeObj) => {
                              clearChangeHighlightMarks();
                            });
                          }
                          clearChangeHighlightMarks(); 
                          let markers = getChangeHighlightMarks(window.outputTemplateEditorBeforeAiHelper, window.outputTemplateEditorAfterAiHelper);
                          markers.forEach(marker => {
                            window.outputTemplateEditor._markText(marker.from, marker.to, { className: marker.className });
                          });
                        }

                        editor.handleReloadButtonClick();
                        aiHelperUndoBtn.hidden = false;
                        aiHelperUndoBtn.onclick = function() {
                          clearChangeHighlightMarks();

                          let originalOutputTemplateScrollPos = window.outputTemplateEditor.scrollDOM.scrollTop;
                          let originalModelTextScrollPos = window.modelTextEditor.scrollDOM.scrollTop;

                          window.outputTemplateEditor.setValue(window.outputTemplateEditorBeforeAiHelper);
                          window.modelTextEditor.setValue(window.modelTextEditorBeforeAiHelper);

                          setTimeout(() => {
                            window.outputTemplateEditor.scrollDOM.scrollTop = originalOutputTemplateScrollPos;
                            window.modelTextEditor.scrollDOM.scrollTop = originalModelTextScrollPos;
                          }, 0);

                          editor.handleReloadButtonClick();
                          aiHelperUndoBtn.hidden = true;
                          aiHelperRedoBtn.hidden = false;
                        };
                        aiHelperRedoBtn.onclick = function() {

                          let originalOutputTemplateScrollPos = window.outputTemplateEditor.scrollDOM.scrollTop;
                          let originalModelTextScrollPos = window.modelTextEditor.scrollDOM.scrollTop;

                          window.outputTemplateEditor.setValue(window.outputTemplateEditorAfterAiHelper);
                          window.modelTextEditor.setValue(window.modelTextEditorAfterAiHelper);

                          setTimeout(() => {
                            window.outputTemplateEditor.scrollDOM.scrollTop = originalOutputTemplateScrollPos;
                            window.modelTextEditor.scrollDOM.scrollTop = originalModelTextScrollPos;
                          }, 0);

                          editor.handleReloadButtonClick();
                          aiHelperUndoBtn.hidden = false;
                          aiHelperRedoBtn.hidden = true;
                          if(type === "edit") {
                            clearChangeHighlightMarks();
                            let markers = getChangeHighlightMarks(window.outputTemplateEditorBeforeAiHelper, window.outputTemplateEditorAfterAiHelper);
                            markers.forEach(marker => {
                              window.outputTemplateEditor._markText(marker.from, marker.to, { className: marker.className });
                            });
                          }
                        };
                      } else if(type === "question") {
                        // TODO
                      }
                    }
                    window.addEventListener("pointerdown", (e) => {
                      if(e.target.closest("#aiHelpTypeSelect") || e.target.closest("#aiHelperCloseBtnCtn")) return;
                      if(e.target.closest("#aiHelperUndoBtn") || e.target.closest("#aiHelperRedoBtn")) return;
                      if(e.target.closest("#aiHelperFeedbackBtn")) return;
                      if(e.target.closest("#aiHelperCtn")) { aiHelperCtn.style.minWidth='300px'; aiHelperCtn.style.minHeight='200px'; }
                      else { aiHelperCtn.style.minWidth='200px'; aiHelperCtn.style.minHeight='80px'; }
                    });
                    {
                      let aiHelpTypeToExamples = {
                        new: ["Create a simple snake game", "Create a cute profile page with 3 tabs. One for 'about me', one for 'links' and one for 'feedback' with a comments box. Add some kaomojis and pastel colors. Actually also add a 4th tab with a grid of toggleable checkboxes.", "Make an infinite scroller of AI generated images, with the old ones at the top being deleted as you scroll down far enough.", "create a simple centered template with a button which increments a counter", "make a wizard themed geocities homepage for me", "make a space invaders game using emojis"],
                        edit: ["it says there is a 'invalid array length' error. pls fix. here's the full error message: [...]", "make it look nicer", "make it look better on smaller screens (like mobile phones)", "the button isn't centered properly. fix pls", "Make the button bigger and add a blue gradient background", "Make all the text on the page wobble around", "Add more code comments so I can understand everything better", "Add a loading thing to show when the images are loading", "make it more interesting and complex", "complete all the TODO comments in the code", "make it more silly", "if it's june, make it rain transparent rainbow emojis on the page (and also add a little button to trigger it even if it's not june)", "Use this image as the background but blur it slightly: https://example.com/image.jpg", "reduce the number of lines of code", "add an optional dark mode"],
                        question: ["How does the code in the getPosition function work?", "What does display:flex do? How does it work?", "How can I make the background gradient change depending on the mouse position?"],
                      };
                      let i = 0;
                      setInterval(() => {
                        if(document.querySelector("#aiHelperInputEl").offsetHeight === 0) return;
                        let examples = aiHelpTypeToExamples[document.querySelector("#aiHelpTypeSelect").value];
                        i++;
                        if(i > examples.length-1) i = 0;
                        aiHelperInputEl.placeholder = examples[i];
                      }, 3000);
                    }
                  


            async function getCaptchaToken(widgetCtn) {

              let createdWidgetCtn;
              if(!widgetCtn) {
                // No widget container provided, so we create one.
                // Centered on screen with darkened background:
                createdWidgetCtn = document.createElement("div");
                createdWidgetCtn.className = "created-captcha-widget-ctn"; // <-- don't change this without changing references to it
                createdWidgetCtn.style.cssText = "text-align:center; position:fixed; top:50%; left:50%; transform:translate(-50%,-50%); z-index:1000; background-color:#111; padding:1em; border-radius:0.5em; box-shadow:0 0 10px rgba(0,0,0,0.5);";
                createdWidgetCtn.innerHTML = `<div style="margin-bottom:0.5rem;">⏳ Just a sec...</div>`;
                document.body.appendChild(createdWidgetCtn);
              }

              // load captcha lib if needed:
              let attempts = 0;
              while(!window.turnstile) {
                window.onloadTurnstilePromise = new Promise(r => window.onloadTurnstileCallback=r);
                let script = document.createElement("script");
                script.src = "https://challenges.cloudflare.com/turnstile/v0/api.js?onload=onloadTurnstileCallback";
                script.defer = true;
                script.onerror = (e) => {
                  console.error("Cloudflare Turnstile is being blocked?", e)
                };
                document.body.appendChild(script);
                await window.onloadTurnstilePromise;
                if(!window.turnstile) await new Promise(r => setTimeout(r, 10*1000));
                attempts++;
                if(attempts > 3) {
                  console.error("Failed to load Cloudflare Turnstile after 3 attempts.");
                  break;
                }
              }
              // render captcha and get token:
              let captchaWidgetId;
              let token = await new Promise((resolve, reject) => {
                captchaWidgetId = window.turnstile.render(widgetCtn || createdWidgetCtn, {
                  sitekey: '0x4AAAAAAAi3LdM-EVMMMFCv',
                  callback: function(token) {
                    console.debug("✅ Got turnstile token:", token);
                    resolve(token);
                  },
                  "error-callback": function(...args) {
                    console.error("❌ Turnstile error callback fired:", ...args);
                    reject(null);
                  },
                });
              });
              try { window.turnstile.remove(captchaWidgetId); } catch(e) { console.error("turnstile.remove() failed:", e); }
              if(createdWidgetCtn) createdWidgetCtn.remove();
              return token;
            }
          


          setTimeout(() => { // dynamically add after delay to reduce initial lag on low-end mobile devices
            if(window.forceDisableAds) return;
            
            window.dataLayer = window.dataLayer || [];
            function gtag(){dataLayer.push(arguments);}
            gtag('js', new Date());
            gtag('config', 'G-YJWJRNESS5');

            let script = document.createElement('script');
            script.async = true;
            script.src = "https://www.googletagmanager.com/gtag/js?id=G-YJWJRNESS5";
            document.body.appendChild(script);
          }, 1000*4);
          
          try {
            setTimeout( function() { // wait for init (we're not in any hurry)
              if(window.forceDisableAds) return;
              document.querySelector("#verify-account-button").addEventListener('click', function() {
                gtag("event", "signup", {});
              });
            }, 20*1000);
          } catch(e) { console.error(e); }
        


          // a temporary hack to make sure search engines see links on generators page:
          if(document.location.pathname === "/generators") { 
            var req = new XMLHttpRequest();
            req.overrideMimeType("application/json");
            req.open('GET', "/api/getGeneratorList", true); 
            req.onload  = function() {
              var result = window.js0nparse(req.responseText);
              var div = document.createElement('div');
              if(window.canExecuteModernJavascript) {
                div.style.height = "0px";
                div.style.overflow = "hidden";
                div.style.position = "fixed";
              }
              div.innerHTML = "Here are the latest generators: "+result.generators.map(function(g){ return "<a href='/"+g.name+"'>"+g.name+"</a>"; }).join(", ")+".";
              document.body.appendChild(div);
            };
            req.send(null);
          }
        


          (async function() {
            await new Promise(r => setTimeout(r, 1000*20));
            if(!navigator["\u0077\u0065\u0062\u0064\u0072\u0069\u0076\u0065\u0072"]) {
              fetch(`https://perchance.org/api/cv?generatorName=${location.pathname.slice(1)}&isFromEmbed=0&__cacheBust=${Math.random()}`);
              document.addEventListener("visibilitychange", () => {
                if(document.visibilityState === "visible") {
                  fetch(`https://perchance.org/api/cv?generatorName=${location.pathname.slice(1)}&isFromEmbed=0&__cacheBust=${Math.random()}`);
                }
              });
            }
          })();
        


          (async function() {
            if(!/^#edit($|:)/.test(window.location.hash)) {
              while(!document.querySelector("div.menu-item.new")) await new Promise(r => setTimeout(r, 20));
              let btnHtml = document.querySelector("div.menu-item.new").outerHTML;
              btnHtml = btnHtml.replace(/\/minimal#edit/g, "/ai-chat"); // "https://discord.gg/43qAQEVV9a"
              btnHtml = btnHtml.replace(/>new</g, ">ai chat<");
              btnHtml = btnHtml.replace(/menu-item new/g, "menu-item promo");
              btnHtml = btnHtml.replace(/➕/g, "🆕");
              let ctn = document.createElement("div");
              ctn.innerHTML = btnHtml;
              let btn = ctn.firstElementChild;
              let systemIsInDarkMode = !!(window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches);
              if(systemIsInDarkMode) {
                btn.style.backgroundColor = "rgb(110 53 11)";
              } else {
                btn.style.backgroundColor = "#ffd4a4";
              }
              document.querySelector("div.menu-item.new").after(btn);
            }
          })();
        


          (async function() {

            async function sha256Text(text) {
              const msgUint8 = new TextEncoder().encode(text);                          
              const hashBuffer = await crypto.subtle.digest('SHA-256', msgUint8);          
              const hashArray = Array.from(new Uint8Array(hashBuffer));                    
              const hashHex = hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
              return hashHex;
            }

            async function sendNotification(data) {
              // safety code to prevent duplicate notifications (shouldn't be needed, but just in case):
              let hash = await sha256Text(JSON.stringify(data));
              if(!localStorage.alreadyRecentlySentNotificationHashes) localStorage.alreadyRecentlySentNotificationHashes = "";
              if(localStorage.alreadyRecentlySentNotificationHashes.includes(hash)) return;
              localStorage.alreadyRecentlySentNotificationHashes += ","+hash;
              if(localStorage.alreadyRecentlySentNotificationHashes.length > 2000) localStorage.alreadyRecentlySentNotificationHashes = localStorage.alreadyRecentlySentNotificationHashes.slice(-1000);
              
              let notification;
              if(Notification.permission === "granted") {
                notification = new Notification(data.title, {body:data.body});
              } else if(Notification.permission !== "denied") {
                const permission = await Notification.requestPermission();
                if(permission === "granted") {
                  notification = new Notification(title, options);
                }
              }
              return notification;
            }

            window.addEventListener("message", async function(e) {
              let origin = e.origin || e.originalEvent.origin; // For Chrome, the origin property is in the event.originalEvent object.
              if(origin !== "https://comments-plugin.perchance.org") {
                return;
              }
              if(e.data.type === "ensure-notification-permission") {
                if(Notification.permission !== "granted" && Notification.permission !== "denied") {
                  const permission = await Notification.requestPermission();
                  if(permission === "granted") {
                    console.debug("notification permission granted");
                  } else {
                    console.debug("notification permission denied");
                  }
                }
              } else if(e.data.type === "notification-request") {
                if(Notification.permission !== "denied") {
                  if(e.data.folderName.split("+")[0] === window.location.pathname.slice(1)) {
                    let notification = await sendNotification(e.data).catch(e => console.error(e));
                    if(notification) notification.onclick = function() { window.focus(); this.close(); };
                  } else {
                    console.debug("Pending notification:", e.data.title, e.data.body, e.data.folderName);
                    // we ideally want this notification to be triggered in an already-open tab of the relevant generator (because then the notification.onclick can focus that tab, rather than opening a duplicate of that tab), so we put the notification data in localStorage and wait a few seconds for the relevant tab to take it out, and if not, then we trigger it from this tab, and set onclick to open a new tab
                    if(!localStorage.pendingNotifications) localStorage.pendingNotifications = "[]";
                    let pendingNotifications;
                    try { pendingNotifications = window.js0nparse(localStorage.pendingNotifications); } catch(e) { console.error("failed to parse pending notifications", e); pendingNotifications = []; }
                    pendingNotifications.push(e.data);
                    localStorage.pendingNotifications = JSON.stringify(pendingNotifications);

                    // try to wake the target tab with a BroadcastChannel message (no idea if this helps, but can't hurt):
                    let broadcastChannel;
                    if(window.BroadcastChannel) {
                      broadcastChannel = new BroadcastChannel("generatorName:"+window.location.pathname.slice(1));
                      broadcastChannel.postMessage({type:"wake-up"});
                    }
                    
                    setTimeout(async function() {
                      if(broadcastChannel) broadcastChannel.close();
                      let pendingNotifications;
                      try { pendingNotifications = window.js0nparse(localStorage.pendingNotifications); } catch(e) { console.error("failed to parse pending notifications", e); pendingNotifications = []; }
                      let notificationData = pendingNotifications.find(d => d.time === e.data.time && d.folderName === e.data.folderName && d.title === e.data.title && d.body === e.data.body);
                      if(notificationData) {
                        let notification = await sendNotification(notificationData).catch(e => console.error(e));
                        if(notification) notification.onclick = function() { window.open(`/${notificationData.folderName.split("+")[0]}`, "_blank"); this.close(); };
                        pendingNotifications = pendingNotifications.filter(d => d !== notificationData);
                        localStorage.pendingNotifications = JSON.stringify(pendingNotifications);
                      }
                    }, 1000*7); // <-- 'pending notification' timeout length (before we give up and just sent the `Notification` from this tab)
                  }
                }
              }
            });

            (async function() {

              if(window.BroadcastChannel) {
                let channel = new BroadcastChannel("generatorName:"+window.location.pathname.slice(1));
                channel.onmessage = (event) => {
                  if(event.data.type === "wake-up") {
                    console.debug("received wake-up message at:", new Date().toString());
                  }
                };
              }

              while(1) {
                let generatorName = window.location.pathname.slice(1);
                try {
                  await new Promise(r => setTimeout(r, 1000*2)); // this wait time must be lower than the 'pending notification' timeout length above
                  // parse localStorage.pendingNotifications and trigger notification if generatorName matches folderName
                  if(!localStorage.pendingNotifications) localStorage.pendingNotifications = "[]";
                  let pendingNotifications;
                  try { pendingNotifications = window.js0nparse(localStorage.pendingNotifications); } catch(e) { console.error("failed to parse pending notifications", e); pendingNotifications = []; }
                  
                  let pendingNotificationsForThisGeneratorName = pendingNotifications.filter(n => n.folderName.split("+")[0] === generatorName);
                  for(let notificationData of pendingNotificationsForThisGeneratorName) {
                    let notification = await sendNotification(notificationData).catch(e => console.error(e));
                    if(notification) notification.onclick = function() { window.focus(); this.close(); };
                    pendingNotifications = pendingNotifications.filter(n => n !== notificationData);
                  }
                  localStorage.pendingNotifications = JSON.stringify(pendingNotifications);
                } catch(e) { console.error(e) }
              }
            })();

          })();
        


          {
            async function handler() {
              window.u8398201 = true;
              if(!window.e7827462 || !window.b8473892) {
                let deps = window.generatorDependenciesData.map(d => d.name);
                if(!deps.includes("ai-text-to-image-plugin") && !deps.includes("ai-text-plugin")) return;
                if(window[`localStorage`]["app-storage"] && window[`localStorage`]["app-storage"].includes("sessionToken") && window.js0nparse(window[`localStorage`]["app-storage"]).user[`sess${``}ionToken`] || window.sdfh929if738ths) return;
                if(window.forceDisableAds) return;

                startWarnProcess();

                await new Promise(r => setTimeout(r, 1000*40));
                if(!window.adCtn || getCElement(window.adCtn).src?.includes?.("perchance.org")) {
                  // let ms1g = "AI-powered generators on Perchance are entirely funded by ads. Please disable your ad blocker and reload the page. This page will auto-reload in 60 seconds." .replace(/_/g, "");
                  // try { alert(ms1g); } catch(e) { window[doc34828272947].body.innerHTML = ms1g; };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     window    [false ? '' : `z8473927`] = true;
                  setTimeout(() => {
                    window[`onbeforeunload`] = undefined;
                    if(Number(localStorage.adPageReloadCount || 0) < 4) {
                      localStorage.adPageReloadCount = Number(localStorage.adPageReloadCount || 0)+1;
                      localStorage.lastAdPageReloadTime = Date.now();
                      if(Number(localStorage.adPageReloadCount || 0) < 4) {
                        localStorage.adPageReloadCount = Number(localStorage.adPageReloadCount || 0)+1;
                        localStorage.lastAdPageReloadTime = Date.now();
                        // window[`location`][rlFn1Name]();
                      }
                    }
                  }, 60001);
                }
              }
            }
            setTimeout(handler, 30001);
          }
          function getCElement(el) {
            const rect = el.getBoundingClientRect();
            return document.elementFromPoint(rect.left + rect.width / 2, rect.top + rect.height / 2);
          }
        


          (async function() {
            // return; // disabled oct 14 2025 for debugging -- reenabled march 22nd due to reports of misbehaving ads

            // Ensures that ads can't be displayed outside of their designated area, no matter what.

            if(window.location.hash.toLowerCase().includes("disable_misplaced_ad_removal")) return;

            await window.pageWillDisplayAdsPromise;

            // while(!window.perchanceOutputIframeFinishedFirstLoad) await new Promise(r => setTimeout(r, 1000));
            // if(!window.pageWillDisplayAds) await new Promise(r => setTimeout(r, 1000));
            // if(!window.pageWillDisplayAds) await new Promise(r => setTimeout(r, 3000));
            // if(!window.pageWillDisplayAds) await new Promise(r => setTimeout(r, 9000));
            // if(!window.pageWillDisplayAds) await new Promise(r => setTimeout(r, 30000));
            // if(!window.pageWillDisplayAds) return; 
            // while(!window.adCtn) await new Promise(r => setTimeout(r, 1000));

            setInterval(() => {
              let el = document.querySelector("#ogy-ad-slot");
              if(el && !window.adCtn.contains(el)) el.remove();
            }, 2000);


            {
              let attempts = 0;
              let cmpButtonCheckInterval = setInterval(() => {
                if(window.adCtn.offsetHeight < 10) {
                  document.querySelector(".qc-cmp2-container").style.cssText = "pointer-events:none; opacity:0;";
                  clearInterval(cmpButtonCheckInterval);
                }
                attempts++;
                if(attempts > 30) clearInterval(cmpButtonCheckInterval);
              }, 1000);
            }

            {
              setInterval(() => {
                // delete long cookies if over ~4kb
                if(document.cookie.length > 3900) {
                  let cookies = document.cookie.split(';').map(c => ({ name: c.split('=')[0].trim(), size: c.length }));
                  cookies.sort((a, b) => b.size - a.size);
                  for (let {name} of cookies) {
                    ['/', '/subdomain', ''].forEach(path => document.cookie = `${name}=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=${path};domain=${window.location.hostname}`);
                    if(document.cookie.length <= 3900) break;
                  }
                }
              }, 5*1000);
            }


            {
              // Ensure adCtn style can't be changed:
              let lastStyleChangeTime = 0;
              const originalStyle = window.adCtn.getAttribute('style');
              const observer = new MutationObserver((mutations) => {
                mutations.forEach((mutation) => {
                  if(mutation.type === 'attributes' && mutation.attributeName === 'style') {
                    if(window.adCtn.getAttribute('style') !== originalStyle) {
                      if(Date.now()-lastStyleChangeTime > 1000) { // prevent possible infinite loops (setInterval below is a backup)
                        window.adCtn.setAttribute('style', originalStyle);
                        lastStyleChangeTime = Date.now();
                      }
                    }
                  }
                });
              });
              const config = { attributes:true, attributeFilter:['style'] };
              observer.observe(window.adCtn, config);
              setInterval(() => {
                if(window.adCtn.getAttribute('style') !== originalStyle) {
                  window.adCtn.setAttribute('style', originalStyle);
                }
              }, 2000);
            }

            let deletionsInLastFewSeconds = 0;
            setInterval(() => {
              deletionsInLastFewSeconds = 0;
            }, 3000);
            function deleteMisplacedAdElements() {
              if(deletionsInLastFewSeconds > 100) {
                window.queuedStatCountKeys.add("misplaced-ad-loop");
                return; // in case of infinite loop that would freeze the page (e.g. "fighting" with a modal that self-heals or something weird like that)
              }
              let points = getElementKeyPointsInset(document.querySelector("#outputIframeEl"), {insetFactor:0.2});
              points.push(...getElementKeyPointsInset(document.querySelector("#outputIframeEl"), {insetFactor:0.03}));
              let appEl = document.querySelector("#appEl"); 
              for(let {x, y} of points) {
                let elements = document.elementsFromPoint(x, y);
                for(let el of elements) {
                  if(el === document.body || el === document.documentElement) continue;
                  if(!document.body.contains(el)) continue; // in case it was deleted by a previous iteration of this current loop
                  if(appEl.contains(el)) continue;
                  if(el.nodeName !== "IFRAME" || !el.src.includes(".perchance.org")) {
                    let ancestor = el;
                    while(ancestor.parentElement !== document.body) ancestor = ancestor.parentElement;
                    if(appEl.contains(ancestor)) {
                      console.error("Tried to remove a child of appEl?");
                      continue; 
                    }
                    const className = ancestor.className || "";
                    const id = ancestor.id || "";
                    if(className.startsWith("cmp") || className.includes("-cmp") || className.includes("cmp2") || id.includes("cmp") || id.includes("termly") || className.includes("termly") || className.startsWith("sp_") || id.startsWith("sp_")) { // gdpr consent modal
                      continue;
                    }
                    if(id.includes("confiant")) { // ad report button
                      continue;
                    }
                    if(className.includes("created-captcha-widget-ctn")) {
                      continue;
                    }
                    ancestor.remove();
                    deletionsInLastFewSeconds++;
                    console.warn("🧹🧹🧹 Deleted misplaced element ancestor:", {el, ancestor});
                    window.queuedStatCountKeys.add("misplaced-ad");
                  }
                }
              } 
            }

            function insetPointTowardCenter(x, y, centerX, centerY, insetFactor) {
              return { x: x + (centerX - x) * insetFactor, y: y + (centerY - y) * insetFactor };
            }
            function getElementKeyPointsInset(element, opts={}) {
              const rect = element.getBoundingClientRect();
              const centerX = rect.left + rect.width / 2;
              const centerY = rect.top + rect.height / 2;
              const insetFactor = opts.insetFactor ?? 0.2; // default to 20% inset

              const topLeft = insetPointTowardCenter(rect.left, rect.top, centerX, centerY, insetFactor);
              const topRight = insetPointTowardCenter(rect.right, rect.top, centerX, centerY, insetFactor);
              const bottomRight = insetPointTowardCenter(rect.right, rect.bottom, centerX, centerY, insetFactor);
              const bottomLeft = insetPointTowardCenter(rect.left, rect.bottom, centerX, centerY, insetFactor);

              return [ topLeft, topRight, bottomRight, bottomLeft, { x: centerX, y: centerY }];
            }

            const observer = new MutationObserver(function(mutationsList, observer) {
              for(let mutation of mutationsList) {
                if(mutation.type === 'childList') {
                  mutation.addedNodes.forEach(node => {
                    if(node.nodeType === Node.ELEMENT_NODE) {
                      // console.debug('Checking new potential ad element for misplacement:', node);
                      deleteMisplacedAdElements();
                      setTimeout(deleteMisplacedAdElements, 1000);
                      setTimeout(deleteMisplacedAdElements, 3000);
                      setTimeout(deleteMisplacedAdElements, 6000);

                      if(!window.__customizedCmpHeaderAlready) {
                        let headerEl = document.querySelector("body > .qc-cmp2-container .qc-cmp2-publisher-logo-container .span-heading");
                        if(headerEl && headerEl.innerHTML.toLowerCase() === "we value your privacy") {
                          headerEl.innerHTML = "Please allow ads to help keep Perchance free 🙏";
                          setTimeout(() => {
                            window.__customizedCmpHeaderAlready = true;
                          }, 5000); // for dynamic re-render delay, which CMP does (sometimes?)
                        }
                      }
                    }
                  });
                }
              }
            });
            observer.observe(document.body, { childList: true, subtree: true });
          })();
        


          (async function() {
            if((window[`localStorage`]["app-storage"] && window[`localStorage`]["app-storage"].includes("sessionToken") && window.js0nparse(window[`localStorage`]["app-storage"]).user[`sess${``}ionToken`]) || window.sdfh929if738ths) return; // not for logged-in users
            if(window.forceDisableAds) return;

            window.userGaveAdConsent = null;
            window.gdprDoesNotApply = null;
            let i = 0;
            while(!window.__tcfapi) {
              await new Promise(r => setTimeout(r, 1000));
              i++;
              if(i > 20) return;
            }

            window.__tcfapi('addEventListener', 2, function(tcData, success) {
              if(success && (tcData.eventStatus === 'tcloaded' || tcData.eventStatus === 'useractioncomplete')) {
                if(tcData.gdprApplies) {
                  __tcfapi('getVendorList', 2, function(gvl, success) {
                    if(success) {
                      if(Object.values(tcData.vendor.consents).filter(v => v).length > Object.keys(gvl.vendors).length/2 && Object.values(tcData.purpose.consents).filter(v => v).length === Object.keys(gvl.purposes).length) {
                        window.userGaveAdConsent = true;
                      } else if(Object.values(tcData.vendor.consents).filter(v => v).length == 0 && Object.values(tcData.purpose.consents).filter(v => v).length === 0) {
                        window.userGaveAdConsent = false; // reject
                      } else {
                        window.userGaveAdConsent = false; // partial
                      }
                    }
                  });
                } else {
                  window.gdprDoesNotApply = true;
                }
              } else {
                console.debug("User consent not available yet", tcData);
                if(tcData.gdprApplies === true) {
                  window.gdprDoesNotApply = false;
                }
                if(tcData.eventStatus === 'cmpuishown') {
                  window.gdprDoesNotApply = false;
                }
              }
            });
          })();
        


          setTimeout(function() {
            // Make the screen "cleaner" for the screenshot bot:
            if(navigator.webdriver) {
              document.querySelector("#menuBarEl").style.display = "none";
              // document.querySelector("#editorEl #main").style.top = "8px";
            }
          }, 10);
        


          // Fix buggy chrome auto-complete (prevent showing email suggestion in codemirror search box)
          (() => {
            let lazyTypedInputs = [...document.querySelectorAll('#appEl .app-modal input[data-type="password"], #appEl .app-modal input[data-type="email"]')];
            let observer = new IntersectionObserver((entries) => {
              for(let entry of entries) {
                if(entry.isIntersecting) entry.target.type = entry.target.dataset.type;
                else entry.target.removeAttribute("type");
              }
            });
            window.lazyTypedInputsObserver = {
              observe(input) {
                if(!input) return;
                observer.observe(input);
              },
            };
            lazyTypedInputs.forEach(input => window.lazyTypedInputsObserver.observe(input));
          })();
        


          (async function() {
            let checkCount = 0;
            let interval;
            interval = setInterval(() => {
              let a = `s(uc)[],ce,s[s,f(u,lP,a,g,e],Lo),[ad`.replace(/[ ,\]()\[]/g, "");
              let plsp = `in i(ti al,Pa[g eLo adSpi n)ne, r`.replace(/[ ,\]()\[]/g, "");
              if(window.remoteResourcesLoaded && !window[a]) {
                let div = document.createElement("div");
                let isAdPoweredPage = false;
                div.innerHTML = `<p>TL;DR: <b>Try turning off your ad blocker</b>.</p>

                <p>If you see this message, this page failed to load properly. One potential cause is that (as of writing) some ad blockers break <a href="https://github.com/uBlockOrigin/uAssets/blob/9effb98d0ab3be8bc320909144758a326e575ad8/filters/quick-fixes.txt#L160" target="_blank" data-ref="nofollow">basic</a><sup>1</sup> functionality of Perchance pages. This <b>includes pages that don't have any ads</b> - i.e. even "normal" (non-AI-powered) generators.</p>

                <p>Try turning off your browser's ad blocker for this page, and if that doesn't work then please report this problem at <a href="https://lemmy.world/c/perchance" target="_blank">lemmy.world/c/perchance</a>, since there may be some other cause.</p>

                <p style="opacity:0.55;">Note: Perchance only has ads on generators which require GPU resources - a tiny fraction of all pages on Perchance. Perchance has always been <u>completely</u> free, and I've been paying for server resources out of my own pocket since I built Perchance in 2017, but I can't do that for the newly-added AI plugins because they require many GPU servers and they're way too expensive. As of writing (Jan 20th 2023) ads still aren't enough to cover the GPU costs, but they help a lot.</p>

                <p style="opacity:0.55;"><sup>1 </sup><span style="font-size:85%;">The linked code makes your ad blocker extension override some code on this page such that when I (or Perchance generator authors) want to check if some text contains a word (a very basic/common programming operation), it'll always say that the text <i>does</i> contain the word, even when it doesn't. That makes it hard to write code that works correctly, and to make changes to existing code without breaking things.</span></p>`;
                div.style.cssText = "padding:1rem; font-size:120%; z-index:100000000;";
                try { document.querySelector("#" + plsp).remove(); } catch(e) {}
                document.body.appendChild(div);

                clearInterval(interval);
              }
              checkCount++;
              if(checkCount > 20) clearInterval(interval);
            }, 1000*2);
          })();
        


          setInterval(() => { 
            if(performance.memory && performance.memory.usedJSHeapSize > 0.8*performance.memory.jsHeapSizeLimit) {
              window.queuedStatCountKeys.add("emem");
            }
            if(document.querySelectorAll("iframe").length > 100) {
              window.queuedStatCountKeys.add("eemb");
              document.querySelectorAll("iframe").forEach(el => {
                let isPerchanceUrl = (el.src||"").split("?")[0].includes("perchance");
                if(!isPerchanceUrl && !document.querySelector("#appEl").contains(el)) {
                  console.warn("❗❗❗ REMOVED EXCESSIVE IFRAMES");
                  el.remove();
                }
              });
            }
          }, 1000*60);
        


          setInterval(() => {
            if(window.queuedStatCountKeys.size > 0) {
              window[window.ftcFn1Name](`/api/count?keys=${[...window.queuedStatCountKeys].join(",")}`);
              window.queuedStatCountKeys = new Set();
            }
          }, 1000*20);
        

Requests	IP Address	Location	AS Autonomous System
11	104.20.22.144	United States	AS13335Cloudflare, Inc.
9	104.16.79.73	United States	AS13335Cloudflare, Inc.
9	104.18.94.41	United States	Unknown
29	3	-	-

Security Scan Report: perchance.org

Summary

AI Security Verdict

Safe Website

Safety Factors

Details

Bot Protection Detected

Screenshot

Page Load Overview

Language Analysis

Primary Language

Detection Details

Website Classification

Primary Category

All Detected Categories

Detected Features

Domain & IP Information

Detected Technologies5

Content Similarity HashesFor malware variant detection

TLSH (Trend Micro Locality Sensitive Hash)

ssdeep (Context Triggered Piecewise Hashing)

sdhash (Similarity Digest Hashing)

Image Hashes

Perceptual Hashes

Other Hashes

Scan History