bwx 0.4.1 → 0.5.0

package/src/bw/folders.ts

@@ -0,0 +1,96 @@
+import pc from "picocolors";
+import { CliError, ExitCode } from "../cli/errors.ts";
+import type { GlobalOptions } from "../cli/types.ts";
+import { runBwOrThrow } from "./runner.ts";
+import { withSession } from "./session.ts";
+
+export interface BwFolder {
+	/** `null` is bw's "No Folder" bucket, which every unfiled item belongs to. */
+	id: string | null;
+	name: string;
+}
+
+const UUID_RE =
+	/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+/** The spelling bw expects on `--folderid` for items that are in no folder. */
+export const NO_FOLDER = "null";
+
+export async function listFolders(opts: GlobalOptions): Promise<BwFolder[]> {
+	const json = await withSession(opts, () => runBwOrThrow(["list", "folders"]));
+	const raw = JSON.parse(json) as Array<Record<string, unknown>>;
+	return raw.map((folder) => ({
+		id: typeof folder.id === "string" ? folder.id : null,
+		name: String(folder.name ?? ""),
+	}));
+}
+
+/**
+ * Turns whatever the caller wrote in `--folder` into an id. IDs pass straight
+ * through, so this costs nothing for callers that already have one; names are
+ * resolved against the vault because a folder id is not something a human — or
+ * an agent reading `bwx list` output — can otherwise discover.
+ *
+ * Returns `null` for the "no folder" bucket (`--folder none`).
+ */
+export async function resolveFolderRef(
+	ref: string,
+	opts: GlobalOptions,
+): Promise<string | null> {
+	if (UUID_RE.test(ref)) return ref;
+	if (ref === NO_FOLDER || ref.toLowerCase() === "none") return null;
+
+	const folders = await listFolders(opts);
+	const named = folders.filter((folder) => folder.id !== null);
+
+	const exact = named.filter(
+		(folder) => folder.name.toLowerCase() === ref.toLowerCase(),
+	);
+	const matches =
+		exact.length > 0
+			? exact
+			: named.filter((folder) =>
+					folder.name.toLowerCase().includes(ref.toLowerCase()),
+				);
+
+	if (matches.length === 0) {
+		throw new CliError(
+			`No folder matching "${ref}". Run 'bwx folders' to list them.`,
+			ExitCode.NotFound,
+		);
+	}
+
+	if (matches.length > 1) {
+		throw new CliError(
+			formatAmbiguousFolders(ref, matches, opts),
+			ExitCode.BadArgs,
+		);
+	}
+
+	return matches[0]!.id;
+}
+
+/** Resolves `--folder` for read commands, where "no folder" is a real filter. */
+export async function resolveFolderFilter(
+	ref: string,
+	opts: GlobalOptions,
+): Promise<string> {
+	return (await resolveFolderRef(ref, opts)) ?? NO_FOLDER;
+}
+
+function formatAmbiguousFolders(
+	ref: string,
+	matches: BwFolder[],
+	opts: GlobalOptions,
+): string {
+	if (opts.json) {
+		return `Multiple folders match "${ref}": ${JSON.stringify(matches)}`;
+	}
+
+	const lines = [`Multiple folders match "${ref}":\n`];
+	for (const folder of matches) {
+		lines.push(`  ${pc.dim(folder.id ?? "-")}  ${folder.name}`);
+	}
+	lines.push(`\nUse the full name or its ID.`);
+	return lines.join("\n");
+}

package/src/bw/generate.ts

