LIT COUSRE TEAM

Uname	: Linux hebron 6.14.3-x86_64-linode168 #1 SMP PREEMPT_DYNAMIC Mon Apr 21 19:47:55 EDT 2025 x86_64
Software	: Apache
PHP	: 5.5.9-1ubuntu4.29
IP Server	: 151.236.222.163
Port	: io.eteclab.net:80
Mail	: ON

File Name : toAST.js

var source;

module.exports = function (ast, traverse, code) {
  source = code;
  ast.range = [ast.start, ast.end];
  traverse(ast, astTransformVisitor);
};

var astTransformVisitor = {
  noScope: true,
  enter: function (path) {
    var node = path.node;

node.range = [node.start, node.end];

// private var to track original node type
    node._babelType = node.type;

if (node.innerComments) {
      node.trailingComments = node.innerComments;
      delete node.innerComments;
    }

if (node.trailingComments) {
      changeComments(node.trailingComments);
    }

if (node.leadingComments) {
      changeComments(node.leadingComments);
    }

// make '_paths' non-enumerable (babel-eslint #200)
    Object.defineProperty(node, "_paths", { value: node._paths, writable: true });
  },
  exit: function (path) {
    var node = path.node;

[
      fixDirectives,
    ].forEach(function (fixer) {
      fixer(path);
    });

if (path.isJSXText()) {
      node.type = "Literal";
      node.raw = node.value;
    }

if (path.isNumericLiteral() ||
        path.isStringLiteral()) {
      changeToLiteral(node);
    }

if (path.isBooleanLiteral()) {
      node.type = "Literal";
      node.raw = String(node.value);
    }

if (path.isNullLiteral()) {
      node.type = "Literal";
      node.raw = "null";
      node.value = null;
    }

if (path.isRegExpLiteral()) {
      node.type = "Literal";
      node.raw = node.extra.raw;
      node.value = {};
      node.regex = {
        pattern: node.pattern,
        flags: node.flags
      };
      delete node.extra;
      delete node.pattern;
      delete node.flags;
    }

if (path.isObjectProperty()) {
      node.type = "Property";
      node.kind = "init";
    }

if (path.isClassMethod() || path.isObjectMethod()) {
      var code = source.slice(node.key.end, node.body.start);
      var offset = code.indexOf("(");

node.value = {
        type: "FunctionExpression",
        id: node.id,
        params: node.params,
        body: node.body,
        async: node.async,
        generator: node.generator,
        expression: node.expression,
        defaults: [], // basic support - TODO: remove (old esprima)
        loc: {
          start: {
            line: node.key.loc.start.line,
            column: node.key.loc.end.column + offset // a[() {]
          },
          end: node.body.loc.end
        }
      };
      // [asdf]() {
      node.value.range = [node.key.end + offset, node.body.end];

node.value.start = node.value.range && node.value.range[0] || node.value.loc.start.column;
      node.value.end = node.value.range && node.value.range[1] || node.value.loc.end.column;

if (node.returnType) {
        node.value.returnType = node.returnType;
      }

if (node.typeParameters) {
        node.value.typeParameters = node.typeParameters;
      }

if (path.isClassMethod()) {
        node.type = "MethodDefinition";
      }

if (path.isObjectMethod()) {
        node.type = "Property";
        if (node.kind === "method") {
          node.kind = "init";
        }
      }

delete node.body;
      delete node.id;
      delete node.async;
      delete node.generator;
      delete node.expression;
      delete node.params;
      delete node.returnType;
      delete node.typeParameters;
    }

if (path.isRestProperty() || path.isSpreadProperty()) {
      node.type = `Experimental${node.type}`;
    }

if (path.isTypeParameter && path.isTypeParameter()) {
      node.type = "Identifier";
      node.typeAnnotation = node.bound;
      delete node.bound;
    }

// flow: prevent "no-undef"
    // for "Component" in: "let x: React.Component"
    if (path.isQualifiedTypeIdentifier()) {
      delete node.id;
    }
    // for "b" in: "var a: { b: Foo }"
    if (path.isObjectTypeProperty()) {
      delete node.key;
    }
    // for "indexer" in: "var a: {[indexer: string]: number}"
    if (path.isObjectTypeIndexer()) {
      delete node.id;
    }
    // for "param" in: "var a: { func(param: Foo): Bar };"
    if (path.isFunctionTypeParam()) {
      delete node.name;
    }

// modules

if (path.isImportDeclaration()) {
      delete node.isType;
    }

if (path.isExportDeclaration()) {
      var declar = path.get("declaration");
      if (declar.isClassExpression()) {
        node.declaration.type = "ClassDeclaration";
      } else if (declar.isFunctionExpression()) {
        node.declaration.type = "FunctionDeclaration";
      }
    }

// TODO: remove (old esprima)
    if (path.isFunction()) {
      if (!node.defaults) {
        node.defaults = [];
      }
    }

// template string range fixes
    if (path.isTemplateLiteral()) {
      node.quasis.forEach(function (q) {
        q.range[0] -= 1;
        if (q.tail) {
          q.range[1] += 1;
        } else {
          q.range[1] += 2;
        }
        q.loc.start.column -= 1;
        if (q.tail) {
          q.loc.end.column += 1;
        } else {
          q.loc.end.column += 2;
        }
      });
    }
  }
};

function fixDirectives (path) {
  if (!(path.isProgram() || path.isFunction())) return;

var node = path.node;
  var directivesContainer = node;
  var body = node.body;

if (node.type !== "Program") {
    directivesContainer = body;
    body = body.body;
  }

if (!directivesContainer.directives) return;

directivesContainer.directives.reverse().forEach(function (directive) {
    directive.type = "ExpressionStatement";
    directive.expression = directive.value;
    delete directive.value;
    directive.expression.type = "Literal";
    changeToLiteral(directive.expression);
    body.unshift(directive);
  });
  delete directivesContainer.directives;
}
// fixDirectives

	: Add Folder
	: Add File
	: Edit File
	: Rename
	: Chmod
	: Delete

Name	Type	Size	Permission	Last Modified	Actions
.	dir	-	0755	2021-11-10 09:12:42	Buat Folder Buat File Info
..	dir	-	0755	2021-11-10 09:12:42
attachComments.js	text/plain	2 KB	0644	2016-04-01 01:10:56	edit rename chmod hapus
convertTemplateType.js	text/plain	2.47 KB	0644	2016-08-03 03:36:05	edit rename chmod hapus
index.js	text/plain	616 B	0644	2016-08-03 03:36:05	edit rename chmod hapus
toAST.js	text/plain	6.18 KB	0644	2016-10-26 08:34:35	edit rename chmod hapus
toToken.js	text/plain	2.25 KB	0644	2016-10-26 08:34:35	edit rename chmod hapus
toTokens.js	text/plain	526 B	0644	2016-04-01 01:10:56	edit rename chmod hapus