@pezkuwi/dev-test 0.85.3 → 0.85.7

package/cjs/env/jest.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jest = jest;
+const node_test_1 = require("node:test");
+const util_js_1 = require("../util.js");
+const JEST_KEYS_STUB = ['advanceTimersByTime', 'advanceTimersToNextTimer', 'autoMockOff', 'autoMockOn', 'clearAllMocks', 'clearAllTimers', 'createMockFromModule', 'deepUnmock', 'disableAutomock', 'doMock', 'dontMock', 'enableAutomock', 'fn', 'genMockFromModule', 'getRealSystemTime', 'getSeed', 'getTimerCount', 'isEnvironmentTornDown', 'isMockFunction', 'isolateModules', 'isolateModulesAsync', 'mock', 'mocked', 'now', 'replaceProperty', 'requireActual', 'requireMock', 'resetAllMocks', 'resetModules', 'restoreAllMocks', 'retryTimes', 'runAllImmediates', 'runAllTicks', 'runAllTimers', 'runOnlyPendingTimers', 'setMock', 'setSystemTime', 'setTimeout', 'spyOn', 'unmock', 'unstable_mockModule', 'useFakeTimers', 'useRealTimers'];
+const JEST_KEYS_WARN = ['setTimeout'];
+const MOCK_KEYS_STUB = ['_isMockFunction', 'getMockImplementation', 'getMockName', 'mock', 'mockClear', 'mockImplementation', 'mockImplementationOnce', 'mockName', 'mockRejectedValue', 'mockRejectedValueOnce', 'mockReset', 'mockResolvedValue', 'mockResolvedValueOnce', 'mockRestore', 'mockReturnThis', 'mockReturnValue', 'mockReturnValueOnce', 'withImplementation'];
+const jestStub = (0, util_js_1.stubObj)('jest', JEST_KEYS_STUB);
+const jestWarn = (0, util_js_1.warnObj)('jest', JEST_KEYS_WARN);
+const mockStub = (0, util_js_1.stubObj)('jest.fn()', MOCK_KEYS_STUB);
+/**
+ * @internal
+ *
+ * This adds the mockReset and mockRestore functionality to any
+ * spy or mock function
+ **/
+function extendMock(mocked) {
+    // We use the node:test mock here for casting below - however we
+    // don't want this in any method signature since this is a private
+    // types export, which could get us in "some" trouble
+    //
+    // Effectively the casts below ensure that our WithMock<*> aligns
+    // on a high-level to what we use via private type...
+    const spy = mocked;
+    return (0, util_js_1.enhanceObj)((0, util_js_1.enhanceObj)(mocked, {
+        mockImplementation: (fn) => {
+            spy.mock.mockImplementation(fn);
+        },
+        mockImplementationOnce: (fn) => {
+            spy.mock.mockImplementationOnce(fn);
+        },
+        mockReset: () => {
+            spy.mock.resetCalls();
+        },
+        mockRestore: () => {
+            spy.mock.restore();
+        }
+    }), mockStub);
+}
+/**
+ * Sets up the jest object. This is certainly not extensive, and probably
+ * not quite meant to be (never say never). Rather this adds the functionality
+ * that we use in the pezkuwi-js projects.
+ **/
+function jest() {
+    return {
+        jest: (0, util_js_1.enhanceObj)((0, util_js_1.enhanceObj)({
+            fn: (fn) => extendMock(node_test_1.mock.fn(fn)),
+            restoreAllMocks: () => {
+                node_test_1.mock.reset();
+            },
+            spyOn: (obj, key) => extendMock(node_test_1.mock.method(obj, key))
+        }, jestWarn), jestStub)
+    };
+}

package/cjs/env/lifecycle.d.ts

@@ -0,0 +1,12 @@
+import { after, afterEach, before, beforeEach } from 'node:test';
+/**
+ * This ensures that the before/after functions are exposed
+ **/
+export declare function lifecycle(): {
+    after: typeof after;
+    afterAll: typeof after;
+    afterEach: typeof afterEach;
+    before: typeof before;
+    beforeAll: typeof before;
+    beforeEach: typeof beforeEach;
+};

package/cjs/env/lifecycle.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lifecycle = lifecycle;
+const node_test_1 = require("node:test");
+/**
+ * This ensures that the before/after functions are exposed
+ **/
+function lifecycle() {
+    return {
+        after: node_test_1.after,
+        afterAll: node_test_1.after,
+        afterEach: node_test_1.afterEach,
+        before: node_test_1.before,
+        beforeAll: node_test_1.before,
+        beforeEach: node_test_1.beforeEach
+    };
+}

