sdocs-dev 1.6.2 → 1.12.0

package/lib/styles.js

@@ -0,0 +1,91 @@
+// Default styles stored at ~/.sdocs/styles.yaml.
+//
+// Users tune a document in the browser, click "Save as Default", and
+// the resulting YAML lands here. Every subsequent `sdoc <file>` merges
+// these defaults under the file's own `styles:` block (file wins on
+// conflict). `sdoc defaults` shows or removes the file.
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+const SDocYaml = require('../shared/sdocs-yaml.js');
+
+function getDefaultsPath() {
+  return path.join(os.homedir(), '.sdocs', 'styles.yaml');
+}
+
+function loadDefaultStyles() {
+  const configPath = getDefaultsPath();
+  if (!fs.existsSync(configPath)) return null;
+  try {
+    const yaml = fs.readFileSync(configPath, 'utf-8');
+    return SDocYaml.parseSimpleYaml(yaml);
+  } catch {
+    return null;
+  }
+}
+
+function showDefaults() {
+  const configPath = getDefaultsPath();
+  if (!fs.existsSync(configPath)) {
+    console.log('No default styles set (~/.sdocs/styles.yaml not found).');
+    console.log('\nTo set defaults, style a document in SDocs and use');
+    console.log('the "Save as Default" panel to generate the command.');
+    return;
+  }
+  console.log(fs.readFileSync(configPath, 'utf-8'));
+}
+
+function resetDefaults() {
+  const configPath = getDefaultsPath();
+  if (!fs.existsSync(configPath)) {
+    console.log('No default styles to remove.');
+    return;
+  }
+  fs.unlinkSync(configPath);
+  console.log('Removed ' + configPath);
+}
+
+// Deep merge: defaults under file styles (file wins on conflict).
+// Recurses one level deeper for light:/dark: sub-objects that contain
+// nested objects (e.g. h1: { color: ... }).
+function mergeStyles(defaults, fileStyles) {
+  if (!defaults) return fileStyles || {};
+  if (!fileStyles) return { ...defaults };
+  const merged = { ...defaults };
+  for (const [k, v] of Object.entries(fileStyles)) {
+    if (typeof v === 'object' && v !== null && typeof merged[k] === 'object' && merged[k] !== null) {
+      const inner = { ...merged[k] };
+      for (const [ik, iv] of Object.entries(v)) {
+        if (typeof iv === 'object' && iv !== null && typeof inner[ik] === 'object' && inner[ik] !== null) {
+          inner[ik] = { ...inner[ik], ...iv };
+        } else {
+          inner[ik] = iv;
+        }
+      }
+      merged[k] = inner;
+    } else {
+      merged[k] = v;
+    }
+  }
+  return merged;
+}
+
+function applyDefaultStyles(content) {
+  const defaults = loadDefaultStyles();
+  if (!defaults) return content;
+
+  const { meta, body } = SDocYaml.parseFrontMatter(content);
+  const mergedStyles = mergeStyles(defaults, meta.styles);
+  const newMeta = { ...meta, styles: mergedStyles };
+  return SDocYaml.serializeFrontMatter(newMeta) + '\n' + body;
+}
+
+module.exports = {
+  getDefaultsPath,
+  loadDefaultStyles,
+  showDefaults,
+  resetDefaults,
+  mergeStyles,
+  applyDefaultStyles,
+};

package/lib/update-check.js

