1574 lines
56 KiB
TypeScript
1574 lines
56 KiB
TypeScript
import DOMPurify from 'isomorphic-dompurify';
|
|
import { Marked } from 'marked';
|
|
|
|
import { DataBase, setDatabase, type Database, type Message, type character, type customscript, type groupChat } from './storage/database';
|
|
import { getFileSrc } from './storage/globalApi';
|
|
import { processScriptFull } from './process/scripts';
|
|
import { get } from 'svelte/store';
|
|
import css from '@adobe/css-tools'
|
|
import { selectedCharID } from './stores';
|
|
import { calcString } from './process/infunctions';
|
|
import { findCharacterbyId, parseKeyValue, sfc32, uuidtoNumber } from './util';
|
|
import { getInlayImage } from './process/files/image';
|
|
import { risuFormater } from './plugins/automark';
|
|
import { getModuleLorebooks } from './process/modules';
|
|
|
|
const mconverted = new Marked({
|
|
gfm: true,
|
|
breaks: true,
|
|
silent: true,
|
|
tokenizer: {
|
|
del(src) {
|
|
const cap = /^~~~(?=\S)([\s\S]*?\S)~~~/.exec(src);
|
|
if (cap) {
|
|
return {
|
|
type: 'del',
|
|
raw: cap[0],
|
|
text: cap[1],
|
|
tokens: this.lexer.inlineTokens(cap[1])
|
|
};
|
|
}
|
|
}
|
|
}
|
|
})
|
|
|
|
|
|
|
|
DOMPurify.addHook("uponSanitizeElement", (node: HTMLElement, data) => {
|
|
if (data.tagName === "iframe") {
|
|
const src = node.getAttribute("src") || "";
|
|
if (!src.startsWith("https://www.youtube.com/embed/")) {
|
|
return node.parentNode.removeChild(node);
|
|
}
|
|
}
|
|
});
|
|
|
|
DOMPurify.addHook("uponSanitizeAttribute", (node, data) => {
|
|
switch(data.attrName){
|
|
case 'style':{
|
|
data.attrValue = data.attrValue.replace(/(absolute)|(z-index)|(fixed)/g, '')
|
|
break
|
|
}
|
|
case 'class':{
|
|
if(data.attrValue){
|
|
data.attrValue = data.attrValue.split(' ').map((v) => {
|
|
return "x-risu-" + v
|
|
}).join(' ')
|
|
}
|
|
break
|
|
}
|
|
case 'href':{
|
|
if(data.attrValue.startsWith('http://') || data.attrValue.startsWith('https://')){
|
|
node.setAttribute('target', '_blank')
|
|
break
|
|
}
|
|
data.attrValue = ''
|
|
break
|
|
}
|
|
}
|
|
})
|
|
|
|
|
|
export const assetRegex = /{{(raw|img|video|audio|bg|emotion|asset|video-img)::(.+?)}}/g
|
|
|
|
async function parseAdditionalAssets(data:string, char:simpleCharacterArgument|character, mode:'normal'|'back', mode2:'unset'|'pre'|'post' = 'unset'){
|
|
const db = get(DataBase)
|
|
const assetWidthString = (db.assetWidth && db.assetWidth !== -1 || db.assetWidth === 0) ? `max-width:${db.assetWidth}rem;` : ''
|
|
|
|
if(char.additionalAssets || char.emotionImages){
|
|
|
|
let assetPaths:{[key:string]:{
|
|
path:string
|
|
ext?:string
|
|
}} = {}
|
|
let emoPaths:{[key:string]:{
|
|
path:string
|
|
}} = {}
|
|
|
|
if(char.additionalAssets){
|
|
for(const asset of char.additionalAssets){
|
|
const assetPath = await getFileSrc(asset[1])
|
|
assetPaths[asset[0].toLocaleLowerCase()] = {
|
|
path: assetPath,
|
|
ext: asset[2]
|
|
}
|
|
}
|
|
}
|
|
if(char.emotionImages){
|
|
for(const emo of char.emotionImages){
|
|
const emoPath = await getFileSrc(emo[1])
|
|
emoPaths[emo[0].toLocaleLowerCase()] = {
|
|
path: emoPath,
|
|
}
|
|
}
|
|
}
|
|
const videoExtention = ['mp4', 'webm', 'avi', 'm4p', 'm4v']
|
|
data = data.replaceAll(assetRegex, (full:string, type:string, name:string) => {
|
|
name = name.toLocaleLowerCase()
|
|
if(type === 'emotion'){
|
|
const path = emoPaths[name]?.path
|
|
if(!path){
|
|
return ''
|
|
}
|
|
return `<img src="${path}" alt="${path}" style="${assetWidthString} "/>`
|
|
}
|
|
const path = assetPaths[name]
|
|
if(!path){
|
|
return ''
|
|
}
|
|
switch(type){
|
|
case 'raw':
|
|
return path.path
|
|
case 'img':
|
|
return `<img src="${path.path}" alt="${path.path}" style="${assetWidthString} "/>`
|
|
case 'video':
|
|
return `<video controls autoplay loop><source src="${path.path}" type="video/mp4"></video>`
|
|
case 'video-img':
|
|
return `<video autoplay muted loop><source src="${path.path}" type="video/mp4"></video>`
|
|
case 'audio':
|
|
return `<audio controls autoplay loop><source src="${path.path}" type="audio/mpeg"></audio>`
|
|
case 'bg':
|
|
if(mode === 'back'){
|
|
return `<div style="width:100%;height:100%;background: linear-gradient(rgba(0, 0, 0, 0.8), rgba(0, 0, 0, 0.8)),url(${path.path}); background-size: cover;"></div>`
|
|
}
|
|
break
|
|
case 'asset':{
|
|
if(path.ext && videoExtention.includes(path.ext)){
|
|
return `<video autoplay muted loop><source src="${path.path}" type="video/mp4"></video>`
|
|
}
|
|
return `<img src="${path.path}" alt="${path.path}" style="${assetWidthString} "/>`
|
|
}
|
|
}
|
|
return ''
|
|
})
|
|
}
|
|
return data
|
|
}
|
|
|
|
async function parseInlayImages(data:string){
|
|
const inlayMatch = data.match(/{{inlay::(.+?)}}/g)
|
|
if(inlayMatch){
|
|
for(const inlay of inlayMatch){
|
|
const id = inlay.substring(9, inlay.length - 2)
|
|
const img = await getInlayImage(id)
|
|
if(img){
|
|
data = data.replace(inlay, `<img src="${img.data}"/>`)
|
|
}
|
|
}
|
|
}
|
|
return data
|
|
}
|
|
|
|
export interface simpleCharacterArgument{
|
|
type: 'simple'
|
|
additionalAssets?: [string, string, string][]
|
|
customscript: customscript[]
|
|
chaId: string,
|
|
virtualscript?: string
|
|
emotionImages?: [string, string][]
|
|
}
|
|
|
|
|
|
export async function ParseMarkdown(data:string, charArg:(character|simpleCharacterArgument | groupChat | string) = null, mode:'normal'|'back' = 'normal', chatID=-1) {
|
|
let firstParsed = ''
|
|
const orgDat = data
|
|
const db = get(DataBase)
|
|
let char = (typeof(charArg) === 'string') ? (findCharacterbyId(charArg)) : (charArg)
|
|
if(char && char.type !== 'group'){
|
|
data = await parseAdditionalAssets(data, char, mode, 'pre')
|
|
firstParsed = data
|
|
}
|
|
if(char){
|
|
data = (await processScriptFull(char, data, 'editdisplay', chatID)).data
|
|
}
|
|
if(firstParsed !== data && char && char.type !== 'group'){
|
|
data = await parseAdditionalAssets(data, char, mode, 'post')
|
|
}
|
|
data = await parseInlayImages(data)
|
|
|
|
data = encodeStyle(data)
|
|
data = risuFormater(data)
|
|
data = mconverted.parse(data)
|
|
return decodeStyle(DOMPurify.sanitize(data, {
|
|
ADD_TAGS: ["iframe", "style", "risu-style", "x-em"],
|
|
ADD_ATTR: ["allow", "allowfullscreen", "frameborder", "scrolling", "risu-btn", 'risu-trigger', 'risu-mark'],
|
|
}))
|
|
}
|
|
|
|
export function parseMarkdownSafe(data:string) {
|
|
return DOMPurify.sanitize(mconverted.parse(data), {
|
|
FORBID_TAGS: ["a", "style"],
|
|
FORBID_ATTR: ["style", "href", "class"]
|
|
})
|
|
}
|
|
|
|
|
|
const styleRegex = /\<style\>(.+?)\<\/style\>/gms
|
|
function encodeStyle(txt:string){
|
|
return txt.replaceAll(styleRegex, (f, c1) => {
|
|
return "<risu-style>" + Buffer.from(c1).toString('hex') + "</risu-style>"
|
|
})
|
|
}
|
|
const styleDecodeRegex = /\<risu-style\>(.+?)\<\/risu-style\>/gms
|
|
|
|
function decodeStyle(text:string){
|
|
|
|
return text.replaceAll(styleDecodeRegex, (full, txt:string) => {
|
|
try {
|
|
const ast = css.parse(Buffer.from(txt, 'hex').toString('utf-8'))
|
|
const rules = ast?.stylesheet?.rules
|
|
if(rules){
|
|
for(const rule of rules){
|
|
|
|
if(rule.type === 'rule'){
|
|
if(rule.selectors){
|
|
for(let i=0;i<rule.selectors.length;i++){
|
|
let slt:string = rule.selectors[i]
|
|
if(slt){
|
|
let selectors = (slt.split(' ') ?? []).map((v) => {
|
|
if(v.startsWith('.')){
|
|
return ".x-risu-" + v.substring(1)
|
|
}
|
|
return v
|
|
}).join(' ')
|
|
|
|
rule.selectors[i] = ".chattext " + selectors
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return `<style>${css.stringify(ast)}</style>`
|
|
|
|
} catch (error) {
|
|
return `CSS ERROR: ${error}`;
|
|
}
|
|
})
|
|
}
|
|
|
|
export async function hasher(data:Uint8Array){
|
|
return Buffer.from(await crypto.subtle.digest("SHA-256", data)).toString('hex');
|
|
}
|
|
|
|
export async function convertImage(data:Uint8Array) {
|
|
if(!get(DataBase).imageCompression){
|
|
return data
|
|
}
|
|
const type = checkImageType(data)
|
|
if(type !== 'Unknown' && type !== 'WEBP' && type !== 'AVIF'){
|
|
return await resizeAndConvert(data)
|
|
}
|
|
return data
|
|
}
|
|
|
|
async function resizeAndConvert(imageData: Uint8Array): Promise<Buffer> {
|
|
return new Promise((resolve, reject) => {
|
|
const base64Image = 'data:image/png;base64,' + Buffer.from(imageData).toString('base64');
|
|
const image = new Image();
|
|
image.onload = () => {
|
|
URL.revokeObjectURL(base64Image);
|
|
|
|
// Create a canvas
|
|
const canvas = document.createElement('canvas');
|
|
const context = canvas.getContext('2d');
|
|
if (!context) {
|
|
throw new Error('Unable to get 2D context');
|
|
}
|
|
|
|
// Compute the new dimensions while maintaining aspect ratio
|
|
let { width, height } = image;
|
|
if (width > 3000 || height > 3000) {
|
|
const aspectRatio = width / height;
|
|
if (width > height) {
|
|
width = 3000;
|
|
height = Math.round(width / aspectRatio);
|
|
} else {
|
|
height = 3000;
|
|
width = Math.round(height * aspectRatio);
|
|
}
|
|
}
|
|
|
|
// Resize and draw the image to the canvas
|
|
canvas.width = width;
|
|
canvas.height = height;
|
|
context.drawImage(image, 0, 0, width, height);
|
|
|
|
// Try to convert to WebP
|
|
let base64 = canvas.toDataURL('image/webp', 75);
|
|
|
|
// If WebP is not supported, convert to JPEG
|
|
if (base64.indexOf('data:image/webp') != 0) {
|
|
base64 = canvas.toDataURL('image/jpeg', 75);
|
|
}
|
|
|
|
// Convert it to Uint8Array
|
|
const array = Buffer.from(base64.split(',')[1], 'base64');
|
|
resolve(array);
|
|
};
|
|
image.src = base64Image;
|
|
});
|
|
}
|
|
|
|
type ImageType = 'JPEG' | 'PNG' | 'GIF' | 'BMP' | 'AVIF' | 'WEBP' | 'Unknown';
|
|
|
|
export function checkImageType(arr:Uint8Array):ImageType {
|
|
const isJPEG = arr[0] === 0xFF && arr[1] === 0xD8 && arr[arr.length-2] === 0xFF && arr[arr.length-1] === 0xD9;
|
|
const isPNG = arr[0] === 0x89 && arr[1] === 0x50 && arr[2] === 0x4E && arr[3] === 0x47 && arr[4] === 0x0D && arr[5] === 0x0A && arr[6] === 0x1A && arr[7] === 0x0A;
|
|
const isGIF = arr[0] === 0x47 && arr[1] === 0x49 && arr[2] === 0x46 && arr[3] === 0x38 && (arr[4] === 0x37 || arr[4] === 0x39) && arr[5] === 0x61;
|
|
const isBMP = arr[0] === 0x42 && arr[1] === 0x4D;
|
|
const isAVIF = arr[4] === 0x66 && arr[5] === 0x74 && arr[6] === 0x79 && arr[7] === 0x70 && arr[8] === 0x61 && arr[9] === 0x76 && arr[10] === 0x69 && arr[11] === 0x66;
|
|
const isWEBP = arr[0] === 0x52 && arr[1] === 0x49 && arr[2] === 0x46 && arr[3] === 0x46 && arr[8] === 0x57 && arr[9] === 0x45 && arr[10] === 0x42 && arr[11] === 0x50;
|
|
|
|
if (isJPEG) return "JPEG";
|
|
if (isPNG) return "PNG";
|
|
if (isGIF) return "GIF";
|
|
if (isBMP) return "BMP";
|
|
if (isAVIF) return "AVIF";
|
|
if (isWEBP) return "WEBP";
|
|
return "Unknown";
|
|
}
|
|
|
|
function wppParser(data:string){
|
|
const lines = data.split('\n');
|
|
let characterDetails:{[key:string]:string[]} = {};
|
|
|
|
lines.forEach(line => {
|
|
|
|
// Check for "{" and "}" indicator of object start and end
|
|
if(line.includes('{')) return;
|
|
if(line.includes('}')) return;
|
|
|
|
// Extract key and value within brackets
|
|
let keyBracketStartIndex = line.indexOf('(');
|
|
let keyBracketEndIndex = line.indexOf(')');
|
|
|
|
if(keyBracketStartIndex === -1 || keyBracketEndIndex === -1)
|
|
throw new Error(`Invalid syntax ${line}`);
|
|
|
|
let key = line.substring(0, keyBracketStartIndex).trim();
|
|
|
|
// Validate Key
|
|
if(!key) throw new Error(`Missing Key in ${line}`);
|
|
|
|
const valueArray=line.substring(keyBracketStartIndex + 1, keyBracketEndIndex)
|
|
.split(',')
|
|
.map(str => str.trim());
|
|
|
|
// Validate Values
|
|
for(let i=0;i<valueArray.length ;i++){
|
|
if(!valueArray[i])
|
|
throw new Error(`Empty Value in ${line}`);
|
|
|
|
}
|
|
characterDetails[key] = valueArray;
|
|
});
|
|
|
|
return characterDetails;
|
|
}
|
|
|
|
|
|
const rgx = /(?:{{|<)(.+?)(?:}}|>)/gm
|
|
type matcherArg = {
|
|
chatID:number,
|
|
db:Database,
|
|
chara:character|string,
|
|
rmVar:boolean,
|
|
var?:{[key:string]:string}
|
|
tokenizeAccurate?:boolean
|
|
consistantChar?:boolean
|
|
displaying?:boolean
|
|
role?:string
|
|
runVar?:boolean
|
|
}
|
|
const matcher = (p1:string,matcherArg:matcherArg) => {
|
|
try {
|
|
if(p1.length > 100000){
|
|
return ''
|
|
}
|
|
const lowerCased = p1.toLocaleLowerCase()
|
|
const chatID = matcherArg.chatID
|
|
const db = matcherArg.db
|
|
const chara = matcherArg.chara
|
|
switch(lowerCased){
|
|
case 'previous_char_chat':
|
|
case 'lastcharmessage':{
|
|
if(chatID !== -1){
|
|
const selchar = db.characters[get(selectedCharID)]
|
|
const chat = selchar.chats[selchar.chatPage]
|
|
let pointer = chatID - 1
|
|
while(pointer >= 0){
|
|
if(chat.message[pointer].role === 'char'){
|
|
return chat.message[pointer].data
|
|
}
|
|
pointer--
|
|
}
|
|
return selchar.firstMsgIndex === -1 ? selchar.firstMessage : selchar.alternateGreetings[selchar.firstMsgIndex]
|
|
}
|
|
return ''
|
|
}
|
|
case 'previous_user_chat':
|
|
case 'lastusermessage':{
|
|
if(chatID !== -1){
|
|
const selchar = db.characters[get(selectedCharID)]
|
|
const chat = selchar.chats[selchar.chatPage]
|
|
let pointer = chatID - 1
|
|
while(pointer >= 0){
|
|
if(chat.message[pointer].role === 'user'){
|
|
return chat.message[pointer].data
|
|
}
|
|
pointer--
|
|
}
|
|
return selchar.firstMsgIndex === -1 ? selchar.firstMessage : selchar.alternateGreetings[selchar.firstMsgIndex]
|
|
}
|
|
return ''
|
|
}
|
|
case 'char':
|
|
case 'bot':{
|
|
if(matcherArg.consistantChar){
|
|
return 'botname'
|
|
}
|
|
let selectedChar = get(selectedCharID)
|
|
let currentChar = db.characters[selectedChar]
|
|
if(currentChar && currentChar.type !== 'group'){
|
|
return currentChar.nickname || currentChar.name
|
|
}
|
|
if(chara){
|
|
if(typeof(chara) === 'string'){
|
|
return chara
|
|
}
|
|
else{
|
|
return chara.name
|
|
}
|
|
}
|
|
return currentChar.nickname || currentChar.name
|
|
}
|
|
case 'user':{
|
|
if(matcherArg.consistantChar){
|
|
return 'username'
|
|
}
|
|
return db.username
|
|
}
|
|
case 'personality':
|
|
case 'char_persona':{
|
|
const argChara = chara
|
|
const achara = (argChara && typeof(argChara) !== 'string') ? argChara : (db.characters[get(selectedCharID)])
|
|
if(achara.type === 'group'){
|
|
return ""
|
|
}
|
|
return achara.personality
|
|
}
|
|
case 'description':
|
|
case 'char_desc':{
|
|
const argChara = chara
|
|
const achara = (argChara && typeof(argChara) !== 'string') ? argChara : (db.characters[get(selectedCharID)])
|
|
if(achara.type === 'group'){
|
|
return ""
|
|
}
|
|
return achara.desc
|
|
}
|
|
case 'scenario':{
|
|
const argChara = chara
|
|
const achara = (argChara && typeof(argChara) !== 'string') ? argChara : (db.characters[get(selectedCharID)])
|
|
if(achara.type === 'group'){
|
|
return ""
|
|
}
|
|
return achara.scenario
|
|
}
|
|
case 'example_dialogue':
|
|
case 'example_message':{
|
|
const argChara = chara
|
|
const achara = (argChara && typeof(argChara) !== 'string') ? argChara : (db.characters[get(selectedCharID)])
|
|
if(achara.type === 'group'){
|
|
return ""
|
|
}
|
|
return achara.exampleMessage
|
|
}
|
|
case 'persona':
|
|
case 'user_persona':{
|
|
return db.personaPrompt
|
|
}
|
|
case 'main_prompt':
|
|
case 'system_prompt':{
|
|
return db.mainPrompt
|
|
}
|
|
case 'lorebook':
|
|
case 'world_info':{
|
|
const argChara = chara
|
|
const achara = (argChara && typeof(argChara) !== 'string') ? argChara : (db.characters[get(selectedCharID)])
|
|
const selchar = db.characters[get(selectedCharID)]
|
|
const chat = selchar.chats[selchar.chatPage]
|
|
const characterLore = (achara.type === 'group') ? [] : (achara.globalLore ?? [])
|
|
const chatLore = chat.localLore ?? []
|
|
const fullLore = characterLore.concat(chatLore.concat(getModuleLorebooks()))
|
|
return fullLore.map((f) => {
|
|
return JSON.stringify(f)
|
|
}).join("§\n")
|
|
}
|
|
case 'history':
|
|
case 'messages':{
|
|
const selchar = db.characters[get(selectedCharID)]
|
|
const chat = selchar.chats[selchar.chatPage]
|
|
return chat.message.map((f) => {
|
|
return f.role + ': ' + f.data
|
|
}).join("§\n")
|
|
}
|
|
case 'ujb':
|
|
case 'global_note':
|
|
case 'system_note':{
|
|
return db.globalNote
|
|
}
|
|
case 'chat_index':{
|
|
return chatID.toString()
|
|
}
|
|
case 'first_msg_index':{
|
|
const selchar = db.characters[get(selectedCharID)]
|
|
return selchar.firstMsgIndex
|
|
}
|
|
case 'blank':
|
|
case 'none':{
|
|
return ''
|
|
}
|
|
case 'message_time':{
|
|
if(matcherArg.tokenizeAccurate){
|
|
return `00:00:00`
|
|
}
|
|
if(chatID === -1){
|
|
return "[Cannot get time]"
|
|
}
|
|
|
|
const selchar = db.characters[get(selectedCharID)]
|
|
const chat = selchar.chats[selchar.chatPage]
|
|
const message = chat.message[chatID]
|
|
if(!message.time){
|
|
return "[Cannot get time, message was sent in older version]"
|
|
}
|
|
const date = new Date(message.time)
|
|
//output time in format like 10:30 AM
|
|
return date.toLocaleTimeString()
|
|
}
|
|
case 'message_date':{
|
|
if(matcherArg.tokenizeAccurate){
|
|
return `00:00:00`
|
|
}
|
|
if(chatID === -1){
|
|
return "[Cannot get time]"
|
|
}
|
|
const selchar = db.characters[get(selectedCharID)]
|
|
const chat = selchar.chats[selchar.chatPage]
|
|
const message = chat.message[chatID]
|
|
if(!message.time){
|
|
return "[Cannot get time, message was sent in older version]"
|
|
}
|
|
const date = new Date(message.time)
|
|
//output date in format like Aug 23, 2021
|
|
return date.toLocaleDateString()
|
|
}
|
|
case 'time':{
|
|
const now = new Date()
|
|
return `${now.getHours()}:${now.getMinutes()}:${now.getSeconds()}`
|
|
}
|
|
case 'date':{
|
|
const now = new Date()
|
|
return `${now.getFullYear()}-${now.getMonth() + 1}-${now.getDate()}`
|
|
}
|
|
case 'isotime':{
|
|
const now = new Date()
|
|
return `${now.getUTCHours()}:${now.getUTCMinutes()}:${now.getUTCSeconds()}`
|
|
}
|
|
case 'isodate':{
|
|
const now = new Date()
|
|
return `${now.getUTCFullYear()}-${now.getUTCMonth() + 1}-${now.getUTCDate()}`
|
|
}
|
|
case 'message_idle_duration':{
|
|
if(matcherArg.tokenizeAccurate){
|
|
return `00:00:00`
|
|
}
|
|
if(chatID === -1){
|
|
return "[Cannot get time]"
|
|
}
|
|
const selchar = db.characters[get(selectedCharID)]
|
|
const chat = selchar.chats[selchar.chatPage]
|
|
|
|
//get latest user message
|
|
let pointer = chatID
|
|
let pointerMode: 'findLast'|'findSecondLast' = 'findLast'
|
|
let message:Message
|
|
let previous_message:Message
|
|
while(pointer >= 0){
|
|
if(chat.message[pointer].role === 'user'){
|
|
if(pointerMode === 'findLast'){
|
|
message = chat.message[pointer]
|
|
pointerMode = 'findSecondLast'
|
|
}
|
|
else{
|
|
previous_message = chat.message[pointer]
|
|
break
|
|
}
|
|
}
|
|
pointer--
|
|
}
|
|
|
|
if(!message){
|
|
return '[No user message found]'
|
|
}
|
|
|
|
if(!previous_message){
|
|
return '[No previous user message found]'
|
|
}
|
|
if(!message.time){
|
|
return "[Cannot get time, message was sent in older version]"
|
|
}
|
|
if(!previous_message.time){
|
|
return "[Cannot get time, previous message was sent in older version]"
|
|
}
|
|
|
|
let duration = message.time - previous_message.time
|
|
//output time in format like 10:30:00
|
|
let seconds = Math.floor(duration / 1000)
|
|
let minutes = Math.floor(seconds / 60)
|
|
let hours = Math.floor(minutes / 60)
|
|
seconds = seconds % 60
|
|
minutes = minutes % 60
|
|
//output, like 1:30:00
|
|
return hours.toString() + ':' + minutes.toString().padStart(2,'0') + ':' + seconds.toString().padStart(2,'0')
|
|
}
|
|
case 'idle_duration':{
|
|
if(matcherArg.tokenizeAccurate){
|
|
return `00:00:00`
|
|
}
|
|
const selchar = db.characters[get(selectedCharID)]
|
|
const chat = selchar.chats[selchar.chatPage]
|
|
const messages = chat.message
|
|
if(messages.length === 0){
|
|
return `00:00:00`
|
|
}
|
|
|
|
const lastMessage = messages[messages.length - 1]
|
|
|
|
if(!lastMessage.time){
|
|
return "[Cannot get time, message was sent in older version]"
|
|
}
|
|
|
|
const now = new Date()
|
|
|
|
let duration = now.getTime() - lastMessage.time
|
|
|
|
let seconds = Math.floor(duration / 1000)
|
|
let minutes = Math.floor(seconds / 60)
|
|
let hours = Math.floor(minutes / 60)
|
|
|
|
seconds = seconds % 60
|
|
minutes = minutes % 60
|
|
|
|
return hours.toString() + ':' + minutes.toString().padStart(2,'0') + ':' + seconds.toString().padStart(2,'0')
|
|
}
|
|
case 'br':
|
|
case 'newline':{
|
|
return '\n'
|
|
}
|
|
case 'model':{
|
|
return db.aiModel
|
|
}
|
|
case 'axmodel':{
|
|
return db.subModel
|
|
}
|
|
case 'role': {
|
|
return matcherArg.role ?? 'role'
|
|
}
|
|
case 'jbtoggled':{
|
|
return db.jailbreakToggle ? '1' : '0'
|
|
}
|
|
case 'random':{
|
|
return Math.random().toString()
|
|
}
|
|
case 'maxcontext':{
|
|
return db.maxContext.toString()
|
|
}
|
|
case 'lastmessage':{
|
|
const selchar = db.characters[get(selectedCharID)]
|
|
if(!selchar){
|
|
return ''
|
|
}
|
|
const chat = selchar.chats[selchar.chatPage]
|
|
return chat.message[chat.message.length - 1].data
|
|
}
|
|
case 'lastmessageid':
|
|
case 'lastmessageindex':{
|
|
const selchar = db.characters[get(selectedCharID)]
|
|
if(!selchar){
|
|
return ''
|
|
}
|
|
const chat = selchar.chats[selchar.chatPage]
|
|
return chat.message.length - 1
|
|
}
|
|
case 'emotionlist':{
|
|
const selchar = db.characters[get(selectedCharID)]
|
|
if(!selchar){
|
|
return ''
|
|
}
|
|
return selchar.emotionImages?.map((f) => {
|
|
return f[0]
|
|
})?.join('§') ?? ''
|
|
}
|
|
case 'assetlist':{
|
|
const selchar = db.characters[get(selectedCharID)]
|
|
if(!selchar || selchar.type === 'group'){
|
|
return ''
|
|
}
|
|
return selchar.additionalAssets?.map((f) => {
|
|
return f[0]
|
|
})?.join('§') ?? ''
|
|
}
|
|
case 'prefill_supported':{
|
|
return db.aiModel.startsWith('claude') ? '1' : '0'
|
|
}
|
|
case 'unixtime':{
|
|
return (Date.now() / 1000).toFixed(2)
|
|
}
|
|
}
|
|
const arra = p1.split("::")
|
|
if(arra.length > 1){
|
|
const v = arra[1]
|
|
switch(arra[0]){
|
|
case 'getvar':{
|
|
return getChatVar(v)
|
|
}
|
|
case 'calc':{
|
|
return calcString(v).toString()
|
|
}
|
|
case 'addvar':{
|
|
if(matcherArg.rmVar){
|
|
return ''
|
|
}
|
|
if(matcherArg.runVar){
|
|
setChatVar(v, (Number(getChatVar(v)) + Number(arra[2])).toString())
|
|
return ''
|
|
}
|
|
return null
|
|
}
|
|
case 'setvar':{
|
|
if(matcherArg.rmVar){
|
|
return ''
|
|
}
|
|
if(matcherArg.runVar){
|
|
setChatVar(v, arra[2])
|
|
return ''
|
|
}
|
|
return null
|
|
}
|
|
case 'setdefaultvar':{
|
|
if(matcherArg.rmVar){
|
|
return ''
|
|
}
|
|
if(matcherArg.runVar){
|
|
if(!getChatVar(v)){
|
|
setChatVar(v, arra[2])
|
|
}
|
|
return ''
|
|
}
|
|
return null
|
|
}
|
|
case 'getglobalvar':{
|
|
return getGlobalChatVar(v)
|
|
}
|
|
case 'button':{
|
|
return `<button class="button-default" risu-trigger="${arra[2]}">${arra[1]}</button>`
|
|
}
|
|
case 'risu':{
|
|
return `<img src="/logo2.png" style="height:${v || 45}px;width:${v || 45}px" />`
|
|
}
|
|
case 'equal':{
|
|
return (arra[1] === arra[2]) ? '1' : '0'
|
|
}
|
|
case 'not_equal':
|
|
case 'notequal':{
|
|
return (arra[1] !== arra[2]) ? '1' : '0'
|
|
}
|
|
case 'greater':{
|
|
return (Number(arra[1]) > Number(arra[2])) ? '1' : '0'
|
|
}
|
|
case 'less':{
|
|
return (Number(arra[1]) < Number(arra[2])) ? '1' : '0'
|
|
}
|
|
case 'greater_equal':
|
|
case 'greaterequal':{
|
|
return (Number(arra[1]) >= Number(arra[2])) ? '1' : '0'
|
|
}
|
|
case 'less_equal':
|
|
case 'lessequal':{
|
|
return (Number(arra[1]) <= Number(arra[2])) ? '1' : '0'
|
|
}
|
|
case 'and':{
|
|
return arra[1] === '1' && arra[2] === '1' ? '1' : '0'
|
|
}
|
|
case 'or':{
|
|
return arra[1] === '1' || arra[2] === '1' ? '1' : '0'
|
|
}
|
|
case 'not':{
|
|
return arra[1] === '1' ? '0' : '1'
|
|
}
|
|
case 'file':{
|
|
if(matcherArg.displaying){
|
|
return `<br><div class="risu-file">${arra[1]}</div><br>`
|
|
}
|
|
return Buffer.from(arra[2], 'base64').toString('utf-8')
|
|
}
|
|
case 'startswith':{
|
|
return arra[1].startsWith(arra[2]) ? '1' : '0'
|
|
}
|
|
case 'endswith':{
|
|
return arra[1].endsWith(arra[2]) ? '1' : '0'
|
|
}
|
|
case 'contains':{
|
|
return arra[1].includes(arra[2]) ? '1' : '0'
|
|
}
|
|
case 'replace':{
|
|
return arra[1].replaceAll(arra[2], arra[3])
|
|
}
|
|
case 'split':{
|
|
return arra[1].split(arra[2]).join('§')
|
|
}
|
|
case 'join':{
|
|
return arra[1].split('§').join(arra[2])
|
|
}
|
|
case 'spread':{
|
|
return arra[1].split('§').join('::')
|
|
}
|
|
case 'trim':{
|
|
return arra[1].trim()
|
|
}
|
|
case 'length':{
|
|
return arra[1].length.toString()
|
|
}
|
|
case 'arraylength':
|
|
case 'array_length':{
|
|
return arra[1].split('§').length.toString()
|
|
}
|
|
case 'lower':{
|
|
return arra[1].toLocaleLowerCase()
|
|
}
|
|
case 'upper':{
|
|
return arra[1].toLocaleUpperCase()
|
|
}
|
|
case 'capitalize':{
|
|
return arra[1].charAt(0).toUpperCase() + arra[1].slice(1)
|
|
}
|
|
case 'round':{
|
|
return Math.round(Number(arra[1])).toString()
|
|
}
|
|
case 'floor':{
|
|
return Math.floor(Number(arra[1])).toString()
|
|
}
|
|
case 'ceil':{
|
|
return Math.ceil(Number(arra[1])).toString()
|
|
}
|
|
case 'abs':{
|
|
return Math.abs(Number(arra[1])).toString()
|
|
}
|
|
case 'remaind':{
|
|
return (Number(arra[1]) % Number(arra[2])).toString()
|
|
}
|
|
case 'previous_chat_log':{
|
|
const selchar = db.characters[get(selectedCharID)]
|
|
const chat = selchar?.chats?.[selchar.chatPage]
|
|
return chat?.message[chatID - 1]?.data ?? 'Out of range'
|
|
|
|
}
|
|
case 'tonumber':{
|
|
return arra[1].split('').filter((v) => {
|
|
return !isNaN(Number(v)) || v === '.'
|
|
}).join('')
|
|
}
|
|
case 'pow':{
|
|
return Math.pow(Number(arra[1]), Number(arra[2])).toString()
|
|
}
|
|
case 'arrayelement':
|
|
case 'array_element':{
|
|
return arra[1].split('§')[Number(arra[2])]
|
|
}
|
|
case 'arrayshift':
|
|
case 'array_shift':{
|
|
const arr = arra[1].split('§')
|
|
arr.shift()
|
|
return arr.join('§')
|
|
}
|
|
case 'arraypop':
|
|
case 'array_pop':{
|
|
const arr = arra[1].split('§')
|
|
arr.pop()
|
|
return arr.join('§')
|
|
}
|
|
case 'arraypush':
|
|
case 'array_push':{
|
|
return arra[1] + '§' + arra[2]
|
|
}
|
|
case 'arraysplice':
|
|
case 'array_splice':{
|
|
const arr = arra[1].split('§')
|
|
arr.splice(Number(arra[2]), Number(arra[3]), arra[4])
|
|
return arr.join('§')
|
|
}
|
|
case 'makearray':
|
|
case 'array':
|
|
case 'a':
|
|
case 'make_array':{
|
|
return arra.slice(1).join('§')
|
|
}
|
|
case 'history':
|
|
case 'messages':{
|
|
const selchar = db.characters[get(selectedCharID)]
|
|
const chat = selchar.chats[selchar.chatPage]
|
|
return chat.message.map((f) => {
|
|
let data = ''
|
|
if(arra.includes('role')){
|
|
data += f.role + ': '
|
|
}
|
|
data += f.data
|
|
return data
|
|
}).join("§\n")
|
|
}
|
|
case 'range':{
|
|
const arr = arra[1].split('§')
|
|
const start = arr.length > 1 ? Number(arr[0]) : 0
|
|
const end = arr.length > 1 ? Number(arr[1]) : Number(arr[0])
|
|
const step = arr.length > 2 ? Number(arr[2]) : 1
|
|
let out = ''
|
|
for(let i=start;i<end;i+=step){
|
|
out += i.toString()
|
|
if(i + step < end){
|
|
out += '§'
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
case 'date':
|
|
case 'time':
|
|
case 'datetimeformat':
|
|
case 'date_time_format':{
|
|
return dateTimeFormat(arra[1])
|
|
}
|
|
case 'module_enabled':{
|
|
const selchar = db.characters[get(selectedCharID)]
|
|
let enabledChatModules:string[] = []
|
|
if(!selchar){
|
|
enabledChatModules = selchar.chats[selchar.chatPage].modules ?? []
|
|
|
|
}
|
|
const moduleId = db.modules.find((f) => {
|
|
return f.name === arra[1]
|
|
}).id
|
|
return (db.enabledModules.includes(moduleId) || enabledChatModules.includes(moduleId)) ? '1' : '0'
|
|
}
|
|
}
|
|
}
|
|
if(p1.startsWith('random')){
|
|
if(p1.startsWith('random::')){
|
|
const randomIndex = Math.floor(Math.random() * (arra.length - 1)) + 1
|
|
if(matcherArg.tokenizeAccurate){
|
|
return arra[0]
|
|
}
|
|
return arra[randomIndex]
|
|
}
|
|
else{
|
|
const arr = p1.replace(/\\,/g, '§X').split(/\:|\,/g)
|
|
const randomIndex = Math.floor(Math.random() * (arr.length - 1)) + 1
|
|
if(matcherArg.tokenizeAccurate){
|
|
return arra[0]
|
|
}
|
|
return arr[randomIndex]?.replace(/§X/g, ',') ?? ''
|
|
}
|
|
}
|
|
if(p1.startsWith('pick')){
|
|
const selchar = db.characters[get(selectedCharID)]
|
|
const selChat = selchar.chats[selchar.chatPage]
|
|
const cid = (chatID < 0) ? selChat.message.length : chatID
|
|
if(p1.startsWith('pick::')){
|
|
const randomIndex = Math.floor(pickHashRand(cid, selchar.chaId) * (arra.length - 1)) + 1
|
|
if(matcherArg.tokenizeAccurate){
|
|
return arra[0]
|
|
}
|
|
return arra[randomIndex]
|
|
}
|
|
else{
|
|
const arr = p1.replace(/\\,/g, '§X').split(/\:|\,/g)
|
|
const randomIndex = Math.floor(pickHashRand(cid, selchar.chaId) * (arr.length - 1)) + 1
|
|
if(matcherArg.tokenizeAccurate){
|
|
return arra[0]
|
|
}
|
|
return arr[randomIndex]?.replace(/§X/g, ',') ?? ''
|
|
}
|
|
}
|
|
if(p1.startsWith('roll:') || p1.startsWith('rollp:')){
|
|
const p = p1.startsWith('rollp:')
|
|
const arr = p1.split(/\:|\ /g)
|
|
let ina = arr.at(-1)
|
|
|
|
if(ina.startsWith('d')){
|
|
ina = ina.substring(1)
|
|
}
|
|
|
|
const maxRoll = parseInt(ina)
|
|
if(isNaN(maxRoll)){
|
|
return 'NaN'
|
|
}
|
|
if(p){
|
|
const selchar = db.characters[get(selectedCharID)]
|
|
const selChat = selchar.chats[selchar.chatPage]
|
|
const cid = (chatID < 0) ? selChat.message.length : chatID
|
|
return (Math.floor(pickHashRand(cid, selchar.chaId) * maxRoll) + 1).toString()
|
|
}
|
|
return (Math.floor(Math.random() * maxRoll) + 1).toString()
|
|
}
|
|
if(p1.startsWith('datetimeformat')){
|
|
let main = p1.substring("datetimeformat".length + 1)
|
|
return dateTimeFormat(main)
|
|
}
|
|
if(p1.startsWith('? ')){
|
|
const substring = p1.substring(2)
|
|
|
|
return calcString(substring).toString()
|
|
}
|
|
if(p1.startsWith('//')){
|
|
return ''
|
|
}
|
|
if(p1.startsWith('hidden_key:')){
|
|
return ''
|
|
}
|
|
if(p1.startsWith('reverse:')){
|
|
return p1.substring(
|
|
p1[8] === ':' ? 9 : 8
|
|
).split('').reverse().join('')
|
|
}
|
|
if(p1.startsWith('comment:')){
|
|
if(!matcherArg.displaying){
|
|
return ''
|
|
}
|
|
return `<div class="risu-comment">${p1.substring(p1[8] === ':' ? 9 : 8)}</div>`
|
|
}
|
|
return null
|
|
} catch (error) {
|
|
return null
|
|
}
|
|
}
|
|
|
|
function pickHashRand(cid:number,word:string) {
|
|
let hashAddress = cid * 23515
|
|
const rand = (word:string) => {
|
|
for (let counter = 0; counter<word.length; counter++){
|
|
hashAddress = ((hashAddress << 5) + hashAddress) + word.charCodeAt(counter)
|
|
}
|
|
return hashAddress
|
|
}
|
|
const randF = sfc32(rand(word), rand(word), rand(word), rand(word))
|
|
return randF()
|
|
}
|
|
|
|
const dateTimeFormat = (main:string) => {
|
|
const date = new Date()
|
|
if(!main){
|
|
return ''
|
|
}
|
|
if(main.startsWith(':')){
|
|
main = main.substring(1)
|
|
}
|
|
if(main.length > 300){
|
|
return ''
|
|
}
|
|
return main
|
|
.replace(/YYYY/g, date.getFullYear().toString())
|
|
.replace(/YY/g, date.getFullYear().toString().substring(2))
|
|
.replace(/MM?/g, (date.getMonth() + 1).toString().padStart(2, '0'))
|
|
.replace(/DD?/g, date.getDate().toString().padStart(2, '0'))
|
|
.replace(/DDDD?/g, (date.getDay() + (date.getMonth() * 30)).toString())
|
|
.replace(/HH?/g, date.getHours().toString().padStart(2, '0'))
|
|
.replace(/hh?/g, (date.getHours() % 12).toString().padStart(2, '0'))
|
|
.replace(/mm?/g, date.getMinutes().toString().padStart(2, '0'))
|
|
.replace(/ss?/g, date.getSeconds().toString().padStart(2, '0'))
|
|
.replace(/X?/g, (Date.now() / 1000).toFixed(2))
|
|
.replace(/x?/g, Date.now().toFixed())
|
|
.replace(/A/g, date.getHours() >= 12 ? 'PM' : 'AM')
|
|
.replace(/MMMM?/g, Intl.DateTimeFormat('en', { month: 'long' }).format(date))
|
|
|
|
}
|
|
|
|
const smMatcher = (p1:string,matcherArg:matcherArg) => {
|
|
if(!p1){
|
|
return null
|
|
}
|
|
const lowerCased = p1.toLocaleLowerCase()
|
|
const db = matcherArg.db
|
|
const chara = matcherArg.chara
|
|
switch(lowerCased){
|
|
case 'char':
|
|
case 'bot':{
|
|
if(matcherArg.consistantChar){
|
|
return 'botname'
|
|
}
|
|
let selectedChar = get(selectedCharID)
|
|
let currentChar = db.characters[selectedChar]
|
|
if(currentChar && currentChar.type !== 'group'){
|
|
return currentChar.nickname || currentChar.name
|
|
}
|
|
if(chara){
|
|
if(typeof(chara) === 'string'){
|
|
return chara
|
|
}
|
|
else{
|
|
return chara.name
|
|
}
|
|
}
|
|
return currentChar.nickname || currentChar.name
|
|
}
|
|
case 'user':{
|
|
if(matcherArg.consistantChar){
|
|
return 'username'
|
|
}
|
|
return db.username
|
|
}
|
|
}
|
|
}
|
|
|
|
const legacyBlockMatcher = (p1:string,matcherArg:matcherArg) => {
|
|
const bn = p1.indexOf('\n')
|
|
|
|
if(bn === -1){
|
|
return null
|
|
}
|
|
|
|
const logic = p1.substring(0, bn)
|
|
const content = p1.substring(bn + 1)
|
|
const statement = logic.split(" ", 2)
|
|
|
|
switch(statement[0]){
|
|
case 'if':{
|
|
if(["","0","-1"].includes(statement[1])){
|
|
return ''
|
|
}
|
|
|
|
return content.trim()
|
|
}
|
|
}
|
|
|
|
return null
|
|
}
|
|
|
|
type blockMatch = 'ignore'|'parse'|'nothing'|'parse-pure'|'pure'|'each'
|
|
|
|
|
|
function blockStartMatcher(p1:string,matcherArg:matcherArg):{type:blockMatch,type2?:string}{
|
|
if(p1.startsWith('#if') || p1.startsWith('#if_pure ')){
|
|
const statement = p1.split(' ', 2)
|
|
const state = statement[1]
|
|
if(state === 'true' || state === '1'){
|
|
return {type:p1.startsWith('#if_pure') ? 'parse-pure' : 'parse'}
|
|
}
|
|
return {type:'ignore'}
|
|
}
|
|
if(p1 === '#pure'){
|
|
return {type:'pure'}
|
|
}
|
|
if(p1.startsWith('#each')){
|
|
return {type:'each',type2:p1.substring(5).trim()}
|
|
}
|
|
return {type:'nothing'}
|
|
}
|
|
|
|
function trimLines(p1:string){
|
|
return p1.split('\n').map((v) => {
|
|
return v.trimStart()
|
|
}).join('\n').trim()
|
|
}
|
|
|
|
function blockEndMatcher(p1:string,type:{type:blockMatch,type2?:string},matcherArg:matcherArg):string{
|
|
switch(type.type){
|
|
case 'pure':
|
|
case 'parse-pure':{
|
|
return p1
|
|
}
|
|
case 'parse':
|
|
case 'each':{
|
|
return trimLines(p1)
|
|
}
|
|
default:{
|
|
return ''
|
|
}
|
|
}
|
|
}
|
|
|
|
export function risuChatParser(da:string, arg:{
|
|
chatID?:number
|
|
db?:Database
|
|
chara?:string|character|groupChat
|
|
rmVar?:boolean,
|
|
var?:{[key:string]:string}
|
|
tokenizeAccurate?:boolean
|
|
consistantChar?:boolean
|
|
visualize?:boolean,
|
|
role?:string
|
|
runVar?:boolean
|
|
} = {}):string{
|
|
const chatID = arg.chatID ?? -1
|
|
const db = arg.db ?? get(DataBase)
|
|
const aChara = arg.chara
|
|
const visualize = arg.visualize ?? false
|
|
let chara:character|string = null
|
|
|
|
if(aChara){
|
|
if(typeof(aChara) !== 'string' && aChara.type === 'group'){
|
|
const gc = findCharacterbyId(aChara.chats[aChara.chatPage].message.at(-1).saying ?? '')
|
|
if(gc.name !== 'Unknown Character'){
|
|
chara = gc
|
|
}
|
|
}
|
|
else{
|
|
chara = aChara
|
|
}
|
|
}
|
|
if(arg.tokenizeAccurate){
|
|
const db = arg.db ?? get(DataBase)
|
|
const selchar = chara ?? db.characters[get(selectedCharID)]
|
|
if(!selchar){
|
|
chara = 'bot'
|
|
}
|
|
}
|
|
|
|
|
|
let pointer = 0;
|
|
let nested:string[] = [""]
|
|
let stackType = new Uint8Array(512)
|
|
let pureModeNest:Map<number,boolean> = new Map()
|
|
let pureModeNestType:Map<number,string> = new Map()
|
|
let blockNestType:Map<number,{type:blockMatch,type2?:string}> = new Map()
|
|
let commentMode = false
|
|
let commentLatest:string[] = [""]
|
|
let commentV = new Uint8Array(512)
|
|
let thinkingMode = false
|
|
const matcherObj = {
|
|
chatID: chatID,
|
|
chara: chara,
|
|
rmVar: arg.rmVar ?? false,
|
|
db: db,
|
|
var: arg.var ?? null,
|
|
tokenizeAccurate: arg.tokenizeAccurate ?? false,
|
|
displaying: arg.visualize ?? false,
|
|
role: arg.role,
|
|
runVar: arg.runVar ?? false,
|
|
consistantChar: arg.consistantChar ?? false
|
|
}
|
|
|
|
|
|
const isPureMode = () => {
|
|
return pureModeNest.size > 0
|
|
}
|
|
const pureModeType = () => {
|
|
if(pureModeNest.size === 0){
|
|
return ''
|
|
}
|
|
return pureModeNestType.get(nested.length) ?? [...pureModeNestType.values()].at(-1) ?? ''
|
|
}
|
|
while(pointer < da.length){
|
|
switch(da[pointer]){
|
|
case '{':{
|
|
if(da[pointer + 1] !== '{' && da[pointer + 1] !== '#'){
|
|
nested[0] += da[pointer]
|
|
break
|
|
}
|
|
pointer++
|
|
nested.unshift('')
|
|
stackType[nested.length] = 1
|
|
break
|
|
}
|
|
case '<':{
|
|
if(stackType[nested.length] === 1){
|
|
nested[0] += da[pointer]
|
|
break
|
|
}
|
|
nested.unshift('')
|
|
stackType[nested.length] = 2
|
|
break
|
|
}
|
|
case '#':{
|
|
//legacy if statement, deprecated
|
|
if(da[pointer + 1] !== '}' || nested.length === 1 || stackType[nested.length] !== 1){
|
|
nested[0] += da[pointer]
|
|
break
|
|
}
|
|
pointer++
|
|
const dat = nested.shift()
|
|
const mc = legacyBlockMatcher(dat, matcherObj)
|
|
nested[0] += mc ?? `{#${dat}#}`
|
|
break
|
|
}
|
|
case '}':{
|
|
if(da[pointer + 1] !== '}' || nested.length === 1 || stackType[nested.length] !== 1){
|
|
nested[0] += da[pointer]
|
|
break
|
|
}
|
|
pointer++
|
|
const dat = nested.shift()
|
|
if(dat.startsWith('#')){
|
|
if(isPureMode()){
|
|
nested[0] += `{{${dat}}}`
|
|
nested.unshift('')
|
|
stackType[nested.length] = 6
|
|
break
|
|
}
|
|
const matchResult = blockStartMatcher(dat, matcherObj)
|
|
if(matchResult.type === 'nothing'){
|
|
nested[0] += `{{${dat}}}`
|
|
break
|
|
}
|
|
else{
|
|
nested.unshift('')
|
|
stackType[nested.length] = 5
|
|
blockNestType.set(nested.length, matchResult)
|
|
if(matchResult.type === 'ignore' || matchResult.type === 'pure' || matchResult.type === 'each'){
|
|
pureModeNest.set(nested.length, true)
|
|
pureModeNestType.set(nested.length, "block")
|
|
}
|
|
break
|
|
}
|
|
}
|
|
if(dat.startsWith('/')){
|
|
if(stackType[nested.length] === 5){
|
|
const blockType = blockNestType.get(nested.length)
|
|
if(blockType.type === 'ignore' || blockType.type === 'pure' || blockType.type === 'each'){
|
|
pureModeNest.delete(nested.length)
|
|
pureModeNestType.delete(nested.length)
|
|
}
|
|
blockNestType.delete(nested.length)
|
|
const dat2 = nested.shift()
|
|
const matchResult = blockEndMatcher(dat2.trim(), blockType, matcherObj)
|
|
if(blockType.type === 'each'){
|
|
const subind = blockType.type2.lastIndexOf(' ')
|
|
const sub = blockType.type2.substring(subind + 1)
|
|
const array = blockType.type2.substring(0, subind).split('§')
|
|
let added = ''
|
|
for(let i = 0;i < array.length;i++){
|
|
const res = matchResult.replaceAll(`{{slot::${sub}}}`, array[i])
|
|
added += res
|
|
}
|
|
da = da.substring(0, pointer + 1) + added.trim() + da.substring(pointer + 1)
|
|
break
|
|
}
|
|
if(matchResult === ''){
|
|
break
|
|
}
|
|
nested[0] += matchResult
|
|
break
|
|
}
|
|
if(stackType[nested.length] === 6){
|
|
console.log(dat)
|
|
const sft = nested.shift()
|
|
nested[0] += sft + `{{${dat}}}`
|
|
break
|
|
}
|
|
}
|
|
const mc = isPureMode() ? null :matcher(dat, matcherObj)
|
|
nested[0] += mc ?? `{{${dat}}}`
|
|
break
|
|
}
|
|
case '>':{
|
|
if(stackType[nested.length] === 1){
|
|
nested[0] += da[pointer]
|
|
break
|
|
}
|
|
if(nested.length === 1 || stackType[nested.length] !== 2){
|
|
break
|
|
}
|
|
const dat = nested.shift()
|
|
if(isPureMode() && pureModeType() !== 'pureSyntax' && pureModeType() !== ''){
|
|
nested[0] += `<${dat}>`
|
|
break
|
|
}
|
|
switch(dat){
|
|
case 'Comment':{
|
|
if(arg.runVar){
|
|
break
|
|
}
|
|
if(!commentMode){
|
|
thinkingMode = false
|
|
commentMode = true
|
|
commentLatest = nested.map((f) => f)
|
|
if(commentLatest[0].endsWith('\n')){
|
|
commentLatest[0] = commentLatest[0].substring(0, commentLatest[0].length - 1)
|
|
}
|
|
commentV = new Uint8Array(stackType)
|
|
}
|
|
break
|
|
}
|
|
case '/Comment':{
|
|
if(commentMode){
|
|
nested = commentLatest
|
|
stackType = commentV
|
|
commentMode = false
|
|
}
|
|
break
|
|
}
|
|
case 'Thoughts':{
|
|
if(!visualize){
|
|
nested[0] += `<${dat}>`
|
|
break
|
|
}
|
|
if(!commentMode){
|
|
thinkingMode = true
|
|
commentMode = true
|
|
commentLatest = nested.map((f) => f)
|
|
if(commentLatest[0].endsWith('\n')){
|
|
commentLatest[0] = commentLatest[0].substring(0, commentLatest[0].length - 1)
|
|
}
|
|
commentV = new Uint8Array(stackType)
|
|
}
|
|
break
|
|
}
|
|
case '/Thoughts':{
|
|
if(!visualize){
|
|
nested[0] += `<${dat}>`
|
|
break
|
|
}
|
|
if(commentMode){
|
|
nested = commentLatest
|
|
stackType = commentV
|
|
commentMode = false
|
|
}
|
|
break
|
|
}
|
|
default:{
|
|
const mc = isPureMode() ? null : smMatcher(dat, matcherObj)
|
|
nested[0] += mc ?? `<${dat}>`
|
|
break
|
|
}
|
|
}
|
|
break
|
|
}
|
|
default:{
|
|
nested[0] += da[pointer]
|
|
break
|
|
}
|
|
}
|
|
pointer++
|
|
}
|
|
if(commentMode){
|
|
nested = commentLatest
|
|
stackType = commentV
|
|
if(thinkingMode){
|
|
nested[0] += `<div>Thinking...</div>`
|
|
}
|
|
commentMode = false
|
|
}
|
|
if(nested.length === 1){
|
|
return nested[0]
|
|
}
|
|
let result = ''
|
|
while(nested.length > 1){
|
|
let dat = (stackType[nested.length] === 1) ? '{{' : "<"
|
|
dat += nested.shift()
|
|
result = dat + result
|
|
}
|
|
return nested[0] + result
|
|
}
|
|
|
|
|
|
export function getChatVar(key:string){
|
|
const db = get(DataBase)
|
|
const selectedChar = get(selectedCharID)
|
|
const char = db.characters[selectedChar]
|
|
if(!char){
|
|
return 'null'
|
|
}
|
|
const chat = char.chats[char.chatPage]
|
|
chat.scriptstate = chat.scriptstate ?? {}
|
|
const state = (chat.scriptstate['$' + key])
|
|
if(state === undefined || state === null){
|
|
const defaultVariables = parseKeyValue(char.defaultVariables).concat(parseKeyValue(db.templateDefaultVariables))
|
|
const findResult = defaultVariables.find((f) => {
|
|
return f[0] === key
|
|
})
|
|
if(findResult){
|
|
return findResult[1]
|
|
}
|
|
return 'null'
|
|
}
|
|
return state.toString()
|
|
}
|
|
|
|
export function getGlobalChatVar(key:string){
|
|
const db = get(DataBase)
|
|
return db.globalChatVariables[key] ?? 'null'
|
|
}
|
|
|
|
export function setChatVar(key:string, value:string){
|
|
const db = get(DataBase)
|
|
const selectedChar = get(selectedCharID)
|
|
const char = db.characters[selectedChar]
|
|
const chat = char.chats[char.chatPage]
|
|
chat.scriptstate = chat.scriptstate ?? {}
|
|
chat.scriptstate['$' + key] = value
|
|
char.chats[char.chatPage] = chat
|
|
db.characters[selectedChar] = char
|
|
setDatabase(db)
|
|
}
|
|
|
|
|
|
async function editDisplay(text){
|
|
let rt = ""
|
|
if(!text.includes("<obs>")){
|
|
return text
|
|
}
|
|
|
|
for(let i=0;i<text.length;i++){
|
|
const obfiEffect = "!@#$%^&*"
|
|
if(Math.random() < 0.4){
|
|
rt += obfiEffect[Math.floor(Math.random() * obfiEffect.length)]
|
|
}
|
|
rt += text[i]
|
|
}
|
|
return rt
|
|
}
|
|
|
|
export type PromptParsed ={[key:string]:string|PromptParsed}
|
|
|
|
export async function promptTypeParser(prompt:string):Promise<string | PromptParsed>{
|
|
//XML type
|
|
try {
|
|
const parser = new DOMParser()
|
|
const dom = `<root>${prompt}</root>`
|
|
const xmlDoc = parser.parseFromString(dom, "text/xml")
|
|
const root = xmlDoc.documentElement
|
|
|
|
const errorNode = root.getElementsByTagName('parsererror')
|
|
|
|
if(errorNode.length > 0){
|
|
throw new Error('XML Parse Error') //fallback to other parser
|
|
}
|
|
|
|
const parseNode = (node:Element):string|PromptParsed => {
|
|
if(node.children.length === 0){
|
|
return node.textContent
|
|
}
|
|
|
|
const data:{[key:string]:string|PromptParsed} = {}
|
|
|
|
for(let i=0;i<node.children.length;i++){
|
|
const child = node.children[i]
|
|
data[child.tagName] = parseNode(child)
|
|
}
|
|
|
|
return data
|
|
}
|
|
|
|
const pnresult = parseNode(root)
|
|
|
|
if(typeof(pnresult) === 'string'){
|
|
throw new Error('XML Parse Error') //fallback to other parser
|
|
}
|
|
|
|
return pnresult
|
|
|
|
} catch (error) {
|
|
|
|
}
|
|
|
|
return prompt
|
|
} |