poops 1.1.0 → 1.2.0

package/lib/markup/engines/nunjucks.js

@@ -0,0 +1,261 @@
+import fs from 'node:fs'
+import { globSync } from 'glob'
+import { Marked } from 'marked'
+import nunjucks from 'nunjucks'
+import path from 'node:path'
+import { discoverImageVariants, parseFrontMatter } from '../helpers.js'
+import { highlightRenderer, highlightCode } from '../highlight.js'
+import { slugify } from 'book-of-spells'
+import dayjs from 'dayjs'
+import log from '../../utils/log.js'
+
+const marked = new Marked({ renderer: highlightRenderer })
+
+class RelativeLoader extends nunjucks.Loader {
+  constructor(templatesDir, includePaths) {
+    super()
+    this.templatesDir = templatesDir
+    this.includePaths = includePaths || []
+    this.includePaths.push('_*')
+  }
+
+  getSource(name) {
+    let fullPath = name
+    if (!fs.existsSync(name)) {
+      let pattern = `**/${name}`
+      if (this.includePaths) {
+        pattern = `{${this.includePaths.join(',')}}/${pattern}`
+      }
+      fullPath = globSync(path.join(this.templatesDir, pattern))[0]
+    }
+    if (!fs.existsSync(fullPath)) {
+      log({ tag: 'markup', error: true, text: 'Template not found:', link: name })
+      return { src: '', path: fullPath, noCache: true }
+    }
+
+    let source = ''
+    let frontMatter = {}
+
+    try {
+      const frontMatterResult = parseFrontMatter(fullPath)
+      frontMatter = frontMatterResult.frontMatter
+      source = frontMatterResult.content
+    } catch (err) {
+      log({ tag: 'error', text: 'Failed parsing front matter:', link: fullPath })
+      console.error(err)
+    }
+
+    if (path.extname(fullPath) === '.md') {
+      source = marked.parse(source)
+    }
+
+    if (frontMatter.layout) {
+      source = `{% extends '${frontMatter.layout}.html' %}\n{% block content %}\n${source}\n{% endblock %}`
+    }
+
+    return { src: source, path: fullPath, noCache: true }
+  }
+
+  resolve(from, to) {
+    return path.resolve(path.dirname(from), to)
+  }
+}
+
+export default class NunjucksEngine {
+  constructor(templatesDir, includePaths, options) {
+    const autoescape = (options && options.autoescape) || false
+
+    this.env = new nunjucks.Environment(
+      new RelativeLoader(templatesDir, includePaths),
+      { autoescape, watch: false, noCache: true }
+    )
+  }
+
+  get fileExtension() { return '.njk' }
+  get indexableExtensions() { return new Set(['.html', '.md', '.njk']) }
+  get markupExtensions() { return 'html|xml|rss|atom|json|njk|md' }
+
+  registerFilters({ timeDateFormat, markupOut }) {
+    const env = this.env
+    env.addFilter('slugify', slugify)
+    env.addFilter('jsonify', (obj) => JSON.stringify(obj))
+    env.addFilter('markdown', (str) => marked.parse(str))
+    env.addFilter('concat', (arr, value) => {
+      if (!Array.isArray(arr)) return [value]
+      return arr.concat(value)
+    })
+    env.addFilter('push', (arr, value) => {
+      if (!Array.isArray(arr)) return [value]
+      arr.push(value)
+      return arr
+    })
+    env.addFilter('svg', (filePath) => {
+      const fullPath = path.resolve(process.cwd(), filePath)
+      if (!fs.existsSync(fullPath)) return ''
+      const content = fs.readFileSync(fullPath, 'utf-8').trim()
+      if (!/^(<\?xml[^?]*\?>\s*)?<svg[\s>]/i.test(content)) return ''
+      return new nunjucks.runtime.SafeString(content)
+    })
+    env.addFilter('date', (str, template) => {
+      const fmt = template || timeDateFormat
+      if (!fmt) return str
+      const date = !str || str.trim() === '' ? new Date() : new Date(str)
+      return dayjs(date).format(fmt)
+    })
+    env.addFilter('srcset', (imagePath) => {
+      const outputDir = path.join(process.cwd(), markupOut)
+      const { variants } = discoverImageVariants(imagePath, outputDir)
+      if (variants.length === 0) return ''
+      return variants.map(v => `${v.path} ${v.width}w`).join(', ')
+    })
+    env.addFilter('highlight', (code, lang) => {
+      const highlighted = highlightCode(code, lang)
+      const langClass = lang ? ` language-${lang}` : ''
+      return new nunjucks.runtime.SafeString(`<pre><code class="hljs${langClass}">${highlighted}</code></pre>`)
+    })
+  }
+
+  registerTags(getOutputDir) {
+    this.env.addExtension('GoogleFontsExtension', new GoogleFontsExtension())
+    this.env.addExtension('ImageExtension', new ImageExtension(getOutputDir))
+    this.env.addExtension('HighlightExtension', new HighlightExtension())
+  }
+
+  setGlobal(key, value) {
+    this.env.addGlobal(key, value)
+  }
+
+  render(templateName, context) {
+    return new Promise((resolve, reject) => {
+      this.env.getTemplate(templateName).render(context, (error, result) => {
+        if (!error) {
+          resolve(result)
+        } else {
+          reject(error)
+        }
+      })
+    })
+  }
+
+  renderString(source, context) {
+    return new Promise((resolve, reject) => {
+      this.env.renderString(source, context, (error, result) => {
+        if (!error) {
+          resolve(result)
+        } else {
+          reject(error)
+        }
+      })
+    })
+  }
+}
+
+// --- Nunjucks Extensions ---
+
+class GoogleFontsExtension {
+  constructor() { this.tags = ['googleFonts'] }
+
+  parse(parser, nodes) {
+    const tok = parser.nextToken()
+    const args = parser.parseSignature(null, true)
+    parser.advanceAfterBlockEnd(tok.value)
+    return new nodes.CallExtension(this, 'run', args)
+  }
+
+  run(context, fonts, kwargs) {
+    if (!fonts || (Array.isArray(fonts) && fonts.length === 0)) return ''
+    if (typeof fonts === 'string') fonts = [fonts]
+    const display = (kwargs && kwargs.display) || 'swap'
+
+    const families = fonts.map(font => {
+      if (typeof font === 'string') return `family=${font.replace(/\s+/g, '+')}`
+      const name = font.name || font.family || ''
+      const weights = font.weights || font.wght
+      let param = `family=${name.replace(/\s+/g, '+')}`
+      if (weights) {
+        const wList = Array.isArray(weights) ? weights : [weights]
+        param += `:wght@${wList.join(';')}`
+      }
+      if (font.ital) {
+        param = param.replace(':wght@', ':ital,wght@')
+        const wList = param.match(/@(.+)$/)[1].split(';')
+        const expanded = []
+        for (const w of wList) { expanded.push(`0,${w}`); expanded.push(`1,${w}`) }
+        param = param.replace(/@.+$/, `@${expanded.join(';')}`)
+      }
+      return param
+    })
+
+    const url = `https://fonts.googleapis.com/css2?${families.join('&')}&display=${display}`
+    return new nunjucks.runtime.SafeString(
+      `<link rel="preconnect" href="https://fonts.googleapis.com">\n
+      <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>\n
+      <link href="${url}" rel="stylesheet">`
+    )
+  }
+}
+
+class ImageExtension {
+  constructor(getOutputDir) { this.tags = ['image']; this.getOutputDir = getOutputDir }
+
+  parse(parser, nodes) {
+    const tok = parser.nextToken()
+    const args = parser.parseSignature(null, true)
+    parser.advanceAfterBlockEnd(tok.value)
+    return new nodes.CallExtension(this, 'run', args)
+  }
+
+  run(context, imagePath, kwargs) {
+    const prefix = context.lookup('relativePathPrefix') || ''
+    const alt = (kwargs && kwargs.alt) || ''
+    const loading = (kwargs && kwargs.loading) || 'lazy'
+    const isSvg = imagePath.endsWith('.svg')
+    const attrs = [`alt="${alt}"`]
+
+    if (isSvg) {
+      attrs.unshift(`src="${prefix}${imagePath}"`)
+    } else {
+      const outputDir = this.getOutputDir()
+      const { src, variants } = discoverImageVariants(imagePath, outputDir)
+      const sizes = (kwargs && kwargs.sizes) || '100vw'
+      attrs.unshift(`src="${prefix}${src}"`)
+      if (variants.length > 0) {
+        const srcsetVal = variants.map(v => `${prefix}${v.path} ${v.width}w`).join(', ')
+        attrs.push(`srcset="${srcsetVal}"`)
+        attrs.push(`sizes="${sizes}"`)
+      }
+    }
+
+    attrs.push(`loading="${loading}"`)
+    if (kwargs) {
+      const skip = new Set(['alt', 'sizes', 'loading'])
+      for (const [key, val] of Object.entries(kwargs)) {
+        if (key.startsWith('__') || skip.has(key)) continue
+        attrs.push(`${key}="${val}"`)
+      }
+    }
+    return new nunjucks.runtime.SafeString(`<img ${attrs.join(' ')}>`)
+  }
+}
+
+class HighlightExtension {
+  constructor() { this.tags = ['highlight'] }
+
+  parse(parser, nodes) {
+    const tok = parser.nextToken()
+    const args = parser.parseSignature(null, true)
+    parser.advanceAfterBlockEnd(tok.value)
+    const body = parser.parseUntilBlocks('endhighlight')
+    parser.advanceAfterBlockEnd()
+    return new nodes.CallExtension(this, 'run', args, [body])
+  }
+
+  run(context, lang, body) {
+    const code = body()
+    const highlighted = highlightCode(code, lang)
+    const langClass = lang ? ` language-${lang}` : ''
+    return new nunjucks.runtime.SafeString(
+      `<pre><code class="hljs${langClass}">${highlighted}</code></pre>`
+    )
+  }
+}

