jseption 0.0.0-stage → 0.0.2

package/dist/builtins/date.js

@@ -0,0 +1,1046 @@
+/*
+ * Date objects (port of the Date part of quickjs.c)
+ *
+ * The calendar computations (get_date_fields / set_date_fields / string
+ * parsing) are ported from the C version; the host Date is only used to
+ * obtain the current time and the local time zone offset.
+ */
+import * as Q from "../quickjs.js";
+import { JS_EXCEPTION, JS_IsException, JS_IsUndefined, JS_IsObject, JS_IsFunction, JS_NewObject, js_create_from_ctor, JS_ThrowTypeError, JS_ThrowTypeErrorNotAnObject, JS_ThrowRangeError, JS_GetPropertyStr, JS_Call, JS_ToFloat64, JS_ToString, JS_ToObject, JS_ToPrimitive, JS_ValueToAtom, HINT_NUMBER, HINT_STRING, HINT_NONE, HINT_FORCE_ORDINARY, JS_ATOM_NULL, JS_ATOM_number, JS_ATOM_integer, JS_ATOM_string, JS_ATOM_default, JS_ATOM_Symbol_toPrimitive, JS_SetPropertyFunctionList, JS_NewGlobalCConstructor, JS_CFUNC_DEF, JS_CFUNC_MAGIC_DEF, JS_ALIAS_DEF, } from "../quickjs.js";
+/* ---------------------------------------------------------------------
+   helpers
+   --------------------------------------------------------------------- */
+/* the C functions receive the real argument count: argv is not padded
+   (missing arguments read as undefined) */
+function js_argc(ctx, argv, fn) {
+    return argv.length;
+}
+function math_mod(a, b) {
+    /* return positive modulo */
+    const m = a % b;
+    return m + (m < 0 ? b : 0);
+}
+function floor_div(a, b) {
+    /* integer division rounding toward -Infinity */
+    const m = a % b;
+    return (a - (m + (m < 0 ? b : 0))) / b;
+}
+/* OS dependent: return the local time zone offset in minutes (positive
+   west of GMT) for the UTC time 'time' in ms */
+function getTimezoneOffset(time) {
+    const d = new Date(time);
+    const off = d.getTimezoneOffset();
+    if (Number.isNaN(off)) {
+        /* out of the host range: use the offset of the clamped time */
+        const t = Math.max(-8.64e15, Math.min(8.64e15, time));
+        const off2 = new Date(t).getTimezoneOffset();
+        return Number.isNaN(off2) ? 0 : off2;
+    }
+    return off;
+}
+function JS_ThisTimeValue(ctx, this_val) {
+    if (Q.JS_IsObject(this_val)) {
+        if (Q.JS_GetClassID(this_val) === 10 /* JSClassID.DATE */ && typeof Q.JS_GetAnyOpaque(this_val) === 'number')
+            return Q.JS_GetAnyOpaque(this_val);
+    }
+    return JS_ThrowTypeError(ctx, 'not a Date object');
+}
+function JS_SetThisTimeValue(ctx, this_val, v) {
+    if (Q.JS_IsObject(this_val)) {
+        if (Q.JS_GetClassID(this_val) === 10 /* JSClassID.DATE */) {
+            Q.JS_SetOpaque(this_val, v);
+            return v;
+        }
+    }
+    return JS_ThrowTypeError(ctx, 'not a Date object');
+}
+function days_from_year(y) {
+    return 365 * (y - 1970) + floor_div(y - 1969, 4) - floor_div(y - 1901, 100) + floor_div(y - 1601, 400);
+}
+function days_in_year(y) {
+    return 365 + (y % 4 === 0 ? 1 : 0) - (y % 100 === 0 ? 1 : 0) + (y % 400 === 0 ? 1 : 0);
+}
+/* return the year, update days */
+function year_from_days(pdays) {
+    let d = pdays.days;
+    let y = floor_div(d * 10000, 3652425) + 1970;
+    /* the initial approximation is very good, so only a few
+       iterations are necessary */
+    let d1;
+    for (;;) {
+        d1 = d - days_from_year(y);
+        if (d1 < 0) {
+            y--;
+            d1 += days_in_year(y);
+        }
+        else {
+            const nd = days_in_year(y);
+            if (d1 < nd)
+                break;
+            d1 -= nd;
+            y++;
+        }
+    }
+    pdays.days = d1;
+    return y;
+}
+const month_days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+const month_names = 'JanFebMarAprMayJunJulAugSepOctNovDec';
+const day_names = 'SunMonTueWedThuFriSat';
+/* fields: [year, month, day, hours, minutes, seconds, ms, weekday, tz]
+   returns -1 if exception, 0 if NaN (and !force), 1 otherwise */
+function get_date_fields(ctx, obj, fields, is_local, force) {
+    const dval = JS_ThisTimeValue(ctx, obj);
+    if (JS_IsException(dval))
+        return -1;
+    let d;
+    let tz = 0;
+    if (Number.isNaN(dval)) {
+        if (!force)
+            return 0; /* NaN */
+        d = 0; /* initialize all fields to 0 */
+    }
+    else {
+        d = dval; /* assuming -8.64e15 <= dval <= -8.64e15 */
+        if (is_local) {
+            tz = -getTimezoneOffset(d);
+            d += tz * 60000;
+        }
+    }
+    /* result is >= 0, we can use % */
+    let h = math_mod(d, 86400000);
+    const pdays = { days: (d - h) / 86400000 };
+    const ms = h % 1000;
+    h = (h - ms) / 1000;
+    const s = h % 60;
+    h = (h - s) / 60;
+    const m = h % 60;
+    h = (h - m) / 60;
+    const wd = math_mod(pdays.days + 4, 7); /* week day */
+    const y = year_from_days(pdays);
+    let i;
+    for (i = 0; i < 11; i++) {
+        let md = month_days[i];
+        if (i === 1)
+            md += days_in_year(y) - 365;
+        if (pdays.days < md)
+            break;
+        pdays.days -= md;
+    }
+    fields[0] = y;
+    fields[1] = i;
+    fields[2] = pdays.days + 1;
+    fields[3] = h;
+    fields[4] = m;
+    fields[5] = s;
+    fields[6] = ms;
+    fields[7] = wd;
+    fields[8] = tz;
+    return 1;
+}
+function time_clip(t) {
+    if (t >= -8.64e15 && t <= 8.64e15)
+        return Math.trunc(t) + 0; /* convert -0 to +0 */
+    return NaN;
+}
+/* The spec mandates the use of 'double' and it specifies the order
+   of the operations */
+function set_date_fields(fields, is_local) {
+    /* emulate 21.4.1.15 MakeDay ( year, month, date ) */
+    const y = fields[0];
+    let m = fields[1];
+    const dt = fields[2];
+    const ym = y + Math.floor(m / 12);
+    let mn = m % 12;
+    if (mn < 0)
+        mn += 12;
+    if (ym < -271821 || ym > 275760)
+        return NaN;
+    const yi = ym;
+    const mi = mn;
+    let days = days_from_year(yi);
+    for (let i = 0; i < mi; i++) {
+        days += month_days[i];
+        if (i === 1)
+            days += days_in_year(yi) - 365;
+    }
+    const day = days + dt - 1;
+    /* emulate 21.4.1.14 MakeTime ( hour, min, sec, ms ) */
+    const h = fields[3];
+    m = fields[4];
+    const s = fields[5];
+    const milli = fields[6];
+    let time = h * 3600000;
+    time += m * 60000;
+    time += s * 1000;
+    time += milli;
+    /* emulate 21.4.1.16 MakeDate ( day, time ) */
+    let tv = (day * 86400000) + time;
+    if (!Number.isFinite(tv))
+        return NaN;
+    /* adjust for local time and clip */
+    if (is_local) {
+        tv += getTimezoneOffset(tv) * 60000;
+    }
+    return time_clip(tv);
+}
+function get_date_field(ctx, this_val, argv, magic) {
+    // get_date_field(obj, n, is_local)
+    const fields = new Array(9).fill(0);
+    const is_local = (magic & 0x0f) !== 0;
+    const n = (magic >> 4) & 0x0f;
+    const res = get_date_fields(ctx, this_val, fields, is_local, false);
+    if (res < 0)
+        return JS_EXCEPTION;
+    if (!res)
+        return NaN;
+    if (magic & 0x100) { // getYear
+        fields[0] -= 1900;
+    }
+    return fields[n];
+}
+function set_date_field(ctx, this_val, argv, magic) {
+    // _field(obj, first_field, end_field, args, is_local)
+    return set_date_field_argc(ctx, this_val, argv, js_argc(ctx, argv, set_date_field), magic);
+}
+/* set_date_field with an explicit argument count */
+function set_date_field_argc(ctx, this_val, argv, argc, magic) {
+    const fields = new Array(9).fill(0);
+    let d = NaN;
+    const first_field = (magic >> 8) & 0x0f;
+    const end_field = (magic >> 4) & 0x0f;
+    const is_local = (magic & 0x0f) !== 0;
+    let res = get_date_fields(ctx, this_val, fields, is_local, first_field === 0);
+    if (res < 0)
+        return JS_EXCEPTION;
+    const res1 = res;
+    // Argument coercion is observable and must be done unconditionally.
+    const n = Math.min(argc, end_field - first_field);
+    for (let i = 0; i < n; i++) {
+        const a = JS_ToFloat64(ctx, argv[i]);
+        if (JS_IsException(a))
+            return JS_EXCEPTION;
+        if (!Number.isFinite(a))
+            res = 0;
+        fields[first_field + i] = Math.trunc(a);
+    }
+    if (!res1)
+        return NaN; /* thisTimeValue is NaN */
+    if (res && argc > 0)
+        d = set_date_fields(fields, is_local);
+    return JS_SetThisTimeValue(ctx, this_val, d);
+}
+function pad(n, width) {
+    return String(n).padStart(width, '0');
+}
+/* %0*d with width 4 + (y < 0): the sign is included in the width */
+function fmt_year(y) {
+    if (y < 0)
+        return '-' + pad(-y, 4);
+    return pad(y, 4);
+}
+/* fmt:
+   0: toUTCString: "Tue, 02 Jan 2018 23:04:46 GMT"
+   1: toString: "Wed Jan 03 2018 00:05:22 GMT+0100 (CET)"
+   2: toISOString: "2018-01-02T23:02:56.927Z"
+   3: toLocaleString: "1/2/2018, 11:40:40 PM"
+   part: 1=date, 2=time 3=all
+   XXX: should use a variant of strftime().
+ */
+function get_date_string(ctx, this_val, argv, magic) {
+    // _string(obj, fmt, part)
+    const fields = new Array(9).fill(0);
+    const fmt = (magic >> 4) & 0x0f;
+    const part = magic & 0x0f;
+    const res = get_date_fields(ctx, this_val, fields, (fmt & 1) !== 0, false);
+    if (res < 0)
+        return JS_EXCEPTION;
+    if (!res) {
+        if (fmt === 2)
+            return JS_ThrowRangeError(ctx, 'Date value is NaN');
+        return 'Invalid Date';
+    }
+    const y = fields[0];
+    const mon = fields[1];
+    const d = fields[2];
+    const h = fields[3];
+    const m = fields[4];
+    const s = fields[5];
+    const ms = fields[6];
+    const wd = fields[7];
+    let tz = fields[8];
+    let buf = '';
+    if (part & 1) { /* date part */
+        switch (fmt) {
+            case 0:
+                buf += `${day_names.substring(wd * 3, wd * 3 + 3)}, ${pad(d, 2)} ${month_names.substring(mon * 3, mon * 3 + 3)} ${fmt_year(y)} `;
+                break;
+            case 1:
+                buf += `${day_names.substring(wd * 3, wd * 3 + 3)} ${month_names.substring(mon * 3, mon * 3 + 3)} ${pad(d, 2)} ${fmt_year(y)}`;
+                if (part === 3)
+                    buf += ' ';
+                break;
+            case 2:
+                if (y >= 0 && y <= 9999) {
+                    buf += pad(y, 4);
+                }
+                else {
+                    buf += (y < 0 ? '-' : '+') + pad(Math.abs(y), 6);
+                }
+                buf += `-${pad(mon + 1, 2)}-${pad(d, 2)}T`;
+                break;
+            case 3:
+                buf += `${pad(mon + 1, 2)}/${pad(d, 2)}/${fmt_year(y)}`;
+                if (part === 3)
+                    buf += ', ';
+                break;
+        }
+    }
+    if (part & 2) { /* time part */
+        switch (fmt) {
+            case 0:
+                buf += `${pad(h, 2)}:${pad(m, 2)}:${pad(s, 2)} GMT`;
+                break;
+            case 1:
+                buf += `${pad(h, 2)}:${pad(m, 2)}:${pad(s, 2)} GMT`;
+                if (tz < 0) {
+                    buf += '-';
+                    tz = -tz;
+                }
+                else {
+                    buf += '+';
+                }
+                /* tz is >= 0, can use % */
+                buf += `${pad(Math.trunc(tz / 60), 2)}${pad(tz % 60, 2)}`;
+                /* XXX: tack the time zone code? */
+                break;
+            case 2:
+                buf += `${pad(h, 2)}:${pad(m, 2)}:${pad(s, 2)}.${pad(ms, 3)}Z`;
+                break;
+            case 3:
+                buf += `${pad((h + 11) % 12 + 1, 2)}:${pad(m, 2)}:${pad(s, 2)} ${h < 12 ? 'A' : 'P'}M`;
+                break;
+        }
+    }
+    return buf;
+}
+/* OS dependent: return the UTC time in ms since 1970. */
+function date_now() {
+    return Date.now();
+}
+function js_date_constructor(ctx, new_target, argv) {
+    // Date(y, mon, d, h, m, s, ms)
+    let argc = js_argc(ctx, argv, js_date_constructor);
+    let val;
+    if (JS_IsUndefined(new_target)) {
+        /* invoked as function */
+        argc = 0;
+    }
+    let n = argc;
+    if (n === 0) {
+        val = date_now();
+    }
+    else if (n === 1) {
+        let has_val = false;
+        val = NaN;
+        if (Q.JS_IsObject(argv[0])) {
+            const p = argv[0];
+            if (Q.JS_GetClassID(p) === 10 /* JSClassID.DATE */ && typeof Q.JS_GetAnyOpaque(p) === 'number') {
+                val = time_clip(Q.JS_GetAnyOpaque(p));
+                has_val = true;
+            }
+        }
+        if (!has_val) {
+            const v = JS_ToPrimitive(ctx, argv[0], HINT_NONE);
+            if (JS_IsException(v))
+                return JS_EXCEPTION;
+            if (typeof v === 'string') {
+                const dv = js_Date_parse(ctx, undefined, [v]);
+                if (JS_IsException(dv))
+                    return JS_EXCEPTION;
+                const r = JS_ToFloat64(ctx, dv);
+                if (JS_IsException(r))
+                    return JS_EXCEPTION;
+                val = r;
+            }
+            else {
+                const r = JS_ToFloat64(ctx, v);
+                if (JS_IsException(r))
+                    return JS_EXCEPTION;
+                val = r;
+            }
+            val = time_clip(val);
+        }
+    }
+    else {
+        const fields = [0, 0, 1, 0, 0, 0, 0];
+        if (n > 7)
+            n = 7;
+        let i;
+        for (i = 0; i < n; i++) {
+            const a = JS_ToFloat64(ctx, argv[i]);
+            if (JS_IsException(a))
+                return JS_EXCEPTION;
+            if (!Number.isFinite(a))
+                break;
+            fields[i] = Math.trunc(a);
+            if (i === 0 && fields[0] >= 0 && fields[0] < 100)
+                fields[0] += 1900;
+        }
+        val = (i === n) ? set_date_fields(fields, true) : NaN;
+    }
+    let rv = js_create_from_ctor(ctx, new_target, 10 /* JSClassID.DATE */);
+    if (JS_IsException(rv))
+        return rv;
+    Q.JS_SetOpaque(rv, val);
+    if (JS_IsUndefined(new_target)) {
+        /* invoked as a function, return (new Date()).toString(); */
+        rv = get_date_string(ctx, rv, [], 0x13);
+    }
+    return rv;
+}
+function js_Date_UTC(ctx, this_val, argv) {
+    // UTC(y, mon, d, h, m, s, ms)
+    const fields = [0, 0, 1, 0, 0, 0, 0];
+    let n = js_argc(ctx, argv, js_Date_UTC);
+    if (n === 0)
+        return NaN;
+    if (n > 7)
+        n = 7;
+    for (let i = 0; i < n; i++) {
+        const a = JS_ToFloat64(ctx, argv[i]);
+        if (JS_IsException(a))
+            return JS_EXCEPTION;
+        if (!Number.isFinite(a))
+            return NaN;
+        fields[i] = Math.trunc(a);
+        if (i === 0 && fields[0] >= 0 && fields[0] < 100)
+            fields[0] += 1900;
+    }
+    return set_date_fields(fields, false);
+}
+/* ---------------------------------------------------------------------
+   Date string parsing
+   --------------------------------------------------------------------- */
+/* the string is converted to a NUL terminated byte array like in the C
+   version: 'sp' has a trailing 0 and reads past the end return 0 */
+class DateParser {
+    sp;
+    p = 0;
+    constructor(sp) { this.sp = sp; }
+    at(i) { return i < this.sp.length ? this.sp[i] : 0; }
+    cur() { return this.at(this.p); }
+}
+function string_skip_char(s, c) {
+    if (s.cur() === c) {
+        s.p += 1;
+        return true;
+    }
+    return false;
+}
+/* skip spaces, update offset, return next char */
+function string_skip_spaces(s) {
+    let c;
+    while ((c = s.cur()) === 32)
+        s.p += 1;
+    return c;
+}
+/* skip dashes dots and commas */
+function string_skip_separators(s) {
+    let c;
+    while ((c = s.cur()) === 45 /* - */ || c === 47 /* / */ || c === 46 /* . */ || c === 44 /* , */)
+        s.p += 1;
+    return c;
+}
+/* skip a word, stop on spaces, digits and separators, update offset
+   (strchr matches the NUL terminator, so the end of string stops too) */
+function string_skip_until(s, stoplist) {
+    let c;
+    while ((c = s.cur()) !== 0 && stoplist.indexOf(String.fromCharCode(c)) < 0)
+        s.p += 1;
+    return c;
+}
+/* parse a numeric field (max_digits = 0 -> no maximum) */
+function string_get_digits(s, pval, min_digits, max_digits) {
+    let v = 0;
+    let c;
+    let p = s.p;
+    const p_start = p;
+    while ((c = s.at(p)) >= 48 && c <= 57) {
+        /* arbitrary limit to 9 digits */
+        if (v >= 100000000)
+            return false;
+        v = v * 10 + c - 48;
+        p++;
+        if (p - p_start === max_digits)
+            break;
+    }
+    if (p - p_start < min_digits)
+        return false;
+    pval.v = v;
+    s.p = p;
+    return true;
+}
+function string_get_milliseconds(s, pval) {
+    /* parse optional fractional part as milliseconds and truncate. */
+    /* spec does not indicate which rounding should be used */
+    let mul = 100, ms = 0, c;
+    let p = s.p;
+    c = s.at(p);
+    if (c === 46 /* . */ || c === 44 /* , */) {
+        p++;
+        const p_start = p;
+        while ((c = s.at(p)) >= 48 && c <= 57) {
+            ms += (c - 48) * mul;
+            mul = Math.trunc(mul / 10);
+            p++;
+            if (p - p_start === 9)
+                break;
+        }
+        if (p > p_start) {
+            /* only consume the separator if digits are present */
+            pval.v = ms;
+            s.p = p;
+        }
+    }
+    return true;
+}
+function upper_ascii(c) {
+    return c >= 97 && c <= 122 ? c - 97 + 65 : c;
+}
+function string_get_tzoffset(s, tzp, strict) {
+    let tz = 0, hh, mm;
+    let p = s.p;
+    const sgn = s.at(p++);
+    if (sgn === 43 /* + */ || sgn === 45 /* - */) {
+        const sub = new DateParser(s.sp);
+        sub.p = p;
+        let n = p;
+        const r = { v: 0 };
+        if (!string_get_digits(sub, r, 1, 0))
+            return false;
+        p = sub.p;
+        hh = r.v;
+        n = p - n;
+        if (strict && n !== 2 && n !== 4)
+            return false;
+        while (n > 4) {
+            n -= 2;
+            hh = Math.trunc(hh / 100);
+        }
+        if (n > 2) {
+            mm = hh % 100;
+            hh = Math.trunc(hh / 100);
+        }
+        else {
+            mm = 0;
+            sub.p = p;
+            if (string_skip_char(sub, 58 /* : */)) { /* optional separator */
+                const r2 = { v: 0 };
+                if (!string_get_digits(sub, r2, 2, 2))
+                    return false;
+                mm = r2.v;
+            }
+            p = sub.p;
+        }
+        if (hh > 23 || mm > 59)
+            return false;
+        tz = hh * 60 + mm;
+        if (sgn !== 43)
+            tz = -tz;
+    }
+    else if (sgn !== 90 /* Z */) {
+        return false;
+    }
+    s.p = p;
+    tzp.v = tz;
+    return true;
+}
+function string_match(s, str) {
+    let p = s.p;
+    for (let i = 0; i < str.length; i++) {
+        if (upper_ascii(s.at(p)) !== upper_ascii(str.charCodeAt(i)))
+            return false;
+        p++;
+    }
+    s.p = p;
+    return true;
+}
+function find_abbrev(s, p, list, count) {
+    for (let n = 0; n < count; n++) {
+        for (let i = 0;; i++) {
+            if (upper_ascii(s.at(p + i)) !== upper_ascii(list.charCodeAt(n * 3 + i)))
+                break;
+            if (i === 2)
+                return n;
+        }
+    }
+    return -1;
+}
+function string_get_month(s, pval) {
+    const n = find_abbrev(s, s.p, month_names, 12);
+    if (n < 0)
+        return false;
+    pval.v = n + 1;
+    s.p += 3;
+    return true;
+}
+/* parse toISOString format */
+function js_date_parse_isostring(sp, fields, pis_local) {
+    const s = new DateParser(sp);
+    const r = { v: 0 };
+    /* initialize fields to the beginning of the Epoch */
+    for (let i = 0; i < 9; i++)
+        fields[i] = (i === 2) ? 1 : 0;
+    pis_local.v = false;
+    /* year is either yyyy digits or [+-]yyyyyy */
+    const sgn = s.cur();
+    if (sgn === 45 /* - */ || sgn === 43 /* + */) {
+        s.p++;
+        if (!string_get_digits(s, r, 6, 6))
+            return false;
+        fields[0] = r.v;
+        if (sgn === 45) {
+            if (fields[0] === 0)
+                return false; // reject -000000
+            fields[0] = -fields[0];
+        }
+    }
+    else {
+        if (!string_get_digits(s, r, 4, 4))
+            return false;
+        fields[0] = r.v;
+    }
+    if (string_skip_char(s, 45 /* - */)) {
+        if (!string_get_digits(s, r, 2, 2))
+            return false; /* month */
+        fields[1] = r.v;
+        if (fields[1] < 1)
+            return false;
+        fields[1] -= 1;
+        if (string_skip_char(s, 45)) {
+            if (!string_get_digits(s, r, 2, 2))
+                return false; /* day */
+            fields[2] = r.v;
+            if (fields[2] < 1)
+                return false;
+        }
+    }
+    if (string_skip_char(s, 84 /* T */)) {
+        pis_local.v = true;
+        if (!string_get_digits(s, r, 2, 2)) { /* hour */
+            fields[3] = 100; // reject unconditionally
+            return true;
+        }
+        fields[3] = r.v;
+        if (!string_skip_char(s, 58 /* : */) || !string_get_digits(s, r, 2, 2)) { /* minute */
+            fields[3] = 100; // reject unconditionally
+            return true;
+        }
+        fields[4] = r.v;
+        if (string_skip_char(s, 58)) {
+            if (!string_get_digits(s, r, 2, 2))
+                return false; /* second */
+            fields[5] = r.v;
+            const rms = { v: fields[6] };
+            string_get_milliseconds(s, rms);
+            fields[6] = rms.v;
+        }
+    }
+    /* parse the time zone offset if present: [+-]HH:mm or [+-]HHmm */
+    if (s.cur()) {
+        pis_local.v = false;
+        const rtz = { v: 0 };
+        if (!string_get_tzoffset(s, rtz, true))
+            return false;
+        fields[8] = rtz.v;
+    }
+    /* error if extraneous characters */
+    return s.cur() === 0;
+}
+const js_tzabbr = [
+    ['GMT', 0], // Greenwich Mean Time
+    ['UTC', 0], // Coordinated Universal Time
+    ['UT', 0], // Universal Time
+    ['Z', 0], // Zulu Time
+    ['EDT', -4 * 60], // Eastern Daylight Time
+    ['EST', -5 * 60], // Eastern Standard Time
+    ['CDT', -5 * 60], // Central Daylight Time
+    ['CST', -6 * 60], // Central Standard Time
+    ['MDT', -6 * 60], // Mountain Daylight Time
+    ['MST', -7 * 60], // Mountain Standard Time
+    ['PDT', -7 * 60], // Pacific Daylight Time
+    ['PST', -8 * 60], // Pacific Standard Time
+    ['WET', +0 * 60], // Western European Time
+    ['WEST', +1 * 60], // Western European Summer Time
+    ['CET', +1 * 60], // Central European Time
+    ['CEST', +2 * 60], // Central European Summer Time
+    ['EET', +2 * 60], // Eastern European Time
+    ['EEST', +3 * 60], // Eastern European Summer Time
+];
+function string_get_tzabbr(s, offset) {
+    for (const [name, off] of js_tzabbr) {
+        if (string_match(s, name)) {
+            offset.v = off;
+            return true;
+        }
+    }
+    return false;
+}
+/* parse toString, toUTCString and other formats */
+function js_date_parse_otherstring(sp, fields, pis_local) {
+    const s = new DateParser(sp);
+    let c;
+    const num = [0, 0, 0];
+    let has_year = false;
+    let has_mon = false;
+    let has_time = false;
+    let num_index = 0;
+    const r = { v: 0 };
+    /* initialize fields to the beginning of 2001-01-01 */
+    fields[0] = 2001;
+    fields[1] = 1;
+    fields[2] = 1;
+    for (let i = 3; i < 9; i++)
+        fields[i] = 0;
+    pis_local.v = true;
+    while (string_skip_spaces(s)) {
+        const p_start = s.p;
+        if ((c = s.cur()) === 43 /* + */ || c === 45 /* - */) {
+            const rtz = { v: 0 };
+            if (has_time && string_get_tzoffset(s, rtz, false)) {
+                fields[8] = rtz.v;
+                pis_local.v = false;
+            }
+            else {
+                s.p++;
+                if (string_get_digits(s, r, 1, 0)) {
+                    let val = r.v;
+                    if (c === 45) {
+                        if (val === 0)
+                            return false;
+                        val = -val;
+                    }
+                    fields[0] = val;
+                    has_year = true;
+                }
+            }
+        }
+        else if (string_get_digits(s, r, 1, 0)) {
+            const val = r.v;
+            if (string_skip_char(s, 58 /* : */)) {
+                /* time part */
+                fields[3] = val;
+                if (!string_get_digits(s, r, 1, 2))
+                    return false;
+                fields[4] = r.v;
+                if (string_skip_char(s, 58)) {
+                    if (!string_get_digits(s, r, 1, 2))
+                        return false;
+                    fields[5] = r.v;
+                    const rms = { v: fields[6] };
+                    string_get_milliseconds(s, rms);
+                    fields[6] = rms.v;
+                }
+                has_time = true;
+            }
+            else {
+                if (s.p - p_start > 2) {
+                    fields[0] = val;
+                    has_year = true;
+                }
+                else if (val < 1 || val > 31) {
+                    fields[0] = val + (val < 100 ? 1900 : 0) + (val < 50 ? 100 : 0);
+                    has_year = true;
+                }
+                else {
+                    if (num_index === 3)
+                        return false;
+                    num[num_index++] = val;
+                }
+            }
+        }
+        else if (string_get_month(s, r)) {
+            fields[1] = r.v;
+            has_mon = true;
+            string_skip_until(s, '0123456789 -/(');
+        }
+        else if (has_time && string_match(s, 'PM')) {
+            if (fields[3] < 12)
+                fields[3] += 12;
+            continue;
+        }
+        else if (has_time && string_match(s, 'AM')) {
+            if (fields[3] === 12)
+                fields[3] -= 12;
+            continue;
+        }
+        else if (string_get_tzabbr(s, r)) {
+            fields[8] = r.v;
+            pis_local.v = false;
+            continue;
+        }
+        else if (c === 40 /* ( */) { /* skip parenthesized phrase */
+            let level = 0;
+            while ((c = s.cur()) !== 0) {
+                s.p++;
+                level += (c === 40) ? 1 : 0;
+                level -= (c === 41) ? 1 : 0;
+                if (!level)
+                    break;
+            }
+            if (level > 0)
+                return false;
+        }
+        else if (c === 41 /* ) */) {
+            return false;
+        }
+        else {
+            if ((has_year ? 1 : 0) + (has_mon ? 1 : 0) + (has_time ? 1 : 0) + num_index)
+                return false;
+            /* skip a word */
+            string_skip_until(s, ' -/(');
+        }
+        string_skip_separators(s);
+    }
+    if (num_index + (has_year ? 1 : 0) + (has_mon ? 1 : 0) > 3)
+        return false;
+    switch (num_index) {
+        case 0:
+            if (!has_year)
+                return false;
+            break;
+        case 1:
+            if (has_mon)
+                fields[2] = num[0];
+            else
+                fields[1] = num[0];
+            break;
+        case 2:
+            if (has_year) {
+                fields[1] = num[0];
+                fields[2] = num[1];
+            }
+            else if (has_mon) {
+                fields[0] = num[1] + (num[1] < 100 ? 1900 : 0) + (num[1] < 50 ? 100 : 0);
+                fields[2] = num[0];
+            }
+            else {
+                fields[1] = num[0];
+                fields[2] = num[1];
+            }
+            break;
+        case 3:
+            fields[0] = num[2] + (num[2] < 100 ? 1900 : 0) + (num[2] < 50 ? 100 : 0);
+            fields[1] = num[0];
+            fields[2] = num[1];
+            break;
+        default:
+            return false;
+    }
+    if (fields[1] < 1 || fields[2] < 1)
+        return false;
+    fields[1] -= 1;
+    return true;
+}
+function js_Date_parse(ctx, this_val, argv) {
+    let rv = NaN;
+    const s = JS_ToString(ctx, argv[0]);
+    if (JS_IsException(s))
+        return JS_EXCEPTION;
+    const str = s;
+    /* convert the string as a byte array */
+    const n = Math.min(str.length, 127);
+    const buf = new Uint8Array(n + 1);
+    for (let i = 0; i < n; i++) {
+        let c = str.charCodeAt(i);
+        if (c > 255)
+            c = (c === 0x2212) ? 45 /* - */ : 120 /* x */;
+        buf[i] = c;
+    }
+    buf[n] = 0;
+    const fields = new Array(9).fill(0);
+    const is_local = { v: false };
+    if (js_date_parse_isostring(buf, fields, is_local) || js_date_parse_otherstring(buf, fields, is_local)) {
+        const field_max = [0, 11, 31, 24, 59, 59];
+        let valid = true;
+        /* check field maximum values */
+        for (let i = 1; i < 6; i++) {
+            if (fields[i] > field_max[i])
+                valid = false;
+        }
+        /* special case 24:00:00.000 */
+        if (fields[3] === 24 && (fields[4] | fields[5] | fields[6]))
+            valid = false;
+        if (valid) {
+            const fields1 = [];
+            for (let i = 0; i < 7; i++)
+                fields1[i] = fields[i];
+            rv = set_date_fields(fields1, is_local.v) - fields[8] * 60000;
+        }
+    }
+    return rv;
+}
+function js_Date_now(ctx, this_val, argv) {
+    // now()
+    return date_now();
+}
+function js_date_Symbol_toPrimitive(ctx, this_val, argv) {
+    // Symbol_toPrimitive(hint)
+    const obj = this_val;
+    let hint = JS_ATOM_NULL;
+    let hint_num;
+    if (!JS_IsObject(obj))
+        return JS_ThrowTypeErrorNotAnObject(ctx);
+    if (typeof argv[0] === 'string') {
+        hint = JS_ValueToAtom(ctx, argv[0]);
+        if (hint === JS_ATOM_NULL)
+            return JS_EXCEPTION;
+    }
+    switch (hint) {
+        case JS_ATOM_number:
+        case JS_ATOM_integer:
+            hint_num = HINT_NUMBER;
+            break;
+        case JS_ATOM_string:
+        case JS_ATOM_default:
+            hint_num = HINT_STRING;
+            break;
+        default:
+            return JS_ThrowTypeError(ctx, 'invalid hint');
+    }
+    return JS_ToPrimitive(ctx, obj, hint_num | HINT_FORCE_ORDINARY);
+}
+function js_date_getTimezoneOffset(ctx, this_val, argv) {
+    // getTimezoneOffset()
+    const v = JS_ThisTimeValue(ctx, this_val);
+    if (JS_IsException(v))
+        return JS_EXCEPTION;
+    if (Number.isNaN(v))
+        return NaN;
+    /* assuming -8.64e15 <= v <= -8.64e15 */
+    return getTimezoneOffset(Math.trunc(v));
+}
+function js_date_getTime(ctx, this_val, argv) {
+    // getTime()
+    const v = JS_ThisTimeValue(ctx, this_val);
+    if (JS_IsException(v))
+        return JS_EXCEPTION;
+    return v;
+}
+function js_date_setTime(ctx, this_val, argv) {
+    // setTime(v)
+    const tv = JS_ThisTimeValue(ctx, this_val);
+    if (JS_IsException(tv))
+        return JS_EXCEPTION;
+    const v = JS_ToFloat64(ctx, argv[0]);
+    if (JS_IsException(v))
+        return JS_EXCEPTION;
+    return JS_SetThisTimeValue(ctx, this_val, time_clip(v));
+}
+function js_date_setYear(ctx, this_val, argv) {
+    // setYear(y)
+    const tv = JS_ThisTimeValue(ctx, this_val);
+    if (JS_IsException(tv))
+        return JS_EXCEPTION;
+    const r = JS_ToFloat64(ctx, argv[0]);
+    if (JS_IsException(r))
+        return JS_EXCEPTION;
+    let y = +r;
+    if (Number.isFinite(y)) {
+        y = Math.trunc(y);
+        if (y >= 0 && y < 100)
+            y += 1900;
+    }
+    return set_date_field_argc(ctx, this_val, [y], 1, 0x011);
+}
+function js_date_toJSON(ctx, this_val, argv) {
+    // toJSON(key)
+    const obj = JS_ToObject(ctx, this_val);
+    if (JS_IsException(obj))
+        return JS_EXCEPTION;
+    const tv = JS_ToPrimitive(ctx, obj, HINT_NUMBER);
+    if (JS_IsException(tv))
+        return JS_EXCEPTION;
+    if (typeof tv === 'number') {
+        if (!Number.isFinite(tv))
+            return null;
+    }
+    const method = JS_GetPropertyStr(ctx, obj, 'toISOString');
+    if (JS_IsException(method))
+        return JS_EXCEPTION;
+    if (!JS_IsFunction(ctx, method)) {
+        return JS_ThrowTypeError(ctx, 'object needs toISOString method');
+    }
+    return JS_Call(ctx, method, obj, []);
+}
+const js_date_funcs = [
+    JS_CFUNC_DEF('now', 0, js_Date_now),
+    JS_CFUNC_DEF('parse', 1, js_Date_parse),
+    JS_CFUNC_DEF('UTC', 7, js_Date_UTC),
+];
+const js_date_proto_funcs = [
+    JS_CFUNC_DEF('valueOf', 0, js_date_getTime),
+    JS_CFUNC_MAGIC_DEF('toString', 0, get_date_string, 0x13),
+    JS_CFUNC_DEF(JS_ATOM_Symbol_toPrimitive, 1, js_date_Symbol_toPrimitive),
+    JS_CFUNC_MAGIC_DEF('toUTCString', 0, get_date_string, 0x03),
+    JS_ALIAS_DEF('toGMTString', 'toUTCString'),
+    JS_CFUNC_MAGIC_DEF('toISOString', 0, get_date_string, 0x23),
+    JS_CFUNC_MAGIC_DEF('toDateString', 0, get_date_string, 0x11),
+    JS_CFUNC_MAGIC_DEF('toTimeString', 0, get_date_string, 0x12),
+    JS_CFUNC_MAGIC_DEF('toLocaleString', 0, get_date_string, 0x33),
+    JS_CFUNC_MAGIC_DEF('toLocaleDateString', 0, get_date_string, 0x31),
+    JS_CFUNC_MAGIC_DEF('toLocaleTimeString', 0, get_date_string, 0x32),
+    JS_CFUNC_DEF('getTimezoneOffset', 0, js_date_getTimezoneOffset),
+    JS_CFUNC_DEF('getTime', 0, js_date_getTime),
+    JS_CFUNC_MAGIC_DEF('getYear', 0, get_date_field, 0x101),
+    JS_CFUNC_MAGIC_DEF('getFullYear', 0, get_date_field, 0x01),
+    JS_CFUNC_MAGIC_DEF('getUTCFullYear', 0, get_date_field, 0x00),
+    JS_CFUNC_MAGIC_DEF('getMonth', 0, get_date_field, 0x11),
+    JS_CFUNC_MAGIC_DEF('getUTCMonth', 0, get_date_field, 0x10),
+    JS_CFUNC_MAGIC_DEF('getDate', 0, get_date_field, 0x21),
+    JS_CFUNC_MAGIC_DEF('getUTCDate', 0, get_date_field, 0x20),
+    JS_CFUNC_MAGIC_DEF('getHours', 0, get_date_field, 0x31),
+    JS_CFUNC_MAGIC_DEF('getUTCHours', 0, get_date_field, 0x30),
+    JS_CFUNC_MAGIC_DEF('getMinutes', 0, get_date_field, 0x41),
+    JS_CFUNC_MAGIC_DEF('getUTCMinutes', 0, get_date_field, 0x40),
+    JS_CFUNC_MAGIC_DEF('getSeconds', 0, get_date_field, 0x51),
+    JS_CFUNC_MAGIC_DEF('getUTCSeconds', 0, get_date_field, 0x50),
+    JS_CFUNC_MAGIC_DEF('getMilliseconds', 0, get_date_field, 0x61),
+    JS_CFUNC_MAGIC_DEF('getUTCMilliseconds', 0, get_date_field, 0x60),
+    JS_CFUNC_MAGIC_DEF('getDay', 0, get_date_field, 0x71),
+    JS_CFUNC_MAGIC_DEF('getUTCDay', 0, get_date_field, 0x70),
+    JS_CFUNC_DEF('setTime', 1, js_date_setTime),
+    JS_CFUNC_MAGIC_DEF('setMilliseconds', 1, set_date_field, 0x671),
+    JS_CFUNC_MAGIC_DEF('setUTCMilliseconds', 1, set_date_field, 0x670),
+    JS_CFUNC_MAGIC_DEF('setSeconds', 2, set_date_field, 0x571),
+    JS_CFUNC_MAGIC_DEF('setUTCSeconds', 2, set_date_field, 0x570),
+    JS_CFUNC_MAGIC_DEF('setMinutes', 3, set_date_field, 0x471),
+    JS_CFUNC_MAGIC_DEF('setUTCMinutes', 3, set_date_field, 0x470),
+    JS_CFUNC_MAGIC_DEF('setHours', 4, set_date_field, 0x371),
+    JS_CFUNC_MAGIC_DEF('setUTCHours', 4, set_date_field, 0x370),
+    JS_CFUNC_MAGIC_DEF('setDate', 1, set_date_field, 0x231),
+    JS_CFUNC_MAGIC_DEF('setUTCDate', 1, set_date_field, 0x230),
+    JS_CFUNC_MAGIC_DEF('setMonth', 2, set_date_field, 0x131),
+    JS_CFUNC_MAGIC_DEF('setUTCMonth', 2, set_date_field, 0x130),
+    JS_CFUNC_DEF('setYear', 1, js_date_setYear),
+    JS_CFUNC_MAGIC_DEF('setFullYear', 3, set_date_field, 0x031),
+    JS_CFUNC_MAGIC_DEF('setUTCFullYear', 3, set_date_field, 0x030),
+    JS_CFUNC_DEF('toJSON', 1, js_date_toJSON),
+];
+export function JS_NewDate(ctx, epoch_ms) {
+    const obj = js_create_from_ctor(ctx, undefined, 10 /* JSClassID.DATE */);
+    if (JS_IsException(obj))
+        return JS_EXCEPTION;
+    Q.JS_SetOpaque(obj, time_clip(epoch_ms));
+    return obj;
+}
+export function JS_AddIntrinsicDate(ctx) {
+    /* Date */
+    const proto = JS_NewObject(ctx);
+    ctx.class_proto[10 /* JSClassID.DATE */] = proto;
+    JS_SetPropertyFunctionList(ctx, proto, js_date_proto_funcs);
+    const obj = JS_NewGlobalCConstructor(ctx, 'Date', js_date_constructor, 7, proto);
+    JS_SetPropertyFunctionList(ctx, obj, js_date_funcs);
+}
+//# sourceMappingURL=date.js.map