/**
 * 返回数字在扑克牌中的表示形式
 * @param { number } num
 * @param { boolean } [forced] 未获取点数字母对应元素时，若此参数不为false，则返回字符串格式
 * @returns { string }
 */
 strNumber(num, forced) {
	if (typeof num !== "number") return;
	let result = lib.numstrList.get(num);
	if (result === undefined && forced !== false) result = num.toString();
	return result;
}

/**
* 返回扑克牌中的表示形式对应的数字
* @param { string } str
* @param { boolean } [forced] 未获取字母点数对应元素时，若此参数不为false，则返回数字格式
* @returns { number }
*/
numString(str, forced) {
	if (typeof str !== "string") return;
	let result = lib.numstrList.entries().reduce((map, list) => {
		map[list[1]] = list[0];
		return map;
	}, {})[str];
	if (result === undefined && forced !== false) result = parseInt(str);
	return result;
}

dingpan: {
        // 其他代码省略
	usable(skill, player) {
		let num, mode = get.mode();
		if (mode == "identity" || mode == "doudizhu") {
			if (mode == "identity" && _status.mode == "purple") num = player.getEnemies().length;
			else num = get.population("fan");
		} else if (mode == "versus") {
			if (!_status.mode || _status.mode != "two") num = player.getEnemies().length;
			else {
				const target = game.findPlayer(x => {
					return !game.hasPlayer(y => {
						return x != y && y.getFriends().length > x.getFriends().length;
					});
				});
				num = target ? target.getFriends(true).length : 1;
			}
		} else {
			num = 1;
		}
		return num;
	},
}

/**
 * @returns { number }
 */
countSkill(skill) {
	const info = lib.skill[skill];
	let num = 0;
	if (!info) {
		console.warn("“" + skill + "”为无效技能ID！");
		return 0;
	}
	if (info.usable !== undefined && this.hasSkill("counttrigger") && this.storage.counttrigger) {
		num = this.storage.counttrigger[skill];
		if (typeof num === "number") return num;
	}
	num = this.getStat("skill")[skill];
	if (typeof num === "number") return num;
	return this.getHistory("useSkill", evt => {
		return evt.skill === skill;
	}).length;
}

// 弃置target的所有红色牌
const cards = target.getDiscardableCards(player, "he", card => {
    return get.color(card) === "red";
});
if (cards.length) await target.discard(cards, player);
// 可以改写为：
const cards = target.getCards("he", card => {
    return get.color(card) === "red";
});
await target.modedDiscard(cards, player);

/* 从target能被弃置的手牌中随机弃置两张 */
const cards = target.getDiscardableCards(target, "h");
if (cards.length) await target.discard(cards.randomGets(2));

/* 从target的手牌中随机弃置两张 */
const cards = target.getCards("h");
await target.modedDiscard(cards.randomGets(2), player);
由于Player.discard为强制弃牌，将第一段代码改为const cards = target.getCards("h");并不能实现第二段代码可能少弃甚至不弃牌的效果

// 新增start参数，可为“top”，“bottom”，“random”，代表从顶部、底部、随机获取，默认为顶部
get.cardPile(name, position, start)

import string from './noname.js?raw';
// 打印该文件的字符串形式
console.log(string);

// 普通worker
import myWorker from 'url?worker';
new myWorker();

// 普通sharedworker
import myWorker2 from 'url?sharedworker';
new myWorker2();

// 模块worker
import myWorker3 from 'url?worker&module';
new myWorker3();

// 模块sharedworker
mport myWorker4 from 'url?sharedworker&module';
new myWorker4();

import logoUrl from 'logo.png?url';
img.src = logoUrl;

import './a/b.css';
await import('./a/b.css');

import sheet from './a/b.css' with { type: "css" };
const { default: sheet  } = await import("./a/b.css", { with: { type: "css" } });

import json from './package.json'
const { default: json } = await import('./package.json');

import json from './package.json' with { type: "json" };
const { default: json } = await import('./package.json', { with: { type: "json"} });

import xxx from './a/b.ts';
const { default: xxx } = await import('./a/b.ts');

import fs from 'node:fs';
const { default: fs } = await import('node:fs');

/* 此前执行以下情况等均会获取相应牌堆首张牌的数组（虽然没有实际应用） ，这与新武将乐周瑜的初始手牌数可为0冲突*/

/* 从牌堆顶摸牌 */
const cards = get.cards(-1);
/* 从牌堆底摸牌 */
const cards = get.bottomCards(0);
/* 从斗地主智斗模式的底牌库中摸牌 */
const cards = player.getTopCards(-2);

