happy-css-modules 0.2.0

package/src/emitter/index.test.ts

@@ -0,0 +1,130 @@
+import { readFile, stat } from 'fs/promises';
+import { jest } from '@jest/globals';
+import chalk from 'chalk';
+import { createFixtures, exists, fakeToken, getFixturePath, waitForAsyncTask } from '../test/util.js';
+import { emitGeneratedFiles, getRelativePath, isSubDirectoryFile } from './index.js';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+
+beforeEach(() => {
+  consoleLogSpy.mockClear();
+});
+
+test('getRelativePath', () => {
+  expect(getRelativePath('/test/1.css.d.ts', '/test/1.css')).toBe('./1.css');
+  expect(getRelativePath('/test/1.css.d.ts', '/test/dir/1.css')).toBe('./dir/1.css');
+  expect(getRelativePath('/test/1.css.d.ts', '/1.css')).toBe('../1.css');
+});
+
+test('isSubDirectoryFile', () => {
+  expect(isSubDirectoryFile('/test', '/test/src/1.css')).toBe(true);
+  expect(isSubDirectoryFile('/test', '/test/dist/1.css')).toBe(true);
+  expect(isSubDirectoryFile('/test', '/1.css')).toBe(false);
+});
+
+describe('emitGeneratedFiles', () => {
+  const defaultArgs = {
+    filePath: getFixturePath('/test/1.css'),
+    tokens: [fakeToken({ name: 'foo', originalLocations: [{ start: { line: 1, column: 1 } }] })],
+    distOptions: undefined,
+    emitDeclarationMap: true,
+    dtsFormatOptions: undefined,
+    silent: true,
+    cwd: getFixturePath('/test'),
+    isExternalFile: () => false,
+  };
+  beforeEach(() => {
+    createFixtures({
+      '/test': {}, // empty directory
+    });
+  });
+  test('generates .d.ts and .d.ts.map', async () => {
+    await emitGeneratedFiles({ ...defaultArgs });
+    expect(await exists(getFixturePath('/test/1.css.d.ts'))).toBeTruthy();
+    // A link to the source map is embedded.
+    expect(await readFile(getFixturePath('/test/1.css.d.ts'), 'utf8')).toEqual(
+      expect.stringContaining('//# sourceMappingURL=./1.css.d.ts.map'),
+    );
+    expect(await exists(getFixturePath('/test/1.css.d.ts.map'))).toBeTruthy();
+  });
+  test('generates only .d.ts and .d.ts.map if emitDeclarationMap is false', async () => {
+    await emitGeneratedFiles({ ...defaultArgs, emitDeclarationMap: false });
+    expect(await exists(getFixturePath('/test/1.css.d.ts'))).toBeTruthy();
+    // A link to the source map is not embedded.
+    expect(await readFile(getFixturePath('/test/1.css.d.ts'), 'utf8')).toEqual(
+      expect.not.stringContaining('//# sourceMappingURL=1.css.d.ts.map'),
+    );
+    expect(await exists(getFixturePath('/test/1.css.d.ts.map'))).toBeFalsy();
+  });
+  test('skips writing to disk if the generated files are the same', async () => {
+    const tokens1 = [fakeToken({ name: 'foo', originalLocations: [{ start: { line: 1, column: 1 } }] })];
+    await emitGeneratedFiles({ ...defaultArgs, tokens: tokens1 });
+    const mtimeForDts1 = (await stat(getFixturePath('/test/1.css.d.ts'))).mtime;
+    const mtimeForSourceMap1 = (await stat(getFixturePath('/test/1.css.d.ts.map'))).mtime;
+
+    await waitForAsyncTask(1); // so that mtime changes.
+    await emitGeneratedFiles({ ...defaultArgs, tokens: tokens1 });
+    const mtimeForDts2 = (await stat(getFixturePath('/test/1.css.d.ts'))).mtime;
+    const mtimeForSourceMap2 = (await stat(getFixturePath('/test/1.css.d.ts.map'))).mtime;
+    expect(mtimeForDts1).toEqual(mtimeForDts2); // skipped
+    expect(mtimeForSourceMap1).toEqual(mtimeForSourceMap2); // skipped
+
+    await waitForAsyncTask(1); // so that mtime changes.
+    const tokens2 = [fakeToken({ name: 'bar', originalLocations: [{ start: { line: 1, column: 1 } }] })];
+    await emitGeneratedFiles({ ...defaultArgs, tokens: tokens2 });
+    const mtimeForDts3 = (await stat(getFixturePath('/test/1.css.d.ts'))).mtime;
+    const mtimeForSourceMap3 = (await stat(getFixturePath('/test/1.css.d.ts.map'))).mtime;
+    expect(mtimeForDts1).not.toEqual(mtimeForDts3); // not skipped
+    expect(mtimeForSourceMap1).not.toEqual(mtimeForSourceMap3); // not skipped
+  });
+  test('outputs write log', async () => {
+    await emitGeneratedFiles({
+      ...defaultArgs,
+      filePath: getFixturePath('/test/1.css'),
+      emitDeclarationMap: true,
+      silent: false,
+    });
+    expect(consoleLogSpy).toHaveBeenCalledTimes(2);
+    expect(consoleLogSpy).toHaveBeenNthCalledWith(1, `Wrote ${chalk.green('1.css.d.ts')}`);
+    expect(consoleLogSpy).toHaveBeenNthCalledWith(2, `Wrote ${chalk.green('1.css.d.ts.map')}`);
+    consoleLogSpy.mockClear();
+
+    await emitGeneratedFiles({
+      ...defaultArgs,
+      filePath: getFixturePath('/test/2.css'),
+      emitDeclarationMap: false,
+      silent: false,
+    });
+    expect(consoleLogSpy).toHaveBeenCalledTimes(1);
+    expect(consoleLogSpy).toHaveBeenNthCalledWith(1, `Wrote ${chalk.green('2.css.d.ts')}`);
+    consoleLogSpy.mockClear();
+
+    await emitGeneratedFiles({
+      ...defaultArgs,
+      filePath: getFixturePath('/test/3.css'),
+      emitDeclarationMap: false,
+      silent: true,
+    });
+    expect(consoleLogSpy).toHaveBeenCalledTimes(0);
+  });
+  test('changes working directory by cwd', async () => {
+    await emitGeneratedFiles({
+      ...defaultArgs,
+      filePath: getFixturePath('/test/1.css'),
+      emitDeclarationMap: false,
+      silent: false,
+      cwd: getFixturePath('/test'),
+    });
+    await emitGeneratedFiles({
+      ...defaultArgs,
+      filePath: getFixturePath('/test/1.css'),
+      emitDeclarationMap: false,
+      silent: false,
+      cwd: getFixturePath('/'),
+    });
+    expect(consoleLogSpy).toHaveBeenCalledTimes(2);
+    expect(consoleLogSpy).toHaveBeenNthCalledWith(1, `Wrote ${chalk.green('1.css.d.ts')}`);
+    expect(consoleLogSpy).toHaveBeenNthCalledWith(2, `Wrote ${chalk.green('test/1.css.d.ts')}`);
+  });
+});

