@vocab/webpack 0.0.0-cjs-exports-20230421064630

package/LICENSE

@@ -0,0 +1,21 @@
+### MIT License
+
+Copyright (c) 2020 SEEK
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/chunk-name/dist/vocab-webpack-chunk-name.cjs.d.ts

@@ -0,0 +1 @@
+export * from "../../dist/declarations/src/chunk-name";

package/chunk-name/dist/vocab-webpack-chunk-name.cjs.dev.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function getChunkName(lang) {
+  return `${lang}-translations`;
+}
+
+exports.getChunkName = getChunkName;

package/chunk-name/dist/vocab-webpack-chunk-name.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./vocab-webpack-chunk-name.cjs.prod.js");
+} else {
+  module.exports = require("./vocab-webpack-chunk-name.cjs.dev.js");
+}

package/chunk-name/dist/vocab-webpack-chunk-name.cjs.prod.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function getChunkName(lang) {
+  return `${lang}-translations`;
+}
+
+exports.getChunkName = getChunkName;

package/chunk-name/dist/vocab-webpack-chunk-name.esm.js

@@ -0,0 +1,5 @@
+function getChunkName(lang) {
+  return `${lang}-translations`;
+}
+
+export { getChunkName };

package/chunk-name/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "dist/vocab-webpack-chunk-name.cjs.js",
+  "module": "dist/vocab-webpack-chunk-name.esm.js"
+}

package/dist/declarations/src/chunk-name.d.ts

@@ -0,0 +1 @@
+export declare function getChunkName(lang: string): string;

package/dist/declarations/src/index.d.ts

@@ -0,0 +1,12 @@
+import type { UserConfig } from '@vocab/core';
+import type { Compiler } from 'webpack';
+interface UserOptions extends Partial<UserConfig> {
+    configFile?: string;
+}
+export declare const compiledVocabFileFilter: RegExp;
+export declare class VocabWebpackPlugin {
+    options: UserConfig;
+    constructor({ configFile, ...rest }?: UserOptions);
+    apply(compiler: Compiler): void;
+}
+export {};

package/dist/declarations/src/loader.d.ts

@@ -0,0 +1,5 @@
+import type { UserConfig } from '@vocab/core';
+import type { LoaderContext as WebpackLoaderContext } from 'webpack';
+type LoaderContext = WebpackLoaderContext<UserConfig>;
+export default function vocabLoader(this: LoaderContext, source: string): Promise<void>;
+export {};

package/dist/declarations/src/logger.d.ts

@@ -0,0 +1,3 @@
+import debug from 'debug';
+export declare const trace: debug.Debugger;
+export declare const log: (...params: unknown[]) => void;

package/dist/declarations/src/web.d.ts

@@ -0,0 +1,3 @@
+import type { TranslationModule } from '@vocab/core';
+export { createTranslationFile } from '@vocab/core/translation-file';
+export declare const createLanguage: (moduleId: string, loadImport: () => Promise<any>) => TranslationModule<any>;

package/dist/logger-65149486.cjs.dev.js

@@ -0,0 +1,12 @@
+'use strict';
+
+require('chalk');
+var debug = require('debug');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var debug__default = /*#__PURE__*/_interopDefault(debug);
+
+const trace = debug__default["default"](`vocab:webpack`);
+
+exports.trace = trace;

package/dist/logger-e1862ea1.esm.js

@@ -0,0 +1,6 @@
+import 'chalk';
+import debug from 'debug';
+
+const trace = debug(`vocab:webpack`);
+
+export { trace as t };

package/dist/logger-f79e34a8.cjs.prod.js

@@ -0,0 +1,12 @@
+'use strict';
+
+require('chalk');
+var debug = require('debug');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var debug__default = /*#__PURE__*/_interopDefault(debug);
+
+const trace = debug__default["default"](`vocab:webpack`);
+
+exports.trace = trace;

package/dist/vocab-webpack.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./declarations/src/index";

