@wular/pnext 0.0.4 → 0.0.6

package/src/compat/register/routing.ts

@@ -7,67 +7,67 @@
 //
 // A pure-core app registers none of these, so its route scan discovers only the generic conventions.
 
-import type { ResolvedConfig } from '../../config';
+import type { ResolvedConfig } from '../../config'
 import {
   registerAlwaysClientEntryReason,
   registerClientEntryDetectors,
   registerRouteDependencyClassifiers,
   registerRouteConventions,
   registerUsageDetectors,
-} from '../../extensions';
-import { nextCompatEnabled } from '../../compat';
-import { escapeRegex } from '../../utils/source';
+} from '../../extensions'
+import { nextCompatEnabled } from '../../compat/aliases'
+import { escapeRegex } from '../../utils/code'
 
 export function registerRoutingExtensions(config: ResolvedConfig): void {
-  if (!nextCompatEnabled(config)) return;
+  if (!nextCompatEnabled(config)) return
   // Next's experimental authInterrupts boundaries mirror error/not-found.
   registerRouteConventions(
     { name: 'forbidden', boundary: true },
     { name: 'unauthorized', boundary: true },
-  );
-  registerUsageDetectors(usesNextRequestImport, usesNextServerConnection);
-  registerRouteDependencyClassifiers(classifyNextRouteDependencies);
+  )
+  registerUsageDetectors(usesNextRequestImport, usesNextServerConnection)
+  registerRouteDependencyClassifiers(classifyNextRouteDependencies)
   registerClientEntryDetectors(
     { reason: 'actions', detect: usesServerActionForm },
     { reason: 'form', detect: usesNextForm },
     { reason: 'control-flow', detect: usesClientControlFlowThrow },
-  );
+  )
   // Next emits its app-router bootstrap for every app page, so every document
   // hydrates — instrumentation-client runs before hydration and the hydration
   // timestamp exists even on a page with no client components at all
   // (instrumentation-client-hook asserts both). Core keeps its leaner default.
-  registerAlwaysClientEntryReason('compat-parity');
+  registerAlwaysClientEntryReason('compat-parity')
 }
 
 // A route's layout chain is re-classified for every route below it, and the answer depends only on
 // the source and the route kind - memoize on exactly that.
