@d1g1tal/tsbuild 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 D1g1talEntr0py
+
+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,388 @@
+# tsbuild
+
+A self-hosting TypeScript build tool that combines the best of three worlds: **TypeScript's type system**, **esbuild's speed**, and **SWC's decorator metadata support**. tsbuild is designed for modern ESM-only projects targeting Node.js 20.16.0+.
+
+> **⚠️ Note:** This is an experimental project for personal use. For production use, consider [tsup](https://tsup.egoist.dev/) instead, which is mature, battle-tested, and widely adopted. Or check out the new [tsdown](https://tsdown.dev/) by [void(0)](https://voidzero.dev/).
+
+## Features
+
+- 🚀 **Blazing Fast** - Leverages esbuild for rapid bundling and transpilation
+- 🔍 **Full Type Safety** - Uses TypeScript API for comprehensive type checking
+- 📦 **Declaration Bundling** - Automatically bundles `.d.ts` files into single entry points
+- ⚡ **Incremental Builds** - Intelligent caching with `.tsbuildinfo` for fast rebuilds
+- 👁️ **Watch Mode** - File watching with automatic rebuilds on changes
+- 🎨 **Decorator Metadata** - Optional SWC integration for `emitDecoratorMetadata` support for legacy decorators (Will probably be removed at some point in favor of native ESM decorators only)
+- 🔌 **Plugin System** - Extensible architecture with custom esbuild plugins
+- 🎯 **ESM-Only** - Pure ESM project with no CommonJS support by design
+- 🧹 **Clean Builds** - Optional output directory cleaning before builds
+- 📊 **Performance Metrics** - Built-in performance logging with detailed timing information
+
+## Why tsbuild?
+
+tsbuild orchestrates a sophisticated three-phase build process:
+
+1. **Type Checking Phase** - TypeScript compiler validates types and emits `.d.ts` files into memory (not disk)
+2. **Transpile Phase** - esbuild bundles JavaScript with custom plugins for module resolution and output formatting
+3. **DTS Bundle Phase** - Custom minimal bundler combines declaration files through dependency graph traversal and AST transformation
+
+This separation of concerns ensures TypeScript handles correctness, esbuild handles speed, and the custom bundler handles declaration consolidation efficiently without creating duplicate TypeScript Programs.
+
+## Installation
+
+```bash
+# pnpm - no SWC dependency (optional for decorator metadata)
+pnpm add -D @d1g1tal/tsbuild --no-optional
+
+# pnpm - with SWC dependency (for decorator metadata)
+pnpm add -D @d1g1tal/tsbuild
+
+# npm
+npm install -D @d1g1tal/tsbuild
+
+# yarn
+yarn add -D @d1g1tal/tsbuild
+```
+
+### Requirements
+
+- **Node.js**: >=20.16.0
+- **pnpm**: >=9.0.0
+
+## Usage
+
+### Configuration
+
+Add a `tsbuild` property to your `tsconfig.json`:
+
+```jsonc
+{
+  "compilerOptions": {
+    "declaration": true,
+    "isolatedModules": true,
+    "isolatedDeclarations": true,
+    "target": "ESNext",
+    "module": "ESNext",
+    "lib": [ "ESNext", "DOM" ],
+    "outDir": "./dist", // default value
+    // ... other TypeScript options
+  },
+  "tsbuild": {
+    "clean": true, // Remove all files from output directory before building (default: true)
+    "platform": "node", // Will default to "browser" if "DOM" is found in "lib", otherwise "node"
+    "entryPoints": {
+      "cli": "./src/cli.ts",
+      "index": "./src/index.ts"
+    },
+    "dts": {
+      "entryPoints": [ "index" ]  // Only bundle declarations for index
+    }
+  }
+}
+```
+
+### CLI Commands
+
+```bash
+# Build once
+tsbuild
+
+# Minify build output
+tsbuild --minify  # or -m
+
+# Force a full rebuild, bypassing incremental compilation.
+tsbuild --force  # or -f
+
+# Clear the incremental build cache (.tsbuild/dts_cache.v8.br) before building.
+tsbuild --clearCache  # or -c
+
+# Build with watch mode
+tsbuild --watch  # or -w
+
+# Type-check only (no bundling)
+tsbuild --noEmit  # or -n
+
+# Use custom tsconfig
+tsbuild --project ./tsconfig.build.json  # or -p
+
+# Display help
+tsbuild --help  # or -h
+
+# Display version
+tsbuild --version  # or -v
+```
+
+> **Note**: `--watch` and `--force` are CLI-only options. If you configure `watch` or `force` in the config, it will be ignored.
+
+### Package.json Scripts
+
+```json
+{
+  "scripts": {
+    "build": "tsbuild",
+    "build:watch": "tsbuild --watch",
+		"build:force": "tsbuild --force",
+    "type-check": "tsbuild --noEmit"
+  }
+}
+```
+
+## Configuration Options
+
+tsbuild supports a comprehensive set of options (full schema available in [`schema.json`](./schema.json)):
+
+### Entry Points
+
+```jsonc
+{
+  "tsbuild": {
+    // Object syntax - recommended for named outputs
+    "entryPoints": {
+      "cli": "./src/cli.ts",
+      "index": "./src/index.ts"
+    },
+
+    // Array syntax - auto-names based on file names
+    "entryPoints": ["./src/index.ts", "./src/cli.ts"]
+  }
+}
+```
+
+If a directory is provided, all files within will be used as entry points.
+
+### Declaration Bundling
+
+```jsonc
+{
+  "tsbuild": {
+    "dts": {},  // Use defaults (bundle declarations for all entry points)
+
+    // Or configure specific options
+    "dts": {
+      "entryPoints": ["index", "cli"],  // Names from entryPoints object
+      "resolve": false  // true = bundle external types from node_modules
+    }
+  }
+}
+```
+
+The `resolve` option controls whether to bundle external types from `node_modules` into your declaration files. When `false` (default for Node.js), external imports remain as import statements. When `true`, the bundler attempts to inline external types. This defaults to:
+- `false` for `platform: "node"` (recommended for Node.js projects - keeps external types as imports)
+- `true` for `platform: "browser"` and `platform: "neutral"` (bundles everything for standalone distribution)
+
+### External Dependencies
+
+```jsonc
+{
+  "tsbuild": {
+    // Don't bundle these modules (keep as imports)
+    "external": ["typescript", "esbuild"],
+
+    // Always bundle these modules (even if in dependencies)
+    "noExternal": ["lodash-es"],
+
+    // Bundle strategy: 'bundle' includes deps, 'external' excludes them
+    "packages": "external"
+  }
+}
+```
+
+By default, bare specifiers (e.g., `lodash`) are treated as external when `platform: "node"`. Use `noExternal` to force bundling specific packages.
+
+### Other Options
+
+```jsonc
+{
+  "tsbuild": {
+    "platform": "node",          // Target platform: 'node' | 'browser' | 'neutral'
+    "clean": true,               // Remove output directory contents before building (default: true)
+    "minify": false,             // Minify output
+    "sourceMap": true,           // Generate source maps (boolean | 'inline' | 'external' | 'both')
+    "splitting": true,           // Enable code splitting
+    "bundle": true,              // Enable/disable bundling
+    "force": false,              // Force full rebuild, bypassing incremental cache
+    "banner": {                  // Inject code at start of files
+      "js": "#!/usr/bin/env node"
+    },
+    "footer": {                  // Inject code at end of files
+      "js": "// Copyright 2025"
+    },
+    "env": {                     // Environment variables (accessible via import.meta.env)
+      "API_URL": "https://api.example.com"
+    },
+    "watch": {                   // Watch mode configuration
+      "enabled": false,          // Set via --watch CLI flag
+      "ignore": ["**/*.test.ts"]
+    },
+    "plugins": []                // Custom esbuild plugins (programmatic API only)
+  }
+}
+```
+
+**Note:** The `target` and `outDir` options come from `tsconfig.json` `compilerOptions` and cannot be overridden in the `tsbuild` section. The `force` and `minify` options are typically better controlled via CLI flags (`--force`, `--minify`) rather than in the config.
+
+## Advanced Features
+
+### Decorator Metadata
+
+tsbuild supports `emitDecoratorMetadata` through SWC integration:
+
+```jsonc
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true
+  }
+}
+```
+
+You must have `@swc/core` installed (as an optional dependency) for this feature to work:
+
+```bash
+pnpm add -D @swc/core
+```
+
+### Custom Plugins
+
+tsbuild supports custom esbuild plugins:
+
+```typescript
+import { TypeScriptProject } from 'tsbuild';
+
+const myPlugin = {
+  name: 'my-plugin',
+  setup(build) {
+    // Your plugin logic
+  }
+};
+
+// In tsconfig.json, plugins aren't directly supported
+// You'll need to use the TypeScriptProject API directly
+```
+
+### Lifecycle Management
+
+tsbuild includes built-in decorators for resource management:
+
+- `@closeOnExit` - Automatically cleanup resources on process exit or SIGINT
+- `@logPerformance` - Wraps async methods with performance timing
+
+These are used internally but can be leveraged when extending tsbuild.
+
+## Architecture
+
+### Core Components
+
+**TypeScriptProject** (`src/type-script-project.ts`) - Central orchestrator that manages the build lifecycle
+**FileManager** (`src/file-manager.ts`) - In-memory `.d.ts` storage with optional caching support
+**IncrementalBuildCache** (`src/incremental-build-cache.ts`) - Brotli-compressed caching to `.tsbuild/dts_cache.v8.br`
+**ProcessManager** (`src/process-manager.ts`) - Global cleanup coordinator for graceful shutdowns
+
+### Plugin System
+
+**External Modules Plugin** - Pattern-based external dependency resolution
+**Output Plugin** - Handles file writing and executable permissions (shebangs get 0o755)
+**Decorator Metadata Plugin** - Optional SWC transform for decorator metadata
+
+### DTS Bundling System
+
+The declaration bundling system (`src/dts/declaration-bundler.ts`) is a custom implementation that:
+
+1. **Module Graph Building** - Traverses import/export statements to build dependency graph using TypeScript's module resolution
+2. **Dependency Sorting** - Topologically sorts modules to ensure correct declaration order
+3. **Code Combination** - Strips imports/exports while preserving external references
+4. **Pre/Post Processing** (`declaration-processor.ts`) - Cleans up directives, splits declarations, fixes modifiers, normalizes exports
+
+This custom bundler works entirely with in-memory declaration files, avoiding the overhead of duplicate TypeScript Program creation with some other bundlers.
+
+## Performance
+
+tsbuild is designed for speed:
+
+- **Incremental builds** - Only recompiles changed files
+- **In-memory declarations** - No intermediate disk I/O for `.d.ts` files
+- **Parallel processing** - Type checking and transpilation run in parallel when possible
+- **Smart caching** - Leverages `.tsbuildinfo` for TypeScript incremental compilation
+
+Typical build times for the tsbuild project itself:
+- Full build: ~400-600ms
+- Incremental rebuild: ~100-200ms
+- Type-check only: ~50-100ms
+
+## Acknowledgments
+
+tsbuild was inspired by and borrows concepts from several excellent projects:
+
+### [tsup](https://tsup.egoist.dev/) by [@egoist](https://github.com/egoist)
+tsbuild's overall architecture, API design, and configuration approach are heavily influenced by tsup. The external module resolution strategy, entry point handling, and plugin system take direct inspiration from tsup's battle-tested design. If you need a production-ready build tool, use tsup.
+
+### [rollup-plugin-dts](https://github.com/Swatinem/rollup-plugin-dts) by [Arpad Borsos](https://github.com/Swatinem)
+The TypeScript declaration bundling system was originally inspired by rollup-plugin-dts's approach to handling complex TypeScript declarations. The current custom implementation builds a dependency graph and combines modules without Rollup, optimizing for in-memory operations and avoiding duplicate TypeScript Program creation.
+
+### Other Dependencies
+- **[esbuild](https://esbuild.github.io/)** - The incredibly fast JavaScript bundler that powers tsbuild's transpilation
+- **[TypeScript](https://www.typescriptlang.org/)** - Type checking, declaration generation, and module resolution
+- **[SWC](https://swc.rs/)** - Optional decorator metadata transformation
+- **[magic-string](https://github.com/Rich-Harris/magic-string)** - Efficient source code transformation with sourcemap support
+- **[watchr](https://github.com/bevry/watchr)** - File watching for watch mode
+
+## Limitations
+
+- **ESM Only** - No CommonJS support by design
+- **Node.js 20.16.0+** - Requires modern Node.js features
+- **Experimental** - Personal project, not recommended for production use
+- **Limited Configuration in tsconfig.json** - Some options (like `plugins`) are only available via programmatic API
+- **tsBuildInfoFile Path Changes** - When changing the `tsBuildInfoFile` path in `tsconfig.json`, the old `.tsbuildinfo` file at the previous location will not be automatically cleaned up and must be manually removed
+
+## Comparison with Other Tools
+
+| Feature | tsbuild | tsup | tsc |
+|---------|---------|------|-----|
+| Type Checking | ✅ Full | ✅ Full | ✅ Full |
+| Fast Bundling | ✅ esbuild | ✅ esbuild | ❌ N/A |
+| Declaration Bundling | ✅ Custom Bundler | ✅ rollup-plugin-dts | ❌ N/A |
+| Decorator Metadata | ✅ SWC (optional) | ✅ SWC | ✅ Native |
+| CommonJS Support | ❌ None | ✅ Yes | ✅ Yes |
+| Watch Mode | ✅ Yes | ✅ Yes | ✅ Yes |
+| Incremental Builds | ✅ Yes | ⚠️ Limited | ✅ Yes |
+| Production Ready | ⚠️ Experimental | ✅ Yes | ✅ Yes |
+
+## Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Build (self-hosting)
+pnpm build
+
+# Watch mode
+pnpm build:watch
+
+# Type-check only
+pnpm type-check
+
+# Run tests
+pnpm test
+
+# Run tests with coverage
+pnpm test:coverage
+
+# Lint
+pnpm lint
+```
+
+## Contributing
+
+This is a personal experimental project. While contributions are welcome, please note that the project is not actively maintained for production use.
+
+## License
+
+ISC
+
+## Author
+
+D1g1talEntr0py
+
+---
+
+**Remember:** For production projects, use [tsup](https://tsup.egoist.dev/) instead. tsbuild is an educational and experimental project exploring how modern build tools can be composed together.

package/dist/44KSX2XO.js

@@ -0,0 +1,269 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/constants.ts
+import { JsxEmit, ScriptTarget } from "typescript";
+var dataUnits = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+var Platform = { NODE: "node", BROWSER: "browser", NEUTRAL: "neutral" };
+var BuildMessageType = { ERROR: "error", WARNING: "warning" };
+var compilerOptionOverrides = {
+  // Skip code generation when error occurs
+  noEmitOnError: true,
+  // Do not allow JavaScript files to be imported into TypeScript files
+  allowJs: false,
+  // Skip type-checking JavaScript files
+  checkJs: false,
+  // Skip declaration map generation. TODO - Would love to figure out how to combine them into a single file / entry point
+  declarationMap: false,
+  // Skip type-checking all dependencies
+  skipLibCheck: true,
+  // Ensure TS2742 errors are visible when `true`. TODO - Figure out how to have this work with a value of `true`
+  preserveSymlinks: false,
+  // Ensure we can parse the latest code
+  target: ScriptTarget.ESNext
+};
+var scriptTargetToEsTarget = {
+  [ScriptTarget.ES3]: "ES6",
+  [ScriptTarget.ES5]: "ES6",
+  [ScriptTarget.ES2015]: "ES2015",
+  [ScriptTarget.ES2016]: "ES2016",
+  [ScriptTarget.ES2017]: "ES2017",
+  [ScriptTarget.ES2018]: "ES2018",
+  [ScriptTarget.ES2019]: "ES2019",
+  [ScriptTarget.ES2020]: "ES2020",
+  [ScriptTarget.ES2021]: "ES2021",
+  [ScriptTarget.ES2022]: "ES2022",
+  [ScriptTarget.ES2023]: "ES2023",
+  [ScriptTarget.ES2024]: "ES2024",
+  [ScriptTarget.ESNext]: "ESNext",
+  [ScriptTarget.JSON]: "ESNext"
+};
+var jsxEmitMap = {
+  [JsxEmit.Preserve]: "preserve",
+  [JsxEmit.React]: "react",
+  [JsxEmit.ReactNative]: "react-native",
+  [JsxEmit.ReactJSX]: "react-jsx",
+  [JsxEmit.ReactJSXDev]: "react-jsxdev"
+};
+var toEsTarget = (target) => scriptTargetToEsTarget[target];
+var toJsxRenderingMode = (jsxEmit) => jsxEmit !== void 0 ? jsxEmitMap[jsxEmit] : void 0;
+var FileExtension = {
+  JS: ".js",
+  DTS: ".d.ts",
+  CSS: ".css",
+  JSON: ".json"
+};
+var Encoding = {
+  utf8: "utf8",
+  base64: "base64"
+};
+var defaultDirOptions = { recursive: true };
+var defaultCleanOptions = { recursive: true, force: true };
+var defaultOutDirectory = "dist";
+var defaultEntryPoint = "index";
+var defaultSourceDirectory = "./src";
+var defaultEntryFile = "src/index.ts";
+var cacheDirectory = ".tsbuild";
+var buildInfoFile = "tsconfig.tsbuildinfo";
+var dtsCacheFile = "dts_cache.v8.br";
+var dtsCacheVersion = 2;
+var format = "esm";
+var newLine = "\n";
+var typeMatcher = /\btype\b/;
+var sourceScriptExtensionExpression = /(?<!\.d)\.[jt]sx?$/;
+var typeScriptExtensionExpression = /(\.tsx?)$/;
+var processEnvExpansionPattern = /\$\{process\.env\.([^}]+)\}/g;
+var inlineTypePattern = /([{,]\s+)type\s+/g;
+
+// src/paths.ts
+import { lstat } from "node:fs/promises";
+import { relative, resolve, join, parse } from "node:path";
+var Paths = class {
+  constructor() {
+  }
+  /**
+   * Computes the absolute path by joining the provided segments.
+   * @param paths Array of path segments to join
+   * @returns The absolute path
+   */
+  static absolute(...paths) {
+    return resolve(...paths);
+  }
+  /**
+   * Computes the relative path from one location to another.
+   * @param from The starting location
+   * @param to The target location
+   * @returns The relative path
+   */
+  static relative(from, to) {
+    return relative(from, to);
+  }
+  /**
+   * Returns the directory name of a path.
+   * @param path - The path to evaluate
+   * @returns The directory name of the path
+   */
+  static parse(path) {
+    return parse(path);
+  }
+  /**
+   * Checks if the given path is a directory.
+   * @param path - The path to check
+   * @returns True if the path is a directory, false otherwise
+   */
+  static async isDirectory(path) {
+    return (await lstat(path)).isDirectory();
+  }
+  /**
+   * Checks if the given path is a file.
+   * @param path - The path to check
+   * @returns True if the path is a file, false otherwise
+   */
+  static async isFile(path) {
+    return (await lstat(path)).isFile();
+  }
+  /**
+   * Checks if a module specifier represents a local path (not a bare specifier).
+   * Local paths start with '/', './', '../', '.', '..', or Windows drive letters (e.g., 'C:\').
+   * @param path - The module specifier to check
+   * @returns True if the path is a local/relative path, false if it's a bare specifier (node module)
+   */
+  static isPath(path) {
+    if (path.length === 0) {
+      return false;
+    }
+    const firstCharacter = path.charCodeAt(0);
+    if (firstCharacter === 47) {
+      return true;
+    }
+    if (firstCharacter === 46) {
+      if (path.length === 1) {
+        return true;
+      }
+      const c1 = path.charCodeAt(1);
+      if (c1 === 47) {
+        return true;
+      }
+      if (c1 === 46) {
+        return path.length === 2 || path.charCodeAt(2) === 47;
+      }
+      return false;
+    }
+    if (firstCharacter >= 65 && firstCharacter <= 90 && path.length >= 3 && path.charCodeAt(1) === 58) {
+      const c2 = path.charCodeAt(2);
+      return c2 === 47 || c2 === 92;
+    }
+    return false;
+  }
+  /**
+   * Joins multiple path segments into a single path.
+   * When the first segment is an AbsolutePath, returns AbsolutePath.
+   * Otherwise, returns RelativePath.
+   * @param first - The first path segment (determines if result is absolute)
+   * @param rest - Additional path segments to join
+   * @returns The joined path
+   */
+  static join(first, ...rest) {
+    return join(first, ...rest);
+  }
+};
+
+// src/json.ts
+var Json = class {
+  /**
+   * Parse a JSON string into an object of type T.
+   * @param jsonString The JSON string to parse.
+   * @returns The parsed object of type T.
+   */
+  static parse(jsonString) {
+    return JSON.parse(jsonString);
+  }
+  /**
+   * Serialize an object of type T into a JSON string.
+   * @param data The object to serialize.
+   * @returns The serialized JSON string.
+   */
+  static serialize(data) {
+    return JSON.stringify(data);
+  }
+};
+
+export {
+  __decoratorStart,
+  __runInitializers,
+  __decorateElement,
+  __publicField,
+  dataUnits,
+  Platform,
+  BuildMessageType,
+  compilerOptionOverrides,
+  toEsTarget,
+  toJsxRenderingMode,
+  FileExtension,
+  Encoding,
+  defaultDirOptions,
+  defaultCleanOptions,
+  defaultOutDirectory,
+  defaultEntryPoint,
+  defaultSourceDirectory,
+  defaultEntryFile,
+  cacheDirectory,
+  buildInfoFile,
+  dtsCacheFile,
+  dtsCacheVersion,
+  format,
+  newLine,
+  typeMatcher,
+  sourceScriptExtensionExpression,
+  typeScriptExtensionExpression,
+  processEnvExpansionPattern,
+  inlineTypePattern,
+  Paths,
+  Json
+};