@openclaw/discord 2026.8.1-beta.3 → 2026.8.1

package/dist/send.reactions-gmJ6yFPo.js

@@ -1,78 +0,0 @@
-import { Tt as getChannelMessage, _t as listMessageReactionUsers, gt as deleteOwnMessageReaction, ht as createOwnMessageReaction } from "./retry-DNsVTeTo.js";
-import { P as createDiscordClient, i as formatReactionEmoji, r as buildReactionIdentifier, s as normalizeReactionEmoji } from "./send.shared-B3fpaLWJ.js";
-import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
-//#region extensions/discord/src/send.reactions.ts
-function createDiscordReactionRuntimeClient(opts) {
-	return createDiscordClient(opts);
-}
-function resolveDiscordReactionClient(opts) {
-	if (!opts.cfg) throw new Error("Discord reactions requires a resolved runtime config. Load and resolve config at the command or gateway boundary, then pass cfg through the runtime path.");
-	const cfg = requireRuntimeConfig(opts.cfg, "Discord reactions");
-	return createDiscordClient({
-		...opts,
-		cfg
-	});
-}
-function isDiscordReactionRuntimeContext(opts) {
-	return Boolean(opts.rest && opts.cfg && opts.accountId);
-}
-async function reactMessageDiscord(channelId, messageId, emoji, opts) {
-	const { rest, request } = isDiscordReactionRuntimeContext(opts) ? createDiscordReactionRuntimeClient(opts) : resolveDiscordReactionClient(opts);
-	const encoded = normalizeReactionEmoji(emoji);
-	await request(() => createOwnMessageReaction(rest, channelId, messageId, encoded), "react");
-	return { ok: true };
-}
-async function removeReactionDiscord(channelId, messageId, emoji, opts) {
-	const { rest, request } = isDiscordReactionRuntimeContext(opts) ? createDiscordReactionRuntimeClient(opts) : resolveDiscordReactionClient(opts);
-	const encoded = normalizeReactionEmoji(emoji);
-	await request(() => deleteOwnMessageReaction(rest, channelId, messageId, encoded), "reaction-remove");
-	return { ok: true };
-}
-async function removeOwnReactionsDiscord(channelId, messageId, opts) {
-	const { rest, request } = isDiscordReactionRuntimeContext(opts) ? createDiscordReactionRuntimeClient(opts) : resolveDiscordReactionClient(opts);
-	const message = await request(() => getChannelMessage(rest, channelId, messageId), "reaction-list");
-	const identifiers = /* @__PURE__ */ new Set();
-	for (const reaction of message.reactions ?? []) {
-		const identifier = reaction.me ? buildReactionIdentifier(reaction.emoji) : void 0;
-		if (identifier) identifiers.add(identifier);
-	}
-	if (identifiers.size === 0) return {
-		ok: true,
-		removed: []
-	};
-	const removed = Array.from(identifiers);
-	await Promise.all(removed.map((identifier) => request(() => deleteOwnMessageReaction(rest, channelId, messageId, normalizeReactionEmoji(identifier)), "reaction-remove")));
-	return {
-		ok: true,
-		removed
-	};
-}
-async function fetchReactionsDiscord(channelId, messageId, opts) {
-	const { rest, request } = isDiscordReactionRuntimeContext(opts) ? createDiscordReactionRuntimeClient(opts) : resolveDiscordReactionClient(opts);
-	const reactions = (await request(() => getChannelMessage(rest, channelId, messageId), "reaction-list")).reactions ?? [];
-	if (reactions.length === 0) return [];
-	const limit = typeof opts.limit === "number" && Number.isFinite(opts.limit) ? Math.min(Math.max(Math.floor(opts.limit), 1), 100) : 100;
-	const summaries = [];
-	for (const reaction of reactions) {
-		const identifier = buildReactionIdentifier(reaction.emoji);
-		if (!identifier) continue;
-		const encoded = encodeURIComponent(identifier);
-		const users = await request(() => listMessageReactionUsers(rest, channelId, messageId, encoded, { limit }), "reaction-users");
-		summaries.push({
-			emoji: {
-				id: reaction.emoji.id ?? null,
-				name: reaction.emoji.name ?? null,
-				raw: formatReactionEmoji(reaction.emoji)
-			},
-			count: reaction.count,
-			users: users.map((user) => ({
-				id: user.id,
-				username: user.username,
-				tag: user.username && user.discriminator ? `${user.username}#${user.discriminator}` : user.username
-			}))
-		});
-	}
-	return summaries;
-}
-//#endregion
-export { removeReactionDiscord as i, reactMessageDiscord as n, removeOwnReactionsDiscord as r, fetchReactionsDiscord as t };

