@rwillians/doctests 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rafael Willians
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,71 @@
+# @rwillians/doctests
+
+The power of doctests now available in JavaScript and TypeScript!
+
+## Examples
+
+**src/utils.ts**
+```ts
+/**
+ * @example Returns a number of the fibonacci sequence by its given
+ *          position.
+ * ```
+ * fib(3) //= 2
+ * fib(4) //= 3
+ * fib(5) //= 5
+ * ```
+ *
+ * @example The value of a position in the fibonacci sequence is equal
+ *          to the sum of the two preceding numbers.
+ * ```
+ * fib(5)                     //= fib(3) + fib(4)
+ * fib(5) === fib(3) + fib(4) //= true
+ * ```
+ *
+ * @example The position is zero-based.
+ *
+ * Zero-based indexing means that the first element of a sequence is
+ * at position 0, the second element is at position 1, and so on. This
+ * is a common convention in programming and mathematics.
+ *
+ * ```
+ * fib(0); //= 0
+ * ```
+ *
+ * As you can see, the first number of the fibonacci sequence is 0,
+ * which is at position 0.
+ *
+ * @example The first and second numbers of the sequence are equal to
+ *          one.
+ * ```ts
+ * const a = fib(1) //= 1
+ * const b = fib(2) //= 1
+ * ```
+ *
+ * @example The given position cannot be less than zero.
+ *
+ * ```js
+ * fib(-1) //^ **Error**
+ * fib(-2) //^ **Error** "position cannot be less than 0, got -2"
+ * fib(-3) //^ **Error** 'position cannot be less than 0, got -3'
+ * ```
+ */
+export const fib = (position: number): number => {
+  if (position   < 0) throw new Error(`position cannot be less than 0, got ${position}`);
+  if (position === 0) return 0;
+  if (position === 1) return 1;
+  if (position === 2) return 1;
+
+  return fib(position - 2) + fib(position - 1);
+};
+```
+
+**test/doctests.spec.ts**
+```ts
+import { doctest } from '@rwillians/doctests';
+
+doctest({
+  include: ['src/**/*.ts'],
+  exclude: ['src/**/*.d.ts', 'src/**/*.{test,spec}.ts'],
+});
+```

package/dist/cjs/compiler.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Compiles a parsed example into the body of an async function. The
+ * runner provides `expect` (from the test framework) and `__errorName`
+ * (error-name matcher) as parameters, and destructures the target
+ * module's exports above this body — so steps can call them directly.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = void 0;
+const compileStep = (step) => {
+    switch (step.kind) {
+        case 'exec':
+            return step.code;
+        case 'equal':
+            return step.binding === null
+                ? `expect(${step.expression}).toEqual(${step.expected});`
+                : `${step.expression};\nexpect(${step.binding}).toEqual(${step.expected});`;
+        case 'throws': {
+            const error = JSON.stringify(step.error);
+            const lines = [
+                '{',
+                '  let __thrown = undefined;',
+                '  let __threw = false;',
+                `  try { ${step.expression}; } catch (error) { __thrown = error; __threw = true; }`,
+                `  if (!__threw) throw new Error('expected \`' + ${JSON.stringify(step.expression)} + '\` to throw ' + ${error} + ', but nothing was thrown');`,
+                `  expect(__errorName(__thrown, ${error})).toBe(${error});`,
+            ];
+            if (step.message !== null) {
+                lines.push(`  expect(String(__thrown.message)).toContain(${JSON.stringify(step.message)});`);
+            }
+            lines.push('}');
+            return lines.join('\n');
+        }
+    }
+};
+const compile = (example) => example.steps.map(compileStep).join('\n');
+exports.compile = compile;

