astro 5.16.0 → 5.16.2

package/astro-jsx.d.ts

@@ -672,6 +672,17 @@ declare namespace astroHTML.JSX {
 		value?: string | string[] | number | undefined | null;
 		popovertarget?: string | undefined | null;
 		popovertargetaction?: 'hide' | 'show' | 'toggle' | undefined | null;
+		command?:
+			| 'show-modal'
+			| 'close'
+			| 'request-close'
+			| 'show-popover'
+			| 'hide-popover'
+			| 'toggle-popover'
+			| (string & {})
+			| undefined
+			| null;
+		commandfor?: string | undefined | null;
 	}
 
 	interface CanvasHTMLAttributes extends HTMLAttributes {

package/dist/assets/fonts/definitions.d.ts

@@ -14,24 +14,6 @@ export interface RemoteFontProviderResolver {
 export interface LocalProviderUrlResolver {
     resolve: (input: string) => string;
 }
-type SingleErrorInput<TType extends string, TData extends Record<string, any>> = {
-    type: TType;
-    data: TData;
-    cause: unknown;
-};
-export type ErrorHandlerInput = SingleErrorInput<'cannot-load-font-provider', {
-    entrypoint: string;
-}> | SingleErrorInput<'unknown-fs-error', {}> | SingleErrorInput<'cannot-fetch-font-file', {
-    url: string;
-}> | SingleErrorInput<'cannot-extract-font-type', {
-    url: string;
-}> | SingleErrorInput<'cannot-extract-data', {
-    family: string;
-    url: string;
-}>;
-export interface ErrorHandler {
-    handle: (input: ErrorHandlerInput) => Error;
-}
 interface ProxyData {
     weight: unifont.FontFaceData['weight'];
     style: unifont.FontFaceData['style'];

package/dist/assets/fonts/infra/build-remote-font-provider-mod-resolver.d.ts

@@ -0,0 +1,2 @@
+import type { RemoteFontProviderModResolver } from '../definitions.js';
+export declare function createBuildRemoteFontProviderModResolver(): RemoteFontProviderModResolver;

package/dist/assets/fonts/infra/build-remote-font-provider-mod-resolver.js

@@ -0,0 +1,10 @@
+function createBuildRemoteFontProviderModResolver() {
+  return {
+    resolve(id) {
+      return import(id);
+    }
+  };
+}
+export {
+  createBuildRemoteFontProviderModResolver
+};

package/dist/assets/fonts/infra/{url-proxy-hash-resolver.d.ts → build-url-proxy-hash-resolver.d.ts}

@@ -3,6 +3,3 @@ export declare function createBuildUrlProxyHashResolver({ hasher, contentResolve
     hasher: Hasher;
     contentResolver: UrlProxyContentResolver;
 }): UrlProxyHashResolver;
-export declare function createDevUrlProxyHashResolver({ baseHashResolver, }: {
-    baseHashResolver: UrlProxyHashResolver;
-}): UrlProxyHashResolver;

package/dist/assets/fonts/infra/build-url-proxy-hash-resolver.js

@@ -0,0 +1,13 @@
+function createBuildUrlProxyHashResolver({
+  hasher,
+  contentResolver
+}) {
+  return {
+    resolve({ originalUrl, type }) {
+      return `${hasher.hashString(contentResolver.resolve(originalUrl))}.${type}`;
+    }
+  };
+}
+export {
+  createBuildUrlProxyHashResolver
+};

package/dist/assets/fonts/infra/{url-resolver.d.ts → build-url-resolver.d.ts}

@@ -1,9 +1,5 @@
 import type { AssetsPrefix } from '../../../types/public/index.js';
 import type { UrlResolver } from '../definitions.js';
-export declare function createDevUrlResolver({ base, searchParams, }: {
-    base: string;
-    searchParams: URLSearchParams;
-}): UrlResolver;
 export declare function createBuildUrlResolver({ base, assetsPrefix, searchParams, }: {
     base: string;
     assetsPrefix: AssetsPrefix;

package/dist/assets/fonts/infra/{url-resolver.js → build-url-resolver.js}

@@ -1,26 +1,6 @@
 import { fileExtension, joinPaths, prependForwardSlash } from "../../../core/path.js";
 import { getAssetsPrefix } from "../../utils/getAssetsPrefix.js";
 import { createPlaceholderURL, stringifyPlaceholderURL } from "../../utils/url.js";
-function createDevUrlResolver({
-  base,
-  searchParams
-}) {
-  let resolved = false;
-  return {
-    resolve(hash) {
-      resolved ||= true;
-      const urlPath = prependForwardSlash(joinPaths(base, hash));
-      const url = createPlaceholderURL(urlPath);
-      searchParams.forEach((value, key) => {
-        url.searchParams.set(key, value);
-      });
-      return stringifyPlaceholderURL(url);
-    },
-    getCspResources() {
-      return resolved ? ["'self'"] : [];
-    }
-  };
-}
 function createBuildUrlResolver({
   base,
   assetsPrefix,
@@ -50,6 +30,5 @@ function createBuildUrlResolver({
   };
 }
 export {
-  createBuildUrlResolver,
-  createDevUrlResolver
+  createBuildUrlResolver
 };

package/dist/assets/fonts/infra/{font-fetcher.d.ts → cached-font-fetcher.d.ts}

@@ -1,8 +1,7 @@
 import type { Storage } from 'unstorage';
-import type { ErrorHandler, FontFetcher } from '../definitions.js';
-export declare function createCachedFontFetcher({ storage, errorHandler, fetch, readFile, }: {
+import type { FontFetcher } from '../definitions.js';
+export declare function createCachedFontFetcher({ storage, fetch, readFile, }: {
     storage: Storage;
-    errorHandler: ErrorHandler;
     fetch: (url: string, init?: RequestInit) => Promise<Response>;
     readFile: (url: string) => Promise<Buffer>;
 }): FontFetcher;

package/dist/assets/fonts/infra/{font-fetcher.js → cached-font-fetcher.js}

@@ -1,8 +1,8 @@
 import { isAbsolute } from "node:path";
+import { AstroError, AstroErrorData } from "../../../core/errors/index.js";
 import { cache } from "../utils.js";
 function createCachedFontFetcher({
   storage,
-  errorHandler,
   fetch,
   readFile
 }) {
@@ -19,11 +19,13 @@ function createCachedFontFetcher({
           }
           return Buffer.from(await response.arrayBuffer());
         } catch (cause) {
-          throw errorHandler.handle({
-            type: "cannot-fetch-font-file",
-            data: { url },
-            cause
-          });
+          throw new AstroError(
+            {
+              ...AstroErrorData.CannotFetchFontFile,
+              message: AstroErrorData.CannotFetchFontFile.message(url)
+            },
+            { cause }
+          );
         }
       });
     }

package/dist/assets/fonts/infra/{remote-font-provider-mod-resolver.d.ts → dev-remote-font-provider-mod-resolver.d.ts}

@@ -1,6 +1,5 @@
 import type { ViteDevServer } from 'vite';
 import type { RemoteFontProviderModResolver } from '../definitions.js';
-export declare function createBuildRemoteFontProviderModResolver(): RemoteFontProviderModResolver;
 export declare function createDevServerRemoteFontProviderModResolver({ server, }: {
     server: ViteDevServer;
 }): RemoteFontProviderModResolver;

package/dist/assets/fonts/infra/{remote-font-provider-mod-resolver.js → dev-remote-font-provider-mod-resolver.js}

@@ -1,10 +1,3 @@
-function createBuildRemoteFontProviderModResolver() {
-  return {
-    resolve(id) {
-      return import(id);
-    }
-  };
-}
 function createDevServerRemoteFontProviderModResolver({
   server
 }) {
@@ -15,6 +8,5 @@ function createDevServerRemoteFontProviderModResolver({
   };
 }
 export {
-  createBuildRemoteFontProviderModResolver,
   createDevServerRemoteFontProviderModResolver
 };

package/dist/assets/fonts/infra/dev-url-proxy-hash-resolver.d.ts

@@ -0,0 +1,5 @@
+import type { Hasher, UrlProxyContentResolver, UrlProxyHashResolver } from '../definitions.js';
+export declare function createDevUrlProxyHashResolver({ hasher, contentResolver, }: {
+    hasher: Hasher;
+    contentResolver: UrlProxyContentResolver;
+}): UrlProxyHashResolver;

package/dist/assets/fonts/infra/{url-proxy-hash-resolver.js → dev-url-proxy-hash-resolver.js}

@@ -1,25 +1,15 @@
-function createBuildUrlProxyHashResolver({
+function createDevUrlProxyHashResolver({
   hasher,
   contentResolver
 }) {
   return {
-    resolve({ originalUrl, type }) {
-      return `${hasher.hashString(contentResolver.resolve(originalUrl))}.${type}`;
-    }
-  };
-}
-function createDevUrlProxyHashResolver({
-  baseHashResolver
-}) {
-  return {
-    resolve(input) {
-      const { cssVariable, data } = input;
+    resolve({ cssVariable, data, originalUrl, type }) {
       return [
         cssVariable.slice(2),
         formatWeight(data.weight),
         data.style,
         data.subset,
-        baseHashResolver.resolve(input)
+        `${hasher.hashString(contentResolver.resolve(originalUrl))}.${type}`
       ].filter(Boolean).join("-");
     }
   };
@@ -34,6 +24,5 @@ function formatWeight(weight) {
   return weight?.replace(/\s+/g, "-");
 }
 export {
-  createBuildUrlProxyHashResolver,
   createDevUrlProxyHashResolver
 };

package/dist/assets/fonts/infra/dev-url-resolver.d.ts

@@ -0,0 +1,5 @@
+import type { UrlResolver } from '../definitions.js';
+export declare function createDevUrlResolver({ base, searchParams, }: {
+    base: string;
+    searchParams: URLSearchParams;
+}): UrlResolver;

package/dist/assets/fonts/infra/dev-url-resolver.js

@@ -0,0 +1,25 @@
+import { joinPaths, prependForwardSlash } from "../../../core/path.js";
+import { createPlaceholderURL, stringifyPlaceholderURL } from "../../utils/url.js";
+function createDevUrlResolver({
+  base,
+  searchParams
+}) {
+  let resolved = false;
+  return {
+    resolve(hash) {
+      resolved ||= true;
+      const urlPath = prependForwardSlash(joinPaths(base, hash));
+      const url = createPlaceholderURL(urlPath);
+      searchParams.forEach((value, key) => {
+        url.searchParams.set(key, value);
+      });
+      return stringifyPlaceholderURL(url);
+    },
+    getCspResources() {
+      return resolved ? ["'self'"] : [];
+    }
+  };
+}
+export {
+  createDevUrlResolver
+};

package/dist/assets/fonts/infra/font-type-extractor.d.ts

@@ -1,4 +1,2 @@
-import type { ErrorHandler, FontTypeExtractor } from '../definitions.js';
-export declare function createFontTypeExtractor({ errorHandler, }: {
-    errorHandler: ErrorHandler;
-}): FontTypeExtractor;
+import type { FontTypeExtractor } from '../definitions.js';
+export declare function createFontTypeExtractor(): FontTypeExtractor;

package/dist/assets/fonts/infra/font-type-extractor.js

@@ -1,17 +1,18 @@
 import { extname } from "node:path";
+import { AstroError, AstroErrorData } from "../../../core/errors/index.js";
 import { isFontType } from "../utils.js";
-function createFontTypeExtractor({
-  errorHandler
-}) {
+function createFontTypeExtractor() {
   return {
     extract(url) {
       const extension = extname(url).slice(1);
       if (!isFontType(extension)) {
-        throw errorHandler.handle({
-          type: "cannot-extract-font-type",
-          data: { url },
-          cause: `Unexpected extension, got "${extension}"`
-        });
+        throw new AstroError(
+          {
+            ...AstroErrorData.CannotExtractFontType,
+            message: AstroErrorData.CannotExtractFontType.message(url)
+          },
+          { cause: `Unexpected extension, got "${extension}"` }
+        );
       }
       return extension;
     }

package/dist/assets/fonts/infra/fontace-font-file-reader.d.ts

@@ -0,0 +1,2 @@
+import type { FontFileReader } from '../definitions.js';
+export declare function createFontaceFontFileReader(): FontFileReader;

package/dist/assets/fonts/infra/fontace-font-file-reader.js

@@ -0,0 +1,27 @@
+import { readFileSync } from "node:fs";
+import { fontace } from "fontace";
+import { AstroError, AstroErrorData } from "../../../core/errors/index.js";
+function createFontaceFontFileReader() {
+  return {
+    extract({ family, url }) {
+      try {
+        const data = fontace(readFileSync(url));
+        return {
+          weight: data.weight,
+          style: data.style
+        };
+      } catch (cause) {
+        throw new AstroError(
+          {
+            ...AstroErrorData.CannotDetermineWeightAndStyleFromFontFile,
+            message: AstroErrorData.CannotDetermineWeightAndStyleFromFontFile.message(family, url)
+          },
+          { cause }
+        );
+      }
+    }
+  };
+}
+export {
+  createFontaceFontFileReader
+};

package/dist/assets/fonts/infra/remote-font-provider-resolver.d.ts

@@ -1,6 +1,5 @@
-import type { ErrorHandler, RemoteFontProviderModResolver, RemoteFontProviderResolver } from '../definitions.js';
-export declare function createRemoteFontProviderResolver({ root, modResolver, errorHandler, }: {
+import type { RemoteFontProviderModResolver, RemoteFontProviderResolver } from '../definitions.js';
+export declare function createRemoteFontProviderResolver({ root, modResolver, }: {
     root: URL;
     modResolver: RemoteFontProviderModResolver;
-    errorHandler: ErrorHandler;
 }): RemoteFontProviderResolver;

package/dist/assets/fonts/infra/remote-font-provider-resolver.js

@@ -1,8 +1,8 @@
+import { AstroError, AstroErrorData } from "../../../core/errors/index.js";
 import { resolveEntrypoint } from "../utils.js";
 function validateMod({
   mod,
-  entrypoint,
-  errorHandler
+  entrypoint
 }) {
   try {
     if (typeof mod !== "object" || mod === null) {
@@ -15,19 +15,18 @@ function validateMod({
       provider: mod.provider
     };
   } catch (cause) {
-    throw errorHandler.handle({
-      type: "cannot-load-font-provider",
-      data: {
-        entrypoint
+    throw new AstroError(
+      {
+        ...AstroErrorData.CannotLoadFontProvider,
+        message: AstroErrorData.CannotLoadFontProvider.message(entrypoint)
       },
-      cause
-    });
+      { cause }
+    );
   }
 }
 function createRemoteFontProviderResolver({
   root,
-  modResolver,
-  errorHandler
+  modResolver
 }) {
   return {
     async resolve({ entrypoint, config }) {
@@ -35,8 +34,7 @@ function createRemoteFontProviderResolver({
       const mod = await modResolver.resolve(id);
       const { provider } = validateMod({
         mod,
-        entrypoint: id,
-        errorHandler
+        entrypoint: id
       });
       return { config, provider };
     }

package/dist/assets/fonts/infra/url-proxy-content-resolver.d.ts

@@ -1,5 +1,3 @@
-import type { ErrorHandler, UrlProxyContentResolver } from '../definitions.js';
-export declare function createLocalUrlProxyContentResolver({ errorHandler, }: {
-    errorHandler: ErrorHandler;
-}): UrlProxyContentResolver;
+import type { UrlProxyContentResolver } from '../definitions.js';
+export declare function createLocalUrlProxyContentResolver(): UrlProxyContentResolver;
 export declare function createRemoteUrlProxyContentResolver(): UrlProxyContentResolver;

package/dist/assets/fonts/infra/url-proxy-content-resolver.js

@@ -1,17 +1,12 @@
 import { readFileSync } from "node:fs";
-function createLocalUrlProxyContentResolver({
-  errorHandler
-}) {
+import { AstroError, AstroErrorData } from "../../../core/errors/index.js";
+function createLocalUrlProxyContentResolver() {
   return {
     resolve(url) {
       try {
         return url + readFileSync(url, "utf-8");
       } catch (cause) {
-        throw errorHandler.handle({
-          type: "unknown-fs-error",
-          data: {},
-          cause
-        });
+        throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause });
       }
     }
   };

package/dist/assets/fonts/infra/xxhash-hasher.d.ts

@@ -0,0 +1,2 @@
+import type { Hasher } from '../definitions.js';
+export declare function createXxhashHasher(): Promise<Hasher>;

package/dist/assets/fonts/infra/{hasher.js → xxhash-hasher.js}

@@ -1,6 +1,6 @@
 import xxhash from "xxhash-wasm";
 import { sortObjectByKey } from "../utils.js";
-async function createXxHasher() {
+async function createXxhashHasher() {
   const { h64ToString: hashString } = await xxhash();
   return {
     hashString,
@@ -10,5 +10,5 @@ async function createXxHasher() {
   };
 }
 export {
-  createXxHasher
+  createXxhashHasher
 };

package/dist/assets/fonts/vite-plugin-fonts.js

@@ -17,36 +17,32 @@ import {
   RESOLVED_VIRTUAL_MODULE_ID,
   VIRTUAL_MODULE_ID
 } from "./constants.js";
-import { createMinifiableCssRenderer } from "./infra/css-renderer.js";
+import { createBuildRemoteFontProviderModResolver } from "./infra/build-remote-font-provider-mod-resolver.js";
+import { createBuildUrlProxyHashResolver } from "./infra/build-url-proxy-hash-resolver.js";
+import { createBuildUrlResolver } from "./infra/build-url-resolver.js";
+import { createCachedFontFetcher } from "./infra/cached-font-fetcher.js";
+import { createCapsizeFontMetricsResolver } from "./infra/capsize-font-metrics-resolver.js";
 import { createDataCollector } from "./infra/data-collector.js";
-import { createAstroErrorHandler } from "./infra/error-handler.js";
-import { createCachedFontFetcher } from "./infra/font-fetcher.js";
-import { createFontaceFontFileReader } from "./infra/font-file-reader.js";
-import { createCapsizeFontMetricsResolver } from "./infra/font-metrics-resolver.js";
+import { createDevServerRemoteFontProviderModResolver } from "./infra/dev-remote-font-provider-mod-resolver.js";
+import { createDevUrlProxyHashResolver } from "./infra/dev-url-proxy-hash-resolver.js";
+import { createDevUrlResolver } from "./infra/dev-url-resolver.js";
 import { createFontTypeExtractor } from "./infra/font-type-extractor.js";
-import { createXxHasher } from "./infra/hasher.js";
+import { createFontaceFontFileReader } from "./infra/fontace-font-file-reader.js";
+import { createFsStorage } from "./infra/fs-storage.js";
 import { createLevenshteinStringMatcher } from "./infra/levenshtein-string-matcher.js";
-import { createRequireLocalProviderUrlResolver } from "./infra/local-provider-url-resolver.js";
-import {
-  createBuildRemoteFontProviderModResolver,
-  createDevServerRemoteFontProviderModResolver
-} from "./infra/remote-font-provider-mod-resolver.js";
+import { createMinifiableCssRenderer } from "./infra/minifiable-css-renderer.js";
 import { createRemoteFontProviderResolver } from "./infra/remote-font-provider-resolver.js";
-import { createFsStorage } from "./infra/storage.js";
+import { createRequireLocalProviderUrlResolver } from "./infra/require-local-provider-url-resolver.js";
 import { createSystemFallbacksProvider } from "./infra/system-fallbacks-provider.js";
 import { createUrlProxy } from "./infra/url-proxy.js";
 import {
   createLocalUrlProxyContentResolver,
   createRemoteUrlProxyContentResolver
 } from "./infra/url-proxy-content-resolver.js";
-import {
-  createBuildUrlProxyHashResolver,
-  createDevUrlProxyHashResolver
-} from "./infra/url-proxy-hash-resolver.js";
-import { createBuildUrlResolver, createDevUrlResolver } from "./infra/url-resolver.js";
+import { createXxhashHasher } from "./infra/xxhash-hasher.js";
 import { orchestrate } from "./orchestrate.js";
 function fontsPlugin({ settings, sync, logger }) {
-  if (sync || !settings.config.experimental.fonts) {
+  if (!settings.config.experimental.fonts) {
     return {
       name: "astro:fonts:fallback",
       resolveId(id) {
@@ -87,12 +83,10 @@ function fontsPlugin({ settings, sync, logger }) {
     createHashResolver
   }) {
     const { root } = settings.config;
-    const hasher = await createXxHasher();
-    const errorHandler = createAstroErrorHandler();
+    const hasher = await createXxhashHasher();
     const remoteFontProviderResolver = createRemoteFontProviderResolver({
       root,
-      modResolver,
-      errorHandler
+      modResolver
     });
     const pathsToWarn = /* @__PURE__ */ new Set();
     const localProviderUrlResolver = createRequireLocalProviderUrlResolver({
@@ -112,10 +106,10 @@ function fontsPlugin({ settings, sync, logger }) {
     });
     const storage = createFsStorage({ base: cacheDir });
     const systemFallbacksProvider = createSystemFallbacksProvider();
-    fontFetcher = createCachedFontFetcher({ storage, errorHandler, fetch, readFile });
+    fontFetcher = createCachedFontFetcher({ storage, fetch, readFile });
     const fontMetricsResolver = createCapsizeFontMetricsResolver({ fontFetcher, cssRenderer });
-    fontTypeExtractor = createFontTypeExtractor({ errorHandler });
-    const fontFileReader = createFontaceFontFileReader({ errorHandler });
+    fontTypeExtractor = createFontTypeExtractor();
+    const fontFileReader = createFontaceFontFileReader();
     const stringMatcher = createLevenshteinStringMatcher();
     const res = await orchestrate({
       families: settings.config.experimental.fonts,
@@ -131,7 +125,7 @@ function fontsPlugin({ settings, sync, logger }) {
       logger,
       createUrlProxy: ({ local, cssVariable, ...params }) => {
         const dataCollector = createDataCollector(params);
-        const contentResolver = local ? createLocalUrlProxyContentResolver({ errorHandler }) : createRemoteUrlProxyContentResolver();
+        const contentResolver = local ? createLocalUrlProxyContentResolver() : createRemoteUrlProxyContentResolver();
         return createUrlProxy({
           urlResolver,
           hashResolver: createHashResolver({ hasher, contentResolver }),
@@ -173,7 +167,7 @@ function fontsPlugin({ settings, sync, logger }) {
             assetsPrefix: settings.config.build.assetsPrefix,
             searchParams: settings.adapter?.client?.assetQueryParams ?? new URLSearchParams()
           }),
-          createHashResolver: (dependencies) => createBuildUrlProxyHashResolver(dependencies)
+          createHashResolver: createBuildUrlProxyHashResolver
         });
       }
     },
@@ -187,9 +181,7 @@ function fontsPlugin({ settings, sync, logger }) {
           base: baseUrl,
           searchParams: settings.adapter?.client?.assetQueryParams ?? new URLSearchParams()
         }),
-        createHashResolver: (dependencies) => createDevUrlProxyHashResolver({
-          baseHashResolver: createBuildUrlProxyHashResolver(dependencies)
-        })
+        createHashResolver: createDevUrlProxyHashResolver
       });
       const localPaths = [...fontFileDataMap.values()].filter(({ url }) => isAbsolute(url)).map((v) => v.url);
       server.watcher.on("change", (path) => {
@@ -252,7 +244,7 @@ function fontsPlugin({ settings, sync, logger }) {
       }
     },
     async buildEnd() {
-      if (settings.config.experimental.fonts.length === 0) {
+      if (sync || settings.config.experimental.fonts.length === 0) {
         cleanup();
         return;
       }

package/dist/assets/utils/remotePattern.d.ts

@@ -1,3 +1 @@
-import { isRemoteAllowed, matchHostname, matchPathname, matchPattern, matchPort, matchProtocol, type RemotePattern } from '@astrojs/internal-helpers/remote';
-export { isRemoteAllowed, matchHostname, matchPort, matchPathname, matchProtocol, matchPattern };
-export type { RemotePattern };
+export { isRemoteAllowed, matchHostname, matchPathname, matchPattern, matchPort, matchProtocol, type RemotePattern, } from '@astrojs/internal-helpers/remote';

package/dist/cli/create-key/infra/crypto-key-generator.d.ts

@@ -1,2 +1,4 @@
 import type { KeyGenerator } from '../definitions.js';
-export declare function createCryptoKeyGenerator(): KeyGenerator;
+export declare class CryptoKeyGenerator implements KeyGenerator {
+    generate(): Promise<string>;
+}

package/dist/cli/create-key/infra/crypto-key-generator.js

@@ -1,13 +1,11 @@
 import { createKey, encodeKey } from "../../../core/encryption.js";
-function createCryptoKeyGenerator() {
-  return {
-    async generate() {
-      const key = await createKey();
-      const encoded = await encodeKey(key);
-      return encoded;
-    }
-  };
+class CryptoKeyGenerator {
+  async generate() {
+    const key = await createKey();
+    const encoded = await encodeKey(key);
+    return encoded;
+  }
 }
 export {
-  createCryptoKeyGenerator
+  CryptoKeyGenerator
 };

package/dist/cli/definitions.d.ts

@@ -17,16 +17,17 @@ export interface AstroVersionProvider {
     readonly version: string;
 }
 export interface CommandRunner {
-    run: <T extends AnyCommand>(command: T, ...args: Parameters<T['run']>) => ReturnType<T['run']>;
+    run: <T extends AnyCommand>(command: T, ...args: Parameters<T['run']>) => ReturnType<T['run']> | undefined;
+}
+export interface CommandExecutorOptions {
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    shell?: boolean;
+    input?: string;
+    stdio?: StdioOptions;
 }
 export interface CommandExecutor {
-    execute: (command: string, args?: Array<string>, options?: {
-        cwd?: string;
-        env?: Record<string, string | undefined>;
-        shell?: boolean;
-        input?: string;
-        stdio?: StdioOptions;
-    }) => Promise<{
+    execute: (command: string, args?: Array<string>, options?: CommandExecutorOptions) => Promise<{
         stdout: string;
     }>;
 }

package/dist/cli/docs/infra/process-cloud-ide-provider.d.ts

@@ -1,2 +1,5 @@
 import type { CloudIdeProvider } from '../definitions.js';
-export declare function createProcessCloudIdeProvider(): CloudIdeProvider;
+import type { CloudIde } from '../domain/cloud-ide.js';
+export declare class ProcessCloudIdeProvider implements CloudIdeProvider {
+    readonly name: CloudIde | null;
+}

package/dist/cli/docs/infra/process-cloud-ide-provider.js

@@ -1,10 +1,6 @@
-function createProcessCloudIdeProvider() {
-  return {
-    get name() {
-      return Boolean(process.env.GITPOD_REPO_ROOT) ? "gitpod" : null;
-    }
-  };
+class ProcessCloudIdeProvider {
+  name = Boolean(process.env.GITPOD_REPO_ROOT) ? "gitpod" : null;
 }
 export {
-  createProcessCloudIdeProvider
+  ProcessCloudIdeProvider
 };