tackbox 0.1.0

package/bin/tackbox-eslint.js

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+const path = require('path')
+const fs = require('fs')
+const { ESLint } = require('eslint')
+
+const REPORTERS_FLAG = '--reporters='
+
+// Split argv into declared reporters (`--reporters=file#func,...`) and the
+// files to lint.
+function parseArgv(argv) {
+  const decls = []
+  const files = []
+  let machine = false
+  for (const a of argv) {
+    if (a === '--machine') {
+      machine = true
+    } else if (a.startsWith(REPORTERS_FLAG)) {
+      for (const d of a.slice(REPORTERS_FLAG.length).split(',')) {
+        if (!d) continue
+        const hash = d.lastIndexOf('#')
+        if (hash > 0) decls.push({ raw: d, file: d.slice(0, hash), fn: d.slice(hash + 1) })
+      }
+    } else {
+      files.push(a)
+    }
+  }
+  return { decls, files, machine }
+}
+
+function parseModule(file, code) {
+  const ext = path.extname(file)
+  if (ext === '.ts' || ext === '.tsx') {
+    return require('@typescript-eslint/parser').parse(code, {
+      ecmaVersion: 'latest',
+      sourceType: 'module',
+    })
+  }
+  if (ext === '.svelte') {
+    return require('svelte-eslint-parser').parse(code, {})
+  }
+  return require('espree').parse(code, { ecmaVersion: 'latest', sourceType: 'module' })
+}
+
+// hasBinding: the AST defines a function or const-arrow named `name`. Existence
+// check for `.tackbox-reporters` symbol validation; a deep walk keeps it parser
+// shape-agnostic across espree / ts / svelte.
+function hasBinding(ast, name) {
+  const seen = new Set()
+  let found = false
+  const visit = node => {
+    if (found || !node || typeof node !== 'object' || seen.has(node)) return
+    seen.add(node)
+    if (Array.isArray(node)) {
+      for (const c of node) visit(c)
+      return
+    }
+    if (node.type === 'FunctionDeclaration' && node.id && node.id.name === name) {
+      found = true
+      return
+    }
+    if (
+      node.type === 'VariableDeclarator' &&
+      node.id && node.id.type === 'Identifier' && node.id.name === name &&
+      node.init &&
+      (node.init.type === 'ArrowFunctionExpression' || node.init.type === 'FunctionExpression')
+    ) {
+      found = true
+      return
+    }
+    for (const k of Object.keys(node)) {
+      if (k === 'parent' || k === 'loc' || k === 'range' || k === 'tokens' || k === 'comments') continue
+      const c = node[k]
+      if (c && typeof c === 'object') visit(c)
+    }
+  }
+  visit(ast)
+  return found
+}
+
+// Validate every declaration's symbol, independent of the lint scope: a dead
+// `file#function` fails the whole run even when that file is not being linted.
+function validateDeclarations(decls) {
+  for (const d of decls) {
+    const abs = path.resolve(process.cwd(), d.file)
+    let code
+    try {
+      code = fs.readFileSync(abs, 'utf8')
+    } catch (e) {
+      throw new Error(`.tackbox-reporters: cannot read ${d.file}: ${e.message}`, { cause: e })
+    }
+    let ast
+    try {
+      ast = parseModule(d.file, code)
+    } catch (e) {
+      throw new Error(`.tackbox-reporters: cannot parse ${d.file}: ${e.message}`, { cause: e })
+    }
+    if (!hasBinding(ast, d.fn)) {
+      throw new Error(`.tackbox-reporters: no top-level function ${d.fn} in ${d.file}`)
+    }
+  }
+}
+
+// Internal machine contract: one {file, line, rule} JSON object per error, for
+// the hook. Human (stylish) output is unchanged. A message with no line emits
+// line: null (location-unknown) - the caller over-reports, never drops it.
+function emitMachine(results) {
+  for (const r of results) {
+    const file = path.relative(process.cwd(), r.filePath)
+    for (const m of r.messages) {
+      if (m.severity !== 2) continue
+      process.stdout.write(JSON.stringify({ file, line: m.line ?? null, rule: m.ruleId, message: m.message }) + '\n')
+    }
+  }
+}
+
+async function main() {
+  const { decls, files, machine } = parseArgv(process.argv.slice(2))
+  if (files.length === 0) {
+    process.stderr.write('tackbox-eslint: no files supplied\n')
+    process.exit(2)
+  }
+  validateDeclarations(decls)
+  const eslint = new ESLint({
+    // Inline directives (eslint-disable ... tackbox/<rule>) would be an
+    // uninventoried, ungated bypass of every tackbox JS rule. Closed here on
+    // the hermetic/published wrapper path; the preset closes it for consumers.
+    allowInlineConfig: false,
+    overrideConfigFile: path.join(__dirname, '..', 'eslint.config.preset.js'),
+    overrideConfig: [{ settings: { tackbox: { reporters: decls.map(d => d.raw) } } }],
+  })
+  const results = await eslint.lintFiles(files)
+  if (machine) {
+    emitMachine(results)
+  } else {
+    const formatter = await eslint.loadFormatter('stylish')
+    const output = await formatter.format(results)
+    if (output) process.stdout.write(output + '\n')
+  }
+  const fail = results.some(r => r.errorCount > 0 || r.fatalErrorCount > 0)
+  process.exit(fail ? 1 : 0)
+}
+
+// no-report: CLI bootstrap, no reporter wired before main() runs
+main().catch(err => {
+  process.stderr.write('tackbox-eslint: ' + (err && err.stack || err) + '\n')
+  process.exit(2)
+})

