diff --git a/loader.ebc.user.js b/loader.ebc.user.js
index 11e3205..ffd2b34 100644
--- a/loader.ebc.user.js
+++ b/loader.ebc.user.js
@@ -7,12 +7,11 @@
 // @description:en  PEX local-dev loader for EBC (loads the build from localhost:8000)
 // @author       PEX
 // @supportURL   https://github.com/Nice8923/BC-PEX
-// @include      /^https:\/\/(www\.)?bondage(projects\.elementfx|-(europe|asia))\.com\/.*/
+// @include      /^https?:\/\/(www\.)?(bondageprojects\.com|bondageprojects\.elementfx\.com|bondage-europe\.com|bondage-asia\.com)\/.*/
 // @grant        none
 // @run-at       document-end
 // ==/UserScript==
 
-window.PEX = window.PEX ?? {};
 if (window.PEX) {
     console.warn('⚗️[PEX] 已加载，跳过重复导入。');
 } else {
diff --git a/loader.embedded.user.js b/loader.embedded.user.js
index 95e3d3d..d98ea27 100644
--- a/loader.embedded.user.js
+++ b/loader.embedded.user.js
@@ -7,16 +7,15 @@
 // @description:en  Persona excretion gameplay: dizzy → excrete → blank → gel → feed-back recovery. Built-in sounds & expressions, /pex commands.
 // @author       PEX
 // @supportURL   https://github.com/Nice8923/BC-PEX
-// @include      /^https:\/\/(www\.)?bondage(projects\.elementfx|-(europe|asia))\.com\/.*/
+// @include      /^https?:\/\/(www\.)?(bondageprojects\.com|bondageprojects\.elementfx\.com|bondage-europe\.com|bondage-asia\.com)\/.*/
 // @grant        none
 // @run-at       document-end
 // ==/UserScript==
 
-window.PEX = window.PEX ?? {};
 if (window.PEX) {
     console.warn('⚗️[PEX] 已加载，跳过重复加载。');
 } else {
-    const CODE = 'const N="0.1.34";const gt="PEX_Settings",Gn=["人格药水","人格药剂","persona potion","personality extraction"],Vn=["凝胶药剂","凝胶药水","plain gel","normal gel"],Kn=[{Eyebrows:"Soft",Eyes:"VeryLewd",Mouth:"Frown",Blush:"High"},{Eyebrows:"Lowered",Eyes:"HeartPink",Mouth:"Moan",Blush:"High"}],Hn={Eyebrows:"Raised",Eyes:"LewdHeartPink",Mouth:"Ahegao",Blush:"VeryHigh"},jn={Eyebrows:"Lowered",Eyes:"Dazed",Mouth:"Frown",Blush:"VeryHigh"},zn={Eyebrows:"Lowered",Eyes:"Lewd",Mouth:"Open",Blush:"Medium"},Wn="https://cdn.jsdelivr.net/gh/Nice8923/BC-PEX@main/Sound/",X=e=>Wn+e,Ue={wait:[X("wait_1.mp3"),X("wait_2.mp3"),X("wait_3.mp3"),X("wait_4.mp3"),X("wait_5.mp3")],excrete:[X("excrete.mp3")],feed:[X("feed.mp3")]};function R(){return{enabled:!0,keywords:[...Gn],normalKeywords:[...Vn],waitSeconds:50,blockedWaitMinutes:15,autoRevertEnabled:!0,autoRevertMinutes:15,gelExpireMode:"vanish",normalExpressionSeconds:5,effectLevel:3,viewMode:"surround",blindLevel:2,timerVisibility:"all",fxDizzy:!0,fxBlank:!0,fxBlur:!0,fxShake:!0,restrictions:!0,seeRemoteAnims:!0,hearRemoteSounds:!1,expressions:{wait:Kn.map(e=>({...e})),excrete:{...Hn},blank:{...jn}},normalExpression:{...zn},gelLayer:24,sounds:{wait:Ue.wait.map(e=>e),excrete:Ue.excrete.map(e=>e),feed:Ue.feed.map(e=>e)},soundOn:{wait:!0,excrete:!0,feed:!0},editModes:{time:"off",autoRevert:"off",timerVisibility:"off"},whitelist:[]}}let l=R();function Ge(e){l=e}let on=null;function Un(e){on=e}function U(){return on}const Ot={zh:{loaded:"⚗️ PEX v{v} 已加载。输入 /pex help 查看指令。",help:["⚗️ PEX v{v} 指令：","/pex help     — 本帮助","/pex howto    — 玩法说明","/pex show     — 打开/关闭游戏内控制台面板","/pex status   — 查看当前状态","/pex reset    — 强制恢复（清除等待/失神/凝胶状态）","/pex settings — 打开设置页","/pex save     — 立即保存设置","调试：按 F12 或 Ctrl+Shift+I 打开浏览器控制台，","把 ⚗️[PEX] 开头的报错信息发给作者。"].join(`
`),cmdUnknown:"未知指令：/pex {sub}（/pex help 查看帮助）",howto:["⚗️ PEX 玩法说明：",'1. 制作一瓶饮料（游戏自带道具），在制作名/描述写触发关键词（如"人格药水"）。',"2. 喝下或注射带关键词的饮料 → 一阵阵越来越晕。","3. 到排出时刻检查臀部装备位：没东西就排出；","   有东西会等待（拿掉立刻排），超上限则药效消失。","4. 人格凝胶排出后失神（黑白/不能动/视野变窄/禁言），凝胶落在脚边。",'5. 点击失神者 → 对话框"捡起凝胶"（手要空）。',"6. 把凝胶交还原主人，主人喝下自己的凝胶 → 恢复；","   默认15分钟没喂回自动恢复，凝胶消散（可关闭）。","7. 普通凝胶（另一套关键词）：无眩晕失神，只有短暂表情变化。",'8. 安全：/pex reset 或设置页"强制恢复"。',"更多：/pex settings 里有完整玩法说明页。"].join(`
`),resetDone:"已强制恢复，所有状态已清除。",resetConfirm:"确定要强制恢复吗？此操作会立即清除全部 PEX 状态。",statusLine:"当前状态：{state}",stateIdle:"正常",stateWaiting:"等待排出（剩余 {sec} 秒）",stateBlocked:"臀部有物品遮挡，等待中（剩余 {min} 分 {sec} 秒）",stateExcreting:"排出中…",stateBlank:"失神中（剩余 {min} 分 {sec} 秒）",stateBlankNormal:"凝胶排出（剩余 {min} 分 {sec} 秒）",cantOpenSettings:"无法打开设置页（当前画面不支持）。",noChatBox:"找不到聊天框，请先进入聊天室再输入 /pex show。",gelExpired:"%NAME%的人格凝胶随时间消散了。",gelExpiredNormal:"%NAME%的普通凝胶随时间消散了。",gelInvalidated:"%NAME%的人格凝胶失去了效力，变成了无效凝胶…",gelInvalidatedNormal:"%NAME%的普通凝胶失去了效力，变成了无效凝胶…",profileEditBtn:"远程编辑对方 PEX 设置",profileEditNoPerm:"不在对方白名单，无法编辑",profileEditOff:"对方不允许远程修改",accessedYourPEX:"{who} 查看了你的 PEX 设置",editedYourPEX:"{who} 修改了你的 PEX 设置",remoteEditLoading:"正在获取 {name} 的 PEX 设置…",remoteEditLoadFail:"获取失败：对方未安装 PEX 或未响应，可重试。"}};let rt="zh";async function Yn(){return rt="zh",rt}function x(e,t={}){let n=Ot[rt]?.[e]??Ot.zh[e]??e;for(const[r,i]of Object.entries(t))n=n.split(`{${r}}`).join(String(i));return n}const $t=250,de=[],oe=new Map;let q=null,Bt=0;function qn(e){const t=[];try{Player&&typeof Player.MemberNumber=="number"&&t.push({SourceCharacter:Player.MemberNumber})}catch{}return Array.isArray(e)?t.concat(e):t}function it(){if(q=null,!de.length)return;const e=Date.now(),t=Math.max(0,$t-(e-Bt));if(t>0){q=setTimeout(it,t);return}const n=de.shift();try{typeof ServerSend=="function"&&ServerSend("ChatRoomChat",n.payload)}catch{}Bt=Date.now(),de.length&&!q&&(q=setTimeout(it,$t))}function P(e,t,n={}){const{dedupeKey:r=null,dedupeMs:i=800,priority:o=!1}=n;if(r){const c=Date.now(),u=oe.get(r);if(u&&c-u<i)return!1;if(oe.set(r,c),oe.size>200)for(const[d,h]of oe)c-h>6e4&&oe.delete(d)}const a={payload:{Type:"Hidden",Content:e,Dictionary:qn(t)}};return o?de.unshift(a):de.push(a),q||(q=setTimeout(it,0)),!0}function b(e,t){try{const n=Jn(e);if(!n)return;const r={Type:"Action",Content:n};t!=null&&(r.Target=t),typeof ServerSend=="function"&&ServerSend("ChatRoomChat",r),setTimeout(()=>{try{const i=document.getElementById("TextAreaChatLog");i&&(i.scrollTop=i.scrollHeight)}catch{}},60)}catch{}}function Jn(e){let t="";try{t=CharacterNickname(Player)||""}catch{}return String(e).split("%NAME%").join(t).split("%POSSESSIVE%").join("自己的").split("%OPP_NAME%").join("对方").split("%OPP_POSSESSIVE%").join("对方的").split("%PRONOUN%").join("自己").split("%INTENSIVE%").join("自己")}const xt=[];function ie(e){typeof e=="function"&&xt.push(e)}function an(e){if(e)try{e.hookFunction("TextQueryMultiple",0,(t,n)=>{const r=t&&t[0],i=n(t);return typeof i=="string"&&i.indexOf("MISSING TEXT IN")>=0&&typeof r=="string"?r:i})}catch{}}function ot(e){if(e)try{e.hookFunction("ChatRoomMessage",1,(t,n)=>{const r=n(t);try{const i=t[0];if(!i||typeof i!="object")return r;for(const o of xt)try{o(i)}catch{}}catch{}return r})}catch(t){console.warn("⚗️[PEX] ChatRoomMessage 挂钩失败:",t.message)}}function Qn(){xt.length=0}const Zn=Object.freeze(Object.defineProperty({__proto__:null,clearMessageHandlers:Qn,pexOnMessage:ie,pexSendAction:b,pexSendHidden:P,registerMessageHook:ot,registerTextQueryHook:an},Symbol.toStringTag,{value:"Module"}));function bt(e,t){if(Array.isArray(e))return Array.isArray(t)?t:e;if(e&&typeof e=="object"){const n={};for(const r of Object.keys(e))n[r]=t&&r in t?bt(e[r],t[r]):e[r];return n}return t===void 0?e:t}function vt(){const e=l;return{v:1,enabled:e.enabled,keywords:e.keywords,normalKeywords:e.normalKeywords,waitSeconds:e.waitSeconds,blockedWaitMinutes:e.blockedWaitMinutes,autoRevertEnabled:e.autoRevertEnabled,autoRevertMinutes:e.autoRevertMinutes,gelExpireMode:e.gelExpireMode,normalExpressionSeconds:e.normalExpressionSeconds,effectLevel:e.effectLevel,viewMode:e.viewMode,blindLevel:e.blindLevel,timerVisibility:e.timerVisibility,fxDizzy:e.fxDizzy,fxBlank:e.fxBlank,fxBlur:e.fxBlur,fxShake:e.fxShake,restrictions:e.restrictions,seeRemoteAnims:e.seeRemoteAnims,expressions:e.expressions,normalExpression:e.normalExpression,gelLayer:e.gelLayer,editModes:e.editModes,whitelist:e.whitelist}}const sn="PEX_sounds";function ln(){try{const e=localStorage.getItem(sn),t=R().sounds;if(e){const n=JSON.parse(e),r=n&&typeof n=="object"&&!Array.isArray(n)&&"sounds"in n?n.sounds:n,i=Array.isArray(r?.drink)?r.drink:[],o={wait:[],excrete:[],feed:[]};for(const s of["wait","excrete","feed"]){const a=r?.[s];o[s]=Array.isArray(a)&&a.length>0?a.slice():t[s].slice()}i.length&&(o.wait=i.concat(o.wait)),l.sounds=o,n&&typeof n.soundOn=="object"&&n.soundOn&&(l.soundOn=Object.assign({},R().soundOn,n.soundOn))}else l.sounds={wait:t.wait.slice(),excrete:t.excrete.slice(),feed:t.feed.slice()},l.soundOn=R().soundOn}catch{}}function Re(){try{localStorage.setItem(sn,JSON.stringify({sounds:l.sounds,soundOn:l.soundOn}))}catch{}}function De(){try{return"PEX_settings_backup_"+(Player?.MemberNumber||Player?.AccountName||"anon")}catch{return"PEX_settings_backup_anon"}}let Le=!1;function at(e){try{if(!e)return null;const t=LZString.decompressFromBase64(e);return t?JSON.parse(t):null}catch{return null}}function er(e){Ge(bt(R(),e))}function tr(e=15e3){const t=Date.now();return new Promise(n=>{const r=()=>{try{Player&&Player.ExtensionSettings!==void 0?n(!0):Date.now()-t>e?n(!1):setTimeout(r,200)}catch{n(!1)}};r()})}function cn(){let e=null,t=null;try{e=Player?.ExtensionSettings?.["PEX"]??null}catch{}try{t=localStorage.getItem(De())}catch{}const n=at(e),r=at(t),i=n&&+n.ts||0,o=r&&+r.ts||0;let s=null,a=null,c=!1;n&&i>=o?(s=n,a=e):r?(s=r,a=t,c=i<o):n&&(s=n,a=e);let u=!1;if(s)try{er(s),u=!0}catch(d){nr(d)}if(u||Ge(R()),l.timerVisibility==="both"&&(l.timerVisibility="all"),Array.isArray(l.expressions)){const d=l.expressions,h=R().expressions;l.expressions={wait:[d[0],d[1]].filter(Boolean).map(A=>({...A})),excrete:d[2]?{...d[2]}:h.excrete,blank:d[3]||d[0]?{...d[3]||d[0]}:h.blank}}if(Le=!0,ln(),u&&a){try{localStorage.setItem(De(),a)}catch{}if(c)try{Player.ExtensionSettings||(Player.ExtensionSettings={}),Player.ExtensionSettings.PEX=a,typeof ServerPlayerExtensionSettingsSync=="function"&&ServerPlayerExtensionSettingsSync("PEX"),console.log("⚗️[PEX] 账号数据落后/丢失，已从本地备份还原并补回账号")}catch{}}}let I=null;function Ye(){try{if(I&&(clearTimeout(I),I=null),Le&&Player){Player.ExtensionSettings||(Player.ExtensionSettings={});const e=vt();e.ts=Date.now();const t=JSON.stringify(e),n=LZString.compressToBase64(t);Player.ExtensionSettings.PEX=n;try{localStorage.setItem(De(),n)}catch{}Re();try{typeof ServerPlayerExtensionSettingsSync=="function"&&ServerPlayerExtensionSettingsSync("PEX")}catch{}try{typeof ServerSendQueueProcess=="function"&&ServerSendQueueProcess()}catch{}}}catch{}}typeof window<"u"&&!window._pexSaveFlush&&(window._pexSaveFlush=Ye,window.addEventListener("pagehide",Ye),window.addEventListener("beforeunload",Ye));function _(e=!1){if(!Le)return;const t=()=>{try{if(!Le||!Player)return;Player.ExtensionSettings||(Player.ExtensionSettings={});const n=vt();n.ts=Date.now();const r=JSON.stringify(n),i=LZString.compressToBase64(r),o=at(i);if(!o||typeof o!="object"){console.warn("⚗️[PEX] 存档校验失败，跳过本次写入");return}i.length>ES_BUDGET&&console.warn("⚗️[PEX] 设置过大（"+i.length+" 字节 > "+ES_BUDGET+"），服务器可能拒收：请减少表情/关键词/音效"),Player.ExtensionSettings.PEX=i,typeof ServerPlayerExtensionSettingsSync=="function"&&ServerPlayerExtensionSettingsSync("PEX");try{localStorage.setItem(De(),i)}catch{}Re()}catch(n){console.warn("⚗️[PEX] 保存失败:",n.message)}};if(e){I&&(clearTimeout(I),I=null),t();return}I&&clearTimeout(I),I=setTimeout(()=>{I=null,t()},600)}let F=null,Xt="";function T(e,t=!1){try{if(!Player||!Player.OnlineSharedSettings)return;Player.OnlineSharedSettings.PEX||(Player.OnlineSharedSettings.PEX={});const n=JSON.stringify(e);if(n===Xt&&!t)return;Xt=n;const r=()=>{const i=Object.assign({},e);i.timerVisibility===void 0&&(i.timerVisibility=l.timerVisibility||"both"),Player.OnlineSharedSettings.PEX.state=i,typeof ServerAccountUpdate?.QueueData=="function"&&ServerAccountUpdate.QueueData({OnlineSharedSettings:Player.OnlineSharedSettings},!0);try{P("PEX_StateSync",[{Tag:"Payload",Value:JSON.stringify(i)}],{dedupeKey:"state:"+(e?.mode||"")+":"+(e?.remainingSec||0)+":"+(e?.gelHolder??""),dedupeMs:4e3})}catch{}};t?(F&&(clearTimeout(F),F=null),r()):(F&&clearTimeout(F),F=setTimeout(()=>{F=null,r()},1e3))}catch{}}let G=null;function ge(e=!1){const t=()=>{try{if(!Player||!Player.OnlineSharedSettings)return;const n=l.editModes||{},r=a=>a==="any"||a==="whitelist",o=["time","autoRevert","timerVisibility"].some(a=>r(n[a])),s=Player.OnlineSharedSettings.PEX?.state;Player.OnlineSharedSettings.PEX={v:N,state:s||null,edit:o,editModes:{time:n.time||"off",autoRevert:n.autoRevert||"off",timerVisibility:n.timerVisibility||"off"},wl:Array.from(l.whitelist||[])},typeof ServerAccountUpdate?.QueueData=="function"&&ServerAccountUpdate.QueueData({OnlineSharedSettings:Player.OnlineSharedSettings},!0);try{P("PEX_SharedSync",[{Tag:"Payload",Value:JSON.stringify({edit:o,editModes:{time:n.time||"off",autoRevert:n.autoRevert||"off",timerVisibility:n.timerVisibility||"off"},wl:Array.from(l.whitelist||[])})}],{dedupeKey:"shared",dedupeMs:3e3})}catch{}}catch{}};if(e){G&&(clearTimeout(G),G=null),t();return}G&&clearTimeout(G),G=setTimeout(()=>{G=null,t()},2e3)}function un(){try{const e={plugin:"PEX",v:N,pex:vt()},t=new Blob([JSON.stringify(e,null,2)],{type:"application/json"}),n=URL.createObjectURL(t),r=document.createElement("a");r.href=n,r.download="PEX-settings.json",document.body.appendChild(r),r.click(),r.remove(),setTimeout(()=>URL.revokeObjectURL(n),1e3)}catch(e){console.warn("⚗️[PEX] 导出失败:",e.message)}}function dn(){const e=document.createElement("input");e.type="file",e.accept="application/json,.json",e.onchange=()=>{const t=e.files&&e.files[0];if(!t)return;const n=new FileReader;n.onload=()=>{try{const r=JSON.parse(String(n.result)),i=r.pex||r;Ge(bt(R(),i)),_(!0),ge(!0),console.log("⚗️[PEX] 设置导入完成")}catch(r){console.warn("⚗️[PEX] 导入失败:",r.message)}},n.readAsText(t)},e.click()}function nr(e){try{console.warn("⚗️[PEX] 设置应用失败:",e.message)}catch{}}const m={IDLE:"idle",WAITING:"waiting",BLOCKED:"blocked",EXCRETING:"excreting",BLANK:"blank"},f={mode:m.IDLE,gelType:"persona",phaseStartedAt:0,phaseEndsAt:0,ownerMemberNumber:null,gelId:null,gelHolder:null};function C(e,t={}){f.mode=e,f.phaseStartedAt=Date.now(),f.phaseEndsAt=t.endsAt??0,t.ownerMemberNumber!==void 0&&(f.ownerMemberNumber=t.ownerMemberNumber),t.gelId!==void 0&&(f.gelId=t.gelId),t.gelHolder!==void 0&&(f.gelHolder=t.gelHolder),t.gelType!==void 0&&(f.gelType=t.gelType)}function fn(){const e=f;switch(e.mode){case m.IDLE:return x("stateIdle");case m.WAITING:{const t=Math.max(0,Math.round((e.phaseEndsAt-Date.now())/1e3));return x("stateWaiting",{sec:t})}case m.BLOCKED:{const t=Math.max(0,Math.round((e.phaseEndsAt-Date.now())/1e3));return x("stateBlocked",{min:Math.floor(t/60),sec:t%60})}case m.EXCRETING:return x("stateExcreting");case m.BLANK:{const t=Math.max(0,Math.round((e.phaseEndsAt-Date.now())/1e3));return e.gelType==="normal"?x("stateBlankNormal",{min:Math.floor(t/60),sec:t%60}):x("stateBlank",{min:Math.floor(t/60),sec:t%60})}default:return x("stateIdle")}}const ce=[],Ft=40;function pn(e){try{const t=new Date,n=i=>String(i).padStart(2,"0"),r="["+n(t.getHours())+":"+n(t.getMinutes())+":"+n(t.getSeconds())+"] "+e.map(i=>typeof i=="string"?i:rr(i)).join(" ");ce.push(r),ce.length>Ft&&ce.splice(0,ce.length-Ft)}catch{}}function rr(e){try{return JSON.stringify(e)}catch{return String(e)}}function p(...e){pn(e),console.log("⚗️[PEX]",...e)}function Oe(...e){pn(e),console.warn("⚗️[PEX]",...e)}function Gt(e,t){return!e||!t?!1:String(e).toLowerCase().includes(String(t).toLowerCase())}function ne(e,t=""){try{return CharacterNickname(e)}catch{return t}}function ir(e){if(!e||typeof e!="string")return"";if(!e.startsWith("\0"))return e;try{return Array.from(e.slice(1,200)).flatMap(t=>{const n=t.charCodeAt(0),r=Math.floor(n/256),i=n-r*256;return[r,i].filter(Boolean).map(o=>String.fromCharCode(o))}).join("")}catch{return""}}function st(e){if(!e)return"";const t=[];try{typeof e.Craft?.Name=="string"&&t.push(e.Craft.Name),typeof e.Craft?.Description=="string"&&t.push(ir(e.Craft.Description)),typeof e.Description=="string"&&t.push(e.Description),typeof e.Name=="string"&&t.push(e.Name),typeof e.Asset?.Name=="string"&&t.push(e.Asset.Name),typeof e.Asset?.Description=="string"&&t.push(e.Asset.Description)}catch{}return t.filter(Boolean).join(" ")}let ae=null;const Vt=new Map;function mn(){try{if(!ae){const e=window.AudioContext||window.webkitAudioContext;if(!e)return null;ae=new e}if(ae.state==="suspended")try{ae.resume()}catch{}return ae}catch{return null}}function or(e){try{const t=String(e).match(/^https:\/\/cdn\.jsdelivr\.net\/gh\/([^/]+)\/([^@]+)@([^/]+)\/(.+)$/);return t?"https://raw.githubusercontent.com/"+t[1]+"/"+t[2]+"/"+t[3]+"/"+t[4]:null}catch{return null}}function Kt(e,t){try{const n=mn();if(!n||!e)return!1;const r=n.createBufferSource();r.buffer=e;const i=n.createGain();return i.gain.value=Math.max(0,Math.min(1,t||1)),r.connect(i),i.connect(n.destination),r.start(),!0}catch{return!1}}function Et(e,t=1){try{if(!e)return;const n=mn();if(!n){typeof AudioPlaySoundEffect=="function"&&AudioPlaySoundEffect(String(e));return}const r=String(e),i=Vt.get(r);if(i){Kt(i,t);return}const o=[r,or(r)].filter(Boolean);let s=0;const a=()=>{if(s>=o.length)return;const c=o[s++];fetch(c).then(u=>{if(!u.ok)throw new Error("HTTP "+u.status);return u.arrayBuffer()}).then(u=>n.decodeAudioData(u)).then(u=>{Vt.set(r,u),Kt(u,t)}).catch(()=>a())};a()}catch{}}function yn(){return .55+Math.max(1,Math.min(5,l?.effectLevel||3))*.09}function hn(e){try{if(l?.soundOn&&l.soundOn[e]===!1)return null;const t=l?.sounds?.[e];if(!Array.isArray(t)||t.length===0)return null;const n=t[Math.floor(Math.random()*t.length)];return n&&Et(String(n),yn()),n||null}catch{return null}}function Pe(e){try{if(e==null)return null;if(Player&&Player.MemberNumber===e)return Player;if(typeof ChatRoomCharacter<"u"&&Array.isArray(ChatRoomCharacter))return ChatRoomCharacter.find(t=>t&&t.MemberNumber===e)||null}catch{}return null}let $e=0,St=0;function B(e){$e=Math.max(0,e||0)}function gn(){$e=0}function wt(e){St=Math.max(0,Math.min(3,e||0))}function xn(){St=0}function ar(){if($e<=0)return 0;try{if(Player?.GraphicsSettings?.AllowBlur===!1)return 0}catch{}return $e}function sr(){return St}function lr(e){if(e)try{e.hookFunction("Player.GetBlurLevel",4,(t,n)=>{let r=0;try{r=n(t)||0}catch{}const i=ar();return i>r?i:r}),e.hookFunction("Player.GetBlindLevel",4,(t,n)=>{let r=0;try{r=n(t)||0}catch{}const i=sr();return i>r?i:r})}catch(t){console.warn("⚗️[PEX] GetBlurLevel 挂钩失败:",t.message)}}const qe="pex-overlay";let j=null,fe=null,xe=!1,Ht=3,w=null,jt=!1;function Y(){return document.getElementById("MainCanvas")||document.querySelector("canvas")}function Pt(){if(j&&document.getElementById(qe))return j;let e=document.getElementById(qe);return e||(e=document.createElement("div"),e.id=qe,Object.assign(e.style,{position:"fixed",left:"0",top:"0",width:"100%",height:"100%",pointerEvents:"none",zIndex:"99998",overflow:"hidden"}),document.body.appendChild(e)),j=e,e}function bn(){if(!jt){jt=!0;try{const e=document.createElement("style");e.id="pex-anim-styles",e.textContent="@keyframes pexDizzyFlash{0%,100%{opacity:0.04}30%{opacity:0.16}60%{opacity:0.24}85%{opacity:0.10}}@keyframes pexDizzyPulse{0%,100%{opacity:0.25}40%{opacity:0.85}70%{opacity:0.35}}",document.head.appendChild(e)}catch{}}}function vn(e,t=3){z(),Ht=Math.max(1,Math.min(5,t||3)),xe=!0,bn();const n=Pt(),r=document.createElement("div");r.style.cssText="position:fixed;inset:0;pointer-events:none;background:radial-gradient(circle at 50% 50%, transparent 42%, rgba(242,123,168,0.55));animation:pexDizzyFlash 1400ms ease-in-out infinite;",n.appendChild(r);const i=document.createElement("div");i.style.cssText="position:fixed;inset:0;pointer-events:none;background:radial-gradient(ellipse at 50% 50%, transparent 35%, rgba(15,8,28,0.42) 100%);animation:pexDizzyPulse 1400ms ease-in-out infinite;",n.appendChild(i);const o=1400,s=800,a=Math.max(2,Math.round(e/o));let c=0,u=0;const d=h=>{if(xe){if(h-u>=100){u=h;const A=h%o/o,k=Math.min(1,c/Math.max(1,a-1)),D=h%o<s?Math.sin(A/(s/o)*Math.PI):0;B(D>.02?1+2.2*k*(Ht/3)*D:.3),A<.05&&c<a&&c++}fe=requestAnimationFrame(d)}};fe=requestAnimationFrame(d)}function cr(e=1500){if(!xe)return;const t=performance.now();let n=0;const r=i=>{if(!xe)return;const o=Math.min(1,(i-t)/e);i-n>=100&&(n=i,B(.4*(1-o))),o<1?requestAnimationFrame(r):z()};requestAnimationFrame(r)}function z(){xe=!1,fe&&(cancelAnimationFrame(fe),fe=null),B(0);const e=Y();if(e){e.style.transition="",e.style.transform="";const t=e.style.filter||"";e.style.filter=t.replace(/blur\([^)]*\)/g,"").trim()}j&&(j.innerHTML="")}let pe=null,_e=!1;function ur(e,t=3,n=!0,r=!0){if(re(),!n&&!r)return;if(_e=!0,bn(),n){const a=Pt(),c=document.createElement("div");c.style.cssText="position:fixed;inset:0;pointer-events:none;background:radial-gradient(circle at 50% 50%, transparent 40%, rgba(242,123,168,0.62));animation:pexDizzyFlash 900ms ease-in-out infinite;",a.appendChild(c)}r&&B(3+(t||3)*.8);const i=Y(),o=3+(t||3)*1.2,s=()=>{if(_e){if(i&&n){const a=(Math.random()-.5)*o*2,c=(Math.random()-.5)*o*2;i.style.transform=`translate(${a.toFixed(1)}px, ${c.toFixed(1)}px)`}pe=requestAnimationFrame(s)}};pe=requestAnimationFrame(s),setTimeout(()=>{_e&&re()},Math.max(500,e))}function re(){_e=!1,pe&&(cancelAnimationFrame(pe),pe=null);const e=Y();e&&(e.style.transform=""),j&&(j.innerHTML="")}let Ve=!1;function Mt(e="surround"){Ve=!0;const t=Y();if(t){const r=t.style.filter||"";r.includes("grayscale")||(t.style.filter=(r?r+" ":"")+"grayscale(1)")}const n=Pt();if(w&&w.remove(),e!=="all"){if(w=document.createElement("div"),w.style.cssText="position:fixed;inset:0;pointer-events:none;z-index:99997;",e==="surround"){const i=.3+.13*(Math.max(1,Math.min(5,l.effectLevel||3))-1);w.style.background=`radial-gradient(ellipse at 50% 55%, transparent 0%, transparent 28%, rgba(5,5,10,${i.toFixed(2)}) 55%, rgba(5,5,10,${Math.min(.95,i+.27).toFixed(2)}) 100%)`}else w.style.background="radial-gradient(ellipse at 50% 60%, transparent 0%, transparent 10%, rgba(5,5,10,0.7) 30%, rgba(5,5,10,0.94) 100%)";n.appendChild(w)}}function dr(){if(Ve)try{const e=Y();if(!e)return;const t=e.style.filter||"";t.includes("grayscale")||(e.style.filter=(t?t+" ":"")+"grayscale(1)")}catch{}}function fr(){Ve=!1;const e=Y();if(e){const t=e.style.filter||"";e.style.filter=t.replace(/grayscale\(1\)/g,"").replace(/\s+/g," ").trim()}w&&(w.remove(),w=null)}function pr(e=800,t){Ve=!1;const n=Math.max(1,e||800);try{const r=Y();if(r){const i=r.style.filter||"";i.includes("grayscale")&&(r.style.transition="filter "+n+"ms ease",r.style.filter=i.replace(/grayscale\(1\)/g,"").replace(/\s+/g," ").trim(),setTimeout(()=>{try{r.style.transition=""}catch{}},n+50))}}catch{}try{if(w){w.style.transition="opacity "+n+"ms ease",w.style.opacity="0";const r=w;setTimeout(()=>{try{r.remove()}catch{}},n+50),w=null}}catch{}setTimeout(()=>{try{t&&t()}catch{}},n)}function mr(){z(),re(),fr(),gn()}let me=null,ye=null,Ne=null,ke=null,En=!1;function Sn(){try{if(typeof WardrobeGetExpression=="function")return WardrobeGetExpression(Player)||null}catch{}return null}function yr(e){const t=e.Eyes??null,n=e.Eyes2!==void 0?e.Eyes2:t;return{Eyebrows:e.Eyebrows??null,Eyes:t,Eyes2:n,Mouth:e.Mouth??null,Blush:e.Blush??null,右眼_Luzi:t,左眼_Luzi:n}}const hr=["Eyes","Eyes2","Emoticon"];function At(e,t){try{if(!Player?.Appearance)return;const n=[];for(const[r,i]of Object.entries(e))try{if(i==null)continue;const o=Player.Appearance.find(a=>a.Asset.Group.Name===r);if(!o)continue;const s=o.Asset?.Group?.AllowExpression;if(Array.isArray(s)&&!s.includes(i)||(o.Property||(o.Property={}),o.Property.Expression===i))continue;o.Property.Expression=i,n.push(r)}catch{}if(!n.length)return;try{typeof CharacterRefresh=="function"&&CharacterRefresh(Player,!1,!1)}catch{}if(t){for(const r of n)if(hr.includes(r))try{typeof ChatRoomCharacterExpressionUpdate=="function"&&ChatRoomCharacterExpressionUpdate(Player,r)}catch{}}}catch{}}function lt(e){try{if(!e)return;me===null&&(me=Sn()),At(yr(e),!0)}catch{}}function _t(e=null){try{if(ye===null){const n=Sn();ye=n?.Eyes??null,Ne=n?.Eyes2??null,ke=n?.Emoticon??null}const t={};if(e)for(const[n,r]of Object.entries(e))r!=null&&(t[n]=r);t.Eyes="Dazed",t.Eyes2="Dazed",At(t,!0)}catch{}}function Ke(){try{const e={};if(ye!==null&&(e.Eyes=ye),Ne!==null&&(e.Eyes2=Ne),ke!==null&&(e.Emoticon=ke),me)for(const[t,n]of Object.entries(me))n!=null&&e[t]===void 0&&(e[t]=n);At(e,!0)}catch{}me=null,ye=null,Ne=null,ke=null}let K=!1,se=null;function He(e){K=!!e;try{K&&Player?(se===null&&(se=Player.BlinkFactor),Player.BlinkFactor=999999,typeof PoseRefresh=="function"&&PoseRefresh(Player)):!K&&Player&&(se!==null&&(Player.BlinkFactor=se,se=null),typeof PoseRefresh=="function"&&PoseRefresh(Player))}catch{}}let Ie=null;function gr(e){try{const t=e?.OnlineSharedSettings?.["PEX"]?.state;if(t&&t.mode==="blank"&&t.type!=="normal")return Ie=e.BlinkFactor,e.BlinkFactor=999999,!0}catch{}return!1}function xr(e){if(Ie!==null){try{e.BlinkFactor=Ie}catch{}Ie=null}}function br(e){if(!e)return;const t=n=>{try{e.hookFunction(n,4,(r,i)=>K?!1:i(r))}catch{}};t("Player.CanWalk"),t("Player.CanInteract"),t("Player.CanChangeOwnClothes"),t("Player.CanKneel");try{e.hookFunction("ActivityCheckPrerequisites",4,(n,r)=>{const[i,o]=n;return o&&typeof o.IsPlayer=="function"&&o.IsPlayer()&&K?!1:r(n)})}catch{}try{e.hookFunction("PoseRefresh",4,(n,r)=>{const i=r(n);try{const o=n&&n[0];o&&typeof o.IsPlayer=="function"&&o.IsPlayer()&&K&&(o.AllowedActivePoseMapping={BodyUpper:[],BodyLower:[],BodyFull:[]})}catch{}return i})}catch{}try{e.hookFunction("CharacterSetFacialExpression",4,(n,r)=>{const i=r(n);try{const o=n&&n[0];if(o&&typeof o.IsPlayer=="function"&&o.IsPlayer()&&K){const s=l.expressions||{};_t(s.blank||s.excrete)}}catch{}return i})}catch{}}const zt=["%NAME%像个木头一样一动不动…","%NAME%身体僵在原地，毫无反应…","%NAME%双目无神，呆呆地杵在那里…","%NAME%仿佛被抽走了魂，一动不动…","%NAME%像坏掉的木偶一样僵住了…","%NAME%全身僵硬，连手指头都不动一下…"];function je(e){En=!!e}function vr(e){if(e)try{e.hookFunction("ChatRoomSendChat",5,(t,n)=>{if(!En)return n(t);let r="";try{r=(document.getElementById("InputChat")||{}).value||""}catch{}const i=r.trim();if(!i||/^[/(*.]/.test(i))return n(t);try{if(typeof ChatRoomTargetMemberNumber=="number"&&ChatRoomTargetMemberNumber>=0)return n(t)}catch{}const o=document.getElementById("InputChat");if(o){o.value="";try{o.dispatchEvent(new InputEvent("input"))}catch{}}const s=zt[Math.floor(Math.random()*zt.length)];setTimeout(()=>{try{b(s)}catch{}},2e3)})}catch(t){console.warn("⚗️[PEX] 禁言挂钩失败:",t.message)}}let ct=[];function ze(){for(const e of ct)clearTimeout(e);ct=[]}function Er(e){return Math.max(1,Math.min(5,Math.floor((e||0)/10)))}function Sr(e,t){const n=[];for(let r=1;r<=t;r++)n.push(e*r/(t+1));return n}function Wt(e,t){if(!Array.isArray(e)||e.length===0)return[];const n=e.slice(),r=[];for(;r.length<t;){n.length||n.push(...e);const i=Math.floor(Math.random()*n.length);r.push(n.splice(i,1)[0])}return r}function wr(e,t){if(ze(),!(t>0))return;const n=Er(t/1e3),r=Sr(t,n),i=Wt(l.sounds?.wait||[],n),o=Wt(l.expressions?.wait||[],n);!i.length&&!o.length||r.forEach((s,a)=>{ct.push(setTimeout(()=>{if(!e())return;const c=i[a];c&&l?.soundOn?.wait!==!1&&(Et(String(c)),Nt("wait",c));const u=o[a];u&&lt(u)},s))})}function Nt(e,t){if(!(!t||!l?.soundOn||l.soundOn[e]===!1))try{P("PEX_Sound",[{Tag:"Kind",Value:String(e)},{Tag:"Id",Value:String(t)}])}catch{}}function Pr(){ie(e=>{try{if(e?.Type!=="Hidden"||e.Content!=="PEX_Sound")return;const t=Number(e.Sender);if(!t||t===Player?.MemberNumber||!l.hearRemoteSounds)return;const r=(Array.isArray(e.Dictionary)?e.Dictionary:[]).find(i=>i?.Tag==="Id");r&&(r.Value??r.Name)&&Et(String(r.Value??r.Name),yn())}catch{}}),p("等待音效/表情系统已启用（段数随等待秒数，音效与表情同步）")}let $=0,M=null;const Mr=800;function wn(){try{return!!InventoryGet(Player,"ItemButt")}catch{return!1}}function ut(e){if(f.mode!==m.IDLE)if(f.mode===m.BLANK&&f.gelType==="normal")p("普通凝胶状态中再次喝下：清掉旧凝胶，重新开始"),ze(),M&&(clearTimeout(M),M=null),f.gelId&&Tt(f.gelId),C(m.IDLE);else return p("已有活动状态，忽略本次触发"),!1;$++;const t=$,n=Math.max(0,l.waitSeconds)*1e3;return C(m.WAITING,{gelType:e,endsAt:Date.now()+n}),n>0&&(l.fxDizzy&&vn(n,l.effectLevel),wr(()=>t===$,n)),T({mode:m.WAITING,type:e,remainingSec:Math.ceil(n/1e3),owner:Player?.MemberNumber},!0),b(e==="persona"?"%NAME%喝下了什么奇怪的东西，一阵异样的感觉涌了上来…":"%NAME%喝下了什么黏糊糊的东西…"),!0}function Ar(){if(wn()){cr(1500),Ke();const e=Math.max(1,l.blockedWaitMinutes)*60*1e3;C(m.BLOCKED,{endsAt:Date.now()+e}),T({mode:m.BLOCKED,type:f.gelType,remainingSec:Math.ceil(e/1e3),owner:Player?.MemberNumber},!0),b("%NAME%的臀部被什么东西挡住了，凝胶堵在里面出不来…");return}Pn()}async function Pn(){if(f.mode===m.EXCRETING)return;const e=$;C(m.EXCRETING);const t=l.expressions||{};t.excrete&&lt(t.excrete),z(),(l.fxShake||l.fxBlur)&&ur(kt+300,l.effectLevel,l.fxShake,l.fxBlur);const n=hn("excrete");Nt("excrete",n);const r=Date.now();if(T({mode:m.EXCRETING,type:f.gelType,owner:Player?.MemberNumber,startedAt:r},!0),await Lr(n),e!==$)return;if(f.gelType==="normal"){const s=l.autoRevertEnabled?Math.max(1,l.autoRevertMinutes)*60*1e3:0,a=Yt(Player?.MemberNumber);re(),B(0),C(m.BLANK,{endsAt:s?Date.now()+s:0,gelId:a,gelHolder:null,gelType:"normal"}),lt(l.normalExpression),M&&clearTimeout(M),M=setTimeout(()=>{M=null,e===$&&Ke()},Math.max(1,l.normalExpressionSeconds)*1e3),T({mode:m.BLANK,type:"normal",remainingSec:s?Math.ceil(s/1e3):0,owner:Player?.MemberNumber,gelId:a,gelHolder:null,expiresAt:s?Date.now()+s:0},!0),b("%NAME%排出了一坨软趴趴的普通凝胶，落在脚边…");return}const i=l.autoRevertEnabled?Math.max(1,l.autoRevertMinutes)*60*1e3:0,o=Yt(Player?.MemberNumber);re(),z(),l.fxBlur&&B(1.5+l.effectLevel*.5),wt(l.blindLevel),C(m.BLANK,{endsAt:i?Date.now()+i:0,gelId:o,gelHolder:null}),dt=l.viewMode,ft=l.effectLevel,pt=l.blindLevel,l.fxBlank&&Mt(l.viewMode),_t(t.blank||t.excrete),l.restrictions&&(je(!0),He(!0)),T({mode:m.BLANK,type:"persona",remainingSec:i?Math.ceil(i/1e3):0,owner:Player?.MemberNumber,gelId:o,gelHolder:null,expiresAt:i?Date.now()+i:0},!0),b("%NAME%的身体一阵脱力，瘫坐下来眼神空洞——人格凝胶被排了出来，落在脚边…")}function Mn(e=!0){$++,ze(),M&&(clearTimeout(M),M=null),mr(),xn(),Ke(),je(!1),He(!1),C(m.IDLE),T(null,!0),e||b("%NAME%恢复了正常。")}function Be(e,t){$++,ze(),M&&(clearTimeout(M),M=null),z(),re(),gn(),xn(),Ke(),je(!1),He(!1),C(m.IDLE),T(null,!0),pr(Mr,t),e&&b(e)}function _r(){p("自动回归触发");const e=f.gelType==="normal";if(f.gelId){if(l.gelExpireMode==="invalid"){Xr(f.gelId,Player?.MemberNumber),Be(x(e?"gelInvalidatedNormal":"gelInvalidated"));return}Tt(f.gelId)}Be(x(e?"gelExpiredNormal":"gelExpired"))}let dt=null,ft=null,pt=null;function Nr(e){const t=f;t.mode===m.WAITING?t.phaseEndsAt>0&&e>=t.phaseEndsAt&&Ar():t.mode===m.BLOCKED?wn()?t.phaseEndsAt>0&&e>=t.phaseEndsAt&&(Mn(),b("%NAME%好像什么也没发生。")):(b("%NAME%臀部的遮挡被拿开了，凝胶开始往外挤…"),Pn()):t.mode===m.BLANK&&(t.gelType!=="normal"&&(l.fxBlank&&dt!==l.viewMode&&(dt=l.viewMode,Mt(l.viewMode)),l.fxBlur&&ft!==l.effectLevel&&(ft=l.effectLevel,B(1.5+l.effectLevel*.5)),pt!==l.blindLevel&&(pt=l.blindLevel,wt(l.blindLevel))),l.autoRevertEnabled&&t.phaseEndsAt>0&&e>=t.phaseEndsAt&&_r())}function kr(){try{Fr()}catch{}const e=f;if((e.mode===m.WAITING||e.mode===m.BLOCKED||e.mode===m.BLANK)&&(e.phaseEndsAt>0||e.mode===m.BLANK)){const t=e.phaseEndsAt>0?Math.max(0,Math.round((e.phaseEndsAt-Date.now())/1e3)):0,n=Math.ceil(t/5)*5;T({mode:e.mode,type:e.gelType,remainingSec:n,owner:e.ownerMemberNumber??Player?.MemberNumber,gelId:e.gelId,gelHolder:e.gelHolder,expiresAt:e.phaseEndsAt||0})}}const kt=7340;let mt=kt,be=0;const It=new Map;function Ir(e){return It.get(e)||0}function Tr(e){It.delete(e)}function Cr(){return be>0?be:mt}function Rr(e){be=e>0?e:0}function An(e){try{if(!e||e.MemberNumber==null)return;It.set(e.MemberNumber,Date.now())}catch{}}function Ut(e){return new Promise(t=>setTimeout(t,e))}function Dr(e){return e?new Promise(t=>{try{const n=new Audio(String(e));let r=!1;const i=o=>{r||(r=!0,t(o))};n.addEventListener("loadedmetadata",()=>i(n.duration>0?n.duration*1e3:0)),n.addEventListener("error",()=>i(0)),setTimeout(()=>i(0),3e3)}catch{t(0)}}):Promise.resolve(0)}async function Lr(e){if(An(Player),be>0){await Ut(be);return}const t=await Dr(e);mt=Math.max(kt,t),await Ut(mt)}function Or(){try{const e=Player?.OnlineSharedSettings?.["PEX"]?.state;if(!e||typeof e!="object"||!e.mode)return;if(e.mode===m.BLANK){const t=e.type==="normal";if(C(m.BLANK,{endsAt:e.expiresAt||0,gelId:e.gelId||null,gelHolder:null,gelType:t?"normal":"persona"}),t){p("登录还原：普通凝胶状态（凝胶 "+(e.gelId||"无")+"）");return}z(),l.fxBlur&&B(1.5+l.effectLevel*.5),wt(l.blindLevel),l.fxBlank&&Mt(l.viewMode);const n=l.expressions||{};_t(n.blank||n.excrete),l.restrictions&&(je(!0),He(!0)),p("登录还原：失神状态（凝胶 "+(e.gelId||"无")+"）")}else if(e.mode===m.WAITING||e.mode===m.BLOCKED){const t=Math.max(1,e.remainingSec||30)*1e3;C(e.mode,{gelType:e.type||"persona",endsAt:Date.now()+t}),e.mode===m.WAITING&&vn(t,l.effectLevel),p("登录还原："+e.mode+"（剩余 "+(e.remainingSec||"?")+" 秒）")}}catch(e){p("登录还原失败:",e.message)}}const $r="GlassFilled",Xe="PEX|";function Yt(e){return`${e}-${Date.now()}`}function Br(e,t,n,r="persona"){try{if(typeof InventoryGet!="function"||typeof InventoryWear!="function"||InventoryGet(Player,"ItemHandheld"))return null;const s={Name:`${kn(e)||"某人"}的${r==="normal"?"普通凝胶":"人格凝胶"}`,Description:`${Xe}${t}|${e}|${n}`,MemberNumber:e,Property:"Normal"},a=InventoryWear(Player,$r,"ItemHandheld",void 0,void 0,e,s,!1);if(!a)return null;try{typeof ChatRoomCharacterUpdate=="function"&&ChatRoomCharacterUpdate(Player)}catch{}return p("凝胶物品已生成:",t),a}catch(i){return p("生成凝胶失败:",i.message),null}}function Ee(e){try{const t=e?.Craft?.Description??"";if(!t.startsWith(Xe))return null;const n=t.slice(Xe.length).split("|"),[r,i,o]=n;return{gelId:r,ownerMemberNumber:+i,expiresAt:+o,invalid:n[3]==="INVALID"}}catch{return null}}function _n(e){return!!Ee(e)}function Se(e){try{const t=InventoryGet(Player,"ItemHandheld"),n=Ee(t);if(n&&(!e||n.gelId===e)){InventoryRemove(Player,"ItemHandheld",!1);try{typeof ChatRoomCharacterUpdate=="function"&&ChatRoomCharacterUpdate(Player)}catch{}return p("凝胶已从手上移除:",n.gelId),!0}}catch{}return!1}function qt(e,t,n){Se(n?.gelId),P("PEX_GelConsumed",[{Tag:"GelId",Value:String(n?.gelId??"")},{Tag:"Drinker",Value:String(t)},{Tag:"Owner",Value:String(n?.ownerMemberNumber)}])}function Tt(e){P("PEX_GelExpired",[{Tag:"GelId",Value:e}],{dedupeKey:"expire-"+e,dedupeMs:5e3})}function Nn(e,t){try{const n=InventoryGet(Player,"ItemHandheld"),r=Ee(n);if(!r||r.gelId!==e||r.invalid)return!1;const i=kn(t)||"某人";n.Craft||(n.Craft={}),n.Craft.Name=`${i}的无效凝胶`,n.Craft.Description=`${Xe}${e}|${t}|${r.expiresAt}|INVALID`,n.Craft.Property="Normal";try{typeof ChatRoomCharacterUpdate=="function"&&ChatRoomCharacterUpdate(Player)}catch{}return p("凝胶已变为无效凝胶:",e),!0}catch(n){return p("无效化凝胶失败:",n.message),!1}}function Xr(e,t){P("PEX_GelInvalidated",[{Tag:"GelId",Value:String(e)},{Tag:"Owner",Value:String(t)}],{dedupeKey:"invalidate-"+e,dedupeMs:5e3})}function Fr(){try{const e=InventoryGet(Player,"ItemHandheld"),t=Ee(e);if(!t||!(t.expiresAt>0)||t.expiresAt>Date.now()||t.invalid)return;typeof l<"u"&&l.gelExpireMode==="invalid"?Nn(t.gelId,t.ownerMemberNumber):Se(t.gelId)}catch{}}function Gr(e){if(e)try{e.hookFunction("DrawCharacter",1,(t,n)=>{const[r,i,o,s]=t,a=!(l.gelLayer>=24);try{a&&r&&r.MemberNumber!=null&&typeof i=="number"&&typeof o=="number"&&Jt(r,i,o,s||1)}catch{}const c=r&&r.MemberNumber!=null?gr(r):!1,u=n(t);c&&xr(r);try{!a&&r&&r.MemberNumber!=null&&typeof i=="number"&&typeof o=="number"&&Jt(r,i,o,s||1)}catch{}return u})}catch(t){p("凝胶底层绘制挂钩失败:",t.message)}}function Jt(e,t,n,r){try{const i=Ir(e.MemberNumber);if(i){const s=Cr()||7340,a=Date.now()-i;if(a>s){Tr(e.MemberNumber);return}if(typeof DrawRect!="function")return;const c=t+250*r,u=n+525*r,d=n+950*r,h=Math.min(1,a/s);h<.25?DrawRect(c-14*r,u-14*r,28*r,28*r,"#ffffff"):h<.5?DrawRect(c-14*r,u+(d-u)*.45-14*r,28*r,28*r,"#ffffff"):h<.75?(DrawRect(c-14*r,u+(d-u)*.82-14*r,28*r,28*r,"#ffffff"),DrawRect(c-18*r,d-8*r,36*r,16*r,"#ffffff")):DrawRect(c-24*r,d-11*r,48*r,22*r,"#ffffff");return}const o=e.OnlineSharedSettings?.["PEX"]?.state;o&&o.mode==="blank"&&o.gelId&&!o.gelHolder&&typeof DrawImageResize=="function"&&DrawImageResize("Assets/Female3DCG/ItemHandheld/Preview/GlassFilled.png",t+250*r-20*r,n+950*r-17*r,40*r,34*r)}catch{}}const Te=new Map;function Vr(){try{if(typeof ChatRoomCharacter>"u"||!Array.isArray(ChatRoomCharacter))return;for(const e of ChatRoomCharacter){if(!e||e.MemberNumber==null||e.MemberNumber===Player?.MemberNumber)continue;const t=e.OnlineSharedSettings?.["PEX"]?.state,n=Te.get(e.MemberNumber);t&&t.mode==="excreting"&&t.startedAt?n!==t.startedAt&&(Te.set(e.MemberNumber,t.startedAt),An(e)):n!==void 0&&Te.delete(e.MemberNumber)}}catch{}}function Kr(){Te.clear()}function Hr(e){ie(t=>{try{if(t?.Type!=="Hidden")return;const n=Array.isArray(t.Dictionary)?t.Dictionary:[],r=i=>{const o=n.find(s=>s?.Tag===i);return o?o.Value??o.Name:void 0};if(t.Content==="PEX_GelExpired"){const i=r("GelId");i&&Se(i)}else if(t.Content==="PEX_GelInvalidated"){const i=r("GelId"),o=+r("Owner");i&&Nn(i,o)}else if(t.Content==="PEX_GelConsumed"){const i=+r("Owner"),o=+r("Drinker"),s=r("GelId");try{const a=Pe(i);a?.OnlineSharedSettings?.["PEX"]&&(a.OnlineSharedSettings.PEX.state=null)}catch{}typeof e=="function"&&e({gelId:s,owner:i,drinker:o})}else if(t.Content==="PEX_GelHeld"){const i=r("GelId"),o=+r("Owner"),s=+r("Holder");try{const a=Pe(o);a?.OnlineSharedSettings?.["PEX"]?.state&&(a.OnlineSharedSettings.PEX.state.gelHolder=s)}catch{}if(o===Player?.MemberNumber)try{f.gelHolder=s,T({mode:"blank",remainingSec:f.phaseEndsAt?Math.max(0,Math.round((f.phaseEndsAt-Date.now())/1e3)):0,owner:Player?.MemberNumber,gelId:i,gelHolder:s,expiresAt:f.phaseEndsAt||0},!0)}catch{}}else if(t.Content==="PEX_StateSync"){const i=r("Payload");if(!i)return;let o=null;try{o=JSON.parse(i)}catch{return}const s=Number(t.Sender);if(!s||s===Player?.MemberNumber||!o||typeof o!="object")return;const a=Pe(s);if(!a)return;try{a.OnlineSharedSettings||(a.OnlineSharedSettings={}),a.OnlineSharedSettings.PEX||(a.OnlineSharedSettings.PEX={}),a.OnlineSharedSettings.PEX.state=o}catch{}}else if(t.Content==="PEX_SharedSync"){const i=r("Payload");if(!i)return;let o=null;try{o=JSON.parse(i)}catch{return}const s=Number(t.Sender);if(!s||s===Player?.MemberNumber||!o||typeof o!="object")return;const a=Pe(s);if(!a)return;try{a.OnlineSharedSettings||(a.OnlineSharedSettings={}),a.OnlineSharedSettings.PEX||(a.OnlineSharedSettings.PEX={});const c=a.OnlineSharedSettings.PEX;o.edit!==void 0&&(c.edit=o.edit),o.editModes&&(c.editModes=o.editModes),o.wl&&(c.wl=o.wl)}catch{}}}catch{}})}function kn(e){try{if(e===Player?.MemberNumber)return CharacterNickname(Player);const t=ChatRoomCharacter?.find(n=>n?.MemberNumber===e);if(t)return CharacterNickname(t)}catch{}return null}function We(){p("强制恢复"),f.gelId&&Tt(f.gelId),Se(f.gelId),Mn(!0),b("%NAME%被强制恢复了，一切回归正常。")}const g={accent:"#f27ba8",teal:"#3f9c92",tealDark:"#2a6b63",text:"#e8e4f5",dim:"#9b93bd",danger:"#ff6b6b"},jr={idle:"空闲",waiting:"排出前等待",blocked:"臀部被挡·等待中",excreting:"排出动画中",blank:"失神中"},zr={all:"全部",surround:"周围",self:"自己"},Wr={self:"仅自己",others:"仅他人",both:"都可见"};let S=null,Ce=null,ue=!1,J=null;function Ur(){return!!S}function In(e){return String(e).replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;")}function le(e,t,n,r){const i=document.createElement("button");return i.textContent=e,Object.assign(i.style,{background:t,border:"1px solid rgba(255,255,255,0.25)",borderRadius:"4px",color:n,cursor:"pointer",fontSize:"11px",padding:"2px 8px",lineHeight:"16px",fontWeight:"bold",whiteSpace:"nowrap"}),i.addEventListener("click",r),i}function Yr(){const e=f;let t="—";if(e.phaseEndsAt>0){const c=Math.max(0,Math.round((e.phaseEndsAt-Date.now())/1e3));t=Math.floor(c/60)+":"+String(c%60).padStart(2,"0")}const n=jr[e.mode]||e.mode,r=e.mode==="idle"?g.dim:g.accent,i=e.gelId?"#"+String(e.gelId).slice(0,8):"—",o=e.gelHolder!=null?"#"+e.gelHolder:"—",s=e.ownerMemberNumber!=null?"#"+e.ownerMemberNumber:"—",a=l;return`
    <div style="display:grid;grid-template-columns:1fr 1fr;gap:2px 14px;font-size:12px;line-height:18px">
      <div><span style="color:${g.dim}">状态</span> <b style="color:${r}">${n}</b>${e.gelType==="normal"?` <span style="color:${g.teal}">（普通凝胶）</span>`:""}</div>
      <div><span style="color:${g.dim}">倒计时</span> <b style="color:${g.text}">${t}</b></div>
      <div><span style="color:${g.dim}">凝胶ID</span> <b style="color:${g.text}">${i}</b></div>
      <div><span style="color:${g.dim}">持有者</span> <b style="color:${g.text}">${o}</b></div>
      <div><span style="color:${g.dim}">主人</span> <b style="color:${g.text}">${s}</b></div>
      <div><span style="color:${g.dim}">类型</span> <b style="color:${g.text}">${In(e.gelType)}</b></div>
    </div>
    <div style="margin-top:5px;padding-top:4px;border-top:1px solid rgba(63,156,146,0.35);display:grid;grid-template-columns:1fr 1fr;gap:2px 14px;font-size:11px;line-height:17px;color:${g.dim}">
      <span>总开关：<b style="color:${g.text}">${a.enabled?"开":"关"}</b></span>
      <span>排出等待：<b style="color:${g.text}">${a.waitSeconds}秒</b></span>
      <span>阻挡上限：<b style="color:${g.text}">${a.blockedWaitMinutes}分</b></span>
      <span>自动回归：<b style="color:${g.text}">${a.autoRevertEnabled?a.autoRevertMinutes+"分":"关"}</b></span>
      <span>普通表情：<b style="color:${g.text}">${a.normalExpressionSeconds}秒</b></span>
      <span>特效强度：<b style="color:${g.text}">${a.effectLevel} / 5</b></span>
      <span>失神视野：<b style="color:${g.text}">${zr[a.viewMode]||a.viewMode}</b></span>
      <span>计时器：<b style="color:${g.text}">${Wr[a.timerVisibility]||a.timerVisibility}</b></span>
    </div>`}function qr(){const e=ce.slice(-8);return e.length?e.map(t=>`<div style="font-size:11px;color:${g.dim};white-space:nowrap;overflow:hidden;text-overflow:ellipsis">${In(t)}</div>`).join(""):`<div style="color:${g.dim};font-size:11px">（暂无日志）</div>`}function Jr(e){if(S||!e)return;S=document.createElement("div"),S.id="pex-panel",Object.assign(S.style,{background:"linear-gradient(135deg, rgba(22,17,40,0.97) 0%, rgba(24,40,38,0.97) 100%)",borderLeft:"3px solid "+g.accent,borderTop:"1px solid rgba(63,156,146,0.4)",padding:"8px 10px 6px",boxShadow:"0 -4px 20px rgba(242,123,168,0.20)",fontFamily:'"Noto Sans SC","Microsoft YaHei",sans-serif',fontSize:"12px",userSelect:"none",marginTop:"4px",display:"block"});const t=document.createElement("div");Object.assign(t.style,{display:"flex",alignItems:"center",justifyContent:"space-between",marginBottom:"6px"});const n=document.createElement("span");n.innerHTML=`⚗️ <b style="color:${g.accent}">PEX</b> <span style="color:${g.dim};font-size:10px">控制台 v${N}</span>`;const r=le("⚙ 设置",g.tealDark,"#c9f0ea",()=>{try{typeof PreferenceSubscreenExtensionsOpen=="function"&&PreferenceSubscreenExtensionsOpen(gt)}catch{}}),i=le("🧪 测试流程",g.tealDark,"#c9f0ea",()=>{try{if(f.mode!=="idle"){p("已有进行中的流程，先 /pex reset 再测");return}const h=l.waitSeconds;l.waitSeconds=10,ut("persona"),l.waitSeconds=h,p("测试流程已启动：10 秒后排出（臀部有东西会等待）")}catch(h){p("测试流程启动失败:",h.message)}}),o=le("💾 保存",g.tealDark,"#c9f0ea",()=>{_(!0),p("设置已保存"),Me()}),s=le("⚠ 强制恢复","rgba(120,30,30,0.85)","#ff8899",()=>{if(!ue){ue=!0,s.textContent="⚠ 再次点击确认",s.style.background=g.danger,clearTimeout(J),J=setTimeout(()=>{ue=!1,s.textContent="⚠ 强制恢复",s.style.background="rgba(120,30,30,0.85)"},4e3);return}ue=!1,clearTimeout(J),s.textContent="⚠ 强制恢复",s.style.background="rgba(120,30,30,0.85)",We(),Me()}),a=le("✕","rgba(100,20,40,0.8)","#ff8899",()=>Tn()),c=document.createElement("div");c.style.cssText="display:flex;gap:4px;align-items:center",c.append(r,i,o,s,a),t.append(n,c),S.appendChild(t);const u=document.createElement("div");u.id="pex-panel-status",S.appendChild(u);const d=document.createElement("div");d.id="pex-panel-log",Object.assign(d.style,{marginTop:"5px",paddingTop:"4px",borderTop:"1px solid rgba(242,123,168,0.25)",maxHeight:"110px",overflowY:"auto"}),S.appendChild(d),e.appendChild(S),Ce=setInterval(Me,1e3),Me()}function Me(){if(!S)return;const e=S.querySelector("#pex-panel-status"),t=S.querySelector("#pex-panel-log");e&&(e.innerHTML=Yr()),t&&(t.innerHTML=qr())}function Tn(){if(Ce&&(clearInterval(Ce),Ce=null),J&&(clearTimeout(J),J=null),ue=!1,S){try{S.remove()}catch{}S=null}}function v(e,t=0){try{const n=document.getElementById("TextAreaChatLog");if(!n)throw new Error("no log");const r=document.createElement("div");r.className="ChatMessage ChatMessageLocalMessage",Object.assign(r.style,{background:"rgba(160,50,120,0.16)",borderLeft:"3px solid rgb(242,123,168)",padding:"4px 8px",margin:"2px 0",color:"rgb(242,175,205)",fontSize:"0.92em",fontFamily:"inherit",whiteSpace:"pre-wrap",transition:"opacity 0.5s ease"}),r.innerHTML='<span style="opacity:0.6;font-size:0.85em">⚗️ PEX</span>　'+e.split(`
`).join("<br>"),n.appendChild(r),n.scrollTop=n.scrollHeight,t>0&&setTimeout(()=>{r.style.opacity="0",setTimeout(()=>r.remove(),500)},t);return}catch{}try{typeof ChatRoomMessage=="function"&&ChatRoomMessage({Type:"LocalMessage",Sender:Player?.MemberNumber,Content:`<font color="#f2afcd">⚗️ [PEX] ${e}</font>`})}catch{}}function Ct(e){const t=e.trim().split(/\s+/);if((t[0]||"").toLowerCase()!=="/pex")return!1;const n=(t[1]||"").toLowerCase();if(!n||n==="help")return v(x("help",{v:N})),!0;if(n==="howto")return v(x("howto",{v:N})),!0;if(n==="reset")return t[2]==="yes"?(We(),v(x("resetDone"))):v(x("resetConfirm")+"（再次输入 /pex reset yes 确认）"),!0;if(n==="show"){const r=document.getElementById("TextAreaChatLog")||document.querySelector(".ChatLog");return r?(Ur()?Tn():Jr(r),!0):(v(x("noChatBox")),!0)}if(n==="status")return v(x("statusLine",{state:fn()})),!0;if(n==="settings"){try{typeof PreferenceSubscreenExtensionsOpen=="function"?PreferenceSubscreenExtensionsOpen(gt):v(x("cantOpenSettings"))}catch(r){v("⚠️ 打开设置页失败: "+r.message)}return!0}return n==="save"?(_(!0),v("设置已保存。"),!0):(v(x("cmdUnknown",{sub:n})),!0)}function Qr(){try{if(typeof CommandCombine=="function")return CommandCombine([{Tag:"pex",Description:"人格排泄插件指令（/pex help 查看说明）",Action:e=>{Ct("/pex "+(e??""))}}]),!0}catch(e){console.warn("⚗️[PEX] CommandCombine 注册失败:",e.message)}return!1}function Cn(){document.addEventListener("keydown",e=>{if(e.key!=="Enter")return;const t=document.getElementById("InputChat")||document.querySelector('textarea[id*="Chat"]');if(!t)return;const n=t.value.trim();n.toLowerCase().startsWith("/pex")&&(Ct(n),e.preventDefault(),e.stopPropagation(),t.value="")},!0)}let Qt=!1;function Zr(){Qt||(Qt=!0,!Qr()&&Cn())}function ei(){Cn()}const ti="modulepreload",ni=function(e,t){return new URL(e,t).href},Zt={},ri=function(t,n,r){let i=Promise.resolve();if(n&&n.length>0){let u=function(d){return Promise.all(d.map(h=>Promise.resolve(h).then(A=>({status:"fulfilled",value:A}),A=>({status:"rejected",reason:A}))))};const s=document.getElementsByTagName("link"),a=document.querySelector("meta[property=csp-nonce]"),c=a?.nonce||a?.getAttribute("nonce");i=u(n.map(d=>{if(d=ni(d,r),d in Zt)return;Zt[d]=!0;const h=d.endsWith(".css"),A=h?'[rel="stylesheet"]':"";if(r)for(let D=s.length-1;D>=0;D--){const we=s[D];if(we.href===d&&(!h||we.rel==="stylesheet"))return}else if(document.querySelector(`link[href="${d}"]${A}`))return;const k=document.createElement("link");if(k.rel=h?"stylesheet":ti,h||(k.as="script"),k.crossOrigin="",k.href=d,c&&k.setAttribute("nonce",c),document.head.appendChild(k),h)return new Promise((D,we)=>{k.addEventListener("load",D),k.addEventListener("error",()=>we(new Error(`Unable to preload CSS for ${d}`)))})}))}function o(s){const a=new Event("vite:preloadError",{cancelable:!0});if(a.payload=s,window.dispatchEvent(a),!a.defaultPrevented)throw s}return i.then(s=>{for(const a of s||[])a.status==="rejected"&&o(a.reason);return t().catch(o)})};let Je=!1;function ii(e,t){const n=U();if(n)try{n.hookFunction("ChatRoomRun",0,(r,i)=>{const o=i(r);try{try{dr()}catch{}if(Je)return o;Je=!0,e&&e()}catch{}return o}),n.hookFunction("ChatRoomLeave",0,(r,i)=>{const o=i(r);try{t&&t(),Je=!1}catch{}return o})}catch(r){console.warn("⚗️[PEX] 房间生命周期挂钩失败:",r.message)}}function oi(e){const t=U();if(t)try{t.onUnload(()=>{try{e&&e()}catch{}})}catch{}}function ai(e){const t={activityName:null,groupName:null,target:null,itemName:null};try{const n=Array.isArray(e?.Dictionary)?e.Dictionary:[];for(const r of n)!r||typeof r!="object"||(t.activityName==null&&typeof r.ActivityName=="string"&&(t.activityName=r.ActivityName),t.groupName==null&&r.Tag==="FocusAssetGroup"&&r.FocusGroupName&&(t.groupName=r.FocusGroupName),t.target==null&&typeof r.TargetCharacter=="number"&&(t.target=r.TargetCharacter),t.itemName==null&&r.Tag==="ActivityAsset"&&r.AssetName&&(t.itemName=r.AssetName))}catch{}if(!t.activityName)try{const n=typeof e?.Content=="string"?JSON.parse(e.Content):null;n&&typeof n=="object"&&(t.activityName=n.Name??n.ActivityName??t.activityName,t.groupName=n.GroupName??t.groupName,t.target=n.TargetMemberNumber??n.TargetCharacter??t.target)}catch{}return t}const si=["人格药水","persona"];function en(e){const t=st(e);return t?si.concat(l.keywords||[]).some(n=>Gt(t,n))?"persona":(l.normalKeywords||[]).some(n=>Gt(t,n))?"normal":null:null}function Rt(e,t){try{if(e==="SipItem"){const n=Ee(t);if(n){if(n.invalid){qt(t,Player?.MemberNumber,n),b("%NAME%喝了一口，什么味道也没有…");return}const i=n.ownerMemberNumber===Player?.MemberNumber;qt(t,Player?.MemberNumber,n),i&&f.mode===m.BLANK?Be("%NAME%喝回了自己的人格凝胶，意识一下子回来了！"):(p("凝胶被喝掉:",n.gelId),b("%NAME%迷迷糊糊地把手里的凝胶喝了下去…"));return}const r=en(t);r&&l.enabled?(p("命中关键词 →",r),ut(r)):p("未命中关键词，物品文本:",st(t).slice(0,60));return}if(e==="Inject"){const n=en(t);n&&l.enabled?(p("注射命中关键词 →",n),ut(n)):p("注射未命中关键词，物品文本:",st(t).slice(0,60))}}catch(n){p("处理活动异常:",n.message)}}function li(e){try{const n=(Array.isArray(e?.Dictionary)?e.Dictionary:[]).find(r=>r?.Tag==="ActivityAsset");return n?{Asset:n.AssetName?{Name:n.AssetName,Group:{Name:n.GroupName}}:null,Craft:n.CraftName?{Name:n.CraftName}:null}:null}catch{return null}}function ci(){ie(e=>{try{if(e?.Type!=="Activity")return;const t=ai(e);if(!t.activityName||(p("收到活动消息:",t.activityName,"目标:",t.target,"物品:",t.itemName||"?","发送者:",e.Sender),!(t.target!=null&&t.target===Player?.MemberNumber)))return;Rt(t.activityName,li(e)||Dt())}catch(t){p("触发检测异常:",t.message)}})}function ui(e){if(e)try{e.hookFunction("ActivityRun",1,(t,n)=>{const r=n(t);try{const[i,o,s,a]=t;if(!i||!o||!a?.Activity?.Name||!(typeof i.IsPlayer=="function"&&i.IsPlayer()&&typeof o.IsPlayer=="function"&&o.IsPlayer()))return r;const u=a.Activity.Name;if(u!=="SipItem"&&u!=="Inject")return r;const d=a.Item||Dt();p("本地动作(ActivityRun):",u,"物品:",d?.Asset?.Name||"?"),Rt(u,d)}catch{}return r})}catch(t){p("ActivityRun 挂钩失败:",t.message)}}function di(e){if(e)try{e.hookFunction("DialogActivityClick",1,(t,n)=>{const r=n(t);try{const[i,o]=t;if(!i||!o?.Activity?.Name||typeof i.IsPlayer!="function"||!i.IsPlayer())return r;const s=o.Activity.Name;if(s!=="SipItem"&&s!=="Inject")return r;const a=o.Item||Dt();p("点击动作(DialogActivityClick):",s,"物品:",a?.Asset?.Name||"?"),Rt(s,a)}catch{}return r})}catch(t){p("DialogActivityClick 挂钩失败:",t.message)}}function Dt(){try{return InventoryGet(Player,"ItemHandheld")}catch{return null}}const Qe="PEX_PickupGel",Ze="PEX_PutGel";function Fe(e){try{const t=e?.OnlineSharedSettings?.PEX?.state;if(t&&t.mode==="blank"&&t.gelId)return t}catch{}return null}function fi(e){try{if(!e||e.MemberNumber==null||e.MemberNumber===Player?.MemberNumber)return!1;const t=Fe(e);return!(!t||t.gelHolder)}catch{return!1}}function pi(e){try{if(!e||e.MemberNumber==null||e.MemberNumber===Player?.MemberNumber)return!1;const t=Fe(e);if(!t)return!1;const n=InventoryGet(Player,"ItemHandheld");if(!n||!_n(n))return!1;const r=mi(n);return!!r&&!r.invalid&&r.gelId===t.gelId}catch{return!1}}function mi(e){try{const t=e?.Craft?.Description??"";if(!t.startsWith("PEX|"))return null;const n=t.slice(4).split("|"),[r,i]=n;return{gelId:r,ownerMemberNumber:+i,invalid:n[3]==="INVALID"}}catch{return null}}function yi(e,t){try{if(!t){b("%NAME%试着捡起凝胶，但它已经不见了…");return}if(InventoryGet(Player,"ItemHandheld")){b("%NAME%想捡起凝胶，但手里已经拿着东西了。");return}const n=t.gelId,r=t.owner??e?.MemberNumber,i=t.expiresAt??Date.now()+1800*1e3,o=Br(r,n,i,t.type==="normal"?"normal":"persona");if(!o){b("%NAME%试着捡起凝胶，但失败了…");return}P("PEX_GelHeld",[{Tag:"GelId",Value:String(n)},{Tag:"Holder",Value:String(Player?.MemberNumber)},{Tag:"Owner",Value:String(r)}]);try{e?.OnlineSharedSettings?.["PEX"]?.state&&(e.OnlineSharedSettings.PEX.state.gelHolder=Player?.MemberNumber)}catch{}b(`%NAME%捡起了地上的${o.Craft?.Name??"凝胶"}，小心地端了起来。`)}catch(n){p("捡起失败:",n.message)}}function hi(e,t){try{if(!t)return;const n=t.gelId,r=t.owner??e?.MemberNumber,i=InventoryGet(Player,"ItemHandheld");if(!i||!_n(i)){b("%NAME%想放回凝胶，但手上已经空了。");return}if(!Se(n))return;P("PEX_GelConsumed",[{Tag:"GelId",Value:String(n)},{Tag:"Drinker",Value:String(r)},{Tag:"Owner",Value:String(r)}]);try{e?.OnlineSharedSettings?.["PEX"]?.state&&(e.OnlineSharedSettings.PEX.state=null)}catch{}b(`%NAME%把凝胶放回了${ne(e,"对方")}的身体里，${ne(e,"对方")}慢慢回过神来。`)}catch(n){p("放回失败:",n.message)}}function gi(){const e=U();if(!e)return;const t=(n,r)=>{const i=n&&n[0];return typeof i=="string"&&i.includes(Qe)?"捡起凝胶":typeof i=="string"&&i.includes(Ze)?"放回凝胶":r(n)};try{e.hookFunction("ActivityDictionaryText",0,t)}catch{}try{e.hookFunction("TextGet",0,t),e.hookFunction("TextGetInScope",0,t)}catch{}try{e.hookFunction("DialogBuildActivities",10,(n,r)=>{const i=r(n);try{const o=n&&n[0];if(typeof DialogActivity>"u"||!Array.isArray(DialogActivity)||!o||o.MemberNumber===Player?.MemberNumber)return i;const s=c=>DialogActivity.some(u=>u&&u.Activity&&u.Activity.Name===c)?!1:(DialogActivity.push({Activity:{Name:c,MaxProgress:0},Item:null,Group:o.FocusGroup&&o.FocusGroup.Name||"ItemHands"}),!0);let a=!1;if(fi(o)&&(a=s(Qe)||a),pi(o)&&(a=s(Ze)||a),!a)return i;try{typeof DialogMenuMapping<"u"&&DialogMenuMapping.activities&&typeof DialogMenuMapping.activities.Reload=="function"&&DialogMenuMapping.activities.Reload(null,{reset:!0,resetDialogItems:!1})}catch{}}catch{}return i})}catch{}try{e.hookFunction("DialogActivityClick",1,(n,r)=>{const[i,o]=n;let s=!1;try{const a=o&&o.Activity&&o.Activity.Name;i&&a===Qe?(yi(i,Fe(i)),s=!0):i&&a===Ze&&(hi(i,Fe(i)),s=!0)}catch{}if(s){try{typeof DialogLeave=="function"&&DialogLeave()}catch{}return}return r(n)})}catch{}}let Q=null,Z=null,ee=null;function xi({gelId:e,owner:t,drinker:n}){try{if(t===Player?.MemberNumber)if(f.mode===m.BLANK){const r=f.gelType==="normal";p("我的凝胶被放回身体:",e,"drinker:",n),Be(r?"%NAME%喝回了自己的凝胶，胃里一阵翻腾…":"%NAME%喝回了自己的人格凝胶，意识一下子回来了！",()=>{const i=hn("feed");Nt("feed",i)})}else p("我的凝胶被消耗:",e)}catch{}}function bi(){const e=U();ci(),e&&ui(e),e&&di(e),e&&vr(e),e&&br(e),e&&Gr(e),Hr(xi),Pr(),gi(),Q&&clearInterval(Q),Q=setInterval(()=>{try{Nr(Date.now())}catch{}},250),Z&&clearInterval(Z),Z=setInterval(()=>{try{kr()}catch{}},1e3),ee&&clearInterval(ee),ee=setInterval(()=>{if(l.seeRemoteAnims)try{Vr()}catch{}},1e3)}function vi(){Q&&(clearInterval(Q),Q=null),Z&&(clearInterval(Z),Z=null),ee&&(clearInterval(ee),ee=null);try{Kr()}catch{}}const tn="pex-settings-panel",Ei=[{key:"basic",label:"基本设置"},{key:"excrete",label:"排出设置"},{key:"fx",label:"特效设置"},{key:"perm",label:"权限设置"},{key:"expr",label:"表情设置"},{key:"sound",label:"音效设置"},{key:"about",label:"关于插件"}],Si=[["Eyebrows",[["Soft","柔和"],["Lowered","低垂"],["Raised","上扬"],["Frown","皱眉"]]],["Eyes",[["VeryLewd","失神"],["HeartPink","心形粉"],["LewdHeartPink","涩心粉"],["Closed","闭眼"],["Dazed","恍惚"]]],["Mouth",[["Frown","抿嘴"],["Moan","呻吟"],["Ahegao","阿黑颜"],["Open","张开"]]],["Blush",[["High","高"],["Medium","中"],["Low","低"],["VeryHigh","极高"]]]];let nn=!1;function wi(){if(!nn){nn=!0;try{const e=document.createElement("style");e.id="pex-settings-styles",e.textContent=`
#pex-settings-panel{position:fixed;left:50%;top:50%;transform:translate(-50%,-50%);
  width:min(100vw,1800px);height:min(100vh,1000px);
  background:#1e1930;border:2px solid #f27ba8;border-radius:12px;color:#e8e4f5;
  font-family:sans-serif;font-size:20px;z-index:2147483646;box-shadow:0 8px 40px rgba(0,0,0,.65);
  display:flex;flex-direction:column;overflow:hidden}
.pex-s-head{display:flex;align-items:center;justify-content:space-between;padding:18px 26px;
  border-bottom:1px solid #37305a;background:#241d3a}
.pex-s-title{color:#f27ba8;font-weight:600;font-size:24px}
.pex-s-body{display:flex;flex:1;min-height:0}
.pex-s-nav{width:240px;border-right:1px solid #37305a;padding:16px 14px;display:flex;flex-direction:column;gap:6px}
.pex-sec-btn{background:transparent;color:#9b93bd;border:none;border-radius:8px;padding:15px 18px;
  text-align:left;font-size:20px;cursor:pointer}
.pex-sec-btn:hover{background:#2a2450;color:#e8e4f5}
.pex-sec-btn.on{background:#f27ba8;color:#241d3a;font-weight:600}
.pex-s-content{flex:1;overflow-y:auto;padding:18px 26px}
.pex-row{display:flex;align-items:center;justify-content:space-between;gap:18px;margin:11px 0}
.pex-lbl{color:#c9c2e0;font-size:20px;flex-shrink:0}
.pex-ctl{display:flex;align-items:center;gap:10px}
.pex-tgl{background:#3a3270;color:#fff;border:none;border-radius:8px;padding:10px 28px;cursor:pointer;font-size:20px}
.pex-tgl.on{background:#2a6b63}
.pex-sel{background:#2a6b63;color:#fff;border:1px solid #37305a;border-radius:8px;padding:10px 14px;font-size:20px}
.pex-num{background:#2b2450;color:#e8e4f5;border:1px solid #c2557f;border-radius:8px;padding:10px 14px;width:130px;font-size:20px}
.pex-txt{background:#2b2450;color:#e8e4f5;border:1px solid #37305a;border-radius:8px;padding:10px 14px;
  width:100%;box-sizing:border-box;font-family:monospace;font-size:19.5px;resize:vertical;min-height:100px}
.pex-note{color:#7d749e;font-size:17.5px;margin:6px 0 14px;line-height:1.7}
.pex-sec-title{color:#f27ba8;font-weight:600;font-size:21.5px;margin:16px 0 6px}
.pex-act{background:#3a3270;color:#fff;border:none;border-radius:8px;padding:12px 26px;cursor:pointer;font-size:20px}
.pex-act:hover{background:#4a407f}
.pex-act.danger{background:#872626}
.pex-act.ok{background:#2a6b63}
.pex-about-line{color:#c9c2e0;font-size:20px;line-height:1.8;margin:3px 0}
.pex-about-head{color:#f27ba8;font-weight:600;font-size:21.5px;margin:14px 0 4px}
.pex-expr-del{background:#872626;color:#fff;border:none;border-radius:8px;padding:8px 18px;margin-left:12px;cursor:pointer;font-size:17px;vertical-align:middle}
.pex-confirm-dialog{position:fixed;left:50%;top:50%;transform:translate(-50%,-50%);width:420px;
  background:linear-gradient(135deg,rgba(30,10,40,.98),rgba(50,15,60,.98));border:1px solid rgba(255,120,200,.45);
  border-radius:12px;padding:22px;z-index:2147483647;color:#ffddee;font-family:sans-serif;font-size:14px;
  box-shadow:0 8px 40px rgba(180,60,160,.4);text-align:center}
.pex-confirm-dialog .msg{font-size:14px;margin-bottom:18px;line-height:1.6;white-space:pre-line}
.pex-confirm-dialog button{border:none;border-radius:8px;padding:9px 26px;font-size:14px;font-weight:600;cursor:pointer;margin:0 7px}
.pex-confirm-dialog .no{background:#4a2030;color:#ffaabb}
.pex-confirm-dialog .yes{background:#872626;color:#aaffaa}
.pex-btn-row{display:flex;gap:10px;margin:10px 0;flex-wrap:wrap}
`,document.head.appendChild(e)}catch{}}}function E(e){return String(e??"").replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;")}function et(e,t){try{const r=document.querySelector(".pex-confirm-dialog");r&&r.remove()}catch{}const n=document.createElement("div");n.className="pex-confirm-dialog",n.innerHTML=`<div class="msg">${E(e)}</div>
        <div><button class="no" type="button">取消</button><button class="yes" type="button">确认</button></div>`,n.querySelector(".no").onclick=()=>n.remove(),n.querySelector(".yes").onclick=()=>{n.remove();try{t&&t()}catch{}},document.body.appendChild(n)}const V={active:"basic",panel:null,_needsRender:!0,load(){try{ln()}catch{}},run(){try{wi(),(!this.panel||!document.getElementById(tn))&&(this._build(),this._needsRender=!0),this._needsRender&&(this._needsRender=!1,this._render(this.active),this._syncNav())}catch(e){p("设置面板渲染异常:",e.message)}},click(){},unload(){this._close()},exit(){this._close()},_close(){try{this.panel&&(this.panel.remove(),this.panel=null)}catch{}},_build(){if(this.panel)try{this.panel.remove()}catch{}const e=document.createElement("div");e.id=tn,e.innerHTML=`
            <div class="pex-s-head">
                <div class="pex-s-title">人格排泄 · 设置</div>
                <button type="button" class="pex-act" data-pex-close="1">✕</button>
            </div>
            <div class="pex-s-body">
                <div class="pex-s-nav">
                    ${Ei.map(t=>`<button type="button" class="pex-sec-btn" data-pex-sec="${t.key}" title="${E(t.label)}">${E(t.label)}</button>`).join("")}
                </div>
                <div class="pex-s-content"></div>
            </div>`,document.body.appendChild(e),this.panel=e,e.querySelector("[data-pex-close]").onclick=()=>{try{typeof PreferenceExit=="function"&&PreferenceExit()}catch{}this._close()},e.querySelectorAll("[data-pex-sec]").forEach(t=>{t.onclick=()=>{this.active!==t.dataset.pexSec&&(this.active=t.dataset.pexSec,this._needsRender=!0,this.run())}})},_syncNav(){try{this.panel.querySelectorAll("[data-pex-sec]").forEach(e=>{e.classList.toggle("on",e.dataset.pexSec===this.active)})}catch{}},_render(e){const t=this.panel.querySelector(".pex-s-content"),n=document.createElement("div");n.className="pex-s-content",t&&t.replaceWith(n);const r=this["_sec_"+e];n.innerHTML=typeof r=="function"?r.call(this):'<div class="pex-note">暂无内容</div>',this._bind(n),e==="expr"&&this._ensureExprPreview()},_bind(e){e.addEventListener("click",t=>{const n=t.target.closest("[data-pex-side]");if(n){const a=n.dataset.pexSide,c=n.dataset.pexVal==="1";this._setPath(a,c),e.querySelectorAll(`[data-pex-side="${a}"]`).forEach(u=>{u.classList.toggle("on",u.dataset.pexVal===n.dataset.pexVal)});return}const r=t.target.closest("[data-pex-mode]");if(r){const a=r.dataset.pexMode;l.editModes&&(l.editModes[a]=r.dataset.pexMv);try{_()}catch{}e.querySelectorAll(`[data-pex-mode="${a}"]`).forEach(c=>{c.classList.toggle("on",c.dataset.pexMv===r.dataset.pexMv)});return}const i=t.target.closest("[data-pex-action]");if(i){const a=this._actions[i.dataset.pexAction];a&&a()}if(t.target.closest("[data-pex-add-expr]")){const a=l.expressions?.wait;if(Array.isArray(a)&&a.length<10){a.push({...l.expressions.excrete||{}});try{_()}catch{}this._needsRender=!0,this.run()}return}const s=t.target.closest("[data-pex-del-expr]");if(s){const a=parseInt(s.dataset.pexDelExpr,10);et('确定删除"等待表情 '+(a+1)+'"吗？',()=>{const c=l.expressions?.wait;if(Array.isArray(c)&&c[a]){c.splice(a,1);try{_()}catch{}this._needsRender=!0,this.run()}});return}}),e.addEventListener("change",t=>{const n=t.target;if(n.dataset.pexSelect){this._setPath(n.dataset.pexSelect,n.value);const r=n.dataset.pexSelect;if(r.startsWith("expressions.wait.")){const i=parseInt(r.split(".").pop(),10);isNaN(i)||(this._exprEditKey=i)}else r.startsWith("expressions.")?this._exprEditKey=r.split(".")[1]:r.startsWith("normalExpression")&&(this._exprEditKey="normal");(r.startsWith("expressions.")||r.startsWith("normalExpression"))&&this._ensureExprPreview();return}if(n.dataset.pexNumber){const r=parseInt(n.value,10);isNaN(r)||this._setPath(n.dataset.pexNumber,r);return}if(n.dataset.pexText){this._setPath(n.dataset.pexText,n.value);return}if(n.dataset.pexSound){const r=n.dataset.pexSound,i=n.value.split(`
`).map(o=>o.trim()).filter(Boolean);l.sounds[r]=i;try{Re()}catch{}}})},_getPath(e){return e.split(".").reduce((t,n)=>t==null?t:t[n],l)},_setPath(e,t){if(e==="whitelistText"){l.whitelist=String(t).split(/[\s,]+/).map(o=>o.trim()).filter(Boolean);try{_()}catch{}return}if(e==="keywords"||e==="normalKeywords"){l[e]=String(t).split(`
`).map(o=>o.trim()).filter(Boolean);try{_()}catch{}return}if(e.startsWith("soundOn.")){const o=e.split(".");l.soundOn&&(l.soundOn[o[1]]=!!t);try{Re()}catch{}return}const n=e.split("."),r=n.pop();let i=l;for(const o of n)i=i[o];if(i&&r in i){i[r]=t;try{_()}catch{}}},_actions:{recover:()=>{et(`确定要强制恢复吗？
此操作会立即清除全部 PEX 状态，包括等待、失神与凝胶。`,()=>We())},reset:()=>{et(`确定要恢复默认设置吗？
所有设置将还原为初始值。`,()=>{Ge(R()),_(!0),ge(!0),V._needsRender=!0,V.run()})},exportCfg:()=>{try{un()}catch{}},importCfg:()=>{try{dn()}catch{}}},_row(e,t,n){return`<div class="pex-row"><div class="pex-lbl" title="${E(t)}">${E(e)}</div><div class="pex-ctl">${n}</div></div>`},_tgl(e,t="开 / 关"){const n=!!this._getPath(e);return`<button type="button" class="pex-tgl ${n?"":"on"}" data-pex-side="${e}" data-pex-val="0" title="${E(t)}">关</button><button type="button" class="pex-tgl ${n?"on":""}" data-pex-side="${e}" data-pex-val="1" title="${E(t)}">开</button>`},_sel(e,t,n){const r=this._getPath(e);return`<select class="pex-sel" data-pex-select="${e}" title="${E(n||"")}">${t.map(([i,o])=>`<option value="${i}" ${r===i?"selected":""}>${E(o)}</option>`).join("")}</select>`},_num(e,t,n,r){return`<input type="number" class="pex-num" data-pex-number="${e}" min="${t}" max="${n}" value="${this._getPath(e)}" title="${E(r||"")}">`},_txt(e,t,n){const r=this._getPath(e),i=Array.isArray(r)?r.join(`
`):r??"";return`<textarea class="pex-txt" data-pex-text="${e}" title="${E(t||"")}" placeholder="${E(n||"")}">${E(i)}</textarea>`},_sec_basic(){return`
            ${this._row("启用插件","关闭后所有触发与表现全部停用",this._tgl("enabled","插件总开关"))}
            <div class="pex-sec-title">触发关键词</div>
            <div class="pex-note">关键词写在物品的制作名、制作描述或雕刻描述中；喝下或注射该物品即触发。</div>
            ${this._row("人格凝胶关键词","命中后进入完整排出流程：眩晕、排出、失神","")}
            ${this._txt("keywords","人格凝胶关键词，每行一个","如：人格药水")}
            ${this._row("普通凝胶关键词","命中后排出普通凝胶：眩晕、表情、凝胶落地，但没有任何失神限制","")}
            ${this._txt("normalKeywords","普通凝胶关键词，每行一个","如：普通凝胶")}
            <div class="pex-sec-title">安全</div>
            <div class="pex-btn-row">
                <button type="button" class="pex-act danger" data-pex-action="recover">强制恢复</button>
            </div>
            <div class="pex-note">强制恢复会立即清除全部 PEX 状态，包括等待、失神与凝胶，需要弹窗二次确认。</div>`},_sec_excrete(){return`
            <div class="pex-sec-title">时间</div>
            ${this._row("排出前等待（秒）","喝下或注射后到开始排出之间的等待时间；等待音效按它自动分段（10 秒 1 段…50 秒及以上 5 段）",this._num("waitSeconds",10,600,"10 到 600 秒"))}
            ${this._row("臀部阻挡上限（分）","臀部装备位有东西时等待多久，超时药效静默消失",this._num("blockedWaitMinutes",1,30,"1 到 30 分钟"))}
            ${this._row("自动回归（分）","排出后多久没被喂回就自动恢复",this._num("autoRevertMinutes",1,30,"1 到 30 分钟"))}
            ${this._row("自动回归","超时后自动恢复并处理凝胶；关闭后凝胶一直等喂回",this._tgl("autoRevertEnabled","自动回归开关"))}
            <div class="pex-sec-title">凝胶</div>
            ${this._row("凝胶到期","到期时凝胶消散消失，或变成持有者手上的无效凝胶永久保留",this._sel("gelExpireMode",[["vanish","消散消失"],["invalid","变无效凝胶"]],"到期行为"))}
            <div class="pex-sec-title">失神限制</div>
            ${this._row("失神限制","失神时不能动、禁言、不眨眼、姿势锁定；关闭后失神只保留视觉表现",this._tgl("restrictions","失神限制总开关"))}
            <div class="pex-note">关闭失神限制后，排出者失神期间仍可以行动、说话和离开房间。</div>`},_sec_fx(){return`
            <div class="pex-sec-title">特效开关</div>
            ${this._row("等待期眩晕","喝下后等待期的眩晕脉冲效果",this._tgl("fxDizzy","眩晕脉冲"))}
            ${this._row("失神黑白","失神时画面黑白并压暗，暗角强弱随特效强度",this._tgl("fxBlank","黑白特效"))}
            ${this._row("模糊特效","眩晕、排出与失神时的画面模糊",this._tgl("fxBlur","模糊特效"))}
            ${this._row("排出震动","排出动画期间的画面震动",this._tgl("fxShake","排出震动"))}
            <div class="pex-sec-title">强度与视野</div>
            ${this._row("特效强度","数字越大，眩晕、模糊、暗角越强",this._sel("effectLevel",[[1,"1"],[2,"2"],[3,"3"],[4,"4"],[5,"5"]],"特效强度 1 到 5"))}
            ${this._row("失神视野","失神时画面整体变暗的程度，关闭则视野不变",this._sel("blindLevel",[[0,"无"],[1,"轻度"],[2,"中度"],[3,"重度"]],"失神视野档位"))}
            ${this._row("凝胶图层","凝胶画在第几层，数字越大越靠上层，24 及以上为顶层（不被遮住）",this._num("gelLayer",0,99,"0 到 99，默认 24"))}
            <div class="pex-sec-title">他人视角</div>
            ${this._row("看别人排出动画","是否播放他人排出时的动画",this._tgl("seeRemoteAnims","远程排出动画"))}
            ${this._row("其他玩家音效","是否播放其他玩家广播的音效（等待/排出/放回）；默认关闭 = 只有自己听得到",this._tgl("hearRemoteSounds","其他玩家音效"))}
            ${this._row("计时器可见性","头顶倒计时谁能看到",this._sel("timerVisibility",[["self","仅自己"],["whitelist","仅白名单"],["others","仅他人"],["all","所有人"]],"计时器可见性"))}
            <div class="pex-note">凝胶固定在角色身体层绘制，会被衣服遮住；特效与强度均为本地设置，不会通过远程修改开放给他人。</div>`},_sec_perm(){const e=l,t=[["time","时间类","排出前等待、臀部阻挡上限、自动回归分钟"],["autoRevert","凝胶自动回归","自动回归的开关"],["timerVisibility","计时器可见性","头顶倒计时的可见档位"]],n=[["off","仅自己"],["whitelist","白名单"],["any","所有人"]];let r='<div class="pex-note">每类设置可独立选择能否被别人远程修改，默认仅自己。</div>';for(const[i,o,s]of t){const a=e.editModes&&e.editModes[i]||"off";r+=this._row(o,s,n.map(([c,u])=>`<button type="button" class="pex-tgl ${a===c?"on":""}" data-pex-mode="${i}" data-pex-mv="${c}" title="${E(s)}">${u}</button>`).join(""))}return r+=`<div class="pex-sec-title">白名单</div>
            <div class="pex-note">成员号逗号分隔，支持 $owner、$lover 等代号；远程修改权限选白名单时生效。</div>
            <textarea class="pex-txt" data-pex-text="whitelistText" title="白名单成员号" placeholder="如：12345, 67890">${E((e.whitelist||[]).join(", "))}</textarea>`,r},_sec_expr(){const e=l.expressions||{},t=Array.isArray(e.wait)?e.wait:[];let n=`<div style="display:flex;gap:18px;align-items:flex-start">
            <div style="flex:1">`;n+=`<div class="pex-sec-title">等待表情池</div>
            <div class="pex-note">排出前等待期间随机抽取播放，与等待音效同步出现（同一时间点）；可自行添加更多组（最多 10 组）。</div>`;for(let r=0;r<t.length;r++)n+=`<div class="pex-sec-title">等待表情 ${r+1}
                <button type="button" class="pex-expr-del" data-pex-del-expr="${r}" title="删除这组等待表情">✕</button></div>`,n+=this._exprRow(`expressions.wait.${r}`);return n+='<div class="pex-btn-row"><button type="button" class="pex-act ok" data-pex-add-expr="wait" title="添加一组等待表情（最多 10 组）">＋ 新增等待表情</button></div>',n+=`<div class="pex-sec-title">排出表情</div>
            <div class="pex-note">与排出动画同时播放（等待期表情之外的下一组）</div>`,n+=this._exprRow("expressions.excrete"),n+=`<div class="pex-sec-title">失神定格</div>
            <div class="pex-note">凝胶排出后定格，持续到恢复</div>`,n+=this._exprRow("expressions.blank"),n+=`<div class="pex-sec-title">普通凝胶表情</div>
            <div class="pex-note">普通凝胶排出后的短暂表情变化</div>`,n+=this._exprRow("normalExpression"),n+=`</div>
            <div style="width:200px;text-align:center;position:sticky;top:0">
                <img id="pex-expr-preview" alt="" style="width:170px;height:170px;border-radius:50%;border:2px solid #f27ba8;background:#241d3a;object-fit:cover">
                <div class="pex-note" style="margin-top:8px">表情预览</div>
            </div>
        </div>`,n},_exprRow(e){let t="";for(const[n,r]of Si)t+=this._row(n,n+" 表情",this._sel(e+"."+n,r,n+" 表情"));return t},_exprPreviewKey:null,_exprEditKey:0,_ensureExprPreview(){const e=this._exprEditKey==="normal"?l.normalExpression:typeof this._exprEditKey=="number"?l.expressions?.wait?.[this._exprEditKey]:l.expressions?.[this._exprEditKey];if(!e)return;const t=String(this._exprEditKey)+":"+JSON.stringify(e);if(t===this._exprPreviewKey)return;this._exprPreviewKey=t;const n=document.getElementById("pex-expr-preview");if(n)try{if(typeof Player>"u"||!Player||typeof CharacterLoadCanvas!="function"){this._fallbackPreview(e,n);return}const r=this._expandExpr(e),i=Object.assign(Object.create(Object.getPrototypeOf(Player)),Player);i.MemberNumber=-77777,i.Appearance=(Player.Appearance||[]).map(s=>{const a=s.Asset.Group.Name;if(r[a]===void 0)return s;const c=Object.assign({},s);return c.Property=Object.assign({},s.Property),c.Property.Expression=r[a],c}),i.Canvas=null,i.CanvasBlink=null,i.MustDraw=!0;try{CharacterLoadCanvas(i)}catch{}const o=()=>{try{const s=i.Canvas;s&&s.width&&this._captureFace(s,n)}catch{}};o(),setTimeout(o,160),setTimeout(o,420),setTimeout(()=>{(!n.src||!n.src.startsWith("data:"))&&this._fallbackPreview(e,n)},1e3)}catch{this._fallbackPreview(e,n)}},_fallbackPreview(e,t){try{if(typeof Player>"u"||!Player?.Appearance||typeof CharacterRefresh!="function")return;const n=this._expandExpr(e),r={},i=[];for(const[o,s]of Object.entries(n))try{if(s==null)continue;const a=Player.Appearance.find(c=>c.Asset.Group.Name===o);if(!a)continue;r[o]=a.Property?.Expression??null,a.Property||(a.Property={}),a.Property.Expression=s,i.push(o)}catch{}if(!i.length)return;try{CharacterRefresh(Player,!1,!1)}catch{}setTimeout(()=>{try{Player?.Canvas?.width&&this._captureFace(Player.Canvas,t)}catch{}try{for(const[o,s]of Object.entries(r)){const a=Player.Appearance.find(c=>c.Asset.Group.Name===o);a&&(a.Property||(a.Property={}),a.Property.Expression=s)}CharacterRefresh(Player,!1,!1)}catch{}},300)}catch{}},_captureFace(e,t){try{const r=document.createElement("canvas");r.width=r.height=320;const i=r.getContext("2d"),o=e.width*.2,s=e.width*.5-o/2,a=e.height*.43-o*.22;i.drawImage(e,s,a,o,o,0,0,320,320);const c=new Image;c.onload=()=>{try{t.src=c.src}catch{}},c.src=r.toDataURL()}catch{}},_expandExpr(e){const t=e.Eyes??null,n=e.Eyes2!==void 0?e.Eyes2:t;return{Eyebrows:e.Eyebrows??null,Eyes:t,Eyes2:n,Mouth:e.Mouth??null,Blush:e.Blush??null,右眼_Luzi:t,左眼_Luzi:n}},_sec_sound(){const e=l.sounds||{wait:[],excrete:[],feed:[]},t=[["wait","等待音效","排出前等待期间分段播放，与等待表情同步出现：10 秒 1 段、20 秒 2 段、30 秒 3 段、40 秒 4 段、50 秒及以上 5 段，均匀分布随机选段；内置 5 段（CDN），自定义地址加入随机池"],["excrete","排出音效","排出动画期间播放；动画长度自动对齐音效时长（默认 7.34 秒）"],["feed","放回音效","被喂回、黑白特效淡出结束后播放（默认 3.96 秒）"]];let n='<div class="pex-note">每类音效有独立开关（关 = 本地不播，也不广播给别人）；素材每行一个地址，留空用内置默认。</div>';for(const[r,i,o]of t){const s=Array.isArray(e[r])?e[r]:[];n+=`<div class="pex-sec-title">${i}　${this._tgl("soundOn."+r,i+"开关")}</div>
                <div class="pex-note">${o}</div>
                <textarea class="pex-txt" data-pex-sound="${r}" title="${E(o)}" placeholder="https://…">${E(s.join(`
`))}</textarea>`}return n},_sec_about(){return`
            <div class="pex-about-head">玩法说明</div>
            <div class="pex-about-line">1. 制作一瓶饮料，在制作名或雕刻描述里写上触发关键词。</div>
            <div class="pex-about-line">2. 喝下或注射后进入排出等待：眩晕脉冲，前两个表情在三分之一和三分之二处播放。</div>
            <div class="pex-about-line">3. 到排出时刻检查臀部装备位：空则排出，有东西会等待，拿掉立刻排出。</div>
            <div class="pex-about-line">4. 排出时第三个表情与动画同播，画面剧烈震动并模糊。</div>
            <div class="pex-about-line">5. 人格凝胶排出后失神：黑白、不能动、禁言、不眨眼、视野变暗，凝胶落在脚边。</div>
            <div class="pex-about-line">6. 点击失神者，在对话框中捡起凝胶，交还原主人喂回即恢复；到期按设置消散或变无效凝胶。</div>
            <div class="pex-about-line">7. 普通凝胶排出后没有失神限制，凝胶同样可以捡起和喂回。</div>
            <div class="pex-about-line">8. 安全：随时使用基本设置中的强制恢复，或输入 /pex reset yes。</div>
            <div class="pex-about-head">指令</div>
            <div class="pex-about-line">/pex help 帮助　/pex howto 玩法说明　/pex status 当前状态</div>
            <div class="pex-about-line">/pex show 控制台面板　/pex settings 打开设置　/pex reset 强制恢复</div>
            <div class="pex-about-head">版本</div>
                <div class="pex-about-line">Personality Excretion v${N}</div>
            <div class="pex-about-head">调试</div>
            <div class="pex-about-line">按 F12 打开浏览器控制台，把 ⚗️[PEX] 开头的报错信息发给作者。</div>
            <div class="pex-about-head">数据</div>
            <div class="pex-btn-row">
                <button type="button" class="pex-act" data-pex-action="exportCfg">导出设置</button>
                <button type="button" class="pex-act" data-pex-action="importCfg">导入设置</button>
                <button type="button" class="pex-act danger" data-pex-action="reset">恢复默认</button>
            </div>
            <div class="pex-about-head">音效素材</div>
            <div class="pex-about-line">默认音效素材来自 pincree.jp 的免费资源（Free Assets）。</div>`}};function Pi(){const e=()=>{try{return typeof PreferenceRegisterExtensionSetting!="function"?!1:(PreferenceRegisterExtensionSetting({Identifier:gt,ButtonText:"人格排泄 PEX",load:()=>V.load(),run:()=>V.run(),click:()=>V.click(),unload:()=>V.unload(),exit:()=>V.exit()}),!0)}catch(r){return p("设置页注册失败:",r.message),!1}};if(e())return;let t=0;const n=setInterval(()=>{t++,(e()||t>30)&&clearInterval(n)},1e3)}function Rn(e){try{return e?.OnlineSharedSettings?.["PEX"]?.state||null}catch{return null}}function Mi(e){try{const t=Rn(e);if(!t||!t.remainingSec||t.remainingSec<=0||t.mode!=="waiting"&&t.mode!=="blocked"&&t.mode!=="blank")return!1;const n=e?.MemberNumber!=null&&Player?.MemberNumber!=null&&e.MemberNumber===Player.MemberNumber,r=t.timerVisibility||l.timerVisibility||"all";if(r==="all"||r==="both")return!0;if(r==="self")return n;if(r==="others")return!n;if(r==="whitelist"){if(n)return!0;const i=e?.OnlineSharedSettings?.["PEX"]?.wl||[],o=Player?.MemberNumber;return i.includes(String(o))}return!1}catch{return!1}}function Ai(e){const t=Math.max(0,Math.ceil(e)),n=Math.floor(t/60);return String(n).padStart(2,"0")+":"+String(t%60).padStart(2,"0")}function _i(e,t,n,r,i){const o=r||1,s=t+100*o,a=n+95*o;let c;i.expiresAt>0?c=Math.max(0,Math.ceil((i.expiresAt-Date.now())/1e3)):c=Math.max(0,i.remainingSec||0);const u=Ai(c);let d=null;const h=typeof MainCanvas<"u"?MainCanvas:null;if(h)try{d=h.font,h.font="600 "+Math.max(12,Math.round(15*o))+'px "Segoe UI", Arial, sans-serif'}catch{}if(DrawText(u,s+1,a+1,"Black",""),DrawText(u,s,a,"#ffffff",""),h&&d!=null)try{h.font=d}catch{}}function Ni(){const e=U();if(e)try{e.hookFunction("ChatRoomCharacterViewDrawOverlay",1,(t,n)=>{const r=n(t);try{if(typeof ChatRoomHideIconState<"u"&&ChatRoomHideIconState>=2)return r;const[i,o,s,a]=t;if(!i||!Mi(i))return r;const c=Rn(i);_i(i,o,s,a,c)}catch{}return r})}catch(t){console.warn("⚗️[PEX] 计时器挂钩失败:",t.message)}}const L={x:1715,y:175,w:90,h:90},ve="pex-remote-panel",Dn=[{key:"time",label:"时间类"},{key:"autoRevert",label:"凝胶自动回归"},{key:"timerVisibility",label:"计时器可见性"}];function tt(e,t){return t==="any"?!0:t==="whitelist"?(Array.isArray(e?.wl)?e.wl.map(Number):[]).includes(Number(Player?.MemberNumber)):!1}function Ln(e){const t=e?.editModes||{};return{time:tt(e,t.time),autoRevert:tt(e,t.autoRevert),timerVisibility:tt(e,t.timerVisibility)}}function ki(e){return!!(e&&(e.time||e.autoRevert||e.timerVisibility))}const W={},he={},Lt=6e4,Ii=8e3;function On(e){const t=Number(e),n=Date.now(),r=W[t];r&&n-r.ts<Lt||he[t]&&n-he[t]<Ii||(he[t]=n,P("PEX_PermQuery",[{Tag:"PEX_PermQuery",Target:t}]))}function Ti(e,t){const n=W[e?.MemberNumber];return n&&Date.now()-n.ts<Lt?n:{perms:Ln(t),values:null,ts:Date.now()}}function yt(e){try{return e?.OnlineSharedSettings?.["PEX"]||null}catch{return null}}function rn(){try{return typeof InformationSheetSelection<"u"?InformationSheetSelection:null}catch{return null}}const y={open:!1,target:null,perms:{},values:{},dirty:!1};function Ci(){let e=document.getElementById(ve);e||(e=document.createElement("div"),e.id=ve,Object.assign(e.style,{position:"fixed",left:"50%",top:"50%",transform:"translate(-50%,-50%)",width:"380px",background:"#1e1930",border:"2px solid #f27ba8",borderRadius:"12px",color:"#e8e4f5",fontFamily:"sans-serif",fontSize:"13px",padding:"16px",zIndex:"2147483646",boxShadow:"0 8px 40px rgba(0,0,0,.6)",maxHeight:"80vh",overflowY:"auto"}),document.body.appendChild(e)),e.style.display="block",y.open=!0,$n(e)}function ht(){const e=document.getElementById(ve);e&&(e.style.display="none"),y.open=!1}function Ae(e){return String(e??"").replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;")}function $n(e){const t=y.target&&ne(y.target)||"对方";let n=`<div style="display:flex;justify-content:space-between;align-items:center;margin-bottom:10px">
        <b style="color:#f27ba8">编辑 ${Ae(t)} 的 PEX 设置</b>
        <button id="pex-remote-close" style="background:#3a2a4a;color:#e8e4f5;border:none;border-radius:6px;padding:4px 10px;cursor:pointer">✕</button>
    </div>`;const r=(s,a,c)=>{const u=!!y.perms[s];n+=`<div style="margin:8px 0;opacity:${u?1:.45}">
            <div style="color:#9b93bd;margin-bottom:4px">${a}${u?"":" 🔒"}</div>${c}</div>`};r("time","排出前等待（秒，0~600）",`<input id="pex-r-wait" type="number" min="0" max="600" value="${Ae(y.values.waitSeconds)}" ${y.perms.time?"":"disabled"}
         style="width:100%;background:#241d3a;color:#e8e4f5;border:1px solid #37305a;border-radius:6px;padding:6px">`),r("time","阻挡等待上限（分钟，1~30）",`<input id="pex-r-blocked" type="number" min="1" max="30" value="${Ae(y.values.blockedWaitMinutes)}" ${y.perms.time?"":"disabled"}
         style="width:100%;background:#241d3a;color:#e8e4f5;border:1px solid #37305a;border-radius:6px;padding:6px">`),r("time","凝胶自动回归（分钟，1~30）",`<input id="pex-r-autorev" type="number" min="1" max="30" value="${Ae(y.values.autoRevertMinutes)}" ${y.perms.time?"":"disabled"}
         style="width:100%;background:#241d3a;color:#e8e4f5;border:1px solid #37305a;border-radius:6px;padding:6px">`),r("timerVisibility","计时器可见性",`<select id="pex-r-vis" ${y.perms.timerVisibility?"":"disabled"}
         style="width:100%;background:#2a6b63;color:#fff;border:1px solid #37305a;border-radius:6px;padding:6px">
         <option value="self" ${y.values.timerVisibility==="self"?"selected":""}>仅自己</option>
         <option value="whitelist" ${y.values.timerVisibility==="whitelist"?"selected":""}>仅白名单</option>
         <option value="others" ${y.values.timerVisibility==="others"?"selected":""}>仅他人</option>
         <option value="all" ${(y.values.timerVisibility||"all")==="all"?"selected":""}>所有人</option></select>`),r("autoRevert","自动回归开关",`<select id="pex-r-ar" ${y.perms.autoRevert?"":"disabled"}
         style="width:100%;background:#2a6b63;color:#fff;border:1px solid #37305a;border-radius:6px;padding:6px">
         <option value="1" ${y.values.autoRevertEnabled?"selected":""}>开启</option>
         <option value="0" ${y.values.autoRevertEnabled?"":"selected"}>关闭</option></select>`);const i=Object.values(y.perms).some(Boolean);n+=`<div style="display:flex;gap:8px;margin-top:14px">
        <button id="pex-remote-save" style="flex:1;background:${i?"#2a6b63":"#3a2a4a"};color:#fff;border:none;border-radius:8px;padding:8px;cursor:${i?"pointer":"not-allowed"}" ${i?"":"disabled"}>保存</button>
        <button id="pex-remote-refresh" style="flex:1;background:#3a2a4a;color:#e8e4f5;border:none;border-radius:8px;padding:8px;cursor:pointer">刷新</button>
    </div>`,n+='<div style="color:#9b93bd;font-size:11px;margin-top:8px">仅可编辑有权限的类别（🔒=无权限）</div>',e.innerHTML=n,e.querySelector("#pex-remote-close").onclick=()=>ht(),e.querySelector("#pex-remote-refresh").onclick=()=>{if(!y.target)return;const s=Number(y.target.MemberNumber);delete W[s],delete he[s],On(s),v("正在刷新权限与设置…",3e3)};const o=e.querySelector("#pex-remote-save");o&&(o.onclick=()=>Di())}const nt={};let O=null,H=null;function Ri(e){const t=Number(e?.MemberNumber);if(t==null)return;const n=W[t];if(n&&Date.now()-n.ts<Lt){Bn(e);return}O={num:t,C:e},he[t]=Date.now(),P("PEX_PermQuery",[{Tag:"PEX_PermQuery",Target:t}],{priority:!0});const r=ne(e)||String(t);v(x("remoteEditLoading",{name:r}),4e3),H&&clearTimeout(H),H=setTimeout(()=>{H=null,O&&O.num===t&&(O=null,v(x("remoteEditLoadFail",{name:r}),8e3))},6e3)}function Bn(e){const t=e.MemberNumber,n=Date.now();t!=null&&(!nt[t]||n-nt[t]>15e3)&&(nt[t]=n,P("PEX_Access",[{Tag:"PEX_Access",Target:t,Name:String(ne(Player)||Player?.MemberNumber||"")}],{dedupeKey:"access:"+t,dedupeMs:15e3})),y.target=e;const r=W[t];y.perms=r?r.perms:Ln(yt(e)),y.values=r&&r.values?r.values:{},Ci()}function Di(){const e=document.getElementById(ve);if(!e||!y.target)return;const t=i=>{try{return e.querySelector(i)?.value}catch{return}},n={waitSeconds:t("#pex-r-wait")!==void 0?parseInt(t("#pex-r-wait"),10):void 0,blockedWaitMinutes:t("#pex-r-blocked")!==void 0?parseInt(t("#pex-r-blocked"),10):void 0,autoRevertMinutes:t("#pex-r-autorev")!==void 0?parseInt(t("#pex-r-autorev"),10):void 0,timerVisibility:t("#pex-r-vis"),autoRevertEnabled:t("#pex-r-ar")==="1"},r={};for(const i of Dn)y.perms[i.key]&&(i.key==="time"?(n.waitSeconds!=null&&(r.waitSeconds=te(n.waitSeconds,0,600)),n.blockedWaitMinutes!=null&&(r.blockedWaitMinutes=te(n.blockedWaitMinutes,1,30)),n.autoRevertMinutes!=null&&(r.autoRevertMinutes=te(n.autoRevertMinutes,1,30))):i.key==="timerVisibility"?["self","whitelist","others","all"].includes(n.timerVisibility)&&(r.timerVisibility=n.timerVisibility):i.key==="autoRevert"&&(r.autoRevertEnabled=!!n.autoRevertEnabled));Object.keys(r).length!==0&&(P("PEX_RemoteSet",[{Tag:"PEX_RemoteSet",Target:String(y.target?.MemberNumber),Values:r}]),v("已发送设置修改请求，等待对方确认…",6e3))}function te(e,t,n){return Math.max(t,Math.min(n,e))}function Li(){ie(e=>{try{if(e?.Type!=="Hidden")return;const t=Array.isArray(e.Dictionary)?e.Dictionary:[],n=o=>{const s=t.find(a=>a?.Tag===o);if(s)return s.Value??s.Name;for(const a of t)if(a&&typeof a=="object"&&a.Tag&&o in a)return a[o]},r=Number(e.Sender),i=o=>{const s=(l.editModes||{})[o]||"off";return s==="any"?!0:s==="whitelist"?(l.whitelist||[]).map(String).includes(String(r)):!1};if(e.Content==="PEX_PermQuery"&&Number(n("Target"))===Player?.MemberNumber){const o={};Dn.forEach(s=>{o[s.key]=i(s.key)}),P("PEX_PermReply",[{Tag:"PEX_PermReply",Target:String(r),Perms:o,Values:{waitSeconds:l.waitSeconds,blockedWaitMinutes:l.blockedWaitMinutes,autoRevertMinutes:l.autoRevertMinutes,autoRevertEnabled:l.autoRevertEnabled,timerVisibility:l.timerVisibility}}],{priority:!0,dedupeKey:"permr:"+r,dedupeMs:500})}else if(e.Content==="PEX_RemoteSet"&&Number(n("Target"))===Player?.MemberNumber){const o=n("Values")||{};i("time")&&(o.waitSeconds!=null&&(l.waitSeconds=te(+o.waitSeconds,0,600)),o.blockedWaitMinutes!=null&&(l.blockedWaitMinutes=te(+o.blockedWaitMinutes,1,30)),o.autoRevertMinutes!=null&&(l.autoRevertMinutes=te(+o.autoRevertMinutes,1,30))),i("timerVisibility")&&["self","whitelist","others","all"].includes(o.timerVisibility)&&(l.timerVisibility=o.timerVisibility),i("autoRevert")&&o.autoRevertEnabled!==void 0&&(l.autoRevertEnabled=!!o.autoRevertEnabled),_(!0),ge(!0),P("PEX_RemoteAck",[{Tag:"PEX_RemoteAck",Target:String(r)}]);const s=ne(r)||String(r);v(x("editedYourPEX",{who:s}),8e3)}}catch(t){p("远程协议异常:",t.message)}})}function Oi(){ie(e=>{try{if(e?.Type!=="Hidden")return;const t=Array.isArray(e.Dictionary)?e.Dictionary:[],n=r=>{const i=t.find(o=>o?.Tag===r);if(i)return i.Value??i.Name;for(const o of t)if(o&&typeof o=="object"&&o.Tag&&r in o)return o[r]};if(e.Content==="PEX_PermReply"&&Number(n("Target"))===Player?.MemberNumber){const r=Number(e.Sender);if(W[r]={perms:n("Perms")||{},values:n("Values")||{},ts:Date.now()},O&&O.num===r){const i=O.C;O=null,H&&(clearTimeout(H),H=null);let o=!1;try{o=typeof CurrentScreen<"u"&&CurrentScreen==="InformationSheet"&&typeof InformationSheetSelection<"u"&&InformationSheetSelection&&Number(InformationSheetSelection.MemberNumber)===r}catch{}o&&Bn(i)}else if(y.open&&y.target?.MemberNumber===r){const i=W[r];y.perms=i.perms,y.values=i.values;const o=document.getElementById(ve);o&&$n(o)}}else if(e.Content==="PEX_Access"&&Number(n("Target"))===Player?.MemberNumber){const r=n("Name")||(()=>{try{return ChatRoomCharacter?.find(i=>i.MemberNumber===Number(e.Sender))?.Nickname}catch{return null}})()||e.Sender;v(x("accessedYourPEX",{who:r}),8e3)}else e.Content==="PEX_RemoteAck"&&Number(n("Target"))===Player?.MemberNumber&&v("对方已应用你的设置修改。",6e3)}catch{}})}function $i(){const e=U();e&&(Li(),Oi(),e.hookFunction("InformationSheetRun",5,(t,n)=>{const r=n(t);try{const i=rn();y.open&&y.target&&i&&i.MemberNumber!==y.target.MemberNumber&&ht();const o=i&&i.MemberNumber!==Player?.MemberNumber?yt(i):null;if(!o)return r;On(i.MemberNumber);const s=Ti(i,o),a=ki(s.perms),c=a?x("profileEditBtn"):o.edit?x("profileEditNoPerm"):x("profileEditOff");DrawButton(L.x,L.y,L.w,L.h,"REX","White","",c,!a)}catch{}return r}),e.hookFunction("InformationSheetClick",5,(t,n)=>{try{const r=rn();if((r&&r.MemberNumber!==Player?.MemberNumber?yt(r):null)&&MouseIn(L.x,L.y,L.w,L.h)){Ri(r);return}}catch{}return n(t)}),e.hookFunction("InformationSheetExit",5,(t,n)=>(y.open&&ht(),n(t))))}function Bi(e=3e4){const t=Date.now();return new Promise(n=>{const r=()=>{typeof bcModSdk<"u"&&bcModSdk?.registerMod?n(!0):Date.now()-t>e?n(!1):setTimeout(r,100)};r()})}function Xi(e=3e4){const t=Date.now();return new Promise(n=>{const r=()=>{try{typeof Player<"u"&&typeof CharacterSetFacialExpression=="function"&&typeof ChatRoomCharacter<"u"?n(!0):Date.now()-t>e?n(!1):setTimeout(r,100)}catch{setTimeout(r,100)}};r()})}function Fi(){return new Promise(e=>{const t=()=>{try{typeof ServerIsLoggedIn=="function"&&ServerIsLoggedIn()||typeof Player<"u"&&Player&&typeof Player.MemberNumber=="number"&&Player.MemberNumber>0&&!!Player.AccountName?e(!0):setTimeout(t,200)}catch{setTimeout(t,200)}};t()})}async function Gi(){p(`初始化 v${N}...`);const e=await Bi();if(!await Xi()){Oe("游戏加载超时，放弃初始化");return}if(await Yn(),await Fi(),await tr(),cn(),Or(),ge(!0),e)try{Un(bcModSdk.registerMod({name:"Personality Excretion (PEX)",fullName:"Personality Excretion",version:N}))}catch(o){Oe("registerMod 失败，进入兼容模式:",o.message)}const n=U();n&&(ot(n),an(n),lr(n),ii(()=>{Zr(),setTimeout(()=>{try{ge(!0)}catch{}},800),setTimeout(()=>{try{f.mode!==m.IDLE&&f.phaseEndsAt>0&&(p("进房还原状态:",f.mode),T({mode:f.mode,remainingSec:Math.max(0,Math.round((f.phaseEndsAt-Date.now())/1e3)),owner:f.ownerMemberNumber,gelId:f.gelId},!0))}catch{}},1500)},()=>{}),oi(()=>{try{vi()}catch{}try{ot&&Vi()}catch{}})),ei(),bi(),Pi(),Ni(),$i();try{typeof window<"u"&&!window._pexUnloadFlush&&(window._pexUnloadFlush=()=>{try{typeof ServerAccountUpdate?.SyncToServer=="function"&&ServerAccountUpdate.SyncToServer()}catch{}},window.addEventListener("pagehide",window._pexUnloadFlush),window.addEventListener("beforeunload",window._pexUnloadFlush))}catch{}p(`初始化完成 v${N}`);let r=!1;const i=setInterval(()=>{try{if(typeof CurrentScreen>"u"||CurrentScreen!=="ChatRoom"||(clearInterval(i),r))return;r=!0,setTimeout(()=>v(x("loaded",{v:N})),1e3)}catch{clearInterval(i)}},500)}function Vi(){ri(()=>Promise.resolve().then(()=>Zn),void 0,import.meta.url).then(e=>e.clearMessageHandlers()).catch(()=>{})}const Ki="https://cdn.jsdelivr.net/gh/Nice8923/BC-PEX@main/Images/",Hi="https://raw.githubusercontent.com/Nice8923/BC-PEX/main/Images/";function Xn(e){return Ki+String(e).replace(/^\//,"")}function Fn(e){return Hi+String(e).replace(/^\//,"")}function ji(e,t){const n=new Image;n.crossOrigin="anonymous";let r=0;return n.addEventListener("load",()=>{try{t&&t(n)}catch{}}),n.addEventListener("error",()=>{r===0?(r=1,Oe("图片 CDN 加载失败，回退 raw:",e),n.src=Fn(e)):Oe("图片加载失败:",e)}),n.src=Xn(e),n}function zi(e,t,n,r,i){const o=Math.max(1,e||1),s=Math.max(1,t||1),a=Math.max(0,n||0);return{sx:a%o*r,sy:Math.floor(a/o)%s*i,sw:r,sh:i}}window.PEX=window.PEX??{};const Wi=window.PEX&&typeof window.PEX=="object"&&!!window.PEX.version;Wi?console.warn(`⚗️[PEX] 检测到已有实例在运行（version: ${window.PEX.version}），跳过重复初始化。`):(window.PEX={version:N,command:(e="")=>Ct(`/pex ${e}`.trim()),reset:()=>We(),status:()=>fn(),getConfig:()=>l,save:()=>_(!0),reload:()=>cn(),setAnimDurationOverride:Rr,images:{imageUrl:Xn,imageFallbackUrl:Fn,loadPexImage:ji,spriteFrame:zi},exportSettings:un,importSettings:dn},Gi());
';
+    const CODE = 'const N="0.1.34";const gt="PEX_Settings",Kn=["人格药水","人格药剂","persona potion","personality extraction"],Hn=["凝胶药剂","凝胶药水","plain gel","normal gel"],jn=[{Eyebrows:"Soft",Eyes:"VeryLewd",Mouth:"Frown",Blush:"High"},{Eyebrows:"Lowered",Eyes:"HeartPink",Mouth:"Moan",Blush:"High"}],zn={Eyebrows:"Raised",Eyes:"LewdHeartPink",Mouth:"Ahegao",Blush:"VeryHigh"},Wn={Eyebrows:"Lowered",Eyes:"Dazed",Mouth:"Frown",Blush:"VeryHigh"},Un={Eyebrows:"Lowered",Eyes:"Lewd",Mouth:"Open",Blush:"Medium"},Yn="https://cdn.jsdelivr.net/gh/Nice8923/BC-PEX@main/Sound/",F=e=>Yn+e,Ue={wait:[F("wait_1.mp3"),F("wait_2.mp3"),F("wait_3.mp3"),F("wait_4.mp3"),F("wait_5.mp3")],excrete:[F("excrete.mp3")],feed:[F("feed.mp3")]};function R(){return{enabled:!0,keywords:[...Kn],normalKeywords:[...Hn],waitSeconds:50,blockedWaitMinutes:15,autoRevertEnabled:!0,autoRevertMinutes:15,gelExpireMode:"vanish",normalExpressionSeconds:5,effectLevel:3,viewMode:"surround",blindLevel:2,timerVisibility:"all",fxDizzy:!0,fxBlank:!0,fxBlur:!0,fxShake:!0,restrictions:!0,seeRemoteAnims:!0,hearRemoteSounds:!1,expressions:{wait:jn.map(e=>({...e})),excrete:{...zn},blank:{...Wn}},normalExpression:{...Un},gelLayer:24,sounds:{wait:Ue.wait.map(e=>e),excrete:Ue.excrete.map(e=>e),feed:Ue.feed.map(e=>e)},soundOn:{wait:!0,excrete:!0,feed:!0},editModes:{time:"off",autoRevert:"off",timerVisibility:"off"},whitelist:[]}}let l=R();function Ge(e){l=e}let sn=null;function qn(e){sn=e}function U(){return sn}const $t={zh:{loaded:"⚗️ PEX v{v} 已加载。输入 /pex help 查看指令。",help:["⚗️ PEX v{v} 指令：","/pex help     — 本帮助","/pex howto    — 玩法说明","/pex show     — 打开/关闭游戏内控制台面板","/pex status   — 查看当前状态","/pex reset    — 强制恢复（清除等待/失神/凝胶状态）","/pex settings — 打开设置页","/pex save     — 立即保存设置","调试：按 F12 或 Ctrl+Shift+I 打开浏览器控制台，","把 ⚗️[PEX] 开头的报错信息发给作者。"].join(`
`),cmdUnknown:"未知指令：/pex {sub}（/pex help 查看帮助）",howto:["⚗️ PEX 玩法说明：",'1. 制作一瓶饮料（游戏自带道具），在制作名/描述写触发关键词（如"人格药水"）。',"2. 喝下或注射带关键词的饮料 → 一阵阵越来越晕。","3. 到排出时刻检查臀部装备位：没东西就排出；","   有东西会等待（拿掉立刻排），超上限则药效消失。","4. 人格凝胶排出后失神（黑白/不能动/视野变窄/禁言），凝胶落在脚边。",'5. 点击失神者 → 对话框"捡起凝胶"（手要空）。',"6. 把凝胶交还原主人，主人喝下自己的凝胶 → 恢复；","   默认15分钟没喂回自动恢复，凝胶消散（可关闭）。","7. 普通凝胶（另一套关键词）：无眩晕失神，只有短暂表情变化。",'8. 安全：/pex reset 或设置页"强制恢复"。',"更多：/pex settings 里有完整玩法说明页。"].join(`
`),resetDone:"已强制恢复，所有状态已清除。",resetConfirm:"确定要强制恢复吗？此操作会立即清除全部 PEX 状态。",statusLine:"当前状态：{state}",stateIdle:"正常",stateWaiting:"等待排出（剩余 {sec} 秒）",stateBlocked:"臀部有物品遮挡，等待中（剩余 {min} 分 {sec} 秒）",stateExcreting:"排出中…",stateBlank:"失神中（剩余 {min} 分 {sec} 秒）",stateBlankNormal:"凝胶排出（剩余 {min} 分 {sec} 秒）",cantOpenSettings:"无法打开设置页（当前画面不支持）。",noChatBox:"找不到聊天框，请先进入聊天室再输入 /pex show。",gelExpired:"%NAME%的人格凝胶随时间消散了。",gelExpiredNormal:"%NAME%的普通凝胶随时间消散了。",gelInvalidated:"%NAME%的人格凝胶失去了效力，变成了无效凝胶…",gelInvalidatedNormal:"%NAME%的普通凝胶失去了效力，变成了无效凝胶…",profileEditBtn:"远程编辑对方 PEX 设置",profileEditNoPerm:"不在对方白名单，无法编辑",profileEditOff:"对方不允许远程修改",accessedYourPEX:"{who} 查看了你的 PEX 设置",editedYourPEX:"{who} 修改了你的 PEX 设置",remoteEditLoading:"正在获取 {name} 的 PEX 设置…",remoteEditLoadFail:"获取失败：对方未安装 PEX 或未响应，可重试。"}};let rt="zh";async function Jn(){return rt="zh",rt}function x(e,t={}){let n=$t[rt]?.[e]??$t.zh[e]??e;for(const[r,i]of Object.entries(t))n=n.split(`{${r}}`).join(String(i));return n}const Bt=250,de=[],oe=new Map;let q=null,Ft=0;function Qn(e){const t=[];try{Player&&typeof Player.MemberNumber=="number"&&t.push({SourceCharacter:Player.MemberNumber})}catch{}return Array.isArray(e)?t.concat(e):t}function it(){if(q=null,!de.length)return;const e=Date.now(),t=Math.max(0,Bt-(e-Ft));if(t>0){q=setTimeout(it,t);return}const n=de.shift();try{typeof ServerSend=="function"&&ServerSend("ChatRoomChat",n.payload)}catch{}Ft=Date.now(),de.length&&!q&&(q=setTimeout(it,Bt))}function P(e,t,n={}){const{dedupeKey:r=null,dedupeMs:i=800,priority:o=!1}=n;if(r){const c=Date.now(),u=oe.get(r);if(u&&c-u<i)return!1;if(oe.set(r,c),oe.size>200)for(const[d,h]of oe)c-h>6e4&&oe.delete(d)}const a={payload:{Type:"Hidden",Content:e,Dictionary:Qn(t)}};return o?de.unshift(a):de.push(a),q||(q=setTimeout(it,0)),!0}function b(e,t){try{const n=Zn(e);if(!n)return;const r={Type:"Action",Content:n};t!=null&&(r.Target=t),typeof ServerSend=="function"&&ServerSend("ChatRoomChat",r),setTimeout(()=>{try{const i=document.getElementById("TextAreaChatLog");i&&(i.scrollTop=i.scrollHeight)}catch{}},60)}catch{}}function Zn(e){let t="";try{t=CharacterNickname(Player)||""}catch{}return String(e).split("%NAME%").join(t).split("%POSSESSIVE%").join("自己的").split("%OPP_NAME%").join("对方").split("%OPP_POSSESSIVE%").join("对方的").split("%PRONOUN%").join("自己").split("%INTENSIVE%").join("自己")}const xt=[];function ie(e){typeof e=="function"&&xt.push(e)}function ln(e){if(e)try{e.hookFunction("TextQueryMultiple",0,(t,n)=>{const r=t&&t[0],i=n(t);return typeof i=="string"&&i.indexOf("MISSING TEXT IN")>=0&&typeof r=="string"?r:i})}catch{}}function ot(e){if(e)try{e.hookFunction("ChatRoomMessage",1,(t,n)=>{const r=n(t);try{const i=t[0];if(!i||typeof i!="object")return r;for(const o of xt)try{o(i)}catch{}}catch{}return r})}catch(t){console.warn("⚗️[PEX] ChatRoomMessage 挂钩失败:",t.message)}}function er(){xt.length=0}const tr=Object.freeze(Object.defineProperty({__proto__:null,clearMessageHandlers:er,pexOnMessage:ie,pexSendAction:b,pexSendHidden:P,registerMessageHook:ot,registerTextQueryHook:ln},Symbol.toStringTag,{value:"Module"}));function bt(e,t){if(Array.isArray(e))return Array.isArray(t)?t:e;if(e&&typeof e=="object"){const n={};for(const r of Object.keys(e))n[r]=t&&r in t?bt(e[r],t[r]):e[r];return n}return t===void 0?e:t}function vt(){const e=l;return{v:1,enabled:e.enabled,keywords:e.keywords,normalKeywords:e.normalKeywords,waitSeconds:e.waitSeconds,blockedWaitMinutes:e.blockedWaitMinutes,autoRevertEnabled:e.autoRevertEnabled,autoRevertMinutes:e.autoRevertMinutes,gelExpireMode:e.gelExpireMode,normalExpressionSeconds:e.normalExpressionSeconds,effectLevel:e.effectLevel,viewMode:e.viewMode,blindLevel:e.blindLevel,timerVisibility:e.timerVisibility,fxDizzy:e.fxDizzy,fxBlank:e.fxBlank,fxBlur:e.fxBlur,fxShake:e.fxShake,restrictions:e.restrictions,seeRemoteAnims:e.seeRemoteAnims,expressions:e.expressions,normalExpression:e.normalExpression,gelLayer:e.gelLayer,editModes:e.editModes,whitelist:e.whitelist}}const cn="PEX_sounds";function un(){try{const e=localStorage.getItem(cn),t=R().sounds;if(e){const n=JSON.parse(e),r=n&&typeof n=="object"&&!Array.isArray(n)&&"sounds"in n?n.sounds:n,i=Array.isArray(r?.drink)?r.drink:[],o={wait:[],excrete:[],feed:[]};for(const s of["wait","excrete","feed"]){const a=r?.[s];o[s]=Array.isArray(a)&&a.length>0?a.slice():t[s].slice()}i.length&&(o.wait=i.concat(o.wait)),l.sounds=o,n&&typeof n.soundOn=="object"&&n.soundOn&&(l.soundOn=Object.assign({},R().soundOn,n.soundOn))}else l.sounds={wait:t.wait.slice(),excrete:t.excrete.slice(),feed:t.feed.slice()},l.soundOn=R().soundOn}catch{}}function Re(){try{localStorage.setItem(cn,JSON.stringify({sounds:l.sounds,soundOn:l.soundOn}))}catch{}}function De(){try{return"PEX_settings_backup_"+(Player?.MemberNumber||Player?.AccountName||"anon")}catch{return"PEX_settings_backup_anon"}}let Le=!1;function at(e){try{if(!e)return null;const t=LZString.decompressFromBase64(e);return t?JSON.parse(t):null}catch{return null}}function nr(e){Ge(bt(R(),e))}function rr(e=15e3){const t=Date.now();return new Promise(n=>{const r=()=>{try{Player&&Player.ExtensionSettings!==void 0?n(!0):Date.now()-t>e?n(!1):setTimeout(r,200)}catch{n(!1)}};r()})}function dn(){let e=null,t=null;try{e=Player?.ExtensionSettings?.["PEX"]??null}catch{}try{t=localStorage.getItem(De())}catch{}const n=at(e),r=at(t),i=n&&+n.ts||0,o=r&&+r.ts||0;let s=null,a=null,c=!1;n&&i>=o?(s=n,a=e):r?(s=r,a=t,c=i<o):n&&(s=n,a=e);let u=!1;if(s)try{nr(s),u=!0}catch(d){ir(d)}if(u||Ge(R()),l.timerVisibility==="both"&&(l.timerVisibility="all"),Array.isArray(l.expressions)){const d=l.expressions,h=R().expressions;l.expressions={wait:[d[0],d[1]].filter(Boolean).map(A=>({...A})),excrete:d[2]?{...d[2]}:h.excrete,blank:d[3]||d[0]?{...d[3]||d[0]}:h.blank}}if(Le=!0,un(),u&&a){try{localStorage.setItem(De(),a)}catch{}if(c)try{Player.ExtensionSettings||(Player.ExtensionSettings={}),Player.ExtensionSettings.PEX=a,typeof ServerPlayerExtensionSettingsSync=="function"&&ServerPlayerExtensionSettingsSync("PEX"),console.log("⚗️[PEX] 账号数据落后/丢失，已从本地备份还原并补回账号")}catch{}}}let I=null;function Ye(){try{if(I&&(clearTimeout(I),I=null),Le&&Player){Player.ExtensionSettings||(Player.ExtensionSettings={});const e=vt();e.ts=Date.now();const t=JSON.stringify(e),n=LZString.compressToBase64(t);Player.ExtensionSettings.PEX=n;try{localStorage.setItem(De(),n)}catch{}Re();try{typeof ServerPlayerExtensionSettingsSync=="function"&&ServerPlayerExtensionSettingsSync("PEX")}catch{}try{typeof ServerSendQueueProcess=="function"&&ServerSendQueueProcess()}catch{}}}catch{}}typeof window<"u"&&!window._pexSaveFlush&&(window._pexSaveFlush=Ye,window.addEventListener("pagehide",Ye),window.addEventListener("beforeunload",Ye));function _(e=!1){if(!Le)return;const t=()=>{try{if(!Le||!Player)return;Player.ExtensionSettings||(Player.ExtensionSettings={});const n=vt();n.ts=Date.now();const r=JSON.stringify(n),i=LZString.compressToBase64(r),o=at(i);if(!o||typeof o!="object"){console.warn("⚗️[PEX] 存档校验失败，跳过本次写入");return}i.length>ES_BUDGET&&console.warn("⚗️[PEX] 设置过大（"+i.length+" 字节 > "+ES_BUDGET+"），服务器可能拒收：请减少表情/关键词/音效"),Player.ExtensionSettings.PEX=i,typeof ServerPlayerExtensionSettingsSync=="function"&&ServerPlayerExtensionSettingsSync("PEX");try{localStorage.setItem(De(),i)}catch{}Re()}catch(n){console.warn("⚗️[PEX] 保存失败:",n.message)}};if(e){I&&(clearTimeout(I),I=null),t();return}I&&clearTimeout(I),I=setTimeout(()=>{I=null,t()},600)}let X=null,Xt="";function T(e,t=!1){try{if(!Player||!Player.OnlineSharedSettings)return;Player.OnlineSharedSettings.PEX||(Player.OnlineSharedSettings.PEX={});const n=JSON.stringify(e);if(n===Xt&&!t)return;Xt=n;const r=()=>{const i=Object.assign({},e);i.timerVisibility===void 0&&(i.timerVisibility=l.timerVisibility||"both"),Player.OnlineSharedSettings.PEX.state=i,typeof ServerAccountUpdate?.QueueData=="function"&&ServerAccountUpdate.QueueData({OnlineSharedSettings:Player.OnlineSharedSettings},!0);try{P("PEX_StateSync",[{Tag:"Payload",Value:JSON.stringify(i)}],{dedupeKey:"state:"+(e?.mode||"")+":"+(e?.remainingSec||0)+":"+(e?.gelHolder??""),dedupeMs:4e3})}catch{}};t?(X&&(clearTimeout(X),X=null),r()):(X&&clearTimeout(X),X=setTimeout(()=>{X=null,r()},1e3))}catch{}}let G=null;function ge(e=!1){const t=()=>{try{if(!Player||!Player.OnlineSharedSettings)return;const n=l.editModes||{},r=a=>a==="any"||a==="whitelist",o=["time","autoRevert","timerVisibility"].some(a=>r(n[a])),s=Player.OnlineSharedSettings.PEX?.state;Player.OnlineSharedSettings.PEX={v:N,state:s||null,edit:o,editModes:{time:n.time||"off",autoRevert:n.autoRevert||"off",timerVisibility:n.timerVisibility||"off"},wl:Array.from(l.whitelist||[])},typeof ServerAccountUpdate?.QueueData=="function"&&ServerAccountUpdate.QueueData({OnlineSharedSettings:Player.OnlineSharedSettings},!0);try{P("PEX_SharedSync",[{Tag:"Payload",Value:JSON.stringify({edit:o,editModes:{time:n.time||"off",autoRevert:n.autoRevert||"off",timerVisibility:n.timerVisibility||"off"},wl:Array.from(l.whitelist||[])})}],{dedupeKey:"shared",dedupeMs:3e3})}catch{}}catch{}};if(e){G&&(clearTimeout(G),G=null),t();return}G&&clearTimeout(G),G=setTimeout(()=>{G=null,t()},2e3)}function fn(){try{const e={plugin:"PEX",v:N,pex:vt()},t=new Blob([JSON.stringify(e,null,2)],{type:"application/json"}),n=URL.createObjectURL(t),r=document.createElement("a");r.href=n,r.download="PEX-settings.json",document.body.appendChild(r),r.click(),r.remove(),setTimeout(()=>URL.revokeObjectURL(n),1e3)}catch(e){console.warn("⚗️[PEX] 导出失败:",e.message)}}function pn(){const e=document.createElement("input");e.type="file",e.accept="application/json,.json",e.onchange=()=>{const t=e.files&&e.files[0];if(!t)return;const n=new FileReader;n.onload=()=>{try{const r=JSON.parse(String(n.result)),i=r.pex||r;Ge(bt(R(),i)),_(!0),ge(!0),console.log("⚗️[PEX] 设置导入完成")}catch(r){console.warn("⚗️[PEX] 导入失败:",r.message)}},n.readAsText(t)},e.click()}function ir(e){try{console.warn("⚗️[PEX] 设置应用失败:",e.message)}catch{}}const m={IDLE:"idle",WAITING:"waiting",BLOCKED:"blocked",EXCRETING:"excreting",BLANK:"blank"},f={mode:m.IDLE,gelType:"persona",phaseStartedAt:0,phaseEndsAt:0,ownerMemberNumber:null,gelId:null,gelHolder:null};function C(e,t={}){f.mode=e,f.phaseStartedAt=Date.now(),f.phaseEndsAt=t.endsAt??0,t.ownerMemberNumber!==void 0&&(f.ownerMemberNumber=t.ownerMemberNumber),t.gelId!==void 0&&(f.gelId=t.gelId),t.gelHolder!==void 0&&(f.gelHolder=t.gelHolder),t.gelType!==void 0&&(f.gelType=t.gelType)}function mn(){const e=f;switch(e.mode){case m.IDLE:return x("stateIdle");case m.WAITING:{const t=Math.max(0,Math.round((e.phaseEndsAt-Date.now())/1e3));return x("stateWaiting",{sec:t})}case m.BLOCKED:{const t=Math.max(0,Math.round((e.phaseEndsAt-Date.now())/1e3));return x("stateBlocked",{min:Math.floor(t/60),sec:t%60})}case m.EXCRETING:return x("stateExcreting");case m.BLANK:{const t=Math.max(0,Math.round((e.phaseEndsAt-Date.now())/1e3));return e.gelType==="normal"?x("stateBlankNormal",{min:Math.floor(t/60),sec:t%60}):x("stateBlank",{min:Math.floor(t/60),sec:t%60})}default:return x("stateIdle")}}const ce=[],Gt=40;function yn(e){try{const t=new Date,n=i=>String(i).padStart(2,"0"),r="["+n(t.getHours())+":"+n(t.getMinutes())+":"+n(t.getSeconds())+"] "+e.map(i=>typeof i=="string"?i:or(i)).join(" ");ce.push(r),ce.length>Gt&&ce.splice(0,ce.length-Gt)}catch{}}function or(e){try{return JSON.stringify(e)}catch{return String(e)}}function p(...e){yn(e),console.log("⚗️[PEX]",...e)}function Oe(...e){yn(e),console.warn("⚗️[PEX]",...e)}function Vt(e,t){return!e||!t?!1:String(e).toLowerCase().includes(String(t).toLowerCase())}function ne(e,t=""){try{return CharacterNickname(e)}catch{return t}}function ar(e){if(!e||typeof e!="string")return"";if(!e.startsWith("\0"))return e;try{return Array.from(e.slice(1,200)).flatMap(t=>{const n=t.charCodeAt(0),r=Math.floor(n/256),i=n-r*256;return[r,i].filter(Boolean).map(o=>String.fromCharCode(o))}).join("")}catch{return""}}function st(e){if(!e)return"";const t=[];try{typeof e.Craft?.Name=="string"&&t.push(e.Craft.Name),typeof e.Craft?.Description=="string"&&t.push(ar(e.Craft.Description)),typeof e.Description=="string"&&t.push(e.Description),typeof e.Name=="string"&&t.push(e.Name),typeof e.Asset?.Name=="string"&&t.push(e.Asset.Name),typeof e.Asset?.Description=="string"&&t.push(e.Asset.Description)}catch{}return t.filter(Boolean).join(" ")}let ae=null;const Kt=new Map;function hn(){try{if(!ae){const e=window.AudioContext||window.webkitAudioContext;if(!e)return null;ae=new e}if(ae.state==="suspended")try{ae.resume()}catch{}return ae}catch{return null}}function sr(e){try{const t=String(e).match(/^https:\/\/cdn\.jsdelivr\.net\/gh\/([^/]+)\/([^@]+)@([^/]+)\/(.+)$/);return t?"https://raw.githubusercontent.com/"+t[1]+"/"+t[2]+"/"+t[3]+"/"+t[4]:null}catch{return null}}function Ht(e,t){try{const n=hn();if(!n||!e)return!1;const r=n.createBufferSource();r.buffer=e;const i=n.createGain();return i.gain.value=Math.max(0,Math.min(1,t||1)),r.connect(i),i.connect(n.destination),r.start(),!0}catch{return!1}}function Et(e,t=1){try{if(!e)return;const n=hn();if(!n){typeof AudioPlaySoundEffect=="function"&&AudioPlaySoundEffect(String(e));return}const r=String(e),i=Kt.get(r);if(i){Ht(i,t);return}const o=[r,sr(r)].filter(Boolean);let s=0;const a=()=>{if(s>=o.length)return;const c=o[s++];fetch(c).then(u=>{if(!u.ok)throw new Error("HTTP "+u.status);return u.arrayBuffer()}).then(u=>n.decodeAudioData(u)).then(u=>{Kt.set(r,u),Ht(u,t)}).catch(()=>a())};a()}catch{}}function gn(){return .55+Math.max(1,Math.min(5,l?.effectLevel||3))*.09}function xn(e){try{if(l?.soundOn&&l.soundOn[e]===!1)return null;const t=l?.sounds?.[e];if(!Array.isArray(t)||t.length===0)return null;const n=t[Math.floor(Math.random()*t.length)];return n&&Et(String(n),gn()),n||null}catch{return null}}function Pe(e){try{if(e==null)return null;if(Player&&Player.MemberNumber===e)return Player;if(typeof ChatRoomCharacter<"u"&&Array.isArray(ChatRoomCharacter))return ChatRoomCharacter.find(t=>t&&t.MemberNumber===e)||null}catch{}return null}let $e=0,St=0;function B(e){$e=Math.max(0,e||0)}function bn(){$e=0}function wt(e){St=Math.max(0,Math.min(3,e||0))}function vn(){St=0}function lr(){if($e<=0)return 0;try{if(Player?.GraphicsSettings?.AllowBlur===!1)return 0}catch{}return $e}function cr(){return St}function ur(e){if(e)try{e.hookFunction("Player.GetBlurLevel",4,(t,n)=>{let r=0;try{r=n(t)||0}catch{}const i=lr();return i>r?i:r}),e.hookFunction("Player.GetBlindLevel",4,(t,n)=>{let r=0;try{r=n(t)||0}catch{}const i=cr();return i>r?i:r})}catch(t){console.warn("⚗️[PEX] GetBlurLevel 挂钩失败:",t.message)}}const qe="pex-overlay";let j=null,fe=null,xe=!1,jt=3,w=null,zt=!1;function Y(){return document.getElementById("MainCanvas")||document.querySelector("canvas")}function Pt(){if(j&&document.getElementById(qe))return j;let e=document.getElementById(qe);return e||(e=document.createElement("div"),e.id=qe,Object.assign(e.style,{position:"fixed",left:"0",top:"0",width:"100%",height:"100%",pointerEvents:"none",zIndex:"99998",overflow:"hidden"}),document.body.appendChild(e)),j=e,e}function En(){if(!zt){zt=!0;try{const e=document.createElement("style");e.id="pex-anim-styles",e.textContent="@keyframes pexDizzyFlash{0%,100%{opacity:0.04}30%{opacity:0.16}60%{opacity:0.24}85%{opacity:0.10}}@keyframes pexDizzyPulse{0%,100%{opacity:0.25}40%{opacity:0.85}70%{opacity:0.35}}",document.head.appendChild(e)}catch{}}}function Sn(e,t=3){z(),jt=Math.max(1,Math.min(5,t||3)),xe=!0,En();const n=Pt(),r=document.createElement("div");r.style.cssText="position:fixed;inset:0;pointer-events:none;background:radial-gradient(circle at 50% 50%, transparent 42%, rgba(242,123,168,0.55));animation:pexDizzyFlash 1400ms ease-in-out infinite;",n.appendChild(r);const i=document.createElement("div");i.style.cssText="position:fixed;inset:0;pointer-events:none;background:radial-gradient(ellipse at 50% 50%, transparent 35%, rgba(15,8,28,0.42) 100%);animation:pexDizzyPulse 1400ms ease-in-out infinite;",n.appendChild(i);const o=1400,s=800,a=Math.max(2,Math.round(e/o));let c=0,u=0;const d=h=>{if(xe){if(h-u>=100){u=h;const A=h%o/o,k=Math.min(1,c/Math.max(1,a-1)),D=h%o<s?Math.sin(A/(s/o)*Math.PI):0;B(D>.02?1+2.2*k*(jt/3)*D:.3),A<.05&&c<a&&c++}fe=requestAnimationFrame(d)}};fe=requestAnimationFrame(d)}function dr(e=1500){if(!xe)return;const t=performance.now();let n=0;const r=i=>{if(!xe)return;const o=Math.min(1,(i-t)/e);i-n>=100&&(n=i,B(.4*(1-o))),o<1?requestAnimationFrame(r):z()};requestAnimationFrame(r)}function z(){xe=!1,fe&&(cancelAnimationFrame(fe),fe=null),B(0);const e=Y();if(e){e.style.transition="",e.style.transform="";const t=e.style.filter||"";e.style.filter=t.replace(/blur\([^)]*\)/g,"").trim()}j&&(j.innerHTML="")}let pe=null,_e=!1;function fr(e,t=3,n=!0,r=!0){if(re(),!n&&!r)return;if(_e=!0,En(),n){const a=Pt(),c=document.createElement("div");c.style.cssText="position:fixed;inset:0;pointer-events:none;background:radial-gradient(circle at 50% 50%, transparent 40%, rgba(242,123,168,0.62));animation:pexDizzyFlash 900ms ease-in-out infinite;",a.appendChild(c)}r&&B(3+(t||3)*.8);const i=Y(),o=3+(t||3)*1.2,s=()=>{if(_e){if(i&&n){const a=(Math.random()-.5)*o*2,c=(Math.random()-.5)*o*2;i.style.transform=`translate(${a.toFixed(1)}px, ${c.toFixed(1)}px)`}pe=requestAnimationFrame(s)}};pe=requestAnimationFrame(s),setTimeout(()=>{_e&&re()},Math.max(500,e))}function re(){_e=!1,pe&&(cancelAnimationFrame(pe),pe=null);const e=Y();e&&(e.style.transform=""),j&&(j.innerHTML="")}let Ve=!1;function Mt(e="surround"){Ve=!0;const t=Y();if(t){const r=t.style.filter||"";r.includes("grayscale")||(t.style.filter=(r?r+" ":"")+"grayscale(1)")}const n=Pt();if(w&&w.remove(),e!=="all"){if(w=document.createElement("div"),w.style.cssText="position:fixed;inset:0;pointer-events:none;z-index:99997;",e==="surround"){const i=.3+.13*(Math.max(1,Math.min(5,l.effectLevel||3))-1);w.style.background=`radial-gradient(ellipse at 50% 55%, transparent 0%, transparent 28%, rgba(5,5,10,${i.toFixed(2)}) 55%, rgba(5,5,10,${Math.min(.95,i+.27).toFixed(2)}) 100%)`}else w.style.background="radial-gradient(ellipse at 50% 60%, transparent 0%, transparent 10%, rgba(5,5,10,0.7) 30%, rgba(5,5,10,0.94) 100%)";n.appendChild(w)}}function pr(){if(Ve)try{const e=Y();if(!e)return;const t=e.style.filter||"";t.includes("grayscale")||(e.style.filter=(t?t+" ":"")+"grayscale(1)")}catch{}}function mr(){Ve=!1;const e=Y();if(e){const t=e.style.filter||"";e.style.filter=t.replace(/grayscale\(1\)/g,"").replace(/\s+/g," ").trim()}w&&(w.remove(),w=null)}function yr(e=800,t){Ve=!1;const n=Math.max(1,e||800);try{const r=Y();if(r){const i=r.style.filter||"";i.includes("grayscale")&&(r.style.transition="filter "+n+"ms ease",r.style.filter=i.replace(/grayscale\(1\)/g,"").replace(/\s+/g," ").trim(),setTimeout(()=>{try{r.style.transition=""}catch{}},n+50))}}catch{}try{if(w){w.style.transition="opacity "+n+"ms ease",w.style.opacity="0";const r=w;setTimeout(()=>{try{r.remove()}catch{}},n+50),w=null}}catch{}setTimeout(()=>{try{t&&t()}catch{}},n)}function hr(){z(),re(),mr(),bn()}let me=null,ye=null,Ne=null,ke=null,wn=!1;function Pn(){try{if(typeof WardrobeGetExpression=="function")return WardrobeGetExpression(Player)||null}catch{}return null}function gr(e){const t=e.Eyes??null,n=e.Eyes2!==void 0?e.Eyes2:t;return{Eyebrows:e.Eyebrows??null,Eyes:t,Eyes2:n,Mouth:e.Mouth??null,Blush:e.Blush??null,右眼_Luzi:t,左眼_Luzi:n}}const xr=["Eyes","Eyes2","Emoticon"];function At(e,t){try{if(!Player?.Appearance)return;const n=[];for(const[r,i]of Object.entries(e))try{if(i==null)continue;const o=Player.Appearance.find(a=>a.Asset.Group.Name===r);if(!o)continue;const s=o.Asset?.Group?.AllowExpression;if(Array.isArray(s)&&!s.includes(i)||(o.Property||(o.Property={}),o.Property.Expression===i))continue;o.Property.Expression=i,n.push(r)}catch{}if(!n.length)return;try{typeof CharacterRefresh=="function"&&CharacterRefresh(Player,!1,!1)}catch{}if(t){for(const r of n)if(xr.includes(r))try{typeof ChatRoomCharacterExpressionUpdate=="function"&&ChatRoomCharacterExpressionUpdate(Player,r)}catch{}}}catch{}}function lt(e){try{if(!e)return;me===null&&(me=Pn()),At(gr(e),!0)}catch{}}function _t(e=null){try{if(ye===null){const n=Pn();ye=n?.Eyes??null,Ne=n?.Eyes2??null,ke=n?.Emoticon??null}const t={};if(e)for(const[n,r]of Object.entries(e))r!=null&&(t[n]=r);t.Eyes="Dazed",t.Eyes2="Dazed",At(t,!0)}catch{}}function Ke(){try{const e={};if(ye!==null&&(e.Eyes=ye),Ne!==null&&(e.Eyes2=Ne),ke!==null&&(e.Emoticon=ke),me)for(const[t,n]of Object.entries(me))n!=null&&e[t]===void 0&&(e[t]=n);At(e,!0)}catch{}me=null,ye=null,Ne=null,ke=null}let K=!1,se=null;function He(e){K=!!e;try{K&&Player?(se===null&&(se=Player.BlinkFactor),Player.BlinkFactor=999999,typeof PoseRefresh=="function"&&PoseRefresh(Player)):!K&&Player&&(se!==null&&(Player.BlinkFactor=se,se=null),typeof PoseRefresh=="function"&&PoseRefresh(Player))}catch{}}let Ie=null;function br(e){try{const t=e?.OnlineSharedSettings?.["PEX"]?.state;if(t&&t.mode==="blank"&&t.type!=="normal")return Ie=e.BlinkFactor,e.BlinkFactor=999999,!0}catch{}return!1}function vr(e){if(Ie!==null){try{e.BlinkFactor=Ie}catch{}Ie=null}}function Er(e){if(!e)return;const t=n=>{try{e.hookFunction(n,4,(r,i)=>K?!1:i(r))}catch{}};t("Player.CanWalk"),t("Player.CanInteract"),t("Player.CanChangeOwnClothes"),t("Player.CanKneel");try{e.hookFunction("ActivityCheckPrerequisites",4,(n,r)=>{const[i,o]=n;return o&&typeof o.IsPlayer=="function"&&o.IsPlayer()&&K?!1:r(n)})}catch{}try{e.hookFunction("PoseRefresh",4,(n,r)=>{const i=r(n);try{const o=n&&n[0];o&&typeof o.IsPlayer=="function"&&o.IsPlayer()&&K&&(o.AllowedActivePoseMapping={BodyUpper:[],BodyLower:[],BodyFull:[]})}catch{}return i})}catch{}try{e.hookFunction("CharacterSetFacialExpression",4,(n,r)=>{const i=r(n);try{const o=n&&n[0];if(o&&typeof o.IsPlayer=="function"&&o.IsPlayer()&&K){const s=l.expressions||{};_t(s.blank||s.excrete)}}catch{}return i})}catch{}}const Wt=["%NAME%像个木头一样一动不动…","%NAME%身体僵在原地，毫无反应…","%NAME%双目无神，呆呆地杵在那里…","%NAME%仿佛被抽走了魂，一动不动…","%NAME%像坏掉的木偶一样僵住了…","%NAME%全身僵硬，连手指头都不动一下…"];function je(e){wn=!!e}function Sr(e){if(e)try{e.hookFunction("ChatRoomSendChat",5,(t,n)=>{if(!wn)return n(t);let r="";try{r=(document.getElementById("InputChat")||{}).value||""}catch{}const i=r.trim();if(!i||/^[/(*.]/.test(i))return n(t);try{if(typeof ChatRoomTargetMemberNumber=="number"&&ChatRoomTargetMemberNumber>=0)return n(t)}catch{}const o=document.getElementById("InputChat");if(o){o.value="";try{o.dispatchEvent(new InputEvent("input"))}catch{}}const s=Wt[Math.floor(Math.random()*Wt.length)];setTimeout(()=>{try{b(s)}catch{}},2e3)})}catch(t){console.warn("⚗️[PEX] 禁言挂钩失败:",t.message)}}let ct=[];function ze(){for(const e of ct)clearTimeout(e);ct=[]}function wr(e){return Math.max(1,Math.min(5,Math.floor((e||0)/10)))}function Pr(e,t){const n=[];for(let r=1;r<=t;r++)n.push(e*r/(t+1));return n}function Ut(e,t){if(!Array.isArray(e)||e.length===0)return[];const n=e.slice(),r=[];for(;r.length<t;){n.length||n.push(...e);const i=Math.floor(Math.random()*n.length);r.push(n.splice(i,1)[0])}return r}function Mr(e,t){if(ze(),!(t>0))return;const n=wr(t/1e3),r=Pr(t,n),i=Ut(l.sounds?.wait||[],n),o=Ut(l.expressions?.wait||[],n);!i.length&&!o.length||r.forEach((s,a)=>{ct.push(setTimeout(()=>{if(!e())return;const c=i[a];c&&l?.soundOn?.wait!==!1&&(Et(String(c)),Nt("wait",c));const u=o[a];u&&lt(u)},s))})}function Nt(e,t){if(!(!t||!l?.soundOn||l.soundOn[e]===!1))try{P("PEX_Sound",[{Tag:"Kind",Value:String(e)},{Tag:"Id",Value:String(t)}])}catch{}}function Ar(){ie(e=>{try{if(e?.Type!=="Hidden"||e.Content!=="PEX_Sound")return;const t=Number(e.Sender);if(!t||t===Player?.MemberNumber||!l.hearRemoteSounds)return;const r=(Array.isArray(e.Dictionary)?e.Dictionary:[]).find(i=>i?.Tag==="Id");r&&(r.Value??r.Name)&&Et(String(r.Value??r.Name),gn())}catch{}}),p("等待音效/表情系统已启用（段数随等待秒数，音效与表情同步）")}let $=0,M=null;const _r=800;function Mn(){try{return!!InventoryGet(Player,"ItemButt")}catch{return!1}}function ut(e){if(f.mode!==m.IDLE)if(f.mode===m.BLANK&&f.gelType==="normal")p("普通凝胶状态中再次喝下：清掉旧凝胶，重新开始"),ze(),M&&(clearTimeout(M),M=null),f.gelId&&Tt(f.gelId),C(m.IDLE);else return p("已有活动状态，忽略本次触发"),!1;$++;const t=$,n=Math.max(0,l.waitSeconds)*1e3;return C(m.WAITING,{gelType:e,endsAt:Date.now()+n}),n>0&&(l.fxDizzy&&Sn(n,l.effectLevel),Mr(()=>t===$,n)),T({mode:m.WAITING,type:e,remainingSec:Math.ceil(n/1e3),owner:Player?.MemberNumber},!0),b(e==="persona"?"%NAME%喝下了什么奇怪的东西，一阵异样的感觉涌了上来…":"%NAME%喝下了什么黏糊糊的东西…"),!0}function Nr(){if(Mn()){dr(1500),Ke();const e=Math.max(1,l.blockedWaitMinutes)*60*1e3;C(m.BLOCKED,{endsAt:Date.now()+e}),T({mode:m.BLOCKED,type:f.gelType,remainingSec:Math.ceil(e/1e3),owner:Player?.MemberNumber},!0),b("%NAME%的臀部被什么东西挡住了，凝胶堵在里面出不来…");return}An()}async function An(){if(f.mode===m.EXCRETING)return;const e=$;C(m.EXCRETING);const t=l.expressions||{};t.excrete&&lt(t.excrete),z(),(l.fxShake||l.fxBlur)&&fr(kt+300,l.effectLevel,l.fxShake,l.fxBlur);const n=xn("excrete");Nt("excrete",n);const r=Date.now();if(T({mode:m.EXCRETING,type:f.gelType,owner:Player?.MemberNumber,startedAt:r},!0),await $r(n),e!==$)return;if(f.gelType==="normal"){const s=l.autoRevertEnabled?Math.max(1,l.autoRevertMinutes)*60*1e3:0,a=qt(Player?.MemberNumber);re(),B(0),C(m.BLANK,{endsAt:s?Date.now()+s:0,gelId:a,gelHolder:null,gelType:"normal"}),lt(l.normalExpression),M&&clearTimeout(M),M=setTimeout(()=>{M=null,e===$&&Ke()},Math.max(1,l.normalExpressionSeconds)*1e3),T({mode:m.BLANK,type:"normal",remainingSec:s?Math.ceil(s/1e3):0,owner:Player?.MemberNumber,gelId:a,gelHolder:null,expiresAt:s?Date.now()+s:0},!0),b("%NAME%排出了一坨软趴趴的普通凝胶，落在脚边…");return}const i=l.autoRevertEnabled?Math.max(1,l.autoRevertMinutes)*60*1e3:0,o=qt(Player?.MemberNumber);re(),z(),l.fxBlur&&B(1.5+l.effectLevel*.5),wt(l.blindLevel),C(m.BLANK,{endsAt:i?Date.now()+i:0,gelId:o,gelHolder:null}),dt=l.viewMode,ft=l.effectLevel,pt=l.blindLevel,l.fxBlank&&Mt(l.viewMode),_t(t.blank||t.excrete),l.restrictions&&(je(!0),He(!0)),T({mode:m.BLANK,type:"persona",remainingSec:i?Math.ceil(i/1e3):0,owner:Player?.MemberNumber,gelId:o,gelHolder:null,expiresAt:i?Date.now()+i:0},!0),b("%NAME%的身体一阵脱力，瘫坐下来眼神空洞——人格凝胶被排了出来，落在脚边…")}function _n(e=!0){$++,ze(),M&&(clearTimeout(M),M=null),hr(),vn(),Ke(),je(!1),He(!1),C(m.IDLE),T(null,!0),e||b("%NAME%恢复了正常。")}function Be(e,t){$++,ze(),M&&(clearTimeout(M),M=null),z(),re(),bn(),vn(),Ke(),je(!1),He(!1),C(m.IDLE),T(null,!0),yr(_r,t),e&&b(e)}function kr(){p("自动回归触发");const e=f.gelType==="normal";if(f.gelId){if(l.gelExpireMode==="invalid"){Gr(f.gelId,Player?.MemberNumber),Be(x(e?"gelInvalidatedNormal":"gelInvalidated"));return}Tt(f.gelId)}Be(x(e?"gelExpiredNormal":"gelExpired"))}let dt=null,ft=null,pt=null;function Ir(e){const t=f;t.mode===m.WAITING?t.phaseEndsAt>0&&e>=t.phaseEndsAt&&Nr():t.mode===m.BLOCKED?Mn()?t.phaseEndsAt>0&&e>=t.phaseEndsAt&&(_n(),b("%NAME%好像什么也没发生。")):(b("%NAME%臀部的遮挡被拿开了，凝胶开始往外挤…"),An()):t.mode===m.BLANK&&(t.gelType!=="normal"&&(l.fxBlank&&dt!==l.viewMode&&(dt=l.viewMode,Mt(l.viewMode)),l.fxBlur&&ft!==l.effectLevel&&(ft=l.effectLevel,B(1.5+l.effectLevel*.5)),pt!==l.blindLevel&&(pt=l.blindLevel,wt(l.blindLevel))),l.autoRevertEnabled&&t.phaseEndsAt>0&&e>=t.phaseEndsAt&&kr())}function Tr(){try{Vr()}catch{}const e=f;if((e.mode===m.WAITING||e.mode===m.BLOCKED||e.mode===m.BLANK)&&(e.phaseEndsAt>0||e.mode===m.BLANK)){const t=e.phaseEndsAt>0?Math.max(0,Math.round((e.phaseEndsAt-Date.now())/1e3)):0,n=Math.ceil(t/5)*5;T({mode:e.mode,type:e.gelType,remainingSec:n,owner:e.ownerMemberNumber??Player?.MemberNumber,gelId:e.gelId,gelHolder:e.gelHolder,expiresAt:e.phaseEndsAt||0})}}const kt=7340;let mt=kt,be=0;const It=new Map;function Cr(e){return It.get(e)||0}function Rr(e){It.delete(e)}function Dr(){return be>0?be:mt}function Lr(e){be=e>0?e:0}function Nn(e){try{if(!e||e.MemberNumber==null)return;It.set(e.MemberNumber,Date.now())}catch{}}function Yt(e){return new Promise(t=>setTimeout(t,e))}function Or(e){return e?new Promise(t=>{try{const n=new Audio(String(e));let r=!1;const i=o=>{r||(r=!0,t(o))};n.addEventListener("loadedmetadata",()=>i(n.duration>0?n.duration*1e3:0)),n.addEventListener("error",()=>i(0)),setTimeout(()=>i(0),3e3)}catch{t(0)}}):Promise.resolve(0)}async function $r(e){if(Nn(Player),be>0){await Yt(be);return}const t=await Or(e);mt=Math.max(kt,t),await Yt(mt)}function Br(){try{const e=Player?.OnlineSharedSettings?.["PEX"]?.state;if(!e||typeof e!="object"||!e.mode)return;if(e.mode===m.BLANK){const t=e.type==="normal";if(C(m.BLANK,{endsAt:e.expiresAt||0,gelId:e.gelId||null,gelHolder:null,gelType:t?"normal":"persona"}),t){p("登录还原：普通凝胶状态（凝胶 "+(e.gelId||"无")+"）");return}z(),l.fxBlur&&B(1.5+l.effectLevel*.5),wt(l.blindLevel),l.fxBlank&&Mt(l.viewMode);const n=l.expressions||{};_t(n.blank||n.excrete),l.restrictions&&(je(!0),He(!0)),p("登录还原：失神状态（凝胶 "+(e.gelId||"无")+"）")}else if(e.mode===m.WAITING||e.mode===m.BLOCKED){const t=Math.max(1,e.remainingSec||30)*1e3;C(e.mode,{gelType:e.type||"persona",endsAt:Date.now()+t}),e.mode===m.WAITING&&Sn(t,l.effectLevel),p("登录还原："+e.mode+"（剩余 "+(e.remainingSec||"?")+" 秒）")}}catch(e){p("登录还原失败:",e.message)}}const Fr="GlassFilled",Fe="PEX|";function qt(e){return`${e}-${Date.now()}`}function Xr(e,t,n,r="persona"){try{if(typeof InventoryGet!="function"||typeof InventoryWear!="function"||InventoryGet(Player,"ItemHandheld"))return null;const s={Name:`${Tn(e)||"某人"}的${r==="normal"?"普通凝胶":"人格凝胶"}`,Description:`${Fe}${t}|${e}|${n}`,MemberNumber:e,Property:"Normal"},a=InventoryWear(Player,Fr,"ItemHandheld",void 0,void 0,e,s,!1);if(!a)return null;try{typeof ChatRoomCharacterUpdate=="function"&&ChatRoomCharacterUpdate(Player)}catch{}return p("凝胶物品已生成:",t),a}catch(i){return p("生成凝胶失败:",i.message),null}}function Ee(e){try{const t=e?.Craft?.Description??"";if(!t.startsWith(Fe))return null;const n=t.slice(Fe.length).split("|"),[r,i,o]=n;return{gelId:r,ownerMemberNumber:+i,expiresAt:+o,invalid:n[3]==="INVALID"}}catch{return null}}function kn(e){return!!Ee(e)}function Se(e){try{const t=InventoryGet(Player,"ItemHandheld"),n=Ee(t);if(n&&(!e||n.gelId===e)){InventoryRemove(Player,"ItemHandheld",!1);try{typeof ChatRoomCharacterUpdate=="function"&&ChatRoomCharacterUpdate(Player)}catch{}return p("凝胶已从手上移除:",n.gelId),!0}}catch{}return!1}function Jt(e,t,n){Se(n?.gelId),P("PEX_GelConsumed",[{Tag:"GelId",Value:String(n?.gelId??"")},{Tag:"Drinker",Value:String(t)},{Tag:"Owner",Value:String(n?.ownerMemberNumber)}])}function Tt(e){P("PEX_GelExpired",[{Tag:"GelId",Value:e}],{dedupeKey:"expire-"+e,dedupeMs:5e3})}function In(e,t){try{const n=InventoryGet(Player,"ItemHandheld"),r=Ee(n);if(!r||r.gelId!==e||r.invalid)return!1;const i=Tn(t)||"某人";n.Craft||(n.Craft={}),n.Craft.Name=`${i}的无效凝胶`,n.Craft.Description=`${Fe}${e}|${t}|${r.expiresAt}|INVALID`,n.Craft.Property="Normal";try{typeof ChatRoomCharacterUpdate=="function"&&ChatRoomCharacterUpdate(Player)}catch{}return p("凝胶已变为无效凝胶:",e),!0}catch(n){return p("无效化凝胶失败:",n.message),!1}}function Gr(e,t){P("PEX_GelInvalidated",[{Tag:"GelId",Value:String(e)},{Tag:"Owner",Value:String(t)}],{dedupeKey:"invalidate-"+e,dedupeMs:5e3})}function Vr(){try{const e=InventoryGet(Player,"ItemHandheld"),t=Ee(e);if(!t||!(t.expiresAt>0)||t.expiresAt>Date.now()||t.invalid)return;typeof l<"u"&&l.gelExpireMode==="invalid"?In(t.gelId,t.ownerMemberNumber):Se(t.gelId)}catch{}}function Kr(e){if(e)try{e.hookFunction("DrawCharacter",1,(t,n)=>{const[r,i,o,s]=t,a=!(l.gelLayer>=24);try{a&&r&&r.MemberNumber!=null&&typeof i=="number"&&typeof o=="number"&&Qt(r,i,o,s||1)}catch{}const c=r&&r.MemberNumber!=null?br(r):!1,u=n(t);c&&vr(r);try{!a&&r&&r.MemberNumber!=null&&typeof i=="number"&&typeof o=="number"&&Qt(r,i,o,s||1)}catch{}return u})}catch(t){p("凝胶底层绘制挂钩失败:",t.message)}}function Qt(e,t,n,r){try{const i=Cr(e.MemberNumber);if(i){const s=Dr()||7340,a=Date.now()-i;if(a>s){Rr(e.MemberNumber);return}if(typeof DrawRect!="function")return;const c=t+250*r,u=n+525*r,d=n+950*r,h=Math.min(1,a/s);h<.25?DrawRect(c-14*r,u-14*r,28*r,28*r,"#ffffff"):h<.5?DrawRect(c-14*r,u+(d-u)*.45-14*r,28*r,28*r,"#ffffff"):h<.75?(DrawRect(c-14*r,u+(d-u)*.82-14*r,28*r,28*r,"#ffffff"),DrawRect(c-18*r,d-8*r,36*r,16*r,"#ffffff")):DrawRect(c-24*r,d-11*r,48*r,22*r,"#ffffff");return}const o=e.OnlineSharedSettings?.["PEX"]?.state;o&&o.mode==="blank"&&o.gelId&&!o.gelHolder&&typeof DrawImageResize=="function"&&DrawImageResize("Assets/Female3DCG/ItemHandheld/Preview/GlassFilled.png",t+250*r-20*r,n+950*r-17*r,40*r,34*r)}catch{}}const Te=new Map;function Hr(){try{if(typeof ChatRoomCharacter>"u"||!Array.isArray(ChatRoomCharacter))return;for(const e of ChatRoomCharacter){if(!e||e.MemberNumber==null||e.MemberNumber===Player?.MemberNumber)continue;const t=e.OnlineSharedSettings?.["PEX"]?.state,n=Te.get(e.MemberNumber);t&&t.mode==="excreting"&&t.startedAt?n!==t.startedAt&&(Te.set(e.MemberNumber,t.startedAt),Nn(e)):n!==void 0&&Te.delete(e.MemberNumber)}}catch{}}function jr(){Te.clear()}function zr(e){ie(t=>{try{if(t?.Type!=="Hidden")return;const n=Array.isArray(t.Dictionary)?t.Dictionary:[],r=i=>{const o=n.find(s=>s?.Tag===i);return o?o.Value??o.Name:void 0};if(t.Content==="PEX_GelExpired"){const i=r("GelId");i&&Se(i)}else if(t.Content==="PEX_GelInvalidated"){const i=r("GelId"),o=+r("Owner");i&&In(i,o)}else if(t.Content==="PEX_GelConsumed"){const i=+r("Owner"),o=+r("Drinker"),s=r("GelId");try{const a=Pe(i);a?.OnlineSharedSettings?.["PEX"]&&(a.OnlineSharedSettings.PEX.state=null)}catch{}typeof e=="function"&&e({gelId:s,owner:i,drinker:o})}else if(t.Content==="PEX_GelHeld"){const i=r("GelId"),o=+r("Owner"),s=+r("Holder");try{const a=Pe(o);a?.OnlineSharedSettings?.["PEX"]?.state&&(a.OnlineSharedSettings.PEX.state.gelHolder=s)}catch{}if(o===Player?.MemberNumber)try{f.gelHolder=s,T({mode:"blank",remainingSec:f.phaseEndsAt?Math.max(0,Math.round((f.phaseEndsAt-Date.now())/1e3)):0,owner:Player?.MemberNumber,gelId:i,gelHolder:s,expiresAt:f.phaseEndsAt||0},!0)}catch{}}else if(t.Content==="PEX_StateSync"){const i=r("Payload");if(!i)return;let o=null;try{o=JSON.parse(i)}catch{return}const s=Number(t.Sender);if(!s||s===Player?.MemberNumber||!o||typeof o!="object")return;const a=Pe(s);if(!a)return;try{a.OnlineSharedSettings||(a.OnlineSharedSettings={}),a.OnlineSharedSettings.PEX||(a.OnlineSharedSettings.PEX={}),a.OnlineSharedSettings.PEX.state=o}catch{}}else if(t.Content==="PEX_SharedSync"){const i=r("Payload");if(!i)return;let o=null;try{o=JSON.parse(i)}catch{return}const s=Number(t.Sender);if(!s||s===Player?.MemberNumber||!o||typeof o!="object")return;const a=Pe(s);if(!a)return;try{a.OnlineSharedSettings||(a.OnlineSharedSettings={}),a.OnlineSharedSettings.PEX||(a.OnlineSharedSettings.PEX={});const c=a.OnlineSharedSettings.PEX;o.edit!==void 0&&(c.edit=o.edit),o.editModes&&(c.editModes=o.editModes),o.wl&&(c.wl=o.wl)}catch{}}}catch{}})}function Tn(e){try{if(e===Player?.MemberNumber)return CharacterNickname(Player);const t=ChatRoomCharacter?.find(n=>n?.MemberNumber===e);if(t)return CharacterNickname(t)}catch{}return null}function We(){p("强制恢复"),f.gelId&&Tt(f.gelId),Se(f.gelId),_n(!0),b("%NAME%被强制恢复了，一切回归正常。")}const g={accent:"#f27ba8",teal:"#3f9c92",tealDark:"#2a6b63",text:"#e8e4f5",dim:"#9b93bd",danger:"#ff6b6b"},Wr={idle:"空闲",waiting:"排出前等待",blocked:"臀部被挡·等待中",excreting:"排出动画中",blank:"失神中"},Ur={all:"全部",surround:"周围",self:"自己"},Yr={self:"仅自己",others:"仅他人",both:"都可见"};let S=null,Ce=null,ue=!1,J=null;function qr(){return!!S}function Cn(e){return String(e).replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;")}function le(e,t,n,r){const i=document.createElement("button");return i.textContent=e,Object.assign(i.style,{background:t,border:"1px solid rgba(255,255,255,0.25)",borderRadius:"4px",color:n,cursor:"pointer",fontSize:"11px",padding:"2px 8px",lineHeight:"16px",fontWeight:"bold",whiteSpace:"nowrap"}),i.addEventListener("click",r),i}function Jr(){const e=f;let t="—";if(e.phaseEndsAt>0){const c=Math.max(0,Math.round((e.phaseEndsAt-Date.now())/1e3));t=Math.floor(c/60)+":"+String(c%60).padStart(2,"0")}const n=Wr[e.mode]||e.mode,r=e.mode==="idle"?g.dim:g.accent,i=e.gelId?"#"+String(e.gelId).slice(0,8):"—",o=e.gelHolder!=null?"#"+e.gelHolder:"—",s=e.ownerMemberNumber!=null?"#"+e.ownerMemberNumber:"—",a=l;return`
    <div style="display:grid;grid-template-columns:1fr 1fr;gap:2px 14px;font-size:12px;line-height:18px">
      <div><span style="color:${g.dim}">状态</span> <b style="color:${r}">${n}</b>${e.gelType==="normal"?` <span style="color:${g.teal}">（普通凝胶）</span>`:""}</div>
      <div><span style="color:${g.dim}">倒计时</span> <b style="color:${g.text}">${t}</b></div>
      <div><span style="color:${g.dim}">凝胶ID</span> <b style="color:${g.text}">${i}</b></div>
      <div><span style="color:${g.dim}">持有者</span> <b style="color:${g.text}">${o}</b></div>
      <div><span style="color:${g.dim}">主人</span> <b style="color:${g.text}">${s}</b></div>
      <div><span style="color:${g.dim}">类型</span> <b style="color:${g.text}">${Cn(e.gelType)}</b></div>
    </div>
    <div style="margin-top:5px;padding-top:4px;border-top:1px solid rgba(63,156,146,0.35);display:grid;grid-template-columns:1fr 1fr;gap:2px 14px;font-size:11px;line-height:17px;color:${g.dim}">
      <span>总开关：<b style="color:${g.text}">${a.enabled?"开":"关"}</b></span>
      <span>排出等待：<b style="color:${g.text}">${a.waitSeconds}秒</b></span>
      <span>阻挡上限：<b style="color:${g.text}">${a.blockedWaitMinutes}分</b></span>
      <span>自动回归：<b style="color:${g.text}">${a.autoRevertEnabled?a.autoRevertMinutes+"分":"关"}</b></span>
      <span>普通表情：<b style="color:${g.text}">${a.normalExpressionSeconds}秒</b></span>
      <span>特效强度：<b style="color:${g.text}">${a.effectLevel} / 5</b></span>
      <span>失神视野：<b style="color:${g.text}">${Ur[a.viewMode]||a.viewMode}</b></span>
      <span>计时器：<b style="color:${g.text}">${Yr[a.timerVisibility]||a.timerVisibility}</b></span>
    </div>`}function Qr(){const e=ce.slice(-8);return e.length?e.map(t=>`<div style="font-size:11px;color:${g.dim};white-space:nowrap;overflow:hidden;text-overflow:ellipsis">${Cn(t)}</div>`).join(""):`<div style="color:${g.dim};font-size:11px">（暂无日志）</div>`}function Zr(e){if(S||!e)return;S=document.createElement("div"),S.id="pex-panel",Object.assign(S.style,{background:"linear-gradient(135deg, rgba(22,17,40,0.97) 0%, rgba(24,40,38,0.97) 100%)",borderLeft:"3px solid "+g.accent,borderTop:"1px solid rgba(63,156,146,0.4)",padding:"8px 10px 6px",boxShadow:"0 -4px 20px rgba(242,123,168,0.20)",fontFamily:'"Noto Sans SC","Microsoft YaHei",sans-serif',fontSize:"12px",userSelect:"none",marginTop:"4px",display:"block"});const t=document.createElement("div");Object.assign(t.style,{display:"flex",alignItems:"center",justifyContent:"space-between",marginBottom:"6px"});const n=document.createElement("span");n.innerHTML=`⚗️ <b style="color:${g.accent}">PEX</b> <span style="color:${g.dim};font-size:10px">控制台 v${N}</span>`;const r=le("⚙ 设置",g.tealDark,"#c9f0ea",()=>{try{typeof PreferenceSubscreenExtensionsOpen=="function"&&PreferenceSubscreenExtensionsOpen(gt)}catch{}}),i=le("🧪 测试流程",g.tealDark,"#c9f0ea",()=>{try{if(f.mode!=="idle"){p("已有进行中的流程，先 /pex reset 再测");return}const h=l.waitSeconds;l.waitSeconds=10,ut("persona"),l.waitSeconds=h,p("测试流程已启动：10 秒后排出（臀部有东西会等待）")}catch(h){p("测试流程启动失败:",h.message)}}),o=le("💾 保存",g.tealDark,"#c9f0ea",()=>{_(!0),p("设置已保存"),Me()}),s=le("⚠ 强制恢复","rgba(120,30,30,0.85)","#ff8899",()=>{if(!ue){ue=!0,s.textContent="⚠ 再次点击确认",s.style.background=g.danger,clearTimeout(J),J=setTimeout(()=>{ue=!1,s.textContent="⚠ 强制恢复",s.style.background="rgba(120,30,30,0.85)"},4e3);return}ue=!1,clearTimeout(J),s.textContent="⚠ 强制恢复",s.style.background="rgba(120,30,30,0.85)",We(),Me()}),a=le("✕","rgba(100,20,40,0.8)","#ff8899",()=>Rn()),c=document.createElement("div");c.style.cssText="display:flex;gap:4px;align-items:center",c.append(r,i,o,s,a),t.append(n,c),S.appendChild(t);const u=document.createElement("div");u.id="pex-panel-status",S.appendChild(u);const d=document.createElement("div");d.id="pex-panel-log",Object.assign(d.style,{marginTop:"5px",paddingTop:"4px",borderTop:"1px solid rgba(242,123,168,0.25)",maxHeight:"110px",overflowY:"auto"}),S.appendChild(d),e.appendChild(S),Ce=setInterval(Me,1e3),Me()}function Me(){if(!S)return;const e=S.querySelector("#pex-panel-status"),t=S.querySelector("#pex-panel-log");e&&(e.innerHTML=Jr()),t&&(t.innerHTML=Qr())}function Rn(){if(Ce&&(clearInterval(Ce),Ce=null),J&&(clearTimeout(J),J=null),ue=!1,S){try{S.remove()}catch{}S=null}}function v(e,t=0){try{const n=document.getElementById("TextAreaChatLog");if(!n)throw new Error("no log");const r=document.createElement("div");r.className="ChatMessage ChatMessageLocalMessage",Object.assign(r.style,{background:"rgba(160,50,120,0.16)",borderLeft:"3px solid rgb(242,123,168)",padding:"4px 8px",margin:"2px 0",color:"rgb(242,175,205)",fontSize:"0.92em",fontFamily:"inherit",whiteSpace:"pre-wrap",transition:"opacity 0.5s ease"}),r.innerHTML='<span style="opacity:0.6;font-size:0.85em">⚗️ PEX</span>　'+e.split(`
`).join("<br>"),n.appendChild(r),n.scrollTop=n.scrollHeight,t>0&&setTimeout(()=>{r.style.opacity="0",setTimeout(()=>r.remove(),500)},t);return}catch{}try{typeof ChatRoomMessage=="function"&&ChatRoomMessage({Type:"LocalMessage",Sender:Player?.MemberNumber,Content:`<font color="#f2afcd">⚗️ [PEX] ${e}</font>`})}catch{}}function Ct(e){const t=e.trim().split(/\s+/);if((t[0]||"").toLowerCase()!=="/pex")return!1;const n=(t[1]||"").toLowerCase();if(!n||n==="help")return v(x("help",{v:N})),!0;if(n==="howto")return v(x("howto",{v:N})),!0;if(n==="reset")return t[2]==="yes"?(We(),v(x("resetDone"))):v(x("resetConfirm")+"（再次输入 /pex reset yes 确认）"),!0;if(n==="show"){const r=document.getElementById("TextAreaChatLog")||document.querySelector(".ChatLog");return r?(qr()?Rn():Zr(r),!0):(v(x("noChatBox")),!0)}if(n==="status")return v(x("statusLine",{state:mn()})),!0;if(n==="settings"){try{typeof PreferenceSubscreenExtensionsOpen=="function"?PreferenceSubscreenExtensionsOpen(gt):v(x("cantOpenSettings"))}catch(r){v("⚠️ 打开设置页失败: "+r.message)}return!0}return n==="save"?(_(!0),v("设置已保存。"),!0):(v(x("cmdUnknown",{sub:n})),!0)}function ei(){try{if(typeof CommandCombine=="function")return CommandCombine([{Tag:"pex",Description:"人格排泄插件指令（/pex help 查看说明）",Action:e=>{Ct("/pex "+(e??""))}}]),!0}catch(e){console.warn("⚗️[PEX] CommandCombine 注册失败:",e.message)}return!1}let Zt=!1;function Dn(){Zt||(Zt=!0,document.addEventListener("keydown",e=>{if(e.key!=="Enter")return;const t=document.getElementById("InputChat")||document.querySelector('textarea[id*="Chat"]');if(!t)return;const n=t.value.trim();n.toLowerCase().startsWith("/pex")&&(Ct(n),e.preventDefault(),e.stopPropagation(),t.value="")},!0))}let en=!1;function ti(){en||(en=!0,!ei()&&Dn())}function ni(){Dn()}const ri="modulepreload",ii=function(e,t){return new URL(e,t).href},tn={},oi=function(t,n,r){let i=Promise.resolve();if(n&&n.length>0){let u=function(d){return Promise.all(d.map(h=>Promise.resolve(h).then(A=>({status:"fulfilled",value:A}),A=>({status:"rejected",reason:A}))))};const s=document.getElementsByTagName("link"),a=document.querySelector("meta[property=csp-nonce]"),c=a?.nonce||a?.getAttribute("nonce");i=u(n.map(d=>{if(d=ii(d,r),d in tn)return;tn[d]=!0;const h=d.endsWith(".css"),A=h?'[rel="stylesheet"]':"";if(r)for(let D=s.length-1;D>=0;D--){const we=s[D];if(we.href===d&&(!h||we.rel==="stylesheet"))return}else if(document.querySelector(`link[href="${d}"]${A}`))return;const k=document.createElement("link");if(k.rel=h?"stylesheet":ri,h||(k.as="script"),k.crossOrigin="",k.href=d,c&&k.setAttribute("nonce",c),document.head.appendChild(k),h)return new Promise((D,we)=>{k.addEventListener("load",D),k.addEventListener("error",()=>we(new Error(`Unable to preload CSS for ${d}`)))})}))}function o(s){const a=new Event("vite:preloadError",{cancelable:!0});if(a.payload=s,window.dispatchEvent(a),!a.defaultPrevented)throw s}return i.then(s=>{for(const a of s||[])a.status==="rejected"&&o(a.reason);return t().catch(o)})};let Je=!1;function ai(e,t){const n=U();if(n)try{n.hookFunction("ChatRoomRun",0,(r,i)=>{const o=i(r);try{try{pr()}catch{}if(Je)return o;Je=!0,e&&e()}catch{}return o}),n.hookFunction("ChatRoomLeave",0,(r,i)=>{const o=i(r);try{t&&t(),Je=!1}catch{}return o})}catch(r){console.warn("⚗️[PEX] 房间生命周期挂钩失败:",r.message)}}function si(e){const t=U();if(t)try{t.onUnload(()=>{try{e&&e()}catch{}})}catch{}}function li(e){const t={activityName:null,groupName:null,target:null,itemName:null};try{const n=Array.isArray(e?.Dictionary)?e.Dictionary:[];for(const r of n)!r||typeof r!="object"||(t.activityName==null&&typeof r.ActivityName=="string"&&(t.activityName=r.ActivityName),t.groupName==null&&r.Tag==="FocusAssetGroup"&&r.FocusGroupName&&(t.groupName=r.FocusGroupName),t.target==null&&typeof r.TargetCharacter=="number"&&(t.target=r.TargetCharacter),t.itemName==null&&r.Tag==="ActivityAsset"&&r.AssetName&&(t.itemName=r.AssetName))}catch{}if(!t.activityName)try{const n=typeof e?.Content=="string"?JSON.parse(e.Content):null;n&&typeof n=="object"&&(t.activityName=n.Name??n.ActivityName??t.activityName,t.groupName=n.GroupName??t.groupName,t.target=n.TargetMemberNumber??n.TargetCharacter??t.target)}catch{}return t}const ci=["人格药水","persona"];function nn(e){const t=st(e);return t?ci.concat(l.keywords||[]).some(n=>Vt(t,n))?"persona":(l.normalKeywords||[]).some(n=>Vt(t,n))?"normal":null:null}function Rt(e,t){try{if(e==="SipItem"){const n=Ee(t);if(n){if(n.invalid){Jt(t,Player?.MemberNumber,n),b("%NAME%喝了一口，什么味道也没有…");return}const i=n.ownerMemberNumber===Player?.MemberNumber;Jt(t,Player?.MemberNumber,n),i&&f.mode===m.BLANK?Be("%NAME%喝回了自己的人格凝胶，意识一下子回来了！"):(p("凝胶被喝掉:",n.gelId),b("%NAME%迷迷糊糊地把手里的凝胶喝了下去…"));return}const r=nn(t);r&&l.enabled?(p("命中关键词 →",r),ut(r)):p("未命中关键词，物品文本:",st(t).slice(0,60));return}if(e==="Inject"){const n=nn(t);n&&l.enabled?(p("注射命中关键词 →",n),ut(n)):p("注射未命中关键词，物品文本:",st(t).slice(0,60))}}catch(n){p("处理活动异常:",n.message)}}function ui(e){try{const n=(Array.isArray(e?.Dictionary)?e.Dictionary:[]).find(r=>r?.Tag==="ActivityAsset");return n?{Asset:n.AssetName?{Name:n.AssetName,Group:{Name:n.GroupName}}:null,Craft:n.CraftName?{Name:n.CraftName}:null}:null}catch{return null}}function di(){ie(e=>{try{if(e?.Type!=="Activity")return;const t=li(e);if(!t.activityName||(p("收到活动消息:",t.activityName,"目标:",t.target,"物品:",t.itemName||"?","发送者:",e.Sender),!(t.target!=null&&t.target===Player?.MemberNumber)))return;Rt(t.activityName,ui(e)||Dt())}catch(t){p("触发检测异常:",t.message)}})}function fi(e){if(e)try{e.hookFunction("ActivityRun",1,(t,n)=>{const r=n(t);try{const[i,o,s,a]=t;if(!i||!o||!a?.Activity?.Name||!(typeof i.IsPlayer=="function"&&i.IsPlayer()&&typeof o.IsPlayer=="function"&&o.IsPlayer()))return r;const u=a.Activity.Name;if(u!=="SipItem"&&u!=="Inject")return r;const d=a.Item||Dt();p("本地动作(ActivityRun):",u,"物品:",d?.Asset?.Name||"?"),Rt(u,d)}catch{}return r})}catch(t){p("ActivityRun 挂钩失败:",t.message)}}function pi(e){if(e)try{e.hookFunction("DialogActivityClick",1,(t,n)=>{const r=n(t);try{const[i,o]=t;if(!i||!o?.Activity?.Name||typeof i.IsPlayer!="function"||!i.IsPlayer())return r;const s=o.Activity.Name;if(s!=="SipItem"&&s!=="Inject")return r;const a=o.Item||Dt();p("点击动作(DialogActivityClick):",s,"物品:",a?.Asset?.Name||"?"),Rt(s,a)}catch{}return r})}catch(t){p("DialogActivityClick 挂钩失败:",t.message)}}function Dt(){try{return InventoryGet(Player,"ItemHandheld")}catch{return null}}const Qe="PEX_PickupGel",Ze="PEX_PutGel";function Xe(e){try{const t=e?.OnlineSharedSettings?.PEX?.state;if(t&&t.mode==="blank"&&t.gelId)return t}catch{}return null}function mi(e){try{if(!e||e.MemberNumber==null||e.MemberNumber===Player?.MemberNumber)return!1;const t=Xe(e);return!(!t||t.gelHolder)}catch{return!1}}function yi(e){try{if(!e||e.MemberNumber==null||e.MemberNumber===Player?.MemberNumber)return!1;const t=Xe(e);if(!t)return!1;const n=InventoryGet(Player,"ItemHandheld");if(!n||!kn(n))return!1;const r=hi(n);return!!r&&!r.invalid&&r.gelId===t.gelId}catch{return!1}}function hi(e){try{const t=e?.Craft?.Description??"";if(!t.startsWith("PEX|"))return null;const n=t.slice(4).split("|"),[r,i]=n;return{gelId:r,ownerMemberNumber:+i,invalid:n[3]==="INVALID"}}catch{return null}}function gi(e,t){try{if(!t){b("%NAME%试着捡起凝胶，但它已经不见了…");return}if(InventoryGet(Player,"ItemHandheld")){b("%NAME%想捡起凝胶，但手里已经拿着东西了。");return}const n=t.gelId,r=t.owner??e?.MemberNumber,i=t.expiresAt??Date.now()+1800*1e3,o=Xr(r,n,i,t.type==="normal"?"normal":"persona");if(!o){b("%NAME%试着捡起凝胶，但失败了…");return}P("PEX_GelHeld",[{Tag:"GelId",Value:String(n)},{Tag:"Holder",Value:String(Player?.MemberNumber)},{Tag:"Owner",Value:String(r)}]);try{e?.OnlineSharedSettings?.["PEX"]?.state&&(e.OnlineSharedSettings.PEX.state.gelHolder=Player?.MemberNumber)}catch{}b(`%NAME%捡起了地上的${o.Craft?.Name??"凝胶"}，小心地端了起来。`)}catch(n){p("捡起失败:",n.message)}}function xi(e,t){try{if(!t)return;const n=t.gelId,r=t.owner??e?.MemberNumber,i=InventoryGet(Player,"ItemHandheld");if(!i||!kn(i)){b("%NAME%想放回凝胶，但手上已经空了。");return}if(!Se(n))return;P("PEX_GelConsumed",[{Tag:"GelId",Value:String(n)},{Tag:"Drinker",Value:String(r)},{Tag:"Owner",Value:String(r)}]);try{e?.OnlineSharedSettings?.["PEX"]?.state&&(e.OnlineSharedSettings.PEX.state=null)}catch{}b(`%NAME%把凝胶放回了${ne(e,"对方")}的身体里，${ne(e,"对方")}慢慢回过神来。`)}catch(n){p("放回失败:",n.message)}}function bi(){const e=U();if(!e)return;const t=(n,r)=>{const i=n&&n[0];return typeof i=="string"&&i.includes(Qe)?"捡起凝胶":typeof i=="string"&&i.includes(Ze)?"放回凝胶":r(n)};try{e.hookFunction("ActivityDictionaryText",0,t)}catch{}try{e.hookFunction("TextGet",0,t),e.hookFunction("TextGetInScope",0,t)}catch{}try{e.hookFunction("DialogBuildActivities",10,(n,r)=>{const i=r(n);try{const o=n&&n[0];if(typeof DialogActivity>"u"||!Array.isArray(DialogActivity)||!o||o.MemberNumber===Player?.MemberNumber)return i;const s=c=>DialogActivity.some(u=>u&&u.Activity&&u.Activity.Name===c)?!1:(DialogActivity.push({Activity:{Name:c,MaxProgress:0},Item:null,Group:o.FocusGroup&&o.FocusGroup.Name||"ItemHands"}),!0);let a=!1;if(mi(o)&&(a=s(Qe)||a),yi(o)&&(a=s(Ze)||a),!a)return i;try{typeof DialogMenuMapping<"u"&&DialogMenuMapping.activities&&typeof DialogMenuMapping.activities.Reload=="function"&&DialogMenuMapping.activities.Reload(null,{reset:!0,resetDialogItems:!1})}catch{}}catch{}return i})}catch{}try{e.hookFunction("DialogActivityClick",1,(n,r)=>{const[i,o]=n;let s=!1;try{const a=o&&o.Activity&&o.Activity.Name;i&&a===Qe?(gi(i,Xe(i)),s=!0):i&&a===Ze&&(xi(i,Xe(i)),s=!0)}catch{}if(s){try{typeof DialogLeave=="function"&&DialogLeave()}catch{}return}return r(n)})}catch{}}let Q=null,Z=null,ee=null;function vi({gelId:e,owner:t,drinker:n}){try{if(t===Player?.MemberNumber)if(f.mode===m.BLANK){const r=f.gelType==="normal";p("我的凝胶被放回身体:",e,"drinker:",n),Be(r?"%NAME%喝回了自己的凝胶，胃里一阵翻腾…":"%NAME%喝回了自己的人格凝胶，意识一下子回来了！",()=>{const i=xn("feed");Nt("feed",i)})}else p("我的凝胶被消耗:",e)}catch{}}function Ei(){const e=U();di(),e&&fi(e),e&&pi(e),e&&Sr(e),e&&Er(e),e&&Kr(e),zr(vi),Ar(),bi(),Q&&clearInterval(Q),Q=setInterval(()=>{try{Ir(Date.now())}catch{}},250),Z&&clearInterval(Z),Z=setInterval(()=>{try{Tr()}catch{}},1e3),ee&&clearInterval(ee),ee=setInterval(()=>{if(l.seeRemoteAnims)try{Hr()}catch{}},1e3)}function Si(){Q&&(clearInterval(Q),Q=null),Z&&(clearInterval(Z),Z=null),ee&&(clearInterval(ee),ee=null);try{jr()}catch{}}const rn="pex-settings-panel",wi=[{key:"basic",label:"基本设置"},{key:"excrete",label:"排出设置"},{key:"fx",label:"特效设置"},{key:"perm",label:"权限设置"},{key:"expr",label:"表情设置"},{key:"sound",label:"音效设置"},{key:"about",label:"关于插件"}],Pi=[["Eyebrows",[["Soft","柔和"],["Lowered","低垂"],["Raised","上扬"],["Frown","皱眉"]]],["Eyes",[["VeryLewd","失神"],["HeartPink","心形粉"],["LewdHeartPink","涩心粉"],["Closed","闭眼"],["Dazed","恍惚"]]],["Mouth",[["Frown","抿嘴"],["Moan","呻吟"],["Ahegao","阿黑颜"],["Open","张开"]]],["Blush",[["High","高"],["Medium","中"],["Low","低"],["VeryHigh","极高"]]]];let on=!1;function Mi(){if(!on){on=!0;try{const e=document.createElement("style");e.id="pex-settings-styles",e.textContent=`
#pex-settings-panel{position:fixed;left:50%;top:50%;transform:translate(-50%,-50%);
  width:min(100vw,1800px);height:min(100vh,1000px);
  background:#1e1930;border:2px solid #f27ba8;border-radius:12px;color:#e8e4f5;
  font-family:sans-serif;font-size:20px;z-index:2147483646;box-shadow:0 8px 40px rgba(0,0,0,.65);
  display:flex;flex-direction:column;overflow:hidden}
.pex-s-head{display:flex;align-items:center;justify-content:space-between;padding:18px 26px;
  border-bottom:1px solid #37305a;background:#241d3a}
.pex-s-title{color:#f27ba8;font-weight:600;font-size:24px}
.pex-s-body{display:flex;flex:1;min-height:0}
.pex-s-nav{width:240px;border-right:1px solid #37305a;padding:16px 14px;display:flex;flex-direction:column;gap:6px}
.pex-sec-btn{background:transparent;color:#9b93bd;border:none;border-radius:8px;padding:15px 18px;
  text-align:left;font-size:20px;cursor:pointer}
.pex-sec-btn:hover{background:#2a2450;color:#e8e4f5}
.pex-sec-btn.on{background:#f27ba8;color:#241d3a;font-weight:600}
.pex-s-content{flex:1;overflow-y:auto;padding:18px 26px}
.pex-row{display:flex;align-items:center;justify-content:space-between;gap:18px;margin:11px 0}
.pex-lbl{color:#c9c2e0;font-size:20px;flex-shrink:0}
.pex-ctl{display:flex;align-items:center;gap:10px}
.pex-tgl{background:#3a3270;color:#fff;border:none;border-radius:8px;padding:10px 28px;cursor:pointer;font-size:20px}
.pex-tgl.on{background:#2a6b63}
.pex-sel{background:#2a6b63;color:#fff;border:1px solid #37305a;border-radius:8px;padding:10px 14px;font-size:20px}
.pex-num{background:#2b2450;color:#e8e4f5;border:1px solid #c2557f;border-radius:8px;padding:10px 14px;width:130px;font-size:20px}
.pex-txt{background:#2b2450;color:#e8e4f5;border:1px solid #37305a;border-radius:8px;padding:10px 14px;
  width:100%;box-sizing:border-box;font-family:monospace;font-size:19.5px;resize:vertical;min-height:100px}
.pex-note{color:#7d749e;font-size:17.5px;margin:6px 0 14px;line-height:1.7}
.pex-sec-title{color:#f27ba8;font-weight:600;font-size:21.5px;margin:16px 0 6px}
.pex-act{background:#3a3270;color:#fff;border:none;border-radius:8px;padding:12px 26px;cursor:pointer;font-size:20px}
.pex-act:hover{background:#4a407f}
.pex-act.danger{background:#872626}
.pex-act.ok{background:#2a6b63}
.pex-about-line{color:#c9c2e0;font-size:20px;line-height:1.8;margin:3px 0}
.pex-about-head{color:#f27ba8;font-weight:600;font-size:21.5px;margin:14px 0 4px}
.pex-expr-del{background:#872626;color:#fff;border:none;border-radius:8px;padding:8px 18px;margin-left:12px;cursor:pointer;font-size:17px;vertical-align:middle}
.pex-confirm-dialog{position:fixed;left:50%;top:50%;transform:translate(-50%,-50%);width:420px;
  background:linear-gradient(135deg,rgba(30,10,40,.98),rgba(50,15,60,.98));border:1px solid rgba(255,120,200,.45);
  border-radius:12px;padding:22px;z-index:2147483647;color:#ffddee;font-family:sans-serif;font-size:14px;
  box-shadow:0 8px 40px rgba(180,60,160,.4);text-align:center}
.pex-confirm-dialog .msg{font-size:14px;margin-bottom:18px;line-height:1.6;white-space:pre-line}
.pex-confirm-dialog button{border:none;border-radius:8px;padding:9px 26px;font-size:14px;font-weight:600;cursor:pointer;margin:0 7px}
.pex-confirm-dialog .no{background:#4a2030;color:#ffaabb}
.pex-confirm-dialog .yes{background:#872626;color:#aaffaa}
.pex-btn-row{display:flex;gap:10px;margin:10px 0;flex-wrap:wrap}
`,document.head.appendChild(e)}catch{}}}function E(e){return String(e??"").replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;")}function et(e,t){try{const r=document.querySelector(".pex-confirm-dialog");r&&r.remove()}catch{}const n=document.createElement("div");n.className="pex-confirm-dialog",n.innerHTML=`<div class="msg">${E(e)}</div>
        <div><button class="no" type="button">取消</button><button class="yes" type="button">确认</button></div>`,n.querySelector(".no").onclick=()=>n.remove(),n.querySelector(".yes").onclick=()=>{n.remove();try{t&&t()}catch{}},document.body.appendChild(n)}const V={active:"basic",panel:null,_needsRender:!0,load(){try{un()}catch{}},run(){try{Mi(),(!this.panel||!document.getElementById(rn))&&(this._build(),this._needsRender=!0),this._needsRender&&(this._needsRender=!1,this._render(this.active),this._syncNav())}catch(e){p("设置面板渲染异常:",e.message)}},click(){},unload(){this._close()},exit(){this._close()},_close(){try{this.panel&&(this.panel.remove(),this.panel=null)}catch{}},_build(){if(this.panel)try{this.panel.remove()}catch{}const e=document.createElement("div");e.id=rn,e.innerHTML=`
            <div class="pex-s-head">
                <div class="pex-s-title">人格排泄 · 设置</div>
                <button type="button" class="pex-act" data-pex-close="1">✕</button>
            </div>
            <div class="pex-s-body">
                <div class="pex-s-nav">
                    ${wi.map(t=>`<button type="button" class="pex-sec-btn" data-pex-sec="${t.key}" title="${E(t.label)}">${E(t.label)}</button>`).join("")}
                </div>
                <div class="pex-s-content"></div>
            </div>`,document.body.appendChild(e),this.panel=e,e.querySelector("[data-pex-close]").onclick=()=>{try{typeof PreferenceExit=="function"&&PreferenceExit()}catch{}this._close()},e.querySelectorAll("[data-pex-sec]").forEach(t=>{t.onclick=()=>{this.active!==t.dataset.pexSec&&(this.active=t.dataset.pexSec,this._needsRender=!0,this.run())}})},_syncNav(){try{this.panel.querySelectorAll("[data-pex-sec]").forEach(e=>{e.classList.toggle("on",e.dataset.pexSec===this.active)})}catch{}},_render(e){const t=this.panel.querySelector(".pex-s-content"),n=document.createElement("div");n.className="pex-s-content",t&&t.replaceWith(n);const r=this["_sec_"+e];n.innerHTML=typeof r=="function"?r.call(this):'<div class="pex-note">暂无内容</div>',this._bind(n),e==="expr"&&this._ensureExprPreview()},_bind(e){e.addEventListener("click",t=>{const n=t.target.closest("[data-pex-side]");if(n){const a=n.dataset.pexSide,c=n.dataset.pexVal==="1";this._setPath(a,c),e.querySelectorAll(`[data-pex-side="${a}"]`).forEach(u=>{u.classList.toggle("on",u.dataset.pexVal===n.dataset.pexVal)});return}const r=t.target.closest("[data-pex-mode]");if(r){const a=r.dataset.pexMode;l.editModes&&(l.editModes[a]=r.dataset.pexMv);try{_()}catch{}e.querySelectorAll(`[data-pex-mode="${a}"]`).forEach(c=>{c.classList.toggle("on",c.dataset.pexMv===r.dataset.pexMv)});return}const i=t.target.closest("[data-pex-action]");if(i){const a=this._actions[i.dataset.pexAction];a&&a()}if(t.target.closest("[data-pex-add-expr]")){const a=l.expressions?.wait;if(Array.isArray(a)&&a.length<10){a.push({...l.expressions.excrete||{}});try{_()}catch{}this._needsRender=!0,this.run()}return}const s=t.target.closest("[data-pex-del-expr]");if(s){const a=parseInt(s.dataset.pexDelExpr,10);et('确定删除"等待表情 '+(a+1)+'"吗？',()=>{const c=l.expressions?.wait;if(Array.isArray(c)&&c[a]){c.splice(a,1);try{_()}catch{}this._needsRender=!0,this.run()}});return}}),e.addEventListener("change",t=>{const n=t.target;if(n.dataset.pexSelect){const r=n.value,i=Number(r);this._setPath(n.dataset.pexSelect,r!==""&&/^\d+$/.test(r)&&!isNaN(i)?i:r);const o=n.dataset.pexSelect;if(o.startsWith("expressions.wait.")){const s=parseInt(o.split(".").pop(),10);isNaN(s)||(this._exprEditKey=s)}else o.startsWith("expressions.")?this._exprEditKey=o.split(".")[1]:o.startsWith("normalExpression")&&(this._exprEditKey="normal");(o.startsWith("expressions.")||o.startsWith("normalExpression"))&&this._ensureExprPreview();return}if(n.dataset.pexNumber){const r=parseInt(n.value,10);isNaN(r)||this._setPath(n.dataset.pexNumber,r);return}if(n.dataset.pexText){this._setPath(n.dataset.pexText,n.value);return}if(n.dataset.pexSound){const r=n.dataset.pexSound,i=n.value.split(`
`).map(o=>o.trim()).filter(Boolean);l.sounds[r]=i;try{Re()}catch{}}})},_getPath(e){return e.split(".").reduce((t,n)=>t==null?t:t[n],l)},_setPath(e,t){if(e==="whitelistText"){l.whitelist=String(t).split(/[\s,]+/).map(o=>o.trim()).filter(Boolean);try{_()}catch{}return}if(e==="keywords"||e==="normalKeywords"){l[e]=String(t).split(`
`).map(o=>o.trim()).filter(Boolean);try{_()}catch{}return}if(e.startsWith("soundOn.")){const o=e.split(".");l.soundOn&&(l.soundOn[o[1]]=!!t);try{Re()}catch{}return}const n=e.split("."),r=n.pop();let i=l;for(const o of n)i=i[o];if(i&&r in i){i[r]=t;try{_()}catch{}}},_actions:{recover:()=>{et(`确定要强制恢复吗？
此操作会立即清除全部 PEX 状态，包括等待、失神与凝胶。`,()=>We())},reset:()=>{et(`确定要恢复默认设置吗？
所有设置将还原为初始值。`,()=>{Ge(R()),_(!0),ge(!0),V._needsRender=!0,V.run()})},exportCfg:()=>{try{fn()}catch{}},importCfg:()=>{try{pn()}catch{}}},_row(e,t,n){return`<div class="pex-row"><div class="pex-lbl" title="${E(t)}">${E(e)}</div><div class="pex-ctl">${n}</div></div>`},_tgl(e,t="开 / 关"){const n=!!this._getPath(e);return`<button type="button" class="pex-tgl ${n?"":"on"}" data-pex-side="${e}" data-pex-val="0" title="${E(t)}">关</button><button type="button" class="pex-tgl ${n?"on":""}" data-pex-side="${e}" data-pex-val="1" title="${E(t)}">开</button>`},_sel(e,t,n){const r=this._getPath(e);return`<select class="pex-sel" data-pex-select="${e}" title="${E(n||"")}">${t.map(([i,o])=>`<option value="${i}" ${String(r)===String(i)?"selected":""}>${E(o)}</option>`).join("")}</select>`},_num(e,t,n,r){return`<input type="number" class="pex-num" data-pex-number="${e}" min="${t}" max="${n}" value="${this._getPath(e)}" title="${E(r||"")}">`},_txt(e,t,n){const r=this._getPath(e),i=Array.isArray(r)?r.join(`
`):r??"";return`<textarea class="pex-txt" data-pex-text="${e}" title="${E(t||"")}" placeholder="${E(n||"")}">${E(i)}</textarea>`},_sec_basic(){return`
            ${this._row("启用插件","关闭后所有触发与表现全部停用",this._tgl("enabled","插件总开关"))}
            <div class="pex-sec-title">触发关键词</div>
            <div class="pex-note">关键词写在物品的制作名、制作描述或雕刻描述中；喝下或注射该物品即触发。</div>
            ${this._row("人格凝胶关键词","命中后进入完整排出流程：眩晕、排出、失神","")}
            ${this._txt("keywords","人格凝胶关键词，每行一个","如：人格药水")}
            ${this._row("普通凝胶关键词","命中后排出普通凝胶：眩晕、表情、凝胶落地，但没有任何失神限制","")}
            ${this._txt("normalKeywords","普通凝胶关键词，每行一个","如：普通凝胶")}
            <div class="pex-sec-title">安全</div>
            <div class="pex-btn-row">
                <button type="button" class="pex-act danger" data-pex-action="recover">强制恢复</button>
            </div>
            <div class="pex-note">强制恢复会立即清除全部 PEX 状态，包括等待、失神与凝胶，需要弹窗二次确认。</div>`},_sec_excrete(){return`
            <div class="pex-sec-title">时间</div>
            ${this._row("排出前等待（秒）","喝下或注射后到开始排出之间的等待时间；等待音效按它自动分段（10 秒 1 段…50 秒及以上 5 段）",this._num("waitSeconds",10,600,"10 到 600 秒"))}
            ${this._row("臀部阻挡上限（分）","臀部装备位有东西时等待多久，超时药效静默消失",this._num("blockedWaitMinutes",1,30,"1 到 30 分钟"))}
            ${this._row("自动回归（分）","排出后多久没被喂回就自动恢复",this._num("autoRevertMinutes",1,30,"1 到 30 分钟"))}
            ${this._row("自动回归","超时后自动恢复并处理凝胶；关闭后凝胶一直等喂回",this._tgl("autoRevertEnabled","自动回归开关"))}
            <div class="pex-sec-title">凝胶</div>
            ${this._row("凝胶到期","到期时凝胶消散消失，或变成持有者手上的无效凝胶永久保留",this._sel("gelExpireMode",[["vanish","消散消失"],["invalid","变无效凝胶"]],"到期行为"))}
            <div class="pex-sec-title">失神限制</div>
            ${this._row("失神限制","失神时不能动、禁言、不眨眼、姿势锁定；关闭后失神只保留视觉表现",this._tgl("restrictions","失神限制总开关"))}
            <div class="pex-note">关闭失神限制后，排出者失神期间仍可以行动、说话和离开房间。</div>`},_sec_fx(){return`
            <div class="pex-sec-title">特效开关</div>
            ${this._row("等待期眩晕","喝下后等待期的眩晕脉冲效果",this._tgl("fxDizzy","眩晕脉冲"))}
            ${this._row("失神黑白","失神时画面黑白并压暗，暗角强弱随特效强度",this._tgl("fxBlank","黑白特效"))}
            ${this._row("模糊特效","眩晕、排出与失神时的画面模糊",this._tgl("fxBlur","模糊特效"))}
            ${this._row("排出震动","排出动画期间的画面震动",this._tgl("fxShake","排出震动"))}
            <div class="pex-sec-title">强度与视野</div>
            ${this._row("特效强度","数字越大，眩晕、模糊、暗角越强",this._sel("effectLevel",[[1,"1"],[2,"2"],[3,"3"],[4,"4"],[5,"5"]],"特效强度 1 到 5"))}
            ${this._row("失神视野","失神时画面整体变暗的程度，关闭则视野不变",this._sel("blindLevel",[[0,"无"],[1,"轻度"],[2,"中度"],[3,"重度"]],"失神视野档位"))}
            ${this._row("凝胶图层","凝胶画在第几层，数字越大越靠上层，24 及以上为顶层（不被遮住）",this._num("gelLayer",0,99,"0 到 99，默认 24"))}
            <div class="pex-sec-title">他人视角</div>
            ${this._row("看别人排出动画","是否播放他人排出时的动画",this._tgl("seeRemoteAnims","远程排出动画"))}
            ${this._row("其他玩家音效","是否播放其他玩家广播的音效（等待/排出/放回）；默认关闭 = 只有自己听得到",this._tgl("hearRemoteSounds","其他玩家音效"))}
            ${this._row("计时器可见性","头顶倒计时谁能看到",this._sel("timerVisibility",[["self","仅自己"],["whitelist","仅白名单"],["others","仅他人"],["all","所有人"]],"计时器可见性"))}
            <div class="pex-note">凝胶固定在角色身体层绘制，会被衣服遮住；特效与强度均为本地设置，不会通过远程修改开放给他人。</div>`},_sec_perm(){const e=l,t=[["time","时间类","排出前等待、臀部阻挡上限、自动回归分钟"],["autoRevert","凝胶自动回归","自动回归的开关"],["timerVisibility","计时器可见性","头顶倒计时的可见档位"]],n=[["off","仅自己"],["whitelist","白名单"],["any","所有人"]];let r='<div class="pex-note">每类设置可独立选择能否被别人远程修改，默认仅自己。</div>';for(const[i,o,s]of t){const a=e.editModes&&e.editModes[i]||"off";r+=this._row(o,s,n.map(([c,u])=>`<button type="button" class="pex-tgl ${a===c?"on":""}" data-pex-mode="${i}" data-pex-mv="${c}" title="${E(s)}">${u}</button>`).join(""))}return r+=`<div class="pex-sec-title">白名单</div>
            <div class="pex-note">成员号逗号分隔，支持 $owner、$lover 等代号；远程修改权限选白名单时生效。</div>
            <textarea class="pex-txt" data-pex-text="whitelistText" title="白名单成员号" placeholder="如：12345, 67890">${E((e.whitelist||[]).join(", "))}</textarea>`,r},_sec_expr(){const e=l.expressions||{},t=Array.isArray(e.wait)?e.wait:[];let n=`<div style="display:flex;gap:18px;align-items:flex-start">
            <div style="flex:1">`;n+=`<div class="pex-sec-title">等待表情池</div>
            <div class="pex-note">排出前等待期间随机抽取播放，与等待音效同步出现（同一时间点）；可自行添加更多组（最多 10 组）。</div>`;for(let r=0;r<t.length;r++)n+=`<div class="pex-sec-title">等待表情 ${r+1}
                <button type="button" class="pex-expr-del" data-pex-del-expr="${r}" title="删除这组等待表情">✕</button></div>`,n+=this._exprRow(`expressions.wait.${r}`);return n+='<div class="pex-btn-row"><button type="button" class="pex-act ok" data-pex-add-expr="wait" title="添加一组等待表情（最多 10 组）">＋ 新增等待表情</button></div>',n+=`<div class="pex-sec-title">排出表情</div>
            <div class="pex-note">与排出动画同时播放（等待期表情之外的下一组）</div>`,n+=this._exprRow("expressions.excrete"),n+=`<div class="pex-sec-title">失神定格</div>
            <div class="pex-note">凝胶排出后定格，持续到恢复</div>`,n+=this._exprRow("expressions.blank"),n+=`<div class="pex-sec-title">普通凝胶表情</div>
            <div class="pex-note">普通凝胶排出后的短暂表情变化</div>`,n+=this._exprRow("normalExpression"),n+=`</div>
            <div style="width:200px;text-align:center;position:sticky;top:0">
                <img id="pex-expr-preview" alt="" style="width:170px;height:170px;border-radius:50%;border:2px solid #f27ba8;background:#241d3a;object-fit:cover">
                <div class="pex-note" style="margin-top:8px">表情预览</div>
            </div>
        </div>`,n},_exprRow(e){let t="";for(const[n,r]of Pi)t+=this._row(n,n+" 表情",this._sel(e+"."+n,r,n+" 表情"));return t},_exprPreviewKey:null,_exprEditKey:0,_ensureExprPreview(){const e=this._exprEditKey==="normal"?l.normalExpression:typeof this._exprEditKey=="number"?l.expressions?.wait?.[this._exprEditKey]:l.expressions?.[this._exprEditKey];if(!e)return;const t=String(this._exprEditKey)+":"+JSON.stringify(e);if(t===this._exprPreviewKey)return;this._exprPreviewKey=t;const n=document.getElementById("pex-expr-preview");if(n)try{if(typeof Player>"u"||!Player||typeof CharacterLoadCanvas!="function"){this._fallbackPreview(e,n);return}const r=this._expandExpr(e),i=Object.assign(Object.create(Object.getPrototypeOf(Player)),Player);i.MemberNumber=-77777,i.Appearance=(Player.Appearance||[]).map(s=>{const a=s.Asset.Group.Name;if(r[a]===void 0)return s;const c=Object.assign({},s);return c.Property=Object.assign({},s.Property),c.Property.Expression=r[a],c}),i.Canvas=null,i.CanvasBlink=null,i.MustDraw=!0;try{CharacterLoadCanvas(i)}catch{}const o=()=>{try{const s=i.Canvas;s&&s.width&&this._captureFace(s,n)}catch{}};o(),setTimeout(o,160),setTimeout(o,420),setTimeout(()=>{(!n.src||!n.src.startsWith("data:"))&&this._fallbackPreview(e,n)},1e3)}catch{this._fallbackPreview(e,n)}},_fallbackPreview(e,t){try{if(typeof Player>"u"||!Player?.Appearance||typeof CharacterRefresh!="function")return;const n=this._expandExpr(e),r={},i=[];for(const[o,s]of Object.entries(n))try{if(s==null)continue;const a=Player.Appearance.find(c=>c.Asset.Group.Name===o);if(!a)continue;r[o]=a.Property?.Expression??null,a.Property||(a.Property={}),a.Property.Expression=s,i.push(o)}catch{}if(!i.length)return;try{CharacterRefresh(Player,!1,!1)}catch{}setTimeout(()=>{try{Player?.Canvas?.width&&this._captureFace(Player.Canvas,t)}catch{}try{for(const[o,s]of Object.entries(r)){const a=Player.Appearance.find(c=>c.Asset.Group.Name===o);a&&(a.Property||(a.Property={}),a.Property.Expression=s)}CharacterRefresh(Player,!1,!1)}catch{}},300)}catch{}},_captureFace(e,t){try{const r=document.createElement("canvas");r.width=r.height=320;const i=r.getContext("2d"),o=e.width*.2,s=e.width*.5-o/2,a=e.height*.43-o*.22;i.drawImage(e,s,a,o,o,0,0,320,320);const c=new Image;c.onload=()=>{try{t.src=c.src}catch{}},c.src=r.toDataURL()}catch{}},_expandExpr(e){const t=e.Eyes??null,n=e.Eyes2!==void 0?e.Eyes2:t;return{Eyebrows:e.Eyebrows??null,Eyes:t,Eyes2:n,Mouth:e.Mouth??null,Blush:e.Blush??null,右眼_Luzi:t,左眼_Luzi:n}},_sec_sound(){const e=l.sounds||{wait:[],excrete:[],feed:[]},t=[["wait","等待音效","排出前等待期间分段播放，与等待表情同步出现：10 秒 1 段、20 秒 2 段、30 秒 3 段、40 秒 4 段、50 秒及以上 5 段，均匀分布随机选段；内置 5 段（CDN），自定义地址加入随机池"],["excrete","排出音效","排出动画期间播放；动画长度自动对齐音效时长（默认 7.34 秒）"],["feed","放回音效","被喂回、黑白特效淡出结束后播放（默认 3.96 秒）"]];let n='<div class="pex-note">每类音效有独立开关（关 = 本地不播，也不广播给别人）；素材每行一个地址，留空用内置默认。</div>';for(const[r,i,o]of t){const s=Array.isArray(e[r])?e[r]:[];n+=`<div class="pex-sec-title">${i}　${this._tgl("soundOn."+r,i+"开关")}</div>
                <div class="pex-note">${o}</div>
                <textarea class="pex-txt" data-pex-sound="${r}" title="${E(o)}" placeholder="https://…">${E(s.join(`
`))}</textarea>`}return n},_sec_about(){return`
            <div class="pex-about-head">玩法说明</div>
            <div class="pex-about-line">1. 制作一瓶饮料，在制作名或雕刻描述里写上触发关键词。</div>
            <div class="pex-about-line">2. 喝下或注射后进入排出等待：眩晕脉冲，前两个表情在三分之一和三分之二处播放。</div>
            <div class="pex-about-line">3. 到排出时刻检查臀部装备位：空则排出，有东西会等待，拿掉立刻排出。</div>
            <div class="pex-about-line">4. 排出时第三个表情与动画同播，画面剧烈震动并模糊。</div>
            <div class="pex-about-line">5. 人格凝胶排出后失神：黑白、不能动、禁言、不眨眼、视野变暗，凝胶落在脚边。</div>
            <div class="pex-about-line">6. 点击失神者，在对话框中捡起凝胶，交还原主人喂回即恢复；到期按设置消散或变无效凝胶。</div>
            <div class="pex-about-line">7. 普通凝胶排出后没有失神限制，凝胶同样可以捡起和喂回。</div>
            <div class="pex-about-line">8. 安全：随时使用基本设置中的强制恢复，或输入 /pex reset yes。</div>
            <div class="pex-about-head">指令</div>
            <div class="pex-about-line">/pex help 帮助　/pex howto 玩法说明　/pex status 当前状态</div>
            <div class="pex-about-line">/pex show 控制台面板　/pex settings 打开设置　/pex reset 强制恢复</div>
            <div class="pex-about-head">版本</div>
                <div class="pex-about-line">Personality Excretion v${N}</div>
            <div class="pex-about-head">调试</div>
            <div class="pex-about-line">按 F12 打开浏览器控制台，把 ⚗️[PEX] 开头的报错信息发给作者。</div>
            <div class="pex-about-head">数据</div>
            <div class="pex-btn-row">
                <button type="button" class="pex-act" data-pex-action="exportCfg">导出设置</button>
                <button type="button" class="pex-act" data-pex-action="importCfg">导入设置</button>
                <button type="button" class="pex-act danger" data-pex-action="reset">恢复默认</button>
            </div>
            <div class="pex-about-head">音效素材</div>
            <div class="pex-about-line">默认音效素材来自 pincree.jp 的免费资源（Free Assets）。</div>`}};function Ai(){const e=()=>{try{return typeof PreferenceRegisterExtensionSetting!="function"?!1:(PreferenceRegisterExtensionSetting({Identifier:gt,ButtonText:"人格排泄 PEX",load:()=>V.load(),run:()=>V.run(),click:()=>V.click(),unload:()=>V.unload(),exit:()=>V.exit()}),!0)}catch(r){return p("设置页注册失败:",r.message),!1}};if(e())return;let t=0;const n=setInterval(()=>{t++,(e()||t>30)&&clearInterval(n)},1e3)}function Lt(e,t,n){if(t==null)return!1;const r=Number(t);if(!Number.isFinite(r)||r<=0)return!1;for(const i of e||[]){const o=String(i).trim();if(/^\d+$/.test(o)){if(Number(o)===r)return!0;continue}try{if(o==="$owner"){if(n&&typeof n.IsOwnedByMemberNumber=="function"&&n.IsOwnedByMemberNumber(r))return!0}else if(o==="$lover"||o==="$lovers"){if(n&&typeof n.IsLoverOfMemberNumber=="function"&&n.IsLoverOfMemberNumber(r))return!0;const s=n&&n.Lovership;if(Array.isArray(s)&&s.map(Number).includes(r))return!0}}catch{}}return!1}function Ln(e){try{return e?.OnlineSharedSettings?.["PEX"]?.state||null}catch{return null}}function _i(e){try{const t=Ln(e);if(!t||!t.remainingSec||t.remainingSec<=0||t.mode!=="waiting"&&t.mode!=="blocked"&&t.mode!=="blank")return!1;const n=e?.MemberNumber!=null&&Player?.MemberNumber!=null&&e.MemberNumber===Player.MemberNumber,r=t.timerVisibility||l.timerVisibility||"all";if(r==="all"||r==="both")return!0;if(r==="self")return n;if(r==="others")return!n;if(r==="whitelist"){if(n)return!0;const i=e?.OnlineSharedSettings?.["PEX"]?.wl||[];return Lt(i,Player?.MemberNumber,e)}return!1}catch{return!1}}function Ni(e){const t=Math.max(0,Math.ceil(e)),n=Math.floor(t/60);return String(n).padStart(2,"0")+":"+String(t%60).padStart(2,"0")}function ki(e,t,n,r,i){const o=r||1,s=t+100*o,a=n+95*o;let c;i.expiresAt>0?c=Math.max(0,Math.ceil((i.expiresAt-Date.now())/1e3)):c=Math.max(0,i.remainingSec||0);const u=Ni(c);let d=null;const h=typeof MainCanvas<"u"?MainCanvas:null;if(h)try{d=h.font,h.font="600 "+Math.max(12,Math.round(15*o))+'px "Segoe UI", Arial, sans-serif'}catch{}if(DrawText(u,s+1,a+1,"Black",""),DrawText(u,s,a,"#ffffff",""),h&&d!=null)try{h.font=d}catch{}}function Ii(){const e=U();if(e)try{e.hookFunction("ChatRoomCharacterViewDrawOverlay",1,(t,n)=>{const r=n(t);try{if(typeof ChatRoomHideIconState<"u"&&ChatRoomHideIconState>=2)return r;const[i,o,s,a]=t;if(!i||!_i(i))return r;const c=Ln(i);ki(i,o,s,a,c)}catch{}return r})}catch(t){console.warn("⚗️[PEX] 计时器挂钩失败:",t.message)}}const L={x:1715,y:175,w:90,h:90},ve="pex-remote-panel",On=[{key:"time",label:"时间类"},{key:"autoRevert",label:"凝胶自动回归"},{key:"timerVisibility",label:"计时器可见性"}];function tt(e,t,n){return t==="any"?!0:t==="whitelist"?Lt(e?.wl,Player?.MemberNumber,n):!1}function $n(e,t){const n=e?.editModes||{};return{time:tt(e,n.time,t),autoRevert:tt(e,n.autoRevert,t),timerVisibility:tt(e,n.timerVisibility,t)}}function Ti(e){return!!(e&&(e.time||e.autoRevert||e.timerVisibility))}const W={},he={},Ot=6e4,Ci=8e3;function Bn(e){const t=Number(e),n=Date.now(),r=W[t];r&&n-r.ts<Ot||he[t]&&n-he[t]<Ci||(he[t]=n,P("PEX_PermQuery",[{Tag:"PEX_PermQuery",Target:t}]))}function Ri(e,t){const n=W[e?.MemberNumber];return n&&Date.now()-n.ts<Ot?n:{perms:$n(t,e),values:null,ts:Date.now()}}function yt(e){try{return e?.OnlineSharedSettings?.["PEX"]||null}catch{return null}}function an(){try{return typeof InformationSheetSelection<"u"?InformationSheetSelection:null}catch{return null}}const y={open:!1,target:null,perms:{},values:{},dirty:!1};function Di(){let e=document.getElementById(ve);e||(e=document.createElement("div"),e.id=ve,Object.assign(e.style,{position:"fixed",left:"50%",top:"50%",transform:"translate(-50%,-50%)",width:"380px",background:"#1e1930",border:"2px solid #f27ba8",borderRadius:"12px",color:"#e8e4f5",fontFamily:"sans-serif",fontSize:"13px",padding:"16px",zIndex:"2147483646",boxShadow:"0 8px 40px rgba(0,0,0,.6)",maxHeight:"80vh",overflowY:"auto"}),document.body.appendChild(e)),e.style.display="block",y.open=!0,Fn(e)}function ht(){const e=document.getElementById(ve);e&&(e.style.display="none"),y.open=!1}function Ae(e){return String(e??"").replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;")}function Fn(e){const t=y.target&&ne(y.target)||"对方";let n=`<div style="display:flex;justify-content:space-between;align-items:center;margin-bottom:10px">
        <b style="color:#f27ba8">编辑 ${Ae(t)} 的 PEX 设置</b>
        <button id="pex-remote-close" style="background:#3a2a4a;color:#e8e4f5;border:none;border-radius:6px;padding:4px 10px;cursor:pointer">✕</button>
    </div>`;const r=(s,a,c)=>{const u=!!y.perms[s];n+=`<div style="margin:8px 0;opacity:${u?1:.45}">
            <div style="color:#9b93bd;margin-bottom:4px">${a}${u?"":" 🔒"}</div>${c}</div>`};r("time","排出前等待（秒，0~600）",`<input id="pex-r-wait" type="number" min="0" max="600" value="${Ae(y.values.waitSeconds)}" ${y.perms.time?"":"disabled"}
         style="width:100%;background:#241d3a;color:#e8e4f5;border:1px solid #37305a;border-radius:6px;padding:6px">`),r("time","阻挡等待上限（分钟，1~30）",`<input id="pex-r-blocked" type="number" min="1" max="30" value="${Ae(y.values.blockedWaitMinutes)}" ${y.perms.time?"":"disabled"}
         style="width:100%;background:#241d3a;color:#e8e4f5;border:1px solid #37305a;border-radius:6px;padding:6px">`),r("time","凝胶自动回归（分钟，1~30）",`<input id="pex-r-autorev" type="number" min="1" max="30" value="${Ae(y.values.autoRevertMinutes)}" ${y.perms.time?"":"disabled"}
         style="width:100%;background:#241d3a;color:#e8e4f5;border:1px solid #37305a;border-radius:6px;padding:6px">`),r("timerVisibility","计时器可见性",`<select id="pex-r-vis" ${y.perms.timerVisibility?"":"disabled"}
         style="width:100%;background:#2a6b63;color:#fff;border:1px solid #37305a;border-radius:6px;padding:6px">
         <option value="self" ${y.values.timerVisibility==="self"?"selected":""}>仅自己</option>
         <option value="whitelist" ${y.values.timerVisibility==="whitelist"?"selected":""}>仅白名单</option>
         <option value="others" ${y.values.timerVisibility==="others"?"selected":""}>仅他人</option>
         <option value="all" ${(y.values.timerVisibility||"all")==="all"?"selected":""}>所有人</option></select>`),r("autoRevert","自动回归开关",`<select id="pex-r-ar" ${y.perms.autoRevert?"":"disabled"}
         style="width:100%;background:#2a6b63;color:#fff;border:1px solid #37305a;border-radius:6px;padding:6px">
         <option value="1" ${y.values.autoRevertEnabled?"selected":""}>开启</option>
         <option value="0" ${y.values.autoRevertEnabled?"":"selected"}>关闭</option></select>`);const i=Object.values(y.perms).some(Boolean);n+=`<div style="display:flex;gap:8px;margin-top:14px">
        <button id="pex-remote-save" style="flex:1;background:${i?"#2a6b63":"#3a2a4a"};color:#fff;border:none;border-radius:8px;padding:8px;cursor:${i?"pointer":"not-allowed"}" ${i?"":"disabled"}>保存</button>
        <button id="pex-remote-refresh" style="flex:1;background:#3a2a4a;color:#e8e4f5;border:none;border-radius:8px;padding:8px;cursor:pointer">刷新</button>
    </div>`,n+='<div style="color:#9b93bd;font-size:11px;margin-top:8px">仅可编辑有权限的类别（🔒=无权限）</div>',e.innerHTML=n,e.querySelector("#pex-remote-close").onclick=()=>ht(),e.querySelector("#pex-remote-refresh").onclick=()=>{if(!y.target)return;const s=Number(y.target.MemberNumber);delete W[s],delete he[s],Bn(s),v("正在刷新权限与设置…",3e3)};const o=e.querySelector("#pex-remote-save");o&&(o.onclick=()=>Oi())}const nt={};let O=null,H=null;function Li(e){const t=Number(e?.MemberNumber);if(t==null)return;const n=W[t];if(n&&Date.now()-n.ts<Ot){Xn(e);return}O={num:t,C:e},he[t]=Date.now(),P("PEX_PermQuery",[{Tag:"PEX_PermQuery",Target:t}],{priority:!0});const r=ne(e)||String(t);v(x("remoteEditLoading",{name:r}),4e3),H&&clearTimeout(H),H=setTimeout(()=>{H=null,O&&O.num===t&&(O=null,v(x("remoteEditLoadFail",{name:r}),8e3))},6e3)}function Xn(e){const t=e.MemberNumber,n=Date.now();t!=null&&(!nt[t]||n-nt[t]>15e3)&&(nt[t]=n,P("PEX_Access",[{Tag:"PEX_Access",Target:t,Name:String(ne(Player)||Player?.MemberNumber||"")}],{dedupeKey:"access:"+t,dedupeMs:15e3})),y.target=e;const r=W[t];y.perms=r?r.perms:$n(yt(e),e),y.values=r&&r.values?r.values:{},Di()}function Oi(){const e=document.getElementById(ve);if(!e||!y.target)return;const t=i=>{try{return e.querySelector(i)?.value}catch{return}},n={waitSeconds:t("#pex-r-wait")!==void 0?parseInt(t("#pex-r-wait"),10):void 0,blockedWaitMinutes:t("#pex-r-blocked")!==void 0?parseInt(t("#pex-r-blocked"),10):void 0,autoRevertMinutes:t("#pex-r-autorev")!==void 0?parseInt(t("#pex-r-autorev"),10):void 0,timerVisibility:t("#pex-r-vis"),autoRevertEnabled:t("#pex-r-ar")==="1"},r={};for(const i of On)y.perms[i.key]&&(i.key==="time"?(n.waitSeconds!=null&&(r.waitSeconds=te(n.waitSeconds,0,600)),n.blockedWaitMinutes!=null&&(r.blockedWaitMinutes=te(n.blockedWaitMinutes,1,30)),n.autoRevertMinutes!=null&&(r.autoRevertMinutes=te(n.autoRevertMinutes,1,30))):i.key==="timerVisibility"?["self","whitelist","others","all"].includes(n.timerVisibility)&&(r.timerVisibility=n.timerVisibility):i.key==="autoRevert"&&(r.autoRevertEnabled=!!n.autoRevertEnabled));Object.keys(r).length!==0&&(P("PEX_RemoteSet",[{Tag:"PEX_RemoteSet",Target:String(y.target?.MemberNumber),Values:r}]),v("已发送设置修改请求，等待对方确认…",6e3))}function te(e,t,n){return Math.max(t,Math.min(n,e))}function $i(){ie(e=>{try{if(e?.Type!=="Hidden")return;const t=Array.isArray(e.Dictionary)?e.Dictionary:[],n=o=>{const s=t.find(a=>a?.Tag===o);if(s)return s.Value??s.Name;for(const a of t)if(a&&typeof a=="object"&&a.Tag&&o in a)return a[o]},r=Number(e.Sender),i=o=>{const s=(l.editModes||{})[o]||"off";return s==="any"?!0:s==="whitelist"?Lt(l.whitelist||[],r,Player):!1};if(e.Content==="PEX_PermQuery"&&Number(n("Target"))===Player?.MemberNumber){const o={};On.forEach(s=>{o[s.key]=i(s.key)}),P("PEX_PermReply",[{Tag:"PEX_PermReply",Target:String(r),Perms:o,Values:{waitSeconds:l.waitSeconds,blockedWaitMinutes:l.blockedWaitMinutes,autoRevertMinutes:l.autoRevertMinutes,autoRevertEnabled:l.autoRevertEnabled,timerVisibility:l.timerVisibility}}],{priority:!0,dedupeKey:"permr:"+r,dedupeMs:500})}else if(e.Content==="PEX_RemoteSet"&&Number(n("Target"))===Player?.MemberNumber){const o=n("Values")||{};i("time")&&(o.waitSeconds!=null&&(l.waitSeconds=te(+o.waitSeconds,0,600)),o.blockedWaitMinutes!=null&&(l.blockedWaitMinutes=te(+o.blockedWaitMinutes,1,30)),o.autoRevertMinutes!=null&&(l.autoRevertMinutes=te(+o.autoRevertMinutes,1,30))),i("timerVisibility")&&["self","whitelist","others","all"].includes(o.timerVisibility)&&(l.timerVisibility=o.timerVisibility),i("autoRevert")&&o.autoRevertEnabled!==void 0&&(l.autoRevertEnabled=!!o.autoRevertEnabled),_(!0),ge(!0),P("PEX_RemoteAck",[{Tag:"PEX_RemoteAck",Target:String(r)}]);const s=ne(r)||String(r);v(x("editedYourPEX",{who:s}),8e3)}}catch(t){p("远程协议异常:",t.message)}})}function Bi(){ie(e=>{try{if(e?.Type!=="Hidden")return;const t=Array.isArray(e.Dictionary)?e.Dictionary:[],n=r=>{const i=t.find(o=>o?.Tag===r);if(i)return i.Value??i.Name;for(const o of t)if(o&&typeof o=="object"&&o.Tag&&r in o)return o[r]};if(e.Content==="PEX_PermReply"&&Number(n("Target"))===Player?.MemberNumber){const r=Number(e.Sender);if(W[r]={perms:n("Perms")||{},values:n("Values")||{},ts:Date.now()},O&&O.num===r){const i=O.C;O=null,H&&(clearTimeout(H),H=null);let o=!1;try{o=typeof CurrentScreen<"u"&&CurrentScreen==="InformationSheet"&&typeof InformationSheetSelection<"u"&&InformationSheetSelection&&Number(InformationSheetSelection.MemberNumber)===r}catch{}o&&Xn(i)}else if(y.open&&y.target?.MemberNumber===r){const i=W[r];y.perms=i.perms,y.values=i.values;const o=document.getElementById(ve);o&&Fn(o)}}else if(e.Content==="PEX_Access"&&Number(n("Target"))===Player?.MemberNumber){const r=n("Name")||(()=>{try{return ChatRoomCharacter?.find(i=>i.MemberNumber===Number(e.Sender))?.Nickname}catch{return null}})()||e.Sender;v(x("accessedYourPEX",{who:r}),8e3)}else e.Content==="PEX_RemoteAck"&&Number(n("Target"))===Player?.MemberNumber&&v("对方已应用你的设置修改。",6e3)}catch{}})}function Fi(){const e=U();e&&($i(),Bi(),e.hookFunction("InformationSheetRun",5,(t,n)=>{const r=n(t);try{const i=an();y.open&&y.target&&i&&i.MemberNumber!==y.target.MemberNumber&&ht();const o=i&&i.MemberNumber!==Player?.MemberNumber?yt(i):null;if(!o)return r;Bn(i.MemberNumber);const s=Ri(i,o),a=Ti(s.perms),c=a?x("profileEditBtn"):o.edit?x("profileEditNoPerm"):x("profileEditOff");DrawButton(L.x,L.y,L.w,L.h,"REX","White","",c,!a)}catch{}return r}),e.hookFunction("InformationSheetClick",5,(t,n)=>{try{const r=an();if((r&&r.MemberNumber!==Player?.MemberNumber?yt(r):null)&&MouseIn(L.x,L.y,L.w,L.h)){Li(r);return}}catch{}return n(t)}),e.hookFunction("InformationSheetExit",5,(t,n)=>(y.open&&ht(),n(t))))}function Xi(e=3e4){const t=Date.now();return new Promise(n=>{const r=()=>{typeof bcModSdk<"u"&&bcModSdk?.registerMod?n(!0):Date.now()-t>e?n(!1):setTimeout(r,100)};r()})}function Gi(e=3e4){const t=Date.now();return new Promise(n=>{const r=()=>{try{typeof Player<"u"&&typeof CharacterSetFacialExpression=="function"&&typeof ChatRoomCharacter<"u"?n(!0):Date.now()-t>e?n(!1):setTimeout(r,100)}catch{setTimeout(r,100)}};r()})}function Vi(){return new Promise(e=>{const t=()=>{try{typeof ServerIsLoggedIn=="function"&&ServerIsLoggedIn()||typeof Player<"u"&&Player&&typeof Player.MemberNumber=="number"&&Player.MemberNumber>0&&!!Player.AccountName?e(!0):setTimeout(t,200)}catch{setTimeout(t,200)}};t()})}async function Ki(){p(`初始化 v${N}...`);const e=await Xi();if(!await Gi()){Oe("游戏加载超时，放弃初始化");return}if(await Jn(),await Vi(),await rr(),dn(),Br(),ge(!0),e)try{qn(bcModSdk.registerMod({name:"Personality Excretion (PEX)",fullName:"Personality Excretion",version:N}))}catch(o){Oe("registerMod 失败，进入兼容模式:",o.message)}const n=U();n&&(ot(n),ln(n),ur(n),ai(()=>{ti(),setTimeout(()=>{try{ge(!0)}catch{}},800),setTimeout(()=>{try{f.mode!==m.IDLE&&f.phaseEndsAt>0&&(p("进房还原状态:",f.mode),T({mode:f.mode,remainingSec:Math.max(0,Math.round((f.phaseEndsAt-Date.now())/1e3)),owner:f.ownerMemberNumber,gelId:f.gelId},!0))}catch{}},1500)},()=>{}),si(()=>{try{Si()}catch{}try{ot&&Hi()}catch{}})),ni(),Ei(),Ai(),Ii(),Fi();try{typeof window<"u"&&!window._pexUnloadFlush&&(window._pexUnloadFlush=()=>{try{typeof ServerAccountUpdate?.SyncToServer=="function"&&ServerAccountUpdate.SyncToServer()}catch{}},window.addEventListener("pagehide",window._pexUnloadFlush),window.addEventListener("beforeunload",window._pexUnloadFlush))}catch{}p(`初始化完成 v${N}`);let r=!1;const i=setInterval(()=>{try{if(typeof CurrentScreen>"u"||CurrentScreen!=="ChatRoom"||(clearInterval(i),r))return;r=!0,setTimeout(()=>v(x("loaded",{v:N})),1e3)}catch{clearInterval(i)}},500)}function Hi(){oi(()=>Promise.resolve().then(()=>tr),void 0,import.meta.url).then(e=>e.clearMessageHandlers()).catch(()=>{})}const ji="https://cdn.jsdelivr.net/gh/Nice8923/BC-PEX@main/Images/",zi="https://raw.githubusercontent.com/Nice8923/BC-PEX/main/Images/";function Gn(e){return ji+String(e).replace(/^\//,"")}function Vn(e){return zi+String(e).replace(/^\//,"")}function Wi(e,t){const n=new Image;n.crossOrigin="anonymous";let r=0;return n.addEventListener("load",()=>{try{t&&t(n)}catch{}}),n.addEventListener("error",()=>{r===0?(r=1,Oe("图片 CDN 加载失败，回退 raw:",e),n.src=Vn(e)):Oe("图片加载失败:",e)}),n.src=Gn(e),n}function Ui(e,t,n,r,i){const o=Math.max(1,e||1),s=Math.max(1,t||1),a=Math.max(0,n||0);return{sx:a%o*r,sy:Math.floor(a/o)%s*i,sw:r,sh:i}}window.PEX=window.PEX??{};const Yi=window.PEX&&typeof window.PEX=="object"&&!!window.PEX.version;Yi?console.warn(`⚗️[PEX] 检测到已有实例在运行（version: ${window.PEX.version}），跳过重复初始化。`):(window.PEX={version:N,command:(e="")=>Ct(`/pex ${e}`.trim()),reset:()=>We(),status:()=>mn(),getConfig:()=>l,save:()=>_(!0),reload:()=>dn(),setAnimDurationOverride:Lr,images:{imageUrl:Gn,imageFallbackUrl:Vn,loadPexImage:Wi,spriteFrame:Ui},exportSettings:fn,importSettings:pn},Ki());
';
     const run = () => {
         // 优先 data: URL 模块导入；若被 CSP 拦截时退回全局 eval
         try {
diff --git a/loader.local.user.js b/loader.local.user.js
index bf97efa..7f48916 100644
--- a/loader.local.user.js
+++ b/loader.local.user.js
@@ -7,12 +7,11 @@
 // @description:en  PEX local-dev loader (loads the build from vite preview)
 // @author       PEX
 // @supportURL   https://github.com/Nice8923/BC-PEX
-// @include      /^https:\/\/(www\.)?bondage(projects\.elementfx|-(europe|asia))\.com\/.*/
+// @include      /^https?:\/\/(www\.)?(bondageprojects\.com|bondageprojects\.elementfx\.com|bondage-europe\.com|bondage-asia\.com)\/.*/
 // @grant        none
 // @run-at       document-end
 // ==/UserScript==
 
-window.PEX = window.PEX ?? {};
 if (window.PEX) {
     console.warn('⚗️[PEX] 已加载，跳过重复导入。');
 } else {
diff --git a/loader.template.user.js b/loader.template.user.js
index 7028a47..e42f7e7 100644
--- a/loader.template.user.js
+++ b/loader.template.user.js
@@ -7,12 +7,11 @@
 // @description:en  Persona excretion gameplay: dizzy → excrete → blank → gel → feed-back recovery. Built-in sounds & expressions, /pex commands.
 // @author       PEX
 // @supportURL   https://github.com/Nice8923/BC-PEX
-// @include      /^https:\/\/(www\.)?bondage(projects\.elementfx|-(europe|asia))\.com\/.*/
+// @include      /^https?:\/\/(www\.)?(bondageprojects\.com|bondageprojects\.elementfx\.com|bondage-europe\.com|bondage-asia\.com)\/.*/
 // @grant        none
 // @run-at       document-end
 // ==/UserScript==
 
-window.PEX = window.PEX ?? {};
 if (window.PEX) {
     console.warn('⚗️[PEX] 已加载，跳过重复加载。');
 } else {
diff --git a/loader.user.js b/loader.user.js
index 7c497ce..f7265d4 100644
--- a/loader.user.js
+++ b/loader.user.js
@@ -7,13 +7,12 @@
 // @description:en  Persona excretion gameplay: dizzy → excrete → blank → gel → feed-back recovery. Supports /pex commands.
 // @author       PEX
 // @supportURL   https://github.com/Nice8923/BC-PEX
-// @include      /^https:\/\/(www\.)?bondage(projects\.elementfx|-(europe|asia))\.com\/.*/
+// @include      /^https?:\/\/(www\.)?(bondageprojects\.com|bondageprojects\.elementfx\.com|bondage-europe\.com|bondage-asia\.com)\/.*/
 // @grant        none
 // @run-at       document-end
 // ==/UserScript==
 
 // 薄加载器：从发布地址拉取构建产物（assets/main.js，GitHub Pages）。
-window.PEX = window.PEX ?? {};
 if (window.PEX) {
     console.warn('⚗️[PEX] 已加载，跳过重复导入。');
 } else {
diff --git a/src/core/commands.js b/src/core/commands.js
index 7843758..92218f8 100644
--- a/src/core/commands.js
+++ b/src/core/commands.js
@@ -134,8 +134,11 @@ function tryRegisterCommand() {
     return false;
 }
 
-// 策略3：keydown Enter 兜底
+// 策略3：keydown Enter 兜底（单例守卫：core-init 顶层 hookChatInput 与进房后 registerCommandOnce 都会调它，避免重复挂监听导致 /pex 触发两次）
+let _keyDownHooked = false;
 function setupKeydownFallback() {
+    if (_keyDownHooked) return;
+    _keyDownHooked = true;
     document.addEventListener('keydown', (e) => {
         if (e.key !== 'Enter') return;
         const input = document.getElementById('InputChat') || document.querySelector('textarea[id*="Chat"]');
diff --git a/src/core/whitelist.js b/src/core/whitelist.js
new file mode 100644
index 0000000..dc0de6a
--- /dev/null
+++ b/src/core/whitelist.js
@@ -0,0 +1,35 @@
+// ════════════════════════════════════════
+//  白名单代号解析
+//  配置里的 whitelist 可填数字成员号，或代号：
+//    $owner  —— 被授权方（目标本人）的主人
+//    $lover  —— 被授权方（目标本人）的恋人
+//  比较时 relativeTo 必须是【被授权方本人】的角色对象：
+//    查看者端 = 被看的角色 C；接收端 = Player（接收方即被授权方）。
+//  代号相对它解析。两条 BC 原生 API（Character 原型方法）：
+//    IsOwnedByMemberNumber(n) / IsLoverOfMemberNumber(n)
+// ════════════════════════════════════════
+
+// candidate：要判断的成员号（查看者 / 发送者）。返回是否放行。
+export function whitelistAllows(list, candidate, relativeTo) {
+    if (candidate == null) return false;
+    const c = Number(candidate);
+    if (!Number.isFinite(c) || c <= 0) return false;
+    for (const e of (list || [])) {
+        const s = String(e).trim();
+        if (/^\d+$/.test(s)) { if (Number(s) === c) return true; continue; }
+        try {
+            // 代号相对被授权方本人解析；各方法独立判断，缺哪个都不影响其它代号
+            if (s === '$owner') {
+                if (relativeTo && typeof relativeTo.IsOwnedByMemberNumber === 'function'
+                    && relativeTo.IsOwnedByMemberNumber(c)) return true;
+            } else if (s === '$lover' || s === '$lovers') {
+                if (relativeTo && typeof relativeTo.IsLoverOfMemberNumber === 'function'
+                    && relativeTo.IsLoverOfMemberNumber(c)) return true;
+                // 兜底：方法缺失时直接查 Lovership 数组
+                const lv = relativeTo && relativeTo.Lovership;
+                if (Array.isArray(lv) && lv.map(Number).includes(c)) return true;
+            }
+        } catch (e) {}
+    }
+    return false;
+}
diff --git a/src/ui/remote.js b/src/ui/remote.js
index 5c86d51..13c9bb8 100644
--- a/src/ui/remote.js
+++ b/src/ui/remote.js
@@ -15,6 +15,7 @@ import { saveSettings, publishSharedSettings } from '../core/storage.js';
 import { printChat } from '../core/commands.js';
 import { ui } from '../expansion/i18n.js';
 import { pexLog, characterNicknameSafe } from '../util/util.js';
+import { whitelistAllows } from '../core/whitelist.js';
 
 const BTN = { x: 1715, y: 175, w: 90, h: 90 };   // 资料页远程修改按钮
 const PANEL_ID = 'pex-remote-panel';
@@ -27,20 +28,20 @@ const CATS = [
 ];
 
 // 我方对目标是否有某类权限（对方公告快照兜底——实时回复到达前先用它）
-function _viewerCanEdit(info, mode) {
+// codeRef = 被授权方本人（被看的角色 C）：白名单里的 $owner/$lover 相对它解析
+function _viewerCanEdit(info, mode, codeRef) {
     if (mode === 'any') return true;
     if (mode === 'whitelist') {
-        const wl = Array.isArray(info?.wl) ? info.wl.map(Number) : [];
-        return wl.includes(Number(Player?.MemberNumber));
+        return whitelistAllows(info?.wl, Player?.MemberNumber, codeRef);
     }
     return false;
 }
-function _viewerPerms(info) {
+function _viewerPerms(info, codeRef) {
     const em = info?.editModes || {};
     return {
-        time: _viewerCanEdit(info, em.time),
-        autoRevert: _viewerCanEdit(info, em.autoRevert),
-        timerVisibility: _viewerCanEdit(info, em.timerVisibility),
+        time: _viewerCanEdit(info, em.time, codeRef),
+        autoRevert: _viewerCanEdit(info, em.autoRevert, codeRef),
+        timerVisibility: _viewerCanEdit(info, em.timerVisibility, codeRef),
     };
 }
 function _canEditAny(perms) {
@@ -68,7 +69,7 @@ function _ensurePerm(num) {
 function _permFor(C, info) {
     const pc = _permCache[C?.MemberNumber];
     if (pc && Date.now() - pc.ts < PERM_TTL) return pc;
-    return { perms: _viewerPerms(info), values: null, ts: Date.now() };
+    return { perms: _viewerPerms(info, C), values: null, ts: Date.now() };
 }
 
 function targetInfo(C) {
@@ -221,7 +222,7 @@ function _doOpenRemoteSettings(C) {
     }
     R.target = C;
     const pc = _permCache[num];
-    R.perms = pc ? pc.perms : _viewerPerms(targetInfo(C));
+    R.perms = pc ? pc.perms : _viewerPerms(targetInfo(C), C);
     R.values = (pc && pc.values) ? pc.values : {};
     showPanel();
 }
@@ -281,8 +282,8 @@ function registerRemoteServer() {
                 const m = (CONFIG.editModes || {})[catKey] || 'off';
                 if (m === 'any') return true;
                 if (m === 'whitelist') {
-                    const wl = (CONFIG.whitelist || []).map(String);
-                    return wl.includes(String(sender));
+                    // 白名单相对【被授权方本人】解析：这里是接收方自己（Player）
+                    return whitelistAllows(CONFIG.whitelist || [], sender, Player);
                 }
                 return false;
             };
diff --git a/src/ui/settings.js b/src/ui/settings.js
index 250ae28..a25f1b0 100644
--- a/src/ui/settings.js
+++ b/src/ui/settings.js
@@ -247,7 +247,11 @@ const EXT = {
         content.addEventListener('change', (e) => {
             const t = e.target;
             if (t.dataset.pexSelect) {
-                this._setPath(t.dataset.pexSelect, t.value);
+                // 数值型下拉（特效强度/失神视野）存数字而非字符串，保持类型一致；
+                // 纯数字值才转（其余如计时器可见性、表情名仍为字符串）
+                const raw = t.value;
+                const num = Number(raw);
+                this._setPath(t.dataset.pexSelect, (raw !== '' && /^\d+$/.test(raw) && !isNaN(num)) ? num : raw);
                 // 表情下拉 → 刷新预览（新结构：expressions.wait.N / expressions.excrete / blank）
                 const sel = t.dataset.pexSelect;
                 if (sel.startsWith('expressions.wait.')) {
@@ -336,7 +340,9 @@ const EXT = {
     },
     _sel(key, options, desc) {
         const val = this._getPath(key);
-        return `<select class="pex-sel" data-pex-select="${key}" title="${esc(desc || '')}">${options.map(([v, l]) => `<option value="${v}" ${val === v ? 'selected' : ''}>${esc(l)}</option>`).join('')}</select>`;
+        // 用字符串比较判定选中：特效强度/失神视野等数值型下拉，
+        // 旧存档可能存成字符串 "3"，与数字 3 严格比较会全部落空 → 下拉回退到第一项
+        return `<select class="pex-sel" data-pex-select="${key}" title="${esc(desc || '')}">${options.map(([v, l]) => `<option value="${v}" ${String(val) === String(v) ? 'selected' : ''}>${esc(l)}</option>`).join('')}</select>`;
     },
     _num(key, min, max, desc) {
         return `<input type="number" class="pex-num" data-pex-number="${key}" min="${min}" max="${max}" value="${this._getPath(key)}" title="${esc(desc || '')}">`;
diff --git a/src/ui/timer.js b/src/ui/timer.js
index 1504e90..329e60b 100644
--- a/src/ui/timer.js
+++ b/src/ui/timer.js
@@ -6,6 +6,7 @@
 
 import { CONFIG, ES_KEY } from '../core/config.js';
 import { getModApi } from '../core/config.js';
+import { whitelistAllows } from '../core/whitelist.js';
 
 // 读角色的 PEX 公告状态
 function readState(C) {
@@ -27,11 +28,11 @@ function shouldDraw(C) {
         if (vis === 'self') return isMe;
         if (vis === 'others') return !isMe;
         if (vis === 'whitelist') {
-            // 仅白名单：自己总能看到自己的；别人要看他在不在被观察者公告的白名单里
+            // 仅白名单：自己总能看到自己的；别人要看他在不在被观察者公告的白名单里。
+            // 白名单相对【被观察者本人】解析：$owner/$lover = 被观察者自己的主人/恋人
             if (isMe) return true;
             const wl = C?.OnlineSharedSettings?.[ES_KEY]?.wl || [];
-            const myNo = Player?.MemberNumber;
-            return wl.includes(String(myNo));
+            return whitelistAllows(wl, Player?.MemberNumber, C);
         }
         return false;
     } catch (e) { return false; }