package/dist/cjs/index.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doctest = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const bun_test_1 = require("bun:test");
+const compiler_1 = require("./compiler");
+const parser_1 = require("./parser");
+const AsyncFunction = Object.getPrototypeOf(async () => undefined).constructor;
+const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+/**
+ * Matches a thrown value against an expected error name. Returns the
+ * expected name on a match (by `error.name` or constructor name), or
+ * the closest description of what was actually thrown — so a mismatch
+ * reads as `expect(received).toBe(expected)` with both names visible.
+ */
+const errorName = (error, expected) => {
+    if (error === null || typeof error !== 'object')
+        return String(error);
+    const names = [error.name, error.constructor?.name];
+    if (names.includes(expected))
+        return expected;
+    return names.find((name) => typeof name === 'string') ?? String(error);
+};
+let transpiler;
+/** Strips TypeScript syntax so ```ts blocks run through `new Function`. */
+const transpile = (code) => {
+    if (typeof Bun === 'undefined')
+        return code;
+    transpiler ??= new Bun.Transpiler({ loader: 'ts', deadCodeElimination: false });
+    return transpiler.transformSync(code);
+};
+const run = async (exports, example) => {
+    const names = Object.keys(exports).filter((name) => IDENTIFIER.test(name));
+    const header = names.length > 0 ? `const { ${names.join(', ')} } = __exports__;` : '';
+    const body = transpile((0, compiler_1.compile)(example));
+    const compiled = new AsyncFunction('__exports__', 'expect', '__errorName', `"use strict";\n${header}\n${body}`);
+    await compiled(exports, bun_test_1.expect, errorName);
+};
+const title = (description) => description.replace(/\.$/, '') || 'doctest';
+const register = (root, path) => {
+    const source = (0, node_fs_1.readFileSync)((0, node_path_1.resolve)(root, path), 'utf8');
+    const docs = (0, parser_1.parse)(source).filter((doc) => doc.exported);
+    if (docs.length === 0)
+        return;
+    (0, bun_test_1.describe)(path, () => {
+        for (const doc of docs) {
+            (0, bun_test_1.describe)(doc.subject, () => {
+                for (const example of doc.examples) {
+                    (0, bun_test_1.it)(title(example.description), async () => {
+                        const exports = (await Promise.resolve(`${(0, node_path_1.resolve)(root, path)}`).then(s => require(s)));
+                        await run(exports, example);
+                    });
+                }
+            });
+        }
+    });
+};
+/**
+ * Registers every doctest found in the files matched by the `include`
+ * globs (relative to the current working directory, minus any matched
+ * by `exclude`) as regular `bun:test` cases:
+ * `describe(file) > describe(symbol) > it(example)`.
+ * Doctests on symbols that are not exported are skipped. A bare array
+ * of globs is accepted as shorthand for `{ include }`.
+ */
+const doctest = (options) => {
+    const { include, exclude = [] } = Array.isArray(options) ? { include: options } : options;
+    const root = process.cwd();
+    const paths = new Set();
+    for (const pattern of include) {
+        for (const path of new Bun.Glob(pattern).scanSync({ cwd: root })) {
+            paths.add(path);
+        }
+    }
+    const excluded = exclude.map((pattern) => new Bun.Glob(pattern));
+    for (const path of [...paths].sort()) {
+        if (excluded.some((glob) => glob.match(path)))
+            continue;
+        register(root, path);
+    }
+};
+exports.doctest = doctest;

