@spacebar_ai/moldclaw-core 2026.3.14 → 2026.3.16

package/dist/send-B01Gvh9m.js

@@ -0,0 +1,629 @@
+import { D as TextStyle, _ as sendZaloLink, b as sendZaloTextMessage, g as sendZaloDeliveredEvent, v as sendZaloReaction, x as sendZaloTypingEvent, y as sendZaloSeenEvent } from "./zalouser-CuxRvztM.js";
+//#region extensions/zalouser/src/group-policy.ts
+function toGroupCandidate(value) {
+	return value?.trim() ?? "";
+}
+function normalizeZalouserGroupSlug(raw) {
+	const trimmed = raw?.trim().toLowerCase() ?? "";
+	if (!trimmed) return "";
+	return trimmed.replace(/^#/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function buildZalouserGroupCandidates(params) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	const push = (value) => {
+		const normalized = toGroupCandidate(value);
+		if (!normalized || seen.has(normalized)) return;
+		seen.add(normalized);
+		out.push(normalized);
+	};
+	const groupId = toGroupCandidate(params.groupId);
+	const groupChannel = toGroupCandidate(params.groupChannel);
+	const groupName = toGroupCandidate(params.groupName);
+	push(groupId);
+	if (params.includeGroupIdAlias === true && groupId) push(`group:${groupId}`);
+	if (params.allowNameMatching !== false) {
+		push(groupChannel);
+		push(groupName);
+		if (groupName) push(normalizeZalouserGroupSlug(groupName));
+	}
+	if (params.includeWildcard !== false) push("*");
+	return out;
+}
+function findZalouserGroupEntry(groups, candidates) {
+	if (!groups) return;
+	for (const candidate of candidates) {
+		const entry = groups[candidate];
+		if (entry) return entry;
+	}
+}
+function isZalouserGroupEntryAllowed(entry) {
+	if (!entry) return false;
+	return entry.allow !== false && entry.enabled !== false;
+}
+//#endregion
+//#region extensions/zalouser/src/message-sid.ts
+function toMessageSidPart(value) {
+	if (typeof value === "string") return value.trim();
+	if (typeof value === "number" && Number.isFinite(value)) return String(Math.trunc(value));
+	return "";
+}
+function parseZalouserMessageSidFull(value) {
+	const raw = toMessageSidPart(value);
+	if (!raw) return null;
+	const [msgIdPart, cliMsgIdPart] = raw.split(":").map((entry) => entry.trim());
+	if (!msgIdPart || !cliMsgIdPart) return null;
+	return {
+		msgId: msgIdPart,
+		cliMsgId: cliMsgIdPart
+	};
+}
+function resolveZalouserReactionMessageIds(params) {
+	const explicitMessageId = toMessageSidPart(params.messageId);
+	const explicitCliMsgId = toMessageSidPart(params.cliMsgId);
+	if (explicitMessageId && explicitCliMsgId) return {
+		msgId: explicitMessageId,
+		cliMsgId: explicitCliMsgId
+	};
+	const parsedFromCurrent = parseZalouserMessageSidFull(params.currentMessageId);
+	if (parsedFromCurrent) return parsedFromCurrent;
+	const currentRaw = toMessageSidPart(params.currentMessageId);
+	if (!currentRaw) return null;
+	if (explicitMessageId && !explicitCliMsgId) return {
+		msgId: explicitMessageId,
+		cliMsgId: currentRaw
+	};
+	if (!explicitMessageId && explicitCliMsgId) return {
+		msgId: currentRaw,
+		cliMsgId: explicitCliMsgId
+	};
+	return {
+		msgId: currentRaw,
+		cliMsgId: currentRaw
+	};
+}
+function formatZalouserMessageSidFull(params) {
+	const msgId = toMessageSidPart(params.msgId);
+	const cliMsgId = toMessageSidPart(params.cliMsgId);
+	if (!msgId && !cliMsgId) return;
+	if (msgId && cliMsgId) return `${msgId}:${cliMsgId}`;
+	return msgId || cliMsgId || void 0;
+}
+function resolveZalouserMessageSid(params) {
+	const msgId = toMessageSidPart(params.msgId);
+	const cliMsgId = toMessageSidPart(params.cliMsgId);
+	if (msgId || cliMsgId) return msgId || cliMsgId;
+	return toMessageSidPart(params.fallback) || void 0;
+}
+//#endregion
+//#region extensions/zalouser/src/text-styles.ts
+const TAG_STYLE_MAP = {
+	red: TextStyle.Red,
+	orange: TextStyle.Orange,
+	yellow: TextStyle.Yellow,
+	green: TextStyle.Green,
+	small: null,
+	big: TextStyle.Big,
+	underline: TextStyle.Underline
+};
+const INLINE_MARKERS = [
+	{
+		pattern: /`([^`\n]+)`/g,
+		extractText: (match) => match[0],
+		literal: true
+	},
+	{
+		pattern: /\\([*_~#\\{}>+\-`])/g,
+		extractText: (match) => match[1],
+		literal: true
+	},
+	{
+		pattern: new RegExp(`\\{(${Object.keys(TAG_STYLE_MAP).join("|")})\\}(.+?)\\{/\\1\\}`, "g"),
+		extractText: (match) => match[2],
+		resolveStyles: (match) => {
+			const style = TAG_STYLE_MAP[match[1]];
+			return style ? [style] : [];
+		}
+	},
+	{
+		pattern: /(?<!\*)\*\*\*(?=\S)([^\n]*?\S)(?<!\*)\*\*\*(?!\*)/g,
+		extractText: (match) => match[1],
+		resolveStyles: () => [TextStyle.Bold, TextStyle.Italic]
+	},
+	{
+		pattern: /(?<!\*)\*\*(?![\s*])([^\n]*?\S)(?<!\*)\*\*(?!\*)/g,
+		extractText: (match) => match[1],
+		resolveStyles: () => [TextStyle.Bold]
+	},
+	{
+		pattern: /(?<![\w_])__(?![\s_])([^\n]*?\S)(?<!_)__(?![\w_])/g,
+		extractText: (match) => match[1],
+		resolveStyles: () => [TextStyle.Bold]
+	},
+	{
+		pattern: /(?<!~)~~(?=\S)([^\n]*?\S)(?<!~)~~(?!~)/g,
+		extractText: (match) => match[1],
+		resolveStyles: () => [TextStyle.StrikeThrough]
+	},
+	{
+		pattern: /(?<!\*)\*(?![\s*])([^\n]*?\S)(?<!\*)\*(?!\*)/g,
+		extractText: (match) => match[1],
+		resolveStyles: () => [TextStyle.Italic]
+	},
+	{
+		pattern: /(?<![\w_])_(?![\s_])([^\n]*?\S)(?<!_)_(?![\w_])/g,
+		extractText: (match) => match[1],
+		resolveStyles: () => [TextStyle.Italic]
+	}
+];
+function parseZalouserTextStyles(input) {
+	const allStyles = [];
+	const escapeMap = [];
+	const lines = input.replace(/\r\n?/g, "\n").split("\n");
+	const lineStyles = [];
+	const processedLines = [];
+	let activeFence = null;
+	for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+		const rawLine = lines[lineIndex];
+		const { text: unquotedLine, indent: baseIndent } = stripQuotePrefix(rawLine);
+		if (activeFence) {
+			const codeLine = activeFence.quoteIndent > 0 ? stripQuotePrefix(rawLine, activeFence.quoteIndent).text : rawLine;
+			if (isClosingFence(codeLine, activeFence)) {
+				activeFence = null;
+				continue;
+			}
+			processedLines.push(escapeLiteralText(normalizeCodeBlockLeadingWhitespace(stripCodeFenceIndent(codeLine, activeFence.indent)), escapeMap));
+			continue;
+		}
+		let line = unquotedLine;
+		const openingFence = resolveOpeningFence(rawLine);
+		if (openingFence) {
+			const fenceLine = openingFence.quoteIndent > 0 ? unquotedLine : rawLine;
+			if (!hasClosingFence(lines, lineIndex + 1, openingFence)) {
+				processedLines.push(escapeLiteralText(fenceLine, escapeMap));
+				activeFence = openingFence;
+				continue;
+			}
+			activeFence = openingFence;
+			continue;
+		}
+		const outputLineIndex = processedLines.length;
+		if (isIndentedCodeBlockLine(line)) {
+			if (baseIndent > 0) lineStyles.push({
+				lineIndex: outputLineIndex,
+				style: TextStyle.Indent,
+				indentSize: baseIndent
+			});
+			processedLines.push(escapeLiteralText(normalizeCodeBlockLeadingWhitespace(line), escapeMap));
+			continue;
+		}
+		const { text: markdownLine, size: markdownPadding } = stripOptionalMarkdownPadding(line);
+		const headingMatch = markdownLine.match(/^(#{1,4})\s(.*)$/);
+		if (headingMatch) {
+			const depth = headingMatch[1].length;
+			lineStyles.push({
+				lineIndex: outputLineIndex,
+				style: TextStyle.Bold
+			});
+			if (depth === 1) lineStyles.push({
+				lineIndex: outputLineIndex,
+				style: TextStyle.Big
+			});
+			if (baseIndent > 0) lineStyles.push({
+				lineIndex: outputLineIndex,
+				style: TextStyle.Indent,
+				indentSize: baseIndent
+			});
+			processedLines.push(headingMatch[2]);
+			continue;
+		}
+		const indentMatch = markdownLine.match(/^(\s+)(.*)$/);
+		let indentLevel = 0;
+		let content = markdownLine;
+		if (indentMatch) {
+			indentLevel = clampIndent(indentMatch[1].length);
+			content = indentMatch[2];
+		}
+		const totalIndent = Math.min(5, baseIndent + indentLevel);
+		if (/^[-*+]\s\[[ xX]\]\s/.test(content)) {
+			if (totalIndent > 0) lineStyles.push({
+				lineIndex: outputLineIndex,
+				style: TextStyle.Indent,
+				indentSize: totalIndent
+			});
+			processedLines.push(content);
+			continue;
+		}
+		const orderedListMatch = content.match(/^(\d+)\.\s(.*)$/);
+		if (orderedListMatch) {
+			if (totalIndent > 0) lineStyles.push({
+				lineIndex: outputLineIndex,
+				style: TextStyle.Indent,
+				indentSize: totalIndent
+			});
+			lineStyles.push({
+				lineIndex: outputLineIndex,
+				style: TextStyle.OrderedList
+			});
+			processedLines.push(orderedListMatch[2]);
+			continue;
+		}
+		const unorderedListMatch = content.match(/^[-*+]\s(.*)$/);
+		if (unorderedListMatch) {
+			if (totalIndent > 0) lineStyles.push({
+				lineIndex: outputLineIndex,
+				style: TextStyle.Indent,
+				indentSize: totalIndent
+			});
+			lineStyles.push({
+				lineIndex: outputLineIndex,
+				style: TextStyle.UnorderedList
+			});
+			processedLines.push(unorderedListMatch[1]);
+			continue;
+		}
+		if (markdownPadding > 0) {
+			if (baseIndent > 0) lineStyles.push({
+				lineIndex: outputLineIndex,
+				style: TextStyle.Indent,
+				indentSize: baseIndent
+			});
+			processedLines.push(line);
+			continue;
+		}
+		if (totalIndent > 0) {
+			lineStyles.push({
+				lineIndex: outputLineIndex,
+				style: TextStyle.Indent,
+				indentSize: totalIndent
+			});
+			processedLines.push(content);
+			continue;
+		}
+		processedLines.push(line);
+	}
+	const segments = parseInlineSegments(processedLines.join("\n"));
+	let plainText = "";
+	for (const segment of segments) {
+		const start = plainText.length;
+		plainText += segment.text;
+		for (const style of segment.styles) allStyles.push({
+			start,
+			len: segment.text.length,
+			st: style
+		});
+	}
+	if (escapeMap.length > 0) {
+		const escapeRegex = /\x01(\d+)\x02/g;
+		const shifts = [];
+		let cumulativeDelta = 0;
+		for (const match of plainText.matchAll(escapeRegex)) {
+			const escapeIndex = Number.parseInt(match[1], 10);
+			cumulativeDelta += match[0].length - escapeMap[escapeIndex].length;
+			shifts.push({
+				pos: (match.index ?? 0) + match[0].length,
+				delta: cumulativeDelta
+			});
+		}
+		for (const style of allStyles) {
+			let startDelta = 0;
+			let endDelta = 0;
+			const end = style.start + style.len;
+			for (const shift of shifts) {
+				if (shift.pos <= style.start) startDelta = shift.delta;
+				if (shift.pos <= end) endDelta = shift.delta;
+			}
+			style.start -= startDelta;
+			style.len -= endDelta - startDelta;
+		}
+		plainText = plainText.replace(escapeRegex, (_match, index) => escapeMap[Number.parseInt(index, 10)]);
+	}
+	const finalLines = plainText.split("\n");
+	let offset = 0;
+	for (let lineIndex = 0; lineIndex < finalLines.length; lineIndex += 1) {
+		const lineLength = finalLines[lineIndex].length;
+		if (lineLength > 0) for (const lineStyle of lineStyles) {
+			if (lineStyle.lineIndex !== lineIndex) continue;
+			if (lineStyle.style === TextStyle.Indent) allStyles.push({
+				start: offset,
+				len: lineLength,
+				st: TextStyle.Indent,
+				indentSize: lineStyle.indentSize
+			});
+			else allStyles.push({
+				start: offset,
+				len: lineLength,
+				st: lineStyle.style
+			});
+		}
+		offset += lineLength + 1;
+	}
+	return {
+		text: plainText,
+		styles: allStyles
+	};
+}
+function clampIndent(spaceCount) {
+	return Math.min(5, Math.max(1, Math.floor(spaceCount / 2)));
+}
+function stripOptionalMarkdownPadding(line) {
+	const match = line.match(/^( {1,3})(?=\S)/);
+	if (!match) return {
+		text: line,
+		size: 0
+	};
+	return {
+		text: line.slice(match[1].length),
+		size: match[1].length
+	};
+}
+function hasClosingFence(lines, startIndex, fence) {
+	for (let index = startIndex; index < lines.length; index += 1) if (isClosingFence(fence.quoteIndent > 0 ? stripQuotePrefix(lines[index], fence.quoteIndent).text : lines[index], fence)) return true;
+	return false;
+}
+function resolveOpeningFence(line) {
+	const directFence = parseFenceMarker(line);
+	if (directFence) return {
+		...directFence,
+		quoteIndent: 0
+	};
+	const quoted = stripQuotePrefix(line);
+	if (quoted.indent === 0) return null;
+	const quotedFence = parseFenceMarker(quoted.text);
+	if (!quotedFence) return null;
+	return {
+		...quotedFence,
+		quoteIndent: quoted.indent
+	};
+}
+function stripQuotePrefix(line, maxDepth = Number.POSITIVE_INFINITY) {
+	let cursor = 0;
+	while (cursor < line.length && cursor < 3 && line[cursor] === " ") cursor += 1;
+	let removedDepth = 0;
+	let consumedCursor = cursor;
+	while (removedDepth < maxDepth && consumedCursor < line.length && line[consumedCursor] === ">") {
+		removedDepth += 1;
+		consumedCursor += 1;
+		if (line[consumedCursor] === " ") consumedCursor += 1;
+	}
+	if (removedDepth === 0) return {
+		text: line,
+		indent: 0
+	};
+	return {
+		text: line.slice(consumedCursor),
+		indent: Math.min(5, removedDepth)
+	};
+}
+function parseFenceMarker(line) {
+	const match = line.match(/^([ ]{0,3})(`{3,}|~{3,})(.*)$/);
+	if (!match) return null;
+	const marker = match[2];
+	const char = marker[0];
+	if (char !== "`" && char !== "~") return null;
+	return {
+		char,
+		length: marker.length,
+		indent: match[1].length
+	};
+}
+function isClosingFence(line, fence) {
+	const match = line.match(/^([ ]{0,3})(`{3,}|~{3,})[ \t]*$/);
+	if (!match) return false;
+	return match[2][0] === fence.char && match[2].length >= fence.length;
+}
+function escapeLiteralText(input, escapeMap) {
+	return input.replace(/[\\*_~{}`]/g, (ch) => {
+		const index = escapeMap.length;
+		escapeMap.push(ch);
+		return `\x01${index}\x02`;
+	});
+}
+function parseInlineSegments(text, inheritedStyles = []) {
+	const segments = [];
+	let cursor = 0;
+	while (cursor < text.length) {
+		const nextMatch = findNextInlineMatch(text, cursor);
+		if (!nextMatch) {
+			pushSegment(segments, text.slice(cursor), inheritedStyles);
+			break;
+		}
+		if (nextMatch.match.index > cursor) pushSegment(segments, text.slice(cursor, nextMatch.match.index), inheritedStyles);
+		const combinedStyles = [...inheritedStyles, ...nextMatch.styles];
+		if (nextMatch.marker.literal) pushSegment(segments, nextMatch.text, combinedStyles);
+		else segments.push(...parseInlineSegments(nextMatch.text, combinedStyles));
+		cursor = nextMatch.match.index + nextMatch.match[0].length;
+	}
+	return segments;
+}
+function findNextInlineMatch(text, startIndex) {
+	let bestMatch = null;
+	for (const [priority, marker] of INLINE_MARKERS.entries()) {
+		const regex = new RegExp(marker.pattern.source, marker.pattern.flags);
+		regex.lastIndex = startIndex;
+		const match = regex.exec(text);
+		if (!match) continue;
+		if (bestMatch && (match.index > bestMatch.match.index || match.index === bestMatch.match.index && priority > bestMatch.priority)) continue;
+		bestMatch = {
+			match,
+			marker,
+			text: marker.extractText(match),
+			styles: marker.resolveStyles?.(match) ?? [],
+			priority
+		};
+	}
+	return bestMatch;
+}
+function pushSegment(segments, text, styles) {
+	if (!text) return;
+	const lastSegment = segments.at(-1);
+	if (lastSegment && sameStyles(lastSegment.styles, styles)) {
+		lastSegment.text += text;
+		return;
+	}
+	segments.push({
+		text,
+		styles: [...styles]
+	});
+}
+function sameStyles(left, right) {
+	return left.length === right.length && left.every((style, index) => style === right[index]);
+}
+function normalizeCodeBlockLeadingWhitespace(line) {
+	return line.replace(/^[ \t]+/, (leadingWhitespace) => leadingWhitespace.replace(/\t/g, "\xA0\xA0\xA0\xA0").replace(/ /g, "\xA0"));
+}
+function isIndentedCodeBlockLine(line) {
+	return /^(?: {4,}|\t)/.test(line);
+}
+function stripCodeFenceIndent(line, indent) {
+	let consumed = 0;
+	let cursor = 0;
+	while (cursor < line.length && consumed < indent && line[cursor] === " ") {
+		cursor += 1;
+		consumed += 1;
+	}
+	return line.slice(cursor);
+}
+//#endregion
+//#region extensions/zalouser/src/send.ts
+const ZALO_TEXT_LIMIT = 2e3;
+const DEFAULT_TEXT_CHUNK_MODE = "length";
+async function sendMessageZalouser(threadId, text, options = {}) {
+	const prepared = options.textMode === "markdown" ? parseZalouserTextStyles(text) : {
+		text,
+		styles: options.textStyles
+	};
+	const textChunkLimit = options.textChunkLimit ?? ZALO_TEXT_LIMIT;
+	const chunks = splitStyledText(prepared.text, (prepared.styles?.length ?? 0) > 0 ? prepared.styles : void 0, textChunkLimit, options.textChunkMode);
+	let lastResult = null;
+	for (const [index, chunk] of chunks.entries()) {
+		const chunkOptions = index === 0 ? {
+			...options,
+			textStyles: chunk.styles
+		} : {
+			...options,
+			caption: void 0,
+			mediaLocalRoots: void 0,
+			mediaUrl: void 0,
+			textStyles: chunk.styles
+		};
+		const result = await sendZaloTextMessage(threadId, chunk.text, chunkOptions);
+		if (!result.ok) return result;
+		lastResult = result;
+	}
+	return lastResult ?? {
+		ok: false,
+		error: "No message content provided"
+	};
+}
+async function sendImageZalouser(threadId, imageUrl, options = {}) {
+	return await sendMessageZalouser(threadId, options.caption ?? "", {
+		...options,
+		caption: void 0,
+		mediaUrl: imageUrl
+	});
+}
+async function sendLinkZalouser(threadId, url, options = {}) {
+	return await sendZaloLink(threadId, url, options);
+}
+async function sendTypingZalouser(threadId, options = {}) {
+	await sendZaloTypingEvent(threadId, options);
+}
+async function sendReactionZalouser(params) {
+	const result = await sendZaloReaction({
+		profile: params.profile,
+		threadId: params.threadId,
+		isGroup: params.isGroup,
+		msgId: params.msgId,
+		cliMsgId: params.cliMsgId,
+		emoji: params.emoji,
+		remove: params.remove
+	});
+	return {
+		ok: result.ok,
+		error: result.error
+	};
+}
+async function sendDeliveredZalouser(params) {
+	await sendZaloDeliveredEvent(params);
+}
+async function sendSeenZalouser(params) {
+	await sendZaloSeenEvent(params);
+}
+function splitStyledText(text, styles, limit, mode) {
+	if (text.length === 0) return [{
+		text,
+		styles: void 0
+	}];
+	const chunks = [];
+	for (const range of splitTextRanges(text, limit, mode ?? DEFAULT_TEXT_CHUNK_MODE)) {
+		const { start, end } = range;
+		chunks.push({
+			text: text.slice(start, end),
+			styles: sliceTextStyles(styles, start, end)
+		});
+	}
+	return chunks;
+}
+function sliceTextStyles(styles, start, end) {
+	if (!styles || styles.length === 0) return;
+	const chunkStyles = styles.map((style) => {
+		const overlapStart = Math.max(style.start, start);
+		const overlapEnd = Math.min(style.start + style.len, end);
+		if (overlapEnd <= overlapStart) return null;
+		if (style.st === TextStyle.Indent) return {
+			start: overlapStart - start,
+			len: overlapEnd - overlapStart,
+			st: style.st,
+			indentSize: style.indentSize
+		};
+		return {
+			start: overlapStart - start,
+			len: overlapEnd - overlapStart,
+			st: style.st
+		};
+	}).filter((style) => style !== null);
+	return chunkStyles.length > 0 ? chunkStyles : void 0;
+}
+function splitTextRanges(text, limit, mode) {
+	if (mode === "newline") return splitTextRangesByPreferredBreaks(text, limit);
+	const ranges = [];
+	for (let start = 0; start < text.length; start += limit) ranges.push({
+		start,
+		end: Math.min(text.length, start + limit)
+	});
+	return ranges;
+}
+function splitTextRangesByPreferredBreaks(text, limit) {
+	const ranges = [];
+	let start = 0;
+	while (start < text.length) {
+		const maxEnd = Math.min(text.length, start + limit);
+		let end = maxEnd;
+		if (maxEnd < text.length) end = findParagraphBreak(text, start, maxEnd) ?? findLastBreak(text, "\n", start, maxEnd) ?? findLastWhitespaceBreak(text, start, maxEnd) ?? maxEnd;
+		if (end <= start) end = maxEnd;
+		ranges.push({
+			start,
+			end
+		});
+		start = end;
+	}
+	return ranges;
+}
+function findParagraphBreak(text, start, end) {
+	const matches = text.slice(start, end).matchAll(/\n[\t ]*\n+/g);
+	let lastMatch;
+	for (const match of matches) lastMatch = match;
+	if (!lastMatch || lastMatch.index === void 0) return;
+	return start + lastMatch.index + lastMatch[0].length;
+}
+function findLastBreak(text, marker, start, end) {
+	const index = text.lastIndexOf(marker, end - 1);
+	if (index < start) return;
+	return index + marker.length;
+}
+function findLastWhitespaceBreak(text, start, end) {
+	for (let index = end - 1; index > start; index -= 1) if (/\s/.test(text[index])) return index + 1;
+}
+//#endregion
+export { sendReactionZalouser as a, formatZalouserMessageSidFull as c, buildZalouserGroupCandidates as d, findZalouserGroupEntry as f, sendMessageZalouser as i, resolveZalouserMessageSid as l, sendImageZalouser as n, sendSeenZalouser as o, isZalouserGroupEntryAllowed as p, sendLinkZalouser as r, sendTypingZalouser as s, sendDeliveredZalouser as t, resolveZalouserReactionMessageIds as u };