@vernikr/size-report 1.2.0 → 1.3.0

package/src/project.js

@@ -0,0 +1,262 @@
+import fs from 'fs';
+import path from 'path';
+import { execFileSync } from 'child_process';
+import { MAX_BUF, git, gitArgv, gitEnv, gitTry, readHistory } from './git.js';
+import { cliCommand, invocation } from './refusal.js';
+
+/* Настройки, выведенные из самого проекта: что считать, где журнал, куда писать и
+ * что колонкой быть не может.
+ *
+ * Зачем отдельно от `src/config.js`. Тот читает **готовые** настройки и только
+ * затем их проверяет, а этот смотрит на проект впервые и почти всё о нём
+ * догадывается — та же работа, что была у черновика (`--init`). Отсюда две роли
+ * одного вывода: без файла настроек он и есть настройки (проект работает сразу,
+ * ничего не заводив), а с `--init` он же ложится файлом, который дальше правят.
+ * Второго вывода «как угадать проект» в пакете нет.
+ *
+ * Два правила, из которых выведено всё остальное.
+ *
+ * **Колонка — это файл.** Состояние движка хранит на колонку один путь, а список
+ * путей колонки — её переименования (в ревизии берётся тот, который в ней есть).
+ * Поэтому «папка целиком» колонкой быть не может, и профиль выбирает файлы, а не
+ * группы путей.
+ *
+ * **Профиль обязан проходить ту же проверку, которой его встретит первый запуск**
+ * (BLOCKERS §N2, REFACTOR R-0.4): путь, не ставший колонкой и не объявленный
+ * исключением, — это код 1 на первом же прогоне. Поэтому `skip` называет и то,
+ * что колонкой быть не может (сам отчёт, замки зависимостей, карты, собранное), и
+ * то, что в колонки не поместилось: так первый `check` зелёный, а что не попало в
+ * отчёт — сказано в файле, а не умолчано.
+ */
+
+/* Что вообще берётся колонкой: текстовые формы, с которыми движок умеет работать.
+ * Файл без знакомого расширения (`LICENSE`, `.gitignore`) колонкой не становится и
+ * называется исключением. */
+const KNOWN_EXTS = ['.js', '.mjs', '.cjs', '.ts', '.tsx', '.jsx', '.html', '.css', '.scss',
+  '.json', '.yaml', '.yml', '.toml', '.md', '.txt', '.py', '.rb', '.go', '.rs', '.sh'];
+
+const JOURNALS = ['WORKLOG.md', 'CHANGELOG.md', 'CHANGES.md', 'HISTORY.md'];
+
+/* Порог по размеру — предохранитель: очень крупный файл в истории обычно собран или
+ * сгенерирован, и в отчёте он перевесил бы весь проект. */
+const MAX_BYTES = 512 * 1024;
+
+/* Сколько файлов идут колонками: отчёт читают глазами, а сотня колонок читается
+ * хуже, чем скачок. Остальное остаётся на виду — в `skip`, откуда его берут
+ * колонкой, когда оно важно. */
+const COLUMN_LIMIT = 12;
+
+/* Индекс — путь и размер: `ls-files -s` даёт объекты, размер спрашивается у них
+ * одной пачкой (`cat-file --batch-check`), а не чтением содержимого. */
+function indexFiles(root) {
+  const listed = git(root, ['ls-files', '-s']).split('\n').filter((l) => l !== '');
+  const sizes = new Map();
+  const shas = listed.map((l) => l.split(/\s+/)[1]);
+  if (shas.length > 0) {
+    const checked = execFileSync('git', gitArgv(['cat-file', '--batch-check=%(objectname)\t%(objectsize)']), {
+      cwd: root, encoding: 'utf8', input: shas.join('\n') + '\n', maxBuffer: MAX_BUF, env: gitEnv()
+    });
+    checked.split('\n').forEach((l) => {
+      const [sha, size] = l.split('\t');
+      sizes.set(sha, Number(size));
+    });
+  }
+  return listed.map((line) => ({ p: line.split('\t')[1], size: sizes.get(line.split(/\s+/)[1]) || 0 }));
+}
+
+/* История — объединение путей всех коммитов, тем же чтением, которым пользуется
+ * полнота (`readHistory`): иначе профиль и `check` считали бы разные истории. Файл,
+ * живущий только в истории, в отчёте просто пуст на HEAD — это не потеря, а факт, и
+ * колонкой (или исключением) он быть обязан. */
+function historyPaths(root) {
+  const seen = new Set();
+  try {
+    readHistory(root).forEach((c) => c.files.forEach((f) => seen.add(f)));
+  } catch (e) {
+    // У репозитория без коммитов истории нет вовсе: `git log` там отказывает, и
+    // это состояние проекта, а не дефект инструмента — `--init` обязан работать и
+    // в нём (первый запуск бывает и до первого коммита).
+    if (/does not have any commits/.test(String(e.stderr))) return seen;
+    throw e;
+  }
+  return seen;
+}
+
+// Дерево и история — одним списком: колонкой становится всё, что тронула история.
+function allPaths(root) {
+  const files = indexFiles(root);
+  const known = new Set(files.map((f) => f.p));
+  historyPaths(root).forEach((p) => {
+    if (!known.has(p)) files.push({ p: p, size: 0 });
+  });
+  return files;
+}
+
+// Наличие каталога решает, куда ляжет отчёт: рядом с доками или в корне.
+function exists(root, p) {
+  return fs.existsSync(path.join(root, p));
+}
+
+function outputOf(root) {
+  return (exists(root, 'docs') ? 'docs/' : '') + 'size-table.html';
+}
+
+/* Менеджер пакетов — по lock-файлу, а не догадкой: команда обязана существовать
+ * в чужом проекте. Один на два места (команду починки и подсказку `--init`). */
+export function packageManager(root) {
+  if (exists(root, 'pnpm-lock.yaml')) return 'pnpm';
+  return exists(root, 'yarn.lock') ? 'yarn' : 'npm';
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch (_e) {
+    return null;
+  }
+}
+
+/* Подпись артефакта и отказы цитируют эту команду, поэтому она обязана работать
+ * здесь и сейчас: свой скрипт — только если он объявлен (иначе `npm run sizes`
+ * отвечает «нет такого скрипта», а совет, который не работает, — худшая подсказка),
+ * иначе — установленный пакет внутри проекта. Имени пакета в команде нет намеренно:
+ * `npx <имя>` без установленного пакета уходит в реестр и запускает чужой код
+ * (REFACTOR R-4.21). */
+function fixCommandOf(root) {
+  const pkg = readJson(path.join(root, 'package.json')) || {};
+  const script = pkg.scripts === undefined ? '' : pkg.scripts.sizes;
+  if (typeof script !== 'string' || script === '') return invocation() + ' --write';
+  return packageManager(root) + ' run sizes';
+}
+
+/* Ссылка на коммит — из адреса origin: два хозяина собирают её одним правилом из
+ * владельца и пути к репозиторию (у GitLab в пути бывают подгруппы, поэтому путь
+ * берётся целиком), а всякий третий хозяин — догадка, которая ведёт не туда.
+ * Remote нет или он не тот — ссылок нет: пустой шаблон строка просто не несёт. */
+const REMOTE_RE = /^\S+?(?:@|\/\/)(?:[^@/]*@)?(github\.com|gitlab\.com)[/:]+((?:[^/\s]+\/)*[^/\s]+?)(?:\.git)?$/;
+
+function commitUrlOf(root) {
+  const m = gitTry(root, ['remote', 'get-url', 'origin']).stdout.trim().match(REMOTE_RE);
+  if (m === null) return '';
+  const shape = m[1] === 'github.com' ? '/commit/{sha}' : '/-/commit/{sha}';
+  return 'https://' + m[1] + '/' + m[2] + shape;
+}
+
+function journalOf(root) {
+  return JOURNALS.find((p) => exists(root, p)) || '';
+}
+
+/* Колонкой не становится: сам отчёт (его размер зависит от числа строк, то есть от
+ * себя), замки зависимостей (их размер — про чужие пакеты), карты и собранное (их
+ * сделала сборка, а не человек) и всё, чего движок не умеет читать. */
+function generated(p, output) {
+  const ext = path.extname(p).toLowerCase();
+  return p === output || KNOWN_EXTS.indexOf(ext) < 0
+    || /(?:^|\/)(?:package-lock\.json|pnpm-lock\.yaml|npm-shrinkwrap\.json|yarn\.lock|composer\.lock|bun\.lockb)$/.test(p)
+    || /\.min\./.test(p) || /\.map$/.test(p);
+}
+
+/* Метка колонки — имя файла; совпадение имён в разных папках разводится путём, а
+ * если и путь занят — числом. Повтор метки проверка настроек не пропустит. */
+function labelFor(used, p) {
+  const candidates = [path.basename(p), p];
+  const free = candidates.find((name) => used.indexOf(name) < 0);
+  if (free !== undefined) return free;
+  let n = 2;
+  while (used.indexOf(p + ' (' + n + ')') >= 0) n++;
+  return p + ' (' + n + ')';
+}
+
+/* Выбор колонок: по кругу от каждого расширения берётся его крупнейший файл — иначе
+ * в отчёте оказались бы одни крупные `.md`, и ни один `.js` не попал бы под
+ * настоящее сжатие (первый отчёт нового проекта обязан быть точным, а не
+ * приближённым). Порядок круга — по весу расширения: сперва то, чего в проекте
+ * больше всего. */
+function columnsOf(files, journal) {
+  const byExt = new Map();
+  files.forEach((f) => {
+    const ext = path.extname(f.p).toLowerCase();
+    const list = byExt.get(ext) || [];
+    list.push(f);
+    byExt.set(ext, list);
+  });
+  const rings = [...byExt.values()].map((list) => list.sort((a, b) => b.size - a.size));
+  const used = [];
+  const columns = [];
+  const take = (p) => {
+    columns.push({ label: labelFor(used, p), paths: [p] });
+    used.push(columns[columns.length - 1].label);
+  };
+  if (journal !== '' && files.some((f) => f.p === journal)) take(journal);
+  for (let round = 0; columns.length < COLUMN_LIMIT; round++) {
+    const before = columns.length;
+    rings.forEach((ring) => {
+      const f = ring[round];
+      if (f !== undefined && columns.length < COLUMN_LIMIT && f.p !== journal) take(f.p);
+    });
+    if (columns.length === before) break;
+  }
+  return columns;
+}
+
+export function projectConfig(root) {
+  const output = outputOf(root);
+  const journal = journalOf(root);
+  const files = allPaths(root);
+  const readable = files.filter((f) => !generated(f.p, output) && f.size <= MAX_BYTES);
+  const columns = columnsOf(readable, journal);
+  const taken = new Set(columns.reduce((all, c) => all.concat(c.paths), []));
+  // Язык, заголовок, порядок строк и выключатель хука не выводятся ни из чего:
+  // они берутся из умолчаний (`DEFAULT_CONFIG`), а не выдаются за вывод из проекта.
+  return {
+    output: output,
+    fixCommand: fixCommandOf(root),
+    metrics: ['raw', 'min', 'tok'],
+    // Настоящее сжатие и настоящий словарь, а не приближения: новый проект не должен
+    // начинать с чисел, которые честны наполовину. Без необязательной зависимости
+    // метрика отступает к другому счёту и прогон возвращает код 4 — это сказано
+    // подписью метрики, а не умолчанием.
+    minify: { engine: 'esbuild' },
+    tokens: { family: 'openai', encoding: 'o200k_base' },
+    columns: columns,
+    journal: journal === '' ? null : {
+      path: journal,
+      url: (path.dirname(output) === '.' ? '' : '../') + journal,
+      pattern: '^## (?<id>\\S+)\\s+(?<title>.+?)\\s*$',
+      anchor: 'heading'
+    },
+    links: { commitUrl: commitUrlOf(root) },
+    // Исключения — всё, что колонкой не стало: и то, что ею быть не может, и то, что
+    // в отчёт не поместилось. Так первый запуск полон, а непоместившееся названо.
+    skip: [output].concat(files.filter((f) => !taken.has(f.p)).map((f) => f.p))
+      .filter((p, i, all) => all.indexOf(p) === i)
+  };
+}
+
+/* Имя черновика (`sniffColumns`) осталось публичным: на него опираются те, кто звал
+ * вывод колонок (`test/api.test.js` держит список имён), и форма ответа та же —
+ * колонки, знакомые расширения проекта и сколько путей всего. */
+export function sniffColumns(root) {
+  const files = allPaths(root);
+  const exts = [...new Set(files.map((f) => path.extname(f.p).toLowerCase()))]
+    .filter((e) => KNOWN_EXTS.indexOf(e) >= 0).sort();
+  return { columns: projectConfig(root).columns, exts: exts, total: files.length };
+}
+
+/* Что сказать человеку, когда настроек нет и работать пришлось на выведенных: одна
+ * строка про то, что вышло, и одна — про то, чем это закрепить. Текст — тем же
+ * списком, что и находка `doctor`: два ответа об одном не должны разойтись словами. */
+export function derivedSummary(cfg) {
+  const labels = cfg.columns.map((c) => c.label);
+  return 'настройки выведены из проекта (файла нет): колонок ' + cfg.columns.length
+    + ' (' + labels.slice(0, 5).join(', ') + (labels.length > 5 ? ', …' : '') + '),'
+    + ' исключено путей ' + cfg.skip.length;
+}
+
+export function derivedLines(cfg) {
+  return [
+    '! ' + derivedSummary(cfg),
+    '  закрепить их файлом (дальше правьте как удобно; иначе состав колонок меняется'
+      + ' от прогона к прогону): ' + cliCommand('--init')
+  ];
+}