package/dist/cjs/parser.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * Dependency-free doctest parser. Scans JSDoc blocks for `@example`
+ * tags and turns their fenced code blocks into executable steps. Text
+ * scanning only — no TypeScript compiler API — so it works the same
+ * for `.js` and `.ts` sources.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+const COMMENT = /\/\*\*([\s\S]*?)\*\//g;
+const STAR_PREFIX = /^\s*\* ?/;
+const TAG = /^@(\w+)\s*/;
+const FENCE = /^```/;
+const DECLARATION = /^(export\s+)?(?:default\s+)?(?:declare\s+)?(?:abstract\s+)?(?:async\s+)?(?:const|let|var|function\*?|class|enum)\s+([A-Za-z_$][\w$]*)/;
+const BINDING = /^(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=/;
+const THROWS = /^\*\*([^*]+)\*\*\s*(?:"([^"]*)"|'([^']*)')?$/;
+const cleanLine = (line) => line.replace(STAR_PREFIX, '').trimEnd();
+/**
+ * The symbol a JSDoc block documents: the first declaration after the
+ * comment (blank lines and `//` comments in between are skipped).
+ */
+const declarationAfter = (source, index) => {
+    for (const line of source.slice(index).split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed === '' || trimmed.startsWith('//'))
+            continue;
+        const match = DECLARATION.exec(trimmed);
+        if (!match)
+            return null;
+        return { subject: match[2], exported: match[1] !== undefined };
+    }
+    return null;
+};
+/**
+ * Splits a cleaned JSDoc body into `@example` sections. A section runs
+ * from its `@example` line to the next `@tag` (or the end of the
+ * block). Tag-looking lines inside code fences are left alone.
+ */
+const splitExamples = (lines) => {
+    const sections = [];
+    let current = null;
+    let fenced = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (FENCE.test(trimmed)) {
+            fenced = !fenced;
+            current?.push(line);
+            continue;
+        }
+        const tag = fenced ? null : TAG.exec(trimmed);
+        if (tag) {
+            current = tag[1] === 'example' ? [trimmed.replace(TAG, '')] : null;
+            if (current)
+                sections.push(current);
+            continue;
+        }
+        current?.push(line);
+    }
+    return sections;
+};
+const classify = (line) => {
+    const markers = [line.indexOf('//='), line.indexOf('//^')].filter((at) => at >= 0);
+    const at = markers.length > 0 ? Math.min(...markers) : -1;
+    if (at < 0)
+        return { kind: 'exec', code: line };
+    const expression = line.slice(0, at).trim().replace(/;$/, '');
+    const rest = line.slice(at + 3).trim();
+    if (line.startsWith('//=', at)) {
+        if (rest === '')
+            throw new Error(`malformed doctest assertion, expected a value after \`//=\`: ${line}`);
+        const binding = BINDING.exec(expression);
+        return { kind: 'equal', binding: binding?.[1] ?? null, expression, expected: rest };
+    }
+    const throws = THROWS.exec(rest);
+    if (!throws)
+        throw new Error(`malformed doctest assertion, expected \`//^ **ErrorType** "optional message"\`: ${line}`);
+    return { kind: 'throws', expression, error: throws[1].trim(), message: throws[2] ?? throws[3] ?? null };
+};
+/**
+ * Parses one `@example` section. The description is the text from the
+ * tag up to the first blank line or code fence; prose paragraphs after
+ * that are ignored; every fenced code block contributes steps.
+ */
+const parseExample = (lines) => {
+    const description = [];
+    const steps = [];
+    let fenced = false;
+    let describing = true;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (FENCE.test(trimmed)) {
+            fenced = !fenced;
+            describing = false;
+            continue;
+        }
+        if (fenced) {
+            if (trimmed !== '')
+                steps.push(classify(trimmed));
+            continue;
+        }
+        if (describing && trimmed === '') {
+            describing = false;
+            continue;
+        }
+        if (describing)
+            description.push(trimmed);
+    }
+    return { description: description.join(' ').replace(/\s+/g, ' ').trim(), steps };
+};
+const parse = (source) => {
+    const docs = [];
+    for (const match of source.matchAll(COMMENT)) {
+        const declaration = declarationAfter(source, match.index + match[0].length);
+        if (!declaration)
+            continue;
+        const lines = match[1].split('\n').map(cleanLine);
+        const examples = splitExamples(lines).map(parseExample).filter((example) => example.steps.length > 0);
+        if (examples.length === 0)
+            continue;
+        docs.push({ ...declaration, examples });
+    }
+    return docs;
+};
+exports.parse = parse;

package/dist/esm/compiler.js

