Diffusion Open Access Compliance Check Tool (OACCT) (issn4frontend) Browse

rOACCT/node_modules/babel-traverse/lib/path/introspection.js
49c99f97fe9aissn4frontend

introspection.js
View Options

			"use strict";

			exports.__esModule = true;
			exports.is = undefined;

			var _getIterator2 = require("babel-runtime/core-js/get-iterator");

			var _getIterator3 = _interopRequireDefault(_getIterator2);

			exports.matchesPattern = matchesPattern;
			exports.has = has;
			exports.isStatic = isStatic;
			exports.isnt = isnt;
			exports.equals = equals;
			exports.isNodeType = isNodeType;
			exports.canHaveVariableDeclarationOrExpression = canHaveVariableDeclarationOrExpression;
			exports.canSwapBetweenExpressionAndStatement = canSwapBetweenExpressionAndStatement;
			exports.isCompletionRecord = isCompletionRecord;
			exports.isStatementOrBlock = isStatementOrBlock;
			exports.referencesImport = referencesImport;
			exports.getSource = getSource;
			exports.willIMaybeExecuteBefore = willIMaybeExecuteBefore;
			exports._guessExecutionStatusRelativeTo = _guessExecutionStatusRelativeTo;
			exports._guessExecutionStatusRelativeToDifferentFunctions = _guessExecutionStatusRelativeToDifferentFunctions;
			exports.resolve = resolve;
			exports._resolve = _resolve;

			var _includes = require("lodash/includes");

			var _includes2 = _interopRequireDefault(_includes);

			var _babelTypes = require("babel-types");

			var t = _interopRequireWildcard(_babelTypes);

			function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

			function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

			function matchesPattern(pattern, allowPartial) {
			if (!this.isMemberExpression()) return false;

			var parts = pattern.split(".");
			var search = [this.node];
			var i = 0;

			function matches(name) {
			var part = parts[i];
			return part === "*" \|\| name === part;
			}

			while (search.length) {
			var node = search.shift();

			if (allowPartial && i === parts.length) {
			return true;
			}

			if (t.isIdentifier(node)) {
			if (!matches(node.name)) return false;
			} else if (t.isLiteral(node)) {
			if (!matches(node.value)) return false;
			} else if (t.isMemberExpression(node)) {
			if (node.computed && !t.isLiteral(node.property)) {
			return false;
			} else {
			search.unshift(node.property);
			search.unshift(node.object);
			continue;
			}
			} else if (t.isThisExpression(node)) {
			if (!matches("this")) return false;
			} else {
			return false;
			}

			if (++i > parts.length) {
			return false;
			}
			}

			return i === parts.length;
			}

			function has(key) {
			var val = this.node && this.node[key];
			if (val && Array.isArray(val)) {
			return !!val.length;
			} else {
			return !!val;
			}
			}

			function isStatic() {
			return this.scope.isStatic(this.node);
			}

			var is = exports.is = has;

			function isnt(key) {
			return !this.has(key);
			}

			function equals(key, value) {
			return this.node[key] === value;
			}

			function isNodeType(type) {
			return t.isType(this.type, type);
			}

			function canHaveVariableDeclarationOrExpression() {
			return (this.key === "init" \|\| this.key === "left") && this.parentPath.isFor();
			}

			function canSwapBetweenExpressionAndStatement(replacement) {
			if (this.key !== "body" \|\| !this.parentPath.isArrowFunctionExpression()) {
			return false;
			}

			if (this.isExpression()) {
			return t.isBlockStatement(replacement);
			} else if (this.isBlockStatement()) {
			return t.isExpression(replacement);
			}

			return false;
			}

			function isCompletionRecord(allowInsideFunction) {
			var path = this;
			var first = true;

			do {
			var container = path.container;

			if (path.isFunction() && !first) {
			return !!allowInsideFunction;
			}

			first = false;

			if (Array.isArray(container) && path.key !== container.length - 1) {
			return false;
			}
			} while ((path = path.parentPath) && !path.isProgram());

			return true;
			}

			function isStatementOrBlock() {
			if (this.parentPath.isLabeledStatement() \|\| t.isBlockStatement(this.container)) {
			return false;
			} else {
			return (0, _includes2.default)(t.STATEMENT_OR_BLOCK_KEYS, this.key);
			}
			}

			function referencesImport(moduleSource, importName) {
			if (!this.isReferencedIdentifier()) return false;

			var binding = this.scope.getBinding(this.node.name);
			if (!binding \|\| binding.kind !== "module") return false;

			var path = binding.path;
			var parent = path.parentPath;
			if (!parent.isImportDeclaration()) return false;

			if (parent.node.source.value === moduleSource) {
			if (!importName) return true;
			} else {
			return false;
			}

			if (path.isImportDefaultSpecifier() && importName === "default") {
			return true;
			}

			if (path.isImportNamespaceSpecifier() && importName === "*") {
			return true;
			}

			if (path.isImportSpecifier() && path.node.imported.name === importName) {
			return true;
			}

			return false;
			}

			function getSource() {
			var node = this.node;
			if (node.end) {
			return this.hub.file.code.slice(node.start, node.end);
			} else {
			return "";
			}
			}

			function willIMaybeExecuteBefore(target) {
			return this._guessExecutionStatusRelativeTo(target) !== "after";
			}

			function _guessExecutionStatusRelativeTo(target) {
			var targetFuncParent = target.scope.getFunctionParent();
			var selfFuncParent = this.scope.getFunctionParent();

			if (targetFuncParent.node !== selfFuncParent.node) {
			var status = this._guessExecutionStatusRelativeToDifferentFunctions(targetFuncParent);
			if (status) {
			return status;
			} else {
			target = targetFuncParent.path;
			}
			}

			var targetPaths = target.getAncestry();
			if (targetPaths.indexOf(this) >= 0) return "after";

			var selfPaths = this.getAncestry();

			var commonPath = void 0;
			var targetIndex = void 0;
			var selfIndex = void 0;
			for (selfIndex = 0; selfIndex < selfPaths.length; selfIndex++) {
			var selfPath = selfPaths[selfIndex];
			targetIndex = targetPaths.indexOf(selfPath);
			if (targetIndex >= 0) {
			commonPath = selfPath;
			break;
			}
			}
			if (!commonPath) {
			return "before";
			}

			var targetRelationship = targetPaths[targetIndex - 1];
			var selfRelationship = selfPaths[selfIndex - 1];
			if (!targetRelationship \|\| !selfRelationship) {
			return "before";
			}

			if (targetRelationship.listKey && targetRelationship.container === selfRelationship.container) {
			return targetRelationship.key > selfRelationship.key ? "before" : "after";
			}

			var targetKeyPosition = t.VISITOR_KEYS[targetRelationship.type].indexOf(targetRelationship.key);
			var selfKeyPosition = t.VISITOR_KEYS[selfRelationship.type].indexOf(selfRelationship.key);
			return targetKeyPosition > selfKeyPosition ? "before" : "after";
			}

			function _guessExecutionStatusRelativeToDifferentFunctions(targetFuncParent) {
			var targetFuncPath = targetFuncParent.path;
			if (!targetFuncPath.isFunctionDeclaration()) return;

			var binding = targetFuncPath.scope.getBinding(targetFuncPath.node.id.name);

			if (!binding.references) return "before";

			var referencePaths = binding.referencePaths;

			for (var _iterator = referencePaths, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) {
			var _ref;

			if (_isArray) {
			if (_i >= _iterator.length) break;
			_ref = _iterator[_i++];
			} else {
			_i = _iterator.next();
			if (_i.done) break;
			_ref = _i.value;
			}

			var path = _ref;

			if (path.key !== "callee" \|\| !path.parentPath.isCallExpression()) {
			return;
			}
			}

			var allStatus = void 0;

			for (var _iterator2 = referencePaths, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : (0, _getIterator3.default)(_iterator2);;) {
			var _ref2;

			if (_isArray2) {
			if (_i2 >= _iterator2.length) break;
			_ref2 = _iterator2[_i2++];
			} else {
			_i2 = _iterator2.next();
			if (_i2.done) break;
			_ref2 = _i2.value;
			}

			var _path = _ref2;

			var childOfFunction = !!_path.find(function (path) {
			return path.node === targetFuncPath.node;
			});
			if (childOfFunction) continue;

			var status = this._guessExecutionStatusRelativeTo(_path);

			if (allStatus) {
			if (allStatus !== status) return;
			} else {
			allStatus = status;
			}
			}

			return allStatus;
			}

			function resolve(dangerous, resolved) {
			return this._resolve(dangerous, resolved) \|\| this;
			}

			function _resolve(dangerous, resolved) {
			if (resolved && resolved.indexOf(this) >= 0) return;

			resolved = resolved \|\| [];
			resolved.push(this);

			if (this.isVariableDeclarator()) {
			if (this.get("id").isIdentifier()) {
			return this.get("init").resolve(dangerous, resolved);
			} else {}
			} else if (this.isReferencedIdentifier()) {
			var binding = this.scope.getBinding(this.node.name);
			if (!binding) return;

			if (!binding.constant) return;

			if (binding.kind === "module") return;

			if (binding.path !== this) {
			var ret = binding.path.resolve(dangerous, resolved);

			if (this.find(function (parent) {
			return parent.node === ret.node;
			})) return;
			return ret;
			}
			} else if (this.isTypeCastExpression()) {
			return this.get("expression").resolve(dangerous, resolved);
			} else if (dangerous && this.isMemberExpression()) {

			var targetKey = this.toComputedKey();
			if (!t.isLiteral(targetKey)) return;

			var targetName = targetKey.value;

			var target = this.get("object").resolve(dangerous, resolved);

			if (target.isObjectExpression()) {
			var props = target.get("properties");
			for (var _iterator3 = props, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : (0, _getIterator3.default)(_iterator3);;) {
			var _ref3;

			if (_isArray3) {
			if (_i3 >= _iterator3.length) break;
			_ref3 = _iterator3[_i3++];
			} else {
			_i3 = _iterator3.next();
			if (_i3.done) break;
			_ref3 = _i3.value;
			}

			var prop = _ref3;

			if (!prop.isProperty()) continue;

			var key = prop.get("key");

			var match = prop.isnt("computed") && key.isIdentifier({ name: targetName });

			match = match \|\| key.isLiteral({ value: targetName });

			if (match) return prop.get("value").resolve(dangerous, resolved);
			}
			} else if (target.isArrayExpression() && !isNaN(+targetName)) {
			var elems = target.get("elements");
			var elem = elems[targetName];
			if (elem) return elem.resolve(dangerous, resolved);
			}
			}
			}