@atlaspack/core 2.16.2-canary.48 → 2.16.2-canary.481

package/test/requests/WriteBundleRequest.test.ts

@@ -0,0 +1,602 @@
+import assert from 'assert';
+import {Readable} from 'stream';
+import SourceMap from '@atlaspack/source-map';
+import {
+  applyReplacementsToSourceMap,
+  applyReplacementsToVLQMappings,
+  SourceMapHashRefRewriteStream,
+  type HashRefReplacement,
+} from '../../src/requests/WriteBundleRequest';
+
+const HASH_REF = 'HASH_REF_0123456789abcdef'; // 25 chars
+const HASH_REPLACEMENT = 'a1b2c3d4'; // 8 chars
+const HASH_REF_LEN = HASH_REF.length; // 25
+const REPLACEMENT_LEN = HASH_REPLACEMENT.length; // 8
+
+/**
+ * Build a single-line code string with HASH_REF placeholders at known positions.
+ * Returns original code, replaced code, correct replacement coordinates, and
+ * identifier position tracking in both coordinate spaces.
+ */
+function buildCodeWithHashRefs(
+  segments: Array<{type: 'code'; text: string} | {type: 'hashref'}>,
+) {
+  let code = '';
+  const hashPositions: Array<{column: number}> = [];
+  const identifierPositions = new Map<string, number>();
+
+  for (const seg of segments) {
+    if (seg.type === 'hashref') {
+      hashPositions.push({column: code.length});
+      code += HASH_REF;
+    } else {
+      const regex = /[A-Z][A-Z_0-9]{3,}/g;
+      let match;
+      while ((match = regex.exec(seg.text)) !== null) {
+        identifierPositions.set(match[0], code.length + match.index);
+      }
+      code += seg.text;
+    }
+  }
+
+  // Build replaced code and compute CORRECT replacement coordinates
+  let replacedCode = '';
+  const correctReplacements: HashRefReplacement[] = [];
+  let srcIdx = 0;
+  for (const hp of hashPositions) {
+    replacedCode += code.slice(srcIdx, hp.column);
+    correctReplacements.push({
+      line: 0,
+      column: replacedCode.length,
+      originalLength: HASH_REF_LEN,
+      newLength: REPLACEMENT_LEN,
+    });
+    replacedCode += HASH_REPLACEMENT;
+    srcIdx = hp.column + HASH_REF_LEN;
+  }
+  replacedCode += code.slice(srcIdx);
+
+  // Track where identifiers end up in the replaced code
+  const replacedIdentifierPositions = new Map<string, number>();
+  for (const [name] of identifierPositions) {
+    const idx = replacedCode.indexOf(name);
+    if (idx >= 0) replacedIdentifierPositions.set(name, idx);
+  }
+
+  return {
+    originalCode: code,
+    replacedCode,
+    correctReplacements,
+    identifierPositions,
+    replacedIdentifierPositions,
+  };
+}
+
+/**
+ * Drains a Readable stream into a single Buffer.
+ */
+function streamToBuffer(stream: Readable): Promise<Buffer> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    stream.on('data', (chunk: Buffer) => chunks.push(chunk));
+    stream.on('end', () => resolve(Buffer.concat(chunks)));
+    stream.on('error', reject);
+  });
+}
+
+/**
+ * Cross-checks applyReplacementsToVLQMappings against the native
+ * applyReplacementsToSourceMap by building a SourceMap, running both
+ * implementations, and asserting identical VLQ output.
+ */
+function crossCheck(sm: SourceMap, replacements: HashRefReplacement[]): void {
+  const vlqBefore = sm.toVLQ().mappings;
+  const vlqResult = applyReplacementsToVLQMappings(vlqBefore, replacements);
+  applyReplacementsToSourceMap(sm, replacements);
+  const nativeResult = sm.toVLQ().mappings;
+  assert.strictEqual(
+    vlqResult,
+    nativeResult,
+    `VLQ result differs from native:\n  VLQ:    ${vlqResult}\n  native: ${nativeResult}`,
+  );
+}
+
+describe('applyReplacementsToSourceMap', () => {
+  describe('with correct replacement coordinates', () => {
+    it('should correctly adjust a single HASH_REF replacement', () => {
+      const {
+        correctReplacements,
+        identifierPositions,
+        replacedIdentifierPositions,
+      } = buildCodeWithHashRefs([
+        {type: 'hashref'},
+        {type: 'code', text: ';var x=SOME_IDENT;'},
+      ]);
+
+      const origCol = identifierPositions.get('SOME_IDENT')!;
+      const expectedCol = replacedIdentifierPositions.get('SOME_IDENT')!;
+
+      const sm = new SourceMap('/');
+      sm.addIndexedMapping({
+        generated: {line: 1, column: origCol},
+        original: {line: 10, column: 5},
+        source: 'test.js',
+      });
+
+      applyReplacementsToSourceMap(sm, correctReplacements);
+
+      const mappings = sm.getMap().mappings;
+      const mapping = mappings.find(
+        (m) => m.original?.line === 10 && m.original?.column === 5,
+      );
+      assert.ok(mapping, 'Mapping should exist');
+      assert.strictEqual(mapping!.generated.column, expectedCol);
+    });
+
+    it('should correctly adjust multiple HASH_REF replacements on the same line', () => {
+      const {
+        correctReplacements,
+        identifierPositions,
+        replacedIdentifierPositions,
+      } = buildCodeWithHashRefs([
+        {type: 'hashref'},
+        {type: 'code', text: ';var a=IDENT_ALPHA;require("'},
+        {type: 'hashref'},
+        {type: 'code', text: '");var b=IDENT_BETA;require("'},
+        {type: 'hashref'},
+        {type: 'code', text: '");var c=IDENT_GAMMA;'},
+      ]);
+
+      const sm = new SourceMap('/');
+      sm.addIndexedMapping({
+        generated: {line: 1, column: identifierPositions.get('IDENT_ALPHA')!},
+        original: {line: 10, column: 0},
+        source: 'test.js',
+      });
+      sm.addIndexedMapping({
+        generated: {line: 1, column: identifierPositions.get('IDENT_BETA')!},
+        original: {line: 20, column: 0},
+        source: 'test.js',
+      });
+      sm.addIndexedMapping({
+        generated: {line: 1, column: identifierPositions.get('IDENT_GAMMA')!},
+        original: {line: 30, column: 0},
+        source: 'test.js',
+      });
+
+      applyReplacementsToSourceMap(sm, correctReplacements);
+
+      const mappings = sm.getMap().mappings;
+      for (const [name, origLine] of [
+        ['IDENT_ALPHA', 10],
+        ['IDENT_BETA', 20],
+        ['IDENT_GAMMA', 30],
+      ] as const) {
+        const mapping = mappings.find((m) => m.original?.line === origLine);
+        const expectedCol = replacedIdentifierPositions.get(name)!;
+        assert.ok(mapping, `${name} mapping should exist`);
+        assert.strictEqual(
+          mapping!.generated.column,
+          expectedCol,
+          `${name}: expected col ${expectedCol}, got ${mapping!.generated.column}`,
+        );
+      }
+    });
+
+    it('should handle 10 replacements on the same line', () => {
+      const segments: Array<{type: 'code'; text: string} | {type: 'hashref'}> =
+        [];
+      for (let i = 0; i < 10; i++) {
+        segments.push({type: 'hashref'});
+        segments.push({
+          type: 'code',
+          text: `;var x${i}=TARGET_${String(i).padStart(2, '0')};require("`,
+        });
+      }
+      segments.push({type: 'code', text: '");'});
+
+      const {
+        correctReplacements,
+        identifierPositions,
+        replacedIdentifierPositions,
+      } = buildCodeWithHashRefs(segments);
+
+      const sm = new SourceMap('/');
+      for (let i = 0; i < 10; i++) {
+        const name = `TARGET_${String(i).padStart(2, '0')}`;
+        sm.addIndexedMapping({
+          generated: {line: 1, column: identifierPositions.get(name)!},
+          original: {line: (i + 1) * 10, column: 0},
+          source: 'test.js',
+        });
+      }
+
+      applyReplacementsToSourceMap(sm, correctReplacements);
+
+      const mappings = sm.getMap().mappings;
+      for (let i = 0; i < 10; i++) {
+        const name = `TARGET_${String(i).padStart(2, '0')}`;
+        const mapping = mappings.find((m) => m.original?.line === (i + 1) * 10);
+        const expectedCol = replacedIdentifierPositions.get(name)!;
+        assert.ok(mapping, `${name} mapping should exist`);
+        assert.strictEqual(
+          mapping!.generated.column,
+          expectedCol,
+          `${name}: expected col ${expectedCol}, got ${mapping!.generated.column}`,
+        );
+      }
+    });
+
+    it('should not affect mappings before the first HASH_REF', () => {
+      const {
+        correctReplacements,
+        identifierPositions,
+        replacedIdentifierPositions,
+      } = buildCodeWithHashRefs([
+        {type: 'code', text: 'var BEFORE_HASH=1;'},
+        {type: 'hashref'},
+        {type: 'code', text: ';var AFTER_HASH=2;'},
+      ]);
+
+      const sm = new SourceMap('/');
+      sm.addIndexedMapping({
+        generated: {line: 1, column: identifierPositions.get('BEFORE_HASH')!},
+        original: {line: 1, column: 0},
+        source: 'test.js',
+      });
+      sm.addIndexedMapping({
+        generated: {line: 1, column: identifierPositions.get('AFTER_HASH')!},
+        original: {line: 2, column: 0},
+        source: 'test.js',
+      });
+
+      applyReplacementsToSourceMap(sm, correctReplacements);
+
+      const mappings = sm.getMap().mappings;
+      const beforeMapping = mappings.find((m) => m.original?.line === 1);
+      assert.ok(beforeMapping);
+      assert.strictEqual(
+        beforeMapping!.generated.column,
+        replacedIdentifierPositions.get('BEFORE_HASH'),
+      );
+
+      const afterMapping = mappings.find((m) => m.original?.line === 2);
+      assert.ok(afterMapping);
+      assert.strictEqual(
+        afterMapping!.generated.column,
+        replacedIdentifierPositions.get('AFTER_HASH'),
+      );
+    });
+  });
+});
+
+describe('applyReplacementsToVLQMappings', () => {
+  it('returns the same string for empty replacements', () => {
+    const sm = new SourceMap('/');
+    sm.addIndexedMapping({
+      generated: {line: 1, column: 10},
+      original: {line: 1, column: 0},
+      source: 'test.js',
+    });
+    const vlq = sm.toVLQ().mappings;
+    assert.strictEqual(applyReplacementsToVLQMappings(vlq, []), vlq);
+  });
+
+  it('returns the same string for a zero-delta replacement', () => {
+    const sm = new SourceMap('/');
+    sm.addIndexedMapping({
+      generated: {line: 1, column: 30},
+      original: {line: 1, column: 0},
+      source: 'test.js',
+    });
+    const vlq = sm.toVLQ().mappings;
+    const repl: HashRefReplacement[] = [
+      {line: 0, column: 0, originalLength: 10, newLength: 10},
+    ];
+    assert.strictEqual(applyReplacementsToVLQMappings(vlq, repl), vlq);
+  });
+
+  it('single replacement agrees with native', () => {
+    const {correctReplacements, identifierPositions} = buildCodeWithHashRefs([
+      {type: 'hashref'},
+      {type: 'code', text: ';var x=SOME_IDENT;'},
+    ]);
+    const sm = new SourceMap('/');
+    sm.addIndexedMapping({
+      generated: {line: 1, column: identifierPositions.get('SOME_IDENT')!},
+      original: {line: 10, column: 5},
+      source: 'test.js',
+    });
+    crossCheck(sm, correctReplacements);
+  });
+
+  it('multiple replacements on the same line agree with native', () => {
+    const {correctReplacements, identifierPositions} = buildCodeWithHashRefs([
+      {type: 'hashref'},
+      {type: 'code', text: ';var a=IDENT_ALPHA;require("'},
+      {type: 'hashref'},
+      {type: 'code', text: '");var b=IDENT_BETA;require("'},
+      {type: 'hashref'},
+      {type: 'code', text: '");var c=IDENT_GAMMA;'},
+    ]);
+    const sm = new SourceMap('/');
+    for (const [name, origLine] of [
+      ['IDENT_ALPHA', 10],
+      ['IDENT_BETA', 20],
+      ['IDENT_GAMMA', 30],
+    ] as const) {
+      sm.addIndexedMapping({
+        generated: {line: 1, column: identifierPositions.get(name)!},
+        original: {line: origLine, column: 0},
+        source: 'test.js',
+      });
+    }
+    crossCheck(sm, correctReplacements);
+  });
+
+  it('10 replacements on the same line agree with native', () => {
+    const segments: Array<{type: 'code'; text: string} | {type: 'hashref'}> =
+      [];
+    for (let i = 0; i < 10; i++) {
+      segments.push({type: 'hashref'});
+      segments.push({
+        type: 'code',
+        text: `;var x${i}=TARGET_${String(i).padStart(2, '0')};require("`,
+      });
+    }
+    segments.push({type: 'code', text: '");'});
+
+    const {correctReplacements, identifierPositions} =
+      buildCodeWithHashRefs(segments);
+
+    const sm = new SourceMap('/');
+    for (let i = 0; i < 10; i++) {
+      const name = `TARGET_${String(i).padStart(2, '0')}`;
+      sm.addIndexedMapping({
+        generated: {line: 1, column: identifierPositions.get(name)!},
+        original: {line: (i + 1) * 10, column: 0},
+        source: 'test.js',
+      });
+    }
+    crossCheck(sm, correctReplacements);
+  });
+
+  it('mapping before the threshold is unaffected', () => {
+    const {correctReplacements, identifierPositions} = buildCodeWithHashRefs([
+      {type: 'code', text: 'var BEFORE_HASH=1;'},
+      {type: 'hashref'},
+      {type: 'code', text: ';var AFTER_HASH=2;'},
+    ]);
+    const sm = new SourceMap('/');
+    sm.addIndexedMapping({
+      generated: {line: 1, column: identifierPositions.get('BEFORE_HASH')!},
+      original: {line: 1, column: 0},
+      source: 'test.js',
+    });
+    sm.addIndexedMapping({
+      generated: {line: 1, column: identifierPositions.get('AFTER_HASH')!},
+      original: {line: 2, column: 0},
+      source: 'test.js',
+    });
+    crossCheck(sm, correctReplacements);
+  });
+
+  it('mapping on a different line is unaffected', () => {
+    const sm = new SourceMap('/');
+    // Line 0 (VLQ line index 0): hash ref at col 0, mapping at col 50
+    // Line 1 (VLQ line index 1): mapping at col 5 – should be untouched
+    sm.addIndexedMapping({
+      generated: {line: 1, column: 50},
+      original: {line: 10, column: 0},
+      source: 'test.js',
+    });
+    sm.addIndexedMapping({
+      generated: {line: 2, column: 5},
+      original: {line: 20, column: 0},
+      source: 'test.js',
+    });
+
+    const replacements: HashRefReplacement[] = [
+      {
+        line: 0,
+        column: 0,
+        originalLength: HASH_REF_LEN,
+        newLength: REPLACEMENT_LEN,
+      },
+    ];
+
+    const vlqBefore = sm.toVLQ().mappings;
+    const vlqResult = applyReplacementsToVLQMappings(vlqBefore, replacements);
+    applyReplacementsToSourceMap(sm, replacements);
+
+    // Verify the line-1 mapping is unchanged by checking parsed values
+    const mappings = sm.getMap().mappings;
+    const line2Mapping = mappings.find((m) => m.original?.line === 20);
+    assert.ok(line2Mapping, 'Line 2 mapping should exist');
+    assert.strictEqual(line2Mapping!.generated.column, 5);
+
+    // Also verify VLQ agrees with native
+    assert.strictEqual(vlqResult, sm.toVLQ().mappings);
+  });
+});
+
+describe('SourceMapHashRefRewriteStream', () => {
+  async function applyStream(
+    json: string,
+    replacements: HashRefReplacement[],
+    chunkSize?: number,
+  ): Promise<string> {
+    const inputBuf = Buffer.from(json, 'utf8');
+    let readable: Readable;
+    if (chunkSize != null) {
+      readable = new Readable({
+        read() {
+          let offset = 0;
+          while (offset < inputBuf.length) {
+            this.push(inputBuf.slice(offset, offset + chunkSize));
+            offset += chunkSize;
+          }
+          this.push(null);
+        },
+      });
+    } else {
+      readable = Readable.from([inputBuf]);
+    }
+    const outBuf = await streamToBuffer(
+      readable.pipe(new SourceMapHashRefRewriteStream(replacements)),
+    );
+    return outBuf.toString('utf8');
+  }
+
+  it('full round-trip: mappings field is correctly rewritten', async () => {
+    const {correctReplacements, identifierPositions} = buildCodeWithHashRefs([
+      {type: 'hashref'},
+      {type: 'code', text: ';var x=SOME_IDENT;'},
+    ]);
+
+    const sm = new SourceMap('/');
+    sm.addIndexedMapping({
+      generated: {line: 1, column: identifierPositions.get('SOME_IDENT')!},
+      original: {line: 10, column: 5},
+      source: 'test.js',
+    });
+
+    const vlqBefore = sm.toVLQ().mappings;
+    const expectedMappings = applyReplacementsToVLQMappings(
+      vlqBefore,
+      correctReplacements,
+    );
+
+    const mapJson = await sm.stringify({format: 'string'});
+    const outputJson = await applyStream(
+      mapJson as string,
+      correctReplacements,
+    );
+    const parsed = JSON.parse(outputJson);
+
+    assert.strictEqual(parsed.mappings, expectedMappings);
+  });
+
+  it('bytes after mappings (sourcesContent) pass through unchanged', async () => {
+    const sm = new SourceMap('/');
+    sm.addIndexedMapping({
+      generated: {line: 1, column: 30},
+      original: {line: 5, column: 0},
+      source: 'test.js',
+    });
+    sm.setSourceContent('test.js', 'const x = 1;\nconst y = 2;\n');
+
+    const replacements: HashRefReplacement[] = [
+      {
+        line: 0,
+        column: 0,
+        originalLength: HASH_REF_LEN,
+        newLength: REPLACEMENT_LEN,
+      },
+    ];
+
+    const mapJson = (await sm.stringify({format: 'string'})) as string;
+    const outputJson = await applyStream(mapJson, replacements);
+    const parsedInput = JSON.parse(mapJson);
+    const parsedOutput = JSON.parse(outputJson);
+
+    // sourcesContent must be byte-for-byte identical
+    assert.deepStrictEqual(
+      parsedOutput.sourcesContent,
+      parsedInput.sourcesContent,
+    );
+    assert.deepStrictEqual(parsedOutput.sources, parsedInput.sources);
+    assert.deepStrictEqual(parsedOutput.names, parsedInput.names);
+  });
+
+  it('handles chunk boundaries mid-key', async () => {
+    const {correctReplacements, identifierPositions} = buildCodeWithHashRefs([
+      {type: 'hashref'},
+      {type: 'code', text: ';var x=SOME_IDENT;'},
+    ]);
+
+    const sm = new SourceMap('/');
+    sm.addIndexedMapping({
+      generated: {line: 1, column: identifierPositions.get('SOME_IDENT')!},
+      original: {line: 10, column: 5},
+      source: 'test.js',
+    });
+
+    const vlqBefore = sm.toVLQ().mappings;
+    const expectedMappings = applyReplacementsToVLQMappings(
+      vlqBefore,
+      correctReplacements,
+    );
+
+    const mapJson = (await sm.stringify({format: 'string'})) as string;
+
+    // Test multiple chunk sizes to exercise boundary conditions.
+    for (const chunkSize of [1, 3, 7, 11, 13]) {
+      const outputJson = await applyStream(
+        mapJson,
+        correctReplacements,
+        chunkSize,
+      );
+      const parsed = JSON.parse(outputJson);
+      assert.strictEqual(
+        parsed.mappings,
+        expectedMappings,
+        `Chunk size ${chunkSize}: mappings mismatch`,
+      );
+    }
+  });
+
+  it('handles chunk boundaries mid-value', async () => {
+    // Use a source map with a longer mappings string to ensure the VLQ value
+    // spans multiple chunks for small chunk sizes.
+    const sm = new SourceMap('/');
+    for (let i = 0; i < 20; i++) {
+      sm.addIndexedMapping({
+        generated: {line: 1, column: i * 5},
+        original: {line: i + 1, column: 0},
+        source: 'test.js',
+      });
+    }
+
+    const replacements: HashRefReplacement[] = [
+      {
+        line: 0,
+        column: 10,
+        originalLength: HASH_REF_LEN,
+        newLength: REPLACEMENT_LEN,
+      },
+    ];
+
+    const vlqBefore = sm.toVLQ().mappings;
+    const expectedMappings = applyReplacementsToVLQMappings(
+      vlqBefore,
+      replacements,
+    );
+
+    const mapJson = (await sm.stringify({format: 'string'})) as string;
+
+    for (const chunkSize of [1, 5, 8]) {
+      const outputJson = await applyStream(mapJson, replacements, chunkSize);
+      const parsed = JSON.parse(outputJson);
+      assert.strictEqual(
+        parsed.mappings,
+        expectedMappings,
+        `Chunk size ${chunkSize}: mappings mismatch`,
+      );
+    }
+  });
+
+  it('no-op for empty replacements – output equals input', async () => {
+    const sm = new SourceMap('/');
+    sm.addIndexedMapping({
+      generated: {line: 1, column: 10},
+      original: {line: 1, column: 0},
+      source: 'test.js',
+    });
+
+    const mapJson = (await sm.stringify({format: 'string'})) as string;
+    const outputJson = await applyStream(mapJson, []);
+
+    assert.strictEqual(outputJson, mapJson);
+  });
+});