@@ -0,0 +1,33 @@
+/**
+ * Compiles a parsed example into the body of an async function. The
+ * runner provides `expect` (from the test framework) and `__errorName`
+ * (error-name matcher) as parameters, and destructures the target
+ * module's exports above this body — so steps can call them directly.
+ */
+const compileStep = (step) => {
+    switch (step.kind) {
+        case 'exec':
+            return step.code;
+        case 'equal':
+            return step.binding === null
+                ? `expect(${step.expression}).toEqual(${step.expected});`
+                : `${step.expression};\nexpect(${step.binding}).toEqual(${step.expected});`;
+        case 'throws': {
+            const error = JSON.stringify(step.error);
+            const lines = [
+                '{',
+                '  let __thrown = undefined;',
+                '  let __threw = false;',
+                `  try { ${step.expression}; } catch (error) { __thrown = error; __threw = true; }`,
+                `  if (!__threw) throw new Error('expected \`' + ${JSON.stringify(step.expression)} + '\` to throw ' + ${error} + ', but nothing was thrown');`,
+                `  expect(__errorName(__thrown, ${error})).toBe(${error});`,
+            ];
+            if (step.message !== null) {
+                lines.push(`  expect(String(__thrown.message)).toContain(${JSON.stringify(step.message)});`);
+            }
+            lines.push('}');
+            return lines.join('\n');
+        }
+    }
+};
+export const compile = (example) => example.steps.map(compileStep).join('\n');

package/dist/esm/index.js

@@ -0,0 +1,79 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { describe, expect, it } from 'bun:test';
+import { compile } from './compiler';
+import { parse } from './parser';
+const AsyncFunction = Object.getPrototypeOf(async () => undefined).constructor;
+const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+/**
+ * Matches a thrown value against an expected error name. Returns the
+ * expected name on a match (by `error.name` or constructor name), or
+ * the closest description of what was actually thrown — so a mismatch
+ * reads as `expect(received).toBe(expected)` with both names visible.
+ */
+const errorName = (error, expected) => {
+    if (error === null || typeof error !== 'object')
+        return String(error);
+    const names = [error.name, error.constructor?.name];
+    if (names.includes(expected))
+        return expected;
+    return names.find((name) => typeof name === 'string') ?? String(error);
+};
+let transpiler;
+/** Strips TypeScript syntax so ```ts blocks run through `new Function`. */
+const transpile = (code) => {
+    if (typeof Bun === 'undefined')
+        return code;
+    transpiler ??= new Bun.Transpiler({ loader: 'ts', deadCodeElimination: false });
+    return transpiler.transformSync(code);
+};
+const run = async (exports, example) => {
+    const names = Object.keys(exports).filter((name) => IDENTIFIER.test(name));
+    const header = names.length > 0 ? `const { ${names.join(', ')} } = __exports__;` : '';
+    const body = transpile(compile(example));
+    const compiled = new AsyncFunction('__exports__', 'expect', '__errorName', `"use strict";\n${header}\n${body}`);
+    await compiled(exports, expect, errorName);
+};
+const title = (description) => description.replace(/\.$/, '') || 'doctest';
+const register = (root, path) => {
+    const source = readFileSync(resolve(root, path), 'utf8');
+    const docs = parse(source).filter((doc) => doc.exported);
+    if (docs.length === 0)
+        return;
+    describe(path, () => {
+        for (const doc of docs) {
+            describe(doc.subject, () => {
+                for (const example of doc.examples) {
+                    it(title(example.description), async () => {
+                        const exports = (await import(resolve(root, path)));
+                        await run(exports, example);
+                    });
+                }
+            });
+        }
+    });
+};
+/**
+ * Registers every doctest found in the files matched by the `include`
+ * globs (relative to the current working directory, minus any matched
+ * by `exclude`) as regular `bun:test` cases:
+ * `describe(file) > describe(symbol) > it(example)`.
+ * Doctests on symbols that are not exported are skipped. A bare array
+ * of globs is accepted as shorthand for `{ include }`.
+ */
+export const doctest = (options) => {
+    const { include, exclude = [] } = Array.isArray(options) ? { include: options } : options;
+    const root = process.cwd();
+    const paths = new Set();
+    for (const pattern of include) {
+        for (const path of new Bun.Glob(pattern).scanSync({ cwd: root })) {
+            paths.add(path);
+        }
+    }
+    const excluded = exclude.map((pattern) => new Bun.Glob(pattern));
+    for (const path of [...paths].sort()) {
+        if (excluded.some((glob) => glob.match(path)))
+            continue;
+        register(root, path);
+    }
+};