package/src/emitter/index.ts

@@ -0,0 +1,92 @@
+import { dirname, isAbsolute, relative } from 'path';
+import chalk from 'chalk';
+import { type Token } from '../loader/index.js';
+import { type LocalsConvention } from '../runner.js';
+import { generateDtsContentWithSourceMap, getDtsFilePath } from './dts.js';
+import { writeFileIfChanged } from './file-system.js';
+import { generateSourceMappingURLComment, getSourceMapFilePath } from './source-map.js';
+
+export function getRelativePath(fromFilePath: string, toFilePath: string): string {
+  const resolved = relative(dirname(fromFilePath), toFilePath);
+  if (resolved.startsWith('..')) {
+    return resolved;
+  } else {
+    return './' + resolved;
+  }
+}
+
+export function isSubDirectoryFile(fromDirectory: string, toFilePath: string): boolean {
+  return isAbsolute(toFilePath) && toFilePath.startsWith(fromDirectory);
+}
+
+function outputWriteLog(cwd: string, filePath: string) {
+  console.log('Wrote ' + chalk.green(relative(cwd, filePath)));
+}
+
+/** The distribution option. */
+export type DistOptions = {
+  /** Root directory. It is absolute. */
+  rootDir: string;
+  /** The path to the output directory. It is absolute. */
+  outDir: string;
+};
+
+export type DtsFormatOptions = {
+  localsConvention?: LocalsConvention;
+};
+
+/** The options for emitter. */
+export type EmitterOptions = {
+  /** The path to the source file (i.e. `/dir/foo.css`). It is absolute. */
+  filePath: string;
+  /** The tokens exported by the source file. */
+  tokens: Token[];
+  /** The distribution option. */
+  distOptions: DistOptions | undefined;
+  /** Whether to output declaration map (i.e. `/dir/foo.css.d.ts.map`) or not. */
+  emitDeclarationMap: boolean | undefined;
+  /** The options for formatting the type definition. */
+  dtsFormatOptions: DtsFormatOptions | undefined;
+  /** Silent output. Do not show "files written" messages */
+  silent: boolean;
+  /** Working directory path. */
+  cwd: string;
+  /** Whether the file is from an external library or not. */
+  isExternalFile: (filePath: string) => boolean;
+};
+
+export async function emitGeneratedFiles({
+  filePath,
+  tokens,
+  distOptions,
+  emitDeclarationMap,
+  dtsFormatOptions,
+  silent,
+  cwd,
+  isExternalFile,
+}: EmitterOptions): Promise<void> {
+  const dtsFilePath = getDtsFilePath(filePath, distOptions);
+  const sourceMapFilePath = getSourceMapFilePath(filePath, distOptions);
+  const { dtsContent, sourceMap } = generateDtsContentWithSourceMap(
+    filePath,
+    dtsFilePath,
+    sourceMapFilePath,
+    tokens,
+    dtsFormatOptions,
+    isExternalFile,
+  );
+
+  if (emitDeclarationMap) {
+    const sourceMappingURLComment = generateSourceMappingURLComment(dtsFilePath, sourceMapFilePath);
+    await writeFileIfChanged(dtsFilePath, dtsContent + sourceMappingURLComment);
+    if (!silent) outputWriteLog(cwd, dtsFilePath);
+
+    // NOTE: tsserver does not support inline declaration maps. Therefore, sourcemap files must be output.
+    // blocked by: https://github.com/microsoft/TypeScript/issues/38966
+    await writeFileIfChanged(sourceMapFilePath, sourceMap.toString());
+    if (!silent) outputWriteLog(cwd, sourceMapFilePath);
+  } else {
+    await writeFileIfChanged(dtsFilePath, dtsContent);
+    if (!silent) outputWriteLog(cwd, dtsFilePath);
+  }
+}