package/dist/vocab-webpack.cjs.dev.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@vocab/core');
+var logger = require('./logger-65149486.cjs.dev.js');
+require('chalk');
+require('debug');
+
+const compiledVocabFileFilter = /\.vocab[\\/]index\.(?:ts|js|cjs|mjs)$/;
+class VocabWebpackPlugin {
+  constructor({
+    configFile,
+    ...rest
+  } = {}) {
+    logger.trace(`Creating Vocab plugin${configFile ? ` with config file ${configFile}` : ''}`);
+    this.options = {
+      ...core.resolveConfigSync(configFile),
+      ...rest
+    };
+    core.validateConfig(this.options);
+  }
+  apply(compiler) {
+    logger.trace(`Applying plugin: ${compiler.options.name} (${compiler.options.target})`);
+    if (!compiler.options.module) {
+      // @ts-expect-error Support for older versions of webpack that may not have module defined at this stage
+      compiler.options.module = {
+        rules: []
+      };
+    }
+    if (!compiler.options.module.rules) {
+      compiler.options.module.rules = [];
+    }
+    compiler.options.module.rules.splice(0, 0, {
+      test: compiledVocabFileFilter,
+      loader: require.resolve('@vocab/webpack/loader'),
+      options: this.options
+    });
+  }
+}
+
+exports.VocabWebpackPlugin = VocabWebpackPlugin;
+exports.compiledVocabFileFilter = compiledVocabFileFilter;

package/dist/vocab-webpack.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./vocab-webpack.cjs.prod.js");
+} else {
+  module.exports = require("./vocab-webpack.cjs.dev.js");
+}

package/dist/vocab-webpack.cjs.prod.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@vocab/core');
+var logger = require('./logger-f79e34a8.cjs.prod.js');
+require('chalk');
+require('debug');
+
+const compiledVocabFileFilter = /\.vocab[\\/]index\.(?:ts|js|cjs|mjs)$/;
+class VocabWebpackPlugin {
+  constructor({
+    configFile,
+    ...rest
+  } = {}) {
+    logger.trace(`Creating Vocab plugin${configFile ? ` with config file ${configFile}` : ''}`);
+    this.options = {
+      ...core.resolveConfigSync(configFile),
+      ...rest
+    };
+    core.validateConfig(this.options);
+  }
+  apply(compiler) {
+    logger.trace(`Applying plugin: ${compiler.options.name} (${compiler.options.target})`);
+    if (!compiler.options.module) {
+      // @ts-expect-error Support for older versions of webpack that may not have module defined at this stage
+      compiler.options.module = {
+        rules: []
+      };
+    }
+    if (!compiler.options.module.rules) {
+      compiler.options.module.rules = [];
+    }
+    compiler.options.module.rules.splice(0, 0, {
+      test: compiledVocabFileFilter,
+      loader: require.resolve('@vocab/webpack/loader'),
+      options: this.options
+    });
+  }
+}
+
+exports.VocabWebpackPlugin = VocabWebpackPlugin;
+exports.compiledVocabFileFilter = compiledVocabFileFilter;

package/dist/vocab-webpack.esm.js

@@ -0,0 +1,38 @@
+import { resolveConfigSync, validateConfig } from '@vocab/core';
+import { t as trace } from './logger-e1862ea1.esm.js';
+import 'chalk';
+import 'debug';
+
+const compiledVocabFileFilter = /\.vocab[\\/]index\.(?:ts|js|cjs|mjs)$/;
+class VocabWebpackPlugin {
+  constructor({
+    configFile,
+    ...rest
+  } = {}) {
+    trace(`Creating Vocab plugin${configFile ? ` with config file ${configFile}` : ''}`);
+    this.options = {
+      ...resolveConfigSync(configFile),
+      ...rest
+    };
+    validateConfig(this.options);
+  }
+  apply(compiler) {
+    trace(`Applying plugin: ${compiler.options.name} (${compiler.options.target})`);
+    if (!compiler.options.module) {
+      // @ts-expect-error Support for older versions of webpack that may not have module defined at this stage
+      compiler.options.module = {
+        rules: []
+      };
+    }
+    if (!compiler.options.module.rules) {
+      compiler.options.module.rules = [];
+    }
+    compiler.options.module.rules.splice(0, 0, {
+      test: compiledVocabFileFilter,
+      loader: require.resolve('@vocab/webpack/loader'),
+      options: this.options
+    });
+  }
+}
+
+export { VocabWebpackPlugin, compiledVocabFileFilter };