package/bin/tackbox-mdlint.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+const { lint } = require('markdownlint/promise')
+const noNonAscii = require('../js/markdownlint-rules/no-non-ascii')
+
+async function run() {
+  const argv = process.argv.slice(2)
+  const machine = argv.includes('--machine')
+  const files = argv.filter(a => a !== '--machine')
+  if (files.length === 0) {
+    process.stderr.write('tackbox-mdlint: no files supplied\n')
+    process.exit(2)
+  }
+  const result = await lint({
+    files,
+    config: { default: true, 'no-non-ascii': true },
+    customRules: [noNonAscii],
+    noInlineConfig: true,
+  })
+  let count = 0
+  for (const [file, errors] of Object.entries(result)) {
+    for (const e of errors) {
+      count++
+      if (machine) {
+        // Internal {file, line, rule} contract for the hook; human output below
+        // is unchanged.
+        const message = e.ruleDescription + (e.errorDetail ? ' [' + e.errorDetail + ']' : '')
+        process.stdout.write(JSON.stringify({ file, line: e.lineNumber, rule: e.ruleNames[0], message }) + '\n')
+        continue
+      }
+      const col = e.errorRange ? ':' + e.errorRange[0] : ''
+      const detail = e.errorDetail ? ' [' + e.errorDetail + ']' : ''
+      const name = e.ruleNames.slice(0, 2).join('/')
+      process.stdout.write(
+        file + ':' + e.lineNumber + col + ' ' + name + ' ' + e.ruleDescription + detail + '\n'
+      )
+    }
+  }
+  process.exit(count > 0 ? 1 : 0)
+}
+
+// no-report: CLI bootstrap, no reporter wired before run() executes
+run().catch(err => {
+  process.stderr.write('tackbox-mdlint: ' + (err && err.stack || err) + '\n')
+  process.exit(2)
+})

package/eslint.config.preset.js

@@ -0,0 +1,21 @@
+const tackbox = require('./js/eslint-plugin.js')
+const tsParser = require('@typescript-eslint/parser')
+const svelteParser = require('svelte-eslint-parser')
+
+const base = {
+  plugins: { tackbox },
+  rules: tackbox.configs.recommended.rules,
+  // Inline eslint-disable directives would silently defeat every tackbox rule;
+  // closed for consumers who use this flat config directly.
+  linterOptions: { noInlineConfig: true },
+}
+
+module.exports = [
+  { files: ['**/*.{js,mjs,cjs,jsx}'], ...base },
+  { files: ['**/*.{ts,tsx}'], languageOptions: { parser: tsParser }, ...base },
+  {
+    files: ['**/*.svelte'],
+    languageOptions: { parser: svelteParser, parserOptions: { parser: tsParser } },
+    ...base,
+  },
+]

package/js/README.md

