clickgo 6.9.0 → 6.11.0

package/test/tool-assets.mjs

@@ -1,64 +0,0 @@
-import assert from 'node:assert/strict';
-import { readFile } from 'node:fs/promises';
-import vm from 'node:vm';
-import { JSDOM } from 'jsdom';
-import ts from 'typescript';
-
-const dom = new JSDOM('<!doctype html><head></head><body></body>', { url: 'https://example.test/' });
-const source = await readFile(new URL('../dist/lib/tool.ts', import.meta.url), 'utf8');
-const tree = ts.createSourceFile('tool.ts', source, ts.ScriptTarget.ES2022, true);
-const names = new Set(['getHeadElement', 'loadScript', 'loadScripts', 'loadLink', 'loadLinks', 'loadAssets']);
-const nodes = tree.statements.filter(node =>
-    (ts.isVariableStatement(node) && node.declarationList.declarations.some(item => item.name.getText(tree) === 'headElement')) ||
-    (ts.isFunctionDeclaration(node) && node.body && names.has(node.name?.text)));
-const api = {};
-vm.runInNewContext(ts.transpileModule(nodes.map(node => node.getText(tree)).join('\n'), {
-    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 },
-}).outputText, { exports: api, document: dom.window.document });
-const head = dom.window.document.head;
-function finish(el, success = true) { el.dispatchEvent(new dom.window.Event(success ? 'load' : 'error')); }
-async function tick() { await new Promise(resolve => setImmediate(resolve)); }
-
-assert.equal(await api.loadAssets([]), true);
-assert.equal(head.children.length, 0);
-const urls = ['/base.js?file=theme.css', '/theme.CSS?version=1#dark', '/addon.js#theme.css', '/override.css#last'];
-const events = [];
-let complete = false;
-const loading = api.loadAssets(urls, { loaded: (url, state) => events.push([url, state]) }).then(value => { complete = true; return value; });
-const scripts = [...head.querySelectorAll('script')];
-const links = [...head.querySelectorAll('link')];
-assert.equal(scripts.length, 2);
-assert.equal(links.length, 2);
-assert.equal(head.children.length, 4, 'all JS and CSS requests start before awaiting a resource');
-assert.deepEqual(scripts.map(el => el.getAttribute('src')), [urls[0], urls[2]], 'query/hash values do not change the resource type');
-assert.deepEqual(links.map(el => el.getAttribute('href')), [urls[1], urls[3]], 'CSS insertion order and original URLs are preserved');
-assert.ok(scripts.every(el => el.async === false), 'unified loader uses browser ordered script execution');
-finish(scripts[1]); finish(links[1]); finish(links[0]);
-await tick();
-assert.equal(complete, false, 'the aggregate waits for every file, regardless of completion order');
-finish(scripts[0]);
-assert.equal(await loading, true);
-assert.deepEqual(events.map(([url, state]) => `${url}:${state}`).sort(), urls.map(url => `${url}:1`).sort(), 'each resource reports its own result once');
-
-head.replaceChildren();
-const cssFailed = api.loadAssets(['/ok.js', '/missing.css']);
-finish(head.querySelector('link'), false);
-finish(head.querySelector('script'));
-assert.equal(await cssFailed, false, 'CSS errors affect the aggregate result');
-head.replaceChildren();
-const jsFailed = api.loadAssets(['/missing.js', '/ok.css']);
-finish(head.querySelector('script'), false);
-finish(head.querySelector('link'));
-assert.equal(await jsFailed, false, 'JS errors affect the aggregate result');
-head.replaceChildren();
-const legacy = api.loadScript('/legacy.js');
-assert.equal(head.querySelector('script').async, true, 'existing single-script loading retains async behavior');
-finish(head.querySelector('script'));
-assert.equal(await legacy, true);
-head.replaceChildren();
-const batch = api.loadScripts(['/legacy-a.js', '/legacy-b.js']);
-assert.ok([...head.querySelectorAll('script')].every(el => el.async === true), 'existing script batches retain async behavior by default');
-for (const el of head.querySelectorAll('script')) finish(el);
-await batch;
-dom.window.close();
-console.log('Unified asset loading, URL classification, order, concurrency, callbacks, errors and legacy behavior passed.');

package/test/tool-clone.mjs

