quickwin 1.0.0

package/lib/text-codec.ts

@@ -0,0 +1,171 @@
+export {} // make this a module so declare global works
+
+declare global {
+    interface TextDecoder<T extends _Label | undefined = _Label | undefined> extends TextDecoderImpl<T> {}
+    var TextDecoder: typeof TextDecoderImpl
+
+    interface TextEncoder<T extends _Label | undefined = _Label | undefined> extends TextEncoderImpl<T> {}
+    var TextEncoder: typeof TextEncoderImpl
+}
+
+const _labelMap = {
+    'utf-8': 'utf-8',
+    'utf8': 'utf-8',
+    'unicode-1-1-utf-8': 'utf-8',
+    'utf-16': 'utf-16le',
+    'utf-16le': 'utf-16le',
+    'utf-16be': 'utf-16be',
+} as const
+
+type _Label = keyof typeof _labelMap
+type _Encoding = typeof _labelMap[_Label]
+type _Result<T> = T extends _Label ? typeof _labelMap[T] : 'utf-8'
+
+function _normalizeLabel<T extends _Label | undefined>(label: T): _Result<T> {
+    if (!label) return 'utf-8' as _Result<T>
+    const result = _labelMap[label.trim().toLowerCase() as _Label]
+    if (result) return result as _Result<T>
+    throw new RangeError(`The encoding label "${label}" is not supported`)
+}
+
+function _decodeUTF8(buf: Uint8Array, fatal: boolean): string {
+    let out = ''
+    for (let i = 0; i < buf.length; ) {
+        const b = buf[i++]!
+        if (b < 0x80) { out += String.fromCharCode(b); continue }
+        if (b < 0xC0) { out += fatal ? (() => { throw new TypeError('unexpected continuation byte') })() : '\uFFFD'; continue }
+        let c: number, min: number
+        if (b < 0xE0) {
+            if (i >= buf.length) { out += fatal ? (() => { throw new TypeError('incomplete utf-8') })() : '\uFFFD'; break }
+            const b2 = buf[i++]!
+            if ((b2 & 0xC0) !== 0x80) { out += '\uFFFD'; continue }
+            c = ((b & 0x1F) << 6) | (b2 & 0x3F)
+            min = 0x80
+        } else if (b < 0xF0) {
+            if (i + 1 >= buf.length) { out += fatal ? (() => { throw new TypeError('incomplete utf-8') })() : '\uFFFD'; break }
+            const b2 = buf[i++]!; const b3 = buf[i++]!
+            if (((b2 & 0xC0) !== 0x80) || ((b3 & 0xC0) !== 0x80)) { out += '\uFFFD'; continue }
+            c = ((b & 0x0F) << 12) | ((b2 & 0x3F) << 6) | (b3 & 0x3F)
+            min = 0x800
+        } else if (b < 0xF8) {
+            if (i + 2 >= buf.length) { out += fatal ? (() => { throw new TypeError('incomplete utf-8') })() : '\uFFFD'; break }
+            const b2 = buf[i++]!; const b3 = buf[i++]!; const b4 = buf[i++]!
+            if (((b2 & 0xC0) !== 0x80) || ((b3 & 0xC0) !== 0x80) || ((b4 & 0xC0) !== 0x80)) { out += '\uFFFD'; continue }
+            c = ((b & 0x07) << 18) | ((b2 & 0x3F) << 12) | ((b3 & 0x3F) << 6) | (b4 & 0x3F)
+            min = 0x10000
+        } else { out += fatal ? (() => { throw new TypeError('invalid utf-8 start') })() : '\uFFFD'; continue }
+        if (c < min || (c >= 0xD800 && c <= 0xDFFF) || c > 0x10FFFF) {
+            out += fatal ? (() => { throw new TypeError('invalid utf-8 codepoint') })() : '\uFFFD'; continue
+        }
+        if (c <= 0xFFFF) out += String.fromCharCode(c)
+        else { c -= 0x10000; out += String.fromCharCode(0xD800 | (c >> 10), 0xDC00 | (c & 0x3FF)) }
+    }
+    return out
+}
+
+function _decodeUTF16(buf: Uint8Array, le: boolean, fatal: boolean): string {
+    const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength)
+    let out = ''
+    for (let i = 0; i + 1 < buf.length; i += 2) {
+        let c = dv.getUint16(i, le)
+        if (c >= 0xD800 && c <= 0xDBFF) {
+            i += 2
+            if (i + 1 >= buf.length) {
+                out += fatal ? (() => { throw new TypeError('truncated surrogate pair') })() : '\uFFFD'; break
+            }
+            const c2 = dv.getUint16(i, le)
+            if (c2 >= 0xDC00 && c2 <= 0xDFFF) {
+                out += String.fromCharCode(c, c2)
+            } else {
+                out += fatal ? (() => { throw new TypeError('invalid surrogate pair') })() : '\uFFFD'
+                i -= 2
+            }
+        } else if (c >= 0xDC00 && c <= 0xDFFF) {
+            out += fatal ? (() => { throw new TypeError('unexpected trailing surrogate') })() : '\uFFFD'
+        } else {
+            out += String.fromCharCode(c)
+        }
+    }
+    return out
+}
+
+class TextDecoderImpl<T extends _Label | undefined = _Label | undefined> {
+    _encoding: _Encoding
+    _fatal: boolean
+    _ignoreBOM: boolean
+
+    constructor(label?: T, options?: { fatal?: boolean, ignoreBOM?: boolean }) {
+        this._encoding = _normalizeLabel(label)
+        this._fatal = options?.fatal ?? false
+        this._ignoreBOM = options?.ignoreBOM ?? false
+    }
+
+    get encoding(): _Result<T> { return this._encoding as _Result<T> }
+    get fatal(): boolean { return this._fatal }
+    get ignoreBOM(): boolean { return this._ignoreBOM }
+
+    decode(buffer?: ArrayBufferView | ArrayBuffer | null): string {
+        if (!buffer) return ''
+        const arr = buffer instanceof Uint8Array ? buffer
+            : buffer instanceof ArrayBuffer ? new Uint8Array(buffer)
+            : new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength)
+
+        if (this._encoding === 'utf-8') {
+            return _decodeUTF8(arr, this._fatal)
+        }
+
+        const le = this._encoding === 'utf-16le'
+        let offset = 0
+
+        if (arr.length >= 2 && !this._ignoreBOM) {
+            const bomLo = le ? arr[0]! : arr[1]!
+            const bomHi = le ? arr[1]! : arr[0]!
+            const bom = (bomHi << 8) | bomLo
+            if (bom === 0xFEFF || bom === 0xFFFE) {
+                offset = 2
+            }
+        }
+
+        return _decodeUTF16(arr.slice(offset), le, this._fatal)
+    }
+}
+
+class TextEncoderImpl<T extends _Label | undefined = _Label | undefined> {
+    _encoding: _Encoding
+
+    constructor(label?: T) {
+        this._encoding = _normalizeLabel(label)
+    }
+
+    get encoding(): _Result<T> { return this._encoding as _Result<T> }
+
+    encode(input?: string): Uint8Array<ArrayBuffer> {
+        if (!input) return new Uint8Array(0)
+
+        if (this._encoding === 'utf-8') {
+            const bytes: number[] = []
+            for (let i = 0; i < input.length; i++) {
+                let c = input.charCodeAt(i)
+                if (c < 0x80) { bytes.push(c) }
+                else if (c < 0x800) { bytes.push(0xC0 | (c >> 6), 0x80 | (c & 0x3F)) }
+                else if (c < 0xD800 || c >= 0xE000) { bytes.push(0xE0 | (c >> 12), 0x80 | ((c >> 6) & 0x3F), 0x80 | (c & 0x3F)) }
+                else { i++; const c2 = input.charCodeAt(i); c = 0x10000 + ((c & 0x3FF) << 10) | (c2 & 0x3FF); bytes.push(0xF0 | (c >> 18), 0x80 | ((c >> 12) & 0x3F), 0x80 | ((c >> 6) & 0x3F), 0x80 | (c & 0x3F)) }
+            }
+            return new Uint8Array(bytes)
+        }
+
+        const le = this._encoding === 'utf-16le'
+        const buf = new ArrayBuffer(input.length * 2)
+        const dv = new DataView(buf)
+        for (let i = 0; i < input.length; i++) dv.setUint16(i * 2, input.charCodeAt(i), le)
+        return new Uint8Array(buf)
+    }
+}
+
+if (typeof globalThis.TextDecoder === 'undefined') {
+    globalThis.TextDecoder = TextDecoderImpl
+}
+
+if (typeof globalThis.TextEncoder === 'undefined') {
+    globalThis.TextEncoder = TextEncoderImpl
+}

