mdeval 1.6.0 → 2.0.0

package/skills/mdeval/SKILL.md

@@ -1,110 +1,61 @@
 ---
 name: mdeval
-description: Evaluates JavaScript in markdown HTML comments and interpolates results in-place. Use when editing markdown files that contain mdeval script blocks or value markers, when the user wants computed/dynamic values in markdown, or when maintaining README badges, version numbers, or stats.
+description: Editing Markdown that contains `<!--mdeval` script blocks or value markers; adding computed values to Markdown, such as versions, counts, file contents, command output, or generated tables; running the `mdeval` CLI or `mdeval/loader`, or debugging their output.
 ---
 
 # mdeval
 
-## When to use
-
-- Markdown contains values derived from code, files, APIs, or shell commands
-- README stats, version numbers, dependency counts, or computed tables
-- Any value where accuracy matters — counts, sizes, dates, calculations
-- Auditable content — the expression proves the value is correct, not just asserted
+This skill covers writing mdeval code in Markdown and running it. mdeval evaluates the code and writes each result into the file.
 
 ## Syntax
 
-Two types of HTML comments — invisible when rendered:
+| Type | Syntax | Starts with |
+| --- | --- | --- |
+| Script block | `<!--mdeval\n...code...\n-->` | `<!--mdeval` + newline |
+| Value marker | `<!--mdeval EXPR-->value<!--/mdeval-->` | `<!--mdeval` + space |
 
-| Type | Syntax | Purpose |
-|------|--------|---------|
-| Script block | `<!--mdeval\n...\n-->` | Define variables, imports, logic. Starts with `<!--mdeval` + newline |
-| Value marker | `<!--mdeval EXPR-->value<!--/mdeval-->` | Interpolate expression result. Starts with `<!--mdeval ` + space |
+- All script blocks in a file form one ES module with full Node.js access and top-level `await`. Their imports and variables are visible to every marker in the file. Blocks are joined in order, so a block starting with `(`, `[`, or a template literal can continue the previous block's last statement unless it ends with a semicolon.
+- `import.meta` refers to the Markdown file, so relative imports and paths resolve from it.
+- Place script blocks at the top of the file. Their position relative to markers does not affect execution, but script blocks execute in their own order. Static imports from all blocks load before any block's code runs, so use dynamic `import()` when an earlier block must set up something an import reads at load time.
+- Scripts and markers can use TypeScript syntax that Node.js strips: type annotations, `interface`, `type`, `as`, `satisfies`, and `!`. Do not use `enum`, `namespace` with values, or constructor parameter properties; they fail at runtime. Markdown under `node_modules` runs as plain JavaScript.
 
-Script blocks run as ESM with full Node.js access and top-level `await`. All blocks in a file merge into one module — imports and variables are shared across blocks and markers. `import.meta` points to the markdown file. Marker expressions are auto-awaited, so promises resolve automatically.
+## Markers
 
-## Marker Expressions
+A marker expression is anything valid after `const x =`. mdeval awaits it, converts the result to text, and replaces the value between `-->` and `<!--/mdeval-->`. An expression that appears in several markers is evaluated once.
 
-Any JavaScript expression valid on the right side of `const x =`:
+Line breaks in values use the line ending most common outside marker values. Ties favor LF, then CRLF; if absent, LF is used.
 
-| Expression | Example |
-|------------|---------|
-| Variable | `<!--mdeval name-->value<!--/mdeval-->` |
-| Property access | `<!--mdeval data.version-->value<!--/mdeval-->` |
-| Computation | `<!--mdeval items.length + " items"-->value<!--/mdeval-->` |
-| IIFE | `<!--mdeval (() => { const x = 1 + 1; return x; })()-->value<!--/mdeval-->` |
+| Result | Written as |
+| --- | --- |
+| `string` | As is, with line breaks converted to the file's line ending |
+| Object with `Symbol.toPrimitive`, such as zx output | `String(value)` |
+| Other object or array | `JSON.stringify(value)` |
+| `undefined` or `null` | Error |
+| Anything else | `String(value)` |
 