-const classificationCache = new Map<string, boolean>();
+const classificationCache = new Map<string, boolean>()
 
 function classifyNextRouteDependencies({
   kind,
   files,
 }: import('../../extensions').RouteDependencyContext) {
   for (const { source } of files) {
-    const key = `${kind}\0${source.length}\0${Bun.hash(source).toString()}`;
-    let usesRequest = classificationCache.get(key);
+    const key = `${kind}\0${source.length}\0${Bun.hash(source).toString()}`
+    let usesRequest = classificationCache.get(key)
     if (usesRequest === undefined) {
-      usesRequest = sourceUsesRequest(kind, source);
-      classificationCache.set(key, usesRequest);
+      usesRequest = sourceUsesRequest(kind, source)
+      classificationCache.set(key, usesRequest)
     }
-    if (usesRequest) return { usesRequest: true };
+    if (usesRequest) return { usesRequest: true }
   }
-  return undefined;
+  return undefined
 }
 
 function sourceUsesRequest(kind: 'page' | 'handler', source: string): boolean {
-  const requestUse = usesNextRequestImport(source) || usesNextServerConnection(source);
-  const afterOnly = hasAfterCallbacks(source) && !hasRequestApiOutsideAfter(source);
-  const handlerAfterDraftMode = kind === 'handler' && hasAfterDraftMode(source);
+  const requestUse = usesNextRequestImport(source) || usesNextServerConnection(source)
+  const afterOnly = hasAfterCallbacks(source) && !hasRequestApiOutsideAfter(source)
+  const handlerAfterDraftMode = kind === 'handler' && hasAfterDraftMode(source)
 
   // Page after() callbacks run after their render scope has detached, so an
   // API used only there does not make the page dynamic. Handler callbacks
   // retain the request scope and must render per request instead.
-  if ((requestUse && (kind === 'handler' || !afterOnly)) || handlerAfterDraftMode) return true;
+  if ((requestUse && (kind === 'handler' || !afterOnly)) || handlerAfterDraftMode) return true
   // An automatic page that schedules after() work needs a request lifecycle to flush it after the
   // response. Explicit static segment config still wins in core's mode inference: the page is statically
   // prerendered and its after() runs during the build prerender, so it must NOT be forced dynamic here.
@@ -80,72 +80,74 @@ function sourceUsesRequest(kind: 'page' | 'handler', source: string): boolean {
     !hasRequestApiUse(source) &&
     !hasAfterDraftMode(source) &&
     !hasExplicitStaticDynamic(source)
-  );
+  )
 }
 
 function hasAfterDraftMode(source: string): boolean {
-  return hasAfterCallbacks(source) && nextHeadersBindings(source).draftMode.length > 0;
+  return hasAfterCallbacks(source) && nextHeadersBindings(source).draftMode.length > 0
 }
 
 function hasRequestApiOutsideAfter(source: string): boolean {
-  return hasRequestApiUse(withoutAfterCallbacks(source));
+  return hasRequestApiUse(withoutAfterCallbacks(source))
 }
 
 function hasRequestApiUse(source: string): boolean {
-  const outside = stripCommentsAndStrings(source);
-  const headers = nextHeadersBindings(source);
+  const outside = stripCommentsAndStrings(source)
+  const headers = nextHeadersBindings(source)
   return (
     headers.headers.some(name => new RegExp(`\\b${escapeRegex(name)}\\s*\\(`).test(outside)) ||
     headers.cookies.some(name => new RegExp(`\\b${escapeRegex(name)}\\s*\\(`).test(outside)) ||
-    connectionBindings(source).some(name => new RegExp(`\\b${escapeRegex(name)}\\s*\\(`).test(outside))
-  );
+    connectionBindings(source).some(name =>
+      new RegExp(`\\b${escapeRegex(name)}\\s*\\(`).test(outside),
+    )
+  )
 }
 
 function nextHeadersBindings(source: string) {
-  const headers: string[] = [];
-  const cookies: string[] = [];
-  const draftMode: string[] = [];
-  const pattern = /\bimport\s+\{([^}]*)\}\s+from\s*['"]next\/headers(?:\.js)?['"]/g;
-  let match: RegExpExecArray | null;
+  const headers: string[] = []
+  const cookies: string[] = []
+  const draftMode: string[] = []
+  const pattern = /\bimport\s+\{([^}]*)\}\s+from\s*['"]next\/headers(?:\.js)?['"]/g
+  let match: RegExpExecArray | null
   while ((match = pattern.exec(stripComments(source)))) {
     for (const item of match[1]!.split(',')) {
-      const [imported, local] = item.trim().split(/\s+as\s+/);
-      const name = (local ?? imported)?.trim();
-      if (!name) continue;
-      if (imported?.trim() === 'headers') headers.push(name);
-      if (imported?.trim() === 'cookies') cookies.push(name);
-      if (imported?.trim() === 'draftMode') draftMode.push(name);
+      const [imported, local] = item.trim().split(/\s+as\s+/)
+      const name = (local ?? imported)?.trim()
+      if (!name) continue
+      if (imported?.trim() === 'headers') headers.push(name)
+      if (imported?.trim() === 'cookies') cookies.push(name)
+      if (imported?.trim() === 'draftMode') draftMode.push(name)
     }
   }
-  return { headers, cookies, draftMode };
+  return { headers, cookies, draftMode }
 }
 
 function connectionBindings(source: string): string[] {
-  const names: string[] = [];
-  const pattern = /\bimport\s+[^'";]+?\s+from\s*['"]next\/server(?:\.js)?['"]/g;
-  let match: RegExpExecArray | null;
+  const names: string[] = []
+  const pattern = /\bimport\s+[^'";]+?\s+from\s*['"]next\/server(?:\.js)?['"]/g
+  let match: RegExpExecArray | null
   while ((match = pattern.exec(stripComments(source)))) {
-    const named = /\{([^}]*)\}/.exec(match[0])?.[1];
-    if (!named) continue;
+    const named = /\{([^}]*)\}/.exec(match[0])?.[1]
+    if (!named) continue
     for (const item of named.split(',')) {
-      const [imported, local] = item.trim().split(/\s+as\s+/);
-      if (imported?.trim() === 'connection') names.push((local ?? imported).trim());
+      const [imported, local] = item.trim().split(/\s+as\s+/)
+      if (imported?.trim() === 'connection') names.push((local ?? imported).trim())
     }
   }