package/loader/dist/vocab-webpack-loader.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "../../dist/declarations/src/loader";
+export { default } from "../../dist/declarations/src/loader";

package/loader/dist/vocab-webpack-loader.cjs.dev.js

@@ -0,0 +1,136 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var path = require('path');
+var cjsModuleLexer = require('cjs-module-lexer');
+var esModuleLexer = require('es-module-lexer');
+var core = require('@vocab/core');
+var chunkName_dist_vocabWebpackChunkName = require('../../chunk-name/dist/vocab-webpack-chunk-name.cjs.dev.js');
+var logger = require('../../dist/logger-65149486.cjs.dev.js');
+require('chalk');
+require('debug');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+var cjsModuleLexer__namespace = /*#__PURE__*/_interopNamespace(cjsModuleLexer);
+var esModuleLexer__namespace = /*#__PURE__*/_interopNamespace(esModuleLexer);
+
+const trace = logger.trace.extend('loader');
+
+// Resolve virtual-resource-loader dependency from current package
+const virtualResourceLoader = require.resolve('virtual-resource-loader');
+function createIdentifier(lang, resourcePath, loadedTranslation) {
+  var _loadedTranslation$la;
+  trace('Creating identifier for language', lang);
+  const languageTranslations = (_loadedTranslation$la = loadedTranslation.languages[lang]) !== null && _loadedTranslation$la !== void 0 ? _loadedTranslation$la : {};
+  const langJson = {};
+  for (const key of loadedTranslation.keys) {
+    langJson[key] = languageTranslations[key].message;
+  }
+  const base64 = Buffer.from(JSON.stringify(langJson), 'utf-8').toString('base64');
+  const unloader = `${virtualResourceLoader}?source=${base64}`;
+  const fileIdent = path__default["default"].basename(resourcePath, 'translations.json');
+  return `./${fileIdent}-${lang}-virtual.json!=!${unloader}!`;
+}
+
+// reimplement `stringifyRequest` from loader-utils 2.x
+// https://github.com/webpack/loader-utils/blob/master/CHANGELOG.md#300-2021-10-20
+function stringifyRequest(request) {
+  return JSON.stringify(this.utils.contextify(this.context, request));
+}
+function renderLanguageLoaderAsync(resourcePath, loadedTranslation) {
+  return lang => {
+    const identifier = stringifyRequest.call(this, createIdentifier(lang, resourcePath, loadedTranslation));
+    return (/* ts */`
+      createLanguage(
+        require.resolveWeak(${identifier}),
+        () => import(
+          /* webpackChunkName: ${JSON.stringify(chunkName_dist_vocabWebpackChunkName.getChunkName(lang))} */
+          ${identifier}
+        )
+      )
+    `.trim()
+    );
+  };
+}
+function findExportNames(source, mode) {
+  if (mode === 'esm') {
+    const [, exports] = esModuleLexer__namespace.parse(source);
+    return exports;
+  }
+  const {
+    exports
+  } = cjsModuleLexer__namespace.parse(source);
+  return exports;
+}
+async function vocabLoader(source) {
+  trace(`Using vocab loader for ${this.resourcePath}`);
+  const callback = this.async();
+  if (!callback) {
+    throw new Error(`Webpack didn't provide an async callback`);
+  }
+
+  // this is necessary for the Web Assembly boot
+  await esModuleLexer__namespace.init;
+  const config = this.getOptions();
+  const devJsonFilePath = core.getDevLanguageFileFromTsFile(this.resourcePath);
+  const loadedTranslation = core.loadTranslation({
+    filePath: devJsonFilePath,
+    fallbacks: 'all'
+  }, config);
+  const target = this.target;
+  if (target && target !== 'web') {
+    trace(`Why are you using the loader on ${target}?`);
+    callback(new Error('Called Vocab Loader with non-web target'));
+    return;
+  }
+  const renderLanguageLoader = renderLanguageLoaderAsync.call(this, devJsonFilePath, loadedTranslation);
+  const translations = /* ts */`
+    const translations = createTranslationFile({
+      ${Object.keys(loadedTranslation.languages).map(lang => `${JSON.stringify(lang)}: ${renderLanguageLoader(lang)}`).join(',\n')}
+      });
+  `;
+  let result;
+  const esmExports = findExportNames(source, 'esm');
+  if (esmExports.length > 0) {
+    const exportName = esmExports[0];
+    result = /* ts */`
+      import { createLanguage, createTranslationFile } from '@vocab/webpack/${target};';
+      ${translations}
+      export { translations as ${exportName} };
+    `;
+  } else {
+    // init needs to be called and waited upon
+    await cjsModuleLexer__namespace.init();
+    const exportName = findExportNames(source, 'cjs')[0];
+    result = /* ts */`
+      const { createLanguage, createTranslationFile } = require('@vocab/webpack/${target}');
+      ${translations}
+      exports.${exportName} = translations;
+    `;
+  }
+  trace('Created translation file', result);
+  callback(null, result);
+}
+
+exports["default"] = vocabLoader;