@@ -0,0 +1,209 @@
+# tackbox (JS / TS / Svelte)
+
+ESLint plugin + browser report helper. Implements the
+`error-reporting-and-coverage` and `error-handling-frontend` specs.
+
+## Linting
+
+The frontend rules run through the hermetic tackbox CLI, which bundles
+ESLint, the parsers, and this plugin - no `npm install` is needed to
+lint:
+
+```bash
+uvx tackbox@latest lint .
+```
+
+## Direct ESLint integration
+
+To wire the plugin into your own ESLint run instead, install it from
+npm:
+
+```bash
+npm install --save-dev tackbox eslint
+```
+
+`@typescript-eslint/parser` and `svelte-eslint-parser` ship as direct
+dependencies, so `.ts`, `.tsx`, `.svelte`, and `<script lang="ts">`
+blocks work out of the box. The plugin exposes a `recommended` config:
+
+```js
+import tackbox from 'tackbox'
+
+export default [
+  {
+    plugins: { tackbox },
+    rules: tackbox.configs.recommended.rules,
+  },
+]
+```
+
+Or run the bundled preset via the bin wrapper:
+
+```bash
+npx tackbox-eslint src/**/*.{ts,svelte}
+```
+
+## Rules
+
+| Rule                               | Summary                              |
+|------------------------------------|--------------------------------------|
+| `tackbox/no-swallow-catch`         | catch must throw, report, or marker  |
+| `tackbox/no-swallow-promise-catch` | .catch/.then rejection handler       |
+| `tackbox/no-swallow-allsettled`    | allSettled result must read .reason  |
+| `tackbox/no-console-error`         | banned; use `reportError`            |
+| `tackbox/valid-error-report`       | static msg + cause + tags + dedupKey |
+| `tackbox/valid-dedup-key`          | static `area.suffix[:identifier]`    |
+| `tackbox/no-throw-and-report`      | catch: no throw+report, no cap+notify|
+| `tackbox/no-broad-notify`          | notify must sit under a condition    |
+| `tackbox/no-parse-fallback`        | JSON.parse catch must propagate err  |
+| `tackbox/ts-rethrow-without-cause` | `throw new` in catch needs `{cause}` |
+| `tackbox/ts-useless-catch`         | catch that only re-throws is a no-op |
+| `tackbox/ts-exit-in-catch`         | no `process.exit` inside catch       |
+| `tackbox/no-skipped-test`          | skip/todo needs `test-skip:` marker  |
+| `tackbox/no-focused-test`          | banned `.only`/`f`-tests; no escape  |
+
+Full constraints per rule:
+
+- `no-swallow-catch` - `catch` must throw, call a reporter, or have
+  `// no-report: <reason>` above the `try`.
+- `no-swallow-promise-catch` - a promise rejection handler must throw,
+  call a reporter, call the enclosing `new Promise(...)` executor's
+  reject parameter (structural resolution, not the name), return the
+  caught error object itself (`e => e` - the rejection-to-value idiom;
+  wrapper objects stay refused), or carry the marker. The handler is
+  `.catch(onErr)` or the second argument of `.then(onOk, onErr)`
+  (`.then(onOk)` alone propagates the rejection and is not checked).
+- `no-swallow-allsettled` - every `Promise.allSettled` call needs at
+  least one `.reason` access in the enclosing function, or the rejected
+  outcomes are silently dropped (`allSettled` never rejects, so a
+  discarded result is the quietest swallow). Passing the result whole
+  to a helper is opaque and counts as a swallow. Escape with a
+  `// no-report: <reason>` marker above.
+- `no-console-error` - `console.error` is banned; use `reportError`.
+- `valid-error-report` - static 15-200 char msg, cause non-null,
+  tags non-empty, dedupKey required. `notify` shares the
+  `(msg, cause, tags, dedupKey)` shape and is validated the same way
+  (D007), though it is never credited as a reporter.
+- `valid-dedup-key` - dedupKey must be a static literal in
+  `area.suffix[:identifier]` form; `notify`'s dedupKey too (D008).
+- `no-throw-and-report` - a `catch` may not both throw and report; nor
+  may one path both capture and `notify` (D006 double-lane -
+  error/warn already reach the user lane, so the notify double-shows).
+- `no-broad-notify` - a `notify` carrying the caught error may
+  terminate a `catch` only when it sits under an additional condition
+  (an `if`/`switch` inside the catch); an unconditional notify as the
+  sole handling routes every error to a toast and blinds telemetry. The
+  complement stays covered by `no-swallow-catch`; a `// no-report:`
+  marker above the `try` suppresses.
+- `no-parse-fallback` - a `try` containing `JSON.parse` must propagate
+  the parse error on every `catch` path: `throw` the caught error
+  object, or return a Result boundary carrying it (`return { ok: false,
+  cause: <err> }` when the enclosing function returns Result/Attempt). A
+  fallback value, a stringified rethrow, or report-and-continue swallows
+  it (report + fallback is still a finding). Escape with a
+  `// parse-skip: <reason>` marker above the `try`.
+- `ts-rethrow-without-cause` - `throw new X(...)` in a `catch` must
+  pass `{ cause: <caught> }` to preserve the stack chain.
+- `ts-useless-catch` - a `catch` whose only statement re-throws the
+  caught error is a no-op wrapper; remove the try/catch.
+- `ts-exit-in-catch` - `process.exit(...)` inside a `catch` masks the
+  exception; let it propagate.
+- `no-skipped-test` - a skip/todo/skipIf in a chain rooted at bare
+  `it` / `test` / `describe` (`it.skip`, `test.todo`, `it.skipIf(c)(...)`,
+  `it.skip.each(...)(...)`), or a bare `xit` / `xdescribe` / `xtest`,
+  silently drops coverage. Chained forms report once, on the inner call.
+  A deeper root (`queue.skip`, `foo.test.skip`) is out of scope. Escape
+  with a `// test-skip: <reason>` marker directly above the statement.
+- `no-focused-test` - a `.only` in a chain rooted at bare `it` / `test` /
+  `describe` (`it.only`, `describe.only`, `test.only.each(...)(...)`), or a
+  bare `fit` / `fdescribe` / `ftest`, disables the rest of the suite. No
+  escape hatch; the focused test must be removed.
+
+## Reporter recognition
+
+A call counts as a reporter only when its callee resolves to one of the
+reporter names imported from `tackbox` / `tackbox/report` (tier-1), or
+to a function declared in a repo-root `.tackbox-reporters` file
+(tier-2). A bare identifier that merely shares the name is not trusted.
+
+Names: `reportError`, `reportWarn`, `reportQuiet`, `reportApiError`,
+`reportLayerError` (4-arg form: msg, cause, tags, dedupKey) and `reportSynth`,
+`reportSynthError` (3-arg form: msg, tags, dedupKey).
+
+`notify` (user lane only) is resolved through the same origin gate but
+is deliberately not a reporter name: it never credits a swallow as a
+capture. `no-broad-notify` gates it, and `valid-error-report` /
+`valid-dedup-key` validate its msg and dedupKey.
+
+Tier-1 covers named, renamed, default- or namespace-member, and CJS
+`require('tackbox/report')` forms. The strict argument contracts
+(`valid-error-report`, `valid-dedup-key`) apply
+to tier-1 calls; declared sinks carry only the argument-flow contract
+(the caught error must flow into the call).
+
+`.tackbox-reporters` lines are `file#function: reason`. The `tackbox`
+CLI parses and validates the file. When you consume this ESLint plugin
+directly (without the CLI), populate `settings.tackbox.reporters` (a
+list of `"file#function"` strings) in your own config; symbol
+validation is the CLI's responsibility and is not performed in that
+mode.
+
+## Report helper
+
+```js
+import { init, reportError, reportWarn, setupGlobalHandlers, flush } from 'tackbox/report'
+
+init({
+  dsn: import.meta.env.VITE_SENTRY_DSN || '',
+  release: import.meta.env.VITE_VERSION,
+  verify: true,         // confirm connectivity at startup
+  debug: false,
+})
+setupGlobalHandlers()
+// ... on shutdown:
+await flush(2000)
+
+// in app code:
+try {
+  await fetchSomething()
+} catch (err) {
+  reportError('failed to fetch projects from API', err, { area: 'projects' }, 'projects.fetch')
+}
+```
+
+Empty DSN: `init` logs a WARN (suppressible via `silentMissing`)
+and stays log-only. `init({ verify: true })` sends one healthcheck
+event with `fingerprint: ["report.startup"]` and flushes; glitchtip
+groups all startups under one issue, no spam.
+
+## Bundled API
+
+- `init(opts)`, `flush(timeout)`, `verify(timeout)`, `isReady()`
+- `reportError(msg, cause, tags, dedupKey)` - log + user lane + capture
+- `reportWarn(msg, cause, tags, dedupKey)` - log + user lane + capture
+- `reportQuiet(msg, cause, tags, dedupKey)` - log + warning-level capture,
+  no user lane (background / self-healed / degraded-with-fallback)
+- `notify(msg, cause, tags, dedupKey)` - log + user lane only, no capture
+  and no rate-window state touched (an expected environmental fault, e.g.
+  the user lost connectivity)
+- `reportSynthError(msg, tags, dedupKey)`
+- `reportPanic(name, recovered)`
+- `setupGlobalHandlers()` wires `window.error` and
+  `window.unhandledrejection` to `reportError`
+
+The `tackbox:error` custom event is the user lane: it is dispatched on the
+window before the init + rate-window gate (and is never rate-limited) after
+each `reportError` / `reportWarn` / `notify` / `reportPanic` call, so a
+single top-level component can render a toast. `reportQuiet` does not
+dispatch it. The event `detail` carries `{ msg, cause, tags, dedupKey,
+level }`; the listener coalesces on `dedupKey`. Capture is gated behind init
+and the per-`dedupKey` rate window; the user lane is not.
+
+Platform limit: a `tackbox:error` listener that throws is not observable from
+`dispatchEvent` - the browser routes a listener failure to `window.onerror` by
+design. So the JS user lane cannot capture its own listener's failure the way
+Go, Python, and Java capture a throwing `report.notifier`. A module-level
+re-entrancy guard stops the one loop this opens (a throwing listener reaching
+`window.onerror`, which `setupGlobalHandlers` turns back into
+`reportError` -> dispatch): a dispatch already in progress on the stack skips
+the nested one and logs locally instead. Sequential dispatches are unaffected.