@@ -1,42 +0,0 @@
-// Run after TypeScript compilation: node test/tool-clone.mjs
-import assert from 'node:assert/strict';
-import { clone } from '../dist/lib/tool.js';
-
-const shared = { 'value': 1 };
-const source = {
-    'map': new Map(),
-    'set': new Set(),
-    shared,
-    'alias': shared,
-    'date': new Date('2026-09-20T00:00:00.000Z'),
-};
-source.self = source;
-source.map.set(shared, source);
-source.set.add(shared);
-source.set.add(source);
-
-const first = clone(source);
-const second = clone(source);
-
-assert.notEqual(first, source);
-assert.notEqual(first, second);
-assert(first.map instanceof Map);
-assert(first.set instanceof Set);
-assert.notEqual(first.map, source.map);
-assert.notEqual(first.map, second.map);
-assert.notEqual(first.set, source.set);
-assert.notEqual(first.set, second.set);
-assert.equal(first.self, first);
-assert.equal(first.shared, first.alias);
-assert.notEqual(first.shared, shared);
-assert.equal(first.map.get(first.shared), first);
-assert(first.set.has(first.shared));
-assert(first.set.has(first));
-assert(first.date instanceof Date);
-assert.notEqual(first.date, source.date);
-assert.equal(first.date.getTime(), source.date.getTime());
-
-first.map.set('only-first', true);
-assert.equal(second.map.has('only-first'), false);
-
-console.log('Tool clone Map/Set, circular-reference and instance-isolation checks passed.');

package/test/toolbox.mjs

@@ -1,88 +0,0 @@
-// Run after TypeScript compilation: node --experimental-vm-modules test/toolbox.mjs
-import assert from 'node:assert/strict';
-import { readFile } from 'node:fs/promises';
-import { SourceTextModule, SyntheticModule } from 'node:vm';
-import { JSDOM } from 'jsdom';
-
-const dom = new JSDOM('<div id="tools"></div>');
-globalThis.HTMLElement = dom.window.HTMLElement;
-const tools = dom.window.document.getElementById('tools');
-class AbstractControl {
-    constructor() {
-        this.refs = { tools };
-        this.emitted = [];
-    }
-    emit(name, value) {
-        this.emitted.push([name, value]);
-    }
-    propNumber(name) {
-        return Number(this.props[name]);
-    }
-    watch(name, callback, options) {
-        if (options?.immediate) {
-            callback();
-        }
-    }
-}
-const clickgo = new SyntheticModule(['control'], function() {
-    this.setExport('control', { AbstractControl });
-});
-const mod = new SourceTextModule(await readFile(new URL('../dist/sources/control/toolbox/code.js', import.meta.url), 'utf8'));
-await mod.link(() => clickgo);
-await mod.evaluate();
-const Toolbox = mod.namespace.default;
-const toolbox = new Toolbox();
-toolbox.props.columns = '2';
-toolbox.onMounted();
-assert.equal(toolbox.columnsData, 2);
-toolbox.toggleColumns();
-assert.equal(toolbox.columnsData, 1);
-assert.deepEqual(toolbox.emitted, [['update:columns', 1]]);
-
-function button(x, y, { disabled = false, hidden = false } = {}) {
-    const item = dom.window.document.createElement('div');
-    item.setAttribute('data-cg-control', 'button');
-    item.setAttribute('role', 'button');
-    item.setAttribute('tabindex', '0');
-    if (disabled) {
-        item.setAttribute('data-cg-disabled', '');
-    }
-    Object.defineProperty(item, 'offsetHeight', { 'value': hidden ? 0 : 24 });
-    item.getBoundingClientRect = () => ({ 'left': x, 'top': y, 'width': 24, 'height': 24 });
-    tools.append(item);
-    return item;
-}
-// A one-tool group precedes a two-column group; DOM index arithmetic would pick the wrong row.
-const browse = button(0, 0);
-const paint = button(0, 40);
-const erase = button(30, 40);
-button(0, 80, { 'disabled': true });
-button(30, 80, { 'hidden': true });
-const select = button(0, 120);
-
-function move(from, key, expected) {
-    from.focus();
-    let prevented = false;
-    toolbox.keydown({ 'target': from, key, 'preventDefault': () => { prevented = true; } });
-    assert.equal(prevented, true);
-    assert.equal(dom.window.document.activeElement, expected, key);
-}
-move(browse, 'ArrowDown', paint);
-move(paint, 'ArrowRight', erase);
-move(erase, 'ArrowLeft', paint);
-move(paint, 'ArrowDown', select);
-move(select, 'Home', browse);
-move(browse, 'End', select);
-move(browse, 'ArrowUp', browse);
-
-// RTL changes the rendered physical positions; navigation must follow those positions.
-paint.getBoundingClientRect = () => ({ 'left': 30, 'top': 40, 'width': 24, 'height': 24 });
-erase.getBoundingClientRect = () => ({ 'left': 0, 'top': 40, 'width': 24, 'height': 24 });
-move(paint, 'ArrowLeft', erase);
-move(erase, 'ArrowRight', paint);
-
-const outside = dom.window.document.createElement('div');
-outside.setAttribute('data-cg-control', 'button');
-outside.setAttribute('role', 'button');
-toolbox.keydown({ 'target': outside, 'key': 'ArrowDown', 'preventDefault': () => assert.fail('header/outside buttons are not tools') });
-console.log('Toolbox column binding and keyboard navigation across groups, hidden/disabled tools and RTL passed.');

