@zohodesk/client_build_tool 0.0.1-0.exp.0.0.3

package/lib/shared/bundler/webpack/custom_plugins/I18nNumericIndexPlugin/I18nNumericIndexPlugin.js

@@ -0,0 +1,190 @@
+"use strict";
+
+const fs = require('fs');
+
+const path = require('path');
+
+const {
+  sources,
+  Compilation
+} = require('webpack');
+
+const {
+  createHash
+} = require("../I18nSplitPlugin/createHash");
+
+const {
+  RawSource
+} = sources;
+const pluginName = 'I18nNumericIndexPlugin';
+
+class I18nNumericIndexPlugin {
+  constructor(options) {
+    this.options = options;
+    this.numericMap = null;
+    this.numericMapPath = options.numericMapPath;
+  }
+
+  loadNumericMapOnce(compilation) {
+    if (this.numericMap) {
+      return this.numericMap;
+    }
+
+    try {
+      if (this.numericMapPath && fs.existsSync(this.numericMapPath)) {
+        const fileContent = fs.readFileSync(this.numericMapPath, 'utf-8');
+        const parsedData = JSON.parse(fileContent);
+
+        if (parsedData && parsedData.sortedOriginalKeys && parsedData.totalKeys !== undefined) {
+          this.numericMap = {
+            sortedOriginalKeys: parsedData.sortedOriginalKeys,
+            totalKeys: parsedData.totalKeys
+          };
+          compilation.logger.info(`${pluginName}: Loaded numeric map from ${this.numericMapPath}.`);
+          return this.numericMap;
+        } else {
+          compilation.logger.error(`${pluginName}: Invalid format in numeric map file at ${this.numericMapPath}.`);
+          this.numericMap = {
+            sortedOriginalKeys: [],
+            totalKeys: 0
+          };
+        }
+      } else {
+        compilation.logger.warn(`${pluginName}: Numeric map path not provided or file not found at ${this.numericMapPath}.`);
+        this.numericMap = {
+          sortedOriginalKeys: [],
+          totalKeys: 0
+        };
+      }
+    } catch (err) {
+      compilation.logger.error(`${pluginName}: Error loading numeric map from ${this.numericMapPath}: ${err.message}`);
+      this.numericMap = {
+        sortedOriginalKeys: [],
+        totalKeys: 0
+      };
+    }
+
+    return this.numericMap;
+  }
+
+  emitFile(compilation, baseFilenameTemplate, locale, fileContentData, jsonpFunc, typeSuffix = '') {
+    const fileContent = `${jsonpFunc}(${JSON.stringify(fileContentData)});`;
+    const source = new RawSource(fileContent);
+    const actualContentHash = createHash({
+      //
+      outputOptions: compilation.outputOptions,
+      content: fileContent
+    });
+    let processedFilenameTemplate = baseFilenameTemplate.replace(/\[locale\]/g, locale).replace(/\[name\]/g, locale).replace(/\[id\]/g, locale);
+    const finalFileName = compilation.getAssetPath(processedFilenameTemplate, {
+      locale: locale,
+      contentHash: actualContentHash,
+      hash: compilation.hash,
+      chunk: {
+        id: `i18n-${typeSuffix || 'data'}-${locale}`,
+        name: `${typeSuffix || 'data'}-${locale}`,
+        hash: actualContentHash,
+        contentHash: {
+          [this.options.moduleType || 'i18n/mini-extract']: actualContentHash
+        }
+      },
+      contentHashType: this.options.moduleType || 'i18n/mini-extract'
+    });
+    compilation.emitAsset(finalFileName, source);
+    compilation.logger.info(`${pluginName}: Emitted ${typeSuffix} i18n file for locale ${locale} to ${finalFileName}`);
+  }
+
+  apply(compiler) {
+    compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+      compilation.hooks.processAssets.tapAsync({
+        name: pluginName,
+        stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
+      }, (assets, callback) => {
+        const {
+          sortedOriginalKeys,
+          totalKeys
+        } = this.loadNumericMapOnce(compilation);
+
+        if (totalKeys === 0 && (!sortedOriginalKeys || sortedOriginalKeys.length === 0)) {
+          compilation.logger.info(`${pluginName}: No numeric keys to process. Skipping numeric file emission.`);
+        }
+
+        const globallyUsedLiteralKeys = new Set();
+        const globallyUsedCommentKeys = new Set();
+
+        for (const module of compilation.modules) {
+          if (module.buildInfo) {
+            if (Array.isArray(module.buildInfo.loaderIdentifiedLiteralI18nKeys)) {
+              module.buildInfo.loaderIdentifiedLiteralI18nKeys.forEach(key => globallyUsedLiteralKeys.add(key));
+            }
+
+            if (Array.isArray(module.buildInfo.loaderIdentifiedCommentI18nKeys)) {
+              module.buildInfo.loaderIdentifiedCommentI18nKeys.forEach(key => globallyUsedCommentKeys.add(key));
+            }
+          }
+        }
+
+        compilation.logger.info(`${pluginName}: Globally identified Literal Keys: ${globallyUsedLiteralKeys.size}, Comment Keys: ${globallyUsedCommentKeys.size}`);
+        const {
+          locales,
+          allI18nObject,
+          numericFilenameTemplate,
+          dynamicFilenameTemplate,
+          numericJsonpFunc,
+          dynamicJsonpFunc
+        } = this.options;
+
+        if (!locales || !allI18nObject || !numericFilenameTemplate || !dynamicFilenameTemplate || !numericJsonpFunc || !dynamicJsonpFunc) {
+          compilation.errors.push(new Error(`${pluginName}: Missing some required options (locales, allI18nObject, filename templates, jsonp funcs).`));
+          return callback();
+        }
+
+        if (totalKeys > 0 && sortedOriginalKeys && sortedOriginalKeys.length > 0) {
+          for (const locale of locales) {
+            const localeTranslations = allI18nObject[locale] || {};
+            const orderedNumericTranslations = new Array(totalKeys);
+
+            for (let i = 0; i < totalKeys; i++) {
+              const originalKey = sortedOriginalKeys[i];
+
+              if (globallyUsedLiteralKeys.has(originalKey)) {
+                orderedNumericTranslations[i] = localeTranslations[originalKey] !== undefined ? localeTranslations[originalKey] : 0; // Use 0 or null as placeholder for missing keys
+              } else {
+                orderedNumericTranslations[i] = 0; // Placeholder for keys not identified as literals or not used
+              }
+            }
+
+            this.emitFile(compilation, numericFilenameTemplate, locale, orderedNumericTranslations, numericJsonpFunc, 'numeric');
+          }
+        }
+
+        if (globallyUsedCommentKeys.size > 0) {
+          for (const locale of locales) {
+            const localeTranslations = allI18nObject[locale] || {};
+            const dynamicKeyTranslations = {};
+            globallyUsedCommentKeys.forEach(originalKey => {
+              if (localeTranslations[originalKey] !== undefined) {
+                dynamicKeyTranslations[originalKey] = localeTranslations[originalKey];
+              } else {
+                dynamicKeyTranslations[originalKey] = null;
+              }
+            });
+
+            if (Object.keys(dynamicKeyTranslations).length > 0) {
+              this.emitFile(compilation, dynamicFilenameTemplate, locale, dynamicKeyTranslations, dynamicJsonpFunc, 'dynamic');
+            }
+          }
+        } else {
+          compilation.logger.info(`${pluginName}: No globally used comment keys found. Skipping dynamic file emission.`);
+        }
+
+        callback();
+      });
+    });
+  }
+
+}
+
+module.exports = {
+  I18nNumericIndexPlugin
+};