package/js/eslint-plugin.js

@@ -0,0 +1,48 @@
+// ESLint plugin: error-reporting-and-coverage rules for JS/TS/Svelte.
+// Mirrors the Go ruleset (ERC001-006) with the frontend variants from
+// the error-handling-frontend spec.
+
+const noSwallowCatch = require('./rules/no-swallow-catch')
+const noSwallowPromiseCatch = require('./rules/no-swallow-promise-catch')
+const noSwallowAllsettled = require('./rules/no-swallow-allsettled')
+const noConsoleError = require('./rules/no-console-error')
+const validErrorReport = require('./rules/valid-error-report')
+const noThrowAndReport = require('./rules/no-throw-and-report')
+const noBroadNotify = require('./rules/no-broad-notify')
+const noParseFallback = require('./rules/no-parse-fallback')
+const validDedupKey = require('./rules/valid-dedup-key')
+const tsRethrowWithoutCause = require('./rules/ts-rethrow-without-cause')
+const tsUselessCatch = require('./rules/ts-useless-catch')
+const tsExitInCatch = require('./rules/ts-exit-in-catch')
+const noSkippedTest = require('./rules/no-skipped-test')
+const noFocusedTest = require('./rules/no-focused-test')
+
+const rules = {
+  'no-swallow-catch': noSwallowCatch,
+  'no-swallow-promise-catch': noSwallowPromiseCatch,
+  'no-swallow-allsettled': noSwallowAllsettled,
+  'no-console-error': noConsoleError,
+  'valid-error-report': validErrorReport,
+  'no-throw-and-report': noThrowAndReport,
+  'no-broad-notify': noBroadNotify,
+  'no-parse-fallback': noParseFallback,
+  'valid-dedup-key': validDedupKey,
+  'ts-rethrow-without-cause': tsRethrowWithoutCause,
+  'ts-useless-catch': tsUselessCatch,
+  'ts-exit-in-catch': tsExitInCatch,
+  'no-skipped-test': noSkippedTest,
+  'no-focused-test': noFocusedTest,
+}
+
+module.exports = {
+  meta: { name: 'tackbox', version: '0.1.0' },
+  rules,
+  configs: {
+    recommended: {
+      plugins: ['tackbox'],
+      rules: Object.fromEntries(
+        Object.keys(rules).map(name => [`tackbox/${name}`, 'error']),
+      ),
+    },
+  },
+}

