gemi 0.4.13 → 0.4.14

package/dist/email/index.js

@@ -4213,9 +4213,565 @@ var require_js = __commonJS((exports, module) => {
   }
 });
 
-// kernel/Kernel.ts
+// http/Controller.ts
+class Controller {
+  requests = {};
+  static kind = "controller";
+  constructor() {
+  }
+}
+
+class ResourceController extends Controller {
+  constructor() {
+    super(...arguments);
+  }
+}
+// internal/isConstructor.ts
+function isConstructor(value) {
+  return typeof value === "function" && value.prototype !== undefined;
+}
+
+// http/ApiRouter.ts
+var isController = function(candidate) {
+  return isConstructor(candidate);
+};
+
+class RouteHandler {
+  method;
+  handler;
+  methodName;
+  middlewares = [];
+  constructor(method, handler, methodName) {
+    this.method = method;
+    this.handler = handler;
+    this.methodName = methodName;
+    this.handler = handler;
+    this.methodName = methodName;
+    this.method = method;
+  }
+  run(req) {
+    let httpRequest = req;
+    if (isController(this.handler)) {
+      const controller = new this.handler;
+      const handler = controller[this.methodName].bind(controller);
+      httpRequest = controller.requests[this.methodName] ? new controller.requests[this.methodName](req.rawRequest, req.params) : httpRequest;
+      return handler(httpRequest);
+    } else {
+      return this.handler(req);
+    }
+  }
+  middleware(middlewareList) {
+    this.middlewares = middlewareList;
+    return this;
+  }
+}
+
+class ApiRouter {
+  routes = {};
+  middlewares = [];
+  middleware(_req) {
+  }
+  get(handler, methodName) {
+    return new RouteHandler("GET", handler, methodName);
+  }
+  post(handler, methodName) {
+    return new RouteHandler("POST", handler, methodName);
+  }
+  put(handler, methodName) {
+    return new RouteHandler("PUT", handler, methodName);
+  }
+  patch(handler, methodName) {
+    return new RouteHandler("PATCH", handler, methodName);
+  }
+  delete(handler, methodName) {
+    return new RouteHandler("DELETE", handler, methodName);
+  }
+  resource(Controller2) {
+
+    class ResourceRouter extends ApiRouter {
+      constructor() {
+        super(...arguments);
+      }
+      routes = {
+        "/": {
+          list: this.get(Controller2, "list"),
+          create: this.post(Controller2, "create")
+        },
+        "/:id": {
+          show: this.get(Controller2, "show"),
+          update: this.put(Controller2, "update"),
+          delete: this.delete(Controller2, "delete")
+        }
+      };
+    }
+    return ResourceRouter;
+  }
+}
+// http/ViewRouter.ts
+class ViewRouter {
+  routes = {};
+  middlewares = [];
+  middleware(req) {
+  }
+  layout(viewPath, handler, children) {
+    function prepare(middlewares = []) {
+      let _children = children ?? {};
+      if (handler && handler.constructor === Object) {
+        _children = handler;
+      }
+      return {
+        exec: async (req) => {
+          let _handler = () => Promise.resolve({
+            data: { [viewPath]: {} },
+            headers: {},
+            head: {}
+          });
+          if (typeof handler === "function") {
+            _handler = handler;
+          }
+          if (Array.isArray(handler)) {
+            const [controller, methodName] = handler;
+            const instance = new controller(app);
+            _handler = instance[methodName].bind(instance);
+          }
+          const data = await _handler(req);
+          return { [viewPath]: data };
+        },
+        children: _children,
+        viewPath,
+        middlewares,
+        kind: "layout"
+      };
+    }
+    return {
+      prepare,
+      middleware: (middlewares) => ({
+        prepare: () => prepare(middlewares)
+      })
+    };
+  }
+  view(viewPath, handler, children) {
+    function prepare(middlewares = []) {
+      let _children = children ?? {};
+      if (handler && handler.constructor === Object) {
+        _children = handler;
+      }
+      return {
+        exec: async (req) => {
+          let _handler = () => Promise.resolve({
+            data: { [viewPath]: {} },
+            headers: {},
+            head: {}
+          });
+          if (typeof handler === "function") {
+            _handler = handler;
+          }
+          if (Array.isArray(handler)) {
+            const [controller, methodName] = handler;
+            const instance = new controller(app);
+            _handler = instance[methodName].bind(instance);
+          }
+          const data = await _handler(req);
+          return { [viewPath]: data };
+        },
+        children: _children,
+        viewPath,
+        middlewares,
+        kind: "view"
+      };
+    }
+    return {
+      prepare,
+      middleware: (middlewares) => ({
+        prepare: () => prepare(middlewares)
+      })
+    };
+  }
+}
+// http/Error.ts
+var GEMI_REQUEST_BREAKER_ERROR = "GEMI_REQUEST_BREAKER_ERROR";
+
+class RequestBreakerError extends Error {
+  constructor() {
+    super(...arguments);
+  }
+  kind = GEMI_REQUEST_BREAKER_ERROR;
+  payload = { api: {}, view: {} };
+}
+
+// http/Router.ts
+class AuthenticationError extends RequestBreakerError {
+  constructor() {
+    super("Authentication error");
+    this.name = "AuthenticationError";
+  }
+  payload = {
+    api: {
+      status: 401,
+      data: { error: "Authentication error" }
+    },
+    view: {
+      status: 302,
+      headers: {
+        "Cache-Control": "private, no-cache, no-store, max-age=0, must-revalidate",
+        Location: "/auth/sign-in"
+      }
+    }
+  };
+}
+
+class ValidationError extends RequestBreakerError {
+  errors = {};
+  constructor(errors) {
+    super("Validation error");
+    this.name = "ValidationError";
+    this.errors = errors;
+    this.payload = {
+      api: {
+        status: 400,
+        data: {
+          error: {
+            kind: "validation_error",
+            messages: errors
+          }
+        },
+        headers: {
+          "Content-Type": "application/json"
+        }
+      },
+      view: {
+        status: 400
+      }
+    };
+  }
+}
+// http/requestContext.ts
 import {AsyncLocalStorage} from "async_hooks";
 
+// http/Cookie.ts
+class Cookie {
+  name;
+  value;
+  options;
+  constructor(name, value, options = {}) {
+    this.name = name;
+    this.value = value;
+    this.options = options;
+  }
+  toString() {
+    return [
+      `${this.name}=${this.value}`,
+      this.options.maxAge ? `Max-Age=${this.options.maxAge}` : "",
+      this.options.httpOnly ? "HttpOnly" : "",
+      this.options.secure ? "Secure" : "",
+      this.options.sameSite ? `SameSite=${this.options.sameSite}` : "SameSite=Strict",
+      this.options.path ? `Path=${this.options.path}` : "Path=/",
+      this.options.domain ? `Domain=${this.options.domain}` : "",
+      this.options.expires ? `Expires=${this.options.expires.toUTCString()}` : "",
+      this.options.partitioned ? "Partitioned" : ""
+    ].filter((i) => i !== "").join("; ");
+  }
+}
+
+// http/requestContext.ts
+var requestContext = new AsyncLocalStorage;
+
+class Store {
+  cookies = new Set;
+  user = null;
+  req = null;
+  constructor() {
+  }
+  setCookie(name, value, options = {}) {
+    this.cookies.add(new Cookie(name, value, options));
+  }
+  setUser(user) {
+    this.user = user;
+  }
+  setRequest(req) {
+    this.req = req;
+  }
+}
+
+class RequestContext {
+  static getStore() {
+    return requestContext.getStore();
+  }
+  static setRequest(req) {
+    requestContext.getStore().req = req;
+  }
+  static async run(fn) {
+    return requestContext.run(new Store, fn);
+  }
+}
+
+// http/HttpRequest.ts
+var validate = function(ruleName) {
+  const [rule, param] = ruleName.split(":");
+  switch (rule) {
+    case "required":
+      return (value) => {
+        return value !== null && value !== undefined && value?.length > 0;
+      };
+    case "password":
+      return (value) => {
+        const passwordRegex = /^(?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[^a-zA-Z0-9]).{8,}$/;
+        return passwordRegex.test(value);
+      };
+    case "number":
+      return (value) => {
+        if (typeof value !== "number")
+          return false;
+        return !isNaN(value);
+      };
+    case "min":
+      return (value) => {
+        return value?.length >= parseInt(param);
+      };
+    case "max":
+      return (value) => {
+        return value?.length <= parseInt(param);
+      };
+    case "email":
+      return (value) => {
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        return emailRegex.test(value);
+      };
+    default:
+      return () => true;
+  }
+};
+
+class Input {
+  data;
+  constructor(data) {
+    this.data = data;
+  }
+  get(key) {
+    return this.data[key];
+  }
+  set(key, value) {
+    this.data[key] = value;
+  }
+  has(key) {
+    return this.data[key] !== undefined;
+  }
+  toJSON() {
+    return this.data;
+  }
+}
+
+class HttpRequest {
+  rawRequest;
+  headers;
+  cookies;
+  schema = {};
+  params;
+  ctx = RequestContext.getStore();
+  constructor(req, params) {
+    this.params = params;
+    this.rawRequest = req;
+    this.headers = req.headers;
+    const cookie = this.rawRequest.headers.get("Cookie");
+    const cookies = new Map;
+    if (cookie) {
+      const cookieArray = cookie.split(";");
+      for (const c of cookieArray) {
+        const [key, value] = c.split("=");
+        cookies.set(key.trim(), value.trim());
+      }
+    }
+    this.cookies = cookies;
+  }
+  async parseBody() {
+    const inputMap = new Input({});
+    if (this.rawRequest.headers.get("Content-Type") === "application/json") {
+      const body = await this.rawRequest.json();
+      for (const [key, value] of Object.entries(body)) {
+        inputMap.set(key, value);
+      }
+    }
+    if (this.rawRequest.headers.get("Content-Type") === "application/x-www-form-urlencoded") {
+      const body = await this.rawRequest.formData();
+      for (const [key, value] of body) {
+        inputMap.set(key, value);
+      }
+    }
+    if (this.rawRequest.headers.get("Content-Type").startsWith("multipart/form-data")) {
+      const body = await this.rawRequest.formData();
+      for (const [key, value] of body) {
+        if (inputMap.has(key)) {
+          const currentValue = inputMap.get(key);
+          if (Array.isArray(currentValue)) {
+            currentValue.push(value);
+            inputMap.set(key, currentValue);
+          } else {
+            inputMap.set(key, [currentValue, value]);
+          }
+        } else {
+          inputMap.set(key, value);
+        }
+      }
+    }
+    return inputMap;
+  }
+  validateInput(input) {
+    const errors = {};
+    for (const [key, rules] of Object.entries(this.schema)) {
+      for (const [rule, message] of Object.entries(rules)) {
+        const validator = validate(rule);
+        if (!validator(input.get(key))) {
+          if (!errors[key]) {
+            errors[key] = [];
+          }
+          if (rule === "required") {
+            errors[key] = [String(message)];
+            break;
+          } else {
+            errors[key].push(String(message));
+          }
+        }
+      }
+    }
+    if (Object.keys(errors).length > 0) {
+      throw new ValidationError(errors);
+    } else {
+      return input;
+    }
+  }
+  async input() {
+    return this.validateInput(await this.parseBody());
+  }
+  async safeInput() {
+    const input = await this.parseBody();
+    try {
+      this.validateInput(input);
+      return {
+        isValid: true,
+        errors: {},
+        input
+      };
+    } catch (err) {
+      if (!(err instanceof ValidationError)) {
+        throw err;
+      }
+      return {
+        isValid: false,
+        errors: err.errors,
+        input
+      };
+    }
+  }
+  async terminate(params) {
+    throw "not implemented";
+  }
+}
+// http/Middleware.ts
+class Middleware {
+  async run(_req) {
+    return {};
+  }
+}
+// http/getCookies.ts
+function getCookies(req) {
+  const cookies = req.headers.get("cookie");
+  if (!cookies) {
+    return new Map;
+  }
+  const _cookies = new Map;
+  const cookieStrings = cookies.split(";");
+  for (const cookieString of cookieStrings) {
+    const [name, value] = cookieString.split("=");
+    _cookies.set(name.trim(), value);
+  }
+  return _cookies;
+}
+// http/MiddlewareServiceProvider.ts
+class MiddlewareServiceProvider {
+  aliases = {};
+}
+// kernel/context.ts
+import {AsyncLocalStorage as AsyncLocalStorage2} from "async_hooks";
+var kernelContext = new AsyncLocalStorage2;
+
+// kernel/KernelContext.ts
+class KernelContext {
+  static getStore = () => kernelContext.getStore();
+}
+
+// http/AuthenticationMiddlware.ts
+class AuthenticationMiddleware extends Middleware {
+  constructor() {
+    super(...arguments);
+  }
+  async run(req) {
+    const requestContextStore = RequestContext.getStore();
+    const accessToken = requestContextStore.req.cookies.get("access_token");
+    if (!accessToken) {
+      throw new AuthenticationError;
+    }
+    let user = requestContextStore.user;
+    if (!user) {
+      const session = await KernelContext.getStore().authenticationServiceProvider.adapter.findSession({
+        token: accessToken,
+        userAgent: requestContextStore.req.headers.get("User-Agent")
+      });
+      if (!session) {
+        throw new AuthenticationError;
+      }
+      user = session?.user;
+      requestContextStore.setUser(user);
+    }
+    return {};
+  }
+}
+// facades/Auth.ts
+class Auth {
+  static async user() {
+    const requestContextStore = RequestContext.getStore();
+    const accessToken = requestContextStore.req.cookies.get("access_token");
+    let user = requestContextStore.user;
+    if (!user) {
+      const adapter = KernelContext.getStore().authenticationServiceProvider.adapter;
+      const session = await adapter.findSession({
+        token: accessToken,
+        userAgent: requestContextStore.req.headers.get("User-Agent")
+      });
+      user = session?.user;
+      requestContextStore.setUser(user);
+    }
+    if (user) {
+      return user;
+    }
+    return null;
+  }
+}
+// facades/Redirect.ts
+class RedirectError extends RequestBreakerError {
+  constructor(path) {
+    super("Redirect error");
+    this.name = "RedirectError";
+    this.payload = {
+      api: {
+        status: 302,
+        data: { error: "Redirect error" }
+      },
+      view: {
+        status: 302,
+        headers: {
+          "Cache-Control": "private, no-cache, no-store, max-age=0, must-revalidate",
+          Location: path
+        }
+      }
+    };
+  }
+}
+
+class Redirect {
+  static to(path) {
+    throw new RedirectError(path);
+  }
+}
 // ../../node_modules/resend/node_modules/@react-email/render/dist/index.mjs
 import * as ReactDomServer from "react-dom/server";
 
@@ -9047,7 +9603,6 @@ var providers = {
     if (error) {
       throw error;
     }
-    console.log({ data });
     if (data) {
       return true;
     }
@@ -9063,16 +9618,4194 @@ class EmailServiceProvider {
   }
 }
 
-// kernel/Kernel.ts
-var context = new AsyncLocalStorage;
+// ../../node_modules/temporal-polyfill/chunks/classApi.js
+var createSlotClass = function(e3, t3, n3, o3, r3) {
+  function Class(...e4) {
+    if (!(this instanceof Class)) {
+      throw new TypeError(P);
+    }
+    oo(this, t3(...e4));
+  }
+  function bindMethod(e4, t4) {
+    return Object.defineProperties(function(...t5) {
+      return e4.call(this, getSpecificSlots(this), ...t5);
+    }, D(t4));
+  }
+  function getSpecificSlots(t4) {
+    const n4 = no(t4);
+    if (!n4 || n4.branding !== e3) {
+      throw new TypeError(P);
+    }
+    return n4;
+  }
+  return Object.defineProperties(Class.prototype, {
+    ...O(T(bindMethod, n3)),
+    ...p(T(bindMethod, o3)),
+    ...h("Temporal." + e3)
+  }), Object.defineProperties(Class, {
+    ...p(r3),
+    ...D(e3)
+  }), [Class, (e4) => {
+    const t4 = Object.create(Class.prototype);
+    return oo(t4, e4), t4;
+  }, getSpecificSlots];
+};
+var createProtocolValidator = function(e3) {
+  return e3 = e3.concat("id").sort(), (t3) => {
+    if (!C(t3, e3)) {
+      throw new TypeError(g);
+    }
+    return t3;
+  };
+};
+var rejectInvalidBag = function(e3) {
+  if (no(e3) || e3.calendar !== undefined || e3.timeZone !== undefined) {
+    throw new TypeError(Z);
+  }
+  return e3;
+};
+var createCalendarFieldMethods = function(e3, t3) {
+  const n3 = {};
+  for (const o3 in e3) {
+    n3[o3] = ({ o: e4 }, n4) => {
+      const r3 = no(n4) || {}, { branding: a2 } = r3, i2 = a2 === J || t3.includes(a2) ? r3 : toPlainDateSlots(n4);
+      return e4[o3](i2);
+    };
+  }
+  return n3;
+};
+var createCalendarGetters = function(e3) {
+  const t3 = {};
+  for (const n3 in e3) {
+    t3[n3] = (e4) => {
+      const { calendar: t4 } = e4;
+      return (o3 = t4, typeof o3 == "string" ? Y(o3) : (r3 = o3, Object.assign(Object.create(co), {
+        i: r3
+      })))[n3](e4);
+      var o3, r3;
+    };
+  }
+  return t3;
+};
+var neverValueOf = function() {
+  throw new TypeError(A);
+};
+var createCalendarFromSlots = function({ calendar: e3 }) {
+  return typeof e3 == "string" ? new lr(e3) : e3;
+};
+var toPlainMonthDaySlots = function(e3, t3) {
+  if (t3 = U(t3), z(e3)) {
+    const n4 = no(e3);
+    if (n4 && n4.branding === q) {
+      return H(t3), n4;
+    }
+    const o3 = extractCalendarSlotFromBag(e3);
+    return K(Qo(o3 || X), !o3, e3, t3);
+  }
+  const n3 = Q(Y, e3);
+  return H(t3), n3;
+};
+var getOffsetNanosecondsForAdapter = function(e3, t3, n3) {
+  return o3 = t3.call(e3, Co(_(n3))), ae(u(o3));
+  var o3;
+};
+var createAdapterOps = function(e3, t3 = ho) {
+  const n3 = Object.keys(t3).sort(), o3 = {};
+  for (const r3 of n3) {
+    o3[r3] = E(t3[r3], e3, $(e3[r3]));
+  }
+  return o3;
+};
+var createTimeZoneOps = function(e3, t3) {
+  return typeof e3 == "string" ? ie(e3) : createAdapterOps(e3, t3);
+};
+var createTimeZoneOffsetOps = function(e3) {
+  return createTimeZoneOps(e3, Do);
+};
+var toInstantSlots = function(e3) {
+  if (z(e3)) {
+    const t3 = no(e3);
+    if (t3) {
+      switch (t3.branding) {
+        case Oe:
+          return t3;
+        case Te:
+          return _(t3.epochNanoseconds);
+      }
+    }
+  }
+  return pe(e3);
+};
+var getImplTransition = function(e3, t3, n3) {
+  const o3 = t3.l(toInstantSlots(n3).epochNanoseconds, e3);
+  return o3 ? Co(_(o3)) : null;
+};
+var refineTimeZoneSlot = function(e3) {
+  return z(e3) ? (no(e3) || {}).timeZone || Fo(e3) : ((e4) => ye(Ne(m(e4))))(e3);
+};
+var toPlainTimeSlots = function(e3, t3) {
+  if (z(e3)) {
+    const n3 = no(e3) || {};
+    switch (n3.branding) {
+      case xe:
+        return H(t3), n3;
+      case We:
+        return H(t3), Ge(n3);
+      case Te:
+        return H(t3), Re(createTimeZoneOffsetOps, n3);
+    }
+    return Ue(e3, t3);
+  }
+  return H(t3), ze(e3);
+};
+var optionalToPlainTimeFields = function(e3) {
+  return e3 === undefined ? undefined : toPlainTimeSlots(e3);
+};
+var toPlainYearMonthSlots = function(e3, t3) {
+  if (t3 = U(t3), z(e3)) {
+    const n4 = no(e3);
+    return n4 && n4.branding === L ? (H(t3), n4) : nt(Ho(getCalendarSlotFromBag(e3)), e3, t3);
+  }
+  const n3 = ot(Y, e3);
+  return H(t3), n3;
+};
+var toPlainDateTimeSlots = function(e3, t3) {
+  if (t3 = U(t3), z(e3)) {
+    const n4 = no(e3) || {};
+    switch (n4.branding) {
+      case We:
+        return H(t3), n4;
+      case J:
+        return H(t3), ee({
+          ...n4,
+          ...Dt
+        });
+      case Te:
+        return H(t3), ht(createTimeZoneOffsetOps, n4);
+    }
+    return Pt(Ko(getCalendarSlotFromBag(e3)), e3, t3);
+  }
+  const n3 = Ct(e3);
+  return H(t3), n3;
+};
+var toPlainDateSlots = function(e3, t3) {
+  if (t3 = U(t3), z(e3)) {
+    const n4 = no(e3) || {};
+    switch (n4.branding) {
+      case J:
+        return H(t3), n4;
+      case We:
+        return H(t3), v(n4);
+      case Te:
+        return H(t3), Bt(createTimeZoneOffsetOps, n4);
+    }
+    return Yt(Ko(getCalendarSlotFromBag(e3)), e3, t3);
+  }
+  const n3 = At(e3);
+  return H(t3), n3;
+};
+var dayAdapter = function(e3, t3, n3) {
+  return d(t3.call(e3, Yo(v(n3, e3))));
+};
+var createCompoundOpsCreator = function(e3) {
+  return (t3) => typeof t3 == "string" ? Y(t3) : ((e4, t4) => {
+    const n3 = Object.keys(t4).sort(), o3 = {};
+    for (const r3 of n3) {
+      o3[r3] = E(t4[r3], e4, e4[r3]);
+    }
+    return o3;
+  })(t3, e3);
+};
+var toDurationSlots = function(e3) {
+  if (z(e3)) {
+    const t3 = no(e3);
+    return t3 && t3.branding === qt ? t3 : Ht(e3);
+  }
+  return Kt(e3);
+};
+var refinePublicRelativeTo = function(e3) {
+  if (e3 !== undefined) {
+    if (z(e3)) {
+      const t3 = no(e3) || {};
+      switch (t3.branding) {
+        case Te:
+        case J:
+          return t3;
+        case We:
+          return v(t3);
+      }
+      const n3 = getCalendarSlotFromBag(e3);
+      return {
+        ...Qt(refineTimeZoneSlot, createTimeZoneOps, Ko(n3), e3),
+        calendar: n3
+      };
+    }
+    return Xt(e3);
+  }
+};
+var getCalendarSlotFromBag = function(e3) {
+  return extractCalendarSlotFromBag(e3) || X;
+};
+var extractCalendarSlotFromBag = function(e3) {
+  const { calendar: t3 } = e3;
+  if (t3 !== undefined) {
+    return refineCalendarSlot(t3);
+  }
+};
+var refineCalendarSlot = function(e3) {
+  return z(e3) ? (no(e3) || {}).calendar || cr(e3) : ((e4) => an(sn(m(e4))))(e3);
+};
+var toZonedDateTimeSlots = function(e3, t3) {
+  if (t3 = U(t3), z(e3)) {
+    const n3 = no(e3);
+    if (n3 && n3.branding === Te) {
+      return wn(t3), n3;
+    }
+    const o3 = getCalendarSlotFromBag(e3);
+    return jn(refineTimeZoneSlot, createTimeZoneOps, Ko(o3), o3, e3, t3);
+  }
+  return Mn(e3, t3);
+};
+var adaptDateMethods = function(e3) {
+  return T((e4) => (t3) => e4(slotsToIso(t3)), e3);
+};
+var slotsToIso = function(e3) {
+  return fn(e3, createTimeZoneOffsetOps);
+};
+var createDateTimeFormatClass = function() {
+  const e3 = En.prototype, t3 = Object.getOwnPropertyDescriptors(e3), n3 = Object.getOwnPropertyDescriptors(En), DateTimeFormat = function(e4, t4 = {}) {
+    if (!(this instanceof DateTimeFormat)) {
+      return new DateTimeFormat(e4, t4);
+    }
+    Or.set(this, ((e5, t5 = {}) => {
+      const n4 = new En(e5, t5), o3 = n4.resolvedOptions(), r3 = o3.locale, a2 = Vn(Object.keys(t5), o3), i2 = Jn(createFormatPrepperForBranding), prepFormat = (...e6) => {
+        let t6;
+        const o4 = e6.map((e7, n5) => {
+          const o5 = no(e7), r4 = (o5 || {}).branding;
+          if (n5 && t6 && t6 !== r4) {
+            throw new TypeError(kn);
+          }
+          return t6 = r4, o5;
+        });
+        return t6 ? i2(t6)(r3, a2, ...o4) : [n4, ...e6];
+      };
+      return prepFormat.u = n4, prepFormat;
+    })(e4, t4));
+  };
+  for (const e4 in t3) {
+    const n4 = t3[e4], o3 = e4.startsWith("format") && createFormatMethod(e4);
+    typeof n4.value == "function" ? n4.value = e4 === "constructor" ? DateTimeFormat : o3 || createProxiedMethod(e4) : o3 && (n4.get = function() {
+      return o3.bind(this);
+    });
+  }
+  return n3.prototype.value = Object.create(e3, t3), Object.defineProperties(DateTimeFormat, n3), DateTimeFormat;
+};
+var createFormatMethod = function(e3) {
+  return function(...t3) {
+    const n3 = Or.get(this), [o3, ...r3] = n3(...t3);
+    return o3[e3](...r3);
+  };
+};
+var createProxiedMethod = function(e3) {
+  return function(...t3) {
+    return Or.get(this).u[e3](...t3);
+  };
+};
+var createFormatPrepperForBranding = function(t3) {
+  const n3 = xn[t3];
+  if (!n3) {
+    throw new TypeError(Ln(t3));
+  }
+  return e2(n3, Jn(qn));
+};
 
