@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/runtime/avm1/globals/date.js

@@ -0,0 +1,436 @@
+// Date, as Ruffle's (https://github.com/ruffle-rs/ruffle)
+// core/src/avm1/globals/date.rs has it: MIT OR Apache-2.0, Copyright (c)
+// 2018-2022 Ruffle LLC and Ruffle contributors. Where adl parts from
+// Ruffle, adl decides (docs/avm1.md, "Date").
+//
+// The calendar is ECMA-262's, in Ruffle's arithmetic (its int casts
+// included). Local time is Flash's on Windows, as adl has it: today's
+// standard offset in every year, and today's daylight saving rule applied
+// to every year, 1900 and 2050 alike, by its month, weekday and time, not
+// the zone's history (Ruffle adds a constant offset, no daylight saving).
+// A local time is taken back to UTC by the rule's local times, so a time
+// in the spring-forward gap is an hour earlier and one in the hour that
+// repeats as it falls back the later one.
+import { Avm1Object, DONT_DELETE, DONT_ENUM, READ_ONLY, } from "../objects.js";
+import { clampInt } from "../operators.js";
+import { toNumber } from "../values.js";
+/** What a Date object holds, in its `primitive`: the time, in ms since 1970 UTC, or NaN. */
+export class DateCell {
+    time;
+    constructor(time) {
+        this.time = time;
+    }
+}
+const MS_PER_SECOND = 1000;
+const MS_PER_MINUTE = 60000;
+const MS_PER_HOUR = 3600000;
+const MS_PER_DAY = 86400000;
+const MONTH_OFFSETS = [
+    [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],
+];
+/** `a mod n` taken non-negative, then cast as Ruffle casts it. */
+function remEuclid(a, n) {
+    const r = clampInt(a % n);
+    return r < 0 ? r + n : r;
+}
+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);
+const isLeap = (year) => year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+function yearOf(t) {
+    const d = day(t);
+    let low = clampInt(Math.floor(d / (t < 0 ? 365 : 366))) + 1970;
+    let high = clampInt(Math.ceil(d / (t < 0 ? 366 : 365))) + 1970;
+    while (low < high) {
+        const pivot = clampInt((low + high) / 2);
+        if (timeFromYear(pivot) <= t) {
+            if (timeFromYear(pivot + 1) > t) {
+                return pivot;
+            }
+            low = pivot + 1;
+        }
+        else {
+            high = pivot - 1;
+        }
+    }
+    return low;
+}
+const dayWithinYear = (t) => clampInt(day(t) - dayFromYear(yearOf(t)));
+function monthOf(t) {
+    const d = dayWithinYear(t);
+    const offsets = MONTH_OFFSETS[isLeap(yearOf(t)) ? 1 : 0];
+    for (let i = 0; i < 11; i++) {
+        if (d < offsets[i + 1]) {
+            return i;
+        }
+    }
+    return 11;
+}
+const dateOf = (t) => dayWithinYear(t) - MONTH_OFFSETS[isLeap(yearOf(t)) ? 1 : 0][monthOf(t)] + 1;
+const weekDay = (t) => remEuclid(day(t) + 4, 7);
+const hoursOf = (t) => remEuclid(Math.floor((t + 0.5) / MS_PER_HOUR), 24);
+const minutesOf = (t) => remEuclid(Math.floor(t / MS_PER_MINUTE), 60);
+const secondsOf = (t) => remEuclid(Math.floor(t / MS_PER_SECOND), 60);
+const msOf = (t) => remEuclid(t, MS_PER_SECOND);
+/** Up to SWF 7 the remainder takes the sign of the time, as Ruffle has it. */
+const timeWithinDay = (t, version) => version > 7 ? ((t % MS_PER_DAY) + MS_PER_DAY) % MS_PER_DAY : t % MS_PER_DAY;
+function makeTime(h, m, s, ms) {
+    return (Math.floor(h) * MS_PER_HOUR +
+        Math.floor(m) * MS_PER_MINUTE +
+        Math.floor(s) * MS_PER_SECOND +
+        Math.floor(ms));
+}
+function dayFromMonth(year, month) {
+    const y = clampInt(year);
+    const m = clampInt(Math.floor(month));
+    if (m < 0 || m > 11) {
+        return Number.NaN;
+    }
+    return dayFromYear(y) + MONTH_OFFSETS[isLeap(y) ? 1 : 0][m];
+}
+function makeDay(year, month, date) {
+    let y = Math.floor(year);
+    const m = Math.floor(month);
+    y += Math.floor(m / 12);
+    return dayFromMonth(y, ((m % 12) + 12) % 12) + Math.floor(date) - 1;
+}
+const makeDate = (d, time) => d * MS_PER_DAY + time;
+/** TimeClip: NaN past 100 million days either side of 1970, else whole. */
+function clip(t) {
+    return !Number.isFinite(t) || Math.abs(t) > 1e8 * MS_PER_DAY ? Number.NaN : Math.floor(t);
+}
+/** A date's fields, a year below 100 taken as 1900's. */
+function fromFields(args) {
+    let year = args[0];
+    if (year < 100) {
+        year += 1900;
+    }
+    return makeDate(makeDay(year, args[1], args.length > 2 ? args[2] : 1), makeTime(args.length > 3 ? args[3] : 0, args.length > 4 ? args[4] : 0, args.length > 5 ? args[5] : 0, args.length > 6 ? args[6] : 0));
+}
+let zone = null;
+const hostOffset = (t) => -new Date(t).getTimezoneOffset() * MS_PER_MINUTE;
+/** The first instant of `[from, to)` whose offset is not `from`'s, to the minute. */
+function transition(from, to) {
+    const before = hostOffset(from);
+    while (to - from > MS_PER_MINUTE) {
+        const mid = from + Math.floor((to - from) / MS_PER_MINUTE / 2) * MS_PER_MINUTE;
+        if (hostOffset(mid) === before) {
+            from = mid;
+        }
+        else {
+            to = mid;
+        }
+    }
+    return to;
+}
+/** A transition at `t` as a rule, its standard local time's month, weekday and week. */
+function ruleOf(t, standard) {
+    const local = t + standard;
+    const date = dateOf(local);
+    const length = MONTH_OFFSETS[isLeap(yearOf(local)) ? 1 : 0];
+    const month = monthOf(local);
+    const last = date + 7 > length[month + 1] - length[month];
+    return {
+        month,
+        weekday: weekDay(local),
+        week: last ? 5 : Math.floor((date - 1) / 7) + 1,
+        time: remEuclid(local, MS_PER_DAY),
+    };
+}
+/** The host's zone, read from its offsets this year, again as the year changes. */
+function hostZone() {
+    const now = Date.now();
+    if (zone !== null && now < zone.until) {
+        return zone;
+    }
+    const year = new Date(now).getUTCFullYear();
+    const months = [];
+    for (let m = 0; m <= 12; m++) {
+        months.push(Date.UTC(year, m, 1));
+    }
+    const offsets = months.map(hostOffset);
+    const standard = Math.min(...offsets);
+    const saving = Math.max(...offsets) - standard;
+    let start = null;
+    let end = null;
+    for (let m = 0; m < 12; m++) {
+        if (offsets[m] !== offsets[m + 1]) {
+            const t = transition(months[m], months[m + 1]);
+            if (hostOffset(t) > offsets[m]) {
+                start = ruleOf(t, standard);
+            }
+            else {
+                end = ruleOf(t, standard);
+            }
+        }
+    }
+    zone = { year, until: months[12], standard, saving, start, end };
+    return zone;
+}
+/** The instant a rule falls on in `year`. */
+function instant(rule, year, standard) {
+    const first = makeDay(year, rule.month, 1);
+    let date = 1 + ((rule.weekday - weekDay(first * MS_PER_DAY) + 7) % 7) + (rule.week - 1) * 7;
+    const length = makeDay(year, rule.month + 1, 1) - first;
+    while (date > length) {
+        date -= 7;
+    }
+    return makeDate(first + date - 1, rule.time) - standard;
+}
+/** The offset east of UTC at `t`, in ms: the standard offset, and daylight saving's by today's rule. */
+function offsetAt(t) {
+    const z = hostZone();
+    if (z.start === null || z.end === null || !Number.isFinite(t)) {
+        return z.standard;
+    }
+    const year = yearOf(t + z.standard);
+    const start = instant(z.start, year, z.standard);
+    const end = instant(z.end, year, z.standard);
+    const saving = start < end ? t >= start && t < end : !(t >= end && t < start);
+    return saving ? z.standard + z.saving : z.standard;
+}
+const localTime = (t) => t + offsetAt(t);
+/**
+ * A local time back to UTC, daylight saving's taken where the local time
+ * is past the rule's local standard time, as Windows compares them: a
+ * time in the spring-forward gap is an hour earlier, one in the hour
+ * that repeats as it falls back the later, standard one.
+ */
+const utcOf = (local) => local - offsetAt(local - hostZone().standard);
+const DAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+const two = (n) => (n < 10 ? `0${n}` : String(n));
+/** As Flash writes a date: "Thu Oct 15 12:34:56 GMT+0300 2026", local. */
+export function dateString(time) {
+    if (!Number.isFinite(time)) {
+        return "Invalid Date";
+    }
+    const t = localTime(time);
+    const offset = clampInt((t - time) / MS_PER_MINUTE);
+    const abs = Math.abs(offset);
+    return `${DAYS[weekDay(t)]} ${MONTHS[monthOf(t)]} ${dateOf(t)} ${two(hoursOf(t))}:${two(minutesOf(t))}:${two(secondsOf(t))} GMT${offset < 0 ? "-" : "+"}${two(Math.floor(abs / 60))}${two(abs % 60)} ${yearOf(t)}`;
+}
+// The methods' ASnative(103, i) indices, a UTC method 128 past its local one.
+const GET_FULL_YEAR = 0;
+const GET_YEAR = 1;
+const GET_MONTH = 2;
+const GET_DATE = 3;
+const GET_DAY = 4;
+const GET_HOURS = 5;
+const GET_MINUTES = 6;
+const GET_SECONDS = 7;
+const GET_MILLISECONDS = 8;
+const SET_FULL_YEAR = 9;
+const SET_MONTH = 10;
+const SET_DATE = 11;
+const SET_HOURS = 12;
+const SET_MINUTES = 13;
+const SET_SECONDS = 14;
+const SET_MILLISECONDS = 15;
+const GET_TIME = 16;
+const SET_TIME = 17;
+const GET_TIMEZONE_OFFSET = 18;
+const TO_STRING = 19;
+const SET_YEAR = 20;
+const CONSTRUCTOR = 256;
+const UTC = 257;
+const UTC_OFFSET = 128;
+/** The arguments as Date's natives take them: numbers, up to 7, to the first undefined. */
+function numbers(args, version) {
+    const out = [];
+    for (let i = 0; i < args.length && i < 7; i++) {
+        if (args[i] === undefined) {
+            break;
+        }
+        out.push(toNumber(args[i], version));
+    }
+    return out;
+}
+function now(version) {
+    const t = Date.now();
+    return version > 7 ? Math.round(t) : t;
+}
+/** ASnative(103, index): a Date method, the constructor, or Date.UTC. */
+function dateNative(index) {
+    return (self, rawArgs, version) => {
+        const args = numbers(rawArgs, version);
+        if (index === CONSTRUCTOR) {
+            let time;
+            if (args.length === 0) {
+                time = now(version);
+            }
+            else if (args.length === 1) {
+                time = args[0];
+            }
+            else {
+                time = utcOf(fromFields(args));
+            }
+            self.primitive = new DateCell(time);
+            return self;
+        }
+        if (index === UTC) {
+            return args.length < 2 ? undefined : fromFields(args);
+        }
+        const cell = self.primitive;
+        if (!(cell instanceof DateCell)) {
+            return undefined;
+        }
+        const time = cell.time;
+        switch (index) {
+            case GET_TIME:
+                return time;
+            case SET_TIME:
+                cell.time = clip(args.length > 0 ? args[0] : Number.NaN);
+                return cell.time;
+            case GET_TIMEZONE_OFFSET:
+                return (time - localTime(time)) / MS_PER_MINUTE;
+        }
+        const utc = index >= UTC_OFFSET;
+        let i = utc ? index - UTC_OFFSET : index;
+        if (i <= GET_MILLISECONDS && Number.isNaN(time)) {
+            return Number.NaN;
+        }
+        const setYear = i === SET_YEAR;
+        if (setYear) {
+            i = SET_FULL_YEAR;
+        }
+        const arg = (field) => field >= i && field - i < args.length
+            ? args[field - i]
+            : field === i
+                ? Number.NaN
+                : undefined;
+        const t = utc ? time : localTime(time);
+        const store = (d, within) => {
+            let value = makeDate(d, within);
+            if (!utc) {
+                value = utcOf(value);
+            }
+            cell.time = clip(value);
+            return cell.time;
+        };
+        switch (i) {
+            case GET_FULL_YEAR:
+                return yearOf(t);
+            case GET_YEAR:
+                return yearOf(t) - 1900;
+            case GET_MONTH:
+                return monthOf(t);
+            case GET_DATE:
+                return dateOf(t);
+            case GET_DAY:
+                return weekDay(t);
+            case GET_HOURS:
+                return hoursOf(t);
+            case GET_MINUTES:
+                return minutesOf(t);
+            case GET_SECONDS:
+                return secondsOf(t);
+            case GET_MILLISECONDS:
+                return msOf(t);
+            case SET_FULL_YEAR:
+            case SET_MONTH:
+            case SET_DATE: {
+                let year = arg(SET_FULL_YEAR) ?? yearOf(t);
+                if (setYear && year >= 0 && year <= 99) {
+                    year += 1900;
+                }
+                let month = arg(SET_MONTH) ?? monthOf(t);
+                // setMonth() of nothing is January.
+                if (i === SET_MONTH && Number.isNaN(month)) {
+                    month = 0;
+                }
+                let date = arg(SET_DATE);
+                if (date === undefined) {
+                    date = dateOf(t);
+                    // From SWF 7, setMonth keeps the day within the month it sets (adl).
+                    const m = Math.floor(month);
+                    if (i === SET_MONTH && version > 6 && m >= 0 && m <= 11) {
+                        const length = MONTH_OFFSETS[isLeap(clampInt(year)) ? 1 : 0];
+                        date = Math.min(date, length[m + 1] - length[m]);
+                    }
+                }
+                return store(makeDay(year, month, date), timeWithinDay(t, version));
+            }
+            case SET_HOURS:
+            case SET_MINUTES:
+            case SET_SECONDS:
+            case SET_MILLISECONDS: {
+                const hours = arg(SET_HOURS) ?? hoursOf(t);
+                let minutes = arg(SET_MINUTES) ?? minutesOf(t);
+                let seconds = arg(SET_SECONDS) ?? secondsOf(t);
+                let ms = arg(SET_MILLISECONDS) ?? msOf(t);
+                if (i === SET_MINUTES) {
+                    minutes = clampInt(minutes);
+                    seconds = clampInt(seconds);
+                    ms = clampInt(ms);
+                }
+                return store(day(t), makeTime(hours, minutes, seconds, ms));
+            }
+            case TO_STRING:
+                return dateString(time);
+            default:
+                return undefined;
+        }
+    };
+}
+const PROTO = [
+    ["getFullYear", GET_FULL_YEAR],
+    ["getYear", GET_YEAR],
+    ["getMonth", GET_MONTH],
+    ["getDate", GET_DATE],
+    ["getDay", GET_DAY],
+    ["getHours", GET_HOURS],
+    ["getMinutes", GET_MINUTES],
+    ["getSeconds", GET_SECONDS],
+    ["getMilliseconds", GET_MILLISECONDS],
+    ["setFullYear", SET_FULL_YEAR],
+    ["setMonth", SET_MONTH],
+    ["setDate", SET_DATE],
+    ["setHours", SET_HOURS],
+    ["setMinutes", SET_MINUTES],
+    ["setSeconds", SET_SECONDS],
+    ["setMilliseconds", SET_MILLISECONDS],
+    ["getTime", GET_TIME],
+    ["setTime", SET_TIME],
+    ["getTimezoneOffset", GET_TIMEZONE_OFFSET],
+    ["toString", TO_STRING],
+    ["setYear", SET_YEAR],
+    ["getUTCFullYear", UTC_OFFSET + GET_FULL_YEAR],
+    ["getUTCYear", UTC_OFFSET + GET_YEAR],
+    ["getUTCMonth", UTC_OFFSET + GET_MONTH],
+    ["getUTCDate", UTC_OFFSET + GET_DATE],
+    ["getUTCDay", UTC_OFFSET + GET_DAY],
+    ["getUTCHours", UTC_OFFSET + GET_HOURS],
+    ["getUTCMinutes", UTC_OFFSET + GET_MINUTES],
+    ["getUTCSeconds", UTC_OFFSET + GET_SECONDS],
+    ["getUTCMilliseconds", UTC_OFFSET + GET_MILLISECONDS],
+    ["setUTCFullYear", UTC_OFFSET + SET_FULL_YEAR],
+    ["setUTCMonth", UTC_OFFSET + SET_MONTH],
+    ["setUTCDate", UTC_OFFSET + SET_DATE],
+    ["setUTCHours", UTC_OFFSET + SET_HOURS],
+    ["setUTCMinutes", UTC_OFFSET + SET_MINUTES],
+    ["setUTCSeconds", UTC_OFFSET + SET_SECONDS],
+    ["setUTCMilliseconds", UTC_OFFSET + SET_MILLISECONDS],
+    ["valueOf", GET_TIME],
+];
+export function dateClass(realm) {
+    const proto = new Avm1Object();
+    // Its `prototype` read-only, as Object's and Number's are (adl).
+    const constr = realm.classOf(proto, dateNative(CONSTRUCTOR), (_, __, version) => dateString(now(version)), READ_ONLY);
+    proto.define("__proto__", realm.objectProto, DONT_ENUM | DONT_DELETE);
+    for (const [name, index] of PROTO) {
+        proto.define(name, realm.method(dateNative(index)), DONT_ENUM | DONT_DELETE);
+    }
+    constr.define("UTC", realm.method(dateNative(UTC)), DONT_ENUM | DONT_DELETE | READ_ONLY);
+    realm.natives.set(103, (i) => i <= SET_YEAR ||
+        i === CONSTRUCTOR ||
+        i === UTC ||
+        (i >= UTC_OFFSET && i <= UTC_OFFSET + SET_MILLISECONDS)
+        ? dateNative(i)
+        : null);
+    return { constr, proto };
+}