package/lib/text-measure.js

@@ -0,0 +1,52 @@
+import * as ffi from 'ffi';
+import * as win from 'win';
+import * as gui from 'gui';
+function loadProc(lib, name) {
+    const ptr = win.GetProcAddress(lib, name);
+    if (!ptr)
+        throw new Error(`Cannot load ${name}`);
+    return ptr;
+}
+const user32 = win.LoadLibrary('user32.dll');
+const gdi32 = win.LoadLibrary('gdi32.dll');
+if (!user32 || !gdi32)
+    throw new Error('Failed to load system DLLs');
+const DrawTextW = loadProc(user32, 'DrawTextW');
+const GetDC = loadProc(user32, 'GetDC');
+const ReleaseDC = loadProc(user32, 'ReleaseDC');
+const SelectObject = loadProc(gdi32, 'SelectObject');
+const FFI_TYPE_UINT64 = ffi.FFI_TYPE_UINT64;
+const FFI_S32 = ffi.FFI_TYPE_SINT32;
+const FFI_PTR = ffi.FFI_TYPE_POINTER;
+export function measureText(hdc, text, maxWidth) {
+    const textBuf = new TextEncoder('utf-16le').encode(text + '\0').buffer;
+    const rect = new ArrayBuffer(16);
+    const dv = new DataView(rect);
+    dv.setInt32(8, maxWidth, true);
+    ffi.ffiCall(DrawTextW, [FFI_TYPE_UINT64, FFI_PTR, FFI_S32, FFI_PTR, FFI_S32], [hdc, textBuf, -1, rect, 1024 /* gui.DrawTextFlag.CALCRECT */], FFI_TYPE_UINT64);
+    return { width: dv.getInt32(8, true), height: dv.getInt32(12, true) };
+}
+export function getButtonIdealSize(hwnd) {
+    const size = new ArrayBuffer(8);
+    gui.SendMessage(hwnd, 5633 /* gui.ButtonExtMsg.GETIDEALSIZE */, 0, ffi.bufferPtr(size));
+    const dv = new DataView(size);
+    return { width: dv.getInt32(0, true), height: dv.getInt32(4, true) };
+}
+export function measureTextForHwnd(hwnd, text) {
+    const hdc = ffi.ffiCall(GetDC, [FFI_TYPE_UINT64], [hwnd], FFI_TYPE_UINT64);
+    if (!hdc)
+        return { width: 0, height: 0 };
+    const hFont = gui.SendMessage(hwnd, 49 /* gui.WmMsg.GETFONT */, 0, 0);
+    const oldFont = hFont ? ffi.ffiCall(SelectObject, [FFI_TYPE_UINT64, FFI_TYPE_UINT64], [hdc, hFont], FFI_TYPE_UINT64) : 0;
+    const result = measureText(hdc, text, 0);
+    if (hFont)
+        ffi.ffiCall(SelectObject, [FFI_TYPE_UINT64, FFI_TYPE_UINT64], [hdc, oldFont], FFI_TYPE_UINT64);
+    ffi.ffiCall(ReleaseDC, [FFI_TYPE_UINT64, FFI_TYPE_UINT64], [hwnd, hdc], FFI_S32);
+    const wr = gui.GetWindowRect(hwnd);
+    const cr = gui.GetClientRect(hwnd);
+    if (wr && cr) {
+        result.width += (wr.right - wr.left) - (cr.right - cr.left);
+        result.height += (wr.bottom - wr.top) - (cr.bottom - cr.top);
+    }
+    return result;
+}

