@swf2es/player-hosts 0.0.0-stage → 0.1.0

package/dist/thread/runtime/avm2/natives/date.js

@@ -0,0 +1,581 @@
+// Date, as avmplus' DateClass and Date: the time a Date holds, its fields
+// by the indices Date.as asks for, the setters, its strings in avmplus'
+// formats, which are not JavaScript's, and its own parser of them for
+// Date.parse and new Date(string).
+//
+// The calendar is avmplus' own arithmetic, not JavaScript's Date: avmplus
+// clips only some results to the time domain, and casts years and seconds
+// to 32-bit ints, which wrap where JavaScript would give NaN. Local time is
+// avmshell's on a POSIX host: the standard offset of now, plus an hour
+// where the host's time zone says daylight saving is in effect, asked of the
+// host (here through JavaScript's Date) with the time in 32-bit seconds.
+// So no zone's history beyond its daylight saving applies, and none after
+// 2038. Flash on Windows (WinPortUtils) applies the zone's rule of today
+// to every year instead, 1900 and 2050 alike; avmshell is the reference.
+//
+// The calendar, local time and parseDate are translated from avmplus'
+// core/Date.cpp, core/DateClass.cpp and VMPI/PosixPortUtils.cpp, and so subject
+// to the Mozilla Public License, v. 2.0: http://mozilla.org/MPL/2.0/.
+const AS3 = "http://adobe.com/AS3/2006/builtin";
+const MONTHS = "JanFebMarAprMayJunJulAugSepOctNovDec";
+const DAYS = "SunMonTueWedThuFriSat";
+const MS_PER_DAY = 86400000;
+const MS_PER_HOUR = 3600000;
+const MS_PER_MINUTE = 60000;
+const MS_PER_SECOND = 1000;
+/** A double cast to a C int on x86: INT_MIN for NaN and anything out of range. */
+function cInt(x) {
+    return x >= -2147483648 && x < 2147483648 ? Math.trunc(x) | 0 : -2147483648;
+}
+/** As MathUtils::toInt: ToInteger, but infinities kept. */
+function toInt(x) {
+    if (Number.isNaN(x)) {
+        return 0;
+    }
+    return Number.isFinite(x) ? Math.trunc(x) : x;
+}
+/** As Date::TimeClip: NaN beyond 8.64e15 milliseconds, else an integer. */
+function timeClip(t) {
+    if (!Number.isFinite(t) || Math.abs(t) > 8.64e15) {
+        return Number.NaN;
+    }
+    return Math.trunc(t) + 0;
+}
+const MONTH_OFFSET = [
+    [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365],
+    [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366],
+];
+const day = (t) => Math.floor(t / MS_PER_DAY);
+const dayFromYear = (year) => 365 * (year - 1970) +
+    Math.floor((year - 1969) / 4) -
+    Math.floor((year - 1901) / 100) +
+    Math.floor((year - 1601) / 400);
+const timeFromYear = (year) => MS_PER_DAY * dayFromYear(year);
+/** As IsLeapYear, of an int: 1 or 0, to index MONTH_OFFSET. */
+const leap = (year) => year % 4 !== 0 ? 0 : year % 100 !== 0 ? 1 : year % 400 !== 0 ? 0 : 1;
+function yearFromTime(t) {
+    const d = day(t);
+    let lo = (cInt(Math.floor(t < 0 ? d / 365 : d / 366)) + 1970) | 0;
+    let hi = (cInt(Math.ceil(t < 0 ? d / 366 : d / 365)) + 1970) | 0;
+    while (lo < hi) {
+        const pivot = cInt((lo + hi) / 2);
+        const pivotTime = timeFromYear(pivot);
+        if (pivotTime <= t) {
+            if (timeFromYear((pivot + 1) | 0) > t) {
+                return pivot;
+            }
+            lo = (pivot + 1) | 0;
+        }
+        else {
+            hi = (pivot - 1) | 0;
+        }
+    }
+    return lo;
+}
+const dayWithinYear = (t) => cInt(day(t) - dayFromYear(yearFromTime(t)));
+function monthFromTime(t) {
+    const d = dayWithinYear(t);
+    const offsets = MONTH_OFFSET[leap(yearFromTime(t))];
+    let i = 0;
+    while (i < 11 && d >= offsets[i + 1]) {
+        i++;
+    }
+    return i;
+}
+const dateFromTime = (t) => dayWithinYear(t) - MONTH_OFFSET[leap(yearFromTime(t))][monthFromTime(t)] + 1;
+/** C's (int) of a remainder, made non-negative by adding the divisor. */
+function positive(r, n) {
+    const i = cInt(r);
+    return i < 0 ? i + n : i;
+}
+const weekDay = (t) => positive((day(t) + 4) % 7, 7);
+const hourFromTime = (t) => positive(Math.floor((t + 0.5) / MS_PER_HOUR) % 24, 24);
+const minFromTime = (t) => positive(Math.floor(t / MS_PER_MINUTE) % 60, 60);
+const secFromTime = (t) => positive(Math.floor(t / MS_PER_SECOND) % 60, 60);
+const msecFromTime = (t) => positive(t % MS_PER_SECOND, MS_PER_SECOND);
+function timeWithinDay(t) {
+    const r = t % MS_PER_DAY;
+    return r < 0 ? r + MS_PER_DAY : r;
+}
+function makeDay(year, month, date) {
+    if (!Number.isFinite(year) || !Number.isFinite(month) || !Number.isFinite(date)) {
+        return Number.NaN;
+    }
+    let y = toInt(year);
+    let m = toInt(month);
+    y += Math.floor(m / 12);
+    m %= 12;
+    if (m < 0) {
+        m += 12;
+    }
+    const iMonth = cInt(Math.floor(m));
+    if (iMonth < 0 || iMonth >= 12) {
+        return Number.NaN;
+    }
+    const iYear = cInt(y);
+    return dayFromYear(iYear) + MONTH_OFFSET[leap(iYear)][iMonth] + (toInt(date) - 1);
+}
+function makeTime(hour, min, sec, ms) {
+    if (!Number.isFinite(hour) ||
+        !Number.isFinite(min) ||
+        !Number.isFinite(sec) ||
+        !Number.isFinite(ms)) {
+        return Number.NaN;
+    }
+    return (toInt(hour) * MS_PER_HOUR + toInt(min) * MS_PER_MINUTE + toInt(sec) * MS_PER_SECOND + toInt(ms));
+}
+function makeDate(d, time) {
+    if (!Number.isFinite(d) || !Number.isFinite(time)) {
+        return Number.NaN;
+    }
+    return toInt(d) * MS_PER_DAY + toInt(time);
+}
+/** The host's offset east of UTC at a time, in milliseconds, its zone's history included. */
+const hostOffset = (ms) => -new Date(ms).getTimezoneOffset() * MS_PER_MINUTE;
+const standardOffsets = new Map();
+/** The host's standard offset in a year: the lesser of January's and July's, whichever has daylight saving. */
+function standardOffset(year) {
+    let offset = standardOffsets.get(year);
+    if (offset === undefined) {
+        const jan = new Date(0);
+        jan.setUTCFullYear(year, 0, 1);
+        const jul = new Date(0);
+        jul.setUTCFullYear(year, 6, 1);
+        offset = Math.min(hostOffset(jan.getTime()), hostOffset(jul.getTime()));
+        standardOffsets.set(year, offset);
+    }
+    return offset;
+}
+let tza = 0;
+let tzaUntil = Number.NEGATIVE_INFINITY;
+/**
+ * As VMPI_getLocalTimeOffset: the standard offset of now, whatever the time
+ * asked about. Read again once a minute, as WinPortUtils does, since every
+ * local field reads it.
+ */
+function localTZA() {
+    const now = Date.now();
+    if (now >= tzaUntil) {
+        tza = standardOffset(yearFromTime(now));
+        tzaUntil = now + MS_PER_MINUTE;
+    }
+    return tza;
+}
+// The last second daylightSavingTA was asked about: a Date's local getters ask about the same one.
+let lastDstSecond = Number.NaN;
+let lastDst = 0;
+/**
+ * As VMPI_getDaylightSavingsTA: an hour where localtime_r says daylight
+ * saving is in effect, of the time in seconds in a 32-bit time_t. An offset
+ * at least half an hour past the year's standard one is daylight saving;
+ * a lesser change is the zone's own history, which avmshell does not see.
+ */
+function daylightSavingTA(t) {
+    const ms = cInt(t / MS_PER_SECOND) * MS_PER_SECOND;
+    if (ms !== lastDstSecond) {
+        lastDstSecond = ms;
+        lastDst =
+            hostOffset(ms) - standardOffset(yearFromTime(ms)) >= 30 * MS_PER_MINUTE ? MS_PER_HOUR : 0;
+    }
+    return lastDst;
+}
+const localTime = (t) => t + localTZA() + daylightSavingTA(t);
+/** As Date.cpp's UTC: local time to UTC, a time in the spring-forward gap an hour later. */
+function utc(t) {
+    const adj = localTZA();
+    const dst = daylightSavingTA(t - adj);
+    if (dst !== 0 && daylightSavingTA(t - adj - MS_PER_HOUR) === 0) {
+        t += MS_PER_HOUR;
+    }
+    return t - adj - dst;
+}
+/** As Date::Date of fields: years below 100 are 1900's; the time is not clipped. */
+function fromFields(n, local) {
+    const year = n[0] < 100 ? n[0] + 1900 : n[0];
+    const t = makeDate(makeDay(year, n[1], n[2]), makeTime(n[3], n[4], n[5], n[6]));
+    return local ? utc(t) : t;
+}
+/** Format's %2: two digits, as characters from '0', whatever the value. */
+const pad2 = (n) => String.fromCharCode(48 + Math.trunc(n / 10), 48 + (n % 10));
+/** As Date::toString, by its format index; empty if the time's fields are out of range. */
+function format(t, index) {
+    if (Number.isNaN(t)) {
+        return "Invalid Date";
+    }
+    const time = index === 6 ? t : localTime(t);
+    const year = yearFromTime(time);
+    const month = monthFromTime(time);
+    const dow = weekDay(time);
+    if (month < 0 || month >= 12 || dow < 0 || dow >= 7) {
+        return "";
+    }
+    let delta = cInt((time - t) / MS_PER_MINUTE);
+    const sign = delta < 0 ? "-" : "+";
+    delta = Math.abs(delta);
+    const zone = `GMT${sign}${pad2(Math.trunc(delta / 60))}${pad2(delta % 60)}`;
+    const date = dateFromTime(time);
+    const hour24 = hourFromTime(time);
+    const hour12 = hour24 % 12 === 0 ? 12 : hour24 % 12;
+    const ampm = hour24 >= 12 ? "P" : "A";
+    const min = minFromTime(time);
+    const sec = secFromTime(time);
+    const dayName = DAYS.substr(dow * 3, 3);
+    const mon = MONTHS.substr(month * 3, 3);
+    const clock = `${pad2(hour24)}:${pad2(min)}:${pad2(sec)}`;
+    switch (index) {
+        case 0:
+            return `${dayName} ${mon} ${date} ${clock} ${zone} ${year}`;
+        case 1:
+        case 4:
+            return `${dayName} ${mon} ${date} ${year}`;
+        case 2:
+            return `${clock} ${zone}`;
+        case 3:
+            return `${dayName} ${mon} ${date} ${year} ${pad2(hour12)}:${pad2(min)}:${pad2(sec)} ${ampm}M`;
+        case 5:
+            return `${pad2(hour12)}:${pad2(min)}:${pad2(sec)} ${ampm}M`;
+        default:
+            return `${dayName} ${mon} ${date} ${clock} ${year} UTC`;
+    }
+}
+/** A Date's field by Date.as' index: UTC fields 0 to 7, local 8 to 15, the offset 16, the time 17. */
+function field(t, index) {
+    if (Number.isNaN(t)) {
+        return Number.NaN;
+    }
+    if (index === 16) {
+        return (t - localTime(t)) / MS_PER_MINUTE;
+    }
+    if (index >= 17) {
+        return t;
+    }
+    const time = index >= 8 ? localTime(t) : t;
+    switch (index & 7) {
+        case 0:
+            return yearFromTime(time);
+        case 1:
+            return monthFromTime(time);
+        case 2:
+            return dateFromTime(time);
+        case 3:
+            return weekDay(time);
+        case 4:
+            return hourFromTime(time);
+        case 5:
+            return minFromTime(time);
+        case 6:
+            return secFromTime(time);
+        default:
+            return msecFromTime(time);
+    }
+}
+/**
+ * As DateObject::_set: the fields from setter `index`'s on, NaN for those
+ * not given; a NaN given makes the time NaN. Indices 1 to 3 set the date,
+ * 4 to 7 the time, negative ones in UTC.
+ */
+function set(rt, time, index, args) {
+    const n = [Number.NaN, Number.NaN, Number.NaN, Number.NaN, Number.NaN, Number.NaN, Number.NaN];
+    const local = index > 0;
+    const first = Math.abs(index) - 1;
+    for (let i = 0; i < args.length && first + i < 7; i++) {
+        n[first + i] = rt.toNumber(args[i]);
+        if (Number.isNaN(n[first + i])) {
+            return Number.NaN;
+        }
+    }
+    let t = local ? localTime(time) : time;
+    if (first < 3) {
+        // As Date::setDate: a NaN time stays NaN unless a year is set, from 0.
+        if (Number.isNaN(time)) {
+            if (Number.isNaN(n[0])) {
+                return time;
+            }
+            t = 0;
+        }
+        const year = Number.isNaN(n[0]) ? yearFromTime(t) : n[0];
+        const month = Number.isNaN(n[1]) ? monthFromTime(t) : n[1];
+        const date = Number.isNaN(n[2]) ? dateFromTime(t) : n[2];
+        t = makeDate(makeDay(year, month, date), timeWithinDay(t));
+    }
+    else {
+        const hour = Number.isNaN(n[3]) ? hourFromTime(t) : n[3];
+        const min = Number.isNaN(n[4]) ? minFromTime(t) : n[4];
+        const sec = Number.isNaN(n[5]) ? secFromTime(t) : n[5];
+        const ms = Number.isNaN(n[6]) ? msecFromTime(t) : n[6];
+        t = makeDate(day(t), makeTime(hour, min, sec, ms));
+    }
+    return timeClip(local ? utc(t) : t);
+}
+const timeOf = (o) => o.$time ?? Number.NaN;
+const KEYWORDS = "JanFebMarAprMayJunJulAugSepOctNovDecSunMonTueWedThuFriSatGMTUTC";
+const UTC_KEYWORD = 12 + 7 + 1;
+/** As parseDateKeyword: a month, UTC, AM or PM, or a day or GMT, which say nothing; false if none. */
+function dateKeyword(word, f) {
+    if (word.length > 3) {
+        return false;
+    }
+    for (let i = 0; i < word.length; i++) {
+        const c = word.charCodeAt(i);
+        if (c < 65 || c > 122 || (c > 90 && c < 97)) {
+            return false;
+        }
+    }
+    if (word.length === 3) {
+        for (let x = 0; x < 7 + 12 + 2; x++) {
+            if (KEYWORDS.substr(x * 3, 3) === word) {
+                if (x < 12) {
+                    f.month = x;
+                }
+                else if (x === UTC_KEYWORD) {
+                    f.zone = 0;
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+    if (word === "AM" || word === "PM") {
+        const valid = f.hour <= 12 && f.hour >= 0;
+        if (word === "AM" && f.hour === 12) {
+            f.hour = 0;
+        }
+        else if (word === "PM" && f.hour !== 12) {
+            f.hour += 12;
+        }
+        return valid;
+    }
+    return false;
+}
+/**
+ * As DateClass::stringToDateDouble: the formats its toString writes and a
+ * few others ("1/1/1999 13:30 PM"), by numbers and the separators before
+ * and after them, and three-letter keywords; NaN for anything else.
+ */
+function parseDate(s) {
+    const f = { year: -1, month: -1, day: -1, hour: -1, min: -1, sec: -1, zone: -1 };
+    const length = s.length;
+    const code = (k) => s.charCodeAt(k);
+    const digit = (c) => c >= 48 && c <= 57;
+    const alpha = (c) => (c >= 65 && c <= 90) || (c >= 97 && c <= 122);
+    let prevc = 0;
+    let i = 0;
+    while (i < length) {
+        let c = code(i);
+        i++;
+        if (c <= 32 || c === 44 || c === 45) {
+            // Whitespace and delimiters; a '-' before a number is a zone's sign.
+            if (i < length && c === 45 && digit(code(i))) {
+                prevc = c;
+            }
+        }
+        else if (c === 47 || c === 58 || c === 43 || c === 45) {
+            prevc = c;
+        }
+        else if (digit(c)) {
+            // As parseDateNumber: a zone offset, a year, a month or day, a time unit.
+            // c is left the character after the digits, or the last digit at the end.
+            let n = c - 48;
+            while (i < length) {
+                c = code(i);
+                if (!digit(c)) {
+                    break;
+                }
+                n = n * 10 + c - 48;
+                i++;
+            }
+            let valid = true;
+            if (prevc === 43 || prevc === 45) {
+                n = n < 24 ? n * 60 : (n % 100) + Math.trunc(n / 100) * 60;
+                if (prevc === 43) {
+                    n = -n;
+                }
+                if (f.zone === 0 || f.zone === -1) {
+                    f.zone = n;
+                }
+                else {
+                    valid = false;
+                }
+            }
+            else if (n >= 70 || (prevc === 47 && f.month >= 0 && f.day >= 0 && f.year < 0)) {
+                if (f.year >= 0) {
+                    valid = false;
+                }
+                else if (c <= 32 || c === 44 || c === 47 || i >= length) {
+                    f.year = n < 100 ? n + 1900 : n;
+                }
+                else {
+                    valid = false;
+                }
+            }
+            else if (c === 47) {
+                if (f.month < 0) {
+                    f.month = n - 1;
+                }
+                else if (f.day < 0) {
+                    f.day = n;
+                }
+                else {
+                    valid = false;
+                }
+            }
+            else if (c === 58) {
+                if (f.hour < 0) {
+                    f.hour = n;
+                }
+                else if (f.min < 0) {
+                    f.min = n;
+                }
+                else {
+                    valid = false;
+                }
+            }
+            else if (i < length && c !== 44 && c > 32 && c !== 45) {
+                valid = false;
+            }
+            else if (f.hour >= 0 && f.min < 0) {
+                f.min = n;
+            }
+            else if (f.min >= 0 && f.sec < 0) {
+                f.sec = n;
+            }
+            else if (f.day < 0) {
+                f.day = n;
+            }
+            else {
+                valid = false;
+            }
+            if (!valid) {
+                return Number.NaN;
+            }
+            prevc = 0;
+        }
+        else {
+            // A keyword, of letters.
+            const start = i - 1;
+            while (i < length && alpha(code(i))) {
+                i++;
+            }
+            if (i <= start + 1 || !dateKeyword(s.slice(start, i), f)) {
+                return Number.NaN;
+            }
+            prevc = 0;
+        }
+    }
+    if (f.year < 0 || f.month < 0 || f.day < 0) {
+        return Number.NaN;
+    }
+    const sec = Math.max(f.sec, 0);
+    const min = Math.max(f.min, 0);
+    const hour = Math.max(f.hour, 0);
+    // No zone: local time. Else UTC, and the offset east of it in minutes.
+    const fields = [f.year, f.month, f.day, hour, min, sec, 0];
+    if (f.zone === -1) {
+        return fromFields(fields, true);
+    }
+    return fromFields(fields, false) + f.zone * 60000;
+}
+/** As DateClass::construct: now, a time, a string, a Date, or local fields. */
+function construct(rt, cls, args) {
+    const o = cls.$it.instance();
+    if (args.length === 0) {
+        o.$time = Date.now();
+    }
+    else if (args.length === 1) {
+        const v = args[0];
+        if (v?.$time !== undefined) {
+            o.$time = v.$time;
+        }
+        else {
+            // A string is parsed; anything else is a number, as AvmCore::number
+            // makes it, an object's string from valueOf too. Either is clipped,
+            // though Date.parse leaves its result unclipped.
+            o.$time = timeClip(typeof v === "string" ? parseDate(v) : rt.toNumber(v));
+        }
+    }
+    else {
+        const n = [0, 0, 1, 0, 0, 0, 0];
+        for (let i = 0; i < args.length && i < 7; i++) {
+            n[i] = rt.toNumber(args[i]);
+        }
+        o.$time = fromFields(n, true);
+    }
+    return o;
+}
+export const dateHook = {
+    construct,
+    // Date.prototype is a Date, of no time.
+    prototype: (_rt, cls) => {
+        const o = cls.$it.instance();
+        o.$time = Number.NaN;
+        return o;
+    },
+    // Date() called is the time now, as a string.
+    call: () => format(Date.now(), 0),
+};
+export function dateNatives() {
+    const natives = {
+        "Date.parse": (rt) => (s) => parseDate(rt.toString(s)),
+        "Date.UTC": (rt) => (...args) => {
+            const n = args.map((a) => rt.toNumber(a));
+            return fromFields([n[0], n[1], n[2] ?? 1, n[3] ?? 0, n[4] ?? 0, n[5] ?? 0, n[6] ?? 0], false);
+        },
+        "Date#Date::_get": () => function (index) {
+            return field(timeOf(this), index);
+        },
+        "Date#Date::_toString": () => function (index) {
+            return format(timeOf(this), index);
+        },
+        "Date#Date::_setTime": (rt) => function (v) {
+            this.$time = timeClip(rt.toNumber(v));
+            return this.$time;
+        },
+        [`Date#${AS3}::getTime`]: () => function () {
+            return timeOf(this);
+        },
+        [`Date#${AS3}::valueOf`]: () => function () {
+            return timeOf(this);
+        },
+        [`Date#${AS3}::getTimezoneOffset`]: () => function () {
+            return field(timeOf(this), 16);
+        },
+    };
+    // The getters by field, as their native names ask for them.
+    const getters = [
+        ["getUTCFullYear", 0],
+        ["getUTCMonth", 1],
+        ["getUTCDate", 2],
+        ["getUTCDay", 3],
+        ["getUTCHours", 4],
+        ["getUTCMinutes", 5],
+        ["getUTCSeconds", 6],
+        ["getUTCMilliseconds", 7],
+        ["getFullYear", 8],
+        ["getMonth", 9],
+        ["getDate", 10],
+        ["getDay", 11],
+        ["getHours", 12],
+        ["getMinutes", 13],
+        ["getSeconds", 14],
+        ["getMilliseconds", 15],
+    ];
+    for (const [name, index] of getters) {
+        natives[`Date#${AS3}::${name}`] = () => function () {
+            return field(timeOf(this), index);
+        };
+    }
+    // The setters, by DateObject's indices: 1 to 7 local, negated in UTC.
+    const setters = ["FullYear", "Month", "Date", "Hours", "Minutes", "Seconds", "Milliseconds"];
+    for (let i = 0; i < setters.length; i++) {
+        for (const [prefix, index] of [
+            ["", i + 1],
+            ["UTC", -(i + 1)],
+        ]) {
+            natives[`Date#Date::_set${prefix}${setters[i]}`] = (rt) => function (...args) {
+                this.$time = set(rt, timeOf(this), index, args);
+                return this.$time;
+            };
+        }
+    }
+    return natives;
+}