package/test/tuieditor-locale.mjs

@@ -1,175 +0,0 @@
-import assert from 'node:assert/strict';
-import { readFile } from 'node:fs/promises';
-import vm from 'node:vm';
-import { setImmediate } from 'node:timers/promises';
-import ts from 'typescript';
-import { JSDOM } from 'jsdom';
-
-const source = await readFile(new URL('../dist/sources/control/tuieditor/code.ts', import.meta.url), 'utf8');
-const compiled = ts.transpileModule(source, {
-    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022, esModuleInterop: false },
-}).outputText;
-const dom = new JSDOM('<!doctype html><html><body></body></html>');
-const { document } = dom.window;
-const requests = [];
-const editors = [];
-function deferred() {
-    let resolve;
-    let reject;
-    const promise = new Promise((yes, no) => { resolve = yes; reject = no; });
-    return { promise, resolve, reject };
-}
-class AbstractControl {
-    get locale() { return this.testLocale; }
-    propBoolean(name) { return this.props[name] === true; }
-    watch(name, callback, options) {
-        this.watches.set(name, callback);
-        if (options?.immediate) callback();
-    }
-    emit() {}
-}
-class Editor {
-    constructor(options) {
-        this.options = options;
-        this.i18n = { get: key => key };
-        options.el.appendChild(document.createElement('div'));
-        editors.push(this);
-    }
-    insertToolbarItem() {}
-}
-let main;
-const clickgo = {
-    modules: {},
-    getCdn: () => 'https://cdn.example',
-    getDirname: () => 'https://app.example/clickgo',
-    core: { getModule: () => main },
-    control: { AbstractControl },
-    tool: {
-        loadScript(url) {
-            const pending = deferred();
-            requests.push({ url, ...pending });
-            return pending.promise;
-        },
-    },
-    dom: { createElement: name => document.createElement(name), watchStyle() {} },
-};
-// Build the actual shared module once, then evaluate controls independently as different tasks do.
-const coreSource = await readFile(new URL('../dist/lib/core.ts', import.meta.url), 'utf8');
-const tree = ts.createSourceFile('core.ts', coreSource, ts.ScriptTarget.ES2022, true);
-const names = new Set(['getModule', 'loadModule']);
-const selected = tree.statements.filter(node =>
-    (ts.isVariableStatement(node) && node.declarationList.declarations.some(item => item.name.getText(tree) === 'modules')) ||
-    (ts.isFunctionDeclaration(node) && node.body && names.has(node.name?.text)));
-const core = {};
-vm.runInNewContext(ts.transpileModule(selected.map(node => node.getText(tree)).join('\n'), {
-    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022, esModuleInterop: false },
-}).outputText, {
-    exports: core, window: { toastui: { Editor } }, clickgo,
-    lTool: { ...clickgo.tool, loadAssets: async () => true, loadStyle() {}, urlResolve: (base, path) => new URL(path, base).href },
-});
-const shared = await core.getModule('@toast-ui/editor');
-main = Promise.resolve(shared);
-function loadControl() {
-    const exports = {};
-    vm.runInNewContext(compiled, { exports, require: () => clickgo });
-    return exports.default;
-}
-let Control = loadControl();
-function create(locale) {
-    const control = new Control();
-    control.testLocale = locale;
-    control.watches = new Map();
-    control.element = document.createElement('div');
-    const content = document.createElement('div');
-    const pop = document.createElement('div');
-    control.element.append(content, pop);
-    control.refs = { content, pop };
-    document.body.appendChild(control.element);
-    return control;
-}
-await create('en').onMounted();
-await create('ar').onMounted();
-assert.equal(requests.length, 0, 'English and unsupported languages need no locale scripts');
-assert.equal(editors.at(-1).options.language, 'en');
-assert.equal(editors.at(-1).options.el.dir, 'rtl');
-
-const base = deferred();
-main = base.promise;
-const first = create('sc');
-Control = loadControl();
-const second = create('sc');
-const a = first.onMounted();
-const b = second.onMounted();
-assert.equal(requests.length, 0, 'locale registration waits for the main library');
-base.resolve(shared);
-await setImmediate();
-assert.equal(requests.length, 1, 'independent task control modules share one pending language request');
-assert.ok(requests[0].url.endsWith('/i18n/zh-cn.min.js'));
-assert.equal(editors.length, 2, 'instances wait until their locale is registered');
-requests[0].resolve(true);
-await Promise.all([a, b]);
-assert.equal(first.access.tuieditor.options.language, 'zh-CN');
-assert.equal(second.access.tuieditor.options.language, 'zh-CN');
-assert.notEqual(first.access.tuieditor, second.access.tuieditor);
-await create('sc').onMounted();
-assert.equal(requests.length, 1, 'ready locale scripts are reused across task control modules');
-
-Control = loadControl();
-await create('sc').onMounted();
-assert.equal(requests.length, 1, 'a later task reuses the same completed language request');
-
-first.testLocale = 'ja';
-first.watches.get('locale')();
-assert.equal(requests.length, 1, 'changing task locale does not reload an existing editor');
-assert.equal(first.access.tuieditor.options.language, 'zh-CN');
-main = Promise.resolve(shared);
-const japanese = create('ja');
-const c = japanese.onMounted();
-await setImmediate();
-assert.ok(requests.at(-1).url.endsWith('/i18n/ja-jp.min.js'));
-requests.at(-1).resolve(true);
-await c;
-assert.equal(japanese.access.tuieditor.options.language, 'ja-JP', 'new editors use the current task language');
-
-const french = create('fr');
-const d = french.onMounted();
-await setImmediate();
-requests.at(-1).resolve(false);
-await d;
-assert.equal(french.access.tuieditor.options.language, 'en', 'locale failure falls back without disabling editing');
-const beforeRetry = requests.length;
-const retry = create('fr').onMounted();
-await setImmediate();
-assert.equal(requests.length, beforeRetry + 1, 'failed locale requests can be retried');
-requests.at(-1).resolve(true);
-await retry;
-assert.equal(editors.at(-1).options.language, 'fr-FR');
-
-const rejected = shared.loadLanguage('de-DE');
-const rejectedWaiter = shared.loadLanguage('de-de');
-requests.at(-1).reject(new Error('external loader rejected'));
-assert.equal(await rejected, false);
-assert.equal(await rejectedWaiter, false, 'external loader errors release all waiters');
-const rejectedRetry = shared.loadLanguage('de-DE');
-requests.at(-1).resolve(true);
-assert.equal(await rejectedRetry, true, 'external errors do not poison the shared cache');
-
-const removed = create('tc');
-const e = removed.onMounted();
-await setImmediate();
-assert.ok(requests.at(-1).url.endsWith('/i18n/zh-tw.min.js'));
-removed.element.remove();
-const count = editors.length;
-requests.at(-1).resolve(true);
-await e;
-assert.equal(editors.length, count, 'removed hosts do not receive late editor instances');
-
-Control = loadControl();
-main = Promise.resolve(null);
-const missing = create('sc');
-const beforeMissing = requests.length;
-await missing.onMounted();
-assert.equal(missing.notInit, true);
-assert.equal(missing.isLoading, false);
-assert.equal(requests.length, beforeMissing, 'a missing main library triggers no locale request');
-console.log('Toast UI cross-task locale requests, reuse, fallback, retries and initialization language passed.');