package/lib/markup/helpers.js

@@ -0,0 +1,170 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import yaml from 'yaml'
+
+const frontMatterCache = new Map()
+
+export function parseFrontMatter(filePath) {
+  let stat
+  try {
+    stat = fs.statSync(filePath)
+  } catch (e) {
+    throw new Error(`Error stating file at ${filePath}: ${e.message}`)
+  }
+
+  const cached = frontMatterCache.get(filePath)
+  if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+    return { frontMatter: { ...cached.value.frontMatter }, content: cached.value.content }
+  }
+
+  let content = ''
+  try {
+    content = fs.readFileSync(filePath, 'utf8')
+  } catch (e) {
+    throw new Error(`Error reading file at ${filePath}: ${e.message}`)
+  }
+
+  if (!content) {
+    throw new Error(`File at ${filePath} is empty`)
+  }
+
+  const frontMatterRegex = /^\s*---\s*[\r\n]+([\s\S]*?)\s*---\s*[\r\n]+/
+  const match = content.match(frontMatterRegex)
+
+  if (!match) {
+    const value = { frontMatter: {}, content }
+    frontMatterCache.set(filePath, { mtimeMs: stat.mtimeMs, size: stat.size, value })
+    return { frontMatter: {}, content }
+  }
+
+  let frontMatter = {}
+  try {
+    frontMatter = yaml.parse(match[1])
+  } catch (e) {
+    throw new Error(`Error parsing front matter in file at ${filePath}: ${e.message}`)
+  }
+
+  const contentWithoutFrontMatter = content.slice(match[0].length)
+  const value = { frontMatter, content: contentWithoutFrontMatter }
+  frontMatterCache.set(filePath, { mtimeMs: stat.mtimeMs, size: stat.size, value })
+  return { frontMatter: { ...frontMatter }, content: contentWithoutFrontMatter }
+}
+
+export function clearFrontMatterCache(filePath) {
+  if (!filePath) {
+    frontMatterCache.clear()
+    return
+  }
+  frontMatterCache.delete(filePath)
+}
+
+const FORMAT_PRIORITY = ['avif', 'webp']
+
+export function discoverImageVariants(imagePath, outputDir) {
+  const parsed = path.parse(imagePath)
+  const dir = path.join(outputDir, parsed.dir)
+  const baseName = parsed.name
+  const originalExt = parsed.ext.replace('.', '')
+  const pattern = /^(.+)-(\d+)w\.([a-z0-9]+)$/
+
+  let files = []
+  try {
+    files = fs.readdirSync(dir)
+  } catch {
+    return { src: imagePath, variants: [] }
+  }
+
+  const variants = []
+  for (const file of files) {
+    const match = file.match(pattern)
+    if (!match) continue
+    const [, name, widthStr, format] = match
+    if (name !== baseName) continue
+    variants.push({
+      path: path.join(parsed.dir, file),
+      width: parseInt(widthStr, 10),
+      format
+    })
+  }
+
+  variants.sort((a, b) => a.width - b.width)
+
+  // Pick best format for srcset: highest priority format that has variants
+  const availableFormats = new Set(variants.map(v => v.format))
+  let srcsetFormat = null
+  for (const fmt of FORMAT_PRIORITY) {
+    if (availableFormats.has(fmt)) {
+      srcsetFormat = fmt
+      break
+    }
+  }
+  if (!srcsetFormat && availableFormats.has(originalExt)) {
+    srcsetFormat = originalExt
+  }
+  if (!srcsetFormat && availableFormats.size > 0) {
+    srcsetFormat = [...availableFormats][0]
+  }
+
+  const srcsetVariants = srcsetFormat ? variants.filter(v => v.format === srcsetFormat) : []
+
+  // Pick middle-sized variant in original format for src fallback
+  const originalVariants = variants.filter(v => v.format === originalExt)
+  let src = imagePath
+  if (originalVariants.length > 0) {
+    const mid = Math.floor((originalVariants.length - 1) / 2)
+    src = originalVariants[mid].path
+  } else if (srcsetVariants.length > 0) {
+    const mid = Math.floor((srcsetVariants.length - 1) / 2)
+    src = srcsetVariants[mid].path
+  }
+
+  return { src, variants: srcsetVariants }
+}
+
+export function replaceOutExtensions(outputPath) {
+  switch (path.extname(outputPath)) {
+    case '.md':
+      outputPath = outputPath.replace(/\.md$/, '.html')
+      break
+    case '.njk':
+      outputPath = outputPath.replace(/\.njk$/, '.html')
+      break
+    case '.liquid':
+      outputPath = outputPath.replace(/\.liquid$/, '.html')
+      break
+  }
+  return outputPath
+}
+
+export function getUpDirPrefix(relativeDir) {
+  if (relativeDir.trim() === '') return ''
+  if (relativeDir.startsWith('/')) relativeDir = relativeDir.slice(1)
+  if (relativeDir.endsWith('/')) relativeDir = relativeDir.slice(0, -1)
+  const relativePathParts = relativeDir.split('/')
+  let upDir = ''
+  for (let i = 0; i < relativePathParts.length; i++) {
+    upDir += '../'
+  }
+  return upDir
+}
+
+export function getRelativePathPrefix(outputDir, fromDir) {
+  let relativeDir = path.relative(process.cwd(), outputDir)
+  const fromRelativeDir = fromDir ? path.relative(process.cwd(), fromDir) : ''
+
+  if (fromRelativeDir && relativeDir.startsWith(fromRelativeDir)) {
+    relativeDir = relativeDir.replace(fromRelativeDir, '')
+  }
+
+  return getUpDirPrefix(relativeDir)
+}
+
+export function getPageUrl(outputPath) {
+  outputPath = replaceOutExtensions(outputPath)
+  return /index\.[a-z]+$/.test(path.basename(outputPath)) ? path.relative(process.cwd(), path.dirname(outputPath)) : path.relative(process.cwd(), outputPath)
+}
+
+export function getPageUrlRelativeToOutput(outputPath, outputDir) {
+  const pageUrl = getPageUrl(outputPath)
+  return path.relative(outputDir, pageUrl)
+}