package/loader/dist/vocab-webpack-loader.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./vocab-webpack-loader.cjs.prod.js");
+} else {
+  module.exports = require("./vocab-webpack-loader.cjs.dev.js");
+}

package/loader/dist/vocab-webpack-loader.cjs.prod.js

@@ -0,0 +1,136 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var path = require('path');
+var cjsModuleLexer = require('cjs-module-lexer');
+var esModuleLexer = require('es-module-lexer');
+var core = require('@vocab/core');
+var chunkName_dist_vocabWebpackChunkName = require('../../chunk-name/dist/vocab-webpack-chunk-name.cjs.prod.js');
+var logger = require('../../dist/logger-f79e34a8.cjs.prod.js');
+require('chalk');
+require('debug');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+var cjsModuleLexer__namespace = /*#__PURE__*/_interopNamespace(cjsModuleLexer);
+var esModuleLexer__namespace = /*#__PURE__*/_interopNamespace(esModuleLexer);
+
+const trace = logger.trace.extend('loader');
+
+// Resolve virtual-resource-loader dependency from current package
+const virtualResourceLoader = require.resolve('virtual-resource-loader');
+function createIdentifier(lang, resourcePath, loadedTranslation) {
+  var _loadedTranslation$la;
+  trace('Creating identifier for language', lang);
+  const languageTranslations = (_loadedTranslation$la = loadedTranslation.languages[lang]) !== null && _loadedTranslation$la !== void 0 ? _loadedTranslation$la : {};
+  const langJson = {};
+  for (const key of loadedTranslation.keys) {
+    langJson[key] = languageTranslations[key].message;
+  }
+  const base64 = Buffer.from(JSON.stringify(langJson), 'utf-8').toString('base64');
+  const unloader = `${virtualResourceLoader}?source=${base64}`;
+  const fileIdent = path__default["default"].basename(resourcePath, 'translations.json');
+  return `./${fileIdent}-${lang}-virtual.json!=!${unloader}!`;
+}
+
+// reimplement `stringifyRequest` from loader-utils 2.x
+// https://github.com/webpack/loader-utils/blob/master/CHANGELOG.md#300-2021-10-20
+function stringifyRequest(request) {
+  return JSON.stringify(this.utils.contextify(this.context, request));
+}
+function renderLanguageLoaderAsync(resourcePath, loadedTranslation) {
+  return lang => {
+    const identifier = stringifyRequest.call(this, createIdentifier(lang, resourcePath, loadedTranslation));
+    return (/* ts */`
+      createLanguage(
+        require.resolveWeak(${identifier}),
+        () => import(
+          /* webpackChunkName: ${JSON.stringify(chunkName_dist_vocabWebpackChunkName.getChunkName(lang))} */
+          ${identifier}
+        )
+      )
+    `.trim()
+    );
+  };
+}
+function findExportNames(source, mode) {
+  if (mode === 'esm') {
+    const [, exports] = esModuleLexer__namespace.parse(source);
+    return exports;
+  }
+  const {
+    exports
+  } = cjsModuleLexer__namespace.parse(source);
+  return exports;
+}
+async function vocabLoader(source) {
+  trace(`Using vocab loader for ${this.resourcePath}`);
+  const callback = this.async();
+  if (!callback) {
+    throw new Error(`Webpack didn't provide an async callback`);
+  }
+
+  // this is necessary for the Web Assembly boot
+  await esModuleLexer__namespace.init;
+  const config = this.getOptions();
+  const devJsonFilePath = core.getDevLanguageFileFromTsFile(this.resourcePath);
+  const loadedTranslation = core.loadTranslation({
+    filePath: devJsonFilePath,
+    fallbacks: 'all'
+  }, config);
+  const target = this.target;
+  if (target && target !== 'web') {
+    trace(`Why are you using the loader on ${target}?`);
+    callback(new Error('Called Vocab Loader with non-web target'));
+    return;
+  }
+  const renderLanguageLoader = renderLanguageLoaderAsync.call(this, devJsonFilePath, loadedTranslation);
+  const translations = /* ts */`
+    const translations = createTranslationFile({
+      ${Object.keys(loadedTranslation.languages).map(lang => `${JSON.stringify(lang)}: ${renderLanguageLoader(lang)}`).join(',\n')}
+      });
+  `;
+  let result;
+  const esmExports = findExportNames(source, 'esm');
+  if (esmExports.length > 0) {
+    const exportName = esmExports[0];
+    result = /* ts */`
+      import { createLanguage, createTranslationFile } from '@vocab/webpack/${target};';
+      ${translations}
+      export { translations as ${exportName} };
+    `;
+  } else {
+    // init needs to be called and waited upon
+    await cjsModuleLexer__namespace.init();
+    const exportName = findExportNames(source, 'cjs')[0];
+    result = /* ts */`
+      const { createLanguage, createTranslationFile } = require('@vocab/webpack/${target}');
+      ${translations}
+      exports.${exportName} = translations;
+    `;
+  }
+  trace('Created translation file', result);
+  callback(null, result);
+}
+
+exports["default"] = vocabLoader;