package/test/vflow.mjs

@@ -1,122 +0,0 @@
-import assert from 'node:assert/strict';
-import { readFile } from 'node:fs/promises';
-import vm from 'node:vm';
-import { JSDOM } from 'jsdom';
-import ts from 'typescript';
-import { getClassPrototype, lang } from '../dist/lib/tool.js';
-
-const dom = new JSDOM('<!doctype html><html><body></body></html>');
-for (const name of ['window', 'document', 'Element', 'HTMLElement', 'SVGElement', 'Node']) {
-    Object.defineProperty(globalThis, name, { configurable: true, value: dom.window[name] });
-}
-Object.defineProperties(HTMLElement.prototype, {
-    offsetWidth: { configurable: true, get: () => 80 },
-    offsetHeight: { configurable: true, get: () => 20 },
-});
-const { createApp, reactive, nextTick, h } = await import('vue');
-const state = reactive({ locale: 'en', direction: 'h', count: 2 });
-const errors = [];
-const watched = [];
-process.on('unhandledRejection', error => { errors.push(error); });
-
-// Keep the framework's computed $el access and component-root mounting order.
-class AbstractControl {
-    get element() { return this.$el; }
-    get locale() { return state.locale; }
-    get localeDirection() { return lang.getDirection(this.locale); }
-    nextTick() { return this.$nextTick(); }
-    watch(...args) { return this.$watch(...args); }
-    emit(...args) { this.$emit(...args); }
-    propInt(name) { return parseInt(this.props[name]); }
-}
-const clickgo = {
-    control: { AbstractControl },
-    dom: {
-        isRtl: el => el instanceof Element && dom.window.getComputedStyle(el).direction === 'rtl',
-        watchStyle: (el, names, callback, immediate) => {
-            assert.ok(el instanceof HTMLElement && el.isConnected, 'style watcher needs a mounted element');
-            watched.push(el);
-            if (immediate) {
-                for (const name of names) callback(name, name === 'font' ? '13px sans-serif' : '0px');
-            }
-        },
-        watchSize() {},
-        unwatchSize() {},
-    },
-};
-const source = await readFile(new URL('../dist/sources/control/vflow/code.ts', import.meta.url), 'utf8');
-const exports = {};
-vm.runInNewContext(ts.transpileModule(source, {
-    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 },
-}).outputText, { exports, require: () => clickgo });
-const instance = new exports.default();
-const prototype = getClassPrototype(instance);
-const layout = await readFile(new URL('../dist/sources/control/vflow/layout.html', import.meta.url), 'utf8');
-const Flow = {
-    template: '<div><slot /></div>',
-    mounted() { this.$emit('clientwidth', 200); this.$emit('clientheight', 100); },
-};
-const Vflow = {
-    template: layout,
-    components: { 'cg-flow': Flow },
-    props: Object.fromEntries(Object.entries(instance.props).map(([name, value]) => [name, {
-        default: () => structuredClone(value),
-    }])),
-    emits: instance.emits,
-    data: () => Object.fromEntries(Object.entries(instance).filter(([name]) => !['props', 'emits'].includes(name))),
-    computed: prototype.access,
-    methods: prototype.method,
-    created() { this.props = this.$props; },
-    async mounted() { await this.$nextTick(); this.onMounted(); },
-};
-const host = document.createElement('div');
-document.body.append(host);
-const app = createApp({
-    render() {
-        return h('div', { dir: lang.getDirection(state.locale) }, [
-            h(Vflow, { ref: 'flow', data: state.count, direction: state.direction }, {
-                default: item => h('span', `Line ${item.row}`),
-            }),
-        ]);
-    },
-});
-app.config.errorHandler = error => { errors.push(error); };
-const root = app.mount(host);
-
-/** --- Drain Vue render, mount and deferred item-size work. --- */
-async function flush() {
-    for (let i = 0; i < 10; ++i) await nextTick();
-    await new Promise(resolve => setImmediate(resolve));
-    assert.deepEqual(errors, [], 'Vflow must mount/update without runtime errors');
-}
-await flush();
-assert.equal(watched.length, 1);
-assert.equal(root.$refs.flow.element, host.querySelector('[direction]'));
-assert.equal(root.$refs.flow.length, 160);
-assert.equal(root.$refs.flow.isRtl, false);
-assert.equal(host.querySelector('.item').style.left, '0px');
-state.count = 102;
-await flush();
-assert.equal(root.$refs.flow.pos.length, 102);
-assert.ok(host.querySelectorAll('.item').length < 102, 'only visible items are rendered');
-state.locale = 'ar';
-await flush();
-assert.equal(root.$refs.flow.isRtl, true);
-assert.equal(host.querySelector('.item').style.left, '');
-assert.equal(host.querySelector('.item').style.right, '0px');
-state.direction = 'v';
-await flush();
-assert.equal(root.$refs.flow.isRtl, false);
-assert.equal(root.$refs.flow.length, 2040);
-state.count = 0;
-await flush();
-assert.equal(root.$refs.flow.pos.length, 0);
-state.count = 2;
-state.direction = 'h';
-state.locale = 'en';
-await flush();
-assert.equal(root.$refs.flow.length, 160);
-assert.equal(host.querySelector('.item').style.left, '0px');
-app.unmount();
-await flush();
-console.log('Vflow real Vue mount, virtualization, data/direction updates and live RTL switching passed.');