@@ -0,0 +1,91 @@
+import { CliError, ExitCode } from "../cli/errors.ts";
+import { runBwOrThrow } from "./runner.ts";
+
+/**
+ * `bw generate` is local — it needs no session and no unlocked vault, so a
+ * generated secret costs one fast spawn and never touches the network.
+ */
+
+export interface GenerateOptions {
+	length?: number;
+	passphrase?: boolean;
+	words?: number;
+	separator?: string;
+	capitalize?: boolean;
+	includeNumber?: boolean;
+	uppercase?: boolean;
+	lowercase?: boolean;
+	numbers?: boolean;
+	special?: boolean;
+	ambiguous?: boolean;
+}
+
+/** bw's own defaults, restated here so `--no-numbers` can turn one off without
+ * silently disabling the rest: bw needs every wanted character set named. */
+const CHARSET_DEFAULTS = {
+	uppercase: true,
+	lowercase: true,
+	numbers: true,
+	special: false,
+} as const;
+
+export function buildGenerateArgs(options: GenerateOptions): string[] {
+	const args = ["generate"];
+
+	if (options.passphrase) {
+		args.push("--passphrase");
+		if (options.words !== undefined) args.push("--words", String(options.words));
+		if (options.separator !== undefined) {
+			args.push("--separator", options.separator);
+		}
+		if (options.capitalize) args.push("--capitalize");
+		if (options.includeNumber) args.push("--includeNumber");
+		return args;
+	}
+
+	const charsets = {
+		uppercase: options.uppercase ?? CHARSET_DEFAULTS.uppercase,
+		lowercase: options.lowercase ?? CHARSET_DEFAULTS.lowercase,
+		numbers: options.numbers ?? CHARSET_DEFAULTS.numbers,
+		special: options.special ?? CHARSET_DEFAULTS.special,
+	};
+
+	if (!Object.values(charsets).some(Boolean)) {
+		throw new CliError(
+			"At least one character set must stay enabled.",
+			ExitCode.BadArgs,
+		);
+	}
+
+	if (options.length !== undefined) {
+		if (!Number.isInteger(options.length) || options.length < 5) {
+			throw new CliError(
+				`Invalid --length "${options.length}". Use an integer of at least 5.`,
+				ExitCode.BadArgs,
+			);
+		}
+		args.push("--length", String(options.length));
+	}
+
+	if (charsets.uppercase) args.push("--uppercase");
+	if (charsets.lowercase) args.push("--lowercase");
+	if (charsets.numbers) args.push("--number");
+	if (charsets.special) args.push("--special");
+	if (options.ambiguous) args.push("--ambiguous");
+
+	return args;
+}
+
+export async function generateSecret(
+	options: GenerateOptions,
+): Promise<string> {
+	const value = await runBwOrThrow(buildGenerateArgs(options), {
+		session: null,
+	});
+
+	if (!value) {
+		throw new CliError("bw generate returned nothing", ExitCode.BwError);
+	}
+
+	return value;
+}

package/src/bw/session.ts

@@ -60,21 +60,47 @@ async function getMasterPassword(): Promise<string> {
 	return pw;
 }
 