package/loader/dist/vocab-webpack-loader.esm.js

@@ -0,0 +1,108 @@
+import path from 'path';
+import * as cjsModuleLexer from 'cjs-module-lexer';
+import * as esModuleLexer from 'es-module-lexer';
+import { getDevLanguageFileFromTsFile, loadTranslation } from '@vocab/core';
+import { getChunkName } from '../../chunk-name/dist/vocab-webpack-chunk-name.esm.js';
+import { t as trace$1 } from '../../dist/logger-e1862ea1.esm.js';
+import 'chalk';
+import 'debug';
+
+const trace = trace$1.extend('loader');
+
+// Resolve virtual-resource-loader dependency from current package
+const virtualResourceLoader = require.resolve('virtual-resource-loader');
+function createIdentifier(lang, resourcePath, loadedTranslation) {
+  var _loadedTranslation$la;
+  trace('Creating identifier for language', lang);
+  const languageTranslations = (_loadedTranslation$la = loadedTranslation.languages[lang]) !== null && _loadedTranslation$la !== void 0 ? _loadedTranslation$la : {};
+  const langJson = {};
+  for (const key of loadedTranslation.keys) {
+    langJson[key] = languageTranslations[key].message;
+  }
+  const base64 = Buffer.from(JSON.stringify(langJson), 'utf-8').toString('base64');
+  const unloader = `${virtualResourceLoader}?source=${base64}`;
+  const fileIdent = path.basename(resourcePath, 'translations.json');
+  return `./${fileIdent}-${lang}-virtual.json!=!${unloader}!`;
+}
+
+// reimplement `stringifyRequest` from loader-utils 2.x
+// https://github.com/webpack/loader-utils/blob/master/CHANGELOG.md#300-2021-10-20
+function stringifyRequest(request) {
+  return JSON.stringify(this.utils.contextify(this.context, request));
+}
+function renderLanguageLoaderAsync(resourcePath, loadedTranslation) {
+  return lang => {
+    const identifier = stringifyRequest.call(this, createIdentifier(lang, resourcePath, loadedTranslation));
+    return (/* ts */`
+      createLanguage(
+        require.resolveWeak(${identifier}),
+        () => import(
+          /* webpackChunkName: ${JSON.stringify(getChunkName(lang))} */
+          ${identifier}
+        )
+      )
+    `.trim()
+    );
+  };
+}
+function findExportNames(source, mode) {
+  if (mode === 'esm') {
+    const [, exports] = esModuleLexer.parse(source);
+    return exports;
+  }
+  const {
+    exports
+  } = cjsModuleLexer.parse(source);
+  return exports;
+}
+async function vocabLoader(source) {
+  trace(`Using vocab loader for ${this.resourcePath}`);
+  const callback = this.async();
+  if (!callback) {
+    throw new Error(`Webpack didn't provide an async callback`);
+  }
+
+  // this is necessary for the Web Assembly boot
+  await esModuleLexer.init;
+  const config = this.getOptions();
+  const devJsonFilePath = getDevLanguageFileFromTsFile(this.resourcePath);
+  const loadedTranslation = loadTranslation({
+    filePath: devJsonFilePath,
+    fallbacks: 'all'
+  }, config);
+  const target = this.target;
+  if (target && target !== 'web') {
+    trace(`Why are you using the loader on ${target}?`);
+    callback(new Error('Called Vocab Loader with non-web target'));
+    return;
+  }
+  const renderLanguageLoader = renderLanguageLoaderAsync.call(this, devJsonFilePath, loadedTranslation);
+  const translations = /* ts */`
+    const translations = createTranslationFile({
+      ${Object.keys(loadedTranslation.languages).map(lang => `${JSON.stringify(lang)}: ${renderLanguageLoader(lang)}`).join(',\n')}
+      });
+  `;
+  let result;
+  const esmExports = findExportNames(source, 'esm');
+  if (esmExports.length > 0) {
+    const exportName = esmExports[0];
+    result = /* ts */`
+      import { createLanguage, createTranslationFile } from '@vocab/webpack/${target};';
+      ${translations}
+      export { translations as ${exportName} };
+    `;
+  } else {
+    // init needs to be called and waited upon
+    await cjsModuleLexer.init();
+    const exportName = findExportNames(source, 'cjs')[0];
+    result = /* ts */`
+      const { createLanguage, createTranslationFile } = require('@vocab/webpack/${target}');
+      ${translations}
+      exports.${exportName} = translations;
+    `;
+  }
+  trace('Created translation file', result);
+  callback(null, result);
+}
+
+export { vocabLoader as default };

