uql-orm 0.1.0

package/dist/browser/uql-browser.min.js

@@ -0,0 +1,4818 @@
+import { _ as _apply_decs_2203_r } from './cc-BEf4wTUm.js';
+import { randomUUID } from 'node:crypto';
+import { Id, Field, ManyToOne, Entity, OneToOne, OneToMany, ManyToMany } from '../entity/index.js';
+import '../type/index.js';
+import { raw, lowerFirst, upperFirst, getKeys } from '../util/index.js';
+import 'reflect-metadata';
+
+var _dec, _dec1, _dec2, _dec3, _dec4, _dec5, _dec6, /**
+   * auto-generated primary-key (when the `onInsert` property is omitted).
+   */ _init_id, /**
+   * foreign-keys are really simple to specify with the `reference` property.
+   */ _init_companyId, /**
+   * The `Relation` wrapper type can be used in ESM projects for the relations to
+   * avoid circular dependency issues.
+   */ _init_company, _init_creatorId, _init_creator, /**
+   * 'onInsert' property can be used to specify a custom mechanism for
+   * obtaining the value of a field when inserting:
+   */ _init_createdAt, /**
+   * 'onUpdate' property can be used to specify a custom mechanism for
+   * obtaining the value of a field when updating:
+   */ _init_updatedAt, _initProto, _dec7, _initClass, _BaseEntity, _dec8, _dec9, _dec10, _init_name, _init_description, _init_kind, _initProto1, _dec11, _initClass1, _BaseEntity1, _dec12, _dec13, /**
+   * an entity can specify its own ID Field and still inherit the others
+   * columns/relations from its parent entity.
+   */ _init_pk, _init_picture, _initProto2, _dec14, _initClass2, _BaseEntity2, _dec15, _dec16, _dec17, _dec18, _dec19, _init_name1, _init_email, _init_password, /**
+   * `mappedBy` property can be a callback or a string (callback is useful for auto-refactoring).
+   */ _init_profile, _init_users, _initProto3, _dec20, _initClass3, _dec21, _dec22, _init_id1, _init_name2, _initProto4, _dec23, _initClass4, _BaseEntity3, _dec24, _dec25, _dec26, _dec27, _init_name3, _init_description1, _init_parentLedgerId, _init_parentLedger, _initProto5, _dec28, _initClass5, _BaseEntity4, _dec29, _dec30, _dec31, /**
+   * an entity can override the ID Field and still inherit the others
+   * columns/relations from its parent entity.
+   * 'onInsert' property can be used to specify a custom mechanism for
+   * auto-generating the primary-key's value when inserting.
+   */ _init_pk1, _init_name4, _init_description2, _initProto6, _dec32, _initClass6, _BaseEntity5, _dec33, _dec34, _dec35, _dec36, _dec37, _init_name5, _init_percentage, _init_categoryId, _init_category, _init_description3, _initProto7, _dec38, _initClass7, _BaseEntity6, _dec39, _dec40, _dec41, _init_name6, _init_measureUnits, /**
+   * `onDelete` callback allows to specify which field will be used when deleting/querying this entity.
+   */ _init_deletedAt, _initProto8, _dec42, _initClass8, _BaseEntity7, _dec43, _dec44, _dec45, _dec46, _init_name7, _init_categoryId1, _init_category1, _init_deletedAt1, _initProto9, _dec47, _initClass9, _BaseEntity8, _dec48, _dec49, _dec50, _init_name8, _init_address, _init_description4, _initProto10, _dec51, _initClass10, _BaseEntity9, _dec52, _dec53, _dec54, _dec55, _dec56, _dec57, _dec58, _dec59, _dec60, _dec61, _dec62, _dec63, _dec64, _dec65, _dec66, _init_name9, _init_description5, _init_code, _init_buyLedgerAccountId, _init_buyLedgerAccount, _init_saleLedgerAccountId, _init_saleLedgerAccount, _init_taxId, _init_tax, _init_measureUnitId, _init_measureUnit, _init_salePrice, _init_inventoryable, _init_tags, _init_tagsCount, _initProto11, _dec67, _initClass11, _BaseEntity10, _dec68, _dec69, _dec70, _init_name10, _init_items, _init_itemsCount, _initProto12, _dec71, _initClass12, _dec72, _dec73, _dec74, _init_id2, _init_itemId, _init_tagId, _initProto13, _dec75, _initClass13, _BaseEntity11, _dec76, _dec77, _dec78, _init_itemAdjustments, _init_date, _init_description6, _initProto14, _dec79, _initClass14, _BaseEntity12, _dec80, _dec81, _dec82, _dec83, _dec84, _dec85, _dec86, _dec87, _init_itemId1, _init_item, _init_number, _init_buyPrice, _init_storehouseId, _init_storehouse, _init_inventoryAdjustmentId, _init_inventoryAdjustment, _initProto15;
+_dec = Id(), _dec1 = Field({
+    references: ()=>_Company
+}), _dec2 = ManyToOne({
+    entity: ()=>_Company
+}), _dec3 = Field({
+    references: ()=>_User
+}), _dec4 = ManyToOne({
+    entity: ()=>_User
+}), _dec5 = Field({
+    onInsert: Date.now
+}), _dec6 = Field({
+    onUpdate: Date.now
+});
+/**
+ * an `abstract` class can (optionally) be used as the base "template" for the entities
+ * (so common fields' declaration is easily reused).
+ */ class BaseEntity {
+    static{
+        ({ e: [_init_id, _init_companyId, _init_company, _init_creatorId, _init_creator, _init_createdAt, _init_updatedAt, _initProto] } = _apply_decs_2203_r(this, [
+            [
+                _dec,
+                0,
+                "id"
+            ],
+            [
+                _dec1,
+                0,
+                "companyId"
+            ],
+            [
+                _dec2,
+                0,
+                "company"
+            ],
+            [
+                _dec3,
+                0,
+                "creatorId"
+            ],
+            [
+                _dec4,
+                0,
+                "creator"
+            ],
+            [
+                _dec5,
+                0,
+                "createdAt"
+            ],
+            [
+                _dec6,
+                0,
+                "updatedAt"
+            ]
+        ], []));
+    }
+    constructor(){
+        this.id = (_initProto(this), _init_id(this));
+        this.companyId = _init_companyId(this);
+        this.company = _init_company(this);
+        this.creatorId = _init_creatorId(this);
+        this.creator = _init_creator(this);
+        this.createdAt = _init_createdAt(this);
+        this.updatedAt = _init_updatedAt(this);
+    }
+}
+let _Company;
+_dec7 = Entity(), _dec8 = Field(), _dec9 = Field(), _dec10 = Field({
+    type: 'jsonb'
+});
+class Company extends (_BaseEntity = BaseEntity) {
+    static{
+        ({ e: [_init_name, _init_description, _init_kind, _initProto1], c: [_Company, _initClass] } = _apply_decs_2203_r(this, [
+            [
+                _dec8,
+                0,
+                "name"
+            ],
+            [
+                _dec9,
+                0,
+                "description"
+            ],
+            [
+                _dec10,
+                0,
+                "kind"
+            ]
+        ], [
+            _dec7
+        ], _BaseEntity));
+    }
+    static{
+        _initClass();
+    }
+    constructor(...args){
+        super(...args), this.name = (_initProto1(this), _init_name(this)), this.description = _init_description(this), this.kind = _init_kind(this);
+    }
+}
+let _Profile;
+_dec11 = Entity({
+    name: 'user_profile'
+}), _dec12 = Id(), _dec13 = Field({
+    name: 'image'
+});
+class Profile extends (_BaseEntity1 = BaseEntity) {
+    static{
+        ({ e: [_init_pk, _init_picture, _initProto2], c: [_Profile, _initClass1] } = _apply_decs_2203_r(this, [
+            [
+                _dec12,
+                0,
+                "pk"
+            ],
+            [
+                _dec13,
+                0,
+                "picture"
+            ]
+        ], [
+            _dec11
+        ], _BaseEntity1));
+    }
+    static{
+        _initClass1();
+    }
+    constructor(...args){
+        super(...args), this.pk = (_initProto2(this), _init_pk(this)), this.picture = _init_picture(this);
+    }
+}
+let _User;
+_dec14 = Entity(), _dec15 = Field(), _dec16 = Field({
+    updatable: false
+}), _dec17 = Field({
+    eager: false
+}), _dec18 = OneToOne({
+    entity: ()=>_Profile,
+    mappedBy: (profile)=>profile.creator,
+    cascade: true
+}), _dec19 = OneToMany({
+    entity: ()=>_User,
+    mappedBy: 'creator'
+});
+class User extends (_BaseEntity2 = BaseEntity) {
+    static{
+        ({ e: [_init_name1, _init_email, _init_password, _init_profile, _init_users, _initProto3], c: [_User, _initClass2] } = _apply_decs_2203_r(this, [
+            [
+                _dec15,
+                0,
+                "name"
+            ],
+            [
+                _dec16,
+                0,
+                "email"
+            ],
+            [
+                _dec17,
+                0,
+                "password"
+            ],
+            [
+                _dec18,
+                0,
+                "profile"
+            ],
+            [
+                _dec19,
+                0,
+                "users"
+            ]
+        ], [
+            _dec14
+        ], _BaseEntity2));
+    }
+    static{
+        _initClass2();
+    }
+    constructor(...args){
+        super(...args), this.name = (_initProto3(this), _init_name1(this)), this.email = _init_email(this), this.password = _init_password(this), this.profile = _init_profile(this), this.users = _init_users(this);
+    }
+}
+let _UserWithNonUpdatableId;
+_dec20 = Entity(), _dec21 = Id({
+    updatable: false
+}), _dec22 = Field();
+class UserWithNonUpdatableId {
+    static{
+        ({ e: [_init_id1, _init_name2, _initProto4], c: [_UserWithNonUpdatableId, _initClass3] } = _apply_decs_2203_r(this, [
+            [
+                _dec21,
+                0,
+                "id"
+            ],
+            [
+                _dec22,
+                0,
+                "name"
+            ]
+        ], [
+            _dec20
+        ]));
+    }
+    static{
+        _initClass3();
+    }
+    constructor(){
+        this.id = (_initProto4(this), _init_id1(this));
+        this.name = _init_name2(this);
+    }
+}
+let _LedgerAccount;
+_dec23 = Entity(), _dec24 = Field(), _dec25 = Field(), _dec26 = Field({
+    references: ()=>_LedgerAccount
+}), _dec27 = ManyToOne();
+class LedgerAccount extends (_BaseEntity3 = BaseEntity) {
+    static{
+        ({ e: [_init_name3, _init_description1, _init_parentLedgerId, _init_parentLedger, _initProto5], c: [_LedgerAccount, _initClass4] } = _apply_decs_2203_r(this, [
+            [
+                _dec24,
+                0,
+                "name"
+            ],
+            [
+                _dec25,
+                0,
+                "description"
+            ],
+            [
+                _dec26,
+                0,
+                "parentLedgerId"
+            ],
+            [
+                _dec27,
+                0,
+                "parentLedger"
+            ]
+        ], [
+            _dec23
+        ], _BaseEntity3));
+    }
+    static{
+        _initClass4();
+    }
+    constructor(...args){
+        super(...args), this.name = (_initProto5(this), _init_name3(this)), this.description = _init_description1(this), this.parentLedgerId = _init_parentLedgerId(this), this.parentLedger = _init_parentLedger(this);
+    }
+}
+let _TaxCategory;
+_dec28 = Entity(), _dec29 = Id({
+    onInsert: randomUUID
+}), _dec30 = Field(), _dec31 = Field();
+class TaxCategory extends (_BaseEntity4 = BaseEntity) {
+    static{
+        ({ e: [_init_pk1, _init_name4, _init_description2, _initProto6], c: [_TaxCategory, _initClass5] } = _apply_decs_2203_r(this, [
+            [
+                _dec29,
+                0,
+                "pk"
+            ],
+            [
+                _dec30,
+                0,
+                "name"
+            ],
+            [
+                _dec31,
+                0,
+                "description"
+            ]
+        ], [
+            _dec28
+        ], _BaseEntity4));
+    }
+    static{
+        _initClass5();
+    }
+    constructor(...args){
+        super(...args), this.pk = (_initProto6(this), _init_pk1(this)), this.name = _init_name4(this), this.description = _init_description2(this);
+    }
+}
+let _Tax;
+_dec32 = Entity(), _dec33 = Field(), _dec34 = Field(), _dec35 = Field({
+    references: ()=>_TaxCategory
+}), _dec36 = ManyToOne(), _dec37 = Field();
+class Tax extends (_BaseEntity5 = BaseEntity) {
+    static{
+        ({ e: [_init_name5, _init_percentage, _init_categoryId, _init_category, _init_description3, _initProto7], c: [_Tax, _initClass6] } = _apply_decs_2203_r(this, [
+            [
+                _dec33,
+                0,
+                "name"
+            ],
+            [
+                _dec34,
+                0,
+                "percentage"
+            ],
+            [
+                _dec35,
+                0,
+                "categoryId"
+            ],
+            [
+                _dec36,
+                0,
+                "category"
+            ],
+            [
+                _dec37,
+                0,
+                "description"
+            ]
+        ], [
+            _dec32
+        ], _BaseEntity5));
+    }
+    static{
+        _initClass6();
+    }
+    constructor(...args){
+        super(...args), this.name = (_initProto7(this), _init_name5(this)), this.percentage = _init_percentage(this), this.categoryId = _init_categoryId(this), this.category = _init_category(this), this.description = _init_description3(this);
+    }
+}
+let _MeasureUnitCategory;
+_dec38 = Entity({
+    softDelete: true
+}), _dec39 = Field(), _dec40 = OneToMany({
+    entity: ()=>_MeasureUnit,
+    mappedBy: (measureUnit)=>measureUnit.categoryId
+}), _dec41 = Field({
+    onDelete: Date.now
+});
+class MeasureUnitCategory extends (_BaseEntity6 = BaseEntity) {
+    static{
+        ({ e: [_init_name6, _init_measureUnits, _init_deletedAt, _initProto8], c: [_MeasureUnitCategory, _initClass7] } = _apply_decs_2203_r(this, [
+            [
+                _dec39,
+                0,
+                "name"
+            ],
+            [
+                _dec40,
+                0,
+                "measureUnits"
+            ],
+            [
+                _dec41,
+                0,
+                "deletedAt"
+            ]
+        ], [
+            _dec38
+        ], _BaseEntity6));
+    }
+    static{
+        _initClass7();
+    }
+    constructor(...args){
+        super(...args), this.name = (_initProto8(this), _init_name6(this)), this.measureUnits = _init_measureUnits(this), this.deletedAt = _init_deletedAt(this);
+    }
+}
+let _MeasureUnit;
+_dec42 = Entity({
+    softDelete: true
+}), _dec43 = Field(), _dec44 = Field({
+    references: ()=>_MeasureUnitCategory
+}), _dec45 = ManyToOne({
+    cascade: 'persist'
+}), _dec46 = Field({
+    onDelete: Date.now
+});
+class MeasureUnit extends (_BaseEntity7 = BaseEntity) {
+    static{
+        ({ e: [_init_name7, _init_categoryId1, _init_category1, _init_deletedAt1, _initProto9], c: [_MeasureUnit, _initClass8] } = _apply_decs_2203_r(this, [
+            [
+                _dec43,
+                0,
+                "name"
+            ],
+            [
+                _dec44,
+                0,
+                "categoryId"
+            ],
+            [
+                _dec45,
+                0,
+                "category"
+            ],
+            [
+                _dec46,
+                0,
+                "deletedAt"
+            ]
+        ], [
+            _dec42
+        ], _BaseEntity7));
+    }
+    static{
+        _initClass8();
+    }
+    constructor(...args){
+        super(...args), this.name = (_initProto9(this), _init_name7(this)), this.categoryId = _init_categoryId1(this), this.category = _init_category1(this), this.deletedAt = _init_deletedAt1(this);
+    }
+}
+let _Storehouse;
+_dec47 = Entity(), _dec48 = Field(), _dec49 = Field(), _dec50 = Field();
+class Storehouse extends (_BaseEntity8 = BaseEntity) {
+    static{
+        ({ e: [_init_name8, _init_address, _init_description4, _initProto10], c: [_Storehouse, _initClass9] } = _apply_decs_2203_r(this, [
+            [
+                _dec48,
+                0,
+                "name"
+            ],
+            [
+                _dec49,
+                0,
+                "address"
+            ],
+            [
+                _dec50,
+                0,
+                "description"
+            ]
+        ], [
+            _dec47
+        ], _BaseEntity8));
+    }
+    static{
+        _initClass9();
+    }
+    constructor(...args){
+        super(...args), this.name = (_initProto10(this), _init_name8(this)), this.address = _init_address(this), this.description = _init_description4(this);
+    }
+}
+let _Item;
+_dec51 = Entity(), _dec52 = Field(), _dec53 = Field(), _dec54 = Field(), _dec55 = Field({
+    references: ()=>_LedgerAccount
+}), _dec56 = ManyToOne(), _dec57 = Field({
+    references: ()=>_LedgerAccount
+}), _dec58 = ManyToOne(), _dec59 = Field({
+    references: ()=>_Tax
+}), _dec60 = ManyToOne(), _dec61 = Field({
+    references: ()=>_MeasureUnit
+}), _dec62 = ManyToOne(), _dec63 = Field(), _dec64 = Field(), _dec65 = ManyToMany({
+    entity: ()=>_Tag,
+    through: ()=>_ItemTag,
+    cascade: true
+}), _dec66 = Field({
+    /**
+     * `virtual` property allows defining the value for a non-persistent field,
+     * such value might be a scalar or a (`raw`) function. Virtual-fields can
+     * be used in `$select` and `$where` as a common field whose value is
+     * replaced is replaced at runtime.
+     */ virtual: raw(({ ctx, escapedPrefix, dialect } = {})=>{
+        ctx.append('(');
+        dialect.count(ctx, _ItemTag, {
+            $where: {
+                itemId: raw(({ ctx: innerCtx } = {})=>{
+                    innerCtx.append(escapedPrefix + dialect.escapeId('id'));
+                })
+            }
+        }, {
+            autoPrefix: true
+        });
+        ctx.append(')');
+    })
+});
+class Item extends (_BaseEntity9 = BaseEntity) {
+    static{
+        ({ e: [_init_name9, _init_description5, _init_code, _init_buyLedgerAccountId, _init_buyLedgerAccount, _init_saleLedgerAccountId, _init_saleLedgerAccount, _init_taxId, _init_tax, _init_measureUnitId, _init_measureUnit, _init_salePrice, _init_inventoryable, _init_tags, _init_tagsCount, _initProto11], c: [_Item, _initClass10] } = _apply_decs_2203_r(this, [
+            [
+                _dec52,
+                0,
+                "name"
+            ],
+            [
+                _dec53,
+                0,
+                "description"
+            ],
+            [
+                _dec54,
+                0,
+                "code"
+            ],
+            [
+                _dec55,
+                0,
+                "buyLedgerAccountId"
+            ],
+            [
+                _dec56,
+                0,
+                "buyLedgerAccount"
+            ],
+            [
+                _dec57,
+                0,
+                "saleLedgerAccountId"
+            ],
+            [
+                _dec58,
+                0,
+                "saleLedgerAccount"
+            ],
+            [
+                _dec59,
+                0,
+                "taxId"
+            ],
+            [
+                _dec60,
+                0,
+                "tax"
+            ],
+            [
+                _dec61,
+                0,
+                "measureUnitId"
+            ],
+            [
+                _dec62,
+                0,
+                "measureUnit"
+            ],
+            [
+                _dec63,
+                0,
+                "salePrice"
+            ],
+            [
+                _dec64,
+                0,
+                "inventoryable"
+            ],
+            [
+                _dec65,
+                0,
+                "tags"
+            ],
+            [
+                _dec66,
+                0,
+                "tagsCount"
+            ]
+        ], [
+            _dec51
+        ], _BaseEntity9));
+    }
+    static{
+        _initClass10();
+    }
+    constructor(...args){
+        super(...args), this.name = (_initProto11(this), _init_name9(this)), this.description = _init_description5(this), this.code = _init_code(this), this.buyLedgerAccountId = _init_buyLedgerAccountId(this), this.buyLedgerAccount = _init_buyLedgerAccount(this), this.saleLedgerAccountId = _init_saleLedgerAccountId(this), this.saleLedgerAccount = _init_saleLedgerAccount(this), this.taxId = _init_taxId(this), this.tax = _init_tax(this), this.measureUnitId = _init_measureUnitId(this), this.measureUnit = _init_measureUnit(this), this.salePrice = _init_salePrice(this), this.inventoryable = _init_inventoryable(this), this.tags = _init_tags(this), this.tagsCount = _init_tagsCount(this);
+    }
+}
+let _Tag;
+_dec67 = Entity(), _dec68 = Field(), _dec69 = ManyToMany({
+    entity: ()=>_Item,
+    mappedBy: (item)=>item.tags
+}), _dec70 = Field({
+    virtual: raw(({ ctx, escapedPrefix, dialect } = {})=>{
+        ctx.append('(');
+        dialect.count(ctx, _ItemTag, {
+            $where: {
+                tagId: raw(({ ctx: innerCtx } = {})=>{
+                    innerCtx.append(escapedPrefix + dialect.escapeId('id'));
+                })
+            }
+        }, {
+            autoPrefix: true
+        });
+        ctx.append(')');
+    })
+});
+class Tag extends (_BaseEntity10 = BaseEntity) {
+    static{
+        ({ e: [_init_name10, _init_items, _init_itemsCount, _initProto12], c: [_Tag, _initClass11] } = _apply_decs_2203_r(this, [
+            [
+                _dec68,
+                0,
+                "name"
+            ],
+            [
+                _dec69,
+                0,
+                "items"
+            ],
+            [
+                _dec70,
+                0,
+                "itemsCount"
+            ]
+        ], [
+            _dec67
+        ], _BaseEntity10));
+    }
+    static{
+        _initClass11();
+    }
+    constructor(...args){
+        super(...args), this.name = (_initProto12(this), _init_name10(this)), this.items = _init_items(this), this.itemsCount = _init_itemsCount(this);
+    }
+}
+let _ItemTag;
+_dec71 = Entity(), _dec72 = Id(), _dec73 = Field({
+    references: ()=>_Item
+}), _dec74 = Field({
+    references: ()=>_Tag
+});
+class ItemTag {
+    static{
+        ({ e: [_init_id2, _init_itemId, _init_tagId, _initProto13], c: [_ItemTag, _initClass12] } = _apply_decs_2203_r(this, [
+            [
+                _dec72,
+                0,
+                "id"
+            ],
+            [
+                _dec73,
+                0,
+                "itemId"
+            ],
+            [
+                _dec74,
+                0,
+                "tagId"
+            ]
+        ], [
+            _dec71
+        ]));
+    }
+    static{
+        _initClass12();
+    }
+    constructor(){
+        this.id = (_initProto13(this), _init_id2(this));
+        this.itemId = _init_itemId(this);
+        this.tagId = _init_tagId(this);
+    }
+}
+let _InventoryAdjustment;
+_dec75 = Entity(), _dec76 = OneToMany({
+    entity: ()=>_ItemAdjustment,
+    mappedBy: (rel)=>rel.inventoryAdjustment,
+    cascade: true
+}), _dec77 = Field(), _dec78 = Field();
+class InventoryAdjustment extends (_BaseEntity11 = BaseEntity) {
+    static{
+        ({ e: [_init_itemAdjustments, _init_date, _init_description6, _initProto14], c: [_InventoryAdjustment, _initClass13] } = _apply_decs_2203_r(this, [
+            [
+                _dec76,
+                0,
+                "itemAdjustments"
+            ],
+            [
+                _dec77,
+                0,
+                "date"
+            ],
+            [
+                _dec78,
+                0,
+                "description"
+            ]
+        ], [
+            _dec75
+        ], _BaseEntity11));
+    }
+    static{
+        _initClass13();
+    }
+    constructor(...args){
+        super(...args), this.itemAdjustments = (_initProto14(this), _init_itemAdjustments(this)), this.date = _init_date(this), this.description = _init_description6(this);
+    }
+}
+let _ItemAdjustment;
+_dec79 = Entity(), _dec80 = Field({
+    references: ()=>_Item
+}), _dec81 = ManyToOne(), _dec82 = Field(), _dec83 = Field(), _dec84 = Field({
+    references: ()=>_Storehouse
+}), _dec85 = ManyToOne(), _dec86 = Field({
+    references: ()=>_InventoryAdjustment
+}), _dec87 = ManyToOne();
+class ItemAdjustment extends (_BaseEntity12 = BaseEntity) {
+    static{
+        ({ e: [_init_itemId1, _init_item, _init_number, _init_buyPrice, _init_storehouseId, _init_storehouse, _init_inventoryAdjustmentId, _init_inventoryAdjustment, _initProto15], c: [_ItemAdjustment, _initClass14] } = _apply_decs_2203_r(this, [
+            [
+                _dec80,
+                0,
+                "itemId"
+            ],
+            [
+                _dec81,
+                0,
+                "item"
+            ],
+            [
+                _dec82,
+                0,
+                "number"
+            ],
+            [
+                _dec83,
+                0,
+                "buyPrice"
+            ],
+            [
+                _dec84,
+                0,
+                "storehouseId"
+            ],
+            [
+                _dec85,
+                0,
+                "storehouse"
+            ],
+            [
+                _dec86,
+                0,
+                "inventoryAdjustmentId"
+            ],
+            [
+                _dec87,
+                0,
+                "inventoryAdjustment"
+            ]
+        ], [
+            _dec79
+        ], _BaseEntity12));
+    }
+    static{
+        _initClass14();
+    }
+    constructor(...args){
+        super(...args), this.itemId = (_initProto15(this), _init_itemId1(this)), this.item = _init_item(this), this.number = _init_number(this), this.buyPrice = _init_buyPrice(this), this.storehouseId = _init_storehouseId(this), this.storehouse = _init_storehouse(this), this.inventoryAdjustmentId = _init_inventoryAdjustmentId(this), this.inventoryAdjustment = _init_inventoryAdjustment(this);
+    }
+}
+
+const holder = globalThis;
+const metaKey = 'uql-orm/entity/decorator';
+const metas = holder[metaKey] ?? new Map();
+holder[metaKey] = metas;
+function getEntities() {
+    return [
+        ...metas.entries()
+    ].reduce((acc, [key, val])=>{
+        if (val.id) {
+            acc.push(key);
+        }
+        return acc;
+    }, []);
+}
+function ensureMeta(entity) {
+    let meta = metas.get(entity);
+    if (meta) {
+        return meta;
+    }
+    meta = {
+        entity,
+        fields: {},
+        relations: {}
+    };
+    metas.set(entity, meta);
+    return meta;
+}
+function getMeta(entity) {
+    const meta = metas.get(entity);
+    if (!meta) {
+        throw TypeError(`'${entity.name}' is not an entity`);
+    }
+    if (meta.processed) {
+        return meta;
+    }
+    meta.processed = true;
+    return fillRelations(meta);
+}
+function fillRelations(meta) {
+    for(const relKey in meta.relations){
+        const relOpts = meta.relations[relKey];
+        if (!relOpts) continue;
+        if (relOpts.references) {
+            continue;
+        }
+        if (relOpts.mappedBy) {
+            fillInverseSideRelations(relOpts);
+            continue;
+        }
+        const relEntity = relOpts.entity();
+        const relMeta = ensureMeta(relEntity);
+        if (relOpts.cardinality === 'mm') {
+            const idKey = meta.id;
+            const relIdKey = relMeta.id;
+            const idName = meta.fields[idKey]?.name ?? idKey;
+            const relIdName = relMeta.fields[relIdKey]?.name ?? relIdKey;
+            const source = lowerFirst(meta.name ?? '') + upperFirst(idName);
+            const target = lowerFirst(relMeta.name ?? '') + upperFirst(relIdName);
+            relOpts.references = [
+                {
+                    local: source,
+                    foreign: idKey
+                },
+                {
+                    local: target,
+                    foreign: relIdKey
+                }
+            ];
+        } else {
+            const relIdKey = relMeta.id;
+            relOpts.references = [
+                {
+                    local: `${relKey}Id`,
+                    foreign: relIdKey
+                }
+            ];
+        }
+        if (relOpts.through) {
+            fillThroughRelations(relOpts.through());
+        }
+    }
+    return meta;
+}
+function fillInverseSideRelations(relOpts) {
+    const relEntity = relOpts.entity();
+    const relMeta = getMeta(relEntity);
+    const mappedBy = getMappedByRelationKey(relOpts);
+    relOpts.mappedBy = mappedBy;
+    if (relMeta.fields[mappedBy]) {
+        relOpts.references = [
+            {
+                local: relMeta.id,
+                foreign: mappedBy
+            }
+        ];
+        return;
+    }
+    const mappedByRelation = relMeta.relations[mappedBy];
+    if (!mappedByRelation) return;
+    if (relOpts.cardinality === 'm1' || relOpts.cardinality === 'mm') {
+        relOpts.references = (mappedByRelation.references ?? []).slice().reverse();
+        relOpts.through = mappedByRelation.through;
+        return;
+    }
+    relOpts.references = (mappedByRelation.references ?? []).map(({ local, foreign })=>({
+            local: foreign,
+            foreign: local
+        }));
+}
+function fillThroughRelations(entity) {
+    const meta = ensureMeta(entity);
+    meta.relations = getKeys(meta.fields).reduce((relations, key)=>{
+        const field = meta.fields[key];
+        if (!field) return relations;
+        const reference = field.references ?? field.reference;
+        if (reference) {
+            const relEntity = reference();
+            const relMeta = ensureMeta(relEntity);
+            const relIdKey = relMeta.id;
+            const relKey = key.slice(0, -relIdKey.length);
+            const relOpts = {
+                entity: reference,
+                cardinality: 'm1',
+                references: [
+                    {
+                        local: key,
+                        foreign: relIdKey
+                    }
+                ]
+            };
+            relations[relKey] = relOpts;
+        }
+        return relations;
+    }, {});
+}
+function getMappedByRelationKey(relOpts) {
+    if (typeof relOpts.mappedBy === 'function') {
+        const relEntity = relOpts.entity();
+        const relMeta = ensureMeta(relEntity);
+        const keyMap = getRelationKeyMap(relMeta);
+        return relOpts.mappedBy(keyMap);
+    }
+    return relOpts.mappedBy;
+}
+function getRelationKeyMap(meta) {
+    const keys = [
+        ...getKeys(meta.fields),
+        ...getKeys(meta.relations)
+    ];
+    return keys.reduce((acc, key)=>{
+        acc[key] = key;
+        return acc;
+    }, {});
+}
+
+async function createTables(querier, primaryKeyType) {
+    const entities = getEntities();
+    await Promise.all(entities.map((entity)=>{
+        const sql = getDdlForTable(entity, querier, primaryKeyType);
+        return querier.run(sql);
+    }));
+}
+async function dropTables(querier) {
+    const entities = getEntities();
+    await Promise.all(entities.map((entity)=>{
+        const meta = getMeta(entity);
+        const sql = `DROP TABLE IF EXISTS ${querier.dialect.escapeId(meta.name)}`;
+        return querier.run(sql);
+    }));
+}
+async function clearTables(querier) {
+    const entities = getEntities();
+    await Promise.all(entities.map((entity)=>{
+        const ctx = querier.dialect.createContext();
+        querier.dialect.delete(ctx, entity, {});
+        return querier.run(ctx.sql, ctx.values);
+    }));
+}
+function getDdlForTable(entity, querier, primaryKeyType) {
+    const meta = getMeta(entity);
+    let sql = `CREATE TABLE ${querier.dialect.escapeId(meta.name)} (\n\t`;
+    const insertableIdType = 'VARCHAR(36)';
+    const defaultType = querier.dialect.escapeIdChar === '"' ? 'TEXT' : 'VARCHAR(255)';
+    const columns = getKeys(meta.fields).map((key)=>{
+        const field = meta.fields[key];
+        let propSql = querier.dialect.escapeId(field.name) + ' ';
+        if (field.isId) {
+            propSql += field.onInsert ? `${insertableIdType} PRIMARY KEY` : primaryKeyType;
+        } else {
+            if (field.type === Number) {
+                propSql += 'BIGINT';
+            } else if (field.type === Date) {
+                propSql += 'TIMESTAMP';
+            } else {
+                propSql += defaultType;
+            }
+        }
+        return propSql;
+    });
+    sql += columns.join(',\n\t');
+    sql += `\n);`;
+    // log('sql', sql);
+    return sql;
+}
+
+// src/index.ts
+var d = {
+    reset: [
+        0,
+        0
+    ],
+    bold: [
+        1,
+        22,
+        "\x1B[22m\x1B[1m"
+    ],
+    dim: [
+        2,
+        22,
+        "\x1B[22m\x1B[2m"
+    ],
+    italic: [
+        3,
+        23
+    ],
+    underline: [
+        4,
+        24
+    ],
+    inverse: [
+        7,
+        27
+    ],
+    hidden: [
+        8,
+        28
+    ],
+    strikethrough: [
+        9,
+        29
+    ],
+    black: [
+        30,
+        39
+    ],
+    red: [
+        31,
+        39
+    ],
+    green: [
+        32,
+        39
+    ],
+    yellow: [
+        33,
+        39
+    ],
+    blue: [
+        34,
+        39
+    ],
+    magenta: [
+        35,
+        39
+    ],
+    cyan: [
+        36,
+        39
+    ],
+    white: [
+        37,
+        39
+    ],
+    gray: [
+        90,
+        39
+    ],
+    bgBlack: [
+        40,
+        49
+    ],
+    bgRed: [
+        41,
+        49
+    ],
+    bgGreen: [
+        42,
+        49
+    ],
+    bgYellow: [
+        43,
+        49
+    ],
+    bgBlue: [
+        44,
+        49
+    ],
+    bgMagenta: [
+        45,
+        49
+    ],
+    bgCyan: [
+        46,
+        49
+    ],
+    bgWhite: [
+        47,
+        49
+    ],
+    blackBright: [
+        90,
+        39
+    ],
+    redBright: [
+        91,
+        39
+    ],
+    greenBright: [
+        92,
+        39
+    ],
+    yellowBright: [
+        93,
+        39
+    ],
+    blueBright: [
+        94,
+        39
+    ],
+    magentaBright: [
+        95,
+        39
+    ],
+    cyanBright: [
+        96,
+        39
+    ],
+    whiteBright: [
+        97,
+        39
+    ],
+    bgBlackBright: [
+        100,
+        49
+    ],
+    bgRedBright: [
+        101,
+        49
+    ],
+    bgGreenBright: [
+        102,
+        49
+    ],
+    bgYellowBright: [
+        103,
+        49
+    ],
+    bgBlueBright: [
+        104,
+        49
+    ],
+    bgMagentaBright: [
+        105,
+        49
+    ],
+    bgCyanBright: [
+        106,
+        49
+    ],
+    bgWhiteBright: [
+        107,
+        49
+    ]
+};
+function g(e) {
+    return String(e);
+}
+g.open = "";
+g.close = "";
+function h() {
+    let e = typeof process != "undefined" ? process : void 0, n = (e == null ? void 0 : e.env) || {}, a = n.FORCE_TTY !== "false", i = (e == null ? void 0 : e.argv) || [];
+    return !("NO_COLOR" in n || i.includes("--no-color")) && ("FORCE_COLOR" in n || i.includes("--color") || (e == null ? void 0 : e.platform) === "win32" || a && n.TERM !== "dumb" || "CI" in n) || typeof window != "undefined" && !!window.chrome;
+}
+function f() {
+    let e = h(), n = (r, t, u, o)=>{
+        let l = "", s = 0;
+        do l += r.substring(s, o) + u, s = o + t.length, o = r.indexOf(t, s);
+        while (~o)
+        return l + r.substring(s);
+    }, a = (r, t, u = r)=>{
+        let o = (l)=>{
+            let s = String(l), b = s.indexOf(t, r.length);
+            return ~b ? r + n(s, t, u, b) + t : r + s + t;
+        };
+        return o.open = r, o.close = t, o;
+    }, i = {
+        isColorSupported: e
+    }, c = (r)=>`\x1B[${r}m`;
+    for(let r in d){
+        let t = d[r];
+        i[r] = e ? a(c(t[0]), c(t[1]), t[2]) : g;
+    }
+    return i;
+}
+var C = f();
+
+function _mergeNamespaces$1(n, m) {
+    m.forEach(function(e) {
+        e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function(k) {
+            if (k !== 'default' && !(k in n)) {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function() {
+                        return e[k];
+                    }
+                });
+            }
+        });
+    });
+    return Object.freeze(n);
+}
+function getKeysOfEnumerableProperties(object, compareKeys) {
+    const rawKeys = Object.keys(object);
+    const keys = compareKeys === null ? rawKeys : rawKeys.sort(compareKeys);
+    if (Object.getOwnPropertySymbols) {
+        for (const symbol of Object.getOwnPropertySymbols(object)){
+            if (Object.getOwnPropertyDescriptor(object, symbol).enumerable) {
+                keys.push(symbol);
+            }
+        }
+    }
+    return keys;
+}
+/**
+* Return entries (for example, of a map)
+* with spacing, indentation, and comma
+* without surrounding punctuation (for example, braces)
+*/ function printIteratorEntries(iterator, config, indentation, depth, refs, printer, separator = ": ") {
+    let result = "";
+    let width = 0;
+    let current = iterator.next();
+    if (!current.done) {
+        result += config.spacingOuter;
+        const indentationNext = indentation + config.indent;
+        while(!current.done){
+            result += indentationNext;
+            if (width++ === config.maxWidth) {
+                result += "…";
+                break;
+            }
+            const name = printer(current.value[0], config, indentationNext, depth, refs);
+            const value = printer(current.value[1], config, indentationNext, depth, refs);
+            result += name + separator + value;
+            current = iterator.next();
+            if (!current.done) {
+                result += `,${config.spacingInner}`;
+            } else if (!config.min) {
+                result += ",";
+            }
+        }
+        result += config.spacingOuter + indentation;
+    }
+    return result;
+}
+/**
+* Return values (for example, of a set)
+* with spacing, indentation, and comma
+* without surrounding punctuation (braces or brackets)
+*/ function printIteratorValues(iterator, config, indentation, depth, refs, printer) {
+    let result = "";
+    let width = 0;
+    let current = iterator.next();
+    if (!current.done) {
+        result += config.spacingOuter;
+        const indentationNext = indentation + config.indent;
+        while(!current.done){
+            result += indentationNext;
+            if (width++ === config.maxWidth) {
+                result += "…";
+                break;
+            }
+            result += printer(current.value, config, indentationNext, depth, refs);
+            current = iterator.next();
+            if (!current.done) {
+                result += `,${config.spacingInner}`;
+            } else if (!config.min) {
+                result += ",";
+            }
+        }
+        result += config.spacingOuter + indentation;
+    }
+    return result;
+}
+/**
+* Return items (for example, of an array)
+* with spacing, indentation, and comma
+* without surrounding punctuation (for example, brackets)
+*/ function printListItems(list, config, indentation, depth, refs, printer) {
+    let result = "";
+    list = list instanceof ArrayBuffer ? new DataView(list) : list;
+    const isDataView = (l)=>l instanceof DataView;
+    const length = isDataView(list) ? list.byteLength : list.length;
+    if (length > 0) {
+        result += config.spacingOuter;
+        const indentationNext = indentation + config.indent;
+        for(let i = 0; i < length; i++){
+            result += indentationNext;
+            if (i === config.maxWidth) {
+                result += "…";
+                break;
+            }
+            if (isDataView(list) || i in list) {
+                result += printer(isDataView(list) ? list.getInt8(i) : list[i], config, indentationNext, depth, refs);
+            }
+            if (i < length - 1) {
+                result += `,${config.spacingInner}`;
+            } else if (!config.min) {
+                result += ",";
+            }
+        }
+        result += config.spacingOuter + indentation;
+    }
+    return result;
+}
+/**
+* Return properties of an object
+* with spacing, indentation, and comma
+* without surrounding punctuation (for example, braces)
+*/ function printObjectProperties(val, config, indentation, depth, refs, printer) {
+    let result = "";
+    const keys = getKeysOfEnumerableProperties(val, config.compareKeys);
+    if (keys.length > 0) {
+        result += config.spacingOuter;
+        const indentationNext = indentation + config.indent;
+        for(let i = 0; i < keys.length; i++){
+            const key = keys[i];
+            const name = printer(key, config, indentationNext, depth, refs);
+            const value = printer(val[key], config, indentationNext, depth, refs);
+            result += `${indentationNext + name}: ${value}`;
+            if (i < keys.length - 1) {
+                result += `,${config.spacingInner}`;
+            } else if (!config.min) {
+                result += ",";
+            }
+        }
+        result += config.spacingOuter + indentation;
+    }
+    return result;
+}
+const asymmetricMatcher = typeof Symbol === "function" && Symbol.for ? Symbol.for("jest.asymmetricMatcher") : 1267621;
+const SPACE$2 = " ";
+const serialize$5 = (val, config, indentation, depth, refs, printer)=>{
+    const stringedValue = val.toString();
+    if (stringedValue === "ArrayContaining" || stringedValue === "ArrayNotContaining") {
+        if (++depth > config.maxDepth) {
+            return `[${stringedValue}]`;
+        }
+        return `${stringedValue + SPACE$2}[${printListItems(val.sample, config, indentation, depth, refs, printer)}]`;
+    }
+    if (stringedValue === "ObjectContaining" || stringedValue === "ObjectNotContaining") {
+        if (++depth > config.maxDepth) {
+            return `[${stringedValue}]`;
+        }
+        return `${stringedValue + SPACE$2}{${printObjectProperties(val.sample, config, indentation, depth, refs, printer)}}`;
+    }
+    if (stringedValue === "StringMatching" || stringedValue === "StringNotMatching") {
+        return stringedValue + SPACE$2 + printer(val.sample, config, indentation, depth, refs);
+    }
+    if (stringedValue === "StringContaining" || stringedValue === "StringNotContaining") {
+        return stringedValue + SPACE$2 + printer(val.sample, config, indentation, depth, refs);
+    }
+    if (typeof val.toAsymmetricMatcher !== "function") {
+        throw new TypeError(`Asymmetric matcher ${val.constructor.name} does not implement toAsymmetricMatcher()`);
+    }
+    return val.toAsymmetricMatcher();
+};
+const test$5 = (val)=>val && val.$$typeof === asymmetricMatcher;
+const plugin$5 = {
+    serialize: serialize$5,
+    test: test$5
+};
+const SPACE$1 = " ";
+const OBJECT_NAMES = new Set([
+    "DOMStringMap",
+    "NamedNodeMap"
+]);
+const ARRAY_REGEXP = /^(?:HTML\w*Collection|NodeList)$/;
+function testName(name) {
+    return OBJECT_NAMES.has(name) || ARRAY_REGEXP.test(name);
+}
+const test$4 = (val)=>val && val.constructor && !!val.constructor.name && testName(val.constructor.name);
+function isNamedNodeMap(collection) {
+    return collection.constructor.name === "NamedNodeMap";
+}
+const serialize$4 = (collection, config, indentation, depth, refs, printer)=>{
+    const name = collection.constructor.name;
+    if (++depth > config.maxDepth) {
+        return `[${name}]`;
+    }
+    return (config.min ? "" : name + SPACE$1) + (OBJECT_NAMES.has(name) ? `{${printObjectProperties(isNamedNodeMap(collection) ? [
+        ...collection
+    ].reduce((props, attribute)=>{
+        props[attribute.name] = attribute.value;
+        return props;
+    }, {}) : {
+        ...collection
+    }, config, indentation, depth, refs, printer)}}` : `[${printListItems([
+        ...collection
+    ], config, indentation, depth, refs, printer)}]`);
+};
+const plugin$4 = {
+    serialize: serialize$4,
+    test: test$4
+};
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/ function escapeHTML(str) {
+    return str.replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+// Return empty string if keys is empty.
+function printProps(keys, props, config, indentation, depth, refs, printer) {
+    const indentationNext = indentation + config.indent;
+    const colors = config.colors;
+    return keys.map((key)=>{
+        const value = props[key];
+        // hidden injected value that should not be printed
+        if (typeof value === "string" && value[0] === "_" && value.startsWith("__vitest_") && value.match(/__vitest_\d+__/)) {
+            return "";
+        }
+        let printed = printer(value, config, indentationNext, depth, refs);
+        if (typeof value !== "string") {
+            if (printed.includes("\n")) {
+                printed = config.spacingOuter + indentationNext + printed + config.spacingOuter + indentation;
+            }
+            printed = `{${printed}}`;
+        }
+        return `${config.spacingInner + indentation + colors.prop.open + key + colors.prop.close}=${colors.value.open}${printed}${colors.value.close}`;
+    }).join("");
+}
+// Return empty string if children is empty.
+function printChildren(children, config, indentation, depth, refs, printer) {
+    return children.map((child)=>config.spacingOuter + indentation + (typeof child === "string" ? printText(child, config) : printer(child, config, indentation, depth, refs))).join("");
+}
+function printShadowRoot(children, config, indentation, depth, refs, printer) {
+    if (config.printShadowRoot === false) {
+        return "";
+    }
+    return [
+        `${config.spacingOuter + indentation}#shadow-root`,
+        printChildren(children, config, indentation + config.indent, depth, refs, printer)
+    ].join("");
+}
+function printText(text, config) {
+    const contentColor = config.colors.content;
+    return contentColor.open + escapeHTML(text) + contentColor.close;
+}
+function printComment(comment, config) {
+    const commentColor = config.colors.comment;
+    return `${commentColor.open}<!--${escapeHTML(comment)}-->${commentColor.close}`;
+}
+// Separate the functions to format props, children, and element,
+// so a plugin could override a particular function, if needed.
+// Too bad, so sad: the traditional (but unnecessary) space
+// in a self-closing tagColor requires a second test of printedProps.
+function printElement(type, printedProps, printedChildren, config, indentation) {
+    const tagColor = config.colors.tag;
+    return `${tagColor.open}<${type}${printedProps && tagColor.close + printedProps + config.spacingOuter + indentation + tagColor.open}${printedChildren ? `>${tagColor.close}${printedChildren}${config.spacingOuter}${indentation}${tagColor.open}</${type}` : `${printedProps && !config.min ? "" : " "}/`}>${tagColor.close}`;
+}
+function printElementAsLeaf(type, config) {
+    const tagColor = config.colors.tag;
+    return `${tagColor.open}<${type}${tagColor.close} …${tagColor.open} />${tagColor.close}`;
+}
+const ELEMENT_NODE = 1;
+const TEXT_NODE = 3;
+const COMMENT_NODE = 8;
+const FRAGMENT_NODE = 11;
+const ELEMENT_REGEXP = /^(?:(?:HTML|SVG)\w*)?Element$/;
+function testHasAttribute(val) {
+    try {
+        return typeof val.hasAttribute === "function" && val.hasAttribute("is");
+    } catch  {
+        return false;
+    }
+}
+function testNode(val) {
+    const constructorName = val.constructor.name;
+    const { nodeType, tagName } = val;
+    const isCustomElement = typeof tagName === "string" && tagName.includes("-") || testHasAttribute(val);
+    return nodeType === ELEMENT_NODE && (ELEMENT_REGEXP.test(constructorName) || isCustomElement) || nodeType === TEXT_NODE && constructorName === "Text" || nodeType === COMMENT_NODE && constructorName === "Comment" || nodeType === FRAGMENT_NODE && constructorName === "DocumentFragment";
+}
+const test$3 = (val)=>val?.constructor?.name && testNode(val);
+function nodeIsText(node) {
+    return node.nodeType === TEXT_NODE;
+}
+function nodeIsComment(node) {
+    return node.nodeType === COMMENT_NODE;
+}
+function nodeIsFragment(node) {
+    return node.nodeType === FRAGMENT_NODE;
+}
+const serialize$3 = (node, config, indentation, depth, refs, printer)=>{
+    if (nodeIsText(node)) {
+        return printText(node.data, config);
+    }
+    if (nodeIsComment(node)) {
+        return printComment(node.data, config);
+    }
+    const type = nodeIsFragment(node) ? "DocumentFragment" : node.tagName.toLowerCase();
+    if (++depth > config.maxDepth) {
+        return printElementAsLeaf(type, config);
+    }
+    return printElement(type, printProps(nodeIsFragment(node) ? [] : Array.from(node.attributes, (attr)=>attr.name).sort(), nodeIsFragment(node) ? {} : [
+        ...node.attributes
+    ].reduce((props, attribute)=>{
+        props[attribute.name] = attribute.value;
+        return props;
+    }, {}), config, indentation + config.indent, depth, refs, printer), (nodeIsFragment(node) || !node.shadowRoot ? "" : printShadowRoot(Array.prototype.slice.call(node.shadowRoot.children), config, indentation + config.indent, depth, refs, printer)) + printChildren(Array.prototype.slice.call(node.childNodes || node.children), config, indentation + config.indent, depth, refs, printer), config, indentation);
+};
+const plugin$3 = {
+    serialize: serialize$3,
+    test: test$3
+};
+// SENTINEL constants are from https://github.com/facebook/immutable-js
+const IS_ITERABLE_SENTINEL = "@@__IMMUTABLE_ITERABLE__@@";
+const IS_LIST_SENTINEL = "@@__IMMUTABLE_LIST__@@";
+const IS_KEYED_SENTINEL = "@@__IMMUTABLE_KEYED__@@";
+const IS_MAP_SENTINEL = "@@__IMMUTABLE_MAP__@@";
+const IS_ORDERED_SENTINEL = "@@__IMMUTABLE_ORDERED__@@";
+const IS_RECORD_SENTINEL = "@@__IMMUTABLE_RECORD__@@";
+const IS_SEQ_SENTINEL = "@@__IMMUTABLE_SEQ__@@";
+const IS_SET_SENTINEL = "@@__IMMUTABLE_SET__@@";
+const IS_STACK_SENTINEL = "@@__IMMUTABLE_STACK__@@";
+const getImmutableName = (name)=>`Immutable.${name}`;
+const printAsLeaf = (name)=>`[${name}]`;
+const SPACE = " ";
+const LAZY = "…";
+function printImmutableEntries(val, config, indentation, depth, refs, printer, type) {
+    return ++depth > config.maxDepth ? printAsLeaf(getImmutableName(type)) : `${getImmutableName(type) + SPACE}{${printIteratorEntries(val.entries(), config, indentation, depth, refs, printer)}}`;
+}
+// Record has an entries method because it is a collection in immutable v3.
+// Return an iterator for Immutable Record from version v3 or v4.
+function getRecordEntries(val) {
+    let i = 0;
+    return {
+        next () {
+            if (i < val._keys.length) {
+                const key = val._keys[i++];
+                return {
+                    done: false,
+                    value: [
+                        key,
+                        val.get(key)
+                    ]
+                };
+            }
+            return {
+                done: true,
+                value: undefined
+            };
+        }
+    };
+}
+function printImmutableRecord(val, config, indentation, depth, refs, printer) {
+    // _name property is defined only for an Immutable Record instance
+    // which was constructed with a second optional descriptive name arg
+    const name = getImmutableName(val._name || "Record");
+    return ++depth > config.maxDepth ? printAsLeaf(name) : `${name + SPACE}{${printIteratorEntries(getRecordEntries(val), config, indentation, depth, refs, printer)}}`;
+}
+function printImmutableSeq(val, config, indentation, depth, refs, printer) {
+    const name = getImmutableName("Seq");
+    if (++depth > config.maxDepth) {
+        return printAsLeaf(name);
+    }
+    if (val[IS_KEYED_SENTINEL]) {
+        return `${name + SPACE}{${val._iter || val._object ? printIteratorEntries(val.entries(), config, indentation, depth, refs, printer) : LAZY}}`;
+    }
+    return `${name + SPACE}[${val._iter || val._array || val._collection || val._iterable ? printIteratorValues(val.values(), config, indentation, depth, refs, printer) : LAZY}]`;
+}
+function printImmutableValues(val, config, indentation, depth, refs, printer, type) {
+    return ++depth > config.maxDepth ? printAsLeaf(getImmutableName(type)) : `${getImmutableName(type) + SPACE}[${printIteratorValues(val.values(), config, indentation, depth, refs, printer)}]`;
+}
+const serialize$2 = (val, config, indentation, depth, refs, printer)=>{
+    if (val[IS_MAP_SENTINEL]) {
+        return printImmutableEntries(val, config, indentation, depth, refs, printer, val[IS_ORDERED_SENTINEL] ? "OrderedMap" : "Map");
+    }
+    if (val[IS_LIST_SENTINEL]) {
+        return printImmutableValues(val, config, indentation, depth, refs, printer, "List");
+    }
+    if (val[IS_SET_SENTINEL]) {
+        return printImmutableValues(val, config, indentation, depth, refs, printer, val[IS_ORDERED_SENTINEL] ? "OrderedSet" : "Set");
+    }
+    if (val[IS_STACK_SENTINEL]) {
+        return printImmutableValues(val, config, indentation, depth, refs, printer, "Stack");
+    }
+    if (val[IS_SEQ_SENTINEL]) {
+        return printImmutableSeq(val, config, indentation, depth, refs, printer);
+    }
+    // For compatibility with immutable v3 and v4, let record be the default.
+    return printImmutableRecord(val, config, indentation, depth, refs, printer);
+};
+// Explicitly comparing sentinel properties to true avoids false positive
+// when mock identity-obj-proxy returns the key as the value for any key.
+const test$2 = (val)=>val && (val[IS_ITERABLE_SENTINEL] === true || val[IS_RECORD_SENTINEL] === true);
+const plugin$2 = {
+    serialize: serialize$2,
+    test: test$2
+};
+function getDefaultExportFromCjs(x) {
+    return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var reactIs$1 = {
+    exports: {}
+};
+var reactIs_production = {};
+/**
+ * @license React
+ * react-is.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */ var hasRequiredReactIs_production;
+function requireReactIs_production() {
+    if (hasRequiredReactIs_production) return reactIs_production;
+    hasRequiredReactIs_production = 1;
+    var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_VIEW_TRANSITION_TYPE = Symbol.for("react.view_transition"), REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference");
+    function typeOf(object) {
+        if ("object" === typeof object && null !== object) {
+            var $$typeof = object.$$typeof;
+            switch($$typeof){
+                case REACT_ELEMENT_TYPE:
+                    switch(object = object.type, object){
+                        case REACT_FRAGMENT_TYPE:
+                        case REACT_PROFILER_TYPE:
+                        case REACT_STRICT_MODE_TYPE:
+                        case REACT_SUSPENSE_TYPE:
+                        case REACT_SUSPENSE_LIST_TYPE:
+                        case REACT_VIEW_TRANSITION_TYPE:
+                            return object;
+                        default:
+                            switch(object = object && object.$$typeof, object){
+                                case REACT_CONTEXT_TYPE:
+                                case REACT_FORWARD_REF_TYPE:
+                                case REACT_LAZY_TYPE:
+                                case REACT_MEMO_TYPE:
+                                    return object;
+                                case REACT_CONSUMER_TYPE:
+                                    return object;
+                                default:
+                                    return $$typeof;
+                            }
+                    }
+                case REACT_PORTAL_TYPE:
+                    return $$typeof;
+            }
+        }
+    }
+    reactIs_production.ContextConsumer = REACT_CONSUMER_TYPE;
+    reactIs_production.ContextProvider = REACT_CONTEXT_TYPE;
+    reactIs_production.Element = REACT_ELEMENT_TYPE;
+    reactIs_production.ForwardRef = REACT_FORWARD_REF_TYPE;
+    reactIs_production.Fragment = REACT_FRAGMENT_TYPE;
+    reactIs_production.Lazy = REACT_LAZY_TYPE;
+    reactIs_production.Memo = REACT_MEMO_TYPE;
+    reactIs_production.Portal = REACT_PORTAL_TYPE;
+    reactIs_production.Profiler = REACT_PROFILER_TYPE;
+    reactIs_production.StrictMode = REACT_STRICT_MODE_TYPE;
+    reactIs_production.Suspense = REACT_SUSPENSE_TYPE;
+    reactIs_production.SuspenseList = REACT_SUSPENSE_LIST_TYPE;
+    reactIs_production.isContextConsumer = function(object) {
+        return typeOf(object) === REACT_CONSUMER_TYPE;
+    };
+    reactIs_production.isContextProvider = function(object) {
+        return typeOf(object) === REACT_CONTEXT_TYPE;
+    };
+    reactIs_production.isElement = function(object) {
+        return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+    };
+    reactIs_production.isForwardRef = function(object) {
+        return typeOf(object) === REACT_FORWARD_REF_TYPE;
+    };
+    reactIs_production.isFragment = function(object) {
+        return typeOf(object) === REACT_FRAGMENT_TYPE;
+    };
+    reactIs_production.isLazy = function(object) {
+        return typeOf(object) === REACT_LAZY_TYPE;
+    };
+    reactIs_production.isMemo = function(object) {
+        return typeOf(object) === REACT_MEMO_TYPE;
+    };
+    reactIs_production.isPortal = function(object) {
+        return typeOf(object) === REACT_PORTAL_TYPE;
+    };
+    reactIs_production.isProfiler = function(object) {
+        return typeOf(object) === REACT_PROFILER_TYPE;
+    };
+    reactIs_production.isStrictMode = function(object) {
+        return typeOf(object) === REACT_STRICT_MODE_TYPE;
+    };
+    reactIs_production.isSuspense = function(object) {
+        return typeOf(object) === REACT_SUSPENSE_TYPE;
+    };
+    reactIs_production.isSuspenseList = function(object) {
+        return typeOf(object) === REACT_SUSPENSE_LIST_TYPE;
+    };
+    reactIs_production.isValidElementType = function(type) {
+        return "string" === typeof type || "function" === typeof type || type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || "object" === typeof type && null !== type && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_CONSUMER_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_CLIENT_REFERENCE || void 0 !== type.getModuleId) ? true : false;
+    };
+    reactIs_production.typeOf = typeOf;
+    return reactIs_production;
+}
+var hasRequiredReactIs$1;
+function requireReactIs$1() {
+    if (hasRequiredReactIs$1) return reactIs$1.exports;
+    hasRequiredReactIs$1 = 1;
+    {
+        reactIs$1.exports = requireReactIs_production();
+    }
+    return reactIs$1.exports;
+}
+var reactIsExports$1 = requireReactIs$1();
+var index$1 = /*@__PURE__*/ getDefaultExportFromCjs(reactIsExports$1);
+var ReactIs19 = /*#__PURE__*/ _mergeNamespaces$1({
+    __proto__: null,
+    default: index$1
+}, [
+    reactIsExports$1
+]);
+var reactIs = {
+    exports: {}
+};
+var reactIs_production_min = {};
+/**
+ * @license React
+ * react-is.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */ var hasRequiredReactIs_production_min;
+function requireReactIs_production_min() {
+    if (hasRequiredReactIs_production_min) return reactIs_production_min;
+    hasRequiredReactIs_production_min = 1;
+    var b = Symbol.for("react.element"), c = Symbol.for("react.portal"), d = Symbol.for("react.fragment"), e = Symbol.for("react.strict_mode"), f = Symbol.for("react.profiler"), g = Symbol.for("react.provider"), h = Symbol.for("react.context"), k = Symbol.for("react.server_context"), l = Symbol.for("react.forward_ref"), m = Symbol.for("react.suspense"), n = Symbol.for("react.suspense_list"), p = Symbol.for("react.memo"), q = Symbol.for("react.lazy"), t = Symbol.for("react.offscreen"), u;
+    u = Symbol.for("react.module.reference");
+    function v(a) {
+        if ("object" === typeof a && null !== a) {
+            var r = a.$$typeof;
+            switch(r){
+                case b:
+                    switch(a = a.type, a){
+                        case d:
+                        case f:
+                        case e:
+                        case m:
+                        case n:
+                            return a;
+                        default:
+                            switch(a = a && a.$$typeof, a){
+                                case k:
+                                case h:
+                                case l:
+                                case q:
+                                case p:
+                                case g:
+                                    return a;
+                                default:
+                                    return r;
+                            }
+                    }
+                case c:
+                    return r;
+            }
+        }
+    }
+    reactIs_production_min.ContextConsumer = h;
+    reactIs_production_min.ContextProvider = g;
+    reactIs_production_min.Element = b;
+    reactIs_production_min.ForwardRef = l;
+    reactIs_production_min.Fragment = d;
+    reactIs_production_min.Lazy = q;
+    reactIs_production_min.Memo = p;
+    reactIs_production_min.Portal = c;
+    reactIs_production_min.Profiler = f;
+    reactIs_production_min.StrictMode = e;
+    reactIs_production_min.Suspense = m;
+    reactIs_production_min.SuspenseList = n;
+    reactIs_production_min.isAsyncMode = function() {
+        return false;
+    };
+    reactIs_production_min.isConcurrentMode = function() {
+        return false;
+    };
+    reactIs_production_min.isContextConsumer = function(a) {
+        return v(a) === h;
+    };
+    reactIs_production_min.isContextProvider = function(a) {
+        return v(a) === g;
+    };
+    reactIs_production_min.isElement = function(a) {
+        return "object" === typeof a && null !== a && a.$$typeof === b;
+    };
+    reactIs_production_min.isForwardRef = function(a) {
+        return v(a) === l;
+    };
+    reactIs_production_min.isFragment = function(a) {
+        return v(a) === d;
+    };
+    reactIs_production_min.isLazy = function(a) {
+        return v(a) === q;
+    };
+    reactIs_production_min.isMemo = function(a) {
+        return v(a) === p;
+    };
+    reactIs_production_min.isPortal = function(a) {
+        return v(a) === c;
+    };
+    reactIs_production_min.isProfiler = function(a) {
+        return v(a) === f;
+    };
+    reactIs_production_min.isStrictMode = function(a) {
+        return v(a) === e;
+    };
+    reactIs_production_min.isSuspense = function(a) {
+        return v(a) === m;
+    };
+    reactIs_production_min.isSuspenseList = function(a) {
+        return v(a) === n;
+    };
+    reactIs_production_min.isValidElementType = function(a) {
+        return "string" === typeof a || "function" === typeof a || a === d || a === f || a === e || a === m || a === n || a === t || "object" === typeof a && null !== a && (a.$$typeof === q || a.$$typeof === p || a.$$typeof === g || a.$$typeof === h || a.$$typeof === l || a.$$typeof === u || void 0 !== a.getModuleId) ? true : false;
+    };
+    reactIs_production_min.typeOf = v;
+    return reactIs_production_min;
+}
+var hasRequiredReactIs;
+function requireReactIs() {
+    if (hasRequiredReactIs) return reactIs.exports;
+    hasRequiredReactIs = 1;
+    {
+        reactIs.exports = requireReactIs_production_min();
+    }
+    return reactIs.exports;
+}
+var reactIsExports = requireReactIs();
+var index = /*@__PURE__*/ getDefaultExportFromCjs(reactIsExports);
+var ReactIs18 = /*#__PURE__*/ _mergeNamespaces$1({
+    __proto__: null,
+    default: index
+}, [
+    reactIsExports
+]);
+const reactIsMethods = [
+    "isAsyncMode",
+    "isConcurrentMode",
+    "isContextConsumer",
+    "isContextProvider",
+    "isElement",
+    "isForwardRef",
+    "isFragment",
+    "isLazy",
+    "isMemo",
+    "isPortal",
+    "isProfiler",
+    "isStrictMode",
+    "isSuspense",
+    "isSuspenseList",
+    "isValidElementType"
+];
+const ReactIs = Object.fromEntries(reactIsMethods.map((m)=>[
+        m,
+        (v)=>ReactIs18[m](v) || ReactIs19[m](v)
+    ]));
+// Given element.props.children, or subtree during recursive traversal,
+// return flattened array of children.
+function getChildren(arg, children = []) {
+    if (Array.isArray(arg)) {
+        for (const item of arg){
+            getChildren(item, children);
+        }
+    } else if (arg != null && arg !== false && arg !== "") {
+        children.push(arg);
+    }
+    return children;
+}
+function getType(element) {
+    const type = element.type;
+    if (typeof type === "string") {
+        return type;
+    }
+    if (typeof type === "function") {
+        return type.displayName || type.name || "Unknown";
+    }
+    if (ReactIs.isFragment(element)) {
+        return "React.Fragment";
+    }
+    if (ReactIs.isSuspense(element)) {
+        return "React.Suspense";
+    }
+    if (typeof type === "object" && type !== null) {
+        if (ReactIs.isContextProvider(element)) {
+            return "Context.Provider";
+        }
+        if (ReactIs.isContextConsumer(element)) {
+            return "Context.Consumer";
+        }
+        if (ReactIs.isForwardRef(element)) {
+            if (type.displayName) {
+                return type.displayName;
+            }
+            const functionName = type.render.displayName || type.render.name || "";
+            return functionName === "" ? "ForwardRef" : `ForwardRef(${functionName})`;
+        }
+        if (ReactIs.isMemo(element)) {
+            const functionName = type.displayName || type.type.displayName || type.type.name || "";
+            return functionName === "" ? "Memo" : `Memo(${functionName})`;
+        }
+    }
+    return "UNDEFINED";
+}
+function getPropKeys$1(element) {
+    const { props } = element;
+    return Object.keys(props).filter((key)=>key !== "children" && props[key] !== undefined).sort();
+}
+const serialize$1 = (element, config, indentation, depth, refs, printer)=>++depth > config.maxDepth ? printElementAsLeaf(getType(element), config) : printElement(getType(element), printProps(getPropKeys$1(element), element.props, config, indentation + config.indent, depth, refs, printer), printChildren(getChildren(element.props.children), config, indentation + config.indent, depth, refs, printer), config, indentation);
+const test$1 = (val)=>val != null && ReactIs.isElement(val);
+const plugin$1 = {
+    serialize: serialize$1,
+    test: test$1
+};
+const testSymbol = typeof Symbol === "function" && Symbol.for ? Symbol.for("react.test.json") : 245830487;
+function getPropKeys(object) {
+    const { props } = object;
+    return props ? Object.keys(props).filter((key)=>props[key] !== undefined).sort() : [];
+}
+const serialize = (object, config, indentation, depth, refs, printer)=>++depth > config.maxDepth ? printElementAsLeaf(object.type, config) : printElement(object.type, object.props ? printProps(getPropKeys(object), object.props, config, indentation + config.indent, depth, refs, printer) : "", object.children ? printChildren(object.children, config, indentation + config.indent, depth, refs, printer) : "", config, indentation);
+const test$6 = (val)=>val && val.$$typeof === testSymbol;
+const plugin = {
+    serialize,
+    test: test$6
+};
+const toString$1 = Object.prototype.toString;
+const toISOString = Date.prototype.toISOString;
+const errorToString = Error.prototype.toString;
+const regExpToString = RegExp.prototype.toString;
+/**
+* Explicitly comparing typeof constructor to function avoids undefined as name
+* when mock identity-obj-proxy returns the key as the value for any key.
+*/ function getConstructorName(val) {
+    return typeof val.constructor === "function" && val.constructor.name || "Object";
+}
+/** Is val is equal to global window object? Works even if it does not exist :) */ function isWindow(val) {
+    return typeof window !== "undefined" && val === window;
+}
+// eslint-disable-next-line regexp/no-super-linear-backtracking
+const SYMBOL_REGEXP = /^Symbol\((.*)\)(.*)$/;
+const NEWLINE_REGEXP = /\n/g;
+class PrettyFormatPluginError extends Error {
+    constructor(message, stack){
+        super(message);
+        this.stack = stack;
+        this.name = this.constructor.name;
+    }
+}
+function isToStringedArrayType(toStringed) {
+    return toStringed === "[object Array]" || toStringed === "[object ArrayBuffer]" || toStringed === "[object DataView]" || toStringed === "[object Float32Array]" || toStringed === "[object Float64Array]" || toStringed === "[object Int8Array]" || toStringed === "[object Int16Array]" || toStringed === "[object Int32Array]" || toStringed === "[object Uint8Array]" || toStringed === "[object Uint8ClampedArray]" || toStringed === "[object Uint16Array]" || toStringed === "[object Uint32Array]";
+}
+function printNumber(val) {
+    return Object.is(val, -0) ? "-0" : String(val);
+}
+function printBigInt(val) {
+    return String(`${val}n`);
+}
+function printFunction(val, printFunctionName) {
+    if (!printFunctionName) {
+        return "[Function]";
+    }
+    return `[Function ${val.name || "anonymous"}]`;
+}
+function printSymbol(val) {
+    return String(val).replace(SYMBOL_REGEXP, "Symbol($1)");
+}
+function printError(val) {
+    return `[${errorToString.call(val)}]`;
+}
+/**
+* The first port of call for printing an object, handles most of the
+* data-types in JS.
+*/ function printBasicValue(val, printFunctionName, escapeRegex, escapeString) {
+    if (val === true || val === false) {
+        return `${val}`;
+    }
+    if (val === undefined) {
+        return "undefined";
+    }
+    if (val === null) {
+        return "null";
+    }
+    const typeOf = typeof val;
+    if (typeOf === "number") {
+        return printNumber(val);
+    }
+    if (typeOf === "bigint") {
+        return printBigInt(val);
+    }
+    if (typeOf === "string") {
+        if (escapeString) {
+            return `"${val.replaceAll(/"|\\/g, "\\$&")}"`;
+        }
+        return `"${val}"`;
+    }
+    if (typeOf === "function") {
+        return printFunction(val, printFunctionName);
+    }
+    if (typeOf === "symbol") {
+        return printSymbol(val);
+    }
+    const toStringed = toString$1.call(val);
+    if (toStringed === "[object WeakMap]") {
+        return "WeakMap {}";
+    }
+    if (toStringed === "[object WeakSet]") {
+        return "WeakSet {}";
+    }
+    if (toStringed === "[object Function]" || toStringed === "[object GeneratorFunction]") {
+        return printFunction(val, printFunctionName);
+    }
+    if (toStringed === "[object Symbol]") {
+        return printSymbol(val);
+    }
+    if (toStringed === "[object Date]") {
+        return Number.isNaN(+val) ? "Date { NaN }" : toISOString.call(val);
+    }
+    if (toStringed === "[object Error]") {
+        return printError(val);
+    }
+    if (toStringed === "[object RegExp]") {
+        if (escapeRegex) {
+            // https://github.com/benjamingr/RegExp.escape/blob/main/polyfill.js
+            return regExpToString.call(val).replaceAll(/[$()*+.?[\\\]^{|}]/g, "\\$&");
+        }
+        return regExpToString.call(val);
+    }
+    if (val instanceof Error) {
+        return printError(val);
+    }
+    return null;
+}
+/**
+* Handles more complex objects ( such as objects with circular references.
+* maps and sets etc )
+*/ function printComplexValue(val, config, indentation, depth, refs, hasCalledToJSON) {
+    if (refs.includes(val)) {
+        return "[Circular]";
+    }
+    refs = [
+        ...refs
+    ];
+    refs.push(val);
+    const hitMaxDepth = ++depth > config.maxDepth;
+    const min = config.min;
+    if (config.callToJSON && !hitMaxDepth && val.toJSON && typeof val.toJSON === "function" && !hasCalledToJSON) {
+        return printer(val.toJSON(), config, indentation, depth, refs, true);
+    }
+    const toStringed = toString$1.call(val);
+    if (toStringed === "[object Arguments]") {
+        return hitMaxDepth ? "[Arguments]" : `${min ? "" : "Arguments "}[${printListItems(val, config, indentation, depth, refs, printer)}]`;
+    }
+    if (isToStringedArrayType(toStringed)) {
+        return hitMaxDepth ? `[${val.constructor.name}]` : `${min ? "" : !config.printBasicPrototype && val.constructor.name === "Array" ? "" : `${val.constructor.name} `}[${printListItems(val, config, indentation, depth, refs, printer)}]`;
+    }
+    if (toStringed === "[object Map]") {
+        return hitMaxDepth ? "[Map]" : `Map {${printIteratorEntries(val.entries(), config, indentation, depth, refs, printer, " => ")}}`;
+    }
+    if (toStringed === "[object Set]") {
+        return hitMaxDepth ? "[Set]" : `Set {${printIteratorValues(val.values(), config, indentation, depth, refs, printer)}}`;
+    }
+    // Avoid failure to serialize global window object in jsdom test environment.
+    // For example, not even relevant if window is prop of React element.
+    return hitMaxDepth || isWindow(val) ? `[${getConstructorName(val)}]` : `${min ? "" : !config.printBasicPrototype && getConstructorName(val) === "Object" ? "" : `${getConstructorName(val)} `}{${printObjectProperties(val, config, indentation, depth, refs, printer)}}`;
+}
+function isNewPlugin(plugin) {
+    return plugin.serialize != null;
+}
+function printPlugin(plugin, val, config, indentation, depth, refs) {
+    let printed;
+    try {
+        printed = isNewPlugin(plugin) ? plugin.serialize(val, config, indentation, depth, refs, printer) : plugin.print(val, (valChild)=>printer(valChild, config, indentation, depth, refs), (str)=>{
+            const indentationNext = indentation + config.indent;
+            return indentationNext + str.replaceAll(NEWLINE_REGEXP, `\n${indentationNext}`);
+        }, {
+            edgeSpacing: config.spacingOuter,
+            min: config.min,
+            spacing: config.spacingInner
+        }, config.colors);
+    } catch (error) {
+        throw new PrettyFormatPluginError(error.message, error.stack);
+    }
+    if (typeof printed !== "string") {
+        throw new TypeError(`pretty-format: Plugin must return type "string" but instead returned "${typeof printed}".`);
+    }
+    return printed;
+}
+function findPlugin(plugins, val) {
+    for (const plugin of plugins){
+        try {
+            if (plugin.test(val)) {
+                return plugin;
+            }
+        } catch (error) {
+            throw new PrettyFormatPluginError(error.message, error.stack);
+        }
+    }
+    return null;
+}
+function printer(val, config, indentation, depth, refs, hasCalledToJSON) {
+    const plugin = findPlugin(config.plugins, val);
+    if (plugin !== null) {
+        return printPlugin(plugin, val, config, indentation, depth, refs);
+    }
+    const basicResult = printBasicValue(val, config.printFunctionName, config.escapeRegex, config.escapeString);
+    if (basicResult !== null) {
+        return basicResult;
+    }
+    return printComplexValue(val, config, indentation, depth, refs, hasCalledToJSON);
+}
+const DEFAULT_THEME = {
+    comment: "gray",
+    content: "reset",
+    prop: "yellow",
+    tag: "cyan",
+    value: "green"
+};
+const DEFAULT_THEME_KEYS = Object.keys(DEFAULT_THEME);
+const DEFAULT_OPTIONS = {
+    callToJSON: true,
+    compareKeys: undefined,
+    escapeRegex: false,
+    escapeString: true,
+    highlight: false,
+    indent: 2,
+    maxDepth: Number.POSITIVE_INFINITY,
+    maxWidth: Number.POSITIVE_INFINITY,
+    min: false,
+    plugins: [],
+    printBasicPrototype: true,
+    printFunctionName: true,
+    printShadowRoot: true,
+    theme: DEFAULT_THEME
+};
+function validateOptions(options) {
+    for (const key of Object.keys(options)){
+        if (!Object.hasOwn(DEFAULT_OPTIONS, key)) {
+            throw new Error(`pretty-format: Unknown option "${key}".`);
+        }
+    }
+    if (options.min && options.indent !== undefined && options.indent !== 0) {
+        throw new Error("pretty-format: Options \"min\" and \"indent\" cannot be used together.");
+    }
+}
+function getColorsHighlight() {
+    return DEFAULT_THEME_KEYS.reduce((colors, key)=>{
+        const value = DEFAULT_THEME[key];
+        const color = value && C[value];
+        if (color && typeof color.close === "string" && typeof color.open === "string") {
+            colors[key] = color;
+        } else {
+            throw new Error(`pretty-format: Option "theme" has a key "${key}" whose value "${value}" is undefined in ansi-styles.`);
+        }
+        return colors;
+    }, Object.create(null));
+}
+function getColorsEmpty() {
+    return DEFAULT_THEME_KEYS.reduce((colors, key)=>{
+        colors[key] = {
+            close: "",
+            open: ""
+        };
+        return colors;
+    }, Object.create(null));
+}
+function getPrintFunctionName(options) {
+    return options?.printFunctionName ?? DEFAULT_OPTIONS.printFunctionName;
+}
+function getEscapeRegex(options) {
+    return options?.escapeRegex ?? DEFAULT_OPTIONS.escapeRegex;
+}
+function getEscapeString(options) {
+    return options?.escapeString ?? DEFAULT_OPTIONS.escapeString;
+}
+function getConfig(options) {
+    return {
+        callToJSON: options?.callToJSON ?? DEFAULT_OPTIONS.callToJSON,
+        colors: options?.highlight ? getColorsHighlight() : getColorsEmpty(),
+        compareKeys: typeof options?.compareKeys === "function" || options?.compareKeys === null ? options.compareKeys : DEFAULT_OPTIONS.compareKeys,
+        escapeRegex: getEscapeRegex(options),
+        escapeString: getEscapeString(options),
+        indent: options?.min ? "" : createIndent(options?.indent ?? DEFAULT_OPTIONS.indent),
+        maxDepth: options?.maxDepth ?? DEFAULT_OPTIONS.maxDepth,
+        maxWidth: options?.maxWidth ?? DEFAULT_OPTIONS.maxWidth,
+        min: options?.min ?? DEFAULT_OPTIONS.min,
+        plugins: options?.plugins ?? DEFAULT_OPTIONS.plugins,
+        printBasicPrototype: options?.printBasicPrototype ?? true,
+        printFunctionName: getPrintFunctionName(options),
+        printShadowRoot: options?.printShadowRoot ?? true,
+        spacingInner: options?.min ? " " : "\n",
+        spacingOuter: options?.min ? "" : "\n"
+    };
+}
+function createIndent(indent) {
+    return Array.from({
+        length: indent + 1
+    }).join(" ");
+}
+/**
+* Returns a presentation string of your `val` object
+* @param val any potential JavaScript object
+* @param options Custom settings
+*/ function format$1(val, options) {
+    if (options) {
+        validateOptions(options);
+        if (options.plugins) {
+            const plugin = findPlugin(options.plugins, val);
+            if (plugin !== null) {
+                return printPlugin(plugin, val, getConfig(options), "", 0, []);
+            }
+        }
+    }
+    const basicResult = printBasicValue(val, getPrintFunctionName(options), getEscapeRegex(options), getEscapeString(options));
+    if (basicResult !== null) {
+        return basicResult;
+    }
+    return printComplexValue(val, getConfig(options), "", 0, []);
+}
+const plugins = {
+    AsymmetricMatcher: plugin$5,
+    DOMCollection: plugin$4,
+    DOMElement: plugin$3,
+    Immutable: plugin$2,
+    ReactElement: plugin$1,
+    ReactTestComponent: plugin};
+
+const ansiColors = {
+    bold: [
+        '1',
+        '22'
+    ],
+    dim: [
+        '2',
+        '22'
+    ],
+    italic: [
+        '3',
+        '23'
+    ],
+    underline: [
+        '4',
+        '24'
+    ],
+    // 5 & 6 are blinking
+    inverse: [
+        '7',
+        '27'
+    ],
+    hidden: [
+        '8',
+        '28'
+    ],
+    strike: [
+        '9',
+        '29'
+    ],
+    // 10-20 are fonts
+    // 21-29 are resets for 1-9
+    black: [
+        '30',
+        '39'
+    ],
+    red: [
+        '31',
+        '39'
+    ],
+    green: [
+        '32',
+        '39'
+    ],
+    yellow: [
+        '33',
+        '39'
+    ],
+    blue: [
+        '34',
+        '39'
+    ],
+    magenta: [
+        '35',
+        '39'
+    ],
+    cyan: [
+        '36',
+        '39'
+    ],
+    white: [
+        '37',
+        '39'
+    ],
+    brightblack: [
+        '30;1',
+        '39'
+    ],
+    brightred: [
+        '31;1',
+        '39'
+    ],
+    brightgreen: [
+        '32;1',
+        '39'
+    ],
+    brightyellow: [
+        '33;1',
+        '39'
+    ],
+    brightblue: [
+        '34;1',
+        '39'
+    ],
+    brightmagenta: [
+        '35;1',
+        '39'
+    ],
+    brightcyan: [
+        '36;1',
+        '39'
+    ],
+    brightwhite: [
+        '37;1',
+        '39'
+    ],
+    grey: [
+        '90',
+        '39'
+    ]
+};
+const styles = {
+    special: 'cyan',
+    number: 'yellow',
+    bigint: 'yellow',
+    boolean: 'yellow',
+    undefined: 'grey',
+    null: 'bold',
+    string: 'green',
+    symbol: 'green',
+    date: 'magenta',
+    regexp: 'red'
+};
+const truncator = '…';
+function colorise(value, styleType) {
+    const color = ansiColors[styles[styleType]] || ansiColors[styleType] || '';
+    if (!color) {
+        return String(value);
+    }
+    return `\u001b[${color[0]}m${String(value)}\u001b[${color[1]}m`;
+}
+function normaliseOptions({ showHidden = false, depth = 2, colors = false, customInspect = true, showProxy = false, maxArrayLength = Infinity, breakLength = Infinity, seen = [], // eslint-disable-next-line no-shadow
+truncate = Infinity, stylize = String } = {}, inspect) {
+    const options = {
+        showHidden: Boolean(showHidden),
+        depth: Number(depth),
+        colors: Boolean(colors),
+        customInspect: Boolean(customInspect),
+        showProxy: Boolean(showProxy),
+        maxArrayLength: Number(maxArrayLength),
+        breakLength: Number(breakLength),
+        truncate: Number(truncate),
+        seen,
+        inspect,
+        stylize
+    };
+    if (options.colors) {
+        options.stylize = colorise;
+    }
+    return options;
+}
+function isHighSurrogate(char) {
+    return char >= '\ud800' && char <= '\udbff';
+}
+function truncate(string, length, tail = truncator) {
+    string = String(string);
+    const tailLength = tail.length;
+    const stringLength = string.length;
+    if (tailLength > length && stringLength > tailLength) {
+        return tail;
+    }
+    if (stringLength > length && stringLength > tailLength) {
+        let end = length - tailLength;
+        if (end > 0 && isHighSurrogate(string[end - 1])) {
+            end = end - 1;
+        }
+        return `${string.slice(0, end)}${tail}`;
+    }
+    return string;
+}
+// eslint-disable-next-line complexity
+function inspectList(list, options, inspectItem, separator = ', ') {
+    inspectItem = inspectItem || options.inspect;
+    const size = list.length;
+    if (size === 0) return '';
+    const originalLength = options.truncate;
+    let output = '';
+    let peek = '';
+    let truncated = '';
+    for(let i = 0; i < size; i += 1){
+        const last = i + 1 === list.length;
+        const secondToLast = i + 2 === list.length;
+        truncated = `${truncator}(${list.length - i})`;
+        const value = list[i];
+        // If there is more than one remaining we need to account for a separator of `, `
+        options.truncate = originalLength - output.length - (last ? 0 : separator.length);
+        const string = peek || inspectItem(value, options) + (last ? '' : separator);
+        const nextLength = output.length + string.length;
+        const truncatedLength = nextLength + truncated.length;
+        // If this is the last element, and adding it would
+        // take us over length, but adding the truncator wouldn't - then break now
+        if (last && nextLength > originalLength && output.length + truncated.length <= originalLength) {
+            break;
+        }
+        // If this isn't the last or second to last element to scan,
+        // but the string is already over length then break here
+        if (!last && !secondToLast && truncatedLength > originalLength) {
+            break;
+        }
+        // Peek at the next string to determine if we should
+        // break early before adding this item to the output
+        peek = last ? '' : inspectItem(list[i + 1], options) + (secondToLast ? '' : separator);
+        // If we have one element left, but this element and
+        // the next takes over length, the break early
+        if (!last && secondToLast && truncatedLength > originalLength && nextLength + peek.length > originalLength) {
+            break;
+        }
+        output += string;
+        // If the next element takes us to length -
+        // but there are more after that, then we should truncate now
+        if (!last && !secondToLast && nextLength + peek.length >= originalLength) {
+            truncated = `${truncator}(${list.length - i - 1})`;
+            break;
+        }
+        truncated = '';
+    }
+    return `${output}${truncated}`;
+}
+function quoteComplexKey(key) {
+    if (key.match(/^[a-zA-Z_][a-zA-Z_0-9]*$/)) {
+        return key;
+    }
+    return JSON.stringify(key).replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
+}
+function inspectProperty([key, value], options) {
+    options.truncate -= 2;
+    if (typeof key === 'string') {
+        key = quoteComplexKey(key);
+    } else if (typeof key !== 'number') {
+        key = `[${options.inspect(key, options)}]`;
+    }
+    options.truncate -= key.length;
+    value = options.inspect(value, options);
+    return `${key}: ${value}`;
+}
+function inspectArray(array, options) {
+    // Object.keys will always output the Array indices first, so we can slice by
+    // `array.length` to get non-index properties
+    const nonIndexProperties = Object.keys(array).slice(array.length);
+    if (!array.length && !nonIndexProperties.length) return '[]';
+    options.truncate -= 4;
+    const listContents = inspectList(array, options);
+    options.truncate -= listContents.length;
+    let propertyContents = '';
+    if (nonIndexProperties.length) {
+        propertyContents = inspectList(nonIndexProperties.map((key)=>[
+                key,
+                array[key]
+            ]), options, inspectProperty);
+    }
+    return `[ ${listContents}${propertyContents ? `, ${propertyContents}` : ''} ]`;
+}
+const getArrayName = (array)=>{
+    // We need to special case Node.js' Buffers, which report to be Uint8Array
+    // @ts-ignore
+    if (typeof Buffer === 'function' && array instanceof Buffer) {
+        return 'Buffer';
+    }
+    if (array[Symbol.toStringTag]) {
+        return array[Symbol.toStringTag];
+    }
+    return array.constructor.name;
+};
+function inspectTypedArray(array, options) {
+    const name = getArrayName(array);
+    options.truncate -= name.length + 4;
+    // Object.keys will always output the Array indices first, so we can slice by
+    // `array.length` to get non-index properties
+    const nonIndexProperties = Object.keys(array).slice(array.length);
+    if (!array.length && !nonIndexProperties.length) return `${name}[]`;
+    // As we know TypedArrays only contain Unsigned Integers, we can skip inspecting each one and simply
+    // stylise the toString() value of them
+    let output = '';
+    for(let i = 0; i < array.length; i++){
+        const string = `${options.stylize(truncate(array[i], options.truncate), 'number')}${i === array.length - 1 ? '' : ', '}`;
+        options.truncate -= string.length;
+        if (array[i] !== array.length && options.truncate <= 3) {
+            output += `${truncator}(${array.length - array[i] + 1})`;
+            break;
+        }
+        output += string;
+    }
+    let propertyContents = '';
+    if (nonIndexProperties.length) {
+        propertyContents = inspectList(nonIndexProperties.map((key)=>[
+                key,
+                array[key]
+            ]), options, inspectProperty);
+    }
+    return `${name}[ ${output}${propertyContents ? `, ${propertyContents}` : ''} ]`;
+}
+function inspectDate(dateObject, options) {
+    const stringRepresentation = dateObject.toJSON();
+    if (stringRepresentation === null) {
+        return 'Invalid Date';
+    }
+    const split = stringRepresentation.split('T');
+    const date = split[0];
+    // If we need to - truncate the time portion, but never the date
+    return options.stylize(`${date}T${truncate(split[1], options.truncate - date.length - 1)}`, 'date');
+}
+function inspectFunction(func, options) {
+    const functionType = func[Symbol.toStringTag] || 'Function';
+    const name = func.name;
+    if (!name) {
+        return options.stylize(`[${functionType}]`, 'special');
+    }
+    return options.stylize(`[${functionType} ${truncate(name, options.truncate - 11)}]`, 'special');
+}
+function inspectMapEntry([key, value], options) {
+    options.truncate -= 4;
+    key = options.inspect(key, options);
+    options.truncate -= key.length;
+    value = options.inspect(value, options);
+    return `${key} => ${value}`;
+}
+// IE11 doesn't support `map.entries()`
+function mapToEntries(map) {
+    const entries = [];
+    map.forEach((value, key)=>{
+        entries.push([
+            key,
+            value
+        ]);
+    });
+    return entries;
+}
+function inspectMap(map, options) {
+    if (map.size === 0) return 'Map{}';
+    options.truncate -= 7;
+    return `Map{ ${inspectList(mapToEntries(map), options, inspectMapEntry)} }`;
+}
+const isNaN = Number.isNaN || ((i)=>i !== i); // eslint-disable-line no-self-compare
+function inspectNumber(number, options) {
+    if (isNaN(number)) {
+        return options.stylize('NaN', 'number');
+    }
+    if (number === Infinity) {
+        return options.stylize('Infinity', 'number');
+    }
+    if (number === -Infinity) {
+        return options.stylize('-Infinity', 'number');
+    }
+    if (number === 0) {
+        return options.stylize(1 / number === Infinity ? '+0' : '-0', 'number');
+    }
+    return options.stylize(truncate(String(number), options.truncate), 'number');
+}
+function inspectBigInt(number, options) {
+    let nums = truncate(number.toString(), options.truncate - 1);
+    if (nums !== truncator) nums += 'n';
+    return options.stylize(nums, 'bigint');
+}
+function inspectRegExp(value, options) {
+    const flags = value.toString().split('/')[2];
+    const sourceLength = options.truncate - (2 + flags.length);
+    const source = value.source;
+    return options.stylize(`/${truncate(source, sourceLength)}/${flags}`, 'regexp');
+}
+// IE11 doesn't support `Array.from(set)`
+function arrayFromSet(set) {
+    const values = [];
+    set.forEach((value)=>{
+        values.push(value);
+    });
+    return values;
+}
+function inspectSet(set, options) {
+    if (set.size === 0) return 'Set{}';
+    options.truncate -= 7;
+    return `Set{ ${inspectList(arrayFromSet(set), options)} }`;
+}
+const stringEscapeChars = new RegExp("['\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5" + '\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]', 'g');
+const escapeCharacters = {
+    '\b': '\\b',
+    '\t': '\\t',
+    '\n': '\\n',
+    '\f': '\\f',
+    '\r': '\\r',
+    "'": "\\'",
+    '\\': '\\\\'
+};
+const hex = 16;
+function escape(char) {
+    return escapeCharacters[char] || `\\u${`0000${char.charCodeAt(0).toString(hex)}`.slice(-4)}`;
+}
+function inspectString(string, options) {
+    if (stringEscapeChars.test(string)) {
+        string = string.replace(stringEscapeChars, escape);
+    }
+    return options.stylize(`'${truncate(string, options.truncate - 2)}'`, 'string');
+}
+function inspectSymbol(value) {
+    if ('description' in Symbol.prototype) {
+        return value.description ? `Symbol(${value.description})` : 'Symbol()';
+    }
+    return value.toString();
+}
+const getPromiseValue = ()=>'Promise{…}';
+function inspectObject$1(object, options) {
+    const properties = Object.getOwnPropertyNames(object);
+    const symbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(object) : [];
+    if (properties.length === 0 && symbols.length === 0) {
+        return '{}';
+    }
+    options.truncate -= 4;
+    options.seen = options.seen || [];
+    if (options.seen.includes(object)) {
+        return '[Circular]';
+    }
+    options.seen.push(object);
+    const propertyContents = inspectList(properties.map((key)=>[
+            key,
+            object[key]
+        ]), options, inspectProperty);
+    const symbolContents = inspectList(symbols.map((key)=>[
+            key,
+            object[key]
+        ]), options, inspectProperty);
+    options.seen.pop();
+    let sep = '';
+    if (propertyContents && symbolContents) {
+        sep = ', ';
+    }
+    return `{ ${propertyContents}${sep}${symbolContents} }`;
+}
+const toStringTag = typeof Symbol !== 'undefined' && Symbol.toStringTag ? Symbol.toStringTag : false;
+function inspectClass(value, options) {
+    let name = '';
+    if (toStringTag && toStringTag in value) {
+        name = value[toStringTag];
+    }
+    name = name || value.constructor.name;
+    // Babel transforms anonymous classes to the name `_class`
+    if (!name || name === '_class') {
+        name = '<Anonymous Class>';
+    }
+    options.truncate -= name.length;
+    return `${name}${inspectObject$1(value, options)}`;
+}
+function inspectArguments(args, options) {
+    if (args.length === 0) return 'Arguments[]';
+    options.truncate -= 13;
+    return `Arguments[ ${inspectList(args, options)} ]`;
+}
+const errorKeys = [
+    'stack',
+    'line',
+    'column',
+    'name',
+    'message',
+    'fileName',
+    'lineNumber',
+    'columnNumber',
+    'number',
+    'description',
+    'cause'
+];
+function inspectObject(error, options) {
+    const properties = Object.getOwnPropertyNames(error).filter((key)=>errorKeys.indexOf(key) === -1);
+    const name = error.name;
+    options.truncate -= name.length;
+    let message = '';
+    if (typeof error.message === 'string') {
+        message = truncate(error.message, options.truncate);
+    } else {
+        properties.unshift('message');
+    }
+    message = message ? `: ${message}` : '';
+    options.truncate -= message.length + 5;
+    options.seen = options.seen || [];
+    if (options.seen.includes(error)) {
+        return '[Circular]';
+    }
+    options.seen.push(error);
+    const propertyContents = inspectList(properties.map((key)=>[
+            key,
+            error[key]
+        ]), options, inspectProperty);
+    return `${name}${message}${propertyContents ? ` { ${propertyContents} }` : ''}`;
+}
+function inspectAttribute([key, value], options) {
+    options.truncate -= 3;
+    if (!value) {
+        return `${options.stylize(String(key), 'yellow')}`;
+    }
+    return `${options.stylize(String(key), 'yellow')}=${options.stylize(`"${value}"`, 'string')}`;
+}
+function inspectNodeCollection(collection, options) {
+    return inspectList(collection, options, inspectNode, '\n');
+}
+function inspectNode(node, options) {
+    switch(node.nodeType){
+        case 1:
+            return inspectHTML(node, options);
+        case 3:
+            return options.inspect(node.data, options);
+        default:
+            return options.inspect(node, options);
+    }
+}
+// @ts-ignore (Deno doesn't have Element)
+function inspectHTML(element, options) {
+    const properties = element.getAttributeNames();
+    const name = element.tagName.toLowerCase();
+    const head = options.stylize(`<${name}`, 'special');
+    const headClose = options.stylize(`>`, 'special');
+    const tail = options.stylize(`</${name}>`, 'special');
+    options.truncate -= name.length * 2 + 5;
+    let propertyContents = '';
+    if (properties.length > 0) {
+        propertyContents += ' ';
+        propertyContents += inspectList(properties.map((key)=>[
+                key,
+                element.getAttribute(key)
+            ]), options, inspectAttribute, ' ');
+    }
+    options.truncate -= propertyContents.length;
+    const truncate = options.truncate;
+    let children = inspectNodeCollection(element.children, options);
+    if (children && children.length > truncate) {
+        children = `${truncator}(${element.children.length})`;
+    }
+    return `${head}${propertyContents}${headClose}${children}${tail}`;
+}
+/* !
+ * loupe
+ * Copyright(c) 2013 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */ const symbolsSupported = typeof Symbol === 'function' && typeof Symbol.for === 'function';
+const chaiInspect = symbolsSupported ? Symbol.for('chai/inspect') : '@@chai/inspect';
+const nodeInspect = Symbol.for('nodejs.util.inspect.custom');
+const constructorMap = new WeakMap();
+const stringTagMap = {};
+const baseTypesMap = {
+    undefined: (value, options)=>options.stylize('undefined', 'undefined'),
+    null: (value, options)=>options.stylize('null', 'null'),
+    boolean: (value, options)=>options.stylize(String(value), 'boolean'),
+    Boolean: (value, options)=>options.stylize(String(value), 'boolean'),
+    number: inspectNumber,
+    Number: inspectNumber,
+    bigint: inspectBigInt,
+    BigInt: inspectBigInt,
+    string: inspectString,
+    String: inspectString,
+    function: inspectFunction,
+    Function: inspectFunction,
+    symbol: inspectSymbol,
+    // A Symbol polyfill will return `Symbol` not `symbol` from typedetect
+    Symbol: inspectSymbol,
+    Array: inspectArray,
+    Date: inspectDate,
+    Map: inspectMap,
+    Set: inspectSet,
+    RegExp: inspectRegExp,
+    Promise: getPromiseValue,
+    // WeakSet, WeakMap are totally opaque to us
+    WeakSet: (value, options)=>options.stylize('WeakSet{…}', 'special'),
+    WeakMap: (value, options)=>options.stylize('WeakMap{…}', 'special'),
+    Arguments: inspectArguments,
+    Int8Array: inspectTypedArray,
+    Uint8Array: inspectTypedArray,
+    Uint8ClampedArray: inspectTypedArray,
+    Int16Array: inspectTypedArray,
+    Uint16Array: inspectTypedArray,
+    Int32Array: inspectTypedArray,
+    Uint32Array: inspectTypedArray,
+    Float32Array: inspectTypedArray,
+    Float64Array: inspectTypedArray,
+    Generator: ()=>'',
+    DataView: ()=>'',
+    ArrayBuffer: ()=>'',
+    Error: inspectObject,
+    HTMLCollection: inspectNodeCollection,
+    NodeList: inspectNodeCollection
+};
+// eslint-disable-next-line complexity
+const inspectCustom = (value, options, type, inspectFn)=>{
+    if (chaiInspect in value && typeof value[chaiInspect] === 'function') {
+        return value[chaiInspect](options);
+    }
+    if (nodeInspect in value && typeof value[nodeInspect] === 'function') {
+        return value[nodeInspect](options.depth, options, inspectFn);
+    }
+    if ('inspect' in value && typeof value.inspect === 'function') {
+        return value.inspect(options.depth, options);
+    }
+    if ('constructor' in value && constructorMap.has(value.constructor)) {
+        return constructorMap.get(value.constructor)(value, options);
+    }
+    if (stringTagMap[type]) {
+        return stringTagMap[type](value, options);
+    }
+    return '';
+};
+const toString = Object.prototype.toString;
+// eslint-disable-next-line complexity
+function inspect$1(value, opts = {}) {
+    const options = normaliseOptions(opts, inspect$1);
+    const { customInspect } = options;
+    let type = value === null ? 'null' : typeof value;
+    if (type === 'object') {
+        type = toString.call(value).slice(8, -1);
+    }
+    // If it is a base value that we already support, then use Loupe's inspector
+    if (type in baseTypesMap) {
+        return baseTypesMap[type](value, options);
+    }
+    // If `options.customInspect` is set to true then try to use the custom inspector
+    if (customInspect && value) {
+        const output = inspectCustom(value, options, type, inspect$1);
+        if (output) {
+            if (typeof output === 'string') return output;
+            return inspect$1(output, options);
+        }
+    }
+    const proto = value ? Object.getPrototypeOf(value) : false;
+    // If it's a plain Object then use Loupe's inspector
+    if (proto === Object.prototype || proto === null) {
+        return inspectObject$1(value, options);
+    }
+    // Specifically account for HTMLElements
+    // @ts-ignore
+    if (value && typeof HTMLElement === 'function' && value instanceof HTMLElement) {
+        return inspectHTML(value, options);
+    }
+    if ('constructor' in value) {
+        // If it is a class, inspect it like an object but add the constructor name
+        if (value.constructor !== Object) {
+            return inspectClass(value, options);
+        }
+        // If it is an object with an anonymous prototype, display it as an object.
+        return inspectObject$1(value, options);
+    }
+    // last chance to check if it's an object
+    if (value === Object(value)) {
+        return inspectObject$1(value, options);
+    }
+    // We have run out of options! Just stringify the value
+    return options.stylize(String(value), type);
+}
+const { AsymmetricMatcher, DOMCollection, DOMElement, Immutable, ReactElement, ReactTestComponent } = plugins;
+const PLUGINS = [
+    ReactTestComponent,
+    ReactElement,
+    DOMElement,
+    DOMCollection,
+    Immutable,
+    AsymmetricMatcher
+];
+function stringify(object, maxDepth = 10, { maxLength, ...options } = {}) {
+    const MAX_LENGTH = maxLength ?? 1e4;
+    let result;
+    try {
+        result = format$1(object, {
+            maxDepth,
+            escapeString: false,
+            plugins: PLUGINS,
+            ...options
+        });
+    } catch  {
+        result = format$1(object, {
+            callToJSON: false,
+            maxDepth,
+            escapeString: false,
+            plugins: PLUGINS,
+            ...options
+        });
+    }
+    // Prevents infinite loop https://github.com/vitest-dev/vitest/issues/7249
+    return result.length >= MAX_LENGTH && maxDepth > 1 ? stringify(object, Math.floor(Math.min(maxDepth, Number.MAX_SAFE_INTEGER) / 2), {
+        maxLength,
+        ...options
+    }) : result;
+}
+const formatRegExp = /%[sdjifoOc%]/g;
+function baseFormat(args, options = {}) {
+    const formatArg = (item, inspecOptions)=>{
+        if (options.prettifyObject) {
+            return stringify(item, undefined, {
+                printBasicPrototype: false,
+                escapeString: false
+            });
+        }
+        return inspect(item, inspecOptions);
+    };
+    if (typeof args[0] !== "string") {
+        const objects = [];
+        for(let i = 0; i < args.length; i++){
+            objects.push(formatArg(args[i], {
+                depth: 0,
+                colors: false
+            }));
+        }
+        return objects.join(" ");
+    }
+    const len = args.length;
+    let i = 1;
+    const template = args[0];
+    let str = String(template).replace(formatRegExp, (x)=>{
+        if (x === "%%") {
+            return "%";
+        }
+        if (i >= len) {
+            return x;
+        }
+        switch(x){
+            case "%s":
+                {
+                    const value = args[i++];
+                    if (typeof value === "bigint") {
+                        return `${value.toString()}n`;
+                    }
+                    if (typeof value === "number" && value === 0 && 1 / value < 0) {
+                        return "-0";
+                    }
+                    if (typeof value === "object" && value !== null) {
+                        if (typeof value.toString === "function" && value.toString !== Object.prototype.toString) {
+                            return value.toString();
+                        }
+                        return formatArg(value, {
+                            depth: 0,
+                            colors: false
+                        });
+                    }
+                    return String(value);
+                }
+            case "%d":
+                {
+                    const value = args[i++];
+                    if (typeof value === "bigint") {
+                        return `${value.toString()}n`;
+                    }
+                    return Number(value).toString();
+                }
+            case "%i":
+                {
+                    const value = args[i++];
+                    if (typeof value === "bigint") {
+                        return `${value.toString()}n`;
+                    }
+                    return Number.parseInt(String(value)).toString();
+                }
+            case "%f":
+                return Number.parseFloat(String(args[i++])).toString();
+            case "%o":
+                return formatArg(args[i++], {
+                    showHidden: true,
+                    showProxy: true
+                });
+            case "%O":
+                return formatArg(args[i++]);
+            case "%c":
+                {
+                    i++;
+                    return "";
+                }
+            case "%j":
+                try {
+                    return JSON.stringify(args[i++]);
+                } catch (err) {
+                    const m = err.message;
+                    if (m.includes("circular structure") || m.includes("cyclic structures") || m.includes("cyclic object")) {
+                        return "[Circular]";
+                    }
+                    throw err;
+                }
+            default:
+                return x;
+        }
+    });
+    for(let x = args[i]; i < len; x = args[++i]){
+        if (x === null || typeof x !== "object") {
+            str += ` ${x}`;
+        } else {
+            str += ` ${formatArg(x)}`;
+        }
+    }
+    return str;
+}
+function format(...args) {
+    return baseFormat(args);
+}
+function inspect(obj, options = {}) {
+    if (options.truncate === 0) {
+        options.truncate = Number.POSITIVE_INFINITY;
+    }
+    return inspect$1(obj, options);
+}
+function objDisplay(obj, options = {}) {
+    if (typeof options.truncate === "undefined") {
+        options.truncate = 40;
+    }
+    const str = inspect(obj, options);
+    const type = Object.prototype.toString.call(obj);
+    if (options.truncate && str.length >= options.truncate) {
+        if (type === "[object Function]") {
+            const fn = obj;
+            return !fn.name ? "[Function]" : `[Function: ${fn.name}]`;
+        } else if (type === "[object Array]") {
+            return `[ Array(${obj.length}) ]`;
+        } else if (type === "[object Object]") {
+            const keys = Object.keys(obj);
+            const kstr = keys.length > 2 ? `${keys.splice(0, 2).join(", ")}, ...` : keys.join(", ");
+            return `{ Object (${kstr}) }`;
+        } else {
+            return str;
+        }
+    }
+    return str;
+}
+
+function assertTypes(value, name, types) {
+    const receivedType = typeof value;
+    const pass = types.includes(receivedType);
+    if (!pass) {
+        throw new TypeError(`${name} value must be ${types.join(" or ")}, received "${receivedType}"`);
+    }
+}
+function toArray(array) {
+    if (array === null || array === undefined) {
+        array = [];
+    }
+    if (Array.isArray(array)) {
+        return array;
+    }
+    return [
+        array
+    ];
+}
+function isObject(item) {
+    return item != null && typeof item === "object" && !Array.isArray(item);
+}
+function objectAttr(source, path, defaultValue = undefined) {
+    // a[3].b -> a.3.b
+    const paths = path.replace(/\[(\d+)\]/g, ".$1").split(".");
+    let result = source;
+    for (const p of paths){
+        result = new Object(result)[p];
+        if (result === undefined) {
+            return defaultValue;
+        }
+    }
+    return result;
+}
+function createDefer() {
+    let resolve = null;
+    let reject = null;
+    const p = new Promise((_resolve, _reject)=>{
+        resolve = _resolve;
+        reject = _reject;
+    });
+    p.resolve = resolve;
+    p.reject = reject;
+    return p;
+}
+function isNegativeNaN(val) {
+    if (!Number.isNaN(val)) {
+        return false;
+    }
+    const f64 = new Float64Array(1);
+    f64[0] = val;
+    const u32 = new Uint32Array(f64.buffer);
+    const isNegative = u32[1] >>> 31 === 1;
+    return isNegative;
+}
+
+const SAFE_TIMERS_SYMBOL = Symbol("vitest:SAFE_TIMERS");
+function getSafeTimers() {
+    const { setTimeout: safeSetTimeout, setInterval: safeSetInterval, clearInterval: safeClearInterval, clearTimeout: safeClearTimeout, setImmediate: safeSetImmediate, clearImmediate: safeClearImmediate, queueMicrotask: safeQueueMicrotask } = globalThis[SAFE_TIMERS_SYMBOL] || globalThis;
+    const { nextTick: safeNextTick } = globalThis[SAFE_TIMERS_SYMBOL] || globalThis.process || {};
+    return {
+        nextTick: safeNextTick,
+        setTimeout: safeSetTimeout,
+        setInterval: safeSetInterval,
+        clearInterval: safeClearInterval,
+        clearTimeout: safeClearTimeout,
+        setImmediate: safeSetImmediate,
+        clearImmediate: safeClearImmediate,
+        queueMicrotask: safeQueueMicrotask
+    };
+}
+
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+    if (!input) {
+        return input;
+    }
+    return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r)=>r.toUpperCase());
+}
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+function cwd() {
+    if (typeof process !== "undefined" && typeof process.cwd === "function") {
+        return process.cwd().replace(/\\/g, "/");
+    }
+    return "/";
+}
+const resolve = function(...arguments_) {
+    arguments_ = arguments_.map((argument)=>normalizeWindowsPath(argument));
+    let resolvedPath = "";
+    let resolvedAbsolute = false;
+    for(let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--){
+        const path = index >= 0 ? arguments_[index] : cwd();
+        if (!path || path.length === 0) {
+            continue;
+        }
+        resolvedPath = `${path}/${resolvedPath}`;
+        resolvedAbsolute = isAbsolute(path);
+    }
+    resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+    if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+        return `/${resolvedPath}`;
+    }
+    return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+    let res = "";
+    let lastSegmentLength = 0;
+    let lastSlash = -1;
+    let dots = 0;
+    let char = null;
+    for(let index = 0; index <= path.length; ++index){
+        if (index < path.length) {
+            char = path[index];
+        } else if (char === "/") {
+            break;
+        } else {
+            char = "/";
+        }
+        if (char === "/") {
+            if (lastSlash === index - 1 || dots === 1) ;
+            else if (dots === 2) {
+                if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+                    if (res.length > 2) {
+                        const lastSlashIndex = res.lastIndexOf("/");
+                        if (lastSlashIndex === -1) {
+                            res = "";
+                            lastSegmentLength = 0;
+                        } else {
+                            res = res.slice(0, lastSlashIndex);
+                            lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+                        }
+                        lastSlash = index;
+                        dots = 0;
+                        continue;
+                    } else if (res.length > 0) {
+                        res = "";
+                        lastSegmentLength = 0;
+                        lastSlash = index;
+                        dots = 0;
+                        continue;
+                    }
+                }
+                if (allowAboveRoot) {
+                    res += res.length > 0 ? "/.." : "..";
+                    lastSegmentLength = 2;
+                }
+            } else {
+                if (res.length > 0) {
+                    res += `/${path.slice(lastSlash + 1, index)}`;
+                } else {
+                    res = path.slice(lastSlash + 1, index);
+                }
+                lastSegmentLength = index - lastSlash - 1;
+            }
+            lastSlash = index;
+            dots = 0;
+        } else if (char === "." && dots !== -1) {
+            ++dots;
+        } else {
+            dots = -1;
+        }
+    }
+    return res;
+}
+const isAbsolute = function(p) {
+    return _IS_ABSOLUTE_RE.test(p);
+};
+
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for(let i = 0; i < chars.length; i++){
+    const c = chars.charCodeAt(i);
+    intToChar[i] = c;
+    charToInt[c] = i;
+}
+const CHROME_IE_STACK_REGEXP = /^\s*at .*(?:\S:\d+|\(native\))/m;
+const SAFARI_NATIVE_CODE_REGEXP = /^(?:eval@)?(?:\[native code\])?$/;
+function extractLocation(urlLike) {
+    // Fail-fast but return locations like "(native)"
+    if (!urlLike.includes(":")) {
+        return [
+            urlLike
+        ];
+    }
+    const regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/;
+    const parts = regExp.exec(urlLike.replace(/^\(|\)$/g, ""));
+    if (!parts) {
+        return [
+            urlLike
+        ];
+    }
+    let url = parts[1];
+    if (url.startsWith("async ")) {
+        url = url.slice(6);
+    }
+    if (url.startsWith("http:") || url.startsWith("https:")) {
+        const urlObj = new URL(url);
+        urlObj.searchParams.delete("import");
+        urlObj.searchParams.delete("browserv");
+        url = urlObj.pathname + urlObj.hash + urlObj.search;
+    }
+    if (url.startsWith("/@fs/")) {
+        const isWindows = /^\/@fs\/[a-zA-Z]:\//.test(url);
+        url = url.slice(isWindows ? 5 : 4);
+    }
+    return [
+        url,
+        parts[2] || undefined,
+        parts[3] || undefined
+    ];
+}
+function parseSingleFFOrSafariStack(raw) {
+    let line = raw.trim();
+    if (SAFARI_NATIVE_CODE_REGEXP.test(line)) {
+        return null;
+    }
+    if (line.includes(" > eval")) {
+        line = line.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, ":$1");
+    }
+    // Early return for lines that don't look like Firefox/Safari stack traces
+    // Firefox/Safari stack traces must contain '@' and should have location info after it
+    if (!line.includes("@")) {
+        return null;
+    }
+    // Find the correct @ that separates function name from location
+    // For cases like '@https://@fs/path' or 'functionName@https://@fs/path'
+    // we need to find the first @ that precedes a valid location (containing :)
+    let atIndex = -1;
+    let locationPart = "";
+    let functionName;
+    // Try each @ from left to right to find the one that gives us a valid location
+    for(let i = 0; i < line.length; i++){
+        if (line[i] === "@") {
+            const candidateLocation = line.slice(i + 1);
+            // Minimum length 3 for valid location: 1 for filename + 1 for colon + 1 for line number (e.g., "a:1")
+            if (candidateLocation.includes(":") && candidateLocation.length >= 3) {
+                atIndex = i;
+                locationPart = candidateLocation;
+                functionName = i > 0 ? line.slice(0, i) : undefined;
+                break;
+            }
+        }
+    }
+    // Validate we found a valid location with minimum length (filename:line format)
+    if (atIndex === -1 || !locationPart.includes(":") || locationPart.length < 3) {
+        return null;
+    }
+    const [url, lineNumber, columnNumber] = extractLocation(locationPart);
+    if (!url || !lineNumber || !columnNumber) {
+        return null;
+    }
+    return {
+        file: url,
+        method: functionName || "",
+        line: Number.parseInt(lineNumber),
+        column: Number.parseInt(columnNumber)
+    };
+}
+function parseSingleStack(raw) {
+    const line = raw.trim();
+    if (!CHROME_IE_STACK_REGEXP.test(line)) {
+        return parseSingleFFOrSafariStack(line);
+    }
+    return parseSingleV8Stack(line);
+}
+// Based on https://github.com/stacktracejs/error-stack-parser
+// Credit to stacktracejs
+function parseSingleV8Stack(raw) {
+    let line = raw.trim();
+    if (!CHROME_IE_STACK_REGEXP.test(line)) {
+        return null;
+    }
+    if (line.includes("(eval ")) {
+        line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, "");
+    }
+    let sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, "");
+    // capture and preserve the parenthesized location "(/foo/my bar.js:12:87)" in
+    // case it has spaces in it, as the string is split on \s+ later on
+    const location = sanitizedLine.match(/ (\(.+\)$)/);
+    // remove the parenthesized location from the line, if it was matched
+    sanitizedLine = location ? sanitizedLine.replace(location[0], "") : sanitizedLine;
+    // if a location was matched, pass it to extractLocation() otherwise pass all sanitizedLine
+    // because this line doesn't have function name
+    const [url, lineNumber, columnNumber] = extractLocation(location ? location[1] : sanitizedLine);
+    let method = location && sanitizedLine || "";
+    let file = url && [
+        "eval",
+        "<anonymous>"
+    ].includes(url) ? undefined : url;
+    if (!file || !lineNumber || !columnNumber) {
+        return null;
+    }
+    if (method.startsWith("async ")) {
+        method = method.slice(6);
+    }
+    if (file.startsWith("file://")) {
+        file = file.slice(7);
+    }
+    // normalize Windows path (\ -> /)
+    file = file.startsWith("node:") || file.startsWith("internal:") ? file : resolve(file);
+    if (method) {
+        method = method.replace(/__vite_ssr_import_\d+__\./g, "").replace(/(Object\.)?__vite_ssr_export_default__\s?/g, "");
+    }
+    return {
+        method,
+        file,
+        line: Number.parseInt(lineNumber),
+        column: Number.parseInt(columnNumber)
+    };
+}
+
+function createChainable(keys, fn) {
+    function create(context) {
+        const chain = function(...args) {
+            return fn.apply(context, args);
+        };
+        Object.assign(chain, fn);
+        chain.withContext = ()=>chain.bind(context);
+        chain.setContext = (key, value)=>{
+            context[key] = value;
+        };
+        chain.mergeContext = (ctx)=>{
+            Object.assign(context, ctx);
+        };
+        for (const key of keys){
+            Object.defineProperty(chain, key, {
+                get () {
+                    return create({
+                        ...context,
+                        [key]: true
+                    });
+                }
+            });
+        }
+        return chain;
+    }
+    const chain = create({});
+    chain.fn = fn;
+    return chain;
+}
+function findTestFileStackTrace(testFilePath, error) {
+    // first line is the error message
+    const lines = error.split("\n").slice(1);
+    for (const line of lines){
+        const stack = parseSingleStack(line);
+        if (stack && stack.file === testFilePath) {
+            return stack;
+        }
+    }
+}
+function createTaskName(names, separator = " > ") {
+    return names.filter((name)=>name !== undefined).join(separator);
+}
+
+class PendingError extends Error {
+    constructor(message, task, note){
+        super(message), this.code = "VITEST_PENDING";
+        this.message = message;
+        this.note = note;
+        this.taskId = task.id;
+    }
+}
+// use WeakMap here to make the Test and Suite object serializable
+const fnMap = new WeakMap();
+const testFixtureMap = new WeakMap();
+const hooksMap = new WeakMap();
+function setFn(key, fn) {
+    fnMap.set(key, fn);
+}
+function setTestFixture(key, fixture) {
+    testFixtureMap.set(key, fixture);
+}
+function getTestFixture(key) {
+    return testFixtureMap.get(key);
+}
+function setHooks(key, hooks) {
+    hooksMap.set(key, hooks);
+}
+function getHooks(key) {
+    return hooksMap.get(key);
+}
+function mergeScopedFixtures(testFixtures, scopedFixtures) {
+    const scopedFixturesMap = scopedFixtures.reduce((map, fixture)=>{
+        map[fixture.prop] = fixture;
+        return map;
+    }, {});
+    const newFixtures = {};
+    testFixtures.forEach((fixture)=>{
+        const useFixture = scopedFixturesMap[fixture.prop] || {
+            ...fixture
+        };
+        newFixtures[useFixture.prop] = useFixture;
+    });
+    for(const fixtureKep in newFixtures){
+        var _fixture$deps;
+        const fixture = newFixtures[fixtureKep];
+        // if the fixture was define before the scope, then its dep
+        // will reference the original fixture instead of the scope
+        fixture.deps = (_fixture$deps = fixture.deps) === null || _fixture$deps === void 0 ? void 0 : _fixture$deps.map((dep)=>newFixtures[dep.prop]);
+    }
+    return Object.values(newFixtures);
+}
+function mergeContextFixtures(fixtures, context, runner) {
+    const fixtureOptionKeys = [
+        "auto",
+        "injected",
+        "scope"
+    ];
+    const fixtureArray = Object.entries(fixtures).map(([prop, value])=>{
+        const fixtureItem = {
+            value
+        };
+        if (Array.isArray(value) && value.length >= 2 && isObject(value[1]) && Object.keys(value[1]).some((key)=>fixtureOptionKeys.includes(key))) {
+            var _runner$injectValue;
+            // fixture with options
+            Object.assign(fixtureItem, value[1]);
+            const userValue = value[0];
+            fixtureItem.value = fixtureItem.injected ? ((_runner$injectValue = runner.injectValue) === null || _runner$injectValue === void 0 ? void 0 : _runner$injectValue.call(runner, prop)) ?? userValue : userValue;
+        }
+        fixtureItem.scope = fixtureItem.scope || "test";
+        if (fixtureItem.scope === "worker" && !runner.getWorkerContext) {
+            fixtureItem.scope = "file";
+        }
+        fixtureItem.prop = prop;
+        fixtureItem.isFn = typeof fixtureItem.value === "function";
+        return fixtureItem;
+    });
+    if (Array.isArray(context.fixtures)) {
+        context.fixtures = context.fixtures.concat(fixtureArray);
+    } else {
+        context.fixtures = fixtureArray;
+    }
+    // Update dependencies of fixture functions
+    fixtureArray.forEach((fixture)=>{
+        if (fixture.isFn) {
+            const usedProps = getUsedProps(fixture.value);
+            if (usedProps.length) {
+                fixture.deps = context.fixtures.filter(({ prop })=>prop !== fixture.prop && usedProps.includes(prop));
+            }
+            // test can access anything, so we ignore it
+            if (fixture.scope !== "test") {
+                var _fixture$deps2;
+                (_fixture$deps2 = fixture.deps) === null || _fixture$deps2 === void 0 ? void 0 : _fixture$deps2.forEach((dep)=>{
+                    if (!dep.isFn) {
+                        // non fn fixtures are always resolved and available to anyone
+                        return;
+                    }
+                    // worker scope can only import from worker scope
+                    if (fixture.scope === "worker" && dep.scope === "worker") {
+                        return;
+                    }
+                    // file scope an import from file and worker scopes
+                    if (fixture.scope === "file" && dep.scope !== "test") {
+                        return;
+                    }
+                    throw new SyntaxError(`cannot use the ${dep.scope} fixture "${dep.prop}" inside the ${fixture.scope} fixture "${fixture.prop}"`);
+                });
+            }
+        }
+    });
+    return context;
+}
+const fixtureValueMaps = new Map();
+const cleanupFnArrayMap = new Map();
+function withFixtures(runner, fn, testContext) {
+    return (hookContext)=>{
+        const context = hookContext || testContext;
+        if (!context) {
+            return fn({});
+        }
+        const fixtures = getTestFixture(context);
+        if (!(fixtures === null || fixtures === void 0 ? void 0 : fixtures.length)) {
+            return fn(context);
+        }
+        const usedProps = getUsedProps(fn);
+        const hasAutoFixture = fixtures.some(({ auto })=>auto);
+        if (!usedProps.length && !hasAutoFixture) {
+            return fn(context);
+        }
+        if (!fixtureValueMaps.get(context)) {
+            fixtureValueMaps.set(context, new Map());
+        }
+        const fixtureValueMap = fixtureValueMaps.get(context);
+        if (!cleanupFnArrayMap.has(context)) {
+            cleanupFnArrayMap.set(context, []);
+        }
+        const cleanupFnArray = cleanupFnArrayMap.get(context);
+        const usedFixtures = fixtures.filter(({ prop, auto })=>auto || usedProps.includes(prop));
+        const pendingFixtures = resolveDeps(usedFixtures);
+        if (!pendingFixtures.length) {
+            return fn(context);
+        }
+        async function resolveFixtures() {
+            for (const fixture of pendingFixtures){
+                // fixture could be already initialized during "before" hook
+                if (fixtureValueMap.has(fixture)) {
+                    continue;
+                }
+                const resolvedValue = await resolveFixtureValue(runner, fixture, context, cleanupFnArray);
+                context[fixture.prop] = resolvedValue;
+                fixtureValueMap.set(fixture, resolvedValue);
+                if (fixture.scope === "test") {
+                    cleanupFnArray.unshift(()=>{
+                        fixtureValueMap.delete(fixture);
+                    });
+                }
+            }
+        }
+        return resolveFixtures().then(()=>fn(context));
+    };
+}
+const globalFixturePromise = new WeakMap();
+function resolveFixtureValue(runner, fixture, context, cleanupFnArray) {
+    var _runner$getWorkerCont;
+    const fileContext = getFileContext(context.task.file);
+    const workerContext = (_runner$getWorkerCont = runner.getWorkerContext) === null || _runner$getWorkerCont === void 0 ? void 0 : _runner$getWorkerCont.call(runner);
+    if (!fixture.isFn) {
+        var _fixture$prop;
+        fileContext[_fixture$prop = fixture.prop] ?? (fileContext[_fixture$prop] = fixture.value);
+        if (workerContext) {
+            var _fixture$prop2;
+            workerContext[_fixture$prop2 = fixture.prop] ?? (workerContext[_fixture$prop2] = fixture.value);
+        }
+        return fixture.value;
+    }
+    if (fixture.scope === "test") {
+        return resolveFixtureFunction(fixture.value, context, cleanupFnArray);
+    }
+    // in case the test runs in parallel
+    if (globalFixturePromise.has(fixture)) {
+        return globalFixturePromise.get(fixture);
+    }
+    let fixtureContext;
+    if (fixture.scope === "worker") {
+        if (!workerContext) {
+            throw new TypeError("[@vitest/runner] The worker context is not available in the current test runner. Please, provide the `getWorkerContext` method when initiating the runner.");
+        }
+        fixtureContext = workerContext;
+    } else {
+        fixtureContext = fileContext;
+    }
+    if (fixture.prop in fixtureContext) {
+        return fixtureContext[fixture.prop];
+    }
+    if (!cleanupFnArrayMap.has(fixtureContext)) {
+        cleanupFnArrayMap.set(fixtureContext, []);
+    }
+    const cleanupFnFileArray = cleanupFnArrayMap.get(fixtureContext);
+    const promise = resolveFixtureFunction(fixture.value, fixtureContext, cleanupFnFileArray).then((value)=>{
+        fixtureContext[fixture.prop] = value;
+        globalFixturePromise.delete(fixture);
+        return value;
+    });
+    globalFixturePromise.set(fixture, promise);
+    return promise;
+}
+async function resolveFixtureFunction(fixtureFn, context, cleanupFnArray) {
+    // wait for `use` call to extract fixture value
+    const useFnArgPromise = createDefer();
+    let isUseFnArgResolved = false;
+    const fixtureReturn = fixtureFn(context, async (useFnArg)=>{
+        // extract `use` argument
+        isUseFnArgResolved = true;
+        useFnArgPromise.resolve(useFnArg);
+        // suspend fixture teardown by holding off `useReturnPromise` resolution until cleanup
+        const useReturnPromise = createDefer();
+        cleanupFnArray.push(async ()=>{
+            // start teardown by resolving `use` Promise
+            useReturnPromise.resolve();
+            // wait for finishing teardown
+            await fixtureReturn;
+        });
+        await useReturnPromise;
+    }).catch((e)=>{
+        // treat fixture setup error as test failure
+        if (!isUseFnArgResolved) {
+            useFnArgPromise.reject(e);
+            return;
+        }
+        // otherwise re-throw to avoid silencing error during cleanup
+        throw e;
+    });
+    return useFnArgPromise;
+}
+function resolveDeps(fixtures, depSet = new Set(), pendingFixtures = []) {
+    fixtures.forEach((fixture)=>{
+        if (pendingFixtures.includes(fixture)) {
+            return;
+        }
+        if (!fixture.isFn || !fixture.deps) {
+            pendingFixtures.push(fixture);
+            return;
+        }
+        if (depSet.has(fixture)) {
+            throw new Error(`Circular fixture dependency detected: ${fixture.prop} <- ${[
+                ...depSet
+            ].reverse().map((d)=>d.prop).join(" <- ")}`);
+        }
+        depSet.add(fixture);
+        resolveDeps(fixture.deps, depSet, pendingFixtures);
+        pendingFixtures.push(fixture);
+        depSet.clear();
+    });
+    return pendingFixtures;
+}
+function getUsedProps(fn) {
+    let fnString = filterOutComments(fn.toString());
+    // match lowered async function and strip it off
+    // example code on esbuild-try https://esbuild.github.io/try/#YgAwLjI0LjAALS1zdXBwb3J0ZWQ6YXN5bmMtYXdhaXQ9ZmFsc2UAZQBlbnRyeS50cwBjb25zdCBvID0gewogIGYxOiBhc3luYyAoKSA9PiB7fSwKICBmMjogYXN5bmMgKGEpID0+IHt9LAogIGYzOiBhc3luYyAoYSwgYikgPT4ge30sCiAgZjQ6IGFzeW5jIGZ1bmN0aW9uKGEpIHt9LAogIGY1OiBhc3luYyBmdW5jdGlvbiBmZihhKSB7fSwKICBhc3luYyBmNihhKSB7fSwKCiAgZzE6IGFzeW5jICgpID0+IHt9LAogIGcyOiBhc3luYyAoeyBhIH0pID0+IHt9LAogIGczOiBhc3luYyAoeyBhIH0sIGIpID0+IHt9LAogIGc0OiBhc3luYyBmdW5jdGlvbiAoeyBhIH0pIHt9LAogIGc1OiBhc3luYyBmdW5jdGlvbiBnZyh7IGEgfSkge30sCiAgYXN5bmMgZzYoeyBhIH0pIHt9LAoKICBoMTogYXN5bmMgKCkgPT4ge30sCiAgLy8gY29tbWVudCBiZXR3ZWVuCiAgaDI6IGFzeW5jIChhKSA9PiB7fSwKfQ
+    //   __async(this, null, function*
+    //   __async(this, arguments, function*
+    //   __async(this, [_0, _1], function*
+    if (/__async\((?:this|null), (?:null|arguments|\[[_0-9, ]*\]), function\*/.test(fnString)) {
+        fnString = fnString.split(/__async\((?:this|null),/)[1];
+    }
+    const match = fnString.match(/[^(]*\(([^)]*)/);
+    if (!match) {
+        return [];
+    }
+    const args = splitByComma(match[1]);
+    if (!args.length) {
+        return [];
+    }
+    let first = args[0];
+    if ("__VITEST_FIXTURE_INDEX__" in fn) {
+        first = args[fn.__VITEST_FIXTURE_INDEX__];
+        if (!first) {
+            return [];
+        }
+    }
+    if (!(first[0] === "{" && first.endsWith("}"))) {
+        throw new Error(`The first argument inside a fixture must use object destructuring pattern, e.g. ({ test } => {}). Instead, received "${first}".`);
+    }
+    const _first = first.slice(1, -1).replace(/\s/g, "");
+    const props = splitByComma(_first).map((prop)=>{
+        return prop.replace(/:.*|=.*/g, "");
+    });
+    const last = props.at(-1);
+    if (last && last.startsWith("...")) {
+        throw new Error(`Rest parameters are not supported in fixtures, received "${last}".`);
+    }
+    return props;
+}
+function filterOutComments(s) {
+    const result = [];
+    let commentState = "none";
+    for(let i = 0; i < s.length; ++i){
+        if (commentState === "singleline") {
+            if (s[i] === "\n") {
+                commentState = "none";
+            }
+        } else if (commentState === "multiline") {
+            if (s[i - 1] === "*" && s[i] === "/") {
+                commentState = "none";
+            }
+        } else if (commentState === "none") {
+            if (s[i] === "/" && s[i + 1] === "/") {
+                commentState = "singleline";
+            } else if (s[i] === "/" && s[i + 1] === "*") {
+                commentState = "multiline";
+                i += 2;
+            } else {
+                result.push(s[i]);
+            }
+        }
+    }
+    return result.join("");
+}
+function splitByComma(s) {
+    const result = [];
+    const stack = [];
+    let start = 0;
+    for(let i = 0; i < s.length; i++){
+        if (s[i] === "{" || s[i] === "[") {
+            stack.push(s[i] === "{" ? "}" : "]");
+        } else if (s[i] === stack.at(-1)) {
+            stack.pop();
+        } else if (!stack.length && s[i] === ",") {
+            const token = s.substring(start, i).trim();
+            if (token) {
+                result.push(token);
+            }
+            start = i + 1;
+        }
+    }
+    const lastToken = s.substring(start).trim();
+    if (lastToken) {
+        result.push(lastToken);
+    }
+    return result;
+}
+function getDefaultHookTimeout() {
+    return getRunner().config.hookTimeout;
+}
+const CLEANUP_TIMEOUT_KEY = Symbol.for("VITEST_CLEANUP_TIMEOUT");
+const CLEANUP_STACK_TRACE_KEY = Symbol.for("VITEST_CLEANUP_STACK_TRACE");
+/**
+* Registers a callback function to be executed once before all tests within the current suite.
+* This hook is useful for scenarios where you need to perform setup operations that are common to all tests in a suite, such as initializing a database connection or setting up a test environment.
+*
+* **Note:** The `beforeAll` hooks are executed in the order they are defined one after another. You can configure this by changing the `sequence.hooks` option in the config file.
+*
+* @param {Function} fn - The callback function to be executed before all tests.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using beforeAll to set up a database connection
+* beforeAll(async () => {
+*   await database.connect();
+* });
+* ```
+*/ function beforeAll(fn, timeout = getDefaultHookTimeout()) {
+    assertTypes(fn, "\"beforeAll\" callback", [
+        "function"
+    ]);
+    const stackTraceError = new Error("STACK_TRACE_ERROR");
+    return getCurrentSuite().on("beforeAll", Object.assign(withTimeout(fn, timeout, true, stackTraceError), {
+        [CLEANUP_TIMEOUT_KEY]: timeout,
+        [CLEANUP_STACK_TRACE_KEY]: stackTraceError
+    }));
+}
+/**
+* Registers a callback function to be executed once after all tests within the current suite have completed.
+* This hook is useful for scenarios where you need to perform cleanup operations after all tests in a suite have run, such as closing database connections or cleaning up temporary files.
+*
+* **Note:** The `afterAll` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+*
+* @param {Function} fn - The callback function to be executed after all tests.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using afterAll to close a database connection
+* afterAll(async () => {
+*   await database.disconnect();
+* });
+* ```
+*/ function afterAll(fn, timeout) {
+    assertTypes(fn, "\"afterAll\" callback", [
+        "function"
+    ]);
+    return getCurrentSuite().on("afterAll", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true, new Error("STACK_TRACE_ERROR")));
+}
+/**
+* Registers a callback function to be executed before each test within the current suite.
+* This hook is useful for scenarios where you need to reset or reinitialize the test environment before each test runs, such as resetting database states, clearing caches, or reinitializing variables.
+*
+* **Note:** The `beforeEach` hooks are executed in the order they are defined one after another. You can configure this by changing the `sequence.hooks` option in the config file.
+*
+* @param {Function} fn - The callback function to be executed before each test. This function receives an `TestContext` parameter if additional test context is needed.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using beforeEach to reset a database state
+* beforeEach(async () => {
+*   await database.reset();
+* });
+* ```
+*/ function beforeEach(fn, timeout = getDefaultHookTimeout()) {
+    assertTypes(fn, "\"beforeEach\" callback", [
+        "function"
+    ]);
+    const stackTraceError = new Error("STACK_TRACE_ERROR");
+    const runner = getRunner();
+    return getCurrentSuite().on("beforeEach", Object.assign(withTimeout(withFixtures(runner, fn), timeout ?? getDefaultHookTimeout(), true, stackTraceError, abortIfTimeout), {
+        [CLEANUP_TIMEOUT_KEY]: timeout,
+        [CLEANUP_STACK_TRACE_KEY]: stackTraceError
+    }));
+}
+/**
+* Registers a callback function to be executed after each test within the current suite has completed.
+* This hook is useful for scenarios where you need to clean up or reset the test environment after each test runs, such as deleting temporary files, clearing test-specific database entries, or resetting mocked functions.
+*
+* **Note:** The `afterEach` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+*
+* @param {Function} fn - The callback function to be executed after each test. This function receives an `TestContext` parameter if additional test context is needed.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using afterEach to delete temporary files created during a test
+* afterEach(async () => {
+*   await fileSystem.deleteTempFiles();
+* });
+* ```
+*/ function afterEach(fn, timeout) {
+    assertTypes(fn, "\"afterEach\" callback", [
+        "function"
+    ]);
+    const runner = getRunner();
+    return getCurrentSuite().on("afterEach", withTimeout(withFixtures(runner, fn), timeout ?? getDefaultHookTimeout(), true, new Error("STACK_TRACE_ERROR"), abortIfTimeout));
+}
+/**
+* Creates a suite of tests, allowing for grouping and hierarchical organization of tests.
+* Suites can contain both tests and other suites, enabling complex test structures.
+*
+* @param {string} name - The name of the suite, used for identification and reporting.
+* @param {Function} fn - A function that defines the tests and suites within this suite.
+* @example
+* ```ts
+* // Define a suite with two tests
+* suite('Math operations', () => {
+*   test('should add two numbers', () => {
+*     expect(add(1, 2)).toBe(3);
+*   });
+*
+*   test('should subtract two numbers', () => {
+*     expect(subtract(5, 2)).toBe(3);
+*   });
+* });
+* ```
+* @example
+* ```ts
+* // Define nested suites
+* suite('String operations', () => {
+*   suite('Trimming', () => {
+*     test('should trim whitespace from start and end', () => {
+*       expect('  hello  '.trim()).toBe('hello');
+*     });
+*   });
+*
+*   suite('Concatenation', () => {
+*     test('should concatenate two strings', () => {
+*       expect('hello' + ' ' + 'world').toBe('hello world');
+*     });
+*   });
+* });
+* ```
+*/ const suite = createSuite();
+/**
+* Defines a test case with a given name and test function. The test function can optionally be configured with test options.
+*
+* @param {string | Function} name - The name of the test or a function that will be used as a test name.
+* @param {TestOptions | TestFunction} [optionsOrFn] - Optional. The test options or the test function if no explicit name is provided.
+* @param {number | TestOptions | TestFunction} [optionsOrTest] - Optional. The test function or options, depending on the previous parameters.
+* @throws {Error} If called inside another test function.
+* @example
+* ```ts
+* // Define a simple test
+* test('should add two numbers', () => {
+*   expect(add(1, 2)).toBe(3);
+* });
+* ```
+* @example
+* ```ts
+* // Define a test with options
+* test('should subtract two numbers', { retry: 3 }, () => {
+*   expect(subtract(5, 2)).toBe(3);
+* });
+* ```
+*/ const test = createTest(function(name, optionsOrFn, optionsOrTest) {
+    getCurrentSuite().test.fn.call(this, formatName(name), optionsOrFn, optionsOrTest);
+});
+/**
+* Creates a suite of tests, allowing for grouping and hierarchical organization of tests.
+* Suites can contain both tests and other suites, enabling complex test structures.
+*
+* @param {string} name - The name of the suite, used for identification and reporting.
+* @param {Function} fn - A function that defines the tests and suites within this suite.
+* @example
+* ```ts
+* // Define a suite with two tests
+* describe('Math operations', () => {
+*   test('should add two numbers', () => {
+*     expect(add(1, 2)).toBe(3);
+*   });
+*
+*   test('should subtract two numbers', () => {
+*     expect(subtract(5, 2)).toBe(3);
+*   });
+* });
+* ```
+* @example
+* ```ts
+* // Define nested suites
+* describe('String operations', () => {
+*   describe('Trimming', () => {
+*     test('should trim whitespace from start and end', () => {
+*       expect('  hello  '.trim()).toBe('hello');
+*     });
+*   });
+*
+*   describe('Concatenation', () => {
+*     test('should concatenate two strings', () => {
+*       expect('hello' + ' ' + 'world').toBe('hello world');
+*     });
+*   });
+* });
+* ```
+*/ const describe = suite;
+/**
+* Defines a test case with a given name and test function. The test function can optionally be configured with test options.
+*
+* @param {string | Function} name - The name of the test or a function that will be used as a test name.
+* @param {TestOptions | TestFunction} [optionsOrFn] - Optional. The test options or the test function if no explicit name is provided.
+* @param {number | TestOptions | TestFunction} [optionsOrTest] - Optional. The test function or options, depending on the previous parameters.
+* @throws {Error} If called inside another test function.
+* @example
+* ```ts
+* // Define a simple test
+* it('adds two numbers', () => {
+*   expect(add(1, 2)).toBe(3);
+* });
+* ```
+* @example
+* ```ts
+* // Define a test with options
+* it('subtracts two numbers', { retry: 3 }, () => {
+*   expect(subtract(5, 2)).toBe(3);
+* });
+* ```
+*/ const it = test;
+let runner;
+let defaultSuite;
+let currentTestFilepath;
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(`Vitest failed to find ${message}. One of the following is possible:` + "\n- \"vitest\" is imported directly without running \"vitest\" command" + "\n- \"vitest\" is imported inside \"globalSetup\" (to fix this, use \"setupFiles\" instead, because \"globalSetup\" runs in a different context)" + "\n- \"vitest\" is imported inside Vite / Vitest config file" + "\n- Otherwise, it might be a Vitest bug. Please report it to https://github.com/vitest-dev/vitest/issues\n");
+    }
+}
+function getRunner() {
+    assert(runner, "the runner");
+    return runner;
+}
+function getCurrentSuite() {
+    const currentSuite = collectorContext.currentSuite || defaultSuite;
+    assert(currentSuite, "the current suite");
+    return currentSuite;
+}
+function createSuiteHooks() {
+    return {
+        beforeAll: [],
+        afterAll: [],
+        beforeEach: [],
+        afterEach: []
+    };
+}
+function parseArguments(optionsOrFn, timeoutOrTest) {
+    if (timeoutOrTest != null && typeof timeoutOrTest === "object") {
+        throw new TypeError(`Signature "test(name, fn, { ... })" was deprecated in Vitest 3 and removed in Vitest 4. Please, provide options as a second argument instead.`);
+    }
+    let options = {};
+    let fn;
+    // it('', () => {}, 1000)
+    if (typeof timeoutOrTest === "number") {
+        options = {
+            timeout: timeoutOrTest
+        };
+    } else if (typeof optionsOrFn === "object") {
+        options = optionsOrFn;
+    }
+    if (typeof optionsOrFn === "function") {
+        if (typeof timeoutOrTest === "function") {
+            throw new TypeError("Cannot use two functions as arguments. Please use the second argument for options.");
+        }
+        fn = optionsOrFn;
+    } else if (typeof timeoutOrTest === "function") {
+        fn = timeoutOrTest;
+    }
+    return {
+        options,
+        handler: fn
+    };
+}
+// implementations
+function createSuiteCollector(name, factory = ()=>{}, mode, each, suiteOptions, parentCollectorFixtures) {
+    const tasks = [];
+    let suite;
+    initSuite();
+    const task = function(name = "", options = {}) {
+        var _collectorContext$cur, _collectorContext$cur2, _collectorContext$cur3;
+        const timeout = (options === null || options === void 0 ? void 0 : options.timeout) ?? runner.config.testTimeout;
+        const currentSuite = (_collectorContext$cur = collectorContext.currentSuite) === null || _collectorContext$cur === void 0 ? void 0 : _collectorContext$cur.suite;
+        const task = {
+            id: "",
+            name,
+            fullName: createTaskName([
+                (currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fullName) ?? ((_collectorContext$cur2 = collectorContext.currentSuite) === null || _collectorContext$cur2 === void 0 || (_collectorContext$cur2 = _collectorContext$cur2.file) === null || _collectorContext$cur2 === void 0 ? void 0 : _collectorContext$cur2.fullName),
+                name
+            ]),
+            fullTestName: createTaskName([
+                currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fullTestName,
+                name
+            ]),
+            suite: currentSuite,
+            each: options.each,
+            fails: options.fails,
+            context: undefined,
+            type: "test",
+            file: (currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.file) ?? ((_collectorContext$cur3 = collectorContext.currentSuite) === null || _collectorContext$cur3 === void 0 ? void 0 : _collectorContext$cur3.file),
+            timeout,
+            retry: options.retry ?? runner.config.retry,
+            repeats: options.repeats,
+            mode: options.only ? "only" : options.skip ? "skip" : options.todo ? "todo" : "run",
+            meta: options.meta ?? Object.create(null),
+            annotations: [],
+            artifacts: []
+        };
+        const handler = options.handler;
+        if (task.mode === "run" && !handler) {
+            task.mode = "todo";
+        }
+        if (options.concurrent || !options.sequential && runner.config.sequence.concurrent) {
+            task.concurrent = true;
+        }
+        task.shuffle = suiteOptions === null || suiteOptions === void 0 ? void 0 : suiteOptions.shuffle;
+        const context = createTestContext(task, runner);
+        // create test context
+        Object.defineProperty(task, "context", {
+            value: context,
+            enumerable: false
+        });
+        setTestFixture(context, options.fixtures);
+        // custom can be called from any place, let's assume the limit is 15 stacks
+        const limit = Error.stackTraceLimit;
+        Error.stackTraceLimit = 15;
+        const stackTraceError = new Error("STACK_TRACE_ERROR");
+        Error.stackTraceLimit = limit;
+        if (handler) {
+            setFn(task, withTimeout(withAwaitAsyncAssertions(withFixtures(runner, handler, context), task), timeout, false, stackTraceError, (_, error)=>abortIfTimeout([
+                    context
+                ], error)));
+        }
+        if (runner.config.includeTaskLocation) {
+            const error = stackTraceError.stack;
+            const stack = findTestFileStackTrace(currentTestFilepath, error);
+            if (stack) {
+                task.location = {
+                    line: stack.line,
+                    column: stack.column
+                };
+            }
+        }
+        tasks.push(task);
+        return task;
+    };
+    const test = createTest(function(name, optionsOrFn, timeoutOrTest) {
+        let { options, handler } = parseArguments(optionsOrFn, timeoutOrTest);
+        // inherit repeats, retry, timeout from suite
+        if (typeof suiteOptions === "object") {
+            options = Object.assign({}, suiteOptions, options);
+        }
+        // inherit concurrent / sequential from suite
+        options.concurrent = this.concurrent || !this.sequential && (options === null || options === void 0 ? void 0 : options.concurrent);
+        options.sequential = this.sequential || !this.concurrent && (options === null || options === void 0 ? void 0 : options.sequential);
+        const test = task(formatName(name), {
+            ...this,
+            ...options,
+            handler
+        });
+        test.type = "test";
+    });
+    let collectorFixtures = parentCollectorFixtures;
+    const collector = {
+        type: "collector",
+        name,
+        mode,
+        suite,
+        options: suiteOptions,
+        test,
+        tasks,
+        collect,
+        task,
+        clear,
+        on: addHook,
+        fixtures () {
+            return collectorFixtures;
+        },
+        scoped (fixtures) {
+            const parsed = mergeContextFixtures(fixtures, {
+                fixtures: collectorFixtures
+            }, runner);
+            if (parsed.fixtures) {
+                collectorFixtures = parsed.fixtures;
+            }
+        }
+    };
+    function addHook(name, ...fn) {
+        getHooks(suite)[name].push(...fn);
+    }
+    function initSuite(includeLocation) {
+        var _collectorContext$cur4, _collectorContext$cur5, _collectorContext$cur6;
+        if (typeof suiteOptions === "number") {
+            suiteOptions = {
+                timeout: suiteOptions
+            };
+        }
+        const currentSuite = (_collectorContext$cur4 = collectorContext.currentSuite) === null || _collectorContext$cur4 === void 0 ? void 0 : _collectorContext$cur4.suite;
+        suite = {
+            id: "",
+            type: "suite",
+            name,
+            fullName: createTaskName([
+                (currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fullName) ?? ((_collectorContext$cur5 = collectorContext.currentSuite) === null || _collectorContext$cur5 === void 0 || (_collectorContext$cur5 = _collectorContext$cur5.file) === null || _collectorContext$cur5 === void 0 ? void 0 : _collectorContext$cur5.fullName),
+                name
+            ]),
+            fullTestName: createTaskName([
+                currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fullTestName,
+                name
+            ]),
+            suite: currentSuite,
+            mode,
+            each,
+            file: (currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.file) ?? ((_collectorContext$cur6 = collectorContext.currentSuite) === null || _collectorContext$cur6 === void 0 ? void 0 : _collectorContext$cur6.file),
+            shuffle: suiteOptions === null || suiteOptions === void 0 ? void 0 : suiteOptions.shuffle,
+            tasks: [],
+            meta: Object.create(null),
+            concurrent: suiteOptions === null || suiteOptions === void 0 ? void 0 : suiteOptions.concurrent
+        };
+        setHooks(suite, createSuiteHooks());
+    }
+    function clear() {
+        tasks.length = 0;
+        initSuite();
+    }
+    async function collect(file) {
+        if (!file) {
+            throw new TypeError("File is required to collect tasks.");
+        }
+        if (factory) {
+            await runWithSuite(collector, ()=>factory(test));
+        }
+        const allChildren = [];
+        for (const i of tasks){
+            allChildren.push(i.type === "collector" ? await i.collect(file) : i);
+        }
+        suite.tasks = allChildren;
+        return suite;
+    }
+    collectTask(collector);
+    return collector;
+}
+function withAwaitAsyncAssertions(fn, task) {
+    return async (...args)=>{
+        const fnResult = await fn(...args);
+        // some async expect will be added to this array, in case user forget to await them
+        if (task.promises) {
+            const result = await Promise.allSettled(task.promises);
+            const errors = result.map((r)=>r.status === "rejected" ? r.reason : undefined).filter(Boolean);
+            if (errors.length) {
+                throw errors;
+            }
+        }
+        return fnResult;
+    };
+}
+function createSuite() {
+    function suiteFn(name, factoryOrOptions, optionsOrFactory) {
+        var _currentSuite$options;
+        let mode = this.only ? "only" : this.skip ? "skip" : this.todo ? "todo" : "run";
+        const currentSuite = collectorContext.currentSuite || defaultSuite;
+        let { options, handler: factory } = parseArguments(factoryOrOptions, optionsOrFactory);
+        if (mode === "run" && !factory) {
+            mode = "todo";
+        }
+        const isConcurrentSpecified = options.concurrent || this.concurrent || options.sequential === false;
+        const isSequentialSpecified = options.sequential || this.sequential || options.concurrent === false;
+        // inherit options from current suite
+        options = {
+            ...currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.options,
+            ...options,
+            shuffle: this.shuffle ?? options.shuffle ?? (currentSuite === null || currentSuite === void 0 || (_currentSuite$options = currentSuite.options) === null || _currentSuite$options === void 0 ? void 0 : _currentSuite$options.shuffle) ?? (void 0 )
+        };
+        // inherit concurrent / sequential from suite
+        const isConcurrent = isConcurrentSpecified || options.concurrent && !isSequentialSpecified;
+        const isSequential = isSequentialSpecified || options.sequential && !isConcurrentSpecified;
+        options.concurrent = isConcurrent && !isSequential;
+        options.sequential = isSequential && !isConcurrent;
+        return createSuiteCollector(formatName(name), factory, mode, this.each, options, currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fixtures());
+    }
+    suiteFn.each = function(cases, ...args) {
+        const suite = this.withContext();
+        this.setContext("each", true);
+        if (Array.isArray(cases) && args.length) {
+            cases = formatTemplateString(cases, args);
+        }
+        return (name, optionsOrFn, fnOrOptions)=>{
+            const _name = formatName(name);
+            const arrayOnlyCases = cases.every(Array.isArray);
+            const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
+            const fnFirst = typeof optionsOrFn === "function";
+            cases.forEach((i, idx)=>{
+                const items = Array.isArray(i) ? i : [
+                    i
+                ];
+                if (fnFirst) {
+                    if (arrayOnlyCases) {
+                        suite(formatTitle(_name, items, idx), handler ? ()=>handler(...items) : undefined, options.timeout);
+                    } else {
+                        suite(formatTitle(_name, items, idx), handler ? ()=>handler(i) : undefined, options.timeout);
+                    }
+                } else {
+                    if (arrayOnlyCases) {
+                        suite(formatTitle(_name, items, idx), options, handler ? ()=>handler(...items) : undefined);
+                    } else {
+                        suite(formatTitle(_name, items, idx), options, handler ? ()=>handler(i) : undefined);
+                    }
+                }
+            });
+            this.setContext("each", undefined);
+        };
+    };
+    suiteFn.for = function(cases, ...args) {
+        if (Array.isArray(cases) && args.length) {
+            cases = formatTemplateString(cases, args);
+        }
+        return (name, optionsOrFn, fnOrOptions)=>{
+            const name_ = formatName(name);
+            const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
+            cases.forEach((item, idx)=>{
+                suite(formatTitle(name_, toArray(item), idx), options, handler ? ()=>handler(item) : undefined);
+            });
+        };
+    };
+    suiteFn.skipIf = (condition)=>condition ? suite.skip : suite;
+    suiteFn.runIf = (condition)=>condition ? suite : suite.skip;
+    return createChainable([
+        "concurrent",
+        "sequential",
+        "shuffle",
+        "skip",
+        "only",
+        "todo"
+    ], suiteFn);
+}
+function createTaskCollector(fn, context) {
+    const taskFn = fn;
+    taskFn.each = function(cases, ...args) {
+        const test = this.withContext();
+        this.setContext("each", true);
+        if (Array.isArray(cases) && args.length) {
+            cases = formatTemplateString(cases, args);
+        }
+        return (name, optionsOrFn, fnOrOptions)=>{
+            const _name = formatName(name);
+            const arrayOnlyCases = cases.every(Array.isArray);
+            const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
+            const fnFirst = typeof optionsOrFn === "function";
+            cases.forEach((i, idx)=>{
+                const items = Array.isArray(i) ? i : [
+                    i
+                ];
+                if (fnFirst) {
+                    if (arrayOnlyCases) {
+                        test(formatTitle(_name, items, idx), handler ? ()=>handler(...items) : undefined, options.timeout);
+                    } else {
+                        test(formatTitle(_name, items, idx), handler ? ()=>handler(i) : undefined, options.timeout);
+                    }
+                } else {
+                    if (arrayOnlyCases) {
+                        test(formatTitle(_name, items, idx), options, handler ? ()=>handler(...items) : undefined);
+                    } else {
+                        test(formatTitle(_name, items, idx), options, handler ? ()=>handler(i) : undefined);
+                    }
+                }
+            });
+            this.setContext("each", undefined);
+        };
+    };
+    taskFn.for = function(cases, ...args) {
+        const test = this.withContext();
+        if (Array.isArray(cases) && args.length) {
+            cases = formatTemplateString(cases, args);
+        }
+        return (name, optionsOrFn, fnOrOptions)=>{
+            const _name = formatName(name);
+            const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
+            cases.forEach((item, idx)=>{
+                // monkey-patch handler to allow parsing fixture
+                const handlerWrapper = handler ? (ctx)=>handler(item, ctx) : undefined;
+                if (handlerWrapper) {
+                    handlerWrapper.__VITEST_FIXTURE_INDEX__ = 1;
+                    handlerWrapper.toString = ()=>handler.toString();
+                }
+                test(formatTitle(_name, toArray(item), idx), options, handlerWrapper);
+            });
+        };
+    };
+    taskFn.skipIf = function(condition) {
+        return condition ? this.skip : this;
+    };
+    taskFn.runIf = function(condition) {
+        return condition ? this : this.skip;
+    };
+    taskFn.scoped = function(fixtures) {
+        const collector = getCurrentSuite();
+        collector.scoped(fixtures);
+    };
+    taskFn.extend = function(fixtures) {
+        const _context = mergeContextFixtures(fixtures, context || {}, runner);
+        const originalWrapper = fn;
+        return createTest(function(name, optionsOrFn, optionsOrTest) {
+            const collector = getCurrentSuite();
+            const scopedFixtures = collector.fixtures();
+            const context = {
+                ...this
+            };
+            if (scopedFixtures) {
+                context.fixtures = mergeScopedFixtures(context.fixtures || [], scopedFixtures);
+            }
+            originalWrapper.call(context, formatName(name), optionsOrFn, optionsOrTest);
+        }, _context);
+    };
+    taskFn.beforeEach = beforeEach;
+    taskFn.afterEach = afterEach;
+    taskFn.beforeAll = beforeAll;
+    taskFn.afterAll = afterAll;
+    const _test = createChainable([
+        "concurrent",
+        "sequential",
+        "skip",
+        "only",
+        "todo",
+        "fails"
+    ], taskFn);
+    if (context) {
+        _test.mergeContext(context);
+    }
+    return _test;
+}
+function createTest(fn, context) {
+    return createTaskCollector(fn, context);
+}
+function formatName(name) {
+    return typeof name === "string" ? name : typeof name === "function" ? name.name || "<anonymous>" : String(name);
+}
+function formatTitle(template, items, idx) {
+    if (template.includes("%#") || template.includes("%$")) {
+        // '%#' match index of the test case
+        template = template.replace(/%%/g, "__vitest_escaped_%__").replace(/%#/g, `${idx}`).replace(/%\$/g, `${idx + 1}`).replace(/__vitest_escaped_%__/g, "%%");
+    }
+    const count = template.split("%").length - 1;
+    if (template.includes("%f")) {
+        const placeholders = template.match(/%f/g) || [];
+        placeholders.forEach((_, i)=>{
+            if (isNegativeNaN(items[i]) || Object.is(items[i], -0)) {
+                // Replace the i-th occurrence of '%f' with '-%f'
+                let occurrence = 0;
+                template = template.replace(/%f/g, (match)=>{
+                    occurrence++;
+                    return occurrence === i + 1 ? "-%f" : match;
+                });
+            }
+        });
+    }
+    const isObjectItem = isObject(items[0]);
+    function formatAttribute(s) {
+        return s.replace(/\$([$\w.]+)/g, (_, key)=>{
+            const isArrayKey = /^\d+$/.test(key);
+            if (!isObjectItem && !isArrayKey) {
+                return `$${key}`;
+            }
+            const arrayElement = isArrayKey ? objectAttr(items, key) : undefined;
+            const value = isObjectItem ? objectAttr(items[0], key, arrayElement) : arrayElement;
+            return objDisplay(value, {
+                truncate: void 0 
+            });
+        });
+    }
+    let output = "";
+    let i = 0;
+    handleRegexMatch(template, formatRegExp, // format "%"
+    (match)=>{
+        if (i < count) {
+            output += format(match[0], items[i++]);
+        } else {
+            output += match[0];
+        }
+    }, // format "$"
+    (nonMatch)=>{
+        output += formatAttribute(nonMatch);
+    });
+    return output;
+}
+// based on https://github.com/unocss/unocss/blob/2e74b31625bbe3b9c8351570749aa2d3f799d919/packages/autocomplete/src/parse.ts#L11
+function handleRegexMatch(input, regex, onMatch, onNonMatch) {
+    let lastIndex = 0;
+    for (const m of input.matchAll(regex)){
+        if (lastIndex < m.index) {
+            onNonMatch(input.slice(lastIndex, m.index));
+        }
+        onMatch(m);
+        lastIndex = m.index + m[0].length;
+    }
+    if (lastIndex < input.length) {
+        onNonMatch(input.slice(lastIndex));
+    }
+}
+function formatTemplateString(cases, args) {
+    const header = cases.join("").trim().replace(/ /g, "").split("\n").map((i)=>i.split("|"))[0];
+    const res = [];
+    for(let i = 0; i < Math.floor(args.length / header.length); i++){
+        const oneCase = {};
+        for(let j = 0; j < header.length; j++){
+            oneCase[header[j]] = args[i * header.length + j];
+        }
+        res.push(oneCase);
+    }
+    return res;
+}
+const now$2 = Date.now;
+const collectorContext = {
+    currentSuite: null
+};
+function collectTask(task) {
+    var _collectorContext$cur;
+    (_collectorContext$cur = collectorContext.currentSuite) === null || _collectorContext$cur === void 0 ? void 0 : _collectorContext$cur.tasks.push(task);
+}
+async function runWithSuite(suite, fn) {
+    const prev = collectorContext.currentSuite;
+    collectorContext.currentSuite = suite;
+    await fn();
+    collectorContext.currentSuite = prev;
+}
+function withTimeout(fn, timeout, isHook = false, stackTraceError, onTimeout) {
+    if (timeout <= 0 || timeout === Number.POSITIVE_INFINITY) {
+        return fn;
+    }
+    const { setTimeout, clearTimeout } = getSafeTimers();
+    // this function name is used to filter error in test/cli/test/fails.test.ts
+    return function runWithTimeout(...args) {
+        const startTime = now$2();
+        const runner = getRunner();
+        runner._currentTaskStartTime = startTime;
+        runner._currentTaskTimeout = timeout;
+        return new Promise((resolve_, reject_)=>{
+            var _timer$unref;
+            const timer = setTimeout(()=>{
+                clearTimeout(timer);
+                rejectTimeoutError();
+            }, timeout);
+            // `unref` might not exist in browser
+            (_timer$unref = timer.unref) === null || _timer$unref === void 0 ? void 0 : _timer$unref.call(timer);
+            function rejectTimeoutError() {
+                const error = makeTimeoutError(isHook, timeout, stackTraceError);
+                onTimeout === null || onTimeout === void 0 ? void 0 : onTimeout(args, error);
+                reject_(error);
+            }
+            function resolve(result) {
+                runner._currentTaskStartTime = undefined;
+                runner._currentTaskTimeout = undefined;
+                clearTimeout(timer);
+                // if test/hook took too long in microtask, setTimeout won't be triggered,
+                // but we still need to fail the test, see
+                // https://github.com/vitest-dev/vitest/issues/2920
+                if (now$2() - startTime >= timeout) {
+                    rejectTimeoutError();
+                    return;
+                }
+                resolve_(result);
+            }
+            function reject(error) {
+                runner._currentTaskStartTime = undefined;
+                runner._currentTaskTimeout = undefined;
+                clearTimeout(timer);
+                reject_(error);
+            }
+            // sync test/hook will be caught by try/catch
+            try {
+                const result = fn(...args);
+                // the result is a thenable, we don't wrap this in Promise.resolve
+                // to avoid creating new promises
+                if (typeof result === "object" && result != null && typeof result.then === "function") {
+                    result.then(resolve, reject);
+                } else {
+                    resolve(result);
+                }
+            } // user sync test/hook throws an error
+            catch (error) {
+                reject(error);
+            }
+        });
+    };
+}
+const abortControllers = new WeakMap();
+function abortIfTimeout([context], error) {
+    if (context) {
+        abortContextSignal(context, error);
+    }
+}
+function abortContextSignal(context, error) {
+    const abortController = abortControllers.get(context);
+    abortController === null || abortController === void 0 ? void 0 : abortController.abort(error);
+}
+function createTestContext(test, runner) {
+    var _runner$extendTaskCon;
+    const context = function() {
+        throw new Error("done() callback is deprecated, use promise instead");
+    };
+    let abortController = abortControllers.get(context);
+    if (!abortController) {
+        abortController = new AbortController();
+        abortControllers.set(context, abortController);
+    }
+    context.signal = abortController.signal;
+    context.task = test;
+    context.skip = (condition, note)=>{
+        if (condition === false) {
+            // do nothing
+            return undefined;
+        }
+        test.result ?? (test.result = {
+            state: "skip"
+        });
+        test.result.pending = true;
+        throw new PendingError("test is skipped; abort execution", test, typeof condition === "string" ? condition : note);
+    };
+    context.annotate = (message, type, attachment)=>{
+        if (test.result && test.result.state !== "run") {
+            throw new Error(`Cannot annotate tests outside of the test run. The test "${test.name}" finished running with the "${test.result.state}" state already.`);
+        }
+        const annotation = {
+            message,
+            type: typeof type === "object" || type === undefined ? "notice" : type
+        };
+        const annotationAttachment = typeof type === "object" ? type : attachment;
+        if (annotationAttachment) {
+            annotation.attachment = annotationAttachment;
+            manageArtifactAttachment(annotation.attachment);
+        }
+        return recordAsyncOperation(test, recordArtifact(test, {
+            type: "internal:annotation",
+            annotation
+        }).then(async ({ annotation })=>{
+            if (!runner.onTestAnnotate) {
+                throw new Error(`Test runner doesn't support test annotations.`);
+            }
+            await finishSendTasksUpdate(runner);
+            const resolvedAnnotation = await runner.onTestAnnotate(test, annotation);
+            test.annotations.push(resolvedAnnotation);
+            return resolvedAnnotation;
+        }));
+    };
+    context.onTestFailed = (handler, timeout)=>{
+        test.onFailed || (test.onFailed = []);
+        test.onFailed.push(withTimeout(handler, timeout ?? runner.config.hookTimeout, true, new Error("STACK_TRACE_ERROR"), (_, error)=>abortController.abort(error)));
+    };
+    context.onTestFinished = (handler, timeout)=>{
+        test.onFinished || (test.onFinished = []);
+        test.onFinished.push(withTimeout(handler, timeout ?? runner.config.hookTimeout, true, new Error("STACK_TRACE_ERROR"), (_, error)=>abortController.abort(error)));
+    };
+    return ((_runner$extendTaskCon = runner.extendTaskContext) === null || _runner$extendTaskCon === void 0 ? void 0 : _runner$extendTaskCon.call(runner, context)) || context;
+}
+function makeTimeoutError(isHook, timeout, stackTraceError) {
+    const message = `${isHook ? "Hook" : "Test"} timed out in ${timeout}ms.\nIf this is a long-running ${isHook ? "hook" : "test"}, pass a timeout value as the last argument or configure it globally with "${isHook ? "hookTimeout" : "testTimeout"}".`;
+    const error = new Error(message);
+    if (stackTraceError === null || stackTraceError === void 0 ? void 0 : stackTraceError.stack) {
+        error.stack = stackTraceError.stack.replace(error.message, stackTraceError.message);
+    }
+    return error;
+}
+const fileContexts = new WeakMap();
+function getFileContext(file) {
+    const context = fileContexts.get(file);
+    if (!context) {
+        throw new Error(`Cannot find file context for ${file.name}`);
+    }
+    return context;
+}
+globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
+globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
+getSafeTimers();
+const packs = new Map();
+const eventsPacks = [];
+const pendingTasksUpdates = [];
+function sendTasksUpdate(runner) {
+    if (packs.size) {
+        var _runner$onTaskUpdate;
+        const taskPacks = Array.from(packs).map(([id, task])=>{
+            return [
+                id,
+                task[0],
+                task[1]
+            ];
+        });
+        const p = (_runner$onTaskUpdate = runner.onTaskUpdate) === null || _runner$onTaskUpdate === void 0 ? void 0 : _runner$onTaskUpdate.call(runner, taskPacks, eventsPacks);
+        if (p) {
+            pendingTasksUpdates.push(p);
+            // remove successful promise to not grow array indefnitely,
+            // but keep rejections so finishSendTasksUpdate can handle them
+            p.then(()=>pendingTasksUpdates.splice(pendingTasksUpdates.indexOf(p), 1), ()=>{});
+        }
+        eventsPacks.length = 0;
+        packs.clear();
+    }
+}
+async function finishSendTasksUpdate(runner) {
+    sendTasksUpdate(runner);
+    await Promise.all(pendingTasksUpdates);
+}
+/**
+* @experimental
+* @advanced
+*
+* Records a custom test artifact during test execution.
+*
+* This function allows you to attach structured data, files, or metadata to a test.
+*
+* Vitest automatically injects the source location where the artifact was created and manages any attachments you include.
+*
+* @param task - The test task context, typically accessed via `this.task` in custom matchers or `context.task` in tests
+* @param artifact - The artifact to record. Must extend {@linkcode TestArtifactBase}
+*
+* @returns A promise that resolves to the recorded artifact with location injected
+*
+* @throws {Error} If called after the test has finished running
+* @throws {Error} If the test runner doesn't support artifacts
+*
+* @example
+* ```ts
+* // In a custom assertion
+* async function toHaveValidSchema(this: MatcherState, actual: unknown) {
+*   const validation = validateSchema(actual)
+*
+*   await recordArtifact(this.task, {
+*     type: 'my-plugin:schema-validation',
+*     passed: validation.valid,
+*     errors: validation.errors,
+*   })
+*
+*   return { pass: validation.valid, message: () => '...' }
+* }
+* ```
+*/ async function recordArtifact(task, artifact) {
+    const runner = getRunner();
+    if (task.result && task.result.state !== "run") {
+        throw new Error(`Cannot record a test artifact outside of the test run. The test "${task.name}" finished running with the "${task.result.state}" state already.`);
+    }
+    const stack = findTestFileStackTrace(task.file.filepath, new Error("STACK_TRACE").stack);
+    if (stack) {
+        artifact.location = {
+            file: stack.file,
+            line: stack.line,
+            column: stack.column
+        };
+        if (artifact.type === "internal:annotation") {
+            artifact.annotation.location = artifact.location;
+        }
+    }
+    if (Array.isArray(artifact.attachments)) {
+        for (const attachment of artifact.attachments){
+            manageArtifactAttachment(attachment);
+        }
+    }
+    // annotations won't resolve as artifacts for backwards compatibility until next major
+    if (artifact.type === "internal:annotation") {
+        return artifact;
+    }
+    if (!runner.onTestArtifactRecord) {
+        throw new Error(`Test runner doesn't support test artifacts.`);
+    }
+    await finishSendTasksUpdate(runner);
+    const resolvedArtifact = await runner.onTestArtifactRecord(task, artifact);
+    task.artifacts.push(resolvedArtifact);
+    return resolvedArtifact;
+}
+const table = [];
+for(let i = 65; i < 91; i++){
+    table.push(String.fromCharCode(i));
+}
+for(let i = 97; i < 123; i++){
+    table.push(String.fromCharCode(i));
+}
+for(let i = 0; i < 10; i++){
+    table.push(i.toString(10));
+}
+table.push("+", "/");
+function encodeUint8Array(bytes) {
+    let base64 = "";
+    const len = bytes.byteLength;
+    for(let i = 0; i < len; i += 3){
+        if (len === i + 1) {
+            const a = (bytes[i] & 252) >> 2;
+            const b = (bytes[i] & 3) << 4;
+            base64 += table[a];
+            base64 += table[b];
+            base64 += "==";
+        } else if (len === i + 2) {
+            const a = (bytes[i] & 252) >> 2;
+            const b = (bytes[i] & 3) << 4 | (bytes[i + 1] & 240) >> 4;
+            const c = (bytes[i + 1] & 15) << 2;
+            base64 += table[a];
+            base64 += table[b];
+            base64 += table[c];
+            base64 += "=";
+        } else {
+            const a = (bytes[i] & 252) >> 2;
+            const b = (bytes[i] & 3) << 4 | (bytes[i + 1] & 240) >> 4;
+            const c = (bytes[i + 1] & 15) << 2 | (bytes[i + 2] & 192) >> 6;
+            const d = bytes[i + 2] & 63;
+            base64 += table[a];
+            base64 += table[b];
+            base64 += table[c];
+            base64 += table[d];
+        }
+    }
+    return base64;
+}
+/**
+* Records an async operation associated with a test task.
+*
+* This function tracks promises that should be awaited before a test completes.
+* The promise is automatically removed from the test's promise list once it settles.
+*/ function recordAsyncOperation(test, promise) {
+    // if promise is explicitly awaited, remove it from the list
+    promise = promise.finally(()=>{
+        if (!test.promises) {
+            return;
+        }
+        const index = test.promises.indexOf(promise);
+        if (index !== -1) {
+            test.promises.splice(index, 1);
+        }
+    });
+    // record promise
+    if (!test.promises) {
+        test.promises = [];
+    }
+    test.promises.push(promise);
+    return promise;
+}
+/**
+* Validates and prepares a test attachment for serialization.
+*
+* This function ensures attachments have either `body` or `path` set (but not both), and converts `Uint8Array` bodies to base64-encoded strings for easier serialization.
+*
+* @param attachment - The attachment to validate and prepare
+*
+* @throws {TypeError} If neither `body` nor `path` is provided
+* @throws {TypeError} If both `body` and `path` are provided
+*/ function manageArtifactAttachment(attachment) {
+    if (attachment.body == null && !attachment.path) {
+        throw new TypeError(`Test attachment requires "body" or "path" to be set. Both are missing.`);
+    }
+    if (attachment.body && attachment.path) {
+        throw new TypeError(`Test attachment requires only one of "body" or "path" to be set. Both are specified.`);
+    }
+    // convert to a string so it's easier to serialise
+    if (attachment.body instanceof Uint8Array) {
+        attachment.body = encodeUint8Array(attachment.body);
+    }
+}
+
+function createSpec(spec) {
+    const proto = Object.getPrototypeOf(spec);
+    let describeFn;
+    const specName = proto.constructor.name;
+    if (specName.startsWith('fff')) {
+        describeFn = describe.only;
+    } else if (specName.startsWith('xxx')) {
+        describeFn = describe.skip;
+    } else {
+        describeFn = describe;
+    }
+    describeFn(specName, ()=>createTestCases(spec));
+}
+function createTestCases(spec) {
+    let proto = Object.getPrototypeOf(spec);
+    const processedMethodsMap = {};
+    while(proto.constructor !== Object){
+        for (const key of Object.getOwnPropertyNames(proto)){
+            const isProcessed = processedMethodsMap[key];
+            processedMethodsMap[key] = true;
+            const method = spec[key];
+            if (isProcessed || key === 'constructor' || typeof method !== 'function') {
+                continue;
+            }
+            const callback = method.bind(spec);
+            const hookFn = hooks[key];
+            if (hookFn) {
+                hookFn(callback);
+            } else if (key.startsWith('should')) {
+                it(key, callback);
+            } else if (key.startsWith('fffShould')) {
+                it.only(key, callback);
+            } else if (key.startsWith('xxxShould')) {
+                it.skip(key, callback);
+            }
+        }
+        proto = Object.getPrototypeOf(proto);
+    }
+}
+const hooks = {
+    beforeAll,
+    beforeEach,
+    afterEach,
+    afterAll
+};
+
+export { BaseEntity, _Company as Company, _InventoryAdjustment as InventoryAdjustment, _Item as Item, _ItemAdjustment as ItemAdjustment, _ItemTag as ItemTag, _LedgerAccount as LedgerAccount, _MeasureUnit as MeasureUnit, _MeasureUnitCategory as MeasureUnitCategory, _Profile as Profile, _Storehouse as Storehouse, _Tag as Tag, _Tax as Tax, _TaxCategory as TaxCategory, _User as User, _UserWithNonUpdatableId as UserWithNonUpdatableId, clearTables, createSpec, createTables, dropTables };
+//# sourceMappingURL=uql-browser.min.js.map