Сохранено!
"use strict";
// JavaScript ES6+
// последний Google Chrome, FireFox

/**
 * JavaScript класс-стенд с академическими задачами.
 * Небходимо заполнить все пропуски в классе так, чтобы он
 * удовлетворял поставленным assert'ам.
 */
class JobSeeker {
	/**
	 * Assert #1
	 */
	constructor() {
		let a = 0;
		this['[[::constructor1;someName]]'] = () => a +++ a;
	}

	/**
	 * Assert #2
	 */
	calc(arg) {
		let args = [arg];
		const fn = (arg) => typeof arg === '[[::calc-type;type]]'
			? args.[[::calc-func1;someFunc]](arg)
			: args.[[::calc-func2;someFunc]](arg) && fn;
		return fn;
	}

	/**
	 * Assert #3
	 */
	get data() {
		return '[[::data-val;data]]';
	}

	/**
	 * Assert #4
	 * Возвращает HTML инфо-карточки соискателя.
	 * Пожалуйста, заполните карточку достоверной информацией о вас.
	 */
	get seekerCard() {
		return `
			<seeker-card>
				<my-info>
					<my-name>[[::card-name;Ваше имя]]</my-name>
					<my-age>[[::card-age;Ваш возраст]]</my-age>
				</my-info>
				<loc-info>
					(<loc-city>[[::card-city;Город проживания]]</loc-city>)
				</loc-info>
				<prof-info>
					(<prof-skills>[[::card-skills;Навыки]]</prof-skills>)
				</prof-info>
			</seeker-card>
		`;
	}

	/**
	 * Assert #4
	 * Возвращает информацию о соискателе
	 */
	async getSeekerInfo() {
		const repo = self['[[::card-service-name;something]]'];
		const listen = name => new Promise(resolve => {
			repo.[[::card-service-method1;method]](
				name,
				class extends HTMLElement {
					constructor() {
						super();
						resolve([
							name.replace(/^.+-/, ''),
							this.innerText
						]);
					}
				}
			);
		});
		let queue = Promise.all('[[::card-keys;something]]'.split(',').map(listen));
		repo.[[::card-service-method2;method]](document.body);
		return new [[::card-class;ClassName]](await queue);
	}

	/**
	 * Assert #5
	 * Трансформирует числа в массиве по модулю 256
	 */
	*getMod256(numbers) {
		return [[::mod-op;operator]] new [[::mod-class;SomeClass]](numbers);
	}

	/**
	 * Assert #6
	 * Корректирует полученный HTML путем DOM преобразований
	 */
	correctHtml(html) {
		let f = document.createElement('div');
		f.innerHTML = html;

		f.querySelectorAll('[[::dom-sel1;selector]]')
			.forEach(el => el.remove());

		let el = f.querySelector('[[::dom-sel2;selector]]');
		el.parentNode.insertBefore(el.nextSibling, el);

		el = f.getElementsByTagName('div')[2]
			.childNodes[3]['[[::dom-sel3;someProp]]'];

		el.textContent = String(parseInt(el.textContent) + 1);

		return f.innerText.replace(/\s/g, '');
	}

	/**
	 * Assert #7
	 * Вспомогательный метод с сакральным смыслом :)
	 */
	static [[::static-method1;someMethod]](arg) {
		return arg === new function() {
			return arg;
		};
	}

	/**
	 * Assert #8
	 * Возвращает стилизованный элемент
	 */
	getElement() {
		let el = document.createElement('div');
		el.style.cssText = 'position: absolute; left: 0; opacity: 0';
		let shadow = el.attachShadow({mode: 'closed'});
		let el2 = document.createElement('div');
		let css = `[[::el-style;css]]`;

		// *зловещий смех* https://gph.to/2QaeWey
		css = css.replace(/rgba?/gi, '');

		el2.style.cssText = css;
		shadow.appendChild(el2);
		document.body.appendChild(el);
		return el2;
	}