package/cjs/env/suite.d.ts

@@ -0,0 +1,20 @@
+type TestFn = (name: string, exec: () => void | Promise<void>, timeout?: number) => void;
+export interface Describe extends TestFn {
+    only: TestFn;
+    skip: TestFn;
+    todo: TestFn;
+}
+export interface It extends TestFn {
+    only: TestFn;
+    skip: TestFn;
+    todo: TestFn;
+}
+/**
+ * This ensures that the describe and it functions match our actual usages.
+ * This includes .only, .skip and .todo helpers (.each is not applied)
+ **/
+export declare function suite(): {
+    describe: Describe;
+    it: It;
+};
+export {};

package/cjs/env/suite.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.suite = suite;
+const node_test_1 = require("node:test");
+const util_js_1 = require("../util.js");
+const MINUTE = 60 * 1000;
+/**
+ * @internal
+ *
+ * Wraps either describe or it with relevant .only, .skip, .todo & .each helpers,
+ * shimming it into a Jest-compatible environment.
+ *
+ * @param {} fn
+ */
+function createWrapper(fn, defaultTimeout) {
+    const wrap = (opts) => (name, exec, timeout) => fn(name, { ...opts, timeout: (timeout || defaultTimeout) }, exec);
+    // Ensure that we have consistent helpers on the function. These are not consistently
+    // applied accross all node:test versions, latest has all, so always apply ours.
+    // Instead of node:test options for e.g. timeout, we provide a Jest-compatible signature
+    return (0, util_js_1.enhanceObj)(wrap({}), {
+        only: wrap({ only: true }),
+        skip: wrap({ skip: true }),
+        todo: wrap({ todo: true })
+    });
+}
+/**
+ * This ensures that the describe and it functions match our actual usages.
+ * This includes .only, .skip and .todo helpers (.each is not applied)
+ **/
+function suite() {
+    return {
+        describe: createWrapper(node_test_1.describe, 60 * MINUTE),
+        it: createWrapper(node_test_1.it, 2 * MINUTE)
+    };
+}

package/cjs/index.d.ts

@@ -0,0 +1 @@
+export {};

package/cjs/index.js

@@ -0,0 +1 @@
+throw new Error('Use node --require @pezkuwi/dev-test/{node, browser} depending on the required environment');

package/cjs/node.d.ts

@@ -0,0 +1 @@
+export {};

package/cjs/node.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("./env/index.js");
+(0, index_js_1.exposeEnv)(false);

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/cjs/packageInfo.d.ts

@@ -0,0 +1,6 @@
+export declare const packageInfo: {
+    name: string;
+    path: string;
+    type: string;
+    version: string;
+};

package/cjs/packageInfo.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageInfo = void 0;
+exports.packageInfo = { name: '@pezkuwi/dev-test', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '0.85.4' };

package/cjs/types.d.ts

@@ -0,0 +1,15 @@
+export type AnyFn = (...args: any[]) => any;
+export type BaseObj = Record<string, unknown>;
+export type BaseFn = Function;
+export type StubFn = (...args: unknown[]) => unknown;
+export type WithMock<F extends AnyFn> = F & {
+    mock: {
+        calls: {
+            arguments: unknown[];
+        }[];
+        mockImplementation: (fn: AnyFn) => void;
+        mockImplementationOnce: (fn: AnyFn) => void;
+        resetCalls: () => void;
+        restore: () => void;
+    };
+};

package/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/util.d.ts

@@ -0,0 +1,20 @@
+import type { BaseFn, BaseObj, StubFn } from './types.js';
+/**
+ * Extends an existing object with the additional function if they
+ * are not already existing.
+ */
+export declare function enhanceObj<T extends BaseObj | BaseFn, X>(obj: T, extra: X): T & Omit<X, keyof T>;
+/**
+ * Extends a given object with the named functions if they do not
+ * already exist on the object.
+ *
+ * @type {StubObjFn}
+ */
+export declare function stubObj<N extends readonly string[]>(objName: string, keys: N, alts?: Record<string, string>): { [K in N[number]]: StubFn; };
+/**
+ * Extends a given object with the named functions if they do not
+ * already exist on the object.
+ *
+ * @type {StubObjFn}
+ */
+export declare function warnObj<N extends readonly string[]>(objName: string, keys: N): { [K in N[number]]: StubFn; };