@@ -0,0 +1,163 @@
+// Daily npm version check + optional auto-install.
+//
+// refreshUpdateCache(): non-blocking GET of dist-tags from npm, written to
+// ~/.sdocs/update-check.json. Runs at most once per day, never on CI.
+//
+// maybeUpdateBinary(): reads the cached `latest`, compares to VERSION, and:
+//   - autoInstallUpdates=true: silent self-upgrade + re-exec.
+//   - interactive TTY: Y/n prompt.
+//   - non-TTY: one-line hint.
+
+const fs    = require('fs');
+const os    = require('os');
+const path  = require('path');
+const https = require('https');
+const readline = require('readline');
+const { execSync, spawnSync } = require('child_process');
+
+const { UPDATE_CACHE, VERSION, ONE_DAY, GITHUB_REPO_URL, INSTALL_SH_URL } = require('./constants');
+const { readSetupState } = require('./agent-block');
+
+// Install-method detection. The URL installer (install.sh) drops the CLI into
+// $SDOCS_HOME/cli (default ~/.sdocs/cli); a global npm install lives under
+// npm's prefix. The two upgrade differently, so every upgrade path branches on
+// this. If you change the installed layout in install.sh, update this check.
+//
+// Both sides are realpath-resolved before comparing: `__dirname` is already
+// canonical, but the home path is raw, so a symlink anywhere above ~/.sdocs
+// (common on macOS/managed homes) would make a raw startsWith() miss. The
+// SDOCS_HOME env var mirrors install.sh so a custom install dir is detected
+// too. realpathSync throws when $SDOCS_HOME/cli does not exist (the npm and
+// dev-checkout cases); the catch turns that into `false`.
+function isUrlInstall(moduleDir) {
+  try {
+    const home = process.env.SDOCS_HOME || path.join(os.homedir(), '.sdocs');
+    const cliRoot = fs.realpathSync(path.join(home, 'cli')) + path.sep;
+    const here = fs.realpathSync(path.resolve(moduleDir || __dirname, '..')) + path.sep;
+    return here.startsWith(cliRoot);
+  } catch (_) { return false; }
+}
+
+// The command that upgrades sdoc in place, given how it was installed.
+function upgradeCommand() {
+  return isUrlInstall()
+    ? `curl -fsSL ${INSTALL_SH_URL} | sh`
+    : 'npm i -g sdocs-dev@latest';
+}
+
+function isNewer(latest, current) {
+  const a = latest.split('.').map(Number);
+  const b = current.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    if (a[i] > b[i]) return true;
+    if (a[i] < b[i]) return false;
+  }
+  return false;
+}
+
+function readCachedLatest() {
+  try { return JSON.parse(fs.readFileSync(UPDATE_CACHE, 'utf-8')).latest; }
+  catch (_) { return null; }
+}
+
+// Self-upgrade: runs the right upgrade command for the install method, then
+// re-execs into the new binary. On any failure, falls through (so the user's
+// actual command still runs).
+function autoInstallAndReexec(latest) {
+  console.log(`\nUpdating sdoc ${VERSION} → ${latest}...`);
+  const cmd = upgradeCommand();
+  try {
+    execSync(cmd, { stdio: 'pipe' });
+  } catch (e) {
+    console.error(`! sdoc auto-update to ${latest} failed: ${(e.stderr || e.message || '').toString().trim().split('\n')[0]}`);
+    console.error(`  Run \`${cmd}\` manually to upgrade.`);
+    return false;
+  }
+  console.log(`✓ sdoc updated ${VERSION} → ${latest}`);
+  console.log(`  Diff: ${GITHUB_REPO_URL}/compare/v${VERSION}...v${latest}`);
+  const r = spawnSync(process.argv0, process.argv.slice(1), { stdio: 'inherit' });
+  process.exit(r.status == null ? 0 : r.status);
+}
+
+async function maybeUpdateBinary() {
+  if (process.env.NO_UPDATE_NOTIFIER || process.env.CI) return;
+  const latest = readCachedLatest();
+  if (!latest || !isNewer(latest, VERSION)) return;
+
+  const state = readSetupState();
+  const autoInstall = state && state.autoInstallUpdates === true;
+
+  if (autoInstall) {
+    autoInstallAndReexec(latest);
+    return;
+  }
+
+  const isInteractive = process.stdout.isTTY && process.stdin.isTTY;
+  if (!isInteractive) {
+    console.log(`Update available: ${VERSION} → ${latest}. Run \`${upgradeCommand()}\` to upgrade.`);
+    return;
+  }
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise(resolve => {
+    rl.question(`\nUpdate available: ${VERSION} → ${latest}. Install now? [Y/n] `, a => {
+      rl.close(); resolve(a.trim().toLowerCase());
+    });
+  });
+  if (answer && answer !== 'y' && answer !== 'yes') return;
+
+  const cmd = upgradeCommand();
+  console.log('Installing the latest sdoc...');
+  try {
+    execSync(cmd, { stdio: 'inherit' });
+    console.log(`✓ Updated to v${latest}`);
+  } catch (_) {
+    console.error(`Update failed. Run \`${cmd}\` to upgrade.`);
+  }
+}
+
+// `sdoc upgrade` — force an upgrade to the latest version right now,
+// regardless of the daily update cache. Branches on install method.
+function runUpgrade() {
+  const cmd = upgradeCommand();
+  console.log(`Upgrading sdoc (currently ${VERSION})...`);
+  try {
+    execSync(cmd, { stdio: 'inherit' });
+  } catch (_) {
+    console.error(`\nUpgrade failed. Run \`${cmd}\` manually.`);
+    process.exit(1);
+  }
+  console.log('✓ sdoc is up to date.');
+}
+
+// Daily refresh of the cached `latest` version from npm. Not gated on TTY:
+// agents populate the cache too, so the update hint reaches them on next run.
+function refreshUpdateCache() {
+  if (process.env.NO_UPDATE_NOTIFIER || process.env.CI) return;
+  try {
+    if (Date.now() - fs.statSync(UPDATE_CACHE).mtimeMs < ONE_DAY) return;
+  } catch (_) {}
+
+  https.get('https://registry.npmjs.org/-/package/sdocs-dev/dist-tags', { timeout: 3000 }, res => {
+    let data = '';
+    res.on('data', chunk => { data += chunk; });
+    res.on('end', () => {
+      try {
+        const latest = JSON.parse(data).latest;
+        fs.mkdirSync(path.dirname(UPDATE_CACHE), { recursive: true });
+        fs.writeFileSync(UPDATE_CACHE, JSON.stringify({ latest }));
+      } catch (_) {}
+    });
+  }).on('error', () => {}).on('timeout', function () { this.destroy(); });
+}
+
+module.exports = {
+  isNewer,
+  readCachedLatest,
+  isUrlInstall,
+  upgradeCommand,
+  autoInstallAndReexec,
+  maybeUpdateBinary,
+  runUpgrade,
+  refreshUpdateCache,
+};

