From c9484489d1e1220cfeac2c5a5968421bd4522452 Mon Sep 17 00:00:00 2001 From: sanderPostma Date: Fri, 14 Mar 2025 02:38:34 +0100 Subject: [PATCH 1/8] chore: implemented expand QPs for showcase --- .../src/controllers/ShowcaseController.ts | 17 +- .../ShowcaseController.integration.test.ts | 701 +++++++++++++++++- .../repositories/ShowcaseRepository.ts | 551 ++++++++++---- .../__tests__/showcase.repository.test.ts | 268 ++++++- .../src/services/ShowcaseService.ts | 9 +- .../src/types/schema/index.ts | 25 +- .../src/utils/mappers.ts | 45 +- .../src/utils/normalize.ts | 31 + .../openapi/openapi.yaml | 47 +- 9 files changed, 1496 insertions(+), 198 deletions(-) create mode 100644 apps/credential-showcase-api-server/src/utils/normalize.ts diff --git a/apps/credential-showcase-api-server/src/controllers/ShowcaseController.ts b/apps/credential-showcase-api-server/src/controllers/ShowcaseController.ts index 9664d9f..ae93703 100644 --- a/apps/credential-showcase-api-server/src/controllers/ShowcaseController.ts +++ b/apps/credential-showcase-api-server/src/controllers/ShowcaseController.ts @@ -1,16 +1,17 @@ -import { BadRequestError, Body, Delete, Get, HttpCode, JsonController, OnUndefined, Param, Post, Put } from 'routing-controllers' +import { BadRequestError, Body, Delete, Get, HttpCode, JsonController, OnUndefined, Param, Post, Put, QueryParam } from 'routing-controllers' import { Service } from 'typedi' import { - ShowcaseResponse, - ShowcaseResponseFromJSONTyped, + instanceOfShowcaseRequest, ShowcaseExpand, ShowcaseRequest, ShowcaseRequestToJSONTyped, + ShowcaseResponse, + ShowcaseResponseFromJSONTyped, ShowcasesResponse, ShowcasesResponseFromJSONTyped, - instanceOfShowcaseRequest, } from 'credential-showcase-openapi' import ShowcaseService from '../services/ShowcaseService' import { showcaseDTOFrom } from '../utils/mappers' +import { normalizeExpandParams } from '../utils/normalize' @JsonController('/showcases') @Service() @@ -18,9 +19,9 @@ class ShowcaseController { constructor(private showcaseService: ShowcaseService) {} @Get('/') - public async getAll(): Promise { + public async getAll(@QueryParam('expand') expand?: ShowcaseExpand[]): Promise { try { - const result = await this.showcaseService.getShowcases() + const result = await this.showcaseService.getShowcases(normalizeExpandParams(expand)) const showcases = result.map((showcase) => showcaseDTOFrom(showcase)) return ShowcasesResponseFromJSONTyped({ showcases }, false) } catch (e) { @@ -32,10 +33,10 @@ class ShowcaseController { } @Get('/:slug') - public async getOne(@Param('slug') slug: string): Promise { + public async getOne(@Param('slug') slug: string, @QueryParam('expand') expand?: ShowcaseExpand[]): Promise { const id = await this.showcaseService.getIdBySlug(slug) try { - const result = await this.showcaseService.getShowcase(id) + const result = await this.showcaseService.getShowcase(id, normalizeExpandParams(expand)) return ShowcaseResponseFromJSONTyped({ showcase: showcaseDTOFrom(result) }, false) } catch (e) { if (e.httpCode !== 404) { diff --git a/apps/credential-showcase-api-server/src/controllers/__tests__/ShowcaseController.integration.test.ts b/apps/credential-showcase-api-server/src/controllers/__tests__/ShowcaseController.integration.test.ts index 171db71..d5ab630 100644 --- a/apps/credential-showcase-api-server/src/controllers/__tests__/ShowcaseController.integration.test.ts +++ b/apps/credential-showcase-api-server/src/controllers/__tests__/ShowcaseController.integration.test.ts @@ -12,14 +12,14 @@ import PersonaRepository from '../../database/repositories/PersonaRepository' import ScenarioRepository from '../../database/repositories/ScenarioRepository' import ShowcaseRepository from '../../database/repositories/ShowcaseRepository' import ShowcaseService from '../../services/ShowcaseService' -import { ShowcaseRequest } from 'credential-showcase-openapi' -import supertest = require('supertest') +import { Showcase, ShowcaseExpand, ShowcaseRequest } from 'credential-showcase-openapi' import { PGlite } from '@electric-sql/pglite' import { drizzle } from 'drizzle-orm/pglite' import * as schema from '../../database/schema' import { NodePgDatabase } from 'drizzle-orm/node-postgres' import { migrate } from 'drizzle-orm/node-postgres/migrator' import DatabaseService from '../../services/DatabaseService' +import supertest = require('supertest') describe('ShowcaseController Integration Tests', () => { let client: PGlite @@ -237,4 +237,701 @@ describe('ShowcaseController Integration Tests', () => { await request.post('/showcases').send(invalidShowcaseRequest2).expect(404) }) + + it('should retrieve a showcase with no expands', async () => { + // Create prerequisites: asset, credential schema, credential definition, issuer, persona, and scenario + const assetRepository = Container.get(AssetRepository) + const asset = await assetRepository.create({ + mediaType: 'image/png', + fileName: 'test.png', + description: 'Test image', + content: Buffer.from('binary data'), + }) + + const credentialSchemaRepository = Container.get(CredentialSchemaRepository) + const credentialSchema = await credentialSchemaRepository.create({ + name: 'example_name', + version: 'example_version', + identifierType: IdentifierType.DID, + identifier: 'did:sov:XUeUZauFLeBNofY3NhaZCB', + attributes: [ + { + name: 'example_attribute_name1', + value: 'example_attribute_value1', + type: CredentialAttributeType.STRING, + }, + { + name: 'example_attribute_name2', + value: 'example_attribute_value2', + type: CredentialAttributeType.STRING, + }, + ], + }) + + const credentialDefinitionRepository = Container.get(CredentialDefinitionRepository) + const credentialDefinition = await credentialDefinitionRepository.create({ + name: 'Test Definition', + version: '1.0', + identifierType: IdentifierType.DID, + identifier: 'did:test:123', + icon: asset.id, + type: CredentialType.ANONCRED, + credentialSchema: credentialSchema.id, + }) + + const issuerRepository = Container.get(IssuerRepository) + const issuer = await issuerRepository.create({ + name: 'Test Issuer', + type: IssuerType.ARIES, + credentialDefinitions: [credentialDefinition.id], + credentialSchemas: [credentialSchema.id], + description: 'Test issuer description', + organization: 'Test Organization', + logo: asset.id, + }) + + // Create a persona + const personaRepository = Container.get(PersonaRepository) + const persona = await personaRepository.create({ + name: 'John Doe', + role: 'Software Engineer', + description: 'Experienced developer', + headshotImage: asset.id, + bodyImage: asset.id, + hidden: false, + }) + + // Create an issuance scenario with at least one step + const scenarioRepository = Container.get(ScenarioRepository) + const scenario = await scenarioRepository.create({ + name: 'Test Scenario', + description: 'Test scenario description', + issuer: issuer.id, // This makes it an issuance scenario + steps: [ + { + title: 'Test Step', + description: 'Test step description', + order: 1, + type: StepType.HUMAN_TASK, + asset: asset.id, + actions: [ + { + title: 'Test Action', + actionType: StepActionType.ARIES_OOB, + text: 'Test action text', + proofRequest: { + attributes: { + attribute1: { + attributes: ['attribute1', 'attribute2'], + restrictions: ['restriction1', 'restriction2'], + }, + }, + predicates: {}, + }, + }, + ], + }, + ], + personas: [persona.id], + hidden: false, + }) + + const showcaseRequest: ShowcaseRequest = { + name: 'Expand Test Showcase', + description: 'Testing expand options', + status: ShowcaseStatus.ACTIVE, + hidden: false, + scenarios: [scenario.id], + credentialDefinitions: [credentialDefinition.id], + personas: [persona.id], + bannerImage: asset.id, + completionMessage: 'Completion message', + } + + const createResponse = await request.post('/showcases').send(showcaseRequest).expect(201) + const createdShowcase = createResponse.body.showcase + + // Retrieve without any expands + const getResponse = await request.get(`/showcases/${createdShowcase.slug}`).expect(200) + + // Verify no related entities are expanded + expect(getResponse.body.showcase.scenarios).toEqual([]) + expect(getResponse.body.showcase.credentialDefinitions).toEqual([]) + expect(getResponse.body.showcase.personas).toEqual([]) + expect(getResponse.body.showcase.bannerImage).toBeUndefined() + expect(getResponse.body.showcase.bannerImageId).toBe(asset.id) + }) + + it('should retrieve a showcase with all expands except asset content', async () => { + // Create prerequisites: asset, credential schema, credential definition, issuer, persona, and scenario + const assetRepository = Container.get(AssetRepository) + const asset = await assetRepository.create({ + mediaType: 'image/png', + fileName: 'test.png', + description: 'Test image', + content: Buffer.from('binary data'), + }) + + const credentialSchemaRepository = Container.get(CredentialSchemaRepository) + const credentialSchema = await credentialSchemaRepository.create({ + name: 'example_name', + version: 'example_version', + identifierType: IdentifierType.DID, + identifier: 'did:sov:XUeUZauFLeBNofY3NhaZCB', + attributes: [ + { + name: 'example_attribute_name1', + value: 'example_attribute_value1', + type: CredentialAttributeType.STRING, + }, + { + name: 'example_attribute_name2', + value: 'example_attribute_value2', + type: CredentialAttributeType.STRING, + }, + ], + }) + + const credentialDefinitionRepository = Container.get(CredentialDefinitionRepository) + const credentialDefinition = await credentialDefinitionRepository.create({ + name: 'Test Definition', + version: '1.0', + identifierType: IdentifierType.DID, + identifier: 'did:test:123', + icon: asset.id, + type: CredentialType.ANONCRED, + credentialSchema: credentialSchema.id, + }) + + const issuerRepository = Container.get(IssuerRepository) + const issuer = await issuerRepository.create({ + name: 'Test Issuer', + type: IssuerType.ARIES, + credentialDefinitions: [credentialDefinition.id], + credentialSchemas: [credentialSchema.id], + description: 'Test issuer description', + organization: 'Test Organization', + logo: asset.id, + }) + + // Create a persona + const personaRepository = Container.get(PersonaRepository) + const persona = await personaRepository.create({ + name: 'John Doe', + role: 'Software Engineer', + description: 'Experienced developer', + headshotImage: asset.id, + bodyImage: asset.id, + hidden: false, + }) + + // Create an issuance scenario with at least one step + const scenarioRepository = Container.get(ScenarioRepository) + const scenario = await scenarioRepository.create({ + name: 'Test Scenario', + description: 'Test scenario description', + issuer: issuer.id, // This makes it an issuance scenario + steps: [ + { + title: 'Test Step', + description: 'Test step description', + order: 1, + type: StepType.HUMAN_TASK, + asset: asset.id, + actions: [ + { + title: 'Test Action', + actionType: StepActionType.ARIES_OOB, + text: 'Test action text', + proofRequest: { + attributes: { + attribute1: { + attributes: ['attribute1', 'attribute2'], + restrictions: ['restriction1', 'restriction2'], + }, + }, + predicates: {}, + }, + }, + ], + }, + ], + personas: [persona.id], + hidden: false, + }) + + const showcaseRequest: ShowcaseRequest = { + name: 'All Expands Showcase', + description: 'Testing all expands except asset content', + status: ShowcaseStatus.ACTIVE, + hidden: false, + scenarios: [scenario.id], + credentialDefinitions: [credentialDefinition.id], + personas: [persona.id], + bannerImage: asset.id, + completionMessage: 'Testing completion message', + } + + const createResponse = await request.post('/showcases').send(showcaseRequest).expect(201) + const createdShowcase = createResponse.body.showcase + + // Retrieve with all expands except asset content + const getResponse = await request + .get(`/showcases/${createdShowcase.slug}?expand=${ShowcaseExpand.Scenarios}&expand=${ShowcaseExpand.CredentialDefinitions}&expand=${ShowcaseExpand.Personas}`) + .expect(200) + + // Verify related entities are expanded + expect(getResponse.body.showcase.scenarios.length).toEqual(1) + expect(getResponse.body.showcase.credentialDefinitions.length).toEqual(1) + expect(getResponse.body.showcase.personas.length).toEqual(1) + + // Verify completionMessage is preserved + expect(getResponse.body.showcase.completionMessage).toEqual('Testing completion message') + + // Verify banner image is a string ID without content + expect(typeof getResponse.body.showcase.bannerImageId).toBe('string') + + // Check that persona image references are string IDs + const responsePersona = getResponse.body.showcase.personas[0] + expect(typeof responsePersona.headshotImageId).toBe('string') + expect(typeof responsePersona.bodyImageId).toBe('string') + + // Check that scenario assets are string IDs + const step = getResponse.body.showcase.scenarios[0].steps[0] + expect(typeof step.assetId).toBe('string') + }) + + it('should retrieve a showcase with all expands including asset content', async () => { + // Create prerequisites: asset, credential schema, credential definition, issuer, persona, and scenario + const assetRepository = Container.get(AssetRepository) + const asset = await assetRepository.create({ + mediaType: 'image/png', + fileName: 'test.png', + description: 'Test image', + content: Buffer.from('binary data'), + }) + + const credentialSchemaRepository = Container.get(CredentialSchemaRepository) + const credentialSchema = await credentialSchemaRepository.create({ + name: 'example_name', + version: 'example_version', + identifierType: IdentifierType.DID, + identifier: 'did:sov:XUeUZauFLeBNofY3NhaZCB', + attributes: [ + { + name: 'example_attribute_name1', + value: 'example_attribute_value1', + type: CredentialAttributeType.STRING, + }, + { + name: 'example_attribute_name2', + value: 'example_attribute_value2', + type: CredentialAttributeType.STRING, + }, + ], + }) + + const credentialDefinitionRepository = Container.get(CredentialDefinitionRepository) + const credentialDefinition = await credentialDefinitionRepository.create({ + name: 'Test Definition', + version: '1.0', + identifierType: IdentifierType.DID, + identifier: 'did:test:123', + icon: asset.id, + type: CredentialType.ANONCRED, + credentialSchema: credentialSchema.id, + }) + + const issuerRepository = Container.get(IssuerRepository) + const issuer = await issuerRepository.create({ + name: 'Test Issuer', + type: IssuerType.ARIES, + credentialDefinitions: [credentialDefinition.id], + credentialSchemas: [credentialSchema.id], + description: 'Test issuer description', + organization: 'Test Organization', + logo: asset.id, + }) + + // Create a persona + const personaRepository = Container.get(PersonaRepository) + const persona = await personaRepository.create({ + name: 'John Doe', + role: 'Software Engineer', + description: 'Experienced developer', + headshotImage: asset.id, + bodyImage: asset.id, + hidden: false, + }) + + // Create an issuance scenario with at least one step + const scenarioRepository = Container.get(ScenarioRepository) + const scenario = await scenarioRepository.create({ + name: 'Test Scenario', + description: 'Test scenario description', + issuer: issuer.id, // This makes it an issuance scenario + steps: [ + { + title: 'Test Step', + description: 'Test step description', + order: 1, + type: StepType.HUMAN_TASK, + asset: asset.id, + actions: [ + { + title: 'Test Action', + actionType: StepActionType.ARIES_OOB, + text: 'Test action text', + proofRequest: { + attributes: { + attribute1: { + attributes: ['attribute1', 'attribute2'], + restrictions: ['restriction1', 'restriction2'], + }, + }, + predicates: {}, + }, + }, + ], + }, + ], + personas: [persona.id], + hidden: false, + }) + + const showcaseRequest: ShowcaseRequest = { + name: 'Assets Content Showcase', + description: 'Testing all expands with asset content', + status: ShowcaseStatus.ACTIVE, + hidden: false, + scenarios: [scenario.id], + credentialDefinitions: [credentialDefinition.id], + personas: [persona.id], + bannerImage: asset.id, + completionMessage: 'Asset content test completion message', + } + + const createResponse = await request.post('/showcases').send(showcaseRequest).expect(201) + const createdShowcase = createResponse.body.showcase + + // Retrieve with all expands including asset content + const getResponse = await request + .get(`/showcases/${createdShowcase.slug}?expand=${ShowcaseExpand.Scenarios}&expand=${ShowcaseExpand.CredentialDefinitions}&expand=${ShowcaseExpand.Personas}&expand=${ShowcaseExpand.AssetContent}`) + .expect(200) + + // Verify related entities are expanded + expect(getResponse.body.showcase.scenarios.length).toEqual(1) + expect(getResponse.body.showcase.credentialDefinitions.length).toEqual(1) + expect(getResponse.body.showcase.personas.length).toEqual(1) + + // Verify completionMessage is preserved + expect(getResponse.body.showcase.completionMessage).toEqual('Asset content test completion message') + + // Verify banner image is an object with content + expect(typeof getResponse.body.showcase.bannerImage).toBe('object') + expect(getResponse.body.showcase.bannerImage).toHaveProperty('id') + expect(getResponse.body.showcase.bannerImage).toHaveProperty('mediaType') + expect(getResponse.body.showcase.bannerImage).toHaveProperty('fileName') + expect(getResponse.body.showcase.bannerImage).toHaveProperty('content') + + // Check that persona image references have content + const responsePersona = getResponse.body.showcase.personas[0] + expect(typeof responsePersona.headshotImage).toBe('object') + expect(responsePersona.headshotImage).toHaveProperty('content') + expect(typeof responsePersona.bodyImage).toBe('object') + expect(responsePersona.bodyImage).toHaveProperty('content') + + // Check that scenario assets have content + const step = getResponse.body.showcase.scenarios[0].steps[0] + expect(typeof step.asset).toBe('object') + expect(step.asset).toHaveProperty('content') + }) + + it('should retrieve all showcases with various expand combinations', async () => { + // Create prerequisites: asset, credential schema, credential definition, issuer, persona, and scenario + const assetRepository = Container.get(AssetRepository) + const asset = await assetRepository.create({ + mediaType: 'image/png', + fileName: 'test.png', + description: 'Test image', + content: Buffer.from('binary data'), + }) + + const credentialSchemaRepository = Container.get(CredentialSchemaRepository) + const credentialSchema = await credentialSchemaRepository.create({ + name: 'example_name', + version: 'example_version', + identifierType: IdentifierType.DID, + identifier: 'did:sov:XUeUZauFLeBNofY3NhaZCB', + attributes: [ + { + name: 'example_attribute_name1', + value: 'example_attribute_value1', + type: CredentialAttributeType.STRING, + }, + { + name: 'example_attribute_name2', + value: 'example_attribute_value2', + type: CredentialAttributeType.STRING, + }, + ], + }) + + const credentialDefinitionRepository = Container.get(CredentialDefinitionRepository) + const credentialDefinition = await credentialDefinitionRepository.create({ + name: 'Test Definition', + version: '1.0', + identifierType: IdentifierType.DID, + identifier: 'did:test:123', + icon: asset.id, + type: CredentialType.ANONCRED, + credentialSchema: credentialSchema.id, + }) + + const issuerRepository = Container.get(IssuerRepository) + const issuer = await issuerRepository.create({ + name: 'Test Issuer', + type: IssuerType.ARIES, + credentialDefinitions: [credentialDefinition.id], + credentialSchemas: [credentialSchema.id], + description: 'Test issuer description', + organization: 'Test Organization', + logo: asset.id, + }) + + // Create a persona + const personaRepository = Container.get(PersonaRepository) + const persona = await personaRepository.create({ + name: 'John Doe', + role: 'Software Engineer', + description: 'Experienced developer', + headshotImage: asset.id, + bodyImage: asset.id, + hidden: false, + }) + + // Create an issuance scenario with at least one step + const scenarioRepository = Container.get(ScenarioRepository) + const scenario = await scenarioRepository.create({ + name: 'Test Scenario', + description: 'Test scenario description', + issuer: issuer.id, // This makes it an issuance scenario + steps: [ + { + title: 'Test Step', + description: 'Test step description', + order: 1, + type: StepType.HUMAN_TASK, + asset: asset.id, + actions: [ + { + title: 'Test Action', + actionType: StepActionType.ARIES_OOB, + text: 'Test action text', + proofRequest: { + attributes: { + attribute1: { + attributes: ['attribute1', 'attribute2'], + restrictions: ['restriction1', 'restriction2'], + }, + }, + predicates: {}, + }, + }, + ], + }, + ], + personas: [persona.id], + hidden: false, + }) + + // Create two showcases + const showcaseRequest1: ShowcaseRequest = { + name: 'First Test Showcase', + description: 'Testing expand options', + status: ShowcaseStatus.ACTIVE, + hidden: false, + scenarios: [scenario.id], + credentialDefinitions: [credentialDefinition.id], + personas: [persona.id], + bannerImage: asset.id, + completionMessage: 'First showcase completion message', + } + + const showcaseRequest2: ShowcaseRequest = { + name: 'Second Test Showcase', + description: 'Testing expand options', + status: ShowcaseStatus.ACTIVE, + hidden: false, + scenarios: [scenario.id], + credentialDefinitions: [credentialDefinition.id], + personas: [persona.id], + completionMessage: 'Second showcase completion message', + } + + await request.post('/showcases').send(showcaseRequest1).expect(201) + await request.post('/showcases').send(showcaseRequest2).expect(201) + + // Test 1: Get all with no expands + const response1 = await request.get('/showcases').expect(200) + expect(response1.body.showcases.length).toBeGreaterThanOrEqual(2) + expect(response1.body.showcases[0].scenarios).toEqual([]) + expect(response1.body.showcases[0].credentialDefinitions).toEqual([]) + expect(response1.body.showcases[0].personas).toEqual([]) + expect(response1.body.showcases[0].completionMessage).toBeDefined() + + // Test 2: Get all with only scenarios expanded + const response2 = await request.get(`/showcases?expand=${ShowcaseExpand.Scenarios}`).expect(200) + expect(response2.body.showcases.length).toBeGreaterThanOrEqual(2) + expect(response2.body.showcases[0].scenarios.length).toBeGreaterThanOrEqual(1) + expect(response2.body.showcases[0].credentialDefinitions).toEqual([]) + expect(response2.body.showcases[0].personas).toEqual([]) + expect(response2.body.showcases[0].completionMessage).toBeDefined() + + // Test 3: Get all with scenarios and credential definitions expanded + const response3 = await request.get(`/showcases?expand=scenarios&expand=credentialdefinitions`).expect(200) // Test normalization + expect(response3.body.showcases.length).toBeGreaterThanOrEqual(2) + expect(response3.body.showcases[0].scenarios.length).toBeGreaterThanOrEqual(1) + expect(response3.body.showcases[0].credentialDefinitions.length).toBeGreaterThanOrEqual(1) + expect(response3.body.showcases[0].personas).toEqual([]) + expect(response3.body.showcases[0].completionMessage).toBeDefined() + + // Test 4: Get all with all expands including asset content + const response4 = await request.get(`/showcases?expand=${ShowcaseExpand.Scenarios}&expand=${ShowcaseExpand.CredentialDefinitions}&expand=${ShowcaseExpand.Personas}&expand=${ShowcaseExpand.AssetContent}`).expect(200) + expect(response4.body.showcases.length).toBeGreaterThanOrEqual(2) + expect(response4.body.showcases[0].scenarios.length).toBeGreaterThanOrEqual(1) + expect(response4.body.showcases[0].credentialDefinitions.length).toBeGreaterThanOrEqual(1) + expect(response4.body.showcases[0].personas.length).toBeGreaterThanOrEqual(1) + expect(response4.body.showcases[0].completionMessage).toBeDefined() + + // Check if at least one showcase has a banner image with content + const showcaseWithBanner = response4.body.showcases.find((showcase: Showcase) => showcase.bannerImage && typeof showcase.bannerImage === 'object') + if (showcaseWithBanner) { + expect(showcaseWithBanner.bannerImage).toHaveProperty('id') + expect(showcaseWithBanner.bannerImage).toHaveProperty('content') + } + }) + + it('should handle mixed valid and invalid expand parameters', async () => { + // Create prerequisites: asset, credential schema, credential definition, issuer, persona, and scenario + const assetRepository = Container.get(AssetRepository) + const asset = await assetRepository.create({ + mediaType: 'image/png', + fileName: 'test.png', + description: 'Test image', + content: Buffer.from('binary data'), + }) + + const credentialSchemaRepository = Container.get(CredentialSchemaRepository) + const credentialSchema = await credentialSchemaRepository.create({ + name: 'example_name', + version: 'example_version', + identifierType: IdentifierType.DID, + identifier: 'did:sov:XUeUZauFLeBNofY3NhaZCB', + attributes: [ + { + name: 'example_attribute_name1', + value: 'example_attribute_value1', + type: CredentialAttributeType.STRING, + }, + { + name: 'example_attribute_name2', + value: 'example_attribute_value2', + type: CredentialAttributeType.STRING, + }, + ], + }) + + const credentialDefinitionRepository = Container.get(CredentialDefinitionRepository) + const credentialDefinition = await credentialDefinitionRepository.create({ + name: 'Test Definition', + version: '1.0', + identifierType: IdentifierType.DID, + identifier: 'did:test:123', + icon: asset.id, + type: CredentialType.ANONCRED, + credentialSchema: credentialSchema.id, + }) + + const issuerRepository = Container.get(IssuerRepository) + const issuer = await issuerRepository.create({ + name: 'Test Issuer', + type: IssuerType.ARIES, + credentialDefinitions: [credentialDefinition.id], + credentialSchemas: [credentialSchema.id], + description: 'Test issuer description', + organization: 'Test Organization', + logo: asset.id, + }) + + // Create a persona + const personaRepository = Container.get(PersonaRepository) + const persona = await personaRepository.create({ + name: 'John Doe', + role: 'Software Engineer', + description: 'Experienced developer', + headshotImage: asset.id, + bodyImage: asset.id, + hidden: false, + }) + + // Create an issuance scenario with at least one step + const scenarioRepository = Container.get(ScenarioRepository) + const scenario = await scenarioRepository.create({ + name: 'Test Scenario', + description: 'Test scenario description', + issuer: issuer.id, // This makes it an issuance scenario + steps: [ + { + title: 'Test Step', + description: 'Test step description', + order: 1, + type: StepType.HUMAN_TASK, + asset: asset.id, + actions: [ + { + title: 'Test Action', + actionType: StepActionType.ARIES_OOB, + text: 'Test action text', + proofRequest: { + attributes: { + attribute1: { + attributes: ['attribute1', 'attribute2'], + restrictions: ['restriction1', 'restriction2'], + }, + }, + predicates: {}, + }, + }, + ], + }, + ], + personas: [persona.id], + hidden: false, + }) + + const showcaseRequest: ShowcaseRequest = { + name: 'Mixed Expand Test', + description: 'Testing mixed valid and invalid expand parameters', + status: ShowcaseStatus.ACTIVE, + hidden: false, + scenarios: [scenario.id], + credentialDefinitions: [credentialDefinition.id], + personas: [persona.id], + bannerImage: asset.id, + completionMessage: 'Mixed expand test completion message', + } + + const createResponse = await request.post('/showcases').send(showcaseRequest).expect(201) + const createdShowcase = createResponse.body.showcase + + // Send request with valid and invalid expand parameters + const getResponse = await request.get(`/showcases/${createdShowcase.slug}?expand=${ShowcaseExpand.Scenarios}&expand=invalidExpand&expand=${ShowcaseExpand.Personas}`).expect(200) + + // Verify valid expands are processed and invalid ones are ignored + expect(getResponse.body.showcase.scenarios.length).toEqual(1) + expect(getResponse.body.showcase.personas.length).toEqual(1) + expect(getResponse.body.showcase.credentialDefinitions).toEqual([]) + expect(getResponse.body.showcase.completionMessage).toEqual('Mixed expand test completion message') + }) }) diff --git a/apps/credential-showcase-api-server/src/database/repositories/ShowcaseRepository.ts b/apps/credential-showcase-api-server/src/database/repositories/ShowcaseRepository.ts index 18a4ca0..72191b2 100644 --- a/apps/credential-showcase-api-server/src/database/repositories/ShowcaseRepository.ts +++ b/apps/credential-showcase-api-server/src/database/repositories/ShowcaseRepository.ts @@ -1,4 +1,4 @@ -import { inArray, eq } from 'drizzle-orm' +import { eq, inArray } from 'drizzle-orm' import { Service } from 'typedi' import { BadRequestError } from 'routing-controllers' import DatabaseService from '../../services/DatabaseService' @@ -11,14 +11,26 @@ import { generateSlug } from '../../utils/slug' import { NotFoundError } from '../../errors' import { credentialDefinitions, - showcasesToCredentialDefinitions, - showcases, - scenarios, personas, + scenarios, + showcases, + showcasesToCredentialDefinitions, showcasesToPersonas, showcasesToScenarios, } from '../schema' -import { Showcase, NewShowcase, RepositoryDefinition } from '../../types' +import { + CredentialDefinition, + CredentialSchema, + Issuer, + NewShowcase, + Persona, + RelyingParty, + RepositoryDefinition, + Scenario, + Showcase, + ShowcaseExpand, + Step, +} from '../../types' @Service() class ShowcaseRepository implements RepositoryDefinition { @@ -30,6 +42,7 @@ class ShowcaseRepository implements RepositoryDefinition private readonly assetRepository: AssetRepository, ) {} + // TODO should we return the asset objects, or just the IDs? async create(showcase: NewShowcase): Promise { if (showcase.personas.length === 0) { return Promise.reject(new BadRequestError('At least one persona is required')) @@ -240,6 +253,7 @@ class ShowcaseRepository implements RepositoryDefinition await (await this.databaseService.getConnection()).delete(showcases).where(eq(showcases.id, id)) } + // TODO should we return the asset objects, or just the IDs? async update(id: string, showcase: NewShowcase): Promise { await this.findById(id) if (showcase.personas.length === 0) { @@ -454,169 +468,300 @@ class ShowcaseRepository implements RepositoryDefinition }) } - async findById(id: string): Promise { - const prepared = (await this.databaseService.getConnection()).query.showcases - .findFirst({ - where: eq(showcases.id, id), + async findById(id: string, expand?: ShowcaseExpand[]): Promise { + const expandSet = new Set(expand || []) + + // Define our query structure based on what should be included + let queryConfig: any = { + where: eq(showcases.id, id), + with: {}, + } + + if (expandSet.has(ShowcaseExpand.ASSET_CONTENT)) { + queryConfig.with.bannerImage = true + } + + // Add credentialDefinitions if needed + if (expandSet.has(ShowcaseExpand.CREDENTIAL_DEFINITIONS)) { + queryConfig.with.credentialDefinitions = { with: { - credentialDefinitions: { + credentialDefinition: { with: { - credentialDefinition: { + // Only include icon if ASSET_CONTENT is in the expands + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { icon: true } : {}), + cs: { with: { - icon: true, - cs: { - with: { - attributes: true, - }, - }, - representations: true, - revocation: true, + attributes: true, }, }, + representations: true, + revocation: true, }, }, - scenarios: { + }, + } + } + + // Add scenarios if needed + if (expandSet.has(ShowcaseExpand.SCENARIOS)) { + queryConfig.with.scenarios = { + with: { + scenario: { with: { - scenario: { + steps: { with: { - steps: { + actions: { with: { - actions: { - with: { - proofRequest: true, - }, - }, - asset: true, + proofRequest: true, }, }, - issuer: { + // Only include asset if ASSET_CONTENT is in the expands + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { asset: true } : {}), + }, + }, + issuer: { + with: { + cds: { with: { - cds: { + cd: { with: { - cd: { + // Only include icon if ASSET_CONTENT is in the expands + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { icon: true } : {}), + cs: { with: { - icon: true, - cs: { - with: { - attributes: true, - }, - }, - representations: true, - revocation: true, + attributes: true, }, }, + representations: true, + revocation: true, }, }, - css: { + }, + }, + css: { + with: { + cs: { with: { - cs: { - with: { - attributes: true, - }, - }, + attributes: true, }, }, - logo: true, }, }, - relyingParty: { + // Only include logo if ASSET_CONTENT is in the expands + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { logo: true } : {}), + }, + }, + relyingParty: { + with: { + cds: { with: { - cds: { + cd: { with: { - cd: { + // Only include icon if ASSET_CONTENT is in the expands + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { icon: true } : {}), + cs: { with: { - icon: true, - cs: { - with: { - attributes: true, - }, - }, - representations: true, - revocation: true, + attributes: true, }, }, + representations: true, + revocation: true, }, }, - logo: true, }, }, - personas: { + // Only include logo if ASSET_CONTENT is in the expands + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { logo: true } : {}), + }, + }, + personas: { + with: { + persona: { with: { - persona: { - with: { - headshotImage: true, - bodyImage: true, - }, - }, + // Only include images if ASSET_CONTENT is in the expands + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) + ? { + headshotImage: true, + bodyImage: true, + } + : {}), }, }, }, }, }, }, - personas: { + }, + } + } + + // Add personas if needed + if (expandSet.has(ShowcaseExpand.PERSONAS)) { + queryConfig.with.personas = { + with: { + persona: { with: { - persona: { - with: { - headshotImage: true, - bodyImage: true, - }, - }, + // Only include images if ASSET_CONTENT is in the expands + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) + ? { + headshotImage: true, + bodyImage: true, + } + : {}), }, }, - bannerImage: true, }, - }) - .prepare('statement_name') + } + } - const result = await prepared.execute() + const connection = await this.databaseService.getConnection() + const result = await connection.query.showcases.findFirst(queryConfig) if (!result) { return Promise.reject(new NotFoundError(`No showcase found for id: ${id}`)) } - return { + // Create a typed showcase result + const showcase: Showcase = { ...result, - scenarios: result.scenarios.map((scenario) => ({ - ...(scenario.scenario as any), - steps: sortSteps(scenario.scenario.steps), - ...(scenario.scenario.relyingParty && { - relyingParty: { - ...(scenario.scenario.relyingParty as any), // TODO check this typing issue at a later point in time - credentialDefinitions: scenario.scenario.relyingParty!.cds.map((credentialDefinition) => credentialDefinition.cd), - }, - }), - ...(scenario.scenario.issuer && { - issuer: { - ...(scenario.scenario.issuer as any), // TODO check this typing issue at a later point in time - credentialDefinitions: scenario.scenario.issuer!.cds.map((credentialDefinition) => credentialDefinition.cd), - credentialSchemas: scenario.scenario.issuer!.css.map((credentialSchema: any) => credentialSchema.cs), - }, - }), - personas: scenario.scenario.personas.map((item) => item.persona), - })), - credentialDefinitions: result.credentialDefinitions.map((item: any) => ({ - ...item.credentialDefinition, - credentialSchema: item.credentialDefinition.cs, - })), - personas: result.personas.map((item) => item.persona), + scenarios: [], + credentialDefinitions: [], + personas: [], + } + + // Process scenarios if they are to be expanded + if (expandSet.has(ShowcaseExpand.SCENARIOS) && 'scenarios' in result && Array.isArray(result.scenarios)) { + // Create a properly typed array for scenarios + const scenariosArray: Scenario[] = [] + + for (const scenarioJoin of result.scenarios) { + if (!scenarioJoin.scenario) continue + + // Create a type-safe copy of the scenario data + const scenarioObj = scenarioJoin.scenario as any + + // Process steps if they exist + let processedSteps: Step[] = [] + if (scenarioObj.steps) { + processedSteps = sortSteps(scenarioObj.steps) as Step[] + } + + // Process relying party if it exists + let processedRelyingParty: RelyingParty | undefined = undefined + if (scenarioObj.relyingParty) { + processedRelyingParty = { + ...scenarioObj.relyingParty, + credentialDefinitions: scenarioObj.relyingParty.cds.map((cd: { cd: CredentialDefinition }) => cd.cd), + } as RelyingParty + } + + // Process issuer if it exists + let processedIssuer: Issuer | undefined = undefined + if (scenarioObj.issuer) { + processedIssuer = { + ...scenarioObj.issuer, + credentialDefinitions: scenarioObj.issuer.cds.map((cd: { cd: CredentialDefinition }) => cd.cd), + credentialSchemas: scenarioObj.issuer.css.map((cs: { cs: CredentialSchema }) => cs.cs), + } as Issuer + } + + // Process personas if they exist + let processedPersonas: Persona[] = [] + if (scenarioObj.personas) { + processedPersonas = scenarioObj.personas.map((p: { persona: Persona }) => p.persona) + } + + // Create the final scenario object with explicit typing + const finalScenario: Scenario = { + ...scenarioObj, + steps: processedSteps, + personas: processedPersonas, + } + + // Add relying party and issuer conditionally + if (processedRelyingParty && 'relyingParty' in finalScenario) { + finalScenario.relyingParty = processedRelyingParty + } + + if (processedIssuer && 'issuer' in finalScenario) { + finalScenario.issuer = processedIssuer + } + + scenariosArray.push(finalScenario) + } + + showcase.scenarios = scenariosArray + } + + // Process credential definitions if they should be expanded + if (expandSet.has(ShowcaseExpand.CREDENTIAL_DEFINITIONS) && 'credentialDefinitions' in result && Array.isArray(result.credentialDefinitions)) { + const credentialDefinitionsArray: CredentialDefinition[] = [] + + for (const cdJoin of result.credentialDefinitions) { + if (!cdJoin.credentialDefinition) continue + + const cdObj = cdJoin.credentialDefinition as any + + credentialDefinitionsArray.push({ + ...cdObj, + credentialSchema: cdObj.cs, + } as CredentialDefinition) + } + + showcase.credentialDefinitions = credentialDefinitionsArray + } + + // Process personas if they should be expanded + if (expandSet.has(ShowcaseExpand.PERSONAS) && 'personas' in result && Array.isArray(result.personas)) { + const personasArray: Persona[] = [] + + for (const personaJoin of result.personas) { + if (!personaJoin.persona) continue + + personasArray.push(personaJoin.persona as Persona) + } + + showcase.personas = personasArray } + + return showcase } - async findAll(): Promise { + async findAll(expand?: ShowcaseExpand[]): Promise { + const expandSet = new Set(expand || []) + + // Define our query structure based on what should be included + let queryConfig: any = { + with: {}, + } + + if (expandSet.has(ShowcaseExpand.ASSET_CONTENT)) { + queryConfig.with.bannerImage = true + } + const connection = await this.databaseService.getConnection() - const showcases = await connection.query.showcases.findMany({ - with: { bannerImage: true }, - }) - const showcaseIds = showcases.map((s: any) => s.id) + const showcasesResult = await connection.query.showcases.findMany(queryConfig) + + if (showcasesResult.length === 0) { + return [] + } + + const showcaseIds = showcasesResult.map((s) => s.id) - const [credDefData, scenariosData, personasData] = await Promise.all([ - connection.query.showcasesToCredentialDefinitions.findMany({ + // Initialize arrays for collecting expanded data + let credDefData: any[] = [] + let scenariosData: any[] = [] + let personasData: any[] = [] + + // Fetch credential definitions if needed + if (expandSet.has(ShowcaseExpand.CREDENTIAL_DEFINITIONS)) { + credDefData = await connection.query.showcasesToCredentialDefinitions.findMany({ where: inArray(showcasesToCredentialDefinitions.showcase, showcaseIds), with: { credentialDefinition: { with: { - icon: true, + // Only include icon if ASSET_CONTENT is in the expands + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { icon: true } : {}), cs: { with: { attributes: true, @@ -627,8 +772,12 @@ class ShowcaseRepository implements RepositoryDefinition }, }, }, - }), - connection.query.showcasesToScenarios.findMany({ + }) + } + + // Fetch scenarios if needed + if (expandSet.has(ShowcaseExpand.SCENARIOS)) { + scenariosData = await connection.query.showcasesToScenarios.findMany({ where: inArray(showcasesToScenarios.showcase, showcaseIds), with: { scenario: { @@ -640,7 +789,8 @@ class ShowcaseRepository implements RepositoryDefinition proofRequest: true, }, }, - asset: true, + // Only include asset if ASSET_CONTENT is in the expands + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { asset: true } : {}), }, }, issuer: { @@ -649,7 +799,8 @@ class ShowcaseRepository implements RepositoryDefinition with: { cd: { with: { - icon: true, + // Only include icon if ASSET_CONTENT is in the expands + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { icon: true } : {}), cs: { with: { attributes: true, @@ -670,7 +821,8 @@ class ShowcaseRepository implements RepositoryDefinition }, }, }, - logo: true, + // Only include logo if ASSET_CONTENT is in the expands + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { logo: true } : {}), }, }, relyingParty: { @@ -679,7 +831,8 @@ class ShowcaseRepository implements RepositoryDefinition with: { cd: { with: { - icon: true, + // Only include icon if ASSET_CONTENT is in the expands + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { icon: true } : {}), cs: { with: { attributes: true, @@ -691,15 +844,21 @@ class ShowcaseRepository implements RepositoryDefinition }, }, }, - logo: true, + // Only include logo if ASSET_CONTENT is in the expands + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { logo: true } : {}), }, }, personas: { with: { persona: { with: { - headshotImage: true, - bodyImage: true, + // Only include images if ASSET_CONTENT is in the expands + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) + ? { + headshotImage: true, + bodyImage: true, + } + : {}), }, }, }, @@ -707,22 +866,34 @@ class ShowcaseRepository implements RepositoryDefinition }, }, }, - }), - connection.query.showcasesToPersonas.findMany({ + }) + } + + // Fetch personas if needed + if (expandSet.has(ShowcaseExpand.PERSONAS)) { + personasData = await connection.query.showcasesToPersonas.findMany({ where: inArray(showcasesToPersonas.showcase, showcaseIds), with: { persona: { with: { - headshotImage: true, - bodyImage: true, + // Only include images if ASSET_CONTENT is in the expands + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) + ? { + headshotImage: true, + bodyImage: true, + } + : {}), }, }, }, - }), - ]) + }) + } - // Group join records by showcase id + // Group data by showcase ID const credDefMap = new Map() + const scenariosMap = new Map() + const personasMap = new Map() + for (const item of credDefData) { const key = item.showcase if (!credDefMap.has(key)) { @@ -731,7 +902,6 @@ class ShowcaseRepository implements RepositoryDefinition credDefMap.get(key)!.push(item) } - const scenariosMap = new Map() for (const item of scenariosData) { const key = item.showcase if (!scenariosMap.has(key)) { @@ -740,7 +910,6 @@ class ShowcaseRepository implements RepositoryDefinition scenariosMap.get(key)!.push(item) } - const personasMap = new Map() for (const item of personasData) { const key = item.showcase if (!personasMap.has(key)) { @@ -749,38 +918,112 @@ class ShowcaseRepository implements RepositoryDefinition personasMap.get(key)!.push(item) } - return showcases.map((showcase: any) => { - return { - ...showcase, - scenarios: (scenariosMap.get(showcase.id) || []).map((s: any) => { - const scenarioData = { ...s.scenario } - scenarioData.steps = sortSteps(s.scenario.steps) - if (s.scenario.relyingParty) { - scenarioData.relyingParty = { - ...s.scenario.relyingParty, - credentialDefinitions: s.scenario.relyingParty.cds.map((item: any) => item.cd), - } + // Process each showcase with its expanded entities + return showcasesResult.map((showcaseData): Showcase => { + const showcase: Showcase = { + ...showcaseData, + scenarios: [], + credentialDefinitions: [], + personas: [], + } + + // Process scenarios if they should be expanded + if (expandSet.has(ShowcaseExpand.SCENARIOS)) { + const scenarioItems = scenariosMap.get(showcaseData.id) || [] + const scenariosArray: Scenario[] = [] + + for (const scenarioJoin of scenarioItems) { + if (!scenarioJoin.scenario) continue + + const scenarioObj = scenarioJoin.scenario as any + + // Process steps + let processedSteps: Step[] = [] + if (scenarioObj.steps) { + processedSteps = sortSteps(scenarioObj.steps) as Step[] + } + + // Process relying party + let processedRelyingParty: RelyingParty | undefined = undefined + if (scenarioObj.relyingParty) { + processedRelyingParty = { + ...scenarioObj.relyingParty, + credentialDefinitions: scenarioObj.relyingParty.cds.map((cd: { cd: CredentialDefinition }) => cd.cd), + } as RelyingParty } - if (s.scenario.issuer) { - scenarioData.issuer = { - ...s.scenario.issuer, - credentialDefinitions: s.scenario.issuer.cds.map((item: any) => item.cd), - credentialSchemas: s.scenario.issuer.css.map((item: any) => item.cs), - } + + // Process issuer + let processedIssuer: Issuer | undefined = undefined + if (scenarioObj.issuer) { + processedIssuer = { + ...scenarioObj.issuer, + credentialDefinitions: scenarioObj.issuer.cds.map((cd: { cd: CredentialDefinition }) => cd.cd), + credentialSchemas: scenarioObj.issuer.css.map((cs: { cs: CredentialSchema }) => cs.cs), + } as Issuer + } + + // Process personas + let processedPersonas: Persona[] = [] + if (scenarioObj.personas) { + processedPersonas = scenarioObj.personas.map((p: { persona: Persona }) => p.persona) } - // TODO check this typing issue at a later point in time - scenarioData.personas = s.scenario.personas.map((p: any) => p.persona) - return scenarioData - }), - credentialDefinitions: (credDefMap.get(showcase.id) || []).map((item: any) => { - return { - ...item.credentialDefinition, - credentialSchema: item.credentialDefinition.cs, + + // Create the final scenario object + const finalScenario: Scenario = { + ...scenarioObj, + steps: processedSteps, + personas: processedPersonas, + } + + // Add relying party and issuer conditionally + if (processedRelyingParty && 'relyingParty' in finalScenario) { + finalScenario.relyingParty = processedRelyingParty } - // TODO check this typing issue at a later point in time - }), - personas: (personasMap.get(showcase.id) || []).map((item: any) => item.persona), + + if (processedIssuer && 'issuer' in finalScenario) { + finalScenario.issuer = processedIssuer + } + + scenariosArray.push(finalScenario) + } + + showcase.scenarios = scenariosArray + } + + // Process credential definitions if they should be expanded + if (expandSet.has(ShowcaseExpand.CREDENTIAL_DEFINITIONS)) { + const cdItems = credDefMap.get(showcaseData.id) || [] + const credentialDefinitionsArray: CredentialDefinition[] = [] + + for (const cdJoin of cdItems) { + if (!cdJoin.credentialDefinition) continue + + const cdObj = cdJoin.credentialDefinition as any + + credentialDefinitionsArray.push({ + ...cdObj, + credentialSchema: cdObj.cs, + } as CredentialDefinition) + } + + showcase.credentialDefinitions = credentialDefinitionsArray } + + // Process personas if they should be expanded + if (expandSet.has(ShowcaseExpand.PERSONAS)) { + const personaItems = personasMap.get(showcaseData.id) || [] + const personasArray: Persona[] = [] + + for (const personaJoin of personaItems) { + if (!personaJoin.persona) continue + + personasArray.push(personaJoin.persona as Persona) + } + + showcase.personas = personasArray + } + + return showcase }) } diff --git a/apps/credential-showcase-api-server/src/database/repositories/__tests__/showcase.repository.test.ts b/apps/credential-showcase-api-server/src/database/repositories/__tests__/showcase.repository.test.ts index 0c71386..6fd92e2 100644 --- a/apps/credential-showcase-api-server/src/database/repositories/__tests__/showcase.repository.test.ts +++ b/apps/credential-showcase-api-server/src/database/repositories/__tests__/showcase.repository.test.ts @@ -29,6 +29,7 @@ import { NewPersona, NewShowcase, Persona, + ShowcaseExpand, ShowcaseStatus, StepActionType, StepType, @@ -254,11 +255,18 @@ describe('Database showcase repository tests', (): void => { expect(savedShowcase.scenarios.length).toEqual(2) expect(savedShowcase.credentialDefinitions.length).toEqual(2) expect(savedShowcase.personas.length).toEqual(2) - expect(savedShowcase.bannerImage!.id).toBeDefined() - expect(savedShowcase.bannerImage!.mediaType).toEqual(asset.mediaType) - expect(savedShowcase.bannerImage!.fileName).toEqual(asset.fileName) - expect(savedShowcase.bannerImage!.description).toEqual(asset.description) - expect(savedShowcase.bannerImage!.content).toStrictEqual(asset.content) + + // Check banner image + expect(savedShowcase.bannerImage).toBeDefined() + if (!savedShowcase.bannerImage || typeof savedShowcase.bannerImage !== 'object') { + throw Error('expected fromDb.bannerImage to be an asset object') + } + + expect(savedShowcase.bannerImage.id).toBeDefined() + expect(savedShowcase.bannerImage.mediaType).toEqual(asset.mediaType) + expect(savedShowcase.bannerImage.fileName).toEqual(asset.fileName) + expect(savedShowcase.bannerImage.description).toEqual(asset.description) + expect(savedShowcase.bannerImage.content).toStrictEqual(asset.content) }) it('Should throw error when saving showcase with no personas', async (): Promise => { @@ -364,7 +372,35 @@ describe('Database showcase repository tests', (): void => { await expect(repository.create(showcase)).rejects.toThrowError(`No scenario found for id: ${unknownScenarioId}`) }) - it('Should get showcase by id from database', async (): Promise => { + it('Should get showcase by id from database with no expands', async (): Promise => { + const showcase: NewShowcase = { + name: 'example_name', + description: 'example_description', + status: ShowcaseStatus.ACTIVE, + hidden: false, + scenarios: [issuanceScenario1.id, issuanceScenario2.id], + credentialDefinitions: [credentialDefinition1.id, credentialDefinition2.id], + personas: [persona1.id, persona2.id], + } + + const savedShowcase = await repository.create(showcase) + expect(savedShowcase).toBeDefined() + + // Get showcase with no expands + const fromDb = await repository.findById(savedShowcase.id, []) + + expect(fromDb).toBeDefined() + expect(fromDb.name).toEqual(showcase.name) + expect(fromDb.description).toEqual(showcase.description) + expect(fromDb.status).toEqual(showcase.status) + expect(fromDb.hidden).toEqual(showcase.hidden) + expect(fromDb.scenarios).toEqual([]) + expect(fromDb.credentialDefinitions).toEqual([]) + expect(fromDb.personas).toEqual([]) + expect(fromDb.bannerImage).toBeNull() // bannerImage is undefined when not expanded + }) + + it('Should get showcase by id from database with all expands including asset content', async (): Promise => { const showcase: NewShowcase = { name: 'example_name', description: 'example_description', @@ -373,12 +409,19 @@ describe('Database showcase repository tests', (): void => { scenarios: [issuanceScenario1.id, issuanceScenario2.id], credentialDefinitions: [credentialDefinition1.id, credentialDefinition2.id], personas: [persona1.id, persona2.id], + bannerImage: asset.id, } const savedShowcase = await repository.create(showcase) expect(savedShowcase).toBeDefined() - const fromDb = await repository.findById(savedShowcase.id) + // Get showcase with all expands including asset content + const fromDb = await repository.findById(savedShowcase.id, [ + ShowcaseExpand.SCENARIOS, + ShowcaseExpand.CREDENTIAL_DEFINITIONS, + ShowcaseExpand.PERSONAS, + ShowcaseExpand.ASSET_CONTENT, + ]) expect(fromDb).toBeDefined() expect(fromDb.name).toEqual(showcase.name) @@ -388,9 +431,75 @@ describe('Database showcase repository tests', (): void => { expect(fromDb.scenarios.length).toEqual(2) expect(fromDb.credentialDefinitions.length).toEqual(2) expect(fromDb.personas.length).toEqual(2) + + // Check that bannerImage is an object with content + expect(fromDb.bannerImage).toBeDefined() + if (!fromDb.bannerImage || typeof fromDb.bannerImage !== 'object') { + throw Error('expected fromDb.bannerImage to be an asset object') + } + expect(fromDb.bannerImage.id).toBeDefined() + expect(fromDb.bannerImage.mediaType).toEqual(asset.mediaType) + expect(fromDb.bannerImage.fileName).toEqual(asset.fileName) + expect(fromDb.bannerImage.description).toEqual(asset.description) + expect(fromDb.bannerImage.content).toBeDefined() + expect(Buffer.isBuffer(fromDb.bannerImage.content)).toBeTruthy() }) - it('Should get all showcases from database', async (): Promise => { + it('Should get showcase by id with relations expanded but without asset content', async (): Promise => { + const showcase: NewShowcase = { + name: 'example_name', + description: 'example_description', + status: ShowcaseStatus.ACTIVE, + hidden: false, + scenarios: [issuanceScenario1.id, issuanceScenario2.id], + credentialDefinitions: [credentialDefinition1.id, credentialDefinition2.id], + personas: [persona1.id, persona2.id], + bannerImage: asset.id, + } + + const savedShowcase = await repository.create(showcase) + expect(savedShowcase).toBeDefined() + + // Get showcase with relations expanded but without asset content + const fromDb = await repository.findById(savedShowcase.id, [ + ShowcaseExpand.SCENARIOS, + ShowcaseExpand.CREDENTIAL_DEFINITIONS, + ShowcaseExpand.PERSONAS, + ]) + + expect(fromDb).toBeDefined() + expect(fromDb.name).toEqual(showcase.name) + expect(fromDb.description).toEqual(showcase.description) + expect(fromDb.status).toEqual(showcase.status) + expect(fromDb.hidden).toEqual(showcase.hidden) + expect(fromDb.scenarios.length).toEqual(2) + expect(fromDb.credentialDefinitions.length).toEqual(2) + expect(fromDb.personas.length).toEqual(2) + + // Check assets are not included or are string IDs + expect(fromDb.bannerImage).toBeDefined() + + // Asset references should be string IDs when ASSET_CONTENT is not expanded + expect(typeof fromDb.bannerImage).toBe('string') + expect(fromDb.bannerImage).toBe(asset.id) + + // Check that persona image references don't have content + for (const persona of fromDb.personas) { + expect(typeof persona.headshotImage).toBe('string') + expect(typeof persona.bodyImage).toBe('string') + } + + // Check that scenario assets don't have content + for (const scenario of fromDb.scenarios) { + for (const step of scenario.steps) { + if (step.asset && typeof step.asset === 'object') { + expect(step.asset.content).not.toBeDefined() + } + } + } + }) + + it('Should get all showcases from database with no expands', async (): Promise => { const showcase: NewShowcase = { name: 'example_name', description: 'example_description', @@ -407,10 +516,151 @@ describe('Database showcase repository tests', (): void => { const savedShowcase2 = await repository.create(showcase) expect(savedShowcase2).toBeDefined() - const fromDb = await repository.findAll() + const fromDb = await repository.findAll([]) expect(fromDb).toBeDefined() expect(fromDb.length).toEqual(2) + fromDb.forEach((showcase) => { + expect(showcase.scenarios).toEqual([]) + expect(showcase.credentialDefinitions).toEqual([]) + expect(showcase.personas).toEqual([]) + expect(showcase.bannerImage).toBeNull() + }) + }) + + it('Should get all showcases from database with all expands including asset content', async (): Promise => { + const showcase: NewShowcase = { + name: 'example_name', + description: 'example_description', + status: ShowcaseStatus.ACTIVE, + hidden: false, + scenarios: [issuanceScenario1.id, issuanceScenario2.id], + credentialDefinitions: [credentialDefinition1.id, credentialDefinition2.id], + personas: [persona1.id, persona2.id], + bannerImage: asset.id, + } + + const savedShowcase1 = await repository.create(showcase) + expect(savedShowcase1).toBeDefined() + + const savedShowcase2 = await repository.create(showcase) + expect(savedShowcase2).toBeDefined() + + const fromDb = await repository.findAll([ + ShowcaseExpand.SCENARIOS, + ShowcaseExpand.CREDENTIAL_DEFINITIONS, + ShowcaseExpand.PERSONAS, + ShowcaseExpand.ASSET_CONTENT, + ]) + + expect(fromDb).toBeDefined() + expect(fromDb.length).toEqual(2) + fromDb.forEach((showcase) => { + expect(showcase.scenarios.length).toEqual(2) + expect(showcase.credentialDefinitions.length).toEqual(2) + expect(showcase.personas.length).toEqual(2) + + // Check that bannerImage has content + if (typeof showcase.bannerImage === 'object' && showcase.bannerImage !== null) { + expect(showcase.bannerImage.content).toBeDefined() + expect(Buffer.isBuffer(showcase.bannerImage.content)).toBeTruthy() + } + }) + }) + + it('Should get all showcases from database with relations expanded but without asset content', async (): Promise => { + const showcase: NewShowcase = { + name: 'example_name', + description: 'example_description', + status: ShowcaseStatus.ACTIVE, + hidden: false, + scenarios: [issuanceScenario1.id, issuanceScenario2.id], + credentialDefinitions: [credentialDefinition1.id, credentialDefinition2.id], + personas: [persona1.id, persona2.id], + bannerImage: asset.id, + } + + const savedShowcase1 = await repository.create(showcase) + expect(savedShowcase1).toBeDefined() + + const savedShowcase2 = await repository.create(showcase) + expect(savedShowcase2).toBeDefined() + + const fromDb = await repository.findAll([ShowcaseExpand.SCENARIOS, ShowcaseExpand.CREDENTIAL_DEFINITIONS, ShowcaseExpand.PERSONAS]) + + expect(fromDb).toBeDefined() + expect(fromDb.length).toEqual(2) + fromDb.forEach((showcase) => { + expect(showcase.scenarios.length).toEqual(2) + expect(showcase.credentialDefinitions.length).toEqual(2) + expect(showcase.personas.length).toEqual(2) + + // Check assets are string IDs or objects without content + if (showcase.bannerImage) { + if (typeof showcase.bannerImage === 'string') { + expect(showcase.bannerImage).toBe(asset.id) + } else if (typeof showcase.bannerImage === 'object') { + expect(showcase.bannerImage.id).toBeDefined() + expect(showcase.bannerImage.content).not.toBeDefined() + } + } + + // Check persona assets + for (const persona of showcase.personas) { + if (persona.headshotImage && typeof persona.headshotImage === 'object') { + expect(persona.headshotImage.content).not.toBeDefined() + } + if (persona.bodyImage && typeof persona.bodyImage === 'object') { + expect(persona.bodyImage.content).not.toBeDefined() + } + } + }) + }) + + it('Should get all showcases from database with all expands', async (): Promise => { + const showcase: NewShowcase = { + name: 'example_name', + description: 'example_description', + status: ShowcaseStatus.ACTIVE, + hidden: false, + scenarios: [issuanceScenario1.id, issuanceScenario2.id], + credentialDefinitions: [credentialDefinition1.id, credentialDefinition2.id], + personas: [persona1.id, persona2.id], + } + + const savedShowcase1 = await repository.create(showcase) + expect(savedShowcase1).toBeDefined() + + const savedShowcase2 = await repository.create(showcase) + expect(savedShowcase2).toBeDefined() + + const fromDb = await repository.findAll([ShowcaseExpand.SCENARIOS, ShowcaseExpand.CREDENTIAL_DEFINITIONS, ShowcaseExpand.PERSONAS]) + + expect(fromDb).toBeDefined() + expect(fromDb.length).toEqual(2) + fromDb.forEach((showcase) => { + expect(showcase.scenarios.length).toEqual(2) + expect(showcase.credentialDefinitions.length).toEqual(2) + expect(showcase.personas.length).toEqual(2) + }) + }) + + it('Should find id by slug', async (): Promise => { + const showcase: NewShowcase = { + name: 'example_name', + description: 'example_description', + status: ShowcaseStatus.ACTIVE, + hidden: false, + scenarios: [issuanceScenario1.id, issuanceScenario2.id], + credentialDefinitions: [credentialDefinition1.id, credentialDefinition2.id], + personas: [persona1.id, persona2.id], + } + + const savedShowcase = await repository.create(showcase) + expect(savedShowcase).toBeDefined() + + const id = await repository.findIdBySlug('example-name') + expect(id).toEqual(savedShowcase.id) }) it('Should delete showcase from database', async (): Promise => { diff --git a/apps/credential-showcase-api-server/src/services/ShowcaseService.ts b/apps/credential-showcase-api-server/src/services/ShowcaseService.ts index 36b2956..a9ccbcb 100644 --- a/apps/credential-showcase-api-server/src/services/ShowcaseService.ts +++ b/apps/credential-showcase-api-server/src/services/ShowcaseService.ts @@ -1,17 +1,18 @@ import { Service } from 'typedi' import ShowcaseRepository from '../database/repositories/ShowcaseRepository' import { Showcase, NewShowcase } from '../types' +import { ShowcaseExpand } from 'credential-showcase-openapi' @Service() class ShowcaseService { constructor(private readonly showcaseRepository: ShowcaseRepository) {} - public getShowcases = async (): Promise => { - return this.showcaseRepository.findAll() + public getShowcases = async (expand?: ShowcaseExpand[]): Promise => { + return this.showcaseRepository.findAll(expand) } - public getShowcase = async (id: string): Promise => { - return this.showcaseRepository.findById(id) + public getShowcase = async (id: string, expand?: ShowcaseExpand[]): Promise => { + return this.showcaseRepository.findById(id, expand) } public createShowcase = async (showcase: NewShowcase): Promise => { diff --git a/apps/credential-showcase-api-server/src/types/schema/index.ts b/apps/credential-showcase-api-server/src/types/schema/index.ts index dcfb463..adec7f6 100644 --- a/apps/credential-showcase-api-server/src/types/schema/index.ts +++ b/apps/credential-showcase-api-server/src/types/schema/index.ts @@ -22,8 +22,8 @@ export type Asset = typeof assets.$inferSelect export type NewAsset = typeof assets.$inferInsert & { fileName?: string | null; description?: string | null } export type Persona = Omit & { - headshotImage: Asset | null - bodyImage: Asset | null + headshotImage: string | Asset | null + bodyImage: string | Asset | null } export type NewPersona = Omit & { headshotImage?: string | null @@ -72,7 +72,7 @@ export type NewRevocationInfo = Omit & { credentialDefinitions: CredentialDefinition[] - logo: Asset | null + logo: string | Asset | null } export type NewRelyingParty = Omit & { credentialDefinitions: string[] @@ -83,7 +83,7 @@ export type NewRelyingParty = Omit & export type Issuer = Omit & { credentialDefinitions: CredentialDefinition[] credentialSchemas: CredentialSchema[] - logo: Asset | null + logo: string | Asset | null } export type NewIssuer = Omit & { credentialDefinitions: string[] @@ -140,7 +140,7 @@ export type IssuanceScenario = Omit & { personas: string[] @@ -154,7 +154,7 @@ export type PresentationScenario = Omit & { personas: string[] @@ -166,7 +166,7 @@ export type NewPresentationScenario = Omit & { actions: AriesOOBAction[] - asset?: Asset | null + asset?: string | Asset | null } export type NewStep = Omit & { asset?: string | null @@ -200,7 +200,7 @@ export type Showcase = Omit & { scenarios: Scenario[] credentialDefinitions: CredentialDefinition[] personas: Persona[] - bannerImage?: Asset | null + bannerImage?: string | Asset | null } export type NewShowcase = Omit & { scenarios: string[] @@ -219,3 +219,12 @@ export enum ShowcaseStatus { ACTIVE = 'ACTIVE', ARCHIVED = 'ARCHIVED', } + +export const ShowcaseExpand = { + SCENARIOS: 'SCENARIOS', + CREDENTIAL_DEFINITIONS: 'CREDENTIAL_DEFINITIONS', + PERSONAS: 'PERSONAS', + ASSET_CONTENT: 'ASSET_CONTENT' +} as const; + +export type ShowcaseExpand = typeof ShowcaseExpand[keyof typeof ShowcaseExpand]; \ No newline at end of file diff --git a/apps/credential-showcase-api-server/src/utils/mappers.ts b/apps/credential-showcase-api-server/src/utils/mappers.ts index 2b930a0..7c22462 100644 --- a/apps/credential-showcase-api-server/src/utils/mappers.ts +++ b/apps/credential-showcase-api-server/src/utils/mappers.ts @@ -61,7 +61,10 @@ export const credentialDefinitionDTOFrom = (credentialDefinition: CredentialDefi credentialSchema: credentialSchemaDTOFrom(credentialDefinition.credentialSchema), representations: credentialDefinition.representations, revocation: credentialDefinition.revocation || undefined, - icon: assetDTOFrom(credentialDefinition.icon), + iconId: typeof credentialDefinition.icon === 'string' ? credentialDefinition.icon : undefined, + icon: credentialDefinition.icon && typeof credentialDefinition.icon !== 'string' + ? assetDTOFrom(credentialDefinition.icon as Asset) + : undefined, } } @@ -69,8 +72,11 @@ export const relyingPartyDTOFrom = (relyingParty: RelyingParty): RelyingPartyDTO return { ...relyingParty, organization: relyingParty.organization || undefined, - logo: relyingParty.logo ? assetDTOFrom(relyingParty.logo) : undefined, - credentialDefinitions: relyingParty.credentialDefinitions.map(credentialDefinitionDTOFrom), + logoId: typeof relyingParty.logo === 'string' ? relyingParty.logo : undefined, + logo: relyingParty.logo && typeof relyingParty.logo !== 'string' + ? assetDTOFrom(relyingParty.logo as Asset) + : undefined, + credentialDefinitions: relyingParty.credentialDefinitions.map(credentialDefinitionDTOFrom) } } @@ -78,9 +84,12 @@ export const issuerDTOFrom = (issuer: Issuer): IssuerDTO => { return { ...issuer, organization: issuer.organization || undefined, - logo: issuer.logo ? assetDTOFrom(issuer.logo) : undefined, + logoId: typeof issuer.logo === 'string' ? issuer.logo : undefined, + logo: issuer.logo && typeof issuer.logo !== 'string' + ? assetDTOFrom(issuer.logo as Asset) + : undefined, credentialDefinitions: issuer.credentialDefinitions.map(credentialDefinitionDTOFrom), - credentialSchemas: issuer.credentialSchemas.map(credentialSchemaDTOFrom), + credentialSchemas: issuer.credentialSchemas.map(credentialSchemaDTOFrom) } } @@ -126,17 +135,26 @@ export const scenarioDTOFrom = (scenario: Scenario): IssuanceScenarioDTO | Prese export const stepDTOFrom = (step: Step): StepDTO => { return { ...step, - asset: step.asset ? assetDTOFrom(step.asset) : undefined, - subScenario: step.subScenario || undefined, + assetId: typeof step.asset === 'string' ? step.asset : undefined, + asset: step.asset && typeof step.asset !== 'string' + ? assetDTOFrom(step.asset as Asset) + : undefined, + subScenario: step.subScenario || undefined } } export const personaDTOFrom = (persona: Persona): PersonaDTO => { return { ...persona, - headshotImage: persona.headshotImage ? assetDTOFrom(persona.headshotImage) : undefined, - bodyImage: persona.bodyImage ? assetDTOFrom(persona.bodyImage) : undefined, - hidden: persona.hidden, + headshotImageId: typeof persona.headshotImage === 'string' ? persona.headshotImage : undefined, + headshotImage: persona.headshotImage && typeof persona.headshotImage !== 'string' + ? assetDTOFrom(persona.headshotImage as Asset) + : undefined, + bodyImageId: typeof persona.bodyImage === 'string' ? persona.bodyImage : undefined, + bodyImage: persona.bodyImage && typeof persona.bodyImage !== 'string' + ? assetDTOFrom(persona.bodyImage as Asset) + : undefined, + hidden: persona.hidden } } @@ -146,8 +164,11 @@ export const showcaseDTOFrom = (showcase: Showcase): ShowcaseDTO => { personas: showcase.personas.map(personaDTOFrom), credentialDefinitions: showcase.credentialDefinitions.map(credentialDefinitionDTOFrom), scenarios: showcase.scenarios.map(scenarioDTOFrom), - bannerImage: showcase.bannerImage ? assetDTOFrom(showcase.bannerImage) : undefined, - completionMessage: showcase.completionMessage || undefined, + bannerImageId: typeof showcase.bannerImage === 'string' ? showcase.bannerImage : undefined, + bannerImage: showcase.bannerImage && typeof showcase.bannerImage !== 'string' + ? assetDTOFrom(showcase.bannerImage as Asset) + : undefined, + completionMessage: showcase.completionMessage || undefined } } diff --git a/apps/credential-showcase-api-server/src/utils/normalize.ts b/apps/credential-showcase-api-server/src/utils/normalize.ts new file mode 100644 index 0000000..f39a2bc --- /dev/null +++ b/apps/credential-showcase-api-server/src/utils/normalize.ts @@ -0,0 +1,31 @@ +import { ShowcaseExpand } from 'credential-showcase-openapi' + +/** + * Normalizes expand parameters to valid ShowcaseExpand enum values + * + * @param expand - Array of expand parameter strings from the request + * @returns Array of valid ShowcaseExpand enum values + */ +export const normalizeExpandParams = (expand?: string[]): ShowcaseExpand[] => { + const expandMap: Record = { + scenarios: ShowcaseExpand.Scenarios, + credentialdefinitions: ShowcaseExpand.CredentialDefinitions, + credential_definitions: ShowcaseExpand.CredentialDefinitions, + personas: ShowcaseExpand.Personas, + assetcontent: ShowcaseExpand.AssetContent, + asset_content: ShowcaseExpand.AssetContent, + } + + return ( + (expand + ?.map((exp) => { + const normalizedKey = exp.toLowerCase().trim() + if (normalizedKey in expandMap) { + return expandMap[normalizedKey as keyof typeof expandMap] + } + console.warn(`Invalid expand parameter: ${exp}`) + return null + }) + .filter(Boolean) as ShowcaseExpand[]) || [] + ) +} diff --git a/packages/credential-showcase-openapi/openapi/openapi.yaml b/packages/credential-showcase-openapi/openapi/openapi.yaml index 88266cd..27940d7 100644 --- a/packages/credential-showcase-openapi/openapi/openapi.yaml +++ b/packages/credential-showcase-openapi/openapi/openapi.yaml @@ -1525,6 +1525,12 @@ paths: - Showcases summary: List all showcases operationId: listShowcases + parameters: + - name: expand + in: query + required: false + schema: + $ref: '#/components/schemas/ShowcaseExpands' responses: '200': description: OK @@ -1578,6 +1584,12 @@ paths: get: tags: - Showcases + parameters: + - name: expand + in: query + required: false + schema: + $ref: '#/components/schemas/ShowcaseExpands' summary: Get a specific showcase operationId: getShowcase responses: @@ -1780,6 +1792,9 @@ components: type: array items: $ref: '#/components/schemas/StepAction' + assetId: + type: string + description: The asset id asset: $ref: '#/components/schemas/Asset' createdAt: @@ -2073,8 +2088,14 @@ components: type: string description: Detailed description of the persona example: John Doe is a verifier for the system + headshotImageId: + type: string + description: The asset id headshotImage: $ref: '#/components/schemas/Asset' + bodyImageId: + type: string + description: The asset id bodyImage: $ref: '#/components/schemas/Asset' hidden: @@ -2347,6 +2368,9 @@ components: type: string description: Organization the issuer belongs to example: Acme Corporation + logoId: + type: string + description: The asset id logo: $ref: '#/components/schemas/Asset' credentialDefinitions: @@ -2451,6 +2475,9 @@ components: type: string description: Organization the relying party belongs to example: Acme Corporation + logoId: + type: string + description: The asset id logo: $ref: '#/components/schemas/Asset' credentialDefinitions: @@ -2535,7 +2562,6 @@ components: - version - type - credentialSchema - - icon # TODO enable back in SHOWCASE-81 # - representations - createdAt @@ -2573,6 +2599,9 @@ components: oneOf: - $ref: '#/components/schemas/RevocationInfo' - $ref: '#/components/schemas/AnonCredRevocation' + iconId: + type: string + description: The asset id icon: $ref: '#/components/schemas/Asset' createdAt: @@ -2925,6 +2954,9 @@ components: description: List of personas involved in this showcase items: $ref: '#/components/schemas/Persona' + bannerImageId: + type: string + description: The asset id bannerImage: $ref: '#/components/schemas/Asset' completionMessage: @@ -3019,6 +3051,19 @@ components: - PRESENTATION description: Types of supported scenarios example: ISSUANCE + ShowcaseExpands: + type: array + description: Which entities to expand + items: + $ref: '#/components/schemas/ShowcaseExpand' + ShowcaseExpand: + type: string + description: Which entity to expand + enum: + - SCENARIOS + - CREDENTIAL_DEFINITIONS + - PERSONAS + - ASSET_CONTENT responses: 'BadRequest': From b9291674e9e99c96e1d92de53df93970f4456b54 Mon Sep 17 00:00:00 2001 From: sanderPostma Date: Fri, 14 Mar 2025 10:37:39 +0100 Subject: [PATCH 2/8] chore: cleanup & pre-commit fix --- .github/workflows/cicd.yaml | 6 +- .husky/pre-commit | 15 + README.md | 2 +- .../package.json | 2 +- .../src/controllers/ShowcaseController.ts | 3 +- .../ShowcaseController.integration.test.ts | 518 +--- .../migrations/meta/0002_snapshot.json | 364 +-- .../database/migrations/meta/_journal.json | 2 +- .../repositories/ShowcaseRepository.ts | 32 +- .../src/types/schema/index.ts | 6 +- .../src/utils/mappers.ts | 38 +- .../src/utils/normalize.ts | 6 +- docker/dev/README.md | 5 +- docker/dev/docker-compose.yml | 22 +- docker/prod/docker-compose.yml | 42 +- jest.json | 22 +- .../openapi/openapi.yaml | 84 +- pnpm-lock.yaml | 2239 +++++++------- ...ntial-showcase-api.postman_collection.json | 2733 +++++++---------- ...tial-showcase-api.postman_environment.json | 172 +- turbo.json | 4 +- 21 files changed, 2669 insertions(+), 3648 deletions(-) diff --git a/.github/workflows/cicd.yaml b/.github/workflows/cicd.yaml index 9592686..fe9ccb9 100644 --- a/.github/workflows/cicd.yaml +++ b/.github/workflows/cicd.yaml @@ -51,7 +51,7 @@ jobs: steps: - name: Checkout code uses: actions/checkout@v3 - + - name: Configure AWS credentials uses: aws-actions/configure-aws-credentials@v1 with: @@ -78,7 +78,7 @@ jobs: steps: - name: Checkout code uses: actions/checkout@v3 - + - name: Configure AWS credentials uses: aws-actions/configure-aws-credentials@v1 with: @@ -111,7 +111,7 @@ jobs: key: ${{ secrets.VPS_SSH_KEY }} script: | cd /home/${{ secrets.VPS_USERNAME }}/credential-showcase-api - + # Deploy API server if changed if [[ "${{ needs.determine-changes.outputs.api_server }}" == "true" ]]; then export TAG=${{ github.sha }} && sudo -E docker compose -f docker/dev/docker-compose.yml pull credential-showcase-api-server diff --git a/.husky/pre-commit b/.husky/pre-commit index 3c19b90..9a81570 100755 --- a/.husky/pre-commit +++ b/.husky/pre-commit @@ -1 +1,16 @@ + +# Stash unstaged and untracked changes, keeping staged files intact +stash_ref=$(git stash push --keep-index --include-untracked -m "pre-commit-$(date +%s)") +echo "Saved unstaged files to stash, ref: $stash_ref" + +# Run prettier formatting pnpm prettier + +# Stage only previously prettier files +git add -u + +# Restore unstaged changes from stash, if any +if [ "$stash_ref" != "No local changes to save" ]; then + echo "Restoring stash" + git stash pop >/dev/null 2>&1 +fi \ No newline at end of file diff --git a/README.md b/README.md index 036c94e..34a7488 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,7 @@ A TypeScript-based monorepo for the Credential Showcase API, consisting of backe # credential-showcase-api-server -the backend server for the Credential Showcase application. It provides REST API endpoints for managing and showcasing credentials. +the backend server for the Credential Showcase application. It provides REST API endpoints for managing and showcasing credentials. # credential-showcase-openapi diff --git a/apps/credential-showcase-api-server/package.json b/apps/credential-showcase-api-server/package.json index b4b0ac1..e8f610f 100644 --- a/apps/credential-showcase-api-server/package.json +++ b/apps/credential-showcase-api-server/package.json @@ -6,7 +6,7 @@ "types": "dist/index.d.ts", "scripts": { "start": "ts-node src/index.ts", - "dev": "ts-node-dev src/index.ts", + "dev": "ts-node-dev --transpile-only src/index.ts", "build": "tsc", "build:clean": "tsc --build --clean && tsc --build", "migration:generate": "npx drizzle-kit generate --config=drizzle.config.ts --name=credential-showcase-api" diff --git a/apps/credential-showcase-api-server/src/controllers/ShowcaseController.ts b/apps/credential-showcase-api-server/src/controllers/ShowcaseController.ts index ae93703..18d355f 100644 --- a/apps/credential-showcase-api-server/src/controllers/ShowcaseController.ts +++ b/apps/credential-showcase-api-server/src/controllers/ShowcaseController.ts @@ -1,7 +1,8 @@ import { BadRequestError, Body, Delete, Get, HttpCode, JsonController, OnUndefined, Param, Post, Put, QueryParam } from 'routing-controllers' import { Service } from 'typedi' import { - instanceOfShowcaseRequest, ShowcaseExpand, + instanceOfShowcaseRequest, + ShowcaseExpand, ShowcaseRequest, ShowcaseRequestToJSONTyped, ShowcaseResponse, diff --git a/apps/credential-showcase-api-server/src/controllers/__tests__/ShowcaseController.integration.test.ts b/apps/credential-showcase-api-server/src/controllers/__tests__/ShowcaseController.integration.test.ts index d5ab630..d3a4323 100644 --- a/apps/credential-showcase-api-server/src/controllers/__tests__/ShowcaseController.integration.test.ts +++ b/apps/credential-showcase-api-server/src/controllers/__tests__/ShowcaseController.integration.test.ts @@ -19,6 +19,7 @@ import * as schema from '../../database/schema' import { NodePgDatabase } from 'drizzle-orm/node-postgres' import { migrate } from 'drizzle-orm/node-postgres/migrator' import DatabaseService from '../../services/DatabaseService' +import { Buffer } from 'buffer' import supertest = require('supertest') describe('ShowcaseController Integration Tests', () => { @@ -26,36 +27,8 @@ describe('ShowcaseController Integration Tests', () => { let app: Application let request: any - beforeAll(async () => { - client = new PGlite() - const database = drizzle(client, { schema }) as unknown as NodePgDatabase - await migrate(database, { migrationsFolder: './apps/credential-showcase-api-server/src/database/migrations' }) - const mockDatabaseService = { - getConnection: jest.fn().mockResolvedValue(database), - } - Container.set(DatabaseService, mockDatabaseService) - useContainer(Container) - Container.get(AssetRepository) - Container.get(CredentialSchemaRepository) - Container.get(CredentialDefinitionRepository) - Container.get(IssuerRepository) - Container.get(PersonaRepository) - Container.get(ScenarioRepository) - Container.get(ShowcaseRepository) - Container.get(ShowcaseService) - app = createExpressServer({ - controllers: [ShowcaseController], - }) - request = supertest(app) - }) - - afterAll(async () => { - await client.close() - Container.reset() - }) - - it('should create, retrieve, update, and delete a showcase', async () => { - // Create prerequisites: asset, credential schema, credential definition, issuer, persona, and scenario + // Helper function to create common prerequisites + async function createTestPrerequisites() { const assetRepository = Container.get(AssetRepository) const asset = await assetRepository.create({ mediaType: 'image/png', @@ -152,7 +125,41 @@ describe('ShowcaseController Integration Tests', () => { hidden: false, }) - // 1. Create a showcase + return { asset, credentialSchema, credentialDefinition, issuer, persona, scenario } + } + + beforeAll(async () => { + client = new PGlite() + const database = drizzle(client, { schema }) as unknown as NodePgDatabase + await migrate(database, { migrationsFolder: './apps/credential-showcase-api-server/src/database/migrations' }) + const mockDatabaseService = { + getConnection: jest.fn().mockResolvedValue(database), + } + Container.set(DatabaseService, mockDatabaseService) + useContainer(Container) + // Initialize all repositories and services + Container.get(AssetRepository) + Container.get(CredentialSchemaRepository) + Container.get(CredentialDefinitionRepository) + Container.get(IssuerRepository) + Container.get(PersonaRepository) + Container.get(ScenarioRepository) + Container.get(ShowcaseRepository) + Container.get(ShowcaseService) + app = createExpressServer({ + controllers: [ShowcaseController], + }) + request = supertest(app) + }) + + afterAll(async () => { + await client.close() + Container.reset() + }) + + it('should create, retrieve, update, and delete a showcase', async () => { + const { asset, credentialDefinition, persona, scenario } = await createTestPrerequisites() + const showcaseRequest: ShowcaseRequest = { name: 'Test Showcase', description: 'Test showcase description', @@ -195,17 +202,12 @@ describe('ShowcaseController Integration Tests', () => { } const updateResponse = await request.put(`/showcases/${createdShowcase.slug}`).send(updatedRequest).expect(200) - const updatedShowcase = updateResponse.body.showcase - expect(updateResponse.body.showcase.name).toEqual('Updated Showcase Name') expect(updateResponse.body.showcase.description).toEqual('Updated showcase description') expect(updateResponse.body.showcase.status).toEqual(ShowcaseStatus.PENDING) - // 5. Delete the showcase - await request.delete(`/showcases/${updatedShowcase.slug}`).expect(204) - - // 6. Verify showcase deletion - await request.get(`/showcases/${updatedShowcase.slug}`).expect(404) + await request.delete(`/showcases/${updateResponse.body.showcase.slug}`).expect(204) + await request.get(`/showcases/${updateResponse.body.showcase.slug}`).expect(404) }) it('should handle errors when accessing non-existent resources', async () => { @@ -239,102 +241,8 @@ describe('ShowcaseController Integration Tests', () => { }) it('should retrieve a showcase with no expands', async () => { - // Create prerequisites: asset, credential schema, credential definition, issuer, persona, and scenario - const assetRepository = Container.get(AssetRepository) - const asset = await assetRepository.create({ - mediaType: 'image/png', - fileName: 'test.png', - description: 'Test image', - content: Buffer.from('binary data'), - }) - - const credentialSchemaRepository = Container.get(CredentialSchemaRepository) - const credentialSchema = await credentialSchemaRepository.create({ - name: 'example_name', - version: 'example_version', - identifierType: IdentifierType.DID, - identifier: 'did:sov:XUeUZauFLeBNofY3NhaZCB', - attributes: [ - { - name: 'example_attribute_name1', - value: 'example_attribute_value1', - type: CredentialAttributeType.STRING, - }, - { - name: 'example_attribute_name2', - value: 'example_attribute_value2', - type: CredentialAttributeType.STRING, - }, - ], - }) - - const credentialDefinitionRepository = Container.get(CredentialDefinitionRepository) - const credentialDefinition = await credentialDefinitionRepository.create({ - name: 'Test Definition', - version: '1.0', - identifierType: IdentifierType.DID, - identifier: 'did:test:123', - icon: asset.id, - type: CredentialType.ANONCRED, - credentialSchema: credentialSchema.id, - }) - - const issuerRepository = Container.get(IssuerRepository) - const issuer = await issuerRepository.create({ - name: 'Test Issuer', - type: IssuerType.ARIES, - credentialDefinitions: [credentialDefinition.id], - credentialSchemas: [credentialSchema.id], - description: 'Test issuer description', - organization: 'Test Organization', - logo: asset.id, - }) - - // Create a persona - const personaRepository = Container.get(PersonaRepository) - const persona = await personaRepository.create({ - name: 'John Doe', - role: 'Software Engineer', - description: 'Experienced developer', - headshotImage: asset.id, - bodyImage: asset.id, - hidden: false, - }) - - // Create an issuance scenario with at least one step - const scenarioRepository = Container.get(ScenarioRepository) - const scenario = await scenarioRepository.create({ - name: 'Test Scenario', - description: 'Test scenario description', - issuer: issuer.id, // This makes it an issuance scenario - steps: [ - { - title: 'Test Step', - description: 'Test step description', - order: 1, - type: StepType.HUMAN_TASK, - asset: asset.id, - actions: [ - { - title: 'Test Action', - actionType: StepActionType.ARIES_OOB, - text: 'Test action text', - proofRequest: { - attributes: { - attribute1: { - attributes: ['attribute1', 'attribute2'], - restrictions: ['restriction1', 'restriction2'], - }, - }, - predicates: {}, - }, - }, - ], - }, - ], - personas: [persona.id], - hidden: false, - }) + const { asset, scenario } = await createTestPrerequisites() + const { credentialDefinition, persona } = await createTestPrerequisites() const showcaseRequest: ShowcaseRequest = { name: 'Expand Test Showcase', @@ -363,103 +271,7 @@ describe('ShowcaseController Integration Tests', () => { }) it('should retrieve a showcase with all expands except asset content', async () => { - // Create prerequisites: asset, credential schema, credential definition, issuer, persona, and scenario - const assetRepository = Container.get(AssetRepository) - const asset = await assetRepository.create({ - mediaType: 'image/png', - fileName: 'test.png', - description: 'Test image', - content: Buffer.from('binary data'), - }) - - const credentialSchemaRepository = Container.get(CredentialSchemaRepository) - const credentialSchema = await credentialSchemaRepository.create({ - name: 'example_name', - version: 'example_version', - identifierType: IdentifierType.DID, - identifier: 'did:sov:XUeUZauFLeBNofY3NhaZCB', - attributes: [ - { - name: 'example_attribute_name1', - value: 'example_attribute_value1', - type: CredentialAttributeType.STRING, - }, - { - name: 'example_attribute_name2', - value: 'example_attribute_value2', - type: CredentialAttributeType.STRING, - }, - ], - }) - - const credentialDefinitionRepository = Container.get(CredentialDefinitionRepository) - const credentialDefinition = await credentialDefinitionRepository.create({ - name: 'Test Definition', - version: '1.0', - identifierType: IdentifierType.DID, - identifier: 'did:test:123', - icon: asset.id, - type: CredentialType.ANONCRED, - credentialSchema: credentialSchema.id, - }) - - const issuerRepository = Container.get(IssuerRepository) - const issuer = await issuerRepository.create({ - name: 'Test Issuer', - type: IssuerType.ARIES, - credentialDefinitions: [credentialDefinition.id], - credentialSchemas: [credentialSchema.id], - description: 'Test issuer description', - organization: 'Test Organization', - logo: asset.id, - }) - - // Create a persona - const personaRepository = Container.get(PersonaRepository) - const persona = await personaRepository.create({ - name: 'John Doe', - role: 'Software Engineer', - description: 'Experienced developer', - headshotImage: asset.id, - bodyImage: asset.id, - hidden: false, - }) - - // Create an issuance scenario with at least one step - const scenarioRepository = Container.get(ScenarioRepository) - const scenario = await scenarioRepository.create({ - name: 'Test Scenario', - description: 'Test scenario description', - issuer: issuer.id, // This makes it an issuance scenario - steps: [ - { - title: 'Test Step', - description: 'Test step description', - order: 1, - type: StepType.HUMAN_TASK, - asset: asset.id, - actions: [ - { - title: 'Test Action', - actionType: StepActionType.ARIES_OOB, - text: 'Test action text', - proofRequest: { - attributes: { - attribute1: { - attributes: ['attribute1', 'attribute2'], - restrictions: ['restriction1', 'restriction2'], - }, - }, - predicates: {}, - }, - }, - ], - }, - ], - personas: [persona.id], - hidden: false, - }) - + const { asset, scenario, credentialDefinition, persona } = await createTestPrerequisites() const showcaseRequest: ShowcaseRequest = { name: 'All Expands Showcase', description: 'Testing all expands except asset content', @@ -477,7 +289,9 @@ describe('ShowcaseController Integration Tests', () => { // Retrieve with all expands except asset content const getResponse = await request - .get(`/showcases/${createdShowcase.slug}?expand=${ShowcaseExpand.Scenarios}&expand=${ShowcaseExpand.CredentialDefinitions}&expand=${ShowcaseExpand.Personas}`) + .get( + `/showcases/${createdShowcase.slug}?expand=${ShowcaseExpand.Scenarios}&expand=${ShowcaseExpand.CredentialDefinitions}&expand=${ShowcaseExpand.Personas}`, + ) .expect(200) // Verify related entities are expanded @@ -502,103 +316,7 @@ describe('ShowcaseController Integration Tests', () => { }) it('should retrieve a showcase with all expands including asset content', async () => { - // Create prerequisites: asset, credential schema, credential definition, issuer, persona, and scenario - const assetRepository = Container.get(AssetRepository) - const asset = await assetRepository.create({ - mediaType: 'image/png', - fileName: 'test.png', - description: 'Test image', - content: Buffer.from('binary data'), - }) - - const credentialSchemaRepository = Container.get(CredentialSchemaRepository) - const credentialSchema = await credentialSchemaRepository.create({ - name: 'example_name', - version: 'example_version', - identifierType: IdentifierType.DID, - identifier: 'did:sov:XUeUZauFLeBNofY3NhaZCB', - attributes: [ - { - name: 'example_attribute_name1', - value: 'example_attribute_value1', - type: CredentialAttributeType.STRING, - }, - { - name: 'example_attribute_name2', - value: 'example_attribute_value2', - type: CredentialAttributeType.STRING, - }, - ], - }) - - const credentialDefinitionRepository = Container.get(CredentialDefinitionRepository) - const credentialDefinition = await credentialDefinitionRepository.create({ - name: 'Test Definition', - version: '1.0', - identifierType: IdentifierType.DID, - identifier: 'did:test:123', - icon: asset.id, - type: CredentialType.ANONCRED, - credentialSchema: credentialSchema.id, - }) - - const issuerRepository = Container.get(IssuerRepository) - const issuer = await issuerRepository.create({ - name: 'Test Issuer', - type: IssuerType.ARIES, - credentialDefinitions: [credentialDefinition.id], - credentialSchemas: [credentialSchema.id], - description: 'Test issuer description', - organization: 'Test Organization', - logo: asset.id, - }) - - // Create a persona - const personaRepository = Container.get(PersonaRepository) - const persona = await personaRepository.create({ - name: 'John Doe', - role: 'Software Engineer', - description: 'Experienced developer', - headshotImage: asset.id, - bodyImage: asset.id, - hidden: false, - }) - - // Create an issuance scenario with at least one step - const scenarioRepository = Container.get(ScenarioRepository) - const scenario = await scenarioRepository.create({ - name: 'Test Scenario', - description: 'Test scenario description', - issuer: issuer.id, // This makes it an issuance scenario - steps: [ - { - title: 'Test Step', - description: 'Test step description', - order: 1, - type: StepType.HUMAN_TASK, - asset: asset.id, - actions: [ - { - title: 'Test Action', - actionType: StepActionType.ARIES_OOB, - text: 'Test action text', - proofRequest: { - attributes: { - attribute1: { - attributes: ['attribute1', 'attribute2'], - restrictions: ['restriction1', 'restriction2'], - }, - }, - predicates: {}, - }, - }, - ], - }, - ], - personas: [persona.id], - hidden: false, - }) - + const { asset, scenario, credentialDefinition, persona } = await createTestPrerequisites() const showcaseRequest: ShowcaseRequest = { name: 'Assets Content Showcase', description: 'Testing all expands with asset content', @@ -616,7 +334,9 @@ describe('ShowcaseController Integration Tests', () => { // Retrieve with all expands including asset content const getResponse = await request - .get(`/showcases/${createdShowcase.slug}?expand=${ShowcaseExpand.Scenarios}&expand=${ShowcaseExpand.CredentialDefinitions}&expand=${ShowcaseExpand.Personas}&expand=${ShowcaseExpand.AssetContent}`) + .get( + `/showcases/${createdShowcase.slug}?expand=${ShowcaseExpand.Scenarios}&expand=${ShowcaseExpand.CredentialDefinitions}&expand=${ShowcaseExpand.Personas}&expand=${ShowcaseExpand.AssetContent}`, + ) .expect(200) // Verify related entities are expanded @@ -648,34 +368,7 @@ describe('ShowcaseController Integration Tests', () => { }) it('should retrieve all showcases with various expand combinations', async () => { - // Create prerequisites: asset, credential schema, credential definition, issuer, persona, and scenario - const assetRepository = Container.get(AssetRepository) - const asset = await assetRepository.create({ - mediaType: 'image/png', - fileName: 'test.png', - description: 'Test image', - content: Buffer.from('binary data'), - }) - - const credentialSchemaRepository = Container.get(CredentialSchemaRepository) - const credentialSchema = await credentialSchemaRepository.create({ - name: 'example_name', - version: 'example_version', - identifierType: IdentifierType.DID, - identifier: 'did:sov:XUeUZauFLeBNofY3NhaZCB', - attributes: [ - { - name: 'example_attribute_name1', - value: 'example_attribute_value1', - type: CredentialAttributeType.STRING, - }, - { - name: 'example_attribute_name2', - value: 'example_attribute_value2', - type: CredentialAttributeType.STRING, - }, - ], - }) + const { asset, credentialSchema } = await createTestPrerequisites() const credentialDefinitionRepository = Container.get(CredentialDefinitionRepository) const credentialDefinition = await credentialDefinitionRepository.create({ @@ -797,7 +490,11 @@ describe('ShowcaseController Integration Tests', () => { expect(response3.body.showcases[0].completionMessage).toBeDefined() // Test 4: Get all with all expands including asset content - const response4 = await request.get(`/showcases?expand=${ShowcaseExpand.Scenarios}&expand=${ShowcaseExpand.CredentialDefinitions}&expand=${ShowcaseExpand.Personas}&expand=${ShowcaseExpand.AssetContent}`).expect(200) + const response4 = await request + .get( + `/showcases?expand=${ShowcaseExpand.Scenarios}&expand=${ShowcaseExpand.CredentialDefinitions}&expand=${ShowcaseExpand.Personas}&expand=${ShowcaseExpand.AssetContent}`, + ) + .expect(200) expect(response4.body.showcases.length).toBeGreaterThanOrEqual(2) expect(response4.body.showcases[0].scenarios.length).toBeGreaterThanOrEqual(1) expect(response4.body.showcases[0].credentialDefinitions.length).toBeGreaterThanOrEqual(1) @@ -813,103 +510,7 @@ describe('ShowcaseController Integration Tests', () => { }) it('should handle mixed valid and invalid expand parameters', async () => { - // Create prerequisites: asset, credential schema, credential definition, issuer, persona, and scenario - const assetRepository = Container.get(AssetRepository) - const asset = await assetRepository.create({ - mediaType: 'image/png', - fileName: 'test.png', - description: 'Test image', - content: Buffer.from('binary data'), - }) - - const credentialSchemaRepository = Container.get(CredentialSchemaRepository) - const credentialSchema = await credentialSchemaRepository.create({ - name: 'example_name', - version: 'example_version', - identifierType: IdentifierType.DID, - identifier: 'did:sov:XUeUZauFLeBNofY3NhaZCB', - attributes: [ - { - name: 'example_attribute_name1', - value: 'example_attribute_value1', - type: CredentialAttributeType.STRING, - }, - { - name: 'example_attribute_name2', - value: 'example_attribute_value2', - type: CredentialAttributeType.STRING, - }, - ], - }) - - const credentialDefinitionRepository = Container.get(CredentialDefinitionRepository) - const credentialDefinition = await credentialDefinitionRepository.create({ - name: 'Test Definition', - version: '1.0', - identifierType: IdentifierType.DID, - identifier: 'did:test:123', - icon: asset.id, - type: CredentialType.ANONCRED, - credentialSchema: credentialSchema.id, - }) - - const issuerRepository = Container.get(IssuerRepository) - const issuer = await issuerRepository.create({ - name: 'Test Issuer', - type: IssuerType.ARIES, - credentialDefinitions: [credentialDefinition.id], - credentialSchemas: [credentialSchema.id], - description: 'Test issuer description', - organization: 'Test Organization', - logo: asset.id, - }) - - // Create a persona - const personaRepository = Container.get(PersonaRepository) - const persona = await personaRepository.create({ - name: 'John Doe', - role: 'Software Engineer', - description: 'Experienced developer', - headshotImage: asset.id, - bodyImage: asset.id, - hidden: false, - }) - - // Create an issuance scenario with at least one step - const scenarioRepository = Container.get(ScenarioRepository) - const scenario = await scenarioRepository.create({ - name: 'Test Scenario', - description: 'Test scenario description', - issuer: issuer.id, // This makes it an issuance scenario - steps: [ - { - title: 'Test Step', - description: 'Test step description', - order: 1, - type: StepType.HUMAN_TASK, - asset: asset.id, - actions: [ - { - title: 'Test Action', - actionType: StepActionType.ARIES_OOB, - text: 'Test action text', - proofRequest: { - attributes: { - attribute1: { - attributes: ['attribute1', 'attribute2'], - restrictions: ['restriction1', 'restriction2'], - }, - }, - predicates: {}, - }, - }, - ], - }, - ], - personas: [persona.id], - hidden: false, - }) - + const { asset, scenario, credentialDefinition, persona } = await createTestPrerequisites() const showcaseRequest: ShowcaseRequest = { name: 'Mixed Expand Test', description: 'Testing mixed valid and invalid expand parameters', @@ -925,8 +526,9 @@ describe('ShowcaseController Integration Tests', () => { const createResponse = await request.post('/showcases').send(showcaseRequest).expect(201) const createdShowcase = createResponse.body.showcase - // Send request with valid and invalid expand parameters - const getResponse = await request.get(`/showcases/${createdShowcase.slug}?expand=${ShowcaseExpand.Scenarios}&expand=invalidExpand&expand=${ShowcaseExpand.Personas}`).expect(200) + const getResponse = await request + .get(`/showcases/${createdShowcase.slug}?expand=${ShowcaseExpand.Scenarios}&expand=invalidExpand&expand=${ShowcaseExpand.Personas}`) + .expect(200) // Verify valid expands are processed and invalid ones are ignored expect(getResponse.body.showcase.scenarios.length).toEqual(1) diff --git a/apps/credential-showcase-api-server/src/database/migrations/meta/0002_snapshot.json b/apps/credential-showcase-api-server/src/database/migrations/meta/0002_snapshot.json index 4ca6d46..ba1b4a8 100644 --- a/apps/credential-showcase-api-server/src/database/migrations/meta/0002_snapshot.json +++ b/apps/credential-showcase-api-server/src/database/migrations/meta/0002_snapshot.json @@ -54,12 +54,8 @@ "name": "ariesProofRequest_step_action_stepAction_id_fk", "tableFrom": "ariesProofRequest", "tableTo": "stepAction", - "columnsFrom": [ - "step_action" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["step_action"], + "columnsTo": ["id"], "onDelete": "cascade", "onUpdate": "no action" } @@ -69,9 +65,7 @@ "ariesProofRequest_step_action_unique": { "name": "ariesProofRequest_step_action_unique", "nullsNotDistinct": false, - "columns": [ - "step_action" - ] + "columns": ["step_action"] } }, "policies": {}, @@ -209,12 +203,8 @@ "name": "credentialAttribute_credential_schema_credentialSchema_id_fk", "tableFrom": "credentialAttribute", "tableTo": "credentialSchema", - "columnsFrom": [ - "credential_schema" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["credential_schema"], + "columnsTo": ["id"], "onDelete": "cascade", "onUpdate": "no action" } @@ -332,12 +322,8 @@ "name": "credentialDefinition_credential_schema_credentialSchema_id_fk", "tableFrom": "credentialDefinition", "tableTo": "credentialSchema", - "columnsFrom": [ - "credential_schema" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["credential_schema"], + "columnsTo": ["id"], "onDelete": "no action", "onUpdate": "no action" }, @@ -345,12 +331,8 @@ "name": "credentialDefinition_icon_asset_id_fk", "tableFrom": "credentialDefinition", "tableTo": "asset", - "columnsFrom": [ - "icon" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["icon"], + "columnsTo": ["id"], "onDelete": "no action", "onUpdate": "no action" } @@ -415,12 +397,8 @@ "name": "credentialRepresentation_credential_definition_credentialDefinition_id_fk", "tableFrom": "credentialRepresentation", "tableTo": "credentialDefinition", - "columnsFrom": [ - "credential_definition" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["credential_definition"], + "columnsTo": ["id"], "onDelete": "cascade", "onUpdate": "no action" } @@ -551,12 +529,8 @@ "name": "relyingPartiesToCredentialDefinitions_relying_party_relyingParty_id_fk", "tableFrom": "relyingPartiesToCredentialDefinitions", "tableTo": "relyingParty", - "columnsFrom": [ - "relying_party" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["relying_party"], + "columnsTo": ["id"], "onDelete": "cascade", "onUpdate": "no action" }, @@ -564,12 +538,8 @@ "name": "relyingPartiesToCredentialDefinitions_credential_definition_credentialDefinition_id_fk", "tableFrom": "relyingPartiesToCredentialDefinitions", "tableTo": "credentialDefinition", - "columnsFrom": [ - "credential_definition" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["credential_definition"], + "columnsTo": ["id"], "onDelete": "cascade", "onUpdate": "no action" } @@ -577,10 +547,7 @@ "compositePrimaryKeys": { "relyingPartiesToCredentialDefinitions_relying_party_credential_definition_pk": { "name": "relyingPartiesToCredentialDefinitions_relying_party_credential_definition_pk", - "columns": [ - "relying_party", - "credential_definition" - ] + "columns": ["relying_party", "credential_definition"] } }, "uniqueConstraints": {}, @@ -667,12 +634,8 @@ "name": "relyingParty_logo_asset_id_fk", "tableFrom": "relyingParty", "tableTo": "asset", - "columnsFrom": [ - "logo" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["logo"], + "columnsTo": ["id"], "onDelete": "no action", "onUpdate": "no action" } @@ -762,12 +725,8 @@ "name": "issuer_logo_asset_id_fk", "tableFrom": "issuer", "tableTo": "asset", - "columnsFrom": [ - "logo" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["logo"], + "columnsTo": ["id"], "onDelete": "no action", "onUpdate": "no action" } @@ -831,12 +790,8 @@ "name": "issuersToCredentialDefinitions_issuer_issuer_id_fk", "tableFrom": "issuersToCredentialDefinitions", "tableTo": "issuer", - "columnsFrom": [ - "issuer" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["issuer"], + "columnsTo": ["id"], "onDelete": "cascade", "onUpdate": "no action" }, @@ -844,12 +799,8 @@ "name": "issuersToCredentialDefinitions_credential_definition_credentialDefinition_id_fk", "tableFrom": "issuersToCredentialDefinitions", "tableTo": "credentialDefinition", - "columnsFrom": [ - "credential_definition" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["credential_definition"], + "columnsTo": ["id"], "onDelete": "cascade", "onUpdate": "no action" } @@ -857,10 +808,7 @@ "compositePrimaryKeys": { "issuersToCredentialDefinitions_issuer_credential_definition_pk": { "name": "issuersToCredentialDefinitions_issuer_credential_definition_pk", - "columns": [ - "issuer", - "credential_definition" - ] + "columns": ["issuer", "credential_definition"] } }, "uniqueConstraints": {}, @@ -907,12 +855,8 @@ "name": "issuersToCredentialSchemas_issuer_issuer_id_fk", "tableFrom": "issuersToCredentialSchemas", "tableTo": "issuer", - "columnsFrom": [ - "issuer" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["issuer"], + "columnsTo": ["id"], "onDelete": "cascade", "onUpdate": "no action" }, @@ -920,12 +864,8 @@ "name": "issuersToCredentialSchemas_credential_schema_credentialSchema_id_fk", "tableFrom": "issuersToCredentialSchemas", "tableTo": "credentialSchema", - "columnsFrom": [ - "credential_schema" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["credential_schema"], + "columnsTo": ["id"], "onDelete": "cascade", "onUpdate": "no action" } @@ -933,10 +873,7 @@ "compositePrimaryKeys": { "issuersToCredentialSchemas_issuer_credential_schema_pk": { "name": "issuersToCredentialSchemas_issuer_credential_schema_pk", - "columns": [ - "issuer", - "credential_schema" - ] + "columns": ["issuer", "credential_schema"] } }, "uniqueConstraints": {}, @@ -1050,12 +987,8 @@ "name": "step_sub_scenario_scenario_id_fk", "tableFrom": "step", "tableTo": "scenario", - "columnsFrom": [ - "sub_scenario" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["sub_scenario"], + "columnsTo": ["id"], "onDelete": "no action", "onUpdate": "no action" }, @@ -1063,12 +996,8 @@ "name": "step_scenario_scenario_id_fk", "tableFrom": "step", "tableTo": "scenario", - "columnsFrom": [ - "scenario" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["scenario"], + "columnsTo": ["id"], "onDelete": "cascade", "onUpdate": "no action" }, @@ -1076,12 +1005,8 @@ "name": "step_asset_asset_id_fk", "tableFrom": "step", "tableTo": "asset", - "columnsFrom": [ - "asset" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["asset"], + "columnsTo": ["id"], "onDelete": "no action", "onUpdate": "no action" } @@ -1091,10 +1016,7 @@ "step_order_scenario_unique": { "name": "step_order_scenario_unique", "nullsNotDistinct": false, - "columns": [ - "order", - "scenario" - ] + "columns": ["order", "scenario"] } }, "policies": {}, @@ -1173,12 +1095,8 @@ "name": "stepAction_step_step_id_fk", "tableFrom": "stepAction", "tableTo": "step", - "columnsFrom": [ - "step" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["step"], + "columnsTo": ["id"], "onDelete": "cascade", "onUpdate": "no action" } @@ -1317,12 +1235,8 @@ "name": "scenario_issuer_issuer_id_fk", "tableFrom": "scenario", "tableTo": "issuer", - "columnsFrom": [ - "issuer" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["issuer"], + "columnsTo": ["id"], "onDelete": "no action", "onUpdate": "no action" }, @@ -1330,12 +1244,8 @@ "name": "scenario_relying_party_relyingParty_id_fk", "tableFrom": "scenario", "tableTo": "relyingParty", - "columnsFrom": [ - "relying_party" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["relying_party"], + "columnsTo": ["id"], "onDelete": "no action", "onUpdate": "no action" }, @@ -1343,12 +1253,8 @@ "name": "scenario_banner_image_asset_id_fk", "tableFrom": "scenario", "tableTo": "asset", - "columnsFrom": [ - "banner_image" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["banner_image"], + "columnsTo": ["id"], "onDelete": "no action", "onUpdate": "no action" } @@ -1358,9 +1264,7 @@ "scenario_slug_unique": { "name": "scenario_slug_unique", "nullsNotDistinct": false, - "columns": [ - "slug" - ] + "columns": ["slug"] } }, "policies": {}, @@ -1438,12 +1342,8 @@ "name": "revocationInfo_credential_definition_credentialDefinition_id_fk", "tableFrom": "revocationInfo", "tableTo": "credentialDefinition", - "columnsFrom": [ - "credential_definition" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["credential_definition"], + "columnsTo": ["id"], "onDelete": "cascade", "onUpdate": "no action" } @@ -1453,9 +1353,7 @@ "revocationInfo_credential_definition_unique": { "name": "revocationInfo_credential_definition_unique", "nullsNotDistinct": false, - "columns": [ - "credential_definition" - ] + "columns": ["credential_definition"] } }, "policies": {}, @@ -1568,12 +1466,8 @@ "name": "persona_headshot_image_asset_id_fk", "tableFrom": "persona", "tableTo": "asset", - "columnsFrom": [ - "headshot_image" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["headshot_image"], + "columnsTo": ["id"], "onDelete": "no action", "onUpdate": "no action" }, @@ -1581,12 +1475,8 @@ "name": "persona_body_image_asset_id_fk", "tableFrom": "persona", "tableTo": "asset", - "columnsFrom": [ - "body_image" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["body_image"], + "columnsTo": ["id"], "onDelete": "no action", "onUpdate": "no action" } @@ -1596,9 +1486,7 @@ "persona_slug_unique": { "name": "persona_slug_unique", "nullsNotDistinct": false, - "columns": [ - "slug" - ] + "columns": ["slug"] } }, "policies": {}, @@ -1658,12 +1546,8 @@ "name": "scenariosToPersonas_scenario_scenario_id_fk", "tableFrom": "scenariosToPersonas", "tableTo": "scenario", - "columnsFrom": [ - "scenario" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["scenario"], + "columnsTo": ["id"], "onDelete": "cascade", "onUpdate": "no action" }, @@ -1671,12 +1555,8 @@ "name": "scenariosToPersonas_persona_persona_id_fk", "tableFrom": "scenariosToPersonas", "tableTo": "persona", - "columnsFrom": [ - "persona" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["persona"], + "columnsTo": ["id"], "onDelete": "cascade", "onUpdate": "no action" } @@ -1684,10 +1564,7 @@ "compositePrimaryKeys": { "scenariosToPersonas_scenario_persona_pk": { "name": "scenariosToPersonas_scenario_persona_pk", - "columns": [ - "scenario", - "persona" - ] + "columns": ["scenario", "persona"] } }, "uniqueConstraints": {}, @@ -1787,12 +1664,8 @@ "name": "showcase_banner_image_asset_id_fk", "tableFrom": "showcase", "tableTo": "asset", - "columnsFrom": [ - "banner_image" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["banner_image"], + "columnsTo": ["id"], "onDelete": "no action", "onUpdate": "no action" } @@ -1802,9 +1675,7 @@ "showcase_slug_unique": { "name": "showcase_slug_unique", "nullsNotDistinct": false, - "columns": [ - "slug" - ] + "columns": ["slug"] } }, "policies": {}, @@ -1864,12 +1735,8 @@ "name": "showcasesToCredentialDefinitions_showcase_showcase_id_fk", "tableFrom": "showcasesToCredentialDefinitions", "tableTo": "showcase", - "columnsFrom": [ - "showcase" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["showcase"], + "columnsTo": ["id"], "onDelete": "cascade", "onUpdate": "no action" }, @@ -1877,12 +1744,8 @@ "name": "showcasesToCredentialDefinitions_credential_definition_credentialDefinition_id_fk", "tableFrom": "showcasesToCredentialDefinitions", "tableTo": "credentialDefinition", - "columnsFrom": [ - "credential_definition" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["credential_definition"], + "columnsTo": ["id"], "onDelete": "cascade", "onUpdate": "no action" } @@ -1890,10 +1753,7 @@ "compositePrimaryKeys": { "showcasesToCredentialDefinitions_showcase_credential_definition_pk": { "name": "showcasesToCredentialDefinitions_showcase_credential_definition_pk", - "columns": [ - "showcase", - "credential_definition" - ] + "columns": ["showcase", "credential_definition"] } }, "uniqueConstraints": {}, @@ -1954,12 +1814,8 @@ "name": "showcasesToPersonas_showcase_showcase_id_fk", "tableFrom": "showcasesToPersonas", "tableTo": "showcase", - "columnsFrom": [ - "showcase" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["showcase"], + "columnsTo": ["id"], "onDelete": "cascade", "onUpdate": "no action" }, @@ -1967,12 +1823,8 @@ "name": "showcasesToPersonas_persona_persona_id_fk", "tableFrom": "showcasesToPersonas", "tableTo": "persona", - "columnsFrom": [ - "persona" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["persona"], + "columnsTo": ["id"], "onDelete": "cascade", "onUpdate": "no action" } @@ -1980,10 +1832,7 @@ "compositePrimaryKeys": { "showcasesToPersonas_showcase_persona_pk": { "name": "showcasesToPersonas_showcase_persona_pk", - "columns": [ - "showcase", - "persona" - ] + "columns": ["showcase", "persona"] } }, "uniqueConstraints": {}, @@ -2044,12 +1893,8 @@ "name": "showcasesToScenarios_showcase_showcase_id_fk", "tableFrom": "showcasesToScenarios", "tableTo": "showcase", - "columnsFrom": [ - "showcase" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["showcase"], + "columnsTo": ["id"], "onDelete": "cascade", "onUpdate": "no action" }, @@ -2057,12 +1902,8 @@ "name": "showcasesToScenarios_scenario_scenario_id_fk", "tableFrom": "showcasesToScenarios", "tableTo": "scenario", - "columnsFrom": [ - "scenario" - ], - "columnsTo": [ - "id" - ], + "columnsFrom": ["scenario"], + "columnsTo": ["id"], "onDelete": "cascade", "onUpdate": "no action" } @@ -2070,10 +1911,7 @@ "compositePrimaryKeys": { "showcasesToScenarios_showcase_scenario_pk": { "name": "showcasesToScenarios_showcase_scenario_pk", - "columns": [ - "showcase", - "scenario" - ] + "columns": ["showcase", "scenario"] } }, "uniqueConstraints": {}, @@ -2086,75 +1924,47 @@ "public.CredentialAttributeType": { "name": "CredentialAttributeType", "schema": "public", - "values": [ - "STRING", - "INTEGER", - "FLOAT", - "BOOLEAN", - "DATE" - ] + "values": ["STRING", "INTEGER", "FLOAT", "BOOLEAN", "DATE"] }, "public.CredentialType": { "name": "CredentialType", "schema": "public", - "values": [ - "ANONCRED" - ] + "values": ["ANONCRED"] }, "public.IdentifierType": { "name": "IdentifierType", "schema": "public", - "values": [ - "DID" - ] + "values": ["DID"] }, "public.IssuerType": { "name": "IssuerType", "schema": "public", - "values": [ - "ARIES" - ] + "values": ["ARIES"] }, "public.StepType": { "name": "StepType", "schema": "public", - "values": [ - "HUMAN_TASK", - "SERVICE", - "SCENARIO" - ] + "values": ["HUMAN_TASK", "SERVICE", "SCENARIO"] }, "public.ScenarioType": { "name": "ScenarioType", "schema": "public", - "values": [ - "ISSUANCE", - "PRESENTATION" - ] + "values": ["ISSUANCE", "PRESENTATION"] }, "public.ShowcaseStatus": { "name": "ShowcaseStatus", "schema": "public", - "values": [ - "PENDING", - "ACTIVE", - "ARCHIVED" - ] + "values": ["PENDING", "ACTIVE", "ARCHIVED"] }, "public.RelyingPartyType": { "name": "RelyingPartyType", "schema": "public", - "values": [ - "ARIES" - ] + "values": ["ARIES"] }, "public.Source": { "name": "Source", "schema": "public", - "values": [ - "IMPORTED", - "CREATED" - ] + "values": ["IMPORTED", "CREATED"] } }, "schemas": {}, @@ -2167,4 +1977,4 @@ "schemas": {}, "tables": {} } -} \ No newline at end of file +} diff --git a/apps/credential-showcase-api-server/src/database/migrations/meta/_journal.json b/apps/credential-showcase-api-server/src/database/migrations/meta/_journal.json index ae1c6e8..bb663fb 100644 --- a/apps/credential-showcase-api-server/src/database/migrations/meta/_journal.json +++ b/apps/credential-showcase-api-server/src/database/migrations/meta/_journal.json @@ -24,4 +24,4 @@ "breakpoints": true } ] -} \ No newline at end of file +} diff --git a/apps/credential-showcase-api-server/src/database/repositories/ShowcaseRepository.ts b/apps/credential-showcase-api-server/src/database/repositories/ShowcaseRepository.ts index 72191b2..cfdb792 100644 --- a/apps/credential-showcase-api-server/src/database/repositories/ShowcaseRepository.ts +++ b/apps/credential-showcase-api-server/src/database/repositories/ShowcaseRepository.ts @@ -225,13 +225,13 @@ class ShowcaseRepository implements RepositoryDefinition steps: sortSteps(scenario.steps), ...(scenario.relyingParty && { relyingParty: { - ...(scenario.relyingParty as any), // TODO check this typing issue at a later point in time + ...(scenario.relyingParty as object), credentialDefinitions: scenario.relyingParty!.cds.map((credentialDefinition) => credentialDefinition.cd), }, }), ...(scenario.issuer && { issuer: { - ...(scenario.issuer as any), // TODO check this typing issue at a later point in time + ...(scenario.issuer as any), credentialDefinitions: scenario.issuer!.cds.map((credentialDefinition) => credentialDefinition.cd), credentialSchemas: scenario.issuer!.css.map((credentialSchema) => credentialSchema.cs), }, @@ -445,13 +445,13 @@ class ShowcaseRepository implements RepositoryDefinition steps: sortSteps(scenario.steps), ...(scenario.relyingParty && { relyingParty: { - ...(scenario.relyingParty as any), // TODO check this typing issue at a later point in time + ...(scenario.relyingParty as object), credentialDefinitions: scenario.relyingParty!.cds.map((credentialDefinition) => credentialDefinition.cd), }, }), ...(scenario.issuer && { issuer: { - ...(scenario.issuer as any), // TODO check this typing issue at a later point in time + ...(scenario.issuer as any), credentialDefinitions: scenario.issuer!.cds.map((credentialDefinition) => credentialDefinition.cd), credentialSchemas: scenario.issuer!.css.map((credentialSchema) => credentialSchema.cs), }, @@ -487,7 +487,6 @@ class ShowcaseRepository implements RepositoryDefinition with: { credentialDefinition: { with: { - // Only include icon if ASSET_CONTENT is in the expands ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { icon: true } : {}), cs: { with: { @@ -515,7 +514,6 @@ class ShowcaseRepository implements RepositoryDefinition proofRequest: true, }, }, - // Only include asset if ASSET_CONTENT is in the expands ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { asset: true } : {}), }, }, @@ -525,7 +523,6 @@ class ShowcaseRepository implements RepositoryDefinition with: { cd: { with: { - // Only include icon if ASSET_CONTENT is in the expands ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { icon: true } : {}), cs: { with: { @@ -547,7 +544,6 @@ class ShowcaseRepository implements RepositoryDefinition }, }, }, - // Only include logo if ASSET_CONTENT is in the expands ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { logo: true } : {}), }, }, @@ -557,7 +553,6 @@ class ShowcaseRepository implements RepositoryDefinition with: { cd: { with: { - // Only include icon if ASSET_CONTENT is in the expands ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { icon: true } : {}), cs: { with: { @@ -570,7 +565,6 @@ class ShowcaseRepository implements RepositoryDefinition }, }, }, - // Only include logo if ASSET_CONTENT is in the expands ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { logo: true } : {}), }, }, @@ -578,7 +572,6 @@ class ShowcaseRepository implements RepositoryDefinition with: { persona: { with: { - // Only include images if ASSET_CONTENT is in the expands ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { headshotImage: true, @@ -601,7 +594,6 @@ class ShowcaseRepository implements RepositoryDefinition with: { persona: { with: { - // Only include images if ASSET_CONTENT is in the expands ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { headshotImage: true, @@ -638,7 +630,7 @@ class ShowcaseRepository implements RepositoryDefinition if (!scenarioJoin.scenario) continue // Create a type-safe copy of the scenario data - const scenarioObj = scenarioJoin.scenario as any + const scenarioObj = scenarioJoin.scenario // Process steps if they exist let processedSteps: Step[] = [] @@ -700,7 +692,7 @@ class ShowcaseRepository implements RepositoryDefinition for (const cdJoin of result.credentialDefinitions) { if (!cdJoin.credentialDefinition) continue - const cdObj = cdJoin.credentialDefinition as any + const cdObj = cdJoin.credentialDefinition credentialDefinitionsArray.push({ ...cdObj, @@ -760,7 +752,6 @@ class ShowcaseRepository implements RepositoryDefinition with: { credentialDefinition: { with: { - // Only include icon if ASSET_CONTENT is in the expands ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { icon: true } : {}), cs: { with: { @@ -789,7 +780,6 @@ class ShowcaseRepository implements RepositoryDefinition proofRequest: true, }, }, - // Only include asset if ASSET_CONTENT is in the expands ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { asset: true } : {}), }, }, @@ -799,7 +789,6 @@ class ShowcaseRepository implements RepositoryDefinition with: { cd: { with: { - // Only include icon if ASSET_CONTENT is in the expands ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { icon: true } : {}), cs: { with: { @@ -821,7 +810,6 @@ class ShowcaseRepository implements RepositoryDefinition }, }, }, - // Only include logo if ASSET_CONTENT is in the expands ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { logo: true } : {}), }, }, @@ -831,7 +819,6 @@ class ShowcaseRepository implements RepositoryDefinition with: { cd: { with: { - // Only include icon if ASSET_CONTENT is in the expands ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { icon: true } : {}), cs: { with: { @@ -844,7 +831,6 @@ class ShowcaseRepository implements RepositoryDefinition }, }, }, - // Only include logo if ASSET_CONTENT is in the expands ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { logo: true } : {}), }, }, @@ -852,7 +838,6 @@ class ShowcaseRepository implements RepositoryDefinition with: { persona: { with: { - // Only include images if ASSET_CONTENT is in the expands ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { headshotImage: true, @@ -876,7 +861,6 @@ class ShowcaseRepository implements RepositoryDefinition with: { persona: { with: { - // Only include images if ASSET_CONTENT is in the expands ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { headshotImage: true, @@ -935,7 +919,7 @@ class ShowcaseRepository implements RepositoryDefinition for (const scenarioJoin of scenarioItems) { if (!scenarioJoin.scenario) continue - const scenarioObj = scenarioJoin.scenario as any + const scenarioObj = scenarioJoin.scenario // Process steps let processedSteps: Step[] = [] @@ -998,7 +982,7 @@ class ShowcaseRepository implements RepositoryDefinition for (const cdJoin of cdItems) { if (!cdJoin.credentialDefinition) continue - const cdObj = cdJoin.credentialDefinition as any + const cdObj = cdJoin.credentialDefinition credentialDefinitionsArray.push({ ...cdObj, diff --git a/apps/credential-showcase-api-server/src/types/schema/index.ts b/apps/credential-showcase-api-server/src/types/schema/index.ts index adec7f6..b123534 100644 --- a/apps/credential-showcase-api-server/src/types/schema/index.ts +++ b/apps/credential-showcase-api-server/src/types/schema/index.ts @@ -224,7 +224,7 @@ export const ShowcaseExpand = { SCENARIOS: 'SCENARIOS', CREDENTIAL_DEFINITIONS: 'CREDENTIAL_DEFINITIONS', PERSONAS: 'PERSONAS', - ASSET_CONTENT: 'ASSET_CONTENT' -} as const; + ASSET_CONTENT: 'ASSET_CONTENT', +} as const -export type ShowcaseExpand = typeof ShowcaseExpand[keyof typeof ShowcaseExpand]; \ No newline at end of file +export type ShowcaseExpand = (typeof ShowcaseExpand)[keyof typeof ShowcaseExpand] diff --git a/apps/credential-showcase-api-server/src/utils/mappers.ts b/apps/credential-showcase-api-server/src/utils/mappers.ts index 7c22462..28b07f7 100644 --- a/apps/credential-showcase-api-server/src/utils/mappers.ts +++ b/apps/credential-showcase-api-server/src/utils/mappers.ts @@ -62,9 +62,7 @@ export const credentialDefinitionDTOFrom = (credentialDefinition: CredentialDefi representations: credentialDefinition.representations, revocation: credentialDefinition.revocation || undefined, iconId: typeof credentialDefinition.icon === 'string' ? credentialDefinition.icon : undefined, - icon: credentialDefinition.icon && typeof credentialDefinition.icon !== 'string' - ? assetDTOFrom(credentialDefinition.icon as Asset) - : undefined, + icon: credentialDefinition.icon && typeof credentialDefinition.icon !== 'string' ? assetDTOFrom(credentialDefinition.icon as Asset) : undefined, } } @@ -73,10 +71,8 @@ export const relyingPartyDTOFrom = (relyingParty: RelyingParty): RelyingPartyDTO ...relyingParty, organization: relyingParty.organization || undefined, logoId: typeof relyingParty.logo === 'string' ? relyingParty.logo : undefined, - logo: relyingParty.logo && typeof relyingParty.logo !== 'string' - ? assetDTOFrom(relyingParty.logo as Asset) - : undefined, - credentialDefinitions: relyingParty.credentialDefinitions.map(credentialDefinitionDTOFrom) + logo: relyingParty.logo && typeof relyingParty.logo !== 'string' ? assetDTOFrom(relyingParty.logo as Asset) : undefined, + credentialDefinitions: relyingParty.credentialDefinitions.map(credentialDefinitionDTOFrom), } } @@ -85,11 +81,9 @@ export const issuerDTOFrom = (issuer: Issuer): IssuerDTO => { ...issuer, organization: issuer.organization || undefined, logoId: typeof issuer.logo === 'string' ? issuer.logo : undefined, - logo: issuer.logo && typeof issuer.logo !== 'string' - ? assetDTOFrom(issuer.logo as Asset) - : undefined, + logo: issuer.logo && typeof issuer.logo !== 'string' ? assetDTOFrom(issuer.logo as Asset) : undefined, credentialDefinitions: issuer.credentialDefinitions.map(credentialDefinitionDTOFrom), - credentialSchemas: issuer.credentialSchemas.map(credentialSchemaDTOFrom) + credentialSchemas: issuer.credentialSchemas.map(credentialSchemaDTOFrom), } } @@ -136,10 +130,8 @@ export const stepDTOFrom = (step: Step): StepDTO => { return { ...step, assetId: typeof step.asset === 'string' ? step.asset : undefined, - asset: step.asset && typeof step.asset !== 'string' - ? assetDTOFrom(step.asset as Asset) - : undefined, - subScenario: step.subScenario || undefined + asset: step.asset && typeof step.asset !== 'string' ? assetDTOFrom(step.asset as Asset) : undefined, + subScenario: step.subScenario || undefined, } } @@ -147,14 +139,10 @@ export const personaDTOFrom = (persona: Persona): PersonaDTO => { return { ...persona, headshotImageId: typeof persona.headshotImage === 'string' ? persona.headshotImage : undefined, - headshotImage: persona.headshotImage && typeof persona.headshotImage !== 'string' - ? assetDTOFrom(persona.headshotImage as Asset) - : undefined, + headshotImage: persona.headshotImage && typeof persona.headshotImage !== 'string' ? assetDTOFrom(persona.headshotImage as Asset) : undefined, bodyImageId: typeof persona.bodyImage === 'string' ? persona.bodyImage : undefined, - bodyImage: persona.bodyImage && typeof persona.bodyImage !== 'string' - ? assetDTOFrom(persona.bodyImage as Asset) - : undefined, - hidden: persona.hidden + bodyImage: persona.bodyImage && typeof persona.bodyImage !== 'string' ? assetDTOFrom(persona.bodyImage as Asset) : undefined, + hidden: persona.hidden, } } @@ -165,10 +153,8 @@ export const showcaseDTOFrom = (showcase: Showcase): ShowcaseDTO => { credentialDefinitions: showcase.credentialDefinitions.map(credentialDefinitionDTOFrom), scenarios: showcase.scenarios.map(scenarioDTOFrom), bannerImageId: typeof showcase.bannerImage === 'string' ? showcase.bannerImage : undefined, - bannerImage: showcase.bannerImage && typeof showcase.bannerImage !== 'string' - ? assetDTOFrom(showcase.bannerImage as Asset) - : undefined, - completionMessage: showcase.completionMessage || undefined + bannerImage: showcase.bannerImage && typeof showcase.bannerImage !== 'string' ? assetDTOFrom(showcase.bannerImage as Asset) : undefined, + completionMessage: showcase.completionMessage || undefined, } } diff --git a/apps/credential-showcase-api-server/src/utils/normalize.ts b/apps/credential-showcase-api-server/src/utils/normalize.ts index f39a2bc..930db30 100644 --- a/apps/credential-showcase-api-server/src/utils/normalize.ts +++ b/apps/credential-showcase-api-server/src/utils/normalize.ts @@ -18,12 +18,12 @@ export const normalizeExpandParams = (expand?: string[]): ShowcaseExpand[] => { return ( (expand - ?.map((exp) => { - const normalizedKey = exp.toLowerCase().trim() + ?.map((expandValue) => { + const normalizedKey = expandValue.toLowerCase().trim() if (normalizedKey in expandMap) { return expandMap[normalizedKey as keyof typeof expandMap] } - console.warn(`Invalid expand parameter: ${exp}`) + console.warn(`Invalid expand parameter: ${expandValue}`) return null }) .filter(Boolean) as ShowcaseExpand[]) || [] diff --git a/docker/dev/README.md b/docker/dev/README.md index 20669be..86dad56 100644 --- a/docker/dev/README.md +++ b/docker/dev/README.md @@ -58,6 +58,7 @@ docker-compose up -d ``` This will start: + - The API server accessible on port defined in your `.env` file - The Traction adapter service - PostgreSQL database with persistent storage @@ -66,6 +67,7 @@ This will start: ## Network Configuration The system uses two isolated Docker networks: + - `messagebroker_net`: For RabbitMQ communication - `db_net`: For database access @@ -93,6 +95,7 @@ To push the images to a Docker registry: ``` The script: + - Checks that API server and Traction adapter versions match - Tags images with the appropriate version number from package.json - Pushes images to the configured registry (default: sphereonregistry.azurecr.io) @@ -109,4 +112,4 @@ The script: - Verify network connectivity between services - Ensure RabbitMQ credentials are correct - Check PostgreSQL connection parameters -- If push script fails, verify your Docker registry credentials and connection \ No newline at end of file +- If push script fails, verify your Docker registry credentials and connection diff --git a/docker/dev/docker-compose.yml b/docker/dev/docker-compose.yml index cb98e25..b8a9145 100644 --- a/docker/dev/docker-compose.yml +++ b/docker/dev/docker-compose.yml @@ -26,9 +26,9 @@ services: - ALLOW_HEADERS=${ALLOW_HEADERS} - ALLOW_CREDENTIALS=${ALLOW_CREDENTIALS} depends_on: - - postgres # Ensure Postgres starts first + - postgres # Ensure Postgres starts first ports: - - "${API_PORT}:3000" # remove when enabling proxy + - '${API_PORT}:3000' # remove when enabling proxy credential-showcase-traction-adapter: build: @@ -48,7 +48,7 @@ services: - APP_NAME=${APP_NAME} - LOG_LEVEL=${LOG_LEVEL} depends_on: - - rabbitmq # Ensure RabbitMQ starts first + - rabbitmq # Ensure RabbitMQ starts first postgres: image: postgres:16 @@ -60,17 +60,17 @@ services: - POSTGRES_PASSWORD=${DB_PASSWORD} - POSTGRES_DB=${DB_NAME} ports: - - "${DB_EXPOSED_PORT}:5432" # Expose Postgres port, default 5432 + - '${DB_EXPOSED_PORT}:5432' # Expose Postgres port, default 5432 volumes: - postgres_data:/var/lib/postgresql/data healthcheck: - test: ["CMD", "pg_isready", "-U", "${DB_USER}"] + test: ['CMD', 'pg_isready', '-U', '${DB_USER}'] interval: 10s timeout: 5s retries: 5 rabbitmq: - image: rabbitmq:4-management # Using RabbitMQ 4.x with management plugin + image: rabbitmq:4-management # Using RabbitMQ 4.x with management plugin restart: unless-stopped networks: - messagebroker_net @@ -78,11 +78,11 @@ services: - RABBITMQ_DEFAULT_USER=${RABBITMQ_USER} - RABBITMQ_DEFAULT_PASS=${RABBITMQ_PASSWORD} ports: - - "${RABBITMQ_EXPOSED_PORT:-5672}:5672" - - "${RABBITMQ_MGMT_EXPOSED_PORT:-15672}:15672" + - '${RABBITMQ_EXPOSED_PORT:-5672}:5672' + - '${RABBITMQ_MGMT_EXPOSED_PORT:-15672}:15672' volumes: - postgres_data: # Named volume for Postgres data persistence + postgres_data: # Named volume for Postgres data persistence networks: api_net: @@ -92,8 +92,8 @@ networks: messagebroker_net: driver: bridge name: messagebroker_net - internal: false # set to false to be able to expose for debugging + internal: false # set to false to be able to expose for debugging db_net: driver: bridge name: db_net - internal: false # set to false to be able to expose for debugging \ No newline at end of file + internal: false # set to false to be able to expose for debugging diff --git a/docker/prod/docker-compose.yml b/docker/prod/docker-compose.yml index cbd948c..d24d68d 100644 --- a/docker/prod/docker-compose.yml +++ b/docker/prod/docker-compose.yml @@ -18,17 +18,17 @@ services: - APP_NAME=${APP_NAME} - LOG_LEVEL=${LOG_LEVEL} depends_on: - - postgres # Ensure Postgres starts first + - postgres # Ensure Postgres starts first ports: - - "${API_PORT}:3000" # remove when enabling proxy + - '${API_PORT}:3000' # remove when enabling proxy labels: - - "traefik.enable=true" - - "traefik.docker.network=frontend" - - "traefik.http.routers.credential-showcase-api-server.entrypoints=websecure" - - "traefik.http.routers.credential-showcase-api-server.rule=${API_PUBLIC_HOSTS}" - - "traefik.http.routers.credential-showcase-api-server.tls.certresolver=acmeresolver" - - "traefik.http.services.credential-showcase-api-server.loadbalancer.server.port=3000" - - "traefik.http.services.credential-showcase-api-server.loadbalancer.server.scheme=http" + - 'traefik.enable=true' + - 'traefik.docker.network=frontend' + - 'traefik.http.routers.credential-showcase-api-server.entrypoints=websecure' + - 'traefik.http.routers.credential-showcase-api-server.rule=${API_PUBLIC_HOSTS}' + - 'traefik.http.routers.credential-showcase-api-server.tls.certresolver=acmeresolver' + - 'traefik.http.services.credential-showcase-api-server.loadbalancer.server.port=3000' + - 'traefik.http.services.credential-showcase-api-server.loadbalancer.server.scheme=http' credential-showcase-traction-adapter: image: ${DOCKER_REGISTRY:-sphereonregistry.azurecr.io}/credential-showcase-traction-adapter:latest @@ -45,7 +45,7 @@ services: - APP_NAME=${APP_NAME} - LOG_LEVEL=${LOG_LEVEL} depends_on: - - rabbitmq # Ensure RabbitMQ starts first + - rabbitmq # Ensure RabbitMQ starts first postgres: image: postgres:16 @@ -59,13 +59,13 @@ services: volumes: - postgres_data:/var/lib/postgresql/data healthcheck: - test: [ "CMD", "pg_isready", "-U", "${DB_USER}" ] + test: ['CMD', 'pg_isready', '-U', '${DB_USER}'] interval: 10s timeout: 5s retries: 5 rabbitmq: - image: rabbitmq:4-management # Using RabbitMQ 4.x with management plugin + image: rabbitmq:4-management # Using RabbitMQ 4.x with management plugin restart: unless-stopped networks: - messagebroker_net @@ -73,13 +73,13 @@ services: - RABBITMQ_DEFAULT_USER=${RABBITMQ_USER} - RABBITMQ_DEFAULT_PASS=${RABBITMQ_PASSWORD} ports: - - "${RABBITMQ_EXPOSED_PORT:-5672}:5672" - - "${RABBITMQ_MGMT_EXPOSED_PORT:-15672}:15672" + - '${RABBITMQ_EXPOSED_PORT:-5672}:5672' + - '${RABBITMQ_MGMT_EXPOSED_PORT:-15672}:15672' traefik: image: traefik:latest profiles: - - traefik # CONDITIONAL - set COMPOSE_PROFILES=traefik to enable + - traefik # CONDITIONAL - set COMPOSE_PROFILES=traefik to enable command: > --providers.docker --providers.docker.exposedbydefault=false @@ -95,8 +95,8 @@ services: --api.dashboard=false --log.level=INFO ports: - - "80:80" - - "443:443" + - '80:80' + - '443:443' volumes: - /var/run/docker.sock:/var/run/docker.sock - ./cert/:/cert/ @@ -104,20 +104,20 @@ services: networks: - frontend labels: - - "traefik.enable=true" + - 'traefik.enable=true' volumes: - postgres_data: # Named volume for Postgres data persistence + postgres_data: # Named volume for Postgres data persistence networks: messagebroker_net: driver: bridge name: messagebroker_net - internal: true # not exposed when set to true + internal: true # not exposed when set to true db_net: driver: bridge name: db_net - internal: true # not exposed when set to true + internal: true # not exposed when set to true frontend: driver: bridge name: frontend_net diff --git a/jest.json b/jest.json index 0b76f3c..985bdcc 100644 --- a/jest.json +++ b/jest.json @@ -1,12 +1,7 @@ { "preset": "ts-jest", "testTimeout": 60000, - "moduleFileExtensions": [ - "ts", - "js", - "json", - "jsonld" - ], + "moduleFileExtensions": ["ts", "js", "json", "jsonld"], "collectCoverage": true, "collectCoverageFrom": [ "packages/**/src/**/*.ts", @@ -17,14 +12,8 @@ "!**/node_modules/**", "!**/packages/**/index.ts" ], - "coveragePathIgnorePatterns": [ - "packages/credential-showcase-openapi" - ], - "coverageReporters": [ - "text", - "lcov", - "json" - ], + "coveragePathIgnorePatterns": ["packages/credential-showcase-openapi"], + "coverageReporters": ["text", "lcov", "json"], "coverageDirectory": "./coverage", "transform": { "\\.jsx?$": "babel-jest", @@ -35,10 +24,7 @@ } ] }, - "testMatch": [ - "**/__tests__/**/*.test.*", - "!dist/*" - ], + "testMatch": ["**/__tests__/**/*.test.*", "!dist/*"], "testEnvironment": "node", "automock": false, "verbose": true diff --git a/packages/credential-showcase-openapi/openapi/openapi.yaml b/packages/credential-showcase-openapi/openapi/openapi.yaml index 27940d7..0bad312 100644 --- a/packages/credential-showcase-openapi/openapi/openapi.yaml +++ b/packages/credential-showcase-openapi/openapi/openapi.yaml @@ -86,7 +86,7 @@ paths: schema: type: string get: - tags: [ "Issuance Scenario" ] + tags: ['Issuance Scenario'] summary: Retrieve a single issuance scenario operationId: getIssuanceScenario responses: @@ -107,7 +107,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' put: - tags: [ "Issuance Scenario" ] + tags: ['Issuance Scenario'] summary: Update an issuance scenario (overwrite) operationId: updateIssuanceScenario requestBody: @@ -134,7 +134,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' delete: - tags: [ "Issuance Scenario" ] + tags: ['Issuance Scenario'] summary: Delete an issuance scenario operationId: deleteIssuanceScenario responses: @@ -160,7 +160,7 @@ paths: type: string get: tags: - - "Issuance Scenario" + - 'Issuance Scenario' summary: List steps in an issuance scenario operationId: listIssuanceScenarioSteps responses: @@ -181,7 +181,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' post: - tags: [ "Issuance Scenario" ] + tags: ['Issuance Scenario'] summary: Add a step to an issuance scenario operationId: createIssuanceScenarioStep requestBody: @@ -220,7 +220,7 @@ paths: schema: type: string get: - tags: [ "Issuance Scenario" ] + tags: ['Issuance Scenario'] summary: Retrieve a specific step in an issuance scenario operationId: getIssuanceScenarioStep responses: @@ -241,7 +241,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' put: - tags: [ "Issuance Scenario" ] + tags: ['Issuance Scenario'] summary: Overwrite a step in an issuance scenario operationId: updateIssuanceScenarioStep requestBody: @@ -268,7 +268,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' delete: - tags: [ "Issuance Scenario" ] + tags: ['Issuance Scenario'] summary: Delete a step in an issuance scenario operationId: deleteIssuanceScenarioStep responses: @@ -298,7 +298,7 @@ paths: schema: type: string get: - tags: [ "Issuance Scenario" ] + tags: ['Issuance Scenario'] summary: List actions in a step operationId: listStepActions responses: @@ -319,7 +319,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' post: - tags: [ "Issuance Scenario" ] + tags: ['Issuance Scenario'] summary: Create an action in a step operationId: createStepAction requestBody: @@ -363,7 +363,7 @@ paths: schema: type: string get: - tags: [ "Issuance Scenario" ] + tags: ['Issuance Scenario'] summary: Retrieve a single action operationId: getStepAction responses: @@ -384,7 +384,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' put: - tags: [ "Issuance Scenario" ] + tags: ['Issuance Scenario'] summary: Overwrite an action operationId: updateStepAction requestBody: @@ -411,7 +411,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' delete: - tags: [ "Issuance Scenario" ] + tags: ['Issuance Scenario'] summary: Delete an action operationId: deleteStepAction responses: @@ -483,7 +483,7 @@ paths: schema: type: string get: - tags: [ "Presentation Scenario" ] + tags: ['Presentation Scenario'] summary: Retrieve a single presentation scenario operationId: getPresentationScenario responses: @@ -504,7 +504,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' put: - tags: [ "Presentation Scenario" ] + tags: ['Presentation Scenario'] summary: Update a presentation scenario (overwrite) operationId: updatePresentationScenario requestBody: @@ -531,7 +531,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' delete: - tags: [ "Presentation Scenario" ] + tags: ['Presentation Scenario'] summary: Delete a presentation scenario operationId: deletePresentationScenario responses: @@ -557,7 +557,7 @@ paths: type: string get: tags: - - "Presentation Scenario" + - 'Presentation Scenario' summary: List steps in a presentation scenario operationId: listPresentationScenarioSteps responses: @@ -578,7 +578,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' post: - tags: [ "Presentation Scenario" ] + tags: ['Presentation Scenario'] summary: Add a step to a presentation scenario operationId: createPresentationScenarioStep requestBody: @@ -617,7 +617,7 @@ paths: schema: type: string get: - tags: [ "Presentation Scenario" ] + tags: ['Presentation Scenario'] summary: Retrieve a specific step in a presentation scenario operationId: getPresentationScenarioStep responses: @@ -638,7 +638,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' put: - tags: [ "Presentation Scenario" ] + tags: ['Presentation Scenario'] summary: Overwrite a step in a presentation scenario operationId: updatePresentationScenarioStep requestBody: @@ -665,7 +665,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' delete: - tags: [ "Presentation Scenario" ] + tags: ['Presentation Scenario'] summary: Delete a step in a presentation scenario operationId: deletePresentationScenarioStep responses: @@ -695,7 +695,7 @@ paths: schema: type: string get: - tags: [ "Presentation Scenario" ] + tags: ['Presentation Scenario'] summary: List actions in a step operationId: listPresentationScenarioStepActions responses: @@ -716,7 +716,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' post: - tags: [ "Presentation Scenario" ] + tags: ['Presentation Scenario'] summary: Create an action in a step operationId: createPresentationScenarioStepAction requestBody: @@ -760,7 +760,7 @@ paths: schema: type: string get: - tags: [ "Presentation Scenario" ] + tags: ['Presentation Scenario'] summary: Retrieve a single action operationId: getPresentationScenarioStepAction responses: @@ -781,7 +781,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' put: - tags: [ "Presentation Scenario" ] + tags: ['Presentation Scenario'] summary: Overwrite an action operationId: updatePresentationScenarioStepAction requestBody: @@ -808,7 +808,7 @@ paths: '500': $ref: '#/components/responses/InternalServerError' delete: - tags: [ "Presentation Scenario" ] + tags: ['Presentation Scenario'] summary: Delete an action operationId: deletePresentationScenarioStepAction responses: @@ -2251,7 +2251,7 @@ components: type: object properties: issuanceScenario: - $ref: '#/components/schemas/IssuanceScenario' + $ref: '#/components/schemas/IssuanceScenario' IssuanceScenario: type: object allOf: @@ -2273,7 +2273,7 @@ components: properties: issuer: type: string - example: "313e4567-e89b-12d3-a456-426614174469" + example: '313e4567-e89b-12d3-a456-426614174469' description: Scenario specialization for credential issuance PresentationScenariosResponse: @@ -2308,7 +2308,7 @@ components: properties: relyingParty: type: string - example: "313e4567-e89b-12d3-a456-426614174469" + example: '313e4567-e89b-12d3-a456-426614174469' IdentifierType: type: string @@ -2385,12 +2385,12 @@ components: type: string description: Date and time the issuer was created format: date-time - example: "2025-03-06T11:30:16.573Z" + example: '2025-03-06T11:30:16.573Z' updatedAt: type: string description: Date and time the issuer was last updated format: date-time - example: "2025-03-06T11:30:16.573Z" + example: '2025-03-06T11:30:16.573Z' IssuerRequest: type: object required: @@ -2488,12 +2488,12 @@ components: type: string description: Date and time the relying party was created format: date-time - example: "2025-03-06T11:30:16.573Z" + example: '2025-03-06T11:30:16.573Z' updatedAt: type: string description: Date and time the relying party was last updated format: date-time - example: "2025-03-06T11:30:16.573Z" + example: '2025-03-06T11:30:16.573Z' RelyingPartyRequest: type: object required: @@ -2670,7 +2670,7 @@ components: properties: credentialDefinitions: type: array - description: "List of credential definitions" + description: 'List of credential definitions' items: $ref: '#/components/schemas/CredentialDefinition' CredentialDefinitionResponse: @@ -2830,7 +2830,7 @@ components: id: type: string description: Unique identifier for the credential schema - example: 123e4567-e89b-12d3-a456-426614174123 + example: 123e4567-e89b-12d3-a456-426614174123 name: type: string description: Name of the credential schema @@ -2893,7 +2893,7 @@ components: properties: credentialSchemas: type: array - description: "List of credential schemas" + description: 'List of credential schemas' items: $ref: '#/components/schemas/CredentialSchema' CredentialSchemaResponse: @@ -2962,7 +2962,7 @@ components: completionMessage: type: string description: Message to display when the showcase is completed - example: "You have successfully completed the showcase" + example: 'You have successfully completed the showcase' createdAt: type: string description: Date and time the showcase was created @@ -2978,7 +2978,7 @@ components: properties: showcases: type: array - description: "List of showcases" + description: 'List of showcases' items: $ref: '#/components/schemas/Showcase' ShowcaseResponse: @@ -3033,14 +3033,14 @@ components: example: 123e4567-e89b-12d3-a456-426614174469 completionMessage: type: string - example: "You have successfully completed the showcase" + example: 'You have successfully completed the showcase' ShowcaseStatus: type: string enum: - - PENDING - - ACTIVE - - ARCHIVED + - PENDING + - ACTIVE + - ARCHIVED description: Types of supported credentials example: PENDING diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 6359c03..9e2819f 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -5,7 +5,6 @@ settings: excludeLinksFromLockfile: false importers: - .: devDependencies: '@types/jest': @@ -159,507 +158,506 @@ importers: version: 7.0.0 packages: - '@ampproject/remapping@2.3.0': - resolution: {integrity: sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==} - engines: {node: '>=6.0.0'} + resolution: { integrity: sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw== } + engines: { node: '>=6.0.0' } '@babel/code-frame@7.26.2': - resolution: {integrity: sha512-RJlIHRueQgwWitWgF8OdFYGZX328Ax5BCemNGlqHfplnRT9ESi8JkFlvaVYbS+UubVY6dpv87Fs2u5M29iNFVQ==} - engines: {node: '>=6.9.0'} + resolution: { integrity: sha512-RJlIHRueQgwWitWgF8OdFYGZX328Ax5BCemNGlqHfplnRT9ESi8JkFlvaVYbS+UubVY6dpv87Fs2u5M29iNFVQ== } + engines: { node: '>=6.9.0' } '@babel/compat-data@7.26.5': - resolution: {integrity: sha512-XvcZi1KWf88RVbF9wn8MN6tYFloU5qX8KjuF3E1PVBmJ9eypXfs4GRiJwLuTZL0iSnJUKn1BFPa5BPZZJyFzPg==} - engines: {node: '>=6.9.0'} + resolution: { integrity: sha512-XvcZi1KWf88RVbF9wn8MN6tYFloU5qX8KjuF3E1PVBmJ9eypXfs4GRiJwLuTZL0iSnJUKn1BFPa5BPZZJyFzPg== } + engines: { node: '>=6.9.0' } '@babel/core@7.26.7': - resolution: {integrity: sha512-SRijHmF0PSPgLIBYlWnG0hyeJLwXE2CgpsXaMOrtt2yp9/86ALw6oUlj9KYuZ0JN07T4eBMVIW4li/9S1j2BGA==} - engines: {node: '>=6.9.0'} + resolution: { integrity: sha512-SRijHmF0PSPgLIBYlWnG0hyeJLwXE2CgpsXaMOrtt2yp9/86ALw6oUlj9KYuZ0JN07T4eBMVIW4li/9S1j2BGA== } + engines: { node: '>=6.9.0' } '@babel/generator@7.26.5': - resolution: {integrity: sha512-2caSP6fN9I7HOe6nqhtft7V4g7/V/gfDsC3Ag4W7kEzzvRGKqiv0pu0HogPiZ3KaVSoNDhUws6IJjDjpfmYIXw==} - engines: {node: '>=6.9.0'} + resolution: { integrity: sha512-2caSP6fN9I7HOe6nqhtft7V4g7/V/gfDsC3Ag4W7kEzzvRGKqiv0pu0HogPiZ3KaVSoNDhUws6IJjDjpfmYIXw== } + engines: { node: '>=6.9.0' } '@babel/helper-compilation-targets@7.26.5': - resolution: {integrity: sha512-IXuyn5EkouFJscIDuFF5EsiSolseme1s0CZB+QxVugqJLYmKdxI1VfIBOst0SUu4rnk2Z7kqTwmoO1lp3HIfnA==} - engines: {node: '>=6.9.0'} + resolution: { integrity: sha512-IXuyn5EkouFJscIDuFF5EsiSolseme1s0CZB+QxVugqJLYmKdxI1VfIBOst0SUu4rnk2Z7kqTwmoO1lp3HIfnA== } + engines: { node: '>=6.9.0' } '@babel/helper-module-imports@7.25.9': - resolution: {integrity: sha512-tnUA4RsrmflIM6W6RFTLFSXITtl0wKjgpnLgXyowocVPrbYrLUXSBXDgTs8BlbmIzIdlBySRQjINYs2BAkiLtw==} - engines: {node: '>=6.9.0'} + resolution: { integrity: sha512-tnUA4RsrmflIM6W6RFTLFSXITtl0wKjgpnLgXyowocVPrbYrLUXSBXDgTs8BlbmIzIdlBySRQjINYs2BAkiLtw== } + engines: { node: '>=6.9.0' } '@babel/helper-module-transforms@7.26.0': - resolution: {integrity: sha512-xO+xu6B5K2czEnQye6BHA7DolFFmS3LB7stHZFaOLb1pAwO1HWLS8fXA+eh0A2yIvltPVmx3eNNDBJA2SLHXFw==} - engines: {node: '>=6.9.0'} + resolution: { integrity: sha512-xO+xu6B5K2czEnQye6BHA7DolFFmS3LB7stHZFaOLb1pAwO1HWLS8fXA+eh0A2yIvltPVmx3eNNDBJA2SLHXFw== } + engines: { node: '>=6.9.0' } peerDependencies: '@babel/core': ^7.0.0 '@babel/helper-plugin-utils@7.26.5': - resolution: {integrity: sha512-RS+jZcRdZdRFzMyr+wcsaqOmld1/EqTghfaBGQQd/WnRdzdlvSZ//kF7U8VQTxf1ynZ4cjUcYgjVGx13ewNPMg==} - engines: {node: '>=6.9.0'} + resolution: { integrity: sha512-RS+jZcRdZdRFzMyr+wcsaqOmld1/EqTghfaBGQQd/WnRdzdlvSZ//kF7U8VQTxf1ynZ4cjUcYgjVGx13ewNPMg== } + engines: { node: '>=6.9.0' } '@babel/helper-string-parser@7.25.9': - resolution: {integrity: sha512-4A/SCr/2KLd5jrtOMFzaKjVtAei3+2r/NChoBNoZ3EyP/+GlhoaEGoWOZUmFmoITP7zOJyHIMm+DYRd8o3PvHA==} - engines: {node: '>=6.9.0'} + resolution: { integrity: sha512-4A/SCr/2KLd5jrtOMFzaKjVtAei3+2r/NChoBNoZ3EyP/+GlhoaEGoWOZUmFmoITP7zOJyHIMm+DYRd8o3PvHA== } + engines: { node: '>=6.9.0' } '@babel/helper-validator-identifier@7.25.9': - resolution: {integrity: sha512-Ed61U6XJc3CVRfkERJWDz4dJwKe7iLmmJsbOGu9wSloNSFttHV0I8g6UAgb7qnK5ly5bGLPd4oXZlxCdANBOWQ==} - engines: {node: '>=6.9.0'} + resolution: { integrity: sha512-Ed61U6XJc3CVRfkERJWDz4dJwKe7iLmmJsbOGu9wSloNSFttHV0I8g6UAgb7qnK5ly5bGLPd4oXZlxCdANBOWQ== } + engines: { node: '>=6.9.0' } '@babel/helper-validator-option@7.25.9': - resolution: {integrity: sha512-e/zv1co8pp55dNdEcCynfj9X7nyUKUXoUEwfXqaZt0omVOmDe9oOTdKStH4GmAw6zxMFs50ZayuMfHDKlO7Tfw==} - engines: {node: '>=6.9.0'} + resolution: { integrity: sha512-e/zv1co8pp55dNdEcCynfj9X7nyUKUXoUEwfXqaZt0omVOmDe9oOTdKStH4GmAw6zxMFs50ZayuMfHDKlO7Tfw== } + engines: { node: '>=6.9.0' } '@babel/helpers@7.26.7': - resolution: {integrity: sha512-8NHiL98vsi0mbPQmYAGWwfcFaOy4j2HY49fXJCfuDcdE7fMIsH9a7GdaeXpIBsbT7307WU8KCMp5pUVDNL4f9A==} - engines: {node: '>=6.9.0'} + resolution: { integrity: sha512-8NHiL98vsi0mbPQmYAGWwfcFaOy4j2HY49fXJCfuDcdE7fMIsH9a7GdaeXpIBsbT7307WU8KCMp5pUVDNL4f9A== } + engines: { node: '>=6.9.0' } '@babel/parser@7.26.7': - resolution: {integrity: sha512-kEvgGGgEjRUutvdVvZhbn/BxVt+5VSpwXz1j3WYXQbXDo8KzFOPNG2GQbdAiNq8g6wn1yKk7C/qrke03a84V+w==} - engines: {node: '>=6.0.0'} + resolution: { integrity: sha512-kEvgGGgEjRUutvdVvZhbn/BxVt+5VSpwXz1j3WYXQbXDo8KzFOPNG2GQbdAiNq8g6wn1yKk7C/qrke03a84V+w== } + engines: { node: '>=6.0.0' } hasBin: true '@babel/plugin-proposal-export-namespace-from@7.18.9': - resolution: {integrity: sha512-k1NtHyOMvlDDFeb9G5PhUXuGj8m/wiwojgQVEhJ/fsVsMCpLyOP4h0uGEjYJKrRI+EVPlb5Jk+Gt9P97lOGwtA==} - engines: {node: '>=6.9.0'} + resolution: { integrity: sha512-k1NtHyOMvlDDFeb9G5PhUXuGj8m/wiwojgQVEhJ/fsVsMCpLyOP4h0uGEjYJKrRI+EVPlb5Jk+Gt9P97lOGwtA== } + engines: { node: '>=6.9.0' } deprecated: This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-export-namespace-from instead. peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-async-generators@7.8.4': - resolution: {integrity: sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==} + resolution: { integrity: sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw== } peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-bigint@7.8.3': - resolution: {integrity: sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg==} + resolution: { integrity: sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg== } peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-class-properties@7.12.13': - resolution: {integrity: sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==} + resolution: { integrity: sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA== } peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-class-static-block@7.14.5': - resolution: {integrity: sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw==} - engines: {node: '>=6.9.0'} + resolution: { integrity: sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw== } + engines: { node: '>=6.9.0' } peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-export-namespace-from@7.8.3': - resolution: {integrity: sha512-MXf5laXo6c1IbEbegDmzGPwGNTsHZmEy6QGznu5Sh2UCWvueywb2ee+CCE4zQiZstxU9BMoQO9i6zUFSY0Kj0Q==} + resolution: { integrity: sha512-MXf5laXo6c1IbEbegDmzGPwGNTsHZmEy6QGznu5Sh2UCWvueywb2ee+CCE4zQiZstxU9BMoQO9i6zUFSY0Kj0Q== } peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-import-attributes@7.26.0': - resolution: {integrity: sha512-e2dttdsJ1ZTpi3B9UYGLw41hifAubg19AtCu/2I/F1QNVclOBr1dYpTdmdyZ84Xiz43BS/tCUkMAZNLv12Pi+A==} - engines: {node: '>=6.9.0'} + resolution: { integrity: sha512-e2dttdsJ1ZTpi3B9UYGLw41hifAubg19AtCu/2I/F1QNVclOBr1dYpTdmdyZ84Xiz43BS/tCUkMAZNLv12Pi+A== } + engines: { node: '>=6.9.0' } peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-import-meta@7.10.4': - resolution: {integrity: sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==} + resolution: { integrity: sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g== } peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-json-strings@7.8.3': - resolution: {integrity: sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==} + resolution: { integrity: sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA== } peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-jsx@7.25.9': - resolution: {integrity: sha512-ld6oezHQMZsZfp6pWtbjaNDF2tiiCYYDqQszHt5VV437lewP9aSi2Of99CK0D0XB21k7FLgnLcmQKyKzynfeAA==} - engines: {node: '>=6.9.0'} + resolution: { integrity: sha512-ld6oezHQMZsZfp6pWtbjaNDF2tiiCYYDqQszHt5VV437lewP9aSi2Of99CK0D0XB21k7FLgnLcmQKyKzynfeAA== } + engines: { node: '>=6.9.0' } peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-logical-assignment-operators@7.10.4': - resolution: {integrity: sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==} + resolution: { integrity: sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig== } peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-nullish-coalescing-operator@7.8.3': - resolution: {integrity: sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==} + resolution: { integrity: sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ== } peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-numeric-separator@7.10.4': - resolution: {integrity: sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==} + resolution: { integrity: sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug== } peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-object-rest-spread@7.8.3': - resolution: {integrity: sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==} + resolution: { integrity: sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA== } peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-optional-catch-binding@7.8.3': - resolution: {integrity: sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==} + resolution: { integrity: sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q== } peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-optional-chaining@7.8.3': - resolution: {integrity: sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==} + resolution: { integrity: sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg== } peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-private-property-in-object@7.14.5': - resolution: {integrity: sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg==} - engines: {node: '>=6.9.0'} + resolution: { integrity: sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg== } + engines: { node: '>=6.9.0' } peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-top-level-await@7.14.5': - resolution: {integrity: sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==} - engines: {node: '>=6.9.0'} + resolution: { integrity: sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw== } + engines: { node: '>=6.9.0' } peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-typescript@7.25.9': - resolution: {integrity: sha512-hjMgRy5hb8uJJjUcdWunWVcoi9bGpJp8p5Ol1229PoN6aytsLwNMgmdftO23wnCLMfVmTwZDWMPNq/D1SY60JQ==} - engines: {node: '>=6.9.0'} + resolution: { integrity: sha512-hjMgRy5hb8uJJjUcdWunWVcoi9bGpJp8p5Ol1229PoN6aytsLwNMgmdftO23wnCLMfVmTwZDWMPNq/D1SY60JQ== } + engines: { node: '>=6.9.0' } peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-transform-modules-commonjs@7.26.3': - resolution: {integrity: sha512-MgR55l4q9KddUDITEzEFYn5ZsGDXMSsU9E+kh7fjRXTIC3RHqfCo8RPRbyReYJh44HQ/yomFkqbOFohXvDCiIQ==} - engines: {node: '>=6.9.0'} + resolution: { integrity: sha512-MgR55l4q9KddUDITEzEFYn5ZsGDXMSsU9E+kh7fjRXTIC3RHqfCo8RPRbyReYJh44HQ/yomFkqbOFohXvDCiIQ== } + engines: { node: '>=6.9.0' } peerDependencies: '@babel/core': ^7.0.0-0 '@babel/template@7.25.9': - resolution: {integrity: sha512-9DGttpmPvIxBb/2uwpVo3dqJ+O6RooAFOS+lB+xDqoE2PVCE8nfoHMdZLpfCQRLwvohzXISPZcgxt80xLfsuwg==} - engines: {node: '>=6.9.0'} + resolution: { integrity: sha512-9DGttpmPvIxBb/2uwpVo3dqJ+O6RooAFOS+lB+xDqoE2PVCE8nfoHMdZLpfCQRLwvohzXISPZcgxt80xLfsuwg== } + engines: { node: '>=6.9.0' } '@babel/traverse@7.26.7': - resolution: {integrity: sha512-1x1sgeyRLC3r5fQOM0/xtQKsYjyxmFjaOrLJNtZ81inNjyJHGIolTULPiSc/2qe1/qfpFLisLQYFnnZl7QoedA==} - engines: {node: '>=6.9.0'} + resolution: { integrity: sha512-1x1sgeyRLC3r5fQOM0/xtQKsYjyxmFjaOrLJNtZ81inNjyJHGIolTULPiSc/2qe1/qfpFLisLQYFnnZl7QoedA== } + engines: { node: '>=6.9.0' } '@babel/types@7.26.7': - resolution: {integrity: sha512-t8kDRGrKXyp6+tjUh7hw2RLyclsW4TRoRvRHtSyAX9Bb5ldlFh+90YAYY6awRXrlB4G5G2izNeGySpATlFzmOg==} - engines: {node: '>=6.9.0'} + resolution: { integrity: sha512-t8kDRGrKXyp6+tjUh7hw2RLyclsW4TRoRvRHtSyAX9Bb5ldlFh+90YAYY6awRXrlB4G5G2izNeGySpATlFzmOg== } + engines: { node: '>=6.9.0' } '@balena/dockerignore@1.0.2': - resolution: {integrity: sha512-wMue2Sy4GAVTk6Ic4tJVcnfdau+gx2EnG7S+uAEe+TWJFqE4YoWN4/H8MSLj4eYJKxGg26lZwboEniNiNwZQ6Q==} + resolution: { integrity: sha512-wMue2Sy4GAVTk6Ic4tJVcnfdau+gx2EnG7S+uAEe+TWJFqE4YoWN4/H8MSLj4eYJKxGg26lZwboEniNiNwZQ6Q== } '@bcoe/v8-coverage@0.2.3': - resolution: {integrity: sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==} + resolution: { integrity: sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw== } '@cspotcode/source-map-support@0.8.1': - resolution: {integrity: sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==} - engines: {node: '>=12'} + resolution: { integrity: sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw== } + engines: { node: '>=12' } '@drizzle-team/brocli@0.10.2': - resolution: {integrity: sha512-z33Il7l5dKjUgGULTqBsQBQwckHh5AbIuxhdsIxDDiZAzBOrZO6q9ogcWC65kU382AfynTfgNumVcNIjuIua6w==} + resolution: { integrity: sha512-z33Il7l5dKjUgGULTqBsQBQwckHh5AbIuxhdsIxDDiZAzBOrZO6q9ogcWC65kU382AfynTfgNumVcNIjuIua6w== } '@electric-sql/pglite@0.2.17': - resolution: {integrity: sha512-qEpKRT2oUaWDH6tjRxLHjdzMqRUGYDnGZlKrnL4dJ77JVMcP2Hpo3NYnOSPKdZdeec57B6QPprCUFg0picx5Pw==} + resolution: { integrity: sha512-qEpKRT2oUaWDH6tjRxLHjdzMqRUGYDnGZlKrnL4dJ77JVMcP2Hpo3NYnOSPKdZdeec57B6QPprCUFg0picx5Pw== } '@esbuild-kit/core-utils@3.3.2': - resolution: {integrity: sha512-sPRAnw9CdSsRmEtnsl2WXWdyquogVpB3yZ3dgwJfe8zrOzTsV7cJvmwrKVa+0ma5BoiGJ+BoqkMvawbayKUsqQ==} + resolution: { integrity: sha512-sPRAnw9CdSsRmEtnsl2WXWdyquogVpB3yZ3dgwJfe8zrOzTsV7cJvmwrKVa+0ma5BoiGJ+BoqkMvawbayKUsqQ== } deprecated: 'Merged into tsx: https://tsx.is' '@esbuild-kit/esm-loader@2.6.5': - resolution: {integrity: sha512-FxEMIkJKnodyA1OaCUoEvbYRkoZlLZ4d/eXFu9Fh8CbBBgP5EmZxrfTRyN0qpXZ4vOvqnE5YdRdcrmUUXuU+dA==} + resolution: { integrity: sha512-FxEMIkJKnodyA1OaCUoEvbYRkoZlLZ4d/eXFu9Fh8CbBBgP5EmZxrfTRyN0qpXZ4vOvqnE5YdRdcrmUUXuU+dA== } deprecated: 'Merged into tsx: https://tsx.is' '@esbuild/aix-ppc64@0.19.12': - resolution: {integrity: sha512-bmoCYyWdEL3wDQIVbcyzRyeKLgk2WtWLTWz1ZIAZF/EGbNOwSA6ew3PftJ1PqMiOOGu0OyFMzG53L0zqIpPeNA==} - engines: {node: '>=12'} + resolution: { integrity: sha512-bmoCYyWdEL3wDQIVbcyzRyeKLgk2WtWLTWz1ZIAZF/EGbNOwSA6ew3PftJ1PqMiOOGu0OyFMzG53L0zqIpPeNA== } + engines: { node: '>=12' } cpu: [ppc64] os: [aix] '@esbuild/android-arm64@0.18.20': - resolution: {integrity: sha512-Nz4rJcchGDtENV0eMKUNa6L12zz2zBDXuhj/Vjh18zGqB44Bi7MBMSXjgunJgjRhCmKOjnPuZp4Mb6OKqtMHLQ==} - engines: {node: '>=12'} + resolution: { integrity: sha512-Nz4rJcchGDtENV0eMKUNa6L12zz2zBDXuhj/Vjh18zGqB44Bi7MBMSXjgunJgjRhCmKOjnPuZp4Mb6OKqtMHLQ== } + engines: { node: '>=12' } cpu: [arm64] os: [android] '@esbuild/android-arm64@0.19.12': - resolution: {integrity: sha512-P0UVNGIienjZv3f5zq0DP3Nt2IE/3plFzuaS96vihvD0Hd6H/q4WXUGpCxD/E8YrSXfNyRPbpTq+T8ZQioSuPA==} - engines: {node: '>=12'} + resolution: { integrity: sha512-P0UVNGIienjZv3f5zq0DP3Nt2IE/3plFzuaS96vihvD0Hd6H/q4WXUGpCxD/E8YrSXfNyRPbpTq+T8ZQioSuPA== } + engines: { node: '>=12' } cpu: [arm64] os: [android] '@esbuild/android-arm@0.18.20': - resolution: {integrity: sha512-fyi7TDI/ijKKNZTUJAQqiG5T7YjJXgnzkURqmGj13C6dCqckZBLdl4h7bkhHt/t0WP+zO9/zwroDvANaOqO5Sw==} - engines: {node: '>=12'} + resolution: { integrity: sha512-fyi7TDI/ijKKNZTUJAQqiG5T7YjJXgnzkURqmGj13C6dCqckZBLdl4h7bkhHt/t0WP+zO9/zwroDvANaOqO5Sw== } + engines: { node: '>=12' } cpu: [arm] os: [android] '@esbuild/android-arm@0.19.12': - resolution: {integrity: sha512-qg/Lj1mu3CdQlDEEiWrlC4eaPZ1KztwGJ9B6J+/6G+/4ewxJg7gqj8eVYWvao1bXrqGiW2rsBZFSX3q2lcW05w==} - engines: {node: '>=12'} + resolution: { integrity: sha512-qg/Lj1mu3CdQlDEEiWrlC4eaPZ1KztwGJ9B6J+/6G+/4ewxJg7gqj8eVYWvao1bXrqGiW2rsBZFSX3q2lcW05w== } + engines: { node: '>=12' } cpu: [arm] os: [android] '@esbuild/android-x64@0.18.20': - resolution: {integrity: sha512-8GDdlePJA8D6zlZYJV/jnrRAi6rOiNaCC/JclcXpB+KIuvfBN4owLtgzY2bsxnx666XjJx2kDPUmnTtR8qKQUg==} - engines: {node: '>=12'} + resolution: { integrity: sha512-8GDdlePJA8D6zlZYJV/jnrRAi6rOiNaCC/JclcXpB+KIuvfBN4owLtgzY2bsxnx666XjJx2kDPUmnTtR8qKQUg== } + engines: { node: '>=12' } cpu: [x64] os: [android] '@esbuild/android-x64@0.19.12': - resolution: {integrity: sha512-3k7ZoUW6Q6YqhdhIaq/WZ7HwBpnFBlW905Fa4s4qWJyiNOgT1dOqDiVAQFwBH7gBRZr17gLrlFCRzF6jFh7Kew==} - engines: {node: '>=12'} + resolution: { integrity: sha512-3k7ZoUW6Q6YqhdhIaq/WZ7HwBpnFBlW905Fa4s4qWJyiNOgT1dOqDiVAQFwBH7gBRZr17gLrlFCRzF6jFh7Kew== } + engines: { node: '>=12' } cpu: [x64] os: [android] '@esbuild/darwin-arm64@0.18.20': - resolution: {integrity: sha512-bxRHW5kHU38zS2lPTPOyuyTm+S+eobPUnTNkdJEfAddYgEcll4xkT8DB9d2008DtTbl7uJag2HuE5NZAZgnNEA==} - engines: {node: '>=12'} + resolution: { integrity: sha512-bxRHW5kHU38zS2lPTPOyuyTm+S+eobPUnTNkdJEfAddYgEcll4xkT8DB9d2008DtTbl7uJag2HuE5NZAZgnNEA== } + engines: { node: '>=12' } cpu: [arm64] os: [darwin] '@esbuild/darwin-arm64@0.19.12': - resolution: {integrity: sha512-B6IeSgZgtEzGC42jsI+YYu9Z3HKRxp8ZT3cqhvliEHovq8HSX2YX8lNocDn79gCKJXOSaEot9MVYky7AKjCs8g==} - engines: {node: '>=12'} + resolution: { integrity: sha512-B6IeSgZgtEzGC42jsI+YYu9Z3HKRxp8ZT3cqhvliEHovq8HSX2YX8lNocDn79gCKJXOSaEot9MVYky7AKjCs8g== } + engines: { node: '>=12' } cpu: [arm64] os: [darwin] '@esbuild/darwin-x64@0.18.20': - resolution: {integrity: sha512-pc5gxlMDxzm513qPGbCbDukOdsGtKhfxD1zJKXjCCcU7ju50O7MeAZ8c4krSJcOIJGFR+qx21yMMVYwiQvyTyQ==} - engines: {node: '>=12'} + resolution: { integrity: sha512-pc5gxlMDxzm513qPGbCbDukOdsGtKhfxD1zJKXjCCcU7ju50O7MeAZ8c4krSJcOIJGFR+qx21yMMVYwiQvyTyQ== } + engines: { node: '>=12' } cpu: [x64] os: [darwin] '@esbuild/darwin-x64@0.19.12': - resolution: {integrity: sha512-hKoVkKzFiToTgn+41qGhsUJXFlIjxI/jSYeZf3ugemDYZldIXIxhvwN6erJGlX4t5h417iFuheZ7l+YVn05N3A==} - engines: {node: '>=12'} + resolution: { integrity: sha512-hKoVkKzFiToTgn+41qGhsUJXFlIjxI/jSYeZf3ugemDYZldIXIxhvwN6erJGlX4t5h417iFuheZ7l+YVn05N3A== } + engines: { node: '>=12' } cpu: [x64] os: [darwin] '@esbuild/freebsd-arm64@0.18.20': - resolution: {integrity: sha512-yqDQHy4QHevpMAaxhhIwYPMv1NECwOvIpGCZkECn8w2WFHXjEwrBn3CeNIYsibZ/iZEUemj++M26W3cNR5h+Tw==} - engines: {node: '>=12'} + resolution: { integrity: sha512-yqDQHy4QHevpMAaxhhIwYPMv1NECwOvIpGCZkECn8w2WFHXjEwrBn3CeNIYsibZ/iZEUemj++M26W3cNR5h+Tw== } + engines: { node: '>=12' } cpu: [arm64] os: [freebsd] '@esbuild/freebsd-arm64@0.19.12': - resolution: {integrity: sha512-4aRvFIXmwAcDBw9AueDQ2YnGmz5L6obe5kmPT8Vd+/+x/JMVKCgdcRwH6APrbpNXsPz+K653Qg8HB/oXvXVukA==} - engines: {node: '>=12'} + resolution: { integrity: sha512-4aRvFIXmwAcDBw9AueDQ2YnGmz5L6obe5kmPT8Vd+/+x/JMVKCgdcRwH6APrbpNXsPz+K653Qg8HB/oXvXVukA== } + engines: { node: '>=12' } cpu: [arm64] os: [freebsd] '@esbuild/freebsd-x64@0.18.20': - resolution: {integrity: sha512-tgWRPPuQsd3RmBZwarGVHZQvtzfEBOreNuxEMKFcd5DaDn2PbBxfwLcj4+aenoh7ctXcbXmOQIn8HI6mCSw5MQ==} - engines: {node: '>=12'} + resolution: { integrity: sha512-tgWRPPuQsd3RmBZwarGVHZQvtzfEBOreNuxEMKFcd5DaDn2PbBxfwLcj4+aenoh7ctXcbXmOQIn8HI6mCSw5MQ== } + engines: { node: '>=12' } cpu: [x64] os: [freebsd] '@esbuild/freebsd-x64@0.19.12': - resolution: {integrity: sha512-EYoXZ4d8xtBoVN7CEwWY2IN4ho76xjYXqSXMNccFSx2lgqOG/1TBPW0yPx1bJZk94qu3tX0fycJeeQsKovA8gg==} - engines: {node: '>=12'} + resolution: { integrity: sha512-EYoXZ4d8xtBoVN7CEwWY2IN4ho76xjYXqSXMNccFSx2lgqOG/1TBPW0yPx1bJZk94qu3tX0fycJeeQsKovA8gg== } + engines: { node: '>=12' } cpu: [x64] os: [freebsd] '@esbuild/linux-arm64@0.18.20': - resolution: {integrity: sha512-2YbscF+UL7SQAVIpnWvYwM+3LskyDmPhe31pE7/aoTMFKKzIc9lLbyGUpmmb8a8AixOL61sQ/mFh3jEjHYFvdA==} - engines: {node: '>=12'} + resolution: { integrity: sha512-2YbscF+UL7SQAVIpnWvYwM+3LskyDmPhe31pE7/aoTMFKKzIc9lLbyGUpmmb8a8AixOL61sQ/mFh3jEjHYFvdA== } + engines: { node: '>=12' } cpu: [arm64] os: [linux] '@esbuild/linux-arm64@0.19.12': - resolution: {integrity: sha512-EoTjyYyLuVPfdPLsGVVVC8a0p1BFFvtpQDB/YLEhaXyf/5bczaGeN15QkR+O4S5LeJ92Tqotve7i1jn35qwvdA==} - engines: {node: '>=12'} + resolution: { integrity: sha512-EoTjyYyLuVPfdPLsGVVVC8a0p1BFFvtpQDB/YLEhaXyf/5bczaGeN15QkR+O4S5LeJ92Tqotve7i1jn35qwvdA== } + engines: { node: '>=12' } cpu: [arm64] os: [linux] '@esbuild/linux-arm@0.18.20': - resolution: {integrity: sha512-/5bHkMWnq1EgKr1V+Ybz3s1hWXok7mDFUMQ4cG10AfW3wL02PSZi5kFpYKrptDsgb2WAJIvRcDm+qIvXf/apvg==} - engines: {node: '>=12'} + resolution: { integrity: sha512-/5bHkMWnq1EgKr1V+Ybz3s1hWXok7mDFUMQ4cG10AfW3wL02PSZi5kFpYKrptDsgb2WAJIvRcDm+qIvXf/apvg== } + engines: { node: '>=12' } cpu: [arm] os: [linux] '@esbuild/linux-arm@0.19.12': - resolution: {integrity: sha512-J5jPms//KhSNv+LO1S1TX1UWp1ucM6N6XuL6ITdKWElCu8wXP72l9MM0zDTzzeikVyqFE6U8YAV9/tFyj0ti+w==} - engines: {node: '>=12'} + resolution: { integrity: sha512-J5jPms//KhSNv+LO1S1TX1UWp1ucM6N6XuL6ITdKWElCu8wXP72l9MM0zDTzzeikVyqFE6U8YAV9/tFyj0ti+w== } + engines: { node: '>=12' } cpu: [arm] os: [linux] '@esbuild/linux-ia32@0.18.20': - resolution: {integrity: sha512-P4etWwq6IsReT0E1KHU40bOnzMHoH73aXp96Fs8TIT6z9Hu8G6+0SHSw9i2isWrD2nbx2qo5yUqACgdfVGx7TA==} - engines: {node: '>=12'} + resolution: { integrity: sha512-P4etWwq6IsReT0E1KHU40bOnzMHoH73aXp96Fs8TIT6z9Hu8G6+0SHSw9i2isWrD2nbx2qo5yUqACgdfVGx7TA== } + engines: { node: '>=12' } cpu: [ia32] os: [linux] '@esbuild/linux-ia32@0.19.12': - resolution: {integrity: sha512-Thsa42rrP1+UIGaWz47uydHSBOgTUnwBwNq59khgIwktK6x60Hivfbux9iNR0eHCHzOLjLMLfUMLCypBkZXMHA==} - engines: {node: '>=12'} + resolution: { integrity: sha512-Thsa42rrP1+UIGaWz47uydHSBOgTUnwBwNq59khgIwktK6x60Hivfbux9iNR0eHCHzOLjLMLfUMLCypBkZXMHA== } + engines: { node: '>=12' } cpu: [ia32] os: [linux] '@esbuild/linux-loong64@0.18.20': - resolution: {integrity: sha512-nXW8nqBTrOpDLPgPY9uV+/1DjxoQ7DoB2N8eocyq8I9XuqJ7BiAMDMf9n1xZM9TgW0J8zrquIb/A7s3BJv7rjg==} - engines: {node: '>=12'} + resolution: { integrity: sha512-nXW8nqBTrOpDLPgPY9uV+/1DjxoQ7DoB2N8eocyq8I9XuqJ7BiAMDMf9n1xZM9TgW0J8zrquIb/A7s3BJv7rjg== } + engines: { node: '>=12' } cpu: [loong64] os: [linux] '@esbuild/linux-loong64@0.19.12': - resolution: {integrity: sha512-LiXdXA0s3IqRRjm6rV6XaWATScKAXjI4R4LoDlvO7+yQqFdlr1Bax62sRwkVvRIrwXxvtYEHHI4dm50jAXkuAA==} - engines: {node: '>=12'} + resolution: { integrity: sha512-LiXdXA0s3IqRRjm6rV6XaWATScKAXjI4R4LoDlvO7+yQqFdlr1Bax62sRwkVvRIrwXxvtYEHHI4dm50jAXkuAA== } + engines: { node: '>=12' } cpu: [loong64] os: [linux] '@esbuild/linux-mips64el@0.18.20': - resolution: {integrity: sha512-d5NeaXZcHp8PzYy5VnXV3VSd2D328Zb+9dEq5HE6bw6+N86JVPExrA6O68OPwobntbNJ0pzCpUFZTo3w0GyetQ==} - engines: {node: '>=12'} + resolution: { integrity: sha512-d5NeaXZcHp8PzYy5VnXV3VSd2D328Zb+9dEq5HE6bw6+N86JVPExrA6O68OPwobntbNJ0pzCpUFZTo3w0GyetQ== } + engines: { node: '>=12' } cpu: [mips64el] os: [linux] '@esbuild/linux-mips64el@0.19.12': - resolution: {integrity: sha512-fEnAuj5VGTanfJ07ff0gOA6IPsvrVHLVb6Lyd1g2/ed67oU1eFzL0r9WL7ZzscD+/N6i3dWumGE1Un4f7Amf+w==} - engines: {node: '>=12'} + resolution: { integrity: sha512-fEnAuj5VGTanfJ07ff0gOA6IPsvrVHLVb6Lyd1g2/ed67oU1eFzL0r9WL7ZzscD+/N6i3dWumGE1Un4f7Amf+w== } + engines: { node: '>=12' } cpu: [mips64el] os: [linux] '@esbuild/linux-ppc64@0.18.20': - resolution: {integrity: sha512-WHPyeScRNcmANnLQkq6AfyXRFr5D6N2sKgkFo2FqguP44Nw2eyDlbTdZwd9GYk98DZG9QItIiTlFLHJHjxP3FA==} - engines: {node: '>=12'} + resolution: { integrity: sha512-WHPyeScRNcmANnLQkq6AfyXRFr5D6N2sKgkFo2FqguP44Nw2eyDlbTdZwd9GYk98DZG9QItIiTlFLHJHjxP3FA== } + engines: { node: '>=12' } cpu: [ppc64] os: [linux] '@esbuild/linux-ppc64@0.19.12': - resolution: {integrity: sha512-nYJA2/QPimDQOh1rKWedNOe3Gfc8PabU7HT3iXWtNUbRzXS9+vgB0Fjaqr//XNbd82mCxHzik2qotuI89cfixg==} - engines: {node: '>=12'} + resolution: { integrity: sha512-nYJA2/QPimDQOh1rKWedNOe3Gfc8PabU7HT3iXWtNUbRzXS9+vgB0Fjaqr//XNbd82mCxHzik2qotuI89cfixg== } + engines: { node: '>=12' } cpu: [ppc64] os: [linux] '@esbuild/linux-riscv64@0.18.20': - resolution: {integrity: sha512-WSxo6h5ecI5XH34KC7w5veNnKkju3zBRLEQNY7mv5mtBmrP/MjNBCAlsM2u5hDBlS3NGcTQpoBvRzqBcRtpq1A==} - engines: {node: '>=12'} + resolution: { integrity: sha512-WSxo6h5ecI5XH34KC7w5veNnKkju3zBRLEQNY7mv5mtBmrP/MjNBCAlsM2u5hDBlS3NGcTQpoBvRzqBcRtpq1A== } + engines: { node: '>=12' } cpu: [riscv64] os: [linux] '@esbuild/linux-riscv64@0.19.12': - resolution: {integrity: sha512-2MueBrlPQCw5dVJJpQdUYgeqIzDQgw3QtiAHUC4RBz9FXPrskyyU3VI1hw7C0BSKB9OduwSJ79FTCqtGMWqJHg==} - engines: {node: '>=12'} + resolution: { integrity: sha512-2MueBrlPQCw5dVJJpQdUYgeqIzDQgw3QtiAHUC4RBz9FXPrskyyU3VI1hw7C0BSKB9OduwSJ79FTCqtGMWqJHg== } + engines: { node: '>=12' } cpu: [riscv64] os: [linux] '@esbuild/linux-s390x@0.18.20': - resolution: {integrity: sha512-+8231GMs3mAEth6Ja1iK0a1sQ3ohfcpzpRLH8uuc5/KVDFneH6jtAJLFGafpzpMRO6DzJ6AvXKze9LfFMrIHVQ==} - engines: {node: '>=12'} + resolution: { integrity: sha512-+8231GMs3mAEth6Ja1iK0a1sQ3ohfcpzpRLH8uuc5/KVDFneH6jtAJLFGafpzpMRO6DzJ6AvXKze9LfFMrIHVQ== } + engines: { node: '>=12' } cpu: [s390x] os: [linux] '@esbuild/linux-s390x@0.19.12': - resolution: {integrity: sha512-+Pil1Nv3Umes4m3AZKqA2anfhJiVmNCYkPchwFJNEJN5QxmTs1uzyy4TvmDrCRNT2ApwSari7ZIgrPeUx4UZDg==} - engines: {node: '>=12'} + resolution: { integrity: sha512-+Pil1Nv3Umes4m3AZKqA2anfhJiVmNCYkPchwFJNEJN5QxmTs1uzyy4TvmDrCRNT2ApwSari7ZIgrPeUx4UZDg== } + engines: { node: '>=12' } cpu: [s390x] os: [linux] '@esbuild/linux-x64@0.18.20': - resolution: {integrity: sha512-UYqiqemphJcNsFEskc73jQ7B9jgwjWrSayxawS6UVFZGWrAAtkzjxSqnoclCXxWtfwLdzU+vTpcNYhpn43uP1w==} - engines: {node: '>=12'} + resolution: { integrity: sha512-UYqiqemphJcNsFEskc73jQ7B9jgwjWrSayxawS6UVFZGWrAAtkzjxSqnoclCXxWtfwLdzU+vTpcNYhpn43uP1w== } + engines: { node: '>=12' } cpu: [x64] os: [linux] '@esbuild/linux-x64@0.19.12': - resolution: {integrity: sha512-B71g1QpxfwBvNrfyJdVDexenDIt1CiDN1TIXLbhOw0KhJzE78KIFGX6OJ9MrtC0oOqMWf+0xop4qEU8JrJTwCg==} - engines: {node: '>=12'} + resolution: { integrity: sha512-B71g1QpxfwBvNrfyJdVDexenDIt1CiDN1TIXLbhOw0KhJzE78KIFGX6OJ9MrtC0oOqMWf+0xop4qEU8JrJTwCg== } + engines: { node: '>=12' } cpu: [x64] os: [linux] '@esbuild/netbsd-x64@0.18.20': - resolution: {integrity: sha512-iO1c++VP6xUBUmltHZoMtCUdPlnPGdBom6IrO4gyKPFFVBKioIImVooR5I83nTew5UOYrk3gIJhbZh8X44y06A==} - engines: {node: '>=12'} + resolution: { integrity: sha512-iO1c++VP6xUBUmltHZoMtCUdPlnPGdBom6IrO4gyKPFFVBKioIImVooR5I83nTew5UOYrk3gIJhbZh8X44y06A== } + engines: { node: '>=12' } cpu: [x64] os: [netbsd] '@esbuild/netbsd-x64@0.19.12': - resolution: {integrity: sha512-3ltjQ7n1owJgFbuC61Oj++XhtzmymoCihNFgT84UAmJnxJfm4sYCiSLTXZtE00VWYpPMYc+ZQmB6xbSdVh0JWA==} - engines: {node: '>=12'} + resolution: { integrity: sha512-3ltjQ7n1owJgFbuC61Oj++XhtzmymoCihNFgT84UAmJnxJfm4sYCiSLTXZtE00VWYpPMYc+ZQmB6xbSdVh0JWA== } + engines: { node: '>=12' } cpu: [x64] os: [netbsd] '@esbuild/openbsd-x64@0.18.20': - resolution: {integrity: sha512-e5e4YSsuQfX4cxcygw/UCPIEP6wbIL+se3sxPdCiMbFLBWu0eiZOJ7WoD+ptCLrmjZBK1Wk7I6D/I3NglUGOxg==} - engines: {node: '>=12'} + resolution: { integrity: sha512-e5e4YSsuQfX4cxcygw/UCPIEP6wbIL+se3sxPdCiMbFLBWu0eiZOJ7WoD+ptCLrmjZBK1Wk7I6D/I3NglUGOxg== } + engines: { node: '>=12' } cpu: [x64] os: [openbsd] '@esbuild/openbsd-x64@0.19.12': - resolution: {integrity: sha512-RbrfTB9SWsr0kWmb9srfF+L933uMDdu9BIzdA7os2t0TXhCRjrQyCeOt6wVxr79CKD4c+p+YhCj31HBkYcXebw==} - engines: {node: '>=12'} + resolution: { integrity: sha512-RbrfTB9SWsr0kWmb9srfF+L933uMDdu9BIzdA7os2t0TXhCRjrQyCeOt6wVxr79CKD4c+p+YhCj31HBkYcXebw== } + engines: { node: '>=12' } cpu: [x64] os: [openbsd] '@esbuild/sunos-x64@0.18.20': - resolution: {integrity: sha512-kDbFRFp0YpTQVVrqUd5FTYmWo45zGaXe0X8E1G/LKFC0v8x0vWrhOWSLITcCn63lmZIxfOMXtCfti/RxN/0wnQ==} - engines: {node: '>=12'} + resolution: { integrity: sha512-kDbFRFp0YpTQVVrqUd5FTYmWo45zGaXe0X8E1G/LKFC0v8x0vWrhOWSLITcCn63lmZIxfOMXtCfti/RxN/0wnQ== } + engines: { node: '>=12' } cpu: [x64] os: [sunos] '@esbuild/sunos-x64@0.19.12': - resolution: {integrity: sha512-HKjJwRrW8uWtCQnQOz9qcU3mUZhTUQvi56Q8DPTLLB+DawoiQdjsYq+j+D3s9I8VFtDr+F9CjgXKKC4ss89IeA==} - engines: {node: '>=12'} + resolution: { integrity: sha512-HKjJwRrW8uWtCQnQOz9qcU3mUZhTUQvi56Q8DPTLLB+DawoiQdjsYq+j+D3s9I8VFtDr+F9CjgXKKC4ss89IeA== } + engines: { node: '>=12' } cpu: [x64] os: [sunos] '@esbuild/win32-arm64@0.18.20': - resolution: {integrity: sha512-ddYFR6ItYgoaq4v4JmQQaAI5s7npztfV4Ag6NrhiaW0RrnOXqBkgwZLofVTlq1daVTQNhtI5oieTvkRPfZrePg==} - engines: {node: '>=12'} + resolution: { integrity: sha512-ddYFR6ItYgoaq4v4JmQQaAI5s7npztfV4Ag6NrhiaW0RrnOXqBkgwZLofVTlq1daVTQNhtI5oieTvkRPfZrePg== } + engines: { node: '>=12' } cpu: [arm64] os: [win32] '@esbuild/win32-arm64@0.19.12': - resolution: {integrity: sha512-URgtR1dJnmGvX864pn1B2YUYNzjmXkuJOIqG2HdU62MVS4EHpU2946OZoTMnRUHklGtJdJZ33QfzdjGACXhn1A==} - engines: {node: '>=12'} + resolution: { integrity: sha512-URgtR1dJnmGvX864pn1B2YUYNzjmXkuJOIqG2HdU62MVS4EHpU2946OZoTMnRUHklGtJdJZ33QfzdjGACXhn1A== } + engines: { node: '>=12' } cpu: [arm64] os: [win32] '@esbuild/win32-ia32@0.18.20': - resolution: {integrity: sha512-Wv7QBi3ID/rROT08SABTS7eV4hX26sVduqDOTe1MvGMjNd3EjOz4b7zeexIR62GTIEKrfJXKL9LFxTYgkyeu7g==} - engines: {node: '>=12'} + resolution: { integrity: sha512-Wv7QBi3ID/rROT08SABTS7eV4hX26sVduqDOTe1MvGMjNd3EjOz4b7zeexIR62GTIEKrfJXKL9LFxTYgkyeu7g== } + engines: { node: '>=12' } cpu: [ia32] os: [win32] '@esbuild/win32-ia32@0.19.12': - resolution: {integrity: sha512-+ZOE6pUkMOJfmxmBZElNOx72NKpIa/HFOMGzu8fqzQJ5kgf6aTGrcJaFsNiVMH4JKpMipyK+7k0n2UXN7a8YKQ==} - engines: {node: '>=12'} + resolution: { integrity: sha512-+ZOE6pUkMOJfmxmBZElNOx72NKpIa/HFOMGzu8fqzQJ5kgf6aTGrcJaFsNiVMH4JKpMipyK+7k0n2UXN7a8YKQ== } + engines: { node: '>=12' } cpu: [ia32] os: [win32] '@esbuild/win32-x64@0.18.20': - resolution: {integrity: sha512-kTdfRcSiDfQca/y9QIkng02avJ+NCaQvrMejlsB3RRv5sE9rRoeBPISaZpKxHELzRxZyLvNts1P27W3wV+8geQ==} - engines: {node: '>=12'} + resolution: { integrity: sha512-kTdfRcSiDfQca/y9QIkng02avJ+NCaQvrMejlsB3RRv5sE9rRoeBPISaZpKxHELzRxZyLvNts1P27W3wV+8geQ== } + engines: { node: '>=12' } cpu: [x64] os: [win32] '@esbuild/win32-x64@0.19.12': - resolution: {integrity: sha512-T1QyPSDCyMXaO3pzBkF96E8xMkiRYbUEZADd29SyPGabqxMViNoii+NcK7eWJAEoU6RZyEm5lVSIjTmcdoB9HA==} - engines: {node: '>=12'} + resolution: { integrity: sha512-T1QyPSDCyMXaO3pzBkF96E8xMkiRYbUEZADd29SyPGabqxMViNoii+NcK7eWJAEoU6RZyEm5lVSIjTmcdoB9HA== } + engines: { node: '>=12' } cpu: [x64] os: [win32] '@fastify/busboy@2.1.1': - resolution: {integrity: sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA==} - engines: {node: '>=14'} + resolution: { integrity: sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA== } + engines: { node: '>=14' } '@hapi/bourne@3.0.0': - resolution: {integrity: sha512-Waj1cwPXJDucOib4a3bAISsKJVb15MKi9IvmTI/7ssVEm6sywXGjVJDhl6/umt1pK1ZS7PacXU3A1PmFKHEZ2w==} + resolution: { integrity: sha512-Waj1cwPXJDucOib4a3bAISsKJVb15MKi9IvmTI/7ssVEm6sywXGjVJDhl6/umt1pK1ZS7PacXU3A1PmFKHEZ2w== } '@isaacs/cliui@8.0.2': - resolution: {integrity: sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==} - engines: {node: '>=12'} + resolution: { integrity: sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA== } + engines: { node: '>=12' } '@istanbuljs/load-nyc-config@1.1.0': - resolution: {integrity: sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==} - engines: {node: '>=8'} + resolution: { integrity: sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ== } + engines: { node: '>=8' } '@istanbuljs/schema@0.1.3': - resolution: {integrity: sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==} - engines: {node: '>=8'} + resolution: { integrity: sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA== } + engines: { node: '>=8' } '@jest/console@29.7.0': - resolution: {integrity: sha512-5Ni4CU7XHQi32IJ398EEP4RrB8eV09sXP2ROqD4bksHrnTree52PsxvX8tpL8LvTZ3pFzXyPbNQReSN41CAhOg==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-5Ni4CU7XHQi32IJ398EEP4RrB8eV09sXP2ROqD4bksHrnTree52PsxvX8tpL8LvTZ3pFzXyPbNQReSN41CAhOg== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } '@jest/core@29.7.0': - resolution: {integrity: sha512-n7aeXWKMnGtDA48y8TLWJPJmLmmZ642Ceo78cYWEpiD7FzDgmNDV/GCVRorPABdXLJZ/9wzzgZAlHjXjxDHGsg==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-n7aeXWKMnGtDA48y8TLWJPJmLmmZ642Ceo78cYWEpiD7FzDgmNDV/GCVRorPABdXLJZ/9wzzgZAlHjXjxDHGsg== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } peerDependencies: node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0 peerDependenciesMeta: @@ -667,28 +665,28 @@ packages: optional: true '@jest/environment@29.7.0': - resolution: {integrity: sha512-aQIfHDq33ExsN4jP1NWGXhxgQ/wixs60gDiKO+XVMd8Mn0NWPWgc34ZQDTb2jKaUWQ7MuwoitXAsN2XVXNMpAw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-aQIfHDq33ExsN4jP1NWGXhxgQ/wixs60gDiKO+XVMd8Mn0NWPWgc34ZQDTb2jKaUWQ7MuwoitXAsN2XVXNMpAw== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } '@jest/expect-utils@29.7.0': - resolution: {integrity: sha512-GlsNBWiFQFCVi9QVSx7f5AgMeLxe9YCCs5PuP2O2LdjDAA8Jh9eX7lA1Jq/xdXw3Wb3hyvlFNfZIfcRetSzYcA==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-GlsNBWiFQFCVi9QVSx7f5AgMeLxe9YCCs5PuP2O2LdjDAA8Jh9eX7lA1Jq/xdXw3Wb3hyvlFNfZIfcRetSzYcA== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } '@jest/expect@29.7.0': - resolution: {integrity: sha512-8uMeAMycttpva3P1lBHB8VciS9V0XAr3GymPpipdyQXbBcuhkLQOSe8E/p92RyAdToS6ZD1tFkX+CkhoECE0dQ==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-8uMeAMycttpva3P1lBHB8VciS9V0XAr3GymPpipdyQXbBcuhkLQOSe8E/p92RyAdToS6ZD1tFkX+CkhoECE0dQ== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } '@jest/fake-timers@29.7.0': - resolution: {integrity: sha512-q4DH1Ha4TTFPdxLsqDXK1d3+ioSL7yL5oCMJZgDYm6i+6CygW5E5xVr/D1HdsGxjt1ZWSfUAs9OxSB/BNelWrQ==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-q4DH1Ha4TTFPdxLsqDXK1d3+ioSL7yL5oCMJZgDYm6i+6CygW5E5xVr/D1HdsGxjt1ZWSfUAs9OxSB/BNelWrQ== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } '@jest/globals@29.7.0': - resolution: {integrity: sha512-mpiz3dutLbkW2MNFubUGUEVLkTGiqW6yLVTA+JbP6fI6J5iL9Y0Nlg8k95pcF8ctKwCS7WVxteBs29hhfAotzQ==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-mpiz3dutLbkW2MNFubUGUEVLkTGiqW6yLVTA+JbP6fI6J5iL9Y0Nlg8k95pcF8ctKwCS7WVxteBs29hhfAotzQ== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } '@jest/reporters@29.7.0': - resolution: {integrity: sha512-DApq0KJbJOEzAFYjHADNNxAE3KbhxQB1y5Kplb5Waqw6zVbuWatSnMjE5gs8FUgEPmNsnZA3NCWl9NG0ia04Pg==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-DApq0KJbJOEzAFYjHADNNxAE3KbhxQB1y5Kplb5Waqw6zVbuWatSnMjE5gs8FUgEPmNsnZA3NCWl9NG0ia04Pg== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } peerDependencies: node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0 peerDependenciesMeta: @@ -696,335 +694,335 @@ packages: optional: true '@jest/schemas@29.6.3': - resolution: {integrity: sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } '@jest/source-map@29.6.3': - resolution: {integrity: sha512-MHjT95QuipcPrpLM+8JMSzFx6eHp5Bm+4XeFDJlwsvVBjmKNiIAvasGK2fxz2WbGRlnvqehFbh07MMa7n3YJnw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-MHjT95QuipcPrpLM+8JMSzFx6eHp5Bm+4XeFDJlwsvVBjmKNiIAvasGK2fxz2WbGRlnvqehFbh07MMa7n3YJnw== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } '@jest/test-result@29.7.0': - resolution: {integrity: sha512-Fdx+tv6x1zlkJPcWXmMDAG2HBnaR9XPSd5aDWQVsfrZmLVT3lU1cwyxLgRmXR9yrq4NBoEm9BMsfgFzTQAbJYA==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-Fdx+tv6x1zlkJPcWXmMDAG2HBnaR9XPSd5aDWQVsfrZmLVT3lU1cwyxLgRmXR9yrq4NBoEm9BMsfgFzTQAbJYA== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } '@jest/test-sequencer@29.7.0': - resolution: {integrity: sha512-GQwJ5WZVrKnOJuiYiAF52UNUJXgTZx1NHjFSEB0qEMmSZKAkdMoIzw/Cj6x6NF4AvV23AUqDpFzQkN/eYCYTxw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-GQwJ5WZVrKnOJuiYiAF52UNUJXgTZx1NHjFSEB0qEMmSZKAkdMoIzw/Cj6x6NF4AvV23AUqDpFzQkN/eYCYTxw== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } '@jest/transform@29.7.0': - resolution: {integrity: sha512-ok/BTPFzFKVMwO5eOHRrvnBVHdRy9IrsrW1GpMaQ9MCnilNLXQKmAX8s1YXDFaai9xJpac2ySzV0YeRRECr2Vw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-ok/BTPFzFKVMwO5eOHRrvnBVHdRy9IrsrW1GpMaQ9MCnilNLXQKmAX8s1YXDFaai9xJpac2ySzV0YeRRECr2Vw== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } '@jest/types@29.6.3': - resolution: {integrity: sha512-u3UPsIilWKOM3F9CXtrG8LEJmNxwoCQC/XVj4IKYXvvpx7QIi/Kg1LI5uDmDpKlac62NUtX7eLjRh+jVZcLOzw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-u3UPsIilWKOM3F9CXtrG8LEJmNxwoCQC/XVj4IKYXvvpx7QIi/Kg1LI5uDmDpKlac62NUtX7eLjRh+jVZcLOzw== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } '@jridgewell/gen-mapping@0.3.8': - resolution: {integrity: sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA==} - engines: {node: '>=6.0.0'} + resolution: { integrity: sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA== } + engines: { node: '>=6.0.0' } '@jridgewell/resolve-uri@3.1.2': - resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==} - engines: {node: '>=6.0.0'} + resolution: { integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw== } + engines: { node: '>=6.0.0' } '@jridgewell/set-array@1.2.1': - resolution: {integrity: sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==} - engines: {node: '>=6.0.0'} + resolution: { integrity: sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A== } + engines: { node: '>=6.0.0' } '@jridgewell/sourcemap-codec@1.5.0': - resolution: {integrity: sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==} + resolution: { integrity: sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ== } '@jridgewell/trace-mapping@0.3.25': - resolution: {integrity: sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==} + resolution: { integrity: sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ== } '@jridgewell/trace-mapping@0.3.9': - resolution: {integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==} + resolution: { integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ== } '@koa/multer@3.0.2': - resolution: {integrity: sha512-Q6WfPpE06mJWyZD1fzxM6zWywaoo+zocAn2YA9QYz4RsecoASr1h/kSzG0c5seDpFVKCMZM9raEfuM7XfqbRLw==} - engines: {node: '>= 8'} + resolution: { integrity: sha512-Q6WfPpE06mJWyZD1fzxM6zWywaoo+zocAn2YA9QYz4RsecoASr1h/kSzG0c5seDpFVKCMZM9raEfuM7XfqbRLw== } + engines: { node: '>= 8' } peerDependencies: multer: '*' '@koa/router@12.0.2': - resolution: {integrity: sha512-sYcHglGKTxGF+hQ6x67xDfkE9o+NhVlRHBqq6gLywaMc6CojK/5vFZByphdonKinYlMLkEkacm+HEse9HzwgTA==} - engines: {node: '>= 12'} + resolution: { integrity: sha512-sYcHglGKTxGF+hQ6x67xDfkE9o+NhVlRHBqq6gLywaMc6CojK/5vFZByphdonKinYlMLkEkacm+HEse9HzwgTA== } + engines: { node: '>= 12' } '@pkgjs/parseargs@0.11.0': - resolution: {integrity: sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==} - engines: {node: '>=14'} + resolution: { integrity: sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg== } + engines: { node: '>=14' } '@sinclair/typebox@0.27.8': - resolution: {integrity: sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==} + resolution: { integrity: sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA== } '@sinonjs/commons@3.0.1': - resolution: {integrity: sha512-K3mCHKQ9sVh8o1C9cxkwxaOmXoAMlDxC1mYyHrjqOWEcBjYr76t96zL2zlj5dUGZ3HSw240X1qgH3Mjf1yJWpQ==} + resolution: { integrity: sha512-K3mCHKQ9sVh8o1C9cxkwxaOmXoAMlDxC1mYyHrjqOWEcBjYr76t96zL2zlj5dUGZ3HSw240X1qgH3Mjf1yJWpQ== } '@sinonjs/fake-timers@10.3.0': - resolution: {integrity: sha512-V4BG07kuYSUkTCSBHG8G8TNhM+F19jXFWnQtzj+we8DrkpSBCee9Z3Ms8yiGer/dlmhe35/Xdgyo3/0rQKg7YA==} + resolution: { integrity: sha512-V4BG07kuYSUkTCSBHG8G8TNhM+F19jXFWnQtzj+we8DrkpSBCee9Z3Ms8yiGer/dlmhe35/Xdgyo3/0rQKg7YA== } '@testcontainers/rabbitmq@10.18.0': - resolution: {integrity: sha512-4qj8Pj0I0s8B7eSa2NqqQI8p8hK+lSdztbzceejZa1QToGtSuYwgfYCRvkWPlASYW8PDpaNotlvk85+bobevkg==} + resolution: { integrity: sha512-4qj8Pj0I0s8B7eSa2NqqQI8p8hK+lSdztbzceejZa1QToGtSuYwgfYCRvkWPlASYW8PDpaNotlvk85+bobevkg== } '@tsconfig/node10@1.0.11': - resolution: {integrity: sha512-DcRjDCujK/kCk/cUe8Xz8ZSpm8mS3mNNpta+jGCA6USEDfktlNvm1+IuZ9eTcDbNk41BHwpHHeW+N1lKCz4zOw==} + resolution: { integrity: sha512-DcRjDCujK/kCk/cUe8Xz8ZSpm8mS3mNNpta+jGCA6USEDfktlNvm1+IuZ9eTcDbNk41BHwpHHeW+N1lKCz4zOw== } '@tsconfig/node12@1.0.11': - resolution: {integrity: sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==} + resolution: { integrity: sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag== } '@tsconfig/node14@1.0.3': - resolution: {integrity: sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==} + resolution: { integrity: sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow== } '@tsconfig/node16@1.0.4': - resolution: {integrity: sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==} + resolution: { integrity: sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA== } '@types/babel__core@7.20.5': - resolution: {integrity: sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==} + resolution: { integrity: sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA== } '@types/babel__generator@7.6.8': - resolution: {integrity: sha512-ASsj+tpEDsEiFr1arWrlN6V3mdfjRMZt6LtK/Vp/kreFLnr5QH5+DhvD5nINYZXzwJvXeGq+05iUXcAzVrqWtw==} + resolution: { integrity: sha512-ASsj+tpEDsEiFr1arWrlN6V3mdfjRMZt6LtK/Vp/kreFLnr5QH5+DhvD5nINYZXzwJvXeGq+05iUXcAzVrqWtw== } '@types/babel__template@7.4.4': - resolution: {integrity: sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==} + resolution: { integrity: sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A== } '@types/babel__traverse@7.20.6': - resolution: {integrity: sha512-r1bzfrm0tomOI8g1SzvCaQHo6Lcv6zu0EA+W2kHrt8dyrHQxGzBBL4kdkzIS+jBMV+EYcMAEAqXqYaLJq5rOZg==} + resolution: { integrity: sha512-r1bzfrm0tomOI8g1SzvCaQHo6Lcv6zu0EA+W2kHrt8dyrHQxGzBBL4kdkzIS+jBMV+EYcMAEAqXqYaLJq5rOZg== } '@types/body-parser@1.19.5': - resolution: {integrity: sha512-fB3Zu92ucau0iQ0JMCFQE7b/dv8Ot07NI3KaZIkIUNXq82k4eBAqUaneXfleGY9JWskeS9y+u0nXMyspcuQrCg==} + resolution: { integrity: sha512-fB3Zu92ucau0iQ0JMCFQE7b/dv8Ot07NI3KaZIkIUNXq82k4eBAqUaneXfleGY9JWskeS9y+u0nXMyspcuQrCg== } '@types/connect@3.4.38': - resolution: {integrity: sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==} + resolution: { integrity: sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug== } '@types/cookiejar@2.1.5': - resolution: {integrity: sha512-he+DHOWReW0nghN24E1WUqM0efK4kI9oTqDm6XmK8ZPe2djZ90BSNdGnIyCLzCPw7/pogPlGbzI2wHGGmi4O/Q==} + resolution: { integrity: sha512-he+DHOWReW0nghN24E1WUqM0efK4kI9oTqDm6XmK8ZPe2djZ90BSNdGnIyCLzCPw7/pogPlGbzI2wHGGmi4O/Q== } '@types/cors@2.8.17': - resolution: {integrity: sha512-8CGDvrBj1zgo2qE+oS3pOCyYNqCPryMWY2bGfwA0dcfopWGgxs+78df0Rs3rc9THP4JkOhLsAa+15VdpAqkcUA==} + resolution: { integrity: sha512-8CGDvrBj1zgo2qE+oS3pOCyYNqCPryMWY2bGfwA0dcfopWGgxs+78df0Rs3rc9THP4JkOhLsAa+15VdpAqkcUA== } '@types/docker-modem@3.0.6': - resolution: {integrity: sha512-yKpAGEuKRSS8wwx0joknWxsmLha78wNMe9R2S3UNsVOkZded8UqOrV8KoeDXoXsjndxwyF3eIhyClGbO1SEhEg==} + resolution: { integrity: sha512-yKpAGEuKRSS8wwx0joknWxsmLha78wNMe9R2S3UNsVOkZded8UqOrV8KoeDXoXsjndxwyF3eIhyClGbO1SEhEg== } '@types/dockerode@3.3.35': - resolution: {integrity: sha512-P+DCMASlsH+QaKkDpekKrP5pLls767PPs+/LrlVbKnEnY5tMpEUa2C6U4gRsdFZengOqxdCIqy16R22Q3pLB6Q==} + resolution: { integrity: sha512-P+DCMASlsH+QaKkDpekKrP5pLls767PPs+/LrlVbKnEnY5tMpEUa2C6U4gRsdFZengOqxdCIqy16R22Q3pLB6Q== } '@types/dotenv-flow@3.3.3': - resolution: {integrity: sha512-aJjBsKw4bfGjvaRwrxBtEOfYZxCAq+LiFTpZ4DGTEK2b9eLVt/IAClapSxMfgV4Mi/2bIBKKjoTCO0lOh4ACLg==} + resolution: { integrity: sha512-aJjBsKw4bfGjvaRwrxBtEOfYZxCAq+LiFTpZ4DGTEK2b9eLVt/IAClapSxMfgV4Mi/2bIBKKjoTCO0lOh4ACLg== } '@types/express-serve-static-core@5.0.6': - resolution: {integrity: sha512-3xhRnjJPkULekpSzgtoNYYcTWgEZkp4myc+Saevii5JPnHNvHMRlBSHDbs7Bh1iPPoVTERHEZXyhyLbMEsExsA==} + resolution: { integrity: sha512-3xhRnjJPkULekpSzgtoNYYcTWgEZkp4myc+Saevii5JPnHNvHMRlBSHDbs7Bh1iPPoVTERHEZXyhyLbMEsExsA== } '@types/express@5.0.0': - resolution: {integrity: sha512-DvZriSMehGHL1ZNLzi6MidnsDhUZM/x2pRdDIKdwbUNqqwHxMlRdkxtn6/EPKyqKpHqTl/4nRZsRNLpZxZRpPQ==} + resolution: { integrity: sha512-DvZriSMehGHL1ZNLzi6MidnsDhUZM/x2pRdDIKdwbUNqqwHxMlRdkxtn6/EPKyqKpHqTl/4nRZsRNLpZxZRpPQ== } '@types/graceful-fs@4.1.9': - resolution: {integrity: sha512-olP3sd1qOEe5dXTSaFvQG+02VdRXcdytWLAZsAq1PecU8uqQAhkrnbli7DagjtXKW/Bl7YJbUsa8MPcuc8LHEQ==} + resolution: { integrity: sha512-olP3sd1qOEe5dXTSaFvQG+02VdRXcdytWLAZsAq1PecU8uqQAhkrnbli7DagjtXKW/Bl7YJbUsa8MPcuc8LHEQ== } '@types/http-errors@2.0.4': - resolution: {integrity: sha512-D0CFMMtydbJAegzOyHjtiKPLlvnm3iTZyZRSZoLq2mRhDdmLfIWOCYPfQJ4cu2erKghU++QvjcUjp/5h7hESpA==} + resolution: { integrity: sha512-D0CFMMtydbJAegzOyHjtiKPLlvnm3iTZyZRSZoLq2mRhDdmLfIWOCYPfQJ4cu2erKghU++QvjcUjp/5h7hESpA== } '@types/istanbul-lib-coverage@2.0.6': - resolution: {integrity: sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==} + resolution: { integrity: sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w== } '@types/istanbul-lib-report@3.0.3': - resolution: {integrity: sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA==} + resolution: { integrity: sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA== } '@types/istanbul-reports@3.0.4': - resolution: {integrity: sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ==} + resolution: { integrity: sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ== } '@types/jest@29.5.14': - resolution: {integrity: sha512-ZN+4sdnLUbo8EVvVc2ao0GFW6oVrQRPn4K2lglySj7APvSrgzxHiNNK99us4WDMi57xxA2yggblIAMNhXOotLQ==} + resolution: { integrity: sha512-ZN+4sdnLUbo8EVvVc2ao0GFW6oVrQRPn4K2lglySj7APvSrgzxHiNNK99us4WDMi57xxA2yggblIAMNhXOotLQ== } '@types/methods@1.1.4': - resolution: {integrity: sha512-ymXWVrDiCxTBE3+RIrrP533E70eA+9qu7zdWoHuOmGujkYtzf4HQF96b8nwHLqhuf4ykX61IGRIB38CC6/sImQ==} + resolution: { integrity: sha512-ymXWVrDiCxTBE3+RIrrP533E70eA+9qu7zdWoHuOmGujkYtzf4HQF96b8nwHLqhuf4ykX61IGRIB38CC6/sImQ== } '@types/mime@1.3.5': - resolution: {integrity: sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w==} + resolution: { integrity: sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w== } '@types/node@18.19.76': - resolution: {integrity: sha512-yvR7Q9LdPz2vGpmpJX5LolrgRdWvB67MJKDPSgIIzpFbaf9a1j/f5DnLp5VDyHGMR0QZHlTr1afsD87QCXFHKw==} + resolution: { integrity: sha512-yvR7Q9LdPz2vGpmpJX5LolrgRdWvB67MJKDPSgIIzpFbaf9a1j/f5DnLp5VDyHGMR0QZHlTr1afsD87QCXFHKw== } '@types/node@20.17.23': - resolution: {integrity: sha512-8PCGZ1ZJbEZuYNTMqywO+Sj4vSKjSjT6Ua+6RFOYlEvIvKQABPtrNkoVSLSKDb4obYcMhspVKmsw8Cm10NFRUg==} + resolution: { integrity: sha512-8PCGZ1ZJbEZuYNTMqywO+Sj4vSKjSjT6Ua+6RFOYlEvIvKQABPtrNkoVSLSKDb4obYcMhspVKmsw8Cm10NFRUg== } '@types/node@22.13.1': - resolution: {integrity: sha512-jK8uzQlrvXqEU91UxiK5J7pKHyzgnI1Qnl0QDHIgVGuolJhRb9EEl28Cj9b3rGR8B2lhFCtvIm5os8lFnO/1Ew==} + resolution: { integrity: sha512-jK8uzQlrvXqEU91UxiK5J7pKHyzgnI1Qnl0QDHIgVGuolJhRb9EEl28Cj9b3rGR8B2lhFCtvIm5os8lFnO/1Ew== } '@types/pg@8.11.11': - resolution: {integrity: sha512-kGT1qKM8wJQ5qlawUrEkXgvMSXoV213KfMGXcwfDwUIfUHXqXYXOfS1nE1LINRJVVVx5wCm70XnFlMHaIcQAfw==} + resolution: { integrity: sha512-kGT1qKM8wJQ5qlawUrEkXgvMSXoV213KfMGXcwfDwUIfUHXqXYXOfS1nE1LINRJVVVx5wCm70XnFlMHaIcQAfw== } '@types/qs@6.9.18': - resolution: {integrity: sha512-kK7dgTYDyGqS+e2Q4aK9X3D7q234CIZ1Bv0q/7Z5IwRDoADNU81xXJK/YVyLbLTZCoIwUoDoffFeF+p/eIklAA==} + resolution: { integrity: sha512-kK7dgTYDyGqS+e2Q4aK9X3D7q234CIZ1Bv0q/7Z5IwRDoADNU81xXJK/YVyLbLTZCoIwUoDoffFeF+p/eIklAA== } '@types/range-parser@1.2.7': - resolution: {integrity: sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==} + resolution: { integrity: sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ== } '@types/send@0.17.4': - resolution: {integrity: sha512-x2EM6TJOybec7c52BX0ZspPodMsQUd5L6PRwOunVyVUhXiBSKf3AezDL8Dgvgt5o0UfKNfuA0eMLr2wLT4AiBA==} + resolution: { integrity: sha512-x2EM6TJOybec7c52BX0ZspPodMsQUd5L6PRwOunVyVUhXiBSKf3AezDL8Dgvgt5o0UfKNfuA0eMLr2wLT4AiBA== } '@types/serve-static@1.15.7': - resolution: {integrity: sha512-W8Ym+h8nhuRwaKPaDw34QUkwsGi6Rc4yYqvKFo5rm2FUEhCFbzVWrxXUxuKK8TASjWsysJY0nsmNCGhCOIsrOw==} + resolution: { integrity: sha512-W8Ym+h8nhuRwaKPaDw34QUkwsGi6Rc4yYqvKFo5rm2FUEhCFbzVWrxXUxuKK8TASjWsysJY0nsmNCGhCOIsrOw== } '@types/ssh2-streams@0.1.12': - resolution: {integrity: sha512-Sy8tpEmCce4Tq0oSOYdfqaBpA3hDM8SoxoFh5vzFsu2oL+znzGz8oVWW7xb4K920yYMUY+PIG31qZnFMfPWNCg==} + resolution: { integrity: sha512-Sy8tpEmCce4Tq0oSOYdfqaBpA3hDM8SoxoFh5vzFsu2oL+znzGz8oVWW7xb4K920yYMUY+PIG31qZnFMfPWNCg== } '@types/ssh2@0.5.52': - resolution: {integrity: sha512-lbLLlXxdCZOSJMCInKH2+9V/77ET2J6NPQHpFI0kda61Dd1KglJs+fPQBchizmzYSOJBgdTajhPqBO1xxLywvg==} + resolution: { integrity: sha512-lbLLlXxdCZOSJMCInKH2+9V/77ET2J6NPQHpFI0kda61Dd1KglJs+fPQBchizmzYSOJBgdTajhPqBO1xxLywvg== } '@types/ssh2@1.15.4': - resolution: {integrity: sha512-9JTQgVBWSgq6mAen6PVnrAmty1lqgCMvpfN+1Ck5WRUsyMYPa6qd50/vMJ0y1zkGpOEgLzm8m8Dx/Y5vRouLaA==} + resolution: { integrity: sha512-9JTQgVBWSgq6mAen6PVnrAmty1lqgCMvpfN+1Ck5WRUsyMYPa6qd50/vMJ0y1zkGpOEgLzm8m8Dx/Y5vRouLaA== } '@types/stack-utils@2.0.3': - resolution: {integrity: sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw==} + resolution: { integrity: sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw== } '@types/strip-bom@3.0.0': - resolution: {integrity: sha512-xevGOReSYGM7g/kUBZzPqCrR/KYAo+F0yiPc85WFTJa0MSLtyFTVTU6cJu/aV4mid7IffDIWqo69THF2o4JiEQ==} + resolution: { integrity: sha512-xevGOReSYGM7g/kUBZzPqCrR/KYAo+F0yiPc85WFTJa0MSLtyFTVTU6cJu/aV4mid7IffDIWqo69THF2o4JiEQ== } '@types/strip-json-comments@0.0.30': - resolution: {integrity: sha512-7NQmHra/JILCd1QqpSzl8+mJRc8ZHz3uDm8YV1Ks9IhK0epEiTw8aIErbvH9PI+6XbqhyIQy3462nEsn7UVzjQ==} + resolution: { integrity: sha512-7NQmHra/JILCd1QqpSzl8+mJRc8ZHz3uDm8YV1Ks9IhK0epEiTw8aIErbvH9PI+6XbqhyIQy3462nEsn7UVzjQ== } '@types/superagent@8.1.9': - resolution: {integrity: sha512-pTVjI73witn+9ILmoJdajHGW2jkSaOzhiFYF1Rd3EQ94kymLqB9PjD9ISg7WaALC7+dCHT0FGe9T2LktLq/3GQ==} + resolution: { integrity: sha512-pTVjI73witn+9ILmoJdajHGW2jkSaOzhiFYF1Rd3EQ94kymLqB9PjD9ISg7WaALC7+dCHT0FGe9T2LktLq/3GQ== } '@types/supertest@6.0.2': - resolution: {integrity: sha512-137ypx2lk/wTQbW6An6safu9hXmajAifU/s7szAHLN/FeIm5w7yR0Wkl9fdJMRSHwOn4HLAI0DaB2TOORuhPDg==} + resolution: { integrity: sha512-137ypx2lk/wTQbW6An6safu9hXmajAifU/s7szAHLN/FeIm5w7yR0Wkl9fdJMRSHwOn4HLAI0DaB2TOORuhPDg== } '@types/validator@13.12.2': - resolution: {integrity: sha512-6SlHBzUW8Jhf3liqrGGXyTJSIFe4nqlJ5A5KaMZ2l/vbM3Wh3KSybots/wfWVzNLK4D1NZluDlSQIbIEPx6oyA==} + resolution: { integrity: sha512-6SlHBzUW8Jhf3liqrGGXyTJSIFe4nqlJ5A5KaMZ2l/vbM3Wh3KSybots/wfWVzNLK4D1NZluDlSQIbIEPx6oyA== } '@types/yargs-parser@21.0.3': - resolution: {integrity: sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==} + resolution: { integrity: sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ== } '@types/yargs@17.0.33': - resolution: {integrity: sha512-WpxBCKWPLr4xSsHgz511rFJAM+wS28w2zEO1QDNY5zM/S8ok70NNfztH0xwhqKyaK0OHCbN98LDAZuy1ctxDkA==} + resolution: { integrity: sha512-WpxBCKWPLr4xSsHgz511rFJAM+wS28w2zEO1QDNY5zM/S8ok70NNfztH0xwhqKyaK0OHCbN98LDAZuy1ctxDkA== } abort-controller@3.0.0: - resolution: {integrity: sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==} - engines: {node: '>=6.5'} + resolution: { integrity: sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg== } + engines: { node: '>=6.5' } accepts@1.3.8: - resolution: {integrity: sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==} - engines: {node: '>= 0.6'} + resolution: { integrity: sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw== } + engines: { node: '>= 0.6' } acorn-walk@8.3.4: - resolution: {integrity: sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==} - engines: {node: '>=0.4.0'} + resolution: { integrity: sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g== } + engines: { node: '>=0.4.0' } acorn@8.14.0: - resolution: {integrity: sha512-cl669nCJTZBsL97OF4kUQm5g5hC2uihk0NxY3WENAC0TYdILVkAyHymAntgxGkl7K+t0cXIrH5siy5S4XkFycA==} - engines: {node: '>=0.4.0'} + resolution: { integrity: sha512-cl669nCJTZBsL97OF4kUQm5g5hC2uihk0NxY3WENAC0TYdILVkAyHymAntgxGkl7K+t0cXIrH5siy5S4XkFycA== } + engines: { node: '>=0.4.0' } hasBin: true ansi-escapes@4.3.2: - resolution: {integrity: sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==} - engines: {node: '>=8'} + resolution: { integrity: sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ== } + engines: { node: '>=8' } ansi-regex@5.0.1: - resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==} - engines: {node: '>=8'} + resolution: { integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ== } + engines: { node: '>=8' } ansi-regex@6.1.0: - resolution: {integrity: sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==} - engines: {node: '>=12'} + resolution: { integrity: sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA== } + engines: { node: '>=12' } ansi-styles@4.3.0: - resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==} - engines: {node: '>=8'} + resolution: { integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg== } + engines: { node: '>=8' } ansi-styles@5.2.0: - resolution: {integrity: sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==} - engines: {node: '>=10'} + resolution: { integrity: sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA== } + engines: { node: '>=10' } ansi-styles@6.2.1: - resolution: {integrity: sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==} - engines: {node: '>=12'} + resolution: { integrity: sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug== } + engines: { node: '>=12' } anymatch@3.1.3: - resolution: {integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==} - engines: {node: '>= 8'} + resolution: { integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw== } + engines: { node: '>= 8' } append-field@1.0.0: - resolution: {integrity: sha512-klpgFSWLW1ZEs8svjfb7g4qWY0YS5imI82dTg+QahUvJ8YqAY0P10Uk8tTyh9ZGuYEZEMaeJYCF5BFuX552hsw==} + resolution: { integrity: sha512-klpgFSWLW1ZEs8svjfb7g4qWY0YS5imI82dTg+QahUvJ8YqAY0P10Uk8tTyh9ZGuYEZEMaeJYCF5BFuX552hsw== } archiver-utils@5.0.2: - resolution: {integrity: sha512-wuLJMmIBQYCsGZgYLTy5FIB2pF6Lfb6cXMSF8Qywwk3t20zWnAi7zLcQFdKQmIB8wyZpY5ER38x08GbwtR2cLA==} - engines: {node: '>= 14'} + resolution: { integrity: sha512-wuLJMmIBQYCsGZgYLTy5FIB2pF6Lfb6cXMSF8Qywwk3t20zWnAi7zLcQFdKQmIB8wyZpY5ER38x08GbwtR2cLA== } + engines: { node: '>= 14' } archiver@7.0.1: - resolution: {integrity: sha512-ZcbTaIqJOfCc03QwD468Unz/5Ir8ATtvAHsK+FdXbDIbGfihqh9mrvdcYunQzqn4HrvWWaFyaxJhGZagaJJpPQ==} - engines: {node: '>= 14'} + resolution: { integrity: sha512-ZcbTaIqJOfCc03QwD468Unz/5Ir8ATtvAHsK+FdXbDIbGfihqh9mrvdcYunQzqn4HrvWWaFyaxJhGZagaJJpPQ== } + engines: { node: '>= 14' } arg@4.1.3: - resolution: {integrity: sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==} + resolution: { integrity: sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA== } argparse@1.0.10: - resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==} + resolution: { integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg== } array-flatten@1.1.1: - resolution: {integrity: sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==} + resolution: { integrity: sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg== } asap@2.0.6: - resolution: {integrity: sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA==} + resolution: { integrity: sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA== } asn1@0.2.6: - resolution: {integrity: sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ==} + resolution: { integrity: sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ== } async-lock@1.4.1: - resolution: {integrity: sha512-Az2ZTpuytrtqENulXwO3GGv1Bztugx6TT37NIo7imr/Qo0gsYiGtSdBa2B6fsXhTpVZDNfu1Qn3pk531e3q+nQ==} + resolution: { integrity: sha512-Az2ZTpuytrtqENulXwO3GGv1Bztugx6TT37NIo7imr/Qo0gsYiGtSdBa2B6fsXhTpVZDNfu1Qn3pk531e3q+nQ== } async@3.2.6: - resolution: {integrity: sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==} + resolution: { integrity: sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA== } asynckit@0.4.0: - resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==} + resolution: { integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q== } b4a@1.6.7: - resolution: {integrity: sha512-OnAYlL5b7LEkALw87fUVafQw5rVR9RjwGd4KUwNQ6DrrNmaVaUCgLipfVlzrPQ4tWOR9P0IXGNOx50jYCCdSJg==} + resolution: { integrity: sha512-OnAYlL5b7LEkALw87fUVafQw5rVR9RjwGd4KUwNQ6DrrNmaVaUCgLipfVlzrPQ4tWOR9P0IXGNOx50jYCCdSJg== } babel-jest@29.7.0: - resolution: {integrity: sha512-BrvGY3xZSwEcCzKvKsCi2GgHqDqsYkOP4/by5xCgIwGXQxIEh+8ew3gmrE1y7XRR6LHZIj6yLYnUi/mm2KXKBg==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-BrvGY3xZSwEcCzKvKsCi2GgHqDqsYkOP4/by5xCgIwGXQxIEh+8ew3gmrE1y7XRR6LHZIj6yLYnUi/mm2KXKBg== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } peerDependencies: '@babel/core': ^7.8.0 babel-plugin-istanbul@6.1.1: - resolution: {integrity: sha512-Y1IQok9821cC9onCx5otgFfRm7Lm+I+wwxOx738M/WLPZ9Q42m4IG5W0FNX8WLL2gYMZo3JkuXIH2DOpWM+qwA==} - engines: {node: '>=8'} + resolution: { integrity: sha512-Y1IQok9821cC9onCx5otgFfRm7Lm+I+wwxOx738M/WLPZ9Q42m4IG5W0FNX8WLL2gYMZo3JkuXIH2DOpWM+qwA== } + engines: { node: '>=8' } babel-plugin-jest-hoist@29.6.3: - resolution: {integrity: sha512-ESAc/RJvGTFEzRwOTT4+lNDk/GNHMkKbNzsvT0qKRfDyyYTskxB5rnU2njIDYVxXCBHHEI1c0YwHob3WaYujOg==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-ESAc/RJvGTFEzRwOTT4+lNDk/GNHMkKbNzsvT0qKRfDyyYTskxB5rnU2njIDYVxXCBHHEI1c0YwHob3WaYujOg== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } babel-preset-current-node-syntax@1.1.0: - resolution: {integrity: sha512-ldYss8SbBlWva1bs28q78Ju5Zq1F+8BrqBZZ0VFhLBvhh6lCpC2o3gDJi/5DRLs9FgYZCnmPYIVFU4lRXCkyUw==} + resolution: { integrity: sha512-ldYss8SbBlWva1bs28q78Ju5Zq1F+8BrqBZZ0VFhLBvhh6lCpC2o3gDJi/5DRLs9FgYZCnmPYIVFU4lRXCkyUw== } peerDependencies: '@babel/core': ^7.0.0 babel-preset-jest@29.6.3: - resolution: {integrity: sha512-0B3bhxR6snWXJZtR/RliHTDPRgn1sNHOR0yVtq/IiQFyuOVjFS+wuio/R4gSNkyYmKmJB4wGZv2NZanmKmTnNA==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-0B3bhxR6snWXJZtR/RliHTDPRgn1sNHOR0yVtq/IiQFyuOVjFS+wuio/R4gSNkyYmKmJB4wGZv2NZanmKmTnNA== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } peerDependencies: '@babel/core': ^7.0.0 balanced-match@1.0.2: - resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==} + resolution: { integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw== } bare-events@2.5.4: - resolution: {integrity: sha512-+gFfDkR8pj4/TrWCGUGWmJIkBwuxPS5F+a5yWjOHQt2hHvNZd5YLzadjmDUtFmMM4y429bnKLa8bYBMHcYdnQA==} + resolution: { integrity: sha512-+gFfDkR8pj4/TrWCGUGWmJIkBwuxPS5F+a5yWjOHQt2hHvNZd5YLzadjmDUtFmMM4y429bnKLa8bYBMHcYdnQA== } bare-fs@4.0.1: - resolution: {integrity: sha512-ilQs4fm/l9eMfWY2dY0WCIUplSUp7U0CT1vrqMg1MUdeZl4fypu5UP0XcDBK5WBQPJAKP1b7XEodISmekH/CEg==} - engines: {bare: '>=1.7.0'} + resolution: { integrity: sha512-ilQs4fm/l9eMfWY2dY0WCIUplSUp7U0CT1vrqMg1MUdeZl4fypu5UP0XcDBK5WBQPJAKP1b7XEodISmekH/CEg== } + engines: { bare: '>=1.7.0' } bare-os@3.4.0: - resolution: {integrity: sha512-9Ous7UlnKbe3fMi7Y+qh0DwAup6A1JkYgPnjvMDNOlmnxNRQvQ/7Nst+OnUQKzk0iAT0m9BisbDVp9gCv8+ETA==} - engines: {bare: '>=1.6.0'} + resolution: { integrity: sha512-9Ous7UlnKbe3fMi7Y+qh0DwAup6A1JkYgPnjvMDNOlmnxNRQvQ/7Nst+OnUQKzk0iAT0m9BisbDVp9gCv8+ETA== } + engines: { bare: '>=1.6.0' } bare-path@3.0.0: - resolution: {integrity: sha512-tyfW2cQcB5NN8Saijrhqn0Zh7AnFNsnczRcuWODH0eYAXBsJ5gVxAUuNr7tsHSC6IZ77cA0SitzT+s47kot8Mw==} + resolution: { integrity: sha512-tyfW2cQcB5NN8Saijrhqn0Zh7AnFNsnczRcuWODH0eYAXBsJ5gVxAUuNr7tsHSC6IZ77cA0SitzT+s47kot8Mw== } bare-stream@2.6.5: - resolution: {integrity: sha512-jSmxKJNJmHySi6hC42zlZnq00rga4jjxcgNZjY9N5WlOe/iOoGRtdwGsHzQv2RlH2KOYMwGUXhf2zXd32BA9RA==} + resolution: { integrity: sha512-jSmxKJNJmHySi6hC42zlZnq00rga4jjxcgNZjY9N5WlOe/iOoGRtdwGsHzQv2RlH2KOYMwGUXhf2zXd32BA9RA== } peerDependencies: bare-buffer: '*' bare-events: '*' @@ -1035,255 +1033,255 @@ packages: optional: true base64-js@1.5.1: - resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==} + resolution: { integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA== } bcrypt-pbkdf@1.0.2: - resolution: {integrity: sha512-qeFIXtP4MSoi6NLqO12WfqARWWuCKi2Rn/9hJLEmtB5yTNr9DqFWkJRCf2qShWzPeAMRnOgCrq0sg/KLv5ES9w==} + resolution: { integrity: sha512-qeFIXtP4MSoi6NLqO12WfqARWWuCKi2Rn/9hJLEmtB5yTNr9DqFWkJRCf2qShWzPeAMRnOgCrq0sg/KLv5ES9w== } better-sqlite3@11.8.1: - resolution: {integrity: sha512-9BxNaBkblMjhJW8sMRZxnxVTRgbRmssZW0Oxc1MPBTfiR+WW21e2Mk4qu8CzrcZb1LwPCnFsfDEzq+SNcBU8eg==} + resolution: { integrity: sha512-9BxNaBkblMjhJW8sMRZxnxVTRgbRmssZW0Oxc1MPBTfiR+WW21e2Mk4qu8CzrcZb1LwPCnFsfDEzq+SNcBU8eg== } binary-extensions@2.3.0: - resolution: {integrity: sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==} - engines: {node: '>=8'} + resolution: { integrity: sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw== } + engines: { node: '>=8' } bindings@1.5.0: - resolution: {integrity: sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==} + resolution: { integrity: sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ== } bl@4.1.0: - resolution: {integrity: sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==} + resolution: { integrity: sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w== } body-parser@1.20.3: - resolution: {integrity: sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==} - engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16} + resolution: { integrity: sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g== } + engines: { node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16 } brace-expansion@1.1.11: - resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==} + resolution: { integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA== } brace-expansion@2.0.1: - resolution: {integrity: sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==} + resolution: { integrity: sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA== } braces@3.0.3: - resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==} - engines: {node: '>=8'} + resolution: { integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA== } + engines: { node: '>=8' } browserslist@4.24.4: - resolution: {integrity: sha512-KDi1Ny1gSePi1vm0q4oxSF8b4DR44GF4BbmS2YdhPLOEqd8pDviZOGH/GsmRwoWJ2+5Lr085X7naowMwKHDG1A==} - engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7} + resolution: { integrity: sha512-KDi1Ny1gSePi1vm0q4oxSF8b4DR44GF4BbmS2YdhPLOEqd8pDviZOGH/GsmRwoWJ2+5Lr085X7naowMwKHDG1A== } + engines: { node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7 } hasBin: true bs-logger@0.2.6: - resolution: {integrity: sha512-pd8DCoxmbgc7hyPKOvxtqNcjYoOsABPQdcCUjGp3d42VR2CX1ORhk2A87oqqu5R1kk+76nsxZupkmyd+MVtCog==} - engines: {node: '>= 6'} + resolution: { integrity: sha512-pd8DCoxmbgc7hyPKOvxtqNcjYoOsABPQdcCUjGp3d42VR2CX1ORhk2A87oqqu5R1kk+76nsxZupkmyd+MVtCog== } + engines: { node: '>= 6' } bser@2.1.1: - resolution: {integrity: sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==} + resolution: { integrity: sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ== } buffer-crc32@1.0.0: - resolution: {integrity: sha512-Db1SbgBS/fg/392AblrMJk97KggmvYhr4pB5ZIMTWtaivCPMWLkmb7m21cJvpvgK+J3nsU2CmmixNBZx4vFj/w==} - engines: {node: '>=8.0.0'} + resolution: { integrity: sha512-Db1SbgBS/fg/392AblrMJk97KggmvYhr4pB5ZIMTWtaivCPMWLkmb7m21cJvpvgK+J3nsU2CmmixNBZx4vFj/w== } + engines: { node: '>=8.0.0' } buffer-from@1.1.2: - resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==} + resolution: { integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ== } buffer@5.7.1: - resolution: {integrity: sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==} + resolution: { integrity: sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ== } buffer@6.0.3: - resolution: {integrity: sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==} + resolution: { integrity: sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA== } buildcheck@0.0.6: - resolution: {integrity: sha512-8f9ZJCUXyT1M35Jx7MkBgmBMo3oHTTBIPLiY9xyL0pl3T5RwcPEY8cUHr5LBNfu/fk6c2T4DJZuVM/8ZZT2D2A==} - engines: {node: '>=10.0.0'} + resolution: { integrity: sha512-8f9ZJCUXyT1M35Jx7MkBgmBMo3oHTTBIPLiY9xyL0pl3T5RwcPEY8cUHr5LBNfu/fk6c2T4DJZuVM/8ZZT2D2A== } + engines: { node: '>=10.0.0' } busboy@1.6.0: - resolution: {integrity: sha512-8SFQbg/0hQ9xy3UNTB0YEnsNBbWfhf7RtnzpL7TkBiTBRfrQ9Fxcnz7VJsleJpyp6rVLvXiuORqjlHi5q+PYuA==} - engines: {node: '>=10.16.0'} + resolution: { integrity: sha512-8SFQbg/0hQ9xy3UNTB0YEnsNBbWfhf7RtnzpL7TkBiTBRfrQ9Fxcnz7VJsleJpyp6rVLvXiuORqjlHi5q+PYuA== } + engines: { node: '>=10.16.0' } byline@5.0.0: - resolution: {integrity: sha512-s6webAy+R4SR8XVuJWt2V2rGvhnrhxN+9S15GNuTK3wKPOXFF6RNc+8ug2XhH+2s4f+uudG4kUVYmYOQWL2g0Q==} - engines: {node: '>=0.10.0'} + resolution: { integrity: sha512-s6webAy+R4SR8XVuJWt2V2rGvhnrhxN+9S15GNuTK3wKPOXFF6RNc+8ug2XhH+2s4f+uudG4kUVYmYOQWL2g0Q== } + engines: { node: '>=0.10.0' } bytes@3.1.2: - resolution: {integrity: sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==} - engines: {node: '>= 0.8'} + resolution: { integrity: sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg== } + engines: { node: '>= 0.8' } cache-content-type@1.0.1: - resolution: {integrity: sha512-IKufZ1o4Ut42YUrZSo8+qnMTrFuKkvyoLXUywKz9GJ5BrhOFGhLdkx9sG4KAnVvbY6kEcSFjLQul+DVmBm2bgA==} - engines: {node: '>= 6.0.0'} + resolution: { integrity: sha512-IKufZ1o4Ut42YUrZSo8+qnMTrFuKkvyoLXUywKz9GJ5BrhOFGhLdkx9sG4KAnVvbY6kEcSFjLQul+DVmBm2bgA== } + engines: { node: '>= 6.0.0' } call-bind-apply-helpers@1.0.1: - resolution: {integrity: sha512-BhYE+WDaywFg2TBWYNXAE+8B1ATnThNBqXHP5nQu0jWJdVvY2hvkpyB3qOmtmDePiS5/BDQ8wASEWGMWRG148g==} - engines: {node: '>= 0.4'} + resolution: { integrity: sha512-BhYE+WDaywFg2TBWYNXAE+8B1ATnThNBqXHP5nQu0jWJdVvY2hvkpyB3qOmtmDePiS5/BDQ8wASEWGMWRG148g== } + engines: { node: '>= 0.4' } call-bound@1.0.3: - resolution: {integrity: sha512-YTd+6wGlNlPxSuri7Y6X8tY2dmm12UMH66RpKMhiX6rsk5wXXnYgbUcOt8kiS31/AjfoTOvCsE+w8nZQLQnzHA==} - engines: {node: '>= 0.4'} + resolution: { integrity: sha512-YTd+6wGlNlPxSuri7Y6X8tY2dmm12UMH66RpKMhiX6rsk5wXXnYgbUcOt8kiS31/AjfoTOvCsE+w8nZQLQnzHA== } + engines: { node: '>= 0.4' } callsites@3.1.0: - resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==} - engines: {node: '>=6'} + resolution: { integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ== } + engines: { node: '>=6' } camelcase@5.3.1: - resolution: {integrity: sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==} - engines: {node: '>=6'} + resolution: { integrity: sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg== } + engines: { node: '>=6' } camelcase@6.3.0: - resolution: {integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==} - engines: {node: '>=10'} + resolution: { integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA== } + engines: { node: '>=10' } caniuse-lite@1.0.30001697: - resolution: {integrity: sha512-GwNPlWJin8E+d7Gxq96jxM6w0w+VFeyyXRsjU58emtkYqnbwHqXm5uT2uCmO0RQE9htWknOP4xtBlLmM/gWxvQ==} + resolution: { integrity: sha512-GwNPlWJin8E+d7Gxq96jxM6w0w+VFeyyXRsjU58emtkYqnbwHqXm5uT2uCmO0RQE9htWknOP4xtBlLmM/gWxvQ== } chalk@4.1.2: - resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==} - engines: {node: '>=10'} + resolution: { integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA== } + engines: { node: '>=10' } char-regex@1.0.2: - resolution: {integrity: sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==} - engines: {node: '>=10'} + resolution: { integrity: sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw== } + engines: { node: '>=10' } chokidar@3.6.0: - resolution: {integrity: sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==} - engines: {node: '>= 8.10.0'} + resolution: { integrity: sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw== } + engines: { node: '>= 8.10.0' } chownr@1.1.4: - resolution: {integrity: sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==} + resolution: { integrity: sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg== } ci-info@3.9.0: - resolution: {integrity: sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==} - engines: {node: '>=8'} + resolution: { integrity: sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ== } + engines: { node: '>=8' } cjs-module-lexer@1.4.3: - resolution: {integrity: sha512-9z8TZaGM1pfswYeXrUpzPrkx8UnWYdhJclsiYMm6x/w5+nN+8Tf/LnAgfLGQCm59qAOxU8WwHEq2vNwF6i4j+Q==} + resolution: { integrity: sha512-9z8TZaGM1pfswYeXrUpzPrkx8UnWYdhJclsiYMm6x/w5+nN+8Tf/LnAgfLGQCm59qAOxU8WwHEq2vNwF6i4j+Q== } class-transformer@0.5.1: - resolution: {integrity: sha512-SQa1Ws6hUbfC98vKGxZH3KFY0Y1lm5Zm0SY8XX9zbK7FJCyVEac3ATW0RIpwzW+oOfmHE5PMPufDG9hCfoEOMw==} + resolution: { integrity: sha512-SQa1Ws6hUbfC98vKGxZH3KFY0Y1lm5Zm0SY8XX9zbK7FJCyVEac3ATW0RIpwzW+oOfmHE5PMPufDG9hCfoEOMw== } class-validator@0.14.1: - resolution: {integrity: sha512-2VEG9JICxIqTpoK1eMzZqaV+u/EiwEJkMGzTrZf6sU/fwsnOITVgYJ8yojSy6CaXtO9V0Cc6ZQZ8h8m4UBuLwQ==} + resolution: { integrity: sha512-2VEG9JICxIqTpoK1eMzZqaV+u/EiwEJkMGzTrZf6sU/fwsnOITVgYJ8yojSy6CaXtO9V0Cc6ZQZ8h8m4UBuLwQ== } cliui@8.0.1: - resolution: {integrity: sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==} - engines: {node: '>=12'} + resolution: { integrity: sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ== } + engines: { node: '>=12' } co-body@6.2.0: - resolution: {integrity: sha512-Kbpv2Yd1NdL1V/V4cwLVxraHDV6K8ayohr2rmH0J87Er8+zJjcTa6dAn9QMPC9CRgU8+aNajKbSf1TzDB1yKPA==} - engines: {node: '>=8.0.0'} + resolution: { integrity: sha512-Kbpv2Yd1NdL1V/V4cwLVxraHDV6K8ayohr2rmH0J87Er8+zJjcTa6dAn9QMPC9CRgU8+aNajKbSf1TzDB1yKPA== } + engines: { node: '>=8.0.0' } co@4.6.0: - resolution: {integrity: sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ==} - engines: {iojs: '>= 1.0.0', node: '>= 0.12.0'} + resolution: { integrity: sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ== } + engines: { iojs: '>= 1.0.0', node: '>= 0.12.0' } collect-v8-coverage@1.0.2: - resolution: {integrity: sha512-lHl4d5/ONEbLlJvaJNtsF/Lz+WvB07u2ycqTYbdrq7UypDXailES4valYb2eWiJFxZlVmpGekfqoxQhzyFdT4Q==} + resolution: { integrity: sha512-lHl4d5/ONEbLlJvaJNtsF/Lz+WvB07u2ycqTYbdrq7UypDXailES4valYb2eWiJFxZlVmpGekfqoxQhzyFdT4Q== } color-convert@2.0.1: - resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==} - engines: {node: '>=7.0.0'} + resolution: { integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ== } + engines: { node: '>=7.0.0' } color-name@1.1.4: - resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==} + resolution: { integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA== } combined-stream@1.0.8: - resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==} - engines: {node: '>= 0.8'} + resolution: { integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg== } + engines: { node: '>= 0.8' } component-emitter@1.3.1: - resolution: {integrity: sha512-T0+barUSQRTUQASh8bx02dl+DhF54GtIDY13Y3m9oWTklKbb3Wv974meRpeZ3lp1JpLVECWWNHC4vaG2XHXouQ==} + resolution: { integrity: sha512-T0+barUSQRTUQASh8bx02dl+DhF54GtIDY13Y3m9oWTklKbb3Wv974meRpeZ3lp1JpLVECWWNHC4vaG2XHXouQ== } compress-commons@6.0.2: - resolution: {integrity: sha512-6FqVXeETqWPoGcfzrXb37E50NP0LXT8kAMu5ooZayhWWdgEY4lBEEcbQNXtkuKQsGduxiIcI4gOTsxTmuq/bSg==} - engines: {node: '>= 14'} + resolution: { integrity: sha512-6FqVXeETqWPoGcfzrXb37E50NP0LXT8kAMu5ooZayhWWdgEY4lBEEcbQNXtkuKQsGduxiIcI4gOTsxTmuq/bSg== } + engines: { node: '>= 14' } concat-map@0.0.1: - resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==} + resolution: { integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg== } concat-stream@1.6.2: - resolution: {integrity: sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==} - engines: {'0': node >= 0.8} + resolution: { integrity: sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw== } + engines: { '0': node >= 0.8 } content-disposition@0.5.4: - resolution: {integrity: sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==} - engines: {node: '>= 0.6'} + resolution: { integrity: sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ== } + engines: { node: '>= 0.6' } content-type@1.0.5: - resolution: {integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==} - engines: {node: '>= 0.6'} + resolution: { integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA== } + engines: { node: '>= 0.6' } convert-source-map@2.0.0: - resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==} + resolution: { integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg== } cookie-signature@1.0.6: - resolution: {integrity: sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==} + resolution: { integrity: sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ== } cookie-signature@1.0.7: - resolution: {integrity: sha512-NXdYc3dLr47pBkpUCHtKSwIOQXLVn8dZEuywboCOJY/osA0wFSLlSawr3KN8qXJEyX66FcONTH8EIlVuK0yyFA==} + resolution: { integrity: sha512-NXdYc3dLr47pBkpUCHtKSwIOQXLVn8dZEuywboCOJY/osA0wFSLlSawr3KN8qXJEyX66FcONTH8EIlVuK0yyFA== } cookie@0.7.1: - resolution: {integrity: sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==} - engines: {node: '>= 0.6'} + resolution: { integrity: sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w== } + engines: { node: '>= 0.6' } cookie@0.7.2: - resolution: {integrity: sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==} - engines: {node: '>= 0.6'} + resolution: { integrity: sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w== } + engines: { node: '>= 0.6' } cookie@1.0.2: - resolution: {integrity: sha512-9Kr/j4O16ISv8zBBhJoi4bXOYNTkFLOqSL3UDB0njXxCXNezjeyVrJyGOWtgfs/q2km1gwBcfH8q1yEGoMYunA==} - engines: {node: '>=18'} + resolution: { integrity: sha512-9Kr/j4O16ISv8zBBhJoi4bXOYNTkFLOqSL3UDB0njXxCXNezjeyVrJyGOWtgfs/q2km1gwBcfH8q1yEGoMYunA== } + engines: { node: '>=18' } cookiejar@2.1.4: - resolution: {integrity: sha512-LDx6oHrK+PhzLKJU9j5S7/Y3jM/mUHvD/DeI1WQmJn652iPC5Y4TBzC9l+5OMOXlyTTA+SmVUPm0HQUwpD5Jqw==} + resolution: { integrity: sha512-LDx6oHrK+PhzLKJU9j5S7/Y3jM/mUHvD/DeI1WQmJn652iPC5Y4TBzC9l+5OMOXlyTTA+SmVUPm0HQUwpD5Jqw== } cookies@0.9.1: - resolution: {integrity: sha512-TG2hpqe4ELx54QER/S3HQ9SRVnQnGBtKUz5bLQWtYAQ+o6GpgMs6sYUvaiJjVxb+UXwhRhAEP3m7LbsIZ77Hmw==} - engines: {node: '>= 0.8'} + resolution: { integrity: sha512-TG2hpqe4ELx54QER/S3HQ9SRVnQnGBtKUz5bLQWtYAQ+o6GpgMs6sYUvaiJjVxb+UXwhRhAEP3m7LbsIZ77Hmw== } + engines: { node: '>= 0.8' } copy-to@2.0.1: - resolution: {integrity: sha512-3DdaFaU/Zf1AnpLiFDeNCD4TOWe3Zl2RZaTzUvWiIk5ERzcCodOE20Vqq4fzCbNoHURFHT4/us/Lfq+S2zyY4w==} + resolution: { integrity: sha512-3DdaFaU/Zf1AnpLiFDeNCD4TOWe3Zl2RZaTzUvWiIk5ERzcCodOE20Vqq4fzCbNoHURFHT4/us/Lfq+S2zyY4w== } core-util-is@1.0.3: - resolution: {integrity: sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==} + resolution: { integrity: sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ== } cors@2.8.5: - resolution: {integrity: sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==} - engines: {node: '>= 0.10'} + resolution: { integrity: sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g== } + engines: { node: '>= 0.10' } cpu-features@0.0.10: - resolution: {integrity: sha512-9IkYqtX3YHPCzoVg1Py+o9057a3i0fp7S530UWokCSaFVTc7CwXPRiOjRjBQQ18ZCNafx78YfnG+HALxtVmOGA==} - engines: {node: '>=10.0.0'} + resolution: { integrity: sha512-9IkYqtX3YHPCzoVg1Py+o9057a3i0fp7S530UWokCSaFVTc7CwXPRiOjRjBQQ18ZCNafx78YfnG+HALxtVmOGA== } + engines: { node: '>=10.0.0' } crc-32@1.2.2: - resolution: {integrity: sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ==} - engines: {node: '>=0.8'} + resolution: { integrity: sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ== } + engines: { node: '>=0.8' } hasBin: true crc32-stream@6.0.0: - resolution: {integrity: sha512-piICUB6ei4IlTv1+653yq5+KoqfBYmj9bw6LqXoOneTMDXk5nM1qt12mFW1caG3LlJXEKW1Bp0WggEmIfQB34g==} - engines: {node: '>= 14'} + resolution: { integrity: sha512-piICUB6ei4IlTv1+653yq5+KoqfBYmj9bw6LqXoOneTMDXk5nM1qt12mFW1caG3LlJXEKW1Bp0WggEmIfQB34g== } + engines: { node: '>= 14' } create-jest@29.7.0: - resolution: {integrity: sha512-Adz2bdH0Vq3F53KEMJOoftQFutWCukm6J24wbPWRO4k1kMY7gS7ds/uoJkNuV8wDCtWWnuwGcJwpWcih+zEW1Q==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-Adz2bdH0Vq3F53KEMJOoftQFutWCukm6J24wbPWRO4k1kMY7gS7ds/uoJkNuV8wDCtWWnuwGcJwpWcih+zEW1Q== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } hasBin: true create-require@1.1.1: - resolution: {integrity: sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==} + resolution: { integrity: sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ== } cross-env@7.0.3: - resolution: {integrity: sha512-+/HKd6EgcQCJGh2PSjZuUitQBQynKor4wrFbRg4DtAgS1aWO+gU52xpH7M9ScGgXSYmAVS9bIJ8EzuaGw0oNAw==} - engines: {node: '>=10.14', npm: '>=6', yarn: '>=1'} + resolution: { integrity: sha512-+/HKd6EgcQCJGh2PSjZuUitQBQynKor4wrFbRg4DtAgS1aWO+gU52xpH7M9ScGgXSYmAVS9bIJ8EzuaGw0oNAw== } + engines: { node: '>=10.14', npm: '>=6', yarn: '>=1' } hasBin: true cross-fetch@3.2.0: - resolution: {integrity: sha512-Q+xVJLoGOeIMXZmbUK4HYk+69cQH6LudR0Vu/pRm2YlU/hDV9CiS0gKUMaWY5f2NeUH9C1nV3bsTlCo0FsTV1Q==} + resolution: { integrity: sha512-Q+xVJLoGOeIMXZmbUK4HYk+69cQH6LudR0Vu/pRm2YlU/hDV9CiS0gKUMaWY5f2NeUH9C1nV3bsTlCo0FsTV1Q== } cross-spawn@7.0.6: - resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==} - engines: {node: '>= 8'} + resolution: { integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA== } + engines: { node: '>= 8' } debug@2.6.9: - resolution: {integrity: sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==} + resolution: { integrity: sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA== } peerDependencies: supports-color: '*' peerDependenciesMeta: @@ -1291,8 +1289,8 @@ packages: optional: true debug@4.4.0: - resolution: {integrity: sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==} - engines: {node: '>=6.0'} + resolution: { integrity: sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA== } + engines: { node: '>=6.0' } peerDependencies: supports-color: '*' peerDependenciesMeta: @@ -1300,11 +1298,11 @@ packages: optional: true decompress-response@6.0.0: - resolution: {integrity: sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==} - engines: {node: '>=10'} + resolution: { integrity: sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ== } + engines: { node: '>=10' } dedent@1.5.3: - resolution: {integrity: sha512-NHQtfOOW68WD8lgypbLA5oT+Bt0xXJhiYvoR6SmmNXZfpzOGXwdKWmcwG8N7PwVVWV3eF/68nmD9BaJSsTBhyQ==} + resolution: { integrity: sha512-NHQtfOOW68WD8lgypbLA5oT+Bt0xXJhiYvoR6SmmNXZfpzOGXwdKWmcwG8N7PwVVWV3eF/68nmD9BaJSsTBhyQ== } peerDependencies: babel-plugin-macros: ^3.1.0 peerDependenciesMeta: @@ -1312,80 +1310,80 @@ packages: optional: true deep-equal@1.0.1: - resolution: {integrity: sha512-bHtC0iYvWhyaTzvV3CZgPeZQqCOBGyGsVV7v4eevpdkLHfiSrXUdBG+qAuSz4RI70sszvjQ1QSZ98An1yNwpSw==} + resolution: { integrity: sha512-bHtC0iYvWhyaTzvV3CZgPeZQqCOBGyGsVV7v4eevpdkLHfiSrXUdBG+qAuSz4RI70sszvjQ1QSZ98An1yNwpSw== } deep-extend@0.6.0: - resolution: {integrity: sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==} - engines: {node: '>=4.0.0'} + resolution: { integrity: sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA== } + engines: { node: '>=4.0.0' } deepmerge@4.3.1: - resolution: {integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==} - engines: {node: '>=0.10.0'} + resolution: { integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A== } + engines: { node: '>=0.10.0' } delayed-stream@1.0.0: - resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==} - engines: {node: '>=0.4.0'} + resolution: { integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ== } + engines: { node: '>=0.4.0' } delegates@1.0.0: - resolution: {integrity: sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ==} + resolution: { integrity: sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ== } depd@1.1.2: - resolution: {integrity: sha512-7emPTl6Dpo6JRXOXjLRxck+FlLRX5847cLKEn00PLAgc3g2hTZZgr+e4c2v6QpSmLeFP3n5yUo7ft6avBK/5jQ==} - engines: {node: '>= 0.6'} + resolution: { integrity: sha512-7emPTl6Dpo6JRXOXjLRxck+FlLRX5847cLKEn00PLAgc3g2hTZZgr+e4c2v6QpSmLeFP3n5yUo7ft6avBK/5jQ== } + engines: { node: '>= 0.6' } depd@2.0.0: - resolution: {integrity: sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==} - engines: {node: '>= 0.8'} + resolution: { integrity: sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw== } + engines: { node: '>= 0.8' } destroy@1.2.0: - resolution: {integrity: sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==} - engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16} + resolution: { integrity: sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg== } + engines: { node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16 } detect-libc@2.0.3: - resolution: {integrity: sha512-bwy0MGW55bG41VqxxypOsdSdGqLwXPI/focwgTYCFMbdUiBAxLg9CFzG08sz2aqzknwiX7Hkl0bQENjg8iLByw==} - engines: {node: '>=8'} + resolution: { integrity: sha512-bwy0MGW55bG41VqxxypOsdSdGqLwXPI/focwgTYCFMbdUiBAxLg9CFzG08sz2aqzknwiX7Hkl0bQENjg8iLByw== } + engines: { node: '>=8' } detect-newline@3.1.0: - resolution: {integrity: sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==} - engines: {node: '>=8'} + resolution: { integrity: sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA== } + engines: { node: '>=8' } dezalgo@1.0.4: - resolution: {integrity: sha512-rXSP0bf+5n0Qonsb+SVVfNfIsimO4HEtmnIpPHY8Q1UCzKlQrDMfdobr8nJOOsRgWCyMRqeSBQzmWUMq7zvVig==} + resolution: { integrity: sha512-rXSP0bf+5n0Qonsb+SVVfNfIsimO4HEtmnIpPHY8Q1UCzKlQrDMfdobr8nJOOsRgWCyMRqeSBQzmWUMq7zvVig== } diff-sequences@29.6.3: - resolution: {integrity: sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } diff@4.0.2: - resolution: {integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==} - engines: {node: '>=0.3.1'} + resolution: { integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A== } + engines: { node: '>=0.3.1' } docker-compose@0.24.8: - resolution: {integrity: sha512-plizRs/Vf15H+GCVxq2EUvyPK7ei9b/cVesHvjnX4xaXjM9spHe2Ytq0BitndFgvTJ3E3NljPNUEl7BAN43iZw==} - engines: {node: '>= 6.0.0'} + resolution: { integrity: sha512-plizRs/Vf15H+GCVxq2EUvyPK7ei9b/cVesHvjnX4xaXjM9spHe2Ytq0BitndFgvTJ3E3NljPNUEl7BAN43iZw== } + engines: { node: '>= 6.0.0' } docker-modem@3.0.8: - resolution: {integrity: sha512-f0ReSURdM3pcKPNS30mxOHSbaFLcknGmQjwSfmbcdOw1XWKXVhukM3NJHhr7NpY9BIyyWQb0EBo3KQvvuU5egQ==} - engines: {node: '>= 8.0'} + resolution: { integrity: sha512-f0ReSURdM3pcKPNS30mxOHSbaFLcknGmQjwSfmbcdOw1XWKXVhukM3NJHhr7NpY9BIyyWQb0EBo3KQvvuU5egQ== } + engines: { node: '>= 8.0' } dockerode@3.3.5: - resolution: {integrity: sha512-/0YNa3ZDNeLr/tSckmD69+Gq+qVNhvKfAHNeZJBnp7EOP6RGKV8ORrJHkUn20So5wU+xxT7+1n5u8PjHbfjbSA==} - engines: {node: '>= 8.0'} + resolution: { integrity: sha512-/0YNa3ZDNeLr/tSckmD69+Gq+qVNhvKfAHNeZJBnp7EOP6RGKV8ORrJHkUn20So5wU+xxT7+1n5u8PjHbfjbSA== } + engines: { node: '>= 8.0' } dotenv-flow@4.1.0: - resolution: {integrity: sha512-0cwP9jpQBQfyHwvE0cRhraZMkdV45TQedA8AAUZMsFzvmLcQyc1HPv+oX0OOYwLFjIlvgVepQ+WuQHbqDaHJZg==} - engines: {node: '>= 12.0.0'} + resolution: { integrity: sha512-0cwP9jpQBQfyHwvE0cRhraZMkdV45TQedA8AAUZMsFzvmLcQyc1HPv+oX0OOYwLFjIlvgVepQ+WuQHbqDaHJZg== } + engines: { node: '>= 12.0.0' } dotenv@16.4.7: - resolution: {integrity: sha512-47qPchRCykZC03FhkYAhrvwU4xDBFIj1QPqaarj6mdM/hgUzfPHcpkHJOn3mJAufFeeAxAzeGsr5X0M4k6fLZQ==} - engines: {node: '>=12'} + resolution: { integrity: sha512-47qPchRCykZC03FhkYAhrvwU4xDBFIj1QPqaarj6mdM/hgUzfPHcpkHJOn3mJAufFeeAxAzeGsr5X0M4k6fLZQ== } + engines: { node: '>=12' } drizzle-kit@0.30.4: - resolution: {integrity: sha512-B2oJN5UkvwwNHscPWXDG5KqAixu7AUzZ3qbe++KU9SsQ+cZWR4DXEPYcvWplyFAno0dhRJECNEhNxiDmFaPGyQ==} + resolution: { integrity: sha512-B2oJN5UkvwwNHscPWXDG5KqAixu7AUzZ3qbe++KU9SsQ+cZWR4DXEPYcvWplyFAno0dhRJECNEhNxiDmFaPGyQ== } hasBin: true drizzle-orm@0.39.3: - resolution: {integrity: sha512-EZ8ZpYvDIvKU9C56JYLOmUskazhad+uXZCTCRN4OnRMsL+xAJ05dv1eCpAG5xzhsm1hqiuC5kAZUCS924u2DTw==} + resolution: { integrity: sha512-EZ8ZpYvDIvKU9C56JYLOmUskazhad+uXZCTCRN4OnRMsL+xAJ05dv1eCpAG5xzhsm1hqiuC5kAZUCS924u2DTw== } peerDependencies: '@aws-sdk/client-rds-data': '>=3' '@cloudflare/workers-types': '>=4' @@ -1471,442 +1469,442 @@ packages: optional: true dunder-proto@1.0.1: - resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==} - engines: {node: '>= 0.4'} + resolution: { integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A== } + engines: { node: '>= 0.4' } dynamic-dedupe@0.3.0: - resolution: {integrity: sha512-ssuANeD+z97meYOqd50e04Ze5qp4bPqo8cCkI4TRjZkzAUgIDTrXV1R8QCdINpiI+hw14+rYazvTRdQrz0/rFQ==} + resolution: { integrity: sha512-ssuANeD+z97meYOqd50e04Ze5qp4bPqo8cCkI4TRjZkzAUgIDTrXV1R8QCdINpiI+hw14+rYazvTRdQrz0/rFQ== } eastasianwidth@0.2.0: - resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==} + resolution: { integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA== } ee-first@1.1.1: - resolution: {integrity: sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==} + resolution: { integrity: sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow== } ejs@3.1.10: - resolution: {integrity: sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA==} - engines: {node: '>=0.10.0'} + resolution: { integrity: sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA== } + engines: { node: '>=0.10.0' } hasBin: true electron-to-chromium@1.5.91: - resolution: {integrity: sha512-sNSHHyq048PFmZY4S90ax61q+gLCs0X0YmcOII9wG9S2XwbVr+h4VW2wWhnbp/Eys3cCwTxVF292W3qPaxIapQ==} + resolution: { integrity: sha512-sNSHHyq048PFmZY4S90ax61q+gLCs0X0YmcOII9wG9S2XwbVr+h4VW2wWhnbp/Eys3cCwTxVF292W3qPaxIapQ== } emittery@0.13.1: - resolution: {integrity: sha512-DeWwawk6r5yR9jFgnDKYt4sLS0LmHJJi3ZOnb5/JdbYwj3nW+FxQnHIjhBKz8YLC7oRNPVM9NQ47I3CVx34eqQ==} - engines: {node: '>=12'} + resolution: { integrity: sha512-DeWwawk6r5yR9jFgnDKYt4sLS0LmHJJi3ZOnb5/JdbYwj3nW+FxQnHIjhBKz8YLC7oRNPVM9NQ47I3CVx34eqQ== } + engines: { node: '>=12' } emoji-regex@8.0.0: - resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==} + resolution: { integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A== } emoji-regex@9.2.2: - resolution: {integrity: sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==} + resolution: { integrity: sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg== } encodeurl@1.0.2: - resolution: {integrity: sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==} - engines: {node: '>= 0.8'} + resolution: { integrity: sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w== } + engines: { node: '>= 0.8' } encodeurl@2.0.0: - resolution: {integrity: sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==} - engines: {node: '>= 0.8'} + resolution: { integrity: sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg== } + engines: { node: '>= 0.8' } encoding@0.1.13: - resolution: {integrity: sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A==} + resolution: { integrity: sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A== } end-of-stream@1.4.4: - resolution: {integrity: sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==} + resolution: { integrity: sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q== } error-ex@1.3.2: - resolution: {integrity: sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==} + resolution: { integrity: sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g== } es-define-property@1.0.1: - resolution: {integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==} - engines: {node: '>= 0.4'} + resolution: { integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g== } + engines: { node: '>= 0.4' } es-errors@1.3.0: - resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==} - engines: {node: '>= 0.4'} + resolution: { integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw== } + engines: { node: '>= 0.4' } es-object-atoms@1.1.1: - resolution: {integrity: sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==} - engines: {node: '>= 0.4'} + resolution: { integrity: sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA== } + engines: { node: '>= 0.4' } es-set-tostringtag@2.1.0: - resolution: {integrity: sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==} - engines: {node: '>= 0.4'} + resolution: { integrity: sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA== } + engines: { node: '>= 0.4' } esbuild-register@3.6.0: - resolution: {integrity: sha512-H2/S7Pm8a9CL1uhp9OvjwrBh5Pvx0H8qVOxNu8Wed9Y7qv56MPtq+GGM8RJpq6glYJn9Wspr8uw7l55uyinNeg==} + resolution: { integrity: sha512-H2/S7Pm8a9CL1uhp9OvjwrBh5Pvx0H8qVOxNu8Wed9Y7qv56MPtq+GGM8RJpq6glYJn9Wspr8uw7l55uyinNeg== } peerDependencies: esbuild: '>=0.12 <1' esbuild@0.18.20: - resolution: {integrity: sha512-ceqxoedUrcayh7Y7ZX6NdbbDzGROiyVBgC4PriJThBKSVPWnnFHZAkfI1lJT8QFkOwH4qOS2SJkS4wvpGl8BpA==} - engines: {node: '>=12'} + resolution: { integrity: sha512-ceqxoedUrcayh7Y7ZX6NdbbDzGROiyVBgC4PriJThBKSVPWnnFHZAkfI1lJT8QFkOwH4qOS2SJkS4wvpGl8BpA== } + engines: { node: '>=12' } hasBin: true esbuild@0.19.12: - resolution: {integrity: sha512-aARqgq8roFBj054KvQr5f1sFu0D65G+miZRCuJyJ0G13Zwx7vRar5Zhn2tkQNzIXcBrNVsv/8stehpj+GAjgbg==} - engines: {node: '>=12'} + resolution: { integrity: sha512-aARqgq8roFBj054KvQr5f1sFu0D65G+miZRCuJyJ0G13Zwx7vRar5Zhn2tkQNzIXcBrNVsv/8stehpj+GAjgbg== } + engines: { node: '>=12' } hasBin: true escalade@3.2.0: - resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==} - engines: {node: '>=6'} + resolution: { integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA== } + engines: { node: '>=6' } escape-html@1.0.3: - resolution: {integrity: sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==} + resolution: { integrity: sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow== } escape-string-regexp@2.0.0: - resolution: {integrity: sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==} - engines: {node: '>=8'} + resolution: { integrity: sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w== } + engines: { node: '>=8' } esprima@4.0.1: - resolution: {integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==} - engines: {node: '>=4'} + resolution: { integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A== } + engines: { node: '>=4' } hasBin: true etag@1.8.1: - resolution: {integrity: sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==} - engines: {node: '>= 0.6'} + resolution: { integrity: sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg== } + engines: { node: '>= 0.6' } event-target-shim@5.0.1: - resolution: {integrity: sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==} - engines: {node: '>=6'} + resolution: { integrity: sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ== } + engines: { node: '>=6' } events@3.3.0: - resolution: {integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==} - engines: {node: '>=0.8.x'} + resolution: { integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q== } + engines: { node: '>=0.8.x' } execa@5.1.1: - resolution: {integrity: sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==} - engines: {node: '>=10'} + resolution: { integrity: sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg== } + engines: { node: '>=10' } exit@0.1.2: - resolution: {integrity: sha512-Zk/eNKV2zbjpKzrsQ+n1G6poVbErQxJ0LBOJXaKZ1EViLzH+hrLu9cdXI4zw9dBQJslwBEpbQ2P1oS7nDxs6jQ==} - engines: {node: '>= 0.8.0'} + resolution: { integrity: sha512-Zk/eNKV2zbjpKzrsQ+n1G6poVbErQxJ0LBOJXaKZ1EViLzH+hrLu9cdXI4zw9dBQJslwBEpbQ2P1oS7nDxs6jQ== } + engines: { node: '>= 0.8.0' } expand-template@2.0.3: - resolution: {integrity: sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==} - engines: {node: '>=6'} + resolution: { integrity: sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg== } + engines: { node: '>=6' } expect@29.7.0: - resolution: {integrity: sha512-2Zks0hf1VLFYI1kbh0I5jP3KHHyCHpkfyHBzsSXRFgl/Bg9mWYfMW8oD+PdMPlEwy5HNsR9JutYy6pMeOh61nw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-2Zks0hf1VLFYI1kbh0I5jP3KHHyCHpkfyHBzsSXRFgl/Bg9mWYfMW8oD+PdMPlEwy5HNsR9JutYy6pMeOh61nw== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } express-session@1.18.1: - resolution: {integrity: sha512-a5mtTqEaZvBCL9A9aqkrtfz+3SMDhOVUnjafjo+s7A9Txkq+SVX2DLvSp1Zrv4uCXa3lMSK3viWnh9Gg07PBUA==} - engines: {node: '>= 0.8.0'} + resolution: { integrity: sha512-a5mtTqEaZvBCL9A9aqkrtfz+3SMDhOVUnjafjo+s7A9Txkq+SVX2DLvSp1Zrv4uCXa3lMSK3viWnh9Gg07PBUA== } + engines: { node: '>= 0.8.0' } express@4.21.2: - resolution: {integrity: sha512-28HqgMZAmih1Czt9ny7qr6ek2qddF4FclbMzwhCREB6OFfH+rXAnuNCwo1/wFvrtbgsQDb4kSbX9de9lFbrXnA==} - engines: {node: '>= 0.10.0'} + resolution: { integrity: sha512-28HqgMZAmih1Czt9ny7qr6ek2qddF4FclbMzwhCREB6OFfH+rXAnuNCwo1/wFvrtbgsQDb4kSbX9de9lFbrXnA== } + engines: { node: '>= 0.10.0' } fast-fifo@1.3.2: - resolution: {integrity: sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==} + resolution: { integrity: sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ== } fast-json-stable-stringify@2.1.0: - resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==} + resolution: { integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw== } fast-safe-stringify@2.1.1: - resolution: {integrity: sha512-W+KJc2dmILlPplD/H4K9l9LcAHAfPtP6BY84uVLXQ6Evcz9Lcg33Y2z1IVblT6xdY54PXYVHEv+0Wpq8Io6zkA==} + resolution: { integrity: sha512-W+KJc2dmILlPplD/H4K9l9LcAHAfPtP6BY84uVLXQ6Evcz9Lcg33Y2z1IVblT6xdY54PXYVHEv+0Wpq8Io6zkA== } fb-watchman@2.0.2: - resolution: {integrity: sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA==} + resolution: { integrity: sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA== } file-uri-to-path@1.0.0: - resolution: {integrity: sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==} + resolution: { integrity: sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw== } filelist@1.0.4: - resolution: {integrity: sha512-w1cEuf3S+DrLCQL7ET6kz+gmlJdbq9J7yXCSjK/OZCPA+qEN1WyF4ZAf0YYJa4/shHJra2t/d/r8SV4Ji+x+8Q==} + resolution: { integrity: sha512-w1cEuf3S+DrLCQL7ET6kz+gmlJdbq9J7yXCSjK/OZCPA+qEN1WyF4ZAf0YYJa4/shHJra2t/d/r8SV4Ji+x+8Q== } fill-range@7.1.1: - resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==} - engines: {node: '>=8'} + resolution: { integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg== } + engines: { node: '>=8' } finalhandler@1.3.1: - resolution: {integrity: sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==} - engines: {node: '>= 0.8'} + resolution: { integrity: sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ== } + engines: { node: '>= 0.8' } find-up@4.1.0: - resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==} - engines: {node: '>=8'} + resolution: { integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw== } + engines: { node: '>=8' } fix-esm@1.0.1: - resolution: {integrity: sha512-EZtb7wPXZS54GaGxaWxMlhd1DUDCnAg5srlYdu/1ZVeW+7wwR3Tp59nu52dXByFs3MBRq+SByx1wDOJpRvLEXw==} + resolution: { integrity: sha512-EZtb7wPXZS54GaGxaWxMlhd1DUDCnAg5srlYdu/1ZVeW+7wwR3Tp59nu52dXByFs3MBRq+SByx1wDOJpRvLEXw== } foreground-child@3.3.0: - resolution: {integrity: sha512-Ld2g8rrAyMYFXBhEqMz8ZAHBi4J4uS1i/CxGMDnjyFWddMXLVcDp051DZfu+t7+ab7Wv6SMqpWmyFIj5UbfFvg==} - engines: {node: '>=14'} + resolution: { integrity: sha512-Ld2g8rrAyMYFXBhEqMz8ZAHBi4J4uS1i/CxGMDnjyFWddMXLVcDp051DZfu+t7+ab7Wv6SMqpWmyFIj5UbfFvg== } + engines: { node: '>=14' } form-data@4.0.2: - resolution: {integrity: sha512-hGfm/slu0ZabnNt4oaRZ6uREyfCj6P4fT/n6A1rGV+Z0VdGXjfOhVUpkn6qVQONHGIFwmveGXyDs75+nr6FM8w==} - engines: {node: '>= 6'} + resolution: { integrity: sha512-hGfm/slu0ZabnNt4oaRZ6uREyfCj6P4fT/n6A1rGV+Z0VdGXjfOhVUpkn6qVQONHGIFwmveGXyDs75+nr6FM8w== } + engines: { node: '>= 6' } formidable@3.5.2: - resolution: {integrity: sha512-Jqc1btCy3QzRbJaICGwKcBfGWuLADRerLzDqi2NwSt/UkXLsHJw2TVResiaoBufHVHy9aSgClOHCeJsSsFLTbg==} + resolution: { integrity: sha512-Jqc1btCy3QzRbJaICGwKcBfGWuLADRerLzDqi2NwSt/UkXLsHJw2TVResiaoBufHVHy9aSgClOHCeJsSsFLTbg== } forwarded@0.2.0: - resolution: {integrity: sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==} - engines: {node: '>= 0.6'} + resolution: { integrity: sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow== } + engines: { node: '>= 0.6' } fresh@0.5.2: - resolution: {integrity: sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==} - engines: {node: '>= 0.6'} + resolution: { integrity: sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q== } + engines: { node: '>= 0.6' } fs-constants@1.0.0: - resolution: {integrity: sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==} + resolution: { integrity: sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow== } fs.realpath@1.0.0: - resolution: {integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==} + resolution: { integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw== } fsevents@2.3.3: - resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==} - engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0} + resolution: { integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw== } + engines: { node: ^8.16.0 || ^10.6.0 || >=11.0.0 } os: [darwin] function-bind@1.1.2: - resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==} + resolution: { integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA== } gensync@1.0.0-beta.2: - resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==} - engines: {node: '>=6.9.0'} + resolution: { integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg== } + engines: { node: '>=6.9.0' } get-caller-file@2.0.5: - resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==} - engines: {node: 6.* || 8.* || >= 10.*} + resolution: { integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg== } + engines: { node: 6.* || 8.* || >= 10.* } get-intrinsic@1.2.7: - resolution: {integrity: sha512-VW6Pxhsrk0KAOqs3WEd0klDiF/+V7gQOpAvY1jVU/LHmaD/kQO4523aiJuikX/QAKYiW6x8Jh+RJej1almdtCA==} - engines: {node: '>= 0.4'} + resolution: { integrity: sha512-VW6Pxhsrk0KAOqs3WEd0klDiF/+V7gQOpAvY1jVU/LHmaD/kQO4523aiJuikX/QAKYiW6x8Jh+RJej1almdtCA== } + engines: { node: '>= 0.4' } get-package-type@0.1.0: - resolution: {integrity: sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==} - engines: {node: '>=8.0.0'} + resolution: { integrity: sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q== } + engines: { node: '>=8.0.0' } get-port@5.1.1: - resolution: {integrity: sha512-g/Q1aTSDOxFpchXC4i8ZWvxA1lnPqx/JHqcpIw0/LX9T8x/GBbi6YnlN5nhaKIFkT8oFsscUKgDJYxfwfS6QsQ==} - engines: {node: '>=8'} + resolution: { integrity: sha512-g/Q1aTSDOxFpchXC4i8ZWvxA1lnPqx/JHqcpIw0/LX9T8x/GBbi6YnlN5nhaKIFkT8oFsscUKgDJYxfwfS6QsQ== } + engines: { node: '>=8' } get-proto@1.0.1: - resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==} - engines: {node: '>= 0.4'} + resolution: { integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g== } + engines: { node: '>= 0.4' } get-stream@6.0.1: - resolution: {integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==} - engines: {node: '>=10'} + resolution: { integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg== } + engines: { node: '>=10' } get-tsconfig@4.10.0: - resolution: {integrity: sha512-kGzZ3LWWQcGIAmg6iWvXn0ei6WDtV26wzHRMwDSzmAbcXrTEXxHy6IehI6/4eT6VRKyMP1eF1VqwrVUmE/LR7A==} + resolution: { integrity: sha512-kGzZ3LWWQcGIAmg6iWvXn0ei6WDtV26wzHRMwDSzmAbcXrTEXxHy6IehI6/4eT6VRKyMP1eF1VqwrVUmE/LR7A== } github-from-package@0.0.0: - resolution: {integrity: sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw==} + resolution: { integrity: sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw== } glob-parent@5.1.2: - resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==} - engines: {node: '>= 6'} + resolution: { integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow== } + engines: { node: '>= 6' } glob@10.4.5: - resolution: {integrity: sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==} + resolution: { integrity: sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg== } hasBin: true glob@11.0.1: - resolution: {integrity: sha512-zrQDm8XPnYEKawJScsnM0QzobJxlT/kHOOlRTio8IH/GrmxRE5fjllkzdaHclIuNjUQTJYH2xHNIGfdpJkDJUw==} - engines: {node: 20 || >=22} + resolution: { integrity: sha512-zrQDm8XPnYEKawJScsnM0QzobJxlT/kHOOlRTio8IH/GrmxRE5fjllkzdaHclIuNjUQTJYH2xHNIGfdpJkDJUw== } + engines: { node: 20 || >=22 } hasBin: true glob@7.2.3: - resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==} + resolution: { integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q== } deprecated: Glob versions prior to v9 are no longer supported globals@11.12.0: - resolution: {integrity: sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==} - engines: {node: '>=4'} + resolution: { integrity: sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA== } + engines: { node: '>=4' } gopd@1.2.0: - resolution: {integrity: sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==} - engines: {node: '>= 0.4'} + resolution: { integrity: sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg== } + engines: { node: '>= 0.4' } graceful-fs@4.2.11: - resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==} + resolution: { integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ== } has-flag@4.0.0: - resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==} - engines: {node: '>=8'} + resolution: { integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ== } + engines: { node: '>=8' } has-symbols@1.1.0: - resolution: {integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==} - engines: {node: '>= 0.4'} + resolution: { integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ== } + engines: { node: '>= 0.4' } has-tostringtag@1.0.2: - resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==} - engines: {node: '>= 0.4'} + resolution: { integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw== } + engines: { node: '>= 0.4' } hasown@2.0.2: - resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==} - engines: {node: '>= 0.4'} + resolution: { integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ== } + engines: { node: '>= 0.4' } hexoid@2.0.0: - resolution: {integrity: sha512-qlspKUK7IlSQv2o+5I7yhUd7TxlOG2Vr5LTa3ve2XSNVKAL/n/u/7KLvKmFNimomDIKvZFXWHv0T12mv7rT8Aw==} - engines: {node: '>=8'} + resolution: { integrity: sha512-qlspKUK7IlSQv2o+5I7yhUd7TxlOG2Vr5LTa3ve2XSNVKAL/n/u/7KLvKmFNimomDIKvZFXWHv0T12mv7rT8Aw== } + engines: { node: '>=8' } html-escaper@2.0.2: - resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==} + resolution: { integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg== } http-assert@1.5.0: - resolution: {integrity: sha512-uPpH7OKX4H25hBmU6G1jWNaqJGpTXxey+YOUizJUAgu0AjLUeC8D73hTrhvDS5D+GJN1DN1+hhc/eF/wpxtp0w==} - engines: {node: '>= 0.8'} + resolution: { integrity: sha512-uPpH7OKX4H25hBmU6G1jWNaqJGpTXxey+YOUizJUAgu0AjLUeC8D73hTrhvDS5D+GJN1DN1+hhc/eF/wpxtp0w== } + engines: { node: '>= 0.8' } http-errors@1.8.1: - resolution: {integrity: sha512-Kpk9Sm7NmI+RHhnj6OIWDI1d6fIoFAtFt9RLaTMRlg/8w49juAStsrBgp0Dp4OdxdVbRIeKhtCUvoi/RuAhO4g==} - engines: {node: '>= 0.6'} + resolution: { integrity: sha512-Kpk9Sm7NmI+RHhnj6OIWDI1d6fIoFAtFt9RLaTMRlg/8w49juAStsrBgp0Dp4OdxdVbRIeKhtCUvoi/RuAhO4g== } + engines: { node: '>= 0.6' } http-errors@2.0.0: - resolution: {integrity: sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==} - engines: {node: '>= 0.8'} + resolution: { integrity: sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ== } + engines: { node: '>= 0.8' } human-signals@2.1.0: - resolution: {integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==} - engines: {node: '>=10.17.0'} + resolution: { integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw== } + engines: { node: '>=10.17.0' } husky@9.1.7: - resolution: {integrity: sha512-5gs5ytaNjBrh5Ow3zrvdUUY+0VxIuWVL4i9irt6friV+BqdCfmV11CQTWMiBYWHbXhco+J1kHfTOUkePhCDvMA==} - engines: {node: '>=18'} + resolution: { integrity: sha512-5gs5ytaNjBrh5Ow3zrvdUUY+0VxIuWVL4i9irt6friV+BqdCfmV11CQTWMiBYWHbXhco+J1kHfTOUkePhCDvMA== } + engines: { node: '>=18' } hasBin: true iconv-lite@0.4.24: - resolution: {integrity: sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==} - engines: {node: '>=0.10.0'} + resolution: { integrity: sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA== } + engines: { node: '>=0.10.0' } iconv-lite@0.6.3: - resolution: {integrity: sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==} - engines: {node: '>=0.10.0'} + resolution: { integrity: sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw== } + engines: { node: '>=0.10.0' } ieee754@1.2.1: - resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==} + resolution: { integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA== } import-local@3.1.0: - resolution: {integrity: sha512-ASB07uLtnDs1o6EHjKpX34BKYDSqnFerfTOJL2HvMqF70LnxpjkzDB8J44oT9pu4AMPkQwf8jl6szgvNd2tRIg==} - engines: {node: '>=8'} + resolution: { integrity: sha512-ASB07uLtnDs1o6EHjKpX34BKYDSqnFerfTOJL2HvMqF70LnxpjkzDB8J44oT9pu4AMPkQwf8jl6szgvNd2tRIg== } + engines: { node: '>=8' } hasBin: true imurmurhash@0.1.4: - resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==} - engines: {node: '>=0.8.19'} + resolution: { integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA== } + engines: { node: '>=0.8.19' } inflation@2.1.0: - resolution: {integrity: sha512-t54PPJHG1Pp7VQvxyVCJ9mBbjG3Hqryges9bXoOO6GExCPa+//i/d5GSuFtpx3ALLd7lgIAur6zrIlBQyJuMlQ==} - engines: {node: '>= 0.8.0'} + resolution: { integrity: sha512-t54PPJHG1Pp7VQvxyVCJ9mBbjG3Hqryges9bXoOO6GExCPa+//i/d5GSuFtpx3ALLd7lgIAur6zrIlBQyJuMlQ== } + engines: { node: '>= 0.8.0' } inflight@1.0.6: - resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==} + resolution: { integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA== } deprecated: This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful. inherits@2.0.4: - resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==} + resolution: { integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ== } ini@1.3.8: - resolution: {integrity: sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==} + resolution: { integrity: sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew== } ipaddr.js@1.9.1: - resolution: {integrity: sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==} - engines: {node: '>= 0.10'} + resolution: { integrity: sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g== } + engines: { node: '>= 0.10' } is-arrayish@0.2.1: - resolution: {integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==} + resolution: { integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg== } is-binary-path@2.1.0: - resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==} - engines: {node: '>=8'} + resolution: { integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw== } + engines: { node: '>=8' } is-core-module@2.16.1: - resolution: {integrity: sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==} - engines: {node: '>= 0.4'} + resolution: { integrity: sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w== } + engines: { node: '>= 0.4' } is-extglob@2.1.1: - resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==} - engines: {node: '>=0.10.0'} + resolution: { integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ== } + engines: { node: '>=0.10.0' } is-fullwidth-code-point@3.0.0: - resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==} - engines: {node: '>=8'} + resolution: { integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg== } + engines: { node: '>=8' } is-generator-fn@2.1.0: - resolution: {integrity: sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==} - engines: {node: '>=6'} + resolution: { integrity: sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ== } + engines: { node: '>=6' } is-generator-function@1.1.0: - resolution: {integrity: sha512-nPUB5km40q9e8UfN/Zc24eLlzdSf9OfKByBw9CIdw4H1giPMeA0OIJvbchsCu4npfI2QcMVBsGEBHKZ7wLTWmQ==} - engines: {node: '>= 0.4'} + resolution: { integrity: sha512-nPUB5km40q9e8UfN/Zc24eLlzdSf9OfKByBw9CIdw4H1giPMeA0OIJvbchsCu4npfI2QcMVBsGEBHKZ7wLTWmQ== } + engines: { node: '>= 0.4' } is-glob@4.0.3: - resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==} - engines: {node: '>=0.10.0'} + resolution: { integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg== } + engines: { node: '>=0.10.0' } is-number@7.0.0: - resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==} - engines: {node: '>=0.12.0'} + resolution: { integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng== } + engines: { node: '>=0.12.0' } is-regex@1.2.1: - resolution: {integrity: sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==} - engines: {node: '>= 0.4'} + resolution: { integrity: sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g== } + engines: { node: '>= 0.4' } is-stream@2.0.1: - resolution: {integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==} - engines: {node: '>=8'} + resolution: { integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg== } + engines: { node: '>=8' } isarray@1.0.0: - resolution: {integrity: sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==} + resolution: { integrity: sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ== } isexe@2.0.0: - resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==} + resolution: { integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw== } istanbul-lib-coverage@3.2.2: - resolution: {integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==} - engines: {node: '>=8'} + resolution: { integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg== } + engines: { node: '>=8' } istanbul-lib-instrument@5.2.1: - resolution: {integrity: sha512-pzqtp31nLv/XFOzXGuvhCb8qhjmTVo5vjVk19XE4CRlSWz0KoeJ3bw9XsA7nOp9YBf4qHjwBxkDzKcME/J29Yg==} - engines: {node: '>=8'} + resolution: { integrity: sha512-pzqtp31nLv/XFOzXGuvhCb8qhjmTVo5vjVk19XE4CRlSWz0KoeJ3bw9XsA7nOp9YBf4qHjwBxkDzKcME/J29Yg== } + engines: { node: '>=8' } istanbul-lib-instrument@6.0.3: - resolution: {integrity: sha512-Vtgk7L/R2JHyyGW07spoFlB8/lpjiOLTjMdms6AFMraYt3BaJauod/NGrfnVG/y4Ix1JEuMRPDPEj2ua+zz1/Q==} - engines: {node: '>=10'} + resolution: { integrity: sha512-Vtgk7L/R2JHyyGW07spoFlB8/lpjiOLTjMdms6AFMraYt3BaJauod/NGrfnVG/y4Ix1JEuMRPDPEj2ua+zz1/Q== } + engines: { node: '>=10' } istanbul-lib-report@3.0.1: - resolution: {integrity: sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==} - engines: {node: '>=10'} + resolution: { integrity: sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw== } + engines: { node: '>=10' } istanbul-lib-source-maps@4.0.1: - resolution: {integrity: sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==} - engines: {node: '>=10'} + resolution: { integrity: sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw== } + engines: { node: '>=10' } istanbul-reports@3.1.7: - resolution: {integrity: sha512-BewmUXImeuRk2YY0PVbxgKAysvhRPUQE0h5QRM++nVWyubKGV0l8qQ5op8+B2DOmwSe63Jivj0BjkPQVf8fP5g==} - engines: {node: '>=8'} + resolution: { integrity: sha512-BewmUXImeuRk2YY0PVbxgKAysvhRPUQE0h5QRM++nVWyubKGV0l8qQ5op8+B2DOmwSe63Jivj0BjkPQVf8fP5g== } + engines: { node: '>=8' } jackspeak@3.4.3: - resolution: {integrity: sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==} + resolution: { integrity: sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw== } jackspeak@4.1.0: - resolution: {integrity: sha512-9DDdhb5j6cpeitCbvLO7n7J4IxnbM6hoF6O1g4HQ5TfhvvKN8ywDM7668ZhMHRqVmxqhps/F6syWK2KcPxYlkw==} - engines: {node: 20 || >=22} + resolution: { integrity: sha512-9DDdhb5j6cpeitCbvLO7n7J4IxnbM6hoF6O1g4HQ5TfhvvKN8ywDM7668ZhMHRqVmxqhps/F6syWK2KcPxYlkw== } + engines: { node: 20 || >=22 } jake@10.9.2: - resolution: {integrity: sha512-2P4SQ0HrLQ+fw6llpLnOaGAvN2Zu6778SJMrCUwns4fOoG9ayrTiZk3VV8sCPkVZF8ab0zksVpS8FDY5pRCNBA==} - engines: {node: '>=10'} + resolution: { integrity: sha512-2P4SQ0HrLQ+fw6llpLnOaGAvN2Zu6778SJMrCUwns4fOoG9ayrTiZk3VV8sCPkVZF8ab0zksVpS8FDY5pRCNBA== } + engines: { node: '>=10' } hasBin: true jest-changed-files@29.7.0: - resolution: {integrity: sha512-fEArFiwf1BpQ+4bXSprcDc3/x4HSzL4al2tozwVpDFpsxALjLYdyiIK4e5Vz66GQJIbXJ82+35PtysofptNX2w==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-fEArFiwf1BpQ+4bXSprcDc3/x4HSzL4al2tozwVpDFpsxALjLYdyiIK4e5Vz66GQJIbXJ82+35PtysofptNX2w== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } jest-circus@29.7.0: - resolution: {integrity: sha512-3E1nCMgipcTkCocFwM90XXQab9bS+GMsjdpmPrlelaxwD93Ad8iVEjX/vvHPdLPnFf+L40u+5+iutRdA1N9myw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-3E1nCMgipcTkCocFwM90XXQab9bS+GMsjdpmPrlelaxwD93Ad8iVEjX/vvHPdLPnFf+L40u+5+iutRdA1N9myw== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } jest-cli@29.7.0: - resolution: {integrity: sha512-OVVobw2IubN/GSYsxETi+gOe7Ka59EFMR/twOU3Jb2GnKKeMGJB5SGUUrEz3SFVmJASUdZUzy83sLNNQ2gZslg==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-OVVobw2IubN/GSYsxETi+gOe7Ka59EFMR/twOU3Jb2GnKKeMGJB5SGUUrEz3SFVmJASUdZUzy83sLNNQ2gZslg== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } hasBin: true peerDependencies: node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0 @@ -1915,8 +1913,8 @@ packages: optional: true jest-config@29.7.0: - resolution: {integrity: sha512-uXbpfeQ7R6TZBqI3/TxCU4q4ttk3u0PJeC+E0zbfSoSjq6bJ7buBPxzQPL0ifrkY4DNu4JUdk0ImlBUYi840eQ==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-uXbpfeQ7R6TZBqI3/TxCU4q4ttk3u0PJeC+E0zbfSoSjq6bJ7buBPxzQPL0ifrkY4DNu4JUdk0ImlBUYi840eQ== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } peerDependencies: '@types/node': '*' ts-node: '>=9.0.0' @@ -1927,51 +1925,51 @@ packages: optional: true jest-diff@29.7.0: - resolution: {integrity: sha512-LMIgiIrhigmPrs03JHpxUh2yISK3vLFPkAodPeo0+BuF7wA2FoQbkEg1u8gBYBThncu7e1oEDUfIXVuTqLRUjw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-LMIgiIrhigmPrs03JHpxUh2yISK3vLFPkAodPeo0+BuF7wA2FoQbkEg1u8gBYBThncu7e1oEDUfIXVuTqLRUjw== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } jest-docblock@29.7.0: - resolution: {integrity: sha512-q617Auw3A612guyaFgsbFeYpNP5t2aoUNLwBUbc/0kD1R4t9ixDbyFTHd1nok4epoVFpr7PmeWHrhvuV3XaJ4g==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-q617Auw3A612guyaFgsbFeYpNP5t2aoUNLwBUbc/0kD1R4t9ixDbyFTHd1nok4epoVFpr7PmeWHrhvuV3XaJ4g== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } jest-each@29.7.0: - resolution: {integrity: sha512-gns+Er14+ZrEoC5fhOfYCY1LOHHr0TI+rQUHZS8Ttw2l7gl+80eHc/gFf2Ktkw0+SIACDTeWvpFcv3B04VembQ==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-gns+Er14+ZrEoC5fhOfYCY1LOHHr0TI+rQUHZS8Ttw2l7gl+80eHc/gFf2Ktkw0+SIACDTeWvpFcv3B04VembQ== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } jest-environment-node@29.7.0: - resolution: {integrity: sha512-DOSwCRqXirTOyheM+4d5YZOrWcdu0LNZ87ewUoywbcb2XR4wKgqiG8vNeYwhjFMbEkfju7wx2GYH0P2gevGvFw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-DOSwCRqXirTOyheM+4d5YZOrWcdu0LNZ87ewUoywbcb2XR4wKgqiG8vNeYwhjFMbEkfju7wx2GYH0P2gevGvFw== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } jest-fetch-mock@3.0.3: - resolution: {integrity: sha512-Ux1nWprtLrdrH4XwE7O7InRY6psIi3GOsqNESJgMJ+M5cv4A8Lh7SN9d2V2kKRZ8ebAfcd1LNyZguAOb6JiDqw==} + resolution: { integrity: sha512-Ux1nWprtLrdrH4XwE7O7InRY6psIi3GOsqNESJgMJ+M5cv4A8Lh7SN9d2V2kKRZ8ebAfcd1LNyZguAOb6JiDqw== } jest-get-type@29.6.3: - resolution: {integrity: sha512-zrteXnqYxfQh7l5FHyL38jL39di8H8rHoecLH3JNxH3BwOrBsNeabdap5e0I23lD4HHI8W5VFBZqG4Eaq5LNcw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-zrteXnqYxfQh7l5FHyL38jL39di8H8rHoecLH3JNxH3BwOrBsNeabdap5e0I23lD4HHI8W5VFBZqG4Eaq5LNcw== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } jest-haste-map@29.7.0: - resolution: {integrity: sha512-fP8u2pyfqx0K1rGn1R9pyE0/KTn+G7PxktWidOBTqFPLYX0b9ksaMFkhK5vrS3DVun09pckLdlx90QthlW7AmA==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-fP8u2pyfqx0K1rGn1R9pyE0/KTn+G7PxktWidOBTqFPLYX0b9ksaMFkhK5vrS3DVun09pckLdlx90QthlW7AmA== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } jest-leak-detector@29.7.0: - resolution: {integrity: sha512-kYA8IJcSYtST2BY9I+SMC32nDpBT3J2NvWJx8+JCuCdl/CR1I4EKUJROiP8XtCcxqgTTBGJNdbB1A8XRKbTetw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-kYA8IJcSYtST2BY9I+SMC32nDpBT3J2NvWJx8+JCuCdl/CR1I4EKUJROiP8XtCcxqgTTBGJNdbB1A8XRKbTetw== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } jest-matcher-utils@29.7.0: - resolution: {integrity: sha512-sBkD+Xi9DtcChsI3L3u0+N0opgPYnCRPtGcQYrgXmR+hmt/fYfWAL0xRXYU8eWOdfuLgBe0YCW3AFtnRLagq/g==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-sBkD+Xi9DtcChsI3L3u0+N0opgPYnCRPtGcQYrgXmR+hmt/fYfWAL0xRXYU8eWOdfuLgBe0YCW3AFtnRLagq/g== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } jest-message-util@29.7.0: - resolution: {integrity: sha512-GBEV4GRADeP+qtB2+6u61stea8mGcOT4mCtrYISZwfu9/ISHFJ/5zOMXYbpBE9RsS5+Gb63DW4FgmnKJ79Kf6w==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-GBEV4GRADeP+qtB2+6u61stea8mGcOT4mCtrYISZwfu9/ISHFJ/5zOMXYbpBE9RsS5+Gb63DW4FgmnKJ79Kf6w== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } jest-mock@29.7.0: - resolution: {integrity: sha512-ITOMZn+UkYS4ZFh83xYAOzWStloNzJFO2s8DWrE4lhtGD+AorgnbkiKERe4wQVBydIGPx059g6riW5Btp6Llnw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-ITOMZn+UkYS4ZFh83xYAOzWStloNzJFO2s8DWrE4lhtGD+AorgnbkiKERe4wQVBydIGPx059g6riW5Btp6Llnw== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } jest-pnp-resolver@1.2.3: - resolution: {integrity: sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w==} - engines: {node: '>=6'} + resolution: { integrity: sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w== } + engines: { node: '>=6' } peerDependencies: jest-resolve: '*' peerDependenciesMeta: @@ -1979,48 +1977,48 @@ packages: optional: true jest-regex-util@29.6.3: - resolution: {integrity: sha512-KJJBsRCyyLNWCNBOvZyRDnAIfUiRJ8v+hOBQYGn8gDyF3UegwiP4gwRR3/SDa42g1YbVycTidUF3rKjyLFDWbg==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-KJJBsRCyyLNWCNBOvZyRDnAIfUiRJ8v+hOBQYGn8gDyF3UegwiP4gwRR3/SDa42g1YbVycTidUF3rKjyLFDWbg== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } jest-resolve-dependencies@29.7.0: - resolution: {integrity: sha512-un0zD/6qxJ+S0et7WxeI3H5XSe9lTBBR7bOHCHXkKR6luG5mwDDlIzVQ0V5cZCuoTgEdcdwzTghYkTWfubi+nA==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-un0zD/6qxJ+S0et7WxeI3H5XSe9lTBBR7bOHCHXkKR6luG5mwDDlIzVQ0V5cZCuoTgEdcdwzTghYkTWfubi+nA== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } jest-resolve@29.7.0: - resolution: {integrity: sha512-IOVhZSrg+UvVAshDSDtHyFCCBUl/Q3AAJv8iZ6ZjnZ74xzvwuzLXid9IIIPgTnY62SJjfuupMKZsZQRsCvxEgA==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-IOVhZSrg+UvVAshDSDtHyFCCBUl/Q3AAJv8iZ6ZjnZ74xzvwuzLXid9IIIPgTnY62SJjfuupMKZsZQRsCvxEgA== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } jest-runner@29.7.0: - resolution: {integrity: sha512-fsc4N6cPCAahybGBfTRcq5wFR6fpLznMg47sY5aDpsoejOcVYFb07AHuSnR0liMcPTgBsA3ZJL6kFOjPdoNipQ==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-fsc4N6cPCAahybGBfTRcq5wFR6fpLznMg47sY5aDpsoejOcVYFb07AHuSnR0liMcPTgBsA3ZJL6kFOjPdoNipQ== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } jest-runtime@29.7.0: - resolution: {integrity: sha512-gUnLjgwdGqW7B4LvOIkbKs9WGbn+QLqRQQ9juC6HndeDiezIwhDP+mhMwHWCEcfQ5RUXa6OPnFF8BJh5xegwwQ==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-gUnLjgwdGqW7B4LvOIkbKs9WGbn+QLqRQQ9juC6HndeDiezIwhDP+mhMwHWCEcfQ5RUXa6OPnFF8BJh5xegwwQ== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } jest-snapshot@29.7.0: - resolution: {integrity: sha512-Rm0BMWtxBcioHr1/OX5YCP8Uov4riHvKPknOGs804Zg9JGZgmIBkbtlxJC/7Z4msKYVbIJtfU+tKb8xlYNfdkw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-Rm0BMWtxBcioHr1/OX5YCP8Uov4riHvKPknOGs804Zg9JGZgmIBkbtlxJC/7Z4msKYVbIJtfU+tKb8xlYNfdkw== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } jest-util@29.7.0: - resolution: {integrity: sha512-z6EbKajIpqGKU56y5KBUgy1dt1ihhQJgWzUlZHArA/+X2ad7Cb5iF+AK1EWVL/Bo7Rz9uurpqw6SiBCefUbCGA==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-z6EbKajIpqGKU56y5KBUgy1dt1ihhQJgWzUlZHArA/+X2ad7Cb5iF+AK1EWVL/Bo7Rz9uurpqw6SiBCefUbCGA== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } jest-validate@29.7.0: - resolution: {integrity: sha512-ZB7wHqaRGVw/9hST/OuFUReG7M8vKeq0/J2egIGLdvjHCmYqGARhzXmtgi+gVeZ5uXFF219aOc3Ls2yLg27tkw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-ZB7wHqaRGVw/9hST/OuFUReG7M8vKeq0/J2egIGLdvjHCmYqGARhzXmtgi+gVeZ5uXFF219aOc3Ls2yLg27tkw== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } jest-watcher@29.7.0: - resolution: {integrity: sha512-49Fg7WXkU3Vl2h6LbLtMQ/HyB6rXSIX7SqvBLQmssRBGN9I0PNvPmAmCWSOY6SOvrjhI/F7/bGAv9RtnsPA03g==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-49Fg7WXkU3Vl2h6LbLtMQ/HyB6rXSIX7SqvBLQmssRBGN9I0PNvPmAmCWSOY6SOvrjhI/F7/bGAv9RtnsPA03g== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } jest-worker@29.7.0: - resolution: {integrity: sha512-eIz2msL/EzL9UFTFFx7jBTkeZfku0yUAyZZZmJ93H2TYEiroIx2PQjEXcwYtYl8zXCxb+PAmA2hLIt/6ZEkPHw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-eIz2msL/EzL9UFTFFx7jBTkeZfku0yUAyZZZmJ93H2TYEiroIx2PQjEXcwYtYl8zXCxb+PAmA2hLIt/6ZEkPHw== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } jest@29.7.0: - resolution: {integrity: sha512-NIy3oAFp9shda19hy4HK0HRTWKtPJmGdnvywu01nOqNC2vZg+Z+fvJDxpMQA88eb2I9EcafcdjYgsDthnYTvGw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-NIy3oAFp9shda19hy4HK0HRTWKtPJmGdnvywu01nOqNC2vZg+Z+fvJDxpMQA88eb2I9EcafcdjYgsDthnYTvGw== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } hasBin: true peerDependencies: node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0 @@ -2029,209 +2027,209 @@ packages: optional: true js-tokens@4.0.0: - resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==} + resolution: { integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ== } js-yaml@3.14.1: - resolution: {integrity: sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==} + resolution: { integrity: sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g== } hasBin: true jsesc@3.1.0: - resolution: {integrity: sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==} - engines: {node: '>=6'} + resolution: { integrity: sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA== } + engines: { node: '>=6' } hasBin: true json-parse-even-better-errors@2.3.1: - resolution: {integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==} + resolution: { integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w== } json5@2.2.3: - resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==} - engines: {node: '>=6'} + resolution: { integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg== } + engines: { node: '>=6' } hasBin: true keygrip@1.1.0: - resolution: {integrity: sha512-iYSchDJ+liQ8iwbSI2QqsQOvqv58eJCEanyJPJi+Khyu8smkcKSFUCbPwzFcL7YVtZ6eONjqRX/38caJ7QjRAQ==} - engines: {node: '>= 0.6'} + resolution: { integrity: sha512-iYSchDJ+liQ8iwbSI2QqsQOvqv58eJCEanyJPJi+Khyu8smkcKSFUCbPwzFcL7YVtZ6eONjqRX/38caJ7QjRAQ== } + engines: { node: '>= 0.6' } kleur@3.0.3: - resolution: {integrity: sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==} - engines: {node: '>=6'} + resolution: { integrity: sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w== } + engines: { node: '>=6' } koa-bodyparser@4.4.1: - resolution: {integrity: sha512-kBH3IYPMb+iAXnrxIhXnW+gXV8OTzCu8VPDqvcDHW9SQrbkHmqPQtiZwrltNmSq6/lpipHnT7k7PsjlVD7kK0w==} - engines: {node: '>=8.0.0'} + resolution: { integrity: sha512-kBH3IYPMb+iAXnrxIhXnW+gXV8OTzCu8VPDqvcDHW9SQrbkHmqPQtiZwrltNmSq6/lpipHnT7k7PsjlVD7kK0w== } + engines: { node: '>=8.0.0' } koa-compose@4.1.0: - resolution: {integrity: sha512-8ODW8TrDuMYvXRwra/Kh7/rJo9BtOfPc6qO8eAfC80CnCvSjSl0bkRM24X6/XBBEyj0v1nRUQ1LyOy3dbqOWXw==} + resolution: { integrity: sha512-8ODW8TrDuMYvXRwra/Kh7/rJo9BtOfPc6qO8eAfC80CnCvSjSl0bkRM24X6/XBBEyj0v1nRUQ1LyOy3dbqOWXw== } koa-convert@2.0.0: - resolution: {integrity: sha512-asOvN6bFlSnxewce2e/DK3p4tltyfC4VM7ZwuTuepI7dEQVcvpyFuBcEARu1+Hxg8DIwytce2n7jrZtRlPrARA==} - engines: {node: '>= 10'} + resolution: { integrity: sha512-asOvN6bFlSnxewce2e/DK3p4tltyfC4VM7ZwuTuepI7dEQVcvpyFuBcEARu1+Hxg8DIwytce2n7jrZtRlPrARA== } + engines: { node: '>= 10' } koa@2.15.4: - resolution: {integrity: sha512-7fNBIdrU2PEgLljXoPWoyY4r1e+ToWCmzS/wwMPbUNs7X+5MMET1ObhJBlUkF5uZG9B6QhM2zS1TsH6adegkiQ==} - engines: {node: ^4.8.4 || ^6.10.1 || ^7.10.1 || >= 8.1.4} + resolution: { integrity: sha512-7fNBIdrU2PEgLljXoPWoyY4r1e+ToWCmzS/wwMPbUNs7X+5MMET1ObhJBlUkF5uZG9B6QhM2zS1TsH6adegkiQ== } + engines: { node: ^4.8.4 || ^6.10.1 || ^7.10.1 || >= 8.1.4 } lazystream@1.0.1: - resolution: {integrity: sha512-b94GiNHQNy6JNTrt5w6zNyffMrNkXZb3KTkCZJb2V1xaEGCk093vkZ2jk3tpaeP33/OiXC+WvK9AxUebnf5nbw==} - engines: {node: '>= 0.6.3'} + resolution: { integrity: sha512-b94GiNHQNy6JNTrt5w6zNyffMrNkXZb3KTkCZJb2V1xaEGCk093vkZ2jk3tpaeP33/OiXC+WvK9AxUebnf5nbw== } + engines: { node: '>= 0.6.3' } leven@3.1.0: - resolution: {integrity: sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==} - engines: {node: '>=6'} + resolution: { integrity: sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A== } + engines: { node: '>=6' } libphonenumber-js@1.11.19: - resolution: {integrity: sha512-bW/Yp/9dod6fmyR+XqSUL1N5JE7QRxQ3KrBIbYS1FTv32e5i3SEtQVX+71CYNv8maWNSOgnlCoNp9X78f/cKiA==} + resolution: { integrity: sha512-bW/Yp/9dod6fmyR+XqSUL1N5JE7QRxQ3KrBIbYS1FTv32e5i3SEtQVX+71CYNv8maWNSOgnlCoNp9X78f/cKiA== } lines-and-columns@1.2.4: - resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==} + resolution: { integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg== } locate-path@5.0.0: - resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==} - engines: {node: '>=8'} + resolution: { integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g== } + engines: { node: '>=8' } lodash.memoize@4.1.2: - resolution: {integrity: sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==} + resolution: { integrity: sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag== } lodash@4.17.21: - resolution: {integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==} + resolution: { integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg== } lru-cache@10.4.3: - resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==} + resolution: { integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ== } lru-cache@11.0.2: - resolution: {integrity: sha512-123qHRfJBmo2jXDbo/a5YOQrJoHF/GNQTLzQ5+IdK5pWpceK17yRc6ozlWd25FxvGKQbIUs91fDFkXmDHTKcyA==} - engines: {node: 20 || >=22} + resolution: { integrity: sha512-123qHRfJBmo2jXDbo/a5YOQrJoHF/GNQTLzQ5+IdK5pWpceK17yRc6ozlWd25FxvGKQbIUs91fDFkXmDHTKcyA== } + engines: { node: 20 || >=22 } lru-cache@5.1.1: - resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==} + resolution: { integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w== } make-dir@4.0.0: - resolution: {integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==} - engines: {node: '>=10'} + resolution: { integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw== } + engines: { node: '>=10' } make-error@1.3.6: - resolution: {integrity: sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==} + resolution: { integrity: sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw== } makeerror@1.0.12: - resolution: {integrity: sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg==} + resolution: { integrity: sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg== } math-intrinsics@1.1.0: - resolution: {integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==} - engines: {node: '>= 0.4'} + resolution: { integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g== } + engines: { node: '>= 0.4' } media-typer@0.3.0: - resolution: {integrity: sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==} - engines: {node: '>= 0.6'} + resolution: { integrity: sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ== } + engines: { node: '>= 0.6' } merge-descriptors@1.0.3: - resolution: {integrity: sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==} + resolution: { integrity: sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ== } merge-stream@2.0.0: - resolution: {integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==} + resolution: { integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w== } methods@1.1.2: - resolution: {integrity: sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==} - engines: {node: '>= 0.6'} + resolution: { integrity: sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w== } + engines: { node: '>= 0.6' } micromatch@4.0.8: - resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==} - engines: {node: '>=8.6'} + resolution: { integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA== } + engines: { node: '>=8.6' } mime-db@1.52.0: - resolution: {integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==} - engines: {node: '>= 0.6'} + resolution: { integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg== } + engines: { node: '>= 0.6' } mime-types@2.1.35: - resolution: {integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==} - engines: {node: '>= 0.6'} + resolution: { integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw== } + engines: { node: '>= 0.6' } mime@1.6.0: - resolution: {integrity: sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==} - engines: {node: '>=4'} + resolution: { integrity: sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg== } + engines: { node: '>=4' } hasBin: true mime@2.6.0: - resolution: {integrity: sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg==} - engines: {node: '>=4.0.0'} + resolution: { integrity: sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg== } + engines: { node: '>=4.0.0' } hasBin: true mimic-fn@2.1.0: - resolution: {integrity: sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==} - engines: {node: '>=6'} + resolution: { integrity: sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg== } + engines: { node: '>=6' } mimic-response@3.1.0: - resolution: {integrity: sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==} - engines: {node: '>=10'} + resolution: { integrity: sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ== } + engines: { node: '>=10' } minimatch@10.0.1: - resolution: {integrity: sha512-ethXTt3SGGR+95gudmqJ1eNhRO7eGEGIgYA9vnPatK4/etz2MEVDno5GMCibdMTuBMyElzIlgxMna3K94XDIDQ==} - engines: {node: 20 || >=22} + resolution: { integrity: sha512-ethXTt3SGGR+95gudmqJ1eNhRO7eGEGIgYA9vnPatK4/etz2MEVDno5GMCibdMTuBMyElzIlgxMna3K94XDIDQ== } + engines: { node: 20 || >=22 } minimatch@3.1.2: - resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==} + resolution: { integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw== } minimatch@5.1.6: - resolution: {integrity: sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==} - engines: {node: '>=10'} + resolution: { integrity: sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g== } + engines: { node: '>=10' } minimatch@9.0.5: - resolution: {integrity: sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==} - engines: {node: '>=16 || 14 >=14.17'} + resolution: { integrity: sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow== } + engines: { node: '>=16 || 14 >=14.17' } minimist@1.2.8: - resolution: {integrity: sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==} + resolution: { integrity: sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA== } minipass@7.1.2: - resolution: {integrity: sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==} - engines: {node: '>=16 || 14 >=14.17'} + resolution: { integrity: sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw== } + engines: { node: '>=16 || 14 >=14.17' } mkdirp-classic@0.5.3: - resolution: {integrity: sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==} + resolution: { integrity: sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A== } mkdirp@0.5.6: - resolution: {integrity: sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==} + resolution: { integrity: sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw== } hasBin: true mkdirp@1.0.4: - resolution: {integrity: sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==} - engines: {node: '>=10'} + resolution: { integrity: sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw== } + engines: { node: '>=10' } hasBin: true ms@2.0.0: - resolution: {integrity: sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==} + resolution: { integrity: sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A== } ms@2.1.3: - resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==} + resolution: { integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA== } multer@1.4.5-lts.1: - resolution: {integrity: sha512-ywPWvcDMeH+z9gQq5qYHCCy+ethsk4goepZ45GLD63fOu0YcNecQxi64nDs3qluZB+murG3/D4dJ7+dGctcCQQ==} - engines: {node: '>= 6.0.0'} + resolution: { integrity: sha512-ywPWvcDMeH+z9gQq5qYHCCy+ethsk4goepZ45GLD63fOu0YcNecQxi64nDs3qluZB+murG3/D4dJ7+dGctcCQQ== } + engines: { node: '>= 6.0.0' } nan@2.22.1: - resolution: {integrity: sha512-pfRR4ZcNTSm2ZFHaztuvbICf+hyiG6ecA06SfAxoPmuHjvMu0KUIae7Y8GyVkbBqeEIidsmXeYooWIX9+qjfRQ==} + resolution: { integrity: sha512-pfRR4ZcNTSm2ZFHaztuvbICf+hyiG6ecA06SfAxoPmuHjvMu0KUIae7Y8GyVkbBqeEIidsmXeYooWIX9+qjfRQ== } nanoid@3.3.6: - resolution: {integrity: sha512-BGcqMMJuToF7i1rt+2PWSNVnWIkGCU78jBG3RxO/bZlnZPK2Cmi2QaffxGO/2RvWi9sL+FAiRiXMgsyxQ1DIDA==} - engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1} + resolution: { integrity: sha512-BGcqMMJuToF7i1rt+2PWSNVnWIkGCU78jBG3RxO/bZlnZPK2Cmi2QaffxGO/2RvWi9sL+FAiRiXMgsyxQ1DIDA== } + engines: { node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1 } hasBin: true napi-build-utils@2.0.0: - resolution: {integrity: sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA==} + resolution: { integrity: sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA== } natural-compare@1.4.0: - resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==} + resolution: { integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw== } negotiator@0.6.3: - resolution: {integrity: sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==} - engines: {node: '>= 0.6'} + resolution: { integrity: sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg== } + engines: { node: '>= 0.6' } node-abi@3.74.0: - resolution: {integrity: sha512-c5XK0MjkGBrQPGYG24GBADZud0NCbznxNx0ZkS+ebUTrmV1qTDxPxSL8zEAPURXSbLRWVexxmP4986BziahL5w==} - engines: {node: '>=10'} + resolution: { integrity: sha512-c5XK0MjkGBrQPGYG24GBADZud0NCbznxNx0ZkS+ebUTrmV1qTDxPxSL8zEAPURXSbLRWVexxmP4986BziahL5w== } + engines: { node: '>=10' } node-fetch@2.7.0: - resolution: {integrity: sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==} - engines: {node: 4.x || >=6.0.0} + resolution: { integrity: sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A== } + engines: { node: 4.x || >=6.0.0 } peerDependencies: encoding: ^0.1.0 peerDependenciesMeta: @@ -2239,140 +2237,140 @@ packages: optional: true node-int64@0.4.0: - resolution: {integrity: sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw==} + resolution: { integrity: sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw== } node-releases@2.0.19: - resolution: {integrity: sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw==} + resolution: { integrity: sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw== } normalize-path@3.0.0: - resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==} - engines: {node: '>=0.10.0'} + resolution: { integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA== } + engines: { node: '>=0.10.0' } npm-run-path@4.0.1: - resolution: {integrity: sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==} - engines: {node: '>=8'} + resolution: { integrity: sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw== } + engines: { node: '>=8' } object-assign@4.1.1: - resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==} - engines: {node: '>=0.10.0'} + resolution: { integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg== } + engines: { node: '>=0.10.0' } object-inspect@1.13.3: - resolution: {integrity: sha512-kDCGIbxkDSXE3euJZZXzc6to7fCrKHNI/hSRQnRuQ+BWjFNzZwiFF8fj/6o2t2G9/jTj8PSIYTfCLelLZEeRpA==} - engines: {node: '>= 0.4'} + resolution: { integrity: sha512-kDCGIbxkDSXE3euJZZXzc6to7fCrKHNI/hSRQnRuQ+BWjFNzZwiFF8fj/6o2t2G9/jTj8PSIYTfCLelLZEeRpA== } + engines: { node: '>= 0.4' } obuf@1.1.2: - resolution: {integrity: sha512-PX1wu0AmAdPqOL1mWhqmlOd8kOIZQwGZw6rh7uby9fTc5lhaOWFLX3I6R1hrF9k3zUY40e6igsLGkDXK92LJNg==} + resolution: { integrity: sha512-PX1wu0AmAdPqOL1mWhqmlOd8kOIZQwGZw6rh7uby9fTc5lhaOWFLX3I6R1hrF9k3zUY40e6igsLGkDXK92LJNg== } on-finished@2.4.1: - resolution: {integrity: sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==} - engines: {node: '>= 0.8'} + resolution: { integrity: sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg== } + engines: { node: '>= 0.8' } on-headers@1.0.2: - resolution: {integrity: sha512-pZAE+FJLoyITytdqK0U5s+FIpjN0JP3OzFi/u8Rx+EV5/W+JTWGXG8xFzevE7AjBfDqHv/8vL8qQsIhHnqRkrA==} - engines: {node: '>= 0.8'} + resolution: { integrity: sha512-pZAE+FJLoyITytdqK0U5s+FIpjN0JP3OzFi/u8Rx+EV5/W+JTWGXG8xFzevE7AjBfDqHv/8vL8qQsIhHnqRkrA== } + engines: { node: '>= 0.8' } once@1.4.0: - resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==} + resolution: { integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w== } onetime@5.1.2: - resolution: {integrity: sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==} - engines: {node: '>=6'} + resolution: { integrity: sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg== } + engines: { node: '>=6' } only@0.0.2: - resolution: {integrity: sha512-Fvw+Jemq5fjjyWz6CpKx6w9s7xxqo3+JCyM0WXWeCSOboZ8ABkyvP8ID4CZuChA/wxSx+XSJmdOm8rGVyJ1hdQ==} + resolution: { integrity: sha512-Fvw+Jemq5fjjyWz6CpKx6w9s7xxqo3+JCyM0WXWeCSOboZ8ABkyvP8ID4CZuChA/wxSx+XSJmdOm8rGVyJ1hdQ== } p-limit@2.3.0: - resolution: {integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==} - engines: {node: '>=6'} + resolution: { integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w== } + engines: { node: '>=6' } p-limit@3.1.0: - resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==} - engines: {node: '>=10'} + resolution: { integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ== } + engines: { node: '>=10' } p-locate@4.1.0: - resolution: {integrity: sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==} - engines: {node: '>=8'} + resolution: { integrity: sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A== } + engines: { node: '>=8' } p-try@2.2.0: - resolution: {integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==} - engines: {node: '>=6'} + resolution: { integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ== } + engines: { node: '>=6' } package-json-from-dist@1.0.1: - resolution: {integrity: sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==} + resolution: { integrity: sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw== } parse-json@5.2.0: - resolution: {integrity: sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==} - engines: {node: '>=8'} + resolution: { integrity: sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg== } + engines: { node: '>=8' } parseurl@1.3.3: - resolution: {integrity: sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==} - engines: {node: '>= 0.8'} + resolution: { integrity: sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ== } + engines: { node: '>= 0.8' } path-exists@4.0.0: - resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==} - engines: {node: '>=8'} + resolution: { integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w== } + engines: { node: '>=8' } path-is-absolute@1.0.1: - resolution: {integrity: sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==} - engines: {node: '>=0.10.0'} + resolution: { integrity: sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg== } + engines: { node: '>=0.10.0' } path-key@3.1.1: - resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==} - engines: {node: '>=8'} + resolution: { integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q== } + engines: { node: '>=8' } path-parse@1.0.7: - resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==} + resolution: { integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw== } path-scurry@1.11.1: - resolution: {integrity: sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==} - engines: {node: '>=16 || 14 >=14.18'} + resolution: { integrity: sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA== } + engines: { node: '>=16 || 14 >=14.18' } path-scurry@2.0.0: - resolution: {integrity: sha512-ypGJsmGtdXUOeM5u93TyeIEfEhM6s+ljAhrk5vAvSx8uyY/02OvrZnA0YNGUrPXfpJMgI1ODd3nwz8Npx4O4cg==} - engines: {node: 20 || >=22} + resolution: { integrity: sha512-ypGJsmGtdXUOeM5u93TyeIEfEhM6s+ljAhrk5vAvSx8uyY/02OvrZnA0YNGUrPXfpJMgI1ODd3nwz8Npx4O4cg== } + engines: { node: 20 || >=22 } path-to-regexp@0.1.12: - resolution: {integrity: sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==} + resolution: { integrity: sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ== } path-to-regexp@6.3.0: - resolution: {integrity: sha512-Yhpw4T9C6hPpgPeA28us07OJeqZ5EzQTkbfwuhsUg0c237RomFoETJgmp2sa3F/41gfLE6G5cqcYwznmeEeOlQ==} + resolution: { integrity: sha512-Yhpw4T9C6hPpgPeA28us07OJeqZ5EzQTkbfwuhsUg0c237RomFoETJgmp2sa3F/41gfLE6G5cqcYwznmeEeOlQ== } pg-cloudflare@1.1.1: - resolution: {integrity: sha512-xWPagP/4B6BgFO+EKz3JONXv3YDgvkbVrGw2mTo3D6tVDQRh1e7cqVGvyR3BE+eQgAvx1XhW/iEASj4/jCWl3Q==} + resolution: { integrity: sha512-xWPagP/4B6BgFO+EKz3JONXv3YDgvkbVrGw2mTo3D6tVDQRh1e7cqVGvyR3BE+eQgAvx1XhW/iEASj4/jCWl3Q== } pg-connection-string@2.7.0: - resolution: {integrity: sha512-PI2W9mv53rXJQEOb8xNR8lH7Hr+EKa6oJa38zsK0S/ky2er16ios1wLKhZyxzD7jUReiWokc9WK5nxSnC7W1TA==} + resolution: { integrity: sha512-PI2W9mv53rXJQEOb8xNR8lH7Hr+EKa6oJa38zsK0S/ky2er16ios1wLKhZyxzD7jUReiWokc9WK5nxSnC7W1TA== } pg-int8@1.0.1: - resolution: {integrity: sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw==} - engines: {node: '>=4.0.0'} + resolution: { integrity: sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw== } + engines: { node: '>=4.0.0' } pg-numeric@1.0.2: - resolution: {integrity: sha512-BM/Thnrw5jm2kKLE5uJkXqqExRUY/toLHda65XgFTBTFYZyopbKjBe29Ii3RbkvlsMoFwD+tHeGaCjjv0gHlyw==} - engines: {node: '>=4'} + resolution: { integrity: sha512-BM/Thnrw5jm2kKLE5uJkXqqExRUY/toLHda65XgFTBTFYZyopbKjBe29Ii3RbkvlsMoFwD+tHeGaCjjv0gHlyw== } + engines: { node: '>=4' } pg-pool@3.8.0: - resolution: {integrity: sha512-VBw3jiVm6ZOdLBTIcXLNdSotb6Iy3uOCwDGFAksZCXmi10nyRvnP2v3jl4d+IsLYRyXf6o9hIm/ZtUzlByNUdw==} + resolution: { integrity: sha512-VBw3jiVm6ZOdLBTIcXLNdSotb6Iy3uOCwDGFAksZCXmi10nyRvnP2v3jl4d+IsLYRyXf6o9hIm/ZtUzlByNUdw== } peerDependencies: pg: '>=8.0' pg-protocol@1.7.0: - resolution: {integrity: sha512-hTK/mE36i8fDDhgDFjy6xNOG+LCorxLG3WO17tku+ij6sVHXh1jQUJ8hYAnRhNla4QVD2H8er/FOjc/+EgC6yQ==} + resolution: { integrity: sha512-hTK/mE36i8fDDhgDFjy6xNOG+LCorxLG3WO17tku+ij6sVHXh1jQUJ8hYAnRhNla4QVD2H8er/FOjc/+EgC6yQ== } pg-protocol@1.8.0: - resolution: {integrity: sha512-jvuYlEkL03NRvOoyoRktBK7+qU5kOvlAwvmrH8sr3wbLrOdVWsRxQfz8mMy9sZFsqJ1hEWNfdWKI4SAmoL+j7g==} + resolution: { integrity: sha512-jvuYlEkL03NRvOoyoRktBK7+qU5kOvlAwvmrH8sr3wbLrOdVWsRxQfz8mMy9sZFsqJ1hEWNfdWKI4SAmoL+j7g== } pg-types@2.2.0: - resolution: {integrity: sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA==} - engines: {node: '>=4'} + resolution: { integrity: sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA== } + engines: { node: '>=4' } pg-types@4.0.2: - resolution: {integrity: sha512-cRL3JpS3lKMGsKaWndugWQoLOCoP+Cic8oseVcbr0qhPzYD5DWXK+RZ9LY9wxRf7RQia4SCwQlXk0q6FCPrVng==} - engines: {node: '>=10'} + resolution: { integrity: sha512-cRL3JpS3lKMGsKaWndugWQoLOCoP+Cic8oseVcbr0qhPzYD5DWXK+RZ9LY9wxRf7RQia4SCwQlXk0q6FCPrVng== } + engines: { node: '>=10' } pg@8.14.0: - resolution: {integrity: sha512-nXbVpyoaXVmdqlKEzToFf37qzyeeh7mbiXsnoWvstSqohj88yaa/I/Rq/HEVn2QPSZEuLIJa/jSpRDyzjEx4FQ==} - engines: {node: '>= 8.0.0'} + resolution: { integrity: sha512-nXbVpyoaXVmdqlKEzToFf37qzyeeh7mbiXsnoWvstSqohj88yaa/I/Rq/HEVn2QPSZEuLIJa/jSpRDyzjEx4FQ== } + engines: { node: '>= 8.0.0' } peerDependencies: pg-native: '>=3.0.1' peerDependenciesMeta: @@ -2380,443 +2378,443 @@ packages: optional: true pgpass@1.0.5: - resolution: {integrity: sha512-FdW9r/jQZhSeohs1Z3sI1yxFQNFvMcnmfuj4WBMUTxOrAyLMaTcE1aAMBiTlbMNaXvBCQuVi0R7hd8udDSP7ug==} + resolution: { integrity: sha512-FdW9r/jQZhSeohs1Z3sI1yxFQNFvMcnmfuj4WBMUTxOrAyLMaTcE1aAMBiTlbMNaXvBCQuVi0R7hd8udDSP7ug== } picocolors@1.1.1: - resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==} + resolution: { integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA== } picomatch@2.3.1: - resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==} - engines: {node: '>=8.6'} + resolution: { integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA== } + engines: { node: '>=8.6' } pirates@4.0.6: - resolution: {integrity: sha512-saLsH7WeYYPiD25LDuLRRY/i+6HaPYr6G1OUlN39otzkSTxKnubR9RTxS3/Kk50s1g2JTgFwWQDQyplC5/SHZg==} - engines: {node: '>= 6'} + resolution: { integrity: sha512-saLsH7WeYYPiD25LDuLRRY/i+6HaPYr6G1OUlN39otzkSTxKnubR9RTxS3/Kk50s1g2JTgFwWQDQyplC5/SHZg== } + engines: { node: '>= 6' } pkg-dir@4.2.0: - resolution: {integrity: sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==} - engines: {node: '>=8'} + resolution: { integrity: sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ== } + engines: { node: '>=8' } postgres-array@2.0.0: - resolution: {integrity: sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA==} - engines: {node: '>=4'} + resolution: { integrity: sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA== } + engines: { node: '>=4' } postgres-array@3.0.2: - resolution: {integrity: sha512-6faShkdFugNQCLwucjPcY5ARoW1SlbnrZjmGl0IrrqewpvxvhSLHimCVzqeuULCbG0fQv7Dtk1yDbG3xv7Veog==} - engines: {node: '>=12'} + resolution: { integrity: sha512-6faShkdFugNQCLwucjPcY5ARoW1SlbnrZjmGl0IrrqewpvxvhSLHimCVzqeuULCbG0fQv7Dtk1yDbG3xv7Veog== } + engines: { node: '>=12' } postgres-bytea@1.0.0: - resolution: {integrity: sha512-xy3pmLuQqRBZBXDULy7KbaitYqLcmxigw14Q5sj8QBVLqEwXfeybIKVWiqAXTlcvdvb0+xkOtDbfQMOf4lST1w==} - engines: {node: '>=0.10.0'} + resolution: { integrity: sha512-xy3pmLuQqRBZBXDULy7KbaitYqLcmxigw14Q5sj8QBVLqEwXfeybIKVWiqAXTlcvdvb0+xkOtDbfQMOf4lST1w== } + engines: { node: '>=0.10.0' } postgres-bytea@3.0.0: - resolution: {integrity: sha512-CNd4jim9RFPkObHSjVHlVrxoVQXz7quwNFpz7RY1okNNme49+sVyiTvTRobiLV548Hx/hb1BG+iE7h9493WzFw==} - engines: {node: '>= 6'} + resolution: { integrity: sha512-CNd4jim9RFPkObHSjVHlVrxoVQXz7quwNFpz7RY1okNNme49+sVyiTvTRobiLV548Hx/hb1BG+iE7h9493WzFw== } + engines: { node: '>= 6' } postgres-date@1.0.7: - resolution: {integrity: sha512-suDmjLVQg78nMK2UZ454hAG+OAW+HQPZ6n++TNDUX+L0+uUlLywnoxJKDou51Zm+zTCjrCl0Nq6J9C5hP9vK/Q==} - engines: {node: '>=0.10.0'} + resolution: { integrity: sha512-suDmjLVQg78nMK2UZ454hAG+OAW+HQPZ6n++TNDUX+L0+uUlLywnoxJKDou51Zm+zTCjrCl0Nq6J9C5hP9vK/Q== } + engines: { node: '>=0.10.0' } postgres-date@2.1.0: - resolution: {integrity: sha512-K7Juri8gtgXVcDfZttFKVmhglp7epKb1K4pgrkLxehjqkrgPhfG6OO8LHLkfaqkbpjNRnra018XwAr1yQFWGcA==} - engines: {node: '>=12'} + resolution: { integrity: sha512-K7Juri8gtgXVcDfZttFKVmhglp7epKb1K4pgrkLxehjqkrgPhfG6OO8LHLkfaqkbpjNRnra018XwAr1yQFWGcA== } + engines: { node: '>=12' } postgres-interval@1.2.0: - resolution: {integrity: sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ==} - engines: {node: '>=0.10.0'} + resolution: { integrity: sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ== } + engines: { node: '>=0.10.0' } postgres-interval@3.0.0: - resolution: {integrity: sha512-BSNDnbyZCXSxgA+1f5UU2GmwhoI0aU5yMxRGO8CdFEcY2BQF9xm/7MqKnYoM1nJDk8nONNWDk9WeSmePFhQdlw==} - engines: {node: '>=12'} + resolution: { integrity: sha512-BSNDnbyZCXSxgA+1f5UU2GmwhoI0aU5yMxRGO8CdFEcY2BQF9xm/7MqKnYoM1nJDk8nONNWDk9WeSmePFhQdlw== } + engines: { node: '>=12' } postgres-range@1.1.4: - resolution: {integrity: sha512-i/hbxIE9803Alj/6ytL7UHQxRvZkI9O4Sy+J3HGc4F4oo/2eQAjTSNJ0bfxyse3bH0nuVesCk+3IRLaMtG3H6w==} + resolution: { integrity: sha512-i/hbxIE9803Alj/6ytL7UHQxRvZkI9O4Sy+J3HGc4F4oo/2eQAjTSNJ0bfxyse3bH0nuVesCk+3IRLaMtG3H6w== } postgres@3.4.5: - resolution: {integrity: sha512-cDWgoah1Gez9rN3H4165peY9qfpEo+SA61oQv65O3cRUE1pOEoJWwddwcqKE8XZYjbblOJlYDlLV4h67HrEVDg==} - engines: {node: '>=12'} + resolution: { integrity: sha512-cDWgoah1Gez9rN3H4165peY9qfpEo+SA61oQv65O3cRUE1pOEoJWwddwcqKE8XZYjbblOJlYDlLV4h67HrEVDg== } + engines: { node: '>=12' } prebuild-install@7.1.3: - resolution: {integrity: sha512-8Mf2cbV7x1cXPUILADGI3wuhfqWvtiLA1iclTDbFRZkgRQS0NqsPZphna9V+HyTEadheuPmjaJMsbzKQFOzLug==} - engines: {node: '>=10'} + resolution: { integrity: sha512-8Mf2cbV7x1cXPUILADGI3wuhfqWvtiLA1iclTDbFRZkgRQS0NqsPZphna9V+HyTEadheuPmjaJMsbzKQFOzLug== } + engines: { node: '>=10' } hasBin: true prettier@3.4.2: - resolution: {integrity: sha512-e9MewbtFo+Fevyuxn/4rrcDAaq0IYxPGLvObpQjiZBMAzB9IGmzlnG9RZy3FFas+eBMu2vA0CszMeduow5dIuQ==} - engines: {node: '>=14'} + resolution: { integrity: sha512-e9MewbtFo+Fevyuxn/4rrcDAaq0IYxPGLvObpQjiZBMAzB9IGmzlnG9RZy3FFas+eBMu2vA0CszMeduow5dIuQ== } + engines: { node: '>=14' } hasBin: true pretty-format@29.7.0: - resolution: {integrity: sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + resolution: { integrity: sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ== } + engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } process-nextick-args@2.0.1: - resolution: {integrity: sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==} + resolution: { integrity: sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag== } process@0.11.10: - resolution: {integrity: sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A==} - engines: {node: '>= 0.6.0'} + resolution: { integrity: sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A== } + engines: { node: '>= 0.6.0' } promise-polyfill@8.3.0: - resolution: {integrity: sha512-H5oELycFml5yto/atYqmjyigJoAo3+OXwolYiH7OfQuYlAqhxNvTfiNMbV9hsC6Yp83yE5r2KTVmtrG6R9i6Pg==} + resolution: { integrity: sha512-H5oELycFml5yto/atYqmjyigJoAo3+OXwolYiH7OfQuYlAqhxNvTfiNMbV9hsC6Yp83yE5r2KTVmtrG6R9i6Pg== } prompts@2.4.2: - resolution: {integrity: sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==} - engines: {node: '>= 6'} + resolution: { integrity: sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q== } + engines: { node: '>= 6' } proper-lockfile@4.1.2: - resolution: {integrity: sha512-TjNPblN4BwAWMXU8s9AEz4JmQxnD1NNL7bNOY/AKUzyamc379FWASUhc/K1pL2noVb+XmZKLL68cjzLsiOAMaA==} + resolution: { integrity: sha512-TjNPblN4BwAWMXU8s9AEz4JmQxnD1NNL7bNOY/AKUzyamc379FWASUhc/K1pL2noVb+XmZKLL68cjzLsiOAMaA== } properties-reader@2.3.0: - resolution: {integrity: sha512-z597WicA7nDZxK12kZqHr2TcvwNU1GCfA5UwfDY/HDp3hXPoPlb5rlEx9bwGTiJnc0OqbBTkU975jDToth8Gxw==} - engines: {node: '>=14'} + resolution: { integrity: sha512-z597WicA7nDZxK12kZqHr2TcvwNU1GCfA5UwfDY/HDp3hXPoPlb5rlEx9bwGTiJnc0OqbBTkU975jDToth8Gxw== } + engines: { node: '>=14' } proxy-addr@2.0.7: - resolution: {integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==} - engines: {node: '>= 0.10'} + resolution: { integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg== } + engines: { node: '>= 0.10' } pump@3.0.2: - resolution: {integrity: sha512-tUPXtzlGM8FE3P0ZL6DVs/3P58k9nk8/jZeQCurTJylQA8qFYzHFfhBJkuqyE0FifOsQ0uKWekiZ5g8wtr28cw==} + resolution: { integrity: sha512-tUPXtzlGM8FE3P0ZL6DVs/3P58k9nk8/jZeQCurTJylQA8qFYzHFfhBJkuqyE0FifOsQ0uKWekiZ5g8wtr28cw== } pure-rand@6.1.0: - resolution: {integrity: sha512-bVWawvoZoBYpp6yIoQtQXHZjmz35RSVHnUOTefl8Vcjr8snTPY1wnpSPMWekcFwbxI6gtmT7rSYPFvz71ldiOA==} + resolution: { integrity: sha512-bVWawvoZoBYpp6yIoQtQXHZjmz35RSVHnUOTefl8Vcjr8snTPY1wnpSPMWekcFwbxI6gtmT7rSYPFvz71ldiOA== } qs@6.13.0: - resolution: {integrity: sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==} - engines: {node: '>=0.6'} + resolution: { integrity: sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg== } + engines: { node: '>=0.6' } random-bytes@1.0.0: - resolution: {integrity: sha512-iv7LhNVO047HzYR3InF6pUcUsPQiHTM1Qal51DcGSuZFBil1aBBWG5eHPNek7bvILMaYJ/8RU1e8w1AMdHmLQQ==} - engines: {node: '>= 0.8'} + resolution: { integrity: sha512-iv7LhNVO047HzYR3InF6pUcUsPQiHTM1Qal51DcGSuZFBil1aBBWG5eHPNek7bvILMaYJ/8RU1e8w1AMdHmLQQ== } + engines: { node: '>= 0.8' } range-parser@1.2.1: - resolution: {integrity: sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==} - engines: {node: '>= 0.6'} + resolution: { integrity: sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg== } + engines: { node: '>= 0.6' } raw-body@2.5.2: - resolution: {integrity: sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==} - engines: {node: '>= 0.8'} + resolution: { integrity: sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA== } + engines: { node: '>= 0.8' } rc@1.2.8: - resolution: {integrity: sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==} + resolution: { integrity: sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw== } hasBin: true react-is@18.3.1: - resolution: {integrity: sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==} + resolution: { integrity: sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg== } readable-stream@2.3.8: - resolution: {integrity: sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==} + resolution: { integrity: sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA== } readable-stream@3.6.2: - resolution: {integrity: sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==} - engines: {node: '>= 6'} + resolution: { integrity: sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA== } + engines: { node: '>= 6' } readable-stream@4.7.0: - resolution: {integrity: sha512-oIGGmcpTLwPga8Bn6/Z75SVaH1z5dUut2ibSyAMVhmUggWpmDn2dapB0n7f8nwaSiRtepAsfJyfXIO5DCVAODg==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + resolution: { integrity: sha512-oIGGmcpTLwPga8Bn6/Z75SVaH1z5dUut2ibSyAMVhmUggWpmDn2dapB0n7f8nwaSiRtepAsfJyfXIO5DCVAODg== } + engines: { node: ^12.22.0 || ^14.17.0 || >=16.0.0 } readdir-glob@1.1.3: - resolution: {integrity: sha512-v05I2k7xN8zXvPD9N+z/uhXPaj0sUFCe2rcWZIpBsqxfP7xXFQ0tipAd/wjj1YxWyWtUS5IDJpOG82JKt2EAVA==} + resolution: { integrity: sha512-v05I2k7xN8zXvPD9N+z/uhXPaj0sUFCe2rcWZIpBsqxfP7xXFQ0tipAd/wjj1YxWyWtUS5IDJpOG82JKt2EAVA== } readdirp@3.6.0: - resolution: {integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==} - engines: {node: '>=8.10.0'} + resolution: { integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA== } + engines: { node: '>=8.10.0' } reflect-metadata@0.2.2: - resolution: {integrity: sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==} + resolution: { integrity: sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q== } require-directory@2.1.1: - resolution: {integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==} - engines: {node: '>=0.10.0'} + resolution: { integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q== } + engines: { node: '>=0.10.0' } resolve-cwd@3.0.0: - resolution: {integrity: sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==} - engines: {node: '>=8'} + resolution: { integrity: sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg== } + engines: { node: '>=8' } resolve-from@5.0.0: - resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==} - engines: {node: '>=8'} + resolution: { integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw== } + engines: { node: '>=8' } resolve-pkg-maps@1.0.0: - resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==} + resolution: { integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw== } resolve.exports@2.0.3: - resolution: {integrity: sha512-OcXjMsGdhL4XnbShKpAcSqPMzQoYkYyhbEaeSko47MjRP9NfEQMhZkXL1DoFlt9LWQn4YttrdnV6X2OiyzBi+A==} - engines: {node: '>=10'} + resolution: { integrity: sha512-OcXjMsGdhL4XnbShKpAcSqPMzQoYkYyhbEaeSko47MjRP9NfEQMhZkXL1DoFlt9LWQn4YttrdnV6X2OiyzBi+A== } + engines: { node: '>=10' } resolve@1.22.10: - resolution: {integrity: sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w==} - engines: {node: '>= 0.4'} + resolution: { integrity: sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w== } + engines: { node: '>= 0.4' } hasBin: true retry@0.12.0: - resolution: {integrity: sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==} - engines: {node: '>= 4'} + resolution: { integrity: sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow== } + engines: { node: '>= 4' } rhea-promise@3.0.3: - resolution: {integrity: sha512-a875P5YcMkePSTEWMsnmCQS7Y4v/XvIw7ZoMtJxqtQRZsqSA6PsZxuz4vktyRykPuUgdNsA6F84dS3iEXZoYnQ==} + resolution: { integrity: sha512-a875P5YcMkePSTEWMsnmCQS7Y4v/XvIw7ZoMtJxqtQRZsqSA6PsZxuz4vktyRykPuUgdNsA6F84dS3iEXZoYnQ== } rhea@3.0.3: - resolution: {integrity: sha512-Y7se0USZQu6dErWSZ7eCmSVTMscyVfz/0+jjhBF7f9PqYfEXdIoQpPkC9Strks6wF9WytuBhn8w8Nz/tmBWpgA==} + resolution: { integrity: sha512-Y7se0USZQu6dErWSZ7eCmSVTMscyVfz/0+jjhBF7f9PqYfEXdIoQpPkC9Strks6wF9WytuBhn8w8Nz/tmBWpgA== } rimraf@2.7.1: - resolution: {integrity: sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==} + resolution: { integrity: sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w== } deprecated: Rimraf versions prior to v4 are no longer supported hasBin: true routing-controllers@0.11.1: - resolution: {integrity: sha512-IGHHR+SpLsmDLUpYmGCwAwg1d6bobugNLlBfljnWnXEwQJhx1FGHOc93aQrErixkT3GiNxkgkVlZeFBXYcZ0LA==} + resolution: { integrity: sha512-IGHHR+SpLsmDLUpYmGCwAwg1d6bobugNLlBfljnWnXEwQJhx1FGHOc93aQrErixkT3GiNxkgkVlZeFBXYcZ0LA== } peerDependencies: class-transformer: ^0.5.1 class-validator: ^0.14.1 safe-buffer@5.1.2: - resolution: {integrity: sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==} + resolution: { integrity: sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g== } safe-buffer@5.2.1: - resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==} + resolution: { integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ== } safe-regex-test@1.1.0: - resolution: {integrity: sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==} - engines: {node: '>= 0.4'} + resolution: { integrity: sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw== } + engines: { node: '>= 0.4' } safer-buffer@2.1.2: - resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==} + resolution: { integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg== } semver@6.3.1: - resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==} + resolution: { integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA== } hasBin: true semver@7.7.1: - resolution: {integrity: sha512-hlq8tAfn0m/61p4BVRcPzIGr6LKiMwo4VM6dGi6pt4qcRkmNzTcWq6eCEjEh+qXjkMDvPlOFFSGwQjoEa6gyMA==} - engines: {node: '>=10'} + resolution: { integrity: sha512-hlq8tAfn0m/61p4BVRcPzIGr6LKiMwo4VM6dGi6pt4qcRkmNzTcWq6eCEjEh+qXjkMDvPlOFFSGwQjoEa6gyMA== } + engines: { node: '>=10' } hasBin: true send@0.19.0: - resolution: {integrity: sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==} - engines: {node: '>= 0.8.0'} + resolution: { integrity: sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw== } + engines: { node: '>= 0.8.0' } serve-static@1.16.2: - resolution: {integrity: sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==} - engines: {node: '>= 0.8.0'} + resolution: { integrity: sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw== } + engines: { node: '>= 0.8.0' } setprototypeof@1.2.0: - resolution: {integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==} + resolution: { integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw== } shebang-command@2.0.0: - resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==} - engines: {node: '>=8'} + resolution: { integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA== } + engines: { node: '>=8' } shebang-regex@3.0.0: - resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==} - engines: {node: '>=8'} + resolution: { integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A== } + engines: { node: '>=8' } side-channel-list@1.0.0: - resolution: {integrity: sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==} - engines: {node: '>= 0.4'} + resolution: { integrity: sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA== } + engines: { node: '>= 0.4' } side-channel-map@1.0.1: - resolution: {integrity: sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==} - engines: {node: '>= 0.4'} + resolution: { integrity: sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA== } + engines: { node: '>= 0.4' } side-channel-weakmap@1.0.2: - resolution: {integrity: sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==} - engines: {node: '>= 0.4'} + resolution: { integrity: sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A== } + engines: { node: '>= 0.4' } side-channel@1.1.0: - resolution: {integrity: sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==} - engines: {node: '>= 0.4'} + resolution: { integrity: sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw== } + engines: { node: '>= 0.4' } signal-exit@3.0.7: - resolution: {integrity: sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==} + resolution: { integrity: sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ== } signal-exit@4.1.0: - resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==} - engines: {node: '>=14'} + resolution: { integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw== } + engines: { node: '>=14' } simple-concat@1.0.1: - resolution: {integrity: sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==} + resolution: { integrity: sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q== } simple-get@4.0.1: - resolution: {integrity: sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA==} + resolution: { integrity: sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA== } sisteransi@1.0.5: - resolution: {integrity: sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==} + resolution: { integrity: sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg== } slash@3.0.0: - resolution: {integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==} - engines: {node: '>=8'} + resolution: { integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q== } + engines: { node: '>=8' } slugify@1.6.6: - resolution: {integrity: sha512-h+z7HKHYXj6wJU+AnS/+IH8Uh9fdcX1Lrhg1/VMdf9PwoBQXFcXiAdsy2tSK0P6gKwJLXp02r90ahUCqHk9rrw==} - engines: {node: '>=8.0.0'} + resolution: { integrity: sha512-h+z7HKHYXj6wJU+AnS/+IH8Uh9fdcX1Lrhg1/VMdf9PwoBQXFcXiAdsy2tSK0P6gKwJLXp02r90ahUCqHk9rrw== } + engines: { node: '>=8.0.0' } source-map-support@0.5.13: - resolution: {integrity: sha512-SHSKFHadjVA5oR4PPqhtAVdcBWwRYVd6g6cAXnIbRiIwc2EhPrTuKUBdSLvlEKyIP3GCf89fltvcZiP9MMFA1w==} + resolution: { integrity: sha512-SHSKFHadjVA5oR4PPqhtAVdcBWwRYVd6g6cAXnIbRiIwc2EhPrTuKUBdSLvlEKyIP3GCf89fltvcZiP9MMFA1w== } source-map-support@0.5.21: - resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==} + resolution: { integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w== } source-map@0.6.1: - resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==} - engines: {node: '>=0.10.0'} + resolution: { integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g== } + engines: { node: '>=0.10.0' } split-ca@1.0.1: - resolution: {integrity: sha512-Q5thBSxp5t8WPTTJQS59LrGqOZqOsrhDGDVm8azCqIBjSBd7nd9o2PM+mDulQQkh8h//4U6hFZnc/mul8t5pWQ==} + resolution: { integrity: sha512-Q5thBSxp5t8WPTTJQS59LrGqOZqOsrhDGDVm8azCqIBjSBd7nd9o2PM+mDulQQkh8h//4U6hFZnc/mul8t5pWQ== } split2@4.2.0: - resolution: {integrity: sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==} - engines: {node: '>= 10.x'} + resolution: { integrity: sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg== } + engines: { node: '>= 10.x' } sprintf-js@1.0.3: - resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==} + resolution: { integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g== } ssh-remote-port-forward@1.0.4: - resolution: {integrity: sha512-x0LV1eVDwjf1gmG7TTnfqIzf+3VPRz7vrNIjX6oYLbeCrf/PeVY6hkT68Mg+q02qXxQhrLjB0jfgvhevoCRmLQ==} + resolution: { integrity: sha512-x0LV1eVDwjf1gmG7TTnfqIzf+3VPRz7vrNIjX6oYLbeCrf/PeVY6hkT68Mg+q02qXxQhrLjB0jfgvhevoCRmLQ== } ssh2@1.16.0: - resolution: {integrity: sha512-r1X4KsBGedJqo7h8F5c4Ybpcr5RjyP+aWIG007uBPRjmdQWfEiVLzSK71Zji1B9sKxwaCvD8y8cwSkYrlLiRRg==} - engines: {node: '>=10.16.0'} + resolution: { integrity: sha512-r1X4KsBGedJqo7h8F5c4Ybpcr5RjyP+aWIG007uBPRjmdQWfEiVLzSK71Zji1B9sKxwaCvD8y8cwSkYrlLiRRg== } + engines: { node: '>=10.16.0' } stack-utils@2.0.6: - resolution: {integrity: sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==} - engines: {node: '>=10'} + resolution: { integrity: sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ== } + engines: { node: '>=10' } statuses@1.5.0: - resolution: {integrity: sha512-OpZ3zP+jT1PI7I8nemJX4AKmAX070ZkYPVWV/AaKTJl+tXCTGyVdC1a4SL8RUQYEwk/f34ZX8UTykN68FwrqAA==} - engines: {node: '>= 0.6'} + resolution: { integrity: sha512-OpZ3zP+jT1PI7I8nemJX4AKmAX070ZkYPVWV/AaKTJl+tXCTGyVdC1a4SL8RUQYEwk/f34ZX8UTykN68FwrqAA== } + engines: { node: '>= 0.6' } statuses@2.0.1: - resolution: {integrity: sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==} - engines: {node: '>= 0.8'} + resolution: { integrity: sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ== } + engines: { node: '>= 0.8' } streamsearch@1.1.0: - resolution: {integrity: sha512-Mcc5wHehp9aXz1ax6bZUyY5afg9u2rv5cqQI3mRrYkGC8rW2hM02jWuwjtL++LS5qinSyhj2QfLyNsuc+VsExg==} - engines: {node: '>=10.0.0'} + resolution: { integrity: sha512-Mcc5wHehp9aXz1ax6bZUyY5afg9u2rv5cqQI3mRrYkGC8rW2hM02jWuwjtL++LS5qinSyhj2QfLyNsuc+VsExg== } + engines: { node: '>=10.0.0' } streamx@2.22.0: - resolution: {integrity: sha512-sLh1evHOzBy/iWRiR6d1zRcLao4gGZr3C1kzNz4fopCOKJb6xD9ub8Mpi9Mr1R6id5o43S+d93fI48UC5uM9aw==} + resolution: { integrity: sha512-sLh1evHOzBy/iWRiR6d1zRcLao4gGZr3C1kzNz4fopCOKJb6xD9ub8Mpi9Mr1R6id5o43S+d93fI48UC5uM9aw== } string-length@4.0.2: - resolution: {integrity: sha512-+l6rNN5fYHNhZZy41RXsYptCjA2Igmq4EG7kZAYFQI1E1VTXarr6ZPXBg6eq7Y6eK4FEhY6AJlyuFIb/v/S0VQ==} - engines: {node: '>=10'} + resolution: { integrity: sha512-+l6rNN5fYHNhZZy41RXsYptCjA2Igmq4EG7kZAYFQI1E1VTXarr6ZPXBg6eq7Y6eK4FEhY6AJlyuFIb/v/S0VQ== } + engines: { node: '>=10' } string-width@4.2.3: - resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==} - engines: {node: '>=8'} + resolution: { integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g== } + engines: { node: '>=8' } string-width@5.1.2: - resolution: {integrity: sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==} - engines: {node: '>=12'} + resolution: { integrity: sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA== } + engines: { node: '>=12' } string_decoder@1.1.1: - resolution: {integrity: sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==} + resolution: { integrity: sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg== } string_decoder@1.3.0: - resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==} + resolution: { integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA== } strip-ansi@6.0.1: - resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==} - engines: {node: '>=8'} + resolution: { integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A== } + engines: { node: '>=8' } strip-ansi@7.1.0: - resolution: {integrity: sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==} - engines: {node: '>=12'} + resolution: { integrity: sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ== } + engines: { node: '>=12' } strip-bom@3.0.0: - resolution: {integrity: sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==} - engines: {node: '>=4'} + resolution: { integrity: sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA== } + engines: { node: '>=4' } strip-bom@4.0.0: - resolution: {integrity: sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==} - engines: {node: '>=8'} + resolution: { integrity: sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w== } + engines: { node: '>=8' } strip-final-newline@2.0.0: - resolution: {integrity: sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==} - engines: {node: '>=6'} + resolution: { integrity: sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA== } + engines: { node: '>=6' } strip-json-comments@2.0.1: - resolution: {integrity: sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==} - engines: {node: '>=0.10.0'} + resolution: { integrity: sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ== } + engines: { node: '>=0.10.0' } strip-json-comments@3.1.1: - resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==} - engines: {node: '>=8'} + resolution: { integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig== } + engines: { node: '>=8' } superagent@9.0.2: - resolution: {integrity: sha512-xuW7dzkUpcJq7QnhOsnNUgtYp3xRwpt2F7abdRYIpCsAt0hhUqia0EdxyXZQQpNmGtsCzYHryaKSV3q3GJnq7w==} - engines: {node: '>=14.18.0'} + resolution: { integrity: sha512-xuW7dzkUpcJq7QnhOsnNUgtYp3xRwpt2F7abdRYIpCsAt0hhUqia0EdxyXZQQpNmGtsCzYHryaKSV3q3GJnq7w== } + engines: { node: '>=14.18.0' } supertest@7.0.0: - resolution: {integrity: sha512-qlsr7fIC0lSddmA3tzojvzubYxvlGtzumcdHgPwbFWMISQwL22MhM2Y3LNt+6w9Yyx7559VW5ab70dgphm8qQA==} - engines: {node: '>=14.18.0'} + resolution: { integrity: sha512-qlsr7fIC0lSddmA3tzojvzubYxvlGtzumcdHgPwbFWMISQwL22MhM2Y3LNt+6w9Yyx7559VW5ab70dgphm8qQA== } + engines: { node: '>=14.18.0' } supports-color@7.2.0: - resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==} - engines: {node: '>=8'} + resolution: { integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw== } + engines: { node: '>=8' } supports-color@8.1.1: - resolution: {integrity: sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==} - engines: {node: '>=10'} + resolution: { integrity: sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q== } + engines: { node: '>=10' } supports-preserve-symlinks-flag@1.0.0: - resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==} - engines: {node: '>= 0.4'} + resolution: { integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w== } + engines: { node: '>= 0.4' } tar-fs@2.0.1: - resolution: {integrity: sha512-6tzWDMeroL87uF/+lin46k+Q+46rAJ0SyPGz7OW7wTgblI273hsBqk2C1j0/xNadNLKDTUL9BukSjB7cwgmlPA==} + resolution: { integrity: sha512-6tzWDMeroL87uF/+lin46k+Q+46rAJ0SyPGz7OW7wTgblI273hsBqk2C1j0/xNadNLKDTUL9BukSjB7cwgmlPA== } tar-fs@2.1.2: - resolution: {integrity: sha512-EsaAXwxmx8UB7FRKqeozqEPop69DXcmYwTQwXvyAPF352HJsPdkVhvTaDPYqfNgruveJIJy3TA2l+2zj8LJIJA==} + resolution: { integrity: sha512-EsaAXwxmx8UB7FRKqeozqEPop69DXcmYwTQwXvyAPF352HJsPdkVhvTaDPYqfNgruveJIJy3TA2l+2zj8LJIJA== } tar-fs@3.0.8: - resolution: {integrity: sha512-ZoROL70jptorGAlgAYiLoBLItEKw/fUxg9BSYK/dF/GAGYFJOJJJMvjPAKDJraCXFwadD456FCuvLWgfhMsPwg==} + resolution: { integrity: sha512-ZoROL70jptorGAlgAYiLoBLItEKw/fUxg9BSYK/dF/GAGYFJOJJJMvjPAKDJraCXFwadD456FCuvLWgfhMsPwg== } tar-stream@2.2.0: - resolution: {integrity: sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==} - engines: {node: '>=6'} + resolution: { integrity: sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ== } + engines: { node: '>=6' } tar-stream@3.1.7: - resolution: {integrity: sha512-qJj60CXt7IU1Ffyc3NJMjh6EkuCFej46zUqJ4J7pqYlThyd9bO0XBTmcOIhSzZJVWfsLks0+nle/j538YAW9RQ==} + resolution: { integrity: sha512-qJj60CXt7IU1Ffyc3NJMjh6EkuCFej46zUqJ4J7pqYlThyd9bO0XBTmcOIhSzZJVWfsLks0+nle/j538YAW9RQ== } template-url@1.0.0: - resolution: {integrity: sha512-QUjZNE7yTdIzB91sITTSYcSX5GRF5FulKvIYCqV5350NfSNfiuuCYQIJZ5PIN7k/uJ+kpurEEv9hFqRRc+JilA==} + resolution: { integrity: sha512-QUjZNE7yTdIzB91sITTSYcSX5GRF5FulKvIYCqV5350NfSNfiuuCYQIJZ5PIN7k/uJ+kpurEEv9hFqRRc+JilA== } test-exclude@6.0.0: - resolution: {integrity: sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==} - engines: {node: '>=8'} + resolution: { integrity: sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w== } + engines: { node: '>=8' } testcontainers@10.18.0: - resolution: {integrity: sha512-MnwWsPjsN5QVe+lSU1LwLZVOyjgwSwv1INzkw8FekdwgvOtvJ7FThQEkbmzRcguQootgwmA9FG54NoTChZDRvA==} + resolution: { integrity: sha512-MnwWsPjsN5QVe+lSU1LwLZVOyjgwSwv1INzkw8FekdwgvOtvJ7FThQEkbmzRcguQootgwmA9FG54NoTChZDRvA== } text-decoder@1.2.3: - resolution: {integrity: sha512-3/o9z3X0X0fTupwsYvR03pJ/DjWuqqrfwBgTQzdWDiQSm9KitAyz/9WqsT2JQW7KV2m+bC2ol/zqpW37NHxLaA==} + resolution: { integrity: sha512-3/o9z3X0X0fTupwsYvR03pJ/DjWuqqrfwBgTQzdWDiQSm9KitAyz/9WqsT2JQW7KV2m+bC2ol/zqpW37NHxLaA== } tmp@0.2.3: - resolution: {integrity: sha512-nZD7m9iCPC5g0pYmcaxogYKggSfLsdxl8of3Q/oIbqCqLLIO9IAF0GWjX1z9NZRHPiXv8Wex4yDCaZsgEw0Y8w==} - engines: {node: '>=14.14'} + resolution: { integrity: sha512-nZD7m9iCPC5g0pYmcaxogYKggSfLsdxl8of3Q/oIbqCqLLIO9IAF0GWjX1z9NZRHPiXv8Wex4yDCaZsgEw0Y8w== } + engines: { node: '>=14.14' } tmpl@1.0.5: - resolution: {integrity: sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw==} + resolution: { integrity: sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw== } to-regex-range@5.0.1: - resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==} - engines: {node: '>=8.0'} + resolution: { integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ== } + engines: { node: '>=8.0' } toidentifier@1.0.1: - resolution: {integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==} - engines: {node: '>=0.6'} + resolution: { integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA== } + engines: { node: '>=0.6' } tr46@0.0.3: - resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==} + resolution: { integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw== } tree-kill@1.2.2: - resolution: {integrity: sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==} + resolution: { integrity: sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A== } hasBin: true ts-jest@29.2.5: - resolution: {integrity: sha512-KD8zB2aAZrcKIdGk4OwpJggeLcH1FgrICqDSROWqlnJXGCXK4Mn6FcdK2B6670Xr73lHMG1kHw8R87A0ecZ+vA==} - engines: {node: ^14.15.0 || ^16.10.0 || ^18.0.0 || >=20.0.0} + resolution: { integrity: sha512-KD8zB2aAZrcKIdGk4OwpJggeLcH1FgrICqDSROWqlnJXGCXK4Mn6FcdK2B6670Xr73lHMG1kHw8R87A0ecZ+vA== } + engines: { node: ^14.15.0 || ^16.10.0 || ^18.0.0 || >=20.0.0 } hasBin: true peerDependencies: '@babel/core': '>=7.0.0-beta.0 <8' @@ -2839,8 +2837,8 @@ packages: optional: true ts-node-dev@2.0.0: - resolution: {integrity: sha512-ywMrhCfH6M75yftYvrvNarLEY+SUXtUvU8/0Z6llrHQVBx12GiFk5sStF8UdfE/yfzk9IAq7O5EEbTQsxlBI8w==} - engines: {node: '>=0.8.0'} + resolution: { integrity: sha512-ywMrhCfH6M75yftYvrvNarLEY+SUXtUvU8/0Z6llrHQVBx12GiFk5sStF8UdfE/yfzk9IAq7O5EEbTQsxlBI8w== } + engines: { node: '>=0.8.0' } hasBin: true peerDependencies: node-notifier: '*' @@ -2850,7 +2848,7 @@ packages: optional: true ts-node@10.9.2: - resolution: {integrity: sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==} + resolution: { integrity: sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ== } hasBin: true peerDependencies: '@swc/core': '>=1.2.50' @@ -2864,198 +2862,197 @@ packages: optional: true tsconfig@7.0.0: - resolution: {integrity: sha512-vZXmzPrL+EmC4T/4rVlT2jNVMWCi/O4DIiSj3UHg1OE5kCKbk4mfrXc6dZksLgRM/TZlKnousKH9bbTazUWRRw==} + resolution: { integrity: sha512-vZXmzPrL+EmC4T/4rVlT2jNVMWCi/O4DIiSj3UHg1OE5kCKbk4mfrXc6dZksLgRM/TZlKnousKH9bbTazUWRRw== } tslib@2.8.1: - resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==} + resolution: { integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w== } tsscmp@1.0.6: - resolution: {integrity: sha512-LxhtAkPDTkVCMQjt2h6eBVY28KCjikZqZfMcC15YBeNjkgUpdCfBu5HoiOTDu86v6smE8yOjyEktJ8hlbANHQA==} - engines: {node: '>=0.6.x'} + resolution: { integrity: sha512-LxhtAkPDTkVCMQjt2h6eBVY28KCjikZqZfMcC15YBeNjkgUpdCfBu5HoiOTDu86v6smE8yOjyEktJ8hlbANHQA== } + engines: { node: '>=0.6.x' } tunnel-agent@0.6.0: - resolution: {integrity: sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==} + resolution: { integrity: sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w== } turbo-darwin-64@2.4.0: - resolution: {integrity: sha512-kVMScnPUa3R4n7woNmkR15kOY0aUwCLJcUyH5UC59ggKqr5HIHwweKYK8N1pwBQso0LQF4I9i93hIzfJguCcwQ==} + resolution: { integrity: sha512-kVMScnPUa3R4n7woNmkR15kOY0aUwCLJcUyH5UC59ggKqr5HIHwweKYK8N1pwBQso0LQF4I9i93hIzfJguCcwQ== } cpu: [x64] os: [darwin] turbo-darwin-arm64@2.4.0: - resolution: {integrity: sha512-8JObIpfun1guA7UlFR5jC/SOVm49lRscxMxfg5jZ5ABft79rhFC+ygN9AwAhGKv6W2DUhIh2xENkSgu4EDmUyg==} + resolution: { integrity: sha512-8JObIpfun1guA7UlFR5jC/SOVm49lRscxMxfg5jZ5ABft79rhFC+ygN9AwAhGKv6W2DUhIh2xENkSgu4EDmUyg== } cpu: [arm64] os: [darwin] turbo-linux-64@2.4.0: - resolution: {integrity: sha512-xWDGGcRlBuGV7HXWAVuTY6vsQi4aZxGMAnuiuNDg8Ij1aHGohOM0RUsWMXjxz4vuJmjk9+/D6NQqHH3AJEXezg==} + resolution: { integrity: sha512-xWDGGcRlBuGV7HXWAVuTY6vsQi4aZxGMAnuiuNDg8Ij1aHGohOM0RUsWMXjxz4vuJmjk9+/D6NQqHH3AJEXezg== } cpu: [x64] os: [linux] turbo-linux-arm64@2.4.0: - resolution: {integrity: sha512-c3En99xMguc/Pdtk/rZP53LnDdw0W6lgUc04he8r8F+UHYSNvgzHh0WGXXmCC6lGbBH72kPhhGx4bAwyvi7dug==} + resolution: { integrity: sha512-c3En99xMguc/Pdtk/rZP53LnDdw0W6lgUc04he8r8F+UHYSNvgzHh0WGXXmCC6lGbBH72kPhhGx4bAwyvi7dug== } cpu: [arm64] os: [linux] turbo-windows-64@2.4.0: - resolution: {integrity: sha512-/gOORuOlyA8JDPzyA16CD3wvyRcuBFePa1URAnFUof9hXQmKxK0VvSDO79cYZFsJSchCKNJpckUS0gYxGsWwoA==} + resolution: { integrity: sha512-/gOORuOlyA8JDPzyA16CD3wvyRcuBFePa1URAnFUof9hXQmKxK0VvSDO79cYZFsJSchCKNJpckUS0gYxGsWwoA== } cpu: [x64] os: [win32] turbo-windows-arm64@2.4.0: - resolution: {integrity: sha512-/DJIdTFijEMM5LSiEpSfarDOMOlYqJV+EzmppqWtHqDsOLF4hbbIBH9sJR6OOp5dURAu5eURBYdmvBRz9Lo6TA==} + resolution: { integrity: sha512-/DJIdTFijEMM5LSiEpSfarDOMOlYqJV+EzmppqWtHqDsOLF4hbbIBH9sJR6OOp5dURAu5eURBYdmvBRz9Lo6TA== } cpu: [arm64] os: [win32] turbo@2.4.0: - resolution: {integrity: sha512-ah/yQp2oMif1X0u7fBJ4MLMygnkbKnW5O8SG6pJvloPCpHfFoZctkSVQiJ3VnvNTq71V2JJIdwmOeu1i34OQyg==} + resolution: { integrity: sha512-ah/yQp2oMif1X0u7fBJ4MLMygnkbKnW5O8SG6pJvloPCpHfFoZctkSVQiJ3VnvNTq71V2JJIdwmOeu1i34OQyg== } hasBin: true tweetnacl@0.14.5: - resolution: {integrity: sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA==} + resolution: { integrity: sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA== } type-detect@4.0.8: - resolution: {integrity: sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==} - engines: {node: '>=4'} + resolution: { integrity: sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g== } + engines: { node: '>=4' } type-fest@0.21.3: - resolution: {integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==} - engines: {node: '>=10'} + resolution: { integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w== } + engines: { node: '>=10' } type-is@1.6.18: - resolution: {integrity: sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==} - engines: {node: '>= 0.6'} + resolution: { integrity: sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g== } + engines: { node: '>= 0.6' } typedarray@0.0.6: - resolution: {integrity: sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==} + resolution: { integrity: sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA== } typedi@0.10.0: - resolution: {integrity: sha512-v3UJF8xm68BBj6AF4oQML3ikrfK2c9EmZUyLOfShpJuItAqVBHWP/KtpGinkSsIiP6EZyyb6Z3NXyW9dgS9X1w==} + resolution: { integrity: sha512-v3UJF8xm68BBj6AF4oQML3ikrfK2c9EmZUyLOfShpJuItAqVBHWP/KtpGinkSsIiP6EZyyb6Z3NXyW9dgS9X1w== } typescript@5.7.3: - resolution: {integrity: sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw==} - engines: {node: '>=14.17'} + resolution: { integrity: sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw== } + engines: { node: '>=14.17' } hasBin: true uid-safe@2.1.5: - resolution: {integrity: sha512-KPHm4VL5dDXKz01UuEd88Df+KzynaohSL9fBh096KWAxSKZQDI2uBrVqtvRM4rwrIrRRKsdLNML/lnaaVSRioA==} - engines: {node: '>= 0.8'} + resolution: { integrity: sha512-KPHm4VL5dDXKz01UuEd88Df+KzynaohSL9fBh096KWAxSKZQDI2uBrVqtvRM4rwrIrRRKsdLNML/lnaaVSRioA== } + engines: { node: '>= 0.8' } undici-types@5.26.5: - resolution: {integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==} + resolution: { integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA== } undici-types@6.19.8: - resolution: {integrity: sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==} + resolution: { integrity: sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw== } undici-types@6.20.0: - resolution: {integrity: sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==} + resolution: { integrity: sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg== } undici@5.28.5: - resolution: {integrity: sha512-zICwjrDrcrUE0pyyJc1I2QzBkLM8FINsgOrt6WjA+BgajVq9Nxu2PbFFXUrAggLfDXlZGZBVZYw7WNV5KiBiBA==} - engines: {node: '>=14.0'} + resolution: { integrity: sha512-zICwjrDrcrUE0pyyJc1I2QzBkLM8FINsgOrt6WjA+BgajVq9Nxu2PbFFXUrAggLfDXlZGZBVZYw7WNV5KiBiBA== } + engines: { node: '>=14.0' } unpipe@1.0.0: - resolution: {integrity: sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==} - engines: {node: '>= 0.8'} + resolution: { integrity: sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ== } + engines: { node: '>= 0.8' } update-browserslist-db@1.1.2: - resolution: {integrity: sha512-PPypAm5qvlD7XMZC3BujecnaOxwhrtoFR+Dqkk5Aa/6DssiH0ibKoketaj9w8LP7Bont1rYeoV5plxD7RTEPRg==} + resolution: { integrity: sha512-PPypAm5qvlD7XMZC3BujecnaOxwhrtoFR+Dqkk5Aa/6DssiH0ibKoketaj9w8LP7Bont1rYeoV5plxD7RTEPRg== } hasBin: true peerDependencies: browserslist: '>= 4.21.0' util-deprecate@1.0.2: - resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==} + resolution: { integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw== } utils-merge@1.0.1: - resolution: {integrity: sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==} - engines: {node: '>= 0.4.0'} + resolution: { integrity: sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA== } + engines: { node: '>= 0.4.0' } v8-compile-cache-lib@3.0.1: - resolution: {integrity: sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==} + resolution: { integrity: sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg== } v8-to-istanbul@9.3.0: - resolution: {integrity: sha512-kiGUalWN+rgBJ/1OHZsBtU4rXZOfj/7rKQxULKlIzwzQSvMJUUNgPwJEEh7gU6xEVxC0ahoOBvN2YI8GH6FNgA==} - engines: {node: '>=10.12.0'} + resolution: { integrity: sha512-kiGUalWN+rgBJ/1OHZsBtU4rXZOfj/7rKQxULKlIzwzQSvMJUUNgPwJEEh7gU6xEVxC0ahoOBvN2YI8GH6FNgA== } + engines: { node: '>=10.12.0' } validator@13.12.0: - resolution: {integrity: sha512-c1Q0mCiPlgdTVVVIJIrBuxNicYE+t/7oKeI9MWLj3fh/uq2Pxh/3eeWbVZ4OcGW1TUf53At0njHw5SMdA3tmMg==} - engines: {node: '>= 0.10'} + resolution: { integrity: sha512-c1Q0mCiPlgdTVVVIJIrBuxNicYE+t/7oKeI9MWLj3fh/uq2Pxh/3eeWbVZ4OcGW1TUf53At0njHw5SMdA3tmMg== } + engines: { node: '>= 0.10' } vary@1.1.2: - resolution: {integrity: sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==} - engines: {node: '>= 0.8'} + resolution: { integrity: sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg== } + engines: { node: '>= 0.8' } walker@1.0.8: - resolution: {integrity: sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ==} + resolution: { integrity: sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ== } webidl-conversions@3.0.1: - resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==} + resolution: { integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ== } whatwg-url@5.0.0: - resolution: {integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==} + resolution: { integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw== } which@2.0.2: - resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==} - engines: {node: '>= 8'} + resolution: { integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA== } + engines: { node: '>= 8' } hasBin: true wrap-ansi@7.0.0: - resolution: {integrity: sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==} - engines: {node: '>=10'} + resolution: { integrity: sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q== } + engines: { node: '>=10' } wrap-ansi@8.1.0: - resolution: {integrity: sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==} - engines: {node: '>=12'} + resolution: { integrity: sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ== } + engines: { node: '>=12' } wrappy@1.0.2: - resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==} + resolution: { integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ== } write-file-atomic@4.0.2: - resolution: {integrity: sha512-7KxauUdBmSdWnmpaGFg+ppNjKF8uNLry8LyzjauQDOVONfFLNKrKvQOxZ/VuTIcS/gge/YNahf5RIIQWTSarlg==} - engines: {node: ^12.13.0 || ^14.15.0 || >=16.0.0} + resolution: { integrity: sha512-7KxauUdBmSdWnmpaGFg+ppNjKF8uNLry8LyzjauQDOVONfFLNKrKvQOxZ/VuTIcS/gge/YNahf5RIIQWTSarlg== } + engines: { node: ^12.13.0 || ^14.15.0 || >=16.0.0 } xtend@4.0.2: - resolution: {integrity: sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==} - engines: {node: '>=0.4'} + resolution: { integrity: sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ== } + engines: { node: '>=0.4' } y18n@5.0.8: - resolution: {integrity: sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==} - engines: {node: '>=10'} + resolution: { integrity: sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA== } + engines: { node: '>=10' } yallist@3.1.1: - resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==} + resolution: { integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g== } yaml@2.7.0: - resolution: {integrity: sha512-+hSoy/QHluxmC9kCIJyL/uyFmLmc+e5CFR5Wa+bpIhIj85LVb9ZH2nVnqrHoSvKogwODv0ClqZkmiSSaIH5LTA==} - engines: {node: '>= 14'} + resolution: { integrity: sha512-+hSoy/QHluxmC9kCIJyL/uyFmLmc+e5CFR5Wa+bpIhIj85LVb9ZH2nVnqrHoSvKogwODv0ClqZkmiSSaIH5LTA== } + engines: { node: '>= 14' } hasBin: true yargs-parser@21.1.1: - resolution: {integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==} - engines: {node: '>=12'} + resolution: { integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw== } + engines: { node: '>=12' } yargs@17.7.2: - resolution: {integrity: sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==} - engines: {node: '>=12'} + resolution: { integrity: sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w== } + engines: { node: '>=12' } ylru@1.4.0: - resolution: {integrity: sha512-2OQsPNEmBCvXuFlIni/a+Rn+R2pHW9INm0BxXJ4hVDA8TirqMj+J/Rp9ItLatT/5pZqWwefVrTQcHpixsxnVlA==} - engines: {node: '>= 4.0.0'} + resolution: { integrity: sha512-2OQsPNEmBCvXuFlIni/a+Rn+R2pHW9INm0BxXJ4hVDA8TirqMj+J/Rp9ItLatT/5pZqWwefVrTQcHpixsxnVlA== } + engines: { node: '>= 4.0.0' } yn@3.1.1: - resolution: {integrity: sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==} - engines: {node: '>=6'} + resolution: { integrity: sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q== } + engines: { node: '>=6' } yocto-queue@0.1.0: - resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==} - engines: {node: '>=10'} + resolution: { integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q== } + engines: { node: '>=10' } zip-stream@6.0.1: - resolution: {integrity: sha512-zK7YHHz4ZXpW89AHXUPbQVGKI7uvkd3hzusTdotCg1UxyaVtg0zFJSTfW/Dq5f7OBBVnq6cZIaC8Ti4hb6dtCA==} - engines: {node: '>= 14'} + resolution: { integrity: sha512-zK7YHHz4ZXpW89AHXUPbQVGKI7uvkd3hzusTdotCg1UxyaVtg0zFJSTfW/Dq5f7OBBVnq6cZIaC8Ti4hb6dtCA== } + engines: { node: '>= 14' } snapshots: - '@ampproject/remapping@2.3.0': dependencies: '@jridgewell/gen-mapping': 0.3.8 diff --git a/postman/credential-showcase-api.postman_collection.json b/postman/credential-showcase-api.postman_collection.json index c47f2c2..36662a9 100644 --- a/postman/credential-showcase-api.postman_collection.json +++ b/postman/credential-showcase-api.postman_collection.json @@ -1,1549 +1,1188 @@ { - "info": { - "_postman_id": "4658d37d-77a6-486a-aaf1-4f3f7cbd76f7", - "name": "credential-showcase-api", - "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json", - "_exporter_id": "10630815" - }, - "item": [ - { - "name": "assets", - "item": [ - { - "name": "assets", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/assets", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "assets" - ] - } - }, - "response": [] - }, - { - "name": "asset", - "request": { - "method": "POST", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"mediaType\": \"image/jpeg\",\r\n \"content\": \"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\"\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/assets", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "assets" - ] - } - }, - "response": [] - }, - { - "name": "asset/{id}", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/assets/{{assetId}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "assets", - "{{assetId}}" - ] - } - }, - "response": [] - }, - { - "name": "asset/{id}", - "request": { - "method": "PUT", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"mediaType\": \"image/jpeg\",\r\n \"fileName\": \"cat3.jpg\",\r\n \"content\": \"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\"\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/assets/{{assetId}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "assets", - "{{assetId}}" - ] - } - }, - "response": [] - }, - { - "name": "asset/{id}", - "request": { - "method": "DELETE", - "header": [], - "url": { - "raw": "{{baseUrl}}/assets/{{assetId}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "assets", - "{{assetId}}" - ] - } - }, - "response": [] - } - ] - }, - { - "name": "credentials/schemas", - "item": [ - { - "name": "credentials/schemas", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/credentials/schemas", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "credentials", - "schemas" - ] - } - }, - "response": [] - }, - { - "name": "credentials/schemas", - "request": { - "method": "POST", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"example_name\",\r\n \"version\": \"example_version\",\r\n \"identifierType\": \"DID\",\r\n \"identifier\": \"did:sov:XUeUZauFLeBNofY3NhaZCB\",\r\n \"attributes\": [\r\n {\r\n \"name\": \"example_attribute_name1\",\r\n \"value\": \"example_attribute_value1\",\r\n \"type\": \"STRING\"\r\n }\r\n ]\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/credentials/schemas", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "credentials", - "schemas" - ] - } - }, - "response": [] - }, - { - "name": "credentials/schemas/{id}", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/credentials/schemas/{{credentialSchemaId}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "credentials", - "schemas", - "{{credentialSchemaId}}" - ] - } - }, - "response": [] - }, - { - "name": "credentials/schemas/{id}", - "request": { - "method": "PUT", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"new_name\",\r\n \"version\": \"example_version\",\r\n \"identifierType\": \"DID\",\r\n \"identifier\": \"did:sov:XUeUZauFLeBNofY3NhaZCB\",\r\n \"attributes\": [\r\n {\r\n \"name\": \"example_attribute_name1\",\r\n \"value\": \"example_attribute_value1\",\r\n \"type\": \"STRING\"\r\n }\r\n ]\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/credentials/schemas/{{credentialSchemaId}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "credentials", - "schemas", - "{{credentialSchemaId}}" - ] - } - }, - "response": [] - }, - { - "name": "credentials/schemas/{id}", - "request": { - "method": "DELETE", - "header": [], - "url": { - "raw": "{{baseUrl}}/credentials/schemas/{{credentialSchemaId}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "credentials", - "schemas", - "{{credentialSchemaId}}" - ] - } - }, - "response": [] - } - ] - }, - { - "name": "credentials/definitions", - "item": [ - { - "name": "credentials/definitions", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/credentials/definitions", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "credentials", - "definitions" - ] - } - }, - "response": [] - }, - { - "name": "credentials/definitions", - "request": { - "method": "POST", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"example_name\",\r\n \"version\": \"example_version\",\r\n \"icon\": \"{{assetId}}\",\r\n \"identifierType\": \"DID\",\r\n \"identifier\": \"did:sov:XUeUZauFLeBNofY3NhaZCB\",\r\n \"type\": \"ANONCRED\",\r\n \"credentialSchema\": \"{{credentialSchemaId}}\",\r\n \"revocation\": {\r\n \"title\": \"example_revocation_title\",\r\n \"description\": \"example_revocation_description\"\r\n }\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/credentials/definitions", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "credentials", - "definitions" - ] - } - }, - "response": [] - }, - { - "name": "credentials/definitions/{id}", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/credentials/definitions/{{credentialDefinitionId}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "credentials", - "definitions", - "{{credentialDefinitionId}}" - ] - } - }, - "response": [] - }, - { - "name": "credentials/definitions/{id}", - "request": { - "method": "PUT", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"NEW_NAME\",\r\n \"version\": \"example_version\",\r\n \"icon\": \"{{assetId}}\",\r\n \"identifierType\": \"DID\",\r\n \"identifier\": \"did:sov:XUeUZauFLeBNofY3NhaZCB\",\r\n \"type\": \"ANONCRED\",\r\n \"credentialSchema\": \"{{credentialSchemaId}}\",\r\n \"revocation\": {\r\n \"title\": \"example_revocation_title\",\r\n \"description\": \"example_revocation_description\"\r\n }\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/credentials/definitions/{{credentialDefinitionId}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "credentials", - "definitions", - "{{credentialDefinitionId}}" - ] - } - }, - "response": [] - }, - { - "name": "credentials/definitions/{id}", - "request": { - "method": "DELETE", - "header": [], - "url": { - "raw": "{{baseUrl}}/credentials/definitions/{{credentialDefinitionId}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "credentials", - "definitions", - "{{credentialDefinitionId}}" - ] - } - }, - "response": [] - } - ] - }, - { - "name": "relying-parties", - "item": [ - { - "name": "relying-parties", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/roles/relying-parties", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "roles", - "relying-parties" - ] - } - }, - "response": [] - }, - { - "name": "relying-parties", - "request": { - "method": "POST", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"example_name\",\r\n \"type\": \"ARIES\",\r\n \"credentialDefinitions\": [\"{{credentialDefinitionId}}\"],\r\n \"description\": \"example_description\",\r\n \"organization\": \"example_organization\",\r\n \"logo\": \"{{assetId}}\"\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "http://localhost:3000/roles/relying-parties", - "protocol": "http", - "host": [ - "localhost" - ], - "port": "3000", - "path": [ - "roles", - "relying-parties" - ] - } - }, - "response": [] - }, - { - "name": "relying-parties/{id}", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/roles/relying-parties/{{relyingPartyId}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "roles", - "relying-parties", - "{{relyingPartyId}}" - ] - } - }, - "response": [] - }, - { - "name": "relying-parties/{id}", - "request": { - "method": "PUT", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"NEW NAME\",\r\n \"type\": \"ARIES\",\r\n \"credentialDefinitions\": [\"{{credentialDefinitionId}}\"],\r\n \"description\": \"example_description\",\r\n \"organization\": \"example_organization\",\r\n \"logo\": \"{{assetId}}\"\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/roles/relying-parties/{{relyingPartyId}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "roles", - "relying-parties", - "{{relyingPartyId}}" - ] - } - }, - "response": [] - }, - { - "name": "relying-parties/{id}", - "request": { - "method": "DELETE", - "header": [], - "url": { - "raw": "{{relyingPartyId}}/roles/relying-parties/{{relyingPartyId}}", - "host": [ - "{{relyingPartyId}}" - ], - "path": [ - "roles", - "relying-parties", - "{{relyingPartyId}}" - ] - } - }, - "response": [] - } - ] - }, - { - "name": "issuers", - "item": [ - { - "name": "issuers", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/roles/issuers", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "roles", - "issuers" - ] - } - }, - "response": [] - }, - { - "name": "issuers", - "request": { - "method": "POST", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"example_name\",\r\n \"type\": \"ARIES\",\r\n \"credentialDefinitions\": [\"{{credentialDefinitionId}}\"],\r\n \"credentialSchemas\": [\"{{credentialSchemaId}}\"],\r\n \"description\": \"example_description\",\r\n \"organization\": \"example_organization\",\r\n \"logo\": \"{{assetId}}\"\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/roles/issuers", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "roles", - "issuers" - ] - } - }, - "response": [] - }, - { - "name": "issuers/{id}", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/roles/issuers/{{issuerId}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "roles", - "issuers", - "{{issuerId}}" - ] - } - }, - "response": [] - }, - { - "name": "issuers/{id}", - "request": { - "method": "PUT", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"new_name\",\r\n \"type\": \"ARIES\",\r\n \"credentialDefinitions\": [\"{{credentialDefinitionId}}\"],\r\n \"credentialSchemas\": [\"{{credentialSchemaId}}\"],\r\n \"description\": \"example_description\",\r\n \"organization\": \"example_organization\",\r\n \"logo\": \"{{assetId}}\"\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/roles/issuers/{{issuerId}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "roles", - "issuers", - "{{issuerId}}" - ] - } - }, - "response": [] - }, - { - "name": "issuers/{id}", - "request": { - "method": "DELETE", - "header": [], - "url": { - "raw": "http://localhost:3000/roles/issuers/{{issuerId}}", - "protocol": "http", - "host": [ - "localhost" - ], - "port": "3000", - "path": [ - "roles", - "issuers", - "{{issuerId}}" - ] - } - }, - "response": [] - } - ] - }, - { - "name": "personas", - "item": [ - { - "name": "personas", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/personas", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "personas" - ] - } - }, - "response": [] - }, - { - "name": "personas", - "request": { - "method": "POST", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"John Doe\",\r\n \"role\": \"Software Engineer\",\r\n \"description\": \"Experienced developer\",\r\n \"headshotImage\": \"{{assetId}}\",\r\n \"bodyImage\": \"{{assetId}}\"\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/personas", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "personas" - ] - } - }, - "response": [] - }, - { - "name": "personas/{slug}", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/personas/{{personaSlug}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "personas", - "{{personaSlug}}" - ] - } - }, - "response": [] - }, - { - "name": "personas/{slug}", - "request": { - "method": "PUT", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"NEW_NAME2\",\r\n \"role\": \"Software Engineer\",\r\n \"description\": \"Experienced developer\",\r\n \"bodyImage\": \"{{assetId}}\"\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/personas/{{personaSlug}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "personas", - "{{personaSlug}}" - ] - } - }, - "response": [] - }, - { - "name": "personas/{slug}", - "request": { - "method": "DELETE", - "header": [], - "url": { - "raw": "{{baseUrl}}/personas/{{personaSlug}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "personas", - "{{personaSlug}}" - ] - } - }, - "response": [] - } - ] - }, - { - "name": "scenarios/issuance", - "item": [ - { - "name": "scenarios/issuances", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/issuances", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances", - "request": { - "method": "POST", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"example_name\",\r\n \"description\": \"example_description\",\r\n \"issuer\": \"{{issuerId}}\",\r\n \"steps\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"description\": \"example_description\",\r\n \"order\": 1,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\",\r\n \"proofRequest\": {\r\n \"attributes\": {\r\n \"attribute1\": {\r\n \"attributes\": [\"attribute1\", \"attribute2\"],\r\n \"restrictions\": [\"restriction1\", \"restriction2\"]\r\n }\r\n },\r\n \"predicates\": {\r\n \"predicate1\": {\r\n \"name\": \"example_name\",\r\n \"type\": \"example_type\",\r\n \"value\":\"example_value\",\r\n \"restrictions\": [\"restriction1\",\"restriction2\"]\r\n }\r\n }\r\n }\r\n }\r\n ]\r\n }\r\n ],\r\n \"personas\": [\"{{personaId}}\"]\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/scenarios/issuances", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances/{slug}", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{issuanceScenarioSlug}}" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances/{slug}", - "request": { - "method": "PUT", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"new_name\",\r\n \"description\": \"example_description\",\r\n \"issuer\": \"{{issuerId}}\",\r\n \"steps\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"description\": \"example_description\",\r\n \"order\": 1,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\",\r\n \"proofRequest\": {\r\n \"attributes\": {\r\n \"attribute1\": {\r\n \"attributes\": [\"attribute1\", \"attribute2\"],\r\n \"restrictions\": [\"restriction1\", \"restriction2\"]\r\n }\r\n },\r\n \"predicates\": {\r\n \"predicate1\": {\r\n \"name\": \"example_name\",\r\n \"type\": \"example_type\",\r\n \"value\":\"example_value\",\r\n \"restrictions\": [\"restriction1\",\"restriction2\"]\r\n }\r\n }\r\n }\r\n }\r\n ]\r\n }\r\n ],\r\n \"personas\": [\"{{personaId}}\"]\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{issuanceScenarioSlug}}" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances/{slug}", - "request": { - "method": "DELETE", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{issuanceScenarioSlug}}" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances/{slug}/steps", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{issuanceScenarioSlug}}", - "steps" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances/{slug}/steps", - "request": { - "method": "POST", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"title\": \"example_title\",\r\n \"description\": \"example_description\",\r\n \"order\": 3,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title1\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text1\"\r\n },\r\n {\r\n \"title\": \"example_title2\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text2\"\r\n }\r\n ]\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{issuanceScenarioSlug}}", - "steps" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances/{slug}/steps/{stepId}", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/2bd1657f-8e19-4d37-b1fc-acb1b7252b70", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{issuanceScenarioSlug}}", - "steps", - "2bd1657f-8e19-4d37-b1fc-acb1b7252b70" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances/{slug}/steps/{stepId}", - "request": { - "method": "PUT", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"title\": \"NEW_TITLE\",\r\n \"description\": \"example_description\",\r\n \"order\": 3,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title1\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text1\"\r\n }\r\n ]\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/93cca8a9-3e8b-4e11-b698-a74d6d6811a5", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{issuanceScenarioSlug}}", - "steps", - "93cca8a9-3e8b-4e11-b698-a74d6d6811a5" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances/{slug}/steps/{stepId}", - "request": { - "method": "DELETE", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/93cca8a9-3e8b-4e11-b698-a74d6d6811a5", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{issuanceScenarioSlug}}", - "steps", - "93cca8a9-3e8b-4e11-b698-a74d6d6811a5" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances/{slug}/steps/{stepId}/actions", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/cb6f7161-cadc-459a-9469-dab91c057c1d/actions", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{issuanceScenarioSlug}}", - "steps", - "cb6f7161-cadc-459a-9469-dab91c057c1d", - "actions" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances/{slug}/steps/{stepId}/actions", - "request": { - "method": "POST", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"title\": \"example_title\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\"\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/cb6f7161-cadc-459a-9469-dab91c057c1d/actions", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{issuanceScenarioSlug}}", - "steps", - "cb6f7161-cadc-459a-9469-dab91c057c1d", - "actions" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances/{slug}/steps/{stepId}/actions/{actionsId}", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/cb6f7161-cadc-459a-9469-dab91c057c1d/actions/296ba62e-83b6-41f8-91aa-b92debec21f9", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{issuanceScenarioSlug}}", - "steps", - "cb6f7161-cadc-459a-9469-dab91c057c1d", - "actions", - "296ba62e-83b6-41f8-91aa-b92debec21f9" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances/{slug}/steps/{stepId}/actions/{actionsId}", - "request": { - "method": "PUT", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"title\": \"NEW_TITLE\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\"\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/cb6f7161-cadc-459a-9469-dab91c057c1d/actions/296ba62e-83b6-41f8-91aa-b92debec21f9", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{issuanceScenarioSlug}}", - "steps", - "cb6f7161-cadc-459a-9469-dab91c057c1d", - "actions", - "296ba62e-83b6-41f8-91aa-b92debec21f9" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/issuances/{slug}/steps/{stepId}/actions/{actionsId}", - "request": { - "method": "DELETE", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/cb6f7161-cadc-459a-9469-dab91c057c1d/actions/296ba62e-83b6-41f8-91aa-b92debec21f9", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{issuanceScenarioSlug}}", - "steps", - "cb6f7161-cadc-459a-9469-dab91c057c1d", - "actions", - "296ba62e-83b6-41f8-91aa-b92debec21f9" - ] - } - }, - "response": [] - } - ] - }, - { - "name": "scenarios/presentation", - "item": [ - { - "name": "scenarios/presentations", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/presentations", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentations", - "request": { - "method": "POST", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"example_name\",\r\n \"description\": \"example_description\",\r\n \"relyingParty\": \"{{relyingPartyId}}\",\r\n \"steps\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"description\": \"example_description\",\r\n \"order\": 1,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\",\r\n \"proofRequest\": {\r\n \"attributes\": {\r\n \"attribute1\": {\r\n \"attributes\": [\"attribute1\", \"attribute2\"],\r\n \"restrictions\": [\"restriction1\", \"restriction2\"]\r\n }\r\n },\r\n \"predicates\": {\r\n \"predicate1\": {\r\n \"name\": \"example_name\",\r\n \"type\": \"example_type\",\r\n \"value\":\"example_value\",\r\n \"restrictions\": [\"restriction1\",\"restriction2\"]\r\n }\r\n }\r\n }\r\n }\r\n ]\r\n }\r\n ],\r\n \"personas\": [\"{{personaId}}\"]\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/scenarios/presentations", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentations/{slug}", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations", - "{{presentationScenarioSlug}}" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentations/{slug}", - "request": { - "method": "PUT", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"NEW_NAME\",\r\n \"description\": \"example_description\",\r\n \"relyingParty\": \"{{relyingPartyId}}\",\r\n \"steps\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"description\": \"example_description\",\r\n \"order\": 1,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\",\r\n \"proofRequest\": {\r\n \"attributes\": {\r\n \"attribute1\": {\r\n \"attributes\": [\"attribute1\", \"attribute2\"],\r\n \"restrictions\": [\"restriction1\", \"restriction2\"]\r\n }\r\n },\r\n \"predicates\": {\r\n \"predicate1\": {\r\n \"name\": \"example_name\",\r\n \"type\": \"example_type\",\r\n \"value\":\"example_value\",\r\n \"restrictions\": [\"restriction1\",\"restriction2\"]\r\n }\r\n }\r\n }\r\n }\r\n ]\r\n }\r\n ],\r\n \"personas\": [\"{{personaId}}\"]\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations", - "{{presentationScenarioSlug}}" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentation/{slug}", - "request": { - "method": "DELETE", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations", - "{{presentationScenarioSlug}}" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentations/{slug}/steps", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/issuances/{{presentationScenarioSlug}}/steps", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "issuances", - "{{presentationScenarioSlug}}", - "steps" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentations/slug}/steps", - "request": { - "method": "POST", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"title\": \"example_title\",\r\n \"description\": \"example_description\",\r\n \"order\": 4,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title1\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text1\"\r\n },\r\n {\r\n \"title\": \"example_title2\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text2\"\r\n }\r\n ]\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations", - "{{presentationScenarioSlug}}", - "steps" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentations/{slug}/steps/{stepId}", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/d53b31b4-70a8-4d2a-9ecb-7ab5a591429d", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations", - "{{presentationScenarioSlug}}", - "steps", - "d53b31b4-70a8-4d2a-9ecb-7ab5a591429d" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentations/{slug}/steps/{stepId}", - "request": { - "method": "PUT", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"title\": \"NEW_TITLE\",\r\n \"description\": \"example_description\",\r\n \"order\": 3,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title1\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text1\"\r\n }\r\n ]\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/d53b31b4-70a8-4d2a-9ecb-7ab5a591429d", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations", - "{{presentationScenarioSlug}}", - "steps", - "d53b31b4-70a8-4d2a-9ecb-7ab5a591429d" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentations/{slug}/steps/{stepId}", - "request": { - "method": "DELETE", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/d53b31b4-70a8-4d2a-9ecb-7ab5a591429d", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations", - "{{presentationScenarioSlug}}", - "steps", - "d53b31b4-70a8-4d2a-9ecb-7ab5a591429d" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentations/{slug}/steps/{stepId}/actions", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/b6873c21-1275-4764-bf63-fe87c98890c7/actions", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations", - "{{presentationScenarioSlug}}", - "steps", - "b6873c21-1275-4764-bf63-fe87c98890c7", - "actions" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentations/{slug}/steps/{stepId}/actions", - "request": { - "method": "POST", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"title\": \"example_title\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\"\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/b6873c21-1275-4764-bf63-fe87c98890c7/actions", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations", - "{{presentationScenarioSlug}}", - "steps", - "b6873c21-1275-4764-bf63-fe87c98890c7", - "actions" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentations/{slug}/steps/{stepId}/actions/{actionsId}", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/cd1a0200-2b66-45a7-9d7e-c92887bf86a4/actions/fffc15db-b4e3-45ef-84b0-6e256ae50065", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations", - "{{presentationScenarioSlug}}", - "steps", - "cd1a0200-2b66-45a7-9d7e-c92887bf86a4", - "actions", - "fffc15db-b4e3-45ef-84b0-6e256ae50065" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentations/{slug}/steps/{stepId}/actions/{actionsId}", - "request": { - "method": "PUT", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"title\": \"NEW_TITLE\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\"\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/cd1a0200-2b66-45a7-9d7e-c92887bf86a4/actions/fffc15db-b4e3-45ef-84b0-6e256ae50065", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations", - "{{presentationScenarioSlug}}", - "steps", - "cd1a0200-2b66-45a7-9d7e-c92887bf86a4", - "actions", - "fffc15db-b4e3-45ef-84b0-6e256ae50065" - ] - } - }, - "response": [] - }, - { - "name": "scenarios/presentations/{slug}/steps/{stepId}/actions/{actionsId}", - "request": { - "method": "DELETE", - "header": [], - "url": { - "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/cd1a0200-2b66-45a7-9d7e-c92887bf86a4/actions/fffc15db-b4e3-45ef-84b0-6e256ae50065", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "scenarios", - "presentations", - "{{presentationScenarioSlug}}", - "steps", - "cd1a0200-2b66-45a7-9d7e-c92887bf86a4", - "actions", - "fffc15db-b4e3-45ef-84b0-6e256ae50065" - ] - } - }, - "response": [] - } - ] - }, - { - "name": "showcases", - "item": [ - { - "name": "showcases", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/showcases", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "showcases" - ] - } - }, - "response": [] - }, - { - "name": "showcases", - "request": { - "method": "POST", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"example_name\",\r\n \"description\": \"example_description\",\r\n \"status\": \"ACTIVE\",\r\n \"hidden\": false,\r\n \"scenarios\": [\"{{issuanceScenarioId}}\", \"{{presentationScenarioId}}\"],\r\n \"credentialDefinitions\": [\"{{credentialDefinitionId}}\"],\r\n \"personas\": [\"{{personaId}}\"]\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "http://localhost:3000/showcases", - "protocol": "http", - "host": [ - "localhost" - ], - "port": "3000", - "path": [ - "showcases" - ] - } - }, - "response": [] - }, - { - "name": "showcases/{slug}", - "request": { - "method": "GET", - "header": [], - "url": { - "raw": "{{baseUrl}}/showcases/{{showcaseSlug}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "showcases", - "{{showcaseSlug}}" - ] - } - }, - "response": [] - }, - { - "name": "showcases/{slug}", - "request": { - "method": "PUT", - "header": [], - "body": { - "mode": "raw", - "raw": "{\r\n \"name\": \"new_name\",\r\n \"description\": \"example_description\",\r\n \"status\": \"ACTIVE\",\r\n \"hidden\": false,\r\n \"scenarios\": [\"{{issuanceScenarioId}}\", \"{{presentationScenarioId}}\"],\r\n \"credentialDefinitions\": [\"{{credentialDefinitionId}}\"],\r\n \"personas\": [\"{{personaId}}\"]\r\n}", - "options": { - "raw": { - "language": "json" - } - } - }, - "url": { - "raw": "{{baseUrl}}/showcases/{{showcaseSlug}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "showcases", - "{{showcaseSlug}}" - ] - } - }, - "response": [] - }, - { - "name": "showcases/{slug}", - "request": { - "method": "DELETE", - "header": [], - "url": { - "raw": "{{baseUrl}}/showcases/{{showcaseSlug}}", - "host": [ - "{{baseUrl}}" - ], - "path": [ - "showcases", - "{{showcaseSlug}}" - ] - } - }, - "response": [] - } - ] - } - ] + "info": { + "_postman_id": "4658d37d-77a6-486a-aaf1-4f3f7cbd76f7", + "name": "credential-showcase-api", + "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json", + "_exporter_id": "10630815" + }, + "item": [ + { + "name": "assets", + "item": [ + { + "name": "assets", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/assets", + "host": ["{{baseUrl}}"], + "path": ["assets"] + } + }, + "response": [] + }, + { + "name": "asset", + "request": { + "method": "POST", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"mediaType\": \"image/jpeg\",\r\n \"content\": \"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\"\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/assets", + "host": ["{{baseUrl}}"], + "path": ["assets"] + } + }, + "response": [] + }, + { + "name": "asset/{id}", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/assets/{{assetId}}", + "host": ["{{baseUrl}}"], + "path": ["assets", "{{assetId}}"] + } + }, + "response": [] + }, + { + "name": "asset/{id}", + "request": { + "method": "PUT", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"mediaType\": \"image/jpeg\",\r\n \"fileName\": \"cat3.jpg\",\r\n \"content\": \"/9j/4AAQSkZJRgABAQEASABIAAD/4gIcSUNDX1BST0ZJTEUAAQEAAAIMbGNtcwIQAABtbnRyUkdCIFhZWiAH3AABABkAAwApADlhY3NwQVBQTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9tYAAQAAAADTLWxjbXMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApkZXNjAAAA/AAAAF5jcHJ0AAABXAAAAAt3dHB0AAABaAAAABRia3B0AAABfAAAABRyWFlaAAABkAAAABRnWFlaAAABpAAAABRiWFlaAAABuAAAABRyVFJDAAABzAAAAEBnVFJDAAABzAAAAEBiVFJDAAABzAAAAEBkZXNjAAAAAAAAAANjMgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0ZXh0AAAAAElYAABYWVogAAAAAAAA9tYAAQAAAADTLVhZWiAAAAAAAAADFgAAAzMAAAKkWFlaIAAAAAAAAG+iAAA49QAAA5BYWVogAAAAAAAAYpkAALeFAAAY2lhZWiAAAAAAAAAkoAAAD4QAALbPY3VydgAAAAAAAAAaAAAAywHJA2MFkghrC/YQPxVRGzQh8SmQMhg7kkYFUXdd7WtwegWJsZp8rGm/fdPD6TD////bAIQABQYGBwkHCgsLCg0ODQ4NExIQEBITHRUWFRYVHSsbIBsbIBsrJi4mIyYuJkQ2MDA2RE9CP0JPX1VVX3hyeJyc0gEFBgYHCQcKCwsKDQ4NDg0TEhAQEhMdFRYVFhUdKxsgGxsgGysmLiYjJi4mRDYwMDZET0I/Qk9fVVVfeHJ4nJzS/8IAEQgC8QH0AwEiAAIRAQMRAf/EADMAAAAHAQEAAAAAAAAAAAAAAAABAgQFBgcDCAEAAwEBAQAAAAAAAAAAAAAAAAECAwQF/9oADAMBAAIQAxAAAADzmZkIyMxEDIZqBiBpMCAAEYUIGkxgyMDBgDIyAGDAwQAzJQEFEIlgDMyAAAgBGBAGY0hRCANSAS0NkAAQFgAYISeiVAZgkdl8lAoIAgQAAGEoYjFWYBgS+awWgwBGABpMwBkoCBgDMwBpWAQYSCjAEZgxp6EoCSZiMAJkoGxIAQCBNGDUCTBINSFMUkyTJKjEk1k2QIwMwpBAzEFEAUSktEZmCQYCFCiKAAGakqERrICMLDmFgEEtIKBmBL5rAwRghQUBF1IADAEpIA0mACgAUpCgQZmhBmBpUAIgowIKDAAEJ6EsCT0SHNYUwjUSCBKBIMCUlZAAABAwnCmR0AwoEmSgMAwCkmAIjAwDAjAAyMAlRqBCgBGFJGa0GIEtIyClAk1EBkDBBqJBmRjM0GIwABGAIGFDBhCFkDYnohYIC0iUEGCkmQGDAERAFhICII1NkYAAwAUABgGBEZqAjJIGkzGFJNIwCYpfNYGAYyIARgyBZBQEFEggYYpJhBGaANSQBkDA1AARoAlpBAoEAMyQCwgwUrmBLCDDoEgagaQIABGAG2CCgMjMZGDA0gCNQIEgwBmS0BPVAEoGxBgwSZKBKjIFkQAKQA6hBoMAmGDAiASmogQKMgCjQBKBKAJNIA0mAUkxLLpzGkgGgslINIJHQkLYYATigoUyMwBL5qAKJQAjUBAAEgzAjK+RVQcejWvH0ebk7hh/TiQQeuajIAZBILAJigQBRESOgINKCVJhCiYDBJKPmoYBEJQ5qGoiJpQJQiMiR0JK2AyAGZGIJVzlqBGxQINR6uayzIjAlEoFECGoAhECMYUAKa0+p1bj6LzY8/uuWsxASq+PfC02yq+x5xEBrBmlYGkgBqQEdCBNKCQNQSQupIMZkQEZkYAICSwABkSgMgQEog0paDGskpBZEQdEmkSjSYGCCGBpN2ZpMayIAFIMFpIgNRJF0BKTu0Fa4rk6VWiq2man6vYITHS2YdoE5leIKIex5qwkmjPmsDIiDqOZiUaFDMJMOhJUJCySCgQGoEEjAIDVzUCggNLPmoFkABGZCIGQKCTAAjSUCCceoirRSuSgWEgRqQBqCACwlILds+or+QkuPrccpu4oz1laovO6zda/E46Pcx9MefunnhwRd3MoAxAgBgAwM0gRgECjCQWEKAGQAwkwWkARhIQYSpijSoRmkAoJIS0pJPofMNLIgBggkzBE9VGkAskgFJNALNABZEAV3bSQaU2mmHF2V/UMulw0KrWyFSga3f6dnpI2Wk6lhXmlM9XfW89ZoK11JAAwSRdAkwURAFGQAzQAWSQLofNQGpABZEYGRJF1SRDWaDEoiSCkBQEaTAL5mHUJAmRpBoo0AFERAsIUBkRAo0AFTtfvad5i5yJ870IuOurnXOPtBcSWkOoZaNifUVLWPPG4VOozY0uu/la9OTlnJL1qIjSGjMzGROeCSQEtKNAGtXMw6BKRdUoALJJh0SkgUfNQlkgAtXNYLLilPsAGgEhpuEktDCSEsiMZhIAwkAoiMFa7kez51daRpFL4fQhGRO7J20UF3phaK5ExuL5tV9o0j9ewm9JUpzrOMa5ue1m0jbPCU6vVamjddjqlKuOJZmlJZ7qcSGak8Y7QZBLFhBh1CSEoiIFnzMFnzMFEXdHJ9dtK4+jzl39DCL8uvfRGJ7ZxauPTq5zCQ5anzQtOp8gHUkkCjSABEAM+Zh00nN9pw20DnIlydWRR1kqG8zd+xfvL1TGtmrF4ZTL7V3isSnb/AB+Ok3GS1XF1me7vSIuGqt4uc+k4e9UqU8od8paC4accqgc+9SY9pGZsdbo2sVs+3K5CVE0ZEQzPm8Q3mdLd8PVGWGuNeTpl+zTlpNoYVgVNvb1i/wAz5xXzHrcCwgCZkQLUEkHUcjDqSQCiIAAkBOem/OHrzl2zaKlsy8n2rRSZpl38Vdj9Ls2uWdbfn9pnO4VuDquY9sFZsNOErWoNqnPo62U51YNZzHVlNRYWrLGRUrYJQKpMxd3CAlM700IJxDOc6j811mTuMKRqFK2ivKvt1zuq3Cq1Tl6L7AFNtxU25eNFE2A6mn8XPLPXpo2Y3bTDAEEXpcPQEGR4IKzNJCUaQCl8jDoEgDCSHqG8+a/QvD0M6BOw3N2Q2jx2qdGPFiuvGLWo3KuTXB1dEIS2rCAcSEZFMqMnXtgtSGYWiloY2vi00nloucX+HYapYsZllq1YmGQZUa2zVMVc5qbj39bq0OdrcDb9Z6TsZYZpgzvyQibP0nqjkg4e4iYadjcOmdzHQcA7OAjSfVgsJCI80GWsiIDCTBZEAMJAKIiB7u2A6ly73hlA3Dl6LE7iHbh3DPJFFHsVch6VoGMcrWuxr2solYWDtTed+isP2AVBteevQRY2FqCqUPTaAPd8b05KMQ1SQTSrk1HukOEcp2Kyyj+k6PZn5tH+il3lcvkV3sna+Q67EWaA0zoyXc1z9aZrl2eWfZOafT85SUk5WEBjA0haLJJiABDUZADIgJakzKa7pIuePp7TsQ45tZuTqPQU5NQvWlFFZmdGDzbnVtFldL1HKnN0vs7zyrC9585b3SgK1Y6eywPYDnnbW/Rmr3FJhpjMMNrHf8m1K86v2kXdKvTMxE1LmarF2Rj+a+oM42Mv1Gm3hXo8fm1gl9u3LpGzl7E2KW5zrafJ+3JVDQXbyKJBB0HINcARKzNJgAQBQSAUaDBUhGuUaDdc2tfn9c9caVVoabZjOtUXyaW2gkq4/wCmixrVe0lSoGa6vCRWz5dqcZK80aZNm3CQco1bl6beoCXeqf1xOoktqpt9TomiZHcpq0smqLi2qrvVyXeyR4HRdHidHAv880daVwduMbP3ve065QFi7debRl4+37z53eckEN8yCiAgAJoEgtZJAlGkDMAAYIAaufVFslYtXH0SFekttHj2m6S859sRwTbqF0Y1OQmofTO/+ivElhD07QbxDcnRapTHLyTM53b6Iyakoq35asYKZgaVQr14v2mbjMdMw6Xx06vaHbrtZuVYlptcX0qLJIJkCY+er8lRAQuu1qqzuTjK5z9uoXDELbxdNtzzUsV6uHOaofP1/L6EQaURADCADQ0gpQIgUEmCgkAZpAKdsgi1OYNXNtdb5nN3x13R/QdDzPMyn0/hrVcf2DGu7hnNU842rszZ+nfL+4c3SuSuFEyqzxciuK5WgueGsQTiC2ytjyrTObZYlfoursdgc0kKrK3WbV1OyWGvvIMhJ6R1gbswRZeVVl7MyrU2y5+1xoNJ1PNd/LOy+aPR85JEfViYIxGEgDCQNoCA1ERgAFAk+ywbAEABKB87iJLK7BKP4Tn11bTPO2k46Sla1fKcNeOL7pJedpjFl0OjaY5PtXn/ANG+3jrGRatScKiihZ8egxnNvjbCJnNB0zyuw6DnI4u6Zszb2uBxXvtlq81Wb3FMjsMPJTaneagOx2/PL0hlJRrIeYtW8dT0CQoeVGT2FWPR5+ISpoGQBRoAAEAZggMzSYAEYAyAOujOWBqrv1Q7mYu68nQ4qEpFS+V0z240r/pGdWXDSdolit7MZqnsHGh+bdLrfansxknj0pd4ib9rFb5yqc6mNKrUfeeceT5531Z0xrrOU9HP6Mr+baLc5jN2an8fT7ClvP8AseG0bmluiU5nRc9u7z5sJWHzuiLmJFmH5/u+Jd/NGc+iOrIGRCWEmBkAAAAMwAMGQAwTwCeMmwSkUDA5eIeS3Uq4q+GrlMe8pTS7W9ypvaatbcN7LLx77Jz1OTV6Glhpfbn6Lnbomxc2jm4Vme2xrtc70/DaeyOn6J6fNkO6cKdkrjhHr3E+bHId6j9A2z4Vu02TPqvjG30zsyxOv+hMad2q0eY9jed/49eeFw0XZa6xfnHUsh7+ZtxWnqySCAjMjA0gwAIDaGXUOYnFhEol1hGFOkiE42ToFWmbJZoqKoW15xy71+XhLRSiJRcki4u2Nmw1KcZ88dJmtXClcvRmEtWrZ1TfJWp2Hzuq0vay+lQFQ607qyZaLXbl1Y7lBRziIyNxrsKlSIu8z9Kna3Vqv0Z2VhBRMVbKZAWtznve80jWdUdUie4+h/BylW0zyeAtL/0eTP8Ak7a7RwPtyaAMDQoGCQYDsqNAEDIAYAASE0FWO19wrGvxN7xtnXdYjePo8+8b5Vt4nJaHusN8i8ymVY++0Koqry3itd5tfANhtND9DDarJCp8r1bTyocNrhC3Wmb1JUGurQ2LWEK1xrinVf1koC2l0455Xr70pM1M+kltsMHfMnn8EhxtPd/3kcLz7o+gN4d121lpFFdabBtY3ztkJ0ZxfTrzuePNaGAJAcQbgG0n2QHd236BNR1TngkZuoOEWKYpk3FarH853h6KFXtDrlrhZKTebm3xMLxx0nG8rJ0lbFnlqccPCnv3y3rMQrKLPl2FfNu1pZYlfrXWuHaAgazypaEqvyAkVCZd750xjEWW1Vek7WGXDQqVdM1YUx9HDLLfnLLon0HUA7wuJbzkfa7Q9jZVMQVkjgi5GWIWdc7BE6KtQF4r2sQw6DaOqg4F0aMAMu7yxA5goXkFhgZXsBWCvzEu2WykcOPe496v0molczUKWhPqhZqUw8gYpK12Ogy1To0fWqpSyn0fnmlUtedUeQwt1VrdA46U+ElWsaIi53QBYSrQcy0mpVu6v9ZgqntMLJmHo7z16Qh2WCs9LychWomIqp9U0yaqNIv1D3hmqIn9J017AXbmukMp1lc197e66m/b1yTRnIsw3nPI9Y68ESXLiKbrziRHx7RygVPxJhJxscaNGkabeuPo6nCx+Okw9ZOaUcykY21bZigaM5p/W69bmg1zXodmVahVW9G3zGSW7NXsVrtnUhGy0ZncyVR5S+ke9rms8Cd2HHWN4HPy/P1okITaLRDSNhh1TSX06kKHZGIQWc7JnlrKpnpG9OV8s2VSmGmsMM8nUSsyS0Z2izwuk9wQi8dWTj0uPl3XwDuwWADocwcxzviCeyHyb61V6b5N5LouVw1jIR8wZ35sOaaLDX421uM3k+h6ZWPm15VLJtZgnR6/rdXTj5mBaS7TCzZS5mchH6UVxvfIMoqV0quHRGudMm9c4GzWRvmR6nvJEdXLHnSp+ruqk4zPash1zoaLnXN4pja2RFjvTM0c43pNdmizfMunNnYQ4kzJSuXp8nMLMEBfUAEgORrMfPsUtI4k2/Hk6bSUI8x0drdxstnHyrHSRI8CQczXmwaR3yyZqdWf5BL3Fljq7EKr9XmHSXfpnKr8h6TqYxum2ewOZqd4c5PTKIY2OvRTxOfuaLa2yW8DqC9GiJIvoTQbyiP6XvnJtoK/aRR46Qb2pN3FPsdLM/r9vzo5SOn0oYWgOfJpdB6nLyV0AcugWHFS1BxWowFlhdFw0qA6c+TrkZPrMY1Fd5OJBjXnbPbNjOvuacfBuX1TX50lA7hLtVQ4PeljacWOEuHPo4loLqnZo2Ih6m5dc9ONLm3r0hc2KIjI3SOtOsGcaRqsDGXbO7C4hH+VxPaVcyVah7VkPVgwkWstSq6J/TmsJ7PuTfS9U+XytxdId9lU6HIuPKo6D0+XmfQw4q6AOR9QHLspxLc3il2rl3rjGZYY62bpXJTDXm3nJRldme8cKWqzeRuQ7lnsVFx1q7ua5Wr5CtRM7K0+LtfDiiXM2GuOqm0V+A5RVmis+e2pyvyXWnONXkwSzOxpkzezz9NHM84S6S7I8i++mMXg+u5P05cnUxTnV4nKZdc3G51rdMHC3lU5JI1gRKrmLEEYcpY9XiIuoDma1ByWsI4DqsfK40mS5trs1bK5N5k5VeWlaeyL0OfN4pzT7al7SCbCJKDcISyMqlMu9Ty1tLOvqKsMJAtNZnK5PxtzZXtbmcbjmd3Q5p1vVYEN3sy0eb15l8ZqrFBxdvm2V0ieuLnIuRp22LHKL1VOvORiZSxRXGwHHRUYmRZqrFZM+mSZOIs2fpyonwjEDM/U4iMzYhRkgJMD6ducxJCz76I5Oi1t3URhq7mKd2HbLLGTOmVjadlXEb2lIKKfTretJzMHIsOXavx1hj89WckxtLKei1NI0rNp4WS88htd1xnbPXz7S+ZWeHCO1mcrdSq+qnJbpoOdQlhuC8yrz5xGmaKc8hds6bP0y16OGsLONzvSq9K1iXwcT1Pz00eTpdxM2DF51HNCaF5+UC5H6nL0W3Adk8yDuOSkOXLKXl2eA0Gl+f1xNqpN90RuXbHnvrP8ecXZJ+qdtcpiCjTmrozio7K3CuEXjqUpHSWk8YKXiwmOkcdq1xa6nUatnvOsaTBabmarLLUXN9mqHa9Fs3PVetSotxIwrXhrLipWar3DCrtV7RWJFNzHEwjDlauXPszw1mERznDfR+lXkjOQi2j0LGJYa5+TRwL0+RwG5A4LgA7huAezcBcYq/s5J15fXlrS+VvQk7vk7zSdkEVL8ujOXrzuLOIkomXZIdnV6Lfwo73SbmWTopa7R6Rx1nQYutOWnLywS2V45Y9EnIdUtVrdYup2t3HifqrI0mZqlndtUprIcKVdkovrrFQj3cbqrCxr0y1XHTuKHYY2y07LSy3in2Tn1me/ThUQL17WZvsLAEedBwL2vO7jgQu5twDtbAhyL+vyCNa0HNrFwdNghJmZ5tcjgd4CeLO79NF5xaZReOlbb6BUpedxWrddZzuv65ZbjErlfprN41ITl/uanG6BXElT1fUEil3mbNSYxlNC5x0G/bXYEvpRycZC6Z2eDb8bkq9eKwyn9bTSrK05lW2sR3E+IPoqy57Glq0vJtBzrQ66iQyce/5cE2AeijzaTIvX4HpMSB+I4gkRHJCUcwLoNHv+T7DybWC7QLfj2uz7M+ed6E3qbtEhyrbSLn1prUU5eR/du2t4SNuNEZV6FtQtzrNYb0E0RMOP43Vq1y7TMilCsbM6CGcyh1EfHyiaTZ0xK5Jm1jaLJU0WhqkOI6fbj4DUqO1B57pdN1iSrU1CDVpmfWKKnpmtS+Ok8yneEjcNgHlUAvX4TIAADAAAA4mIDsGjan51dQ/Q7LK3/JvoUFXb5y70WD9E2UWGy2g46PaYeUd8mzCq2eCz07GJmlmlvVLWuKDekvoJo/uXkzB26oiX1WsFzwkYBoFrZRLW5dOM+nlUxBS/W4r1gRC0mVoqMszk1acxyvJtEtQY4K1hkx5RzHdujeGdydgrt/w17OoZ/DsQlReXhwGPW5CBgCMAAAADhuAm56jKRqh53dMdNPuuGPefXbXeeL5tF166zc1Wu/NrF9qJCw+8Xfrli949BMMtl8b0iFzuC2y2xWN7Djo/Y85PLRw3hGydwbQfWpduYq2OWc+lLmQ4R8bc98/1HlSq8+TBFbdW6tKo+DnbHSrURN1Sohh2b6pcrDKi7vxb27m2aWSCtynoFDSfFgA9TjAAAAAAAAAAA3DcBOWrO7DD1WTjpDk2lpmotufaXb8+8V0g5es0qxBP53ozpthfO5qDkJbjJnUpyum+dV6WphFRt6oPea2uexnQOTazr4rebWOsNI0U6hlF2P8ApFTwpxyIe85oRDFOzMi4sptmzeaVTGc6vQGq7W7ZSenPtL1yQTvEnCWzk6JmYr7KC0iLFz5YAHqcQAAAAAAAAAAAyMO8hGuguM3UrHz6Jko+cw1lLjyVy6w+T3+iazapnhyTk4Z0zilTLRiDCF70Xqy1mkRqrnS+0J25do2u7H0Tf2rDpap0AVSuUtERVrbDl3yDqHdOmOOkrYQtdZdHlXsOdUitarm1PRGVXuaM4p17p3RlDSTedY9uFHvvJ0XxUf2glBEip8lAD1OMAAAAAAAAAAAAAHXksJG0V27w51DfnybvbFXUYauIR7LVNjkEssNKI3usRrPK7RczhrRIGy9NJh02OHa7WKpWRDaItMU1P0G5WYPOk1dc36srXK5Vz0nborL2otFTUpIOtjibhlV6fVKx5VyjntQoi5mIi6I+i2uE3zjH7JFK26Tnug8HVYbNUZiRqIEaR5nBH6fGAAAAAAAgMEAMEYGCAdZGOdIu1tpuo8+kQ2dxXJ0SspI16HY2iX81AOY7lSuzmPl8ry239O4+kLoWXitXCtu9Ikas6yfedWksde7Z6+1yG1xTlqrQMqzue0V2jN2O1V+ozd12jNVIyubywX2B4yUuIkbFUk4vO9HzraGoE7RYrVX5vi6J55DybkBApeWgB6XGAAAAAAAAAAAAAGCAdHLMBcbTmEpL0ez51Pc2krJxPPLSXHVnLiZRiwHIWahXSXzEfIoms2k2TLca+edRdY0WGmqTZL88i6S70KeSzHpc4+45O2K9odipzFS/wzZo65xvha4fVSslBz8U1grJLJ1eibRSwzqZ5WLSZSXiLVzbzLTl1IngkXHkAyHo8xkAAAAGQAAyAAAAAABggCuvAwnJSo9kXyXqV0w0lUpk8dCpWgV3OmNwahkYg2gLWfUSZqnWVObm69aubWUlKnKIddKq2tXWMz+I6M7tH0yK3z07nhD2lsExjN3yq3NzXLpaeTVuwHYM3l2bvRpS1FSkU/TnX8HO508k+DsVfFoCPJoA9PkAAAAAAAAAAAAAAAAAAAKAAuwATt/AyuVfgc+iwBnTyHAio7oBaKQAc07TAJbHQQMNGM0BLhuwCdBrQHXnTIgDt52b8BOw6CBjcJBgJ3JYEOfrQFGf2QDWFtAMdLfaAMa5wwFLQwBWf//EADEQAAMAAgICAQIEBwACAgMAAAECAwAEERIFExQhIhAjMDEGFSAyM0BQJEEWNEJwgP/aAAgBAQABBQH/AKo/Ef8AD4/0Tg//AF9x/wDwDz/tcf8AfP8A2D/X/wCl/b/u/vi6uzyyNnBH/C5/2vG+NWpgyjBWVDu+FBiR/wBrSj7LO6Sn8okJ3oIbrofNaBI/7OknVKUJaVDxpyKikuX09sink9M69v8AsapPxv3yES2Q9iFqIVeLTy002Z7MHjT/AKw5zX4+MQ4I+pmW4nyRTVqM1K8tvQ+br/8AWmAShZdeahsGizZw6YHxy6irT58fufTzeh1f/qheckeYKDmvvVQtfkOYsStUxKa7ZNzC+s82zc1H17/8HnOf9KfPZePQwBz30mdKxdaatRj3qjO0KY+utV8ds0bPM6vyNM/rc/6/P6+uELiZmnIy4zxu11esqqP5nqUD60uL/wBxmS2pt9H8lqfG2v8Ap6P+c/Q/+6Fkwy165Pa3tUJTT3cPjY8vr0QnVkqiv03NIbmqc5+pH0/oH6Y/4PitevyKKSxJybED402EK66C2prbIZdtc9l5M0BXXkitnjtunq85qdLkE4efw4PCrz+A/Dg88fQIcb/VJ4wH/R/h5Pv6AZsDhlIIYLzp+QqDSML4dWqikaFAzrXtNK62x9+tdLS2tWkX14B5JpOzUmAulL2m8+rrE4JFmnDkT1CQ2ogV0/M/0en1b6NWdVXFzn9cHPDsBIfttLgYjAvcKPo8yRTdVcPlZl9jYnafsVs7dK+9Fbfkm7p69aTXQ2FvXa0odpdOaQZNiWos506o6VkZx9jP47iz7cyceZA/WSbMdXwzuE1dOKjZhh2JFaaWpddvSMajOf19OrRjrP3nsw+2i8Hv9fmrxo11r55Kf06y9769ZGcqCezq1aeuFVdJ+Kmcj4+OvGQhV9zZ2KpNPRb3b+1s/I1oWtt+TYLuq3bW8ZqLLWsBW+3ouVMfo0+M4/SlqVeet4lUTnU1x/Nfqve6HWQAqDkHsT5lFOt+PP4c/pAcnX1Pa0tdYZWnJ2R91Ppndhib+wGB+RB50fLaC7Gto6nRfyJLuUKj0FM2ZFslTVR6bs0yu8Cy62wk9hRLdQlIzSzKmv8A+Zs3fX1tBtZnusqT4NnPjeFrrEAj7ePw54/DnOcjKlX1vEziD5OaGm1QlHdy0teeL1xqFGNzk73JsC/jf19JQ2zr64iLEvQ3+t2By31IB5cHPHbDo/rDPN1XNiwmHcYtEzbNmXY+RWm6hk7yv8XW1VXGVV128PL1V9XxxLvVRSq+T2FpbR00fXS5pts3Z4bVXA6yS3jprr0hVHabAgcnJTeja3hAZpbX1hsbg4RphNejHOpUAJ1fqhOw3IXnE45X8rx/P6/ik77jrwdmPOGp7inImhoNbQasraUTDT0gL6GxytrCsvI0Lah5Moa9OevSUaI2zWySi1+U1JbQrrS+PDyFgsdWP5m/pprrra0b6vntCxO3NBHxJEt8fl00Vqmpt/4Ibc0Bvq8bb6hJkzmHhqFJVhrgbRrl9ivu+HamfB4yei+JNBnxpDKwmq0j9ehyc0NPL7Cy0f1/4eVDtWV+XqmX1SKzjRm8bpjDNeLvILeQaq1AsmgfdvxNE15iUtuwTNVPdK2vOSvMfF09cTyzLI7m7ts25sU2XDxGxTYpsvCDCnzE5kGlW8xreQmVC0qy0qEELV4WKbOyf/jpTPlaerLZ8qWAuuS3CmR2O5XToXpLq8kTiajtGE8fVKnY12wkAacpVPmfIHYv+v4vZdLGgZbQ1zYM5bTISv5aC1+MGyhuHEm2PHhtiacQksyvyp+v5htFrmBpv++u3s8X109K3KrranfaSni11mXi6MqJTx2wriuvL372+0vIpKO9taboI2Y0jCo6t4+LkUXVnXd5au39w7pgqJjp3EdQYdGfEkm80hp4KSXG8i4ynlaYbl8PfnZ2Bq6RP1/Xk3DzpzMWL5M0rScldTQgCasldAmGohK6tZTTYv015bChtyarbsJ6f0ofJOKS8cpes3/L8vT37Pj5Q0odmNqVnGVh21PG2aG1FnWnndTY48PsVi3j/pq6Wn+R8HrcVgNaJTYnuQdSn0aHKL8tgy1gMju05jY8rVVICsdialqTyczipmtJKU822u1P9Bf3WhRNblmnITPylZqU/LWStTVanXf+ubbtbZts1V32XMUn30b0RhCxs3mJNKfim7T1Spbaok9zRoWVCsnSDBdlQi2nEb+jsildxp20/HeNjLKu8MnX1z2be7F1+yTlVbXVObeLYTsnrePCL79UnW9FFgyzyd5svx48XX7fvcpIDJ8dt/dnqwd2Zv8AQlD2ZPVmua4RG2bUbJOdfEvMptPaOTv7hGoYx0DC/kABeWoV06VdZM2eGm655NeyaAGePOusPPRQ4y9U6qXSrPIMRsV8SSuv4nqN3dVYwp1zuhfYn7TJFVryt7Y0dI64jxXssNnXE8PKZBVY6+16slt6lBsRjy9IsVLccfVRziowz+INuQb9cZr+omSykJlaNYmazbhaD3ZqzIow2FA+rvL87fdQvmFV7eNT/wAbckFnP1s2hrlJeTIWWsGVfGKqpvJS1/JW9zaxJL3dZp41Dq2cKm5tDO3yDFbSyfjHpJI0Q6rTTG1u+w8JLPR1Zdu/3OklG5pRGT1lLSj9gWPKPRM7c5/6+uasRyh6t5Hba9/w5/W1wC7lemkOVrwWVUKfJpKuts9cncKFpJ2prQVm1u58jA+/wXKavn05zxklraa/b5vnpra9EwtQLbbCDdkIS0ddY62tNKb94BI08gssd3uySTS1abaGK7bie1cUhqL2YXAysVAEkVtShNtv5NF+IwGrDRd2idc2mlTPlQMUYsScROo37iGi7sx/0Jnhg6sUZvXrr1jbyo6m9GpphXMYr0d9Zclv62RYzFPH++mnPqfOq6r4aarODfbaIqw1ARaPsbZ1PbtX1613N4suDQnPY8lfqtbszavih7Nt07yr+dHnZRk42l3ANhvIOweFzaaMY+tUCV4ba11dficrJ6MKs6ETIMpk5HW4w8DEZc/ifYJUn/Sio6LWjts7tkWWrStH8YZ21NWy08xTYhN3rVvVUYmzsTbx38RvGsWjtDyU6GMWKquyhadQMmeq786Z8jvmiWGMri8Ohr5Gs6Vj48tSMUQeWoRTXn9dSbe2vONfV0FntEn7MjYsZ0X2g3R2HtHxul9mVC6liAoXJ7CZKykbbFU+938tcV3P9FPqzV6LMT4CN79FURK6cykYFW/iappsaMOsmXKcAQ1rbNvH+Q2NC2t5mGwu8MvudMFiV26ES8gj9tTXUSqg769KPl0o2zPQY1WEcuD08l9+3qAKsdIcUpOZ+OnOt36R/vZZyWdlOVJ4jR2x9VeNv1qKj1h9gnI1+uu/DbXHqvstHWLcn/Rk4UliRYp69ODBdF2DI5dFfkb5JEIL6NvTSct7jv4PyHwt/wDiO/jt5NXYpF9Si7Wr5OPC6NPpthaam2D2jJCtjw1C42tlTeBKEdAq7fCijmtPHapUbzFFZr7LQ1Spcw7+yyqF2qLDWVEO7JMV6C0q+zNpOBZWo9p8Zq6xGa0Qx8jMejyu0tK/6cT9aDsy34zRKMI0IeZzyET30pLbU36ds32JsP39DKjpwP4XbmPkNdWh48FFp98m6DYhNOLAHKPzhtIKmz3IuozyN0c6Gs9XJaS1js1pq6jetUTj4ydfhqElGNZ0lVMmxJoi5rvRaX2mpm7QLg6IAGo2lr5/EXkiiknn/TkQcSSexkPM1YBdiS1nfnPNQcZ4lUSnk9XNjVpRtTxnTKa/Ubf25/Cg/J21/K1w3HuY5Z+lZjKuVazv1aHtGv49pgITh8YGxNfqiRbHFkb4jWb1twsghZHYWJw7TJmmpNHKqJfVtxlMtsa/eCTpXXk2b3mPQt71s7fv+p9MCE4Y0GH6fjzjDIFgeOZzsZmG+8qQoyCVFum94xpNDy4VU19RlNpTG3tp1rQ1p/DQ4TyNR6lGcd8XTDKlFJ+rJEcjS8csUqqDNryEJO/8RayZ/wDLJc//ADDZBj/GG1zDyunVddqPlIk4oIzf7TI8hGmTpCdZJFsJIatW9d9V2YS+++62utWLsrcGhBf9YfTBagz3NnsTB6jiojCOuhxec2ZMrTrRkjsNxC0JLHbLvfxULK38KVz+R76DyPjNhE9KrHweyqTRi9bdExU+7XmMohfJovHjNNfY4Azz/lhrRrsUqwm5wjP4b/h/xm7o+d8Hr6zz9k20/MbWs/jfMR2pbFVy1F4PC119cvilRQ065Sa7AWP5voOeQ47MBh/0VUsfh1GeqGD0ZJo9pdetnAw7KMk7KjTaZTSE+KMzH2V9up5A5/MtZs8pviybMWRdDXfhKFA7dsjEtX4naXDqXCyGn1RPJeRWc/I7jX2NXSBC6v5789tLyWxrEVrszbS+m7rlU8J4pitGPO8OMTUByUDzJwVaTgIei1ovKB+fLwBVxhH685O+f+OmNt2I/CLfWyntLZKrXZJyf358SjCevfrrUoF19vpFffU+tmeTNSW4VAYu9mXoF+8JHkTl98VCJu0TvtV+0+YSUt3aptPsQEm8WErHflw29IpbXi1X1ZcY6tg0l2K6MFXW20FE2vH7PaW7dDr7/ITYTvsE4lZ5ur1yP2NuODGiAM36yqoD0Zv6Ub6uhZWjnqfmf2tr7jIH8iA00csi+0x0jF1M1xqETMS9NlqZLvkB9CR1RzhcmVuc2j9lbUL+MrJJ38Y+yNN30tisZbEdzxz9dLx5IjrdManLaOjMmzjo1U5fow8l4lEzvRG8dVAnvdViVUP68PWZ8luvwz/rcBc+hPSedEz1Z0bOrZryDH4/5d06NIBsbX5E/tIn906gTnw1EjuoUexxpHnyDETnVi0jy0qcJOoxKIwd2E67Dc0ZWxpcV1Z6zNpxUp5Lw0tlfV5HRP8ANecXyP1tubTrpaFnVPTrLuXgyzf7djycY43mVc7c88Ztfd7yrvLsyFUzaooGw7c9Oc4w/oorMfg2GCeqmd9IH5UBn8xOfzJ8/mlhn81qcTeLCNokUbW6bEecVvWV2FIPrbNcMMDdsSXONToG8tKeToaDfB45C5rN9E7gSXrgoozZY9LXCnV7HYtBBmpsYl7qn81ZEPlNUimjpVf+W66mOpqyDeSipfeAp77vj3oJ8bNzq+PaeeQCUl489Mq7Bo1BNKy527pSLS5RZoEYjnjkleP6/ZJcO1cj9BFpmml/W3GXGWKZGgVgqUWOmuL47aGXbysxub2xNbfH2E1Un18hrEwWpVtXYLvqVJxB90lApvgoNirNnidf6bevTF7KIzRsbVbHCh9fXoyU+UjMdsY23SSfN38ht/Uw9rrSK5GnOeTrZRpkBJgHKr0wbNOyKHJUdDKzY3jqjDq/a2dfw4w/oy1r1z+VbQz4OupCeLTJT1mzT1Dy+qTlYIF2thZlvInmG+CNfyAXJeYnwnkNd82fjWbc8XO+RptyqkuU/iLxJjTxV1W/qRgNcoGvsTr5DyjbD600a+rFUBVXxtZTQy6EVANanBxwiqTWc7Kk7Kxu2e5FMXozT1Axnqoo8xZ5toIHyyrN6IFTZQcMV5OymDZAyS+xduqvKsuMcE514z6/hx/THVrQdNRMXcPakfIPgTxs8XciG+f5CefzF8hv5OzFX+7K+P2qEeA8kzL4qkMlKYyd48U8dGzW8O7Psx8h38fs7a3ShzyOslob2s2vsjfITb8uVC+R3KNLxO7tHx/gvQTL7r3XXWO/Czmnc9pA7WmM2NOuaIW4r4qqvsa+z2loWOR8SyjU1kQFyj32YqNzs9NLyEeL1JStLNnX69VNP5cQazTGpXpKf0V3JSA4OtSlaxkgohGHn8Zzd25hPONjZcJqTw+Qv1/9/GWYbbfhPG7RX4+mmTpopmntUYPtOMrs5auxTJeL8gSNP1BxHj+WbfIvWWfPORvM5O30YqR/FemVf2HsnW58R4WEURQMOXp0SvldO1EXx+tZaOcYNw2y8mcNRWmQZJsmbruhWa0zr+SeSjycrJ34nvWLhtHYxYV51NFitJY/rC9wD7p5SmuWt+Ys5sXrqKjQpTNqz9k+uWQjKyoc64kwQ9Sw9U5ZXYo4yc3dxr/HHOmh/mNwHZmM9KhWI1kyfy64NOgHfx6FvJ2Vdna26ZCM9fJ7x5p2o8dwKO3tw/R/k2BXaoM8lJNqCeHu9fB+H19ReV69s2bMgp5AKw8boVOx4CLu/iNlj8Xc1p226Oj7tFF7OAu86su87jb7DNQUDeMn9NlX9S6zPlNaaZRddzWwAP0WnyGm9SCNlhiEHNaP5ZLcWqVY7nbH12A14kYdiHOylKrbWqr/AJlX9iz/ABhrUqW2E1MdmZsGqwA2Unk9fa2WE9XXY+R2KKr8HsvE4vUtRZY8Rmmrvnvhw7M460cq4BndifkOHrulEjudnXYbJbWfOmgF4USujCq72js9JHdkqeYYVlsSsu/onH0hh0frPQGJoS42vHArqKyW8evbJU655Wk0x3NwNdlOrrnjYM1L65635bOq8y9XMpvxKqBN2TMunrt0OmoNNeq5TohTdfrZqF3cBfwRFC/K4nk9clfes8RHpSKa4au7zkwhyM1GPBhk2YBqvwWyOp3zbs12WoniPwtFPW02wTZrUtTtt9+EpwNfaDYtvtX0sFTsBrsglegynkpK3/i1X4xx7UV6LVcoWGLY8o1ita0UbH3U0d6yqd6nWlPprLRjHWr1CtObrTnYVGWs+2MpVtYO7A0OSrLGeTYH6h26tQ0ed0bsi9cLav4ooxmLFEZm/Klju7sidiXLZVgBxgzXPQpfkUNcYNxryHXb2Xxh0mk/v16saTcPhmufH+nxABXTY58M46Ga6+yy5K0nxKMpO44xtqbFmjsYnjuoXaeeWqaDreOT2IuwVHB8lBK9p7A2oRaja9RkpiohptMoJYtJTFbUD05cOkJpWiMzSBZjST69PutuljPZZidztk5fl+7gVoxwJTn1A/gByWPOJLkNX7cAJNGHCfZPBzgbJ0OSZiGOQ1++dzzHo1DXu7n8tW6rq7HXI7KnA2cni6sFpIZaKlq65BE3V0q/U0VqxHZYVoASGV4CuP48qWR0yqa7YFDmu45M/FVRdZTZF0Zzwwm4dXmHU5enbE68NUoFQfFvNlekyuGDulVcFS3KfTNW8OtKKVHs5VWcMrALdCM/ZeqrjuzH8B9qohZqMGb8EAbEkMmVGBlOVpxOv1VfonAGcgjspxptzqdorCoINiMaozjtj/XOqmbz5BHDVViKfvSAV5j8uLspNx1DyZPJ6FJZ/K6PkdP2Sh44Qz6Z2oHeZfEPAtsBFaiGi/2SbijuUSmx1eiT4aiqatVgZ8n18YlEJXYkq0m3E4UI6OpZQCq8nt9f6H/dTwPxXJ3bFohyXQsWBYgZ9vDgEcYv0xeFDsWaNypXbBzur4tftFfo1iM+UACylX2GLrdfkAFjr14J2G4+RsrWQKtPjodRFVlGOxUyZKDuFyjjq95UzZlRa9KsuvpoMPZGpssZU2Z90ZGFtYFJlQKIc1ZIuCQDr9Jzk9cnOxPxZHG01J/9f0KPr/THry/GAocHC4j51HGFM9gBUjh/rnB4BIzueUt1CbTetd7gCvZu55LHjWn7HsXeu92FkkGp8LqoRc4YZMq05WOPNHxmXrtM80hvjcm+++vXXrPYCuHH2DGqrH3lV92WLu68qz9Ka9OyH2dcUzJCuMnsS5mJ56mQwcjPi1fD/Sv7/jxn0ySoQwXlQSVVs9QxZ4OMdWOUVVCB+woMdpjC79Q88kFI9XAopA1a81mp7xmrHU1RwNVCm0iDOJ9flBG2tpZ4+2BjbbCmxbYB+TSsvcdhD5D2ZTYh2+TDbjPRsttTZV2pZfZ7OH7NWRg4kOopabNmpRvXeR9lJDJyTHg4zWVC3qiF16dm7sxmNojjOPw4/Afhx+M/7k49dlftMEmcicE+AXUB3QZXa7Yr/VI/Ro5YYIfQ6oOLLrmsfu8gR7NfX4zXUOFUY3DWLHpvEvjyuMrolteQd0TWcGin2LTtmvtevLTWg39I7GNMBtPjtDpVHUzIb2INctk5DtuHrOjQL6W1NXtQZPtUus0hendvsM4XTr0JyUZ53UUOwy/0cZx+HH49Mj+/3BLGmS9nKDrjXAzu7H1ls+IFCQVR7EApsBimsAWUtgmvDJijrnktbnNIvgrMYqBUn1ddcri15HZeGPUScB2tw9iXClgdyfsrqu8rVgUe+oeH9xLXmcnVdlYhSJT5C6wRt+n23KlPRRs+QqLo212L2AGxODSWMvYs0DaelBzdT0PNR6iPx4/qCk4E4xa9SLFhXryGwTzoTiTUYHUY3U43dzWZzWhxkpL26qzDhXhAMrKvt90npOKEbMKe7SY+k1oaVCTgLgN7FV7CmPTjCO4ViqnrbGRhsDX+6ceUTtE7CKRXYya9WILsdhZYlkbNjal3vWzUTW2ZjurbGvREe14gTE6Y0ulptNh/LJObG0xKrZ0if01ZAY0Th/WcWS4ozpnXgp1wTDF+vLIC8k+h1/pKP3nmlvWQdwBYpJeutfBwGVZJhJRX2Kssalc7MKD9tiX1mCMmKqdf7mp9MH3pr2RxsmQOvsS91teZM/YDC65eZOU6gbk1otnbvOtPWDy0Io49nrRAO3uVMnuVdqCpz4lWFrdMTWcj9DjPWc6sCq/VZuMUJ2RxhV2z0qM+MqYnamGWCHBVW7KCWovC+lxRu3Td49YiwWFWU2BMvzWwCnYJzFpDp8g+uYLk632/GAmZ9chMBZhCz6vrfY2+qaWzd2lCRLB2HQcClCZN7BvFVOveIo83Sq+nISDH4HcWmVYCqGwscklCZbO2jvsIR9Wov7foDuc9bY8xmrZAo7YS+JUAnZnibnGQ0qUwIOGUZKXY3XpkE6rOYwKvfbflXmTOa4ddFpaLIp1yHWKq/o6uNNXnsQaJ12myr9crLFbK/aWdKTruvMbc/wA/V0xTK6hFoyXn18qgPr+i23xcMILWe3P2RFFB1h+ZfhWq+BLOAqqNYnrSPOBtjE9Xs6S/RCHJzAx+OJxoWCTQVtyU5JWY5i4iEqWwMOp5YKQgf+4t1S9asqALIurYth1oDHNp+Vj1+OaDAilbyf06D8ruanK1qdS2neboVVheiKvzZ2jtXr01Xr7E1WbNfTKH43ZGmALAAPsqFvdCH2+YiyK+ht9lrL3T06sRRqepKUwyYJQVZtX5E8nuWoLcsdZZKy1Qj+rnA5GBmODnmc2K3XrkOXKRQ4B3xEClaclKIma6+yhovezriEduo5fome76+xVMaKZ7h7sqoFmWzZmGzVfOFyZZMpU0nt66bGv4ne9LruNO27ts+NH8uEXWmpocmeoq4q/Rq8I+2cWwK7L+m1aDKdX1aWBXWj1zbYg6TEudodo02Ti8piOxeUe6DXplGIyUE9hduf6Oc5/Dn8IxXman17YUEGzNrgcPsqs1i9MCnhIdcD9cVyuVYgJPgSLdmdWaKM2FOc9Ryij0p2GbAIFeccFV96l67onsnya9dvaHteY2FIb165ZhLXbiWiqhYAYeMq68zqWMqyOCarRnE32qVZ5MVOpqvRuqKNy/K61MJlXHh0NAKBZLktW3E50JrHoNSa57pLnP4c5znOc5znOAjNZ17B+wpDtl9ZlydVTNRuzRb2icucKKcP2gyCKqck0GIg71RVPkNicxLnruUUStcT1JUn1+YprbdK0Pk/ZC+5WdLg+uswRryd11dc5r66F/5YqtFSmftntxyWDq5ZS0XWaPhYSbckjM1HFY7fN9ao5s/bLhXnptMY1m4SoYp1OQSaj1TLOtZA92Kdp43sJznOc5znOc5znFAOa55zXVFVnZsrqDH1Tit2yezSr/ACE6jaXg7ZFfaaCrqJt+Wpt1HyZzpzzOnlJpm7tMaU2HeFDT11Dl6yZrTmebaXsWXjz0Gp9YaQVpyUF4qTjPwTsoT3cGU1c1RmBkVNVK5Tu6bYYZRGXBrTCSj2TkENGZPKg8L07K2a0JMIgAzXph3p81qjr+YhTbPXnOfw5znOc5XOyZ7MnWhzTPYoVGEFsvHnNjWYoI0XFai5N3Q+0PgFBlQ6FRy+2C2et/ZabiK6Ts3wGLroAGuv22aaGJ45fR8VUMF4QJ1OxILkqpRS3TL1AC7pmlH64gR2EDPA/bAXXLNyql0NJe3NwNN68nE+OqdZNWk6DGfEVe9J1R9pxxq7KnNPqcsCUKUcTrzlUC4dlc5/DnOc5zn8ecivZobEorPYtfIocnEcfEZ3fS4waSl38auGPXNGKkuikWgwBgeLwRVGkzMutFEaHDrFe8xxtMgYSK+vybFWk6VxbcL7Ueevco5uxRzSpmhqkVvgkEzuyrVuV/MKo1VNfZ2t9EI7PXtJJmSrE9DczmbHieruN3GyhFqctoccrJeZTGLOk3pSbJKpYPGPPOc5znOc5znOc5zi1YZpKuRzXqDgKjFvIZ7lIDKS55z98oSqjY5YzOR2ZcTRmpR1Qde5Ycm9VVbO3w9DeUz2Lgpe/u1gKNOG0xpqyaa2hxkU+lNbgyVmnw+V44P5eetMUdmqEAmGWexRHSiMo+3qwlTOspstleu5GPCwbh6l8eQcQ5U6O1FGv/AJo7QONC5yP0cyGds753zvnbO2ds7ZziBjmslhmnJioLIG2Dg2eM+WnM9rXXG8jIgbQY22CTqKqT3thmWarBo7Huvd+2azv7NnemmvvbKmYHeCqyj43ab/R0mvSep2ya9CU5WPGcFis+GbtgqrHplZAhimLfvT4pUljw3+M316V1axA2KSosZTXKz5bZSk3UqyMi867IHQRmTsIWjroM+zpL7g3AP6C8ZMSOaqz5TcKA+SbP5iCW23OUs+Uo2dL0bU09kD5M9dNXZF51H5t+vH1WcVYE896xLYmuudOEbUXmPCVuiNkFDYyOiqy1B4zkDOw6sQMpULi0Rx8iBNDZcog2JRm3FOpPSM6wUFdrx/fNbZnIvsa2VpPpYljt0DLFUZbJy0/sz8kheMWBKyLcTonPO0f0gxGe5+EvQZLucLpiDuYeE2XyXhJLi6MUG2B0oIe3XRURlAOwyBPaGD0X167Jyy/YtQEanGz7iH8izzLXn63PXO6NNn9VxRSPoW7ntPY5y3DJEu+JrpghVRNSH2Vj1ZdYA7Eey3AS222SUVOxBvUSxms3fHnyrS6YXfIFVzheRFuuqeZPbI+s5Mt1/RVWxFyXqGB5YGlzqb2soby8lEvLq2V8inXZszZLWd2m9ZoGpll+2TKX3N/83U8n+WaLy9AW39maufIJ1GytNZ5VWOpZjRtszylp7CLcrhombF+mPfqOzUWQqxqylV/MSm50zYSdVsbzfWvAlxGi1jnNA2w7u+xF0bS68bTnmxRwkgVlboV9VW+1sQU7JSk6Q6rj6x5/Um/BlccOA2a0fqvyOqJTn7AO6qPYMtuLmxsFDK/qDNzk05JoLPJn5tsd8JdVRqJk95URnRHvqzdSjZHXboEr6p15WMwG1W4DEAqy9l21Aa7ca4Jy+mjCuvJRSBctB/ULHOy1Z4t656zrlyzUaRnikDBsKRETKgjEMitO5bXurAyf9Tpk4ZH1gzESqbcRibDua1IBbgmVHzYKgXd+vTsz/fix+6aAO8CCjKDe3L63LLND6hs09ei/dPG+RCYrS5+P1P2+0ai9qSRWsoSr3AxxOeUJZgypiKThICa+3HrWw7jaDZtd6ICsnTT7C6UTBtUGd+UJ5Ht4zWb6SmwDIONS/GHZmCd9R+qM14qTOYOGcBh3oostoljsDiX1wxByvQEOz0XTIkJGaTD4IKxrqhF9JNdPXDZZRE1mnacMlzN/mvLI+URsoi0lB26FRVdhaZrE+tmouN7QktftMerqqkKyROU7hlWJX1TL7c6JbWv1z2W6PNy+xI9S7DDZhkyCIuwZByfg4mp1Y6i/qjtiezI4TyOPr3iF0tbs3Tk2dUG3sUJ1dNUk91WUIe1d6ACSTrHdYVtsz5I3vVsV2ZOfb0o6rFdp41G5rsM1qMrR2O00ZMLlKko7XCg+vsEiHSeuVy2oSLBSIcKn8xRjGy1FOuxDa0SmJyuQunXemgVuFXYbnJ/v36ZPuZ6q9hFjx7YLRuCf1BxinJ4OSPjuc1lmmJTgl242UY5SS99OXdPIS5x6hBusempUPFgyvshwCjk27d0UEP7PUYN00VV02dGdMi1teo3KReO5K6NumRWilJgSxPUSmwHylx2qmqTs2moDF8mCD32XQfJK0hbvqIA6rHndHQ0qCFfjGWhVrDvqKrYslD3VAEnrFf1QcShzX2L8zS74r+pjsNxNCi32iwWY40PqN+aqrBqV2UdxAdYvLjLxUuJfb8b6a2svb2IybP5dtwcVn5C6tsCdpNr8oqUnV9o8xZgvyTF/kRGPtSbPk7Hb5MnzqTmvLq2sUbPjLN73WbHYU4bKW+QnTeopFOcBUYrupipJ1kUksBnXmff9eIXJXkgOw1M+mI5XOhI68CWrxms33bluaTmEp8dsM+U22PTYp1jqD8vf59Mg88TXKvrs1CJeySR7z0w8ceMK5teM7rUWGSfhjWyNJqc+vgyqyB6o+RUDJRUjV2Jdm2KAXgPX6FmHggNtd+rkdKpnRTgXhtdzkHz28MnfisPv/W5yfGTP0SRKhOAXJyS/RA2FlRFUcWp2rsgosCHYo/XYkXppj7bx+mwAsaJPPtUUokLbG9CWwnkfWflDvPYVm2PiUz40uKaBZZ6ZBGhyT4z6nRabU0FcNr70UnbuZL2Z6GePyVdLhdfrxsKoyoII6kIRkOjFIsHEaOIUXq3v5/W4xWzS+ra7dss45J5Z5mU+xmnrZsofytf7R/ls1VTELdKTHu0yEOwDzvbHMmfskX+m444qrkj2er0chXv3Xa7Z63XNdk6xK4utPNiTUS3yIpbyUOKlWwVopnTYk215B+dZuGfYDhyVLFGy3dKKx7Io5kRwtft9/I+hqy3Q/rAE4vUZGvcvudhNSc1jKGXuzZCJ7CtGfaP5cue2sVVU2Pv17N7WqTfnvs7Wz2G0/wBRBkjGf5d5BptHmnxyDrwVsTU7tTxpVl11RUkZ4rIw9o4RO+IlMvpa9V2/HTgzCiZrtQsU9zNJ5q++jhah2rqOVsrKRiHNQ/SLqHiq8LGjGdlA/wBANk6AZKzvhfsyuky1e2F1nOz9i3brt04kgHec267P0wkZsWxZctS3bIUPSfXNeX/kJqqcTT6qkAHMucLetmUEoARbVPExso3zGXPZGg2HnsTtqK2NqWRvegb5gbJwmzppjlSozbn2z4vbERGSSdWWSO/oM81y/Jvrt/pA4tyANtgsm4EP7geMVCuFM2Wbto/YdVjNUJBeo6/+i7HC/GJ9M5HYxTvL60V/tjtLRV2OTbbiytRwG3lZn3NiY/m2s2HfZQ23JiILRVg3VtEA7ZCuqrwrIA+xEZLb+9r61mp2nTs5ZPTTEoDirsAy7qaq3f8A01OQyS8YHLOR91Psn0OSkPWW5b7VVkOH78efC+ztWE26BuV4PSHIK/SnDyrcN3s7gpdkylj2+UpDXsMjsKAeM1mtOU/IyytkObM7qNYumdmaexr7CGHdRROMpLnIKxyw4z0e2fsIkLnqvKj/AE1yH7T/AGh/dr/37n9jf5Y/3Q/xD96Y39nk8H9kv8Cf2z/fX/xSyv8AeP7h/wDWH+R/22/8v/4r/bp5q/41wf5X/t0f8m7h/eP+VP7J/wCHX/vb/Pq/4aZD/Fqf/X//xABIEAABAwEFBAcFBwMCAwcFAAABAAIRIQMSMUFRImFxgRMykaGxwdEQQlLh8AQjMEBicvEgM4JQolNzkiQ0Q4OTssJjkNLi8v/aAAgBAQAGPwH/AO4JRhjM6KrCCP8AXZfMZIsbdDtDmujtLMAnI+Cc6xxAm7vH+tgEUXR2ToP1RRa3oOeirJp73i0oNc7PH1XTsGA2h5/604kYV3qQZ4rrRq2qv2RJANQ0z2gwiQZn6qujtcCIUe6cP9ZfXcFOJ1VO1TAPBbZkHIyCps3y0VgprXZ91EWOxH+sOyM10UwOIX6uxbTSTkHDzRa4w3RwgdqmzMxl5IBssjLGu7yXSMb95Z4DUaf6vEwqisrCFHVP12qNoxqFjHB3lVE0LfeBV8NdHvDTeEAKmDJ1XT2dWO60ZH/VxxWyaq669GkKS4Ob+rJRDcf2lS1hjuUWlmWbx5Jt0tcLwh2Han2Nr1XGIOjk+zdl4ZH/AFURiqgzP1PsEHkpmZHaEXWTqfCVBHFpUmzu9qIY/ayaaXuaFnaGHMdB14lNth/csutvb/qu1hmmsNYBuu3e25SuWq6Sw+8HvWbqO5FXLWzc3UGsK9ZfaGNblecfFXbQ3HHB2LDxhMZaEEuOzaA9U8dCrNlq2LwMn3XJ9mOriz9p/wBUH1KIbhosF6rHonfqrZnn7qaLWzL7P3bRtTHHPmsnO1ivMI9FbFjx7pMeKi2sWlnxRRSxwu6YhXjD2478aomPvbObu8af6ox12WnNGuJxV0lf3rvK8Fe+7fGJs2EH/aUSBagTUtF9vOPNXrJ7Q765q5bMDxk6Z7HeqO2C0CoNHAK9YvvQKsGyY4Zp110B4II3mn1vTX2joIvg9qNswDo3+Knmt0A+yf6x/pDzjSoRhSsFIvgjNqAe8Wn7mw8f5BXm3Z1GK+JusmVsv6RoP7i3gcVBZjgd/kVfA6zaiojeE/pYJJkEe9kUbG1Im7SdZTmOFe5WrpnABWQh1SQ4xgVQGBWuajMkDtKeI1AUqiJ0CJ0A76IRApM+QRG/8k/coOKGw6u5T+SdQTFD7cV1XcWhEAstNz3XSO0IPNhbs/Wx1/wmUA63vDI3C09rSr10yPe97tUzUYPZnxGqDulrmNDqhe6pcCBoRiOasySBceM9D6IEH7xmfijAiBU6JjLWYE50Ks2EwJmMBtIvaAPvC1sVq1XLocXC92miZeaHPJcPQqHNDALMBu92pTWUrIOtME9oODJ7Fq0a6Ep4gbTnG9ulCRFJ/HgCqY602RmM04XQSTWc1LWgVxiEb4B7KKLgFKfQTgXYYa/kWnImuaEZ/wBAFowujA3tocCpsrQgjrD3ueMhDYvNcYwlFoJYcIOFVN2Nmo5wg6C4Y0rQ0qjWobJOponGOvaACmCdswHCm9faazV9fRBgIdcb0hGsfyhdFLhg6ZXvRPs7EZQ3WdU1zoDw6d0AU71DAW3WnuVg92DnwZ1FO+FswGh2W5OLTdtLlYpSsqztKm8Be4GgTGNiWuIGmslAudtOaCRpKechQbyg3M/hlzWOJnAIG2IEiqJYMscXFHo2EnepdaAbyYlCWhwGcqW3THaO1UI5lNeGyc9OJ/IhomGjayRa3A15qEfZIJCH3meMSukG033gCDdKhsFzRN17ZDgPAhGGwYcANJ471BxDOjJB0VnOBr30HcrIsbV1MKyaeSfWvSADshXBFwm42upqeSY0QZvNd+0/wnFjrsuruaFaW0Vb1eOqL7R204Wba/FiVaETca3pK+8GmO9H7QQYDHuDdC0QEx75l9qI31xVm14gP2T6r7VtbcgNGgGatHTWGXa9qe844kZ6BdFdghzncNVaT1ooBrkEKYYrn7Z/ouMElNNqdo5J1nZsIA03oZ60V3abq04qgrovevauXvTyRoSeK6s8pT5NRr+QswfiTrS+a9ivNcomVPsgLBdK0w3C13b01xkXjUaHBAPgOPeRigIiXRPHApxI6t3mWgkqwptWjhyF2U6Lw+8c+RuqEbFrJDHgkfvgKauBbBOhna9FaWrz1ousGea+0vIBusuMZjed/KDbQkvF9041GKc20J2mtkZ7KZYNjqkNOMzRHa2bIdG2DWWjxVtaGl0tAOMGJorOzJ/uQ5x3XaBWT7SIFnIGF52QKfZVI6VkD9I9USw++Re3DFF5Enbk7z6BMvMEAEkefNEirjUaBXSIKqPZKutElB1s+5qM0WWbAxsSfmVMUOYz5lEhwvZgGVcy3UQlj+dR8lAtHDw7l1C79X8IgAR2rNQHifrVWxccvyFkN6ABpCkYp24+xwNCMDlwV6C20BiDqMEaENdF6MWn4hwRY+BaEFrv1EHFdG4zdmDjgnsJhxfNnviiDCKlsg7hkVb24Gy0tgbogp8iAIIn4c0Nmga6a5ouBq6wsKbzKdMfFrDsuJzTW2TSXNYIzzX2d9Npgp33kA914iYrXaOa+0G8AW2Jazial3grB+GzAPwZHx7VaWk3Zc3lNOZVpZskNe6aawi5jZ6NuWZo2ia6zdV5vNH6roiOCE3p6NxeTjJC+0PcYYQdgViih2V8urEJjcdoScjHki6JDQrSBF/Fx7U52rYaAhZ2YmUDbG42ZOsINsWRIALjjROLbN1o7KSAOSAoDMXZmF94HHnK2Q7/AMxYcg7wUTe3Fwx5K8W9Hxqq4cPMKQZ9glwHEkJtnDjfH1J/IVid5T75AaMD88ltxhC8VsifqFJweI4ELe3NS4CIr4KztG42ZFdy6UbN9ri4b2HzlWYczZDC5pnMhQyDMDtoe5CzFQGtl2NcE0umDj2z5K4S53SPJN7EdnarR1A7a6M742fRdG4S8Q+mbne6EbRraGzaHRWDMO7FauOVnB3fUprQIJeL4xuzgFasDusWhm8yrJlm3/s9k0lzpxqh0xEXQ+Mrt8eSdBDbMWA7jkrIAUc4zvpPkmMtZfaNv3Y92hoto7FpJaeOasHTQ2sxqaBNDnbBe47yBmULrutHbM14BXmjZOG9BtnJiqHTW1BUxRRYWdfiPirxdJJgDzUjbfWBkN5QN2Tm458FDWAA/ET81IgToQQrtpDTxhNkgOGBIX9sQc2lbBO+US2ScwMFJ2ZyzWfFYyPrRFo6jaD8gLuKxLScx5rYMPj3RsnfCaz4fd9FexE7XPNER1jNMnKSJkwFd9x9nR3PBEgyLokaDAq0DHyx800MT3pr/fDCBpSkhOa3CIHNbJBN+D+0aprnCXdMWtPJCCLjZE+KL2uENvFtcTESvshaTNHHtTmz123ndivOMAmjnY40MK2aHbVo/accmjPiVZBrttovOIxADSe0qALl+5H6msFU63fmQz/AZp7L4N8NY05wMVZubRjWOhu8ldI29AJqdCahONwPDbDY4/JWV7/wzaAGMQ2hKnKzc1s5kkJrHNm/rmE57iYIBphwCe1mzgN9dUZ6jcz9YrjQBAE1nmroaKipxW1aweBWz9oBAy9Fem0I1z7l/ftMfeAKrLoxopZYjtavcbwlypMeCq1vYvRQXw94p+RFYqmg3QZxOauuLRSkIPa0O+Jmsab04/8ASTpo5XXnAwD6qzglu0ZH6m0VuxtNq8w8aoGb95l3g7MFAOMFjS2c6egRAIJa1xu/pwgIODgQ5wimBiCN6L2NkWo8BPJAFzRLA4+faiy1htnLXXTkJ8VdsWANvOaT+ytOxPJq4Noe7zXSO2bzqftA+imWN2uM/pGQTne9cvnUnALp3bTiyS3Gjj6I3MWi+47tBzRDmy51i21cNMSm1gh13txVBJBnlMK8BLbxdu4q0tGibrC48ArKZNoLJ10Gkk/yrQuEzsCTQlF1q6LuMYUGSa45uFcJMTPBXrouOdIEVpSeeqphBvDQuRmSRMFElvAkVKrLRux7VSzJEYl9fJQ24Bwqe2qJa20nmgXyCRS9mhNgDmLrgfRD7va/WIPasHjvWKwQw3pxc+Xe6ADTj+SDXxdO70Rs7pNdn4SPJXqmMRhEeaMAREziKprgIlwj0XWIcXXmjCMihZvo4NIkbqKytGXg6LxbnTHDMKhpcvGMooVQnZFJyTpJDgAQd8ol7qgl0YcZXSGDstcR+3FWoNRdLjyRDGAMDid1aK1oLznUPFM2pa1kCc5n0Vpa7RJoJynGFtUbMDtonQAYJHYaAK1vBpvRe0DdO9Psp+8eGNnQJ0D7sZ8M06XAQwBWl73gGidZpyTxA2rMBCDWJbNQKwhgH2ZaTIoN/NRjtzA7KpvSmaucWhBxAbLjsY0wEro8S6XHirrAC5x23QoDReAr84V60AZpI8kRc7oQEXhoRJCIa8XdHXh4qIp/1BHo2t3gYK6L7Toq+zHxRIm87DVEuMk/keCAJhdY0zTCDiEL8CVdI2Q8ckwta5waZY7GmYKdEOMS3U8FcLpkOIDhtNOEJ143i6y2d9FdpUTO91VaWhresA8TiLjqhWLtWuO7aOaeRhg0aLpI6wgiNxTm2kXQ8uef0mqtCDF0YcSrKYJMujkrN1zGOTce1ZtdfDt7W4q0tL8AON3cBgjJcWQXOgYxEBPD4Lphx8exB7et0cQcNS5XyeHA6oluI6g8ES+0nZAkYknRNaQIBAGcJ5a0PaXB1c+JVlYtq4BvSEUxQgtbTHIAUnyCcz342pNa+a6RzgcgG5lBlm3i5AMZ94cIqQnF1dSqDtQvMvN1oVskA/C5T0BnVjrpVTaSNesOa6xI3hTRZFaLoRN5rYJ/IwUYM8QhQxMQPFXCWupQjFXiyIBU3ttl3Gsg5olpcMRhNOCD22jSzINKZatAaZncdeCvgX2k7bc5TGtNRhuVR0bx1tMMQnX7Odk7OZBxCuH3DAP6XZoMtD1nxKs25XKnhRWp+O6rQjQXv8sk2YkswOV7NOcRsN6snvO5NYwEDB7jiSMArpgw65hulXAY2IEZu3KwL3XLsucToTXtVkKbZLKJziQbNjsPJC6C4yeHJOhk3qDcrJ0xWbo0Ra58E8gAMSm2c7Re44eKvAOAgc49E82jhWZAr4ZK9NS2QIwaqzJTg2C4mtFee6yB3y9UtGn9pg9hVQHxlEFbLo/S7BUdTQqqoslgiTg0SrR11gE+76/kcuaCwAnL5qlnE01W0YF3Z4xULo5BmhrgrjWi9N4Sb3YjfYGl2IBAntQLQRqNe1AiW3sDkdyvOvwKSPd3oCye14iKnuQbeMjrA4tV8Y7kcnBzXA5GKkJsDFvgVEUrGcpoInpHMBG/rQmsEgXjJ+t2Cso6zg1hpprwmU6d5EY3j9VQZE2rnwTpr3KSIYx2zvumFawbznggaADBWYMOFmYHHMldGzC/Xmti7fujtKF2prdn9QxX2UB8GADOcCqvNfQYGuO9G6ILSCZ3jBFgYTtBoynXlqjfkudkfRXjeh2gEHTVWhujjJkxlKo9lnyV60tQW69GEbNts20Pwlgae1Qyz5OJ7porwlj/AHmlbu0ezD2YJzrheXc431VT+Sx81da8bt6L5mSa8NVdbLRiM4+SxrrguqARjOXYq2pI7leqIxII80WC2Dwd4X3Vs1zc2lEhrWH/AMO0bhwcPJEPG1FS1ag9qGzDr046KNJHem6Co4zKs3M2nHHS8BdQuHZkMbvvNFeSc+vRMAbZ1iszO9NtHUYXl0EV5plgxsFz6RvogLxpiefmnWYdF0bRmrnnJXRwlFzJAxBzg5qreA4BF1o0B0uOgBhCyIgXhLoxGYTmdZol4GhjzJTGEwTMWbKuk5kp/RiXQ260GMdSnWj3tdtftA3BXhZwTMXsAFIaXnLeod1vh9U9xYSedeavgDHa/TohZ284C6/AhyuP2hkc+Slrp9pUkwFZNnZjKqp+SlAAwujMRkQou7zwTAXbJwcnsGOKxVSXH2Ag1G5bc3SIKFpZO2xvx4pwreQd8cbWhAW+J5p3d4q8BANTroO5NuGBeut5tiVdFWNa5jHD4hiVZzDjcdjm5xkfNPMzRt13ExRbdn798UxjPhGC6Jo6pgu/UcShswJwQFMJMbsFAJJNJ11Vn8IcDxQd0sQa6p3Qtl9pv7ycgiLMX7ciHOyb2oPNTdmAKnf6IS0m0Mk3jeu5miwdN28GupGQLkXOaS7qtg/UFdXkMtwHmsQBhVCv3fwgd58k7XL1KuWnbmFX2QCJXWruwTWQROYJPinkYCg4D8lCgCFezjIpt9myechNEz0eGdE4Fmy/GN2Y3oEQQalOZNLNoHMovzPtbZWLC57sAnCHCsPaaYKTFcOSoNkmab08/EGxxzVyRJj/AHBPJpfN2vZ5JjXP+7gkBMBowmgwIv17k546rKBGzdSk3tBghaBpFnUnWGoWgMMJndvKmIEdylv0NVQVLZ5KGjajH0V4im/JVdAJ4krpGPi9kWtrzlBp2DGLQ4/JOYyycN96SexXujkuI5xgi54NcGZ802GtE9w9UxrroBHB3ILMd5QlzsNkYdinx9kRihAeSpPYrS2xvG6wZbysAOH5PFQ1tTvRE8kDIvIgCCDh5hYXXNNQvtT6T0wE8imftTHXjLsBkoGisrcCbuI3FG2sqWoz+Ib0C05ymOH8bkIFA5XQMwZTWvBiAOcwi4gbP2dzrughWYbpeM4xNAoqAX9wEpl0bLf4lEvlojLGuHchDTAwHAYBHUnFGawnESJC6o1Mmq2i0iJumcl7vhCzdGqEBoJyJpzX3Nnen3ZEHmV97a2P7WUji5ON7rHrN05SVXGIkinqi4GATUuoeSpM81rv+ZTnOiIiibA+aJeJPw6IA0zgfJBoEaac0GM/t2YhvmfyouuHgq4qriHAzgg8HZNHCc1UYr7fZ0mlo2d2Ka5uTapoPuiFXJo9m/2PGQciIyQg1JqNwTGuB2nt7nLpHdV2ywfEMI7ZUGMpTDFR3zRXXNN6Aacwq1Ac5xPH1UzjhuCMATGCjCm1XHgqB134sUAO10lXiWuE4k48lVga3mFcEcf5UuF7vToOuI7gqgA4EOddnwTeja2BS6CAPNAuEQ3KJHFS11CM6F3mibxu51w7kW2TXP7QO1byawaIOL+GaaJFoAJOzXsQcb3d4I2bXG8caYD8rEoShkE0gnZNUHOPR7I/bPmgaB2o6rvmm/aGZUMb06wFpqbI/E3Tki4BAjRSau8FWK+x8n3kVyKtWtmBg7gnQAXBouTvjZCDSdoAF28mgVs4YhsNnC8Fdm84MDZ1JoU4Ay4ujmKdygA80fBNL4IlAAQNP5U3nn9vmnO6I46yIQcegEYFsq64NcNcPJSL5KkOMZyr1y80YnEj/pOCPRv6Led+hlC8+8YmTj5LqkCqmJ4n1V11neEYkx3KktLawCHTyRN984YRvxTKEXDSsQi1sFx3KXuJk/jYqhHauqVX+keiwUfJG9QHFpw7E20sQbuL7PI8AU4TQiHA0V6zvBrXS1wxYUbP7W3HC0AofRB7S1zToiGgJxvcj7PqijNaGO7+UA29crQZpoAhweyDzkprzndjSU+aguk8skxjRteCbSqrkopPgpmSuq7nmj90zcMYQ6RjCJyEUReLQ3c5iW8dy2XNtBkQarHLCYPcpk9k/wAq8yzxxpCA6PAe9tHulGTJjA2ZB5Gil4aDliD2oukcW496M3ROsHzRigu4YTwTSQ7KQTQcEQwzxqp2ROnmgdCiRhP49F1iqhp4hVsxyJCwcOfthXpogQ6owOiM3nDHGeKYRaEsJ0FNxRDmxoaKbsHcBVBzdkkIx1RqJ8V95c1hrQI7E455J1a5BTid2CqcQZ8ExzX0uwZx/lF/Rmd57E4T1cPJBwoC4bITn6+yAAXnqgokmZWB9htLUuLxaQQDEBDoTs8fVXmGqADjcmbhwTS3HQq71TvFCoc+zad9VeZaAu+tExznTXWfBRcAp1k6r3zyCuzG4VCIx3ol1m0nXEdyrA3fk4AJOgW3dZ+4wq28/taT4wqdKewLqkHjKwUyD4qKrCZyKksGGIdVCSXaVrPJNYDdzLYuh43SpsulJioBkU/dCrEzhEH/AHKrmyMs0WWbaEwSU1uAIvcdEyBG8q7eAjGEALuU7UGiGB4b1LXRpTMbltQZxjCcJQgZiB5IwinGVKukxvCPFONm4i9iNU0vqSqJpjNC0EhXJrr/ACiCLw492oTbsNmuKmztIPvQMUW3Kj9NCuoOTiO9OvBvIIOvmOCkWgfzV7ZnvUT+QoMMTgBxX/EPY31KgOut0bsju9tVIWBlZLqrqGmlU6GTAqQixzHRdwB705kP3G9TuTRSzuijXYFbYiKho2ge1OBw40RN6gpGXMrbsuM4clFBEgHdMqjcZQxH1hVXi8VplC8lM9VXpV4ySQKBGh3phmpxEYKcxkr0Qjo6oQaOaEZLqpn/AAxL3bmNz5lA3do1UZZBXm2hJGs+JUPrXMChU3G7x9FAEEmaGnlKx30E9q2v/bCmMcqQpxGUKCyZyRpH48u5DVAZDADD+n1WCy9glSMNVekt4Qg8OgOwOAQbaYj36KhujMwPNXw0mMSPHCiDRZC6cAH48SnvtHOgCk6lXWyYz4KpNOakmQhShiPaRNfHmrodiJonDGqvEbWUZZJxIG6EBaTc3KhmlCoLTE0KusbAzVa70LJrS8kwBP1RdGCHVm1fkY90bgrsOjd8lQt7FUSeKvtcQj2LryTjEgq63twKq0OOoNVWzkHVdSngi1tRrEqv429Vcv7n+0r+4O9f3LPt9mCqFGKw9sOogce8ICMNCmikHAkQQdxTtpzvrinEO5EzCGxAxcUQRAFaBEg7OCAiQAsfNVdhvVDnyQrkgZPknNmVUtbvxTRBoZ3qiwrFDoo9wcx8lt/Zic9lw81T7NaA74W05lmDk0yUQxpax/Wd7xV0CgGiP3gOevgqzGpVTeGmCi7snLFFzWup+mPBNqI0QBMSaCKol0mcaeihs8T8lxz0R/EhoJO6q27tn+9wCrblx/QzzMKlnau/c4DwC2fstl/kXO81T7N9l/8AT9V/Y+zf+i1Usvsw/wDJaq2P2Y8bFqr9k+yf+l6FCfsdkD+kub4FUsLp/wCYT4rFYKoPZ6Kju9Q7tQajiJ3aIO2Tq5CuJxu4rYMx+lYZVHmm4YoQ7BO2aKMUIjfAyTYM0mlVxVRS92q8DQnargdITZb1Wm6mw29rCkga3TSeCF43f0nfkgQBJ0NVBB5lS0RPNBofXQGvYVdY17j+lTaMtGTw+SNwjATjRNbsDTMoue4cqL+5QDeqAqajfiquB3HyVAcJ+ijuXNQ7L8LZs53ur3KL5A0FB3fg7IPJCThkQspWPcqz2LNVaFSn+UIw0uOhEjtCADGR8DU15sQJxTenI2qtExRNuBoAwhOgbxinNdqg0NRANdEYOM5ppPxYKtMUOKcXR6KlneEVjxom9bGv1khUn4gD3hOdZDjvR6SxFBiaB0+aYelBZ7uzervRAtRqBdPdorjbzp2jk4cdyhzQXx1utRYmJoLvyQvX2UwmZKJkFudIjxUNAka0U7I3RPiqsdxikIu13raE1xlG56KHYbqIlzsES1vskhbmip/G+7snu4NJW2GWY1e9oX3n22yH7Q5/kv8AvTncLL1Koz7faDdZthS37L9sj9d1vkv+7D/K2AX9r7IP3WpPmqfZvsLuDS7zX/dPso4WfzVfs9lyBHmv7BjcPNVvdiNbPkfNNq3GUC11nOZwjkEyz6IuGBcBTiqt8SjatFCodmuSo8oOm9CqIA70BQmMFsidwGCqJ1yX9sFww+igWNwyMKRB5ogUHC9C6z4fkGo9LZ9XF0EiNdyDmOviNReHajsHg6PNCGifeOXgFAe4kZQhQ3coUwQCjAJ7/NNa1t0TUEAobI8FDaaxKY55jTer7HTqFBUCjQpRI6oxlXMlgsPwbwEN+J1G9q2nutDozZHaUBYWFm05Q2+//dK/7R9o6MHK0tI/2hf3LW0P6G3O9yAsfsVlJ+ObUqHW9nYD4WtbPY0KXW/2m042haOwKoZzBJ7TKp9di38ZWzYPPJf2Y4uaPNRbW/2Zm6/J7AFJtAR9aqJjSkKQ0Timw5tNaoQdr4p/hXbS8RGMeq8k4EYhXd6ZXNUqsJGkIHo7rVekXjpl7LxhoFTojcicaoNh9MiB5otdZCDiRTwTYMDGSPNF14jOQJTptTfwmaq80uOghR0hcJ7FHSSNJQltFQOB/UgLkTmEai9HDwV82rDGV6oUOu8zBVXODRpRQHuc3QrDvQq47oU2huhbOCgYK8cldLU66yUSWwFvVG/0Q0KgFo7U9UeqzeR2D0W242rvhbRvN3oi2ziybpZ07Tj7JtyW6WY63PRXbMCzacm4nicSrxs7jfifsDvX3n2m8dLJs97oCFyyc/8Afax3NUMsLMftbPeZQDvtBbuZ6iAou3t9o6/3YK4HE/pbQdjUA2wIH6oHivvrWzadGguPkvu706mPKUHF0D9Ruj1QDXF/cB24oXgQO5XgCDv9mKZbDA4nwTdyZZxUlVbJ1hCAoCJrHhxTrC1aYwN4Uad6LQes3imzhHDsQIG0MJzCF1obONadhRwadwxRewwTkKKjg6d/ooLpj3XV8VjcI0X3loHDcfBUDuxGNqThmoDgJGdVMGNRUdqgtTZMaVVXAwcF1TM4yVnuUHaKFOKF2Kdi2zyCkmFdajXkEZElDFTcPsvOMN7zuCuNEN+EZ8dV97V3/DH/AMirtAwYMbRvsDWiXHAIXXND87V3VbuZqd69+2OZOw31UWd2yH/02x34q85xJ1JlBz4s2fE+nYMSthhtT8TqDk0eao51MGgQBywU2tq1gVLO0tj3eXgoZZsYNPqAoNq+NBT/ANsL7+Gk+4Np/oOaAsw2z34ntQuk79UW2TaDGBPa5XjPE+SFx1dfqVQ3tyF70hFjuxFogAZnPgrz62pxJy3BA9vswNcc00POy7qlOeBJPaEDSmWvMIBj4bkHVjcjeF6DmaEK66yu1kUEdqGVImFfrGsqniiHTB1EjmEBdut4yOS6zkMAfFUMboUtjeqtdyUNviNy2CDz8QtuBRdWdMFE+zaPJC9AGiizLVtOkq6wGdVN6pyUlbWOUKmCi6gP4A9FFnjm/wD/AB9tMJiUbOwq80fanwarziSdT7A60Is278TwC+5ZB+N9Xcsgr0F0++4+ZVSba0GLW7LBzzUB1xujdldY9ipaHgj3nABRZTOdoceWik05VKFC1pwjrOjy34K6Id+kf25/+a2idzcP4U0G/IBRiFVwhQDKcZrXmqRIGJQJNCoI9CseSrVG7HJfdWjmAZqj79BQ1mPNXXsLQsAQdVLBzlVEHsRunkRiqiFu3YpzQ5+sESFTLRdYExwWVEHse5jj2HiFJLWO+LFh46IglzTp6IXpNNCVcgAFfdGeSqZ5KpQr2q8a7isGSchksVRpxUuMuKwkaoS1QG0UyrjMPePxfL2hz8D1W5n5Kh2zSlAxujd59l5xDGfEc+AzX3TYPxuq7losyTiZ7yVDR0hFS53Ub6qAXHVxxPoNyjyQw5YKhW0acpKjBuQ9Vsq8+IxrhGp3eK6OzvXTTe/ju3INaZ1dlyQBxPcEG4Zn2Ae75I41yCAGgQA+IXjqckJNCfJXUPNBt4URh+M1V1zTImnp6IBwcwjOEHG4ZwOqPRPAPwuEj5Lo3S2cjVp4LdzQkTwQguwUi64HMY9y/tmIyqrwjzVwidJVDSeqaqQwkbjI7CpEhAPc0t44cNEfeHepdEaEeqo00Wy8g6Fq2iChsEjcouxG9Ch3rYs5KIgzoutO5TdI8FqUP6LzhTTUok4q60SVlaP/ANo9VecSTqsYAxOiFnZths4Zk710bTQGp+I+mntq9UKo5bRMrpHjYFAM3HRXP+r0UXdp42tzTlzUnBok8lWpKJOqqsFqfFVE6+i4pjdPNEn3yAns/Vs8QmydxKeTSCECfeFOIVYvBtRqCj0WJ9w4OG7erpkx2t9QrpIcMpwWyTHwn1VRBzac0Ohq7/huME/tOaLXg2b8NoeKoRJwBwPA67kWkdHaz7wov7ferrpa7Ka96AdHGFLYB0XWI4hfdhqBILOPVlRaEApwDQ3fjKilTii1pK2nKhNELz9kb1dsx2Yq85hCImqhrQN6wBVWj27hgrzjdbrrwV1gutz1PH2QFdbgO86ouzdRvmfbgFIpwWS+Skm6wYn03o2jqNYIY3RbWGLuAqU5xxKfvIHmnQvNbJqte/8Ako78c1HvOHYhThyTeCBigFFOlU12hPgg0nZtGEEcahGyJgxeG4hYw9myd4yTYzq1B3vxj5FXmE3CdoO912/TioIMZgoyrjbVt7R1J5o2H26xNoG4HC1ZwJxHFG1+y2vS2ThiBXg9qAt2XrtAcxwJ8Cr2LdQgLrTHJUHyVR/lT5KuGeK/SaYq7MjUqX7Td2IU9Zhwdkjor0U3+0EwoMDfChlo96qVHeVM4e3eVtVPw+qk+2czQINGaphgOH9GJWqnAIMHHgg0ZY8U/hHapzVTmoHsvvz6rVOZVPrcFwI7kzX0RdFcUa5+ymACaMwxvbCZbDGzLXH9rqo7nR6dyIyB8Uc/TerzXUwk1H7XbkQ5uyOsM2f/AK71PWYcHjLipTWWzb4aKfE3gfJTZnsp/BQJoTnkeKOIcO8ea2RX4c+WqIvI8KgraPRuyrA5ohzBXTxopvQnOIEbkfeY47VEZdByORC2SDxEqpEaBUahUFQ4IMg/4ow2JzKmexQZVVuU5/0xpRO1Ijl/TBICqZQL3UbWPJEnEmSq+2iqVepPujzKqZhY0QCpgFwMp37Sn1pT2AYE1O5qLtTPBMY40dZtY4cQgw4uY2dzhTyVrep92ZHDNTJB3Zb1IaIcNoe67+U1zbwb7rveYfhOoRaWjCrcuW7cpZgt62KHu/hbIribPzapy0nw0V5pJA0xCAcQHnM58ViWEZ6LFpnT0VIn6wVA88ahHZMjJQRsxgrvWrszl/KJbKghG6Vi88Aq2cKGMIdqVtPLldy3KgBOpKxC4/0j+r1WRVQsTzXy9tQqQOK908FJWClRKgaI1qQnb8E5v6KchKnE9yNSScU1pzOKdaauJHkhoWk78SVaE0vNmf3IEZIgDDJSBNILULhwNNRuWFcwPFG4d8KMfrJX7O0ulp5QqOuWw30PH1VXOa8O2gRB5hbN2fhxHFqDXNwGOP0E9pBYQsjvzW2SRronTJUDkvJTJE+PskKszuK1CGPNQxwrmscdVsdqkx/UP6uqqNKo1VHsw9tSr0cFtAj2SMFVURjROnJMJ+JFvHuQ1R1dQJp1bRWTzQXSCdEMMPCqaZF1zccuCFq2hpIxTXMw8iqCWuGIx/lMOLZG0MdxV8GHNG0AP9w8wrp2LfrNczC04b9Qrhul3gfmnWlmLrxlSDuTRaENnZY8+474XbtFF67aNyR6Tr/GM/3equubhQFx18kR0d14NWyiRO+VMtI3ouERxRLZT2Ft6YPYgC1wWBC68Kruaq5yJOO4rrECV1mngqNH4eP9GSx7vZKgExuVGqvsAapywUqmqIxESrgw800xmrQ55c020Bu1qjGQ+SawGrSnsyB7lZcHXgd6AaYxjREEkGmpXW5hbRg/ECASuhe4Fr6B2Ba7KVdeHMcw6rpmC5tbYHuO14FdMK2zRt3aXm/EN+oV5jidZxRa5tLShI1yKbZ2huubSzJNR+k7kbxcw3uSuFzY91wxHI5IX6ubmMY+sFN43cioo8TwRs337Nw1zRDhTepbdphGKZedPFfeWcjcqWcQiSiARO9Fxe3khs0VGlReA/DoxZLIezaf6qk8T7Pi8FVXnBUUBXniNG+q8FTtROSJj+CpAzUYjvUDEuMKTUZLPTyReZptDSlfFO2YICZtVDf5CtC6gkYKGlpB3wUZZTfQjmEejMtxhZTkf4RdJDhdJjRwofJQ6CI7WoFjyIN5rty6ZlB7zRkd25S2OxfeWVS0GuElFpaRaAQCPeAy4rCfEcVXDJ0oubFcVHRzOOhG4otZaODQaNdkUCQ1XI2t6r24otJgbkTQkDmodKqJCqFdYHUV3bCoDz/CqVQj2VVKLX2Vw0VBdb3lUBXgoCkCuq8SUAKnwQAFAjxW6nig3GleJQu/UJ4yDvFPBdLmmVNmRA75THkbAAJhOtKR4zRGplEMcbzf9yginu7k0tHFQBBar0bXirwrENI3REIsLpzBONVcdrQ7/mrwEj3vmg9mDhsu14prXNgxUBB4rhVqbab6jCD81tZnJEEmR3hOYLWHRpMro3hrirxbIIwXVu7igabkDcCoyAqCVtWbq4QFIdA70WtJgZyqucsO0/hzX2ZLqysuSwVFvUDDNQ32AQqeyp2AgJVqcxCD4ikoCM5K+0PdQ7McysdZ5ohpqRI4ynMbRuACuSfmU29EQJ7EaYRn3hcclWSMjgVecJ81oJrkjTGplZ3mYcCqmoxB81ecbu9OsrzSx1ROu5XhOyatOLVe2XaqCHbxnG5AGC5uDoxG8IS8sIwcELWzulw5direEZFbDiaVEqrSoDv8c0WyCB8Qqo2m8FS0dO9NAtIj9MIXXTrKq6/zVzoxOuKkA/iZvKrDfFdW9xUBolbu5RiTkpfitnqqB7JRZOGPFEDFBoC0jFOa3lvTWzUY9uC/ee5PFZB80ZxxIWdDRXsdVNZCbukclKBrTJNivkjjGKMHFQ4QQoxs3SCNJUPrNG2o8+CdYPdN4UmoPBEjZnLQ6EJtrO0Nlzh3ErJpyOS2mmWhYbTBE6gogwNDgjYvi7abM6SjZ2slzSQqAzmhdOCJIaY0oQgC694qWmOMIPcexS1/ag03sVtBwOoaqEkSh95HH8GiqpLqKGtKwA4ldeOSkunipe88M0BZt5q/a0GipQDNbPsAb1lI7VJyTn7gjo4oOacCtTePagThBqpFTgfBB2d2eaDtCFaNilf5UdqmMCpFMx6JrhSeyVAoVDhQ4IA8pV4GHDVRaicr04fNWjrMwDDtxDs48UHDZcOxOMdba5nEKtJoQURd4q7QxhKxAnrDKFaS2+0YjLit+Tc1Y2jgSSC1xGTm58wq7XcUCHmzOV5NI2Scd/ArZc2NHY8kZeyN+KjpJ3IfdiFIFexXSIaj1RVdbu/B0WMrUqeqqmVsjmsearQIXW7epW0S49yk0blvULeoxc5C6MVdGHmgCeJ1KqKNbgiIqgYwr2oNAnP5ITU3T4JskT1VTKUDnCAV7TwQpNm41H1mhm0iiLCUWPmHVn4SFU1BqNCMwrzDeYcCMtxVdoRBaayNEx9nBbEXcxFEDll6FCDUFVwmu5TndyzCvF0ZXo8UNkitQmvbWZZjgW5cwr1QQnsBG1Vu5yLhF4YhXXGW71B2hlkotbC8Jo5fdsIHGULzVeBKF66eUKrCpNYyNIU/g4KseyVipguPcqKQaj3shwWyJOqwvHJvqVetDJyAwCujHvV1ueKBZrAKukzFVJ7Fy8U4NyFToiAIJMrcHI57HiscTRADrHCOSrm0kHerhMS0p8YtRAFZKkYuExvwXRvqx2E5FXXdU9V3DVWrYwIdZ+fYuls5FdoDJEA0c36lB3vaK83mFTPnKdAqMkMv1equlsg1BGA4K9SH0vYtPFOZcLY08RqrWcWva/8A+Kbmr8xPcpFHZcCq13IwBuBKuF0BEh8cCpvdyrc4SqtZ2o0cBxlAloPeqExub+BQKrlJKpgsL3ghSnYFtVA7FgAFLyQ3IKjYblvW9QOZCi7BdkMTxV3NxqfIbkNqAO5NAzqdwCu417U60kDRfpnDVHL0V74nIgVCutxJEKzbNQ6R2Jhw+p81ZmIoR/0lbQ+7fZXwd2YXWq0Q6N2Dgr1n7p2hq166S7X3hv1XRuMiaOzaYohJi0btA5OA81eaKHrDT5LUKi0KgOgnJEOxqJ8inXoDhjVGKtcajirlXMfiM5QuEsIx3K3lvWsHG7kSK0WIBGRThNwjFuRTYwQNZW2wAnv4KWzwmoTSYHLFRgdynHgaogvuqhD94XWUEzz/AAsCUNmFgshvKgTav1PVbyRcdt2vujmvuxT4vd5aqGn97yaI9Gdn3noQCB3lEnHNOcRWKSgwa7Tt5TtAK8dE1oq9xjtxXR2eOqYPeJhOjMn0TXk4MEKzOAGyUHxEW4bG40RYQC42JI4jLxTAJ2WlxG4Itb7r5B4hWT7PqXyQ3S9i1QAdk7J3ack2m1ZtLTvafRBw1qjZkVlHTwKgx6rYPJYQjFfEfJfeRdOfogCJ0nMcc1fa3/HPvTrjy1w9zXkmnCHFbQmMJzVqB1eifTLBRcBMVg+CzkdV3kr2Yd4qvMFFrYLPrBbVCFGAW1DgoGycioLb3NbLS1VPYqeH4NTCDbNp4radJUMUulx4qSAGdgVT92FdbN3PeN6ZefTQZ/tCvZN7B6lAubX3W5jii8j9u4aq6DQ98JsjanDMuKDZpMnii97toskN44BNv9e+C7kJ8VSS4Aimp0RYD1dn1Vm3C6xCy02jzhMfq1pP7hQ+CdaNkSbw8U5wFNOKYSKwA7lRFs4KIEFB2G9bKFa5FAOFc0Gmdw9FiNxwK2Ad7Srwlp4oBNa5pug4afJXWl0nqk15Smm0Yb0kA/zkiZvCktOXBOdNPBWhJgmzdXKtEbrphbXWWJk7tFTq6qjQ6NCpgxqtgmdFv4LZDv8ALBRaCTwU2dl20Xkv7bv681gVQALFV7FHcqjgFL3clJ2GZBdU7mnzRMF9ocTor52nZHIcB5qA01/3KXGSaBuSAA2jigcXYJtwm6Gz2pj7SaEHhCbOIaRzdUoHOaeqCaDunxTuIpuhERhJTafQRnA49ig+6e5cKgolopMq8MDiN6latjDdu4INtHdI04OzjIq7UtmmoO4rar+oY81sk9tFDqKpBBWzijg4b6QiReGRHyQdfu0rmOYQdd2c42grSaiAgbNwbK2lW9IwQNWzh6KWgb1S7vQB2SDiFevy4KQY5LAXhmqtUwF1jy/Cz5Lf8IR2bsdixJ3qVMf5HyVG8yoi8e7mpNdAFstE65BE95RujdKjLMfWqdNXHIDMotaMh2ICsJz9RimjOJO6U0HEhXjgbW6UI3hEYZhN0rXROyyVwmrRM7h/Kg8uJ8in6HxUt5tOR3IlhiD1TkV0T9l4q35K6/tV4oXSK4CaFYYotoRuw56IThlNHN55qHNrqNENoThXFbZlt6nHmrrWBwPu4ditWuGMckdhj2fqCi7THgg6+oeJBUXSCESpIWwY1RvOlbskS6hCDQ13FVns/ChpxVXR4qKhveVEQN3nqqz7cSjOGmqq3gMkXG7JFB9ZIXBh9SVLnSZx0Q6MTjO9F9oaxjosKATG5MDs4J9E50+6aprjhcJPBOtPeNqDwNUSfdM96sjOOeshGm03Ea5FBzaOuweIqES+Tu3Zotq+yrdO45K99FNpuWyUKVCnGMQgfd1y5qDgTpIKoZ0nFY7Q8F1wGnKcCrto29dOy4Gv8oiGvBGaLrzo7l19oHq/yhsgGMlXTREEI3W44hY0V8jbiu/esIKqS3wV1zCN4UsivYg3CvJE0I1lXb3eqPI5/hzEDXMoTIWY7l1isCq0XW7V1wN6u2TrxJxOCNmwVzd6K9iNdSruA8ZTW3cCtrqsM+SIbjUu4gJt52DTJQbPujuKLfiIHYnCNm+Smt1JvJjYwTbwxAqnAIubjGB1VOqcRoVQ0RB2Tu8Qsrwx3qmyVIrrGSia5iMUcC3MK8wzd63zWOU7+SuyNoY5FQXwyajRXbQVBMOGfFDZmW9Vx8CiOjc1wFbxrTxUmxivWbVY1RloJOEjFEtmBkicJQBMFQ8lEONNU2Qa5K40y06hXXnePkrueRyKjowd4RvMM/t/BwW1dHNAtaHnWPVQZHOF1x2Erq88Fj7YaHEqXWt3cFBOJ0qpDdnKUHHVEwa55o9HIJJxxKuvIBMk8Cr13EjsU/qKYSKNaXdyu6sJ9U2MiPROHNXY/wD5OaIPWB7VebU+Klua0KDsvBXm1CBmRlqib9D3LadhmaEI3yWnCfNSMRmMwqC69uWHYgbwdXB2KwvajP5qdrChA7irhzqB8lebDnaihCAdEZqlpOcEYIBuyNcR8lV1Rig1xn4SrpxBoquBUlstVMPBZSg4UhS4xwqFszOoVAzmfw8+dVRSZVSoaq2kBVN7eVAausAgHAukoAacIWXoops4oOme5X9ZaOeKsxmU+PetIHKic46kBN/bQbiE4g9X0THtNWyW+iYdQYTbQVpWO0FXhgcVz7Vfyz3Kjrrvqm8FYXXNEGMCFdNQct6lm1d063AqG1IPVIhwW89vYtjHJEmzG8gweYVXAOyJp2qX3rNwOUqGv2sL2M8ZVSKVQIrwUAPa/UIG+x00vBA36DrBXgaBOBwKG0oKuiYOIIwRa5oQggr+4AVVo4qbOZVbNvL8LBVDO1YN7SVnyHzXUJ4hD7s3tJ9aKrq6AgrBUMqa+akTxTWMjOc6okzAxKfJrFVZNmrj3SrQTQOj5prRF8NIGp3KyMiL9N97BOblekc6KQYdDhO9mCtXTMhxjcKea+zTjgeQTC2ox7E6DLawD2osblSu4r4XD4t/kVWYOedECDnT0QNTEGmMFAgCHdV4w56cEXe972qb0kkj3s0C07QzIoUDFRyK+8Y4b8fFC8Q9urcuSG3T3YwI3gqOjD57fmi0MdHw6dqlgujMAz4IE10rQoNghqkMkZqRn7u9EmyHFbMgjIo3sVzRfIDhkqBStkS04hbTJBw3LZe6N/4uJVZ9k5DFQxgY3hJ71m49q28dERSVOI8kbmHDNPGohX/fyOk6KnFAb8VJdtMEg/tV4nqivigTXXjMq0FdozwVlUmHgjgRVAuqz6hNcDsmhzgjAo2jTBo4Z4ppaMuqixpP6eIVBe13hXS28Mh7wlOAqw4j6zURNYWzQ/DlyRiQ7RyLdPdeIWy64ZwNR2oOYf3AUhG/U6hN2OEoPZ1gMyHJzujbOceiLbRSC80rlC6zgYxI9FeDhIyxRDrwcexVgo3XFukpwIhyJKBBvBfQUskGFDxddwWw/Z4/iYhVI7Vi1SbRsaxTtQFlZzHvO8goHqoLydy3+Ckuhu9NaIMDDBUAHMdy7ZJyhUBhQcJVWncgeqMl0dbtJPBG6IRBrKdU0gjcrh0xTmOMU2Srr+rUHdKAihz0KrycFGBKmJMdqkngfVFwiDS0act6i1nd/Kh5IGpFPki04wLpMOCrZXp3wF92COKm0vD9QqF0ZLBpBkFQ5k6KAbjsq4r7xjZwa8V7wsjqJry1Qcx0t/TinNDL0ZhEENcBuV7TFpVMUSW5I71GWKEGmq28s1Jw1BXUngfxqglVaBGvzUvtKaCSrtm08/kqCupwCoUS6XKSYAyCns1KcNWlvaplScch6raMcU440xV4yAESQnU1TjEiKhOjHMa5haaFXLQRURKcHDqmDu4q4frggJ2hgcJ9CodiMHfWah2stIz4JomSzLOEW0cIoDoth0NwunJBpFMYy5KhKpaxATgbVs44kIvA2o1G0pbN00LScF94A6dBJ7ldbIms+oKdQKSB2+icYpr6pxlpcrzW0OSMqkIwJTNqmSLSpvc1BqDos/xut3+zAqpuhBovOV9ygUH1VbvYxxioklYVvdyJvVBK1g+KbFJpxKFkOq1PbgQ6D4JsGhi+EZiogjUTiE2/UQAeCe120AJDhocCmF1awYRh00gEZjegDMTAUnKhWk4zgd/FOECdMj80LxqMDgpZEg4TCvMPFqBaWnUFUkcCvdJ16pV03A4HB5ryRh17UAIsqD8KmAHDAqrdtu9Ay6d62rzRNTkmgPggTMyDwRc1rQDmK1XWMrq11XVlG6YMoGFQ/JQ4A7x6I7ccV/cI7D+Nj7M1UXeOPYtrZb/ud6BYVyEUby1VOaxQBqSQm/UIRkFN6GurxzomuPvYIRiP/caK0foQFbE1NO0mqLtIUZYt4GqjOTVWXAtPBAZjvRnm1PA62uRhRaAkOEHlmELOWvmtm44OHwlFt0kgYHFdU3TjPkpvQ081NptMOa2HFxjEYx5ogk4oNLrp31BQvOYBioaWOGWIKA62lFRrQexXmyIobtUWWglumHMK6WmFUbPgjMHeKq8yoVQCPBYlNfQwhcpqtChLsc0YF45hYOH4/othsb81I5n5rZcJ+IequsJxrqSptXf4q60KL20Si3KMVXkFZyOq7sAW8ZbtVZMze4HyU6+qc01g4o70CRgI7KqcRe7oQaDTpO7BSOqR4UVk+zN3pG/7tFJUgbLqgjEHcix0DwJ1XwvGXonB2yTjSh+tQg5hB1b7rh6qA2WOAgfyiTRuJE+BV8W46TCcA7c5HZcBGGIRcWg6DHvWzQaSheJB4IAgOV5jXD9MobZEjPEeqJZptDzTjZuEk9XBbXNSP5UxCw5LZzV4hAgVUlpoaqRgVEYfj+ZVBeO/BVM7svZsiuvoiTrCoKuwGvyQBMuPWO5O+BsHsQk1ArxQc7MTHhyTnuNcVZOOLWgg8kxu4c1U7UEnyTXEUCuNHWMuPAJugIHkrvFXHjERzhOsj7vVT7wF6cd/zWGwTUaFHUCo3aoC/XFh8l0VqMMDmrjjG9FpJ0hHaxGarQoLbZX4hjz1QF1rgd8IR0tMswiLRroyQMyzXGFUm4eccFS0nPCnyRcZEmhRcDIzCotl3ELesVuUHHJQTHFXZiqO2W7vyOgXgidEKUGCLzUuoPrRXBifqVDcB3oEjA9rj6IwaAy53BFpxI2lZ6dGT2K+RkAFKLcsFUZKygVJ8CmOBqSg8fF2FNtfdvN7FaMrcccRkMQRwQvjCjiMHMKaBF8VY4HrD1UgCcwES5l7hQoFpvgYfEFPWA7txV14IGRKjrR2hDADUUW0L3apDIPH1QcTQZzUc1t8nNy4pweYyOhXQueC3EEZKphw7wgHDHAqH0QDGggqdO72DchIUAgjJPaMRkVE1GI0VHfkRAvHfgnhhvOxtLX3QNAoVewIXovkdT4W71enatO27u4qBz3bk4ggaHQappAoTNdAaSmtnMueVOliB2lNYTtE/NNbqe5VxqVcyaXTwGCgUlxjkE2Pds4/6qq1OTX3kbP4hRAnRaxkvu95Zyxb6Jj2k3hS8gSC0+8d6DwPNpQNQc81kW6ZK9JEdyukNO9Q0Xhk8V7QodZljt/VKoLt7Q07lUnipneQhAa4aHyV5oxyNUBdjULCiNSVN6d6m6pAVBVYSM0w1BGBR6RokijhioiRr+QrVBtAM8ghZWOzZjtcdT5KG8yukgOd7vFYzJl28o2lpUgUHw8UGDAVMJgB2bojfvQgTHVHmre0+EYqXjZZBO85BOtXe4yvEhM3NjnCvTssAnipyIrxzQ3IanHgnj4mfNWR95sDtqncfZGFZ5jBydIxxQdrQrqniCrzQHA1j0QdcFRWMeYX3ZnxRyOmHYv7juJHiofZtccy3FdZ0HBbNoDTt7VAddIwGSjZBOI81LJDxi12fBVx7CgSpY+VXFUW1TeiDyIUOWy6805aLrciodAIpX8jGS0GgQbg3RQMu5fE/wAFtOpjAQaBjlmZVTh1uKMCAUyybgLpO84+aDJ6tXcc0LL3rR7XOGgGARA62HAINidePyQPZ6oOdMDFWoH7R4qc048O6ic04FxTmHrQY5IHetxxQ4doUXVsEtIxkZotc0csvRYnXVGAXM10W1LtJGSDhBPehMGO1UdDsGh3qgtpha5QZ3SUXWkPUlojKFgQCtoCciMVQRTtQBxWKDHUmoRLXfMI56graAkUr+Tgcyrre1Fa5lG1dierx1UuMAYqtKTGgQjEmVa2pqLNuHxOOCdbPk2jhsjec0SY3re7wV4jhwTBlNSnQesaBEA1EDsqUDlPin7yYTHa4p2+ab0NniEWh1W1apNIPYpaQ5uRzC+8ZcyJjxUMgjt8VF51nacx4odI6RkYqpvUmhj6hbXWxDhgVDmbWWhV6ORQ2QWZ0wUjaGhVBd1ogWOnLRSH0+EpwvFs5EQommSBubWoUO2T4Lo3/wCJ0K2jOii0xyOqO1H5XeuKvkYUaEGmt0yd7kSavcZWEkprNXyU7dRbVScAtrNfCwIO7PVDQHwQKKEVMwtwcpyDjPBCMjBUt4qesD3jRZwcwqvr7jxgU5rnwdI7ldc683KaqCDd+HJbNfFAgmMjiOaF6QMDWUYtZ0rVSbVrxqBFN62BMoB2meSLhBBxzWPJC06zTi3RXgZaULroIQezrDrBNOeIQvDnoheqzCdFFz8q7ijwTVZ/8x3gh9ZIftTf8k9P/airH9ybwCb+9H9vmuYTf3HwT/3J/wC4+Kf+1vj7P/PQ/wCaF9o/5hR5e0K3T1Zp/FBPX+Pscn+z/FN5p3JWn/LVnwX/xAApEAEAAgIBAwQCAwEBAQEAAAABABEhMUFRYXEQgZGhscEg0fDhMPFA/9oACAEBAAE/EKgejKjCH8iX68yv5D6VNx3Khv0qa9E/lzOITiMH0qVmVEPUwIpfoy5f86gejCJA9Kj6VKhKlRhKlVMwzA9R6p6X6V6VCNw9DPoH8WVCJBh63K9Kleh6kv0Jz6c+lR9AlSiPpj0uHpz6LAlenM49K9L9D1H1dxqvQz6HqEZUPWpX8K9T1qEZXqS8yoelRIEqHoelSowaiwY3K9Fj6BCPpXpUT0AlRlegepAfSpcqVMSvQfQ9QgSpX8A9B9VgypXpREhFly/UnHpTKlerCV6X6AMIqJOZUCJKlHrn0P5HoSvWpUqMYa/iTn0rEr0fVlYgRPUjU49KlSoEIx9Kh6LK9VPQIwj6VL9CViVKjD1GXFlwlEYMoYnpUJcuEPRIRzCZIZ9Kh6lHrXoelSpxDEu4yoEYR9K9SOIOZiP8a9Q9WZ9H+ASpUBleqw9D0xUP/Bgy/U9E9L9LgxqYi5hLlehGVL9T1PQi+pXoRfXEuD/AJXqRPRuVE9QjB/k+lxYPoRIMYG/S5cGcS5zFjAhXqHqSoypXowYwlfxrHpiX/Af5alxqXCXGHo+g49K9CL6JCXL/AImoxfS/QleoS4wGGosPQJA1GvQIy2XM+hOPS6lwYRYPpXrxL9Ll+lyoRly/Q8ysetw9LiwZzL9WHpXoeghFiQhLHLiIaRKalej/AAr+PMJf8BjL9MypXoTmCS5d+h6Esi/wfS/Q/gS/4HoelRhNeYUgurxLpZegLsdez1lNqhuzpEBftFj6V62y4TUqVXoTEv0uU+ty4suX6XLl+hL/AIMelenMJfrUCV6X6Er0uX6EsuY2ECzGfPDFzCXDXVzuV49Tj8298PMNL3HyV5PuMOkyiOxOJcH0GLD0uLBiw9OPQjuXCMuXH0v+Aej6kYS5cYsPW/Qi+gSoeiy/S/QLk2fEUVIsFvPc8QKMUAbt+c2MThoaDKdDWTk5iFmmCyU7KfTHWJQRwcPF5lESvU9bl/wuL6XLmKgxfTUuDGFziHoy4Q9Liy5cWMPTEP4VLl/xCBOZmAphoeO0X4J4UnsxGVWsgZSCjIC9gl8Q8Bq3XBwN2cPJubeVrsoMJ1EisGVa/icep/C5cuOPQjD1PW4/xYsqV6cQj6X61/G4PrfoS4vpcue0vwhMnJ2J1zqkz71+4EKCnwPPJCmwMNs13rcqPRR1FC89HcuSs0zC8fs4llFuh28DfmAVX4Hn0PS5foy8y5cuXL9CMLuX/C5cuXBlwZcf53Ll+h/I/hmY9LjsVd9pawCADtXZupkAOwJ8SllAHCZPa+sVSubMPNLO0rpQpNZ2H6itQqloicrhPzHGcRuVtJ4OrxOHA0dbP0s+IkJcYfwGXD0PS/Rl+oy4epGDLhLm/wCD/Gz0uX6XL/gwZcuC6LavrxmDyymm6U8wey3l6/ELtdFljb44EF5PsDR5FsIlaXNWHyYyJj0TfP8A2403Awb7o3XiFSZQOA5rvykpgA37Db2fzF9B9b/k+ty/4MJcfQSXCHpv0ZcuX63/ACGXL9Ll+ly/RrUW1dR7q4FjzisfEpGq4HF+LxcK5VzhS+Rx/UbOHSAtdBxT2ZWua1U+wqj4iSDyf2ciS7ePPjyjXhxKQyQOXQDp4uV0V1TYJ9SjG3Y9UvyB/wCFy5cuD6X6DF9L9L9L9LlwZcuXLly/UuX659Lly5fpf8bivUyxbV9owDMHJkrjq8wCxwkVSIcmxOkHhqg/Ajhr5JW3ZyAi++T8xNQqtDHa6aYcoTs7exfzTLaf4ko0vpdXLbhUTDIgO6aHtmVIKUrmhb+HMWq4JeIS4JGLLly5cJcv0XLlwfW4w9D0X1uXGMv0H1X/AAuXLjCXLly4MreuVUOLnATgF2cD7QpdIyvIYhWDLvgeqOjHiFAWROg0+z7SiPGEgXagT2JQULsfiyfMAZvKPxVvk94GWJfu0EexdyhhtArZfhvZFAYonXIfGppltxZcuXLl/wAbly5cuX63D0WDLjBlx1616VAzAly/W5fpfoy5cuXCo4b2JgckSIsYytJTfK32z4iF0HYWPZHcKaPKW9gt91kQFikAdAbB2g/KAooMeG/IwbtGSr4IvvLfBsL5Bp9pv9KtkzZhUvuQxcBchQYF81fzMYi1ddWnwe8ps0wYHVRAOcwcSlPEDD/typsR216363/BRZcuXFhcuLLgy/QZeIAFvsReZfH8b9bly5fovpcVaqqj9iaTvHFsJSz7X1lBBZpZT3Lwv4HEHMRYE+ak+IrjUsR7b15ihWFjdA99j6lLWuPD4LQ7YQ/YyRhydyyJLN7CL5MMPuVMRFKKGzeRenZHH10MYKt+5fiY4ULWhtJXTU1TdqFKZoD6tgavUEkWAZVo8REvxFmusINSCp1uK6LFiLxdGJcZfpcGL6Wy5cGXM+t+lwbcz3UVlBLP4XLl+lely/WlIbcodInfvEm3tuvmFiU/UEP5TGOiQse2mcLJLC9rrOzKh1xc+Vb82ypXTlCC+a3js3HlGHLEvSoe58xNhYFz0H4NMymBMaKsga/SQkuhGi9HDm4zS6cllT8VMCioPZmzzCxcFPl3nzUZhCigC2s+I0QEjqLRSdSWhqj34l9pbNqaBvND9TEQnTzdRMUW0DwO/iC8YVf93gEu0Nd0AAsFrwFFnVcsct6WXp3iy5cuXBl49Ll+ly/S/VxAVeDtfM/CnOYpIcBV42sFwreh+4nlzzCxglS5cv1PS4vrcuENOmOLURbVrioAqjn/AGYVKmO0Rwqg2WeQnkjXKEtnygJSQCwVPJRDaalsmmGql9quU/R05gPHZ2SpahGK1FKca10OmB6OFgaMYuTvLuDjpV74oGnn0Xtovza6hsMmA6W8OcDUQ3VC5was75lvxrZclD5v8xNsOAimj6oiSDa/agBXsHzFyHQ3rFbo3io+Uyb0uA+bjpwKFacCV3VmGRCC9C2M3nUG1CTdnE75jNogrkUDHmb21RvRT/UswtsONkrErCwZfoMv1uX6XM0vSWfNLrtHBbHtho8Q4FVnhbrwdIa1wDAOll7ZSodMqHfR75lBLaVFp4s290g7EWFZHVDBELrHov0uLLly5fpcuLBm+SHsbIaoneoD8jl/ST2qXLCWBa41AiirFHlBfa6jzVKpo+DTuEEsFgKBeEd3Kbrk3qpQC53wwW6VLmws6VvDNResMLxnSMXkUQNlA1xePeEZ4UBF47y3qA2MsFnQ2zBAD91p7qDHmKKlY2UBWODTzHpbdAQ4OqrXhcBwKCCkmlX7A8wYrUTdGHO21r1h9PYG8QpaDEWA2E6i0TLIXYa10eJR8A6BYF6tmpbgggKS+mu5dyrkEJaLfsQwTUzIGBl5bFMGzKX1rMWg2gOcW8e3LGm3AwKt4P3DiOpzL/guIGhAA68ykAlbtG7/AFA+LAIOwofzMqkKqrDjUBxOPl1BVEPMmWoX1oXHn4mGE0VwdihErQ5p+6Y+QmqZPdKPBmXa6l+pYQMv1uXLIvo5BtaJaZCAmGA+YYuuo4YyckBnj8Qyo3GuGYw5Gpb6wEQ9jYtfcQcvZ8zIey+8sNVRXU0O1XJFHlSNiNcgpqI79KRwT8xTr3jKNHwMIgF1exmu3wuAw3Ji1YiGMIJFAeUNglMuLQq0c7cYHcjQwIqYNa9jG/HLAGwkZyXK60a4InbIMqCmHTAe02sqMqzlxb5jTtsKwR5pbYwN4adBaeWVVStVlDaLvK6zYwJc5cDgjkKVbyTA6oQHgaoKtX0HEBkGAvCS09WjERLwqQVSCdFfqFxgW3VuvwSimN1ecEMgitt8bg0DfEVMehg2mu0ODqwBLQvQvB2uEkNCja5YrN94PmeUZZqqBrPmAaFdA8MCgY7xkuOLLp61VMLeay5C+2MSj0U7uj4QlanlSe9/qZ4eguvarY2umOjXFc6ljL9F9Rly/S/W5c05I+dk2KS08L14lQQZcr8HDKLGhbvddO82i8bhwZzMDK1dHzMFEjqufEoRWidJx7Uy+8sXVVLamRvGKqIVAReC1SueTxHOCJtVcjnYQ9HRGSwAFaFJWoXJ98t67wdCNKsqpgvNa6x3oLFu6N1xyzZbusKitZaEsCAcuaLPNEtnQE5ADBDPobZUV3ZeV5JkBAeLzZ3jowN+FIu6K/BL7lbUwSp3KwsTKSluq74heKLLVJWPnL3hkcG0jXVZnKSrjLVvkX4i2eXq7CkXotrxMv4oPLig5AI8CryNBdLrgRLDlmFL42moCWNKcnd+YkEM5xuGjmiOR4XiWd0X7RY+VjWDozpYFBJXpW9y+dTFLC0yeQRjxiJAUqgN9XFspRsaCPxK0hNN/s/C4cDXqWb7Uv3jyrmrYe5lK9Fkpy+XMPGh7WQaHc2MJNrwEC/q4pbXNy8wly5cuXLl/wAH0WlvFo7ZxCGLNaxkIwowKu6a3bEB/ipRn3AEuImz1dL4YvDUuDMns6fqZdIiasUrjfL2iQ09ACVV1mvuChbADQaIPZpxw4h2nXusvw3VxgVXMdo9xGJdIVHYCubT4gXa9cEseygqY1e/BrCh6o0e0sfkUK4G3bVvYlNmggAD3Q6j8i4hmHla81Xmte83RhULyJ13qjmoIpT3s0G1yv1cs/DFzYKToI8wB6AKnADAGGn5mVGmrV8SqtnebsAdlUKelEwFIWLWQ5YEWM6LwqwAuzJY8NNSu030cniNxU0bFABVZaMQgKpLkxvnlvnrFiK26Gx18HXeW1kAqZ1WukSYqtlcmQX3l1lejCYF8WtRDCF431zDn3rMoBquYBjZIzW+faEKhfhoWHG89o4gkAZB0Ws94Vtjuzry4HpKmxKAYV9VZKLgI5UV1oWfUNUDw4+EB8I5Rot6Np9QAsWbuW/Z7S7dngT81OJEelRAQvSD4SJx1nNAdSL6VLly5cuXBly5cYML0RyFFnU7kYmxnAdkZ8tR9qCJUiic4iZtFLtycPhh/GaMcW7fMxKlTrChE6KOzqQB1jMPYH5mNMeZmlsMRqikZbWC1wd9RA6BExVsrrZnmBshCyV/dkU0I765B22hblQKGNvzZAMAoOyaobS+OYRMiZqiihpgbXWKmihNjog6BF+WrlkJRRuhtYSUsqy6mL7q5xFvqhbyrpB6ggIRJtTpgr4c9LiaEwtrdcGay+YIZc1srjnduD5jMJk1CS08KHpK44wM0rodNEDOt0xosPCIfFgq1LBe6r5iq4Dvq2DvCdVeZ7z7vxKfW3ZCubChRMxhYFtCyJMgX5hYAiFxhha6SztvbNFEucyFWy6z15YBgbUbmtq81OEc9VUWoOO0ZgfALnq9cwgrhsr8lHtLra3kfFPmXIWyLD4gMDTose2IbWplENZDNdpvVDNlt6KCX0uLRtuOp80LLG2db75f21CVWdm2HsGU6amN2DrLruMOtSyoGK64J7wwQXqLXN+h/wCNy5cuXCQvLLj7xLsgy6k9jeu0PZNiGpqwNPNa6R0FXRDgDguTxEJbKA5MCnUdkUxUvVx1Pd5jEsCoMPPs11l+i2KNqC3e8RQx0Jtr2MWRSBr1qwYVWAYYFnkmxpToOZ0qS60Us3YOZQ0guVRzTxgOsQYBBnKUTpdpxC5zcEAKp3G8vGCEUMU2qFfHMsuNIVrKqMXUOxFSYKBIFd3Hi2WI3NRSUBbWrvggWhZ2MpxMYDtVxGAhu68F9QvzMjrqsDkFnS6O8JTBI6FAw3dFQorMsAF99iwNNghVZCm8ZxHi0NB6IHTuMUgA9Zgc8mFqpEtwirQsfZF0fJHAHHllqaoBTQiW4Db0ilFotQcCNXvAStuilU2GBcAZzlZloyrlRay9VwQbDgugs7YLuEFBK6C1ttdD8wcM5ELX1zl7EALdOkD4Sbz5SVp92vEMUJlpQfZb5qIaoKXnPdupcq2CgS65RggmDhQPpl0p2Cld0P7jqFdrCC8Oz2IUpbbsoX10sSwUHpc/uZkjuCIeL35lictvO/f0v0uX/O/RZcZ5oZg4CF2JTUKFI9dYbEuUDptBOBE6pLUUJVG1Lo+mbDLAWI+7XMdrxttBcelkNxpzAW17DsiEosjs9jpde0Q/ZnRrVvYPMRSDi7WeYabIATRYKhDtYWW6RoTdlacaZll4ZDoXXWVgYBDaCCILMcNsMBeqmNLHAL5iVWCzSKgCtYUeqDw9uAH+do1osFboFQ7VubYBZrQJJ0G0OrKejddZmuwDvcQyqyGKhScXSCKHiJSj+LCUiBS8C6gCiDZzk2ec48QFyKkOBm3QxXdgi8sNFh07xJ2ZqtaoOo492W2gEKLItc2uF6QZwFSAUewdNEpiR9uRw/QhRFgcqmVTGH6Q7Uq20Rhe7+JdKAAPO8EwxrWQTdt89IbGcOC/dqIFsVKW9yrfMCVMcPxJb4MQz2bcPr+5mpMsnsulIQDbAHxZl4gYEByeIq38xhbX2Q/qWAzt/wBuahHi0hDYBvDQcXx8zo09iO5UTx/C5fpfrcv1v0uJrTm+l/mGqQLBUdLIzy7aKjNXtPeXUILAOSY6Oes47BL6GefibkEHkrD+hH4UwWzMKdDddI6po5wtrFwGHCqGSO0faNQriuEVaqHXNQUIz2IjSPbcd2AN4Nijxi41BAbWChCNl4fMrQe0pSqg5Mtx6TR11TGOhbfeOmfYtYUro5lT0LRVa+JflCTWy2OVNOCATkL2n8ExgmakqoWtUB3OPmJtV7dDiV5xfLcSGT52IDluLvVNYw4Q6XUJaVXhdKfJdQapPrKbWu9suGgYGKoPglrAcizZYZc59vMoVSoJyCrOE3ZvURqHQwd2IxlOT3lEIKthLW6dR2rbBojABtUMLwVg5eJhFtpgOD2Nd40umaIKwXWsfBLs1JU5uq4DpzqXLKBmarfUZa3KrJfjRfiIZc4RW8Ur8wVYLXxmiMOoZ3Yfr+InZX3PibiAizaQt3ND7kQVE03fjKJ2gEHdc0D8k3/mVBAnLgfqJLSoCiW8WZiZFWq2rLly5cuXLiy5foS/S4XeozQdLbP3AM6Mhqv17xG20ozGvbDXWCgXgTD21FgMBB0N0l9K/qJUNI3p0E458RtfAArXSzSZHMEiqSGgS9OvCRUA6CqrhePkjYDS9NgJfW5nxFLIULX7sTwWiPymNS6a40ygVLdLqViKq3dFH3wRyxRmZA0Hhob7xmQMF3SLW9URggmS2gh+LloAQwVyGvxGqlgCgZlJe6EF6aOMWAYD0oteYguGW6Yey8y5xckKKHqqxvEZnFoGXPD2iR2xwON+2y6DrUM9nK1Vtq6hbUSqxLDBZlTvNvdqBfUKVQkQZpAoeswMOMWmDyg23rEprH2TLDcYqqxMKUDUwFC83zN4C1Gxrf6XxCbmqlhc28uhnpKVommw4LvRzUd7sHGHi8rN662DgZb4o6ahaxZpMi+W7fEDAYcqx70XKRI6oJ10HDCQKDafCytdl/QEQY04sJD2AX7w4C+Gi/tisndY/pzDrT2Lj4VZaKt3xmF7JMM36XFlyz/wuXLlLzqItmdl/hl1BS7zZ4dxAWWSCrOof+w8XzEADuXZ2g38/KvPjswkoWWyGkDr1lBaUaWF9VoXxkiqhawiucYx4xAlLKLyXXYuM7mWcZwYnfnvBA3F0z3Jsaw9dzDyiDDQtYbOkxgIe7wQX0RrzLRlYplHC6PXi4XwAIOSyh+Ze7EKYRVB8A/Ee9ArY0Za8pc3TnVYWPkSk6KbMCK86CWsAwqsLKOLWvbEtRzQ4jyVWU6rK5XAcrbcL94txgRVY57C8QniS9ssG+4hBwqqFUPM0dDVoGrPg2ylKuCqoGAdurMqVluLVah0DmM/kUQuCVW3FvWX3JTXJRHjjsSuwp6yoc4aVQDcpDsVFt5ABxpEig1CEqqwtH3Am5oFZuzm3pWJZBQCljg7u1/BL6tFqWGwv7dRIa8tUt4sa+oNVnJ+EC/aMrqx+7p37RFKq6V9js9/mUXA3WV2XZDEExxX46QDLT8R1Gx0xMhSnvDow+3Hh3LkY6cseXXn0X0XL/hcX1v0uXKUo8qvxUGBViYtP/pHYUi63muDL4hAEVpte/uJixsLoPgCWSEKszld7pG5U5U2CvNIfZGEH1Ch7m5WI7uC+GVTBPse93kmYtKkXtVFDqV13BMBWmhTXcX0eYTTYA5UqntZrvDpiAiLBWaxs5JhFBrQvd0WMrwljXFpX5ix6FWORoPzHqJoCwgXTvExAuW3v4y6AqYRAeWVFKnhLuxEstCLKju+4qu8CljBq+FbqhXXcB4AcR5y/cupHDotr0YuEUBBbTojmuJRa0mmAtnHVhzBULLWttvjN+03BgBU1Rl1bogaCIwABdM2XcQ7QvQcANHK6N1L5XbDtMHJfNGahyQNVRnU1fJB2ItKwoKKWrBbnvxDC3NGThRZaNYA3ENVYNjjdo6EsKTImTboxtgdaAWe+tJX1cSCRbgToKLlk/W6K9y3xEtAwHnr2mOKeUGrYe3ER17JvTxEDLzOMaLKd40I5bFfb2IRlemJf8rly/UxXUpjQqqV+kxAYwTA88MSi5jIaGaOzrzGggtd0ThD3YhRslxs+Yu6oNt9qm9wSeiFunS3iVVtiift5gb4bRSnwgfcuDhcOwu8YGvZIC4xaK7LcA7K2ZJnWQGtUasaccPtLUbxdWt4xz+YhlwVbZwaeiY94FrbDXNMx3im9WM4P6RWnNbVDCz3vwRK6NAcWVOwITB0RlC/Z1lxOQJgAdBRo4IKmAN3eq/m1gUQRY0A4VvNMV1gLIq1k/8AvsS9+3JmvEQrp1ulhPRlc2DaJm6Me1F94iGKG+AHgxUad+RGLzdVUa1AWFioqww4ELdUGq2aQ1u7ZVpmCAO20GqHXENcKzdEAOtm+JcBhPIUL0MXFoKxRq/TNUO6PeMDFL2LL6jB4JWL9bst0LQc18wWhDjqhYOz13xGIS8oHL2dPWUVasjp3Z+GGqh06TskobN8zIXMGE+0Adytof1BNRJbctFYrywFwo+/Q/hcuX/4XBzFW0V1ML+pgTUvNh538zOQKUcmPmFAgSyqO/7iOFisHbgeLjJXyBQJpL1Z8MwB5KVW7+oPsGuZg2t9JVn0WH6lUKMI0FchqZ+ggjqwY2LY3QeWLOR6v5gC4hptLsdWh7wAYReGuDT17QWzyU7Ir81HG76kQGEelWshywJQazVXim2KGbXKUxdi6vpFjfKCtJC+mS0YV5U4tRPdhroRheYBhXinAAdUTLRRF5C56qUS4bFOpo37wPYU0ihQO0zpAkorFDOK+JcgDQNiO3Q+4db4otgIlt0q8VEUiRzYQMUMB9wQrbgbMoHJ7+8IsfYaltBvB2XqDR0u0QWwF64AtcEpllgLW1YW32uqhVbebp282cvsTdIXdGt4dnyo6W1YKPlx+YZV4PCb2l7Xo4hQrRamXzGiusKZc2PY8p0/UbBwiUF1Ur98R0/EKITpGT0zf1LSoVoijmrfmZBqHxaFcYg+ly5f8Ll/wuXLlwVUu3Uy4Va4YELObUj/AFGkhhtKJixIySrC0X9mNwMoFkFLkdAMyZjYZzsK2NQZ07Qt5uXUbQ8Ee1cx5EaAjXtot32I7MRZIVyPJDNpC7cKf+kAapo9KR23k95SybK+rToTIixc6KB+oYANrsxb3F8TcWp9rV4et01MqwtTQC26BXzClIFdaKt+ACI3yjRkpAHJmpdR/kirXNflzC2OvNUDAu3YcGWXC0TduROs6vnoQisByq1hvLtrmXEEFo3bQmgxcADXv4rn3cw90Uwoocpeu6x1isK9g532hcU7mcT0SoY6GWAsDoQVFdXEyzey6/uhAdu4ByweV7leDi8aqW8WpSivqdfMMSTaKUIzpL4WMVSioRYNdEerxBum/bVi42WxCBWnB4oHPdhIB3kVpfLGS26wZ4ju4jHbxBEKdCfniNgs7E3xLxKz52Oxo+4SORwKDxL9H0f436XL9b9BKkDNKu6ZSAKBC1+3EuJKypQ8kF+sN7peTp0lyRL4HP8AZNliVHXNkvUFkqaFMTAEoCjxeyPRzugoFZeeYiWcBb/UVhCTForHeHoUEBVmzvOJXgQDpZ/fMGTBkzdufhFV3BjLG5VdXRdFva2AIZAwnN8uCNrIQ5oo374I26DaS5Rk4Nse2IKecjQ7XRBArDKYWqg5ri8cxMn0q2eIe9LDjmIWN0GHAdgxnU2srWsu8BOfYspLK54z3gmbJDYYC+kS2JQqW4yoUHaGdDqFugBVnlzHDappVR2AFfEyMbhpRzWQJhQ1DaVm2H1zMFkFAXYVb6sQtocLl8znwQIJuyNI52HjLFqNjLi2gDb2sjPdhkHOCVb3uY1sIKUK6DQS3TIygFOmRqUCEsl2riu8PGGUW9nRFnOVYofG4F6BNE99mZkyV0O9OCIu4Fwux8sT0P8AyuX/ABsioq+wc9oArY5Ftfa9xAZFMWRSgQVa32SBXKEWMq20l8XGUOVlcid+kKMFCuxvl3UYmwpHBLN9yW7wnXjdsonAHjf7iaVuBgrbO5YdSMreQf3+o6lbajd/3Fq2i2TifmEel1rDf/RrvAyxcKWnih4spmAWmp1Rq+Baa6QVlagLnqPOpTtUqlDaALyuewSmPZFmxt6029qlZuF0KOTwHEICLKXb9swmCgFewdOrLorJKos4Mb7xKGjQBdXopWPDEYQrrRU7XLMEKU5fBqveZsJgbUHa7V7QvCFmcI8UDXvFZYZClh0GzHhaiRWooCwZf/qA3BmDu6KUvZog2giiSu7VWOoyyOubinm7VE6zylp22gPFwBHNUfIY+4znNfICYozl7s334a5DNIRktt2L8sAU9wIPgtTUfujoA1XnmMS7X1P/AAv0v0v+GZVIC6WKC43Sun2TEcV9z+pqrCwlZvGsMvnkLurN5RLGzcFX8wGo6hgyxW5SbWm2thvjtBYti2BMuV56GMOMs5uGuDg29NQkMfUu1xbRgcjkgLhzKRAEV7koxYevTrDXDdLoC8B1wQwTYsKRGW3GyYpSFXkAHqruBWSQCqFGPF+0NyzIqQ6vgOWEYIVShlgcDrrUbhwhYZC9so06guy8Cw8Z1RoKd+kwoVLVtF7tNypgyjUx5B9QlUnhXurMzZMH5h4io1bgKK6Yv3xBjqatKztaYcAMXx0rVe0onhUJbDpkD5hjDecC+lAHdm+Y5bAdh6LFeAgTTgOD7FZeInvMhrJfamviAAZi7sMdqfMHAfKkb1hcaqL5cThrSj2lJcZF7rhQtx8Rw0r5pDs83zL60l3QTs9owS4Lb3MEd/4Ev+V9piAujyTaHtQ/NQK32y/xLLBPOJfoIdzILdJwQQtQ0MWZpZvFSs13blv0LliuIMr5aJfcJX+hsUCb4HbJOPrmoHgcREpAhbGEXjrN0ytcSVkMq5exzLHHfvBohOc2cw9QJwU1qyY8YvgjbcF0Ucst94HINNOjpdbzxAUKbBVXQFsrVrL0gRn9KNXGavmW9hI+Qt9CsasluTQAunJ79pVMsHHYrodWg94F4DOKs7THNPPMO2wu07ufMLQUUovQc5iIKbwXTyxA6nZv/kyEBMiM9lly8lKFy2d13DET6qLpu2VkZL5F5p9sVKAI5AaeEz5haLVSflsPeGCV1SFXkflLQNDI+28HvH3s1CPswRKZUlY8WUTrWplAAtwuNrIDjc0GR0ttzFyF3SnwoTMqU1VOab9sQaB0Ps8M1LeV4WA9/wBy0eSirPXuj7wBrrTMEiSHQXXoety//FKtJ4xNF77f5lj7uP6qK8v/AAZYDu90A/kIEpp6P/2FF5e1jFW6U6uWkNtXuFRMNlK3VumICoaF2HKnGe3vKb4SuZyF3e5piLsVm7zoqZ/IK5ySsuY4RqONcLdwWEdiZV4oLfaCKVHYrWUa8wZx1sa7nmXhjTBs/u42SsmjbbdwGO+UbtcPms3ibYpgL+RRR8y6a0R2IUqtXiVIClUxSliWcWnQp1juRFIvIeyUX+YamivicMAiw7pHhpK+WL0I1dBbKWopcDhFrHvcbsgqrKPfhAKpRKTCOx6jKtZc1+27TyR0ELvFH335IhacoI5M1x7bgroiAEOMYuxjclVeC292iq6TGNEiHneta7rD9OYnWfMJbRybOr/UwWJleju9XzKU3ljBydtnjiCogau0dA3vzDsYKNKrsy1ivZgD+Fx9GX/49ipCvwRp4bpP6ZfqVcg4+0hctMPT+6Yqs6tfQTOaZ4y/qYlU6WQyC0OauKNVL0Ptple0woW7U1SSzDUKcPUNbrkbhY6bT6ATqQa8k1wGi0tfbMO2SMjazu6WeINWwNHIf7lbCnDbW3oRgA1RSsqVGc1jrHsgrOB5LDv9Qw0BeSjNyupHBgDBWaL95eLlLyShkpCvMHwJeQAqp6E3CrSAoKBrA6GtTTl1QGq9mphGjZ11RA0BcCdBggdi0725IDpDogrXIY4jz9ihI0VdjuTrHbQc9JjYJv8AzNqCw8cxjmAcF27mfIxre+yYJ4zBoLqZqHYOTtBKCABz+OfMbQgadJe/TxHoG5QT1ms1cI4rMYD2GpcQgOga86ZiQTdlU7X/AFCbIUFZ/BKoo+M6czE5C7xVRD+F/wDmq1VsNDqnU8vvn/jsTwGX/YfeVnz6YOFeIOq72TNk6t/NxnNr5NnZl1gD1IrNnJtT2hKet2D/ALmbfrooXsXe+kpR8OdnwGSOc3G2cwlTrgujzCjtAUFcUpCq41HDvM0aeC7qJG42TxDR+C87i0QpMxYdaVjio4BHEKSilOOdyldjRbzwb0wrDcAKVY5sCMO2tbgHBb0lQ0GMNfi5QVGV1tH8hcw6AKFrA0/65eDkcRTASuEGqFoVuOxqLbMHGXDfbUqrGBGvNHWMAoear/5GOq/6E0kcuAiUZFKrpxL9IA5Kt6jrM08DZLtZ8sR1LiL6WCheijoRwtmwWnHIXXtB4xEKEehQVK2NbGZ5AJXi9OmXvHUwDLUsVPYSN9IFC+XJrB0H5hHK7aoVXvjHux8RMwoPcmH3m20aseKePDFbxYu0379ZnAhRL12zKD/j/wBhF9ORw+XQ7w1KG4Q9uvf+JgunsLlDCXKVLt3YFTHixj3J418QhYrhZXkJTlwpq/pqBcygKHd6x3hGbdaUEetCIdWBBVyQiPXIfaMNN0EceWSBAI5BJ0D6+4gCTkDh7AxDQlRaoOA9rjaCVVbkoY3xUGo9KOvDh96jwwCy3wfG4AWhqwDVdGYghweXVVwzAiKVe8nGjvmZSjA6LHGYuL2Y4vbBw1aDVcnu8TENb6VoTtWZVXtl2P8AkSJWt1O5HWzNqT3YtKCWbVXlZg1waaae3eYwBMD3bddS6lrTTUXTw2IZGhhzrxfCXNukKUo9Ltpjo3GgLflOPuWbpVQbB+VCUHSbG3ydYRDGOAY5TmWuQxlgfeJ1hepbpThhDtKAyxrWFlooz05X3xcEcU5or7uoy0PDzF9z0uXB9Lly5iUTExCgqOwbrz/UyFLcqlwryR6QxY90H6lOE+P5CdIHwjKnYlSzeG/OIkovq4m5VXzHqpuZgw1BjHoTTDooXYgnZGW8AtAFe7iAXcWt9gBfeEygyl3i+LQX3IGEo5DYdac/EUlFVjaujHfq1PFAQ61jipQYQpXNPPepzCBd/HSdiJVuD27kZShoOAXw+8eW4t0XV73MvNbRxTvKRFYLs6rab3qVhdWBMAPHnUGpNKQ2OrXBxACQivlSfVXOsQb14l0KOgVtzXNRHSPVKzOcU6QCG3WjDzVKuCY+c3N81QsRNCZlOMC8t9IGQMwNre9whzZd4FdVxNvYBVE8WPuKCg4Da9wBlTfoqWydNwCL4Lvscn1CQaBVKKPHfljFwHk2/Dv2gZGg0BxdrSwOpIBvwIcJTVmXslPaMsvLSvIx87iWETOQ2PWYLYVzH6B/Ps4oK+CYzSefocv1M9zgR+FHvUcMv+W78wbhf5cglBQPa/kz/KfqH0E/pmFj/wDCggF+ivxRPFUCfliMmirKXsGIVG9sxStPulTHgPVOPMFcdnTI+YsnjZW4wtsK67O7dS81p27D1XRTCxqBkzvrjESOIBawqzmHUEFQQV1OpKOgCsAYMYGmJqJQDQ2dyowdmVK02moGnUJm9047kRIFIudvDiP04OFCUqzupBUliAWvxxUS5sCNdeN9ZRKBQcNHNVxGVfQjRlwDnvKzGEWMhzSdS4MOAydU1hOWdNUC2V5F17SxtoWOR+yOetaELnWEOpBCv2WDR3cRqcLLkK9giRMEqlvAX8yx1Wq+d1Tj5IXM0GMk6tNpe6Sg5jqCFe8HlrNgT4weWI1hLVVb8FsbqHKooHSms+8EN8RvlPND+JSdVl306NV+JfjXqXjlH9xV6mxQ10FwlunK3fgQqpgjLo9ot0G3uy96XFYDETaVmVKlejDQH1fwUfmf6D2xSUFtb/8ABqCbawUleYOAT6ZYpQ5VcQtbe6NUQv8AzmVIueKPzBhcrkiwdeBP7SHKpYsHRKPtmVwlo3e6pH8zFTuCZr8MSL7liONbvzAAllMD60eIro3YWvcT/MWFw2pRCBzTs3+p1wdNu+vjUDD2MnJqm75viH5nzUa1CLSzhfHERCCqAP61DEWiUqKNXafiVcqMoMt4GFpvrEOUuySsnJgV1gm4F1aeKz7hxkdILeGRzZCawhZXFlXoccxMjqlSNESvxzKgYN2iji6vuiwOdlEDgtrsjVrqVqJyU3W8MNuVYCV3CAFBg6o4RAT4gVgOWJdKtfqYAQMttXQ6d4DqkGbB5v8ApEarBn7xYRqUOEAJndKQAHFLs33OsvVCVYu19LvJLAmudKPiY9GilKdE7RqoOrDVppwAbhZRtiXRq4pi+hArZqYFsWDqI4ly5X8VrcKKG6sj5Co01lw34tfqYBLo59AmwRzbftWHxAfBPgKWUYCDj/VoALcc/hKl+UVr8RCny32TCLHkBFcuEijYPOsPswSoEarQ9yyu8dWe90Hi1FwDNxclUpmrSqvccutAUsHsFduYHw7yJ0XJ4GHqnOv2RKYmazAVBw8xwFioxix4xFuPaltpZXMUNbvVWPFwIdGGVdWAFolHYurekEZJTyRw5zW5oDJuiBvBYYjkAmRVA8Lg/FwUhpTYr4trszOkLEKYeKNPzMqOzIS1qxrxmMMGsFZb3ur8bhTSHLgmg5mqNJKozgODfEO1W7QScrtnxLrPfDaj209Lgu5EogrmrzcuEhoFGu1uXll507GAU4wYY4NFDZw7tiPhTYT2bsessViooFL7VVeIIO9ZAV025O1QIGQrCLpbVMJmztrXWv6lOgFFhk++YgKuJ1lfo8BwR3zRaX4gwhZujjzCqFAzqKxbYqIsERvUVf8AConEO2C92/aHt3GXonadwh27f1J/AQ6yNe0O1j7VNnVcY8Nj8EWCxAmPYUPqUuhRwOyE92Fyh0+4Rde8Jxbwaj3W0HLTwge0EdreiMN8LkdfKSknk+sE/UZsjkf54mMAyUUPgZFlW1j/AE3AvIGn9QpoUpo1Og2ERZo4NA7IC/aAGPyKU6oaInJWtG/qpfnaMAhZOF0CV8y2tgbhcLT4XzMMHQfQiDrHLS+9almwDFKocC77zYLXOauq4xTHDAWZLdFa3LQaELLe+ktQLbIs1kGIkpDMzvFjD6MT1SsUDmWkWGcGOqN57kqA0EMYe2feJgJkKa61QMYWRYG9utn4horYilae+fzBsl5eU8Zq/iCTlmH4JhQcgRj+nbQuD0aNQDp9xIA3WaUiQgQ3mOKXf5lvUClCDzyeIqtu82u5ENEaxWHfME7dNreC2NZlyA77YlrBB1hMq3Jgi2p7HNsRiehL0C5o6cRWRYSVQuvxALwPMzZnv6ZVGreAOquAlWugx9ox73EFNTlcD9AgI9QNXky+z3hLD7K79p95Vp2rnqrKpIlhtnlg+c9pwmTPJO/hqB9X4hxkaW/GR3oedHsh9xg0FzVPKg94Yhcnb4wnzCTl4tWPKvowVD8aTpiJx+CsD2Y/Upbj/wBgqRN6L1YG+oL8plc1Xf8AE2nwQrItYzuc0YaEZctqn2oi1oayD2v8xk5UujH7/wCSkAAcm4CqqlVU8IvY4ygHJqFbexMIuoyPDDegLxfxCZW60OM9H+5QgKLZb7HSWJk0IeBt8jCDhowC/J34ZpaqovM7sXq+YkzTgE7F9feK4mNwu8YB+pdle6QodDLL6Mqyw9gxREhhBtxwqE/EMoVgoBffL7lCeerVLq7l1NGqP0x21C64O4+MssoFBBR9qj3BgBh1yjAXeThLPYpClOHdV8xMvA9K/wCu0GwyBQSn2WyN2/0b3Fjt09hZ77mE1uC9MtCwaXt6Sqbjhq3SCrzOBtZag0wbX4nNKPaOShmG/YFB0l9AY11iihOqVLHEvKNqwtOjy99EGZOVktwrag679ZpPDrwZhtKmBR7cvdthEXtoNrEY1w6uwNvYHiLij1UKLzy3zUtrcUgN85faK+UnL5YiStNV+w8EXqt9V8i08vaW6SaD8IDywYqcIW+7X0MrzMRa/en2hyu65fR+CCZw0LVXFVkgmzWBbfKPy2e0ZcxyPtWfYCVwfLHI5V4PMLC4V98we7Dpa6wAdgCr4gXOHdCvEAyt8GWXmgc/iUPJ5BB2WX8EpmDDlvvGswpZfKx0i0AgZhansEdZBv3S/Xw8fMdoXQNuib8Msz20m+p1HzLuYHWQxi7TxBqU0slT4HzKwNVLhqnFPaI0U7YPurRO8uwsEyK6DHzLf2Xk9ESpairYGI/pj9C25T/LhAsM2v4NeSBgS2gXHuXXaEQ2UmEz1LZXQkeh7ElwZTSFjvFHIUq5FNtMexjanb0xmBbGiirrrzcQAWLrLvZ+oimhkKLfSn/sR7pbKW+9y/sjjowChy89IuqK6H7i2sYJavuAaFuU0dhhezquiYKHKXasnDNRjSHECQicUWSiD2HEeh1AGAtUGhfgRKrbK0vc6DvtlSoTDVCeheO72IAwNQCnU8gdXNxUl7S35Y0FsYmiyql2cvvREsIcR7b8FsrZSpwPHJ4IOtTIwOHdeKlsjFB0PCZ+4GRryrZfLlltiZumD63KowGzA6qwtUVoHxPHvuZr1VXZN3XfqyogtoMeyLQDlUIUacpLUdS4V3cdCZj6cSArOAx8LhWEQ2tF06wRZDLZXyHXpNsiqK30PEBAAMG3/wCv0QJvcvkmL47xlBhGxBcFdszVJDjlP1+IymkFLo/2IVWppZfGdwUGjoqk8XKvAG9ReuHDcvMYtF5xVNNQPa6Mi2WXSdRyReg64t3gmMh6SgJ78y8hEoAhTonLH7F3WT8mYOZtKaFO9f1AcLnGPnj3irGea6F9yxgeiGAb4rMWjUWUNns0wSiZYosFXVZpOkJZUDXNf1Fk2Kqyrhue5mcZRDkdOb766yiYcpr3yyS/nqED7jBhAJzXkJlKd4METzLSLRaaLfd6SpqXAGKrgdlhGIRw35mFpiM3lGGOeEBvsEDdii1a+piIOA48y4yRxaiL2ibgvc6xUHkidrXuj9OD3leg5qGBrurx3c8S92KTTqwfI7qBUDvGh+ln2Yg7XdL2WvbnvGQbZOByNB1YhAJ0Ubaa9z7EaxpKVR9AD2XvG7IVoYo6AeQfZiw5dmD8sfVHueCj7jbFLIvPVbWBloZ3u/dgYTpQxo2/T03CUEppTGmtUONAmaAaPp29+YQgqtDk0e8KTKjyJYex9ymhdN31ZahLlpixsPJEJtdQreQ7B0gpnW78xmCUvKjQ8Bb5malgR6Ur4uCi2DD2e/mFZC0QQIla8xQMgpNzz5C2+ych03La9rFsXhbXuuJRWBbQDr3O2yLbAjRS7LzEA0h+U0YfZGVqAGPoPbTLJznlLHvd/iWDB1bJ4HftApc5BmvG32hF+IE8Hl7kzBrMr8P6iDyj2FcZqWqY1ms7Dhvp+JTjG8NnY+epLUytBVdnghK6XJSAnjIRQIWiZt5VWPkekfxoN68nj4i/I71nCFh9oFoouhso6FTN3C6Fe5GCpeusHgDRhUHALs3k+ZWtdyCjHeUNtLrB8sqA1w/uU43bpk94LpDXAmNbbTxUZBVHcu5u5UqFG4Wj6XjrHrtbf9xByX0G/wD5P8R/v/UcLe1+Ox2jtgK30P2vBzCVEFe1L5e2iZHrhcPPhw95bcGd1Htani7JRVvdKhrBVeufafDA6+IXbHI6EfmIvDrnzx4H2zA6FV5B+Z7UTWcwupw93ESKvKhyv/Y4wytZ5+4rQz1yxTYVpi8dre0ArpiysNsd6PtiJaMncGKXt+o3jVtHt1/cQV4C9W2f6jmWfCmX2sgjtN1DVIu+5Kuba4A8L2azATgxnFLp99QyKOEP/SaBTKaJeGCA5LUO46ITusJTxcfghJY4BR0lgXaiWnY5HS5RsrwO7XMCkbz6wxdsM2dq2N8H+4mh2zbfphTuPiURmlJbteEfJNHYXIBMdsxhzVYMcf8AUGK93ZCni0Y9OrApfxN0DYLILwuJ19DY0va3ctnawrLusx+JgJFifeNV4hbi8C/J0i82eBX1HIqco0fUttlvTmAQRgaCXg9il9sQq7Dqzh1YAVCUVjL1hbEjDbZ7RqgJVjL8ykSqcs3Lnx6PRrq9DrL5WAodD+3mc6Grlq6Hl+iZ1x0u/L58a9DQWrQd4ANbWvtP6HaeQzdDX6j3lTPiKP5CAoDu/pHDeXxMWQGEagN16OgdriCEYKa6PfleXMIbWVuOD7JagtVrv+oYQ/ii/wBIlplAXtZglzjLamUdCdtXV8RLDZ3f0rk+JWAWpsNr206Xi9cEzFoXsuhjxe+WKM5d0Oiox7TClpR99+/ScdSPAdPN5WEbpj8P7iMhbJ1IzYDmnH4Ll3mAc7NX1LghshR2DartKg0aTVcIeHjpC8CKDxfXprw8xjgBhP2E+xnL0rYHtK8gfCJ8cd4jOtQ1FoLYvpeIGGqWu/8AjFh6w8eWxgOzeuv4jP6MseubB/ygoKTBdXh3T2YUFrDdjwlQTiDBbbbzfzFim3SCy+Q/6lmgIapXtsp9mIBveNs9HAP5jOwSy/2LOTuTDCFI8noGztGVjjnLjskbQWOZRCCZVRLBahgoxDDBfRgvb29LgAK1ma+gPBi+8ZQo3rkJTC0ZV32jpmuBLQp7yogR3XscHvDJHQ/s/UsbbVHAHQOCVKjt6nsHL+pucVHbv7SwaQ8LXzuVBSIU1fxBtLdt/iYTQ4uvzAcAMK18F7YuINCOhLDzyy6yzJdVDijkge4v8QBsdzHGAlnniAnZVYJyKnQYDpTh3nNvYMwFe+hiL6Yq0+CGQrnM87A7XmJwOF15wmMrBodTFn5lW0tTfHH5hKU2KJ4dzA5JF6plfeXD5XsP9xtVQB1AXwqe8YQtbfZeXvAuFknbRv3CPCVqkRXsHIQxLhRtmuouGLoop331MvQMniVwGlc5aOi+G6YBs3dB/wB6SnbIF+e46qyZahYrfI0lZhVkFiq12Kae57kcAEyYrqdBBRSu0APJ07bh0Ab00W+/MCwG1WBBxZbqV0xRWRWhdOjK2y5YXfO3fcmiWoFr+efci5fV+TVXLnThBo6s6sOzUCBaNe0TZArQ9oOrcOSBrJc1wLS8EAjawA/mUH3GP7ktyDIwLMvEDBpLFrOhiQyeahBemXwRdxtz08SpXpUJi0Ae2/uYdf2DfzKlSoM4fmYlA1iIW+WqDPdiMiTkw1oeWWYLE6rAOH3G9L4OPwTCgA7wLhFHSMLRXQMxEokZTb+A46ysj1HKrlXyxQtAUdV1GLM38d4Ab6A7537wAu1r+9/qZo4T4GVDZY7Wf9lwLTeXqdIgWiWcGV95qcUPDj4xGCDicV/hbj5gVbsz8x0YoGS3p4rJC0AYulrgPTrfGY4Xhadhxx1EaQTTOVvrvELoK2MaO08rn4TFO+a2B1Hp+OYgHBojq+nchZTTaVaORHcLCohatrizZ0IioGV2VW89R7Y6ktdAkNvROneGB7RgrWv7QiNhrL2N3/SRPKVEdO+RWekCyAugDF56PqHZMUoWcg7GFIGxiWG0SN64FNvZrDKxxUnFTwuq/KVDTdIYruQBZaw94qi7yVmYNQ8Bv3mpxVEpZnKG3qIagxSITD5TemJih3dio0a/aOK9X0SpUqVLPMRyrKlSoBDnweUOFe1MI6+cwji54Dj4mcGvAj8xRuCIigZ8TA2X1igHqPKOs0dFvtEvm79o5vRuxhrRegcsw1TrXeLwhbyxI7HHQuq+5U3hX5fqoiW7edA/EqrOmOnnqxxmQNbV3iBY6q6i4RirB0Or2lgttCOF3Pa4huWBy0FzzbqFjU0Gujx4ziJDFzacO/MNEmy5DOP1Cm3Zdm7dE4YIVFFeYmx36krAZLDbwoHTk+JkVBNbHusf3BwgtmawWOvJHtCach9Ujh44O5TERbB14G+phlfuTayysofdfEoqqAxAnbL4cRdjzY2U8lcQnSYaij6bgJaXBMrhsPzELhH3LOvJc32O7J1nHVw0q/ERE500FV6+dx0aTWtMDa8X3l2bZvBfgjlvW3SEWSmmkTmdbDsZfGnIWV5jlEqsow+I52F7/wBTJ7SpUqVPtSpUqF4FiPXJ6hD/AED/AMm2PljnJ4ICWleW2UZod0gN2fMtUKPlfEYIH5m4CtOYgyzziAWI92IaItVhTrcMlkfiVpCGs38yqBWl8bv9TTam49u0z2cP5heQIO8FlBSn5xCI1kJ6OF/UFVF35bjiDuSBYnvBmsIBeKGXywZgIKrIwLzxLC/AFZPrMCXdVQ8p8RBbYWVY2N4pw/MByoq6BHD2S7HSS8Q5YZQukpIBzljRJG0f9HEQuQcjQvNaByhmUob4VxKBE7moM6Bs7osTl8uJZoSDqjV3qk6MIq3A4q4oGLPd1gLcXYLHg3bfs43EkDCGH+6RA1rwGu97+YHdBltfslMGyjI2/MIXQaoRB3LYaRL5VYPDAXMbC4owZKviFrZ4jDhOLVBo6tJ/cckgYjnkLC8/mWgkNAp+pbUl4Vb9SvRUwRgeipUNDAzuXW0VsmUNecw8OPL/AFP+MhXP0fVzki9Vv+iAqb7b+WIkDlaYQquBQX2iNg30vU65UNRK3TFbtCntFVGQvwR2IztEU0uR/ErGotfseDibwrauKyx44TarNbh3iilDE8hjHsfMDDS8Q4pLHi8x6fPE25FT5haYVzRhX5iiEQLkGDjnEIcSg71oezwxyBA2ZA3iV5GMmj37MIXkqA9S9sG2w37KdFxHBeRbomKdfiXYE0A32Gq618MHCwZQu18Pc2SyEc0UF61d+YkWqGLAOQHhiC72nIOx3bTwyuMZDmx4uZNB1a7pyPWGocEa+wjAPNbXtKpgtZVV1jjkwKOvTBUMgpoAAeNR+FsLyOiEt5RYpqr4mKdMVi1HopnKx6alQiOl0cYgMtU4zf1BBV9AyeYgSmCkDHah8ha+8xxK1wR80mhJUqB6leoLZaOsBerDg3rSS5l+iBUGlYtahrV38Nwjd8nxLispy8RXtXF49hATEdpzOvxg1GsoBtrBF6tdQ346QwChfN5/6j9XRdA/2o4UsVvqTH5lVBdgTvv5JWrDgB6lJKhkLzA0gsp6Hr3i4N0HTrLXa/mUzUwnNNYxxjEDl1BlVbVr6RjtttilUOEYJmLK7Cyn25iIAHmzirPEMQgjawxSm8dfMSgywol6z+El/fNw1RyMCdmJnRjZ3tU56QBpXDVoaOj8QxweysCoZsu3tFNqRfCbGtnfZOJdqS3N9tJGipKMwbl5z6OtTMvcU57sTrcMVSznjJNzQYdd6jjtqHAw5XJ4H7gAHTFpGMDq4Vdp3lZQqoZOqDnzLdIclDFCalMg1lcDXfrDNBhoWeGaDEyoy7IxNKtjjfZGMwuuqp2eYBJ7XErS8COyXBt3TWphENaKIboQ2hC4KBq9mVAhFSpUqVNMQchvoMMKWeVm6OulE3AvtX9wHC9t3M5Sr3qYA6CBA9rp/cXoj532usbLicvHeEGXVcAO0qGZeuoewDV+rnEZTgFRuBIswcAOZloJp8Zv3Z06P1v/AJKo63fgCfELGrVQYvp30igsqinC/qGsKik6psSH1gD3KTwwudVYG3DPc3EyCALwtq9gxC1lKAcdUOsmSFvY2KN1ZpvPPiAACiKtC7yTLZRt92avp+4d/qoBqvYxMqIFRRL5rcJqBSr2eCVmU3LEMWAk9wxKah7INHzAtrHCxR/HCKpb0oNpzU6dYpI4IWB4HU5mKwHolW5B/wAwKILomT9iTWW6P7kdhCjlQCrPkesd6oOpkcdIlfmBYJLtDXkl7uKFNc2JW431EbvteZlh7ZbfFyo17wTD2Ygbqp5fZJjbo2Vb7uoYD15C6hDaZc/tC7RFtlW8sNjKr9XSGbd1V32KgS02+SVAiSoEqBASNu4eCBlpui1+ZSNN9XicpSm7il1dXAfMG6LeyvmLXCSIUWfn5YRQ9l9IOahn/qMMLrF8EJDaGXv2IjVGLTi0lxF3caOv9TGc6r65hCqK2cY6HVhjBYNBRaWeYc9oO2f8wA8nJ0zFFsS4Haq8YtguywX7wWd4UOF17AtfiYQopyIo2f7ccmqqGAoA+CBHOXzsfrEMyaWAqFLvll0mvI6Viz8wWw1blTfJj6Y9QYYmn+4tRaxpqj+5c6WgoMqz7RiOWosjftiUDAIbtqlUdaeGOKbKuCPQOu0LZvHHPk6yq0tJxbSsnZ6mY8U3F68ciZxfJjmGqAabItca35lBOvFbk27a2RjCyvYyHc4SWIAv/DP5gJMo8Ed2sRts8wmHACxfuDS+5C+cs3U5zv5lKh1T9ImjtVUG+lwrQCNKbTvxDZ4asWV7bl5JS3aeOYSRttYe+AiuDyRoHaM2rTuHiXMrzdyvQJUqVAjUu8MtNV5iYYM8SzLtM0QewHTcVDdc2qGLPkGj4h+HbLrwOsEobVA/5AYwbUtVFYWAZQox+Y7QY5/7LB1ir/qIwZSg6EFAtZny/wCy12Rsw0/i47ErXpg39ys23YrpfS/MKabdOpzz02xqCt2vLo8Smjuu+g/KuWXpBKeUB8wKKsArnOce8dwtlO39BCA3oFayb94+1tKCbBDDCkypWy6ePi/iHMV13pLTuMvBbl1eL+5YQhWzlde5Lwb0BikfbcaOiyDrZXMbkRQriu97I1JAWeRyL2HbURRtkGwxSOV7ys1OuYNZWZ0kdlOQsvMjNdy4JwVIbDU5xj2mC1YUnNq2ulx+GwEwnPe4YqtA1p76PHeIQ3IuC5L1iVCswNiwHPd3O8UIWsQkAnA4faKAZZxk+dxqNDL7xjmVqac8P3HgwuEiofQW7AfRLlBNApXswKX1CJ9xJdrtC/LiF0BUOGoUu0ayfqBAlSvQjOZzDC+38s3OSCdXlEWUFvvJ+MypxdgHywngHgvwG5WzWg5HmteCIU7cWLXsBHh1MjwvmLpXola4CMEGM54lh05ex/2aCVVvTtGXZX/TMtABy88xgHQD0FvXcjYdWOtBvzvUPWpKvUy+RlLblVdhhR3plPVsjAVgffcvKUNhusjxiUDzsHkYfmbICENVURzBQ73j3EtqsNjybJQ1yxss3z5uXfEpgvPK7nbiWBF74gaFionR7Qr4z2XyEy4I2rC+zXTrKMrng8j1MwVVKAbKwPToeSK5oE2JeTvgcTdOaGw3s7dpQnrXR1DzdMdvJpKHm+lm4UJmUBksekqAJgBkxoe3TpBHgmnwlhq+f3LtrDfkDQXZfWPwRuiZB0ubnXkcP6D8wwAvgUYGWAWBhOj1ISxNkWFt/wBEfajsLCc6RAYeQwRoR1PxE5jRd18xxq+H9iKb9HWr94+BAG26etzvfbCV6XCMuXLuM37mNmC8Y+5sgdaW4146vzB7crV8w0Le7Af3A5FQZpQeI0OA4sv/AOzNUju56HfpHksPDQ8VFlaChz4BxCCiG3x/UZADtXAGriNlpXsc296hvspRevMCvQ21hTqKVR8qZae2orhxg9VwQCSmxrIK5vsfmPFkj92ZnuWroAAd2rlILQXtu2O8Jib2EqxS/pl6qtidtJ5G4EYlFo8CU/iI8ZFHw6rtAel2pHn/AJYtXEt5prF66GZxCrOLHT2U30SaHGnSZw/pisgkU2s+1lvZiGD3w6fc56JcvbKLW456SZp6RvEoSy5w5rYfEbRWpN5GC7xjO+ZZ14LN1ryHD7MbGiwV3/2olLV4Lt3rj6jHMuXGyxZwwmBCLEN6DxcT0LkljfS7oh0RDCjnjyGICXAvPh6xKI0V9j51GprIJTXU7RNTOMg8TK1QWMj3mW0KOcd0jzKdG7wwwCzTr8Q3UQYLshCkrIWfMrNm8EPoDVj/AKShKp6OJcuXBiy54TRNRHAXxDVTJ1zCF48f8jKy0azn5/qGxkDm2g+MzNPG18OkVtQDg7fqLAOZR7FvyxttbeQOxys2ifSnyX4NRAGJ+UNc9IZ5wCgXli3p2IBrpyXPlmNiLcbdKHa4gbIvYGQ97mZRQfTR78y7txRc5VDXUCyNHuZ5BarymjvBDWKzABi+/MsSwItcuav2ma8CjWirX5ggVjRTtRqArACy3R/ntLgVTy5YBgOgEdtp7THD0joxIgaOe9e8QVaJhN1e57x3ZQllWd3WZRyzyPgi6cJxBCVsOQui7vS+0NAYA5z4TsP0xdr7JHYMezxKmKDYsWHSIF9VmLpu8/MRFNaeAOF/DBazstlp464ihFqkBnWEHT8ReoDuwwvR3JVtJlY1HR/PSDs2FKsbHMRmxNH2tpa8lwoxoppf/kSoHA1hbH5ljXYxqwv6uogBhlgoY22M9pd2C0p+kl5zDOUvwyyL+x+YdisOBv5OIZWlfa/MZCjjiXsQBeva2+IZDeGiXLly/UE5gL5O+YqcHYjCF7X+YqtSm9E5Rd8fA3HLEaAo8Bz5lyoFkVerIUPuxpTml58BV+DExPWVwp4Ne8XtmCFK61+2Xi8rgzV8eYJb11oHY6sGBYYa+4ukeWwAuQy9hy8xrSso6ybU7sZjadSlz5ojPIYJeF++ixBrGOkDA1DdNgTbaNqwAKts26Dn7igROBKu1B9+JmYS88IOj9Tn4B75GFlkI/wfa5XzBU7WkLDsGBrJrxVQ1kMM6KCuSr8yocMxV1A/2NwTuskcA9nWnJ0uP6xLQ7Gaeee5EtC8nmD1xh7QGBA7SVZ4NJyTSkqp0enXo6S6JQ2XmrjhczaK/n+4HZk0sOvSXJBbYL4Oz0lOSCwZtNLVPR5j9DoFwRwJf7ydZmrQC4wpD89YkxzKYBoR1Z1gTfYMlh3nFPSEeTklTk9ptArOh2jtThstyHS473ZExhKej5lDbQ71DaPFBwLquHqQcYAty/JslpV1/JUxLWc6EvbV914jiCGBa+dxnoFy90sQiAXdtMACUG/Qv+YAy6t6cRBWpxo+o4gU68e0W7k9XiWVILtw+Dma/Ol+DS+7KxcjehOBRgQbZqlt75fcx3itEl7AVxfL0DBAxUdv4H9xALT4Xt0uKyDMtUBkI5LoCoOz45jBNgFTegCbzpscW/pCYwUO7IroYivMmkODr/iAqLIHiw6ec+0TssY5QYAIiXY0t1X6l8pYymGkfxFrVjVX1njcQgYvKteTQ+IgK1Qb2U84WNBVjDoUeLBjyLtzJRzcXZUB1CXbHz620zEdKNLsHm3xMZbADq456/mDiGqso6ldK+oCktLznqHc56wStIJrT930lZOrbzh87hQ3Y62JEgJCqKodUuHolIVWlWU8NvsYJRVReW2GgejTKpdWZmFlP6RWWrUNAdK0+IbgaEvCLa5ioRrAYB1eYhULBtg6f7lNvjAa8pfL5yNWcrvKSORw4c/EXaUGMgRhw0tpunqpezoeT3lt95oh0bDDv7IAkpkFofMdUTpAN/uOk5eawfMqObG6vzG914zl+o/xA5qdYqQYyCvthGgtg492WdRng1Livc4Hvz7TW86n0csVIhSprXnARy1egobKtx5+oqCONc7gDYdddJbIK3Fi+t8Er2HRlHnumFzpNBy6t6+YU3RXbyV2XHeNoF7U7Ce3Mc97bdo3j5l0dtjuwe4KwKzTLHVNO2URTP0Mj6vzm7gFK6lghy7agLsVF5oHHwGIPNpPQS4vwxyvtqMNIFN4Vx+ZuLWKwFETxmW6nljs9ymFWks11qkfiPSwlDV56wEXbDpZrJ1GNqFK2aKcJD3Bubl79mOcEig8prPPaPaFFpha6usG2lNWUPReHzhghaR5GHk6jBQB6UReOcPxDC1diYSnqOElcEXw9H/4hI9ehp7APzFSBLXhOEta+SFBlgSKrCvxHEXhtRsAIGdH7RnByF0xGrkVnApz5jAWC+xyqGKLbNOsqCaLv7s8xQ2AvcdmElW1Mr7R8LWic/NSsiSmhfSEVYbq2GWpDyr6SrSl75fcYMHj1Lj6FOYcjAPJ5amPym37iBlV6vErxHYOviD4Cbp+2VKFcP7gNQ1gH4DiCKw8y9ja92HooJeAe047cx7NDojp4+CGXcFxQnOoDq9oCtb3jKvPB1ZeBqDcE/R0hyMAh1nR+2ACOguKXb1wQsAuNl9nS5ZeFToMg/UNBuBkXH8XRLMI/J1fA6xoBzWeXmE3di7T9qIRwprfc2/EarePsLmNBFlnlCfglPLlw5MP2Mulva9dPshY0XAc5v7IjkSBWM8ezMZGsTjTPnr1gUqpW6zThs5Osz0MxtT3LhjaBTlW4Q5rTHuxicx6OzTxeI9qX1go9HJ1uU1Tpyds4hW2eUpHyUn4lCJ2L2J3xf5jMgyzeR7jxHJVt1kp3JUPsoCvNvUdTZNqQW2cZOGE2CqMQBp61+JXUJpLMt6cZqL5x0iA9IpRWtl2lYsZVhChxHWY+qDtVZ3XhghG3Q13rpAWqV0KR7nJAzGA/NFbajNOU7zkQCLkdyNm4s02dSJUYpodlwRL40LZCtIvcV6F/iFy/RUFq+NmBCuzq9ViNC+SXR6hVsCpZ52feteIvlXbmJIrRoqjslZEb3z+22bTmUuh3/pKlo6Oqrr2IV9XkafHbvMkqt4FDnwwETFWGc5UJkKqWG0XV9zXiIB3xczQYNUfBDgXzbE0V1Xb2l3OEOhd29tsrf3G6cAdgz3gV9XGHgPY+4ASxtbrD/cFG3rpRZ7MAqKqd018w1rJEeLH9xVCnVXMMPjrDBSmkc3XD3KruSj0KHKYTqYe0rqSwtwBj8EAM3X1oYbORrMBvY7XYtPXvhijnS2CGM/9jY1F2revQ9estoGGlHTBadesUSy7TJXInJFM8yTAOj1gFbBAUFj0Rw/6pQoBYWRJmg5/SXUWpR2OjwLj8xM2ext5YeTmMaEqwAjw1dSqFuXrSKTyl2iGkWHrpV/cUDaoNu2695Vm0raZ6OGVFfEUrboO67MYcLsx9XLAtejWdfc24C0ba94RyL169yAgSXTevmPal8AcifVM3VpS6f8AsFI5KstE6QoFFOKTz/cxgB3WRLQV3i/zAp6QLuCLA2rb7wCBPtle/wDUSlHrh9o6e0xBWVjSvROVBbHxb/MPoE6Xf5gtRVdrlpUB8F/uNUF6G/LtF0JDG33VuMjpDN1q3olIFVdOsnu7wQtsSzagG3Gg4iKILZyja3xxLYqt2HQErS76G0HPdaAmbLwQ758AISP0jbX6xLGLcAgKHtcOIwt4C1fEXytA1t/VQcikCOx/cUTQ0TlT81jFK1kK5T8/MEQS/csFdMwoqBWW7Fc2fnMehRXbVnc113MtXSqyU8PaWKxWM760vbj6lqZ/LmuE/UDKGw5Kd9H24lnNbD9HDGAsM4LDrT+RuCJUuKQVmqdkHPQNdRwmLqbLWlUsOF1fRwxKIgsY9MZBxwkNNc3TPZHDcPIOsWuWC+ZdKNQ2yvk+lMZVjVcG90nXEBhANK28o4lKKtWFPbP1LlSCrP8AI/UNYLd8leNQXpAY1x7uvWX0qXnWejBkF1/BJqhLGw+0YLCo0YUMS3sLdu0ZRTeFKPebFpzpXzFKndAJK/wF5eXlpeOCa6sGs/ceAIuDFgpuvaFsnxqnzE3k8P8AcE7PIMqwPcH+Yvdb5y/dxRX1h9y+mmbgBly5g4mmVM+EDBrM8Kti1YEqMV33L5jhwyHUBw9C2GrgoYo6LOrHzyrF5bFfqVO8RosqgPP4IKBawdDR9w3Nq6ZsOvdfqbnFPsBXvDtfgrXj2qFMsUc6aWz7jcbqK0rgXs1XmYgWdW9mB94FEAGLQcj+GIqGyubqEYMdnvXPxL01Gejt+wnDAKHA4TszKNAuvzKChJ5KdO3Z1G4unJSnOzZBiQWUevjJccWFAI2V/wBbhhCicBU6g3457y6OcFGTg/sdSuvAFaEaHp1EjVQ2gw4B15uFQsSNjOckrCAbDodnlhms5TQOipqW0KC6RpOo9YpWK1gHtDI2C01T7010gxcOaKvzASPd8Z6wjIb3cyNhRuZ6wiC7DgOThJU2DCZT0iIEE7nmOsKigNHcYmnWMZalapnO34/8CIOi92MW+8t+iBZzqieKMvQjoSfgYq7E6BfuoqVReASPgPhuMzf6md+bh4Bj9sWm4HQ8/olqCsCBfFtjc07qEMIcBFxNl+uuA69IS+gVanqwMAwBSLtbuFKgE4oU7XUq0Kl8iar/AHEKtbVi9DUwpxF7CrlAJmt7ofSYTd8ORRf3GjzQV8bT9y0VqFo6mnhhCEUPZv8A7HeIdcg4O9al5Cwt8J3/AH0htZab7p+yLkzbnC3hrhlA2eTnudn6lFLcrwOSnk5JRlgc5Hyc0d9RJSq0dhYbO5qIEC0GRTQSZ0wNts1rjoMKLoxyDs7P3C3DS2opiaXIUriPJx7JgV1AoD2K3KONWFdnUtj2GEBtiqodTkgmvLA1xrp1qERqqCwX2PaGUsvDLbemMitFmxOzLA2jRmuL4YotLidj+yPii6zsgefqcwqrMBy5XeNtJZ1Oe0HLLmm6e50hk7pdDxxEFCGbEPibFJ6l/wDkxY14hjD5Jg6i27YyLbWW36IA1PeVy56tn4lM+3LvzU2h1Afie/R3gXhVxn4lvUAbAO9WvtKrzEcALigIqpsYLOXPmbwqG3F51ncGiijBVL+XyRGQBYNKrJ/EdSFqebp1+LiOFRUdKYeajyjQzzVf1KmUqrOafyP1OQg2eB/Up9t3Rp8EdR6qqw6VmvNccymyhTmoPoMLwsAHe8J3l8CF2q6BqyVc4lHfuO34xBUNbYKJdZRwMjEtqg5e66dHiAEOu/Dw/wD2WWVRHR2f3KusO8IcVi/bMSpdhlChfKv1FxZpkOKvIG6ejDiKeoWHgR4YUhqhVqNHZDNGVbBvkMiX0jMyihUE4AcxkGBYwl9sxC0W6TSPc6RaN0gYrlT/AFwDHYKha7/kYE0hSmw8RhvNXjsxKUdR0kJUD2tIZqsvJz7Q7Sdgr+oHdN4TSdoOiuC8/wCJZlJuzXmuILeEYQYx0lsIDrr4gBkdVh/8kOA+alrX0n4YXyb1IafPG1PzAbUex/cFBrYF/rBMIHsh5SJha+Aqg6q1CuhPvvp1iyq3XF9m8EwR8038wThTYglZu3zOJBk2uiu7xGWEpSNAIpctpb2ODsnd1LdEBWQS1HjXmUFLhlN7av7YOl4mtdR8xqOFzqUD8k0PA6AwPKMu5AkboUeRio95muXZT7k3LzR4VY/3Am4RiAij6xUcvXUGl1U9ki63BQw0yPXRZplQJHgauFd0+yEymdqrJv8A4isKNB2CXqtZxcenQPJvAby50IGliE4DudSIA1IrHpf9wwooXAHrWmNRFuC6nk6VDaHBWFPyH5iIpCq18neOsOixMlaMJYRmacjfM8UDojcaBAqgpfYfeMlIHAIkrLjVLCcWZHzLcJWcX4Wi/eHXVACw9+kysStjIOjKQa7CldkgvhjkPZjZZBlMnZ8Rbls5bK8xXC22mViIaHpmdurTL0BMma9orKVWhp7VNRxSI0Lfk/8AQWJk9lqVVi+bg1g+5H0puKB4057TJTmxyO63/EfiB2hf61EIm74B9YyrAUMBbeu0zIbLyaNFv6JWNslHTCrO/SNK7CnStX1qDWXbBnQo61pdRKl+pc5/qK6phfJeILR+qFnXHEWAVQOpkF+SX+r3qqVzF5gKTk8+/MQaBffZPqNNYoiWItr4zB7ClDkODrs+JQrbBgg0/i4jKZitI4a7Msw22EugyPkK+IBaBQM9CzmvkhNUG7KHYF2dIpTZVaRNIOg+zCAFmBKaM66nErOItppV1Or4HEeIzy+l5oXHs7mId4uI7Xh8biHSOB3VmqZz3mBErSS61i/IxCS2L61kUDD3g6q+QN9BHHZiuvAAa6wNIYFjR3aYlS1YOatvhGPCFILLgb2SlRtmQIYoVqHpTa4eaOIhCFPUe8ScXTn8d49ZKvYPZgGjNGm9jM+lVk48wbgkzWajW8pTS2vtCUgUqs/9mGB2tVrdJBPOyVT/AMwt3BuvkgCIzxI6FXff2ygHekXHu29gYPUeWGeaBr8ythd5UbeBmn0qlB8FESwzTf8Am4T7gYfBzBgAM0Hv1exKJp2rQDwhaLLpaAFrFQKTT08xqAoF1yQfQAEGaZng2RpYZWQOK+SsIFXJXnrAkqFZXHvGkhnOq6/cfnAIOhBr5neUbhHT+pQOWoO+x1LilLXT2U7PSaDM0/kH9Q2gDdml5x5lvTkYwjTUCGcZ8Ncd1aXZzFbwEtuKdOjxBC4OE7TjuTr8yvQdMR5S/liKfTZiT2tp65jgN2MTslj+YyKfuTtfTvmFgUvLR5GrPEHSHM/C6MAj9agt1houYEm5vwbWAoK2SFvD+FI20KlTDVowOzKlHyKQPRGyHBbLKU7nUgCMVTZ+9MSoQ4DD4ioBA2XqGAFcoVKGFXeTt3uLqXTRprqQDKpxSkeiQyFE6mqlTreSwPs8xdLByIAn/nct6wKwq5vBWIQIwoSKHa34ldg9Cj9gR/R1uh9f2jKtorSB41NCN4sNvQgqBqyXo6Y0RB11Ry8TMhA0C0/3MzUBrsCoPKBLxiYY30mez0+IzWlxYy3d39S2N81dOfYh1Ui3m0uoVCC/F6mW4D4WF/cWFpldXVJ4cQBVMBMlgQe4zOUqR7D/APZRWIiGDqPaCiUPHaboRyd4ZW513vlcwkhawcHT/Iw91ussOOMcPuKqltiLdaYzyRhkNQbc6vadGXAraCi26u8H1BaSi2d8bvUoFDyCO74vkhAj2qV8P+8R0umoJRXRATxFY8mqU6jjPeGg02VLdQ+ncpLXUUM96lifoH/0FcMUbQUsAhwqVIWcnG+jkhoGoCtEPkPSLEFmx2p0w/MUCDeOe3eY5KZDYP6lcwRz1JSNmd1L0A0nUSYeWMno7uUQPZvfSFC1B1bT0Yo2Ow9XtGuaf+nMHD8kFjTx/SBEVV6rEsu7uCLR5BzL0ot1QC9+sRrgNpwef1BIfPXbqesS0HR1fF/mO3W6DpE+oKHd3B4UZM+zHmXiEC6+Li52Iq+NH5i2ADgfBKyysU61/wAqAuePAuj8xRsH5l59yMQCFzpCzqIw4jBm3ez5sgY0G/cg+Rg+Cu46c+HDDrG4rw66oK9Fjgely93OjT/xgFRxjo5Ds7pV8Vrer9p06iDT4lRRWMuWzm49KiU2C8nDfaISrSdf2/1TPwKNVPbo9TULDJ2gfHDEdgeq6+oVc3TlWKnKdzJuubah1hWvJiXUFEaGa8rKLsjjHHCXkmstIiw+F0wpEV0Wrxb9Q5UpAX8qmCxLMX1H4Zm8Tlp2ZxGlAXHDMlQWKHPZhoOAcnbtLFIlg7S6dS+owycjgbzA1WGlbaOsIRusASHsx3i4aKPl/wDQg6pRr4Q1Ste9rHoU74iy6lWO7xtOEs5tPF3PuURTEdI4bUq714jUrLs5vyyxVK4x+CDfRSDgF5Zn9XlotpgL9iNZewvjJ0mTFAA5QmDHMa+jRHKv5rljKKUE4Njw7Ja7a+evtETVGK2tq3eobM5Ler1hwLojfC9orRseDWIwvW403qvaUoVhTgOS+5eO0CBaNd40neCDBAvsSnDXJEjSntrDuVKUTJqfvpP4Y/kfLYDAl7QwkAo6YNQe7cEG+Ckoc4vXc1HqTBBV54E+oLqiwo8VJ0fME2EZcCYpukez7MG2PQDwmsfEegmRVg6w4r/YmaKFLV4/2YzioNEKHlj9qOmvkaZnjlChfUy1EGnKyUPU/WoVr6HF1xGSi+ayvEQTNMYGOtaY17lylNdklxecDSoKxVim9J1li9BrKj1IiyY4BRcZy2mZwIMHYnWHidwpOpcJK7VV/wCwHFwNYo7KlICvf8mEKN9Wj3UurXMbc9FrzCUwbUz3SwG+6xa336StNV3/AFMk2DV8cHbqwpA1YIq7rLHFk6G29Ep8AgDVLHyMqSWaVeF/DtFMeG4xaPxEIy1i0c8ooDYXhX9srION9qZVuwaNVSAutoBruP5IVQBtvRX5ZjuMaVOjR7Yj2M6uhy8zK8T7N0wLfIwvfOzhOkvO6WNUjVHh0pzKKKjGj5RM4zlW3TU4YPQAz0my0/Rg2dwuSt0nR030i6w4gwE5ze4yutnIhMFFg1y4ZRdULzxcicQ6dJcnt0DxuCFNo07V8zADU7Y/5EN00pVduJU3EbsK7icR6rZD6DqGAjYRNvQOH8zdMJFvJKQXHtB8ibqWM7NfC4FQOOt3FxE9V+opVWxTZ4qV4Xt4YzCvDj4j4XgDxApRRdnECeyw4f8A2A5Ytye5j4mDI64fbEIByaGB4CLSsHYgNmPTLT8CZ3uhXbtV6H5gq7MR77u35Q+QXo9n6iXGASuV2HfJGDZoOr/7KBCzu3p4fcQc7fLHPbcrVfIi2zg7pAkbBKzkGvEpAcYqrW6e0pMIZK9vhuMqo93UFHZu4Us4B2cmYQ6K/cGXLC9nDy0y7NuSN2W/MqlBQ7OfpLVLG79yeYQWrvRVw/dQTAgsoias9TUcbN1472eR6MZGFbNKaxfaYB0Unj/alEEYKvT79YtgIbHEDBauwFK8JqJuBcILwweW5d6ahLPGdPZiYE2up4Uv7MTMcCLnEbhLAq7Ao2e8cqFDqzeezxHT9sXZHNO1Gp2gYHo9L4lrBZ0V3GPDYeVzMVhqw4ZUq8OesQgSjrkh0LyMlae0JLKBs4TzGm+wI5DfWVeGZEI2dN5BZfU/9xdagTtT4JjFHU59oUdXpWXvEUdqXv0IzgooOjm3zFABzY76vh96lI19W93MHkoMJtGL8QtsqA30ngDc2IR1XKq4NRkrI5avNezBJAsB6YkIxNAeLK+ZZVLW++iKoLQKzQ4GOBwAz1u5sMgm7bh+yCKxZV7Fw/MVXtqIGgW69pvRaU4WG/EWWEvYD5RNVzEoGbmOZDoOfEyjY0btdhk6mItULZ7Ed44/UoXMbLUGrK/URVXBCHYRq/E4lRSYQ8CFdukKpPSfepVNoMDo7OkiuBRSBReXNS1iRzjTzxCdIvQNdRZO5B9LnN2C1+zL29vCatzTMyctgKHGS6Yevhlj5cS3w3NgnUswsQGg0YYhVvWkUSG7ABLC++MxqDoQw+UVhc1kNxzQb08R4mTDiHWPZ69FhZHSM1/UxYNwzmkBpYcXV/8Auc1qAJSHdmyb+wveGqGLHZd2+vxDAZDg3/yURgH+vMTKrIPY7Lg224itPwcJhFSe22h+4Ramziqp8+DqspjMZM6DqtI3bKUm1H/Yh4BK45u9+ooEgx4FfEvIKJ8coJEWAHo2kom0auwn0ZWDwvDVAe6xyjf8gHyVGTOAVzqx/M0ldNtWlj4Zlwulu8YzKLjRAvjgTp0ZS8NKLvn5OYeENQtPUH/ZgvQECwPNfqLQc7T/AOA7OpslcFGeTaHbJKSF5p6nU2D8ShSyNYU9f9TAtKrSveLsmEB26XiJpAhVlOe5feocrEZLm9ainATBf9xDdSmwPeuZR0GQLq9ifxMijeqlvH9RggVQFAj31GINOc5TrUCIRLs4f+TCA/8AMytAvtzFgqXohhaeFj2ZjNAMO0XZMU666XyRTd5KvLvKZ6Ycn/tc0BdQsL8OIAryTgOXxDvCLv8AwujiCUXRafuHKAatk7+9cxOlCwd97tMN7VGgcPd0PeNrmtFZdX/sQOSLwWW7dJamBrTlwrwcxAIlF9W8naWNigvA/RLIFUdFAfliOqoqucDMDF2U9B9Er20KnLp+EJvaTo6rcdAEy7sHB7mZoeGryVBsbFuuFPiYqYs1+YjIWO+44YYoVRJitB+GY8GhrC9+9xLggV4xw94UECzeHyTGokJrHVH+6xwMh0D06HeYFCNmh2rk7QaXKXlg+XMGihalCzsIi1Ij/PmW4LMquzuYiBeti2wdE/CWMItOXSmVKOHcWcPMGDS2H6OHiKa2Mo2L0f1FVB6hvz3liXKg34j7LueeyQCFgRs7MRaydGL7w11UMjcNoFmcbmHC3a58OeJhAW6Sqk4GWuRsYpX/AL2wlZbFrQ5imV6pl94cdXWjg6vVmG7RQGh/tsP20Zo1/TzEei3VL1892FwGrXK9XYPmEorhbd9B4lwcwrtx4lGOA92ncuLisBY5f6aIa4HeAVPfLEMtvHPkXu6l8wgMsCTK9ovTBRo1hrdOgxyFgbcro8sQOwGLu/gMvqCGg9qxKsdrgf66wliqB6WwUwWJUjhyvpxE6lCg6JDZS1y+C/JDshXqbrS/3F2ZkIeR+5Z4DbRBcpyvEISyzJBvfv5MxAoWjnwf0zwiqyvIe53iy6F4aB2g2bGkRcaslEJcaB7dD5jFgR0og9GGITxsvr5hTUoFkUTzsi/LbTp99R+Es7U7M4Qjikb7SslYWLLz1grrUtnUNFpzsYQhRrT26RxVK2s3yDCs67/NjhJc1Ll8o6neU7WO5R/+EZUy6NDs5l+Utzyf6m9Zev5mF0aGT6+WM0WCd6wjscQxAHLuzACbWf4ZlOF4Hp0IQSGItIo+Lz4jfrKt0Uv9RorLac1/dcd4h42Y6Dj3gNSCgW4GMHSM2tLpy3x2lixlo6LlfMQaBA85H6geo2P2z85gKKuw8A/uOnqrHlDSUoLwZr4agKoEDmExftr4gBjQi1Z0H/ZlwbUKtK7+YXOHB8Kck39HLHwyHRjJHujbuQWHQAlK/T4bJTyaYNu4mGoCr4CwPtn4ROtsbAuNYgG0DSc28NxddZV4qxrmyOTTVSiujWmZpOEKvs1Muc1BbEBfpkuQ9K2S9NQuO89meRGRfZ1LQttleRivGmUN+QjsDJZnK7wBYRpR0cjGGtVjD5sgptUU9CWxF8hS464//HcTrHxv8PMEXditXkOZrqJ4eozWABNLo9oPrbK4PHMULeo8sLh1Y7tCsR2GDBXHf24hmC92Tu/1MFWRb2uAC4oZv4O8DNA8t11XxAudS06aEVQbtfdywx4oqju0fqAqLa/ei/qMlOUe1lMNtbDPCLPxLh9URur8xFJCkHJnI/uGyg6LydR4+oquJUZKrZXPj6iqUo5QHC6Rieh3SpXWjCgRZ0/I7IjvDsr5nR7woHF1qj5rcuEC0NrychjsmACqPcdkCVK9FW8azZLY3YWD0dUWyEZGmFseioK+NQxwqogPnMylEMuCPjvLdFTFh7xm4ep4ZUWRhXD2YgB9A+HrEugYqck4ZXVN+RMpDNtG+nxFmCcOyu3b/wDEahNjzPqPR/tH7n+J1T6n6T/H2n+rsz/Lz6Nv6d1/wxPop99H+DxP9zqn0n6m/wDtl6Ra/H9zX/u2f7Hef6PWfS/CH5T8LNP85n3P1NvbPrT778T8Gfk/qbPOfmfSfSn4/Sf6O808PQ/1M//EADMRAAICAQMCBAUDAwQDAAAAAAABAhEhAxIxQVEgMGFxBBAiMoETQJEUQvBSobHBI1DR/9oACAECAQE/AP39/wDoL/d38q+ef268NeC/2tftLX7BfJD8FeRJ0rs/qK/tZp6sZrD82/2OtcpbehsRJT05KcenKNPUjOCkuv7Wn5EvvZVolGjQk9LUp/bJ/wAPzK8m15EvuZaodMnBOLR8Lq2tr5X/AB+zryZ889RDrqWiX0yUl0IyTSa6/s78b4E7sjwSVDk/Q5Ph9TbJwf4L+V+dfk6jqDNNlUxp1hji74Hd8NE4W7ITbXqfqPqKeTebmRlnJfjbSJ/FwTpZ9h/FP/QzT1Yy9+3k63213ZDbF1eSSTQmInNUbpNUJNMr+RXyPFYGqRfLIzFNPwNpK2S+Lt1BX69CSnL7pfgjCC4GQxqR9XXk6/QcW2aU7jTGsknRzRRGhMbZlrkch8IdDw2Q1muRaqZqfExX25Y1qan3PHYUElgoUUSZBXOK/Pk/EcoSyQSSslIi0+pfAsst9DhC9R1WCVVQovI3ZNdhuuFk2Slz/AoRjhKyTj1E0JWPalkdNmhHr/Hk66uhqnk3OjLKFF0ehVNE8yHhUXkUlkhKpEpJt0PLHHFkZI22OKXRm1WVSJWyEbdCVLyGzUmPOSxcF4ISqKIvJN/V6ElUiLvqNux0sltOxMUmcnUiyVMuhyvga6s+HVty8l8GrdEYN4JwpIXq0UrOERlSfuNcEpN5GxdWKLkyTVUjbkUaXysTG85GmxbUjVabpGjGoLyWS5sclGN1ljblyaW2MG2Re7sT0nVr+DbkyjqakvqRF3Q5VwRVyHyKXfCE08lCGierSpZFq6ilbY4uU1XUSpJeS1aNuTUvJDKPi9Rw0YV3yfDyi+OKJSSRKnkxVFo23ISpEmQdKxZtskQVCZjgTXBtVsemvyaMP7vKYzLwbXH2NXSU9NweLyn6kPiNb4Z1OPHXof1etqyVIpx00nz1G7bGJ5QsklZGEuzNjS4GkPBY2bi1Rpae52+BKvKZqNohfJNeha4F6Mc2qSNWS2ckJ5JZG0kabVG6OnBSfLNOSkrJyjFW2aetCbruSlTa5XRiaGx2WaP2+W1gw1TKVYN0uxNZLfc3JK7smm1dimLVwOTb9zR0dkMs+K/8ul9L+qP+58F8ZGOJP0PifjIyX08HwWnJJzkq7Elgi08DjtRJ5OTRi1Hy5SwRnT5JbrtFslgeeLZKb3I1FatIlGh8Glp3G+w5/SQVUT0dKb+qFvusENDRjxp/yW3ljtsSSXqSf0ElKyCyhSRflaibRt/zJFRceSmupL2sVYxXqiek3kTUtJvbmsobg2+gvh7jaNWe1bUJvgV+xGb6GReyHRWcEvtR1IltC1JNikWvIksDgiMkiS6m1X8oohiXuf00NydE8fakiWm27eWLSpcOyLzkSS6DlXUUm+o/UTQ1CSqy0uBCbN2Bsz1ZGS8bWCSV5ybn0FLo8jQhISJPAySZddaYhcicV0sjqJS4NdvchLcxxS6iNMl8tySHK1VlPoKUvTxM1Fm/kkkbu4hNm5m5McRxQ1gjFPjB0HuvAlI3JpJotI3Nv5QbQ8rA4OxwE0Nqj6fXxM1K+VlZExMtDRlDY4ouP8jrubknk/VuOP5Gu+fmsECMm8F4yNWXRZjxPgk7YyxDE3ZYmMsclTHYkyk0rGmiNteptfb8GehVEIjdMzyhjsRfv4tWVIfA2JsimhyTFSRJpkG7olJZG84OIstMbSsg7VEWnyj6awSd+4mVnBC6M3VG6nQ7HzwWyv8AK8LNVMXBKhM3X1Eo1Y22/km+UKSbdiXORu0Ys2UJ0uCUnZuf4HbsbtepFKkR9hZGsilS4G7Gi34WydMddBplegoEuKFGiTwbnX5Es+4kl1E+fUarkU8Dk2RTYtNEmqoT6iWbIvA5V0Meo2WY558THJZTHdiFtGkNIbiuScrwdSSo3SGxLdjr0NjTFCyMUryTnykU27IxojHA4sawXg3J8sVdy74KXhbwN/UNWho30R1ESnklLBeToJZo24P0mxab69BuLeeSeoo8EpSkKNZF0EiK4HLohr6RjKXqNmfDLgmskJ1gcUyUKFwPkjC2j9LNIWlXLFCHI3A/WSwPXY7YoiE7Rhl+pBoaSY3gdPoNL1Eh+6Nz7rwtE45Hd4P1JI/VaXA52RkxarXB+s+hum2O8CXUcMlJHBuQrFgb+UWJjjaIp3lcE0rLHFG1dvFrLqSZ+o+yMvoPT9B80XfHHYwUbkKfRG90W2JMUSijHqdRpiwRYiaXYeB+5f8Al+JxsnFdrJRinkWpXCIzcnk1L3MSYtzoWeo+glhCWRIXJRaQmV6FenyVFiXqS9R+hkz3/wBvFRKA9vYk43yZrA03yaeiqz1P0o1lD0YcZI6UEaullOI7XKLi/QVU6Y2JNiVF0Y7ITLyRqzpgksDT4QstcFPs/HJYJR9BxZTQqb4G1Gr5JTb6imuHZKaUcCm+SW2Tf/A9KXYUVgSSFRaEvRja7DuuBog/ZkaZJYJYE1XBfkTXynd8mjRKt+TY1NP1OG75NJKs8DUUhuFC1Xw1gjp28M2dGNdhR/Al2TY1XQtCmu5i8ERmoL2N3+X5El6E00N31Nyihq2mb6onl8mVEi+75HtfApUqFJ8rjsRkpGxCil1KJsSMPoJRZHA6NROxKi15DNRYFFrLGm2RXJKOCUepcmkQg2xwijTjHqOMBwihzrhm6TE33Epd/wDscfUdpFvqQZJ0h8/K/XyWiURxfU2iSfJJFYOtji17m5qx60uwpSb5EmRpdBV/qI2ngUsFMc12ISfclJD54Kx1Nvt5TRJDRdOxv5yVckkhUKiKixQroOCJRXsbX6/gdV/iI7RxiOqMIdvqb/Xy5D4HyvkuWL7l7EzqIRHh+xHp7IZPl+xDlkuPwL/o/wDgupLgX2/j5f/EAC8RAAICAQMEAQMDAwUBAAAAAAABAhEhEBIxAyAwQVFhcYEEIqETMsFAQmKR8NH/2gAIAQMBAT8A7r7no+y+1ae9fXb70z4ktK1vw12V568lY1rTPYu6zPh48dmNL78+G9feliL1z2V4a7az3Z7L8FeBK2Lpr5Jwce3Hctb8K7+msWXRHbOLTJwcZNPT34WX3vSvB0/7RtkXk6sd8P8Akl/HetL8l96If2jbsWBPJ14U7+dL7loh9j0rA/F01+0atCEcpokmm1qtH/pUJUkSdMT/AAKzg6sLW5eBrSitK7K0x3xVtaXaHyJiyhPFEor4NiHHBtNo4ld9WyP6eVW8C6Efkn06H4OiluzwhtvjgTpko2tIrJSvBdjYzGlDjY0+xK2R/TvmToW2Kwhtvkomv2vw9I6e2jrQ2ywbx5EixvWyhFCHA/psh0JPnCFtjwvybvktG76kVg6rqyy+/pC4wdTqN4EuxHvTNiLWkfqUWkW5ciRY5CUmyNpZOrK34em+SL+BrJxo9OUxcCKKGsCWilpuoTb9jl9DlkY0jqypDfhhHSnpWSSHwRF/aPAo4LeCKsaoa1uyqFB2KCXJZ15cLSvBAlIg7HRbG7GuBPIkhJWP7nCFdjyXpgXwbfr+BNJUNuxNpW0TdyfijxQlbE0lg6jbaSG6FPInitEQX7WSVWV8l1pt+Bpp6MjPJ0+i5NN4R1f08FHAppdKVj58V4IVZJUyEU5y+yokmnkrNiEUbsDyxIoSE6JSvVRdim6RPrSa5JydV40KkNpkJ00/aJdGE1hi/TKOZMVNv4I4QhrA2JkpfVG7JbOStKyNuzqSryRRKiP3Gi5JEUm8ogv3fQlHSmySbY022l6G8ltP6Di0rNnH8jWNWdTxoyjJSItUY+BRbdVSIv0SibMigiU054RCG2WeH/B1Og7wLou6ZNpJRT45E7Za9mGxLB6JvxxWSrRGvZQhWQiqOm6dMtMUconKpUbckpOze/mhy9tjfxwJKhi5FSQ2S8ceTcO0+BtfArP5I9TaK/6iV4b5P6U65RLqOMlYop3Jlof0JRMDa0x7FyWMo2IcSvBF5E2NNif1E8FkmXgf6ubg0uRTf+5ti6mK4N5JDbfsoaoyVZ+5etHqjBJd6IspeyvwWNaOhGSNexZHaLwO/kcbRCqLoTekhaVkos2x+H3weNGUNGBJG340TYnkb+peRbUsmDa+bKGhDyItUWZKK7+npWjQ1pZZQpMdiv4FG1hm1KX+C/jH00SwMY0uzHgisFFa1goaEhI2u0KhyXwW0LI1X2Hgv50k0LRCGfnugrYitGxJjtsVolVCQkVbRQlwSVZGmuDNkVX2GlyhtUN3pQhFGe7ps9kRood3QljTHA1VDYkbWJ2NZIpVTKFWDj7DvTgRVnAiu6OBFo3I3C5HISElYxlcaNaN0X7Es2SyX6Y1krRI296EsJioY7MlsSbIRrImJsxpfschsv6EVRuwOTY3ktCZQkx3ZWO5EVgsizamOBGOCMclKj2WWKRaFGSWOCMW0WkW2fgb0oTyIyZ+UVjuXJFjVlibY0xIto3YN10XISZs9igjcOTY0XT0rJJaJZFZZ7F9jPdF4E0JRKVmKMDihxSG1RZeaLEmxKyiQ8lCHonkbQngotlvugxKzYiq4ExFNf8A0piQ4m1FI4Y2OReqLwPOli0vB/7juTIsUx59m1JEKMDpWPC40d3Y2Ma0rS9PXZEsdH471ISEvoWL7EpuzexdSQ5yITdZMMpjRwN9nOjPZFieB8H5XemRYmizhCtiSQ4kU7yUiNo3obZZQ1oke9JDEyI0il4IssjxwT4IrBuVUc0Sv0KxJm1XdknSL9ljZYslFaMREaP/AHHgRERVsWBRI4Ryx/RCsqxr5GmjcXohiHY86R4JZKXhizdeBNUN4E8iZhDlgTbJNlyRbZtKSGYLEUNCR6Gf9eJMsTGJll4ExJG1DpG4Y1pWiX1GiKPXlTLPRWlidibGNDs3CbEyxDst6X5Yi5FwM9aI9D9jGS/zouPyS9C5Fx2PT//Z\"\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/assets/{{assetId}}", + "host": ["{{baseUrl}}"], + "path": ["assets", "{{assetId}}"] + } + }, + "response": [] + }, + { + "name": "asset/{id}", + "request": { + "method": "DELETE", + "header": [], + "url": { + "raw": "{{baseUrl}}/assets/{{assetId}}", + "host": ["{{baseUrl}}"], + "path": ["assets", "{{assetId}}"] + } + }, + "response": [] + } + ] + }, + { + "name": "credentials/schemas", + "item": [ + { + "name": "credentials/schemas", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/credentials/schemas", + "host": ["{{baseUrl}}"], + "path": ["credentials", "schemas"] + } + }, + "response": [] + }, + { + "name": "credentials/schemas", + "request": { + "method": "POST", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"example_name\",\r\n \"version\": \"example_version\",\r\n \"identifierType\": \"DID\",\r\n \"identifier\": \"did:sov:XUeUZauFLeBNofY3NhaZCB\",\r\n \"attributes\": [\r\n {\r\n \"name\": \"example_attribute_name1\",\r\n \"value\": \"example_attribute_value1\",\r\n \"type\": \"STRING\"\r\n }\r\n ]\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/credentials/schemas", + "host": ["{{baseUrl}}"], + "path": ["credentials", "schemas"] + } + }, + "response": [] + }, + { + "name": "credentials/schemas/{id}", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/credentials/schemas/{{credentialSchemaId}}", + "host": ["{{baseUrl}}"], + "path": ["credentials", "schemas", "{{credentialSchemaId}}"] + } + }, + "response": [] + }, + { + "name": "credentials/schemas/{id}", + "request": { + "method": "PUT", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"new_name\",\r\n \"version\": \"example_version\",\r\n \"identifierType\": \"DID\",\r\n \"identifier\": \"did:sov:XUeUZauFLeBNofY3NhaZCB\",\r\n \"attributes\": [\r\n {\r\n \"name\": \"example_attribute_name1\",\r\n \"value\": \"example_attribute_value1\",\r\n \"type\": \"STRING\"\r\n }\r\n ]\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/credentials/schemas/{{credentialSchemaId}}", + "host": ["{{baseUrl}}"], + "path": ["credentials", "schemas", "{{credentialSchemaId}}"] + } + }, + "response": [] + }, + { + "name": "credentials/schemas/{id}", + "request": { + "method": "DELETE", + "header": [], + "url": { + "raw": "{{baseUrl}}/credentials/schemas/{{credentialSchemaId}}", + "host": ["{{baseUrl}}"], + "path": ["credentials", "schemas", "{{credentialSchemaId}}"] + } + }, + "response": [] + } + ] + }, + { + "name": "credentials/definitions", + "item": [ + { + "name": "credentials/definitions", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/credentials/definitions", + "host": ["{{baseUrl}}"], + "path": ["credentials", "definitions"] + } + }, + "response": [] + }, + { + "name": "credentials/definitions", + "request": { + "method": "POST", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"example_name\",\r\n \"version\": \"example_version\",\r\n \"icon\": \"{{assetId}}\",\r\n \"identifierType\": \"DID\",\r\n \"identifier\": \"did:sov:XUeUZauFLeBNofY3NhaZCB\",\r\n \"type\": \"ANONCRED\",\r\n \"credentialSchema\": \"{{credentialSchemaId}}\",\r\n \"revocation\": {\r\n \"title\": \"example_revocation_title\",\r\n \"description\": \"example_revocation_description\"\r\n }\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/credentials/definitions", + "host": ["{{baseUrl}}"], + "path": ["credentials", "definitions"] + } + }, + "response": [] + }, + { + "name": "credentials/definitions/{id}", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/credentials/definitions/{{credentialDefinitionId}}", + "host": ["{{baseUrl}}"], + "path": ["credentials", "definitions", "{{credentialDefinitionId}}"] + } + }, + "response": [] + }, + { + "name": "credentials/definitions/{id}", + "request": { + "method": "PUT", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"NEW_NAME\",\r\n \"version\": \"example_version\",\r\n \"icon\": \"{{assetId}}\",\r\n \"identifierType\": \"DID\",\r\n \"identifier\": \"did:sov:XUeUZauFLeBNofY3NhaZCB\",\r\n \"type\": \"ANONCRED\",\r\n \"credentialSchema\": \"{{credentialSchemaId}}\",\r\n \"revocation\": {\r\n \"title\": \"example_revocation_title\",\r\n \"description\": \"example_revocation_description\"\r\n }\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/credentials/definitions/{{credentialDefinitionId}}", + "host": ["{{baseUrl}}"], + "path": ["credentials", "definitions", "{{credentialDefinitionId}}"] + } + }, + "response": [] + }, + { + "name": "credentials/definitions/{id}", + "request": { + "method": "DELETE", + "header": [], + "url": { + "raw": "{{baseUrl}}/credentials/definitions/{{credentialDefinitionId}}", + "host": ["{{baseUrl}}"], + "path": ["credentials", "definitions", "{{credentialDefinitionId}}"] + } + }, + "response": [] + } + ] + }, + { + "name": "relying-parties", + "item": [ + { + "name": "relying-parties", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/roles/relying-parties", + "host": ["{{baseUrl}}"], + "path": ["roles", "relying-parties"] + } + }, + "response": [] + }, + { + "name": "relying-parties", + "request": { + "method": "POST", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"example_name\",\r\n \"type\": \"ARIES\",\r\n \"credentialDefinitions\": [\"{{credentialDefinitionId}}\"],\r\n \"description\": \"example_description\",\r\n \"organization\": \"example_organization\",\r\n \"logo\": \"{{assetId}}\"\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "http://localhost:3000/roles/relying-parties", + "protocol": "http", + "host": ["localhost"], + "port": "3000", + "path": ["roles", "relying-parties"] + } + }, + "response": [] + }, + { + "name": "relying-parties/{id}", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/roles/relying-parties/{{relyingPartyId}}", + "host": ["{{baseUrl}}"], + "path": ["roles", "relying-parties", "{{relyingPartyId}}"] + } + }, + "response": [] + }, + { + "name": "relying-parties/{id}", + "request": { + "method": "PUT", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"NEW NAME\",\r\n \"type\": \"ARIES\",\r\n \"credentialDefinitions\": [\"{{credentialDefinitionId}}\"],\r\n \"description\": \"example_description\",\r\n \"organization\": \"example_organization\",\r\n \"logo\": \"{{assetId}}\"\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/roles/relying-parties/{{relyingPartyId}}", + "host": ["{{baseUrl}}"], + "path": ["roles", "relying-parties", "{{relyingPartyId}}"] + } + }, + "response": [] + }, + { + "name": "relying-parties/{id}", + "request": { + "method": "DELETE", + "header": [], + "url": { + "raw": "{{relyingPartyId}}/roles/relying-parties/{{relyingPartyId}}", + "host": ["{{relyingPartyId}}"], + "path": ["roles", "relying-parties", "{{relyingPartyId}}"] + } + }, + "response": [] + } + ] + }, + { + "name": "issuers", + "item": [ + { + "name": "issuers", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/roles/issuers", + "host": ["{{baseUrl}}"], + "path": ["roles", "issuers"] + } + }, + "response": [] + }, + { + "name": "issuers", + "request": { + "method": "POST", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"example_name\",\r\n \"type\": \"ARIES\",\r\n \"credentialDefinitions\": [\"{{credentialDefinitionId}}\"],\r\n \"credentialSchemas\": [\"{{credentialSchemaId}}\"],\r\n \"description\": \"example_description\",\r\n \"organization\": \"example_organization\",\r\n \"logo\": \"{{assetId}}\"\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/roles/issuers", + "host": ["{{baseUrl}}"], + "path": ["roles", "issuers"] + } + }, + "response": [] + }, + { + "name": "issuers/{id}", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/roles/issuers/{{issuerId}}", + "host": ["{{baseUrl}}"], + "path": ["roles", "issuers", "{{issuerId}}"] + } + }, + "response": [] + }, + { + "name": "issuers/{id}", + "request": { + "method": "PUT", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"new_name\",\r\n \"type\": \"ARIES\",\r\n \"credentialDefinitions\": [\"{{credentialDefinitionId}}\"],\r\n \"credentialSchemas\": [\"{{credentialSchemaId}}\"],\r\n \"description\": \"example_description\",\r\n \"organization\": \"example_organization\",\r\n \"logo\": \"{{assetId}}\"\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/roles/issuers/{{issuerId}}", + "host": ["{{baseUrl}}"], + "path": ["roles", "issuers", "{{issuerId}}"] + } + }, + "response": [] + }, + { + "name": "issuers/{id}", + "request": { + "method": "DELETE", + "header": [], + "url": { + "raw": "http://localhost:3000/roles/issuers/{{issuerId}}", + "protocol": "http", + "host": ["localhost"], + "port": "3000", + "path": ["roles", "issuers", "{{issuerId}}"] + } + }, + "response": [] + } + ] + }, + { + "name": "personas", + "item": [ + { + "name": "personas", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/personas", + "host": ["{{baseUrl}}"], + "path": ["personas"] + } + }, + "response": [] + }, + { + "name": "personas", + "request": { + "method": "POST", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"John Doe\",\r\n \"role\": \"Software Engineer\",\r\n \"description\": \"Experienced developer\",\r\n \"headshotImage\": \"{{assetId}}\",\r\n \"bodyImage\": \"{{assetId}}\"\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/personas", + "host": ["{{baseUrl}}"], + "path": ["personas"] + } + }, + "response": [] + }, + { + "name": "personas/{slug}", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/personas/{{personaSlug}}", + "host": ["{{baseUrl}}"], + "path": ["personas", "{{personaSlug}}"] + } + }, + "response": [] + }, + { + "name": "personas/{slug}", + "request": { + "method": "PUT", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"NEW_NAME2\",\r\n \"role\": \"Software Engineer\",\r\n \"description\": \"Experienced developer\",\r\n \"bodyImage\": \"{{assetId}}\"\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/personas/{{personaSlug}}", + "host": ["{{baseUrl}}"], + "path": ["personas", "{{personaSlug}}"] + } + }, + "response": [] + }, + { + "name": "personas/{slug}", + "request": { + "method": "DELETE", + "header": [], + "url": { + "raw": "{{baseUrl}}/personas/{{personaSlug}}", + "host": ["{{baseUrl}}"], + "path": ["personas", "{{personaSlug}}"] + } + }, + "response": [] + } + ] + }, + { + "name": "scenarios/issuance", + "item": [ + { + "name": "scenarios/issuances", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/issuances", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "issuances"] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances", + "request": { + "method": "POST", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"example_name\",\r\n \"description\": \"example_description\",\r\n \"issuer\": \"{{issuerId}}\",\r\n \"steps\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"description\": \"example_description\",\r\n \"order\": 1,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\",\r\n \"proofRequest\": {\r\n \"attributes\": {\r\n \"attribute1\": {\r\n \"attributes\": [\"attribute1\", \"attribute2\"],\r\n \"restrictions\": [\"restriction1\", \"restriction2\"]\r\n }\r\n },\r\n \"predicates\": {\r\n \"predicate1\": {\r\n \"name\": \"example_name\",\r\n \"type\": \"example_type\",\r\n \"value\":\"example_value\",\r\n \"restrictions\": [\"restriction1\",\"restriction2\"]\r\n }\r\n }\r\n }\r\n }\r\n ]\r\n }\r\n ],\r\n \"personas\": [\"{{personaId}}\"]\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/scenarios/issuances", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "issuances"] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances/{slug}", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "issuances", "{{issuanceScenarioSlug}}"] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances/{slug}", + "request": { + "method": "PUT", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"new_name\",\r\n \"description\": \"example_description\",\r\n \"issuer\": \"{{issuerId}}\",\r\n \"steps\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"description\": \"example_description\",\r\n \"order\": 1,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\",\r\n \"proofRequest\": {\r\n \"attributes\": {\r\n \"attribute1\": {\r\n \"attributes\": [\"attribute1\", \"attribute2\"],\r\n \"restrictions\": [\"restriction1\", \"restriction2\"]\r\n }\r\n },\r\n \"predicates\": {\r\n \"predicate1\": {\r\n \"name\": \"example_name\",\r\n \"type\": \"example_type\",\r\n \"value\":\"example_value\",\r\n \"restrictions\": [\"restriction1\",\"restriction2\"]\r\n }\r\n }\r\n }\r\n }\r\n ]\r\n }\r\n ],\r\n \"personas\": [\"{{personaId}}\"]\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "issuances", "{{issuanceScenarioSlug}}"] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances/{slug}", + "request": { + "method": "DELETE", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "issuances", "{{issuanceScenarioSlug}}"] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances/{slug}/steps", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "issuances", "{{issuanceScenarioSlug}}", "steps"] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances/{slug}/steps", + "request": { + "method": "POST", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"title\": \"example_title\",\r\n \"description\": \"example_description\",\r\n \"order\": 3,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title1\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text1\"\r\n },\r\n {\r\n \"title\": \"example_title2\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text2\"\r\n }\r\n ]\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "issuances", "{{issuanceScenarioSlug}}", "steps"] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances/{slug}/steps/{stepId}", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/2bd1657f-8e19-4d37-b1fc-acb1b7252b70", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "issuances", "{{issuanceScenarioSlug}}", "steps", "2bd1657f-8e19-4d37-b1fc-acb1b7252b70"] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances/{slug}/steps/{stepId}", + "request": { + "method": "PUT", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"title\": \"NEW_TITLE\",\r\n \"description\": \"example_description\",\r\n \"order\": 3,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title1\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text1\"\r\n }\r\n ]\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/93cca8a9-3e8b-4e11-b698-a74d6d6811a5", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "issuances", "{{issuanceScenarioSlug}}", "steps", "93cca8a9-3e8b-4e11-b698-a74d6d6811a5"] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances/{slug}/steps/{stepId}", + "request": { + "method": "DELETE", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/93cca8a9-3e8b-4e11-b698-a74d6d6811a5", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "issuances", "{{issuanceScenarioSlug}}", "steps", "93cca8a9-3e8b-4e11-b698-a74d6d6811a5"] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances/{slug}/steps/{stepId}/actions", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/cb6f7161-cadc-459a-9469-dab91c057c1d/actions", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "issuances", "{{issuanceScenarioSlug}}", "steps", "cb6f7161-cadc-459a-9469-dab91c057c1d", "actions"] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances/{slug}/steps/{stepId}/actions", + "request": { + "method": "POST", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"title\": \"example_title\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\"\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/cb6f7161-cadc-459a-9469-dab91c057c1d/actions", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "issuances", "{{issuanceScenarioSlug}}", "steps", "cb6f7161-cadc-459a-9469-dab91c057c1d", "actions"] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances/{slug}/steps/{stepId}/actions/{actionsId}", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/cb6f7161-cadc-459a-9469-dab91c057c1d/actions/296ba62e-83b6-41f8-91aa-b92debec21f9", + "host": ["{{baseUrl}}"], + "path": [ + "scenarios", + "issuances", + "{{issuanceScenarioSlug}}", + "steps", + "cb6f7161-cadc-459a-9469-dab91c057c1d", + "actions", + "296ba62e-83b6-41f8-91aa-b92debec21f9" + ] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances/{slug}/steps/{stepId}/actions/{actionsId}", + "request": { + "method": "PUT", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"title\": \"NEW_TITLE\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\"\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/cb6f7161-cadc-459a-9469-dab91c057c1d/actions/296ba62e-83b6-41f8-91aa-b92debec21f9", + "host": ["{{baseUrl}}"], + "path": [ + "scenarios", + "issuances", + "{{issuanceScenarioSlug}}", + "steps", + "cb6f7161-cadc-459a-9469-dab91c057c1d", + "actions", + "296ba62e-83b6-41f8-91aa-b92debec21f9" + ] + } + }, + "response": [] + }, + { + "name": "scenarios/issuances/{slug}/steps/{stepId}/actions/{actionsId}", + "request": { + "method": "DELETE", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{issuanceScenarioSlug}}/steps/cb6f7161-cadc-459a-9469-dab91c057c1d/actions/296ba62e-83b6-41f8-91aa-b92debec21f9", + "host": ["{{baseUrl}}"], + "path": [ + "scenarios", + "issuances", + "{{issuanceScenarioSlug}}", + "steps", + "cb6f7161-cadc-459a-9469-dab91c057c1d", + "actions", + "296ba62e-83b6-41f8-91aa-b92debec21f9" + ] + } + }, + "response": [] + } + ] + }, + { + "name": "scenarios/presentation", + "item": [ + { + "name": "scenarios/presentations", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/presentations", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "presentations"] + } + }, + "response": [] + }, + { + "name": "scenarios/presentations", + "request": { + "method": "POST", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"example_name\",\r\n \"description\": \"example_description\",\r\n \"relyingParty\": \"{{relyingPartyId}}\",\r\n \"steps\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"description\": \"example_description\",\r\n \"order\": 1,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\",\r\n \"proofRequest\": {\r\n \"attributes\": {\r\n \"attribute1\": {\r\n \"attributes\": [\"attribute1\", \"attribute2\"],\r\n \"restrictions\": [\"restriction1\", \"restriction2\"]\r\n }\r\n },\r\n \"predicates\": {\r\n \"predicate1\": {\r\n \"name\": \"example_name\",\r\n \"type\": \"example_type\",\r\n \"value\":\"example_value\",\r\n \"restrictions\": [\"restriction1\",\"restriction2\"]\r\n }\r\n }\r\n }\r\n }\r\n ]\r\n }\r\n ],\r\n \"personas\": [\"{{personaId}}\"]\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/scenarios/presentations", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "presentations"] + } + }, + "response": [] + }, + { + "name": "scenarios/presentations/{slug}", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "presentations", "{{presentationScenarioSlug}}"] + } + }, + "response": [] + }, + { + "name": "scenarios/presentations/{slug}", + "request": { + "method": "PUT", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"NEW_NAME\",\r\n \"description\": \"example_description\",\r\n \"relyingParty\": \"{{relyingPartyId}}\",\r\n \"steps\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"description\": \"example_description\",\r\n \"order\": 1,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\",\r\n \"proofRequest\": {\r\n \"attributes\": {\r\n \"attribute1\": {\r\n \"attributes\": [\"attribute1\", \"attribute2\"],\r\n \"restrictions\": [\"restriction1\", \"restriction2\"]\r\n }\r\n },\r\n \"predicates\": {\r\n \"predicate1\": {\r\n \"name\": \"example_name\",\r\n \"type\": \"example_type\",\r\n \"value\":\"example_value\",\r\n \"restrictions\": [\"restriction1\",\"restriction2\"]\r\n }\r\n }\r\n }\r\n }\r\n ]\r\n }\r\n ],\r\n \"personas\": [\"{{personaId}}\"]\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "presentations", "{{presentationScenarioSlug}}"] + } + }, + "response": [] + }, + { + "name": "scenarios/presentation/{slug}", + "request": { + "method": "DELETE", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "presentations", "{{presentationScenarioSlug}}"] + } + }, + "response": [] + }, + { + "name": "scenarios/presentations/{slug}/steps", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/issuances/{{presentationScenarioSlug}}/steps", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "issuances", "{{presentationScenarioSlug}}", "steps"] + } + }, + "response": [] + }, + { + "name": "scenarios/presentations/slug}/steps", + "request": { + "method": "POST", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"title\": \"example_title\",\r\n \"description\": \"example_description\",\r\n \"order\": 4,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title1\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text1\"\r\n },\r\n {\r\n \"title\": \"example_title2\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text2\"\r\n }\r\n ]\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "presentations", "{{presentationScenarioSlug}}", "steps"] + } + }, + "response": [] + }, + { + "name": "scenarios/presentations/{slug}/steps/{stepId}", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/d53b31b4-70a8-4d2a-9ecb-7ab5a591429d", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "presentations", "{{presentationScenarioSlug}}", "steps", "d53b31b4-70a8-4d2a-9ecb-7ab5a591429d"] + } + }, + "response": [] + }, + { + "name": "scenarios/presentations/{slug}/steps/{stepId}", + "request": { + "method": "PUT", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"title\": \"NEW_TITLE\",\r\n \"description\": \"example_description\",\r\n \"order\": 3,\r\n \"type\": \"HUMAN_TASK\",\r\n \"asset\": \"{{assetId}}\",\r\n \"actions\": [\r\n {\r\n \"title\": \"example_title1\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text1\"\r\n }\r\n ]\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/d53b31b4-70a8-4d2a-9ecb-7ab5a591429d", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "presentations", "{{presentationScenarioSlug}}", "steps", "d53b31b4-70a8-4d2a-9ecb-7ab5a591429d"] + } + }, + "response": [] + }, + { + "name": "scenarios/presentations/{slug}/steps/{stepId}", + "request": { + "method": "DELETE", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/d53b31b4-70a8-4d2a-9ecb-7ab5a591429d", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "presentations", "{{presentationScenarioSlug}}", "steps", "d53b31b4-70a8-4d2a-9ecb-7ab5a591429d"] + } + }, + "response": [] + }, + { + "name": "scenarios/presentations/{slug}/steps/{stepId}/actions", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/b6873c21-1275-4764-bf63-fe87c98890c7/actions", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "presentations", "{{presentationScenarioSlug}}", "steps", "b6873c21-1275-4764-bf63-fe87c98890c7", "actions"] + } + }, + "response": [] + }, + { + "name": "scenarios/presentations/{slug}/steps/{stepId}/actions", + "request": { + "method": "POST", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"title\": \"example_title\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\"\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/b6873c21-1275-4764-bf63-fe87c98890c7/actions", + "host": ["{{baseUrl}}"], + "path": ["scenarios", "presentations", "{{presentationScenarioSlug}}", "steps", "b6873c21-1275-4764-bf63-fe87c98890c7", "actions"] + } + }, + "response": [] + }, + { + "name": "scenarios/presentations/{slug}/steps/{stepId}/actions/{actionsId}", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/cd1a0200-2b66-45a7-9d7e-c92887bf86a4/actions/fffc15db-b4e3-45ef-84b0-6e256ae50065", + "host": ["{{baseUrl}}"], + "path": [ + "scenarios", + "presentations", + "{{presentationScenarioSlug}}", + "steps", + "cd1a0200-2b66-45a7-9d7e-c92887bf86a4", + "actions", + "fffc15db-b4e3-45ef-84b0-6e256ae50065" + ] + } + }, + "response": [] + }, + { + "name": "scenarios/presentations/{slug}/steps/{stepId}/actions/{actionsId}", + "request": { + "method": "PUT", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"title\": \"NEW_TITLE\",\r\n \"actionType\": \"ARIES_OOB\",\r\n \"text\": \"example_text\"\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/cd1a0200-2b66-45a7-9d7e-c92887bf86a4/actions/fffc15db-b4e3-45ef-84b0-6e256ae50065", + "host": ["{{baseUrl}}"], + "path": [ + "scenarios", + "presentations", + "{{presentationScenarioSlug}}", + "steps", + "cd1a0200-2b66-45a7-9d7e-c92887bf86a4", + "actions", + "fffc15db-b4e3-45ef-84b0-6e256ae50065" + ] + } + }, + "response": [] + }, + { + "name": "scenarios/presentations/{slug}/steps/{stepId}/actions/{actionsId}", + "request": { + "method": "DELETE", + "header": [], + "url": { + "raw": "{{baseUrl}}/scenarios/presentations/{{presentationScenarioSlug}}/steps/cd1a0200-2b66-45a7-9d7e-c92887bf86a4/actions/fffc15db-b4e3-45ef-84b0-6e256ae50065", + "host": ["{{baseUrl}}"], + "path": [ + "scenarios", + "presentations", + "{{presentationScenarioSlug}}", + "steps", + "cd1a0200-2b66-45a7-9d7e-c92887bf86a4", + "actions", + "fffc15db-b4e3-45ef-84b0-6e256ae50065" + ] + } + }, + "response": [] + } + ] + }, + { + "name": "showcases", + "item": [ + { + "name": "showcases", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/showcases", + "host": ["{{baseUrl}}"], + "path": ["showcases"] + } + }, + "response": [] + }, + { + "name": "showcases", + "request": { + "method": "POST", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"example_name\",\r\n \"description\": \"example_description\",\r\n \"status\": \"ACTIVE\",\r\n \"hidden\": false,\r\n \"scenarios\": [\"{{issuanceScenarioId}}\", \"{{presentationScenarioId}}\"],\r\n \"credentialDefinitions\": [\"{{credentialDefinitionId}}\"],\r\n \"personas\": [\"{{personaId}}\"]\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "http://localhost:3000/showcases", + "protocol": "http", + "host": ["localhost"], + "port": "3000", + "path": ["showcases"] + } + }, + "response": [] + }, + { + "name": "showcases/{slug}", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/showcases/{{showcaseSlug}}", + "host": ["{{baseUrl}}"], + "path": ["showcases", "{{showcaseSlug}}"] + } + }, + "response": [] + }, + { + "name": "showcases/{slug}", + "request": { + "method": "PUT", + "header": [], + "body": { + "mode": "raw", + "raw": "{\r\n \"name\": \"new_name\",\r\n \"description\": \"example_description\",\r\n \"status\": \"ACTIVE\",\r\n \"hidden\": false,\r\n \"scenarios\": [\"{{issuanceScenarioId}}\", \"{{presentationScenarioId}}\"],\r\n \"credentialDefinitions\": [\"{{credentialDefinitionId}}\"],\r\n \"personas\": [\"{{personaId}}\"]\r\n}", + "options": { + "raw": { + "language": "json" + } + } + }, + "url": { + "raw": "{{baseUrl}}/showcases/{{showcaseSlug}}", + "host": ["{{baseUrl}}"], + "path": ["showcases", "{{showcaseSlug}}"] + } + }, + "response": [] + }, + { + "name": "showcases/{slug}", + "request": { + "method": "DELETE", + "header": [], + "url": { + "raw": "{{baseUrl}}/showcases/{{showcaseSlug}}", + "host": ["{{baseUrl}}"], + "path": ["showcases", "{{showcaseSlug}}"] + } + }, + "response": [] + } + ] + } + ] } diff --git a/postman/credential-showcase-api.postman_environment.json b/postman/credential-showcase-api.postman_environment.json index 9bed8af..4b127a9 100644 --- a/postman/credential-showcase-api.postman_environment.json +++ b/postman/credential-showcase-api.postman_environment.json @@ -1,87 +1,87 @@ { - "id": "0932d044-a32b-4565-91bd-3e7f6e68b166", - "name": "credential-showcase-api", - "values": [ - { - "key": "baseUrl", - "value": "http://localhost:3000", - "type": "default", - "enabled": true - }, - { - "key": "assetId", - "value": "49d11e62-08b5-4d20-85ed-156c4d44d4b3", - "type": "default", - "enabled": true - }, - { - "key": "credentialSchemaId", - "value": "246a8004-84b4-44e6-8f64-8cd5c80d97f0", - "type": "default", - "enabled": true - }, - { - "key": "credentialDefinitionId", - "value": "239c5311-64ba-4638-b25a-c702ffc86370", - "type": "default", - "enabled": true - }, - { - "key": "relyingPartyId", - "value": "baa645ce-3894-45cb-90b1-f091988a3e63", - "type": "default", - "enabled": true - }, - { - "key": "issuerId", - "value": "8c71bf49-9078-4517-bb3f-d999de493562", - "type": "default", - "enabled": true - }, - { - "key": "personaSlug", - "value": "john-doe", - "type": "default", - "enabled": true - }, - { - "key": "personaId", - "value": "8b7e9a24-dbb4-48b8-a944-b035e9307b39", - "type": "default", - "enabled": true - }, - { - "key": "showcaseSlug", - "value": "bc-showcase", - "type": "default", - "enabled": true - }, - { - "key": "issuanceScenarioId", - "value": "00993b2a-8174-4f8e-acf5-dc67f1c7ecf6", - "type": "default", - "enabled": true - }, - { - "key": "issuanceScenarioSlug", - "value": "issuance-scenario", - "type": "default", - "enabled": true - }, - { - "key": "presentationScenarioId", - "value": "5cd165b3-859d-453f-8178-452924dc588a", - "type": "default", - "enabled": true - }, - { - "key": "presentationScenarioSlug", - "value": "presentation-scenario", - "type": "default", - "enabled": true - } - ], - "_postman_variable_scope": "environment", - "_postman_exported_at": "2025-03-10T16:03:12.610Z", - "_postman_exported_using": "Postman/11.35.4" -} \ No newline at end of file + "id": "0932d044-a32b-4565-91bd-3e7f6e68b166", + "name": "credential-showcase-api", + "values": [ + { + "key": "baseUrl", + "value": "http://localhost:3000", + "type": "default", + "enabled": true + }, + { + "key": "assetId", + "value": "49d11e62-08b5-4d20-85ed-156c4d44d4b3", + "type": "default", + "enabled": true + }, + { + "key": "credentialSchemaId", + "value": "246a8004-84b4-44e6-8f64-8cd5c80d97f0", + "type": "default", + "enabled": true + }, + { + "key": "credentialDefinitionId", + "value": "239c5311-64ba-4638-b25a-c702ffc86370", + "type": "default", + "enabled": true + }, + { + "key": "relyingPartyId", + "value": "baa645ce-3894-45cb-90b1-f091988a3e63", + "type": "default", + "enabled": true + }, + { + "key": "issuerId", + "value": "8c71bf49-9078-4517-bb3f-d999de493562", + "type": "default", + "enabled": true + }, + { + "key": "personaSlug", + "value": "john-doe", + "type": "default", + "enabled": true + }, + { + "key": "personaId", + "value": "8b7e9a24-dbb4-48b8-a944-b035e9307b39", + "type": "default", + "enabled": true + }, + { + "key": "showcaseSlug", + "value": "bc-showcase", + "type": "default", + "enabled": true + }, + { + "key": "issuanceScenarioId", + "value": "00993b2a-8174-4f8e-acf5-dc67f1c7ecf6", + "type": "default", + "enabled": true + }, + { + "key": "issuanceScenarioSlug", + "value": "issuance-scenario", + "type": "default", + "enabled": true + }, + { + "key": "presentationScenarioId", + "value": "5cd165b3-859d-453f-8178-452924dc588a", + "type": "default", + "enabled": true + }, + { + "key": "presentationScenarioSlug", + "value": "presentation-scenario", + "type": "default", + "enabled": true + } + ], + "_postman_variable_scope": "environment", + "_postman_exported_at": "2025-03-10T16:03:12.610Z", + "_postman_exported_using": "Postman/11.35.4" +} diff --git a/turbo.json b/turbo.json index 72da009..196df31 100644 --- a/turbo.json +++ b/turbo.json @@ -34,9 +34,7 @@ }, "generate:models": { "dependsOn": ["^generate:models"], - "outputs": [ - "src/**" - ] + "outputs": ["src/**"] } } } From a97e767ac68c199be86eb409e1d0b592b8f612ca Mon Sep 17 00:00:00 2001 From: sanderPostma Date: Fri, 14 Mar 2025 10:50:21 +0100 Subject: [PATCH 3/8] chore: pre-commit fix --- .husky/pre-commit | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.husky/pre-commit b/.husky/pre-commit index 9a81570..1cc03ec 100755 --- a/.husky/pre-commit +++ b/.husky/pre-commit @@ -6,7 +6,7 @@ echo "Saved unstaged files to stash, ref: $stash_ref" # Run prettier formatting pnpm prettier -# Stage only previously prettier files +# Stage only prettier modified files git add -u # Restore unstaged changes from stash, if any From 1db4c29701f18784eade16767c51b630becaccec Mon Sep 17 00:00:00 2001 From: sanderPostma Date: Fri, 14 Mar 2025 12:21:32 +0100 Subject: [PATCH 4/8] chore: So not ignore invalid expand parameters --- .../ShowcaseController.integration.test.ts | 22 ++++++++++++------- .../src/utils/normalize.ts | 4 ++-- 2 files changed, 16 insertions(+), 10 deletions(-) diff --git a/apps/credential-showcase-api-server/src/controllers/__tests__/ShowcaseController.integration.test.ts b/apps/credential-showcase-api-server/src/controllers/__tests__/ShowcaseController.integration.test.ts index d3a4323..aa00549 100644 --- a/apps/credential-showcase-api-server/src/controllers/__tests__/ShowcaseController.integration.test.ts +++ b/apps/credential-showcase-api-server/src/controllers/__tests__/ShowcaseController.integration.test.ts @@ -509,7 +509,7 @@ describe('ShowcaseController Integration Tests', () => { } }) - it('should handle mixed valid and invalid expand parameters', async () => { + it('should throw an error for invalid expand parameters', async () => { const { asset, scenario, credentialDefinition, persona } = await createTestPrerequisites() const showcaseRequest: ShowcaseRequest = { name: 'Mixed Expand Test', @@ -520,20 +520,26 @@ describe('ShowcaseController Integration Tests', () => { credentialDefinitions: [credentialDefinition.id], personas: [persona.id], bannerImage: asset.id, - completionMessage: 'Mixed expand test completion message', + completionMessage: 'Test completion message', } const createResponse = await request.post('/showcases').send(showcaseRequest).expect(201) const createdShowcase = createResponse.body.showcase - const getResponse = await request + // Should now expect a 400 Bad Request error when using invalid expand parameter + await request .get(`/showcases/${createdShowcase.slug}?expand=${ShowcaseExpand.Scenarios}&expand=invalidExpand&expand=${ShowcaseExpand.Personas}`) + .expect(400) + + // Test with only valid expand parameters + const validResponse = await request + .get(`/showcases/${createdShowcase.slug}?expand=${ShowcaseExpand.Scenarios}&expand=${ShowcaseExpand.Personas}`) .expect(200) - // Verify valid expands are processed and invalid ones are ignored - expect(getResponse.body.showcase.scenarios.length).toEqual(1) - expect(getResponse.body.showcase.personas.length).toEqual(1) - expect(getResponse.body.showcase.credentialDefinitions).toEqual([]) - expect(getResponse.body.showcase.completionMessage).toEqual('Mixed expand test completion message') + // Verify valid expands are processed correctly + expect(validResponse.body.showcase.scenarios.length).toEqual(1) + expect(validResponse.body.showcase.personas.length).toEqual(1) + expect(validResponse.body.showcase.credentialDefinitions).toEqual([]) + expect(validResponse.body.showcase.completionMessage).toEqual('Test completion message') }) }) diff --git a/apps/credential-showcase-api-server/src/utils/normalize.ts b/apps/credential-showcase-api-server/src/utils/normalize.ts index 930db30..4322b89 100644 --- a/apps/credential-showcase-api-server/src/utils/normalize.ts +++ b/apps/credential-showcase-api-server/src/utils/normalize.ts @@ -1,4 +1,5 @@ import { ShowcaseExpand } from 'credential-showcase-openapi' +import { BadRequestError } from 'routing-controllers' /** * Normalizes expand parameters to valid ShowcaseExpand enum values @@ -23,8 +24,7 @@ export const normalizeExpandParams = (expand?: string[]): ShowcaseExpand[] => { if (normalizedKey in expandMap) { return expandMap[normalizedKey as keyof typeof expandMap] } - console.warn(`Invalid expand parameter: ${expandValue}`) - return null + throw new BadRequestError(`Invalid expand parameter: ${expandValue}`) }) .filter(Boolean) as ShowcaseExpand[]) || [] ) From cb2df61a60c50a49bf2febf6980e7d2a390ee3e4 Mon Sep 17 00:00:00 2001 From: sanderPostma Date: Fri, 14 Mar 2025 16:55:34 +0100 Subject: [PATCH 5/8] chore: Save changes --- .../src/controllers/ShowcaseController.ts | 17 +- .../repositories/ShowcaseRepository.ts | 384 +++++++++--------- .../src/services/ShowcaseService.ts | 39 +- .../src/types/index.ts | 1 + .../src/types/schema/index.ts | 6 +- .../src/types/services/index.ts | 27 ++ .../src/utils/mappers.ts | 14 +- .../openapi/openapi.yaml | 21 +- packages/credential-showcase-openapi/pom.xml | 2 +- 9 files changed, 280 insertions(+), 231 deletions(-) create mode 100644 apps/credential-showcase-api-server/src/types/services/index.ts diff --git a/apps/credential-showcase-api-server/src/controllers/ShowcaseController.ts b/apps/credential-showcase-api-server/src/controllers/ShowcaseController.ts index 18d355f..72e60ed 100644 --- a/apps/credential-showcase-api-server/src/controllers/ShowcaseController.ts +++ b/apps/credential-showcase-api-server/src/controllers/ShowcaseController.ts @@ -10,9 +10,9 @@ import { ShowcasesResponse, ShowcasesResponseFromJSONTyped, } from 'credential-showcase-openapi' -import ShowcaseService from '../services/ShowcaseService' import { showcaseDTOFrom } from '../utils/mappers' import { normalizeExpandParams } from '../utils/normalize' +import { ShowcaseService } from '../services/ShowcaseService' @JsonController('/showcases') @Service() @@ -22,7 +22,7 @@ class ShowcaseController { @Get('/') public async getAll(@QueryParam('expand') expand?: ShowcaseExpand[]): Promise { try { - const result = await this.showcaseService.getShowcases(normalizeExpandParams(expand)) + const result = await this.showcaseService.getShowcases({ expand: normalizeExpandParams(expand) }) const showcases = result.map((showcase) => showcaseDTOFrom(showcase)) return ShowcasesResponseFromJSONTyped({ showcases }, false) } catch (e) { @@ -35,9 +35,9 @@ class ShowcaseController { @Get('/:slug') public async getOne(@Param('slug') slug: string, @QueryParam('expand') expand?: ShowcaseExpand[]): Promise { - const id = await this.showcaseService.getIdBySlug(slug) + const id = await this.showcaseService.getIdBySlug({ slug }) try { - const result = await this.showcaseService.getShowcase(id, normalizeExpandParams(expand)) + const result = await this.showcaseService.getShowcase({ id, expand: normalizeExpandParams(expand) }) return ShowcaseResponseFromJSONTyped({ showcase: showcaseDTOFrom(result) }, false) } catch (e) { if (e.httpCode !== 404) { @@ -66,12 +66,13 @@ class ShowcaseController { @Put('/:slug') public async put(@Param('slug') slug: string, @Body() showcaseRequest: ShowcaseRequest): Promise { - const id = await this.showcaseService.getIdBySlug(slug) + const id = await this.showcaseService.getIdBySlug({ slug }) try { if (!instanceOfShowcaseRequest(showcaseRequest)) { return Promise.reject(new BadRequestError()) } - const result = await this.showcaseService.updateShowcase(id, ShowcaseRequestToJSONTyped(showcaseRequest)) + const result = await this.showcaseService.updateShowcase({ id, showcase: ShowcaseRequestToJSONTyped(showcaseRequest) }) + return ShowcaseResponseFromJSONTyped({ showcase: showcaseDTOFrom(result) }, false) } catch (e) { if (e.httpCode !== 404) { @@ -84,9 +85,9 @@ class ShowcaseController { @OnUndefined(204) @Delete('/:slug') public async delete(@Param('slug') slug: string): Promise { - const id = await this.showcaseService.getIdBySlug(slug) + const id = await this.showcaseService.getIdBySlug({ slug }) try { - return this.showcaseService.deleteShowcase(id) + return this.showcaseService.deleteShowcase({ id }) } catch (e) { if (e.httpCode !== 404) { console.error(`Delete showcase id=${id} failed:`, e) diff --git a/apps/credential-showcase-api-server/src/database/repositories/ShowcaseRepository.ts b/apps/credential-showcase-api-server/src/database/repositories/ShowcaseRepository.ts index cfdb792..b0ad47e 100644 --- a/apps/credential-showcase-api-server/src/database/repositories/ShowcaseRepository.ts +++ b/apps/credential-showcase-api-server/src/database/repositories/ShowcaseRepository.ts @@ -21,9 +21,11 @@ import { import { CredentialDefinition, CredentialSchema, + IssuanceScenario, Issuer, NewShowcase, Persona, + PresentationScenario, RelyingParty, RepositoryDefinition, Scenario, @@ -32,6 +34,8 @@ import { Step, } from '../../types' +type ShowcaseRow = typeof showcases.$inferSelect + @Service() class ShowcaseRepository implements RepositoryDefinition { constructor( @@ -470,7 +474,121 @@ class ShowcaseRepository implements RepositoryDefinition async findById(id: string, expand?: ShowcaseExpand[]): Promise { const expandSet = new Set(expand || []) + let queryConfig = this.buildQueryConfigForId(id, expandSet) + + const connection = await this.databaseService.getConnection() + const result = await connection.query.showcases.findFirst(queryConfig) + + if (!result) { + return Promise.reject(new NotFoundError(`No showcase found for id: ${id}`)) + } + + // Create a typed showcase result + const showcase: Showcase = { + ...result, + scenarios: [], + credentialDefinitions: [], + personas: [], + } + + this.populateScenarios(result, expandSet, showcase) + this.populateCredentialDefs(result, expandSet, showcase) + this.populatePersonas(result, expandSet, showcase) + + return showcase + } + + private populatePersonas(result: ShowcaseRow, expandSet: Set, showcase: Showcase) { + if ('personas' in result && Array.isArray(result.personas)) { + if (expandSet.has(ShowcaseExpand.PERSONAS)) { + showcase.personas = result.personas.filter((personaJoin) => personaJoin.persona).map((personaJoin) => personaJoin.persona as Persona) + } else { + showcase.personas = result.personas.map((showcasesToPersona) => showcasesToPersona.persona) + } + } + } + + private populateCredentialDefs(result: ShowcaseRow, expandSet: Set, showcase: Showcase) { + if ('credentialDefinitions' in result && Array.isArray(result.credentialDefinitions)) { + if (expandSet.has(ShowcaseExpand.CREDENTIAL_DEFINITIONS)) { + const credentialDefinitionsArray: CredentialDefinition[] = [] + + for (const cdJoin of result.credentialDefinitions) { + if (!cdJoin.credentialDefinition) continue + + const cdObj = cdJoin.credentialDefinition + credentialDefinitionsArray.push({ + ...cdObj, + credentialSchema: cdObj.cs, + } as CredentialDefinition) + } + + showcase.credentialDefinitions = credentialDefinitionsArray + } else { + showcase.credentialDefinitions = result.credentialDefinitions.map( + (showcaseToCredentialDefinition) => showcaseToCredentialDefinition.credentialDefinition, + ) + } + } + } + + private populateScenarios(result: ShowcaseRow, expandSet: Set, showcase: Showcase) { + if ('scenarios' in result && Array.isArray(result.scenarios)) { + if (expandSet.has(ShowcaseExpand.SCENARIOS)) { + showcase.scenarios = result.scenarios + .filter((scenarioJoin) => scenarioJoin.scenario) + .map((scenarioJoin) => { + const scenarioObj = scenarioJoin.scenario + + // Process steps if they exist + const processedSteps = scenarioObj.steps ? (sortSteps(scenarioObj.steps) as Step[]) : [] + + // Process relying party if it exists + const processedRelyingParty = scenarioObj.relyingParty + ? ({ + ...scenarioObj.relyingParty, + credentialDefinitions: scenarioObj.relyingParty.cds.map((cd: { cd: CredentialDefinition }) => cd.cd), + } as RelyingParty) + : undefined + + // Process issuer if it exists + const processedIssuer = scenarioObj.issuer + ? ({ + ...scenarioObj.issuer, + credentialDefinitions: scenarioObj.issuer.cds.map((cd: { cd: CredentialDefinition }) => cd.cd), + credentialSchemas: scenarioObj.issuer.css.map((cs: { cs: CredentialSchema }) => cs.cs), + } as Issuer) + : undefined + + // Process personas if they exist + const processedPersonas = scenarioObj.personas ? scenarioObj.personas.map((p: { persona: Persona }) => p.persona) : [] + + // Create the final scenario object with proper typing + const finalScenario: Scenario = { + ...scenarioObj, + steps: processedSteps, + personas: processedPersonas, + } + + // Add relying party and issuer conditionally + if (processedRelyingParty && 'relyingParty' in finalScenario) { + finalScenario.relyingParty = processedRelyingParty + } + + if (processedIssuer && 'issuer' in finalScenario) { + finalScenario.issuer = processedIssuer + } + + return finalScenario + }) + } else { + showcase.scenarios = result.scenarios.map((showcasesToScenario) => showcasesToScenario.scenario) + } + } + } + + private buildQueryConfigForId(id: string, expandSet: Set<'SCENARIOS' | 'CREDENTIAL_DEFINITIONS' | 'PERSONAS' | 'ASSET_CONTENT'>) { // Define our query structure based on what should be included let queryConfig: any = { where: eq(showcases.id, id), @@ -487,7 +605,7 @@ class ShowcaseRepository implements RepositoryDefinition with: { credentialDefinition: { with: { - ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { icon: true } : {}), + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) && { icon: true }), cs: { with: { attributes: true, @@ -499,6 +617,13 @@ class ShowcaseRepository implements RepositoryDefinition }, }, } + } else { + // Include only the credentialDefinitions join table without expanding the credentialDefinition entity + queryConfig.with.credentialDefinitions = { + columns: { + credentialDefinition: true, + }, + } } // Add scenarios if needed @@ -523,7 +648,7 @@ class ShowcaseRepository implements RepositoryDefinition with: { cd: { with: { - ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { icon: true } : {}), + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) && { icon: true }), cs: { with: { attributes: true, @@ -553,7 +678,7 @@ class ShowcaseRepository implements RepositoryDefinition with: { cd: { with: { - ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { icon: true } : {}), + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) && { icon: true }), cs: { with: { attributes: true, @@ -586,6 +711,13 @@ class ShowcaseRepository implements RepositoryDefinition }, }, } + } else { + // Include only the scenarios join table without expanding the scenario entity + queryConfig.with.scenarios = { + columns: { + scenario: true, + }, + } } // Add personas if needed @@ -604,119 +736,15 @@ class ShowcaseRepository implements RepositoryDefinition }, }, } - } - - const connection = await this.databaseService.getConnection() - const result = await connection.query.showcases.findFirst(queryConfig) - - if (!result) { - return Promise.reject(new NotFoundError(`No showcase found for id: ${id}`)) - } - - // Create a typed showcase result - const showcase: Showcase = { - ...result, - scenarios: [], - credentialDefinitions: [], - personas: [], - } - - // Process scenarios if they are to be expanded - if (expandSet.has(ShowcaseExpand.SCENARIOS) && 'scenarios' in result && Array.isArray(result.scenarios)) { - // Create a properly typed array for scenarios - const scenariosArray: Scenario[] = [] - - for (const scenarioJoin of result.scenarios) { - if (!scenarioJoin.scenario) continue - - // Create a type-safe copy of the scenario data - const scenarioObj = scenarioJoin.scenario - - // Process steps if they exist - let processedSteps: Step[] = [] - if (scenarioObj.steps) { - processedSteps = sortSteps(scenarioObj.steps) as Step[] - } - - // Process relying party if it exists - let processedRelyingParty: RelyingParty | undefined = undefined - if (scenarioObj.relyingParty) { - processedRelyingParty = { - ...scenarioObj.relyingParty, - credentialDefinitions: scenarioObj.relyingParty.cds.map((cd: { cd: CredentialDefinition }) => cd.cd), - } as RelyingParty - } - - // Process issuer if it exists - let processedIssuer: Issuer | undefined = undefined - if (scenarioObj.issuer) { - processedIssuer = { - ...scenarioObj.issuer, - credentialDefinitions: scenarioObj.issuer.cds.map((cd: { cd: CredentialDefinition }) => cd.cd), - credentialSchemas: scenarioObj.issuer.css.map((cs: { cs: CredentialSchema }) => cs.cs), - } as Issuer - } - - // Process personas if they exist - let processedPersonas: Persona[] = [] - if (scenarioObj.personas) { - processedPersonas = scenarioObj.personas.map((p: { persona: Persona }) => p.persona) - } - - // Create the final scenario object with explicit typing - const finalScenario: Scenario = { - ...scenarioObj, - steps: processedSteps, - personas: processedPersonas, - } - - // Add relying party and issuer conditionally - if (processedRelyingParty && 'relyingParty' in finalScenario) { - finalScenario.relyingParty = processedRelyingParty - } - - if (processedIssuer && 'issuer' in finalScenario) { - finalScenario.issuer = processedIssuer - } - - scenariosArray.push(finalScenario) - } - - showcase.scenarios = scenariosArray - } - - // Process credential definitions if they should be expanded - if (expandSet.has(ShowcaseExpand.CREDENTIAL_DEFINITIONS) && 'credentialDefinitions' in result && Array.isArray(result.credentialDefinitions)) { - const credentialDefinitionsArray: CredentialDefinition[] = [] - - for (const cdJoin of result.credentialDefinitions) { - if (!cdJoin.credentialDefinition) continue - - const cdObj = cdJoin.credentialDefinition - - credentialDefinitionsArray.push({ - ...cdObj, - credentialSchema: cdObj.cs, - } as CredentialDefinition) - } - - showcase.credentialDefinitions = credentialDefinitionsArray - } - - // Process personas if they should be expanded - if (expandSet.has(ShowcaseExpand.PERSONAS) && 'personas' in result && Array.isArray(result.personas)) { - const personasArray: Persona[] = [] - - for (const personaJoin of result.personas) { - if (!personaJoin.persona) continue - - personasArray.push(personaJoin.persona as Persona) + } else { + // Include only the personas join table without expanding the persona entity + queryConfig.with.personas = { + columns: { + persona: true, + }, } - - showcase.personas = personasArray } - - return showcase + return queryConfig } async findAll(expand?: ShowcaseExpand[]): Promise { @@ -752,7 +780,7 @@ class ShowcaseRepository implements RepositoryDefinition with: { credentialDefinition: { with: { - ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { icon: true } : {}), + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) && { icon: true }), cs: { with: { attributes: true, @@ -789,7 +817,7 @@ class ShowcaseRepository implements RepositoryDefinition with: { cd: { with: { - ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { icon: true } : {}), + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) && { icon: true }), cs: { with: { attributes: true, @@ -819,7 +847,7 @@ class ShowcaseRepository implements RepositoryDefinition with: { cd: { with: { - ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) ? { icon: true } : {}), + ...(expandSet.has(ShowcaseExpand.ASSET_CONTENT) && { icon: true }), cs: { with: { attributes: true, @@ -914,97 +942,57 @@ class ShowcaseRepository implements RepositoryDefinition // Process scenarios if they should be expanded if (expandSet.has(ShowcaseExpand.SCENARIOS)) { const scenarioItems = scenariosMap.get(showcaseData.id) || [] - const scenariosArray: Scenario[] = [] - - for (const scenarioJoin of scenarioItems) { - if (!scenarioJoin.scenario) continue - - const scenarioObj = scenarioJoin.scenario - - // Process steps - let processedSteps: Step[] = [] - if (scenarioObj.steps) { - processedSteps = sortSteps(scenarioObj.steps) as Step[] - } - - // Process relying party - let processedRelyingParty: RelyingParty | undefined = undefined - if (scenarioObj.relyingParty) { - processedRelyingParty = { - ...scenarioObj.relyingParty, - credentialDefinitions: scenarioObj.relyingParty.cds.map((cd: { cd: CredentialDefinition }) => cd.cd), - } as RelyingParty - } - - // Process issuer - let processedIssuer: Issuer | undefined = undefined - if (scenarioObj.issuer) { - processedIssuer = { - ...scenarioObj.issuer, - credentialDefinitions: scenarioObj.issuer.cds.map((cd: { cd: CredentialDefinition }) => cd.cd), - credentialSchemas: scenarioObj.issuer.css.map((cs: { cs: CredentialSchema }) => cs.cs), - } as Issuer - } - - // Process personas - let processedPersonas: Persona[] = [] - if (scenarioObj.personas) { - processedPersonas = scenarioObj.personas.map((p: { persona: Persona }) => p.persona) - } - - // Create the final scenario object - const finalScenario: Scenario = { - ...scenarioObj, - steps: processedSteps, - personas: processedPersonas, - } - - // Add relying party and issuer conditionally - if (processedRelyingParty && 'relyingParty' in finalScenario) { - finalScenario.relyingParty = processedRelyingParty - } - - if (processedIssuer && 'issuer' in finalScenario) { - finalScenario.issuer = processedIssuer - } - - scenariosArray.push(finalScenario) - } - - showcase.scenarios = scenariosArray + showcase.scenarios = scenarioItems + .filter((scenarioJoin) => scenarioJoin.scenario) + .map((scenarioJoin) => { + const scenarioObj = scenarioJoin.scenario + + // Create the final scenario object + const finalScenario: Scenario = { + ...scenarioObj, + steps: scenarioObj.steps ? (sortSteps(scenarioObj.steps) as Step[]) : [], + personas: scenarioObj.personas ? scenarioObj.personas.map((p: { persona: Persona }) => p.persona) : [], + } + + // Process relying party if it exists + if ('relyingParty' in scenarioObj && scenarioObj.relyingParty) { + ;(finalScenario as PresentationScenario).relyingParty = { + ...scenarioObj.relyingParty, + credentialDefinitions: scenarioObj.relyingParty.cds.map((cd: { cd: CredentialDefinition }) => cd.cd), + } as RelyingParty + } + + // Process issuer if it exists + if ('issuer' in scenarioObj && scenarioObj.issuer) { + ;(finalScenario as IssuanceScenario).issuer = { + ...scenarioObj.issuer, + credentialDefinitions: scenarioObj.issuer.cds.map((cd: { cd: CredentialDefinition }) => cd.cd), + credentialSchemas: scenarioObj.issuer.css.map((cs: { cs: CredentialSchema }) => cs.cs), + } as Issuer + } + + return finalScenario + }) } // Process credential definitions if they should be expanded if (expandSet.has(ShowcaseExpand.CREDENTIAL_DEFINITIONS)) { const cdItems = credDefMap.get(showcaseData.id) || [] - const credentialDefinitionsArray: CredentialDefinition[] = [] - - for (const cdJoin of cdItems) { - if (!cdJoin.credentialDefinition) continue - - const cdObj = cdJoin.credentialDefinition - - credentialDefinitionsArray.push({ - ...cdObj, - credentialSchema: cdObj.cs, - } as CredentialDefinition) - } - - showcase.credentialDefinitions = credentialDefinitionsArray + showcase.credentialDefinitions = cdItems + .filter((cdJoin) => cdJoin.credentialDefinition) + .map( + (cdJoin) => + ({ + ...cdJoin.credentialDefinition, + credentialSchema: cdJoin.credentialDefinition.cs, + }) as CredentialDefinition, + ) } // Process personas if they should be expanded if (expandSet.has(ShowcaseExpand.PERSONAS)) { const personaItems = personasMap.get(showcaseData.id) || [] - const personasArray: Persona[] = [] - - for (const personaJoin of personaItems) { - if (!personaJoin.persona) continue - - personasArray.push(personaJoin.persona as Persona) - } - - showcase.personas = personasArray + showcase.personas = personaItems.filter((personaJoin) => personaJoin.persona).map((personaJoin) => personaJoin.persona as Persona) } return showcase diff --git a/apps/credential-showcase-api-server/src/services/ShowcaseService.ts b/apps/credential-showcase-api-server/src/services/ShowcaseService.ts index a9ccbcb..d0fd759 100644 --- a/apps/credential-showcase-api-server/src/services/ShowcaseService.ts +++ b/apps/credential-showcase-api-server/src/services/ShowcaseService.ts @@ -1,35 +1,40 @@ +import { + CreateShowcaseParams, + DeleteShowcaseParams, + GetIdBySlugParams, + GetShowcaseParams, + GetShowcasesParams, + Showcase, + UpdateShowcaseParams, +} from '../types' import { Service } from 'typedi' import ShowcaseRepository from '../database/repositories/ShowcaseRepository' -import { Showcase, NewShowcase } from '../types' -import { ShowcaseExpand } from 'credential-showcase-openapi' @Service() -class ShowcaseService { +export class ShowcaseService { constructor(private readonly showcaseRepository: ShowcaseRepository) {} - public getShowcases = async (expand?: ShowcaseExpand[]): Promise => { - return this.showcaseRepository.findAll(expand) + public getShowcases = async (params: GetShowcasesParams = {}): Promise => { + return this.showcaseRepository.findAll(params.expand) } - public getShowcase = async (id: string, expand?: ShowcaseExpand[]): Promise => { - return this.showcaseRepository.findById(id, expand) + public getShowcase = async (params: GetShowcaseParams): Promise => { + return this.showcaseRepository.findById(params.id, params.expand) } - public createShowcase = async (showcase: NewShowcase): Promise => { - return this.showcaseRepository.create(showcase) + public createShowcase = async (params: CreateShowcaseParams): Promise => { + return this.showcaseRepository.create(params.showcase) } - public updateShowcase = async (id: string, showcase: NewShowcase): Promise => { - return this.showcaseRepository.update(id, showcase) + public updateShowcase = async (params: UpdateShowcaseParams): Promise => { + return this.showcaseRepository.update(params.id, params.showcase) } - public deleteShowcase = async (id: string): Promise => { - return this.showcaseRepository.delete(id) + public deleteShowcase = async (params: DeleteShowcaseParams): Promise => { + return this.showcaseRepository.delete(params.id) } - public getIdBySlug = async (slug: string): Promise => { - return this.showcaseRepository.findIdBySlug(slug) + public getIdBySlug = async (params: GetIdBySlugParams): Promise => { + return this.showcaseRepository.findIdBySlug(params.slug) } } - -export default ShowcaseService diff --git a/apps/credential-showcase-api-server/src/types/index.ts b/apps/credential-showcase-api-server/src/types/index.ts index db9b863..e5c65cc 100644 --- a/apps/credential-showcase-api-server/src/types/index.ts +++ b/apps/credential-showcase-api-server/src/types/index.ts @@ -1,4 +1,5 @@ export * from './respository' export * from './schema' export * from './scenario' +export * from './services' export * from './slug' diff --git a/apps/credential-showcase-api-server/src/types/schema/index.ts b/apps/credential-showcase-api-server/src/types/schema/index.ts index b123534..e9bd498 100644 --- a/apps/credential-showcase-api-server/src/types/schema/index.ts +++ b/apps/credential-showcase-api-server/src/types/schema/index.ts @@ -197,9 +197,9 @@ export type AriesProofRequest = typeof ariesProofRequests.$inferSelect export type NewAriesProofRequest = Omit export type Showcase = Omit & { - scenarios: Scenario[] - credentialDefinitions: CredentialDefinition[] - personas: Persona[] + scenarios: (Scenario | string)[] + credentialDefinitions: (CredentialDefinition | string)[] + personas: (Persona | string)[] bannerImage?: string | Asset | null } export type NewShowcase = Omit & { diff --git a/apps/credential-showcase-api-server/src/types/services/index.ts b/apps/credential-showcase-api-server/src/types/services/index.ts new file mode 100644 index 0000000..6df297b --- /dev/null +++ b/apps/credential-showcase-api-server/src/types/services/index.ts @@ -0,0 +1,27 @@ +import { NewShowcase, ShowcaseExpand } from '../schema' + +export type GetShowcasesParams = { + expand?: ShowcaseExpand[] +} + +export type GetShowcaseParams = { + id: string + expand?: ShowcaseExpand[] +} + +export type CreateShowcaseParams = { + showcase: NewShowcase +} + +export type UpdateShowcaseParams = { + id: string + showcase: NewShowcase +} + +export type DeleteShowcaseParams = { + id: string +} + +export type GetIdBySlugParams = { + slug: string +} diff --git a/apps/credential-showcase-api-server/src/utils/mappers.ts b/apps/credential-showcase-api-server/src/utils/mappers.ts index 28b07f7..5879636 100644 --- a/apps/credential-showcase-api-server/src/utils/mappers.ts +++ b/apps/credential-showcase-api-server/src/utils/mappers.ts @@ -9,6 +9,7 @@ import { PresentationScenario as PresentationScenarioDTO, RelyingParty as RelyingPartyDTO, Showcase as ShowcaseDTO, + ShowcasePersonasInner, Step as StepDTO, } from 'credential-showcase-openapi' import { @@ -146,10 +147,21 @@ export const personaDTOFrom = (persona: Persona): PersonaDTO => { } } +export const showcasePersonaDTOFrom = (persona: Persona): ShowcasePersonasInner => { + return { + ...persona, + headshotImageId: typeof persona.headshotImage === 'string' ? persona.headshotImage : undefined, + headshotImage: persona.headshotImage && typeof persona.headshotImage !== 'string' ? assetDTOFrom(persona.headshotImage as Asset) : undefined, + bodyImageId: typeof persona.bodyImage === 'string' ? persona.bodyImage : undefined, + bodyImage: persona.bodyImage && typeof persona.bodyImage !== 'string' ? assetDTOFrom(persona.bodyImage as Asset) : undefined, + hidden: persona.hidden, + } +} + export const showcaseDTOFrom = (showcase: Showcase): ShowcaseDTO => { return { ...showcase, - personas: showcase.personas.map(personaDTOFrom), + personas: [], // showcase.personas.map(showcasePersonaDTOFrom as Persona), // FIXME credentialDefinitions: showcase.credentialDefinitions.map(credentialDefinitionDTOFrom), scenarios: showcase.scenarios.map(scenarioDTOFrom), bannerImageId: typeof showcase.bannerImage === 'string' ? showcase.bannerImage : undefined, diff --git a/packages/credential-showcase-openapi/openapi/openapi.yaml b/packages/credential-showcase-openapi/openapi/openapi.yaml index 0bad312..998ed7f 100644 --- a/packages/credential-showcase-openapi/openapi/openapi.yaml +++ b/packages/credential-showcase-openapi/openapi/openapi.yaml @@ -1675,6 +1675,15 @@ components: openIdConnectUrl: description: OpenID Connect security scheme for OAuth2 flows schemas: + Id: + type: object + required: + - id + properties: + id: + type: string + description: item id + example: 123e4567-e89b-12d3-a456-426614174469 Asset: type: object required: @@ -2943,17 +2952,23 @@ components: type: array description: List of scenarios in this showcase items: - $ref: '#/components/schemas/Scenario' + oneOf: + - $ref: '#/components/schemas/Scenario' + - $ref: '#/components/schemas/Id' credentialDefinitions: type: array description: List of credential definitions used in this showcase items: - $ref: '#/components/schemas/CredentialDefinition' + oneOf: + - $ref: '#/components/schemas/CredentialDefinition' + - $ref: '#/components/schemas/Id' personas: type: object description: List of personas involved in this showcase items: - $ref: '#/components/schemas/Persona' + oneOf: + - $ref: '#/components/schemas/Persona' + - $ref: '#/components/schemas/Id' bannerImageId: type: string description: The asset id diff --git a/packages/credential-showcase-openapi/pom.xml b/packages/credential-showcase-openapi/pom.xml index 264f6f1..16f50bf 100644 --- a/packages/credential-showcase-openapi/pom.xml +++ b/packages/credential-showcase-openapi/pom.xml @@ -99,7 +99,7 @@ false UTF-8 - 7.11.0 + 7.12.0 3.9.0 17 17 From 9b42955fe387bd744f79fa1d2796275abe7c8b35 Mon Sep 17 00:00:00 2001 From: sanderPostma Date: Mon, 17 Mar 2025 15:54:32 +0100 Subject: [PATCH 6/8] chore: post-merge --- package.json | 1 + pnpm-lock.yaml | 2252 ++++++++++++++++++++++++------------------------ 2 files changed, 1135 insertions(+), 1118 deletions(-) diff --git a/package.json b/package.json index 1e000ec..7aae75d 100644 --- a/package.json +++ b/package.json @@ -35,6 +35,7 @@ "@types/supertest": "^6.0.2", "cross-env": "^7.0.3", "husky": "^9.1.7", + "rimraf": "^6.0.1", "jest": "^29.7.0", "jest-environment-node": "^29.7.0", "jest-fetch-mock": "^3.0.3", diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 9e2819f..e44cc64 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -5,6 +5,7 @@ settings: excludeLinksFromLockfile: false importers: + .: devDependencies: '@types/jest': @@ -34,6 +35,9 @@ importers: prettier: specifier: ^3.4.2 version: 3.4.2 + rimraf: + specifier: ^6.0.1 + version: 6.0.1 supertest: specifier: ^7.0.0 version: 7.0.0 @@ -158,506 +162,507 @@ importers: version: 7.0.0 packages: + '@ampproject/remapping@2.3.0': - resolution: { integrity: sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw== } - engines: { node: '>=6.0.0' } + resolution: {integrity: sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==} + engines: {node: '>=6.0.0'} '@babel/code-frame@7.26.2': - resolution: { integrity: sha512-RJlIHRueQgwWitWgF8OdFYGZX328Ax5BCemNGlqHfplnRT9ESi8JkFlvaVYbS+UubVY6dpv87Fs2u5M29iNFVQ== } - engines: { node: '>=6.9.0' } + resolution: {integrity: sha512-RJlIHRueQgwWitWgF8OdFYGZX328Ax5BCemNGlqHfplnRT9ESi8JkFlvaVYbS+UubVY6dpv87Fs2u5M29iNFVQ==} + engines: {node: '>=6.9.0'} '@babel/compat-data@7.26.5': - resolution: { integrity: sha512-XvcZi1KWf88RVbF9wn8MN6tYFloU5qX8KjuF3E1PVBmJ9eypXfs4GRiJwLuTZL0iSnJUKn1BFPa5BPZZJyFzPg== } - engines: { node: '>=6.9.0' } + resolution: {integrity: sha512-XvcZi1KWf88RVbF9wn8MN6tYFloU5qX8KjuF3E1PVBmJ9eypXfs4GRiJwLuTZL0iSnJUKn1BFPa5BPZZJyFzPg==} + engines: {node: '>=6.9.0'} '@babel/core@7.26.7': - resolution: { integrity: sha512-SRijHmF0PSPgLIBYlWnG0hyeJLwXE2CgpsXaMOrtt2yp9/86ALw6oUlj9KYuZ0JN07T4eBMVIW4li/9S1j2BGA== } - engines: { node: '>=6.9.0' } + resolution: {integrity: sha512-SRijHmF0PSPgLIBYlWnG0hyeJLwXE2CgpsXaMOrtt2yp9/86ALw6oUlj9KYuZ0JN07T4eBMVIW4li/9S1j2BGA==} + engines: {node: '>=6.9.0'} '@babel/generator@7.26.5': - resolution: { integrity: sha512-2caSP6fN9I7HOe6nqhtft7V4g7/V/gfDsC3Ag4W7kEzzvRGKqiv0pu0HogPiZ3KaVSoNDhUws6IJjDjpfmYIXw== } - engines: { node: '>=6.9.0' } + resolution: {integrity: sha512-2caSP6fN9I7HOe6nqhtft7V4g7/V/gfDsC3Ag4W7kEzzvRGKqiv0pu0HogPiZ3KaVSoNDhUws6IJjDjpfmYIXw==} + engines: {node: '>=6.9.0'} '@babel/helper-compilation-targets@7.26.5': - resolution: { integrity: sha512-IXuyn5EkouFJscIDuFF5EsiSolseme1s0CZB+QxVugqJLYmKdxI1VfIBOst0SUu4rnk2Z7kqTwmoO1lp3HIfnA== } - engines: { node: '>=6.9.0' } + resolution: {integrity: sha512-IXuyn5EkouFJscIDuFF5EsiSolseme1s0CZB+QxVugqJLYmKdxI1VfIBOst0SUu4rnk2Z7kqTwmoO1lp3HIfnA==} + engines: {node: '>=6.9.0'} '@babel/helper-module-imports@7.25.9': - resolution: { integrity: sha512-tnUA4RsrmflIM6W6RFTLFSXITtl0wKjgpnLgXyowocVPrbYrLUXSBXDgTs8BlbmIzIdlBySRQjINYs2BAkiLtw== } - engines: { node: '>=6.9.0' } + resolution: {integrity: sha512-tnUA4RsrmflIM6W6RFTLFSXITtl0wKjgpnLgXyowocVPrbYrLUXSBXDgTs8BlbmIzIdlBySRQjINYs2BAkiLtw==} + engines: {node: '>=6.9.0'} '@babel/helper-module-transforms@7.26.0': - resolution: { integrity: sha512-xO+xu6B5K2czEnQye6BHA7DolFFmS3LB7stHZFaOLb1pAwO1HWLS8fXA+eh0A2yIvltPVmx3eNNDBJA2SLHXFw== } - engines: { node: '>=6.9.0' } + resolution: {integrity: sha512-xO+xu6B5K2czEnQye6BHA7DolFFmS3LB7stHZFaOLb1pAwO1HWLS8fXA+eh0A2yIvltPVmx3eNNDBJA2SLHXFw==} + engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0 '@babel/helper-plugin-utils@7.26.5': - resolution: { integrity: sha512-RS+jZcRdZdRFzMyr+wcsaqOmld1/EqTghfaBGQQd/WnRdzdlvSZ//kF7U8VQTxf1ynZ4cjUcYgjVGx13ewNPMg== } - engines: { node: '>=6.9.0' } + resolution: {integrity: sha512-RS+jZcRdZdRFzMyr+wcsaqOmld1/EqTghfaBGQQd/WnRdzdlvSZ//kF7U8VQTxf1ynZ4cjUcYgjVGx13ewNPMg==} + engines: {node: '>=6.9.0'} '@babel/helper-string-parser@7.25.9': - resolution: { integrity: sha512-4A/SCr/2KLd5jrtOMFzaKjVtAei3+2r/NChoBNoZ3EyP/+GlhoaEGoWOZUmFmoITP7zOJyHIMm+DYRd8o3PvHA== } - engines: { node: '>=6.9.0' } + resolution: {integrity: sha512-4A/SCr/2KLd5jrtOMFzaKjVtAei3+2r/NChoBNoZ3EyP/+GlhoaEGoWOZUmFmoITP7zOJyHIMm+DYRd8o3PvHA==} + engines: {node: '>=6.9.0'} '@babel/helper-validator-identifier@7.25.9': - resolution: { integrity: sha512-Ed61U6XJc3CVRfkERJWDz4dJwKe7iLmmJsbOGu9wSloNSFttHV0I8g6UAgb7qnK5ly5bGLPd4oXZlxCdANBOWQ== } - engines: { node: '>=6.9.0' } + resolution: {integrity: sha512-Ed61U6XJc3CVRfkERJWDz4dJwKe7iLmmJsbOGu9wSloNSFttHV0I8g6UAgb7qnK5ly5bGLPd4oXZlxCdANBOWQ==} + engines: {node: '>=6.9.0'} '@babel/helper-validator-option@7.25.9': - resolution: { integrity: sha512-e/zv1co8pp55dNdEcCynfj9X7nyUKUXoUEwfXqaZt0omVOmDe9oOTdKStH4GmAw6zxMFs50ZayuMfHDKlO7Tfw== } - engines: { node: '>=6.9.0' } + resolution: {integrity: sha512-e/zv1co8pp55dNdEcCynfj9X7nyUKUXoUEwfXqaZt0omVOmDe9oOTdKStH4GmAw6zxMFs50ZayuMfHDKlO7Tfw==} + engines: {node: '>=6.9.0'} '@babel/helpers@7.26.7': - resolution: { integrity: sha512-8NHiL98vsi0mbPQmYAGWwfcFaOy4j2HY49fXJCfuDcdE7fMIsH9a7GdaeXpIBsbT7307WU8KCMp5pUVDNL4f9A== } - engines: { node: '>=6.9.0' } + resolution: {integrity: sha512-8NHiL98vsi0mbPQmYAGWwfcFaOy4j2HY49fXJCfuDcdE7fMIsH9a7GdaeXpIBsbT7307WU8KCMp5pUVDNL4f9A==} + engines: {node: '>=6.9.0'} '@babel/parser@7.26.7': - resolution: { integrity: sha512-kEvgGGgEjRUutvdVvZhbn/BxVt+5VSpwXz1j3WYXQbXDo8KzFOPNG2GQbdAiNq8g6wn1yKk7C/qrke03a84V+w== } - engines: { node: '>=6.0.0' } + resolution: {integrity: sha512-kEvgGGgEjRUutvdVvZhbn/BxVt+5VSpwXz1j3WYXQbXDo8KzFOPNG2GQbdAiNq8g6wn1yKk7C/qrke03a84V+w==} + engines: {node: '>=6.0.0'} hasBin: true '@babel/plugin-proposal-export-namespace-from@7.18.9': - resolution: { integrity: sha512-k1NtHyOMvlDDFeb9G5PhUXuGj8m/wiwojgQVEhJ/fsVsMCpLyOP4h0uGEjYJKrRI+EVPlb5Jk+Gt9P97lOGwtA== } - engines: { node: '>=6.9.0' } + resolution: {integrity: sha512-k1NtHyOMvlDDFeb9G5PhUXuGj8m/wiwojgQVEhJ/fsVsMCpLyOP4h0uGEjYJKrRI+EVPlb5Jk+Gt9P97lOGwtA==} + engines: {node: '>=6.9.0'} deprecated: This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-export-namespace-from instead. peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-async-generators@7.8.4': - resolution: { integrity: sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw== } + resolution: {integrity: sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==} peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-bigint@7.8.3': - resolution: { integrity: sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg== } + resolution: {integrity: sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg==} peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-class-properties@7.12.13': - resolution: { integrity: sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA== } + resolution: {integrity: sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==} peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-class-static-block@7.14.5': - resolution: { integrity: sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw== } - engines: { node: '>=6.9.0' } + resolution: {integrity: sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw==} + engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-export-namespace-from@7.8.3': - resolution: { integrity: sha512-MXf5laXo6c1IbEbegDmzGPwGNTsHZmEy6QGznu5Sh2UCWvueywb2ee+CCE4zQiZstxU9BMoQO9i6zUFSY0Kj0Q== } + resolution: {integrity: sha512-MXf5laXo6c1IbEbegDmzGPwGNTsHZmEy6QGznu5Sh2UCWvueywb2ee+CCE4zQiZstxU9BMoQO9i6zUFSY0Kj0Q==} peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-import-attributes@7.26.0': - resolution: { integrity: sha512-e2dttdsJ1ZTpi3B9UYGLw41hifAubg19AtCu/2I/F1QNVclOBr1dYpTdmdyZ84Xiz43BS/tCUkMAZNLv12Pi+A== } - engines: { node: '>=6.9.0' } + resolution: {integrity: sha512-e2dttdsJ1ZTpi3B9UYGLw41hifAubg19AtCu/2I/F1QNVclOBr1dYpTdmdyZ84Xiz43BS/tCUkMAZNLv12Pi+A==} + engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-import-meta@7.10.4': - resolution: { integrity: sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g== } + resolution: {integrity: sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==} peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-json-strings@7.8.3': - resolution: { integrity: sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA== } + resolution: {integrity: sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==} peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-jsx@7.25.9': - resolution: { integrity: sha512-ld6oezHQMZsZfp6pWtbjaNDF2tiiCYYDqQszHt5VV437lewP9aSi2Of99CK0D0XB21k7FLgnLcmQKyKzynfeAA== } - engines: { node: '>=6.9.0' } + resolution: {integrity: sha512-ld6oezHQMZsZfp6pWtbjaNDF2tiiCYYDqQszHt5VV437lewP9aSi2Of99CK0D0XB21k7FLgnLcmQKyKzynfeAA==} + engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-logical-assignment-operators@7.10.4': - resolution: { integrity: sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig== } + resolution: {integrity: sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==} peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-nullish-coalescing-operator@7.8.3': - resolution: { integrity: sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ== } + resolution: {integrity: sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==} peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-numeric-separator@7.10.4': - resolution: { integrity: sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug== } + resolution: {integrity: sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==} peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-object-rest-spread@7.8.3': - resolution: { integrity: sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA== } + resolution: {integrity: sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==} peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-optional-catch-binding@7.8.3': - resolution: { integrity: sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q== } + resolution: {integrity: sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==} peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-optional-chaining@7.8.3': - resolution: { integrity: sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg== } + resolution: {integrity: sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==} peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-private-property-in-object@7.14.5': - resolution: { integrity: sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg== } - engines: { node: '>=6.9.0' } + resolution: {integrity: sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg==} + engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-top-level-await@7.14.5': - resolution: { integrity: sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw== } - engines: { node: '>=6.9.0' } + resolution: {integrity: sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==} + engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-syntax-typescript@7.25.9': - resolution: { integrity: sha512-hjMgRy5hb8uJJjUcdWunWVcoi9bGpJp8p5Ol1229PoN6aytsLwNMgmdftO23wnCLMfVmTwZDWMPNq/D1SY60JQ== } - engines: { node: '>=6.9.0' } + resolution: {integrity: sha512-hjMgRy5hb8uJJjUcdWunWVcoi9bGpJp8p5Ol1229PoN6aytsLwNMgmdftO23wnCLMfVmTwZDWMPNq/D1SY60JQ==} + engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 '@babel/plugin-transform-modules-commonjs@7.26.3': - resolution: { integrity: sha512-MgR55l4q9KddUDITEzEFYn5ZsGDXMSsU9E+kh7fjRXTIC3RHqfCo8RPRbyReYJh44HQ/yomFkqbOFohXvDCiIQ== } - engines: { node: '>=6.9.0' } + resolution: {integrity: sha512-MgR55l4q9KddUDITEzEFYn5ZsGDXMSsU9E+kh7fjRXTIC3RHqfCo8RPRbyReYJh44HQ/yomFkqbOFohXvDCiIQ==} + engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 '@babel/template@7.25.9': - resolution: { integrity: sha512-9DGttpmPvIxBb/2uwpVo3dqJ+O6RooAFOS+lB+xDqoE2PVCE8nfoHMdZLpfCQRLwvohzXISPZcgxt80xLfsuwg== } - engines: { node: '>=6.9.0' } + resolution: {integrity: sha512-9DGttpmPvIxBb/2uwpVo3dqJ+O6RooAFOS+lB+xDqoE2PVCE8nfoHMdZLpfCQRLwvohzXISPZcgxt80xLfsuwg==} + engines: {node: '>=6.9.0'} '@babel/traverse@7.26.7': - resolution: { integrity: sha512-1x1sgeyRLC3r5fQOM0/xtQKsYjyxmFjaOrLJNtZ81inNjyJHGIolTULPiSc/2qe1/qfpFLisLQYFnnZl7QoedA== } - engines: { node: '>=6.9.0' } + resolution: {integrity: sha512-1x1sgeyRLC3r5fQOM0/xtQKsYjyxmFjaOrLJNtZ81inNjyJHGIolTULPiSc/2qe1/qfpFLisLQYFnnZl7QoedA==} + engines: {node: '>=6.9.0'} '@babel/types@7.26.7': - resolution: { integrity: sha512-t8kDRGrKXyp6+tjUh7hw2RLyclsW4TRoRvRHtSyAX9Bb5ldlFh+90YAYY6awRXrlB4G5G2izNeGySpATlFzmOg== } - engines: { node: '>=6.9.0' } + resolution: {integrity: sha512-t8kDRGrKXyp6+tjUh7hw2RLyclsW4TRoRvRHtSyAX9Bb5ldlFh+90YAYY6awRXrlB4G5G2izNeGySpATlFzmOg==} + engines: {node: '>=6.9.0'} '@balena/dockerignore@1.0.2': - resolution: { integrity: sha512-wMue2Sy4GAVTk6Ic4tJVcnfdau+gx2EnG7S+uAEe+TWJFqE4YoWN4/H8MSLj4eYJKxGg26lZwboEniNiNwZQ6Q== } + resolution: {integrity: sha512-wMue2Sy4GAVTk6Ic4tJVcnfdau+gx2EnG7S+uAEe+TWJFqE4YoWN4/H8MSLj4eYJKxGg26lZwboEniNiNwZQ6Q==} '@bcoe/v8-coverage@0.2.3': - resolution: { integrity: sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw== } + resolution: {integrity: sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==} '@cspotcode/source-map-support@0.8.1': - resolution: { integrity: sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw== } - engines: { node: '>=12' } + resolution: {integrity: sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==} + engines: {node: '>=12'} '@drizzle-team/brocli@0.10.2': - resolution: { integrity: sha512-z33Il7l5dKjUgGULTqBsQBQwckHh5AbIuxhdsIxDDiZAzBOrZO6q9ogcWC65kU382AfynTfgNumVcNIjuIua6w== } + resolution: {integrity: sha512-z33Il7l5dKjUgGULTqBsQBQwckHh5AbIuxhdsIxDDiZAzBOrZO6q9ogcWC65kU382AfynTfgNumVcNIjuIua6w==} '@electric-sql/pglite@0.2.17': - resolution: { integrity: sha512-qEpKRT2oUaWDH6tjRxLHjdzMqRUGYDnGZlKrnL4dJ77JVMcP2Hpo3NYnOSPKdZdeec57B6QPprCUFg0picx5Pw== } + resolution: {integrity: sha512-qEpKRT2oUaWDH6tjRxLHjdzMqRUGYDnGZlKrnL4dJ77JVMcP2Hpo3NYnOSPKdZdeec57B6QPprCUFg0picx5Pw==} '@esbuild-kit/core-utils@3.3.2': - resolution: { integrity: sha512-sPRAnw9CdSsRmEtnsl2WXWdyquogVpB3yZ3dgwJfe8zrOzTsV7cJvmwrKVa+0ma5BoiGJ+BoqkMvawbayKUsqQ== } + resolution: {integrity: sha512-sPRAnw9CdSsRmEtnsl2WXWdyquogVpB3yZ3dgwJfe8zrOzTsV7cJvmwrKVa+0ma5BoiGJ+BoqkMvawbayKUsqQ==} deprecated: 'Merged into tsx: https://tsx.is' '@esbuild-kit/esm-loader@2.6.5': - resolution: { integrity: sha512-FxEMIkJKnodyA1OaCUoEvbYRkoZlLZ4d/eXFu9Fh8CbBBgP5EmZxrfTRyN0qpXZ4vOvqnE5YdRdcrmUUXuU+dA== } + resolution: {integrity: sha512-FxEMIkJKnodyA1OaCUoEvbYRkoZlLZ4d/eXFu9Fh8CbBBgP5EmZxrfTRyN0qpXZ4vOvqnE5YdRdcrmUUXuU+dA==} deprecated: 'Merged into tsx: https://tsx.is' '@esbuild/aix-ppc64@0.19.12': - resolution: { integrity: sha512-bmoCYyWdEL3wDQIVbcyzRyeKLgk2WtWLTWz1ZIAZF/EGbNOwSA6ew3PftJ1PqMiOOGu0OyFMzG53L0zqIpPeNA== } - engines: { node: '>=12' } + resolution: {integrity: sha512-bmoCYyWdEL3wDQIVbcyzRyeKLgk2WtWLTWz1ZIAZF/EGbNOwSA6ew3PftJ1PqMiOOGu0OyFMzG53L0zqIpPeNA==} + engines: {node: '>=12'} cpu: [ppc64] os: [aix] '@esbuild/android-arm64@0.18.20': - resolution: { integrity: sha512-Nz4rJcchGDtENV0eMKUNa6L12zz2zBDXuhj/Vjh18zGqB44Bi7MBMSXjgunJgjRhCmKOjnPuZp4Mb6OKqtMHLQ== } - engines: { node: '>=12' } + resolution: {integrity: sha512-Nz4rJcchGDtENV0eMKUNa6L12zz2zBDXuhj/Vjh18zGqB44Bi7MBMSXjgunJgjRhCmKOjnPuZp4Mb6OKqtMHLQ==} + engines: {node: '>=12'} cpu: [arm64] os: [android] '@esbuild/android-arm64@0.19.12': - resolution: { integrity: sha512-P0UVNGIienjZv3f5zq0DP3Nt2IE/3plFzuaS96vihvD0Hd6H/q4WXUGpCxD/E8YrSXfNyRPbpTq+T8ZQioSuPA== } - engines: { node: '>=12' } + resolution: {integrity: sha512-P0UVNGIienjZv3f5zq0DP3Nt2IE/3plFzuaS96vihvD0Hd6H/q4WXUGpCxD/E8YrSXfNyRPbpTq+T8ZQioSuPA==} + engines: {node: '>=12'} cpu: [arm64] os: [android] '@esbuild/android-arm@0.18.20': - resolution: { integrity: sha512-fyi7TDI/ijKKNZTUJAQqiG5T7YjJXgnzkURqmGj13C6dCqckZBLdl4h7bkhHt/t0WP+zO9/zwroDvANaOqO5Sw== } - engines: { node: '>=12' } + resolution: {integrity: sha512-fyi7TDI/ijKKNZTUJAQqiG5T7YjJXgnzkURqmGj13C6dCqckZBLdl4h7bkhHt/t0WP+zO9/zwroDvANaOqO5Sw==} + engines: {node: '>=12'} cpu: [arm] os: [android] '@esbuild/android-arm@0.19.12': - resolution: { integrity: sha512-qg/Lj1mu3CdQlDEEiWrlC4eaPZ1KztwGJ9B6J+/6G+/4ewxJg7gqj8eVYWvao1bXrqGiW2rsBZFSX3q2lcW05w== } - engines: { node: '>=12' } + resolution: {integrity: sha512-qg/Lj1mu3CdQlDEEiWrlC4eaPZ1KztwGJ9B6J+/6G+/4ewxJg7gqj8eVYWvao1bXrqGiW2rsBZFSX3q2lcW05w==} + engines: {node: '>=12'} cpu: [arm] os: [android] '@esbuild/android-x64@0.18.20': - resolution: { integrity: sha512-8GDdlePJA8D6zlZYJV/jnrRAi6rOiNaCC/JclcXpB+KIuvfBN4owLtgzY2bsxnx666XjJx2kDPUmnTtR8qKQUg== } - engines: { node: '>=12' } + resolution: {integrity: sha512-8GDdlePJA8D6zlZYJV/jnrRAi6rOiNaCC/JclcXpB+KIuvfBN4owLtgzY2bsxnx666XjJx2kDPUmnTtR8qKQUg==} + engines: {node: '>=12'} cpu: [x64] os: [android] '@esbuild/android-x64@0.19.12': - resolution: { integrity: sha512-3k7ZoUW6Q6YqhdhIaq/WZ7HwBpnFBlW905Fa4s4qWJyiNOgT1dOqDiVAQFwBH7gBRZr17gLrlFCRzF6jFh7Kew== } - engines: { node: '>=12' } + resolution: {integrity: sha512-3k7ZoUW6Q6YqhdhIaq/WZ7HwBpnFBlW905Fa4s4qWJyiNOgT1dOqDiVAQFwBH7gBRZr17gLrlFCRzF6jFh7Kew==} + engines: {node: '>=12'} cpu: [x64] os: [android] '@esbuild/darwin-arm64@0.18.20': - resolution: { integrity: sha512-bxRHW5kHU38zS2lPTPOyuyTm+S+eobPUnTNkdJEfAddYgEcll4xkT8DB9d2008DtTbl7uJag2HuE5NZAZgnNEA== } - engines: { node: '>=12' } + resolution: {integrity: sha512-bxRHW5kHU38zS2lPTPOyuyTm+S+eobPUnTNkdJEfAddYgEcll4xkT8DB9d2008DtTbl7uJag2HuE5NZAZgnNEA==} + engines: {node: '>=12'} cpu: [arm64] os: [darwin] '@esbuild/darwin-arm64@0.19.12': - resolution: { integrity: sha512-B6IeSgZgtEzGC42jsI+YYu9Z3HKRxp8ZT3cqhvliEHovq8HSX2YX8lNocDn79gCKJXOSaEot9MVYky7AKjCs8g== } - engines: { node: '>=12' } + resolution: {integrity: sha512-B6IeSgZgtEzGC42jsI+YYu9Z3HKRxp8ZT3cqhvliEHovq8HSX2YX8lNocDn79gCKJXOSaEot9MVYky7AKjCs8g==} + engines: {node: '>=12'} cpu: [arm64] os: [darwin] '@esbuild/darwin-x64@0.18.20': - resolution: { integrity: sha512-pc5gxlMDxzm513qPGbCbDukOdsGtKhfxD1zJKXjCCcU7ju50O7MeAZ8c4krSJcOIJGFR+qx21yMMVYwiQvyTyQ== } - engines: { node: '>=12' } + resolution: {integrity: sha512-pc5gxlMDxzm513qPGbCbDukOdsGtKhfxD1zJKXjCCcU7ju50O7MeAZ8c4krSJcOIJGFR+qx21yMMVYwiQvyTyQ==} + engines: {node: '>=12'} cpu: [x64] os: [darwin] '@esbuild/darwin-x64@0.19.12': - resolution: { integrity: sha512-hKoVkKzFiToTgn+41qGhsUJXFlIjxI/jSYeZf3ugemDYZldIXIxhvwN6erJGlX4t5h417iFuheZ7l+YVn05N3A== } - engines: { node: '>=12' } + resolution: {integrity: sha512-hKoVkKzFiToTgn+41qGhsUJXFlIjxI/jSYeZf3ugemDYZldIXIxhvwN6erJGlX4t5h417iFuheZ7l+YVn05N3A==} + engines: {node: '>=12'} cpu: [x64] os: [darwin] '@esbuild/freebsd-arm64@0.18.20': - resolution: { integrity: sha512-yqDQHy4QHevpMAaxhhIwYPMv1NECwOvIpGCZkECn8w2WFHXjEwrBn3CeNIYsibZ/iZEUemj++M26W3cNR5h+Tw== } - engines: { node: '>=12' } + resolution: {integrity: sha512-yqDQHy4QHevpMAaxhhIwYPMv1NECwOvIpGCZkECn8w2WFHXjEwrBn3CeNIYsibZ/iZEUemj++M26W3cNR5h+Tw==} + engines: {node: '>=12'} cpu: [arm64] os: [freebsd] '@esbuild/freebsd-arm64@0.19.12': - resolution: { integrity: sha512-4aRvFIXmwAcDBw9AueDQ2YnGmz5L6obe5kmPT8Vd+/+x/JMVKCgdcRwH6APrbpNXsPz+K653Qg8HB/oXvXVukA== } - engines: { node: '>=12' } + resolution: {integrity: sha512-4aRvFIXmwAcDBw9AueDQ2YnGmz5L6obe5kmPT8Vd+/+x/JMVKCgdcRwH6APrbpNXsPz+K653Qg8HB/oXvXVukA==} + engines: {node: '>=12'} cpu: [arm64] os: [freebsd] '@esbuild/freebsd-x64@0.18.20': - resolution: { integrity: sha512-tgWRPPuQsd3RmBZwarGVHZQvtzfEBOreNuxEMKFcd5DaDn2PbBxfwLcj4+aenoh7ctXcbXmOQIn8HI6mCSw5MQ== } - engines: { node: '>=12' } + resolution: {integrity: sha512-tgWRPPuQsd3RmBZwarGVHZQvtzfEBOreNuxEMKFcd5DaDn2PbBxfwLcj4+aenoh7ctXcbXmOQIn8HI6mCSw5MQ==} + engines: {node: '>=12'} cpu: [x64] os: [freebsd] '@esbuild/freebsd-x64@0.19.12': - resolution: { integrity: sha512-EYoXZ4d8xtBoVN7CEwWY2IN4ho76xjYXqSXMNccFSx2lgqOG/1TBPW0yPx1bJZk94qu3tX0fycJeeQsKovA8gg== } - engines: { node: '>=12' } + resolution: {integrity: sha512-EYoXZ4d8xtBoVN7CEwWY2IN4ho76xjYXqSXMNccFSx2lgqOG/1TBPW0yPx1bJZk94qu3tX0fycJeeQsKovA8gg==} + engines: {node: '>=12'} cpu: [x64] os: [freebsd] '@esbuild/linux-arm64@0.18.20': - resolution: { integrity: sha512-2YbscF+UL7SQAVIpnWvYwM+3LskyDmPhe31pE7/aoTMFKKzIc9lLbyGUpmmb8a8AixOL61sQ/mFh3jEjHYFvdA== } - engines: { node: '>=12' } + resolution: {integrity: sha512-2YbscF+UL7SQAVIpnWvYwM+3LskyDmPhe31pE7/aoTMFKKzIc9lLbyGUpmmb8a8AixOL61sQ/mFh3jEjHYFvdA==} + engines: {node: '>=12'} cpu: [arm64] os: [linux] '@esbuild/linux-arm64@0.19.12': - resolution: { integrity: sha512-EoTjyYyLuVPfdPLsGVVVC8a0p1BFFvtpQDB/YLEhaXyf/5bczaGeN15QkR+O4S5LeJ92Tqotve7i1jn35qwvdA== } - engines: { node: '>=12' } + resolution: {integrity: sha512-EoTjyYyLuVPfdPLsGVVVC8a0p1BFFvtpQDB/YLEhaXyf/5bczaGeN15QkR+O4S5LeJ92Tqotve7i1jn35qwvdA==} + engines: {node: '>=12'} cpu: [arm64] os: [linux] '@esbuild/linux-arm@0.18.20': - resolution: { integrity: sha512-/5bHkMWnq1EgKr1V+Ybz3s1hWXok7mDFUMQ4cG10AfW3wL02PSZi5kFpYKrptDsgb2WAJIvRcDm+qIvXf/apvg== } - engines: { node: '>=12' } + resolution: {integrity: sha512-/5bHkMWnq1EgKr1V+Ybz3s1hWXok7mDFUMQ4cG10AfW3wL02PSZi5kFpYKrptDsgb2WAJIvRcDm+qIvXf/apvg==} + engines: {node: '>=12'} cpu: [arm] os: [linux] '@esbuild/linux-arm@0.19.12': - resolution: { integrity: sha512-J5jPms//KhSNv+LO1S1TX1UWp1ucM6N6XuL6ITdKWElCu8wXP72l9MM0zDTzzeikVyqFE6U8YAV9/tFyj0ti+w== } - engines: { node: '>=12' } + resolution: {integrity: sha512-J5jPms//KhSNv+LO1S1TX1UWp1ucM6N6XuL6ITdKWElCu8wXP72l9MM0zDTzzeikVyqFE6U8YAV9/tFyj0ti+w==} + engines: {node: '>=12'} cpu: [arm] os: [linux] '@esbuild/linux-ia32@0.18.20': - resolution: { integrity: sha512-P4etWwq6IsReT0E1KHU40bOnzMHoH73aXp96Fs8TIT6z9Hu8G6+0SHSw9i2isWrD2nbx2qo5yUqACgdfVGx7TA== } - engines: { node: '>=12' } + resolution: {integrity: sha512-P4etWwq6IsReT0E1KHU40bOnzMHoH73aXp96Fs8TIT6z9Hu8G6+0SHSw9i2isWrD2nbx2qo5yUqACgdfVGx7TA==} + engines: {node: '>=12'} cpu: [ia32] os: [linux] '@esbuild/linux-ia32@0.19.12': - resolution: { integrity: sha512-Thsa42rrP1+UIGaWz47uydHSBOgTUnwBwNq59khgIwktK6x60Hivfbux9iNR0eHCHzOLjLMLfUMLCypBkZXMHA== } - engines: { node: '>=12' } + resolution: {integrity: sha512-Thsa42rrP1+UIGaWz47uydHSBOgTUnwBwNq59khgIwktK6x60Hivfbux9iNR0eHCHzOLjLMLfUMLCypBkZXMHA==} + engines: {node: '>=12'} cpu: [ia32] os: [linux] '@esbuild/linux-loong64@0.18.20': - resolution: { integrity: sha512-nXW8nqBTrOpDLPgPY9uV+/1DjxoQ7DoB2N8eocyq8I9XuqJ7BiAMDMf9n1xZM9TgW0J8zrquIb/A7s3BJv7rjg== } - engines: { node: '>=12' } + resolution: {integrity: sha512-nXW8nqBTrOpDLPgPY9uV+/1DjxoQ7DoB2N8eocyq8I9XuqJ7BiAMDMf9n1xZM9TgW0J8zrquIb/A7s3BJv7rjg==} + engines: {node: '>=12'} cpu: [loong64] os: [linux] '@esbuild/linux-loong64@0.19.12': - resolution: { integrity: sha512-LiXdXA0s3IqRRjm6rV6XaWATScKAXjI4R4LoDlvO7+yQqFdlr1Bax62sRwkVvRIrwXxvtYEHHI4dm50jAXkuAA== } - engines: { node: '>=12' } + resolution: {integrity: sha512-LiXdXA0s3IqRRjm6rV6XaWATScKAXjI4R4LoDlvO7+yQqFdlr1Bax62sRwkVvRIrwXxvtYEHHI4dm50jAXkuAA==} + engines: {node: '>=12'} cpu: [loong64] os: [linux] '@esbuild/linux-mips64el@0.18.20': - resolution: { integrity: sha512-d5NeaXZcHp8PzYy5VnXV3VSd2D328Zb+9dEq5HE6bw6+N86JVPExrA6O68OPwobntbNJ0pzCpUFZTo3w0GyetQ== } - engines: { node: '>=12' } + resolution: {integrity: sha512-d5NeaXZcHp8PzYy5VnXV3VSd2D328Zb+9dEq5HE6bw6+N86JVPExrA6O68OPwobntbNJ0pzCpUFZTo3w0GyetQ==} + engines: {node: '>=12'} cpu: [mips64el] os: [linux] '@esbuild/linux-mips64el@0.19.12': - resolution: { integrity: sha512-fEnAuj5VGTanfJ07ff0gOA6IPsvrVHLVb6Lyd1g2/ed67oU1eFzL0r9WL7ZzscD+/N6i3dWumGE1Un4f7Amf+w== } - engines: { node: '>=12' } + resolution: {integrity: sha512-fEnAuj5VGTanfJ07ff0gOA6IPsvrVHLVb6Lyd1g2/ed67oU1eFzL0r9WL7ZzscD+/N6i3dWumGE1Un4f7Amf+w==} + engines: {node: '>=12'} cpu: [mips64el] os: [linux] '@esbuild/linux-ppc64@0.18.20': - resolution: { integrity: sha512-WHPyeScRNcmANnLQkq6AfyXRFr5D6N2sKgkFo2FqguP44Nw2eyDlbTdZwd9GYk98DZG9QItIiTlFLHJHjxP3FA== } - engines: { node: '>=12' } + resolution: {integrity: sha512-WHPyeScRNcmANnLQkq6AfyXRFr5D6N2sKgkFo2FqguP44Nw2eyDlbTdZwd9GYk98DZG9QItIiTlFLHJHjxP3FA==} + engines: {node: '>=12'} cpu: [ppc64] os: [linux] '@esbuild/linux-ppc64@0.19.12': - resolution: { integrity: sha512-nYJA2/QPimDQOh1rKWedNOe3Gfc8PabU7HT3iXWtNUbRzXS9+vgB0Fjaqr//XNbd82mCxHzik2qotuI89cfixg== } - engines: { node: '>=12' } + resolution: {integrity: sha512-nYJA2/QPimDQOh1rKWedNOe3Gfc8PabU7HT3iXWtNUbRzXS9+vgB0Fjaqr//XNbd82mCxHzik2qotuI89cfixg==} + engines: {node: '>=12'} cpu: [ppc64] os: [linux] '@esbuild/linux-riscv64@0.18.20': - resolution: { integrity: sha512-WSxo6h5ecI5XH34KC7w5veNnKkju3zBRLEQNY7mv5mtBmrP/MjNBCAlsM2u5hDBlS3NGcTQpoBvRzqBcRtpq1A== } - engines: { node: '>=12' } + resolution: {integrity: sha512-WSxo6h5ecI5XH34KC7w5veNnKkju3zBRLEQNY7mv5mtBmrP/MjNBCAlsM2u5hDBlS3NGcTQpoBvRzqBcRtpq1A==} + engines: {node: '>=12'} cpu: [riscv64] os: [linux] '@esbuild/linux-riscv64@0.19.12': - resolution: { integrity: sha512-2MueBrlPQCw5dVJJpQdUYgeqIzDQgw3QtiAHUC4RBz9FXPrskyyU3VI1hw7C0BSKB9OduwSJ79FTCqtGMWqJHg== } - engines: { node: '>=12' } + resolution: {integrity: sha512-2MueBrlPQCw5dVJJpQdUYgeqIzDQgw3QtiAHUC4RBz9FXPrskyyU3VI1hw7C0BSKB9OduwSJ79FTCqtGMWqJHg==} + engines: {node: '>=12'} cpu: [riscv64] os: [linux] '@esbuild/linux-s390x@0.18.20': - resolution: { integrity: sha512-+8231GMs3mAEth6Ja1iK0a1sQ3ohfcpzpRLH8uuc5/KVDFneH6jtAJLFGafpzpMRO6DzJ6AvXKze9LfFMrIHVQ== } - engines: { node: '>=12' } + resolution: {integrity: sha512-+8231GMs3mAEth6Ja1iK0a1sQ3ohfcpzpRLH8uuc5/KVDFneH6jtAJLFGafpzpMRO6DzJ6AvXKze9LfFMrIHVQ==} + engines: {node: '>=12'} cpu: [s390x] os: [linux] '@esbuild/linux-s390x@0.19.12': - resolution: { integrity: sha512-+Pil1Nv3Umes4m3AZKqA2anfhJiVmNCYkPchwFJNEJN5QxmTs1uzyy4TvmDrCRNT2ApwSari7ZIgrPeUx4UZDg== } - engines: { node: '>=12' } + resolution: {integrity: sha512-+Pil1Nv3Umes4m3AZKqA2anfhJiVmNCYkPchwFJNEJN5QxmTs1uzyy4TvmDrCRNT2ApwSari7ZIgrPeUx4UZDg==} + engines: {node: '>=12'} cpu: [s390x] os: [linux] '@esbuild/linux-x64@0.18.20': - resolution: { integrity: sha512-UYqiqemphJcNsFEskc73jQ7B9jgwjWrSayxawS6UVFZGWrAAtkzjxSqnoclCXxWtfwLdzU+vTpcNYhpn43uP1w== } - engines: { node: '>=12' } + resolution: {integrity: sha512-UYqiqemphJcNsFEskc73jQ7B9jgwjWrSayxawS6UVFZGWrAAtkzjxSqnoclCXxWtfwLdzU+vTpcNYhpn43uP1w==} + engines: {node: '>=12'} cpu: [x64] os: [linux] '@esbuild/linux-x64@0.19.12': - resolution: { integrity: sha512-B71g1QpxfwBvNrfyJdVDexenDIt1CiDN1TIXLbhOw0KhJzE78KIFGX6OJ9MrtC0oOqMWf+0xop4qEU8JrJTwCg== } - engines: { node: '>=12' } + resolution: {integrity: sha512-B71g1QpxfwBvNrfyJdVDexenDIt1CiDN1TIXLbhOw0KhJzE78KIFGX6OJ9MrtC0oOqMWf+0xop4qEU8JrJTwCg==} + engines: {node: '>=12'} cpu: [x64] os: [linux] '@esbuild/netbsd-x64@0.18.20': - resolution: { integrity: sha512-iO1c++VP6xUBUmltHZoMtCUdPlnPGdBom6IrO4gyKPFFVBKioIImVooR5I83nTew5UOYrk3gIJhbZh8X44y06A== } - engines: { node: '>=12' } + resolution: {integrity: sha512-iO1c++VP6xUBUmltHZoMtCUdPlnPGdBom6IrO4gyKPFFVBKioIImVooR5I83nTew5UOYrk3gIJhbZh8X44y06A==} + engines: {node: '>=12'} cpu: [x64] os: [netbsd] '@esbuild/netbsd-x64@0.19.12': - resolution: { integrity: sha512-3ltjQ7n1owJgFbuC61Oj++XhtzmymoCihNFgT84UAmJnxJfm4sYCiSLTXZtE00VWYpPMYc+ZQmB6xbSdVh0JWA== } - engines: { node: '>=12' } + resolution: {integrity: sha512-3ltjQ7n1owJgFbuC61Oj++XhtzmymoCihNFgT84UAmJnxJfm4sYCiSLTXZtE00VWYpPMYc+ZQmB6xbSdVh0JWA==} + engines: {node: '>=12'} cpu: [x64] os: [netbsd] '@esbuild/openbsd-x64@0.18.20': - resolution: { integrity: sha512-e5e4YSsuQfX4cxcygw/UCPIEP6wbIL+se3sxPdCiMbFLBWu0eiZOJ7WoD+ptCLrmjZBK1Wk7I6D/I3NglUGOxg== } - engines: { node: '>=12' } + resolution: {integrity: sha512-e5e4YSsuQfX4cxcygw/UCPIEP6wbIL+se3sxPdCiMbFLBWu0eiZOJ7WoD+ptCLrmjZBK1Wk7I6D/I3NglUGOxg==} + engines: {node: '>=12'} cpu: [x64] os: [openbsd] '@esbuild/openbsd-x64@0.19.12': - resolution: { integrity: sha512-RbrfTB9SWsr0kWmb9srfF+L933uMDdu9BIzdA7os2t0TXhCRjrQyCeOt6wVxr79CKD4c+p+YhCj31HBkYcXebw== } - engines: { node: '>=12' } + resolution: {integrity: sha512-RbrfTB9SWsr0kWmb9srfF+L933uMDdu9BIzdA7os2t0TXhCRjrQyCeOt6wVxr79CKD4c+p+YhCj31HBkYcXebw==} + engines: {node: '>=12'} cpu: [x64] os: [openbsd] '@esbuild/sunos-x64@0.18.20': - resolution: { integrity: sha512-kDbFRFp0YpTQVVrqUd5FTYmWo45zGaXe0X8E1G/LKFC0v8x0vWrhOWSLITcCn63lmZIxfOMXtCfti/RxN/0wnQ== } - engines: { node: '>=12' } + resolution: {integrity: sha512-kDbFRFp0YpTQVVrqUd5FTYmWo45zGaXe0X8E1G/LKFC0v8x0vWrhOWSLITcCn63lmZIxfOMXtCfti/RxN/0wnQ==} + engines: {node: '>=12'} cpu: [x64] os: [sunos] '@esbuild/sunos-x64@0.19.12': - resolution: { integrity: sha512-HKjJwRrW8uWtCQnQOz9qcU3mUZhTUQvi56Q8DPTLLB+DawoiQdjsYq+j+D3s9I8VFtDr+F9CjgXKKC4ss89IeA== } - engines: { node: '>=12' } + resolution: {integrity: sha512-HKjJwRrW8uWtCQnQOz9qcU3mUZhTUQvi56Q8DPTLLB+DawoiQdjsYq+j+D3s9I8VFtDr+F9CjgXKKC4ss89IeA==} + engines: {node: '>=12'} cpu: [x64] os: [sunos] '@esbuild/win32-arm64@0.18.20': - resolution: { integrity: sha512-ddYFR6ItYgoaq4v4JmQQaAI5s7npztfV4Ag6NrhiaW0RrnOXqBkgwZLofVTlq1daVTQNhtI5oieTvkRPfZrePg== } - engines: { node: '>=12' } + resolution: {integrity: sha512-ddYFR6ItYgoaq4v4JmQQaAI5s7npztfV4Ag6NrhiaW0RrnOXqBkgwZLofVTlq1daVTQNhtI5oieTvkRPfZrePg==} + engines: {node: '>=12'} cpu: [arm64] os: [win32] '@esbuild/win32-arm64@0.19.12': - resolution: { integrity: sha512-URgtR1dJnmGvX864pn1B2YUYNzjmXkuJOIqG2HdU62MVS4EHpU2946OZoTMnRUHklGtJdJZ33QfzdjGACXhn1A== } - engines: { node: '>=12' } + resolution: {integrity: sha512-URgtR1dJnmGvX864pn1B2YUYNzjmXkuJOIqG2HdU62MVS4EHpU2946OZoTMnRUHklGtJdJZ33QfzdjGACXhn1A==} + engines: {node: '>=12'} cpu: [arm64] os: [win32] '@esbuild/win32-ia32@0.18.20': - resolution: { integrity: sha512-Wv7QBi3ID/rROT08SABTS7eV4hX26sVduqDOTe1MvGMjNd3EjOz4b7zeexIR62GTIEKrfJXKL9LFxTYgkyeu7g== } - engines: { node: '>=12' } + resolution: {integrity: sha512-Wv7QBi3ID/rROT08SABTS7eV4hX26sVduqDOTe1MvGMjNd3EjOz4b7zeexIR62GTIEKrfJXKL9LFxTYgkyeu7g==} + engines: {node: '>=12'} cpu: [ia32] os: [win32] '@esbuild/win32-ia32@0.19.12': - resolution: { integrity: sha512-+ZOE6pUkMOJfmxmBZElNOx72NKpIa/HFOMGzu8fqzQJ5kgf6aTGrcJaFsNiVMH4JKpMipyK+7k0n2UXN7a8YKQ== } - engines: { node: '>=12' } + resolution: {integrity: sha512-+ZOE6pUkMOJfmxmBZElNOx72NKpIa/HFOMGzu8fqzQJ5kgf6aTGrcJaFsNiVMH4JKpMipyK+7k0n2UXN7a8YKQ==} + engines: {node: '>=12'} cpu: [ia32] os: [win32] '@esbuild/win32-x64@0.18.20': - resolution: { integrity: sha512-kTdfRcSiDfQca/y9QIkng02avJ+NCaQvrMejlsB3RRv5sE9rRoeBPISaZpKxHELzRxZyLvNts1P27W3wV+8geQ== } - engines: { node: '>=12' } + resolution: {integrity: sha512-kTdfRcSiDfQca/y9QIkng02avJ+NCaQvrMejlsB3RRv5sE9rRoeBPISaZpKxHELzRxZyLvNts1P27W3wV+8geQ==} + engines: {node: '>=12'} cpu: [x64] os: [win32] '@esbuild/win32-x64@0.19.12': - resolution: { integrity: sha512-T1QyPSDCyMXaO3pzBkF96E8xMkiRYbUEZADd29SyPGabqxMViNoii+NcK7eWJAEoU6RZyEm5lVSIjTmcdoB9HA== } - engines: { node: '>=12' } + resolution: {integrity: sha512-T1QyPSDCyMXaO3pzBkF96E8xMkiRYbUEZADd29SyPGabqxMViNoii+NcK7eWJAEoU6RZyEm5lVSIjTmcdoB9HA==} + engines: {node: '>=12'} cpu: [x64] os: [win32] '@fastify/busboy@2.1.1': - resolution: { integrity: sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA== } - engines: { node: '>=14' } + resolution: {integrity: sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA==} + engines: {node: '>=14'} '@hapi/bourne@3.0.0': - resolution: { integrity: sha512-Waj1cwPXJDucOib4a3bAISsKJVb15MKi9IvmTI/7ssVEm6sywXGjVJDhl6/umt1pK1ZS7PacXU3A1PmFKHEZ2w== } + resolution: {integrity: sha512-Waj1cwPXJDucOib4a3bAISsKJVb15MKi9IvmTI/7ssVEm6sywXGjVJDhl6/umt1pK1ZS7PacXU3A1PmFKHEZ2w==} '@isaacs/cliui@8.0.2': - resolution: { integrity: sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA== } - engines: { node: '>=12' } + resolution: {integrity: sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==} + engines: {node: '>=12'} '@istanbuljs/load-nyc-config@1.1.0': - resolution: { integrity: sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ== } - engines: { node: '>=8' } + resolution: {integrity: sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==} + engines: {node: '>=8'} '@istanbuljs/schema@0.1.3': - resolution: { integrity: sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA== } - engines: { node: '>=8' } + resolution: {integrity: sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==} + engines: {node: '>=8'} '@jest/console@29.7.0': - resolution: { integrity: sha512-5Ni4CU7XHQi32IJ398EEP4RrB8eV09sXP2ROqD4bksHrnTree52PsxvX8tpL8LvTZ3pFzXyPbNQReSN41CAhOg== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-5Ni4CU7XHQi32IJ398EEP4RrB8eV09sXP2ROqD4bksHrnTree52PsxvX8tpL8LvTZ3pFzXyPbNQReSN41CAhOg==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} '@jest/core@29.7.0': - resolution: { integrity: sha512-n7aeXWKMnGtDA48y8TLWJPJmLmmZ642Ceo78cYWEpiD7FzDgmNDV/GCVRorPABdXLJZ/9wzzgZAlHjXjxDHGsg== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-n7aeXWKMnGtDA48y8TLWJPJmLmmZ642Ceo78cYWEpiD7FzDgmNDV/GCVRorPABdXLJZ/9wzzgZAlHjXjxDHGsg==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} peerDependencies: node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0 peerDependenciesMeta: @@ -665,28 +670,28 @@ packages: optional: true '@jest/environment@29.7.0': - resolution: { integrity: sha512-aQIfHDq33ExsN4jP1NWGXhxgQ/wixs60gDiKO+XVMd8Mn0NWPWgc34ZQDTb2jKaUWQ7MuwoitXAsN2XVXNMpAw== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-aQIfHDq33ExsN4jP1NWGXhxgQ/wixs60gDiKO+XVMd8Mn0NWPWgc34ZQDTb2jKaUWQ7MuwoitXAsN2XVXNMpAw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} '@jest/expect-utils@29.7.0': - resolution: { integrity: sha512-GlsNBWiFQFCVi9QVSx7f5AgMeLxe9YCCs5PuP2O2LdjDAA8Jh9eX7lA1Jq/xdXw3Wb3hyvlFNfZIfcRetSzYcA== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-GlsNBWiFQFCVi9QVSx7f5AgMeLxe9YCCs5PuP2O2LdjDAA8Jh9eX7lA1Jq/xdXw3Wb3hyvlFNfZIfcRetSzYcA==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} '@jest/expect@29.7.0': - resolution: { integrity: sha512-8uMeAMycttpva3P1lBHB8VciS9V0XAr3GymPpipdyQXbBcuhkLQOSe8E/p92RyAdToS6ZD1tFkX+CkhoECE0dQ== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-8uMeAMycttpva3P1lBHB8VciS9V0XAr3GymPpipdyQXbBcuhkLQOSe8E/p92RyAdToS6ZD1tFkX+CkhoECE0dQ==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} '@jest/fake-timers@29.7.0': - resolution: { integrity: sha512-q4DH1Ha4TTFPdxLsqDXK1d3+ioSL7yL5oCMJZgDYm6i+6CygW5E5xVr/D1HdsGxjt1ZWSfUAs9OxSB/BNelWrQ== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-q4DH1Ha4TTFPdxLsqDXK1d3+ioSL7yL5oCMJZgDYm6i+6CygW5E5xVr/D1HdsGxjt1ZWSfUAs9OxSB/BNelWrQ==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} '@jest/globals@29.7.0': - resolution: { integrity: sha512-mpiz3dutLbkW2MNFubUGUEVLkTGiqW6yLVTA+JbP6fI6J5iL9Y0Nlg8k95pcF8ctKwCS7WVxteBs29hhfAotzQ== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-mpiz3dutLbkW2MNFubUGUEVLkTGiqW6yLVTA+JbP6fI6J5iL9Y0Nlg8k95pcF8ctKwCS7WVxteBs29hhfAotzQ==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} '@jest/reporters@29.7.0': - resolution: { integrity: sha512-DApq0KJbJOEzAFYjHADNNxAE3KbhxQB1y5Kplb5Waqw6zVbuWatSnMjE5gs8FUgEPmNsnZA3NCWl9NG0ia04Pg== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-DApq0KJbJOEzAFYjHADNNxAE3KbhxQB1y5Kplb5Waqw6zVbuWatSnMjE5gs8FUgEPmNsnZA3NCWl9NG0ia04Pg==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} peerDependencies: node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0 peerDependenciesMeta: @@ -694,335 +699,335 @@ packages: optional: true '@jest/schemas@29.6.3': - resolution: { integrity: sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} '@jest/source-map@29.6.3': - resolution: { integrity: sha512-MHjT95QuipcPrpLM+8JMSzFx6eHp5Bm+4XeFDJlwsvVBjmKNiIAvasGK2fxz2WbGRlnvqehFbh07MMa7n3YJnw== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-MHjT95QuipcPrpLM+8JMSzFx6eHp5Bm+4XeFDJlwsvVBjmKNiIAvasGK2fxz2WbGRlnvqehFbh07MMa7n3YJnw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} '@jest/test-result@29.7.0': - resolution: { integrity: sha512-Fdx+tv6x1zlkJPcWXmMDAG2HBnaR9XPSd5aDWQVsfrZmLVT3lU1cwyxLgRmXR9yrq4NBoEm9BMsfgFzTQAbJYA== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-Fdx+tv6x1zlkJPcWXmMDAG2HBnaR9XPSd5aDWQVsfrZmLVT3lU1cwyxLgRmXR9yrq4NBoEm9BMsfgFzTQAbJYA==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} '@jest/test-sequencer@29.7.0': - resolution: { integrity: sha512-GQwJ5WZVrKnOJuiYiAF52UNUJXgTZx1NHjFSEB0qEMmSZKAkdMoIzw/Cj6x6NF4AvV23AUqDpFzQkN/eYCYTxw== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-GQwJ5WZVrKnOJuiYiAF52UNUJXgTZx1NHjFSEB0qEMmSZKAkdMoIzw/Cj6x6NF4AvV23AUqDpFzQkN/eYCYTxw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} '@jest/transform@29.7.0': - resolution: { integrity: sha512-ok/BTPFzFKVMwO5eOHRrvnBVHdRy9IrsrW1GpMaQ9MCnilNLXQKmAX8s1YXDFaai9xJpac2ySzV0YeRRECr2Vw== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-ok/BTPFzFKVMwO5eOHRrvnBVHdRy9IrsrW1GpMaQ9MCnilNLXQKmAX8s1YXDFaai9xJpac2ySzV0YeRRECr2Vw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} '@jest/types@29.6.3': - resolution: { integrity: sha512-u3UPsIilWKOM3F9CXtrG8LEJmNxwoCQC/XVj4IKYXvvpx7QIi/Kg1LI5uDmDpKlac62NUtX7eLjRh+jVZcLOzw== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-u3UPsIilWKOM3F9CXtrG8LEJmNxwoCQC/XVj4IKYXvvpx7QIi/Kg1LI5uDmDpKlac62NUtX7eLjRh+jVZcLOzw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} '@jridgewell/gen-mapping@0.3.8': - resolution: { integrity: sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA== } - engines: { node: '>=6.0.0' } + resolution: {integrity: sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA==} + engines: {node: '>=6.0.0'} '@jridgewell/resolve-uri@3.1.2': - resolution: { integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw== } - engines: { node: '>=6.0.0' } + resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==} + engines: {node: '>=6.0.0'} '@jridgewell/set-array@1.2.1': - resolution: { integrity: sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A== } - engines: { node: '>=6.0.0' } + resolution: {integrity: sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==} + engines: {node: '>=6.0.0'} '@jridgewell/sourcemap-codec@1.5.0': - resolution: { integrity: sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ== } + resolution: {integrity: sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==} '@jridgewell/trace-mapping@0.3.25': - resolution: { integrity: sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ== } + resolution: {integrity: sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==} '@jridgewell/trace-mapping@0.3.9': - resolution: { integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ== } + resolution: {integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==} '@koa/multer@3.0.2': - resolution: { integrity: sha512-Q6WfPpE06mJWyZD1fzxM6zWywaoo+zocAn2YA9QYz4RsecoASr1h/kSzG0c5seDpFVKCMZM9raEfuM7XfqbRLw== } - engines: { node: '>= 8' } + resolution: {integrity: sha512-Q6WfPpE06mJWyZD1fzxM6zWywaoo+zocAn2YA9QYz4RsecoASr1h/kSzG0c5seDpFVKCMZM9raEfuM7XfqbRLw==} + engines: {node: '>= 8'} peerDependencies: multer: '*' '@koa/router@12.0.2': - resolution: { integrity: sha512-sYcHglGKTxGF+hQ6x67xDfkE9o+NhVlRHBqq6gLywaMc6CojK/5vFZByphdonKinYlMLkEkacm+HEse9HzwgTA== } - engines: { node: '>= 12' } + resolution: {integrity: sha512-sYcHglGKTxGF+hQ6x67xDfkE9o+NhVlRHBqq6gLywaMc6CojK/5vFZByphdonKinYlMLkEkacm+HEse9HzwgTA==} + engines: {node: '>= 12'} '@pkgjs/parseargs@0.11.0': - resolution: { integrity: sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg== } - engines: { node: '>=14' } + resolution: {integrity: sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==} + engines: {node: '>=14'} '@sinclair/typebox@0.27.8': - resolution: { integrity: sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA== } + resolution: {integrity: sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==} '@sinonjs/commons@3.0.1': - resolution: { integrity: sha512-K3mCHKQ9sVh8o1C9cxkwxaOmXoAMlDxC1mYyHrjqOWEcBjYr76t96zL2zlj5dUGZ3HSw240X1qgH3Mjf1yJWpQ== } + resolution: {integrity: sha512-K3mCHKQ9sVh8o1C9cxkwxaOmXoAMlDxC1mYyHrjqOWEcBjYr76t96zL2zlj5dUGZ3HSw240X1qgH3Mjf1yJWpQ==} '@sinonjs/fake-timers@10.3.0': - resolution: { integrity: sha512-V4BG07kuYSUkTCSBHG8G8TNhM+F19jXFWnQtzj+we8DrkpSBCee9Z3Ms8yiGer/dlmhe35/Xdgyo3/0rQKg7YA== } + resolution: {integrity: sha512-V4BG07kuYSUkTCSBHG8G8TNhM+F19jXFWnQtzj+we8DrkpSBCee9Z3Ms8yiGer/dlmhe35/Xdgyo3/0rQKg7YA==} '@testcontainers/rabbitmq@10.18.0': - resolution: { integrity: sha512-4qj8Pj0I0s8B7eSa2NqqQI8p8hK+lSdztbzceejZa1QToGtSuYwgfYCRvkWPlASYW8PDpaNotlvk85+bobevkg== } + resolution: {integrity: sha512-4qj8Pj0I0s8B7eSa2NqqQI8p8hK+lSdztbzceejZa1QToGtSuYwgfYCRvkWPlASYW8PDpaNotlvk85+bobevkg==} '@tsconfig/node10@1.0.11': - resolution: { integrity: sha512-DcRjDCujK/kCk/cUe8Xz8ZSpm8mS3mNNpta+jGCA6USEDfktlNvm1+IuZ9eTcDbNk41BHwpHHeW+N1lKCz4zOw== } + resolution: {integrity: sha512-DcRjDCujK/kCk/cUe8Xz8ZSpm8mS3mNNpta+jGCA6USEDfktlNvm1+IuZ9eTcDbNk41BHwpHHeW+N1lKCz4zOw==} '@tsconfig/node12@1.0.11': - resolution: { integrity: sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag== } + resolution: {integrity: sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==} '@tsconfig/node14@1.0.3': - resolution: { integrity: sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow== } + resolution: {integrity: sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==} '@tsconfig/node16@1.0.4': - resolution: { integrity: sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA== } + resolution: {integrity: sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==} '@types/babel__core@7.20.5': - resolution: { integrity: sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA== } + resolution: {integrity: sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==} '@types/babel__generator@7.6.8': - resolution: { integrity: sha512-ASsj+tpEDsEiFr1arWrlN6V3mdfjRMZt6LtK/Vp/kreFLnr5QH5+DhvD5nINYZXzwJvXeGq+05iUXcAzVrqWtw== } + resolution: {integrity: sha512-ASsj+tpEDsEiFr1arWrlN6V3mdfjRMZt6LtK/Vp/kreFLnr5QH5+DhvD5nINYZXzwJvXeGq+05iUXcAzVrqWtw==} '@types/babel__template@7.4.4': - resolution: { integrity: sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A== } + resolution: {integrity: sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==} '@types/babel__traverse@7.20.6': - resolution: { integrity: sha512-r1bzfrm0tomOI8g1SzvCaQHo6Lcv6zu0EA+W2kHrt8dyrHQxGzBBL4kdkzIS+jBMV+EYcMAEAqXqYaLJq5rOZg== } + resolution: {integrity: sha512-r1bzfrm0tomOI8g1SzvCaQHo6Lcv6zu0EA+W2kHrt8dyrHQxGzBBL4kdkzIS+jBMV+EYcMAEAqXqYaLJq5rOZg==} '@types/body-parser@1.19.5': - resolution: { integrity: sha512-fB3Zu92ucau0iQ0JMCFQE7b/dv8Ot07NI3KaZIkIUNXq82k4eBAqUaneXfleGY9JWskeS9y+u0nXMyspcuQrCg== } + resolution: {integrity: sha512-fB3Zu92ucau0iQ0JMCFQE7b/dv8Ot07NI3KaZIkIUNXq82k4eBAqUaneXfleGY9JWskeS9y+u0nXMyspcuQrCg==} '@types/connect@3.4.38': - resolution: { integrity: sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug== } + resolution: {integrity: sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==} '@types/cookiejar@2.1.5': - resolution: { integrity: sha512-he+DHOWReW0nghN24E1WUqM0efK4kI9oTqDm6XmK8ZPe2djZ90BSNdGnIyCLzCPw7/pogPlGbzI2wHGGmi4O/Q== } + resolution: {integrity: sha512-he+DHOWReW0nghN24E1WUqM0efK4kI9oTqDm6XmK8ZPe2djZ90BSNdGnIyCLzCPw7/pogPlGbzI2wHGGmi4O/Q==} '@types/cors@2.8.17': - resolution: { integrity: sha512-8CGDvrBj1zgo2qE+oS3pOCyYNqCPryMWY2bGfwA0dcfopWGgxs+78df0Rs3rc9THP4JkOhLsAa+15VdpAqkcUA== } + resolution: {integrity: sha512-8CGDvrBj1zgo2qE+oS3pOCyYNqCPryMWY2bGfwA0dcfopWGgxs+78df0Rs3rc9THP4JkOhLsAa+15VdpAqkcUA==} '@types/docker-modem@3.0.6': - resolution: { integrity: sha512-yKpAGEuKRSS8wwx0joknWxsmLha78wNMe9R2S3UNsVOkZded8UqOrV8KoeDXoXsjndxwyF3eIhyClGbO1SEhEg== } + resolution: {integrity: sha512-yKpAGEuKRSS8wwx0joknWxsmLha78wNMe9R2S3UNsVOkZded8UqOrV8KoeDXoXsjndxwyF3eIhyClGbO1SEhEg==} '@types/dockerode@3.3.35': - resolution: { integrity: sha512-P+DCMASlsH+QaKkDpekKrP5pLls767PPs+/LrlVbKnEnY5tMpEUa2C6U4gRsdFZengOqxdCIqy16R22Q3pLB6Q== } + resolution: {integrity: sha512-P+DCMASlsH+QaKkDpekKrP5pLls767PPs+/LrlVbKnEnY5tMpEUa2C6U4gRsdFZengOqxdCIqy16R22Q3pLB6Q==} '@types/dotenv-flow@3.3.3': - resolution: { integrity: sha512-aJjBsKw4bfGjvaRwrxBtEOfYZxCAq+LiFTpZ4DGTEK2b9eLVt/IAClapSxMfgV4Mi/2bIBKKjoTCO0lOh4ACLg== } + resolution: {integrity: sha512-aJjBsKw4bfGjvaRwrxBtEOfYZxCAq+LiFTpZ4DGTEK2b9eLVt/IAClapSxMfgV4Mi/2bIBKKjoTCO0lOh4ACLg==} '@types/express-serve-static-core@5.0.6': - resolution: { integrity: sha512-3xhRnjJPkULekpSzgtoNYYcTWgEZkp4myc+Saevii5JPnHNvHMRlBSHDbs7Bh1iPPoVTERHEZXyhyLbMEsExsA== } + resolution: {integrity: sha512-3xhRnjJPkULekpSzgtoNYYcTWgEZkp4myc+Saevii5JPnHNvHMRlBSHDbs7Bh1iPPoVTERHEZXyhyLbMEsExsA==} '@types/express@5.0.0': - resolution: { integrity: sha512-DvZriSMehGHL1ZNLzi6MidnsDhUZM/x2pRdDIKdwbUNqqwHxMlRdkxtn6/EPKyqKpHqTl/4nRZsRNLpZxZRpPQ== } + resolution: {integrity: sha512-DvZriSMehGHL1ZNLzi6MidnsDhUZM/x2pRdDIKdwbUNqqwHxMlRdkxtn6/EPKyqKpHqTl/4nRZsRNLpZxZRpPQ==} '@types/graceful-fs@4.1.9': - resolution: { integrity: sha512-olP3sd1qOEe5dXTSaFvQG+02VdRXcdytWLAZsAq1PecU8uqQAhkrnbli7DagjtXKW/Bl7YJbUsa8MPcuc8LHEQ== } + resolution: {integrity: sha512-olP3sd1qOEe5dXTSaFvQG+02VdRXcdytWLAZsAq1PecU8uqQAhkrnbli7DagjtXKW/Bl7YJbUsa8MPcuc8LHEQ==} '@types/http-errors@2.0.4': - resolution: { integrity: sha512-D0CFMMtydbJAegzOyHjtiKPLlvnm3iTZyZRSZoLq2mRhDdmLfIWOCYPfQJ4cu2erKghU++QvjcUjp/5h7hESpA== } + resolution: {integrity: sha512-D0CFMMtydbJAegzOyHjtiKPLlvnm3iTZyZRSZoLq2mRhDdmLfIWOCYPfQJ4cu2erKghU++QvjcUjp/5h7hESpA==} '@types/istanbul-lib-coverage@2.0.6': - resolution: { integrity: sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w== } + resolution: {integrity: sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==} '@types/istanbul-lib-report@3.0.3': - resolution: { integrity: sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA== } + resolution: {integrity: sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA==} '@types/istanbul-reports@3.0.4': - resolution: { integrity: sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ== } + resolution: {integrity: sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ==} '@types/jest@29.5.14': - resolution: { integrity: sha512-ZN+4sdnLUbo8EVvVc2ao0GFW6oVrQRPn4K2lglySj7APvSrgzxHiNNK99us4WDMi57xxA2yggblIAMNhXOotLQ== } + resolution: {integrity: sha512-ZN+4sdnLUbo8EVvVc2ao0GFW6oVrQRPn4K2lglySj7APvSrgzxHiNNK99us4WDMi57xxA2yggblIAMNhXOotLQ==} '@types/methods@1.1.4': - resolution: { integrity: sha512-ymXWVrDiCxTBE3+RIrrP533E70eA+9qu7zdWoHuOmGujkYtzf4HQF96b8nwHLqhuf4ykX61IGRIB38CC6/sImQ== } + resolution: {integrity: sha512-ymXWVrDiCxTBE3+RIrrP533E70eA+9qu7zdWoHuOmGujkYtzf4HQF96b8nwHLqhuf4ykX61IGRIB38CC6/sImQ==} '@types/mime@1.3.5': - resolution: { integrity: sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w== } + resolution: {integrity: sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w==} '@types/node@18.19.76': - resolution: { integrity: sha512-yvR7Q9LdPz2vGpmpJX5LolrgRdWvB67MJKDPSgIIzpFbaf9a1j/f5DnLp5VDyHGMR0QZHlTr1afsD87QCXFHKw== } + resolution: {integrity: sha512-yvR7Q9LdPz2vGpmpJX5LolrgRdWvB67MJKDPSgIIzpFbaf9a1j/f5DnLp5VDyHGMR0QZHlTr1afsD87QCXFHKw==} '@types/node@20.17.23': - resolution: { integrity: sha512-8PCGZ1ZJbEZuYNTMqywO+Sj4vSKjSjT6Ua+6RFOYlEvIvKQABPtrNkoVSLSKDb4obYcMhspVKmsw8Cm10NFRUg== } + resolution: {integrity: sha512-8PCGZ1ZJbEZuYNTMqywO+Sj4vSKjSjT6Ua+6RFOYlEvIvKQABPtrNkoVSLSKDb4obYcMhspVKmsw8Cm10NFRUg==} '@types/node@22.13.1': - resolution: { integrity: sha512-jK8uzQlrvXqEU91UxiK5J7pKHyzgnI1Qnl0QDHIgVGuolJhRb9EEl28Cj9b3rGR8B2lhFCtvIm5os8lFnO/1Ew== } + resolution: {integrity: sha512-jK8uzQlrvXqEU91UxiK5J7pKHyzgnI1Qnl0QDHIgVGuolJhRb9EEl28Cj9b3rGR8B2lhFCtvIm5os8lFnO/1Ew==} '@types/pg@8.11.11': - resolution: { integrity: sha512-kGT1qKM8wJQ5qlawUrEkXgvMSXoV213KfMGXcwfDwUIfUHXqXYXOfS1nE1LINRJVVVx5wCm70XnFlMHaIcQAfw== } + resolution: {integrity: sha512-kGT1qKM8wJQ5qlawUrEkXgvMSXoV213KfMGXcwfDwUIfUHXqXYXOfS1nE1LINRJVVVx5wCm70XnFlMHaIcQAfw==} '@types/qs@6.9.18': - resolution: { integrity: sha512-kK7dgTYDyGqS+e2Q4aK9X3D7q234CIZ1Bv0q/7Z5IwRDoADNU81xXJK/YVyLbLTZCoIwUoDoffFeF+p/eIklAA== } + resolution: {integrity: sha512-kK7dgTYDyGqS+e2Q4aK9X3D7q234CIZ1Bv0q/7Z5IwRDoADNU81xXJK/YVyLbLTZCoIwUoDoffFeF+p/eIklAA==} '@types/range-parser@1.2.7': - resolution: { integrity: sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ== } + resolution: {integrity: sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==} '@types/send@0.17.4': - resolution: { integrity: sha512-x2EM6TJOybec7c52BX0ZspPodMsQUd5L6PRwOunVyVUhXiBSKf3AezDL8Dgvgt5o0UfKNfuA0eMLr2wLT4AiBA== } + resolution: {integrity: sha512-x2EM6TJOybec7c52BX0ZspPodMsQUd5L6PRwOunVyVUhXiBSKf3AezDL8Dgvgt5o0UfKNfuA0eMLr2wLT4AiBA==} '@types/serve-static@1.15.7': - resolution: { integrity: sha512-W8Ym+h8nhuRwaKPaDw34QUkwsGi6Rc4yYqvKFo5rm2FUEhCFbzVWrxXUxuKK8TASjWsysJY0nsmNCGhCOIsrOw== } + resolution: {integrity: sha512-W8Ym+h8nhuRwaKPaDw34QUkwsGi6Rc4yYqvKFo5rm2FUEhCFbzVWrxXUxuKK8TASjWsysJY0nsmNCGhCOIsrOw==} '@types/ssh2-streams@0.1.12': - resolution: { integrity: sha512-Sy8tpEmCce4Tq0oSOYdfqaBpA3hDM8SoxoFh5vzFsu2oL+znzGz8oVWW7xb4K920yYMUY+PIG31qZnFMfPWNCg== } + resolution: {integrity: sha512-Sy8tpEmCce4Tq0oSOYdfqaBpA3hDM8SoxoFh5vzFsu2oL+znzGz8oVWW7xb4K920yYMUY+PIG31qZnFMfPWNCg==} '@types/ssh2@0.5.52': - resolution: { integrity: sha512-lbLLlXxdCZOSJMCInKH2+9V/77ET2J6NPQHpFI0kda61Dd1KglJs+fPQBchizmzYSOJBgdTajhPqBO1xxLywvg== } + resolution: {integrity: sha512-lbLLlXxdCZOSJMCInKH2+9V/77ET2J6NPQHpFI0kda61Dd1KglJs+fPQBchizmzYSOJBgdTajhPqBO1xxLywvg==} '@types/ssh2@1.15.4': - resolution: { integrity: sha512-9JTQgVBWSgq6mAen6PVnrAmty1lqgCMvpfN+1Ck5WRUsyMYPa6qd50/vMJ0y1zkGpOEgLzm8m8Dx/Y5vRouLaA== } + resolution: {integrity: sha512-9JTQgVBWSgq6mAen6PVnrAmty1lqgCMvpfN+1Ck5WRUsyMYPa6qd50/vMJ0y1zkGpOEgLzm8m8Dx/Y5vRouLaA==} '@types/stack-utils@2.0.3': - resolution: { integrity: sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw== } + resolution: {integrity: sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw==} '@types/strip-bom@3.0.0': - resolution: { integrity: sha512-xevGOReSYGM7g/kUBZzPqCrR/KYAo+F0yiPc85WFTJa0MSLtyFTVTU6cJu/aV4mid7IffDIWqo69THF2o4JiEQ== } + resolution: {integrity: sha512-xevGOReSYGM7g/kUBZzPqCrR/KYAo+F0yiPc85WFTJa0MSLtyFTVTU6cJu/aV4mid7IffDIWqo69THF2o4JiEQ==} '@types/strip-json-comments@0.0.30': - resolution: { integrity: sha512-7NQmHra/JILCd1QqpSzl8+mJRc8ZHz3uDm8YV1Ks9IhK0epEiTw8aIErbvH9PI+6XbqhyIQy3462nEsn7UVzjQ== } + resolution: {integrity: sha512-7NQmHra/JILCd1QqpSzl8+mJRc8ZHz3uDm8YV1Ks9IhK0epEiTw8aIErbvH9PI+6XbqhyIQy3462nEsn7UVzjQ==} '@types/superagent@8.1.9': - resolution: { integrity: sha512-pTVjI73witn+9ILmoJdajHGW2jkSaOzhiFYF1Rd3EQ94kymLqB9PjD9ISg7WaALC7+dCHT0FGe9T2LktLq/3GQ== } + resolution: {integrity: sha512-pTVjI73witn+9ILmoJdajHGW2jkSaOzhiFYF1Rd3EQ94kymLqB9PjD9ISg7WaALC7+dCHT0FGe9T2LktLq/3GQ==} '@types/supertest@6.0.2': - resolution: { integrity: sha512-137ypx2lk/wTQbW6An6safu9hXmajAifU/s7szAHLN/FeIm5w7yR0Wkl9fdJMRSHwOn4HLAI0DaB2TOORuhPDg== } + resolution: {integrity: sha512-137ypx2lk/wTQbW6An6safu9hXmajAifU/s7szAHLN/FeIm5w7yR0Wkl9fdJMRSHwOn4HLAI0DaB2TOORuhPDg==} '@types/validator@13.12.2': - resolution: { integrity: sha512-6SlHBzUW8Jhf3liqrGGXyTJSIFe4nqlJ5A5KaMZ2l/vbM3Wh3KSybots/wfWVzNLK4D1NZluDlSQIbIEPx6oyA== } + resolution: {integrity: sha512-6SlHBzUW8Jhf3liqrGGXyTJSIFe4nqlJ5A5KaMZ2l/vbM3Wh3KSybots/wfWVzNLK4D1NZluDlSQIbIEPx6oyA==} '@types/yargs-parser@21.0.3': - resolution: { integrity: sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ== } + resolution: {integrity: sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==} '@types/yargs@17.0.33': - resolution: { integrity: sha512-WpxBCKWPLr4xSsHgz511rFJAM+wS28w2zEO1QDNY5zM/S8ok70NNfztH0xwhqKyaK0OHCbN98LDAZuy1ctxDkA== } + resolution: {integrity: sha512-WpxBCKWPLr4xSsHgz511rFJAM+wS28w2zEO1QDNY5zM/S8ok70NNfztH0xwhqKyaK0OHCbN98LDAZuy1ctxDkA==} abort-controller@3.0.0: - resolution: { integrity: sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg== } - engines: { node: '>=6.5' } + resolution: {integrity: sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==} + engines: {node: '>=6.5'} accepts@1.3.8: - resolution: { integrity: sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw== } - engines: { node: '>= 0.6' } + resolution: {integrity: sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==} + engines: {node: '>= 0.6'} acorn-walk@8.3.4: - resolution: { integrity: sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g== } - engines: { node: '>=0.4.0' } + resolution: {integrity: sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==} + engines: {node: '>=0.4.0'} acorn@8.14.0: - resolution: { integrity: sha512-cl669nCJTZBsL97OF4kUQm5g5hC2uihk0NxY3WENAC0TYdILVkAyHymAntgxGkl7K+t0cXIrH5siy5S4XkFycA== } - engines: { node: '>=0.4.0' } + resolution: {integrity: sha512-cl669nCJTZBsL97OF4kUQm5g5hC2uihk0NxY3WENAC0TYdILVkAyHymAntgxGkl7K+t0cXIrH5siy5S4XkFycA==} + engines: {node: '>=0.4.0'} hasBin: true ansi-escapes@4.3.2: - resolution: { integrity: sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ== } - engines: { node: '>=8' } + resolution: {integrity: sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==} + engines: {node: '>=8'} ansi-regex@5.0.1: - resolution: { integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ== } - engines: { node: '>=8' } + resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==} + engines: {node: '>=8'} ansi-regex@6.1.0: - resolution: { integrity: sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA== } - engines: { node: '>=12' } + resolution: {integrity: sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==} + engines: {node: '>=12'} ansi-styles@4.3.0: - resolution: { integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg== } - engines: { node: '>=8' } + resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==} + engines: {node: '>=8'} ansi-styles@5.2.0: - resolution: { integrity: sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA== } - engines: { node: '>=10' } + resolution: {integrity: sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==} + engines: {node: '>=10'} ansi-styles@6.2.1: - resolution: { integrity: sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug== } - engines: { node: '>=12' } + resolution: {integrity: sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==} + engines: {node: '>=12'} anymatch@3.1.3: - resolution: { integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw== } - engines: { node: '>= 8' } + resolution: {integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==} + engines: {node: '>= 8'} append-field@1.0.0: - resolution: { integrity: sha512-klpgFSWLW1ZEs8svjfb7g4qWY0YS5imI82dTg+QahUvJ8YqAY0P10Uk8tTyh9ZGuYEZEMaeJYCF5BFuX552hsw== } + resolution: {integrity: sha512-klpgFSWLW1ZEs8svjfb7g4qWY0YS5imI82dTg+QahUvJ8YqAY0P10Uk8tTyh9ZGuYEZEMaeJYCF5BFuX552hsw==} archiver-utils@5.0.2: - resolution: { integrity: sha512-wuLJMmIBQYCsGZgYLTy5FIB2pF6Lfb6cXMSF8Qywwk3t20zWnAi7zLcQFdKQmIB8wyZpY5ER38x08GbwtR2cLA== } - engines: { node: '>= 14' } + resolution: {integrity: sha512-wuLJMmIBQYCsGZgYLTy5FIB2pF6Lfb6cXMSF8Qywwk3t20zWnAi7zLcQFdKQmIB8wyZpY5ER38x08GbwtR2cLA==} + engines: {node: '>= 14'} archiver@7.0.1: - resolution: { integrity: sha512-ZcbTaIqJOfCc03QwD468Unz/5Ir8ATtvAHsK+FdXbDIbGfihqh9mrvdcYunQzqn4HrvWWaFyaxJhGZagaJJpPQ== } - engines: { node: '>= 14' } + resolution: {integrity: sha512-ZcbTaIqJOfCc03QwD468Unz/5Ir8ATtvAHsK+FdXbDIbGfihqh9mrvdcYunQzqn4HrvWWaFyaxJhGZagaJJpPQ==} + engines: {node: '>= 14'} arg@4.1.3: - resolution: { integrity: sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA== } + resolution: {integrity: sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==} argparse@1.0.10: - resolution: { integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg== } + resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==} array-flatten@1.1.1: - resolution: { integrity: sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg== } + resolution: {integrity: sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==} asap@2.0.6: - resolution: { integrity: sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA== } + resolution: {integrity: sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA==} asn1@0.2.6: - resolution: { integrity: sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ== } + resolution: {integrity: sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ==} async-lock@1.4.1: - resolution: { integrity: sha512-Az2ZTpuytrtqENulXwO3GGv1Bztugx6TT37NIo7imr/Qo0gsYiGtSdBa2B6fsXhTpVZDNfu1Qn3pk531e3q+nQ== } + resolution: {integrity: sha512-Az2ZTpuytrtqENulXwO3GGv1Bztugx6TT37NIo7imr/Qo0gsYiGtSdBa2B6fsXhTpVZDNfu1Qn3pk531e3q+nQ==} async@3.2.6: - resolution: { integrity: sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA== } + resolution: {integrity: sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==} asynckit@0.4.0: - resolution: { integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q== } + resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==} b4a@1.6.7: - resolution: { integrity: sha512-OnAYlL5b7LEkALw87fUVafQw5rVR9RjwGd4KUwNQ6DrrNmaVaUCgLipfVlzrPQ4tWOR9P0IXGNOx50jYCCdSJg== } + resolution: {integrity: sha512-OnAYlL5b7LEkALw87fUVafQw5rVR9RjwGd4KUwNQ6DrrNmaVaUCgLipfVlzrPQ4tWOR9P0IXGNOx50jYCCdSJg==} babel-jest@29.7.0: - resolution: { integrity: sha512-BrvGY3xZSwEcCzKvKsCi2GgHqDqsYkOP4/by5xCgIwGXQxIEh+8ew3gmrE1y7XRR6LHZIj6yLYnUi/mm2KXKBg== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-BrvGY3xZSwEcCzKvKsCi2GgHqDqsYkOP4/by5xCgIwGXQxIEh+8ew3gmrE1y7XRR6LHZIj6yLYnUi/mm2KXKBg==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} peerDependencies: '@babel/core': ^7.8.0 babel-plugin-istanbul@6.1.1: - resolution: { integrity: sha512-Y1IQok9821cC9onCx5otgFfRm7Lm+I+wwxOx738M/WLPZ9Q42m4IG5W0FNX8WLL2gYMZo3JkuXIH2DOpWM+qwA== } - engines: { node: '>=8' } + resolution: {integrity: sha512-Y1IQok9821cC9onCx5otgFfRm7Lm+I+wwxOx738M/WLPZ9Q42m4IG5W0FNX8WLL2gYMZo3JkuXIH2DOpWM+qwA==} + engines: {node: '>=8'} babel-plugin-jest-hoist@29.6.3: - resolution: { integrity: sha512-ESAc/RJvGTFEzRwOTT4+lNDk/GNHMkKbNzsvT0qKRfDyyYTskxB5rnU2njIDYVxXCBHHEI1c0YwHob3WaYujOg== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-ESAc/RJvGTFEzRwOTT4+lNDk/GNHMkKbNzsvT0qKRfDyyYTskxB5rnU2njIDYVxXCBHHEI1c0YwHob3WaYujOg==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} babel-preset-current-node-syntax@1.1.0: - resolution: { integrity: sha512-ldYss8SbBlWva1bs28q78Ju5Zq1F+8BrqBZZ0VFhLBvhh6lCpC2o3gDJi/5DRLs9FgYZCnmPYIVFU4lRXCkyUw== } + resolution: {integrity: sha512-ldYss8SbBlWva1bs28q78Ju5Zq1F+8BrqBZZ0VFhLBvhh6lCpC2o3gDJi/5DRLs9FgYZCnmPYIVFU4lRXCkyUw==} peerDependencies: '@babel/core': ^7.0.0 babel-preset-jest@29.6.3: - resolution: { integrity: sha512-0B3bhxR6snWXJZtR/RliHTDPRgn1sNHOR0yVtq/IiQFyuOVjFS+wuio/R4gSNkyYmKmJB4wGZv2NZanmKmTnNA== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-0B3bhxR6snWXJZtR/RliHTDPRgn1sNHOR0yVtq/IiQFyuOVjFS+wuio/R4gSNkyYmKmJB4wGZv2NZanmKmTnNA==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} peerDependencies: '@babel/core': ^7.0.0 balanced-match@1.0.2: - resolution: { integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw== } + resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==} bare-events@2.5.4: - resolution: { integrity: sha512-+gFfDkR8pj4/TrWCGUGWmJIkBwuxPS5F+a5yWjOHQt2hHvNZd5YLzadjmDUtFmMM4y429bnKLa8bYBMHcYdnQA== } + resolution: {integrity: sha512-+gFfDkR8pj4/TrWCGUGWmJIkBwuxPS5F+a5yWjOHQt2hHvNZd5YLzadjmDUtFmMM4y429bnKLa8bYBMHcYdnQA==} bare-fs@4.0.1: - resolution: { integrity: sha512-ilQs4fm/l9eMfWY2dY0WCIUplSUp7U0CT1vrqMg1MUdeZl4fypu5UP0XcDBK5WBQPJAKP1b7XEodISmekH/CEg== } - engines: { bare: '>=1.7.0' } + resolution: {integrity: sha512-ilQs4fm/l9eMfWY2dY0WCIUplSUp7U0CT1vrqMg1MUdeZl4fypu5UP0XcDBK5WBQPJAKP1b7XEodISmekH/CEg==} + engines: {bare: '>=1.7.0'} bare-os@3.4.0: - resolution: { integrity: sha512-9Ous7UlnKbe3fMi7Y+qh0DwAup6A1JkYgPnjvMDNOlmnxNRQvQ/7Nst+OnUQKzk0iAT0m9BisbDVp9gCv8+ETA== } - engines: { bare: '>=1.6.0' } + resolution: {integrity: sha512-9Ous7UlnKbe3fMi7Y+qh0DwAup6A1JkYgPnjvMDNOlmnxNRQvQ/7Nst+OnUQKzk0iAT0m9BisbDVp9gCv8+ETA==} + engines: {bare: '>=1.6.0'} bare-path@3.0.0: - resolution: { integrity: sha512-tyfW2cQcB5NN8Saijrhqn0Zh7AnFNsnczRcuWODH0eYAXBsJ5gVxAUuNr7tsHSC6IZ77cA0SitzT+s47kot8Mw== } + resolution: {integrity: sha512-tyfW2cQcB5NN8Saijrhqn0Zh7AnFNsnczRcuWODH0eYAXBsJ5gVxAUuNr7tsHSC6IZ77cA0SitzT+s47kot8Mw==} bare-stream@2.6.5: - resolution: { integrity: sha512-jSmxKJNJmHySi6hC42zlZnq00rga4jjxcgNZjY9N5WlOe/iOoGRtdwGsHzQv2RlH2KOYMwGUXhf2zXd32BA9RA== } + resolution: {integrity: sha512-jSmxKJNJmHySi6hC42zlZnq00rga4jjxcgNZjY9N5WlOe/iOoGRtdwGsHzQv2RlH2KOYMwGUXhf2zXd32BA9RA==} peerDependencies: bare-buffer: '*' bare-events: '*' @@ -1033,255 +1038,255 @@ packages: optional: true base64-js@1.5.1: - resolution: { integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA== } + resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==} bcrypt-pbkdf@1.0.2: - resolution: { integrity: sha512-qeFIXtP4MSoi6NLqO12WfqARWWuCKi2Rn/9hJLEmtB5yTNr9DqFWkJRCf2qShWzPeAMRnOgCrq0sg/KLv5ES9w== } + resolution: {integrity: sha512-qeFIXtP4MSoi6NLqO12WfqARWWuCKi2Rn/9hJLEmtB5yTNr9DqFWkJRCf2qShWzPeAMRnOgCrq0sg/KLv5ES9w==} better-sqlite3@11.8.1: - resolution: { integrity: sha512-9BxNaBkblMjhJW8sMRZxnxVTRgbRmssZW0Oxc1MPBTfiR+WW21e2Mk4qu8CzrcZb1LwPCnFsfDEzq+SNcBU8eg== } + resolution: {integrity: sha512-9BxNaBkblMjhJW8sMRZxnxVTRgbRmssZW0Oxc1MPBTfiR+WW21e2Mk4qu8CzrcZb1LwPCnFsfDEzq+SNcBU8eg==} binary-extensions@2.3.0: - resolution: { integrity: sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw== } - engines: { node: '>=8' } + resolution: {integrity: sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==} + engines: {node: '>=8'} bindings@1.5.0: - resolution: { integrity: sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ== } + resolution: {integrity: sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==} bl@4.1.0: - resolution: { integrity: sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w== } + resolution: {integrity: sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==} body-parser@1.20.3: - resolution: { integrity: sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g== } - engines: { node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16 } + resolution: {integrity: sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==} + engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16} brace-expansion@1.1.11: - resolution: { integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA== } + resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==} brace-expansion@2.0.1: - resolution: { integrity: sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA== } + resolution: {integrity: sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==} braces@3.0.3: - resolution: { integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA== } - engines: { node: '>=8' } + resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==} + engines: {node: '>=8'} browserslist@4.24.4: - resolution: { integrity: sha512-KDi1Ny1gSePi1vm0q4oxSF8b4DR44GF4BbmS2YdhPLOEqd8pDviZOGH/GsmRwoWJ2+5Lr085X7naowMwKHDG1A== } - engines: { node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7 } + resolution: {integrity: sha512-KDi1Ny1gSePi1vm0q4oxSF8b4DR44GF4BbmS2YdhPLOEqd8pDviZOGH/GsmRwoWJ2+5Lr085X7naowMwKHDG1A==} + engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7} hasBin: true bs-logger@0.2.6: - resolution: { integrity: sha512-pd8DCoxmbgc7hyPKOvxtqNcjYoOsABPQdcCUjGp3d42VR2CX1ORhk2A87oqqu5R1kk+76nsxZupkmyd+MVtCog== } - engines: { node: '>= 6' } + resolution: {integrity: sha512-pd8DCoxmbgc7hyPKOvxtqNcjYoOsABPQdcCUjGp3d42VR2CX1ORhk2A87oqqu5R1kk+76nsxZupkmyd+MVtCog==} + engines: {node: '>= 6'} bser@2.1.1: - resolution: { integrity: sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ== } + resolution: {integrity: sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==} buffer-crc32@1.0.0: - resolution: { integrity: sha512-Db1SbgBS/fg/392AblrMJk97KggmvYhr4pB5ZIMTWtaivCPMWLkmb7m21cJvpvgK+J3nsU2CmmixNBZx4vFj/w== } - engines: { node: '>=8.0.0' } + resolution: {integrity: sha512-Db1SbgBS/fg/392AblrMJk97KggmvYhr4pB5ZIMTWtaivCPMWLkmb7m21cJvpvgK+J3nsU2CmmixNBZx4vFj/w==} + engines: {node: '>=8.0.0'} buffer-from@1.1.2: - resolution: { integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ== } + resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==} buffer@5.7.1: - resolution: { integrity: sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ== } + resolution: {integrity: sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==} buffer@6.0.3: - resolution: { integrity: sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA== } + resolution: {integrity: sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==} buildcheck@0.0.6: - resolution: { integrity: sha512-8f9ZJCUXyT1M35Jx7MkBgmBMo3oHTTBIPLiY9xyL0pl3T5RwcPEY8cUHr5LBNfu/fk6c2T4DJZuVM/8ZZT2D2A== } - engines: { node: '>=10.0.0' } + resolution: {integrity: sha512-8f9ZJCUXyT1M35Jx7MkBgmBMo3oHTTBIPLiY9xyL0pl3T5RwcPEY8cUHr5LBNfu/fk6c2T4DJZuVM/8ZZT2D2A==} + engines: {node: '>=10.0.0'} busboy@1.6.0: - resolution: { integrity: sha512-8SFQbg/0hQ9xy3UNTB0YEnsNBbWfhf7RtnzpL7TkBiTBRfrQ9Fxcnz7VJsleJpyp6rVLvXiuORqjlHi5q+PYuA== } - engines: { node: '>=10.16.0' } + resolution: {integrity: sha512-8SFQbg/0hQ9xy3UNTB0YEnsNBbWfhf7RtnzpL7TkBiTBRfrQ9Fxcnz7VJsleJpyp6rVLvXiuORqjlHi5q+PYuA==} + engines: {node: '>=10.16.0'} byline@5.0.0: - resolution: { integrity: sha512-s6webAy+R4SR8XVuJWt2V2rGvhnrhxN+9S15GNuTK3wKPOXFF6RNc+8ug2XhH+2s4f+uudG4kUVYmYOQWL2g0Q== } - engines: { node: '>=0.10.0' } + resolution: {integrity: sha512-s6webAy+R4SR8XVuJWt2V2rGvhnrhxN+9S15GNuTK3wKPOXFF6RNc+8ug2XhH+2s4f+uudG4kUVYmYOQWL2g0Q==} + engines: {node: '>=0.10.0'} bytes@3.1.2: - resolution: { integrity: sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg== } - engines: { node: '>= 0.8' } + resolution: {integrity: sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==} + engines: {node: '>= 0.8'} cache-content-type@1.0.1: - resolution: { integrity: sha512-IKufZ1o4Ut42YUrZSo8+qnMTrFuKkvyoLXUywKz9GJ5BrhOFGhLdkx9sG4KAnVvbY6kEcSFjLQul+DVmBm2bgA== } - engines: { node: '>= 6.0.0' } + resolution: {integrity: sha512-IKufZ1o4Ut42YUrZSo8+qnMTrFuKkvyoLXUywKz9GJ5BrhOFGhLdkx9sG4KAnVvbY6kEcSFjLQul+DVmBm2bgA==} + engines: {node: '>= 6.0.0'} call-bind-apply-helpers@1.0.1: - resolution: { integrity: sha512-BhYE+WDaywFg2TBWYNXAE+8B1ATnThNBqXHP5nQu0jWJdVvY2hvkpyB3qOmtmDePiS5/BDQ8wASEWGMWRG148g== } - engines: { node: '>= 0.4' } + resolution: {integrity: sha512-BhYE+WDaywFg2TBWYNXAE+8B1ATnThNBqXHP5nQu0jWJdVvY2hvkpyB3qOmtmDePiS5/BDQ8wASEWGMWRG148g==} + engines: {node: '>= 0.4'} call-bound@1.0.3: - resolution: { integrity: sha512-YTd+6wGlNlPxSuri7Y6X8tY2dmm12UMH66RpKMhiX6rsk5wXXnYgbUcOt8kiS31/AjfoTOvCsE+w8nZQLQnzHA== } - engines: { node: '>= 0.4' } + resolution: {integrity: sha512-YTd+6wGlNlPxSuri7Y6X8tY2dmm12UMH66RpKMhiX6rsk5wXXnYgbUcOt8kiS31/AjfoTOvCsE+w8nZQLQnzHA==} + engines: {node: '>= 0.4'} callsites@3.1.0: - resolution: { integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ== } - engines: { node: '>=6' } + resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==} + engines: {node: '>=6'} camelcase@5.3.1: - resolution: { integrity: sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg== } - engines: { node: '>=6' } + resolution: {integrity: sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==} + engines: {node: '>=6'} camelcase@6.3.0: - resolution: { integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA== } - engines: { node: '>=10' } + resolution: {integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==} + engines: {node: '>=10'} caniuse-lite@1.0.30001697: - resolution: { integrity: sha512-GwNPlWJin8E+d7Gxq96jxM6w0w+VFeyyXRsjU58emtkYqnbwHqXm5uT2uCmO0RQE9htWknOP4xtBlLmM/gWxvQ== } + resolution: {integrity: sha512-GwNPlWJin8E+d7Gxq96jxM6w0w+VFeyyXRsjU58emtkYqnbwHqXm5uT2uCmO0RQE9htWknOP4xtBlLmM/gWxvQ==} chalk@4.1.2: - resolution: { integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA== } - engines: { node: '>=10' } + resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==} + engines: {node: '>=10'} char-regex@1.0.2: - resolution: { integrity: sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw== } - engines: { node: '>=10' } + resolution: {integrity: sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==} + engines: {node: '>=10'} chokidar@3.6.0: - resolution: { integrity: sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw== } - engines: { node: '>= 8.10.0' } + resolution: {integrity: sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==} + engines: {node: '>= 8.10.0'} chownr@1.1.4: - resolution: { integrity: sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg== } + resolution: {integrity: sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==} ci-info@3.9.0: - resolution: { integrity: sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ== } - engines: { node: '>=8' } + resolution: {integrity: sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==} + engines: {node: '>=8'} cjs-module-lexer@1.4.3: - resolution: { integrity: sha512-9z8TZaGM1pfswYeXrUpzPrkx8UnWYdhJclsiYMm6x/w5+nN+8Tf/LnAgfLGQCm59qAOxU8WwHEq2vNwF6i4j+Q== } + resolution: {integrity: sha512-9z8TZaGM1pfswYeXrUpzPrkx8UnWYdhJclsiYMm6x/w5+nN+8Tf/LnAgfLGQCm59qAOxU8WwHEq2vNwF6i4j+Q==} class-transformer@0.5.1: - resolution: { integrity: sha512-SQa1Ws6hUbfC98vKGxZH3KFY0Y1lm5Zm0SY8XX9zbK7FJCyVEac3ATW0RIpwzW+oOfmHE5PMPufDG9hCfoEOMw== } + resolution: {integrity: sha512-SQa1Ws6hUbfC98vKGxZH3KFY0Y1lm5Zm0SY8XX9zbK7FJCyVEac3ATW0RIpwzW+oOfmHE5PMPufDG9hCfoEOMw==} class-validator@0.14.1: - resolution: { integrity: sha512-2VEG9JICxIqTpoK1eMzZqaV+u/EiwEJkMGzTrZf6sU/fwsnOITVgYJ8yojSy6CaXtO9V0Cc6ZQZ8h8m4UBuLwQ== } + resolution: {integrity: sha512-2VEG9JICxIqTpoK1eMzZqaV+u/EiwEJkMGzTrZf6sU/fwsnOITVgYJ8yojSy6CaXtO9V0Cc6ZQZ8h8m4UBuLwQ==} cliui@8.0.1: - resolution: { integrity: sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ== } - engines: { node: '>=12' } + resolution: {integrity: sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==} + engines: {node: '>=12'} co-body@6.2.0: - resolution: { integrity: sha512-Kbpv2Yd1NdL1V/V4cwLVxraHDV6K8ayohr2rmH0J87Er8+zJjcTa6dAn9QMPC9CRgU8+aNajKbSf1TzDB1yKPA== } - engines: { node: '>=8.0.0' } + resolution: {integrity: sha512-Kbpv2Yd1NdL1V/V4cwLVxraHDV6K8ayohr2rmH0J87Er8+zJjcTa6dAn9QMPC9CRgU8+aNajKbSf1TzDB1yKPA==} + engines: {node: '>=8.0.0'} co@4.6.0: - resolution: { integrity: sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ== } - engines: { iojs: '>= 1.0.0', node: '>= 0.12.0' } + resolution: {integrity: sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ==} + engines: {iojs: '>= 1.0.0', node: '>= 0.12.0'} collect-v8-coverage@1.0.2: - resolution: { integrity: sha512-lHl4d5/ONEbLlJvaJNtsF/Lz+WvB07u2ycqTYbdrq7UypDXailES4valYb2eWiJFxZlVmpGekfqoxQhzyFdT4Q== } + resolution: {integrity: sha512-lHl4d5/ONEbLlJvaJNtsF/Lz+WvB07u2ycqTYbdrq7UypDXailES4valYb2eWiJFxZlVmpGekfqoxQhzyFdT4Q==} color-convert@2.0.1: - resolution: { integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ== } - engines: { node: '>=7.0.0' } + resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==} + engines: {node: '>=7.0.0'} color-name@1.1.4: - resolution: { integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA== } + resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==} combined-stream@1.0.8: - resolution: { integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg== } - engines: { node: '>= 0.8' } + resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==} + engines: {node: '>= 0.8'} component-emitter@1.3.1: - resolution: { integrity: sha512-T0+barUSQRTUQASh8bx02dl+DhF54GtIDY13Y3m9oWTklKbb3Wv974meRpeZ3lp1JpLVECWWNHC4vaG2XHXouQ== } + resolution: {integrity: sha512-T0+barUSQRTUQASh8bx02dl+DhF54GtIDY13Y3m9oWTklKbb3Wv974meRpeZ3lp1JpLVECWWNHC4vaG2XHXouQ==} compress-commons@6.0.2: - resolution: { integrity: sha512-6FqVXeETqWPoGcfzrXb37E50NP0LXT8kAMu5ooZayhWWdgEY4lBEEcbQNXtkuKQsGduxiIcI4gOTsxTmuq/bSg== } - engines: { node: '>= 14' } + resolution: {integrity: sha512-6FqVXeETqWPoGcfzrXb37E50NP0LXT8kAMu5ooZayhWWdgEY4lBEEcbQNXtkuKQsGduxiIcI4gOTsxTmuq/bSg==} + engines: {node: '>= 14'} concat-map@0.0.1: - resolution: { integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg== } + resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==} concat-stream@1.6.2: - resolution: { integrity: sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw== } - engines: { '0': node >= 0.8 } + resolution: {integrity: sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==} + engines: {'0': node >= 0.8} content-disposition@0.5.4: - resolution: { integrity: sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ== } - engines: { node: '>= 0.6' } + resolution: {integrity: sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==} + engines: {node: '>= 0.6'} content-type@1.0.5: - resolution: { integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA== } - engines: { node: '>= 0.6' } + resolution: {integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==} + engines: {node: '>= 0.6'} convert-source-map@2.0.0: - resolution: { integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg== } + resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==} cookie-signature@1.0.6: - resolution: { integrity: sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ== } + resolution: {integrity: sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==} cookie-signature@1.0.7: - resolution: { integrity: sha512-NXdYc3dLr47pBkpUCHtKSwIOQXLVn8dZEuywboCOJY/osA0wFSLlSawr3KN8qXJEyX66FcONTH8EIlVuK0yyFA== } + resolution: {integrity: sha512-NXdYc3dLr47pBkpUCHtKSwIOQXLVn8dZEuywboCOJY/osA0wFSLlSawr3KN8qXJEyX66FcONTH8EIlVuK0yyFA==} cookie@0.7.1: - resolution: { integrity: sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w== } - engines: { node: '>= 0.6' } + resolution: {integrity: sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==} + engines: {node: '>= 0.6'} cookie@0.7.2: - resolution: { integrity: sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w== } - engines: { node: '>= 0.6' } + resolution: {integrity: sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==} + engines: {node: '>= 0.6'} cookie@1.0.2: - resolution: { integrity: sha512-9Kr/j4O16ISv8zBBhJoi4bXOYNTkFLOqSL3UDB0njXxCXNezjeyVrJyGOWtgfs/q2km1gwBcfH8q1yEGoMYunA== } - engines: { node: '>=18' } + resolution: {integrity: sha512-9Kr/j4O16ISv8zBBhJoi4bXOYNTkFLOqSL3UDB0njXxCXNezjeyVrJyGOWtgfs/q2km1gwBcfH8q1yEGoMYunA==} + engines: {node: '>=18'} cookiejar@2.1.4: - resolution: { integrity: sha512-LDx6oHrK+PhzLKJU9j5S7/Y3jM/mUHvD/DeI1WQmJn652iPC5Y4TBzC9l+5OMOXlyTTA+SmVUPm0HQUwpD5Jqw== } + resolution: {integrity: sha512-LDx6oHrK+PhzLKJU9j5S7/Y3jM/mUHvD/DeI1WQmJn652iPC5Y4TBzC9l+5OMOXlyTTA+SmVUPm0HQUwpD5Jqw==} cookies@0.9.1: - resolution: { integrity: sha512-TG2hpqe4ELx54QER/S3HQ9SRVnQnGBtKUz5bLQWtYAQ+o6GpgMs6sYUvaiJjVxb+UXwhRhAEP3m7LbsIZ77Hmw== } - engines: { node: '>= 0.8' } + resolution: {integrity: sha512-TG2hpqe4ELx54QER/S3HQ9SRVnQnGBtKUz5bLQWtYAQ+o6GpgMs6sYUvaiJjVxb+UXwhRhAEP3m7LbsIZ77Hmw==} + engines: {node: '>= 0.8'} copy-to@2.0.1: - resolution: { integrity: sha512-3DdaFaU/Zf1AnpLiFDeNCD4TOWe3Zl2RZaTzUvWiIk5ERzcCodOE20Vqq4fzCbNoHURFHT4/us/Lfq+S2zyY4w== } + resolution: {integrity: sha512-3DdaFaU/Zf1AnpLiFDeNCD4TOWe3Zl2RZaTzUvWiIk5ERzcCodOE20Vqq4fzCbNoHURFHT4/us/Lfq+S2zyY4w==} core-util-is@1.0.3: - resolution: { integrity: sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ== } + resolution: {integrity: sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==} cors@2.8.5: - resolution: { integrity: sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g== } - engines: { node: '>= 0.10' } + resolution: {integrity: sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==} + engines: {node: '>= 0.10'} cpu-features@0.0.10: - resolution: { integrity: sha512-9IkYqtX3YHPCzoVg1Py+o9057a3i0fp7S530UWokCSaFVTc7CwXPRiOjRjBQQ18ZCNafx78YfnG+HALxtVmOGA== } - engines: { node: '>=10.0.0' } + resolution: {integrity: sha512-9IkYqtX3YHPCzoVg1Py+o9057a3i0fp7S530UWokCSaFVTc7CwXPRiOjRjBQQ18ZCNafx78YfnG+HALxtVmOGA==} + engines: {node: '>=10.0.0'} crc-32@1.2.2: - resolution: { integrity: sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ== } - engines: { node: '>=0.8' } + resolution: {integrity: sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ==} + engines: {node: '>=0.8'} hasBin: true crc32-stream@6.0.0: - resolution: { integrity: sha512-piICUB6ei4IlTv1+653yq5+KoqfBYmj9bw6LqXoOneTMDXk5nM1qt12mFW1caG3LlJXEKW1Bp0WggEmIfQB34g== } - engines: { node: '>= 14' } + resolution: {integrity: sha512-piICUB6ei4IlTv1+653yq5+KoqfBYmj9bw6LqXoOneTMDXk5nM1qt12mFW1caG3LlJXEKW1Bp0WggEmIfQB34g==} + engines: {node: '>= 14'} create-jest@29.7.0: - resolution: { integrity: sha512-Adz2bdH0Vq3F53KEMJOoftQFutWCukm6J24wbPWRO4k1kMY7gS7ds/uoJkNuV8wDCtWWnuwGcJwpWcih+zEW1Q== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-Adz2bdH0Vq3F53KEMJOoftQFutWCukm6J24wbPWRO4k1kMY7gS7ds/uoJkNuV8wDCtWWnuwGcJwpWcih+zEW1Q==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} hasBin: true create-require@1.1.1: - resolution: { integrity: sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ== } + resolution: {integrity: sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==} cross-env@7.0.3: - resolution: { integrity: sha512-+/HKd6EgcQCJGh2PSjZuUitQBQynKor4wrFbRg4DtAgS1aWO+gU52xpH7M9ScGgXSYmAVS9bIJ8EzuaGw0oNAw== } - engines: { node: '>=10.14', npm: '>=6', yarn: '>=1' } + resolution: {integrity: sha512-+/HKd6EgcQCJGh2PSjZuUitQBQynKor4wrFbRg4DtAgS1aWO+gU52xpH7M9ScGgXSYmAVS9bIJ8EzuaGw0oNAw==} + engines: {node: '>=10.14', npm: '>=6', yarn: '>=1'} hasBin: true cross-fetch@3.2.0: - resolution: { integrity: sha512-Q+xVJLoGOeIMXZmbUK4HYk+69cQH6LudR0Vu/pRm2YlU/hDV9CiS0gKUMaWY5f2NeUH9C1nV3bsTlCo0FsTV1Q== } + resolution: {integrity: sha512-Q+xVJLoGOeIMXZmbUK4HYk+69cQH6LudR0Vu/pRm2YlU/hDV9CiS0gKUMaWY5f2NeUH9C1nV3bsTlCo0FsTV1Q==} cross-spawn@7.0.6: - resolution: { integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA== } - engines: { node: '>= 8' } + resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==} + engines: {node: '>= 8'} debug@2.6.9: - resolution: { integrity: sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA== } + resolution: {integrity: sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==} peerDependencies: supports-color: '*' peerDependenciesMeta: @@ -1289,8 +1294,8 @@ packages: optional: true debug@4.4.0: - resolution: { integrity: sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA== } - engines: { node: '>=6.0' } + resolution: {integrity: sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==} + engines: {node: '>=6.0'} peerDependencies: supports-color: '*' peerDependenciesMeta: @@ -1298,11 +1303,11 @@ packages: optional: true decompress-response@6.0.0: - resolution: { integrity: sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ== } - engines: { node: '>=10' } + resolution: {integrity: sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==} + engines: {node: '>=10'} dedent@1.5.3: - resolution: { integrity: sha512-NHQtfOOW68WD8lgypbLA5oT+Bt0xXJhiYvoR6SmmNXZfpzOGXwdKWmcwG8N7PwVVWV3eF/68nmD9BaJSsTBhyQ== } + resolution: {integrity: sha512-NHQtfOOW68WD8lgypbLA5oT+Bt0xXJhiYvoR6SmmNXZfpzOGXwdKWmcwG8N7PwVVWV3eF/68nmD9BaJSsTBhyQ==} peerDependencies: babel-plugin-macros: ^3.1.0 peerDependenciesMeta: @@ -1310,80 +1315,80 @@ packages: optional: true deep-equal@1.0.1: - resolution: { integrity: sha512-bHtC0iYvWhyaTzvV3CZgPeZQqCOBGyGsVV7v4eevpdkLHfiSrXUdBG+qAuSz4RI70sszvjQ1QSZ98An1yNwpSw== } + resolution: {integrity: sha512-bHtC0iYvWhyaTzvV3CZgPeZQqCOBGyGsVV7v4eevpdkLHfiSrXUdBG+qAuSz4RI70sszvjQ1QSZ98An1yNwpSw==} deep-extend@0.6.0: - resolution: { integrity: sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA== } - engines: { node: '>=4.0.0' } + resolution: {integrity: sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==} + engines: {node: '>=4.0.0'} deepmerge@4.3.1: - resolution: { integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A== } - engines: { node: '>=0.10.0' } + resolution: {integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==} + engines: {node: '>=0.10.0'} delayed-stream@1.0.0: - resolution: { integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ== } - engines: { node: '>=0.4.0' } + resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==} + engines: {node: '>=0.4.0'} delegates@1.0.0: - resolution: { integrity: sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ== } + resolution: {integrity: sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ==} depd@1.1.2: - resolution: { integrity: sha512-7emPTl6Dpo6JRXOXjLRxck+FlLRX5847cLKEn00PLAgc3g2hTZZgr+e4c2v6QpSmLeFP3n5yUo7ft6avBK/5jQ== } - engines: { node: '>= 0.6' } + resolution: {integrity: sha512-7emPTl6Dpo6JRXOXjLRxck+FlLRX5847cLKEn00PLAgc3g2hTZZgr+e4c2v6QpSmLeFP3n5yUo7ft6avBK/5jQ==} + engines: {node: '>= 0.6'} depd@2.0.0: - resolution: { integrity: sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw== } - engines: { node: '>= 0.8' } + resolution: {integrity: sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==} + engines: {node: '>= 0.8'} destroy@1.2.0: - resolution: { integrity: sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg== } - engines: { node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16 } + resolution: {integrity: sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==} + engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16} detect-libc@2.0.3: - resolution: { integrity: sha512-bwy0MGW55bG41VqxxypOsdSdGqLwXPI/focwgTYCFMbdUiBAxLg9CFzG08sz2aqzknwiX7Hkl0bQENjg8iLByw== } - engines: { node: '>=8' } + resolution: {integrity: sha512-bwy0MGW55bG41VqxxypOsdSdGqLwXPI/focwgTYCFMbdUiBAxLg9CFzG08sz2aqzknwiX7Hkl0bQENjg8iLByw==} + engines: {node: '>=8'} detect-newline@3.1.0: - resolution: { integrity: sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA== } - engines: { node: '>=8' } + resolution: {integrity: sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==} + engines: {node: '>=8'} dezalgo@1.0.4: - resolution: { integrity: sha512-rXSP0bf+5n0Qonsb+SVVfNfIsimO4HEtmnIpPHY8Q1UCzKlQrDMfdobr8nJOOsRgWCyMRqeSBQzmWUMq7zvVig== } + resolution: {integrity: sha512-rXSP0bf+5n0Qonsb+SVVfNfIsimO4HEtmnIpPHY8Q1UCzKlQrDMfdobr8nJOOsRgWCyMRqeSBQzmWUMq7zvVig==} diff-sequences@29.6.3: - resolution: { integrity: sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} diff@4.0.2: - resolution: { integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A== } - engines: { node: '>=0.3.1' } + resolution: {integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==} + engines: {node: '>=0.3.1'} docker-compose@0.24.8: - resolution: { integrity: sha512-plizRs/Vf15H+GCVxq2EUvyPK7ei9b/cVesHvjnX4xaXjM9spHe2Ytq0BitndFgvTJ3E3NljPNUEl7BAN43iZw== } - engines: { node: '>= 6.0.0' } + resolution: {integrity: sha512-plizRs/Vf15H+GCVxq2EUvyPK7ei9b/cVesHvjnX4xaXjM9spHe2Ytq0BitndFgvTJ3E3NljPNUEl7BAN43iZw==} + engines: {node: '>= 6.0.0'} docker-modem@3.0.8: - resolution: { integrity: sha512-f0ReSURdM3pcKPNS30mxOHSbaFLcknGmQjwSfmbcdOw1XWKXVhukM3NJHhr7NpY9BIyyWQb0EBo3KQvvuU5egQ== } - engines: { node: '>= 8.0' } + resolution: {integrity: sha512-f0ReSURdM3pcKPNS30mxOHSbaFLcknGmQjwSfmbcdOw1XWKXVhukM3NJHhr7NpY9BIyyWQb0EBo3KQvvuU5egQ==} + engines: {node: '>= 8.0'} dockerode@3.3.5: - resolution: { integrity: sha512-/0YNa3ZDNeLr/tSckmD69+Gq+qVNhvKfAHNeZJBnp7EOP6RGKV8ORrJHkUn20So5wU+xxT7+1n5u8PjHbfjbSA== } - engines: { node: '>= 8.0' } + resolution: {integrity: sha512-/0YNa3ZDNeLr/tSckmD69+Gq+qVNhvKfAHNeZJBnp7EOP6RGKV8ORrJHkUn20So5wU+xxT7+1n5u8PjHbfjbSA==} + engines: {node: '>= 8.0'} dotenv-flow@4.1.0: - resolution: { integrity: sha512-0cwP9jpQBQfyHwvE0cRhraZMkdV45TQedA8AAUZMsFzvmLcQyc1HPv+oX0OOYwLFjIlvgVepQ+WuQHbqDaHJZg== } - engines: { node: '>= 12.0.0' } + resolution: {integrity: sha512-0cwP9jpQBQfyHwvE0cRhraZMkdV45TQedA8AAUZMsFzvmLcQyc1HPv+oX0OOYwLFjIlvgVepQ+WuQHbqDaHJZg==} + engines: {node: '>= 12.0.0'} dotenv@16.4.7: - resolution: { integrity: sha512-47qPchRCykZC03FhkYAhrvwU4xDBFIj1QPqaarj6mdM/hgUzfPHcpkHJOn3mJAufFeeAxAzeGsr5X0M4k6fLZQ== } - engines: { node: '>=12' } + resolution: {integrity: sha512-47qPchRCykZC03FhkYAhrvwU4xDBFIj1QPqaarj6mdM/hgUzfPHcpkHJOn3mJAufFeeAxAzeGsr5X0M4k6fLZQ==} + engines: {node: '>=12'} drizzle-kit@0.30.4: - resolution: { integrity: sha512-B2oJN5UkvwwNHscPWXDG5KqAixu7AUzZ3qbe++KU9SsQ+cZWR4DXEPYcvWplyFAno0dhRJECNEhNxiDmFaPGyQ== } + resolution: {integrity: sha512-B2oJN5UkvwwNHscPWXDG5KqAixu7AUzZ3qbe++KU9SsQ+cZWR4DXEPYcvWplyFAno0dhRJECNEhNxiDmFaPGyQ==} hasBin: true drizzle-orm@0.39.3: - resolution: { integrity: sha512-EZ8ZpYvDIvKU9C56JYLOmUskazhad+uXZCTCRN4OnRMsL+xAJ05dv1eCpAG5xzhsm1hqiuC5kAZUCS924u2DTw== } + resolution: {integrity: sha512-EZ8ZpYvDIvKU9C56JYLOmUskazhad+uXZCTCRN4OnRMsL+xAJ05dv1eCpAG5xzhsm1hqiuC5kAZUCS924u2DTw==} peerDependencies: '@aws-sdk/client-rds-data': '>=3' '@cloudflare/workers-types': '>=4' @@ -1469,442 +1474,442 @@ packages: optional: true dunder-proto@1.0.1: - resolution: { integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A== } - engines: { node: '>= 0.4' } + resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==} + engines: {node: '>= 0.4'} dynamic-dedupe@0.3.0: - resolution: { integrity: sha512-ssuANeD+z97meYOqd50e04Ze5qp4bPqo8cCkI4TRjZkzAUgIDTrXV1R8QCdINpiI+hw14+rYazvTRdQrz0/rFQ== } + resolution: {integrity: sha512-ssuANeD+z97meYOqd50e04Ze5qp4bPqo8cCkI4TRjZkzAUgIDTrXV1R8QCdINpiI+hw14+rYazvTRdQrz0/rFQ==} eastasianwidth@0.2.0: - resolution: { integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA== } + resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==} ee-first@1.1.1: - resolution: { integrity: sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow== } + resolution: {integrity: sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==} ejs@3.1.10: - resolution: { integrity: sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA== } - engines: { node: '>=0.10.0' } + resolution: {integrity: sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA==} + engines: {node: '>=0.10.0'} hasBin: true electron-to-chromium@1.5.91: - resolution: { integrity: sha512-sNSHHyq048PFmZY4S90ax61q+gLCs0X0YmcOII9wG9S2XwbVr+h4VW2wWhnbp/Eys3cCwTxVF292W3qPaxIapQ== } + resolution: {integrity: sha512-sNSHHyq048PFmZY4S90ax61q+gLCs0X0YmcOII9wG9S2XwbVr+h4VW2wWhnbp/Eys3cCwTxVF292W3qPaxIapQ==} emittery@0.13.1: - resolution: { integrity: sha512-DeWwawk6r5yR9jFgnDKYt4sLS0LmHJJi3ZOnb5/JdbYwj3nW+FxQnHIjhBKz8YLC7oRNPVM9NQ47I3CVx34eqQ== } - engines: { node: '>=12' } + resolution: {integrity: sha512-DeWwawk6r5yR9jFgnDKYt4sLS0LmHJJi3ZOnb5/JdbYwj3nW+FxQnHIjhBKz8YLC7oRNPVM9NQ47I3CVx34eqQ==} + engines: {node: '>=12'} emoji-regex@8.0.0: - resolution: { integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A== } + resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==} emoji-regex@9.2.2: - resolution: { integrity: sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg== } + resolution: {integrity: sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==} encodeurl@1.0.2: - resolution: { integrity: sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w== } - engines: { node: '>= 0.8' } + resolution: {integrity: sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==} + engines: {node: '>= 0.8'} encodeurl@2.0.0: - resolution: { integrity: sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg== } - engines: { node: '>= 0.8' } + resolution: {integrity: sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==} + engines: {node: '>= 0.8'} encoding@0.1.13: - resolution: { integrity: sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A== } + resolution: {integrity: sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A==} end-of-stream@1.4.4: - resolution: { integrity: sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q== } + resolution: {integrity: sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==} error-ex@1.3.2: - resolution: { integrity: sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g== } + resolution: {integrity: sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==} es-define-property@1.0.1: - resolution: { integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g== } - engines: { node: '>= 0.4' } + resolution: {integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==} + engines: {node: '>= 0.4'} es-errors@1.3.0: - resolution: { integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw== } - engines: { node: '>= 0.4' } + resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==} + engines: {node: '>= 0.4'} es-object-atoms@1.1.1: - resolution: { integrity: sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA== } - engines: { node: '>= 0.4' } + resolution: {integrity: sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==} + engines: {node: '>= 0.4'} es-set-tostringtag@2.1.0: - resolution: { integrity: sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA== } - engines: { node: '>= 0.4' } + resolution: {integrity: sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==} + engines: {node: '>= 0.4'} esbuild-register@3.6.0: - resolution: { integrity: sha512-H2/S7Pm8a9CL1uhp9OvjwrBh5Pvx0H8qVOxNu8Wed9Y7qv56MPtq+GGM8RJpq6glYJn9Wspr8uw7l55uyinNeg== } + resolution: {integrity: sha512-H2/S7Pm8a9CL1uhp9OvjwrBh5Pvx0H8qVOxNu8Wed9Y7qv56MPtq+GGM8RJpq6glYJn9Wspr8uw7l55uyinNeg==} peerDependencies: esbuild: '>=0.12 <1' esbuild@0.18.20: - resolution: { integrity: sha512-ceqxoedUrcayh7Y7ZX6NdbbDzGROiyVBgC4PriJThBKSVPWnnFHZAkfI1lJT8QFkOwH4qOS2SJkS4wvpGl8BpA== } - engines: { node: '>=12' } + resolution: {integrity: sha512-ceqxoedUrcayh7Y7ZX6NdbbDzGROiyVBgC4PriJThBKSVPWnnFHZAkfI1lJT8QFkOwH4qOS2SJkS4wvpGl8BpA==} + engines: {node: '>=12'} hasBin: true esbuild@0.19.12: - resolution: { integrity: sha512-aARqgq8roFBj054KvQr5f1sFu0D65G+miZRCuJyJ0G13Zwx7vRar5Zhn2tkQNzIXcBrNVsv/8stehpj+GAjgbg== } - engines: { node: '>=12' } + resolution: {integrity: sha512-aARqgq8roFBj054KvQr5f1sFu0D65G+miZRCuJyJ0G13Zwx7vRar5Zhn2tkQNzIXcBrNVsv/8stehpj+GAjgbg==} + engines: {node: '>=12'} hasBin: true escalade@3.2.0: - resolution: { integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA== } - engines: { node: '>=6' } + resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==} + engines: {node: '>=6'} escape-html@1.0.3: - resolution: { integrity: sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow== } + resolution: {integrity: sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==} escape-string-regexp@2.0.0: - resolution: { integrity: sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w== } - engines: { node: '>=8' } + resolution: {integrity: sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==} + engines: {node: '>=8'} esprima@4.0.1: - resolution: { integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A== } - engines: { node: '>=4' } + resolution: {integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==} + engines: {node: '>=4'} hasBin: true etag@1.8.1: - resolution: { integrity: sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg== } - engines: { node: '>= 0.6' } + resolution: {integrity: sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==} + engines: {node: '>= 0.6'} event-target-shim@5.0.1: - resolution: { integrity: sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ== } - engines: { node: '>=6' } + resolution: {integrity: sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==} + engines: {node: '>=6'} events@3.3.0: - resolution: { integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q== } - engines: { node: '>=0.8.x' } + resolution: {integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==} + engines: {node: '>=0.8.x'} execa@5.1.1: - resolution: { integrity: sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg== } - engines: { node: '>=10' } + resolution: {integrity: sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==} + engines: {node: '>=10'} exit@0.1.2: - resolution: { integrity: sha512-Zk/eNKV2zbjpKzrsQ+n1G6poVbErQxJ0LBOJXaKZ1EViLzH+hrLu9cdXI4zw9dBQJslwBEpbQ2P1oS7nDxs6jQ== } - engines: { node: '>= 0.8.0' } + resolution: {integrity: sha512-Zk/eNKV2zbjpKzrsQ+n1G6poVbErQxJ0LBOJXaKZ1EViLzH+hrLu9cdXI4zw9dBQJslwBEpbQ2P1oS7nDxs6jQ==} + engines: {node: '>= 0.8.0'} expand-template@2.0.3: - resolution: { integrity: sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg== } - engines: { node: '>=6' } + resolution: {integrity: sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==} + engines: {node: '>=6'} expect@29.7.0: - resolution: { integrity: sha512-2Zks0hf1VLFYI1kbh0I5jP3KHHyCHpkfyHBzsSXRFgl/Bg9mWYfMW8oD+PdMPlEwy5HNsR9JutYy6pMeOh61nw== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-2Zks0hf1VLFYI1kbh0I5jP3KHHyCHpkfyHBzsSXRFgl/Bg9mWYfMW8oD+PdMPlEwy5HNsR9JutYy6pMeOh61nw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} express-session@1.18.1: - resolution: { integrity: sha512-a5mtTqEaZvBCL9A9aqkrtfz+3SMDhOVUnjafjo+s7A9Txkq+SVX2DLvSp1Zrv4uCXa3lMSK3viWnh9Gg07PBUA== } - engines: { node: '>= 0.8.0' } + resolution: {integrity: sha512-a5mtTqEaZvBCL9A9aqkrtfz+3SMDhOVUnjafjo+s7A9Txkq+SVX2DLvSp1Zrv4uCXa3lMSK3viWnh9Gg07PBUA==} + engines: {node: '>= 0.8.0'} express@4.21.2: - resolution: { integrity: sha512-28HqgMZAmih1Czt9ny7qr6ek2qddF4FclbMzwhCREB6OFfH+rXAnuNCwo1/wFvrtbgsQDb4kSbX9de9lFbrXnA== } - engines: { node: '>= 0.10.0' } + resolution: {integrity: sha512-28HqgMZAmih1Czt9ny7qr6ek2qddF4FclbMzwhCREB6OFfH+rXAnuNCwo1/wFvrtbgsQDb4kSbX9de9lFbrXnA==} + engines: {node: '>= 0.10.0'} fast-fifo@1.3.2: - resolution: { integrity: sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ== } + resolution: {integrity: sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==} fast-json-stable-stringify@2.1.0: - resolution: { integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw== } + resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==} fast-safe-stringify@2.1.1: - resolution: { integrity: sha512-W+KJc2dmILlPplD/H4K9l9LcAHAfPtP6BY84uVLXQ6Evcz9Lcg33Y2z1IVblT6xdY54PXYVHEv+0Wpq8Io6zkA== } + resolution: {integrity: sha512-W+KJc2dmILlPplD/H4K9l9LcAHAfPtP6BY84uVLXQ6Evcz9Lcg33Y2z1IVblT6xdY54PXYVHEv+0Wpq8Io6zkA==} fb-watchman@2.0.2: - resolution: { integrity: sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA== } + resolution: {integrity: sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA==} file-uri-to-path@1.0.0: - resolution: { integrity: sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw== } + resolution: {integrity: sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==} filelist@1.0.4: - resolution: { integrity: sha512-w1cEuf3S+DrLCQL7ET6kz+gmlJdbq9J7yXCSjK/OZCPA+qEN1WyF4ZAf0YYJa4/shHJra2t/d/r8SV4Ji+x+8Q== } + resolution: {integrity: sha512-w1cEuf3S+DrLCQL7ET6kz+gmlJdbq9J7yXCSjK/OZCPA+qEN1WyF4ZAf0YYJa4/shHJra2t/d/r8SV4Ji+x+8Q==} fill-range@7.1.1: - resolution: { integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg== } - engines: { node: '>=8' } + resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==} + engines: {node: '>=8'} finalhandler@1.3.1: - resolution: { integrity: sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ== } - engines: { node: '>= 0.8' } + resolution: {integrity: sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==} + engines: {node: '>= 0.8'} find-up@4.1.0: - resolution: { integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw== } - engines: { node: '>=8' } + resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==} + engines: {node: '>=8'} fix-esm@1.0.1: - resolution: { integrity: sha512-EZtb7wPXZS54GaGxaWxMlhd1DUDCnAg5srlYdu/1ZVeW+7wwR3Tp59nu52dXByFs3MBRq+SByx1wDOJpRvLEXw== } + resolution: {integrity: sha512-EZtb7wPXZS54GaGxaWxMlhd1DUDCnAg5srlYdu/1ZVeW+7wwR3Tp59nu52dXByFs3MBRq+SByx1wDOJpRvLEXw==} foreground-child@3.3.0: - resolution: { integrity: sha512-Ld2g8rrAyMYFXBhEqMz8ZAHBi4J4uS1i/CxGMDnjyFWddMXLVcDp051DZfu+t7+ab7Wv6SMqpWmyFIj5UbfFvg== } - engines: { node: '>=14' } + resolution: {integrity: sha512-Ld2g8rrAyMYFXBhEqMz8ZAHBi4J4uS1i/CxGMDnjyFWddMXLVcDp051DZfu+t7+ab7Wv6SMqpWmyFIj5UbfFvg==} + engines: {node: '>=14'} form-data@4.0.2: - resolution: { integrity: sha512-hGfm/slu0ZabnNt4oaRZ6uREyfCj6P4fT/n6A1rGV+Z0VdGXjfOhVUpkn6qVQONHGIFwmveGXyDs75+nr6FM8w== } - engines: { node: '>= 6' } + resolution: {integrity: sha512-hGfm/slu0ZabnNt4oaRZ6uREyfCj6P4fT/n6A1rGV+Z0VdGXjfOhVUpkn6qVQONHGIFwmveGXyDs75+nr6FM8w==} + engines: {node: '>= 6'} formidable@3.5.2: - resolution: { integrity: sha512-Jqc1btCy3QzRbJaICGwKcBfGWuLADRerLzDqi2NwSt/UkXLsHJw2TVResiaoBufHVHy9aSgClOHCeJsSsFLTbg== } + resolution: {integrity: sha512-Jqc1btCy3QzRbJaICGwKcBfGWuLADRerLzDqi2NwSt/UkXLsHJw2TVResiaoBufHVHy9aSgClOHCeJsSsFLTbg==} forwarded@0.2.0: - resolution: { integrity: sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow== } - engines: { node: '>= 0.6' } + resolution: {integrity: sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==} + engines: {node: '>= 0.6'} fresh@0.5.2: - resolution: { integrity: sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q== } - engines: { node: '>= 0.6' } + resolution: {integrity: sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==} + engines: {node: '>= 0.6'} fs-constants@1.0.0: - resolution: { integrity: sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow== } + resolution: {integrity: sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==} fs.realpath@1.0.0: - resolution: { integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw== } + resolution: {integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==} fsevents@2.3.3: - resolution: { integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw== } - engines: { node: ^8.16.0 || ^10.6.0 || >=11.0.0 } + resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==} + engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0} os: [darwin] function-bind@1.1.2: - resolution: { integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA== } + resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==} gensync@1.0.0-beta.2: - resolution: { integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg== } - engines: { node: '>=6.9.0' } + resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==} + engines: {node: '>=6.9.0'} get-caller-file@2.0.5: - resolution: { integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg== } - engines: { node: 6.* || 8.* || >= 10.* } + resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==} + engines: {node: 6.* || 8.* || >= 10.*} get-intrinsic@1.2.7: - resolution: { integrity: sha512-VW6Pxhsrk0KAOqs3WEd0klDiF/+V7gQOpAvY1jVU/LHmaD/kQO4523aiJuikX/QAKYiW6x8Jh+RJej1almdtCA== } - engines: { node: '>= 0.4' } + resolution: {integrity: sha512-VW6Pxhsrk0KAOqs3WEd0klDiF/+V7gQOpAvY1jVU/LHmaD/kQO4523aiJuikX/QAKYiW6x8Jh+RJej1almdtCA==} + engines: {node: '>= 0.4'} get-package-type@0.1.0: - resolution: { integrity: sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q== } - engines: { node: '>=8.0.0' } + resolution: {integrity: sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==} + engines: {node: '>=8.0.0'} get-port@5.1.1: - resolution: { integrity: sha512-g/Q1aTSDOxFpchXC4i8ZWvxA1lnPqx/JHqcpIw0/LX9T8x/GBbi6YnlN5nhaKIFkT8oFsscUKgDJYxfwfS6QsQ== } - engines: { node: '>=8' } + resolution: {integrity: sha512-g/Q1aTSDOxFpchXC4i8ZWvxA1lnPqx/JHqcpIw0/LX9T8x/GBbi6YnlN5nhaKIFkT8oFsscUKgDJYxfwfS6QsQ==} + engines: {node: '>=8'} get-proto@1.0.1: - resolution: { integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g== } - engines: { node: '>= 0.4' } + resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==} + engines: {node: '>= 0.4'} get-stream@6.0.1: - resolution: { integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg== } - engines: { node: '>=10' } + resolution: {integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==} + engines: {node: '>=10'} get-tsconfig@4.10.0: - resolution: { integrity: sha512-kGzZ3LWWQcGIAmg6iWvXn0ei6WDtV26wzHRMwDSzmAbcXrTEXxHy6IehI6/4eT6VRKyMP1eF1VqwrVUmE/LR7A== } + resolution: {integrity: sha512-kGzZ3LWWQcGIAmg6iWvXn0ei6WDtV26wzHRMwDSzmAbcXrTEXxHy6IehI6/4eT6VRKyMP1eF1VqwrVUmE/LR7A==} github-from-package@0.0.0: - resolution: { integrity: sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw== } + resolution: {integrity: sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw==} glob-parent@5.1.2: - resolution: { integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow== } - engines: { node: '>= 6' } + resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==} + engines: {node: '>= 6'} glob@10.4.5: - resolution: { integrity: sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg== } + resolution: {integrity: sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==} hasBin: true glob@11.0.1: - resolution: { integrity: sha512-zrQDm8XPnYEKawJScsnM0QzobJxlT/kHOOlRTio8IH/GrmxRE5fjllkzdaHclIuNjUQTJYH2xHNIGfdpJkDJUw== } - engines: { node: 20 || >=22 } + resolution: {integrity: sha512-zrQDm8XPnYEKawJScsnM0QzobJxlT/kHOOlRTio8IH/GrmxRE5fjllkzdaHclIuNjUQTJYH2xHNIGfdpJkDJUw==} + engines: {node: 20 || >=22} hasBin: true glob@7.2.3: - resolution: { integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q== } + resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==} deprecated: Glob versions prior to v9 are no longer supported globals@11.12.0: - resolution: { integrity: sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA== } - engines: { node: '>=4' } + resolution: {integrity: sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==} + engines: {node: '>=4'} gopd@1.2.0: - resolution: { integrity: sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg== } - engines: { node: '>= 0.4' } + resolution: {integrity: sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==} + engines: {node: '>= 0.4'} graceful-fs@4.2.11: - resolution: { integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ== } + resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==} has-flag@4.0.0: - resolution: { integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ== } - engines: { node: '>=8' } + resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==} + engines: {node: '>=8'} has-symbols@1.1.0: - resolution: { integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ== } - engines: { node: '>= 0.4' } + resolution: {integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==} + engines: {node: '>= 0.4'} has-tostringtag@1.0.2: - resolution: { integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw== } - engines: { node: '>= 0.4' } + resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==} + engines: {node: '>= 0.4'} hasown@2.0.2: - resolution: { integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ== } - engines: { node: '>= 0.4' } + resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==} + engines: {node: '>= 0.4'} hexoid@2.0.0: - resolution: { integrity: sha512-qlspKUK7IlSQv2o+5I7yhUd7TxlOG2Vr5LTa3ve2XSNVKAL/n/u/7KLvKmFNimomDIKvZFXWHv0T12mv7rT8Aw== } - engines: { node: '>=8' } + resolution: {integrity: sha512-qlspKUK7IlSQv2o+5I7yhUd7TxlOG2Vr5LTa3ve2XSNVKAL/n/u/7KLvKmFNimomDIKvZFXWHv0T12mv7rT8Aw==} + engines: {node: '>=8'} html-escaper@2.0.2: - resolution: { integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg== } + resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==} http-assert@1.5.0: - resolution: { integrity: sha512-uPpH7OKX4H25hBmU6G1jWNaqJGpTXxey+YOUizJUAgu0AjLUeC8D73hTrhvDS5D+GJN1DN1+hhc/eF/wpxtp0w== } - engines: { node: '>= 0.8' } + resolution: {integrity: sha512-uPpH7OKX4H25hBmU6G1jWNaqJGpTXxey+YOUizJUAgu0AjLUeC8D73hTrhvDS5D+GJN1DN1+hhc/eF/wpxtp0w==} + engines: {node: '>= 0.8'} http-errors@1.8.1: - resolution: { integrity: sha512-Kpk9Sm7NmI+RHhnj6OIWDI1d6fIoFAtFt9RLaTMRlg/8w49juAStsrBgp0Dp4OdxdVbRIeKhtCUvoi/RuAhO4g== } - engines: { node: '>= 0.6' } + resolution: {integrity: sha512-Kpk9Sm7NmI+RHhnj6OIWDI1d6fIoFAtFt9RLaTMRlg/8w49juAStsrBgp0Dp4OdxdVbRIeKhtCUvoi/RuAhO4g==} + engines: {node: '>= 0.6'} http-errors@2.0.0: - resolution: { integrity: sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ== } - engines: { node: '>= 0.8' } + resolution: {integrity: sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==} + engines: {node: '>= 0.8'} human-signals@2.1.0: - resolution: { integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw== } - engines: { node: '>=10.17.0' } + resolution: {integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==} + engines: {node: '>=10.17.0'} husky@9.1.7: - resolution: { integrity: sha512-5gs5ytaNjBrh5Ow3zrvdUUY+0VxIuWVL4i9irt6friV+BqdCfmV11CQTWMiBYWHbXhco+J1kHfTOUkePhCDvMA== } - engines: { node: '>=18' } + resolution: {integrity: sha512-5gs5ytaNjBrh5Ow3zrvdUUY+0VxIuWVL4i9irt6friV+BqdCfmV11CQTWMiBYWHbXhco+J1kHfTOUkePhCDvMA==} + engines: {node: '>=18'} hasBin: true iconv-lite@0.4.24: - resolution: { integrity: sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA== } - engines: { node: '>=0.10.0' } + resolution: {integrity: sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==} + engines: {node: '>=0.10.0'} iconv-lite@0.6.3: - resolution: { integrity: sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw== } - engines: { node: '>=0.10.0' } + resolution: {integrity: sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==} + engines: {node: '>=0.10.0'} ieee754@1.2.1: - resolution: { integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA== } + resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==} import-local@3.1.0: - resolution: { integrity: sha512-ASB07uLtnDs1o6EHjKpX34BKYDSqnFerfTOJL2HvMqF70LnxpjkzDB8J44oT9pu4AMPkQwf8jl6szgvNd2tRIg== } - engines: { node: '>=8' } + resolution: {integrity: sha512-ASB07uLtnDs1o6EHjKpX34BKYDSqnFerfTOJL2HvMqF70LnxpjkzDB8J44oT9pu4AMPkQwf8jl6szgvNd2tRIg==} + engines: {node: '>=8'} hasBin: true imurmurhash@0.1.4: - resolution: { integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA== } - engines: { node: '>=0.8.19' } + resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==} + engines: {node: '>=0.8.19'} inflation@2.1.0: - resolution: { integrity: sha512-t54PPJHG1Pp7VQvxyVCJ9mBbjG3Hqryges9bXoOO6GExCPa+//i/d5GSuFtpx3ALLd7lgIAur6zrIlBQyJuMlQ== } - engines: { node: '>= 0.8.0' } + resolution: {integrity: sha512-t54PPJHG1Pp7VQvxyVCJ9mBbjG3Hqryges9bXoOO6GExCPa+//i/d5GSuFtpx3ALLd7lgIAur6zrIlBQyJuMlQ==} + engines: {node: '>= 0.8.0'} inflight@1.0.6: - resolution: { integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA== } + resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==} deprecated: This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful. inherits@2.0.4: - resolution: { integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ== } + resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==} ini@1.3.8: - resolution: { integrity: sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew== } + resolution: {integrity: sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==} ipaddr.js@1.9.1: - resolution: { integrity: sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g== } - engines: { node: '>= 0.10' } + resolution: {integrity: sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==} + engines: {node: '>= 0.10'} is-arrayish@0.2.1: - resolution: { integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg== } + resolution: {integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==} is-binary-path@2.1.0: - resolution: { integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw== } - engines: { node: '>=8' } + resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==} + engines: {node: '>=8'} is-core-module@2.16.1: - resolution: { integrity: sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w== } - engines: { node: '>= 0.4' } + resolution: {integrity: sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==} + engines: {node: '>= 0.4'} is-extglob@2.1.1: - resolution: { integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ== } - engines: { node: '>=0.10.0' } + resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==} + engines: {node: '>=0.10.0'} is-fullwidth-code-point@3.0.0: - resolution: { integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg== } - engines: { node: '>=8' } + resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==} + engines: {node: '>=8'} is-generator-fn@2.1.0: - resolution: { integrity: sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ== } - engines: { node: '>=6' } + resolution: {integrity: sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==} + engines: {node: '>=6'} is-generator-function@1.1.0: - resolution: { integrity: sha512-nPUB5km40q9e8UfN/Zc24eLlzdSf9OfKByBw9CIdw4H1giPMeA0OIJvbchsCu4npfI2QcMVBsGEBHKZ7wLTWmQ== } - engines: { node: '>= 0.4' } + resolution: {integrity: sha512-nPUB5km40q9e8UfN/Zc24eLlzdSf9OfKByBw9CIdw4H1giPMeA0OIJvbchsCu4npfI2QcMVBsGEBHKZ7wLTWmQ==} + engines: {node: '>= 0.4'} is-glob@4.0.3: - resolution: { integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg== } - engines: { node: '>=0.10.0' } + resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==} + engines: {node: '>=0.10.0'} is-number@7.0.0: - resolution: { integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng== } - engines: { node: '>=0.12.0' } + resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==} + engines: {node: '>=0.12.0'} is-regex@1.2.1: - resolution: { integrity: sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g== } - engines: { node: '>= 0.4' } + resolution: {integrity: sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==} + engines: {node: '>= 0.4'} is-stream@2.0.1: - resolution: { integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg== } - engines: { node: '>=8' } + resolution: {integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==} + engines: {node: '>=8'} isarray@1.0.0: - resolution: { integrity: sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ== } + resolution: {integrity: sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==} isexe@2.0.0: - resolution: { integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw== } + resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==} istanbul-lib-coverage@3.2.2: - resolution: { integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg== } - engines: { node: '>=8' } + resolution: {integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==} + engines: {node: '>=8'} istanbul-lib-instrument@5.2.1: - resolution: { integrity: sha512-pzqtp31nLv/XFOzXGuvhCb8qhjmTVo5vjVk19XE4CRlSWz0KoeJ3bw9XsA7nOp9YBf4qHjwBxkDzKcME/J29Yg== } - engines: { node: '>=8' } + resolution: {integrity: sha512-pzqtp31nLv/XFOzXGuvhCb8qhjmTVo5vjVk19XE4CRlSWz0KoeJ3bw9XsA7nOp9YBf4qHjwBxkDzKcME/J29Yg==} + engines: {node: '>=8'} istanbul-lib-instrument@6.0.3: - resolution: { integrity: sha512-Vtgk7L/R2JHyyGW07spoFlB8/lpjiOLTjMdms6AFMraYt3BaJauod/NGrfnVG/y4Ix1JEuMRPDPEj2ua+zz1/Q== } - engines: { node: '>=10' } + resolution: {integrity: sha512-Vtgk7L/R2JHyyGW07spoFlB8/lpjiOLTjMdms6AFMraYt3BaJauod/NGrfnVG/y4Ix1JEuMRPDPEj2ua+zz1/Q==} + engines: {node: '>=10'} istanbul-lib-report@3.0.1: - resolution: { integrity: sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw== } - engines: { node: '>=10' } + resolution: {integrity: sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==} + engines: {node: '>=10'} istanbul-lib-source-maps@4.0.1: - resolution: { integrity: sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw== } - engines: { node: '>=10' } + resolution: {integrity: sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==} + engines: {node: '>=10'} istanbul-reports@3.1.7: - resolution: { integrity: sha512-BewmUXImeuRk2YY0PVbxgKAysvhRPUQE0h5QRM++nVWyubKGV0l8qQ5op8+B2DOmwSe63Jivj0BjkPQVf8fP5g== } - engines: { node: '>=8' } + resolution: {integrity: sha512-BewmUXImeuRk2YY0PVbxgKAysvhRPUQE0h5QRM++nVWyubKGV0l8qQ5op8+B2DOmwSe63Jivj0BjkPQVf8fP5g==} + engines: {node: '>=8'} jackspeak@3.4.3: - resolution: { integrity: sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw== } + resolution: {integrity: sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==} jackspeak@4.1.0: - resolution: { integrity: sha512-9DDdhb5j6cpeitCbvLO7n7J4IxnbM6hoF6O1g4HQ5TfhvvKN8ywDM7668ZhMHRqVmxqhps/F6syWK2KcPxYlkw== } - engines: { node: 20 || >=22 } + resolution: {integrity: sha512-9DDdhb5j6cpeitCbvLO7n7J4IxnbM6hoF6O1g4HQ5TfhvvKN8ywDM7668ZhMHRqVmxqhps/F6syWK2KcPxYlkw==} + engines: {node: 20 || >=22} jake@10.9.2: - resolution: { integrity: sha512-2P4SQ0HrLQ+fw6llpLnOaGAvN2Zu6778SJMrCUwns4fOoG9ayrTiZk3VV8sCPkVZF8ab0zksVpS8FDY5pRCNBA== } - engines: { node: '>=10' } + resolution: {integrity: sha512-2P4SQ0HrLQ+fw6llpLnOaGAvN2Zu6778SJMrCUwns4fOoG9ayrTiZk3VV8sCPkVZF8ab0zksVpS8FDY5pRCNBA==} + engines: {node: '>=10'} hasBin: true jest-changed-files@29.7.0: - resolution: { integrity: sha512-fEArFiwf1BpQ+4bXSprcDc3/x4HSzL4al2tozwVpDFpsxALjLYdyiIK4e5Vz66GQJIbXJ82+35PtysofptNX2w== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-fEArFiwf1BpQ+4bXSprcDc3/x4HSzL4al2tozwVpDFpsxALjLYdyiIK4e5Vz66GQJIbXJ82+35PtysofptNX2w==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} jest-circus@29.7.0: - resolution: { integrity: sha512-3E1nCMgipcTkCocFwM90XXQab9bS+GMsjdpmPrlelaxwD93Ad8iVEjX/vvHPdLPnFf+L40u+5+iutRdA1N9myw== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-3E1nCMgipcTkCocFwM90XXQab9bS+GMsjdpmPrlelaxwD93Ad8iVEjX/vvHPdLPnFf+L40u+5+iutRdA1N9myw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} jest-cli@29.7.0: - resolution: { integrity: sha512-OVVobw2IubN/GSYsxETi+gOe7Ka59EFMR/twOU3Jb2GnKKeMGJB5SGUUrEz3SFVmJASUdZUzy83sLNNQ2gZslg== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-OVVobw2IubN/GSYsxETi+gOe7Ka59EFMR/twOU3Jb2GnKKeMGJB5SGUUrEz3SFVmJASUdZUzy83sLNNQ2gZslg==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} hasBin: true peerDependencies: node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0 @@ -1913,8 +1918,8 @@ packages: optional: true jest-config@29.7.0: - resolution: { integrity: sha512-uXbpfeQ7R6TZBqI3/TxCU4q4ttk3u0PJeC+E0zbfSoSjq6bJ7buBPxzQPL0ifrkY4DNu4JUdk0ImlBUYi840eQ== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-uXbpfeQ7R6TZBqI3/TxCU4q4ttk3u0PJeC+E0zbfSoSjq6bJ7buBPxzQPL0ifrkY4DNu4JUdk0ImlBUYi840eQ==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} peerDependencies: '@types/node': '*' ts-node: '>=9.0.0' @@ -1925,51 +1930,51 @@ packages: optional: true jest-diff@29.7.0: - resolution: { integrity: sha512-LMIgiIrhigmPrs03JHpxUh2yISK3vLFPkAodPeo0+BuF7wA2FoQbkEg1u8gBYBThncu7e1oEDUfIXVuTqLRUjw== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-LMIgiIrhigmPrs03JHpxUh2yISK3vLFPkAodPeo0+BuF7wA2FoQbkEg1u8gBYBThncu7e1oEDUfIXVuTqLRUjw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} jest-docblock@29.7.0: - resolution: { integrity: sha512-q617Auw3A612guyaFgsbFeYpNP5t2aoUNLwBUbc/0kD1R4t9ixDbyFTHd1nok4epoVFpr7PmeWHrhvuV3XaJ4g== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-q617Auw3A612guyaFgsbFeYpNP5t2aoUNLwBUbc/0kD1R4t9ixDbyFTHd1nok4epoVFpr7PmeWHrhvuV3XaJ4g==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} jest-each@29.7.0: - resolution: { integrity: sha512-gns+Er14+ZrEoC5fhOfYCY1LOHHr0TI+rQUHZS8Ttw2l7gl+80eHc/gFf2Ktkw0+SIACDTeWvpFcv3B04VembQ== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-gns+Er14+ZrEoC5fhOfYCY1LOHHr0TI+rQUHZS8Ttw2l7gl+80eHc/gFf2Ktkw0+SIACDTeWvpFcv3B04VembQ==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} jest-environment-node@29.7.0: - resolution: { integrity: sha512-DOSwCRqXirTOyheM+4d5YZOrWcdu0LNZ87ewUoywbcb2XR4wKgqiG8vNeYwhjFMbEkfju7wx2GYH0P2gevGvFw== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-DOSwCRqXirTOyheM+4d5YZOrWcdu0LNZ87ewUoywbcb2XR4wKgqiG8vNeYwhjFMbEkfju7wx2GYH0P2gevGvFw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} jest-fetch-mock@3.0.3: - resolution: { integrity: sha512-Ux1nWprtLrdrH4XwE7O7InRY6psIi3GOsqNESJgMJ+M5cv4A8Lh7SN9d2V2kKRZ8ebAfcd1LNyZguAOb6JiDqw== } + resolution: {integrity: sha512-Ux1nWprtLrdrH4XwE7O7InRY6psIi3GOsqNESJgMJ+M5cv4A8Lh7SN9d2V2kKRZ8ebAfcd1LNyZguAOb6JiDqw==} jest-get-type@29.6.3: - resolution: { integrity: sha512-zrteXnqYxfQh7l5FHyL38jL39di8H8rHoecLH3JNxH3BwOrBsNeabdap5e0I23lD4HHI8W5VFBZqG4Eaq5LNcw== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-zrteXnqYxfQh7l5FHyL38jL39di8H8rHoecLH3JNxH3BwOrBsNeabdap5e0I23lD4HHI8W5VFBZqG4Eaq5LNcw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} jest-haste-map@29.7.0: - resolution: { integrity: sha512-fP8u2pyfqx0K1rGn1R9pyE0/KTn+G7PxktWidOBTqFPLYX0b9ksaMFkhK5vrS3DVun09pckLdlx90QthlW7AmA== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-fP8u2pyfqx0K1rGn1R9pyE0/KTn+G7PxktWidOBTqFPLYX0b9ksaMFkhK5vrS3DVun09pckLdlx90QthlW7AmA==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} jest-leak-detector@29.7.0: - resolution: { integrity: sha512-kYA8IJcSYtST2BY9I+SMC32nDpBT3J2NvWJx8+JCuCdl/CR1I4EKUJROiP8XtCcxqgTTBGJNdbB1A8XRKbTetw== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-kYA8IJcSYtST2BY9I+SMC32nDpBT3J2NvWJx8+JCuCdl/CR1I4EKUJROiP8XtCcxqgTTBGJNdbB1A8XRKbTetw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} jest-matcher-utils@29.7.0: - resolution: { integrity: sha512-sBkD+Xi9DtcChsI3L3u0+N0opgPYnCRPtGcQYrgXmR+hmt/fYfWAL0xRXYU8eWOdfuLgBe0YCW3AFtnRLagq/g== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-sBkD+Xi9DtcChsI3L3u0+N0opgPYnCRPtGcQYrgXmR+hmt/fYfWAL0xRXYU8eWOdfuLgBe0YCW3AFtnRLagq/g==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} jest-message-util@29.7.0: - resolution: { integrity: sha512-GBEV4GRADeP+qtB2+6u61stea8mGcOT4mCtrYISZwfu9/ISHFJ/5zOMXYbpBE9RsS5+Gb63DW4FgmnKJ79Kf6w== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-GBEV4GRADeP+qtB2+6u61stea8mGcOT4mCtrYISZwfu9/ISHFJ/5zOMXYbpBE9RsS5+Gb63DW4FgmnKJ79Kf6w==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} jest-mock@29.7.0: - resolution: { integrity: sha512-ITOMZn+UkYS4ZFh83xYAOzWStloNzJFO2s8DWrE4lhtGD+AorgnbkiKERe4wQVBydIGPx059g6riW5Btp6Llnw== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-ITOMZn+UkYS4ZFh83xYAOzWStloNzJFO2s8DWrE4lhtGD+AorgnbkiKERe4wQVBydIGPx059g6riW5Btp6Llnw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} jest-pnp-resolver@1.2.3: - resolution: { integrity: sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w== } - engines: { node: '>=6' } + resolution: {integrity: sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w==} + engines: {node: '>=6'} peerDependencies: jest-resolve: '*' peerDependenciesMeta: @@ -1977,48 +1982,48 @@ packages: optional: true jest-regex-util@29.6.3: - resolution: { integrity: sha512-KJJBsRCyyLNWCNBOvZyRDnAIfUiRJ8v+hOBQYGn8gDyF3UegwiP4gwRR3/SDa42g1YbVycTidUF3rKjyLFDWbg== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-KJJBsRCyyLNWCNBOvZyRDnAIfUiRJ8v+hOBQYGn8gDyF3UegwiP4gwRR3/SDa42g1YbVycTidUF3rKjyLFDWbg==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} jest-resolve-dependencies@29.7.0: - resolution: { integrity: sha512-un0zD/6qxJ+S0et7WxeI3H5XSe9lTBBR7bOHCHXkKR6luG5mwDDlIzVQ0V5cZCuoTgEdcdwzTghYkTWfubi+nA== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-un0zD/6qxJ+S0et7WxeI3H5XSe9lTBBR7bOHCHXkKR6luG5mwDDlIzVQ0V5cZCuoTgEdcdwzTghYkTWfubi+nA==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} jest-resolve@29.7.0: - resolution: { integrity: sha512-IOVhZSrg+UvVAshDSDtHyFCCBUl/Q3AAJv8iZ6ZjnZ74xzvwuzLXid9IIIPgTnY62SJjfuupMKZsZQRsCvxEgA== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-IOVhZSrg+UvVAshDSDtHyFCCBUl/Q3AAJv8iZ6ZjnZ74xzvwuzLXid9IIIPgTnY62SJjfuupMKZsZQRsCvxEgA==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} jest-runner@29.7.0: - resolution: { integrity: sha512-fsc4N6cPCAahybGBfTRcq5wFR6fpLznMg47sY5aDpsoejOcVYFb07AHuSnR0liMcPTgBsA3ZJL6kFOjPdoNipQ== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-fsc4N6cPCAahybGBfTRcq5wFR6fpLznMg47sY5aDpsoejOcVYFb07AHuSnR0liMcPTgBsA3ZJL6kFOjPdoNipQ==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} jest-runtime@29.7.0: - resolution: { integrity: sha512-gUnLjgwdGqW7B4LvOIkbKs9WGbn+QLqRQQ9juC6HndeDiezIwhDP+mhMwHWCEcfQ5RUXa6OPnFF8BJh5xegwwQ== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-gUnLjgwdGqW7B4LvOIkbKs9WGbn+QLqRQQ9juC6HndeDiezIwhDP+mhMwHWCEcfQ5RUXa6OPnFF8BJh5xegwwQ==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} jest-snapshot@29.7.0: - resolution: { integrity: sha512-Rm0BMWtxBcioHr1/OX5YCP8Uov4riHvKPknOGs804Zg9JGZgmIBkbtlxJC/7Z4msKYVbIJtfU+tKb8xlYNfdkw== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-Rm0BMWtxBcioHr1/OX5YCP8Uov4riHvKPknOGs804Zg9JGZgmIBkbtlxJC/7Z4msKYVbIJtfU+tKb8xlYNfdkw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} jest-util@29.7.0: - resolution: { integrity: sha512-z6EbKajIpqGKU56y5KBUgy1dt1ihhQJgWzUlZHArA/+X2ad7Cb5iF+AK1EWVL/Bo7Rz9uurpqw6SiBCefUbCGA== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-z6EbKajIpqGKU56y5KBUgy1dt1ihhQJgWzUlZHArA/+X2ad7Cb5iF+AK1EWVL/Bo7Rz9uurpqw6SiBCefUbCGA==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} jest-validate@29.7.0: - resolution: { integrity: sha512-ZB7wHqaRGVw/9hST/OuFUReG7M8vKeq0/J2egIGLdvjHCmYqGARhzXmtgi+gVeZ5uXFF219aOc3Ls2yLg27tkw== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-ZB7wHqaRGVw/9hST/OuFUReG7M8vKeq0/J2egIGLdvjHCmYqGARhzXmtgi+gVeZ5uXFF219aOc3Ls2yLg27tkw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} jest-watcher@29.7.0: - resolution: { integrity: sha512-49Fg7WXkU3Vl2h6LbLtMQ/HyB6rXSIX7SqvBLQmssRBGN9I0PNvPmAmCWSOY6SOvrjhI/F7/bGAv9RtnsPA03g== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-49Fg7WXkU3Vl2h6LbLtMQ/HyB6rXSIX7SqvBLQmssRBGN9I0PNvPmAmCWSOY6SOvrjhI/F7/bGAv9RtnsPA03g==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} jest-worker@29.7.0: - resolution: { integrity: sha512-eIz2msL/EzL9UFTFFx7jBTkeZfku0yUAyZZZmJ93H2TYEiroIx2PQjEXcwYtYl8zXCxb+PAmA2hLIt/6ZEkPHw== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-eIz2msL/EzL9UFTFFx7jBTkeZfku0yUAyZZZmJ93H2TYEiroIx2PQjEXcwYtYl8zXCxb+PAmA2hLIt/6ZEkPHw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} jest@29.7.0: - resolution: { integrity: sha512-NIy3oAFp9shda19hy4HK0HRTWKtPJmGdnvywu01nOqNC2vZg+Z+fvJDxpMQA88eb2I9EcafcdjYgsDthnYTvGw== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-NIy3oAFp9shda19hy4HK0HRTWKtPJmGdnvywu01nOqNC2vZg+Z+fvJDxpMQA88eb2I9EcafcdjYgsDthnYTvGw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} hasBin: true peerDependencies: node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0 @@ -2027,209 +2032,209 @@ packages: optional: true js-tokens@4.0.0: - resolution: { integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ== } + resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==} js-yaml@3.14.1: - resolution: { integrity: sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g== } + resolution: {integrity: sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==} hasBin: true jsesc@3.1.0: - resolution: { integrity: sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA== } - engines: { node: '>=6' } + resolution: {integrity: sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==} + engines: {node: '>=6'} hasBin: true json-parse-even-better-errors@2.3.1: - resolution: { integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w== } + resolution: {integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==} json5@2.2.3: - resolution: { integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg== } - engines: { node: '>=6' } + resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==} + engines: {node: '>=6'} hasBin: true keygrip@1.1.0: - resolution: { integrity: sha512-iYSchDJ+liQ8iwbSI2QqsQOvqv58eJCEanyJPJi+Khyu8smkcKSFUCbPwzFcL7YVtZ6eONjqRX/38caJ7QjRAQ== } - engines: { node: '>= 0.6' } + resolution: {integrity: sha512-iYSchDJ+liQ8iwbSI2QqsQOvqv58eJCEanyJPJi+Khyu8smkcKSFUCbPwzFcL7YVtZ6eONjqRX/38caJ7QjRAQ==} + engines: {node: '>= 0.6'} kleur@3.0.3: - resolution: { integrity: sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w== } - engines: { node: '>=6' } + resolution: {integrity: sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==} + engines: {node: '>=6'} koa-bodyparser@4.4.1: - resolution: { integrity: sha512-kBH3IYPMb+iAXnrxIhXnW+gXV8OTzCu8VPDqvcDHW9SQrbkHmqPQtiZwrltNmSq6/lpipHnT7k7PsjlVD7kK0w== } - engines: { node: '>=8.0.0' } + resolution: {integrity: sha512-kBH3IYPMb+iAXnrxIhXnW+gXV8OTzCu8VPDqvcDHW9SQrbkHmqPQtiZwrltNmSq6/lpipHnT7k7PsjlVD7kK0w==} + engines: {node: '>=8.0.0'} koa-compose@4.1.0: - resolution: { integrity: sha512-8ODW8TrDuMYvXRwra/Kh7/rJo9BtOfPc6qO8eAfC80CnCvSjSl0bkRM24X6/XBBEyj0v1nRUQ1LyOy3dbqOWXw== } + resolution: {integrity: sha512-8ODW8TrDuMYvXRwra/Kh7/rJo9BtOfPc6qO8eAfC80CnCvSjSl0bkRM24X6/XBBEyj0v1nRUQ1LyOy3dbqOWXw==} koa-convert@2.0.0: - resolution: { integrity: sha512-asOvN6bFlSnxewce2e/DK3p4tltyfC4VM7ZwuTuepI7dEQVcvpyFuBcEARu1+Hxg8DIwytce2n7jrZtRlPrARA== } - engines: { node: '>= 10' } + resolution: {integrity: sha512-asOvN6bFlSnxewce2e/DK3p4tltyfC4VM7ZwuTuepI7dEQVcvpyFuBcEARu1+Hxg8DIwytce2n7jrZtRlPrARA==} + engines: {node: '>= 10'} koa@2.15.4: - resolution: { integrity: sha512-7fNBIdrU2PEgLljXoPWoyY4r1e+ToWCmzS/wwMPbUNs7X+5MMET1ObhJBlUkF5uZG9B6QhM2zS1TsH6adegkiQ== } - engines: { node: ^4.8.4 || ^6.10.1 || ^7.10.1 || >= 8.1.4 } + resolution: {integrity: sha512-7fNBIdrU2PEgLljXoPWoyY4r1e+ToWCmzS/wwMPbUNs7X+5MMET1ObhJBlUkF5uZG9B6QhM2zS1TsH6adegkiQ==} + engines: {node: ^4.8.4 || ^6.10.1 || ^7.10.1 || >= 8.1.4} lazystream@1.0.1: - resolution: { integrity: sha512-b94GiNHQNy6JNTrt5w6zNyffMrNkXZb3KTkCZJb2V1xaEGCk093vkZ2jk3tpaeP33/OiXC+WvK9AxUebnf5nbw== } - engines: { node: '>= 0.6.3' } + resolution: {integrity: sha512-b94GiNHQNy6JNTrt5w6zNyffMrNkXZb3KTkCZJb2V1xaEGCk093vkZ2jk3tpaeP33/OiXC+WvK9AxUebnf5nbw==} + engines: {node: '>= 0.6.3'} leven@3.1.0: - resolution: { integrity: sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A== } - engines: { node: '>=6' } + resolution: {integrity: sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==} + engines: {node: '>=6'} libphonenumber-js@1.11.19: - resolution: { integrity: sha512-bW/Yp/9dod6fmyR+XqSUL1N5JE7QRxQ3KrBIbYS1FTv32e5i3SEtQVX+71CYNv8maWNSOgnlCoNp9X78f/cKiA== } + resolution: {integrity: sha512-bW/Yp/9dod6fmyR+XqSUL1N5JE7QRxQ3KrBIbYS1FTv32e5i3SEtQVX+71CYNv8maWNSOgnlCoNp9X78f/cKiA==} lines-and-columns@1.2.4: - resolution: { integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg== } + resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==} locate-path@5.0.0: - resolution: { integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g== } - engines: { node: '>=8' } + resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==} + engines: {node: '>=8'} lodash.memoize@4.1.2: - resolution: { integrity: sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag== } + resolution: {integrity: sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==} lodash@4.17.21: - resolution: { integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg== } + resolution: {integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==} lru-cache@10.4.3: - resolution: { integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ== } + resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==} lru-cache@11.0.2: - resolution: { integrity: sha512-123qHRfJBmo2jXDbo/a5YOQrJoHF/GNQTLzQ5+IdK5pWpceK17yRc6ozlWd25FxvGKQbIUs91fDFkXmDHTKcyA== } - engines: { node: 20 || >=22 } + resolution: {integrity: sha512-123qHRfJBmo2jXDbo/a5YOQrJoHF/GNQTLzQ5+IdK5pWpceK17yRc6ozlWd25FxvGKQbIUs91fDFkXmDHTKcyA==} + engines: {node: 20 || >=22} lru-cache@5.1.1: - resolution: { integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w== } + resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==} make-dir@4.0.0: - resolution: { integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw== } - engines: { node: '>=10' } + resolution: {integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==} + engines: {node: '>=10'} make-error@1.3.6: - resolution: { integrity: sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw== } + resolution: {integrity: sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==} makeerror@1.0.12: - resolution: { integrity: sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg== } + resolution: {integrity: sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg==} math-intrinsics@1.1.0: - resolution: { integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g== } - engines: { node: '>= 0.4' } + resolution: {integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==} + engines: {node: '>= 0.4'} media-typer@0.3.0: - resolution: { integrity: sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ== } - engines: { node: '>= 0.6' } + resolution: {integrity: sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==} + engines: {node: '>= 0.6'} merge-descriptors@1.0.3: - resolution: { integrity: sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ== } + resolution: {integrity: sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==} merge-stream@2.0.0: - resolution: { integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w== } + resolution: {integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==} methods@1.1.2: - resolution: { integrity: sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w== } - engines: { node: '>= 0.6' } + resolution: {integrity: sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==} + engines: {node: '>= 0.6'} micromatch@4.0.8: - resolution: { integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA== } - engines: { node: '>=8.6' } + resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==} + engines: {node: '>=8.6'} mime-db@1.52.0: - resolution: { integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg== } - engines: { node: '>= 0.6' } + resolution: {integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==} + engines: {node: '>= 0.6'} mime-types@2.1.35: - resolution: { integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw== } - engines: { node: '>= 0.6' } + resolution: {integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==} + engines: {node: '>= 0.6'} mime@1.6.0: - resolution: { integrity: sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg== } - engines: { node: '>=4' } + resolution: {integrity: sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==} + engines: {node: '>=4'} hasBin: true mime@2.6.0: - resolution: { integrity: sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg== } - engines: { node: '>=4.0.0' } + resolution: {integrity: sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg==} + engines: {node: '>=4.0.0'} hasBin: true mimic-fn@2.1.0: - resolution: { integrity: sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg== } - engines: { node: '>=6' } + resolution: {integrity: sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==} + engines: {node: '>=6'} mimic-response@3.1.0: - resolution: { integrity: sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ== } - engines: { node: '>=10' } + resolution: {integrity: sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==} + engines: {node: '>=10'} minimatch@10.0.1: - resolution: { integrity: sha512-ethXTt3SGGR+95gudmqJ1eNhRO7eGEGIgYA9vnPatK4/etz2MEVDno5GMCibdMTuBMyElzIlgxMna3K94XDIDQ== } - engines: { node: 20 || >=22 } + resolution: {integrity: sha512-ethXTt3SGGR+95gudmqJ1eNhRO7eGEGIgYA9vnPatK4/etz2MEVDno5GMCibdMTuBMyElzIlgxMna3K94XDIDQ==} + engines: {node: 20 || >=22} minimatch@3.1.2: - resolution: { integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw== } + resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==} minimatch@5.1.6: - resolution: { integrity: sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g== } - engines: { node: '>=10' } + resolution: {integrity: sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==} + engines: {node: '>=10'} minimatch@9.0.5: - resolution: { integrity: sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow== } - engines: { node: '>=16 || 14 >=14.17' } + resolution: {integrity: sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==} + engines: {node: '>=16 || 14 >=14.17'} minimist@1.2.8: - resolution: { integrity: sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA== } + resolution: {integrity: sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==} minipass@7.1.2: - resolution: { integrity: sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw== } - engines: { node: '>=16 || 14 >=14.17' } + resolution: {integrity: sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==} + engines: {node: '>=16 || 14 >=14.17'} mkdirp-classic@0.5.3: - resolution: { integrity: sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A== } + resolution: {integrity: sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==} mkdirp@0.5.6: - resolution: { integrity: sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw== } + resolution: {integrity: sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==} hasBin: true mkdirp@1.0.4: - resolution: { integrity: sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw== } - engines: { node: '>=10' } + resolution: {integrity: sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==} + engines: {node: '>=10'} hasBin: true ms@2.0.0: - resolution: { integrity: sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A== } + resolution: {integrity: sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==} ms@2.1.3: - resolution: { integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA== } + resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==} multer@1.4.5-lts.1: - resolution: { integrity: sha512-ywPWvcDMeH+z9gQq5qYHCCy+ethsk4goepZ45GLD63fOu0YcNecQxi64nDs3qluZB+murG3/D4dJ7+dGctcCQQ== } - engines: { node: '>= 6.0.0' } + resolution: {integrity: sha512-ywPWvcDMeH+z9gQq5qYHCCy+ethsk4goepZ45GLD63fOu0YcNecQxi64nDs3qluZB+murG3/D4dJ7+dGctcCQQ==} + engines: {node: '>= 6.0.0'} nan@2.22.1: - resolution: { integrity: sha512-pfRR4ZcNTSm2ZFHaztuvbICf+hyiG6ecA06SfAxoPmuHjvMu0KUIae7Y8GyVkbBqeEIidsmXeYooWIX9+qjfRQ== } + resolution: {integrity: sha512-pfRR4ZcNTSm2ZFHaztuvbICf+hyiG6ecA06SfAxoPmuHjvMu0KUIae7Y8GyVkbBqeEIidsmXeYooWIX9+qjfRQ==} nanoid@3.3.6: - resolution: { integrity: sha512-BGcqMMJuToF7i1rt+2PWSNVnWIkGCU78jBG3RxO/bZlnZPK2Cmi2QaffxGO/2RvWi9sL+FAiRiXMgsyxQ1DIDA== } - engines: { node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1 } + resolution: {integrity: sha512-BGcqMMJuToF7i1rt+2PWSNVnWIkGCU78jBG3RxO/bZlnZPK2Cmi2QaffxGO/2RvWi9sL+FAiRiXMgsyxQ1DIDA==} + engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1} hasBin: true napi-build-utils@2.0.0: - resolution: { integrity: sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA== } + resolution: {integrity: sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA==} natural-compare@1.4.0: - resolution: { integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw== } + resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==} negotiator@0.6.3: - resolution: { integrity: sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg== } - engines: { node: '>= 0.6' } + resolution: {integrity: sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==} + engines: {node: '>= 0.6'} node-abi@3.74.0: - resolution: { integrity: sha512-c5XK0MjkGBrQPGYG24GBADZud0NCbznxNx0ZkS+ebUTrmV1qTDxPxSL8zEAPURXSbLRWVexxmP4986BziahL5w== } - engines: { node: '>=10' } + resolution: {integrity: sha512-c5XK0MjkGBrQPGYG24GBADZud0NCbznxNx0ZkS+ebUTrmV1qTDxPxSL8zEAPURXSbLRWVexxmP4986BziahL5w==} + engines: {node: '>=10'} node-fetch@2.7.0: - resolution: { integrity: sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A== } - engines: { node: 4.x || >=6.0.0 } + resolution: {integrity: sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==} + engines: {node: 4.x || >=6.0.0} peerDependencies: encoding: ^0.1.0 peerDependenciesMeta: @@ -2237,140 +2242,140 @@ packages: optional: true node-int64@0.4.0: - resolution: { integrity: sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw== } + resolution: {integrity: sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw==} node-releases@2.0.19: - resolution: { integrity: sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw== } + resolution: {integrity: sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw==} normalize-path@3.0.0: - resolution: { integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA== } - engines: { node: '>=0.10.0' } + resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==} + engines: {node: '>=0.10.0'} npm-run-path@4.0.1: - resolution: { integrity: sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw== } - engines: { node: '>=8' } + resolution: {integrity: sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==} + engines: {node: '>=8'} object-assign@4.1.1: - resolution: { integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg== } - engines: { node: '>=0.10.0' } + resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==} + engines: {node: '>=0.10.0'} object-inspect@1.13.3: - resolution: { integrity: sha512-kDCGIbxkDSXE3euJZZXzc6to7fCrKHNI/hSRQnRuQ+BWjFNzZwiFF8fj/6o2t2G9/jTj8PSIYTfCLelLZEeRpA== } - engines: { node: '>= 0.4' } + resolution: {integrity: sha512-kDCGIbxkDSXE3euJZZXzc6to7fCrKHNI/hSRQnRuQ+BWjFNzZwiFF8fj/6o2t2G9/jTj8PSIYTfCLelLZEeRpA==} + engines: {node: '>= 0.4'} obuf@1.1.2: - resolution: { integrity: sha512-PX1wu0AmAdPqOL1mWhqmlOd8kOIZQwGZw6rh7uby9fTc5lhaOWFLX3I6R1hrF9k3zUY40e6igsLGkDXK92LJNg== } + resolution: {integrity: sha512-PX1wu0AmAdPqOL1mWhqmlOd8kOIZQwGZw6rh7uby9fTc5lhaOWFLX3I6R1hrF9k3zUY40e6igsLGkDXK92LJNg==} on-finished@2.4.1: - resolution: { integrity: sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg== } - engines: { node: '>= 0.8' } + resolution: {integrity: sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==} + engines: {node: '>= 0.8'} on-headers@1.0.2: - resolution: { integrity: sha512-pZAE+FJLoyITytdqK0U5s+FIpjN0JP3OzFi/u8Rx+EV5/W+JTWGXG8xFzevE7AjBfDqHv/8vL8qQsIhHnqRkrA== } - engines: { node: '>= 0.8' } + resolution: {integrity: sha512-pZAE+FJLoyITytdqK0U5s+FIpjN0JP3OzFi/u8Rx+EV5/W+JTWGXG8xFzevE7AjBfDqHv/8vL8qQsIhHnqRkrA==} + engines: {node: '>= 0.8'} once@1.4.0: - resolution: { integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w== } + resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==} onetime@5.1.2: - resolution: { integrity: sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg== } - engines: { node: '>=6' } + resolution: {integrity: sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==} + engines: {node: '>=6'} only@0.0.2: - resolution: { integrity: sha512-Fvw+Jemq5fjjyWz6CpKx6w9s7xxqo3+JCyM0WXWeCSOboZ8ABkyvP8ID4CZuChA/wxSx+XSJmdOm8rGVyJ1hdQ== } + resolution: {integrity: sha512-Fvw+Jemq5fjjyWz6CpKx6w9s7xxqo3+JCyM0WXWeCSOboZ8ABkyvP8ID4CZuChA/wxSx+XSJmdOm8rGVyJ1hdQ==} p-limit@2.3.0: - resolution: { integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w== } - engines: { node: '>=6' } + resolution: {integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==} + engines: {node: '>=6'} p-limit@3.1.0: - resolution: { integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ== } - engines: { node: '>=10' } + resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==} + engines: {node: '>=10'} p-locate@4.1.0: - resolution: { integrity: sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A== } - engines: { node: '>=8' } + resolution: {integrity: sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==} + engines: {node: '>=8'} p-try@2.2.0: - resolution: { integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ== } - engines: { node: '>=6' } + resolution: {integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==} + engines: {node: '>=6'} package-json-from-dist@1.0.1: - resolution: { integrity: sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw== } + resolution: {integrity: sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==} parse-json@5.2.0: - resolution: { integrity: sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg== } - engines: { node: '>=8' } + resolution: {integrity: sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==} + engines: {node: '>=8'} parseurl@1.3.3: - resolution: { integrity: sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ== } - engines: { node: '>= 0.8' } + resolution: {integrity: sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==} + engines: {node: '>= 0.8'} path-exists@4.0.0: - resolution: { integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w== } - engines: { node: '>=8' } + resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==} + engines: {node: '>=8'} path-is-absolute@1.0.1: - resolution: { integrity: sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg== } - engines: { node: '>=0.10.0' } + resolution: {integrity: sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==} + engines: {node: '>=0.10.0'} path-key@3.1.1: - resolution: { integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q== } - engines: { node: '>=8' } + resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==} + engines: {node: '>=8'} path-parse@1.0.7: - resolution: { integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw== } + resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==} path-scurry@1.11.1: - resolution: { integrity: sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA== } - engines: { node: '>=16 || 14 >=14.18' } + resolution: {integrity: sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==} + engines: {node: '>=16 || 14 >=14.18'} path-scurry@2.0.0: - resolution: { integrity: sha512-ypGJsmGtdXUOeM5u93TyeIEfEhM6s+ljAhrk5vAvSx8uyY/02OvrZnA0YNGUrPXfpJMgI1ODd3nwz8Npx4O4cg== } - engines: { node: 20 || >=22 } + resolution: {integrity: sha512-ypGJsmGtdXUOeM5u93TyeIEfEhM6s+ljAhrk5vAvSx8uyY/02OvrZnA0YNGUrPXfpJMgI1ODd3nwz8Npx4O4cg==} + engines: {node: 20 || >=22} path-to-regexp@0.1.12: - resolution: { integrity: sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ== } + resolution: {integrity: sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==} path-to-regexp@6.3.0: - resolution: { integrity: sha512-Yhpw4T9C6hPpgPeA28us07OJeqZ5EzQTkbfwuhsUg0c237RomFoETJgmp2sa3F/41gfLE6G5cqcYwznmeEeOlQ== } + resolution: {integrity: sha512-Yhpw4T9C6hPpgPeA28us07OJeqZ5EzQTkbfwuhsUg0c237RomFoETJgmp2sa3F/41gfLE6G5cqcYwznmeEeOlQ==} pg-cloudflare@1.1.1: - resolution: { integrity: sha512-xWPagP/4B6BgFO+EKz3JONXv3YDgvkbVrGw2mTo3D6tVDQRh1e7cqVGvyR3BE+eQgAvx1XhW/iEASj4/jCWl3Q== } + resolution: {integrity: sha512-xWPagP/4B6BgFO+EKz3JONXv3YDgvkbVrGw2mTo3D6tVDQRh1e7cqVGvyR3BE+eQgAvx1XhW/iEASj4/jCWl3Q==} pg-connection-string@2.7.0: - resolution: { integrity: sha512-PI2W9mv53rXJQEOb8xNR8lH7Hr+EKa6oJa38zsK0S/ky2er16ios1wLKhZyxzD7jUReiWokc9WK5nxSnC7W1TA== } + resolution: {integrity: sha512-PI2W9mv53rXJQEOb8xNR8lH7Hr+EKa6oJa38zsK0S/ky2er16ios1wLKhZyxzD7jUReiWokc9WK5nxSnC7W1TA==} pg-int8@1.0.1: - resolution: { integrity: sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw== } - engines: { node: '>=4.0.0' } + resolution: {integrity: sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw==} + engines: {node: '>=4.0.0'} pg-numeric@1.0.2: - resolution: { integrity: sha512-BM/Thnrw5jm2kKLE5uJkXqqExRUY/toLHda65XgFTBTFYZyopbKjBe29Ii3RbkvlsMoFwD+tHeGaCjjv0gHlyw== } - engines: { node: '>=4' } + resolution: {integrity: sha512-BM/Thnrw5jm2kKLE5uJkXqqExRUY/toLHda65XgFTBTFYZyopbKjBe29Ii3RbkvlsMoFwD+tHeGaCjjv0gHlyw==} + engines: {node: '>=4'} pg-pool@3.8.0: - resolution: { integrity: sha512-VBw3jiVm6ZOdLBTIcXLNdSotb6Iy3uOCwDGFAksZCXmi10nyRvnP2v3jl4d+IsLYRyXf6o9hIm/ZtUzlByNUdw== } + resolution: {integrity: sha512-VBw3jiVm6ZOdLBTIcXLNdSotb6Iy3uOCwDGFAksZCXmi10nyRvnP2v3jl4d+IsLYRyXf6o9hIm/ZtUzlByNUdw==} peerDependencies: pg: '>=8.0' pg-protocol@1.7.0: - resolution: { integrity: sha512-hTK/mE36i8fDDhgDFjy6xNOG+LCorxLG3WO17tku+ij6sVHXh1jQUJ8hYAnRhNla4QVD2H8er/FOjc/+EgC6yQ== } + resolution: {integrity: sha512-hTK/mE36i8fDDhgDFjy6xNOG+LCorxLG3WO17tku+ij6sVHXh1jQUJ8hYAnRhNla4QVD2H8er/FOjc/+EgC6yQ==} pg-protocol@1.8.0: - resolution: { integrity: sha512-jvuYlEkL03NRvOoyoRktBK7+qU5kOvlAwvmrH8sr3wbLrOdVWsRxQfz8mMy9sZFsqJ1hEWNfdWKI4SAmoL+j7g== } + resolution: {integrity: sha512-jvuYlEkL03NRvOoyoRktBK7+qU5kOvlAwvmrH8sr3wbLrOdVWsRxQfz8mMy9sZFsqJ1hEWNfdWKI4SAmoL+j7g==} pg-types@2.2.0: - resolution: { integrity: sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA== } - engines: { node: '>=4' } + resolution: {integrity: sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA==} + engines: {node: '>=4'} pg-types@4.0.2: - resolution: { integrity: sha512-cRL3JpS3lKMGsKaWndugWQoLOCoP+Cic8oseVcbr0qhPzYD5DWXK+RZ9LY9wxRf7RQia4SCwQlXk0q6FCPrVng== } - engines: { node: '>=10' } + resolution: {integrity: sha512-cRL3JpS3lKMGsKaWndugWQoLOCoP+Cic8oseVcbr0qhPzYD5DWXK+RZ9LY9wxRf7RQia4SCwQlXk0q6FCPrVng==} + engines: {node: '>=10'} pg@8.14.0: - resolution: { integrity: sha512-nXbVpyoaXVmdqlKEzToFf37qzyeeh7mbiXsnoWvstSqohj88yaa/I/Rq/HEVn2QPSZEuLIJa/jSpRDyzjEx4FQ== } - engines: { node: '>= 8.0.0' } + resolution: {integrity: sha512-nXbVpyoaXVmdqlKEzToFf37qzyeeh7mbiXsnoWvstSqohj88yaa/I/Rq/HEVn2QPSZEuLIJa/jSpRDyzjEx4FQ==} + engines: {node: '>= 8.0.0'} peerDependencies: pg-native: '>=3.0.1' peerDependenciesMeta: @@ -2378,443 +2383,448 @@ packages: optional: true pgpass@1.0.5: - resolution: { integrity: sha512-FdW9r/jQZhSeohs1Z3sI1yxFQNFvMcnmfuj4WBMUTxOrAyLMaTcE1aAMBiTlbMNaXvBCQuVi0R7hd8udDSP7ug== } + resolution: {integrity: sha512-FdW9r/jQZhSeohs1Z3sI1yxFQNFvMcnmfuj4WBMUTxOrAyLMaTcE1aAMBiTlbMNaXvBCQuVi0R7hd8udDSP7ug==} picocolors@1.1.1: - resolution: { integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA== } + resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==} picomatch@2.3.1: - resolution: { integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA== } - engines: { node: '>=8.6' } + resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==} + engines: {node: '>=8.6'} pirates@4.0.6: - resolution: { integrity: sha512-saLsH7WeYYPiD25LDuLRRY/i+6HaPYr6G1OUlN39otzkSTxKnubR9RTxS3/Kk50s1g2JTgFwWQDQyplC5/SHZg== } - engines: { node: '>= 6' } + resolution: {integrity: sha512-saLsH7WeYYPiD25LDuLRRY/i+6HaPYr6G1OUlN39otzkSTxKnubR9RTxS3/Kk50s1g2JTgFwWQDQyplC5/SHZg==} + engines: {node: '>= 6'} pkg-dir@4.2.0: - resolution: { integrity: sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ== } - engines: { node: '>=8' } + resolution: {integrity: sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==} + engines: {node: '>=8'} postgres-array@2.0.0: - resolution: { integrity: sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA== } - engines: { node: '>=4' } + resolution: {integrity: sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA==} + engines: {node: '>=4'} postgres-array@3.0.2: - resolution: { integrity: sha512-6faShkdFugNQCLwucjPcY5ARoW1SlbnrZjmGl0IrrqewpvxvhSLHimCVzqeuULCbG0fQv7Dtk1yDbG3xv7Veog== } - engines: { node: '>=12' } + resolution: {integrity: sha512-6faShkdFugNQCLwucjPcY5ARoW1SlbnrZjmGl0IrrqewpvxvhSLHimCVzqeuULCbG0fQv7Dtk1yDbG3xv7Veog==} + engines: {node: '>=12'} postgres-bytea@1.0.0: - resolution: { integrity: sha512-xy3pmLuQqRBZBXDULy7KbaitYqLcmxigw14Q5sj8QBVLqEwXfeybIKVWiqAXTlcvdvb0+xkOtDbfQMOf4lST1w== } - engines: { node: '>=0.10.0' } + resolution: {integrity: sha512-xy3pmLuQqRBZBXDULy7KbaitYqLcmxigw14Q5sj8QBVLqEwXfeybIKVWiqAXTlcvdvb0+xkOtDbfQMOf4lST1w==} + engines: {node: '>=0.10.0'} postgres-bytea@3.0.0: - resolution: { integrity: sha512-CNd4jim9RFPkObHSjVHlVrxoVQXz7quwNFpz7RY1okNNme49+sVyiTvTRobiLV548Hx/hb1BG+iE7h9493WzFw== } - engines: { node: '>= 6' } + resolution: {integrity: sha512-CNd4jim9RFPkObHSjVHlVrxoVQXz7quwNFpz7RY1okNNme49+sVyiTvTRobiLV548Hx/hb1BG+iE7h9493WzFw==} + engines: {node: '>= 6'} postgres-date@1.0.7: - resolution: { integrity: sha512-suDmjLVQg78nMK2UZ454hAG+OAW+HQPZ6n++TNDUX+L0+uUlLywnoxJKDou51Zm+zTCjrCl0Nq6J9C5hP9vK/Q== } - engines: { node: '>=0.10.0' } + resolution: {integrity: sha512-suDmjLVQg78nMK2UZ454hAG+OAW+HQPZ6n++TNDUX+L0+uUlLywnoxJKDou51Zm+zTCjrCl0Nq6J9C5hP9vK/Q==} + engines: {node: '>=0.10.0'} postgres-date@2.1.0: - resolution: { integrity: sha512-K7Juri8gtgXVcDfZttFKVmhglp7epKb1K4pgrkLxehjqkrgPhfG6OO8LHLkfaqkbpjNRnra018XwAr1yQFWGcA== } - engines: { node: '>=12' } + resolution: {integrity: sha512-K7Juri8gtgXVcDfZttFKVmhglp7epKb1K4pgrkLxehjqkrgPhfG6OO8LHLkfaqkbpjNRnra018XwAr1yQFWGcA==} + engines: {node: '>=12'} postgres-interval@1.2.0: - resolution: { integrity: sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ== } - engines: { node: '>=0.10.0' } + resolution: {integrity: sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ==} + engines: {node: '>=0.10.0'} postgres-interval@3.0.0: - resolution: { integrity: sha512-BSNDnbyZCXSxgA+1f5UU2GmwhoI0aU5yMxRGO8CdFEcY2BQF9xm/7MqKnYoM1nJDk8nONNWDk9WeSmePFhQdlw== } - engines: { node: '>=12' } + resolution: {integrity: sha512-BSNDnbyZCXSxgA+1f5UU2GmwhoI0aU5yMxRGO8CdFEcY2BQF9xm/7MqKnYoM1nJDk8nONNWDk9WeSmePFhQdlw==} + engines: {node: '>=12'} postgres-range@1.1.4: - resolution: { integrity: sha512-i/hbxIE9803Alj/6ytL7UHQxRvZkI9O4Sy+J3HGc4F4oo/2eQAjTSNJ0bfxyse3bH0nuVesCk+3IRLaMtG3H6w== } + resolution: {integrity: sha512-i/hbxIE9803Alj/6ytL7UHQxRvZkI9O4Sy+J3HGc4F4oo/2eQAjTSNJ0bfxyse3bH0nuVesCk+3IRLaMtG3H6w==} postgres@3.4.5: - resolution: { integrity: sha512-cDWgoah1Gez9rN3H4165peY9qfpEo+SA61oQv65O3cRUE1pOEoJWwddwcqKE8XZYjbblOJlYDlLV4h67HrEVDg== } - engines: { node: '>=12' } + resolution: {integrity: sha512-cDWgoah1Gez9rN3H4165peY9qfpEo+SA61oQv65O3cRUE1pOEoJWwddwcqKE8XZYjbblOJlYDlLV4h67HrEVDg==} + engines: {node: '>=12'} prebuild-install@7.1.3: - resolution: { integrity: sha512-8Mf2cbV7x1cXPUILADGI3wuhfqWvtiLA1iclTDbFRZkgRQS0NqsPZphna9V+HyTEadheuPmjaJMsbzKQFOzLug== } - engines: { node: '>=10' } + resolution: {integrity: sha512-8Mf2cbV7x1cXPUILADGI3wuhfqWvtiLA1iclTDbFRZkgRQS0NqsPZphna9V+HyTEadheuPmjaJMsbzKQFOzLug==} + engines: {node: '>=10'} hasBin: true prettier@3.4.2: - resolution: { integrity: sha512-e9MewbtFo+Fevyuxn/4rrcDAaq0IYxPGLvObpQjiZBMAzB9IGmzlnG9RZy3FFas+eBMu2vA0CszMeduow5dIuQ== } - engines: { node: '>=14' } + resolution: {integrity: sha512-e9MewbtFo+Fevyuxn/4rrcDAaq0IYxPGLvObpQjiZBMAzB9IGmzlnG9RZy3FFas+eBMu2vA0CszMeduow5dIuQ==} + engines: {node: '>=14'} hasBin: true pretty-format@29.7.0: - resolution: { integrity: sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ== } - engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 } + resolution: {integrity: sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} process-nextick-args@2.0.1: - resolution: { integrity: sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag== } + resolution: {integrity: sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==} process@0.11.10: - resolution: { integrity: sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A== } - engines: { node: '>= 0.6.0' } + resolution: {integrity: sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A==} + engines: {node: '>= 0.6.0'} promise-polyfill@8.3.0: - resolution: { integrity: sha512-H5oELycFml5yto/atYqmjyigJoAo3+OXwolYiH7OfQuYlAqhxNvTfiNMbV9hsC6Yp83yE5r2KTVmtrG6R9i6Pg== } + resolution: {integrity: sha512-H5oELycFml5yto/atYqmjyigJoAo3+OXwolYiH7OfQuYlAqhxNvTfiNMbV9hsC6Yp83yE5r2KTVmtrG6R9i6Pg==} prompts@2.4.2: - resolution: { integrity: sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q== } - engines: { node: '>= 6' } + resolution: {integrity: sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==} + engines: {node: '>= 6'} proper-lockfile@4.1.2: - resolution: { integrity: sha512-TjNPblN4BwAWMXU8s9AEz4JmQxnD1NNL7bNOY/AKUzyamc379FWASUhc/K1pL2noVb+XmZKLL68cjzLsiOAMaA== } + resolution: {integrity: sha512-TjNPblN4BwAWMXU8s9AEz4JmQxnD1NNL7bNOY/AKUzyamc379FWASUhc/K1pL2noVb+XmZKLL68cjzLsiOAMaA==} properties-reader@2.3.0: - resolution: { integrity: sha512-z597WicA7nDZxK12kZqHr2TcvwNU1GCfA5UwfDY/HDp3hXPoPlb5rlEx9bwGTiJnc0OqbBTkU975jDToth8Gxw== } - engines: { node: '>=14' } + resolution: {integrity: sha512-z597WicA7nDZxK12kZqHr2TcvwNU1GCfA5UwfDY/HDp3hXPoPlb5rlEx9bwGTiJnc0OqbBTkU975jDToth8Gxw==} + engines: {node: '>=14'} proxy-addr@2.0.7: - resolution: { integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg== } - engines: { node: '>= 0.10' } + resolution: {integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==} + engines: {node: '>= 0.10'} pump@3.0.2: - resolution: { integrity: sha512-tUPXtzlGM8FE3P0ZL6DVs/3P58k9nk8/jZeQCurTJylQA8qFYzHFfhBJkuqyE0FifOsQ0uKWekiZ5g8wtr28cw== } + resolution: {integrity: sha512-tUPXtzlGM8FE3P0ZL6DVs/3P58k9nk8/jZeQCurTJylQA8qFYzHFfhBJkuqyE0FifOsQ0uKWekiZ5g8wtr28cw==} pure-rand@6.1.0: - resolution: { integrity: sha512-bVWawvoZoBYpp6yIoQtQXHZjmz35RSVHnUOTefl8Vcjr8snTPY1wnpSPMWekcFwbxI6gtmT7rSYPFvz71ldiOA== } + resolution: {integrity: sha512-bVWawvoZoBYpp6yIoQtQXHZjmz35RSVHnUOTefl8Vcjr8snTPY1wnpSPMWekcFwbxI6gtmT7rSYPFvz71ldiOA==} qs@6.13.0: - resolution: { integrity: sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg== } - engines: { node: '>=0.6' } + resolution: {integrity: sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==} + engines: {node: '>=0.6'} random-bytes@1.0.0: - resolution: { integrity: sha512-iv7LhNVO047HzYR3InF6pUcUsPQiHTM1Qal51DcGSuZFBil1aBBWG5eHPNek7bvILMaYJ/8RU1e8w1AMdHmLQQ== } - engines: { node: '>= 0.8' } + resolution: {integrity: sha512-iv7LhNVO047HzYR3InF6pUcUsPQiHTM1Qal51DcGSuZFBil1aBBWG5eHPNek7bvILMaYJ/8RU1e8w1AMdHmLQQ==} + engines: {node: '>= 0.8'} range-parser@1.2.1: - resolution: { integrity: sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg== } - engines: { node: '>= 0.6' } + resolution: {integrity: sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==} + engines: {node: '>= 0.6'} raw-body@2.5.2: - resolution: { integrity: sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA== } - engines: { node: '>= 0.8' } + resolution: {integrity: sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==} + engines: {node: '>= 0.8'} rc@1.2.8: - resolution: { integrity: sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw== } + resolution: {integrity: sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==} hasBin: true react-is@18.3.1: - resolution: { integrity: sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg== } + resolution: {integrity: sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==} readable-stream@2.3.8: - resolution: { integrity: sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA== } + resolution: {integrity: sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==} readable-stream@3.6.2: - resolution: { integrity: sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA== } - engines: { node: '>= 6' } + resolution: {integrity: sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==} + engines: {node: '>= 6'} readable-stream@4.7.0: - resolution: { integrity: sha512-oIGGmcpTLwPga8Bn6/Z75SVaH1z5dUut2ibSyAMVhmUggWpmDn2dapB0n7f8nwaSiRtepAsfJyfXIO5DCVAODg== } - engines: { node: ^12.22.0 || ^14.17.0 || >=16.0.0 } + resolution: {integrity: sha512-oIGGmcpTLwPga8Bn6/Z75SVaH1z5dUut2ibSyAMVhmUggWpmDn2dapB0n7f8nwaSiRtepAsfJyfXIO5DCVAODg==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} readdir-glob@1.1.3: - resolution: { integrity: sha512-v05I2k7xN8zXvPD9N+z/uhXPaj0sUFCe2rcWZIpBsqxfP7xXFQ0tipAd/wjj1YxWyWtUS5IDJpOG82JKt2EAVA== } + resolution: {integrity: sha512-v05I2k7xN8zXvPD9N+z/uhXPaj0sUFCe2rcWZIpBsqxfP7xXFQ0tipAd/wjj1YxWyWtUS5IDJpOG82JKt2EAVA==} readdirp@3.6.0: - resolution: { integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA== } - engines: { node: '>=8.10.0' } + resolution: {integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==} + engines: {node: '>=8.10.0'} reflect-metadata@0.2.2: - resolution: { integrity: sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q== } + resolution: {integrity: sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==} require-directory@2.1.1: - resolution: { integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q== } - engines: { node: '>=0.10.0' } + resolution: {integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==} + engines: {node: '>=0.10.0'} resolve-cwd@3.0.0: - resolution: { integrity: sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg== } - engines: { node: '>=8' } + resolution: {integrity: sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==} + engines: {node: '>=8'} resolve-from@5.0.0: - resolution: { integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw== } - engines: { node: '>=8' } + resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==} + engines: {node: '>=8'} resolve-pkg-maps@1.0.0: - resolution: { integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw== } + resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==} resolve.exports@2.0.3: - resolution: { integrity: sha512-OcXjMsGdhL4XnbShKpAcSqPMzQoYkYyhbEaeSko47MjRP9NfEQMhZkXL1DoFlt9LWQn4YttrdnV6X2OiyzBi+A== } - engines: { node: '>=10' } + resolution: {integrity: sha512-OcXjMsGdhL4XnbShKpAcSqPMzQoYkYyhbEaeSko47MjRP9NfEQMhZkXL1DoFlt9LWQn4YttrdnV6X2OiyzBi+A==} + engines: {node: '>=10'} resolve@1.22.10: - resolution: { integrity: sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w== } - engines: { node: '>= 0.4' } + resolution: {integrity: sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w==} + engines: {node: '>= 0.4'} hasBin: true retry@0.12.0: - resolution: { integrity: sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow== } - engines: { node: '>= 4' } + resolution: {integrity: sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==} + engines: {node: '>= 4'} rhea-promise@3.0.3: - resolution: { integrity: sha512-a875P5YcMkePSTEWMsnmCQS7Y4v/XvIw7ZoMtJxqtQRZsqSA6PsZxuz4vktyRykPuUgdNsA6F84dS3iEXZoYnQ== } + resolution: {integrity: sha512-a875P5YcMkePSTEWMsnmCQS7Y4v/XvIw7ZoMtJxqtQRZsqSA6PsZxuz4vktyRykPuUgdNsA6F84dS3iEXZoYnQ==} rhea@3.0.3: - resolution: { integrity: sha512-Y7se0USZQu6dErWSZ7eCmSVTMscyVfz/0+jjhBF7f9PqYfEXdIoQpPkC9Strks6wF9WytuBhn8w8Nz/tmBWpgA== } + resolution: {integrity: sha512-Y7se0USZQu6dErWSZ7eCmSVTMscyVfz/0+jjhBF7f9PqYfEXdIoQpPkC9Strks6wF9WytuBhn8w8Nz/tmBWpgA==} rimraf@2.7.1: - resolution: { integrity: sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w== } + resolution: {integrity: sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==} deprecated: Rimraf versions prior to v4 are no longer supported hasBin: true + rimraf@6.0.1: + resolution: {integrity: sha512-9dkvaxAsk/xNXSJzMgFqqMCuFgt2+KsOFek3TMLfo8NCPfWpBmqwyNn5Y+NX56QUYfCtsyhF3ayiboEoUmJk/A==} + engines: {node: 20 || >=22} + hasBin: true + routing-controllers@0.11.1: - resolution: { integrity: sha512-IGHHR+SpLsmDLUpYmGCwAwg1d6bobugNLlBfljnWnXEwQJhx1FGHOc93aQrErixkT3GiNxkgkVlZeFBXYcZ0LA== } + resolution: {integrity: sha512-IGHHR+SpLsmDLUpYmGCwAwg1d6bobugNLlBfljnWnXEwQJhx1FGHOc93aQrErixkT3GiNxkgkVlZeFBXYcZ0LA==} peerDependencies: class-transformer: ^0.5.1 class-validator: ^0.14.1 safe-buffer@5.1.2: - resolution: { integrity: sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g== } + resolution: {integrity: sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==} safe-buffer@5.2.1: - resolution: { integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ== } + resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==} safe-regex-test@1.1.0: - resolution: { integrity: sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw== } - engines: { node: '>= 0.4' } + resolution: {integrity: sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==} + engines: {node: '>= 0.4'} safer-buffer@2.1.2: - resolution: { integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg== } + resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==} semver@6.3.1: - resolution: { integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA== } + resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==} hasBin: true semver@7.7.1: - resolution: { integrity: sha512-hlq8tAfn0m/61p4BVRcPzIGr6LKiMwo4VM6dGi6pt4qcRkmNzTcWq6eCEjEh+qXjkMDvPlOFFSGwQjoEa6gyMA== } - engines: { node: '>=10' } + resolution: {integrity: sha512-hlq8tAfn0m/61p4BVRcPzIGr6LKiMwo4VM6dGi6pt4qcRkmNzTcWq6eCEjEh+qXjkMDvPlOFFSGwQjoEa6gyMA==} + engines: {node: '>=10'} hasBin: true send@0.19.0: - resolution: { integrity: sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw== } - engines: { node: '>= 0.8.0' } + resolution: {integrity: sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==} + engines: {node: '>= 0.8.0'} serve-static@1.16.2: - resolution: { integrity: sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw== } - engines: { node: '>= 0.8.0' } + resolution: {integrity: sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==} + engines: {node: '>= 0.8.0'} setprototypeof@1.2.0: - resolution: { integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw== } + resolution: {integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==} shebang-command@2.0.0: - resolution: { integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA== } - engines: { node: '>=8' } + resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==} + engines: {node: '>=8'} shebang-regex@3.0.0: - resolution: { integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A== } - engines: { node: '>=8' } + resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==} + engines: {node: '>=8'} side-channel-list@1.0.0: - resolution: { integrity: sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA== } - engines: { node: '>= 0.4' } + resolution: {integrity: sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==} + engines: {node: '>= 0.4'} side-channel-map@1.0.1: - resolution: { integrity: sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA== } - engines: { node: '>= 0.4' } + resolution: {integrity: sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==} + engines: {node: '>= 0.4'} side-channel-weakmap@1.0.2: - resolution: { integrity: sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A== } - engines: { node: '>= 0.4' } + resolution: {integrity: sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==} + engines: {node: '>= 0.4'} side-channel@1.1.0: - resolution: { integrity: sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw== } - engines: { node: '>= 0.4' } + resolution: {integrity: sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==} + engines: {node: '>= 0.4'} signal-exit@3.0.7: - resolution: { integrity: sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ== } + resolution: {integrity: sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==} signal-exit@4.1.0: - resolution: { integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw== } - engines: { node: '>=14' } + resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==} + engines: {node: '>=14'} simple-concat@1.0.1: - resolution: { integrity: sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q== } + resolution: {integrity: sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==} simple-get@4.0.1: - resolution: { integrity: sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA== } + resolution: {integrity: sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA==} sisteransi@1.0.5: - resolution: { integrity: sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg== } + resolution: {integrity: sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==} slash@3.0.0: - resolution: { integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q== } - engines: { node: '>=8' } + resolution: {integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==} + engines: {node: '>=8'} slugify@1.6.6: - resolution: { integrity: sha512-h+z7HKHYXj6wJU+AnS/+IH8Uh9fdcX1Lrhg1/VMdf9PwoBQXFcXiAdsy2tSK0P6gKwJLXp02r90ahUCqHk9rrw== } - engines: { node: '>=8.0.0' } + resolution: {integrity: sha512-h+z7HKHYXj6wJU+AnS/+IH8Uh9fdcX1Lrhg1/VMdf9PwoBQXFcXiAdsy2tSK0P6gKwJLXp02r90ahUCqHk9rrw==} + engines: {node: '>=8.0.0'} source-map-support@0.5.13: - resolution: { integrity: sha512-SHSKFHadjVA5oR4PPqhtAVdcBWwRYVd6g6cAXnIbRiIwc2EhPrTuKUBdSLvlEKyIP3GCf89fltvcZiP9MMFA1w== } + resolution: {integrity: sha512-SHSKFHadjVA5oR4PPqhtAVdcBWwRYVd6g6cAXnIbRiIwc2EhPrTuKUBdSLvlEKyIP3GCf89fltvcZiP9MMFA1w==} source-map-support@0.5.21: - resolution: { integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w== } + resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==} source-map@0.6.1: - resolution: { integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g== } - engines: { node: '>=0.10.0' } + resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==} + engines: {node: '>=0.10.0'} split-ca@1.0.1: - resolution: { integrity: sha512-Q5thBSxp5t8WPTTJQS59LrGqOZqOsrhDGDVm8azCqIBjSBd7nd9o2PM+mDulQQkh8h//4U6hFZnc/mul8t5pWQ== } + resolution: {integrity: sha512-Q5thBSxp5t8WPTTJQS59LrGqOZqOsrhDGDVm8azCqIBjSBd7nd9o2PM+mDulQQkh8h//4U6hFZnc/mul8t5pWQ==} split2@4.2.0: - resolution: { integrity: sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg== } - engines: { node: '>= 10.x' } + resolution: {integrity: sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==} + engines: {node: '>= 10.x'} sprintf-js@1.0.3: - resolution: { integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g== } + resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==} ssh-remote-port-forward@1.0.4: - resolution: { integrity: sha512-x0LV1eVDwjf1gmG7TTnfqIzf+3VPRz7vrNIjX6oYLbeCrf/PeVY6hkT68Mg+q02qXxQhrLjB0jfgvhevoCRmLQ== } + resolution: {integrity: sha512-x0LV1eVDwjf1gmG7TTnfqIzf+3VPRz7vrNIjX6oYLbeCrf/PeVY6hkT68Mg+q02qXxQhrLjB0jfgvhevoCRmLQ==} ssh2@1.16.0: - resolution: { integrity: sha512-r1X4KsBGedJqo7h8F5c4Ybpcr5RjyP+aWIG007uBPRjmdQWfEiVLzSK71Zji1B9sKxwaCvD8y8cwSkYrlLiRRg== } - engines: { node: '>=10.16.0' } + resolution: {integrity: sha512-r1X4KsBGedJqo7h8F5c4Ybpcr5RjyP+aWIG007uBPRjmdQWfEiVLzSK71Zji1B9sKxwaCvD8y8cwSkYrlLiRRg==} + engines: {node: '>=10.16.0'} stack-utils@2.0.6: - resolution: { integrity: sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ== } - engines: { node: '>=10' } + resolution: {integrity: sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==} + engines: {node: '>=10'} statuses@1.5.0: - resolution: { integrity: sha512-OpZ3zP+jT1PI7I8nemJX4AKmAX070ZkYPVWV/AaKTJl+tXCTGyVdC1a4SL8RUQYEwk/f34ZX8UTykN68FwrqAA== } - engines: { node: '>= 0.6' } + resolution: {integrity: sha512-OpZ3zP+jT1PI7I8nemJX4AKmAX070ZkYPVWV/AaKTJl+tXCTGyVdC1a4SL8RUQYEwk/f34ZX8UTykN68FwrqAA==} + engines: {node: '>= 0.6'} statuses@2.0.1: - resolution: { integrity: sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ== } - engines: { node: '>= 0.8' } + resolution: {integrity: sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==} + engines: {node: '>= 0.8'} streamsearch@1.1.0: - resolution: { integrity: sha512-Mcc5wHehp9aXz1ax6bZUyY5afg9u2rv5cqQI3mRrYkGC8rW2hM02jWuwjtL++LS5qinSyhj2QfLyNsuc+VsExg== } - engines: { node: '>=10.0.0' } + resolution: {integrity: sha512-Mcc5wHehp9aXz1ax6bZUyY5afg9u2rv5cqQI3mRrYkGC8rW2hM02jWuwjtL++LS5qinSyhj2QfLyNsuc+VsExg==} + engines: {node: '>=10.0.0'} streamx@2.22.0: - resolution: { integrity: sha512-sLh1evHOzBy/iWRiR6d1zRcLao4gGZr3C1kzNz4fopCOKJb6xD9ub8Mpi9Mr1R6id5o43S+d93fI48UC5uM9aw== } + resolution: {integrity: sha512-sLh1evHOzBy/iWRiR6d1zRcLao4gGZr3C1kzNz4fopCOKJb6xD9ub8Mpi9Mr1R6id5o43S+d93fI48UC5uM9aw==} string-length@4.0.2: - resolution: { integrity: sha512-+l6rNN5fYHNhZZy41RXsYptCjA2Igmq4EG7kZAYFQI1E1VTXarr6ZPXBg6eq7Y6eK4FEhY6AJlyuFIb/v/S0VQ== } - engines: { node: '>=10' } + resolution: {integrity: sha512-+l6rNN5fYHNhZZy41RXsYptCjA2Igmq4EG7kZAYFQI1E1VTXarr6ZPXBg6eq7Y6eK4FEhY6AJlyuFIb/v/S0VQ==} + engines: {node: '>=10'} string-width@4.2.3: - resolution: { integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g== } - engines: { node: '>=8' } + resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==} + engines: {node: '>=8'} string-width@5.1.2: - resolution: { integrity: sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA== } - engines: { node: '>=12' } + resolution: {integrity: sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==} + engines: {node: '>=12'} string_decoder@1.1.1: - resolution: { integrity: sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg== } + resolution: {integrity: sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==} string_decoder@1.3.0: - resolution: { integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA== } + resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==} strip-ansi@6.0.1: - resolution: { integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A== } - engines: { node: '>=8' } + resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==} + engines: {node: '>=8'} strip-ansi@7.1.0: - resolution: { integrity: sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ== } - engines: { node: '>=12' } + resolution: {integrity: sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==} + engines: {node: '>=12'} strip-bom@3.0.0: - resolution: { integrity: sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA== } - engines: { node: '>=4' } + resolution: {integrity: sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==} + engines: {node: '>=4'} strip-bom@4.0.0: - resolution: { integrity: sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w== } - engines: { node: '>=8' } + resolution: {integrity: sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==} + engines: {node: '>=8'} strip-final-newline@2.0.0: - resolution: { integrity: sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA== } - engines: { node: '>=6' } + resolution: {integrity: sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==} + engines: {node: '>=6'} strip-json-comments@2.0.1: - resolution: { integrity: sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ== } - engines: { node: '>=0.10.0' } + resolution: {integrity: sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==} + engines: {node: '>=0.10.0'} strip-json-comments@3.1.1: - resolution: { integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig== } - engines: { node: '>=8' } + resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==} + engines: {node: '>=8'} superagent@9.0.2: - resolution: { integrity: sha512-xuW7dzkUpcJq7QnhOsnNUgtYp3xRwpt2F7abdRYIpCsAt0hhUqia0EdxyXZQQpNmGtsCzYHryaKSV3q3GJnq7w== } - engines: { node: '>=14.18.0' } + resolution: {integrity: sha512-xuW7dzkUpcJq7QnhOsnNUgtYp3xRwpt2F7abdRYIpCsAt0hhUqia0EdxyXZQQpNmGtsCzYHryaKSV3q3GJnq7w==} + engines: {node: '>=14.18.0'} supertest@7.0.0: - resolution: { integrity: sha512-qlsr7fIC0lSddmA3tzojvzubYxvlGtzumcdHgPwbFWMISQwL22MhM2Y3LNt+6w9Yyx7559VW5ab70dgphm8qQA== } - engines: { node: '>=14.18.0' } + resolution: {integrity: sha512-qlsr7fIC0lSddmA3tzojvzubYxvlGtzumcdHgPwbFWMISQwL22MhM2Y3LNt+6w9Yyx7559VW5ab70dgphm8qQA==} + engines: {node: '>=14.18.0'} supports-color@7.2.0: - resolution: { integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw== } - engines: { node: '>=8' } + resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==} + engines: {node: '>=8'} supports-color@8.1.1: - resolution: { integrity: sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q== } - engines: { node: '>=10' } + resolution: {integrity: sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==} + engines: {node: '>=10'} supports-preserve-symlinks-flag@1.0.0: - resolution: { integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w== } - engines: { node: '>= 0.4' } + resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==} + engines: {node: '>= 0.4'} tar-fs@2.0.1: - resolution: { integrity: sha512-6tzWDMeroL87uF/+lin46k+Q+46rAJ0SyPGz7OW7wTgblI273hsBqk2C1j0/xNadNLKDTUL9BukSjB7cwgmlPA== } + resolution: {integrity: sha512-6tzWDMeroL87uF/+lin46k+Q+46rAJ0SyPGz7OW7wTgblI273hsBqk2C1j0/xNadNLKDTUL9BukSjB7cwgmlPA==} tar-fs@2.1.2: - resolution: { integrity: sha512-EsaAXwxmx8UB7FRKqeozqEPop69DXcmYwTQwXvyAPF352HJsPdkVhvTaDPYqfNgruveJIJy3TA2l+2zj8LJIJA== } + resolution: {integrity: sha512-EsaAXwxmx8UB7FRKqeozqEPop69DXcmYwTQwXvyAPF352HJsPdkVhvTaDPYqfNgruveJIJy3TA2l+2zj8LJIJA==} tar-fs@3.0.8: - resolution: { integrity: sha512-ZoROL70jptorGAlgAYiLoBLItEKw/fUxg9BSYK/dF/GAGYFJOJJJMvjPAKDJraCXFwadD456FCuvLWgfhMsPwg== } + resolution: {integrity: sha512-ZoROL70jptorGAlgAYiLoBLItEKw/fUxg9BSYK/dF/GAGYFJOJJJMvjPAKDJraCXFwadD456FCuvLWgfhMsPwg==} tar-stream@2.2.0: - resolution: { integrity: sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ== } - engines: { node: '>=6' } + resolution: {integrity: sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==} + engines: {node: '>=6'} tar-stream@3.1.7: - resolution: { integrity: sha512-qJj60CXt7IU1Ffyc3NJMjh6EkuCFej46zUqJ4J7pqYlThyd9bO0XBTmcOIhSzZJVWfsLks0+nle/j538YAW9RQ== } + resolution: {integrity: sha512-qJj60CXt7IU1Ffyc3NJMjh6EkuCFej46zUqJ4J7pqYlThyd9bO0XBTmcOIhSzZJVWfsLks0+nle/j538YAW9RQ==} template-url@1.0.0: - resolution: { integrity: sha512-QUjZNE7yTdIzB91sITTSYcSX5GRF5FulKvIYCqV5350NfSNfiuuCYQIJZ5PIN7k/uJ+kpurEEv9hFqRRc+JilA== } + resolution: {integrity: sha512-QUjZNE7yTdIzB91sITTSYcSX5GRF5FulKvIYCqV5350NfSNfiuuCYQIJZ5PIN7k/uJ+kpurEEv9hFqRRc+JilA==} test-exclude@6.0.0: - resolution: { integrity: sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w== } - engines: { node: '>=8' } + resolution: {integrity: sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==} + engines: {node: '>=8'} testcontainers@10.18.0: - resolution: { integrity: sha512-MnwWsPjsN5QVe+lSU1LwLZVOyjgwSwv1INzkw8FekdwgvOtvJ7FThQEkbmzRcguQootgwmA9FG54NoTChZDRvA== } + resolution: {integrity: sha512-MnwWsPjsN5QVe+lSU1LwLZVOyjgwSwv1INzkw8FekdwgvOtvJ7FThQEkbmzRcguQootgwmA9FG54NoTChZDRvA==} text-decoder@1.2.3: - resolution: { integrity: sha512-3/o9z3X0X0fTupwsYvR03pJ/DjWuqqrfwBgTQzdWDiQSm9KitAyz/9WqsT2JQW7KV2m+bC2ol/zqpW37NHxLaA== } + resolution: {integrity: sha512-3/o9z3X0X0fTupwsYvR03pJ/DjWuqqrfwBgTQzdWDiQSm9KitAyz/9WqsT2JQW7KV2m+bC2ol/zqpW37NHxLaA==} tmp@0.2.3: - resolution: { integrity: sha512-nZD7m9iCPC5g0pYmcaxogYKggSfLsdxl8of3Q/oIbqCqLLIO9IAF0GWjX1z9NZRHPiXv8Wex4yDCaZsgEw0Y8w== } - engines: { node: '>=14.14' } + resolution: {integrity: sha512-nZD7m9iCPC5g0pYmcaxogYKggSfLsdxl8of3Q/oIbqCqLLIO9IAF0GWjX1z9NZRHPiXv8Wex4yDCaZsgEw0Y8w==} + engines: {node: '>=14.14'} tmpl@1.0.5: - resolution: { integrity: sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw== } + resolution: {integrity: sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw==} to-regex-range@5.0.1: - resolution: { integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ== } - engines: { node: '>=8.0' } + resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==} + engines: {node: '>=8.0'} toidentifier@1.0.1: - resolution: { integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA== } - engines: { node: '>=0.6' } + resolution: {integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==} + engines: {node: '>=0.6'} tr46@0.0.3: - resolution: { integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw== } + resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==} tree-kill@1.2.2: - resolution: { integrity: sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A== } + resolution: {integrity: sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==} hasBin: true ts-jest@29.2.5: - resolution: { integrity: sha512-KD8zB2aAZrcKIdGk4OwpJggeLcH1FgrICqDSROWqlnJXGCXK4Mn6FcdK2B6670Xr73lHMG1kHw8R87A0ecZ+vA== } - engines: { node: ^14.15.0 || ^16.10.0 || ^18.0.0 || >=20.0.0 } + resolution: {integrity: sha512-KD8zB2aAZrcKIdGk4OwpJggeLcH1FgrICqDSROWqlnJXGCXK4Mn6FcdK2B6670Xr73lHMG1kHw8R87A0ecZ+vA==} + engines: {node: ^14.15.0 || ^16.10.0 || ^18.0.0 || >=20.0.0} hasBin: true peerDependencies: '@babel/core': '>=7.0.0-beta.0 <8' @@ -2837,8 +2847,8 @@ packages: optional: true ts-node-dev@2.0.0: - resolution: { integrity: sha512-ywMrhCfH6M75yftYvrvNarLEY+SUXtUvU8/0Z6llrHQVBx12GiFk5sStF8UdfE/yfzk9IAq7O5EEbTQsxlBI8w== } - engines: { node: '>=0.8.0' } + resolution: {integrity: sha512-ywMrhCfH6M75yftYvrvNarLEY+SUXtUvU8/0Z6llrHQVBx12GiFk5sStF8UdfE/yfzk9IAq7O5EEbTQsxlBI8w==} + engines: {node: '>=0.8.0'} hasBin: true peerDependencies: node-notifier: '*' @@ -2848,7 +2858,7 @@ packages: optional: true ts-node@10.9.2: - resolution: { integrity: sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ== } + resolution: {integrity: sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==} hasBin: true peerDependencies: '@swc/core': '>=1.2.50' @@ -2862,197 +2872,198 @@ packages: optional: true tsconfig@7.0.0: - resolution: { integrity: sha512-vZXmzPrL+EmC4T/4rVlT2jNVMWCi/O4DIiSj3UHg1OE5kCKbk4mfrXc6dZksLgRM/TZlKnousKH9bbTazUWRRw== } + resolution: {integrity: sha512-vZXmzPrL+EmC4T/4rVlT2jNVMWCi/O4DIiSj3UHg1OE5kCKbk4mfrXc6dZksLgRM/TZlKnousKH9bbTazUWRRw==} tslib@2.8.1: - resolution: { integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w== } + resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==} tsscmp@1.0.6: - resolution: { integrity: sha512-LxhtAkPDTkVCMQjt2h6eBVY28KCjikZqZfMcC15YBeNjkgUpdCfBu5HoiOTDu86v6smE8yOjyEktJ8hlbANHQA== } - engines: { node: '>=0.6.x' } + resolution: {integrity: sha512-LxhtAkPDTkVCMQjt2h6eBVY28KCjikZqZfMcC15YBeNjkgUpdCfBu5HoiOTDu86v6smE8yOjyEktJ8hlbANHQA==} + engines: {node: '>=0.6.x'} tunnel-agent@0.6.0: - resolution: { integrity: sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w== } + resolution: {integrity: sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==} turbo-darwin-64@2.4.0: - resolution: { integrity: sha512-kVMScnPUa3R4n7woNmkR15kOY0aUwCLJcUyH5UC59ggKqr5HIHwweKYK8N1pwBQso0LQF4I9i93hIzfJguCcwQ== } + resolution: {integrity: sha512-kVMScnPUa3R4n7woNmkR15kOY0aUwCLJcUyH5UC59ggKqr5HIHwweKYK8N1pwBQso0LQF4I9i93hIzfJguCcwQ==} cpu: [x64] os: [darwin] turbo-darwin-arm64@2.4.0: - resolution: { integrity: sha512-8JObIpfun1guA7UlFR5jC/SOVm49lRscxMxfg5jZ5ABft79rhFC+ygN9AwAhGKv6W2DUhIh2xENkSgu4EDmUyg== } + resolution: {integrity: sha512-8JObIpfun1guA7UlFR5jC/SOVm49lRscxMxfg5jZ5ABft79rhFC+ygN9AwAhGKv6W2DUhIh2xENkSgu4EDmUyg==} cpu: [arm64] os: [darwin] turbo-linux-64@2.4.0: - resolution: { integrity: sha512-xWDGGcRlBuGV7HXWAVuTY6vsQi4aZxGMAnuiuNDg8Ij1aHGohOM0RUsWMXjxz4vuJmjk9+/D6NQqHH3AJEXezg== } + resolution: {integrity: sha512-xWDGGcRlBuGV7HXWAVuTY6vsQi4aZxGMAnuiuNDg8Ij1aHGohOM0RUsWMXjxz4vuJmjk9+/D6NQqHH3AJEXezg==} cpu: [x64] os: [linux] turbo-linux-arm64@2.4.0: - resolution: { integrity: sha512-c3En99xMguc/Pdtk/rZP53LnDdw0W6lgUc04he8r8F+UHYSNvgzHh0WGXXmCC6lGbBH72kPhhGx4bAwyvi7dug== } + resolution: {integrity: sha512-c3En99xMguc/Pdtk/rZP53LnDdw0W6lgUc04he8r8F+UHYSNvgzHh0WGXXmCC6lGbBH72kPhhGx4bAwyvi7dug==} cpu: [arm64] os: [linux] turbo-windows-64@2.4.0: - resolution: { integrity: sha512-/gOORuOlyA8JDPzyA16CD3wvyRcuBFePa1URAnFUof9hXQmKxK0VvSDO79cYZFsJSchCKNJpckUS0gYxGsWwoA== } + resolution: {integrity: sha512-/gOORuOlyA8JDPzyA16CD3wvyRcuBFePa1URAnFUof9hXQmKxK0VvSDO79cYZFsJSchCKNJpckUS0gYxGsWwoA==} cpu: [x64] os: [win32] turbo-windows-arm64@2.4.0: - resolution: { integrity: sha512-/DJIdTFijEMM5LSiEpSfarDOMOlYqJV+EzmppqWtHqDsOLF4hbbIBH9sJR6OOp5dURAu5eURBYdmvBRz9Lo6TA== } + resolution: {integrity: sha512-/DJIdTFijEMM5LSiEpSfarDOMOlYqJV+EzmppqWtHqDsOLF4hbbIBH9sJR6OOp5dURAu5eURBYdmvBRz9Lo6TA==} cpu: [arm64] os: [win32] turbo@2.4.0: - resolution: { integrity: sha512-ah/yQp2oMif1X0u7fBJ4MLMygnkbKnW5O8SG6pJvloPCpHfFoZctkSVQiJ3VnvNTq71V2JJIdwmOeu1i34OQyg== } + resolution: {integrity: sha512-ah/yQp2oMif1X0u7fBJ4MLMygnkbKnW5O8SG6pJvloPCpHfFoZctkSVQiJ3VnvNTq71V2JJIdwmOeu1i34OQyg==} hasBin: true tweetnacl@0.14.5: - resolution: { integrity: sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA== } + resolution: {integrity: sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA==} type-detect@4.0.8: - resolution: { integrity: sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g== } - engines: { node: '>=4' } + resolution: {integrity: sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==} + engines: {node: '>=4'} type-fest@0.21.3: - resolution: { integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w== } - engines: { node: '>=10' } + resolution: {integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==} + engines: {node: '>=10'} type-is@1.6.18: - resolution: { integrity: sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g== } - engines: { node: '>= 0.6' } + resolution: {integrity: sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==} + engines: {node: '>= 0.6'} typedarray@0.0.6: - resolution: { integrity: sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA== } + resolution: {integrity: sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==} typedi@0.10.0: - resolution: { integrity: sha512-v3UJF8xm68BBj6AF4oQML3ikrfK2c9EmZUyLOfShpJuItAqVBHWP/KtpGinkSsIiP6EZyyb6Z3NXyW9dgS9X1w== } + resolution: {integrity: sha512-v3UJF8xm68BBj6AF4oQML3ikrfK2c9EmZUyLOfShpJuItAqVBHWP/KtpGinkSsIiP6EZyyb6Z3NXyW9dgS9X1w==} typescript@5.7.3: - resolution: { integrity: sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw== } - engines: { node: '>=14.17' } + resolution: {integrity: sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw==} + engines: {node: '>=14.17'} hasBin: true uid-safe@2.1.5: - resolution: { integrity: sha512-KPHm4VL5dDXKz01UuEd88Df+KzynaohSL9fBh096KWAxSKZQDI2uBrVqtvRM4rwrIrRRKsdLNML/lnaaVSRioA== } - engines: { node: '>= 0.8' } + resolution: {integrity: sha512-KPHm4VL5dDXKz01UuEd88Df+KzynaohSL9fBh096KWAxSKZQDI2uBrVqtvRM4rwrIrRRKsdLNML/lnaaVSRioA==} + engines: {node: '>= 0.8'} undici-types@5.26.5: - resolution: { integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA== } + resolution: {integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==} undici-types@6.19.8: - resolution: { integrity: sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw== } + resolution: {integrity: sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==} undici-types@6.20.0: - resolution: { integrity: sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg== } + resolution: {integrity: sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==} undici@5.28.5: - resolution: { integrity: sha512-zICwjrDrcrUE0pyyJc1I2QzBkLM8FINsgOrt6WjA+BgajVq9Nxu2PbFFXUrAggLfDXlZGZBVZYw7WNV5KiBiBA== } - engines: { node: '>=14.0' } + resolution: {integrity: sha512-zICwjrDrcrUE0pyyJc1I2QzBkLM8FINsgOrt6WjA+BgajVq9Nxu2PbFFXUrAggLfDXlZGZBVZYw7WNV5KiBiBA==} + engines: {node: '>=14.0'} unpipe@1.0.0: - resolution: { integrity: sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ== } - engines: { node: '>= 0.8' } + resolution: {integrity: sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==} + engines: {node: '>= 0.8'} update-browserslist-db@1.1.2: - resolution: { integrity: sha512-PPypAm5qvlD7XMZC3BujecnaOxwhrtoFR+Dqkk5Aa/6DssiH0ibKoketaj9w8LP7Bont1rYeoV5plxD7RTEPRg== } + resolution: {integrity: sha512-PPypAm5qvlD7XMZC3BujecnaOxwhrtoFR+Dqkk5Aa/6DssiH0ibKoketaj9w8LP7Bont1rYeoV5plxD7RTEPRg==} hasBin: true peerDependencies: browserslist: '>= 4.21.0' util-deprecate@1.0.2: - resolution: { integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw== } + resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==} utils-merge@1.0.1: - resolution: { integrity: sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA== } - engines: { node: '>= 0.4.0' } + resolution: {integrity: sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==} + engines: {node: '>= 0.4.0'} v8-compile-cache-lib@3.0.1: - resolution: { integrity: sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg== } + resolution: {integrity: sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==} v8-to-istanbul@9.3.0: - resolution: { integrity: sha512-kiGUalWN+rgBJ/1OHZsBtU4rXZOfj/7rKQxULKlIzwzQSvMJUUNgPwJEEh7gU6xEVxC0ahoOBvN2YI8GH6FNgA== } - engines: { node: '>=10.12.0' } + resolution: {integrity: sha512-kiGUalWN+rgBJ/1OHZsBtU4rXZOfj/7rKQxULKlIzwzQSvMJUUNgPwJEEh7gU6xEVxC0ahoOBvN2YI8GH6FNgA==} + engines: {node: '>=10.12.0'} validator@13.12.0: - resolution: { integrity: sha512-c1Q0mCiPlgdTVVVIJIrBuxNicYE+t/7oKeI9MWLj3fh/uq2Pxh/3eeWbVZ4OcGW1TUf53At0njHw5SMdA3tmMg== } - engines: { node: '>= 0.10' } + resolution: {integrity: sha512-c1Q0mCiPlgdTVVVIJIrBuxNicYE+t/7oKeI9MWLj3fh/uq2Pxh/3eeWbVZ4OcGW1TUf53At0njHw5SMdA3tmMg==} + engines: {node: '>= 0.10'} vary@1.1.2: - resolution: { integrity: sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg== } - engines: { node: '>= 0.8' } + resolution: {integrity: sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==} + engines: {node: '>= 0.8'} walker@1.0.8: - resolution: { integrity: sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ== } + resolution: {integrity: sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ==} webidl-conversions@3.0.1: - resolution: { integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ== } + resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==} whatwg-url@5.0.0: - resolution: { integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw== } + resolution: {integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==} which@2.0.2: - resolution: { integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA== } - engines: { node: '>= 8' } + resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==} + engines: {node: '>= 8'} hasBin: true wrap-ansi@7.0.0: - resolution: { integrity: sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q== } - engines: { node: '>=10' } + resolution: {integrity: sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==} + engines: {node: '>=10'} wrap-ansi@8.1.0: - resolution: { integrity: sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ== } - engines: { node: '>=12' } + resolution: {integrity: sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==} + engines: {node: '>=12'} wrappy@1.0.2: - resolution: { integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ== } + resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==} write-file-atomic@4.0.2: - resolution: { integrity: sha512-7KxauUdBmSdWnmpaGFg+ppNjKF8uNLry8LyzjauQDOVONfFLNKrKvQOxZ/VuTIcS/gge/YNahf5RIIQWTSarlg== } - engines: { node: ^12.13.0 || ^14.15.0 || >=16.0.0 } + resolution: {integrity: sha512-7KxauUdBmSdWnmpaGFg+ppNjKF8uNLry8LyzjauQDOVONfFLNKrKvQOxZ/VuTIcS/gge/YNahf5RIIQWTSarlg==} + engines: {node: ^12.13.0 || ^14.15.0 || >=16.0.0} xtend@4.0.2: - resolution: { integrity: sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ== } - engines: { node: '>=0.4' } + resolution: {integrity: sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==} + engines: {node: '>=0.4'} y18n@5.0.8: - resolution: { integrity: sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA== } - engines: { node: '>=10' } + resolution: {integrity: sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==} + engines: {node: '>=10'} yallist@3.1.1: - resolution: { integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g== } + resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==} yaml@2.7.0: - resolution: { integrity: sha512-+hSoy/QHluxmC9kCIJyL/uyFmLmc+e5CFR5Wa+bpIhIj85LVb9ZH2nVnqrHoSvKogwODv0ClqZkmiSSaIH5LTA== } - engines: { node: '>= 14' } + resolution: {integrity: sha512-+hSoy/QHluxmC9kCIJyL/uyFmLmc+e5CFR5Wa+bpIhIj85LVb9ZH2nVnqrHoSvKogwODv0ClqZkmiSSaIH5LTA==} + engines: {node: '>= 14'} hasBin: true yargs-parser@21.1.1: - resolution: { integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw== } - engines: { node: '>=12' } + resolution: {integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==} + engines: {node: '>=12'} yargs@17.7.2: - resolution: { integrity: sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w== } - engines: { node: '>=12' } + resolution: {integrity: sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==} + engines: {node: '>=12'} ylru@1.4.0: - resolution: { integrity: sha512-2OQsPNEmBCvXuFlIni/a+Rn+R2pHW9INm0BxXJ4hVDA8TirqMj+J/Rp9ItLatT/5pZqWwefVrTQcHpixsxnVlA== } - engines: { node: '>= 4.0.0' } + resolution: {integrity: sha512-2OQsPNEmBCvXuFlIni/a+Rn+R2pHW9INm0BxXJ4hVDA8TirqMj+J/Rp9ItLatT/5pZqWwefVrTQcHpixsxnVlA==} + engines: {node: '>= 4.0.0'} yn@3.1.1: - resolution: { integrity: sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q== } - engines: { node: '>=6' } + resolution: {integrity: sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==} + engines: {node: '>=6'} yocto-queue@0.1.0: - resolution: { integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q== } - engines: { node: '>=10' } + resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==} + engines: {node: '>=10'} zip-stream@6.0.1: - resolution: { integrity: sha512-zK7YHHz4ZXpW89AHXUPbQVGKI7uvkd3hzusTdotCg1UxyaVtg0zFJSTfW/Dq5f7OBBVnq6cZIaC8Ti4hb6dtCA== } - engines: { node: '>= 14' } + resolution: {integrity: sha512-zK7YHHz4ZXpW89AHXUPbQVGKI7uvkd3hzusTdotCg1UxyaVtg0zFJSTfW/Dq5f7OBBVnq6cZIaC8Ti4hb6dtCA==} + engines: {node: '>= 14'} snapshots: + '@ampproject/remapping@2.3.0': dependencies: '@jridgewell/gen-mapping': 0.3.8 @@ -5749,6 +5760,11 @@ snapshots: dependencies: glob: 7.2.3 + rimraf@6.0.1: + dependencies: + glob: 11.0.1 + package-json-from-dist: 1.0.1 + routing-controllers@0.11.1(class-transformer@0.5.1)(class-validator@0.14.1): dependencies: class-transformer: 0.5.1 From 4cda3412054591ac3f672255078bb008ecbcfd3c Mon Sep 17 00:00:00 2001 From: sanderPostma Date: Mon, 17 Mar 2025 17:59:13 +0100 Subject: [PATCH 7/8] chore: final fixes --- .../src/controllers/ShowcaseController.ts | 6 +- .../ShowcaseController.integration.test.ts | 67 +++--- .../repositories/ShowcaseRepository.ts | 147 +++---------- .../__tests__/issuer.repository.test.ts | 53 +++-- .../__tests__/persona.repository.test.ts | 86 ++++---- .../__tests__/relyingParty.repository.test.ts | 49 +++-- .../__tests__/scenario.repository.test.ts | 207 ++++++++++-------- .../__tests__/showcase.repository.test.ts | 11 +- .../src/types/schema/index.ts | 6 +- .../src/utils/mappers.ts | 138 +++++++++--- .../openapi/openapi.yaml | 58 +---- 11 files changed, 422 insertions(+), 406 deletions(-) diff --git a/apps/credential-showcase-api-server/src/controllers/ShowcaseController.ts b/apps/credential-showcase-api-server/src/controllers/ShowcaseController.ts index 72e60ed..f9c6add 100644 --- a/apps/credential-showcase-api-server/src/controllers/ShowcaseController.ts +++ b/apps/credential-showcase-api-server/src/controllers/ShowcaseController.ts @@ -54,7 +54,11 @@ class ShowcaseController { if (!instanceOfShowcaseRequest(showcaseRequest)) { return Promise.reject(new BadRequestError()) } - const result = await this.showcaseService.createShowcase(ShowcaseRequestToJSONTyped(showcaseRequest)) +<<<<<<< Updated upstream + const result = await this.showcaseService.createShowcase({ showcase: ShowcaseRequestToJSONTyped(showcaseRequest) }) +======= + const result = await this.showcaseService.createShowcase({showcase: ShowcaseRequestToJSONTyped(showcaseRequest)}) +>>>>>>> Stashed changes return ShowcaseResponseFromJSONTyped({ showcase: showcaseDTOFrom(result) }, false) } catch (e) { if (e.httpCode !== 404) { diff --git a/apps/credential-showcase-api-server/src/controllers/__tests__/ShowcaseController.integration.test.ts b/apps/credential-showcase-api-server/src/controllers/__tests__/ShowcaseController.integration.test.ts index aa00549..bf91254 100644 --- a/apps/credential-showcase-api-server/src/controllers/__tests__/ShowcaseController.integration.test.ts +++ b/apps/credential-showcase-api-server/src/controllers/__tests__/ShowcaseController.integration.test.ts @@ -11,7 +11,7 @@ import IssuerRepository from '../../database/repositories/IssuerRepository' import PersonaRepository from '../../database/repositories/PersonaRepository' import ScenarioRepository from '../../database/repositories/ScenarioRepository' import ShowcaseRepository from '../../database/repositories/ShowcaseRepository' -import ShowcaseService from '../../services/ShowcaseService' +import { ShowcaseService } from '../../services/ShowcaseService' import { Showcase, ShowcaseExpand, ShowcaseRequest } from 'credential-showcase-openapi' import { PGlite } from '@electric-sql/pglite' import { drizzle } from 'drizzle-orm/pglite' @@ -262,12 +262,15 @@ describe('ShowcaseController Integration Tests', () => { // Retrieve without any expands const getResponse = await request.get(`/showcases/${createdShowcase.slug}`).expect(200) - // Verify no related entities are expanded - expect(getResponse.body.showcase.scenarios).toEqual([]) - expect(getResponse.body.showcase.credentialDefinitions).toEqual([]) - expect(getResponse.body.showcase.personas).toEqual([]) - expect(getResponse.body.showcase.bannerImage).toBeUndefined() - expect(getResponse.body.showcase.bannerImageId).toBe(asset.id) + // Verify related entities have IDs but no expanded content + expect(getResponse.body.showcase.scenarios).toHaveLength(1) + expect(getResponse.body.showcase.scenarios[0]).toHaveProperty('id') + expect(getResponse.body.showcase.credentialDefinitions).toHaveLength(1) + expect(getResponse.body.showcase.credentialDefinitions[0]).toHaveProperty('id') + expect(getResponse.body.showcase.personas).toHaveLength(1) + expect(getResponse.body.showcase.personas[0]).toHaveProperty('id') + expect(getResponse.body.showcase.bannerImage).toHaveProperty('id') + expect(Object.keys(getResponse.body.showcase.bannerImage).length).toBe(1) // Only contains id }) it('should retrieve a showcase with all expands except asset content', async () => { @@ -303,16 +306,17 @@ describe('ShowcaseController Integration Tests', () => { expect(getResponse.body.showcase.completionMessage).toEqual('Testing completion message') // Verify banner image is a string ID without content - expect(typeof getResponse.body.showcase.bannerImageId).toBe('string') - - // Check that persona image references are string IDs + expect(getResponse.body.showcase.bannerImage).toHaveProperty('id') + expect(getResponse.body.showcase.bannerImage).not.toHaveProperty('content') + // Check that persona image references are objects with id const responsePersona = getResponse.body.showcase.personas[0] - expect(typeof responsePersona.headshotImageId).toBe('string') - expect(typeof responsePersona.bodyImageId).toBe('string') - - // Check that scenario assets are string IDs + expect(responsePersona.headshotImage).toHaveProperty('id') + expect(responsePersona.headshotImage).not.toHaveProperty('content') + expect(responsePersona.bodyImage).toHaveProperty('id') + expect(responsePersona.bodyImage).not.toHaveProperty('content') + // Check that scenario assets are objects with id const step = getResponse.body.showcase.scenarios[0].steps[0] - expect(typeof step.assetId).toBe('string') + expect(step.asset).toHaveProperty('id') }) it('should retrieve a showcase with all expands including asset content', async () => { @@ -465,20 +469,24 @@ describe('ShowcaseController Integration Tests', () => { await request.post('/showcases').send(showcaseRequest1).expect(201) await request.post('/showcases').send(showcaseRequest2).expect(201) - // Test 1: Get all with no expands const response1 = await request.get('/showcases').expect(200) expect(response1.body.showcases.length).toBeGreaterThanOrEqual(2) - expect(response1.body.showcases[0].scenarios).toEqual([]) - expect(response1.body.showcases[0].credentialDefinitions).toEqual([]) - expect(response1.body.showcases[0].personas).toEqual([]) + expect(response1.body.showcases[0].scenarios.length).toBeGreaterThanOrEqual(1) + expect(response1.body.showcases[0].scenarios[0]).toHaveProperty('id') + expect(response1.body.showcases[0].credentialDefinitions.length).toBeGreaterThanOrEqual(1) + expect(response1.body.showcases[0].credentialDefinitions[0]).toHaveProperty('id') + expect(response1.body.showcases[0].personas.length).toBeGreaterThanOrEqual(1) + expect(response1.body.showcases[0].personas[0]).toHaveProperty('id') expect(response1.body.showcases[0].completionMessage).toBeDefined() // Test 2: Get all with only scenarios expanded const response2 = await request.get(`/showcases?expand=${ShowcaseExpand.Scenarios}`).expect(200) expect(response2.body.showcases.length).toBeGreaterThanOrEqual(2) expect(response2.body.showcases[0].scenarios.length).toBeGreaterThanOrEqual(1) - expect(response2.body.showcases[0].credentialDefinitions).toEqual([]) - expect(response2.body.showcases[0].personas).toEqual([]) + expect(response2.body.showcases[0].credentialDefinitions.length).toBeGreaterThanOrEqual(1) + expect(response2.body.showcases[0].credentialDefinitions[0]).toHaveProperty('id') + expect(response2.body.showcases[0].personas.length).toBeGreaterThanOrEqual(1) + expect(response2.body.showcases[0].personas[0]).toHaveProperty('id') expect(response2.body.showcases[0].completionMessage).toBeDefined() // Test 3: Get all with scenarios and credential definitions expanded @@ -486,7 +494,8 @@ describe('ShowcaseController Integration Tests', () => { expect(response3.body.showcases.length).toBeGreaterThanOrEqual(2) expect(response3.body.showcases[0].scenarios.length).toBeGreaterThanOrEqual(1) expect(response3.body.showcases[0].credentialDefinitions.length).toBeGreaterThanOrEqual(1) - expect(response3.body.showcases[0].personas).toEqual([]) + expect(response3.body.showcases[0].personas.length).toBeGreaterThanOrEqual(1) + expect(response3.body.showcases[0].personas[0]).toHaveProperty('id') expect(response3.body.showcases[0].completionMessage).toBeDefined() // Test 4: Get all with all expands including asset content @@ -536,10 +545,14 @@ describe('ShowcaseController Integration Tests', () => { .get(`/showcases/${createdShowcase.slug}?expand=${ShowcaseExpand.Scenarios}&expand=${ShowcaseExpand.Personas}`) .expect(200) - // Verify valid expands are processed correctly - expect(validResponse.body.showcase.scenarios.length).toEqual(1) - expect(validResponse.body.showcase.personas.length).toEqual(1) - expect(validResponse.body.showcase.credentialDefinitions).toEqual([]) - expect(validResponse.body.showcase.completionMessage).toEqual('Test completion message') + // Verify related entities have IDs but no expanded content + expect(validResponse.body.showcase.scenarios).toHaveLength(1) + expect(validResponse.body.showcase.scenarios[0]).toHaveProperty('id') + expect(validResponse.body.showcase.credentialDefinitions).toHaveLength(1) + expect(validResponse.body.showcase.credentialDefinitions[0]).toHaveProperty('id') + expect(validResponse.body.showcase.personas).toHaveLength(1) + expect(validResponse.body.showcase.personas[0]).toHaveProperty('id') + expect(validResponse.body.showcase.bannerImage).toHaveProperty('id') + expect(Object.keys(validResponse.body.showcase.bannerImage).length).toBe(1) // Only contains id }) }) diff --git a/apps/credential-showcase-api-server/src/database/repositories/ShowcaseRepository.ts b/apps/credential-showcase-api-server/src/database/repositories/ShowcaseRepository.ts index b0ad47e..3812739 100644 --- a/apps/credential-showcase-api-server/src/database/repositories/ShowcaseRepository.ts +++ b/apps/credential-showcase-api-server/src/database/repositories/ShowcaseRepository.ts @@ -21,11 +21,9 @@ import { import { CredentialDefinition, CredentialSchema, - IssuanceScenario, Issuer, NewShowcase, Persona, - PresentationScenario, RelyingParty, RepositoryDefinition, Scenario, @@ -759,24 +757,9 @@ class ShowcaseRepository implements RepositoryDefinition queryConfig.with.bannerImage = true } - const connection = await this.databaseService.getConnection() - const showcasesResult = await connection.query.showcases.findMany(queryConfig) - - if (showcasesResult.length === 0) { - return [] - } - - const showcaseIds = showcasesResult.map((s) => s.id) - - // Initialize arrays for collecting expanded data - let credDefData: any[] = [] - let scenariosData: any[] = [] - let personasData: any[] = [] - - // Fetch credential definitions if needed + // Add credentialDefinitions to query config if (expandSet.has(ShowcaseExpand.CREDENTIAL_DEFINITIONS)) { - credDefData = await connection.query.showcasesToCredentialDefinitions.findMany({ - where: inArray(showcasesToCredentialDefinitions.showcase, showcaseIds), + queryConfig.with.credentialDefinitions = { with: { credentialDefinition: { with: { @@ -791,13 +774,18 @@ class ShowcaseRepository implements RepositoryDefinition }, }, }, - }) + } + } else { + queryConfig.with.credentialDefinitions = { + columns: { + credentialDefinition: true, + }, + } } - // Fetch scenarios if needed + // Add scenarios to query config if (expandSet.has(ShowcaseExpand.SCENARIOS)) { - scenariosData = await connection.query.showcasesToScenarios.findMany({ - where: inArray(showcasesToScenarios.showcase, showcaseIds), + queryConfig.with.scenarios = { with: { scenario: { with: { @@ -879,13 +867,18 @@ class ShowcaseRepository implements RepositoryDefinition }, }, }, - }) + } + } else { + queryConfig.with.scenarios = { + columns: { + scenario: true, + }, + } } - // Fetch personas if needed + // Add personas to query config if (expandSet.has(ShowcaseExpand.PERSONAS)) { - personasData = await connection.query.showcasesToPersonas.findMany({ - where: inArray(showcasesToPersonas.showcase, showcaseIds), + queryConfig.with.personas = { with: { persona: { with: { @@ -898,102 +891,34 @@ class ShowcaseRepository implements RepositoryDefinition }, }, }, - }) - } - - // Group data by showcase ID - const credDefMap = new Map() - const scenariosMap = new Map() - const personasMap = new Map() - - for (const item of credDefData) { - const key = item.showcase - if (!credDefMap.has(key)) { - credDefMap.set(key, []) } - credDefMap.get(key)!.push(item) - } - - for (const item of scenariosData) { - const key = item.showcase - if (!scenariosMap.has(key)) { - scenariosMap.set(key, []) + } else { + queryConfig.with.personas = { + columns: { + persona: true, + }, } - scenariosMap.get(key)!.push(item) } - for (const item of personasData) { - const key = item.showcase - if (!personasMap.has(key)) { - personasMap.set(key, []) - } - personasMap.get(key)!.push(item) + const connection = await this.databaseService.getConnection() + const showcasesResult = await connection.query.showcases.findMany(queryConfig) + + if (showcasesResult.length === 0) { + return [] } - // Process each showcase with its expanded entities - return showcasesResult.map((showcaseData): Showcase => { + return showcasesResult.map((result): Showcase => { + // Create a typed showcase result const showcase: Showcase = { - ...showcaseData, + ...result, scenarios: [], credentialDefinitions: [], personas: [], } - // Process scenarios if they should be expanded - if (expandSet.has(ShowcaseExpand.SCENARIOS)) { - const scenarioItems = scenariosMap.get(showcaseData.id) || [] - showcase.scenarios = scenarioItems - .filter((scenarioJoin) => scenarioJoin.scenario) - .map((scenarioJoin) => { - const scenarioObj = scenarioJoin.scenario - - // Create the final scenario object - const finalScenario: Scenario = { - ...scenarioObj, - steps: scenarioObj.steps ? (sortSteps(scenarioObj.steps) as Step[]) : [], - personas: scenarioObj.personas ? scenarioObj.personas.map((p: { persona: Persona }) => p.persona) : [], - } - - // Process relying party if it exists - if ('relyingParty' in scenarioObj && scenarioObj.relyingParty) { - ;(finalScenario as PresentationScenario).relyingParty = { - ...scenarioObj.relyingParty, - credentialDefinitions: scenarioObj.relyingParty.cds.map((cd: { cd: CredentialDefinition }) => cd.cd), - } as RelyingParty - } - - // Process issuer if it exists - if ('issuer' in scenarioObj && scenarioObj.issuer) { - ;(finalScenario as IssuanceScenario).issuer = { - ...scenarioObj.issuer, - credentialDefinitions: scenarioObj.issuer.cds.map((cd: { cd: CredentialDefinition }) => cd.cd), - credentialSchemas: scenarioObj.issuer.css.map((cs: { cs: CredentialSchema }) => cs.cs), - } as Issuer - } - - return finalScenario - }) - } - - // Process credential definitions if they should be expanded - if (expandSet.has(ShowcaseExpand.CREDENTIAL_DEFINITIONS)) { - const cdItems = credDefMap.get(showcaseData.id) || [] - showcase.credentialDefinitions = cdItems - .filter((cdJoin) => cdJoin.credentialDefinition) - .map( - (cdJoin) => - ({ - ...cdJoin.credentialDefinition, - credentialSchema: cdJoin.credentialDefinition.cs, - }) as CredentialDefinition, - ) - } - - // Process personas if they should be expanded - if (expandSet.has(ShowcaseExpand.PERSONAS)) { - const personaItems = personasMap.get(showcaseData.id) || [] - showcase.personas = personaItems.filter((personaJoin) => personaJoin.persona).map((personaJoin) => personaJoin.persona as Persona) - } + this.populateScenarios(result, expandSet, showcase) + this.populateCredentialDefs(result, expandSet, showcase) + this.populatePersonas(result, expandSet, showcase) return showcase }) diff --git a/apps/credential-showcase-api-server/src/database/repositories/__tests__/issuer.repository.test.ts b/apps/credential-showcase-api-server/src/database/repositories/__tests__/issuer.repository.test.ts index 756233e..eb02800 100644 --- a/apps/credential-showcase-api-server/src/database/repositories/__tests__/issuer.repository.test.ts +++ b/apps/credential-showcase-api-server/src/database/repositories/__tests__/issuer.repository.test.ts @@ -122,12 +122,17 @@ describe('Database issuer repository tests', (): void => { expect(savedIssuer.description).toEqual(issuer.description) expect(savedIssuer.organization).toEqual(issuer.organization) expect(savedIssuer.credentialDefinitions.length).toEqual(2) - expect(savedIssuer.logo).not.toBeNull() - expect(savedIssuer.logo!.id).toBeDefined() - expect(savedIssuer.logo!.mediaType).toEqual(asset.mediaType) - expect(savedIssuer.logo!.fileName).toEqual(asset.fileName) - expect(savedIssuer.logo!.description).toEqual(asset.description) - expect(savedIssuer.logo!.content).toStrictEqual(asset.content) +<<<<<<< Updated upstream + const logoAsset = savedIssuer.logo as Asset +======= + const logoAsset = savedIssuer.logo as Asset +>>>>>>> Stashed changes + expect(logoAsset).not.toBeNull() + expect(logoAsset!.id).toBeDefined() + expect(logoAsset!.mediaType).toEqual(asset.mediaType) + expect(logoAsset!.fileName).toEqual(asset.fileName) + expect(logoAsset!.description).toEqual(asset.description) + expect(logoAsset!.content).toStrictEqual(asset.content) }) it('Should throw error when saving issuer with invalid logo id', async (): Promise => { @@ -210,12 +215,17 @@ describe('Database issuer repository tests', (): void => { expect(fromDb.description).toEqual(issuer.description) expect(fromDb.organization).toEqual(issuer.organization) expect(fromDb.credentialDefinitions.length).toEqual(2) - expect(fromDb.logo).not.toBeNull() - expect(fromDb.logo!.id).toBeDefined() - expect(fromDb.logo!.mediaType).toEqual(asset.mediaType) - expect(fromDb.logo!.fileName).toEqual(asset.fileName) - expect(fromDb.logo!.description).toEqual(asset.description) - expect(fromDb.logo!.content).toStrictEqual(asset.content) +<<<<<<< Updated upstream + const logoAsset = fromDb.logo as Asset +======= + const logoAsset = fromDb.logo as Asset +>>>>>>> Stashed changes + expect(logoAsset).not.toBeNull() + expect(logoAsset!.id).toBeDefined() + expect(logoAsset!.mediaType).toEqual(asset.mediaType) + expect(logoAsset!.fileName).toEqual(asset.fileName) + expect(logoAsset!.description).toEqual(asset.description) + expect(logoAsset!.content).toStrictEqual(asset.content) }) it('Should get all issuers from database', async (): Promise => { @@ -277,7 +287,7 @@ describe('Database issuer repository tests', (): void => { name: newName, credentialDefinitions: [credentialDefinition1.id], credentialSchemas: [credentialSchema.id], - logo: savedIssuer.logo?.id, + logo: (savedIssuer.logo as Asset)?.id, }) expect(updatedIssuer).toBeDefined() @@ -286,12 +296,17 @@ describe('Database issuer repository tests', (): void => { expect(updatedIssuer.description).toEqual(issuer.description) expect(updatedIssuer.organization).toEqual(issuer.organization) expect(updatedIssuer.credentialDefinitions.length).toEqual(1) - expect(updatedIssuer.logo).not.toBeNull() - expect(updatedIssuer.logo!.id).toBeDefined() - expect(updatedIssuer.logo!.mediaType).toEqual(asset.mediaType) - expect(updatedIssuer.logo!.fileName).toEqual(asset.fileName) - expect(updatedIssuer.logo!.description).toEqual(asset.description) - expect(updatedIssuer.logo!.content).toStrictEqual(asset.content) +<<<<<<< Updated upstream + const logoAsset = updatedIssuer.logo as Asset +======= + const logoAsset = updatedIssuer.logo as Asset +>>>>>>> Stashed changes + expect(logoAsset).not.toBeNull() + expect(logoAsset!.id).toBeDefined() + expect(logoAsset!.mediaType).toEqual(asset.mediaType) + expect(logoAsset!.fileName).toEqual(asset.fileName) + expect(logoAsset!.description).toEqual(asset.description) + expect(logoAsset!.content).toStrictEqual(asset.content) }) it('Should throw error when updating issuer with invalid logo id', async (): Promise => { diff --git a/apps/credential-showcase-api-server/src/database/repositories/__tests__/persona.repository.test.ts b/apps/credential-showcase-api-server/src/database/repositories/__tests__/persona.repository.test.ts index 0a201cd..3e1d663 100644 --- a/apps/credential-showcase-api-server/src/database/repositories/__tests__/persona.repository.test.ts +++ b/apps/credential-showcase-api-server/src/database/repositories/__tests__/persona.repository.test.ts @@ -58,18 +58,20 @@ describe('Database persona repository tests', (): void => { expect(savedPersona.role).toEqual(persona.role) expect(savedPersona.description).toEqual(persona.description) expect(savedPersona.hidden).toEqual(persona.hidden) - expect(savedPersona.headshotImage).toBeDefined() - expect(savedPersona.headshotImage!.id).toBeDefined() - expect(savedPersona.headshotImage!.mediaType).toEqual(asset.mediaType) - expect(savedPersona.headshotImage!.fileName).toEqual(asset.fileName) - expect(savedPersona.headshotImage!.description).toEqual(asset.description) - expect(savedPersona.headshotImage!.content).toStrictEqual(asset.content) - expect(savedPersona.bodyImage).toBeDefined() - expect(savedPersona.bodyImage!.id).toBeDefined() - expect(savedPersona.bodyImage!.mediaType).toEqual(asset.mediaType) - expect(savedPersona.bodyImage!.fileName).toEqual(asset.fileName) - expect(savedPersona.bodyImage!.description).toEqual(asset.description) - expect(savedPersona.bodyImage!.content).toStrictEqual(asset.content) + const hsAsset = savedPersona.headshotImage as Asset + expect(hsAsset).toBeDefined() + expect(hsAsset!.id).toBeDefined() + expect(hsAsset!.mediaType).toEqual(asset.mediaType) + expect(hsAsset!.fileName).toEqual(asset.fileName) + expect(hsAsset!.description).toEqual(asset.description) + expect(hsAsset!.content).toStrictEqual(asset.content) + const biAsset = savedPersona.bodyImage as Asset + expect(biAsset).toBeDefined() + expect(biAsset!.id).toBeDefined() + expect(biAsset!.mediaType).toEqual(asset.mediaType) + expect(biAsset!.fileName).toEqual(asset.fileName) + expect(biAsset!.description).toEqual(asset.description) + expect(biAsset!.content).toStrictEqual(asset.content) }) it('Should save persona without images to database', async (): Promise => { @@ -135,18 +137,20 @@ describe('Database persona repository tests', (): void => { expect(fromDb.name).toEqual(persona.name) expect(fromDb.role).toEqual(persona.role) expect(fromDb.description).toEqual(persona.description) - expect(fromDb.headshotImage).toBeDefined() - expect(fromDb.headshotImage!.id).toBeDefined() - expect(fromDb.headshotImage!.mediaType).toEqual(asset.mediaType) - expect(fromDb.headshotImage!.fileName).toEqual(asset.fileName) - expect(fromDb.headshotImage!.description).toEqual(asset.description) - expect(fromDb.headshotImage!.content).toStrictEqual(asset.content) - expect(fromDb.bodyImage).toBeDefined() - expect(fromDb.bodyImage!.id).toBeDefined() - expect(fromDb.bodyImage!.mediaType).toEqual(asset.mediaType) - expect(fromDb.bodyImage!.fileName).toEqual(asset.fileName) - expect(fromDb.bodyImage!.description).toEqual(asset.description) - expect(fromDb.bodyImage!.content).toStrictEqual(asset.content) + const hsAsset = fromDb.headshotImage as Asset + expect(hsAsset).toBeDefined() + expect(hsAsset!.id).toBeDefined() + expect(hsAsset!.mediaType).toEqual(asset.mediaType) + expect(hsAsset!.fileName).toEqual(asset.fileName) + expect(hsAsset!.description).toEqual(asset.description) + expect(hsAsset!.content).toStrictEqual(asset.content) + const biAsset = fromDb.bodyImage as Asset + expect(biAsset).toBeDefined() + expect(biAsset!.id).toBeDefined() + expect(biAsset!.mediaType).toEqual(asset.mediaType) + expect(biAsset!.fileName).toEqual(asset.fileName) + expect(biAsset!.description).toEqual(asset.description) + expect(biAsset!.content).toStrictEqual(asset.content) }) it('Should get all personas from database', async (): Promise => { @@ -204,8 +208,8 @@ describe('Database persona repository tests', (): void => { const newName = 'Jane Doe' const updatedPersona = await personaRepository.update(savedPersona.id, { ...savedPersona, - headshotImage: savedPersona.headshotImage!.id, - bodyImage: savedPersona.bodyImage!.id, + headshotImage: (savedPersona.headshotImage as Asset)!.id, + bodyImage: (savedPersona.bodyImage as Asset)!.id, name: newName, }) @@ -215,18 +219,20 @@ describe('Database persona repository tests', (): void => { expect(updatedPersona.role).toEqual(persona.role) expect(updatedPersona.description).toEqual(persona.description) expect(updatedPersona.hidden).toEqual(persona.hidden) - expect(updatedPersona.headshotImage).toBeDefined() - expect(updatedPersona.headshotImage!.id).toBeDefined() - expect(updatedPersona.headshotImage!.mediaType).toEqual(asset.mediaType) - expect(updatedPersona.headshotImage!.fileName).toEqual(asset.fileName) - expect(updatedPersona.headshotImage!.description).toEqual(asset.description) - expect(updatedPersona.headshotImage!.content).toStrictEqual(asset.content) - expect(updatedPersona.bodyImage).toBeDefined() - expect(updatedPersona.bodyImage!.id).toBeDefined() - expect(updatedPersona.bodyImage!.mediaType).toEqual(asset.mediaType) - expect(updatedPersona.bodyImage!.fileName).toEqual(asset.fileName) - expect(updatedPersona.bodyImage!.description).toEqual(asset.description) - expect(updatedPersona.bodyImage!.content).toStrictEqual(asset.content) + const hsAsset = updatedPersona.headshotImage as Asset + expect(hsAsset).toBeDefined() + expect(hsAsset!.id).toBeDefined() + expect(hsAsset!.mediaType).toEqual(asset.mediaType) + expect(hsAsset!.fileName).toEqual(asset.fileName) + expect(hsAsset!.description).toEqual(asset.description) + expect(hsAsset!.content).toStrictEqual(asset.content) + const biAsset = updatedPersona.bodyImage as Asset + expect(biAsset).toBeDefined() + expect(biAsset!.id).toBeDefined() + expect(biAsset!.mediaType).toEqual(asset.mediaType) + expect(biAsset!.fileName).toEqual(asset.fileName) + expect(biAsset!.description).toEqual(asset.description) + expect(biAsset!.content).toStrictEqual(asset.content) }) it('Should throw error when updating persona with invalid headshot image id', async (): Promise => { @@ -246,7 +252,7 @@ describe('Database persona repository tests', (): void => { const updatedPersona: NewPersona = { ...savedPersona, headshotImage: unknownImageId, - bodyImage: savedPersona.bodyImage!.id, + bodyImage: (savedPersona.bodyImage as Asset)!.id, } await expect(personaRepository.update(savedPersona.id, updatedPersona)).rejects.toThrowError(`No asset found for id: ${unknownImageId}`) @@ -268,7 +274,7 @@ describe('Database persona repository tests', (): void => { const updatedPersona: NewPersona = { ...savedPersona, - headshotImage: savedPersona.headshotImage!.id, + headshotImage: (savedPersona.headshotImage as Asset).id, bodyImage: unknownImageId, } diff --git a/apps/credential-showcase-api-server/src/database/repositories/__tests__/relyingParty.repository.test.ts b/apps/credential-showcase-api-server/src/database/repositories/__tests__/relyingParty.repository.test.ts index 37c30f7..5099a9d 100644 --- a/apps/credential-showcase-api-server/src/database/repositories/__tests__/relyingParty.repository.test.ts +++ b/apps/credential-showcase-api-server/src/database/repositories/__tests__/relyingParty.repository.test.ts @@ -13,15 +13,15 @@ import * as schema from '../../schema' import { Asset, CredentialAttributeType, - CredentialType, CredentialDefinition, + CredentialSchema, + CredentialType, + IdentifierType, NewAsset, NewCredentialDefinition, + NewCredentialSchema, NewRelyingParty, RelyingPartyType, - NewCredentialSchema, - IdentifierType, - CredentialSchema, } from '../../../types' describe('Database relying party repository tests', (): void => { @@ -122,12 +122,13 @@ describe('Database relying party repository tests', (): void => { expect(savedRelyingParty.description).toEqual(relyingParty.description) expect(savedRelyingParty.organization).toEqual(relyingParty.organization) expect(savedRelyingParty.credentialDefinitions.length).toEqual(2) - expect(savedRelyingParty.logo).not.toBeNull() - expect(savedRelyingParty.logo!.id).toBeDefined() - expect(savedRelyingParty.logo!.mediaType).toEqual(asset.mediaType) - expect(savedRelyingParty.logo!.fileName).toEqual(asset.fileName) - expect(savedRelyingParty.logo!.description).toEqual(asset.description) - expect(savedRelyingParty.logo!.content).toStrictEqual(asset.content) + const logoAsset = savedRelyingParty.logo as Asset + expect(logoAsset).not.toBeNull() + expect(logoAsset!.id).toBeDefined() + expect(logoAsset!.mediaType).toEqual(logoAsset.mediaType) + expect(logoAsset!.fileName).toEqual(logoAsset.fileName) + expect(logoAsset!.description).toEqual(logoAsset.description) + expect(logoAsset!.content).toStrictEqual(logoAsset.content) }) it('Should throw error when saving relying party with invalid logo id', async (): Promise => { @@ -192,12 +193,13 @@ describe('Database relying party repository tests', (): void => { expect(fromDb.description).toEqual(relyingParty.description) expect(fromDb.organization).toEqual(relyingParty.organization) expect(fromDb.credentialDefinitions.length).toEqual(2) - expect(fromDb.logo).not.toBeNull() - expect(fromDb.logo!.id).toBeDefined() - expect(fromDb.logo!.mediaType).toEqual(asset.mediaType) - expect(fromDb.logo!.fileName).toEqual(asset.fileName) - expect(fromDb.logo!.description).toEqual(asset.description) - expect(fromDb.logo!.content).toStrictEqual(asset.content) + const logoAsset = fromDb.logo as Asset + expect(logoAsset).not.toBeNull() + expect(logoAsset!.id).toBeDefined() + expect(logoAsset!.mediaType).toEqual(logoAsset.mediaType) + expect(logoAsset!.fileName).toEqual(logoAsset.fileName) + expect(logoAsset!.description).toEqual(logoAsset.description) + expect(logoAsset!.content).toStrictEqual(logoAsset.content) }) it('Should get all relying parties from database', async (): Promise => { @@ -255,7 +257,7 @@ describe('Database relying party repository tests', (): void => { ...savedRelyingParty, name: newName, credentialDefinitions: [credentialDefinition1.id], - logo: savedRelyingParty.logo?.id, + logo: (savedRelyingParty.logo as Asset)?.id, }) expect(updatedRelyingParty).toBeDefined() @@ -264,12 +266,13 @@ describe('Database relying party repository tests', (): void => { expect(updatedRelyingParty.description).toEqual(relyingParty.description) expect(updatedRelyingParty.organization).toEqual(relyingParty.organization) expect(updatedRelyingParty.credentialDefinitions.length).toEqual(1) - expect(updatedRelyingParty.logo).not.toBeNull() - expect(updatedRelyingParty.logo!.id).toBeDefined() - expect(updatedRelyingParty.logo!.mediaType).toEqual(asset.mediaType) - expect(updatedRelyingParty.logo!.fileName).toEqual(asset.fileName) - expect(updatedRelyingParty.logo!.description).toEqual(asset.description) - expect(updatedRelyingParty.logo!.content).toStrictEqual(asset.content) + const logoAsset = updatedRelyingParty.logo as Asset + expect(logoAsset).not.toBeNull() + expect(logoAsset!.id).toBeDefined() + expect(logoAsset!.mediaType).toEqual(logoAsset.mediaType) + expect(logoAsset!.fileName).toEqual(logoAsset.fileName) + expect(logoAsset!.description).toEqual(logoAsset.description) + expect(logoAsset!.content).toStrictEqual(logoAsset.content) }) it('Should throw error when updating relying party with invalid logo id', async (): Promise => { diff --git a/apps/credential-showcase-api-server/src/database/repositories/__tests__/scenario.repository.test.ts b/apps/credential-showcase-api-server/src/database/repositories/__tests__/scenario.repository.test.ts index 8004b45..289b117 100644 --- a/apps/credential-showcase-api-server/src/database/repositories/__tests__/scenario.repository.test.ts +++ b/apps/credential-showcase-api-server/src/database/repositories/__tests__/scenario.repository.test.ts @@ -278,11 +278,12 @@ describe('Database scenario repository tests', (): void => { issuanceScenario.steps[0].actions[0].proofRequest!.predicates.predicate1.value, ) expect(savedIssuanceScenario.steps[0].actions[0].proofRequest!.predicates!.predicate1.restrictions!.length).toEqual(2) - expect(savedIssuanceScenario.steps[0].asset).not.toBeNull() - expect(savedIssuanceScenario.steps[0].asset!.mediaType).toEqual(asset.mediaType) - expect(savedIssuanceScenario.steps[0].asset!.fileName).toEqual(asset.fileName) - expect(savedIssuanceScenario.steps[0].asset!.description).toEqual(asset.description) - expect(savedIssuanceScenario.steps[0].asset!.content).toStrictEqual(asset.content) + const stepAsset = savedIssuanceScenario.steps[0].asset as Asset + expect(stepAsset).not.toBeNull() + expect(stepAsset!.mediaType).toEqual(asset.mediaType) + expect(stepAsset!.fileName).toEqual(asset.fileName) + expect(stepAsset!.description).toEqual(asset.description) + expect(stepAsset!.content).toStrictEqual(asset.content) expect((savedIssuanceScenario).issuer).not.toBeNull() expect((savedIssuanceScenario).issuer!.name).toEqual(issuer.name) expect((savedIssuanceScenario).issuer!.credentialDefinitions.length).toEqual(1) @@ -294,23 +295,26 @@ describe('Database scenario repository tests', (): void => { expect(savedIssuanceScenario.personas[0].name).toEqual(persona1.name) expect(savedIssuanceScenario.personas[0].role).toEqual(persona1.role) expect(savedIssuanceScenario.personas[0].description).toEqual(persona1.description) - expect(savedIssuanceScenario.personas[0].headshotImage).not.toBeNull() - expect(savedIssuanceScenario.personas[0].headshotImage!.id).toBeDefined() - expect(savedIssuanceScenario.personas[0].headshotImage!.mediaType).toEqual(asset.mediaType) - expect(savedIssuanceScenario.personas[0].headshotImage!.fileName).toEqual(asset.fileName) - expect(savedIssuanceScenario.personas[0].headshotImage!.description).toEqual(asset.description) - expect(savedIssuanceScenario.personas[0].headshotImage!.content).toStrictEqual(asset.content) - expect(savedIssuanceScenario.personas[0].bodyImage).not.toBeNull() - expect(savedIssuanceScenario.personas[0].bodyImage!.id).toBeDefined() - expect(savedIssuanceScenario.personas[0].bodyImage!.mediaType).toEqual(asset.mediaType) - expect(savedIssuanceScenario.personas[0].bodyImage!.fileName).toEqual(asset.fileName) - expect(savedIssuanceScenario.personas[0].bodyImage!.description).toEqual(asset.description) - expect(savedIssuanceScenario.personas[0].bodyImage!.content).toStrictEqual(asset.content) - expect(savedIssuanceScenario.bannerImage!.id).toBeDefined() - expect(savedIssuanceScenario.bannerImage!.mediaType).toEqual(asset.mediaType) - expect(savedIssuanceScenario.bannerImage!.fileName).toEqual(asset.fileName) - expect(savedIssuanceScenario.bannerImage!.description).toEqual(asset.description) - expect(savedIssuanceScenario.bannerImage!.content).toStrictEqual(asset.content) + const hsAsset = savedIssuanceScenario.personas[0].headshotImage as Asset + expect(hsAsset).not.toBeNull() + expect(hsAsset!.id).toBeDefined() + expect(hsAsset!.mediaType).toEqual(asset.mediaType) + expect(hsAsset!.fileName).toEqual(asset.fileName) + expect(hsAsset!.description).toEqual(asset.description) + expect(hsAsset!.content).toStrictEqual(asset.content) + const biAsset = savedIssuanceScenario.personas[0].bodyImage as Asset + expect(biAsset).not.toBeNull() + expect(biAsset!.id).toBeDefined() + expect(biAsset!.mediaType).toEqual(asset.mediaType) + expect(biAsset!.fileName).toEqual(asset.fileName) + expect(biAsset!.description).toEqual(asset.description) + expect(biAsset!.content).toStrictEqual(asset.content) + const bnAsset = savedIssuanceScenario.bannerImage as Asset + expect(bnAsset!.id).toBeDefined() + expect(bnAsset!.mediaType).toEqual(asset.mediaType) + expect(bnAsset!.fileName).toEqual(asset.fileName) + expect(bnAsset!.description).toEqual(asset.description) + expect(bnAsset!.content).toStrictEqual(asset.content) }) it('Should save presentation scenario to database', async (): Promise => { @@ -421,11 +425,12 @@ describe('Database scenario repository tests', (): void => { expect(savedPresentationScenario.steps[0].actions[0].title).toEqual(presentationScenario.steps[0].actions[0].title) expect(savedPresentationScenario.steps[0].actions[0].actionType).toEqual(presentationScenario.steps[0].actions[0].actionType) expect(savedPresentationScenario.steps[0].actions[0].text).toEqual(presentationScenario.steps[0].actions[0].text) - expect(savedPresentationScenario.steps[0].asset).not.toBeNull() - expect(savedPresentationScenario.steps[0].asset!.mediaType).toEqual(asset.mediaType) - expect(savedPresentationScenario.steps[0].asset!.fileName).toEqual(asset.fileName) - expect(savedPresentationScenario.steps[0].asset!.description).toEqual(asset.description) - expect(savedPresentationScenario.steps[0].asset!.content).toStrictEqual(asset.content) + const stepAsset = savedPresentationScenario.steps[0].asset as Asset + expect(stepAsset).not.toBeNull() + expect(stepAsset!.mediaType).toEqual(asset.mediaType) + expect(stepAsset!.fileName).toEqual(asset.fileName) + expect(stepAsset!.description).toEqual(asset.description) + expect(stepAsset!.content).toStrictEqual(asset.content) expect((savedPresentationScenario).relyingParty).not.toBeNull() expect((savedPresentationScenario).relyingParty!.name).toEqual(relyingParty.name) expect((savedPresentationScenario).relyingParty!.credentialDefinitions.length).toEqual(1) @@ -437,23 +442,26 @@ describe('Database scenario repository tests', (): void => { expect(savedPresentationScenario.personas[0].name).toEqual(persona1.name) expect(savedPresentationScenario.personas[0].role).toEqual(persona1.role) expect(savedPresentationScenario.personas[0].description).toEqual(persona1.description) - expect(savedPresentationScenario.personas[0].headshotImage).not.toBeNull() - expect(savedPresentationScenario.personas[0].headshotImage!.id).toBeDefined() - expect(savedPresentationScenario.personas[0].headshotImage!.mediaType).toEqual(asset.mediaType) - expect(savedPresentationScenario.personas[0].headshotImage!.fileName).toEqual(asset.fileName) - expect(savedPresentationScenario.personas[0].headshotImage!.description).toEqual(asset.description) - expect(savedPresentationScenario.personas[0].headshotImage!.content).toStrictEqual(asset.content) - expect(savedPresentationScenario.personas[0].bodyImage).not.toBeNull() - expect(savedPresentationScenario.personas[0].bodyImage!.id).toBeDefined() - expect(savedPresentationScenario.personas[0].bodyImage!.mediaType).toEqual(asset.mediaType) - expect(savedPresentationScenario.personas[0].bodyImage!.fileName).toEqual(asset.fileName) - expect(savedPresentationScenario.personas[0].bodyImage!.description).toEqual(asset.description) - expect(savedPresentationScenario.personas[0].bodyImage!.content).toStrictEqual(asset.content) - expect(savedPresentationScenario.bannerImage!.id).toBeDefined() - expect(savedPresentationScenario.bannerImage!.mediaType).toEqual(asset.mediaType) - expect(savedPresentationScenario.bannerImage!.fileName).toEqual(asset.fileName) - expect(savedPresentationScenario.bannerImage!.description).toEqual(asset.description) - expect(savedPresentationScenario.bannerImage!.content).toStrictEqual(asset.content) + const hsAsset = savedPresentationScenario.personas[0].headshotImage as Asset + expect(hsAsset).not.toBeNull() + expect(hsAsset!.id).toBeDefined() + expect(hsAsset!.mediaType).toEqual(asset.mediaType) + expect(hsAsset!.fileName).toEqual(asset.fileName) + expect(hsAsset!.description).toEqual(asset.description) + expect(hsAsset!.content).toStrictEqual(asset.content) + const iAsset = savedPresentationScenario.personas[0].bodyImage as Asset + expect(iAsset).not.toBeNull() + expect(iAsset!.id).toBeDefined() + expect(iAsset!.mediaType).toEqual(asset.mediaType) + expect(iAsset!.fileName).toEqual(asset.fileName) + expect(iAsset!.description).toEqual(asset.description) + expect(iAsset!.content).toStrictEqual(asset.content) + const bnAsset = savedPresentationScenario.bannerImage as Asset + expect(bnAsset!.id).toBeDefined() + expect(bnAsset!.mediaType).toEqual(asset.mediaType) + expect(bnAsset!.fileName).toEqual(asset.fileName) + expect(bnAsset!.description).toEqual(asset.description) + expect(bnAsset!.content).toStrictEqual(asset.content) }) it('Should throw error when saving scenario with no steps', async (): Promise => { @@ -989,18 +997,20 @@ describe('Database scenario repository tests', (): void => { expect(fromDb.personas[0].name).toEqual(persona1.name) expect(fromDb.personas[0].role).toEqual(persona1.role) expect(fromDb.personas[0].description).toEqual(persona1.description) - expect(fromDb.personas[0].headshotImage).not.toBeNull() - expect(fromDb.personas[0].headshotImage!.id).toBeDefined() - expect(fromDb.personas[0].headshotImage!.mediaType).toEqual(asset.mediaType) - expect(fromDb.personas[0].headshotImage!.fileName).toEqual(asset.fileName) - expect(fromDb.personas[0].headshotImage!.description).toEqual(asset.description) - expect(fromDb.personas[0].headshotImage!.content).toStrictEqual(asset.content) - expect(fromDb.personas[0].bodyImage).not.toBeNull() - expect(fromDb.personas[0].bodyImage!.id).toBeDefined() - expect(fromDb.personas[0].bodyImage!.mediaType).toEqual(asset.mediaType) - expect(fromDb.personas[0].bodyImage!.fileName).toEqual(asset.fileName) - expect(fromDb.personas[0].bodyImage!.description).toEqual(asset.description) - expect(fromDb.personas[0].bodyImage!.content).toStrictEqual(asset.content) + const hsAsset = fromDb.personas[0].headshotImage as Asset + expect(hsAsset).not.toBeNull() + expect(hsAsset!.id).toBeDefined() + expect(hsAsset!.mediaType).toEqual(asset.mediaType) + expect(hsAsset!.fileName).toEqual(asset.fileName) + expect(hsAsset!.description).toEqual(asset.description) + expect(hsAsset!.content).toStrictEqual(asset.content) + const biAsset = fromDb.personas[0].bodyImage as Asset + expect(biAsset).not.toBeNull() + expect(biAsset!.id).toBeDefined() + expect(biAsset!.mediaType).toEqual(asset.mediaType) + expect(biAsset!.fileName).toEqual(asset.fileName) + expect(biAsset!.description).toEqual(asset.description) + expect(biAsset!.content).toStrictEqual(asset.content) }) it('Should get all scenarios from database', async (): Promise => { @@ -1395,11 +1405,12 @@ describe('Database scenario repository tests', (): void => { expect(updatedIssuanceScenarioResult.steps[0].actions[0].title).toEqual(updatedIssuanceScenario.steps[0].actions[0].title) expect(updatedIssuanceScenarioResult.steps[0].actions[0].actionType).toEqual(updatedIssuanceScenario.steps[0].actions[0].actionType) expect(updatedIssuanceScenarioResult.steps[0].actions[0].text).toEqual(updatedIssuanceScenario.steps[0].actions[0].text) - expect(updatedIssuanceScenarioResult.steps[0].asset).not.toBeNull() - expect(updatedIssuanceScenarioResult.steps[0].asset!.mediaType).toEqual(asset.mediaType) - expect(updatedIssuanceScenarioResult.steps[0].asset!.fileName).toEqual(asset.fileName) - expect(updatedIssuanceScenarioResult.steps[0].asset!.description).toEqual(asset.description) - expect(updatedIssuanceScenarioResult.steps[0].asset!.content).toStrictEqual(asset.content) + const stepAsset = updatedIssuanceScenarioResult.steps[0].asset as Asset + expect(stepAsset).not.toBeNull() + expect(stepAsset!.mediaType).toEqual(asset.mediaType) + expect(stepAsset!.fileName).toEqual(asset.fileName) + expect(stepAsset!.description).toEqual(asset.description) + expect(stepAsset!.content).toStrictEqual(asset.content) expect(updatedIssuanceScenarioResult.steps[0].actions[0].proofRequest).not.toBeNull() expect(updatedIssuanceScenarioResult.steps[0].actions[0].proofRequest!.attributes).not.toBeNull() expect(updatedIssuanceScenarioResult.steps[0].actions[0].proofRequest!.attributes!.attribute1).toBeDefined() @@ -1422,18 +1433,20 @@ describe('Database scenario repository tests', (): void => { expect(updatedIssuanceScenarioResult.personas[0].name).toEqual(persona1.name) expect(updatedIssuanceScenarioResult.personas[0].role).toEqual(persona1.role) expect(updatedIssuanceScenarioResult.personas[0].description).toEqual(persona1.description) - expect(updatedIssuanceScenarioResult.personas[0].headshotImage).not.toBeNull() - expect(updatedIssuanceScenarioResult.personas[0].headshotImage!.id).toBeDefined() - expect(updatedIssuanceScenarioResult.personas[0].headshotImage!.mediaType).toEqual(asset.mediaType) - expect(updatedIssuanceScenarioResult.personas[0].headshotImage!.fileName).toEqual(asset.fileName) - expect(updatedIssuanceScenarioResult.personas[0].headshotImage!.description).toEqual(asset.description) - expect(updatedIssuanceScenarioResult.personas[0].headshotImage!.content).toStrictEqual(asset.content) - expect(updatedIssuanceScenarioResult.personas[0].bodyImage).not.toBeNull() - expect(updatedIssuanceScenarioResult.personas[0].bodyImage!.id).toBeDefined() - expect(updatedIssuanceScenarioResult.personas[0].bodyImage!.mediaType).toEqual(asset.mediaType) - expect(updatedIssuanceScenarioResult.personas[0].bodyImage!.fileName).toEqual(asset.fileName) - expect(updatedIssuanceScenarioResult.personas[0].bodyImage!.description).toEqual(asset.description) - expect(updatedIssuanceScenarioResult.personas[0].bodyImage!.content).toStrictEqual(asset.content) + const hsAsset = updatedIssuanceScenarioResult.personas[0].headshotImage as Asset + expect(hsAsset).not.toBeNull() + expect(hsAsset!.id).toBeDefined() + expect(hsAsset!.mediaType).toEqual(asset.mediaType) + expect(hsAsset!.fileName).toEqual(asset.fileName) + expect(hsAsset!.description).toEqual(asset.description) + expect(hsAsset!.content).toStrictEqual(asset.content) + const biAsset = updatedIssuanceScenarioResult.personas[0].bodyImage as Asset + expect(biAsset).not.toBeNull() + expect(biAsset!.id).toBeDefined() + expect(biAsset!.mediaType).toEqual(asset.mediaType) + expect(biAsset!.fileName).toEqual(asset.fileName) + expect(biAsset!.description).toEqual(asset.description) + expect(biAsset!.content).toStrictEqual(asset.content) }) it('Should throw error when updating scenario with no steps', async (): Promise => { @@ -2195,11 +2208,12 @@ describe('Database scenario repository tests', (): void => { expect(fromDb.steps[1].actions[0].title).toEqual(step.actions[0].title) expect(fromDb.steps[1].actions[0].actionType).toEqual(step.actions[0].actionType) expect(fromDb.steps[1].actions[0].text).toEqual(step.actions[0].text) - expect(fromDb.steps[1].asset).not.toBeNull() - expect(fromDb.steps[1].asset!.mediaType).toEqual(asset.mediaType) - expect(fromDb.steps[1].asset!.fileName).toEqual(asset.fileName) - expect(fromDb.steps[1].asset!.description).toEqual(asset.description) - expect(fromDb.steps[1].asset!.content).toStrictEqual(asset.content) + const stepAsset = fromDb.steps[1].asset as Asset + expect(stepAsset).not.toBeNull() + expect(stepAsset!.mediaType).toEqual(asset.mediaType) + expect(stepAsset!.fileName).toEqual(asset.fileName) + expect(stepAsset!.description).toEqual(asset.description) + expect(stepAsset!.content).toStrictEqual(asset.content) expect(fromDb.steps[1].actions[0].proofRequest).not.toBeNull() expect(fromDb.steps[1].actions[0].proofRequest!.attributes).not.toBeNull() expect(fromDb.steps[1].actions[0].proofRequest!.attributes!.attribute1).toBeDefined() @@ -2382,11 +2396,12 @@ describe('Database scenario repository tests', (): void => { expect(fromDb.actions[0].title).toEqual(issuanceScenario.steps[0].actions[0].title) expect(fromDb.actions[0].actionType).toEqual(issuanceScenario.steps[0].actions[0].actionType) expect(fromDb.actions[0].text).toEqual(issuanceScenario.steps[0].actions[0].text) - expect(fromDb.asset).not.toBeNull() - expect(fromDb.asset!.mediaType).toEqual(asset.mediaType) - expect(fromDb.asset!.fileName).toEqual(asset.fileName) - expect(fromDb.asset!.description).toEqual(asset.description) - expect(fromDb.asset!.content).toStrictEqual(asset.content) + const dbAsset = fromDb.asset as Asset + expect(dbAsset).not.toBeNull() + expect(dbAsset!.mediaType).toEqual(asset.mediaType) + expect(dbAsset!.fileName).toEqual(asset.fileName) + expect(dbAsset!.description).toEqual(asset.description) + expect(dbAsset!.content).toStrictEqual(asset.content) expect(fromDb.actions[0].proofRequest).not.toBeNull() expect(fromDb.actions[0].proofRequest!.attributes).not.toBeNull() expect(fromDb.actions[0].proofRequest!.attributes!.attribute1).toBeDefined() @@ -2513,11 +2528,12 @@ describe('Database scenario repository tests', (): void => { expect(fromDb[0].actions[0].title).toEqual(issuanceScenario.steps[0].actions[0].title) expect(fromDb[0].actions[0].actionType).toEqual(issuanceScenario.steps[0].actions[0].actionType) expect(fromDb[0].actions[0].text).toEqual(issuanceScenario.steps[0].actions[0].text) - expect(fromDb[0].asset).not.toBeNull() - expect(fromDb[0].asset!.mediaType).toEqual(asset.mediaType) - expect(fromDb[0].asset!.fileName).toEqual(asset.fileName) - expect(fromDb[0].asset!.description).toEqual(asset.description) - expect(fromDb[0].asset!.content).toStrictEqual(asset.content) + const dbAsset = fromDb[0].asset as Asset + expect(dbAsset).not.toBeNull() + expect(dbAsset!.mediaType).toEqual(asset.mediaType) + expect(dbAsset!.fileName).toEqual(asset.fileName) + expect(dbAsset!.description).toEqual(asset.description) + expect(dbAsset!.content).toStrictEqual(asset.content) }) it('Should delete scenario step from database', async (): Promise => { @@ -2744,7 +2760,7 @@ describe('Database scenario repository tests', (): void => { }, }, ], - asset: savedIssuanceScenario.steps[0].asset!.id, + asset: (savedIssuanceScenario.steps[0].asset as Asset)!.id, } const updatedStepResult = await repository.updateStep(savedIssuanceScenario.id, savedIssuanceScenario.steps[0].id, updatedStep) @@ -2757,11 +2773,12 @@ describe('Database scenario repository tests', (): void => { expect(updatedStepResult.actions[0].title).toEqual(updatedStep.actions[0].title) expect(updatedStepResult.actions[0].actionType).toEqual(updatedStep.actions[0].actionType) expect(updatedStepResult.actions[0].text).toEqual(updatedStep.actions[0].text) - expect(updatedStepResult.asset).not.toBeNull() - expect(updatedStepResult.asset!.mediaType).toEqual(asset.mediaType) - expect(updatedStepResult.asset!.fileName).toEqual(asset.fileName) - expect(updatedStepResult.asset!.description).toEqual(asset.description) - expect(updatedStepResult.asset!.content).toStrictEqual(asset.content) + const updAsset = updatedStepResult.asset as Asset + expect(updAsset).not.toBeNull() + expect(updAsset!.mediaType).toEqual(asset.mediaType) + expect(updAsset!.fileName).toEqual(asset.fileName) + expect(updAsset!.description).toEqual(asset.description) + expect(updAsset!.content).toStrictEqual(asset.content) expect(updatedStepResult.actions[0].proofRequest).not.toBeNull() expect(updatedStepResult.actions[0].proofRequest!.attributes).not.toBeNull() expect(updatedStepResult.actions[0].proofRequest!.attributes!.attribute1).toBeDefined() @@ -2838,7 +2855,7 @@ describe('Database scenario repository tests', (): void => { const updatedStep: NewStep = { ...savedIssuanceScenario.steps[0], actions: [], - asset: savedIssuanceScenario.steps[0].asset!.id, + asset: (savedIssuanceScenario.steps[0].asset as Asset)!.id, } await expect(repository.updateStep(savedIssuanceScenario.id, savedIssuanceScenario.steps[0].id, updatedStep)).rejects.toThrowError( diff --git a/apps/credential-showcase-api-server/src/database/repositories/__tests__/showcase.repository.test.ts b/apps/credential-showcase-api-server/src/database/repositories/__tests__/showcase.repository.test.ts index 6fd92e2..fa195fb 100644 --- a/apps/credential-showcase-api-server/src/database/repositories/__tests__/showcase.repository.test.ts +++ b/apps/credential-showcase-api-server/src/database/repositories/__tests__/showcase.repository.test.ts @@ -394,10 +394,13 @@ describe('Database showcase repository tests', (): void => { expect(fromDb.description).toEqual(showcase.description) expect(fromDb.status).toEqual(showcase.status) expect(fromDb.hidden).toEqual(showcase.hidden) - expect(fromDb.scenarios).toEqual([]) - expect(fromDb.credentialDefinitions).toEqual([]) - expect(fromDb.personas).toEqual([]) - expect(fromDb.bannerImage).toBeNull() // bannerImage is undefined when not expanded + expect(fromDb.scenarios.length).toBeGreaterThan(0) + expect(fromDb.scenarios[0]).toBe(issuanceScenario1.id) + expect(fromDb.credentialDefinitions.length).toBeGreaterThan(0) + expect(fromDb.credentialDefinitions[0]).toBe(credentialDefinition1.id) + expect(fromDb.personas.length).toBeGreaterThan(0) + expect(fromDb.personas[0]).toBe(persona1.id) + expect(fromDb.bannerImage).toBeNull() // bannerImage is null when not expanded }) it('Should get showcase by id from database with all expands including asset content', async (): Promise => { diff --git a/apps/credential-showcase-api-server/src/types/schema/index.ts b/apps/credential-showcase-api-server/src/types/schema/index.ts index e9bd498..b123534 100644 --- a/apps/credential-showcase-api-server/src/types/schema/index.ts +++ b/apps/credential-showcase-api-server/src/types/schema/index.ts @@ -197,9 +197,9 @@ export type AriesProofRequest = typeof ariesProofRequests.$inferSelect export type NewAriesProofRequest = Omit export type Showcase = Omit & { - scenarios: (Scenario | string)[] - credentialDefinitions: (CredentialDefinition | string)[] - personas: (Persona | string)[] + scenarios: Scenario[] + credentialDefinitions: CredentialDefinition[] + personas: Persona[] bannerImage?: string | Asset | null } export type NewShowcase = Omit & { diff --git a/apps/credential-showcase-api-server/src/utils/mappers.ts b/apps/credential-showcase-api-server/src/utils/mappers.ts index 5879636..e04747c 100644 --- a/apps/credential-showcase-api-server/src/utils/mappers.ts +++ b/apps/credential-showcase-api-server/src/utils/mappers.ts @@ -9,7 +9,6 @@ import { PresentationScenario as PresentationScenarioDTO, RelyingParty as RelyingPartyDTO, Showcase as ShowcaseDTO, - ShowcasePersonasInner, Step as StepDTO, } from 'credential-showcase-openapi' import { @@ -62,8 +61,18 @@ export const credentialDefinitionDTOFrom = (credentialDefinition: CredentialDefi credentialSchema: credentialSchemaDTOFrom(credentialDefinition.credentialSchema), representations: credentialDefinition.representations, revocation: credentialDefinition.revocation || undefined, - iconId: typeof credentialDefinition.icon === 'string' ? credentialDefinition.icon : undefined, - icon: credentialDefinition.icon && typeof credentialDefinition.icon !== 'string' ? assetDTOFrom(credentialDefinition.icon as Asset) : undefined, +<<<<<<< Updated upstream + icon: + typeof credentialDefinition.icon === 'string' + ? { id: credentialDefinition.icon } + : credentialDefinition.icon + ? assetDTOFrom(credentialDefinition.icon as Asset) + : undefined, +======= + icon: typeof credentialDefinition.icon === 'string' + ? { id: credentialDefinition.icon } + : credentialDefinition.icon ? assetDTOFrom(credentialDefinition.icon as Asset) : undefined +>>>>>>> Stashed changes } } @@ -71,9 +80,16 @@ export const relyingPartyDTOFrom = (relyingParty: RelyingParty): RelyingPartyDTO return { ...relyingParty, organization: relyingParty.organization || undefined, - logoId: typeof relyingParty.logo === 'string' ? relyingParty.logo : undefined, - logo: relyingParty.logo && typeof relyingParty.logo !== 'string' ? assetDTOFrom(relyingParty.logo as Asset) : undefined, +<<<<<<< Updated upstream + logo: + typeof relyingParty.logo === 'string' ? { id: relyingParty.logo } : relyingParty.logo ? assetDTOFrom(relyingParty.logo as Asset) : undefined, credentialDefinitions: relyingParty.credentialDefinitions.map(credentialDefinitionDTOFrom), +======= + logo: typeof relyingParty.logo === 'string' + ? { id: relyingParty.logo } + : relyingParty.logo ? assetDTOFrom(relyingParty.logo as Asset) : undefined, + credentialDefinitions: relyingParty.credentialDefinitions.map(credentialDefinitionDTOFrom) +>>>>>>> Stashed changes } } @@ -81,10 +97,15 @@ export const issuerDTOFrom = (issuer: Issuer): IssuerDTO => { return { ...issuer, organization: issuer.organization || undefined, - logoId: typeof issuer.logo === 'string' ? issuer.logo : undefined, - logo: issuer.logo && typeof issuer.logo !== 'string' ? assetDTOFrom(issuer.logo as Asset) : undefined, +<<<<<<< Updated upstream + logo: typeof issuer.logo === 'string' ? { id: issuer.logo } : issuer.logo ? assetDTOFrom(issuer.logo as Asset) : undefined, +======= + logo: typeof issuer.logo === 'string' + ? { id: issuer.logo } + : issuer.logo ? assetDTOFrom(issuer.logo as Asset) : undefined, +>>>>>>> Stashed changes credentialDefinitions: issuer.credentialDefinitions.map(credentialDefinitionDTOFrom), - credentialSchemas: issuer.credentialSchemas.map(credentialSchemaDTOFrom), + credentialSchemas: issuer.credentialSchemas.map(credentialSchemaDTOFrom) } } @@ -99,6 +120,18 @@ export const issuanceScenarioDTOFrom = (issuanceScenario: IssuanceScenario): Iss type: ScenarioType.ISSUANCE, steps: issuanceScenario.steps.map(stepDTOFrom), personas: issuanceScenario.personas.map(personaDTOFrom), +<<<<<<< Updated upstream + bannerImage: + typeof issuanceScenario.bannerImage === 'string' + ? { id: issuanceScenario.bannerImage } + : issuanceScenario.bannerImage + ? assetDTOFrom(issuanceScenario.bannerImage as Asset) + : undefined, +======= + bannerImage: typeof issuanceScenario.bannerImage === 'string' + ? { id: issuanceScenario.bannerImage } + : issuanceScenario.bannerImage ? assetDTOFrom(issuanceScenario.bannerImage as Asset) : undefined +>>>>>>> Stashed changes } } @@ -113,6 +146,18 @@ export const presentationScenarioDTOFrom = (presentationScenario: PresentationSc type: ScenarioType.PRESENTATION, steps: presentationScenario.steps.map(stepDTOFrom), personas: presentationScenario.personas.map(personaDTOFrom), +<<<<<<< Updated upstream + bannerImage: + typeof presentationScenario.bannerImage === 'string' + ? { id: presentationScenario.bannerImage } + : presentationScenario.bannerImage + ? assetDTOFrom(presentationScenario.bannerImage as Asset) + : undefined, +======= + bannerImage: typeof presentationScenario.bannerImage === 'string' + ? { id: presentationScenario.bannerImage } + : presentationScenario.bannerImage ? assetDTOFrom(presentationScenario.bannerImage as Asset) : undefined +>>>>>>> Stashed changes } } @@ -130,43 +175,76 @@ export const scenarioDTOFrom = (scenario: Scenario): IssuanceScenarioDTO | Prese export const stepDTOFrom = (step: Step): StepDTO => { return { ...step, - assetId: typeof step.asset === 'string' ? step.asset : undefined, - asset: step.asset && typeof step.asset !== 'string' ? assetDTOFrom(step.asset as Asset) : undefined, +<<<<<<< Updated upstream + asset: typeof step.asset === 'string' ? { id: step.asset } : step.asset ? assetDTOFrom(step.asset as Asset) : undefined, subScenario: step.subScenario || undefined, +======= + asset: typeof step.asset === 'string' + ? { id: step.asset } + : step.asset ? assetDTOFrom(step.asset as Asset) : undefined, + subScenario: step.subScenario || undefined +>>>>>>> Stashed changes } } export const personaDTOFrom = (persona: Persona): PersonaDTO => { return { ...persona, - headshotImageId: typeof persona.headshotImage === 'string' ? persona.headshotImage : undefined, - headshotImage: persona.headshotImage && typeof persona.headshotImage !== 'string' ? assetDTOFrom(persona.headshotImage as Asset) : undefined, - bodyImageId: typeof persona.bodyImage === 'string' ? persona.bodyImage : undefined, - bodyImage: persona.bodyImage && typeof persona.bodyImage !== 'string' ? assetDTOFrom(persona.bodyImage as Asset) : undefined, - hidden: persona.hidden, - } -} - -export const showcasePersonaDTOFrom = (persona: Persona): ShowcasePersonasInner => { - return { - ...persona, - headshotImageId: typeof persona.headshotImage === 'string' ? persona.headshotImage : undefined, - headshotImage: persona.headshotImage && typeof persona.headshotImage !== 'string' ? assetDTOFrom(persona.headshotImage as Asset) : undefined, - bodyImageId: typeof persona.bodyImage === 'string' ? persona.bodyImage : undefined, - bodyImage: persona.bodyImage && typeof persona.bodyImage !== 'string' ? assetDTOFrom(persona.bodyImage as Asset) : undefined, +<<<<<<< Updated upstream + headshotImage: + typeof persona.headshotImage === 'string' + ? { id: persona.headshotImage } + : persona.headshotImage + ? assetDTOFrom(persona.headshotImage as Asset) + : undefined, + bodyImage: + typeof persona.bodyImage === 'string' ? { id: persona.bodyImage } : persona.bodyImage ? assetDTOFrom(persona.bodyImage as Asset) : undefined, hidden: persona.hidden, +======= + headshotImage: typeof persona.headshotImage === 'string' + ? { id: persona.headshotImage } + : persona.headshotImage ? assetDTOFrom(persona.headshotImage as Asset) : undefined, + bodyImage: typeof persona.bodyImage === 'string' + ? { id: persona.bodyImage } + : persona.bodyImage ? assetDTOFrom(persona.bodyImage as Asset) : undefined, + hidden: persona.hidden +>>>>>>> Stashed changes } } export const showcaseDTOFrom = (showcase: Showcase): ShowcaseDTO => { return { ...showcase, - personas: [], // showcase.personas.map(showcasePersonaDTOFrom as Persona), // FIXME - credentialDefinitions: showcase.credentialDefinitions.map(credentialDefinitionDTOFrom), - scenarios: showcase.scenarios.map(scenarioDTOFrom), - bannerImageId: typeof showcase.bannerImage === 'string' ? showcase.bannerImage : undefined, - bannerImage: showcase.bannerImage && typeof showcase.bannerImage !== 'string' ? assetDTOFrom(showcase.bannerImage as Asset) : undefined, +<<<<<<< Updated upstream + personas: showcase.personas.map((persona) => (typeof persona === 'string' ? { id: persona } : personaDTOFrom(persona as Persona))), + credentialDefinitions: showcase.credentialDefinitions.map((credentialDef) => + typeof credentialDef === 'string' ? { id: credentialDef } : credentialDefinitionDTOFrom(credentialDef as CredentialDefinition), + ), + scenarios: showcase.scenarios.map((scenario) => (typeof scenario === 'string' ? { id: scenario } : scenarioDTOFrom(scenario as Scenario))), + bannerImage: + typeof showcase.bannerImage === 'string' + ? { id: showcase.bannerImage } + : showcase.bannerImage + ? assetDTOFrom(showcase.bannerImage as Asset) + : undefined, completionMessage: showcase.completionMessage || undefined, +======= + personas: showcase.personas.map(persona => + typeof persona === 'string' + ? { id: persona } + : personaDTOFrom(persona as Persona)), + credentialDefinitions: showcase.credentialDefinitions.map(credentialDef => + typeof credentialDef === 'string' + ? { id: credentialDef } + : credentialDefinitionDTOFrom(credentialDef as CredentialDefinition)), + scenarios: showcase.scenarios.map(scenario => + typeof scenario === 'string' + ? { id: scenario } + : scenarioDTOFrom(scenario as Scenario)), bannerImage: typeof showcase.bannerImage === 'string' + ? { id: showcase.bannerImage } + : showcase.bannerImage ? assetDTOFrom(showcase.bannerImage as Asset) : undefined, + completionMessage: showcase.completionMessage || undefined +>>>>>>> Stashed changes } } diff --git a/packages/credential-showcase-openapi/openapi/openapi.yaml b/packages/credential-showcase-openapi/openapi/openapi.yaml index 998ed7f..2f0eb18 100644 --- a/packages/credential-showcase-openapi/openapi/openapi.yaml +++ b/packages/credential-showcase-openapi/openapi/openapi.yaml @@ -1675,23 +1675,10 @@ components: openIdConnectUrl: description: OpenID Connect security scheme for OAuth2 flows schemas: - Id: - type: object - required: - - id - properties: - id: - type: string - description: item id - example: 123e4567-e89b-12d3-a456-426614174469 Asset: type: object required: - id - - mediaType - - content - - createdAt - - updatedAt properties: id: type: string @@ -2070,12 +2057,6 @@ components: type: object required: - id - - name - - slug - - role - - description - - createdAt - - updatedAt properties: id: type: string @@ -2097,14 +2078,8 @@ components: type: string description: Detailed description of the persona example: John Doe is a verifier for the system - headshotImageId: - type: string - description: The asset id headshotImage: $ref: '#/components/schemas/Asset' - bodyImageId: - type: string - description: The asset id bodyImage: $ref: '#/components/schemas/Asset' hidden: @@ -2165,14 +2140,6 @@ components: type: object required: - id - - name - - slug - - type - - description - - steps - - personas - - createdAt - - updatedAt properties: id: type: string @@ -2216,6 +2183,8 @@ components: description: Date and time the scenario was last updated format: date-time example: 2025-03-06T11:30:16.573Z + bannerImage: + $ref: '#/components/schemas/Asset' ScenarioRequest: type: object required: @@ -2567,14 +2536,6 @@ components: type: object required: - id - - name - - version - - type - - credentialSchema - # TODO enable back in SHOWCASE-81 - # - representations - - createdAt - - updatedAt properties: id: type: string @@ -2952,26 +2913,17 @@ components: type: array description: List of scenarios in this showcase items: - oneOf: - - $ref: '#/components/schemas/Scenario' - - $ref: '#/components/schemas/Id' + $ref: '#/components/schemas/Scenario' credentialDefinitions: type: array description: List of credential definitions used in this showcase items: - oneOf: - - $ref: '#/components/schemas/CredentialDefinition' - - $ref: '#/components/schemas/Id' + $ref: '#/components/schemas/CredentialDefinition' personas: type: object description: List of personas involved in this showcase items: - oneOf: - - $ref: '#/components/schemas/Persona' - - $ref: '#/components/schemas/Id' - bannerImageId: - type: string - description: The asset id + $ref: '#/components/schemas/Persona' bannerImage: $ref: '#/components/schemas/Asset' completionMessage: From c7a85fae6400da4581151ec8a2885dd52888a125 Mon Sep 17 00:00:00 2001 From: sanderPostma Date: Mon, 17 Mar 2025 18:03:50 +0100 Subject: [PATCH 8/8] chore: final fixes --- .husky/pre-commit | 6 ++ .../src/controllers/ShowcaseController.ts | 4 -- .../__tests__/issuer.repository.test.ts | 12 ---- .../src/utils/mappers.ts | 68 +------------------ 4 files changed, 7 insertions(+), 83 deletions(-) diff --git a/.husky/pre-commit b/.husky/pre-commit index 1cc03ec..513ca56 100755 --- a/.husky/pre-commit +++ b/.husky/pre-commit @@ -1,3 +1,9 @@ +# Check if prettier would make changes +if ! pnpm prettier --check; then + echo "Error: Prettier check failed. Please format your code before committing." + echo "You can run 'pnpm prettier' to fix formatting issues." + exit 1 +fi # Stash unstaged and untracked changes, keeping staged files intact stash_ref=$(git stash push --keep-index --include-untracked -m "pre-commit-$(date +%s)") diff --git a/apps/credential-showcase-api-server/src/controllers/ShowcaseController.ts b/apps/credential-showcase-api-server/src/controllers/ShowcaseController.ts index f9c6add..b5bd6ab 100644 --- a/apps/credential-showcase-api-server/src/controllers/ShowcaseController.ts +++ b/apps/credential-showcase-api-server/src/controllers/ShowcaseController.ts @@ -54,11 +54,7 @@ class ShowcaseController { if (!instanceOfShowcaseRequest(showcaseRequest)) { return Promise.reject(new BadRequestError()) } -<<<<<<< Updated upstream const result = await this.showcaseService.createShowcase({ showcase: ShowcaseRequestToJSONTyped(showcaseRequest) }) -======= - const result = await this.showcaseService.createShowcase({showcase: ShowcaseRequestToJSONTyped(showcaseRequest)}) ->>>>>>> Stashed changes return ShowcaseResponseFromJSONTyped({ showcase: showcaseDTOFrom(result) }, false) } catch (e) { if (e.httpCode !== 404) { diff --git a/apps/credential-showcase-api-server/src/database/repositories/__tests__/issuer.repository.test.ts b/apps/credential-showcase-api-server/src/database/repositories/__tests__/issuer.repository.test.ts index eb02800..866f75a 100644 --- a/apps/credential-showcase-api-server/src/database/repositories/__tests__/issuer.repository.test.ts +++ b/apps/credential-showcase-api-server/src/database/repositories/__tests__/issuer.repository.test.ts @@ -122,11 +122,7 @@ describe('Database issuer repository tests', (): void => { expect(savedIssuer.description).toEqual(issuer.description) expect(savedIssuer.organization).toEqual(issuer.organization) expect(savedIssuer.credentialDefinitions.length).toEqual(2) -<<<<<<< Updated upstream const logoAsset = savedIssuer.logo as Asset -======= - const logoAsset = savedIssuer.logo as Asset ->>>>>>> Stashed changes expect(logoAsset).not.toBeNull() expect(logoAsset!.id).toBeDefined() expect(logoAsset!.mediaType).toEqual(asset.mediaType) @@ -215,11 +211,7 @@ describe('Database issuer repository tests', (): void => { expect(fromDb.description).toEqual(issuer.description) expect(fromDb.organization).toEqual(issuer.organization) expect(fromDb.credentialDefinitions.length).toEqual(2) -<<<<<<< Updated upstream const logoAsset = fromDb.logo as Asset -======= - const logoAsset = fromDb.logo as Asset ->>>>>>> Stashed changes expect(logoAsset).not.toBeNull() expect(logoAsset!.id).toBeDefined() expect(logoAsset!.mediaType).toEqual(asset.mediaType) @@ -296,11 +288,7 @@ describe('Database issuer repository tests', (): void => { expect(updatedIssuer.description).toEqual(issuer.description) expect(updatedIssuer.organization).toEqual(issuer.organization) expect(updatedIssuer.credentialDefinitions.length).toEqual(1) -<<<<<<< Updated upstream const logoAsset = updatedIssuer.logo as Asset -======= - const logoAsset = updatedIssuer.logo as Asset ->>>>>>> Stashed changes expect(logoAsset).not.toBeNull() expect(logoAsset!.id).toBeDefined() expect(logoAsset!.mediaType).toEqual(asset.mediaType) diff --git a/apps/credential-showcase-api-server/src/utils/mappers.ts b/apps/credential-showcase-api-server/src/utils/mappers.ts index e04747c..0c91057 100644 --- a/apps/credential-showcase-api-server/src/utils/mappers.ts +++ b/apps/credential-showcase-api-server/src/utils/mappers.ts @@ -61,18 +61,12 @@ export const credentialDefinitionDTOFrom = (credentialDefinition: CredentialDefi credentialSchema: credentialSchemaDTOFrom(credentialDefinition.credentialSchema), representations: credentialDefinition.representations, revocation: credentialDefinition.revocation || undefined, -<<<<<<< Updated upstream icon: typeof credentialDefinition.icon === 'string' ? { id: credentialDefinition.icon } : credentialDefinition.icon ? assetDTOFrom(credentialDefinition.icon as Asset) : undefined, -======= - icon: typeof credentialDefinition.icon === 'string' - ? { id: credentialDefinition.icon } - : credentialDefinition.icon ? assetDTOFrom(credentialDefinition.icon as Asset) : undefined ->>>>>>> Stashed changes } } @@ -80,16 +74,9 @@ export const relyingPartyDTOFrom = (relyingParty: RelyingParty): RelyingPartyDTO return { ...relyingParty, organization: relyingParty.organization || undefined, -<<<<<<< Updated upstream logo: typeof relyingParty.logo === 'string' ? { id: relyingParty.logo } : relyingParty.logo ? assetDTOFrom(relyingParty.logo as Asset) : undefined, credentialDefinitions: relyingParty.credentialDefinitions.map(credentialDefinitionDTOFrom), -======= - logo: typeof relyingParty.logo === 'string' - ? { id: relyingParty.logo } - : relyingParty.logo ? assetDTOFrom(relyingParty.logo as Asset) : undefined, - credentialDefinitions: relyingParty.credentialDefinitions.map(credentialDefinitionDTOFrom) ->>>>>>> Stashed changes } } @@ -97,15 +84,9 @@ export const issuerDTOFrom = (issuer: Issuer): IssuerDTO => { return { ...issuer, organization: issuer.organization || undefined, -<<<<<<< Updated upstream logo: typeof issuer.logo === 'string' ? { id: issuer.logo } : issuer.logo ? assetDTOFrom(issuer.logo as Asset) : undefined, -======= - logo: typeof issuer.logo === 'string' - ? { id: issuer.logo } - : issuer.logo ? assetDTOFrom(issuer.logo as Asset) : undefined, ->>>>>>> Stashed changes credentialDefinitions: issuer.credentialDefinitions.map(credentialDefinitionDTOFrom), - credentialSchemas: issuer.credentialSchemas.map(credentialSchemaDTOFrom) + credentialSchemas: issuer.credentialSchemas.map(credentialSchemaDTOFrom), } } @@ -120,18 +101,12 @@ export const issuanceScenarioDTOFrom = (issuanceScenario: IssuanceScenario): Iss type: ScenarioType.ISSUANCE, steps: issuanceScenario.steps.map(stepDTOFrom), personas: issuanceScenario.personas.map(personaDTOFrom), -<<<<<<< Updated upstream bannerImage: typeof issuanceScenario.bannerImage === 'string' ? { id: issuanceScenario.bannerImage } : issuanceScenario.bannerImage ? assetDTOFrom(issuanceScenario.bannerImage as Asset) : undefined, -======= - bannerImage: typeof issuanceScenario.bannerImage === 'string' - ? { id: issuanceScenario.bannerImage } - : issuanceScenario.bannerImage ? assetDTOFrom(issuanceScenario.bannerImage as Asset) : undefined ->>>>>>> Stashed changes } } @@ -146,18 +121,12 @@ export const presentationScenarioDTOFrom = (presentationScenario: PresentationSc type: ScenarioType.PRESENTATION, steps: presentationScenario.steps.map(stepDTOFrom), personas: presentationScenario.personas.map(personaDTOFrom), -<<<<<<< Updated upstream bannerImage: typeof presentationScenario.bannerImage === 'string' ? { id: presentationScenario.bannerImage } : presentationScenario.bannerImage ? assetDTOFrom(presentationScenario.bannerImage as Asset) : undefined, -======= - bannerImage: typeof presentationScenario.bannerImage === 'string' - ? { id: presentationScenario.bannerImage } - : presentationScenario.bannerImage ? assetDTOFrom(presentationScenario.bannerImage as Asset) : undefined ->>>>>>> Stashed changes } } @@ -175,22 +144,14 @@ export const scenarioDTOFrom = (scenario: Scenario): IssuanceScenarioDTO | Prese export const stepDTOFrom = (step: Step): StepDTO => { return { ...step, -<<<<<<< Updated upstream asset: typeof step.asset === 'string' ? { id: step.asset } : step.asset ? assetDTOFrom(step.asset as Asset) : undefined, subScenario: step.subScenario || undefined, -======= - asset: typeof step.asset === 'string' - ? { id: step.asset } - : step.asset ? assetDTOFrom(step.asset as Asset) : undefined, - subScenario: step.subScenario || undefined ->>>>>>> Stashed changes } } export const personaDTOFrom = (persona: Persona): PersonaDTO => { return { ...persona, -<<<<<<< Updated upstream headshotImage: typeof persona.headshotImage === 'string' ? { id: persona.headshotImage } @@ -200,22 +161,12 @@ export const personaDTOFrom = (persona: Persona): PersonaDTO => { bodyImage: typeof persona.bodyImage === 'string' ? { id: persona.bodyImage } : persona.bodyImage ? assetDTOFrom(persona.bodyImage as Asset) : undefined, hidden: persona.hidden, -======= - headshotImage: typeof persona.headshotImage === 'string' - ? { id: persona.headshotImage } - : persona.headshotImage ? assetDTOFrom(persona.headshotImage as Asset) : undefined, - bodyImage: typeof persona.bodyImage === 'string' - ? { id: persona.bodyImage } - : persona.bodyImage ? assetDTOFrom(persona.bodyImage as Asset) : undefined, - hidden: persona.hidden ->>>>>>> Stashed changes } } export const showcaseDTOFrom = (showcase: Showcase): ShowcaseDTO => { return { ...showcase, -<<<<<<< Updated upstream personas: showcase.personas.map((persona) => (typeof persona === 'string' ? { id: persona } : personaDTOFrom(persona as Persona))), credentialDefinitions: showcase.credentialDefinitions.map((credentialDef) => typeof credentialDef === 'string' ? { id: credentialDef } : credentialDefinitionDTOFrom(credentialDef as CredentialDefinition), @@ -228,23 +179,6 @@ export const showcaseDTOFrom = (showcase: Showcase): ShowcaseDTO => { ? assetDTOFrom(showcase.bannerImage as Asset) : undefined, completionMessage: showcase.completionMessage || undefined, -======= - personas: showcase.personas.map(persona => - typeof persona === 'string' - ? { id: persona } - : personaDTOFrom(persona as Persona)), - credentialDefinitions: showcase.credentialDefinitions.map(credentialDef => - typeof credentialDef === 'string' - ? { id: credentialDef } - : credentialDefinitionDTOFrom(credentialDef as CredentialDefinition)), - scenarios: showcase.scenarios.map(scenario => - typeof scenario === 'string' - ? { id: scenario } - : scenarioDTOFrom(scenario as Scenario)), bannerImage: typeof showcase.bannerImage === 'string' - ? { id: showcase.bannerImage } - : showcase.bannerImage ? assetDTOFrom(showcase.bannerImage as Asset) : undefined, - completionMessage: showcase.completionMessage || undefined ->>>>>>> Stashed changes } }