package/lib/markup/highlight.js

@@ -0,0 +1,77 @@
+import hljs from 'highlight.js/lib/core'
+
+import javascript from 'highlight.js/lib/languages/javascript'
+import typescript from 'highlight.js/lib/languages/typescript'
+import css from 'highlight.js/lib/languages/css'
+import scss from 'highlight.js/lib/languages/scss'
+import xml from 'highlight.js/lib/languages/xml'
+import json from 'highlight.js/lib/languages/json'
+import bash from 'highlight.js/lib/languages/bash'
+import shell from 'highlight.js/lib/languages/shell'
+import python from 'highlight.js/lib/languages/python'
+import ruby from 'highlight.js/lib/languages/ruby'
+import php from 'highlight.js/lib/languages/php'
+import java from 'highlight.js/lib/languages/java'
+import c from 'highlight.js/lib/languages/c'
+import cpp from 'highlight.js/lib/languages/cpp'
+import csharp from 'highlight.js/lib/languages/csharp'
+import go from 'highlight.js/lib/languages/go'
+import rust from 'highlight.js/lib/languages/rust'
+import yaml from 'highlight.js/lib/languages/yaml'
+import markdown from 'highlight.js/lib/languages/markdown'
+import sql from 'highlight.js/lib/languages/sql'
+import diff from 'highlight.js/lib/languages/diff'
+
+hljs.registerLanguage('javascript', javascript)
+hljs.registerLanguage('js', javascript)
+hljs.registerLanguage('typescript', typescript)
+hljs.registerLanguage('ts', typescript)
+hljs.registerLanguage('css', css)
+hljs.registerLanguage('scss', scss)
+hljs.registerLanguage('html', xml)
+hljs.registerLanguage('xml', xml)
+hljs.registerLanguage('json', json)
+hljs.registerLanguage('bash', bash)
+hljs.registerLanguage('sh', bash)
+hljs.registerLanguage('shell', shell)
+hljs.registerLanguage('python', python)
+hljs.registerLanguage('py', python)
+hljs.registerLanguage('ruby', ruby)
+hljs.registerLanguage('rb', ruby)
+hljs.registerLanguage('php', php)
+hljs.registerLanguage('java', java)
+hljs.registerLanguage('c', c)
+hljs.registerLanguage('cpp', cpp)
+hljs.registerLanguage('csharp', csharp)
+hljs.registerLanguage('cs', csharp)
+hljs.registerLanguage('go', go)
+hljs.registerLanguage('rust', rust)
+hljs.registerLanguage('rs', rust)
+hljs.registerLanguage('yaml', yaml)
+hljs.registerLanguage('yml', yaml)
+hljs.registerLanguage('markdown', markdown)
+hljs.registerLanguage('md', markdown)
+hljs.registerLanguage('sql', sql)
+hljs.registerLanguage('diff', diff)
+
+function escapeHtml(str) {
+  return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;')
+}
+
+export function highlightCode(code, language) {
+  if (language) {
+    const lang = language.toLowerCase().trim()
+    if (hljs.getLanguage(lang)) {
+      return hljs.highlight(code, { language: lang }).value
+    }
+  }
+  return hljs.highlightAuto(code).value
+}
+
+export const highlightRenderer = {
+  code(code, lang) {
+    const highlighted = highlightCode(code, lang)
+    const langClass = lang ? ` language-${escapeHtml(lang)}` : ''
+    return `<pre><code class="hljs${langClass}">${highlighted}</code></pre>\n`
+  }
+}

