@cloudflare/pages-shared 0.13.11 → 0.13.13

package/asset-server/handler.ts

@@ -1,3 +1,7 @@
+import {
+	generateRulesMatcher,
+	replacer,
+} from "@cloudflare/workers-shared/asset-worker/src/utils/rules-engine";
 import {
 	FoundResponse,
 	InternalServerErrorResponse,
@@ -11,7 +15,6 @@ import {
 	SeeOtherResponse,
 	TemporaryRedirectResponse,
 } from "./responses";
-import { generateRulesMatcher, replacer } from "./rulesEngine";
 import type {
 	Metadata,
 	MetadataHeadersEntries,

package/metadata-generator/createMetadataObject.ts

@@ -1,20 +1,14 @@
-import { relative } from "node:path";
 import {
-	ANALYTICS_VERSION,
-	HEADERS_VERSION,
-	PLACEHOLDER_REGEX,
-	REDIRECTS_VERSION,
-	SPLAT_REGEX,
-} from "./constants";
-import type { MetadataStaticRedirects } from "../asset-server/metadata";
+	constructHeaders,
+	constructRedirects,
+} from "@cloudflare/workers-shared/utils/configuration/constructConfiguration";
+import { ANALYTICS_VERSION } from "./constants";
+import type { Metadata } from "./types";
 import type {
 	Logger,
-	Metadata,
-	MetadataHeaders,
-	MetadataRedirects,
 	ParsedHeaders,
 	ParsedRedirects,
-} from "./types";
+} from "@cloudflare/workers-shared/utils/configuration/types";
 
 const noopLogger = {
 	debug: (_message: string) => {},
@@ -52,154 +46,6 @@ export function createMetadataObject({
 	};
 }
 
-function constructRedirects({
-	redirects,
-	redirectsFile,
-	logger,
-}: {
-	redirects?: ParsedRedirects;
-	redirectsFile?: string;
-	logger: Logger;
-}): Metadata {
-	if (!redirects) {
-		return {};
-	}
-
-	const num_valid = redirects.rules.length;
-	const num_invalid = redirects.invalid.length;
-
-	// exhaustive check, since we could not have parsed `redirects` out of
-	// a non-existing redirects file
-	const redirectsRelativePath = redirectsFile
-		? relative(process.cwd(), redirectsFile)
-		: "";
-
-	logger.log(
-		`✨ Parsed ${num_valid} valid redirect rule${num_valid === 1 ? "" : "s"}.`
-	);
-
-	if (num_invalid > 0) {
-		let invalidRedirectRulesList = ``;
-
-		for (const { line, lineNumber, message } of redirects.invalid) {
-			invalidRedirectRulesList += `▶︎ ${message}\n`;
-
-			if (line) {
-				invalidRedirectRulesList += `    at ${redirectsRelativePath}${lineNumber ? `:${lineNumber}` : ""} | ${line}\n\n`;
-			}
-		}
-
-		logger.warn(
-			`Found ${num_invalid} invalid redirect rule${num_invalid === 1 ? "" : "s"}:\n` +
-				`${invalidRedirectRulesList}`
-		);
-	}
-
-	/* Better to return no Redirects object at all than one with empty rules */
-	if (num_valid === 0) {
-		return {};
-	}
-
-	const staticRedirects: MetadataStaticRedirects = {};
-	const dynamicRedirects: MetadataRedirects = {};
-	let canCreateStaticRule = true;
-	for (const rule of redirects.rules) {
-		if (!rule.from.match(SPLAT_REGEX) && !rule.from.match(PLACEHOLDER_REGEX)) {
-			if (canCreateStaticRule) {
-				staticRedirects[rule.from] = {
-					status: rule.status,
-					to: rule.to,
-					lineNumber: rule.lineNumber,
-				};
-				continue;
-			} else {
-				logger.info(
-					`The redirect rule ${rule.from} → ${rule.status} ${rule.to} could be made more performant by bringing it above any lines with splats or placeholders.`
-				);
-			}
-		}
-
-		dynamicRedirects[rule.from] = { status: rule.status, to: rule.to };
-		canCreateStaticRule = false;
-	}
-
-	return {
-		redirects: {
-			version: REDIRECTS_VERSION,
-			staticRules: staticRedirects,
-			rules: dynamicRedirects,
-		},
-	};
-}
-
-function constructHeaders({
-	headers,
-	headersFile,
-	logger,
-}: {
-	headers?: ParsedHeaders;
-	headersFile?: string;
-	logger: Logger;
-}): Metadata {
-	if (!headers) {
-		return {};
-	}
-
-	const num_valid = headers.rules.length;
-	const num_invalid = headers.invalid.length;
-
-	// exhaustive check, since we could not have parsed `headers` out of
-	// a non-existing headers file
-	const headersRelativePath = headersFile
-		? relative(process.cwd(), headersFile)
-		: "";
-
-	logger.log(
-		`✨ Parsed ${num_valid} valid header rule${num_valid === 1 ? "" : "s"}.`
-	);
-
-	if (num_invalid > 0) {
-		let invalidHeaderRulesList = ``;
-
-		for (const { line, lineNumber, message } of headers.invalid) {
-			invalidHeaderRulesList += `▶︎ ${message}\n`;
-
-			if (line) {
-				invalidHeaderRulesList += `    at ${headersRelativePath}${lineNumber ? `:${lineNumber}` : ""} | ${line}\n\n`;
-			}
-		}
-
-		logger.warn(
-			`Found ${num_invalid} invalid header rule${num_invalid === 1 ? "" : "s"}:\n` +
-				`${invalidHeaderRulesList}`
-		);
-	}
-
-	/* Better to return no Headers object at all than one with empty rules */
-	if (num_valid === 0) {
-		return {};
-	}
-
-	const rules: MetadataHeaders = {};
-	for (const rule of headers.rules) {
-		rules[rule.path] = {};
-
-		if (Object.keys(rule.headers).length) {
-			rules[rule.path].set = rule.headers;
-		}
-		if (rule.unsetHeaders.length) {
-			rules[rule.path].unset = rule.unsetHeaders;
-		}
-	}
-
-	return {
-		headers: {
-			version: HEADERS_VERSION,
-			rules,
-		},
-	};
-}
-
 function constructWebAnalytics({
 	webAnalyticsToken,
 }: {

package/metadata-generator/types.ts

@@ -1,48 +1,13 @@
-/* REDIRECT PARSING TYPES */
+import type {
+	ParsedHeaders,
+	ParsedRedirects,
+} from "@cloudflare/workers-shared/utils/configuration/types";
 
-export type RedirectLine = [from: string, to: string, status?: number];
-export type RedirectRule = {
-	from: string;
-	to: string;
-	status: number;
-	lineNumber: number;
-};
-
-export type Headers = Record<string, string>;
-export type HeadersRule = {
-	path: string;
-	headers: Headers;
-	unsetHeaders: string[];
-};
-
-export type InvalidRedirectRule = {
-	line?: string;
-	lineNumber?: number;
-	message: string;
-};
-
-export type InvalidHeadersRule = {
-	line?: string;
-	lineNumber?: number;
-	message: string;
-};
-
-export type ParsedRedirects = {
-	invalid: InvalidRedirectRule[];
-	rules: RedirectRule[];
-};
-
-/** Parsed redirects and input file */
 export type ParsedRedirectsWithFile = {
 	parsedRedirects?: ParsedRedirects;
 	file?: string;
 };
 
-export type ParsedHeaders = {
-	invalid: InvalidHeadersRule[];
-	rules: HeadersRule[];
-};
-
 /** Parsed headers and input file */
 export type ParsedHeadersWithFile = {
 	parsedHeaders?: ParsedHeaders;
@@ -86,11 +51,3 @@ export type Metadata = {
 	deploymentId?: string;
 	failOpen?: boolean;
 };
-
-export interface Logger {
-	debug: (message: string) => void;
-	log: (message: string) => void;
-	info: (message: string) => void;
-	warn: (message: string) => void;
-	error: (error: Error) => void;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudflare/pages-shared",
-  "version": "0.13.11",
+  "version": "0.13.13",
   "repository": {
     "type": "git",
     "url": "https://github.com/cloudflare/workers-sdk.git",
@@ -13,11 +13,12 @@
     "metadata-generator/**/*"
   ],
   "dependencies": {
-    "miniflare": "3.20250214.2"
+    "@cloudflare/workers-shared": "0.15.0",
+    "miniflare": "3.20250310.0"
   },
   "devDependencies": {
     "@cloudflare/vitest-pool-workers": "0.7.0",
-    "@cloudflare/workers-types": "^4.20250214.0",
+    "@cloudflare/workers-types": "^4.20250310.0",
     "concurrently": "^8.2.2",
     "glob": "^10.4.5",
     "html-rewriter-wasm": "^0.4.1",

package/asset-server/rulesEngine.ts

@@ -1,96 +0,0 @@
-// Taken from https://stackoverflow.com/a/3561711
-// which is everything from the tc39 proposal, plus the following two characters: ^/
-// It's also everything included in the URLPattern escape (https://wicg.github.io/urlpattern/#escape-a-regexp-string), plus the following: -
-// As the answer says, there's no downside to escaping these extra characters, so better safe than sorry
-const ESCAPE_REGEX_CHARACTERS = /[-/\\^$*+?.()|[\]{}]/g;
-const escapeRegex = (str: string) => {
-	return str.replace(ESCAPE_REGEX_CHARACTERS, "\\$&");
-};
-
-// Placeholder names must begin with a colon then a letter, be alphanumeric and optionally contain underscores.
-// e.g. :place_123_holder
-const HOST_PLACEHOLDER_REGEX =
-	/(?<=^https:\\\/\\\/[^/]*?):([A-Za-z]\w*)(?=\\)/g;
-const PLACEHOLDER_REGEX = /:([A-Za-z]\w*)/g;
-
-export type Replacements = Record<string, string>;
-
-export type Removals = string[];
-
-export const replacer = (str: string, replacements: Replacements) => {
-	for (const [replacement, value] of Object.entries(replacements)) {
-		str = str.replaceAll(`:${replacement}`, value);
-	}
-	return str;
-};
-
-export const generateRulesMatcher = <T>(
-	rules?: Record<string, T>,
-	replacerFn: (match: T, replacements: Replacements) => T = (match) => match
-) => {
-	if (!rules) {
-		return () => [];
-	}
-
-	const compiledRules = Object.entries(rules)
-		.map(([rule, match]) => {
-			const crossHost = rule.startsWith("https://");
-
-			// Create :splat capturer then escape.
-			rule = rule.split("*").map(escapeRegex).join("(?<splat>.*)");
-
-			// Create :placeholder capturers (already escaped).
-			// For placeholders in the host, we separate at forward slashes and periods.
-			// For placeholders in the path, we separate at forward slashes.
-			// This matches the behavior of URLPattern.
-			// e.g. https://:subdomain.domain/ -> https://(here).domain/
-			// e.g. /static/:file -> /static/(image.jpg)
-			// e.g. /blog/:post -> /blog/(an-exciting-post)
-			const host_matches = rule.matchAll(HOST_PLACEHOLDER_REGEX);
-			for (const host_match of host_matches) {
-				rule = rule.split(host_match[0]).join(`(?<${host_match[1]}>[^/.]+)`);
-			}
-
-			const path_matches = rule.matchAll(PLACEHOLDER_REGEX);
-			for (const path_match of path_matches) {
-				rule = rule.split(path_match[0]).join(`(?<${path_match[1]}>[^/]+)`);
-			}
-
-			// Wrap in line terminators to be safe.
-			rule = "^" + rule + "$";
-
-			try {
-				const regExp = new RegExp(rule);
-				return [{ crossHost, regExp }, match];
-			} catch {}
-		})
-		.filter((value) => value !== undefined) as [
-		{ crossHost: boolean; regExp: RegExp },
-		T,
-	][];
-
-	return ({ request }: { request: Request }) => {
-		const { pathname, hostname } = new URL(request.url);
-
-		return compiledRules
-			.map(([{ crossHost, regExp }, match]) => {
-				// This, rather confusingly, means that although we enforce `https://` protocols in
-				// the rules of `_headers`/`_redirects`, we don't actually respect that at all at runtime.
-				// When processing a request against an absolute URL rule, we rewrite the protocol to `https://`.
-				// This has the benefit of ensuring attackers can't specify a different protocol
-				// to circumvent a developer's security rules (e.g. CORS), but it isn't obvious behavior.
-				// We should consider different syntax in the future for developers when they specify rules.
-				// For example, `*://example.com/path`, `://example.com/path` or `//example.com/`.
-				// Though we'd need to be careful with that last one
-				// as that would currently be read as a relative URL.
-				// Perhaps, if we ever move the `_headers`/`_redirects` files to acting ahead of Functions,
-				// this might be a good time for this change.
-				const test = crossHost ? `https://${hostname}${pathname}` : pathname;
-				const result = regExp.exec(test);
-				if (result) {
-					return replacerFn(match, result.groups || {});
-				}
-			})
-			.filter((value) => value !== undefined) as T[];
-	};
-};

package/metadata-generator/parseHeaders.ts

@@ -1,170 +0,0 @@
-import {
-	HEADER_SEPARATOR,
-	MAX_HEADER_RULES,
-	MAX_LINE_LENGTH,
-	UNSET_OPERATOR,
-} from "./constants";
-import { validateUrl } from "./validateURL";
-import type { HeadersRule, InvalidHeadersRule, ParsedHeaders } from "./types";
-
-// Not strictly necessary to check for all protocols-like beginnings, since _technically_ that could be a legit header (e.g. name=http, value=://I'm a value).
-// But we're checking here since some people might be caught out and it'll help 99.9% of people who get it wrong.
-// We do the proper validation in `validateUrl` anyway :)
-const LINE_IS_PROBABLY_A_PATH = new RegExp(/^([^\s]+:\/\/|^\/)/);
-
-export function parseHeaders(input: string): ParsedHeaders {
-	const lines = input.split("\n");
-	const rules: HeadersRule[] = [];
-	const invalid: InvalidHeadersRule[] = [];
-
-	let rule: (HeadersRule & { line: string }) | undefined = undefined;
-
-	for (let i = 0; i < lines.length; i++) {
-		const line = lines[i].trim();
-		if (line.length === 0 || line.startsWith("#")) {
-			continue;
-		}
-
-		if (line.length > MAX_LINE_LENGTH) {
-			invalid.push({
-				message: `Ignoring line ${
-					i + 1
-				} as it exceeds the maximum allowed length of ${MAX_LINE_LENGTH}.`,
-			});
-			continue;
-		}
-
-		if (LINE_IS_PROBABLY_A_PATH.test(line)) {
-			if (rules.length >= MAX_HEADER_RULES) {
-				invalid.push({
-					message: `Maximum number of rules supported is ${MAX_HEADER_RULES}. Skipping remaining ${
-						lines.length - i
-					} lines of file.`,
-				});
-				break;
-			}
-
-			if (rule) {
-				if (isValidRule(rule)) {
-					rules.push({
-						path: rule.path,
-						headers: rule.headers,
-						unsetHeaders: rule.unsetHeaders,
-					});
-				} else {
-					invalid.push({
-						line: rule.line,
-						lineNumber: i + 1,
-						message: "No headers specified",
-					});
-				}
-			}
-
-			const [path, pathError] = validateUrl(line, false, true);
-			if (pathError) {
-				invalid.push({
-					line,
-					lineNumber: i + 1,
-					message: pathError,
-				});
-				rule = undefined;
-				continue;
-			}
-
-			rule = {
-				path: path as string,
-				line,
-				headers: {},
-				unsetHeaders: [],
-			};
-			continue;
-		}
-
-		if (!line.includes(HEADER_SEPARATOR)) {
-			if (!rule) {
-				invalid.push({
-					line,
-					lineNumber: i + 1,
-					message: "Expected a path beginning with at least one forward-slash",
-				});
-			} else {
-				if (line.trim().startsWith(UNSET_OPERATOR)) {
-					rule.unsetHeaders.push(line.trim().replace(UNSET_OPERATOR, ""));
-				} else {
-					invalid.push({
-						line,
-						lineNumber: i + 1,
-						message:
-							"Expected a colon-separated header pair (e.g. name: value)",
-					});
-				}
-			}
-			continue;
-		}
-
-		const [rawName, ...rawValue] = line.split(HEADER_SEPARATOR);
-		const name = rawName.trim().toLowerCase();
-
-		if (name.includes(" ")) {
-			invalid.push({
-				line,
-				lineNumber: i + 1,
-				message: "Header name cannot include spaces",
-			});
-			continue;
-		}
-
-		const value = rawValue.join(HEADER_SEPARATOR).trim();
-
-		if (name === "") {
-			invalid.push({
-				line,
-				lineNumber: i + 1,
-				message: "No header name specified",
-			});
-			continue;
-		}
-
-		if (value === "") {
-			invalid.push({
-				line,
-				lineNumber: i + 1,
-				message: "No header value specified",
-			});
-			continue;
-		}
-
-		if (!rule) {
-			invalid.push({
-				line,
-				lineNumber: i + 1,
-				message: `Path should come before header (${name}: ${value})`,
-			});
-			continue;
-		}
-
-		const existingValues = rule.headers[name];
-		rule.headers[name] = existingValues ? `${existingValues}, ${value}` : value;
-	}
-
-	if (rule) {
-		if (isValidRule(rule)) {
-			rules.push({
-				path: rule.path,
-				headers: rule.headers,
-				unsetHeaders: rule.unsetHeaders,
-			});
-		} else {
-			invalid.push({ line: rule.line, message: "No headers specified" });
-		}
-	}
-
-	return {
-		rules,
-		invalid,
-	};
-}
-
-function isValidRule(rule: HeadersRule) {
-	return Object.keys(rule.headers).length > 0 || rule.unsetHeaders.length > 0;
-}

package/metadata-generator/parseRedirects.ts

@@ -1,155 +0,0 @@
-import {
-	MAX_DYNAMIC_REDIRECT_RULES,
-	MAX_LINE_LENGTH,
-	MAX_STATIC_REDIRECT_RULES,
-	PERMITTED_STATUS_CODES,
-	PLACEHOLDER_REGEX,
-	SPLAT_REGEX,
-} from "./constants";
-import { urlHasHost, validateUrl } from "./validateURL";
-import type {
-	InvalidRedirectRule,
-	ParsedRedirects,
-	RedirectLine,
-	RedirectRule,
-} from "./types";
-
-export function parseRedirects(input: string): ParsedRedirects {
-	const lines = input.split("\n");
-	const rules: RedirectRule[] = [];
-	const seen_paths = new Set<string>();
-	const invalid: InvalidRedirectRule[] = [];
-
-	let staticRules = 0;
-	let dynamicRules = 0;
-	let canCreateStaticRule = true;
-
-	for (let i = 0; i < lines.length; i++) {
-		const line = lines[i].trim();
-		if (line.length === 0 || line.startsWith("#")) {
-			continue;
-		}
-
-		if (line.length > MAX_LINE_LENGTH) {
-			invalid.push({
-				message: `Ignoring line ${
-					i + 1
-				} as it exceeds the maximum allowed length of ${MAX_LINE_LENGTH}.`,
-			});
-			continue;
-		}
-
-		const tokens = line.split(/\s+/);
-
-		if (tokens.length < 2 || tokens.length > 3) {
-			invalid.push({
-				line,
-				lineNumber: i + 1,
-				message: `Expected exactly 2 or 3 whitespace-separated tokens. Got ${tokens.length}.`,
-			});
-			continue;
-		}
-
-		const [str_from, str_to, str_status = "302"] = tokens as RedirectLine;
-
-		const fromResult = validateUrl(str_from, true, true, false, false);
-		if (fromResult[0] === undefined) {
-			invalid.push({
-				line,
-				lineNumber: i + 1,
-				message: fromResult[1],
-			});
-			continue;
-		}
-		const from = fromResult[0];
-
-		if (
-			canCreateStaticRule &&
-			!from.match(SPLAT_REGEX) &&
-			!from.match(PLACEHOLDER_REGEX)
-		) {
-			staticRules += 1;
-
-			if (staticRules > MAX_STATIC_REDIRECT_RULES) {
-				invalid.push({
-					message: `Maximum number of static rules supported is ${MAX_STATIC_REDIRECT_RULES}. Skipping line.`,
-				});
-				continue;
-			}
-		} else {
-			dynamicRules += 1;
-			canCreateStaticRule = false;
-
-			if (dynamicRules > MAX_DYNAMIC_REDIRECT_RULES) {
-				invalid.push({
-					message: `Maximum number of dynamic rules supported is ${MAX_DYNAMIC_REDIRECT_RULES}. Skipping remaining ${
-						lines.length - i
-					} lines of file.`,
-				});
-				break;
-			}
-		}
-
-		const toResult = validateUrl(str_to, false, false, true, true);
-		if (toResult[0] === undefined) {
-			invalid.push({
-				line,
-				lineNumber: i + 1,
-				message: toResult[1],
-			});
-			continue;
-		}
-		const to = toResult[0];
-
-		const status = Number(str_status);
-		if (isNaN(status) || !PERMITTED_STATUS_CODES.has(status)) {
-			invalid.push({
-				line,
-				lineNumber: i + 1,
-				message: `Valid status codes are 200, 301, 302 (default), 303, 307, or 308. Got ${str_status}.`,
-			});
-			continue;
-		}
-
-		// We want to always block the `/* /index.html` redirect - this will cause TOO_MANY_REDIRECTS errors as
-		// the asset worker will redirect it back to `/`, removing the `/index.html`. This is the case for regular
-		// redirects, as well as proxied (200) rewrites. We only want to run this on relative urls
-		if (/\/\*?$/.test(from) && /\/index(.html)?$/.test(to) && !urlHasHost(to)) {
-			invalid.push({
-				line,
-				lineNumber: i + 1,
-				message:
-					"Infinite loop detected in this rule and has been ignored. This will cause a redirect to strip `.html` or `/index` and end up triggering this rule again. Please fix or remove this rule to silence this warning.",
-			});
-			continue;
-		}
-
-		if (seen_paths.has(from)) {
-			invalid.push({
-				line,
-				lineNumber: i + 1,
-				message: `Ignoring duplicate rule for path ${from}.`,
-			});
-			continue;
-		}
-		seen_paths.add(from);
-
-		if (status === 200) {
-			if (urlHasHost(to)) {
-				invalid.push({
-					line,
-					lineNumber: i + 1,
-					message: `Proxy (200) redirects can only point to relative paths. Got ${to}`,
-				});
-				continue;
-			}
-		}
-
-		rules.push({ from, to, status, lineNumber: i + 1 });
-	}
-
-	return {
-		rules,
-		invalid,
-	};
-}

package/metadata-generator/validateURL.ts

@@ -1,76 +0,0 @@
-export const extractPathname = (
-	path = "/",
-	includeSearch: boolean,
-	includeHash: boolean
-): string => {
-	if (!path.startsWith("/")) {
-		path = `/${path}`;
-	}
-	const url = new URL(`//${path}`, "relative://");
-	return `${url.pathname}${includeSearch ? url.search : ""}${
-		includeHash ? url.hash : ""
-	}`;
-};
-
-const URL_REGEX = /^https:\/\/+(?<host>[^/]+)\/?(?<path>.*)/;
-const HOST_WITH_PORT_REGEX = /.*:\d+$/;
-const PATH_REGEX = /^\//;
-
-export const validateUrl = (
-	token: string,
-	onlyRelative = false,
-	disallowPorts = false,
-	includeSearch = false,
-	includeHash = false
-): [undefined, string] | [string, undefined] => {
-	const host = URL_REGEX.exec(token);
-	if (host && host.groups && host.groups.host) {
-		if (onlyRelative) {
-			return [
-				undefined,
-				`Only relative URLs are allowed. Skipping absolute URL ${token}.`,
-			];
-		}
-
-		if (disallowPorts && host.groups.host.match(HOST_WITH_PORT_REGEX)) {
-			return [
-				undefined,
-				`Specifying ports is not supported. Skipping absolute URL ${token}.`,
-			];
-		}
-
-		return [
-			`https://${host.groups.host}${extractPathname(
-				host.groups.path,
-				includeSearch,
-				includeHash
-			)}`,
-			undefined,
-		];
-	} else {
-		if (!token.startsWith("/") && onlyRelative) {
-			token = `/${token}`;
-		}
-
-		const path = PATH_REGEX.exec(token);
-		if (path) {
-			try {
-				return [extractPathname(token, includeSearch, includeHash), undefined];
-			} catch {
-				return [undefined, `Error parsing URL segment ${token}. Skipping.`];
-			}
-		}
-	}
-
-	return [
-		undefined,
-		onlyRelative
-			? "URLs should begin with a forward-slash."
-			: 'URLs should either be relative (e.g. begin with a forward-slash), or use HTTPS (e.g. begin with "https://").',
-	];
-};
-
-export function urlHasHost(token: string): boolean {
-	const host = URL_REGEX.exec(token);
-	return Boolean(host && host.groups && host.groups.host);
-}