feat(prompt): initial implementation of prompt management feature

Relates to #21586

.gitignore

@@ -214,31 +214,3 @@ mise.toml
 
 # AI Assistant
 .roo/
-
-# Node.js
-node_modules/
-npm-debug.log
-yarn-error.log
-package-lock.json
-pnpm-lock.yaml
-
-# Python
-__pycache__/
-*.pyc
-*.pyo
-*.pyd
-.Python
-env/
-venv/
-pip-cache/
-.env
-
-# IDEs
-.vscode/
-.idea/
-*.swp
-*.swo
-
-# OS
-.DS_Store
-Thumbs.db

README.md

@@ -266,236 +266,3 @@ To protect your privacy, please avoid posting security issues on GitHub. Instead
 ## License
 
 This repository is available under the [Dify Open Source License](LICENSE), which is essentially Apache 2.0 with a few additional restrictions.
-
-# Dify 多智能体记忆问题复现方案
-
-## 问题概述
-
-根据 [GitHub Issue #21640](https://github.com/langgenius/dify/issues/21640)，在多智能体聊天流程系统中存在记忆隔离问题：
-
-- 每个智能体都有记忆功能（10条消息）
-- 当对话流程切换到不同智能体时，新智能体会看到来自其他智能体的聊天历史
-- 这导致智能体产生"幻觉"（hallucination），回答不准确
-
-## 复现方法
-
-### 方法1：手动复现（推荐）
-
-1. **登录Dify控制台**
-   - 访问您的Dify实例
-   - 登录管理员账户
-
-2. **创建工作流应用**
-   - 创建新的工作流应用
-   - 选择"工作流"模式
-
-3. **添加节点**
-   ```
-   Start节点 → 问题分类器 → Agent A (技术) / Agent B (商业) → End节点
-   ```
-
-4. **配置智能体**
-   - **Agent A**：
-     - 系统提示词："你是Agent A，专门处理技术问题"
-     - 启用记忆：窗口大小10
-   - **Agent B**：
-     - 系统提示词："你是Agent B，专门处理商业问题"  
-     - 启用记忆：窗口大小10
-
-5. **配置路由逻辑**
-   - 使用问题分类器根据内容类型路由
-   - 技术问题 → Agent A
-   - 商业问题 → Agent B
-
-6. **测试场景**
-   ```
-   用户: "如何配置Docker容器？" → Agent A回答
-   用户: "什么是Kubernetes？" → Agent A回答  
-   用户: "如何制定营销策略？" → Agent B回答（可能引用技术内容）
-   用户: "如何提高客户满意度？" → Agent B回答（可能引用技术内容）
-   ```
-
-7. **观察问题**
-   - 检查Agent B的回答是否包含Docker、Kubernetes等技术相关内容
-   - 如果包含，说明存在记忆隔离问题
-
-### 方法2：使用复现脚本
-
-1. **配置脚本**
-   ```bash
-   # 编辑 reproduction_script.py
-   DIFY_BASE_URL = "http://your-dify-instance.com"
-   DIFY_API_KEY = "your_api_key_here"
-   ```
-
-2. **运行脚本**
-   ```bash
-   python reproduction_script.py
-   ```
-
-3. **分析结果**
-   - 脚本会自动检测Agent B回答中的技术关键词
-   - 如果发现技术相关内容，说明存在记忆隔离问题
-
-## 问题分析
-
-### 当前实现机制
-
-1. **记忆存储**：所有节点共享同一个对话ID
-2. **记忆获取**：基于整个对话获取历史消息
-3. **记忆配置**：每个节点可独立配置，但都基于同一对话
-
-### 核心问题
-
-```python
-# 当前记忆获取逻辑 (api/core/workflow/nodes/llm/llm_utils.py)
-def fetch_memory(variable_pool, app_id, node_data_memory, model_instance):
-    # 获取对话ID
-    conversation_id = variable_pool.get(["sys", "CONVERSATION_ID"])
-    
-    # 基于整个对话获取记忆 - 问题所在
-    conversation = session.scalar(stmt)
-    memory = TokenBufferMemory(conversation=conversation, model_instance=model_instance)
-```
-
-## 解决方案
-
-### 方案1：节点特定记忆（推荐）
-
-1. **修改MemoryConfig**
-   ```python
-   class MemoryConfig(BaseModel):
-       window: WindowConfig
-       role_prefix: Optional[RolePrefix] = None
-       query_prompt_template: Optional[str] = None
-       # 新增：节点特定记忆开关
-       node_specific_memory: bool = False
-   ```
-
-2. **修改记忆获取逻辑**
-   ```python
-   def fetch_memory(variable_pool, app_id, node_data_memory, model_instance, node_id):
-       # 如果启用节点特定记忆，只获取该节点的历史
-       if node_data_memory and node_data_memory.node_specific_memory:
-           # 过滤该节点的消息历史
-           pass
-   ```
-
-3. **前端UI修改**
-   - 在记忆配置中添加"节点特定记忆"开关
-   - 提供用户友好的说明文字
-
-### 方案2：记忆过滤
-
-1. **数据库层面过滤**
-   - 在Message表中添加node_id字段
-   - 根据节点ID过滤历史消息
-
-2. **应用层面过滤**
-   - 在记忆获取时添加节点过滤条件
-   - 只包含特定节点参与的消息
-
-### 方案3：记忆上下文切换
-
-1. **动态记忆管理**
-   - 在节点切换时调整记忆上下文
-   - 根据节点类型选择性地包含历史
-
-## 实施步骤
-
-### 后端修改
-
-1. **修改数据模型**
-   ```sql
-   -- 可选：在Message表中添加node_id字段
-   ALTER TABLE messages ADD COLUMN node_id VARCHAR(255);
-   CREATE INDEX idx_messages_node_id ON messages(node_id);
-   ```
-
-2. **修改核心代码**
-   - `api/core/prompt/entities/advanced_prompt_entities.py`
-   - `api/core/memory/token_buffer_memory.py`
-   - `api/core/workflow/nodes/llm/llm_utils.py`
-
-3. **添加测试用例**
-   - 单元测试验证记忆隔离功能
-   - 集成测试验证多智能体场景
-
-### 前端修改
-
-1. **UI组件更新**
-   - `web/app/components/workflow/nodes/_base/components/memory-config.tsx`
-   - 添加节点特定记忆开关
-
-2. **国际化支持**
-   - 在 `web/i18n/zh-Hans/workflow.ts` 中添加相关文本
-
-3. **类型定义更新**
-   - 更新TypeScript类型定义
-
-## 测试验证
-
-### 功能测试
-
-1. **记忆隔离测试**
-   - 验证节点特定记忆开关是否正常工作
-   - 验证不同节点的记忆是否隔离
-
-2. **多智能体测试**
-   - 测试技术Agent和商业Agent的记忆隔离
-   - 验证回答的准确性和相关性
-
-### 性能测试
-
-1. **记忆过滤性能**
-   - 验证记忆过滤对性能的影响
-   - 确保在大规模对话中的稳定性
-
-2. **数据库查询优化**
-   - 验证节点过滤查询的性能
-   - 确保索引的有效性
-
-### 用户体验测试
-
-1. **功能易用性**
-   - 验证用户是否能够理解和使用新功能
-   - 确保配置界面的友好性
-
-2. **向后兼容性**
-   - 验证现有工作流是否正常工作
-   - 确保默认行为保持不变
-
-## 预期效果
-
-### 问题解决
-
-1. **消除幻觉**：Agent B不再看到Agent A的技术对话历史
-2. **提高准确性**：每个智能体只基于自己的专业领域回答
-3. **改善用户体验**：多智能体对话更加准确和连贯
-
-### 功能增强
-
-1. **灵活配置**：用户可以选择是否启用节点特定记忆
-2. **向后兼容**：现有工作流无需修改即可正常工作
-3. **性能优化**：通过记忆过滤减少不必要的上下文
-
-## 相关文件
-
-- `reproduction_steps.md` - 详细的复现步骤
-- `implementation_example.py` - 实现示例代码
-- `reproduction_script.py` - 自动化复现脚本
-
-## 贡献指南
-
-如果您想为这个功能做出贡献：
-
-1. Fork Dify仓库
-2. 创建功能分支
-3. 实现节点特定记忆功能
-4. 添加测试用例
-5. 提交Pull Request
-
-## 联系方式
-
-- GitHub Issue: [#21640](https://github.com/langgenius/dify/issues/21640)
-- 项目主页: [https://github.com/langgenius/dify](https://github.com/langgenius/dify)

api/controllers/console/prompt_template.py

@@ -13,27 +13,28 @@ class PromptTemplateListApi(Resource):
     @account_initialization_required
     def get(self):
         templates = PromptTemplateService.get_prompt_templates()
-        # Manual serialization is no longer needed with Flask-RESTful
-        return [template.to_dict() for template in templates]
+        return {"data": [template.to_dict() for template in templates]}
 
     @setup_required
     @login_required
     @account_initialization_required
     def post(self):
         parser = reqparse.RequestParser()
-        parser.add_argument('name', type=str, required=True, help='Name is required')
-        parser.add_argument('mode', type=str, required=True, help='Mode is required')
-        parser.add_argument('prompt_content', type=str, required=True, help='Prompt content is required.')
-        parser.add_argument('description', type=str, required=False)
-        parser.add_argument('tags', type=list, location='json')
-        parser.add_argument('model_name', type=str, required=False, location='json')
-        parser.add_argument('model_parameters', type=dict, required=False, location='json')
+        parser.add_argument("name", type=str, required=True, help="Name is required")
+        parser.add_argument("mode", type=str, required=True, help="Mode is required")
+        parser.add_argument("prompt_content", type=str, required=True, help="Prompt content is required.")
+        parser.add_argument("description", type=str, required=False)
+        parser.add_argument("tags", type=list, location="json")
+        parser.add_argument("model_name", type=str, required=False, location="json")
+        parser.add_argument("model_parameters", type=dict, required=False, location="json")
         args = parser.parse_args()
 
         template = PromptTemplateService.create_prompt_template(**args)
         return template.to_dict(), 201
 
-api.add_resource(PromptTemplateListApi, '/prompt-templates')
+
+api.add_resource(PromptTemplateListApi, "/prompt-templates")
+
 
 class PromptTemplateApi(Resource):
     @setup_required
@@ -54,13 +55,13 @@ class PromptTemplateApi(Resource):
         Update a prompt template.
         """
         parser = reqparse.RequestParser()
-        parser.add_argument('name', type=str, required=True, help='Name is required')
-        parser.add_argument('mode', type=str, required=True, help='Mode is required')
-        parser.add_argument('prompt_content', type=str, required=True, help='Prompt content is required')
-        parser.add_argument('description', type=str, required=False)
-        parser.add_argument('tags', type=list, location='json')
-        parser.add_argument('model_name', type=str, required=False, location='json')
-        parser.add_argument('model_parameters', type=dict, required=False, location='json')
+        parser.add_argument("name", type=str, required=True, help="Name is required")
+        parser.add_argument("mode", type=str, required=True, help="Mode is required")
+        parser.add_argument("prompt_content", type=str, required=True, help="Prompt content is required")
+        parser.add_argument("description", type=str, required=False)
+        parser.add_argument("tags", type=list, location="json")
+        parser.add_argument("model_name", type=str, required=False, location="json")
+        parser.add_argument("model_parameters", type=dict, required=False, location="json")
         args = parser.parse_args()
 
         template = PromptTemplateService.update_prompt_template(template_id=template_id, **args)
@@ -79,6 +80,7 @@ class PromptTemplateApi(Resource):
             # According to REST principles, DELETE should be idempotent.
             # If the resource is already gone, we can consider the operation successful.
             pass
-        return '', 204
+        return "", 204
+
 
-api.add_resource(PromptTemplateApi, '/prompt-templates/<uuid:template_id>') 
+api.add_resource(PromptTemplateApi, "/prompt-templates/<uuid:template_id>")

api/cookies.txt

@@ -1,4 +0,0 @@
-# Netscape HTTP Cookie File
-# https://curl.se/docs/http-cookies.html
-# This file was generated by libcurl! Edit at your own risk.
-

api/core/workflow/nodes/llm/node.py

@@ -155,8 +155,7 @@ class LLMNode(BaseNode[LLMNodeData]):
             # If a prompt template is used, load it and override node data
             if self.node_data.prompt_template_id:
                 prompt_template_entity = PromptTemplateService.get_prompt_template_for_workflow(
-                    template_id=self.node_data.prompt_template_id,
-                    tenant_id=self.tenant_id
+                    template_id=self.node_data.prompt_template_id, tenant_id=self.tenant_id
                 )
                 latest_version = prompt_template_entity.get_latest_version()
 

api/models/prompt_template.py

@@ -3,94 +3,98 @@ from __future__ import annotations
 from sqlalchemy import desc
 from sqlalchemy.dialects.postgresql import JSONB, UUID
 
-from .engine import db
+from models.model import db
 
 # from .account import Account  <- This is the source of the circular import
 
 
-class PromptTemplate(db.Model):
-    __tablename__ = 'prompt_templates'
+class PromptTemplate(db.Model):  # type: ignore[name-defined]
+    __tablename__ = "prompt_templates"
     __table_args__ = (
-        db.PrimaryKeyConstraint('id', name='prompt_template_pkey'),
-        db.Index('prompt_template_tenant_id_idx', 'tenant_id'),
+        db.PrimaryKeyConstraint("id", name="prompt_template_pkey"),
+        db.Index("prompt_template_tenant_id_idx", "tenant_id"),
     )
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
 
-    id = db.Column(UUID, primary_key=True, server_default=db.text('uuid_generate_v4()'))
+    id = db.Column(UUID, primary_key=True, server_default=db.text("uuid_generate_v4()"))
     tenant_id = db.Column(UUID, nullable=False)
     name = db.Column(db.String(255), nullable=False)
     mode = db.Column(db.String(255), nullable=False)
     description = db.Column(db.Text, nullable=True)
     tags = db.Column(JSONB, nullable=True)
 
-    created_at = db.Column(db.DateTime, nullable=False, server_default=db.text('CURRENT_TIMESTAMP(0)'))
-    updated_at = db.Column(db.DateTime, nullable=False,
-                           server_default=db.text('CURRENT_TIMESTAMP(0)'),
-                           onupdate=db.text('CURRENT_TIMESTAMP(0)'))
+    created_at = db.Column(db.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)"))
+    updated_at = db.Column(
+        db.DateTime,
+        nullable=False,
+        server_default=db.text("CURRENT_TIMESTAMP(0)"),
+        onupdate=db.text("CURRENT_TIMESTAMP(0)"),
+    )
 
     # Relationships
-    versions = db.relationship('PromptVersion', back_populates='prompt_template',
-                               cascade="all, delete-orphan", lazy='dynamic')
+    versions = db.relationship(
+        "PromptVersion", back_populates="prompt_template", cascade="all, delete-orphan", lazy="dynamic"
+    )
 
     def get_latest_version(self):
         """
         Fetches the most recent version of the prompt template.
         """
-        return self.versions.order_by(desc(PromptVersion.created_at)).first()
+        return self.versions.order_by(desc(PromptVersion.created_at)).first()  # type: ignore
 
     def to_dict(self):
         latest_version = self.get_latest_version()
         model_settings = None
         if latest_version:
-            model_settings = {
-                "model_name": latest_version.model_name,
-                "parameters": latest_version.model_parameters
-            }
+            model_settings = {"model_name": latest_version.model_name, "parameters": latest_version.model_parameters}
 
         return {
-            'id': str(self.id),
-            'name': self.name,
-            'mode': self.mode,
-            'description': self.description,
-            'tags': self.tags,
-            'prompt_content': latest_version.prompt_text if latest_version else None,
-            'model_settings': model_settings,
-            'created_at': self.created_at.isoformat(),
-            'updated_at': self.updated_at.isoformat(),
+            "id": str(self.id),
+            "name": self.name,
+            "mode": self.mode,
+            "description": self.description,
+            "tags": self.tags,
+            "prompt_content": latest_version.prompt_text if latest_version else None,
+            "model_settings": model_settings,
+            "created_at": self.created_at.isoformat(),
+            "updated_at": self.updated_at.isoformat(),
         }
 
     def __repr__(self):
-        return f'<PromptTemplate @{self.id}>'
+        return f"<PromptTemplate @{self.id}>"
 
 
-class PromptVersion(db.Model):
-    __tablename__ = 'prompt_versions'
+class PromptVersion(db.Model):  # type: ignore[name-defined]
+    __tablename__ = "prompt_versions"
     __table_args__ = (
-        db.PrimaryKeyConstraint('id', name='prompt_version_pkey'),
-        db.Index('prompt_version_template_id_idx', 'prompt_template_id'),
+        db.PrimaryKeyConstraint("id", name="prompt_version_pkey"),
+        db.Index("prompt_version_template_id_idx", "prompt_template_id"),
     )
 
-    id = db.Column(UUID, primary_key=True, server_default=db.text('uuid_generate_v4()'))
-    prompt_template_id = db.Column(UUID, db.ForeignKey('prompt_templates.id'), nullable=False)
-    version = db.Column(db.String(255), nullable=False, default='1.0')
+    id = db.Column(UUID, primary_key=True, server_default=db.text("uuid_generate_v4()"))
+    prompt_template_id = db.Column(UUID, db.ForeignKey("prompt_templates.id"), nullable=False)
+    version = db.Column(db.String(255), nullable=False, default="1.0")
     prompt_text = db.Column(db.Text, nullable=False)
     variables = db.Column(JSONB, nullable=True)
     model_name = db.Column(db.String(255), nullable=True)
     model_parameters = db.Column(JSONB, nullable=True)
     model_settings = db.Column(JSONB, nullable=True)
 
-    status = db.Column(db.String(50), nullable=False, default='draft') # e.g., draft, published, archived
+    status = db.Column(db.String(50), nullable=False, default="draft")  # e.g., draft, published, archived
 
     created_by = db.Column(UUID, nullable=False)
-    created_at = db.Column(db.DateTime, nullable=False, server_default=db.text('CURRENT_TIMESTAMP(0)'))
-    updated_at = db.Column(db.DateTime, nullable=False,
-                           server_default=db.text('CURRENT_TIMESTAMP(0)'),
-                           onupdate=db.text('CURRENT_TIMESTAMP(0)'))
+    created_at = db.Column(db.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)"))
+    updated_at = db.Column(
+        db.DateTime,
+        nullable=False,
+        server_default=db.text("CURRENT_TIMESTAMP(0)"),
+        onupdate=db.text("CURRENT_TIMESTAMP(0)"),
+    )
 
     # Relationships
-    prompt_template = db.relationship('PromptTemplate', back_populates='versions')
+    prompt_template = db.relationship("PromptTemplate", back_populates="versions")
 
     def __repr__(self):
-        return f'<PromptVersion @{self.id} for Template {self.prompt_template_id}>' 
+        return f"<PromptVersion @{self.id} for Template {self.prompt_template_id}>"

api/print_routes.py

@@ -1,4 +0,0 @@
-from app import create_app
-
-app = create_app()
-print(app.url_map)

api/services/prompt_template_service.py

@@ -10,7 +10,6 @@ from models.prompt_template import PromptTemplate, PromptVersion
 
 
 class PromptTemplateService:
-
     @staticmethod
     def get_prompt_templates():
         """
@@ -75,9 +74,7 @@ class PromptTemplateService:
             raise NotFound("User not authenticated.")
 
         template = (
-            db.session.query(PromptTemplate)
-            .filter_by(id=template_id, tenant_id=current_user.current_tenant_id)
-            .first()
+            db.session.query(PromptTemplate).filter_by(id=template_id, tenant_id=current_user.current_tenant_id).first()
         )
         if not template:
             raise NotFound(f"Prompt template with id {template_id} not found.")
@@ -89,11 +86,7 @@ class PromptTemplateService:
         Get a specific prompt template by ID for a specific tenant.
         This method is designed for workflow context where current_user is not available.
         """
-        template = (
-            db.session.query(PromptTemplate)
-            .filter_by(id=template_id, tenant_id=tenant_id)
-            .first()
-        )
+        template = db.session.query(PromptTemplate).filter_by(id=template_id, tenant_id=tenant_id).first()
         if not template:
             raise NotFound(f"Prompt template with id {template_id} not found for the given tenant.")
         return template
@@ -128,9 +121,11 @@ class PromptTemplateService:
         latest_version = template.get_latest_version()
 
         # Create a new version only if the prompt content or model settings have changed
-        if (latest_version.prompt_text != prompt_content or
-            latest_version.model_name != model_name or
-            latest_version.model_parameters != model_parameters):
+        if (
+            latest_version.prompt_text != prompt_content
+            or latest_version.model_name != model_name
+            or latest_version.model_parameters != model_parameters
+        ):
             new_version = PromptVersion(
                 prompt_template=template,
                 prompt_text=prompt_content,
@@ -152,9 +147,7 @@ class PromptTemplateService:
             raise NotFound("User not authenticated.")
 
         template = (
-            db.session.query(PromptTemplate)
-            .filter_by(id=template_id, tenant_id=current_user.current_tenant_id)
-            .first()
+            db.session.query(PromptTemplate).filter_by(id=template_id, tenant_id=current_user.current_tenant_id).first()
         )
         if not template:
             raise NotFound(f"Prompt template with id {template_id} not found.")

node_modules/.package-lock.json

@@ -0,0 +1,17 @@
+{
+  "name": "dify",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "node_modules/date-fns": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/date-fns/-/date-fns-4.1.0.tgz",
+      "integrity": "sha512-Ukq0owbQXxa/U3EGtsdVBkR1w7KOQ5gIBqdH2hkvknzZPYvBxb/aa6E8L7tmjFtkwZBu3UXBbjIgPo/Ez4xaNg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/kossnocorp"
+      }
+    }
+  }
+}

node_modules/date-fns/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Sasha Koss and Lesha Koss https://kossnocorp.mit-license.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/date-fns/README.md

@@ -0,0 +1,58 @@
+🔥️ **NEW**: [date-fns v4.0 with first-class time zone support is out!](https://blog.date-fns.org/v40-with-time-zone-support/)
+
+<img alt="date-fns" title="date-fns" src="https://raw.githubusercontent.com/date-fns/date-fns/master/docs/logotype.svg" width="150" />
+
+date-fns provides the most comprehensive, yet simple and consistent toolset for manipulating JavaScript dates in a browser & Node.js
+
+👉 [Documentation](https://date-fns.org/)
+
+👉 [Blog](https://blog.date-fns.org/)
+
+<hr>
+
+It's like [Lodash](https://lodash.com) for dates
+
+- It has [**200+ functions** for all occasions](https://date-fns.org/docs/Getting-Started/).
+- **Modular**: Pick what you need. Works with webpack, Browserify, or Rollup and also supports tree-shaking.
+- **Native dates**: Uses existing native type. It doesn't extend core objects for safety's sake.
+- **Immutable & Pure**: Built using pure functions and always returns a new date instance.
+- **TypeScript**: The library is 100% TypeScript with brand-new handcrafted types.
+- **I18n**: Dozens of locales. Include only what you need.
+- [and many more benefits](https://date-fns.org/)
+
+```js
+import { compareAsc, format } from "date-fns";
+
+format(new Date(2014, 1, 11), "yyyy-MM-dd");
+//=> '2014-02-11'
+
+const dates = [
+  new Date(1995, 6, 2),
+  new Date(1987, 1, 11),
+  new Date(1989, 6, 10),
+];
+dates.sort(compareAsc);
+//=> [
+//   Wed Feb 11 1987 00:00:00,
+//   Mon Jul 10 1989 00:00:00,
+//   Sun Jul 02 1995 00:00:00
+// ]
+```
+
+The library is available as an [npm package](https://www.npmjs.com/package/date-fns).
+To install the package run:
+
+```bash
+npm install date-fns --save
+```
+
+## Docs
+
+[See date-fns.org](https://date-fns.org/) for more details, API,
+and other docs.
+
+<br />
+
+## License
+
+[MIT © Sasha Koss](https://kossnocorp.mit-license.org/)

node_modules/date-fns/SECURITY.md

@@ -0,0 +1,12 @@
+# Security Policy
+
+## Supported Versions
+
+Security updates are applied only to the latest release.
+
+## Reporting a Vulnerability
+
+If you have discovered a security vulnerability in this project, please report it privately. **Do not disclose it as a public issue.** 
+This gives us time to work with you to fix the issue before public exposure, reducing the chance that the exploit will be used before a patch is released.
+Please disclose it to [Sasha Koss](mailto:koss@nocorp.me). This project is maintained by a team of volunteers
+on a reasonable-effort basis. As such, please give us at least 90 days to work on a fix before public exposure.

node_modules/date-fns/_lib/addLeadingZeros.cjs

@@ -0,0 +1,7 @@
+"use strict";
+exports.addLeadingZeros = addLeadingZeros;
+function addLeadingZeros(number, targetLength) {
+  const sign = number < 0 ? "-" : "";
+  const output = Math.abs(number).toString().padStart(targetLength, "0");
+  return sign + output;
+}

node_modules/date-fns/_lib/addLeadingZeros.d.cts

@@ -0,0 +1,4 @@
+export declare function addLeadingZeros(
+  number: number,
+  targetLength: number,
+): string;

node_modules/date-fns/_lib/addLeadingZeros.d.ts

@@ -0,0 +1,4 @@
+export declare function addLeadingZeros(
+  number: number,
+  targetLength: number,
+): string;

node_modules/date-fns/_lib/addLeadingZeros.js

@@ -0,0 +1,5 @@
+export function addLeadingZeros(number, targetLength) {
+  const sign = number < 0 ? "-" : "";
+  const output = Math.abs(number).toString().padStart(targetLength, "0");
+  return sign + output;
+}

node_modules/date-fns/_lib/defaultLocale.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "defaultLocale", {
+  enumerable: true,
+  get: function () {
+    return _index.enUS;
+  },
+});
+var _index = require("../locale/en-US.cjs");

node_modules/date-fns/_lib/defaultLocale.d.cts

@@ -0,0 +1 @@
+export { enUS as defaultLocale } from "../locale/en-US.js";

node_modules/date-fns/_lib/defaultLocale.d.ts

@@ -0,0 +1 @@
+export { enUS as defaultLocale } from "../locale/en-US.js";

node_modules/date-fns/_lib/defaultLocale.js

@@ -0,0 +1 @@
+export { enUS as defaultLocale } from "../locale/en-US.js";

node_modules/date-fns/_lib/defaultOptions.cjs

@@ -0,0 +1,13 @@
+"use strict";
+exports.getDefaultOptions = getDefaultOptions;
+exports.setDefaultOptions = setDefaultOptions;
+
+let defaultOptions = {};
+
+function getDefaultOptions() {
+  return defaultOptions;
+}
+
+function setDefaultOptions(newOptions) {
+  defaultOptions = newOptions;
+}

node_modules/date-fns/_lib/defaultOptions.d.cts

@@ -0,0 +1,11 @@
+import type {
+  FirstWeekContainsDateOptions,
+  Locale,
+  LocalizedOptions,
+  WeekOptions,
+} from "../types.js";
+export type DefaultOptions = LocalizedOptions<keyof Locale> &
+  WeekOptions &
+  FirstWeekContainsDateOptions;
+export declare function getDefaultOptions(): DefaultOptions;
+export declare function setDefaultOptions(newOptions: DefaultOptions): void;

node_modules/date-fns/_lib/defaultOptions.d.ts

@@ -0,0 +1,11 @@
+import type {
+  FirstWeekContainsDateOptions,
+  Locale,
+  LocalizedOptions,
+  WeekOptions,
+} from "../types.js";
+export type DefaultOptions = LocalizedOptions<keyof Locale> &
+  WeekOptions &
+  FirstWeekContainsDateOptions;
+export declare function getDefaultOptions(): DefaultOptions;
+export declare function setDefaultOptions(newOptions: DefaultOptions): void;

node_modules/date-fns/_lib/defaultOptions.js

@@ -0,0 +1,9 @@
+let defaultOptions = {};
+
+export function getDefaultOptions() {
+  return defaultOptions;
+}
+
+export function setDefaultOptions(newOptions) {
+  defaultOptions = newOptions;
+}

node_modules/date-fns/_lib/format/formatters.cjs

@@ -0,0 +1,780 @@
+"use strict";
+exports.formatters = void 0;
+var _index = require("../../getDayOfYear.cjs");
+var _index2 = require("../../getISOWeek.cjs");
+var _index3 = require("../../getISOWeekYear.cjs");
+var _index4 = require("../../getWeek.cjs");
+var _index5 = require("../../getWeekYear.cjs");
+
+var _index6 = require("../addLeadingZeros.cjs");
+var _index7 = require("./lightFormatters.cjs");
+
+const dayPeriodEnum = {
+  am: "am",
+  pm: "pm",
+  midnight: "midnight",
+  noon: "noon",
+  morning: "morning",
+  afternoon: "afternoon",
+  evening: "evening",
+  night: "night",
+};
+
+/*
+ * |     | Unit                           |     | Unit                           |
+ * |-----|--------------------------------|-----|--------------------------------|
+ * |  a  | AM, PM                         |  A* | Milliseconds in day            |
+ * |  b  | AM, PM, noon, midnight         |  B  | Flexible day period            |
+ * |  c  | Stand-alone local day of week  |  C* | Localized hour w/ day period   |
+ * |  d  | Day of month                   |  D  | Day of year                    |
+ * |  e  | Local day of week              |  E  | Day of week                    |
+ * |  f  |                                |  F* | Day of week in month           |
+ * |  g* | Modified Julian day            |  G  | Era                            |
+ * |  h  | Hour [1-12]                    |  H  | Hour [0-23]                    |
+ * |  i! | ISO day of week                |  I! | ISO week of year               |
+ * |  j* | Localized hour w/ day period   |  J* | Localized hour w/o day period  |
+ * |  k  | Hour [1-24]                    |  K  | Hour [0-11]                    |
+ * |  l* | (deprecated)                   |  L  | Stand-alone month              |
+ * |  m  | Minute                         |  M  | Month                          |
+ * |  n  |                                |  N  |                                |
+ * |  o! | Ordinal number modifier        |  O  | Timezone (GMT)                 |
+ * |  p! | Long localized time            |  P! | Long localized date            |
+ * |  q  | Stand-alone quarter            |  Q  | Quarter                        |
+ * |  r* | Related Gregorian year         |  R! | ISO week-numbering year        |
+ * |  s  | Second                         |  S  | Fraction of second             |
+ * |  t! | Seconds timestamp              |  T! | Milliseconds timestamp         |
+ * |  u  | Extended year                  |  U* | Cyclic year                    |
+ * |  v* | Timezone (generic non-locat.)  |  V* | Timezone (location)            |
+ * |  w  | Local week of year             |  W* | Week of month                  |
+ * |  x  | Timezone (ISO-8601 w/o Z)      |  X  | Timezone (ISO-8601)            |
+ * |  y  | Year (abs)                     |  Y  | Local week-numbering year      |
+ * |  z  | Timezone (specific non-locat.) |  Z* | Timezone (aliases)             |
+ *
+ * Letters marked by * are not implemented but reserved by Unicode standard.
+ *
+ * Letters marked by ! are non-standard, but implemented by date-fns:
+ * - `o` modifies the previous token to turn it into an ordinal (see `format` docs)
+ * - `i` is ISO day of week. For `i` and `ii` is returns numeric ISO week days,
+ *   i.e. 7 for Sunday, 1 for Monday, etc.
+ * - `I` is ISO week of year, as opposed to `w` which is local week of year.
+ * - `R` is ISO week-numbering year, as opposed to `Y` which is local week-numbering year.
+ *   `R` is supposed to be used in conjunction with `I` and `i`
+ *   for universal ISO week-numbering date, whereas
+ *   `Y` is supposed to be used in conjunction with `w` and `e`
+ *   for week-numbering date specific to the locale.
+ * - `P` is long localized date format
+ * - `p` is long localized time format
+ */
+
+const formatters = (exports.formatters = {
+  // Era
+  G: function (date, token, localize) {
+    const era = date.getFullYear() > 0 ? 1 : 0;
+    switch (token) {
+      // AD, BC
+      case "G":
+      case "GG":
+      case "GGG":
+        return localize.era(era, { width: "abbreviated" });
+      // A, B
+      case "GGGGG":
+        return localize.era(era, { width: "narrow" });
+      // Anno Domini, Before Christ
+      case "GGGG":
+      default:
+        return localize.era(era, { width: "wide" });
+    }
+  },
+
+  // Year
+  y: function (date, token, localize) {
+    // Ordinal number
+    if (token === "yo") {
+      const signedYear = date.getFullYear();
+      // Returns 1 for 1 BC (which is year 0 in JavaScript)
+      const year = signedYear > 0 ? signedYear : 1 - signedYear;
+      return localize.ordinalNumber(year, { unit: "year" });
+    }
+
+    return _index7.lightFormatters.y(date, token);
+  },
+
+  // Local week-numbering year
+  Y: function (date, token, localize, options) {
+    const signedWeekYear = (0, _index5.getWeekYear)(date, options);
+    // Returns 1 for 1 BC (which is year 0 in JavaScript)
+    const weekYear = signedWeekYear > 0 ? signedWeekYear : 1 - signedWeekYear;
+
+    // Two digit year
+    if (token === "YY") {
+      const twoDigitYear = weekYear % 100;
+      return (0, _index6.addLeadingZeros)(twoDigitYear, 2);
+    }
+
+    // Ordinal number
+    if (token === "Yo") {
+      return localize.ordinalNumber(weekYear, { unit: "year" });
+    }
+
+    // Padding
+    return (0, _index6.addLeadingZeros)(weekYear, token.length);
+  },
+
+  // ISO week-numbering year
+  R: function (date, token) {
+    const isoWeekYear = (0, _index3.getISOWeekYear)(date);
+
+    // Padding
+    return (0, _index6.addLeadingZeros)(isoWeekYear, token.length);
+  },
+
+  // Extended year. This is a single number designating the year of this calendar system.
+  // The main difference between `y` and `u` localizers are B.C. years:
+  // | Year | `y` | `u` |
+  // |------|-----|-----|
+  // | AC 1 |   1 |   1 |
+  // | BC 1 |   1 |   0 |
+  // | BC 2 |   2 |  -1 |
+  // Also `yy` always returns the last two digits of a year,
+  // while `uu` pads single digit years to 2 characters and returns other years unchanged.
+  u: function (date, token) {
+    const year = date.getFullYear();
+    return (0, _index6.addLeadingZeros)(year, token.length);
+  },
+
+  // Quarter
+  Q: function (date, token, localize) {
+    const quarter = Math.ceil((date.getMonth() + 1) / 3);
+    switch (token) {
+      // 1, 2, 3, 4
+      case "Q":
+        return String(quarter);
+      // 01, 02, 03, 04
+      case "QQ":
+        return (0, _index6.addLeadingZeros)(quarter, 2);
+      // 1st, 2nd, 3rd, 4th
+      case "Qo":
+        return localize.ordinalNumber(quarter, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "QQQ":
+        return localize.quarter(quarter, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "QQQQQ":
+        return localize.quarter(quarter, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // 1st quarter, 2nd quarter, ...
+      case "QQQQ":
+      default:
+        return localize.quarter(quarter, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // Stand-alone quarter
+  q: function (date, token, localize) {
+    const quarter = Math.ceil((date.getMonth() + 1) / 3);
+    switch (token) {
+      // 1, 2, 3, 4
+      case "q":
+        return String(quarter);
+      // 01, 02, 03, 04
+      case "qq":
+        return (0, _index6.addLeadingZeros)(quarter, 2);
+      // 1st, 2nd, 3rd, 4th
+      case "qo":
+        return localize.ordinalNumber(quarter, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "qqq":
+        return localize.quarter(quarter, {
+          width: "abbreviated",
+          context: "standalone",
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "qqqqq":
+        return localize.quarter(quarter, {
+          width: "narrow",
+          context: "standalone",
+        });
+      // 1st quarter, 2nd quarter, ...
+      case "qqqq":
+      default:
+        return localize.quarter(quarter, {
+          width: "wide",
+          context: "standalone",
+        });
+    }
+  },
+
+  // Month
+  M: function (date, token, localize) {
+    const month = date.getMonth();
+    switch (token) {
+      case "M":
+      case "MM":
+        return _index7.lightFormatters.M(date, token);
+      // 1st, 2nd, ..., 12th
+      case "Mo":
+        return localize.ordinalNumber(month + 1, { unit: "month" });
+      // Jan, Feb, ..., Dec
+      case "MMM":
+        return localize.month(month, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      // J, F, ..., D
+      case "MMMMM":
+        return localize.month(month, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // January, February, ..., December
+      case "MMMM":
+      default:
+        return localize.month(month, { width: "wide", context: "formatting" });
+    }
+  },
+
+  // Stand-alone month
+  L: function (date, token, localize) {
+    const month = date.getMonth();
+    switch (token) {
+      // 1, 2, ..., 12
+      case "L":
+        return String(month + 1);
+      // 01, 02, ..., 12
+      case "LL":
+        return (0, _index6.addLeadingZeros)(month + 1, 2);
+      // 1st, 2nd, ..., 12th
+      case "Lo":
+        return localize.ordinalNumber(month + 1, { unit: "month" });
+      // Jan, Feb, ..., Dec
+      case "LLL":
+        return localize.month(month, {
+          width: "abbreviated",
+          context: "standalone",
+        });
+      // J, F, ..., D
+      case "LLLLL":
+        return localize.month(month, {
+          width: "narrow",
+          context: "standalone",
+        });
+      // January, February, ..., December
+      case "LLLL":
+      default:
+        return localize.month(month, { width: "wide", context: "standalone" });
+    }
+  },
+
+  // Local week of year
+  w: function (date, token, localize, options) {
+    const week = (0, _index4.getWeek)(date, options);
+
+    if (token === "wo") {
+      return localize.ordinalNumber(week, { unit: "week" });
+    }
+
+    return (0, _index6.addLeadingZeros)(week, token.length);
+  },
+
+  // ISO week of year
+  I: function (date, token, localize) {
+    const isoWeek = (0, _index2.getISOWeek)(date);
+
+    if (token === "Io") {
+      return localize.ordinalNumber(isoWeek, { unit: "week" });
+    }
+
+    return (0, _index6.addLeadingZeros)(isoWeek, token.length);
+  },
+
+  // Day of the month
+  d: function (date, token, localize) {
+    if (token === "do") {
+      return localize.ordinalNumber(date.getDate(), { unit: "date" });
+    }
+
+    return _index7.lightFormatters.d(date, token);
+  },
+
+  // Day of year
+  D: function (date, token, localize) {
+    const dayOfYear = (0, _index.getDayOfYear)(date);
+
+    if (token === "Do") {
+      return localize.ordinalNumber(dayOfYear, { unit: "dayOfYear" });
+    }
+
+    return (0, _index6.addLeadingZeros)(dayOfYear, token.length);
+  },
+
+  // Day of week
+  E: function (date, token, localize) {
+    const dayOfWeek = date.getDay();
+    switch (token) {
+      // Tue
+      case "E":
+      case "EE":
+      case "EEE":
+        return localize.day(dayOfWeek, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      // T
+      case "EEEEE":
+        return localize.day(dayOfWeek, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // Tu
+      case "EEEEEE":
+        return localize.day(dayOfWeek, {
+          width: "short",
+          context: "formatting",
+        });
+      // Tuesday
+      case "EEEE":
+      default:
+        return localize.day(dayOfWeek, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // Local day of week
+  e: function (date, token, localize, options) {
+    const dayOfWeek = date.getDay();
+    const localDayOfWeek = (dayOfWeek - options.weekStartsOn + 8) % 7 || 7;
+    switch (token) {
+      // Numerical value (Nth day of week with current locale or weekStartsOn)
+      case "e":
+        return String(localDayOfWeek);
+      // Padded numerical value
+      case "ee":
+        return (0, _index6.addLeadingZeros)(localDayOfWeek, 2);
+      // 1st, 2nd, ..., 7th
+      case "eo":
+        return localize.ordinalNumber(localDayOfWeek, { unit: "day" });
+      case "eee":
+        return localize.day(dayOfWeek, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      // T
+      case "eeeee":
+        return localize.day(dayOfWeek, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // Tu
+      case "eeeeee":
+        return localize.day(dayOfWeek, {
+          width: "short",
+          context: "formatting",
+        });
+      // Tuesday
+      case "eeee":
+      default:
+        return localize.day(dayOfWeek, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // Stand-alone local day of week
+  c: function (date, token, localize, options) {
+    const dayOfWeek = date.getDay();
+    const localDayOfWeek = (dayOfWeek - options.weekStartsOn + 8) % 7 || 7;
+    switch (token) {
+      // Numerical value (same as in `e`)
+      case "c":
+        return String(localDayOfWeek);
+      // Padded numerical value
+      case "cc":
+        return (0, _index6.addLeadingZeros)(localDayOfWeek, token.length);
+      // 1st, 2nd, ..., 7th
+      case "co":
+        return localize.ordinalNumber(localDayOfWeek, { unit: "day" });
+      case "ccc":
+        return localize.day(dayOfWeek, {
+          width: "abbreviated",
+          context: "standalone",
+        });
+      // T
+      case "ccccc":
+        return localize.day(dayOfWeek, {
+          width: "narrow",
+          context: "standalone",
+        });
+      // Tu
+      case "cccccc":
+        return localize.day(dayOfWeek, {
+          width: "short",
+          context: "standalone",
+        });
+      // Tuesday
+      case "cccc":
+      default:
+        return localize.day(dayOfWeek, {
+          width: "wide",
+          context: "standalone",
+        });
+    }
+  },
+
+  // ISO day of week
+  i: function (date, token, localize) {
+    const dayOfWeek = date.getDay();
+    const isoDayOfWeek = dayOfWeek === 0 ? 7 : dayOfWeek;
+    switch (token) {
+      // 2
+      case "i":
+        return String(isoDayOfWeek);
+      // 02
+      case "ii":
+        return (0, _index6.addLeadingZeros)(isoDayOfWeek, token.length);
+      // 2nd
+      case "io":
+        return localize.ordinalNumber(isoDayOfWeek, { unit: "day" });
+      // Tue
+      case "iii":
+        return localize.day(dayOfWeek, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      // T
+      case "iiiii":
+        return localize.day(dayOfWeek, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // Tu
+      case "iiiiii":
+        return localize.day(dayOfWeek, {
+          width: "short",
+          context: "formatting",
+        });
+      // Tuesday
+      case "iiii":
+      default:
+        return localize.day(dayOfWeek, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // AM or PM
+  a: function (date, token, localize) {
+    const hours = date.getHours();
+    const dayPeriodEnumValue = hours / 12 >= 1 ? "pm" : "am";
+
+    switch (token) {
+      case "a":
+      case "aa":
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      case "aaa":
+        return localize
+          .dayPeriod(dayPeriodEnumValue, {
+            width: "abbreviated",
+            context: "formatting",
+          })
+          .toLowerCase();
+      case "aaaaa":
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "narrow",
+          context: "formatting",
+        });
+      case "aaaa":
+      default:
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // AM, PM, midnight, noon
+  b: function (date, token, localize) {
+    const hours = date.getHours();
+    let dayPeriodEnumValue;
+    if (hours === 12) {
+      dayPeriodEnumValue = dayPeriodEnum.noon;
+    } else if (hours === 0) {
+      dayPeriodEnumValue = dayPeriodEnum.midnight;
+    } else {
+      dayPeriodEnumValue = hours / 12 >= 1 ? "pm" : "am";
+    }
+
+    switch (token) {
+      case "b":
+      case "bb":
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      case "bbb":
+        return localize
+          .dayPeriod(dayPeriodEnumValue, {
+            width: "abbreviated",
+            context: "formatting",
+          })
+          .toLowerCase();
+      case "bbbbb":
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "narrow",
+          context: "formatting",
+        });
+      case "bbbb":
+      default:
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // in the morning, in the afternoon, in the evening, at night
+  B: function (date, token, localize) {
+    const hours = date.getHours();
+    let dayPeriodEnumValue;
+    if (hours >= 17) {
+      dayPeriodEnumValue = dayPeriodEnum.evening;
+    } else if (hours >= 12) {
+      dayPeriodEnumValue = dayPeriodEnum.afternoon;
+    } else if (hours >= 4) {
+      dayPeriodEnumValue = dayPeriodEnum.morning;
+    } else {
+      dayPeriodEnumValue = dayPeriodEnum.night;
+    }
+
+    switch (token) {
+      case "B":
+      case "BB":
+      case "BBB":
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      case "BBBBB":
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "narrow",
+          context: "formatting",
+        });
+      case "BBBB":
+      default:
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // Hour [1-12]
+  h: function (date, token, localize) {
+    if (token === "ho") {
+      let hours = date.getHours() % 12;
+      if (hours === 0) hours = 12;
+      return localize.ordinalNumber(hours, { unit: "hour" });
+    }
+
+    return _index7.lightFormatters.h(date, token);
+  },
+
+  // Hour [0-23]
+  H: function (date, token, localize) {
+    if (token === "Ho") {
+      return localize.ordinalNumber(date.getHours(), { unit: "hour" });
+    }
+
+    return _index7.lightFormatters.H(date, token);
+  },
+
+  // Hour [0-11]
+  K: function (date, token, localize) {
+    const hours = date.getHours() % 12;
+
+    if (token === "Ko") {
+      return localize.ordinalNumber(hours, { unit: "hour" });
+    }
+
+    return (0, _index6.addLeadingZeros)(hours, token.length);
+  },
+
+  // Hour [1-24]
+  k: function (date, token, localize) {
+    let hours = date.getHours();
+    if (hours === 0) hours = 24;
+
+    if (token === "ko") {
+      return localize.ordinalNumber(hours, { unit: "hour" });
+    }
+
+    return (0, _index6.addLeadingZeros)(hours, token.length);
+  },
+
+  // Minute
+  m: function (date, token, localize) {
+    if (token === "mo") {
+      return localize.ordinalNumber(date.getMinutes(), { unit: "minute" });
+    }
+
+    return _index7.lightFormatters.m(date, token);
+  },
+
+  // Second
+  s: function (date, token, localize) {
+    if (token === "so") {
+      return localize.ordinalNumber(date.getSeconds(), { unit: "second" });
+    }
+
+    return _index7.lightFormatters.s(date, token);
+  },
+
+  // Fraction of second
+  S: function (date, token) {
+    return _index7.lightFormatters.S(date, token);
+  },
+
+  // Timezone (ISO-8601. If offset is 0, output is always `'Z'`)
+  X: function (date, token, _localize) {
+    const timezoneOffset = date.getTimezoneOffset();
+
+    if (timezoneOffset === 0) {
+      return "Z";
+    }
+
+    switch (token) {
+      // Hours and optional minutes
+      case "X":
+        return formatTimezoneWithOptionalMinutes(timezoneOffset);
+
+      // Hours, minutes and optional seconds without `:` delimiter
+      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+      // so this token always has the same output as `XX`
+      case "XXXX":
+      case "XX": // Hours and minutes without `:` delimiter
+        return formatTimezone(timezoneOffset);
+
+      // Hours, minutes and optional seconds with `:` delimiter
+      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+      // so this token always has the same output as `XXX`
+      case "XXXXX":
+      case "XXX": // Hours and minutes with `:` delimiter
+      default:
+        return formatTimezone(timezoneOffset, ":");
+    }
+  },
+
+  // Timezone (ISO-8601. If offset is 0, output is `'+00:00'` or equivalent)
+  x: function (date, token, _localize) {
+    const timezoneOffset = date.getTimezoneOffset();
+
+    switch (token) {
+      // Hours and optional minutes
+      case "x":
+        return formatTimezoneWithOptionalMinutes(timezoneOffset);
+
+      // Hours, minutes and optional seconds without `:` delimiter
+      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+      // so this token always has the same output as `xx`
+      case "xxxx":
+      case "xx": // Hours and minutes without `:` delimiter
+        return formatTimezone(timezoneOffset);
+
+      // Hours, minutes and optional seconds with `:` delimiter
+      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+      // so this token always has the same output as `xxx`
+      case "xxxxx":
+      case "xxx": // Hours and minutes with `:` delimiter
+      default:
+        return formatTimezone(timezoneOffset, ":");
+    }
+  },
+
+  // Timezone (GMT)
+  O: function (date, token, _localize) {
+    const timezoneOffset = date.getTimezoneOffset();
+
+    switch (token) {
+      // Short
+      case "O":
+      case "OO":
+      case "OOO":
+        return "GMT" + formatTimezoneShort(timezoneOffset, ":");
+      // Long
+      case "OOOO":
+      default:
+        return "GMT" + formatTimezone(timezoneOffset, ":");
+    }
+  },
+
+  // Timezone (specific non-location)
+  z: function (date, token, _localize) {
+    const timezoneOffset = date.getTimezoneOffset();
+
+    switch (token) {
+      // Short
+      case "z":
+      case "zz":
+      case "zzz":
+        return "GMT" + formatTimezoneShort(timezoneOffset, ":");
+      // Long
+      case "zzzz":
+      default:
+        return "GMT" + formatTimezone(timezoneOffset, ":");
+    }
+  },
+
+  // Seconds timestamp
+  t: function (date, token, _localize) {
+    const timestamp = Math.trunc(+date / 1000);
+    return (0, _index6.addLeadingZeros)(timestamp, token.length);
+  },
+
+  // Milliseconds timestamp
+  T: function (date, token, _localize) {
+    return (0, _index6.addLeadingZeros)(+date, token.length);
+  },
+});
+
+function formatTimezoneShort(offset, delimiter = "") {
+  const sign = offset > 0 ? "-" : "+";
+  const absOffset = Math.abs(offset);
+  const hours = Math.trunc(absOffset / 60);
+  const minutes = absOffset % 60;
+  if (minutes === 0) {
+    return sign + String(hours);
+  }
+  return (
+    sign + String(hours) + delimiter + (0, _index6.addLeadingZeros)(minutes, 2)
+  );
+}
+
+function formatTimezoneWithOptionalMinutes(offset, delimiter) {
+  if (offset % 60 === 0) {
+    const sign = offset > 0 ? "-" : "+";
+    return sign + (0, _index6.addLeadingZeros)(Math.abs(offset) / 60, 2);
+  }
+  return formatTimezone(offset, delimiter);
+}
+
+function formatTimezone(offset, delimiter = "") {
+  const sign = offset > 0 ? "-" : "+";
+  const absOffset = Math.abs(offset);
+  const hours = (0, _index6.addLeadingZeros)(Math.trunc(absOffset / 60), 2);
+  const minutes = (0, _index6.addLeadingZeros)(absOffset % 60, 2);
+  return sign + hours + delimiter + minutes;
+}

node_modules/date-fns/_lib/format/formatters.d.cts

@@ -0,0 +1,18 @@
+import type { Localize } from "../../locale/types.js";
+import type {
+  FirstWeekContainsDateOptions,
+  LocalizedOptions,
+  WeekOptions,
+} from "../../types.js";
+type Formatter = (
+  date: Date,
+  token: string,
+  localize: Localize,
+  options: Required<
+    LocalizedOptions<"options"> & WeekOptions & FirstWeekContainsDateOptions
+  >,
+) => string;
+export declare const formatters: {
+  [token: string]: Formatter;
+};
+export {};

node_modules/date-fns/_lib/format/formatters.d.ts

@@ -0,0 +1,18 @@
+import type { Localize } from "../../locale/types.js";
+import type {
+  FirstWeekContainsDateOptions,
+  LocalizedOptions,
+  WeekOptions,
+} from "../../types.js";
+type Formatter = (
+  date: Date,
+  token: string,
+  localize: Localize,
+  options: Required<
+    LocalizedOptions<"options"> & WeekOptions & FirstWeekContainsDateOptions
+  >,
+) => string;
+export declare const formatters: {
+  [token: string]: Formatter;
+};
+export {};

node_modules/date-fns/_lib/format/formatters.js

@@ -0,0 +1,776 @@
+import { getDayOfYear } from "../../getDayOfYear.js";
+import { getISOWeek } from "../../getISOWeek.js";
+import { getISOWeekYear } from "../../getISOWeekYear.js";
+import { getWeek } from "../../getWeek.js";
+import { getWeekYear } from "../../getWeekYear.js";
+
+import { addLeadingZeros } from "../addLeadingZeros.js";
+import { lightFormatters } from "./lightFormatters.js";
+
+const dayPeriodEnum = {
+  am: "am",
+  pm: "pm",
+  midnight: "midnight",
+  noon: "noon",
+  morning: "morning",
+  afternoon: "afternoon",
+  evening: "evening",
+  night: "night",
+};
+
+/*
+ * |     | Unit                           |     | Unit                           |
+ * |-----|--------------------------------|-----|--------------------------------|
+ * |  a  | AM, PM                         |  A* | Milliseconds in day            |
+ * |  b  | AM, PM, noon, midnight         |  B  | Flexible day period            |
+ * |  c  | Stand-alone local day of week  |  C* | Localized hour w/ day period   |
+ * |  d  | Day of month                   |  D  | Day of year                    |
+ * |  e  | Local day of week              |  E  | Day of week                    |
+ * |  f  |                                |  F* | Day of week in month           |
+ * |  g* | Modified Julian day            |  G  | Era                            |
+ * |  h  | Hour [1-12]                    |  H  | Hour [0-23]                    |
+ * |  i! | ISO day of week                |  I! | ISO week of year               |
+ * |  j* | Localized hour w/ day period   |  J* | Localized hour w/o day period  |
+ * |  k  | Hour [1-24]                    |  K  | Hour [0-11]                    |
+ * |  l* | (deprecated)                   |  L  | Stand-alone month              |
+ * |  m  | Minute                         |  M  | Month                          |
+ * |  n  |                                |  N  |                                |
+ * |  o! | Ordinal number modifier        |  O  | Timezone (GMT)                 |
+ * |  p! | Long localized time            |  P! | Long localized date            |
+ * |  q  | Stand-alone quarter            |  Q  | Quarter                        |
+ * |  r* | Related Gregorian year         |  R! | ISO week-numbering year        |
+ * |  s  | Second                         |  S  | Fraction of second             |
+ * |  t! | Seconds timestamp              |  T! | Milliseconds timestamp         |
+ * |  u  | Extended year                  |  U* | Cyclic year                    |
+ * |  v* | Timezone (generic non-locat.)  |  V* | Timezone (location)            |
+ * |  w  | Local week of year             |  W* | Week of month                  |
+ * |  x  | Timezone (ISO-8601 w/o Z)      |  X  | Timezone (ISO-8601)            |
+ * |  y  | Year (abs)                     |  Y  | Local week-numbering year      |
+ * |  z  | Timezone (specific non-locat.) |  Z* | Timezone (aliases)             |
+ *
+ * Letters marked by * are not implemented but reserved by Unicode standard.
+ *
+ * Letters marked by ! are non-standard, but implemented by date-fns:
+ * - `o` modifies the previous token to turn it into an ordinal (see `format` docs)
+ * - `i` is ISO day of week. For `i` and `ii` is returns numeric ISO week days,
+ *   i.e. 7 for Sunday, 1 for Monday, etc.
+ * - `I` is ISO week of year, as opposed to `w` which is local week of year.
+ * - `R` is ISO week-numbering year, as opposed to `Y` which is local week-numbering year.
+ *   `R` is supposed to be used in conjunction with `I` and `i`
+ *   for universal ISO week-numbering date, whereas
+ *   `Y` is supposed to be used in conjunction with `w` and `e`
+ *   for week-numbering date specific to the locale.
+ * - `P` is long localized date format
+ * - `p` is long localized time format
+ */
+
+export const formatters = {
+  // Era
+  G: function (date, token, localize) {
+    const era = date.getFullYear() > 0 ? 1 : 0;
+    switch (token) {
+      // AD, BC
+      case "G":
+      case "GG":
+      case "GGG":
+        return localize.era(era, { width: "abbreviated" });
+      // A, B
+      case "GGGGG":
+        return localize.era(era, { width: "narrow" });
+      // Anno Domini, Before Christ
+      case "GGGG":
+      default:
+        return localize.era(era, { width: "wide" });
+    }
+  },
+
+  // Year
+  y: function (date, token, localize) {
+    // Ordinal number
+    if (token === "yo") {
+      const signedYear = date.getFullYear();
+      // Returns 1 for 1 BC (which is year 0 in JavaScript)
+      const year = signedYear > 0 ? signedYear : 1 - signedYear;
+      return localize.ordinalNumber(year, { unit: "year" });
+    }
+
+    return lightFormatters.y(date, token);
+  },
+
+  // Local week-numbering year
+  Y: function (date, token, localize, options) {
+    const signedWeekYear = getWeekYear(date, options);
+    // Returns 1 for 1 BC (which is year 0 in JavaScript)
+    const weekYear = signedWeekYear > 0 ? signedWeekYear : 1 - signedWeekYear;
+
+    // Two digit year
+    if (token === "YY") {
+      const twoDigitYear = weekYear % 100;
+      return addLeadingZeros(twoDigitYear, 2);
+    }
+
+    // Ordinal number
+    if (token === "Yo") {
+      return localize.ordinalNumber(weekYear, { unit: "year" });
+    }
+
+    // Padding
+    return addLeadingZeros(weekYear, token.length);
+  },
+
+  // ISO week-numbering year
+  R: function (date, token) {
+    const isoWeekYear = getISOWeekYear(date);
+
+    // Padding
+    return addLeadingZeros(isoWeekYear, token.length);
+  },
+
+  // Extended year. This is a single number designating the year of this calendar system.
+  // The main difference between `y` and `u` localizers are B.C. years:
+  // | Year | `y` | `u` |
+  // |------|-----|-----|
+  // | AC 1 |   1 |   1 |
+  // | BC 1 |   1 |   0 |
+  // | BC 2 |   2 |  -1 |
+  // Also `yy` always returns the last two digits of a year,
+  // while `uu` pads single digit years to 2 characters and returns other years unchanged.
+  u: function (date, token) {
+    const year = date.getFullYear();
+    return addLeadingZeros(year, token.length);
+  },
+
+  // Quarter
+  Q: function (date, token, localize) {
+    const quarter = Math.ceil((date.getMonth() + 1) / 3);
+    switch (token) {
+      // 1, 2, 3, 4
+      case "Q":
+        return String(quarter);
+      // 01, 02, 03, 04
+      case "QQ":
+        return addLeadingZeros(quarter, 2);
+      // 1st, 2nd, 3rd, 4th
+      case "Qo":
+        return localize.ordinalNumber(quarter, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "QQQ":
+        return localize.quarter(quarter, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "QQQQQ":
+        return localize.quarter(quarter, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // 1st quarter, 2nd quarter, ...
+      case "QQQQ":
+      default:
+        return localize.quarter(quarter, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // Stand-alone quarter
+  q: function (date, token, localize) {
+    const quarter = Math.ceil((date.getMonth() + 1) / 3);
+    switch (token) {
+      // 1, 2, 3, 4
+      case "q":
+        return String(quarter);
+      // 01, 02, 03, 04
+      case "qq":
+        return addLeadingZeros(quarter, 2);
+      // 1st, 2nd, 3rd, 4th
+      case "qo":
+        return localize.ordinalNumber(quarter, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "qqq":
+        return localize.quarter(quarter, {
+          width: "abbreviated",
+          context: "standalone",
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "qqqqq":
+        return localize.quarter(quarter, {
+          width: "narrow",
+          context: "standalone",
+        });
+      // 1st quarter, 2nd quarter, ...
+      case "qqqq":
+      default:
+        return localize.quarter(quarter, {
+          width: "wide",
+          context: "standalone",
+        });
+    }
+  },
+
+  // Month
+  M: function (date, token, localize) {
+    const month = date.getMonth();
+    switch (token) {
+      case "M":
+      case "MM":
+        return lightFormatters.M(date, token);
+      // 1st, 2nd, ..., 12th
+      case "Mo":
+        return localize.ordinalNumber(month + 1, { unit: "month" });
+      // Jan, Feb, ..., Dec
+      case "MMM":
+        return localize.month(month, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      // J, F, ..., D
+      case "MMMMM":
+        return localize.month(month, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // January, February, ..., December
+      case "MMMM":
+      default:
+        return localize.month(month, { width: "wide", context: "formatting" });
+    }
+  },
+
+  // Stand-alone month
+  L: function (date, token, localize) {
+    const month = date.getMonth();
+    switch (token) {
+      // 1, 2, ..., 12
+      case "L":
+        return String(month + 1);
+      // 01, 02, ..., 12
+      case "LL":
+        return addLeadingZeros(month + 1, 2);
+      // 1st, 2nd, ..., 12th
+      case "Lo":
+        return localize.ordinalNumber(month + 1, { unit: "month" });
+      // Jan, Feb, ..., Dec
+      case "LLL":
+        return localize.month(month, {
+          width: "abbreviated",
+          context: "standalone",
+        });
+      // J, F, ..., D
+      case "LLLLL":
+        return localize.month(month, {
+          width: "narrow",
+          context: "standalone",
+        });
+      // January, February, ..., December
+      case "LLLL":
+      default:
+        return localize.month(month, { width: "wide", context: "standalone" });
+    }
+  },
+
+  // Local week of year
+  w: function (date, token, localize, options) {
+    const week = getWeek(date, options);
+
+    if (token === "wo") {
+      return localize.ordinalNumber(week, { unit: "week" });
+    }
+
+    return addLeadingZeros(week, token.length);
+  },
+
+  // ISO week of year
+  I: function (date, token, localize) {
+    const isoWeek = getISOWeek(date);
+
+    if (token === "Io") {
+      return localize.ordinalNumber(isoWeek, { unit: "week" });
+    }
+
+    return addLeadingZeros(isoWeek, token.length);
+  },
+
+  // Day of the month
+  d: function (date, token, localize) {
+    if (token === "do") {
+      return localize.ordinalNumber(date.getDate(), { unit: "date" });
+    }
+
+    return lightFormatters.d(date, token);
+  },
+
+  // Day of year
+  D: function (date, token, localize) {
+    const dayOfYear = getDayOfYear(date);
+
+    if (token === "Do") {
+      return localize.ordinalNumber(dayOfYear, { unit: "dayOfYear" });
+    }
+
+    return addLeadingZeros(dayOfYear, token.length);
+  },
+
+  // Day of week
+  E: function (date, token, localize) {
+    const dayOfWeek = date.getDay();
+    switch (token) {
+      // Tue
+      case "E":
+      case "EE":
+      case "EEE":
+        return localize.day(dayOfWeek, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      // T
+      case "EEEEE":
+        return localize.day(dayOfWeek, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // Tu
+      case "EEEEEE":
+        return localize.day(dayOfWeek, {
+          width: "short",
+          context: "formatting",
+        });
+      // Tuesday
+      case "EEEE":
+      default:
+        return localize.day(dayOfWeek, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // Local day of week
+  e: function (date, token, localize, options) {
+    const dayOfWeek = date.getDay();
+    const localDayOfWeek = (dayOfWeek - options.weekStartsOn + 8) % 7 || 7;
+    switch (token) {
+      // Numerical value (Nth day of week with current locale or weekStartsOn)
+      case "e":
+        return String(localDayOfWeek);
+      // Padded numerical value
+      case "ee":
+        return addLeadingZeros(localDayOfWeek, 2);
+      // 1st, 2nd, ..., 7th
+      case "eo":
+        return localize.ordinalNumber(localDayOfWeek, { unit: "day" });
+      case "eee":
+        return localize.day(dayOfWeek, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      // T
+      case "eeeee":
+        return localize.day(dayOfWeek, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // Tu
+      case "eeeeee":
+        return localize.day(dayOfWeek, {
+          width: "short",
+          context: "formatting",
+        });
+      // Tuesday
+      case "eeee":
+      default:
+        return localize.day(dayOfWeek, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // Stand-alone local day of week
+  c: function (date, token, localize, options) {
+    const dayOfWeek = date.getDay();
+    const localDayOfWeek = (dayOfWeek - options.weekStartsOn + 8) % 7 || 7;
+    switch (token) {
+      // Numerical value (same as in `e`)
+      case "c":
+        return String(localDayOfWeek);
+      // Padded numerical value
+      case "cc":
+        return addLeadingZeros(localDayOfWeek, token.length);
+      // 1st, 2nd, ..., 7th
+      case "co":
+        return localize.ordinalNumber(localDayOfWeek, { unit: "day" });
+      case "ccc":
+        return localize.day(dayOfWeek, {
+          width: "abbreviated",
+          context: "standalone",
+        });
+      // T
+      case "ccccc":
+        return localize.day(dayOfWeek, {
+          width: "narrow",
+          context: "standalone",
+        });
+      // Tu
+      case "cccccc":
+        return localize.day(dayOfWeek, {
+          width: "short",
+          context: "standalone",
+        });
+      // Tuesday
+      case "cccc":
+      default:
+        return localize.day(dayOfWeek, {
+          width: "wide",
+          context: "standalone",
+        });
+    }
+  },
+
+  // ISO day of week
+  i: function (date, token, localize) {
+    const dayOfWeek = date.getDay();
+    const isoDayOfWeek = dayOfWeek === 0 ? 7 : dayOfWeek;
+    switch (token) {
+      // 2
+      case "i":
+        return String(isoDayOfWeek);
+      // 02
+      case "ii":
+        return addLeadingZeros(isoDayOfWeek, token.length);
+      // 2nd
+      case "io":
+        return localize.ordinalNumber(isoDayOfWeek, { unit: "day" });
+      // Tue
+      case "iii":
+        return localize.day(dayOfWeek, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      // T
+      case "iiiii":
+        return localize.day(dayOfWeek, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // Tu
+      case "iiiiii":
+        return localize.day(dayOfWeek, {
+          width: "short",
+          context: "formatting",
+        });
+      // Tuesday
+      case "iiii":
+      default:
+        return localize.day(dayOfWeek, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // AM or PM
+  a: function (date, token, localize) {
+    const hours = date.getHours();
+    const dayPeriodEnumValue = hours / 12 >= 1 ? "pm" : "am";
+
+    switch (token) {
+      case "a":
+      case "aa":
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      case "aaa":
+        return localize
+          .dayPeriod(dayPeriodEnumValue, {
+            width: "abbreviated",
+            context: "formatting",
+          })
+          .toLowerCase();
+      case "aaaaa":
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "narrow",
+          context: "formatting",
+        });
+      case "aaaa":
+      default:
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // AM, PM, midnight, noon
+  b: function (date, token, localize) {
+    const hours = date.getHours();
+    let dayPeriodEnumValue;
+    if (hours === 12) {
+      dayPeriodEnumValue = dayPeriodEnum.noon;
+    } else if (hours === 0) {
+      dayPeriodEnumValue = dayPeriodEnum.midnight;
+    } else {
+      dayPeriodEnumValue = hours / 12 >= 1 ? "pm" : "am";
+    }
+
+    switch (token) {
+      case "b":
+      case "bb":
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      case "bbb":
+        return localize
+          .dayPeriod(dayPeriodEnumValue, {
+            width: "abbreviated",
+            context: "formatting",
+          })
+          .toLowerCase();
+      case "bbbbb":
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "narrow",
+          context: "formatting",
+        });
+      case "bbbb":
+      default:
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // in the morning, in the afternoon, in the evening, at night
+  B: function (date, token, localize) {
+    const hours = date.getHours();
+    let dayPeriodEnumValue;
+    if (hours >= 17) {
+      dayPeriodEnumValue = dayPeriodEnum.evening;
+    } else if (hours >= 12) {
+      dayPeriodEnumValue = dayPeriodEnum.afternoon;
+    } else if (hours >= 4) {
+      dayPeriodEnumValue = dayPeriodEnum.morning;
+    } else {
+      dayPeriodEnumValue = dayPeriodEnum.night;
+    }
+
+    switch (token) {
+      case "B":
+      case "BB":
+      case "BBB":
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "abbreviated",
+          context: "formatting",
+        });
+      case "BBBBB":
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "narrow",
+          context: "formatting",
+        });
+      case "BBBB":
+      default:
+        return localize.dayPeriod(dayPeriodEnumValue, {
+          width: "wide",
+          context: "formatting",
+        });
+    }
+  },
+
+  // Hour [1-12]
+  h: function (date, token, localize) {
+    if (token === "ho") {
+      let hours = date.getHours() % 12;
+      if (hours === 0) hours = 12;
+      return localize.ordinalNumber(hours, { unit: "hour" });
+    }
+
+    return lightFormatters.h(date, token);
+  },
+
+  // Hour [0-23]
+  H: function (date, token, localize) {
+    if (token === "Ho") {
+      return localize.ordinalNumber(date.getHours(), { unit: "hour" });
+    }
+
+    return lightFormatters.H(date, token);
+  },
+
+  // Hour [0-11]
+  K: function (date, token, localize) {
+    const hours = date.getHours() % 12;
+
+    if (token === "Ko") {
+      return localize.ordinalNumber(hours, { unit: "hour" });
+    }
+
+    return addLeadingZeros(hours, token.length);
+  },
+
+  // Hour [1-24]
+  k: function (date, token, localize) {
+    let hours = date.getHours();
+    if (hours === 0) hours = 24;
+
+    if (token === "ko") {
+      return localize.ordinalNumber(hours, { unit: "hour" });
+    }
+
+    return addLeadingZeros(hours, token.length);
+  },
+
+  // Minute
+  m: function (date, token, localize) {
+    if (token === "mo") {
+      return localize.ordinalNumber(date.getMinutes(), { unit: "minute" });
+    }
+
+    return lightFormatters.m(date, token);
+  },
+
+  // Second
+  s: function (date, token, localize) {
+    if (token === "so") {
+      return localize.ordinalNumber(date.getSeconds(), { unit: "second" });
+    }
+
+    return lightFormatters.s(date, token);
+  },
+
+  // Fraction of second
+  S: function (date, token) {
+    return lightFormatters.S(date, token);
+  },
+
+  // Timezone (ISO-8601. If offset is 0, output is always `'Z'`)
+  X: function (date, token, _localize) {
+    const timezoneOffset = date.getTimezoneOffset();
+
+    if (timezoneOffset === 0) {
+      return "Z";
+    }
+
+    switch (token) {
+      // Hours and optional minutes
+      case "X":
+        return formatTimezoneWithOptionalMinutes(timezoneOffset);
+
+      // Hours, minutes and optional seconds without `:` delimiter
+      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+      // so this token always has the same output as `XX`
+      case "XXXX":
+      case "XX": // Hours and minutes without `:` delimiter
+        return formatTimezone(timezoneOffset);
+
+      // Hours, minutes and optional seconds with `:` delimiter
+      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+      // so this token always has the same output as `XXX`
+      case "XXXXX":
+      case "XXX": // Hours and minutes with `:` delimiter
+      default:
+        return formatTimezone(timezoneOffset, ":");
+    }
+  },
+
+  // Timezone (ISO-8601. If offset is 0, output is `'+00:00'` or equivalent)
+  x: function (date, token, _localize) {
+    const timezoneOffset = date.getTimezoneOffset();
+
+    switch (token) {
+      // Hours and optional minutes
+      case "x":
+        return formatTimezoneWithOptionalMinutes(timezoneOffset);
+
+      // Hours, minutes and optional seconds without `:` delimiter
+      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+      // so this token always has the same output as `xx`
+      case "xxxx":
+      case "xx": // Hours and minutes without `:` delimiter
+        return formatTimezone(timezoneOffset);
+
+      // Hours, minutes and optional seconds with `:` delimiter
+      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+      // so this token always has the same output as `xxx`
+      case "xxxxx":
+      case "xxx": // Hours and minutes with `:` delimiter
+      default:
+        return formatTimezone(timezoneOffset, ":");
+    }
+  },
+
+  // Timezone (GMT)
+  O: function (date, token, _localize) {
+    const timezoneOffset = date.getTimezoneOffset();
+
+    switch (token) {
+      // Short
+      case "O":
+      case "OO":
+      case "OOO":
+        return "GMT" + formatTimezoneShort(timezoneOffset, ":");
+      // Long
+      case "OOOO":
+      default:
+        return "GMT" + formatTimezone(timezoneOffset, ":");
+    }
+  },
+
+  // Timezone (specific non-location)
+  z: function (date, token, _localize) {
+    const timezoneOffset = date.getTimezoneOffset();
+
+    switch (token) {
+      // Short
+      case "z":
+      case "zz":
+      case "zzz":
+        return "GMT" + formatTimezoneShort(timezoneOffset, ":");
+      // Long
+      case "zzzz":
+      default:
+        return "GMT" + formatTimezone(timezoneOffset, ":");
+    }
+  },
+
+  // Seconds timestamp
+  t: function (date, token, _localize) {
+    const timestamp = Math.trunc(+date / 1000);
+    return addLeadingZeros(timestamp, token.length);
+  },
+
+  // Milliseconds timestamp
+  T: function (date, token, _localize) {
+    return addLeadingZeros(+date, token.length);
+  },
+};
+
+function formatTimezoneShort(offset, delimiter = "") {
+  const sign = offset > 0 ? "-" : "+";
+  const absOffset = Math.abs(offset);
+  const hours = Math.trunc(absOffset / 60);
+  const minutes = absOffset % 60;
+  if (minutes === 0) {
+    return sign + String(hours);
+  }
+  return sign + String(hours) + delimiter + addLeadingZeros(minutes, 2);
+}
+
+function formatTimezoneWithOptionalMinutes(offset, delimiter) {
+  if (offset % 60 === 0) {
+    const sign = offset > 0 ? "-" : "+";
+    return sign + addLeadingZeros(Math.abs(offset) / 60, 2);
+  }
+  return formatTimezone(offset, delimiter);
+}
+
+function formatTimezone(offset, delimiter = "") {
+  const sign = offset > 0 ? "-" : "+";
+  const absOffset = Math.abs(offset);
+  const hours = addLeadingZeros(Math.trunc(absOffset / 60), 2);
+  const minutes = addLeadingZeros(absOffset % 60, 2);
+  return sign + hours + delimiter + minutes;
+}

node_modules/date-fns/_lib/format/lightFormatters.cjs

@@ -0,0 +1,102 @@
+"use strict";
+exports.lightFormatters = void 0;
+var _index = require("../addLeadingZeros.cjs");
+
+/*
+ * |     | Unit                           |     | Unit                           |
+ * |-----|--------------------------------|-----|--------------------------------|
+ * |  a  | AM, PM                         |  A* |                                |
+ * |  d  | Day of month                   |  D  |                                |
+ * |  h  | Hour [1-12]                    |  H  | Hour [0-23]                    |
+ * |  m  | Minute                         |  M  | Month                          |
+ * |  s  | Second                         |  S  | Fraction of second             |
+ * |  y  | Year (abs)                     |  Y  |                                |
+ *
+ * Letters marked by * are not implemented but reserved by Unicode standard.
+ */
+
+const lightFormatters = (exports.lightFormatters = {
+  // Year
+  y(date, token) {
+    // From http://www.unicode.org/reports/tr35/tr35-31/tr35-dates.html#Date_Format_tokens
+    // | Year     |     y | yy |   yyy |  yyyy | yyyyy |
+    // |----------|-------|----|-------|-------|-------|
+    // | AD 1     |     1 | 01 |   001 |  0001 | 00001 |
+    // | AD 12    |    12 | 12 |   012 |  0012 | 00012 |
+    // | AD 123   |   123 | 23 |   123 |  0123 | 00123 |
+    // | AD 1234  |  1234 | 34 |  1234 |  1234 | 01234 |
+    // | AD 12345 | 12345 | 45 | 12345 | 12345 | 12345 |
+
+    const signedYear = date.getFullYear();
+    // Returns 1 for 1 BC (which is year 0 in JavaScript)
+    const year = signedYear > 0 ? signedYear : 1 - signedYear;
+    return (0, _index.addLeadingZeros)(
+      token === "yy" ? year % 100 : year,
+      token.length,
+    );
+  },
+
+  // Month
+  M(date, token) {
+    const month = date.getMonth();
+    return token === "M"
+      ? String(month + 1)
+      : (0, _index.addLeadingZeros)(month + 1, 2);
+  },
+
+  // Day of the month
+  d(date, token) {
+    return (0, _index.addLeadingZeros)(date.getDate(), token.length);
+  },
+
+  // AM or PM
+  a(date, token) {
+    const dayPeriodEnumValue = date.getHours() / 12 >= 1 ? "pm" : "am";
+
+    switch (token) {
+      case "a":
+      case "aa":
+        return dayPeriodEnumValue.toUpperCase();
+      case "aaa":
+        return dayPeriodEnumValue;
+      case "aaaaa":
+        return dayPeriodEnumValue[0];
+      case "aaaa":
+      default:
+        return dayPeriodEnumValue === "am" ? "a.m." : "p.m.";
+    }
+  },
+
+  // Hour [1-12]
+  h(date, token) {
+    return (0, _index.addLeadingZeros)(
+      date.getHours() % 12 || 12,
+      token.length,
+    );
+  },
+
+  // Hour [0-23]
+  H(date, token) {
+    return (0, _index.addLeadingZeros)(date.getHours(), token.length);
+  },
+
+  // Minute
+  m(date, token) {
+    return (0, _index.addLeadingZeros)(date.getMinutes(), token.length);
+  },
+
+  // Second
+  s(date, token) {
+    return (0, _index.addLeadingZeros)(date.getSeconds(), token.length);
+  },
+
+  // Fraction of second
+  S(date, token) {
+    const numberOfDigits = token.length;
+    const milliseconds = date.getMilliseconds();
+    const fractionalSeconds = Math.trunc(
+      milliseconds * Math.pow(10, numberOfDigits - 3),
+    );
+    return (0, _index.addLeadingZeros)(fractionalSeconds, token.length);
+  },
+});

node_modules/date-fns/_lib/format/lightFormatters.d.cts

@@ -0,0 +1,11 @@
+export declare const lightFormatters: {
+  y(date: Date, token: string): string;
+  M(date: Date, token: string): string;
+  d(date: Date, token: string): string;
+  a(date: Date, token: string): string;
+  h(date: Date, token: string): string;
+  H(date: Date, token: string): string;
+  m(date: Date, token: string): string;
+  s(date: Date, token: string): string;
+  S(date: Date, token: string): string;
+};

node_modules/date-fns/_lib/format/lightFormatters.d.ts

@@ -0,0 +1,11 @@
+export declare const lightFormatters: {
+  y(date: Date, token: string): string;
+  M(date: Date, token: string): string;
+  d(date: Date, token: string): string;
+  a(date: Date, token: string): string;
+  h(date: Date, token: string): string;
+  H(date: Date, token: string): string;
+  m(date: Date, token: string): string;
+  s(date: Date, token: string): string;
+  S(date: Date, token: string): string;
+};

node_modules/date-fns/_lib/format/lightFormatters.js

@@ -0,0 +1,92 @@
+import { addLeadingZeros } from "../addLeadingZeros.js";
+
+/*
+ * |     | Unit                           |     | Unit                           |
+ * |-----|--------------------------------|-----|--------------------------------|
+ * |  a  | AM, PM                         |  A* |                                |
+ * |  d  | Day of month                   |  D  |                                |
+ * |  h  | Hour [1-12]                    |  H  | Hour [0-23]                    |
+ * |  m  | Minute                         |  M  | Month                          |
+ * |  s  | Second                         |  S  | Fraction of second             |
+ * |  y  | Year (abs)                     |  Y  |                                |
+ *
+ * Letters marked by * are not implemented but reserved by Unicode standard.
+ */
+
+export const lightFormatters = {
+  // Year
+  y(date, token) {
+    // From http://www.unicode.org/reports/tr35/tr35-31/tr35-dates.html#Date_Format_tokens
+    // | Year     |     y | yy |   yyy |  yyyy | yyyyy |
+    // |----------|-------|----|-------|-------|-------|
+    // | AD 1     |     1 | 01 |   001 |  0001 | 00001 |
+    // | AD 12    |    12 | 12 |   012 |  0012 | 00012 |
+    // | AD 123   |   123 | 23 |   123 |  0123 | 00123 |
+    // | AD 1234  |  1234 | 34 |  1234 |  1234 | 01234 |
+    // | AD 12345 | 12345 | 45 | 12345 | 12345 | 12345 |
+
+    const signedYear = date.getFullYear();
+    // Returns 1 for 1 BC (which is year 0 in JavaScript)
+    const year = signedYear > 0 ? signedYear : 1 - signedYear;
+    return addLeadingZeros(token === "yy" ? year % 100 : year, token.length);
+  },
+
+  // Month
+  M(date, token) {
+    const month = date.getMonth();
+    return token === "M" ? String(month + 1) : addLeadingZeros(month + 1, 2);
+  },
+
+  // Day of the month
+  d(date, token) {
+    return addLeadingZeros(date.getDate(), token.length);
+  },
+
+  // AM or PM
+  a(date, token) {
+    const dayPeriodEnumValue = date.getHours() / 12 >= 1 ? "pm" : "am";
+
+    switch (token) {
+      case "a":
+      case "aa":
+        return dayPeriodEnumValue.toUpperCase();
+      case "aaa":
+        return dayPeriodEnumValue;
+      case "aaaaa":
+        return dayPeriodEnumValue[0];
+      case "aaaa":
+      default:
+        return dayPeriodEnumValue === "am" ? "a.m." : "p.m.";
+    }
+  },
+
+  // Hour [1-12]
+  h(date, token) {
+    return addLeadingZeros(date.getHours() % 12 || 12, token.length);
+  },
+
+  // Hour [0-23]
+  H(date, token) {
+    return addLeadingZeros(date.getHours(), token.length);
+  },
+
+  // Minute
+  m(date, token) {
+    return addLeadingZeros(date.getMinutes(), token.length);
+  },
+
+  // Second
+  s(date, token) {
+    return addLeadingZeros(date.getSeconds(), token.length);
+  },
+
+  // Fraction of second
+  S(date, token) {
+    const numberOfDigits = token.length;
+    const milliseconds = date.getMilliseconds();
+    const fractionalSeconds = Math.trunc(
+      milliseconds * Math.pow(10, numberOfDigits - 3),
+    );
+    return addLeadingZeros(fractionalSeconds, token.length);
+  },
+};

node_modules/date-fns/_lib/format/longFormatters.cjs

@@ -0,0 +1,67 @@
+"use strict";
+exports.longFormatters = void 0;
+
+const dateLongFormatter = (pattern, formatLong) => {
+  switch (pattern) {
+    case "P":
+      return formatLong.date({ width: "short" });
+    case "PP":
+      return formatLong.date({ width: "medium" });
+    case "PPP":
+      return formatLong.date({ width: "long" });
+    case "PPPP":
+    default:
+      return formatLong.date({ width: "full" });
+  }
+};
+
+const timeLongFormatter = (pattern, formatLong) => {
+  switch (pattern) {
+    case "p":
+      return formatLong.time({ width: "short" });
+    case "pp":
+      return formatLong.time({ width: "medium" });
+    case "ppp":
+      return formatLong.time({ width: "long" });
+    case "pppp":
+    default:
+      return formatLong.time({ width: "full" });
+  }
+};
+
+const dateTimeLongFormatter = (pattern, formatLong) => {
+  const matchResult = pattern.match(/(P+)(p+)?/) || [];
+  const datePattern = matchResult[1];
+  const timePattern = matchResult[2];
+
+  if (!timePattern) {
+    return dateLongFormatter(pattern, formatLong);
+  }
+
+  let dateTimeFormat;
+
+  switch (datePattern) {
+    case "P":
+      dateTimeFormat = formatLong.dateTime({ width: "short" });
+      break;
+    case "PP":
+      dateTimeFormat = formatLong.dateTime({ width: "medium" });
+      break;
+    case "PPP":
+      dateTimeFormat = formatLong.dateTime({ width: "long" });
+      break;
+    case "PPPP":
+    default:
+      dateTimeFormat = formatLong.dateTime({ width: "full" });
+      break;
+  }
+
+  return dateTimeFormat
+    .replace("{{date}}", dateLongFormatter(datePattern, formatLong))
+    .replace("{{time}}", timeLongFormatter(timePattern, formatLong));
+};
+
+const longFormatters = (exports.longFormatters = {
+  p: timeLongFormatter,
+  P: dateTimeLongFormatter,
+});

node_modules/date-fns/_lib/format/longFormatters.d.cts

@@ -0,0 +1,4 @@
+import type { FormatLong } from "../../locale/types.js";
+type LongFormatter = (pattern: string, formatLong: FormatLong) => string;
+export declare const longFormatters: Record<string, LongFormatter>;
+export {};

node_modules/date-fns/_lib/format/longFormatters.d.ts

@@ -0,0 +1,4 @@
+import type { FormatLong } from "../../locale/types.js";
+type LongFormatter = (pattern: string, formatLong: FormatLong) => string;
+export declare const longFormatters: Record<string, LongFormatter>;
+export {};

node_modules/date-fns/_lib/format/longFormatters.js

@@ -0,0 +1,64 @@
+const dateLongFormatter = (pattern, formatLong) => {
+  switch (pattern) {
+    case "P":
+      return formatLong.date({ width: "short" });
+    case "PP":
+      return formatLong.date({ width: "medium" });
+    case "PPP":
+      return formatLong.date({ width: "long" });
+    case "PPPP":
+    default:
+      return formatLong.date({ width: "full" });
+  }
+};
+
+const timeLongFormatter = (pattern, formatLong) => {
+  switch (pattern) {
+    case "p":
+      return formatLong.time({ width: "short" });
+    case "pp":
+      return formatLong.time({ width: "medium" });
+    case "ppp":
+      return formatLong.time({ width: "long" });
+    case "pppp":
+    default:
+      return formatLong.time({ width: "full" });
+  }
+};
+
+const dateTimeLongFormatter = (pattern, formatLong) => {
+  const matchResult = pattern.match(/(P+)(p+)?/) || [];
+  const datePattern = matchResult[1];
+  const timePattern = matchResult[2];
+
+  if (!timePattern) {
+    return dateLongFormatter(pattern, formatLong);
+  }
+
+  let dateTimeFormat;
+
+  switch (datePattern) {
+    case "P":
+      dateTimeFormat = formatLong.dateTime({ width: "short" });
+      break;
+    case "PP":
+      dateTimeFormat = formatLong.dateTime({ width: "medium" });
+      break;
+    case "PPP":
+      dateTimeFormat = formatLong.dateTime({ width: "long" });
+      break;
+    case "PPPP":
+    default:
+      dateTimeFormat = formatLong.dateTime({ width: "full" });
+      break;
+  }
+
+  return dateTimeFormat
+    .replace("{{date}}", dateLongFormatter(datePattern, formatLong))
+    .replace("{{time}}", timeLongFormatter(timePattern, formatLong));
+};
+
+export const longFormatters = {
+  p: timeLongFormatter,
+  P: dateTimeLongFormatter,
+};

node_modules/date-fns/_lib/getRoundingMethod.cjs

@@ -0,0 +1,11 @@
+"use strict";
+exports.getRoundingMethod = getRoundingMethod;
+
+function getRoundingMethod(method) {
+  return (number) => {
+    const round = method ? Math[method] : Math.trunc;
+    const result = round(number);
+    // Prevent negative zero
+    return result === 0 ? 0 : result;
+  };
+}

node_modules/date-fns/_lib/getRoundingMethod.d.cts

@@ -0,0 +1,4 @@
+import type { RoundingMethod } from "../types.js";
+export declare function getRoundingMethod(
+  method: RoundingMethod | undefined,
+): (number: number) => number;

node_modules/date-fns/_lib/getRoundingMethod.d.ts

@@ -0,0 +1,4 @@
+import type { RoundingMethod } from "../types.js";
+export declare function getRoundingMethod(
+  method: RoundingMethod | undefined,
+): (number: number) => number;

node_modules/date-fns/_lib/getRoundingMethod.js

@@ -0,0 +1,8 @@
+export function getRoundingMethod(method) {
+  return (number) => {
+    const round = method ? Math[method] : Math.trunc;
+    const result = round(number);
+    // Prevent negative zero
+    return result === 0 ? 0 : result;
+  };
+}

node_modules/date-fns/_lib/getTimezoneOffsetInMilliseconds.cjs

@@ -0,0 +1,31 @@
+"use strict";
+exports.getTimezoneOffsetInMilliseconds = getTimezoneOffsetInMilliseconds;
+var _index = require("../toDate.cjs");
+
+/**
+ * Google Chrome as of 67.0.3396.87 introduced timezones with offset that includes seconds.
+ * They usually appear for dates that denote time before the timezones were introduced
+ * (e.g. for 'Europe/Prague' timezone the offset is GMT+00:57:44 before 1 October 1891
+ * and GMT+01:00:00 after that date)
+ *
+ * Date#getTimezoneOffset returns the offset in minutes and would return 57 for the example above,
+ * which would lead to incorrect calculations.
+ *
+ * This function returns the timezone offset in milliseconds that takes seconds in account.
+ */
+function getTimezoneOffsetInMilliseconds(date) {
+  const _date = (0, _index.toDate)(date);
+  const utcDate = new Date(
+    Date.UTC(
+      _date.getFullYear(),
+      _date.getMonth(),
+      _date.getDate(),
+      _date.getHours(),
+      _date.getMinutes(),
+      _date.getSeconds(),
+      _date.getMilliseconds(),
+    ),
+  );
+  utcDate.setUTCFullYear(_date.getFullYear());
+  return +date - +utcDate;
+}

node_modules/date-fns/_lib/getTimezoneOffsetInMilliseconds.d.cts

@@ -0,0 +1,15 @@
+import type { DateArg } from "../types.js";
+/**
+ * Google Chrome as of 67.0.3396.87 introduced timezones with offset that includes seconds.
+ * They usually appear for dates that denote time before the timezones were introduced
+ * (e.g. for 'Europe/Prague' timezone the offset is GMT+00:57:44 before 1 October 1891
+ * and GMT+01:00:00 after that date)
+ *
+ * Date#getTimezoneOffset returns the offset in minutes and would return 57 for the example above,
+ * which would lead to incorrect calculations.
+ *
+ * This function returns the timezone offset in milliseconds that takes seconds in account.
+ */
+export declare function getTimezoneOffsetInMilliseconds(
+  date: DateArg<Date> & {},
+): number;

node_modules/date-fns/_lib/getTimezoneOffsetInMilliseconds.d.ts

@@ -0,0 +1,15 @@
+import type { DateArg } from "../types.js";
+/**
+ * Google Chrome as of 67.0.3396.87 introduced timezones with offset that includes seconds.
+ * They usually appear for dates that denote time before the timezones were introduced
+ * (e.g. for 'Europe/Prague' timezone the offset is GMT+00:57:44 before 1 October 1891
+ * and GMT+01:00:00 after that date)
+ *
+ * Date#getTimezoneOffset returns the offset in minutes and would return 57 for the example above,
+ * which would lead to incorrect calculations.
+ *
+ * This function returns the timezone offset in milliseconds that takes seconds in account.
+ */
+export declare function getTimezoneOffsetInMilliseconds(
+  date: DateArg<Date> & {},
+): number;

node_modules/date-fns/_lib/getTimezoneOffsetInMilliseconds.js

@@ -0,0 +1,29 @@
+import { toDate } from "../toDate.js";
+
+/**
+ * Google Chrome as of 67.0.3396.87 introduced timezones with offset that includes seconds.
+ * They usually appear for dates that denote time before the timezones were introduced
+ * (e.g. for 'Europe/Prague' timezone the offset is GMT+00:57:44 before 1 October 1891
+ * and GMT+01:00:00 after that date)
+ *
+ * Date#getTimezoneOffset returns the offset in minutes and would return 57 for the example above,
+ * which would lead to incorrect calculations.
+ *
+ * This function returns the timezone offset in milliseconds that takes seconds in account.
+ */
+export function getTimezoneOffsetInMilliseconds(date) {
+  const _date = toDate(date);
+  const utcDate = new Date(
+    Date.UTC(
+      _date.getFullYear(),
+      _date.getMonth(),
+      _date.getDate(),
+      _date.getHours(),
+      _date.getMinutes(),
+      _date.getSeconds(),
+      _date.getMilliseconds(),
+    ),
+  );
+  utcDate.setUTCFullYear(_date.getFullYear());
+  return +date - +utcDate;
+}

node_modules/date-fns/_lib/normalizeDates.cjs

@@ -0,0 +1,11 @@
+"use strict";
+exports.normalizeDates = normalizeDates;
+var _index = require("../constructFrom.cjs");
+
+function normalizeDates(context, ...dates) {
+  const normalize = _index.constructFrom.bind(
+    null,
+    context || dates.find((date) => typeof date === "object"),
+  );
+  return dates.map(normalize);
+}

node_modules/date-fns/_lib/normalizeDates.d.cts

@@ -0,0 +1,13 @@
+import type { ContextFn, DateArg } from "../types.js";
+export declare function normalizeDates(
+  context: ContextFn<Date> | undefined,
+  ...dates: [DateArg<Date>, DateArg<Date>, DateArg<Date>]
+): [Date, Date, Date];
+export declare function normalizeDates(
+  context: ContextFn<Date> | undefined,
+  ...dates: [DateArg<Date>, DateArg<Date>]
+): [Date, Date];
+export declare function normalizeDates(
+  context: ContextFn<Date> | undefined,
+  ...dates: Array<DateArg<Date> & {}>
+): Date[];

node_modules/date-fns/_lib/normalizeDates.d.ts

@@ -0,0 +1,13 @@
+import type { ContextFn, DateArg } from "../types.js";
+export declare function normalizeDates(
+  context: ContextFn<Date> | undefined,
+  ...dates: [DateArg<Date>, DateArg<Date>, DateArg<Date>]
+): [Date, Date, Date];
+export declare function normalizeDates(
+  context: ContextFn<Date> | undefined,
+  ...dates: [DateArg<Date>, DateArg<Date>]
+): [Date, Date];
+export declare function normalizeDates(
+  context: ContextFn<Date> | undefined,
+  ...dates: Array<DateArg<Date> & {}>
+): Date[];

node_modules/date-fns/_lib/normalizeDates.js

@@ -0,0 +1,9 @@
+import { constructFrom } from "../constructFrom.js";
+
+export function normalizeDates(context, ...dates) {
+  const normalize = constructFrom.bind(
+    null,
+    context || dates.find((date) => typeof date === "object"),
+  );
+  return dates.map(normalize);
+}

node_modules/date-fns/_lib/normalizeInterval.cjs

@@ -0,0 +1,12 @@
+"use strict";
+exports.normalizeInterval = normalizeInterval;
+var _index = require("./normalizeDates.cjs");
+
+function normalizeInterval(context, interval) {
+  const [start, end] = (0, _index.normalizeDates)(
+    context,
+    interval.start,
+    interval.end,
+  );
+  return { start, end };
+}

node_modules/date-fns/_lib/normalizeInterval.d.cts

@@ -0,0 +1,5 @@
+import type { ContextFn, Interval, NormalizedInterval } from "../types.js";
+export declare function normalizeInterval(
+  context: ContextFn<Date> | undefined,
+  interval: Interval,
+): NormalizedInterval<Date>;

node_modules/date-fns/_lib/normalizeInterval.d.ts

@@ -0,0 +1,5 @@
+import type { ContextFn, Interval, NormalizedInterval } from "../types.js";
+export declare function normalizeInterval(
+  context: ContextFn<Date> | undefined,
+  interval: Interval,
+): NormalizedInterval<Date>;

node_modules/date-fns/_lib/normalizeInterval.js

@@ -0,0 +1,6 @@
+import { normalizeDates } from "./normalizeDates.js";
+
+export function normalizeInterval(context, interval) {
+  const [start, end] = normalizeDates(context, interval.start, interval.end);
+  return { start, end };
+}

node_modules/date-fns/_lib/protectedTokens.cjs

@@ -0,0 +1,27 @@
+"use strict";
+exports.isProtectedDayOfYearToken = isProtectedDayOfYearToken;
+exports.isProtectedWeekYearToken = isProtectedWeekYearToken;
+exports.warnOrThrowProtectedError = warnOrThrowProtectedError;
+const dayOfYearTokenRE = /^D+$/;
+const weekYearTokenRE = /^Y+$/;
+
+const throwTokens = ["D", "DD", "YY", "YYYY"];
+
+function isProtectedDayOfYearToken(token) {
+  return dayOfYearTokenRE.test(token);
+}
+
+function isProtectedWeekYearToken(token) {
+  return weekYearTokenRE.test(token);
+}
+
+function warnOrThrowProtectedError(token, format, input) {
+  const _message = message(token, format, input);
+  console.warn(_message);
+  if (throwTokens.includes(token)) throw new RangeError(_message);
+}
+
+function message(token, format, input) {
+  const subject = token[0] === "Y" ? "years" : "days of the month";
+  return `Use \`${token.toLowerCase()}\` instead of \`${token}\` (in \`${format}\`) for formatting ${subject} to the input \`${input}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`;
+}

node_modules/date-fns/_lib/protectedTokens.d.cts

@@ -0,0 +1,7 @@
+export declare function isProtectedDayOfYearToken(token: string): boolean;
+export declare function isProtectedWeekYearToken(token: string): boolean;
+export declare function warnOrThrowProtectedError(
+  token: string,
+  format: string,
+  input: string,
+): void;

node_modules/date-fns/_lib/protectedTokens.d.ts

@@ -0,0 +1,7 @@
+export declare function isProtectedDayOfYearToken(token: string): boolean;
+export declare function isProtectedWeekYearToken(token: string): boolean;
+export declare function warnOrThrowProtectedError(
+  token: string,
+  format: string,
+  input: string,
+): void;

node_modules/date-fns/_lib/protectedTokens.js

@@ -0,0 +1,23 @@
+const dayOfYearTokenRE = /^D+$/;
+const weekYearTokenRE = /^Y+$/;
+
+const throwTokens = ["D", "DD", "YY", "YYYY"];
+
+export function isProtectedDayOfYearToken(token) {
+  return dayOfYearTokenRE.test(token);
+}
+
+export function isProtectedWeekYearToken(token) {
+  return weekYearTokenRE.test(token);
+}
+
+export function warnOrThrowProtectedError(token, format, input) {
+  const _message = message(token, format, input);
+  console.warn(_message);
+  if (throwTokens.includes(token)) throw new RangeError(_message);
+}
+
+function message(token, format, input) {
+  const subject = token[0] === "Y" ? "years" : "days of the month";
+  return `Use \`${token.toLowerCase()}\` instead of \`${token}\` (in \`${format}\`) for formatting ${subject} to the input \`${input}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`;
+}

node_modules/date-fns/_lib/test.cjs

@@ -0,0 +1,59 @@
+"use strict";
+exports.assertType = assertType;
+exports.fakeDate = fakeDate;
+exports.generateOffset = generateOffset;
+exports.resetDefaultOptions = resetDefaultOptions;
+var _vitest = require("./test/vitest");
+var _index = require("./addLeadingZeros.cjs");
+var _index2 = require("./defaultOptions.cjs");
+var _sinon = require("./test/sinon");
+
+function assertType(_value) {}
+
+function resetDefaultOptions() {
+  (0, _index2.setDefaultOptions)({});
+}
+
+// This makes sure we create the consistent offsets across timezones, no matter where these tests are ran.
+function generateOffset(originalDate) {
+  // Add the timezone.
+  let offset = "";
+  const tzOffset = originalDate.getTimezoneOffset();
+
+  if (tzOffset !== 0) {
+    const absoluteOffset = Math.abs(tzOffset);
+    const hourOffset = (0, _index.addLeadingZeros)(
+      Math.trunc(absoluteOffset / 60),
+      2,
+    );
+    const minuteOffset = (0, _index.addLeadingZeros)(absoluteOffset % 60, 2);
+    // If less than 0, the sign is +, because it is ahead of time.
+    const sign = tzOffset < 0 ? "+" : "-";
+
+    offset = `${sign}${hourOffset}:${minuteOffset}`;
+  } else {
+    offset = "Z";
+  }
+
+  return offset;
+}
+
+function fakeDate(date) {
+  let clock;
+
+  function fakeNow(date) {
+    clock?.restore();
+    clock = _sinon.default.useFakeTimers(+date);
+  }
+
+  (0, _vitest.beforeEach)(() => {
+    fakeNow(+date);
+  });
+
+  (0, _vitest.afterEach)(() => {
+    clock?.restore();
+    clock = undefined;
+  });
+
+  return { fakeNow };
+}

node_modules/date-fns/_lib/test.d.cts

@@ -0,0 +1,14 @@
+export declare function assertType<Type>(_value: Type): void;
+export declare namespace assertType {
+  type Equal<T, U> =
+    Exclude<T, U> extends never
+      ? Exclude<U, T> extends never
+        ? true
+        : false
+      : false;
+}
+export declare function resetDefaultOptions(): void;
+export declare function generateOffset(originalDate: Date): string;
+export declare function fakeDate(date: number | Date): {
+  fakeNow: (date: number | Date) => void;
+};

node_modules/date-fns/_lib/test.d.ts

@@ -0,0 +1,14 @@
+export declare function assertType<Type>(_value: Type): void;
+export declare namespace assertType {
+  type Equal<T, U> =
+    Exclude<T, U> extends never
+      ? Exclude<U, T> extends never
+        ? true
+        : false
+      : false;
+}
+export declare function resetDefaultOptions(): void;
+export declare function generateOffset(originalDate: Date): string;
+export declare function fakeDate(date: number | Date): {
+  fakeNow: (date: number | Date) => void;
+};

node_modules/date-fns/_lib/test.js

@@ -0,0 +1,51 @@
+import { afterEach, beforeEach } from "./test/vitest";
+import { addLeadingZeros } from "./addLeadingZeros.js";
+import { setDefaultOptions } from "./defaultOptions.js";
+import sinon from "./test/sinon";
+
+export function assertType(_value) {}
+
+export function resetDefaultOptions() {
+  setDefaultOptions({});
+}
+
+// This makes sure we create the consistent offsets across timezones, no matter where these tests are ran.
+export function generateOffset(originalDate) {
+  // Add the timezone.
+  let offset = "";
+  const tzOffset = originalDate.getTimezoneOffset();
+
+  if (tzOffset !== 0) {
+    const absoluteOffset = Math.abs(tzOffset);
+    const hourOffset = addLeadingZeros(Math.trunc(absoluteOffset / 60), 2);
+    const minuteOffset = addLeadingZeros(absoluteOffset % 60, 2);
+    // If less than 0, the sign is +, because it is ahead of time.
+    const sign = tzOffset < 0 ? "+" : "-";
+
+    offset = `${sign}${hourOffset}:${minuteOffset}`;
+  } else {
+    offset = "Z";
+  }
+
+  return offset;
+}
+
+export function fakeDate(date) {
+  let clock;
+
+  function fakeNow(date) {
+    clock?.restore();
+    clock = sinon.useFakeTimers(+date);
+  }
+
+  beforeEach(() => {
+    fakeNow(+date);
+  });
+
+  afterEach(() => {
+    clock?.restore();
+    clock = undefined;
+  });
+
+  return { fakeNow };
+}

node_modules/date-fns/add.cjs

@@ -0,0 +1,75 @@
+"use strict";
+exports.add = add;
+var _index = require("./addDays.cjs");
+var _index2 = require("./addMonths.cjs");
+var _index3 = require("./constructFrom.cjs");
+var _index4 = require("./toDate.cjs");
+
+/**
+ * The {@link add} function options.
+ */
+
+/**
+ * @name add
+ * @category Common Helpers
+ * @summary Add the specified years, months, weeks, days, hours, minutes, and seconds to the given date.
+ *
+ * @description
+ * Add the specified years, months, weeks, days, hours, minutes, and seconds to the given date.
+ *
+ * @typeParam DateType - The `Date` type the function operates on. Gets inferred from passed arguments. Allows using extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param duration - The object with years, months, weeks, days, hours, minutes, and seconds to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the seconds added
+ *
+ * @example
+ * // Add the following duration to 1 September 2014, 10:19:50
+ * const result = add(new Date(2014, 8, 1, 10, 19, 50), {
+ *   years: 2,
+ *   months: 9,
+ *   weeks: 1,
+ *   days: 7,
+ *   hours: 5,
+ *   minutes: 9,
+ *   seconds: 30,
+ * })
+ * //=> Thu Jun 15 2017 15:29:20
+ */
+function add(date, duration, options) {
+  const {
+    years = 0,
+    months = 0,
+    weeks = 0,
+    days = 0,
+    hours = 0,
+    minutes = 0,
+    seconds = 0,
+  } = duration;
+
+  // Add years and months
+  const _date = (0, _index4.toDate)(date, options?.in);
+  const dateWithMonths =
+    months || years
+      ? (0, _index2.addMonths)(_date, months + years * 12)
+      : _date;
+
+  // Add weeks and days
+  const dateWithDays =
+    days || weeks
+      ? (0, _index.addDays)(dateWithMonths, days + weeks * 7)
+      : dateWithMonths;
+
+  // Add days, hours, minutes, and seconds
+  const minutesToAdd = minutes + hours * 60;
+  const secondsToAdd = seconds + minutesToAdd * 60;
+  const msToAdd = secondsToAdd * 1000;
+
+  return (0, _index3.constructFrom)(
+    options?.in || date,
+    +dateWithDays + msToAdd,
+  );
+}

node_modules/date-fns/add.d.cts

@@ -0,0 +1,44 @@
+import type { ContextOptions, DateArg, Duration } from "./types.js";
+/**
+ * The {@link add} function options.
+ */
+export interface AddOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name add
+ * @category Common Helpers
+ * @summary Add the specified years, months, weeks, days, hours, minutes, and seconds to the given date.
+ *
+ * @description
+ * Add the specified years, months, weeks, days, hours, minutes, and seconds to the given date.
+ *
+ * @typeParam DateType - The `Date` type the function operates on. Gets inferred from passed arguments. Allows using extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param duration - The object with years, months, weeks, days, hours, minutes, and seconds to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the seconds added
+ *
+ * @example
+ * // Add the following duration to 1 September 2014, 10:19:50
+ * const result = add(new Date(2014, 8, 1, 10, 19, 50), {
+ *   years: 2,
+ *   months: 9,
+ *   weeks: 1,
+ *   days: 7,
+ *   hours: 5,
+ *   minutes: 9,
+ *   seconds: 30,
+ * })
+ * //=> Thu Jun 15 2017 15:29:20
+ */
+export declare function add<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  duration: Duration,
+  options?: AddOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/add.d.ts

@@ -0,0 +1,44 @@
+import type { ContextOptions, DateArg, Duration } from "./types.js";
+/**
+ * The {@link add} function options.
+ */
+export interface AddOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name add
+ * @category Common Helpers
+ * @summary Add the specified years, months, weeks, days, hours, minutes, and seconds to the given date.
+ *
+ * @description
+ * Add the specified years, months, weeks, days, hours, minutes, and seconds to the given date.
+ *
+ * @typeParam DateType - The `Date` type the function operates on. Gets inferred from passed arguments. Allows using extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param duration - The object with years, months, weeks, days, hours, minutes, and seconds to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the seconds added
+ *
+ * @example
+ * // Add the following duration to 1 September 2014, 10:19:50
+ * const result = add(new Date(2014, 8, 1, 10, 19, 50), {
+ *   years: 2,
+ *   months: 9,
+ *   weeks: 1,
+ *   days: 7,
+ *   hours: 5,
+ *   minutes: 9,
+ *   seconds: 30,
+ * })
+ * //=> Thu Jun 15 2017 15:29:20
+ */
+export declare function add<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  duration: Duration,
+  options?: AddOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/add.js

@@ -0,0 +1,69 @@
+import { addDays } from "./addDays.js";
+import { addMonths } from "./addMonths.js";
+import { constructFrom } from "./constructFrom.js";
+import { toDate } from "./toDate.js";
+
+/**
+ * The {@link add} function options.
+ */
+
+/**
+ * @name add
+ * @category Common Helpers
+ * @summary Add the specified years, months, weeks, days, hours, minutes, and seconds to the given date.
+ *
+ * @description
+ * Add the specified years, months, weeks, days, hours, minutes, and seconds to the given date.
+ *
+ * @typeParam DateType - The `Date` type the function operates on. Gets inferred from passed arguments. Allows using extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param duration - The object with years, months, weeks, days, hours, minutes, and seconds to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the seconds added
+ *
+ * @example
+ * // Add the following duration to 1 September 2014, 10:19:50
+ * const result = add(new Date(2014, 8, 1, 10, 19, 50), {
+ *   years: 2,
+ *   months: 9,
+ *   weeks: 1,
+ *   days: 7,
+ *   hours: 5,
+ *   minutes: 9,
+ *   seconds: 30,
+ * })
+ * //=> Thu Jun 15 2017 15:29:20
+ */
+export function add(date, duration, options) {
+  const {
+    years = 0,
+    months = 0,
+    weeks = 0,
+    days = 0,
+    hours = 0,
+    minutes = 0,
+    seconds = 0,
+  } = duration;
+
+  // Add years and months
+  const _date = toDate(date, options?.in);
+  const dateWithMonths =
+    months || years ? addMonths(_date, months + years * 12) : _date;
+
+  // Add weeks and days
+  const dateWithDays =
+    days || weeks ? addDays(dateWithMonths, days + weeks * 7) : dateWithMonths;
+
+  // Add days, hours, minutes, and seconds
+  const minutesToAdd = minutes + hours * 60;
+  const secondsToAdd = seconds + minutesToAdd * 60;
+  const msToAdd = secondsToAdd * 1000;
+
+  return constructFrom(options?.in || date, +dateWithDays + msToAdd);
+}
+
+// Fallback for modularized imports:
+export default add;

node_modules/date-fns/addBusinessDays.cjs

@@ -0,0 +1,76 @@
+"use strict";
+exports.addBusinessDays = addBusinessDays;
+var _index = require("./constructFrom.cjs");
+var _index2 = require("./isSaturday.cjs");
+var _index3 = require("./isSunday.cjs");
+var _index4 = require("./isWeekend.cjs");
+var _index5 = require("./toDate.cjs");
+
+/**
+ * The {@link addBusinessDays} function options.
+ */
+
+/**
+ * @name addBusinessDays
+ * @category Day Helpers
+ * @summary Add the specified number of business days (mon - fri) to the given date.
+ *
+ * @description
+ * Add the specified number of business days (mon - fri) to the given date, ignoring weekends.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of business days to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the business days added
+ *
+ * @example
+ * // Add 10 business days to 1 September 2014:
+ * const result = addBusinessDays(new Date(2014, 8, 1), 10)
+ * //=> Mon Sep 15 2014 00:00:00 (skipped weekend days)
+ */
+function addBusinessDays(date, amount, options) {
+  const _date = (0, _index5.toDate)(date, options?.in);
+  const startedOnWeekend = (0, _index4.isWeekend)(_date, options);
+
+  if (isNaN(amount)) return (0, _index.constructFrom)(options?.in, NaN);
+
+  const hours = _date.getHours();
+  const sign = amount < 0 ? -1 : 1;
+  const fullWeeks = Math.trunc(amount / 5);
+
+  _date.setDate(_date.getDate() + fullWeeks * 7);
+
+  // Get remaining days not part of a full week
+  let restDays = Math.abs(amount % 5);
+
+  // Loops over remaining days
+  while (restDays > 0) {
+    _date.setDate(_date.getDate() + sign);
+    if (!(0, _index4.isWeekend)(_date, options)) restDays -= 1;
+  }
+
+  // If the date is a weekend day and we reduce a dividable of
+  // 5 from it, we land on a weekend date.
+  // To counter this, we add days accordingly to land on the next business day
+  if (
+    startedOnWeekend &&
+    (0, _index4.isWeekend)(_date, options) &&
+    amount !== 0
+  ) {
+    // If we're reducing days, we want to add days until we land on a weekday
+    // If we're adding days we want to reduce days until we land on a weekday
+    if ((0, _index2.isSaturday)(_date, options))
+      _date.setDate(_date.getDate() + (sign < 0 ? 2 : -1));
+    if ((0, _index3.isSunday)(_date, options))
+      _date.setDate(_date.getDate() + (sign < 0 ? 1 : -2));
+  }
+
+  // Restore hours to avoid DST lag
+  _date.setHours(hours);
+
+  return _date;
+}

node_modules/date-fns/addBusinessDays.d.cts

@@ -0,0 +1,36 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addBusinessDays} function options.
+ */
+export interface AddBusinessDaysOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addBusinessDays
+ * @category Day Helpers
+ * @summary Add the specified number of business days (mon - fri) to the given date.
+ *
+ * @description
+ * Add the specified number of business days (mon - fri) to the given date, ignoring weekends.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of business days to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the business days added
+ *
+ * @example
+ * // Add 10 business days to 1 September 2014:
+ * const result = addBusinessDays(new Date(2014, 8, 1), 10)
+ * //=> Mon Sep 15 2014 00:00:00 (skipped weekend days)
+ */
+export declare function addBusinessDays<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddBusinessDaysOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addBusinessDays.d.ts

@@ -0,0 +1,36 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addBusinessDays} function options.
+ */
+export interface AddBusinessDaysOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addBusinessDays
+ * @category Day Helpers
+ * @summary Add the specified number of business days (mon - fri) to the given date.
+ *
+ * @description
+ * Add the specified number of business days (mon - fri) to the given date, ignoring weekends.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of business days to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the business days added
+ *
+ * @example
+ * // Add 10 business days to 1 September 2014:
+ * const result = addBusinessDays(new Date(2014, 8, 1), 10)
+ * //=> Mon Sep 15 2014 00:00:00 (skipped weekend days)
+ */
+export declare function addBusinessDays<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddBusinessDaysOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addBusinessDays.js

@@ -0,0 +1,73 @@
+import { constructFrom } from "./constructFrom.js";
+import { isSaturday } from "./isSaturday.js";
+import { isSunday } from "./isSunday.js";
+import { isWeekend } from "./isWeekend.js";
+import { toDate } from "./toDate.js";
+
+/**
+ * The {@link addBusinessDays} function options.
+ */
+
+/**
+ * @name addBusinessDays
+ * @category Day Helpers
+ * @summary Add the specified number of business days (mon - fri) to the given date.
+ *
+ * @description
+ * Add the specified number of business days (mon - fri) to the given date, ignoring weekends.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of business days to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the business days added
+ *
+ * @example
+ * // Add 10 business days to 1 September 2014:
+ * const result = addBusinessDays(new Date(2014, 8, 1), 10)
+ * //=> Mon Sep 15 2014 00:00:00 (skipped weekend days)
+ */
+export function addBusinessDays(date, amount, options) {
+  const _date = toDate(date, options?.in);
+  const startedOnWeekend = isWeekend(_date, options);
+
+  if (isNaN(amount)) return constructFrom(options?.in, NaN);
+
+  const hours = _date.getHours();
+  const sign = amount < 0 ? -1 : 1;
+  const fullWeeks = Math.trunc(amount / 5);
+
+  _date.setDate(_date.getDate() + fullWeeks * 7);
+
+  // Get remaining days not part of a full week
+  let restDays = Math.abs(amount % 5);
+
+  // Loops over remaining days
+  while (restDays > 0) {
+    _date.setDate(_date.getDate() + sign);
+    if (!isWeekend(_date, options)) restDays -= 1;
+  }
+
+  // If the date is a weekend day and we reduce a dividable of
+  // 5 from it, we land on a weekend date.
+  // To counter this, we add days accordingly to land on the next business day
+  if (startedOnWeekend && isWeekend(_date, options) && amount !== 0) {
+    // If we're reducing days, we want to add days until we land on a weekday
+    // If we're adding days we want to reduce days until we land on a weekday
+    if (isSaturday(_date, options))
+      _date.setDate(_date.getDate() + (sign < 0 ? 2 : -1));
+    if (isSunday(_date, options))
+      _date.setDate(_date.getDate() + (sign < 0 ? 1 : -2));
+  }
+
+  // Restore hours to avoid DST lag
+  _date.setHours(hours);
+
+  return _date;
+}
+
+// Fallback for modularized imports:
+export default addBusinessDays;

node_modules/date-fns/addDays.cjs

@@ -0,0 +1,41 @@
+"use strict";
+exports.addDays = addDays;
+var _index = require("./constructFrom.cjs");
+var _index2 = require("./toDate.cjs");
+
+/**
+ * The {@link addDays} function options.
+ */
+
+/**
+ * @name addDays
+ * @category Day Helpers
+ * @summary Add the specified number of days to the given date.
+ *
+ * @description
+ * Add the specified number of days to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of days to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the days added
+ *
+ * @example
+ * // Add 10 days to 1 September 2014:
+ * const result = addDays(new Date(2014, 8, 1), 10)
+ * //=> Thu Sep 11 2014 00:00:00
+ */
+function addDays(date, amount, options) {
+  const _date = (0, _index2.toDate)(date, options?.in);
+  if (isNaN(amount)) return (0, _index.constructFrom)(options?.in || date, NaN);
+
+  // If 0 days, no-op to avoid changing times in the hour before end of DST
+  if (!amount) return _date;
+
+  _date.setDate(_date.getDate() + amount);
+  return _date;
+}

node_modules/date-fns/addDays.d.cts

@@ -0,0 +1,36 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addDays} function options.
+ */
+export interface AddDaysOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addDays
+ * @category Day Helpers
+ * @summary Add the specified number of days to the given date.
+ *
+ * @description
+ * Add the specified number of days to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of days to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the days added
+ *
+ * @example
+ * // Add 10 days to 1 September 2014:
+ * const result = addDays(new Date(2014, 8, 1), 10)
+ * //=> Thu Sep 11 2014 00:00:00
+ */
+export declare function addDays<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddDaysOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addDays.d.ts

@@ -0,0 +1,36 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addDays} function options.
+ */
+export interface AddDaysOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addDays
+ * @category Day Helpers
+ * @summary Add the specified number of days to the given date.
+ *
+ * @description
+ * Add the specified number of days to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of days to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the days added
+ *
+ * @example
+ * // Add 10 days to 1 September 2014:
+ * const result = addDays(new Date(2014, 8, 1), 10)
+ * //=> Thu Sep 11 2014 00:00:00
+ */
+export declare function addDays<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddDaysOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addDays.js

@@ -0,0 +1,42 @@
+import { constructFrom } from "./constructFrom.js";
+import { toDate } from "./toDate.js";
+
+/**
+ * The {@link addDays} function options.
+ */
+
+/**
+ * @name addDays
+ * @category Day Helpers
+ * @summary Add the specified number of days to the given date.
+ *
+ * @description
+ * Add the specified number of days to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of days to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the days added
+ *
+ * @example
+ * // Add 10 days to 1 September 2014:
+ * const result = addDays(new Date(2014, 8, 1), 10)
+ * //=> Thu Sep 11 2014 00:00:00
+ */
+export function addDays(date, amount, options) {
+  const _date = toDate(date, options?.in);
+  if (isNaN(amount)) return constructFrom(options?.in || date, NaN);
+
+  // If 0 days, no-op to avoid changing times in the hour before end of DST
+  if (!amount) return _date;
+
+  _date.setDate(_date.getDate() + amount);
+  return _date;
+}
+
+// Fallback for modularized imports:
+export default addDays;

node_modules/date-fns/addHours.cjs

@@ -0,0 +1,38 @@
+"use strict";
+exports.addHours = addHours;
+var _index = require("./addMilliseconds.cjs");
+var _index2 = require("./constants.cjs");
+
+/**
+ * The {@link addHours} function options.
+ */
+
+/**
+ * @name addHours
+ * @category Hour Helpers
+ * @summary Add the specified number of hours to the given date.
+ *
+ * @description
+ * Add the specified number of hours to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of hours to be added
+ * @param options - An object with options
+ *
+ * @returns The new date with the hours added
+ *
+ * @example
+ * // Add 2 hours to 10 July 2014 23:00:00:
+ * const result = addHours(new Date(2014, 6, 10, 23, 0), 2)
+ * //=> Fri Jul 11 2014 01:00:00
+ */
+function addHours(date, amount, options) {
+  return (0, _index.addMilliseconds)(
+    date,
+    amount * _index2.millisecondsInHour,
+    options,
+  );
+}

node_modules/date-fns/addHours.d.cts

@@ -0,0 +1,36 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addHours} function options.
+ */
+export interface AddHoursOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addHours
+ * @category Hour Helpers
+ * @summary Add the specified number of hours to the given date.
+ *
+ * @description
+ * Add the specified number of hours to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of hours to be added
+ * @param options - An object with options
+ *
+ * @returns The new date with the hours added
+ *
+ * @example
+ * // Add 2 hours to 10 July 2014 23:00:00:
+ * const result = addHours(new Date(2014, 6, 10, 23, 0), 2)
+ * //=> Fri Jul 11 2014 01:00:00
+ */
+export declare function addHours<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddHoursOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addHours.d.ts

@@ -0,0 +1,36 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addHours} function options.
+ */
+export interface AddHoursOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addHours
+ * @category Hour Helpers
+ * @summary Add the specified number of hours to the given date.
+ *
+ * @description
+ * Add the specified number of hours to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of hours to be added
+ * @param options - An object with options
+ *
+ * @returns The new date with the hours added
+ *
+ * @example
+ * // Add 2 hours to 10 July 2014 23:00:00:
+ * const result = addHours(new Date(2014, 6, 10, 23, 0), 2)
+ * //=> Fri Jul 11 2014 01:00:00
+ */
+export declare function addHours<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddHoursOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addHours.js

@@ -0,0 +1,35 @@
+import { addMilliseconds } from "./addMilliseconds.js";
+import { millisecondsInHour } from "./constants.js";
+
+/**
+ * The {@link addHours} function options.
+ */
+
+/**
+ * @name addHours
+ * @category Hour Helpers
+ * @summary Add the specified number of hours to the given date.
+ *
+ * @description
+ * Add the specified number of hours to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of hours to be added
+ * @param options - An object with options
+ *
+ * @returns The new date with the hours added
+ *
+ * @example
+ * // Add 2 hours to 10 July 2014 23:00:00:
+ * const result = addHours(new Date(2014, 6, 10, 23, 0), 2)
+ * //=> Fri Jul 11 2014 01:00:00
+ */
+export function addHours(date, amount, options) {
+  return addMilliseconds(date, amount * millisecondsInHour, options);
+}
+
+// Fallback for modularized imports:
+export default addHours;

node_modules/date-fns/addISOWeekYears.cjs

@@ -0,0 +1,39 @@
+"use strict";
+exports.addISOWeekYears = addISOWeekYears;
+var _index = require("./getISOWeekYear.cjs");
+var _index2 = require("./setISOWeekYear.cjs");
+
+/**
+ * The {@link addISOWeekYears} function options.
+ */
+
+/**
+ * @name addISOWeekYears
+ * @category ISO Week-Numbering Year Helpers
+ * @summary Add the specified number of ISO week-numbering years to the given date.
+ *
+ * @description
+ * Add the specified number of ISO week-numbering years to the given date.
+ *
+ * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of ISO week-numbering years to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the ISO week-numbering years added
+ *
+ * @example
+ * // Add 5 ISO week-numbering years to 2 July 2010:
+ * const result = addISOWeekYears(new Date(2010, 6, 2), 5)
+ * //=> Fri Jun 26 2015 00:00:00
+ */
+function addISOWeekYears(date, amount, options) {
+  return (0, _index2.setISOWeekYear)(
+    date,
+    (0, _index.getISOWeekYear)(date, options) + amount,
+    options,
+  );
+}

node_modules/date-fns/addISOWeekYears.d.cts

@@ -0,0 +1,37 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addISOWeekYears} function options.
+ */
+export interface AddISOWeekYearsOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addISOWeekYears
+ * @category ISO Week-Numbering Year Helpers
+ * @summary Add the specified number of ISO week-numbering years to the given date.
+ *
+ * @description
+ * Add the specified number of ISO week-numbering years to the given date.
+ *
+ * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of ISO week-numbering years to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the ISO week-numbering years added
+ *
+ * @example
+ * // Add 5 ISO week-numbering years to 2 July 2010:
+ * const result = addISOWeekYears(new Date(2010, 6, 2), 5)
+ * //=> Fri Jun 26 2015 00:00:00
+ */
+export declare function addISOWeekYears<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddISOWeekYearsOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addISOWeekYears.d.ts

@@ -0,0 +1,37 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addISOWeekYears} function options.
+ */
+export interface AddISOWeekYearsOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addISOWeekYears
+ * @category ISO Week-Numbering Year Helpers
+ * @summary Add the specified number of ISO week-numbering years to the given date.
+ *
+ * @description
+ * Add the specified number of ISO week-numbering years to the given date.
+ *
+ * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of ISO week-numbering years to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the ISO week-numbering years added
+ *
+ * @example
+ * // Add 5 ISO week-numbering years to 2 July 2010:
+ * const result = addISOWeekYears(new Date(2010, 6, 2), 5)
+ * //=> Fri Jun 26 2015 00:00:00
+ */
+export declare function addISOWeekYears<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddISOWeekYearsOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addISOWeekYears.js

@@ -0,0 +1,36 @@
+import { getISOWeekYear } from "./getISOWeekYear.js";
+import { setISOWeekYear } from "./setISOWeekYear.js";
+
+/**
+ * The {@link addISOWeekYears} function options.
+ */
+
+/**
+ * @name addISOWeekYears
+ * @category ISO Week-Numbering Year Helpers
+ * @summary Add the specified number of ISO week-numbering years to the given date.
+ *
+ * @description
+ * Add the specified number of ISO week-numbering years to the given date.
+ *
+ * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of ISO week-numbering years to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the ISO week-numbering years added
+ *
+ * @example
+ * // Add 5 ISO week-numbering years to 2 July 2010:
+ * const result = addISOWeekYears(new Date(2010, 6, 2), 5)
+ * //=> Fri Jun 26 2015 00:00:00
+ */
+export function addISOWeekYears(date, amount, options) {
+  return setISOWeekYear(date, getISOWeekYear(date, options) + amount, options);
+}
+
+// Fallback for modularized imports:
+export default addISOWeekYears;

node_modules/date-fns/addMilliseconds.cjs

@@ -0,0 +1,37 @@
+"use strict";
+exports.addMilliseconds = addMilliseconds;
+var _index = require("./constructFrom.cjs");
+var _index2 = require("./toDate.cjs");
+
+/**
+ * The {@link addMilliseconds} function options.
+ */
+
+/**
+ * @name addMilliseconds
+ * @category Millisecond Helpers
+ * @summary Add the specified number of milliseconds to the given date.
+ *
+ * @description
+ * Add the specified number of milliseconds to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of milliseconds to be added.
+ * @param options - The options object
+ *
+ * @returns The new date with the milliseconds added
+ *
+ * @example
+ * // Add 750 milliseconds to 10 July 2014 12:45:30.000:
+ * const result = addMilliseconds(new Date(2014, 6, 10, 12, 45, 30, 0), 750)
+ * //=> Thu Jul 10 2014 12:45:30.750
+ */
+function addMilliseconds(date, amount, options) {
+  return (0, _index.constructFrom)(
+    options?.in || date,
+    +(0, _index2.toDate)(date) + amount,
+  );
+}

node_modules/date-fns/addMilliseconds.d.cts

@@ -0,0 +1,36 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addMilliseconds} function options.
+ */
+export interface AddMillisecondsOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addMilliseconds
+ * @category Millisecond Helpers
+ * @summary Add the specified number of milliseconds to the given date.
+ *
+ * @description
+ * Add the specified number of milliseconds to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of milliseconds to be added.
+ * @param options - The options object
+ *
+ * @returns The new date with the milliseconds added
+ *
+ * @example
+ * // Add 750 milliseconds to 10 July 2014 12:45:30.000:
+ * const result = addMilliseconds(new Date(2014, 6, 10, 12, 45, 30, 0), 750)
+ * //=> Thu Jul 10 2014 12:45:30.750
+ */
+export declare function addMilliseconds<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddMillisecondsOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addMilliseconds.d.ts

@@ -0,0 +1,36 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addMilliseconds} function options.
+ */
+export interface AddMillisecondsOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addMilliseconds
+ * @category Millisecond Helpers
+ * @summary Add the specified number of milliseconds to the given date.
+ *
+ * @description
+ * Add the specified number of milliseconds to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of milliseconds to be added.
+ * @param options - The options object
+ *
+ * @returns The new date with the milliseconds added
+ *
+ * @example
+ * // Add 750 milliseconds to 10 July 2014 12:45:30.000:
+ * const result = addMilliseconds(new Date(2014, 6, 10, 12, 45, 30, 0), 750)
+ * //=> Thu Jul 10 2014 12:45:30.750
+ */
+export declare function addMilliseconds<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddMillisecondsOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addMilliseconds.js

@@ -0,0 +1,35 @@
+import { constructFrom } from "./constructFrom.js";
+import { toDate } from "./toDate.js";
+
+/**
+ * The {@link addMilliseconds} function options.
+ */
+
+/**
+ * @name addMilliseconds
+ * @category Millisecond Helpers
+ * @summary Add the specified number of milliseconds to the given date.
+ *
+ * @description
+ * Add the specified number of milliseconds to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of milliseconds to be added.
+ * @param options - The options object
+ *
+ * @returns The new date with the milliseconds added
+ *
+ * @example
+ * // Add 750 milliseconds to 10 July 2014 12:45:30.000:
+ * const result = addMilliseconds(new Date(2014, 6, 10, 12, 45, 30, 0), 750)
+ * //=> Thu Jul 10 2014 12:45:30.750
+ */
+export function addMilliseconds(date, amount, options) {
+  return constructFrom(options?.in || date, +toDate(date) + amount);
+}
+
+// Fallback for modularized imports:
+export default addMilliseconds;

node_modules/date-fns/addMinutes.cjs

@@ -0,0 +1,36 @@
+"use strict";
+exports.addMinutes = addMinutes;
+var _index = require("./constants.cjs");
+var _index2 = require("./toDate.cjs");
+
+/**
+ * The {@link addMinutes} function options.
+ */
+
+/**
+ * @name addMinutes
+ * @category Minute Helpers
+ * @summary Add the specified number of minutes to the given date.
+ *
+ * @description
+ * Add the specified number of minutes to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of minutes to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the minutes added
+ *
+ * @example
+ * // Add 30 minutes to 10 July 2014 12:00:00:
+ * const result = addMinutes(new Date(2014, 6, 10, 12, 0), 30)
+ * //=> Thu Jul 10 2014 12:30:00
+ */
+function addMinutes(date, amount, options) {
+  const _date = (0, _index2.toDate)(date, options?.in);
+  _date.setTime(_date.getTime() + amount * _index.millisecondsInMinute);
+  return _date;
+}

node_modules/date-fns/addMinutes.d.cts

@@ -0,0 +1,36 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addMinutes} function options.
+ */
+export interface AddMinutesOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addMinutes
+ * @category Minute Helpers
+ * @summary Add the specified number of minutes to the given date.
+ *
+ * @description
+ * Add the specified number of minutes to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of minutes to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the minutes added
+ *
+ * @example
+ * // Add 30 minutes to 10 July 2014 12:00:00:
+ * const result = addMinutes(new Date(2014, 6, 10, 12, 0), 30)
+ * //=> Thu Jul 10 2014 12:30:00
+ */
+export declare function addMinutes<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddMinutesOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addMinutes.d.ts

@@ -0,0 +1,36 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addMinutes} function options.
+ */
+export interface AddMinutesOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addMinutes
+ * @category Minute Helpers
+ * @summary Add the specified number of minutes to the given date.
+ *
+ * @description
+ * Add the specified number of minutes to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of minutes to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the minutes added
+ *
+ * @example
+ * // Add 30 minutes to 10 July 2014 12:00:00:
+ * const result = addMinutes(new Date(2014, 6, 10, 12, 0), 30)
+ * //=> Thu Jul 10 2014 12:30:00
+ */
+export declare function addMinutes<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddMinutesOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addMinutes.js

@@ -0,0 +1,37 @@
+import { millisecondsInMinute } from "./constants.js";
+import { toDate } from "./toDate.js";
+
+/**
+ * The {@link addMinutes} function options.
+ */
+
+/**
+ * @name addMinutes
+ * @category Minute Helpers
+ * @summary Add the specified number of minutes to the given date.
+ *
+ * @description
+ * Add the specified number of minutes to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of minutes to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the minutes added
+ *
+ * @example
+ * // Add 30 minutes to 10 July 2014 12:00:00:
+ * const result = addMinutes(new Date(2014, 6, 10, 12, 0), 30)
+ * //=> Thu Jul 10 2014 12:30:00
+ */
+export function addMinutes(date, amount, options) {
+  const _date = toDate(date, options?.in);
+  _date.setTime(_date.getTime() + amount * millisecondsInMinute);
+  return _date;
+}
+
+// Fallback for modularized imports:
+export default addMinutes;

node_modules/date-fns/addMonths.cjs

@@ -0,0 +1,78 @@
+"use strict";
+exports.addMonths = addMonths;
+var _index = require("./constructFrom.cjs");
+var _index2 = require("./toDate.cjs");
+
+/**
+ * The {@link addMonths} function options.
+ */
+
+/**
+ * @name addMonths
+ * @category Month Helpers
+ * @summary Add the specified number of months to the given date.
+ *
+ * @description
+ * Add the specified number of months to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of months to be added.
+ * @param options - The options object
+ *
+ * @returns The new date with the months added
+ *
+ * @example
+ * // Add 5 months to 1 September 2014:
+ * const result = addMonths(new Date(2014, 8, 1), 5)
+ * //=> Sun Feb 01 2015 00:00:00
+ *
+ * // Add one month to 30 January 2023:
+ * const result = addMonths(new Date(2023, 0, 30), 1)
+ * //=> Tue Feb 28 2023 00:00:00
+ */
+function addMonths(date, amount, options) {
+  const _date = (0, _index2.toDate)(date, options?.in);
+  if (isNaN(amount)) return (0, _index.constructFrom)(options?.in || date, NaN);
+  if (!amount) {
+    // If 0 months, no-op to avoid changing times in the hour before end of DST
+    return _date;
+  }
+  const dayOfMonth = _date.getDate();
+
+  // The JS Date object supports date math by accepting out-of-bounds values for
+  // month, day, etc. For example, new Date(2020, 0, 0) returns 31 Dec 2019 and
+  // new Date(2020, 13, 1) returns 1 Feb 2021.  This is *almost* the behavior we
+  // want except that dates will wrap around the end of a month, meaning that
+  // new Date(2020, 13, 31) will return 3 Mar 2021 not 28 Feb 2021 as desired. So
+  // we'll default to the end of the desired month by adding 1 to the desired
+  // month and using a date of 0 to back up one day to the end of the desired
+  // month.
+  const endOfDesiredMonth = (0, _index.constructFrom)(
+    options?.in || date,
+    _date.getTime(),
+  );
+  endOfDesiredMonth.setMonth(_date.getMonth() + amount + 1, 0);
+  const daysInMonth = endOfDesiredMonth.getDate();
+  if (dayOfMonth >= daysInMonth) {
+    // If we're already at the end of the month, then this is the correct date
+    // and we're done.
+    return endOfDesiredMonth;
+  } else {
+    // Otherwise, we now know that setting the original day-of-month value won't
+    // cause an overflow, so set the desired day-of-month. Note that we can't
+    // just set the date of `endOfDesiredMonth` because that object may have had
+    // its time changed in the unusual case where where a DST transition was on
+    // the last day of the month and its local time was in the hour skipped or
+    // repeated next to a DST transition.  So we use `date` instead which is
+    // guaranteed to still have the original time.
+    _date.setFullYear(
+      endOfDesiredMonth.getFullYear(),
+      endOfDesiredMonth.getMonth(),
+      dayOfMonth,
+    );
+    return _date;
+  }
+}

node_modules/date-fns/addMonths.d.cts

@@ -0,0 +1,40 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addMonths} function options.
+ */
+export interface AddMonthsOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addMonths
+ * @category Month Helpers
+ * @summary Add the specified number of months to the given date.
+ *
+ * @description
+ * Add the specified number of months to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of months to be added.
+ * @param options - The options object
+ *
+ * @returns The new date with the months added
+ *
+ * @example
+ * // Add 5 months to 1 September 2014:
+ * const result = addMonths(new Date(2014, 8, 1), 5)
+ * //=> Sun Feb 01 2015 00:00:00
+ *
+ * // Add one month to 30 January 2023:
+ * const result = addMonths(new Date(2023, 0, 30), 1)
+ * //=> Tue Feb 28 2023 00:00:00
+ */
+export declare function addMonths<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddMonthsOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addMonths.d.ts

@@ -0,0 +1,40 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addMonths} function options.
+ */
+export interface AddMonthsOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addMonths
+ * @category Month Helpers
+ * @summary Add the specified number of months to the given date.
+ *
+ * @description
+ * Add the specified number of months to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of months to be added.
+ * @param options - The options object
+ *
+ * @returns The new date with the months added
+ *
+ * @example
+ * // Add 5 months to 1 September 2014:
+ * const result = addMonths(new Date(2014, 8, 1), 5)
+ * //=> Sun Feb 01 2015 00:00:00
+ *
+ * // Add one month to 30 January 2023:
+ * const result = addMonths(new Date(2023, 0, 30), 1)
+ * //=> Tue Feb 28 2023 00:00:00
+ */
+export declare function addMonths<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddMonthsOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addMonths.js

@@ -0,0 +1,76 @@
+import { constructFrom } from "./constructFrom.js";
+import { toDate } from "./toDate.js";
+
+/**
+ * The {@link addMonths} function options.
+ */
+
+/**
+ * @name addMonths
+ * @category Month Helpers
+ * @summary Add the specified number of months to the given date.
+ *
+ * @description
+ * Add the specified number of months to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of months to be added.
+ * @param options - The options object
+ *
+ * @returns The new date with the months added
+ *
+ * @example
+ * // Add 5 months to 1 September 2014:
+ * const result = addMonths(new Date(2014, 8, 1), 5)
+ * //=> Sun Feb 01 2015 00:00:00
+ *
+ * // Add one month to 30 January 2023:
+ * const result = addMonths(new Date(2023, 0, 30), 1)
+ * //=> Tue Feb 28 2023 00:00:00
+ */
+export function addMonths(date, amount, options) {
+  const _date = toDate(date, options?.in);
+  if (isNaN(amount)) return constructFrom(options?.in || date, NaN);
+  if (!amount) {
+    // If 0 months, no-op to avoid changing times in the hour before end of DST
+    return _date;
+  }
+  const dayOfMonth = _date.getDate();
+
+  // The JS Date object supports date math by accepting out-of-bounds values for
+  // month, day, etc. For example, new Date(2020, 0, 0) returns 31 Dec 2019 and
+  // new Date(2020, 13, 1) returns 1 Feb 2021.  This is *almost* the behavior we
+  // want except that dates will wrap around the end of a month, meaning that
+  // new Date(2020, 13, 31) will return 3 Mar 2021 not 28 Feb 2021 as desired. So
+  // we'll default to the end of the desired month by adding 1 to the desired
+  // month and using a date of 0 to back up one day to the end of the desired
+  // month.
+  const endOfDesiredMonth = constructFrom(options?.in || date, _date.getTime());
+  endOfDesiredMonth.setMonth(_date.getMonth() + amount + 1, 0);
+  const daysInMonth = endOfDesiredMonth.getDate();
+  if (dayOfMonth >= daysInMonth) {
+    // If we're already at the end of the month, then this is the correct date
+    // and we're done.
+    return endOfDesiredMonth;
+  } else {
+    // Otherwise, we now know that setting the original day-of-month value won't
+    // cause an overflow, so set the desired day-of-month. Note that we can't
+    // just set the date of `endOfDesiredMonth` because that object may have had
+    // its time changed in the unusual case where where a DST transition was on
+    // the last day of the month and its local time was in the hour skipped or
+    // repeated next to a DST transition.  So we use `date` instead which is
+    // guaranteed to still have the original time.
+    _date.setFullYear(
+      endOfDesiredMonth.getFullYear(),
+      endOfDesiredMonth.getMonth(),
+      dayOfMonth,
+    );
+    return _date;
+  }
+}
+
+// Fallback for modularized imports:
+export default addMonths;

node_modules/date-fns/addQuarters.cjs

@@ -0,0 +1,33 @@
+"use strict";
+exports.addQuarters = addQuarters;
+var _index = require("./addMonths.cjs");
+
+/**
+ * The {@link addQuarters} function options.
+ */
+
+/**
+ * @name addQuarters
+ * @category Quarter Helpers
+ * @summary Add the specified number of year quarters to the given date.
+ *
+ * @description
+ * Add the specified number of year quarters to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of quarters to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the quarters added
+ *
+ * @example
+ * // Add 1 quarter to 1 September 2014:
+ * const result = addQuarters(new Date(2014, 8, 1), 1)
+ * //=; Mon Dec 01 2014 00:00:00
+ */
+function addQuarters(date, amount, options) {
+  return (0, _index.addMonths)(date, amount * 3, options);
+}

node_modules/date-fns/addQuarters.d.cts

@@ -0,0 +1,36 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addQuarters} function options.
+ */
+export interface AddQuartersOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addQuarters
+ * @category Quarter Helpers
+ * @summary Add the specified number of year quarters to the given date.
+ *
+ * @description
+ * Add the specified number of year quarters to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of quarters to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the quarters added
+ *
+ * @example
+ * // Add 1 quarter to 1 September 2014:
+ * const result = addQuarters(new Date(2014, 8, 1), 1)
+ * //=; Mon Dec 01 2014 00:00:00
+ */
+export declare function addQuarters<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddQuartersOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addQuarters.d.ts

@@ -0,0 +1,36 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addQuarters} function options.
+ */
+export interface AddQuartersOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addQuarters
+ * @category Quarter Helpers
+ * @summary Add the specified number of year quarters to the given date.
+ *
+ * @description
+ * Add the specified number of year quarters to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of quarters to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the quarters added
+ *
+ * @example
+ * // Add 1 quarter to 1 September 2014:
+ * const result = addQuarters(new Date(2014, 8, 1), 1)
+ * //=; Mon Dec 01 2014 00:00:00
+ */
+export declare function addQuarters<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddQuartersOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addQuarters.js

@@ -0,0 +1,34 @@
+import { addMonths } from "./addMonths.js";
+
+/**
+ * The {@link addQuarters} function options.
+ */
+
+/**
+ * @name addQuarters
+ * @category Quarter Helpers
+ * @summary Add the specified number of year quarters to the given date.
+ *
+ * @description
+ * Add the specified number of year quarters to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of quarters to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the quarters added
+ *
+ * @example
+ * // Add 1 quarter to 1 September 2014:
+ * const result = addQuarters(new Date(2014, 8, 1), 1)
+ * //=; Mon Dec 01 2014 00:00:00
+ */
+export function addQuarters(date, amount, options) {
+  return addMonths(date, amount * 3, options);
+}
+
+// Fallback for modularized imports:
+export default addQuarters;

node_modules/date-fns/addSeconds.cjs

@@ -0,0 +1,33 @@
+"use strict";
+exports.addSeconds = addSeconds;
+var _index = require("./addMilliseconds.cjs");
+
+/**
+ * The {@link addSeconds} function options.
+ */
+
+/**
+ * @name addSeconds
+ * @category Second Helpers
+ * @summary Add the specified number of seconds to the given date.
+ *
+ * @description
+ * Add the specified number of seconds to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of seconds to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the seconds added
+ *
+ * @example
+ * // Add 30 seconds to 10 July 2014 12:45:00:
+ * const result = addSeconds(new Date(2014, 6, 10, 12, 45, 0), 30)
+ * //=> Thu Jul 10 2014 12:45:30
+ */
+function addSeconds(date, amount, options) {
+  return (0, _index.addMilliseconds)(date, amount * 1000, options);
+}

node_modules/date-fns/addSeconds.d.cts

@@ -0,0 +1,36 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addSeconds} function options.
+ */
+export interface AddSecondsOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addSeconds
+ * @category Second Helpers
+ * @summary Add the specified number of seconds to the given date.
+ *
+ * @description
+ * Add the specified number of seconds to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of seconds to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the seconds added
+ *
+ * @example
+ * // Add 30 seconds to 10 July 2014 12:45:00:
+ * const result = addSeconds(new Date(2014, 6, 10, 12, 45, 0), 30)
+ * //=> Thu Jul 10 2014 12:45:30
+ */
+export declare function addSeconds<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddSecondsOptions<ResultDate> | undefined,
+): ResultDate;

node_modules/date-fns/addSeconds.d.ts

@@ -0,0 +1,36 @@
+import type { ContextOptions, DateArg } from "./types.js";
+/**
+ * The {@link addSeconds} function options.
+ */
+export interface AddSecondsOptions<DateType extends Date = Date>
+  extends ContextOptions<DateType> {}
+/**
+ * @name addSeconds
+ * @category Second Helpers
+ * @summary Add the specified number of seconds to the given date.
+ *
+ * @description
+ * Add the specified number of seconds to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of seconds to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the seconds added
+ *
+ * @example
+ * // Add 30 seconds to 10 July 2014 12:45:00:
+ * const result = addSeconds(new Date(2014, 6, 10, 12, 45, 0), 30)
+ * //=> Thu Jul 10 2014 12:45:30
+ */
+export declare function addSeconds<
+  DateType extends Date,
+  ResultDate extends Date = DateType,
+>(
+  date: DateArg<DateType>,
+  amount: number,
+  options?: AddSecondsOptions<ResultDate> | undefined,
+): ResultDate;