This repository has been archived on 2024-07-27. You can view files and clone it, but cannot push or open issues or pull requests.
keksAccountGUI/node_modulesOLD/@babel/plugin-transform-for-of/lib/index.js

310 lines
9 KiB
JavaScript
Raw Normal View History

2019-08-11 18:48:02 +00:00
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
function _helperPluginUtils() {
const data = require("@babel/helper-plugin-utils");
_helperPluginUtils = function () {
return data;
};
return data;
}
function _core() {
const data = require("@babel/core");
_core = function () {
return data;
};
return data;
}
var _default = (0, _helperPluginUtils().declare)((api, options) => {
api.assertVersion(7);
const {
loose,
assumeArray
} = options;
if (loose === true && assumeArray === true) {
throw new Error(`The loose and assumeArray options cannot be used together in @babel/plugin-transform-for-of`);
}
if (assumeArray) {
return {
name: "transform-for-of",
visitor: {
ForOfStatement(path) {
const {
scope
} = path;
const {
left,
right,
body
} = path.node;
const i = scope.generateUidIdentifier("i");
let array = scope.maybeGenerateMemoised(right, true);
const inits = [_core().types.variableDeclarator(i, _core().types.numericLiteral(0))];
if (array) {
inits.push(_core().types.variableDeclarator(array, right));
} else {
array = right;
}
const item = _core().types.memberExpression(_core().types.cloneNode(array), _core().types.cloneNode(i), true);
let assignment;
if (_core().types.isVariableDeclaration(left)) {
assignment = left;
assignment.declarations[0].init = item;
} else {
assignment = _core().types.expressionStatement(_core().types.assignmentExpression("=", left, item));
}
const block = _core().types.toBlock(body);
block.body.unshift(assignment);
path.replaceWith(_core().types.forStatement(_core().types.variableDeclaration("let", inits), _core().types.binaryExpression("<", _core().types.cloneNode(i), _core().types.memberExpression(_core().types.cloneNode(array), _core().types.identifier("length"))), _core().types.updateExpression("++", _core().types.cloneNode(i)), block));
}
}
};
}
const pushComputedProps = loose ? pushComputedPropsLoose : pushComputedPropsSpec;
const buildForOfArray = (0, _core().template)(`
for (var KEY = 0, NAME = ARR; KEY < NAME.length; KEY++) BODY;
`);
const buildForOfLoose = (0, _core().template)(`
for (var LOOP_OBJECT = OBJECT,
IS_ARRAY = Array.isArray(LOOP_OBJECT),
INDEX = 0,
LOOP_OBJECT = IS_ARRAY ? LOOP_OBJECT : LOOP_OBJECT[Symbol.iterator]();;) {
INTERMEDIATE;
if (IS_ARRAY) {
if (INDEX >= LOOP_OBJECT.length) break;
ID = LOOP_OBJECT[INDEX++];
} else {
INDEX = LOOP_OBJECT.next();
if (INDEX.done) break;
ID = INDEX.value;
}
}
`);
const buildForOf = (0, _core().template)(`
var ITERATOR_COMPLETION = true;
var ITERATOR_HAD_ERROR_KEY = false;
var ITERATOR_ERROR_KEY = undefined;
try {
for (
var ITERATOR_KEY = OBJECT[Symbol.iterator](), STEP_KEY;
!(ITERATOR_COMPLETION = (STEP_KEY = ITERATOR_KEY.next()).done);
ITERATOR_COMPLETION = true
) {}
} catch (err) {
ITERATOR_HAD_ERROR_KEY = true;
ITERATOR_ERROR_KEY = err;
} finally {
try {
if (!ITERATOR_COMPLETION && ITERATOR_KEY.return != null) {
ITERATOR_KEY.return();
}
} finally {
if (ITERATOR_HAD_ERROR_KEY) {
throw ITERATOR_ERROR_KEY;
}
}
}
`);
function _ForOfStatementArray(path) {
const {
node,
scope
} = path;
const right = scope.generateUidIdentifierBasedOnNode(node.right, "arr");
const iterationKey = scope.generateUidIdentifier("i");
let loop = buildForOfArray({
BODY: node.body,
KEY: iterationKey,
NAME: right,
ARR: node.right
});
_core().types.inherits(loop, node);
_core().types.ensureBlock(loop);
const iterationValue = _core().types.memberExpression(_core().types.cloneNode(right), _core().types.cloneNode(iterationKey), true);
const left = node.left;
if (_core().types.isVariableDeclaration(left)) {
left.declarations[0].init = iterationValue;
loop.body.body.unshift(left);
} else {
loop.body.body.unshift(_core().types.expressionStatement(_core().types.assignmentExpression("=", left, iterationValue)));
}
if (path.parentPath.isLabeledStatement()) {
loop = _core().types.labeledStatement(path.parentPath.node.label, loop);
}
return [loop];
}
function replaceWithArray(path) {
if (path.parentPath.isLabeledStatement()) {
path.parentPath.replaceWithMultiple(_ForOfStatementArray(path));
} else {
path.replaceWithMultiple(_ForOfStatementArray(path));
}
}
return {
name: "transform-for-of",
visitor: {
ForOfStatement(path, state) {
const right = path.get("right");
if (right.isArrayExpression() || right.isGenericType("Array") || _core().types.isArrayTypeAnnotation(right.getTypeAnnotation())) {
replaceWithArray(path);
return;
}
const {
node
} = path;
const build = pushComputedProps(path, state);
const declar = build.declar;
const loop = build.loop;
const block = loop.body;
path.ensureBlock();
if (declar) {
block.body.push(declar);
}
block.body = block.body.concat(node.body.body);
_core().types.inherits(loop, node);
_core().types.inherits(loop.body, node.body);
if (build.replaceParent) {
path.parentPath.replaceWithMultiple(build.node);
path.remove();
} else {
path.replaceWithMultiple(build.node);
}
}
}
};
function pushComputedPropsLoose(path, file) {
const {
node,
scope,
parent
} = path;
const {
left
} = node;
let declar, id, intermediate;
if (_core().types.isIdentifier(left) || _core().types.isPattern(left) || _core().types.isMemberExpression(left)) {
id = left;
intermediate = null;
} else if (_core().types.isVariableDeclaration(left)) {
id = scope.generateUidIdentifier("ref");
declar = _core().types.variableDeclaration(left.kind, [_core().types.variableDeclarator(left.declarations[0].id, _core().types.identifier(id.name))]);
intermediate = _core().types.variableDeclaration("var", [_core().types.variableDeclarator(_core().types.identifier(id.name))]);
} else {
throw file.buildCodeFrameError(left, `Unknown node type ${left.type} in ForStatement`);
}
const iteratorKey = scope.generateUidIdentifier("iterator");
const isArrayKey = scope.generateUidIdentifier("isArray");
const loop = buildForOfLoose({
LOOP_OBJECT: iteratorKey,
IS_ARRAY: isArrayKey,
OBJECT: node.right,
INDEX: scope.generateUidIdentifier("i"),
ID: id,
INTERMEDIATE: intermediate
});
const isLabeledParent = _core().types.isLabeledStatement(parent);
let labeled;
if (isLabeledParent) {
labeled = _core().types.labeledStatement(parent.label, loop);
}
return {
replaceParent: isLabeledParent,
declar: declar,
node: labeled || loop,
loop: loop
};
}
function pushComputedPropsSpec(path, file) {
const {
node,
scope,
parent
} = path;
const left = node.left;
let declar;
const stepKey = scope.generateUid("step");
const stepValue = _core().types.memberExpression(_core().types.identifier(stepKey), _core().types.identifier("value"));
if (_core().types.isIdentifier(left) || _core().types.isPattern(left) || _core().types.isMemberExpression(left)) {
declar = _core().types.expressionStatement(_core().types.assignmentExpression("=", left, stepValue));
} else if (_core().types.isVariableDeclaration(left)) {
declar = _core().types.variableDeclaration(left.kind, [_core().types.variableDeclarator(left.declarations[0].id, stepValue)]);
} else {
throw file.buildCodeFrameError(left, `Unknown node type ${left.type} in ForStatement`);
}
const template = buildForOf({
ITERATOR_HAD_ERROR_KEY: scope.generateUidIdentifier("didIteratorError"),
ITERATOR_COMPLETION: scope.generateUidIdentifier("iteratorNormalCompletion"),
ITERATOR_ERROR_KEY: scope.generateUidIdentifier("iteratorError"),
ITERATOR_KEY: scope.generateUidIdentifier("iterator"),
STEP_KEY: _core().types.identifier(stepKey),
OBJECT: node.right
});
const isLabeledParent = _core().types.isLabeledStatement(parent);
const tryBody = template[3].block.body;
const loop = tryBody[0];
if (isLabeledParent) {
tryBody[0] = _core().types.labeledStatement(parent.label, loop);
}
return {
replaceParent: isLabeledParent,
declar: declar,
loop: loop,
node: template
};
}
});
exports.default = _default;