rankforge 0.3.0

package/src/html-extract.mjs

@@ -0,0 +1,226 @@
+import { isHttpUrl, resolveUrl, sameOrigin } from "./url-utils.mjs";
+
+const decodeEntities = (value) =>
+  String(value || "")
+    .replace(/ /g, " ")
+    .replace(/"/g, '"')
+    .replace(/'/g, "'")
+    .replace(/'/g, "'")
+    .replace(/&/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">");
+
+export const cleanText = (value) =>
+  decodeEntities(value)
+    .replace(/<[^>]+>/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+
+const attr = (tag, name) => {
+  const pattern = new RegExp(`\\b${name}\\s*=\\s*["']([^"']*)["']`, "i");
+  return tag.match(pattern)?.[1] ?? null;
+};
+
+const allMatches = (html, pattern, mapper) => {
+  const results = [];
+  let match;
+  while ((match = pattern.exec(html))) results.push(mapper(match));
+  return results;
+};
+
+const unique = (values) => [...new Set(values.filter(Boolean))];
+
+const firstTagContent = (html, tagName) => {
+  const pattern = new RegExp(`<${tagName}\\b[^>]*>([\\s\\S]*?)<\\/${tagName}>`, "i");
+  const match = html.match(pattern);
+  return match ? cleanText(match[1]) : null;
+};
+
+const metaByName = (html, name) => {
+  const tags = allMatches(html, /<meta\b[^>]*>/gi, (match) => match[0]);
+  const tag = tags.find((item) => attr(item, "name")?.toLowerCase() === name.toLowerCase());
+  return tag ? cleanText(attr(tag, "content") || "") : null;
+};
+
+const metaByProperty = (html, property) => {
+  const tags = allMatches(html, /<meta\b[^>]*>/gi, (match) => match[0]);
+  const tag = tags.find((item) => attr(item, "property")?.toLowerCase() === property.toLowerCase());
+  return tag ? cleanText(attr(tag, "content") || "") : null;
+};
+
+const metaContents = (html, selectors) => {
+  const tags = allMatches(html, /<meta\b[^>]*>/gi, (match) => match[0]);
+  return unique(
+    tags.flatMap((tag) => {
+      const content = cleanText(attr(tag, "content") || "");
+      if (!content) return [];
+      return selectors.some(({ key, value }) => attr(tag, key)?.toLowerCase() === value.toLowerCase()) ? [content] : [];
+    }),
+  );
+};
+
+const linkTags = (html) => allMatches(html, /<link\b[^>]*>/gi, (match) => match[0]);
+
+const relParts = (tag) =>
+  String(attr(tag, "rel") || "")
+    .toLowerCase()
+    .split(/\s+/)
+    .filter(Boolean);
+
+const linkByRel = (html, rel, baseUrl) => {
+  const tags = linkTags(html);
+  const tag = tags.find((item) =>
+    relParts(item).includes(rel.toLowerCase()),
+  );
+  const href = tag ? attr(tag, "href") : null;
+  return href && baseUrl ? resolveUrl(href, baseUrl) : href;
+};
+
+const favicon = (html, baseUrl) => {
+  const tag = linkTags(html).find((item) => {
+    const rel = relParts(item);
+    return rel.includes("icon") || rel.includes("shortcut") || rel.includes("apple-touch-icon");
+  });
+  const href = tag ? attr(tag, "href") : null;
+  return href && baseUrl ? resolveUrl(href, baseUrl) : href;
+};
+
+const hreflangLinks = (html, baseUrl) =>
+  linkTags(html)
+    .filter((tag) => relParts(tag).includes("alternate") && attr(tag, "hreflang") && attr(tag, "href"))
+    .map((tag) => ({
+      hreflang: attr(tag, "hreflang"),
+      href: baseUrl ? resolveUrl(attr(tag, "href"), baseUrl) : attr(tag, "href"),
+    }))
+    .filter((item) => item.href);
+
+const previewDirectives = (values) =>
+  unique(
+    values
+      .filter(Boolean)
+      .flatMap((value) => String(value).split(","))
+      .map((item) => item.trim())
+      .filter((item) => /^(?:nosnippet|noarchive|noimageindex|max-(?:snippet|image-preview|video-preview):)/i.test(item)),
+  );
+
+const structuredDataTypes = (value) => {
+  if (!value) return [];
+  if (Array.isArray(value)) return value.flatMap(structuredDataTypes);
+  if (typeof value !== "object") return [];
+
+  const types = [];
+  if (value["@type"]) {
+    if (Array.isArray(value["@type"])) types.push(...value["@type"].map(String));
+    else types.push(String(value["@type"]));
+  }
+  if (value["@graph"]) types.push(...structuredDataTypes(value["@graph"]));
+  return types;
+};
+
+const linkCounts = (links, baseUrl) => {
+  const counts = { internal: 0, external: 0 };
+  for (const link of links) {
+    if (!isHttpUrl(link.href)) continue;
+    if (baseUrl && sameOrigin(baseUrl, link.href)) counts.internal += 1;
+    else counts.external += 1;
+  }
+  return counts;
+};
+
+export const extractHtmlEvidence = (html, baseUrl = null) => {
+  const title = firstTagContent(html, "title");
+  const description = metaByName(html, "description");
+  const robots = metaByName(html, "robots");
+  const googlebot = metaByName(html, "googlebot");
+  const canonical = linkByRel(html, "canonical", baseUrl);
+  const siteName = metaByProperty(html, "og:site_name") || metaByName(html, "application-name");
+  const alternates = hreflangLinks(html, baseUrl);
+  const faviconUrl = favicon(html, baseUrl);
+
+  const h1 = allMatches(html, /<h1\b[^>]*>([\s\S]*?)<\/h1>/gi, (match) => cleanText(match[1]));
+  const headings = allMatches(html, /<h([2-6])\b[^>]*>([\s\S]*?)<\/h\1>/gi, (match) => ({
+    level: Number(match[1]),
+    text: cleanText(match[2]),
+  }));
+
+  const links = allMatches(html, /<a\b[^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi, (match) => ({
+    href: baseUrl ? resolveUrl(match[1], baseUrl) : match[1],
+    text: cleanText(match[2]),
+  })).filter((link) => link.href);
+  const countsByLinkType = linkCounts(links, baseUrl);
+
+  const images = allMatches(html, /<img\b[^>]*>/gi, (match) => {
+    const tag = match[0];
+    const src = attr(tag, "src");
+    return {
+      src: src && baseUrl ? resolveUrl(src, baseUrl) : src,
+      alt: attr(tag, "alt"),
+    };
+  });
+
+  const structuredData = allMatches(
+    html,
+    /<script\b[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi,
+    (match) => {
+      const raw = match[1].trim();
+      try {
+        return { data: JSON.parse(raw) };
+      } catch {
+        return { parseError: true, rawPreview: cleanText(raw).slice(0, 500) };
+      }
+    },
+  );
+  const schemaTypes = unique(structuredData.flatMap((item) => structuredDataTypes(item.data)));
+
+  const authors = metaContents(html, [
+    { key: "name", value: "author" },
+    { key: "property", value: "article:author" },
+  ]);
+  const dates = unique([
+    ...metaContents(html, [
+      { key: "name", value: "date" },
+      { key: "property", value: "article:published_time" },
+      { key: "property", value: "article:modified_time" },
+      { key: "name", value: "dc.date" },
+    ]),
+    ...allMatches(html, /<time\b[^>]*>/gi, (match) => attr(match[0], "datetime")),
+  ]);
+
+  const visibleText = cleanText(
+    html
+      .replace(/<script[\s\S]*?<\/script>/gi, " ")
+      .replace(/<style[\s\S]*?<\/style>/gi, " "),
+  );
+
+  return {
+    title,
+    description,
+    robots,
+    canonical,
+    favicon: faviconUrl,
+    siteName,
+    hreflang: alternates,
+    previewDirectives: previewDirectives([robots, googlebot]),
+    h1,
+    headings,
+    links,
+    images,
+    structuredData,
+    schemaTypes,
+    entitySignals: {
+      authors,
+      dates,
+    },
+    counts: {
+      h1: h1.length,
+      headings: headings.length,
+      links: links.length,
+      internalLinks: countsByLinkType.internal,
+      externalLinks: countsByLinkType.external,
+      images: images.length,
+      structuredData: structuredData.length,
+      visibleTextCharacters: visibleText.length,
+    },
+    visibleTextPreview: visibleText.slice(0, 1200),
+  };
+};

package/src/index.mjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { runCli } from "./cli.mjs";
+
+const exitCode = await runCli(process.argv.slice(2), {
+  stdout: process.stdout,
+  stderr: process.stderr,
+});
+
+process.exitCode = exitCode;

package/src/integrations.mjs

@@ -0,0 +1,78 @@
+import { readTextFileLimited, resolveLimits } from "./io-guards.mjs";
+import { readLighthouseReport } from "./performance.mjs";
+
+const parseCsvLine = (line) => {
+  const cells = [];
+  let current = "";
+  let quoted = false;
+  for (let index = 0; index < line.length; index++) {
+    const char = line[index];
+    if (char === '"') {
+      quoted = !quoted;
+      continue;
+    }
+    if (char === "," && !quoted) {
+      cells.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  cells.push(current);
+  return cells;
+};
+
+const number = (value) => {
+  const parsed = Number(String(value || "").replace("%", ""));
+  return Number.isFinite(parsed) ? parsed : null;
+};
+
+export const readSearchConsoleCsv = (filePath, options = {}) => {
+  const limits = resolveLimits(options.limits);
+  const [headerLine, ...lines] = readTextFileLimited(filePath, {
+    security: options.security,
+    allowRestricted: true,
+    limits,
+    maxBytes: limits.maxIntegrationBytes,
+  })
+    .trim()
+    .split(/\r?\n/);
+  const headers = parseCsvLine(headerLine).map((header) => header.trim().toLowerCase());
+  const rows = lines.filter(Boolean).map((line) => {
+    const cells = parseCsvLine(line);
+    const row = Object.fromEntries(headers.map((header, index) => [header, cells[index] ?? ""]));
+    return {
+      query: row.query || "",
+      page: row.page || "",
+      clicks: number(row.clicks),
+      impressions: number(row.impressions),
+      ctr: number(row.ctr),
+      position: number(row.position),
+    };
+  });
+  return { type: "search_console_csv", source: filePath, rows };
+};
+
+const readJsonRows = (filePath, type, options = {}) => {
+  const limits = resolveLimits(options.limits);
+  const parsed = JSON.parse(
+    readTextFileLimited(filePath, {
+      security: options.security,
+      allowRestricted: true,
+      limits,
+      maxBytes: limits.maxIntegrationBytes,
+    }),
+  );
+  return { type, source: filePath, rows: Array.isArray(parsed) ? parsed : parsed.rows || [] };
+};
+
+export const readSerpExport = (filePath, options = {}) => readJsonRows(filePath, "serp_export", options);
+
+export const readAiAnswers = (filePath, options = {}) => readJsonRows(filePath, "ai_answer_export", options);
+
+export const readIntegrations = (integrations = {}, options = {}) => ({
+  searchConsole: integrations.searchConsole ? readSearchConsoleCsv(integrations.searchConsole, options) : null,
+  serp: integrations.serp ? readSerpExport(integrations.serp, options) : null,
+  aiAnswers: integrations.aiAnswers ? readAiAnswers(integrations.aiAnswers, options) : null,
+  lighthouse: integrations.lighthouse ? readLighthouseReport(integrations.lighthouse, options) : null,
+});

package/src/io-guards.mjs

@@ -0,0 +1,196 @@
+import dns from "node:dns/promises";
+import fs from "node:fs";
+import net from "node:net";
+
+export const defaultLimits = {
+  timeoutMs: 15000,
+  maxHtmlBytes: 2_000_000,
+  maxTextBytes: 1_000_000,
+  maxFileBytes: 5_000_000,
+  maxIntegrationBytes: 5_000_000,
+};
+
+export const resolveLimits = (limits = {}) => ({
+  ...defaultLimits,
+  ...(limits || {}),
+});
+
+const securityMode = (security = {}) => security?.mode || "local";
+
+const isBlockedHostname = (hostname) => {
+  const normalized = String(hostname || "").toLowerCase().replace(/^\[|\]$/g, "");
+  return (
+    normalized === "localhost" ||
+    normalized.endsWith(".localhost") ||
+    normalized === "ip6-localhost" ||
+    normalized === "metadata.google.internal"
+  );
+};
+
+const isPrivateIpv4 = (address) => {
+  const parts = address.split(".").map(Number);
+  if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part))) return false;
+  const [a, b] = parts;
+  return (
+    a === 0 ||
+    a === 10 ||
+    a === 127 ||
+    a === 169 && b === 254 ||
+    a === 172 && b >= 16 && b <= 31 ||
+    a === 192 && b === 168 ||
+    a === 100 && b >= 64 && b <= 127 ||
+    a === 198 && (b === 18 || b === 19)
+  );
+};
+
+const isPrivateIpv6 = (address) => {
+  const normalized = address.toLowerCase();
+  const firstHextet = Number.parseInt(normalized.split(":")[0], 16);
+  return (
+    normalized === "::1" ||
+    normalized.startsWith("::ffff:") ||
+    (Number.isFinite(firstHextet) && firstHextet >= 0xfe80 && firstHextet <= 0xfebf) ||
+    normalized.startsWith("fc") ||
+    normalized.startsWith("fd")
+  );
+};
+
+const isPrivateAddress = (address) => {
+  const version = net.isIP(address);
+  if (version === 4) return isPrivateIpv4(address);
+  if (version === 6) return isPrivateIpv6(address);
+  return false;
+};
+
+const resolveAddresses = async (hostname) => {
+  const literalVersion = net.isIP(hostname);
+  if (literalVersion) return [hostname];
+  try {
+    const records = await dns.lookup(hostname, { all: true, verbatim: true });
+    return records.map((record) => record.address);
+  } catch {
+    return [];
+  }
+};
+
+export const assertUrlAllowed = async (target, security = {}) => {
+  if (securityMode(security) !== "restricted") return;
+
+  const parsed = new URL(target);
+  if (!["http:", "https:"].includes(parsed.protocol)) {
+    throw new Error(`Restricted security mode only allows HTTP(S) URLs: ${target}`);
+  }
+  const hostname = parsed.hostname.replace(/^\[|\]$/g, "");
+  if (isBlockedHostname(hostname)) {
+    throw new Error(`Restricted security mode blocks private network target: ${target}`);
+  }
+
+  const addresses = await resolveAddresses(hostname);
+  if (addresses.some(isPrivateAddress)) {
+    throw new Error(`Restricted security mode blocks private network target: ${target}`);
+  }
+};
+
+export const assertFileAllowed = (target, security = {}, options = {}) => {
+  if (securityMode(security) === "restricted" && !options.allowRestricted) {
+    throw new Error(`Local file targets are disabled by restricted security mode: ${target}`);
+  }
+};
+
+export const readTextFileLimited = (filePath, options = {}) => {
+  const limits = resolveLimits(options.limits);
+  const maxBytes = options.maxBytes ?? limits.maxFileBytes;
+  if (options.security) assertFileAllowed(filePath, options.security, { allowRestricted: options.allowRestricted });
+
+  const stat = fs.statSync(filePath);
+  if (!stat.isFile()) {
+    throw new Error(`Only regular files can be read: ${filePath}`);
+  }
+  if (stat.size > maxBytes) {
+    throw new Error(`File ${filePath} exceeds ${maxBytes} bytes.`);
+  }
+  return fs.readFileSync(filePath, "utf8");
+};
+
+export const fetchWithGuards = async (target, options = {}) => {
+  const limits = resolveLimits(options.limits);
+  const redirect = options.fetchOptions?.redirect || "manual";
+  if (securityMode(options.security) === "restricted" && redirect !== "manual") {
+    throw new Error("Restricted security mode requires manual redirects.");
+  }
+  await assertUrlAllowed(target, options.security);
+
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), limits.timeoutMs);
+  try {
+    return await fetch(target, {
+      redirect: "manual",
+      ...options.fetchOptions,
+      signal: controller.signal,
+    });
+  } catch (error) {
+    if (error.name === "AbortError") {
+      throw new Error(`Timed out fetching ${target} after ${limits.timeoutMs} ms.`);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+  }
+};
+
+export const readResponseTextLimited = async (response, options = {}) => {
+  const limits = resolveLimits(options.limits);
+  const maxBytes = options.maxBytes ?? limits.maxTextBytes;
+  const label = options.label || response.url || "response";
+  const timeoutError = () => new Error(`Timed out reading response body for ${label} after ${limits.timeoutMs} ms.`);
+  const contentLength = Number(response.headers.get("content-length"));
+  if (Number.isFinite(contentLength) && contentLength > maxBytes) {
+    throw new Error(`Response body for ${label} exceeds ${maxBytes} bytes.`);
+  }
+
+  if (!response.body) {
+    let timeout;
+    const text = await Promise.race([
+      response.text(),
+      new Promise((resolve, reject) => {
+        timeout = setTimeout(() => reject(timeoutError()), limits.timeoutMs);
+      }),
+    ]).finally(() => clearTimeout(timeout));
+    if (Buffer.byteLength(text, "utf8") > maxBytes) {
+      throw new Error(`Response body for ${label} exceeds ${maxBytes} bytes.`);
+    }
+    return text;
+  }
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let received = 0;
+  let text = "";
+  let timeout;
+  let timedOut = false;
+  const timeoutPromise = new Promise((resolve, reject) => {
+    timeout = setTimeout(() => {
+      timedOut = true;
+      reader.cancel().catch(() => {});
+      reject(timeoutError());
+    }, limits.timeoutMs);
+  });
+
+  try {
+    while (true) {
+      const { done, value } = await Promise.race([reader.read(), timeoutPromise]);
+      if (timedOut) throw timeoutError();
+      if (done) break;
+      received += value.byteLength;
+      if (received > maxBytes) {
+        await reader.cancel();
+        throw new Error(`Response body for ${label} exceeds ${maxBytes} bytes.`);
+      }
+      text += decoder.decode(value, { stream: true });
+    }
+  } finally {
+    clearTimeout(timeout);
+  }
+
+  return text + decoder.decode();
+};

package/src/performance.mjs

@@ -0,0 +1,112 @@
+import { implementationTaskFor } from "./finding-task.mjs";
+import { readTextFileLimited, resolveLimits } from "./io-guards.mjs";
+import { getRule } from "./rules.mjs";
+
+const numericAuditValue = (audits, id) => {
+  const value = audits?.[id]?.numericValue;
+  return Number.isFinite(value) ? value : null;
+};
+
+const scoreToPercent = (score) => {
+  if (!Number.isFinite(score)) return null;
+  return Math.round(score * 100);
+};
+
+const lighthouseUrl = (evidence) => evidence.finalUrl || evidence.requestedUrl || evidence.source || "Lighthouse report";
+
+const effortFor = (severity) => (severity === "P0" || severity === "P1" ? "M" : "S");
+
+const createPerformanceFinding = (ruleId, lighthouse, evidence, impact) => {
+  const rule = getRule(ruleId);
+  if (!rule) throw new Error(`Unknown rule: ${ruleId}`);
+  const owner = "Engineering";
+  const effort = effortFor(rule.defaultSeverity);
+
+  return {
+    ruleId: rule.id,
+    title: rule.title,
+    severity: rule.defaultSeverity,
+    dimension: rule.dimension,
+    affectedUrls: [lighthouseUrl(lighthouse)],
+    evidence,
+    impact,
+    recommendation: rule.recommendation,
+    implementationTask: implementationTaskFor(rule, owner, effort),
+    owner,
+    effort,
+    confidence: "high",
+    sources: rule.sources,
+  };
+};
+
+export const readLighthouseReport = (filePath, options = {}) => {
+  const limits = resolveLimits(options.limits);
+  const parsed = JSON.parse(
+    readTextFileLimited(filePath, {
+      security: options.security,
+      allowRestricted: true,
+      limits,
+      maxBytes: limits.maxIntegrationBytes,
+    }),
+  );
+  const performanceScore = scoreToPercent(parsed.categories?.performance?.score);
+
+  return {
+    type: "lighthouse",
+    source: filePath,
+    lighthouseVersion: parsed.lighthouseVersion || null,
+    requestedUrl: parsed.requestedUrl || null,
+    finalUrl: parsed.finalDisplayedUrl || parsed.finalUrl || null,
+    formFactor: parsed.configSettings?.formFactor || null,
+    performanceScore,
+    metrics: {
+      lcpMs: numericAuditValue(parsed.audits, "largest-contentful-paint"),
+      cls: numericAuditValue(parsed.audits, "cumulative-layout-shift"),
+      tbtMs: numericAuditValue(parsed.audits, "total-blocking-time"),
+    },
+  };
+};
+
+export const evaluatePerformance = (lighthouse) => {
+  if (!lighthouse) return [];
+
+  const findings = [];
+  const score = lighthouse.performanceScore;
+  const lcpMs = lighthouse.metrics?.lcpMs;
+  const cls = lighthouse.metrics?.cls;
+
+  if (Number.isFinite(score) && score < 50) {
+    findings.push(
+      createPerformanceFinding(
+        "performance.lighthouse_poor",
+        lighthouse,
+        ["$.integrations.lighthouse.performanceScore"],
+        `Imported Lighthouse performance score is ${score}/100.`,
+      ),
+    );
+  }
+
+  if (Number.isFinite(lcpMs) && lcpMs > 2500) {
+    findings.push(
+      createPerformanceFinding(
+        "performance.lcp_poor",
+        lighthouse,
+        ["$.integrations.lighthouse.metrics.lcpMs"],
+        `Largest Contentful Paint is ${Math.round(lcpMs)} ms in the imported Lighthouse report.`,
+      ),
+    );
+  }
+
+  if (Number.isFinite(cls) && cls > 0.1) {
+    findings.push(
+      createPerformanceFinding(
+        "performance.cls_poor",
+        lighthouse,
+        ["$.integrations.lighthouse.metrics.cls"],
+        `Cumulative Layout Shift is ${cls} in the imported Lighthouse report.`,
+      ),
+    );
+  }
+
+  return findings;
+};

package/src/regex-guards.mjs

@@ -0,0 +1,52 @@
+export const maxRegexPatternLength = 200;
+
+const nestedQuantifierPattern =
+  /\((?:\?:)?(?:[^()\\]|\\.)*(?:[+*?]|\{\d+,?\d*\})(?:[^()\\]|\\.)*\)(?:[+*?]|\{\d+,?\d*\})/;
+
+const quantifiedAlternationPattern = /\((?:\?:)?([^()]*\|[^()]*)\)(?:[+*?]|\{\d+,?\d*\})/g;
+
+const hasOverlappingAlternation = (pattern) => {
+  let match;
+  quantifiedAlternationPattern.lastIndex = 0;
+  try {
+    while ((match = quantifiedAlternationPattern.exec(pattern))) {
+      const alternatives = match[1]
+        .split("|")
+        .map((item) => item.replace(/\\(.)/g, "$1"))
+        .filter(Boolean);
+      for (let index = 0; index < alternatives.length; index++) {
+        for (let compare = index + 1; compare < alternatives.length; compare++) {
+          const left = alternatives[index];
+          const right = alternatives[compare];
+          if (left.startsWith(right) || right.startsWith(left)) return true;
+        }
+      }
+    }
+  } finally {
+    quantifiedAlternationPattern.lastIndex = 0;
+  }
+  return false;
+};
+
+export const unsafeRegexReason = (pattern) => {
+  if (pattern.length > maxRegexPatternLength) {
+    return `pattern is longer than ${maxRegexPatternLength} characters`;
+  }
+  if (hasOverlappingAlternation(pattern)) {
+    return "pattern contains overlapping alternation";
+  }
+  if (nestedQuantifierPattern.test(pattern)) {
+    return "pattern contains nested quantifiers";
+  }
+  return null;
+};
+
+export const assertSafeRegexPattern = (pattern, key = "pattern") => {
+  const reason = unsafeRegexReason(pattern);
+  if (reason) throw new Error(`${key} contains an unsafe regular expression: ${reason}`);
+};
+
+export const compileSafeRegex = (pattern, key = "pattern") => {
+  assertSafeRegexPattern(pattern, key);
+  return new RegExp(pattern);
+};