package/js/markdownlint-rules/no-non-ascii.js

@@ -0,0 +1,132 @@
+// Custom markdownlint rule: flag any character outside the printable
+// ASCII range (codepoints > 0x7F). Keeps docs strictly ASCII so
+// em-dashes, curly quotes, Cyrillic, box-drawing chars, emoji, etc.
+// cannot leak into prose, tables, or code fences.
+//
+// One escape hatch: a language marker in an HTML comment within the first
+// 5 lines widens the alphabet for that one file to a declared language's
+// script (plus a little typographic punctuation). It never disables the
+// rule - every other non-ASCII character (emoji, zero-width, other
+// scripts) is still flagged, and a misplaced / duplicate / malformed
+// marker is a finding that leaves the file strict-ASCII.
+//
+//   <!-- tackbox: lang=ru personal experimental repo -->
+//
+// The marker is read from micromark HTML-comment tokens, not params.lines:
+// markdownlint masks HTML-comment interiors in `lines`, so the raw code is
+// only visible in the parse tree.
+
+// code -> extra codepoints allowed when a valid marker declares it. Add a
+// language by adding one entry: its script range(s) plus the typographic
+// punctuation its prose uses.
+const LANG_SCRIPTS = {
+  ru: {
+    // Cyrillic (U+0400-U+04FF).
+    ranges: [[0x0400, 0x04ff]],
+    // Typographic punctuation common in Russian prose: em/en dash,
+    // guillemets, ellipsis, curly single/double quotes (incl. low
+    // opening quotes), NBSP.
+    punct: [
+      0x2014, 0x2013, 0x00ab, 0x00bb, 0x2026,
+      0x2018, 0x2019, 0x201c, 0x201d, 0x201e, 0x201a, 0x00a0,
+    ],
+  },
+}
+
+const MARKER_MAX_LINE = 5
+const MARKER_RE = /<!--\s*tackbox:\s*lang=([^\s>]*)[^>]*-->/g
+
+function collectMarkers(token, found) {
+  for (const m of token.text.matchAll(MARKER_RE)) {
+    const before = token.text.slice(0, m.index)
+    const lineOffset = (before.match(/\n/g) || []).length
+    const lastNl = before.lastIndexOf('\n')
+    found.push({
+      lineNumber: token.startLine + lineOffset,
+      code: m[1],
+      col: lineOffset === 0 ? token.startColumn + m.index : m.index - lastNl,
+      len: m[0].length,
+    })
+  }
+}
+
+// Every marker occurrence in the file's HTML comments: {lineNumber, code,
+// col, len}. Walks the micromark tree; htmlFlow / htmlText carry the raw
+// comment text (their children just re-slice it, so we do not descend).
+function findMarkers(tokens) {
+  const found = []
+  const walk = (toks) => {
+    for (const t of toks) {
+      if (t.type === 'htmlFlow' || t.type === 'htmlText') {
+        collectMarkers(t, found)
+        continue
+      }
+      if (t.children && t.children.length) walk(t.children)
+    }
+  }
+  walk(tokens)
+  return found
+}
+
+// Validate the marker set; emit findings for a misplaced / duplicate /
+// malformed / unknown marker. Return the allow-config for a single valid
+// marker, or null (strict ASCII-only) for no marker or any invalid one.
+function resolveMarkers(markers, onError) {
+  if (markers.length === 0) return null
+  const markerErr = (m, detail) =>
+    onError({ lineNumber: m.lineNumber, detail, range: [m.col, m.len] })
+
+  if (markers.length > 1) {
+    for (const dup of markers.slice(1)) {
+      markerErr(dup, 'duplicate tackbox lang marker (one marker per file)')
+    }
+    return null
+  }
+  const m = markers[0]
+  if (m.lineNumber > MARKER_MAX_LINE) {
+    markerErr(m, `tackbox lang marker must be within the first ${MARKER_MAX_LINE} lines`)
+    return null
+  }
+  if (m.code === '') {
+    markerErr(m, 'tackbox lang marker is missing a language code')
+    return null
+  }
+  const cfg = LANG_SCRIPTS[m.code]
+  if (!cfg) {
+    markerErr(m, `tackbox lang marker: unsupported language code '${m.code}'`)
+    return null
+  }
+  return cfg
+}
+
+function isWidened(code, allow) {
+  if (!allow) return false
+  for (const [lo, hi] of allow.ranges) {
+    if (code >= lo && code <= hi) return true
+  }
+  return allow.punct.includes(code)
+}
+
+module.exports = {
+  names: ['MD-ASCII', 'no-non-ascii'],
+  description: 'Non-ASCII character',
+  tags: ['ascii'],
+  parser: 'micromark',
+  function: function rule(params, onError) {
+    const allow = resolveMarkers(findMarkers(params.parsers.micromark.tokens), onError)
+    params.lines.forEach((line, idx) => {
+      let col = 0
+      for (const ch of line) {
+        const code = ch.codePointAt(0)
+        if (code > 0x7f && !isWidened(code, allow)) {
+          onError({
+            lineNumber: idx + 1,
+            detail: 'Non-ASCII character U+' + code.toString(16).toUpperCase() + ' (' + ch + ')',
+            range: [col + 1, ch.length],
+          })
+        }
+        col += ch.length
+      }
+    })
+  },
+}