Server : Apache/2.4.41 (Ubuntu) System : Linux absol.cf 5.4.0-198-generic #218-Ubuntu SMP Fri Sep 27 20:18:53 UTC 2024 x86_64 User : www-data ( 33) PHP Version : 7.4.33 Disable Function : pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,pcntl_unshare, Directory :  /var/www/html/libs/absol-full/dist/js/

Upload File : current_dir [ Writeable ] document_root [ Writeable ]

/*** module: node_modules/absol-tutor/js/engine/ScriptEngine.js ***/
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _AsyncCommand = _interopRequireDefault(require("./AsyncCommand"));

var _runtime = _interopRequireDefault(require("regenerator-runtime/runtime"));

var _TProgram = _interopRequireDefault(require("./TProgram"));

var _TDebug = _interopRequireDefault(require("./TDebug"));


var traverse = babel.traverse;
var parse = babel.parse;
var babelTypes = babel.types;
var presetEnv = babel.presetEnv;
var generator = babel.generator;

function ScriptEngine() {
  this.asyncCommandClasses = {};
  this.syncCommandClasses = {};
  this.constantClasses = {};
  this.asyncCommandFunctions = {};
  this.syncCommandFunctions = {};
  this.constants = {};
  this.installClass(_TDebug.default);
}

ScriptEngine.prototype.makeModuleTemplate = function (code, argNames) {
  return 'module.exports = async function exec(' + argNames.join(',') + ') {\n' + code + '\nreturn 0;' + '}';
};

ScriptEngine.prototype.awaitInject = function (code, ast) {
  var dict = Object.assign({}, this.asyncCommandClasses, this.asyncCommandFunctions);
  traverse(ast, {
    ExpressionStatement: function (path) {
      if (path.node.ignore) return;
      if (path.node.loc.start.line === 1) return;

      var _db = babel.types.callExpression(babel.types.identifier("_db"), [babel.types.numericLiteral(path.node.loc.start.line), babel.types.numericLiteral(path.node.loc.start.column), babel.types.numericLiteral(path.node.start), babel.types.numericLiteral(path.node.end)]);

      _db.ignore = true;
      path.insertBefore(_db);
    },
    CallExpression: function (path) {
      var needUpdate = false;

      if (path.parent.type === 'AwaitExpression') {
        needUpdate = true;
      } else {
        var node = path.node;
        var callee = node.callee;
        var calleeName = code.substr(callee.start, callee.end - callee.start);

        if (dict[calleeName]) {
          var newNode = babelTypes.awaitExpression(node);
          path.replaceWith(newNode);
          needUpdate = true;
        }
      }

      if (needUpdate) {
        var p = path;
        var pNode;

        while (p) {
          pNode = p.node;

          if (pNode.type === 'FunctionDeclaration') {
            pNode.async = true;
            dict[pNode.id.name] = true;
            break;
          }

          p = p.parentPath;
        }
      }
    }
  });
  return ast;
};

ScriptEngine.prototype.makeEnvVariable = function (process, name) {
  var clazz = this.asyncCommandClasses[name] || this.syncCommandClasses[name];
  var className;

  if (clazz) {
    if (clazz.attachEnv) {
      clazz.attachEnv(process, process.env);
    } else {
      className = clazz.prototype.className || clazz.name;
      new Function('process', 'env', className, 'env.' + name + ' = function ' + name + '(' + clazz.prototype.argNames.join(', ') + ') {' + 'return new ' + className + '(process, {' + clazz.prototype.argNames.map(function (argName) {
        return argName + ': ' + argName;
      }).concat('arguments: Array.prototype.slice.call(arguments)').join(',\n') + '}).exec();' + '}')(process, process.env, clazz);
    }

    return;
  }

  clazz = this.constantClasses[name];

  if (clazz) {
    if (clazz.attachEnv) {
      clazz.attachEnv(process, process.env);
    } else {
      process.env[name] = new clazz(process, {});
    }

    return;
  }

  var func = this.syncCommandFunctions[name] || this.asyncCommandFunctions[name];

  if (func) {
    process.env[name] = func;
    return;
  }

  if (name in this.constants) {
    process.env[name] = this.constants[name];
  }
};
/***
 *
 * @param {TProcess} process
 * @returns {*}
 */


ScriptEngine.prototype.makeEnvVariables = function (process) {
  process.program.envArgNames.forEach(function (arg) {
    this.makeEnvVariable(process, arg);
  }.bind(this));
};

ScriptEngine.prototype.ProgramClass = _TProgram.default;
/***
 * @returns TProgram
 */

ScriptEngine.prototype.compile = function (code) {
  var argNames = Object.keys(Object.assign({}, this.asyncCommandClasses, this.syncCommandClasses, this.constantClasses, this.syncCommandFunctions, this.asyncCommandFunctions, this.constants));
  code = this.makeModuleTemplate(code, argNames);
  var ast = parse(code);
  this.awaitInject(code, ast);
  var options = {
    presets: [presetEnv]
  };
  var newCode = generator(ast, {}, code).code;
  var transformedCode = babel.transform(newCode, options).code;
  var m = {};
  var execFn = new Function('module', 'regeneratorRuntime', transformedCode);
  execFn(m, _runtime.default);
  return new this.ProgramClass(this, m.exports, argNames, {
    code: code,
    es6Code: newCode,
    transformedCode: transformedCode
  });
};

ScriptEngine.prototype.installClass = function (clazz) {
  var type = clazz.prototype.type;
  var name = clazz.prototype.name;

  switch (type) {
    case 'async':
      this.asyncCommandClasses[name] = clazz;
      break;

    case 'sync':
      this.syncCommandClasses[name] = clazz;
      break;

    case 'const':
      this.constantClasses[name] = clazz;
      break;
  }

  return this;
};

ScriptEngine.prototype.installFunction = function (name, func, async) {
  if (async) {
    this.asyncCommandFunctions[name] = func;
  } else {
    this.syncCommandFunctions[name] = func;
  }

  return this;
};

ScriptEngine.prototype.installConst = function (name, value) {
  this.constants[name] = value;
};

var _default = ScriptEngine;
exports.default = _default;