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; | |