package/lib/url.js

@@ -0,0 +1,111 @@
+// URL encoding for SDocs links.
+//
+// - toBase64Url / fromBase64Url: URL-safe base64.
+// - compressToBase64Url / decompressFromBase64Url: brotli + base64url.
+//   The browser uses the same shape so a URL built here decodes there
+//   identically. Decompression falls back to raw inflate for old links.
+// - buildUrl: the public form (`#md=<compressed>`), default-style
+//   stripping included so the URL is as short as the browser would write.
+
+const zlib = require('zlib');
+const SDocYaml   = require('../shared/sdocs-yaml.js');
+const SDocStyles = require('../shared/sdocs-styles.js');
+const { slugify } = require('../shared/sdocs-slugify.js');
+const { DEFAULT_URL } = require('./constants');
+
+function toBase64Url(buf) {
+  return Buffer.from(buf).toString('base64')
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=+$/, '');
+}
+
+function fromBase64Url(b64url) {
+  let b64 = b64url.replace(/-/g, '+').replace(/_/g, '/');
+  const pad = (4 - b64.length % 4) % 4;
+  b64 += '='.repeat(pad);
+  return Buffer.from(b64, 'base64');
+}
+
+function compressToBase64Url(text) {
+  const compressed = zlib.brotliCompressSync(Buffer.from(text, 'utf-8'), {
+    params: { [zlib.constants.BROTLI_PARAM_QUALITY]: 11 }
+  });
+  return toBase64Url(compressed);
+}
+
+function decompressFromBase64Url(b64url) {
+  const buf = fromBase64Url(b64url);
+  try {
+    return zlib.brotliDecompressSync(buf).toString('utf-8');
+  } catch (_) {
+    return zlib.inflateRawSync(buf).toString('utf-8');
+  }
+}
+
+// Strip default styles from the front matter, then brotli+base64url the result.
+// This is the exact `md=` payload the browser's fragment Source decodes. Shared
+// by buildUrl (static / share links) and the bridge URL builder so both paths
+// emit one identical encoding - no second code path to drift out of sync.
+function stripAndCompress(content) {
+  const parsed = SDocYaml.parseFrontMatter(content);
+  if (parsed.meta && parsed.meta.styles) {
+    const stripped = SDocStyles.stripStyleDefaults(parsed.meta.styles);
+    if (Object.keys(stripped).length > 0) {
+      parsed.meta.styles = stripped;
+    } else {
+      delete parsed.meta.styles;
+    }
+    content = SDocYaml.serializeFrontMatter(parsed.meta) + '\n' + parsed.body;
+  }
+  return compressToBase64Url(content);
+}
+
+function buildUrl(content, opts) {
+  const baseUrl = opts.url || process.env.SDOCS_URL || DEFAULT_URL;
+  const params = new URLSearchParams();
+
+  // Runtime-only metadata (paths). Stripped from the URL by the browser on load,
+  // so anything the user copies from the address bar won't contain them.
+  if (opts.local && Object.keys(opts.local).length > 0) {
+    const json = JSON.stringify(opts.local);
+    const b64 = Buffer.from(json, 'utf-8').toString('base64')
+      .replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+    params.set('local', b64);
+  }
+
+  if (content) {
+    params.set('md', stripAndCompress(content));
+  } else if (opts.defaultStyles) {
+    const stylesJson = JSON.stringify(opts.defaultStyles);
+    params.set('styles', encodeURIComponent(Buffer.from(stylesJson, 'utf-8').toString('base64')));
+  }
+
+  const mode = opts.mode || (content ? 'read' : 'style');
+  if (mode && mode !== 'read') params.set('mode', mode);
+
+  if (opts.theme) params.set('theme', opts.theme);
+
+  if (opts.section) {
+    params.set('sec', slugify(opts.section));
+  }
+
+  // `sdoc present <file>` opens straight into fullscreen slide view.
+  // The browser checks for `present` in the hash and triggers present
+  // mode after the document loads. The value "0" picks the first slide.
+  if (opts.present) {
+    params.set('present', '0');
+  }
+
+  const qs = params.toString();
+  return qs ? `${baseUrl}/#${qs}` : baseUrl;
+}
+
+module.exports = {
+  toBase64Url,
+  fromBase64Url,
+  compressToBase64Url,
+  decompressFromBase64Url,
+  stripAndCompress,
+  buildUrl,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sdocs-dev",
-  "version": "1.6.2",
+  "version": "1.12.0",
   "description": "Open, share, and style markdown files from the terminal",
   "main": "bin/sdocs-dev.js",
   "bin": {
@@ -9,13 +9,10 @@
   },
   "files": [
     "bin/",
-    "public/sdocs-yaml.js",
-    "public/sdocs-styles.js",
-    "public/sdocs-slugify.js"
+    "lib/",
+    "shared/"
   ],
   "scripts": {
-    "start": "node server.js",
-    "test": "node test/run.js",
     "postinstall": "node bin/sdocs-postinstall.js"
   },
   "keywords": [
@@ -32,15 +29,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/espressoplease/SDocs.git"
+    "url": "git+https://github.com/espressoplease/smalldocs.git"
   },
-  "homepage": "https://sdocs.dev",
-  "devDependencies": {
-    "@playwright/test": "^1.59.1",
-    "better-sqlite3": "^12.8.0",
-    "brotli": "^1.3.3",
-    "brotli-dec-wasm": "^2.3.2",
-    "brotli-wasm": "^3.0.1",
-    "marked": "^11.0.0"
-  }
+  "homepage": "https://smalldocs.org"
 }

