Skip to content
GitLab
Commit 2101a218 authored by Alfakhori's avatar Alfakhori
Browse files

Merge branch 'Rosenstein' into 'master' 

update some ui

See merge request !1
parents bf137ad8 91e89eab
Hide whitespace changes
Inline Side-by-side
node_modules/@babel/plugin-transform-block-scoping/package.json deleted 100644 → 0
View file @ bf137ad8
{
"_from": "@babel/plugin-transform-block-scoping@^7.3.4",
"_id": "@babel/plugin-transform-block-scoping@7.6.3",
"_inBundle": false,
"_integrity": "sha512-7hvrg75dubcO3ZI2rjYTzUrEuh1E9IyDEhhB6qfcooxhDA33xx2MasuLVgdxzcP6R/lipAC6n9ub9maNW6RKdw==",
"_location": "/@babel/plugin-transform-block-scoping",
"_phantomChildren": {},
"_requested": {
"type": "range",
"registry": true,
"raw": "@babel/plugin-transform-block-scoping@^7.3.4",
"name": "@babel/plugin-transform-block-scoping",
"escapedName": "@babel%2fplugin-transform-block-scoping",
"scope": "@babel",
"rawSpec": "^7.3.4",
"saveSpec": null,
"fetchSpec": "^7.3.4"
},
"_requiredBy": [
"/@babel/preset-env"
],
"_resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.6.3.tgz",
"_shasum": "6e854e51fbbaa84351b15d4ddafe342f3a5d542a",
"_spec": "@babel/plugin-transform-block-scoping@^7.3.4",
"_where": "C:\\Work\\OneDrive - bwstaff\\M4_Lab\\TV3\\NewVersion01\\LAFJLBmf939XYm5gj\\dev\\node_modules\\@babel\\preset-env",
"bundleDependencies": false,
"dependencies": {
"@babel/helper-plugin-utils": "^7.0.0",
"lodash": "^4.17.13"
},
"deprecated": false,
"description": "Compile ES2015 block scoping (const and let) to ES5",
"devDependencies": {
"@babel/core": "^7.6.3",
"@babel/helper-plugin-test-runner": "^7.0.0"
},
"gitHead": "d329156ebc17da01382acb83e212cb4328534ebc",
"keywords": [
"babel-plugin"
],
"license": "MIT",
"main": "lib/index.js",
"name": "@babel/plugin-transform-block-scoping",
"peerDependencies": {
"@babel/core": "^7.0.0-0"
},
"publishConfig": {
"access": "public"
},
"repository": {
"type": "git",
"url": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-block-scoping"
},
"version": "7.6.3"
}
node_modules/@babel/plugin-transform-classes/LICENSE deleted 100644 → 0
View file @ bf137ad8
MIT License
Copyright (c) 2014-present Sebastian McKenzie and other contributors
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
node_modules/@babel/plugin-transform-classes/README.md deleted 100644 → 0
View file @ bf137ad8
# @babel/plugin-transform-classes
> Compile ES2015 classes to ES5
See our website [@babel/plugin-transform-classes](https://babeljs.io/docs/en/next/babel-plugin-transform-classes.html) for more information.
## Install
Using npm:
```sh
npm install --save-dev @babel/plugin-transform-classes
```
or using yarn:
```sh
yarn add @babel/plugin-transform-classes --dev
```
node_modules/@babel/plugin-transform-classes/lib/index.js deleted 100644 → 0
View file @ bf137ad8
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _helperPluginUtils = require("@babel/helper-plugin-utils");
var _helperAnnotateAsPure = _interopRequireDefault(require("@babel/helper-annotate-as-pure"));
var _helperFunctionName = _interopRequireDefault(require("@babel/helper-function-name"));
var _helperSplitExportDeclaration = _interopRequireDefault(require("@babel/helper-split-export-declaration"));
var _core = require("@babel/core");
var _globals = _interopRequireDefault(require("globals"));
var _transformClass = _interopRequireDefault(require("./transformClass"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
const getBuiltinClasses = category => Object.keys(_globals.default[category]).filter(name => /^[A-Z]/.test(name));
const builtinClasses = new Set([...getBuiltinClasses("builtin"), ...getBuiltinClasses("browser")]);
var _default = (0, _helperPluginUtils.declare)((api, options) => {
api.assertVersion(7);
const {
loose
} = options;
const VISITED = Symbol();
return {
name: "transform-classes",
visitor: {
ExportDefaultDeclaration(path) {
if (!path.get("declaration").isClassDeclaration()) return;
(0, _helperSplitExportDeclaration.default)(path);
},
ClassDeclaration(path) {
const {
node
} = path;
const ref = node.id || path.scope.generateUidIdentifier("class");
path.replaceWith(_core.types.variableDeclaration("let", [_core.types.variableDeclarator(ref, _core.types.toExpression(node))]));
},
ClassExpression(path, state) {
const {
node
} = path;
if (node[VISITED]) return;
const inferred = (0, _helperFunctionName.default)(path);
if (inferred && inferred !== node) {
path.replaceWith(inferred);
return;
}
node[VISITED] = true;
path.replaceWith((0, _transformClass.default)(path, state.file, builtinClasses, loose));
if (path.isCallExpression()) {
(0, _helperAnnotateAsPure.default)(path);
if (path.get("callee").isArrowFunctionExpression()) {
path.get("callee").arrowFunctionToExpression();
}
}
}
}
};
});
exports.default = _default;
\ No newline at end of file
node_modules/@babel/plugin-transform-classes/lib/transformClass.js deleted 100644 → 0
View file @ bf137ad8
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = transformClass;
var _helperFunctionName = _interopRequireDefault(require("@babel/helper-function-name"));
var _helperReplaceSupers = _interopRequireWildcard(require("@babel/helper-replace-supers"));
var _helperOptimiseCallExpression = _interopRequireDefault(require("@babel/helper-optimise-call-expression"));
var defineMap = _interopRequireWildcard(require("@babel/helper-define-map"));
var _core = require("@babel/core");
function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; if (obj != null) { var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function buildConstructor(classRef, constructorBody, node) {
const func = _core.types.functionDeclaration(_core.types.cloneNode(classRef), [], constructorBody);
_core.types.inherits(func, node);
return func;
}
function transformClass(path, file, builtinClasses, isLoose) {
const classState = {
parent: undefined,
scope: undefined,
node: undefined,
path: undefined,
file: undefined,
classId: undefined,
classRef: undefined,
superName: undefined,
superReturns: [],
isDerived: false,
extendsNative: false,
construct: undefined,
constructorBody: undefined,
userConstructor: undefined,
userConstructorPath: undefined,
hasConstructor: false,
instancePropBody: [],
instancePropRefs: {},
staticPropBody: [],
body: [],
superThises: [],
pushedConstructor: false,
pushedInherits: false,
protoAlias: null,
isLoose: false,
hasInstanceDescriptors: false,
hasStaticDescriptors: false,
instanceMutatorMap: {},
staticMutatorMap: {}
};
const setState = newState => {
Object.assign(classState, newState);
};
const findThisesVisitor = _core.traverse.visitors.merge([_helperReplaceSupers.environmentVisitor, {
ThisExpression(path) {
classState.superThises.push(path);
}
}]);
function pushToMap(node, enumerable, kind = "value", scope) {
let mutatorMap;
if (node.static) {
setState({
hasStaticDescriptors: true
});
mutatorMap = classState.staticMutatorMap;
} else {
setState({
hasInstanceDescriptors: true
});
mutatorMap = classState.instanceMutatorMap;
}
const map = defineMap.push(mutatorMap, node, kind, classState.file, scope);
if (enumerable) {
map.enumerable = _core.types.booleanLiteral(true);
}
return map;
}
function maybeCreateConstructor() {
let hasConstructor = false;
const paths = classState.path.get("body.body");
for (const path of paths) {
hasConstructor = path.equals("kind", "constructor");
if (hasConstructor) break;
}
if (hasConstructor) return;
let params, body;
if (classState.isDerived) {
const constructor = _core.template.expression.ast`
(function () {
super(...arguments);
})
`;
params = constructor.params;
body = constructor.body;
} else {
params = [];
body = _core.types.blockStatement([]);
}
classState.path.get("body").unshiftContainer("body", _core.types.classMethod("constructor", _core.types.identifier("constructor"), params, body));
}
function buildBody() {
maybeCreateConstructor();
pushBody();
verifyConstructor();
if (classState.userConstructor) {
const {
constructorBody,
userConstructor,
construct
} = classState;
constructorBody.body = constructorBody.body.concat(userConstructor.body.body);
_core.types.inherits(construct, userConstructor);
_core.types.inherits(constructorBody, userConstructor.body);
}
pushDescriptors();
}
function pushBody() {
const classBodyPaths = classState.path.get("body.body");
for (const path of classBodyPaths) {
const node = path.node;
if (path.isClassProperty()) {
throw path.buildCodeFrameError("Missing class properties transform.");
}
if (node.decorators) {
throw path.buildCodeFrameError("Method has decorators, put the decorator plugin before the classes one.");
}
if (_core.types.isClassMethod(node)) {
const isConstructor = node.kind === "constructor";
const replaceSupers = new _helperReplaceSupers.default({
methodPath: path,
objectRef: classState.classRef,
superRef: classState.superName,
isLoose: classState.isLoose,
file: classState.file
});
replaceSupers.replace();
const superReturns = [];
path.traverse(_core.traverse.visitors.merge([_helperReplaceSupers.environmentVisitor, {
ReturnStatement(path) {
if (!path.getFunctionParent().isArrowFunctionExpression()) {
superReturns.push(path);
}
}
}]));
if (isConstructor) {
pushConstructor(superReturns, node, path);
} else {
pushMethod(node, path);
}
}
}
}
function clearDescriptors() {
setState({
hasInstanceDescriptors: false,
hasStaticDescriptors: false,
instanceMutatorMap: {},
staticMutatorMap: {}
});
}
function pushDescriptors() {
pushInheritsToBody();
const {
body
} = classState;
let instanceProps;
let staticProps;
if (classState.hasInstanceDescriptors) {
instanceProps = defineMap.toClassObject(classState.instanceMutatorMap);
}
if (classState.hasStaticDescriptors) {
staticProps = defineMap.toClassObject(classState.staticMutatorMap);
}
if (instanceProps || staticProps) {
if (instanceProps) {
instanceProps = defineMap.toComputedObjectFromClass(instanceProps);
}
if (staticProps) {
staticProps = defineMap.toComputedObjectFromClass(staticProps);
}
let args = [_core.types.cloneNode(classState.classRef), _core.types.nullLiteral(), _core.types.nullLiteral()];
if (instanceProps) args[1] = instanceProps;
if (staticProps) args[2] = staticProps;
let lastNonNullIndex = 0;
for (let i = 0; i < args.length; i++) {
if (!_core.types.isNullLiteral(args[i])) lastNonNullIndex = i;
}
args = args.slice(0, lastNonNullIndex + 1);
body.push(_core.types.expressionStatement(_core.types.callExpression(classState.file.addHelper("createClass"), args)));
}
clearDescriptors();
}
function wrapSuperCall(bareSuper, superRef, thisRef, body) {
let bareSuperNode = bareSuper.node;
let call;
if (classState.isLoose) {
bareSuperNode.arguments.unshift(_core.types.thisExpression());
if (bareSuperNode.arguments.length === 2 && _core.types.isSpreadElement(bareSuperNode.arguments[1]) && _core.types.isIdentifier(bareSuperNode.arguments[1].argument, {
name: "arguments"
})) {
bareSuperNode.arguments[1] = bareSuperNode.arguments[1].argument;
bareSuperNode.callee = _core.types.memberExpression(_core.types.cloneNode(superRef), _core.types.identifier("apply"));
} else {
bareSuperNode.callee = _core.types.memberExpression(_core.types.cloneNode(superRef), _core.types.identifier("call"));
}
call = _core.types.logicalExpression("||", bareSuperNode, _core.types.thisExpression());
} else {
bareSuperNode = (0, _helperOptimiseCallExpression.default)(_core.types.callExpression(classState.file.addHelper("getPrototypeOf"), [_core.types.cloneNode(classState.classRef)]), _core.types.thisExpression(), bareSuperNode.arguments);
call = _core.types.callExpression(classState.file.addHelper("possibleConstructorReturn"), [_core.types.thisExpression(), bareSuperNode]);
}
if (bareSuper.parentPath.isExpressionStatement() && bareSuper.parentPath.container === body.node.body && body.node.body.length - 1 === bareSuper.parentPath.key) {
if (classState.superThises.length) {
call = _core.types.assignmentExpression("=", thisRef(), call);
}
bareSuper.parentPath.replaceWith(_core.types.returnStatement(call));
} else {
bareSuper.replaceWith(_core.types.assignmentExpression("=", thisRef(), call));
}
}
function verifyConstructor() {
if (!classState.isDerived) return;
const path = classState.userConstructorPath;
const body = path.get("body");
path.traverse(findThisesVisitor);
let thisRef = function () {
const ref = path.scope.generateDeclaredUidIdentifier("this");
thisRef = () => _core.types.cloneNode(ref);
return ref;
};
for (const thisPath of classState.superThises) {
const {
node,
parentPath
} = thisPath;
if (parentPath.isMemberExpression({
object: node
})) {
thisPath.replaceWith(thisRef());
continue;
}
thisPath.replaceWith(_core.types.callExpression(classState.file.addHelper("assertThisInitialized"), [thisRef()]));
}
const bareSupers = new Set();
path.traverse(_core.traverse.visitors.merge([_helperReplaceSupers.environmentVisitor, {
Super(path) {
const {
node,
parentPath
} = path;
if (parentPath.isCallExpression({
callee: node
})) {
bareSupers.add(parentPath);
}
}
}]));
let guaranteedSuperBeforeFinish = !!bareSupers.size;
for (const bareSuper of bareSupers) {
wrapSuperCall(bareSuper, classState.superName, thisRef, body);
if (guaranteedSuperBeforeFinish) {
bareSuper.find(function (parentPath) {
if (parentPath === path) {
return true;
}
if (parentPath.isLoop() || parentPath.isConditional() || parentPath.isArrowFunctionExpression()) {
guaranteedSuperBeforeFinish = false;
return true;
}
});
}
}
let wrapReturn;
if (classState.isLoose) {
wrapReturn = returnArg => {
const thisExpr = _core.types.callExpression(classState.file.addHelper("assertThisInitialized"), [thisRef()]);
return returnArg ? _core.types.logicalExpression("||", returnArg, thisExpr) : thisExpr;
};
} else {
wrapReturn = returnArg => _core.types.callExpression(classState.file.addHelper("possibleConstructorReturn"), [thisRef()].concat(returnArg || []));
}
const bodyPaths = body.get("body");
if (!bodyPaths.length || !bodyPaths.pop().isReturnStatement()) {
body.pushContainer("body", _core.types.returnStatement(guaranteedSuperBeforeFinish ? thisRef() : wrapReturn()));
}
for (const returnPath of classState.superReturns) {
returnPath.get("argument").replaceWith(wrapReturn(returnPath.node.argument));
}
}
function pushMethod(node, path) {
const scope = path ? path.scope : classState.scope;
if (node.kind === "method") {
if (processMethod(node, scope)) return;
}
pushToMap(node, false, null, scope);
}
function processMethod(node, scope) {
if (classState.isLoose && !node.decorators) {
let {
classRef
} = classState;
if (!node.static) {
insertProtoAliasOnce();
classRef = classState.protoAlias;
}
const methodName = _core.types.memberExpression(_core.types.cloneNode(classRef), node.key, node.computed || _core.types.isLiteral(node.key));
let func = _core.types.functionExpression(null, node.params, node.body, node.generator, node.async);
_core.types.inherits(func, node);
const key = _core.types.toComputedKey(node, node.key);
if (_core.types.isStringLiteral(key)) {
func = (0, _helperFunctionName.default)({
node: func,
id: key,
scope
});
}
const expr = _core.types.expressionStatement(_core.types.assignmentExpression("=", methodName, func));
_core.types.inheritsComments(expr, node);
classState.body.push(expr);
return true;
}
return false;
}
function insertProtoAliasOnce() {
if (classState.protoAlias === null) {
setState({
protoAlias: classState.scope.generateUidIdentifier("proto")
});
const classProto = _core.types.memberExpression(classState.classRef, _core.types.identifier("prototype"));
const protoDeclaration = _core.types.variableDeclaration("var", [_core.types.variableDeclarator(classState.protoAlias, classProto)]);
classState.body.push(protoDeclaration);
}
}
function pushConstructor(superReturns, method, path) {
if (path.scope.hasOwnBinding(classState.classRef.name)) {
path.scope.rename(classState.classRef.name);
}
setState({
userConstructorPath: path,
userConstructor: method,
hasConstructor: true,
superReturns
});
const {
construct
} = classState;
_core.types.inheritsComments(construct, method);
construct.params = method.params;
_core.types.inherits(construct.body, method.body);
construct.body.directives = method.body.directives;
pushConstructorToBody();
}
function pushConstructorToBody() {
if (classState.pushedConstructor) return;
classState.pushedConstructor = true;
if (classState.hasInstanceDescriptors || classState.hasStaticDescriptors) {
pushDescriptors();
}
classState.body.push(classState.construct);
pushInheritsToBody();
}
function pushInheritsToBody() {
if (!classState.isDerived || classState.pushedInherits) return;
setState({
pushedInherits: true
});
classState.body.unshift(_core.types.expressionStatement(_core.types.callExpression(classState.file.addHelper(classState.isLoose ? "inheritsLoose" : "inherits"), [_core.types.cloneNode(classState.classRef), _core.types.cloneNode(classState.superName)])));
}
function setupClosureParamsArgs() {
const {
superName
} = classState;
const closureParams = [];
const closureArgs = [];
if (classState.isDerived) {
const arg = classState.extendsNative ? _core.types.callExpression(classState.file.addHelper("wrapNativeSuper"), [_core.types.cloneNode(superName)]) : _core.types.cloneNode(superName);
const param = classState.scope.generateUidIdentifierBasedOnNode(superName);
closureParams.push(param);
closureArgs.push(arg);
setState({
superName: _core.types.cloneNode(param)
});
}
return {
closureParams,
closureArgs
};
}
function classTransformer(path, file, builtinClasses, isLoose) {
setState({
parent: path.parent,
scope: path.scope,
node: path.node,
path,
file,
isLoose
});
setState({
classId: classState.node.id,
classRef: classState.node.id ? _core.types.identifier(classState.node.id.name) : classState.scope.generateUidIdentifier("class"),
superName: classState.node.superClass,
isDerived: !!classState.node.superClass,
constructorBody: _core.types.blockStatement([])
});
setState({
extendsNative: classState.isDerived && builtinClasses.has(classState.superName.name) && !classState.scope.hasBinding(classState.superName.name, true)
});
const {
classRef,
node,
constructorBody
} = classState;
setState({
construct: buildConstructor(classRef, constructorBody, node)
});
let {
body
} = classState;
const {
closureParams,
closureArgs
} = setupClosureParamsArgs();
buildBody();
if (!classState.isLoose) {
constructorBody.body.unshift(_core.types.expressionStatement(_core.types.callExpression(classState.file.addHelper("classCallCheck"), [_core.types.thisExpression(), _core.types.cloneNode(classState.classRef)])));
}
body = body.concat(classState.staticPropBody.map(fn => fn(_core.types.cloneNode(classState.classRef))));
const isStrict = path.isInStrictMode();
let constructorOnly = classState.classId && body.length === 1;
if (constructorOnly && !isStrict) {
for (const param of classState.construct.params) {
if (!_core.types.isIdentifier(param)) {
constructorOnly = false;
break;
}
}
}
const directives = constructorOnly ? body[0].body.directives : [];
if (!isStrict) {
directives.push(_core.types.directive(_core.types.directiveLiteral("use strict")));
}
if (constructorOnly) {
return _core.types.toExpression(body[0]);
}
body.push(_core.types.returnStatement(_core.types.cloneNode(classState.classRef)));
const container = _core.types.arrowFunctionExpression(closureParams, _core.types.blockStatement(body, directives));
return _core.types.callExpression(container, closureArgs);
}
return classTransformer(path, file, builtinClasses, isLoose);
}
\ No newline at end of file
node_modules/@babel/plugin-transform-classes/package.json deleted 100644 → 0
View file @ bf137ad8
{
"_from": "@babel/plugin-transform-classes@^7.3.4",
"_id": "@babel/plugin-transform-classes@7.7.0",
"_inBundle": false,
"_integrity": "sha512-/b3cKIZwGeUesZheU9jNYcwrEA7f/Bo4IdPmvp7oHgvks2majB5BoT5byAql44fiNQYOPzhk2w8DbgfuafkMoA==",
"_location": "/@babel/plugin-transform-classes",
"_phantomChildren": {},
"_requested": {
"type": "range",
"registry": true,
"raw": "@babel/plugin-transform-classes@^7.3.4",
"name": "@babel/plugin-transform-classes",
"escapedName": "@babel%2fplugin-transform-classes",
"scope": "@babel",
"rawSpec": "^7.3.4",
"saveSpec": null,
"fetchSpec": "^7.3.4"
},
"_requiredBy": [
"/@babel/preset-env"
],
"_resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.7.0.tgz",
"_shasum": "b411ecc1b8822d24b81e5d184f24149136eddd4a",
"_spec": "@babel/plugin-transform-classes@^7.3.4",
"_where": "C:\\Work\\OneDrive - bwstaff\\M4_Lab\\TV3\\NewVersion01\\LAFJLBmf939XYm5gj\\dev\\node_modules\\@babel\\preset-env",
"bundleDependencies": false,
"dependencies": {
"@babel/helper-annotate-as-pure": "^7.7.0",
"@babel/helper-define-map": "^7.7.0",
"@babel/helper-function-name": "^7.7.0",
"@babel/helper-optimise-call-expression": "^7.7.0",
"@babel/helper-plugin-utils": "^7.0.0",
"@babel/helper-replace-supers": "^7.7.0",
"@babel/helper-split-export-declaration": "^7.7.0",
"globals": "^11.1.0"
},
"deprecated": false,
"description": "Compile ES2015 classes to ES5",
"devDependencies": {
"@babel/core": "^7.7.0",
"@babel/helper-plugin-test-runner": "^7.0.0"
},
"gitHead": "97faa83953cb87e332554fa559a4956d202343ea",
"keywords": [
"babel-plugin"
],
"license": "MIT",
"main": "lib/index.js",
"name": "@babel/plugin-transform-classes",
"peerDependencies": {
"@babel/core": "^7.0.0-0"
},
"publishConfig": {
"access": "public"
},
"repository": {
"type": "git",
"url": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-classes"
},
"version": "7.7.0"
}
node_modules/@babel/plugin-transform-computed-properties/LICENSE deleted 100644 → 0
View file @ bf137ad8
MIT License
Copyright (c) 2014-2018 Sebastian McKenzie and other contributors
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
node_modules/@babel/plugin-transform-computed-properties/README.md deleted 100644 → 0
View file @ bf137ad8
# @babel/plugin-transform-computed-properties
> Compile ES2015 computed properties to ES5
See our website [@babel/plugin-transform-computed-properties](https://babeljs.io/docs/en/next/babel-plugin-transform-computed-properties.html) for more information.
## Install
Using npm:
```sh
npm install --save-dev @babel/plugin-transform-computed-properties
```
or using yarn:
```sh
yarn add @babel/plugin-transform-computed-properties --dev
```
node_modules/@babel/plugin-transform-computed-properties/lib/index.js deleted 100644 → 0
View file @ bf137ad8
"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
} = options;
const pushComputedProps = loose ? pushComputedPropsLoose : pushComputedPropsSpec;
const buildMutatorMapAssign = (0, _core().template)(`
MUTATOR_MAP_REF[KEY] = MUTATOR_MAP_REF[KEY] || {};
MUTATOR_MAP_REF[KEY].KIND = VALUE;
`);
function getValue(prop) {
if (_core().types.isObjectProperty(prop)) {
return prop.value;
} else if (_core().types.isObjectMethod(prop)) {
return _core().types.functionExpression(null, prop.params, prop.body, prop.generator, prop.async);
}
}
function pushAssign(objId, prop, body) {
if (prop.kind === "get" && prop.kind === "set") {
pushMutatorDefine(objId, prop, body);
} else {
body.push(_core().types.expressionStatement(_core().types.assignmentExpression("=", _core().types.memberExpression(_core().types.cloneNode(objId), prop.key, prop.computed || _core().types.isLiteral(prop.key)), getValue(prop))));
}
}
function pushMutatorDefine({
body,
getMutatorId,
scope
}, prop) {
let key = !prop.computed && _core().types.isIdentifier(prop.key) ? _core().types.stringLiteral(prop.key.name) : prop.key;
const maybeMemoise = scope.maybeGenerateMemoised(key);
if (maybeMemoise) {
body.push(_core().types.expressionStatement(_core().types.assignmentExpression("=", maybeMemoise, key)));
key = maybeMemoise;
}
body.push(...buildMutatorMapAssign({
MUTATOR_MAP_REF: getMutatorId(),
KEY: _core().types.cloneNode(key),
VALUE: getValue(prop),
KIND: _core().types.identifier(prop.kind)
}));
}
function pushComputedPropsLoose(info) {
for (const prop of info.computedProps) {
if (prop.kind === "get" || prop.kind === "set") {
pushMutatorDefine(info, prop);
} else {
pushAssign(_core().types.cloneNode(info.objId), prop, info.body);
}
}
}
function pushComputedPropsSpec(info) {
const {
objId,
body,
computedProps,
state
} = info;
for (const prop of computedProps) {
const key = _core().types.toComputedKey(prop);
if (prop.kind === "get" || prop.kind === "set") {
pushMutatorDefine(info, prop);
} else if (_core().types.isStringLiteral(key, {
value: "__proto__"
})) {
pushAssign(objId, prop, body);
} else {
if (computedProps.length === 1) {
return _core().types.callExpression(state.addHelper("defineProperty"), [info.initPropExpression, key, getValue(prop)]);
} else {
body.push(_core().types.expressionStatement(_core().types.callExpression(state.addHelper("defineProperty"), [_core().types.cloneNode(objId), key, getValue(prop)])));
}
}
}
}
return {
name: "transform-computed-properties",
visitor: {
ObjectExpression: {
exit(path, state) {
const {
node,
parent,
scope
} = path;
let hasComputed = false;
for (const prop of node.properties) {
hasComputed = prop.computed === true;
if (hasComputed) break;
}
if (!hasComputed) return;
const initProps = [];
const computedProps = [];
let foundComputed = false;
for (const prop of node.properties) {
if (prop.computed) {
foundComputed = true;
}
if (foundComputed) {
computedProps.push(prop);
} else {
initProps.push(prop);
}
}
const objId = scope.generateUidIdentifierBasedOnNode(parent);
const initPropExpression = _core().types.objectExpression(initProps);
const body = [];
body.push(_core().types.variableDeclaration("var", [_core().types.variableDeclarator(objId, initPropExpression)]));
let mutatorRef;
const getMutatorId = function () {
if (!mutatorRef) {
mutatorRef = scope.generateUidIdentifier("mutatorMap");
body.push(_core().types.variableDeclaration("var", [_core().types.variableDeclarator(mutatorRef, _core().types.objectExpression([]))]));
}
return _core().types.cloneNode(mutatorRef);
};
const single = pushComputedProps({
scope,
objId,
body,
computedProps,
initPropExpression,
getMutatorId,
state
});
if (mutatorRef) {
body.push(_core().types.expressionStatement(_core().types.callExpression(state.addHelper("defineEnumerableProperties"), [_core().types.cloneNode(objId), _core().types.cloneNode(mutatorRef)])));
}
if (single) {
path.replaceWith(single);
} else {
body.push(_core().types.expressionStatement(_core().types.cloneNode(objId)));
path.replaceWithMultiple(body);
}
}
}
}
};
});
exports.default = _default;
\ No newline at end of file
node_modules/@babel/plugin-transform-computed-properties/package.json deleted 100644 → 0
View file @ bf137ad8
{
"_from": "@babel/plugin-transform-computed-properties@^7.2.0",
"_id": "@babel/plugin-transform-computed-properties@7.2.0",
"_inBundle": false,
"_integrity": "sha512-kP/drqTxY6Xt3NNpKiMomfgkNn4o7+vKxK2DDKcBG9sHj51vHqMBGy8wbDS/J4lMxnqs153/T3+DmCEAkC5cpA==",
"_location": "/@babel/plugin-transform-computed-properties",
"_phantomChildren": {},
"_requested": {
"type": "range",
"registry": true,
"raw": "@babel/plugin-transform-computed-properties@^7.2.0",
"name": "@babel/plugin-transform-computed-properties",
"escapedName": "@babel%2fplugin-transform-computed-properties",
"scope": "@babel",
"rawSpec": "^7.2.0",
"saveSpec": null,
"fetchSpec": "^7.2.0"
},
"_requiredBy": [
"/@babel/preset-env"
],
"_resolved": "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.2.0.tgz",
"_shasum": "83a7df6a658865b1c8f641d510c6f3af220216da",
"_spec": "@babel/plugin-transform-computed-properties@^7.2.0",
"_where": "C:\\Work\\OneDrive - bwstaff\\M4_Lab\\TV3\\NewVersion01\\LAFJLBmf939XYm5gj\\dev\\node_modules\\@babel\\preset-env",
"bundleDependencies": false,
"dependencies": {
"@babel/helper-plugin-utils": "^7.0.0"
},
"deprecated": false,
"description": "Compile ES2015 computed properties to ES5",
"devDependencies": {
"@babel/core": "^7.2.0",
"@babel/helper-plugin-test-runner": "^7.0.0"
},
"keywords": [
"babel-plugin"
],
"license": "MIT",
"main": "lib/index.js",
"name": "@babel/plugin-transform-computed-properties",
"peerDependencies": {
"@babel/core": "^7.0.0-0"
},
"publishConfig": {
"access": "public"
},
"repository": {
"type": "git",
"url": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-computed-properties"
},
"version": "7.2.0"
}
node_modules/@babel/plugin-transform-destructuring/LICENSE deleted 100644 → 0
View file @ bf137ad8
MIT License
Copyright (c) 2014-present Sebastian McKenzie and other contributors
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
node_modules/@babel/plugin-transform-destructuring/README.md deleted 100644 → 0
View file @ bf137ad8
# @babel/plugin-transform-destructuring
> Compile ES2015 destructuring to ES5
See our website [@babel/plugin-transform-destructuring](https://babeljs.io/docs/en/next/babel-plugin-transform-destructuring.html) for more information.
## Install
Using npm:
```sh
npm install --save-dev @babel/plugin-transform-destructuring
```
or using yarn:
```sh
yarn add @babel/plugin-transform-destructuring --dev
```
node_modules/@babel/plugin-transform-destructuring/lib/index.js deleted 100644 → 0
View file @ bf137ad8
"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 = false,
useBuiltIns = false
} = options;
if (typeof loose !== "boolean") {
throw new Error(`.loose must be a boolean or undefined`);
}
const arrayOnlySpread = loose;
function getExtendsHelper(file) {
return useBuiltIns ? _core().types.memberExpression(_core().types.identifier("Object"), _core().types.identifier("assign")) : file.addHelper("extends");
}
function variableDeclarationHasPattern(node) {
for (const declar of node.declarations) {
if (_core().types.isPattern(declar.id)) {
return true;
}
}
return false;
}
function hasRest(pattern) {
for (const elem of pattern.elements) {
if (_core().types.isRestElement(elem)) {
return true;
}
}
return false;
}
function hasObjectRest(pattern) {
for (const elem of pattern.properties) {
if (_core().types.isRestElement(elem)) {
return true;
}
}
return false;
}
const STOP_TRAVERSAL = {};
const arrayUnpackVisitor = (node, ancestors, state) => {
if (!ancestors.length) {
return;
}
if (_core().types.isIdentifier(node) && _core().types.isReferenced(node, ancestors[ancestors.length - 1]) && state.bindings[node.name]) {
state.deopt = true;
throw STOP_TRAVERSAL;
}
};
class DestructuringTransformer {
constructor(opts) {
this.blockHoist = opts.blockHoist;
this.operator = opts.operator;
this.arrays = {};
this.nodes = opts.nodes || [];
this.scope = opts.scope;
this.kind = opts.kind;
this.arrayOnlySpread = opts.arrayOnlySpread;
this.addHelper = opts.addHelper;
}
buildVariableAssignment(id, init) {
let op = this.operator;
if (_core().types.isMemberExpression(id)) op = "=";
let node;
if (op) {
node = _core().types.expressionStatement(_core().types.assignmentExpression(op, id, _core().types.cloneNode(init) || this.scope.buildUndefinedNode()));
} else {
node = _core().types.variableDeclaration(this.kind, [_core().types.variableDeclarator(id, _core().types.cloneNode(init))]);
}
node._blockHoist = this.blockHoist;
return node;
}
buildVariableDeclaration(id, init) {
const declar = _core().types.variableDeclaration("var", [_core().types.variableDeclarator(_core().types.cloneNode(id), _core().types.cloneNode(init))]);
declar._blockHoist = this.blockHoist;
return declar;
}
push(id, _init) {
const init = _core().types.cloneNode(_init);
if (_core().types.isObjectPattern(id)) {
this.pushObjectPattern(id, init);
} else if (_core().types.isArrayPattern(id)) {
this.pushArrayPattern(id, init);
} else if (_core().types.isAssignmentPattern(id)) {
this.pushAssignmentPattern(id, init);
} else {
this.nodes.push(this.buildVariableAssignment(id, init));
}
}
toArray(node, count) {
if (this.arrayOnlySpread || _core().types.isIdentifier(node) && this.arrays[node.name]) {
return node;
} else {
return this.scope.toArray(node, count);
}
}
pushAssignmentPattern({
left,
right
}, valueRef) {
const tempId = this.scope.generateUidIdentifierBasedOnNode(valueRef);
this.nodes.push(this.buildVariableDeclaration(tempId, valueRef));
const tempConditional = _core().types.conditionalExpression(_core().types.binaryExpression("===", _core().types.cloneNode(tempId), this.scope.buildUndefinedNode()), right, _core().types.cloneNode(tempId));
if (_core().types.isPattern(left)) {
let patternId;
let node;
if (this.kind === "const") {
patternId = this.scope.generateUidIdentifier(tempId.name);
node = this.buildVariableDeclaration(patternId, tempConditional);
} else {
patternId = tempId;
node = _core().types.expressionStatement(_core().types.assignmentExpression("=", _core().types.cloneNode(tempId), tempConditional));
}
this.nodes.push(node);
this.push(left, patternId);
} else {
this.nodes.push(this.buildVariableAssignment(left, tempConditional));
}
}
pushObjectRest(pattern, objRef, spreadProp, spreadPropIndex) {
const keys = [];
let allLiteral = true;
for (let i = 0; i < pattern.properties.length; i++) {
const prop = pattern.properties[i];
if (i >= spreadPropIndex) break;
if (_core().types.isRestElement(prop)) continue;
const key = prop.key;
if (_core().types.isIdentifier(key) && !prop.computed) {
keys.push(_core().types.stringLiteral(key.name));
} else if (_core().types.isTemplateLiteral(prop.key)) {
keys.push(_core().types.cloneNode(prop.key));
} else if (_core().types.isLiteral(key)) {
keys.push(_core().types.stringLiteral(String(key.value)));
} else {
keys.push(_core().types.cloneNode(key));
allLiteral = false;
}
}
let value;
if (keys.length === 0) {
value = _core().types.callExpression(getExtendsHelper(this), [_core().types.objectExpression([]), _core().types.cloneNode(objRef)]);
} else {
let keyExpression = _core().types.arrayExpression(keys);
if (!allLiteral) {
keyExpression = _core().types.callExpression(_core().types.memberExpression(keyExpression, _core().types.identifier("map")), [this.addHelper("toPropertyKey")]);
}
value = _core().types.callExpression(this.addHelper(`objectWithoutProperties${loose ? "Loose" : ""}`), [_core().types.cloneNode(objRef), keyExpression]);
}
this.nodes.push(this.buildVariableAssignment(spreadProp.argument, value));
}
pushObjectProperty(prop, propRef) {
if (_core().types.isLiteral(prop.key)) prop.computed = true;
const pattern = prop.value;
const objRef = _core().types.memberExpression(_core().types.cloneNode(propRef), prop.key, prop.computed);
if (_core().types.isPattern(pattern)) {
this.push(pattern, objRef);
} else {
this.nodes.push(this.buildVariableAssignment(pattern, objRef));
}
}
pushObjectPattern(pattern, objRef) {
if (!pattern.properties.length) {
this.nodes.push(_core().types.expressionStatement(_core().types.callExpression(this.addHelper("objectDestructuringEmpty"), [objRef])));
}
if (pattern.properties.length > 1 && !this.scope.isStatic(objRef)) {
const temp = this.scope.generateUidIdentifierBasedOnNode(objRef);
this.nodes.push(this.buildVariableDeclaration(temp, objRef));
objRef = temp;
}
if (hasObjectRest(pattern)) {
let copiedPattern;
for (let i = 0; i < pattern.properties.length; i++) {
const prop = pattern.properties[i];
if (_core().types.isRestElement(prop)) {
break;
}
const key = prop.key;
if (prop.computed && !this.scope.isPure(key)) {
const name = this.scope.generateUidIdentifierBasedOnNode(key);
this.nodes.push(this.buildVariableDeclaration(name, key));
if (!copiedPattern) {
copiedPattern = pattern = Object.assign({}, pattern, {
properties: pattern.properties.slice()
});
}
copiedPattern.properties[i] = Object.assign({}, copiedPattern.properties[i], {
key: name
});
}
}
}
for (let i = 0; i < pattern.properties.length; i++) {
const prop = pattern.properties[i];
if (_core().types.isRestElement(prop)) {
this.pushObjectRest(pattern, objRef, prop, i);
} else {
this.pushObjectProperty(prop, objRef);
}
}
}
canUnpackArrayPattern(pattern, arr) {
if (!_core().types.isArrayExpression(arr)) return false;
if (pattern.elements.length > arr.elements.length) return;
if (pattern.elements.length < arr.elements.length && !hasRest(pattern)) {
return false;
}
for (const elem of pattern.elements) {
if (!elem) return false;
if (_core().types.isMemberExpression(elem)) return false;
}
for (const elem of arr.elements) {
if (_core().types.isSpreadElement(elem)) return false;
if (_core().types.isCallExpression(elem)) return false;
if (_core().types.isMemberExpression(elem)) return false;
}
const bindings = _core().types.getBindingIdentifiers(pattern);
const state = {
deopt: false,
bindings
};
try {
_core().types.traverse(arr, arrayUnpackVisitor, state);
} catch (e) {
if (e !== STOP_TRAVERSAL) throw e;
}
return !state.deopt;
}
pushUnpackedArrayPattern(pattern, arr) {
for (let i = 0; i < pattern.elements.length; i++) {
const elem = pattern.elements[i];
if (_core().types.isRestElement(elem)) {
this.push(elem.argument, _core().types.arrayExpression(arr.elements.slice(i)));
} else {
this.push(elem, arr.elements[i]);
}
}
}
pushArrayPattern(pattern, arrayRef) {
if (!pattern.elements) return;
if (this.canUnpackArrayPattern(pattern, arrayRef)) {
return this.pushUnpackedArrayPattern(pattern, arrayRef);
}
const count = !hasRest(pattern) && pattern.elements.length;
const toArray = this.toArray(arrayRef, count);
if (_core().types.isIdentifier(toArray)) {
arrayRef = toArray;
} else {
arrayRef = this.scope.generateUidIdentifierBasedOnNode(arrayRef);
this.arrays[arrayRef.name] = true;
this.nodes.push(this.buildVariableDeclaration(arrayRef, toArray));
}
for (let i = 0; i < pattern.elements.length; i++) {
let elem = pattern.elements[i];
if (!elem) continue;
let elemRef;
if (_core().types.isRestElement(elem)) {
elemRef = this.toArray(arrayRef);
elemRef = _core().types.callExpression(_core().types.memberExpression(elemRef, _core().types.identifier("slice")), [_core().types.numericLiteral(i)]);
elem = elem.argument;
} else {
elemRef = _core().types.memberExpression(arrayRef, _core().types.numericLiteral(i), true);
}
this.push(elem, elemRef);
}
}
init(pattern, ref) {
if (!_core().types.isArrayExpression(ref) && !_core().types.isMemberExpression(ref)) {
const memo = this.scope.maybeGenerateMemoised(ref, true);
if (memo) {
this.nodes.push(this.buildVariableDeclaration(memo, _core().types.cloneNode(ref)));
ref = memo;
}
}
this.push(pattern, ref);
return this.nodes;
}
}
return {
name: "transform-destructuring",
visitor: {
ExportNamedDeclaration(path) {
const declaration = path.get("declaration");
if (!declaration.isVariableDeclaration()) return;
if (!variableDeclarationHasPattern(declaration.node)) return;
const specifiers = [];
for (const name of Object.keys(path.getOuterBindingIdentifiers(path))) {
specifiers.push(_core().types.exportSpecifier(_core().types.identifier(name), _core().types.identifier(name)));
}
path.replaceWith(declaration.node);
path.insertAfter(_core().types.exportNamedDeclaration(null, specifiers));
},
ForXStatement(path) {
const {
node,
scope
} = path;
const left = node.left;
if (_core().types.isPattern(left)) {
const temp = scope.generateUidIdentifier("ref");
node.left = _core().types.variableDeclaration("var", [_core().types.variableDeclarator(temp)]);
path.ensureBlock();
if (node.body.body.length === 0 && path.isCompletionRecord()) {
node.body.body.unshift(_core().types.expressionStatement(scope.buildUndefinedNode()));
}
node.body.body.unshift(_core().types.expressionStatement(_core().types.assignmentExpression("=", left, temp)));
return;
}
if (!_core().types.isVariableDeclaration(left)) return;
const pattern = left.declarations[0].id;
if (!_core().types.isPattern(pattern)) return;
const key = scope.generateUidIdentifier("ref");
node.left = _core().types.variableDeclaration(left.kind, [_core().types.variableDeclarator(key, null)]);
const nodes = [];
const destructuring = new DestructuringTransformer({
kind: left.kind,
scope: scope,
nodes: nodes,
arrayOnlySpread,
addHelper: name => this.addHelper(name)
});
destructuring.init(pattern, key);
path.ensureBlock();
const block = node.body;
block.body = nodes.concat(block.body);
},
CatchClause({
node,
scope
}) {
const pattern = node.param;
if (!_core().types.isPattern(pattern)) return;
const ref = scope.generateUidIdentifier("ref");
node.param = ref;
const nodes = [];
const destructuring = new DestructuringTransformer({
kind: "let",
scope: scope,
nodes: nodes,
arrayOnlySpread,
addHelper: name => this.addHelper(name)
});
destructuring.init(pattern, ref);
node.body.body = nodes.concat(node.body.body);
},
AssignmentExpression(path) {
const {
node,
scope
} = path;
if (!_core().types.isPattern(node.left)) return;
const nodes = [];
const destructuring = new DestructuringTransformer({
operator: node.operator,
scope: scope,
nodes: nodes,
arrayOnlySpread,
addHelper: name => this.addHelper(name)
});
let ref;
if (path.isCompletionRecord() || !path.parentPath.isExpressionStatement()) {
ref = scope.generateUidIdentifierBasedOnNode(node.right, "ref");
nodes.push(_core().types.variableDeclaration("var", [_core().types.variableDeclarator(ref, node.right)]));
if (_core().types.isArrayExpression(node.right)) {
destructuring.arrays[ref.name] = true;
}
}
destructuring.init(node.left, ref || node.right);
if (ref) {
if (path.parentPath.isArrowFunctionExpression()) {
path.replaceWith(_core().types.blockStatement([]));
nodes.push(_core().types.returnStatement(_core().types.cloneNode(ref)));
} else {
nodes.push(_core().types.expressionStatement(_core().types.cloneNode(ref)));
}
}
path.replaceWithMultiple(nodes);
},
VariableDeclaration(path) {
const {
node,
scope,
parent
} = path;
if (_core().types.isForXStatement(parent)) return;
if (!parent || !path.container) return;
if (!variableDeclarationHasPattern(node)) return;
const nodeKind = node.kind;
const nodes = [];
let declar;
for (let i = 0; i < node.declarations.length; i++) {
declar = node.declarations[i];
const patternId = declar.init;
const pattern = declar.id;
const destructuring = new DestructuringTransformer({
blockHoist: node._blockHoist,
nodes: nodes,
scope: scope,
kind: node.kind,
arrayOnlySpread,
addHelper: name => this.addHelper(name)
});
if (_core().types.isPattern(pattern)) {
destructuring.init(pattern, patternId);
if (+i !== node.declarations.length - 1) {
_core().types.inherits(nodes[nodes.length - 1], declar);
}
} else {
nodes.push(_core().types.inherits(destructuring.buildVariableAssignment(declar.id, _core().types.cloneNode(declar.init)), declar));
}
}
let tail = null;
const nodesOut = [];
for (const node of nodes) {
if (tail !== null && _core().types.isVariableDeclaration(node)) {
tail.declarations.push(...node.declarations);
} else {
node.kind = nodeKind;
nodesOut.push(node);
tail = _core().types.isVariableDeclaration(node) ? node : null;
}
}
for (const nodeOut of nodesOut) {
if (!nodeOut.declarations) continue;
for (const declaration of nodeOut.declarations) {
const {
name
} = declaration.id;
if (scope.bindings[name]) {
scope.bindings[name].kind = nodeOut.kind;
}
}
}
if (nodesOut.length === 1) {
path.replaceWith(nodesOut[0]);
} else {
path.replaceWithMultiple(nodesOut);
}
}
}
};
});
exports.default = _default;
\ No newline at end of file
node_modules/@babel/plugin-transform-destructuring/package.json deleted 100644 → 0
View file @ bf137ad8
{
"_from": "@babel/plugin-transform-destructuring@^7.2.0",
"_id": "@babel/plugin-transform-destructuring@7.6.0",
"_inBundle": false,
"_integrity": "sha512-2bGIS5P1v4+sWTCnKNDZDxbGvEqi0ijeqM/YqHtVGrvG2y0ySgnEEhXErvE9dA0bnIzY9bIzdFK0jFA46ASIIQ==",
"_location": "/@babel/plugin-transform-destructuring",
"_phantomChildren": {},
"_requested": {
"type": "range",
"registry": true,
"raw": "@babel/plugin-transform-destructuring@^7.2.0",
"name": "@babel/plugin-transform-destructuring",
"escapedName": "@babel%2fplugin-transform-destructuring",
"scope": "@babel",
"rawSpec": "^7.2.0",
"saveSpec": null,
"fetchSpec": "^7.2.0"
},
"_requiredBy": [
"/@babel/preset-env"
],
"_resolved": "https://registry.npmjs.org/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.6.0.tgz",
"_shasum": "44bbe08b57f4480094d57d9ffbcd96d309075ba6",
"_spec": "@babel/plugin-transform-destructuring@^7.2.0",
"_where": "C:\\Work\\OneDrive - bwstaff\\M4_Lab\\TV3\\NewVersion01\\LAFJLBmf939XYm5gj\\dev\\node_modules\\@babel\\preset-env",
"bundleDependencies": false,
"dependencies": {
"@babel/helper-plugin-utils": "^7.0.0"
},
"deprecated": false,
"description": "Compile ES2015 destructuring to ES5",
"devDependencies": {
"@babel/core": "^7.6.0",
"@babel/helper-plugin-test-runner": "^7.0.0"
},
"gitHead": "cbd5a26e57758e3f748174ff84aa570e8780e85d",
"keywords": [
"babel-plugin"
],
"license": "MIT",
"main": "lib/index.js",
"name": "@babel/plugin-transform-destructuring",
"peerDependencies": {
"@babel/core": "^7.0.0-0"
},
"publishConfig": {
"access": "public"
},
"repository": {
"type": "git",
"url": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-destructuring"
},
"version": "7.6.0"
}
node_modules/@babel/plugin-transform-dotall-regex/LICENSE deleted 100644 → 0
View file @ bf137ad8
MIT License
Copyright (c) 2014-present Sebastian McKenzie and other contributors
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
node_modules/@babel/plugin-transform-dotall-regex/README.md deleted 100644 → 0
View file @ bf137ad8
# @babel/plugin-transform-dotall-regex
> Compile regular expressions using the `s` (`dotAll`) flag to ES5.
See our website [@babel/plugin-transform-dotall-regex](https://babeljs.io/docs/en/next/babel-plugin-transform-dotall-regex.html) for more information.
## Install
Using npm:
```sh
npm install --save-dev @babel/plugin-transform-dotall-regex
```
or using yarn:
```sh
yarn add @babel/plugin-transform-dotall-regex --dev
```
node_modules/@babel/plugin-transform-dotall-regex/lib/index.js deleted 100644 → 0
View file @ bf137ad8
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _helperCreateRegexpFeaturesPlugin = require("@babel/helper-create-regexp-features-plugin");
var _helperPluginUtils = require("@babel/helper-plugin-utils");
var _default = (0, _helperPluginUtils.declare)(api => {
api.assertVersion(7);
return (0, _helperCreateRegexpFeaturesPlugin.createRegExpFeaturePlugin)({
name: "transform-dotall-regex",
feature: "dotAllFlag"
});
});
exports.default = _default;
\ No newline at end of file
node_modules/@babel/plugin-transform-dotall-regex/package.json deleted 100644 → 0
View file @ bf137ad8
{
"_from": "@babel/plugin-transform-dotall-regex@^7.2.0",
"_id": "@babel/plugin-transform-dotall-regex@7.7.0",
"_inBundle": false,
"_integrity": "sha512-3QQlF7hSBnSuM1hQ0pS3pmAbWLax/uGNCbPBND9y+oJ4Y776jsyujG2k0Sn2Aj2a0QwVOiOFL5QVPA7spjvzSA==",
"_location": "/@babel/plugin-transform-dotall-regex",
"_phantomChildren": {},
"_requested": {
"type": "range",
"registry": true,
"raw": "@babel/plugin-transform-dotall-regex@^7.2.0",
"name": "@babel/plugin-transform-dotall-regex",
"escapedName": "@babel%2fplugin-transform-dotall-regex",
"scope": "@babel",
"rawSpec": "^7.2.0",
"saveSpec": null,
"fetchSpec": "^7.2.0"
},
"_requiredBy": [
"/@babel/preset-env"
],
"_resolved": "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.7.0.tgz",
"_shasum": "c5c9ecacab3a5e0c11db6981610f0c32fd698b3b",
"_spec": "@babel/plugin-transform-dotall-regex@^7.2.0",
"_where": "C:\\Work\\OneDrive - bwstaff\\M4_Lab\\TV3\\NewVersion01\\LAFJLBmf939XYm5gj\\dev\\node_modules\\@babel\\preset-env",
"bugs": {
"url": "https://github.com/babel/babel/issues"
},
"bundleDependencies": false,
"dependencies": {
"@babel/helper-create-regexp-features-plugin": "^7.7.0",
"@babel/helper-plugin-utils": "^7.0.0"
},
"deprecated": false,
"description": "Compile regular expressions using the `s` (`dotAll`) flag to ES5.",
"devDependencies": {
"@babel/core": "^7.7.0",
"@babel/helper-plugin-test-runner": "^7.0.0"
},
"gitHead": "97faa83953cb87e332554fa559a4956d202343ea",
"homepage": "https://babeljs.io/",
"keywords": [
"babel-plugin",
"regex",
"regexp",
"regular expressions",
"dotall"
],
"license": "MIT",
"main": "lib/index.js",
"name": "@babel/plugin-transform-dotall-regex",
"peerDependencies": {
"@babel/core": "^7.0.0-0"
},
"publishConfig": {
"access": "public"
},
"repository": {
"type": "git",
"url": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-dotall-regex"
},
"version": "7.7.0"
}
node_modules/@babel/plugin-transform-dotall-regex/src/index.js deleted 100644 → 0
View file @ bf137ad8
/* eslint-disable @babel/development/plugin-name */
import { createRegExpFeaturePlugin } from "@babel/helper-create-regexp-features-plugin";
import { declare } from "@babel/helper-plugin-utils";
export default declare(api => {
api.assertVersion(7);
return createRegExpFeaturePlugin({
name: "transform-dotall-regex",
feature: "dotAllFlag",
});
});
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

Dies ist die Gitlab-Instanz des Transferportals der Hochschule für Technik Stuttgart. Hier geht es zurück zum Portal