package/src/refusal.js

@@ -108,7 +108,7 @@ export const USAGE = [
   '  hook-run          то, что зовёт хук: пересборка и коммит отчёта (вручную не нужно)',
   '',
   'Режимы:',
-  '  --init [файл]   черновик настроек (--force — перезаписать существующий)',
+  '  --init [файл]   закрепить настройки файлом (--force — перезаписать существующий)',
   '  --write         собрать таблицу в файл из настроек',
   '  --data          данные контракта в stdout — для страницы и для агента',
   '  --page [файл]   страница отчёта (по умолчанию рядом с таблицей)',
@@ -124,6 +124,11 @@ export const USAGE = [
   'Запуск один: команда и режим не совмещаются, режим тоже один, и лишнее слово',
   'вместе с незнакомым ключом — отказ с готовой командой, а не обычный прогон.',
   '',
+  'Настройки заводить не обязательно: без файла они выводятся из самого проекта',
+  '(колонки — по группам путей из дерева и истории, журнал и куда писать — оттуда же),',
+  'и об этом сказано в выводе. «--init» закрепляет выведенное файлом — дальше правят его;',
+  'файл, названный ключом «--config», обязан быть, иначе — отказ.',
+  '',
   'Коды выхода: 0 — всё хорошо, 1 — расхождение с историей или неполнота, 2 — вызов,',
   'настройки или окружение, 3 — неполная история, 4 — нет датчика, 5 — внутренняя',
   'ошибка. У doctor свой порядок: 2, 3, 1, 4 — по важности находки, а не по тому,',

package/src/render.js

@@ -65,13 +65,13 @@ export function noteText(rows, cfg) {
     + fill(loc.note.rows, { rows: rows.length, command: cfg.fixCommand });
 }
 
-export function render(rows, cfg) {
-  const loc = LOCALES[cfg.locale];
+/* Шапка таблицы: строка групп (итог и колонки) и под ней строка метрик. */
+function tableHead(cfg, loc) {
   const metrics = cfg.metrics;
   const groupHead = (label, cls) => '<th colspan="' + metrics.length + '" class="' + cls + '">' + esc(label) + '</th>';
   const subHead = () => metrics.map((m, i) => '<th' + (i === 0 ? ' class="g"' : '') + '>'
     + esc(METRICS[m].label) + '</th>').join('');
-  const head = '<tr>'
+  return '<tr>'
     + '<th rowspan="2" class="c-commit">' + esc(loc.commit) + '</th>'
     + groupHead(loc.total, 'g')
     + cfg.columns.map((c) => groupHead(c.label, 'g')).join('')
@@ -79,11 +79,17 @@ export function render(rows, cfg) {
     + subHead()
     + cfg.columns.map(() => subHead()).join('')
     + '</tr>';
+}
 
-  /* Дельта считается к предыдущему коммиту (в списке ниже он идёт строкой ниже),
-   * а появление файла — рост на весь его объём: иначе сумма дельт по колонке не
-   * сходилась бы с текущим размером, и верхняя строка была бы недоказуемой. Всё
-   * это считает `rowModel` — тот же, что и на странице. */
+/* Тело таблицы: строки-коммиты сверху вниз — от старых к новым, — а над ними
+ * строка «сейчас» с абсолютными размерами.
+ *
+ * Дельта считается к предыдущему коммиту (в списке ниже он идёт строкой ниже),
+ * а появление файла — рост на весь его объём: иначе сумма дельт по колонке не
+ * сходилась бы с текущим размером, и верхняя строка была бы недоказуемой. Всё
+ * это считает `rowModel` — тот же, что и на странице. */
+function tableBody(rows, cfg, loc) {
+  const metrics = cfg.metrics;
   const cellsHtml = (make) => (cells) => cells.map((c, mi) => make(c, mi === 0)).join('');
   const rowCells = cellsHtml((c, first) => cellHtml(c, first));
   const nowCells = cellsHtml((v, first) => valueHtml(v, first));
@@ -94,12 +100,15 @@ export function render(rows, cfg) {
       + blocksHtml(rowModel(row.cells, prev === null ? null : prev.cells, metrics), rowCells)
       + '</tr>';
   }).reverse().join('\n');
-
   const nowRow = rows.length === 0 ? '' : '<tr class="now">'
     + '<th class="c-commit">' + esc(loc.now) + '</th>'
     + blocksHtml(nowModel(rows[rows.length - 1].cells, metrics), nowCells)
     + '</tr>';
+  return nowRow + '\n' + body;
+}
 
+export function render(rows, cfg) {
+  const loc = LOCALES[cfg.locale];
   /* Подпись называет только то, что не меняется от самих служебных коммитов:
    * число строк и список колонок. Иначе таблица считалась бы устаревшей сразу
    * после собственного коммита — из-за пересчитанного «пропущено N» в тексте. */
@@ -118,11 +127,10 @@ ${CSS}
 <p class="note">${noteText(rows, cfg)}</p>
 <table>
 <thead>
-${head}
+${tableHead(cfg, loc)}
 </thead>
 <tbody>
-${nowRow}
-${body}
+${tableBody(rows, cfg, loc)}
 </tbody>
 </table>
 </body>

package/src/size-table.js

@@ -44,7 +44,7 @@
  *   size --json             строки как JSON в stdout
  *   size --data             данные для страницы и агента в stdout
  *   size --page [файл]      собрать страницу отчёта
- *   size --init [файл]      черновик конфига для нового проекта
+ *   size --init [файл]      закрепить настройки файлом (без него они выводятся из проекта)
  *   size --config <путь>    другой файл настроек
  *   size --help             справка и коды выхода
  *
@@ -60,17 +60,23 @@
  *   strip → refusal, parse                             — снятие балласта и гард;
  *   metrics → strip                                    — реестр метрик;
  *   git → refusal                                      — всё, что читается у git;
- *   config → git, refusal, locales, metrics, data      — настройки проекта;
+ *   project → git, refusal, data                       — что проект говорит о себе сам;
+ *   config → project, git, refusal, locales, metrics, data — настройки проекта;
  *   history → git, metrics, journal, refusal           — сборка по истории;
  *   data → locales, metrics, journal, history, tool    — контракт со страницей;
  *   render → locales, metrics, journal, derived        — статический артефакт;
  *   page/build → locales, render                       — страница отчёта;
- *   cli → все                                          — режимы и разбор ключей.
+ *   modes → почти все                                  — что делать по запросу;
+ *   init → config, project, refusal, artifact          — закрепление настроек файлом;
+ *   cli → args, modes, init, config, refusal           — вход: разбор и доставка.
  *
  * Публичный API — то, чем пользуются `bin/size.js` и `test/`: список ниже не
  * сокращается при разбиении (это проверяет `test/api.test.js`).
  */
-export { main, initMode, sniffColumns, check, dataMode, pageMode } from './cli.js';
+export { main } from './cli.js';
+export { initMode } from './init.js';
+export { sniffColumns } from './project.js';
+export { check, dataMode, pageMode } from './modes.js';
 export { reportData, categoryOf, CATEGORY_EXTS, CATEGORY_ORDER } from './data.js';
 export { measureHistory } from './history.js';
 export { render, noteText, cellHtml, valueHtml } from './render.js';

package/src/strip/forms.js

@@ -0,0 +1,26 @@
+import { stripJs } from './js.js';
+
+/* Формы текста, у которых снятие балласта своё: разметка, стили, строки файла и
+ * JSON. Разные формы — разные правила, и одно правило на все было бы либо
+ * трусостью (не снимать ничего), либо порчей чужого синтаксиса. */
+
+export function stripCss(src) {
+  return src.replace(/\/\*[\s\S]*?\*\//g, ' ');
+}
+
+/* HTML: комментарии разметки (включая маркеры вклеек `<!--icon …-->` и
+ * `<!--/icon-->`), комментарии внутри <script> как JS и внутри <style> как CSS. */
+export function stripHtml(src) {
+  return src
+    .replace(/<!--[\s\S]*?-->/g, '')
+    .replace(/(<script\b[^>]*>)([\s\S]*?)(<\/script>)/gi, (_m, open, body, close) => open + stripJs(body) + close)
+    .replace(/(<style\b[^>]*>)([\s\S]*?)(<\/style>)/gi, (_m, open, body, close) => open + stripCss(body) + close);
+}
+
+export function stripLines(text) {
+  return text.split('\n').map((l) => l.trim()).filter((l) => l !== '').join('\n');
+}
+
+export function compactJson(text) {
+  try { return JSON.stringify(JSON.parse(text)); } catch (_e) { return stripLines(text); }
+}

package/src/strip/guard.js

@@ -0,0 +1,59 @@
+import path from 'path';
+import vm from 'vm';
+import { refuseCause } from '../refusal.js';
+import { moduleError } from '../parse.js';
+
+/* Гард стриппера: он не имеет права выбросить что-то кроме комментариев и
+ * отступов, поэтому результат обязан компилироваться. Проверяем только те
+ * расширения, где содержимое — валидный JavaScript (список в конфиге,
+ * `minify.guard`): TypeScript или JSX хостом не проверяются, и делать вид, что
+ * проверили, было бы хуже, чем не проверять.
+ *
+ * Модуль или скрипт решает текст, а не расширение: проект с бандлером пишет
+ * `import`/`export` прямо в `.js` (и с `type: module` в манифесте, и без него), а
+ * `vm.Script` разбирает такой файл как скрипт и падает на самом `export`. Гард
+ * обязан понимать оба формата, поэтому пробует тот, на который файл похож, и
+ * принимает результат, если он разбирается хотя бы одним из двух способов.
+ * От этого он не слабеет: настоящая поломка не разберётся ни скриптом, ни
+ * модулем, и тогда наружу идёт причина того разбора, которым файл был.
+ *
+ * Модуль разбирает отдельный рабочий поток (`parse.js`): без него разбор модуля
+ * стоил бы запуска Node на каждую клетку. Иначе конфиг вида `eslint.config.mjs`
+ * остался бы без гарда, а без гарда его правка могла бы испортить «объём» молча.
+ *
+ * Когда не разбирается даже исходный текст, стриппер тут ни при чём: в этой
+ * графе измеряется не JavaScript (TypeScript, JSX), и это отказ с командой
+ * починки — правкой настроек. */
+
+const MODULE_MARK = /^[ \t]*(?:import|export)\b/m;
+const MODULE_EXT = ['.mjs'];
+
+export function assertCompilable(min, rev, p, src) {
+  // Скрипт пробуется первым не ради формы, а ради цены: этот разбор идёт
+  // в процессе, а модуль — в рабочем потоке.
+  const asScript = scriptError(min, p);
+  if (asScript === null) return;
+  const asModule = moduleError(min);
+  if (asModule === null) return;
+  const shape = MODULE_EXT.indexOf(path.extname(p).toLowerCase()) >= 0 || MODULE_MARK.test(min);
+  if (src !== undefined && scriptError(src, p) !== null && moduleError(src) !== null) {
+    refuseCause('файл не JavaScript', 'файл ' + p + ' — не JavaScript: его исходный текст не'
+      + ' разбирается ни как скрипт, ни как модуль, так что дело не в стриптере, а '
+      + path.extname(p) + ' стоит в minify.guard: ' + (shape ? asModule : asScript) + '\n'
+      + '  починка: уберите это расширение из minify.guard или задайте для него '
+      + 'minify.ext — например { "' + path.extname(p).toLowerCase() + '": "strip-lines" }');
+  }
+  // Причина — того разбора, которым файл был: обвинять в чужой форме незачем.
+  throw new Error('стриппер испортил ' + p + ' на ' + rev.slice(0, 7) + ': '
+    + (shape ? asModule : asScript));
+}
+
+// Разбор как скрипт — в процессе: дешевле и без временных файлов.
+function scriptError(text, p) {
+  try {
+    new vm.Script(text, { filename: p });
+    return null;
+  } catch (e) {
+    return e.message;
+  }
+}

package/src/strip/js.js

@@ -0,0 +1,136 @@
+/* Снятие комментариев и отступов — метрика «объём без балласта», а не
+ * минификация: пробелы внутри строк и порядок токенов не трогаются (это позволит
+ * сравнивать числа между языками и не зависит от чужого инструмента, которого в
+ * проекте нет). Строки и шаблоны проходят насквозь, блочный комментарий
+ * заменяется пробелом, чтобы `a` и `b` из `a` + блочный комментарий + `b` не
+ * склеились в одно имя, перевод строки после `//` сохраняется — он разделяет
+ * токены.
+ *
+ * Проход разложен по случаям: комментарий, регексп, строка и обычный символ.
+ * Случай говорит, сколько он съел (`false` — не его), и все они делят одно
+ * состояние прохода; состояния «по копии на случай» здесь не заводится, потому
+ * что решение о регекспе зависит от всего, что уже выведено.
+ */
+
+/* Состояние прохода: текст, место в нём и то, чем отличают регексп от деления, —
+ * последний значимый символ вывода и хвост последнего слова (после `return` идёт
+ * выражение, а не деление). */
+function scanOf(src) {
+  return { src: src, out: '', i: 0, last: '', word: '' };
+}
+
+export function stripJs(src) {
+  const s = scanOf(src);
+  while (s.i < src.length) {
+    /* Комментарные пары проверяются до регекси: ни `/`, ни `*` не могут быть
+     * первым символом литерала регекспа, а вот `/*` в начале файла — обычное дело. */
+    if (skipLineComment(s) || skipBlockComment(s) || takeRegex(s) || takeString(s)) continue;
+    putChar(s);
+  }
+  return s.out;
+}
+
+// Строчный комментарий: `//` съедается до перевода строки, сам перевод остаётся.
+function skipLineComment(s) {
+  if (s.src[s.i] !== '/' || s.src[s.i + 1] !== '/') return false;
+  const nl = s.src.indexOf('\n', s.i);
+  s.i = nl === -1 ? s.src.length : nl;
+  return true;
+}
+
+// Блочный комментарий — на пробел: он разделяет имена, но не занимает объём.
+function skipBlockComment(s) {
+  if (s.src[s.i] !== '/' || s.src[s.i + 1] !== '*') return false;
+  const end = s.src.indexOf('*/', s.i + 2);
+  s.out += ' ';
+  s.i = end === -1 ? s.src.length : end + 2;
+  return true;
+}
+
+/* Регексп начинается там, где ожидается операнд: после оператора, открывающей
+ * скобки или ключевого слова. Признак грубый, но его хватает: без него
+ * `replace(/\//g, …)` читалось бы как начало строчного комментария и резало
+ * строку (проверено гардом компиляции). */
+const REGEX_KEYWORDS = ['return', 'typeof', 'instanceof', 'in', 'of', 'new', 'delete', 'void', 'case', 'do', 'else', 'yield', 'await'];
+
+function regexAllowed(last, word) {
+  if (last === '') return true;
+  if (REGEX_KEYWORDS.indexOf(word) !== -1) return true;
+  return '([{,;:=!&|?+-*%~^<>'.indexOf(last) !== -1;
+}
+
+function takeRegex(s) {
+  if (s.src[s.i] !== '/' || !regexAllowed(s.last, s.word)) return false;
+  const end = endOfRegex(s.src, s.i);
+  s.out += s.src.slice(s.i, end);
+  s.i = end;
+  s.last = '/';
+  s.word = '';
+  return true;
+}
+
+function endOfRegex(src, start) {
+  let i = start + 1;
+  let inClass = false;
+  while (i < src.length) {
+    const ch = src[i];
+    if (ch === '\\') { i += 2; continue; }
+    if (ch === '\n') return start + 1; // наткнулись на строку — значит, это был не регексп
+    if (ch === '[') inClass = true;
+    else if (ch === ']') inClass = false;
+    else if (ch === '/' && !inClass) return i + 1;
+    i++;
+  }
+  return start + 1;
+}
+
+// Строка или шаблон — целиком, вместе со своим содержимым.
+function takeString(s) {
+  const quote = s.src[s.i];
+  if (quote !== '"' && quote !== "'" && quote !== '`') return false;
+  const end = endOfString(s.src, s.i, quote);
+  s.out += s.src.slice(s.i, end);
+  s.i = end;
+  s.last = quote;
+  s.word = '';
+  return true;
+}
+
+function endOfString(src, start, quote) {
+  let i = start + 1;
+  while (i < src.length) {
+    const ch = src[i];
+    if (ch === '\\') { i += 2; continue; }
+    if (ch === quote) return i + 1;
+    // В шаблоне `${…}` живёт выражение, а в нём — свои строки.
+    if (quote === '`' && ch === '$' && src[i + 1] === '{') { i = endOfTemplateExpr(src, i + 2); continue; }
+    i++;
+  }
+  return src.length;
+}
+
+function endOfTemplateExpr(src, start) {
+  let depth = 1;
+  let i = start;
+  while (i < src.length) {
+    const ch = src[i];
+    if (ch === '\\') { i += 2; continue; }
+    if (ch === '{') { depth++; i++; continue; }
+    if (ch === '}') { depth--; i++; if (depth === 0) return i; continue; }
+    if (ch === '"' || ch === "'" || ch === '`') { i = endOfString(src, i, ch); continue; }
+    i++;
+  }
+  return src.length;
+}
+
+/* Обычный символ: он попадает в вывод, а состояние прохода запоминает по нему,
+ * где может стоять регексп. */
+function putChar(s) {
+  const ch = s.src[s.i];
+  s.out += ch;
+  if (ch.trim() !== '') {
+    s.last = ch;
+    s.word = /[\w$]/.test(ch) ? s.word + ch : '';
+  }
+  s.i++;
+}