package/cjs/util.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enhanceObj = enhanceObj;
+exports.stubObj = stubObj;
+exports.warnObj = warnObj;
+/**
+ * Extends an existing object with the additional function if they
+ * are not already existing.
+ */
+function enhanceObj(obj, extra) {
+    Object
+        .entries(extra)
+        .forEach(([key, value]) => {
+        obj[key] ??= value;
+    });
+    return obj;
+}
+/**
+ * @internal
+ *
+ * A helper to create a stub object based wite the stub creator supplied
+ */
+function createStub(keys, creator) {
+    return keys.reduce((obj, key) => {
+        obj[key] ??= creator(key);
+        return obj;
+    }, {});
+}
+/**
+ * Extends a given object with the named functions if they do not
+ * already exist on the object.
+ *
+ * @type {StubObjFn}
+ */
+function stubObj(objName, keys, alts) {
+    return createStub(keys, (key) => () => {
+        const alt = alts?.[key];
+        throw new Error(`${objName}.${key} has not been implemented${alt ? ` (Use ${alt} instead)` : ''}`);
+    });
+}
+/**
+ * Extends a given object with the named functions if they do not
+ * already exist on the object.
+ *
+ * @type {StubObjFn}
+ */
+function warnObj(objName, keys) {
+    return createStub(keys, (key) => () => {
+        console.warn(`${objName}.${key} has been implemented as a noop`);
+    });
+}

package/env/browser.d.ts