package/dist/esm/parser.js

@@ -0,0 +1,120 @@
+/**
+ * Dependency-free doctest parser. Scans JSDoc blocks for `@example`
+ * tags and turns their fenced code blocks into executable steps. Text
+ * scanning only — no TypeScript compiler API — so it works the same
+ * for `.js` and `.ts` sources.
+ */
+const COMMENT = /\/\*\*([\s\S]*?)\*\//g;
+const STAR_PREFIX = /^\s*\* ?/;
+const TAG = /^@(\w+)\s*/;
+const FENCE = /^```/;
+const DECLARATION = /^(export\s+)?(?:default\s+)?(?:declare\s+)?(?:abstract\s+)?(?:async\s+)?(?:const|let|var|function\*?|class|enum)\s+([A-Za-z_$][\w$]*)/;
+const BINDING = /^(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=/;
+const THROWS = /^\*\*([^*]+)\*\*\s*(?:"([^"]*)"|'([^']*)')?$/;
+const cleanLine = (line) => line.replace(STAR_PREFIX, '').trimEnd();
+/**
+ * The symbol a JSDoc block documents: the first declaration after the
+ * comment (blank lines and `//` comments in between are skipped).
+ */
+const declarationAfter = (source, index) => {
+    for (const line of source.slice(index).split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed === '' || trimmed.startsWith('//'))
+            continue;
+        const match = DECLARATION.exec(trimmed);
+        if (!match)
+            return null;
+        return { subject: match[2], exported: match[1] !== undefined };
+    }
+    return null;
+};
+/**
+ * Splits a cleaned JSDoc body into `@example` sections. A section runs
+ * from its `@example` line to the next `@tag` (or the end of the
+ * block). Tag-looking lines inside code fences are left alone.
+ */
+const splitExamples = (lines) => {
+    const sections = [];
+    let current = null;
+    let fenced = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (FENCE.test(trimmed)) {
+            fenced = !fenced;
+            current?.push(line);
+            continue;
+        }
+        const tag = fenced ? null : TAG.exec(trimmed);
+        if (tag) {
+            current = tag[1] === 'example' ? [trimmed.replace(TAG, '')] : null;
+            if (current)
+                sections.push(current);
+            continue;
+        }
+        current?.push(line);
+    }
+    return sections;
+};
+const classify = (line) => {
+    const markers = [line.indexOf('//='), line.indexOf('//^')].filter((at) => at >= 0);
+    const at = markers.length > 0 ? Math.min(...markers) : -1;
+    if (at < 0)
+        return { kind: 'exec', code: line };
+    const expression = line.slice(0, at).trim().replace(/;$/, '');
+    const rest = line.slice(at + 3).trim();
+    if (line.startsWith('//=', at)) {
+        if (rest === '')
+            throw new Error(`malformed doctest assertion, expected a value after \`//=\`: ${line}`);
+        const binding = BINDING.exec(expression);
+        return { kind: 'equal', binding: binding?.[1] ?? null, expression, expected: rest };
+    }
+    const throws = THROWS.exec(rest);
+    if (!throws)
+        throw new Error(`malformed doctest assertion, expected \`//^ **ErrorType** "optional message"\`: ${line}`);
+    return { kind: 'throws', expression, error: throws[1].trim(), message: throws[2] ?? throws[3] ?? null };
+};
+/**
+ * Parses one `@example` section. The description is the text from the
+ * tag up to the first blank line or code fence; prose paragraphs after
+ * that are ignored; every fenced code block contributes steps.
+ */
+const parseExample = (lines) => {
+    const description = [];
+    const steps = [];
+    let fenced = false;
+    let describing = true;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (FENCE.test(trimmed)) {
+            fenced = !fenced;
+            describing = false;
+            continue;
+        }
+        if (fenced) {
+            if (trimmed !== '')
+                steps.push(classify(trimmed));
+            continue;
+        }
+        if (describing && trimmed === '') {
+            describing = false;
+            continue;
+        }
+        if (describing)
+            description.push(trimmed);
+    }
+    return { description: description.join(' ').replace(/\s+/g, ' ').trim(), steps };
+};
+export const parse = (source) => {
+    const docs = [];
+    for (const match of source.matchAll(COMMENT)) {
+        const declaration = declarationAfter(source, match.index + match[0].length);
+        if (!declaration)
+            continue;
+        const lines = match[1].split('\n').map(cleanLine);
+        const examples = splitExamples(lines).map(parseExample).filter((example) => example.steps.length > 0);
+        if (examples.length === 0)
+            continue;
+        docs.push({ ...declaration, examples });
+    }
+    return docs;
+};

