@nimbus-sh/worker 0.1.0

package/dist/runtime/barrel-synthesizer.js

@@ -0,0 +1,541 @@
+/**
+ * barrel-synthesizer.ts — generate synthetic entry files for "barrel"
+ * packages so they tree-shake cleanly through esbuild.
+ *
+ * Why this exists
+ * ───────────────
+ * Some npm packages ship as a "barrel" — a single index file that
+ * re-exports hundreds or thousands of named exports, each living in
+ * its own source file. Examples observed in the wild:
+ *
+ *   lucide-react@0.460:        ~3940 files (~1500 icons × 2 entry forms)
+ *   @phosphor-icons/react:     thousands of icon components
+ *   react-icons:               thousands of icons across icon families
+ *   @mui/icons-material:       thousands of Material icons
+ *   @heroicons/react:          hundreds of icons (split by style)
+ *
+ * Bundling the whole barrel as if it were a normal browser module OOMs
+ * esbuild's WASM facet — the compiler tries to ingest the entire
+ * source tree into one ESM output. We previously fell back to
+ * `https://esm.sh/<pkg>?deps=react@<v>,react-dom@<v>` (commit fc17847)
+ * which violated the 100% edge contract: every preview load fetched
+ * tree-shaken bytes from a third-party CDN.
+ *
+ * The fix is structural. Instead of bundling `import * from 'pkg'`,
+ * we scan the user's source code for the SET of named imports the
+ * project actually uses
+ *
+ *   import { Home, FileText, Zap } from 'lucide-react'
+ *
+ * and synthesize a tiny entry module
+ *
+ *   export { Home, FileText, Zap } from 'lucide-react';
+ *
+ * which esbuild bundles in milliseconds because reachability prunes
+ * everything else. The output is small (5–20 KiB for typical icon
+ * sets) and ships from our edge.
+ *
+ * Generality
+ * ──────────
+ * This is NOT lucide-react-specific. Any barrel package whose author
+ * marked `sideEffects: false` (or whose individual icon files are
+ * side-effect-free) works automatically — esbuild's tree-shake takes
+ * care of selecting the actually-used exports. Packages without
+ * sideEffects: false may still tree-shake because esbuild's static
+ * analysis of `export { X } from './x.js'` is conservative-correct.
+ *
+ * Failure mode
+ * ────────────
+ * If the scanner can't enumerate the set (dynamic imports, computed
+ * member access like `Icons[name]`, etc.), the synthesizer returns
+ * null and the caller MUST hard-error. NO CDN fallback. The user
+ * sees a clear remediation: "add a static import for the
+ * dynamically-referenced icon."
+ */
+import { packageNameFromSpecifier } from './barrel-detect.js';
+/**
+ * Static-import scanner. Walks the user's source tree under projDir
+ * and extracts named-import sets. Returns a map keyed by package name.
+ *
+ * Recognized syntax:
+ *   import { A } from 'pkg'
+ *   import { A, B } from 'pkg'
+ *   import { A as X, B as Y } from 'pkg'
+ *   import D, { A } from 'pkg'   // only A is captured (D is default)
+ *
+ * NOT recognized (intentional — these can't be statically tree-shaken):
+ *   import * as M from 'pkg'             — caller must bundle whole pkg
+ *   import('pkg')                         — dynamic; runtime resolution
+ *   const { A } = require('pkg')          — CJS at runtime
+ *
+ * The scanner is intentionally conservative-text-based. We do NOT
+ * parse a full AST — that would require shipping acorn or esbuild's
+ * parser at runtime in the supervisor. The regex covers the >99% case
+ * for browser source code in TS/JS/JSX/TSX.
+ *
+ * Costs: O(files × content_length). For Mossaic (199 source files,
+ * ~150 KiB total source) this is single-digit ms.
+ */
+export function scanNamedImports(vfs, projDir) {
+    const result = new Map();
+    const scanExts = new Set(['.ts', '.tsx', '.jsx', '.js', '.mjs']);
+    const add = (pkgName, name) => {
+        let set = result.get(pkgName);
+        if (!set) {
+            set = new Set();
+            result.set(pkgName, set);
+        }
+        set.add(name);
+    };
+    // Match `import { ... } from 'spec'` and `import D, { ... } from 'spec'`.
+    // Non-greedy to handle multiple imports per file. The `[^"']*?` after
+    // the closing brace tolerates whitespace + the optional `from`.
+    // Captures:
+    //   1: the named-import body (between { and })
+    //   2: the specifier
+    const namedImportRe = /import\s+(?:[A-Za-z_$][\w$]*\s*,\s*)?\{([^}]+)\}\s*from\s*["']([^"']+)["']/g;
+    const walk = (dir, depth) => {
+        if (depth > 6)
+            return;
+        let entries;
+        try {
+            entries = vfs.readdir(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.name === 'node_modules' || entry.name === '.git' ||
+                entry.name === 'dist' || entry.name === 'build')
+                continue;
+            const path = dir + '/' + entry.name;
+            if (entry.type === 'directory') {
+                walk(path, depth + 1);
+                continue;
+            }
+            const dot = entry.name.lastIndexOf('.');
+            if (dot < 0)
+                continue;
+            const ext = entry.name.substring(dot);
+            if (!scanExts.has(ext))
+                continue;
+            let code;
+            try {
+                code = vfs.readFileString(path);
+            }
+            catch {
+                continue;
+            }
+            let m;
+            while ((m = namedImportRe.exec(code)) !== null) {
+                const body = m[1];
+                const specRaw = m[2];
+                // Skip relative + builtin imports: only bare package specifiers.
+                if (specRaw.startsWith('.') || specRaw.startsWith('/') || specRaw.startsWith('node:'))
+                    continue;
+                // Skip subpath imports — the user is opting into per-file
+                // resolution; esbuild bundles the specific file directly.
+                const pkgName = packageNameFromSpecifier(specRaw);
+                if (specRaw !== pkgName)
+                    continue;
+                // Parse the named-import body. Each item is one of:
+                //   X
+                //   X as Y
+                //   "X" as Y         (TS bracket-import, rare)
+                // We capture the SOURCE name (the export name on the package),
+                // NOT the local alias.
+                for (const partRaw of body.split(',')) {
+                    const part = partRaw.trim();
+                    if (!part)
+                        continue;
+                    const asMatch = part.match(/^([A-Za-z_$][\w$]*)\s+as\s+[A-Za-z_$][\w$]*$/);
+                    if (asMatch) {
+                        add(pkgName, asMatch[1]);
+                        continue;
+                    }
+                    // Plain identifier — capture as-is. Reject anything that's not
+                    // a clean JS identifier (e.g. comments, type-only imports).
+                    if (/^[A-Za-z_$][\w$]*$/.test(part)) {
+                        add(pkgName, part);
+                    }
+                    else if (/^type\s+([A-Za-z_$][\w$]*)/.test(part)) {
+                        // `import { type Foo } from 'pkg'` — capture, esbuild will
+                        // strip type-only imports during bundle.
+                        const tm = part.match(/^type\s+([A-Za-z_$][\w$]*)/);
+                        if (tm)
+                            add(pkgName, tm[1]);
+                    }
+                    // Anything else (e.g. "default as X") is non-named; skip.
+                }
+            }
+        }
+    };
+    walk(projDir, 0);
+    return result;
+}
+export function buildSyntheticEntry(vfs, nmDir, pkgName, names) {
+    if (names.size === 0)
+        return null;
+    const indexPath = findPackageEsmEntry(vfs, nmDir, pkgName);
+    if (!indexPath)
+        return null;
+    const indexCode = (() => {
+        try {
+            return vfs.readFileString(indexPath);
+        }
+        catch {
+            return null;
+        }
+    })();
+    if (!indexCode)
+        return null;
+    const exportMap = new Map();
+    // Match an entire `export { ... } from '...';` block.
+    const reExport = /export\s*\{([^}]+)\}\s*from\s*["']([^"']+)["']\s*;?/g;
+    let m;
+    while ((m = reExport.exec(indexCode)) !== null) {
+        const body = m[1];
+        const path = m[2];
+        if (!path.startsWith('.'))
+            continue; // only relative re-exports
+        for (const partRaw of body.split(',')) {
+            const part = partRaw.trim();
+            if (!part)
+                continue;
+            // `default as X`
+            const defAs = part.match(/^default\s+as\s+([A-Za-z_$][\w$]*)$/);
+            if (defAs) {
+                exportMap.set(defAs[1], { path, sourceName: 'default', isDefault: true });
+                continue;
+            }
+            // `X as Y`
+            const renamed = part.match(/^([A-Za-z_$][\w$]*)\s+as\s+([A-Za-z_$][\w$]*)$/);
+            if (renamed) {
+                exportMap.set(renamed[2], { path, sourceName: renamed[1], isDefault: false });
+                continue;
+            }
+            // `X`
+            if (/^[A-Za-z_$][\w$]*$/.test(part)) {
+                exportMap.set(part, { path, sourceName: part, isDefault: false });
+                continue;
+            }
+            // `default` (default re-export with no rename) is rare; skip.
+        }
+    }
+    // Primitives wave (P6) — `export * from './x.js'` support.
+    //
+    // Many barrel packages (date-fns, several utility libraries, some
+    // icon kits) use `export *` aggregation instead of per-name
+    // re-exports. The original synthesizer ignored these → exportMap
+    // stayed empty → /preview/@modules/<pkg> 500'd with "synthetic
+    // entry generation returned null".
+    //
+    // Strategy: harvest each `export *` source's own top-level export
+    // declarations once, and inject them into the same exportMap with
+    // `sourceName === exportedName`. This is not a full ESM resolver
+    // (we don't follow nested `export *` chains), but it covers the
+    // common case where the file at the end of the chain has explicit
+    // `export function X` / `export const X` / `export class X` /
+    // `export { X }` declarations — which matches every barrel
+    // observed in the wild.
+    //
+    // Cap on the number of `export *` sources we walk so a pathological
+    // barrel-of-barrels can't blow the synthesizer's budget.
+    const indexDirForStar = indexPath.substring(0, indexPath.lastIndexOf('/'));
+    const reExportStar = /export\s*\*\s*from\s*["']([^"']+)["']\s*;?/g;
+    const STAR_SOURCE_CAP = 1500; // date-fns has ~290; well within cap
+    let starSourcesWalked = 0;
+    let s;
+    while ((s = reExportStar.exec(indexCode)) !== null && starSourcesWalked < STAR_SOURCE_CAP) {
+        const path = s[1];
+        if (!path.startsWith('.'))
+            continue;
+        starSourcesWalked++;
+        const fullPath = normalizeJoin(indexDirForStar, path);
+        let starCode;
+        try {
+            starCode = vfs.readFileString(fullPath);
+        }
+        catch {
+            starCode = null;
+        }
+        if (!starCode)
+            continue;
+        // Harvest top-level exports from the source file. Order of patterns:
+        //   1. `export { X, Y as Z } from "..."` (re-export from elsewhere)
+        //   2. `export { X, Y as Z };` (re-export of locally-bound names)
+        //   3. `export function|class|const|let|var X` (declaration)
+        // We do NOT walk transitive `export *` chains; that's the
+        // budget cap in exchange for simplicity. esbuild handles the
+        // actual resolution at bundle time anyway — we only need enough
+        // entries in the map to MATCH the user's named imports.
+        const reInnerNamed = /export\s*\{([^}]+)\}\s*(?:from\s*["'][^"']+["'])?\s*;?/g;
+        let im;
+        while ((im = reInnerNamed.exec(starCode)) !== null) {
+            for (const partRaw of im[1].split(',')) {
+                const part = partRaw.trim();
+                if (!part)
+                    continue;
+                const renamed = part.match(/^([A-Za-z_$][\w$]*)\s+as\s+([A-Za-z_$][\w$]*)$/);
+                if (renamed) {
+                    if (!exportMap.has(renamed[2])) {
+                        exportMap.set(renamed[2], { path, sourceName: renamed[2], isDefault: false });
+                    }
+                    continue;
+                }
+                if (/^[A-Za-z_$][\w$]*$/.test(part)) {
+                    if (!exportMap.has(part)) {
+                        exportMap.set(part, { path, sourceName: part, isDefault: false });
+                    }
+                }
+            }
+        }
+        // Top-level declarations — `export function X`, `export class X`,
+        // `export const X`, `export let X`, `export var X`. Async, generator
+        // and TS modifiers (default, abstract) handled by the prefix opt-out.
+        const reDecl = /export\s+(?:async\s+)?(?:function\*?|class|const|let|var)\s+([A-Za-z_$][\w$]*)/g;
+        let dm;
+        while ((dm = reDecl.exec(starCode)) !== null) {
+            const name = dm[1];
+            if (!exportMap.has(name)) {
+                exportMap.set(name, { path, sourceName: name, isDefault: false });
+            }
+        }
+    }
+    if (exportMap.size === 0)
+        return null;
+    // Match user's requested names against the map. Build per-file
+    // groupings so the synthetic entry has one re-export per source
+    // file (smaller text, cleaner tree-shake graph).
+    const indexDir = indexPath.substring(0, indexPath.lastIndexOf('/'));
+    const grouped = new Map();
+    let matched = 0;
+    for (const name of names) {
+        const ref = exportMap.get(name);
+        if (!ref)
+            continue;
+        matched++;
+        // Resolve relative path against indexDir, then strip the
+        // package's nmDir prefix so we can build a `pkgName/...` import.
+        const fullPath = normalizeJoin(indexDir, ref.path);
+        let arr = grouped.get(fullPath);
+        if (!arr) {
+            arr = [];
+            grouped.set(fullPath, arr);
+        }
+        arr.push({ exportedName: name, sourceName: ref.sourceName, isDefault: ref.isDefault });
+    }
+    if (matched === 0)
+        return null;
+    // Emit per-file re-export lines. Use `pkgName/<rel-from-pkg-root>`
+    // so esbuild's resolver follows the package's exports field if any.
+    const pkgRoot = nmDir + '/' + pkgName;
+    const sortedFiles = [...grouped.keys()].sort();
+    const lines = [
+        `// AUTO-GENERATED synthetic entry for ${pkgName}`,
+        `// ${matched} of ${names.size} requested names matched the parsed barrel.`,
+        `// esbuild tree-shakes the rest of the package away.`,
+    ];
+    if (matched < names.size) {
+        const missing = [...names].filter(n => !exportMap.has(n));
+        lines.push(`// MISSING (not found in barrel index): ${missing.sort().join(', ')}`);
+    }
+    const referencedFiles = [];
+    for (const filePath of sortedFiles) {
+        let relFromPkg = filePath.startsWith(pkgRoot + '/')
+            ? filePath.substring(pkgRoot.length + 1)
+            : filePath;
+        // Use the package-rooted form so esbuild's resolver respects
+        // the package's exports/main fields. Strip leading slash.
+        const importSpec = pkgName + '/' + relFromPkg;
+        const items = grouped.get(filePath);
+        // Sort items for determinism.
+        items.sort((a, b) => a.exportedName.localeCompare(b.exportedName));
+        const memberLines = items.map(i => {
+            if (i.isDefault)
+                return `default as ${i.exportedName}`;
+            if (i.sourceName === i.exportedName)
+                return i.exportedName;
+            return `${i.sourceName} as ${i.exportedName}`;
+        });
+        lines.push(`export { ${memberLines.join(', ')} } from ${JSON.stringify(importSpec)};`);
+        referencedFiles.push(filePath);
+    }
+    return {
+        code: lines.join('\n') + '\n',
+        referencedFiles,
+    };
+}
+/**
+ * Build a SCOPED slice for a synthetic-entry bundle: include only
+ * the files the synthetic entry directly references (+ their
+ * transitive imports walked via static analysis), plus the package
+ * root's `package.json` (esbuild's resolver reads it for exports/main
+ * fields). This bypasses the standard `walkDir` over the whole
+ * package, which for icon-libraries with thousands of files can
+ * exceed the 28 MiB slice cap.
+ *
+ * Caller still appends the synthetic entry file itself to the slice
+ * (we don't include it here because it lives in a synthetic
+ * directory the caller already manages).
+ *
+ * Returns the list of `SliceEntry`-shaped objects to push into the
+ * existing slice, plus the total bytes added (for cap-tracking).
+ *
+ * `transitiveCap`: how many files we'll walk in total. Bounded so a
+ * pathological barrel-of-barrels can't blow the cap. Default 800,
+ * which empirically covers icon-libraries with up to ~400 imported
+ * icons (each pulling 1-2 transitive shared utility files).
+ */
+export function buildScopedSliceForSynthetic(vfs, nmDir, pkgName, referencedFiles, transitiveCap = 800) {
+    const entries = [];
+    let totalBytes = 0;
+    const visited = new Set();
+    const dirSet = new Set();
+    const pkgRoot = nmDir + '/' + pkgName;
+    const addDir = (d) => {
+        if (dirSet.has(d) || !d)
+            return;
+        dirSet.add(d);
+        entries.push({ path: '/' + d.replace(/^\/+/, ''), isDir: true });
+    };
+    // Always include the package root + its package.json. esbuild's
+    // resolver reads package.json for sideEffects, exports, main, etc.
+    addDir(pkgRoot);
+    const pkgJsonPath = pkgRoot + '/package.json';
+    if (vfs.exists(pkgJsonPath) && !vfs.isDirectory(pkgJsonPath)) {
+        try {
+            const bytes = vfs.readFile(pkgJsonPath);
+            entries.push({ path: '/' + pkgJsonPath.replace(/^\/+/, ''), bytes, isDir: false });
+            totalBytes += bytes.length + pkgJsonPath.length;
+            visited.add(pkgJsonPath);
+        }
+        catch { }
+    }
+    // Walker: BFS over referenced files + their relative imports.
+    const queue = [...referencedFiles];
+    while (queue.length > 0 && visited.size < transitiveCap) {
+        const filePath = queue.shift();
+        if (visited.has(filePath))
+            continue;
+        visited.add(filePath);
+        if (!vfs.exists(filePath) || vfs.isDirectory(filePath))
+            continue;
+        let bytes;
+        try {
+            bytes = vfs.readFile(filePath);
+        }
+        catch {
+            continue;
+        }
+        // Track parent dirs so esbuild's plugin's dirSet has them.
+        const slash = filePath.lastIndexOf('/');
+        if (slash > 0)
+            addDir(filePath.substring(0, slash));
+        entries.push({ path: '/' + filePath.replace(/^\/+/, ''), bytes, isDir: false });
+        totalBytes += bytes.length + filePath.length;
+        // Parse relative imports and queue them. Same regex as
+        // scanNamedImports but with relative-path predicate.
+        const text = new TextDecoder().decode(bytes);
+        const importRe = /(?:from\s+|import\s*\(?\s*)["'](\.\.?\/[^"']+)["']/g;
+        let m;
+        while ((m = importRe.exec(text)) !== null) {
+            const rel = m[1];
+            const dir = filePath.substring(0, slash > 0 ? slash : 0);
+            const candidate = normalizeJoin(dir, rel);
+            // Try with extensions (.js, .mjs, no-ext-as-dir/index.js).
+            for (const ext of ['', '.js', '.mjs', '.cjs', '.jsx']) {
+                const tryPath = candidate + ext;
+                if (!visited.has(tryPath) && vfs.exists(tryPath) && !vfs.isDirectory(tryPath)) {
+                    queue.push(tryPath);
+                    break;
+                }
+            }
+            // Also try as directory with index.js.
+            const idx = candidate + '/index.js';
+            if (!visited.has(idx) && vfs.exists(idx) && !vfs.isDirectory(idx)) {
+                queue.push(idx);
+            }
+        }
+    }
+    return { entries, totalBytes };
+}
+/**
+ * Resolve the package's main ESM entry file path (preferring the
+ * `module` field, then `main`). Returns null if the package isn't
+ * installed or doesn't expose a JS entry.
+ */
+function findPackageEsmEntry(vfs, nmDir, pkgName) {
+    const pkgRoot = nmDir + '/' + pkgName;
+    const pkgJsonPath = pkgRoot + '/package.json';
+    if (!vfs.exists(pkgJsonPath))
+        return null;
+    let pkg;
+    try {
+        pkg = JSON.parse(vfs.readFileString(pkgJsonPath));
+    }
+    catch {
+        return null;
+    }
+    // Prefer module (ESM), then main.
+    const candidates = [];
+    if (typeof pkg.module === 'string')
+        candidates.push(pkg.module);
+    if (typeof pkg.main === 'string')
+        candidates.push(pkg.main);
+    // Some packages publish `exports` field with a default condition
+    // pointing at ESM; try that as a tiebreaker.
+    if (pkg.exports && typeof pkg.exports === 'object') {
+        const root = pkg.exports['.'] || pkg.exports;
+        if (root && typeof root === 'object') {
+            const m = root.import || root.module || root.default;
+            if (typeof m === 'string')
+                candidates.unshift(m);
+        }
+        else if (typeof root === 'string') {
+            candidates.unshift(root);
+        }
+    }
+    for (const rel of candidates) {
+        const clean = rel.replace(/^\.\//, '');
+        const abs = pkgRoot + '/' + clean;
+        if (vfs.exists(abs) && !vfs.isDirectory(abs))
+            return abs;
+        // Try with index.js if rel is a directory.
+        const idx = abs + '/index.js';
+        if (vfs.exists(idx))
+            return idx;
+    }
+    return null;
+}
+/**
+ * Normalize-join two paths: `dir + '/' + rel`, resolving `.` and `..`
+ * segments. Used when the barrel-index references siblings via
+ * relative paths like `./icons/house.js`.
+ */
+function normalizeJoin(dir, rel) {
+    const stack = dir.split('/').filter(Boolean);
+    for (const seg of rel.split('/')) {
+        if (seg === '.' || seg === '')
+            continue;
+        if (seg === '..')
+            stack.pop();
+        else
+            stack.push(seg);
+    }
+    return (dir.startsWith('/') ? '/' : '') + stack.join('/');
+}
+/**
+ * VFS path where synthetic entries are written. Lives under the
+ * project's node_modules in a Nimbus-private namespace so package
+ * managers don't collide with real package directories.
+ *
+ * Format: <projDir>/node_modules/.nimbus-synthetic/<safeName>.entry.js
+ *
+ * Safe name = pkgName with '@' and '/' replaced by '__' so scoped
+ * packages produce a valid filesystem path.
+ */
+export function syntheticEntryPath(projDir, pkgName) {
+    const safe = pkgName.replace(/[@/]/g, '__');
+    return projDir + '/node_modules/.nimbus-synthetic/' + safe + '.entry.js';
+}

package/dist/runtime/bun-repl.d.ts

@@ -0,0 +1,46 @@
+/**
+ * bun-repl.ts — Bun REPL adapter.
+ *
+ * Bun is native (workerd nodejs_compat) — no facet-bootstrap like
+ * Pyodide. We dispatch eval through a long-lived child-facet that
+ * holds a vm.Context across submits, so user-defined variables /
+ * functions / imports persist.
+ *
+ * Design:
+ *   - One child-facet per REPL session (NimbusLoaderPool with
+ *     concurrency=1, omitSupervisor=true).
+ *   - Facet-side: globalThis.__nimbus_bun_ctx caches a vm.createContext()
+ *     dict; each push() runs vm.runInContext(line, ctx) and returns
+ *     {stdout, stderr, isIncomplete, isExit}.
+ *   - Continuation detection: probe parse via `new Function(...code)`
+ *     wrapped in try/catch — recoverable SyntaxError patterns
+ *     (per Node's repl.Recoverable shape) → incomplete.
+ *   - Expression displayhook: vm.runInContext returns the last
+ *     expression value; if !== undefined, util.inspect(value) → stdout.
+ *   - Exit: override process.exit inside the context to throw a
+ *     sentinel; catch sentinel → kind:'exit'.
+ *
+ * NOT supported in v1 (deferred):
+ *   - Top-level await at the REPL prompt (Bun supports this natively
+ *     but vm.runInContext doesn't unwrap top-level await — would need
+ *     vm.SourceTextModule or evaluation pre-wrap).
+ *   - Ctrl-C mid-execution (no SIGINT plumbing across facet boundary).
+ *   - Tab-completion.
+ *
+ * No setTimeout / sleep / retry / defensive-catch on hot paths. Errors
+ * thrown by vm bubble up; we surface them as stderr via the runtime
+ * stderr capture.
+ */
+import type { FacetManager } from '../facets/manager.js';
+import type { WebSocketTerminal } from '../facets/ws-terminal.js';
+export interface BunReplDeps {
+    facetMgr: FacetManager;
+    terminal: WebSocketTerminal;
+}
+/**
+ * Top-level wrapper: builds a Bun REPL adapter, drives a ReplSession
+ * to completion, returns the exit code. Called from the bun factory's
+ * wrapper in init.ts when `bun` is invoked with no args.
+ */
+export declare function runBunRepl(deps: BunReplDeps): Promise<number>;
+//# sourceMappingURL=bun-repl.d.ts.map

package/dist/runtime/bun-repl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bun-repl.d.ts","sourceRoot":"","sources":["../../src/runtime/bun-repl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAKlE,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,YAAY,CAAC;IACvB,QAAQ,EAAE,iBAAiB,CAAC;CAC7B;AAiTD;;;;GAIG;AACH,wBAAsB,UAAU,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAInE"}