package/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/ContributionGuide.md

@@ -0,0 +1,11 @@
+# I18n Split Plugin ContributionGuide
+we have modifyed mini-css-extract-plugin to sute our needs of i18n related extraction and downloading.
+So In future may be when we need to update mini-css-extract-plugin Kindly cross check with this I18n Plugin as well.
+
+Even not breaking change, may be just performacne update or feature update. addeding that to this plugin will be use full. Kindly consider it.
+
+## Thing we Ignored 
+ * we use webpack ast hook for adding I18nDependency. So we did not need `loader.js`
+ * we ignore order of import in single chunk since I18n going to be download as object.  
+      we did not need it.
+ * 

package/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/I18nFilesEmitPlugin.js

@@ -0,0 +1,174 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.I18nFilesEmitPlugin = void 0;
+
+var _webpack = require("webpack");
+
+var _createHash = require("./createHash");
+
+var _pathCreator = require("./pathCreator");
+
+var _propertiesUtils = require("./utils/propertiesUtils");
+
+var _LocaleChunkAssetsStore = require("./LocaleChunkAssetsStore");
+
+/* eslint-disable no-restricted-syntax */
+const pluginName = 'I18nFilesEmitPlugin';
+const {
+  RawSource
+} = _webpack.sources;
+
+class I18nFilesEmitPlugin {
+  constructor(options) {
+    this.options = options; // this.options = {
+    //   locales: options.locales,
+    //   chunkFilename: options.chunkFilename,
+    //   filename: options.filename,
+    //   allI18nObject: options.allI18nObject,
+    //   jsonpFunc: options.jsonpFunc
+    // };
+  }
+
+  apply(compiler) {
+    compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+      // Get store for cache
+      this.store = (0, _LocaleChunkAssetsStore.getLocaleChunkAssetsStore)(compilation);
+      const i18nStore = this.store;
+      compilation.hooks.beforeHash.tap(pluginName, () => {
+        i18nStore.clear();
+        this.createAndStoreFileContentForEveryChunkAndLocale(compilation);
+      });
+      compilation.hooks.chunkHash.tap(pluginName, (chunk, hash) => {
+        this.updateChunkHashForEveryLocale(chunk, hash);
+      });
+      compilation.hooks.contentHash.tap(pluginName, chunk => {
+        if (!i18nStore.isChunkHasI18n(chunk.id)) {
+          return;
+        }
+
+        this.emitI18nFileForEveryLocale(chunk, compilation);
+      });
+    });
+  }
+
+  createAndStoreFileContentForEveryChunkAndLocale(compilation) {
+    const {
+      chunks
+    } = compilation;
+    const {
+      locales
+    } = this.options;
+    const i18nStore = this.store;
+
+    for (const chunk of chunks) {
+      const i18nKeys = i18nStore.getI18nKeysForChunk(chunk);
+
+      if (!i18nKeys.length) {
+        // eslint-disable-next-line no-continue
+        continue;
+      }
+
+      for (const locale of locales) {
+        const content = this.getI18nChunkFileContent(i18nKeys, locale);
+        i18nStore.storeData(chunk.id, locale, {
+          content
+        });
+      }
+    }
+  }
+
+  updateChunkHashForEveryLocale(chunk, hash) {
+    const {
+      locales
+    } = this.options;
+    const i18nStore = this.store;
+
+    if (i18nStore.isChunkHasI18n(chunk.id)) {
+      for (const loc of locales) {
+        const content = i18nStore.getContent(chunk.id, loc);
+        hash.update(content);
+      }
+    }
+  }
+
+  emitI18nFileForEveryLocale(chunk, compilation) {
+    const i18nStore = this.store;
+    const {
+      locales,
+      chunkFilename,
+      filename
+    } = this.options;
+    const fileNameTemplate = chunk.canBeInitial() ? filename : chunkFilename; // const { chunks } = compilation;
+
+    for (const locale of locales) {
+      const content = i18nStore.getContent(chunk.id, locale);
+      const contentHash = (0, _createHash.createHash)({
+        outputOptions: compilation.outputOptions,
+        content
+      });
+      const {
+        filename
+      } = I18nFilesEmitPlugin.createFilenameWithHash({
+        compilation,
+        contentHash,
+        fileNameTemplate,
+        chunk,
+        locale
+      });
+      i18nStore.storeData(chunk.id, locale, {
+        contentHash,
+        filename
+      });
+      compilation.emitAsset(filename, new RawSource(content));
+    }
+  }
+
+  static createFilenameWithHash({
+    compilation,
+    fileNameTemplate,
+    chunk,
+    locale,
+    contentHash
+  }) {
+    const fileName = fileNameTemplate.replaceAll('[locale]', locale);
+    const filename = (0, _pathCreator.pathCreator)(fileName, compilation, {
+      hash: compilation.hash,
+      locale,
+      chunkName: chunk.name,
+      chunkId: chunk.id,
+      chunkHash: chunk.hash,
+      contentHash
+    });
+    return {
+      contentHash,
+      filename
+    };
+  }
+
+  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)})`;
+  }
+
+}
+
+exports.I18nFilesEmitPlugin = I18nFilesEmitPlugin;

package/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/I18nKeysIdentifer.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _utils = require("./utils");
+
+var _LocaleChunkAssetsStore = require("./LocaleChunkAssetsStore");
+
+/* eslint-disable max-classes-per-file */
+const pluginName = 'I18nKeysIdentifier';
+/**
+ * this plugin search the i18 keys and make it as I18nDependency.
+ * how it works?
+ *  this plugin get jsResourceI18nKeys in constructor.
+ *  we walk thought the js files AST
+ *      if any string literal in that AST is in jsResourceI18nKeys then  we consider that string as I18n key
+ *  after the walk of AST we get some I18n keys
+ *  then we make it as I18nDependency.
+ */
+
+class I18nKeysIdentifer {
+  constructor({
+    jsResourceI18nKeys
+  }) {
+    this.jsResourceI18nKeys = jsResourceI18nKeys;
+    this.store = new _LocaleChunkAssetsStore.LocaleChunkAssetsStore();
+  }
+
+  apply(compiler) {
+    // const { splitChunks } = compiler.options.optimization;
+    // if (splitChunks) {
+    //   if (splitChunks.defaultSizeTypes.includes('...')) {
+    //     splitChunks.defaultSizeTypes.push(MODULE_TYPE);
+    //   }
+    // }
+    compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+      this.store.updateCompilation(compilation);
+      (0, _LocaleChunkAssetsStore.setLocaleChunkAssetsStore)(compilation, this.store);
+    });
+    compiler.hooks.normalModuleFactory.tap(pluginName, factory => {
+      // handler for parser
+      const handler = parser => {
+        parser.hooks.program.tap(pluginName, (ast, comments) => {
+          const {
+            module
+          } = parser.state; //
+
+          if (!(module && /\.jsx?$/.test(module.resource))) {
+            return;
+          } // i18n grep proper contract regex
+
+
+          let i18nKeys = (0, _utils.collectI18nKeysfromAST)(ast, this.jsResourceI18nKeys);
+          i18nKeys = i18nKeys.concat( // i18n grep proper contract regex
+          (0, _utils.collectI18nKeysfromComments)(comments, this.jsResourceI18nKeys));
+
+          if (i18nKeys.length) {
+            // console.log('i18nKeys.length', module.resource, i18nKeys);
+            this.store.updateModuleI18nKeys(module.resource, i18nKeys);
+          }
+        });
+      }; // this below  hook was tapped for collect I18n Key from files and add as Dependency
+      // const factory = params.normalModuleFactory;
+
+
+      factory.hooks.parser.for('javascript/auto').tap(pluginName, handler);
+      factory.hooks.parser.for('javascript/dynamic').tap(pluginName, handler);
+    });
+  }
+
+}
+
+exports.default = I18nKeysIdentifer;

package/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/I18nRuntimeDealerPlugin.js

@@ -0,0 +1,223 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.I18nRuntimeDealerPlugin = void 0;
+
+var _webpack = require("webpack");
+
+var _htmlWebpackPlugin = _interopRequireDefault(require("html-webpack-plugin"));
+
+var _constants = require("./constants");
+
+var _getI18nLoadingRuntimeModule = require("./getI18nLoadingRuntimeModule");
+
+var _templateFileName = require("./templateFileName");
+
+var _hashUtils = require("./utils/hashUtils");
+
+var _urlConcat = require("../../../../server/urlConcat");
+
+var _I18nFilesEmitPlugin = require("./I18nFilesEmitPlugin");
+
+var _LocaleChunkAssetsStore = require("./LocaleChunkAssetsStore");
+
+var _logger = require("../../../../../logger");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const {
+  RawSource
+} = _webpack.sources;
+const pluginName = 'I18nRuntimeDealerPlugin'; // I18nExtractPlugin.loader = require.resolve('./loader');
+
+class I18nRuntimeDealerPlugin {
+  constructor(options) {
+    this.options = options;
+  }
+
+  apply(compiler) {
+    compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+      // Get store for cache
+      this.store = (0, _LocaleChunkAssetsStore.getLocaleChunkAssetsStore)(compilation);
+
+      if (!this.options.runtime) {
+        return;
+      }
+
+      this.createI18nDownloadCodeInRuntimeFile(compilation);
+      this.addI18nIntoInitialHtml(compilation);
+    });
+  }
+
+  addI18nIntoInitialHtml(compilation) {
+    const i18nStore = this.store;
+
+    _htmlWebpackPlugin.default.getHooks(compilation).beforeAssetTagGeneration.tap(pluginName, hookOptions => {
+      const {
+        assets
+      } = hookOptions;
+      const {
+        templateLabel,
+        filename,
+        publicPath = '',
+        mainChunkName
+      } = this.options; // const dummyContent = '// dummy comment';
+
+      const dummyContentHash = 'dummy0content0hashes';
+      const entryPoint = compilation.entrypoints.get(mainChunkName);
+      const initialChunks = Array.from(entryPoint.chunks).filter(c => c.canBeInitial() && c.id !== c.runtime);
+      const initialI18nAssets = initialChunks.filter(c => i18nStore.isChunkHasI18n(c)).map(c => {
+        const data = _I18nFilesEmitPlugin.I18nFilesEmitPlugin.createFilenameWithHash({
+          compilation,
+          fileNameTemplate: filename,
+          chunk: c,
+          locale: templateLabel,
+          // NOTE: we used dummy  content hash.
+          //  Because we have no plan on use in content hash to initial I18n chunks
+          // So Dummy hash was being used it will not work  just skip warnings
+          contentHash: dummyContentHash
+        });
+
+        return (0, _urlConcat.urlConcat)(publicPath, data.filename);
+      });
+      const allJSAssets = [...initialI18nAssets, ...assets.js].map(url => url.replaceAll('[locale]', templateLabel).replaceAll('%5Blocale%5D', templateLabel));
+      return {
+        assets: { ...assets,
+          js: allJSAssets
+        }
+      };
+    });
+  }
+
+  createI18nDownloadCodeInRuntimeFile(compilation) {
+    const {
+      chunkFilename,
+      locales,
+      localeVarName
+    } = this.options;
+    const chunkFilenameHasContentHash = (0, _hashUtils.hasContentHash)(chunkFilename);
+
+    const getI18nChunks = mainChunk => this.filterI18nUsedChunks(mainChunk.getAllAsyncChunks());
+
+    const I18nLoadingRuntimeModule = (0, _getI18nLoadingRuntimeModule.getI18nLoadingRuntimeModule)({
+      getI18nChunks
+    });
+    const enabledChunks = new WeakSet();
+
+    const chunkFilenameUrlGenerator = (i18nChunks, locale) => (0, _templateFileName.templateFileName)({
+      compilation,
+      localeVarName,
+      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(_webpack.RuntimeGlobals.getFullHash);
+      }
+
+      set.add(_webpack.RuntimeGlobals.publicPath);
+      compilation.addRuntimeModule(entryRuntimeChunk, new I18nLoadingRuntimeModule(set, {
+        prefixFunc: chunkFilenameHasContentHash ? prefixFunc : chunkFilenameUrlGenerator,
+        runtimeOptions,
+        chunkFilename
+      }));
+    };
+
+    compilation.hooks.runtimeRequirementInTree.for(_webpack.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));
+        } // eslint-disable-next-line no-restricted-syntax
+
+
+        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 and  efc 
+          // compilation.deleteAsset(runtimeFileName);
+        }
+      });
+      compilation.hooks.processAssets.tap({
+        name: pluginName,
+        stage: _webpack.Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE // additionalAssets: true
+
+      }, () => {
+        // eslint-disable-next-line no-underscore-dangle
+        const entries = compilation._getChunkGraphEntries(); // eslint-disable-next-line no-restricted-syntax
+
+
+        for (const entryChunk of entries) {
+          const runtimeFileName = [...entryChunk.files][0] || '';
+
+          if (runtimeFileName.includes('runtime') && runtimeFileName.includes('[locale]')) {
+            (0, _logger.verboseLogger)('deleteAsset', runtimeFileName);
+            compilation.deleteAsset(runtimeFileName);
+          }
+        }
+      });
+    }
+  }
+
+  filterI18nUsedChunks(chunks) {
+    const i18nStore = this.store;
+    return Array.from(chunks).filter(c => i18nStore.isChunkHasI18n(c.id));
+  }
+
+  getContentHashes(locale) {
+    const i18nStore = this.store;
+    const contentHashes = {};
+    i18nStore.forEachChunkId(chunkId => {
+      const contentHash = i18nStore.getContentHash(chunkId, locale);
+
+      if (contentHash) {
+        contentHashes[chunkId] = contentHash;
+      }
+    }); // console.log({ contentHashes });
+
+    return contentHashes;
+  }
+
+}
+
+exports.I18nRuntimeDealerPlugin = I18nRuntimeDealerPlugin;