luhn-generator
Version:
A generator of numbers that passes the validation of Luhn algorithm or Luhn formula, also known as the 'modulus 10' or 'mod 10' algorithm
337 lines (271 loc) • 8.71 kB
JavaScript
;
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
module.exports = function evaluate(path, {
tdz = false
} = {}) {
if (!tdz && !path.isReferencedIdentifier()) {
return baseEvaluate(path);
}
if (path.isReferencedIdentifier()) {
return evaluateIdentifier(path);
}
const state = {
confident: true
}; // prepare
path.traverse({
Scope(scopePath) {
scopePath.skip();
},
ReferencedIdentifier(idPath) {
const binding = idPath.scope.getBinding(idPath.node.name); // don't deopt globals
// let babel take care of it
if (!binding) return;
const evalResult = evaluateIdentifier(idPath);
if (!evalResult.confident) {
state.confident = evalResult.confident;
state.deoptPath = evalResult.deoptPath;
}
}
});
if (!state.confident) {
return state;
}
return baseEvaluate(path);
};
function baseEvaluate(path) {
try {
return path.evaluate();
} catch (e) {
return {
confident: false,
error: e
};
}
} // Original Source:
// https://github.com/babel/babel/blob/master/packages/babel-traverse/src/path/evaluation.js
// modified for Babel-minify use
function evaluateIdentifier(path) {
if (!path.isReferencedIdentifier()) {
throw new Error(`Expected ReferencedIdentifier. Got ${path.type}`);
}
const node = path.node;
const binding = path.scope.getBinding(node.name);
if (!binding) {
const name = node.name;
if (!name) {
return deopt(path);
}
switch (name) {
case "undefined":
return {
confident: true,
value: undefined
};
case "NaN":
return {
confident: true,
value: NaN
};
case "Infinity":
return {
confident: true,
value: Infinity
};
default:
return deopt(path);
}
}
if (binding.constantViolations.length > 0) {
return deopt(binding.path);
} // referenced in a different scope - deopt
if (shouldDeoptBasedOnScope(binding, path)) {
return deopt(path);
} // let/var/const referenced before init
// or "var" referenced in an outer scope
const flowEvalResult = evaluateBasedOnControlFlow(binding, path);
if (flowEvalResult.confident) {
return flowEvalResult;
}
if (flowEvalResult.shouldDeopt) {
return deopt(path);
}
return path.evaluate();
} // check if referenced in a different fn scope
// we can't determine if this function is called sync or async
// if the binding is in program scope
// all it's references inside a different function should be deopted
function shouldDeoptBasedOnScope(binding, refPath) {
if (binding.scope.path.isProgram() && refPath.scope !== binding.scope) {
return true;
}
return false;
}
function evaluateBasedOnControlFlow(binding, refPath) {
if (binding.kind === "var") {
// early-exit
const declaration = binding.path.parentPath;
if (declaration.parentPath) {
/**
* Handle when binding is created inside a parent block and
* the corresponding parent is removed by other plugins
* if (false) { var a } -> var a
*/
if (declaration.parentPath.removed) {
return {
confident: true,
value: void 0
};
}
if (declaration.parentPath.isIfStatement() || declaration.parentPath.isLoop() || declaration.parentPath.isSwitchCase()) {
return {
shouldDeopt: true
};
}
}
const fnParent = (binding.path.scope.getFunctionParent() || binding.path.scope.getProgramParent()).path;
let blockParentPath = binding.path.scope.getBlockParent().path;
let blockParent = blockParentPath.node;
if (blockParentPath === fnParent && !fnParent.isProgram()) {
blockParent = blockParent.body;
} // detect Usage Outside Init Scope
const blockBody = blockParent.body;
if (Array.isArray(blockBody) && !blockBody.some(stmt => isAncestor(stmt, refPath))) {
return {
shouldDeopt: true
};
} // Detect usage before init
const stmts = fnParent.isProgram() ? fnParent.node.body : fnParent.node.body.body;
const compareResult = compareBindingAndReference({
binding,
refPath,
stmts
});
if (compareResult.reference && compareResult.binding) {
if (compareResult.reference.scope === "current" && compareResult.reference.idx < compareResult.binding.idx) {
return {
confident: true,
value: void 0
};
}
}
} else if (binding.kind === "let" || binding.kind === "const") {
// binding.path is the declarator
const declarator = binding.path;
const declaration = declarator.parentPath;
if (declaration.parentPath && (declaration.parentPath.isIfStatement() || declaration.parentPath.isLoop() || declaration.parentPath.isSwitchCase())) {
return {
shouldDeopt: true
};
}
const scopePath = declarator.scope.path;
let scopeNode = scopePath.node;
if (scopePath.isFunction() || scopePath.isCatchClause()) {
scopeNode = scopeNode.body;
} // Detect Usage before Init
let stmts = scopeNode.body;
if (!Array.isArray(stmts)) {
stmts = [stmts];
}
const compareResult = compareBindingAndReference({
binding,
refPath,
stmts
});
if (compareResult.reference && compareResult.binding) {
if (compareResult.reference.scope === "current" && compareResult.reference.idx < compareResult.binding.idx) {
throw new Error(`ReferenceError: Used ${refPath.node.name}: ` + `${binding.kind} binding before declaration`);
}
if (compareResult.reference.scope === "other") {
return {
shouldDeopt: true
};
}
}
}
return {
confident: false,
shouldDeopt: false
};
}
function compareBindingAndReference({
binding,
refPath,
stmts
}) {
const state = {
binding: null,
reference: null
};
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = stmts.entries()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
const _step$value = _slicedToArray(_step.value, 2),
idx = _step$value[0],
stmt = _step$value[1];
if (isAncestor(stmt, binding.path)) {
state.binding = {
idx
};
}
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = binding.referencePaths[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
const ref = _step2.value;
if (ref === refPath && isAncestor(stmt, ref)) {
state.reference = {
idx,
scope: binding.path.scope === ref.scope ? "current" : "other"
};
break;
}
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return state;
}
function deopt(deoptPath) {
return {
confident: false,
deoptPath
};
}
/**
* is nodeParent an ancestor of path
*/
function isAncestor(nodeParent, path) {
return !!path.findParent(parent => parent.node === nodeParent);
}