package/lib/text-measure.ts

@@ -0,0 +1,54 @@
+import * as ffi from 'ffi'
+import * as win from 'win'
+import * as gui from 'gui'
+
+function loadProc(lib: win.HMODULE, name: string): number {
+    const ptr = win.GetProcAddress(lib, name)
+    if (!ptr) throw new Error(`Cannot load ${name}`)
+    return ptr
+}
+
+const user32 = win.LoadLibrary('user32.dll')
+const gdi32 = win.LoadLibrary('gdi32.dll')
+if (!user32 || !gdi32) throw new Error('Failed to load system DLLs')
+const DrawTextW = loadProc(user32, 'DrawTextW')
+const GetDC = loadProc(user32, 'GetDC')
+const ReleaseDC = loadProc(user32, 'ReleaseDC')
+const SelectObject = loadProc(gdi32, 'SelectObject')
+
+const FFI_TYPE_UINT64 = ffi.FFI_TYPE_UINT64
+const FFI_S32 = ffi.FFI_TYPE_SINT32
+const FFI_PTR = ffi.FFI_TYPE_POINTER
+
+export function measureText(hdc: number, text: string, maxWidth: number): { width: number; height: number } {
+    const textBuf = new TextEncoder('utf-16le').encode(text + '\0').buffer
+    const rect = new ArrayBuffer(16)
+    const dv = new DataView(rect)
+    dv.setInt32(8, maxWidth, true)
+    ffi.ffiCall(DrawTextW, [FFI_TYPE_UINT64, FFI_PTR, FFI_S32, FFI_PTR, FFI_S32], [hdc, textBuf, -1, rect, gui.DrawTextFlag.CALCRECT], FFI_TYPE_UINT64)
+    return { width: dv.getInt32(8, true), height: dv.getInt32(12, true) }
+}
+
+export function getButtonIdealSize(hwnd: gui.HWND): { width: number; height: number } {
+    const size = new ArrayBuffer(8)
+    gui.SendMessage(hwnd, gui.ButtonExtMsg.GETIDEALSIZE, 0, ffi.bufferPtr(size))
+    const dv = new DataView(size)
+    return { width: dv.getInt32(0, true), height: dv.getInt32(4, true) }
+}
+
+export function measureTextForHwnd(hwnd: gui.HWND, text: string): { width: number; height: number } {
+    const hdc = ffi.ffiCall(GetDC, [FFI_TYPE_UINT64], [hwnd], FFI_TYPE_UINT64)
+    if (!hdc) return { width: 0, height: 0 }
+    const hFont = gui.SendMessage(hwnd, gui.WmMsg.GETFONT, 0, 0)
+    const oldFont = hFont ? ffi.ffiCall(SelectObject, [FFI_TYPE_UINT64, FFI_TYPE_UINT64], [hdc, hFont], FFI_TYPE_UINT64) : 0
+    const result = measureText(hdc, text, 0)
+    if (hFont) ffi.ffiCall(SelectObject, [FFI_TYPE_UINT64, FFI_TYPE_UINT64], [hdc, oldFont], FFI_TYPE_UINT64)
+    ffi.ffiCall(ReleaseDC, [FFI_TYPE_UINT64, FFI_TYPE_UINT64], [hwnd, hdc], FFI_S32)
+    const wr = gui.GetWindowRect(hwnd)
+    const cr = gui.GetClientRect(hwnd)
+    if (wr && cr) {
+        result.width += (wr.right - wr.left) - (cr.right - cr.left)
+        result.height += (wr.bottom - wr.top) - (cr.bottom - cr.top)
+    }
+    return result
+}