package/dist/send.receipt-Cnhoautb.js

@@ -1,76 +0,0 @@
-import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
-import { attachChannelToResults } from "openclaw/plugin-sdk/channel-send-result";
-//#region extensions/discord/src/send.receipt.ts
-function toDiscordOutboundDeliveryResult(result) {
-	const { channelId, ...delivery } = result;
-	return {
-		...delivery,
-		target: {
-			kind: "channel",
-			id: channelId
-		}
-	};
-}
-function createDiscordSendReceiptFromResults(params) {
-	const receipt = createMessageReceiptFromOutboundResults({
-		results: attachChannelToResults("discord", params.results),
-		threadId: params.threadId
-	});
-	return {
-		...receipt,
-		parts: receipt.parts.map(({ platformMessageId, kind, threadId, replyToId, raw }, index) => ({
-			platformMessageId,
-			kind,
-			index,
-			threadId,
-			replyToId,
-			raw
-		}))
-	};
-}
-function createDiscordSendReceipt(params) {
-	return createMessageReceiptFromOutboundResults({
-		results: params.platformMessageIds.map((messageId) => messageId.trim()).filter((messageId) => messageId && messageId !== "unknown").map((messageId, index) => {
-			const result = {
-				channel: "discord",
-				messageId
-			};
-			if (params.channelId) result.channelId = params.channelId;
-			if (params.reply?.scope === "first" && index === 0) {
-				const rawResult = {
-					channel: "discord",
-					messageId
-				};
-				if (params.channelId) rawResult.channelId = params.channelId;
-				result.receipt = createMessageReceiptFromOutboundResults({
-					results: [rawResult],
-					kind: params.kind,
-					threadId: params.threadId,
-					replyToId: params.reply.messageId
-				});
-			}
-			return result;
-		}),
-		kind: params.kind,
-		threadId: params.threadId,
-		replyToId: params.reply?.scope === "all" ? params.reply.messageId : void 0
-	});
-}
-function createDiscordSendResult(params) {
-	const messageId = params.result.id || "unknown";
-	const channelId = params.result.channel_id ?? params.fallbackChannelId;
-	const receiptParams = {
-		platformMessageIds: params.result.platformMessageIds?.length ? params.result.platformMessageIds : [messageId],
-		channelId,
-		kind: params.kind
-	};
-	if (params.threadId != null) receiptParams.threadId = String(params.threadId);
-	if (params.reply) receiptParams.reply = params.reply;
-	return {
-		messageId,
-		channelId,
-		receipt: createDiscordSendReceipt(receiptParams)
-	};
-}
-//#endregion
-export { toDiscordOutboundDeliveryResult as i, createDiscordSendReceiptFromResults as n, createDiscordSendResult as r, createDiscordSendReceipt as t };

package/dist/subagent-progress-FPLqBY1s.js

