@yamato-daiwa/automation 0.5.0-alpha.1 → 0.5.0-alpha.3

package/EntryPoint.js

@@ -3177,12 +3177,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports["default"] = mustProvideIncrementalProjectBuilding;
 const ConsumingProjectBuildingModes_1 = __importDefault(__webpack_require__(/*! @ProjectBuilding/Common/Restrictions/ConsumingProjectBuildingModes */ "./ProjectBuilding/Common/Restrictions/ConsumingProjectBuildingModes.ts"));
 function mustProvideIncrementalProjectBuilding(consumingProjectBuildingModes) {
     return consumingProjectBuildingModes === ConsumingProjectBuildingModes_1.default.staticPreview ||
         consumingProjectBuildingModes === ConsumingProjectBuildingModes_1.default.localDevelopment;
 }
-exports["default"] = mustProvideIncrementalProjectBuilding;
 
 
 /***/ }),
@@ -5000,7 +5000,11 @@ class PlainCopyingRawSettingsNormalizer {
             ], { alwaysForwardSlashSeparators: true });
             sourceAndOutputFilesAbsolutePathsCorrespondenceMapForCurrentGroup.set(sourceFileAbsolutePath, outputFileAbsolutePath);
         }
-        (0, es_extensions_1.addMultiplePairsToMap)(PlainCopyingSharedState_1.default.sourceFilesAbsolutePathsAndRespectiveFilesGroupSettingsCorrespondenceMap, sourceAndOutputFilesAbsolutePathsCorrespondenceMapForCurrentGroup);
+        (0, es_extensions_1.addEntriesToMap)({
+            targetMap: PlainCopyingSharedState_1.default.sourceFilesAbsolutePathsAndRespectiveFilesGroupSettingsCorrespondenceMap,
+            newEntries: sourceAndOutputFilesAbsolutePathsCorrespondenceMapForCurrentGroup,
+            mutably: true
+        });
         return {
             aliasName,
             sourceTopDirectoryAbsolutePath,
@@ -6571,7 +6575,16 @@ class ECMA_ScriptLogicProcessingRawSettingsNormalizer extends SourceCodeProcessi
     static createDirectoriesAliasesAndCorrespondingAbsolutePathsMap(typeScriptConfigurationFileAbsolutePath, typeScriptCompilerOptions) {
         /* [ TypeScript theory ] If `baseUrl` has been specified in configuration file, once parsed, it will be the
          +   absolute path herewith forward slashes path separators. */
-        const typeScriptBasicAbsolutePath = typeScriptCompilerOptions.baseUrl ?? typeScriptConfigurationFileAbsolutePath;
+        const typeScriptBasicAbsolutePath = typeScriptCompilerOptions.baseUrl ??
+            es_extensions_nodejs_1.ImprovedPath.extractDirectoryFromFilePath({
+                targetPath: typeScriptConfigurationFileAbsolutePath,
+                alwaysForwardSlashSeparators: true,
+                ambiguitiesResolution: {
+                    mustConsiderLastSegmentWihtoutDotsAsFileNameWithoutExtension: true,
+                    mustConsiderLastSegmentStartingWithDotAsDirectory: false,
+                    mustConsiderLastSegmentWithNonLeadingDotAsDirectory: false
+                }
+            });
         return new Map(Object.entries(typeScriptCompilerOptions.paths ?? {}).map(([rawAlias, rawPaths]) => [
             rawAlias.endsWith("/*") ? rawAlias.slice(0, -"/*".length) : rawAlias,
             rawPaths.map((rawPath) => es_extensions_nodejs_1.ImprovedPath.joinPathSegments([
@@ -7019,8 +7032,11 @@ const es_extensions_nodejs_1 = __webpack_require__(/*! @yamato-daiwa/es-extensio
 class ECMA_ScriptLogicProcessor {
     static ENTRY_POINTS_AND_PARTIAL_FILES_MAPPING_CACHE_FILE_NAME_WITH_EXTENSION = "ECMA_ScriptEntryPointsAndAffiliatedFilesMappingCache.json";
     TASK_NAME_FOR_LOGGING = "ECMAScript logic processing";
-    masterConfigRepresentative;
+    projectBuildingMasterConfigRepresentative;
     ECMA_ScriptLogicProcessingConfigRepresentative;
+    webpackConfigurationsForExistingEntryPoints;
+    webpackMultiCompiler;
+    entryPointsSourceFilesAbsolutePathsAndWebpackConfigurationNamesMap;
     absolutePathOfFilesWaitingForReProcessing = new Set();
     sourceCodeSelectiveReprocessingHelper;
     subsequentFilesStateChangeTimeout = null;
@@ -7030,57 +7046,66 @@ class ECMA_ScriptLogicProcessor {
             return (callback) => { callback(); };
         }
         const dataHoldingSelfInstance = new ECMA_ScriptLogicProcessor(ecmaScriptLogicProcessingSettingsRepresentative, projectBuildingMasterConfigRepresentative);
-        const webpackConfigurationsForExistingEntryPoints = [];
-        const entryPointsSourceFilesAbsolutePathsAndWebpackConfigurationNamesMap = new Map();
-        for (const [index, ECMA_ScriptLogicEntryPointsGroupSettings] of Array.from(ecmaScriptLogicProcessingSettingsRepresentative.relevantEntryPointsGroupsSettings.values()).entries()) {
-            const entryPointsSourceFileAbsolutePaths = es_extensions_nodejs_1.ImprovedGlob.getFilesAbsolutePathsSynchronously(ECMA_ScriptLogicEntryPointsGroupSettings.sourceFilesGlobSelectors, { alwaysForwardSlashSeparators: true });
-            if (entryPointsSourceFileAbsolutePaths.length === 0) {
-                es_extensions_1.Logger.logWarning({
-                    title: "ECMAScript logic Entry Points Not Found",
-                    description: `No ECMAScript entry points has been found for group "${ECMA_ScriptLogicEntryPointsGroupSettings.ID}".` +
-                        "Please restart the project building once they will be added."
-                });
-                continue;
-            }
-            webpackConfigurationsForExistingEntryPoints.push(WebpackConfigGenerator_1.default.generateWebpackConfigurationForEntryPointsGroupWithExistingFiles({
-                entryPointsSourceFilesAbsolutePaths: entryPointsSourceFileAbsolutePaths,
-                ECMA_ScriptLogicEntryPointsGroupSettings,
-                ECMA_ScriptLogicProcessingConfigRepresentative: ecmaScriptLogicProcessingSettingsRepresentative,
-                masterConfigRepresentative: projectBuildingMasterConfigRepresentative,
-                mustProvideTypeScriptTypeChecking: index === 0
-            }));
-            (0, es_extensions_1.addMultiplePairsToMap)(entryPointsSourceFilesAbsolutePathsAndWebpackConfigurationNamesMap, entryPointsSourceFileAbsolutePaths.map((entryPointsSourceFileAbsolutePath) => [entryPointsSourceFileAbsolutePath, ECMA_ScriptLogicEntryPointsGroupSettings.ID]));
-        }
         return (gulpCallback) => {
             try {
-                /* [ Webpack theory ] Although there is no `null` hardError is type definitions, the `hardError` could be null. */
-                (0, webpack_1.default)(webpackConfigurationsForExistingEntryPoints, dataHoldingSelfInstance.generateWebpackCallback(gulpCallback));
+                dataHoldingSelfInstance.webpackMultiCompiler.run(dataHoldingSelfInstance.generateWebpackCallback(gulpCallback));
             }
             catch (error) {
                 /* [ Theory ] Once reached here, the Gulp tasks chain will collapse whatever will callback called to no. */
                 es_extensions_1.Logger.logError({
                     errorType: es_extensions_1.UnexpectedEventError.NAME,
                     title: es_extensions_1.UnexpectedEventError.localization.defaultTitle,
-                    description: "依存性の'Webpack'の実行中エラーが発生した。'webpack'関数の呼び出しを'try/catch'に包めなければいけない事に就いて説明書" +
-                        "(https://webpack.js.org/api/node/)に書いてはないが、今は'catch'に当たった状態だ。'Gulp'課題鎖が崩れない様に、エラーを再投擲無しで捕まえた。",
+                    description: "The error emitted by Webpack has been caught while no error catching required according the official" +
+                        "documentation: https://webpack.js.org/api/node/",
                     occurrenceLocation: "ECMA_ScriptLogicProcessor.provideLogicProcessing(projectBuildingMasterConfigRepresentative)",
                     caughtError: error
                 });
             }
+            gulpCallback();
         };
     }
     constructor(ecmaScriptLogicProcessingConfigRepresentative, masterConfigRepresentative) {
         this.ECMA_ScriptLogicProcessingConfigRepresentative = ecmaScriptLogicProcessingConfigRepresentative;
-        this.masterConfigRepresentative = masterConfigRepresentative;
-        if (this.masterConfigRepresentative.mustProvideIncrementalBuilding) {
+        this.projectBuildingMasterConfigRepresentative = masterConfigRepresentative;
+        const webpackConfigurationsForExistingEntryPoints = [];
+        const entryPointsSourceFilesAbsolutePathsAndWebpackConfigurationNamesMap = new Map();
+        for (const [index, ECMA_ScriptLogicEntryPointsGroupSettings] of Array.from(this.ECMA_ScriptLogicProcessingConfigRepresentative.relevantEntryPointsGroupsSettings.values()).entries()) {
+            const entryPointsSourceFilesAbsolutePaths = es_extensions_nodejs_1.ImprovedGlob.getFilesAbsolutePathsSynchronously(ECMA_ScriptLogicEntryPointsGroupSettings.sourceFilesGlobSelectors, { alwaysForwardSlashSeparators: true });
+            if (entryPointsSourceFilesAbsolutePaths.length === 0) {
+                es_extensions_1.Logger.logWarning({
+                    title: "ECMAScript Logic Entry Points Not Found",
+                    description: `No ECMAScript entry points has been found for group "${ECMA_ScriptLogicEntryPointsGroupSettings.ID}". ` +
+                        "Please restart the project building once they will be added."
+                });
+                continue;
+            }
+            webpackConfigurationsForExistingEntryPoints.push(WebpackConfigGenerator_1.default.generateWebpackConfigurationForEntryPointsGroupWithExistingFiles({
+                entryPointsSourceFilesAbsolutePaths,
+                ECMA_ScriptLogicEntryPointsGroupSettings,
+                ECMA_ScriptLogicProcessingConfigRepresentative: this.ECMA_ScriptLogicProcessingConfigRepresentative,
+                masterConfigRepresentative: this.projectBuildingMasterConfigRepresentative,
+                mustProvideTypeScriptTypeChecking: index === 0
+            }));
+            (0, es_extensions_1.addEntriesToMap)({
+                targetMap: entryPointsSourceFilesAbsolutePathsAndWebpackConfigurationNamesMap,
+                newEntries: entryPointsSourceFilesAbsolutePaths.map((entryPointsSourceFileAbsolutePath) => [entryPointsSourceFileAbsolutePath, ECMA_ScriptLogicEntryPointsGroupSettings.ID]),
+                mutably: true
+            });
+        }
+        this.webpackConfigurationsForExistingEntryPoints = webpackConfigurationsForExistingEntryPoints;
+        this.webpackMultiCompiler = (0, webpack_1.default)(this.webpackConfigurationsForExistingEntryPoints);
+        this.entryPointsSourceFilesAbsolutePathsAndWebpackConfigurationNamesMap =
+            entryPointsSourceFilesAbsolutePathsAndWebpackConfigurationNamesMap;
+        if (this.projectBuildingMasterConfigRepresentative.mustProvideIncrementalBuilding) {
             this.sourceCodeSelectiveReprocessingHelper = new SourceCodeSelectiveReprocessingHelper_1.default({
                 initialEntryPointsSourceFilesAbsolutePaths: this.ECMA_ScriptLogicProcessingConfigRepresentative.initialRelevantEntryPointsSourceFilesAbsolutePaths,
-                affiliatedFilesResolutionRules: {
-                    affiliatedFilesIncludingDeclarationsPatterns: ECMA_ScriptSpecialist_1.default.partialFilesIncludingDeclarationPatterns,
-                    implicitFilesNamesExtensionsWithoutLeadingDotsOfAffiliatedFiles: this.ECMA_ScriptLogicProcessingConfigRepresentative.
+                childrenFilesResolutionRules: {
+                    childrenFilesIncludingDeclarationsPatterns: ECMA_ScriptSpecialist_1.default.partialFilesIncludingDeclarationPatterns,
+                    implicitFilesNamesExtensionsWithoutLeadingDotsOfChildrenFiles: this.ECMA_ScriptLogicProcessingConfigRepresentative.
                         supportedEntryPointsSourceFileNameExtensionsWithoutLeadingDots
                 },
-                directoriesAliasesAndTheirAbsolutePatsMap: new Map(),
+                directoriesAliasesAndTheirAbsolutePatsMap: ECMA_ScriptLogicProcessor.
+                    generateUnifiedDirectoriesAliasesAndTheirAbsolutePatsMapForSourceCodeSelectiveReprocessingHelper(this.ECMA_ScriptLogicProcessingConfigRepresentative),
                 isEntryPoint: this.ECMA_ScriptLogicProcessingConfigRepresentative.
                     isEntryPoint.
                     bind(this.ECMA_ScriptLogicProcessingConfigRepresentative),
@@ -7090,7 +7115,7 @@ class ECMA_ScriptLogicProcessor {
                     targetFilesTypeInSingularForm: this.ECMA_ScriptLogicProcessingConfigRepresentative.
                         TARGET_FILES_KIND_FOR_LOGGING__SINGULAR_FORM
                 },
-                consumingProjectRootDirectoryAbsolutePath: this.masterConfigRepresentative.consumingProjectRootDirectoryAbsolutePath,
+                consumingProjectRootDirectoryAbsolutePath: this.projectBuildingMasterConfigRepresentative.consumingProjectRootDirectoryAbsolutePath,
                 cacheFileAbsolutePath: es_extensions_nodejs_1.ImprovedPath.joinPathSegments([
                     DotYDA_DirectoryManager_1.default.OPTIMIZATION_FILES_DIRECTORY_ABSOLUTE_PATH,
                     ECMA_ScriptLogicProcessor.ENTRY_POINTS_AND_PARTIAL_FILES_MAPPING_CACHE_FILE_NAME_WITH_EXTENSION
@@ -7099,7 +7124,7 @@ class ECMA_ScriptLogicProcessor {
             ECMA_ScriptSourceFilesWatcher_1.default.
                 initializeIfRequiredAndGetInstance({
                 ecmaScriptLogicProcessingSettingsRepresentative: this.ECMA_ScriptLogicProcessingConfigRepresentative,
-                projectBuildingMasterConfigRepresentative: this.masterConfigRepresentative
+                projectBuildingMasterConfigRepresentative: this.projectBuildingMasterConfigRepresentative
             }).
                 addOnAnyEventRelatedWithActualFilesHandler({
                 handlerID: "ON_ANY_EVENT_WITH_ECMA_SCRIPT_LOGIC_SOURCE_CODE_FILE--BY_ECMA_SCRIPT_LOGIC_PROCESSOR",
@@ -7123,8 +7148,16 @@ class ECMA_ScriptLogicProcessor {
             clearTimeout(this.subsequentFilesStateChangeTimeout);
         }
         this.subsequentFilesStateChangeTimeout = setTimeout(() => {
-            const absolutePathOfEntryPointsWhichMustBeReprocessed = this.sourceCodeSelectiveReprocessingHelper?.getAbsolutePathsOfEntryPointsWhichMustBeProcessed(this.absolutePathOfFilesWaitingForReProcessing) ??
+            const absolutePathOfEntryPointsWhichMustBeReprocessed__forwardSlashSeparators = this.sourceCodeSelectiveReprocessingHelper?.getAbsolutePathsOfEntryPointsWhichMustBeProcessed(this.absolutePathOfFilesWaitingForReProcessing) ??
                 [];
+            const actualConfigurationsNames = Array.from((0, es_extensions_1.filterMap)(this.entryPointsSourceFilesAbsolutePathsAndWebpackConfigurationNamesMap, (targetEntryPointAbsolutePath__forwardSlashSeparators) => absolutePathOfEntryPointsWhichMustBeReprocessed__forwardSlashSeparators.
+                includes(targetEntryPointAbsolutePath__forwardSlashSeparators)).values());
+            if (actualConfigurationsNames.length === 1) {
+                (0, es_extensions_1.getArrayElementSatisfiesThePredicateIfSuchElementIsExactlyOne)(this.webpackMultiCompiler.compilers, (webpackCompiler) => webpackCompiler.name === actualConfigurationsNames[0], { mustThrowErrorIfElementNotFoundOrMatchesAreMultiple: true }).run(this.generateWebpackCallback());
+            }
+            else if (actualConfigurationsNames.length > 1) {
+                this.webpackMultiCompiler.run(this.generateWebpackCallback());
+            }
             this.absolutePathOfFilesWaitingForReProcessing.clear();
         }, (0, es_extensions_1.secondsToMilliseconds)(1));
     }
@@ -7135,7 +7168,15 @@ class ECMA_ScriptLogicProcessor {
             }
             let finalErrorMessageDynamicPart;
             /* [ Webpack theory ] Even there is no hard error braking the build, there are could be the soft errors. */
-            const softErrors = (0, es_extensions_1.undefinedToEmptyArray)(statistics?.stats[0]?.compilation.errors);
+            let softErrors = [];
+            if (statistics instanceof webpack_1.default.Stats) {
+                softErrors = statistics.compilation.errors;
+                /* [ Theory ]
+                 * `statistics instanceof Webpack.MultiStats` will fail because actually there is no `Webpack.MultiStats` class. */
+            }
+            else if ((0, es_extensions_1.isNotUndefined)(statistics)) {
+                softErrors = statistics.stats[0]?.compilation.errors;
+            }
             if ((0, es_extensions_1.isNeitherUndefinedNorNull)(hardError)) {
                 finalErrorMessageDynamicPart = hardError.message;
             }
@@ -7154,8 +7195,8 @@ class ECMA_ScriptLogicProcessor {
                     message: "Error has occurred. Please check the console."
                 });
             }
-            /** 〔 納品版のみ理由 〕　開発版で同じ事をすれば、gulpが落ちる */
-            if (!this.masterConfigRepresentative.mustProvideIncrementalBuilding && (0, es_extensions_1.isNotUndefined)(finalErrorMessageDynamicPart)) {
+            if (!this.projectBuildingMasterConfigRepresentative.mustProvideIncrementalBuilding &&
+                (0, es_extensions_1.isNotUndefined)(finalErrorMessageDynamicPart)) {
                 es_extensions_1.Logger.logError({
                     errorType: "ECMA_ScriptLogicProcessingError",
                     title: "ECMAScript logic processing error",
@@ -7165,11 +7206,33 @@ class ECMA_ScriptLogicProcessor {
                 gulpCallback?.(new Error(finalErrorMessageDynamicPart));
             }
             else {
-                (0, es_extensions_1.addMultiplePairsToMap)(ECMA_ScriptLogicProcessingSharedState_1.default.sourceFilesAbsolutePathsAndOutputFilesActualPathsMap, ECMA_ScriptLogicEntryPointsSourceFilesAbsolutePathsAndOutputFilesActualPathsMapGenerator_1.default.generate(this.ECMA_ScriptLogicProcessingConfigRepresentative));
+                (0, es_extensions_1.addEntriesToMap)({
+                    targetMap: ECMA_ScriptLogicProcessingSharedState_1.default.sourceFilesAbsolutePathsAndOutputFilesActualPathsMap,
+                    newEntries: ECMA_ScriptLogicEntryPointsSourceFilesAbsolutePathsAndOutputFilesActualPathsMapGenerator_1.default.generate(this.ECMA_ScriptLogicProcessingConfigRepresentative),
+                    mutably: true
+                });
                 gulpCallback?.();
             }
         };
     }
+    /* [ Theory ] Although it is a rare case, same directory alias (e.g. "@components") could refer to different
+    *    directory depending on entry points group. Because the `SourceCodeSelectiveReprocessingHelper` does not
+    *    respect the specific entry points group, all aliases definition must be merged herewith wihtout overwriting. */
+    static generateUnifiedDirectoriesAliasesAndTheirAbsolutePatsMapForSourceCodeSelectiveReprocessingHelper(ecmaScriptLogicProcessingConfigRepresentative) {
+        const unifiedDirectoriesAliasesAndTheirAbsolutePatsMap = new Map();
+        for (const entryPointsGroup of ecmaScriptLogicProcessingConfigRepresentative.relevantEntryPointsGroupsSettings.values()) {
+            for (const [directoryAlias, correspondingDirectoriesAbsolutePaths] of entryPointsGroup.directoriesAliasesAndCorrespondingAbsolutePathsMap) {
+                const alreadyRegisteredCorrespondingDirectoriesAbsolutePaths = unifiedDirectoriesAliasesAndTheirAbsolutePatsMap.get(directoryAlias);
+                if ((0, es_extensions_1.isUndefined)(alreadyRegisteredCorrespondingDirectoriesAbsolutePaths)) {
+                    unifiedDirectoriesAliasesAndTheirAbsolutePatsMap.set(directoryAlias, new Set(correspondingDirectoriesAbsolutePaths));
+                }
+                else {
+                    (0, es_extensions_1.addMultipleElementsToSet)(alreadyRegisteredCorrespondingDirectoriesAbsolutePaths, correspondingDirectoriesAbsolutePaths);
+                }
+            }
+        }
+        return unifiedDirectoriesAliasesAndTheirAbsolutePatsMap;
+    }
 }
 exports["default"] = ECMA_ScriptLogicProcessor;
 
@@ -7379,13 +7442,9 @@ class ECMA_ScriptSourceCodeLinter extends LinterLikeTaskExecutor_1.default {
                 }),
                 es_extensions_nodejs_1.ImprovedGlob.buildExcludingOfDirectoryWithSubdirectoriesGlobSelector(es_extensions_nodejs_1.ImprovedPath.joinPathSegments([projectBuildingMasterConfigRepresentative.consumingProjectRootDirectoryAbsolutePath, "node_modules"])),
                 /* [ ESLint theory ]
-                 * As default, ESLint finds the configuration file at `process.cwd()` and detects the `.eslintignore` file there.
-                 * However, because of the integration with Gulp, the files specified in `.eslintignore` must be additionally
-                 *   excluded from `targetFilesGlobSelectors`. */
-                ...ESLintLinterSpecialist_1.default.getGlobSelectorsOfExcludedFiles({
-                    consumingProjectRootDirectoryAbsolutePath: projectBuildingMasterConfigRepresentative.consumingProjectRootDirectoryAbsolutePath,
-                    mustSkipNodeModulesDirectory: true
-                })
+                 * In there are files and/or directories ignored in ESLint configuration they also must be excluded from
+                 *   the Gulp pipelines otherwise ESLint will emit the warning for ignored files. */
+                ...ESLintLinterSpecialist_1.default.generateExcludingGlobSelectorsOfIgnoredFiles(projectBuildingMasterConfigRepresentative.consumingProjectRootDirectoryAbsolutePath)
             ],
             logging: {
                 pathsOfFilesWillBeProcessed: ecmaScriptLogicProcessingSettingsRepresentative.loggingSettings.filesPaths,
@@ -7973,7 +8032,6 @@ class WebpackConfigGenerator {
                     supportedEntryPointsSourceFileNameExtensionsWithoutLeadingDots.
                     map((fileNameExtensionWithoutDot) => `.${fileNameExtensionWithoutDot}`),
                 alias: {
-                    //
                     ...WebpackSpecialist_1.default.convertPathsAliasesFromTypeScriptFormatToWebpackFormat({
                         typeScriptPathsSettings: typeScriptCompilerOptions.paths,
                         typeScriptBasicAbsolutePath: typeScriptCompilerOptions.baseUrl ??
@@ -8840,9 +8898,9 @@ class MarkupProcessor extends GulpStreamsBasedTaskExecutor_1.default {
             dataHoldingSelfInstance.sourceCodeSelectiveReprocessingHelper = new SourceCodeSelectiveReprocessingHelper_1.default({
                 initialEntryPointsSourceFilesAbsolutePaths: markupProcessingSettingsRepresentative.
                     initialRelevantEntryPointsSourceFilesAbsolutePaths,
-                affiliatedFilesResolutionRules: {
-                    affiliatedFilesIncludingDeclarationsPatterns: PugPreProcessorSpecialist_1.default.partialFilesIncludingDeclarationPatterns,
-                    implicitFilesNamesExtensionsWithoutLeadingDotsOfAffiliatedFiles: PugPreProcessorSpecialist_1.default.
+                childrenFilesResolutionRules: {
+                    childrenFilesIncludingDeclarationsPatterns: PugPreProcessorSpecialist_1.default.partialFilesIncludingDeclarationPatterns,
+                    implicitFilesNamesExtensionsWithoutLeadingDotsOfChildrenFiles: PugPreProcessorSpecialist_1.default.
                         implicitFilesNamesExtensionsWithoutLeadingDotsOfPartials
                 },
                 isEntryPoint: markupProcessingSettingsRepresentative.isEntryPoint.bind(markupProcessingSettingsRepresentative),
@@ -12069,7 +12127,7 @@ class RoutingSettingsNormalizer {
                 occurrenceLocation: "RoutingSettingsNormalizer.normalizeDepthLevelWiseRecursively(...parameters)"
             });
         }
-        RoutingSettingsNormalizer.routingPathSegments.push(RoutingSettingsNormalizer.routingPathSegments.length === 0 ? "" : "$children");
+        RoutingSettingsNormalizer.routingPathSegments.push(...RoutingSettingsNormalizer.routingPathSegments.length === 0 ? [""] : ["$children", ""]);
         for (const [routeKey, rawRoute] of Object.entries(rawRoutingOfSpecificDepthLevel)) {
             RoutingSettingsNormalizer.routingPathSegments[RoutingSettingsNormalizer.routingPathSegments.length - 1] = routeKey;
             if (!(0, es_extensions_1.isArbitraryObject)(rawRoute)) {
@@ -12093,7 +12151,6 @@ class RoutingSettingsNormalizer {
                         localization
                     })
                 } : null,
-                // TODO ========================================================================================================
                 ...(0, es_extensions_1.isArbitraryObject)(rawRoute.$sectioning) ? {
                     $sectioning: RoutingSettingsNormalizer.normalizeSectioning(rawRoute.$sectioning, routeURI, localization)
                 } : null
@@ -12220,57 +12277,81 @@ class RoutingSettingsNormalizer {
         }
         return headingWorkpiece;
     }
-    // TODO ==============================================================================================================
     /* ━━━ Sectioning ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ */
     static normalizeSectioning(rawSectioningSpecification, parentRouteURI, localization) {
         RoutingSettingsNormalizer.routingPathSegments.push("$sectioning");
+        if (!(0, es_extensions_1.isString)(parentRouteURI)) {
+            es_extensions_1.Logger.throwErrorAndLog({
+                errorInstance: new es_extensions_1.InvalidExternalDataError({
+                    customMessage: `The sectioning at "${RoutingSettingsNormalizer.routingPathSegments.join(".")}" has been defined ` +
+                        "while the $URI of the parent route has not been. " +
+                        "It must be defined to compute the URI for each section."
+                }),
+                title: es_extensions_1.InvalidExternalDataError.localization.defaultTitle,
+                occurrenceLocation: "RoutingSettingsNormalizer.normalizeSectioning(...parameters)"
+            });
+        }
         if (!(0, es_extensions_1.isNonEmptyString)(rawSectioningSpecification.$specificationFileRelativePath)) {
             es_extensions_1.Logger.throwErrorAndLog({
                 errorInstance: new es_extensions_1.InvalidExternalDataError({
-                    customMessage: [
-                        `Malformed routing at "${RoutingSettingsNormalizer.routingPathSegments.join(".")}".`,
+                    customMessage: `Malformed routing at "${RoutingSettingsNormalizer.routingPathSegments.join(".")}.` +
+                        "$specificationFileRelativePath\"." +
                         "The \"$sectioning.$specificationFileRelativePath\" must be defined with the valid file path relative " +
-                            "to project top directory."
-                    ].join(" ")
+                        "to project top directory."
                 }),
                 title: es_extensions_1.InvalidExternalDataError.localization.defaultTitle,
-                occurrenceLocation: "RoutingSettingsNormalizer.normalizeSectioning(rawSectioningSpecification)"
+                occurrenceLocation: "RoutingSettingsNormalizer.normalizeSectioning(...parameters)"
             });
         }
-        const rawSectioning = es_extensions_nodejs_1.ObjectDataFilesProcessor.processFile({
-            filePath: es_extensions_nodejs_1.ImprovedPath.joinPathSegments([
-                RoutingSettingsNormalizer.projectRootDirectoryAbsolutePath,
-                rawSectioningSpecification.$specificationFileRelativePath
-            ]),
-            synchronously: true,
-            schema: es_extensions_nodejs_1.ObjectDataFilesProcessor.SupportedSchemas.YAML
-        });
-        if (!(0, es_extensions_1.isArbitraryObject)(rawSectioning)) {
+        const rawSectioningSchemaFileAbsolutePath = es_extensions_nodejs_1.ImprovedPath.joinPathSegments([
+            RoutingSettingsNormalizer.projectRootDirectoryAbsolutePath,
+            rawSectioningSpecification.$specificationFileRelativePath
+        ], { alwaysForwardSlashSeparators: true });
+        let rawSectioningSchema;
+        try {
+            rawSectioningSchema = es_extensions_nodejs_1.ObjectDataFilesProcessor.processFile({
+                filePath: es_extensions_nodejs_1.ImprovedPath.joinPathSegments([
+                    RoutingSettingsNormalizer.projectRootDirectoryAbsolutePath,
+                    rawSectioningSpecification.$specificationFileRelativePath
+                ]),
+                synchronously: true,
+                schema: es_extensions_nodejs_1.ObjectDataFilesProcessor.SupportedSchemas.YAML
+            });
+        }
+        catch (error) {
             es_extensions_1.Logger.throwErrorAndLog({
                 errorInstance: new es_extensions_1.InvalidExternalDataError({
-                    customMessage: [
-                        `Malformed sectioning at "${rawSectioningSpecification.$specificationFileRelativePath}".`,
-                        `Must be an object while ${typeof rawSectioning} found.`
-                    ].join(" ")
+                    customMessage: "The error has occurred during the reading of sectioning file at " +
+                        `"${rawSectioningSpecification.$specificationFileRelativePath}".`
                 }),
                 title: es_extensions_1.InvalidExternalDataError.localization.defaultTitle,
-                occurrenceLocation: "RoutingSettingsNormalizer.normalizeSectioning(rawSectioningSpecification)"
+                occurrenceLocation: "RoutingSettingsNormalizer.normalizeSectioning(...parameters)",
+                innerError: error
             });
         }
-        if (!(0, es_extensions_1.isString)(parentRouteURI)) {
+        RoutingSettingsNormalizer.cachedAbsolutePathsOfSectioning.add(rawSectioningSchemaFileAbsolutePath);
+        if (!(0, es_extensions_1.isArbitraryObject)(rawSectioningSchema)) {
             es_extensions_1.Logger.throwErrorAndLog({
                 errorInstance: new es_extensions_1.InvalidExternalDataError({
-                    customMessage: `The sectioning at "${rawSectioningSpecification.$specificationFileRelativePath}" has been defined while ` +
-                        "the $URI of the parent route has not been." +
-                        "It must be defined to compute the URI for each section."
+                    customMessage: `Malformed sectioning at "${rawSectioningSpecification.$specificationFileRelativePath}". ` +
+                        `Must be an object while ${typeof (0, es_extensions_1.nullToUndefined)(rawSectioningSchema)} found.`
                 }),
                 title: es_extensions_1.InvalidExternalDataError.localization.defaultTitle,
-                occurrenceLocation: "RoutingSettingsNormalizer.normalizeSectioning(rawSectioningSpecification)"
+                occurrenceLocation: "RoutingSettingsNormalizer.normalizeSectioning(...parameters)"
             });
         }
         if ((0, es_extensions_1.isArbitraryObject)(rawSectioningSpecification.$localizations)) {
             if ((0, es_extensions_1.isUndefined)(localization)) {
-                throw new Error("未処理エラー1");
+                es_extensions_1.Logger.throwErrorAndLog({
+                    errorInstance: new es_extensions_1.InvalidExternalDataError({
+                        customMessage: "The $localizations has been specified for sectioning " +
+                            `"${RoutingSettingsNormalizer.routingPathSegments.join(".")}", but common localizations for ` +
+                            "routing has not been. " +
+                            "Specify the $localizations property also in routing configuration."
+                    }),
+                    title: es_extensions_1.InvalidExternalDataError.localization.defaultTitle,
+                    occurrenceLocation: "RoutingSettingsNormalizer.normalizeSectioning(...parameters)"
+                });
             }
             const targetLocalizationFileRelativePath = rawSectioningSpecification.$localizations[localization.locale];
             RoutingSettingsNormalizer.routingPathSegments.push("$localizations", localization.locale);
@@ -12279,30 +12360,42 @@ class RoutingSettingsNormalizer {
                     errorInstance: new es_extensions_1.InvalidExternalDataError({
                         customMessage: "Invalid path to sectioning localization at " +
                             `"${RoutingSettingsNormalizer.routingPathSegments.join(".")}". ` +
-                            `Must be the string with file path relative to project root directory, ${typeof es_extensions_1.isString} found.`
+                            "Must be the string with file path relative to project root directory, " +
+                            `${typeof (0, es_extensions_1.nullToUndefined)(targetLocalizationFileRelativePath)} found.`
                     }),
                     title: es_extensions_1.InvalidExternalDataError.localization.defaultTitle,
-                    occurrenceLocation: "RoutingSettingsNormalizer.normalizeSectioning(rawSectioningSpecification)"
+                    occurrenceLocation: "RoutingSettingsNormalizer.normalizeSectioning(...parameters)"
                 });
             }
-            const sectioningRawLocalization = es_extensions_nodejs_1.ObjectDataFilesProcessor.processFile({
-                filePath: es_extensions_nodejs_1.ImprovedPath.joinPathSegments([
-                    RoutingSettingsNormalizer.projectRootDirectoryAbsolutePath, targetLocalizationFileRelativePath
-                ]),
-                synchronously: true,
-                schema: es_extensions_nodejs_1.ObjectDataFilesProcessor.SupportedSchemas.YAML
-            });
+            const targetLocalizationFileAbsolutePath = es_extensions_nodejs_1.ImprovedPath.joinPathSegments([RoutingSettingsNormalizer.projectRootDirectoryAbsolutePath, targetLocalizationFileRelativePath], { alwaysForwardSlashSeparators: true });
+            let sectioningRawLocalization;
+            try {
+                sectioningRawLocalization = es_extensions_nodejs_1.ObjectDataFilesProcessor.processFile({
+                    filePath: targetLocalizationFileAbsolutePath,
+                    synchronously: true,
+                    schema: es_extensions_nodejs_1.ObjectDataFilesProcessor.SupportedSchemas.YAML
+                });
+            }
+            catch (error) {
+                es_extensions_1.Logger.throwErrorAndLog({
+                    errorInstance: new es_extensions_1.FileReadingFailedError({ filePath: targetLocalizationFileAbsolutePath }),
+                    title: es_extensions_1.FileReadingFailedError.localization.defaultTitle,
+                    occurrenceLocation: "RoutingSettingsNormalizer.normalizeSectioning(...parameters)",
+                    innerError: error
+                });
+            }
+            RoutingSettingsNormalizer.cachedAbsolutePathsOfSectioning.add(targetLocalizationFileAbsolutePath);
             if (!(0, es_extensions_1.isArbitraryObject)(sectioningRawLocalization)) {
                 es_extensions_1.Logger.throwErrorAndLog({
                     errorInstance: new es_extensions_1.InvalidExternalDataError({
-                        customMessage: `Malformed sectioning localization at "${targetLocalizationFileRelativePath}".`
+                        customMessage: `Malformed sectioning localization at "${targetLocalizationFileAbsolutePath}".`
                     }),
                     title: es_extensions_1.InvalidExternalDataError.localization.defaultTitle,
-                    occurrenceLocation: "RoutingSettingsNormalizer.normalizeSectioning(rawSectioningSpecification)"
+                    occurrenceLocation: "RoutingSettingsNormalizer.normalizeSectioning(...parameters)"
                 });
             }
             const normalizedLocalizedSectioning = RoutingSettingsNormalizer.normalizeSectioningDepthLevelRecursively({
-                rawSectioningOfSpecificDepthLevel: rawSectioning,
+                rawSectioningOfSpecificDepthLevel: rawSectioningSchema,
                 outputWorkpiece: {},
                 localization: {
                     locale: localization.locale,
@@ -12310,11 +12403,12 @@ class RoutingSettingsNormalizer {
                 },
                 parentRouteURI
             });
-            RoutingSettingsNormalizer.routingPathSegments.pop();
+            /* eslint-disable-next-line @typescript-eslint/no-magic-numbers -- `$localizations` and `localization.locale` */
+            RoutingSettingsNormalizer.routingPathSegments.splice(-2);
             return normalizedLocalizedSectioning;
         }
         return RoutingSettingsNormalizer.normalizeSectioningDepthLevelRecursively({
-            rawSectioningOfSpecificDepthLevel: rawSectioning,
+            rawSectioningOfSpecificDepthLevel: rawSectioningSchema,
             outputWorkpiece: {},
             parentRouteURI
         });
@@ -12323,60 +12417,56 @@ class RoutingSettingsNormalizer {
         if (!(0, es_extensions_1.isArbitraryObject)(rawSectioningOfSpecificDepthLevel)) {
             es_extensions_1.Logger.throwErrorAndLog({
                 errorInstance: new es_extensions_1.InvalidExternalDataError({
-                    customMessage: [
-                        "Malformed routing",
-                        RoutingSettingsNormalizer.routingPathSegments.length > 0 ?
-                            [` at "${RoutingSettingsNormalizer.routingPathSegments.join(".")}".`] :
-                            ["."],
-                        `Must be an object while ${typeof rawSectioningOfSpecificDepthLevel} found.`
-                    ].join(" ")
+                    customMessage: `Malformed routing at "${RoutingSettingsNormalizer.routingPathSegments.join(".")}". ` +
+                        `Must be an object while ${typeof (0, es_extensions_1.nullToUndefined)(rawSectioningOfSpecificDepthLevel)} found.`
                 }),
                 title: es_extensions_1.InvalidExternalDataError.localization.defaultTitle,
-                occurrenceLocation: "RoutingSettingsNormalizer.normalizeDepthLevelWiseRecursively(...parameters)"
+                occurrenceLocation: "RoutingSettingsNormalizer.normalizeDepthLevelWiseRecursively(compoundParameter)"
             });
         }
+        RoutingSettingsNormalizer.routingPathSegments.push(
+        /* eslint-disable-next-line @typescript-eslint/no-magic-numbers -- For the top level of sectioning case,
+          the "$sectioning" element will be second from the end.  */
+        ...RoutingSettingsNormalizer.routingPathSegments[RoutingSettingsNormalizer.routingPathSegments.length - 3] ===
+            "$sectioning" ? [""] : ["$children", ""]);
         RoutingSettingsNormalizer.routingPathSegments.push("");
-        for (const [sectionKey, rawSectionMetadata] of Object.entries(rawSectioningOfSpecificDepthLevel)) {
+        for (const [sectionKey, sectionRawMetadata] of Object.entries(rawSectioningOfSpecificDepthLevel)) {
             RoutingSettingsNormalizer.routingPathSegments[RoutingSettingsNormalizer.routingPathSegments.length - 1] = sectionKey;
-            if (!(0, es_extensions_1.isArbitraryObject)(rawSectionMetadata)) {
+            if (!(0, es_extensions_1.isArbitraryObject)(sectionRawMetadata)) {
                 es_extensions_1.Logger.throwErrorAndLog({
                     errorInstance: new es_extensions_1.InvalidExternalDataError({
-                        customMessage: [
-                            `Malformed sectioning at "${RoutingSettingsNormalizer.routingPathSegments.join(".")}".`,
-                            `Must be an object while ${typeof rawSectionMetadata} found.`
-                        ].join(" ")
+                        customMessage: `Malformed sectioning at "${RoutingSettingsNormalizer.routingPathSegments.join(".")}".` +
+                            `Must be an object while ${typeof (0, es_extensions_1.nullToUndefined)(sectionRawMetadata)} found.`
                     }),
                     title: es_extensions_1.InvalidExternalDataError.localization.defaultTitle,
-                    occurrenceLocation: "RoutingSettingsNormalizer.normalizeSectioningDepthLevelRecursively(compoundParameter)"
+                    occurrenceLocation: "RoutingSettingsNormalizer.normalizeDepthLevelWiseRecursively(compoundParameter)"
                 });
             }
-            if (!(0, es_extensions_1.isString)(rawSectionMetadata.$anchor)) {
+            if (!(0, es_extensions_1.isString)(sectionRawMetadata.$anchor)) {
                 es_extensions_1.Logger.throwErrorAndLog({
                     errorInstance: new es_extensions_1.InvalidExternalDataError({
-                        customMessage: [
-                            `Malformed sectioning at "${RoutingSettingsNormalizer.routingPathSegments.join(".")}".`,
-                            `The property "$anchor" must be defined with string while ${typeof rawSectionMetadata} found.`
-                        ].join(" ")
+                        customMessage: `Malformed sectioning at "${RoutingSettingsNormalizer.routingPathSegments.join(".")}". ` +
+                            `The property "$anchor" must be defined with string while ${typeof sectionRawMetadata} found.`
                     }),
                     title: es_extensions_1.InvalidExternalDataError.localization.defaultTitle,
-                    occurrenceLocation: "RoutingSettingsNormalizer.normalizeSectioningDepthLevelRecursively(compoundParameter)"
+                    occurrenceLocation: "RoutingSettingsNormalizer.normalizeDepthLevelWiseRecursively(compoundParameter)"
                 });
             }
-            const normalizedSectionMetadata = {
-                $heading: RoutingSettingsNormalizer.normalizeHeading(rawSectionMetadata.$heading, localization),
-                $anchor: rawSectionMetadata.$anchor,
-                $URI: `${parentRouteURI}#${rawSectionMetadata.$anchor}`,
-                ...(0, es_extensions_1.isArbitraryObject)(rawSectionMetadata.$children) ? {
+            outputWorkpiece[sectionKey] = {
+                $heading: RoutingSettingsNormalizer.normalizeHeading(sectionRawMetadata.$heading, localization),
+                $anchor: sectionRawMetadata.$anchor,
+                $URI: `${parentRouteURI}#${sectionRawMetadata.$anchor}`,
+                ...(0, es_extensions_1.isArbitraryObject)(sectionRawMetadata.$children) ? {
                     $children: RoutingSettingsNormalizer.normalizeSectioningDepthLevelRecursively({
-                        rawSectioningOfSpecificDepthLevel: rawSectionMetadata.$children,
+                        rawSectioningOfSpecificDepthLevel: sectionRawMetadata.$children,
                         outputWorkpiece: {},
                         localization,
                         parentRouteURI
                     })
                 } : null
             };
-            outputWorkpiece[sectionKey] = normalizedSectionMetadata;
         }
+        RoutingSettingsNormalizer.routingPathSegments.pop();
         return outputWorkpiece;
     }
 }
@@ -13313,9 +13403,9 @@ class StylesProcessor extends GulpStreamsBasedTaskExecutor_1.default {
             dataHoldingSelfInstance.sourceCodeSelectiveReprocessingHelper = new SourceCodeSelectiveReprocessingHelper_1.default({
                 initialEntryPointsSourceFilesAbsolutePaths: stylesProcessingSettingsRepresentative.
                     initialRelevantEntryPointsSourceFilesAbsolutePaths,
-                affiliatedFilesResolutionRules: {
-                    affiliatedFilesIncludingDeclarationsPatterns: StylusPreProcessorSpecialist_1.default.partialFilesIncludingDeclarationPatterns,
-                    implicitFilesNamesExtensionsWithoutLeadingDotsOfAffiliatedFiles: StylusPreProcessorSpecialist_1.default.
+                childrenFilesResolutionRules: {
+                    childrenFilesIncludingDeclarationsPatterns: StylusPreProcessorSpecialist_1.default.partialFilesIncludingDeclarationPatterns,
+                    implicitFilesNamesExtensionsWithoutLeadingDotsOfChildrenFiles: StylusPreProcessorSpecialist_1.default.
                         implicitFilesNamesExtensionsWithoutLeadingDotsOfPartials
                 },
                 isEntryPoint: stylesProcessingSettingsRepresentative.isEntryPoint.bind(stylesProcessingSettingsRepresentative),
@@ -13599,11 +13689,11 @@ exports["default"] = ChokidarSpecialistLocalization__English;
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 class ECMA_ScriptSpecialist {
-    /* [ Fiddle ] https://regex101.com/r/4X0mYk/6 */
+    /* [ Fiddle ] https://regex101.com/r/4X0mYk/7 */
     static partialFilesIncludingDeclarationPatterns = [
         /* eslint-disable-next-line prefer-named-capture-group --
          * No simple way to know the capturing group name outside of this file. */
-        /from\s+["']((?:\w|-|\.|\/|:)+)["']/gmu
+        /from\s+["']((?:\w|-|\.|\/|:|@|~)+)["']/gmu
     ];
 }
 exports["default"] = ECMA_ScriptSpecialist;
@@ -13622,25 +13712,108 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-const fs_1 = __importDefault(__webpack_require__(/*! fs */ "fs"));
 const path_1 = __importDefault(__webpack_require__(/*! path */ "path"));
+const fs_1 = __importDefault(__webpack_require__(/*! fs */ "fs"));
 const es_extensions_nodejs_1 = __webpack_require__(/*! @yamato-daiwa/es-extensions-nodejs */ "@yamato-daiwa/es-extensions-nodejs");
+const es_extensions_1 = __webpack_require__(/*! @yamato-daiwa/es-extensions */ "@yamato-daiwa/es-extensions");
 class ESLintLinterSpecialist {
-    static IGNORING_DIRECTIVES_DEFAULT_FILE_NAME_WITH_EXTENSION = ".eslintignore";
-    static getGlobSelectorsOfExcludedFiles(compoundParameter) {
-        return [
-            ...ESLintLinterSpecialist.getGlobSelectorsOfExcludedFilesFromIgnoringDirectiveFile(compoundParameter)
-        ];
-    }
-    static getGlobSelectorsOfExcludedFilesFromIgnoringDirectiveFile({ consumingProjectRootDirectoryAbsolutePath, mustSkipNodeModulesDirectory }) {
-        return fs_1.default.
-            readFileSync(path_1.default.join(process.cwd(), ESLintLinterSpecialist.IGNORING_DIRECTIVES_DEFAULT_FILE_NAME_WITH_EXTENSION), "utf8").
-            split(/\r?\n/u).
-            filter((line) => (/\w/u).test(line)).
-            filter((line) => !(mustSkipNodeModulesDirectory && line.includes("node_modules"))).
-            map((relativePathBasedGlob) => (path_1.default.parse(relativePathBasedGlob).ext.length === 0 ?
-            es_extensions_nodejs_1.ImprovedGlob.buildExcludingOfDirectoryWithSubdirectoriesGlobSelector(es_extensions_nodejs_1.ImprovedPath.joinPathSegments([consumingProjectRootDirectoryAbsolutePath, relativePathBasedGlob], { alwaysForwardSlashSeparators: true })) :
-            es_extensions_nodejs_1.ImprovedGlob.includingGlobSelectorToExcludingOne(es_extensions_nodejs_1.ImprovedPath.joinPathSegments([consumingProjectRootDirectoryAbsolutePath, relativePathBasedGlob], { alwaysForwardSlashSeparators: true }))));
+    static SUPPORTED_CONFIGURATION_FILES_NAMES_WITH_EXTENSIONS = [
+        "eslint.config.js",
+        "eslint.config.mjs",
+        "eslint.config.cjs",
+        "eslint.config.ts",
+        "eslint.config.mts",
+        "eslint.config.cts"
+    ];
+    static generateExcludingGlobSelectorsOfIgnoredFiles(consumingProjectRootDirectoryAbsolutePath) {
+        let configurationFileContent;
+        for (const potentialConfigurationFileNameWithExtension of ESLintLinterSpecialist.SUPPORTED_CONFIGURATION_FILES_NAMES_WITH_EXTENSIONS) {
+            try {
+                configurationFileContent = fs_1.default.readFileSync(es_extensions_nodejs_1.ImprovedPath.joinPathSegments([
+                    consumingProjectRootDirectoryAbsolutePath,
+                    potentialConfigurationFileNameWithExtension
+                ], { alwaysForwardSlashSeparators: true }), "utf-8");
+                break;
+            }
+            catch (error) {
+                if ((0, es_extensions_nodejs_1.isErrnoException)(error) && error.code === "ENOENT") {
+                    continue;
+                }
+                es_extensions_1.Logger.logError({
+                    mustOutputIf: true,
+                    errorType: "FileReadingFailedError",
+                    title: "File Reading Failed",
+                    description: `Unable to read the file ${potentialConfigurationFileNameWithExtension} while this file seems to be exist`,
+                    occurrenceLocation: "ESLintLinterSpecialist.getGlobSelectorsOfExcludedFiles(compoundParameter)",
+                    caughtError: error
+                });
+            }
+        }
+        if ((0, es_extensions_1.isUndefined)(configurationFileContent)) {
+            es_extensions_1.Logger.logWarning({
+                title: "No Files Will be Ignored by ESLint",
+                description: "ESLint configuration file not found thus unable to decide which files must be ignored.",
+                occurrenceLocation: "className.methodName(compoundParameter)"
+            });
+            return [];
+        }
+        const filesIgnoringPatternsRawExpression = (0, es_extensions_1.getMatchingWithFirstRegularExpressionCapturingGroup)({
+            targetString: configurationFileContent,
+            regularExpression: /ignores:\s*(?<array>\[(?:.|\s)+?\])/gu
+        });
+        if ((0, es_extensions_1.isNull)(filesIgnoringPatternsRawExpression)) {
+            return [];
+        }
+        let filesIgnoringPatterns;
+        try {
+            filesIgnoringPatterns = JSON.parse(filesIgnoringPatternsRawExpression.replace("'", "\""));
+        }
+        catch (error) {
+            es_extensions_1.Logger.logError({
+                errorType: es_extensions_1.InvalidExternalDataError.NAME,
+                title: es_extensions_1.InvalidExternalDataError.localization.defaultTitle,
+                description: "Invalid ignoring patters in ESLint configuration.",
+                occurrenceLocation: "ESLintLinterSpecialist.getGlobSelectorsOfExcludedFiles(compoundParameter)",
+                caughtError: error
+            });
+            return [];
+        }
+        const processingResult = es_extensions_1.RawObjectDataProcessor.process(filesIgnoringPatterns, {
+            subtype: es_extensions_1.RawObjectDataProcessor.ObjectSubtypes.indexedArray,
+            nameForLogging: "ESLint ignoring patterns",
+            element: {
+                type: String
+            }
+        });
+        if (processingResult.rawDataIsInvalid) {
+            es_extensions_1.Logger.logError({
+                errorType: es_extensions_1.InvalidExternalDataError.NAME,
+                title: es_extensions_1.InvalidExternalDataError.localization.defaultTitle,
+                description: "Invalid ignoring patters in ESLint configuration.\n" +
+                    es_extensions_1.RawObjectDataProcessor.formatValidationErrorsList(processingResult.validationErrorsMessages),
+                occurrenceLocation: "ESLintLinterSpecialist.getGlobSelectorsOfExcludedFiles(compoundParameter)"
+            });
+            return [];
+        }
+        /* [ Theory ] Known Patterns from ESLint Documentation & Experiments
+         * 1. ".config/*": ignore subdirectory ".config" in directory below root, but not ".config" recursively
+         * 2. ".config/": equivalent of 1
+         * 2. ".config": equivalent of 1
+         * 3. "＊＊/.config/": recursive ignoring of ".config"
+         * 4. config.js - ignoring of specific file
+         * See https://eslint.org/docs/latest/use/configure/ignore#ignoring-files
+         * */
+        return processingResult.processedData.
+            /* [ Theory ]
+             * ESLint ignores "node_modules" as default, so it must be ignored whatever it has been specified in ESLint
+             *   configuration file or no. */
+            filter((ignoredFilesPattern) => !ignoredFilesPattern.includes("node_module")).
+            map((ignoredFilesPattern) => {
+            if (ignoredFilesPattern.startsWith("**/")) {
+                return es_extensions_nodejs_1.ImprovedGlob.buildExcludingOfDirectoryWithSubdirectoriesGlobSelector(path_1.default.join(consumingProjectRootDirectoryAbsolutePath, ignoredFilesPattern.replace(/^\*\*\//gu, "")));
+            }
+            return es_extensions_nodejs_1.ImprovedGlob.buildExcludingOfDirectoryWithSubdirectoriesGlobSelector(path_1.default.join(consumingProjectRootDirectoryAbsolutePath, ignoredFilesPattern.replace(/\*/gu, "")));
+        });
     }
 }
 exports["default"] = ESLintLinterSpecialist;
@@ -13940,6 +14113,7 @@ exports["default"] = WebpackSpecialist;
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports["default"] = getExpectedToBeExistingMapValue;
 const es_extensions_1 = __webpack_require__(/*! @yamato-daiwa/es-extensions */ "@yamato-daiwa/es-extensions");
 function getExpectedToBeExistingMapValue(targetMap, targetKey) {
     const targetValue = targetMap.get(targetKey);
@@ -13952,7 +14126,6 @@ function getExpectedToBeExistingMapValue(targetMap, targetKey) {
     }
     return targetValue;
 }
-exports["default"] = getExpectedToBeExistingMapValue;
 
 
 /***/ }),
@@ -14001,11 +14174,11 @@ exports["default"] = Stopwatch;
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports["default"] = replaceLinesSeparators;
 const es_extensions_1 = __webpack_require__(/*! @yamato-daiwa/es-extensions */ "@yamato-daiwa/es-extensions");
 function replaceLinesSeparators(targetString, lineSeparators) {
     return (0, es_extensions_1.explodeStringToLines)({ targetString, mustIgnoreCarriageReturn: false }).join(lineSeparators);
 }
-exports["default"] = replaceLinesSeparators;
 
 
 /***/ }),
@@ -14300,12 +14473,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 const es_extensions_1 = __webpack_require__(/*! @yamato-daiwa/es-extensions */ "@yamato-daiwa/es-extensions");
 const es_extensions_nodejs_1 = __webpack_require__(/*! @yamato-daiwa/es-extensions-nodejs */ "@yamato-daiwa/es-extensions-nodejs");
 const fs_1 = __importDefault(__webpack_require__(/*! fs */ "fs"));
-/* [ Theory ]
- * With plain Gulp, we don't know the relations of entry points and affiliated files thus must to re-process all entry
- * points on any file changed. When files number is large, the performance impact will be tangible even for the local
- * development mode when the speed is negligible to certain extent. To optimize this, we need to know the parents entry
- * points of each file, herewith the hierarchy could be arbitrary large. Also, we need to avoid of the reading of same
- * file twice while its content not changed. */
+const path_1 = __importDefault(__webpack_require__(/*! path */ "path"));
 class SourceCodeSelectiveReprocessingHelper {
     static DEBUGGING_MODE = false;
     static cachedMetadataFileContentSpecification = {
@@ -14322,7 +14490,7 @@ class SourceCodeSelectiveReprocessingHelper {
                             type: String,
                             required: true
                         },
-                        directAffiliatedFilesRelativePaths: {
+                        directChildrenFilesRelativePaths: {
                             type: Array,
                             required: true,
                             element: { type: String }
@@ -14330,7 +14498,7 @@ class SourceCodeSelectiveReprocessingHelper {
                     }
                 }
             },
-            affiliatedFiles: {
+            childrenFiles: {
                 type: es_extensions_1.RawObjectDataProcessor.ValuesTypesIDs.associativeArrayOfUniformTypeValues,
                 required: true,
                 value: {
@@ -14340,7 +14508,7 @@ class SourceCodeSelectiveReprocessingHelper {
                             type: String,
                             required: true
                         },
-                        directAffiliatedFilesRelativePaths: {
+                        directChildrenFilesRelativePaths: {
                             type: Array,
                             required: true,
                             element: { type: String }
@@ -14357,183 +14525,208 @@ class SourceCodeSelectiveReprocessingHelper {
     };
     entryPointsMetadata = new Map();
     isEntryPoint;
-    affiliatedFilesMetadata = new Map();
-    affiliatedFilesResolutionRules;
-    absolutePathsOfAffiliatedFilesWhichHasBeenScannedDuringCurrentPass = new Set();
+    childrenFilesMetadata = new Map();
+    resolvedAliasedPaths = new Map();
+    childrenFilesResolutionRules;
+    absolutePathsOfChildrenFilesWhichHasBeenScannedDuringCurrentPass = new Set();
+    directoriesAliasesAndTheirAbsolutePatsMap;
     CONSUMING_PROJECT_ROOT_DIRECTORY_ABSOLUTE_PATH;
     CACHED_METADATA_FILE_ABSOLUTE_PATH;
     TARGET_FILES_TYPE_IN_SINGULAR_FORM;
+    /* ━━━ Constructor ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ */
     constructor(initializationProperties) {
         this.isEntryPoint = initializationProperties.isEntryPoint;
-        this.affiliatedFilesResolutionRules = initializationProperties.affiliatedFilesResolutionRules;
+        this.childrenFilesResolutionRules = initializationProperties.childrenFilesResolutionRules;
+        this.directoriesAliasesAndTheirAbsolutePatsMap =
+            initializationProperties.directoriesAliasesAndTheirAbsolutePatsMap ?? new Map();
         this.CONSUMING_PROJECT_ROOT_DIRECTORY_ABSOLUTE_PATH = initializationProperties.consumingProjectRootDirectoryAbsolutePath;
         this.CACHED_METADATA_FILE_ABSOLUTE_PATH = initializationProperties.cacheFileAbsolutePath;
         this.TARGET_FILES_TYPE_IN_SINGULAR_FORM = initializationProperties.logging.targetFilesTypeInSingularForm;
-        this.generateInitialMetadataMaps(new Set(initializationProperties.initialEntryPointsSourceFilesAbsolutePaths.map((entryPointFileAbsolutePath__potentiallyWithOperationingSystemDependentPathSeparators) => es_extensions_nodejs_1.ImprovedPath.replacePathSeparatorsToForwardSlashes(entryPointFileAbsolutePath__potentiallyWithOperationingSystemDependentPathSeparators))));
+        /* [ Theory ] The cached metadata from previous YDA launches could be. */
+        this.retrieveCacheFromFileAndApplyIfItExists();
+        this.scanFilesHierarchyTreeForEntryPoints(new Set(initializationProperties.initialEntryPointsSourceFilesAbsolutePaths.map((entryPointFileAbsolutePath__potentiallyWithOperationingSystemDependentPathSeparators) => es_extensions_nodejs_1.ImprovedPath.replacePathSeparatorsToForwardSlashes(entryPointFileAbsolutePath__potentiallyWithOperationingSystemDependentPathSeparators))));
         if (initializationProperties.logging.mustEnable) {
-            this.logAffiliatedFilesAndEntryPointsRelationships();
+            this.logChildrenFilesAndEntryPointsRelationships();
         }
-        this.cacheFilesMetadataMapsToFile();
+        this.saveCachedFilesMetadataMapsToFile();
     }
-    getAbsolutePathsOfEntryPointsWhichMustBeProcessed(absolutePathsOfFilesWithChangesStatus) {
-        const absolutePathsOfEntryPointsWhichMustBeProcessed = new Set();
-        for (const absolutePathOfFileWithChangesStatus of absolutePathsOfFilesWithChangesStatus) {
-            if (this.isEntryPoint(absolutePathOfFileWithChangesStatus)) {
-                if (fs_1.default.existsSync(absolutePathOfFileWithChangesStatus)) {
-                    absolutePathsOfEntryPointsWhichMustBeProcessed.add(absolutePathOfFileWithChangesStatus);
+    /* ━━━ Public Methods ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ */
+    getAbsolutePathsOfEntryPointsWhichMustBeProcessed(absolutePathsOfFilesWithChangedStatus__forwardSlashSeparators) {
+        const absolutePathsOfEntryPointsWhichMustBeProcessed__forwardSlashSeparators = new Set();
+        const absolutePathsOfChildrenFilesWhichParentEntryPointsMustBeProcessed__forwardSlashSeparators = new Set();
+        for (const absolutePathOfFileWithChangedStatus__forwardSlashSeparators of absolutePathsOfFilesWithChangedStatus__forwardSlashSeparators) {
+            const pathRelativeRelativeToConsumingProjectRootDirectoryOfFileWithChangedStatus__forwardSlashSeparators = es_extensions_nodejs_1.ImprovedPath.computeRelativePath({
+                basePath: this.CONSUMING_PROJECT_ROOT_DIRECTORY_ABSOLUTE_PATH,
+                comparedPath: absolutePathOfFileWithChangedStatus__forwardSlashSeparators,
+                alwaysForwardSlashSeparators: true
+            });
+            if (fs_1.default.existsSync(absolutePathOfFileWithChangedStatus__forwardSlashSeparators)) {
+                if (this.isEntryPoint(absolutePathOfFileWithChangedStatus__forwardSlashSeparators)) {
+                    absolutePathsOfEntryPointsWhichMustBeProcessed__forwardSlashSeparators.
+                        add(absolutePathOfFileWithChangedStatus__forwardSlashSeparators);
                 }
                 else {
-                    this.entryPointsMetadata.delete(es_extensions_nodejs_1.ImprovedPath.computeRelativePath({
-                        basePath: this.CONSUMING_PROJECT_ROOT_DIRECTORY_ABSOLUTE_PATH,
-                        comparedPath: absolutePathOfFileWithChangesStatus,
-                        alwaysForwardSlashSeparators: true
-                    }));
+                    absolutePathsOfChildrenFilesWhichParentEntryPointsMustBeProcessed__forwardSlashSeparators.
+                        add(absolutePathOfFileWithChangedStatus__forwardSlashSeparators);
                 }
             }
             else {
-                const targetAffiliatedFileRelativePath = es_extensions_nodejs_1.ImprovedPath.computeRelativePath({
-                    basePath: this.CONSUMING_PROJECT_ROOT_DIRECTORY_ABSOLUTE_PATH,
-                    comparedPath: absolutePathOfFileWithChangesStatus,
-                    alwaysForwardSlashSeparators: true
+                this.clearFileMetadataPathFromCache(pathRelativeRelativeToConsumingProjectRootDirectoryOfFileWithChangedStatus__forwardSlashSeparators);
+            }
+        }
+        this.scanFilesHierarchyTreeForEntryPoints(absolutePathsOfEntryPointsWhichMustBeProcessed__forwardSlashSeparators);
+        this.saveCachedFilesMetadataMapsToFile();
+        for (const absolutePathOfChildFile__forwardSlashSeparators of absolutePathsOfChildrenFilesWhichParentEntryPointsMustBeProcessed__forwardSlashSeparators) {
+            const pathOfChildFileRelativeToConsumingProjectRootDirectory__forwardSlashSeparators = es_extensions_nodejs_1.ImprovedPath.
+                computeRelativePath({
+                basePath: this.CONSUMING_PROJECT_ROOT_DIRECTORY_ABSOLUTE_PATH,
+                comparedPath: absolutePathOfChildFile__forwardSlashSeparators,
+                alwaysForwardSlashSeparators: true
+            });
+            (0, es_extensions_1.addMultipleElementsToSet)(absolutePathsOfEntryPointsWhichMustBeProcessed__forwardSlashSeparators, Array.from(this.childrenFilesMetadata.get(pathOfChildFileRelativeToConsumingProjectRootDirectory__forwardSlashSeparators)?.parentEntryPointsAbsolutePaths ??
+                new Set()));
+        }
+        return Array.from(absolutePathsOfEntryPointsWhichMustBeProcessed__forwardSlashSeparators);
+    }
+    /* ━━━ Private Methods ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ */
+    /* ─── Initial Pass ─────────────────────────────────────────────────────────────────────────────────────────────── */
+    retrieveCacheFromFileAndApplyIfItExists() {
+        let cachedRawMetadata;
+        try {
+            cachedRawMetadata = es_extensions_nodejs_1.ObjectDataFilesProcessor.processFile({
+                filePath: this.CACHED_METADATA_FILE_ABSOLUTE_PATH,
+                validDataSpecification: SourceCodeSelectiveReprocessingHelper.cachedMetadataFileContentSpecification,
+                synchronously: true
+            });
+        }
+        catch (error) {
+            if (!(error instanceof es_extensions_nodejs_1.FileNotFoundError)) {
+                es_extensions_1.Logger.logError({
+                    mustOutputIf:  true || 0,
+                    errorType: "CachedDataRetrievingFailedError",
+                    title: "Cached Data Retrieving Failed",
+                    description: `Unable to read the existing cache file at "${this.CACHED_METADATA_FILE_ABSOLUTE_PATH}".`,
+                    occurrenceLocation: "sourceCodeSelectiveReprocessingHelper.retrieveCacheFromFileAndApplyIfItExists()",
+                    caughtError: error
                 });
-                if (fs_1.default.existsSync(absolutePathOfFileWithChangesStatus)) {
-                    (0, es_extensions_1.addMultipleElementsToSet)(absolutePathsOfEntryPointsWhichMustBeProcessed, Array.from(this.affiliatedFilesMetadata.get(targetAffiliatedFileRelativePath)?.parentEntryPointsAbsolutePaths ?? []));
-                }
-                else {
-                    this.affiliatedFilesMetadata.delete(targetAffiliatedFileRelativePath);
-                }
             }
+            return;
+        }
+        for (const [entryPointPathRelativeToConsumingProjectRootDirectory, entryPointRawMetadata] of Object.entries(cachedRawMetadata.entryPoints)) {
+            this.entryPointsMetadata.set(entryPointPathRelativeToConsumingProjectRootDirectory, {
+                modificationDate__ISO8601: entryPointRawMetadata.modificationDate__ISO8601,
+                directChildrenFilesRelativePaths: new Set(entryPointRawMetadata.directChildrenFilesRelativePaths)
+            });
+        }
+        for (const [childFilePathRelativeToConsumingProjectRootDirectory, childFileMetadata] of Object.entries(cachedRawMetadata.childrenFiles)) {
+            this.childrenFilesMetadata.set(childFilePathRelativeToConsumingProjectRootDirectory, {
+                modificationDateTime__ISO8601: childFileMetadata.modificationDate__ISO8601,
+                directChildrenFilesRelativePaths: new Set(childFileMetadata.directChildrenFilesRelativePaths),
+                parentEntryPointsAbsolutePaths: new Set(childFileMetadata.parentEntryPointsRelativePaths.map((parentEntryPointsRelativePath) => es_extensions_nodejs_1.ImprovedPath.joinPathSegments([this.CONSUMING_PROJECT_ROOT_DIRECTORY_ABSOLUTE_PATH, parentEntryPointsRelativePath], { alwaysForwardSlashSeparators: true })))
+            });
         }
-        return Array.from(absolutePathsOfEntryPointsWhichMustBeProcessed);
     }
-    /* ━━━ First Mapping Since Last YDA Launch ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ */
-    /* [ Theory ] The cached metadata from previous YDA launches could be. */
-    generateInitialMetadataMaps(initialEntryPointsAbsolutePaths) {
-        this.extractCacheFromFileAndApplyIfItExists();
-        for (const entryPointFileAbsolutePath of initialEntryPointsAbsolutePaths) {
-            const entryPointDirectoryAbsolutePath = es_extensions_nodejs_1.ImprovedPath.extractDirectoryFromFilePath({
-                targetPath: entryPointFileAbsolutePath,
-                alwaysForwardSlashSeparators: true,
+    /* ─── All Passes ───────────────────────────────────────────────────────────────────────────────────────────────── */
+    scanFilesHierarchyTreeForEntryPoints(targetEntryPointsAbsolutePaths__forwardSlashSeparators) {
+        for (const entryPointAbsolutePath__forwardSlashSeparators of targetEntryPointsAbsolutePaths__forwardSlashSeparators) {
+            const entryPointDirectoryAbsolutePath__forwardSlashSeparators = es_extensions_nodejs_1.ImprovedPath.extractDirectoryFromFilePath({
+                targetPath: entryPointAbsolutePath__forwardSlashSeparators,
                 ambiguitiesResolution: {
                     mustConsiderLastSegmentStartingWithDotAsDirectory: false,
                     mustConsiderLastSegmentWithNonLeadingDotAsDirectory: false,
                     mustConsiderLastSegmentWihtoutDotsAsFileNameWithoutExtension: true
-                }
+                },
+                alwaysForwardSlashSeparators: true
             });
-            const entryPointFilePathRelativeToConsumingProjectRootDirectory = es_extensions_nodejs_1.ImprovedPath.computeRelativePath({
+            const entryPointPathRelativeToConsumingProjectRootDirectory__forwardSlashSeparators = es_extensions_nodejs_1.ImprovedPath.
+                computeRelativePath({
                 basePath: this.CONSUMING_PROJECT_ROOT_DIRECTORY_ABSOLUTE_PATH,
-                comparedPath: entryPointFileAbsolutePath,
+                comparedPath: entryPointAbsolutePath__forwardSlashSeparators,
                 alwaysForwardSlashSeparators: true
             });
-            let entryPointModificationDateTime__ISO8601;
+            let entryPointLastModificationDateTime__ISO8601;
             try {
-                entryPointModificationDateTime__ISO8601 = fs_1.default.statSync(entryPointFileAbsolutePath).mtime.toISOString();
+                entryPointLastModificationDateTime__ISO8601 = fs_1.default.statSync(entryPointAbsolutePath__forwardSlashSeparators).
+                    mtime.
+                    toISOString();
             }
             catch (error) {
                 if ((0, es_extensions_nodejs_1.isErrnoException)(error) && error.code === "ENOENT") {
-                    this.entryPointsMetadata.delete(entryPointFilePathRelativeToConsumingProjectRootDirectory);
+                    this.entryPointsMetadata.delete(entryPointPathRelativeToConsumingProjectRootDirectory__forwardSlashSeparators);
                     continue;
                 }
                 es_extensions_1.Logger.logError({
                     mustOutputIf:  true || 0,
                     errorType: "FileStatisticsRetrievingFailedError",
                     title: "File Statistics Retrieving Failed Error",
-                    description: `Unable to retrieve the statistics of file "${entryPointFilePathRelativeToConsumingProjectRootDirectory}". ` +
+                    description: "Unable to retrieve the statistics of file " +
+                        `"${entryPointPathRelativeToConsumingProjectRootDirectory__forwardSlashSeparators}". ` +
                         "This file will not be mapped.",
-                    occurrenceLocation: "sourceCodeSelectiveReprocessingHelper.generateInitialMetadataMaps()",
+                    occurrenceLocation: "sourceCodeSelectiveReprocessingHelper." +
+                        "scanFilesHierarchyTreeForEntryPoints(targetEntryPointsAbsolutePaths__forwardSlashSeparators)",
                     caughtError: error
                 });
                 continue;
             }
-            const cachedMetadataOfCurrentEntryPoint = this.entryPointsMetadata.get(entryPointFilePathRelativeToConsumingProjectRootDirectory);
-            let absolutePathsOfDirectExistingAffiliatedFilesOfCurrentEntryPoint;
-            if (cachedMetadataOfCurrentEntryPoint?.modificationDate__ISO8601 === entryPointModificationDateTime__ISO8601) {
-                /* [ Theory ] Although the entry point file is existing and has not changed since last mapping, its affiliated
-                 *   files could be added or deleted. */
-                absolutePathsOfDirectExistingAffiliatedFilesOfCurrentEntryPoint = new Set();
-                for (const relativePathOfAffiliatedFileOfCurrentEntryPoint of cachedMetadataOfCurrentEntryPoint.directAffiliatedFilesRelativePaths) {
-                    const absolutePathOfAffiliatedFileOfCurrentEntryPoint = es_extensions_nodejs_1.ImprovedPath.joinPathSegments([this.CONSUMING_PROJECT_ROOT_DIRECTORY_ABSOLUTE_PATH, relativePathOfAffiliatedFileOfCurrentEntryPoint], { alwaysForwardSlashSeparators: true });
-                    if (!fs_1.default.existsSync(absolutePathOfAffiliatedFileOfCurrentEntryPoint)) {
-                        cachedMetadataOfCurrentEntryPoint.directAffiliatedFilesRelativePaths.
-                            delete(relativePathOfAffiliatedFileOfCurrentEntryPoint);
+            let cachedMetadataOfCurrentEntryPoint = this.entryPointsMetadata.get(entryPointPathRelativeToConsumingProjectRootDirectory__forwardSlashSeparators);
+            let absolutePathsOfExistingDirectChildrenFilesOfCurrentEntryPoint__forwardSlashSeparators = new Set();
+            /* [ Theory ] This condition will could be truthy (but not always) only on initial pass. */
+            if (cachedMetadataOfCurrentEntryPoint?.modificationDate__ISO8601 === entryPointLastModificationDateTime__ISO8601) {
+                /* [ Theory ]
+                 * Although the entry point file is existing and has not changed since last scan, its children files could
+                 *  be added or deleted. */
+                for (const pathRelativeToConsumingProjectRootDirectoryOfChildFileOfCurrentEntryPoint__forwardSlashSeparators of cachedMetadataOfCurrentEntryPoint.directChildrenFilesRelativePaths) {
+                    const absolutePathOfChildFileOfCurrentEntryPoint__forwardSlashSeparators = es_extensions_nodejs_1.ImprovedPath.joinPathSegments([
+                        this.CONSUMING_PROJECT_ROOT_DIRECTORY_ABSOLUTE_PATH,
+                        pathRelativeToConsumingProjectRootDirectoryOfChildFileOfCurrentEntryPoint__forwardSlashSeparators
+                    ], { alwaysForwardSlashSeparators: true });
+                    if (!fs_1.default.existsSync(absolutePathOfChildFileOfCurrentEntryPoint__forwardSlashSeparators)) {
+                        this.clearFileMetadataPathFromCache(pathRelativeToConsumingProjectRootDirectoryOfChildFileOfCurrentEntryPoint__forwardSlashSeparators);
                     }
-                    absolutePathsOfDirectExistingAffiliatedFilesOfCurrentEntryPoint = new Set(Array.from(cachedMetadataOfCurrentEntryPoint.directAffiliatedFilesRelativePaths));
+                    absolutePathsOfExistingDirectChildrenFilesOfCurrentEntryPoint__forwardSlashSeparators = new Set(Array.from(cachedMetadataOfCurrentEntryPoint.directChildrenFilesRelativePaths));
                 }
             }
             else {
-                absolutePathsOfDirectExistingAffiliatedFilesOfCurrentEntryPoint = this.
-                    getAbsolutePathsOfExistingAffiliatedFilesOfExistingUpdatedTargetOne({
-                    targetFileAbsolutePath: entryPointFileAbsolutePath,
-                    targetFileDirectoryAbsolutePath: entryPointDirectoryAbsolutePath
+                /* [ Maintainability ]　Keep this variable for debugging. */
+                absolutePathsOfExistingDirectChildrenFilesOfCurrentEntryPoint__forwardSlashSeparators = this.
+                    getAbsolutePathsOfExistingChildrenFilesOfExistingTargetFile__forwardSlashSeparators({
+                    targetFileAbsolutePath__forwardSlashSeparators: entryPointAbsolutePath__forwardSlashSeparators,
+                    preComputedTargetFileDirectoryAbsolutePath__forwardSlashSeparators: entryPointDirectoryAbsolutePath__forwardSlashSeparators
                 });
-                this.entryPointsMetadata.set(entryPointFilePathRelativeToConsumingProjectRootDirectory, {
-                    modificationDate__ISO8601: entryPointModificationDateTime__ISO8601,
-                    directAffiliatedFilesRelativePaths: (0, es_extensions_1.createSetBasedOnOtherSet)(absolutePathsOfDirectExistingAffiliatedFilesOfCurrentEntryPoint, (absolutePathOfExistingAffiliatedFileOfCurrentEntryPoint) => es_extensions_nodejs_1.ImprovedPath.computeRelativePath({
+                cachedMetadataOfCurrentEntryPoint = {
+                    modificationDate__ISO8601: entryPointLastModificationDateTime__ISO8601,
+                    directChildrenFilesRelativePaths: (0, es_extensions_1.createSetBasedOnOtherSet)(absolutePathsOfExistingDirectChildrenFilesOfCurrentEntryPoint__forwardSlashSeparators, (absolutePathOfExistingDirectChildFileOfCurrentEntryPoint__forwardSlashSeparators) => es_extensions_nodejs_1.ImprovedPath.computeRelativePath({
                         basePath: this.CONSUMING_PROJECT_ROOT_DIRECTORY_ABSOLUTE_PATH,
-                        comparedPath: absolutePathOfExistingAffiliatedFileOfCurrentEntryPoint,
+                        comparedPath: absolutePathOfExistingDirectChildFileOfCurrentEntryPoint__forwardSlashSeparators,
                         alwaysForwardSlashSeparators: true
                     }))
-                });
+                };
+                this.entryPointsMetadata.set(entryPointPathRelativeToConsumingProjectRootDirectory__forwardSlashSeparators, cachedMetadataOfCurrentEntryPoint);
             }
             es_extensions_1.Logger.logGeneric({
                 mustOutputIf: SourceCodeSelectiveReprocessingHelper.DEBUGGING_MODE,
                 badge: { customText: "Debug" },
-                title: "SourceCodeSelectiveReprocessingHelper, entry point has been analyzed.",
-                description: `The metadata of entry point "${entryPointFilePathRelativeToConsumingProjectRootDirectory}" ` +
-                    `has been is:\n${(0, es_extensions_1.stringifyAndFormatArbitraryValue)(this.entryPointsMetadata)}\n`
-            });
-            for (const absolutePathOfDirectExistingAffiliatedFileOfCurrentEntryPoint of absolutePathsOfDirectExistingAffiliatedFilesOfCurrentEntryPoint) {
-                this.updateMetadataMapForExistingAffiliatedFile({
-                    targetAffiliatedFileAbsolutePath: absolutePathOfDirectExistingAffiliatedFileOfCurrentEntryPoint,
-                    parentEntryPointAbsolutePath: entryPointFileAbsolutePath
+                title: "SourceCodeSelectiveReprocessingHelper, Entry Point Analysis Complete.",
+                description: entryPointPathRelativeToConsumingProjectRootDirectory__forwardSlashSeparators,
+                additionalData: cachedMetadataOfCurrentEntryPoint
+            });
+            for (const absolutePathOfDirectExistingChildFileOfCurrentEntryPoint__forwardSlashSeparators of absolutePathsOfExistingDirectChildrenFilesOfCurrentEntryPoint__forwardSlashSeparators) {
+                this.updateMetadataForExistingChildFile({
+                    targetChildFileAbsolutePath__forwardSlashSeparators: absolutePathOfDirectExistingChildFileOfCurrentEntryPoint__forwardSlashSeparators,
+                    parentEntryPointAbsolutePath__forwardSlashSeparators: entryPointAbsolutePath__forwardSlashSeparators
                 });
-                this.absolutePathsOfAffiliatedFilesWhichHasBeenScannedDuringCurrentPass.
-                    add(absolutePathOfDirectExistingAffiliatedFileOfCurrentEntryPoint);
+                this.absolutePathsOfChildrenFilesWhichHasBeenScannedDuringCurrentPass.
+                    add(absolutePathOfDirectExistingChildFileOfCurrentEntryPoint__forwardSlashSeparators);
             }
         }
-        this.absolutePathsOfAffiliatedFilesWhichHasBeenScannedDuringCurrentPass.clear();
+        this.absolutePathsOfChildrenFilesWhichHasBeenScannedDuringCurrentPass.clear();
     }
-    extractCacheFromFileAndApplyIfItExists() {
-        let cachedRawMetadata;
-        try {
-            cachedRawMetadata = es_extensions_nodejs_1.ObjectDataFilesProcessor.processFile({
-                filePath: this.CACHED_METADATA_FILE_ABSOLUTE_PATH,
-                validDataSpecification: SourceCodeSelectiveReprocessingHelper.cachedMetadataFileContentSpecification,
-                synchronously: true
-            });
-        }
-        catch (error) {
-            if (!(error instanceof es_extensions_nodejs_1.FileNotFoundError)) {
-                es_extensions_1.Logger.logError({
-                    mustOutputIf:  true || 0,
-                    errorType: "CachedDataRetrievingFailure",
-                    title: "Cached Data Retrieving Failure",
-                    description: `Unable to read the existing cache file "${this.CACHED_METADATA_FILE_ABSOLUTE_PATH}".`,
-                    occurrenceLocation: "sourceCodeSelectiveReprocessingHelper.extractCacheFromFileAndApplyIfItExists()",
-                    caughtError: error
-                });
-            }
-            return;
-        }
-        for (const [entryPointPathRelativeToConsumingProjectRootDirectory, entryPointRawMetadata] of Object.entries(cachedRawMetadata.entryPoints)) {
-            this.entryPointsMetadata.set(entryPointPathRelativeToConsumingProjectRootDirectory, {
-                modificationDate__ISO8601: entryPointRawMetadata.modificationDate__ISO8601,
-                directAffiliatedFilesRelativePaths: new Set(entryPointRawMetadata.directAffiliatedFilesRelativePaths)
-            });
-        }
-        for (const [affiliatedFilePathRelativeToConsumingProjectRootDirectory, affiliatedFileMetadata] of Object.entries(cachedRawMetadata.affiliatedFiles)) {
-            this.affiliatedFilesMetadata.set(affiliatedFilePathRelativeToConsumingProjectRootDirectory, {
-                modificationDateTime__ISO8601: affiliatedFileMetadata.modificationDate__ISO8601,
-                directAffiliatedFilesRelativePaths: new Set(affiliatedFileMetadata.directAffiliatedFilesRelativePaths),
-                parentEntryPointsAbsolutePaths: new Set(affiliatedFileMetadata.parentEntryPointsRelativePaths.map((parentEntryPointsRelativePath) => es_extensions_nodejs_1.ImprovedPath.joinPathSegments([this.CONSUMING_PROJECT_ROOT_DIRECTORY_ABSOLUTE_PATH, parentEntryPointsRelativePath], { alwaysForwardSlashSeparators: true })))
-            });
-        }
-    }
-    getAbsolutePathsOfExistingAffiliatedFilesOfExistingUpdatedTargetOne({ targetFileAbsolutePath, targetFileDirectoryAbsolutePath }) {
-        const absolutePathsOfExistingAffiliatedFilesOfTargetOne = new Set();
+    /* [ Approach ] The target file could be either entry point or not. */
+    getAbsolutePathsOfExistingChildrenFilesOfExistingTargetFile__forwardSlashSeparators({ targetFileAbsolutePath__forwardSlashSeparators, preComputedTargetFileDirectoryAbsolutePath__forwardSlashSeparators }) {
+        const absolutePathsOfExistingChildrenFilesOfTargetOne__forwardSlashSeparators = new Set();
         let fileContent;
         try {
-            fileContent = fs_1.default.readFileSync(targetFileAbsolutePath, "utf-8");
+            fileContent = fs_1.default.readFileSync(targetFileAbsolutePath__forwardSlashSeparators, "utf-8");
         }
         catch (error) {
             if ((0, es_extensions_nodejs_1.isErrnoException)(error) && error.code === "ENOENT") {
@@ -14541,231 +14734,291 @@ class SourceCodeSelectiveReprocessingHelper {
                     mustOutputIf:  true || 0,
                     errorType: es_extensions_1.UnexpectedEventError.NAME,
                     title: es_extensions_1.UnexpectedEventError.localization.defaultTitle,
-                    description: `The existence of the file "${targetFileAbsolutePath}" has been confirmed one moment ago ` +
-                        "but suddenly disappeared during reading. Skipping this file.",
+                    description: `Contrary to expectations, "${targetFileAbsolutePath__forwardSlashSeparators}" file does not exist. ` +
+                        "Skipping this file.",
                     occurrenceLocation: "sourceCodeSelectiveReprocessingHelper." +
-                        "getAbsolutePathsOfExistingAffiliatedFilesOfExistingUpdatedTargetOne(compoundParameter)",
+                        "getAbsolutePathsOfExistingChildrenFilesOfExistingTargetFile__forwardSlashSeparators(compoundParameter)",
                     caughtError: error
                 });
-                return absolutePathsOfExistingAffiliatedFilesOfTargetOne;
+                return absolutePathsOfExistingChildrenFilesOfTargetOne__forwardSlashSeparators;
             }
             es_extensions_1.Logger.logError({
                 mustOutputIf:  true || 0,
                 errorType: es_extensions_1.FileReadingFailedError.NAME,
                 title: es_extensions_1.FileReadingFailedError.localization.defaultTitle,
-                description: es_extensions_1.FileReadingFailedError.localization.generateDescription({ filePath: targetFileAbsolutePath }),
+                description: es_extensions_1.FileReadingFailedError.localization.
+                    generateDescription({ filePath: targetFileAbsolutePath__forwardSlashSeparators }),
                 occurrenceLocation: "sourceCodeSelectiveReprocessingHelper." +
-                    "getAbsolutePathsOfExistingAffiliatedFilesOfExistingUpdatedTargetOne(compoundParameter)",
+                    "getAbsolutePathsOfExistingChildrenFilesOfExistingTargetFile__forwardSlashSeparators(compoundParameter)",
                 caughtError: error
             });
-            return absolutePathsOfExistingAffiliatedFilesOfTargetOne;
+            return absolutePathsOfExistingChildrenFilesOfTargetOne__forwardSlashSeparators;
         }
-        for (const fileIncludingDeclarationPattern of this.affiliatedFilesResolutionRules.affiliatedFilesIncludingDeclarationsPatterns) {
+        for (const fileIncludingDeclarationPattern of this.childrenFilesResolutionRules.childrenFilesIncludingDeclarationsPatterns) {
             /* [ Theory ] Same file could be included for the multiple times.
              *   Occasionally it is even meaningful, but we are not need the duplicated here. */
-            const affiliatedFilesRawPaths = new Set(Array.from(fileContent.matchAll(fileIncludingDeclarationPattern)).
+            const childrenFilesRawPaths = new Set(Array.from(fileContent.matchAll(fileIncludingDeclarationPattern)).
                 map((regularExpressionMatchingData) => regularExpressionMatchingData[1]).
-                filter((affiliatedFileRawPath) => (0, es_extensions_1.isNonEmptyString)(affiliatedFileRawPath)));
-            for (const affiliatedFileRawPath of affiliatedFilesRawPaths) {
-                const affiliatedFileNormalizedPath = this.computeAbsolutePathOfAffiliatedFileIfItExists({
-                    affiliatedFileRawPath,
-                    parentFileDirectoryAbsolutePath: targetFileDirectoryAbsolutePath
+                filter((childFileRawPath) => (0, es_extensions_1.isNonEmptyString)(childFileRawPath)));
+            const targetChildFileDirectoryAbsolutePath__forwardSlashSeparators = preComputedTargetFileDirectoryAbsolutePath__forwardSlashSeparators ??
+                es_extensions_nodejs_1.ImprovedPath.extractDirectoryFromFilePath({
+                    targetPath: targetFileAbsolutePath__forwardSlashSeparators,
+                    ambiguitiesResolution: {
+                        mustConsiderLastSegmentStartingWithDotAsDirectory: false,
+                        mustConsiderLastSegmentWithNonLeadingDotAsDirectory: false,
+                        mustConsiderLastSegmentWihtoutDotsAsFileNameWithoutExtension: true
+                    },
+                    alwaysForwardSlashSeparators: true
+                });
+            for (const childFileRawPath of childrenFilesRawPaths) {
+                const childFileNormalizedPath = this.computeAbsolutePathOfChildFileIfItExists({
+                    childFileRawPath,
+                    parentFileDirectoryAbsolutePath__forwardSlashSeparators: targetChildFileDirectoryAbsolutePath__forwardSlashSeparators
                 });
-                if ((0, es_extensions_1.isNotNull)(affiliatedFileNormalizedPath)) {
-                    absolutePathsOfExistingAffiliatedFilesOfTargetOne.add(affiliatedFileNormalizedPath);
+                if ((0, es_extensions_1.isNotNull)(childFileNormalizedPath)) {
+                    absolutePathsOfExistingChildrenFilesOfTargetOne__forwardSlashSeparators.add(childFileNormalizedPath);
                 }
             }
         }
-        return absolutePathsOfExistingAffiliatedFilesOfTargetOne;
+        return absolutePathsOfExistingChildrenFilesOfTargetOne__forwardSlashSeparators;
     }
-    updateMetadataMapForExistingAffiliatedFile({ targetAffiliatedFileAbsolutePath, parentEntryPointAbsolutePath }) {
-        const targetAffiliatedFileRelativePath = es_extensions_nodejs_1.ImprovedPath.computeRelativePath({
+    computeAbsolutePathOfChildFileIfItExists({ childFileRawPath, parentFileDirectoryAbsolutePath__forwardSlashSeparators }) {
+        let possibleIntermediatePathsOfChildFileWithResolvedAlias = new Set();
+        const segmentsOfChildFileRawPath = es_extensions_nodejs_1.ImprovedPath.explodePathToSegments(childFileRawPath);
+        const firstSegmentOfChildFileRawPath = segmentsOfChildFileRawPath[0];
+        if ((0, es_extensions_1.isNonEmptyString)(firstSegmentOfChildFileRawPath)) {
+            possibleIntermediatePathsOfChildFileWithResolvedAlias = (0, es_extensions_1.createSetBasedOnOtherSet)(this.directoriesAliasesAndTheirAbsolutePatsMap.get(firstSegmentOfChildFileRawPath) ?? new Set(), (absolutePathOfDirectoryOnWhichAliasedFirstPathSegmentCouldRefer) => es_extensions_nodejs_1.ImprovedPath.joinPathSegments((0, es_extensions_1.replaceArrayElementsByIndexesImmutably)({
+                targetArray: segmentsOfChildFileRawPath,
+                index: 0,
+                newElement: absolutePathOfDirectoryOnWhichAliasedFirstPathSegmentCouldRefer
+            }), { alwaysForwardSlashSeparators: true }));
+        }
+        let isChildFileRawPathAliased;
+        if (possibleIntermediatePathsOfChildFileWithResolvedAlias.size > 0) {
+            const previouslyResolvedPathFromAliasedOne = this.resolvedAliasedPaths.get(childFileRawPath);
+            if ((0, es_extensions_1.isString)(previouslyResolvedPathFromAliasedOne)) {
+                try {
+                    if (fs_1.default.existsSync(previouslyResolvedPathFromAliasedOne)) {
+                        return previouslyResolvedPathFromAliasedOne;
+                    }
+                }
+                catch (error) {
+                    if (true) {
+                        es_extensions_1.Logger.logError({
+                            errorType: "FileCheckingError",
+                            title: "File Checking Error",
+                            description: `The error occurred during the checking of the file ${previouslyResolvedPathFromAliasedOne}` +
+                                "for existence.",
+                            occurrenceLocation: "sourceCodeSelectiveReprocessingHelper." +
+                                "computeAbsolutePathOfChildFileIfItExists(compoundParameter)",
+                            caughtError: error
+                        });
+                    }
+                }
+                this.resolvedAliasedPaths.delete(childFileRawPath);
+            }
+            isChildFileRawPathAliased = true;
+        }
+        else {
+            isChildFileRawPathAliased = false;
+            possibleIntermediatePathsOfChildFileWithResolvedAlias = new Set([childFileRawPath]);
+        }
+        const possibleAbsolutePathsOfTargetChildFile__forwardSlashSeparators = new Set();
+        const explicitlySpecifiedLastFileNameExtensionInChildrenFileRawPath = (0, es_extensions_1.extractLastExtensionOfFileName)({ targetPath: childFileRawPath, withLeadingDot: false });
+        /* [ Approach ]
+        * The second condition of if-branch is aimed to the processing of paths with multiple files names extensions.
+        * For example, in the Pug preprocessor case, the file "ProductCard.static.pug" could be referred as
+        *   `include ProductCard.static`. */
+        if ((0, es_extensions_1.isNull)(explicitlySpecifiedLastFileNameExtensionInChildrenFileRawPath) ||
+            !this.childrenFilesResolutionRules.implicitFilesNamesExtensionsWithoutLeadingDotsOfChildrenFiles.
+                includes(explicitlySpecifiedLastFileNameExtensionInChildrenFileRawPath)) {
+            for (const possibleIntermediatePathOfChildFileWithResolvedAlias of possibleIntermediatePathsOfChildFileWithResolvedAlias) {
+                (0, es_extensions_1.addMultipleElementsToSet)(possibleAbsolutePathsOfTargetChildFile__forwardSlashSeparators, this.childrenFilesResolutionRules.implicitFilesNamesExtensionsWithoutLeadingDotsOfChildrenFiles.map((childFileNameImplicitExtension) => es_extensions_nodejs_1.ImprovedPath.joinPathSegments([
+                    ...path_1.default.isAbsolute(possibleIntermediatePathOfChildFileWithResolvedAlias) ?
+                        [] : [parentFileDirectoryAbsolutePath__forwardSlashSeparators],
+                    `${possibleIntermediatePathOfChildFileWithResolvedAlias}.${childFileNameImplicitExtension}`
+                ], { alwaysForwardSlashSeparators: true })));
+            }
+        }
+        else {
+            for (const possibleIntermediatePathOfChildFileWithResolvedAlias of possibleIntermediatePathsOfChildFileWithResolvedAlias) {
+                possibleAbsolutePathsOfTargetChildFile__forwardSlashSeparators.add(es_extensions_nodejs_1.ImprovedPath.joinPathSegments([
+                    ...path_1.default.isAbsolute(possibleIntermediatePathOfChildFileWithResolvedAlias) ?
+                        [] : [parentFileDirectoryAbsolutePath__forwardSlashSeparators],
+                    possibleIntermediatePathOfChildFileWithResolvedAlias
+                ], { alwaysForwardSlashSeparators: true }));
+            }
+        }
+        for (const possibleAbsolutePathOfTargetChildFile of possibleAbsolutePathsOfTargetChildFile__forwardSlashSeparators) {
+            try {
+                if (fs_1.default.existsSync(possibleAbsolutePathOfTargetChildFile)) {
+                    if (isChildFileRawPathAliased) {
+                        this.resolvedAliasedPaths.set(childFileRawPath, possibleAbsolutePathOfTargetChildFile);
+                    }
+                    return possibleAbsolutePathOfTargetChildFile;
+                }
+            }
+            catch (error) {
+                if (true) {
+                    es_extensions_1.Logger.logError({
+                        errorType: "FileCheckingError",
+                        title: "File Checking Error",
+                        description: `The error occurred during the checking of the file ${possibleAbsolutePathOfTargetChildFile}` +
+                            "for existence.",
+                        occurrenceLocation: "sourceCodeSelectiveReprocessingHelper." +
+                            "computeAbsolutePathOfChildFileIfItExists(compoundParameter)",
+                        caughtError: error
+                    });
+                }
+                return null;
+            }
+        }
+        return null;
+    }
+    updateMetadataForExistingChildFile({ targetChildFileAbsolutePath__forwardSlashSeparators, parentEntryPointAbsolutePath__forwardSlashSeparators }) {
+        const targetChildFileRelativePath__forwardSlashSeparators = es_extensions_nodejs_1.ImprovedPath.computeRelativePath({
             basePath: this.CONSUMING_PROJECT_ROOT_DIRECTORY_ABSOLUTE_PATH,
-            comparedPath: targetAffiliatedFileAbsolutePath,
+            comparedPath: targetChildFileAbsolutePath__forwardSlashSeparators,
             alwaysForwardSlashSeparators: true
         });
-        const cachedMetadataOfCurrentAffiliatedFile = this.affiliatedFilesMetadata.get(targetAffiliatedFileRelativePath);
+        const cachedMetadataOfCurrentChildFile = this.childrenFilesMetadata.get(targetChildFileRelativePath__forwardSlashSeparators);
         es_extensions_1.Logger.logGeneric({
             mustOutputIf: SourceCodeSelectiveReprocessingHelper.DEBUGGING_MODE,
             badge: { customText: "Debug" },
-            title: "SourceCodeSelectiveReprocessingHelper, updating of affiliated files metadata map.",
-            description: `The metadata of affiliated file "${targetAffiliatedFileRelativePath}" .\n`,
+            title: "SourceCodeSelectiveReprocessingHelper, Updating of Children Files Metadata",
+            description: targetChildFileRelativePath__forwardSlashSeparators,
             additionalData: {
-                absolutePathsOfAffiliatedFilesWhichHasBeenScannedDuringCurrentPass: this.absolutePathsOfAffiliatedFilesWhichHasBeenScannedDuringCurrentPass
+                absolutePathsOfAffiliatedFilesWhichHasBeenScannedDuringCurrentPass: this.absolutePathsOfChildrenFilesWhichHasBeenScannedDuringCurrentPass
             }
         });
-        /* [ Approach ] If the file has been scanned it must be in the cache however for the TypeScript type checking
-        *   the non-undefined check of "cachedMetadataOfCurrentAffiliatedFile" additionally required. */
-        if (this.absolutePathsOfAffiliatedFilesWhichHasBeenScannedDuringCurrentPass.has(targetAffiliatedFileRelativePath) &&
-            (0, es_extensions_1.isNotUndefined)(cachedMetadataOfCurrentAffiliatedFile)) {
-            cachedMetadataOfCurrentAffiliatedFile.parentEntryPointsAbsolutePaths.add(parentEntryPointAbsolutePath);
+        /* [ Approach ] If the child file has been scanned it must be in the `childrenFilesMetadata` however for the
+        *    TypeScript type checking the non-undefined check of "cachedMetadataOfCurrentAffiliatedFile" additionally
+        *    required. */
+        if (this.absolutePathsOfChildrenFilesWhichHasBeenScannedDuringCurrentPass.
+            has(targetChildFileRelativePath__forwardSlashSeparators) &&
+            (0, es_extensions_1.isNotUndefined)(cachedMetadataOfCurrentChildFile)) {
+            cachedMetadataOfCurrentChildFile.parentEntryPointsAbsolutePaths.
+                add(parentEntryPointAbsolutePath__forwardSlashSeparators);
             this.registerEntryPointAsParentTo({
-                cachedMetadataOfCurrentAffiliatedFile,
-                parentEntryPointAbsolutePath
+                cachedMetadataOfTargetChildFile: cachedMetadataOfCurrentChildFile,
+                parentEntryPointAbsolutePath__forwardSlashSeparators
             });
             return;
         }
-        let targetAffiliatedFileModificationDateTime__ISO8601;
+        let targetChildFileModificationDateTime__ISO8601;
         try {
-            targetAffiliatedFileModificationDateTime__ISO8601 = fs_1.default.
-                statSync(targetAffiliatedFileAbsolutePath).mtime.toISOString();
+            targetChildFileModificationDateTime__ISO8601 = fs_1.default.
+                statSync(targetChildFileAbsolutePath__forwardSlashSeparators).mtime.toISOString();
         }
         catch (error) {
             es_extensions_1.Logger.logError({
                 errorType: "FileStatisticsRetrievingFailedError",
-                title: "File statistics retrieving failed error",
-                description: `Unable to retrieve the statistics of file "${targetAffiliatedFileAbsolutePath}". ` +
+                title: "File Statistics Retrieving Failed Error",
+                description: `Unable to retrieve the statistics of file "${targetChildFileAbsolutePath__forwardSlashSeparators}". ` +
                     "This file will not be mapped.",
-                occurrenceLocation: "sourceCodeSelectiveReprocessingHelper." +
-                    "updateMetadataMapForExistingAffiliatedFile(propertiesObject)",
+                occurrenceLocation: "sourceCodeSelectiveReprocessingHelper.updateMetadataForExistingChildFile(compoundParameter)",
                 caughtError: error
             });
             return;
         }
-        let absolutePathsOfExistingAffiliatedFilesOfTargetOne;
-        if ((0, es_extensions_1.isNotUndefined)(cachedMetadataOfCurrentAffiliatedFile) &&
-            cachedMetadataOfCurrentAffiliatedFile.modificationDateTime__ISO8601 === targetAffiliatedFileModificationDateTime__ISO8601) {
-            absolutePathsOfExistingAffiliatedFilesOfTargetOne = new Set();
-            /* [ Theory ] Although the affiliated file is existing and has not changed since last mapping, its affiliated
+        let absolutePathsOfExistingChildrenFilesOfTargetOne__forwardSlashSeparators;
+        if (cachedMetadataOfCurrentChildFile?.modificationDateTime__ISO8601 === targetChildFileModificationDateTime__ISO8601) {
+            absolutePathsOfExistingChildrenFilesOfTargetOne__forwardSlashSeparators = new Set();
+            /* [ Theory ] Although the children file is existing and has not changed since last mapping, its children
              *   files could be added or deleted. */
-            for (const relativePathOfAffiliatedFileOfCurrentOne of cachedMetadataOfCurrentAffiliatedFile.directAffiliatedFilesRelativePaths) {
-                const absolutePathOfAffiliatedFileOfCurrentOne = es_extensions_nodejs_1.ImprovedPath.joinPathSegments([this.CONSUMING_PROJECT_ROOT_DIRECTORY_ABSOLUTE_PATH, relativePathOfAffiliatedFileOfCurrentOne], { alwaysForwardSlashSeparators: true });
-                if (!fs_1.default.existsSync(absolutePathOfAffiliatedFileOfCurrentOne)) {
-                    cachedMetadataOfCurrentAffiliatedFile.directAffiliatedFilesRelativePaths.
-                        delete(relativePathOfAffiliatedFileOfCurrentOne);
+            for (const relativePathOfChildFileOfCurrentOne of cachedMetadataOfCurrentChildFile.directChildrenFilesRelativePaths) {
+                const absolutePathOfChildFileOfCurrentOne__forwardSlashSeparators = es_extensions_nodejs_1.ImprovedPath.joinPathSegments([this.CONSUMING_PROJECT_ROOT_DIRECTORY_ABSOLUTE_PATH, relativePathOfChildFileOfCurrentOne], { alwaysForwardSlashSeparators: true });
+                if (!fs_1.default.existsSync(absolutePathOfChildFileOfCurrentOne__forwardSlashSeparators)) {
+                    cachedMetadataOfCurrentChildFile.directChildrenFilesRelativePaths.delete(relativePathOfChildFileOfCurrentOne);
                 }
-                absolutePathsOfExistingAffiliatedFilesOfTargetOne = new Set(Array.from(cachedMetadataOfCurrentAffiliatedFile.directAffiliatedFilesRelativePaths));
+                absolutePathsOfExistingChildrenFilesOfTargetOne__forwardSlashSeparators = new Set(Array.from(cachedMetadataOfCurrentChildFile.directChildrenFilesRelativePaths));
             }
-            cachedMetadataOfCurrentAffiliatedFile.parentEntryPointsAbsolutePaths.add(parentEntryPointAbsolutePath);
+            cachedMetadataOfCurrentChildFile.parentEntryPointsAbsolutePaths.
+                add(parentEntryPointAbsolutePath__forwardSlashSeparators);
         }
         else {
-            absolutePathsOfExistingAffiliatedFilesOfTargetOne = this.
-                getAbsolutePathsOfExistingAffiliatedFilesOfExistingUpdatedTargetOne({
-                targetFileAbsolutePath: targetAffiliatedFileAbsolutePath,
-                targetFileDirectoryAbsolutePath: es_extensions_nodejs_1.ImprovedPath.extractDirectoryFromFilePath({
-                    targetPath: targetAffiliatedFileAbsolutePath,
-                    alwaysForwardSlashSeparators: true,
-                    ambiguitiesResolution: {
-                        mustConsiderLastSegmentStartingWithDotAsDirectory: false,
-                        mustConsiderLastSegmentWithNonLeadingDotAsDirectory: false,
-                        mustConsiderLastSegmentWihtoutDotsAsFileNameWithoutExtension: true
-                    }
-                })
-            });
-            this.affiliatedFilesMetadata.set(targetAffiliatedFileRelativePath, {
-                parentEntryPointsAbsolutePaths: new Set([parentEntryPointAbsolutePath]),
-                modificationDateTime__ISO8601: targetAffiliatedFileModificationDateTime__ISO8601,
-                directAffiliatedFilesRelativePaths: (0, es_extensions_1.createSetBasedOnOtherSet)(absolutePathsOfExistingAffiliatedFilesOfTargetOne, (absolutePathOfExistingAffiliatedFileOfCurrentOne) => es_extensions_nodejs_1.ImprovedPath.computeRelativePath({
+            absolutePathsOfExistingChildrenFilesOfTargetOne__forwardSlashSeparators = this.
+                getAbsolutePathsOfExistingChildrenFilesOfExistingTargetFile__forwardSlashSeparators({
+                targetFileAbsolutePath__forwardSlashSeparators: targetChildFileAbsolutePath__forwardSlashSeparators
+            });
+            this.childrenFilesMetadata.set(targetChildFileRelativePath__forwardSlashSeparators, {
+                parentEntryPointsAbsolutePaths: new Set([parentEntryPointAbsolutePath__forwardSlashSeparators]),
+                modificationDateTime__ISO8601: targetChildFileModificationDateTime__ISO8601,
+                directChildrenFilesRelativePaths: (0, es_extensions_1.createSetBasedOnOtherSet)(absolutePathsOfExistingChildrenFilesOfTargetOne__forwardSlashSeparators, (absolutePathOfExistingAffiliatedFileOfCurrentOne) => es_extensions_nodejs_1.ImprovedPath.computeRelativePath({
                     basePath: this.CONSUMING_PROJECT_ROOT_DIRECTORY_ABSOLUTE_PATH,
                     comparedPath: absolutePathOfExistingAffiliatedFileOfCurrentOne,
                     alwaysForwardSlashSeparators: true
                 }))
             });
         }
-        this.absolutePathsOfAffiliatedFilesWhichHasBeenScannedDuringCurrentPass.add(targetAffiliatedFileRelativePath);
-        if (SourceCodeSelectiveReprocessingHelper.DEBUGGING_MODE) {
-            es_extensions_1.Logger.logInfo({
-                badge: { customText: "Debug" },
-                title: "SourceCodeSelectiveReprocessingHelper, affiliated files scanning complete.",
-                description: `The metadata of affiliated file "${targetAffiliatedFileRelativePath}"has been updated.\n`,
-                additionalData: {
-                    affiliatedFilesMetadata: this.affiliatedFilesMetadata
-                }
-            });
-        }
-        for (const absolutePathOfExistingAffiliatedFileOfTargetOne of absolutePathsOfExistingAffiliatedFilesOfTargetOne) {
-            this.updateMetadataMapForExistingAffiliatedFile({
-                targetAffiliatedFileAbsolutePath: absolutePathOfExistingAffiliatedFileOfTargetOne,
-                parentEntryPointAbsolutePath
+        this.absolutePathsOfChildrenFilesWhichHasBeenScannedDuringCurrentPass.
+            add(targetChildFileRelativePath__forwardSlashSeparators);
+        for (const absolutePathOfExistingAffiliatedFileOfTargetOne__forwardSlashSeparators of absolutePathsOfExistingChildrenFilesOfTargetOne__forwardSlashSeparators) {
+            this.updateMetadataForExistingChildFile({
+                targetChildFileAbsolutePath__forwardSlashSeparators: absolutePathOfExistingAffiliatedFileOfTargetOne__forwardSlashSeparators,
+                parentEntryPointAbsolutePath__forwardSlashSeparators
             });
         }
     }
-    computeAbsolutePathOfAffiliatedFileIfItExists({ affiliatedFileRawPath, parentFileDirectoryAbsolutePath }) {
-        const possibleAbsolutePathsOfTargetAffiliatedFile = new Set();
-        const explicitlySpecifiedLastFileNameExtensionInAffiliatedFileRawPath = (0, es_extensions_1.extractLastExtensionOfFileName)({ targetPath: affiliatedFileRawPath, withLeadingDot: false });
-        /* [ Approach ]
-        * The second condition is aimed to the processing of paths with multiple files names extensions.
-        * For example, in the Pug preprocessor case, the file "ProductCard.static.pug" could be referred as
-        *   `include ProductCard.static`. */
-        if ((0, es_extensions_1.isNull)(explicitlySpecifiedLastFileNameExtensionInAffiliatedFileRawPath) ||
-            !this.affiliatedFilesResolutionRules.implicitFilesNamesExtensionsWithoutLeadingDotsOfAffiliatedFiles.
-                includes(explicitlySpecifiedLastFileNameExtensionInAffiliatedFileRawPath)) {
-            (0, es_extensions_1.addMultipleElementsToSet)(possibleAbsolutePathsOfTargetAffiliatedFile, this.affiliatedFilesResolutionRules.implicitFilesNamesExtensionsWithoutLeadingDotsOfAffiliatedFiles.map((affiliatedFileNameImplicitExtension) => es_extensions_nodejs_1.ImprovedPath.joinPathSegments([parentFileDirectoryAbsolutePath, `${affiliatedFileRawPath}.${affiliatedFileNameImplicitExtension}`], { alwaysForwardSlashSeparators: true })));
-        }
-        else {
-            possibleAbsolutePathsOfTargetAffiliatedFile.add(es_extensions_nodejs_1.ImprovedPath.joinPathSegments([parentFileDirectoryAbsolutePath, affiliatedFileRawPath], { alwaysForwardSlashSeparators: true }));
-        }
-        for (const possibleAbsolutePathOfTargetAffiliatedFile of possibleAbsolutePathsOfTargetAffiliatedFile) {
-            try {
-                if (fs_1.default.existsSync(possibleAbsolutePathOfTargetAffiliatedFile)) {
-                    return possibleAbsolutePathOfTargetAffiliatedFile;
-                }
-            }
-            catch (error) {
-                if (true) {
-                    es_extensions_1.Logger.logError({
-                        errorType: "FileCheckingError",
-                        title: "File checking error",
-                        description: `The error occurred during the checking of the file ${possibleAbsolutePathOfTargetAffiliatedFile}` +
-                            "for existence.",
-                        occurrenceLocation: "sourceCodeSelectiveReprocessingHelper." +
-                            "computeAbsolutePathOfAffiliatedFileIfItExists(compoundParameter)",
-                        caughtError: error
-                    });
-                }
-                return null;
-            }
-        }
-        return null;
-    }
-    registerEntryPointAsParentTo({ cachedMetadataOfCurrentAffiliatedFile, parentEntryPointAbsolutePath }) {
-        for (const relativePathsOfDirectAffiliatedFileOfCurrentOne of cachedMetadataOfCurrentAffiliatedFile.directAffiliatedFilesRelativePaths) {
-            const cachedMetadataOfAffiliatedFileOfCurrentOne = this.affiliatedFilesMetadata.get(relativePathsOfDirectAffiliatedFileOfCurrentOne);
-            if ((0, es_extensions_1.isUndefined)(cachedMetadataOfAffiliatedFileOfCurrentOne)) {
+    registerEntryPointAsParentTo({ cachedMetadataOfTargetChildFile, parentEntryPointAbsolutePath__forwardSlashSeparators }) {
+        for (const relativePathsOfDirectChildFileOfCurrentOne__forwardSlashSeparators of cachedMetadataOfTargetChildFile.directChildrenFilesRelativePaths) {
+            const cachedMetadataOfChildFileOfCurrentOne = this.childrenFilesMetadata.get(relativePathsOfDirectChildFileOfCurrentOne__forwardSlashSeparators);
+            if ((0, es_extensions_1.isUndefined)(cachedMetadataOfChildFileOfCurrentOne)) {
                 continue;
             }
-            cachedMetadataOfAffiliatedFileOfCurrentOne.parentEntryPointsAbsolutePaths.add(parentEntryPointAbsolutePath);
+            cachedMetadataOfChildFileOfCurrentOne.parentEntryPointsAbsolutePaths.
+                add(parentEntryPointAbsolutePath__forwardSlashSeparators);
             this.registerEntryPointAsParentTo({
-                cachedMetadataOfCurrentAffiliatedFile: cachedMetadataOfAffiliatedFileOfCurrentOne,
-                parentEntryPointAbsolutePath
+                cachedMetadataOfTargetChildFile: cachedMetadataOfChildFileOfCurrentOne,
+                parentEntryPointAbsolutePath__forwardSlashSeparators
             });
         }
     }
-    /* === Cache file ================================================================================================= */
-    cacheFilesMetadataMapsToFile() {
+    clearFileMetadataPathFromCache(targetFileRelativePath__forwardSlashesPathSeparators) {
+        this.entryPointsMetadata.delete(targetFileRelativePath__forwardSlashesPathSeparators);
+        for (const entryPointMetadata of this.entryPointsMetadata.values()) {
+            entryPointMetadata.directChildrenFilesRelativePaths.delete(targetFileRelativePath__forwardSlashesPathSeparators);
+        }
+        this.childrenFilesMetadata.delete(targetFileRelativePath__forwardSlashesPathSeparators);
+        for (const childFileMetadata of this.childrenFilesMetadata.values()) {
+            childFileMetadata.directChildrenFilesRelativePaths.delete(targetFileRelativePath__forwardSlashesPathSeparators);
+            childFileMetadata.parentEntryPointsAbsolutePaths.delete(targetFileRelativePath__forwardSlashesPathSeparators);
+        }
+    }
+    /* ─── Cache File ───────────────────────────────────────────────────────────────────────────────────────────────── */
+    saveCachedFilesMetadataMapsToFile() {
         const outputData = {
             entryPoints: Array.from(this.entryPointsMetadata.entries()).
                 reduce((entryPointsMetadata, [entryPointPathRelativeToConsumingProjectRootDirectory, entryPointMetadata]) => {
                 entryPointsMetadata[entryPointPathRelativeToConsumingProjectRootDirectory] = {
                     modificationDate__ISO8601: entryPointMetadata.modificationDate__ISO8601,
-                    directAffiliatedFilesRelativePaths: Array.from(entryPointMetadata.directAffiliatedFilesRelativePaths)
+                    directChildrenFilesRelativePaths: Array.from(entryPointMetadata.directChildrenFilesRelativePaths)
                 };
                 return entryPointsMetadata;
             }, {}),
-            affiliatedFiles: Array.from(this.affiliatedFilesMetadata.entries()).
-                reduce((affiliatedFilesMetadata, [affiliatedFilePathRelativeToConsumingProjectRootDirectory, affiliatedFileMetadata]) => {
-                affiliatedFilesMetadata[affiliatedFilePathRelativeToConsumingProjectRootDirectory] = {
-                    modificationDate__ISO8601: affiliatedFileMetadata.modificationDateTime__ISO8601,
-                    directAffiliatedFilesRelativePaths: Array.from(affiliatedFileMetadata.directAffiliatedFilesRelativePaths),
-                    parentEntryPointsRelativePaths: Array.from(affiliatedFileMetadata.parentEntryPointsAbsolutePaths).
+            childrenFiles: Array.from(this.childrenFilesMetadata.entries()).
+                reduce((childrenFilesMetadata, [childFilePathRelativeToConsumingProjectRootDirectory, childFileMetadata]) => {
+                childrenFilesMetadata[childFilePathRelativeToConsumingProjectRootDirectory] = {
+                    modificationDate__ISO8601: childFileMetadata.modificationDateTime__ISO8601,
+                    directChildrenFilesRelativePaths: Array.from(childFileMetadata.directChildrenFilesRelativePaths),
+                    parentEntryPointsRelativePaths: Array.from(childFileMetadata.parentEntryPointsAbsolutePaths).
                         map((parentEntryPointsAbsolutePath) => es_extensions_nodejs_1.ImprovedPath.computeRelativePath({
                         basePath: this.CONSUMING_PROJECT_ROOT_DIRECTORY_ABSOLUTE_PATH,
                         comparedPath: parentEntryPointsAbsolutePath,
                         alwaysForwardSlashSeparators: true
                     }))
                 };
-                return affiliatedFilesMetadata;
+                return childrenFilesMetadata;
             }, {})
         };
         fs_1.default.writeFileSync(this.CACHED_METADATA_FILE_ABSOLUTE_PATH, (0, es_extensions_1.stringifyAndFormatArbitraryValue)(outputData));
     }
-    /* === Incremental remapping ====================================================================================== */
-    /* ━━━ Logging ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ */
-    logAffiliatedFilesAndEntryPointsRelationships() {
+    /* ─── Logging ──────────────────────────────────────────────────────────────────────────────────────────────────── */
+    logChildrenFilesAndEntryPointsRelationships() {
         let accumulatingString = "";
-        for (const [affiliatedFileRelativePath, affiliatedFileMetadata] of this.affiliatedFilesMetadata.entries()) {
-            accumulatingString = `${accumulatingString}File: "${affiliatedFileRelativePath}" has parents:\n`;
-            for (const entryPointFileAbsolutePath of affiliatedFileMetadata.parentEntryPointsAbsolutePaths) {
+        for (const [childFileRelativePath, childFileMetadata] of this.childrenFilesMetadata.entries()) {
+            accumulatingString = `${accumulatingString}File: "${childFileRelativePath}" has parents:\n`;
+            for (const entryPointFileAbsolutePath of childFileMetadata.parentEntryPointsAbsolutePaths) {
                 accumulatingString = `${accumulatingString}  ● ${es_extensions_nodejs_1.ImprovedPath.computeRelativePath({
                     basePath: this.CONSUMING_PROJECT_ROOT_DIRECTORY_ABSOLUTE_PATH,
                     comparedPath: entryPointFileAbsolutePath,
@@ -14774,8 +15027,8 @@ class SourceCodeSelectiveReprocessingHelper {
             }
         }
         es_extensions_1.Logger.logInfo({
-            title: `${this.TARGET_FILES_TYPE_IN_SINGULAR_FORM} Affiliated Files and Respective Parent Entry Points Relationships`,
-            description: accumulatingString.length > 0 ? accumulatingString : "No existing affiliated files has been found."
+            title: `${this.TARGET_FILES_TYPE_IN_SINGULAR_FORM} Children Files and Respective Parent Entry Points Relationships`,
+            description: accumulatingString.length > 0 ? accumulatingString : "No existing children files has been found."
         });
     }
 }
@@ -14858,11 +15111,11 @@ exports["default"] = VinylFileClass;
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports["default"] = createImmediatelyEndingEmptyStream;
 const stream_1 = __webpack_require__(/*! stream */ "stream");
 function createImmediatelyEndingEmptyStream() {
     return () => new stream_1.PassThrough().end();
 }
-exports["default"] = createImmediatelyEndingEmptyStream;
 
 
 /***/ }),
@@ -14875,6 +15128,7 @@ exports["default"] = createImmediatelyEndingEmptyStream;
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports["default"] = extractStringifiedContentFromVinylFile;
 function extractStringifiedContentFromVinylFile(targetFile) {
     if (targetFile.contents === null) {
         return "";
@@ -14884,7 +15138,6 @@ function extractStringifiedContentFromVinylFile(targetFile) {
     }
     return targetFile.contents.toString();
 }
-exports["default"] = extractStringifiedContentFromVinylFile;
 
 
 /***/ }),
@@ -15321,7 +15574,7 @@ function revisionHash(data) {
   \***********************/
 /***/ ((module) => {
 
-module.exports = /*#__PURE__*/JSON.parse('{"name":"@yamato-daiwa/automation","version":"0.5.0-alpha.1","description":"The project building tool with declarative YAML configuration specializing on Pug, Stylus and TypeScript as source code languages.","keywords":["build","pug","stylus","tool","typescript"],"engines":{"node":">=18.18.0"},"bin":{"yda":"Executable"},"files":["EntryPoint.js"],"dependencies":{"@stylistic/eslint-plugin":"1.7.2","@typescript-eslint/eslint-plugin":"7.12.0","@typescript-eslint/parser":"7.12.0","@vue/compiler-sfc":"3.4.27","@webdiscus/pug-loader":"2.11.0","@yamato-daiwa/es-extensions":"1.7.0-rc.2","@yamato-daiwa/es-extensions-nodejs":"1.7.0-alpha.10","@yamato-daiwa/style_guides":"0.2.7","autoprefixer":"10.4.19","browser-sync":"3.0.2","css-loader":"7.1.2","cssnano":"7.0.2","eslint":"8.57.0","eslint-plugin-import":"2.29.1","eslint-plugin-node":"11.1.0","eslint-plugin-react":"7.34.2","eslint-plugin-vue":"9.26.0","eslint-plugin-vue-pug":"0.6.2","fork-ts-checker-webpack-plugin":"7.3.0","gulp":"4.0.2","gulp-data":"1.3.1","gulp-html-prettify":"0.0.1","gulp-if":"3.0.0","gulp-imagemin":"7.1.0","gulp-nodemon":"2.5.0","gulp-plumber":"1.2.1","gulp-postcss":"10.0.0","gulp-pug":"5.0.0","gulp-sourcemaps":"3.0.0","gulp-stylus":"3.0.1","imagemin-pngquant":"9.0.2","json5-loader":"4.0.1","node-html-parser":"6.1.13","node-notifier":"10.0.1","pa11y":"8.0.0","probe-image-size":"7.2.3","pug3-ast-loader":"0.0.0","pug-lint":"2.7.0","puppeteer":"22.10.0","rev-hash":"4.1.0","stlint":"1.0.65","stream-combiner2":"1.1.1","style-loader":"4.0.0","stylus":"0.63.0","stylus-loader":"8.1.0","ts-loader":"9.5.1","vinyl":"2.2.1","vue-loader":"17.4.2","vue-style-loader":"4.1.3","w3c-html-validator":"0.8.1","webpack":"5.91.0","webpack-node-externals":"3.0.0","webpack-stream":"7.0.0","worker-loader":"3.0.8","yaml-loader":"0.8.1"},"devDependencies":{"@types/browser-sync":"2.29.0","@types/cssnano":"5.0.0","@types/gulp":"4.0.17","@types/gulp-html-prettify":"0.0.5","@types/gulp-if":"3.0.4","@types/gulp-imagemin":"8.0.6","@types/gulp-nodemon":"0.0.37","@types/gulp-plumber":"0.0.37","@types/gulp-postcss":"8.0.6","@types/gulp-sourcemaps":"0.0.38","@types/gulp-stylus":"2.7.8","@types/node":"20.14.2","@types/node-notifier":"8.0.5","@types/pa11y":"5.3.7","@types/probe-image-size":"7.2.4","@types/pug":"2.0.10","@types/webpack-node-externals":"3.0.4","@types/webpack-stream":"3.2.15","eslint-webpack-plugin":"4.2.0","ts-node":"10.9.2","typescript":"5.4.5","webpack-cli":"5.1.4"},"scripts":{"Incremental development building":"webpack --mode development","Production building":"webpack --mode production","Linting":"eslint Source","Tree diagram of source files generating":"tree Source /f"},"license":"MIT","repository":{"type":"git","url":"git+https://github.com/TokugawaTakeshi/Yamato-Daiwa-Automation.git"},"bugs":{"url":"https://github.com/TokugawaTakeshi/Yamato-Daiwa-Automation/issues","email":"tokugawa.takesi@gmail.com"}}');
+module.exports = /*#__PURE__*/JSON.parse('{"name":"@yamato-daiwa/automation","version":"0.5.0-alpha.3","description":"The project building tool with declarative YAML configuration specializing on Pug, Stylus and TypeScript as source code languages.","keywords":["build","pug","stylus","tool","typescript"],"engines":{"node":">=18.18.0"},"bin":{"yda":"Executable"},"files":["EntryPoint.js"],"dependencies":{"@stylistic/eslint-plugin":"2.8.0","@typescript-eslint/eslint-plugin":"8.8.0","@typescript-eslint/parser":"8.8.0","@vue/compiler-sfc":"3.4.27","@webdiscus/pug-loader":"2.11.0","@yamato-daiwa/es-extensions":"1.8.0-alpha.2","@yamato-daiwa/es-extensions-nodejs":"1.8.0-alpha.1","@yamato-daiwa/style_guides":"0.3.0-alpha.8","autoprefixer":"10.4.19","browser-sync":"3.0.2","css-loader":"7.1.2","cssnano":"7.0.2","eslint":"9.12.0","eslint-plugin-import":"2.31.0","eslint-plugin-n":"17.10.3","eslint-plugin-react":"7.37.1","eslint-plugin-vue":"9.28.0","eslint-plugin-vue-pug":"0.6.2","fork-ts-checker-webpack-plugin":"7.3.0","gulp":"4.0.2","gulp-data":"1.3.1","gulp-html-prettify":"0.0.1","gulp-if":"3.0.0","gulp-imagemin":"7.1.0","gulp-nodemon":"2.5.0","gulp-plumber":"1.2.1","gulp-postcss":"10.0.0","gulp-pug":"5.0.0","gulp-sourcemaps":"3.0.0","gulp-stylus":"3.0.1","imagemin-pngquant":"9.0.2","json5-loader":"4.0.1","node-html-parser":"6.1.13","node-notifier":"10.0.1","pa11y":"8.0.0","probe-image-size":"7.2.3","pug3-ast-loader":"0.0.0","pug-lint":"2.7.0","puppeteer":"22.10.0","rev-hash":"4.1.0","stlint":"1.0.65","stream-combiner2":"1.1.1","style-loader":"4.0.0","stylus":"0.63.0","stylus-loader":"8.1.0","ts-loader":"9.5.1","vinyl":"2.2.1","vue-loader":"17.4.2","vue-style-loader":"4.1.3","w3c-html-validator":"0.8.1","webpack":"5.91.0","webpack-node-externals":"3.0.0","webpack-stream":"7.0.0","worker-loader":"3.0.8","yaml-loader":"0.8.1"},"devDependencies":{"@types/browser-sync":"2.29.0","@types/cssnano":"5.0.0","@types/gulp":"4.0.17","@types/gulp-html-prettify":"0.0.5","@types/gulp-if":"3.0.4","@types/gulp-imagemin":"7.0.3","@types/gulp-nodemon":"0.0.37","@types/gulp-plumber":"0.0.37","@types/gulp-postcss":"8.0.6","@types/gulp-sourcemaps":"0.0.38","@types/gulp-stylus":"2.7.8","@types/node":"20.14.2","@types/node-notifier":"8.0.5","@types/pa11y":"5.3.7","@types/probe-image-size":"7.2.4","@types/pug":"2.0.10","@types/webpack-node-externals":"3.0.4","@types/webpack-stream":"3.2.15","eslint-webpack-plugin":"4.2.0","ts-node":"10.9.2","typescript":"5.5.4","webpack-cli":"5.1.4"},"scripts":{"Incremental development building":"webpack --mode development","Production building":"webpack --mode production","Linting":"eslint Source","Tree diagram of source files generating":"tree Source /f"},"license":"MIT","repository":{"type":"git","url":"git+https://github.com/TokugawaTakeshi/Yamato-Daiwa-Automation.git"},"bugs":{"url":"https://github.com/TokugawaTakeshi/Yamato-Daiwa-Automation/issues","email":"tokugawa.takesi@gmail.com"}}');
 
 /***/ })