forges 0.0.0 → 0.1.0

package/dist/gitee-CA-f7Rs8.mjs

@@ -0,0 +1,1272 @@
+import { C as requireIssueOrPull, Ct as MergeMethodRequiredError, E as summariseChecks, O as toDate, Pt as toMergeError, S as phased, T as resolveToken, _t as ForgeError, c as checkRunState, dt as fromBase64, f as getManyConcurrently, ft as toFileContent, g as iteratePages, i as githubShapedWeb, j as toWarning, jt as UnsupportedOperationError, k as toFileStatus, m as hexColour, n as perKind, p as hasEveryLabel, r as verb, s as actorLogin, t as defineForgeProvider, w as requireThread, wt as NotFoundError } from "./define-D3yEXtKK.mjs";
+import { c as timingSafeEqual, n as headerValue, r as hmacSha256Base64, t as bodyText } from "./crypto-CQNEyYHD.mjs";
+import { i as refEvent, o as verifySharedToken, r as nativeEventsFor, t as eventKindsOf } from "./webhooks-rn9-8lxT.mjs";
+//#region src/gitee/webhook-events.ts
+/** Gitee subscribes per event with a boolean flag, so the flag names are the native events. */
+const GITEE_NATIVE_EVENTS = {
+	comment: ["note_events"],
+	state_change: ["issues_events", "merge_requests_events"],
+	label: ["issues_events", "merge_requests_events"],
+	assignment: ["issues_events", "merge_requests_events"],
+	review: ["merge_requests_events"],
+	push: ["push_events"],
+	ref: ["tag_push_events"]
+};
+/** Normalised kinds and actions Gitee deliveries translate into. */
+const GITEE_WEBHOOK_EVENTS = [
+	{
+		kind: "comment",
+		action: "created"
+	},
+	{
+		kind: "state_change",
+		action: "opened"
+	},
+	{
+		kind: "state_change",
+		action: "closed"
+	},
+	{
+		kind: "state_change",
+		action: "reopened"
+	},
+	{
+		kind: "state_change",
+		action: "merged"
+	},
+	{ kind: "push" },
+	{
+		kind: "ref",
+		action: "created"
+	},
+	{
+		kind: "ref",
+		action: "deleted"
+	}
+];
+//#endregion
+//#region src/gitee/normalise.ts
+const FORGE = "gitee";
+function toActor(instance, user) {
+	if (!user) return;
+	return {
+		forge: FORGE,
+		instance,
+		login: user.login,
+		id: String(user.id),
+		name: user.name,
+		avatarUrl: user.avatar_url,
+		url: user.html_url,
+		typeRaw: user.type,
+		isBotHint: user.type === "Bot" || /\[bot\]$|-bot$/i.test(user.login)
+	};
+}
+function toRepoRef(instance, repo) {
+	const [owner = repo.namespace?.path ?? "", name = repo.path] = repo.full_name.split("/");
+	return {
+		forge: FORGE,
+		instance,
+		owner,
+		name,
+		externalId: String(repo.id)
+	};
+}
+function toRepo(instance, raw) {
+	return {
+		ref: toRepoRef(instance, raw),
+		description: raw.description ?? void 0,
+		defaultBranch: raw.default_branch,
+		visibility: raw.private ? "private" : raw.internal ? "internal" : "public",
+		isFork: raw.fork ?? false,
+		isArchived: false,
+		parent: raw.parent ? toRepoRef(instance, raw.parent) : void 0,
+		topics: [],
+		url: raw.html_url,
+		cloneUrls: {
+			https: raw.html_url ? `${raw.html_url}.git` : void 0,
+			ssh: raw.ssh_url
+		},
+		createdAt: toDate(raw.created_at),
+		updatedAt: toDate(raw.updated_at),
+		pushedAt: toDate(raw.pushed_at),
+		openIssueCount: raw.open_issues_count,
+		owner: toActor(instance, raw.owner),
+		language: raw.language ?? void 0,
+		homepage: raw.homepage || void 0,
+		licence: raw.license ?? void 0,
+		stars: raw.stargazers_count,
+		forks: raw.forks_count,
+		watchers: raw.watchers_count,
+		raw
+	};
+}
+/** Gitee issues are `open`, `progressing`, `closed` or `rejected`; progressing work is still open. */
+function issueState(state) {
+	return state === "open" || state === "progressing" ? "open" : state === "closed" || state === "rejected" ? "closed" : "unknown";
+}
+function toIssueThread(ref, raw) {
+	const instance = ref.instance;
+	return {
+		ref: {
+			...ref,
+			kind: "issue",
+			number: raw.number,
+			externalId: String(raw.id)
+		},
+		kind: "issue",
+		title: raw.title,
+		body: raw.body ?? void 0,
+		state: issueState(raw.state),
+		stateRaw: raw.state,
+		stateReason: raw.state === "rejected" ? "not_planned" : void 0,
+		isDraft: false,
+		author: toActor(instance, raw.user),
+		assignees: raw.assignee ? [toActor(instance, raw.assignee)] : [],
+		reviewers: [],
+		labels: (raw.labels ?? []).map((label) => ({
+			name: label.name,
+			colour: label.color
+		})),
+		url: raw.html_url,
+		createdAt: toDate(raw.created_at),
+		updatedAt: toDate(raw.updated_at),
+		closedAt: toDate(raw.finished_at),
+		lastActivityAt: toDate(raw.updated_at),
+		commentCount: raw.comments,
+		raw
+	};
+}
+function toPullThread(ref, raw) {
+	const instance = ref.instance;
+	const state = raw.merged_at || raw.state === "merged" ? "merged" : raw.state === "open" ? "open" : raw.state === "closed" ? "closed" : "unknown";
+	return {
+		ref: {
+			...ref,
+			kind: "pull_request",
+			number: String(raw.number),
+			externalId: String(raw.id)
+		},
+		kind: "pull_request",
+		title: raw.title,
+		body: raw.body ?? void 0,
+		state,
+		stateRaw: raw.state,
+		isDraft: raw.draft ?? false,
+		author: toActor(instance, raw.user),
+		assignees: [],
+		reviewers: (raw.assignees ?? []).map((reviewer) => ({
+			actor: toActor(instance, reviewer),
+			state: reviewer.accept ? "approved" : "pending",
+			stateRaw: reviewer.accept ? "accepted" : "requested"
+		})),
+		labels: (raw.labels ?? []).map((label) => ({
+			name: label.name,
+			colour: label.color
+		})),
+		url: raw.html_url,
+		createdAt: toDate(raw.created_at),
+		updatedAt: toDate(raw.updated_at),
+		closedAt: toDate(raw.closed_at),
+		lastActivityAt: toDate(raw.updated_at),
+		locked: raw.locked,
+		branches: raw.head && raw.base ? {
+			head: {
+				ref: raw.head.ref,
+				sha: raw.head.sha,
+				repo: raw.head.repo ? toRepoRef(instance, raw.head.repo) : void 0
+			},
+			base: {
+				ref: raw.base.ref,
+				sha: raw.base.sha
+			}
+		} : void 0,
+		raw
+	};
+}
+/** Inline review comments are `diff_comment`s; everything else is conversation. */
+function isConversationComment(raw) {
+	return raw.comment_type !== "diff_comment" && !raw.path;
+}
+function toComment(thread, raw) {
+	return {
+		ref: {
+			forge: FORGE,
+			instance: thread.instance,
+			thread,
+			id: String(raw.id)
+		},
+		body: raw.body,
+		author: toActor(thread.instance, raw.user),
+		createdAt: toDate(raw.created_at),
+		updatedAt: toDate(raw.updated_at),
+		url: raw.html_url,
+		raw
+	};
+}
+function toCommentEvent(thread, raw) {
+	const actor = toActor(thread.instance, raw.user);
+	const inline = !isConversationComment(raw);
+	return {
+		forge: FORGE,
+		instance: thread.instance,
+		id: `comment:${raw.id}`,
+		kind: inline ? "review_comment" : "comment",
+		kindRaw: raw.comment_type ?? "comment",
+		summary: `${actor?.login ?? "someone"} ${inline ? "commented on the diff" : "commented"}`,
+		occurredAt: toDate(raw.created_at) ?? /* @__PURE__ */ new Date(0),
+		actor,
+		repo: thread.repo,
+		thread,
+		source: "poll",
+		payload: raw
+	};
+}
+const LOG_KINDS = {
+	label: "label",
+	add_label: "label",
+	remove_label: "label",
+	assign: "assignment",
+	set_assignee: "assignment",
+	change_issue_state: "state_change",
+	closed: "state_change",
+	reopened: "state_change",
+	merged: "state_change",
+	review: "review",
+	approve: "review"
+};
+function toLogEvent(thread, raw) {
+	const actor = toActor(thread.instance, raw.user);
+	return {
+		forge: FORGE,
+		instance: thread.instance,
+		id: `log:${raw.id}`,
+		kind: LOG_KINDS[raw.action_type ?? ""] ?? "other",
+		kindRaw: raw.action_type,
+		summary: `${actor?.login ?? "someone"} ${raw.content ?? raw.action_type ?? "changed the thread"}`.trim(),
+		occurredAt: toDate(raw.created_at) ?? /* @__PURE__ */ new Date(0),
+		actor,
+		repo: thread.repo,
+		thread,
+		source: "poll",
+		payload: raw
+	};
+}
+function threadFromUrl(instance, repo, url) {
+	const match = /\/(issues|pulls)\/([^/?#]+)/.exec(url ?? "");
+	return repo && match ? {
+		forge: FORGE,
+		instance,
+		repo,
+		kind: match[1] === "pulls" ? "pull_request" : "issue",
+		number: match[2]
+	} : void 0;
+}
+function toNotification(instance, raw) {
+	const repo = raw.repository ? toRepoRef(instance, raw.repository) : void 0;
+	const type = raw.subject?.type ?? raw.type ?? "unknown";
+	const thread = threadFromUrl(instance, repo, raw.subject?.url ?? raw.html_url);
+	return {
+		ref: {
+			forge: FORGE,
+			instance,
+			id: String(raw.id)
+		},
+		subject: thread ? {
+			type: "thread",
+			thread: {
+				...thread,
+				typeRaw: type
+			}
+		} : repo ? {
+			type: "repo",
+			repo
+		} : {
+			type: "other",
+			typeRaw: type,
+			id: String(raw.id),
+			url: raw.html_url
+		},
+		subjectTypeRaw: type,
+		reason: raw.type === "referer" ? "mention" : "unknown",
+		reasonRaw: raw.type,
+		unread: raw.unread,
+		title: raw.subject?.title ?? raw.content ?? type,
+		subjectState: "unknown",
+		updatedAt: toDate(raw.updated_at) ?? /* @__PURE__ */ new Date(0),
+		raw
+	};
+}
+function toCheck(repo, raw) {
+	return {
+		ref: {
+			forge: FORGE,
+			instance: repo.instance,
+			repo,
+			id: String(raw.id),
+			type: "check_run"
+		},
+		name: raw.name,
+		state: checkRunState(raw.status, raw.conclusion),
+		stateRaw: raw.status,
+		conclusionRaw: raw.conclusion ?? void 0,
+		url: raw.html_url ?? raw.details_url,
+		startedAt: toDate(raw.started_at),
+		completedAt: toDate(raw.completed_at),
+		raw
+	};
+}
+/** Gitee releases have no draft state or separate publish time. */
+function toRelease(repo, raw) {
+	return {
+		ref: {
+			forge: FORGE,
+			instance: repo.instance,
+			repo,
+			id: String(raw.id),
+			tag: raw.tag_name
+		},
+		name: raw.name || void 0,
+		tag: raw.tag_name,
+		body: raw.body || void 0,
+		isDraft: false,
+		isPrerelease: raw.prerelease,
+		author: toActor(repo.instance, raw.author),
+		publishedAt: toDate(raw.created_at),
+		createdAt: toDate(raw.created_at),
+		assets: raw.assets?.map((asset) => ({
+			name: asset.name ?? asset.browser_download_url.split("/").pop() ?? "",
+			url: asset.browser_download_url
+		})),
+		raw
+	};
+}
+function toChangedFile(raw) {
+	return {
+		path: raw.filename,
+		status: toFileStatus(raw.status),
+		statusRaw: raw.status,
+		additions: raw.additions,
+		deletions: raw.deletions,
+		patch: typeof raw.patch === "string" ? raw.patch : raw.patch?.diff,
+		sha: raw.sha
+	};
+}
+function parentShas(parents) {
+	if (Array.isArray(parents)) return parents.flatMap((parent) => typeof parent === "string" ? [parent] : parent.sha ? [parent.sha] : []);
+	return parents?.shas ?? (parents?.sha ? [parents.sha] : []);
+}
+function toCommit(repo, raw) {
+	return {
+		ref: {
+			forge: FORGE,
+			instance: repo.instance,
+			repo,
+			sha: raw.sha
+		},
+		sha: raw.sha,
+		message: raw.commit?.message ?? "",
+		author: {
+			actor: toActor(repo.instance, raw.author),
+			name: raw.commit?.author?.name,
+			email: raw.commit?.author?.email,
+			date: toDate(raw.commit?.author?.date)
+		},
+		committer: {
+			actor: toActor(repo.instance, raw.committer),
+			name: raw.commit?.committer?.name,
+			email: raw.commit?.committer?.email,
+			date: toDate(raw.commit?.committer?.date)
+		},
+		parents: parentShas(raw.parents),
+		url: raw.html_url,
+		...raw.stats ? { stats: {
+			additions: raw.stats.additions ?? 0,
+			deletions: raw.stats.deletions ?? 0,
+			total: raw.stats.total
+		} } : {},
+		...raw.files ? { files: raw.files.map(toChangedFile) } : {},
+		raw
+	};
+}
+function toBranch(raw) {
+	return {
+		name: raw.name,
+		sha: raw.commit?.sha ?? "",
+		isProtected: raw.protected,
+		raw
+	};
+}
+function toTag(raw) {
+	return {
+		name: raw.name,
+		sha: raw.commit?.sha ?? "",
+		raw
+	};
+}
+function toTreeEntry(raw) {
+	return {
+		path: raw.path,
+		type: raw.mode === "120000" ? "symlink" : raw.type === "tree" ? "directory" : raw.type === "commit" ? "submodule" : "file",
+		sha: raw.sha,
+		size: raw.size,
+		mode: raw.mode
+	};
+}
+function toWebhook(target, raw) {
+	const nativeEvents = Object.entries(raw).filter(([key, value]) => key.endsWith("_events") && value === true).map(([key]) => key);
+	return {
+		ref: {
+			forge: FORGE,
+			instance: target.instance,
+			target,
+			id: String(raw.id)
+		},
+		url: raw.url,
+		events: eventKindsOf(GITEE_NATIVE_EVENTS, nativeEvents),
+		nativeEvents,
+		active: true,
+		createdAt: toDate(raw.created_at),
+		raw
+	};
+}
+//#endregion
+//#region src/gitee/webhooks.ts
+/** Gitee rejects signatures more than an hour from the request time. */
+const TOLERANCE_MS = 36e5;
+/**
+* Gitee sends either the hook password, or a signature, in `X-Gitee-Token`.
+* The signature is the URL-encoded base64 HMAC-SHA256 of
+* `<X-Gitee-Timestamp>\n<secret>` under the secret, with the timestamp in
+* milliseconds; it signs the timestamp, not the body.
+*/
+async function verifyGiteeToken(delivery, secret, now = Date.now()) {
+	const token = headerValue(delivery.headers, "x-gitee-token");
+	const key = delivery.secret ?? secret;
+	if (!key || !token) return false;
+	if (verifySharedToken(delivery, secret, "x-gitee-token")) return true;
+	const timestamp = headerValue(delivery.headers, "x-gitee-timestamp");
+	if (!timestamp || !(Math.abs(now - Number(timestamp)) <= TOLERANCE_MS)) return false;
+	const expected = await hmacSha256Base64(key, `${timestamp}\n${key}`);
+	let received = token;
+	try {
+		received = decodeURIComponent(token);
+	} catch {}
+	return timingSafeEqual(received, expected);
+}
+const KINDS = {
+	open: "state_change",
+	close: "state_change",
+	reopen: "state_change",
+	merge: "state_change",
+	state_change: "state_change",
+	approved: "review",
+	tested: "review",
+	assign: "assignment",
+	label: "label"
+};
+function translateGiteeWebhook(instance, delivery) {
+	const payload = JSON.parse(bodyText(delivery.body));
+	const hook = payload.hook_name ?? headerValue(delivery.headers, "x-gitee-event") ?? "";
+	const rawRepo = payload.repository ?? payload.project;
+	const repo = rawRepo ? toRepoRef(instance, rawRepo) : void 0;
+	const actor = toActor(instance, payload.sender ?? payload.user ?? payload.comment?.user);
+	const who = actor?.login ?? "someone";
+	const base = {
+		forge: FORGE,
+		instance,
+		id: headerValue(delivery.headers, "x-gitee-delivery") ?? `${hook}:${payload.timestamp ?? Date.now()}`,
+		kindRaw: payload.action ? `${hook}.${payload.action}` : hook,
+		occurredAt: toDate(payload.comment?.created_at) ?? (payload.timestamp ? new Date(Number(payload.timestamp)) : /* @__PURE__ */ new Date()),
+		actor,
+		repo,
+		source: "webhook",
+		payload
+	};
+	if (hook === "push_hooks" || hook === "tag_push_hooks" || hook === "Push Hook" || hook === "Tag Push Hook") return [{
+		...base,
+		...refEvent(who, {
+			ref: payload.ref ?? "",
+			before: payload.before,
+			after: payload.after,
+			created: payload.created,
+			deleted: payload.deleted,
+			commits: (payload.commits ?? []).map((commit) => ({
+				sha: commit.id,
+				message: commit.message,
+				author: commit.author?.username ?? commit.author?.name,
+				url: commit.url
+			}))
+		})
+	}];
+	const thread = repo && payload.pull_request ? {
+		forge: FORGE,
+		instance,
+		repo,
+		kind: "pull_request",
+		number: String(payload.pull_request.number)
+	} : repo && payload.issue ? {
+		forge: FORGE,
+		instance,
+		repo,
+		kind: "issue",
+		number: payload.issue.number
+	} : void 0;
+	if (hook === "note_hooks" || hook === "Note Hook") return [{
+		...base,
+		kind: "comment",
+		thread,
+		summary: `${who} commented${thread ? ` on ${thread.kind === "issue" ? "" : "!"}${thread.number}` : ""}`
+	}];
+	return [{
+		...base,
+		kind: KINDS[payload.action ?? ""] ?? "other",
+		thread,
+		summary: `${who} ${payload.action ?? "changed"} ${thread ? `${thread.kind === "issue" ? "" : "!"}${thread.number}` : hook}`
+	}];
+}
+const giteeWebhooks = ({ options, instance }) => ({
+	events: GITEE_WEBHOOK_EVENTS,
+	verify: (delivery) => verifyGiteeToken(delivery, options.webhookSecret),
+	translate: (delivery) => translateGiteeWebhook(instance, delivery)
+});
+//#endregion
+//#region src/gitee/index.ts
+const PULL = { pull_request: true };
+const PER_PAGE = 50;
+function setupGitee({ instance, origin: context, fetcher, baseUrl }) {
+	const repoPath = (repo) => `/repos/${encodeURIComponent(repo.owner)}/${encodeURIComponent(repo.name)}`;
+	async function readUser(path, signal) {
+		const { data } = await fetcher.json(path, { signal });
+		return {
+			...toActor(instance, data),
+			bio: data.bio ?? void 0,
+			company: data.company ?? void 0,
+			websiteUrl: data.blog || void 0,
+			createdAt: toDate(data.created_at),
+			followers: data.followers,
+			following: data.following,
+			publicRepos: data.public_repos,
+			raw: data
+		};
+	}
+	function requirePull(thread, action) {
+		const ref = requireThread(thread, context);
+		if (ref.kind !== "pull_request") throw new UnsupportedOperationError(`Only pull requests can be ${action}`, context);
+		return ref;
+	}
+	const threadPath = (ref) => `${repoPath(ref.repo)}/${ref.kind === "pull_request" ? "pulls" : "issues"}/${encodeURIComponent(ref.number)}`;
+	/**
+	* Gitee pages by number and reports the page count in `total_page`. The
+	* cursor carries the next page's URL, with the same filters.
+	*/
+	async function numberedPage(path, query, listOptions) {
+		const perPage = Math.min(listOptions.perPage ?? PER_PAGE, 100);
+		const url = listOptions.cursor?.nextUrl ?? fetcher.resolve(path, {
+			...query,
+			page: 1,
+			per_page: perPage
+		});
+		const page = Number(new URL(url).searchParams.get("page") ?? 1);
+		const { data, response } = await fetcher.json(url, { signal: listOptions.signal });
+		const items = data ?? [];
+		const total = Number(response.headers.get("total_page"));
+		return {
+			items,
+			cursor: (Number.isFinite(total) && total > 0 ? page < total : items.length === perPage) ? { nextUrl: nextPage(url, page) } : void 0
+		};
+	}
+	function nextPage(url, page) {
+		const next = new URL(url);
+		next.searchParams.set("page", String(page + 1));
+		return next.toString();
+	}
+	function all(path, options = {}) {
+		return Array.fromAsync(iteratePages((page) => numberedPage(path, {}, page), { signal: options.signal }));
+	}
+	/** Gitee records an approval, with no review object to read back. */
+	async function createReview(thread, input, options) {
+		const ref = requireThread(thread, context);
+		if (ref.kind !== "pull_request") throw new UnsupportedOperationError("Only pull requests can be reviewed", context);
+		if (input.event !== "approve") throw new UnsupportedOperationError("Gitee records approvals only; post anything else as a comment", context);
+		if (input.comments?.length) throw new UnsupportedOperationError("Gitee approvals carry no inline comments", context);
+		const { data } = await fetcher.json(`${threadPath(ref)}/review`, {
+			method: "POST",
+			json: input.body ? { body: input.body } : {},
+			signal: options?.signal
+		});
+		return {
+			ref: {
+				forge: FORGE,
+				instance,
+				thread: ref,
+				id: String(data?.id ?? "approval")
+			},
+			state: "approved",
+			stateRaw: "approved",
+			body: input.body,
+			comments: false,
+			raw: data
+		};
+	}
+	async function headChecks(repo, sha, signal) {
+		const { data } = await fetcher.json(`${repoPath(repo)}/commits/${sha}/check-runs`, { signal });
+		return (Array.isArray(data) ? data : data.check_runs ?? []).map((raw) => toCheck(repo, raw));
+	}
+	async function get(thread, options) {
+		const ref = requireIssueOrPull(thread, context, "read");
+		if (ref.kind === "issue") return toIssueThread(ref, (await fetcher.json(threadPath(ref), { signal: options?.signal })).data);
+		const { data } = await fetcher.json(threadPath(ref), { signal: options?.signal });
+		const result = toPullThread(ref, data);
+		if (data.head?.sha) try {
+			result.checks = summariseChecks((await headChecks(ref.repo, data.head.sha, options?.signal)).map((check) => check.state));
+		} catch (error) {
+			if (!(error instanceof ForgeError)) throw error;
+			result.warnings = [...result.warnings ?? [], toWarning("checks_unreadable", error, ref.number)];
+		}
+		return result;
+	}
+	async function listPage(repo, query = {}) {
+		if (query.kind === "discussion") return {
+			items: [],
+			warnings: [{
+				code: "kind_unsupported",
+				message: "Gitee has no discussions"
+			}]
+		};
+		const warnings = [];
+		if (!query.cursor) {
+			if (query.sort === "comments") warnings.push({
+				code: "sort_unsupported",
+				message: "Gitee cannot sort by comment count; sorted by creation time"
+			});
+			if (query.assignee && query.kind !== "issue") warnings.push({
+				code: "filter_unsupported",
+				message: "Gitee pull requests have reviewers, not assignees; the assignee filter applies to issues only"
+			});
+		}
+		const state = query.state ?? "open";
+		const createdAfter = query.createdAfter?.getTime();
+		const phases = [];
+		for (const kind of query.kind ? [query.kind] : ["issue", "pull_request"]) {
+			const states = kind === "issue" ? state === "open" ? ["open", "progressing"] : state === "closed" ? ["closed", "rejected"] : ["all"] : state === "closed" ? ["closed", "merged"] : [state];
+			phases.push(...states.map((value) => ({
+				kind,
+				state: value
+			})));
+		}
+		const page = await phased(phases.map((phase) => async (cursor) => {
+			const pulls = phase.kind === "pull_request";
+			const result = await numberedPage(`${repoPath(repo)}/${pulls ? "pulls" : "issues"}`, {
+				state: phase.state,
+				labels: query.labels?.join(","),
+				sort: query.sort === "updated" ? "updated" : "created",
+				direction: query.direction ?? "desc",
+				since: query.since?.toISOString(),
+				...pulls ? { author: query.author } : {
+					creator: query.author,
+					assignee: query.assignee
+				}
+			}, {
+				perPage: query.perPage,
+				cursor,
+				signal: query.signal
+			});
+			return {
+				items: result.items.filter((raw) => (createdAfter === void 0 || (Date.parse(raw.created_at ?? "") || 0) >= createdAfter) && hasEveryLabel(raw.labels, query.labels)).map((raw) => {
+					const ref = {
+						forge: FORGE,
+						instance,
+						repo,
+						kind: phase.kind,
+						number: String(raw.number)
+					};
+					return pulls ? toPullThread(ref, raw) : toIssueThread(ref, raw);
+				}),
+				cursor: result.cursor
+			};
+		}), query.cursor);
+		return warnings.length ? {
+			...page,
+			warnings: [...warnings, ...page.warnings ?? []]
+		} : page;
+	}
+	/** Gitee subscribes with one boolean per event group rather than a list of names. */
+	function hookFlags(input) {
+		return Object.fromEntries(nativeEventsFor(GITEE_NATIVE_EVENTS, input.events, input.nativeEvents).map((flag) => [flag, true]));
+	}
+	/** Gitee searches issues only; its pull requests have no search endpoint. */
+	async function searchThreadsPage(query) {
+		if (query.kind === "pull_request") return {
+			items: [],
+			warnings: [{
+				code: "kind_unsupported",
+				message: "Gitee has no pull request search"
+			}]
+		};
+		const warnings = [];
+		if (!query.cursor && query.involves) warnings.push({
+			code: "filter_unsupported",
+			message: "Gitee has no involves filter; it was ignored"
+		});
+		if (!query.cursor && query.since) warnings.push({
+			code: "filter_unsupported",
+			message: "Gitee issue search has no update-time filter; it was ignored"
+		});
+		const page = await numberedPage("/search/issues", {
+			q: query.text ?? "",
+			repo: query.repo ? `${query.repo.owner}/${query.repo.name}` : void 0,
+			state: query.state && query.state !== "all" ? query.state : void 0,
+			label: query.labels?.join(","),
+			author: query.author,
+			assignee: query.assignee,
+			sort: query.sort === "updated" ? "updated_at" : "created_at",
+			order: query.direction ?? "desc"
+		}, {
+			perPage: query.perPage,
+			cursor: query.cursor,
+			signal: query.signal
+		});
+		return {
+			items: page.items.flatMap((raw) => {
+				const repo = query.repo ?? (raw.repository && toRepoRef(instance, raw.repository));
+				return repo && hasEveryLabel(raw.labels, query.labels) ? [toIssueThread({
+					forge: FORGE,
+					instance,
+					repo,
+					kind: "issue",
+					number: raw.number
+				}, raw)] : [];
+			}),
+			cursor: page.cursor,
+			...warnings.length ? { warnings } : {}
+		};
+	}
+	async function searchReposPage(query) {
+		const page = await numberedPage("/search/repositories", {
+			q: query.text ?? "",
+			owner: query.owner,
+			language: query.language,
+			sort: query.sort === "stars" ? "stars_count" : query.sort === "updated" ? "last_push_at" : void 0,
+			order: query.direction ?? "desc"
+		}, {
+			perPage: query.perPage,
+			cursor: query.cursor,
+			signal: query.signal
+		});
+		const warnings = query.sort === "created" && !query.cursor ? [{
+			code: "sort_unsupported",
+			message: "Gitee has no repository search by creation time; sorted by best match"
+		}] : void 0;
+		return {
+			items: page.items.map((raw) => toRepo(instance, raw)),
+			cursor: page.cursor,
+			warnings
+		};
+	}
+	async function commentsPage(thread, listOptions = {}) {
+		const ref = requireIssueOrPull(thread, context, "list comments on");
+		const page = await numberedPage(`${threadPath(ref)}/comments`, {}, listOptions);
+		return {
+			items: page.items.filter(isConversationComment).map((raw) => toComment(ref, raw)),
+			cursor: page.cursor
+		};
+	}
+	/** Comments and the operation log, merged and ordered by time, so one complete page. */
+	async function eventsPage(thread, listOptions = {}) {
+		const ref = requireIssueOrPull(thread, context, "list events on");
+		const logsPath = ref.kind === "pull_request" ? `${threadPath(ref)}/operate_logs` : `/repos/${encodeURIComponent(ref.repo.owner)}/issues/${encodeURIComponent(ref.number)}/operate_logs`;
+		const [comments, { data: logs }] = await Promise.all([all(`${threadPath(ref)}/comments`, listOptions), fetcher.json(logsPath, {
+			query: ref.kind === "issue" ? { repo: ref.repo.name } : { sort: "asc" },
+			signal: listOptions.signal
+		})]);
+		return { items: [...comments.map((raw) => toCommentEvent(ref, raw)), ...(logs ?? []).map((raw) => toLogEvent(ref, raw))].sort((a, b) => a.occurredAt.getTime() - b.occurredAt.getTime()) };
+	}
+	/** Issue writes are addressed by owner, with the repository in the body. */
+	function issueWrite(ref, json, signal) {
+		return fetcher.json(`/repos/${encodeURIComponent(ref.repo.owner)}/issues/${encodeURIComponent(ref.number)}`, {
+			method: "PATCH",
+			json: {
+				repo: ref.repo.name,
+				...json
+			},
+			signal
+		});
+	}
+	async function setState(thread, state, options) {
+		const ref = requireIssueOrPull(thread, context, state === "open" ? "reopen" : "close");
+		if (ref.kind === "issue") {
+			await issueWrite(ref, { state }, options?.signal);
+			return;
+		}
+		await fetcher.raw(threadPath(ref), {
+			method: "PATCH",
+			json: { state },
+			signal: options?.signal
+		});
+	}
+	async function notificationPage(listOptions = {}) {
+		const perPage = Math.min(listOptions.perPage ?? PER_PAGE, 100);
+		const url = listOptions.cursor?.nextUrl ?? fetcher.resolve("/notifications/threads", {
+			unread: listOptions.all ? void 0 : true,
+			since: listOptions.since?.toISOString(),
+			page: 1,
+			per_page: perPage
+		});
+		const page = Number(new URL(url).searchParams.get("page") ?? 1);
+		const { data, response } = await fetcher.json(url, { signal: listOptions.signal });
+		const items = data.list ?? [];
+		const totalPages = Number(response.headers.get("total_page"));
+		const more = Number.isFinite(totalPages) && totalPages > 0 ? page < totalPages : data.total_count !== void 0 ? page * perPage < data.total_count : items.length === perPage;
+		return {
+			items: items.map((raw) => toNotification(instance, raw)),
+			cursor: more ? { nextUrl: nextPage(url, page) } : void 0
+		};
+	}
+	async function releasesPage(repo, listOptions = {}) {
+		const page = await numberedPage(`${repoPath(repo)}/releases`, {}, listOptions);
+		return {
+			items: page.items.map((raw) => toRelease(repo, raw)),
+			cursor: page.cursor
+		};
+	}
+	return {
+		checks: { list: verb(true, async (repo, sha, options) => ({ items: await headChecks(repo, sha, options?.signal) })) },
+		traits: {
+			eventKinds: "native",
+			authKinds: ["token", "anonymous"]
+		},
+		users: {
+			get: verb(true, (login, options) => readUser(`/users/${encodeURIComponent(login)}`, options?.signal)),
+			me: verb(true, (options) => readUser("/user", options?.signal))
+		},
+		repos: {
+			get: verb(true, async (ref, options) => toRepo(instance, (await fetcher.json(repoPath(ref), { signal: options?.signal })).data)),
+			listPage: verb(true, async (listOptions = {}) => {
+				const page = await numberedPage("/user/repos", {}, listOptions);
+				return {
+					items: page.items.map((raw) => toRepo(instance, raw)),
+					cursor: page.cursor
+				};
+			}),
+			labelsPage: verb(true, async (repo, listOptions = {}) => {
+				const page = await numberedPage(`${repoPath(repo)}/labels`, {}, listOptions);
+				return {
+					items: page.items.map((raw) => ({
+						name: raw.name,
+						colour: raw.color ?? void 0
+					})),
+					cursor: page.cursor
+				};
+			}),
+			createLabel: verb("unverified", async (repo, label, options) => {
+				const { data } = await fetcher.json(`${repoPath(repo)}/labels`, {
+					method: "POST",
+					json: {
+						name: label.name,
+						color: hexColour(label.colour)
+					},
+					signal: options?.signal
+				});
+				return {
+					name: data.name,
+					colour: data.color ?? void 0
+				};
+			}),
+			collaboratorsPage: verb(true, async (repo, listOptions = {}) => {
+				const page = await numberedPage(`${repoPath(repo)}/collaborators`, {}, listOptions);
+				return {
+					items: page.items.map((raw) => ({
+						actor: toActor(instance, raw),
+						role: raw.permissions?.admin ? "admin" : raw.permissions?.push ? "write" : raw.permissions?.pull ? "read" : "none",
+						raw
+					})),
+					cursor: page.cursor
+				};
+			})
+		},
+		notifications: {
+			listPage: verb(true, notificationPage),
+			markRead: verb(true, async (ref, options) => {
+				await fetcher.raw(`/notifications/threads/${ref.id}`, {
+					method: "PATCH",
+					signal: options?.signal
+				});
+			}),
+			markAllRead: verb("unverified", async (bulk = {}) => {
+				if (bulk.before) throw new UnsupportedOperationError("Gitee marks notifications read without a time bound", context);
+				await fetcher.raw(bulk.repo ? `${repoPath(bulk.repo)}/notifications` : "/notifications/threads", {
+					method: "PUT",
+					signal: bulk.signal
+				});
+			}),
+			unreadCount: verb(true, async (options) => (await fetcher.json("/notifications/count", {
+				query: { unread: true },
+				signal: options?.signal
+			})).data.notification_count ?? 0)
+		},
+		contents: {
+			file: verb(true, async (repo, path, fileOptions = {}) => {
+				const { data } = await fetcher.json(`${repoPath(repo)}/contents/${path.split("/").map(encodeURIComponent).join("/")}`, {
+					query: { ref: fileOptions.ref },
+					signal: fileOptions.signal
+				});
+				const file = {
+					path: data.path,
+					sha: data.sha,
+					size: data.size,
+					url: data._links?.html
+				};
+				return toFileContent(fromBase64(data.content ?? ""), file, fileOptions, context);
+			}),
+			treePage: verb(true, async (repo, treeOptions = {}) => {
+				const ref = treeOptions.ref ?? (await fetcher.json(repoPath(repo), { signal: treeOptions.signal })).data.default_branch ?? "master";
+				const { data } = await fetcher.json(`${repoPath(repo)}/git/trees/${encodeURIComponent(ref)}`, {
+					query: { recursive: treeOptions.recursive ? 1 : void 0 },
+					signal: treeOptions.signal
+				});
+				const prefix = treeOptions.path?.replace(/^\/|\/$/g, "");
+				return {
+					items: (data.tree ?? []).filter((entry) => !prefix || entry.path.startsWith(`${prefix}/`)).map(toTreeEntry),
+					...data.truncated ? { warnings: [{
+						code: "tree_truncated",
+						message: "Gitee truncated the tree; read it directory by directory instead"
+					}] } : {}
+				};
+			}),
+			branchesPage: verb(true, async (repo, listOptions = {}) => {
+				const page = await numberedPage(`${repoPath(repo)}/branches`, {}, listOptions);
+				return {
+					items: page.items.map(toBranch),
+					cursor: page.cursor
+				};
+			}),
+			tagsPage: verb(true, async (repo, listOptions = {}) => {
+				const { data } = await fetcher.json(`${repoPath(repo)}/tags`, { signal: listOptions.signal });
+				return { items: (data ?? []).map(toTag) };
+			}),
+			resolveRef: verb(true, async (repo, ref, options) => (await fetcher.json(`${repoPath(repo)}/commits/${encodeURIComponent(ref)}`, { signal: options?.signal })).data.sha),
+			commitsPage: verb(true, async (repo, query = {}) => {
+				const page = await numberedPage(`${repoPath(repo)}/commits`, {
+					sha: query.ref,
+					path: query.path,
+					author: query.author,
+					since: query.since?.toISOString(),
+					until: query.until?.toISOString()
+				}, query);
+				return {
+					items: page.items.map((raw) => toCommit(repo, raw)),
+					cursor: page.cursor
+				};
+			}),
+			commit: verb(true, async (repo, sha, options) => toCommit(repo, (await fetcher.json(`${repoPath(repo)}/commits/${sha}`, { signal: options?.signal })).data)),
+			compare: verb(true, async (repo, base, head, options) => {
+				const { data } = await fetcher.json(`${repoPath(repo)}/compare/${encodeURIComponent(base)}...${encodeURIComponent(head)}`, { signal: options?.signal });
+				return {
+					base,
+					head,
+					aheadBy: data.commits?.length,
+					commits: (data.commits ?? []).map((raw) => toCommit(repo, raw)),
+					files: (data.files ?? []).map(toChangedFile),
+					raw: data
+				};
+			})
+		},
+		search: {
+			threadsPage: verb(true, searchThreadsPage),
+			reposPage: verb(true, searchReposPage)
+		},
+		releases: {
+			listPage: verb(true, releasesPage),
+			get: verb(true, async (ref, options) => toRelease(ref.repo, (await fetcher.json(`${repoPath(ref.repo)}/releases/${ref.id}`, { signal: options?.signal })).data)),
+			getByTag: verb(true, async (repo, tag, options) => toRelease(repo, (await fetcher.json(`${repoPath(repo)}/releases/tags/${encodeURIComponent(tag)}`, { signal: options?.signal })).data)),
+			latest: verb(true, async (repo, options) => {
+				try {
+					const latest = toRelease(repo, (await fetcher.json(`${repoPath(repo)}/releases/latest`, { signal: options?.signal })).data);
+					if (!latest.isPrerelease) return latest;
+				} catch (error) {
+					if (!(error instanceof NotFoundError)) throw error;
+					return;
+				}
+				return (await releasesPage(repo, {
+					perPage: 20,
+					signal: options?.signal
+				})).items.find((release) => !release.isPrerelease);
+			})
+		},
+		threads: {
+			get: perKind({
+				issue: true,
+				pull_request: true
+			}, get),
+			getMany: verb(true, (refs, options) => getManyConcurrently(refs, get, options)),
+			listPage: perKind({
+				issue: true,
+				pull_request: true
+			}, listPage),
+			eventsPage: verb(true, eventsPage),
+			filesPage: verb(true, async (thread, listOptions = {}) => {
+				const ref = requirePull(thread, "read for changed files");
+				const { data } = await fetcher.json(`${threadPath(ref)}/files`, { signal: listOptions.signal });
+				return { items: (data ?? []).map(toChangedFile) };
+			}),
+			commitsPage: verb(true, async (thread, listOptions = {}) => {
+				const ref = requirePull(thread, "read for commits");
+				const { data } = await fetcher.json(`${threadPath(ref)}/commits`, { signal: listOptions.signal });
+				return { items: (data ?? []).map((raw) => toCommit(thread.repo, raw)) };
+			}),
+			commentsPage: perKind({
+				issue: true,
+				pull_request: true
+			}, commentsPage),
+			comment: perKind({
+				issue: "unverified",
+				pull_request: true
+			}, async (thread, body, options) => {
+				const ref = requireIssueOrPull(thread, context, "comment on");
+				return toComment(ref, (await fetcher.json(`${threadPath(ref)}/comments`, {
+					method: "POST",
+					json: { body },
+					signal: options?.signal
+				})).data);
+			}),
+			editComment: perKind({
+				issue: "unverified",
+				pull_request: "unverified"
+			}, async (ref, body, options) => {
+				const kind = ref.thread.kind === "pull_request" ? "pulls" : "issues";
+				return toComment(ref.thread, (await fetcher.json(`${repoPath(ref.thread.repo)}/${kind}/comments/${ref.id}`, {
+					method: "PATCH",
+					json: { body },
+					signal: options?.signal
+				})).data);
+			}),
+			deleteComment: perKind({
+				issue: "unverified",
+				pull_request: "unverified"
+			}, async (ref, options) => {
+				const kind = ref.thread.kind === "pull_request" ? "pulls" : "issues";
+				await fetcher.raw(`${repoPath(ref.thread.repo)}/${kind}/comments/${ref.id}`, {
+					method: "DELETE",
+					signal: options?.signal
+				});
+			}),
+			create: perKind({
+				issue: "unverified",
+				pull_request: "unverified"
+			}, async (repo, input, options) => {
+				const labels = input.labels?.join(",");
+				if (input.kind === "issue") {
+					if ((input.assignees?.length ?? 0) > 1) throw new UnsupportedOperationError("Gitee issues take a single assignee", context);
+					const { data } = await fetcher.json(`/repos/${encodeURIComponent(repo.owner)}/issues`, {
+						method: "POST",
+						json: {
+							repo: repo.name,
+							title: input.title,
+							body: input.body,
+							labels,
+							assignee: input.assignees?.[0] ? actorLogin(input.assignees[0]) : void 0
+						},
+						signal: options?.signal
+					});
+					return toIssueThread({
+						forge: FORGE,
+						instance,
+						repo,
+						kind: "issue",
+						number: data.number
+					}, data);
+				}
+				if (!input.head || !input.base) throw new UnsupportedOperationError("Creating a pull request needs head and base branches", context);
+				const { data } = await fetcher.json(`${repoPath(repo)}/pulls`, {
+					method: "POST",
+					json: {
+						title: input.title,
+						body: input.body,
+						head: input.head,
+						base: input.base,
+						labels,
+						draft: input.draft,
+						assignees: input.assignees?.map(actorLogin).join(",")
+					},
+					signal: options?.signal
+				});
+				return toPullThread({
+					forge: FORGE,
+					instance,
+					repo,
+					kind: "pull_request",
+					number: String(data.number)
+				}, data);
+			}),
+			update: perKind({
+				issue: "unverified",
+				pull_request: "unverified"
+			}, async (thread, input, options) => {
+				const ref = requireIssueOrPull(thread, context, "update");
+				return ref.kind === "issue" ? toIssueThread(ref, (await issueWrite(ref, { ...input }, options?.signal)).data) : toPullThread(ref, (await fetcher.json(threadPath(ref), {
+					method: "PATCH",
+					json: input,
+					signal: options?.signal
+				})).data);
+			}),
+			close: perKind({
+				issue: "unverified",
+				pull_request: true
+			}, (ref, options) => setState(ref, "closed", options)),
+			reopen: perKind({
+				issue: "unverified",
+				pull_request: true
+			}, (ref, options) => setState(ref, "open", options)),
+			addLabels: perKind({
+				issue: "unverified",
+				pull_request: "unverified"
+			}, async (thread, labels, options) => {
+				await fetcher.raw(`${threadPath(requireIssueOrPull(thread, context, "label"))}/labels`, {
+					method: "POST",
+					json: labels,
+					signal: options?.signal
+				});
+			}),
+			removeLabels: perKind({
+				issue: "unverified",
+				pull_request: "unverified"
+			}, async (thread, labels, options) => {
+				const ref = requireIssueOrPull(thread, context, "label");
+				for (const label of labels) await fetcher.raw(`${threadPath(ref)}/labels/${encodeURIComponent(label)}`, {
+					method: "DELETE",
+					signal: options?.signal
+				});
+			}),
+			setLabels: perKind({
+				issue: "unverified",
+				pull_request: "unverified"
+			}, async (thread, labels, options) => {
+				await fetcher.raw(`${threadPath(requireIssueOrPull(thread, context, "label"))}/labels`, {
+					method: "PUT",
+					json: labels,
+					signal: options?.signal
+				});
+			}),
+			setAssignees: perKind({ issue: "unverified" }, async (thread, assignees, options) => {
+				if (assignees.length > 1) throw new UnsupportedOperationError("Gitee issues take a single assignee", context);
+				await issueWrite(requireIssueOrPull(thread, context, "assign"), { assignee: assignees[0] ? actorLogin(assignees[0]) : "" }, options?.signal);
+			}),
+			requestReview: perKind({ pull_request: "unverified" }, async (thread, reviewers, options) => {
+				await fetcher.raw(`${threadPath(requireThread(thread, context))}/assignees`, {
+					method: "POST",
+					json: { assignees: reviewers.map(actorLogin).join(",") },
+					signal: options?.signal
+				});
+			}),
+			merge: verb(true, async (thread, mergeOptions = {}, hooks = {}) => {
+				const ref = requireThread(thread, context);
+				if (ref.kind !== "pull_request") throw new UnsupportedOperationError("Only pull requests can be merged", context);
+				if (mergeOptions.whenChecksPass) throw new UnsupportedOperationError("Gitee has no auto-merge through the API", context);
+				if (!mergeOptions.method) throw new MergeMethodRequiredError([
+					"merge",
+					"squash",
+					"rebase"
+				], context);
+				if (![
+					"merge",
+					"squash",
+					"rebase"
+				].includes(mergeOptions.method)) throw new UnsupportedOperationError(`Gitee does not support the ${mergeOptions.method} merge method`, context);
+				await hooks.beforeMerge?.();
+				await fetcher.raw(`${threadPath(ref)}/merge`, {
+					method: "PUT",
+					json: {
+						merge_method: mergeOptions.method,
+						title: mergeOptions.title,
+						description: mergeOptions.message
+					},
+					mapError: toMergeError,
+					signal: mergeOptions.signal
+				});
+			}),
+			checks: perKind(PULL, async (thread, options) => {
+				const ref = requireThread(thread, context);
+				const { data } = await fetcher.json(threadPath(ref), { signal: options?.signal });
+				return { items: data.head?.sha ? await headChecks(ref.repo, data.head.sha, options?.signal) : [] };
+			}),
+			createReview: verb("unverified", createReview)
+		},
+		web: githubShapedWeb(baseUrl.replace(/\/api\/v5$/, ""), {
+			pull: "pulls",
+			commentFragment: "note_",
+			file: (at) => `/blob/${encodeURIComponent(at)}`,
+			lineFragment: (line) => `L${line}`,
+			pullPrefix: "!"
+		}),
+		webhooks: {
+			listPage: verb("unverified", async (target, listOptions = {}) => {
+				const page = await numberedPage(`${repoPath(target)}/hooks`, {}, listOptions);
+				return {
+					items: page.items.map((raw) => toWebhook(target, raw)),
+					cursor: page.cursor
+				};
+			}),
+			create: verb("unverified", async (target, input, options) => toWebhook(target, (await fetcher.json(`${repoPath(target)}/hooks`, {
+				method: "POST",
+				json: {
+					url: input.url,
+					password: input.secret,
+					...hookFlags(input)
+				},
+				signal: options?.signal
+			})).data)),
+			update: verb("unverified", async (ref, update, options) => toWebhook(ref.target, (await fetcher.json(`${repoPath(ref.target)}/hooks/${ref.id}`, {
+				method: "PATCH",
+				json: {
+					...update.url ? { url: update.url } : {},
+					...update.secret ? { password: update.secret } : {},
+					...hookFlags(update)
+				},
+				signal: options?.signal
+			})).data)),
+			delete: verb("unverified", async (ref, options) => {
+				await fetcher.raw(`${repoPath(ref.target)}/hooks/${ref.id}`, {
+					method: "DELETE",
+					signal: options?.signal
+				});
+			}),
+			rotateSecret: verb("unverified", async (ref, secret, options) => toWebhook(ref.target, (await fetcher.json(`${repoPath(ref.target)}/hooks/${ref.id}`, {
+				method: "PATCH",
+				json: { password: secret },
+				signal: options?.signal
+			})).data))
+		},
+		scopes: giteeScopesFor
+	};
+}
+const GITEE = {
+	forge: FORGE,
+	baseUrl: "https://gitee.com",
+	anonymous: true,
+	apiPath: "/api/v5",
+	headers: { accept: "application/json" },
+	authHeaders: ({ options: { auth } }) => auth?.type === "token" ? async () => ({ authorization: `token ${await resolveToken(auth)}` }) : void 0,
+	setup: setupGitee
+};
+/** Creates a Gitee provider for gitee.com. The enterprise edition (`e.gitee.com`) is not covered. */
+const gitee = /* @__PURE__ */ defineForgeProvider({
+	...GITEE,
+	webhooks: giteeWebhooks
+});
+/** `gitee()` without webhook ingestion, for bundles that never receive a delivery. */
+const giteeLite = /* @__PURE__ */ defineForgeProvider(GITEE);
+/** Gitee OAuth scopes, one per resource group. */
+function giteeScopesFor(verb) {
+	const [group = "", name = ""] = verb.split(".");
+	if (group === "webhooks") return name === "verify" || name === "ingest" ? {} : { token: ["hook"] };
+	if (group === "notifications") return { token: ["notes", "user_info"] };
+	if (group === "users" || group === "search") return { token: ["user_info"] };
+	if (group === "threads") return { token: [
+		"issues",
+		"pull_requests",
+		"notes"
+	] };
+	return { token: ["projects"] };
+}
+//#endregion
+export { giteeLite as n, giteeScopesFor as r, gitee as t };