v12 (#5712)

Co-authored-by: MeiMei <30769358+mei23@users.noreply.github.com>
Co-authored-by: Satsuki Yanagi <17376330+u1-liquid@users.noreply.github.com>

5 files changed, 75 insertions, 620 deletions

diff --git a/src/misc/aiscript/evaluator.ts b/src/misc/aiscript/evaluator.ts
deleted file mode 100644
index c53cef75b6..0000000000
--- a/src/misc/aiscript/evaluator.ts
+++ /dev/null
@@ -1,266 +0,0 @@
-import autobind from 'autobind-decorator';
-import * as seedrandom from 'seedrandom';
-import { Variable, PageVar, envVarsDef, funcDefs, Block, isFnBlock } from '.';
-
-type Fn = {
-	slots: string[];
-	exec: (args: Record<string, any>) => ReturnType<ASEvaluator['evaluate']>;
-};
-
-/**
- * AiScript evaluator
- */
-export class ASEvaluator {
-	private variables: Variable[];
-	private pageVars: PageVar[];
-	private envVars: Record<keyof typeof envVarsDef, any>;
-
-	private opts: {
-		randomSeed: string; user?: any; visitor?: any; page?: any; url?: string; version: string;
-	};
-
-	constructor(variables: Variable[], pageVars: PageVar[], opts: ASEvaluator['opts']) {
-		this.variables = variables;
-		this.pageVars = pageVars;
-		this.opts = opts;
-
-		const date = new Date();
-
-		this.envVars = {
-			AI: 'kawaii',
-			VERSION: opts.version,
-			URL: opts.page ? `${opts.url}/@${opts.page.user.username}/pages/${opts.page.name}` : '',
-			LOGIN: opts.visitor != null,
-			NAME: opts.visitor ? opts.visitor.name || opts.visitor.username : '',
-			USERNAME: opts.visitor ? opts.visitor.username : '',
-			USERID: opts.visitor ? opts.visitor.id : '',
-			NOTES_COUNT: opts.visitor ? opts.visitor.notesCount : 0,
-			FOLLOWERS_COUNT: opts.visitor ? opts.visitor.followersCount : 0,
-			FOLLOWING_COUNT: opts.visitor ? opts.visitor.followingCount : 0,
-			IS_CAT: opts.visitor ? opts.visitor.isCat : false,
-			MY_NOTES_COUNT: opts.user ? opts.user.notesCount : 0,
-			MY_FOLLOWERS_COUNT: opts.user ? opts.user.followersCount : 0,
-			MY_FOLLOWING_COUNT: opts.user ? opts.user.followingCount : 0,
-			SEED: opts.randomSeed ? opts.randomSeed : '',
-			YMD: `${date.getFullYear()}/${date.getMonth() + 1}/${date.getDate()}`,
-			NULL: null
-		};
-	}
-
-	@autobind
-	public updatePageVar(name: string, value: any) {
-		const pageVar = this.pageVars.find(v => v.name === name);
-		if (pageVar !== undefined) {
-			pageVar.value = value;
-		} else {
-			throw new AiScriptError(`No such page var '${name}'`);
-		}
-	}
-
-	@autobind
-	public updateRandomSeed(seed: string) {
-		this.opts.randomSeed = seed;
-		this.envVars.SEED = seed;
-	}
-
-	@autobind
-	private interpolate(str: string, scope: Scope) {
-		return str.replace(/{(.+?)}/g, match => {
-			const v = scope.getState(match.slice(1, -1).trim());
-			return v == null ? 'NULL' : v.toString();
-		});
-	}
-
-	@autobind
-	public evaluateVars(): Record<string, any> {
-		const values: Record<string, any> = {};
-
-		for (const [k, v] of Object.entries(this.envVars)) {
-			values[k] = v;
-		}
-
-		for (const v of this.pageVars) {
-			values[v.name] = v.value;
-		}
-
-		for (const v of this.variables) {
-			values[v.name] = this.evaluate(v, new Scope([values]));
-		}
-
-		return values;
-	}
-
-	@autobind
-	private evaluate(block: Block, scope: Scope): any {
-		if (block.type === null) {
-			return null;
-		}
-
-		if (block.type === 'number') {
-			return parseInt(block.value, 10);
-		}
-
-		if (block.type === 'text' || block.type === 'multiLineText') {
-			return this.interpolate(block.value || '', scope);
-		}
-
-		if (block.type === 'textList') {
-			return this.interpolate(block.value || '', scope).trim().split('\n');
-		}
-
-		if (block.type === 'ref') {
-			return scope.getState(block.value);
-		}
-
-		if (isFnBlock(block)) { // ユーザー関数定義
-			return {
-				slots: block.value.slots.map(x => x.name),
-				exec: (slotArg: Record<string, any>) => {
-					return this.evaluate(block.value.expression, scope.createChildScope(slotArg, block.id));
-				}
-			} as Fn;
-		}
-
-		if (block.type.startsWith('fn:')) { // ユーザー関数呼び出し
-			const fnName = block.type.split(':')[1];
-			const fn = scope.getState(fnName);
-			const args = {} as Record<string, any>;
-			for (let i = 0; i < fn.slots.length; i++) {
-				const name = fn.slots[i];
-				args[name] = this.evaluate(block.args[i], scope);
-			}
-			return fn.exec(args);
-		}
-
-		if (block.args === undefined) return null;
-
-		const date = new Date();
-		const day = `${this.opts.visitor ? this.opts.visitor.id : ''} ${date.getFullYear()}/${date.getMonth() + 1}/${date.getDate()}`;
-
-		const funcs: { [p in keyof typeof funcDefs]: Function } = {
-			not: (a: boolean) => !a,
-			or: (a: boolean, b: boolean) => a || b,
-			and: (a: boolean, b: boolean) => a && b,
-			eq: (a: any, b: any) => a === b,
-			notEq: (a: any, b: any) => a !== b,
-			gt: (a: number, b: number) => a > b,
-			lt: (a: number, b: number) => a < b,
-			gtEq: (a: number, b: number) => a >= b,
-			ltEq: (a: number, b: number) => a <= b,
-			if: (bool: boolean, a: any, b: any) => bool ? a : b,
-			for: (times: number, fn: Fn) => {
-				const result = [];
-				for (let i = 0; i < times; i++) {
-					result.push(fn.exec({
-						[fn.slots[0]]: i + 1
-					}));
-				}
-				return result;
-			},
-			add: (a: number, b: number) => a + b,
-			subtract: (a: number, b: number) => a - b,
-			multiply: (a: number, b: number) => a * b,
-			divide: (a: number, b: number) => a / b,
-			mod: (a: number, b: number) => a % b,
-			round: (a: number) => Math.round(a),
-			strLen: (a: string) => a.length,
-			strPick: (a: string, b: number) => a[b - 1],
-			strReplace: (a: string, b: string, c: string) => a.split(b).join(c),
-			strReverse: (a: string) => a.split('').reverse().join(''),
-			join: (texts: string[], separator: string) => texts.join(separator || ''),
-			stringToNumber: (a: string) => parseInt(a),
-			numberToString: (a: number) => a.toString(),
-			splitStrByLine: (a: string) => a.split('\n'),
-			pick: (list: any[], i: number) => list[i - 1],
-			listLen: (list: any[]) => list.length,
-			random: (probability: number) => Math.floor(seedrandom(`${this.opts.randomSeed}:${block.id}`)() * 100) < probability,
-			rannum: (min: number, max: number) => min + Math.floor(seedrandom(`${this.opts.randomSeed}:${block.id}`)() * (max - min + 1)),
-			randomPick: (list: any[]) => list[Math.floor(seedrandom(`${this.opts.randomSeed}:${block.id}`)() * list.length)],
-			dailyRandom: (probability: number) => Math.floor(seedrandom(`${day}:${block.id}`)() * 100) < probability,
-			dailyRannum: (min: number, max: number) => min + Math.floor(seedrandom(`${day}:${block.id}`)() * (max - min + 1)),
-			dailyRandomPick: (list: any[]) => list[Math.floor(seedrandom(`${day}:${block.id}`)() * list.length)],
-			seedRandom: (seed: any, probability: number) => Math.floor(seedrandom(seed)() * 100) < probability,
-			seedRannum: (seed: any, min: number, max: number) => min + Math.floor(seedrandom(seed)() * (max - min + 1)),
-			seedRandomPick: (seed: any, list: any[]) => list[Math.floor(seedrandom(seed)() * list.length)],
-			DRPWPM: (list: string[]) => {
-				const xs = [];
-				let totalFactor = 0;
-				for (const x of list) {
-					const parts = x.split(' ');
-					const factor = parseInt(parts.pop()!, 10);
-					const text = parts.join(' ');
-					totalFactor += factor;
-					xs.push({ factor, text });
-				}
-				const r = seedrandom(`${day}:${block.id}`)() * totalFactor;
-				let stackedFactor = 0;
-				for (const x of xs) {
-					if (r >= stackedFactor && r <= stackedFactor + x.factor) {
-						return x.text;
-					} else {
-						stackedFactor += x.factor;
-					}
-				}
-				return xs[0].text;
-			},
-		};
-
-		const fnName = block.type;
-		const fn = (funcs as any)[fnName];
-		if (fn == null) {
-			throw new AiScriptError(`No such function '${fnName}'`);
-		} else {
-			return fn(...block.args.map(x => this.evaluate(x, scope)));
-		}
-	}
-}
-
-class AiScriptError extends Error {
-	public info?: any;
-
-	constructor(message: string, info?: any) {
-		super(message);
-
-		this.info = info;
-
-		// Maintains proper stack trace for where our error was thrown (only available on V8)
-		if (Error.captureStackTrace) {
-			Error.captureStackTrace(this, AiScriptError);
-		}
-	}
-}
-
-class Scope {
-	private layerdStates: Record<string, any>[];
-	public name: string;
-
-	constructor(layerdStates: Scope['layerdStates'], name?: Scope['name']) {
-		this.layerdStates = layerdStates;
-		this.name = name || 'anonymous';
-	}
-
-	@autobind
-	public createChildScope(states: Record<string, any>, name?: Scope['name']): Scope {
-		const layer = [states, ...this.layerdStates];
-		return new Scope(layer, name);
-	}
-
-	/**
-	 * 指定した名前の変数の値を取得します
-	 * @param name 変数名
-	 */
-	@autobind
-	public getState(name: string): any {
-		for (const later of this.layerdStates) {
-			const state = later[name];
-			if (state !== undefined) {
-				return state;
-			}
-		}
-
-		throw new AiScriptError(
-			`No such variable '${name}' in scope '${this.name}'`, {
-				scope: this.layerdStates
-			});
-	}
-}
diff --git a/src/misc/aiscript/index.ts b/src/misc/aiscript/index.ts
deleted file mode 100644
index f2de1bb40d..0000000000
--- a/src/misc/aiscript/index.ts
+++ /dev/null
@@ -1,140 +0,0 @@
-/**
- * AiScript
- */
-
-import {
-	faMagic,
-	faSquareRootAlt,
-	faAlignLeft,
-	faShareAlt,
-	faPlus,
-	faMinus,
-	faTimes,
-	faDivide,
-	faList,
-	faQuoteRight,
-	faEquals,
-	faGreaterThan,
-	faLessThan,
-	faGreaterThanEqual,
-	faLessThanEqual,
-	faNotEqual,
-	faDice,
-	faSortNumericUp,
-	faExchangeAlt,
-	faRecycle,
-	faIndent,
-	faCalculator,
-} from '@fortawesome/free-solid-svg-icons';
-import { faFlag } from '@fortawesome/free-regular-svg-icons';
-
-export type Block<V = any> = {
-	id: string;
-	type: string;
-	args: Block[];
-	value: V;
-};
-
-export type FnBlock = Block<{
-	slots: {
-		name: string;
-		type: Type;
-	}[];
-	expression: Block;
-}>;
-
-export type Variable = Block & {
-	name: string;
-};
-
-export type Type = 'string' | 'number' | 'boolean' | 'stringArray' | null;
-
-export const funcDefs: Record<string, { in: any[]; out: any; category: string; icon: any; }> = {
-	if:              { in: ['boolean', 0, 0],              out: 0,             category: 'flow',       icon: faShareAlt, },
-	for:             { in: ['number', 'function'],         out: null,          category: 'flow',       icon: faRecycle, },
-	not:             { in: ['boolean'],                    out: 'boolean',     category: 'logical',    icon: faFlag, },
-	or:              { in: ['boolean', 'boolean'],         out: 'boolean',     category: 'logical',    icon: faFlag, },
-	and:             { in: ['boolean', 'boolean'],         out: 'boolean',     category: 'logical',    icon: faFlag, },
-	add:             { in: ['number', 'number'],           out: 'number',      category: 'operation',  icon: faPlus, },
-	subtract:        { in: ['number', 'number'],           out: 'number',      category: 'operation',  icon: faMinus, },
-	multiply:        { in: ['number', 'number'],           out: 'number',      category: 'operation',  icon: faTimes, },
-	divide:          { in: ['number', 'number'],           out: 'number',      category: 'operation',  icon: faDivide, },
-	mod:             { in: ['number', 'number'],           out: 'number',      category: 'operation',  icon: faDivide, },
-	round:           { in: ['number'],                     out: 'number',      category: 'operation',  icon: faCalculator, },
-	eq:              { in: [0, 0],                         out: 'boolean',     category: 'comparison', icon: faEquals, },
-	notEq:           { in: [0, 0],                         out: 'boolean',     category: 'comparison', icon: faNotEqual, },
-	gt:              { in: ['number', 'number'],           out: 'boolean',     category: 'comparison', icon: faGreaterThan, },
-	lt:              { in: ['number', 'number'],           out: 'boolean',     category: 'comparison', icon: faLessThan, },
-	gtEq:            { in: ['number', 'number'],           out: 'boolean',     category: 'comparison', icon: faGreaterThanEqual, },
-	ltEq:            { in: ['number', 'number'],           out: 'boolean',     category: 'comparison', icon: faLessThanEqual, },
-	strLen:          { in: ['string'],                     out: 'number',      category: 'text',       icon: faQuoteRight, },
-	strPick:         { in: ['string', 'number'],           out: 'string',      category: 'text',       icon: faQuoteRight, },
-	strReplace:      { in: ['string', 'string', 'string'], out: 'string',      category: 'text',       icon: faQuoteRight, },
-	strReverse:      { in: ['string'],                     out: 'string',      category: 'text',       icon: faQuoteRight, },
-	join:            { in: ['stringArray', 'string'],      out: 'string',      category: 'text',       icon: faQuoteRight, },
-	stringToNumber:  { in: ['string'],                     out: 'number',      category: 'convert',    icon: faExchangeAlt, },
-	numberToString:  { in: ['number'],                     out: 'string',      category: 'convert',    icon: faExchangeAlt, },
-	splitStrByLine:  { in: ['string'],                     out: 'stringArray', category: 'convert',    icon: faExchangeAlt, },
-	pick:            { in: [null, 'number'],               out: null,          category: 'list',       icon: faIndent, },
-	listLen:         { in: [null],                         out: 'number',      category: 'list',       icon: faIndent, },
-	rannum:          { in: ['number', 'number'],           out: 'number',      category: 'random',     icon: faDice, },
-	dailyRannum:     { in: ['number', 'number'],           out: 'number',      category: 'random',     icon: faDice, },
-	seedRannum:      { in: [null, 'number', 'number'],     out: 'number',      category: 'random',     icon: faDice, },
-	random:          { in: ['number'],                     out: 'boolean',     category: 'random',     icon: faDice, },
-	dailyRandom:     { in: ['number'],                     out: 'boolean',     category: 'random',     icon: faDice, },
-	seedRandom:      { in: [null, 'number'],               out: 'boolean',     category: 'random',     icon: faDice, },
-	randomPick:      { in: [0],                            out: 0,             category: 'random',     icon: faDice, },
-	dailyRandomPick: { in: [0],                            out: 0,             category: 'random',     icon: faDice, },
-	seedRandomPick:  { in: [null, 0],                      out: 0,             category: 'random',     icon: faDice, },
-	DRPWPM:      { in: ['stringArray'],                out: 'string',      category: 'random',     icon: faDice, }, // dailyRandomPickWithProbabilityMapping
-};
-
-export const literalDefs: Record<string, { out: any; category: string; icon: any; }> = {
-	text:          { out: 'string',      category: 'value', icon: faQuoteRight, },
-	multiLineText: { out: 'string',      category: 'value', icon: faAlignLeft, },
-	textList:      { out: 'stringArray', category: 'value', icon: faList, },
-	number:        { out: 'number',      category: 'value', icon: faSortNumericUp, },
-	ref:           { out: null,          category: 'value', icon: faMagic, },
-	fn:            { out: 'function',    category: 'value', icon: faSquareRootAlt, },
-};
-
-export const blockDefs = [
-	...Object.entries(literalDefs).map(([k, v]) => ({
-		type: k, out: v.out, category: v.category, icon: v.icon
-	})),
-	...Object.entries(funcDefs).map(([k, v]) => ({
-		type: k, out: v.out, category: v.category, icon: v.icon
-	}))
-];
-
-export function isFnBlock(block: Block): block is FnBlock {
-	return block.type === 'fn';
-}
-
-export type PageVar = { name: string; value: any; type: Type; };
-
-export const envVarsDef: Record<string, Type> = {
-	AI: 'string',
-	URL: 'string',
-	VERSION: 'string',
-	LOGIN: 'boolean',
-	NAME: 'string',
-	USERNAME: 'string',
-	USERID: 'string',
-	NOTES_COUNT: 'number',
-	FOLLOWERS_COUNT: 'number',
-	FOLLOWING_COUNT: 'number',
-	IS_CAT: 'boolean',
-	MY_NOTES_COUNT: 'number',
-	MY_FOLLOWERS_COUNT: 'number',
-	MY_FOLLOWING_COUNT: 'number',
-	SEED: null,
-	YMD: 'string',
-	NULL: null,
-};
-
-export function isLiteralBlock(v: Block) {
-	if (v.type === null) return true;
-	if (literalDefs[v.type]) return true;
-	return false;
-}
diff --git a/src/misc/aiscript/type-checker.ts b/src/misc/aiscript/type-checker.ts
deleted file mode 100644
index 817e549864..0000000000
--- a/src/misc/aiscript/type-checker.ts
+++ /dev/null
@@ -1,186 +0,0 @@
-import autobind from 'autobind-decorator';
-import { Type, Block, funcDefs, envVarsDef, Variable, PageVar, isLiteralBlock } from '.';
-
-type TypeError = {
-	arg: number;
-	expect: Type;
-	actual: Type;
-};
-
-/**
- * AiScript type checker
- */
-export class ASTypeChecker {
-	public variables: Variable[];
-	public pageVars: PageVar[];
-
-	constructor(variables: ASTypeChecker['variables'] = [], pageVars: ASTypeChecker['pageVars'] = []) {
-		this.variables = variables;
-		this.pageVars = pageVars;
-	}
-
-	@autobind
-	public typeCheck(v: Block): TypeError | null {
-		if (isLiteralBlock(v)) return null;
-
-		const def = funcDefs[v.type];
-		if (def == null) {
-			throw new Error('Unknown type: ' + v.type);
-		}
-
-		const generic: Type[] = [];
-
-		for (let i = 0; i < def.in.length; i++) {
-			const arg = def.in[i];
-			const type = this.infer(v.args[i]);
-			if (type === null) continue;
-
-			if (typeof arg === 'number') {
-				if (generic[arg] === undefined) {
-					generic[arg] = type;
-				} else if (type !== generic[arg]) {
-					return {
-						arg: i,
-						expect: generic[arg],
-						actual: type
-					};
-				}
-			} else if (type !== arg) {
-				return {
-					arg: i,
-					expect: arg,
-					actual: type
-				};
-			}
-		}
-
-		return null;
-	}
-
-	@autobind
-	public getExpectedType(v: Block, slot: number): Type {
-		const def = funcDefs[v.type];
-		if (def == null) {
-			throw new Error('Unknown type: ' + v.type);
-		}
-
-		const generic: Type[] = [];
-
-		for (let i = 0; i < def.in.length; i++) {
-			const arg = def.in[i];
-			const type = this.infer(v.args[i]);
-			if (type === null) continue;
-
-			if (typeof arg === 'number') {
-				if (generic[arg] === undefined) {
-					generic[arg] = type;
-				}
-			}
-		}
-
-		if (typeof def.in[slot] === 'number') {
-			return generic[def.in[slot]] || null;
-		} else {
-			return def.in[slot];
-		}
-	}
-
-	@autobind
-	public infer(v: Block): Type {
-		if (v.type === null) return null;
-		if (v.type === 'text') return 'string';
-		if (v.type === 'multiLineText') return 'string';
-		if (v.type === 'textList') return 'stringArray';
-		if (v.type === 'number') return 'number';
-		if (v.type === 'ref') {
-			const variable = this.variables.find(va => va.name === v.value);
-			if (variable) {
-				return this.infer(variable);
-			}
-
-			const pageVar = this.pageVars.find(va => va.name === v.value);
-			if (pageVar) {
-				return pageVar.type;
-			}
-
-			const envVar = envVarsDef[v.value];
-			if (envVar !== undefined) {
-				return envVar;
-			}
-
-			return null;
-		}
-		if (v.type === 'fn') return null; // todo
-		if (v.type.startsWith('fn:')) return null; // todo
-
-		const generic: Type[] = [];
-
-		const def = funcDefs[v.type];
-
-		for (let i = 0; i < def.in.length; i++) {
-			const arg = def.in[i];
-			if (typeof arg === 'number') {
-				const type = this.infer(v.args[i]);
-
-				if (generic[arg] === undefined) {
-					generic[arg] = type;
-				} else {
-					if (type !== generic[arg]) {
-						generic[arg] = null;
-					}
-				}
-			}
-		}
-
-		if (typeof def.out === 'number') {
-			return generic[def.out];
-		} else {
-			return def.out;
-		}
-	}
-
-	@autobind
-	public getVarByName(name: string): Variable {
-		const v = this.variables.find(x => x.name === name);
-		if (v !== undefined) {
-			return v;
-		} else {
-			throw new Error(`No such variable '${name}'`);
-		}
-	}
-
-	@autobind
-	public getVarsByType(type: Type): Variable[] {
-		if (type == null) return this.variables;
-		return this.variables.filter(x => (this.infer(x) === null) || (this.infer(x) === type));
-	}
-
-	@autobind
-	public getEnvVarsByType(type: Type): string[] {
-		if (type == null) return Object.keys(envVarsDef);
-		return Object.entries(envVarsDef).filter(([k, v]) => v === null || type === v).map(([k, v]) => k);
-	}
-
-	@autobind
-	public getPageVarsByType(type: Type): string[] {
-		if (type == null) return this.pageVars.map(v => v.name);
-		return this.pageVars.filter(v => type === v.type).map(v => v.name);
-	}
-
-	@autobind
-	public isUsedName(name: string) {
-		if (this.variables.some(v => v.name === name)) {
-			return true;
-		}
-
-		if (this.pageVars.some(v => v.name === name)) {
-			return true;
-		}
-
-		if (envVarsDef[name]) {
-			return true;
-		}
-
-		return false;
-	}
-}
diff --git a/src/misc/check-hit-antenna.ts b/src/misc/check-hit-antenna.ts
new file mode 100644
index 0000000000..b527d34354
--- /dev/null
+++ b/src/misc/check-hit-antenna.ts
@@ -0,0 +1,53 @@
+import { Antenna } from '../models/entities/antenna';
+import { Note } from '../models/entities/note';
+import { User } from '../models/entities/user';
+import { UserListJoinings } from '../models';
+import parseAcct from './acct/parse';
+import { getFullApAccount } from './convert-host';
+
+export async function checkHitAntenna(antenna: Antenna, note: Note, noteUser: User, followers: User['id'][]): Promise<boolean> {
+	if (note.visibility === 'specified') return false;
+
+	if (note.visibility === 'followers') {
+		if (!followers.includes(antenna.userId)) return false;
+	}
+
+	if (!antenna.withReplies && note.replyId != null) return false;
+
+	if (antenna.src === 'home') {
+		if (!followers.includes(antenna.userId)) return false;
+	} else if (antenna.src === 'list') {
+		const listUsers = (await UserListJoinings.find({
+			userListId: antenna.userListId!
+		})).map(x => x.userId);
+
+		if (!listUsers.includes(note.userId)) return false;
+	} else if (antenna.src === 'users') {
+		const accts = antenna.users.map(x => {
+			const { username, host } = parseAcct(x);
+			return getFullApAccount(username, host).toLowerCase();
+		});
+		if (!accts.includes(getFullApAccount(noteUser.username, noteUser.host).toLowerCase())) return false;
+	}
+
+	if (antenna.keywords.length > 0) {
+		if (note.text == null) return false;
+
+		const matched = antenna.keywords.some(keywords =>
+			keywords.every(keyword =>
+				antenna.caseSensitive
+					? note.text!.includes(keyword)
+					: note.text!.toLowerCase().includes(keyword.toLowerCase())
+			));
+		
+		if (!matched) return false;
+	}
+
+	if (antenna.withFile) {
+		if (note.fileIds.length === 0) return false;
+	}
+
+	// TODO: eval expression
+
+	return true;
+}
diff --git a/src/misc/reaction-lib.ts b/src/misc/reaction-lib.ts
index ced90ce78f..eba57ea303 100644
--- a/src/misc/reaction-lib.ts
+++ b/src/misc/reaction-lib.ts
@@ -2,31 +2,29 @@ import { emojiRegex } from './emoji-regex';
 import { fetchMeta } from './fetch-meta';
 import { Emojis } from '../models';
 
-const basic10: Record<string, string> = {
-	'👍': 'like',
-	'❤': 'love',	// ここに記述する場合は異体字セレクタを入れない
-	'😆': 'laugh',
-	'🤔': 'hmm',
-	'😮': 'surprise',
-	'🎉': 'congrats',
-	'💢': 'angry',
-	'😥': 'confused',
-	'😇': 'rip',
-	'🍮': 'pudding',
+const legacy10: Record<string, string> = {
+	'like':     '👍',
+	'love':     '❤', // ここに記述する場合は異体字セレクタを入れない
+	'laugh':    '😆',
+	'hmm':      '🤔',
+	'surprise': '😮',
+	'congrats': '🎉',
+	'angry':    '💢',
+	'confused': '😥',
+	'rip':      '😇',
+	'pudding':  '🍮',
 };
 
 export async function getFallbackReaction(): Promise<string> {
 	const meta = await fetchMeta();
-	return  meta.useStarForReactionFallback ? 'star' : 'like';
+	return meta.useStarForReactionFallback ? '⭐' : '👍';
 }
 
-export async function toDbReaction(reaction?: string | null, enableEmoji = true): Promise<string> {
+export async function toDbReaction(reaction?: string | null): Promise<string> {
 	if (reaction == null) return await getFallbackReaction();
 
-	// 既存の文字列リアクションはそのまま
-	if (Object.values(basic10).includes(reaction)) return reaction;
-
-	if (!enableEmoji) return await getFallbackReaction();
+	// 文字列タイプのリアクションを絵文字に変換
+	if (Object.keys(legacy10).includes(reaction)) return legacy10[reaction];
 
 	// Unicode絵文字
 	const match = emojiRegex.exec(reaction);
@@ -34,17 +32,8 @@ export async function toDbReaction(reaction?: string | null, enableEmoji = true)
 		// 合字を含む1つの絵文字
 		const unicode = match[0];
 
-		// 異体字セレクタ除去後の絵文字
-		const normalized = unicode.match('\u200d') ? unicode : unicode.replace(/\ufe0f/g, '');
-
-		// Unicodeプリンは寿司化不能とするため文字列化しない
-		if (normalized === '🍮') return normalized;
-
-		// プリン以外の既存のリアクションは文字列化する
-		if (basic10[normalized]) return basic10[normalized];
-
-		// それ以外はUnicodeのまま
-		return normalized;
+		// 異体字セレクタ除去
+		return unicode.match('\u200d') ? unicode : unicode.replace(/\ufe0f/g, '');
 	}
 
 	const custom = reaction.match(/^:([\w+-]+):$/);
@@ -59,3 +48,8 @@ export async function toDbReaction(reaction?: string | null, enableEmoji = true)
 
 	return await getFallbackReaction();
 }
+
+export function convertLegacyReaction(reaction: string): string {
+	if (Object.keys(legacy10).includes(reaction)) return legacy10[reaction];
+	return reaction;
+}