package/lib/url.js

@@ -0,0 +1,278 @@
+function _encode(s) { return encodeURIComponent(s); }
+function _decode(s) {
+    try {
+        return decodeURIComponent(s.replace(/\+/g, ' '));
+    }
+    catch {
+        return s;
+    }
+}
+function _normalizePath(path) {
+    if (!path)
+        return '/';
+    const parts = path.split('/');
+    const out = [];
+    let hasRoot = path[0] === '/';
+    if (hasRoot)
+        out.push('');
+    for (const p of parts) {
+        if (p === '' || p === '.')
+            continue;
+        if (p === '..') {
+            const last = out[out.length - 1];
+            if (last !== undefined && last !== '')
+                out.pop();
+        }
+        else {
+            out.push(p);
+        }
+    }
+    if (path.endsWith('/') && out[out.length - 1] !== '')
+        out.push('');
+    const result = out.join('/');
+    if (hasRoot && !result.startsWith('/'))
+        return '/' + result;
+    return result || '/';
+}
+function _parseURL(url) {
+    const r = { scheme: '', user: '', pass: '', host: '', port: '', path: '/', query: '', fragment: '' };
+    const fi = url.indexOf('#');
+    if (fi >= 0) {
+        r.fragment = url.slice(fi + 1);
+        url = url.slice(0, fi);
+    }
+    const qi = url.indexOf('?');
+    if (qi >= 0) {
+        r.query = url.slice(qi + 1);
+        url = url.slice(0, qi);
+    }
+    const sm = url.match(/^([a-zA-Z][a-zA-Z0-9+\-.]*):(.*)$/);
+    if (sm) {
+        r.scheme = sm[1].toLowerCase();
+        url = sm[2];
+    }
+    if (url.startsWith('//')) {
+        url = url.slice(2);
+        const si = url.indexOf('/');
+        let auth;
+        if (si < 0) {
+            auth = url;
+            url = '';
+        }
+        else {
+            auth = url.slice(0, si);
+            url = url.slice(si);
+        }
+        const ai = auth.lastIndexOf('@');
+        if (ai >= 0) {
+            const ui = auth.slice(0, ai);
+            auth = auth.slice(ai + 1);
+            const ci = ui.indexOf(':');
+            if (ci >= 0) {
+                r.user = _decode(ui.slice(0, ci));
+                r.pass = _decode(ui.slice(ci + 1));
+            }
+            else
+                r.user = _decode(ui);
+        }
+        if (auth.startsWith('[')) {
+            const cb = auth.indexOf(']');
+            r.host = auth.slice(1, cb).toLowerCase();
+            const pp = auth.slice(cb + 1);
+            if (pp.startsWith(':'))
+                r.port = pp.slice(1);
+        }
+        else {
+            const ci = auth.lastIndexOf(':');
+            if (ci >= 0 && ci === auth.lastIndexOf(':')) {
+                r.host = auth.slice(0, ci).toLowerCase();
+                r.port = auth.slice(ci + 1);
+            }
+            else
+                r.host = auth.toLowerCase();
+        }
+    }
+    r.path = url;
+    if (r.host && !r.path.startsWith('/'))
+        r.path = '/' + r.path;
+    return r;
+}
+class URLSearchParamsImpl {
+    _list = [];
+    constructor(init) {
+        if (typeof init === 'string') {
+            const s = init.startsWith('?') ? init.slice(1) : init;
+            if (!s)
+                return;
+            for (const p of s.split('&')) {
+                const eq = p.indexOf('=');
+                if (eq < 0) {
+                    this._list.push([_decode(p), '']);
+                    continue;
+                }
+                this._list.push([_decode(p.slice(0, eq)), _decode(p.slice(eq + 1))]);
+            }
+        }
+        else if (init) {
+            if (Array.isArray(init))
+                for (const [k, v] of init)
+                    this._list.push([String(k), String(v)]);
+            else
+                for (const k of Object.keys(init))
+                    this._list.push([k, String(init[k])]);
+        }
+    }
+    append(key, value) { this._list.push([key, value]); }
+    delete(key) { this._list = this._list.filter(([k]) => k !== key); }
+    get(key) { for (const [k, v] of this._list)
+        if (k === key)
+            return v; return null; }
+    getAll(key) { return this._list.filter(([k]) => k === key).map(([, v]) => v); }
+    has(key) { return this._list.some(([k]) => k === key); }
+    set(key, value) {
+        let f = false;
+        for (let i = 0; i < this._list.length; i++) {
+            if (this._list[i][0] === key) {
+                if (!f) {
+                    this._list[i][1] = value;
+                    f = true;
+                }
+                else {
+                    this._list.splice(i, 1);
+                    i--;
+                }
+            }
+        }
+        if (!f)
+            this._list.push([key, value]);
+    }
+    sort() { this._list.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0); }
+    forEach(fn) { for (const [k, v] of this._list)
+        fn(v, k); }
+    *keys() { for (const [k] of this._list)
+        yield k; }
+    *values() { for (const [, v] of this._list)
+        yield v; }
+    *entries() { for (const item of this._list)
+        yield [item[0], item[1]]; }
+    *[Symbol.iterator]() { for (const item of this._list)
+        yield item; }
+    toString() { return this._list.map(([k, v]) => _encode(k) + '=' + _encode(v)).join('&'); }
+    get size() { return this._list.length; }
+}
+if (typeof globalThis.URLSearchParams === 'undefined') {
+    globalThis.URLSearchParams = URLSearchParamsImpl;
+}
+class URLImpl {
+    _scheme = '';
+    _username = '';
+    _password = '';
+    _hostname = '';
+    _port = '';
+    _pathname = '/';
+    _query = '';
+    _fragment = '';
+    _searchParams = new URLSearchParamsImpl();
+    constructor(url, base) {
+        let p = _parseURL(url);
+        if (p.scheme) {
+            this._apply(p);
+            return;
+        }
+        if (base === undefined)
+            throw new TypeError('Invalid URL');
+        const b = new URLImpl(base);
+        if (p.host) {
+            p.scheme = b._scheme;
+            this._apply(p);
+            return;
+        }
+        if (!p.path && !p.query) {
+            this._apply({
+                scheme: b._scheme, user: b._username, pass: b._password,
+                host: b._hostname, port: b._port,
+                path: b._pathname, query: b._query, fragment: p.fragment || ''
+            });
+            return;
+        }
+        p.scheme = b._scheme;
+        if (!p.user)
+            p.user = b._username;
+        if (!p.pass)
+            p.pass = b._password;
+        if (!p.host)
+            p.host = b._hostname;
+        if (!p.port)
+            p.port = b._port;
+        if (!p.fragment)
+            p.fragment = '';
+        if (p.path && !p.path.startsWith('/')) {
+            const bd = b._pathname.substring(0, b._pathname.lastIndexOf('/') + 1);
+            p.path = _normalizePath(bd + p.path);
+        }
+        else if (!p.path) {
+            p.path = b._pathname;
+            if (!p.query)
+                p.query = b._query;
+        }
+        this._apply(p);
+    }
+    _apply(p) {
+        this._scheme = p.scheme;
+        this._username = p.user;
+        this._password = p.pass;
+        this._hostname = p.host;
+        this._port = p.port;
+        this._pathname = _normalizePath(p.path || '/');
+        this._query = p.query;
+        this._fragment = p.fragment;
+        this._searchParams = new URLSearchParamsImpl(this._query);
+    }
+    get href() { return this.toString(); }
+    get protocol() { return this._scheme + ':'; }
+    get hostname() { return this._hostname; }
+    get port() { return this._port; }
+    get pathname() { return this._pathname; }
+    get search() { return this._query ? '?' + this._query : ''; }
+    get hash() { return this._fragment ? '#' + this._fragment : ''; }
+    get host() {
+        const h = this._hostname;
+        const ipv6 = h.includes(':');
+        return (ipv6 ? '[' + h + ']' : h) + (this._port ? ':' + this._port : '');
+    }
+    get origin() {
+        const h = this._hostname;
+        const ipv6 = h.includes(':');
+        return this._scheme + '://' + (ipv6 ? '[' + h + ']' : h) + (this._port ? ':' + this._port : '');
+    }
+    get username() { return this._username; }
+    get password() { return this._password; }
+    get searchParams() { return this._searchParams; }
+    toString() {
+        let s = this._scheme + ':';
+        const special = ['http', 'https', 'ws', 'wss', 'ftp', 'file'];
+        if (this._hostname || (special.includes(this._scheme) && this._pathname.startsWith('/'))) {
+            s += '//';
+            if (this._username) {
+                s += _encode(this._username);
+                if (this._password)
+                    s += ':' + _encode(this._password);
+                s += '@';
+            }
+            s += this._hostname.includes(':') ? '[' + this._hostname + ']' : this._hostname;
+            if (this._port)
+                s += ':' + this._port;
+        }
+        s += this._pathname;
+        if (this._query)
+            s += '?' + this._query;
+        if (this._fragment)
+            s += '#' + this._fragment;
+        return s;
+    }
+    toJSON() { return this.toString(); }
+}
+if (typeof globalThis.URL === 'undefined') {
+    globalThis.URL = URLImpl;
+}
+export {};