@atlaspack/transformer-css 2.14.5-canary.25 → 2.14.5-canary.251

package/CHANGELOG.md

@@ -1,5 +1,263 @@
 # @atlaspack/transformer-css
 
+## 2.14.35
+
+### Patch Changes
+
+- Updated dependencies [[`79a7e22`](https://github.com/atlassian-labs/atlaspack/commit/79a7e22ef119891a2f4180a9d3cc66b38dd52092), [`3da8e69`](https://github.com/atlassian-labs/atlaspack/commit/3da8e690605472d81c531366b65fa9844f8ca337), [`c372f3f`](https://github.com/atlassian-labs/atlaspack/commit/c372f3fd6fce8200d5cf47f41bc7895c6cbb5558), [`17dfea9`](https://github.com/atlassian-labs/atlaspack/commit/17dfea9e9f3169807808520df9c09ebf70dc8b10), [`f1070ec`](https://github.com/atlassian-labs/atlaspack/commit/f1070ec48e99b4ec111a03179c5ab5b74163fab1)]:
+  - @atlaspack/feature-flags@2.25.5
+  - @atlaspack/utils@3.0.3
+  - @atlaspack/plugin@2.14.35
+  - @atlaspack/types@2.15.25
+
+## 2.14.34
+
+### Patch Changes
+
+- Updated dependencies [[`662d3c6`](https://github.com/atlassian-labs/atlaspack/commit/662d3c627888b16bf27df15cfac5a9094509e93d)]:
+  - @atlaspack/feature-flags@2.25.4
+  - @atlaspack/types@2.15.24
+  - @atlaspack/utils@3.0.2
+  - @atlaspack/plugin@2.14.34
+
+## 2.14.33
+
+### Patch Changes
+
+- Updated dependencies [[`236e546`](https://github.com/atlassian-labs/atlaspack/commit/236e5465863dca6044a7191e05260a5b924c342e), [`f07351a`](https://github.com/atlassian-labs/atlaspack/commit/f07351a2398b6a8e5155a2daad77e69b7dcb2b4b)]:
+  - @atlaspack/utils@3.0.1
+  - @atlaspack/feature-flags@2.25.3
+  - @atlaspack/types@2.15.23
+  - @atlaspack/plugin@2.14.33
+
+## 2.14.32
+
+### Patch Changes
+
+- [#800](https://github.com/atlassian-labs/atlaspack/pull/800) [`1180103`](https://github.com/atlassian-labs/atlaspack/commit/118010351ed444f8178988afb3f77807154dd933) Thanks [@mattcompiles](https://github.com/mattcompiles)! - Fix errors when creating diagnostics with relative file paths
+
+  BREAKING CHANGE: The `remapSourceLocation` API in `@atlaspack/utils` now requires the project root
+
+- Updated dependencies [[`0207171`](https://github.com/atlassian-labs/atlaspack/commit/0207171e59e985c51e105aec2e0a99de174374bd), [`10ee3fa`](https://github.com/atlassian-labs/atlaspack/commit/10ee3fa5b75a92acde8973673d9b3c5b6f3958e5), [`1180103`](https://github.com/atlassian-labs/atlaspack/commit/118010351ed444f8178988afb3f77807154dd933), [`2bc93b1`](https://github.com/atlassian-labs/atlaspack/commit/2bc93b17cea07fd7cbb68acec84d8471345a22b4)]:
+  - @atlaspack/feature-flags@2.25.2
+  - @atlaspack/utils@3.0.0
+  - @atlaspack/plugin@2.14.32
+  - @atlaspack/types@2.15.22
+
+## 2.14.31
+
+### Patch Changes
+
+- [#785](https://github.com/atlassian-labs/atlaspack/pull/785) [`0e7dd5e`](https://github.com/atlassian-labs/atlaspack/commit/0e7dd5ec6fbe05aa9e0bb5775a9d0975f206a922) Thanks [@matt-koko](https://github.com/matt-koko)! - We need to re-publish every package in Atlaspack with the corrected types field.
+
+- Updated dependencies [[`0e7dd5e`](https://github.com/atlassian-labs/atlaspack/commit/0e7dd5ec6fbe05aa9e0bb5775a9d0975f206a922)]:
+  - @atlaspack/diagnostic@2.14.4
+  - @atlaspack/feature-flags@2.25.1
+  - @atlaspack/plugin@2.14.31
+  - @atlaspack/types@2.15.21
+  - @atlaspack/utils@2.19.3
+
+## 2.14.30
+
+### Patch Changes
+
+- [#779](https://github.com/atlassian-labs/atlaspack/pull/779) [`7a52bab`](https://github.com/atlassian-labs/atlaspack/commit/7a52bab6281e8edbfa66af248eb6f872c6b4b7bd) Thanks [@marcins](https://github.com/marcins)! - Add new feature flag `preserveUnstableSingleFileOutputInCss` which when enabled will ensure the `unstableSingleFileOutput` property on the asset environment is preserved when transforming CSS.
+
+- Updated dependencies [[`7a52bab`](https://github.com/atlassian-labs/atlaspack/commit/7a52bab6281e8edbfa66af248eb6f872c6b4b7bd), [`038e87a`](https://github.com/atlassian-labs/atlaspack/commit/038e87a7858d39556d59d3a2d17db534d45f62c6), [`f6532d7`](https://github.com/atlassian-labs/atlaspack/commit/f6532d7a4f7f007bd4e5e36af04dd466f0b9f572), [`602f8ed`](https://github.com/atlassian-labs/atlaspack/commit/602f8ed9d8381301df8b2cc82c1d5cf6f2f94fec)]:
+  - @atlaspack/feature-flags@2.25.0
+  - @atlaspack/utils@2.19.2
+  - @atlaspack/plugin@2.14.30
+  - @atlaspack/types@2.15.20
+
+## 2.14.29
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/utils@2.19.1
+  - @atlaspack/plugin@2.14.29
+  - @atlaspack/types@2.15.19
+
+## 2.14.28
+
+### Patch Changes
+
+- Updated dependencies [[`f0349a6`](https://github.com/atlassian-labs/atlaspack/commit/f0349a6b9b04755088f121095ca6301a2ada3767)]:
+  - @atlaspack/utils@2.19.0
+  - @atlaspack/plugin@2.14.28
+  - @atlaspack/types@2.15.18
+
+## 2.14.27
+
+### Patch Changes
+
+- [#752](https://github.com/atlassian-labs/atlaspack/pull/752) [`a0aed1d`](https://github.com/atlassian-labs/atlaspack/commit/a0aed1dac6111096f7061675ac16a1417cbf6a17) Thanks [@marcins](https://github.com/marcins)! - Fix missing dependencies in package.json
+
+- Updated dependencies []:
+  - @atlaspack/utils@2.18.4
+  - @atlaspack/plugin@2.14.27
+  - @atlaspack/types@2.15.17
+
+## 2.14.26
+
+### Patch Changes
+
+- [#742](https://github.com/atlassian-labs/atlaspack/pull/742) [`ee040bb`](https://github.com/atlassian-labs/atlaspack/commit/ee040bb6428f29b57d892ddd8107e29077d08ffd) Thanks [@yamadapc](https://github.com/yamadapc)! - Internal changes and bug fixes to environmentDeduplication flag
+
+- Updated dependencies [[`ee040bb`](https://github.com/atlassian-labs/atlaspack/commit/ee040bb6428f29b57d892ddd8107e29077d08ffd), [`889c65c`](https://github.com/atlassian-labs/atlaspack/commit/889c65cd25b811045e26a117e7404f694dde77a2)]:
+  - @atlaspack/diagnostic@2.14.3
+  - @atlaspack/plugin@2.14.26
+  - @atlaspack/utils@2.18.3
+
+## 2.14.25
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/utils@2.18.2
+  - @atlaspack/plugin@2.14.25
+
+## 2.14.24
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/utils@2.18.1
+  - @atlaspack/plugin@2.14.24
+
+## 2.14.23
+
+### Patch Changes
+
+- Updated dependencies [[`23d561e`](https://github.com/atlassian-labs/atlaspack/commit/23d561e51e68b0c38fd1ff4e4fb173e5e7b01cf2)]:
+  - @atlaspack/utils@2.18.0
+  - @atlaspack/plugin@2.14.23
+
+## 2.14.22
+
+### Patch Changes
+
+- [#720](https://github.com/atlassian-labs/atlaspack/pull/720) [`d2fd849`](https://github.com/atlassian-labs/atlaspack/commit/d2fd849770fe6305e9c694bd97b1bd905abd9d94) Thanks [@alshdavid](https://github.com/alshdavid)! - Migrate to TypeScript
+
+- Updated dependencies [[`d2fd849`](https://github.com/atlassian-labs/atlaspack/commit/d2fd849770fe6305e9c694bd97b1bd905abd9d94)]:
+  - @atlaspack/diagnostic@2.14.2
+  - @atlaspack/plugin@2.14.22
+  - @atlaspack/utils@2.17.4
+
+## 2.14.21
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/utils@2.17.3
+  - @atlaspack/plugin@2.14.21
+
+## 2.14.20
+
+### Patch Changes
+
+- [#702](https://github.com/atlassian-labs/atlaspack/pull/702) [`daaa768`](https://github.com/atlassian-labs/atlaspack/commit/daaa7688786772d7e3713b71c5bba6b89ec704aa) Thanks [@alshdavid](https://github.com/alshdavid)! - Fixes to Flow types
+
+- Updated dependencies [[`daaa768`](https://github.com/atlassian-labs/atlaspack/commit/daaa7688786772d7e3713b71c5bba6b89ec704aa)]:
+  - @atlaspack/plugin@2.14.20
+  - @atlaspack/utils@2.17.2
+
+## 2.14.19
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/utils@2.17.1
+  - @atlaspack/plugin@2.14.19
+
+## 2.14.18
+
+### Patch Changes
+
+- Updated dependencies [[`dbb4072`](https://github.com/atlassian-labs/atlaspack/commit/dbb40721ebeb45990a14ba04e6b44e7f836fb32d), [`de23e0c`](https://github.com/atlassian-labs/atlaspack/commit/de23e0ce49d5504fe3947ac26640a3d951087da3), [`18a57cf`](https://github.com/atlassian-labs/atlaspack/commit/18a57cf8a4789b2de5ad8e2676f317a26cc91417), [`a5ed1b4`](https://github.com/atlassian-labs/atlaspack/commit/a5ed1b414498560f393ff491af4da25b6e8dde56)]:
+  - @atlaspack/utils@2.17.0
+  - @atlaspack/plugin@2.14.18
+
+## 2.14.17
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/utils@2.16.1
+  - @atlaspack/plugin@2.14.17
+
+## 2.14.16
+
+### Patch Changes
+
+- Updated dependencies [[`30ee2cf`](https://github.com/atlassian-labs/atlaspack/commit/30ee2cfcd34cf2646ded0eda13fdb80a2a5de529)]:
+  - @atlaspack/utils@2.16.0
+  - @atlaspack/plugin@2.14.16
+
+## 2.14.15
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/utils@2.15.3
+  - @atlaspack/plugin@2.14.15
+
+## 2.14.14
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/utils@2.15.2
+  - @atlaspack/plugin@2.14.14
+
+## 2.14.13
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/utils@2.15.1
+  - @atlaspack/plugin@2.14.13
+
+## 2.14.12
+
+### Patch Changes
+
+- Updated dependencies [[`e39c6cf`](https://github.com/atlassian-labs/atlaspack/commit/e39c6cf05f7e95ce5420dbcea66f401b1cbd397c)]:
+  - @atlaspack/utils@2.15.0
+  - @atlaspack/plugin@2.14.12
+
+## 2.14.11
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/utils@2.14.11
+  - @atlaspack/plugin@2.14.11
+
+## 2.14.10
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/plugin@2.14.10
+  - @atlaspack/utils@2.14.10
+
+## 2.14.9
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/utils@2.14.9
+  - @atlaspack/plugin@2.14.9
+
+## 2.14.8
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/utils@2.14.8
+  - @atlaspack/plugin@2.14.8
+
 ## 2.14.7
 
 ### Patch Changes

package/dist/CSSTransformer.js

@@ -0,0 +1,405 @@
+"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 });
+const path_1 = __importDefault(require("path"));
+const source_map_1 = __importDefault(require("@parcel/source-map"));
+const plugin_1 = require("@atlaspack/plugin");
+const utils_1 = require("@atlaspack/utils");
+const native = __importStar(require("lightningcss"));
+const browserslist_1 = __importDefault(require("browserslist"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const { transform, transformStyleAttribute, browserslistToTargets } = native;
+exports.default = new plugin_1.Transformer({
+    async loadConfig({ config, options }) {
+        let conf = await config.getConfigFrom(options.projectRoot + '/index', [], {
+            packageKey: '@atlaspack/transformer-css',
+        });
+        let contents = conf?.contents;
+        // @ts-expect-error TS2339
+        if (typeof contents?.cssModules?.include === 'string') {
+            // @ts-expect-error TS2339
+            contents.cssModules.include = [(0, utils_1.globToRegex)(contents.cssModules.include)];
+            // @ts-expect-error TS2339
+        }
+        else if (Array.isArray(contents?.cssModules?.include)) {
+            // @ts-expect-error TS2339
+            contents.cssModules.include = contents.cssModules.include.map(
+            // @ts-expect-error TS7006
+            (include) => typeof include === 'string' ? (0, utils_1.globToRegex)(include) : include);
+        }
+        // @ts-expect-error TS2339
+        if (typeof contents?.cssModules?.exclude === 'string') {
+            // @ts-expect-error TS2339
+            contents.cssModules.exclude = [(0, utils_1.globToRegex)(contents.cssModules.exclude)];
+            // @ts-expect-error TS2339
+        }
+        else if (Array.isArray(contents?.cssModules?.exclude)) {
+            // @ts-expect-error TS2339
+            contents.cssModules.exclude = contents.cssModules.exclude.map(
+            // @ts-expect-error TS7006
+            (exclude) => typeof exclude === 'string' ? (0, utils_1.globToRegex)(exclude) : exclude);
+        }
+        return contents;
+    },
+    async transform({ asset, config, options, logger }) {
+        if ((0, feature_flags_1.getFeatureFlag)('compiledCssInJsTransformer') &&
+            asset.filePath.endsWith('.compiled.css')) {
+            return handleCompiledCssAsset(asset);
+        }
+        // Normalize the asset's environment so that properties that only affect JS don't cause CSS to be duplicated.
+        // For example, with ESModule and CommonJS targets, only a single shared CSS bundle should be produced.
+        let env = asset.env;
+        asset.setEnvironment({
+            context: 'browser',
+            engines: {
+                browsers: asset.env.engines.browsers,
+            },
+            shouldOptimize: asset.env.shouldOptimize,
+            shouldScopeHoist: asset.env.shouldScopeHoist,
+            sourceMap: asset.env.sourceMap,
+            unstableSingleFileOutput: (0, feature_flags_1.getFeatureFlag)('preserveUnstableSingleFileOutputInCss')
+                ? asset.env.unstableSingleFileOutput
+                : undefined,
+        });
+        let [code, originalMap] = await Promise.all([
+            asset.getBuffer(),
+            asset.getMap(),
+            // @ts-expect-error TS2339
+            process.browser && native.default(),
+        ]);
+        let targets = getTargets(asset.env.engines.browsers);
+        let res;
+        try {
+            if (asset.meta.type === 'attr') {
+                res = transformStyleAttribute({
+                    code,
+                    analyzeDependencies: true,
+                    // @ts-expect-error TS2339
+                    errorRecovery: config?.errorRecovery || false,
+                    targets,
+                });
+            }
+            else {
+                let cssModules = false;
+                if (asset.meta.type !== 'tag' &&
+                    asset.meta.cssModulesCompiled == null) {
+                    // @ts-expect-error TS2339
+                    let cssModulesConfig = config?.cssModules;
+                    let isCSSModule = /\.module\./.test(asset.filePath);
+                    if (asset.isSource) {
+                        let projectRootPath = path_1.default.relative(options.projectRoot, asset.filePath);
+                        if (typeof cssModulesConfig === 'boolean') {
+                            isCSSModule = true;
+                        }
+                        else if (cssModulesConfig?.include) {
+                            // @ts-expect-error TS7006
+                            isCSSModule = cssModulesConfig.include.some((include) => include.test(projectRootPath));
+                        }
+                        else if (cssModulesConfig?.global) {
+                            isCSSModule = true;
+                        }
+                        if (cssModulesConfig?.exclude?.some((exclude) => exclude.test(projectRootPath))) {
+                            isCSSModule = false;
+                        }
+                    }
+                    if (isCSSModule) {
+                        if (cssModulesConfig?.dashedIdents && !asset.isSource) {
+                            cssModulesConfig.dashedIdents = false;
+                        }
+                        cssModules = cssModulesConfig ?? true;
+                    }
+                }
+                res = transform({
+                    filename: (0, utils_1.normalizeSeparators)(path_1.default.relative(options.projectRoot, asset.filePath)),
+                    code,
+                    cssModules,
+                    analyzeDependencies: asset.meta.hasDependencies !== false
+                        ? {
+                            preserveImports: true,
+                        }
+                        : false,
+                    sourceMap: !!asset.env.sourceMap,
+                    // @ts-expect-error TS2339
+                    drafts: config?.drafts,
+                    // @ts-expect-error TS2339
+                    pseudoClasses: config?.pseudoClasses,
+                    // @ts-expect-error TS2339
+                    errorRecovery: config?.errorRecovery || false,
+                    targets,
+                });
+            }
+        }
+        catch (err) {
+            err.filePath = asset.filePath;
+            let diagnostic = (0, diagnostic_1.errorToDiagnostic)(err, {
+                origin: '@atlaspack/transformer-css',
+            });
+            if (err.data?.type === 'AmbiguousUrlInCustomProperty' && err.data.url) {
+                let p = '/' +
+                    (0, utils_1.relativePath)(options.projectRoot, path_1.default.resolve(path_1.default.dirname(asset.filePath), err.data.url), false);
+                diagnostic[0].hints = [`Replace with: url(${p})`];
+                diagnostic[0].documentationURL =
+                    'https://parceljs.org/languages/css/#url()';
+            }
+            throw new diagnostic_1.default({
+                diagnostic,
+            });
+        }
+        if (res.warnings) {
+            for (let warning of res.warnings) {
+                logger.warn({
+                    message: warning.message,
+                    codeFrames: [
+                        {
+                            filePath: asset.filePath,
+                            codeHighlights: [
+                                {
+                                    start: {
+                                        line: warning.loc.line,
+                                        column: warning.loc.column + 1,
+                                    },
+                                    end: {
+                                        line: warning.loc.line,
+                                        column: warning.loc.column + 1,
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                });
+            }
+        }
+        // @ts-expect-error TS2339
+        if (res.map != null) {
+            // @ts-expect-error TS2339
+            let vlqMap = JSON.parse(Buffer.from(res.map).toString());
+            let map = new source_map_1.default(options.projectRoot);
+            map.addVLQMap(vlqMap);
+            if (originalMap) {
+                map.extends(originalMap);
+            }
+            asset.setMap(map);
+        }
+        if (res.dependencies) {
+            for (let dep of res.dependencies) {
+                let loc = convertLoc(dep.loc);
+                if (originalMap) {
+                    loc = (0, utils_1.remapSourceLocation)(loc, originalMap, options.projectRoot);
+                }
+                // @ts-expect-error TS2339
+                if (dep.type === 'import' && !res.exports) {
+                    asset.addDependency({
+                        specifier: dep.url,
+                        specifierType: 'url',
+                        loc,
+                        packageConditions: ['style'],
+                        meta: {
+                            // For the glob resolver to distinguish between `@import` and other URL dependencies.
+                            isCSSImport: true,
+                            media: dep.media,
+                            placeholder: dep.placeholder,
+                        },
+                    });
+                }
+                else if (dep.type === 'url') {
+                    asset.addURLDependency(dep.url, {
+                        loc,
+                        meta: {
+                            placeholder: dep.placeholder,
+                        },
+                    });
+                }
+            }
+        }
+        let assets = [asset];
+        let buffer = Buffer.from(res.code);
+        // @ts-expect-error TS2339
+        if (res.exports != null) {
+            // @ts-expect-error TS2339
+            let exports = res.exports;
+            asset.symbols.ensure();
+            asset.symbols.set('default', 'default');
+            let dependencies = new Map();
+            let locals = new Map();
+            let c = 0;
+            let depjs = '';
+            let js = '';
+            let cssImports = '';
+            let jsDeps = [];
+            for (let key in exports) {
+                locals.set(exports[key].name, key);
+            }
+            asset.uniqueKey ?? (asset.uniqueKey = asset.id);
+            let seen = new Set();
+            let add = (key) => {
+                if (seen.has(key)) {
+                    return;
+                }
+                seen.add(key);
+                let e = exports[key];
+                let s = `module.exports[${JSON.stringify(key)}] = \`${e.name}`;
+                for (let ref of e.composes) {
+                    s += ' ';
+                    if (ref.type === 'local') {
+                        let exported = (0, nullthrows_1.default)(locals.get(ref.name));
+                        add(exported);
+                        s += '${' + `module.exports[${JSON.stringify(exported)}]` + '}';
+                        asset.addDependency({
+                            specifier: (0, nullthrows_1.default)(asset.uniqueKey),
+                            specifierType: 'esm',
+                            symbols: new Map([
+                                [exported, { local: ref.name, isWeak: false, loc: null }],
+                            ]),
+                        });
+                    }
+                    else if (ref.type === 'global') {
+                        s += ref.name;
+                    }
+                    else if (ref.type === 'dependency') {
+                        let d = dependencies.get(ref.specifier);
+                        if (d == null) {
+                            d = `dep_${c++}`;
+                            depjs += `import * as ${d} from ${JSON.stringify(ref.specifier)};\n`;
+                            dependencies.set(ref.specifier, d);
+                            cssImports += `@import "${ref.specifier}";\n`;
+                            asset.addDependency({
+                                specifier: ref.specifier,
+                                specifierType: 'esm',
+                                packageConditions: ['style'],
+                            });
+                        }
+                        s += '${' + `${d}[${JSON.stringify(ref.name)}]` + '}';
+                    }
+                }
+                s += '`;\n';
+                // If the export is referenced internally (e.g. used @keyframes), add a self-reference
+                // to the JS so the symbol is retained during tree-shaking.
+                if (e.isReferenced) {
+                    s += `module.exports[${JSON.stringify(key)}];\n`;
+                    asset.addDependency({
+                        specifier: (0, nullthrows_1.default)(asset.uniqueKey),
+                        specifierType: 'esm',
+                        symbols: new Map([
+                            [key, { local: exports[key].name, isWeak: false, loc: null }],
+                        ]),
+                    });
+                }
+                js += s;
+            };
+            // It's possible that the exports can be ordered differently between builds.
+            // Sorting by key is safe as the order is irrelevant but needs to be deterministic.
+            for (let key of Object.keys(exports).sort()) {
+                asset.symbols.set(key, exports[key].name);
+                add(key);
+            }
+            if (res.dependencies) {
+                for (let dep of res.dependencies) {
+                    if (dep.type === 'import') {
+                        // TODO: Figure out how to treeshake this
+                        let d = `dep_$${c++}`;
+                        depjs += `import * as ${d} from ${JSON.stringify(dep.url)};\n`;
+                        js += `for (let key in ${d}) { if (key in module.exports) module.exports[key] += ' ' + ${d}[key]; else module.exports[key] = ${d}[key]; }\n`;
+                        asset.symbols.set('*', '*');
+                    }
+                }
+            }
+            // @ts-expect-error TS2339
+            if (res.references != null) {
+                // @ts-expect-error TS2339
+                let references = res.references;
+                for (let symbol in references) {
+                    let reference = references[symbol];
+                    asset.addDependency({
+                        specifier: reference.specifier,
+                        specifierType: 'esm',
+                        packageConditions: ['style'],
+                        symbols: new Map([
+                            [reference.name, { local: symbol, isWeak: false, loc: null }],
+                        ]),
+                    });
+                    asset.meta.hasReferences = true;
+                    cssImports += `@import "${reference.specifier}";\n`;
+                }
+            }
+            assets.push({
+                type: 'js',
+                // @ts-expect-error TS2353
+                content: depjs + js,
+                dependencies: jsDeps,
+                env,
+            });
+            // Prepend @import rules for each composes dependency so packager knows where to insert them.
+            if (cssImports.length > 0) {
+                buffer = Buffer.concat([Buffer.from(cssImports), buffer]);
+            }
+        }
+        asset.setBuffer(buffer);
+        return assets;
+    },
+});
+let cache = new Map();
+function getTargets(browsers) {
+    if (browsers == null) {
+        return undefined;
+    }
+    let cached = cache.get(browsers);
+    if (cached != null) {
+        return cached;
+    }
+    let targets = browserslistToTargets((0, browserslist_1.default)(browsers));
+    cache.set(browsers, targets);
+    return targets;
+}
+function convertLoc(loc) {
+    return {
+        filePath: loc.filePath,
+        start: { line: loc.start.line, column: loc.start.column },
+        end: { line: loc.end.line, column: loc.end.column + 1 },
+    };
+}
+async function handleCompiledCssAsset(asset) {
+    const code = await asset.getCode();
+    const rules = code.split('\n').map((line) => line.trim());
+    // styleRules will be consumed by the optimiser in @compiled/parcel-optimizer
+    asset.meta.styleRules = rules;
+    // Empty the code because we only use compiled CSS assets for their metadata
+    asset.setCode('');
+    return [asset];
+}