+/**
+ * Whether reads will work right now without an unlock. `bw status` answers for
+ * the vault, not for us: it reports "locked" whenever the vault has no session
+ * of its own, even when bwx holds a cached one that works perfectly. Reporting
+ * that raw answer sends callers off to unlock a vault they can already read.
+ */
+export type SessionState =
+	/** Cached session works — reads succeed with no unlock. */
+	| "valid"
+	/** A session was cached but the vault no longer accepts it. */
+	| "stale"
+	/** Nothing cached; the next read unlocks. */
+	| "none";
+
+/** Confirms a token by asking the vault, which is the only authority on it. */
+async function sessionWorks(token: string): Promise<boolean> {
+	const check = await runBw(["status"], { session: token });
+	if (check.exitCode !== 0) return false;
+	try {
+		return (
+			BwStatusSchema.parse(JSON.parse(check.stdout)).status === "unlocked"
+		);
+	} catch {
+		return false;
+	}
+}
+
+export async function probeSessionState(
+	opts: GlobalOptions,
+): Promise<SessionState> {
+	const cached = getSession() || loadCachedSession(opts);
+	if (!cached) return "none";
+	return (await sessionWorks(cached)) ? "valid" : "stale";
+}
+
 export async function ensureUnlocked(opts: GlobalOptions): Promise<void> {
 	// Try cached session first
 	const cached = getSession() || loadCachedSession(opts);
 	if (cached) {
 		setSession(cached);
-		// Quick check — try a lightweight command
-		const check = await runBw(["status"]);
-		if (check.exitCode === 0) {
-			try {
-				const status = BwStatusSchema.parse(JSON.parse(check.stdout));
-				if (status.status === "unlocked") return;
-			} catch {
-				// Fall through
-			}
-		}
+		if (await sessionWorks(cached)) return;
 	}
 
 	const status = await getStatus();

package/src/cli/commands/config.ts

@@ -7,6 +7,7 @@ import {
 	loadConfig,
 	saveConfig,
 } from "../../config/store.ts";
+import { readLine } from "../input.ts";
 
 export function registerConfig(program: Command): void {
 	const configCmd = program
@@ -161,13 +162,3 @@ function redactSensitive(value: unknown): unknown {
 function isSensitiveKey(key: string): boolean {
 	return SENSITIVE_KEY_RE.some((pattern) => pattern.test(key));
 }
-
-async function readLine(): Promise<string> {
-	const chunks: Uint8Array[] = [];
-	for await (const chunk of Bun.stdin.stream()) {
-		chunks.push(chunk);
-		const text = Buffer.concat(chunks).toString();
-		if (text.includes("\n")) return text.split("\n")[0]!.trim();
-	}
-	return Buffer.concat(chunks).toString().trim();
-}

package/src/cli/commands/create.ts

@@ -5,6 +5,8 @@ import { CliError, ExitCode } from "../errors.ts";
 import { runBwOrThrow } from "../../bw/runner.ts";
 import { withSession } from "../../bw/session.ts";
 import { buildNewItem, bwEncode } from "../../bw/encoding.ts";
+import { generateSecret } from "../../bw/generate.ts";
+import { resolveFolderRef } from "../../bw/folders.ts";
 import {
 	assertSingleStdinSource,
 	collect,
@@ -15,6 +17,7 @@ import {
 	StdinReader,
 	type ItemTextInputs,
 } from "../input.ts";
+import { redactGeneratedPassword } from "./generate.ts";
 
 interface CreateOptions extends ItemTextInputs {
 	type: string;
@@ -27,8 +30,19 @@ interface CreateOptions extends ItemTextInputs {
 	folder?: string;
 	favorite?: boolean;
 	fromJson?: boolean;
+	generateLength?: number;
 }
 
+/** Flags a secure note has nowhere to store — see {@link assertLoginFlags}. */
+const LOGIN_ONLY_FLAGS: Array<[keyof CreateOptions, string]> = [
+	["username", "--username"],
+	["password", "--password"],
+	["passwordStdin", "--password-stdin"],
+	["passwordFile", "--password-file"],
+	["passwordEnv", "--password-env"],
+	["passwordGenerate", "--password-generate"],
+];
+
 export function registerCreate(program: Command): void {
 	program
 		.command("create").alias("add")
@@ -42,11 +56,13 @@ export function registerCreate(program: Command): void {
 		.option("--password-stdin", "Read password from stdin")
 		.option("--password-file <path>", "Read password from file (use - for stdin)")
 		.option("--password-env <name>", "Read password from environment variable")
+		.option("--password-generate", "Generate the password; it is never printed")
+		.option("--generate-length <n>", "Length for --password-generate", parseInt)
 		.option("--uri <url>", "URI (repeatable)", collect, [])
 		.option("--field <kv>", "Custom field k=v (repeatable)", collect, [])
 		.option("--field-file <kv>", "Custom field value from file k=path (repeatable)", collect, [])
 		.option("--field-env <kv>", "Custom field value from env var k=ENV (repeatable)", collect, [])
-		.option("--folder <id>", "Folder ID")
+		.option("--folder <name|id>", "Folder name or ID")
 		.option("--favorite", "Mark as favorite")
 		.option("--from-json", "Read full item JSON from stdin")
 		.action(async function (
@@ -57,6 +73,7 @@ export function registerCreate(program: Command): void {
 			const stdin = new StdinReader();
 
 			let encoded: string;
+			let generated = false;
 
 			if (localOpts.fromJson) {
 				const stdinText = await stdin.read();
@@ -82,6 +99,8 @@ export function registerCreate(program: Command): void {
 					);
 				}
 
+				assertLoginFlags(localOpts);
+
 				const explicitStdinSources = listExplicitStdinInputs({
 					...localOpts,
 					fieldFileFlag: "--field-file",
@@ -89,7 +108,10 @@ export function registerCreate(program: Command): void {
 				});
 				assertSingleStdinSource(explicitStdinSources);
 
-				const textInputs = await resolveItemTextInputs(localOpts, stdin);
+				const textInputs = await resolveItemTextInputs(localOpts, stdin, () =>
+					generateSecret({ length: localOpts.generateLength }),
+				);
+				generated = textInputs.passwordGenerated ?? false;
 				let notes = textInputs.notes;
 
 				// Backward compatibility: piped create input becomes note content.
@@ -119,7 +141,9 @@ export function registerCreate(program: Command): void {
 					password: textInputs.password ?? null,
 					uris: localOpts.uri,
 					fields,
-					folderId: localOpts.folder ?? null,
+					folderId: localOpts.folder
+						? await resolveFolderRef(localOpts.folder, opts)
+						: null,
 					favorite: localOpts.favorite ?? false,
 				});
 
@@ -132,11 +156,33 @@ export function registerCreate(program: Command): void {
 
 			const created = JSON.parse(result);
 			if (opts.json) {
-				emitData(created, opts);
+				emitData(redactGeneratedPassword(created, generated), opts);
 			} else if (opts.plain) {
 				emitData(created.id, opts);
 			} else {
-				emitSuccess(`Created "${created.name}" (${created.id})`, opts);
+				const note = generated ? " — password generated (not printed)" : "";
+				emitSuccess(`Created "${created.name}" (${created.id})${note}`, opts);
 			}
 		});
 }
+
+/**
+ * A secure note has no login object, so `buildNewItem` drops usernames,
+ * passwords, and URIs on the floor. Accepting them silently means a caller can
+ * "store" a credential, get exit 0, and end up with an item that never held it.
+ */
+function assertLoginFlags(localOpts: CreateOptions): void {
+	if (localOpts.type === "login") return;
+
+	const used = LOGIN_ONLY_FLAGS.filter(([key]) => Boolean(localOpts[key])).map(
+		([, flag]) => flag,
+	);
+	if (localOpts.uri.length > 0) used.push("--uri");
+
+	if (used.length > 0) {
+		throw new CliError(
+			`${used.join(", ")} ${used.length > 1 ? "need" : "needs"} --type login (a note cannot store them).`,
+			ExitCode.BadArgs,
+		);
+	}
+}

package/src/cli/commands/delete.ts

@@ -4,6 +4,8 @@ import { emitData, emitSuccess } from "../io.ts";
 import { CliError, ExitCode } from "../errors.ts";
 import { runBwOrThrow } from "../../bw/runner.ts";
 import { withSession } from "../../bw/session.ts";
+import { readLine } from "../input.ts";
+import type { GlobalOptions } from "../types.ts";
 import pc from "picocolors";
 
 export function registerDelete(program: Command): void {
@@ -12,7 +14,7 @@ export function registerDelete(program: Command): void {
 		.description("Delete a vault item")
 		.argument("<item>", "Item name or ID")
 		.option("--permanent", "Permanently delete (no trash)")
-		.option("--force", "Skip confirmation prompt")
+		.option("--force", "Skip confirmation prompt (required when not interactive)")
 		.action(async function (
 			this: Command,
 			item: string,
@@ -28,17 +30,7 @@ export function registerDelete(program: Command): void {
 			const itemId: string = current.id;
 			const itemName: string = current.name;
 
-			// Confirm unless --force, --json, or --plain
-			if (!localOpts.force && !opts.json && !opts.plain && process.stdin.isTTY) {
-				const label = localOpts.permanent ? "permanently delete" : "delete";
-				process.stderr.write(
-					`${pc.yellow("?")} ${label} "${itemName}" (${itemId})? [y/N] `,
-				);
-				const answer = await readLine();
-				if (answer.toLowerCase() !== "y") {
-					throw new CliError("Cancelled", ExitCode.UserCancelled);
-				}
-			}
+			await confirmDelete(itemName, itemId, localOpts, opts);
 
 			const args = ["delete", "item", itemId];
 			if (localOpts.permanent) args.push("--permanent");
@@ -46,22 +38,57 @@ export function registerDelete(program: Command): void {
 			await withSession(opts, () => runBwOrThrow(args));
 
 			if (opts.json) {
-				emitData({ id: itemId, name: itemName, deleted: true }, opts);
+				emitData(
+					{
+						id: itemId,
+						name: itemName,
+						deleted: true,
+						permanent: localOpts.permanent ?? false,
+					},
+					opts,
+				);
 			} else if (opts.plain) {
 				emitData(itemId, opts);
 			} else {
 				const label = localOpts.permanent ? "Permanently deleted" : "Deleted";
-				emitSuccess(`${label} "${itemName}" (${itemId})`, opts);
+				const undo = localOpts.permanent
+					? ""
+					: ` — undo with ${pc.dim(`bwx restore ${itemId}`)}`;
+				emitSuccess(`${label} "${itemName}" (${itemId})${undo}`, opts);
 			}
 		});
+
 }
 
-async function readLine(): Promise<string> {
-	const chunks: Uint8Array[] = [];
-	for await (const chunk of Bun.stdin.stream()) {
-		chunks.push(chunk);
-		const text = Buffer.concat(chunks).toString();
-		if (text.includes("\n")) return text.split("\n")[0]!.trim();
+/**
+ * A prompt only guards a human at a terminal. The common caller here is a script
+ * or an agent, where the prompt never renders — so anything non-interactive must
+ * say `--force` out loud instead of being deleted on the strength of a flag that
+ * silently did nothing.
+ */
+async function confirmDelete(
+	itemName: string,
+	itemId: string,
+	localOpts: { permanent?: boolean; force?: boolean },
+	opts: GlobalOptions,
+): Promise<void> {
+	if (localOpts.force) return;
+
+	const interactive = process.stdin.isTTY && !opts.json && !opts.plain;
+	const label = localOpts.permanent ? "permanently delete" : "delete";
+
+	if (!interactive) {
+		throw new CliError(
+			`Refusing to ${label} "${itemName}" (${itemId}) without confirmation. Pass --force.`,
+			ExitCode.BadArgs,
+		);
+	}
+
+	process.stderr.write(
+		`${pc.yellow("?")} ${label} "${itemName}" (${itemId})? [y/N] `,
+	);
+	const answer = await readLine();
+	if (answer.toLowerCase() !== "y") {
+		throw new CliError("Cancelled", ExitCode.UserCancelled);
 	}
-	return Buffer.concat(chunks).toString().trim();
 }

package/src/cli/commands/edit.ts

@@ -5,6 +5,9 @@ import { CliError, ExitCode } from "../errors.ts";
 import { runBwOrThrow } from "../../bw/runner.ts";
 import { withSession } from "../../bw/session.ts";
 import { patchItem, bwEncode } from "../../bw/encoding.ts";
+import { generateSecret } from "../../bw/generate.ts";
+import { resolveFolderRef } from "../../bw/folders.ts";
+import { BwItemType } from "../../bw/types.ts";
 import {
 	assertSingleStdinSource,
 	collect,
@@ -14,6 +17,7 @@ import {
 	StdinReader,
 	type ItemTextInputs,
 } from "../input.ts";
+import { redactGeneratedPassword } from "./generate.ts";
 
 interface EditOptions extends ItemTextInputs {
 	name?: string;
@@ -26,8 +30,18 @@ interface EditOptions extends ItemTextInputs {
 	folder?: string;
 	favorite?: boolean;
 	fromJson?: boolean;
+	generateLength?: number;
 }
 
+const LOGIN_ONLY_FLAGS: Array<[keyof EditOptions, string]> = [
+	["username", "--username"],
+	["password", "--password"],
+	["passwordStdin", "--password-stdin"],
+	["passwordFile", "--password-file"],
+	["passwordEnv", "--password-env"],
+	["passwordGenerate", "--password-generate"],
+];
+
 export function registerEdit(program: Command): void {
 	program
 		.command("edit")
@@ -41,12 +55,14 @@ export function registerEdit(program: Command): void {
 		.option("--password-stdin", "Read password from stdin")
 		.option("--password-file <path>", "Read password from file (use - for stdin)")
 		.option("--password-env <name>", "Read password from environment variable")
+		.option("--password-generate", "Generate the password; it is never printed")
+		.option("--generate-length <n>", "Length for --password-generate", parseInt)
 		.option("--uri <url>", "Set URIs (repeatable, replaces all)", collect, [])
 		.option("--add-field <kv>", "Add/update field k=v", collect, [])
 		.option("--add-field-file <kv>", "Add/update field value from file k=path", collect, [])
 		.option("--add-field-env <kv>", "Add/update field value from env var k=ENV", collect, [])
 		.option("--rm-field <name>", "Remove field by name", collect, [])
-		.option("--folder <id>", "Move to folder")
+		.option("--folder <name|id>", "Move to folder ('none' to unfile)")
 		.option("--favorite", "Set favorite")
 		.option("--no-favorite", "Unset favorite")
 		.option("--from-json", "Read full item JSON from stdin (replaces item)")
@@ -57,6 +73,7 @@ export function registerEdit(program: Command): void {
 		) {
 			const opts = getGlobalOpts(this);
 			const stdin = new StdinReader();
+			let generated = false;
 
 			const result = await withSession(opts, async () => {
 				// Fetch current item
@@ -73,6 +90,8 @@ export function registerEdit(program: Command): void {
 					}
 					encoded = bwEncode(stdinText);
 				} else {
+					assertLoginFlags(localOpts, current);
+
 					assertSingleStdinSource(
 						listExplicitStdinInputs({
 							...localOpts,
@@ -81,7 +100,10 @@ export function registerEdit(program: Command): void {
 						}),
 					);
 
-					const textInputs = await resolveItemTextInputs(localOpts, stdin);
+					const textInputs = await resolveItemTextInputs(localOpts, stdin, () =>
+						generateSecret({ length: localOpts.generateLength }),
+					);
+					generated = textInputs.passwordGenerated ?? false;
 
 					const addFields = await resolveFieldSources({
 						inline: localOpts.addField,
@@ -100,7 +122,9 @@ export function registerEdit(program: Command): void {
 						uris: localOpts.uri.length > 0 ? localOpts.uri : undefined,
 						addFields,
 						rmFields: localOpts.rmField,
-						folderId: localOpts.folder,
+						folderId: localOpts.folder
+							? await resolveFolderRef(localOpts.folder, opts)
+							: undefined,
 						favorite: localOpts.favorite,
 					});
 					encoded = bwEncode(JSON.stringify(patched));
@@ -111,11 +135,35 @@ export function registerEdit(program: Command): void {
 
 			const updated = JSON.parse(result);
 			if (opts.json) {
-				emitData(updated, opts);
+				emitData(redactGeneratedPassword(updated, generated), opts);
 			} else if (opts.plain) {
 				emitData(updated.id, opts);
 			} else {
-				emitSuccess(`Updated "${updated.name}" (${updated.id})`, opts);
+				const note = generated ? " — password generated (not printed)" : "";
+				emitSuccess(`Updated "${updated.name}" (${updated.id})${note}`, opts);
 			}
 		});
 }
+
+/**
+ * Same trap as `create`: only a login item has somewhere to put a password, so
+ * setting one on a note would be accepted and then quietly lost.
+ */
+function assertLoginFlags(
+	localOpts: EditOptions,
+	current: Record<string, unknown>,
+): void {
+	if (current.type === BwItemType.Login) return;
+
+	const used = LOGIN_ONLY_FLAGS.filter(([key]) => Boolean(localOpts[key])).map(
+		([, flag]) => flag,
+	);
+	if (localOpts.uri.length > 0) used.push("--uri");
+
+	if (used.length === 0) return;
+
+	throw new CliError(
+		`${used.join(", ")} ${used.length > 1 ? "need" : "needs"} a login item, but "${String(current.name)}" is not one.`,
+		ExitCode.BadArgs,
+	);
+}

package/src/cli/commands/folders.ts

@@ -0,0 +1,34 @@
+import type { Command } from "commander";
+import pc from "picocolors";
+import { listFolders } from "../../bw/folders.ts";
+import { emitData } from "../io.ts";
+import { getGlobalOpts } from "../program.ts";
+
+/**
+ * Folder IDs are the only handle `--folder` used to accept, and nothing else in
+ * bwx ever printed one — so this is what makes that flag usable at all.
+ */
+export function registerFolders(program: Command): void {
+	program
+		.command("folders")
+		.alias("folder")
+		.description("List vault folders")
+		.action(async function (this: Command) {
+			const opts = getGlobalOpts(this);
+			const folders = await listFolders(opts);
+
+			if (opts.json) {
+				emitData(folders, opts);
+				return;
+			}
+
+			for (const folder of folders) {
+				const id = folder.id ?? "-";
+				process.stdout.write(
+					opts.plain
+						? `${id}\t${folder.name}\n`
+						: `${pc.dim(id)}  ${folder.name}\n`,
+				);
+			}
+		});
+}