dynamicTranslate: {
    jineng(player) {
        if (player.storage.jineng == 1) return '出牌阶段，你可以摸一张牌。';
        else if (player.storage.jineng == 2) return '出牌阶段，你可以摸两张牌。';
        else if (player.storage.jineng == 3) return '出牌阶段，你可以摸三张牌。';
    }
}
现在对原来的返回值进行一步类型检查的保底检测，不为字符串则于控制台反馈

/* 此前执行以下语句均无效果 */
if (typeof player.storage.skill_id1 === "string") player.markAuto("skill_id1");
if (typeof player.storage.skill_id2 === "boolean") player.markAuto("skill_id2");

//以后将支持直接为这三个函数获得的牌添加gaintag
//lib.element.player.draw
player.draw().gaintag.add('wusheng');
//lib.element.player.gainPlayerCard
player.gainPlayerCard(target,'h',true).gaintag.add('wusheng');
//lib.element.player.chooseToGive
player.chooseToGive(target,'h',true).gaintag.add('wusheng');

//界左慈化身
rehuashen: {
	content() {
		"step 0";
		//...代码省略
		var dialog = (event.dialog = ui.create.dialog(get.prompt("rehuashen"), [cards, (item, type, position, noclick, node) => lib.skill.rehuashen.$createButton(item, type, position, noclick, node)]));
		event.dialog.videoId = event.videoId;
		var buttons = dialog.content.querySelector(".buttons");
		var array = dialog.buttons.filter(item => !item.classList.contains("nodisplay") && item.style.display !== "none");
		var groups = array
			.map(i => get.character(i.link).group)
			.unique()
			.sort((a, b) => {
				const getNum = g => (lib.group.includes(g) ? lib.group.indexOf(g) : lib.group.length);
				return getNum(a) - getNum(b);
			});
		if (groups.length > 1) {
			event.dialog.classList.add("fullheight");
			event.dialog.addPagination({
				data: array,
				totalPageCount: groups.length,
				container: dialog.content,
				insertAfter: buttons,
				onPageChange(state) {
					const { pageNumber, data } = state;
					data.forEach(item => {
						const group = get.character(item.link).group;
						item.classList[groups.indexOf(group) + 1 === pageNumber ? "remove" : "add"]("nodisplay");
					});
				},
				pageLimitForCN: ["上一势力", "下一势力"],
				pageNumberForCN: groups.map(i => get.plainText(lib.translate[i + "2"] || lib.translate[i] || "无").slice(0, 1)),
				changePageEvent: "click",
			});
		}
		//...代码省略
		"step 2";
		if (result.bool && event.control != "弃置化身") {
			event.card = result.links[0];
			var func = function (card, id) {
				var dialog = get.idDialog(id);
				if (dialog) {
					//禁止翻页
					var paginationInstance = dialog.paginationMap?.get(event.dialog.content.querySelector(".buttons"));
					if (paginationInstance?.state) paginationInstance.state.pageRefuseChanged = true;
					for (var i = 0; i < dialog.buttons.length; i++) {
						if (dialog.buttons[i].link == card) {
							dialog.buttons[i].classList.add("selectedx");
						} else {
							dialog.buttons[i].classList.add("unselectable");
						}
					}
				}
			};
			if (player.isOnline2()) {
				player.send(func, event.card, event.videoId);
			} else if (event.isMine()) {
				func(event.card, event.videoId);
			}
			var list = player.storage.rehuashen.map[event.card].slice(0);
			list.push("返回");
			player
				.chooseControl(list)
				.set("choice", event.aiChoice)
				.set("ai", function () {
					return _status.event.choice;
				});
		} else {
			lib.skill.rehuashen.removeHuashen(player, result.links.slice(0));
			lib.skill.rehuashen.addHuashens(player, result.links.length);
		}
		"step 3";
		if (result.control == "返回") {
			var func = function (id) {
				var dialog = get.idDialog(id);
				if (dialog) {
					//允许翻页
					var paginationInstance = dialog.paginationMap?.get(event.dialog.content.querySelector(".buttons"));
					if (paginationInstance?.state) paginationInstance.state.pageRefuseChanged = false;
					for (var i = 0; i < dialog.buttons.length; i++) {
						dialog.buttons[i].classList.remove("selectedx");
						dialog.buttons[i].classList.remove("unselectable");
					}
				}
			};
			if (player.isOnline2()) {
				player.send(func, event.videoId);
			} else if (event.isMine()) {
				func(event.videoId);
			}
			event._result = { control: "更换技能" };
			event.goto(1);
			return;
		}
		//...代码省略
	},
},