package/dist/types/compiler.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Compiles a parsed example into the body of an async function. The
+ * runner provides `expect` (from the test framework) and `__errorName`
+ * (error-name matcher) as parameters, and destructures the target
+ * module's exports above this body — so steps can call them directly.
+ */
+import type { Example } from './parser';
+export declare const compile: (example: Example) => string;

package/dist/types/index.d.ts

@@ -0,0 +1,14 @@
+type DoctestOptions = {
+    include: string[];
+    exclude?: string[];
+};
+/**
+ * Registers every doctest found in the files matched by the `include`
+ * globs (relative to the current working directory, minus any matched
+ * by `exclude`) as regular `bun:test` cases:
+ * `describe(file) > describe(symbol) > it(example)`.
+ * Doctests on symbols that are not exported are skipped. A bare array
+ * of globs is accepted as shorthand for `{ include }`.
+ */
+export declare const doctest: (options: string[] | DoctestOptions) => void;
+export {};

package/dist/types/parser.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Dependency-free doctest parser. Scans JSDoc blocks for `@example`
+ * tags and turns their fenced code blocks into executable steps. Text
+ * scanning only — no TypeScript compiler API — so it works the same
+ * for `.js` and `.ts` sources.
+ */
+export type Step = {
+    kind: 'exec';
+    code: string;
+} | {
+    kind: 'equal';
+    binding: string | null;
+    expression: string;
+    expected: string;
+} | {
+    kind: 'throws';
+    expression: string;
+    error: string;
+    message: string | null;
+};
+export type Example = {
+    description: string;
+    steps: Step[];
+};
+export type Doc = {
+    subject: string;
+    exported: boolean;
+    examples: Example[];
+};
+export declare const parse: (source: string) => Doc[];

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@rwillians/doctests",
+  "description": "The power of doctests now available to JavaScript and TypeScript.",
+  "version": "0.0.1",
+  "publishConfig": { "access": "public" },
+  "author": "Rafael Willians <me@rwillians.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/rwillians/doctests-js.git"
+  },
+  "keywords": [
+    "documentation",
+    "test",
+    "doctest",
+    "doctests",
+    "bun",
+    "jest"
+  ],
+  "type": "module",
+  "module": "dist/esm/index.js",
+  "main": "dist/cjs/index.js",
+  "files": ["dist/", "LICENSE"],
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "default": "./dist/cjs/index.js"
+    }
+  },
+  "scripts": {
+    "build": "bun run build:cjs && bun run build:esm",
+    "build:cjs": "bun run --bun tsc --project tsconfig-cjs.json",
+    "build:esm": "bun run --bun tsc --project tsconfig-esm.json"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.14"
+  },
+  "peerDependencies": {
+    "typescript": "^5.9.3"
+  }
+}