	/**
	 * Assert #9
	 * Находит все простые числа до указанного числа.
	 * Для поиска используется мощности видеокарты (а-ля GPGPU).
	 */
	findPrimeNumbers(max) {
		let size = Math.ceil(Math.sqrt(2 ** Math.log2(max + 2))),
			plane = [-1, -1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1],
			out = new Uint8Array(size ** 2 * 4);

		let c = document.createElement('[[::prime-elem;someElement]]');
		c.height = c.width = size;
		let gl = c.getContext('webgl');

		const createShader = (type, glslCode) => {
			let shader = gl.createShader(type);
			gl.shaderSource(shader, glslCode);
			gl.compileShader(shader);
			return shader;
		};

		let prg = gl.createProgram();

		gl.attachShader(prg, createShader(gl.VERTEX_SHADER, `
			attribute vec4 aVertices;
			void main(void) {
				[[::prime-var1;someVar]] = aVertices;
			}
		`));

		gl.attachShader(prg, createShader(gl.FRAGMENT_SHADER, `
			precision mediump float;
			[[::prime-kw;someKeyword]] int uColumns;
			void main(void) {
				int num = int(gl_FragCoord.y) * uColumns + int(gl_FragCoord.x);
				gl_FragColor.x = [[::prime-num1;0.0]];

				for (int i = 2; i < 1024; i++) {
					if (i >= num) {
						break;
					}

					if (num - (i * int(floor(float(num / i)))) == 0) {
						// the number is not prime
						gl_FragColor.x = 0.0;
						break;
					}
				}
			}
		`));

		gl.linkProgram(prg);
		gl.useProgram(prg);

		let location = gl.getAttribLocation(prg, '[[::prime-attr;someName]]');
		gl.bindBuffer(gl.ARRAY_BUFFER, gl.createBuffer());
		gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(plane), gl.STATIC_DRAW);
		gl.enableVertexAttribArray(location);
		gl.vertexAttribPointer(location, plane.length / 6, gl.FLOAT, false, 0, 0);
		gl.uniform1i(gl.getUniformLocation(prg, 'uColumns'), size);
		gl.[[::prime-func1;someFunc]](gl.TRIANGLES, 0, 6);
		gl.readPixels(0, 0, size, size, gl.RGBA, gl.UNSIGNED_BYTE, out);

		return [...out]
			.map((v, i) => i % 4 === 0 && v === 255 ? i >> 0b[[::prime-num3;0]] : 0)
			.filter(v => v !== 0 && v <= max)
			.splice(1);
	}
}

Assert 0/0

let inst = new JobSeeker();
console.assert(
	inst == 1 && inst == 3 && inst == 5
);
let inst = new JobSeeker();
console.assert(
	inst.calc(2)(2)(3)((x, y) => x + y) === 7
	&& inst.calc(1)(5)(2)((x, y) => x * y) === 10
	&& inst.calc(16)(8)((x, y) => x / y) === 2
);
let data;
console.assert(
	typeof (data = JSON.parse(new JobSeeker().data)) === "object"
	&& data.hasOwnProperty("\u{0030}")
	&& typeof Object.values(data)[0] === "object"
	&& Boolean(data[+false]) === false
);
let inst = new JobSeeker();
document.querySelector("#some-element").innerHTML = inst.seekerCard;
inst.getSeekerInfo().then(info => {
	console.assert(
		/^[А-Я][-а-я]+\s[А-Я]\.$/.test(info.get("name") || "")
		&& parseInt(info.get("age") || "0") >= 18
		&& /^[дгп]\.\s[А-Я][-А-Яа-я]+$/.test(info.get("city"))
		&& (info.get("skills") || "").split(",").filter(v => !!v).length >= 5
	);
});
let num = [1462, 3552, 4356, 6, 56766, 99];
let res = Array.from(new JobSeeker().getMod256(num));
console.assert(
	res.length === num.length
	&& res.every((v, i) => v === num[i] % 256)
);
console.assert(
	"0123456789" === new JobSeeker().correctHtml(`
		<div>0<b><span>1</span>2</b></div>
		<div>0<div><b><span>1</span>2</b><span>4</span>3</div></div>
		<div>5<span><b>6</b>7</span>8<span><b>8</b></span></div>
	`)
);
console.assert(
	String instanceof JobSeeker
	&& !("" instanceof JobSeeker)
	&& Number instanceof JobSeeker
	&& !(5 instanceof JobSeeker)
	&& {} instanceof JobSeeker
	&& [] instanceof JobSeeker
);
let inst = new JobSeeker();
let el = inst.getElement();
console.assert(
	el.offsetWidth === 100
	&& el.style.width === "200px"
	&& el.style.borderLeftWidth === "5px"
	&& el.offsetLeft === 0
	&& el.getBoundingClientRect().left > 20
	&& el.style.backgroundColor === "rgba(17, 34, 51, 0)"
);
let inst = new JobSeeker();
console.assert(
	inst.findPrimeNumbers(8) == "2,3,5,7"
	&& inst.findPrimeNumbers(31) == "2,3,5,7,11,13,17,19,23,29,31"
	&& inst.findPrimeNumbers(1000)[167] === 997
);

Проблема валидации

Подсвеченное в коде поле имеет недопустимое значение. Выполнить программу невозможно.

Уровень 1

Level