package/src/emitter/source-map.test.ts

@@ -0,0 +1,20 @@
+import { EOL } from 'os';
+import { getSourceMapFilePath, generateSourceMappingURLComment } from './source-map.js';
+
+test('getSourceMapFilePath', () => {
+  expect(getSourceMapFilePath('/app/src/dir/1.css', undefined)).toBe('/app/src/dir/1.css.d.ts.map');
+  expect(getSourceMapFilePath('/app/src/dir/1.css', { rootDir: '/app', outDir: '/app/dist' })).toBe(
+    '/app/dist/src/dir/1.css.d.ts.map',
+  );
+  expect(() => getSourceMapFilePath('/tmp/src/dir/1.css', { rootDir: '/app', outDir: '/app/dist' })).toThrow();
+  expect(() => getSourceMapFilePath('/app/src/dir/1.css', { rootDir: '/app', outDir: '/tmp/dist' })).toThrow();
+});
+
+test('generateSourceMappingURLComment', () => {
+  expect(generateSourceMappingURLComment('/app/src/dir/1.css.d.ts', '/app/src/dir/1.css.d.ts.map')).toBe(
+    '//# sourceMappingURL=./1.css.d.ts.map' + EOL,
+  );
+  expect(generateSourceMappingURLComment('/app/src/dir1/1.css.d.ts', '/app/src/dir2/1.css.d.ts.map')).toBe(
+    '//# sourceMappingURL=../dir2/1.css.d.ts.map' + EOL,
+  );
+});

