@caryhu/codemine-forge 0.0.1-alpha.0

package/dist/forge-controller.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openForgeController = exports.createForgeController = void 0;
+const build_pipeline_1 = require("./build-pipeline");
+const dev_server_preview_1 = require("./dev-server-preview");
+const virtual_file_system_1 = require("./virtual-file-system");
+const package_resolution_1 = require("./package-resolution");
+const terminal_commands_1 = require("./terminal-commands");
+function createForgeController(options = {}) {
+    const fileSystem = options.fileSystem ?? (0, virtual_file_system_1.createVirtualFileSystem)();
+    const packageResolver = options.packageResolver ??
+        (0, package_resolution_1.createPackageResolver)({
+            ...options.packageResolution,
+            fileSystem,
+        });
+    const buildPipeline = options.buildPipeline ??
+        (0, build_pipeline_1.createBuildPipeline)({
+            ...options.buildPipelineOptions,
+            fileSystem,
+            packageResolver,
+        });
+    const devServerPreview = options.devServerPreview ??
+        (0, dev_server_preview_1.createDevServerPreview)({
+            ...options.devServerPreviewOptions,
+            fileSystem,
+            buildPipeline,
+        });
+    return new DefaultForgeController(fileSystem, buildPipeline, devServerPreview, packageResolver, options.terminal ??
+        (0, terminal_commands_1.createForgeTerminal)({
+            ...options.terminalOptions,
+            buildPipeline,
+            devServerPreview,
+            packageResolver,
+        }));
+}
+exports.createForgeController = createForgeController;
+async function openForgeController(options) {
+    const storage = options.storage ?? (0, virtual_file_system_1.createIndexedDbForgeStorage)({ limits: options.limits });
+    const fileSystem = await (0, virtual_file_system_1.openVirtualFileSystem)({
+        ...options,
+        storage,
+    });
+    const packageResolver = (0, package_resolution_1.createPackageResolver)({
+        ...options.packageResolution,
+        fileSystem,
+        storage,
+    });
+    const buildPipeline = (0, build_pipeline_1.createBuildPipeline)({
+        fileSystem,
+        packageResolver,
+    });
+    const devServerPreview = (0, dev_server_preview_1.createDevServerPreview)({
+        fileSystem,
+        buildPipeline,
+    });
+    return new DefaultForgeController(fileSystem, buildPipeline, devServerPreview, packageResolver, (0, terminal_commands_1.createForgeTerminal)({ buildPipeline, devServerPreview, packageResolver }));
+}
+exports.openForgeController = openForgeController;
+class DefaultForgeController {
+    constructor(fileSystem, buildPipeline, devServerPreview, packageResolver, terminal) {
+        this.fileSystem = fileSystem;
+        this.buildPipeline = buildPipeline;
+        this.devServerPreview = devServerPreview;
+        this.packageResolver = packageResolver;
+        this.terminal = terminal;
+    }
+    executeCommand(commandText, options) {
+        return this.terminal.execute(commandText, options);
+    }
+    rebuildDevSession(sessionId, options) {
+        return this.devServerPreview.rebuild(sessionId, options);
+    }
+    startDevSession(options) {
+        return this.devServerPreview.start(options);
+    }
+    stopDevSession(sessionId) {
+        return this.devServerPreview.stop(sessionId);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { createEsbuildWasmWorkerMessageHandler, createEsbuildWasmWorkerService, createTransformFailureDiagnostic, createUnsupportedOperationDiagnostic, createWasmInitializationFailureDiagnostic, createWorkerNotInitializedDiagnostic, createWorkerStartupFailureDiagnostic, DefaultEsbuildWasmWorkerService, ESBUILD_WASM_WORKER_CAPABILITY, ESBUILD_WASM_WORKER_PROTOCOL, installEsbuildWasmWorker, type ForgeEsbuildWasmDiagnosticCauseCategory, type ForgeEsbuildWasmInitializeFailureResult, type ForgeEsbuildWasmInitializeRequest, type ForgeEsbuildWasmInitializeResult, type ForgeEsbuildWasmInitializeSuccessResult, type ForgeEsbuildWasmInitializeWorkerFailureResponse, type ForgeEsbuildWasmInitializeWorkerRequest, type ForgeEsbuildWasmInitializeWorkerSuccessResponse, type ForgeEsbuildWasmRuntime, type ForgeEsbuildWasmRuntimeMetadata, type ForgeEsbuildWasmTransformFailureResult, type ForgeEsbuildWasmTransformLoader, type ForgeEsbuildWasmTransformRequest, type ForgeEsbuildWasmTransformResult, type ForgeEsbuildWasmTransformSuccessResult, type ForgeEsbuildWasmTransformWarning, type ForgeEsbuildWasmTransformWorkerFailureResponse, type ForgeEsbuildWasmTransformWorkerRequest, type ForgeEsbuildWasmTransformWorkerSuccessResponse, type ForgeEsbuildWasmUnsupportedOperation, type ForgeEsbuildWasmUnsupportedOperationResult, type ForgeEsbuildWasmUrl, type ForgeEsbuildWasmWorkerAdapterOptions, type ForgeEsbuildWasmWorkerDiagnostic, type ForgeEsbuildWasmWorkerDiagnosticCode, type ForgeEsbuildWasmWorkerFactory, type ForgeEsbuildWasmWorkerGlobalScope, type ForgeEsbuildWasmWorkerMessageEvent, type ForgeEsbuildWasmWorkerPort, type ForgeEsbuildWasmWorkerRequestMessage, type ForgeEsbuildWasmWorkerResponseMessage, type ForgeEsbuildWasmWorkerService, type ForgeEsbuildWasmWorkerServiceOptions, } from "./esbuild-wasm-worker";
+export { createForgeController, openForgeController, type ForgeController, type ForgeControllerOptions, type ForgeOpenControllerOptions, } from "./forge-controller";
+export { BUILD_PIPELINE_CAPABILITY, createBuildPipeline, createEsbuildWorkerTransformDiagnostic, createMissingBuildScriptDiagnostic, createMissingEntryDiagnostic, createUnresolvedImportDiagnostic, createUnsupportedBuildScriptDiagnostic, createViteConfigNotExecutedDiagnostic, DefaultBuildPipeline, isSupportedViteBuildScript, type ForgeBrowserBundle, type ForgeBrowserBundleManifest, type ForgeBuildDiagnostic, type ForgeBuildManifest, type ForgeBuildMode, type ForgeBuildOutputFile, type ForgeBuildPipeline, type ForgeBuildPipelineDiagnostic, type ForgeBuildPipelineDiagnosticCode, type ForgeBuildPipelineOptions, type ForgeBuildRequest, type ForgeBuildResult, type ForgeBuildTiming, } from "./build-pipeline";
+export { createInvalidDependencyDiagnostic, createInvalidManifestDiagnostic, createCdnPackageSource, createPackageCacheKey, createPackageResolutionDiagnostic, createPackageResolver, createUnsupportedRangeDiagnostic, createUnresolvedPackageDiagnostic, collectDependencyRequests, DEFAULT_FORGE_MANIFEST_PATH, DefaultPackageResolver, ForgePackageResolutionError, PACKAGE_RESOLUTION_CAPABILITY, readPackageManifest, type ForgeBundleAliases, type ForgeCdnPackageFetch, type ForgeCdnPackageMetadataUrlFactory, type ForgeCdnPackageSourceOptions, type ForgeDependencyKind, type ForgeDependencyRequest, type ForgeImportMap, type ForgePackageDiagnostic, type ForgePackageFile, type ForgePackageLockMetadata, type ForgePackageLockPackage, type ForgePackageManifest, type ForgePackageRecord, type ForgePackageResolutionDiagnostic, type ForgePackageResolutionDiagnosticCode, type ForgePackageResolutionMode, type ForgePackageResolutionResult, type ForgePackageResolver, type ForgePackageResolverOptions, type ForgePackageSource, type ForgeResolvePackagesOptions, } from "./package-resolution";
+export { createDevServerPreview, createForgePreviewDocument, createMissingDevScriptDiagnostic, createSessionNotFoundDiagnostic, createSessionStoppedDiagnostic, createUnsupportedDevScriptDiagnostic, DefaultDevServerPreview, DEV_SERVER_PREVIEW_CAPABILITY, isSupportedViteDevScript, type ForgeCreatePreviewDocumentOptions, type ForgeDevServerPreview, type ForgeDevServerPreviewDiagnostic, type ForgeDevServerPreviewDiagnosticCode, type ForgeDevServerPreviewEvent, type ForgeDevServerPreviewEventListener, type ForgeDevServerPreviewOptions, type ForgeDevSession, type ForgeDevSessionDiagnostic, type ForgeDevSessionFailedEvent, type ForgeDevSessionFileChange, type ForgeDevSessionRefreshResult, type ForgeDevSessionStartedEvent, type ForgeDevSessionStartResult, type ForgeDevSessionStatus, type ForgeDevSessionStoppedEvent, type ForgeDevSessionStopResult, type ForgePreviewDocument, type ForgePreviewRefreshedEvent, type ForgeRebuildDevSessionOptions, type ForgeStartDevSessionOptions, } from "./dev-server-preview";
+export { createForgeTerminal, createNpmInstallCommandHandler, createNpmRunBuildCommandHandler, createNpmRunDevCommandHandler, createParseErrorDiagnostic, createUnsupportedCommandDiagnostic, DefaultForgeTerminal, NpmInstallCommandHandler, NpmRunBuildCommandHandler, NpmRunDevCommandHandler, parseForgeCommandText, TERMINAL_COMMANDS_CAPABILITY, type ForgeCommand, type ForgeCommandContext, type ForgeCommandDiagnostic, type ForgeCommandHandler, type ForgeCommandParseResult, type ForgeCommandResult, type ForgeTerminal, type ForgeTerminalDiagnostic, type ForgeTerminalDiagnosticCode, type ForgeTerminalExecuteOptions, type ForgeTerminalOptions, type ForgeTerminalOutputKind, type ForgeTerminalOutputLine, } from "./terminal-commands";
+export { createVirtualFileSystem, createForgeDiagnostic, createInvalidPathDiagnostic, createMissingParentDiagnostic, createNotFoundDiagnostic, createNotImplementedDiagnostic, createPathTraversalDiagnostic, createIndexedDbForgeStorage, createLimitExceededDiagnostic, ForgeFileSystemError, DEFAULT_FORGE_VFS_LIMITS, FORGE_INDEXED_DB_NAME, FORGE_INDEXED_DB_STORES, FORGE_INDEXED_DB_VERSION, IndexedDbForgeStorage, normalizeForgePath, openVirtualFileSystem, resolveForgeVirtualFileSystemLimits, VIRTUAL_FILE_SYSTEM_CAPABILITY, type ForgeBuildCacheRecord, type ForgeDiagnosticInput, type ForgeDeleteOptions, type ForgeDiagnostic, type ForgeDiagnosticCode, type ForgeDiagnosticSeverity, type ForgeDirEntry, type ForgeFileCreatedEvent, type ForgeFileDeletedEvent, type ForgeFileEvent, type ForgeFileKind, type ForgeFileRecord, type ForgeFileRenamedEvent, type ForgeFileSource, type ForgeFileStat, type ForgeFileUpdatedEvent, type ForgeFileWatchListener, type ForgeLimitDiagnostic, type ForgeMkdirOptions, type ForgeOpenVirtualFileSystemOptions, type ForgePackageCacheRecord, type ForgePersistedWorkspace, type ForgeVirtualFileSystemLimits, type ResolvedForgeVirtualFileSystemLimits, type ForgeRestoreOptions, type ForgeSnapshot, type ForgeSnapshotOptions, type ForgeUnsubscribe, type ForgeVirtualFileSystemOptions, type ForgeVirtualFileSystemStorage, type ForgeVirtualFileSystem, type ForgeWorkspace, type ForgeWorkspaceMetadata, type ForgeWriteFileOptions, type ForgePathNormalizationResult, type IndexedDbForgeStorageOptions, } from "./virtual-file-system";

package/dist/index.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNpmRunDevCommandHandler = exports.createNpmRunBuildCommandHandler = exports.createNpmInstallCommandHandler = exports.createForgeTerminal = exports.isSupportedViteDevScript = exports.DEV_SERVER_PREVIEW_CAPABILITY = exports.DefaultDevServerPreview = exports.createUnsupportedDevScriptDiagnostic = exports.createSessionStoppedDiagnostic = exports.createSessionNotFoundDiagnostic = exports.createMissingDevScriptDiagnostic = exports.createForgePreviewDocument = exports.createDevServerPreview = exports.readPackageManifest = exports.PACKAGE_RESOLUTION_CAPABILITY = exports.ForgePackageResolutionError = exports.DefaultPackageResolver = exports.DEFAULT_FORGE_MANIFEST_PATH = exports.collectDependencyRequests = exports.createUnresolvedPackageDiagnostic = exports.createUnsupportedRangeDiagnostic = exports.createPackageResolver = exports.createPackageResolutionDiagnostic = exports.createPackageCacheKey = exports.createCdnPackageSource = exports.createInvalidManifestDiagnostic = exports.createInvalidDependencyDiagnostic = exports.isSupportedViteBuildScript = exports.DefaultBuildPipeline = exports.createViteConfigNotExecutedDiagnostic = exports.createUnsupportedBuildScriptDiagnostic = exports.createUnresolvedImportDiagnostic = exports.createMissingEntryDiagnostic = exports.createMissingBuildScriptDiagnostic = exports.createEsbuildWorkerTransformDiagnostic = exports.createBuildPipeline = exports.BUILD_PIPELINE_CAPABILITY = exports.openForgeController = exports.createForgeController = exports.installEsbuildWasmWorker = exports.ESBUILD_WASM_WORKER_PROTOCOL = exports.ESBUILD_WASM_WORKER_CAPABILITY = exports.DefaultEsbuildWasmWorkerService = exports.createWorkerStartupFailureDiagnostic = exports.createWorkerNotInitializedDiagnostic = exports.createWasmInitializationFailureDiagnostic = exports.createUnsupportedOperationDiagnostic = exports.createTransformFailureDiagnostic = exports.createEsbuildWasmWorkerService = exports.createEsbuildWasmWorkerMessageHandler = void 0;
+exports.VIRTUAL_FILE_SYSTEM_CAPABILITY = exports.resolveForgeVirtualFileSystemLimits = exports.openVirtualFileSystem = exports.normalizeForgePath = exports.IndexedDbForgeStorage = exports.FORGE_INDEXED_DB_VERSION = exports.FORGE_INDEXED_DB_STORES = exports.FORGE_INDEXED_DB_NAME = exports.DEFAULT_FORGE_VFS_LIMITS = exports.ForgeFileSystemError = exports.createLimitExceededDiagnostic = exports.createIndexedDbForgeStorage = exports.createPathTraversalDiagnostic = exports.createNotImplementedDiagnostic = exports.createNotFoundDiagnostic = exports.createMissingParentDiagnostic = exports.createInvalidPathDiagnostic = exports.createForgeDiagnostic = exports.createVirtualFileSystem = exports.TERMINAL_COMMANDS_CAPABILITY = exports.parseForgeCommandText = exports.NpmRunDevCommandHandler = exports.NpmRunBuildCommandHandler = exports.NpmInstallCommandHandler = exports.DefaultForgeTerminal = exports.createUnsupportedCommandDiagnostic = exports.createParseErrorDiagnostic = void 0;
+var esbuild_wasm_worker_1 = require("./esbuild-wasm-worker");
+Object.defineProperty(exports, "createEsbuildWasmWorkerMessageHandler", { enumerable: true, get: function () { return esbuild_wasm_worker_1.createEsbuildWasmWorkerMessageHandler; } });
+Object.defineProperty(exports, "createEsbuildWasmWorkerService", { enumerable: true, get: function () { return esbuild_wasm_worker_1.createEsbuildWasmWorkerService; } });
+Object.defineProperty(exports, "createTransformFailureDiagnostic", { enumerable: true, get: function () { return esbuild_wasm_worker_1.createTransformFailureDiagnostic; } });
+Object.defineProperty(exports, "createUnsupportedOperationDiagnostic", { enumerable: true, get: function () { return esbuild_wasm_worker_1.createUnsupportedOperationDiagnostic; } });
+Object.defineProperty(exports, "createWasmInitializationFailureDiagnostic", { enumerable: true, get: function () { return esbuild_wasm_worker_1.createWasmInitializationFailureDiagnostic; } });
+Object.defineProperty(exports, "createWorkerNotInitializedDiagnostic", { enumerable: true, get: function () { return esbuild_wasm_worker_1.createWorkerNotInitializedDiagnostic; } });
+Object.defineProperty(exports, "createWorkerStartupFailureDiagnostic", { enumerable: true, get: function () { return esbuild_wasm_worker_1.createWorkerStartupFailureDiagnostic; } });
+Object.defineProperty(exports, "DefaultEsbuildWasmWorkerService", { enumerable: true, get: function () { return esbuild_wasm_worker_1.DefaultEsbuildWasmWorkerService; } });
+Object.defineProperty(exports, "ESBUILD_WASM_WORKER_CAPABILITY", { enumerable: true, get: function () { return esbuild_wasm_worker_1.ESBUILD_WASM_WORKER_CAPABILITY; } });
+Object.defineProperty(exports, "ESBUILD_WASM_WORKER_PROTOCOL", { enumerable: true, get: function () { return esbuild_wasm_worker_1.ESBUILD_WASM_WORKER_PROTOCOL; } });
+Object.defineProperty(exports, "installEsbuildWasmWorker", { enumerable: true, get: function () { return esbuild_wasm_worker_1.installEsbuildWasmWorker; } });
+var forge_controller_1 = require("./forge-controller");
+Object.defineProperty(exports, "createForgeController", { enumerable: true, get: function () { return forge_controller_1.createForgeController; } });
+Object.defineProperty(exports, "openForgeController", { enumerable: true, get: function () { return forge_controller_1.openForgeController; } });
+var build_pipeline_1 = require("./build-pipeline");
+Object.defineProperty(exports, "BUILD_PIPELINE_CAPABILITY", { enumerable: true, get: function () { return build_pipeline_1.BUILD_PIPELINE_CAPABILITY; } });
+Object.defineProperty(exports, "createBuildPipeline", { enumerable: true, get: function () { return build_pipeline_1.createBuildPipeline; } });
+Object.defineProperty(exports, "createEsbuildWorkerTransformDiagnostic", { enumerable: true, get: function () { return build_pipeline_1.createEsbuildWorkerTransformDiagnostic; } });
+Object.defineProperty(exports, "createMissingBuildScriptDiagnostic", { enumerable: true, get: function () { return build_pipeline_1.createMissingBuildScriptDiagnostic; } });
+Object.defineProperty(exports, "createMissingEntryDiagnostic", { enumerable: true, get: function () { return build_pipeline_1.createMissingEntryDiagnostic; } });
+Object.defineProperty(exports, "createUnresolvedImportDiagnostic", { enumerable: true, get: function () { return build_pipeline_1.createUnresolvedImportDiagnostic; } });
+Object.defineProperty(exports, "createUnsupportedBuildScriptDiagnostic", { enumerable: true, get: function () { return build_pipeline_1.createUnsupportedBuildScriptDiagnostic; } });
+Object.defineProperty(exports, "createViteConfigNotExecutedDiagnostic", { enumerable: true, get: function () { return build_pipeline_1.createViteConfigNotExecutedDiagnostic; } });
+Object.defineProperty(exports, "DefaultBuildPipeline", { enumerable: true, get: function () { return build_pipeline_1.DefaultBuildPipeline; } });
+Object.defineProperty(exports, "isSupportedViteBuildScript", { enumerable: true, get: function () { return build_pipeline_1.isSupportedViteBuildScript; } });
+var package_resolution_1 = require("./package-resolution");
+Object.defineProperty(exports, "createInvalidDependencyDiagnostic", { enumerable: true, get: function () { return package_resolution_1.createInvalidDependencyDiagnostic; } });
+Object.defineProperty(exports, "createInvalidManifestDiagnostic", { enumerable: true, get: function () { return package_resolution_1.createInvalidManifestDiagnostic; } });
+Object.defineProperty(exports, "createCdnPackageSource", { enumerable: true, get: function () { return package_resolution_1.createCdnPackageSource; } });
+Object.defineProperty(exports, "createPackageCacheKey", { enumerable: true, get: function () { return package_resolution_1.createPackageCacheKey; } });
+Object.defineProperty(exports, "createPackageResolutionDiagnostic", { enumerable: true, get: function () { return package_resolution_1.createPackageResolutionDiagnostic; } });
+Object.defineProperty(exports, "createPackageResolver", { enumerable: true, get: function () { return package_resolution_1.createPackageResolver; } });
+Object.defineProperty(exports, "createUnsupportedRangeDiagnostic", { enumerable: true, get: function () { return package_resolution_1.createUnsupportedRangeDiagnostic; } });
+Object.defineProperty(exports, "createUnresolvedPackageDiagnostic", { enumerable: true, get: function () { return package_resolution_1.createUnresolvedPackageDiagnostic; } });
+Object.defineProperty(exports, "collectDependencyRequests", { enumerable: true, get: function () { return package_resolution_1.collectDependencyRequests; } });
+Object.defineProperty(exports, "DEFAULT_FORGE_MANIFEST_PATH", { enumerable: true, get: function () { return package_resolution_1.DEFAULT_FORGE_MANIFEST_PATH; } });
+Object.defineProperty(exports, "DefaultPackageResolver", { enumerable: true, get: function () { return package_resolution_1.DefaultPackageResolver; } });
+Object.defineProperty(exports, "ForgePackageResolutionError", { enumerable: true, get: function () { return package_resolution_1.ForgePackageResolutionError; } });
+Object.defineProperty(exports, "PACKAGE_RESOLUTION_CAPABILITY", { enumerable: true, get: function () { return package_resolution_1.PACKAGE_RESOLUTION_CAPABILITY; } });
+Object.defineProperty(exports, "readPackageManifest", { enumerable: true, get: function () { return package_resolution_1.readPackageManifest; } });
+var dev_server_preview_1 = require("./dev-server-preview");
+Object.defineProperty(exports, "createDevServerPreview", { enumerable: true, get: function () { return dev_server_preview_1.createDevServerPreview; } });
+Object.defineProperty(exports, "createForgePreviewDocument", { enumerable: true, get: function () { return dev_server_preview_1.createForgePreviewDocument; } });
+Object.defineProperty(exports, "createMissingDevScriptDiagnostic", { enumerable: true, get: function () { return dev_server_preview_1.createMissingDevScriptDiagnostic; } });
+Object.defineProperty(exports, "createSessionNotFoundDiagnostic", { enumerable: true, get: function () { return dev_server_preview_1.createSessionNotFoundDiagnostic; } });
+Object.defineProperty(exports, "createSessionStoppedDiagnostic", { enumerable: true, get: function () { return dev_server_preview_1.createSessionStoppedDiagnostic; } });
+Object.defineProperty(exports, "createUnsupportedDevScriptDiagnostic", { enumerable: true, get: function () { return dev_server_preview_1.createUnsupportedDevScriptDiagnostic; } });
+Object.defineProperty(exports, "DefaultDevServerPreview", { enumerable: true, get: function () { return dev_server_preview_1.DefaultDevServerPreview; } });
+Object.defineProperty(exports, "DEV_SERVER_PREVIEW_CAPABILITY", { enumerable: true, get: function () { return dev_server_preview_1.DEV_SERVER_PREVIEW_CAPABILITY; } });
+Object.defineProperty(exports, "isSupportedViteDevScript", { enumerable: true, get: function () { return dev_server_preview_1.isSupportedViteDevScript; } });
+var terminal_commands_1 = require("./terminal-commands");
+Object.defineProperty(exports, "createForgeTerminal", { enumerable: true, get: function () { return terminal_commands_1.createForgeTerminal; } });
+Object.defineProperty(exports, "createNpmInstallCommandHandler", { enumerable: true, get: function () { return terminal_commands_1.createNpmInstallCommandHandler; } });
+Object.defineProperty(exports, "createNpmRunBuildCommandHandler", { enumerable: true, get: function () { return terminal_commands_1.createNpmRunBuildCommandHandler; } });
+Object.defineProperty(exports, "createNpmRunDevCommandHandler", { enumerable: true, get: function () { return terminal_commands_1.createNpmRunDevCommandHandler; } });
+Object.defineProperty(exports, "createParseErrorDiagnostic", { enumerable: true, get: function () { return terminal_commands_1.createParseErrorDiagnostic; } });
+Object.defineProperty(exports, "createUnsupportedCommandDiagnostic", { enumerable: true, get: function () { return terminal_commands_1.createUnsupportedCommandDiagnostic; } });
+Object.defineProperty(exports, "DefaultForgeTerminal", { enumerable: true, get: function () { return terminal_commands_1.DefaultForgeTerminal; } });
+Object.defineProperty(exports, "NpmInstallCommandHandler", { enumerable: true, get: function () { return terminal_commands_1.NpmInstallCommandHandler; } });
+Object.defineProperty(exports, "NpmRunBuildCommandHandler", { enumerable: true, get: function () { return terminal_commands_1.NpmRunBuildCommandHandler; } });
+Object.defineProperty(exports, "NpmRunDevCommandHandler", { enumerable: true, get: function () { return terminal_commands_1.NpmRunDevCommandHandler; } });
+Object.defineProperty(exports, "parseForgeCommandText", { enumerable: true, get: function () { return terminal_commands_1.parseForgeCommandText; } });
+Object.defineProperty(exports, "TERMINAL_COMMANDS_CAPABILITY", { enumerable: true, get: function () { return terminal_commands_1.TERMINAL_COMMANDS_CAPABILITY; } });
+var virtual_file_system_1 = require("./virtual-file-system");
+Object.defineProperty(exports, "createVirtualFileSystem", { enumerable: true, get: function () { return virtual_file_system_1.createVirtualFileSystem; } });
+Object.defineProperty(exports, "createForgeDiagnostic", { enumerable: true, get: function () { return virtual_file_system_1.createForgeDiagnostic; } });
+Object.defineProperty(exports, "createInvalidPathDiagnostic", { enumerable: true, get: function () { return virtual_file_system_1.createInvalidPathDiagnostic; } });
+Object.defineProperty(exports, "createMissingParentDiagnostic", { enumerable: true, get: function () { return virtual_file_system_1.createMissingParentDiagnostic; } });
+Object.defineProperty(exports, "createNotFoundDiagnostic", { enumerable: true, get: function () { return virtual_file_system_1.createNotFoundDiagnostic; } });
+Object.defineProperty(exports, "createNotImplementedDiagnostic", { enumerable: true, get: function () { return virtual_file_system_1.createNotImplementedDiagnostic; } });
+Object.defineProperty(exports, "createPathTraversalDiagnostic", { enumerable: true, get: function () { return virtual_file_system_1.createPathTraversalDiagnostic; } });
+Object.defineProperty(exports, "createIndexedDbForgeStorage", { enumerable: true, get: function () { return virtual_file_system_1.createIndexedDbForgeStorage; } });
+Object.defineProperty(exports, "createLimitExceededDiagnostic", { enumerable: true, get: function () { return virtual_file_system_1.createLimitExceededDiagnostic; } });
+Object.defineProperty(exports, "ForgeFileSystemError", { enumerable: true, get: function () { return virtual_file_system_1.ForgeFileSystemError; } });
+Object.defineProperty(exports, "DEFAULT_FORGE_VFS_LIMITS", { enumerable: true, get: function () { return virtual_file_system_1.DEFAULT_FORGE_VFS_LIMITS; } });
+Object.defineProperty(exports, "FORGE_INDEXED_DB_NAME", { enumerable: true, get: function () { return virtual_file_system_1.FORGE_INDEXED_DB_NAME; } });
+Object.defineProperty(exports, "FORGE_INDEXED_DB_STORES", { enumerable: true, get: function () { return virtual_file_system_1.FORGE_INDEXED_DB_STORES; } });
+Object.defineProperty(exports, "FORGE_INDEXED_DB_VERSION", { enumerable: true, get: function () { return virtual_file_system_1.FORGE_INDEXED_DB_VERSION; } });
+Object.defineProperty(exports, "IndexedDbForgeStorage", { enumerable: true, get: function () { return virtual_file_system_1.IndexedDbForgeStorage; } });
+Object.defineProperty(exports, "normalizeForgePath", { enumerable: true, get: function () { return virtual_file_system_1.normalizeForgePath; } });
+Object.defineProperty(exports, "openVirtualFileSystem", { enumerable: true, get: function () { return virtual_file_system_1.openVirtualFileSystem; } });
+Object.defineProperty(exports, "resolveForgeVirtualFileSystemLimits", { enumerable: true, get: function () { return virtual_file_system_1.resolveForgeVirtualFileSystemLimits; } });
+Object.defineProperty(exports, "VIRTUAL_FILE_SYSTEM_CAPABILITY", { enumerable: true, get: function () { return virtual_file_system_1.VIRTUAL_FILE_SYSTEM_CAPABILITY; } });

package/dist/package-resolution/cdn-source.d.ts

@@ -0,0 +1,11 @@
+import type { ForgeDependencyRequest, ForgePackageSource } from "./types";
+export type ForgeCdnPackageFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export type ForgeCdnPackageMetadataUrlFactory = (request: ForgeDependencyRequest, baseUrl: string) => string | URL;
+export interface ForgeCdnPackageSourceOptions {
+    readonly baseUrl: string | URL;
+    readonly id?: string;
+    readonly fetch?: ForgeCdnPackageFetch;
+    readonly headers?: HeadersInit;
+    readonly createMetadataUrl?: ForgeCdnPackageMetadataUrlFactory;
+}
+export declare function createCdnPackageSource(options: ForgeCdnPackageSourceOptions): ForgePackageSource;

package/dist/package-resolution/cdn-source.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCdnPackageSource = void 0;
+const DEFAULT_CDN_SOURCE_ID = "cdn";
+function createCdnPackageSource(options) {
+    const baseUrl = options.baseUrl.toString();
+    const fetchPackage = options.fetch ?? globalThis.fetch?.bind(globalThis);
+    const sourceId = options.id ?? DEFAULT_CDN_SOURCE_ID;
+    const createMetadataUrl = options.createMetadataUrl ?? createDefaultMetadataUrl;
+    return {
+        id: sourceId,
+        async resolvePackage(request) {
+            if (fetchPackage === undefined) {
+                return undefined;
+            }
+            let response;
+            try {
+                response = await fetchPackage(createMetadataUrl(request, baseUrl), {
+                    headers: options.headers,
+                });
+            }
+            catch {
+                return undefined;
+            }
+            if (!response.ok) {
+                return undefined;
+            }
+            let metadata;
+            try {
+                metadata = await response.json();
+            }
+            catch {
+                return undefined;
+            }
+            return normalizeCdnPackageRecord(metadata, request, sourceId);
+        },
+    };
+}
+exports.createCdnPackageSource = createCdnPackageSource;
+function createDefaultMetadataUrl(request, baseUrl) {
+    const trimmedBase = baseUrl.replace(/\/+$/, "");
+    const packageKey = `${encodeURIComponent(request.name)}@${encodeURIComponent(request.requestedRange)}`;
+    return `${trimmedBase}/${packageKey}.json`;
+}
+function normalizeCdnPackageRecord(metadata, request, sourceId) {
+    if (!isPlainObject(metadata)) {
+        return undefined;
+    }
+    const version = stringField(metadata, "version");
+    const entry = selectPackageEntry(metadata);
+    const entryUrl = stringField(metadata, "entryUrl");
+    if (version === undefined || entry === undefined) {
+        return undefined;
+    }
+    return {
+        name: request.name,
+        requestedRange: request.requestedRange,
+        sourceId,
+        version,
+        entry,
+        entryUrl,
+        browserEntry: stringField(metadata, "browserEntry") ?? browserEntryField(metadata),
+        moduleEntry: stringField(metadata, "moduleEntry") ?? stringField(metadata, "module"),
+        dependencies: stringRecordField(metadata, "dependencies") ?? {},
+        files: packageFilesField(metadata, "files") ?? {},
+        integrity: stringField(metadata, "integrity"),
+    };
+}
+function selectPackageEntry(metadata) {
+    return (stringField(metadata, "entry") ??
+        browserEntryField(metadata) ??
+        exportsEntryField(metadata) ??
+        stringField(metadata, "moduleEntry") ??
+        stringField(metadata, "module") ??
+        stringField(metadata, "main"));
+}
+function browserEntryField(metadata) {
+    const browser = metadata.browser;
+    return typeof browser === "string" && browser.length > 0
+        ? browser
+        : undefined;
+}
+function exportsEntryField(metadata) {
+    return selectExportEntry(metadata.exports);
+}
+function selectExportEntry(value) {
+    if (typeof value === "string" && value.length > 0) {
+        return value;
+    }
+    if (!isPlainObject(value)) {
+        return undefined;
+    }
+    const rootExport = value["."];
+    if (rootExport !== undefined) {
+        return selectExportEntry(rootExport);
+    }
+    return (selectExportCondition(value, "browser") ??
+        selectExportCondition(value, "import") ??
+        selectExportCondition(value, "default"));
+}
+function selectExportCondition(value, condition) {
+    return selectExportEntry(value[condition]);
+}
+function packageFilesField(value, field) {
+    const files = value[field];
+    if (files === undefined) {
+        return undefined;
+    }
+    if (!isPlainObject(files)) {
+        return undefined;
+    }
+    const result = {};
+    for (const [path, file] of Object.entries(files)) {
+        if (!isPlainObject(file)) {
+            return undefined;
+        }
+        const filePath = stringField(file, "path") ?? path;
+        const contentType = stringField(file, "contentType");
+        const size = numberField(file, "size");
+        const content = file.content;
+        if (content !== undefined &&
+            typeof content !== "string" &&
+            !(content instanceof Uint8Array)) {
+            return undefined;
+        }
+        result[path] = {
+            path: filePath,
+            content,
+            contentType,
+            size,
+        };
+    }
+    return result;
+}
+function stringRecordField(value, field) {
+    const record = value[field];
+    if (record === undefined) {
+        return undefined;
+    }
+    if (!isPlainObject(record)) {
+        return undefined;
+    }
+    const result = {};
+    for (const [key, item] of Object.entries(record)) {
+        if (typeof item !== "string") {
+            return undefined;
+        }
+        result[key] = item;
+    }
+    return result;
+}
+function stringField(value, field) {
+    const item = value[field];
+    return typeof item === "string" && item.length > 0 ? item : undefined;
+}
+function numberField(value, field) {
+    const item = value[field];
+    return typeof item === "number" && Number.isFinite(item) ? item : undefined;
+}
+function isPlainObject(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value));
+}