package/test/{test-utils.js → test-utils.ts}

@@ -1,6 +1,4 @@
-// @flow strict-local
-
-import type {Environment, AtlaspackOptions, Target} from '../src/types';
+import type {AtlaspackOptions, Target} from '../src/types';
 
 import {DEFAULT_FEATURE_FLAGS} from '@atlaspack/feature-flags';
 import {inputFS, outputFS, cache, cacheDir} from '@atlaspack/test-utils';
@@ -8,6 +6,7 @@ import {relativePath} from '@atlaspack/utils';
 import {NodePackageManager} from '@atlaspack/package-manager';
 import {createEnvironment} from '../src/Environment';
 import {toProjectPath} from '../src/projectPath';
+import type {EnvironmentRef} from '../src/EnvironmentManager';
 
 export const DEFAULT_OPTIONS: AtlaspackOptions = {
   cacheDir,
@@ -51,7 +50,7 @@ export const DEFAULT_OPTIONS: AtlaspackOptions = {
   },
 };
 
-export const DEFAULT_ENV: Environment = createEnvironment({
+export const DEFAULT_ENV: EnvironmentRef = createEnvironment({
   context: 'browser',
   engines: {
     browsers: ['> 1%'],

package/test/{utils.test.js → utils.test.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import assert from 'assert';
 import {getPublicId} from '../src/utils';
 
@@ -28,7 +26,7 @@ describe('getPublicId', () => {
 
   it('uses more characters if there is a collision', () => {
     assert.equal(
-      getPublicId(id, (publicId) =>
+      getPublicId(id, (publicId: any) =>
         [fullPublicId.slice(0, 5), fullPublicId.slice(0, 6)].includes(publicId),
       ),
       fullPublicId.slice(0, 7),

package/tsconfig.json

@@ -0,0 +1,60 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "include": ["./src/", "./package.json"],
+  "compilerOptions": {
+    "composite": true
+  },
+  "references": [
+    {
+      "path": "../../dev/babel-register/tsconfig.json"
+    },
+    {
+      "path": "../../utils/events/tsconfig.json"
+    },
+    {
+      "path": "../build-cache/tsconfig.json"
+    },
+    {
+      "path": "../cache/tsconfig.json"
+    },
+    {
+      "path": "../diagnostic/tsconfig.json"
+    },
+    {
+      "path": "../feature-flags/tsconfig.json"
+    },
+    {
+      "path": "../fs/tsconfig.json"
+    },
+    {
+      "path": "../graph/tsconfig.json"
+    },
+    {
+      "path": "../logger/tsconfig.json"
+    },
+    {
+      "path": "../package-manager/tsconfig.json"
+    },
+    {
+      "path": "../plugin/tsconfig.json"
+    },
+    {
+      "path": "../profiler/tsconfig.json"
+    },
+    {
+      "path": "../rust/tsconfig.json"
+    },
+    {
+      "path": "../types/tsconfig.json"
+    },
+    {
+      "path": "../utils/tsconfig.json"
+    },
+    {
+      "path": "../workers/tsconfig.json"
+    },
+    {
+      "path": "../source-map/tsconfig.json"
+    }
+  ]
+}