Befor generating
This commit is contained in:
marys committed
1 parent
3383f4bf4a
commit
1aa1b5f625
6756 files changed
+649946
-1
No files matched your search
Generated
Vendored
+22
@@ -0,0 +1,22 @@
|
||||
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.
|
||||
Generated
Vendored
+19
@@ -0,0 +1,19 @@
|
||||
# @babel/helper-member-expression-to-functions
|
||||
|
||||
> Helper function to replace certain member expressions with function calls
|
||||
|
||||
See our website [@babel/helper-member-expression-to-functions](https://babeljs.io/docs/babel-helper-member-expression-to-functions) for more information.
|
||||
|
||||
## Install
|
||||
|
||||
Using npm:
|
||||
|
||||
```sh
|
||||
npm install --save @babel/helper-member-expression-to-functions
|
||||
```
|
||||
|
||||
or using yarn:
|
||||
|
||||
```sh
|
||||
yarn add @babel/helper-member-expression-to-functions
|
||||
```
|
||||
Generated
Vendored
+400
@@ -0,0 +1,400 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', { value: true });
|
||||
|
||||
var _t = require('@babel/types');
|
||||
|
||||
function _interopNamespace(e) {
|
||||
if (e && e.__esModule) return e;
|
||||
var n = Object.create(null);
|
||||
if (e) {
|
||||
Object.keys(e).forEach(function (k) {
|
||||
if (k !== 'default') {
|
||||
var d = Object.getOwnPropertyDescriptor(e, k);
|
||||
Object.defineProperty(n, k, d.get ? d : {
|
||||
enumerable: true,
|
||||
get: function () { return e[k]; }
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
n.default = e;
|
||||
return Object.freeze(n);
|
||||
}
|
||||
|
||||
var _t__namespace = /*#__PURE__*/_interopNamespace(_t);
|
||||
|
||||
function willPathCastToBoolean(path) {
|
||||
const maybeWrapped = path;
|
||||
const {
|
||||
node,
|
||||
parentPath
|
||||
} = maybeWrapped;
|
||||
if (parentPath.isLogicalExpression()) {
|
||||
const {
|
||||
operator,
|
||||
right
|
||||
} = parentPath.node;
|
||||
if (operator === "&&" || operator === "||" || operator === "??" && node === right) {
|
||||
return willPathCastToBoolean(parentPath);
|
||||
}
|
||||
}
|
||||
if (parentPath.isSequenceExpression()) {
|
||||
const {
|
||||
expressions
|
||||
} = parentPath.node;
|
||||
if (expressions[expressions.length - 1] === node) {
|
||||
return willPathCastToBoolean(parentPath);
|
||||
} else {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return parentPath.isConditional({
|
||||
test: node
|
||||
}) || parentPath.isUnaryExpression({
|
||||
operator: "!"
|
||||
}) || parentPath.isForStatement({
|
||||
test: node
|
||||
}) || parentPath.isWhile({
|
||||
test: node
|
||||
});
|
||||
}
|
||||
|
||||
const {
|
||||
LOGICAL_OPERATORS,
|
||||
arrowFunctionExpression,
|
||||
assignmentExpression,
|
||||
binaryExpression,
|
||||
booleanLiteral,
|
||||
callExpression,
|
||||
cloneNode,
|
||||
conditionalExpression,
|
||||
identifier,
|
||||
isMemberExpression,
|
||||
isOptionalCallExpression,
|
||||
isOptionalMemberExpression,
|
||||
isUpdateExpression,
|
||||
logicalExpression,
|
||||
memberExpression,
|
||||
nullLiteral,
|
||||
optionalCallExpression,
|
||||
optionalMemberExpression,
|
||||
sequenceExpression,
|
||||
updateExpression
|
||||
} = _t__namespace;
|
||||
class AssignmentMemoiser {
|
||||
constructor() {
|
||||
this._map = void 0;
|
||||
this._map = new WeakMap();
|
||||
}
|
||||
has(key) {
|
||||
return this._map.has(key);
|
||||
}
|
||||
get(key) {
|
||||
if (!this.has(key)) return;
|
||||
const record = this._map.get(key);
|
||||
const {
|
||||
value
|
||||
} = record;
|
||||
record.count--;
|
||||
if (record.count === 0) {
|
||||
return assignmentExpression("=", value, key);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
set(key, value, count) {
|
||||
return this._map.set(key, {
|
||||
count,
|
||||
value
|
||||
});
|
||||
}
|
||||
}
|
||||
function toNonOptional(path, base) {
|
||||
const {
|
||||
node
|
||||
} = path;
|
||||
if (isOptionalMemberExpression(node)) {
|
||||
return memberExpression(base, node.property, node.computed);
|
||||
}
|
||||
if (path.isOptionalCallExpression()) {
|
||||
const callee = path.get("callee");
|
||||
if (path.node.optional && callee.isOptionalMemberExpression()) {
|
||||
const object = callee.node.object;
|
||||
const context = path.scope.maybeGenerateMemoised(object);
|
||||
callee.get("object").replaceWith(assignmentExpression("=", context, object));
|
||||
return callExpression(memberExpression(base, identifier("call")), [context, ...path.node.arguments]);
|
||||
}
|
||||
return callExpression(base, path.node.arguments);
|
||||
}
|
||||
return path.node;
|
||||
}
|
||||
function isInDetachedTree(path) {
|
||||
while (path) {
|
||||
if (path.isProgram()) break;
|
||||
const {
|
||||
parentPath,
|
||||
container,
|
||||
listKey
|
||||
} = path;
|
||||
const parentNode = parentPath.node;
|
||||
if (listKey) {
|
||||
if (container !== parentNode[listKey]) {
|
||||
return true;
|
||||
}
|
||||
} else {
|
||||
if (container !== parentNode) return true;
|
||||
}
|
||||
path = parentPath;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
const handle = {
|
||||
memoise() {},
|
||||
handle(member, noDocumentAll) {
|
||||
const {
|
||||
node,
|
||||
parent,
|
||||
parentPath,
|
||||
scope
|
||||
} = member;
|
||||
if (member.isOptionalMemberExpression()) {
|
||||
if (isInDetachedTree(member)) return;
|
||||
const endPath = member.find(({
|
||||
node,
|
||||
parent
|
||||
}) => {
|
||||
if (isOptionalMemberExpression(parent)) {
|
||||
return parent.optional || parent.object !== node;
|
||||
}
|
||||
if (isOptionalCallExpression(parent)) {
|
||||
return (node !== member.node && parent.optional || parent.callee !== node
|
||||
);
|
||||
}
|
||||
return true;
|
||||
});
|
||||
if (scope.path.isPattern()) {
|
||||
endPath.replaceWith(callExpression(arrowFunctionExpression([], endPath.node), []));
|
||||
return;
|
||||
}
|
||||
const willEndPathCastToBoolean = willPathCastToBoolean(endPath);
|
||||
const rootParentPath = endPath.parentPath;
|
||||
if (rootParentPath.isUpdateExpression({
|
||||
argument: node
|
||||
})) {
|
||||
throw member.buildCodeFrameError(`can't handle update expression`);
|
||||
}
|
||||
const isAssignment = rootParentPath.isAssignmentExpression({
|
||||
left: endPath.node
|
||||
});
|
||||
const isDeleteOperation = rootParentPath.isUnaryExpression({
|
||||
operator: "delete"
|
||||
});
|
||||
if (isDeleteOperation && endPath.isOptionalMemberExpression() && endPath.get("property").isPrivateName()) {
|
||||
throw member.buildCodeFrameError(`can't delete a private class element`);
|
||||
}
|
||||
let startingOptional = member;
|
||||
for (;;) {
|
||||
if (startingOptional.isOptionalMemberExpression()) {
|
||||
if (startingOptional.node.optional) break;
|
||||
startingOptional = startingOptional.get("object");
|
||||
continue;
|
||||
} else if (startingOptional.isOptionalCallExpression()) {
|
||||
if (startingOptional.node.optional) break;
|
||||
startingOptional = startingOptional.get("callee");
|
||||
continue;
|
||||
}
|
||||
throw new Error(`Internal error: unexpected ${startingOptional.node.type}`);
|
||||
}
|
||||
const startingNode = startingOptional.isOptionalMemberExpression() ? startingOptional.node.object : startingOptional.node.callee;
|
||||
const baseNeedsMemoised = scope.maybeGenerateMemoised(startingNode);
|
||||
const baseRef = baseNeedsMemoised != null ? baseNeedsMemoised : startingNode;
|
||||
const parentIsOptionalCall = parentPath.isOptionalCallExpression({
|
||||
callee: node
|
||||
});
|
||||
const isOptionalCall = parent => parentIsOptionalCall;
|
||||
const parentIsCall = parentPath.isCallExpression({
|
||||
callee: node
|
||||
});
|
||||
startingOptional.replaceWith(toNonOptional(startingOptional, baseRef));
|
||||
if (isOptionalCall()) {
|
||||
if (parent.optional) {
|
||||
parentPath.replaceWith(this.optionalCall(member, parent.arguments));
|
||||
} else {
|
||||
parentPath.replaceWith(this.call(member, parent.arguments));
|
||||
}
|
||||
} else if (parentIsCall) {
|
||||
member.replaceWith(this.boundGet(member));
|
||||
} else if (this.delete && parentPath.isUnaryExpression({
|
||||
operator: "delete"
|
||||
})) {
|
||||
parentPath.replaceWith(this.delete(member));
|
||||
} else if (parentPath.isAssignmentExpression()) {
|
||||
handleAssignment(this, member, parentPath);
|
||||
} else {
|
||||
member.replaceWith(this.get(member));
|
||||
}
|
||||
let regular = member.node;
|
||||
for (let current = member; current !== endPath;) {
|
||||
const parentPath = current.parentPath;
|
||||
if (parentPath === endPath && isOptionalCall() && parent.optional) {
|
||||
regular = parentPath.node;
|
||||
break;
|
||||
}
|
||||
regular = toNonOptional(parentPath, regular);
|
||||
current = parentPath;
|
||||
}
|
||||
let context;
|
||||
const endParentPath = endPath.parentPath;
|
||||
if (isMemberExpression(regular) && endParentPath.isOptionalCallExpression({
|
||||
callee: endPath.node,
|
||||
optional: true
|
||||
})) {
|
||||
const {
|
||||
object
|
||||
} = regular;
|
||||
context = member.scope.maybeGenerateMemoised(object);
|
||||
if (context) {
|
||||
regular.object = assignmentExpression("=", context, object);
|
||||
}
|
||||
}
|
||||
let replacementPath = endPath;
|
||||
if (isDeleteOperation || isAssignment) {
|
||||
replacementPath = endParentPath;
|
||||
regular = endParentPath.node;
|
||||
}
|
||||
const baseMemoised = baseNeedsMemoised ? assignmentExpression("=", cloneNode(baseRef), cloneNode(startingNode)) : cloneNode(baseRef);
|
||||
if (willEndPathCastToBoolean) {
|
||||
let nonNullishCheck;
|
||||
if (noDocumentAll) {
|
||||
nonNullishCheck = binaryExpression("!=", baseMemoised, nullLiteral());
|
||||
} else {
|
||||
nonNullishCheck = logicalExpression("&&", binaryExpression("!==", baseMemoised, nullLiteral()), binaryExpression("!==", cloneNode(baseRef), scope.buildUndefinedNode()));
|
||||
}
|
||||
replacementPath.replaceWith(logicalExpression("&&", nonNullishCheck, regular));
|
||||
} else {
|
||||
let nullishCheck;
|
||||
if (noDocumentAll) {
|
||||
nullishCheck = binaryExpression("==", baseMemoised, nullLiteral());
|
||||
} else {
|
||||
nullishCheck = logicalExpression("||", binaryExpression("===", baseMemoised, nullLiteral()), binaryExpression("===", cloneNode(baseRef), scope.buildUndefinedNode()));
|
||||
}
|
||||
replacementPath.replaceWith(conditionalExpression(nullishCheck, isDeleteOperation ? booleanLiteral(true) : scope.buildUndefinedNode(), regular));
|
||||
}
|
||||
if (context) {
|
||||
const endParent = endParentPath.node;
|
||||
endParentPath.replaceWith(optionalCallExpression(optionalMemberExpression(endParent.callee, identifier("call"), false, true), [cloneNode(context), ...endParent.arguments], false));
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (isUpdateExpression(parent, {
|
||||
argument: node
|
||||
})) {
|
||||
if (this.simpleSet) {
|
||||
member.replaceWith(this.simpleSet(member));
|
||||
return;
|
||||
}
|
||||
const {
|
||||
operator,
|
||||
prefix
|
||||
} = parent;
|
||||
this.memoise(member, 2);
|
||||
const ref = scope.generateUidIdentifierBasedOnNode(node);
|
||||
scope.push({
|
||||
id: ref
|
||||
});
|
||||
const seq = [assignmentExpression("=", cloneNode(ref), this.get(member))];
|
||||
if (prefix) {
|
||||
seq.push(updateExpression(operator, cloneNode(ref), prefix));
|
||||
const value = sequenceExpression(seq);
|
||||
parentPath.replaceWith(this.set(member, value));
|
||||
return;
|
||||
} else {
|
||||
const ref2 = scope.generateUidIdentifierBasedOnNode(node);
|
||||
scope.push({
|
||||
id: ref2
|
||||
});
|
||||
seq.push(assignmentExpression("=", cloneNode(ref2), updateExpression(operator, cloneNode(ref), prefix)), cloneNode(ref));
|
||||
const value = sequenceExpression(seq);
|
||||
parentPath.replaceWith(sequenceExpression([this.set(member, value), cloneNode(ref2)]));
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (parentPath.isAssignmentExpression({
|
||||
left: node
|
||||
})) {
|
||||
handleAssignment(this, member, parentPath);
|
||||
return;
|
||||
}
|
||||
if (parentPath.isCallExpression({
|
||||
callee: node
|
||||
})) {
|
||||
parentPath.replaceWith(this.call(member, parentPath.node.arguments));
|
||||
return;
|
||||
}
|
||||
if (parentPath.isOptionalCallExpression({
|
||||
callee: node
|
||||
})) {
|
||||
if (scope.path.isPattern()) {
|
||||
parentPath.replaceWith(callExpression(arrowFunctionExpression([], parentPath.node), []));
|
||||
return;
|
||||
}
|
||||
parentPath.replaceWith(this.optionalCall(member, parentPath.node.arguments));
|
||||
return;
|
||||
}
|
||||
if (this.delete && parentPath.isUnaryExpression({
|
||||
operator: "delete"
|
||||
})) {
|
||||
parentPath.replaceWith(this.delete(member));
|
||||
return;
|
||||
}
|
||||
if (parentPath.isForXStatement({
|
||||
left: node
|
||||
}) || parentPath.isObjectProperty({
|
||||
value: node
|
||||
}) && parentPath.parentPath.isObjectPattern() || parentPath.isAssignmentPattern({
|
||||
left: node
|
||||
}) && parentPath.parentPath.isObjectProperty({
|
||||
value: parent
|
||||
}) && parentPath.parentPath.parentPath.isObjectPattern() || parentPath.isArrayPattern() || parentPath.isAssignmentPattern({
|
||||
left: node
|
||||
}) && parentPath.parentPath.isArrayPattern() || parentPath.isRestElement()) {
|
||||
member.replaceWith(this.destructureSet(member));
|
||||
return;
|
||||
}
|
||||
if (parentPath.isTaggedTemplateExpression()) {
|
||||
member.replaceWith(this.boundGet(member));
|
||||
} else {
|
||||
member.replaceWith(this.get(member));
|
||||
}
|
||||
}
|
||||
};
|
||||
function handleAssignment(state, member, parentPath) {
|
||||
if (state.simpleSet) {
|
||||
member.replaceWith(state.simpleSet(member));
|
||||
return;
|
||||
}
|
||||
const {
|
||||
operator,
|
||||
right: value
|
||||
} = parentPath.node;
|
||||
if (operator === "=") {
|
||||
parentPath.replaceWith(state.set(member, value));
|
||||
} else {
|
||||
const operatorTrunc = operator.slice(0, -1);
|
||||
if (LOGICAL_OPERATORS.includes(operatorTrunc)) {
|
||||
state.memoise(member, 1);
|
||||
parentPath.replaceWith(logicalExpression(operatorTrunc, state.get(member), state.set(member, value)));
|
||||
} else {
|
||||
state.memoise(member, 2);
|
||||
parentPath.replaceWith(state.set(member, binaryExpression(operatorTrunc, state.get(member), value)));
|
||||
}
|
||||
}
|
||||
}
|
||||
function memberExpressionToFunctions(path, visitor, state) {
|
||||
path.traverse(visitor, Object.assign({}, handle, state, {
|
||||
memoiser: new AssignmentMemoiser()
|
||||
}));
|
||||
}
|
||||
|
||||
exports.default = memberExpressionToFunctions;
|
||||
//# sourceMappingURL=index.js.map
|
||||
Generated
Vendored
+1
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"index.js","sources":["../src/util.ts","../src/index.ts"],"sourcesContent":["import type { NodePath } from \"@babel/traverse\";\n\n/**\n * Test if a NodePath will be cast to boolean when evaluated.\n *\n * @example\n * // returns true\n * const nodePathAQDotB = NodePath(\"if (a?.#b) {}\").get(\"test\"); // a?.#b\n * willPathCastToBoolean(nodePathAQDotB)\n * @example\n * // returns false\n * willPathCastToBoolean(NodePath(\"a?.#b\"))\n * @todo Respect transparent expression wrappers\n * @see {@link packages/babel-plugin-transform-optional-chaining/src/util.js}\n * @param {NodePath} path\n * @returns {boolean}\n */\nexport function willPathCastToBoolean(path: NodePath): boolean {\n const maybeWrapped = path;\n const { node, parentPath } = maybeWrapped;\n if (parentPath.isLogicalExpression()) {\n const { operator, right } = parentPath.node;\n if (\n operator === \"&&\" ||\n operator === \"||\" ||\n (operator === \"??\" && node === right)\n ) {\n return willPathCastToBoolean(parentPath);\n }\n }\n if (parentPath.isSequenceExpression()) {\n const { expressions } = parentPath.node;\n if (expressions[expressions.length - 1] === node) {\n return willPathCastToBoolean(parentPath);\n } else {\n // if it is in the middle of a sequence expression, we don't\n // care the return value so just cast to boolean for smaller\n // output\n return true;\n }\n }\n return (\n parentPath.isConditional({ test: node }) ||\n parentPath.isUnaryExpression({ operator: \"!\" }) ||\n parentPath.isForStatement({ test: node }) ||\n parentPath.isWhile({ test: node })\n );\n}\n","import type { NodePath, Visitor } from \"@babel/traverse\";\nimport {\n LOGICAL_OPERATORS,\n arrowFunctionExpression,\n assignmentExpression,\n binaryExpression,\n booleanLiteral,\n callExpression,\n cloneNode,\n conditionalExpression,\n identifier,\n isMemberExpression,\n isOptionalCallExpression,\n isOptionalMemberExpression,\n isUpdateExpression,\n logicalExpression,\n memberExpression,\n nullLiteral,\n optionalCallExpression,\n optionalMemberExpression,\n sequenceExpression,\n updateExpression,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\nimport { willPathCastToBoolean } from \"./util.ts\";\n\nclass AssignmentMemoiser {\n private _map: WeakMap<t.Expression, { count: number; value: t.Identifier }>;\n constructor() {\n this._map = new WeakMap();\n }\n\n has(key: t.Expression) {\n return this._map.has(key);\n }\n\n get(key: t.Expression) {\n if (!this.has(key)) return;\n\n const record = this._map.get(key);\n const { value } = record;\n\n record.count--;\n if (record.count === 0) {\n // The `count` access is the outermost function call (hopefully), so it\n // does the assignment.\n return assignmentExpression(\"=\", value, key);\n }\n return value;\n }\n\n set(key: t.Expression, value: t.Identifier, count: number) {\n return this._map.set(key, { count, value });\n }\n}\n\nfunction toNonOptional(\n path: NodePath<t.Expression>,\n base: t.Expression,\n): t.Expression {\n const { node } = path;\n if (isOptionalMemberExpression(node)) {\n return memberExpression(base, node.property, node.computed);\n }\n\n if (path.isOptionalCallExpression()) {\n const callee = path.get(\"callee\");\n if (path.node.optional && callee.isOptionalMemberExpression()) {\n // object must be a conditional expression because the optional private access in object has been transformed\n const object = callee.node.object as t.ConditionalExpression;\n const context = path.scope.maybeGenerateMemoised(object);\n callee\n .get(\"object\")\n .replaceWith(assignmentExpression(\"=\", context, object));\n\n return callExpression(memberExpression(base, identifier(\"call\")), [\n context,\n ...path.node.arguments,\n ]);\n }\n\n return callExpression(base, path.node.arguments);\n }\n\n return path.node;\n}\n\n// Determines if the current path is in a detached tree. This can happen when\n// we are iterating on a path, and replace an ancestor with a new node. Babel\n// doesn't always stop traversing the old node tree, and that can cause\n// inconsistencies.\nfunction isInDetachedTree(path: NodePath) {\n while (path) {\n if (path.isProgram()) break;\n\n const { parentPath, container, listKey } = path;\n const parentNode = parentPath.node;\n if (listKey) {\n if (\n container !==\n // @ts-expect-error listKey must be a valid parent node key\n parentNode[listKey]\n ) {\n return true;\n }\n } else {\n if (container !== parentNode) return true;\n }\n\n path = parentPath;\n }\n\n return false;\n}\n\ntype Member = NodePath<t.OptionalMemberExpression | t.MemberExpression>;\n\nconst handle = {\n memoise() {\n // noop.\n },\n\n handle(this: HandlerState, membeLine truncated
|
||||
Generated
Vendored
+25
@@ -0,0 +1,25 @@
|
||||
{
|
||||
"name": "@babel/helper-member-expression-to-functions",
|
||||
"version": "7.29.7",
|
||||
"description": "Helper function to replace certain member expressions with function calls",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/babel/babel.git",
|
||||
"directory": "packages/babel-helper-member-expression-to-functions"
|
||||
},
|
||||
"homepage": "https://babel.dev/docs/en/next/babel-helper-member-expression-to-functions",
|
||||
"license": "MIT",
|
||||
"publishConfig": {
|
||||
"access": "public"
|
||||
},
|
||||
"main": "./lib/index.js",
|
||||
"author": "The Babel Team (https://babel.dev/team)",
|
||||
"dependencies": {
|
||||
"@babel/traverse": "^7.29.7",
|
||||
"@babel/types": "^7.29.7"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=6.9.0"
|
||||
},
|
||||
"type": "commonjs"
|
||||
}
|
||||
Reference in new issue
Block a user