package/dist/package-resolution/diagnostics.d.ts

@@ -0,0 +1,15 @@
+import type { ForgePackageResolutionDiagnostic, ForgePackageResolutionDiagnosticCode } from "./types";
+interface ForgePackageDiagnosticInput {
+    readonly code: ForgePackageResolutionDiagnosticCode;
+    readonly message: string;
+    readonly path?: string;
+    readonly dependencyName?: string;
+    readonly requestedRange?: string;
+    readonly cause?: unknown;
+}
+export declare function createPackageResolutionDiagnostic(input: ForgePackageDiagnosticInput): ForgePackageResolutionDiagnostic;
+export declare function createInvalidManifestDiagnostic(path: string, cause?: unknown): ForgePackageResolutionDiagnostic;
+export declare function createInvalidDependencyDiagnostic(dependencyName: string, requestedRange: string | undefined, message?: string): ForgePackageResolutionDiagnostic;
+export declare function createUnsupportedRangeDiagnostic(dependencyName: string, requestedRange: string): ForgePackageResolutionDiagnostic;
+export declare function createUnresolvedPackageDiagnostic(dependencyName: string, requestedRange: string): ForgePackageResolutionDiagnostic;
+export {};

package/dist/package-resolution/diagnostics.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUnresolvedPackageDiagnostic = exports.createUnsupportedRangeDiagnostic = exports.createInvalidDependencyDiagnostic = exports.createInvalidManifestDiagnostic = exports.createPackageResolutionDiagnostic = void 0;
+function createPackageResolutionDiagnostic(input) {
+    return {
+        code: input.code,
+        severity: "error",
+        message: input.message,
+        path: input.path,
+        dependencyName: input.dependencyName,
+        requestedRange: input.requestedRange,
+        cause: input.cause,
+    };
+}
+exports.createPackageResolutionDiagnostic = createPackageResolutionDiagnostic;
+function createInvalidManifestDiagnostic(path, cause) {
+    return createPackageResolutionDiagnostic({
+        code: "invalid_manifest",
+        message: "Package manifest is invalid.",
+        path,
+        cause,
+    });
+}
+exports.createInvalidManifestDiagnostic = createInvalidManifestDiagnostic;
+function createInvalidDependencyDiagnostic(dependencyName, requestedRange, message = "Package dependency declaration is invalid.") {
+    return createPackageResolutionDiagnostic({
+        code: "invalid_dependency",
+        message,
+        dependencyName,
+        requestedRange,
+    });
+}
+exports.createInvalidDependencyDiagnostic = createInvalidDependencyDiagnostic;
+function createUnsupportedRangeDiagnostic(dependencyName, requestedRange) {
+    return createPackageResolutionDiagnostic({
+        code: "unsupported_range",
+        message: "Package range uses an unsupported resolver protocol.",
+        dependencyName,
+        requestedRange,
+    });
+}
+exports.createUnsupportedRangeDiagnostic = createUnsupportedRangeDiagnostic;
+function createUnresolvedPackageDiagnostic(dependencyName, requestedRange) {
+    return createPackageResolutionDiagnostic({
+        code: "unresolved_package",
+        message: "Package could not be resolved by configured sources.",
+        dependencyName,
+        requestedRange,
+    });
+}
+exports.createUnresolvedPackageDiagnostic = createUnresolvedPackageDiagnostic;

