薇星幻海
326 lines
24 KiB
JavaScript
326 lines
24 KiB
JavaScript
/* Exam evidence, original entry time and bounded real submit interaction. */
|
||
(function (root) {
|
||
'use strict';
|
||
const clean = value => String(value == null ? '' : value).replace(/[\u200b-\u200d\u2060\uFEFF]/g, '').replace(/\s+/g, ' ').trim();
|
||
const same = (a, b) => JSON.stringify(a.map(clean).sort()) === JSON.stringify(b.map(clean).sort());
|
||
function visible(node) {
|
||
if (!node || !node.isConnected || node.closest('[hidden],[aria-hidden="true"],.hidden,[inert]')) return false;
|
||
const style = root.getComputedStyle(node);
|
||
return node.getClientRects().length > 0 && style.display !== 'none' && style.visibility !== 'hidden';
|
||
}
|
||
function remainingSeconds(doc) {
|
||
const text = clean(doc.querySelector('.pc_examtest_countdown .time')?.textContent);
|
||
const parts = text.match(/^(\d{1,3}):(\d{2}):(\d{2})$/);
|
||
if (!parts || Number(parts[2]) > 59 || Number(parts[3]) > 59) return null;
|
||
return Number(parts[1]) * 3600 + Number(parts[2]) * 60 + Number(parts[3]);
|
||
}
|
||
function paperKey(url, container) {
|
||
const parsed = new URL(url);
|
||
const route = parsed.hash.startsWith('#/') ? new URL(parsed.hash.slice(1), parsed.origin) : parsed;
|
||
const identities = new Map();
|
||
for (const params of [parsed.searchParams, route.searchParams]) for (const [name, value] of params) {
|
||
const key = name.toLowerCase().replace(/_/g, '');
|
||
if (/^(?:attemptid|examattemptid|answerrecordid|examrecordid|paperrecordid|recordid|examid|paperid|examinationid)$/.test(key) && value) identities.set(key, value);
|
||
}
|
||
if (container) for (const attribute of ['data-attempt-id', 'data-exam-attempt-id', 'data-answer-record-id', 'data-exam-record-id']) {
|
||
const node = container.matches?.('[' + attribute + ']') ? container : container.querySelector?.('[' + attribute + ']');
|
||
if (node && clean(node.getAttribute(attribute))) identities.set(attribute, clean(node.getAttribute(attribute)));
|
||
}
|
||
return route.origin + route.pathname + '|test' + (identities.size ? '|' + JSON.stringify(Array.from(identities).sort()) : '');
|
||
}
|
||
function readPaper(doc, context, snapshot, topic) {
|
||
const core = root.QuestionBankCore, matcher = root.YianAnswerMatcher;
|
||
const bank = core.extract(doc, context.sourceUrl);
|
||
const boxes = Array.from(doc.querySelectorAll(core.selectors.question));
|
||
const details = [];
|
||
let totalScore = 0, predictedScore = 0, matchedCount = 0, verifiedCount = 0, validPoints = true;
|
||
bank.questions.forEach((question, index) => {
|
||
const box = boxes[index];
|
||
const pointNodes = box ? Array.from(box.querySelectorAll('.pc_examtest_content_question_value')) : [];
|
||
const marks = pointNodes.length === 1 ? clean(pointNodes[0].textContent).match(/^[（(]?\s*(\d+(?:\.\d+)?)\s*分\s*[)）]?$/) : null;
|
||
const points = marks ? Number(marks[1]) : null;
|
||
if (!(points > 0 && points <= 100)) validPoints = false;
|
||
else totalScore += points;
|
||
const match = matcher.match(question, Object.assign({}, context, { courses: topic?.courses || [] }), snapshot);
|
||
const nodes = box ? Array.from(box.querySelectorAll(core.selectors.option)) : [];
|
||
const currentTexts = question.options.filter((_, i) => nodes[i]?.classList.contains('examtest_content_list_des_checked')).map(option => option.text);
|
||
const verified = match.status === 'matched' && same(currentTexts, match.correctTexts);
|
||
if (match.status === 'matched') matchedCount++;
|
||
if (verified) { verifiedCount++; if (points > 0) predictedScore += points; }
|
||
details.push({ number: question.number, question: question.question, points, verified,
|
||
status: match.status, reason: !marks ? '分值不明' : verified ? '当前答案全文核验通过' : match.status === 'matched' ? '选中内容尚未核验一致' : match.reason,
|
||
correctTexts: match.correctTexts || [], currentTexts });
|
||
});
|
||
const complete = bank.expectedTotal > 0 && bank.expectedTotal === bank.total && boxes.length === bank.total;
|
||
// The confirmed threshold is 80 raw points on the supplied 100-point paper.
|
||
const scoreValid = complete && validPoints && Math.abs(totalScore - 100) < 0.000001;
|
||
const fullyVerified = complete && matchedCount === bank.total && verifiedCount === bank.total;
|
||
return { title: bank.title, total: bank.total, complete, totalScore, predictedScore, matchedCount, verifiedCount,
|
||
fullyVerified, unverifiedCount: Math.max(0, bank.total - verifiedCount),
|
||
missing: details.filter(item => item.status === 'missing').length,
|
||
conflict: details.filter(item => item.status === 'conflict').length, scoreValid, details,
|
||
signature: JSON.stringify([bank.title, bank.expectedTotal, bank.questions.map((q, index) => [q.type, q.question, q.options.map(o => [o.label, o.text]), details[index].points])]),
|
||
reason: !complete ? '等待完整试卷及答题卡' : !scoreValid ? '题目分值或 100 分分制未完整确认，等待人工检查' : '' };
|
||
}
|
||
function create(options) {
|
||
options = options || {};
|
||
const doc = options.document || root.document;
|
||
const now = options.now || Date.now;
|
||
const storage = options.storage || { get: async (_key, fallback) => fallback, set: async () => {} };
|
||
let enabled = false, destroyed = false, busy = false, entry = null, currentKey = '', stage = 'idle';
|
||
let error = '', last = {}, scope = '', ownSubmit = false, generation = 0, observing = null, observationVersion = 0;
|
||
const emit = patch => {
|
||
last = Object.assign({}, last, patch, { enabled, stage });
|
||
if (options.onState) options.onState(Object.assign({}, last));
|
||
return last;
|
||
};
|
||
const log = message => options.onLog && options.onLog('info', message);
|
||
const persist = () => entry ? storage.set('exam:' + currentKey, Object.assign({}, entry)) : Promise.resolve();
|
||
function context() { return options.getContext(); }
|
||
function keyFor(ctx) { return paperKey(ctx.sourceUrl || root.location.href, ctx.root); }
|
||
function sameContext(left, right) {
|
||
return left && right && left.root === right.root && left.mode === right.mode && left.revision === right.revision && keyFor(left) === keyFor(right);
|
||
}
|
||
function timerEvidence(ctx) {
|
||
const stamp = now(), remain = remainingSeconds(doc);
|
||
const parsed = new URL(ctx.sourceUrl || root.location.href);
|
||
const route = parsed.hash.startsWith('#/') ? new URL(parsed.hash.slice(1), parsed.origin) : parsed;
|
||
const minutes = Number(route.searchParams.get('totaltime'));
|
||
const duration = minutes > 0 && minutes <= 1440 ? minutes * 60 : null;
|
||
const strong = Boolean(duration && remain !== null && remain <= duration);
|
||
return { stamp, remain, strong, startedAt: strong ? stamp - (duration - remain) * 1000 : stamp };
|
||
}
|
||
function timerReset(saved, timer) {
|
||
if (!Number.isFinite(saved.lastRemaining) || !Number.isFinite(saved.lastObservedAt) || timer.remain === null) return false;
|
||
const elapsed = Math.max(0, (timer.stamp - saved.lastObservedAt) / 1000);
|
||
return timer.remain - Math.max(0, saved.lastRemaining - elapsed) > 5;
|
||
}
|
||
function identifiedAttempt(ctx) {
|
||
return /"(?:attemptid|examattemptid|answerrecordid|examrecordid|paperrecordid|recordid|data-attempt-id|data-exam-attempt-id|data-answer-record-id|data-exam-record-id)"/.test(keyFor(ctx));
|
||
}
|
||
function settings() { return options.getSettings ? options.getSettings() : {}; }
|
||
function manualIncomplete() { return settings().manualConfirmIncomplete !== false; }
|
||
function scopeValue(ctx, evidence, topic) {
|
||
return JSON.stringify([keyFor(ctx), ctx.revision, evidence.signature, topic?.courses, manualIncomplete()]);
|
||
}
|
||
function resultVisible() {
|
||
return Array.from(doc.querySelectorAll('.exam_submited_box,.exam-result,app-exam-result,[data-exam-result]'))
|
||
.some(node => visible(node) && /提交成功|交卷成功|考试结束|得分|成绩/.test(node.textContent));
|
||
}
|
||
function observe() {
|
||
const ctx = context();
|
||
if (!ctx || ctx.mode !== 'test' || !ctx.root || destroyed) return Promise.resolve(null);
|
||
const key = keyFor(ctx);
|
||
if (observing && observing.key === key) return observing.promise;
|
||
if (key === currentKey && entry) {
|
||
const timer = timerEvidence(ctx);
|
||
const resetTimer = timerReset(entry, timer);
|
||
const changedPaper = entry.paperSignature && ctx.ready && readPaper(doc, ctx, options.getSnapshot(), options.getTopic()).signature !== entry.paperSignature;
|
||
const pending = ['submitting', 'confirming', 'unknown'].includes(entry.stage);
|
||
if ((resetTimer || changedPaper) && !pending) {
|
||
enabled = false; stage = 'awaitingAttempt'; scope = ''; error = '检测到新试卷或重置的倒计时，请明确启动新场次'; last = { submitted: false };
|
||
}
|
||
// A stored result belongs to the earlier attempt until the current website
|
||
// actually shows that result. Explicit enable may start a fresh visible paper.
|
||
if (stage === 'submitted' && !resultVisible() && ctx.exam && !ctx.submitted) {
|
||
enabled = false; stage = 'awaitingAttempt'; scope = ''; error = '检测到可作答试卷，请明确启动新场次';
|
||
last = { submitted: false };
|
||
}
|
||
return Promise.resolve(entry);
|
||
}
|
||
enabled = false; stage = 'idle'; scope = ''; error = ''; currentKey = key; entry = null; last = { submitted: false };
|
||
const version = ++observationVersion;
|
||
const promise = (async () => {
|
||
const timer = timerEvidence(ctx);
|
||
const saved = await storage.get('exam:' + key, null);
|
||
if (destroyed || version !== observationVersion || key !== currentKey || !sameContext(ctx, context())) return null;
|
||
entry = saved && Number.isFinite(saved.startedAt) ? Object.assign({}, saved) : { startedAt: timer.startedAt, initialRemaining: timer.remain, stage: 'idle' };
|
||
const pending = ['submitting', 'confirming', 'unknown'].includes(entry.stage);
|
||
const expiredCache = Number.isFinite(entry.lastObservedAt) && Number.isFinite(entry.lastRemaining) && timer.remain > 0 && timer.stamp - entry.lastObservedAt > (entry.lastRemaining + 30) * 1000;
|
||
const resetTimer = timerReset(entry, timer);
|
||
const changedPaper = entry.paperSignature && ctx.ready && readPaper(doc, ctx, options.getSnapshot(), options.getTopic()).signature !== entry.paperSignature;
|
||
const unconfirmedClock = saved && timer.remain === null && !identifiedAttempt(ctx);
|
||
// Current explicit duration/countdown evidence wins over an older attempt's
|
||
// timestamp; taking Math.min here would make a retake immediately eligible.
|
||
if (timer.strong && !pending) entry.startedAt = timer.startedAt;
|
||
else entry.startedAt = Math.min(timer.stamp, entry.startedAt);
|
||
if (pending) { stage = 'unknown'; error = '上次交卷结果尚未确认，请检查网站结果后人工处理'; }
|
||
else if (entry.stage === 'submitted' || expiredCache || resetTimer || changedPaper || unconfirmedClock) { stage = 'awaitingAttempt'; error = '旧场次或计时连续性未确认，请明确启动新场次，重新计算最早交卷时间'; }
|
||
entry.lastObservedAt = timer.stamp; entry.lastRemaining = timer.remain;
|
||
// Preserve a submitted/pending record until explicit new-attempt authorization.
|
||
if (stage !== 'awaitingAttempt') await persist();
|
||
return !destroyed && version === observationVersion && key === currentKey && sameContext(ctx, context()) ? entry : null;
|
||
})().finally(() => { if (observing?.promise === promise) observing = null; });
|
||
observing = { key, promise }; return promise;
|
||
}
|
||
async function enable() {
|
||
const token = ++generation, requested = context();
|
||
enabled = false;
|
||
await observe();
|
||
if (token !== generation || !sameContext(requested, context()) || !entry || ['submitting', 'confirming', 'unknown'].includes(stage) || destroyed || resultVisible()) return false;
|
||
if (entry.manualRequired && stage !== 'awaitingAttempt' && manualIncomplete()) {
|
||
stage = 'waiting'; error = '网站提示存在未作答题，请在原网页手动确认交卷';
|
||
emit({ requiresManualSubmission: true, message: error }); return false;
|
||
}
|
||
const ctx = context(), topic = options.getTopic();
|
||
if (!topic || topic.status !== 'matched') { error = topic?.reason || '请先确认考试主题与题库关联'; emit({ message: error }); return false; }
|
||
const evidence = readPaper(doc, ctx, options.getSnapshot(), topic);
|
||
if (!evidence.complete || !evidence.scoreValid || !ctx.ready || !ctx.exam || ctx.submitted) { emit({ message: evidence.reason || '等待整卷加载完成后启动考试任务' }); return false; }
|
||
if (Array.from(doc.querySelectorAll('.dialog_box,[role="dialog"],.modal')).some(visible)) {
|
||
emit({ message: '请先在网页取消或关闭当前交卷对话框，再继续任务' }); return false;
|
||
}
|
||
if (stage === 'awaitingAttempt') {
|
||
const timer = timerEvidence(ctx);
|
||
entry = { startedAt: timer.startedAt, initialRemaining: timer.remain, lastRemaining: timer.remain, lastObservedAt: timer.stamp, stage: 'idle' };
|
||
}
|
||
if (!manualIncomplete() && entry.manualRequired) { entry.manualRequired = false; entry.confirmed = false; delete entry.submitAt; }
|
||
scope = scopeValue(ctx, evidence, topic);
|
||
enabled = true; stage = 'answering'; error = ''; entry.stage = stage; entry.paperSignature = evidence.signature; await persist();
|
||
if (token !== generation || destroyed || !enabled || !sameContext(ctx, context()) || !context().ready || options.getTopic()?.status !== 'matched' || scope !== scopeFor(context())) {
|
||
if (token === generation) disable('启动过程中页面、题库或任务状态已变化，请重新启动'); return false;
|
||
}
|
||
log(manualIncomplete() ? '当前考试已授权：题目不全时由用户在网页确认；整卷核验后按得分和时长交卷'
|
||
: '题目不全时手动确认已关闭：全部可匹配题核验后，严格大于 80 分且达到最早时长才交卷');
|
||
return true;
|
||
}
|
||
function disable(reason) {
|
||
generation++;
|
||
enabled = false;
|
||
if (!['submitting', 'confirming', 'submitted', 'unknown'].includes(stage)) stage = 'paused';
|
||
error = reason || '考试自动交卷已暂停';
|
||
emit({ message: error });
|
||
}
|
||
function scopeFor(ctx) {
|
||
const topic = options.getTopic(), evidence = readPaper(doc, ctx, options.getSnapshot(), topic);
|
||
return scopeValue(ctx, evidence, topic);
|
||
}
|
||
function canClick(token, ctx, confirmation) {
|
||
if (token !== generation || destroyed || !enabled || !sameContext(ctx, context())) return false;
|
||
const current = context(), topic = options.getTopic(), evidence = readPaper(doc, current, options.getSnapshot(), topic);
|
||
const configured = Number(settings().minSubmitMinutes), minimum = Number.isFinite(configured) && configured > 0 ? configured * 60 : 360;
|
||
const pendingTooLong = confirmation && now() - entry.submitAt > 12000;
|
||
return current.mode === 'test' && current.root?.isConnected && current.ready && topic?.status === 'matched'
|
||
&& scope === scopeValue(current, evidence, topic)
|
||
&& evidence.scoreValid && evidence.matchedCount === evidence.verifiedCount
|
||
&& (!manualIncomplete() || evidence.fullyVerified && !entry.manualRequired) && evidence.predictedScore > 80
|
||
&& options.getRunnerState() === 'complete' && (now() - entry.startedAt) / 1000 >= minimum
|
||
&& remainingSeconds(doc) !== 0 && !pendingTooLong && (confirmation || current.exam && !current.submitted);
|
||
}
|
||
function confirmationButton() {
|
||
const dialogs = Array.from(doc.querySelectorAll('.dialog_box,[role="dialog"],.modal')).filter(visible);
|
||
const containers = dialogs.filter(node => !dialogs.some(other => other !== node && other.contains(node)));
|
||
if (!containers.length) return { pending: true };
|
||
if (manualIncomplete() && containers.some(node => /未答|未作答|没有作答|尚未作答|漏答|未完成.*题|题.*未完成/.test(clean(node.textContent)))) {
|
||
return { manualRequired: true, reason: '网站提示存在未作答题，请在原网页手动确认交卷' };
|
||
}
|
||
const matches = containers.filter(node => /(?:确认|确定|是否).*交卷|交卷.*(?:确认|确定)|未答.*(?:提交|交卷)|(?:提交|交卷).*未答/.test(clean(node.textContent)));
|
||
if (matches.length !== 1 || /验证|人脸|异常|失败|重新考试/.test(matches[0].textContent)) return { reason: '交卷对话框无法唯一确认，请人工检查' };
|
||
const buttons = Array.from(matches[0].querySelectorAll('button,[role="button"],.btn,.submited_btn'))
|
||
.filter(node => visible(node) && !node.disabled && node.getAttribute('aria-disabled') !== 'true' && /^(确定|确认|确认交卷|确定交卷|提交|交卷|继续交卷|仍要交卷)$/.test(clean(node.textContent)));
|
||
return buttons.length === 1 ? { button: buttons[0], container: matches[0] } : { reason: '交卷确认按钮无法唯一识别，请人工检查' };
|
||
}
|
||
async function tick() {
|
||
if (destroyed || busy) return last;
|
||
busy = true;
|
||
const token = generation;
|
||
try {
|
||
const ctx = context();
|
||
if (!ctx || ctx.mode !== 'test' || !ctx.root) { if (enabled) disable('考试页面已切换'); return emit({}); }
|
||
await observe();
|
||
if (token !== generation || destroyed || !sameContext(ctx, context()) || !entry) return last;
|
||
if (resultVisible()) {
|
||
stage = 'submitted'; entry.stage = stage; enabled = false; await persist();
|
||
if (token !== generation || destroyed || !sameContext(ctx, context())) return last;
|
||
return emit({ message: '网站已显示考试结果', submitted: true, requiresManualSubmission: false });
|
||
}
|
||
const topic = options.getTopic(), evidence = readPaper(doc, ctx, options.getSnapshot(), topic);
|
||
const elapsedSeconds = Math.max(0, (now() - entry.startedAt) / 1000);
|
||
const configured = Number(settings().minSubmitMinutes);
|
||
const minimum = Number.isFinite(configured) && configured > 0 ? configured * 60 : 360;
|
||
const waitSeconds = Math.max(0, Math.ceil(minimum - elapsedSeconds));
|
||
const remaining = remainingSeconds(doc);
|
||
const runner = options.getRunnerState();
|
||
entry.lastObservedAt = now(); entry.lastRemaining = remaining;
|
||
emit(Object.assign({}, evidence, { elapsedSeconds: Math.floor(elapsedSeconds), waitSeconds, remainingSeconds: remaining,
|
||
manualConfirmIncomplete: manualIncomplete(),
|
||
requiresManualSubmission: manualIncomplete() && (Boolean(entry.manualRequired) || runner === 'complete' && !evidence.fullyVerified),
|
||
predictedScore: Math.round(evidence.predictedScore * 100) / 100, submitted: false, message: error || evidence.reason }));
|
||
if (!enabled) return last;
|
||
if (scope !== scopeValue(ctx, evidence, topic) || topic?.status !== 'matched') {
|
||
disable('试卷、题库或主题关联已变更，请重新启动核验'); return last;
|
||
}
|
||
if (remaining === 0 || ctx.submitted && !['submitting', 'confirming'].includes(stage)) { disable('网站考试已经结束或提交'); return last; }
|
||
if (['submitting', 'confirming'].includes(stage) && now() - entry.submitAt > 12000) {
|
||
stage = 'unknown'; entry.stage = stage; enabled = false; await persist();
|
||
if (token !== generation || destroyed || !sameContext(ctx, context())) return last;
|
||
return emit({ message: '提交结果未确认，已停止重复提交，请检查网站状态' });
|
||
}
|
||
const allVerified = evidence.matchedCount === evidence.verifiedCount;
|
||
if (!evidence.scoreValid || !allVerified || runner !== 'complete') {
|
||
if (stage === 'confirming' || stage === 'submitting') {
|
||
enabled = false; stage = 'unknown'; entry.stage = stage; await persist();
|
||
if (token !== generation || destroyed || !sameContext(ctx, context())) return last;
|
||
return emit({ message: '交卷过程中核验条件变化，等待人工检查' });
|
||
}
|
||
if (runner === 'complete') {
|
||
enabled = false; stage = 'waiting'; error = evidence.reason || '题目未全部核验，请在网页检查未核验题并手动确认交卷';
|
||
return emit({ requiresManualSubmission: true, message: error });
|
||
}
|
||
stage = 'answering'; return emit({ message: evidence.reason || '等待所有可匹配题处理并回读核验' });
|
||
}
|
||
if (manualIncomplete() && !evidence.fullyVerified) {
|
||
enabled = false; stage = 'waiting';
|
||
error = '题目未全部核验（' + evidence.verifiedCount + '/' + evidence.total + '），请在网页检查未核验题并手动确认交卷';
|
||
log(error); return emit({ requiresManualSubmission: true, message: error });
|
||
}
|
||
if (!(evidence.predictedScore > 80)) { stage = 'waiting'; return emit({ message: '预计得分小于或等于 80 分，等待人工操作' }); }
|
||
if (remaining !== null && remaining <= waitSeconds) { stage = 'waiting'; return emit({ message: '网站截止时间早于最早交卷时间，等待人工操作' }); }
|
||
if (waitSeconds) { stage = 'waitingSubmit'; return emit({ message: '核验完成，等待最早交卷时间' }); }
|
||
if (stage === 'confirming' || stage === 'submitting') {
|
||
const target = confirmationButton();
|
||
if (target.pending) return last;
|
||
if (target.manualRequired) {
|
||
generation++; enabled = false; stage = 'waiting'; entry.stage = 'manualRequired'; entry.manualRequired = true;
|
||
error = target.reason; await persist(); log(error);
|
||
return emit({ requiresManualSubmission: true, message: error });
|
||
}
|
||
if (target.reason) { disable(target.reason); return last; }
|
||
if (!entry.confirmed) {
|
||
entry.confirmed = true; entry.stage = stage = 'confirming'; await persist();
|
||
if (!canClick(token, ctx, true) || confirmationButton().button !== target.button) {
|
||
if (token === generation && enabled) disable('交卷确认前页面或核验条件已变化，请人工检查'); return last;
|
||
}
|
||
ownSubmit = true; try { target.button.click(); } finally { ownSubmit = false; }
|
||
log('已点击当前场次的交卷确认，等待网站结果');
|
||
}
|
||
return last;
|
||
}
|
||
if (!ctx.exam || !ctx.ready || runner !== 'complete') return last;
|
||
const findCommits = () => Array.from(ctx.root.querySelectorAll('.pc_examtest_commit')).filter(node => visible(node) && !node.disabled && node.getAttribute('aria-disabled') !== 'true' && clean(node.textContent) === '交卷');
|
||
const commits = findCommits();
|
||
if (commits.length !== 1) { disable('当前交卷入口无法唯一识别'); return last; }
|
||
stage = entry.stage = 'submitting'; entry.submitAt = now(); entry.confirmed = false; await persist();
|
||
const currentCommits = findCommits();
|
||
if (!canClick(token, ctx, false) || currentCommits.length !== 1 || currentCommits[0] !== commits[0]) {
|
||
if (token === generation && enabled) disable('交卷前页面或核验条件已变化，请人工检查'); return last;
|
||
}
|
||
ownSubmit = true; try { commits[0].click(); } finally { ownSubmit = false; }
|
||
log('已点击交卷，等待当前场次的确认或结果');
|
||
return emit({ message: '交卷处理中，等待网站确认' });
|
||
} catch (failure) { disable('考试核验失败：' + failure.message); return last; }
|
||
finally { busy = false; }
|
||
}
|
||
function manual(event) {
|
||
if (!event.isTrusted || ownSubmit || !enabled) return;
|
||
const node = event.target?.nodeType === 1 ? event.target : event.target?.parentElement;
|
||
if (node?.closest('.pc_examtest_content_list_des,.pc_examtest_commit,.dialog_box button,[role="dialog"] button,.examine_box button')) disable('检测到人工处理，已取消自动交卷计划');
|
||
}
|
||
doc.addEventListener('click', manual, true);
|
||
return { observe, enable, disable, tick, getState: () => Object.assign({}, last, { enabled, stage }),
|
||
destroy() { generation++; observationVersion++; destroyed = true; enabled = false; doc.removeEventListener('click', manual, true); } };
|
||
}
|
||
const api = { create, readPaper, remainingSeconds, paperKey };
|
||
root.YianExamController = api;
|
||
if (typeof module !== 'undefined' && module.exports) module.exports = api;
|
||
})(typeof window !== 'undefined' ? window : globalThis);
|