@@ -1,110 +0,0 @@
-import { c as resolveDiscordAccount, u as resolveDiscordAccountConfig } from "./accounts-DNl-oCEw.js";
-import { i as removeReactionDiscord } from "./send.reactions-gmJ6yFPo.js";
-import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/routing";
-import { listAgentIds, resolveAgentConfig } from "openclaw/plugin-sdk/agent-scope-runtime";
-import { DEFAULT_EMOJIS } from "openclaw/plugin-sdk/channel-feedback";
-//#region extensions/discord/src/subagent-progress.ts
-const PROGRESS_STORE_TTL_MS = 10080 * 6e4;
-const MAX_TRACKED_RUNS = 4096;
-const RETRY_BASE_DELAY_MS = 1e3;
-const RETRY_MAX_DELAY_MS = 60 * 6e4;
-const RETRY_MAX_ATTEMPTS = 12;
-const HISTORICAL_RUNNING_EMOJIS = /* @__PURE__ */ new Set([
-	"1️⃣",
-	"2️⃣",
-	"3️⃣",
-	"4️⃣",
-	"5️⃣",
-	"6️⃣",
-	"7️⃣",
-	"8️⃣",
-	"9️⃣",
-	"🔟"
-]);
-const recoveryRetries = /* @__PURE__ */ new Map();
-function logFailure(api, action, error) {
-	const message = error instanceof Error ? error.message : String(error);
-	api.logger.debug?.(`discord retired subagent progress ${action} failed: ${message}`);
-}
-function reservedReactionEmojis(api, accountAckReaction) {
-	const reserved = new Set(Object.values(DEFAULT_EMOJIS));
-	for (const emoji of [api.config.messages?.ackReaction, accountAckReaction]) if (emoji?.trim()) reserved.add(emoji.trim());
-	for (const agentId of listAgentIds(api.config)) {
-		const emoji = resolveAgentConfig(api.config, agentId)?.identity?.emoji?.trim();
-		if (emoji) reserved.add(emoji);
-	}
-	return reserved;
-}
-function clearRecoveryRetry(api) {
-	const retry = recoveryRetries.get(api);
-	if (retry?.timer) clearTimeout(retry.timer);
-	recoveryRetries.delete(api);
-}
-function scheduleRecoveryRetry(api) {
-	const retry = recoveryRetries.get(api) ?? { attempts: 0 };
-	if (retry.timer || retry.attempts >= RETRY_MAX_ATTEMPTS) return;
-	const delayMs = Math.min(RETRY_BASE_DELAY_MS * 2 ** retry.attempts, RETRY_MAX_DELAY_MS);
-	retry.attempts += 1;
-	retry.timer = setTimeout(() => {
-		retry.timer = void 0;
-		recoverDiscordSubagentProgress(api);
-	}, delayMs);
-	retry.timer.unref?.();
-	recoveryRetries.set(api, retry);
-}
-async function cleanPersistedReaction(api, store, entry) {
-	try {
-		if (entry.value.accountId !== DEFAULT_ACCOUNT_ID && !resolveDiscordAccountConfig(api.config, entry.value.accountId)) return false;
-		const account = resolveDiscordAccount({
-			cfg: api.config,
-			accountId: entry.value.accountId
-		});
-		if (!account.enabled || account.tokenStatus !== "available") return false;
-		const emoji = entry.value.runningEmoji;
-		if (emoji && HISTORICAL_RUNNING_EMOJIS.has(emoji) && !reservedReactionEmojis(api, account.config.ackReaction).has(emoji)) await removeReactionDiscord(entry.value.channelId, entry.value.messageId, emoji, {
-			cfg: api.config,
-			accountId: entry.value.accountId
-		});
-		await store.consume(entry.key);
-		return true;
-	} catch (error) {
-		logFailure(api, "startup cleanup", error);
-		return false;
-	}
-}
-async function recoverDiscordSubagentProgressImpl(api) {
-	let store;
-	try {
-		store = api.runtime.state.openKeyedStore({
-			namespace: "subagent-progress",
-			maxEntries: MAX_TRACKED_RUNS,
-			overflowPolicy: "reject-new",
-			defaultTtlMs: PROGRESS_STORE_TTL_MS
-		});
-	} catch (error) {
-		logFailure(api, "state store open", error);
-		scheduleRecoveryRetry(api);
-		return;
-	}
-	let entries;
-	try {
-		entries = await store.entries();
-	} catch (error) {
-		logFailure(api, "startup recovery list", error);
-		scheduleRecoveryRetry(api);
-		return;
-	}
-	let retryNeeded = false;
-	for (const entry of entries) if (!await cleanPersistedReaction(api, store, entry)) retryNeeded = true;
-	if (retryNeeded) scheduleRecoveryRetry(api);
-	else clearRecoveryRetry(api);
-}
-function resetDiscordSubagentProgressForTest() {
-	for (const [api, retry] of recoveryRetries) {
-		if (retry.timer) clearTimeout(retry.timer);
-		recoveryRetries.delete(api);
-	}
-}
-const recoverDiscordSubagentProgress = Object.assign(recoverDiscordSubagentProgressImpl, { resetForTest: resetDiscordSubagentProgressForTest });
-//#endregion
-export { recoverDiscordSubagentProgress };