package/dist/package-resolution/errors.d.ts

@@ -0,0 +1,5 @@
+import type { ForgePackageDiagnostic } from "./types";
+export declare class ForgePackageResolutionError extends Error {
+    readonly diagnostic: ForgePackageDiagnostic;
+    constructor(diagnostic: ForgePackageDiagnostic);
+}

package/dist/package-resolution/errors.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForgePackageResolutionError = void 0;
+class ForgePackageResolutionError extends Error {
+    constructor(diagnostic) {
+        super(diagnostic.message);
+        this.diagnostic = diagnostic;
+        this.name = "ForgePackageResolutionError";
+    }
+}
+exports.ForgePackageResolutionError = ForgePackageResolutionError;

package/dist/package-resolution/index.d.ts

@@ -0,0 +1,6 @@
+export { createCdnPackageSource, type ForgeCdnPackageFetch, type ForgeCdnPackageMetadataUrlFactory, type ForgeCdnPackageSourceOptions, } from "./cdn-source";
+export { createInvalidDependencyDiagnostic, createInvalidManifestDiagnostic, createPackageResolutionDiagnostic, createUnsupportedRangeDiagnostic, createUnresolvedPackageDiagnostic, } from "./diagnostics";
+export { ForgePackageResolutionError } from "./errors";
+export { collectDependencyRequests, DEFAULT_FORGE_MANIFEST_PATH, readPackageManifest, } from "./manifest";
+export { createPackageCacheKey, createPackageResolver, DefaultPackageResolver, } from "./resolver";
+export { PACKAGE_RESOLUTION_CAPABILITY, type ForgeBundleAliases, type ForgeDependencyKind, type ForgeDependencyRequest, type ForgeImportMap, type ForgePackageDiagnostic, type ForgePackageFile, type ForgePackageLockMetadata, type ForgePackageLockPackage, type ForgePackageManifest, type ForgePackageRecord, type ForgePackageResolutionDiagnostic, type ForgePackageResolutionDiagnosticCode, type ForgePackageResolutionMode, type ForgePackageResolutionResult, type ForgePackageResolver, type ForgePackageResolverOptions, type ForgePackageSource, type ForgeResolvePackagesOptions, } from "./types";

