@zohodesk/react-cli 1.1.11-exp.5 → 1.1.11-exp.6

package/packages/client_build_tool/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/index.js

@@ -1,39 +1,401 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.pluginName = exports.default = void 0;
+var _webpack = require("webpack");
+
+var _htmlWebpackPlugin = _interopRequireDefault(require("html-webpack-plugin"));
+
+var _constants = require("./constants");
 
 var _I18nKeysIdentifer = _interopRequireDefault(require("./I18nKeysIdentifer"));
 
+var _getI18nModule = require("./getI18nModule");
+
+var _getI18nDependency = require("./getI18nDependency");
+
 var _optionsHandler = require("./optionsHandler");
 
-var _I18nFilesEmitPlugin = require("./I18nFilesEmitPlugin");
+var _getI18nLoadingRuntimeModule = require("./getI18nLoadingRuntimeModule");
+
+var _createHash = require("./createHash");
+
+var _pathCreator = require("./pathCreator");
+
+var _templateFileName = require("./templateFileName");
+
+var _hashUtils = require("./utils/hashUtils");
 
-var _I18nRuntimeDealerPlugin = require("./I18nRuntimeDealerPlugin");
+var _propertiesUtils = require("./utils/propertiesUtils");
+
+var _urlConcat = require("../../../../server/urlConcat");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+/* eslint-disable no-restricted-syntax */
+
+/* eslint-disable no-nested-ternary */
 // import getI18nKeysFormModules from './utils/getI18nKeysFormModules';
 const pluginName = 'mini-i18n-extract-plugin';
-exports.pluginName = pluginName;
 const pluginSymbol = Symbol(pluginName);
 