-  return names;
+  return names
 }
 
 // Masking only blanks comment/string characters, so a source with no `after`
 // token at all cannot grow one — the gate skips the whole-source mask (the
 // common case) without changing a single answer.
-const AFTER_TOKEN = /\bafter\b/;
+const AFTER_TOKEN = /\bafter\b/
 
 function mentionsAfter(source: string): boolean {
-  return source.includes('after') && AFTER_TOKEN.test(source);
+  return source.includes('after') && AFTER_TOKEN.test(source)
 }
 
 function hasAfterCallbacks(source: string): boolean {
-  return mentionsAfter(source) && /\bafter\s*\(/.test(maskCommentsAndStrings(source));
+  return mentionsAfter(source) && /\bafter\s*\(/.test(maskCommentsAndStrings(source))
 }
 
 // Explicit static segment config that keeps a page statically prerenderable
@@ -154,81 +156,81 @@ function hasAfterCallbacks(source: string): boolean {
 function hasExplicitStaticDynamic(source: string): boolean {
   return /\bexport\s+const\s+dynamic\s*=\s*['"](?:error|force-static)['"]/.test(
     stripComments(source),
-  );
+  )
 }
 
 function withoutAfterCallbacks(source: string): string {
-  if (!mentionsAfter(source)) return source;
-  const chars = [...source];
-  const searchable = maskCommentsAndStrings(source);
-  const pattern = /\bafter\s*\(/g;
-  let match: RegExpExecArray | null;
+  if (!mentionsAfter(source)) return source
+  const chars = [...source]
+  const searchable = maskCommentsAndStrings(source)
+  const pattern = /\bafter\s*\(/g
+  let match: RegExpExecArray | null
   while ((match = pattern.exec(searchable))) {
-    let depth = 1;
-    let index = match.index + match[0].length;
+    let depth = 1
+    let index = match.index + match[0].length
     for (; index < searchable.length && depth > 0; index++) {
-      if (searchable[index] === '(') depth++;
-      else if (searchable[index] === ')') depth--;
+      if (searchable[index] === '(') depth++
+      else if (searchable[index] === ')') depth--
     }
-    if (depth !== 0) continue;
-    for (let cursor = match.index; cursor < index; cursor++) chars[cursor] = ' ';
-    pattern.lastIndex = index;
+    if (depth !== 0) continue
+    for (let cursor = match.index; cursor < index; cursor++) chars[cursor] = ' '
+    pattern.lastIndex = index
   }
-  return chars.join('');
+  return chars.join('')
 }
 
-const maskCommentsAndStrings = memoizeBySource(maskSource);
+const maskCommentsAndStrings = memoizeBySource(maskSource)
 
 function maskSource(source: string): string {
-  const chars = [...source];
-  let quote: string | undefined;
-  let lineComment = false;
-  let blockComment = false;
+  const chars = [...source]
+  let quote: string | undefined
+  let lineComment = false
+  let blockComment = false
   for (let index = 0; index < chars.length; index++) {
-    const char = chars[index]!;
-    const next = chars[index + 1];
+    const char = chars[index]!
+    const next = chars[index + 1]
     if (lineComment) {
-      if (char === '\n') lineComment = false;
-      else chars[index] = ' ';
-      continue;
+      if (char === '\n') lineComment = false
+      else chars[index] = ' '
+      continue
     }
     if (blockComment) {
-      chars[index] = char === '\n' ? '\n' : ' ';
+      chars[index] = char === '\n' ? '\n' : ' '
       if (char === '*' && next === '/') {
-        chars[index + 1] = ' ';
-        blockComment = false;
-        index++;
+        chars[index + 1] = ' '
+        blockComment = false
+        index++
       }
-      continue;
+      continue
     }
     if (quote) {
-      chars[index] = char === '\n' ? '\n' : ' ';
+      chars[index] = char === '\n' ? '\n' : ' '
       if (char === '\\') {
-        if (next && next !== '\n') chars[index + 1] = ' ';
-        index++;
+        if (next && next !== '\n') chars[index + 1] = ' '
+        index++
       } else if (char === quote) {
-        quote = undefined;
+        quote = undefined
       }
-      continue;
+      continue
     }
     if (char === '/' && next === '/') {
-      chars[index] = chars[index + 1] = ' ';
-      lineComment = true;
-      index++;
-      continue;
+      chars[index] = chars[index + 1] = ' '
+      lineComment = true
+      index++
+      continue
     }
     if (char === '/' && next === '*') {
-      chars[index] = chars[index + 1] = ' ';
-      blockComment = true;
-      index++;
-      continue;
+      chars[index] = chars[index + 1] = ' '
+      blockComment = true
+      index++
+      continue
     }
     if (char === '"' || char === "'" || char === '`') {
-      chars[index] = ' ';
-      quote = char;
+      chars[index] = ' '
+      quote = char
     }
   }
-  return chars.join('');
+  return chars.join('')
 }
 
 // A source that declares a server action needs the client action runtime, even
@@ -236,8 +238,8 @@ function maskSource(source: string): string {
 // to. Matched on the RAW source: stripComments also blanks string literals,
 // which would erase the directive being looked for.
 function usesServerActionForm(source: string): boolean {
-  if (source.includes('use server') && /(['"])use server\1/.test(source)) return true;
-  return usesClientFunctionFormAction(source);
+  if (source.includes('use server') && /(['"])use server\1/.test(source)) return true
+  return usesClientFunctionFormAction(source)
 }
 
 // React runs a FUNCTION passed to `<form action>` / `<button formAction>` on the client with the form's
@@ -245,131 +247,132 @@ function usesServerActionForm(source: string): boolean {
 // with no `'use server'` anywhere. Restricted to `'use client'` sources (a server component passing a
 // function needs the directive) and to non-string expressions, so `<form action={url}>` keeps the lean
 // entry.
-const CLIENT_FUNCTION_ACTION_PATTERN = /\b(?:action|formAction)\s*=\s*\{\s*(?!['"`])/;
+const CLIENT_FUNCTION_ACTION_PATTERN = /\b(?:action|formAction)\s*=\s*\{\s*(?!['"`])/
 
 function usesClientFunctionFormAction(source: string): boolean {
-  if (!hasUseClientDirective(source)) return false;
-  return CLIENT_FUNCTION_ACTION_PATTERN.test(stripComments(source));
+  if (!hasUseClientDirective(source)) return false
+  return CLIENT_FUNCTION_ACTION_PATTERN.test(stripComments(source))
 }
 
-const USE_CLIENT_DIRECTIVE = /^\s*(?:\/\/[^\n]*\n|\/\*[\s\S]*?\*\/\s*|#![^\n]*\n|\s)*(['"])use client\1/;
+const USE_CLIENT_DIRECTIVE =
+  /^\s*(?:\/\/[^\n]*\n|\/\*[\s\S]*?\*\/\s*|#![^\n]*\n|\s)*(['"])use client\1/
 
 // The prologue regex scans every leading comment; the literal it ends in has to
 // be somewhere in the source for it to match at all.
 function hasUseClientDirective(source: string): boolean {
-  return source.includes('use client') && USE_CLIENT_DIRECTIVE.test(source);
+  return source.includes('use client') && USE_CLIENT_DIRECTIVE.test(source)
 }
 const CONTROL_FLOW_IMPORT_PATTERN =
-  /import\s*\{[^}]*\b(?:notFound|forbidden|unauthorized)\b[^}]*\}\s*from\s*['"]next\/navigation(?:\.js)?['"]/;
+  /import\s*\{[^}]*\b(?:notFound|forbidden|unauthorized)\b[^}]*\}\s*from\s*['"]next\/navigation(?:\.js)?['"]/
 
 // A `'use client'` module that throws notFound()/forbidden()/unauthorized() does it during HYDRATION,
 // where only the in-tree ClientErrorBoundary can render the outcome - the deferred window last resort
 // lands at idle, long after the throw has unmounted the SSR tree. Server components keep the lean entry:
 // their throw is resolved by the server render.
 function usesClientControlFlowThrow(source: string): boolean {
-  return hasUseClientDirective(source) && CONTROL_FLOW_IMPORT_PATTERN.test(source);
+  return hasUseClientDirective(source) && CONTROL_FLOW_IMPORT_PATTERN.test(source)
 }
 
-const NEXT_FORM_IMPORT_PATTERN = /import\s+[^'";]*\s+from\s+['"]next\/form(?:\.js)?['"]/;
+const NEXT_FORM_IMPORT_PATTERN = /import\s+[^'";]*\s+from\s+['"]next\/form(?:\.js)?['"]/
 
 function usesNextForm(source: string): boolean {
-  if (!source.includes('next/form')) return false;
-  const searchable = stripComments(source);
-  if (!NEXT_FORM_IMPORT_PATTERN.test(searchable)) return false;
+  if (!source.includes('next/form')) return false
+  const searchable = stripComments(source)
+  if (!NEXT_FORM_IMPORT_PATTERN.test(searchable)) return false
   return (
     /\b<form\b[^>]*\b(?:action|formAction)\s*=/.test(searchable) ||
     /\bformAction\s*:\s*/.test(searchable) ||
     /<\s*[A-Za-z_$][\w$]*\b[^>]*\b(?:action|formAction)\s*=/.test(searchable)
-  );
+  )
 }
 
 // A next/headers or next/navigation request-hook import makes a route dynamic.
 function usesNextRequestImport(source: string): boolean {
-  const withoutComments = stripComments(source);
+  const withoutComments = stripComments(source)
   // A `draftMode`-only import of next/headers is not request-bound: Next still
   // fully prerenders such pages (isEnabled is false at build time); only a
   // __prerender_bypass cookie opts into a fresh dynamic render at request time.
   const draftModeOnlyImport =
-    /\bimport\s+\{\s*draftMode\s*(?:as\s+[\w$]+\s*)?,?\s*\}\s*from\s*['"]next\/headers(?:\.js)?['"]/g;
+    /\bimport\s+\{\s*draftMode\s*(?:as\s+[\w$]+\s*)?,?\s*\}\s*from\s*['"]next\/headers(?:\.js)?['"]/g
   return (
     nextHeadersImportPattern().test(withoutComments.replace(draftModeOnlyImport, '')) ||
     importsNextNavigationRequestHook(withoutComments)
-  );
+  )
 }
 
 function nextHeadersImportPattern() {
-  return /(?:from\s+|import\s*\()\s*['"]next\/headers(?:\.js)?['"]/;
+  return /(?:from\s+|import\s*\()\s*['"]next\/headers(?:\.js)?['"]/
 }
 
 function importsNextNavigationRequestHook(source: string): boolean {
-  const importPattern = /\bimport\s+(type\s+)?([^'";]+?)\s+from\s+['"]next\/navigation['"]/g;
-  let match: RegExpExecArray | null;
+  const importPattern = /\bimport\s+(type\s+)?([^'";]+?)\s+from\s+['"]next\/navigation['"]/g
+  let match: RegExpExecArray | null
   while ((match = importPattern.exec(source))) {
-    const [, typeKeyword, clause] = match;
+    const [, typeKeyword, clause] = match
     if (!typeKeyword && clause && includesRequestNavigationHook(importedExports(clause)))
-      return true;
+      return true
   }
 
-  const exportPattern = /\bexport\s+(type\s+)?\{([^}]*)\}\s+from\s+['"]next\/navigation['"]/g;
+  const exportPattern = /\bexport\s+(type\s+)?\{([^}]*)\}\s+from\s+['"]next\/navigation['"]/g
   while ((match = exportPattern.exec(source))) {
-    const [, typeKeyword, clause] = match;
-    if (!typeKeyword && clause && includesRequestNavigationHook(exportedNames(clause))) return true;
+    const [, typeKeyword, clause] = match
+    if (!typeKeyword && clause && includesRequestNavigationHook(exportedNames(clause))) return true
   }
-  return false;
+  return false
 }
 
 function usesNextServerConnection(source: string): boolean {
-  const withoutComments = stripComments(source);
-  const searchable = stripCommentsAndStrings(source);
-  const importPattern = /\bimport\s+(type\s+)?([^'";]+?)\s+from\s+['"]next\/server(?:\.js)?['"]/g;
-  let match: RegExpExecArray | null;
+  const withoutComments = stripComments(source)
+  const searchable = stripCommentsAndStrings(source)
+  const importPattern = /\bimport\s+(type\s+)?([^'";]+?)\s+from\s+['"]next\/server(?:\.js)?['"]/g
+  let match: RegExpExecArray | null
   while ((match = importPattern.exec(withoutComments))) {
-    const [, typeKeyword, clause] = match;
-    if (typeKeyword || !clause) continue;
+    const [, typeKeyword, clause] = match
+    if (typeKeyword || !clause) continue
     for (const pattern of importedConnectionCallPatterns(clause)) {
-      if (pattern.test(searchable)) return true;
+      if (pattern.test(searchable)) return true
     }
   }
-  return false;
+  return false
 }
 
 function importedConnectionCallPatterns(clause: string): RegExp[] {
-  const patterns: RegExp[] = [];
-  const namespace = /\*\s+as\s+([A-Za-z_$][\w$]*)/.exec(clause)?.[1];
-  if (namespace) patterns.push(new RegExp(`\\b${escapeRegex(namespace)}\\.connection\\s*\\(`));
-  const named = /\{([^}]*)\}/.exec(clause)?.[1];
+  const patterns: RegExp[] = []
+  const namespace = /\*\s+as\s+([A-Za-z_$][\w$]*)/.exec(clause)?.[1]
+  if (namespace) patterns.push(new RegExp(`\\b${escapeRegex(namespace)}\\.connection\\s*\\(`))
+  const named = /\{([^}]*)\}/.exec(clause)?.[1]
   if (named) {
     for (const item of named.split(',')) {
-      const [imported, local] = item.trim().split(/\s+as\s+/);
+      const [imported, local] = item.trim().split(/\s+as\s+/)
       if (imported?.trim() === 'connection') {
-        patterns.push(new RegExp(`\\b${escapeRegex((local ?? imported).trim())}\\s*\\(`));
+        patterns.push(new RegExp(`\\b${escapeRegex((local ?? imported).trim())}\\s*\\(`))
       }
     }
   }
-  return patterns;
+  return patterns
 }
 
 function includesRequestNavigationHook(exports: string[]): boolean {
   return (
     exports.includes('*') || exports.includes('useSearchParams') || exports.includes('useRoute')
-  );
+  )
 }
 
 function importedExports(clause: string): string[] {
-  const value = clause.trim();
-  if (!value) return [];
-  const exports = new Set<string>();
-  if (value.startsWith('*')) exports.add('*');
-  const defaultImport = /^[A-Za-z_$][\w$]*/.exec(value);
-  if (defaultImport && !value.startsWith('{') && !value.startsWith('*')) exports.add('default');
-  const named = /\{([^}]*)\}/.exec(value);
+  const value = clause.trim()
+  if (!value) return []
+  const exports = new Set<string>()
+  if (value.startsWith('*')) exports.add('*')
+  const defaultImport = /^[A-Za-z_$][\w$]*/.exec(value)
+  if (defaultImport && !value.startsWith('{') && !value.startsWith('*')) exports.add('default')
+  const named = /\{([^}]*)\}/.exec(value)
   if (named?.[1]) {
     for (const item of named[1].split(',')) {
-      const [name] = item.trim().split(/\s+as\s+/);
-      if (name) exports.add(name.trim());
+      const [name] = item.trim().split(/\s+as\s+/)
+      if (name) exports.add(name.trim())
     }
   }
-  return [...exports];
+  return [...exports]
 }
 
 function exportedNames(clause: string): string[] {
@@ -381,7 +384,7 @@ function exportedNames(clause: string): string[] {
         .split(/\s+as\s+/)[0]
         ?.trim(),
     )
-    .filter((name): name is string => Boolean(name) && name !== 'type');
+    .filter((name): name is string => Boolean(name) && name !== 'type')
 }
 
 /**
@@ -390,21 +393,21 @@ function exportedNames(clause: string): string[] {
  * each; the key is the source itself, so it never stales.
  */
 function memoizeBySource(derive: (source: string) => string) {
-  const cache = new Map<string, string>();
+  const cache = new Map<string, string>()
   return (source: string): string => {
-    const hit = cache.get(source);
-    if (hit !== undefined) return hit;
-    const value = derive(source);
-    if (cache.size >= 4) cache.delete(cache.keys().next().value!);
-    cache.set(source, value);
-    return value;
-  };
+    const hit = cache.get(source)
+    if (hit !== undefined) return hit
+    const value = derive(source)
+    if (cache.size >= 4) cache.delete(cache.keys().next().value!)
+    cache.set(source, value)
+    return value
+  }
 }
 
 const stripCommentsAndStrings = memoizeBySource(source =>
   stripComments(source).replace(/(['"`])(?:\\[\s\S]|(?!\1)[^\\])*\1/g, ''),
-);
+)
 
 const stripComments = memoizeBySource(source =>
   source.replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^:])\/\/.*$/gm, '$1'),
-);
+)