package/test/web-drag-mask.mjs

@@ -1,96 +0,0 @@
-// Run: node --experimental-vm-modules test/web-drag-mask.mjs
-import assert from 'node:assert/strict';
-import { readFile } from 'node:fs/promises';
-import { SourceTextModule, SyntheticModule } from 'node:vm';
-import { JSDOM } from 'jsdom';
-import ts from 'typescript';
-
-const dom = new JSDOM('<!doctype html><html><head></head><body></body></html>');
-for (const name of ['window', 'document', 'Element', 'SVGElement', 'Node', 'HTMLElement']) {
-    globalThis[name] = dom.window[name];
-}
-globalThis.getComputedStyle = dom.window.getComputedStyle.bind(dom.window);
-const { createApp, compile, reactive, nextTick } = await import('vue');
-const pointer = await import('@litert/pointer');
-const state = reactive({ move: false });
-const clickgo = new SyntheticModule(['control', 'dom'], function() {
-    this.setExport('control', { AbstractControl: class {} });
-    this.setExport('dom', { is: state });
-});
-const source = await readFile(new URL('../dist/sources/control/web/code.ts', import.meta.url), 'utf8');
-const web = new SourceTextModule(ts.transpileModule(source, {
-    compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.ESNext },
-}).outputText);
-await web.link(() => clickgo);
-await web.evaluate();
-const control = new web.namespace.default();
-
-// Exercise the actual launcher hooks with the installed Pointer library.
-const launcher = await readFile(new URL('../dist/clickgo.ts', import.meta.url), 'utf8');
-const hookSource = launcher.match(/    modules\.pointer\.addMoveHook\('down',[\s\S]*?    modules\.pointer\.addMoveHook\('up',[\s\S]*?    \}\);/)[0];
-const hooks = new SourceTextModule(`import { pointer, is } from 'bridge';
-    const modules = { pointer }; const lDom = { is }; ${hookSource}`);
-const bridge = new SyntheticModule(['pointer', 'is'], function() {
-    this.setExport('pointer', pointer);
-    this.setExport('is', state);
-});
-await hooks.link(() => bridge);
-await hooks.evaluate();
-
-const template = await readFile(new URL('../dist/sources/control/web/layout.html', import.meta.url), 'utf8');
-const host = document.createElement('div');
-document.body.append(host);
-const app = createApp({
-    render: compile(template),
-    data: () => ({ src: 'about:blank' }),
-    computed: { showMask: () => control.showMask },
-});
-app.mount(host);
-const iframe = host.querySelector('iframe');
-const mask = host.querySelector('.mask');
-assert.equal(iframe.getAttribute('src'), 'about:blank');
-assert.equal(mask.style.display, 'none');
-
-function event(type, x, y) {
-    const e = new dom.window.Event(type, { bubbles: true, cancelable: true });
-    Object.assign(e, { clientX: x, clientY: y, pointerId: 1, pointerType: 'mouse', button: 0 });
-    return e;
-}
-
-for (const operation of ['move', 'resize']) {
-    for (const finish of ['pointerup', 'pointercancel']) {
-        let updates = 0;
-        const handle = document.createElement('div');
-        document.body.append(handle);
-        handle.addEventListener('pointerdown', e => {
-            if (operation === 'resize') {
-                pointer.resize(e, {
-                    border: 'rb', objectLeft: 0, objectTop: 0,
-                    objectWidth: 400, objectHeight: 300,
-                    move: () => { ++updates; },
-                });
-            }
-            else {
-                pointer.move(e, { move: () => { ++updates; } });
-            }
-        });
-        handle.dispatchEvent(event('pointerdown', 400, 300));
-        await nextTick();
-        assert.equal(state.move, true);
-        assert.notEqual(mask.style.display, 'none');
-        mask.dispatchEvent(event('pointermove', 350, 250));
-        mask.dispatchEvent(event('pointermove', 320, 230));
-        assert.equal(updates, 2);
-        mask.dispatchEvent(event(finish, 320, 230));
-        await nextTick();
-        assert.equal(state.move, false);
-        assert.equal(mask.style.display, 'none');
-        mask.dispatchEvent(event('pointermove', 300, 200));
-        assert.equal(updates, 2);
-        assert.equal(host.querySelector('iframe'), iframe);
-        handle.remove();
-    }
-}
-app.unmount();
-dom.window.close();
-console.log('WEB drag/resize mask, pointerup/cancel cleanup and iframe preservation checks passed.');