-class Kernel {
-  emailServiceProvider = EmailServiceProvider;
-  static getContext = () => context.getStore();
+// ../../node_modules/temporal-polyfill/chunks/internal.js
+var clampProp = function(e2, n2, t2, o2, r2) {
+  return clampEntity(n2, getDefinedProp(e2, n2), t2, o2, r2);
+};
+var clampEntity = function(e2, n2, t2, o2, r2, i) {
+  const a = clampNumber(n2, t2, o2);
+  if (r2 && n2 !== a) {
+    throw new RangeError(numberOutOfRange(e2, n2, t2, o2, i));
+  }
+  return a;
+};
+var getDefinedProp = function(e2, n2) {
+  const t2 = e2[n2];
+  if (t2 === undefined) {
+    throw new TypeError(missingField(n2));
+  }
+  return t2;
+};
+var z = function(e2) {
+  return e2 !== null && /object|function/.test(typeof e2);
+};
+var Jn = function(e2, n2 = Map) {
+  const t2 = new n2;
+  return (n3, ...o2) => {
+    if (t2.has(n3)) {
+      return t2.get(n3);
+    }
+    const r2 = e2(n3, ...o2);
+    return t2.set(n3, r2), r2;
+  };
+};
+var D = function(e2) {
+  return p({
+    name: e2
+  }, 1);
+};
+var p = function(e2, n2) {
+  return T((e3) => ({
+    value: e3,
+    configurable: 1,
+    writable: !n2
+  }), e2);
+};
+var O = function(e2) {
+  return T((e3) => ({
+    get: e3,
+    configurable: 1
+  }), e2);
+};
+var h = function(e2) {
+  return {
+    [Symbol.toStringTag]: {
+      value: e2,
+      configurable: 1
+    }
+  };
+};
+var zipProps = function(e2, n2) {
+  const t2 = {};
+  let o2 = e2.length;
+  for (const r2 of n2) {
+    t2[e2[--o2]] = r2;
+  }
+  return t2;
+};
+var T = function(e2, n2, t2) {
+  const o2 = {};
+  for (const r2 in n2) {
+    o2[r2] = e2(n2[r2], r2, t2);
+  }
+  return o2;
+};
+var b = function(e2, n2, t2) {
+  const o2 = {};
+  for (let r2 = 0;r2 < n2.length; r2++) {
+    const i = n2[r2];
+    o2[i] = e2(i, r2, t2);
+  }
+  return o2;
+};
+var remapProps = function(e2, n2, t2) {
+  const o2 = {};
+  for (let r2 = 0;r2 < e2.length; r2++) {
+    o2[n2[r2]] = t2[e2[r2]];
+  }
+  return o2;
+};
+var Vn = function(e2, n2) {
+  const t2 = {};
+  for (const o2 of e2) {
+    t2[o2] = n2[o2];
+  }
+  return t2;
+};
+var V2 = function(e2, n2) {
+  const t2 = {};
+  for (const o2 in n2) {
+    e2.has(o2) || (t2[o2] = n2[o2]);
+  }
+  return t2;
+};
+var nn = function(e2) {
+  e2 = {
+    ...e2
+  };
+  const n2 = Object.keys(e2);
+  for (const t2 of n2) {
+    e2[t2] === undefined && delete e2[t2];
+  }
+  return e2;
+};
+var C = function(e2, n2) {
+  for (const t2 of n2) {
+    if (!(t2 in e2)) {
+      return 0;
+    }
+  }
+  return 1;
+};
+var allPropsEqual = function(e2, n2, t2) {
+  for (const o2 of e2) {
+    if (n2[o2] !== t2[o2]) {
+      return 0;
+    }
+  }
+  return 1;
+};
+var zeroOutProps = function(e2, n2, t2) {
+  const o2 = {
+    ...t2
+  };
+  for (let t3 = 0;t3 < n2; t3++) {
+    o2[e2[t3]] = 0;
+  }
+  return o2;
+};
+var E = function(e2, ...n2) {
+  return (...t2) => e2(...n2, ...t2);
+};
+var capitalize = function(e2) {
+  return e2[0].toUpperCase() + e2.substring(1);
+};
+var sortStrings = function(e2) {
+  return e2.slice().sort();
+};
+var padNumber = function(e2, n2) {
+  return String(n2).padStart(e2, "0");
+};
+var compareNumbers = function(e2, n2) {
+  return Math.sign(e2 - n2);
+};
+var clampNumber = function(e2, n2, t2) {
+  return Math.min(Math.max(e2, n2), t2);
+};
+var divModFloor = function(e2, n2) {
+  return [Math.floor(e2 / n2), modFloor(e2, n2)];
+};
+var modFloor = function(e2, n2) {
+  return (e2 % n2 + n2) % n2;
+};
+var divModTrunc = function(e2, n2) {
+  return [divTrunc(e2, n2), modTrunc(e2, n2)];
+};
+var divTrunc = function(e2, n2) {
+  return Math.trunc(e2 / n2) || 0;
+};
+var modTrunc = function(e2, n2) {
+  return e2 % n2 || 0;
+};
+var hasHalf = function(e2) {
+  return Math.abs(e2 % 1) === 0.5;
+};
+var givenFieldsToBigNano = function(e2, n2, t2) {
+  let o2 = 0, r2 = 0;
+  for (let i2 = 0;i2 <= n2; i2++) {
+    const n3 = e2[t2[i2]], a2 = Xr[i2], s2 = Qr / a2, [c2, u] = divModTrunc(n3, s2);
+    o2 += u * a2, r2 += c2;
+  }
+  const [i, a] = divModTrunc(o2, Qr);
+  return [r2 + i, a];
+};
+var nanoToGivenFields = function(e2, n2, t2) {
+  const o2 = {};
+  for (let r2 = n2;r2 >= 0; r2--) {
+    const n3 = Xr[r2];
+    o2[t2[r2]] = divTrunc(e2, n3), e2 = modTrunc(e2, n3);
+  }
+  return o2;
+};
+var un = function(e2) {
+  return e2 === X ? si : [];
+};
+var cn = function(e2) {
+  return e2 === X ? li : [];
+};
+var ln = function(e2) {
+  return e2 === X ? ["year", "day"] : [];
+};
+var l2 = function(e2) {
+  if (e2 !== undefined) {
+    return m(e2);
+  }
+};
+var S = function(e2) {
+  if (e2 !== undefined) {
+    return d(e2);
+  }
+};
+var c2 = function(e2) {
+  if (e2 !== undefined) {
+    return u(e2);
+  }
+};
+var d = function(e2) {
+  return requireNumberIsPositive(u(e2));
+};
+var u = function(e2) {
+  return requireNumberIsInteger(Mi(e2));
+};
+var on = function(e2) {
+  if (e2 == null) {
+    throw new TypeError("Cannot be null or undefined");
+  }
+  return e2;
+};
+var requirePropDefined = function(e2, n2) {
+  if (n2 == null) {
+    throw new RangeError(missingField(e2));
+  }
+  return n2;
+};
+var de = function(e2) {
+  if (!z(e2)) {
+    throw new TypeError(hr);
+  }
+  return e2;
+};
+var requireType = function(e2, n2, t2 = e2) {
+  if (typeof n2 !== e2) {
+    throw new TypeError(invalidEntity(t2, n2));
+  }
+  return n2;
+};
+var requireNumberIsInteger = function(e2, n2 = "number") {
+  if (!Number.isInteger(e2)) {
+    throw new RangeError(expectedInteger(n2, e2));
+  }
+  return e2 || 0;
+};
+var requireNumberIsPositive = function(e2, n2 = "number") {
+  if (e2 <= 0) {
+    throw new RangeError(expectedPositive(n2, e2));
+  }
+  return e2;
+};
+var toString = function(e2) {
+  if (typeof e2 == "symbol") {
+    throw new TypeError(pr);
+  }
+  return String(e2);
+};
+var toStringViaPrimitive = function(e2, n2) {
+  return z(e2) ? String(e2) : m(e2, n2);
+};
+var toBigInt = function(e2) {
+  if (typeof e2 == "string") {
+    return BigInt(e2);
+  }
+  if (typeof e2 != "bigint") {
+    throw new TypeError(invalidBigInt(e2));
+  }
+  return e2;
+};
+var toNumber = function(e2, n2 = "number") {
+  if (typeof e2 == "bigint") {
+    throw new TypeError(forbiddenBigIntToNumber(n2));
+  }
+  if (e2 = Number(e2), !Number.isFinite(e2)) {
+    throw new RangeError(expectedFinite(n2, e2));
+  }
+  return e2;
+};
+var toInteger = function(e2, n2) {
+  return Math.trunc(toNumber(e2, n2)) || 0;
+};
+var toStrictInteger = function(e2, n2) {
+  return requireNumberIsInteger(toNumber(e2, n2), n2);
+};
+var toPositiveInteger = function(e2, n2) {
+  return requireNumberIsPositive(toInteger(e2, n2), n2);
+};
+var createBigNano = function(e2, n2) {
+  let [t2, o2] = divModTrunc(n2, Qr), r2 = e2 + t2;
+  const i = Math.sign(r2);
+  return i && i === -Math.sign(o2) && (r2 -= i, o2 += i * Qr), [r2, o2];
+};
+var addBigNanos = function(e2, n2, t2 = 1) {
+  return createBigNano(e2[0] + n2[0] * t2, e2[1] + n2[1] * t2);
+};
+var moveBigNano = function(e2, n2) {
+  return createBigNano(e2[0], e2[1] + n2);
+};
+var re = function(e2, n2) {
+  return addBigNanos(n2, e2, -1);
+};
+var te = function(e2, n2) {
+  return compareNumbers(e2[0], n2[0]) || compareNumbers(e2[1], n2[1]);
+};
+var bigNanoOutside = function(e2, n2, t2) {
+  return te(e2, n2) === -1 || te(e2, t2) === 1;
+};
+var bigIntToBigNano = function(e2, n2 = 1) {
+  const t2 = BigInt(Qr / n2);
+  return [Number(e2 / t2), Number(e2 % t2) * n2];
+};
+var he = function(e2, n2 = 1) {
+  const t2 = Qr / n2, [o2, r2] = divModTrunc(e2, t2);
+  return [o2, r2 * n2];
+};
+var bigNanoToBigInt = function(e2, n2 = 1) {
+  const [t2, o2] = e2, r2 = Math.floor(o2 / n2), i = Qr / n2;
+  return BigInt(t2) * BigInt(i) + BigInt(r2);
+};
+var oe = function(e2, n2 = 1, t2) {
+  const [o2, r2] = e2, [i, a] = divModTrunc(r2, n2);
+  return o2 * (Qr / n2) + (i + (t2 ? a / n2 : 0));
+};
+var divModBigNano = function(e2, n2, t2 = divModFloor) {
+  const [o2, r2] = e2, [i, a] = t2(r2, n2);
+  return [o2 * (Qr / n2) + i, a];
+};
+var hashIntlFormatParts = function(e2, n2) {
+  const t2 = e2.formatToParts(n2), o2 = {};
+  for (const e3 of t2) {
+    o2[e3.type] = e3.value;
+  }
+  return o2;
+};
+var checkIsoYearMonthInBounds = function(e2) {
+  return clampProp(e2, "isoYear", Li, Ai, 1), e2.isoYear === Li ? clampProp(e2, "isoMonth", 4, 12, 1) : e2.isoYear === Ai && clampProp(e2, "isoMonth", 1, 9, 1), e2;
+};
+var checkIsoDateInBounds = function(e2) {
+  return checkIsoDateTimeInBounds({
+    ...e2,
+    ...Dt,
+    isoHour: 12
+  }), e2;
+};
+var checkIsoDateTimeInBounds = function(e2) {
+  const n2 = clampProp(e2, "isoYear", Li, Ai, 1), t2 = n2 === Li ? 1 : n2 === Ai ? -1 : 0;
+  return t2 && checkEpochNanoInBounds(isoToEpochNano({
+    ...e2,
+    isoDay: e2.isoDay + t2,
+    isoNanosecond: e2.isoNanosecond - t2
+  })), e2;
+};
+var checkEpochNanoInBounds = function(e2) {
+  if (!e2 || bigNanoOutside(e2, Ui, qi)) {
+    throw new RangeError(Cr);
+  }
+  return e2;
+};
+var isoTimeFieldsToNano = function(e2) {
+  return givenFieldsToBigNano(e2, 5, j)[1];
+};
+var nanoToIsoTimeAndDay = function(e2) {
+  const [n2, t2] = divModFloor(e2, Qr);
+  return [nanoToGivenFields(t2, 5, j), n2];
+};
+var epochNanoToSec = function(e2) {
+  return epochNanoToSecMod(e2)[0];
+};
+var epochNanoToSecMod = function(e2) {
+  return divModBigNano(e2, _r);
+};
+var isoToEpochMilli = function(e2) {
+  return isoArgsToEpochMilli(e2.isoYear, e2.isoMonth, e2.isoDay, e2.isoHour, e2.isoMinute, e2.isoSecond, e2.isoMillisecond);
+};
+var isoToEpochNano = function(e2) {
+  const n2 = isoToEpochMilli(e2);
+  if (n2 !== undefined) {
+    const [t2, o2] = divModTrunc(n2, Gr);
+    return [t2, o2 * be + (e2.isoMicrosecond || 0) * Vr + (e2.isoNanosecond || 0)];
+  }
+};
+var isoToEpochNanoWithOffset = function(e2, n2) {
+  const [t2, o2] = nanoToIsoTimeAndDay(isoTimeFieldsToNano(e2) - n2);
+  return checkEpochNanoInBounds(isoToEpochNano({
+    ...e2,
+    isoDay: e2.isoDay + o2,
+    ...t2
+  }));
+};
+var isoArgsToEpochSec = function(...e2) {
+  return isoArgsToEpochMilli(...e2) / Hr;
+};
+var isoArgsToEpochMilli = function(...e2) {
+  const [n2, t2] = isoToLegacyDate(...e2), o2 = n2.valueOf();
+  if (!isNaN(o2)) {
+    return o2 - t2 * Gr;
+  }
+};
+var isoToLegacyDate = function(e2, n2 = 1, t2 = 1, o2 = 0, r2 = 0, i = 0, a = 0) {
+  const s2 = e2 === Li ? 1 : e2 === Ai ? -1 : 0, c3 = new Date;
+  return c3.setUTCHours(o2, r2, i, a), c3.setUTCFullYear(e2, n2 - 1, t2 + s2), [c3, s2];
+};
+var Ie = function(e2, n2) {
+  let [t2, o2] = moveBigNano(e2, n2);
+  o2 < 0 && (o2 += Qr, t2 -= 1);
+  const [r2, i] = divModFloor(o2, be), [a, s2] = divModFloor(i, Vr);
+  return epochMilliToIso(t2 * Gr + r2, a, s2);
+};
+var epochMilliToIso = function(e2, n2 = 0, t2 = 0) {
+  const o2 = Math.ceil(Math.max(0, Math.abs(e2) - zi) / Gr) * Math.sign(e2), r2 = new Date(e2 - o2 * Gr);
+  return zipProps(wi, [r2.getUTCFullYear(), r2.getUTCMonth() + 1, r2.getUTCDate() + o2, r2.getUTCHours(), r2.getUTCMinutes(), r2.getUTCSeconds(), r2.getUTCMilliseconds(), n2, t2]);
+};
+var computeIsoDateParts = function(e2) {
+  return [e2.isoYear, e2.isoMonth, e2.isoDay];
+};
+var computeIsoMonthsInYear = function() {
+  return xi;
+};
+var computeIsoDaysInMonth = function(e2, n2) {
+  switch (n2) {
+    case 2:
+      return computeIsoInLeapYear(e2) ? 29 : 28;
+    case 4:
+    case 6:
+    case 9:
+    case 11:
+      return 30;
+  }
+  return 31;
+};
+var computeIsoDaysInYear = function(e2) {
+  return computeIsoInLeapYear(e2) ? 366 : 365;
+};
+var computeIsoInLeapYear = function(e2) {
+  return e2 % 4 == 0 && (e2 % 100 != 0 || e2 % 400 == 0);
+};
+var computeIsoDayOfWeek = function(e2) {
+  const [n2, t2] = isoToLegacyDate(e2.isoYear, e2.isoMonth, e2.isoDay);
+  return modFloor(n2.getUTCDay() - t2, 7) || 7;
+};
+var computeGregoryEraParts = function({ isoYear: e2 }) {
+  return e2 < 1 ? ["bce", 1 - e2] : ["ce", e2];
+};
+var computeJapaneseEraParts = function(e2) {
+  const n2 = isoToEpochMilli(e2);
+  if (n2 < $i) {
+    return computeGregoryEraParts(e2);
+  }
+  const t2 = hashIntlFormatParts(La(Ti), n2), { era: o2, eraYear: r2 } = parseIntlYear(t2, Ti);
+  return [o2, r2];
+};
+var checkIsoDateTimeFields = function(e2) {
+  return checkIsoDateFields(e2), constrainIsoTimeFields(e2, 1), e2;
+};
+var checkIsoDateFields = function(e2) {
+  return constrainIsoDateFields(e2, 1), e2;
+};
+var isIsoDateFieldsValid = function(e2) {
+  return allPropsEqual(Oi, e2, constrainIsoDateFields(e2));
+};
+var constrainIsoDateFields = function(e2, n2) {
+  const { isoYear: t2 } = e2, o2 = clampProp(e2, "isoMonth", 1, computeIsoMonthsInYear(), n2);
+  return {
+    isoYear: t2,
+    isoMonth: o2,
+    isoDay: clampProp(e2, "isoDay", 1, computeIsoDaysInMonth(t2, o2), n2)
+  };
+};
+var constrainIsoTimeFields = function(e2, n2) {
+  return zipProps(j, [clampProp(e2, "isoHour", 0, 23, n2), clampProp(e2, "isoMinute", 0, 59, n2), clampProp(e2, "isoSecond", 0, 59, n2), clampProp(e2, "isoMillisecond", 0, 999, n2), clampProp(e2, "isoMicrosecond", 0, 999, n2), clampProp(e2, "isoNanosecond", 0, 999, n2)]);
+};
+var H = function(e2) {
+  return e2 === undefined ? 0 : ua(de(e2));
+};
+var wn = function(e2, n2 = 0) {
+  e2 = normalizeOptions(e2);
+  const t2 = la(e2), o2 = fa(e2, n2);
+  return [ua(e2), o2, t2];
+};
+var ve = function(e2) {
+  return la(normalizeOptions(e2));
+};
+var _t = function(e2) {
+  return e2 = normalizeOptions(e2), sa(e2, 9, 6, 1);
+};
+var refineDiffOptions = function(e2, n2, t2, o2 = 9, r2 = 0, i = 4) {
+  n2 = normalizeOptions(n2);
+  let a = sa(n2, o2, r2), s2 = parseRoundingIncInteger(n2), c3 = ha(n2, i);
+  const u2 = aa(n2, o2, r2, 1);
+  return a == null ? a = Math.max(t2, u2) : checkLargestSmallestUnit(a, u2), s2 = refineRoundingInc(s2, u2, 1), e2 && (c3 = ((e3) => e3 < 4 ? (e3 + 2) % 4 : e3)(c3)), [a, u2, s2, c3];
+};
+var refineRoundingOptions = function(e2, n2 = 6, t2) {
+  let o2 = parseRoundingIncInteger(e2 = normalizeOptionsOrString(e2, Hi));
+  const r2 = ha(e2, 7);
+  let i = aa(e2, n2);
+  return i = requirePropDefined(Hi, i), o2 = refineRoundingInc(o2, i, undefined, t2), [i, o2, r2];
+};
+var refineDateDisplayOptions = function(e2) {
+  return da(normalizeOptions(e2));
+};
+var refineTimeDisplayOptions = function(e2, n2) {
+  return refineTimeDisplayTuple(normalizeOptions(e2), n2);
+};
+var refineTimeDisplayTuple = function(e2, n2 = 4) {
+  const t2 = refineSubsecDigits(e2);
+  return [ha(e2, 4), ...refineSmallestUnitAndSubsecDigits(aa(e2, n2), t2)];
+};
+var refineSmallestUnitAndSubsecDigits = function(e2, n2) {
+  return e2 != null ? [Xr[e2], e2 < 4 ? 9 - 3 * e2 : -1] : [n2 === undefined ? 1 : 10 ** (9 - n2), n2];
+};
+var parseRoundingIncInteger = function(e2) {
+  const n2 = e2[_i];
+  return n2 === undefined ? 1 : toInteger(n2, _i);
+};
+var refineRoundingInc = function(e2, n2, t2, o2) {
+  const r2 = o2 ? Qr : Xr[n2 + 1];
+  if (r2) {
+    const t3 = Xr[n2];
+    if (r2 % ((e2 = clampEntity(_i, e2, 1, r2 / t3 - (o2 ? 0 : 1), 1)) * t3)) {
+      throw new RangeError(invalidEntity(_i, e2));
+    }
+  } else {
+    e2 = clampEntity(_i, e2, 1, t2 ? 10 ** 9 : 1, 1);
+  }
+  return e2;
+};
+var refineSubsecDigits = function(e2) {
+  let n2 = e2[Ji];
+  if (n2 !== undefined) {
+    if (typeof n2 != "number") {
+      if (toString(n2) === "auto") {
+        return;
+      }
+      throw new RangeError(invalidEntity(Ji, n2));
+    }
+    n2 = clampEntity(Ji, Math.floor(n2), 0, 9, 1);
+  }
+  return n2;
+};
+var normalizeOptions = function(e2) {
+  return e2 === undefined ? {} : de(e2);
+};
+var normalizeOptionsOrString = function(e2, n2) {
+  return typeof e2 == "string" ? {
+    [n2]: e2
+  } : de(e2);
+};
+var U = function(e2) {
+  if (e2 !== undefined) {
+    if (z(e2)) {
+      return Object.assign(Object.create(null), e2);
+    }
+    throw new TypeError(hr);
+  }
+};
+var overrideOverflowOptions = function(e2, n2) {
+  return e2 && Object.assign(Object.create(null), e2, {
+    overflow: Xi[n2]
+  });
+};
+var refineUnitOption = function(e2, n2, t2 = 9, o2 = 0, r2) {
+  let i = n2[e2];
+  if (i === undefined) {
+    return r2 ? o2 : undefined;
+  }
+  if (i = toString(i), i === "auto") {
+    return r2 ? o2 : null;
+  }
+  let a = $r[i];
+  if (a === undefined && (a = Ei[i]), a === undefined) {
+    throw new RangeError(invalidChoice(e2, i, $r));
+  }
+  return clampEntity(e2, a, o2, t2, 1, Et), a;
+};
+var refineChoiceOption = function(e2, n2, t2, o2 = 0) {
+  const r2 = t2[e2];
+  if (r2 === undefined) {
+    return o2;
+  }
+  const i = toString(r2), a = n2[i];
+  if (a === undefined) {
+    throw new RangeError(invalidChoice(e2, i, n2));
+  }
+  return a;
+};
+var checkLargestSmallestUnit = function(e2, n2) {
+  if (n2 > e2) {
+    throw new RangeError(Ar);
+  }
+};
+var _ = function(e2) {
+  return {
+    branding: Oe,
+    epochNanoseconds: e2
+  };
+};
+var Yn = function(e2, n2, t2) {
+  return {
+    branding: Te,
+    calendar: t2,
+    timeZone: n2,
+    epochNanoseconds: e2
+  };
+};
+var ee = function(e2, n2 = e2.calendar) {
+  return {
+    branding: We,
+    calendar: n2,
+    ...Vn(Yi, e2)
+  };
+};
+var v = function(e2, n2 = e2.calendar) {
+  return {
+    branding: J,
+    calendar: n2,
+    ...Vn(Bi, e2)
+  };
+};
+var createPlainYearMonthSlots = function(e2, n2 = e2.calendar) {
+  return {
+    branding: L,
+    calendar: n2,
+    ...Vn(Bi, e2)
+  };
+};
+var createPlainMonthDaySlots = function(e2, n2 = e2.calendar) {
+  return {
+    branding: q,
+    calendar: n2,
+    ...Vn(Bi, e2)
+  };
+};
+var Ge = function(e2) {
+  return {
+    branding: xe,
+    ...Vn(ki, e2)
+  };
+};
+var Vt = function(e2) {
+  return {
+    branding: qt,
+    sign: computeDurationSign(e2),
+    ...Vn(Ni, e2)
+  };
+};
+var M = function(e2) {
+  return epochNanoToSec(e2.epochNanoseconds);
+};
+var y = function(e2) {
+  return divModBigNano(e2.epochNanoseconds, be)[0];
+};
+var N = function(e2) {
+  return bigNanoToBigInt(e2.epochNanoseconds, Vr);
+};
+var B = function(e2) {
+  return bigNanoToBigInt(e2.epochNanoseconds);
+};
+var extractEpochNano = function(e2) {
+  return e2.epochNanoseconds;
+};
+var I2 = function(e2) {
+  return typeof e2 == "string" ? e2 : m(e2.id);
+};
+var isIdLikeEqual = function(e2, n2) {
+  return e2 === n2 || I2(e2) === I2(n2);
+};
+var Ut = function(e2, n2, t2, o2, r2) {
+  const i = getMaxDurationUnit(o2), [a, s2] = ((e3, n3) => {
+    const t3 = n3((e3 = normalizeOptionsOrString(e3, Vi))[Ki]);
+    let o3 = ca(e3);
+    return o3 = requirePropDefined(Vi, o3), [o3, t3];
+  })(r2, e2);
+  if (isUniformUnit(Math.max(a, i), s2)) {
+    return totalDayTimeDuration(o2, a);
+  }
+  if (!s2) {
+    throw new RangeError(zr);
+  }
+  const [c3, u2, l3] = createMarkerSystem(n2, t2, s2), f = createMarkerToEpochNano(l3), d2 = createMoveMarker(l3), m = createDiffMarkers(l3), p2 = d2(u2, c3, o2), h2 = m(u2, c3, p2, a);
+  return isUniformUnit(a, s2) ? totalDayTimeDuration(h2, a) : ((e3, n3, t3, o3, r3, i2, a2) => {
+    const s3 = computeDurationSign(e3), [c4, u3] = clampRelativeDuration(o3, bi(t3, e3), t3, s3, r3, i2, a2), l4 = computeEpochNanoFrac(n3, c4, u3);
+    return e3[F[t3]] + l4 * s3;
+  })(h2, f(p2), a, u2, c3, f, d2);
+};
+var totalDayTimeDuration = function(e2, n2) {
+  return oe(durationFieldsToBigNano(e2), Xr[n2], 1);
+};
+var clampRelativeDuration = function(e2, n2, t2, o2, r2, i, a) {
+  const s2 = F[t2], c3 = {
+    ...n2,
+    [s2]: n2[s2] + o2
+  }, u2 = a(e2, r2, n2), l3 = a(e2, r2, c3);
+  return [i(u2), i(l3)];
+};
+var computeEpochNanoFrac = function(e2, n2, t2) {
+  const o2 = oe(re(n2, t2));
+  if (!o2) {
+    throw new RangeError(vr);
+  }
+  return oe(re(n2, e2)) / o2;
+};
+var ce = function(e2, n2) {
+  const [t2, o2, r2] = refineRoundingOptions(n2, 5, 1);
+  return _(roundBigNano(e2.epochNanoseconds, t2, o2, r2, 1));
+};
+var Pn = function(e2, n2, t2) {
+  let { epochNanoseconds: o2, timeZone: r2, calendar: i } = n2;
+  const [a, s2, c3] = refineRoundingOptions(t2);
+  if (a === 0 && s2 === 1) {
+    return n2;
+  }
+  const u2 = e2(r2);
+  if (a === 6) {
+    o2 = ((e3, n3, t3, o3) => {
+      const r3 = fn(t3, n3), [i2, a2] = e3(r3), s3 = t3.epochNanoseconds, c4 = we(n3, i2), u3 = we(n3, a2);
+      if (bigNanoOutside(s3, c4, u3)) {
+        throw new RangeError(vr);
+      }
+      return roundWithMode(computeEpochNanoFrac(s3, c4, u3), o3) ? u3 : c4;
+    })(computeDayInterval, u2, n2, c3);
+  } else {
+    const e3 = u2.getOffsetNanosecondsFor(o2);
+    o2 = getMatchingInstantFor(u2, roundDateTime(Ie(o2, e3), a, s2, c3), e3, 2, 0, 1);
+  }
+  return Yn(o2, r2, i);
+};
+var dt = function(e2, n2) {
+  return ee(roundDateTime(e2, ...refineRoundingOptions(n2)), e2.calendar);
+};
+var Ee = function(e2, n2) {
+  const [t2, o2, r2] = refineRoundingOptions(n2, 5);
+  var i;
+  return Ge((i = r2, roundTimeToNano(e2, computeNanoInc(t2, o2), i)[0]));
+};
+var dn = function(e2, n2) {
+  const t2 = e2(n2.timeZone), o2 = fn(n2, t2), [r2, i] = computeDayInterval(o2), a = oe(re(we(t2, r2), we(t2, i)), Kr, 1);
+  if (a <= 0) {
+    throw new RangeError(vr);
+  }
+  return a;
+};
+var Cn = function(e2, n2) {
+  const { timeZone: t2, calendar: o2 } = n2, r2 = ((e3, n3, t3) => we(n3, e3(fn(t3, n3))))(computeDayFloor, e2(t2), n2);
+  return Yn(r2, t2, o2);
+};
+var roundDateTime = function(e2, n2, t2, o2) {
+  return roundDateTimeToNano(e2, computeNanoInc(n2, t2), o2);
+};
+var roundDateTimeToNano = function(e2, n2, t2) {
+  const [o2, r2] = roundTimeToNano(e2, n2, t2);
+  return checkIsoDateTimeInBounds({
+    ...moveByDays(e2, r2),
+    ...o2
+  });
+};
+var roundTimeToNano = function(e2, n2, t2) {
+  return nanoToIsoTimeAndDay(roundByInc(isoTimeFieldsToNano(e2), n2, t2));
+};
+var roundToMinute = function(e2) {
+  return roundByInc(e2, Jr, 7);
+};
+var computeNanoInc = function(e2, n2) {
+  return Xr[e2] * n2;
+};
+var computeDayInterval = function(e2) {
+  const n2 = computeDayFloor(e2);
+  return [n2, moveByDays(n2, 1)];
+};
+var computeDayFloor = function(e2) {
+  return Ci(6, e2);
+};
+var roundDayTimeDurationByInc = function(e2, n2, t2) {
+  const o2 = Math.min(getMaxDurationUnit(e2), 6);
+  return nanoToDurationDayTimeFields(roundBigNanoByInc(durationFieldsToBigNano(e2, o2), n2, t2), o2);
+};
+var roundRelativeDuration = function(e2, n2, t2, o2, r2, i, a, s2, c3, u2) {
+  if (o2 === 0 && r2 === 1) {
+    return e2;
+  }
+  const l3 = isUniformUnit(o2, s2) ? isZonedEpochSlots(s2) && o2 < 6 && t2 >= 6 ? nudgeZonedTimeDuration : nudgeDayTimeDuration : nudgeRelativeDuration;
+  let [f, d2, m] = l3(e2, n2, t2, o2, r2, i, a, s2, c3, u2);
+  return m && o2 !== 7 && (f = ((e3, n3, t3, o3, r3, i2, a2, s3) => {
+    const c4 = computeDurationSign(e3);
+    for (let u3 = o3 + 1;u3 <= t3; u3++) {
+      if (u3 === 7 && t3 !== 7) {
+        continue;
+      }
+      const o4 = bi(u3, e3);
+      o4[F[u3]] += c4;
+      const l4 = oe(re(a2(s3(r3, i2, o4)), n3));
+      if (l4 && Math.sign(l4) !== c4) {
+        break;
+      }
+      e3 = o4;
+    }
+    return e3;
+  })(f, d2, t2, Math.max(6, o2), a, s2, c3, u2)), f;
+};
+var roundBigNano = function(e2, n2, t2, o2, r2) {
+  if (n2 === 6) {
+    const n3 = ((e3) => e3[0] + e3[1] / Qr)(e2);
+    return [roundByInc(n3, t2, o2), 0];
+  }
+  return roundBigNanoByInc(e2, computeNanoInc(n2, t2), o2, r2);
+};
+var roundBigNanoByInc = function(e2, n2, t2, o2) {
+  let [r2, i] = e2;
+  o2 && i < 0 && (i += Qr, r2 -= 1);
+  const [a, s2] = divModFloor(roundByInc(i, n2, t2), Qr);
+  return createBigNano(r2 + a, s2);
+};
+var roundByInc = function(e2, n2, t2) {
+  return roundWithMode(e2 / n2, t2) * n2;
+};
+var roundWithMode = function(e2, n2) {
+  return ga[n2](e2);
+};
+var nudgeDayTimeDuration = function(e2, n2, t2, o2, r2, i) {
+  const a = computeDurationSign(e2), s2 = durationFieldsToBigNano(e2), c3 = roundBigNano(s2, o2, r2, i), u2 = re(s2, c3), l3 = Math.sign(c3[0] - s2[0]) === a, f = nanoToDurationDayTimeFields(c3, Math.min(t2, 6));
+  return [{
+    ...e2,
+    ...f
+  }, addBigNanos(n2, u2), l3];
+};
+var nudgeZonedTimeDuration = function(e2, n2, t2, o2, r2, i, a, s2, c3, u2) {
+  const l3 = computeDurationSign(e2), f = oe(durationFieldsToBigNano(e2, 5)), d2 = computeNanoInc(o2, r2);
+  let m = roundByInc(f, d2, i);
+  const [p2, h2] = clampRelativeDuration(a, {
+    ...e2,
+    ...Fi
+  }, 6, l3, s2, c3, u2), g = m - oe(re(p2, h2));
+  let T2 = 0;
+  g && Math.sign(g) !== l3 ? n2 = moveBigNano(p2, m) : (T2 += l3, m = roundByInc(g, d2, i), n2 = moveBigNano(h2, m));
+  const D2 = nanoToDurationTimeFields(m);
+  return [{
+    ...e2,
+    ...D2,
+    days: e2.days + T2
+  }, n2, Boolean(T2)];
+};
+var nudgeRelativeDuration = function(e2, n2, t2, o2, r2, i, a, s2, c3, u2) {
+  const l3 = computeDurationSign(e2), f = F[o2], d2 = bi(o2, e2);
+  o2 === 7 && (e2 = {
+    ...e2,
+    weeks: e2.weeks + Math.trunc(e2.days / 7)
+  });
+  const m = divTrunc(e2[f], r2) * r2;
+  d2[f] = m;
+  const [p2, h2] = clampRelativeDuration(a, d2, o2, r2 * l3, s2, c3, u2), g = m + computeEpochNanoFrac(n2, p2, h2) * l3 * r2, T2 = roundByInc(g, r2, i), D2 = Math.sign(T2 - g) === l3;
+  return d2[f] = T2, [d2, D2 ? h2 : p2, D2];
+};
+var me = function(e2, n2, t2, o2) {
+  const [r2, i, a, s2] = ((e3) => {
+    const n3 = refineTimeDisplayTuple(e3 = normalizeOptions(e3));
+    return [e3.timeZone, ...n3];
+  })(o2), c3 = r2 !== undefined;
+  return ((e3, n3, t3, o3, r3, i2) => {
+    t3 = roundBigNanoByInc(t3, r3, o3, 1);
+    const a2 = n3.getOffsetNanosecondsFor(t3);
+    return formatIsoDateTimeFields(Ie(t3, a2), i2) + (e3 ? Fe(roundToMinute(a2)) : "Z");
+  })(c3, n2(c3 ? e2(r2) : Ta), t2.epochNanoseconds, i, a, s2);
+};
+var In = function(e2, n2, t2) {
+  const [o2, r2, i, a, s2, c3] = ((e3) => {
+    e3 = normalizeOptions(e3);
+    const n3 = da(e3), t3 = refineSubsecDigits(e3), o3 = pa(e3), r3 = ha(e3, 4), i2 = aa(e3, 4);
+    return [n3, ma(e3), o3, r3, ...refineSmallestUnitAndSubsecDigits(i2, t3)];
+  })(t2);
+  return ((e3, n3, t3, o3, r3, i2, a2, s3, c4, u2) => {
+    o3 = roundBigNanoByInc(o3, c4, s3, 1);
+    const l3 = e3(t3).getOffsetNanosecondsFor(o3);
+    return formatIsoDateTimeFields(Ie(o3, l3), u2) + Fe(roundToMinute(l3), a2) + ((e4, n4) => n4 !== 1 ? "[" + (n4 === 2 ? "!" : "") + I2(e4) + "]" : "")(t3, i2) + formatCalendar(n3, r3);
+  })(e2, n2.calendar, n2.timeZone, n2.epochNanoseconds, o2, r2, i, a, s2, c3);
+};
+var Tt = function(e2, n2) {
+  const [t2, o2, r2, i] = ((e3) => (e3 = normalizeOptions(e3), [da(e3), ...refineTimeDisplayTuple(e3)]))(n2);
+  return a = e2.calendar, s2 = t2, c3 = i, formatIsoDateTimeFields(roundDateTimeToNano(e2, r2, o2), c3) + formatCalendar(a, s2);
+  var a, s2, c3;
+};
+var yt = function(e2, n2) {
+  return t2 = e2.calendar, o2 = e2, r2 = refineDateDisplayOptions(n2), formatIsoDateFields(o2) + formatCalendar(t2, r2);
+  var t2, o2, r2;
+};
+var et = function(e2, n2) {
+  return formatDateLikeIso(e2.calendar, formatIsoYearMonthFields, e2, refineDateDisplayOptions(n2));
+};
+var W = function(e2, n2) {
+  return formatDateLikeIso(e2.calendar, formatIsoMonthDayFields, e2, refineDateDisplayOptions(n2));
+};
+var qe = function(e2, n2) {
+  const [t2, o2, r2] = refineTimeDisplayOptions(n2);
+  return i = r2, formatIsoTimeFields(roundTimeToNano(e2, o2, t2)[0], i);
+  var i;
+};
+var zt = function(e2, n2) {
+  const [t2, o2, r2] = refineTimeDisplayOptions(n2, 3);
+  return o2 > 1 && (e2 = {
+    ...e2,
+    ...roundDayTimeDurationByInc(e2, o2, t2)
+  }), ((e3, n3) => {
+    const { sign: t3 } = e3, o3 = t3 === -1 ? negateDurationFields(e3) : e3, { hours: r3, minutes: i } = o3, [a, s2] = divModBigNano(durationFieldsToBigNano(o3, 3), _r, divModTrunc);
+    checkDurationTimeUnit(a);
+    const c3 = formatSubsecNano(s2, n3), u2 = n3 >= 0 || !t3 || c3;
+    return (t3 < 0 ? "-" : "") + "P" + formatDurationFragments({
+      Y: formatDurationNumber(o3.years),
+      M: formatDurationNumber(o3.months),
+      W: formatDurationNumber(o3.weeks),
+      D: formatDurationNumber(o3.days)
+    }) + (r3 || i || a || u2 ? "T" + formatDurationFragments({
+      H: formatDurationNumber(r3),
+      M: formatDurationNumber(i),
+      S: formatDurationNumber(a, u2) + c3
+    }) : "");
+  })(e2, r2);
+};
+var formatDateLikeIso = function(e2, n2, t2, o2) {
+  const r2 = I2(e2), i = o2 > 1 || o2 === 0 && r2 !== X;
+  return o2 === 1 ? r2 === X ? n2(t2) : formatIsoDateFields(t2) : i ? formatIsoDateFields(t2) + formatCalendarId(r2, o2 === 2) : n2(t2);
+};
+var formatDurationFragments = function(e2) {
+  const n2 = [];
+  for (const t2 in e2) {
+    const o2 = e2[t2];
+    o2 && n2.push(o2, t2);
+  }
+  return n2.join("");
+};
+var formatIsoDateTimeFields = function(e2, n2) {
+  return formatIsoDateFields(e2) + "T" + formatIsoTimeFields(e2, n2);
+};
+var formatIsoDateFields = function(e2) {
+  return formatIsoYearMonthFields(e2) + "-" + xr(e2.isoDay);
+};
+var formatIsoYearMonthFields = function(e2) {
+  const { isoYear: n2 } = e2;
+  return (n2 < 0 || n2 > 9999 ? getSignStr(n2) + padNumber(6, Math.abs(n2)) : padNumber(4, n2)) + "-" + xr(e2.isoMonth);
+};
+var formatIsoMonthDayFields = function(e2) {
+  return xr(e2.isoMonth) + "-" + xr(e2.isoDay);
+};
+var formatIsoTimeFields = function(e2, n2) {
+  const t2 = [xr(e2.isoHour), xr(e2.isoMinute)];
+  return n2 !== -1 && t2.push(xr(e2.isoSecond) + ((e3, n3, t3, o2) => formatSubsecNano(e3 * be + n3 * Vr + t3, o2))(e2.isoMillisecond, e2.isoMicrosecond, e2.isoNanosecond, n2)), t2.join(":");
+};
+var Fe = function(e2, n2 = 0) {
+  if (n2 === 1) {
+    return "";
+  }
+  const [t2, o2] = divModFloor(Math.abs(e2), Kr), [r2, i] = divModFloor(o2, Jr), [a, s2] = divModFloor(i, _r);
+  return getSignStr(e2) + xr(t2) + ":" + xr(r2) + (a || s2 ? ":" + xr(a) + formatSubsecNano(s2) : "");
+};
+var formatCalendar = function(e2, n2) {
+  if (n2 !== 1) {
+    const t2 = I2(e2);
+    if (n2 > 1 || n2 === 0 && t2 !== X) {
+      return formatCalendarId(t2, n2 === 2);
+    }
+  }
+  return "";
+};
+var formatCalendarId = function(e2, n2) {
+  return "[" + (n2 ? "!" : "") + "u-ca=" + e2 + "]";
+};
+var formatSubsecNano = function(e2, n2) {
+  let t2 = padNumber(9, e2);
+  return t2 = n2 === undefined ? t2.replace(Na, "") : t2.slice(0, n2), t2 ? "." + t2 : "";
+};
+var getSignStr = function(e2) {
+  return e2 < 0 ? "-" : "+";
+};
+var formatDurationNumber = function(e2, n2) {
+  return e2 || n2 ? e2.toLocaleString("fullwide", {
+    useGrouping: 0
+  }) : "";
+};
+var _zonedEpochSlotsToIso = function(e2, n2) {
+  const { epochNanoseconds: t2 } = e2, o2 = (n2.getOffsetNanosecondsFor ? n2 : n2(e2.timeZone)).getOffsetNanosecondsFor(t2), r2 = Ie(t2, o2);
+  return {
+    calendar: e2.calendar,
+    ...r2,
+    offsetNanoseconds: o2
+  };
+};
+var mn = function(e2, n2) {
+  const t2 = fn(n2, e2);
+  return {
+    calendar: n2.calendar,
+    ...Vn(Yi, t2),
+    offset: Fe(t2.offsetNanoseconds),
+    timeZone: n2.timeZone
+  };
+};
+var getMatchingInstantFor = function(e2, n2, t2, o2 = 0, r2 = 0, i, a) {
+  if (t2 !== undefined && o2 === 1 && (o2 === 1 || a)) {
+    return isoToEpochNanoWithOffset(n2, t2);
+  }
+  const s2 = e2.getPossibleInstantsFor(n2);
+  if (t2 !== undefined && o2 !== 3) {
+    const e3 = ((e4, n3, t3, o3) => {
+      const r3 = isoToEpochNano(n3);
+      o3 && (t3 = roundToMinute(t3));
+      for (const n4 of e4) {
+        let e5 = oe(re(n4, r3));
+        if (o3 && (e5 = roundToMinute(e5)), e5 === t3) {
+          return n4;
+        }
+      }
+    })(s2, n2, t2, i);
+    if (e3 !== undefined) {
+      return e3;
+    }
+    if (o2 === 0) {
+      throw new RangeError(kr);
+    }
+  }
+  return a ? isoToEpochNano(n2) : we(e2, n2, r2, s2);
+};
+var we = function(e2, n2, t2 = 0, o2 = e2.getPossibleInstantsFor(n2)) {
+  if (o2.length === 1) {
+    return o2[0];
+  }
+  if (t2 === 1) {
+    throw new RangeError(Yr);
+  }
+  if (o2.length) {
+    return o2[t2 === 3 ? 1 : 0];
+  }
+  const r2 = isoToEpochNano(n2), i = ((e3, n3) => {
+    const t3 = e3.getOffsetNanosecondsFor(moveBigNano(n3, -Qr));
+    return ne(e3.getOffsetNanosecondsFor(moveBigNano(n3, Qr)) - t3);
+  })(e2, r2), a = i * (t2 === 2 ? -1 : 1);
+  return (o2 = e2.getPossibleInstantsFor(Ie(r2, a)))[t2 === 2 ? 0 : o2.length - 1];
+};
+var ae = function(e2) {
+  if (Math.abs(e2) >= Qr) {
+    throw new RangeError(wr);
+  }
+  return e2;
+};
+var ne = function(e2) {
+  if (e2 > Qr) {
+    throw new RangeError(Br);
+  }
+  return e2;
+};
+var se = function(e2, n2, t2) {
+  return _(checkEpochNanoInBounds(addBigNanos(n2.epochNanoseconds, ((e3) => {
+    if (durationHasDateParts(e3)) {
+      throw new RangeError(qr);
+    }
+    return durationFieldsToBigNano(e3, 5);
+  })(e2 ? negateDurationFields(t2) : t2))));
+};
+var hn = function(e2, n2, t2, o2, r2, i = Object.create(null)) {
+  const a = n2(o2.timeZone), s2 = e2(o2.calendar);
+  return {
+    ...o2,
+    ...moveZonedEpochs(a, s2, o2, t2 ? negateDurationFields(r2) : r2, i)
+  };
+};
+var ct = function(e2, n2, t2, o2, r2 = Object.create(null)) {
+  const { calendar: i } = t2;
+  return ee(moveDateTime(e2(i), t2, n2 ? negateDurationFields(o2) : o2, r2), i);
+};
+var bt = function(e2, n2, t2, o2, r2) {
+  const { calendar: i } = t2;
+  return v(moveDate(e2(i), t2, n2 ? negateDurationFields(o2) : o2, r2), i);
+};
+var Qe = function(e2, n2, t2, o2, r2 = Object.create(null)) {
+  const i = t2.calendar, a = e2(i);
+  let s2 = moveToDayOfMonthUnsafe(a, t2);
+  n2 && (o2 = xt(o2)), o2.sign < 0 && (s2 = a.dateAdd(s2, {
+    ...Si,
+    months: 1
+  }), s2 = moveByDays(s2, -1));
+  const c3 = a.dateAdd(s2, o2, r2);
+  return createPlainYearMonthSlots(moveToDayOfMonthUnsafe(a, c3), i);
+};
+var Ye = function(e2, n2, t2) {
+  return Ge(moveTime(n2, e2 ? negateDurationFields(t2) : t2)[0]);
+};
+var moveZonedEpochs = function(e2, n2, t2, o2, r2) {
+  const i = durationFieldsToBigNano(o2, 5);
+  let a = t2.epochNanoseconds;
+  if (durationHasDateParts(o2)) {
+    const s2 = fn(t2, e2);
+    a = addBigNanos(we(e2, {
+      ...moveDate(n2, s2, {
+        ...o2,
+        ...Fi
+      }, r2),
+      ...Vn(j, s2)
+    }), i);
+  } else {
+    a = addBigNanos(a, i), H(r2);
+  }
+  return {
+    epochNanoseconds: checkEpochNanoInBounds(a)
+  };
+};
+var moveDateTime = function(e2, n2, t2, o2) {
+  const [r2, i] = moveTime(n2, t2);
+  return checkIsoDateTimeInBounds({
+    ...moveDate(e2, n2, {
+      ...t2,
+      ...Fi,
+      days: t2.days + i
+    }, o2),
+    ...r2
+  });
+};
+var moveDate = function(e2, n2, t2, o2) {
+  if (t2.years || t2.months || t2.weeks) {
+    return e2.dateAdd(n2, t2, o2);
+  }
+  H(o2);
+  const r2 = t2.days + durationFieldsToBigNano(t2, 5)[0];
+  return r2 ? checkIsoDateInBounds(moveByDays(n2, r2)) : n2;
+};
+var moveToDayOfMonthUnsafe = function(e2, n2, t2 = 1) {
+  return moveByDays(n2, t2 - e2.day(n2));
+};
+var moveTime = function(e2, n2) {
+  const [t2, o2] = durationFieldsToBigNano(n2, 5), [r2, i] = nanoToIsoTimeAndDay(isoTimeFieldsToNano(e2) + o2);
+  return [r2, t2 + i];
+};
+var moveByDays = function(e2, n2) {
+  return n2 ? {
+    ...e2,
+    ...epochMilliToIso(isoToEpochMilli(e2) + n2 * Gr)
+  } : e2;
+};
+var createMarkerSystem = function(e2, n2, t2) {
+  const o2 = e2(t2.calendar);
+  return isZonedEpochSlots(t2) ? [t2, o2, n2(t2.timeZone)] : [{
+    ...t2,
+    ...Dt
+  }, o2];
+};
+var createMarkerToEpochNano = function(e2) {
+  return e2 ? extractEpochNano : isoToEpochNano;
+};
+var createMoveMarker = function(e2) {
+  return e2 ? E(moveZonedEpochs, e2) : moveDateTime;
+};
+var createDiffMarkers = function(e2) {
+  return e2 ? E(diffZonedEpochsExact, e2) : diffDateTimesExact;
+};
+var isZonedEpochSlots = function(e2) {
+  return e2 && e2.epochNanoseconds;
+};
+var isUniformUnit = function(e2, n2) {
+  return e2 <= 6 - (isZonedEpochSlots(n2) ? 1 : 0);
+};
+var Wt = function(e2, n2, t2, o2, r2, i, a) {
+  const s2 = e2(normalizeOptions(a).relativeTo), c3 = Math.max(getMaxDurationUnit(r2), getMaxDurationUnit(i));
+  if (isUniformUnit(c3, s2)) {
+    return Vt(checkDurationUnits(((e3, n3, t3, o3) => {
+      const r3 = addBigNanos(durationFieldsToBigNano(e3), durationFieldsToBigNano(n3), o3 ? -1 : 1);
+      if (!Number.isFinite(r3[0])) {
+        throw new RangeError(Cr);
+      }
+      return {
+        ...Si,
+        ...nanoToDurationDayTimeFields(r3, t3)
+      };
+    })(r2, i, c3, o2)));
+  }
+  if (!s2) {
+    throw new RangeError(zr);
+  }
+  o2 && (i = negateDurationFields(i));
+  const [u2, l3, f] = createMarkerSystem(n2, t2, s2), d2 = createMoveMarker(f), m = createDiffMarkers(f), p2 = d2(l3, u2, r2);
+  return Vt(m(l3, u2, d2(l3, p2, i), c3));
+};
+var Gt = function(e2, n2, t2, o2, r2) {
+  const i = getMaxDurationUnit(o2), [a, s2, c3, u2, l3] = ((e3, n3, t3) => {
+    e3 = normalizeOptionsOrString(e3, Hi);
+    let o3 = sa(e3);
+    const r3 = t3(e3[Ki]);
+    let i2 = parseRoundingIncInteger(e3);
+    const a2 = ha(e3, 7);
+    let s3 = aa(e3);
+    if (o3 === undefined && s3 === undefined) {
+      throw new RangeError(Ur);
+    }
+    return s3 == null && (s3 = 0), o3 == null && (o3 = Math.max(s3, n3)), checkLargestSmallestUnit(o3, s3), i2 = refineRoundingInc(i2, s3, 1), [o3, s3, i2, a2, r3];
+  })(r2, i, e2), f = Math.max(i, a);
+  if (!isZonedEpochSlots(l3) && f <= 6) {
+    return Vt(checkDurationUnits(((e3, n3, t3, o3, r3) => {
+      const i2 = roundBigNano(durationFieldsToBigNano(e3), t3, o3, r3);
+      return {
+        ...Si,
+        ...nanoToDurationDayTimeFields(i2, n3)
+      };
+    })(o2, a, s2, c3, u2)));
+  }
+  if (!l3) {
+    throw new RangeError(zr);
+  }
+  const [d2, m, p2] = createMarkerSystem(n2, t2, l3), h2 = createMarkerToEpochNano(p2), g = createMoveMarker(p2), T2 = createDiffMarkers(p2), D2 = g(m, d2, o2);
+  let I3 = T2(m, d2, D2, a);
+  const M2 = o2.sign, N2 = computeDurationSign(I3);
+  if (M2 && N2 && M2 !== N2) {
+    throw new RangeError(vr);
+  }
+  return N2 && (I3 = roundRelativeDuration(I3, h2(D2), a, s2, c3, u2, m, d2, h2, g)), Vt(I3);
+};
+var Rt = function(e2) {
+  return e2.sign === -1 ? xt(e2) : e2;
+};
+var xt = function(e2) {
+  return Vt(negateDurationFields(e2));
+};
+var negateDurationFields = function(e2) {
+  const n2 = {};
+  for (const t2 of F) {
+    n2[t2] = -1 * e2[t2] || 0;
+  }
+  return n2;
+};
+var Jt = function(e2) {
+  return !e2.sign;
+};
+var computeDurationSign = function(e2, n2 = F) {
+  let t2 = 0;
+  for (const o2 of n2) {
+    const n3 = Math.sign(e2[o2]);
+    if (n3) {
+      if (t2 && t2 !== n3) {
+        throw new RangeError(Rr);
+      }
+      t2 = n3;
+    }
+  }
+  return t2;
+};
+var checkDurationUnits = function(e2) {
+  for (const n2 of vi) {
+    clampEntity(n2, e2[n2], -ya, ya, 1);
+  }
+  return checkDurationTimeUnit(oe(durationFieldsToBigNano(e2), _r)), e2;
+};
+var checkDurationTimeUnit = function(e2) {
+  if (!Number.isSafeInteger(e2)) {
+    throw new RangeError(Zr);
+  }
+};
+var durationFieldsToBigNano = function(e2, n2 = 6) {
+  return givenFieldsToBigNano(e2, n2, F);
+};
+var nanoToDurationDayTimeFields = function(e2, n2 = 6) {
+  const [t2, o2] = e2, r2 = nanoToGivenFields(o2, n2, F);
+  if (r2[F[n2]] += t2 * (Qr / Xr[n2]), !Number.isFinite(r2[F[n2]])) {
+    throw new RangeError(Cr);
+  }
+  return r2;
+};
+var nanoToDurationTimeFields = function(e2, n2 = 5) {
+  return nanoToGivenFields(e2, n2, F);
+};
+var durationHasDateParts = function(e2) {
+  return Boolean(computeDurationSign(e2, Pi));
+};
+var getMaxDurationUnit = function(e2) {
+  let n2 = 9;
+  for (;n2 > 0 && !e2[F[n2]]; n2--) {
+  }
+  return n2;
+};
+var createSplitTuple = function(e2, n2) {
+  return [e2, n2];
+};
+var computePeriod = function(e2) {
+  const n2 = Math.floor(e2 / Da) * Da;
+  return [n2, n2 + Da];
+};
+var pe = function(e2) {
+  const n2 = parseDateTimeLike(e2 = toStringViaPrimitive(e2));
+  if (!n2) {
+    throw new RangeError(failedParse(e2));
+  }
+  let t2;
+  if (n2.m) {
+    t2 = 0;
+  } else {
+    if (!n2.offset) {
+      throw new RangeError(failedParse(e2));
+    }
+    t2 = parseOffsetNano(n2.offset);
+  }
+  return n2.timeZone && parseOffsetNanoMaybe(n2.timeZone, 1), _(isoToEpochNanoWithOffset(checkIsoDateTimeFields(n2), t2));
+};
+var Xt = function(e2) {
+  const n2 = parseDateTimeLike(m(e2));
+  if (!n2) {
+    throw new RangeError(failedParse(e2));
+  }
+  if (n2.timeZone) {
+    return finalizeZonedDateTime(n2, n2.offset ? parseOffsetNano(n2.offset) : undefined);
+  }
+  if (n2.m) {
+    throw new RangeError(failedParse(e2));
+  }
+  return finalizeDate(n2);
+};
+var Mn = function(e2, n2) {
+  const t2 = parseDateTimeLike(m(e2));
+  if (!t2 || !t2.timeZone) {
+    throw new RangeError(failedParse(e2));
+  }
+  const { offset: o2 } = t2, r2 = o2 ? parseOffsetNano(o2) : undefined, [, i, a] = wn(n2);
+  return finalizeZonedDateTime(t2, r2, i, a);
+};
+var parseOffsetNano = function(e2) {
+  const n2 = parseOffsetNanoMaybe(e2);
+  if (n2 === undefined) {
+    throw new RangeError(failedParse(e2));
+  }
+  return n2;
+};
+var Ct = function(e2) {
+  const n2 = parseDateTimeLike(m(e2));
+  if (!n2 || n2.m) {
+    throw new RangeError(failedParse(e2));
+  }
+  return ee(finalizeDateTime(n2));
+};
+var At = function(e2) {
+  const n2 = parseDateTimeLike(m(e2));
+  if (!n2 || n2.m) {
+    throw new RangeError(failedParse(e2));
+  }
+  return v(n2.p ? finalizeDateTime(n2) : finalizeDate(n2));
+};
+var ot = function(e2, n2) {
+  const t2 = parseYearMonthOnly(m(n2));
+  if (t2) {
+    return requireIsoCalendar(t2), createPlainYearMonthSlots(checkIsoYearMonthInBounds(checkIsoDateFields(t2)));
+  }
+  const o2 = At(n2);
+  return createPlainYearMonthSlots(moveToDayOfMonthUnsafe(e2(o2.calendar), o2));
+};
+var requireIsoCalendar = function(e2) {
+  if (e2.calendar !== X) {
+    throw new RangeError(invalidSubstring(e2.calendar));
+  }
+};
+var Q = function(e2, n2) {
+  const t2 = parseMonthDayOnly(m(n2));
+  if (t2) {
+    return requireIsoCalendar(t2), createPlainMonthDaySlots(checkIsoDateFields(t2));
+  }
+  const o2 = At(n2), { calendar: r2 } = o2, i = e2(r2), [a, s2, c3] = i.h(o2), [u2, l3] = i.I(a, s2), [f, d2] = i.N(u2, l3, c3);
+  return createPlainMonthDaySlots(checkIsoDateInBounds(i.P(f, d2, c3)), r2);
+};
+var ze = function(e2) {
+  let n2, t2 = ((e3) => {
+    const n3 = Ca.exec(e3);
+    return n3 ? (organizeAnnotationParts(n3[10]), organizeTimeParts(n3)) : undefined;
+  })(m(e2));
+  if (!t2) {
+    if (t2 = parseDateTimeLike(e2), !t2) {
+      throw new RangeError(failedParse(e2));
+    }
+    if (!t2.p) {
+      throw new RangeError(failedParse(e2));
+    }
+    if (t2.m) {
+      throw new RangeError(invalidSubstring("Z"));
+    }
+    requireIsoCalendar(t2);
+  }
+  if ((n2 = parseYearMonthOnly(e2)) && isIsoDateFieldsValid(n2)) {
+    throw new RangeError(failedParse(e2));
+  }
+  if ((n2 = parseMonthDayOnly(e2)) && isIsoDateFieldsValid(n2)) {
+    throw new RangeError(failedParse(e2));
+  }
+  return Ge(constrainIsoTimeFields(t2, 1));
+};
+var Kt = function(e2) {
+  const n2 = ((e3) => {
+    const n3 = za.exec(e3);
+    return n3 ? ((e4) => {
+      function parseUnit(e5, r3, i) {
+        let a = 0, s2 = 0;
+        if (i && ([a, o2] = divModFloor(o2, Xr[i])), e5 !== undefined) {
+          if (t2) {
+            throw new RangeError(invalidSubstring(e5));
+          }
+          s2 = ((e6) => {
+            const n5 = parseInt(e6);
+            if (!Number.isFinite(n5)) {
+              throw new RangeError(invalidSubstring(e6));
+            }
+            return n5;
+          })(e5), n4 = 1, r3 && (o2 = parseSubsecNano(r3) * (Xr[i] / _r), t2 = 1);
+        }
+        return a + s2;
+      }
+      let n4 = 0, t2 = 0, o2 = 0, r2 = {
+        ...zipProps(F, [parseUnit(e4[2]), parseUnit(e4[3]), parseUnit(e4[4]), parseUnit(e4[5]), parseUnit(e4[6], e4[7], 5), parseUnit(e4[8], e4[9], 4), parseUnit(e4[10], e4[11], 3)]),
+        ...nanoToGivenFields(o2, 2, F)
+      };
+      if (!n4) {
+        throw new RangeError(noValidFields(F));
+      }
+      return parseSign(e4[1]) < 0 && (r2 = negateDurationFields(r2)), r2;
+    })(n3) : undefined;
+  })(m(e2));
+  if (!n2) {
+    throw new RangeError(failedParse(e2));
+  }
+  return Vt(checkDurationUnits(n2));
+};
+var sn = function(e2) {
+  const n2 = parseDateTimeLike(e2) || parseYearMonthOnly(e2) || parseMonthDayOnly(e2);
+  return n2 ? n2.calendar : e2;
+};
+var Ne = function(e2) {
+  const n2 = parseDateTimeLike(e2);
+  return n2 && (n2.timeZone || n2.m && Ta || n2.offset) || e2;
+};
+var finalizeZonedDateTime = function(e2, n2, t2 = 0, o2 = 0) {
+  const r2 = ye(e2.timeZone), i = ie(r2);
+  return Yn(getMatchingInstantFor(i, checkIsoDateTimeFields(e2), n2, t2, o2, !i.v, e2.m), r2, an(e2.calendar));
+};
+var finalizeDateTime = function(e2) {
+  return resolveSlotsCalendar(checkIsoDateTimeInBounds(checkIsoDateTimeFields(e2)));
+};
+var finalizeDate = function(e2) {
+  return resolveSlotsCalendar(checkIsoDateInBounds(checkIsoDateFields(e2)));
+};
+var resolveSlotsCalendar = function(e2) {
+  return {
+    ...e2,
+    calendar: an(e2.calendar)
+  };
+};
+var parseDateTimeLike = function(e2) {
+  const n2 = Ya.exec(e2);
+  return n2 ? ((e3) => {
+    const n3 = e3[10], t2 = (n3 || "").toUpperCase() === "Z";
+    return {
+      isoYear: organizeIsoYearParts(e3),
+      isoMonth: parseInt(e3[4]),
+      isoDay: parseInt(e3[5]),
+      ...organizeTimeParts(e3.slice(5)),
+      ...organizeAnnotationParts(e3[16]),
+      p: Boolean(e3[6]),
+      m: t2,
+      offset: t2 ? undefined : n3
+    };
+  })(n2) : undefined;
+};
+var parseYearMonthOnly = function(e2) {
+  const n2 = Ba.exec(e2);
+  return n2 ? ((e3) => ({
+    isoYear: organizeIsoYearParts(e3),
+    isoMonth: parseInt(e3[4]),
+    isoDay: 1,
+    ...organizeAnnotationParts(e3[5])
+  }))(n2) : undefined;
+};
+var parseMonthDayOnly = function(e2) {
+  const n2 = ka.exec(e2);
+  return n2 ? ((e3) => ({
+    isoYear: ji,
+    isoMonth: parseInt(e3[1]),
+    isoDay: parseInt(e3[2]),
+    ...organizeAnnotationParts(e3[3])
+  }))(n2) : undefined;
+};
+var parseOffsetNanoMaybe = function(e2, n2) {
+  const t2 = Za.exec(e2);
+  return t2 ? ((e3, n3) => {
+    const t3 = e3[4] || e3[5];
+    if (n3 && t3) {
+      throw new RangeError(invalidSubstring(t3));
+    }
+    return ae((parseInt0(e3[2]) * Kr + parseInt0(e3[3]) * Jr + parseInt0(e3[4]) * _r + parseSubsecNano(e3[5] || "")) * parseSign(e3[1]));
+  })(t2, n2) : undefined;
+};
+var organizeIsoYearParts = function(e2) {
+  const n2 = parseSign(e2[1]), t2 = parseInt(e2[2] || e2[3]);
+  if (n2 < 0 && !t2) {
+    throw new RangeError(invalidSubstring(-0));
+  }
+  return n2 * t2;
+};
+var organizeTimeParts = function(e2) {
+  const n2 = parseInt0(e2[3]);
+  return {
+    ...nanoToIsoTimeAndDay(parseSubsecNano(e2[4] || ""))[0],
+    isoHour: parseInt0(e2[1]),
+    isoMinute: parseInt0(e2[2]),
+    isoSecond: n2 === 60 ? 59 : n2
+  };
+};
+var organizeAnnotationParts = function(e2) {
+  let n2, t2;
+  const o2 = [];
+  if (e2.replace(Ra, (e3, r2, i) => {
+    const a = Boolean(r2), [s2, c3] = i.split("=").reverse();
+    if (c3) {
+      if (c3 === "u-ca") {
+        o2.push(s2), n2 || (n2 = a);
+      } else if (a || /[A-Z]/.test(c3)) {
+        throw new RangeError(invalidSubstring(e3));
+      }
+    } else {
+      if (t2) {
+        throw new RangeError(invalidSubstring(e3));
+      }
+      t2 = s2;
+    }
+    return "";
+  }), o2.length > 1 && n2) {
+    throw new RangeError(invalidSubstring(e2));
+  }
+  return {
+    timeZone: t2,
+    calendar: o2[0] || X
+  };
+};
+var parseSubsecNano = function(e2) {
+  return parseInt(e2.padEnd(9, "0"));
+};
+var createRegExp = function(e2) {
+  return new RegExp(`^${e2}\$`, "i");
+};
+var parseSign = function(e2) {
+  return e2 && e2 !== "+" ? -1 : 1;
+};
+var parseInt0 = function(e2) {
+  return e2 === undefined ? 0 : parseInt(e2);
+};
+var Me = function(e2) {
+  return ye(m(e2));
+};
+var ye = function(e2) {
+  const n2 = getTimeZoneEssence(e2);
+  return typeof n2 == "number" ? Fe(n2) : n2 ? ((e3) => {
+    if (Ua.test(e3)) {
+      throw new RangeError(br);
+    }
+    return e3.toLowerCase().split("/").map((e4, n3) => (e4.length <= 3 || /\d/.test(e4)) && !/etc|yap/.test(e4) ? e4.toUpperCase() : e4.replace(/baja|dumont|[a-z]+/g, (e5, t2) => e5.length <= 2 && !n3 || e5 === "in" || e5 === "chat" ? e5.toUpperCase() : e5.length > 2 || !t2 ? capitalize(e5).replace(/island|noronha|murdo|rivadavia|urville/, capitalize) : e5)).join("/");
+  })(e2) : Ta;
+};
+var getTimeZoneAtomic = function(e2) {
+  const n2 = getTimeZoneEssence(e2);
+  return typeof n2 == "number" ? n2 : n2 ? n2.resolvedOptions().timeZone : Ta;
+};
+var getTimeZoneEssence = function(e2) {
+  const n2 = parseOffsetNanoMaybe(e2 = e2.toUpperCase(), 1);
+  return n2 !== undefined ? n2 : e2 !== Ta ? qa(e2) : undefined;
+};
+var Ze = function(e2, n2) {
+  return te(e2.epochNanoseconds, n2.epochNanoseconds);
+};
+var yn = function(e2, n2) {
+  return te(e2.epochNanoseconds, n2.epochNanoseconds);
+};
+var $t = function(e2, n2, t2, o2, r2, i) {
+  const a = e2(normalizeOptions(i).relativeTo), s2 = Math.max(getMaxDurationUnit(o2), getMaxDurationUnit(r2));
+  if (allPropsEqual(F, o2, r2)) {
+    return 0;
+  }
+  if (isUniformUnit(s2, a)) {
+    return te(durationFieldsToBigNano(o2), durationFieldsToBigNano(r2));
+  }
+  if (!a) {
+    throw new RangeError(zr);
+  }
+  const [c3, u2, l3] = createMarkerSystem(n2, t2, a), f = createMarkerToEpochNano(l3), d2 = createMoveMarker(l3);
+  return te(f(d2(u2, c3, o2)), f(d2(u2, c3, r2)));
+};
+var gt = function(e2, n2) {
+  return rt(e2, n2) || He(e2, n2);
+};
+var rt = function(e2, n2) {
+  return compareNumbers(isoToEpochMilli(e2), isoToEpochMilli(n2));
+};
+var He = function(e2, n2) {
+  return compareNumbers(isoTimeFieldsToNano(e2), isoTimeFieldsToNano(n2));
+};
+var ue = function(e2, n2) {
+  return !Ze(e2, n2);
+};
+var gn = function(e2, n2) {
+  return !yn(e2, n2) && !!je(e2.timeZone, n2.timeZone) && isIdLikeEqual(e2.calendar, n2.calendar);
+};
+var ft = function(e2, n2) {
+  return !gt(e2, n2) && isIdLikeEqual(e2.calendar, n2.calendar);
+};
+var It = function(e2, n2) {
+  return !rt(e2, n2) && isIdLikeEqual(e2.calendar, n2.calendar);
+};
+var $e = function(e2, n2) {
+  return !rt(e2, n2) && isIdLikeEqual(e2.calendar, n2.calendar);
+};
+var x = function(e2, n2) {
+  return !rt(e2, n2) && isIdLikeEqual(e2.calendar, n2.calendar);
+};
+var Ve = function(e2, n2) {
+  return !He(e2, n2);
+};
+var je = function(e2, n2) {
+  if (e2 === n2) {
+    return 1;
+  }
+  const t2 = I2(e2), o2 = I2(n2);
+  if (t2 === o2) {
+    return 1;
+  }
+  try {
+    return getTimeZoneAtomic(t2) === getTimeZoneAtomic(o2);
+  } catch (e3) {
+  }
+};
+var le = function(e2, n2, t2, o2) {
+  const r2 = refineDiffOptions(e2, U(o2), 3, 5), i = diffEpochNanos(n2.epochNanoseconds, t2.epochNanoseconds, ...r2);
+  return Vt(e2 ? negateDurationFields(i) : i);
+};
+var Dn = function(e2, n2, t2, o2, r2, i) {
+  const a = getCommonCalendarSlot(o2.calendar, r2.calendar), s2 = U(i), [c3, u2, l3, f] = refineDiffOptions(t2, s2, 5), d2 = o2.epochNanoseconds, m = r2.epochNanoseconds, p2 = te(m, d2);
+  let h2;
+  if (p2) {
+    if (c3 < 6) {
+      h2 = diffEpochNanos(d2, m, c3, u2, l3, f);
+    } else {
+      const t3 = n2(((e3, n3) => {
+        if (!je(e3, n3)) {
+          throw new RangeError(Fr);
+        }
+        return e3;
+      })(o2.timeZone, r2.timeZone)), i2 = e2(a);
+      h2 = diffZonedEpochsBig(i2, t3, o2, r2, p2, c3, s2), h2 = roundRelativeDuration(h2, m, c3, u2, l3, f, i2, o2, extractEpochNano, E(moveZonedEpochs, t3));
+    }
+  } else {
+    h2 = Si;
+  }
+  return Vt(t2 ? negateDurationFields(h2) : h2);
+};
+var ut = function(e2, n2, t2, o2, r2) {
+  const i = getCommonCalendarSlot(t2.calendar, o2.calendar), a = U(r2), [s2, c3, u2, l3] = refineDiffOptions(n2, a, 6), f = isoToEpochNano(t2), d2 = isoToEpochNano(o2), m = te(d2, f);
+  let p2;
+  if (m) {
+    if (s2 <= 6) {
+      p2 = diffEpochNanos(f, d2, s2, c3, u2, l3);
+    } else {
+      const n3 = e2(i);
+      p2 = diffDateTimesBig(n3, t2, o2, m, s2, a), p2 = roundRelativeDuration(p2, d2, s2, c3, u2, l3, n3, t2, isoToEpochNano, moveDateTime);
+    }
+  } else {
+    p2 = Si;
+  }
+  return Vt(n2 ? negateDurationFields(p2) : p2);
+};
+var Ft = function(e2, n2, t2, o2, r2) {
+  const i = getCommonCalendarSlot(t2.calendar, o2.calendar), a = U(r2);
+  return diffDateLike(n2, () => e2(i), t2, o2, ...refineDiffOptions(n2, a, 6, 9, 6), a);
+};
+var Xe = function(e2, n2, t2, o2, r2) {
+  const i = getCommonCalendarSlot(t2.calendar, o2.calendar), a = U(r2), s2 = refineDiffOptions(n2, a, 9, 9, 8), c3 = e2(i);
+  return diffDateLike(n2, () => c3, moveToDayOfMonthUnsafe(c3, t2), moveToDayOfMonthUnsafe(c3, o2), ...s2, a);
+};
+var diffDateLike = function(e2, n2, t2, o2, r2, i, a, s2, c3) {
+  const u2 = isoToEpochNano(t2), l3 = isoToEpochNano(o2);
+  let f;
+  if (te(l3, u2)) {
+    if (r2 === 6) {
+      f = diffEpochNanos(u2, l3, r2, i, a, s2);
+    } else {
+      const e3 = n2();
+      f = e3.dateUntil(t2, o2, r2, c3), i === 6 && a === 1 || (f = roundRelativeDuration(f, l3, r2, i, a, s2, e3, t2, isoToEpochNano, moveDate));
+    }
+  } else {
+    f = Si;
+  }
+  return Vt(e2 ? negateDurationFields(f) : f);
+};
+var Ae = function(e2, n2, t2, o2) {
+  const r2 = U(o2), [i, a, s2, c3] = refineDiffOptions(e2, r2, 5, 5), u2 = roundByInc(diffTimes(n2, t2), computeNanoInc(a, s2), c3), l3 = {
+    ...Si,
+    ...nanoToDurationTimeFields(u2, i)
+  };
+  return Vt(e2 ? negateDurationFields(l3) : l3);
+};
+var diffZonedEpochsExact = function(e2, n2, t2, o2, r2, i) {
+  const a = te(o2.epochNanoseconds, t2.epochNanoseconds);
+  return a ? r2 < 6 ? diffEpochNanosExact(t2.epochNanoseconds, o2.epochNanoseconds, r2) : diffZonedEpochsBig(n2, e2, t2, o2, a, r2, i) : Si;
+};
+var diffDateTimesExact = function(e2, n2, t2, o2, r2) {
+  const i = isoToEpochNano(n2), a = isoToEpochNano(t2), s2 = te(a, i);
+  return s2 ? o2 <= 6 ? diffEpochNanosExact(i, a, o2) : diffDateTimesBig(e2, n2, t2, s2, o2, r2) : Si;
+};
+var diffZonedEpochsBig = function(e2, n2, t2, o2, r2, i, a) {
+  const [s2, c3, u2] = ((e3, n3, t3, o3) => {
+    function updateMid() {
+      return l4 = {
+        ...moveByDays(a2, c4++ * -o3),
+        ...i2
+      }, f2 = we(e3, l4), te(s3, f2) === -o3;
+    }
+    const r3 = fn(n3, e3), i2 = Vn(j, r3), a2 = fn(t3, e3), s3 = t3.epochNanoseconds;
+    let c4 = 0;
+    const u3 = diffTimes(r3, a2);
+    let l4, f2;
+    if (Math.sign(u3) === -o3 && c4++, updateMid() && (o3 === -1 || updateMid())) {
+      throw new RangeError(vr);
+    }
+    const d2 = oe(re(f2, s3));
+    return [r3, l4, d2];
+  })(n2, t2, o2, r2);
+  var l3, f;
+  return {
+    ...i === 6 ? (l3 = s2, f = c3, {
+      ...Si,
+      days: diffDays(l3, f)
+    }) : e2.dateUntil(s2, c3, i, a),
+    ...nanoToDurationTimeFields(u2)
+  };
+};
+var diffDateTimesBig = function(e2, n2, t2, o2, r2, i) {
+  const [a, s2, c3] = ((e3, n3, t3) => {
+    let o3 = n3, r3 = diffTimes(e3, n3);
+    return Math.sign(r3) === -t3 && (o3 = moveByDays(n3, -t3), r3 += Qr * t3), [e3, o3, r3];
+  })(n2, t2, o2);
+  return {
+    ...e2.dateUntil(a, s2, r2, i),
+    ...nanoToDurationTimeFields(c3)
+  };
+};
+var diffEpochNanos = function(e2, n2, t2, o2, r2, i) {
+  return {
+    ...Si,
+    ...nanoToDurationDayTimeFields(roundBigNano(re(e2, n2), o2, r2, i), t2)
+  };
+};
+var diffEpochNanosExact = function(e2, n2, t2) {
+  return {
+    ...Si,
+    ...nanoToDurationDayTimeFields(re(e2, n2), t2)
+  };
+};
+var diffDays = function(e2, n2) {
+  return diffEpochMilliByDay(isoToEpochMilli(e2), isoToEpochMilli(n2));
+};
+var diffEpochMilliByDay = function(e2, n2) {
+  return Math.trunc((n2 - e2) / Gr);
+};
+var diffTimes = function(e2, n2) {
+  return isoTimeFieldsToNano(n2) - isoTimeFieldsToNano(e2);
+};
+var getCommonCalendarSlot = function(e2, n2) {
+  if (!isIdLikeEqual(e2, n2)) {
+    throw new RangeError(Er);
+  }
+  return e2;
+};
+var createIntlCalendar = function(e2) {
+  function epochMilliToIntlFields(e3) {
+    return ((e4, n3) => ({
+      ...parseIntlYear(e4, n3),
+      F: e4.month,
+      day: parseInt(e4.day)
+    }))(hashIntlFormatParts(n2, e3), t2);
+  }
+  const n2 = La(e2), t2 = computeCalendarIdBase(e2);
+  return {
+    id: e2,
+    O: createIntlFieldCache(epochMilliToIntlFields),
+    B: createIntlYearDataCache(epochMilliToIntlFields)
+  };
+};
+var createIntlFieldCache = function(e2) {
+  return Jn((n2) => {
+    const t2 = isoToEpochMilli(n2);
+    return e2(t2);
+  }, WeakMap);
+};
+var createIntlYearDataCache = function(e2) {
+  const n2 = e2(0).year - Wi;
+  return Jn((t2) => {
+    let o2, r2 = isoArgsToEpochMilli(t2 - n2);
+    const i = [], a = [];
+    do {
+      r2 += 400 * Gr;
+    } while ((o2 = e2(r2)).year <= t2);
+    do {
+      r2 += (1 - o2.day) * Gr, o2.year === t2 && (i.push(r2), a.push(o2.F)), r2 -= Gr;
+    } while ((o2 = e2(r2)).year >= t2);
+    return {
+      k: i.reverse(),
+      C: Wr(a.reverse())
+    };
+  });
+};
+var parseIntlYear = function(e2, n2) {
+  let t2, o2, r2 = parseIntlPartsYear(e2);
+  if (e2.era) {
+    const i = Di[n2];
+    i !== undefined && (t2 = n2 === "islamic" ? "ah" : e2.era.normalize("NFD").toLowerCase().replace(/[^a-z0-9]/g, ""), t2 === "bc" || t2 === "b" ? t2 = "bce" : t2 !== "ad" && t2 !== "a" || (t2 = "ce"), o2 = r2, r2 = eraYearToYear(o2, i[t2] || 0));
+  }
+  return {
+    era: t2,
+    eraYear: o2,
+    year: r2
+  };
+};
+var parseIntlPartsYear = function(e2) {
+  return parseInt(e2.relatedYear || e2.year);
+};
+var computeIntlDateParts = function(e2) {
+  const { year: n2, F: t2, day: o2 } = this.O(e2), { C: r2 } = this.B(n2);
+  return [n2, r2[t2] + 1, o2];
+};
+var computeIntlEpochMilli = function(e2, n2 = 1, t2 = 1) {
+  return this.B(e2).k[n2 - 1] + (t2 - 1) * Gr;
+};
+var computeIntlLeapMonth = function(e2) {
+  const n2 = queryMonthStrings(this, e2), t2 = queryMonthStrings(this, e2 - 1), o2 = n2.length;
+  if (o2 > t2.length) {
+    const e3 = getCalendarLeapMonthMeta(this);
+    if (e3 < 0) {
+      return -e3;
+    }
+    for (let e4 = 0;e4 < o2; e4++) {
+      if (n2[e4] !== t2[e4]) {
+        return e4 + 1;
+      }
+    }
+  }
+};
+var computeIntlDaysInYear = function(e2) {
+  return diffEpochMilliByDay(computeIntlEpochMilli.call(this, e2), computeIntlEpochMilli.call(this, e2 + 1));
+};
+var computeIntlDaysInMonth = function(e2, n2) {
+  const { k: t2 } = this.B(e2);
+  let o2 = n2 + 1, r2 = t2;
+  return o2 > t2.length && (o2 = 1, r2 = this.B(e2 + 1).k), diffEpochMilliByDay(t2[n2 - 1], r2[o2 - 1]);
+};
+var computeIntlMonthsInYear = function(e2) {
+  return this.B(e2).k.length;
+};
+var queryMonthStrings = function(e2, n2) {
+  return Object.keys(e2.B(n2).C);
+};
+var rn = function(e2) {
+  return an(m(e2));
+};
+var an = function(e2) {
+  if ((e2 = e2.toLowerCase()) !== X && e2 !== gi && computeCalendarIdBase(e2) !== computeCalendarIdBase(La(e2).resolvedOptions().calendar)) {
+    throw new RangeError(invalidCalendar(e2));
+  }
+  return e2;
+};
+var computeCalendarIdBase = function(e2) {
+  return e2 === "islamicc" && (e2 = "islamic"), e2.split("-")[0];
+};
+var computeNativeWeekOfYear = function(e2) {
+  return this.R(e2)[0];
+};
+var computeNativeYearOfWeek = function(e2) {
+  return this.R(e2)[1];
+};
+var computeNativeDayOfYear = function(e2) {
+  const [n2] = this.h(e2);
+  return diffEpochMilliByDay(this.q(n2), isoToEpochMilli(e2)) + 1;
+};
+var parseMonthCode = function(e2) {
+  const n2 = Wa.exec(e2);
+  if (!n2) {
+    throw new RangeError(invalidMonthCode(e2));
+  }
+  return [parseInt(n2[1]), Boolean(n2[2])];
+};
+var monthCodeNumberToMonth = function(e2, n2, t2) {
+  return e2 + (n2 || t2 && e2 >= t2 ? 1 : 0);
+};
+var monthToMonthCodeNumber = function(e2, n2) {
+  return e2 - (n2 && e2 >= n2 ? 1 : 0);
+};
+var eraYearToYear = function(e2, n2) {
+  return (n2 + e2) * (Math.sign(n2) || 1) || 0;
+};
+var getCalendarEraOrigins = function(e2) {
+  return Di[getCalendarIdBase(e2)];
+};
+var getCalendarLeapMonthMeta = function(e2) {
+  return Ii[getCalendarIdBase(e2)];
+};
+var getCalendarIdBase = function(e2) {
+  return computeCalendarIdBase(e2.id || X);
+};
+var Qt = function(e2, n2, t2, o2) {
+  const r2 = refineCalendarFields(t2, o2, en, [], ri);
+  if (r2.timeZone !== undefined) {
+    const o3 = t2.dateFromFields(r2), i = refineTimeBag(r2), a = e2(r2.timeZone);
+    return {
+      epochNanoseconds: getMatchingInstantFor(n2(a), {
+        ...o3,
+        ...i
+      }, r2.offset !== undefined ? parseOffsetNano(r2.offset) : undefined),
+      timeZone: a
+    };
+  }
+  return {
+    ...t2.dateFromFields(r2),
+    ...Dt
+  };
+};
+var jn = function(e2, n2, t2, o2, r2, i) {
+  const a = refineCalendarFields(t2, r2, en, ti, ri), s2 = e2(a.timeZone), [c3, u2, l3] = wn(i), f = t2.dateFromFields(a, overrideOverflowOptions(i, c3)), d2 = refineTimeBag(a, c3);
+  return Yn(getMatchingInstantFor(n2(s2), {
+    ...f,
+    ...d2
+  }, a.offset !== undefined ? parseOffsetNano(a.offset) : undefined, u2, l3), s2, o2);
+};
+var Pt = function(e2, n2, t2) {
+  const o2 = refineCalendarFields(e2, n2, en, [], w), r2 = H(t2);
+  return ee(checkIsoDateTimeInBounds({
+    ...e2.dateFromFields(o2, overrideOverflowOptions(t2, r2)),
+    ...refineTimeBag(o2, r2)
+  }));
+};
+var Yt = function(e2, n2, t2, o2 = []) {
+  const r2 = refineCalendarFields(e2, n2, en, o2);
+  return e2.dateFromFields(r2, t2);
+};
+var nt = function(e2, n2, t2, o2) {
+  const r2 = refineCalendarFields(e2, n2, fi, o2);
+  return e2.yearMonthFromFields(r2, t2);
+};
+var K = function(e2, n2, t2, o2, r2 = []) {
+  const i = refineCalendarFields(e2, t2, en, r2);
+  return n2 && i.month !== undefined && i.monthCode === undefined && i.year === undefined && (i.year = ji), e2.monthDayFromFields(i, o2);
+};
+var Ue = function(e2, n2) {
+  const t2 = H(n2);
+  return Ge(refineTimeBag(refineFields(e2, ei, [], 1), t2));
+};
+var Ht = function(e2) {
+  const n2 = refineFields(e2, Ni);
+  return Vt(checkDurationUnits({
+    ...Si,
+    ...n2
+  }));
+};
+var refineCalendarFields = function(e2, n2, t2, o2 = [], r2 = []) {
+  return refineFields(n2, [...e2.fields(t2), ...r2].sort(), o2);
+};
+var refineFields = function(e2, n2, t2, o2 = !t2) {
+  const r2 = {};
+  let i, a = 0;
+  for (const o3 of n2) {
+    if (o3 === i) {
+      throw new RangeError(duplicateFields(o3));
+    }
+    if (o3 === "constructor" || o3 === "__proto__") {
+      throw new RangeError(tn(o3));
+    }
+    let n3 = e2[o3];
+    if (n3 !== undefined) {
+      a = 1, Ga[o3] && (n3 = Ga[o3](n3, o3)), r2[o3] = n3;
+    } else if (t2) {
+      if (t2.includes(o3)) {
+        throw new TypeError(missingField(o3));
+      }
+      r2[o3] = hi[o3];
+    }
+    i = o3;
+  }
+  if (o2 && !a) {
+    throw new TypeError(noValidFields(n2));
+  }
+  return r2;
+};
+var refineTimeBag = function(e2, n2) {
+  return constrainIsoTimeFields(Ha({
+    ...hi,
+    ...e2
+  }), n2);
+};
+var Sn = function(e2, n2, t2, o2, r2, i) {
+  const a = U(i), { calendar: s2, timeZone: c3 } = t2;
+  return Yn(((e3, n3, t3, o3, r3) => {
+    const i2 = mergeCalendarFields(e3, t3, o3, en, oi, ni), [a2, s3, c4] = wn(r3, 2);
+    return getMatchingInstantFor(n3, {
+      ...e3.dateFromFields(i2, overrideOverflowOptions(r3, a2)),
+      ...refineTimeBag(i2, a2)
+    }, parseOffsetNano(i2.offset), s3, c4);
+  })(e2(s2), n2(c3), o2, r2, a), c3, s2);
+};
+var at = function(e2, n2, t2, o2, r2) {
+  const i = U(r2);
+  return ee(((e3, n3, t3, o3) => {
+    const r3 = mergeCalendarFields(e3, n3, t3, en, w), i2 = H(o3);
+    return checkIsoDateTimeInBounds({
+      ...e3.dateFromFields(r3, overrideOverflowOptions(o3, i2)),
+      ...refineTimeBag(r3, i2)
+    });
+  })(e2(n2.calendar), t2, o2, i));
+};
+var Zt = function(e2, n2, t2, o2, r2) {
+  const i = U(r2);
+  return ((e3, n3, t3, o3) => {
+    const r3 = mergeCalendarFields(e3, n3, t3, en);
+    return e3.dateFromFields(r3, o3);
+  })(e2(n2.calendar), t2, o2, i);
+};
+var Ke = function(e2, n2, t2, o2, r2) {
+  const i = U(r2);
+  return createPlainYearMonthSlots(((e3, n3, t3, o3) => {
+    const r3 = mergeCalendarFields(e3, n3, t3, fi);
+    return e3.yearMonthFromFields(r3, o3);
+  })(e2(n2.calendar), t2, o2, i));
+};
+var k = function(e2, n2, t2, o2, r2) {
+  const i = U(r2);
+  return ((e3, n3, t3, o3) => {
+    const r3 = mergeCalendarFields(e3, n3, t3, en);
+    return e3.monthDayFromFields(r3, o3);
+  })(e2(n2.calendar), t2, o2, i);
+};
+var Be = function(e2, n2, t2) {
+  return Ge(((e3, n3, t3) => {
+    const o2 = H(t3);
+    return refineTimeBag({
+      ...Vn(ei, e3),
+      ...refineFields(n3, ei)
+    }, o2);
+  })(e2, n2, t2));
+};
+var kt = function(e2, n2) {
+  return Vt((t2 = e2, o2 = n2, checkDurationUnits({
+    ...t2,
+    ...refineFields(o2, Ni)
+  })));
+  var t2, o2;
+};
+var mergeCalendarFields = function(e2, n2, t2, o2, r2 = [], i = []) {
+  const a = [...e2.fields(o2), ...r2].sort();
+  let s2 = refineFields(n2, a, i);
+  const c3 = refineFields(t2, a);
+  return s2 = e2.mergeFields(s2, c3), refineFields(s2, a, []);
+};
+var convertToPlainMonthDay = function(e2, n2) {
+  const t2 = refineCalendarFields(e2, n2, pi);
+  return e2.monthDayFromFields(t2);
+};
+var convertToPlainYearMonth = function(e2, n2, t2) {
+  const o2 = refineCalendarFields(e2, n2, di);
+  return e2.yearMonthFromFields(o2, t2);
+};
+var convertToIso = function(e2, n2, t2, o2, r2) {
+  n2 = Vn(t2 = e2.fields(t2), n2), o2 = refineFields(o2, r2 = e2.fields(r2), []);
+  let i = e2.mergeFields(n2, o2);
+  return i = refineFields(i, [...t2, ...r2].sort(), []), e2.dateFromFields(i);
+};
+var refineYear = function(e2, n2) {
+  let { era: t2, eraYear: o2, year: r2 } = n2;
+  const i = getCalendarEraOrigins(e2);
+  if (t2 !== undefined || o2 !== undefined) {
+    if (t2 === undefined || o2 === undefined) {
+      throw new TypeError(Dr);
+    }
+    if (!i) {
+      throw new RangeError(gr);
+    }
+    const e3 = i[t2];
+    if (e3 === undefined) {
+      throw new RangeError(invalidEra(t2));
+    }
+    const n3 = eraYearToYear(o2, e3);
+    if (r2 !== undefined && r2 !== n3) {
+      throw new RangeError(Ir);
+    }
+    r2 = n3;
+  } else if (r2 === undefined) {
+    throw new TypeError(missingYear(i));
+  }
+  return r2;
+};
+var refineMonth = function(e2, n2, t2, o2) {
+  let { month: r2, monthCode: i } = n2;
+  if (i !== undefined) {
+    const n3 = ((e3, n4, t3, o3) => {
+      const r3 = e3.U(t3), [i2, a] = parseMonthCode(n4);
+      let s2 = monthCodeNumberToMonth(i2, a, r3);
+      if (a) {
+        const n5 = getCalendarLeapMonthMeta(e3);
+        if (n5 === undefined) {
+          throw new RangeError(Pr);
+        }
+        if (n5 > 0) {
+          if (s2 > n5) {
+            throw new RangeError(Pr);
+          }
+          if (r3 === undefined) {
+            if (o3 === 1) {
+              throw new RangeError(Pr);
+            }
+            s2--;
+          }
+        } else {
+          if (s2 !== -n5) {
+            throw new RangeError(Pr);
+          }
+          if (r3 === undefined && o3 === 1) {
+            throw new RangeError(Pr);
+          }
+        }
+      }
+      return s2;
+    })(e2, i, t2, o2);
+    if (r2 !== undefined && r2 !== n3) {
+      throw new RangeError(Mr);
+    }
+    r2 = n3, o2 = 1;
+  } else if (r2 === undefined) {
+    throw new TypeError(Nr);
+  }
+  return clampEntity("month", r2, 1, e2.L(t2), o2);
+};
+var refineDay = function(e2, n2, t2, o2, r2) {
+  return clampProp(n2, "day", 1, e2.j(o2, t2), r2);
+};
+var spliceFields = function(e2, n2, t2, o2) {
+  let r2 = 0;
+  const i = [];
+  for (const e3 of t2) {
+    n2[e3] !== undefined ? r2 = 1 : i.push(e3);
+  }
+  if (Object.assign(e2, n2), r2) {
+    for (const n3 of o2 || i) {
+      delete e2[n3];
+    }
+  }
+};
+var Se = function(e2) {
+  return _(checkEpochNanoInBounds(bigIntToBigNano(toBigInt(e2))));
+};
+var vn = function(e2, n2, t2, o2, r2 = X) {
+  return Yn(checkEpochNanoInBounds(bigIntToBigNano(toBigInt(t2))), n2(o2), e2(r2));
+};
+var pt = function(e2, n2, t2, o2, r2 = 0, i = 0, a = 0, s2 = 0, c3 = 0, u2 = 0, l3 = X) {
+  return ee(checkIsoDateTimeInBounds(checkIsoDateTimeFields(T(toInteger, zipProps(wi, [n2, t2, o2, r2, i, a, s2, c3, u2])))), e2(l3));
+};
+var Nt = function(e2, n2, t2, o2, r2 = X) {
+  return v(checkIsoDateInBounds(checkIsoDateFields(T(toInteger, {
+    isoYear: n2,
+    isoMonth: t2,
+    isoDay: o2
+  }))), e2(r2));
+};
+var tt = function(e2, n2, t2, o2 = X, r2 = 1) {
+  const i = toInteger(n2), a = toInteger(t2), s2 = e2(o2);
+  return createPlainYearMonthSlots(checkIsoYearMonthInBounds(checkIsoDateFields({
+    isoYear: i,
+    isoMonth: a,
+    isoDay: toInteger(r2)
+  })), s2);
+};
+var G = function(e2, n2, t2, o2 = X, r2 = ji) {
+  const i = toInteger(n2), a = toInteger(t2), s2 = e2(o2);
+  return createPlainMonthDaySlots(checkIsoDateInBounds(checkIsoDateFields({
+    isoYear: toInteger(r2),
+    isoMonth: i,
+    isoDay: a
+  })), s2);
+};
+var ke = function(e2 = 0, n2 = 0, t2 = 0, o2 = 0, r2 = 0, i = 0) {
+  return Ge(constrainIsoTimeFields(T(toInteger, zipProps(j, [e2, n2, t2, o2, r2, i])), 1));
+};
+var Lt = function(e2 = 0, n2 = 0, t2 = 0, o2 = 0, r2 = 0, i = 0, a = 0, s2 = 0, c3 = 0, u2 = 0) {
+  return Vt(checkDurationUnits(T(toStrictInteger, zipProps(F, [e2, n2, t2, o2, r2, i, a, s2, c3, u2]))));
+};
+var fe = function(e2, n2, t2 = X) {
+  return Yn(e2.epochNanoseconds, n2, t2);
+};
+var Zn = function(e2) {
+  return _(e2.epochNanoseconds);
+};
+var ht = function(e2, n2) {
+  return ee(fn(n2, e2));
+};
+var Bt = function(e2, n2) {
+  return v(fn(n2, e2));
+};
+var bn = function(e2, n2, t2) {
+  return convertToPlainYearMonth(e2(n2.calendar), t2);
+};
+var Fn = function(e2, n2, t2) {
+  return convertToPlainMonthDay(e2(n2.calendar), t2);
+};
+var Re = function(e2, n2) {
+  return Ge(fn(n2, e2));
+};
+var mt = function(e2, n2, t2, o2) {
+  const r2 = ((e3, n3, t3, o3) => {
+    const r3 = ve(o3);
+    return we(e3(n3), t3, r3);
+  })(e2, t2, n2, o2);
+  return Yn(checkEpochNanoInBounds(r2), t2, n2.calendar);
+};
+var St = function(e2, n2, t2) {
+  const o2 = e2(n2.calendar);
+  return createPlainYearMonthSlots({
+    ...n2,
+    ...convertToPlainYearMonth(o2, t2)
+  });
+};
+var Ot = function(e2, n2, t2) {
+  return convertToPlainMonthDay(e2(n2.calendar), t2);
+};
+var vt = function(e2, n2, t2, o2, r2) {
+  const i = e2(r2.timeZone), a = r2.plainTime, s2 = a !== undefined ? n2(a) : Dt;
+  return Yn(we(t2(i), {
+    ...o2,
+    ...s2
+  }), i, o2.calendar);
+};
+var wt = function(e2, n2 = Dt) {
+  return ee(checkIsoDateTimeInBounds({
+    ...e2,
+    ...n2
+  }));
+};
+var jt = function(e2, n2, t2) {
+  return convertToPlainYearMonth(e2(n2.calendar), t2);
+};
+var Mt = function(e2, n2, t2) {
+  return convertToPlainMonthDay(e2(n2.calendar), t2);
+};
+var _e = function(e2, n2, t2, o2) {
+  return ((e3, n3, t3) => convertToIso(e3, n3, di, de(t3), li))(e2(n2.calendar), t2, o2);
+};
+var R = function(e2, n2, t2, o2) {
+  return ((e3, n3, t3) => convertToIso(e3, n3, pi, de(t3), si))(e2(n2.calendar), t2, o2);
+};
+var Je = function(e2, n2, t2, o2, r2) {
+  const i = de(r2), a = n2(i.plainDate), s2 = e2(i.timeZone);
+  return Yn(we(t2(s2), {
+    ...a,
+    ...o2
+  }), s2, a.calendar);
+};
+var Le = function(e2, n2) {
+  return ee(checkIsoDateTimeInBounds({
+    ...e2,
+    ...n2
+  }));
+};
+var De = function(e2) {
+  return _(checkEpochNanoInBounds(he(e2, _r)));
+};
+var Pe = function(e2) {
+  return _(checkEpochNanoInBounds(he(e2, be)));
+};
+var Ce = function(e2) {
+  return _(checkEpochNanoInBounds(bigIntToBigNano(toBigInt(e2), Vr)));
+};
+var ge = function(e2) {
+  return _(checkEpochNanoInBounds(bigIntToBigNano(toBigInt(e2))));
+};
+var pn = function(e2, n2, t2 = Dt) {
+  const o2 = n2.timeZone, r2 = e2(o2), i = {
+    ...fn(n2, r2),
+    ...t2
+  };
+  return Yn(getMatchingInstantFor(r2, i, i.offsetNanoseconds, 2), o2, n2.calendar);
+};
+var Tn = function(e2, n2, t2) {
+  const o2 = n2.timeZone, r2 = e2(o2), i = {
+    ...fn(n2, r2),
+    ...t2
+  }, a = getPreferredCalendarSlot(n2.calendar, t2.calendar);
+  return Yn(getMatchingInstantFor(r2, i, i.offsetNanoseconds, 2), o2, a);
+};
+var lt = function(e2, n2 = Dt) {
+  return ee({
+    ...e2,
+    ...n2
+  });
+};
+var st = function(e2, n2) {
+  return ee({
+    ...e2,
+    ...n2
+  }, getPreferredCalendarSlot(e2.calendar, n2.calendar));
+};
+var it = function(e2, n2) {
+  return {
+    ...e2,
+    calendar: n2
+  };
+};
+var On = function(e2, n2) {
+  return {
+    ...e2,
+    timeZone: n2
+  };
+};
+var getPreferredCalendarSlot = function(e2, n2) {
+  if (e2 === n2) {
+    return e2;
+  }
+  const t2 = I2(e2), o2 = I2(n2);
+  if (t2 === o2 || t2 === X) {
+    return n2;
+  }
+  if (o2 === X) {
+    return e2;
+  }
+  throw new RangeError(Er);
+};
+var createNativeOpsCreator = function(e2, n2) {
+  return (t2) => t2 === X ? e2 : t2 === gi || t2 === Ti ? Object.assign(Object.create(e2), {
+    id: t2
+  }) : Object.assign(Object.create(n2), Aa(t2));
+};
+var createOptionsTransformer = function(e2, n2, t2) {
+  const o2 = new Set(t2);
+  return (r2) => (((e3, n3) => {
+    for (const t3 of n3) {
+      if (t3 in e3) {
+        return 1;
+      }
+    }
+    return 0;
+  })(r2 = V2(o2, r2), e2) || Object.assign(r2, n2), t2 && (r2.timeZone = Ta, ["full", "long"].includes(r2.timeStyle) && (r2.timeStyle = "medium")), r2);
+};
+var e2 = function(e3, n2 = qn) {
+  const [t2, , , o2] = e3;
+  return (r2, i = Ns, ...a) => {
+    const s2 = n2(o2 && o2(...a), r2, i, t2), c3 = s2.resolvedOptions();
+    return [s2, ...toEpochMillis(e3, c3, a)];
+  };
+};
+var qn = function(e3, n2, t2, o2) {
+  if (t2 = o2(t2), e3) {
+    if (t2.timeZone !== undefined) {
+      throw new TypeError(Lr);
+    }
+    t2.timeZone = e3;
+  }
+  return new En(n2, t2);
+};
+var toEpochMillis = function(e3, n2, t2) {
+  const [, o2, r2] = e3;
+  return t2.map((e4) => (e4.calendar && ((e5, n3, t3) => {
+    if ((t3 || e5 !== X) && e5 !== n3) {
+      throw new RangeError(Er);
+    }
+  })(I2(e4.calendar), n2.calendar, r2), o2(e4, n2)));
+};
+var An = function(e3) {
+  const n2 = Bn();
+  return Ie(n2, e3.getOffsetNanosecondsFor(n2));
+};
+var Bn = function() {
+  return he(Date.now(), be);
+};
+var Nn = function() {
+  return ys || (ys = new En().resolvedOptions().timeZone);
+};
+var expectedInteger = (e3, n2) => `Non-integer ${e3}: ${n2}`;
+var expectedPositive = (e3, n2) => `Non-positive ${e3}: ${n2}`;
+var expectedFinite = (e3, n2) => `Non-finite ${e3}: ${n2}`;
+var forbiddenBigIntToNumber = (e3) => `Cannot convert bigint to ${e3}`;
+var invalidBigInt = (e3) => `Invalid bigint: ${e3}`;
+var pr = "Cannot convert Symbol to string";
+var hr = "Invalid object";
+var numberOutOfRange = (e3, n2, t2, o2, r2) => r2 ? numberOutOfRange(e3, r2[n2], r2[t2], r2[o2]) : invalidEntity(e3, n2) + `; must be between ${t2}-${o2}`;
+var invalidEntity = (e3, n2) => `Invalid ${e3}: ${n2}`;
+var missingField = (e3) => `Missing ${e3}`;
+var tn = (e3) => `Invalid field ${e3}`;
+var duplicateFields = (e3) => `Duplicate field ${e3}`;
+var noValidFields = (e3) => "No valid fields: " + e3.join();
+var Z = "Invalid bag";
+var invalidChoice = (e3, n2, t2) => invalidEntity(e3, n2) + "; must be " + Object.keys(t2).join();
+var A = "Cannot use valueOf";
+var P = "Invalid calling context";
+var gr = "Forbidden era/eraYear";
+var Dr = "Mismatching era/eraYear";
+var Ir = "Mismatching year/eraYear";
+var invalidEra = (e3) => `Invalid era: ${e3}`;
+var missingYear = (e3) => "Missing year" + (e3 ? "/era/eraYear" : "");
+var invalidMonthCode = (e3) => `Invalid monthCode: ${e3}`;
+var Mr = "Mismatching month/monthCode";
+var Nr = "Missing month/monthCode";
+var yr = "Cannot guess year";
+var Pr = "Invalid leap month";
+var g = "Invalid protocol";
+var vr = "Invalid protocol results";
+var Er = "Mismatching Calendars";
+var invalidCalendar = (e3) => `Invalid Calendar: ${e3}`;
+var Fr = "Mismatching TimeZones";
+var br = "Forbidden ICU TimeZone";
+var wr = "Out-of-bounds offset";
+var Br = "Out-of-bounds TimeZone gap";
+var kr = "Invalid TimeZone offset";
+var Yr = "Ambiguous offset";
+var Cr = "Out-of-bounds date";
+var Zr = "Out-of-bounds duration";
+var Rr = "Cannot mix duration signs";
+var zr = "Missing relativeTo";
+var qr = "Cannot use large units";
+var Ur = "Required smallestUnit or largestUnit";
+var Ar = "smallestUnit > largestUnit";
+var failedParse = (e3) => `Cannot parse: ${e3}`;
+var invalidSubstring = (e3) => `Invalid substring: ${e3}`;
+var Ln = (e3) => `Cannot format ${e3}`;
+var kn = "Mismatching types for formatting";
+var Lr = "Cannot specify TimeZone";
+var Wr = E(b, (e3, n2) => n2);
+var jr = E(b, (e3, n2, t2) => t2);
+var xr = E(padNumber, 2);
+var $r = {
+  nanosecond: 0,
+  microsecond: 1,
+  millisecond: 2,
+  second: 3,
+  minute: 4,
+  hour: 5,
+  day: 6,
+  week: 7,
+  month: 8,
+  year: 9
+};
+var Et = Object.keys($r);
+var Gr = 86400000;
+var Hr = 1000;
+var Vr = 1000;
+var be = 1e6;
+var _r = 1e9;
+var Jr = 60000000000;
+var Kr = 3600000000000;
+var Qr = 86400000000000;
+var Xr = [1, Vr, be, _r, Jr, Kr, Qr];
+var w = Et.slice(0, 6);
+var ei = sortStrings(w);
+var ni = ["offset"];
+var ti = ["timeZone"];
+var oi = w.concat(ni);
+var ri = oi.concat(ti);
+var ii = ["era", "eraYear"];
+var ai = ii.concat(["year"]);
+var si = ["year"];
+var ci = ["monthCode"];
+var ui = ["month"].concat(ci);
+var li = ["day"];
+var fi = ui.concat(si);
+var di = ci.concat(si);
+var en = li.concat(fi);
+var mi = li.concat(ui);
+var pi = li.concat(ci);
+var hi = jr(w, 0);
+var X = "iso8601";
+var gi = "gregory";
+var Ti = "japanese";
+var Di = {
+  [gi]: {
+    bce: -1,
+    ce: 0
+  },
+  [Ti]: {
+    bce: -1,
+    ce: 0,
+    meiji: 1867,
+    taisho: 1911,
+    showa: 1925,
+    heisei: 1988,
+    reiwa: 2018
+  },
+  ethioaa: {
+    era0: 0
+  },
+  ethiopic: {
+    era0: 0,
+    era1: 5500
+  },
+  coptic: {
+    era0: -1,
+    era1: 0
+  },
+  roc: {
+    beforeroc: -1,
+    minguo: 0
+  },
+  buddhist: {
+    be: 0
+  },
+  islamic: {
+    ah: 0
+  },
+  indian: {
+    saka: 0
+  },
+  persian: {
+    ap: 0
+  }
+};
+var Ii = {
+  chinese: 13,
+  dangi: 13,
+  hebrew: -6
+};
+var m = E(requireType, "string");
+var f = E(requireType, "boolean");
+var Mi = E(requireType, "number");
+var $ = E(requireType, "function");
+var F = Et.map((e3) => e3 + "s");
+var Ni = sortStrings(F);
+var yi = F.slice(0, 6);
+var Pi = F.slice(6);
+var vi = Pi.slice(1);
+var Ei = Wr(F);
+var Si = jr(F, 0);
+var Fi = jr(yi, 0);
+var bi = E(zeroOutProps, F);
+var j = ["isoNanosecond", "isoMicrosecond", "isoMillisecond", "isoSecond", "isoMinute", "isoHour"];
+var Oi = ["isoDay", "isoMonth", "isoYear"];
+var wi = j.concat(Oi);
+var Bi = sortStrings(Oi);
+var ki = sortStrings(j);
+var Yi = sortStrings(wi);
+var Dt = jr(ki, 0);
+var Ci = E(zeroOutProps, wi);
+var En = Intl.DateTimeFormat;
+var Zi = "en-GB";
+var Ri = 1e8;
+var zi = Ri * Gr;
+var qi = [Ri, 0];
+var Ui = [-Ri, 0];
+var Ai = 275760;
+var Li = -271821;
+var Wi = 1970;
+var ji = 1972;
+var xi = 12;
+var $i = isoArgsToEpochMilli(1868, 9, 8);
+var Gi = Jn(computeJapaneseEraParts, WeakMap);
+var Hi = "smallestUnit";
+var Vi = "unit";
+var _i = "roundingIncrement";
+var Ji = "fractionalSecondDigits";
+var Ki = "relativeTo";
+var Qi = {
+  constrain: 0,
+  reject: 1
+};
+var Xi = Object.keys(Qi);
+var ea = {
+  compatible: 0,
+  reject: 1,
+  earlier: 2,
+  later: 3
+};
+var na = {
+  reject: 0,
+  use: 1,
+  prefer: 2,
+  ignore: 3
+};
+var ta = {
+  auto: 0,
+  never: 1,
+  critical: 2,
+  always: 3
+};
+var oa = {
+  auto: 0,
+  never: 1,
+  critical: 2
+};
+var ra = {
+  auto: 0,
+  never: 1
+};
+var ia = {
+  floor: 0,
+  halfFloor: 1,
+  ceil: 2,
+  halfCeil: 3,
+  trunc: 4,
+  halfTrunc: 5,
+  expand: 6,
+  halfExpand: 7,
+  halfEven: 8
+};
+var aa = E(refineUnitOption, Hi);
+var sa = E(refineUnitOption, "largestUnit");
+var ca = E(refineUnitOption, Vi);
+var ua = E(refineChoiceOption, "overflow", Qi);
+var la = E(refineChoiceOption, "disambiguation", ea);
+var fa = E(refineChoiceOption, "offset", na);
+var da = E(refineChoiceOption, "calendarName", ta);
+var ma = E(refineChoiceOption, "timeZoneName", oa);
+var pa = E(refineChoiceOption, "offset", ra);
+var ha = E(refineChoiceOption, "roundingMode", ia);
+var L = "PlainYearMonth";
+var q = "PlainMonthDay";
+var J = "PlainDate";
+var We = "PlainDateTime";
+var xe = "PlainTime";
+var Te = "ZonedDateTime";
+var Oe = "Instant";
+var qt = "Duration";
+var ga = [Math.floor, (e3) => hasHalf(e3) ? Math.floor(e3) : Math.round(e3), Math.ceil, (e3) => hasHalf(e3) ? Math.ceil(e3) : Math.round(e3), Math.trunc, (e3) => hasHalf(e3) ? Math.trunc(e3) || 0 : Math.round(e3), (e3) => e3 < 0 ? Math.floor(e3) : Math.ceil(e3), (e3) => Math.sign(e3) * Math.round(Math.abs(e3)) || 0, (e3) => hasHalf(e3) ? (e3 = Math.trunc(e3) || 0) + e3 % 2 : Math.round(e3)];
+var Ta = "UTC";
+var Da = 5184000;
+var Ia = isoArgsToEpochSec(1847);
+var Ma = isoArgsToEpochSec((new Date()).getUTCFullYear() + 10);
+var Na = /0+$/;
+var fn = Jn(_zonedEpochSlotsToIso, WeakMap);
+var ya = 2 ** 32 - 1;
+var ie = Jn((e3) => {
+  const n2 = getTimeZoneEssence(e3);
+  return typeof n2 == "object" ? new IntlTimeZone(n2) : new FixedTimeZone(n2 || 0);
+});
+
+class FixedTimeZone {
+  constructor(e3) {
+    this.v = e3;
+  }
+  getOffsetNanosecondsFor() {
+    return this.v;
+  }
+  getPossibleInstantsFor(e3) {
+    return [isoToEpochNanoWithOffset(e3, this.v)];
+  }
+  l() {
+  }
+}
+
+class IntlTimeZone {
+  constructor(e3) {
+    this.$ = ((e4) => {
+      function getOffsetSec(e5) {
+        const i = clampNumber(e5, o2, r2), [a, s2] = computePeriod(i), c3 = n2(a), u2 = n2(s2);
+        return c3 === u2 ? c3 : pinch(t2(a, s2), c3, u2, e5);
+      }
+      function pinch(n3, t3, o3, r3) {
+        let i, a;
+        for (;(r3 === undefined || (i = r3 < n3[0] ? t3 : r3 >= n3[1] ? o3 : undefined) === undefined) && (a = n3[1] - n3[0]); ) {
+          const t4 = n3[0] + Math.floor(a / 2);
+          e4(t4) === o3 ? n3[1] = t4 : n3[0] = t4 + 1;
+        }
+        return i;
+      }
+      const n2 = Jn(e4), t2 = Jn(createSplitTuple);
+      let o2 = Ia, r2 = Ma;
+      return {
+        G(e5) {
+          const n3 = getOffsetSec(e5 - 86400), t3 = getOffsetSec(e5 + 86400), o3 = e5 - n3, r3 = e5 - t3;
+          if (n3 === t3) {
+            return [o3];
+          }
+          const i = getOffsetSec(o3);
+          return i === getOffsetSec(r3) ? [e5 - i] : n3 > t3 ? [o3, r3] : [];
+        },
+        V: getOffsetSec,
+        l(e5, i) {
+          const a = clampNumber(e5, o2, r2);
+          let [s2, c3] = computePeriod(a);
+          const u2 = Da * i, l3 = i < 0 ? () => c3 > o2 || (o2 = a, 0) : () => s2 < r2 || (r2 = a, 0);
+          for (;l3(); ) {
+            const o3 = n2(s2), r3 = n2(c3);
+            if (o3 !== r3) {
+              const n3 = t2(s2, c3);
+              pinch(n3, o3, r3);
+              const a2 = n3[0];
+              if ((compareNumbers(a2, e5) || 1) === i) {
+                return a2;
+              }
+            }
+            s2 += u2, c3 += u2;
+          }
+        }
+      };
+    })(((e4) => (n2) => {
+      const t2 = hashIntlFormatParts(e4, n2 * Hr);
+      return isoArgsToEpochSec(parseIntlPartsYear(t2), parseInt(t2.month), parseInt(t2.day), parseInt(t2.hour), parseInt(t2.minute), parseInt(t2.second)) - n2;
+    })(e3));
+  }
+  getOffsetNanosecondsFor(e3) {
+    return this.$.V(epochNanoToSec(e3)) * _r;
+  }
+  getPossibleInstantsFor(e3) {
+    const [n2, t2] = [isoArgsToEpochSec((o2 = e3).isoYear, o2.isoMonth, o2.isoDay, o2.isoHour, o2.isoMinute, o2.isoSecond), o2.isoMillisecond * be + o2.isoMicrosecond * Vr + o2.isoNanosecond];
+    var o2;
+    return this.$.G(n2).map((e4) => checkEpochNanoInBounds(moveBigNano(he(e4, _r), t2)));
+  }
+  l(e3, n2) {
+    const [t2, o2] = epochNanoToSecMod(e3), r2 = this.$.l(t2 + (n2 > 0 || o2 ? 1 : 0), n2);
+    if (r2 !== undefined) {
+      return he(r2, _r);
+    }
+  }
+}
+var Pa = "([+\u2212-])";
+var va = "(?:[.,](\\d{1,9}))?";
+var Ea = `(?:(?:${Pa}(\\d{6}))|(\\d{4}))-?(\\d{2})`;
+var Sa = "(\\d{2})(?::?(\\d{2})(?::?(\\d{2})" + va + ")?)?";
+var Fa = Pa + Sa;
+var ba = Ea + "-?(\\d{2})(?:[T ]" + Sa + "(Z|" + Fa + ")?)?";
+var Oa = "\\[(!?)([^\\]]*)\\]";
+var wa = `((?:${Oa}){0,9})`;
+var Ba = createRegExp(Ea + wa);
+var ka = createRegExp("(?:--)?(\\d{2})-?(\\d{2})" + wa);
+var Ya = createRegExp(ba + wa);
+var Ca = createRegExp("T?" + Sa + "(?:" + Fa + ")?" + wa);
+var Za = createRegExp(Fa);
+var Ra = new RegExp(Oa, "g");
+var za = createRegExp(`${Pa}?P(\\d+Y)?(\\d+M)?(\\d+W)?(\\d+D)?(?:T(?:(\\d+)${va}H)?(?:(\\d+)${va}M)?(?:(\\d+)${va}S)?)?`);
+var qa = Jn((e3) => new En(Zi, {
+  timeZone: e3,
+  era: "short",
+  year: "numeric",
+  month: "numeric",
+  day: "numeric",
+  hour: "numeric",
+  minute: "numeric",
+  second: "numeric"
+}));
+var Ua = /^(AC|AE|AG|AR|AS|BE|BS|CA|CN|CS|CT|EA|EC|IE|IS|JS|MI|NE|NS|PL|PN|PR|PS|SS|VS)T$/;
+var Aa = Jn(createIntlCalendar);
+var La = Jn((e3) => new En(Zi, {
+  calendar: e3,
+  timeZone: Ta,
+  era: "short",
+  year: "numeric",
+  month: "short",
+  day: "numeric"
+}));
+var Wa = /^M(\d{2})(L?)$/;
+var ja = {
+  era: toStringViaPrimitive,
+  eraYear: toInteger,
+  year: toInteger,
+  month: toPositiveInteger,
+  monthCode: toStringViaPrimitive,
+  day: toPositiveInteger
+};
+var xa = jr(w, toInteger);
+var $a = jr(F, toStrictInteger);
+var Ga = Object.assign({}, ja, xa, $a, {
+  offset: toStringViaPrimitive
+});
+var Ha = E(remapProps, w, j);
+var Va = {
+  dateAdd(e3, n2, t2) {
+    const o2 = H(t2);
+    let r2, { years: i, months: a, weeks: s2, days: c3 } = n2;
+    if (c3 += durationFieldsToBigNano(n2, 5)[0], i || a) {
+      r2 = ((e4, n3, t3, o3, r3) => {
+        let [i2, a2, s3] = e4.h(n3);
+        if (t3) {
+          const [n4, o4] = e4.I(i2, a2);
+          i2 += t3, a2 = monthCodeNumberToMonth(n4, o4, e4.U(i2)), a2 = clampEntity("month", a2, 1, e4.L(i2), r3);
+        }
+        return o3 && ([i2, a2] = e4._(i2, a2, o3)), s3 = clampEntity("day", s3, 1, e4.j(i2, a2), r3), e4.q(i2, a2, s3);
+      })(this, e3, i, a, o2);
+    } else {
+      if (!s2 && !c3) {
+        return e3;
+      }
+      r2 = isoToEpochMilli(e3);
+    }
+    return r2 += (7 * s2 + c3) * Gr, checkIsoDateInBounds(epochMilliToIso(r2));
+  },
+  dateUntil(e3, n2, t2) {
+    if (t2 <= 7) {
+      let o3 = 0, r3 = diffDays({
+        ...e3,
+        ...Dt
+      }, {
+        ...n2,
+        ...Dt
+      });
+      return t2 === 7 && ([o3, r3] = divModTrunc(r3, 7)), {
+        ...Si,
+        weeks: o3,
+        days: r3
+      };
+    }
+    const o2 = this.h(e3), r2 = this.h(n2);
+    let [i, a, s2] = ((e4, n3, t3, o3, r3, i2, a2) => {
+      let s3 = r3 - n3, c3 = i2 - t3, u2 = a2 - o3;
+      if (s3 || c3) {
+        const l3 = Math.sign(s3 || c3);
+        let f2 = e4.j(r3, i2), d2 = 0;
+        if (Math.sign(u2) === -l3) {
+          const o4 = f2;
+          [r3, i2] = e4._(r3, i2, -l3), s3 = r3 - n3, c3 = i2 - t3, f2 = e4.j(r3, i2), d2 = l3 < 0 ? -o4 : f2;
+        }
+        if (u2 = a2 - Math.min(o3, f2) + d2, s3) {
+          const [o4, a3] = e4.I(n3, t3), [u3, f3] = e4.I(r3, i2);
+          if (c3 = u3 - o4 || Number(f3) - Number(a3), Math.sign(c3) === -l3) {
+            const t4 = l3 < 0 && -e4.L(r3);
+            s3 = (r3 -= l3) - n3, c3 = i2 - monthCodeNumberToMonth(o4, a3, e4.U(r3)) + (t4 || e4.L(r3));
+          }
+        }
+      }
+      return [s3, c3, u2];
+    })(this, ...o2, ...r2);
+    return t2 === 8 && (a += this.J(i, o2[0]), i = 0), {
+      ...Si,
+      years: i,
+      months: a,
+      days: s2
+    };
+  },
+  dateFromFields(e3, n2) {
+    const t2 = H(n2), o2 = refineYear(this, e3), r2 = refineMonth(this, e3, o2, t2), i = refineDay(this, e3, r2, o2, t2);
+    return v(checkIsoDateInBounds(this.P(o2, r2, i)), this.id || X);
+  },
+  yearMonthFromFields(e3, n2) {
+    const t2 = H(n2), o2 = refineYear(this, e3), r2 = refineMonth(this, e3, o2, t2);
+    return createPlainYearMonthSlots(checkIsoYearMonthInBounds(this.P(o2, r2, 1)), this.id || X);
+  },
+  monthDayFromFields(e3, n2) {
+    const t2 = H(n2), o2 = !this.id, { monthCode: r2, year: i, month: a } = e3;
+    let s2, c3, u2, l3, f2;
+    if (r2 !== undefined) {
+      [s2, c3] = parseMonthCode(r2), f2 = getDefinedProp(e3, "day");
+      const n3 = this.N(s2, c3, f2);
+      if (!n3) {
+        throw new RangeError(yr);
+      }
+      if ([u2, l3] = n3, a !== undefined && a !== l3) {
+        throw new RangeError(Mr);
+      }
+      o2 && (l3 = clampEntity("month", l3, 1, xi, 1), f2 = clampEntity("day", f2, 1, computeIsoDaysInMonth(i !== undefined ? i : u2, l3), t2));
+    } else {
+      u2 = i === undefined && o2 ? ji : refineYear(this, e3), l3 = refineMonth(this, e3, u2, t2), f2 = refineDay(this, e3, l3, u2, t2);
+      const n3 = this.U(u2);
+      c3 = l3 === n3, s2 = monthToMonthCodeNumber(l3, n3);
+      const r3 = this.N(s2, c3, f2);
+      if (!r3) {
+        throw new RangeError(yr);
+      }
+      [u2, l3] = r3;
+    }
+    return createPlainMonthDaySlots(checkIsoDateInBounds(this.P(u2, l3, f2)), this.id || X);
+  },
+  fields(e3) {
+    return getCalendarEraOrigins(this) && e3.includes("year") ? [...e3, ...ii] : e3;
+  },
+  mergeFields(e3, n2) {
+    const t2 = Object.assign(Object.create(null), e3);
+    return spliceFields(t2, n2, ui), getCalendarEraOrigins(this) && (spliceFields(t2, n2, ai), this.id === Ti && spliceFields(t2, n2, mi, ii)), t2;
+  },
+  inLeapYear(e3) {
+    const [n2] = this.h(e3);
+    return this.K(n2);
+  },
+  monthsInYear(e3) {
+    const [n2] = this.h(e3);
+    return this.L(n2);
+  },
+  daysInMonth(e3) {
+    const [n2, t2] = this.h(e3);
+    return this.j(n2, t2);
+  },
+  daysInYear(e3) {
+    const [n2] = this.h(e3);
+    return this.X(n2);
+  },
+  dayOfYear: computeNativeDayOfYear,
+  era(e3) {
+    return this.ee(e3)[0];
+  },
+  eraYear(e3) {
+    return this.ee(e3)[1];
+  },
+  monthCode(e3) {
+    const [n2, t2] = this.h(e3), [o2, r2] = this.I(n2, t2);
+    return ((e4, n3) => "M" + xr(e4) + (n3 ? "L" : ""))(o2, r2);
+  },
+  dayOfWeek: computeIsoDayOfWeek,
+  daysInWeek() {
+    return 7;
+  }
+};
+var _a2 = {
+  dayOfYear: computeNativeDayOfYear,
+  h: computeIsoDateParts,
+  q: isoArgsToEpochMilli
+};
+var Ja = Object.assign({}, _a2, {
+  weekOfYear: computeNativeWeekOfYear,
+  yearOfWeek: computeNativeYearOfWeek,
+  R(e3) {
+    function computeWeekShift(e4) {
+      return (7 - e4 < n2 ? 7 : 0) - e4;
+    }
+    function computeWeeksInYear(e4) {
+      const n3 = computeIsoDaysInYear(l3 + e4), t3 = e4 || 1, o3 = computeWeekShift(modFloor(a + n3 * t3, 7));
+      return c3 = (n3 + (o3 - s2) * t3) / 7;
+    }
+    const n2 = this.id ? 1 : 4, t2 = computeIsoDayOfWeek(e3), o2 = this.dayOfYear(e3), r2 = modFloor(t2 - 1, 7), i = o2 - 1, a = modFloor(r2 - i, 7), s2 = computeWeekShift(a);
+    let c3, u2 = Math.floor((i - s2) / 7) + 1, l3 = e3.isoYear;
+    return u2 ? u2 > computeWeeksInYear(0) && (u2 = 1, l3++) : (u2 = computeWeeksInYear(-1), l3--), [u2, l3, c3];
+  }
+});
+var Ka = {
+  dayOfYear: computeNativeDayOfYear,
+  h: computeIntlDateParts,
+  q: computeIntlEpochMilli,
+  weekOfYear: computeNativeWeekOfYear,
+  yearOfWeek: computeNativeYearOfWeek,
+  R() {
+    return [];
+  }
+};
+var Y = createNativeOpsCreator(Object.assign({}, Va, Ja, {
+  h: computeIsoDateParts,
+  ee(e3) {
+    return this.id === gi ? computeGregoryEraParts(e3) : this.id === Ti ? Gi(e3) : [];
+  },
+  I: (e3, n2) => [n2, 0],
+  N(e3, n2) {
+    if (!n2) {
+      return [ji, e3];
+    }
+  },
+  K: computeIsoInLeapYear,
+  U() {
+  },
+  L: computeIsoMonthsInYear,
+  J: (e3) => e3 * xi,
+  j: computeIsoDaysInMonth,
+  X: computeIsoDaysInYear,
+  P: (e3, n2, t2) => ({
+    isoYear: e3,
+    isoMonth: n2,
+    isoDay: t2
+  }),
+  q: isoArgsToEpochMilli,
+  _: (e3, n2, t2) => (e3 += divTrunc(t2, xi), (n2 += modTrunc(t2, xi)) < 1 ? (e3--, n2 += xi) : n2 > xi && (e3++, n2 -= xi), [e3, n2]),
+  year(e3) {
+    return e3.isoYear;
+  },
+  month(e3) {
+    return e3.isoMonth;
+  },
+  day: (e3) => e3.isoDay
+}), Object.assign({}, Va, Ka, {
+  h: computeIntlDateParts,
+  ee(e3) {
+    const n2 = this.O(e3);
+    return [n2.era, n2.eraYear];
+  },
+  I(e3, n2) {
+    const t2 = computeIntlLeapMonth.call(this, e3);
+    return [monthToMonthCodeNumber(n2, t2), t2 === n2];
+  },
+  N(e3, n2, t2) {
+    let [o2, r2, i] = computeIntlDateParts.call(this, {
+      isoYear: ji,
+      isoMonth: xi,
+      isoDay: 31
+    });
+    const a = computeIntlLeapMonth.call(this, o2), s2 = r2 === a;
+    (compareNumbers(e3, monthToMonthCodeNumber(r2, a)) || compareNumbers(Number(n2), Number(s2)) || compareNumbers(t2, i)) === 1 && o2--;
+    for (let r3 = 0;r3 < 100; r3++) {
+      const i2 = o2 - r3, a2 = computeIntlLeapMonth.call(this, i2), s3 = monthCodeNumberToMonth(e3, n2, a2);
+      if (n2 === (s3 === a2) && t2 <= computeIntlDaysInMonth.call(this, i2, s3)) {
+        return [i2, s3];
+      }
+    }
+  },
+  K(e3) {
+    const n2 = computeIntlDaysInYear.call(this, e3);
+    return n2 > computeIntlDaysInYear.call(this, e3 - 1) && n2 > computeIntlDaysInYear.call(this, e3 + 1);
+  },
+  U: computeIntlLeapMonth,
+  L: computeIntlMonthsInYear,
+  J(e3, n2) {
+    const t2 = n2 + e3, o2 = Math.sign(e3), r2 = o2 < 0 ? -1 : 0;
+    let i = 0;
+    for (let e4 = n2;e4 !== t2; e4 += o2) {
+      i += computeIntlMonthsInYear.call(this, e4 + r2);
+    }
+    return i;
+  },
+  j: computeIntlDaysInMonth,
+  X: computeIntlDaysInYear,
+  P(e3, n2, t2) {
+    return epochMilliToIso(computeIntlEpochMilli.call(this, e3, n2, t2));
+  },
+  q: computeIntlEpochMilli,
+  _(e3, n2, t2) {
+    if (t2) {
+      if (n2 += t2, !Number.isSafeInteger(n2)) {
+        throw new RangeError(Cr);
+      }
+      if (t2 < 0) {
+        for (;n2 < 1; ) {
+          n2 += computeIntlMonthsInYear.call(this, --e3);
+        }
+      } else {
+        let t3;
+        for (;n2 > (t3 = computeIntlMonthsInYear.call(this, e3)); ) {
+          n2 -= t3, e3++;
+        }
+      }
+    }
+    return [e3, n2];
+  },
+  year(e3) {
+    return this.O(e3).year;
+  },
+  month(e3) {
+    const { year: n2, F: t2 } = this.O(e3), { C: o2 } = this.B(n2);
+    return o2[t2] + 1;
+  },
+  day(e3) {
+    return this.O(e3).day;
+  }
+}));
+var Qa = "numeric";
+var Xa = ["timeZoneName"];
+var es = {
+  month: Qa,
+  day: Qa
+};
+var ns = {
+  year: Qa,
+  month: Qa
+};
+var ts = Object.assign({}, ns, {
+  day: Qa
+});
+var os = {
+  hour: Qa,
+  minute: Qa,
+  second: Qa
+};
+var rs = Object.assign({}, ts, os);
+var is = Object.assign({}, rs, {
+  timeZoneName: "short"
+});
+var as = Object.keys(ns);
+var ss = Object.keys(es);
+var cs = Object.keys(ts);
+var us = Object.keys(os);
+var ls = ["dateStyle"];
+var fs = as.concat(ls);
+var ds = ss.concat(ls);
+var ms = cs.concat(ls, ["weekday"]);
+var ps = us.concat(["dayPeriod", "timeStyle"]);
+var hs = ms.concat(ps);
+var gs = hs.concat(Xa);
+var Ts = Xa.concat(ps);
+var Ds = Xa.concat(ms);
+var Is = Xa.concat(["day", "weekday"], ps);
+var Ms = Xa.concat(["year", "weekday"], ps);
+var Ns = {};
+var t2 = [createOptionsTransformer(hs, rs), y];
+var s2 = [createOptionsTransformer(gs, is), y, 0, (e3, n2) => {
+  const t3 = I2(e3.timeZone);
+  if (n2 && I2(n2.timeZone) !== t3) {
+    throw new RangeError(Fr);
+  }
+  return t3;
+}];
+var n2 = [createOptionsTransformer(hs, rs, Xa), isoToEpochMilli];
+var o2 = [createOptionsTransformer(ms, ts, Ts), isoToEpochMilli];
+var r2 = [createOptionsTransformer(ps, os, Ds), (e3) => isoTimeFieldsToNano(e3) / be];
+var a = [createOptionsTransformer(fs, ns, Is), isoToEpochMilli, 1];
+var i = [createOptionsTransformer(ds, es, Ms), isoToEpochMilli, 1];
+var ys;
+
+// ../../node_modules/temporal-polyfill/chunks/classApi.js
+var xn = {
+  Instant: t2,
+  PlainDateTime: n2,
+  PlainDate: o2,
+  PlainTime: r2,
+  PlainYearMonth: a,
+  PlainMonthDay: i
+};
+var Rn = e2(t2);
+var Wn = e2(s2);
+var Gn = e2(n2);
+var Un = e2(o2);
+var zn = e2(r2);
+var Hn = e2(a);
+var Kn = e2(i);
+var Qn = {
+  era: l2,
+  eraYear: c2,
+  year: u,
+  month: d,
+  daysInMonth: d,
+  daysInYear: d,
+  inLeapYear: f,
+  monthsInYear: d
+};
+var Xn = {
+  monthCode: m
+};
+var $n = {
+  day: d
+};
+var _n = {
+  dayOfWeek: d,
+  dayOfYear: d,
+  weekOfYear: S,
+  yearOfWeek: c2,
+  daysInWeek: d
+};
+var eo = Object.assign({}, Qn, Xn, $n, _n);
+var to = new WeakMap;
+var no = to.get.bind(to);
+var oo = to.set.bind(to);
+var ro = {
+  ...createCalendarFieldMethods(Qn, [L]),
+  ...createCalendarFieldMethods(_n, []),
+  ...createCalendarFieldMethods(Xn, [L, q]),
+  ...createCalendarFieldMethods($n, [q])
+};
+var ao = createCalendarGetters(eo);
+var io = createCalendarGetters({
+  ...Qn,
+  ...Xn
+});
+var so = createCalendarGetters({
+  ...Xn,
+  ...$n
+});
+var lo = {
+  calendarId: (e3) => I2(e3.calendar)
+};
+var co = T((e3, t3) => function(n3) {
+  const { i: o3 } = this;
+  return e3(o3[t3](Yo(v(n3, o3))));
+}, eo);
+var uo = b((e3) => (t3) => t3[e3], F.concat("sign"));
+var fo = b((e3, t3) => (e4) => e4[j[t3]], w);
+var mo = {
+  epochSeconds: M,
+  epochMilliseconds: y,
+  epochMicroseconds: N,
+  epochNanoseconds: B
+};
+var So = E(V2, new Set(["branding"]));
+var [Oo, To, po] = createSlotClass(q, E(G, refineCalendarSlot), {
+  ...lo,
+  ...so
+}, {
+  getISOFields: So,
+  getCalendar: createCalendarFromSlots,
+  with(e3, t3, n3) {
+    return To(k(_o, e3, this, rejectInvalidBag(t3), n3));
+  },
+  equals: (e3, t3) => x(e3, toPlainMonthDaySlots(t3)),
+  toPlainDate(e3, t3) {
+    return Yo(R($o, e3, this, t3));
+  },
+  toLocaleString(e3, t3, n3) {
+    const [o3, r3] = Kn(t3, n3, e3);
+    return o3.format(r3);
+  },
+  toString: W,
+  toJSON: (e3) => W(e3),
+  valueOf: neverValueOf
+}, {
+  from: (e3, t3) => To(toPlainMonthDaySlots(e3, t3))
+});
+var ho = {
+  getOffsetNanosecondsFor: getOffsetNanosecondsForAdapter,
+  getPossibleInstantsFor(e3, t3, n3) {
+    const o3 = [...t3.call(e3, No(ee(n3, X)))].map((e4) => go(e4).epochNanoseconds), r3 = o3.length;
+    return r3 > 1 && (o3.sort(te), ne(oe(re(o3[0], o3[r3 - 1])))), o3;
+  }
+};
+var Do = {
+  getOffsetNanosecondsFor: getOffsetNanosecondsForAdapter
+};
+var [Po, Co, go] = createSlotClass(Oe, Se, mo, {
+  add: (e3, t3) => Co(se(0, e3, toDurationSlots(t3))),
+  subtract: (e3, t3) => Co(se(1, e3, toDurationSlots(t3))),
+  until: (e3, t3, n3) => ar(le(0, e3, toInstantSlots(t3), n3)),
+  since: (e3, t3, n3) => ar(le(1, e3, toInstantSlots(t3), n3)),
+  round: (e3, t3) => Co(ce(e3, t3)),
+  equals: (e3, t3) => ue(e3, toInstantSlots(t3)),
+  toZonedDateTime(e3, t3) {
+    const n3 = de(t3);
+    return dr(fe(e3, refineTimeZoneSlot(n3.timeZone), refineCalendarSlot(n3.calendar)));
+  },
+  toZonedDateTimeISO: (e3, t3) => dr(fe(e3, refineTimeZoneSlot(t3))),
+  toLocaleString(e3, t3, n3) {
+    const [o3, r3] = Rn(t3, n3, e3);
+    return o3.format(r3);
+  },
+  toString: (e3, t3) => me(refineTimeZoneSlot, createTimeZoneOffsetOps, e3, t3),
+  toJSON: (e3) => me(refineTimeZoneSlot, createTimeZoneOffsetOps, e3),
+  valueOf: neverValueOf
+}, {
+  from: (e3) => Co(toInstantSlots(e3)),
+  fromEpochSeconds: (e3) => Co(De(e3)),
+  fromEpochMilliseconds: (e3) => Co(Pe(e3)),
+  fromEpochMicroseconds: (e3) => Co(Ce(e3)),
+  fromEpochNanoseconds: (e3) => Co(ge(e3)),
+  compare: (e3, t3) => Ze(toInstantSlots(e3), toInstantSlots(t3))
+});
+var [Zo, bo] = createSlotClass("TimeZone", (e3) => {
+  const t3 = Me(e3);
+  return {
+    branding: "TimeZone",
+    id: t3,
+    o: ie(t3)
+  };
+}, {
+  id: (e3) => e3.id
+}, {
+  getPossibleInstantsFor: ({ o: e3 }, t3) => e3.getPossibleInstantsFor(toPlainDateTimeSlots(t3)).map((e4) => Co(_(e4))),
+  getOffsetNanosecondsFor: ({ o: e3 }, t3) => e3.getOffsetNanosecondsFor(toInstantSlots(t3).epochNanoseconds),
+  getOffsetStringFor(e3, t3) {
+    const n3 = toInstantSlots(t3).epochNanoseconds, o3 = createAdapterOps(this, Do).getOffsetNanosecondsFor(n3);
+    return Fe(o3);
+  },
+  getPlainDateTimeFor(e3, t3, n3 = X) {
+    const o3 = toInstantSlots(t3).epochNanoseconds, r3 = createAdapterOps(this, Do).getOffsetNanosecondsFor(o3);
+    return No(ee(Ie(o3, r3), refineCalendarSlot(n3)));
+  },
+  getInstantFor(e3, t3, n3) {
+    const o3 = toPlainDateTimeSlots(t3), r3 = ve(n3), a2 = createAdapterOps(this);
+    return Co(_(we(a2, o3, r3)));
+  },
+  getNextTransition: ({ o: e3 }, t3) => getImplTransition(1, e3, t3),
+  getPreviousTransition: ({ o: e3 }, t3) => getImplTransition(-1, e3, t3),
+  equals(e3, t3) {
+    return !!je(this, refineTimeZoneSlot(t3));
+  },
+  toString: (e3) => e3.id,
+  toJSON: (e3) => e3.id
+}, {
+  from(e3) {
+    const t3 = refineTimeZoneSlot(e3);
+    return typeof t3 == "string" ? new Zo(t3) : t3;
+  }
+});
+var Fo = createProtocolValidator(Object.keys(ho));
+var [Io, vo] = createSlotClass(xe, ke, fo, {
+  getISOFields: So,
+  with(e3, t3, n3) {
+    return vo(Be(this, rejectInvalidBag(t3), n3));
+  },
+  add: (e3, t3) => vo(Ye(0, e3, toDurationSlots(t3))),
+  subtract: (e3, t3) => vo(Ye(1, e3, toDurationSlots(t3))),
+  until: (e3, t3, n3) => ar(Ae(0, e3, toPlainTimeSlots(t3), n3)),
+  since: (e3, t3, n3) => ar(Ae(1, e3, toPlainTimeSlots(t3), n3)),
+  round: (e3, t3) => vo(Ee(e3, t3)),
+  equals: (e3, t3) => Ve(e3, toPlainTimeSlots(t3)),
+  toZonedDateTime: (e3, t3) => dr(Je(refineTimeZoneSlot, toPlainDateSlots, createTimeZoneOps, e3, t3)),
+  toPlainDateTime: (e3, t3) => No(Le(e3, toPlainDateSlots(t3))),
+  toLocaleString(e3, t3, n3) {
+    const [o3, r3] = zn(t3, n3, e3);
+    return o3.format(r3);
+  },
+  toString: qe,
+  toJSON: (e3) => qe(e3),
+  valueOf: neverValueOf
+}, {
+  from: (e3, t3) => vo(toPlainTimeSlots(e3, t3)),
+  compare: (e3, t3) => He(toPlainTimeSlots(e3), toPlainTimeSlots(t3))
+});
+var [wo, jo, Mo] = createSlotClass(L, E(tt, refineCalendarSlot), {
+  ...lo,
+  ...io
+}, {
+  getISOFields: So,
+  getCalendar: createCalendarFromSlots,
+  with(e3, t3, n3) {
+    return jo(Ke(Xo, e3, this, rejectInvalidBag(t3), n3));
+  },
+  add: (e3, t3, n3) => jo(Qe(nr, 0, e3, toDurationSlots(t3), n3)),
+  subtract: (e3, t3, n3) => jo(Qe(nr, 1, e3, toDurationSlots(t3), n3)),
+  until: (e3, t3, n3) => ar(Xe(or, 0, e3, toPlainYearMonthSlots(t3), n3)),
+  since: (e3, t3, n3) => ar(Xe(or, 1, e3, toPlainYearMonthSlots(t3), n3)),
+  equals: (e3, t3) => $e(e3, toPlainYearMonthSlots(t3)),
+  toPlainDate(e3, t3) {
+    return Yo(_e($o, e3, this, t3));
+  },
+  toLocaleString(e3, t3, n3) {
+    const [o3, r3] = Hn(t3, n3, e3);
+    return o3.format(r3);
+  },
+  toString: et,
+  toJSON: (e3) => et(e3),
+  valueOf: neverValueOf
+}, {
+  from: (e3, t3) => jo(toPlainYearMonthSlots(e3, t3)),
+  compare: (e3, t3) => rt(toPlainYearMonthSlots(e3), toPlainYearMonthSlots(t3))
+});
+var [yo, No] = createSlotClass(We, E(pt, refineCalendarSlot), {
+  ...lo,
+  ...ao,
+  ...fo
+}, {
+  getISOFields: So,
+  getCalendar: createCalendarFromSlots,
+  with(e3, t3, n3) {
+    return No(at($o, e3, this, rejectInvalidBag(t3), n3));
+  },
+  withCalendar: (e3, t3) => No(it(e3, refineCalendarSlot(t3))),
+  withPlainDate: (e3, t3) => No(st(e3, toPlainDateSlots(t3))),
+  withPlainTime: (e3, t3) => No(lt(e3, optionalToPlainTimeFields(t3))),
+  add: (e3, t3, n3) => No(ct(er, 0, e3, toDurationSlots(t3), n3)),
+  subtract: (e3, t3, n3) => No(ct(er, 1, e3, toDurationSlots(t3), n3)),
+  until: (e3, t3, n3) => ar(ut(tr, 0, e3, toPlainDateTimeSlots(t3), n3)),
+  since: (e3, t3, n3) => ar(ut(tr, 1, e3, toPlainDateTimeSlots(t3), n3)),
+  round: (e3, t3) => No(dt(e3, t3)),
+  equals: (e3, t3) => ft(e3, toPlainDateTimeSlots(t3)),
+  toZonedDateTime: (e3, t3, n3) => dr(mt(createTimeZoneOps, e3, refineTimeZoneSlot(t3), n3)),
+  toPlainDate: (e3) => Yo(v(e3)),
+  toPlainTime: (e3) => vo(Ge(e3)),
+  toPlainYearMonth(e3) {
+    return jo(St(Ho, e3, this));
+  },
+  toPlainMonthDay(e3) {
+    return To(Ot(Qo, e3, this));
+  },
+  toLocaleString(e3, t3, n3) {
+    const [o3, r3] = Gn(t3, n3, e3);
+    return o3.format(r3);
+  },
+  toString: Tt,
+  toJSON: (e3) => Tt(e3),
+  valueOf: neverValueOf
+}, {
+  from: (e3, t3) => No(toPlainDateTimeSlots(e3, t3)),
+  compare: (e3, t3) => gt(toPlainDateTimeSlots(e3), toPlainDateTimeSlots(t3))
+});
+var [Bo, Yo, Ao] = createSlotClass(J, E(Nt, refineCalendarSlot), {
+  ...lo,
+  ...ao
+}, {
+  getISOFields: So,
+  getCalendar: createCalendarFromSlots,
+  with(e3, t3, n3) {
+    return Yo(Zt($o, e3, this, rejectInvalidBag(t3), n3));
+  },
+  withCalendar: (e3, t3) => Yo(it(e3, refineCalendarSlot(t3))),
+  add: (e3, t3, n3) => Yo(bt(er, 0, e3, toDurationSlots(t3), n3)),
+  subtract: (e3, t3, n3) => Yo(bt(er, 1, e3, toDurationSlots(t3), n3)),
+  until: (e3, t3, n3) => ar(Ft(tr, 0, e3, toPlainDateSlots(t3), n3)),
+  since: (e3, t3, n3) => ar(Ft(tr, 1, e3, toPlainDateSlots(t3), n3)),
+  equals: (e3, t3) => It(e3, toPlainDateSlots(t3)),
+  toZonedDateTime(e3, t3) {
+    const n3 = !z(t3) || t3 instanceof Zo ? {
+      timeZone: t3
+    } : t3;
+    return dr(vt(refineTimeZoneSlot, toPlainTimeSlots, createTimeZoneOps, e3, n3));
+  },
+  toPlainDateTime: (e3, t3) => No(wt(e3, optionalToPlainTimeFields(t3))),
+  toPlainYearMonth(e3) {
+    return jo(jt(Ho, e3, this));
+  },
+  toPlainMonthDay(e3) {
+    return To(Mt(Qo, e3, this));
+  },
+  toLocaleString(e3, t3, n3) {
+    const [o3, r3] = Un(t3, n3, e3);
+    return o3.format(r3);
+  },
+  toString: yt,
+  toJSON: (e3) => yt(e3),
+  valueOf: neverValueOf
+}, {
+  from: (e3, t3) => Yo(toPlainDateSlots(e3, t3)),
+  compare: (e3, t3) => rt(toPlainDateSlots(e3), toPlainDateSlots(t3))
+});
+var Eo = {
+  fields(e3, t3, n3) {
+    return [...t3.call(e3, n3)];
+  }
+};
+var Vo = Object.assign({
+  dateFromFields(e3, t3, n3, o3) {
+    return Ao(t3.call(e3, Object.assign(Object.create(null), n3), o3));
+  }
+}, Eo);
+var Jo = Object.assign({
+  yearMonthFromFields(e3, t3, n3, o3) {
+    return Mo(t3.call(e3, Object.assign(Object.create(null), n3), o3));
+  }
+}, Eo);
+var Lo = Object.assign({
+  monthDayFromFields(e3, t3, n3, o3) {
+    return po(t3.call(e3, Object.assign(Object.create(null), n3), o3));
+  }
+}, Eo);
+var qo = {
+  mergeFields(e3, t3, n3, o3) {
+    return de(t3.call(e3, Object.assign(Object.create(null), n3), Object.assign(Object.create(null), o3)));
+  }
+};
+var ko = Object.assign({}, Vo, qo);
+var xo = Object.assign({}, Jo, qo);
+var Ro = Object.assign({}, Lo, qo);
+var Wo = {
+  dateAdd(e3, t3, n3, o3, r3) {
+    return Ao(t3.call(e3, Yo(v(n3, e3)), ar(Vt(o3)), r3));
+  }
+};
+var Go = Object.assign({}, Wo, {
+  dateUntil(e3, t3, n3, o3, r3, a2) {
+    return ir(t3.call(e3, Yo(v(n3, e3)), Yo(v(o3, e3)), Object.assign(Object.create(null), a2, {
+      largestUnit: Et[r3]
+    })));
+  }
+});
+var Uo = Object.assign({}, Wo, {
+  day: dayAdapter
+});
+var zo = Object.assign({}, Go, {
+  day: dayAdapter
+});
+var Ho = createCompoundOpsCreator(Jo);
+var Ko = createCompoundOpsCreator(Vo);
+var Qo = createCompoundOpsCreator(Lo);
+var Xo = createCompoundOpsCreator(xo);
+var $o = createCompoundOpsCreator(ko);
+var _o = createCompoundOpsCreator(Ro);
+var er = createCompoundOpsCreator(Wo);
+var tr = createCompoundOpsCreator(Go);
+var nr = createCompoundOpsCreator(Uo);
+var or = createCompoundOpsCreator(zo);
+var [rr, ar, ir] = createSlotClass(qt, Lt, {
+  ...uo,
+  blank: Jt
+}, {
+  with: (e3, t3) => ar(kt(e3, t3)),
+  negated: (e3) => ar(xt(e3)),
+  abs: (e3) => ar(Rt(e3)),
+  add: (e3, t3, n3) => ar(Wt(refinePublicRelativeTo, tr, createTimeZoneOps, 0, e3, toDurationSlots(t3), n3)),
+  subtract: (e3, t3, n3) => ar(Wt(refinePublicRelativeTo, tr, createTimeZoneOps, 1, e3, toDurationSlots(t3), n3)),
+  round: (e3, t3) => ar(Gt(refinePublicRelativeTo, tr, createTimeZoneOps, e3, t3)),
+  total: (e3, t3) => Ut(refinePublicRelativeTo, tr, createTimeZoneOps, e3, t3),
+  toLocaleString(e3, t3, n3) {
+    return Intl.DurationFormat ? new Intl.DurationFormat(t3, n3).format(this) : zt(e3);
+  },
+  toString: zt,
+  toJSON: (e3) => zt(e3),
+  valueOf: neverValueOf
+}, {
+  from: (e3) => ar(toDurationSlots(e3)),
+  compare: (e3, t3, n3) => $t(refinePublicRelativeTo, er, createTimeZoneOps, toDurationSlots(e3), toDurationSlots(t3), n3)
+});
+var sr = {
+  toString: (e3) => e3.id,
+  toJSON: (e3) => e3.id,
+  ...ro,
+  dateAdd: ({ id: e3, o: t3 }, n3, o3, r3) => Yo(v(t3.dateAdd(toPlainDateSlots(n3), toDurationSlots(o3), r3), e3)),
+  dateUntil: ({ o: e3 }, t3, n3, o3) => ar(Vt(e3.dateUntil(toPlainDateSlots(t3), toPlainDateSlots(n3), _t(o3)))),
+  dateFromFields: ({ id: e3, o: t3 }, n3, o3) => Yo(Yt(t3, n3, o3, ln(e3))),
+  yearMonthFromFields: ({ id: e3, o: t3 }, n3, o3) => jo(nt(t3, n3, o3, un(e3))),
+  monthDayFromFields: ({ id: e3, o: t3 }, n3, o3) => To(K(t3, 0, n3, o3, cn(e3))),
+  fields({ o: e3 }, t3) {
+    const n3 = new Set(en), o3 = [];
+    for (const e4 of t3) {
+      if (m(e4), !n3.has(e4)) {
+        throw new RangeError(tn(e4));
+      }
+      n3.delete(e4), o3.push(e4);
+    }
+    return e3.fields(o3);
+  },
+  mergeFields: ({ o: e3 }, t3, n3) => e3.mergeFields(nn(on(t3)), nn(on(n3)))
+};
+var [lr] = createSlotClass("Calendar", (e3) => {
+  const t3 = rn(e3);
+  return {
+    branding: "Calendar",
+    id: t3,
+    o: Y(t3)
+  };
+}, {
+  id: (e3) => e3.id
+}, sr, {
+  from(e3) {
+    const t3 = refineCalendarSlot(e3);
+    return typeof t3 == "string" ? new lr(t3) : t3;
+  }
+});
+var cr = createProtocolValidator(Object.keys(sr).slice(4));
+var [ur, dr] = createSlotClass(Te, E(vn, refineCalendarSlot, refineTimeZoneSlot), {
+  ...mo,
+  ...lo,
+  ...adaptDateMethods(ao),
+  ...adaptDateMethods(fo),
+  offset: (e3) => Fe(slotsToIso(e3).offsetNanoseconds),
+  offsetNanoseconds: (e3) => slotsToIso(e3).offsetNanoseconds,
+  timeZoneId: (e3) => I2(e3.timeZone),
+  hoursInDay: (e3) => dn(createTimeZoneOps, e3)
+}, {
+  getISOFields: (e3) => mn(createTimeZoneOffsetOps, e3),
+  getCalendar: createCalendarFromSlots,
+  getTimeZone: ({ timeZone: e3 }) => typeof e3 == "string" ? new Zo(e3) : e3,
+  with(e3, t3, n3) {
+    return dr(Sn($o, createTimeZoneOps, e3, this, rejectInvalidBag(t3), n3));
+  },
+  withCalendar: (e3, t3) => dr(it(e3, refineCalendarSlot(t3))),
+  withTimeZone: (e3, t3) => dr(On(e3, refineTimeZoneSlot(t3))),
+  withPlainDate: (e3, t3) => dr(Tn(createTimeZoneOps, e3, toPlainDateSlots(t3))),
+  withPlainTime: (e3, t3) => dr(pn(createTimeZoneOps, e3, optionalToPlainTimeFields(t3))),
+  add: (e3, t3, n3) => dr(hn(er, createTimeZoneOps, 0, e3, toDurationSlots(t3), n3)),
+  subtract: (e3, t3, n3) => dr(hn(er, createTimeZoneOps, 1, e3, toDurationSlots(t3), n3)),
+  until: (e3, t3, n3) => ar(Vt(Dn(tr, createTimeZoneOps, 0, e3, toZonedDateTimeSlots(t3), n3))),
+  since: (e3, t3, n3) => ar(Vt(Dn(tr, createTimeZoneOps, 1, e3, toZonedDateTimeSlots(t3), n3))),
+  round: (e3, t3) => dr(Pn(createTimeZoneOps, e3, t3)),
+  startOfDay: (e3) => dr(Cn(createTimeZoneOps, e3)),
+  equals: (e3, t3) => gn(e3, toZonedDateTimeSlots(t3)),
+  toInstant: (e3) => Co(Zn(e3)),
+  toPlainDateTime: (e3) => No(ht(createTimeZoneOffsetOps, e3)),
+  toPlainDate: (e3) => Yo(Bt(createTimeZoneOffsetOps, e3)),
+  toPlainTime: (e3) => vo(Re(createTimeZoneOffsetOps, e3)),
+  toPlainYearMonth(e3) {
+    return jo(bn(Ho, e3, this));
+  },
+  toPlainMonthDay(e3) {
+    return To(Fn(Qo, e3, this));
+  },
+  toLocaleString(e3, t3, n3 = {}) {
+    const [o3, r3] = Wn(t3, n3, e3);
+    return o3.format(r3);
+  },
+  toString: (e3, t3) => In(createTimeZoneOffsetOps, e3, t3),
+  toJSON: (e3) => In(createTimeZoneOffsetOps, e3),
+  valueOf: neverValueOf
+}, {
+  from: (e3, t3) => dr(toZonedDateTimeSlots(e3, t3)),
+  compare: (e3, t3) => yn(toZonedDateTimeSlots(e3), toZonedDateTimeSlots(t3))
+});
+var fr = Object.defineProperties({}, {
+  ...h("Temporal.Now"),
+  ...p({
+    timeZoneId: () => Nn(),
+    instant: () => Co(_(Bn())),
+    zonedDateTime: (e3, t3 = Nn()) => dr(Yn(Bn(), refineTimeZoneSlot(t3), refineCalendarSlot(e3))),
+    zonedDateTimeISO: (e3 = Nn()) => dr(Yn(Bn(), refineTimeZoneSlot(e3), X)),
+    plainDateTime: (e3, t3 = Nn()) => No(ee(An(createTimeZoneOffsetOps(refineTimeZoneSlot(t3))), refineCalendarSlot(e3))),
+    plainDateTimeISO: (e3 = Nn()) => No(ee(An(createTimeZoneOffsetOps(refineTimeZoneSlot(e3))), X)),
+    plainDate: (e3, t3 = Nn()) => Yo(v(An(createTimeZoneOffsetOps(refineTimeZoneSlot(t3))), refineCalendarSlot(e3))),
+    plainDateISO: (e3 = Nn()) => Yo(v(An(createTimeZoneOffsetOps(refineTimeZoneSlot(e3))), X)),
+    plainTimeISO: (e3 = Nn()) => vo(Ge(An(createTimeZoneOffsetOps(refineTimeZoneSlot(e3)))))
+  })
+});
+var mr = Object.defineProperties({}, {
+  ...h("Temporal"),
+  ...p({
+    PlainYearMonth: wo,
+    PlainMonthDay: Oo,
+    PlainDate: Bo,
+    PlainTime: Io,
+    PlainDateTime: yo,
+    ZonedDateTime: ur,
+    Instant: Po,
+    Calendar: lr,
+    TimeZone: Zo,
+    Duration: rr,
+    Now: fr
+  })
+});
+var Sr = createDateTimeFormatClass();
+var Or = new WeakMap;
+var Tr = Object.defineProperties(Object.create(Intl), p({
+  DateTimeFormat: Sr
+}));
+// auth/adapters/blank.ts
+class AdapterNotFound extends Error {
+  constructor() {
+    super("Adapter not found");
+    this.name = "AdapterNotFound";
+  }
+}
+
+class BlankAdapter {
+  createSession() {
+    throw new AdapterNotFound;
+  }
+  deleteSession() {
+    throw new AdapterNotFound;
+  }
+  findSession() {
+    throw new AdapterNotFound;
+  }
+  findUserByEmailAddress() {
+    throw new AdapterNotFound;
+  }
+  updateSession() {
+    throw new AdapterNotFound;
+  }
+  createUser() {
+    throw new AdapterNotFound;
+  }
+}
+
+// auth/AuthenticationServiceProvider.ts
+class AuthenticationError2 extends RequestBreakerError {
+  error;
+  constructor(error = "Invalid credentials") {
+    super("Authentication error");
+    this.name = "AuthenticationError";
+    this.error = error;
+    this.payload = {
+      api: {
+        status: 401,
+        data: {
+          error: {
+            kind: "form_error",
+            message: this.error
+          }
+        }
+      },
+      view: {}
+    };
+  }
+}
+
+class AuthorizationError extends RequestBreakerError {
+  error;
+  constructor(error = "Not authorized") {
+    super("Authentication error");
+    this.name = "AuthenticationError";
+    this.error = error;
+    this.payload = {
+      api: {
+        status: 401,
+        data: { error: this.error }
+      },
+      view: {}
+    };
+  }
+}
+
+class SignInRequest extends HttpRequest {
+  constructor() {
+    super(...arguments);
+  }
+  schema = {
+    email: {
+      required: "Email is required",
+      string: "Invalid email",
+      email: "Invalid email"
+    },
+    password: {
+      required: "Password is required"
+    }
+  };
+}
+
+class SignUpRequest extends HttpRequest {
+  constructor() {
+    super(...arguments);
+  }
+  schema = {
+    name: {
+      string: "Invalid name",
+      required: true,
+      "min:2": "Name must be at least 3 characters"
+    },
+    email: {
+      string: "Invalid email",
+      required: true,
+      email: "Invalid email"
+    },
+    password: {
+      required: true,
+      "min:8": "Password must be at least 8 characters"
+    }
+  };
+}
+
+class AuthController extends Controller {
+  constructor() {
+    super(...arguments);
+  }
+  requests = {
+    signUp: SignUpRequest,
+    signIn: SignInRequest
+  };
+  provider = KernelContext.getStore().authenticationServiceProvider;
+  async me() {
+    const user = await Auth.user();
+    if (!user) {
+      throw new AuthorizationError;
+    }
+    return { user };
+  }
+  async signIn(req) {
+    const input = await req.input.call(req);
+    const { email, password } = input.toJSON();
+    const user = await this.provider.adapter.findUserByEmailAddress(email);
+    if (!user) {
+      throw new AuthenticationError2;
+    }
+    const isPasswordValid = await this.provider.verifyPassword(password, user.password);
+    if (!isPasswordValid) {
+      throw new AuthenticationError2;
+    }
+    const userAgent2 = req.headers.get("User-Agent");
+    const hasher = new Bun.CryptoHasher("sha256");
+    hasher.update(`${user.email}${userAgent2}`);
+    const token2 = hasher.digest("hex");
+    let session = await this.provider.adapter.findSession({
+      token: token2,
+      userAgent: userAgent2
+    });
+    if (!session) {
+      session = await this.provider.adapter.createSession({
+        token: token2,
+        userId: user.id,
+        userAgent: req.headers.get("User-Agent"),
+        expiresAt: new Date(mr.Now.instant().add({ hours: this.provider.sessionExpiresInHours }).toString()),
+        absoluteExpiresAt: new Date(mr.Now.instant().add({ hours: this.provider.sessionAbsoluteExpiresInHours }).toString())
+      });
+    } else {
+      session = await this.provider.adapter.updateSession({
+        token: token2,
+        expiresAt: new Date(mr.Now.instant().add({ hours: this.provider.sessionExpiresInHours }).toString())
+      });
+    }
+    req.ctx.setCookie("access_token", session.token, {
+      expires: session.expiresAt
+    });
+    await this.provider.onSignIn(user);
+    return { user };
+  }
+  async signUp(req) {
+    const input = await req.input();
+    const { email, password, name: name2 } = input.toJSON();
+    const user = await this.provider.adapter.findUserByEmailAddress(email);
+    if (user) {
+      throw new Error("User already exists");
+    }
+    const hashedPassword = await this.provider.hashPassword(password);
+    const newUser = await this.provider.adapter.createUser({
+      email,
+      name: name2,
+      password: hashedPassword
+    });
+    await this.provider.onSignUp(newUser);
+    return { user: newUser };
+  }
+  async signOut(req) {
+    const token2 = req.cookies.get("access_token");
+    const user = await Auth.user();
+    await this.provider.adapter.deleteSession({ token: token2 });
+    req.ctx.setCookie("access_token", "", {
+      expires: new Date(0)
+    });
+    await this.provider.onSignOut(user);
+    return {};
+  }
+  async forgotPassword(req) {
+    const input = await req.input();
+    const { email } = input.toJSON();
+    const user = await this.provider.adapter.findUserByEmailAddress(email);
+    if (!user) {
+      return {};
+    }
+    const token2 = await this.provider.generateForgotPasswordToken(user);
+    await this.provider.adapter.createPasswordResetToken({
+      user,
+      token: token2
+    });
+    await this.provider.onForgotPassword(user, token2);
+    return {};
+  }
+  async resetPassword(req) {
+    const input = await req.input();
+    const { password, token: token2 } = input.toJSON();
+    const passwordResetToken = await this.provider.adapter.findPasswordResetToken({ token: token2 });
+    if (!passwordResetToken) {
+      throw new Error("Invalid token");
+    }
+    const isTokenExpired = mr.Now.instant().until(mr.Instant.from(passwordResetToken.createdAt.toISOString()).add({ hours: 24 }).toString()).sign;
+    if (isTokenExpired) {
+      throw new Error("Token expired");
+    }
+    await this.provider.adapter.deletePasswordResetToken({ token: token2 });
+    const user = await this.provider.adapter.findUserByEmailAddress(passwordResetToken.user.email);
+    if (!user) {
+      throw new Error("User not found");
+    }
+    const hashedPassword = await this.provider.hashPassword(password);
+    await this.provider.adapter.updateUserPassword({
+      id: user.id,
+      password: hashedPassword
+    });
+    await this.provider.adapter.deleteAllUserSessions(user.id);
+    await this.provider.onResetPassword(user);
+    return {};
+  }
+}
+
+class AuthApiRouter extends ApiRouter {
+  constructor() {
+    super(...arguments);
+  }
+  routes = {
+    "/sign-in": this.post(AuthController, "signIn"),
+    "/sign-up": this.post(AuthController, "signUp"),
+    "/sign-out": this.post(AuthController, "signOut"),
+    "/forgot-password": this.post(AuthController, "forgotPassword"),
+    "/reset-password": this.post(AuthController, "resetPassword"),
+    "/me": this.get(AuthController, "me")
+  };
+}
+
+class AuthViewRouter extends ViewRouter {
+  constructor() {
+    super(...arguments);
+  }
+  routes = {
+    "/sign-in": this.view("auth/SignIn"),
+    "/sign-up": this.view("auth/SignUp"),
+    "/reset-password": this.view("auth/ResetPassword"),
+    "/forgot-password": this.view("auth/ForgotPassword")
+  };
+}
+
+class AuthenticationServiceProvider {
+  basePath = "/auth";
+  routers = {
+    api: AuthApiRouter,
+    view: AuthViewRouter
+  };
+  sessionExpiresInHours = 24;
+  sessionAbsoluteExpiresInHours = 672;
+  adapter = new BlankAdapter;
+  async verifyPassword(password, hash) {
+    return await Bun.password.verify(password, hash);
+  }
+  async hashPassword(password) {
+    return await Bun.password.hash(password);
+  }
+  async generateForgotPasswordToken(user) {
+    const hasher = new Bun.CryptoHasher("sha256");
+    hasher.update(`${user.email}${Date.now()}`);
+    return hasher.digest("hex");
+  }
+  onSignUp(_user) {
+  }
+  onSignIn(_user) {
+  }
+  onSignOut(_user) {
+  }
+  onForgotPassword(_user, _verificationToken) {
+  }
+  onResetPassword(_user) {
+  }
+}
+
+// kernel/Kernel.ts
+class Kernel {
+  emailServiceProvider = EmailServiceProvider;
+  authenticationServiceProvider = AuthenticationServiceProvider;
+  middlewareServiceProvider = MiddlewareServiceProvider;
+  services;
+  getServices = () => {
+    if (!this.services) {
+      this.services = {
+        emailServiceProvider: new this.emailServiceProvider,
+        authenticationServiceProvider: new this.authenticationServiceProvider,
+        middlewareServiceProvider: new this.middlewareServiceProvider
+      };
+    }
+    return this.services;
+  };
+  static getContext = () => kernelContext.getStore();
   run(cb) {
-    return context.run({
-      emailServiceProvider: new this.emailServiceProvider
-    }, cb);
+    const services = this.getServices();
+    return kernelContext.run(services, cb);
   }
 }
 // email/Email.tsx
@@ -9088,7 +13821,7 @@ class Email {
   static async send(Template, params) {
     const template = new Template;
     const {
-      to = template.to,
+      to: to2 = template.to,
       from = template.from,
       subject = template.subject,
       cc = template.cc,
@@ -9108,7 +13841,7 @@ class Email {
       cc,
       from,
       subject,
-      to,
+      to: to2,
       attachments,
       html
     });