package/dist/package-resolution/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PACKAGE_RESOLUTION_CAPABILITY = exports.DefaultPackageResolver = exports.createPackageResolver = exports.createPackageCacheKey = exports.readPackageManifest = exports.DEFAULT_FORGE_MANIFEST_PATH = exports.collectDependencyRequests = exports.ForgePackageResolutionError = exports.createUnresolvedPackageDiagnostic = exports.createUnsupportedRangeDiagnostic = exports.createPackageResolutionDiagnostic = exports.createInvalidManifestDiagnostic = exports.createInvalidDependencyDiagnostic = exports.createCdnPackageSource = void 0;
+var cdn_source_1 = require("./cdn-source");
+Object.defineProperty(exports, "createCdnPackageSource", { enumerable: true, get: function () { return cdn_source_1.createCdnPackageSource; } });
+var diagnostics_1 = require("./diagnostics");
+Object.defineProperty(exports, "createInvalidDependencyDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createInvalidDependencyDiagnostic; } });
+Object.defineProperty(exports, "createInvalidManifestDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createInvalidManifestDiagnostic; } });
+Object.defineProperty(exports, "createPackageResolutionDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createPackageResolutionDiagnostic; } });
+Object.defineProperty(exports, "createUnsupportedRangeDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createUnsupportedRangeDiagnostic; } });
+Object.defineProperty(exports, "createUnresolvedPackageDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createUnresolvedPackageDiagnostic; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "ForgePackageResolutionError", { enumerable: true, get: function () { return errors_1.ForgePackageResolutionError; } });
+var manifest_1 = require("./manifest");
+Object.defineProperty(exports, "collectDependencyRequests", { enumerable: true, get: function () { return manifest_1.collectDependencyRequests; } });
+Object.defineProperty(exports, "DEFAULT_FORGE_MANIFEST_PATH", { enumerable: true, get: function () { return manifest_1.DEFAULT_FORGE_MANIFEST_PATH; } });
+Object.defineProperty(exports, "readPackageManifest", { enumerable: true, get: function () { return manifest_1.readPackageManifest; } });
+var resolver_1 = require("./resolver");
+Object.defineProperty(exports, "createPackageCacheKey", { enumerable: true, get: function () { return resolver_1.createPackageCacheKey; } });
+Object.defineProperty(exports, "createPackageResolver", { enumerable: true, get: function () { return resolver_1.createPackageResolver; } });
+Object.defineProperty(exports, "DefaultPackageResolver", { enumerable: true, get: function () { return resolver_1.DefaultPackageResolver; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "PACKAGE_RESOLUTION_CAPABILITY", { enumerable: true, get: function () { return types_1.PACKAGE_RESOLUTION_CAPABILITY; } });

package/dist/package-resolution/manifest.d.ts

@@ -0,0 +1,5 @@
+import type { ForgeVirtualFileSystem } from "../virtual-file-system";
+import type { ForgeDependencyRequest, ForgePackageManifest } from "./types";
+export declare const DEFAULT_FORGE_MANIFEST_PATH = "/package.json";
+export declare function readPackageManifest(fileSystem: ForgeVirtualFileSystem, manifestPath?: string): Promise<ForgePackageManifest>;
+export declare function collectDependencyRequests(manifest: ForgePackageManifest): readonly ForgeDependencyRequest[];

package/dist/package-resolution/manifest.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectDependencyRequests = exports.readPackageManifest = exports.DEFAULT_FORGE_MANIFEST_PATH = void 0;
+const virtual_file_system_1 = require("../virtual-file-system");
+const diagnostics_1 = require("./diagnostics");
+const errors_1 = require("./errors");
+exports.DEFAULT_FORGE_MANIFEST_PATH = "/package.json";
+async function readPackageManifest(fileSystem, manifestPath = exports.DEFAULT_FORGE_MANIFEST_PATH) {
+    let text;
+    try {
+        text = await fileSystem.readText(manifestPath);
+    }
+    catch (error) {
+        if (error instanceof virtual_file_system_1.ForgeFileSystemError) {
+            throw new errors_1.ForgePackageResolutionError(error.diagnostic);
+        }
+        throw error;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (error) {
+        throw new errors_1.ForgePackageResolutionError((0, diagnostics_1.createInvalidManifestDiagnostic)(manifestPath, error));
+    }
+    if (!isPlainObject(parsed)) {
+        throw new errors_1.ForgePackageResolutionError((0, diagnostics_1.createInvalidManifestDiagnostic)(manifestPath));
+    }
+    return {
+        name: optionalString(parsed.name, manifestPath, "name"),
+        version: optionalString(parsed.version, manifestPath, "version"),
+        type: optionalString(parsed.type, manifestPath, "type"),
+        scripts: optionalStringRecord(parsed.scripts, manifestPath, "scripts"),
+        dependencies: optionalStringRecord(parsed.dependencies, manifestPath, "dependencies"),
+        devDependencies: optionalStringRecord(parsed.devDependencies, manifestPath, "devDependencies"),
+        imports: optionalUnknownRecord(parsed.imports),
+    };
+}
+exports.readPackageManifest = readPackageManifest;
+function collectDependencyRequests(manifest) {
+    const requests = new Map();
+    addDependencyRequests(requests, manifest.dependencies, "dependency");
+    addDependencyRequests(requests, manifest.devDependencies, "devDependency");
+    return Array.from(requests.values()).sort((left, right) => compareDependencyRequests(left, right));
+}
+exports.collectDependencyRequests = collectDependencyRequests;
+function addDependencyRequests(requests, dependencies, kind) {
+    const dependencyNames = Object.keys(dependencies).sort((left, right) => left.localeCompare(right));
+    for (const dependencyName of dependencyNames) {
+        const requestedRange = dependencies[dependencyName];
+        assertValidDependency(dependencyName, requestedRange);
+        const existing = requests.get(dependencyName);
+        if (existing !== undefined) {
+            if (existing.requestedRange !== requestedRange) {
+                throw new errors_1.ForgePackageResolutionError((0, diagnostics_1.createInvalidDependencyDiagnostic)(dependencyName, requestedRange, "Dependency is declared with conflicting ranges."));
+            }
+            continue;
+        }
+        requests.set(dependencyName, {
+            name: dependencyName,
+            requestedRange,
+            kind,
+        });
+    }
+}
+function compareDependencyRequests(left, right) {
+    const nameComparison = left.name.localeCompare(right.name);
+    if (nameComparison !== 0) {
+        return nameComparison;
+    }
+    return left.kind.localeCompare(right.kind);
+}
+function assertValidDependency(dependencyName, requestedRange) {
+    if (!isValidPackageName(dependencyName)) {
+        throw new errors_1.ForgePackageResolutionError((0, diagnostics_1.createInvalidDependencyDiagnostic)(dependencyName, requestedRange));
+    }
+    if (typeof requestedRange !== "string" || requestedRange.trim().length === 0) {
+        throw new errors_1.ForgePackageResolutionError((0, diagnostics_1.createInvalidDependencyDiagnostic)(dependencyName, requestedRange, "Dependency range must be a non-empty string."));
+    }
+    if (isUnsupportedRange(requestedRange)) {
+        throw new errors_1.ForgePackageResolutionError((0, diagnostics_1.createUnsupportedRangeDiagnostic)(dependencyName, requestedRange));
+    }
+}
+function optionalString(value, manifestPath, field) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    throw new errors_1.ForgePackageResolutionError((0, diagnostics_1.createInvalidManifestDiagnostic)(manifestPath, `${field} must be a string when present.`));
+}
+function optionalStringRecord(value, manifestPath, field) {
+    if (value === undefined) {
+        return {};
+    }
+    if (!isPlainObject(value)) {
+        throw new errors_1.ForgePackageResolutionError((0, diagnostics_1.createInvalidManifestDiagnostic)(manifestPath, `${field} must be an object when present.`));
+    }
+    const record = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (typeof item !== "string") {
+            throw new errors_1.ForgePackageResolutionError((0, diagnostics_1.createInvalidManifestDiagnostic)(manifestPath, `${field}.${key} must be a string.`));
+        }
+        record[key] = item;
+    }
+    return record;
+}
+function optionalUnknownRecord(value) {
+    return isPlainObject(value) ? { ...value } : {};
+}
+function isPlainObject(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value));
+}
+function isValidPackageName(name) {
+    if (name.length === 0 || name.length > 214 || name !== name.toLowerCase()) {
+        return false;
+    }
+    const packageNameSegment = "[a-z0-9][a-z0-9._~-]*";
+    const unscoped = new RegExp(`^${packageNameSegment}$`);
+    const scoped = new RegExp(`^@${packageNameSegment}/${packageNameSegment}$`);
+    return unscoped.test(name) || scoped.test(name);
+}
+function isUnsupportedRange(range) {
+    return /^(?:file:|link:|workspace:|git(?:\+|:)|https?:)/.test(range);
+}