package/lib/markup/indexer.js

@@ -0,0 +1,154 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { readJsonFile, fileSize } from '../utils/helpers.js'
+import log from '../utils/log.js'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const DEFAULT_STOP_WORDS_PATH = path.join(__dirname, 'stop-words-en.json')
+
+function loadStopWords(stopWordsOption) {
+  if (stopWordsOption === false) return new Set()
+  if (Array.isArray(stopWordsOption)) return new Set(stopWordsOption)
+
+  const filePath = typeof stopWordsOption === 'string'
+    ? path.resolve(process.cwd(), stopWordsOption)
+    : DEFAULT_STOP_WORDS_PATH
+
+  try {
+    return new Set(readJsonFile(filePath))
+  } catch (err) {
+    log({ tag: 'indexer', error: true, text: 'Failed loading stop words:', link: filePath })
+    return new Set()
+  }
+}
+
+const DEFAULTS = {
+  minWordLength: 3,
+  maxKeywords: 20,
+  globalFrequencyCeiling: 0.8
+}
+
+const INTERNAL_FIELDS = new Set(['content', 'isIndex', 'layout', 'published'])
+
+function normalizeConfig(config) {
+  if (!config) return null
+  if (typeof config === 'string') return { output: config, ...DEFAULTS }
+  return { ...DEFAULTS, ...config }
+}
+
+export function extractKeywords(htmlContent, options = {}) {
+  const { minWordLength = DEFAULTS.minWordLength, stopWords = new Set() } = options
+
+  const text = htmlContent.replace(/<[^>]*>/g, ' ')
+  const words = text
+    .toLowerCase()
+    .replace(/[^a-z0-9\-\s]/g, ' ')
+    .split(/\s+/)
+    .filter(w => w.length >= minWordLength && !stopWords.has(w) && !/^\d+$/.test(w))
+
+  const freq = new Map()
+  for (const word of words) {
+    freq.set(word, (freq.get(word) || 0) + 1)
+  }
+
+  return [...freq.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .map(([word]) => word)
+}
+
+function applyGlobalFrequencyCeiling(entries, ceiling) {
+  const totalPages = entries.length
+  if (totalPages === 0) return entries
+
+  const maxAppearances = Math.max(1, Math.floor(totalPages * ceiling))
+
+  const wordPageCount = new Map()
+  for (const entry of entries) {
+    const seen = new Set(entry.keywords)
+    for (const word of seen) {
+      wordPageCount.set(word, (wordPageCount.get(word) || 0) + 1)
+    }
+  }
+
+  const tooCommon = new Set()
+  for (const [word, count] of wordPageCount) {
+    if (count > maxAppearances) tooCommon.add(word)
+  }
+
+  if (tooCommon.size === 0) return entries
+
+  for (const entry of entries) {
+    entry.keywords = entry.keywords.filter(w => !tooCommon.has(w))
+  }
+
+  return entries
+}
+
+function escapeXml(str) {
+  return str
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;')
+}
+
+export function generateSearchIndex(pageEntries, outputDir, config) {
+  config = normalizeConfig(config)
+  if (!config) return
+
+  const stopWords = loadStopWords(config.stopWords)
+
+  let entries = pageEntries
+    .filter(e => !e.isIndex)
+    .map(e => {
+      const entry = {}
+      for (const [key, value] of Object.entries(e)) {
+        if (!INTERNAL_FIELDS.has(key)) entry[key] = value
+      }
+      if (!entry.keywords) {
+        entry.keywords = extractKeywords(e.content || '', { ...config, stopWords })
+          .slice(0, config.maxKeywords)
+      }
+      return entry
+    })
+
+  entries = applyGlobalFrequencyCeiling(entries, config.globalFrequencyCeiling)
+
+  const outputPath = path.join(process.cwd(), outputDir, config.output)
+  fs.writeFileSync(outputPath, JSON.stringify(entries, null, 2))
+  log({ tag: 'indexer', text: 'Generated search index:', link: path.relative(process.cwd(), outputPath), size: fileSize(outputPath) })
+}
+
+export function generateSitemap(pageEntries, outputDir, siteUrl, config) {
+  config = normalizeConfig(config)
+  if (!config) return
+
+  const baseUrl = siteUrl ? siteUrl.replace(/\/+$/, '') : ''
+
+  let xml = '<?xml version="1.0" encoding="UTF-8"?>\n'
+  xml += '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n'
+
+  for (const entry of pageEntries) {
+    const loc = baseUrl ? `${baseUrl}/${entry.url}` : entry.url
+    xml += '  <url>\n'
+    xml += `    <loc>${escapeXml(loc)}</loc>\n`
+    if (entry.date) {
+      const dateStr = new Date(entry.date).toISOString().slice(0, 10)
+      xml += `    <lastmod>${dateStr}</lastmod>\n`
+    }
+    xml += '  </url>\n'
+  }
+
+  xml += '</urlset>\n'
+
+  const outputPath = path.join(process.cwd(), outputDir, config.output)
+  fs.writeFileSync(outputPath, xml)
+  log({ tag: 'indexer', text: 'Generated sitemap:', link: path.relative(process.cwd(), outputPath), size: fileSize(outputPath) })
+}
+
+export function generateIndexFiles(pageEntries, outputDir, siteUrl, config) {
+  generateSearchIndex(pageEntries, outputDir, config.searchIndex)
+  generateSitemap(pageEntries, outputDir, siteUrl, config.sitemap)
+}

package/lib/markup/stop-words-en.json

@@ -0,0 +1,25 @@
+[
+  "a", "ab", "about", "above", "after", "again", "against", "all", "am", "an",
+  "and", "any", "are", "as", "at", "be", "because", "been", "before", "being",
+  "below", "between", "both", "but", "by", "can", "could", "did", "do", "does",
+  "doing", "down", "during", "each", "few", "for", "from", "further", "get",
+  "got", "had", "has", "have", "having", "he", "her", "here", "hers", "herself",
+  "him", "himself", "his", "how", "i", "if", "in", "into", "is", "it", "its",
+  "itself", "just", "let", "like", "may", "me", "might", "more", "most", "must",
+  "my", "myself", "no", "nor", "not", "now", "of", "off", "on", "once", "only",
+  "or", "other", "our", "ours", "ourselves", "out", "over", "own", "per", "same",
+  "she", "should", "so", "some", "such", "than", "that", "the", "their", "theirs",
+  "them", "themselves", "then", "there", "these", "they", "this", "those", "through",
+  "to", "too", "under", "until", "up", "upon", "us", "very", "was", "we", "were",
+  "what", "when", "where", "which", "while", "who", "whom", "why", "will", "with",
+  "would", "you", "your", "yours", "yourself", "yourselves",
+  "also", "come", "even", "every", "find", "first", "give", "go", "going",
+  "gone", "good", "great", "help", "here", "href", "http", "https", "keep", "know",
+  "last", "long", "look", "made", "make", "many", "much", "need", "new", "next",
+  "old", "one", "part", "put", "right", "said", "say", "see", "set", "since",
+  "still", "take", "tell", "thing", "think", "time", "two", "use", "used", "using",
+  "want", "way", "well", "work", "www", "year",
+  "class", "div", "span", "true", "false", "null", "undefined", "var", "const",
+  "function", "return",
+  "amp", "quot", "nbsp", "apos", "mdash", "ndash", "hellip", "laquo", "raquo"
+]