package/shared/sdocs-contrast.js

@@ -0,0 +1,196 @@
+// sdocs-contrast.js - WCAG contrast analysis for custom-styled documents.
+//
+// Why this exists: an agent that hand-picks colours can easily produce an
+// unreadable pair - dark text on a dark background, a navy heading on a near
+// black page - without noticing, especially when it tuned the colours while
+// viewing one theme. This module resolves the effective palette for BOTH the
+// light and dark themes (mirroring how the browser applies front-matter
+// styles) and grades every text-on-background pair against WCAG ratios, so
+// `sdoc color-analysis` can warn before the document ships.
+//
+// Pure: no I/O, no third-party deps. Shared between the CLI and tests (and
+// available to the browser via window.SDocContrast).
+(function (exports) {
+  'use strict';
+
+  var SDocStyles = (typeof module !== 'undefined' && module.exports)
+    ? require('./sdocs-styles.js')
+    : (typeof window !== 'undefined' ? window.SDocStyles : null);
+
+  // Light-theme defaults for colours the document didn't override. Mirrors
+  // the LIGHT_DEFAULTS / DARK_DEFAULTS tables in sdocs-theme.js. Headings
+  // default to the body text colour (the colour cascade root).
+  var LIGHT_DEFAULTS = {
+    bg: '#ffffff', text: '#1c1917', link: '#2563eb',
+    blockBg: '#f4f1ed', blockText: '#6b6560',
+    codeBg: '#f4f1ed', codeText: '#6b21a8',
+    bqBg: '#f7f5f2', bqText: '#6b6560'
+  };
+  var DARK_DEFAULTS = {
+    bg: '#2c2a26', text: '#e7e5e2', link: '#60a5fa',
+    blockBg: '#1a1816', blockText: '#a8a29e',
+    codeBg: '#1a1816', codeText: '#b8a99a',
+    bqBg: '#252320', bqText: '#a8a29e'
+  };
+
+  // ── WCAG maths ────────────────────────────────────────
+  function hexToRgb(hex) {
+    if (typeof hex !== 'string') return null;
+    var h = hex.trim().replace(/^#/, '');
+    if (h.length === 3) h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
+    if (!/^[0-9a-fA-F]{6}$/.test(h)) return null;
+    return { r: parseInt(h.slice(0, 2), 16), g: parseInt(h.slice(2, 4), 16), b: parseInt(h.slice(4, 6), 16) };
+  }
+
+  function channelLin(c) {
+    var s = c / 255;
+    return s <= 0.03928 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4);
+  }
+
+  function relativeLuminance(hex) {
+    var rgb = hexToRgb(hex);
+    if (!rgb) return null;
+    return 0.2126 * channelLin(rgb.r) + 0.7152 * channelLin(rgb.g) + 0.0722 * channelLin(rgb.b);
+  }
+
+  // WCAG contrast ratio, 1..21. Returns null for unparseable input.
+  function contrastRatio(a, b) {
+    var la = relativeLuminance(a), lb = relativeLuminance(b);
+    if (la == null || lb == null) return null;
+    var hi = Math.max(la, lb), lo = Math.min(la, lb);
+    return (hi + 0.05) / (lo + 0.05);
+  }
+
+  // Fail line. Calibrated against human review rather than the strict
+  // WCAG-AA body bar (4.5:1): pairs in the ~3.2-4.4 range read fine on a
+  // normal screen, while everything that actually caused unreadable docs
+  // sat well below 3:1. Set as a single constant so it's easy to retune.
+  // (WCAG bands are still reported via `level` for anyone who wants them.)
+  var MIN_CONTRAST = 3.0;
+
+  // Grade a ratio against MIN_CONTRAST. `large` is kept for callers that
+  // want to annotate heading vs body, but the pass/fail line is uniform.
+  //   level: 'fail' | 'aa-large' | 'aa' | 'aaa' (informational WCAG bands)
+  //   ok:    ratio meets the fail line
+  function grade(ratio, large) {
+    var level;
+    if (ratio == null) level = 'unknown';
+    else if (ratio >= 7) level = 'aaa';
+    else if (ratio >= 4.5) level = 'aa';
+    else if (ratio >= 3) level = 'aa-large';
+    else level = 'fail';
+    return {
+      ratio: ratio == null ? null : Math.round(ratio * 100) / 100,
+      level: level,
+      need: MIN_CONTRAST,
+      ok: ratio != null && ratio >= MIN_CONTRAST
+    };
+  }
+
+  // ── Palette resolution ────────────────────────────────
+  // Resolve a single colour for both themes. `explicit` is the front-matter
+  // value (or null/undefined). The dark value mirrors applyStylesFromMeta:
+  // an explicit dark override wins, else an explicit light value is inverted,
+  // else the theme default applies.
+  function resolve(explicit, ctrlId, darkBlock, lightDefault, darkDefault) {
+    var light = explicit || lightDefault;
+    var dark;
+    if (darkBlock && darkBlock[ctrlId]) dark = darkBlock[ctrlId];
+    else if (explicit && SDocStyles && SDocStyles.invertLightness) {
+      dark = SDocStyles.invertLightness(explicit, SDocStyles.colorControlRole
+        ? SDocStyles.colorControlRole(ctrlId) : undefined);
+    } else dark = darkDefault;
+    return { light: light, dark: dark };
+  }
+
+  // Resolve the full set of text-on-background pairs for a parsed `styles`
+  // object. Returns { light: [pairs], dark: [pairs] } where each pair is
+  // { label, surface, fg, bg, large }.
+  function resolvePairs(styles) {
+    styles = styles || {};
+    var darkBlock = (SDocStyles && SDocStyles.parseDarkBlock) ? SDocStyles.parseDarkBlock(styles.dark) : {};
+    var headers = styles.headers || {};
+    var h = function (n) { return styles['h' + n] || {}; };
+
+    // Page background and the colours that sit on it.
+    var bg        = resolve(styles.background, '_sd_ctrl-bg-color', darkBlock, LIGHT_DEFAULTS.bg, DARK_DEFAULTS.bg);
+    var body      = resolve(styles.color, '_sd_ctrl-color', darkBlock, LIGHT_DEFAULTS.text, DARK_DEFAULTS.text);
+    var headingFallback = headers.color || styles.color;
+    function heading(n) {
+      var explicit = h(n).color || headers.color;
+      var id = '_sd_ctrl-h' + n + '-color';
+      var lightDef = headingFallback || LIGHT_DEFAULTS.text;
+      var darkDef = body.dark;
+      return resolve(explicit, id, darkBlock, lightDef, darkDef);
+    }
+    var h1 = heading(1), h2 = heading(2), h3 = heading(3), h4 = heading(4);
+    var link = resolve((styles.link || {}).color, '_sd_ctrl-link-color', darkBlock, LIGHT_DEFAULTS.link, DARK_DEFAULTS.link);
+
+    var blocks = styles.blocks || {};
+    var bqBg = resolve((styles.blockquote || {}).background || blocks.background, '_sd_ctrl-bq-bg', darkBlock, LIGHT_DEFAULTS.bqBg, DARK_DEFAULTS.bqBg);
+    var bqText = resolve((styles.blockquote || {}).color || blocks.color, '_sd_ctrl-bq-color', darkBlock, LIGHT_DEFAULTS.bqText, DARK_DEFAULTS.bqText);
+    var codeBg = resolve((styles.code || {}).background || blocks.background, '_sd_ctrl-code-bg', darkBlock, LIGHT_DEFAULTS.codeBg, DARK_DEFAULTS.codeBg);
+    var codeText = resolve((styles.code || {}).color || blocks.color, '_sd_ctrl-code-color', darkBlock, LIGHT_DEFAULTS.codeText, DARK_DEFAULTS.codeText);
+
+    function build(theme) {
+      var pick = function (c) { return c[theme]; };
+      return [
+        { label: 'body text', surface: 'page',       fg: pick(body), bg: pick(bg), large: false },
+        { label: 'h1',        surface: 'page',       fg: pick(h1),   bg: pick(bg), large: true },
+        { label: 'h2',        surface: 'page',       fg: pick(h2),   bg: pick(bg), large: true },
+        { label: 'h3',        surface: 'page',       fg: pick(h3),   bg: pick(bg), large: true },
+        { label: 'h4',        surface: 'page',       fg: pick(h4),   bg: pick(bg), large: true },
+        { label: 'link',      surface: 'page',       fg: pick(link), bg: pick(bg), large: false },
+        { label: 'blockquote text', surface: 'blockquote', fg: pick(bqText),   bg: pick(bqBg),   large: false },
+        { label: 'code text',       surface: 'code block', fg: pick(codeText), bg: pick(codeBg), large: false }
+      ];
+    }
+    return { light: build('light'), dark: build('dark') };
+  }
+
+  // Full analysis for a parsed styles object: grades every pair in both
+  // themes. `hasCustomStyles` is false when the document set no colours, in
+  // which case the built-in defaults are known-good and nothing is flagged.
+  function analyzeStyles(styles) {
+    var hasColors = styles && hasCustomColors(styles);
+    var pairs = resolvePairs(styles);
+    function gradeList(list) {
+      return list.map(function (p) {
+        var g = grade(contrastRatio(p.fg, p.bg), p.large);
+        return {
+          label: p.label, surface: p.surface, fg: p.fg, bg: p.bg, large: p.large,
+          ratio: g.ratio, level: g.level, need: g.need, ok: g.ok
+        };
+      });
+    }
+    var light = gradeList(pairs.light);
+    var dark = gradeList(pairs.dark);
+    var fails = light.concat(dark).filter(function (p) { return !p.ok; });
+    return { hasCustomColors: !!hasColors, light: light, dark: dark, fails: fails };
+  }
+
+  function hasCustomColors(styles) {
+    if (!styles) return false;
+    var keys = ['background', 'color', 'link', 'blocks', 'blockquote', 'code', 'headers', 'h1', 'h2', 'h3', 'h4', 'dark'];
+    for (var i = 0; i < keys.length; i++) {
+      var v = styles[keys[i]];
+      if (v == null) continue;
+      if (typeof v === 'string') return true;            // background / color
+      if (typeof v === 'object') {
+        if (v.color || v.background || v.borderColor) return true;
+      }
+    }
+    return false;
+  }
+
+  exports.hexToRgb = hexToRgb;
+  exports.relativeLuminance = relativeLuminance;
+  exports.contrastRatio = contrastRatio;
+  exports.grade = grade;
+  exports.MIN_CONTRAST = MIN_CONTRAST;
+  exports.resolvePairs = resolvePairs;
+  exports.analyzeStyles = analyzeStyles;
+  exports.hasCustomColors = hasCustomColors;
+  exports.LIGHT_DEFAULTS = LIGHT_DEFAULTS;
+  exports.DARK_DEFAULTS = DARK_DEFAULTS;
+})(typeof module !== 'undefined' && module.exports ? module.exports : (window.SDocContrast = {}));