gs_nuxt/node_modules/hard-source-webpack-plugin/lib/TransformGeneratorPlugin.js

const relateContext = require('./util/relate-context');
const pluginCompat = require('./util/plugin-compat');

const GeneratorSchemas4 = [
  ['ByTypeGenerator', 'map'],
  ['JavascriptGenerator'],
  ['JsonGenerator'],
  ['WebAssemblyGenerator'],
  ['WebAssemblyJavascriptGenerator'],
];

try {
  try {
    GeneratorSchemas4[0].Generator = require('webpack/lib/Generator').byType(
      {},
    ).constructor;
  } catch (_) {}
  GeneratorSchemas4[1].Generator = require('webpack/lib/JavascriptGenerator');
  GeneratorSchemas4[2].Generator = require('webpack/lib/JsonGenerator');
  try {
    GeneratorSchemas4[3].Generator = require('webpack/lib/WebAssemblyGenerator');
  } catch (_) {
    GeneratorSchemas4[3].Generator = require('webpack/lib/wasm/WebAssemblyGenerator');
  }
  try {
    GeneratorSchemas4[4].Generator = require('webpack/lib/wasm/WebAssemblyJavascriptGenerator');
  } catch (_) {}
} catch (_) {}

const freezeArgument = {
  map(arg, generator, extra, methods) {
    const map = {};
    for (const key in arg) {
      map[key] = methods.freeze('Generator', null, arg[key], extra);
    }
    return map;
  },
};

const thawArgument = {
  map(arg, generator, extra, methods) {
    const map = {};
    for (const key in arg) {
      map[key] = methods.thaw('Generator', null, arg[key], extra);
    }
    return map;
  },
};

function freezeGenerator(generator, extra, methods) {
  const schemas = extra.schemas;
  for (let i = 0; i < schemas.length; i++) {
    if (generator.constructor === schemas[i].Generator) {
      const frozen = {
        type: schemas[i][0],
      };
      for (let j = 1; j < schemas[i].length; j++) {
        let arg = generator[schemas[i][j]];
        if (freezeArgument[schemas[i][j]]) {
          arg = freezeArgument[schemas[i][j]](arg, generator, extra, methods);
        }
        frozen[schemas[i][j]] = arg;
      }
      return frozen;
    }
  }
}

function thawGenerator(frozen, extra, methods) {
  const schemas = extra.schemas;
  for (let i = 0; i < schemas.length; i++) {
    if (frozen.type === schemas[i][0]) {
      const Generator = schemas[i].Generator;
      const args = [];
      for (let j = 1; j < schemas[i].length; j++) {
        let arg = frozen[schemas[i][j]];
        if (thawArgument[schemas[i][j]]) {
          arg = thawArgument[schemas[i][j]](arg, frozen, extra, methods);
        }
        args.push(arg);
      }
      try {
        return new Generator(...args);
      } catch (_) {
        return new (Function.prototype.bind.apply(
          Generator,
          [null].concat(args),
        ))();
      }
    }
  }
}

class TransformGeneratorPlugin {
  apply(compiler) {
    pluginCompat.register(
      compiler,
      '_hardSourceBeforeFreezeGenerator',
      'syncWaterfall',
      ['frozen', 'item', 'extra'],
    );
    pluginCompat.register(
      compiler,
      '_hardSourceFreezeGenerator',
      'syncWaterfall',
      ['frozen', 'item', 'extra'],
    );
    pluginCompat.register(
      compiler,
      '_hardSourceAfterFreezeGenerator',
      'syncWaterfall',
      ['frozen', 'item', 'extra'],
    );

    pluginCompat.register(
      compiler,
      '_hardSourceBeforeThawGenerator',
      'syncWaterfall',
      ['item', 'frozen', 'extra'],
    );
    pluginCompat.register(
      compiler,
      '_hardSourceThawGenerator',
      'syncWaterfall',
      ['item', 'frozen', 'extra'],
    );
    pluginCompat.register(
      compiler,
      '_hardSourceAfterThawGenerator',
      'syncWaterfall',
      ['item', 'frozen', 'extra'],
    );

    let methods;

    pluginCompat.tap(
      compiler,
      '_hardSourceMethods',
      'TransformGeneratorPlugin',
      _methods => {
        methods = _methods;
      },
    );

    pluginCompat.tap(
      compiler,
      '_hardSourceFreezeGenerator',
      'TransformGeneratorPlugin freeze',
      (frozen, generator, extra) => {
        extra.schemas = GeneratorSchemas4;
        frozen = freezeGenerator(generator, extra, methods);
        frozen.moduleType = extra.module.type;
        frozen.options = {};
        return frozen;
      },
    );

    pluginCompat.tap(
      compiler,
      '_hardSourceThawGenerator',
      'TransformGeneratorPlugin thaw',
      (generator, { moduleType, options }, { normalModuleFactory }) => {
        return normalModuleFactory.getGenerator(moduleType, options);
      },
    );
  }
}

module.exports = TransformGeneratorPlugin;