-Duplicate expressions across markers are evaluated once and reused.
+Keep logic that one marker needs inside that marker. Markers can span lines, and an IIFE holds statements:
 
-## Value Coercion
+````markdown
+<!--mdeval (() => {
+  const n = 3;
+  return n % 2 === 0 ? 'even' : 'odd';
+})()-->odd<!--/mdeval-->
+````
 
-| Type | Result |
-|------|--------|
-| `string` | As-is |
-| `number`, `boolean`, `bigint` | `String(value)` |
-| `object`, `array` | `JSON.stringify(value)` |
-| object with `Symbol.toPrimitive` | `String(value)` (e.g. zx `ProcessOutput`) |
-| `Promise` | Auto-awaited, then coerced |
-| `undefined`, `null` | Error |
+Use script blocks for imports and for values that several markers share.
 
 ## Helpers
 
-| Helper | Description |
-|--------|-------------|
-| `block(value)` | Wraps value with newlines for block-level rendering |
-| `$` | [zx](https://google.github.io/zx/) shell — run commands via tagged templates: `` $`git branch` `` |
-
-| File | Access |
-|------|--------|
-| `.md` | Globals — call directly: `block(x)`, `` $`cmd` `` |
-| `.js`, `.ts`, anything else | `import { block, $ } from 'mdeval'` |
-
-CLI (and `--import mdeval/loader`) seeds the helpers on `globalThis` at startup. Modules imported transitively from a `.md` see them too, but in non-`.md` files prefer the explicit import. `import { block, $ } from 'mdeval'` is side-effect-free.
-
-## Importing `.md` exports from a script
-
-Use when a Node script (validation, migration, agent tooling) needs to read exports from a `.md`. Run the script with `--import mdeval/loader`:
-
-```bash
-node --import mdeval/loader ./consumer.js
-```
-
-`consumer.js` can use ordinary static imports against `.md` files:
-
-```js
-import { todos } from './TODOS.md';
-
-console.log(todos);
-```
-
-- `--import mdeval/loader` is a side-effect-only entry — seeds `block`/`$` on `globalThis` and registers the Node ESM loader before any of the script's imports link.
-- Without it, static `import` of a `.md` fails — Node can't resolve `.md` until the loader is registered.
-- The plain `mdeval` import (`import { block, $ } from 'mdeval'`) stays pure — no globals, no loader. Use it when you only want the helpers.
-- Works on `.md` directly too: `node --import mdeval/loader ./TODOS.md`.
-- Runtime stack traces from a `.md` point at original lines and columns automatically.
-
-## CLI
-
-```bash
-mdeval README.md                    # single file
-mdeval README.md docs/guide.md      # multiple files
-mdeval "docs/**/*.md"               # glob pattern
-mdeval "**/*.md"                    # recursive — node_modules and dotdirs auto-excluded
-```
-
-Supports full glob syntax including `**` recursive, `{a,b}` brace expansion, and `!` negation.
+| Helper | Use |
+| --- | --- |
+| `block(value)` | Puts the value on its own lines. Required for headings, lists, tables, and other block Markdown. |
+| `$` | Runs a shell command with [zx](https://google.github.io/zx/): `` $`git branch --show-current` `` |
 
-`node_modules` and hidden directories (`.git`, `.next`, etc.) are automatically excluded from glob expansion. No need to manually negate them. To explicitly include `node_modules`, reference it in the pattern: `mdeval "node_modules/pkg/*.md"`.
+Both are globals in `.md` files at runtime and when type-checked, without imports. Their types are visible throughout the TypeScript program; if another global conflicts, use a separate tsconfig for Markdown that excludes the conflicting declaration from all loaded files, including root files, imports, and `compilerOptions.types` inherited through `extends`. In `.js` and `.ts` files, import the helpers used: `import { block, $ } from 'mdeval'`.
 
 ## Patterns
 
-### Shell commands
-
-````markdown
-<!--mdeval $`git branch --show-current`-->main<!--/mdeval-->
-````
-
-### Read package.json
+Read `package.json`:
 
 ````markdown
 <!--mdeval
@@ -112,165 +63,123 @@ import fs from 'node:fs/promises';
 const pkg = JSON.parse(await fs.readFile('package.json', 'utf8'));
 -->
 
-Version: <!--mdeval pkg.version-->0.0.0<!--/mdeval-->
+Version: <!--mdeval pkg.version-->1.0.0<!--/mdeval-->
 ````
 
-### Import from other .md files
-
-Only script blocks are executed — markers are not processed:
+Shell output:
 
 ````markdown
-<!--mdeval
-import { version } from './data.md';
--->
-
-<!--mdeval version-->1.0.0<!--/mdeval-->
+Branch: <!--mdeval $`git branch --show-current`-->main<!--/mdeval-->
 ````
 
-If the imported `.md` may not yet have mdeval content (stubs filled in over time), use a **namespace import** — named imports against an empty module are rejected by Node's ESM linker, but missing properties on a namespace resolve to `undefined`:
+Typed data, which `tsc` can check:
 
 ````markdown
 <!--mdeval
-import * as data from './stub.md';
-const version = data.version ?? 'tbd';
+interface Release {
+  version: string;
+  date: string;
+}
+
+const releases = [
+  { version: '1.1.0', date: '2026-11-01' },
+  { version: '1.0.0', date: '2026-10-01' },
+] satisfies Release[];
 -->
-````
 
-### Generate Markdown with md-pen
+Latest: <!--mdeval releases[0].version-->1.1.0<!--/mdeval-->
+````
 
-Use [md-pen](https://github.com/privatenumber/md-pen) for formatted output (tables, lists, headings):
+Generated Markdown with [md-pen](https://github.com/privatenumber/md-pen). It must be installed in the project:
 
 ````markdown
 <!--mdeval
-import { table, bold, link } from 'md-pen';
-const deps = [['cleye', '^2.3.0'], ['md-pen', '^0.0.2']];
-const depsTable = table(deps.map(([name, v]) => [link(`https://npm.im/${name}`, bold(name)), v]));
+import { table } from 'md-pen';
 -->
 
-<!--mdeval block(depsTable)-->
+<!--mdeval block(table([
+  { Package: 'cleye', Version: '^2.3.0' },
+  { Package: 'md-pen', Version: '^0.0.2' },
+]))-->
 | Package | Version |
 | - | - |
-| [__cleye__](https://npm.im/cleye) | ^2.3.0 |
+| cleye | ^2.3.0 |
+| md-pen | ^0.0.2 |
 <!--/mdeval-->
 ````
 
-## Gotchas
-
-**Block-level values need `block()`.** Without it, block elements don't render:
+Data from another `.md` file. Importing a `.md` file runs only its script blocks:
 
 ````markdown
-<!-- ❌ Heading stays on same line as comment, won't render -->
-<!--mdeval heading-->### Title<!--/mdeval-->
+<!--mdeval
+import { version } from './data.md';
+-->
 
-<!-- ✅ block() adds newlines so the heading renders correctly -->
-<!--mdeval block(heading)-->
-### Title
-<!--/mdeval-->
+Version: <!--mdeval version-->1.0.0<!--/mdeval-->
 ````
 
-**Script code cannot contain `-->`** — it closes the HTML comment:
+If the imported file may not have mdeval code yet, use a namespace import. A named import of a missing export fails, but a missing namespace property is `undefined`:
 
 ````markdown
-<!-- ❌ --> in the string literal closes the comment prematurely -->
 <!--mdeval
-const x = "<!--/mdeval-->";
--->
-
-<!-- ✅ Build the string without --> -->
-<!--mdeval
-const x = String.fromCharCode(45, 45, 62);
+import * as data from './stub.md';
+const version = data.version ?? 'tbd';
 -->
 ````
 
-**Values cannot contain mdeval syntax.** Producing `<!--mdeval ` or `<!--/mdeval-->` in a value throws an error to prevent document corruption on re-parse.
-
-**Place scripts at the top.** Order doesn't affect execution — scripts can appear after the markers that reference them — but top placement signals the file contains generated content.
-
-**Markers can span multiple lines — use them to inline logic.** Don't cram expressions into one line. Co-locate marker-specific computation with its output:
-
-````markdown
-<!--mdeval block(table([
-  { name: 'cleye', version: '^2.3.0' },
-  { name: 'md-pen', version: '^0.0.2' },
-]))-->
-| Package | Version |
-| - | - |
-| cleye | ^2.3.0 |
-| md-pen | ^0.0.2 |
-<!--/mdeval-->
-````
+## Gotchas
 
-For statements or control flow, wrap in an IIFE: `<!--mdeval (() => { ... })()-->`. Reserve script blocks for shared imports or values referenced by multiple markers.
+**Block Markdown needs `block()`.** Without it, a heading, list, or table stays on the marker's line and does not render.
 
-**Standalone markers suppress inline markdown in the value.** When a marker opens a line — standalone paragraph, list item, or blockquote — GitHub treats the entire line as a raw HTML block. Inline markdown in the value (`` `code` ``, `**bold**`, `[link](url)`) is not processed and appears literally.
+**Script code cannot contain `-->` or `<!--mdeval` followed by a space or newline.** The first ends the HTML comment; the second makes mdeval report an unclosed script, even inside a string. Build the text instead, such as `'--' + '>'` or `'<!--' + 'mdeval '`. Rewrite `x-- > y` as `x -= 1; x > y`.
 
-````markdown
-<!-- ❌ backtick shows literally — line is an HTML block, not inline markdown -->
-<!--mdeval expr-->`value`<!--/mdeval-->
-````
+**Values cannot contain `<!--mdeval` followed by a space, a newline, or CRLF, or `<!--/mdeval-->`.** mdeval throws instead of writing them.
 
-Use a multi-line marker so the value occupies its own lines, which are processed as normal markdown. Use [md-pen](https://github.com/privatenumber/md-pen) to generate formatted values:
+**A marker that starts a line turns off inline Markdown in its value.** When a marker opens a paragraph, list item, or blockquote, GitHub treats the line as raw HTML, so `` `code` ``, `**bold**`, and links in the value appear literally. Wrap the value in `block()` so it renders on its own lines:
 
 ````markdown
 <!--mdeval
-import { code, bold, link } from 'md-pen';
+import { code } from 'md-pen';
 -->
 
-<!--mdeval code('asdf')-->
-`asdf`
+<!--mdeval block(code('value'))-->
+`value`
 <!--/mdeval-->
 ````
 
-Markers inside headings are always inline — markdown in the value always renders there.
+Markers inside headings, or after other text on a line, render inline Markdown normally.
 
-**Comments don't work in link URLs or image alt text.** GitHub escapes comment syntax in these positions:
+**Markers do not work in link URLs or image alt text.** GitHub shows or encodes the comment there instead of hiding it. mdeval warns about markers in alt text.
 
-````markdown
-<!-- ❌ comment is URL-encoded as href -->
-[text](<!-- comment -->)
+**`<details>` needs blank lines around `</summary>`.** Without them, block Markdown inside it renders as text. md-pen's `details(summary, content)` writes the correct shape.
 
-<!-- ❌ comment appears as visible alt text -->
-![<!-- comment -->](image.png)
-````
+**Examples in code are safe.** mdeval ignores markers in fenced, indented, and inline code, so Markdown can document mdeval syntax.
 
-**`<details>` requires blank lines around the `</summary>` close.** Block-level Markdown inside a `<details>` only renders when blank lines surround the closing `</summary>` tag — otherwise lists, code fences, tables, and other block elements render as literal text. md-pen's `details(summary, content)` emits the correct shape:
+**Do not create a `.md` file that only holds code.** mdeval warns about it. Put shared logic in a `.js` or `.ts` file and import it.
 
-````markdown
-<!--mdeval
-import { details, ul } from 'md-pen';
--->
+## CLI
 
-<!--mdeval block(details(
-  'Click me',
-  ul(['item one', 'item two']),
-))-->
-<details>
-<summary>Click me</summary>
+```bash
+mdeval README.md "docs/**/*.md"
+```
 
-- item one
-- item two
+- mdeval updates each file in place and prints the path of each file it changed.
+- For CI, run `npx mdeval --check "**/*.md"` to report outdated files and exit 1 without rewriting; evaluation can still have side effects.
+- For a Lefthook pre-commit hook, use a job with `run: npx mdeval --check "**/*.md"` and no `glob`, so changes to non-Markdown inputs are checked too. When it fails, run `npx mdeval "**/*.md"`, review and stage the updates, and commit again. Do not rewrite files in the hook (with `stage_fixed` or `fail_on_changes`) or parse mdeval's stdout to stage files: Lefthook's rollback can discard unstaged edits, `stage_fixed` misses dependent files, and scripts can print to stdout.
+- Globs skip `node_modules` and hidden directories unless the pattern names them, such as `"node_modules/pkg/*.md"`.
+- Warnings go to stderr. A `marker leaks into rendered ...` warning means a marker will show as text on GitHub. Fix it unless the marker is an intentional example.
+- After editing mdeval code, run `mdeval` on the file and check the written values.
 
-</details>
-<!--/mdeval-->
-````
+## References
 
-**Set up a git hook so values never go stale.** Use [Lefthook](https://github.com/evilmartians/lefthook) with this config:
-
-```yaml
-# lefthook.yml
-pre-commit:
-  jobs:
-    - name: mdeval
-      # lefthook's default `gobwas` matcher requires `**` to span 1+ dirs,
-      # so `**/*.md` alone misses root-level files like README.md
-      glob: ["*.md", "**/*.md"]
-      run: |
-        files=$(npx mdeval "**/*.md")
-        [ -z "$files" ] || git add $files
-```
+- `references/type-checking.md`: setting up or running `tsc` on Markdown, or fixing a TypeScript error reported at a `.md` line. If the project's `tsconfig.json` lists mdeval in `contentMappers`, read it and run `tsc` after editing mdeval code.
+- `references/node-loader.md`: a Node.js script, test, or tool imports a `.md` file, or runs one with `node`.
 
-`git add $files` re-stages only the files mdeval actually rewrote. Assumes `.md` paths without spaces.
+## Reporting problems
 
-**Markers in code blocks are safe.** Fenced, indented, and inline code won't be touched — safe to document mdeval syntax in your own README.
+Report bugs in mdeval or in this skill to [privatenumber/mdeval](https://github.com/privatenumber/mdeval/issues) without waiting to be asked. This includes wrong behavior, confusing errors or warnings, wrong or missing guidance in this skill, and friction that cost time.
 
-**Never create a .md file with only a script block and no real content.** Markdown files must contain actual prose/documentation. For shared logic or utilities, create a `.js` or `.ts` file and import it from your markdown instead.
+1. Search open and closed issues: `gh issue list -R privatenumber/mdeval --search "<terms>" --state all`.
+2. Confirm the behavior on the latest mdeval release.
+3. Write a minimal Markdown reproduction without the user's private content.
+4. If your instructions allow filing issues for the user, run `gh issue create -R privatenumber/mdeval`. Otherwise, show the user the draft and file it only after they approve it.

package/skills/mdeval/references/node-loader.md

@@ -0,0 +1,25 @@
+# Importing `.md` files from Node.js
+
+`.md` files with mdeval script blocks are ES modules. Run a script with the loader to import their exports:
+
+```bash
+node --import mdeval/loader ./script.js
+```
+
+```js
+// script.js
+import { todos } from './TODOS.md'
+
+console.log(todos)
+```
+
+- `--import mdeval/loader` must come before the script, so the loader is registered before `.md` imports resolve. Without it, importing a `.md` file fails.
+- The loader also defines the `block` and `$` globals that `.md` code uses.
+- Importing a `.md` file runs only its script blocks. It does not evaluate markers or change the file.
+- TypeScript scripts work the same way: `node --import mdeval/loader ./script.ts`.
+- Run a `.md` file's script blocks directly: `node --import mdeval/loader ./TODOS.md`.
+- Stack traces from `.md` code report the original Markdown lines.
+
+In `.js` and `.ts` files, import the helpers instead of relying on globals: `import { block, $ } from 'mdeval'`. This import has no side effects. It does not define globals or register the loader.
+
+In tests that spawn the script, pass the flag to the child process, for example `spawn(process.execPath, ['--import', 'mdeval/loader', scriptPath])`.

package/skills/mdeval/references/type-checking.md

@@ -0,0 +1,70 @@
+# Type checking mdeval code
+
+TypeScript 7.1 checks the code in script blocks and markers through a content mapper, and reports errors at the original Markdown lines. Checking does not run the code.
+
+## Set up
+
+Install the TypeScript 7.1 beta:
+
+```bash
+npm install --save-dev typescript@7.1.0-beta
+```
+
+Register mdeval for `.md` files in `tsconfig.json`, and include the Markdown files to check:
+
+```json
+{
+    "compilerOptions": {
+        "module": "nodenext",
+        "target": "esnext",
+        "strict": true,
+        "erasableSyntaxOnly": true,
+        "noEmit": true
+    },
+    "contentMappers": [
+        {
+            "package": "mdeval",
+            "extensions": [
+                ".md"
+            ]
+        }
+    ],
+    "include": [
+        "README.md",
+        "docs/**/*.md"
+    ]
+}
+```
+
+Ask the user before adding this to a project. It requires a beta compiler.
+
+## Run
+
+```bash
+npx tsc --noEmit --runExternalCode
+```
+
+`--runExternalCode` lets `tsc` start mdeval's mapper. Without it, `tsc` fails with `TS18068: Content mappers require the '--runExternalCode' command line flag to be enabled.`
+
+## What is checked
+
+- Each `.md` file outside `node_modules` is a TypeScript module. Annotate with TypeScript syntax, such as `const count: number = 42`. JSDoc types are not checked there.
+- Markdown under `node_modules` is checked as JavaScript because Node runs it as JavaScript.
+- `erasableSyntaxOnly` reports syntax that fails at runtime, such as `enum`, at its Markdown line.
+- `block` and `$` are available without imports; explicit imports also work. Their global types are visible throughout the TypeScript program, including `.ts` and `.js` files, which matches runtime: the loader puts them on `globalThis` for every module in the process. Code that also runs without the loader should import them, or Markdown should be checked under its own tsconfig.
+- For conflicting globals, including full zx's `$`, use a separate tsconfig for Markdown that excludes the conflicting declaration from all loaded files, including root files, the import graph, and `compilerOptions.types` inherited through `extends` (for example, `zx/globals`). With `skipLibCheck`, the first declaration TypeScript checks determines the type, and a conflicting later `.d.ts` declaration can be skipped. For `a.md`, `globals.d.ts`, then `b.md`, the first Markdown declaration establishes the type and TS2403 can be absent.
+- A repeated marker expression is checked once, and its errors point to the first occurrence.
+- Fenced code, inline code, and rendered marker values are not checked.
+- A `.ts` file that imports a `.md` file is checked against the `.md` exports' types when the `.ts` file is in `include`.
+
+## Fix errors
+
+Fix a reported error in the script block or marker at that Markdown line, then run `tsc` again.
+
+A namespace import of a `.md` file without exports, such as `import * as data from './stub.md'`, reports `Property 'version' does not exist` for `data.version`, even though the value is `undefined` at runtime. Give the imported file the export, or cast the namespace to the expected shape:
+
+```ts
+import * as stub from './stub.md'
+
+const data = stub as { version?: string }
+```

package/dist/md-loader.mjs

@@ -1,12 +0,0 @@
-#!/usr/bin/env node
-var x=Object.defineProperty;var c=(e,a)=>x(e,"name",{value:a,configurable:!0});import b from"node:fs/promises";import{pathToFileURL as E,fileURLToPath as T}from"node:url";import{p as $,E as B,M as F}from"./parse-markdown-wnFVEAED.mjs";import{GenMapping as P,toEncodedMap as W,addSegment as U}from"@jridgewell/gen-mapping";import"micromark";const M=10,v=13,N=c(e=>e===9||e===M||e===11||e===12||e===v||e===32,"isWhitespaceCode"),j=c(e=>e>=48&&e<=57||e>=65&&e<=90||e===95||e>=97&&e<=122||e===36,"isIdentifierCode"),A=c((e,a)=>{const h=E(e).href,p=new P({file:e}),s=[];let i="";const o=[];for(let n=a.indexOf(`
-`);n!==-1;n=a.indexOf(`
-`,n+1))o.push(n);const y=c(n=>{let t=0,r=o.length;for(;t<r;){const f=Math.floor((t+r)/2);o[f]<n?t=f+1:r=f}const d=t>0?o[t-1]:-1;return{line:t,column:n-d-1}},"positionFromOffset"),u=c(n=>{i+=n},"appendLineChunk"),S=c(()=>{s.push(i),i=""},"flushLine"),O=c((n,t)=>{const r=y(t);let d=r.line,f=r.column,L=!1,R=!1,m=0;const w=c(l=>i.length+l-m,"generatedColumn");for(let l=0;l<n.length;l+=1){const g=n.codePointAt(l),C=N(g),I=j(g);!C&&(l===0||R||!L||!I)&&U(p,s.length,w(l),h,d,f),g===M?(d+=1,f=0):f+=1,L=I,R=C,g===M&&(u(n.slice(m,l)),S(),m=l+1)}m<n.length&&u(n.slice(m))},"appendSourceText"),k=c(n=>{let t=0;for(let r=n.indexOf(`
-`);r!==-1;r=n.indexOf(`
-`,t))u(n.slice(t,r)),S(),t=r+1;t<n.length&&u(n.slice(t))},"appendSyntheticText");return{appendSource(n,t){O(n,t)},appendSynthetic(n){k(n)},toModuleSource:c(()=>{const t=`${(i===""?s:[...s,i]).join(`
-`)}
-`,r=W(p),d=`//# sourceMappingURL=data:application/json;base64,${Buffer.from(JSON.stringify(r)).toString("base64")}`;return`${t}${d}
-`},"toModuleSource")}},"createSourceBuilder"),X=c((e,a,h,p)=>{const s=A(a,e);for(const o of h)s.appendSource(o.content,o.contentStart),o.content.endsWith(`
-`)||s.appendSynthetic(`
-`);const i=new Map;for(const o of p)i.has(o.expression)||i.set(o.expression,{index:i.size,marker:o});for(const[o,{index:y,marker:u}]of i){const S=`export const ${B}${y} = `;s.appendSynthetic(S),s.appendSource(o,u.start+F.length),s.appendSynthetic(`;
-`)}return s.toModuleSource()},"generateModule"),_=c(async(e,a,h)=>{if(!e.endsWith(".md"))return h(e,a);const p=T(e),s=await b.readFile(p,"utf8"),{scriptBlocks:i,markers:o}=$(s);return i.length===0&&o.length===0?{format:"module",source:"",shortCircuit:!0}:{format:"module",source:X(s,p,i,o),shortCircuit:!0}},"load");export{_ as load};

package/dist/parse-markdown-wnFVEAED.mjs

@@ -1,6 +0,0 @@
-var M=Object.defineProperty;var l=(n,e)=>M(n,"name",{value:e,configurable:!0});import{postprocess as v,parse as w,preprocess as k}from"micromark";const x="mdeval",c=`<!--${x}`,C=`${c} `,E=`<!--/${x}-->`,b=`__${x}_`,g="-->",_=l(n=>{const e=new Map;for(const{expression:s}of n)e.has(s)||e.set(s,e.size);return e},"buildExpressionMap"),$=l(n=>{const e=n.codePointAt(0)===65279?1:0,s=v(w().document().write(k()(n,void 0,!0))),r=[];for(const[o,t]of s)o==="enter"&&(t.type==="codeFenced"||t.type==="codeIndented"||t.type==="codeText")&&r.push([t.start.offset+e,t.end.offset+e]);return r},"findCodeRanges"),R=l(n=>{let e=null,s=0;return r=>{for(e===null&&(e=$(n));s<e.length&&e[s][1]<=r;)s+=1;return s<e.length&&r>=e[s][0]}},"createIsInCode"),u=l((n,e)=>{let s=e;for(;s<n.length;){const r=n.indexOf(c,s);if(r===-1)return-1;const o=n[r+c.length];if(o===" "||o===`
-`||o==="\r"&&n[r+c.length+1]===`
-`)return r;s=r+c.length}return-1},"findNextMdevalOpening"),S=l(n=>{if(!n.includes(c))return{scriptBlocks:[],markers:[]};const e=R(n),s=[],r=[];let o=0;for(;o<n.length;){const t=n.indexOf(c,o);if(t===-1)break;const i=t+c.length,m=n[i];if(m===`
-`||m==="\r"&&n[i+1]===`
-`){const f=m===`
-`?i+1:i+2,a=n.indexOf(g,f),d=u(n,f),p=d!==-1&&(a===-1||d<a);if(a===-1||p){if(!e(t))throw new Error(p?`mdeval: unclosed script block at offset ${t} (another mdeval opening found before \`-->\`)`:`mdeval: unclosed script block at offset ${t} (missing \`-->\`)`);if(a===-1)break;o=f;continue}const h=a+g.length;e(t)||s.push({content:n.slice(f,a),contentStart:f,start:t,end:h}),o=h;continue}if(m===" "){const f=i+1,a=n.indexOf(g,f);if(a===-1){if(e(t))break;throw new Error(`mdeval: unclosed marker open at offset ${t} (missing \`-->\` on the marker open)`)}const d=a+g.length,p=n.indexOf(E,d),h=u(n,d);if(p===-1||h!==-1&&h<p){if(e(t)){o=d;continue}throw new Error(`mdeval: unclosed marker open at offset ${t} (missing \`<!--/mdeval-->\`)`)}const O=p+E.length;e(t)||r.push({expression:n.slice(f,a),start:t,end:O}),o=O;continue}o=i}return{scriptBlocks:s,markers:r}},"parseMarkdown"),I=l((n,{scriptBlocks:e,markers:s})=>{if(e.length===0&&s.length===0)return!1;const r=[...e.map(t=>[t.start,t.end]),...s.map(t=>[t.start,t.end])].sort((t,i)=>t[0]-i[0]);let o=0;for(const[t,i]of r){if(n.slice(o,t).trim()!=="")return!1;o=i}return n.slice(o).trim()===""},"isOnlyMdeval");export{c as C,b as E,C as M,E as a,_ as b,g as c,I as i,S as p};