wentout

'use strict';

/**

AI explanation from Qwen coder 2.5

In Node.js, the conventional way
 to perform a null check in a callback function,
 particularly for error handling,
 involves checking the first argument of the callback.

wentout

'use strict';

const ogp = Object.getPrototypeOf;
const ohp = Object.prototype.hasOwnProperty;

const Cstr = function () {
    // console.log(this.value);
    const root = this;
    const main = this.constructor;
    const isItSelf = main === Cstr;

wentout

'use strict';

const myObj = {};
let field = 123;

Object.defineProperty( myObj, 'field', {
	async get () {
		return new Promise( ( resolve, reject ) => {
			setTimeout( () => {
				resolve( field );

wentout

'use strict';

const count = 1_000_000_000;

console.time('finished in');

const myArr = [];

let i = 0;

wentout

'use strict';

class MyPromise<T> extends Promise<T> {
    constructor(handler: (
        resolve: (value: T) => unknown,
        reject: () => unknown) => void
    ) {
        super(handler);
    }
}

wentout

'use strict';

// for testing this code please use the following command
// 
// node PubSubOnWrappers.js | grep stack
// 
// to see if stack size exceed
// 
// for huge amount of async subs in Node.js we are receiving
// "Exception in PromiseRejectCallback" 

wentout

'use strict';


// though Error.prototype.stack is non standard
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/stack

const myErrorObject = new Error('my error');
myErrorObject.prop = 123;
const hop = (o, p) => Object.prototype.hasOwnProperty.call(o, p);

wentout

function foo() { };
const bar = { a: 'a' };
Object
    .setPrototypeOf(
        foo.prototype,
        bar
    );
const baz = Object.create(foo.prototype);
console.log(baz instanceof foo);

wentout

'use strict';
const ogp = Object.getPrototypeOf;
const osp = Object.setPrototypeOf;

const MyArrayConstructor = function() {};
osp(MyArrayConstructor.prototype, new Array);

class MyArray extends MyArrayConstructor {
    constructor(...args) {
        super(...args);

wentout

class Base {
    constructor() {
        return new Extended;
    }
}

class Extended extends Base {
    constructor() {
        super();
    }