wrangler 2.1.14 → 2.2.0

package/miniflare-dist/index.mjs

@@ -5592,6 +5592,7 @@ function createMetadataObject({
   headers,
   webAnalyticsToken,
   deploymentId,
+  failOpen,
   logger = (_message) => {
   }
 }) {
@@ -5599,7 +5600,8 @@ function createMetadataObject({
     ...constructRedirects({ redirects, logger }),
     ...constructHeaders({ headers, logger }),
     ...constructWebAnalytics({ webAnalyticsToken, logger }),
-    deploymentId
+    deploymentId,
+    failOpen
   };
 }
 function constructRedirects({

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wrangler",
-	"version": "2.1.14",
+	"version": "2.2.0",
 	"description": "Command-line interface for all things Cloudflare Workers",
 	"keywords": [
 		"wrangler",
@@ -160,6 +160,7 @@
 		"jest-fetch-mock": "^3.0.3",
 		"jest-websocket-mock": "^2.3.0",
 		"mime": "^3.0.0",
+		"minimatch": "^5.1.0",
 		"msw": "^0.47.1",
 		"npx-import": "^1.1.3",
 		"open": "^8.4.0",

package/src/__tests__/access.test.ts

@@ -0,0 +1,25 @@
+import { domainUsesAccess, getAccessToken } from "../user/access";
+import { msw, mswAccessHandlers } from "./helpers/msw";
+
+describe("access", () => {
+	beforeEach(() => {
+		msw.use(...mswAccessHandlers);
+	});
+
+	describe("basic", () => {
+		it("should correctly detect an access protected domain", async () => {
+			expect(await domainUsesAccess("access-protected.com")).toBeTruthy();
+			expect(await domainUsesAccess("not-access-protected.com")).toBeFalsy();
+		});
+		it("should not fail without cloudflared installed", async () => {
+			expect(await getAccessToken("not-access-protected.com")).toBeFalsy();
+		});
+		it("should error without cloudflared installed on an access protected domain", async () => {
+			await expect(getAccessToken("access-protected.com")).rejects.toEqual(
+				new Error(
+					"To use Wrangler with Cloudflare Access, please install `cloudflared` from https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/install-and-setup/installation"
+				)
+			);
+		});
+	});
+});

package/src/__tests__/api-dev.test.ts

@@ -5,7 +5,7 @@ import { runInTempDir } from "./helpers/run-in-tmp";
 
 jest.unmock("undici");
 
-describe("unstable_dev", () => {
+describe.skip("unstable_dev", () => {
 	it("should return Hello World", async () => {
 		const worker = await unstable_dev(
 			"src/__tests__/helpers/worker-scripts/hello-world-worker.js",

package/src/__tests__/api-devregistry.test.js

@@ -1,13 +1,13 @@
 import { unstable_dev } from "../api";
 import { fetch } from "undici";
 
-jest.unmock("undici");
+// jest.unmock("undici");
 
 /**
  * a huge caveat to how testing multi-worker scripts works:
  * you can't shutdown the first worker you spun up, or it'll kill the devRegistry
  */
-describe("multi-worker testing", () => {
+describe.skip("multi-worker testing", () => {
 	let childWorker;
 	let parentWorker;
 

package/src/__tests__/configuration.test.ts

@@ -49,6 +49,10 @@ describe("normalizeAndValidateConfig()", () => {
 			main: undefined,
 			migrations: [],
 			name: undefined,
+			queues: {
+				consumers: [],
+				producers: [],
+			},
 			r2_buckets: [],
 			services: [],
 			route: undefined,
@@ -75,6 +79,7 @@ describe("normalizeAndValidateConfig()", () => {
 			node_compat: undefined,
 			first_party_worker: undefined,
 			keep_vars: undefined,
+			logpush: undefined,
 		});
 		expect(diagnostics.hasErrors()).toBe(false);
 		expect(diagnostics.hasWarnings()).toBe(false);
@@ -924,6 +929,7 @@ describe("normalizeAndValidateConfig()", () => {
 				minify: true,
 				node_compat: true,
 				first_party_worker: true,
+				logpush: true,
 			};
 
 			const { config, diagnostics } = normalizeAndValidateConfig(
@@ -998,6 +1004,7 @@ describe("normalizeAndValidateConfig()", () => {
 				minify: "INVALID",
 				node_compat: "INVALID",
 				first_party_worker: "INVALID",
+				logpush: "INVALID",
 			} as unknown as RawEnvironment;
 
 			const { config, diagnostics } = normalizeAndValidateConfig(
@@ -1065,7 +1072,8 @@ describe("normalizeAndValidateConfig()", () => {
 			  - Expected \\"no_bundle\\" to be of type boolean but got \\"INVALID\\".
 			  - Expected \\"minify\\" to be of type boolean but got \\"INVALID\\".
 			  - Expected \\"node_compat\\" to be of type boolean but got \\"INVALID\\".
-			  - Expected \\"first_party_worker\\" to be of type boolean but got \\"INVALID\\"."
+			  - Expected \\"first_party_worker\\" to be of type boolean but got \\"INVALID\\".
+			  - Expected \\"logpush\\" to be of type boolean but got \\"INVALID\\"."
 		`);
 		});
 
@@ -1698,6 +1706,110 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 		});
 
+		describe("[queues]", () => {
+			it("should error if queues is not an object", () => {
+				const { config, diagnostics } = normalizeAndValidateConfig(
+					{ queues: [] } as unknown as RawConfig,
+					undefined,
+					{ env: undefined }
+				);
+
+				expect(config).toEqual(
+					expect.not.objectContaining({ queues: expect.anything })
+				);
+				expect(diagnostics.hasWarnings()).toBe(false);
+				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+			                  "Processing wrangler configuration:
+			                    - The field \\"queues\\" should be an object but got []."
+		              `);
+			});
+
+			it("should error if queues producer bindings are not valid", () => {
+				const { config, diagnostics } = normalizeAndValidateConfig(
+					{
+						queues: {
+							invalidField: "madeupValue",
+							producers: [
+								{},
+								{ binding: "QUEUE_BINDING_1" },
+								{ binding: 2333, queue: 2444 },
+								{ binding: "QUEUE_BINDING_3", queue: "" },
+							],
+						},
+					} as unknown as RawConfig,
+					undefined,
+					{ env: undefined }
+				);
+
+				expect(config).toEqual(
+					expect.not.objectContaining({
+						queues: { producers: expect.anything },
+					})
+				);
+				expect(diagnostics.hasWarnings()).toBe(true);
+				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
+					"Processing wrangler configuration:
+					  - Unexpected fields found in queues field: \\"invalidField\\""
+				`);
+
+				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+					"Processing wrangler configuration:
+					  - \\"queues.producers[0]\\" bindings should have a string \\"binding\\" field but got {}.
+					  - \\"queues.producers[0]\\" bindings should have a string \\"queue\\" field but got {}.
+					  - \\"queues.producers[1]\\" bindings should have a string \\"queue\\" field but got {\\"binding\\":\\"QUEUE_BINDING_1\\"}.
+					  - \\"queues.producers[2]\\" bindings should have a string \\"binding\\" field but got {\\"binding\\":2333,\\"queue\\":2444}.
+					  - \\"queues.producers[2]\\" bindings should have a string \\"queue\\" field but got {\\"binding\\":2333,\\"queue\\":2444}.
+					  - \\"queues.producers[3]\\" bindings should have a string \\"queue\\" field but got {\\"binding\\":\\"QUEUE_BINDING_3\\",\\"queue\\":\\"\\"}."
+				`);
+			});
+
+			it("should error if queues consumers are not valid", () => {
+				const { config, diagnostics } = normalizeAndValidateConfig(
+					{
+						queues: {
+							invalidField: "madeupValue",
+							consumers: [
+								{},
+								{ queue: 22 },
+								{ queue: "myQueue", invalidField: "madeupValue" },
+								{
+									queue: "myQueue",
+									max_batch_size: "3",
+									max_batch_timeout: null,
+									max_retries: "hello",
+									dead_letter_queue: 5,
+								},
+							],
+						},
+					} as unknown as RawConfig,
+					undefined,
+					{ env: undefined }
+				);
+
+				expect(config).toEqual(
+					expect.not.objectContaining({
+						queues: { producers: expect.anything },
+					})
+				);
+				expect(diagnostics.hasWarnings()).toBe(true);
+				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
+					"Processing wrangler configuration:
+					  - Unexpected fields found in queues field: \\"invalidField\\"
+					  - Unexpected fields found in queues.consumers[2] field: \\"invalidField\\""
+				`);
+
+				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+					"Processing wrangler configuration:
+					  - \\"queues.consumers[0]\\" should have a string \\"queue\\" field but got {}.
+					  - \\"queues.consumers[1]\\" should have a string \\"queue\\" field but got {\\"queue\\":22}.
+					  - \\"queues.consumers[3]\\" should, optionally, have a number \\"max_batch_size\\" field but got {\\"queue\\":\\"myQueue\\",\\"max_batch_size\\":\\"3\\",\\"max_batch_timeout\\":null,\\"max_retries\\":\\"hello\\",\\"dead_letter_queue\\":5}.
+					  - \\"queues.consumers[3]\\" should, optionally, have a number \\"max_batch_timeout\\" field but got {\\"queue\\":\\"myQueue\\",\\"max_batch_size\\":\\"3\\",\\"max_batch_timeout\\":null,\\"max_retries\\":\\"hello\\",\\"dead_letter_queue\\":5}.
+					  - \\"queues.consumers[3]\\" should, optionally, have a number \\"max_retries\\" field but got {\\"queue\\":\\"myQueue\\",\\"max_batch_size\\":\\"3\\",\\"max_batch_timeout\\":null,\\"max_retries\\":\\"hello\\",\\"dead_letter_queue\\":5}.
+					  - \\"queues.consumers[3]\\" should, optionally, have a string \\"dead_letter_queue\\" field but got {\\"queue\\":\\"myQueue\\",\\"max_batch_size\\":\\"3\\",\\"max_batch_timeout\\":null,\\"max_retries\\":\\"hello\\",\\"dead_letter_queue\\":5}."
+				`);
+			});
+		});
+
 		describe("[r2_buckets]", () => {
 			it("should error if r2_buckets is an object", () => {
 				const { diagnostics } = normalizeAndValidateConfig(
@@ -2332,6 +2444,7 @@ describe("normalizeAndValidateConfig()", () => {
 				minify: true,
 				node_compat: true,
 				first_party_worker: true,
+				logpush: true,
 			};
 
 			const { config, diagnostics } = normalizeAndValidateConfig(
@@ -2376,6 +2489,7 @@ describe("normalizeAndValidateConfig()", () => {
 				minify: false,
 				node_compat: false,
 				first_party_worker: false,
+				logpush: false,
 			};
 			const rawConfig: RawConfig = {
 				name: "mock-name",
@@ -2399,6 +2513,7 @@ describe("normalizeAndValidateConfig()", () => {
 				minify: true,
 				node_compat: true,
 				first_party_worker: true,
+				logpush: true,
 				env: {
 					ENV1: rawEnv,
 				},
@@ -2661,6 +2776,7 @@ describe("normalizeAndValidateConfig()", () => {
 				minify: "INVALID",
 				node_compat: "INVALID",
 				first_party_worker: "INVALID",
+				logpush: "INVALID",
 			} as unknown as RawEnvironment;
 
 			const { config, diagnostics } = normalizeAndValidateConfig(
@@ -2697,7 +2813,8 @@ describe("normalizeAndValidateConfig()", () => {
 			    - Expected \\"no_bundle\\" to be of type boolean but got \\"INVALID\\".
 			    - Expected \\"minify\\" to be of type boolean but got \\"INVALID\\".
 			    - Expected \\"node_compat\\" to be of type boolean but got \\"INVALID\\".
-			    - Expected \\"first_party_worker\\" to be of type boolean but got \\"INVALID\\"."
+			    - Expected \\"first_party_worker\\" to be of type boolean but got \\"INVALID\\".
+			    - Expected \\"logpush\\" to be of type boolean but got \\"INVALID\\"."
 		`);
 		});
 

package/src/__tests__/d1.test.ts

@@ -29,6 +29,7 @@ describe("d1", () => {
 
 		Flags:
 		  -c, --config   Path to .toml configuration file  [string]
+		  -e, --env      Environment to use for operations and .env files  [string]
 		  -h, --help     Show help  [boolean]
 		  -v, --version  Show version number  [boolean]
 
@@ -61,6 +62,7 @@ describe("d1", () => {
 
 		Flags:
 		  -c, --config   Path to .toml configuration file  [string]
+		  -e, --env      Environment to use for operations and .env files  [string]
 		  -h, --help     Show help  [boolean]
 		  -v, --version  Show version number  [boolean]
 

package/src/__tests__/deployments.test.ts

@@ -54,38 +54,38 @@ describe("deployments", () => {
 	it("should log deployments", async () => {
 		await runWrangler("deployments");
 		expect(std.out).toMatchInlineSnapshot(`
-		"
-		Version ID: Galaxy-Class
-		Version number: 1701-E
-		Created on: 2021-01-01T00:00:00.000000Z
-		Author email: Jean-Luc-Picard@federation.org
-		Latest deploy: true
+		"🚧\`wrangler deployments\` is a beta command. Please report any issues to https://github.com/cloudflare/wrangler2/issues/new/choose
+
 
-		Version ID: Intrepid-Class
-		Version number: NCC-74656
+		Deployment ID: Intrepid-Class
 		Created on: 2021-02-02T00:00:00.000000Z
-		Author email: Kathryn-Janeway@federation.org
-		Latest deploy: false
-		"
+		Author: Kathryn-Janeway@federation.org
+		Source: Wrangler
+
+		Deployment ID: Galaxy-Class
+		Created on: 2021-01-01T00:00:00.000000Z
+		Author: Jean-Luc-Picard@federation.org
+		Source: Wrangler
+		🟩Active"
 	`);
 	});
 
 	it("should log deployments for script with passed in name option", async () => {
 		await runWrangler("deployments --name somethingElse");
 		expect(std.out).toMatchInlineSnapshot(`
-		"
-		Version ID: Galaxy-Class
-		Version number: 1701-E
-		Created on: 2021-01-01T00:00:00.000000Z
-		Author email: Jean-Luc-Picard@federation.org
-		Latest deploy: true
+		"🚧\`wrangler deployments\` is a beta command. Please report any issues to https://github.com/cloudflare/wrangler2/issues/new/choose
+
 
-		Version ID: Intrepid-Class
-		Version number: NCC-74656
+		Deployment ID: Intrepid-Class
 		Created on: 2021-02-02T00:00:00.000000Z
-		Author email: Kathryn-Janeway@federation.org
-		Latest deploy: false
-		"
+		Author: Kathryn-Janeway@federation.org
+		Source: Wrangler
+
+		Deployment ID: Galaxy-Class
+		Created on: 2021-01-01T00:00:00.000000Z
+		Author: Jean-Luc-Picard@federation.org
+		Source: Wrangler
+		🟩Active"
 	`);
 	});
 });

package/src/__tests__/dev.test.tsx

@@ -3,14 +3,31 @@ import getPort from "get-port";
 import patchConsole from "patch-console";
 import dedent from "ts-dedent";
 import Dev from "../dev/dev";
+import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
 import { setMockResponse, unsetAllMocks } from "./helpers/mock-cfetch";
 import { mockConsoleMethods } from "./helpers/mock-console";
+import {
+	msw,
+	mswSuccessOauthHandlers,
+	mswSuccessUserHandlers,
+	mswZoneHandlers,
+} from "./helpers/msw";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
 import writeWranglerToml from "./helpers/write-wrangler-toml";
 
 describe("wrangler dev", () => {
+	beforeEach(() => {
+		msw.use(
+			...mswZoneHandlers,
+			...mswSuccessOauthHandlers,
+			...mswSuccessUserHandlers
+		);
+	});
+
 	runInTempDir();
+	mockAccountId();
+	mockApiToken();
 	const std = mockConsoleMethods();
 	afterEach(() => {
 		(Dev as jest.Mock).mockClear();
@@ -319,6 +336,87 @@ describe("wrangler dev", () => {
 			);
 		});
 
+		it("should find the host from the given pattern, not zone_name", async () => {
+			writeWranglerToml({
+				main: "index.js",
+				routes: [
+					{
+						pattern: "https://subdomain.exists.com/*",
+						zone_name: "does-not-exist.com",
+					},
+				],
+			});
+			await fs.promises.writeFile("index.js", `export default {};`);
+			await runWrangler("dev");
+			expect(std.out).toMatchInlineSnapshot(`""`);
+			expect(std.err).toMatchInlineSnapshot(`""`);
+		});
+
+		it("should fail for non-existing zones", async () => {
+			writeWranglerToml({
+				main: "index.js",
+				routes: [
+					{
+						pattern: "https://subdomain.does-not-exist.com/*",
+						zone_name: "exists.com",
+					},
+				],
+			});
+			await fs.promises.writeFile("index.js", `export default {};`);
+			await expect(runWrangler("dev")).rejects.toEqual(
+				new Error("Could not find zone for subdomain.does-not-exist.com")
+			);
+		});
+
+		it("should fail for non-existing zones, when falling back from */*", async () => {
+			writeWranglerToml({
+				main: "index.js",
+				routes: [
+					{
+						pattern: "*/*",
+						zone_name: "does-not-exist.com",
+					},
+				],
+			});
+			await fs.promises.writeFile("index.js", `export default {};`);
+			await expect(runWrangler("dev")).rejects.toEqual(
+				new Error("Could not find zone for does-not-exist.com")
+			);
+		});
+
+		it("should fallback to zone_name when given the pattern */*", async () => {
+			writeWranglerToml({
+				main: "index.js",
+				routes: [
+					{
+						pattern: "*/*",
+						zone_name: "exists.com",
+					},
+				],
+			});
+			await fs.promises.writeFile("index.js", `export default {};`);
+			await runWrangler("dev");
+			expect(std.out).toMatchInlineSnapshot(`""`);
+			expect(std.err).toMatchInlineSnapshot(`""`);
+		});
+		it("fails when given the pattern */* and no zone_name", async () => {
+			writeWranglerToml({
+				main: "index.js",
+				routes: [
+					{
+						pattern: "*/*",
+						zone_id: "exists-com",
+					},
+				],
+			});
+			await fs.promises.writeFile("index.js", `export default {};`);
+			const err = new TypeError() as unknown as { code: string; input: string };
+			err.code = "ERR_INVALID_URL";
+			err.input = "http:///";
+
+			await expect(runWrangler("dev")).rejects.toEqual(err);
+		});
+
 		it("given a long host, it should use the longest subdomain that resolves to a zone", async () => {
 			writeWranglerToml({
 				main: "index.js",
@@ -566,6 +664,40 @@ describe("wrangler dev", () => {
 		      `);
 			expect(std.warn).toMatchInlineSnapshot(`""`);
 		});
+
+		describe(".env", () => {
+			beforeEach(() => {
+				fs.writeFileSync(".env", "CUSTOM_BUILD_VAR=default");
+				fs.writeFileSync(".env.custom", "CUSTOM_BUILD_VAR=custom");
+				fs.writeFileSync("index.js", `export default {};`);
+				writeWranglerToml({
+					main: "index.js",
+					env: { custom: {} },
+					build: {
+						// Ideally, we'd just log the var here and match it in `std.out`,
+						// but stdout from custom builds is piped directly to
+						// `process.stdout` which we don't capture.
+						command: `node -e "require('fs').writeFileSync('var.txt', process.env.CUSTOM_BUILD_VAR)"`,
+					},
+				});
+
+				// We won't overwrite existing process.env keys with .env values (to
+				// allow .env overrides to specified on then shell), so make sure this
+				// key definitely doesn't exist.
+				delete process.env.CUSTOM_BUILD_VAR;
+			});
+
+			it("should load environment variables from `.env`", async () => {
+				await runWrangler("dev");
+				const output = fs.readFileSync("var.txt", "utf8");
+				expect(output).toMatch("default");
+			});
+			it("should prefer to load environment variables from `.env.<environment>` if `--env <environment>` is set", async () => {
+				await runWrangler("dev --env custom");
+				const output = fs.readFileSync("var.txt", "utf8");
+				expect(output).toMatch("custom");
+			});
+		});
 	});
 
 	describe("upstream-protocol", () => {
@@ -970,6 +1102,27 @@ describe("wrangler dev", () => {
 			expect(std.warn).toMatchInlineSnapshot(`""`);
 			expect(std.err).toMatchInlineSnapshot(`""`);
 		});
+
+		it("should prefer `.dev.vars.<environment>` if `--env <environment> set`", async () => {
+			fs.writeFileSync("index.js", `export default {};`);
+			fs.writeFileSync(".dev.vars", "DEFAULT_VAR=default");
+			fs.writeFileSync(".dev.vars.custom", "CUSTOM_VAR=custom");
+
+			writeWranglerToml({ main: "index.js", env: { custom: {} } });
+			await runWrangler("dev --env custom");
+			const varBindings: Record<string, unknown> = (Dev as jest.Mock).mock
+				.calls[0][0].bindings.vars;
+
+			expect(varBindings).toEqual({ CUSTOM_VAR: "custom" });
+			expect(std.out).toMatchInlineSnapshot(`
+			        "Using vars defined in .dev.vars.custom
+			        Your worker has access to the following bindings:
+			        - Vars:
+			          - CUSTOM_VAR: \\"(hidden)\\""
+		      `);
+			expect(std.warn).toMatchInlineSnapshot(`""`);
+			expect(std.err).toMatchInlineSnapshot(`""`);
+		});
 	});
 
 	describe("serve static assets", () => {
@@ -996,13 +1149,13 @@ describe("wrangler dev", () => {
 
 			Flags:
 			  -c, --config   Path to .toml configuration file  [string]
+			  -e, --env      Environment to use for operations and .env files  [string]
 			  -h, --help     Show help  [boolean]
 			  -v, --version  Show version number  [boolean]
 
 			Options:
 			      --name                                       Name of the worker  [string]
 			      --no-bundle                                  Skip internal build steps and directly publish script  [boolean] [default: false]
-			  -e, --env                                        Perform on a specific environment  [string]
 			      --compatibility-date                         Date to use for compatibility checks  [string]
 			      --compatibility-flags, --compatibility-flag  Flags to use for compatibility checks  [array]
 			      --latest                                     Use the latest version of the worker runtime  [boolean] [default: true]
@@ -1259,24 +1412,23 @@ describe("wrangler dev", () => {
 			});
 			fs.writeFileSync("index.js", `export default {};`);
 			await runWrangler("dev index.js");
-			expect(std).toMatchInlineSnapshot(`
-			        Object {
-			          "debug": "",
-			          "err": "",
-			          "out": "Your worker has access to the following bindings:
-			        - Services:
-			          - WorkerA: A
-			          - WorkerB: B - staging",
-			          "warn": "▲ [WARNING] Processing wrangler.toml configuration:
+			expect(std.out).toMatchInlineSnapshot(`
+			"Your worker has access to the following bindings:
+			- Services:
+			  - WorkerA: A
+			  - WorkerB: B - staging"
+		`);
+			expect(std.warn).toMatchInlineSnapshot(`
+			"▲ [WARNING] Processing wrangler.toml configuration:
 
-			            - \\"services\\" fields are experimental and may change or break at any time.
+			    - \\"services\\" fields are experimental and may change or break at any time.
 
 
-			        ▲ [WARNING] This worker is bound to live services: WorkerA (A), WorkerB (B@staging)
+			▲ [WARNING] This worker is bound to live services: WorkerA (A), WorkerB (B@staging)
 
-			        ",
-			        }
-		      `);
+			"
+		`);
+			expect(std.err).toMatchInlineSnapshot(`""`);
 		});
 	});
 

package/src/__tests__/helpers/msw/handlers/access.ts

@@ -0,0 +1,13 @@
+import { rest } from "msw";
+
+export default [
+	rest.get("*access-protected.com*", (_, response, cxt) => {
+		return response.once(
+			cxt.status(302),
+			cxt.set("location", "access-protected-com.cloudflareaccess.com")
+		);
+	}),
+	rest.get("*not-access-protected.com*", (_, response, cxt) => {
+		return response.once(cxt.status(200), cxt.body("OK"));
+	}),
+];