@@ -0,0 +1,313 @@
+/**
+ * Export a very basic JSDom environment - this is just enough so we have
+ * @testing-environment/react tests passing in this repo
+ *
+ * FIXME: This approach is actually _explicitly_ discouraged by JSDOM - when
+ * using window you should run the tests inside that context, instead of just
+ * blindly relying on the globals as we do here
+ */
+export declare function browser(): {
+    HTMLAnchorElement: {
+        new (): HTMLAnchorElement;
+        prototype: HTMLAnchorElement;
+    };
+    HTMLAreaElement: {
+        new (): HTMLAreaElement;
+        prototype: HTMLAreaElement;
+    };
+    HTMLAudioElement: {
+        new (): HTMLAudioElement;
+        prototype: HTMLAudioElement;
+    };
+    HTMLBRElement: {
+        new (): HTMLBRElement;
+        prototype: HTMLBRElement;
+    };
+    HTMLBaseElement: {
+        new (): HTMLBaseElement;
+        prototype: HTMLBaseElement;
+    };
+    HTMLBodyElement: {
+        new (): HTMLBodyElement;
+        prototype: HTMLBodyElement;
+    };
+    HTMLButtonElement: {
+        new (): HTMLButtonElement;
+        prototype: HTMLButtonElement;
+    };
+    HTMLCanvasElement: {
+        new (): HTMLCanvasElement;
+        prototype: HTMLCanvasElement;
+    };
+    HTMLDListElement: {
+        new (): HTMLDListElement;
+        prototype: HTMLDListElement;
+    };
+    HTMLDataElement: {
+        new (): HTMLDataElement;
+        prototype: HTMLDataElement;
+    };
+    HTMLDataListElement: {
+        new (): HTMLDataListElement;
+        prototype: HTMLDataListElement;
+    };
+    HTMLDetailsElement: {
+        new (): HTMLDetailsElement;
+        prototype: HTMLDetailsElement;
+    };
+    HTMLDialogElement: {
+        new (): HTMLDialogElement;
+        readonly prototype: HTMLDialogElement;
+    };
+    HTMLDirectoryElement: {
+        new (): HTMLDirectoryElement;
+        prototype: HTMLDirectoryElement;
+    };
+    HTMLDivElement: {
+        new (): HTMLDivElement;
+        prototype: HTMLDivElement;
+    };
+    HTMLElement: {
+        new (): HTMLElement;
+        prototype: HTMLElement;
+    };
+    HTMLEmbedElement: {
+        new (): HTMLEmbedElement;
+        prototype: HTMLEmbedElement;
+    };
+    HTMLFieldSetElement: {
+        new (): HTMLFieldSetElement;
+        prototype: HTMLFieldSetElement;
+    };
+    HTMLFontElement: {
+        new (): HTMLFontElement;
+        prototype: HTMLFontElement;
+    };
+    HTMLFormElement: {
+        new (): HTMLFormElement;
+        prototype: HTMLFormElement;
+    };
+    HTMLFrameElement: {
+        new (): HTMLFrameElement;
+        prototype: HTMLFrameElement;
+    };
+    HTMLFrameSetElement: {
+        new (): HTMLFrameSetElement;
+        prototype: HTMLFrameSetElement;
+    };
+    HTMLHRElement: {
+        new (): HTMLHRElement;
+        prototype: HTMLHRElement;
+    };
+    HTMLHeadElement: {
+        new (): HTMLHeadElement;
+        prototype: HTMLHeadElement;
+    };
+    HTMLHeadingElement: {
+        new (): HTMLHeadingElement;
+        prototype: HTMLHeadingElement;
+    };
+    HTMLHtmlElement: {
+        new (): HTMLHtmlElement;
+        prototype: HTMLHtmlElement;
+    };
+    HTMLIFrameElement: {
+        new (): HTMLIFrameElement;
+        prototype: HTMLIFrameElement;
+    };
+    HTMLImageElement: {
+        new (): HTMLImageElement;
+        prototype: HTMLImageElement;
+    };
+    HTMLInputElement: {
+        new (): HTMLInputElement;
+        prototype: HTMLInputElement;
+    };
+    HTMLLIElement: {
+        new (): HTMLLIElement;
+        prototype: HTMLLIElement;
+    };
+    HTMLLabelElement: {
+        new (): HTMLLabelElement;
+        prototype: HTMLLabelElement;
+    };
+    HTMLLegendElement: {
+        new (): HTMLLegendElement;
+        prototype: HTMLLegendElement;
+    };
+    HTMLLinkElement: {
+        new (): HTMLLinkElement;
+        prototype: HTMLLinkElement;
+    };
+    HTMLMapElement: {
+        new (): HTMLMapElement;
+        prototype: HTMLMapElement;
+    };
+    HTMLMarqueeElement: {
+        new (): HTMLMarqueeElement;
+        prototype: HTMLMarqueeElement;
+    };
+    HTMLMediaElement: {
+        new (): HTMLMediaElement;
+        prototype: HTMLMediaElement;
+        readonly NETWORK_EMPTY: 0;
+        readonly NETWORK_IDLE: 1;
+        readonly NETWORK_LOADING: 2;
+        readonly NETWORK_NO_SOURCE: 3;
+        readonly HAVE_NOTHING: 0;
+        readonly HAVE_METADATA: 1;
+        readonly HAVE_CURRENT_DATA: 2;
+        readonly HAVE_FUTURE_DATA: 3;
+        readonly HAVE_ENOUGH_DATA: 4;
+    };
+    HTMLMenuElement: {
+        new (): HTMLMenuElement;
+        prototype: HTMLMenuElement;
+    };
+    HTMLMetaElement: {
+        new (): HTMLMetaElement;
+        prototype: HTMLMetaElement;
+    };
+    HTMLMeterElement: {
+        new (): HTMLMeterElement;
+        prototype: HTMLMeterElement;
+    };
+    HTMLModElement: {
+        new (): HTMLModElement;
+        prototype: HTMLModElement;
+    };
+    HTMLOListElement: {
+        new (): HTMLOListElement;
+        prototype: HTMLOListElement;
+    };
+    HTMLObjectElement: {
+        new (): HTMLObjectElement;
+        prototype: HTMLObjectElement;
+    };
+    HTMLOptGroupElement: {
+        new (): HTMLOptGroupElement;
+        prototype: HTMLOptGroupElement;
+    };
+    HTMLOptionElement: {
+        new (): HTMLOptionElement;
+        prototype: HTMLOptionElement;
+    };
+    HTMLOutputElement: {
+        new (): HTMLOutputElement;
+        prototype: HTMLOutputElement;
+    };
+    HTMLParagraphElement: {
+        new (): HTMLParagraphElement;
+        prototype: HTMLParagraphElement;
+    };
+    HTMLParamElement: {
+        new (): HTMLParamElement;
+        prototype: HTMLParamElement;
+    };
+    HTMLPictureElement: {
+        new (): HTMLPictureElement;
+        prototype: HTMLPictureElement;
+    };
+    HTMLPreElement: {
+        new (): HTMLPreElement;
+        prototype: HTMLPreElement;
+    };
+    HTMLProgressElement: {
+        new (): HTMLProgressElement;
+        prototype: HTMLProgressElement;
+    };
+    HTMLQuoteElement: {
+        new (): HTMLQuoteElement;
+        prototype: HTMLQuoteElement;
+    };
+    HTMLScriptElement: {
+        new (): HTMLScriptElement;
+        prototype: HTMLScriptElement;
+        supports(type: string): boolean;
+    };
+    HTMLSelectElement: {
+        new (): HTMLSelectElement;
+        prototype: HTMLSelectElement;
+    };
+    HTMLSlotElement: {
+        new (): HTMLSlotElement;
+        prototype: HTMLSlotElement;
+    };
+    HTMLSourceElement: {
+        new (): HTMLSourceElement;
+        prototype: HTMLSourceElement;
+    };
+    HTMLSpanElement: {
+        new (): HTMLSpanElement;
+        prototype: HTMLSpanElement;
+    };
+    HTMLStyleElement: {
+        new (): HTMLStyleElement;
+        prototype: HTMLStyleElement;
+    };
+    HTMLTableCaptionElement: {
+        new (): HTMLTableCaptionElement;
+        prototype: HTMLTableCaptionElement;
+    };
+    HTMLTableCellElement: {
+        new (): HTMLTableCellElement;
+        prototype: HTMLTableCellElement;
+    };
+    HTMLTableColElement: {
+        new (): HTMLTableColElement;
+        prototype: HTMLTableColElement;
+    };
+    HTMLTableElement: {
+        new (): HTMLTableElement;
+        prototype: HTMLTableElement;
+    };
+    HTMLTableRowElement: {
+        new (): HTMLTableRowElement;
+        prototype: HTMLTableRowElement;
+    };
+    HTMLTableSectionElement: {
+        new (): HTMLTableSectionElement;
+        prototype: HTMLTableSectionElement;
+    };
+    HTMLTemplateElement: {
+        new (): HTMLTemplateElement;
+        prototype: HTMLTemplateElement;
+    };
+    HTMLTextAreaElement: {
+        new (): HTMLTextAreaElement;
+        prototype: HTMLTextAreaElement;
+    };
+    HTMLTimeElement: {
+        new (): HTMLTimeElement;
+        prototype: HTMLTimeElement;
+    };
+    HTMLTitleElement: {
+        new (): HTMLTitleElement;
+        prototype: HTMLTitleElement;
+    };
+    HTMLTrackElement: {
+        new (): HTMLTrackElement;
+        prototype: HTMLTrackElement;
+        readonly NONE: 0;
+        readonly LOADING: 1;
+        readonly LOADED: 2;
+        readonly ERROR: 3;
+    };
+    HTMLUListElement: {
+        new (): HTMLUListElement;
+        prototype: HTMLUListElement;
+    };
+    HTMLUnknownElement: {
+        new (): HTMLUnknownElement;
+        prototype: HTMLUnknownElement;
+    };
+    HTMLVideoElement: {
+        new (): HTMLVideoElement;
+        prototype: HTMLVideoElement;
+    };
+    crypto: Crypto;
+    document: Document;
+    localStorage: Storage;
+    navigator: Navigator;
+    window: import("jsdom").DOMWindow;
+};