package/loader/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "dist/vocab-webpack-loader.cjs.js",
+  "module": "dist/vocab-webpack-loader.esm.js"
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@vocab/webpack",
+  "version": "0.0.0-cjs-exports-20230421064630",
+  "main": "dist/vocab-webpack.cjs.js",
+  "module": "dist/vocab-webpack.esm.js",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "module": "./dist/vocab-webpack.esm.js",
+      "default": "./dist/vocab-webpack.cjs.js"
+    },
+    "./chunk-name": {
+      "module": "./chunk-name/dist/vocab-webpack-chunk-name.esm.js",
+      "default": "./chunk-name/dist/vocab-webpack-chunk-name.cjs.js"
+    },
+    "./loader": {
+      "module": "./loader/dist/vocab-webpack-loader.esm.js",
+      "default": "./loader/dist/vocab-webpack-loader.cjs.js"
+    },
+    "./web": {
+      "module": "./web/dist/vocab-webpack-web.esm.js",
+      "default": "./web/dist/vocab-webpack-web.cjs.js"
+    }
+  },
+  "author": "SEEK",
+  "license": "MIT",
+  "preconstruct": {
+    "entrypoints": [
+      "index.ts",
+      "loader.ts",
+      "web.ts",
+      "chunk-name.ts"
+    ]
+  },
+  "files": [
+    "chunk-name",
+    "dist",
+    "loader",
+    "web"
+  ],
+  "dependencies": {
+    "@vocab/core": "^1.3.0",
+    "chalk": "^4.1.0",
+    "cjs-module-lexer": "^1.2.2",
+    "debug": "^4.3.1",
+    "es-module-lexer": "^0.9.3",
+    "virtual-resource-loader": "^1.0.1"
+  },
+  "devDependencies": {
+    "@types/debug": "^4.1.5",
+    "webpack": "^5.37.0"
+  },
+  "peerDependencies": {
+    "webpack": "^5.37.0"
+  }
+}

