[READ-ONLY] Mirror of https://github.com/CanadaHonk/porffor. An ahead-of-time JavaScript compiler porffor.dev
Something went wrong. Try again.
JavaScript
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095export default `var Temporal = { Duration: class Duration { constructor(years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds) { Object.defineProperty(this, '_temporalBrand', { value: 'Temporal.Duration', writable: false, enumerable: false, configurable: false }); this._years = Duration._toInteger(years === undefined ? 0 : years, 'years'); this._months = Duration._toInteger(months === undefined ? 0 : months, 'months'); this._weeks = Duration._toInteger(weeks === undefined ? 0 : weeks, 'weeks'); this._days = Duration._toInteger(days === undefined ? 0 : days, 'days'); this._hours = Duration._toInteger(hours === undefined ? 0 : hours, 'hours'); this._minutes = Duration._toInteger(minutes === undefined ? 0 : minutes, 'minutes'); this._seconds = Duration._toInteger(seconds === undefined ? 0 : seconds, 'seconds'); this._milliseconds = Duration._toInteger(milliseconds === undefined ? 0 : milliseconds, 'milliseconds'); this._microseconds = Duration._toInteger(microseconds === undefined ? 0 : microseconds, 'microseconds'); this._nanoseconds = Duration._toInteger(nanoseconds === undefined ? 0 : nanoseconds, 'nanoseconds'); }
static _toInteger(value, name) { const out = Number(value); if (!Number.isFinite(out)) throw new RangeError('Invalid ' + name); if (Object.is(out, -0)) return 0; return Math.trunc(out); }
static _digit(str, i) { const x = str.charCodeAt(i) - 48; return x >= 0 && x <= 9 ? x : -1; }
static _parseNDigits(str, start, count) { let out = 0; for (let i = 0; i < count; i++) { const d = Duration._digit(str, start + i); if (d < 0) return -1; out = out * 10 + d; }
return out; }
static _pad(value, size) { let out = String(Math.abs(value)); while (out.length < size) out = '0' + out; return out; }
static _toOptions(options) { if (options === undefined) return {}; if (options === null) throw new TypeError('Options cannot be null'); const t = typeof options; if (t !== 'object' && t !== 'function') throw new TypeError('Options must be an object'); if ( t === 'object' && Object.keys(options).length === 0 && !Object.isExtensible(options) && Number.isFinite(Number(options)) ) { throw new TypeError('Options must be an object'); } return options; }
static _getStringOption(options, name, fallback, allowed) { let value = options[name]; if (value === undefined) return fallback; value = String(value); if (allowed && allowed.indexOf(value) < 0) { throw new RangeError('Invalid ' + name); } return value; }
static _getUnitOption(options, name, fallback, allowed) { const value = options[name]; if (value === undefined) { if (fallback === undefined) return undefined; return Duration._normalizeUnit(fallback, name, allowed); }
return Duration._normalizeUnit(value, name, allowed); }
static _normalizeUnit(unit, name, allowed) { let value = String(unit); if (value.length > 1 && value.charCodeAt(value.length - 1) === 115) { const singular = value.slice(0, -1); if ( singular === 'year' || singular === 'month' || singular === 'week' || singular === 'day' || singular === 'hour' || singular === 'minute' || singular === 'second' || singular === 'millisecond' || singular === 'microsecond' || singular === 'nanosecond' ) { value = singular; } } if (allowed && allowed.indexOf(value) < 0) throw new RangeError('Invalid ' + name); return value; }
static _getNumberOption(options, name, fallback) { const value = options[name]; if (value === undefined) return fallback; return Duration._toInteger(value, name); }
static _getRoundingIncrementOption(options) { const raw = options.roundingIncrement; if (raw === undefined) return 1; const num = Number(raw); if (!Number.isFinite(num)) throw new RangeError('Invalid roundingIncrement'); let out = Math.trunc(num); if (Object.is(out, -0)) out = 0; if (out < 1 || out > 1000000000) throw new RangeError('roundingIncrement out of range'); return out; }
static _normalizeRoundingMode(mode, fallback) { const out = mode === undefined ? (fallback === undefined ? 'halfExpand' : fallback) : String(mode); if (out === 'ceil' || out === 'floor' || out === 'trunc' || out === 'expand' || out === 'halfCeil' || out === 'halfFloor' || out === 'halfExpand' || out === 'halfTrunc' || out === 'halfEven') { return out; } throw new RangeError('Invalid roundingMode'); }
static _unitRank(unit) { if (unit === 'year') return 9; if (unit === 'month') return 8; if (unit === 'week') return 7; if (unit === 'day') return 6; if (unit === 'hour') return 5; if (unit === 'minute') return 4; if (unit === 'second') return 3; if (unit === 'millisecond') return 2; if (unit === 'microsecond') return 1; if (unit === 'nanosecond') return 0; return -1; }
static _resolveAutoLargestUnit(smallestUnit, fallbackLargestUnit) { if (smallestUnit === undefined) return fallbackLargestUnit; return Duration._unitRank(smallestUnit) > Duration._unitRank(fallbackLargestUnit) ? smallestUnit : fallbackLargestUnit; }
static _assertValidUnitRange(largestUnit, smallestUnit) { if (Duration._unitRank(largestUnit) < Duration._unitRank(smallestUnit)) { throw new RangeError('largestUnit cannot be smaller than smallestUnit'); } }
static _differenceSettings(options, smallestUnitFallback, smallestAllowed, largestUnitFallback, largestAllowed, roundingModeFallback) { const largestUnitValue = options.largestUnit; const largestUnitRaw = largestUnitValue === undefined ? 'auto' : Duration._normalizeUnit(largestUnitValue, 'largestUnit'); const roundingIncrement = Duration._getRoundingIncrementOption(options); const roundingMode = Duration._normalizeRoundingMode(options.roundingMode, roundingModeFallback); const smallestUnitValue = options.smallestUnit; const smallestUnit = smallestUnitValue === undefined ? smallestUnitFallback : Duration._normalizeUnit(smallestUnitValue, 'smallestUnit'); if (largestAllowed && largestAllowed.indexOf(largestUnitRaw) < 0) throw new RangeError('Invalid largestUnit'); if (smallestAllowed && smallestAllowed.indexOf(smallestUnit) < 0) throw new RangeError('Invalid smallestUnit'); const largestUnit = largestUnitRaw === 'auto' ? Duration._resolveAutoLargestUnit(smallestUnit, largestUnitFallback) : largestUnitRaw; Duration._assertValidUnitRange(largestUnit, smallestUnit); return { largestUnit, smallestUnit, roundingIncrement, roundingMode }; }
static _validateTimeRoundingIncrement(smallestUnit, roundingIncrement) { let dividend; if (smallestUnit === 'hour') dividend = 24; else if (smallestUnit === 'minute') dividend = 60; else if (smallestUnit === 'second') dividend = 60; else if (smallestUnit === 'millisecond') dividend = 1000; else if (smallestUnit === 'microsecond') dividend = 1000; else if (smallestUnit === 'nanosecond') dividend = 1000; if (dividend !== undefined && (roundingIncrement >= dividend || dividend % roundingIncrement !== 0)) { throw new RangeError('Invalid roundingIncrement'); } }
static _unitNanoseconds(unit) { if (unit === 'nanosecond') return 1; if (unit === 'microsecond') return 1000; if (unit === 'millisecond') return 1000000; if (unit === 'second') return 1000000000; if (unit === 'minute') return 60 * 1000000000; if (unit === 'hour') return 3600 * 1000000000; if (unit === 'day') return 86400 * 1000000000; if (unit === 'week') return 7 * 86400 * 1000000000; if (unit === 'month') return 30 * 86400 * 1000000000; if (unit === 'year') return 365 * 86400 * 1000000000; throw new RangeError('Invalid unit'); }
static _roundToIncrement(value, increment, mode) { if (!Number.isFinite(value)) throw new RangeError('Invalid rounding value'); if (!Number.isFinite(increment) || increment <= 0) throw new RangeError('roundingIncrement must be positive'); if (value === 0) return 0;
const m = Duration._normalizeRoundingMode(mode, 'halfExpand'); const sign = value < 0 ? -1 : 1; const abs = Math.abs(value); const q = abs / increment; const lo = Math.floor(q); const frac = q - lo; const up = frac === 0 ? lo : lo + 1; let steps = lo;
if (m === 'trunc') steps = lo; else if (m === 'expand') steps = up; else if (m === 'ceil') steps = sign < 0 ? lo : up; else if (m === 'floor') steps = sign < 0 ? up : lo; else if (frac > 0.5) steps = up; else if (frac < 0.5) steps = lo; else if (m === 'halfTrunc') steps = lo; else if (m === 'halfCeil') steps = sign > 0 ? up : lo; else if (m === 'halfFloor') steps = sign < 0 ? up : lo; else if (m === 'halfEven') steps = lo % 2 === 0 ? lo : up; else steps = up;
return sign * steps * increment; }
static _roundNanoseconds(totalNanoseconds, smallestUnit, roundingIncrement, roundingMode) { const step = Duration._unitNanoseconds(smallestUnit) * roundingIncrement; return Duration._roundToIncrement(totalNanoseconds, step, roundingMode); }
static _formatIsoYear(year) { const y = Duration._toInteger(year, 'year'); if (y >= 0 && y <= 9999) return Duration._pad(y, 4); const sign = y < 0 ? '-' : '+'; return sign + Duration._pad(Math.abs(y), 6); }
static _offsetNanoseconds(text, label) { if (typeof text !== 'string') throw new TypeError((label || 'offset') + ' must be a string'); if (text === 'Z' || text === 'z') return 0; if (text.length < 2) throw new RangeError('Invalid offset'); const signChar = text.charCodeAt(0); if (signChar !== 43 && signChar !== 45) throw new RangeError('Invalid offset'); const sign = signChar === 45 ? -1 : 1;
let i = 1; if (i + 1 >= text.length) throw new RangeError('Invalid offset'); const hh = Duration._parseNDigits(text, i, 2); if (hh < 0 || hh > 23) throw new RangeError('Invalid offset'); i += 2;
let mm = 0; let ss = 0; let frac = 0; let fracDigits = 0;
if (i < text.length) { const sep = text.charCodeAt(i); if (sep === 58) { i++; if (i + 1 >= text.length) throw new RangeError('Invalid offset'); mm = Duration._parseNDigits(text, i, 2); if (mm < 0 || mm > 59) throw new RangeError('Invalid offset'); i += 2; if (i < text.length) { if (text.charCodeAt(i) !== 58) throw new RangeError('Invalid offset'); i++; if (i + 1 >= text.length) throw new RangeError('Invalid offset'); ss = Duration._parseNDigits(text, i, 2); if (ss < 0 || ss > 59) throw new RangeError('Invalid offset'); i += 2; } } else { const remaining = text.length - i; if (remaining !== 2 && remaining !== 4) throw new RangeError('Invalid offset'); mm = Duration._parseNDigits(text, i, 2); if (mm < 0 || mm > 59) throw new RangeError('Invalid offset'); i += 2; if (remaining === 4) { ss = Duration._parseNDigits(text, i, 2); if (ss < 0 || ss > 59) throw new RangeError('Invalid offset'); i += 2; } } }
if (i < text.length) { if (text.charCodeAt(i) !== 46) throw new RangeError('Invalid offset'); i++; while (i < text.length) { const d = Duration._digit(text, i); if (d < 0) throw new RangeError('Invalid offset'); if (fracDigits < 9) frac = frac * 10 + d; fracDigits++; i++; } }
if (i !== text.length) throw new RangeError('Invalid offset'); while (fracDigits < 9) { frac *= 10; fracDigits++; }
const totalNs = ((((hh * 60) + mm) * 60) + ss) * 1000000000 + frac; return sign * totalNs; }
static _formatOffsetNanoseconds(nanoseconds) { if (!Number.isFinite(nanoseconds)) throw new RangeError('Invalid offset'); const sign = nanoseconds < 0 ? '-' : '+'; let abs = Math.abs(Math.trunc(nanoseconds)); const hh = Math.trunc(abs / (3600 * 1000000000)); abs -= hh * 3600 * 1000000000; const mm = Math.trunc(abs / (60 * 1000000000)); abs -= mm * 60 * 1000000000; const ss = Math.trunc(abs / 1000000000); abs -= ss * 1000000000; let out = sign + Duration._pad(hh, 2) + ':' + Duration._pad(mm, 2); if (ss !== 0 || abs !== 0) { out += ':' + Duration._pad(ss, 2); if (abs !== 0) { let frac = Duration._pad(abs, 9); while (frac.length > 0 && frac.charCodeAt(frac.length - 1) === 48) frac = frac.slice(0, -1); out += '.' + frac; } } return out; }
static _normalizeTimeZoneId(value, label) { let v = value; if (v === undefined) return 'UTC'; if (v === null) throw new TypeError((label || 'timeZone') + ' cannot be null'); const t = typeof v; if (t !== 'string' && t !== 'object') throw new TypeError((label || 'timeZone') + ' must be a string or object'); if (typeof v === 'object') { if (v._temporalBrand === 'Temporal.ZonedDateTime') return v._timeZone; if (v.timeZoneId !== undefined) v = v.timeZoneId; else if (v.id !== undefined) v = v.id; }
v = String(v); if (v.length === 0) throw new RangeError('Invalid timeZone'); if (v.indexOf('[') >= 0 && v.indexOf(']') > v.indexOf('[')) { const ann = Temporal.PlainDate._extractAnnotations(v); if (ann.timeZone !== undefined) v = ann.timeZone; }
if (v.indexOf('T') >= 0 || v.indexOf('t') >= 0 || v.indexOf(' ') >= 0) { const last = v.charCodeAt(v.length - 1); if (last === 90 || last === 122) return 'UTC'; for (let i = v.length - 1; i > 0; i--) { const ch = v.charCodeAt(i); if (ch === 43 || ch === 45) { const maybeOffset = v.slice(i); try { return Duration._formatOffsetNanoseconds(Duration._offsetNanoseconds(maybeOffset, 'timeZone')); } catch (e) {} } } }
const lower = v.toLowerCase(); if (lower === 'utc' || lower === 'gmt' || lower === 'z') return 'UTC'; if (v.charCodeAt(0) === 43 || v.charCodeAt(0) === 45) { return Duration._formatOffsetNanoseconds(Duration._offsetNanoseconds(v, 'timeZone')); } const first = v.charCodeAt(0); if (!((first >= 65 && first <= 90) || (first >= 97 && first <= 122))) { throw new RangeError('Invalid timeZone'); }
for (let i = 0; i < v.length; i++) { const c = v.charCodeAt(i); const ok = (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || (c >= 48 && c <= 57) || c === 47 || c === 95 || c === 45 || c === 43; if (!ok) throw new RangeError('Invalid timeZone'); }
return v; }
static _timeZoneOffsetNanoseconds(timeZone) { const tz = Duration._normalizeTimeZoneId(timeZone, 'timeZone'); if (tz === 'UTC') return 0; if (tz.charCodeAt(0) === 43 || tz.charCodeAt(0) === 45) { return Duration._offsetNanoseconds(tz, 'timeZone'); } return 0; }
static _normalizeCalendarId(value, label) { let v = value; if (v === undefined) return 'iso8601'; if (v === null) throw new TypeError((label || 'calendar') + ' cannot be null'); const t = typeof v; if (t !== 'string' && t !== 'object') throw new TypeError((label || 'calendar') + ' must be a string or object'); if (typeof v === 'object') { if (v.calendarId !== undefined) v = v.calendarId; else if (v.id !== undefined) v = v.id; else if (v.calendar !== undefined) v = v.calendar; else throw new TypeError((label || 'calendar') + ' must be a string'); }
v = String(v); if (v.indexOf('[') >= 0 && v.indexOf('u-ca=') >= 0) { const ann = Temporal.PlainDate._extractAnnotations(v); v = ann.calendar; }
v = v.toLowerCase(); if (v === 'iso') v = 'iso8601'; if (v.length === 0) throw new RangeError('Invalid calendar'); if (v !== 'iso8601') throw new RangeError('Invalid calendar'); const first = v.charCodeAt(0); if (first < 97 || first > 122) throw new RangeError('Invalid calendar');
for (let i = 0; i < v.length; i++) { const c = v.charCodeAt(i); const ok = (c >= 97 && c <= 122) || (c >= 48 && c <= 57) || c === 45; if (!ok) throw new RangeError('Invalid calendar'); }
return v; }
static _checkIsoDateRange(year, month, day) { if (year < -271821 || year > 275760) throw new RangeError('Date outside valid ISO range'); if (year === -271821) { if (month < 4 || (month === 4 && day < 20)) throw new RangeError('Date outside valid ISO range'); } if (year === 275760) { if (month > 9 || (month === 9 && day > 13)) throw new RangeError('Date outside valid ISO range'); } }
static _checkEpochNanosecondsRange(epochNanoseconds) { const max = 8640000000000000000000; if (!Number.isFinite(epochNanoseconds)) throw new RangeError('Invalid epochNanoseconds'); if (epochNanoseconds < -max || epochNanoseconds > max) throw new RangeError('epochNanoseconds out of range'); }
static _requireThis(value, label) { if (!value || typeof value !== 'object' || value._temporalBrand !== 'Temporal.Duration') { throw new TypeError('Temporal.Duration.prototype.' + label + ' called on incompatible receiver'); }
return value; }
static _coerce(value, label) { if (typeof value === 'string') { const parsed = Duration._parseISO(value); return new Duration( parsed.years, parsed.months, parsed.weeks, parsed.days, parsed.hours, parsed.minutes, parsed.seconds, parsed.milliseconds, parsed.microseconds, parsed.nanoseconds ); }
if (value && typeof value === 'object') { if (value._temporalBrand === 'Temporal.Duration') return value;
return new Duration( value.years, value.months, value.weeks, value.days, value.hours, value.minutes, value.seconds, value.milliseconds, value.microseconds, value.nanoseconds ); }
throw new TypeError('Temporal.Duration.' + label + ' requires a duration-like value'); }
static _parseISO(value) { if (typeof value !== 'string') throw new TypeError('Temporal.Duration string expected'); if (value.length < 2) throw new RangeError('Invalid duration string');
let i = 0; let sign = 1; if (value.charCodeAt(i) === 43) i++; else if (value.charCodeAt(i) === 45) { sign = -1; i++; }
if (value.charCodeAt(i) !== 80) throw new RangeError('Invalid duration string'); i++;
let inTime = false; let hadAny = false; let years = 0; let months = 0; let weeks = 0; let days = 0; let hours = 0; let minutes = 0; let seconds = 0; let milliseconds = 0; let microseconds = 0; let nanoseconds = 0;
while (i < value.length) { if (value.charCodeAt(i) === 84) { inTime = true; i++; continue; }
if (i >= value.length) break;
let intPart = 0; let intDigits = 0; while (i < value.length) { const d = Duration._digit(value, i); if (d < 0) break; intPart = intPart * 10 + d; intDigits++; i++; }
if (intDigits === 0) throw new RangeError('Invalid duration string');
let fracPart = 0; let fracDigits = 0; if (i < value.length && value.charCodeAt(i) === 46) { i++; while (i < value.length) { const d = Duration._digit(value, i); if (d < 0) break; if (fracDigits < 9) fracPart = fracPart * 10 + d; fracDigits++; i++; } }
if (i >= value.length) throw new RangeError('Invalid duration string'); const unit = value.charCodeAt(i); i++;
hadAny = true; if (!inTime && unit === 89) { years = intPart; continue; }
if (!inTime && unit === 77) { months = intPart; continue; }
if (!inTime && unit === 87) { weeks = intPart; continue; }
if (!inTime && unit === 68) { days = intPart; continue; }
if (inTime && unit === 72) { hours = intPart; continue; }
if (inTime && unit === 77) { minutes = intPart; continue; }
if (inTime && unit === 83) { seconds = intPart; if (fracDigits > 0) { let nanos = fracPart; let p = fracDigits; while (p < 9) { nanos *= 10; p++; } milliseconds = Math.trunc(nanos / 1000000); nanos -= milliseconds * 1000000; microseconds = Math.trunc(nanos / 1000); nanos -= microseconds * 1000; nanoseconds = nanos; } continue; }
throw new RangeError('Invalid duration string'); }
if (!hadAny) throw new RangeError('Invalid duration string');
return { years: years * sign, months: months * sign, weeks: weeks * sign, days: days * sign, hours: hours * sign, minutes: minutes * sign, seconds: seconds * sign, milliseconds: milliseconds * sign, microseconds: microseconds * sign, nanoseconds: nanoseconds * sign }; }
static _hasCalendarUnits(duration) { return duration.years !== 0 || duration.months !== 0 || duration.weeks !== 0; }
static _toRelativeToDate(relativeTo) { if (relativeTo == null) return null; if (typeof relativeTo === 'string') { const parts = Temporal.PlainDateTime._parseISODateTimeString(relativeTo); if (parts.timeZone !== undefined && parts.offsetNanoseconds != null) { const tz = Temporal.Duration._normalizeTimeZoneId(parts.timeZone, 'timeZone'); if (tz.charCodeAt(0) === 43 || tz.charCodeAt(0) === 45) { if (Temporal.Duration._offsetNanoseconds(tz, 'timeZone') !== parts.offsetNanoseconds) { throw new RangeError('Offset does not match time zone'); } } } return new Temporal.PlainDate(parts.date.year, parts.date.month, parts.date.day, parts.calendar); }
if (typeof relativeTo !== 'object') throw new TypeError('relativeTo must be an object or string'); if (relativeTo._temporalBrand === 'Temporal.PlainDate') return Temporal.PlainDate.from(relativeTo); if (relativeTo._temporalBrand === 'Temporal.PlainDateTime') return relativeTo.toPlainDate(); if (relativeTo._temporalBrand === 'Temporal.ZonedDateTime') return relativeTo.toPlainDate(); if (relativeTo.year !== undefined && relativeTo.month !== undefined && relativeTo.day !== undefined) { return Temporal.PlainDate.from(relativeTo); } throw new TypeError('Invalid relativeTo'); }
static _calendarDaySeconds(duration, relativeTo) { const base = Duration._toRelativeToDate(relativeTo); if (!base) { return (duration.years * 365 + duration.months * 30 + duration.weeks * 7 + duration.days) * 86400; }
const startMs = Date.UTC(base.year, base.month - 1, base.day);
let year = base.year + duration.years; let month = base.month + duration.months; while (month > 12) { month -= 12; year++; } while (month < 1) { month += 12; year--; }
let day = base.day; const dim = Temporal.PlainDate._daysInMonth(year, month); if (day > dim) day = dim;
const shifted = new Date(Date.UTC(year, month - 1, day)); shifted.setUTCDate(shifted.getUTCDate() + duration.weeks * 7 + duration.days); const endMs = Date.UTC(shifted.getUTCFullYear(), shifted.getUTCMonth(), shifted.getUTCDate()); return (endMs - startMs) / 1000; }
static _totalNanoseconds(duration, relativeTo) { const daySeconds = Duration._calendarDaySeconds(duration, relativeTo); const h = duration.hours * 3600; const m = duration.minutes * 60; const s = duration.seconds; const ms = duration.milliseconds / 1000; const us = duration.microseconds / 1000000; const ns = duration.nanoseconds / 1000000000; return (daySeconds + h + m + s + ms + us + ns) * 1000000000; }
static from(value) { return Duration._coerce(value, 'from'); }
static compare(one, two, options) { const opts = Duration._toOptions(options); const a = Duration._coerce(one, 'compare'); const b = Duration._coerce(two, 'compare'); const relativeTo = opts.relativeTo; if ((Duration._hasCalendarUnits(a) || Duration._hasCalendarUnits(b)) && relativeTo === undefined) { throw new RangeError('relativeTo is required for years/months/weeks'); } const aa = Duration._totalNanoseconds(a, relativeTo); const bb = Duration._totalNanoseconds(b, relativeTo); if (aa < bb) return -1; if (aa > bb) return 1; return 0; }
static _fromTotalNanoseconds(total) { return Duration._balanceNanoseconds(total, 'day'); }
static _balanceNanoseconds(total, largestUnit) { const unit = largestUnit === undefined ? 'day' : largestUnit; let sign = 1; let rest = Math.trunc(total); if (rest < 0) { sign = -1; rest = -rest; }
let years = 0; let months = 0; let weeks = 0; let days = 0; let hours = 0; let minutes = 0; let seconds = 0; let milliseconds = 0; let microseconds = 0; let nanoseconds = 0;
if (unit === 'year') { years = Math.trunc(rest / Duration._unitNanoseconds('year')); rest -= years * Duration._unitNanoseconds('year'); } else if (unit === 'month') { months = Math.trunc(rest / Duration._unitNanoseconds('month')); rest -= months * Duration._unitNanoseconds('month'); } else if (unit === 'week') { weeks = Math.trunc(rest / Duration._unitNanoseconds('week')); rest -= weeks * Duration._unitNanoseconds('week'); } else if (unit === 'day') { days = Math.trunc(rest / Duration._unitNanoseconds('day')); rest -= days * Duration._unitNanoseconds('day'); } else if (unit === 'hour') { hours = Math.trunc(rest / Duration._unitNanoseconds('hour')); rest -= hours * Duration._unitNanoseconds('hour'); } else if (unit === 'minute') { minutes = Math.trunc(rest / Duration._unitNanoseconds('minute')); rest -= minutes * Duration._unitNanoseconds('minute'); } else if (unit === 'second') { seconds = Math.trunc(rest / Duration._unitNanoseconds('second')); rest -= seconds * Duration._unitNanoseconds('second'); } else if (unit === 'millisecond') { milliseconds = Math.trunc(rest / Duration._unitNanoseconds('millisecond')); rest -= milliseconds * Duration._unitNanoseconds('millisecond'); } else if (unit === 'microsecond') { microseconds = Math.trunc(rest / Duration._unitNanoseconds('microsecond')); rest -= microseconds * Duration._unitNanoseconds('microsecond'); }
if (unit === 'year' || unit === 'month' || unit === 'week' || unit === 'day') { hours += Math.trunc(rest / Duration._unitNanoseconds('hour')); rest -= hours * Duration._unitNanoseconds('hour'); minutes = Math.trunc(rest / Duration._unitNanoseconds('minute')); rest -= minutes * Duration._unitNanoseconds('minute'); seconds = Math.trunc(rest / Duration._unitNanoseconds('second')); rest -= seconds * Duration._unitNanoseconds('second'); milliseconds = Math.trunc(rest / Duration._unitNanoseconds('millisecond')); rest -= milliseconds * Duration._unitNanoseconds('millisecond'); microseconds = Math.trunc(rest / Duration._unitNanoseconds('microsecond')); rest -= microseconds * Duration._unitNanoseconds('microsecond'); nanoseconds = rest; } else if (unit === 'hour') { minutes = Math.trunc(rest / Duration._unitNanoseconds('minute')); rest -= minutes * Duration._unitNanoseconds('minute'); seconds = Math.trunc(rest / Duration._unitNanoseconds('second')); rest -= seconds * Duration._unitNanoseconds('second'); milliseconds = Math.trunc(rest / Duration._unitNanoseconds('millisecond')); rest -= milliseconds * Duration._unitNanoseconds('millisecond'); microseconds = Math.trunc(rest / Duration._unitNanoseconds('microsecond')); rest -= microseconds * Duration._unitNanoseconds('microsecond'); nanoseconds = rest; } else if (unit === 'minute') { seconds = Math.trunc(rest / Duration._unitNanoseconds('second')); rest -= seconds * Duration._unitNanoseconds('second'); milliseconds = Math.trunc(rest / Duration._unitNanoseconds('millisecond')); rest -= milliseconds * Duration._unitNanoseconds('millisecond'); microseconds = Math.trunc(rest / Duration._unitNanoseconds('microsecond')); rest -= microseconds * Duration._unitNanoseconds('microsecond'); nanoseconds = rest; } else if (unit === 'second') { milliseconds = Math.trunc(rest / Duration._unitNanoseconds('millisecond')); rest -= milliseconds * Duration._unitNanoseconds('millisecond'); microseconds = Math.trunc(rest / Duration._unitNanoseconds('microsecond')); rest -= microseconds * Duration._unitNanoseconds('microsecond'); nanoseconds = rest; } else if (unit === 'millisecond') { microseconds = Math.trunc(rest / Duration._unitNanoseconds('microsecond')); rest -= microseconds * Duration._unitNanoseconds('microsecond'); nanoseconds = rest; } else if (unit === 'microsecond') { nanoseconds = rest; } else if (unit === 'nanosecond') { nanoseconds = rest; }
return new Duration( years * sign, months * sign, weeks * sign, days * sign, hours * sign, minutes * sign, seconds * sign, milliseconds * sign, microseconds * sign, nanoseconds * sign ); }
get years() { return Duration._requireThis(this, 'years')._years; } get months() { return Duration._requireThis(this, 'months')._months; } get weeks() { return Duration._requireThis(this, 'weeks')._weeks; } get days() { return Duration._requireThis(this, 'days')._days; } get hours() { return Duration._requireThis(this, 'hours')._hours; } get minutes() { return Duration._requireThis(this, 'minutes')._minutes; } get seconds() { return Duration._requireThis(this, 'seconds')._seconds; } get milliseconds() { return Duration._requireThis(this, 'milliseconds')._milliseconds; } get microseconds() { return Duration._requireThis(this, 'microseconds')._microseconds; } get nanoseconds() { return Duration._requireThis(this, 'nanoseconds')._nanoseconds; }
get sign() { const d = Duration._requireThis(this, 'sign'); const arr = [d._years, d._months, d._weeks, d._days, d._hours, d._minutes, d._seconds, d._milliseconds, d._microseconds, d._nanoseconds]; for (let i = 0; i < arr.length; i++) { if (arr[i] < 0) return -1; if (arr[i] > 0) return 1; } return 0; }
get blank() { return Duration._requireThis(this, 'blank').sign === 0; }
with(item) { const d = Duration._requireThis(this, 'with'); if (!item || typeof item !== 'object') throw new TypeError('Temporal.Duration.with requires an object'); return new Temporal.Duration( item.years === undefined ? d._years : item.years, item.months === undefined ? d._months : item.months, item.weeks === undefined ? d._weeks : item.weeks, item.days === undefined ? d._days : item.days, item.hours === undefined ? d._hours : item.hours, item.minutes === undefined ? d._minutes : item.minutes, item.seconds === undefined ? d._seconds : item.seconds, item.milliseconds === undefined ? d._milliseconds : item.milliseconds, item.microseconds === undefined ? d._microseconds : item.microseconds, item.nanoseconds === undefined ? d._nanoseconds : item.nanoseconds ); }
negated() { const d = Duration._requireThis(this, 'negated'); return new Temporal.Duration(-d._years, -d._months, -d._weeks, -d._days, -d._hours, -d._minutes, -d._seconds, -d._milliseconds, -d._microseconds, -d._nanoseconds); }
abs() { const d = Duration._requireThis(this, 'abs'); return new Temporal.Duration( Math.abs(d._years), Math.abs(d._months), Math.abs(d._weeks), Math.abs(d._days), Math.abs(d._hours), Math.abs(d._minutes), Math.abs(d._seconds), Math.abs(d._milliseconds), Math.abs(d._microseconds), Math.abs(d._nanoseconds) ); }
add(other) { const d = Duration._requireThis(this, 'add'); const rhs = Duration._coerce(other, 'add'); return new Temporal.Duration( d._years + rhs._years, d._months + rhs._months, d._weeks + rhs._weeks, d._days + rhs._days, d._hours + rhs._hours, d._minutes + rhs._minutes, d._seconds + rhs._seconds, d._milliseconds + rhs._milliseconds, d._microseconds + rhs._microseconds, d._nanoseconds + rhs._nanoseconds ); }
subtract(other) { Duration._requireThis(this, 'subtract'); const rhs = Duration._coerce(other, 'subtract'); return this.add(rhs.negated()); }
round(options) { const d = Duration._requireThis(this, 'round'); if (options === undefined) throw new TypeError('options is required'); const opts = typeof options === 'string' ? { smallestUnit: options } : Duration._toOptions(options); if (opts.smallestUnit === undefined && opts.largestUnit === undefined) { throw new RangeError('smallestUnit or largestUnit is required'); } const smallestUnit = Duration._getUnitOption(opts, 'smallestUnit', 'nanosecond', [ 'year', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond', 'microsecond', 'nanosecond' ]); const largestUnit = Duration._getUnitOption(opts, 'largestUnit', 'auto', [ 'auto', 'year', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond', 'microsecond', 'nanosecond' ]); const increment = Duration._getNumberOption(opts, 'roundingIncrement', 1); const mode = Duration._normalizeRoundingMode(opts.roundingMode, 'halfExpand'); const relativeTo = opts.relativeTo; if (increment <= 0) throw new RangeError('roundingIncrement must be positive'); if (Duration._hasCalendarUnits(d) && relativeTo === undefined) throw new RangeError('relativeTo is required for calendar units');
const total = Duration._totalNanoseconds(d, relativeTo); const rounded = Duration._roundNanoseconds(total, smallestUnit, increment, mode); return largestUnit === 'auto' ? Duration._fromTotalNanoseconds(rounded) : Duration._balanceNanoseconds(rounded, largestUnit); }
total(options) { const d = Duration._requireThis(this, 'total'); if (options === undefined) throw new TypeError('options is required'); const opts = typeof options === 'string' ? { unit: options } : Duration._toOptions(options); const unit = Duration._getUnitOption(opts, 'unit', opts.smallestUnit, [ 'year', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond', 'microsecond', 'nanosecond' ]); if (unit === undefined) throw new RangeError('unit is required'); if (Duration._hasCalendarUnits(d) && opts.relativeTo === undefined) throw new RangeError('relativeTo is required for calendar units'); const totalNs = Duration._totalNanoseconds(d, opts.relativeTo); return totalNs / Duration._unitNanoseconds(unit); }
toString(options) { const d = Duration._requireThis(this, 'toString'); const opts = Duration._toOptions(options); const smallestUnit = Duration._getUnitOption(opts, 'smallestUnit', 'nanosecond', [ 'day', 'hour', 'minute', 'second', 'millisecond', 'microsecond', 'nanosecond' ]); const roundingIncrement = Duration._getNumberOption(opts, 'roundingIncrement', 1); const roundingMode = Duration._normalizeRoundingMode(opts.roundingMode, 'trunc'); const fractionalSecondDigits = opts.fractionalSecondDigits; const needsRounding = opts.smallestUnit !== undefined || opts.roundingIncrement !== undefined || opts.roundingMode !== undefined; const rounded = needsRounding ? d.round({ smallestUnit, roundingIncrement, roundingMode, relativeTo: opts.relativeTo }) : d;
let sign = ''; if (rounded.sign < 0) sign = '-';
const y = Math.abs(rounded._years); const mo = Math.abs(rounded._months); const w = Math.abs(rounded._weeks); const da = Math.abs(rounded._days); const h = Math.abs(rounded._hours); const mi = Math.abs(rounded._minutes); const s = Math.abs(rounded._seconds); const ms = Math.abs(rounded._milliseconds); const us = Math.abs(rounded._microseconds); const ns = Math.abs(rounded._nanoseconds);
let out = sign + 'P'; if (y) out += y + 'Y'; if (mo) out += mo + 'M'; if (w) out += w + 'W'; if (da) out += da + 'D';
if (h || mi || s || ms || us || ns) { out += 'T'; if (h) out += h + 'H'; if (mi) out += mi + 'M';
if (s || ms || us || ns) { let secondsPart = s; let msPart = ms; let usPart = us; let nsPart = ns; if (nsPart >= 1000) { const carry = Math.trunc(nsPart / 1000); usPart += carry; nsPart -= carry * 1000; } if (usPart >= 1000) { const carry = Math.trunc(usPart / 1000); msPart += carry; usPart -= carry * 1000; } if (msPart >= 1000) { const carry = Math.trunc(msPart / 1000); secondsPart += carry; msPart -= carry * 1000; } const frac = msPart * 1000000 + usPart * 1000 + nsPart; if (frac === 0) { out += secondsPart + 'S'; } else { let fracText = Duration._pad(frac, 9); if (fractionalSecondDigits !== undefined && fractionalSecondDigits !== 'auto') { const fd = Duration._toInteger(fractionalSecondDigits, 'fractionalSecondDigits'); if (fd < 0 || fd > 9) throw new RangeError('fractionalSecondDigits out of range'); fracText = fracText.slice(0, fd); while (fracText.length < fd) fracText += '0'; } while (fracText.length > 0 && fracText.charCodeAt(fracText.length - 1) === 48) { fracText = fracText.slice(0, -1); } if (fracText.length === 0) out += secondsPart + 'S'; else out += secondsPart + '.' + fracText + 'S'; } } }
if (out === sign + 'P') out += 'T0S'; return out; }
toJSON() { Duration._requireThis(this, 'toJSON'); return this.toString(); }
toLocaleString() { Duration._requireThis(this, 'toLocaleString'); return this.toString(); }
valueOf() { Duration._requireThis(this, 'valueOf'); throw new TypeError('Do not use valueOf on Temporal.Duration'); } },
Instant: class Instant { constructor(epochNanoseconds) { Object.defineProperty(this, '_temporalBrand', { value: 'Temporal.Instant', writable: false, enumerable: false, configurable: false }); this._epochNanoseconds = Temporal.Duration._toInteger(epochNanoseconds, 'epochNanoseconds'); Temporal.Duration._checkEpochNanosecondsRange(this._epochNanoseconds); }
static _requireThis(value, label) { if (!value || typeof value !== 'object' || value._temporalBrand !== 'Temporal.Instant') { throw new TypeError('Temporal.Instant.prototype.' + label + ' called on incompatible receiver'); }
return value; }
static fromEpochMilliseconds(epochMilliseconds) { const ms = Temporal.Duration._toInteger(epochMilliseconds, 'epochMilliseconds'); return new Temporal.Instant(ms * 1000000); }
static fromEpochNanoseconds(epochNanoseconds) { return new Temporal.Instant(epochNanoseconds); }
static from(value) { if (typeof value === 'string') { const parts = Temporal.PlainDateTime._parseISODateTimeString(value); if (parts.time == null) throw new RangeError('Temporal.Instant requires a date-time string'); return new Temporal.Instant(Temporal.PlainDateTime._partsToEpochNanoseconds(parts, true)); }
if (value && typeof value === 'object') { if (value._temporalBrand === 'Temporal.Instant') return new Temporal.Instant(value._epochNanoseconds); if (value.epochNanoseconds !== undefined) return new Temporal.Instant(value.epochNanoseconds); if (value.epochMilliseconds !== undefined) return Temporal.Instant.fromEpochMilliseconds(value.epochMilliseconds); if (typeof value.toString === 'function') return Temporal.Instant.from(value.toString()); }
throw new TypeError('Cannot convert value to Temporal.Instant'); }
static compare(a, b) { const aa = Temporal.Instant.from(a); const bb = Temporal.Instant.from(b); if (aa._epochNanoseconds < bb._epochNanoseconds) return -1; if (aa._epochNanoseconds > bb._epochNanoseconds) return 1; return 0; }
get epochNanoseconds() { return Temporal.Instant._requireThis(this, 'epochNanoseconds')._epochNanoseconds; } get epochMilliseconds() { return Math.trunc(Temporal.Instant._requireThis(this, 'epochMilliseconds')._epochNanoseconds / 1000000); }
equals(other) { Temporal.Instant._requireThis(this, 'equals'); return Temporal.Instant.compare(this, other) === 0; }
add(durationLike) { Temporal.Instant._requireThis(this, 'add'); const d = Temporal.Duration.from(durationLike); if (d.years !== 0 || d.months !== 0 || d.weeks !== 0 || d.days !== 0) { throw new RangeError('Temporal.Instant.add does not support calendar units'); }
return new Temporal.Instant(this._epochNanoseconds + Temporal.Duration._totalNanoseconds(d)); }
subtract(durationLike) { Temporal.Instant._requireThis(this, 'subtract'); return this.add(Temporal.Duration.from(durationLike).negated()); }
since(other, options = undefined) { Temporal.Instant._requireThis(this, 'since'); const rhs = Temporal.Instant.from(other); const opts = Temporal.Duration._toOptions(options); const settings = Temporal.Duration._differenceSettings( opts, 'nanosecond', [ 'hour', 'minute', 'second', 'millisecond', 'microsecond', 'nanosecond' ], 'second', [ 'auto', 'hour', 'minute', 'second', 'millisecond', 'microsecond', 'nanosecond' ], 'trunc' ); Temporal.Duration._validateTimeRoundingIncrement(settings.smallestUnit, settings.roundingIncrement); const total = this._epochNanoseconds - rhs._epochNanoseconds; const rounded = Temporal.Duration._roundNanoseconds(total, settings.smallestUnit, settings.roundingIncrement, settings.roundingMode); return Temporal.Duration._balanceNanoseconds(rounded, settings.largestUnit); }
until(other, options) { Temporal.Instant._requireThis(this, 'until'); return Temporal.Instant.from(other).since(this, options); }
round(options) { Temporal.Instant._requireThis(this, 'round'); if (options === undefined) throw new TypeError('options is required'); const opts = typeof options === 'string' ? { smallestUnit: options } : Temporal.Duration._toOptions(options); if (opts.smallestUnit === undefined) throw new RangeError('smallestUnit is required'); const smallestUnit = Temporal.Duration._getUnitOption(opts, 'smallestUnit', undefined, [ 'hour', 'minute', 'second', 'millisecond', 'microsecond', 'nanosecond' ]); const increment = Temporal.Duration._getNumberOption(opts, 'roundingIncrement', 1); const mode = Temporal.Duration._normalizeRoundingMode(opts.roundingMode, 'halfExpand'); if (increment <= 0) throw new RangeError('roundingIncrement must be positive'); return new Temporal.Instant(Temporal.Duration._roundNanoseconds(this._epochNanoseconds, smallestUnit, increment, mode)); }
toZonedDateTimeISO(timeZone) { Temporal.Instant._requireThis(this, 'toZonedDateTimeISO'); return new Temporal.ZonedDateTime(this._epochNanoseconds, timeZone === undefined ? 'UTC' : timeZone, 'iso8601'); }
toZonedDateTime(item) { Temporal.Instant._requireThis(this, 'toZonedDateTime'); if (!item || typeof item !== 'object') throw new TypeError('Temporal.Instant.toZonedDateTime requires an object'); return new Temporal.ZonedDateTime(this._epochNanoseconds, item.timeZone, item.calendar === undefined ? 'iso8601' : item.calendar); }
toString(options) { Temporal.Instant._requireThis(this, 'toString'); const opts = Temporal.Duration._toOptions(options); const smallestUnit = Temporal.Duration._getUnitOption(opts, 'smallestUnit', 'nanosecond', [ 'hour', 'minute', 'second', 'millisecond', 'microsecond', 'nanosecond' ]); const roundingMode = Temporal.Duration._normalizeRoundingMode(opts.roundingMode, 'trunc'); const roundingIncrement = Temporal.Duration._getNumberOption(opts, 'roundingIncrement', 1); const fractionalSecondDigits = opts.fractionalSecondDigits; const rounded = this.round({ smallestUnit, roundingMode, roundingIncrement }); let ns = rounded._epochNanoseconds; let ms = ns >= 0 ? Math.trunc(ns / 1000000) : Math.floor(ns / 1000000); let remNs = ns - ms * 1000000; if (remNs < 0) remNs += 1000000;
const d = new Date(ms); const year = Temporal.Duration._formatIsoYear(d.getUTCFullYear()); const month = Temporal.Duration._pad(d.getUTCMonth() + 1, 2); const day = Temporal.Duration._pad(d.getUTCDate(), 2); const hour = Temporal.Duration._pad(d.getUTCHours(), 2); const minute = Temporal.Duration._pad(d.getUTCMinutes(), 2); const second = Temporal.Duration._pad(d.getUTCSeconds(), 2);
let out = year + '-' + month + '-' + day + 'T' + hour; if (smallestUnit !== 'hour') out += ':' + minute; if (smallestUnit !== 'hour' && smallestUnit !== 'minute') out += ':' + second; if (smallestUnit !== 'hour' && smallestUnit !== 'minute' && (smallestUnit !== 'second' || fractionalSecondDigits !== undefined)) { let fracNs = d.getUTCMilliseconds() * 1000000 + remNs; let fracText = Temporal.Duration._pad(fracNs, 9); if (fractionalSecondDigits !== undefined && fractionalSecondDigits !== 'auto') { const fd = Temporal.Duration._toInteger(fractionalSecondDigits, 'fractionalSecondDigits'); if (fd < 0 || fd > 9) throw new RangeError('fractionalSecondDigits out of range'); fracText = fracText.slice(0, fd); while (fracText.length < fd) fracText += '0'; } else if (smallestUnit === 'millisecond') fracText = fracText.slice(0, 3); else if (smallestUnit === 'microsecond') fracText = fracText.slice(0, 6); else { while (fracText.length > 0 && fracText.charCodeAt(fracText.length - 1) === 48) fracText = fracText.slice(0, -1); } if (fracText.length > 0) out += '.' + fracText; }
return out + 'Z'; }
toJSON() { Temporal.Instant._requireThis(this, 'toJSON'); return this.toString(); }
toLocaleString() { Temporal.Instant._requireThis(this, 'toLocaleString'); return this.toString(); }
valueOf() { Temporal.Instant._requireThis(this, 'valueOf'); throw new TypeError('Do not use valueOf on Temporal.Instant'); } },
PlainDate: class PlainDate { constructor(year, month, day, calendar = undefined) { Object.defineProperty(this, '_temporalBrand', { value: 'Temporal.PlainDate', writable: false, enumerable: false, configurable: false }); this._year = Temporal.Duration._toInteger(year, 'year'); this._month = Temporal.Duration._toInteger(month, 'month'); this._day = Temporal.Duration._toInteger(day, 'day'); this._calendar = Temporal.Duration._normalizeCalendarId(calendar, 'calendar'); Temporal.PlainDate._validate(this._year, this._month, this._day); Temporal.Duration._checkIsoDateRange(this._year, this._month, this._day); }
static _requireThis(value, label) { if (!value || typeof value !== 'object' || value._temporalBrand !== 'Temporal.PlainDate') { throw new TypeError('Temporal.PlainDate.prototype.' + label + ' called on incompatible receiver'); }
return value; }
static _digit(str, i) { const d = str.charCodeAt(i) - 48; return d >= 0 && d <= 9 ? d : -1; }
static _isLeapYear(year) { if (year % 400 === 0) return true; if (year % 100 === 0) return false; return year % 4 === 0; }
static _daysInMonth(year, month) { if (month === 1 || month === 3 || month === 5 || month === 7 || month === 8 || month === 10 || month === 12) return 31; if (month === 4 || month === 6 || month === 9 || month === 11) return 30; if (month === 2) return Temporal.PlainDate._isLeapYear(year) ? 29 : 28; return 0; }
static _validate(year, month, day) { if (month < 1 || month > 12) throw new RangeError('Invalid month'); const dim = Temporal.PlainDate._daysInMonth(year, month); if (day < 1 || day > dim) throw new RangeError('Invalid day'); }
static _epochDay(date) { return Math.trunc(Date.UTC(date._year, date._month - 1, date._day) / 86400000); }
static _differenceMonthsDays(lhs, rhs) { let months = (lhs._year - rhs._year) * 12 + (lhs._month - rhs._month); let pivot = rhs.add(new Temporal.Duration(0, months, 0, 0, 0, 0, 0, 0, 0, 0), { overflow: 'constrain' }); const cmp = Temporal.PlainDate.compare(pivot, lhs); if (months > 0 && cmp > 0) { months--; pivot = rhs.add(new Temporal.Duration(0, months, 0, 0, 0, 0, 0, 0, 0, 0), { overflow: 'constrain' }); } else if (months < 0 && cmp < 0) { months++; pivot = rhs.add(new Temporal.Duration(0, months, 0, 0, 0, 0, 0, 0, 0, 0), { overflow: 'constrain' }); } const days = Temporal.PlainDate._epochDay(lhs) - Temporal.PlainDate._epochDay(pivot); return { months, days }; }
static _roundedCalendarMonths(rhs, months, days, unit, roundingIncrement, roundingMode) { const unitMonths = unit === 'year' ? 12 : 1; const step = unitMonths * roundingIncrement; let value = months;
if (days > 0) { const lower = rhs.add(new Temporal.Duration(0, months, 0, 0, 0, 0, 0, 0, 0, 0), { overflow: 'constrain' }); const upper = rhs.add(new Temporal.Duration(0, months + 1, 0, 0, 0, 0, 0, 0, 0, 0), { overflow: 'constrain' }); const span = Temporal.PlainDate._epochDay(upper) - Temporal.PlainDate._epochDay(lower); if (span !== 0) value += days / span; } else if (days < 0) { const lower = rhs.add(new Temporal.Duration(0, months - 1, 0, 0, 0, 0, 0, 0, 0, 0), { overflow: 'constrain' }); const upper = rhs.add(new Temporal.Duration(0, months, 0, 0, 0, 0, 0, 0, 0, 0), { overflow: 'constrain' }); const span = Temporal.PlainDate._epochDay(upper) - Temporal.PlainDate._epochDay(lower); if (span !== 0) value += days / span; }
return Temporal.Duration._roundToIncrement(value, step, roundingMode); }
static _extractAnnotations(value) { if (typeof value !== 'string') throw new TypeError('Temporal string expected');
let bare = ''; let calendar = 'iso8601'; let timeZone; let sawCalendar = false; let sawTimeZone = false;
for (let i = 0; i < value.length; i++) { const ch = value.charCodeAt(i); if (ch !== 91) { bare += value[i]; continue; }
let end = i + 1; while (end < value.length && value.charCodeAt(end) !== 93) end++; if (end >= value.length) throw new RangeError('Invalid annotation');
let tag = value.slice(i + 1, end); let critical = false; if (tag.length > 0 && tag.charCodeAt(0) === 33) { critical = true; tag = tag.slice(1); }
const eq = tag.indexOf('='); if (eq >= 0) { const key = tag.slice(0, eq); const val = tag.slice(eq + 1); if (key === 'u-ca') { if (sawCalendar) throw new RangeError('Duplicate calendar annotation'); calendar = Temporal.Duration._normalizeCalendarId(val, 'calendar'); sawCalendar = true; } else if (critical) throw new RangeError('Unknown critical annotation'); } else if (tag.length > 0) { if (sawTimeZone) throw new RangeError('Duplicate time zone annotation'); timeZone = Temporal.Duration._normalizeTimeZoneId(tag, 'timeZone'); sawTimeZone = true; } else if (critical) { throw new RangeError('Unknown critical annotation'); }
i = end; }
return { bare, calendar, timeZone }; }
static _parseDatePart(dateText) { if (dateText.length < 8) throw new RangeError('Invalid ISO date string');
let i = 0; let sign = 1; let hadSign = false; if (dateText.charCodeAt(i) === 43) { hadSign = true; i++; } else if (dateText.charCodeAt(i) === 45) { sign = -1; hadSign = true; i++; }
let year = 0; let yearDigits = 0; while (i < dateText.length) { const d = Temporal.PlainDate._digit(dateText, i); if (d < 0) break; year = year * 10 + d; yearDigits++; i++; }
if (yearDigits < 4) throw new RangeError('Invalid ISO date string'); if (!hadSign && yearDigits !== 4) throw new RangeError('Invalid ISO date string'); if (hadSign && yearDigits !== 6) throw new RangeError('Invalid ISO date string'); year *= sign;
if (i >= dateText.length || dateText.charCodeAt(i) !== 45) throw new RangeError('Invalid ISO date string'); i++;
if (i + 1 >= dateText.length) throw new RangeError('Invalid ISO date string'); const month = Temporal.Duration._parseNDigits(dateText, i, 2); if (month < 0) throw new RangeError('Invalid ISO date string'); i += 2;
if (i >= dateText.length || dateText.charCodeAt(i) !== 45) throw new RangeError('Invalid ISO date string'); i++;
if (i + 1 >= dateText.length) throw new RangeError('Invalid ISO date string'); const day = Temporal.Duration._parseNDigits(dateText, i, 2); if (day < 0) throw new RangeError('Invalid ISO date string'); i += 2;
if (i !== dateText.length) throw new RangeError('Invalid ISO date string'); return { year, month, day }; }
static _fromParts(parts, options) { const opts = Temporal.Duration._toOptions(options); const overflow = Temporal.Duration._getStringOption(opts, 'overflow', 'constrain', [ 'constrain', 'reject' ]);
let year = Temporal.Duration._toInteger(parts.year, 'year'); let month = Temporal.Duration._toInteger(parts.month, 'month'); let day = Temporal.Duration._toInteger(parts.day, 'day');
if (overflow === 'constrain') { if (month < 1) month = 1; if (month > 12) month = 12; const dim = Temporal.PlainDate._daysInMonth(year, month); if (day < 1) day = 1; if (day > dim) day = dim; } else { Temporal.PlainDate._validate(year, month, day); }
return new Temporal.PlainDate(year, month, day, Temporal.Duration._normalizeCalendarId(parts.calendar, 'calendar')); }
static from(value, options) { const opts = Temporal.Duration._toOptions(options); if (typeof value === 'string') { const p = Temporal.PlainDateTime._parseISODateTimeString(value); const out = p.date; Temporal.PlainDate._validate(out.year, out.month, out.day); return new Temporal.PlainDate(out.year, out.month, out.day, p.calendar); }
if (value && typeof value === 'object') { if (value._temporalBrand === 'Temporal.PlainDate') { return Temporal.PlainDate._fromParts({ year: value._year, month: value._month, day: value._day, calendar: value._calendar }, opts); } if (value._temporalBrand === 'Temporal.PlainDateTime') { return Temporal.PlainDate._fromParts({ year: value._year, month: value._month, day: value._day, calendar: value._calendar }, opts); } if (value._temporalBrand === 'Temporal.ZonedDateTime') { const pdt = Temporal.ZonedDateTime._instantToPlainDateTime(value._epochNanoseconds, value._timeZone, value._calendar); return Temporal.PlainDate._fromParts({ year: pdt._year, month: pdt._month, day: pdt._day, calendar: pdt._calendar }, opts); }
const calendar = value.calendar; const dayValue = value.day; const day = dayValue === undefined ? undefined : Temporal.Duration._toInteger(dayValue, 'day'); const monthValue = value.month; let month = monthValue === undefined ? undefined : Temporal.Duration._toInteger(monthValue, 'month'); const monthCodeValue = value.monthCode; if (monthCodeValue !== undefined) { const monthCode = String(monthCodeValue); if (monthCode.length !== 3 || monthCode.charCodeAt(0) !== 77) throw new RangeError('Invalid monthCode'); const parsedMonth = Temporal.Duration._parseNDigits(monthCode, 1, 2); if (parsedMonth < 1 || parsedMonth > 12) throw new RangeError('Invalid monthCode'); if (month !== undefined && month !== parsedMonth) throw new RangeError('month and monthCode disagree'); month = parsedMonth; } const yearValue = value.year; const year = yearValue === undefined ? undefined : Temporal.Duration._toInteger(yearValue, 'year'); if (year !== undefined && day !== undefined && month !== undefined) { return Temporal.PlainDate._fromParts({ year, month, day, calendar }, opts); } }
throw new TypeError('Cannot convert value to Temporal.PlainDate'); }
static compare(a, b) { const aa = Temporal.PlainDate.from(a); const bb = Temporal.PlainDate.from(b); if (aa._year !== bb._year) return aa._year < bb._year ? -1 : 1; if (aa._month !== bb._month) return aa._month < bb._month ? -1 : 1; if (aa._day !== bb._day) return aa._day < bb._day ? -1 : 1; return 0; }
static _padUnsigned(value, size) { let out = String(Math.abs(value)); while (out.length < size) out = '0' + out; return out; }
static _isoWeek(date) { const tmp = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate())); const day = tmp.getUTCDay(); const isoDay = day === 0 ? 7 : day; tmp.setUTCDate(tmp.getUTCDate() + 4 - isoDay); const yearStart = new Date(Date.UTC(tmp.getUTCFullYear(), 0, 1)); const diff = Math.floor((tmp - yearStart) / 86400000); const week = Math.floor(diff / 7) + 1; return { week, year: tmp.getUTCFullYear() }; }
get year() { return Temporal.PlainDate._requireThis(this, 'year')._year; } get month() { return Temporal.PlainDate._requireThis(this, 'month')._month; } get day() { return Temporal.PlainDate._requireThis(this, 'day')._day; } get calendarId() { return Temporal.PlainDate._requireThis(this, 'calendarId')._calendar; } get monthCode() { return 'M' + Temporal.Duration._pad(this.month, 2); } get dayOfWeek() { const d = new Date(Date.UTC(this.year, this.month - 1, this.day)); const x = d.getUTCDay(); return x === 0 ? 7 : x; } get dayOfYear() { const d = new Date(Date.UTC(this.year, this.month - 1, this.day)); const s = new Date(Date.UTC(this.year, 0, 1)); return Math.floor((d - s) / 86400000) + 1; } get weekOfYear() { const d = new Date(Date.UTC(this.year, this.month - 1, this.day)); return Temporal.PlainDate._isoWeek(d).week; } get yearOfWeek() { const d = new Date(Date.UTC(this.year, this.month - 1, this.day)); return Temporal.PlainDate._isoWeek(d).year; } get daysInWeek() { return 7; } get daysInMonth() { return Temporal.PlainDate._daysInMonth(this.year, this.month); } get daysInYear() { return Temporal.PlainDate._isLeapYear(this.year) ? 366 : 365; } get monthsInYear() { return 12; } get inLeapYear() { return Temporal.PlainDate._isLeapYear(this.year); } get era() { return this.year <= 0 ? 'bce' : 'ce'; } get eraYear() { return this.year <= 0 ? 1 - this.year : this.year; }
with(item, options) { const d = Temporal.PlainDate._requireThis(this, 'with'); if (!item || typeof item !== 'object') throw new TypeError('Temporal.PlainDate.with requires an object'); return Temporal.PlainDate._fromParts( { year: item.year === undefined ? d._year : item.year, month: item.month === undefined ? d._month : item.month, day: item.day === undefined ? d._day : item.day, calendar: item.calendar === undefined ? d._calendar : item.calendar }, options ); }
withCalendar(calendar) { Temporal.PlainDate._requireThis(this, 'withCalendar'); return new Temporal.PlainDate(this._year, this._month, this._day, calendar); }
add(durationLike, options) { Temporal.PlainDate._requireThis(this, 'add'); const opts = Temporal.Duration._toOptions(options); const overflow = Temporal.Duration._getStringOption(opts, 'overflow', 'constrain', [ 'constrain', 'reject' ]); const d = Temporal.Duration.from(durationLike);
let year = this._year + d.years; let month = this._month + d.months; while (month > 12) { month -= 12; year++; } while (month < 1) { month += 12; year--; }
let day = this._day; if (overflow === 'constrain') { const dim = Temporal.PlainDate._daysInMonth(year, month); if (day > dim) day = dim; }
const date = new Date(Date.UTC(year, month - 1, day)); const dayDelta = d.weeks * 7 + d.days; if (dayDelta !== 0) date.setUTCDate(date.getUTCDate() + dayDelta); if (d.hours || d.minutes || d.seconds || d.milliseconds || d.microseconds || d.nanoseconds) { const ms = (((d.hours * 60 + d.minutes) * 60 + d.seconds) * 1000) + d.milliseconds + d.microseconds / 1000 + d.nanoseconds / 1000000; date.setTime(date.getTime() + ms); }
return new Temporal.PlainDate(date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate(), this._calendar); }
subtract(durationLike, options) { Temporal.PlainDate._requireThis(this, 'subtract'); return this.add(Temporal.Duration.from(durationLike).negated(), options); }
since(other, options = undefined) { Temporal.PlainDate._requireThis(this, 'since'); const rhs = Temporal.PlainDate.from(other); const opts = Temporal.Duration._toOptions(options); const settings = Temporal.Duration._differenceSettings( opts, 'day', [ 'year', 'month', 'week', 'day' ], 'day', [ 'auto', 'year', 'month', 'week', 'day' ], 'trunc' );
const dayDiff = Temporal.PlainDate._epochDay(this) - Temporal.PlainDate._epochDay(rhs); const largestUnit = settings.largestUnit; const smallestUnit = settings.smallestUnit; const roundingIncrement = settings.roundingIncrement; const roundingMode = settings.roundingMode;
if (largestUnit === 'year' || largestUnit === 'month' || smallestUnit === 'year' || smallestUnit === 'month') { const base = Temporal.PlainDate._differenceMonthsDays(this, rhs); let months = base.months; let days = base.days;
if (smallestUnit === 'year' || smallestUnit === 'month') { const monthsStep = (smallestUnit === 'year' ? 12 : 1) * roundingIncrement; rhs.add(new Temporal.Duration(0, monthsStep, 0, 0, 0, 0, 0, 0, 0, 0), { overflow: 'constrain' }); rhs.add(new Temporal.Duration(0, -monthsStep, 0, 0, 0, 0, 0, 0, 0, 0), { overflow: 'constrain' }); months = Temporal.PlainDate._roundedCalendarMonths(rhs, months, days, smallestUnit, roundingIncrement, roundingMode); days = 0; } else if (smallestUnit === 'week') { const roundedDays = Temporal.Duration._roundToIncrement(dayDiff / 7, roundingIncrement, roundingMode) * 7; const roundedDate = rhs.add(new Temporal.Duration(0, 0, 0, roundedDays, 0, 0, 0, 0, 0, 0), { overflow: 'constrain' }); const rounded = Temporal.PlainDate._differenceMonthsDays(roundedDate, rhs); months = rounded.months; days = rounded.days; } else if (smallestUnit === 'day') { const roundedDays = Temporal.Duration._roundToIncrement(dayDiff, roundingIncrement, roundingMode); const roundedDate = rhs.add(new Temporal.Duration(0, 0, 0, roundedDays, 0, 0, 0, 0, 0, 0), { overflow: 'constrain' }); const rounded = Temporal.PlainDate._differenceMonthsDays(roundedDate, rhs); months = rounded.months; days = rounded.days; }
if (largestUnit === 'year') { const years = months < 0 ? Math.ceil(months / 12) : Math.floor(months / 12); months -= years * 12; return new Temporal.Duration(years, months, 0, days, 0, 0, 0, 0, 0, 0); } if (largestUnit === 'month') { return new Temporal.Duration(0, months, 0, days, 0, 0, 0, 0, 0, 0); } }
const roundedDays = smallestUnit === 'week' ? Temporal.Duration._roundToIncrement(dayDiff / 7, roundingIncrement, roundingMode) * 7 : Temporal.Duration._roundToIncrement(dayDiff, roundingIncrement, roundingMode); if (largestUnit === 'week') { const weeks = roundedDays < 0 ? Math.ceil(roundedDays / 7) : Math.floor(roundedDays / 7); return new Temporal.Duration(0, 0, weeks, roundedDays - weeks * 7, 0, 0, 0, 0, 0, 0); } return new Temporal.Duration(0, 0, 0, roundedDays, 0, 0, 0, 0, 0, 0); }
until(other, options) { Temporal.PlainDate._requireThis(this, 'until'); return Temporal.PlainDate.from(other).since(this, options); }
equals(other) { Temporal.PlainDate._requireThis(this, 'equals'); return Temporal.PlainDate.compare(this, other) === 0 && this._calendar === Temporal.PlainDate.from(other)._calendar; }
toPlainDateTime(item) { Temporal.PlainDate._requireThis(this, 'toPlainDateTime'); const t = item === undefined ? new Temporal.PlainTime(0, 0, 0, 0, 0, 0) : Temporal.PlainTime.from(item); return new Temporal.PlainDateTime(this._year, this._month, this._day, t.hour, t.minute, t.second, t.millisecond, t.microsecond, t.nanosecond, this._calendar); }
toZonedDateTime(item) { Temporal.PlainDate._requireThis(this, 'toZonedDateTime'); if (!item || typeof item !== 'object') throw new TypeError('Temporal.PlainDate.toZonedDateTime requires an object'); const pdt = this.toPlainDateTime(item.plainTime); return pdt.toZonedDateTime(item.timeZone); }
toString(options) { Temporal.PlainDate._requireThis(this, 'toString'); const opts = Temporal.Duration._toOptions(options); const calendarName = Temporal.Duration._getStringOption(opts, 'calendarName', 'auto', [ 'auto', 'always', 'never', 'critical' ]);
const y = Temporal.Duration._formatIsoYear(this._year); const m = Temporal.Duration._pad(this._month, 2); const d = Temporal.Duration._pad(this._day, 2); let out = y + '-' + m + '-' + d; if (calendarName === 'always') { out += '[u-ca=' + this._calendar + ']'; } else if (calendarName === 'critical') { out += '[!u-ca=' + this._calendar + ']'; } else if (calendarName === 'auto' && this._calendar !== 'iso8601') { out += '[u-ca=' + this._calendar + ']'; } return out; }
toJSON() { Temporal.PlainDate._requireThis(this, 'toJSON'); return this.toString(); }
toLocaleString() { Temporal.PlainDate._requireThis(this, 'toLocaleString'); return this.toString(); }
valueOf() { Temporal.PlainDate._requireThis(this, 'valueOf'); throw new TypeError('Do not use valueOf on Temporal.PlainDate'); } },
PlainTime: class PlainTime { constructor(hour, minute, second, millisecond, microsecond, nanosecond) { Object.defineProperty(this, '_temporalBrand', { value: 'Temporal.PlainTime', writable: false, enumerable: false, configurable: false }); this._hour = Temporal.Duration._toInteger(hour === undefined ? 0 : hour, 'hour'); this._minute = Temporal.Duration._toInteger(minute === undefined ? 0 : minute, 'minute'); this._second = Temporal.Duration._toInteger(second === undefined ? 0 : second, 'second'); this._millisecond = Temporal.Duration._toInteger(millisecond === undefined ? 0 : millisecond, 'millisecond'); this._microsecond = Temporal.Duration._toInteger(microsecond === undefined ? 0 : microsecond, 'microsecond'); this._nanosecond = Temporal.Duration._toInteger(nanosecond === undefined ? 0 : nanosecond, 'nanosecond'); Temporal.PlainTime._validate(this._hour, this._minute, this._second, this._millisecond, this._microsecond, this._nanosecond); }
static _requireThis(value, label) { if (!value || typeof value !== 'object' || value._temporalBrand !== 'Temporal.PlainTime') { throw new TypeError('Temporal.PlainTime.prototype.' + label + ' called on incompatible receiver'); }
return value; }
static _validate(hour, minute, second, millisecond, microsecond, nanosecond) { if (hour < 0 || hour > 23) throw new RangeError('Invalid hour'); if (minute < 0 || minute > 59) throw new RangeError('Invalid minute'); if (second < 0 || second > 59) throw new RangeError('Invalid second'); if (millisecond < 0 || millisecond > 999) throw new RangeError('Invalid millisecond'); if (microsecond < 0 || microsecond > 999) throw new RangeError('Invalid microsecond'); if (nanosecond < 0 || nanosecond > 999) throw new RangeError('Invalid nanosecond'); }
static _parseTimePart(text) { if (text.length < 5) throw new RangeError('Invalid ISO time string'); if (text.charCodeAt(2) !== 58) throw new RangeError('Invalid ISO time string');
const hour = Temporal.Duration._parseNDigits(text, 0, 2); const minute = Temporal.Duration._parseNDigits(text, 3, 2); if (hour < 0 || minute < 0) throw new RangeError('Invalid ISO time string');
let second = 0; let millisecond = 0; let microsecond = 0; let nanosecond = 0; let leapSecond = false;
let i = 5; if (i < text.length) { if (text.charCodeAt(i) !== 58) throw new RangeError('Invalid ISO time string'); i++; if (i + 1 >= text.length) throw new RangeError('Invalid ISO time string');
second = Temporal.Duration._parseNDigits(text, i, 2); if (second < 0) throw new RangeError('Invalid ISO time string'); if (second === 60) { leapSecond = true; second = 59; } i += 2;
if (i < text.length) { if (text.charCodeAt(i) !== 46) throw new RangeError('Invalid ISO time string'); i++;
let frac = 0; let fracDigits = 0; while (i < text.length) { const d = Temporal.Duration._digit(text, i); if (d < 0) throw new RangeError('Invalid ISO time string'); if (fracDigits < 9) frac = frac * 10 + d; fracDigits++; i++; }
if (fracDigits === 0) throw new RangeError('Invalid ISO time string'); while (fracDigits < 9) { frac *= 10; fracDigits++; }
millisecond = Math.trunc(frac / 1000000); frac -= millisecond * 1000000; microsecond = Math.trunc(frac / 1000); frac -= microsecond * 1000; nanosecond = frac; } }
Temporal.PlainTime._validate(hour, minute, second, millisecond, microsecond, nanosecond); return { hour, minute, second, millisecond, microsecond, nanosecond, leapSecond }; }
static from(value) { if (typeof value === 'string') { const raw = Temporal.PlainDate._extractAnnotations(value); let txt = raw.bare; let sep = txt.indexOf('T'); if (sep < 0) sep = txt.indexOf('t'); if (sep < 0) sep = txt.indexOf(' '); if (sep >= 0) txt = txt.slice(sep + 1); if (txt.length > 0 && (txt.charCodeAt(0) === 84 || txt.charCodeAt(0) === 116)) txt = txt.slice(1);
let offsetIndex = -1; for (let i = 1; i < txt.length; i++) { const ch = txt.charCodeAt(i); if (ch === 43 || ch === 45) { offsetIndex = i; break; } if (ch === 90 || ch === 122) { offsetIndex = i; break; } } if (offsetIndex >= 0) txt = txt.slice(0, offsetIndex); const parsed = Temporal.PlainTime._parseTimePart(txt); return new Temporal.PlainTime(parsed.hour, parsed.minute, parsed.second, parsed.millisecond, parsed.microsecond, parsed.nanosecond); }
if (value && typeof value === 'object') { if (value._temporalBrand === 'Temporal.PlainTime') { return new Temporal.PlainTime(value._hour, value._minute, value._second, value._millisecond, value._microsecond, value._nanosecond); }
if (value.hour !== undefined) { return new Temporal.PlainTime(value.hour, value.minute, value.second, value.millisecond, value.microsecond, value.nanosecond); } }
throw new TypeError('Cannot convert value to Temporal.PlainTime'); }
static compare(a, b) { const aa = Temporal.PlainTime.from(a); const bb = Temporal.PlainTime.from(b); if (aa._hour !== bb._hour) return aa._hour < bb._hour ? -1 : 1; if (aa._minute !== bb._minute) return aa._minute < bb._minute ? -1 : 1; if (aa._second !== bb._second) return aa._second < bb._second ? -1 : 1; if (aa._millisecond !== bb._millisecond) return aa._millisecond < bb._millisecond ? -1 : 1; if (aa._microsecond !== bb._microsecond) return aa._microsecond < bb._microsecond ? -1 : 1; if (aa._nanosecond !== bb._nanosecond) return aa._nanosecond < bb._nanosecond ? -1 : 1; return 0; }
static _toNanoseconds(p) { return (((((p._hour * 60 + p._minute) * 60 + p._second) * 1000 + p._millisecond) * 1000 + p._microsecond) * 1000 + p._nanosecond); }
static _fromNanoseconds(total) { let t = total % 86400000000000; if (t < 0) t += 86400000000000;
const hour = Math.trunc(t / 3600000000000); t -= hour * 3600000000000; const minute = Math.trunc(t / 60000000000); t -= minute * 60000000000; const second = Math.trunc(t / 1000000000); t -= second * 1000000000; const millisecond = Math.trunc(t / 1000000); t -= millisecond * 1000000; const microsecond = Math.trunc(t / 1000); t -= microsecond * 1000; const nanosecond = t;
return new Temporal.PlainTime(hour, minute, second, millisecond, microsecond, nanosecond); }
get hour() { return Temporal.PlainTime._requireThis(this, 'hour')._hour; } get minute() { return Temporal.PlainTime._requireThis(this, 'minute')._minute; } get second() { return Temporal.PlainTime._requireThis(this, 'second')._second; } get millisecond() { return Temporal.PlainTime._requireThis(this, 'millisecond')._millisecond; } get microsecond() { return Temporal.PlainTime._requireThis(this, 'microsecond')._microsecond; } get nanosecond() { return Temporal.PlainTime._requireThis(this, 'nanosecond')._nanosecond; }
with(item) { const p = Temporal.PlainTime._requireThis(this, 'with'); if (!item || typeof item !== 'object') throw new TypeError('Temporal.PlainTime.with requires an object'); return new Temporal.PlainTime( item.hour === undefined ? p._hour : item.hour, item.minute === undefined ? p._minute : item.minute, item.second === undefined ? p._second : item.second, item.millisecond === undefined ? p._millisecond : item.millisecond, item.microsecond === undefined ? p._microsecond : item.microsecond, item.nanosecond === undefined ? p._nanosecond : item.nanosecond ); }
add(durationLike) { Temporal.PlainTime._requireThis(this, 'add'); const d = Temporal.Duration.from(durationLike); if (d.years || d.months || d.weeks || d.days) throw new RangeError('Temporal.PlainTime.add does not support calendar units'); const delta = Temporal.Duration._totalNanoseconds(d); return Temporal.PlainTime._fromNanoseconds(Temporal.PlainTime._toNanoseconds(this) + delta); }
subtract(durationLike) { Temporal.PlainTime._requireThis(this, 'subtract'); return this.add(Temporal.Duration.from(durationLike).negated()); }
since(other, options = undefined) { Temporal.PlainTime._requireThis(this, 'since'); const rhs = Temporal.PlainTime.from(other); const opts = Temporal.Duration._toOptions(options); const settings = Temporal.Duration._differenceSettings( opts, 'nanosecond', [ 'hour', 'minute', 'second', 'millisecond', 'microsecond', 'nanosecond' ], 'hour', [ 'auto', 'hour', 'minute', 'second', 'millisecond', 'microsecond', 'nanosecond' ], 'trunc' ); Temporal.Duration._validateTimeRoundingIncrement(settings.smallestUnit, settings.roundingIncrement); const delta = Temporal.PlainTime._toNanoseconds(this) - Temporal.PlainTime._toNanoseconds(rhs); const rounded = Temporal.Duration._roundNanoseconds(delta, settings.smallestUnit, settings.roundingIncrement, settings.roundingMode); return Temporal.Duration._balanceNanoseconds(rounded, settings.largestUnit); }
until(other, options) { Temporal.PlainTime._requireThis(this, 'until'); return Temporal.PlainTime.from(other).since(this, options); }
round(options) { Temporal.PlainTime._requireThis(this, 'round'); if (options === undefined) throw new TypeError('options is required'); const opts = typeof options === 'string' ? { smallestUnit: options } : Temporal.Duration._toOptions(options); if (opts.smallestUnit === undefined) throw new RangeError('smallestUnit is required'); const smallestUnit = Temporal.Duration._getUnitOption(opts, 'smallestUnit', undefined, [ 'hour', 'minute', 'second', 'millisecond', 'microsecond', 'nanosecond' ]); const increment = Temporal.Duration._getNumberOption(opts, 'roundingIncrement', 1); const mode = Temporal.Duration._normalizeRoundingMode(opts.roundingMode, 'halfExpand'); if (increment <= 0) throw new RangeError('roundingIncrement must be positive');
const ns = Temporal.PlainTime._toNanoseconds(this); return Temporal.PlainTime._fromNanoseconds(Temporal.Duration._roundNanoseconds(ns, smallestUnit, increment, mode)); }
toPlainDateTime(item) { Temporal.PlainTime._requireThis(this, 'toPlainDateTime'); const date = Temporal.PlainDate.from(item); return new Temporal.PlainDateTime(date.year, date.month, date.day, this._hour, this._minute, this._second, this._millisecond, this._microsecond, this._nanosecond, date.calendarId); }
equals(other) { Temporal.PlainTime._requireThis(this, 'equals'); return Temporal.PlainTime.compare(this, other) === 0; }
toString(options) { Temporal.PlainTime._requireThis(this, 'toString'); const opts = Temporal.Duration._toOptions(options); let smallestUnit = Temporal.Duration._getUnitOption(opts, 'smallestUnit', 'nanosecond', [ 'hour', 'minute', 'second', 'millisecond', 'microsecond', 'nanosecond' ]); let fractionalSecondDigits = opts.fractionalSecondDigits; const roundingIncrement = Temporal.Duration._getNumberOption(opts, 'roundingIncrement', 1); const roundingMode = Temporal.Duration._normalizeRoundingMode(opts.roundingMode, 'trunc'); const rounded = this.round({ smallestUnit, roundingIncrement, roundingMode });
let frac = rounded._millisecond * 1000000 + rounded._microsecond * 1000 + rounded._nanosecond; let fracText = Temporal.Duration._pad(frac, 9);
if (fractionalSecondDigits !== undefined) { const fd = Temporal.Duration._toInteger(fractionalSecondDigits, 'fractionalSecondDigits'); if (fd < 0 || fd > 9) throw new RangeError('fractionalSecondDigits out of range'); fracText = fracText.slice(0, fd); while (fracText.length < fd) fracText += '0'; } else { if (smallestUnit === 'hour' || smallestUnit === 'minute') fracText = ''; else if (smallestUnit === 'second') fracText = ''; else if (smallestUnit === 'millisecond') fracText = fracText.slice(0, 3); else if (smallestUnit === 'microsecond') fracText = fracText.slice(0, 6); else { while (fracText.length > 0 && fracText.charCodeAt(fracText.length - 1) === 48) fracText = fracText.slice(0, -1); } }
const hh = Temporal.Duration._pad(rounded._hour, 2); const mm = Temporal.Duration._pad(rounded._minute, 2); const ss = Temporal.Duration._pad(rounded._second, 2); if (smallestUnit === 'hour') return hh; if (smallestUnit === 'minute') return hh + ':' + mm; if (fracText.length === 0) return hh + ':' + mm + ':' + ss; return hh + ':' + mm + ':' + ss + '.' + fracText; }
toJSON() { Temporal.PlainTime._requireThis(this, 'toJSON'); return this.toString(); }
toLocaleString() { Temporal.PlainTime._requireThis(this, 'toLocaleString'); return this.toString(); }
valueOf() { Temporal.PlainTime._requireThis(this, 'valueOf'); throw new TypeError('Do not use valueOf on Temporal.PlainTime'); } },
PlainDateTime: class PlainDateTime { constructor(year, month, day, hour, minute, second, millisecond, microsecond, nanosecond, calendar = undefined) { Object.defineProperty(this, '_temporalBrand', { value: 'Temporal.PlainDateTime', writable: false, enumerable: false, configurable: false }); this._year = Temporal.Duration._toInteger(year, 'year'); this._month = Temporal.Duration._toInteger(month, 'month'); this._day = Temporal.Duration._toInteger(day, 'day'); this._hour = Temporal.Duration._toInteger(hour === undefined ? 0 : hour, 'hour'); this._minute = Temporal.Duration._toInteger(minute === undefined ? 0 : minute, 'minute'); this._second = Temporal.Duration._toInteger(second === undefined ? 0 : second, 'second'); this._millisecond = Temporal.Duration._toInteger(millisecond === undefined ? 0 : millisecond, 'millisecond'); this._microsecond = Temporal.Duration._toInteger(microsecond === undefined ? 0 : microsecond, 'microsecond'); this._nanosecond = Temporal.Duration._toInteger(nanosecond === undefined ? 0 : nanosecond, 'nanosecond'); this._calendar = Temporal.Duration._normalizeCalendarId(calendar, 'calendar');
Temporal.PlainDate._validate(this._year, this._month, this._day); Temporal.PlainTime._validate(this._hour, this._minute, this._second, this._millisecond, this._microsecond, this._nanosecond); Temporal.Duration._checkIsoDateRange(this._year, this._month, this._day); }
static _requireThis(value, label) { if (!value || typeof value !== 'object' || value._temporalBrand !== 'Temporal.PlainDateTime') { throw new TypeError('Temporal.PlainDateTime.prototype.' + label + ' called on incompatible receiver'); }
return value; }
static _offsetNanoseconds(offsetText) { if (offsetText == null || offsetText.length === 0) return null; return Temporal.Duration._offsetNanoseconds(offsetText, 'offset'); }
static _timeZoneOffsetNanoseconds(timeZone) { return Temporal.Duration._timeZoneOffsetNanoseconds(timeZone); }
static _parseISODateTimeString(value) { const ann = Temporal.PlainDate._extractAnnotations(value); let bare = ann.bare;
let sep = bare.indexOf('T'); if (sep < 0) sep = bare.indexOf('t'); if (sep < 0) sep = bare.indexOf(' ');
let dateText = bare; let timeText = ''; if (sep >= 0) { dateText = bare.slice(0, sep); timeText = bare.slice(sep + 1); if (timeText.length === 0) throw new RangeError('Invalid ISO date-time string'); }
const date = Temporal.PlainDate._parseDatePart(dateText);
if (timeText.length === 0) { return { date, time: null, offsetNanoseconds: null, timeZone: ann.timeZone, calendar: ann.calendar, leapSecond: false }; }
let offsetNanoseconds = null; let offsetIndex = -1; let seenOffsetSign = false; for (let i = 0; i < timeText.length; i++) { const ch = timeText.charCodeAt(i); if (i > 0 && (ch === 43 || ch === 45)) { if (seenOffsetSign) throw new RangeError('Invalid ISO date-time string'); offsetIndex = i; seenOffsetSign = true; break; } }
let timePart = timeText; if (timeText.length > 0) { for (let i = 0; i < timeText.length; i++) { const ch = timeText.charCodeAt(i); if (ch === 90 || ch === 122) { if (i !== timeText.length - 1) throw new RangeError('Invalid ISO date-time string'); offsetIndex = i; break; } } }
if (offsetIndex >= 0) { if (offsetIndex === timeText.length - 1) { offsetNanoseconds = 0; timePart = timeText.slice(0, -1); } else { const offsetText = timeText.slice(offsetIndex); offsetNanoseconds = Temporal.PlainDateTime._offsetNanoseconds(offsetText); timePart = timeText.slice(0, offsetIndex); } }
const time = Temporal.PlainTime._parseTimePart(timePart);
return { date, time, offsetNanoseconds, timeZone: ann.timeZone, calendar: ann.calendar, leapSecond: time.leapSecond === true }; }
static _partsToEpochNanoseconds(parts, preferOffset) { const d = parts.date; const t = parts.time;
const ms = Date.UTC(d.year, d.month - 1, d.day, t.hour, t.minute, t.second, t.millisecond); let ns = ms * 1000000 + t.microsecond * 1000 + t.nanosecond;
let offset = 0; if (parts.offsetNanoseconds != null && preferOffset !== false) { offset = parts.offsetNanoseconds; } else if (parts.timeZone !== undefined) { offset = Temporal.PlainDateTime._timeZoneOffsetNanoseconds(parts.timeZone); }
ns -= offset; if (parts.leapSecond) ns += 1000000000; return ns; }
static from(value, options) { const opts = Temporal.Duration._toOptions(options); const overflow = Temporal.Duration._getStringOption(opts, 'overflow', 'constrain', [ 'constrain', 'reject' ]);
if (typeof value === 'string') { const parts = Temporal.PlainDateTime._parseISODateTimeString(value); if (parts.time == null) { return new Temporal.PlainDateTime(parts.date.year, parts.date.month, parts.date.day, 0, 0, 0, 0, 0, 0, parts.calendar); }
if (overflow === 'reject') { Temporal.PlainDate._validate(parts.date.year, parts.date.month, parts.date.day); }
return new Temporal.PlainDateTime( parts.date.year, parts.date.month, parts.date.day, parts.time.hour, parts.time.minute, parts.time.second, parts.time.millisecond, parts.time.microsecond, parts.time.nanosecond, parts.calendar ); }
if (value && typeof value === 'object') { if (value._temporalBrand === 'Temporal.PlainDateTime') { return new Temporal.PlainDateTime(value._year, value._month, value._day, value._hour, value._minute, value._second, value._millisecond, value._microsecond, value._nanosecond, value._calendar); }
if (value.year !== undefined && value.month !== undefined && value.day !== undefined) { return new Temporal.PlainDateTime( value.year, value.month, value.day, value.hour, value.minute, value.second, value.millisecond, value.microsecond, value.nanosecond, value.calendar ); } }
throw new TypeError('Cannot convert value to Temporal.PlainDateTime'); }
static compare(a, b) { const aa = Temporal.PlainDateTime.from(a); const bb = Temporal.PlainDateTime.from(b); if (aa._year !== bb._year) return aa._year < bb._year ? -1 : 1; if (aa._month !== bb._month) return aa._month < bb._month ? -1 : 1; if (aa._day !== bb._day) return aa._day < bb._day ? -1 : 1; if (aa._hour !== bb._hour) return aa._hour < bb._hour ? -1 : 1; if (aa._minute !== bb._minute) return aa._minute < bb._minute ? -1 : 1; if (aa._second !== bb._second) return aa._second < bb._second ? -1 : 1; if (aa._millisecond !== bb._millisecond) return aa._millisecond < bb._millisecond ? -1 : 1; if (aa._microsecond !== bb._microsecond) return aa._microsecond < bb._microsecond ? -1 : 1; if (aa._nanosecond !== bb._nanosecond) return aa._nanosecond < bb._nanosecond ? -1 : 1; return 0; }
static _toEpochNanoseconds(dt, timeZone) { const ms = Date.UTC(dt._year, dt._month - 1, dt._day, dt._hour, dt._minute, dt._second, dt._millisecond); const frac = dt._microsecond * 1000 + dt._nanosecond; const offset = Temporal.PlainDateTime._timeZoneOffsetNanoseconds(timeZone); return ms * 1000000 + frac - offset; }
get year() { return Temporal.PlainDateTime._requireThis(this, 'year')._year; } get month() { return Temporal.PlainDateTime._requireThis(this, 'month')._month; } get day() { return Temporal.PlainDateTime._requireThis(this, 'day')._day; } get hour() { return Temporal.PlainDateTime._requireThis(this, 'hour')._hour; } get minute() { return Temporal.PlainDateTime._requireThis(this, 'minute')._minute; } get second() { return Temporal.PlainDateTime._requireThis(this, 'second')._second; } get millisecond() { return Temporal.PlainDateTime._requireThis(this, 'millisecond')._millisecond; } get microsecond() { return Temporal.PlainDateTime._requireThis(this, 'microsecond')._microsecond; } get nanosecond() { return Temporal.PlainDateTime._requireThis(this, 'nanosecond')._nanosecond; } get calendarId() { return Temporal.PlainDateTime._requireThis(this, 'calendarId')._calendar; } get monthCode() { return 'M' + Temporal.Duration._pad(this.month, 2); } get dayOfWeek() { return this.toPlainDate().dayOfWeek; } get dayOfYear() { return this.toPlainDate().dayOfYear; } get weekOfYear() { return this.toPlainDate().weekOfYear; } get yearOfWeek() { return this.toPlainDate().yearOfWeek; } get daysInWeek() { return 7; } get daysInMonth() { return this.toPlainDate().daysInMonth; } get daysInYear() { return this.toPlainDate().daysInYear; } get monthsInYear() { return 12; } get inLeapYear() { return this.toPlainDate().inLeapYear; }
with(item, options) { const d = Temporal.PlainDateTime._requireThis(this, 'with'); if (!item || typeof item !== 'object') throw new TypeError('Temporal.PlainDateTime.with requires an object'); const opts = Temporal.Duration._toOptions(options); Temporal.Duration._getStringOption(opts, 'overflow', 'constrain', [ 'constrain', 'reject' ]);
return new Temporal.PlainDateTime( item.year === undefined ? d._year : item.year, item.month === undefined ? d._month : item.month, item.day === undefined ? d._day : item.day, item.hour === undefined ? d._hour : item.hour, item.minute === undefined ? d._minute : item.minute, item.second === undefined ? d._second : item.second, item.millisecond === undefined ? d._millisecond : item.millisecond, item.microsecond === undefined ? d._microsecond : item.microsecond, item.nanosecond === undefined ? d._nanosecond : item.nanosecond, item.calendar === undefined ? d._calendar : item.calendar ); }
withCalendar(calendar) { Temporal.PlainDateTime._requireThis(this, 'withCalendar'); return new Temporal.PlainDateTime(this._year, this._month, this._day, this._hour, this._minute, this._second, this._millisecond, this._microsecond, this._nanosecond, calendar); }
add(durationLike, options) { Temporal.PlainDateTime._requireThis(this, 'add'); const opts = Temporal.Duration._toOptions(options); const overflow = Temporal.Duration._getStringOption(opts, 'overflow', 'constrain', [ 'constrain', 'reject' ]); const d = Temporal.Duration.from(durationLike);
let year = this._year + d.years; let month = this._month + d.months; while (month > 12) { month -= 12; year++; } while (month < 1) { month += 12; year--; }
let day = this._day; if (overflow === 'constrain') { const dim = Temporal.PlainDate._daysInMonth(year, month); if (day > dim) day = dim; }
const ms = Date.UTC(year, month - 1, day, this._hour, this._minute, this._second, this._millisecond); let ns = ms * 1000000 + this._microsecond * 1000 + this._nanosecond; const dayAndTime = new Temporal.Duration(0, 0, d.weeks, d.days, d.hours, d.minutes, d.seconds, d.milliseconds, d.microseconds, d.nanoseconds); ns += Temporal.Duration._totalNanoseconds(dayAndTime);
return Temporal.ZonedDateTime._instantToPlainDateTime(ns, 'UTC', this._calendar); }
subtract(durationLike, options) { Temporal.PlainDateTime._requireThis(this, 'subtract'); return this.add(Temporal.Duration.from(durationLike).negated(), options); }
since(other, options = undefined) { Temporal.PlainDateTime._requireThis(this, 'since'); const rhs = Temporal.PlainDateTime.from(other); const opts = Temporal.Duration._toOptions(options); const settings = Temporal.Duration._differenceSettings( opts, 'nanosecond', [ 'day', 'hour', 'minute', 'second', 'millisecond', 'microsecond', 'nanosecond' ], 'day', [ 'auto', 'day', 'hour', 'minute', 'second', 'millisecond', 'microsecond', 'nanosecond' ], 'trunc' ); Temporal.Duration._validateTimeRoundingIncrement(settings.smallestUnit, settings.roundingIncrement); const dayDiff = Temporal.PlainDate._epochDay(this) - Temporal.PlainDate._epochDay(rhs); const timeDiff = Temporal.PlainTime._toNanoseconds(this) - Temporal.PlainTime._toNanoseconds(rhs); if ( settings.largestUnit === 'microsecond' && settings.smallestUnit === 'nanosecond' && settings.roundingIncrement === 1 && settings.roundingMode === 'trunc' ) { const dayMicroseconds = dayDiff * 86400 * 1000000; const timeMicroseconds = Math.trunc(timeDiff / 1000); const nanoseconds = timeDiff - timeMicroseconds * 1000; return new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, dayMicroseconds + timeMicroseconds, nanoseconds); } const total = dayDiff * Temporal.Duration._unitNanoseconds('day') + timeDiff; const rounded = Temporal.Duration._roundNanoseconds(total, settings.smallestUnit, settings.roundingIncrement, settings.roundingMode); return Temporal.Duration._balanceNanoseconds(rounded, settings.largestUnit); }
until(other, options) { Temporal.PlainDateTime._requireThis(this, 'until'); return Temporal.PlainDateTime.from(other).since(this, options); }
round(options) { Temporal.PlainDateTime._requireThis(this, 'round'); if (options === undefined) throw new TypeError('options is required'); const opts = typeof options === 'string' ? { smallestUnit: options } : Temporal.Duration._toOptions(options); if (opts.smallestUnit === undefined) throw new RangeError('smallestUnit is required'); const smallestUnit = Temporal.Duration._getUnitOption(opts, 'smallestUnit', undefined, [ 'day', 'hour', 'minute', 'second', 'millisecond', 'microsecond', 'nanosecond' ]); const increment = Temporal.Duration._getNumberOption(opts, 'roundingIncrement', 1); const mode = Temporal.Duration._normalizeRoundingMode(opts.roundingMode, 'halfExpand'); if (increment <= 0) throw new RangeError('roundingIncrement must be positive');
const ns = Temporal.PlainDateTime._toEpochNanoseconds(this, 'UTC'); return Temporal.ZonedDateTime._instantToPlainDateTime(Temporal.Duration._roundNanoseconds(ns, smallestUnit, increment, mode), 'UTC', this._calendar); }
equals(other) { Temporal.PlainDateTime._requireThis(this, 'equals'); return Temporal.PlainDateTime.compare(this, other) === 0 && this._calendar === Temporal.PlainDateTime.from(other)._calendar; }
toPlainDate() { Temporal.PlainDateTime._requireThis(this, 'toPlainDate'); return new Temporal.PlainDate(this._year, this._month, this._day, this._calendar); }
toPlainTime() { Temporal.PlainDateTime._requireThis(this, 'toPlainTime'); return new Temporal.PlainTime(this._hour, this._minute, this._second, this._millisecond, this._microsecond, this._nanosecond); }
toZonedDateTime(timeZone) { Temporal.PlainDateTime._requireThis(this, 'toZonedDateTime'); return new Temporal.ZonedDateTime(Temporal.PlainDateTime._toEpochNanoseconds(this, timeZone), timeZone === undefined ? 'UTC' : timeZone, this._calendar); }
toInstant(timeZone) { Temporal.PlainDateTime._requireThis(this, 'toInstant'); return new Temporal.Instant(Temporal.PlainDateTime._toEpochNanoseconds(this, timeZone === undefined ? 'UTC' : timeZone)); }
toString(options) { Temporal.PlainDateTime._requireThis(this, 'toString'); const opts = Temporal.Duration._toOptions(options); const date = this.toPlainDate().toString({ calendarName: 'never' }); const time = this.toPlainTime().toString(opts); const calendarName = Temporal.Duration._getStringOption(opts, 'calendarName', 'auto', [ 'auto', 'always', 'never', 'critical' ]);
let out = date + 'T' + time; if (calendarName === 'always') { out += '[u-ca=' + this._calendar + ']'; } else if (calendarName === 'critical') { out += '[!u-ca=' + this._calendar + ']'; } else if (calendarName === 'auto' && this._calendar !== 'iso8601') { out += '[u-ca=' + this._calendar + ']'; } return out; }
toJSON() { Temporal.PlainDateTime._requireThis(this, 'toJSON'); return this.toString(); }
toLocaleString() { Temporal.PlainDateTime._requireThis(this, 'toLocaleString'); return this.toString(); }
valueOf() { Temporal.PlainDateTime._requireThis(this, 'valueOf'); throw new TypeError('Do not use valueOf on Temporal.PlainDateTime'); } },
PlainYearMonth: class PlainYearMonth { constructor(year, month, calendar = undefined, referenceISODay = undefined) { Object.defineProperty(this, '_temporalBrand', { value: 'Temporal.PlainYearMonth', writable: false, enumerable: false, configurable: false }); this._year = year === undefined ? 0 : Temporal.Duration._toInteger(year, 'year'); this._month = month === undefined ? 1 : Temporal.Duration._toInteger(month, 'month'); this._calendar = Temporal.Duration._normalizeCalendarId(calendar, 'calendar'); this._referenceISODay = referenceISODay === undefined ? 1 : Temporal.Duration._toInteger(referenceISODay, 'referenceISODay'); if (this._month < 1 || this._month > 12) throw new RangeError('Invalid month'); if (this._referenceISODay < 1 || this._referenceISODay > 31) throw new RangeError('Invalid referenceISODay'); let dim = 31; if (this._month === 4 || this._month === 6 || this._month === 9 || this._month === 11) dim = 30; else if (this._month === 2) { dim = (this._year % 400 === 0 || (this._year % 4 === 0 && this._year % 100 !== 0)) ? 29 : 28; } let refDay = this._referenceISODay; if (refDay > dim) refDay = dim; Temporal.Duration._checkIsoDateRange(this._year, this._month, refDay); }
static _requireThis(value, label) { if (!value || typeof value !== 'object' || value._temporalBrand !== 'Temporal.PlainYearMonth') { throw new TypeError('Temporal.PlainYearMonth.prototype.' + label + ' called on incompatible receiver'); }
return value; }
static from(value, options) { const opts = Temporal.Duration._toOptions(options); Temporal.Duration._getStringOption(opts, 'overflow', 'constrain', [ 'constrain', 'reject' ]);
if (typeof value === 'string') { const sepT = value.indexOf('T'); const sepTLower = value.indexOf('t'); const sepSpace = value.indexOf(' '); let hasDateTimeSeparator = sepT >= 0; if (sepTLower >= 0 && (sepT < 0 || sepTLower < sepT)) hasDateTimeSeparator = true; if (sepSpace >= 0 && (sepT < 0 || sepSpace < sepT) && (sepTLower < 0 || sepSpace < sepTLower)) hasDateTimeSeparator = true; if (hasDateTimeSeparator) { const parsed = Temporal.PlainDateTime._parseISODateTimeString(value); return new Temporal.PlainYearMonth(parsed.date.year, parsed.date.month, parsed.calendar, parsed.date.day); }
const ann = Temporal.PlainDate._extractAnnotations(value); let txt = ann.bare; const t = txt.indexOf('T'); if (t >= 0) txt = txt.slice(0, t);
let i = 0; let sign = 1; if (txt.charCodeAt(i) === 43) i++; else if (txt.charCodeAt(i) === 45) { sign = -1; i++; } let year = 0; let yearDigits = 0; while (i < txt.length) { const d = Temporal.Duration._digit(txt, i); if (d < 0) break; year = year * 10 + d; yearDigits++; i++; } if (yearDigits < 4) throw new RangeError('Invalid PlainYearMonth string'); year *= sign; if (i >= txt.length || txt.charCodeAt(i) !== 45) throw new RangeError('Invalid PlainYearMonth string'); i++; if (i + 1 >= txt.length) throw new RangeError('Invalid PlainYearMonth string'); const month = Temporal.Duration._parseNDigits(txt, i, 2); if (month < 0) throw new RangeError('Invalid PlainYearMonth string'); i += 2; if (i === txt.length) return new Temporal.PlainYearMonth(year, month, ann.calendar, 1); if (txt.charCodeAt(i) !== 45) throw new RangeError('Invalid PlainYearMonth string'); i++; if (i + 1 >= txt.length) throw new RangeError('Invalid PlainYearMonth string'); const day = Temporal.Duration._parseNDigits(txt, i, 2); if (day < 0) throw new RangeError('Invalid PlainYearMonth string'); i += 2; if (i !== txt.length) throw new RangeError('Invalid PlainYearMonth string'); return new Temporal.PlainYearMonth(year, month, ann.calendar, day); }
if (value && typeof value === 'object') { if (value._temporalBrand === 'Temporal.PlainYearMonth') { return new Temporal.PlainYearMonth(value._year, value._month, value._calendar, value._referenceISODay); }
if (value.year !== undefined && value.month !== undefined) { return new Temporal.PlainYearMonth(value.year, value.month, value.calendar, value.day === undefined ? value.referenceISODay : value.day); } }
throw new TypeError('Cannot convert value to Temporal.PlainYearMonth'); }
static compare(a, b) { const aa = Temporal.PlainYearMonth.from(a); const bb = Temporal.PlainYearMonth.from(b); if (aa._year !== bb._year) return aa._year < bb._year ? -1 : 1; if (aa._month !== bb._month) return aa._month < bb._month ? -1 : 1; if (aa._referenceISODay !== bb._referenceISODay) return aa._referenceISODay < bb._referenceISODay ? -1 : 1; return 0; }
get year() { return Temporal.PlainYearMonth._requireThis(this, 'year')._year; } get month() { return Temporal.PlainYearMonth._requireThis(this, 'month')._month; } get monthCode() { return 'M' + Temporal.Duration._pad(this.month, 2); } get calendarId() { return Temporal.PlainYearMonth._requireThis(this, 'calendarId')._calendar; } get daysInMonth() { return Temporal.PlainDate._daysInMonth(this.year, this.month); } get daysInYear() { return Temporal.PlainDate._isLeapYear(this.year) ? 366 : 365; } get monthsInYear() { return 12; } get inLeapYear() { return Temporal.PlainDate._isLeapYear(this.year); } get era() { return this.year <= 0 ? 'bce' : 'ce'; } get eraYear() { return this.year <= 0 ? 1 - this.year : this.year; }
with(item, options) { const ym = Temporal.PlainYearMonth._requireThis(this, 'with'); if (!item || typeof item !== 'object') throw new TypeError('Temporal.PlainYearMonth.with requires an object'); const opts = Temporal.Duration._toOptions(options); Temporal.Duration._getStringOption(opts, 'overflow', 'constrain', [ 'constrain', 'reject' ]);
return new Temporal.PlainYearMonth( item.year === undefined ? ym._year : item.year, item.month === undefined ? ym._month : item.month, item.calendar === undefined ? ym._calendar : item.calendar, item.referenceISODay === undefined ? ym._referenceISODay : item.referenceISODay ); }
withCalendar(calendar) { Temporal.PlainYearMonth._requireThis(this, 'withCalendar'); return new Temporal.PlainYearMonth(this._year, this._month, calendar, this._referenceISODay); }
add(durationLike, options) { Temporal.PlainYearMonth._requireThis(this, 'add'); const opts = Temporal.Duration._toOptions(options); Temporal.Duration._getStringOption(opts, 'overflow', 'constrain', [ 'constrain', 'reject' ]); const d = Temporal.Duration.from(durationLike);
let year = this._year + d.years; let month = this._month + d.months; while (month > 12) { month -= 12; year++; } while (month < 1) { month += 12; year--; }
return new Temporal.PlainYearMonth(year, month, this._calendar, this._referenceISODay); }
subtract(durationLike, options) { Temporal.PlainYearMonth._requireThis(this, 'subtract'); return this.add(Temporal.Duration.from(durationLike).negated(), options); }
since(other, options = undefined) { Temporal.PlainYearMonth._requireThis(this, 'since'); const rhs = Temporal.PlainYearMonth.from(other); const opts = Temporal.Duration._toOptions(options); const settings = Temporal.Duration._differenceSettings( opts, 'month', [ 'year', 'month' ], 'year', [ 'auto', 'year', 'month' ], 'trunc' ); let months = (this._year - rhs._year) * 12 + (this._month - rhs._month); if (settings.smallestUnit === 'year') { const yearsRounded = Temporal.Duration._roundToIncrement(months / 12, settings.roundingIncrement, settings.roundingMode); months = yearsRounded * 12; } else { months = Temporal.Duration._roundToIncrement(months, settings.roundingIncrement, settings.roundingMode); }
if (settings.largestUnit === 'year') { const years = months < 0 ? Math.ceil(months / 12) : Math.floor(months / 12); return new Temporal.Duration(years, months - years * 12, 0, 0, 0, 0, 0, 0, 0, 0); }
return new Temporal.Duration(0, months, 0, 0, 0, 0, 0, 0, 0, 0); }
until(other, options) { Temporal.PlainYearMonth._requireThis(this, 'until'); return Temporal.PlainYearMonth.from(other).since(this, options); }
equals(other) { Temporal.PlainYearMonth._requireThis(this, 'equals'); const rhs = Temporal.PlainYearMonth.from(other); return this._year === rhs._year && this._month === rhs._month && this._calendar === rhs._calendar && this._referenceISODay === rhs._referenceISODay; }
toPlainDate(item) { Temporal.PlainYearMonth._requireThis(this, 'toPlainDate'); if (!item || typeof item !== 'object') throw new TypeError('Temporal.PlainYearMonth.toPlainDate requires an object'); const day = item.day === undefined ? this._referenceISODay : item.day; return new Temporal.PlainDate(this._year, this._month, day, this._calendar); }
toString(options) { Temporal.PlainYearMonth._requireThis(this, 'toString'); const opts = Temporal.Duration._toOptions(options); const calendarName = Temporal.Duration._getStringOption(opts, 'calendarName', 'auto', [ 'auto', 'always', 'never', 'critical' ]);
const y = Temporal.Duration._formatIsoYear(this._year); const m = Temporal.Duration._pad(this._month, 2); let out = y + '-' + m; if (calendarName === 'always') { out += '[u-ca=' + this._calendar + ']'; } else if (calendarName === 'critical') { out += '[!u-ca=' + this._calendar + ']'; } else if (calendarName === 'auto' && this._calendar !== 'iso8601') { out += '[u-ca=' + this._calendar + ']'; } return out; }
toJSON() { Temporal.PlainYearMonth._requireThis(this, 'toJSON'); return this.toString(); }
toLocaleString() { Temporal.PlainYearMonth._requireThis(this, 'toLocaleString'); return this.toString(); }
valueOf() { Temporal.PlainYearMonth._requireThis(this, 'valueOf'); throw new TypeError('Do not use valueOf on Temporal.PlainYearMonth'); } },
PlainMonthDay: class PlainMonthDay { constructor(month, day, calendar = undefined, referenceISOYear = undefined) { Object.defineProperty(this, '_temporalBrand', { value: 'Temporal.PlainMonthDay', writable: false, enumerable: false, configurable: false }); this._month = Temporal.Duration._toInteger(month, 'month'); this._day = Temporal.Duration._toInteger(day, 'day'); this._calendar = Temporal.Duration._normalizeCalendarId(calendar, 'calendar'); this._referenceISOYear = Temporal.Duration._toInteger(referenceISOYear === undefined ? 1972 : referenceISOYear, 'referenceISOYear');
if (this._month < 1 || this._month > 12) throw new RangeError('Invalid month'); const dim = Temporal.PlainDate._daysInMonth(this._referenceISOYear, this._month); if (this._day < 1 || this._day > dim) throw new RangeError('Invalid day'); Temporal.Duration._checkIsoDateRange(this._referenceISOYear, this._month, this._day); }
static _requireThis(value, label) { if (!value || typeof value !== 'object' || value._temporalBrand !== 'Temporal.PlainMonthDay') { throw new TypeError('Temporal.PlainMonthDay.prototype.' + label + ' called on incompatible receiver'); }
return value; }
static from(value, options) { const opts = Temporal.Duration._toOptions(options); Temporal.Duration._getStringOption(opts, 'overflow', 'constrain', [ 'constrain', 'reject' ]);
if (typeof value === 'string') { const ann = Temporal.PlainDate._extractAnnotations(value); let txt = ann.bare; const t = txt.indexOf('T'); if (t >= 0) txt = txt.slice(0, t);
if (txt.length >= 10) { const d = Temporal.PlainDate._parseDatePart(txt); return new Temporal.PlainMonthDay(d.month, d.day, ann.calendar, d.year); }
if (txt.length === 7 && txt.charCodeAt(0) === 45 && txt.charCodeAt(1) === 45 && txt.charCodeAt(4) === 45) { const month = Temporal.Duration._parseNDigits(txt, 2, 2); const day = Temporal.Duration._parseNDigits(txt, 5, 2); if (month < 0 || day < 0) throw new RangeError('Invalid PlainMonthDay string'); return new Temporal.PlainMonthDay(month, day, ann.calendar, 1972); }
throw new RangeError('Invalid PlainMonthDay string'); }
if (value && typeof value === 'object') { if (value._temporalBrand === 'Temporal.PlainMonthDay') { return new Temporal.PlainMonthDay(value._month, value._day, value._calendar, value._referenceISOYear); }
if (value.month !== undefined && value.day !== undefined) { return new Temporal.PlainMonthDay(value.month, value.day, value.calendar, value.year === undefined ? value.referenceISOYear : value.year); }
if (value.monthCode !== undefined && value.day !== undefined) { const monthCode = String(value.monthCode); if (monthCode.length !== 3 || monthCode.charCodeAt(0) !== 77) throw new RangeError('Invalid monthCode'); const month = Temporal.Duration._parseNDigits(monthCode, 1, 2); if (month < 0) throw new RangeError('Invalid monthCode'); return new Temporal.PlainMonthDay(month, value.day, value.calendar, value.year === undefined ? value.referenceISOYear : value.year); } }
throw new TypeError('Cannot convert value to Temporal.PlainMonthDay'); }
static compare(a, b) { const aa = Temporal.PlainMonthDay.from(a); const bb = Temporal.PlainMonthDay.from(b); if (aa._month !== bb._month) return aa._month < bb._month ? -1 : 1; if (aa._day !== bb._day) return aa._day < bb._day ? -1 : 1; return 0; }
get monthCode() { return 'M' + Temporal.Duration._pad(Temporal.PlainMonthDay._requireThis(this, 'monthCode')._month, 2); } get day() { return Temporal.PlainMonthDay._requireThis(this, 'day')._day; } get month() { return Temporal.PlainMonthDay._requireThis(this, 'month')._month; } get calendarId() { return Temporal.PlainMonthDay._requireThis(this, 'calendarId')._calendar; }
with(item, options) { const md = Temporal.PlainMonthDay._requireThis(this, 'with'); if (!item || typeof item !== 'object') throw new TypeError('Temporal.PlainMonthDay.with requires an object'); const opts = Temporal.Duration._toOptions(options); Temporal.Duration._getStringOption(opts, 'overflow', 'constrain', [ 'constrain', 'reject' ]);
let month = md._month; if (item.month !== undefined) month = item.month; else if (item.monthCode !== undefined) { const code = String(item.monthCode); if (code.length !== 3 || code.charCodeAt(0) !== 77) throw new RangeError('Invalid monthCode'); month = Temporal.Duration._parseNDigits(code, 1, 2); if (month < 0) throw new RangeError('Invalid monthCode'); }
return new Temporal.PlainMonthDay( month, item.day === undefined ? md._day : item.day, item.calendar === undefined ? md._calendar : item.calendar, item.referenceISOYear === undefined ? md._referenceISOYear : item.referenceISOYear ); }
withCalendar(calendar) { Temporal.PlainMonthDay._requireThis(this, 'withCalendar'); return new Temporal.PlainMonthDay(this._month, this._day, calendar, this._referenceISOYear); }
equals(other) { Temporal.PlainMonthDay._requireThis(this, 'equals'); const rhs = Temporal.PlainMonthDay.from(other); return this._month === rhs._month && this._day === rhs._day && this._calendar === rhs._calendar; }
toPlainDate(item) { Temporal.PlainMonthDay._requireThis(this, 'toPlainDate'); if (!item || typeof item !== 'object') throw new TypeError('Temporal.PlainMonthDay.toPlainDate requires an object'); if (item.year === undefined) throw new TypeError('Temporal.PlainMonthDay.toPlainDate requires year'); return new Temporal.PlainDate(item.year, this._month, this._day, this._calendar); }
toString(options) { Temporal.PlainMonthDay._requireThis(this, 'toString'); const opts = Temporal.Duration._toOptions(options); const calendarName = Temporal.Duration._getStringOption(opts, 'calendarName', 'auto', [ 'auto', 'always', 'never', 'critical' ]);
let out = '--' + Temporal.Duration._pad(this._month, 2) + '-' + Temporal.Duration._pad(this._day, 2); if (calendarName === 'always') { out += '[u-ca=' + this._calendar + ']'; } else if (calendarName === 'critical') { out += '[!u-ca=' + this._calendar + ']'; } else if (calendarName === 'auto' && this._calendar !== 'iso8601') { out += '[u-ca=' + this._calendar + ']'; } return out; }
toJSON() { Temporal.PlainMonthDay._requireThis(this, 'toJSON'); return this.toString(); }
toLocaleString() { Temporal.PlainMonthDay._requireThis(this, 'toLocaleString'); return this.toString(); }
valueOf() { Temporal.PlainMonthDay._requireThis(this, 'valueOf'); throw new TypeError('Do not use valueOf on Temporal.PlainMonthDay'); } },
ZonedDateTime: class ZonedDateTime { constructor(epochNanoseconds, timeZone, calendar = undefined) { Object.defineProperty(this, '_temporalBrand', { value: 'Temporal.ZonedDateTime', writable: false, enumerable: false, configurable: false }); this._epochNanoseconds = Temporal.Duration._toInteger(epochNanoseconds, 'epochNanoseconds'); Temporal.Duration._checkEpochNanosecondsRange(this._epochNanoseconds); this._timeZone = Temporal.Duration._normalizeTimeZoneId(timeZone, 'timeZone'); this._calendar = Temporal.Duration._normalizeCalendarId(calendar, 'calendar'); }
static _requireThis(value, label) { if (!value || typeof value !== 'object' || value._temporalBrand !== 'Temporal.ZonedDateTime') { throw new TypeError('Temporal.ZonedDateTime.prototype.' + label + ' called on incompatible receiver'); }
return value; }
static _instantToPlainDateTime(epochNanoseconds, timeZone, calendar) { const offset = Temporal.PlainDateTime._timeZoneOffsetNanoseconds(timeZone); let local = epochNanoseconds + offset; let ms = local >= 0 ? Math.trunc(local / 1000000) : Math.floor(local / 1000000); let rem = local - ms * 1000000; if (rem < 0) rem += 1000000;
const microsecond = Math.trunc(rem / 1000); const nanosecond = rem - microsecond * 1000;
const date = new Date(ms); return new Temporal.PlainDateTime( date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds(), date.getUTCMilliseconds(), microsecond, nanosecond, calendar === undefined ? 'iso8601' : calendar ); }
static from(value, options) { const opts = Temporal.Duration._toOptions(options); Temporal.Duration._getStringOption(opts, 'disambiguation', 'compatible', [ 'compatible', 'earlier', 'later', 'reject' ]); const offsetOption = Temporal.Duration._getStringOption(opts, 'offset', 'reject', [ 'prefer', 'use', 'ignore', 'reject' ]); Temporal.Duration._getStringOption(opts, 'overflow', 'constrain', [ 'constrain', 'reject' ]);
if (typeof value === 'string') { const parts = Temporal.PlainDateTime._parseISODateTimeString(value); if (parts.time == null) throw new RangeError('Temporal.ZonedDateTime requires a date-time string');
const timeZone = Temporal.Duration._normalizeTimeZoneId(parts.timeZone === undefined ? 'UTC' : parts.timeZone, 'timeZone'); const ns = Temporal.PlainDateTime._partsToEpochNanoseconds(parts, offsetOption !== 'ignore'); if (offsetOption === 'reject' && parts.offsetNanoseconds != null && (timeZone.charCodeAt(0) === 43 || timeZone.charCodeAt(0) === 45)) { const zoneOffset = Temporal.Duration._offsetNanoseconds(timeZone, 'timeZone'); if (zoneOffset !== parts.offsetNanoseconds) throw new RangeError('Offset does not match time zone'); } return new Temporal.ZonedDateTime(ns, timeZone, parts.calendar); }
if (value && typeof value === 'object') { if (value._temporalBrand === 'Temporal.ZonedDateTime') { return new Temporal.ZonedDateTime(value._epochNanoseconds, value._timeZone, value._calendar); }
if (value.epochNanoseconds !== undefined) { return new Temporal.ZonedDateTime(value.epochNanoseconds, value.timeZone, value.calendar); }
if (value.year !== undefined && value.month !== undefined && value.day !== undefined) { const pdt = Temporal.PlainDateTime.from(value); const tz = Temporal.Duration._normalizeTimeZoneId(value.timeZone === undefined ? 'UTC' : value.timeZone, 'timeZone'); return pdt.toZonedDateTime(tz); } }
throw new TypeError('Cannot convert value to Temporal.ZonedDateTime'); }
static compare(a, b) { const aa = Temporal.ZonedDateTime.from(a); const bb = Temporal.ZonedDateTime.from(b); if (aa._epochNanoseconds < bb._epochNanoseconds) return -1; if (aa._epochNanoseconds > bb._epochNanoseconds) return 1; return 0; }
get epochNanoseconds() { return Temporal.ZonedDateTime._requireThis(this, 'epochNanoseconds')._epochNanoseconds; } get epochMilliseconds() { return Math.trunc(Temporal.ZonedDateTime._requireThis(this, 'epochMilliseconds')._epochNanoseconds / 1000000); } get timeZoneId() { return Temporal.ZonedDateTime._requireThis(this, 'timeZoneId')._timeZone; } get calendarId() { return Temporal.ZonedDateTime._requireThis(this, 'calendarId')._calendar; }
get year() { return this.toPlainDateTime().year; } get month() { return this.toPlainDateTime().month; } get day() { return this.toPlainDateTime().day; } get hour() { return this.toPlainDateTime().hour; } get minute() { return this.toPlainDateTime().minute; } get second() { return this.toPlainDateTime().second; } get millisecond() { return this.toPlainDateTime().millisecond; } get microsecond() { return this.toPlainDateTime().microsecond; } get nanosecond() { return this.toPlainDateTime().nanosecond; } get monthCode() { return this.toPlainDateTime().monthCode; } get dayOfWeek() { return this.toPlainDateTime().dayOfWeek; } get dayOfYear() { return this.toPlainDateTime().dayOfYear; } get weekOfYear() { return this.toPlainDateTime().weekOfYear; } get yearOfWeek() { return this.toPlainDateTime().yearOfWeek; } get daysInWeek() { return this.toPlainDateTime().daysInWeek; } get daysInMonth() { return this.toPlainDateTime().daysInMonth; } get daysInYear() { return this.toPlainDateTime().daysInYear; } get monthsInYear() { return this.toPlainDateTime().monthsInYear; } get inLeapYear() { return this.toPlainDateTime().inLeapYear; } get offsetNanoseconds() { return Temporal.PlainDateTime._timeZoneOffsetNanoseconds(this._timeZone); } get offset() { return Temporal.Duration._formatOffsetNanoseconds(this.offsetNanoseconds); }
with(item, options) { const zdt = Temporal.ZonedDateTime._requireThis(this, 'with'); if (!item || typeof item !== 'object') throw new TypeError('Temporal.ZonedDateTime.with requires an object');
const opts = Temporal.Duration._toOptions(options); Temporal.Duration._getStringOption(opts, 'overflow', 'constrain', [ 'constrain', 'reject' ]); Temporal.Duration._getStringOption(opts, 'disambiguation', 'compatible', [ 'compatible', 'earlier', 'later', 'reject' ]); Temporal.Duration._getStringOption(opts, 'offset', 'prefer', [ 'prefer', 'use', 'ignore', 'reject' ]);
const pdt = zdt.toPlainDateTime().with(item, options); return pdt.toZonedDateTime(item.timeZone === undefined ? zdt._timeZone : item.timeZone).withCalendar(item.calendar === undefined ? zdt._calendar : item.calendar); }
withCalendar(calendar) { Temporal.ZonedDateTime._requireThis(this, 'withCalendar'); return new Temporal.ZonedDateTime(this._epochNanoseconds, this._timeZone, calendar); }
withTimeZone(timeZone) { Temporal.ZonedDateTime._requireThis(this, 'withTimeZone'); return new Temporal.ZonedDateTime(this._epochNanoseconds, timeZone, this._calendar); }
add(durationLike, options) { Temporal.ZonedDateTime._requireThis(this, 'add'); const opts = Temporal.Duration._toOptions(options); Temporal.Duration._getStringOption(opts, 'overflow', 'constrain', [ 'constrain', 'reject' ]); Temporal.Duration._getStringOption(opts, 'disambiguation', 'compatible', [ 'compatible', 'earlier', 'later', 'reject' ]); Temporal.Duration._getStringOption(opts, 'offset', 'prefer', [ 'prefer', 'use', 'ignore', 'reject' ]);
const d = Temporal.Duration.from(durationLike); if (d.years || d.months || d.weeks || d.days) { const pdt = this.toPlainDateTime().add(d, options); return pdt.toZonedDateTime(this._timeZone).withCalendar(this._calendar); }
return new Temporal.ZonedDateTime(this._epochNanoseconds + Temporal.Duration._totalNanoseconds(d), this._timeZone, this._calendar); }
subtract(durationLike, options) { Temporal.ZonedDateTime._requireThis(this, 'subtract'); return this.add(Temporal.Duration.from(durationLike).negated(), options); }
since(other, options = undefined) { Temporal.ZonedDateTime._requireThis(this, 'since'); const rhs = Temporal.ZonedDateTime.from(other); const opts = Temporal.Duration._toOptions(options); const settings = Temporal.Duration._differenceSettings( opts, 'nanosecond', [ 'day', 'hour', 'minute', 'second', 'millisecond', 'microsecond', 'nanosecond' ], 'day', [ 'auto', 'day', 'hour', 'minute', 'second', 'millisecond', 'microsecond', 'nanosecond' ], 'trunc' ); Temporal.Duration._validateTimeRoundingIncrement(settings.smallestUnit, settings.roundingIncrement); const total = this._epochNanoseconds - rhs._epochNanoseconds; const rounded = Temporal.Duration._roundNanoseconds(total, settings.smallestUnit, settings.roundingIncrement, settings.roundingMode); return Temporal.Duration._balanceNanoseconds(rounded, settings.largestUnit); }
until(other, options) { Temporal.ZonedDateTime._requireThis(this, 'until'); return Temporal.ZonedDateTime.from(other).since(this, options); }
round(options) { Temporal.ZonedDateTime._requireThis(this, 'round'); if (options === undefined) throw new TypeError('options is required'); const opts = typeof options === 'string' ? { smallestUnit: options } : Temporal.Duration._toOptions(options); if (opts.smallestUnit === undefined) throw new RangeError('smallestUnit is required'); const smallestUnit = Temporal.Duration._getUnitOption(opts, 'smallestUnit', undefined, [ 'day', 'hour', 'minute', 'second', 'millisecond', 'microsecond', 'nanosecond' ]); const increment = Temporal.Duration._getNumberOption(opts, 'roundingIncrement', 1); const mode = Temporal.Duration._normalizeRoundingMode(opts.roundingMode, 'halfExpand'); if (increment <= 0) throw new RangeError('roundingIncrement must be positive'); return new Temporal.ZonedDateTime(Temporal.Duration._roundNanoseconds(this._epochNanoseconds, smallestUnit, increment, mode), this._timeZone, this._calendar); }
equals(other) { Temporal.ZonedDateTime._requireThis(this, 'equals'); const rhs = Temporal.ZonedDateTime.from(other); return this._epochNanoseconds === rhs._epochNanoseconds && this._timeZone === rhs._timeZone && this._calendar === rhs._calendar; }
toInstant() { Temporal.ZonedDateTime._requireThis(this, 'toInstant'); return new Temporal.Instant(this._epochNanoseconds); }
toPlainDateTime() { Temporal.ZonedDateTime._requireThis(this, 'toPlainDateTime'); return Temporal.ZonedDateTime._instantToPlainDateTime(this._epochNanoseconds, this._timeZone, this._calendar); }
toPlainDate() { Temporal.ZonedDateTime._requireThis(this, 'toPlainDate'); return this.toPlainDateTime().toPlainDate(); }
toPlainTime() { Temporal.ZonedDateTime._requireThis(this, 'toPlainTime'); return this.toPlainDateTime().toPlainTime(); }
startOfDay() { Temporal.ZonedDateTime._requireThis(this, 'startOfDay'); return this.toPlainDate().toZonedDateTime({ timeZone: this._timeZone, plainTime: new Temporal.PlainTime(0, 0, 0, 0, 0, 0) }); }
toString(options) { Temporal.ZonedDateTime._requireThis(this, 'toString'); const opts = Temporal.Duration._toOptions(options); const calendarName = Temporal.Duration._getStringOption(opts, 'calendarName', 'auto', [ 'auto', 'always', 'never', 'critical' ]); const showOffset = Temporal.Duration._getStringOption(opts, 'offset', 'auto', [ 'auto', 'always', 'never' ]); const showTimeZone = Temporal.Duration._getStringOption(opts, 'timeZoneName', 'auto', [ 'auto', 'never', 'critical' ]);
let out = this.toPlainDateTime().toString({ smallestUnit: opts.smallestUnit, fractionalSecondDigits: opts.fractionalSecondDigits, roundingMode: opts.roundingMode, roundingIncrement: opts.roundingIncrement, calendarName: 'never' }); if (showOffset !== 'never') out += this.offset; if (showTimeZone !== 'never') { if (showTimeZone === 'critical') out += '[!' + this._timeZone + ']'; else out += '[' + this._timeZone + ']'; } if (calendarName === 'always') { out += '[u-ca=' + this._calendar + ']'; } else if (calendarName === 'critical') { out += '[!u-ca=' + this._calendar + ']'; } else if (calendarName === 'auto' && this._calendar !== 'iso8601') { out += '[u-ca=' + this._calendar + ']'; } return out; }
toJSON() { Temporal.ZonedDateTime._requireThis(this, 'toJSON'); return this.toString(); }
toLocaleString() { Temporal.ZonedDateTime._requireThis(this, 'toLocaleString'); return this.toString(); }
valueOf() { Temporal.ZonedDateTime._requireThis(this, 'valueOf'); throw new TypeError('Do not use valueOf on Temporal.ZonedDateTime'); } },
Now: { instant() { return Temporal.Instant.fromEpochMilliseconds(Date.now()); },
plainDateISO(timeZone = undefined) { const tz = Temporal.Duration._normalizeTimeZoneId(timeZone === undefined ? 'UTC' : timeZone, 'timeZone'); const instant = Temporal.Now.instant(); return Temporal.ZonedDateTime._instantToPlainDateTime(instant.epochNanoseconds, tz, 'iso8601').toPlainDate(); },
plainTimeISO(timeZone = undefined) { const tz = Temporal.Duration._normalizeTimeZoneId(timeZone === undefined ? 'UTC' : timeZone, 'timeZone'); const instant = Temporal.Now.instant(); return Temporal.ZonedDateTime._instantToPlainDateTime(instant.epochNanoseconds, tz, 'iso8601').toPlainTime(); },
plainDateTimeISO(timeZone = undefined) { const tz = Temporal.Duration._normalizeTimeZoneId(timeZone === undefined ? 'UTC' : timeZone, 'timeZone'); const instant = Temporal.Now.instant(); return Temporal.ZonedDateTime._instantToPlainDateTime(instant.epochNanoseconds, tz, 'iso8601'); },
zonedDateTimeISO(timeZone = undefined) { const tz = Temporal.Duration._normalizeTimeZoneId(timeZone === undefined ? 'UTC' : timeZone, 'timeZone'); return Temporal.Now.instant().toZonedDateTimeISO(tz); },
timeZoneId() { return 'UTC'; } }};`;