@wular/pnext 0.0.3 → 0.0.6

package/src/cli/analyze-print.ts

@@ -1,181 +0,0 @@
-import { bold, cyan, dim } from '../utils/ansi';
-import type { analyzeProject } from './analyze';
-
-type AnalyzeResult = Awaited<ReturnType<typeof analyzeProject>>;
-type Compression = AnalyzeResult['compression'];
-
-export function printAnalyzeResult(
-  result: AnalyzeResult,
-  options: { route?: string; files: boolean },
-) {
-  console.log(
-    `PNext analyze: ${result.mode === 'production' ? 'production build' : 'dev server cache'} at ${dim(result.root)} (${result.compression})`,
-  );
-  printRouteBundles(result);
-  // With a route filter, the remaining files are mostly other routes' bundles —
-  // listing them as "other" would misread as unowned weight.
-  if (!options.route) printAnalyzeFiles(result, { details: options.files });
-}
-
-function printRouteBundles(result: AnalyzeResult) {
-  if (result.routeBundles.length === 0) return;
-
-  console.log(`\n${bold('Routes')}`);
-  for (const bundle of result.routeBundles) {
-    console.log(`\n${cyan(bundle.route)} ${dim(`(${bundle.page} page)`)}`);
-    printBundleGroup('initial', bundle.initial, result.compression);
-    printDynamicBundleGroup('visible dynamic', bundle.visibleDynamic, result.compression);
-    printDynamicBundleGroup('dynamic', bundle.dynamic, result.compression);
-    printBundleGroup('shared after dynamic', bundle.lazyShared, result.compression);
-  }
-  console.log('');
-}
-
-function printBundleGroup(
-  label: string,
-  files: AnalyzeResult['routeBundles'][number]['initial'],
-  compression: Compression,
-) {
-  if (files.length === 0) return;
-  console.log(`\n  ${bold(label.padEnd(22))} ${formatTotalSize(files, compression)}`);
-  printBundleFiles(files, compression, '    ', rowColumns(files));
-}
-
-function printDynamicBundleGroup(
-  label: string,
-  files: AnalyzeResult['routeBundles'][number]['visibleDynamic'],
-  compression: Compression,
-) {
-  if (files.length === 0) return;
-  console.log(`\n  ${bold(label)}`);
-  const columns = rowColumns(files);
-  const componentWidth = Math.max(...files.map(file => file.exportName.length));
-  const pathWidth = Math.max(...files.map(file => file.path.length));
-  for (const file of files) {
-    console.log(
-      `    ${file.exportName.padEnd(componentWidth)}  ${dim(file.path.padEnd(pathWidth))}  ${formatFileSize(file, compression, columns)}`,
-    );
-  }
-}
-
-function formatTotalSize(
-  files: { rawBytes: number; compressedBytes: number }[],
-  compression: Compression,
-) {
-  const rawBytes = files.reduce((total, file) => total + file.rawBytes, 0);
-  const compressedBytes = files.reduce((total, file) => total + file.compressedBytes, 0);
-  return `${formatBytes(compressedBytes)} ${compression}  ${dim(`${formatBytes(rawBytes)} raw`)}`;
-}
-
-function printAnalyzeFiles(result: AnalyzeResult, options: { details: boolean }) {
-  const routeFiles = new Set(
-    result.routeBundles.flatMap(bundle => [
-      ...bundle.initial.map(file => file.path),
-      ...bundle.visibleDynamic.map(file => file.path),
-      ...bundle.dynamic.map(file => file.path),
-      ...bundle.lazyShared.map(file => file.path),
-    ]),
-  );
-  const sorted = sortedAnalyzeFiles(result.files).filter(file => !routeFiles.has(file.path));
-  if (sorted.length === 0) return;
-
-  if (!options.details) {
-    console.log(
-      `Other files: ${formatFileCount(sorted)}  ${formatTotalSize(sorted, result.compression)}`,
-    );
-    console.log('Run pnext analyze --files to list them.');
-    return;
-  }
-
-  console.log(`${bold('Other files')}\n`);
-  for (const type of ['html', 'css', 'js', 'asset'] as const) {
-    const files = sorted.filter(file => file.type === type);
-    if (files.length === 0) continue;
-    console.log(bold(type));
-    printBundleFiles(files, result.compression, '  ', rowColumns(files));
-    console.log('');
-  }
-}
-
-function printBundleFiles(
-  files: { path: string; rawBytes: number; compressedBytes: number }[],
-  compression: Compression,
-  indent: string,
-  columns: RowColumns,
-) {
-  const pathWidth = Math.max(...files.map(file => file.path.length));
-  for (const file of files) {
-    console.log(
-      `${indent}${dim(file.path.padEnd(pathWidth))}  ${formatFileSize(file, compression, columns)}`,
-    );
-  }
-}
-
-interface RowColumns {
-  compressedWidth: number;
-  rawWidth: number;
-}
-
-function rowColumns(files: { rawBytes: number; compressedBytes: number }[]): RowColumns {
-  return {
-    compressedWidth: Math.max(...files.map(file => formatBytes(file.compressedBytes).length)),
-    rawWidth: Math.max(...files.map(file => formatBytes(file.rawBytes).length)),
-  };
-}
-
-function formatFileSize(
-  file: { rawBytes: number; compressedBytes: number },
-  compression: Compression,
-  columns: RowColumns,
-) {
-  const compressed = formatBytes(file.compressedBytes).padStart(columns.compressedWidth);
-  const raw = `${formatBytes(file.rawBytes).padStart(columns.rawWidth)} raw`;
-  return `${compressed} ${compression}  ${dim(raw)}`;
-}
-
-function formatFileCount(files: AnalyzeResult['files']) {
-  const counts = new Map<string, number>();
-  for (const file of files) counts.set(file.type, (counts.get(file.type) ?? 0) + 1);
-  return [...counts].map(([type, count]) => `${count} ${pluralFileType(type, count)}`).join(', ');
-}
-
-function pluralFileType(type: string, count: number) {
-  if (count === 1) return type;
-  if (type === 'js' || type === 'css' || type === 'html') return type;
-  return `${type}s`;
-}
-
-function sortedAnalyzeFiles(files: AnalyzeResult['files']) {
-  return [...files].sort((a, b) => {
-    const typeDelta = analyzeTypeRank(a.type) - analyzeTypeRank(b.type);
-    if (typeDelta) return typeDelta;
-    const sizeDelta = b.compressedBytes - a.compressedBytes;
-    if (sizeDelta) return sizeDelta;
-    return a.path.localeCompare(b.path);
-  });
-}
-
-function analyzeTypeRank(type: AnalyzeResult['files'][number]['type']) {
-  switch (type) {
-    case 'html':
-      return 0;
-    case 'css':
-      return 1;
-    case 'js':
-      return 2;
-    case 'asset':
-      return 3;
-  }
-}
-
-function formatBytes(bytes: number) {
-  if (bytes < 1024) return `${bytes} B`;
-  const units = ['KB', 'MB', 'GB', 'TB'] as const;
-  let value = bytes / 1024;
-  let unitIndex = 0;
-  while (value >= 1024 && unitIndex < units.length - 1) {
-    value /= 1024;
-    unitIndex += 1;
-  }
-  return `${value >= 10 ? value.toFixed(1) : value.toFixed(2)} ${units[unitIndex]}`;
-}

