Spaces:
Runtime error
Runtime error
| ; | |
| Object.defineProperty(exports, "__esModule", { value: true }); | |
| exports.msFromTime = exports.OrdinaryHasInstance = exports.SecFromTime = exports.MinFromTime = exports.HourFromTime = exports.DateFromTime = exports.MonthFromTime = exports.InLeapYear = exports.DayWithinYear = exports.DaysInYear = exports.YearFromTime = exports.TimeFromYear = exports.DayFromYear = exports.WeekDay = exports.Day = exports.Type = exports.HasOwnProperty = exports.ArrayCreate = exports.SameValue = exports.ToObject = exports.TimeClip = exports.ToNumber = exports.ToString = void 0; | |
| /** | |
| * https://tc39.es/ecma262/#sec-tostring | |
| */ | |
| function ToString(o) { | |
| // Only symbol is irregular... | |
| if (typeof o === 'symbol') { | |
| throw TypeError('Cannot convert a Symbol value to a string'); | |
| } | |
| return String(o); | |
| } | |
| exports.ToString = ToString; | |
| /** | |
| * https://tc39.es/ecma262/#sec-tonumber | |
| * @param val | |
| */ | |
| function ToNumber(val) { | |
| if (val === undefined) { | |
| return NaN; | |
| } | |
| if (val === null) { | |
| return +0; | |
| } | |
| if (typeof val === 'boolean') { | |
| return val ? 1 : +0; | |
| } | |
| if (typeof val === 'number') { | |
| return val; | |
| } | |
| if (typeof val === 'symbol' || typeof val === 'bigint') { | |
| throw new TypeError('Cannot convert symbol/bigint to number'); | |
| } | |
| return Number(val); | |
| } | |
| exports.ToNumber = ToNumber; | |
| /** | |
| * https://tc39.es/ecma262/#sec-tointeger | |
| * @param n | |
| */ | |
| function ToInteger(n) { | |
| var number = ToNumber(n); | |
| if (isNaN(number) || SameValue(number, -0)) { | |
| return 0; | |
| } | |
| if (isFinite(number)) { | |
| return number; | |
| } | |
| var integer = Math.floor(Math.abs(number)); | |
| if (number < 0) { | |
| integer = -integer; | |
| } | |
| if (SameValue(integer, -0)) { | |
| return 0; | |
| } | |
| return integer; | |
| } | |
| /** | |
| * https://tc39.es/ecma262/#sec-timeclip | |
| * @param time | |
| */ | |
| function TimeClip(time) { | |
| if (!isFinite(time)) { | |
| return NaN; | |
| } | |
| if (Math.abs(time) > 8.64 * 1e15) { | |
| return NaN; | |
| } | |
| return ToInteger(time); | |
| } | |
| exports.TimeClip = TimeClip; | |
| /** | |
| * https://tc39.es/ecma262/#sec-toobject | |
| * @param arg | |
| */ | |
| function ToObject(arg) { | |
| if (arg == null) { | |
| throw new TypeError('undefined/null cannot be converted to object'); | |
| } | |
| return Object(arg); | |
| } | |
| exports.ToObject = ToObject; | |
| /** | |
| * https://www.ecma-international.org/ecma-262/11.0/index.html#sec-samevalue | |
| * @param x | |
| * @param y | |
| */ | |
| function SameValue(x, y) { | |
| if (Object.is) { | |
| return Object.is(x, y); | |
| } | |
| // SameValue algorithm | |
| if (x === y) { | |
| // Steps 1-5, 7-10 | |
| // Steps 6.b-6.e: +0 != -0 | |
| return x !== 0 || 1 / x === 1 / y; | |
| } | |
| // Step 6.a: NaN == NaN | |
| return x !== x && y !== y; | |
| } | |
| exports.SameValue = SameValue; | |
| /** | |
| * https://www.ecma-international.org/ecma-262/11.0/index.html#sec-arraycreate | |
| * @param len | |
| */ | |
| function ArrayCreate(len) { | |
| return new Array(len); | |
| } | |
| exports.ArrayCreate = ArrayCreate; | |
| /** | |
| * https://www.ecma-international.org/ecma-262/11.0/index.html#sec-hasownproperty | |
| * @param o | |
| * @param prop | |
| */ | |
| function HasOwnProperty(o, prop) { | |
| return Object.prototype.hasOwnProperty.call(o, prop); | |
| } | |
| exports.HasOwnProperty = HasOwnProperty; | |
| /** | |
| * https://www.ecma-international.org/ecma-262/11.0/index.html#sec-type | |
| * @param x | |
| */ | |
| function Type(x) { | |
| if (x === null) { | |
| return 'Null'; | |
| } | |
| if (typeof x === 'undefined') { | |
| return 'Undefined'; | |
| } | |
| if (typeof x === 'function' || typeof x === 'object') { | |
| return 'Object'; | |
| } | |
| if (typeof x === 'number') { | |
| return 'Number'; | |
| } | |
| if (typeof x === 'boolean') { | |
| return 'Boolean'; | |
| } | |
| if (typeof x === 'string') { | |
| return 'String'; | |
| } | |
| if (typeof x === 'symbol') { | |
| return 'Symbol'; | |
| } | |
| if (typeof x === 'bigint') { | |
| return 'BigInt'; | |
| } | |
| } | |
| exports.Type = Type; | |
| var MS_PER_DAY = 86400000; | |
| /** | |
| * https://www.ecma-international.org/ecma-262/11.0/index.html#eqn-modulo | |
| * @param x | |
| * @param y | |
| * @return k of the same sign as y | |
| */ | |
| function mod(x, y) { | |
| return x - Math.floor(x / y) * y; | |
| } | |
| /** | |
| * https://tc39.es/ecma262/#eqn-Day | |
| * @param t | |
| */ | |
| function Day(t) { | |
| return Math.floor(t / MS_PER_DAY); | |
| } | |
| exports.Day = Day; | |
| /** | |
| * https://tc39.es/ecma262/#sec-week-day | |
| * @param t | |
| */ | |
| function WeekDay(t) { | |
| return mod(Day(t) + 4, 7); | |
| } | |
| exports.WeekDay = WeekDay; | |
| /** | |
| * https://tc39.es/ecma262/#sec-year-number | |
| * @param y | |
| */ | |
| function DayFromYear(y) { | |
| return Date.UTC(y, 0) / MS_PER_DAY; | |
| } | |
| exports.DayFromYear = DayFromYear; | |
| /** | |
| * https://tc39.es/ecma262/#sec-year-number | |
| * @param y | |
| */ | |
| function TimeFromYear(y) { | |
| return Date.UTC(y, 0); | |
| } | |
| exports.TimeFromYear = TimeFromYear; | |
| /** | |
| * https://tc39.es/ecma262/#sec-year-number | |
| * @param t | |
| */ | |
| function YearFromTime(t) { | |
| return new Date(t).getUTCFullYear(); | |
| } | |
| exports.YearFromTime = YearFromTime; | |
| function DaysInYear(y) { | |
| if (y % 4 !== 0) { | |
| return 365; | |
| } | |
| if (y % 100 !== 0) { | |
| return 366; | |
| } | |
| if (y % 400 !== 0) { | |
| return 365; | |
| } | |
| return 366; | |
| } | |
| exports.DaysInYear = DaysInYear; | |
| function DayWithinYear(t) { | |
| return Day(t) - DayFromYear(YearFromTime(t)); | |
| } | |
| exports.DayWithinYear = DayWithinYear; | |
| function InLeapYear(t) { | |
| return DaysInYear(YearFromTime(t)) === 365 ? 0 : 1; | |
| } | |
| exports.InLeapYear = InLeapYear; | |
| /** | |
| * https://tc39.es/ecma262/#sec-month-number | |
| * @param t | |
| */ | |
| function MonthFromTime(t) { | |
| var dwy = DayWithinYear(t); | |
| var leap = InLeapYear(t); | |
| if (dwy >= 0 && dwy < 31) { | |
| return 0; | |
| } | |
| if (dwy < 59 + leap) { | |
| return 1; | |
| } | |
| if (dwy < 90 + leap) { | |
| return 2; | |
| } | |
| if (dwy < 120 + leap) { | |
| return 3; | |
| } | |
| if (dwy < 151 + leap) { | |
| return 4; | |
| } | |
| if (dwy < 181 + leap) { | |
| return 5; | |
| } | |
| if (dwy < 212 + leap) { | |
| return 6; | |
| } | |
| if (dwy < 243 + leap) { | |
| return 7; | |
| } | |
| if (dwy < 273 + leap) { | |
| return 8; | |
| } | |
| if (dwy < 304 + leap) { | |
| return 9; | |
| } | |
| if (dwy < 334 + leap) { | |
| return 10; | |
| } | |
| if (dwy < 365 + leap) { | |
| return 11; | |
| } | |
| throw new Error('Invalid time'); | |
| } | |
| exports.MonthFromTime = MonthFromTime; | |
| function DateFromTime(t) { | |
| var dwy = DayWithinYear(t); | |
| var mft = MonthFromTime(t); | |
| var leap = InLeapYear(t); | |
| if (mft === 0) { | |
| return dwy + 1; | |
| } | |
| if (mft === 1) { | |
| return dwy - 30; | |
| } | |
| if (mft === 2) { | |
| return dwy - 58 - leap; | |
| } | |
| if (mft === 3) { | |
| return dwy - 89 - leap; | |
| } | |
| if (mft === 4) { | |
| return dwy - 119 - leap; | |
| } | |
| if (mft === 5) { | |
| return dwy - 150 - leap; | |
| } | |
| if (mft === 6) { | |
| return dwy - 180 - leap; | |
| } | |
| if (mft === 7) { | |
| return dwy - 211 - leap; | |
| } | |
| if (mft === 8) { | |
| return dwy - 242 - leap; | |
| } | |
| if (mft === 9) { | |
| return dwy - 272 - leap; | |
| } | |
| if (mft === 10) { | |
| return dwy - 303 - leap; | |
| } | |
| if (mft === 11) { | |
| return dwy - 333 - leap; | |
| } | |
| throw new Error('Invalid time'); | |
| } | |
| exports.DateFromTime = DateFromTime; | |
| var HOURS_PER_DAY = 24; | |
| var MINUTES_PER_HOUR = 60; | |
| var SECONDS_PER_MINUTE = 60; | |
| var MS_PER_SECOND = 1e3; | |
| var MS_PER_MINUTE = MS_PER_SECOND * SECONDS_PER_MINUTE; | |
| var MS_PER_HOUR = MS_PER_MINUTE * MINUTES_PER_HOUR; | |
| function HourFromTime(t) { | |
| return mod(Math.floor(t / MS_PER_HOUR), HOURS_PER_DAY); | |
| } | |
| exports.HourFromTime = HourFromTime; | |
| function MinFromTime(t) { | |
| return mod(Math.floor(t / MS_PER_MINUTE), MINUTES_PER_HOUR); | |
| } | |
| exports.MinFromTime = MinFromTime; | |
| function SecFromTime(t) { | |
| return mod(Math.floor(t / MS_PER_SECOND), SECONDS_PER_MINUTE); | |
| } | |
| exports.SecFromTime = SecFromTime; | |
| function IsCallable(fn) { | |
| return typeof fn === 'function'; | |
| } | |
| /** | |
| * The abstract operation OrdinaryHasInstance implements | |
| * the default algorithm for determining if an object O | |
| * inherits from the instance object inheritance path | |
| * provided by constructor C. | |
| * @param C class | |
| * @param O object | |
| * @param internalSlots internalSlots | |
| */ | |
| function OrdinaryHasInstance(C, O, internalSlots) { | |
| if (!IsCallable(C)) { | |
| return false; | |
| } | |
| if (internalSlots === null || internalSlots === void 0 ? void 0 : internalSlots.boundTargetFunction) { | |
| var BC = internalSlots === null || internalSlots === void 0 ? void 0 : internalSlots.boundTargetFunction; | |
| return O instanceof BC; | |
| } | |
| if (typeof O !== 'object') { | |
| return false; | |
| } | |
| var P = C.prototype; | |
| if (typeof P !== 'object') { | |
| throw new TypeError('OrdinaryHasInstance called on an object with an invalid prototype property.'); | |
| } | |
| return Object.prototype.isPrototypeOf.call(P, O); | |
| } | |
| exports.OrdinaryHasInstance = OrdinaryHasInstance; | |
| function msFromTime(t) { | |
| return mod(t, MS_PER_SECOND); | |
| } | |
| exports.msFromTime = msFromTime; | |