package/env/browser.js

@@ -0,0 +1,95 @@
+import { JSDOM } from 'jsdom';
+/**
+ * Export a very basic JSDom environment - this is just enough so we have
+ * @testing-environment/react tests passing in this repo
+ *
+ * FIXME: This approach is actually _explicitly_ discouraged by JSDOM - when
+ * using window you should run the tests inside that context, instead of just
+ * blindly relying on the globals as we do here
+ */
+export function browser() {
+    const { window } = new JSDOM('', { url: 'http://localhost' });
+    return {
+        // All HTML Elements that are defined on the JSDOM window object.
+        // (we copied as-is from the types definition). We cannot get this
+        // via Object.keys(window).filter(...) so we have to specify explicitly
+        HTMLAnchorElement: window.HTMLAnchorElement,
+        HTMLAreaElement: window.HTMLAreaElement,
+        HTMLAudioElement: window.HTMLAudioElement,
+        HTMLBRElement: window.HTMLBRElement,
+        HTMLBaseElement: window.HTMLBaseElement,
+        HTMLBodyElement: window.HTMLBodyElement,
+        HTMLButtonElement: window.HTMLButtonElement,
+        HTMLCanvasElement: window.HTMLCanvasElement,
+        HTMLDListElement: window.HTMLDListElement,
+        HTMLDataElement: window.HTMLDataElement,
+        HTMLDataListElement: window.HTMLDataListElement,
+        HTMLDetailsElement: window.HTMLDetailsElement,
+        HTMLDialogElement: window.HTMLDialogElement,
+        HTMLDirectoryElement: window.HTMLDirectoryElement,
+        HTMLDivElement: window.HTMLDivElement,
+        HTMLElement: window.HTMLElement,
+        HTMLEmbedElement: window.HTMLEmbedElement,
+        HTMLFieldSetElement: window.HTMLFieldSetElement,
+        HTMLFontElement: window.HTMLFontElement,
+        HTMLFormElement: window.HTMLFormElement,
+        HTMLFrameElement: window.HTMLFrameElement,
+        HTMLFrameSetElement: window.HTMLFrameSetElement,
+        HTMLHRElement: window.HTMLHRElement,
+        HTMLHeadElement: window.HTMLHeadElement,
+        HTMLHeadingElement: window.HTMLHeadingElement,
+        HTMLHtmlElement: window.HTMLHtmlElement,
+        HTMLIFrameElement: window.HTMLIFrameElement,
+        HTMLImageElement: window.HTMLImageElement,
+        HTMLInputElement: window.HTMLInputElement,
+        HTMLLIElement: window.HTMLLIElement,
+        HTMLLabelElement: window.HTMLLabelElement,
+        HTMLLegendElement: window.HTMLLegendElement,
+        HTMLLinkElement: window.HTMLLinkElement,
+        HTMLMapElement: window.HTMLMapElement,
+        HTMLMarqueeElement: window.HTMLMarqueeElement,
+        HTMLMediaElement: window.HTMLMediaElement,
+        HTMLMenuElement: window.HTMLMenuElement,
+        HTMLMetaElement: window.HTMLMetaElement,
+        HTMLMeterElement: window.HTMLMeterElement,
+        HTMLModElement: window.HTMLModElement,
+        HTMLOListElement: window.HTMLOListElement,
+        HTMLObjectElement: window.HTMLObjectElement,
+        HTMLOptGroupElement: window.HTMLOptGroupElement,
+        HTMLOptionElement: window.HTMLOptionElement,
+        HTMLOutputElement: window.HTMLOutputElement,
+        HTMLParagraphElement: window.HTMLParagraphElement,
+        HTMLParamElement: window.HTMLParamElement,
+        HTMLPictureElement: window.HTMLPictureElement,
+        HTMLPreElement: window.HTMLPreElement,
+        HTMLProgressElement: window.HTMLProgressElement,
+        HTMLQuoteElement: window.HTMLQuoteElement,
+        HTMLScriptElement: window.HTMLScriptElement,
+        HTMLSelectElement: window.HTMLSelectElement,
+        HTMLSlotElement: window.HTMLSlotElement,
+        HTMLSourceElement: window.HTMLSourceElement,
+        HTMLSpanElement: window.HTMLSpanElement,
+        HTMLStyleElement: window.HTMLStyleElement,
+        HTMLTableCaptionElement: window.HTMLTableCaptionElement,
+        HTMLTableCellElement: window.HTMLTableCellElement,
+        HTMLTableColElement: window.HTMLTableColElement,
+        HTMLTableElement: window.HTMLTableElement,
+        HTMLTableRowElement: window.HTMLTableRowElement,
+        HTMLTableSectionElement: window.HTMLTableSectionElement,
+        HTMLTemplateElement: window.HTMLTemplateElement,
+        HTMLTextAreaElement: window.HTMLTextAreaElement,
+        HTMLTimeElement: window.HTMLTimeElement,
+        HTMLTitleElement: window.HTMLTitleElement,
+        HTMLTrackElement: window.HTMLTrackElement,
+        HTMLUListElement: window.HTMLUListElement,
+        HTMLUnknownElement: window.HTMLUnknownElement,
+        HTMLVideoElement: window.HTMLVideoElement,
+        // normal service resumes, the base top-level names
+        crypto: window.crypto,
+        document: window.document,
+        localStorage: window.localStorage,
+        navigator: window.navigator,
+        // window...
+        window
+    };
+}