package/src/compat/middleware/manifest.ts

@@ -1,210 +0,0 @@
-// Middleware manifest emission (COMPAT - may import core freely).
-//
-// Writes the two Next-shaped manifests a few suites read directly from the build output:
-//   - `<out>/server/middleware-manifest.json`: the edge-middleware entry with its compiled matchers,
-//     entrypoint and files list.
-//   - `<out>/server/functions-config-manifest.json`: the node-runtime variant, when the middleware opts
-//     into `runtime: 'nodejs'`.
-//
-// Only the fields the tests read are populated. A pure-core app writes neither.
-
-import path from 'node:path';
-import { mkdir, writeFile } from 'node:fs/promises';
-import { findProxyFile, type ProxyConfig, type ProxyModule } from '../../proxy';
-import { pathToFileHref, type ResolvedConfig } from '../../config';
-import { toPosixPath } from '../../utils/fs';
-import type { RouteManifestEntry } from '../../types';
-import { readMiddlewareWasmBindingsForOutPath } from '../bundler/wasm';
-import { preferredRegionForRoute } from '../next/preferred-region';
-
-interface ManifestMatcher {
-  regexp: string;
-  originalSource: string;
-}
-
-interface MiddlewareEntry {
-  name: string;
-  page: string;
-  matchers: ManifestMatcher[];
-  wasm: { name: string; filePath: string }[];
-  assets: never[];
-  files: string[];
-  entrypoint: string;
-  env: Record<string, string>;
-}
-
-interface MiddlewareManifest {
-  version: number;
-  sortedMiddleware: string[];
-  middleware: Record<string, MiddlewareEntry>;
-  functions: Record<string, unknown>;
-}
-
-interface FunctionsConfigManifest {
-  version: number;
-  functions: Record<string, { runtime: string; matchers: ManifestMatcher[] }>;
-}
-
-/**
- * Emit the middleware manifests for the resolved proxy file, if any. `entryFile`
- * is the compiled proxy module path (relative to `outPath`, posix) produced by
- * the build; it is recorded as the manifest `entrypoint` under `server/`.
- */
-export async function writeMiddlewareManifests(
-  config: ResolvedConfig,
-  entryFile: string | undefined,
-  routes: RouteManifestEntry[] = [],
-): Promise<void> {
-  const source = findProxyFile(config);
-  // Edge-runtime app segments are manifest `functions` entries alongside the
-  // middleware, keyed by their app path (route groups included) — an app with
-  // an edge page and no middleware still writes the manifest for them.
-  const functions = edgeFunctionEntries(config, routes);
-  if (!source || !entryFile) {
-    if (Object.keys(functions).length === 0) return;
-    const serverDir = path.join(config.outPath, 'server');
-    await mkdir(serverDir, { recursive: true });
-    await writeFile(
-      path.join(serverDir, 'middleware-manifest.json'),
-      `${JSON.stringify({ ...emptyMiddlewareManifest(), functions }, null, 2)}\n`,
-    );
-    return;
-  }
-
-  const moduleFile = path.resolve(config.outPath, entryFile);
-  const module = (await import(pathToFileHref(moduleFile))) as ProxyModule;
-  const matchers = manifestMatchers(module.config);
-  const runtime = proxyRuntime(module.config);
-  const entrypoint = toServerEntrypoint(entryFile);
-
-  const serverDir = path.join(config.outPath, 'server');
-  await mkdir(serverDir, { recursive: true });
-
-  if (runtime === 'nodejs') {
-    const functionsConfig: FunctionsConfigManifest = {
-      version: 1,
-      functions: { '/_middleware': { runtime: 'nodejs', matchers } },
-    };
-    await writeFile(
-      path.join(serverDir, 'functions-config-manifest.json'),
-      `${JSON.stringify(functionsConfig, null, 2)}\n`,
-    );
-    // A node-runtime middleware still lists an empty edge middleware manifest so
-    // consumers that always read it find a valid (empty) shape.
-    await writeFile(
-      path.join(serverDir, 'middleware-manifest.json'),
-      `${JSON.stringify({ ...emptyMiddlewareManifest(), functions }, null, 2)}\n`,
-    );
-    return;
-  }
-
-  const entry: MiddlewareEntry = {
-    name: 'middleware',
-    page: '/',
-    matchers,
-    wasm: readMiddlewareWasmBindingsForOutPath(config.outPath),
-    assets: [],
-    files: [entrypoint],
-    entrypoint,
-    env: {},
-  };
-  const manifest: MiddlewareManifest = {
-    version: 3,
-    sortedMiddleware: ['/'],
-    middleware: { '/': entry },
-    functions,
-  };
-  await writeFile(
-    path.join(serverDir, 'middleware-manifest.json'),
-    `${JSON.stringify(manifest, null, 2)}\n`,
-  );
-}
-
-function emptyMiddlewareManifest(): MiddlewareManifest {
-  return { version: 3, sortedMiddleware: [], middleware: {}, functions: {} };
-}
-
-/**
- * Manifest `functions` entries for app segments that declared
- * `export const runtime = 'edge'`. Next keys them by the segment's app path
- * (route groups kept, e.g. `/(group)/group/page`) and records the URL the
- * segment answers as its matcher.
- */
-function edgeFunctionEntries(
-  config: ResolvedConfig,
-  routes: RouteManifestEntry[],
-): Record<string, unknown> {
-  const entries: Record<string, unknown> = {};
-  if (!config.appPath) return entries;
-  for (const route of routes) {
-    const runtime = route.segmentConfig?.runtime;
-    if (runtime !== 'edge' && runtime !== 'experimental-edge') continue;
-    const page = appManifestKey(config.appPath, route.file);
-    if (!page) continue;
-    const regions = preferredRegionForRoute(route);
-    entries[page] = {
-      files: [],
-      name: `app${page}`,
-      page,
-      matchers: [{ regexp: `^${routeMatcherRegexp(route.route)}$`, originalSource: route.route }],
-      wasm: [],
-      assets: [],
-      env: {},
-      ...(regions ? { regions } : {}),
-    };
-  }
-  return entries;
-}
-
-// `<app>/(group)/group/page.tsx` → `/(group)/group/page`.
-function appManifestKey(appPath: string, file: string): string | undefined {
-  const relative = toPosixPath(path.relative(appPath, file));
-  if (!relative || relative.startsWith('..')) return undefined;
-  return `/${relative.replace(/\.[^./]+$/, '')}`;
-}
-
-// The URL regexp Next records for a segment: literal path with each dynamic
-// segment widened to a single path part.
-function routeMatcherRegexp(route: string): string {
-  return route.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/:([^/\\]+)/g, '[^/]+');
-}
-
-// Compile config.matcher entries into { regexp, originalSource } pairs. With no
-// matcher, the middleware runs on every path: Next records the `/:path*` source
-// and its `^/.*$` regexp.
-function manifestMatchers(config: ProxyConfig | undefined): ManifestMatcher[] {
-  const matcher = config?.matcher;
-  if (!matcher) return [{ regexp: '^/.*$', originalSource: '/:path*' }];
-  const list = Array.isArray(matcher) ? matcher : [matcher];
-  return list.map(item => {
-    const originalSource = typeof item === 'string' ? item : item.source;
-    return { regexp: `^${matcherRegexp(originalSource)}$`, originalSource };
-  });
-}
-
-// Mirror src/proxy.ts matcherPattern for the manifest regexp string (kept in
-// sync with the runtime matcher). Raw regex sources pass through unchanged.
-function matcherRegexp(matcher: string): string {
-  if (matcher.includes('(')) return matcher;
-  if (matcher === '/') return '/';
-  let source = '';
-  for (const segment of matcher.split('/').filter(Boolean)) {
-    if (/^:[^/]+\*$/.test(segment)) source += '(?:/.*)?';
-    else if (/^:[^/]+$/.test(segment)) source += '/[^/]+';
-    else source += `/${segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`;
-  }
-  return source || '/';
-}
-
-function proxyRuntime(config: ProxyConfig | undefined): 'edge' | 'nodejs' {
-  const runtime = (config as { runtime?: unknown } | undefined)?.runtime;
-  return runtime === 'nodejs' ? 'nodejs' : 'edge';
-}
-
-// Record the compiled entry under the `server/` prefix Next uses, forcing a
-// `.js` extension (the manifest tests assert `^server/.+\.(js|mjs|cjs)$`).
-function toServerEntrypoint(entryFile: string): string {
-  const posix = toPosixPath(entryFile).replace(/^\.?\//, '');
-  const withinServer = posix.startsWith('server/') ? posix : `server/${path.posix.basename(posix)}`;
-  return withinServer.replace(/\.[^./]+$/, '.js');
-}

package/src/compat/next/image-client.tsx

@@ -1,215 +0,0 @@
-'use client';
-
-import {
-  forwardRef,
-  useCallback,
-  useEffect,
-  useLayoutEffect,
-  useRef,
-  useState,
-} from 'preact/compat';
-import type { Ref } from 'preact/compat';
-import type { JSX } from 'preact';
-import { getImagesConfig, resolveImageProps } from './image-props';
-import type { ImageProps, ResolvedImagesConfig } from './image-props';
-
-const useSettleEffect = (!process.browser && typeof window === 'undefined') ? useEffect : useLayoutEffect;
-
-// The initial hydration pass, before the entry flips __NEXT_HYDRATED (a
-// microtask after the island mounts). Layout effects run inside it, so an image
-// seen here came from the server document — one rendered by a later client
-// update (a click) did not.
-function hydrating(): boolean {
-  return (
-    (process.browser || typeof window !== 'undefined') &&
-    !(window as { __NEXT_HYDRATED?: boolean }).__NEXT_HYDRATED
-  );
-}
-
-type OnLoad = NonNullable<ImageProps['onLoad']>;
-type OnLoadingComplete = NonNullable<ImageProps['onLoadingComplete']>;
-type ImageClientProps = ImageProps & { __pnextConfig?: ResolvedImagesConfig };
-
-function handleLoading(
-  img: HTMLImageElement | null,
-  placeholder: string,
-  onLoadRef: { current: OnLoad | undefined },
-  onLoadingCompleteRef: { current: OnLoadingComplete | undefined },
-  setBlurComplete: (b: boolean) => void,
-): void {
-  if (!img) return;
-  const src = img.src;
-  const marker = img as HTMLImageElement & { 'data-loaded-src'?: string };
-  if (marker['data-loaded-src'] === src) return;
-  marker['data-loaded-src'] = src;
-  const p = 'decode' in img ? img.decode() : Promise.resolve();
-  void p.catch(() => undefined).then(() => {
-    if (!img.parentElement || !img.isConnected) return;
-    if (placeholder !== 'empty') setBlurComplete(true);
-    if (onLoadRef.current) {
-      const event = new Event('load');
-      Object.defineProperty(event, 'target', { writable: false, value: img });
-      let prevented = false;
-      let stopped = false;
-      onLoadRef.current({
-        ...(event as unknown as Record<string, unknown>),
-        nativeEvent: event,
-        currentTarget: img,
-        target: img,
-        isDefaultPrevented: () => prevented,
-        isPropagationStopped: () => stopped,
-        persist: () => undefined,
-        preventDefault: () => {
-          prevented = true;
-          event.preventDefault();
-        },
-        stopPropagation: () => {
-          stopped = true;
-          event.stopPropagation();
-        },
-      } as unknown as JSX.TargetedEvent<HTMLImageElement, Event>);
-    }
-    if (onLoadingCompleteRef.current) onLoadingCompleteRef.current(img);
-  });
-}
-
-function useMergedRef<T>(refA: Ref<T> | undefined, refB: Ref<T> | undefined): (el: T | null) => void {
-  const cleanupA = useRef<(() => void) | null>(null);
-  const cleanupB = useRef<(() => void) | null>(null);
-  return useCallback(
-    (current: T | null) => {
-      if (current === null) {
-        cleanupA.current?.();
-        cleanupA.current = null;
-        cleanupB.current?.();
-        cleanupB.current = null;
-      } else {
-        if (refA) cleanupA.current = applyRef(refA, current);
-        if (refB) cleanupB.current = applyRef(refB, current);
-      }
-    },
-    [refA, refB],
-  );
-}
-
-function applyRef<T>(ref: NonNullable<Ref<T>>, current: T): () => void {
-  if (typeof ref === 'function') {
-    const cleanup = ref(current);
-    return typeof cleanup === 'function' ? cleanup : () => (ref as (v: T | null) => void)(null);
-  }
-  (ref as { current: T | null }).current = current;
-  return () => {
-    (ref as { current: T | null }).current = null;
-  };
-}
-
-const Image = forwardRef<HTMLImageElement, ImageClientProps>(function Image(
-  { __pnextConfig, ...imageProps },
-  forwardedRef,
-) {
-  const config = __pnextConfig ?? getImagesConfig();
-  const [blurComplete, setBlurComplete] = useState(false);
-  const [showAltText, setShowAltText] = useState(false);
-  const { props, meta } = resolveImageProps(imageProps, config, blurComplete, showAltText);
-
-  const { onLoad, onError, onLoadingComplete } = imageProps;
-  const onLoadRef = useRef(onLoad);
-  useEffect(() => {
-    onLoadRef.current = onLoad;
-  }, [onLoad]);
-  const onLoadingCompleteRef = useRef(onLoadingComplete);
-  useEffect(() => {
-    onLoadingCompleteRef.current = onLoadingComplete;
-  }, [onLoadingComplete]);
-
-  const placeholder = meta.placeholder;
-  const renderedSrc = typeof props.src === 'string' ? props.src : '';
-  const insertedImgRef = useRef<HTMLImageElement | null>(null);
-  const settledSrcRef = useRef<string | undefined>(undefined);
-  // True while an error the app must not see is outstanding: the server-rendered
-  // request that was already in flight when this component mounted. See below.
-  const swallowErrorRef = useRef(false);
-  useSettleEffect(() => {
-    const img = insertedImgRef.current;
-    if (img === null || settledSrcRef.current === renderedSrc) return;
-    settledSrcRef.current = renderedSrc;
-    // An error on a server-rendered image happens before onError is attached,
-    // so it is lost — Next re-issues the request once at mount to surface it.
-    if (onError) {
-      if (img.complete) {
-        const currentSrc = img.src;
-        img.src = currentSrc;
-      } else if (hydrating()) {
-        // Same situation, mid-flight: the request started with the document,
-        // so its outcome still predates this mount. Swallow it and re-issue
-        // once it lands, so onError sees an error raised against this mount.
-        swallowErrorRef.current = true;
-        img.addEventListener(
-          'error',
-          () => {
-            swallowErrorRef.current = false;
-            const failedSrc = img.src;
-            img.src = failedSrc;
-          },
-          { once: true },
-        );
-      }
-    }
-    const settle = () =>
-      handleLoading(img, placeholder, onLoadRef, onLoadingCompleteRef, setBlurComplete);
-    if (img.complete) settle();
-  }, [renderedSrc, placeholder, onError]);
-
-  const ref = useMergedRef<HTMLImageElement>(forwardedRef, insertedImgRef);
-  const extra = imageProps as unknown as {
-    crossOrigin?: string;
-    referrerPolicy?: string;
-    fetchPriority?: string;
-  };
-  const preloadLink =
-    meta.preload ? (
-      <link
-        rel="preload"
-        as="image"
-        href={meta.imgAttributes.srcSet ? undefined : meta.imgAttributes.src}
-        {...({
-          imagesrcset: meta.imgAttributes.srcSet,
-          imagesizes: meta.imgAttributes.sizes,
-          crossOrigin: extra.crossOrigin,
-          referrerPolicy: extra.referrerPolicy,
-          fetchpriority: extra.fetchPriority,
-        } as Record<string, unknown>)}
-      />
-    ) : null;
-
-  return (
-    <>
-      {preloadLink}
-      <img
-        {...props}
-        data-nimg={meta.fill ? 'fill' : '1'}
-        ref={ref}
-        onLoad={event => {
-          handleLoading(
-            event.currentTarget,
-            placeholder,
-            onLoadRef,
-            onLoadingCompleteRef,
-            setBlurComplete,
-          );
-        }}
-        onError={event => {
-          setShowAltText(true);
-          if (placeholder !== 'empty') setBlurComplete(true);
-          // The pre-mount failure is re-issued by the settle effect; the app
-          // hears about the retry, not the request that predated its handler.
-          if (swallowErrorRef.current) return;
-          onError?.(event);
-        }}
-      />
-    </>
-  );
-});
-
-export default Image;
-export { Image };

package/src/compat/next/link-usage.ts

@@ -1,29 +0,0 @@
-import { scanFirstPartySource } from './image-usage';
-
-/**
- * Build-time app fact: can any first-party source render `<Link legacyBehavior>`? The legacy child path
- * (child validation, the deprecation notice, the server/lazy child diagnostics, cloneElement) is a
- * meaningful slice of `next/link`, and next/link is initial on every page that links anywhere.
- *
- * One-sided like the blur gate: every unreadable case answers "yes". A wrong "no" renders the legacy
- * child shape on the server and a plain anchor on the client - a hydration mismatch. The scan sees the
- * app and its workspace packages, not registry dependencies.
- */
-const legacyProp = /\blegacyBehavior\b/;
-
-/** A Link re-exported from here can be rendered by a file this scan can't tie
- * back to `next/link`, so treat the re-export itself as usage. */
-const reexportedLink = /export\s[^;]*from\s*['"]next\/link['"]/;
-
-const cache = new Map<string, boolean>();
-
-export function appUsesLegacyLink(root: string) {
-  const cached = cache.get(root);
-  if (cached !== undefined) return cached;
-  const used = scanFirstPartySource(
-    root,
-    source => legacyProp.test(source) || reexportedLink.test(source),
-  );
-  cache.set(root, used);
-  return used;
-}

package/src/css/index.ts

@@ -1,2 +0,0 @@
-// Public surface of the CSS pipeline; implementation in ./build.
-export * from './build';

package/src/render/index.ts

@@ -1 +0,0 @@
-export * from './renderer';

package/src/style-modules.d.ts

@@ -1,9 +0,0 @@
-declare module '*.module.css' {
-  const classes: Record<string, string>;
-  export default classes;
-}
-
-declare module '*.css' {
-  const href: string | undefined;
-  export default href;
-}