package/dist/targets-B2pf49zc.js

@@ -1,3 +0,0 @@
-import "./accounts-DNl-oCEw.js";
-import "./target-resolver-DIXShHaZ.js";
-export {};

package/node_modules/typebox/build/format/_idna.d.mts

@@ -1,2 +0,0 @@
-export declare function IsIdnLabel(value: string): boolean;
-export declare function IsLabel(value: string): boolean;

package/node_modules/typebox/build/format/_idna.mjs

@@ -1,246 +0,0 @@
-import { Unreachable } from '../system/unreachable/index.mjs';
-import * as Puny from './_puny.mjs';
-// ------------------------------------------------------------------
-// Unicode General Category Helper (RFC 5892)
-// ------------------------------------------------------------------
-function IsNonspacingMark(cp) {
-    return /\p{Mn}/u.test(String.fromCodePoint(cp));
-}
-function IsSpacingCombiningMark(cp) {
-    return /\p{Mc}/u.test(String.fromCodePoint(cp));
-}
-function IsEnclosingMark(cp) {
-    return /\p{Me}/u.test(String.fromCodePoint(cp));
-}
-function IsCombiningMark(cp) {
-    return IsNonspacingMark(cp) || IsSpacingCombiningMark(cp) || IsEnclosingMark(cp);
-}
-// ------------------------------------------------------------------
-// RFC 5892 §2.6 DISALLOWED exceptions
-//
-// https://tools.ietf.org/html/rfc5892#section-2.6
-// ------------------------------------------------------------------
-const RFC5892_DISALLOWED = new Set([
-    0x0640, // ARABIC TATWEEL
-    0x07fa, // NKO LAJANYALAN
-    0x302e, // HANGUL SINGLE DOT TONE MARK
-    0x302f, // HANGUL DOUBLE DOT TONE MARK
-    0x3031, // VERTICAL KANA REPEAT MARK
-    0x3032, // VERTICAL KANA REPEAT WITH VOICED ITERATION MARK
-    0x3033, // VERTICAL KANA REPEAT MARK UPPER HALF
-    0x3034, // VERTICAL KANA REPEAT WITH VOICED ITERATION MARK UPPER HALF
-    0x3035, // VERTICAL KANA REPEAT MARK LOWER HALF
-    0x303b // VERTICAL IDEOGRAPHIC ITERATION MARK
-]);
-// ------------------------------------------------------------------
-// A set of Virama (halant) code points used to validate CONTEXTJ
-// rules (RFC 5892 Appendix A.1). These characters allow a subsequent
-// Zero Width Non-Joiner (U+200C) or Zero Width Joiner (U+200D) to
-// be valid in a label.
-// ------------------------------------------------------------------
-const VIRAMA_CPS = new Set([
-    0x094d,
-    0x09cd,
-    0x0a4d,
-    0x0acd,
-    0x0b4d,
-    0x0bcd,
-    0x0c4d,
-    0x0ccd,
-    0x0d3b,
-    0x0d3c,
-    0x0d4d,
-    0x0dca,
-    0x1b44,
-    0x1baa,
-    0x1bab,
-    0xa9c0,
-    0x11046,
-    0x1107f,
-    0x110b9,
-    0x11133,
-    0x11134,
-    0x111c0,
-    0x11235,
-    0x1134d,
-    0x11442,
-    0x114c2,
-    0x115bf,
-    0x1163f,
-    0x116b6,
-    0x11c3f,
-    0x11d44,
-    0x11d45
-]);
-// ------------------------------------------------------------------
-// Guards for CONTEXTO rules (RFC 5892 Appendix A)
-// ------------------------------------------------------------------
-function IsGreek(cp) {
-    return /\p{Script=Greek}/u.test(String.fromCodePoint(cp));
-}
-function IsHebrew(cp) {
-    return /\p{Script=Hebrew}/u.test(String.fromCodePoint(cp));
-}
-function IsHiragana(cp) {
-    return /\p{Script=Hiragana}/u.test(String.fromCodePoint(cp));
-}
-function IsKatakana(cp) {
-    return /\p{Script=Katakana}/u.test(String.fromCodePoint(cp));
-}
-function IsHan(cp) {
-    return /\p{Script=Han}/u.test(String.fromCodePoint(cp));
-}
-function IsArabicIndicDigit(cp) {
-    return cp >= 0x0660 && cp <= 0x0669;
-}
-function IsExtendedArabicIndicDigit(cp) {
-    return cp >= 0x06f0 && cp <= 0x06f9;
-}
-function IsVirama(cp) {
-    return VIRAMA_CPS.has(cp);
-}
-// ------------------------------------------------------------------
-// IsUnicodeLabel
-// ------------------------------------------------------------------
-function IsUnicodeLabel(value) {
-    // deno-coverage-ignore-start - unable to reach via format guards
-    if (value.length === 0)
-        return Unreachable(); // false
-    // deno-coverage-ignore-stop
-    // Use spread to handle surrogate pairs and provide O(1) neighbor access
-    const cps = [...value].map((c) => c.codePointAt(0));
-    const len = cps.length;
-    // RFC 5891 §4.2.3.2: Hyphen rules
-    if (cps[0] === 0x2d || cps[len - 1] === 0x2d)
-        return false;
-    if (len >= 4 && cps[2] === 0x2d && cps[3] === 0x2d)
-        return false;
-    // RFC 5891 §4.2.3.2 - Must not begin with a combining mark
-    if (IsCombiningMark(cps[0]))
-        return false;
-    let hasJapanese = false;
-    let hasArabicIndic = false;
-    let hasExtendedArabicIndic = false;
-    for (let i = 0; i < len; i++) {
-        const cp = cps[i];
-        // 1. DISALLOWED exceptions
-        if (RFC5892_DISALLOWED.has(cp))
-            return false;
-        // 2. Collect Flags
-        if (IsHiragana(cp) || IsKatakana(cp) || IsHan(cp))
-            hasJapanese = true;
-        if (IsArabicIndicDigit(cp))
-            hasArabicIndic = true;
-        if (IsExtendedArabicIndicDigit(cp))
-            hasExtendedArabicIndic = true;
-        // 3. CONTEXTO / CONTEXTJ Neighbor Rules
-        const prev = cps[i - 1], next = cps[i + 1];
-        switch (cp) {
-            case 0x00b7:
-                if (prev !== 0x006c || next !== 0x006c)
-                    return false;
-                break; // MIDDLE DOT (Catalan)
-            case 0x0375:
-                if (next === undefined || !IsGreek(next))
-                    return false;
-                break; // Greek KERAIA
-            case 0x05f3:
-            case 0x05f4:
-                if (prev === undefined || !IsHebrew(prev))
-                    return false;
-                break; // Hebrew GERESH
-            case 0x200c: // ZWNJ - RFC 5892 Appendix A.1
-                // Note: Full validation requires a Unicode joining type table. We reject
-                // only when preceded by ASCII (U+0000-U+007F), which can never satisfy
-                // the Virama or cursive-joining rules.
-                if (prev === undefined || (prev < 0x0080 && !IsVirama(prev)))
-                    return false;
-                break;
-            case 0x200d: // ZWJ  - RFC 5892 Appendix A.2
-                if (prev === undefined || !IsVirama(prev))
-                    return false;
-                break;
-            case 0x30fb: /* Checked at end via hasJapanese */
-                break; // KATAKANA MIDDLE DOT
-        }
-    }
-    // 4. Global Context Validations (Post-loop)
-    // RFC 5892 Appendix A.7 - Katakana Middle Dot requirement
-    if (value.includes('\u30fb') && !hasJapanese)
-        return false;
-    // RFC 5892 Appendix A.8/A.9 - Mixing Arabic Digits
-    if (hasArabicIndic && hasExtendedArabicIndic)
-        return false;
-    return true;
-}
-// ------------------------------------------------------------------
-// IsAsciiLabel
-// ------------------------------------------------------------------
-function IsAsciiLabel(value) {
-    // Must not start or end with a hyphen
-    if (value.charCodeAt(0) === 45 || value.charCodeAt(value.length - 1) === 45)
-        return false;
-    // RFC 5891 §4.2.3.1 : "--" at positions 3-4 is reserved for A-labels only
-    if (value.length >= 4 && value.charCodeAt(2) === 45 && value.charCodeAt(3) === 45)
-        return false;
-    // All characters must be alphanumeric or hyphen
-    for (let i = 0; i < value.length; i++) {
-        const ch = value.charCodeAt(i);
-        if (!((ch >= 97 && ch <= 122) || // a-z
-            (ch >= 65 && ch <= 90) || // A-Z
-            (ch >= 48 && ch <= 57) || // 0-9
-            ch === 45 // '-'
-        ))
-            return false;
-    }
-    return true;
-}
-// ------------------------------------------------------------------
-// IsPunyLabel
-// ------------------------------------------------------------------
-function IsPuny(value) {
-    return value.toLowerCase().startsWith('xn--');
-}
-function IsPunyLabel(value) {
-    try {
-        const payload = value.slice(4).toLowerCase();
-        // 1. Structural Validation (RFC 3492 syntax)
-        //
-        // If the payload contains a hyphen, it MUST be a delimiter separating basic
-        // ASCII characters from the variable-length integers. A payload consisting
-        // of ONLY a hyphen or starting with multiple hyphens without basic ASCII
-        // characters (like "-9uc") is fundamentally malformed.
-        //
-        const lastHyphen = payload.lastIndexOf('-');
-        if (lastHyphen === 0) {
-            // Catches "-9uc" right here because the delimiter is at index 0, meaning 0
-            // basic ASCII characters preceded it, which is non-canonical.
-            return false;
-        }
-        // 2. Decode the payload
-        const decoded = Puny.Decode(payload);
-        if (!decoded)
-            return false;
-        // 3. Validate the output rules against RFC 5892
-        return IsUnicodeLabel(decoded);
-    }
-    catch {
-        return false;
-    }
-}
-// ------------------------------------------------------------------
-// IsIdnLabel
-// ------------------------------------------------------------------
-export function IsIdnLabel(value) {
-    if (value.length === 0 || value.length > 63)
-        return false;
-    return IsPuny(value) ? IsPunyLabel(value) : IsUnicodeLabel(value);
-}
-// ------------------------------------------------------------------
-// IsLabel
-// ------------------------------------------------------------------
-export function IsLabel(value) {
-    if (value.length === 0 || value.length > 63)
-        return false;
-    return IsPuny(value) ? IsPunyLabel(value) : IsAsciiLabel(value);
-}