package/src/emitter/source-map.ts

@@ -0,0 +1,17 @@
+import { EOL } from 'os';
+import { getDtsFilePath } from './dts.js';
+import { type DistOptions, getRelativePath } from './index.js';
+
+/**
+ * Get .d.ts.map file path.
+ * @param filePath The path to the source file (i.e. `foo.css`). It is absolute.
+ * @param distOptions The distribution option.
+ * @returns The path to the .d.ts.map file. It is absolute.
+ */
+export function getSourceMapFilePath(filePath: string, distOptions: DistOptions | undefined): string {
+  return getDtsFilePath(filePath, distOptions) + '.map';
+}
+
+export function generateSourceMappingURLComment(dtsFilePath: string, sourceMapFilePath: string): string {
+  return `//# sourceMappingURL=${getRelativePath(dtsFilePath, sourceMapFilePath)}` + EOL;
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export { parseArgv } from './cli.js';
+export { run } from './runner.js';
+export { type Transformer } from './transformer/index.js';

package/src/integration-test/go-to-definition.test.ts

@@ -0,0 +1,371 @@
+import { jest } from '@jest/globals';
+import dedent from 'dedent';
+import { run } from '../runner.js';
+import { getModuleDefinitions, getMultipleIdentifierDefinitions } from '../test/tsserver.js';
+import { createFixtures, getFixturePath } from '../test/util.js';
+
+// It is heavy test, so increase timeout.
+jest.setTimeout(60 * 1000); // 60s
+
+const defaultOptions = {
+  pattern: 'test/**/*.{css,scss}',
+  silent: true,
+  declarationMap: true,
+  cwd: getFixturePath('/'),
+};
+
+test('basic', async () => {
+  createFixtures({
+    '/test/1.css': dedent`
+    .basic {}
+    .cascading {}
+    .cascading {}
+    .pseudo_class_1 {}
+    .pseudo_class_2:hover {}
+    :not(.pseudo_class_3) {}
+    .multiple_selector_1.multiple_selector_2 {}
+    .combinator_1 + .combinator_2 {}
+    @supports (display: flex) {
+      @media screen and (min-width: 900px) {
+        .at_rule {}
+      }
+    }
+    .selector_list_1, .selector_list_2 {}
+    :local .local_class_name_1 {}
+    :local {
+      .local_class_name_2 {}
+      .local_class_name_3 {}
+    }
+    :local(.local_class_name_4) {}
+    .composes_target {}
+    .composes {
+      composes: composes_target;
+    }
+    `,
+  });
+  await run({ ...defaultOptions });
+  const results = await getMultipleIdentifierDefinitions(getFixturePath(`/test/1.css`), [
+    'basic',
+    'cascading',
+    'pseudo_class_1',
+    'pseudo_class_2',
+    'pseudo_class_3',
+    'multiple_selector_1',
+    'multiple_selector_2',
+    'combinator_1',
+    'combinator_2',
+    'at_rule',
+    'selector_list_1',
+    'selector_list_2',
+    'local_class_name_1',
+    'local_class_name_2',
+    'local_class_name_3',
+    'local_class_name_4',
+    'composes_target',
+    'composes',
+  ]);
+  // FIXME: Fix an issue where the text at definition destination was incorrect.
+  expect(results).toMatchInlineSnapshot(`
+    [
+      {
+        "definitions": [
+          { file: "<fixtures>/test/1.css", text: ".basic ", start: { line: 1, offset: 1 }, end: { line: 1, offset: 8 } },
+        ],
+        "identifier": "basic",
+      },
+      {
+        "definitions": [
+          { file: "<fixtures>/test/1.css", text: ".cascading ", start: { line: 2, offset: 1 }, end: { line: 2, offset: 12 } },
+          { file: "<fixtures>/test/1.css", text: ".cascading ", start: { line: 3, offset: 1 }, end: { line: 3, offset: 12 } },
+        ],
+        "identifier": "cascading",
+      },
+      {
+        "definitions": [
+          { file: "<fixtures>/test/1.css", text: ".pseudo_class_1 ", start: { line: 4, offset: 1 }, end: { line: 4, offset: 17 } },
+        ],
+        "identifier": "pseudo_class_1",
+      },
+      {
+        "definitions": [
+          { file: "<fixtures>/test/1.css", text: ".pseudo_class_2:", start: { line: 5, offset: 1 }, end: { line: 5, offset: 17 } },
+        ],
+        "identifier": "pseudo_class_2",
+      },
+      {
+        "definitions": [
+          { file: "<fixtures>/test/1.css", text: ".pseudo_class_3)", start: { line: 6, offset: 6 }, end: { line: 6, offset: 22 } },
+        ],
+        "identifier": "pseudo_class_3",
+      },
+      {
+        "definitions": [
+          {
+      file: "<fixtures>/test/1.css",
+      text: ".multiple_selector_1.",
+      start: { line: 7, offset: 1 },
+      end: { line: 7, offset: 22 },
+    },
+        ],
+        "identifier": "multiple_selector_1",
+      },
+      {
+        "definitions": [
+          {
+      file: "<fixtures>/test/1.css",
+      text: ".multiple_selector_2 ",
+      start: { line: 7, offset: 21 },
+      end: { line: 7, offset: 42 },
+    },
+        ],
+        "identifier": "multiple_selector_2",
+      },
+      {
+        "definitions": [
+          { file: "<fixtures>/test/1.css", text: ".combinator_1 ", start: { line: 8, offset: 1 }, end: { line: 8, offset: 15 } },
+        ],
+        "identifier": "combinator_1",
+      },
+      {
+        "definitions": [
+          { file: "<fixtures>/test/1.css", text: ".combinator_2 ", start: { line: 8, offset: 17 }, end: { line: 8, offset: 31 } },
+        ],
+        "identifier": "combinator_2",
+      },
+      {
+        "definitions": [
+          { file: "<fixtures>/test/1.css", text: ".at_rule ", start: { line: 11, offset: 5 }, end: { line: 11, offset: 14 } },
+        ],
+        "identifier": "at_rule",
+      },
+      {
+        "definitions": [
+          {
+      file: "<fixtures>/test/1.css",
+      text: ".selector_list_1,",
+      start: { line: 14, offset: 1 },
+      end: { line: 14, offset: 18 },
+    },
+        ],
+        "identifier": "selector_list_1",
+      },
+      {
+        "definitions": [
+          {
+      file: "<fixtures>/test/1.css",
+      text: ".selector_list_2 ",
+      start: { line: 14, offset: 19 },
+      end: { line: 14, offset: 36 },
+    },
+        ],
+        "identifier": "selector_list_2",
+      },
+      {
+        "definitions": [
+          {
+      file: "<fixtures>/test/1.css",
+      text: ".local_class_name_1 ",
+      start: { line: 15, offset: 8 },
+      end: { line: 15, offset: 28 },
+    },
+        ],
+        "identifier": "local_class_name_1",
+      },
+      {
+        "definitions": [
+          {
+      file: "<fixtures>/test/1.css",
+      text: ".local_class_name_2 ",
+      start: { line: 17, offset: 3 },
+      end: { line: 17, offset: 23 },
+    },
+        ],
+        "identifier": "local_class_name_2",
+      },
+      {
+        "definitions": [
+          {
+      file: "<fixtures>/test/1.css",
+      text: ".local_class_name_3 ",
+      start: { line: 18, offset: 3 },
+      end: { line: 18, offset: 23 },
+    },
+        ],
+        "identifier": "local_class_name_3",
+      },
+      {
+        "definitions": [
+          {
+      file: "<fixtures>/test/1.css",
+      text: ".local_class_name_4)",
+      start: { line: 20, offset: 8 },
+      end: { line: 20, offset: 28 },
+    },
+        ],
+        "identifier": "local_class_name_4",
+      },
+      {
+        "definitions": [
+          {
+      file: "<fixtures>/test/1.css",
+      text: ".composes_target ",
+      start: { line: 21, offset: 1 },
+      end: { line: 21, offset: 18 },
+    },
+        ],
+        "identifier": "composes_target",
+      },
+      {
+        "definitions": [
+          { file: "<fixtures>/test/1.css", text: ".composes ", start: { line: 22, offset: 1 }, end: { line: 22, offset: 11 } },
+        ],
+        "identifier": "composes",
+      },
+    ]
+  `);
+  const moduleDefinitions = await getModuleDefinitions(getFixturePath('/test/1.css'));
+  expect(moduleDefinitions).toMatchInlineSnapshot(`
+    [
+      { file: "<fixtures>/test/1.css", text: "", start: { line: 1, offset: 1 }, end: { line: 1, offset: 1 } },
+    ]
+  `);
+});
+
+test('imported tokens', async () => {
+  createFixtures({
+    '/test/1.css': dedent`
+    @import './2.css';
+    .a {}
+    .b {}
+    .b {}
+    `,
+    '/test/2.css': dedent`
+    @import './3.css';
+    .c {}
+    `,
+    '/test/3.css': dedent`
+    .d {}
+    `,
+  });
+  await run({ ...defaultOptions });
+  const results = await getMultipleIdentifierDefinitions(getFixturePath(`/test/1.css`), ['a', 'b', 'c', 'd']);
+  expect(results).toMatchInlineSnapshot(`
+    [
+      {
+        "definitions": [
+          { file: "<fixtures>/test/1.css", text: ".a ", start: { line: 2, offset: 1 }, end: { line: 2, offset: 4 } },
+        ],
+        "identifier": "a",
+      },
+      {
+        "definitions": [
+          { file: "<fixtures>/test/1.css", text: ".b ", start: { line: 3, offset: 1 }, end: { line: 3, offset: 4 } },
+          { file: "<fixtures>/test/1.css", text: ".b ", start: { line: 4, offset: 1 }, end: { line: 4, offset: 4 } },
+        ],
+        "identifier": "b",
+      },
+      {
+        "definitions": [
+          { file: "<fixtures>/test/2.css", text: ".c ", start: { line: 2, offset: 1 }, end: { line: 2, offset: 4 } },
+        ],
+        "identifier": "c",
+      },
+      {
+        "definitions": [
+          { file: "<fixtures>/test/3.css", text: ".d ", start: { line: 1, offset: 1 }, end: { line: 1, offset: 4 } },
+        ],
+        "identifier": "d",
+      },
+    ]
+  `);
+});
+
+test('with transformer', async () => {
+  createFixtures({
+    '/test/1.scss': dedent`
+    @use './2.scss' as two; // sass feature test (@use)
+    @import './3.scss'; // css feature test (@import)
+    .basic { dummy: ''; }
+    .nesting {
+      dummy: '';
+      // sass feature test (nesting)
+      .nesting_1 { dummy: ''; }
+      &_2 { dummy: ''; }
+      composes: basic; // css module feature test (composes)
+      composes: d from './4.scss'; // css module feature test (composes from other file)
+    }
+    `,
+    '/test/2.scss': dedent`
+    .b_1 { dummy: ''; }
+    @mixin b_2 { dummy: ''; }
+    `,
+    '/test/3.scss': dedent`
+    .c { dummy: ''; }
+    `,
+    '/test/4.scss': dedent`
+    .d { dummy: ''; }
+    `,
+  });
+  await run({ ...defaultOptions });
+  const results = await getMultipleIdentifierDefinitions(getFixturePath(`/test/1.scss`), [
+    'basic',
+    'nesting',
+    'nesting_1',
+    'nesting_2',
+    'b_1',
+    'b_2',
+    'c',
+    'd',
+  ]);
+  expect(results).toMatchInlineSnapshot(`
+    [
+      {
+        "definitions": [
+          { file: "<fixtures>/test/1.scss", text: ".basic ", start: { line: 3, offset: 1 }, end: { line: 3, offset: 8 } },
+        ],
+        "identifier": "basic",
+      },
+      {
+        "definitions": [
+          { file: "<fixtures>/test/1.scss", text: ".nesting ", start: { line: 4, offset: 1 }, end: { line: 4, offset: 10 } },
+          { file: "<fixtures>/test/1.scss", text: ".nesting_", start: { line: 7, offset: 3 }, end: { line: 7, offset: 12 } },
+        ],
+        "identifier": "nesting",
+      },
+      {
+        "definitions": [
+          { file: "<fixtures>/test/1.scss", text: ".nesting_1 ", start: { line: 7, offset: 3 }, end: { line: 7, offset: 14 } },
+        ],
+        "identifier": "nesting_1",
+      },
+      {
+        "definitions": [
+          { file: "<fixtures>/test/1.scss", text: "&_2 { dummy", start: { line: 8, offset: 3 }, end: { line: 8, offset: 14 } },
+        ],
+        "identifier": "nesting_2",
+      },
+      {
+        "definitions": [
+          { file: "<fixtures>/test/2.scss", text: ".b_1 ", start: { line: 1, offset: 1 }, end: { line: 1, offset: 6 } },
+        ],
+        "identifier": "b_1",
+      },
+      {
+        "definitions": [],
+        "identifier": "b_2",
+      },
+      {
+        "definitions": [
+          { file: "<fixtures>/test/3.scss", text: ".c ", start: { line: 1, offset: 1 }, end: { line: 1, offset: 4 } },
+        ],
+        "identifier": "c",
+      },
+      {
+        "definitions": [
+          { file: "<fixtures>/test/4.scss", text: ".d ", start: { line: 1, offset: 1 }, end: { line: 1, offset: 4 } },
+        ],
+        "identifier": "d",
+      },
+    ]
+  `);
+});

package/src/library/README.md

@@ -0,0 +1,3 @@
+## library
+
+This is a directory to put library forks or wrappers to avoid bugs.

package/src/library/source-map/index.ts

@@ -0,0 +1,26 @@
+import { SourceNode as OriginalSourceNode, type CodeWithSourceMap } from 'source-map';
+
+// TODO: Open PR to mozilla/source-map
+
+// The type definitions bundled in the source-map package are incorrect.
+// Therefore, the type definitions are overwritten here.
+
+type Chunk = string | StrictlyTypedSourceNode | Chunk[];
+
+interface StrictlyTypedSourceNode extends OriginalSourceNode {
+  // eslint-disable-next-line @typescript-eslint/no-misused-new
+  new (line: number | null, column: number | null, source: string | null): StrictlyTypedSourceNode;
+  // eslint-disable-next-line @typescript-eslint/no-misused-new
+  new (
+    line: number | null,
+    column: number | null,
+    source: string | null,
+    chunk?: Chunk,
+    name?: string,
+  ): StrictlyTypedSourceNode;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const SourceNode: StrictlyTypedSourceNode = OriginalSourceNode as any;
+
+export { SourceNode, type CodeWithSourceMap };