function _defineProperties(target, props) {
for (let i = 0; i < props.length; i++) {
const descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ('value' in descriptor) {
descriptor.writable = true;
}
Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
}
}
function _createClass(Constructor, protoProps, staticProps) {
if (protoProps) {
_defineProperties(Constructor.prototype, protoProps);
}
if (staticProps) {
_defineProperties(Constructor, staticProps);
}
Object.defineProperty(Constructor, 'prototype', { writable: false });
return Constructor;
}
function _toPropertyKey(t) {
const i = _toPrimitive(t, 'string');
return typeof i === 'symbol' ? i : String(i);
}
function _toPrimitive(t, r) {
if (typeof t !== 'object' || !t) {
return t;
}
const e = t[Symbol.toPrimitive];
if (void 0 !== e) {
const i = e.call(t, r || 'default');
if (typeof i !== 'object') {
return i;
}
throw new TypeError('@@toPrimitive must return a primitive value.');
}
return (r === 'string' ? String : Number)(t);
}
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError('Cannot call a class as a function');
}
}
function _callSuper(t, o, e) {
return (
(o = _getPrototypeOf(o)),
_possibleConstructorReturn(
t,
_isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e),
)
);
}
function _possibleConstructorReturn(self, call) {
if (call && (typeof call === 'object' || typeof call === 'function')) {
return call;
} else if (call !== void 0) {
throw new TypeError('Derived constructors may only return object or undefined');
}
return _assertThisInitialized(self);
}
function _assertThisInitialized(self) {
if (self === void 0) {
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
}
return self;
}
function _inherits(subClass, superClass) {
if (typeof superClass !== 'function' && superClass !== null) {
throw new TypeError('Super expression must either be null or a function');
}
subClass.prototype = Object.create(superClass && superClass.prototype, {
constructor: { value: subClass, writable: true, configurable: true },
});
Object.defineProperty(subClass, 'prototype', { writable: false });
if (superClass) {
_setPrototypeOf(subClass, superClass);
}
}
function _wrapNativeSuper(Class) {
const _cache = typeof Map === 'function' ? new Map() : undefined;
_wrapNativeSuper = function _wrapNativeSuper(Class) {
if (Class === null || !_isNativeFunction(Class)) {
return Class;
}
if (typeof Class !== 'function') {
throw new TypeError('Super expression must either be null or a function');
}
if (typeof _cache !== 'undefined') {
if (_cache.has(Class)) {
return _cache.get(Class);
}
_cache.set(Class, Wrapper);
}
function Wrapper() {
return _construct(Class, arguments, _getPrototypeOf(this).constructor);
}
Wrapper.prototype = Object.create(Class.prototype, {
constructor: {
value: Wrapper,
enumerable: false,
writable: true,
configurable: true,
},
});
return _setPrototypeOf(Wrapper, Class);
};
return _wrapNativeSuper(Class);
}
function _construct(t, e, r) {
if (_isNativeReflectConstruct()) {
return Reflect.construct.apply(null, arguments);
}
const o = [null];
o.push.apply(o, e);
const p = new (t.bind.apply(t, o))();
return r && _setPrototypeOf(p, r.prototype), p;
}
function _isNativeReflectConstruct() {
try {
var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], () => {}));
} catch (err) {}
return (_isNativeReflectConstruct = function _isNativeReflectConstruct() {
return !!t;
})();
}
function _isNativeFunction(fn) {
try {
return Function.toString.call(fn).indexOf('[native code]') !== -1;
} catch (err) {
return typeof fn === 'function';
}
}
function _setPrototypeOf(o, p) {
_setPrototypeOf = Object.setPrototypeOf
? Object.setPrototypeOf.bind()
: function _setPrototypeOf(o, p) {
o.__proto__ = p;
return o;
};
return _setPrototypeOf(o, p);
}
function _getPrototypeOf(o) {
_getPrototypeOf = Object.setPrototypeOf
? Object.getPrototypeOf.bind()
: function _getPrototypeOf(o) {
return o.__proto__ || Object.getPrototypeOf(o);
};
return _getPrototypeOf(o);
}
const ReversedArray = /* #__PURE__*/ (function (_Array) {
_inherits(ReversedArray, _Array);
function ReversedArray() {
_classCallCheck(this, ReversedArray);
return _callSuper(this, ReversedArray, arguments);
}
return _createClass(ReversedArray);
})(/* #__PURE__*/ _wrapNativeSuper(Array));
const arr = new ReversedArray(1, 2, 3);
console.log(arr);class ReversedArray extends Array {}
const arr = new ReversedArray(1, 2, 3)
console.log(arr);const a = 1 и потом спрашивать "где а?".const RevercedArray = function(...args) {
const arr = Array.apply(this, args);
arr.forEach((v, i) => {
this[i] = v
})
this.length = arr.length
};{} — это, по сути, алиас другого типа: Object (с большой буквы), а поскольку всё наследуется от Object (кроме нулл и андефайнд), то и присвоить можно любое значение. А присвоить его можно любому значению, потому что по сути это Record<any, any> со всеми вытекающими.
В целом, подозреваю, что имеет место баг.