package/node_modules/typebox/build/format/_puny.d.mts

@@ -1 +0,0 @@
-export declare function Decode(value: string): string;

package/node_modules/typebox/build/format/_puny.mjs

@@ -1,77 +0,0 @@
-import { Unreachable } from '../system/unreachable/index.mjs';
-// ------------------------------------------------------------------
-// PunyCode (RFC 3492)
-// ------------------------------------------------------------------
-const PUNYCODE_BASE = 36;
-const PUNYCODE_TMIN = 1;
-const PUNYCODE_TMAX = 26;
-const PUNYCODE_SKEW = 38;
-const PUNYCODE_DAMP = 700;
-const PUNYCODE_INITIAL_BIAS = 72;
-const PUNYCODE_INITIAL_N = 128;
-// ------------------------------------------------------------------
-// Adapt
-// ------------------------------------------------------------------
-function Adapt(delta, numPoints, firstTime) {
-    delta = firstTime ? Math.floor(delta / PUNYCODE_DAMP) : delta >> 1;
-    delta += Math.floor(delta / numPoints);
-    let k = 0;
-    while (delta > (((PUNYCODE_BASE - PUNYCODE_TMIN) * PUNYCODE_TMAX) >> 1)) {
-        delta = Math.floor(delta / (PUNYCODE_BASE - PUNYCODE_TMIN));
-        k += PUNYCODE_BASE;
-    }
-    return k + Math.floor(((PUNYCODE_BASE - PUNYCODE_TMIN + 1) * delta) / (delta + PUNYCODE_SKEW));
-}
-// ------------------------------------------------------------------
-// Decode
-// ------------------------------------------------------------------
-export function Decode(value) {
-    const output = [];
-    let n = PUNYCODE_INITIAL_N;
-    let i = 0;
-    let bias = PUNYCODE_INITIAL_BIAS;
-    const delimIdx = value.lastIndexOf('-');
-    if (delimIdx > 0) {
-        for (let j = 0; j < delimIdx; j++) {
-            const cp = value.charCodeAt(j);
-            if (cp >= 128)
-                throw new Error('Invalid punycode: non-basic before delimiter');
-            output.push(cp);
-        }
-    }
-    let inIdx = delimIdx < 0 ? 0 : delimIdx + 1;
-    while (inIdx < value.length) {
-        const oldi = i;
-        let w = 1;
-        let k = PUNYCODE_BASE;
-        while (true) {
-            if (inIdx >= value.length)
-                throw new Error('Invalid punycode: unexpected end of input');
-            const ch = value.charCodeAt(inIdx++);
-            let digit;
-            if (ch >= 0x61 && ch <= 0x7a)
-                digit = ch - 0x61; // a-z => 0-25
-            else if (ch >= 0x30 && ch <= 0x39)
-                digit = ch - 0x30 + 26; // 0-9 => 26-35
-            // deno-coverage-ignore-start - _idna.ts maps input to lowercase, so we can't reach here
-            else if (ch >= 0x41 && ch <= 0x5a)
-                Unreachable(); // digit = ch - 0x41 // A-Z => 0-25
-            // deno-coverage-ignore-stop
-            else
-                throw new Error('Invalid punycode: bad digit character');
-            i += digit * w;
-            const t = k <= bias ? PUNYCODE_TMIN : k >= bias + PUNYCODE_TMAX ? PUNYCODE_TMAX : k - bias;
-            if (digit < t)
-                break;
-            w *= PUNYCODE_BASE - t;
-            k += PUNYCODE_BASE;
-        }
-        const outLen = output.length + 1;
-        bias = Adapt(i - oldi, outLen, oldi === 0);
-        n += Math.floor(i / outLen);
-        i %= outLen;
-        output.splice(i, 0, n);
-        i++;
-    }
-    return globalThis.String.fromCodePoint(...output);
-}

package/node_modules/typebox/build/schema/resolve/ref.d.mts

@@ -1,3 +0,0 @@
-import * as Schema from '../types/index.mjs';
-export declare function Ref(schema: Schema.XSchemaObject, ref: string): Schema.XSchema | undefined;
-export declare function DynamicRef(root: Schema.XSchemaObject, base: Schema.XSchemaObject, dynamicRef: Schema.XDynamicRef, dynamicAnchors: Schema.XDynamicAnchor[]): Schema.XSchema | undefined;