package/web/dist/vocab-webpack-web.cjs.d.ts

@@ -0,0 +1 @@
+export * from "../../dist/declarations/src/web";

package/web/dist/vocab-webpack-web.cjs.dev.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var icuHandler = require('@vocab/core/icu-handler');
+var translationFile = require('@vocab/core/translation-file');
+
+const createLanguage = (moduleId, loadImport) => {
+  let promiseValue;
+  return {
+    getValue: locale => {
+      // @ts-expect-error Missing webpack types
+      if (!__webpack_modules__[moduleId]) {
+        return undefined;
+      }
+
+      // @ts-expect-error Missing webpack types
+      const m = __webpack_require__(moduleId);
+      return icuHandler.getParsedICUMessages(m, locale);
+    },
+    load: () => {
+      if (!promiseValue) {
+        promiseValue = loadImport();
+      }
+      return promiseValue;
+    }
+  };
+};
+
+Object.defineProperty(exports, 'createTranslationFile', {
+  enumerable: true,
+  get: function () { return translationFile.createTranslationFile; }
+});
+exports.createLanguage = createLanguage;

package/web/dist/vocab-webpack-web.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./vocab-webpack-web.cjs.prod.js");
+} else {
+  module.exports = require("./vocab-webpack-web.cjs.dev.js");
+}

package/web/dist/vocab-webpack-web.cjs.prod.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var icuHandler = require('@vocab/core/icu-handler');
+var translationFile = require('@vocab/core/translation-file');
+
+const createLanguage = (moduleId, loadImport) => {
+  let promiseValue;
+  return {
+    getValue: locale => {
+      // @ts-expect-error Missing webpack types
+      if (!__webpack_modules__[moduleId]) {
+        return undefined;
+      }
+
+      // @ts-expect-error Missing webpack types
+      const m = __webpack_require__(moduleId);
+      return icuHandler.getParsedICUMessages(m, locale);
+    },
+    load: () => {
+      if (!promiseValue) {
+        promiseValue = loadImport();
+      }
+      return promiseValue;
+    }
+  };
+};
+
+Object.defineProperty(exports, 'createTranslationFile', {
+  enumerable: true,
+  get: function () { return translationFile.createTranslationFile; }
+});
+exports.createLanguage = createLanguage;

package/web/dist/vocab-webpack-web.esm.js

@@ -0,0 +1,26 @@
+import { getParsedICUMessages } from '@vocab/core/icu-handler';
+export { createTranslationFile } from '@vocab/core/translation-file';
+
+const createLanguage = (moduleId, loadImport) => {
+  let promiseValue;
+  return {
+    getValue: locale => {
+      // @ts-expect-error Missing webpack types
+      if (!__webpack_modules__[moduleId]) {
+        return undefined;
+      }
+
+      // @ts-expect-error Missing webpack types
+      const m = __webpack_require__(moduleId);
+      return getParsedICUMessages(m, locale);
+    },
+    load: () => {
+      if (!promiseValue) {
+        promiseValue = loadImport();
+      }
+      return promiseValue;
+    }
+  };
+};
+
+export { createLanguage };

package/web/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "dist/vocab-webpack-web.cjs.js",
+  "module": "dist/vocab-webpack-web.esm.js"
+}