@ternkit/tern 1.0.0 → 1.2.0

package/dist/server/url.js

@@ -0,0 +1,594 @@
+// URL and URLSearchParams for the server renderer.
+//
+// QuickJS has no URL. core-js's polyfill keeps each URL's state in a WeakMap
+// whose values point back at their keys, and QuickJS never frees such
+// entries, so every URL that outlives a render leaked. This implementation
+// keeps state in ordinary private fields instead. It covers the WHATWG URL
+// standard for what pages use: special and opaque schemes, relative
+// resolution, dot segments, default ports and percent-encoding. It does not
+// convert international domain names to punycode or parse IPv6 hosts beyond
+// keeping them as written.
+const SPECIAL = { 'http:': '80', 'https:': '443', 'ws:': '80', 'wss:': '443', 'ftp:': '21', 'file:': '' };
+// Percent-encode sets from the URL standard.
+const C0 = (c) => c < 0x20 || c > 0x7e;
+const FRAGMENT = (c) => C0(c) || c === 0x20 || c === 0x22 || c === 0x3c || c === 0x3e || c === 0x60;
+const QUERY = (c) => C0(c) || c === 0x20 || c === 0x22 || c === 0x23 || c === 0x3c || c === 0x3e;
+const SPECIAL_QUERY = (c) => QUERY(c) || c === 0x27;
+const PATH = (c) => QUERY(c) || c === 0x3f || c === 0x60 || c === 0x7b || c === 0x7d || c === 0x5e;
+const USERINFO = (c) => PATH(c) || c === 0x2f || c === 0x3a || c === 0x3b || c === 0x3d || c === 0x40 || (c >= 0x5b && c <= 0x5d) || c === 0x7c;
+// application/x-www-form-urlencoded: everything but *-._ and alphanumerics.
+const FORM = (c) => !((c >= 0x30 && c <= 0x39) || (c >= 0x41 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a) || c === 0x2a || c === 0x2d || c === 0x2e || c === 0x5f);
+const encoder = typeof TextEncoder === 'function' ? new TextEncoder() : null;
+function utf8(s) {
+    if (encoder)
+        return [...encoder.encode(s)];
+    const out = [];
+    for (const ch of s) {
+        let c = ch.codePointAt(0);
+        if (c >= 0xd800 && c <= 0xdfff)
+            c = 0xfffd;
+        if (c < 0x80)
+            out.push(c);
+        else if (c < 0x800)
+            out.push(0xc0 | (c >> 6), 0x80 | (c & 63));
+        else if (c < 0x10000)
+            out.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 63), 0x80 | (c & 63));
+        else
+            out.push(0xf0 | (c >> 18), 0x80 | ((c >> 12) & 63), 0x80 | ((c >> 6) & 63), 0x80 | (c & 63));
+    }
+    return out;
+}
+const HEX = '0123456789ABCDEF';
+function encode(s, set, spaceAsPlus = false) {
+    let out = '';
+    for (const ch of s) {
+        const c = ch.codePointAt(0);
+        if (c < 0x80 && !set(c)) {
+            out += ch;
+            continue;
+        }
+        if (spaceAsPlus && c === 0x20) {
+            out += '+';
+            continue;
+        }
+        for (const b of utf8(ch))
+            out += '%' + HEX[b >> 4] + HEX[b & 15];
+    }
+    return out;
+}
+function decode(s) {
+    const bytes = [];
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+        if (c === 0x25 && /^[0-9a-fA-F]{2}$/.test(s.slice(i + 1, i + 3))) {
+            bytes.push(parseInt(s.slice(i + 1, i + 3), 16));
+            i += 2;
+        }
+        else if (c < 0x80) {
+            bytes.push(c);
+        }
+        else {
+            bytes.push(...utf8(s[i] + (c >= 0xd800 && c <= 0xdbff ? (s[++i] ?? '') : '')));
+        }
+    }
+    return decodeUTF8(bytes);
+}
+function decodeUTF8(bytes) {
+    let out = '';
+    for (let i = 0; i < bytes.length;) {
+        const b = bytes[i];
+        let n = 0;
+        let c = 0;
+        if (b < 0x80)
+            [n, c] = [0, b];
+        else if (b >= 0xc2 && b < 0xe0)
+            [n, c] = [1, b & 31];
+        else if (b >= 0xe0 && b < 0xf0)
+            [n, c] = [2, b & 15];
+        else if (b >= 0xf0 && b < 0xf5)
+            [n, c] = [3, b & 7];
+        else {
+            out += '�';
+            i++;
+            continue;
+        }
+        let ok = i + n < bytes.length + 0 || n === 0;
+        for (let k = 1; k <= n && ok; k++) {
+            const cb = bytes[i + k];
+            if (cb === undefined || (cb & 0xc0) !== 0x80)
+                ok = false;
+            else
+                c = (c << 6) | (cb & 63);
+        }
+        if (!ok) {
+            out += '�';
+            i++;
+            continue;
+        }
+        out += String.fromCodePoint(c);
+        i += n + 1;
+    }
+    return out;
+}
+function invalid(input) {
+    return new TypeError(`Invalid URL: ${input}`);
+}
+function normalizePath(segments) {
+    const out = [];
+    for (let i = 0; i < segments.length; i++) {
+        const seg = segments[i];
+        const lower = seg.toLowerCase();
+        const last = i === segments.length - 1;
+        if (lower === '..' || lower === '.%2e' || lower === '%2e.' || lower === '%2e%2e') {
+            out.pop();
+            if (last)
+                out.push('');
+        }
+        else if (lower === '.' || lower === '%2e') {
+            if (last)
+                out.push('');
+        }
+        else {
+            out.push(encode(seg, PATH));
+        }
+    }
+    return out;
+}
+function parseHost(host, special, input) {
+    if (host.startsWith('[')) {
+        if (!host.endsWith(']'))
+            throw invalid(input);
+        return host.toLowerCase();
+    }
+    if (!special)
+        return encode(host, C0);
+    const h = decode(host).toLowerCase();
+    if (h === '' || /[\0\t\n\r #/:<>?@[\\\]^|%]/.test(h))
+        throw invalid(input);
+    return ipv4(h) ?? h;
+}
+/** Normalizes IPv4 hosts written in decimal, hex or octal parts, as browsers do. */
+function ipv4(h) {
+    const parts = h.split('.');
+    if (parts[parts.length - 1] === '')
+        parts.pop();
+    if (parts.length === 0 || parts.length > 4)
+        return null;
+    const last = parts[parts.length - 1];
+    if (!/^(0x[0-9a-f]*|[0-9]+)$/.test(last))
+        return null;
+    const nums = [];
+    for (const p of parts) {
+        let n;
+        if (/^0x[0-9a-f]*$/.test(p))
+            n = p.length === 2 ? 0 : parseInt(p.slice(2), 16);
+        else if (/^0[0-7]+$/.test(p))
+            n = parseInt(p.slice(1), 8);
+        else if (/^[0-9]+$/.test(p))
+            n = parseInt(p, 10);
+        else
+            return null;
+        nums.push(n);
+    }
+    let value = nums.pop();
+    if (nums.some((n) => n > 255) || value >= 256 ** (4 - nums.length))
+        return null;
+    nums.forEach((n, i) => (value += n * 256 ** (3 - i)));
+    return [value >>> 24, (value >>> 16) & 255, (value >>> 8) & 255, value & 255].join('.');
+}
+function parse(input, base) {
+    // Strip leading and trailing C0 controls and spaces, and all tabs and newlines.
+    const raw = input.replace(/^[\u0000- ]+|[\u0000- ]+$/g, '').replace(/[\t\n\r]/g, '');
+    let rest = raw;
+    let fragment = null;
+    const hashAt = rest.indexOf('#');
+    if (hashAt >= 0) {
+        fragment = encode(rest.slice(hashAt + 1), FRAGMENT);
+        rest = rest.slice(0, hashAt);
+    }
+    const scheme = /^([a-zA-Z][a-zA-Z0-9+.-]*):/.exec(rest);
+    if (!scheme) {
+        if (!base)
+            throw invalid(input);
+        return resolve(rest, fragment, base, input);
+    }
+    const protocol = scheme[1].toLowerCase() + ':';
+    rest = rest.slice(scheme[0].length);
+    const special = protocol in SPECIAL;
+    if (special && base && base.protocol === protocol && !rest.startsWith('/') && !rest.startsWith('\\')) {
+        // "http:foo" relative to an http: base.
+        return resolve(rest, fragment, base, input);
+    }
+    if (protocol === 'file:') {
+        if (/^[/\\]{2}/.test(rest))
+            return withAuthority(protocol, rest.slice(2), fragment, input, true);
+        return withAuthority(protocol, rest.replace(/^[/\\]?/, '/'), fragment, input, true);
+    }
+    if (special)
+        return withAuthority(protocol, rest.replace(/^[/\\]*/, ''), fragment, input, false);
+    if (rest.startsWith('//'))
+        return withAuthority(protocol, rest.slice(2), fragment, input, false);
+    if (rest.startsWith('/')) {
+        const { path, query } = splitQuery(rest, false);
+        return { protocol, username: '', password: '', hostname: '', hasHost: false, port: '', path: normalizePath(path.slice(1).split('/')), opaque: null, query, fragment };
+    }
+    const { path, query } = splitQuery(rest, false);
+    return { protocol, username: '', password: '', hostname: '', hasHost: false, port: '', path: [], opaque: encode(path, C0), query, fragment };
+}
+function splitQuery(s, special) {
+    const q = s.indexOf('?');
+    if (q < 0)
+        return { path: s, query: null };
+    return { path: s.slice(0, q), query: encode(s.slice(q + 1), special ? SPECIAL_QUERY : QUERY) };
+}
+function withAuthority(protocol, rest, fragment, input, file) {
+    const special = protocol in SPECIAL;
+    const end = rest.search(special ? /[/\\?]/ : /[/?]/);
+    const authority = end < 0 ? rest : rest.slice(0, end);
+    let tail = end < 0 ? '' : rest.slice(end);
+    if (special)
+        tail = tail.replace(/^[^?]*/, (m) => m.replace(/\\/g, '/'));
+    let username = '';
+    let password = '';
+    let hostport = authority;
+    const at = authority.lastIndexOf('@');
+    if (at >= 0) {
+        const userinfo = authority.slice(0, at);
+        hostport = authority.slice(at + 1);
+        const colon = userinfo.indexOf(':');
+        username = encode(colon < 0 ? userinfo : userinfo.slice(0, colon), USERINFO);
+        password = colon < 0 ? '' : encode(userinfo.slice(colon + 1), USERINFO);
+    }
+    let host = hostport;
+    let port = '';
+    const portMatch = /:([0-9]*)$/.exec(hostport);
+    if (portMatch && !hostport.endsWith(']')) {
+        host = hostport.slice(0, portMatch.index);
+        if (portMatch[1]) {
+            const n = parseInt(portMatch[1], 10);
+            if (n > 65535)
+                throw invalid(input);
+            port = String(n);
+        }
+    }
+    else if (/:[^\]]*$/.test(hostport) && !hostport.startsWith('[')) {
+        throw invalid(input);
+    }
+    if (SPECIAL[protocol] === port)
+        port = '';
+    if (file && host.toLowerCase() === 'localhost')
+        host = '';
+    if (special && !file && host === '')
+        throw invalid(input);
+    const hostname = host === '' ? '' : parseHost(host, special, input);
+    const { path, query } = splitQuery(tail, special);
+    const segments = path === '' ? (special ? [''] : []) : normalizePath(path.slice(1).split('/'));
+    return { protocol, username, password, hostname, hasHost: true, port, path: segments, opaque: null, query, fragment };
+}
+function resolve(rest, fragment, base, input) {
+    const special = base.protocol in SPECIAL;
+    if (special)
+        rest = rest.replace(/\\/g, '/');
+    if (base.opaque !== null) {
+        if (rest !== '' || fragment === null)
+            throw invalid(input);
+        return { ...base, fragment };
+    }
+    if (rest.startsWith('//'))
+        return withAuthority(base.protocol, rest.slice(2), fragment, input, base.protocol === 'file:');
+    if (rest === '')
+        return { ...base, path: [...base.path], fragment };
+    if (rest.startsWith('?')) {
+        return { ...base, path: [...base.path], query: encode(rest.slice(1), special ? SPECIAL_QUERY : QUERY), fragment };
+    }
+    const { path, query } = splitQuery(rest, special);
+    let segments;
+    if (path.startsWith('/')) {
+        segments = path.slice(1).split('/');
+    }
+    else {
+        segments = [...base.path.slice(0, -1), ...path.split('/')];
+    }
+    return { ...base, path: normalizePath(segments), query, fragment };
+}
+function serialize(p, excludeFragment = false) {
+    let s = p.protocol;
+    if (p.hasHost) {
+        s += '//';
+        if (p.username || p.password)
+            s += p.username + (p.password ? ':' + p.password : '') + '@';
+        s += p.hostname + (p.port ? ':' + p.port : '');
+    }
+    else if (p.opaque === null && p.path.length > 1 && p.path[0] === '') {
+        s += '/.';
+    }
+    s += p.opaque ?? (p.path.length || p.hasHost ? '/' + p.path.join('/') : '');
+    if (p.query !== null)
+        s += '?' + p.query;
+    if (!excludeFragment && p.fragment !== null)
+        s += '#' + p.fragment;
+    return s;
+}
+export class URLSearchParams {
+    #list = [];
+    #url = null;
+    constructor(init) {
+        if (init == null)
+            return;
+        if (typeof init === 'string') {
+            this.#list = parseQuery(init.startsWith('?') ? init.slice(1) : init);
+        }
+        else if (typeof init[Symbol.iterator] === 'function') {
+            for (const pair of init) {
+                const [k, v] = [...pair];
+                if (pair.length !== 2 && [...pair].length !== 2)
+                    throw new TypeError('Each pair needs a name and a value');
+                this.#list.push([String(k), String(v)]);
+            }
+        }
+        else {
+            for (const [k, v] of Object.entries(init))
+                this.#list.push([k, String(v)]);
+        }
+    }
+    /** @internal Links the params to their URL, so changes update it. */
+    static _link(params, url, query) {
+        params.#url = url;
+        params.#list = query ? parseQuery(query) : [];
+    }
+    /** @internal */
+    static _reset(params, query) {
+        params.#list = query ? parseQuery(query) : [];
+    }
+    #update() {
+        if (this.#url)
+            URL._setQuery(this.#url, this.toString());
+    }
+    get size() {
+        return this.#list.length;
+    }
+    append(name, value) {
+        this.#list.push([String(name), String(value)]);
+        this.#update();
+    }
+    delete(name, value) {
+        this.#list = this.#list.filter(([k, v]) => !(k === name && (value === undefined || v === String(value))));
+        this.#update();
+    }
+    get(name) {
+        return this.#list.find(([k]) => k === name)?.[1] ?? null;
+    }
+    getAll(name) {
+        return this.#list.filter(([k]) => k === name).map(([, v]) => v);
+    }
+    has(name, value) {
+        return this.#list.some(([k, v]) => k === name && (value === undefined || v === String(value)));
+    }
+    set(name, value) {
+        const i = this.#list.findIndex(([k]) => k === name);
+        if (i < 0)
+            this.#list.push([String(name), String(value)]);
+        else {
+            this.#list[i] = [String(name), String(value)];
+            this.#list = this.#list.filter(([k], j) => j <= i || k !== name);
+        }
+        this.#update();
+    }
+    sort() {
+        this.#list = this.#list
+            .map((e, i) => [e, i])
+            .sort(([a, i], [b, j]) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : i - j))
+            .map(([e]) => e);
+        this.#update();
+    }
+    forEach(fn, thisArg) {
+        for (const [k, v] of this.#list)
+            fn.call(thisArg, v, k, this);
+    }
+    *entries() {
+        for (const [k, v] of this.#list)
+            yield [k, v];
+    }
+    *keys() {
+        for (const [k] of this.#list)
+            yield k;
+    }
+    *values() {
+        for (const [, v] of this.#list)
+            yield v;
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    toString() {
+        return this.#list.map(([k, v]) => encode(k, FORM, true) + '=' + encode(v, FORM, true)).join('&');
+    }
+    get [Symbol.toStringTag]() {
+        return 'URLSearchParams';
+    }
+}
+function parseQuery(q) {
+    const out = [];
+    for (const part of q.split('&')) {
+        if (!part)
+            continue;
+        const eq = part.indexOf('=');
+        const k = eq < 0 ? part : part.slice(0, eq);
+        const v = eq < 0 ? '' : part.slice(eq + 1);
+        out.push([decode(k.replace(/\+/g, ' ')), decode(v.replace(/\+/g, ' '))]);
+    }
+    return out;
+}
+export class URL {
+    #p;
+    #params = null;
+    constructor(url, base) {
+        const b = base === undefined ? undefined : parse(String(base));
+        this.#p = parse(String(url), b);
+    }
+    static canParse(url, base) {
+        try {
+            new URL(url, base);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    static parse(url, base) {
+        try {
+            return new URL(url, base);
+        }
+        catch {
+            return null;
+        }
+    }
+    /** @internal */
+    static _setQuery(url, query) {
+        url.#p.query = query === '' ? null : query;
+    }
+    get href() {
+        return serialize(this.#p);
+    }
+    set href(v) {
+        this.#p = parse(v);
+        if (this.#params)
+            URLSearchParams._reset(this.#params, this.#p.query);
+    }
+    get origin() {
+        const p = this.#p;
+        if (p.protocol in SPECIAL && p.protocol !== 'file:')
+            return p.protocol + '//' + p.hostname + (p.port ? ':' + p.port : '');
+        if (p.protocol === 'blob:') {
+            try {
+                return new URL(p.opaque ?? '').origin;
+            }
+            catch {
+                return 'null';
+            }
+        }
+        return 'null';
+    }
+    get protocol() {
+        return this.#p.protocol;
+    }
+    set protocol(v) {
+        const m = /^([a-zA-Z][a-zA-Z0-9+.-]*)/.exec(v);
+        if (!m)
+            return;
+        const next = m[1].toLowerCase() + ':';
+        if (next in SPECIAL !== this.#p.protocol in SPECIAL)
+            return;
+        this.#p.protocol = next;
+        if (SPECIAL[next] === this.#p.port)
+            this.#p.port = '';
+    }
+    get username() {
+        return this.#p.username;
+    }
+    set username(v) {
+        if (this.#p.hasHost && this.#p.hostname)
+            this.#p.username = encode(v, USERINFO);
+    }
+    get password() {
+        return this.#p.password;
+    }
+    set password(v) {
+        if (this.#p.hasHost && this.#p.hostname)
+            this.#p.password = encode(v, USERINFO);
+    }
+    get host() {
+        return this.#p.hostname + (this.#p.port ? ':' + this.#p.port : '');
+    }
+    set host(v) {
+        if (this.#p.opaque !== null)
+            return;
+        try {
+            const next = parse(this.#p.protocol + '//' + v);
+            this.#p.hostname = next.hostname;
+            this.#p.port = next.port;
+            this.#p.hasHost = true;
+        }
+        catch {
+            // invalid hosts are ignored, as in browsers
+        }
+    }
+    get hostname() {
+        return this.#p.hostname;
+    }
+    set hostname(v) {
+        if (this.#p.opaque !== null)
+            return;
+        try {
+            this.#p.hostname = parse(this.#p.protocol + '//' + v).hostname;
+            this.#p.hasHost = true;
+        }
+        catch {
+            // ignored
+        }
+    }
+    get port() {
+        return this.#p.port;
+    }
+    set port(v) {
+        if (!this.#p.hostname || this.#p.protocol === 'file:')
+            return;
+        const m = /^[0-9]*/.exec(String(v))[0];
+        if (m === '') {
+            if (String(v) === '')
+                this.#p.port = '';
+            return;
+        }
+        const n = parseInt(m, 10);
+        if (n > 65535)
+            return;
+        this.#p.port = SPECIAL[this.#p.protocol] === String(n) ? '' : String(n);
+    }
+    get pathname() {
+        const p = this.#p;
+        return p.opaque ?? (p.path.length || p.hasHost ? '/' + p.path.join('/') : '');
+    }
+    set pathname(v) {
+        if (this.#p.opaque !== null)
+            return;
+        const special = this.#p.protocol in SPECIAL;
+        let s = String(v);
+        if (special)
+            s = s.replace(/\\/g, '/');
+        s = s.replace(/[?#]/g, (c) => (c === '?' ? '%3F' : '%23'));
+        this.#p.path = normalizePath((s.startsWith('/') ? s.slice(1) : s).split('/'));
+    }
+    get search() {
+        return this.#p.query ? '?' + this.#p.query : '';
+    }
+    set search(v) {
+        const s = String(v);
+        const q = s.startsWith('?') ? s.slice(1) : s;
+        this.#p.query = s === '' ? null : encode(q, this.#p.protocol in SPECIAL ? SPECIAL_QUERY : QUERY);
+        if (this.#params)
+            URLSearchParams._reset(this.#params, this.#p.query);
+    }
+    get searchParams() {
+        if (!this.#params) {
+            this.#params = new URLSearchParams();
+            URLSearchParams._link(this.#params, this, this.#p.query);
+        }
+        return this.#params;
+    }
+    get hash() {
+        return this.#p.fragment ? '#' + this.#p.fragment : '';
+    }
+    set hash(v) {
+        const s = String(v);
+        this.#p.fragment = s === '' ? null : encode(s.startsWith('#') ? s.slice(1) : s, FRAGMENT);
+    }
+    toString() {
+        return this.href;
+    }
+    toJSON() {
+        return this.href;
+    }
+    get [Symbol.toStringTag]() {
+        return 'URL';
+    }
+}

package/dist/server/web.d.ts

@@ -0,0 +1,74 @@
+export declare class TextEncoderPolyfill {
+    readonly encoding = "utf-8";
+    encode(input?: string): Uint8Array;
+    encodeInto(input: string, dest: Uint8Array): {
+        read: number;
+        written: number;
+    };
+}
+export declare class TextDecoderPolyfill {
+    readonly encoding: string;
+    readonly fatal: boolean;
+    readonly ignoreBOM: boolean;
+    constructor(label?: string, options?: {
+        fatal?: boolean;
+        ignoreBOM?: boolean;
+    });
+    decode(input?: ArrayBuffer | ArrayBufferView): string;
+}
+export declare class EventPolyfill {
+    readonly type: string;
+    readonly bubbles: boolean;
+    readonly cancelable: boolean;
+    readonly composed: boolean;
+    readonly timeStamp: number;
+    defaultPrevented: boolean;
+    target: unknown;
+    currentTarget: unknown;
+    /** @internal */
+    _stop: boolean;
+    constructor(type: string, init?: {
+        bubbles?: boolean;
+        cancelable?: boolean;
+        composed?: boolean;
+    });
+    preventDefault(): void;
+    stopPropagation(): void;
+    stopImmediatePropagation(): void;
+}
+export declare class CustomEventPolyfill<T = unknown> extends EventPolyfill {
+    readonly detail: T | null;
+    constructor(type: string, init?: {
+        detail?: T;
+        bubbles?: boolean;
+        cancelable?: boolean;
+    });
+}
+type Listener = ((e: EventPolyfill) => void) | {
+    handleEvent(e: EventPolyfill): void;
+};
+export declare class EventTargetPolyfill {
+    #private;
+    addEventListener(type: string, fn: Listener | null, options?: boolean | {
+        once?: boolean;
+        signal?: AbortSignalPolyfill;
+    }): void;
+    removeEventListener(type: string, fn: Listener | null): void;
+    dispatchEvent(event: EventPolyfill): boolean;
+}
+export declare class AbortSignalPolyfill extends EventTargetPolyfill {
+    aborted: boolean;
+    reason: unknown;
+    onabort: ((e: EventPolyfill) => void) | null;
+    throwIfAborted(): void;
+    static abort(reason?: unknown): AbortSignalPolyfill;
+    static timeout(): AbortSignalPolyfill;
+    static any(signals: AbortSignalPolyfill[]): AbortSignalPolyfill;
+}
+export declare class AbortControllerPolyfill {
+    readonly signal: AbortSignalPolyfill;
+    abort(reason?: unknown): void;
+}
+/** Installs every missing API on g (globalThis in the renderer). */
+export declare function install(g: Record<string, unknown>): void;
+export {};