@atlaspack/packager-css 2.14.5-canary.36 → 2.14.5-canary.361

package/dist/CSSPackager.js

@@ -0,0 +1,330 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSpecifier = getSpecifier;
+const lightningcss_1 = __importStar(require("lightningcss"));
+const assert_1 = __importDefault(require("assert"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const source_map_1 = __importDefault(require("@atlaspack/source-map"));
+const plugin_1 = require("@atlaspack/plugin");
+const diagnostic_1 = require("@atlaspack/diagnostic");
+const utils_1 = require("@atlaspack/utils");
+exports.default = new plugin_1.Packager({
+    async package({ bundle, bundleGraph, getInlineBundleContents, getSourceMapReference, logger, options, }) {
+        // Inline style attributes are parsed differently from full CSS files.
+        if (bundle.bundleBehavior === 'inline') {
+            let entry = bundle.getMainEntry();
+            if (entry?.meta.type === 'attr') {
+                return replaceReferences(bundle, bundleGraph, await entry.getCode(), await entry.getMap(), getInlineBundleContents);
+            }
+        }
+        let queue = new utils_1.PromiseQueue({
+            maxConcurrent: 32,
+        });
+        // @ts-expect-error TS2304
+        let hoistedImports = [];
+        let assetsByPlaceholder = new Map();
+        // @ts-expect-error TS7034
+        let entry = null;
+        let entryContents = '';
+        bundle.traverse({
+            enter: (node, context) => {
+                if (node.type === 'asset' && !context) {
+                    // If there is only one entry, we'll use it directly.
+                    // Otherwise, we'll create a fake bundle entry with @import rules for each root asset.
+                    // @ts-expect-error TS7005
+                    if (entry == null) {
+                        entry = node.value.id;
+                    }
+                    else {
+                        entry = bundle.id;
+                    }
+                    assetsByPlaceholder.set(node.value.id, node.value);
+                    entryContents += `@import "${node.value.id}";\n`;
+                }
+                return true;
+            },
+            exit: (node) => {
+                if (node.type === 'dependency') {
+                    let resolved = bundleGraph.getResolvedAsset(node.value, bundle);
+                    // Hoist unresolved external dependencies (i.e. http: imports)
+                    if (node.value.priority === 'sync' &&
+                        !bundleGraph.isDependencySkipped(node.value) &&
+                        !resolved) {
+                        hoistedImports.push(node.value.specifier);
+                    }
+                    if (resolved && bundle.hasAsset(resolved)) {
+                        assetsByPlaceholder.set(node.value.meta.placeholder ?? node.value.specifier, resolved);
+                    }
+                    return;
+                }
+                let asset = node.value;
+                queue.add(() => {
+                    if (!asset.symbols.isCleared &&
+                        options.mode === 'production' &&
+                        asset.astGenerator?.type === 'postcss') {
+                        // a CSS Modules asset
+                        return processCSSModule(options, logger, bundleGraph, bundle, asset);
+                    }
+                    else {
+                        return Promise.all([
+                            asset,
+                            asset.getCode().then((css) => {
+                                // Replace CSS variable references with resolved symbols.
+                                if (asset.meta.hasReferences) {
+                                    let replacements = new Map();
+                                    for (let dep of asset.getDependencies()) {
+                                        for (let [exported, { local }] of dep.symbols) {
+                                            let resolved = bundleGraph.getResolvedAsset(dep, bundle);
+                                            if (resolved) {
+                                                let resolution = bundleGraph.getSymbolResolution(resolved, exported, bundle);
+                                                if (resolution.symbol) {
+                                                    replacements.set(local, resolution.symbol);
+                                                }
+                                            }
+                                        }
+                                    }
+                                    if (replacements.size > 0) {
+                                        let regex = new RegExp([...replacements.keys()].join('|'), 'g');
+                                        css = css.replace(regex, (m) => escapeDashedIdent(replacements.get(m) || m));
+                                    }
+                                }
+                                return css;
+                            }),
+                            bundle.env.sourceMap ? asset.getMap() : null,
+                        ]);
+                    }
+                });
+            },
+        });
+        let outputs = new Map(
+        // @ts-expect-error TS2345
+        (await queue.run()).map(([asset, code, map]) => [
+            asset,
+            [code, map],
+        ]));
+        let map = new source_map_1.default(options.projectRoot);
+        // @ts-expect-error TS2339
+        if (process.browser) {
+            // @ts-expect-error TS2349
+            await (0, lightningcss_1.default)();
+        }
+        let res = await (0, lightningcss_1.bundleAsync)({
+            // @ts-expect-error TS2322
+            filename: (0, nullthrows_1.default)(entry),
+            sourceMap: !!bundle.env.sourceMap,
+            resolver: {
+                resolve(specifier) {
+                    return specifier;
+                },
+                async read(file) {
+                    if (file === bundle.id) {
+                        return entryContents;
+                    }
+                    let asset = assetsByPlaceholder.get(file);
+                    if (!asset) {
+                        return '';
+                    }
+                    let [code, map] = (0, nullthrows_1.default)(outputs.get(asset));
+                    if (map) {
+                        let sm = await map.stringify({ format: 'inline' });
+                        (0, assert_1.default)(typeof sm === 'string');
+                        code += `\n/*# sourceMappingURL=${sm} */`;
+                    }
+                    return code;
+                },
+            },
+        });
+        let contents = res.code.toString();
+        if (res.map) {
+            let vlqMap = JSON.parse(res.map.toString());
+            map.addVLQMap(vlqMap);
+            let reference = await getSourceMapReference(map);
+            if (reference != null) {
+                contents += '/*# sourceMappingURL=' + reference + ' */\n';
+            }
+        }
+        // Prepend hoisted external imports.
+        if (hoistedImports.length > 0) {
+            let lineOffset = 0;
+            let hoistedCode = '';
+            for (let url of hoistedImports) {
+                hoistedCode += `@import "${url}";\n`;
+                lineOffset++;
+            }
+            if (bundle.env.sourceMap) {
+                map.offsetLines(1, lineOffset);
+            }
+            contents = hoistedCode + contents;
+        }
+        return replaceReferences(bundle, bundleGraph, contents, map, getInlineBundleContents);
+    },
+});
+function replaceReferences(
+// @ts-expect-error TS2304
+bundle, 
+// @ts-expect-error TS2304
+bundleGraph, contents, 
+// @ts-expect-error TS2552
+map, getInlineBundleContents) {
+    ({ contents, map } = (0, utils_1.replaceURLReferences)({
+        bundle,
+        bundleGraph,
+        contents,
+        map,
+        getReplacement: escapeString,
+    }));
+    return (0, utils_1.replaceInlineReferences)({
+        bundle,
+        bundleGraph,
+        contents,
+        getInlineBundleContents,
+        getInlineReplacement: (dep, inlineType, contents) => ({
+            from: getSpecifier(dep),
+            to: escapeString(contents),
+        }),
+        map,
+    });
+}
+function getSpecifier(dep) {
+    if (typeof dep.meta.placeholder === 'string') {
+        return dep.meta.placeholder;
+    }
+    return dep.id;
+}
+function escapeString(contents) {
+    return contents.replace(/(["\\])/g, '\\$1');
+}
+async function processCSSModule(
+// @ts-expect-error TS2552
+options, 
+// @ts-expect-error TS2304
+logger, 
+// @ts-expect-error TS2304
+bundleGraph, 
+// @ts-expect-error TS2304
+bundle, asset) {
+    // @ts-expect-error TS2709
+    let postcss = await options.packageManager.require('postcss', options.projectRoot + '/index', {
+        range: '^8.4.5',
+        saveDev: true,
+        shouldAutoInstall: options.shouldAutoInstall,
+    });
+    let ast = postcss.fromJSON((0, nullthrows_1.default)((await asset.getAST())?.program));
+    let usedSymbols = bundleGraph.getUsedSymbols(asset);
+    if (usedSymbols != null) {
+        let localSymbols = new Set([...asset.symbols].map(([, { local }]) => `.${local}`));
+        let defaultImport = null;
+        if (usedSymbols.has('default')) {
+            let incoming = bundleGraph.getIncomingDependencies(asset);
+            // @ts-expect-error TS7006
+            defaultImport = incoming.find((d) => d.symbols.hasExportSymbol('default'));
+            if (defaultImport) {
+                let loc = defaultImport.symbols.get('default')?.loc;
+                logger.warn({
+                    message: 'CSS modules cannot be tree shaken when imported with a default specifier',
+                    ...(loc && {
+                        codeFrames: [
+                            {
+                                filePath: (0, nullthrows_1.default)(loc?.filePath ?? defaultImport.sourcePath),
+                                codeHighlights: [(0, diagnostic_1.convertSourceLocationToHighlight)(loc)],
+                            },
+                        ],
+                    }),
+                    hints: [
+                        `Instead do: import * as style from "${defaultImport.specifier}";`,
+                    ],
+                    documentationURL: 'https://parceljs.org/languages/css/#tree-shaking',
+                });
+            }
+        }
+        if (!defaultImport && !usedSymbols.has('*')) {
+            let usedLocalSymbols = new Set([...usedSymbols].map((exportSymbol) => `.${(0, nullthrows_1.default)(asset.symbols.get(exportSymbol)).local}`));
+            ast.walkRules((rule) => {
+                if (localSymbols.has(rule.selector) &&
+                    !usedLocalSymbols.has(rule.selector)) {
+                    rule.remove();
+                }
+            });
+        }
+    }
+    let { content, map } = await postcss().process(ast, {
+        from: undefined,
+        to: options.projectRoot + '/index',
+        map: {
+            annotation: false,
+            inline: false,
+        },
+        // Pass postcss's own stringifier to it to silence its warning
+        // as we don't want to perform any transformations -- only generate
+        stringifier: postcss.stringify,
+    });
+    let sourceMap;
+    if (bundle.env.sourceMap && map != null) {
+        sourceMap = new source_map_1.default(options.projectRoot);
+        sourceMap.addVLQMap(map.toJSON());
+    }
+    return [asset, content, sourceMap];
+}
+function escapeDashedIdent(name) {
+    // https://drafts.csswg.org/cssom/#serialize-an-identifier
+    let res = '';
+    // @ts-expect-error TS2488
+    for (let c of name) {
+        let code = c.codePointAt(0);
+        if (code === 0) {
+            res += '\ufffd';
+        }
+        else if ((code >= 0x1 && code <= 0x1f) || code === 0x7f) {
+            res += '\\' + code.toString(16) + ' ';
+        }
+        else if ((code >= 48 /* '0' */ && code <= 57) /* '9' */ ||
+            (code >= 65 /* 'A' */ && code <= 90) /* 'Z' */ ||
+            (code >= 97 /* 'a' */ && code <= 122) /* 'z' */ ||
+            code === 95 /* '_' */ ||
+            code === 45 /* '-' */ ||
+            code & 128 // non-ascii
+        ) {
+            res += c;
+        }
+        else {
+            res += '\\' + c;
+        }
+    }
+    return res;
+}

package/lib/CSSPackager.js

@@ -27,7 +27,7 @@ function _nullthrows() {
   return data;
 }
 function _sourceMap() {
-  const data = _interopRequireDefault(require("@parcel/source-map"));
+  const data = _interopRequireDefault(require("@atlaspack/source-map"));
   _sourceMap = function () {
     return data;
   };
@@ -57,7 +57,6 @@ function _utils() {
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-// $FlowFixMe - init for browser build.
 var _default = exports.default = new (_plugin().Packager)({
   async package({
     bundle,
@@ -77,8 +76,10 @@ var _default = exports.default = new (_plugin().Packager)({
     let queue = new (_utils().PromiseQueue)({
       maxConcurrent: 32
     });
+    // @ts-expect-error TS2304
     let hoistedImports = [];
     let assetsByPlaceholder = new Map();
+    // @ts-expect-error TS7034
     let entry = null;
     let entryContents = '';
     bundle.traverse({
@@ -86,6 +87,7 @@ var _default = exports.default = new (_plugin().Packager)({
         if (node.type === 'asset' && !context) {
           // If there is only one entry, we'll use it directly.
           // Otherwise, we'll create a fake bundle entry with @import rules for each root asset.
+          // @ts-expect-error TS7005
           if (entry == null) {
             entry = node.value.id;
           } else {
@@ -144,14 +146,18 @@ var _default = exports.default = new (_plugin().Packager)({
         });
       }
     });
-    let outputs = new Map((await queue.run()).map(([asset, code, map]) => [asset, [code, map]]));
+    let outputs = new Map(
+    // @ts-expect-error TS2345
+    (await queue.run()).map(([asset, code, map]) => [asset, [code, map]]));
     let map = new (_sourceMap().default)(options.projectRoot);
 
-    // $FlowFixMe
+    // @ts-expect-error TS2339
     if (process.browser) {
+      // @ts-expect-error TS2349
       await (0, _lightningcss().default)();
     }
     let res = await (0, _lightningcss().bundleAsync)({
+      // @ts-expect-error TS2322
       filename: (0, _nullthrows().default)(entry),
       sourceMap: !!bundle.env.sourceMap,
       resolver: {
@@ -204,7 +210,13 @@ var _default = exports.default = new (_plugin().Packager)({
     return replaceReferences(bundle, bundleGraph, contents, map, getInlineBundleContents);
   }
 });
-function replaceReferences(bundle, bundleGraph, contents, map, getInlineBundleContents) {
+function replaceReferences(
+// @ts-expect-error TS2304
+bundle,
+// @ts-expect-error TS2304
+bundleGraph, contents,
+// @ts-expect-error TS2552
+map, getInlineBundleContents) {
   ({
     contents,
     map
@@ -236,8 +248,17 @@ function getSpecifier(dep) {
 function escapeString(contents) {
   return contents.replace(/(["\\])/g, '\\$1');
 }
-async function processCSSModule(options, logger, bundleGraph, bundle, asset) {
+async function processCSSModule(
+// @ts-expect-error TS2552
+options,
+// @ts-expect-error TS2304
+logger,
+// @ts-expect-error TS2304
+bundleGraph,
+// @ts-expect-error TS2304
+bundle, asset) {
   var _await$asset$getAST;
+  // @ts-expect-error TS2709
   let postcss = await options.packageManager.require('postcss', options.projectRoot + '/index', {
     range: '^8.4.5',
     saveDev: true,
@@ -252,6 +273,7 @@ async function processCSSModule(options, logger, bundleGraph, bundle, asset) {
     let defaultImport = null;
     if (usedSymbols.has('default')) {
       let incoming = bundleGraph.getIncomingDependencies(asset);
+      // @ts-expect-error TS7006
       defaultImport = incoming.find(d => d.symbols.hasExportSymbol('default'));
       if (defaultImport) {
         var _defaultImport$symbol;
@@ -302,6 +324,7 @@ async function processCSSModule(options, logger, bundleGraph, bundle, asset) {
 function escapeDashedIdent(name) {
   // https://drafts.csswg.org/cssom/#serialize-an-identifier
   let res = '';
+  // @ts-expect-error TS2488
   for (let c of name) {
     let code = c.codePointAt(0);
     if (code === 0) {

package/lib/types/CSSPackager.d.ts

@@ -0,0 +1,5 @@
+import type { Dependency } from '@atlaspack/types-internal';
+import { Packager } from '@atlaspack/plugin';
+declare const _default: Packager<unknown, unknown>;
+export default _default;
+export declare function getSpecifier(dep: Dependency): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/packager-css",
-  "version": "2.14.5-canary.36+2d10c6656",
+  "version": "2.14.5-canary.361+405bbaf61",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -9,16 +9,18 @@
     "type": "git",
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
-  "main": "lib/CSSPackager.js",
-  "source": "src/CSSPackager.js",
+  "main": "./lib/CSSPackager.js",
+  "source": "./src/CSSPackager.ts",
+  "types": "./lib/types/CSSPackager.d.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
   "dependencies": {
-    "@atlaspack/diagnostic": "2.14.1-canary.104+2d10c6656",
-    "@atlaspack/plugin": "2.14.5-canary.36+2d10c6656",
-    "@atlaspack/utils": "2.14.5-canary.36+2d10c6656",
-    "@parcel/source-map": "^2.1.1",
+    "@atlaspack/diagnostic": "2.14.1-canary.429+405bbaf61",
+    "@atlaspack/plugin": "2.14.5-canary.361+405bbaf61",
+    "@atlaspack/source-map": "3.2.5-canary.4140+405bbaf61",
+    "@atlaspack/types-internal": "2.14.1-canary.429+405bbaf61",
+    "@atlaspack/utils": "2.14.5-canary.361+405bbaf61",
     "lightningcss": "^1.28.2",
     "nullthrows": "^1.1.1"
   },
@@ -30,5 +32,8 @@
     "lightningcss": "lightningcss-wasm"
   },
   "type": "commonjs",
-  "gitHead": "2d10c6656fc58743c5dbed1d2b6c5666887f9fe4"
-}
+  "scripts": {
+    "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
+  },
+  "gitHead": "405bbaf619f634cf9e58cc618d9a911f7db2998d"
+}

package/src/{CSSPackager.js → CSSPackager.ts}

@@ -1,14 +1,11 @@
-// @flow
-
 import type {Root} from 'postcss';
-import type {Asset, Dependency} from '@atlaspack/types';
-import typeof PostCSS from 'postcss';
-// $FlowFixMe - init for browser build.
+import type {Asset, Dependency} from '@atlaspack/types-internal';
+import PostCSS from 'postcss';
 import init, {bundleAsync} from 'lightningcss';
 
 import invariant from 'assert';
 import nullthrows from 'nullthrows';
-import SourceMap from '@parcel/source-map';
+import SourceMap from '@atlaspack/source-map';
 import {Packager} from '@atlaspack/plugin';
 import {convertSourceLocationToHighlight} from '@atlaspack/diagnostic';
 import {
@@ -17,7 +14,7 @@ import {
   replaceURLReferences,
 } from '@atlaspack/utils';
 
-export default (new Packager({
+export default new Packager({
   async package({
     bundle,
     bundleGraph,
@@ -43,8 +40,10 @@ export default (new Packager({
     let queue = new PromiseQueue({
       maxConcurrent: 32,
     });
-    let hoistedImports = [];
+    // @ts-expect-error TS2304
+    let hoistedImports: Array<DependencySpecifier> = [];
     let assetsByPlaceholder = new Map();
+    // @ts-expect-error TS7034
     let entry = null;
     let entryContents = '';
 
@@ -53,6 +52,7 @@ export default (new Packager({
         if (node.type === 'asset' && !context) {
           // If there is only one entry, we'll use it directly.
           // Otherwise, we'll create a fake bundle entry with @import rules for each root asset.
+          // @ts-expect-error TS7005
           if (entry == null) {
             entry = node.value.id;
           } else {
@@ -145,23 +145,29 @@ export default (new Packager({
     });
 
     let outputs = new Map(
-      (await queue.run()).map(([asset, code, map]) => [asset, [code, map]]),
+      // @ts-expect-error TS2345
+      (await queue.run()).map(([asset, code, map]: [any, any, any]) => [
+        asset,
+        [code, map],
+      ]),
     );
     let map = new SourceMap(options.projectRoot);
 
-    // $FlowFixMe
+    // @ts-expect-error TS2339
     if (process.browser) {
+      // @ts-expect-error TS2349
       await init();
     }
 
     let res = await bundleAsync({
+      // @ts-expect-error TS2322
       filename: nullthrows(entry),
       sourceMap: !!bundle.env.sourceMap,
       resolver: {
-        resolve(specifier) {
+        resolve(specifier: string) {
           return specifier;
         },
-        async read(file) {
+        async read(file: string) {
           if (file === bundle.id) {
             return entryContents;
           }
@@ -216,14 +222,25 @@ export default (new Packager({
       getInlineBundleContents,
     );
   },
-}): Packager);
+}) as Packager<unknown, unknown>;
 
 function replaceReferences(
-  bundle,
-  bundleGraph,
-  contents,
-  map,
-  getInlineBundleContents,
+  // @ts-expect-error TS2304
+  bundle: NamedBundle,
+  // @ts-expect-error TS2304
+  bundleGraph: BundleGraph<NamedBundle>,
+  contents: string,
+  // @ts-expect-error TS2552
+  map: NodeSourceMap | null | undefined,
+  getInlineBundleContents: (
+    // @ts-expect-error TS2304
+    arg1: Bundle,
+    // @ts-expect-error TS2304
+    arg2: BundleGraph<NamedBundle>,
+    // @ts-expect-error TS2304
+  ) => Async<{
+    contents: Blob;
+  }>,
 ) {
   ({contents, map} = replaceURLReferences({
     bundle,
@@ -259,12 +276,17 @@ function escapeString(contents: string): string {
 }
 
 async function processCSSModule(
-  options,
-  logger,
-  bundleGraph,
-  bundle,
-  asset,
-): Promise<[Asset, string, ?SourceMap]> {
+  // @ts-expect-error TS2552
+  options: PluginOptions,
+  // @ts-expect-error TS2304
+  logger: PluginLogger,
+  // @ts-expect-error TS2304
+  bundleGraph: BundleGraph<NamedBundle>,
+  // @ts-expect-error TS2304
+  bundle: NamedBundle,
+  asset: Asset,
+): Promise<[Asset, string, SourceMap | null | undefined]> {
+  // @ts-expect-error TS2709
   let postcss: PostCSS = await options.packageManager.require(
     'postcss',
     options.projectRoot + '/index',
@@ -280,12 +302,13 @@ async function processCSSModule(
   let usedSymbols = bundleGraph.getUsedSymbols(asset);
   if (usedSymbols != null) {
     let localSymbols = new Set(
-      [...asset.symbols].map(([, {local}]) => `.${local}`),
+      [...asset.symbols].map(([, {local}]: [any, any]) => `.${local}`),
     );
 
     let defaultImport = null;
     if (usedSymbols.has('default')) {
       let incoming = bundleGraph.getIncomingDependencies(asset);
+      // @ts-expect-error TS7006
       defaultImport = incoming.find((d) =>
         d.symbols.hasExportSymbol('default'),
       );
@@ -349,9 +372,10 @@ async function processCSSModule(
   return [asset, content, sourceMap];
 }
 
-function escapeDashedIdent(name) {
+function escapeDashedIdent(name: symbol | string) {
   // https://drafts.csswg.org/cssom/#serialize-an-identifier
   let res = '';
+  // @ts-expect-error TS2488
   for (let c of name) {
     let code = c.codePointAt(0);
     if (code === 0) {

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "include": ["src"],
+  "compilerOptions": {
+    "composite": true
+  },
+  "references": [
+    {
+      "path": "../../core/diagnostic/tsconfig.json"
+    },
+    {
+      "path": "../../core/plugin/tsconfig.json"
+    },
+    {
+      "path": "../../core/types-internal/tsconfig.json"
+    },
+    {
+      "path": "../../core/utils/tsconfig.json"
+    },
+    {
+      "path": "../../core/source-map/tsconfig.json"
+    }
+  ]
+}