+function getChunkModules(chunk, chunkGraph) {
+  return typeof chunkGraph !== 'undefined' ? chunkGraph.getChunkModules(chunk) : chunk.modulesIterable;
+}
+
 class I18nExtractPlugin {
   constructor(options = {}) {
     // initialize options
     this.options = (0, _optionsHandler.optionsHandler)(options);
   }
 
+  getI18nKeysForChunk(chunk, chunkGraph) {
+    const {
+      modulesI18nKeysMap
+    } = this.i18nKeysIdentifer;
+    const i18nKeysMap = {};
+
+    for (const mod of getChunkModules(chunk, chunkGraph)) {
+      const keys = modulesI18nKeysMap[mod.resource];
+
+      if (keys) {
+        for (const key of keys) {
+          i18nKeysMap[key] = 1;
+        }
+      }
+    }
+
+    return Object.keys(i18nKeysMap);
+  }
+
+  getI18nContentForkeys(i18nKeys, locale) {
+    const {
+      allI18nObject
+    } = this.options;
+    const data = {};
+
+    for (const key of i18nKeys) {
+      data[key] = allI18nObject[locale][key];
+    }
+
+    return data;
+  }
+
+  getI18nChunkFileContent(i18nKeys, loc) {
+    const {
+      jsonpFunc
+    } = this.options;
+    const data = this.getI18nContentForkeys(i18nKeys, loc);
+    return `${jsonpFunc}(${(0, _propertiesUtils.jsonToString)(data)})`;
+  }
+
+  filterI18nUsedChunks(chunks) {
+    const {
+      localeChunkAssestMap
+    } = this;
+    return Array.from(chunks).filter(c => localeChunkAssestMap[c.id]);
+  }
+
+  getContentHashes(locale) {
+    const {
+      localeChunkAssestMap
+    } = this;
+    const contentHashes = {};
+    Object.keys(localeChunkAssestMap).forEach(chunkId => {
+      if (localeChunkAssestMap[chunkId] && localeChunkAssestMap[chunkId][locale] && localeChunkAssestMap[chunkId][locale].contentHash) {
+        contentHashes[chunkId] = localeChunkAssestMap[chunkId][locale].contentHash;
+      } // console.log(localeChunkAssestMap[chunkId][locale]);
+
+    }); // console.log({ contentHashes });
+
+    return contentHashes;
+  }
+
   apply(compiler) {
-    new _I18nKeysIdentifer.default(this.options).apply(compiler);
-    new _I18nFilesEmitPlugin.I18nFilesEmitPlugin(this.options).apply(compiler);
-    new _I18nRuntimeDealerPlugin.I18nRuntimeDealerPlugin(this.options).apply(compiler);
+    const {
+      webpack
+    } = compiler;
+    this.addToDefaultTypes(compiler);
+    const I18nModule = (0, _getI18nModule.getI18nModule)(webpack);
+    const I18nDependency = (0, _getI18nDependency.getI18nDependency)(webpack); // initialize base data's and plugis
+
+    this.i18nKeysIdentifer = new _I18nKeysIdentifer.default(this.options, {
+      I18nModule,
+      I18nDependency
+    });
+    this.i18nKeysIdentifer.apply(compiler);
+    compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+      this.localeChunkAssestMap = {};
+      compilation.hooks.beforeHash.tap(pluginName, () => {
+        const {
+          locales
+        } = this.options;
+        const {
+          chunks
+        } = compilation;
+        this.localeChunkAssestMap = {};
+        const {
+          localeChunkAssestMap
+        } = this;
+
+        for (const chunk of chunks) {
+          const {
+            chunkGraph
+          } = compilation;
+          const i18nKeys = this.getI18nKeysForChunk(chunk, chunkGraph);
+
+          if (i18nKeys.length) {
+            localeChunkAssestMap[chunk.id] = {};
+
+            for (const loc of locales) {
+              const content = this.getI18nChunkFileContent(i18nKeys, loc);
+              localeChunkAssestMap[chunk.id][loc] = {
+                content
+              };
+            }
+          }
+        }
+      });
+      compilation.hooks.chunkHash.tap(pluginName, (chunk, hash) => {
+        const {
+          localeChunkAssestMap
+        } = this;
+        const {
+          locales
+        } = this.options;
+
+        if (localeChunkAssestMap[chunk.id]) {
+          for (const loc of locales) {
+            const {
+              content
+            } = localeChunkAssestMap[chunk.id][loc];
+            hash.update(content);
+          }
+        }
+      });
+
+      function createFilenameWithHash({
+        fileNameTemplate,
+        chunk,
+        locale,
+        content
+      }) {
+        const fileName = fileNameTemplate.replaceAll('[locale]', locale);
+        const contentHash = (0, _createHash.createHash)({
+          compiler,
+          outputOptions: compilation.outputOptions,
+          content
+        });
+        const filename = (0, _pathCreator.pathCreator)(fileName, compilation, {
+          hash: compilation.hash,
+          chunkId: chunk.id,
+          chunkHash: chunk.hash,
+          contentHash
+        });
+        return {
+          contentHash,
+          filename
+        };
+      }
+
+      compilation.hooks.contentHash.tap(pluginName, chunk => {
+        const {
+          RawSource
+        } = webpack.sources;
+        const {
+          locales,
+          chunkFilename,
+          filename
+        } = this.options;
+        const fileNameTemplate = chunk.canBeInitial() ? filename : chunkFilename; // const { chunks } = compilation;
+
+        const {
+          localeChunkAssestMap
+        } = this; // function filterI18nUsedChunks(chunks) {
+        //   return Array.from(chunks).filter(c => localeChunkAssestMap[c.id]);
+        // }
+        // for (const chunk of chunks) {
+
+        if (localeChunkAssestMap[chunk.id]) {
+          for (const locale of locales) {
+            const localObject = localeChunkAssestMap[chunk.id][locale];
+            const {
+              content
+            } = localObject;
+            const {
+              contentHash,
+              filename
+            } = createFilenameWithHash({
+              fileNameTemplate,
+              chunk,
+              locale,
+              content
+            });
+            localObject.contentHash = contentHash;
+            localObject.filename = filename;
+            compilation.emitAsset(filename, new RawSource(content));
+          }
+        }
+      });
+
+      if (!this.options.runtime) {
+        return;
+      }
+
+      this.createI18nDownloadCodeInRuntimeFile(webpack, compilation, compiler); // ## compilation.hooks.runtimeRequirementInTree
+      // ##   .for(RuntimeGlobals.hmrDownloadUpdateHandlers)
+      // ##   .tap(pluginName, handler);
+
+      _htmlWebpackPlugin.default.getHooks(compilation).beforeAssetTagGeneration.tap(pluginName, hookOptions => {
+        const {
+          assets
+        } = hookOptions;
+        const {
+          templateLabel,
+          filename,
+          publicPath = ''
+        } = this.options;
+        const dummyContent = '// dummy comment';
+        const initialChunks = compilation.chunks.filter(c => c.canBeInitial() && c.id !== c.runtime);
+        const initialI18nAssets = initialChunks.map(c => {
+          const data = createFilenameWithHash({
+            fileNameTemplate: filename,
+            chunk: c,
+            locale: templateLabel,
+            content: dummyContent
+          });
+          return (0, _urlConcat.urlConcat)(publicPath, data.filename);
+        });
+        const allJSAssets = [...initialI18nAssets, ...assets.js].map(url => url.replaceAll('[locale]', templateLabel).replaceAll('%5Blocale%5D', templateLabel));
+        console.log('HtmlWebpackPluginallJSAssets', {
+          assets,
+          filename,
+          allJSAssets
+        });
+        return {
+          assets: { ...assets,
+            js: allJSAssets
+          }
+        };
+      });
+    });
+  }
+
+  createI18nDownloadCodeInRuntimeFile(webpack, compilation, compiler) {
+    const {
+      RuntimeGlobals
+    } = webpack;
+    const {
+      RawSource
+    } = webpack.sources;
+    const {
+      chunkFilename,
+      locales
+    } = this.options;
+    const chunkFilenameHasContentHash = (0, _hashUtils.hasContentHash)(chunkFilename);
+
+    const getI18nChunks = mainChunk => this.filterI18nUsedChunks(mainChunk.getAllAsyncChunks());
+
+    const I18nLoadingRuntimeModule = (0, _getI18nLoadingRuntimeModule.getI18nLoadingRuntimeModule)({
+      getI18nChunks,
+      webpack
+    });
+    const enabledChunks = new WeakSet();
+
+    const chunkFilenameUrlgenerator = (i18nChunks, locale) => (0, _templateFileName.templateFileName)({
+      compiler,
+      compilation,
+      locale,
+      dynamicFilename: chunkFilename,
+      contentHashes: this.getContentHashes(locale),
+      chunks: i18nChunks
+    });
+
+    const prefixFunc = () => _constants.I18N_CHUNK_NAME_GENERATION_SEGMENT;
+
+    const handler = (entryRuntimeChunk, set) => {
+      if (enabledChunks.has(entryRuntimeChunk)) {
+        return;
+      }
+
+      enabledChunks.add(entryRuntimeChunk);
+      const {
+        chunkFilename,
+        // filename: initialFilename,
+        runtimeOptions
+      } = this.options;
+
+      if (typeof chunkFilename === 'string' && /\[(full)?hash(:\d+)?\]/.test(chunkFilename)) {
+        set.add(RuntimeGlobals.getFullHash);
+      }
+
+      set.add(RuntimeGlobals.publicPath);
+      compilation.addRuntimeModule(entryRuntimeChunk, new I18nLoadingRuntimeModule(set, {
+        prefixFunc: chunkFilenameHasContentHash ? prefixFunc : chunkFilenameUrlgenerator,
+        compiler,
+        runtimeOptions,
+        chunkFilename
+      }));
+    };
+
+    compilation.hooks.runtimeRequirementInTree.for(RuntimeGlobals.ensureChunkHandlers).tap(pluginName, handler);
+
+    if (chunkFilenameHasContentHash) {
+      compilation.hooks.processAssets.tap({
+        name: pluginName,
+        stage: _webpack.Compilation.PROCESS_ASSETS_STAGE_DERIVED // additionalAssets: true
+
+      }, assets => {
+        // eslint-disable-next-line no-underscore-dangle
+        const entries = compilation._getChunkGraphEntries();
+
+        function createRuntimeFilePerLocale({
+          locale,
+          runtimeFileName,
+          runtimeFileSourceStr,
+          i18nChunks
+        }) {
+          const newRuntimeName = runtimeFileName.replaceAll('[locale]', locale);
+          const replaceText = chunkFilenameUrlgenerator(i18nChunks, locale);
+          const replacedStr = runtimeFileSourceStr.replace(_constants.I18N_CHUNK_NAME_GENERATION_SEGMENT, replaceText);
+          compilation.emitAsset(newRuntimeName, new RawSource(replacedStr));
+        }
+
+        for (const entryChunk of entries) {
+          const i18nChunks = getI18nChunks(entryChunk);
+          const runtimeFileName = entryChunk.files[0];
+          const runtimeFileSourceStr = assets[runtimeFileName].source();
+          locales.forEach(locale => createRuntimeFilePerLocale({
+            locale,
+            entryChunk,
+            runtimeFileName,
+            runtimeFileSourceStr,
+            i18nChunks
+          })); // NOTE: we don't delete, Because of HTML plugin needs to add runtime file in html
+          // compilation.deleteAsset(runtimeFileName);
+        }
+      });
+    }
+  } // eslint-disable-next-line class-methods-use-this
+
+
+  addToDefaultTypes(compiler) {
+    const {
+      splitChunks
+    } = compiler.options.optimization;
+
+    if (splitChunks) {
+      if (splitChunks.defaultSizeTypes.includes('...')) {
+        splitChunks.defaultSizeTypes.push(_constants.MODULE_TYPE);
+      }
+    }
   }
 
 }
 
