stylelint-plugin-rhythmguard 3.10.2 → 3.12.0

package/src/audit/report.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const fs = require('node:fs');
+const path = require('node:path');
 
 const {
   createTokenKindMatcher,
@@ -14,7 +14,7 @@ const { createDefaultAuditOptions } = require('./shared');
 const {
   applyAuditConfig,
   loadAuditConfig,
-  loadIgnorePatterns,
+  resolveIgnorePatterns,
 } = require('./config');
 const { buildReport, collectTokenDefinitions } = require('./contract');
 const { DEFAULT_SCALE, formatPath } = require('./shared');
@@ -27,22 +27,20 @@ const {
 const { applyDecisions, buildDecisionPlan } = require('./decisions');
 const { collectDeclarations, resolveTokenChains, toChainsContract } = require('./token-chains');
 const { resolveTokenLadders, toLaddersContract } = require('./token-ladders');
-const { assertDirectory, getScanFiles } = require('./scan/files');
+const { assertDirectory, getScanFiles, readSourceFromDisk } = require('./scan/files');
 const { collectCssFindings, runStylelintAudit } = require('./scan/stylesheets');
 const { collectTailwindFindings, collectTailwindMotionFindings } = require('./scan/templates');
 
 async function createAuditReport(options) {
   const parsed = normalizeCreateAuditOptions(options);
   const resolvedDir = assertDirectory(parsed.dir);
-  let ignorePatterns;
-  ignorePatterns = [
-    ...loadIgnorePatterns(parsed.ignorePath),
-    ...parsed.ignorePatterns,
-  ];
+  const ignorePatterns = resolveIgnorePatterns(parsed);
 
   const scanFiles = getScanFiles(resolvedDir, ignorePatterns, parsed);
 
   const { cssFiles, scanScope, templateFiles } = scanFiles;
+  // A --staged run reads each changed file as the index holds it.
+  const readSource = scanFiles.readSource || readSourceFromDisk;
 
   const tokenSourceResult = parseTokenSources({
     baseFontSize: parsed.baseFontSize,
@@ -50,23 +48,34 @@ async function createAuditReport(options) {
     tokenKind: parsed.tokenKind,
   });
 
+  // The spacing scale always reads spacing tokens; --token-kind shapes the token contract only (issue #260).
+  const spacingSourceResult = parsed.tokenKind === 'spacing'
+    ? tokenSourceResult
+    : parseTokenSources({ baseFontSize: parsed.baseFontSize, sources: parsed.tokenSources, tokenKind: 'spacing' });
+
   const scale = resolveAuditScale({
     baseFontSize: parsed.baseFontSize,
     cssFiles,
+    readSource,
     requested: parsed.scale,
-    tokenSourceResult,
+    tokenSourceResult: spacingSourceResult,
   });
 
   const lintOptions = {
     baseFontSize: parsed.baseFontSize,
     checkMathBounds: parsed.checkMathBounds,
     includeMotion: parsed.includeMotion,
+    readSource: scanFiles.readSource,
     scale: scale.values,
     scales: parsed.scales,
   };
 
   const cssResults = await runStylelintAudit(cssFiles, lintOptions);
-  const stylelintFindings = collectCssFindings(cssResults);
+  const collectedCssFindings = collectCssFindings(cssResults, readSource);
+  // A stylesheet that failed to parse was not audited; it is reported apart
+  // and is neither a finding nor a clean file.
+  const parseErrorFindings = collectedCssFindings.filter((finding) => finding.type === 'parse-error');
+  const stylelintFindings = collectedCssFindings.filter((finding) => finding.type !== 'parse-error');
   const decided = applyDecisions({
     baseFontSize: parsed.baseFontSize,
     cssFindings: stylelintFindings.filter((finding) => !finding.type.startsWith('motion-')),
@@ -88,6 +97,8 @@ async function createAuditReport(options) {
     externalTokenDefinitions: tokenSourceResult.definitions,
     includeMotion: parsed.includeMotion,
     motionFindings,
+    parseErrorFindings,
+    readSource,
     scale,
     scanScope,
     scssFiles: cssResults.scssFiles || 0,
@@ -104,11 +115,13 @@ async function createAuditReport(options) {
   const declarations = collectDeclarations({
     cssFiles,
     externalDefinitions: tokenSourceResult.definitions,
+    readSource,
     skipFile: (file) => NON_AUTHORED_SEGMENT.test(file),
   });
   report.tokenContract.chains = toChainsContract(resolveTokenChains({
     baseFontSize: parsed.baseFontSize,
     declarations,
+    references: collectDeclarations({ cssFiles: [], externalDefinitions: chainDefinitions(parsed) }),
     scale: scale.values,
   }));
   report.tokenContract.ladders = toLaddersContract(resolveTokenLadders({
@@ -127,17 +140,47 @@ async function createAuditReport(options) {
     scale: scale.values,
   });
 
-  if (parsed.sinceBaseline) {
-    applyBaselineComparison(report, parsed.baselinePath);
-  }
+  if (parsed.sinceBaseline || parsed.writeBaseline) {
+    const unauditedFiles = [
+      ...(cssResults.unauditedFiles || []),
+      ...parseErrorFindings.map((finding) => path.resolve(process.cwd(), finding.file)),
+    ];
+    const unaudited = new Set(unauditedFiles);
+    const baselineScope = {
+      auditedFiles: [...cssFiles, ...templateFiles].filter((file) => !unaudited.has(file)),
+      scanRoot: resolvedDir,
+      scoped: scanScope.mode !== 'full',
+      unauditedFiles,
+    };
+
+    if (parsed.sinceBaseline) {
+      applyBaselineComparison(report, parsed.baselinePath, baselineScope);
+    }
 
-  if (parsed.writeBaseline) {
-    writeBaseline(report, parsed.baselinePath);
+    if (parsed.writeBaseline) {
+      writeBaseline(report, parsed.baselinePath, baselineScope);
+    }
   }
 
   return report;
 }
 
+/**
+ * Every custom property a chain can end in: all tokens in the token sources,
+ * whatever --token-kind says and whatever name pattern a source sets, plus
+ * installed token packages (issue #259). A chain through `--size-8` or a
+ * package's `--space-2` resolves instead of reading "not declared"; these are
+ * looked up only, never reported as chains of their own.
+ */
+function chainDefinitions(parsed) {
+  const unfiltered = (source) => (source && typeof source === 'object' ? { ...source, tokenPattern: null } : source);
+  return parseTokenSources({
+    baseFontSize: parsed.baseFontSize,
+    sources: [...parsed.tokenSources, ...discoverTokenPackages(process.cwd())].map(unfiltered),
+    tokenKind: 'all',
+  }).definitions;
+}
+
 const NON_AUTHORED_SEGMENT = /(^|\/)(test|tests|__tests__|spec|specs|fixtures?|__fixtures__|__snapshots__|vendor|third[-_]?party|storybook-static)(\/|$)/i;
 
 /**
@@ -145,7 +188,7 @@ const NON_AUTHORED_SEGMENT = /(^|\/)(test|tests|__tests__|spec|specs|fixtures?|_
  * "auto": external token sources, then spacing custom properties across the scanned
  * CSS, then the default scale. First source that yields values wins.
  */
-function resolveAuditScale({ baseFontSize, cssFiles, requested, tokenSourceResult }) {
+function resolveAuditScale({ baseFontSize, cssFiles, readSource = readSourceFromDisk, requested, tokenSourceResult }) {
   if (Array.isArray(requested)) {
     return {
       files: [],
@@ -178,7 +221,7 @@ function resolveAuditScale({ baseFontSize, cssFiles, requested, tokenSourceResul
     }
     let text;
     try {
-      text = fs.readFileSync(filePath, 'utf8');
+      text = readSource(filePath);
     } catch {
       continue;
     }

package/src/audit/scan/files.js

@@ -77,39 +77,39 @@ function getScanFiles(rootDir, ignorePatterns, parsed) {
 }
 
 function getGitChangedScanFiles(rootDir, ignorePatterns, parsed) {
-  const args = parsed.staged
-    ? ['diff', '--name-only', '--cached', '--diff-filter=ACMR', '--']
-    : ['diff', '--name-only', '--diff-filter=ACMR', parsed.since, '--'];
-  let output;
-
-  try {
-    output = execFileSync('git', args, {
-      cwd: process.cwd(),
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-  } catch (err) {
-    const stderr = err.stderr ? String(err.stderr).trim() : err.message;
-    throw new Error(`Unable to read changed files from git: ${stderr}`, { cause: err });
-  }
-
+  // Git runs in the scanned directory, so the repository is the one that holds
+  // the files, whichever directory the command was started from.
+  const topLevel = runGit(rootDir, ['rev-parse', '--show-toplevel']).replace(/\r?\n$/, '');
+  const changed = parsed.staged
+    ? listStagedFiles(rootDir)
+    : listFilesChangedSince(rootDir, parsed.since);
+
+  // git reports the top level with symlinks resolved (/private/var on macOS);
+  // compare in that form, then name files under the directory as it was given.
+  const realRootDir = fs.realpathSync(rootDir);
   const cssFiles = [];
   const templateFiles = [];
   const ignoreMatchers = createIgnoreMatchers(ignorePatterns);
   const seen = new Set();
-  const changedFiles = output.split(/\r?\n/)
-    .map((filePath) => filePath.trim())
-    .filter(Boolean);
-
-  for (const filePath of changedFiles) {
-    const fullPath = path.resolve(process.cwd(), filePath);
+  const stagedBlobs = new Map();
 
-    if (!isPathInside(rootDir, fullPath) || seen.has(fullPath) || !fs.existsSync(fullPath)) {
+  for (const entry of changed) {
+    const realPath = path.resolve(topLevel, entry.path);
+    if (!isPathInside(realRootDir, realPath)) {
+      continue;
+    }
+    const fullPath = path.join(rootDir, path.relative(realRootDir, realPath));
+    if (seen.has(fullPath)) {
       continue;
     }
 
-    const stat = fs.statSync(fullPath);
-    if (!stat.isFile()) {
+    if (parsed.staged) {
+      // The index entry is what gets committed: a regular file blob, whatever
+      // the working tree holds now, or whether the file is still there at all.
+      if (!REGULAR_FILE_MODES.has(entry.mode)) {
+        continue;
+      }
+    } else if (!fs.existsSync(fullPath) || !fs.statSync(fullPath).isFile()) {
       continue;
     }
 
@@ -123,18 +123,143 @@ function getGitChangedScanFiles(rootDir, ignorePatterns, parsed) {
       cssFiles.push(fullPath);
     } else if (isTemplateFile(fullPath)) {
       templateFiles.push(fullPath);
+    } else {
+      continue;
+    }
+    if (parsed.staged) {
+      stagedBlobs.set(fullPath, entry.blob);
     }
   }
 
-  return {
+  const result = {
     cssFiles,
     scanScope: {
-      changedFiles: changedFiles.length,
+      changedFiles: changed.length,
       mode: parsed.staged ? 'staged' : 'since',
       since: parsed.since,
     },
     templateFiles,
   };
+
+  if (parsed.staged) {
+    result.readSource = createStagedSourceReader(rootDir, stagedBlobs);
+  }
+
+  return result;
+}
+
+const REGULAR_FILE_MODES = new Set(['100644', '100755']);
+
+// -z prints names raw and NUL-separated: no quoting of spaces or non-ASCII
+// bytes. diff.relative is pinned off so every name is relative to the
+// repository top level, whatever the user's git config says.
+function listFilesChangedSince(rootDir, since) {
+  const output = runGit(rootDir, ['-c', 'diff.relative=false', 'diff', '--name-only', '-z', '--diff-filter=ACMR', since, '--']);
+  return output.split('\0').filter(Boolean).map((filePath) => ({ path: filePath }));
+}
+
+/**
+ * Staged files with the mode and blob id the index holds for each. `--raw -z`
+ * prints `:<old mode> <new mode> <old id> <new id> <status>` and then the path,
+ * or two paths (from, then to) for a rename or a copy.
+ */
+function listStagedFiles(rootDir) {
+  const output = runGit(rootDir, [
+    '-c', 'diff.relative=false',
+    'diff', '--cached', '--raw', '-z', '--no-abbrev', '--no-color', '--diff-filter=ACMR', '--',
+  ]);
+  const fields = output.split('\0');
+  const entries = [];
+  for (let index = 0; index < fields.length; index++) {
+    const header = fields[index];
+    if (!header.startsWith(':')) {
+      continue;
+    }
+    const [, mode, , blob, status = ''] = header.slice(1).split(' ');
+    const pathCount = /^[RC]/.test(status) ? 2 : 1;
+    const filePath = fields[index + pathCount];
+    index += pathCount;
+    if (filePath) {
+      entries.push({ blob, mode, path: filePath });
+    }
+  }
+  return entries;
+}
+
+/**
+ * Reads staged files from their index blobs, fetched in one `git cat-file
+ * --batch` call, and any other path from disk. Each blob comes back as a
+ * `<id> blob <size>` line followed by exactly <size> bytes and a newline.
+ */
+function createStagedSourceReader(rootDir, stagedBlobs) {
+  const contents = new Map();
+  const ids = Array.from(new Set(stagedBlobs.values()));
+  if (ids.length > 0) {
+    const output = runGit(rootDir, ['cat-file', '--batch'], `${ids.join('\n')}\n`, null);
+    const byId = new Map();
+    let offset = 0;
+    while (offset < output.length) {
+      const headerEnd = output.indexOf(0x0a, offset);
+      if (headerEnd === -1) {
+        break;
+      }
+      const [id, type, size] = output.subarray(offset, headerEnd).toString('utf8').split(' ');
+      offset = headerEnd + 1;
+      if (type !== 'blob') {
+        continue;
+      }
+      const length = Number(size);
+      byId.set(id, output.subarray(offset, offset + length).toString('utf8'));
+      offset += length + 1;
+    }
+    for (const [filePath, id] of stagedBlobs) {
+      if (byId.has(id)) {
+        contents.set(filePath, byId.get(id));
+      }
+    }
+  }
+
+  return (filePath) => (contents.has(filePath)
+    ? contents.get(filePath)
+    : readSourceFromDisk(filePath));
+}
+
+/** Reads a scanned file from disk. A staged run swaps in a reader for the index. */
+function readSourceFromDisk(filePath) {
+  return fs.readFileSync(filePath, 'utf8');
+}
+
+/**
+ * The repository top level for a directory, with symlinks resolved, or null
+ * when the directory is not inside a git work tree (or git is not installed).
+ */
+function findGitTopLevel(dir) {
+  try {
+    const output = execFileSync('git', ['rev-parse', '--show-toplevel'], {
+      cwd: dir,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).replace(/\r?\n$/, '');
+    return output ? path.resolve(output) : null;
+  } catch {
+    return null;
+  }
+}
+
+// With `encoding` null the output comes back as a Buffer (blob sizes are bytes).
+function runGit(cwd, args, input, encoding = 'utf8') {
+  try {
+    return execFileSync('git', args, {
+      cwd,
+      encoding,
+      input,
+      maxBuffer: 1024 * 1024 * 1024,
+      stdio: [input === undefined ? 'ignore' : 'pipe', 'pipe', 'pipe'],
+    });
+  } catch (err) {
+    const stderr = err.stderr ? String(err.stderr).trim() : err.message;
+    throw new Error(`Unable to read changed files from git: ${stderr}`, { cause: err });
+  }
 }
 
 function isPathInside(rootDir, filePath) {
@@ -247,6 +372,7 @@ module.exports = {
   assertDirectory,
   createIgnoreMatchers,
   escapeRegExp,
+  findGitTopLevel,
   getGitChangedScanFiles,
   getScanFiles,
   globToRegExp,
@@ -255,6 +381,7 @@ module.exports = {
   isPathInside,
   isScssFile,
   isTemplateFile,
+  readSourceFromDisk,
   shouldIgnorePath,
   shouldIgnoreRelativeFile,
   toPosixRelativePath,

package/src/audit/scan/stylesheets.js

@@ -5,13 +5,13 @@
  * warning into a finding, and recover the CSS property at the warning position
  * from the source, since Stylelint reports positions rather than nodes.
  */
-const fs = require('node:fs');
+const path = require('node:path');
 const {
   DEFAULT_AUDIT_TOKEN_PATTERN,
   formatPath,
   pluginPath,
 } = require('../shared');
-const { isScssFile } = require('./files');
+const { isScssFile, readSourceFromDisk } = require('./files');
 
 let scssSyntaxCache;
 
@@ -37,6 +37,8 @@ async function runStylelintAudit(cssFiles, options) {
     const empty = [];
     empty.scssFiles = 0;
     empty.scssSkipped = 0;
+    empty.stylelintIgnored = 0;
+    empty.unauditedFiles = [];
     return empty;
   }
 
@@ -80,56 +82,106 @@ async function runStylelintAudit(cssFiles, options) {
   const scssFiles = cssFiles.filter(isScssFile);
   const results = [];
 
+  // A project's own .stylelintignore may exclude every file we pass; that is
+  // a count to report, not a reason for the audit to throw.
+  const lint = (files, config) => (options.readSource
+    ? lintSources(stylelint, files, config, options.readSource)
+    : stylelint.lint({ allowEmptyInput: true, config, files }).then((result) => result.results || []));
+
   if (plainFiles.length > 0) {
-    // A project's own .stylelintignore may exclude every file we pass; that is
-    // a count to report, not a reason for the audit to throw.
-    const result = await stylelint.lint({
-      allowEmptyInput: true,
-      files: plainFiles,
-      config: {
-        plugins: [pluginPath],
-        rules,
-      },
-    });
-    results.push(...(result.results || []));
+    results.push(...await lint(plainFiles, { plugins: [pluginPath], rules }));
   }
 
-  let scssSkipped = 0;
+  let skippedScssFiles = [];
   if (scssFiles.length > 0) {
     const scssSyntax = resolveScssSyntax();
     if (scssSyntax) {
-      const result = await stylelint.lint({
-        allowEmptyInput: true,
-        files: scssFiles,
-        config: {
-          customSyntax: scssSyntax,
-          plugins: [pluginPath],
-          rules,
-        },
-      });
-      results.push(...(result.results || []));
+      results.push(...await lint(scssFiles, { customSyntax: scssSyntax, plugins: [pluginPath], rules }));
     } else {
-      scssSkipped = scssFiles.length;
+      skippedScssFiles = scssFiles;
     }
   }
 
-  results.scssFiles = scssFiles.length;
-  results.scssSkipped = scssSkipped;
+  assertNoInvalidOptions(results);
+
   // Stylelint returns no result at all for a file its ignore file excludes, so
-  // the difference between what was passed and what came back is that count.
-  const linted = plainFiles.length + scssFiles.length - scssSkipped;
-  results.stylelintIgnored = Math.max(0, linted - results.length);
+  // a file passed in with no result back is one it ignored.
+  const returned = new Set(results.map((result) => path.resolve(String(result.source))));
+  const skipped = new Set(skippedScssFiles);
+  const ignoredFiles = cssFiles.filter((file) => !skipped.has(file) && !returned.has(path.resolve(file)));
+
+  results.scssFiles = scssFiles.length;
+  results.scssSkipped = skippedScssFiles.length;
+  results.stylelintIgnored = ignoredFiles.length;
+  // Neither kind was audited: they count as neither scanned nor clean.
+  results.unauditedFiles = [...skippedScssFiles, ...ignoredFiles];
   return results;
 }
 
-function collectCssFindings(fileResults) {
+/** Lints each file from the text the reader returns (the staged blob in a --staged run). */
+async function lintSources(stylelint, files, config, readSource) {
+  const results = [];
+  for (const file of files) {
+    let code;
+    try {
+      code = readSource(file);
+    } catch {
+      continue;
+    }
+    const result = await stylelint.lint({ allowEmptyInput: true, code, codeFilename: file, config });
+    results.push(...(result.results || []));
+  }
+  return results;
+}
+
+/**
+ * Stylelint does not run a rule whose options it rejects: it reports an
+ * invalidOptionWarning and no findings for that rule. Read as findings, that is
+ * a clean audit and a passing gate, so any rejected option stops the run.
+ */
+function assertNoInvalidOptions(results) {
+  const texts = new Set();
+  for (const result of results) {
+    for (const warning of result.invalidOptionWarnings || []) {
+      texts.add(warning.text);
+    }
+  }
+
+  if (texts.size > 0) {
+    throw new Error(`Stylelint rejected the audit's rule options, so no findings could be collected: ${Array.from(texts).join('; ')}`);
+  }
+}
+
+/**
+ * Stylelint reports a stylesheet it cannot parse as a single CssSyntaxError
+ * warning and runs no rule on it. That is not drift: it is a file the audit
+ * could not read, kept apart as a `parse-error` finding.
+ */
+function isParseErrorWarning(warning) {
+  return warning.rule === 'CssSyntaxError';
+}
+
+function collectCssFindings(fileResults, readSource) {
   const findings = [];
   const sources = new Map();
 
   for (const fileResult of fileResults) {
     for (const warning of fileResult.warnings || []) {
       const text = warning.text || '';
-      const source = readSourceOnce(sources, fileResult.source);
+      if (isParseErrorWarning(warning)) {
+        findings.push({
+          column: warning.column || 1,
+          file: formatPath(fileResult.source),
+          line: warning.line || 1,
+          property: null,
+          rule: warning.rule,
+          text,
+          type: 'parse-error',
+          value: null,
+        });
+        continue;
+      }
+      const source = readSourceOnce(sources, fileResult.source, readSource);
       const offScaleMatch = text.match(
         /Unexpected (?:off-scale (?:value|(?:clamp|min|max)\(\) (?:minimum|maximum|argument))|transform translation value) "([^"]+)"/,
       );
@@ -166,13 +218,13 @@ function collectCssFindings(fileResults) {
   return findings;
 }
 
-function readSourceOnce(cache, filePath) {
+function readSourceOnce(cache, filePath, readSource = readSourceFromDisk) {
   if (!filePath) {
     return null;
   }
   if (!cache.has(filePath)) {
     try {
-      cache.set(filePath, fs.readFileSync(filePath, 'utf8'));
+      cache.set(filePath, readSource(filePath));
     } catch {
       cache.set(filePath, null);
     }
@@ -281,6 +333,7 @@ module.exports = {
   findDeclarationProperty,
   getCssFindingType,
   getCssFindingValue,
+  isParseErrorWarning,
   positionToOffset,
   readSourceOnce,
   resolveScssSyntax,

package/src/audit/scan/templates.js

@@ -20,7 +20,7 @@ function collectTailwindFindings(templateFiles, options) {
   for (const filePath of templateFiles) {
     let source;
     try {
-      source = fs.readFileSync(filePath, 'utf8');
+      source = options.readSource ? options.readSource(filePath) : fs.readFileSync(filePath, 'utf8');
     } catch {
       continue;
     }
@@ -66,7 +66,7 @@ function collectTailwindMotionFindings(templateFiles, options) {
   for (const filePath of templateFiles) {
     let source;
     try {
-      source = fs.readFileSync(filePath, 'utf8');
+      source = options.readSource ? options.readSource(filePath) : fs.readFileSync(filePath, 'utf8');
     } catch {
       continue;
     }
@@ -122,15 +122,28 @@ function buildTailwindMotionFindingText(token, analysis) {
  * bundle that took hours. This walks the source once: an escape never closes a
  * literal, a ' or " literal that reaches a line break is not a literal (the
  * language agrees), and a backtick literal may span lines.
+ *
+ * Class strings also sit inside other literals: a ternary in a template
+ * literal's ${}, a Vue :class="{ 'p-2': on }" object, a Svelte {expression}
+ * inside class="...". After a literal closes, its value is scanned again for
+ * literals in the other quote kinds. A literal never holds its own quote
+ * unescaped, so each level drops one quote kind: at most three levels, and
+ * every character is read at most three times.
  */
+const QUOTES = ['"', "'", '`'];
+
 function findStringLiterals(source) {
   const literals = [];
-  const { length } = source;
-  let index = 0;
+  scanStringLiterals(source, 0, source.length, QUOTES, literals);
+  return literals;
+}
+
+function scanStringLiterals(source, start, length, quotes, literals) {
+  let index = start;
 
   while (index < length) {
     const quote = source[index];
-    if (quote !== '"' && quote !== "'" && quote !== '`') {
+    if (!quotes.includes(quote)) {
       index += 1;
       continue;
     }
@@ -156,13 +169,15 @@ function findStringLiterals(source) {
 
     if (closed) {
       literals.push({ quote, value: source.slice(valueStart, cursor), valueStart });
+      const innerQuotes = quotes.filter((candidate) => candidate !== quote);
+      if (innerQuotes.length > 0) {
+        scanStringLiterals(source, valueStart, cursor, innerQuotes, literals);
+      }
       index = cursor + 1;
     } else {
       index = valueStart;
     }
   }
-
-  return literals;
 }
 
 function getLineStarts(source) {