-exports.default = I18nExtractPlugin;
 I18nExtractPlugin.pluginName = pluginName;
-I18nExtractPlugin.pluginSymbol = pluginSymbol;
+I18nExtractPlugin.pluginSymbol = pluginSymbol; // I18nExtractPlugin.loader = require.resolve('./loader');
+
+module.exports = I18nExtractPlugin;
+/**
+ * TODO:
+ * move `localeChunkAssestMap` as separate module or file or class
+ */

package/packages/client_build_tool/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/optionsHandler.js

@@ -28,7 +28,6 @@ function optionsHandler(options) {
   return {
     filename: options.filename || _constants.DEFAULT_FILENAME,
     chunkFilename: options.chunkFilename || chunkNameDecider(options.filename),
-    mainChunkName: options.mainChunkName,
     templateLabel: options.templateLabel,
     publicPath: options.publicPath,
     disableDefault: options.disableDefault,

package/packages/client_build_tool/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/templateFileName.js

@@ -5,17 +5,23 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.templateFileName = templateFileName;
 
-var _webpack = require("webpack");
-
 var _templateHashHelpers = require("./templateHashHelpers");
 
 function templateFileName({
+  compiler,
   compilation,
   dynamicFilename,
-  localeVarName,
+  locale,
   chunks,
   contentHashes
 }) {
+  const {
+    webpack
+  } = compiler;
+  const {
+    Template,
+    RuntimeGlobals
+  } = webpack;
   const MODULE_TYPE = 'text/mini-i18n';
   const {
     mapExpr,
@@ -23,8 +29,8 @@ function templateFileName({
   } = (0, _templateHashHelpers.templateHashHelpers)(chunks); // "i18n-chunk/[locale]/[name].[chunkhash].js"
 
   const i18nURLPathTemplate = compilation.getPath(JSON.stringify(dynamicFilename).replace(/\[locale\]/gi, '"+ locale +"'), {
-    hash: `" + ${_webpack.RuntimeGlobals.getFullHash}() + "`,
-    hashWithLength: length => `" + ${_webpack.RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
+    hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
+    hashWithLength: length => `" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
     chunk: {
       id: '" + chunkId + "',
       hash: mapExpr(c => c.renderedHash),
@@ -39,5 +45,5 @@ function templateFileName({
     },
     contentHashType: MODULE_TYPE
   });
-  return _webpack.Template.asString([`${_webpack.RuntimeGlobals.require}.miniI18nF = function(chunkId){var locale = (${localeVarName});return (${i18nURLPathTemplate})}`]);
+  return Template.asString([`var locale = ${JSON.stringify(locale)};`, `${RuntimeGlobals.require}.miniI18nF = function(chunkId){return (${i18nURLPathTemplate})}`]);
 }

package/packages/client_build_tool/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/templateHashHelpers.js

@@ -5,16 +5,16 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.templateHashHelpers = templateHashHelpers;
 
-/**
- * this function will be used for chunk name, chunk hash, contentHash
- * in these, sometime chunk name and chunk id same for some chunkss so below logic has little towek
- * @param {Chunk} chunks
- * @returns { mapExpr, mapExprWithLength }
+/**
+ * this function will be used for chunk name, chunk hash, contentHash
+ * in these, sometime chunk name and chunk id same for some chunkss so below logic has little towek
+ * @param {Chunk} chunks
+ * @returns { mapExpr, mapExprWithLength }
  */
 function templateHashHelpers(chunks) {
-  /**
-   * @param {function(Chunk): string | number} fn function from chunk to value
-   * @returns {string} code with static mapping of results of fn
+  /**
+   * @param {function(Chunk): string | number} fn function from chunk to value
+   * @returns {string} code with static mapping of results of fn
    */
   const createMap = fn => {
     const obj = {};
@@ -44,16 +44,16 @@ function templateHashHelpers(chunks) {
 
     return useId ? `(${JSON.stringify(obj)}[chunkId] || chunkId)` : `${JSON.stringify(obj)}[chunkId]`;
   };
-  /**
-   * @param {function(Chunk): string | number} fn function from chunk to value
-   * @returns {string} code with static mapping of results of fn for including in quoted string
+  /**
+   * @param {function(Chunk): string | number} fn function from chunk to value
+   * @returns {string} code with static mapping of results of fn for including in quoted string
    */
 
 
   const mapExpr = fn => `" + ${createMap(fn)} + "`;
-  /**
-   * @param {function(Chunk): string | number} fn function from chunk to value
-   * @returns {function(number): string} function which generates code with static mapping of results of fn for including in quoted string for specific length
+  /**
+   * @param {function(Chunk): string | number} fn function from chunk to value
+   * @returns {function(number): string} function which generates code with static mapping of results of fn for including in quoted string for specific length
    */
 
 
@@ -65,13 +65,13 @@ function templateHashHelpers(chunks) {
     mapExprWithLength
   };
 }
-/**
-  function mapExpr(fn) {
-    const obj = {};
-    // eslint-disable-next-line no-restricted-syntax
-    for (const c of chunks) {
-      obj[c.id] = fn(c);
-    }
-    return `(${JSON.stringify(obj)})[chunkId]`;
-  }
+/**
+  function mapExpr(fn) {
+    const obj = {};
+    // eslint-disable-next-line no-restricted-syntax
+    for (const c of chunks) {
+      obj[c.id] = fn(c);
+    }
+    return `(${JSON.stringify(obj)})[chunkId]`;
+  }
  */

package/packages/client_build_tool/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/utils/collectI18nKeys.js

@@ -8,17 +8,17 @@ exports.collectI18nKeysfromComments = collectI18nKeysfromComments;
 
 var _estreeWalker = require("estree-walker");
 
+// const { walk } = require('estree-walker');
 function collectI18nKeysfromAST(ast, allI18n) {
-  const i18nKeys = {};
+  let i18nKeys = {};
   (0, _estreeWalker.walk)(ast, {
-    enter(node) {
+    enter: function (node) {
       if (node.type === 'Literal') {
         if ((node.raw[0] === '\'' || node.raw[0] === '"') && Object.hasOwnProperty.call(allI18n, node.value)) {
           i18nKeys[node.value] = allI18n[node.value];
         }
       }
     }
-
   });
   return Object.keys(i18nKeys);
 }
@@ -27,7 +27,7 @@ const prefixI18nComment = 'I18N';
 const prefixI18nComment1 = 'dynamic-i18n-key';
 
 function getI18nKeysFromComment(comment) {
-  const commentString = comment.value.trim();
+  let commentString = comment.value.trim();
   let i18nKeyStr;
 
   if (commentString.startsWith(prefixI18nComment)) {
@@ -47,20 +47,17 @@ function getI18nKeysFromComment(comment) {
 
 function collectI18nKeysfromComments(comments, allI18n) {
   // TODO: need to implement
-  const i18nKeys = {};
-  /* eslint-disable no-restricted-syntax */
+  let i18nKeys = {};
 
-  for (const comment of comments) {
-    const keys = getI18nKeysFromComment(comment);
+  for (let comment of comments) {
+    let keys = getI18nKeysFromComment(comment);
 
-    for (const key of keys) {
+    for (let key of keys) {
       if (key && allI18n[key]) {
         i18nKeys[key] = allI18n[key];
       }
     }
   }
-  /* eslint-enable no-restricted-syntax */
-
 
   return Object.keys(i18nKeys);
 }

package/packages/client_build_tool/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/utils/propertiesUtils.js

@@ -11,8 +11,6 @@ var _fs = require("fs");
 
 var _path = require("path");
 
-var _constants = require("../../../../../constants");
-
 function isComment(line) {
   return line[0] === '#';
 }
@@ -66,7 +64,7 @@ function getAllI18n({
   try {
     const files = (0, _fs.readdirSync)(folderPath, 'utf8');
     const allLangI18n = {};
-    const context = (0, _constants.joinWithAppPath)(folderPath);
+    const context = (0, _path.join)(process.cwd(), folderPath);
     files.forEach(file => {
       const filePath = (0, _path.join)(context, file);
 
@@ -115,15 +113,15 @@ function jsonToString(json, keySeperator) {
   str += '}';
   return str;
 }
-/**
- * not useable due to special charector
- * 
-      return `{${Object.keys(data).map(key =>  `"${key}": "${data[key]}"`).join(",")}}`
-      // return JSON.stringify(data);
-      let str = "{";
-      for (const key of Object.keys(data)) {
-        str+= `"${key}": "${data[key]}",`
-      }
-      str+="}";
-      return str;
+/**
+ * not useable due to special charector
+ * 
+      return `{${Object.keys(data).map(key =>  `"${key}": "${data[key]}"`).join(",")}}`
+      // return JSON.stringify(data);
+      let str = "{";
+      for (const key of Object.keys(data)) {
+        str+= `"${key}": "${data[key]}",`
+      }
+      str+="}";
+      return str;
  */

package/packages/client_build_tool/lib/shared/bundler/webpack/custom_plugins/RtlSplitPlugin/OverwriteCssPathForRTL.js

@@ -13,6 +13,7 @@ var _replaceCssDirTemplate = require("./replaceCssDirTemplate");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+// const HtmlWebpackPlugin = require('html-webpack-plugin');
 // import { JavascriptModulesPlugin } from 'webpack';
 const pluginName = 'OverwriteCssPathForRTL';
 
@@ -26,15 +27,15 @@ class OverwriteCssPathForRTL {
 
   overwriteCssPathinHTML(compilation) {
     // NOTE: need to reconsider It is not working as expected
-    _htmlWebpackPlugin.default.getHooks(compilation).beforeAssetTagGeneration.tap(pluginName, data => {
+    _htmlWebpackPlugin.default.getHooks(compilation).beforeAssetTagGeneration.tapAsync(pluginName, (data, cb) => {
       const {
         assets
       } = data;
-      return { ...data,
+      cb(null, { ...data,
         assets: { ...assets,
           css: assets.css && (0, _replaceCssDirTemplate.replaceCssDirTemplateMapper)(assets.css, this.templateLabel)
         }
-      };
+      });
     });
   }
 
@@ -44,7 +45,7 @@ class OverwriteCssPathForRTL {
     } = compiler.webpack.sources;
 
     _JavascriptModulesPlugin.default.getCompilationHooks(compilation).renderMain.tap(pluginName, source => {
-      const templateText = `"+(${this.dirVarName} === "rtl" ? "rtl": "ltr")+"`;
+      const templateText = `"+(${this.dirVarName} === "rtl" ? ".rtl": ".ltr")+"`;
       const replacedStr = source.source().replace(/\[dir\]/g, templateText);
       return new RawSource(replacedStr);
     });