repo_id
stringclasses 563
values | file_path
stringlengths 40
166
| content
stringlengths 1
2.94M
| __index_level_0__
int64 0
0
|
|---|---|---|---|
solana_public_repos/nautilus-project/nautilus/tests
|
solana_public_repos/nautilus-project/nautilus/tests/tests/all-tests.sh
|
echo "\n\n================================================="
echo "\n Nautilus Program Tests"
echo "\n\n================================================="
sleep 2
echo "\nBuilding all test programs...\n"
sleep 5
cargo build-sbf --manifest-path="./programs/wallets/Cargo.toml"
cargo build-sbf --manifest-path="./programs/tokens/Cargo.toml"
cargo build-sbf --manifest-path="./programs/records/Cargo.toml"
cargo build-sbf --manifest-path="./programs/accounts/Cargo.toml"
echo "\nDeploying all test programs...\n"
solana program deploy ./programs/wallets/target/deploy/program_nautilus.so
solana program deploy ./programs/tokens/target/deploy/program_nautilus.so
solana program deploy ./programs/records/target/deploy/program_nautilus.so
solana program deploy ./programs/accounts/target/deploy/program_nautilus.so
echo "\nCommencing all tests...\n"
yarn
sleep 3
echo "\nLaunching test suite: Wallets\n"
yarn run test-wallets
sleep 5
echo "\nLaunching test suite: Tokens\n"
yarn run test-tokens
sleep 5
echo "\nLaunching test suite: Records\n"
yarn run test-records
sleep 5
echo "\nLaunching test suite: Accounts\n"
yarn run test-accounts
sleep 5
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests
|
solana_public_repos/nautilus-project/nautilus/tests/tests/records/test.ts
|
import {
it,
describe,
} from 'mocha'
import {
Keypair,
LAMPORTS_PER_SOL,
sendAndConfirmTransaction,
Transaction,
TransactionInstruction,
} from '@solana/web3.js'
import { PAYER, PROGRAM_RECORDS, TEST_CONFIGS } from '../const'
import {
MyInstructions,
createCreateCarInstruction,
createCreateHomeInstruction,
createCreatePersonInstruction,
createFundCarInstruction,
createFundHomeInstruction,
createFundPersonInstruction,
createInitializeInstruction,
createReadCarInstruction,
createReadHomeInstruction,
createReadPersonInstruction,
createTransferFromCarInstruction,
createTransferFromHomeInstruction,
createTransferFromPersonInstruction,
} from './instructions'
describe("Nautilus Unit Tests: Create Records", async () => {
const connection = TEST_CONFIGS.connection
const payer = PAYER
const program = PROGRAM_RECORDS
const personName = "Joe"
const homeId = 1
const homeHouseNumber = 15
const homeStreet = "Solana St."
const carMake = "Chevrolet"
const carModel = "Corvette"
const fundTransferAmount = LAMPORTS_PER_SOL / 1000
async function test(ix: TransactionInstruction, signers: Keypair[]) {
TEST_CONFIGS.sleep()
let sx = await sendAndConfirmTransaction(
connection,
new Transaction().add(ix),
signers,
{skipPreflight: true}
)
console.log(`\n\n [INFO]: sig: ${sx}\n`)
}
it("Initialize Nautilus Index", async () => test(
createInitializeInstruction(payer.publicKey, program.publicKey),
[payer],
))
it("Create Person", async () => test(
await createCreatePersonInstruction(payer.publicKey, program.publicKey, personName, payer.publicKey),
[payer],
))
it("Read Person", async () => test(
await createReadPersonInstruction(program.publicKey),
[payer],
))
it("Create Home", async () => test(
createCreateHomeInstruction(payer.publicKey, program.publicKey, homeId, homeHouseNumber, homeStreet),
[payer],
))
it("Read Home", async () => test(
createReadHomeInstruction(program.publicKey, homeId),
[payer],
))
it("Create Car", async () => test(
await createCreateCarInstruction(payer.publicKey, program.publicKey, carMake, carModel, payer.publicKey, payer.publicKey),
[payer],
))
it("Read Car", async () => test(
await createReadCarInstruction(program.publicKey),
[payer],
))
it("Fund Person", async () => test(
await createFundPersonInstruction(payer.publicKey, program.publicKey, fundTransferAmount),
[payer],
))
it("Transfer from Person", async () => test(
await createTransferFromPersonInstruction(payer.publicKey, program.publicKey, fundTransferAmount),
[payer],
))
it("Fund Home", async () => test(
await createFundHomeInstruction(payer.publicKey, program.publicKey, fundTransferAmount, homeId),
[payer],
))
it("Transfer from Home", async () => test(
await createTransferFromHomeInstruction(payer.publicKey, program.publicKey, fundTransferAmount, homeId),
[payer],
))
it("Fund Car", async () => test(
await createFundCarInstruction(payer.publicKey, program.publicKey, fundTransferAmount),
[payer],
))
it("Transfer from Car", async () => test(
await createTransferFromCarInstruction(payer.publicKey, program.publicKey, fundTransferAmount),
[payer],
))
})
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests/records
|
solana_public_repos/nautilus-project/nautilus/tests/tests/records/instructions/car.ts
|
import * as borsh from "borsh"
import { Buffer } from "buffer"
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction
} from '@solana/web3.js'
import { createBaseInstruction, fetchIndex, MyInstructions } from "."
import assert from "assert"
class CreateCarInstructionData {
instruction: MyInstructions
make: string
model: string
purchase_authority: Uint8Array
operating_authority: Uint8Array
constructor(props: {
instruction: MyInstructions,
make: string,
model: string,
purchase_authority: PublicKey,
operating_authority: PublicKey,
}) {
this.instruction = props.instruction
this.make = props.make
this.model = props.model
this.purchase_authority = props.purchase_authority.toBuffer()
this.operating_authority = props.operating_authority.toBuffer()
}
toBuffer() {
return Buffer.from(borsh.serialize(CreateCarInstructionDataSchema, this))
}
}
const CreateCarInstructionDataSchema = new Map([
[ CreateCarInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
['make', 'string'],
['model', 'string'],
['purchase_authority', [32]],
['operating_authority', [32]],
],
}]
])
export function deriveCarAddress(programId: PublicKey, id: number): PublicKey {
return PublicKey.findProgramAddressSync(
[Buffer.from("car"), Buffer.from(Uint8Array.of(id))],
programId
)[0]
}
function createInstruction(
index: PublicKey,
newRecord: PublicKey,
payer: PublicKey,
programId: PublicKey,
make: string,
model: string,
purchase_authority: PublicKey,
operating_authority: PublicKey,
): TransactionInstruction {
const myInstructionObject = new CreateCarInstructionData({
instruction: MyInstructions.CreateCar,
make,
model,
purchase_authority,
operating_authority,
})
const keys = [
{pubkey: index, isSigner: false, isWritable: true},
{pubkey: newRecord, isSigner: false, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
]
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
export async function createCreateCarInstruction(
payer: PublicKey,
programId: PublicKey,
make: string,
model: string,
purchase_authority: PublicKey,
operating_authority: PublicKey,
): Promise<TransactionInstruction> {
const index = await fetchIndex(programId)
const currentId = index[1].get("car");
assert(currentId != undefined)
const newRecord = deriveCarAddress(programId, currentId + 1)
return createInstruction(index[0], newRecord, payer, programId, make, model, purchase_authority, operating_authority)
}
export async function createReadCarInstruction(
programId: PublicKey,
): Promise<TransactionInstruction> {
const index = await fetchIndex(programId)
const currentId = index[1].get("car");
assert(currentId != undefined)
const record = deriveCarAddress(programId, currentId + 1) // TODO
return createBaseInstruction(
programId,
MyInstructions.ReadCar,
[
{pubkey: index[0], isSigner: false, isWritable: false},
{pubkey: record, isSigner: false, isWritable: false},
],
)
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests/records
|
solana_public_repos/nautilus-project/nautilus/tests/tests/records/instructions/transfer.ts
|
import * as borsh from "borsh"
import { Buffer } from "buffer"
import {
PublicKey,
SystemProgram,
TransactionInstruction
} from '@solana/web3.js'
import { MyInstructions, deriveCarAddress, deriveHomeAddress, derivePersonAddress, fetchIndex } from "."
import assert from "assert"
class FundOrTransferInstructionData {
instruction: MyInstructions
amount: number
constructor(props: {
instruction: MyInstructions,
amount: number,
}) {
this.instruction = props.instruction
this.amount = props.amount
}
toBuffer() {
return Buffer.from(borsh.serialize(FundOrTransferInstructionDataSchema, this))
}
}
const FundOrTransferInstructionDataSchema = new Map([
[ FundOrTransferInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
['amount', 'u64'],
],
}]
])
function createInstruction(
programId: PublicKey,
amount: number,
instruction: MyInstructions,
keys: {pubkey: PublicKey, isSigner: boolean, isWritable: boolean}[]
): TransactionInstruction {
const myInstructionObject = new FundOrTransferInstructionData({instruction, amount})
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
export async function createFundPersonInstruction(
payer: PublicKey,
programId: PublicKey,
amount: number,
): Promise<TransactionInstruction> {
const index = await fetchIndex(programId)
const currentId = index[1].get("person");
assert(currentId != undefined)
const record = derivePersonAddress(programId, currentId + 1)
const keys = [
{pubkey: index[0], isSigner: false, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: record, isSigner: false, isWritable: true},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
]
return createInstruction(programId, amount, MyInstructions.FundPerson, keys)
}
export async function createTransferFromPersonInstruction(
recipient: PublicKey,
programId: PublicKey,
amount: number,
): Promise<TransactionInstruction> {
const index = await fetchIndex(programId)
const currentId = index[1].get("person");
assert(currentId != undefined)
const record = derivePersonAddress(programId, currentId + 1)
const keys = [
{pubkey: index[0], isSigner: false, isWritable: true},
{pubkey: record, isSigner: false, isWritable: true},
{pubkey: recipient, isSigner: false, isWritable: true},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
]
return createInstruction(programId, amount, MyInstructions.TransferFromPerson, keys)
}
export async function createFundHomeInstruction(
payer: PublicKey,
programId: PublicKey,
amount: number,
homeId: number
): Promise<TransactionInstruction> {
const index = await fetchIndex(programId)
const record = deriveHomeAddress(programId, homeId)
const keys = [
{pubkey: index[0], isSigner: false, isWritable: true},
{pubkey: record, isSigner: false, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
]
return createInstruction(programId, amount, MyInstructions.FundHome, keys)
}
export async function createTransferFromHomeInstruction(
recipient: PublicKey,
programId: PublicKey,
amount: number,
homeId: number,
): Promise<TransactionInstruction> {
const index = await fetchIndex(programId)
const record = deriveHomeAddress(programId, homeId)
const keys = [
{pubkey: index[0], isSigner: false, isWritable: true},
{pubkey: record, isSigner: false, isWritable: true},
{pubkey: recipient, isSigner: false, isWritable: true},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
]
return createInstruction(programId, amount, MyInstructions.TransferFromHome, keys)
}
export async function createFundCarInstruction(
payer: PublicKey,
programId: PublicKey,
amount: number,
): Promise<TransactionInstruction> {
const index = await fetchIndex(programId)
const currentId = index[1].get("car");
assert(currentId != undefined)
const record = deriveCarAddress(programId, currentId + 1)
const keys = [
{pubkey: index[0], isSigner: false, isWritable: true},
{pubkey: record, isSigner: false, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
]
return createInstruction(programId, amount, MyInstructions.FundCar, keys)
}
export async function createTransferFromCarInstruction(
recipient: PublicKey,
programId: PublicKey,
amount: number,
): Promise<TransactionInstruction> {
const index = await fetchIndex(programId)
const currentId = index[1].get("car");
assert(currentId != undefined)
const record = deriveCarAddress(programId, currentId + 1)
const keys = [
{pubkey: index[0], isSigner: false, isWritable: true},
{pubkey: record, isSigner: false, isWritable: true},
{pubkey: recipient, isSigner: false, isWritable: true},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
]
return createInstruction(programId, amount, MyInstructions.TransferFromCar, keys)
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests/records
|
solana_public_repos/nautilus-project/nautilus/tests/tests/records/instructions/index.ts
|
export * from './car'
export * from './home'
export * from './person'
export * from './transfer'
import { PublicKey, SYSVAR_RENT_PUBKEY, SystemProgram, TransactionInstruction } from '@solana/web3.js'
import * as borsh from "borsh"
import { Buffer } from "buffer"
import { TEST_CONFIGS } from '../../const'
export enum MyInstructions {
Initialize,
CreatePerson,
ReadPerson,
CreateHome,
ReadHome,
CreateCar,
ReadCar,
FundPerson,
TransferFromPerson,
FundHome,
TransferFromHome,
FundCar,
TransferFromCar,
}
export class BaseInstructionData {
instruction: MyInstructions
constructor(props: {
instruction: MyInstructions,
}) {
this.instruction = props.instruction
}
toBuffer() {
return Buffer.from(borsh.serialize(BaseInstructionDataSchema, this))
}
}
const BaseInstructionDataSchema = new Map([
[ BaseInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
],
}]
])
export function createBaseInstruction(
programId: PublicKey,
instruction: MyInstructions,
keys: {pubkey: PublicKey, isSigner: boolean, isWritable: boolean}[],
): TransactionInstruction {
const myInstructionObject = new BaseInstructionData({instruction})
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
export function deriveIndexAddress(programId: PublicKey): PublicKey {
return PublicKey.findProgramAddressSync(
[Buffer.from("nautilus_index"), Buffer.from(Uint8Array.of(0))],
programId
)[0]
}
export async function fetchIndex(programId: PublicKey): Promise<[PublicKey, Map<string, number>]> {
const connection = TEST_CONFIGS.connection
const indexPubkey = deriveIndexAddress(programId)
const indexAccountInfo = await connection.getAccountInfo(indexPubkey)
return [indexPubkey ,new Map<string, number>([
["person", 0],
["home", 0],
["car", 0],
])] // TODO
}
export function createInitializeInstruction(payer: PublicKey, programId: PublicKey): TransactionInstruction {
const indexPubkey = deriveIndexAddress(programId)
console.log(` [INFO]: Index: ${indexPubkey.toBase58()}`)
return createBaseInstruction(
programId,
MyInstructions.Initialize,
[
{pubkey: indexPubkey, isSigner: false, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
],
)
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests/records
|
solana_public_repos/nautilus-project/nautilus/tests/tests/records/instructions/home.ts
|
import * as borsh from "borsh"
import { Buffer } from "buffer"
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction
} from '@solana/web3.js'
import { createBaseInstruction, deriveIndexAddress, fetchIndex, MyInstructions } from "."
class CreateHomeInstructionData {
instruction: MyInstructions
id: number
house_number: number
street: string
constructor(props: {
instruction: MyInstructions,
id: number,
house_number: number,
street: string,
}) {
this.instruction = props.instruction
this.id = props.id
this.house_number = props.house_number
this.street = props.street
}
toBuffer() {
return Buffer.from(borsh.serialize(CreateHomeInstructionDataSchema, this))
}
}
const CreateHomeInstructionDataSchema = new Map([
[ CreateHomeInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
['id', 'u8'],
['house_number', 'u8'],
['street', 'string'],
],
}]
])
export function deriveHomeAddress(programId: PublicKey, id: number): PublicKey {
return PublicKey.findProgramAddressSync(
[Buffer.from("home"), Buffer.from(Uint8Array.of(id))],
programId
)[0]
}
function createInstruction(
index: PublicKey,
newRecord: PublicKey,
payer: PublicKey,
programId: PublicKey,
id: number,
house_number: number,
street: string,
): TransactionInstruction {
const myInstructionObject = new CreateHomeInstructionData({
instruction: MyInstructions.CreateHome,
id,
house_number,
street,
})
const keys = [
{pubkey: index, isSigner: false, isWritable: true},
{pubkey: newRecord, isSigner: false, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
]
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
export function createCreateHomeInstruction(
payer: PublicKey,
programId: PublicKey,
id: number,
house_number: number,
street: string,
): TransactionInstruction {
const index = deriveIndexAddress(programId)
const newRecord = deriveHomeAddress(programId, id)
return createInstruction(index, newRecord, payer, programId, id, house_number, street)
}
export function createReadHomeInstruction(
programId: PublicKey,
id: number,
): TransactionInstruction {
const index = deriveIndexAddress(programId)
const record = deriveHomeAddress(programId, id)
return createBaseInstruction(
programId,
MyInstructions.ReadHome,
[
{pubkey: index, isSigner: false, isWritable: false},
{pubkey: record, isSigner: false, isWritable: false},
],
)
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests/records
|
solana_public_repos/nautilus-project/nautilus/tests/tests/records/instructions/person.ts
|
import * as borsh from "borsh"
import { Buffer } from "buffer"
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction
} from '@solana/web3.js'
import { createBaseInstruction, fetchIndex, MyInstructions } from "."
import assert from "assert"
class CreatePersonInstructionData {
instruction: MyInstructions
name: string
authority: Uint8Array
constructor(props: {
instruction: MyInstructions,
name: string,
authority: PublicKey,
}) {
this.instruction = props.instruction
this.name = props.name
this.authority = props.authority.toBuffer()
}
toBuffer() {
return Buffer.from(borsh.serialize(CreatePersonInstructionDataSchema, this))
}
}
const CreatePersonInstructionDataSchema = new Map([
[ CreatePersonInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
['name', 'string'],
['authority', [32]],
],
}]
])
export function derivePersonAddress(programId: PublicKey, id: number): PublicKey {
return PublicKey.findProgramAddressSync(
[Buffer.from("person"), Buffer.from(Uint8Array.of(id))],
programId
)[0]
}
function createInstruction(
index: PublicKey,
newRecord: PublicKey,
payer: PublicKey,
programId: PublicKey,
name: string,
authority: PublicKey,
): TransactionInstruction {
const myInstructionObject = new CreatePersonInstructionData({
instruction: MyInstructions.CreatePerson,
name,
authority,
})
const keys = [
{pubkey: index, isSigner: false, isWritable: true},
{pubkey: newRecord, isSigner: false, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
]
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
export async function createCreatePersonInstruction(
payer: PublicKey,
programId: PublicKey,
name: string,
authority: PublicKey,
): Promise<TransactionInstruction> {
const index = await fetchIndex(programId)
const currentId = index[1].get("person");
assert(currentId != undefined)
const newRecord = derivePersonAddress(programId, currentId + 1)
return createInstruction(index[0], newRecord, payer, programId, name, authority)
}
export async function createReadPersonInstruction(
programId: PublicKey,
): Promise<TransactionInstruction> {
const index = await fetchIndex(programId)
const currentId = index[1].get("person");
assert(currentId != undefined)
const record = derivePersonAddress(programId, currentId + 1) // TODO
return createBaseInstruction(
programId,
MyInstructions.ReadPerson,
[
{pubkey: index[0], isSigner: false, isWritable: false},
{pubkey: record, isSigner: false, isWritable: false},
],
)
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests
|
solana_public_repos/nautilus-project/nautilus/tests/tests/records-2/test.ts
|
import {
it,
describe,
} from 'mocha'
import {
Keypair,
sendAndConfirmTransaction,
Transaction,
TransactionInstruction,
} from '@solana/web3.js'
import { PAYER, PROGRAM_RECORDS, TEST_CONFIGS } from '../const'
import {
createCreateCarInstruction,
createCreateHomeInstruction,
createCreatePersonInstruction,
createInitializeInstruction,
createReadCarInstruction,
createReadHomeInstruction,
createReadPersonInstruction,
} from './instructions'
describe("Nautilus Unit Tests: Create Records", async () => {
const connection = TEST_CONFIGS.connection
const payer = PAYER
const program = PROGRAM_RECORDS
const personName = "Joe"
const homeId = 1
const homeHouseNumber = 15
const homeStreet = "Solana St."
const carMake = "Chevrolet"
const carModel = "Corvette"
async function test(ix: TransactionInstruction, signers: Keypair[]) {
TEST_CONFIGS.sleep()
let sx = await sendAndConfirmTransaction(
connection,
new Transaction().add(ix),
signers,
{skipPreflight: true}
)
console.log(`\n\n [INFO]: sig: ${sx}\n`)
}
it("Initialize Nautilus Index", async () => test(
createInitializeInstruction(payer.publicKey, program.publicKey),
[payer],
))
it("Create Person", async () => test(
await createCreatePersonInstruction(payer.publicKey, program.publicKey, personName, payer.publicKey),
[payer],
))
it("Read Person", async () => test(
await createReadPersonInstruction(program.publicKey),
[payer],
))
it("Create Home", async () => test(
createCreateHomeInstruction(payer.publicKey, program.publicKey, homeId, homeHouseNumber, homeStreet),
[payer],
))
it("Read Home", async () => test(
createReadHomeInstruction(program.publicKey, homeId),
[payer],
))
it("Create Car", async () => test(
await createCreateCarInstruction(payer.publicKey, program.publicKey, carMake, carModel, payer.publicKey, payer.publicKey),
[payer],
))
it("Read Car", async () => test(
await createReadCarInstruction(program.publicKey),
[payer],
))
})
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests/records-2
|
solana_public_repos/nautilus-project/nautilus/tests/tests/records-2/instructions/car.ts
|
import * as borsh from "borsh"
import { Buffer } from "buffer"
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction
} from '@solana/web3.js'
import { createBaseInstruction, fetchIndex, MyInstructions } from "."
import assert from "assert"
class CreateCarInstructionData {
instruction: MyInstructions
make: string
model: string
purchase_authority: Uint8Array
operating_authority: Uint8Array
constructor(props: {
instruction: MyInstructions,
make: string,
model: string,
purchase_authority: PublicKey,
operating_authority: PublicKey,
}) {
this.instruction = props.instruction
this.make = props.make
this.model = props.model
this.purchase_authority = props.purchase_authority.toBuffer()
this.operating_authority = props.operating_authority.toBuffer()
}
toBuffer() {
return Buffer.from(borsh.serialize(CreateCarInstructionDataSchema, this))
}
}
const CreateCarInstructionDataSchema = new Map([
[ CreateCarInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
['make', 'string'],
['model', 'string'],
['purchase_authority', [32]],
['operating_authority', [32]],
],
}]
])
function deriveCarAddress(programId: PublicKey, id: number): PublicKey {
return PublicKey.findProgramAddressSync(
[Buffer.from("car"), Buffer.from(Uint8Array.of(id))],
programId
)[0]
}
function createInstruction(
index: PublicKey,
newRecord: PublicKey,
payer: PublicKey,
programId: PublicKey,
make: string,
model: string,
purchase_authority: PublicKey,
operating_authority: PublicKey,
): TransactionInstruction {
const myInstructionObject = new CreateCarInstructionData({
instruction: MyInstructions.CreateCar,
make,
model,
purchase_authority,
operating_authority,
})
const keys = [
{pubkey: index, isSigner: false, isWritable: true},
{pubkey: newRecord, isSigner: false, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
]
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
export async function createCreateCarInstruction(
payer: PublicKey,
programId: PublicKey,
make: string,
model: string,
purchase_authority: PublicKey,
operating_authority: PublicKey,
): Promise<TransactionInstruction> {
const index = await fetchIndex(programId)
const currentId = index[1].get("car");
assert(currentId != undefined)
const newRecord = deriveCarAddress(programId, currentId + 1)
return createInstruction(index[0], newRecord, payer, programId, make, model, purchase_authority, operating_authority)
}
export async function createReadCarInstruction(
programId: PublicKey,
): Promise<TransactionInstruction> {
const index = await fetchIndex(programId)
const currentId = index[1].get("car");
assert(currentId != undefined)
const record = deriveCarAddress(programId, currentId + 1) // TODO
return createBaseInstruction(
programId,
MyInstructions.ReadCar,
[
{pubkey: index[0], isSigner: false, isWritable: false},
{pubkey: record, isSigner: false, isWritable: false},
],
)
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests/records-2
|
solana_public_repos/nautilus-project/nautilus/tests/tests/records-2/instructions/index.ts
|
export * from './car'
export * from './home'
export * from './person'
import { PublicKey, SYSVAR_RENT_PUBKEY, SystemProgram, TransactionInstruction } from '@solana/web3.js'
import * as borsh from "borsh"
import { Buffer } from "buffer"
import { TEST_CONFIGS } from '../../const'
export enum MyInstructions {
Initialize,
CreatePerson,
ReadPerson,
CreateHome,
ReadHome,
CreateCar,
ReadCar,
}
export class BaseInstructionData {
instruction: MyInstructions
constructor(props: {
instruction: MyInstructions,
}) {
this.instruction = props.instruction
}
toBuffer() {
return Buffer.from(borsh.serialize(BaseInstructionDataSchema, this))
}
}
const BaseInstructionDataSchema = new Map([
[ BaseInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
],
}]
])
export function createBaseInstruction(
programId: PublicKey,
instruction: MyInstructions,
keys: {pubkey: PublicKey, isSigner: boolean, isWritable: boolean}[],
): TransactionInstruction {
const myInstructionObject = new BaseInstructionData({instruction})
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
export function deriveIndexAddress(programId: PublicKey): PublicKey {
return PublicKey.findProgramAddressSync(
[Buffer.from("nautilus_index"), Buffer.from(Uint8Array.of(0))],
programId
)[0]
}
export async function fetchIndex(programId: PublicKey): Promise<[PublicKey, Map<string, number>]> {
const connection = TEST_CONFIGS.connection
const indexPubkey = deriveIndexAddress(programId)
const indexAccountInfo = await connection.getAccountInfo(indexPubkey)
return [indexPubkey ,new Map<string, number>([
["person", 0],
["home", 0],
["car", 0],
])] // TODO
}
export function createInitializeInstruction(payer: PublicKey, programId: PublicKey): TransactionInstruction {
const indexPubkey = deriveIndexAddress(programId)
console.log(` [INFO]: Index: ${indexPubkey.toBase58()}`)
return createBaseInstruction(
programId,
MyInstructions.Initialize,
[
{pubkey: indexPubkey, isSigner: false, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
],
)
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests/records-2
|
solana_public_repos/nautilus-project/nautilus/tests/tests/records-2/instructions/home.ts
|
import * as borsh from "borsh"
import { Buffer } from "buffer"
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction
} from '@solana/web3.js'
import { createBaseInstruction, deriveIndexAddress, fetchIndex, MyInstructions } from "."
class CreateHomeInstructionData {
instruction: MyInstructions
id: number
house_number: number
street: string
constructor(props: {
instruction: MyInstructions,
id: number,
house_number: number,
street: string,
}) {
this.instruction = props.instruction
this.id = props.id
this.house_number = props.house_number
this.street = props.street
}
toBuffer() {
return Buffer.from(borsh.serialize(CreateHomeInstructionDataSchema, this))
}
}
const CreateHomeInstructionDataSchema = new Map([
[ CreateHomeInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
['id', 'u8'],
['house_number', 'u8'],
['street', 'string'],
],
}]
])
function deriveHomeAddress(programId: PublicKey, id: number): PublicKey {
return PublicKey.findProgramAddressSync(
[Buffer.from("home"), Buffer.from(Uint8Array.of(id))],
programId
)[0]
}
function createInstruction(
index: PublicKey,
newRecord: PublicKey,
payer: PublicKey,
programId: PublicKey,
id: number,
house_number: number,
street: string,
): TransactionInstruction {
const myInstructionObject = new CreateHomeInstructionData({
instruction: MyInstructions.CreateHome,
id,
house_number,
street,
})
const keys = [
{pubkey: index, isSigner: false, isWritable: true},
{pubkey: newRecord, isSigner: false, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
]
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
export function createCreateHomeInstruction(
payer: PublicKey,
programId: PublicKey,
id: number,
house_number: number,
street: string,
): TransactionInstruction {
const index = deriveIndexAddress(programId)
const newRecord = deriveHomeAddress(programId, id)
return createInstruction(index, newRecord, payer, programId, id, house_number, street)
}
export function createReadHomeInstruction(
programId: PublicKey,
id: number,
): TransactionInstruction {
const index = deriveIndexAddress(programId)
const record = deriveHomeAddress(programId, id)
return createBaseInstruction(
programId,
MyInstructions.ReadHome,
[
{pubkey: index, isSigner: false, isWritable: false},
{pubkey: record, isSigner: false, isWritable: false},
],
)
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests/records-2
|
solana_public_repos/nautilus-project/nautilus/tests/tests/records-2/instructions/person.ts
|
import * as borsh from "borsh"
import { Buffer } from "buffer"
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction
} from '@solana/web3.js'
import { createBaseInstruction, fetchIndex, MyInstructions } from "."
import assert from "assert"
class CreatePersonInstructionData {
instruction: MyInstructions
name: string
authority: Uint8Array
constructor(props: {
instruction: MyInstructions,
name: string,
authority: PublicKey,
}) {
this.instruction = props.instruction
this.name = props.name
this.authority = props.authority.toBuffer()
}
toBuffer() {
return Buffer.from(borsh.serialize(CreatePersonInstructionDataSchema, this))
}
}
const CreatePersonInstructionDataSchema = new Map([
[ CreatePersonInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
['name', 'string'],
['authority', [32]],
],
}]
])
function derivePersonAddress(programId: PublicKey, id: number): PublicKey {
return PublicKey.findProgramAddressSync(
[Buffer.from("person"), Buffer.from(Uint8Array.of(id))],
programId
)[0]
}
function createInstruction(
index: PublicKey,
newRecord: PublicKey,
payer: PublicKey,
programId: PublicKey,
name: string,
authority: PublicKey,
): TransactionInstruction {
const myInstructionObject = new CreatePersonInstructionData({
instruction: MyInstructions.CreatePerson,
name,
authority,
})
const keys = [
{pubkey: index, isSigner: false, isWritable: true},
{pubkey: newRecord, isSigner: false, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
]
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
export async function createCreatePersonInstruction(
payer: PublicKey,
programId: PublicKey,
name: string,
authority: PublicKey,
): Promise<TransactionInstruction> {
const index = await fetchIndex(programId)
const currentId = index[1].get("person");
assert(currentId != undefined)
const newRecord = derivePersonAddress(programId, currentId + 1)
return createInstruction(index[0], newRecord, payer, programId, name, authority)
}
export async function createReadPersonInstruction(
programId: PublicKey,
): Promise<TransactionInstruction> {
const index = await fetchIndex(programId)
const currentId = index[1].get("person");
assert(currentId != undefined)
const record = derivePersonAddress(programId, currentId + 1) // TODO
return createBaseInstruction(
programId,
MyInstructions.ReadPerson,
[
{pubkey: index[0], isSigner: false, isWritable: false},
{pubkey: record, isSigner: false, isWritable: false},
],
)
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests
|
solana_public_repos/nautilus-project/nautilus/tests/tests/accounts/test.ts
|
import {
it,
describe,
} from 'mocha'
import {
Keypair,
sendAndConfirmTransaction,
Transaction,
TransactionInstruction,
} from '@solana/web3.js'
import { PAYER, PROGRAM_ACCOUNTS, TEST_CONFIGS } from '../const'
import {
createCreateCarInstruction,
createCreateHomeInstruction,
createCreatePersonInstruction,
createReadCarInstruction,
createReadHomeInstruction,
createReadPersonInstruction,
} from './instructions'
describe("Nautilus Unit Tests: Create Accounts", async () => {
const connection = TEST_CONFIGS.connection
const payer = PAYER
const program = PROGRAM_ACCOUNTS
const personName = "Joe"
const personAuthority = Keypair.generate().publicKey
const homeHouseNumber = 15
const homeStreet = "Solana St."
const homeSomeRandomPubkey = Keypair.generate().publicKey
const carMake = "Chevrolet"
const carModel = "Corvette"
const carPurchaseAuthority = Keypair.generate().publicKey
const carOperatingAuthority = Keypair.generate().publicKey
async function test(ix: TransactionInstruction, signers: Keypair[]) {
TEST_CONFIGS.sleep()
let sx = await sendAndConfirmTransaction(
connection,
new Transaction().add(ix),
signers,
{skipPreflight: true}
)
console.log(`\n\n [INFO]: sig: ${sx}\n`)
}
it("Create Person", async () => test(
await createCreatePersonInstruction(payer.publicKey, program.publicKey, personName, personAuthority),
[payer],
))
it("Read Person", async () => test(
await createReadPersonInstruction(program.publicKey, personAuthority),
[payer],
))
it("Create Home", async () => test(
createCreateHomeInstruction(payer.publicKey, program.publicKey, homeHouseNumber, homeStreet, homeSomeRandomPubkey),
[payer],
))
it("Read Home", async () => test(
createReadHomeInstruction(program.publicKey, homeSomeRandomPubkey),
[payer],
))
it("Create Car", async () => test(
await createCreateCarInstruction(payer.publicKey, program.publicKey, carMake, carModel, carPurchaseAuthority, carOperatingAuthority),
[payer],
))
it("Read Car", async () => test(
await createReadCarInstruction(program.publicKey, carPurchaseAuthority, carOperatingAuthority),
[payer],
))
})
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests/accounts
|
solana_public_repos/nautilus-project/nautilus/tests/tests/accounts/instructions/car.ts
|
import * as borsh from "borsh"
import { Buffer } from "buffer"
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction
} from '@solana/web3.js'
import { createBaseInstruction, MyInstructions } from "."
import assert from "assert"
class CreateCarInstructionData {
instruction: MyInstructions
make: string
model: string
purchase_authority: Uint8Array
operating_authority: Uint8Array
constructor(props: {
instruction: MyInstructions,
make: string,
model: string,
purchase_authority: PublicKey,
operating_authority: PublicKey,
}) {
this.instruction = props.instruction
this.make = props.make
this.model = props.model
this.purchase_authority = props.purchase_authority.toBuffer()
this.operating_authority = props.operating_authority.toBuffer()
}
toBuffer() {
return Buffer.from(borsh.serialize(CreateCarInstructionDataSchema, this))
}
}
const CreateCarInstructionDataSchema = new Map([
[ CreateCarInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
['make', 'string'],
['model', 'string'],
['purchase_authority', [32]],
['operating_authority', [32]],
],
}]
])
function deriveCarAddress(programId: PublicKey, purchaseAuthority: PublicKey, operatingAuthority: PublicKey): PublicKey {
return PublicKey.findProgramAddressSync(
[Buffer.from("car"), purchaseAuthority.toBuffer(), operatingAuthority.toBuffer()],
programId
)[0]
}
function createInstruction(
newRecord: PublicKey,
payer: PublicKey,
programId: PublicKey,
make: string,
model: string,
purchase_authority: PublicKey,
operating_authority: PublicKey,
): TransactionInstruction {
const myInstructionObject = new CreateCarInstructionData({
instruction: MyInstructions.CreateCar,
make,
model,
purchase_authority,
operating_authority,
})
const keys = [
{pubkey: newRecord, isSigner: false, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
]
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
export async function createCreateCarInstruction(
payer: PublicKey,
programId: PublicKey,
make: string,
model: string,
purchaseAuthority: PublicKey,
operatingAuthority: PublicKey,
): Promise<TransactionInstruction> {
const newRecord = deriveCarAddress(programId, purchaseAuthority, operatingAuthority)
return createInstruction(newRecord, payer, programId, make, model, purchaseAuthority, operatingAuthority)
}
export async function createReadCarInstruction(
programId: PublicKey,
purchaseAuthority: PublicKey,
operatingAuthority: PublicKey,
): Promise<TransactionInstruction> {
const record = deriveCarAddress(programId, purchaseAuthority, operatingAuthority) // TODO
return createBaseInstruction(
programId,
MyInstructions.ReadCar,
[
{pubkey: record, isSigner: false, isWritable: false},
],
)
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests/accounts
|
solana_public_repos/nautilus-project/nautilus/tests/tests/accounts/instructions/index.ts
|
export * from './car'
export * from './home'
export * from './person'
import { PublicKey, SYSVAR_RENT_PUBKEY, SystemProgram, TransactionInstruction } from '@solana/web3.js'
import * as borsh from "borsh"
import { Buffer } from "buffer"
import { TEST_CONFIGS } from '../../const'
export enum MyInstructions {
CreatePerson,
ReadPerson,
CreateHome,
ReadHome,
CreateCar,
ReadCar,
}
export class BaseInstructionData {
instruction: MyInstructions
constructor(props: {
instruction: MyInstructions,
}) {
this.instruction = props.instruction
}
toBuffer() {
return Buffer.from(borsh.serialize(BaseInstructionDataSchema, this))
}
}
const BaseInstructionDataSchema = new Map([
[ BaseInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
],
}]
])
export function createBaseInstruction(
programId: PublicKey,
instruction: MyInstructions,
keys: {pubkey: PublicKey, isSigner: boolean, isWritable: boolean}[],
): TransactionInstruction {
const myInstructionObject = new BaseInstructionData({instruction})
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests/accounts
|
solana_public_repos/nautilus-project/nautilus/tests/tests/accounts/instructions/home.ts
|
import * as borsh from "borsh"
import { Buffer } from "buffer"
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction
} from '@solana/web3.js'
import { createBaseInstruction, MyInstructions } from "."
class CreateHomeInstructionData {
instruction: MyInstructions
house_number: number
street: string
some_pubkey: Uint8Array
constructor(props: {
instruction: MyInstructions,
house_number: number,
street: string,
some_pubkey: PublicKey,
}) {
this.instruction = props.instruction
this.house_number = props.house_number
this.street = props.street
this.some_pubkey = props.some_pubkey.toBuffer()
}
toBuffer() {
return Buffer.from(borsh.serialize(CreateHomeInstructionDataSchema, this))
}
}
const CreateHomeInstructionDataSchema = new Map([
[ CreateHomeInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
['house_number', 'u8'],
['street', 'string'],
['some_pubkey', [32]],
],
}]
])
function deriveHomeAddress(programId: PublicKey, somePubkey: PublicKey): PublicKey {
return PublicKey.findProgramAddressSync(
[Buffer.from("home"), somePubkey.toBuffer()],
programId
)[0]
}
function createInstruction(
newAccount: PublicKey,
payer: PublicKey,
programId: PublicKey,
house_number: number,
street: string,
some_pubkey: PublicKey,
): TransactionInstruction {
const myInstructionObject = new CreateHomeInstructionData({
instruction: MyInstructions.CreateHome,
house_number,
street,
some_pubkey,
})
const keys = [
{pubkey: newAccount, isSigner: false, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
]
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
export function createCreateHomeInstruction(
payer: PublicKey,
programId: PublicKey,
house_number: number,
street: string,
somePubkey: PublicKey,
): TransactionInstruction {
const newAccount = deriveHomeAddress(programId, somePubkey)
return createInstruction(newAccount, payer, programId, house_number, street, somePubkey)
}
export function createReadHomeInstruction(
programId: PublicKey,
somePubkey: PublicKey,
): TransactionInstruction {
const account = deriveHomeAddress(programId, somePubkey)
return createBaseInstruction(
programId,
MyInstructions.ReadHome,
[
{pubkey: account, isSigner: false, isWritable: false},
],
)
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests/accounts
|
solana_public_repos/nautilus-project/nautilus/tests/tests/accounts/instructions/person.ts
|
import * as borsh from "borsh"
import { Buffer } from "buffer"
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction
} from '@solana/web3.js'
import { createBaseInstruction, MyInstructions } from "."
import assert from "assert"
class CreatePersonInstructionData {
instruction: MyInstructions
name: string
authority: Uint8Array
constructor(props: {
instruction: MyInstructions,
name: string,
authority: PublicKey,
}) {
this.instruction = props.instruction
this.name = props.name
this.authority = props.authority.toBuffer()
}
toBuffer() {
return Buffer.from(borsh.serialize(CreatePersonInstructionDataSchema, this))
}
}
const CreatePersonInstructionDataSchema = new Map([
[ CreatePersonInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
['name', 'string'],
['authority', [32]],
],
}]
])
function derivePersonAddress(programId: PublicKey, authority: PublicKey): PublicKey {
return PublicKey.findProgramAddressSync(
[Buffer.from("person"), authority.toBuffer()],
programId
)[0]
}
function createInstruction(
newAccount: PublicKey,
payer: PublicKey,
programId: PublicKey,
name: string,
authority: PublicKey,
): TransactionInstruction {
const myInstructionObject = new CreatePersonInstructionData({
instruction: MyInstructions.CreatePerson,
name,
authority,
})
const keys = [
{pubkey: newAccount, isSigner: false, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
]
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
export async function createCreatePersonInstruction(
payer: PublicKey,
programId: PublicKey,
name: string,
authority: PublicKey,
): Promise<TransactionInstruction> {
const newAccount = derivePersonAddress(programId, authority)
return createInstruction(newAccount, payer, programId, name, authority)
}
export async function createReadPersonInstruction(
programId: PublicKey,
authority: PublicKey,
): Promise<TransactionInstruction> {
const account = derivePersonAddress(programId, authority) // TODO
return createBaseInstruction(
programId,
MyInstructions.ReadPerson,
[
{pubkey: account, isSigner: false, isWritable: false},
],
)
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests
|
solana_public_repos/nautilus-project/nautilus/tests/tests/wallets/test.ts
|
import {
it,
describe,
} from 'mocha'
import {
Keypair,
LAMPORTS_PER_SOL,
PublicKey,
sendAndConfirmTransaction,
Transaction,
TransactionInstruction,
} from '@solana/web3.js'
import { PAYER, PROGRAM_WALLETS, TEST_CONFIGS } from '../const'
import {
createAllocateWalletInstruction,
createComplexInstruction,
createCreateWalletInstruction,
createCreateWalletWithPayerInstruction,
createReadWalletInstruction,
createTransferInstruction,
} from './instructions'
import { createAssignInstruction } from './instructions/assign'
describe("Nautilus Unit Tests: Wallets", async () => {
const connection = TEST_CONFIGS.connection
const payer = PAYER
const program = PROGRAM_WALLETS
const rent_payer = Keypair.generate()
const newWallet = Keypair.generate()
const newWalletToBeAllocated = Keypair.generate()
const newWalletToBeAssignedAway = Keypair.generate()
const newWalletWithPayer = Keypair.generate()
const transferAmount = LAMPORTS_PER_SOL / 1000
// Complex instruction
const compAuthority1 = Keypair.generate()
const compAuthority2 = Keypair.generate()
const compRentPayer1 = Keypair.generate()
const compRentPayer2 = Keypair.generate()
const compTransferRecipient = Keypair.generate()
const compWalletToAllocate = Keypair.generate()
const compWalletToCreate = Keypair.generate()
const compWalletToCreateWithTransferSafe = Keypair.generate()
const compWalletToCreateWithTransferUnsafe = Keypair.generate()
const compFundAmount = LAMPORTS_PER_SOL / 1000
const compTransferAmount = LAMPORTS_PER_SOL / 1000
async function initAccount(publicKey: PublicKey) {
await TEST_CONFIGS.sleep()
connection.confirmTransaction(
await connection.requestAirdrop(publicKey, LAMPORTS_PER_SOL / 100)
)
}
async function initTestAccounts() {
initAccount(rent_payer.publicKey)
initAccount(compRentPayer1.publicKey)
initAccount(compRentPayer2.publicKey)
initAccount(compAuthority2.publicKey)
}
async function test(ix: TransactionInstruction, signers: Keypair[]) {
await TEST_CONFIGS.sleep()
let sx = await sendAndConfirmTransaction(
connection,
new Transaction().add(ix),
signers,
{skipPreflight: true}
)
console.log(`\n\n [INFO]: sig: ${sx}\n`)
}
before(async () => {
await TEST_CONFIGS.sleep()
initTestAccounts()
})
// Wallets
it("Allocate Wallet", async () => test(
createAllocateWalletInstruction(newWalletToBeAllocated.publicKey, payer.publicKey, program.publicKey),
[payer, newWalletToBeAllocated],
))
it("Create Wallet to be assigned away", async () => test(
createCreateWalletInstruction(newWalletToBeAssignedAway.publicKey, payer.publicKey, program.publicKey),
[payer, newWalletToBeAssignedAway],
))
it("Assign away Wallet", async () => test(
createAssignInstruction(newWalletToBeAssignedAway.publicKey, program.publicKey, program.publicKey),
[payer, newWalletToBeAssignedAway],
))
it("Create Wallet", async () => test(
createCreateWalletInstruction(newWallet.publicKey, payer.publicKey, program.publicKey),
[payer, newWallet],
))
it("Read Wallet", async () => test(
createReadWalletInstruction(newWallet.publicKey, program.publicKey),
[payer],
))
it("Create Wallet with Payer", async () => test(
createCreateWalletWithPayerInstruction(newWalletWithPayer.publicKey, payer.publicKey, program.publicKey),
[payer, newWalletWithPayer],
))
it("Read Wallet Created With Payer", async () => test(
createReadWalletInstruction(newWalletWithPayer.publicKey, program.publicKey),
[payer],
))
it("Transfer", async () => test(
createTransferInstruction(payer.publicKey, newWallet.publicKey, program.publicKey, transferAmount),
[payer],
))
it("Complex", async () => test(
createComplexInstruction(
compAuthority1.publicKey,
compAuthority2.publicKey,
compRentPayer1.publicKey,
compRentPayer2.publicKey,
compTransferRecipient.publicKey,
compWalletToAllocate.publicKey,
compWalletToCreate.publicKey,
compWalletToCreateWithTransferSafe.publicKey,
compWalletToCreateWithTransferUnsafe.publicKey,
payer.publicKey,
program.publicKey,
compFundAmount,
compTransferAmount,
),
[
payer,
compAuthority1,
compAuthority2,
compRentPayer1,
compRentPayer2,
compWalletToAllocate,
compWalletToCreate,
],
))
})
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests/wallets
|
solana_public_repos/nautilus-project/nautilus/tests/tests/wallets/instructions/wallet.ts
|
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction
} from '@solana/web3.js'
import { MyInstructions, createBaseInstruction } from "."
export function createAllocateWalletInstruction(
newWallet: PublicKey,
payer: PublicKey,
programId: PublicKey,
): TransactionInstruction {
return createBaseInstruction(
programId,
MyInstructions.Allocate,
[
{pubkey: newWallet, isSigner: true, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
],
)
}
export function createCreateWalletInstruction(
newWallet: PublicKey,
payer: PublicKey,
programId: PublicKey,
): TransactionInstruction {
return createBaseInstruction(
programId,
MyInstructions.Create,
[
{pubkey: newWallet, isSigner: true, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
],
)
}
export function createReadWalletInstruction(
newWallet: PublicKey,
programId: PublicKey,
): TransactionInstruction {
return createBaseInstruction(
programId,
MyInstructions.Read,
[
{pubkey: newWallet, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
],
)
}
export function createCreateWalletWithPayerInstruction(
newWallet: PublicKey,
payer: PublicKey,
programId: PublicKey,
): TransactionInstruction {
return createBaseInstruction(
programId,
MyInstructions.CreateWithPayer,
[
{pubkey: newWallet, isSigner: true, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
]
)
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests/wallets
|
solana_public_repos/nautilus-project/nautilus/tests/tests/wallets/instructions/complex.ts
|
import * as borsh from "borsh"
import { Buffer } from "buffer"
import {
PublicKey,
SYSVAR_RENT_PUBKEY,
SystemProgram,
TransactionInstruction
} from '@solana/web3.js'
import { MyInstructions } from "."
class ComplexInstructionData {
instruction: MyInstructions
amount_to_fund: number
amount_to_transfer: number
constructor(props: {
instruction: MyInstructions,
amount_to_fund: number,
amount_to_transfer: number,
}) {
this.instruction = props.instruction
this.amount_to_fund = props.amount_to_fund
this.amount_to_transfer = props.amount_to_transfer
}
toBuffer() {
return Buffer.from(borsh.serialize(ComplexInstructionDataSchema, this))
}
}
const ComplexInstructionDataSchema = new Map([
[ ComplexInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
['amount_to_fund', 'u64'],
['amount_to_transfer', 'u64'],
],
}]
])
function createInstruction(
authority1: PublicKey,
authority2: PublicKey,
rentPayer1: PublicKey,
rentPayer2: PublicKey,
transferRecipient: PublicKey,
walletAllocate: PublicKey,
walletCreate: PublicKey,
walletCreateWithTransferSafe: PublicKey,
walletCreateWithTransferUnsafe: PublicKey,
payer: PublicKey,
programId: PublicKey,
amount_to_fund: number,
amount_to_transfer: number,
instruction: MyInstructions,
): TransactionInstruction {
const myInstructionObject = new ComplexInstructionData({instruction, amount_to_fund, amount_to_transfer})
const keys = [
{pubkey: authority1, isSigner: true, isWritable: true},
{pubkey: authority2, isSigner: true, isWritable: true},
{pubkey: rentPayer1, isSigner: true, isWritable: true},
{pubkey: rentPayer2, isSigner: true, isWritable: true},
{pubkey: transferRecipient, isSigner: false, isWritable: true},
{pubkey: walletAllocate, isSigner: true, isWritable: true},
{pubkey: walletCreate, isSigner: true, isWritable: true},
{pubkey: walletCreateWithTransferSafe, isSigner: false, isWritable: true},
{pubkey: walletCreateWithTransferUnsafe, isSigner: false, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
]
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
export function createComplexInstruction(
authority1: PublicKey,
authority2: PublicKey,
rentPayer1: PublicKey,
rentPayer2: PublicKey,
transferRecipient: PublicKey,
walletAllocate: PublicKey,
walletCreate: PublicKey,
walletCreateWithTransferSafe: PublicKey,
walletCreateWithTransferUnsafe: PublicKey,
payer: PublicKey,
programId: PublicKey,
amountToFund: number,
amountToTransfer: number,
): TransactionInstruction {
return createInstruction(
authority1,
authority2,
rentPayer1,
rentPayer2,
transferRecipient,
walletAllocate,
walletCreate,
walletCreateWithTransferSafe,
walletCreateWithTransferUnsafe,
payer,
programId,
amountToFund,
amountToTransfer,
MyInstructions.Complex,
)
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests/wallets
|
solana_public_repos/nautilus-project/nautilus/tests/tests/wallets/instructions/assign.ts
|
import * as borsh from "borsh"
import { Buffer } from "buffer"
import {
PublicKey,
SystemProgram,
TransactionInstruction
} from '@solana/web3.js'
import { MyInstructions } from "."
class AssignInstructionData {
instruction: MyInstructions
owner: Uint8Array
constructor(props: {
instruction: MyInstructions,
owner: PublicKey,
}) {
this.instruction = props.instruction
this.owner = props.owner.toBuffer()
}
toBuffer() {
return Buffer.from(borsh.serialize(AssignInstructionDataSchema, this))
}
}
const AssignInstructionDataSchema = new Map([
[ AssignInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
['owner', [32]],
],
}]
])
function createInstruction(
wallet: PublicKey,
programId: PublicKey,
owner: PublicKey,
instruction: MyInstructions,
): TransactionInstruction {
const myInstructionObject = new AssignInstructionData({instruction, owner})
const keys = [
{pubkey: wallet, isSigner: true, isWritable: true},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
]
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
export function createAssignInstruction(
wallet: PublicKey,
programId: PublicKey,
owner: PublicKey,
): TransactionInstruction {
return createInstruction(wallet, programId, owner, MyInstructions.Assign)
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests/wallets
|
solana_public_repos/nautilus-project/nautilus/tests/tests/wallets/instructions/transfer.ts
|
import * as borsh from "borsh"
import { Buffer } from "buffer"
import {
PublicKey,
SystemProgram,
TransactionInstruction
} from '@solana/web3.js'
import { MyInstructions } from "."
class TransferInstructionData {
instruction: MyInstructions
amount: number
constructor(props: {
instruction: MyInstructions,
amount: number,
}) {
this.instruction = props.instruction
this.amount = props.amount
}
toBuffer() {
return Buffer.from(borsh.serialize(TransferInstructionDataSchema, this))
}
}
const TransferInstructionDataSchema = new Map([
[ TransferInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
['amount', 'u64'],
],
}]
])
function createInstruction(
from: PublicKey,
to: PublicKey,
programId: PublicKey,
amount: number,
instruction: MyInstructions,
): TransactionInstruction {
const myInstructionObject = new TransferInstructionData({instruction, amount})
const keys = [
{pubkey: from, isSigner: true, isWritable: true},
{pubkey: to, isSigner: false, isWritable: true},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
]
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
export function createTransferInstruction(
from: PublicKey,
to: PublicKey,
programId: PublicKey,
amount: number,
): TransactionInstruction {
return createInstruction(from, to, programId, amount, MyInstructions.Transfer)
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests/wallets
|
solana_public_repos/nautilus-project/nautilus/tests/tests/wallets/instructions/index.ts
|
export * from './complex'
export * from './transfer'
export * from './wallet'
import { PublicKey, TransactionInstruction } from '@solana/web3.js'
import * as borsh from "borsh"
import { Buffer } from "buffer"
export enum MyInstructions {
Allocate,
Assign,
Create,
CreateWithPayer,
Read,
Transfer,
Complex,
}
export class BaseInstructionData {
instruction: MyInstructions
constructor(props: {
instruction: MyInstructions,
}) {
this.instruction = props.instruction
}
toBuffer() {
return Buffer.from(borsh.serialize(BaseInstructionDataSchema, this))
}
}
const BaseInstructionDataSchema = new Map([
[ BaseInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
],
}]
])
export function createBaseInstruction(
programId: PublicKey,
instruction: MyInstructions,
keys: {pubkey: PublicKey, isSigner: boolean, isWritable: boolean}[],
): TransactionInstruction {
const myInstructionObject = new BaseInstructionData({instruction})
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests
|
solana_public_repos/nautilus-project/nautilus/tests/tests/tokens/test.ts
|
import {
it,
describe,
} from 'mocha'
import {
Keypair,
LAMPORTS_PER_SOL,
PublicKey,
sendAndConfirmTransaction,
Transaction,
TransactionInstruction,
} from '@solana/web3.js'
import { PAYER, PROGRAM_TOKENS, TEST_CONFIGS } from '../const'
import {
MyInstructions,
createBurnTokensInstruction,
createCreateAssociatedTokenInstruction,
createCreateAssociatedTokenWithPayerInstruction,
createCreateMetadataInstruction,
createCreateMetadataWithPayerInstruction,
createCreateMintInstruction,
createCreateMintWithPayerInstruction,
createCreateNftInstruction,
createCreateNftWithPayerInstruction,
createCreateTokenInstruction,
createCreateTokenWithPayerInstruction,
createFreezeAssociatedTokenInstruction,
createMintDisableMintingInstruction,
createMintMintToInstruction,
createNftMintToInstruction,
createReadAssociatedTokenInstruction,
createReadMetadataInstruction,
createReadMintInstruction,
createReadNftInstruction,
createReadTokenInstruction,
createThawAssociatedTokenInstruction,
createTokenDisableMintingInstruction,
createTokenMintToInstruction,
createTransferTokensInstruction,
} from './instructions'
describe("Nautilus Unit Tests: Tokens", async () => {
const skipMetadata = TEST_CONFIGS.skipMetadata // `true` for localnet
const connection = TEST_CONFIGS.connection
const payer = PAYER
const program = PROGRAM_TOKENS
const rent_payer = Keypair.generate()
const testWallet1 = Keypair.generate()
const testWallet2 = Keypair.generate()
const newMint = Keypair.generate()
const newMintWithPayer = Keypair.generate()
const mintMintAmount = 20
const mintTransferAmount = 5
const mintBurnAmount = 5
const newTokenMint = Keypair.generate()
const newTokenMintWithPayer = Keypair.generate()
const tokenMintAmount = 20
const tokenTransferAmount = 5
const tokenBurnAmount = 5
const tokenDecimals = 9
const tokenTitle = "Nautilus Token"
const tokenSymbol = "NTLS"
const tokenUri = "NTLS"
const newNftMint = Keypair.generate()
const newNftMintWithPayer = Keypair.generate()
const nftTitle = "Nautilus NFT"
const nftSymbol = "NTLS"
const nftUri = "NTLS"
async function initAccount(publicKey: PublicKey) {
await TEST_CONFIGS.sleep()
connection.confirmTransaction(
await connection.requestAirdrop(publicKey, LAMPORTS_PER_SOL / 100)
)
}
async function initTestAccounts() {
initAccount(rent_payer.publicKey)
initAccount(testWallet1.publicKey)
initAccount(testWallet2.publicKey)
}
async function test(ix: TransactionInstruction, signers: Keypair[]) {
await TEST_CONFIGS.sleep()
let sx = await sendAndConfirmTransaction(
connection,
new Transaction().add(ix),
signers,
{skipPreflight: true}
)
console.log(`\n\n [INFO]: sig: ${sx}\n`)
}
before(async () => {
if (skipMetadata) console.log(" [WARN]: `skipMetadata` is set to `true`, so tests for Metadata and Token will not execute & will automatically pass.")
await TEST_CONFIGS.sleep()
initTestAccounts()
})
// Mints
it("Create Mint", async () => test(
createCreateMintInstruction(newMint.publicKey, payer.publicKey, program.publicKey, tokenDecimals),
[payer, newMint],
))
it("Read Mint", async () => test(
createReadMintInstruction(newMint.publicKey, program.publicKey),
[payer],
))
it("Create Mint with Payer", async () => test(
createCreateMintWithPayerInstruction(newMintWithPayer.publicKey, payer.publicKey, program.publicKey, tokenDecimals),
[payer, newMintWithPayer],
))
it("Read Mint Created With Payer", async () => test(
createReadMintInstruction(newMintWithPayer.publicKey, program.publicKey),
[payer],
))
// Metadatas
it("Create Metadata", async () => {if (!skipMetadata) return test(
createCreateMetadataInstruction(newMint.publicKey, payer.publicKey, program.publicKey, tokenTitle, tokenSymbol, tokenUri),
[payer],
)})
it("Read Metadata", async () => {if (!skipMetadata) return test(
createReadMetadataInstruction(newMint.publicKey, program.publicKey),
[payer],
)})
it("Create Metadata with Payer", async () => {if (!skipMetadata) return test(
createCreateMetadataWithPayerInstruction(newMintWithPayer.publicKey, payer.publicKey, program.publicKey, tokenTitle, tokenSymbol, tokenUri),
[payer],
)})
it("Read Metadata Created With Payer", async () => {if (!skipMetadata) return test(
createReadMetadataInstruction(newMintWithPayer.publicKey, program.publicKey),
[payer],
)})
// Associated Token Accounts
it("Create Associated Token", async () => test(
createCreateAssociatedTokenInstruction(newMint.publicKey, testWallet1.publicKey, payer.publicKey, program.publicKey),
[payer],
))
it("Read Associated Token", async () => test(
createReadAssociatedTokenInstruction(newMint.publicKey, testWallet1.publicKey, program.publicKey),
[payer],
))
it("Freeze Associated Token", async () => test(
createFreezeAssociatedTokenInstruction(newMint.publicKey, testWallet1.publicKey, payer.publicKey, program.publicKey),
[payer],
))
it("Thaw Associated Token", async () => test(
createThawAssociatedTokenInstruction(newMint.publicKey, testWallet1.publicKey, payer.publicKey, program.publicKey),
[payer],
))
it("Create Associated Token with Payer", async () => test(
createCreateAssociatedTokenWithPayerInstruction(newMintWithPayer.publicKey, testWallet1.publicKey, payer.publicKey, program.publicKey),
[payer],
))
it("Read Associated Token Created With Payer", async () => test(
createReadAssociatedTokenInstruction(newMintWithPayer.publicKey, testWallet1.publicKey, program.publicKey),
[payer],
))
// Tokens
it("Create Token", async () => {if (!skipMetadata) return test(
createCreateTokenInstruction(newTokenMint.publicKey, payer.publicKey, program.publicKey, tokenDecimals, tokenTitle, tokenSymbol, tokenUri),
[payer, newTokenMint],
)})
it("Read Token", async () => {if (!skipMetadata) return test(
createReadTokenInstruction(newTokenMint.publicKey, program.publicKey),
[payer],
)})
it("Create Token with Payer", async () => {if (!skipMetadata) return test(
createCreateTokenWithPayerInstruction(newTokenMintWithPayer.publicKey, payer.publicKey, program.publicKey, tokenDecimals, tokenTitle, tokenSymbol, tokenUri),
[payer, newTokenMintWithPayer],
)})
it("Read Token Created With Payer", async () => {if (!skipMetadata) return test(
createReadTokenInstruction(newTokenMintWithPayer.publicKey, program.publicKey),
[payer],
)})
// NFTs
it("Create NFT", async () => {if (!skipMetadata) return test(
createCreateNftInstruction(newNftMint.publicKey, payer.publicKey, program.publicKey, nftTitle, nftSymbol, nftUri),
[payer, newNftMint],
)})
it("Read NFT", async () => {if (!skipMetadata) return test(
createReadNftInstruction(newNftMint.publicKey, program.publicKey),
[payer],
)})
it("Create NFT with Payer", async () => {if (!skipMetadata) return test(
createCreateNftWithPayerInstruction(newNftMintWithPayer.publicKey, payer.publicKey, program.publicKey, nftTitle, nftSymbol, nftUri),
[payer, newNftMintWithPayer],
)})
it("Read NFT Created With Payer", async () => {if (!skipMetadata) return test(
createReadNftInstruction(newTokenMintWithPayer.publicKey, program.publicKey),
[payer],
)})
// Minting & Transferring
it("Mint: Mint To", async () => test(
createMintMintToInstruction(newMint.publicKey, testWallet1.publicKey, payer.publicKey, program.publicKey, mintMintAmount),
[payer],
))
it("Mint: Burn", async () => test(
createBurnTokensInstruction(newMint.publicKey, testWallet1.publicKey, program.publicKey, mintBurnAmount),
[payer, testWallet1],
))
it("Mint: Create Associated Token For Transfer", async () => test(
createCreateAssociatedTokenInstruction(newMint.publicKey, testWallet2.publicKey, payer.publicKey, program.publicKey),
[payer],
))
it("Mint: Transfer", async () => test(
createTransferTokensInstruction(newMint.publicKey, testWallet1.publicKey, testWallet2.publicKey, program.publicKey, mintTransferAmount),
[payer, testWallet1],
))
it("Mint: Disable Minting", async () => test(
createMintDisableMintingInstruction(MyInstructions.MintDisableMinting, newMint.publicKey, payer.publicKey, program.publicKey),
[payer],
))
it("Token: Create Associated Token For MintTo", async () => {if (!skipMetadata) return test(
createCreateAssociatedTokenInstruction(newTokenMint.publicKey, testWallet1.publicKey, payer.publicKey, program.publicKey),
[payer],
)})
it("Token: Mint To", async () => {if (!skipMetadata) return test(
createTokenMintToInstruction(newTokenMint.publicKey, testWallet1.publicKey, payer.publicKey, program.publicKey, tokenMintAmount),
[payer],
)})
it("Token: Burn", async () => {if (!skipMetadata) return test(
createBurnTokensInstruction(newTokenMint.publicKey, testWallet1.publicKey, program.publicKey, tokenBurnAmount),
[payer, testWallet1],
)})
it("Token: Create Associated Token For Transfer", async () => {if (!skipMetadata) return test(
createCreateAssociatedTokenInstruction(newTokenMint.publicKey, testWallet2.publicKey, payer.publicKey, program.publicKey),
[payer],
)})
it("Token: Transfer", async () => {if (!skipMetadata) return test(
createTransferTokensInstruction(newTokenMint.publicKey, testWallet1.publicKey, testWallet2.publicKey, program.publicKey, tokenTransferAmount),
[payer, testWallet1],
)})
it("Token: Disable Minting", async () => {if (!skipMetadata) return test(
createTokenDisableMintingInstruction(MyInstructions.TokenDisableMinting, newTokenMint.publicKey, payer.publicKey, program.publicKey),
[payer],
)})
it("NFT: Create Associated Token For MintTo", async () => {if (!skipMetadata) return test(
createCreateAssociatedTokenInstruction(newNftMint.publicKey, testWallet1.publicKey, payer.publicKey, program.publicKey),
[payer],
)})
it("NFT: Mint To", async () => {if (!skipMetadata) return test(
createNftMintToInstruction(newNftMint.publicKey, testWallet1.publicKey, payer.publicKey, program.publicKey),
[payer],
)})
})
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests/tokens
|
solana_public_repos/nautilus-project/nautilus/tests/tests/tokens/instructions/mint.ts
|
import * as borsh from "borsh"
import { Buffer } from "buffer"
import { ASSOCIATED_TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync, TOKEN_PROGRAM_ID } from '@solana/spl-token'
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction
} from '@solana/web3.js'
import { createBaseInstruction, MyInstructions } from "."
// Create
class CreateMintInstructionData {
instruction: MyInstructions
decimals: number
constructor(props: {
instruction: MyInstructions,
decimals: number,
}) {
this.instruction = props.instruction
this.decimals = props.decimals
}
toBuffer() {
return Buffer.from(borsh.serialize(CreateMintInstructionDataSchema, this))
}
}
const CreateMintInstructionDataSchema = new Map([
[ CreateMintInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
['decimals', 'u8'],
],
}]
])
function createCreateInstruction(
newMint: PublicKey,
payer: PublicKey,
programId: PublicKey,
decimals: number,
instruction: MyInstructions,
): TransactionInstruction {
const myInstructionObject = new CreateMintInstructionData({instruction, decimals})
function deriveKeys(instruction: MyInstructions) {
if (instruction === MyInstructions.CreateMint) return [
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: newMint, isSigner: true, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
{pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
]
else if (instruction === MyInstructions.CreateMintWithPayer) return [
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: newMint, isSigner: true, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
{pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
]
return []
}
const keys = deriveKeys(instruction)
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
export function createCreateMintInstruction(
newMint: PublicKey,
payer: PublicKey,
programId: PublicKey,
decimals: number,
): TransactionInstruction {
return createCreateInstruction(newMint, payer, programId, decimals, MyInstructions.CreateMint)
}
export function createCreateMintWithPayerInstruction(
newMint: PublicKey,
payer: PublicKey,
programId: PublicKey,
decimals: number,
): TransactionInstruction {
return createCreateInstruction(newMint, payer, programId, decimals, MyInstructions.CreateMintWithPayer)
}
// Mint To
class MintMintToInstructionData {
instruction: MyInstructions
amount: number
constructor(props: {
instruction: MyInstructions,
amount: number,
}) {
this.instruction = props.instruction
this.amount = props.amount
}
toBuffer() {
return Buffer.from(borsh.serialize(MintMintToInstructionDataSchema, this))
}
}
const MintMintToInstructionDataSchema = new Map([
[ MintMintToInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
['amount', 'u64'],
],
}]
])
export function createMintMintToInstruction(
mint: PublicKey,
recipient: PublicKey,
authority: PublicKey,
programId: PublicKey,
amount: number,
): TransactionInstruction {
const myInstructionObject = new MintMintToInstructionData({
instruction: MyInstructions.MintMintTo,
amount,
})
const recipientAssociatedToken = getAssociatedTokenAddressSync(mint, recipient)
const keys = [
{pubkey: authority, isSigner: true, isWritable: true},
{pubkey: mint, isSigner: false, isWritable: true},
{pubkey: recipientAssociatedToken, isSigner: false, isWritable: true},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
{pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
{pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
]
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
// Disable Minting
export function createMintDisableMintingInstruction(
instruction: MyInstructions,
mint: PublicKey,
authority: PublicKey,
programId: PublicKey,
): TransactionInstruction {
return createBaseInstruction(
programId,
instruction,
[
{pubkey: authority, isSigner: true, isWritable: true},
{pubkey: mint, isSigner: false, isWritable: true},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
{pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
],
)
}
// Read
export function createReadMintInstruction(
newMint: PublicKey,
programId: PublicKey,
): TransactionInstruction {
return createBaseInstruction(
programId,
MyInstructions.ReadMint,
[
{pubkey: newMint, isSigner: false, isWritable: false},
{pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
],
)
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests/tokens
|
solana_public_repos/nautilus-project/nautilus/tests/tests/tokens/instructions/associated-token.ts
|
import * as borsh from "borsh"
import { Buffer } from "buffer"
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction
} from '@solana/web3.js'
import { createBaseInstruction, MyInstructions } from "."
import { ASSOCIATED_TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync, TOKEN_PROGRAM_ID } from "@solana/spl-token"
// Create
class CreateAssociatedTokenInstructionData {
instruction: MyInstructions
constructor(props: {
instruction: MyInstructions,
}) {
this.instruction = props.instruction
}
toBuffer() {
return Buffer.from(borsh.serialize(CreateAssociatedTokenInstructionDataSchema, this))
}
}
const CreateAssociatedTokenInstructionDataSchema = new Map([
[ CreateAssociatedTokenInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
],
}]
])
function createInstruction(
mint: PublicKey,
owner: PublicKey,
payer: PublicKey,
programId: PublicKey,
instruction: MyInstructions,
): TransactionInstruction {
const myInstructionObject = new CreateAssociatedTokenInstructionData({instruction})
const newAssociatedToken = getAssociatedTokenAddressSync(mint, owner)
function deriveKeys(instruction: MyInstructions) {
if (instruction === MyInstructions.CreateAssociatedToken) return [
{pubkey: mint, isSigner: false, isWritable: false},
{pubkey: newAssociatedToken, isSigner: false, isWritable: true},
{pubkey: owner, isSigner: false, isWritable: false},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
{pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
{pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
]
else if (instruction === MyInstructions.CreateAssociatedTokenWithPayer) return [
{pubkey: mint, isSigner: false, isWritable: false},
{pubkey: newAssociatedToken, isSigner: false, isWritable: true},
{pubkey: owner, isSigner: false, isWritable: false},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
{pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
{pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
]
return []
}
const keys = deriveKeys(instruction)
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
export function createCreateAssociatedTokenInstruction(
mint: PublicKey,
owner: PublicKey,
payer: PublicKey,
programId: PublicKey,
): TransactionInstruction {
return createInstruction(mint, owner, payer, programId, MyInstructions.CreateAssociatedToken)
}
export function createCreateAssociatedTokenWithPayerInstruction(
mint: PublicKey,
owner: PublicKey,
payer: PublicKey,
programId: PublicKey,
): TransactionInstruction {
return createInstruction(mint, owner, payer, programId, MyInstructions.CreateAssociatedTokenWithPayer)
}
// Burn
class BurnTokensInstructionData {
instruction: MyInstructions
amount: number
constructor(props: {
instruction: MyInstructions,
amount: number,
}) {
this.instruction = props.instruction
this.amount = props.amount
}
toBuffer() {
return Buffer.from(borsh.serialize(BurnTokensInstructionDataSchema, this))
}
}
const BurnTokensInstructionDataSchema = new Map([
[ BurnTokensInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
['amount', 'u64'],
],
}]
])
export function createBurnTokensInstruction(
mint: PublicKey,
from: PublicKey,
programId: PublicKey,
amount: number,
): TransactionInstruction {
const myInstructionObject = new BurnTokensInstructionData({
instruction: MyInstructions.BurnTokens,
amount,
})
const fromAssociatedToken = getAssociatedTokenAddressSync(mint, from)
const keys = [
{pubkey: from, isSigner: true, isWritable: true},
{pubkey: fromAssociatedToken, isSigner: false, isWritable: true},
{pubkey: mint, isSigner: false, isWritable: true},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
{pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
{pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
]
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
// Transfer
class TransferTokensInstructionData {
instruction: MyInstructions
amount: number
constructor(props: {
instruction: MyInstructions,
amount: number,
}) {
this.instruction = props.instruction
this.amount = props.amount
}
toBuffer() {
return Buffer.from(borsh.serialize(TransferTokensInstructionDataSchema, this))
}
}
const TransferTokensInstructionDataSchema = new Map([
[ TransferTokensInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
['amount', 'u64'],
],
}]
])
export function createTransferTokensInstruction(
mint: PublicKey,
from: PublicKey,
to: PublicKey,
programId: PublicKey,
amount: number,
): TransactionInstruction {
const myInstructionObject = new TransferTokensInstructionData({
instruction: MyInstructions.TransferTokens,
amount,
})
const fromAssociatedToken = getAssociatedTokenAddressSync(mint, from)
const toAssociatedToken = getAssociatedTokenAddressSync(mint, to)
const keys = [
{pubkey: from, isSigner: true, isWritable: true},
{pubkey: fromAssociatedToken, isSigner: false, isWritable: true},
{pubkey: toAssociatedToken, isSigner: false, isWritable: true},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
{pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
{pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
]
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
// Freeze
export function createFreezeAssociatedTokenInstruction(
mint: PublicKey,
owner: PublicKey,
authority: PublicKey,
programId: PublicKey,
): TransactionInstruction {
const associatedToken = getAssociatedTokenAddressSync(mint, owner)
return createBaseInstruction(
programId,
MyInstructions.FreezeAccount,
[
{pubkey: associatedToken, isSigner: false, isWritable: true},
{pubkey: authority, isSigner: true, isWritable: true},
{pubkey: mint, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
{pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
{pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
],
)
}
// Thaw
export function createThawAssociatedTokenInstruction(
mint: PublicKey,
owner: PublicKey,
authority: PublicKey,
programId: PublicKey,
): TransactionInstruction {
const associatedToken = getAssociatedTokenAddressSync(mint, owner)
return createBaseInstruction(
programId,
MyInstructions.ThawAccount,
[
{pubkey: associatedToken, isSigner: false, isWritable: true},
{pubkey: authority, isSigner: true, isWritable: true},
{pubkey: mint, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
{pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
{pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
],
)
}
// Read
export function createReadAssociatedTokenInstruction(
mint: PublicKey,
owner: PublicKey,
programId: PublicKey,
): TransactionInstruction {
const newAssociatedToken = getAssociatedTokenAddressSync(mint, owner)
return createBaseInstruction(
programId,
MyInstructions.ReadAssociatedToken,
[
{pubkey: newAssociatedToken, isSigner: false, isWritable: false},
{pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
{pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
],
)
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests/tokens
|
solana_public_repos/nautilus-project/nautilus/tests/tests/tokens/instructions/nft.ts
|
import * as borsh from "borsh"
import { Buffer } from "buffer"
import { PROGRAM_ID as METADATA_PROGRAM_ID } from '@metaplex-foundation/mpl-token-metadata'
import { ASSOCIATED_TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync, TOKEN_PROGRAM_ID } from '@solana/spl-token'
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction
} from '@solana/web3.js'
import { createBaseInstruction, MyInstructions } from "."
// Create
class CreateNftInstructionData {
instruction: MyInstructions
title: string
symbol: string
uri: string
constructor(props: {
instruction: MyInstructions,
title: string,
symbol: string,
uri: string,
}) {
this.instruction = props.instruction
this.title = props.title
this.symbol = props.symbol
this.uri = props.uri
}
toBuffer() {
return Buffer.from(borsh.serialize(CreateNftInstructionDataSchema, this))
}
}
const CreateNftInstructionDataSchema = new Map([
[ CreateNftInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
['title', 'string'],
['symbol', 'string'],
['uri', 'string'],
],
}]
])
function getMetadataAddress(mint: PublicKey): PublicKey {
return PublicKey.findProgramAddressSync(
[
Buffer.from("metadata"),
METADATA_PROGRAM_ID.toBuffer(),
mint.toBuffer(),
],
METADATA_PROGRAM_ID,
)[0]
}
function createCreateInstruction(
newMint: PublicKey,
payer: PublicKey,
programId: PublicKey,
title: string,
symbol: string,
uri: string,
instruction: MyInstructions,
): TransactionInstruction {
const myInstructionObject = new CreateNftInstructionData({instruction, title, symbol, uri})
const newMetadata = getMetadataAddress(newMint)
function deriveKeys(instruction: MyInstructions) {
if (instruction === MyInstructions.CreateNft) return [
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: newMint, isSigner: true, isWritable: true},
{pubkey: newMetadata, isSigner: false, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
{pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
{pubkey: METADATA_PROGRAM_ID, isSigner: false, isWritable: false},
]
else if (instruction === MyInstructions.CreateNftWithPayer) return [
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: newMint, isSigner: true, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: newMetadata, isSigner: false, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
{pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
{pubkey: METADATA_PROGRAM_ID, isSigner: false, isWritable: false},
]
return []
}
const keys = deriveKeys(instruction)
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
export function createCreateNftInstruction(
newMint: PublicKey,
payer: PublicKey,
programId: PublicKey,
title: string,
symbol: string,
uri: string,
): TransactionInstruction {
return createCreateInstruction(newMint, payer, programId, title, symbol, uri, MyInstructions.CreateNft)
}
export function createCreateNftWithPayerInstruction(
newMint: PublicKey,
payer: PublicKey,
programId: PublicKey,
title: string,
symbol: string,
uri: string,
): TransactionInstruction {
return createCreateInstruction(newMint, payer, programId, title, symbol, uri, MyInstructions.CreateNftWithPayer)
}
// Mint To
export function createNftMintToInstruction(
mint: PublicKey,
recipient: PublicKey,
authority: PublicKey,
programId: PublicKey,
): TransactionInstruction {
const metadata = getMetadataAddress(mint)
const recipientAssociatedToken = getAssociatedTokenAddressSync(mint, recipient)
return createBaseInstruction(
programId,
MyInstructions.NftMintTo,
[
{pubkey: authority, isSigner: true, isWritable: true},
{pubkey: mint, isSigner: false, isWritable: true},
{pubkey: recipientAssociatedToken, isSigner: false, isWritable: true},
{pubkey: metadata, isSigner: false, isWritable: true},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
{pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
{pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
{pubkey: METADATA_PROGRAM_ID, isSigner: false, isWritable: false},
],
)
}
// Read
export function createReadNftInstruction(
mint: PublicKey,
programId: PublicKey,
): TransactionInstruction {
const newMetadata = getMetadataAddress(mint)
return createBaseInstruction(
programId,
MyInstructions.ReadNft,
[
{pubkey: mint, isSigner: false, isWritable: false},
{pubkey: newMetadata, isSigner: false, isWritable: false},
{pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
{pubkey: METADATA_PROGRAM_ID, isSigner: false, isWritable: false},
],
)
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests/tokens
|
solana_public_repos/nautilus-project/nautilus/tests/tests/tokens/instructions/index.ts
|
export * from './associated-token'
export * from './mint'
export * from './metadata'
export * from './nft'
export * from './token'
import { TOKEN_PROGRAM_ID } from '@solana/spl-token'
import { PublicKey, SystemProgram, TransactionInstruction } from '@solana/web3.js'
import * as borsh from "borsh"
import { Buffer } from "buffer"
export enum MyInstructions {
CreateMint,
CreateMintWithPayer,
MintMintTo,
MintDisableMinting,
ReadMint,
CreateMetadata,
CreateMetadataWithPayer,
ReadMetadata,
CreateAssociatedToken,
CreateAssociatedTokenWithPayer,
ReadAssociatedToken,
BurnTokens,
TransferTokens,
FreezeAccount,
ThawAccount,
CreateToken,
CreateTokenWithPayer,
TokenMintTo,
TokenDisableMinting,
ReadToken,
CreateNft,
CreateNftWithPayer,
NftMintTo,
ReadNft,
}
export class BaseInstructionData {
instruction: MyInstructions
constructor(props: {
instruction: MyInstructions,
}) {
this.instruction = props.instruction
}
toBuffer() {
return Buffer.from(borsh.serialize(BaseInstructionDataSchema, this))
}
}
const BaseInstructionDataSchema = new Map([
[ BaseInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
],
}]
])
export function createBaseInstruction(
programId: PublicKey,
instruction: MyInstructions,
keys: {pubkey: PublicKey, isSigner: boolean, isWritable: boolean}[],
): TransactionInstruction {
const myInstructionObject = new BaseInstructionData({instruction})
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests/tokens
|
solana_public_repos/nautilus-project/nautilus/tests/tests/tokens/instructions/metadata.ts
|
import * as borsh from "borsh"
import { Buffer } from "buffer"
import { PROGRAM_ID as METADATA_PROGRAM_ID } from '@metaplex-foundation/mpl-token-metadata'
import { TOKEN_PROGRAM_ID } from '@solana/spl-token'
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction
} from '@solana/web3.js'
import { createBaseInstruction, MyInstructions } from "."
class CreateMetadataInstructionData {
instruction: MyInstructions
title: string
symbol: string
uri: string
constructor(props: {
instruction: MyInstructions,
title: string,
symbol: string,
uri: string,
}) {
this.instruction = props.instruction
this.title = props.title
this.symbol = props.symbol
this.uri = props.uri
}
toBuffer() {
return Buffer.from(borsh.serialize(CreateMetadataInstructionDataSchema, this))
}
}
const CreateMetadataInstructionDataSchema = new Map([
[ CreateMetadataInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
['title', 'string'],
['symbol', 'string'],
['uri', 'string'],
],
}]
])
function getMetadataAddress(mint: PublicKey): PublicKey {
return PublicKey.findProgramAddressSync(
[
Buffer.from("metadata"),
METADATA_PROGRAM_ID.toBuffer(),
mint.toBuffer(),
],
METADATA_PROGRAM_ID,
)[0]
}
function createInstruction(
mint: PublicKey,
payer: PublicKey,
programId: PublicKey,
title: string,
symbol: string,
uri: string,
instruction: MyInstructions,
): TransactionInstruction {
const myInstructionObject = new CreateMetadataInstructionData({instruction, title, symbol, uri})
const newMetadata = getMetadataAddress(mint)
function deriveKeys(instruction: MyInstructions) {
if (instruction === MyInstructions.CreateMetadata) return [
{pubkey: mint, isSigner: false, isWritable: false},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: newMetadata, isSigner: false, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
{pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
{pubkey: METADATA_PROGRAM_ID, isSigner: false, isWritable: false},
]
else if (instruction === MyInstructions.CreateMetadataWithPayer) return [
{pubkey: mint, isSigner: false, isWritable: false},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: newMetadata, isSigner: false, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
{pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
{pubkey: METADATA_PROGRAM_ID, isSigner: false, isWritable: false},
]
return []
}
const keys = deriveKeys(instruction)
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
export function createCreateMetadataInstruction(
mint: PublicKey,
payer: PublicKey,
programId: PublicKey,
title: string,
symbol: string,
uri: string,
): TransactionInstruction {
return createInstruction(mint, payer, programId, title, symbol, uri, MyInstructions.CreateMetadata)
}
export function createReadMetadataInstruction(
mint: PublicKey,
programId: PublicKey,
): TransactionInstruction {
const newMetadata = getMetadataAddress(mint)
return createBaseInstruction(
programId,
MyInstructions.ReadMetadata,
[
{pubkey: newMetadata, isSigner: false, isWritable: false},
{pubkey: METADATA_PROGRAM_ID, isSigner: false, isWritable: false},
],
)
}
export function createCreateMetadataWithPayerInstruction(
mint: PublicKey,
payer: PublicKey,
programId: PublicKey,
title: string,
symbol: string,
uri: string,
): TransactionInstruction {
return createInstruction(mint, payer, programId, title, symbol, uri, MyInstructions.CreateMetadataWithPayer)
}
export function createReadMetadataCreatedWithPayerInstruction(
mint: PublicKey,
programId: PublicKey,
): TransactionInstruction {
const newMetadata = getMetadataAddress(mint)
return createBaseInstruction(
programId,
MyInstructions.ReadMetadataCreatedWithPayer,
[
{pubkey: newMetadata, isSigner: false, isWritable: false},
{pubkey: METADATA_PROGRAM_ID, isSigner: false, isWritable: false},
],
)
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/tests/tokens
|
solana_public_repos/nautilus-project/nautilus/tests/tests/tokens/instructions/token.ts
|
import * as borsh from "borsh"
import { Buffer } from "buffer"
import { PROGRAM_ID as METADATA_PROGRAM_ID } from '@metaplex-foundation/mpl-token-metadata'
import { ASSOCIATED_TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync, TOKEN_PROGRAM_ID } from '@solana/spl-token'
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction
} from '@solana/web3.js'
import { createBaseInstruction, MyInstructions } from "."
// Create
class CreateTokenInstructionData {
instruction: MyInstructions
decimals: number
title: string
symbol: string
uri: string
constructor(props: {
instruction: MyInstructions,
decimals: number
title: string,
symbol: string,
uri: string,
}) {
this.instruction = props.instruction
this.decimals = props.decimals
this.title = props.title
this.symbol = props.symbol
this.uri = props.uri
}
toBuffer() {
return Buffer.from(borsh.serialize(CreateTokenInstructionDataSchema, this))
}
}
const CreateTokenInstructionDataSchema = new Map([
[ CreateTokenInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
['decimals', 'u8'],
['title', 'string'],
['symbol', 'string'],
['uri', 'string'],
],
}]
])
function getMetadataAddress(mint: PublicKey): PublicKey {
return PublicKey.findProgramAddressSync(
[
Buffer.from("metadata"),
METADATA_PROGRAM_ID.toBuffer(),
mint.toBuffer(),
],
METADATA_PROGRAM_ID,
)[0]
}
function createCreateInstruction(
newMint: PublicKey,
payer: PublicKey,
programId: PublicKey,
decimals: number,
title: string,
symbol: string,
uri: string,
instruction: MyInstructions,
): TransactionInstruction {
const myInstructionObject = new CreateTokenInstructionData({instruction, decimals, title, symbol, uri})
const newMetadata = getMetadataAddress(newMint)
function deriveKeys(instruction: MyInstructions) {
if (instruction === MyInstructions.CreateToken) return [
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: newMint, isSigner: true, isWritable: true},
{pubkey: newMetadata, isSigner: false, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
{pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
{pubkey: METADATA_PROGRAM_ID, isSigner: false, isWritable: false},
]
else if (instruction === MyInstructions.CreateTokenWithPayer) return [
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: newMint, isSigner: true, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: newMetadata, isSigner: false, isWritable: true},
{pubkey: payer, isSigner: true, isWritable: true},
{pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
{pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
{pubkey: METADATA_PROGRAM_ID, isSigner: false, isWritable: false},
]
return []
}
const keys = deriveKeys(instruction)
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
export function createCreateTokenInstruction(
newMint: PublicKey,
payer: PublicKey,
programId: PublicKey,
decimals: number,
title: string,
symbol: string,
uri: string,
): TransactionInstruction {
return createCreateInstruction(newMint, payer, programId, decimals, title, symbol, uri, MyInstructions.CreateToken)
}
export function createCreateTokenWithPayerInstruction(
newMint: PublicKey,
payer: PublicKey,
programId: PublicKey,
decimals: number,
title: string,
symbol: string,
uri: string,
): TransactionInstruction {
return createCreateInstruction(newMint, payer, programId, decimals, title, symbol, uri, MyInstructions.CreateTokenWithPayer)
}
// Mint To
class TokenMintToInstructionData {
instruction: MyInstructions
amount: number
constructor(props: {
instruction: MyInstructions,
amount: number,
}) {
this.instruction = props.instruction
this.amount = props.amount
}
toBuffer() {
return Buffer.from(borsh.serialize(TokenMintToInstructionDataSchema, this))
}
}
const TokenMintToInstructionDataSchema = new Map([
[ TokenMintToInstructionData, {
kind: 'struct',
fields: [
['instruction', 'u8'],
['amount', 'u64'],
],
}]
])
export function createTokenMintToInstruction(
mint: PublicKey,
recipient: PublicKey,
authority: PublicKey,
programId: PublicKey,
amount: number,
): TransactionInstruction {
const myInstructionObject = new TokenMintToInstructionData({
instruction: MyInstructions.TokenMintTo,
amount,
})
const metadata = getMetadataAddress(mint)
const recipientAssociatedToken = getAssociatedTokenAddressSync(mint, recipient)
const keys = [
{pubkey: authority, isSigner: true, isWritable: true},
{pubkey: recipientAssociatedToken, isSigner: false, isWritable: true},
{pubkey: mint, isSigner: false, isWritable: true},
{pubkey: metadata, isSigner: false, isWritable: true},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
{pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
{pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
{pubkey: METADATA_PROGRAM_ID, isSigner: false, isWritable: false},
]
return new TransactionInstruction({
keys,
programId,
data: myInstructionObject.toBuffer(),
})
}
// Disable Minting
export function createTokenDisableMintingInstruction(
instruction: MyInstructions,
mint: PublicKey,
authority: PublicKey,
programId: PublicKey,
): TransactionInstruction {
const metadata = getMetadataAddress(mint)
return createBaseInstruction(
programId,
instruction,
[
{pubkey: authority, isSigner: true, isWritable: true},
{pubkey: mint, isSigner: false, isWritable: true},
{pubkey: metadata, isSigner: false, isWritable: true},
{pubkey: SystemProgram.programId, isSigner: false, isWritable: false},
{pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
{pubkey: METADATA_PROGRAM_ID, isSigner: false, isWritable: false},
],
)
}
// Read
export function createReadTokenInstruction(
mint: PublicKey,
programId: PublicKey,
): TransactionInstruction {
const newMetadata = getMetadataAddress(mint)
return createBaseInstruction(
programId,
MyInstructions.ReadToken,
[
{pubkey: mint, isSigner: false, isWritable: false},
{pubkey: newMetadata, isSigner: false, isWritable: false},
{pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false},
{pubkey: METADATA_PROGRAM_ID, isSigner: false, isWritable: false},
],
)
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/programs
|
solana_public_repos/nautilus-project/nautilus/tests/programs/records/Cargo.toml
|
[package]
name = "program-nautilus"
version = "0.1.0"
edition = "2021"
[lib]
crate-type = ["cdylib", "lib"]
[dependencies]
nautilus = { path = "../../../solana", version = "0.0.1" }
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/programs/records
|
solana_public_repos/nautilus-project/nautilus/tests/programs/records/src/lib.rs
|
//! Testing data records (PDAs).
use nautilus::splogger::{info, Splog};
use nautilus::*;
#[nautilus]
mod program_nautilus {
// Right now, the Nautilus Index must be initialized ahead of time.
// Perhaps we can do this with the CLI.
fn initialize<'a>(mut nautilus_index: Create<'a, NautilusIndex<'a>>) -> ProgramResult {
info!("Index size: {}", nautilus_index.span()?);
//
// /* Business Logic */
//
nautilus_index.create()?;
//
Ok(())
}
fn create_person<'a>(
mut new_person: Create<'a, Record<'a, Person>>,
name: String,
authority: Pubkey,
) -> ProgramResult {
info!("-- New Person: {}", &new_person.key());
info!("-- Authority: {}", &authority);
//
// /* Business Logic */
//
new_person.create(name, authority)?;
//
new_person.self_account.print();
Ok(())
}
fn read_person<'a>(person: Record<'a, Person>) -> ProgramResult {
person.print();
//
// /* Business Logic */
//
Ok(())
}
fn create_home<'a>(
mut new_home: Create<'a, Record<'a, Home>>,
id: u8,
house_number: u8,
street: String,
) -> ProgramResult {
info!("-- New Home: {}", &new_home.key());
//
// /* Business Logic */
//
new_home.create(id, house_number, street)?;
//
new_home.self_account.print();
Ok(())
}
fn read_home<'a>(home: Record<'a, Home>) -> ProgramResult {
home.print();
//
// /* Business Logic */
//
Ok(())
}
fn create_car<'a>(
mut new_car: Create<'a, Record<'a, Car>>,
make: String,
model: String,
purchase_authority: Pubkey,
operating_authority: Pubkey,
) -> ProgramResult {
info!("-- New Car: {}", &new_car.key());
//
// /* Business Logic */
//
new_car.create(make, model, purchase_authority, operating_authority)?;
//
new_car.self_account.print();
Ok(())
}
fn read_car<'a>(car: Record<'a, Car>) -> ProgramResult {
car.print();
//
// /* Business Logic */
//
Ok(())
}
fn fund_person<'a>(
person: Mut<Record<'a, Person>>,
payer: Signer<Wallet<'a>>,
amount: u64,
) -> ProgramResult {
payer.transfer_lamports(person, amount)
}
fn transfer_from_person<'a>(
person: Mut<Record<'a, Person>>,
recipient: Mut<Wallet<'a>>,
amount: u64,
) -> ProgramResult {
person.transfer_lamports(recipient, amount)
}
fn fund_home<'a>(
home: Mut<Record<'a, Home>>,
payer: Signer<Wallet<'a>>,
amount: u64,
) -> ProgramResult {
payer.transfer_lamports(home, amount)
}
fn transfer_from_home<'a>(
home: Mut<Record<'a, Home>>,
recipient: Mut<Wallet<'a>>,
amount: u64,
) -> ProgramResult {
home.transfer_lamports(recipient, amount)
}
fn fund_car<'a>(
car: Mut<Record<'a, Car>>,
payer: Signer<Wallet<'a>>,
amount: u64,
) -> ProgramResult {
payer.transfer_lamports(car, amount)
}
fn transfer_from_car<'a>(
car: Mut<Record<'a, Car>>,
recipient: Mut<Wallet<'a>>,
amount: u64,
) -> ProgramResult {
car.transfer_lamports(recipient, amount)
}
}
#[derive(Table)]
struct Person {
#[primary_key(autoincrement = true)]
id: u8,
name: String,
#[authority]
authority: Pubkey,
}
#[derive(Table)]
struct Home {
#[primary_key(autoincrement = false)]
id: u8,
house_number: u8,
street: String,
}
#[derive(Table)]
#[default_instructions(Create, Delete, Update)]
struct Car {
#[primary_key(autoincrement = true)]
id: u8,
make: String,
model: String,
#[authority]
purchase_authority: Pubkey,
#[authority]
operating_authority: Pubkey,
}
//
pub trait TestPrint {
fn print(&self);
}
impl TestPrint for Record<'_, Person> {
fn print(&self) {
info!("-- Person: {}", self.key());
info!(" ID: {}", self.data.id);
info!(" Name: {}", self.data.name);
info!(" Authority: {}", self.data.authority);
}
}
impl TestPrint for Record<'_, Home> {
fn print(&self) {
info!("-- Home: {}", self.key());
info!(" ID: {}", self.data.id);
info!(" House Number: {}", self.data.house_number);
info!(" Street: {}", self.data.street);
}
}
impl TestPrint for Record<'_, Car> {
fn print(&self) {
info!("-- Car: {}", self.key());
info!(" ID: {}", self.data.id);
info!(" Make: {}", self.data.make);
info!(" Model: {}", self.data.model);
info!(" Purchase Auth: {}", self.data.purchase_authority);
info!(" Operating Auth: {}", self.data.operating_authority);
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/programs
|
solana_public_repos/nautilus-project/nautilus/tests/programs/accounts/Cargo.toml
|
[package]
name = "program-nautilus"
version = "0.1.0"
edition = "2021"
[lib]
crate-type = ["cdylib", "lib"]
[dependencies]
nautilus = { path = "../../../solana", version = "0.0.1" }
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/programs/accounts
|
solana_public_repos/nautilus-project/nautilus/tests/programs/accounts/src/lib.rs
|
//! Testing non-record data accounts (PDAs).
use nautilus::splogger::{info, Splog};
use nautilus::*;
#[nautilus]
mod program_nautilus {
fn create_person<'a>(
mut new_person: Create<'a, Account<'a, Person>>,
name: String,
authority: Pubkey,
) -> ProgramResult {
info!(" * New Person: {}", &new_person.key());
info!(" * Authority: {}", &authority);
//
// /* Business Logic */
//
new_person.create(name, authority)?;
//
new_person.self_account.print();
Ok(())
}
fn read_person<'a>(person: Account<'a, Person>) -> ProgramResult {
person.print();
//
// /* Business Logic */
//
Ok(())
}
fn create_home<'a>(
mut new_home: Create<'a, Account<'a, Home>>,
house_number: u8,
street: String,
some_pubkey: Pubkey,
) -> ProgramResult {
info!(" * New Home: {}", &new_home.key());
//
// /* Business Logic */
//
new_home.create(house_number, street, (some_pubkey,))?; // Seed parameter required
//
new_home.self_account.print();
Ok(())
}
fn read_home<'a>(home: Account<'a, Home>) -> ProgramResult {
home.print();
//
// /* Business Logic */
//
Ok(())
}
fn create_car<'a>(
mut new_car: Create<'a, Account<'a, Car>>,
make: String,
model: String,
purchase_authority: Pubkey,
operating_authority: Pubkey,
) -> ProgramResult {
info!(" * New Car: {}", &new_car.key());
//
// /* Business Logic */
//
new_car.create(make, model, purchase_authority, operating_authority)?;
//
new_car.self_account.print();
Ok(())
}
fn read_car<'a>(car: Account<'a, Car>) -> ProgramResult {
car.print();
//
// /* Business Logic */
//
Ok(())
}
}
#[derive(State)]
#[seeds(
"person", // Literal seed
authority, // Self-referencing seed
)]
struct Person {
name: String,
#[authority]
authority: Pubkey,
}
#[derive(State)]
#[seeds(
"home", // Literal seed
some_pubkey: Pubkey, // Parameter seed
)]
struct Home {
house_number: u8,
street: String,
}
#[derive(State)]
#[seeds(
"car", // Literal seed
purchase_authority, // Self-referencing seed
operating_authority, // Self-referencing seed
)]
struct Car {
make: String,
model: String,
#[authority]
purchase_authority: Pubkey,
#[authority]
operating_authority: Pubkey,
}
//
pub trait TestPrint {
fn print(&self);
}
impl TestPrint for Account<'_, Person> {
fn print(&self) {
info!(" * Person: {}", self.key());
info!(" Name: {}", self.data.name);
info!(" Authority: {}", self.data.authority);
}
}
impl TestPrint for Account<'_, Home> {
fn print(&self) {
info!(" * Home: {}", self.key());
info!(" House Number: {}", self.data.house_number);
info!(" Street: {}", self.data.street);
}
}
impl TestPrint for Account<'_, Car> {
fn print(&self) {
info!(" * Car: {}", self.key());
info!(" Make: {}", self.data.make);
info!(" Model: {}", self.data.model);
info!(" Purchase Auth: {}", self.data.purchase_authority);
info!(" Operating Auth: {}", self.data.operating_authority);
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/programs
|
solana_public_repos/nautilus-project/nautilus/tests/programs/wallets/Cargo.toml
|
[package]
name = "program-nautilus"
version = "0.1.0"
edition = "2021"
[lib]
crate-type = ["cdylib", "lib"]
[dependencies]
nautilus = { path = "../../../solana", version = "0.0.1" }
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/programs/wallets
|
solana_public_repos/nautilus-project/nautilus/tests/programs/wallets/src/lib.rs
|
//! Testing system accounts.
use nautilus::splogger::{info, Splog};
use nautilus::*;
#[nautilus]
mod program_nautilus {
fn allocate<'a>(new_wallet: Create<'a, Wallet<'a>>) -> ProgramResult {
print_wallet_details(&new_wallet, "Allocate acct pre-allocate");
//
// /* Business Logic */
//
new_wallet.allocate()?;
//
print_wallet_details(&new_wallet, "Allocate acct post-allocate");
Ok(())
}
fn assign<'a>(wallet: Signer<Wallet<'a>>, new_owner: Pubkey) -> ProgramResult {
print_wallet_details(&wallet, "Assign acct pre-assign");
//
// /* Business Logic */
//
wallet.assign(new_owner)?;
//
print_wallet_details(&wallet, "Assign acct post-assign");
Ok(())
}
fn create<'a>(mut new_wallet: Create<'a, Wallet<'a>>) -> ProgramResult {
print_wallet_details(&new_wallet, "Create acct pre-create");
//
// /* Business Logic */
//
new_wallet.create()?;
//
print_wallet_details(&new_wallet, "Create acct post-create");
Ok(())
}
fn create_with_payer<'a>(
mut new_wallet: Create<'a, Wallet<'a>>,
rent_payer: Signer<Wallet<'a>>,
) -> ProgramResult {
print_wallet_details(&new_wallet, "Create acct pre-create");
print_wallet_details(&rent_payer, "Rent payer pre-create");
//
// /* Business Logic */
//
new_wallet.create_with_payer(rent_payer.clone())?; // Cloning so we can ref later
//
print_wallet_details(&new_wallet, "Create acct post-create");
print_wallet_details(&rent_payer, "Rent payer post-create");
Ok(())
}
fn read(wallet: Wallet) -> ProgramResult {
print_wallet_details(&wallet, "Read");
//
// /* Business Logic */
//
Ok(())
}
fn transfer<'a>(from: Signer<Wallet<'a>>, to: Mut<Wallet<'a>>, amount: u64) -> ProgramResult {
print_wallet_details(&from, "From acct pre-transfer");
print_wallet_details(&to, "To acct pre-transfer");
info!(
"Transferring {} From: {} to: {}",
amount,
from.key(),
to.key()
);
//
// /* Business Logic */
//
from.transfer_lamports(to.clone(), amount)?; // Cloning so we can ref later
//
print_wallet_details(&from, "From acct post-transfer");
print_wallet_details(&to, "To acct post-transfer");
Ok(())
}
/// A simluated "complex" program instruction to test Nautilus.
/// The logic herein is just for example.
fn complex<'a>(
_authority1: Signer<Wallet<'a>>, // Marking this as `Signer` will ensure it's a signer on the tx.
authority2: Signer<Wallet<'a>>,
rent_payer1: Signer<Wallet<'a>>,
rent_payer2: Signer<Wallet<'a>>,
wallet_to_allocate: Create<'a, Wallet<'a>>, // Marking this as `Create` will ensure it hasn't been created.
mut wallet_to_create: Create<'a, Wallet<'a>>,
wallet_to_create_with_transfer_safe: Create<'a, Wallet<'a>>,
wallet_to_create_with_transfer_unsafe: Mut<Wallet<'a>>,
some_other_transfer_recipient: Mut<Wallet<'a>>,
amount_to_fund: u64,
amount_to_transfer: u64,
) -> ProgramResult {
//
// /* Business Logic */
//
// Some random checks to simulate how custom checks might look.
assert!(rent_payer1
.owner()
.eq(&nautilus::solana_program::system_program::ID));
assert!(rent_payer2
.owner()
.eq(&nautilus::solana_program::system_program::ID));
// Even though the check will be applied via `Signer` in the function sig, you can still
// check yourself if you choose to.
assert!(authority2.is_signer());
// Even though the check will be applied via `Create` in the function sig, you can still
// check yourself if you choose to.
assert!(wallet_to_allocate.lamports() == 0);
assert!(wallet_to_allocate.is_writable());
wallet_to_allocate.allocate()?;
assert!(wallet_to_create.lamports() == 0);
assert!(wallet_to_create.is_writable());
wallet_to_create.create()?;
// Safe - checked at entry with `Create`.
rent_payer1.transfer_lamports(wallet_to_create_with_transfer_safe, amount_to_fund)?;
// Unsafe - not marked with `Create`.
rent_payer2.transfer_lamports(wallet_to_create_with_transfer_unsafe, amount_to_fund)?;
// Transfer with balance assertions
let from_beg_balance = authority2.lamports();
let to_beg_balance = some_other_transfer_recipient.lamports();
authority2.transfer_lamports(some_other_transfer_recipient.clone(), amount_to_transfer)?;
let from_end_balance = authority2.lamports();
let to_end_balance = some_other_transfer_recipient.lamports();
assert!(from_beg_balance - from_end_balance == amount_to_transfer);
assert!(to_end_balance - to_beg_balance == amount_to_transfer);
//
Ok(())
}
}
fn print_wallet_details<'a>(wallet: &impl NautilusAccountInfo<'a>, desc: &str) {
info!(" * Wallet info for: {}:", desc);
info!(" Address: {}", wallet.key());
info!(" Owner: {}", wallet.owner());
info!(" Size: {}", wallet.size().unwrap());
info!(" Lamports: {}", wallet.lamports());
}
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/programs
|
solana_public_repos/nautilus-project/nautilus/tests/programs/tokens/Cargo.toml
|
[package]
name = "program-nautilus"
version = "0.1.0"
edition = "2021"
[lib]
crate-type = ["cdylib", "lib"]
[dependencies]
nautilus = { path = "../../../solana", version = "0.0.1" }
| 0
|
solana_public_repos/nautilus-project/nautilus/tests/programs/tokens
|
solana_public_repos/nautilus-project/nautilus/tests/programs/tokens/src/lib.rs
|
//! Testing token-related objects.
use nautilus::spl_token::instruction::AuthorityType;
use nautilus::splogger::{info, Splog};
use nautilus::*;
#[nautilus]
mod program_nautilus {
// Mints
fn create_mint<'a>(
mut new_mint: Create<'a, Mint<'a>>,
decimals: u8,
mint_authority: Signer<Wallet<'a>>,
) -> ProgramResult {
info!(" * New Mint Public Key: {}", &new_mint.key());
//
// /* Business Logic */
//
new_mint.create(decimals, mint_authority.clone(), Some(mint_authority))?;
//
print_mint_data(&new_mint.self_account.data, "Create");
Ok(())
}
fn create_mint_with_payer<'a>(
mut new_mint: Create<'a, Mint<'a>>,
decimals: u8,
mint_authority: Signer<Wallet<'a>>,
rent_payer: Signer<Wallet<'a>>,
) -> ProgramResult {
info!(" * New Mint Public Key: {}", &new_mint.key());
info!(" * Rent Payer Public Key: {}", &rent_payer.key());
//
// /* Business Logic */
//
new_mint.create_with_payer(
decimals,
mint_authority.clone(),
Some(mint_authority),
rent_payer,
)?;
//
print_mint_data(&new_mint.self_account.data, "Create with payer");
Ok(())
}
fn mint_mint_to<'a>(
mint: Mut<Mint<'a>>,
to: Mut<AssociatedTokenAccount<'a>>,
authority: Signer<Wallet<'a>>,
amount: u64,
) -> ProgramResult {
print_associated_token_data(&to.self_account.data, "To acct pre-mint");
info!(" * Mint Public Key: {}", &mint.key());
print_mint_data(&mint.self_account.data, "MintTo");
info!("Minting {} tokens to: {}", amount, to.key());
//
// /* Business Logic */
//
mint.mint_to(to.clone(), authority, amount)?; // Cloning so we can ref later
//
print_associated_token_data(&to.self_account.data, "To acct post-mint");
Ok(())
}
fn mint_disable_minting<'a>(
mint: Mut<Mint<'a>>,
authority: Signer<Wallet<'a>>,
) -> ProgramResult {
info!(" * Mint Public Key: {}", &mint.key());
print_mint_data(&mint.self_account.data, "Mint pre-disabling");
//
// /* Business Logic */
//
mint.set_authority(None, AuthorityType::MintTokens, authority)?;
//
print_mint_data(&mint.self_account.data, "Mint post-disabling");
Ok(())
}
fn read_mint(mint: Mint) -> ProgramResult {
info!(" * Mint Public Key: {}", &mint.key());
print_mint_data(&mint.data, "Read");
//
// /* Business Logic */
//
Ok(())
}
// Metadatas
fn create_metadata<'a>(
mut new_metadata: Create<'a, Metadata<'a>>,
mint: Mint<'a>,
title: String,
symbol: String,
uri: String,
mint_authority: Signer<Wallet<'a>>,
) -> ProgramResult {
info!(" * New Metadata Public Key: {}", &new_metadata.key());
info!(" * Mint Public Key: {}", &mint.key());
//
// /* Business Logic */
//
new_metadata.create(
title,
symbol,
uri,
mint,
mint_authority.clone(),
mint_authority,
)?;
//
print_metadata_data(&new_metadata.self_account.data, "Create");
Ok(())
}
fn create_metadata_with_payer<'a>(
mut new_metadata: Create<'a, Metadata<'a>>,
mint: Mint<'a>,
title: String,
symbol: String,
uri: String,
mint_authority: Signer<Wallet<'a>>,
rent_payer: Signer<Wallet<'a>>,
) -> ProgramResult {
info!(" * New Metadata Public Key: {}", &new_metadata.key());
info!(" * Mint Public Key: {}", &mint.key());
info!(" * Rent Payer Public Key: {}", &rent_payer.key());
//
// /* Business Logic */
//
new_metadata.create_with_payer(
title,
symbol,
uri,
mint,
mint_authority.clone(),
mint_authority,
rent_payer,
)?;
//
print_metadata_data(&new_metadata.self_account.data, "Create with payer");
Ok(())
}
fn read_metadata(metadata: Metadata) -> ProgramResult {
info!(" * Metadata Public Key: {}", &metadata.key());
print_metadata_data(&metadata.data, "Read");
//
// /* Business Logic */
//
Ok(())
}
// Associated Token Accounts
fn create_associated_token<'a>(
mut new_associated_token: Create<'a, AssociatedTokenAccount<'a>>,
mint: Mint<'a>,
owner: Wallet<'a>,
) -> ProgramResult {
info!(
" * New AssociatedTokenAccount Public Key: {}",
&new_associated_token.key()
);
info!(" * Mint Public Key: {}", &mint.key());
info!(" * Owner Public Key: {}", &owner.key());
//
// /* Business Logic */
//
new_associated_token.create(mint, owner)?;
//
print_associated_token_data(&new_associated_token.self_account.data, "Create");
Ok(())
}
fn create_associated_token_with_payer<'a>(
mut new_associated_token: Create<'a, AssociatedTokenAccount<'a>>,
mint: Mint<'a>,
owner: Wallet<'a>,
rent_payer: Signer<Wallet<'a>>,
) -> ProgramResult {
info!(
" * New AssociatedTokenAccount Public Key: {}",
&new_associated_token.key()
);
info!(" * Mint Public Key: {}", &mint.key());
info!(" * Owner Public Key: {}", &owner.key());
info!(" * Rent Payer Public Key: {}", &rent_payer.key());
//
// /* Business Logic */
//
new_associated_token.create_with_payer(mint, owner, rent_payer)?;
//
print_associated_token_data(&new_associated_token.self_account.data, "Create with payer");
Ok(())
}
fn read_associated_token(associated_token: AssociatedTokenAccount) -> ProgramResult {
info!(
" * AssociatedTokenAccount Public Key: {}",
&associated_token.key()
);
print_associated_token_data(&associated_token.data, "Read");
//
// /* Business Logic */
//
Ok(())
}
fn burn_tokens<'a>(
mint: Mint<'a>,
from: Mut<AssociatedTokenAccount<'a>>,
authority: Signer<Wallet<'a>>,
amount: u64,
) -> ProgramResult {
print_associated_token_data(&from.self_account.data, "From acct pre-burn");
info!("Burning {} tokens from: {} ", amount, from.key(),);
//
// /* Business Logic */
//
from.burn(mint, authority, amount)?; // Cloning so we can ref later
//
print_associated_token_data(&from.self_account.data, "From acct post-burn");
Ok(())
}
fn transfer_tokens<'a>(
from: Mut<AssociatedTokenAccount<'a>>,
to: Mut<AssociatedTokenAccount<'a>>,
authority: Signer<Wallet<'a>>,
amount: u64,
) -> ProgramResult {
print_associated_token_data(&from.self_account.data, "From acct pre-transfer");
print_associated_token_data(&to.self_account.data, "To acct pre-transfer");
info!(
"Transferring {} tokens from: {} to: {}",
amount,
from.key(),
to.key()
);
//
// /* Business Logic */
//
from.transfer(to.clone(), authority, amount)?; // Cloning so we can ref later
//
print_associated_token_data(&from.self_account.data, "From acct post-transfer");
print_associated_token_data(&to.self_account.data, "To acct post-transfer");
Ok(())
}
fn freeze_account<'a>(
mint: Mint<'a>,
account: Mut<AssociatedTokenAccount<'a>>,
authority: Signer<Wallet<'a>>,
) -> ProgramResult {
info!(" * AssociatedTokenAccount Public Key: {}", &account.key());
print_associated_token_data(&account.self_account.data, "Freeze (pre)");
//
// /* Business Logic */
//
account.freeze(mint, authority)?; // Cloning so we can ref later
//
print_associated_token_data(&account.self_account.data, "Freeze (post)");
Ok(())
}
fn thaw_account<'a>(
mint: Mint<'a>,
account: Mut<AssociatedTokenAccount<'a>>,
authority: Signer<Wallet<'a>>,
) -> ProgramResult {
info!(" * AssociatedTokenAccount Public Key: {}", &account.key());
print_associated_token_data(&account.self_account.data, "Thaw (pre)");
//
// /* Business Logic */
//
account.thaw(mint, authority)?; // Cloning so we can ref later
//
print_associated_token_data(&account.self_account.data, "Thaw (post)");
Ok(())
}
// Tokens
fn create_token<'a>(
mut new_token: Create<'a, Token<'a>>,
decimals: u8,
title: String,
symbol: String,
uri: String,
mint_authority: Signer<Wallet<'a>>,
) -> ProgramResult {
info!(" * New Token Public Key: {}", &new_token.key());
//
// /* Business Logic */
//
new_token.create(
decimals,
title,
symbol,
uri,
mint_authority.clone(),
mint_authority.clone(),
Some(mint_authority),
)?;
//
print_mint_data(&new_token.self_account.mint.data, "Create");
print_metadata_data(&new_token.self_account.metadata.data, "Create");
Ok(())
}
fn create_token_with_payer<'a>(
mut new_token: Create<'a, Token<'a>>,
decimals: u8,
title: String,
symbol: String,
uri: String,
mint_authority: Signer<Wallet<'a>>,
rent_payer: Signer<Wallet<'a>>,
) -> ProgramResult {
info!(" * New Token Public Key: {}", &new_token.key());
info!(" * Rent Payer Public Key: {}", &rent_payer.key());
//
// /* Business Logic */
//
new_token.create_with_payer(
decimals,
title,
symbol,
uri,
mint_authority.clone(),
mint_authority.clone(),
Some(mint_authority),
rent_payer,
)?;
//
print_mint_data(&new_token.self_account.mint.data, "Create with payer");
print_metadata_data(&new_token.self_account.metadata.data, "Create with payer");
Ok(())
}
fn token_mint_to<'a>(
token: Mut<Token<'a>>,
to: Mut<AssociatedTokenAccount<'a>>,
authority: Signer<Wallet<'a>>,
amount: u64,
) -> ProgramResult {
print_associated_token_data(&to.self_account.data, "To acct pre-mint");
info!(" * Token Public Key: {}", &token.key());
print_mint_data(&token.self_account.mint.data, "MintTo");
info!("Minting {} tokens to: {}", amount, to.key());
//
// /* Business Logic */
//
token.mint_to(to.clone(), authority, amount)?; // Cloning so we can ref later
//
print_associated_token_data(&to.self_account.data, "To acct post-mint");
Ok(())
}
fn token_disable_minting<'a>(
token: Mut<Token<'a>>,
authority: Signer<Wallet<'a>>,
) -> ProgramResult {
info!(" * Mint Public Key: {}", &token.key());
print_mint_data(&token.self_account.mint.data, "Token mint pre-disabling");
//
// /* Business Logic */
//
token.set_authority(None, AuthorityType::MintTokens, authority)?;
//
print_mint_data(&token.self_account.mint.data, "token mint post-disabling");
Ok(())
}
fn read_token(token: Token) -> ProgramResult {
info!(" * Token Public Key: {}", &token.key());
print_mint_data(&token.mint.data, "Read");
print_metadata_data(&token.metadata.data, "Read");
//
// /* Business Logic */
//
Ok(())
}
// NFTs
fn create_nft<'a>(
mut new_nft: Create<'a, Nft<'a>>,
title: String,
symbol: String,
uri: String,
mint_authority: Signer<Wallet<'a>>,
) -> ProgramResult {
info!(" * New NFT Public Key: {}", &new_nft.key());
//
// /* Business Logic */
//
new_nft.create(
title,
symbol,
uri,
mint_authority.clone(),
mint_authority.clone(),
Some(mint_authority),
)?;
//
print_mint_data(&new_nft.self_account.mint.data, "Create");
print_metadata_data(&new_nft.self_account.metadata.data, "Create");
Ok(())
}
fn create_nft_with_payer<'a>(
mut new_nft: Create<'a, Nft<'a>>,
title: String,
symbol: String,
uri: String,
mint_authority: Signer<Wallet<'a>>,
rent_payer: Signer<Wallet<'a>>,
) -> ProgramResult {
info!(" * New NFT Public Key: {}", &new_nft.key());
info!(" * Rent Payer Public Key: {}", &rent_payer.key());
//
// /* Business Logic */
//
new_nft.create_with_payer(
title,
symbol,
uri,
mint_authority.clone(),
mint_authority.clone(),
Some(mint_authority),
rent_payer,
)?;
//
print_mint_data(&new_nft.self_account.mint.data, "Create with payer");
print_metadata_data(&new_nft.self_account.metadata.data, "Create with payer");
Ok(())
}
fn nft_mint_to<'a>(
nft: Mut<Nft<'a>>,
to: Mut<AssociatedTokenAccount<'a>>,
authority: Signer<Wallet<'a>>,
) -> ProgramResult {
print_associated_token_data(&to.self_account.data, "To acct pre-mint");
info!(" * NFT Public Key: {}", &nft.key());
print_mint_data(&nft.self_account.mint.data, "MintTo");
info!("Minting NFT to: {}", to.key());
//
// /* Business Logic */
//
nft.mint_to(to.clone(), authority)?; // Cloning so we can ref later
//
print_associated_token_data(&to.self_account.data, "To acct post-mint");
Ok(())
}
fn read_nft(nft: Nft) -> ProgramResult {
info!(" * NFT Public Key: {}", &nft.key());
print_mint_data(&nft.mint.data, "Read");
print_metadata_data(&nft.metadata.data, "Read");
//
// /* Business Logic */
//
Ok(())
}
}
fn print_mint_data(data: &MintState, desc: &str) {
info!(" * Mint Data for: {}:", desc);
info!(" Mint Authority: {:#?}", data.mint_authority);
info!(" Supply: {}", data.supply);
info!(" Decimals: {}", data.decimals);
info!(" Is Initialized: {}", data.is_initialized);
info!(" Freeze Authority: {:#?}", data.freeze_authority);
}
fn print_metadata_data(data: &MetadataState, desc: &str) {
info!(" * Metadata Data for: {}:", desc);
info!(" Mint: {:#?}", data.mint);
info!(
" Primary Sale Happened: {}",
data.primary_sale_happened
);
info!(" Is Mutable: {}", data.is_mutable);
info!(" Edition Nonce: {:#?}", data.edition_nonce);
info!(" Title: {}", data.data.name);
info!(" Symbol: {}", data.data.symbol);
info!(" URI: {}", data.data.uri);
}
fn print_associated_token_data(data: &AssociatedTokenAccountState, desc: &str) {
info!(" * Associated Token Data for: {}:", desc);
info!(" Mint: {:#?}", data.mint);
info!(" Owner: {:#?}", data.owner);
info!(" Amount: {}", data.amount);
info!(" Delegate: {:#?}", data.delegate);
info!(" Is Native: {:#?}", data.is_native);
info!(" Delegated Amount: {}", data.delegated_amount);
info!(" Close Authority: {:#?}", data.close_authority);
}
| 0
|
solana_public_repos/nautilus-project/nautilus
|
solana_public_repos/nautilus-project/nautilus/solana/Cargo.toml
|
[package]
name = "nautilus"
version = "0.0.1"
authors = ["Joe Caulfield <jcaulfield135@gmail.com>"]
repository = "https://github.com/nautilus-project/nautilus"
license = "Apache-2.0"
description = "SQL-native Solana program framework"
rust-version = "1.59"
edition = "2021"
[dependencies]
borsh = "0.9.3"
borsh-derive = "0.9.3"
mpl-token-metadata = { version = "1.9.1", features = ["no-entrypoint"] }
nautilus-derive = { path = "./derive", version = "0.0.1" }
num-traits = "0.2.15"
solana-program = "1.15.2"
spl-associated-token-account = "1.1.3"
spl-token = "3.5.0"
spl-token-2022 = "0.6.1"
splogger = { git = "https://github.com/nautilus-project/splogger", branch = "main", version = "0.0.1" }
thiserror = "1.0.40"
winnow = "=0.4.1"
| 0
|
solana_public_repos/nautilus-project/nautilus
|
solana_public_repos/nautilus-project/nautilus/solana/rustfmt.toml
|
comment_width = 80
wrap_comments = true
| 0
|
solana_public_repos/nautilus-project/nautilus/solana
|
solana_public_repos/nautilus-project/nautilus/solana/idl/Cargo.toml
|
[package]
name = "nautilus-idl"
version = "0.0.1"
authors = ["Joe Caulfield <jcaulfield135@gmail.com>"]
repository = "https://github.com/nautilus-project/nautilus"
license = "Apache-2.0"
description = "Generates an IDL for a Nautilus program"
rust-version = "1.59"
edition = "2021"
[dependencies]
borsh = "0.10.2"
borsh-derive = "0.10.2"
serde = { version = "1.0.152", features = ["derive"] }
serde_json = "1.0.93"
syn = { version = "1.0", features = ["extra-traits", "full"] }
toml = "0.7.2"
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/idl
|
solana_public_repos/nautilus-project/nautilus/solana/idl/tests/idl.rs
|
use nautilus_idl::*;
#[test]
fn idl() {
let (name, version) = parse_cargo_toml("Cargo.toml").unwrap();
let metadata = IdlMetadata::new("some-program-id");
let types = vec![IdlType::new(
"CustomArgs",
IdlTypeType::new(
"struct",
vec![
IdlTypeTypeField::new("string1", "string"),
IdlTypeTypeField::new("string2", "string"),
],
),
)];
let accounts = vec![
IdlAccount::new(
"Hero",
IdlTypeType::new(
"struct",
vec![
IdlTypeTypeField::new("id", "u8"),
IdlTypeTypeField::new("name", "string"),
IdlTypeTypeField::new("authority", "publicKey"),
],
),
),
IdlAccount::new(
"Villain",
IdlTypeType::new(
"struct",
vec![
IdlTypeTypeField::new("id", "u8"),
IdlTypeTypeField::new("name", "string"),
IdlTypeTypeField::new("authority", "publicKey"),
],
),
),
];
let instructions = vec![
IdlInstruction::new(
"CreateHero",
vec![
IdlInstructionAccount::new(
"autoincAccount",
true,
false,
"The autoincrement account.",
),
IdlInstructionAccount::new("newAccount", true, false, "The account to be created."),
IdlInstructionAccount::new(
"authority",
true,
true,
"One of the authorities specified for this account.",
),
IdlInstructionAccount::new("feePayer", true, true, "Fee payer"),
IdlInstructionAccount::new("systemProgram", false, false, "The System Program"),
],
vec![IdlInstructionArg::new(
"hero",
IdlInstructionArgType::new("Hero"),
)],
IdlInstructionDiscriminant::new(0),
),
IdlInstruction::new(
"DeleteHero",
vec![
IdlInstructionAccount::new(
"targetAccount",
true,
false,
"The account to be deleted.",
),
IdlInstructionAccount::new(
"authority",
true,
true,
"One of the authorities specified for this account.",
),
IdlInstructionAccount::new("feePayer", true, true, "Fee payer"),
],
vec![],
IdlInstructionDiscriminant::new(1),
),
IdlInstruction::new(
"UpdateHero",
vec![
IdlInstructionAccount::new(
"targetAccount",
true,
false,
"The account to be updated.",
),
IdlInstructionAccount::new(
"authority",
true,
true,
"One of the authorities specified for this account.",
),
IdlInstructionAccount::new("feePayer", true, true, "Fee payer"),
IdlInstructionAccount::new("systemProgram", false, false, "The System Program"),
],
vec![IdlInstructionArg::new(
"hero",
IdlInstructionArgType::new("Hero"),
)],
IdlInstructionDiscriminant::new(2),
),
IdlInstruction::new(
"CreateVillain",
vec![
IdlInstructionAccount::new(
"autoincAccount",
true,
false,
"The autoincrement account.",
),
IdlInstructionAccount::new("newAccount", true, false, "The account to be created."),
IdlInstructionAccount::new(
"authority",
true,
true,
"One of the authorities specified for this account.",
),
IdlInstructionAccount::new("feePayer", true, true, "Fee payer"),
IdlInstructionAccount::new("systemProgram", false, false, "The System Program"),
],
vec![IdlInstructionArg::new(
"villain",
IdlInstructionArgType::new("Villain"),
)],
IdlInstructionDiscriminant::new(3),
),
IdlInstruction::new(
"DeleteVillain",
vec![
IdlInstructionAccount::new(
"targetAccount",
true,
false,
"The account to be deleted.",
),
IdlInstructionAccount::new(
"authority",
true,
true,
"One of the authorities specified for this account.",
),
IdlInstructionAccount::new("feePayer", true, true, "Fee payer"),
],
vec![],
IdlInstructionDiscriminant::new(4),
),
IdlInstruction::new(
"UpdateVillain",
vec![
IdlInstructionAccount::new(
"targetAccount",
true,
false,
"The account to be updated.",
),
IdlInstructionAccount::new(
"authority",
true,
true,
"One of the authorities specified for this account.",
),
IdlInstructionAccount::new("feePayer", true, true, "Fee payer"),
IdlInstructionAccount::new("systemProgram", false, false, "The System Program"),
],
vec![IdlInstructionArg::new(
"villain",
IdlInstructionArgType::new("Villain"),
)],
IdlInstructionDiscriminant::new(5),
),
IdlInstruction::new(
"CustomInstruction",
vec![
IdlInstructionAccount::new(
"targetAccount",
true,
false,
"The account to be used as a test.",
),
IdlInstructionAccount::new(
"authority",
true,
true,
"One of the authorities specified for this account.",
),
IdlInstructionAccount::new("feePayer", true, true, "Fee payer"),
IdlInstructionAccount::new("systemProgram", false, false, "The System Program"),
],
vec![IdlInstructionArg::new(
"customArgs",
IdlInstructionArgType::new("CustomArgs"),
)],
IdlInstructionDiscriminant::new(6),
),
];
let idl = Idl::new(&version, &name, instructions, accounts, types, metadata);
idl.write_to_json("./target/idl");
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/idl
|
solana_public_repos/nautilus-project/nautilus/solana/idl/src/util.rs
|
use super::{idl_metadata::IdlMetadata, Idl};
pub fn load_idl_from_json(idl_path: &str) -> std::io::Result<Idl> {
let file = std::fs::File::open(idl_path)?;
let idl: Idl = serde_json::from_reader(file)?;
Ok(idl)
}
pub fn update_program_id(idl_path: &str, program_id: &str) -> std::io::Result<()> {
let mut idl: Idl = load_idl_from_json(idl_path)?;
idl.metadata = IdlMetadata::new(program_id);
idl.write_to_json(idl_path)?;
Ok(())
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/idl
|
solana_public_repos/nautilus-project/nautilus/solana/idl/src/idl_instruction.rs
|
use serde::{Deserialize, Serialize};
use super::idl_type::IdlType;
/// An IDL instruction.
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct IdlInstruction {
pub name: String,
pub accounts: Vec<IdlInstructionAccount>,
pub args: Vec<IdlInstructionArg>,
pub discriminant: IdlInstructionDiscriminant,
}
impl IdlInstruction {
pub fn new(
name: &str,
accounts: Vec<IdlInstructionAccount>,
args: Vec<IdlInstructionArg>,
discriminant: IdlInstructionDiscriminant,
) -> Self {
Self {
name: name.to_string(),
accounts,
args,
discriminant,
}
}
}
/// An account listed in an IDL instruction.
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct IdlInstructionAccount {
pub name: String,
pub is_mut: bool,
pub is_signer: bool,
#[serde(rename = "type")]
pub account_type: String,
pub desc: String,
}
impl IdlInstructionAccount {
pub fn new(
name: String,
is_mut: bool,
is_signer: bool,
account_type: String,
desc: String,
) -> Self {
Self {
name,
is_mut,
is_signer,
account_type,
desc,
}
}
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct IdlInstructionArg {
pub name: String,
#[serde(rename = "type")]
pub arg_type: IdlType,
}
impl IdlInstructionArg {
pub fn new(name: String, arg_type: IdlType) -> Self {
Self { name, arg_type }
}
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct IdlInstructionDiscriminant {
#[serde(rename = "type")]
pub discriminant_type: IdlType,
pub value: u8,
}
impl IdlInstructionDiscriminant {
pub fn new(value: u8) -> Self {
Self {
discriminant_type: IdlType::U8,
value,
}
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/idl
|
solana_public_repos/nautilus-project/nautilus/solana/idl/src/lib.rs
|
//
//
// ----------------------------------------------------------------
// Nautilus IDL
// ----------------------------------------------------------------
//
// Much of this IDL crate is inspired by or borrowed directly from Metaplex's
// Shank.
//
// Nautilus and its contributors intend to introduce a shared, dynamic IDL crate
// to be used by anyone across the Solana community.
//
// All credit to contributors at Metaplex for anything borrowed in this crate.
//
// Shank: https://github.com/metaplex-foundation/shank
//
//
use std::{
fs::{self, File},
io::Write,
path::Path,
};
use serde::{Deserialize, Serialize};
use self::{idl_instruction::IdlInstruction, idl_metadata::IdlMetadata, idl_type_def::IdlTypeDef};
pub mod converters;
pub mod idl_instruction;
pub mod idl_metadata;
pub mod idl_nautilus_config;
pub mod idl_type;
pub mod idl_type_def;
pub mod util;
/// The entire IDL itself.
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Idl {
pub version: String,
pub name: String,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub instructions: Vec<IdlInstruction>,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub accounts: Vec<IdlTypeDef>,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub types: Vec<IdlTypeDef>,
pub metadata: IdlMetadata,
}
impl Idl {
pub fn new(
version: String,
name: String,
instructions: Vec<IdlInstruction>,
accounts: Vec<IdlTypeDef>,
types: Vec<IdlTypeDef>,
metadata: IdlMetadata,
) -> Self {
Self {
version,
name,
instructions,
accounts,
types,
metadata,
}
}
pub fn write_to_json(&self, dir_path: &str) -> std::io::Result<()> {
if dir_path != "." {
fs::create_dir_all(dir_path)?;
}
let idl_path = Path::join(Path::new(dir_path), &format!("{}.json", &self.name));
let mut file = File::create(idl_path)?;
let json_string = serde_json::to_string(&self)?;
file.write_all(json_string.as_bytes())?;
Ok(())
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/idl
|
solana_public_repos/nautilus-project/nautilus/solana/idl/src/idl_type_def.rs
|
use serde::{Deserialize, Serialize};
use super::{idl_nautilus_config::IdlTypeDefNautilusConfig, idl_type::IdlType};
/// An IDL type definition.
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct IdlTypeDef {
pub name: String,
#[serde(rename = "type")]
pub idl_type: IdlTypeDefType,
#[serde(skip_serializing_if = "Option::is_none")]
pub config: Option<IdlTypeDefNautilusConfig>,
}
impl IdlTypeDef {
pub fn new(
name: String,
idl_type: IdlTypeDefType,
config: Option<IdlTypeDefNautilusConfig>,
) -> Self {
Self {
name,
idl_type,
config,
}
}
}
impl From<&syn::ItemStruct> for IdlTypeDef {
fn from(value: &syn::ItemStruct) -> Self {
Self {
name: value.ident.to_string(),
idl_type: IdlTypeDefType::Struct {
fields: value.fields.iter().map(|f| f.into()).collect(),
},
config: None,
}
}
}
impl From<&syn::ItemEnum> for IdlTypeDef {
fn from(value: &syn::ItemEnum) -> Self {
Self {
name: value.ident.to_string(),
idl_type: IdlTypeDefType::Enum {
variants: value.variants.iter().map(|v| v.into()).collect(),
},
config: None,
}
}
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "lowercase", tag = "kind")]
pub enum IdlTypeDefType {
Struct { fields: Vec<IdlTypeStructField> },
Enum { variants: Vec<IdlTypeEnumVariant> },
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct IdlTypeStructField {
pub name: String,
#[serde(rename = "type")]
pub field_data_type: IdlType,
}
impl IdlTypeStructField {
pub fn new(name: String, field_data_type: IdlType) -> Self {
Self {
name,
field_data_type,
}
}
}
impl From<&syn::Field> for IdlTypeStructField {
fn from(value: &syn::Field) -> Self {
let name = match &value.ident {
Some(ident) => ident.to_string(),
None => panic!("Expected named field."),
};
let ty = &value.ty;
Self {
name,
field_data_type: ty.into(),
}
}
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct IdlTypeEnumVariant {
pub name: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub fields: Option<IdlTypeEnumFields>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(untagged)]
pub enum IdlTypeEnumFields {
Named(Vec<IdlTypeStructField>),
}
impl From<&syn::Variant> for IdlTypeEnumVariant {
fn from(value: &syn::Variant) -> Self {
let fields = match &value.fields {
syn::Fields::Named(named_fields) => {
let fields = named_fields
.named
.iter()
.map(|field| field.into())
.collect();
Some(IdlTypeEnumFields::Named(fields))
}
syn::Fields::Unit => None,
syn::Fields::Unnamed(_) => panic!("Expected named fields in enum variant."),
};
Self {
name: value.ident.to_string(),
fields,
}
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/idl
|
solana_public_repos/nautilus-project/nautilus/solana/idl/src/idl_metadata.rs
|
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct IdlMetadata {
pub origin: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub address: Option<String>,
}
impl IdlMetadata {
pub fn new(address: &str) -> Self {
Self {
origin: "nautilus".to_string(),
address: Some(address.to_string()),
}
}
pub fn new_with_no_id() -> Self {
Self {
origin: "nautilus".to_string(),
address: None,
}
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/idl
|
solana_public_repos/nautilus-project/nautilus/solana/idl/src/idl_type.rs
|
use serde::{Deserialize, Serialize};
/// An IDL type enum for converting from Rust types to IDL type.
///
/// Copied from Shank: https://github.com/metaplex-foundation/shank
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub enum IdlType {
Array(Box<IdlType>, usize),
Bool,
Bytes,
Defined(String),
I128,
I16,
I32,
I64,
I8,
Option(Box<IdlType>),
Tuple(Vec<IdlType>),
PublicKey,
String,
U128,
U16,
U32,
U64,
U8,
Vec(Box<IdlType>),
HashMap(Box<IdlType>, Box<IdlType>),
BTreeMap(Box<IdlType>, Box<IdlType>),
HashSet(Box<IdlType>),
BTreeSet(Box<IdlType>),
}
impl From<&syn::Type> for IdlType {
fn from(value: &syn::Type) -> Self {
match value {
syn::Type::Path(type_path) => {
let ident = &type_path.path.segments.last().unwrap().ident;
let arguments = &type_path.path.segments.last().unwrap().arguments;
match ident.to_string().as_str() {
"Vec" => {
if let syn::PathArguments::AngleBracketed(args) = arguments {
if args.args.len() == 1 {
let inner_type = args.args.first().unwrap();
if let syn::GenericArgument::Type(inner_type) = inner_type {
return IdlType::Vec(Box::new(Self::from(inner_type)));
}
}
}
panic!("Expected Vec<T>.");
}
"bool" => IdlType::Bool,
"u8" => IdlType::U8,
"u16" => IdlType::U16,
"u32" => IdlType::U32,
"u64" => IdlType::U64,
"u128" => IdlType::U128,
"i8" => IdlType::I8,
"i16" => IdlType::I16,
"i32" => IdlType::I32,
"i64" => IdlType::I64,
"i128" => IdlType::I128,
"String" => IdlType::String,
"Pubkey" => IdlType::PublicKey,
"Bytes" => IdlType::Bytes,
_ => IdlType::Defined(ident.to_string()),
}
}
syn::Type::Array(array_type) => {
let size = match &array_type.len {
syn::Expr::Lit(lit) => {
if let syn::Lit::Int(int_lit) = &lit.lit {
int_lit.base10_parse().unwrap()
} else {
panic!("Expected array length as an integer literal.");
}
}
_ => panic!("Expected array length as an integer literal."),
};
IdlType::Array(Box::new(Self::from(&*array_type.elem)), size)
}
syn::Type::Tuple(tuple_type) => {
let types = tuple_type
.elems
.iter()
.map(|elem| Self::from(elem))
.collect();
IdlType::Tuple(types)
}
syn::Type::Reference(type_reference) => {
if let syn::Type::Slice(slice_type) = &*type_reference.elem {
if let syn::Type::Path(ref_type_path) = &*slice_type.elem {
let ident = &ref_type_path.path.segments.last().unwrap().ident;
if ident == "u8" {
IdlType::Bytes
} else {
panic!("Expected &[u8].");
}
} else {
panic!("Expected &[u8].");
}
} else {
Self::from(&*type_reference.elem)
}
}
syn::Type::Paren(paren_type) => Self::from(&*paren_type.elem),
_ => panic!("Unsupported type."),
}
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/idl
|
solana_public_repos/nautilus-project/nautilus/solana/idl/src/idl_nautilus_config.rs
|
use serde::{Deserialize, Serialize};
use crate::idl_type::IdlType;
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub enum IdlSeed {
Lit { value: String },
Field { key: String },
Param { key: String, value: IdlType },
}
/// Additional Nautilus-specific IDL configurations.
///
/// These configurations are additional (and mostly optional) configs for the
/// client to use to perform certain actions such as SQL queries and
/// autoincrement.
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct IdlTypeDefNautilusConfig {
#[serde(skip_serializing_if = "Option::is_none")]
pub discrminator_str: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub table_name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub primary_key: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub autoincrement: Option<bool>,
pub authorities: Vec<String>,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub default_instructions: Vec<IdlTypeDefNautilusConfigDefaultInstruction>,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub seeds: Vec<IdlSeed>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub enum IdlTypeDefNautilusConfigDefaultInstruction {
Create(String),
Delete(String),
Update(String),
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/idl/src
|
solana_public_repos/nautilus-project/nautilus/solana/idl/src/converters/py.rs
|
//! Converts a JSON IDL to Python bindings.
use std::{
fs::{self, File},
io::Write,
path::Path,
};
use crate::{
idl_instruction::IdlInstruction,
idl_type::IdlType,
idl_type_def::{IdlTypeDef, IdlTypeDefType},
Idl,
};
pub trait PythonIdlWrite {
fn write_to_py(&self, dir_path: &str) -> std::io::Result<()>;
}
pub trait PythonConverter {
fn to_python_string(&self) -> String;
}
impl PythonIdlWrite for Idl {
fn write_to_py(&self, dir_path: &str) -> std::io::Result<()> {
if dir_path != "." {
fs::create_dir_all(dir_path)?;
}
let py_idl_path = Path::join(Path::new(dir_path), &format!("{}.py", &self.name));
let mut file = File::create(py_idl_path)?;
let python_string = self.to_python_string();
file.write_all(python_string.as_bytes())?;
Ok(())
}
}
impl PythonConverter for Idl {
fn to_python_string(&self) -> String {
// TODO: Lay down schema and add instructions/configs:
let mut all_types = self.accounts.clone();
all_types.extend(self.types.clone());
let all_types_strings: Vec<String> =
all_types.iter().map(|t| t.to_python_string()).collect();
let res = all_types_strings.join("\n");
res
}
}
impl PythonConverter for IdlInstruction {
fn to_python_string(&self) -> String {
todo!()
}
}
impl PythonConverter for IdlTypeDef {
fn to_python_string(&self) -> String {
match &self.idl_type {
IdlTypeDefType::Struct { fields } => {
let fields_str = fields
.iter()
.map(|field| {
format!(
" {}: {}",
field.name,
field.field_data_type.to_python_string()
)
})
.collect::<Vec<String>>()
.join("\n");
format!("class {}:\n{}\n", self.name, fields_str)
}
IdlTypeDefType::Enum { .. } => String::new(), // TODO: Python enums not supported yet
}
}
}
impl PythonConverter for IdlType {
fn to_python_string(&self) -> String {
match self {
IdlType::Array(inner_type, size) => {
format!("[{}; {}]", inner_type.to_python_string(), size)
}
IdlType::Bool => "bool".to_string(),
IdlType::Bytes => "bytes".to_string(),
IdlType::Defined(name) => name.clone(),
IdlType::I128 => "int".to_string(),
IdlType::I16 => "int".to_string(),
IdlType::I32 => "int".to_string(),
IdlType::I64 => "int".to_string(),
IdlType::I8 => "int".to_string(),
IdlType::Option(inner_type) => format!("Optional[{}]", inner_type.to_python_string()),
IdlType::Tuple(types) => format!(
"Tuple[{}]",
types
.iter()
.map(|t| t.to_python_string())
.collect::<Vec<String>>()
.join(", ")
),
IdlType::PublicKey => "PublicKey".to_string(),
IdlType::String => "str".to_string(),
IdlType::U128 => "int".to_string(),
IdlType::U16 => "int".to_string(),
IdlType::U32 => "int".to_string(),
IdlType::U64 => "int".to_string(),
IdlType::U8 => "int".to_string(),
IdlType::Vec(inner_type) => format!("List[{}]", inner_type.to_python_string()),
IdlType::HashMap(key_type, value_type) => format!(
"Dict[{}, {}]",
key_type.to_python_string(),
value_type.to_python_string()
),
IdlType::BTreeMap(key_type, value_type) => format!(
"Dict[{}, {}]",
key_type.to_python_string(),
value_type.to_python_string()
),
IdlType::HashSet(value_type) => format!("Set[{}]", value_type.to_python_string()),
IdlType::BTreeSet(value_type) => format!("Set[{}]", value_type.to_python_string()),
}
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/idl/src
|
solana_public_repos/nautilus-project/nautilus/solana/idl/src/converters/mod.rs
|
pub mod py;
pub mod ts;
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/idl/src
|
solana_public_repos/nautilus-project/nautilus/solana/idl/src/converters/ts.rs
|
//! Converts a JSON IDL to TypeScript bindings.
use std::{
fs::{self, File},
io::Write,
path::Path,
};
use crate::{
idl_instruction::IdlInstruction,
idl_type::IdlType,
idl_type_def::{IdlTypeDef, IdlTypeDefType, IdlTypeEnumFields},
Idl,
};
pub trait TypeScriptIdlWrite {
fn write_to_ts(&self, dir_path: &str) -> std::io::Result<()>;
}
pub trait TypeScriptConverter {
fn to_typescript_string(&self) -> String;
}
impl TypeScriptIdlWrite for Idl {
fn write_to_ts(&self, dir_path: &str) -> std::io::Result<()> {
if dir_path != "." {
fs::create_dir_all(dir_path)?;
}
let ts_idl_path = Path::join(Path::new(dir_path), &format!("{}.ts", &self.name));
let mut file = File::create(ts_idl_path)?;
let typescript_string = self.to_typescript_string();
file.write_all(typescript_string.as_bytes())?;
Ok(())
}
}
impl TypeScriptConverter for Idl {
fn to_typescript_string(&self) -> String {
// TODO: Lay down schema and add instructions/configs:
let mut all_types = self.accounts.clone();
all_types.extend(self.types.clone());
let all_types_strings: Vec<String> =
all_types.iter().map(|t| t.to_typescript_string()).collect();
let res = all_types_strings.join("\n");
res
}
}
impl TypeScriptConverter for IdlInstruction {
fn to_typescript_string(&self) -> String {
todo!()
}
}
impl TypeScriptConverter for IdlTypeDef {
fn to_typescript_string(&self) -> String {
match &self.idl_type {
IdlTypeDefType::Struct { fields } => {
let fields_str = fields
.iter()
.map(|field| {
format!(
" {}: {};",
field.name,
field.field_data_type.to_typescript_string()
)
})
.collect::<Vec<String>>()
.join("\n");
format!("type {} = {{\n{}\n}};", self.name, fields_str)
}
IdlTypeDefType::Enum { variants } => {
let variants_str = variants
.iter()
.map(|variant| {
let fields_str = match &variant.fields {
Some(IdlTypeEnumFields::Named(fields)) => fields
.iter()
.map(|field| {
format!(
" {}: {};",
field.name,
field.field_data_type.to_typescript_string()
)
})
.collect::<Vec<String>>()
.join(", "),
None => String::new(),
};
format!("{} = {{ {} }}", variant.name, fields_str)
})
.collect::<Vec<String>>()
.join(" | ");
format!("type {} = {};", self.name, variants_str)
}
}
}
}
impl TypeScriptConverter for IdlType {
fn to_typescript_string(&self) -> String {
match self {
IdlType::Array(idl_type, size) => {
format!("[{}; {}]", idl_type.to_typescript_string(), size)
}
IdlType::Bool => "boolean".to_string(),
IdlType::Bytes => "Uint8Array".to_string(),
IdlType::Defined(name) => name.clone(),
IdlType::I128 | IdlType::I16 | IdlType::I32 | IdlType::I64 | IdlType::I8 => {
"number".to_string()
}
IdlType::Option(idl_type) => format!("{} | null", idl_type.to_typescript_string()),
IdlType::Tuple(idl_types) => format!(
"[{}]",
idl_types
.iter()
.map(|idl_type| idl_type.to_typescript_string())
.collect::<Vec<String>>()
.join(", ")
),
IdlType::PublicKey => "PublicKey".to_string(),
IdlType::String => "string".to_string(),
IdlType::U128 | IdlType::U16 | IdlType::U32 | IdlType::U64 | IdlType::U8 => {
"number".to_string()
}
IdlType::Vec(idl_type) => format!("{}[]", idl_type.to_typescript_string()),
IdlType::HashMap(key_type, value_type) => format!(
"Map<{}, {}>",
key_type.to_typescript_string(),
value_type.to_typescript_string()
),
IdlType::BTreeMap(key_type, value_type) => format!(
"Map<{}, {}>",
key_type.to_typescript_string(),
value_type.to_typescript_string()
),
IdlType::HashSet(idl_type) => format!("Set<{}>", idl_type.to_typescript_string()),
IdlType::BTreeSet(idl_type) => format!("Set<{}>", idl_type.to_typescript_string()),
}
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana
|
solana_public_repos/nautilus-project/nautilus/solana/derive/Cargo.toml
|
[package]
name = "nautilus-derive"
version = "0.0.1"
authors = ["Joe Caulfield <jcaulfield135@gmail.com>"]
repository = "https://github.com/nautilus-project/nautilus"
license = "Apache-2.0"
description = "Nautilus derive macro for adding CRUD operations to data types"
rust-version = "1.59"
edition = "2021"
[lib]
proc-macro = true
[dependencies]
proc-macro2 = "1.0"
quote = "1.0"
nautilus-syn = { path = "../syn", version = "0.0.1" }
syn = { version = "1.0", features = ["extra-traits"] }
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/derive
|
solana_public_repos/nautilus-project/nautilus/solana/derive/src/lib.rs
|
//! Nautilus' macros used to power its abstraction.
use nautilus_syn::{entry::NautilusEntrypoint, object::NautilusObject};
use proc_macro::TokenStream;
use quote::ToTokens;
use syn::{parse_macro_input, ItemStruct};
extern crate proc_macro;
/// The procedural macro to build the entirety of a Nautilus program.
///
/// This macro alone can build a valid Nautilus program from the annotated
/// module.
///
/// Parses the annotated module into a `syn::ItemMod` and converts that to a
/// `nautilus_syn::NautilusEntrypoint` to build the program's entrypoint,
/// processor, and IDL.
#[proc_macro_attribute]
pub fn nautilus(_: TokenStream, input: TokenStream) -> TokenStream {
parse_macro_input!(input as NautilusEntrypoint)
.to_token_stream()
.into()
}
/// The derive macro to implement the required traits to allow for the annotated
/// struct to serve as the data type for a Nautilus record - allowing it to be
/// used as `T` inside of `Record<'_, T>`.
#[proc_macro_derive(Table, attributes(default_instructions, primary_key, authority))]
pub fn nautilus_table(input: TokenStream) -> TokenStream {
let item_struct = parse_macro_input!(input as ItemStruct);
NautilusObject::from_item_struct(
item_struct,
nautilus_syn::object::NautilusObjectType::Record,
)
.to_token_stream()
.into()
}
/// The derive macro to implement the required traits to allow for the annotated
/// struct to serve as the data type for a Nautilus account - allowing it to be
/// used as `T` inside of `Account<'_, T>`.
#[proc_macro_derive(State, attributes(seeds, authority))]
pub fn nautilus_account(input: TokenStream) -> TokenStream {
let item_struct = parse_macro_input!(input as ItemStruct);
NautilusObject::from_item_struct(
item_struct,
nautilus_syn::object::NautilusObjectType::Account,
)
.to_token_stream()
.into()
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana
|
solana_public_repos/nautilus-project/nautilus/solana/syn/Cargo.toml
|
[package]
name = "nautilus-syn"
version = "0.0.1"
authors = ["Joe Caulfield <jcaulfield135@gmail.com>"]
repository = "https://github.com/nautilus-project/nautilus"
license = "Apache-2.0"
description = "Lib for parsing syntax for Nautilus derive macros"
rust-version = "1.59"
edition = "2021"
[dependencies]
borsh = "0.9.3"
borsh-derive = "0.9.3"
cargo_toml = "0.15.2"
case = "1.0.0"
convert_case = "0.6.0"
nautilus-idl = { version = "0.0.1", path = "../idl" }
proc-macro2 = "1.0"
quote = "1.0"
shank_idl = "0.0.12"
shank_macro_impl = "0.0.12"
solana-program = "1.15.0"
syn = { version = "1.0", features = ["extra-traits", "full"] }
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/syn
|
solana_public_repos/nautilus-project/nautilus/solana/syn/src/lib.rs
|
//
//
// ----------------------------------------------------------------
// Nautilus Token Generation
// ----------------------------------------------------------------
//
//
pub mod entry;
pub mod object;
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/syn/src
|
solana_public_repos/nautilus-project/nautilus/solana/syn/src/entry/entry_variant.rs
|
//! A `syn`-powered struct that dissolves to the required components to create
//! the variants of the program's instruction enum and it's associated processor
//! match arm initialization logic.
use nautilus_idl::idl_instruction::IdlInstruction;
use proc_macro2::{Span, TokenStream};
use quote::quote;
use syn::{Ident, Type};
use crate::{
entry::required_account::{to_ident_pointer, RequiredAccountSubtype},
object::{parser::NautilusObjectConfig, source::source_nautilus_names, NautilusObject},
};
use super::{
entry_enum::NautilusEntrypointEnum,
required_account::{
metadata_ident, mint_authority_ident, self_account_ident, RequiredAccount,
RequiredAccountType,
},
};
/// The struct used to house all of the required components for building out the
/// generated program, derived from the user's declared function.
///
/// The key functionality actually occurs in the trait implementations for this
/// struct - including the self implementations such as `new(..)`.
#[derive(Debug)]
pub struct NautilusEntrypointEnumVariant {
/// Instruction discriminant: derived from the order the functions are
/// declared.
pub discriminant: u8,
/// The identifier of this instruction's variant in the program instruction
/// enum.
pub variant_ident: Ident,
/// The arguments required for this instruction's variant in the program
/// instruction enum.
pub variant_args: Vec<(Ident, Type)>,
/// All required accounts for this instruction, in order to instantiate the
/// declared Nautilus objects.
pub required_accounts: Vec<RequiredAccount>,
/// The identifier of the user's declared function, in order to call it.
pub call_ident: Ident,
/// The "call context" of each declared parameter in the user's defined
/// function signature.
///
/// "Call context" can be explored further by examining the documentation
/// for `CallContext`, but essentially it's information about whether or
/// not the parameter is a Nautilus object or an instruction argument.
pub call_context: Vec<CallContext>,
}
/// "Call context" for each declared parameter in the user's defined function
/// signature.
#[derive(Debug)]
pub enum CallContext {
/// The parameter is in fact a Nautilus object.
///
/// Houses the configurations for this specific Nautilus object declared,
/// which will tell Nautilus how to instanitate it.
Nautilus(NautilusObject),
/// The parameter is an instruction argument and not a Nautilus object.
Arg(Ident),
}
impl NautilusEntrypointEnumVariant {
/// Creates a new `NautilusEntrypointEnumVariant`.
///
/// This action will map each `CallContext::Nautilus(..)` for the parameters
/// declared in the user's function to determine all required accounts
/// for the instruction.
pub fn new(
discriminant: u8,
variant_ident: Ident,
variant_args: Vec<(Ident, Type)>,
call_ident: Ident,
call_context: Vec<CallContext>,
) -> Self {
let required_accounts = RequiredAccount::condense(
call_context
.iter()
.filter_map(|ctx| match ctx {
CallContext::Nautilus(n) => {
let req = n.get_required_accounts();
let mut accounts = vec![];
accounts.extend(req.0);
match req.1 {
Some(r) => accounts.extend(r),
None => (),
};
Some(accounts)
}
CallContext::Arg(_) => None,
})
.collect(),
);
Self {
discriminant,
variant_ident,
variant_args,
required_accounts,
call_ident,
call_context,
}
}
/// Builds the processor match arm for this particular declared function.
///
/// This function is where the bulk of the magic occurs.
///
/// Its basically going to generate the code to extract all required
/// accounts from the provided list of accounts in the program's
/// entrypoint, ie. `accounts: &[AccountInfo]`, then use those
/// accounts to create `Box` pointers and instantiate each declared Nautilus
/// object, then call the user's function.
fn build_match_arm_logic(&self) -> TokenStream {
let instruction_name = self.variant_ident.to_string();
let mut index_init = quote!();
// Maps all required accounts for this instruction into the proper tokens to
// extract from the iterator and create a `Box` pointer for that
// account. The `Box` pointer is created in this step, so all cloning
// later in the match arm is cloning the `Box<AccountInfo>` instead of
// the `AccountInfo` itself.
let all_accounts = self.required_accounts.iter().map(|r| {
let ident = match &r.account_type {
RequiredAccountType::Account(subtype) => match &subtype {
RequiredAccountSubtype::SelfAccount => self_account_ident(&r.ident),
RequiredAccountSubtype::Metadata => metadata_ident(&r.ident),
RequiredAccountSubtype::MintAuthority => mint_authority_ident(&r.ident),
},
RequiredAccountType::IndexAccount => {
index_init = quote! { let nautilus_index = NautilusIndex::load(program_id, index_pointer)?; }; // TODO
r.ident.clone()
}
_ => r.ident.clone(),
};
let ident_pointer = to_ident_pointer(&ident);
quote! {
let #ident = next_account_info(accounts_iter)?.to_owned();
let #ident_pointer = Box::new(#ident);
}
});
let mut object_inits = vec![];
let mut call_args = vec![];
// This block is going to try to instantiate every Nautilus object needed to
// call the user's function. Non-Nautilus objects will simply
// pass-through to the called function. The last line of the processor
// match arm will call the user's function with all of the instantiated
// "call_args".
{
self.call_context.iter().for_each(|ctx| {
match ctx {
CallContext::Nautilus(obj) => match &obj.entry_config {
Some(config) => {
let arg_ident = &config.arg_ident;
let (obj_type, arg_ty, is_custom) = match source_nautilus_names().contains(&obj.ident.to_string()) {
true => (obj.ident.clone(), quote!(), false),
false => {
let ty = &obj.ident;
(
match &obj.object_config {
Some(t) => match t {
NautilusObjectConfig::RecordConfig { .. } => Ident::new("Record", Span::call_site()),
NautilusObjectConfig::AccountConfig { .. } => Ident::new("Account", Span::call_site()),
},
None => panic!("Object {} did not match any source Nautilus objects and was not annotated with a Nautilus #[derive(..)] macro", &obj.ident.to_string()),
},
quote! { #ty },
true,
)
},
};
let required_accounts_for_obj = obj.get_required_accounts();
// Identifiers for all accounts required "for read" - in other words, any `Box<AccountInfo<'_>>` fields required
// for that Nautilus object.
let read_call_idents = required_accounts_for_obj.0.iter().map(|r| {
let t: TokenStream = r.into();
t
});
match required_accounts_for_obj.1 {
// If the object is wrapped in `Create<'_, T>`, this option will have a value.
// This means we need to get the identifiers for all accounts required "for create" as well.
Some(accounts_for_create) => {
let create_call_idents = accounts_for_create.iter().map(|r| {
let t: TokenStream = r.into();
t
});
let create_obj_init = match is_custom {
true => quote! {
let mut #arg_ident = Create::new(
#(#create_call_idents,)*
#obj_type::< #arg_ty >::new(#(#read_call_idents,)*)
)?;
},
false => quote! {
let mut #arg_ident = Create::new(
#(#create_call_idents,)*
#obj_type::new(#(#read_call_idents,)*)
)?;
},
};
object_inits.push(create_obj_init);
},
None => {
if config.is_signer {
object_inits.push(
quote! { let #arg_ident = Signer::new(#obj_type::load(#(#read_call_idents,)*)?)?; },
);
} else if config.is_mut {
object_inits.push(
quote! { let #arg_ident = Mut::new(#obj_type::load(#(#read_call_idents,)*)?)?; },
);
} else {
object_inits.push(match is_custom {
true => quote! { let #arg_ident = #obj_type::< #arg_ty >::load(#(#read_call_idents,)*)?; },
false => quote! { let #arg_ident = #obj_type::load(#(#read_call_idents,)*)?; },
}
);
}
},
};
call_args.push(quote! { #arg_ident })
}
None => {
panic!("Error processing entrypoint: `entry_config` not set.")
}
},
CallContext::Arg(arg) => call_args.push(quote! { #arg }),
};
});
}
let call_ident = &self.call_ident;
quote::quote! {
{
splogger::info!("Instruction: {}", #instruction_name);
let accounts_iter = &mut accounts.iter();
#(#all_accounts)*
#index_init
#(#object_inits)*
#call_ident(#(#call_args,)*)
}
}
}
}
impl From<&NautilusEntrypointEnumVariant> for (TokenStream, TokenStream, IdlInstruction) {
/// Dissolves the `NautilusEntrypointEnumVariant` into the proper components
/// for building out the generated program.
///
/// When the `NautilusEntrypointEnum` is dissolved, it dissolves each
/// `NautilusEntrypointEnumVariant` of its `variants` vector and
/// aggregates each generated component.
///
/// Consider the return type of the function itself - defined at the trait
/// level: (`TokenStream`, `TokenStream`, `IdlInstruction`):
/// * `TokenStream` (first): The identifier and associated arguments for the
/// program instruction enum variant for this particular declared
/// function.
/// * `TokenStream` (second): The processor match arm for this particular
/// declared function.
/// * `IdlInstruction`: The IDL instruction derived from this particular
/// declared function.
fn from(value: &NautilusEntrypointEnumVariant) -> Self {
let variant_ident = &value.variant_ident;
let enum_ident = NautilusEntrypointEnum::enum_ident();
let (arg_names, arg_types): (Vec<Ident>, Vec<Type>) =
value.variant_args.clone().into_iter().unzip();
let match_arm_logic = value.build_match_arm_logic();
(
quote! { #variant_ident(#(#arg_types,)*), },
quote! { #enum_ident::#variant_ident(#(#arg_names,)*) => #match_arm_logic, },
value.into(),
)
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/syn/src
|
solana_public_repos/nautilus-project/nautilus/solana/syn/src/entry/idl.rs
|
//! Converters to allow for dissolving of Nautilus token-generation
//! configuration structs,
// such as `NautilusEntrypointEnum` and `NautilusEntrypointEnumVariant`,
// into IDL components.
use nautilus_idl::{
idl_instruction::{
IdlInstruction, IdlInstructionAccount, IdlInstructionArg, IdlInstructionDiscriminant,
},
idl_nautilus_config::{
IdlSeed, IdlTypeDefNautilusConfig, IdlTypeDefNautilusConfigDefaultInstruction,
},
idl_type_def::IdlTypeDef,
};
use crate::object::{
default_instructions::DefaultInstruction, parser::NautilusObjectConfig, seeds::Seed,
NautilusObject, NautilusObjectRawType,
};
use super::{entry_variant::NautilusEntrypointEnumVariant, required_account::RequiredAccount};
/// Converts the `NautilusEntrypointEnumVariant` into an IDL instruction.
///
/// This will use the configurations from the variant to build the necessary
/// instruction in the IDL - including all required accounts.
impl From<&NautilusEntrypointEnumVariant> for IdlInstruction {
fn from(value: &NautilusEntrypointEnumVariant) -> Self {
let mut name = value.variant_ident.to_string();
name.replace_range(..1, &name[..1].to_lowercase());
IdlInstruction {
name,
accounts: value.required_accounts.iter().map(|a| a.into()).collect(),
args: value
.variant_args
.iter()
.map(|(ident, ty)| IdlInstructionArg::new(ident.to_string(), ty.into()))
.collect(),
discriminant: IdlInstructionDiscriminant::new(value.discriminant),
}
}
}
/// Straightforward conversion from a `RequiredAccount` into its IDL
/// representation, including configs for `is_mut` and `is_signer`.
impl From<&RequiredAccount> for IdlInstructionAccount {
fn from(value: &RequiredAccount) -> Self {
Self {
name: value.name.clone(),
is_mut: value.is_mut,
is_signer: value.is_signer,
account_type: value.account_type.to_string(),
desc: value.desc.clone(),
}
}
}
/// Straightforward conversion from a `NautilusObject` into its IDL type
/// definition.
impl From<&NautilusObject> for IdlTypeDef {
fn from(value: &NautilusObject) -> Self {
let mut default_type_def: IdlTypeDef = match &value.raw_type {
NautilusObjectRawType::Struct(raw) => raw.into(),
NautilusObjectRawType::Enum(raw) => raw.into(),
};
match &value.object_config {
Some(config) => default_type_def.config = Some(config.into()),
None => (),
}
default_type_def
}
}
/// Converts the object configurations for a `NautilusObject` into IDL
/// configurations.
///
/// These configurations are additional (and mostly optional) configs for the
/// client to use to perform certain actions such as SQL queries and
/// autoincrement.
impl From<&NautilusObjectConfig> for IdlTypeDefNautilusConfig {
fn from(value: &NautilusObjectConfig) -> Self {
match value {
NautilusObjectConfig::RecordConfig {
table_name,
data_fields: _, // Unused in additional config.
autoincrement_enabled,
primary_key_ident,
primary_key_ty: _, // Unused, points to field name instead.
authorities,
default_instructions,
} => Self {
discrminator_str: None,
table_name: Some(table_name.clone()),
primary_key: Some(primary_key_ident.to_string()),
autoincrement: Some(*autoincrement_enabled),
authorities: authorities.iter().map(|a| a.to_string()).collect(),
default_instructions: default_instructions
.iter()
.map(|s| s.clone().into())
.collect(),
seeds: vec![],
},
NautilusObjectConfig::AccountConfig {
discrminator_str,
data_fields: _, // Unused in additional config.
authorities,
seeds,
} => Self {
discrminator_str: Some(discrminator_str.clone()),
table_name: None,
primary_key: None,
autoincrement: None,
authorities: authorities.iter().map(|a| a.to_string()).collect(),
default_instructions: vec![],
seeds: seeds.iter().map(|s| s.into()).collect(),
},
}
}
}
/// Converts a `Seed` from the `syn` crate into an `IdlSeed` from the `idl`
/// crate.
impl From<&Seed> for IdlSeed {
fn from(value: &Seed) -> Self {
match value {
Seed::Lit { value } => IdlSeed::Lit {
value: value.clone(),
},
Seed::Field { ident } => IdlSeed::Field {
key: ident.to_string(),
},
Seed::Param { ident, ty } => IdlSeed::Param {
key: ident.to_string(),
value: ty.into(),
},
}
}
}
/// Converts a `DefaultInstruction` from the `syn` crate into an
/// `IdlTypeDefNautilusConfigDefaultInstruction` from the `idl` crate.
impl From<DefaultInstruction> for IdlTypeDefNautilusConfigDefaultInstruction {
fn from(value: DefaultInstruction) -> Self {
match value {
DefaultInstruction::Create(val) => {
IdlTypeDefNautilusConfigDefaultInstruction::Create(val)
}
DefaultInstruction::Delete(val) => {
IdlTypeDefNautilusConfigDefaultInstruction::Delete(val)
}
DefaultInstruction::Update(val) => {
IdlTypeDefNautilusConfigDefaultInstruction::Update(val)
}
}
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/syn/src
|
solana_public_repos/nautilus-project/nautilus/solana/syn/src/entry/mod.rs
|
//! Builds the entrypoint, processor, and IDL for a Nautilus program.
pub mod entry_enum;
pub mod entry_variant;
pub mod idl;
pub mod parser;
pub mod required_account;
use nautilus_idl::{
converters::{py::PythonIdlWrite, ts::TypeScriptIdlWrite},
idl_metadata::IdlMetadata,
Idl,
};
use proc_macro2::TokenStream;
use quote::{quote, ToTokens};
use syn::{parse::Parse, Item, ItemFn, ItemMod};
use self::{
entry_enum::NautilusEntrypointEnum,
parser::{is_use_super_star, parse_crate_context, parse_manifest},
};
/// The struct containing the parsed contents required to convert the user's
/// annotated module into the proper program configurations.
/// * `leftover_content`: Any declarations in the module that aren't named
/// functions.
/// * `instruction_enum`: The built-out program instruction enum derived from
/// the functions and their arguments.
/// * `declared_functions`: The user's declared functions as-is.
/// * `processor`: The program's processor, built into a function
/// `process_instruction`.
#[derive(Debug)]
pub struct NautilusEntrypoint {
pub leftover_content: Vec<Item>,
pub instruction_enum: TokenStream,
pub declared_functions: Vec<ItemFn>,
pub processor: TokenStream,
}
impl From<ItemMod> for NautilusEntrypoint {
/// Converts the user's annotated module into the `NautilusEntrypoint`
/// struct.
///
/// All of the work to build out the entrypoint, processor, and IDL for a
/// Nautilus program is done here. During this conversion, the module
/// (`ItemMod`) is broken down into components, and the functions declared
/// by the user are extracted and used to build out various child
/// structs such as `NautilusEntrypointEnum` and
/// `NautilusEntrypointEnumVariant`.
///
/// Using information extracted from the user's manifest (`Cargo.toml`) and
/// the entirety of their crate, this function builds the
/// `NautilusEntrypointEnum`, which basically dissolves to the required
/// components.
///
/// For more specific information see the documentation for
/// `NautilusEntrypointEnum` and `NautilusEntrypointEnumVariant`.
fn from(value: ItemMod) -> Self {
let mut declared_functions = vec![];
let leftover_content: Vec<Item> = value
.content
.clone()
.unwrap()
.1
.into_iter()
.filter_map(|item| match is_use_super_star(&item) {
true => None,
false => match item {
Item::Fn(input_fn) => {
declared_functions.push(input_fn);
None
}
_ => Some(item),
},
})
.collect();
let (crate_version, crate_name) = parse_manifest();
let (nautilus_objects, idl_accounts, idl_types) = parse_crate_context();
let nautilus_enum =
&NautilusEntrypointEnum::new(nautilus_objects, declared_functions.clone());
let (instruction_enum, processor, idl_instructions) = nautilus_enum.into();
let idl = Idl::new(
crate_version,
crate_name,
idl_instructions,
idl_accounts,
idl_types,
IdlMetadata::new_with_no_id(),
);
match idl.write_to_json("./target/idl") {
Ok(()) => (),
Err(e) => println!("[ERROR]: Error writing IDL to JSON file: {:#?}", e),
};
match idl.write_to_py("./target/idl") {
Ok(()) => (),
Err(e) => println!(
"[ERROR]: Error writing Python bindings to .py file: {:#?}",
e
),
};
match idl.write_to_ts("./target/idl") {
Ok(()) => (),
Err(e) => println!(
"[ERROR]: Error writing TypeScript bindings to .ts file: {:#?}",
e
),
};
Self {
leftover_content,
instruction_enum,
declared_functions,
processor,
}
}
}
impl Parse for NautilusEntrypoint {
/// Parses the user's defined module into a `syn::ItemMod`, which is an
/// already pre-fabricated function, and calls Into<NautilusEntrypoint>
/// to fire the `from(value: ItemMod)` in the trait implementation `impl
/// From<ItemMod> for NautilusEntrypoint`, which does all the magic.
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
Ok(ItemMod::parse(input)?.into())
}
}
impl ToTokens for NautilusEntrypoint {
/// Extends the existing compiler tokens by the tokens generated by the
/// `NautilusEntrypoint`.
fn to_tokens(&self, tokens: &mut TokenStream) {
tokens.extend::<TokenStream>(self.into());
}
}
impl From<&NautilusEntrypoint> for TokenStream {
/// Converts each component of the `NautilusEntrypoint` into the proper
/// tokens for the compiler.
fn from(ast: &NautilusEntrypoint) -> Self {
let leftover_content = &ast.leftover_content;
let instruction_enum = &ast.instruction_enum;
let declared_functions = &ast.declared_functions;
let processor = &ast.processor;
quote! {
#instruction_enum
#processor
#(#declared_functions)*
#(#leftover_content)*
}
.into()
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/syn/src
|
solana_public_repos/nautilus-project/nautilus/solana/syn/src/entry/entry_enum.rs
|
//! A `syn`-powered enum that dissolves to the required components to create the
//! program's entrypoint, processor, and IDL.
use nautilus_idl::idl_instruction::IdlInstruction;
use proc_macro2::{Span, TokenStream};
use quote::quote;
use syn::{Ident, ItemFn};
use crate::{
entry::entry_variant::NautilusEntrypointEnumVariant, entry::parser::parse_function,
object::NautilusObject,
};
/// The struct used to house all of the "variants" of type
/// `NautilusEntrypointEnumVariant` which dissolve to the required components
/// for building out the generated program.
///
/// The key functionality actually occurs in the trait implementations for this
/// struct - including the self implementations such as `new(..)`.
#[derive(Debug)]
pub struct NautilusEntrypointEnum {
pub variants: Vec<NautilusEntrypointEnumVariant>,
}
impl NautilusEntrypointEnum {
/// Creates a new `NautilusEntrypointEnum`.
///
/// This action will simply convert the user's declared functions into
/// `NautilusEntrypointEnumVariant` instances, which dissolve to
/// the required components for building out the generated program.
pub fn new(nautilus_objects: Vec<NautilusObject>, declared_functions: Vec<ItemFn>) -> Self {
let variants = declared_functions
.into_iter()
.enumerate()
.map(|(i, f)| {
let (variant_ident, variant_args, call_ident, call_context) =
parse_function(&nautilus_objects, f);
NautilusEntrypointEnumVariant::new(
i.try_into().unwrap(),
variant_ident,
variant_args,
call_ident,
call_context,
)
})
.collect();
Self { variants }
}
pub fn enum_ident() -> Ident {
Ident::new("NautilusEntrypoint", Span::call_site())
}
}
impl From<&NautilusEntrypointEnum> for (TokenStream, TokenStream, Vec<IdlInstruction>) {
/// Maps each `NautilusEntrypointEnumVariant` into the proper components and
/// dissolves itself into the required components for building out the
/// generated program.
///
/// Consider the `fold` operation on the `variants` field, which returns
/// (`variants`, `match_arms`, `idl_instructions`):
/// * `variants`: The variants of the instruction enum for the program.
/// * `match_arms`: The match arms of the processor which will process
/// whichever instruction enum variant (and its arguments) is provided to
/// the program.
/// * `idl_instructions`: The IDL instructions derived from the declared
/// functions - to be used in generating the IDL.
///
/// Consider the return type of the function itself - defined at the trait
/// level: (`TokenStream`, `TokenStream`, `Vec<IdlInstruction>`):
/// * `TokenStream` (first): The instruction enum.
/// * `TokenStream` (second): The processor.
/// * `Vec<IdlInstruction>`: The list of IDL instructions.
fn from(value: &NautilusEntrypointEnum) -> Self {
let enum_name = NautilusEntrypointEnum::enum_ident();
let (variants, match_arms, idl_instructions) = value.variants.iter().fold(
(Vec::new(), Vec::new(), Vec::new()),
|(mut variants, mut match_arms, mut idl_instructions), v| {
let (a, b, c): (TokenStream, TokenStream, IdlInstruction) = v.into();
variants.push(a);
match_arms.push(b);
idl_instructions.push(c);
(variants, match_arms, idl_instructions)
},
);
(
quote! {
#[derive(borsh::BorshDeserialize, borsh::BorshSerialize)]
pub enum #enum_name {
#(#variants)*
}
},
quote! {
pub fn process_instruction<'a>(
program_id: &'static Pubkey,
accounts: &[AccountInfo],
input: &[u8],
) -> ProgramResult {
let instruction = #enum_name::try_from_slice(input)?;
match instruction {
#(#match_arms)*
}
}
entrypoint!(process_instruction);
},
idl_instructions,
)
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/syn/src
|
solana_public_repos/nautilus-project/nautilus/solana/syn/src/entry/required_account.rs
|
//! The module for determining accounts required for a Nautilus object.
use case::CaseExt;
use convert_case::{Case, Casing};
use proc_macro2::Span;
use quote::quote;
use syn::Ident;
use crate::object::NautilusObjectType;
/// The details of a required account for a Nautilus object.
///
/// These details pretty much map to their IDL representation directly.
#[derive(Clone, Debug, PartialEq)]
pub struct RequiredAccount {
pub ident: Ident,
pub name: String,
pub is_mut: bool,
pub is_signer: bool,
pub desc: String,
pub account_type: RequiredAccountType,
}
/// The type of account required.
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum RequiredAccountType {
ProgramId,
IndexAccount,
Account(RequiredAccountSubtype), // Any general account not matching the other variants
FeePayer,
Sysvar,
SystemProgram,
Program,
TokenProgram,
AssociatedTokenProgram,
TokenMetadataProgram,
}
/// The sub-type of a general account.
///
/// `SelfAccount` is the underlying account, while others like `Metadata` and
/// `MintAuthority` are required for some objects like `Token` and `Mint`.
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum RequiredAccountSubtype {
SelfAccount, // The underlying account for any Nautilus object
Metadata,
MintAuthority,
}
/// The type of Nautilus object
#[derive(Clone, Debug, PartialEq)]
pub enum ObjectType {
NautilusIndex,
Wallet,
Nft(bool),
Token(bool),
Mint(bool),
Metadata,
AssociatedTokenAccount,
Record(bool, Vec<Construct>), // Table record
Account(bool, Vec<Construct>), // State account
}
/// A construct shell enum used to map variants with provided args into required
/// accounts.
///
/// This enum almost mirrors the `RequiredAccountType` enum, but in this context
/// its used to pass provided configurations - such as `is_mut` and `is_signer`
/// - to the resolver.
///
/// If you examine `From<Construct> for RequiredAccount`, you'll see this enum
/// is used to resolve the required accounts for any of its variants with the
/// configs.
#[derive(Clone, Debug, PartialEq)]
pub enum Construct {
ProgramId,
Index(bool),
SelfAccount(String, String, bool, bool),
Metadata(String, String, bool),
MintAuthority(String, String, bool, bool),
FeePayer,
Sysvar(SysvarType),
SystemProgram,
TokenProgram,
AssociatedTokenProgram,
TokenMetadataProgram,
}
#[derive(Clone, Debug, PartialEq)]
pub enum SysvarType {
Clock,
EpochSchedule,
Rent,
}
impl From<Construct> for RequiredAccount {
/// Converts a Construct into the proper RequiredAccount using the provided
/// variant arguments.
fn from(value: Construct) -> Self {
match value {
Construct::ProgramId => {
let name = "program_id".to_string();
RequiredAccount {
ident: Ident::new(&name, Span::call_site()),
name: name.clone(),
is_mut: false,
is_signer: false,
desc: name,
account_type: RequiredAccountType::ProgramId,
}
}
Construct::Index(is_mut) => {
let name = "index".to_string();
RequiredAccount {
ident: name_to_ident_snake(&name),
name,
is_mut,
is_signer: false,
desc: "The Nautilus Index for this program".to_string(),
account_type: RequiredAccountType::IndexAccount,
}
}
Construct::SelfAccount(name, desc, is_mut, is_signer) => {
let ident = name_to_ident_snake(&name);
RequiredAccount {
ident,
name,
is_mut,
is_signer,
desc,
account_type: RequiredAccountType::Account(RequiredAccountSubtype::SelfAccount),
}
}
Construct::Metadata(name, desc, is_mut) => {
let ident = name_to_ident_snake(&name);
RequiredAccount {
ident,
name,
is_mut,
is_signer: false,
desc,
account_type: RequiredAccountType::Account(RequiredAccountSubtype::Metadata),
}
}
Construct::MintAuthority(name, desc, is_mut, is_signer) => {
let ident = name_to_ident_snake(&name);
RequiredAccount {
ident,
name,
is_mut,
is_signer,
desc,
account_type: RequiredAccountType::Account(
RequiredAccountSubtype::MintAuthority,
),
}
}
Construct::FeePayer => {
let account_type = RequiredAccountType::FeePayer;
let name = account_type.to_string();
RequiredAccount {
ident: name_to_ident_snake(&name),
name,
is_mut: true,
is_signer: true,
desc: "The transaction fee payer".to_string(),
account_type,
}
}
Construct::Sysvar(sysvar_type) => {
let name = match sysvar_type {
SysvarType::Clock => "clock".to_string(),
SysvarType::EpochSchedule => "epochSchedule".to_string(),
SysvarType::Rent => "rent".to_string(),
};
RequiredAccount {
ident: name_to_ident_snake(&name),
name: name.clone(),
is_mut: false,
is_signer: false,
desc: format!("The Sysvar: {}", &(name.to_case(Case::Title))).to_string(),
account_type: RequiredAccountType::Sysvar,
}
}
Construct::SystemProgram => {
let account_type = RequiredAccountType::SystemProgram;
let name = account_type.to_string();
RequiredAccount {
ident: name_to_ident_snake(&name),
name,
is_mut: false,
is_signer: false,
desc: "The System Program".to_string(),
account_type,
}
}
Construct::TokenProgram => {
let account_type = RequiredAccountType::TokenProgram;
let name = account_type.to_string();
RequiredAccount {
ident: name_to_ident_snake(&name),
name,
is_mut: false,
is_signer: false,
desc: "The Token Program".to_string(),
account_type,
}
}
Construct::AssociatedTokenProgram => {
let account_type = RequiredAccountType::AssociatedTokenProgram;
let name = account_type.to_string();
RequiredAccount {
ident: name_to_ident_snake(&name),
name,
is_mut: false,
is_signer: false,
desc: "The Associated Token Program".to_string(),
account_type,
}
}
Construct::TokenMetadataProgram => {
let account_type = RequiredAccountType::TokenMetadataProgram;
let name = account_type.to_string();
RequiredAccount {
ident: name_to_ident_snake(&name),
name,
is_mut: false,
is_signer: false,
desc: "The Token Metadata Program".to_string(),
account_type,
}
}
}
}
}
// TODO: Add support for custom descriptions
//
impl RequiredAccount {
pub fn derive_object_type(
ty_name: &str,
is_mut: bool,
nautilus_ty: Option<NautilusObjectType>,
) -> ObjectType {
if ty_name.eq("NautilusIndex") {
ObjectType::NautilusIndex
} else if ty_name.eq("Wallet") {
ObjectType::Wallet
} else if ty_name.eq("Nft") {
ObjectType::Nft(false) // TODO: PDA Tokens not supported yet
} else if ty_name.eq("Token") {
ObjectType::Token(false) // TODO: PDA Tokens not supported yet
} else if ty_name.eq("Mint") {
ObjectType::Mint(false) // TODO: PDA Tokens not supported yet
} else if ty_name.eq("Metadata") {
ObjectType::Metadata
} else if ty_name.eq("AssociatedTokenAccount") {
ObjectType::AssociatedTokenAccount
} else {
match nautilus_ty {
Some(t) => match t {
NautilusObjectType::Record => ObjectType::Record(is_mut, vec![]), // TODO: PDA authorities not supported yet
NautilusObjectType::Account => ObjectType::Account(is_mut, vec![]), // TODO: PDA authorities not supported yet
},
None => panic!("Could not match object type: {}. Was it annotated with a Nautilus #[derive(..)] macro?", ty_name)
}
}
}
/// Resolves the required accounts for an object name and ObjectType.
/// The object name, as declared in the user's function signature, is used
/// to append as a prefix to certain accounts where necessary.
pub fn resolve_accounts(
obj_name: String,
object_type: ObjectType,
is_create: bool,
is_signer: bool,
is_mut: bool,
) -> (Vec<Self>, Option<Vec<Self>>) {
let read = match object_type {
ObjectType::NautilusIndex => {
vec![
Construct::ProgramId.into(),
Construct::SelfAccount(obj_name.clone(), obj_name, is_mut, false).into(),
]
}
ObjectType::Wallet => vec![
Construct::SelfAccount(obj_name.clone(), obj_name, is_mut, is_signer).into(),
Construct::SystemProgram.into(),
],
ObjectType::Token(is_pda) | ObjectType::Nft(is_pda) => {
let metadata_name = obj_name.clone() + "_metadata";
vec![
Construct::SelfAccount(
obj_name.clone(),
obj_name.clone(),
is_mut,
is_signer && !is_pda,
)
.into(),
Construct::Metadata(
metadata_name.clone(),
format!("Metadata account for: {}", obj_name),
is_mut,
)
.into(),
Construct::TokenProgram.into(),
Construct::TokenMetadataProgram.into(),
]
}
ObjectType::Mint(is_pda) => vec![
Construct::SelfAccount(obj_name.clone(), obj_name, is_mut, is_signer && !is_pda)
.into(),
Construct::TokenProgram.into(),
],
ObjectType::Metadata => vec![
Construct::SelfAccount(obj_name.clone(), obj_name, is_mut, false).into(),
Construct::TokenMetadataProgram.into(),
],
ObjectType::AssociatedTokenAccount => {
vec![
Construct::SelfAccount(obj_name.clone(), obj_name, is_mut, false).into(),
Construct::TokenProgram.into(),
Construct::AssociatedTokenProgram.into(),
]
}
ObjectType::Record(is_mut, _) => {
vec![
Construct::ProgramId.into(),
Construct::SelfAccount(obj_name.clone(), obj_name, is_mut, false).into(),
Construct::Index(is_mut).into(),
]
}
ObjectType::Account(is_mut, _) => {
vec![
Construct::ProgramId.into(),
Construct::SelfAccount(obj_name.clone(), obj_name, is_mut, false).into(),
]
}
};
(
read,
match is_create {
true => Some(vec![
Construct::FeePayer.into(),
Construct::SystemProgram.into(),
Construct::Sysvar(SysvarType::Rent).into(),
]),
false => None,
},
)
}
/// De-duplication of required accounts. Used to aggregate all accounts
/// required for an instruction.
pub fn condense(all_required_accounts: Vec<Vec<Self>>) -> Vec<Self> {
let flattened = all_required_accounts
.into_iter()
.flat_map(|v| v.into_iter())
.filter(|r| match r.account_type {
RequiredAccountType::ProgramId => false,
_ => true,
});
let mut map = std::collections::HashMap::new();
for account in flattened {
let entry = map.entry(account.name.clone()).or_insert(account.clone());
entry.is_mut |= account.is_mut;
entry.is_signer |= account.is_signer;
entry.desc = account.desc;
}
let mut res: Vec<RequiredAccount> = map.into_iter().map(|(_, v)| v).collect();
res.sort_by(|a, b| {
let account_type_cmp = a.account_type.cmp(&b.account_type);
if account_type_cmp == std::cmp::Ordering::Equal {
a.name.cmp(&b.name)
} else {
account_type_cmp
}
});
res
}
}
impl From<&RequiredAccount> for proc_macro2::TokenStream {
/// Converts a required account into the tokens used to instantiate a
/// Nautilus object. Each required account for a Nautilus object can use
/// `Into<TokenStream>` to generate the cloning of the `Box` pointers in
/// the processor match arm, to be passed into the object's initializer.
fn from(ast: &RequiredAccount) -> Self {
match &ast.account_type {
RequiredAccountType::ProgramId => quote! { program_id },
RequiredAccountType::IndexAccount => quote! { nautilus_index.clone() },
RequiredAccountType::Account(subtype) => match subtype {
RequiredAccountSubtype::SelfAccount => {
let ident_pointer = self_account_ident_pointer(&ast.ident);
quote! { #ident_pointer.clone() }
}
RequiredAccountSubtype::Metadata => {
let ident_pointer = metadata_ident_pointer(&ast.ident);
quote! { #ident_pointer.clone() }
}
RequiredAccountSubtype::MintAuthority => {
let ident_pointer = mint_authority_ident_pointer(&ast.ident);
quote! { #ident_pointer.clone() }
}
},
_ => {
let ident_pointer = to_ident_pointer(&ast.ident);
quote! { #ident_pointer.clone() }
}
}
}
}
impl ToString for RequiredAccountType {
fn to_string(&self) -> String {
match self {
RequiredAccountType::IndexAccount => "index".to_string(),
RequiredAccountType::FeePayer => "feePayer".to_string(),
RequiredAccountType::Sysvar => "sysvar".to_string(),
RequiredAccountType::SystemProgram => "systemProgram".to_string(),
RequiredAccountType::Program => "program".to_string(),
RequiredAccountType::TokenProgram => "tokenProgram".to_string(),
RequiredAccountType::AssociatedTokenProgram => "associatedTokenProgram".to_string(),
RequiredAccountType::TokenMetadataProgram => "tokenMetadataProgram".to_string(),
_ => "account".to_string(),
}
}
}
pub fn appended_ident(ident: &Ident, to_append: &str) -> Ident {
Ident::new(&(ident.to_string() + to_append), Span::call_site())
}
pub fn self_account_ident(ident: &Ident) -> Ident {
appended_ident(ident, "_self_account")
}
pub fn metadata_ident(ident: &Ident) -> Ident {
appended_ident(ident, "_metadata_account")
}
pub fn mint_authority_ident(ident: &Ident) -> Ident {
appended_ident(ident, "_mint_authority")
}
pub fn to_ident_pointer(ident: &Ident) -> Ident {
appended_ident(ident, "_pointer")
}
pub fn self_account_ident_pointer(ident: &Ident) -> Ident {
appended_ident(ident, "_self_account_pointer")
}
pub fn metadata_ident_pointer(ident: &Ident) -> Ident {
appended_ident(ident, "_metadata_account_pointer")
}
pub fn mint_authority_ident_pointer(ident: &Ident) -> Ident {
appended_ident(ident, "_mint_authority_pointer")
}
pub fn name_to_ident(name: &str) -> Ident {
Ident::new(name, Span::call_site())
}
pub fn name_to_ident_snake(name: &str) -> Ident {
Ident::new(&(name.to_string().to_snake()), Span::call_site())
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/syn/src
|
solana_public_repos/nautilus-project/nautilus/solana/syn/src/entry/parser.rs
|
//! Parses information about the user's entire crate.
use cargo_toml::Manifest;
use convert_case::{Case::Pascal, Casing};
use nautilus_idl::idl_type_def::IdlTypeDef;
use proc_macro2::Span;
use quote::quote;
use shank_macro_impl::krate::CrateContext;
use syn::{FnArg, Ident, Item, ItemFn, Pat, PathArguments, Type, TypePath, UseTree};
use syn::{Meta, NestedMeta};
use crate::object::source::source_nautilus_objects;
use crate::object::ObjectEntryConfig;
use crate::object::{NautilusObject, NautilusObjectType};
use super::entry_variant::CallContext;
/// Parses metadata from the user's `Cargo.toml`
pub fn parse_manifest() -> (String, String) {
let manifest = Manifest::from_path("Cargo.toml")
.expect("Failed to detect `Cargo.toml`. Is your Cargo.toml file structured properly ?");
let package = manifest
.package
.expect("Failed to parse `Cargo.toml`. Is your Cargo.toml file structured properly ?");
let crate_version = package
.version
.get()
.expect("Failed to parse crate version from `Cargo.toml`. Did you provide one ?");
(String::from(crate_version), package.name)
}
/// Uses Metaplex's `shank_macro_impl` to parse all of the contents of the
/// user's crate.
///
/// It uses this information to build the rest of the IDL (accounts and types),
/// and return all defined Nautilus objects annotated with a Nautilus derive
/// macro.
///
/// Consider the return type: (`Vec<NautilusObject>`, `Vec<IdlTypeDef>`,
/// `Vec<IdlTypeDef>`):
/// * `Vec<NautilusObject>`: All Nautilus objects defined in the crate using
/// Nautilus derive macros.
/// * `Vec<IdlTypeDef>` (first): All accounts for the IDL (Nautilus objects).
/// * `Vec<IdlTypeDef>` (second): All types for the IDL (non-Nautilus objects
/// defined in the crate).
pub fn parse_crate_context() -> (Vec<NautilusObject>, Vec<IdlTypeDef>, Vec<IdlTypeDef>) {
let root = std::env::current_dir().unwrap().join("src/lib.rs");
let crate_context = CrateContext::parse(root).expect(
"Failed to detect `src/lib.rs`. Are you sure you've built your program with `--lib` ?",
);
let mut idl_accounts: Vec<IdlTypeDef> = vec![];
let mut idl_types: Vec<IdlTypeDef> = vec![];
let mut nautilus_objects: Vec<NautilusObject> = crate_context
.structs()
.filter_map(|s| {
if let Some(attr) = s.attrs.iter().find(|attr| attr.path.is_ident("derive")) {
if let Ok(Meta::List(meta_list)) = attr.parse_meta() {
let matched_macro =
meta_list
.nested
.iter()
.find_map(|nested_meta| match nested_meta {
NestedMeta::Meta(Meta::Path(path)) => {
if path.is_ident("Table") {
Some(NautilusObjectType::Record)
} else if path.is_ident("State") {
Some(NautilusObjectType::Account)
} else {
None
}
}
_ => None,
});
if let Some(nautilus_ty) = matched_macro {
let nautilus_obj: NautilusObject =
NautilusObject::from_item_struct(s.clone(), nautilus_ty);
let i = &nautilus_obj;
idl_accounts.push(i.into());
return Some(nautilus_obj);
}
}
}
idl_types.push(s.into());
None
})
.collect();
nautilus_objects.extend(source_nautilus_objects());
crate_context.enums().for_each(|e| idl_types.push(e.into()));
(nautilus_objects, idl_accounts, idl_types)
}
/// Parses all required information from a user's defined function.
///
/// All Nautilus objects - both from the source crate itself and the user's
/// crate - are provided as a parameter in order to decipher whether or not a
/// function's parameter is a Nautilus object.
///
/// Consider the return type: (`Ident`, `Vec<(Ident, Type)>`, `Ident`,
/// `Vec<CallContext>`):
/// * `Ident` (first): The identifier of this instruction's variant in the
/// program instruction enum.
/// * `Vec<(Ident, Type)>` (second): The arguments required for this
/// instruction's variant in the program instruction enum.
/// * `Ident` (second): The "call context" of each declared parameter in the
/// user's defined function signature.
/// * `Vec<CallContext>`: The "call context" of each declared parameter in the
/// user's defined function signature.
///
/// You can see these return values are directly used to build a
/// `NautilusEntrypointEnumVariant`.
pub fn parse_function(
nautilus_objects: &Vec<NautilusObject>,
function: ItemFn,
) -> (Ident, Vec<(Ident, Type)>, Ident, Vec<CallContext>) {
let variant_ident = Ident::new(
&function.sig.ident.to_string().to_case(Pascal),
Span::call_site(),
);
let call_ident = function.sig.ident.clone();
let mut variant_args = vec![];
let call_context = function
.sig
.inputs
.into_iter()
.map(|input| match input {
FnArg::Typed(arg) => match *arg.pat {
Pat::Ident(ref pat_ident) => {
let (type_string, is_create, is_signer, is_mut) = parse_type(&arg.ty);
for obj in nautilus_objects {
if obj.ident == &type_string {
let mut nautilus_obj = obj.clone();
nautilus_obj.entry_config = Some(ObjectEntryConfig {
arg_ident: pat_ident.ident.clone(),
is_create,
is_signer,
is_mut,
});
return CallContext::Nautilus(nautilus_obj);
}
}
variant_args.push((pat_ident.ident.clone(), *arg.ty.clone()));
return CallContext::Arg(pat_ident.ident.clone());
}
_ => panic!("Error parsing function."),
},
_ => panic!("Error parsing function."),
})
.collect();
(variant_ident, variant_args, call_ident, call_context)
}
/// Parses the type of a parameter of a user's defined function signature.
pub fn parse_type(ty: &Type) -> (String, bool, bool, bool) {
let mut is_create = false;
let mut is_signer = false;
let mut is_mut = false;
let mut is_pda = false;
let mut child_type = None;
if let Type::Path(TypePath { path, .. }) = &ty {
if let Some(segment) = path.segments.first() {
if segment.ident == "Create" {
is_create = true;
is_signer = true;
is_mut = true;
(child_type, is_pda) = derive_child_type(&segment.arguments)
} else if segment.ident == "Signer" {
is_signer = true;
(child_type, is_pda) = derive_child_type(&segment.arguments)
} else if segment.ident == "Mut" {
is_mut = true;
(child_type, is_pda) = derive_child_type(&segment.arguments)
} else if segment.ident == "Record" || segment.ident == "Account" {
is_pda = true;
(child_type, _) = derive_child_type(&segment.arguments)
}
}
}
is_mut = is_create || is_signer || is_mut;
if is_pda {
is_signer = false;
}
let type_name = if is_create || is_signer || is_mut || is_pda {
if let Some(t) = &child_type {
format!("{}", quote! { #t })
} else {
panic!("Could not parse provided type: {:#?}", ty);
}
} else {
let mut new_t = ty.clone();
remove_lifetimes_from_type(&mut new_t);
format!("{}", quote! { #new_t })
};
(type_name, is_create, is_signer, is_mut)
}
/// Derives the child type of a compound object with angle-bracket generic
/// arguments, ie: `Object<T>`.
fn derive_child_type(arguments: &PathArguments) -> (Option<Type>, bool) {
if let PathArguments::AngleBracketed(args) = arguments {
for arg in &args.args {
if let syn::GenericArgument::Type(ty) = arg {
let mut new_ty = ty.clone();
remove_lifetimes_from_type(&mut new_ty);
if let Type::Path(TypePath { path, .. }) = &new_ty {
if let Some(segment) = path.segments.first() {
if segment.ident == "Record" || segment.ident == "Account" {
return derive_child_type(&segment.arguments);
}
}
}
return (Some(new_ty), false);
}
}
}
(None, false)
}
/// Removes all lifetime specifiers from a `syn::Type`.
///
/// This is not currently used to replace code but to generate a string
/// representation of a type.
fn remove_lifetimes_from_type(t: &mut Type) {
match t {
Type::Path(ref mut tp) => {
if let Some(segment) = tp.path.segments.last_mut() {
if let PathArguments::AngleBracketed(ref mut abga) = segment.arguments {
if abga.args.len() == 1
&& abga
.args
.iter()
.any(|arg| matches!(arg, syn::GenericArgument::Lifetime(_)))
{
segment.arguments = PathArguments::None;
}
}
}
}
Type::Reference(ref mut tr) => {
tr.lifetime = None;
remove_lifetimes_from_type(&mut tr.elem);
}
Type::Paren(ref mut tp) => {
remove_lifetimes_from_type(&mut tp.elem);
}
Type::Tuple(ref mut tt) => {
for elem in &mut tt.elems {
remove_lifetimes_from_type(elem);
}
}
_ => (),
}
}
/// Is the item `use super::*;`
pub fn is_use_super_star(item: &Item) -> bool {
if let Item::Use(use_item) = item {
if let UseTree::Path(use_path) = &use_item.tree {
if let UseTree::Glob(_) = &*use_path.tree {
return use_path.ident == Ident::new("super", use_path.ident.span());
}
}
}
false
}
pub fn type_to_string(ty: &syn::Type) -> Option<String> {
if let syn::Type::Path(type_path) = ty {
if let Some(segment) = type_path.path.segments.last() {
return Some(segment.ident.to_string());
}
}
None
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/syn/src
|
solana_public_repos/nautilus-project/nautilus/solana/syn/src/object/default_instructions.rs
|
use syn::{Attribute, NestedMeta};
/// Possible default instructions for records.
#[derive(Clone, Debug)]
pub enum DefaultInstruction {
Create(String),
Delete(String),
Update(String),
}
impl DefaultInstruction {
pub fn parse(nested_meta: &NestedMeta, struct_name: &str) -> syn::Result<Self> {
if let syn::NestedMeta::Meta(syn::Meta::Path(ref path)) = nested_meta {
let variant_string = path.get_ident().unwrap().to_string();
if variant_string.eq("Create") {
return Ok(DefaultInstruction::Create(struct_name.to_string()));
} else if variant_string.eq("Delete") {
return Ok(DefaultInstruction::Delete(struct_name.to_string()));
} else if variant_string.eq("Update") {
return Ok(DefaultInstruction::Update(struct_name.to_string()));
} else {
return Err(syn_error(&format!(
"Unknown default instruction: {}",
variant_string
)));
}
} else {
return Err(syn_error(
"Invalid format for `default_instructions` attribute",
));
}
}
}
pub struct DefaultInstructionParser {
pub instructions: Vec<DefaultInstruction>,
}
impl DefaultInstructionParser {
pub fn parse(attr: &Attribute, struct_name: &str) -> syn::Result<Self> {
let mut instructions: Vec<DefaultInstruction> = vec![];
if let Ok(syn::Meta::List(ref meta_list)) = attr.parse_meta() {
for nested_meta in meta_list.nested.iter() {
instructions.push(DefaultInstruction::parse(nested_meta, struct_name)?)
}
} else {
return Err(syn_error(
"Invalid format for `default_instructions` attribute",
));
};
Ok(DefaultInstructionParser { instructions })
}
}
fn syn_error(msg: &str) -> syn::Error {
syn::Error::new_spanned("default_instructions", msg)
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/syn/src
|
solana_public_repos/nautilus-project/nautilus/solana/syn/src/object/source.rs
|
//! Spawns all objects from Nautilus's `src/objects/.` into `syn::ItemStruct`
//! types for `syn` processing.
use syn::{punctuated::Punctuated, Field, FieldsNamed, Ident, ItemStruct};
use super::NautilusObject;
/// Enum vehicle used to build a `syn::Field`.
enum SourceField {
ProgramId,
AccountInfo,
Metadata,
SystemProgram,
TokenProgram,
AssociatedTokenProgram,
TokenMetadataProgram,
}
impl From<&SourceField> for Field {
/// Converts from a `SourceField` to a `syn::Field`.
fn from(value: &SourceField) -> Self {
match value {
SourceField::ProgramId => source_field("program_id"),
SourceField::AccountInfo => source_field("account_info"),
SourceField::Metadata => source_field("metadata"),
SourceField::SystemProgram => source_field("system_program"),
SourceField::TokenProgram => source_field("token_program"),
SourceField::AssociatedTokenProgram => source_field("associated_token_program"),
SourceField::TokenMetadataProgram => source_field("token_metadata_program"),
}
}
}
/// Helper function to build a named `syn::Field` from defaults.
fn source_field(field_name: &str) -> Field {
Field {
attrs: vec![],
vis: syn::Visibility::Inherited,
ident: Some(Ident::new(field_name, proc_macro2::Span::call_site())),
colon_token: Some(Default::default()),
ty: syn::parse_quote!(AccountInfo<'a>),
}
}
/// Helper function to build a named `syn::ItemStruct` from defaults.
fn source_struct(name: &str, source_fields: Vec<SourceField>) -> ItemStruct {
let ident = Ident::new(name, proc_macro2::Span::call_site());
let fields = {
let mut fields = Punctuated::new();
for f in &source_fields {
fields.push(f.into())
}
FieldsNamed {
brace_token: Default::default(),
named: fields,
}
};
ItemStruct {
attrs: vec![],
vis: syn::Visibility::Inherited,
struct_token: Default::default(),
ident,
generics: Default::default(),
fields: syn::Fields::Named(fields),
semi_token: None,
}
}
/// Uses helpers to return a vector of all Nautilus objects from Nautilus's
/// `src/objects/.` as `syn::ItemStruct` types.
pub fn source_nautilus_objects() -> Vec<NautilusObject> {
[
source_struct(
"NautilusIndex",
vec![SourceField::ProgramId, SourceField::AccountInfo],
),
source_struct(
"Wallet",
vec![SourceField::AccountInfo, SourceField::SystemProgram],
),
source_struct(
"Mint",
vec![SourceField::AccountInfo, SourceField::TokenProgram],
),
source_struct(
"Metadata",
vec![SourceField::AccountInfo, SourceField::TokenMetadataProgram],
),
source_struct(
"AssociatedTokenAccount",
vec![
SourceField::AccountInfo,
SourceField::TokenProgram,
SourceField::AssociatedTokenProgram,
],
),
source_struct(
"Token",
vec![
SourceField::AccountInfo,
SourceField::Metadata,
SourceField::TokenProgram,
SourceField::TokenMetadataProgram,
],
),
source_struct(
"Nft",
vec![
SourceField::AccountInfo,
SourceField::Metadata,
SourceField::TokenProgram,
SourceField::TokenMetadataProgram,
],
),
]
.into_iter()
.map(|s| NautilusObject::from_item_struct(s, super::NautilusObjectType::Account))
.collect()
}
/// Returns a vector with just the string names of all objects from Nautilus's
/// `src/objects/.`.
pub fn source_nautilus_names() -> Vec<String> {
vec![
"NautilusIndex".to_string(),
"Wallet".to_string(),
"Mint".to_string(),
"Metadata".to_string(),
"AssociatedTokenAccount".to_string(),
"Token".to_string(),
"Nft".to_string(),
]
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/syn/src
|
solana_public_repos/nautilus-project/nautilus/solana/syn/src/object/mod.rs
|
//! Builds the required trait implementations for an annotated struct.
pub mod data;
pub mod default_instructions;
pub mod parser;
pub mod seeds;
pub mod source;
use proc_macro2::TokenStream;
use quote::{quote, ToTokens};
use syn::{Ident, ItemEnum, ItemStruct};
use crate::entry::required_account::RequiredAccount;
use self::{
data::{
impl_borsh, impl_clone, impl_default, impl_nautilus_account_data, impl_nautilus_record_data,
},
parser::{parse_item_struct, NautilusObjectConfig},
};
/// The struct containing the parsed contents of a user's struct, annotated with
/// either `#[derive(nautilus::Table)]` or `#[derive(nautilus::State)]`.
///
/// * `ident`: The struct's identifier.
/// * `raw_Type`: The raw type of the object (is it a struct or enum?).
/// * `entry_config`: Account-specific configurations required for building the
/// program's entrypoint, such as `is_signer`.
/// * `object_config`: The object's configurations. these will be specific to
/// whether or not it's a `Record` or an `Account`.
#[derive(Clone, Debug)]
pub struct NautilusObject {
pub ident: Ident,
pub raw_type: NautilusObjectRawType,
pub entry_config: Option<ObjectEntryConfig>,
pub object_config: Option<NautilusObjectConfig>,
}
/// The type of Nautilus object.
#[derive(Clone, Debug)]
pub enum NautilusObjectType {
Record,
Account,
}
/// Represent a "raw type" of an object (struct or enum?).
#[derive(Clone, Debug)]
pub enum NautilusObjectRawType {
Struct(ItemStruct),
Enum(ItemEnum),
}
/// Entrypoint configurations for underlying accounts.
#[derive(Clone, Debug)]
pub struct ObjectEntryConfig {
pub arg_ident: Ident,
pub is_create: bool,
pub is_signer: bool,
pub is_mut: bool,
}
impl NautilusObject {
/// Converts the user's annotated struct into the `NautilusObject` struct.
///
/// All of the work to implement all required traits for the account's inner
/// data is done here. It's handled mostly by the
/// `parse_item_struct(..)` function.
///
/// Note: because the `NautilusObject` struct is used for derivations on
/// many different kinds of Nautilus objects, the default for converting
/// directly from a `syn::ItemStruct` into a `NautilusObject`
/// is to set the value for `entry_config` to `None`. This is because we
/// don't require these configurations when comprising a list of types -
/// both for the IDL and to compare from later. This is done in the
/// entrypoint `#[nautilus]` macro.
pub fn from_item_struct(value: ItemStruct, nautilus_ty: NautilusObjectType) -> Self {
let ident = value.ident.clone();
let object_config = parse_item_struct(&value, nautilus_ty);
Self {
ident,
raw_type: NautilusObjectRawType::Struct(value.clone()),
entry_config: None,
object_config,
}
}
/// Resolve the required accounts for this object type based on its
/// configurations and object type (`Record`, `Account`, `Mint`, etc.).
pub fn get_required_accounts(&self) -> (Vec<RequiredAccount>, Option<Vec<RequiredAccount>>) {
match &self.entry_config {
Some(config) => RequiredAccount::resolve_accounts(
config.arg_ident.to_string(),
RequiredAccount::derive_object_type(
&self.ident.to_string(),
config.is_mut,
self.object_config.as_ref().map(|config| match config {
NautilusObjectConfig::RecordConfig { .. } => NautilusObjectType::Record,
NautilusObjectConfig::AccountConfig { .. } => NautilusObjectType::Account,
})
),
config.is_create,
config.is_signer,
config.is_mut,
),
None => panic!("Error: `get_required_accounts` was invoked before setting the value for `entry_config`!"),
}
}
}
impl ToTokens for NautilusObject {
/// Extends the existing compiler tokens by the tokens generated by the
/// `NautilusObject`.
fn to_tokens(&self, tokens: &mut TokenStream) {
tokens.extend::<TokenStream>(self.into());
}
}
impl From<&NautilusObject> for TokenStream {
/// Spawns a myriad of new tokens from the `NautilusObject` for the
/// compiler. This is where the various configurations are used to
/// generate tokens for implementing traits.
fn from(ast: &NautilusObject) -> Self {
let ident = &ast.ident;
let object_config = match &ast.object_config {
Some(object_config) => object_config,
None => panic!(
"No object_config was derived for this Nautilus object: {}",
ident.to_string()
),
};
match object_config {
NautilusObjectConfig::RecordConfig {
table_name,
data_fields,
autoincrement_enabled,
primary_key_ident,
primary_key_ty,
authorities: _, // TODO: Add authority function creation
default_instructions: _, // TODO: Add default instructions to
} => {
let fields = &data_fields;
let impl_clone = impl_clone(ident, fields);
let impl_default = impl_default(ident, fields);
let impl_borsh = impl_borsh(ident, fields);
let impl_nautilus_record_data = impl_nautilus_record_data(
ident,
fields,
&table_name,
*autoincrement_enabled,
&primary_key_ident,
&primary_key_ty,
);
quote! {
#impl_clone
#impl_default
#impl_borsh
#impl_nautilus_record_data
}
.into()
}
NautilusObjectConfig::AccountConfig {
discrminator_str,
data_fields,
authorities: _, // TODO: Add authority function creation
seeds,
} => {
let fields = &data_fields;
let impl_clone = impl_clone(ident, fields);
let impl_default = impl_default(ident, fields);
let impl_borsh = impl_borsh(ident, fields);
let impl_nautilus_account_data =
impl_nautilus_account_data(ident, fields, &discrminator_str, seeds);
quote! {
#impl_clone
#impl_default
#impl_borsh
#impl_nautilus_account_data
}
.into()
}
}
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/syn/src
|
solana_public_repos/nautilus-project/nautilus/solana/syn/src/object/data.rs
|
//! Spawns the tokens for the required trait implementations for an annotated
//! struct.
use proc_macro2::{Span, TokenStream};
use quote::quote;
use syn::{token::Colon, Fields, FnArg, Ident, Pat, PatIdent, PatType, Type};
use super::seeds::Seed;
/// Generates tokens to implement `Clone` on a struct.
pub fn impl_clone(ident: &Ident, fields: &Fields) -> TokenStream {
let clone_constructors = fields.iter().map(|f| {
let ident = &f.ident.as_ref().unwrap();
quote! { #ident: ::core::clone::Clone::clone(&self.#ident) }
});
quote! {
impl ::core::clone::Clone for #ident {
#[inline]
fn clone(&self) -> Self {
Self {
#(#clone_constructors,)*
}
}
}
}
}
/// Generates tokens to implement `Default` on a struct.
pub fn impl_default(ident: &Ident, fields: &Fields) -> TokenStream {
let fields_default = fields.iter().map(|f| {
let i = &f.ident.clone().unwrap();
quote! { #i: ::core::default::Default::default() }
});
quote! {
impl ::core::default::Default for #ident {
#[inline]
fn default() -> Self {
Self {
#(#fields_default,)*
}
}
}
}
}
/// Generates tokens to implement `BorshDeserialize` and `BorshSerialize` on a
/// struct.
pub fn impl_borsh(ident: &Ident, fields: &Fields) -> TokenStream {
let borsh_ser_where = fields.iter().map(|f| {
let field_ty = f.ty.clone();
quote::quote! { #field_ty: nautilus::borsh::ser::BorshSerialize }
});
let borsh_ser_impl = fields.iter().map(|f| {
let field_name = f.ident.clone();
quote::quote! { nautilus::borsh::BorshSerialize::serialize(&self.#field_name, writer)? }
});
let borsh_deser_where = fields.iter().map(|f| {
let field_ty = f.ty.clone();
quote::quote! { #field_ty: nautilus::borsh::de::BorshDeserialize }
});
let borsh_deser_impl = fields.iter().map(|f| {
let field_name = f.ident.clone();
quote::quote! { #field_name: nautilus::borsh::BorshDeserialize::deserialize(buf)? }
});
quote::quote! {
impl nautilus::borsh::ser::BorshSerialize for #ident
where
#(#borsh_ser_where,)*
{
fn serialize<W: nautilus::borsh::maybestd::io::Write>(
&self,
writer: &mut W,
) -> ::core::result::Result<(), nautilus::borsh::maybestd::io::Error> {
borsh::BorshSerialize::serialize(&self.discriminator(), writer)?; // Serialize the discriminator first
#(#borsh_ser_impl;)*
Ok(())
}
}
impl nautilus::borsh::de::BorshDeserialize for #ident
where
#(#borsh_deser_where,)*
{
fn deserialize(
buf: &mut &[u8],
) -> ::core::result::Result<Self, nautilus::borsh::maybestd::io::Error> {
let _discrim: [u8; 8] = borsh::BorshDeserialize::deserialize(buf)?; // Skip the first 8 bytes for discriminator
Ok(Self {
#(#borsh_deser_impl,)*
})
}
}
}
}
/// Generates tokens to implement `NautilusRecordData` on a struct.
pub fn impl_nautilus_record_data(
ident: &Ident,
fields: &Fields,
table_name: &String,
autoincrement: bool,
primary_key_ident: &Ident,
primary_key_ty: &Type,
) -> TokenStream {
let nautilus_create_obj_trait_ident = &Ident::new(
&("NautilusCreate".to_owned() + &ident.to_string()),
Span::call_site(),
);
let tokens_primary_key_seed = build_tokens_primary_key_seed(primary_key_ident, primary_key_ty);
let (data_new_fn_args, data_new_call_args) =
get_new_fn_args_for_record(fields, autoincrement, primary_key_ident);
let data_new_fn = match autoincrement {
true => quote! {
pub fn new<'a>(
mut nautilus_index: NautilusIndex<'a>,
fee_payer: impl NautilusSigner<'a>,
#(#data_new_fn_args,)*
) -> Result<Box<Self>, ProgramError> {
let #primary_key_ident = nautilus_index.add_record(
Self::TABLE_NAME,
fee_payer,
)?.try_into().unwrap();
Ok(Box::new(Self{ #primary_key_ident, #(#data_new_call_args,)* }))
}
},
false => quote! {
pub fn new<'a>(
_nautilus_index: NautilusIndex<'a>,
fee_payer: impl NautilusSigner<'a>,
#(#data_new_fn_args,)*
) -> Result<Box<Self>, ProgramError> {
Ok(Box::new(Self{ #(#data_new_call_args,)* }))
}
},
};
quote! {
impl #ident {
#data_new_fn
}
impl NautilusRecordData for #ident {
const TABLE_NAME: &'static str = #table_name;
const AUTO_INCREMENT: bool = #autoincrement;
fn primary_key(&self) -> Vec<u8> {
#tokens_primary_key_seed
}
fn check_authorities(&self, accounts: Vec<AccountInfo>) -> Result<(), ProgramError> {
todo!()
}
fn count_authorities(&self) -> u8 {
todo!()
}
}
pub trait #nautilus_create_obj_trait_ident<'a> {
fn create(&mut self, #(#data_new_fn_args,)*) -> ProgramResult;
fn create_with_payer(&mut self, #(#data_new_fn_args,)* payer: impl NautilusSigner<'a>) -> ProgramResult;
}
impl<'a> #nautilus_create_obj_trait_ident<'a> for Create<'a, Record<'a, #ident>> {
fn create(&mut self, #(#data_new_fn_args,)*) -> ProgramResult {
let rent_payer = Signer::new(Wallet {
account_info: self.fee_payer.to_owned(),
system_program: self.system_program.to_owned(),
})?;
self.self_account.data = #ident ::new(
self.self_account.index.clone(),
rent_payer,
#(#data_new_call_args,)*
)?;
self.create_record()
}
fn create_with_payer(&mut self, #(#data_new_fn_args,)* payer: impl NautilusSigner<'a>) -> ProgramResult {
self.self_account.data = #ident ::new(
self.self_account.index.clone(),
payer.clone(),
#(#data_new_call_args,)*
)?;
self.create_record_with_payer(payer)
}
}
}
}
/// Generates tokens to implement `NautilusAccountData` on a struct.
pub fn impl_nautilus_account_data(
ident: &Ident,
fields: &Fields,
discrminator_str: &String,
seeds: &Vec<Seed>,
) -> TokenStream {
let nautilus_inner_trait_ident = &Ident::new(
&("NautilusInner".to_owned() + &ident.to_string()),
Span::call_site(),
);
let nautilus_create_obj_trait_ident = &Ident::new(
&("NautilusCreate".to_owned() + &ident.to_string()),
Span::call_site(),
);
let (data_new_fn_args, data_new_call_args) = get_new_fn_args_for_account(fields);
let data_new_fn = quote! {
pub fn new<'a>(
fee_payer: impl NautilusSigner<'a>,
#(#data_new_fn_args,)*
) -> Result<Box<Self>, ProgramError> {
Ok(Box::new(Self{ #(#data_new_call_args,)* }))
}
};
// Determines how we build the `seeds(..)` and `pda(..)` functions and their
// respective callers.
let (seeds_inner, seeds_params_tuple) = build_seeds_components_for_account(seeds);
let (
seeds_args,
seeds_caller,
pda_args,
pda_caller,
pda_caller_outer,
pda_args_outer,
create_args,
create_with_payer_args,
) = match &seeds_params_tuple {
Some(tuple) => (
quote! { &self, seeds: #tuple },
quote! { seeds },
quote! { &self, program_id: &Pubkey, seeds: #tuple },
quote! { program_id, seeds },
quote! { seeds },
quote! { &self, seeds: #tuple },
quote! { &mut self, #(#data_new_fn_args,)* seeds: #tuple },
quote! { &mut self, #(#data_new_fn_args,)* seeds: #tuple, payer: impl NautilusSigner<'a> },
),
None => (
quote! { &self },
quote!(),
quote! { &self, program_id: &Pubkey },
quote! { program_id },
quote!(),
quote! { &self },
quote! { &mut self, #(#data_new_fn_args,)* },
quote! { &mut self, #(#data_new_fn_args,)* payer: impl NautilusSigner<'a> },
),
};
// For seeds on inner data `T`.
let seeds_fn = quote! {
pub fn seeds(#seeds_args) -> Result<Vec<Vec<u8>>, ProgramError> {
Ok(#seeds_inner)
}
};
// For PDA on inner data `T`.
let pda_fn = quote! {
pub fn pda(#pda_args) -> Result<(Pubkey, u8), ProgramError> {
let seeds_vec = self.seeds(#seeds_caller)?;
let seeds: Vec<&[u8]> = seeds_vec.iter().map(AsRef::as_ref).collect();
Ok(Pubkey::find_program_address(&seeds, program_id))
}
};
// For seeds on `Account<T>`.
let seeds_fn_outer = quote! {
fn seeds(#seeds_args) -> Result<Vec<Vec<u8>>, ProgramError> {
self.data.seeds(#seeds_caller)
}
};
// For PDA on `Account<T>`.
let pda_fn_outer = quote! {
fn pda(#pda_args_outer) -> Result<(Pubkey, u8), ProgramError> {
let program_id = self.program_id;
self.data.pda(#pda_caller)
}
};
// For seeds on `Create<Account<T>>`.
let seeds_fn_outer_2 = quote! {
fn seeds(#seeds_args) -> Result<Vec<Vec<u8>>, ProgramError> {
self.self_account.seeds(#seeds_caller)
}
};
// For PDA on `Create<Account<T>>`.
let pda_fn_outer_2 = quote! {
fn pda(#pda_args_outer) -> Result<(Pubkey, u8), ProgramError> {
self.self_account.pda(#pda_caller_outer)
}
};
quote! {
impl #ident {
#data_new_fn
#seeds_fn
#pda_fn
}
impl NautilusAccountData for #ident {
const DISCRIMINATOR_STR: &'static str = #discrminator_str;
fn check_authorities(&self, accounts: Vec<AccountInfo>) -> Result<(), ProgramError> {
todo!()
}
fn count_authorities(&self) -> u8 {
todo!()
}
}
pub trait #nautilus_inner_trait_ident<'a> {
fn seeds(#seeds_args) -> Result<Vec<Vec<u8>>, ProgramError>;
fn pda(#pda_args_outer) -> Result<(Pubkey, u8), ProgramError>;
}
impl<'a> #nautilus_inner_trait_ident<'a> for Account<'a, #ident> {
#seeds_fn_outer
#pda_fn_outer
}
impl<'a> #nautilus_inner_trait_ident<'a> for Create<'a, Account<'a, #ident>> {
#seeds_fn_outer_2
#pda_fn_outer_2
}
pub trait #nautilus_create_obj_trait_ident<'a> {
fn create(#create_args) -> ProgramResult;
fn create_with_payer(#create_with_payer_args) -> ProgramResult;
}
impl<'a> #nautilus_create_obj_trait_ident<'a> for Create<'a, Account<'a, #ident>> {
fn create(#create_args) -> ProgramResult {
let payer = Signer::new(Wallet {
account_info: self.fee_payer.to_owned(),
system_program: self.system_program.to_owned(),
})?;
self.self_account.data = #ident ::new(
payer.clone(),
#(#data_new_call_args,)*
)?;
let (pda, bump) = self.pda(#pda_caller_outer)?;
assert_eq!(
&pda,
self.key(),
"Derived PDA does not match data for account {:#?}",
self.key()
);
let mut signer_seeds_vec = self.seeds(#seeds_caller)?;
signer_seeds_vec.push(vec![bump]);
let signer_seeds: Vec<&[u8]> = signer_seeds_vec.iter().map(AsRef::as_ref).collect();
cpi::system::create_pda(
self.self_account.clone(),
self.self_account.program_id,
payer,
self.self_account.data.clone(),
signer_seeds,
)
}
fn create_with_payer(#create_with_payer_args) -> ProgramResult {
self.self_account.data = #ident ::new(
payer.clone(),
#(#data_new_call_args,)*
)?;
let (pda, bump) = self.pda(#pda_caller_outer)?;
assert_eq!(
&pda,
self.key(),
"Derived PDA does not match data for account {:#?}",
self.key()
);
let mut signer_seeds_vec = self.seeds(#seeds_caller)?;
signer_seeds_vec.push(vec![bump]);
let signer_seeds: Vec<&[u8]> = signer_seeds_vec.iter().map(AsRef::as_ref).collect();
cpi::system::create_pda(
self.self_account.clone(),
self.self_account.program_id,
payer,
self.self_account.data.clone(),
signer_seeds,
)
}
}
}
}
/// Helper function to generate tokens for writing the function that returns the
/// data type's primary key.
fn build_tokens_primary_key_seed(key: &syn::Ident, ty: &syn::Type) -> TokenStream {
match quote::quote!(#ty).to_string().as_str() {
"String" => quote::quote! {
self.#key.as_bytes().to_vec()
},
"u8" => quote::quote! {
vec![self.#key]
},
"u16" | "u32" | "u64" => quote::quote! {
self.#key.to_le_bytes().to_vec()
},
"Pubkey" => quote::quote! {
self.#key.to_vec()
},
_ => panic!(
"Invalid primary key type! Only `String`, `u8`, `u16, `u32`, `u64`, and `Pubkey` are supported."
),
}
}
/// Helper function that parses the fields of a struct to determine the function
/// signature for a `new(..) -> Self` function to create a record.
fn get_new_fn_args_for_record(
fields: &Fields,
autoincrement: bool,
primary_key_ident: &Ident,
) -> (Vec<FnArg>, Vec<Ident>) {
let mut data_new_fn_args: Vec<FnArg> = vec![];
let mut data_new_call_args: Vec<Ident> = vec![];
fields.iter().for_each(|f| match &f.ident {
Some(ident) => {
if !(autoincrement && ident == primary_key_ident) {
data_new_call_args.push(ident.clone());
data_new_fn_args.push(FnArg::Typed(PatType {
attrs: vec![],
pat: Box::new(Pat::Ident(PatIdent {
attrs: vec![],
by_ref: None,
mutability: None,
ident: ident.clone(),
subpat: None,
})),
colon_token: Colon::default(),
ty: Box::new(f.ty.clone()),
}))
}
}
None => (),
});
(data_new_fn_args, data_new_call_args)
}
/// Helper function that parses the fields of a struct to determine the function
/// signature for a `new(..) -> Self` function to create an account.
fn get_new_fn_args_for_account(fields: &Fields) -> (Vec<FnArg>, Vec<Ident>) {
let mut data_new_fn_args: Vec<FnArg> = vec![];
let mut data_new_call_args: Vec<Ident> = vec![];
fields.iter().for_each(|f| match &f.ident {
Some(ident) => {
data_new_call_args.push(ident.clone());
data_new_fn_args.push(FnArg::Typed(PatType {
attrs: vec![],
pat: Box::new(Pat::Ident(PatIdent {
attrs: vec![],
by_ref: None,
mutability: None,
ident: ident.clone(),
subpat: None,
})),
colon_token: Colon::default(),
ty: Box::new(f.ty.clone()),
}))
}
None => (),
});
(data_new_fn_args, data_new_call_args)
}
/// Builds the various arguments for the account's seeds.
///
/// Consider the return type of this function:
/// * 'seeds_inner': Conversions of all seeds into the `Vec<Vec<u8>>`.
/// * 'seeds_params': Input parameters required for any seeds declared that are
/// parameter-like.
/// * 'seeds_params_tuple': Input parameters required represented in a tuple.
fn build_seeds_components_for_account(seeds: &Vec<Seed>) -> (TokenStream, Option<TokenStream>) {
let mut seeds_inner_items: Vec<TokenStream> = vec![];
let mut seeds_params_types: Vec<&Type> = vec![];
let mut i = 0usize;
seeds.into_iter().for_each(|s| match s {
Seed::Lit { value } => seeds_inner_items.push(quote! { #value.as_bytes().to_vec() }),
Seed::Field { ident } => {
seeds_inner_items.push(quote! { borsh::BorshSerialize::try_to_vec(&self.#ident)? })
}
Seed::Param { ident: _, ty } => {
let index_accessor = syn::Index::from(i);
seeds_params_types.push(&ty);
seeds_inner_items
.push(quote! { borsh::BorshSerialize::try_to_vec(&seeds.#index_accessor)? });
i += 1;
}
});
// `Vec<u8>` conversions.
let seeds_inner = quote! {
vec![#(#seeds_inner_items,)*]
};
// Parameters for the `seeds(..)` function as a tuple.
let seeds_params_tuple = match seeds_params_types.len() > 0 {
true => Some(quote! { (#(#seeds_params_types,)*) }),
false => None,
};
(seeds_inner, seeds_params_tuple)
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/syn/src
|
solana_public_repos/nautilus-project/nautilus/solana/syn/src/object/seeds.rs
|
use syn::{
parse::{Parse, ParseStream},
punctuated::Punctuated,
token::Comma,
Ident, LitStr, Type,
};
/// Possible account seeds.
#[derive(Clone, Debug)]
pub enum Seed {
Lit { value: String },
Field { ident: Ident },
Param { ident: Ident, ty: Type },
}
impl Parse for Seed {
/// Parses a parsed token stream into a `Seed`.
fn parse(input: ParseStream) -> syn::Result<Self> {
let lookahead = input.lookahead1();
if lookahead.peek(LitStr) {
let lit: LitStr = input.parse()?;
Ok(Seed::Lit { value: lit.value() })
} else if lookahead.peek(Ident) {
let ident: Ident = input.parse()?;
if input.peek(syn::Token![:]) {
input.parse::<syn::Token![:]>()?;
let ty: Type = input.parse()?;
Ok(Seed::Param { ident, ty })
} else {
Ok(Seed::Field { ident })
}
} else {
Err(lookahead.error())
}
}
}
/// Vehicle for parsing a parsed token stream into a `Vec<Seed>`.
pub struct SeedParser {
pub seeds: Vec<Seed>,
}
impl Parse for SeedParser {
/// Parses a parsed token stream into a `Vec<Seed>`.
fn parse(input: ParseStream) -> syn::Result<Self> {
let content;
syn::parenthesized!(content in input);
let seeds: Punctuated<Seed, Comma> = content.parse_terminated(Seed::parse)?;
Ok(SeedParser {
seeds: seeds.into_iter().collect(),
})
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/syn/src
|
solana_public_repos/nautilus-project/nautilus/solana/syn/src/object/parser.rs
|
//! Parses a user's defined struct.
use proc_macro2::TokenStream;
use syn::{Fields, Ident, ItemStruct, Type};
use crate::object::seeds::SeedParser;
use super::{
default_instructions::{DefaultInstruction, DefaultInstructionParser},
seeds::Seed,
NautilusObjectType,
};
/// Object configurations for either a `Record<T>` or `Account<T>`.
#[derive(Clone, Debug)]
pub enum NautilusObjectConfig {
/// Object configurations for a `Record<T>`.
RecordConfig {
table_name: String,
data_fields: Fields,
autoincrement_enabled: bool,
primary_key_ident: Ident,
primary_key_ty: Type,
authorities: Vec<Ident>,
default_instructions: Vec<DefaultInstruction>,
},
/// Object configurations for an `Account<T>`.
AccountConfig {
discrminator_str: String,
data_fields: Fields,
authorities: Vec<Ident>,
seeds: Vec<Seed>,
},
}
pub struct NautilusAccountFieldAttributes {
pub is_primary_key: bool,
pub autoincrement_enabled: bool,
pub is_authority: bool,
}
/// Parse out a `syn::ItemStruct` according to whichever type of Nautilus object
/// is attempting to be created from the macro.
pub fn parse_item_struct(
item_struct: &ItemStruct,
nautilus_ty: NautilusObjectType,
) -> Option<NautilusObjectConfig> {
let ident_string = item_struct.ident.to_string();
let discrminator_str = ident_string.clone().to_lowercase();
let data_fields = item_struct.fields.clone();
match nautilus_ty {
NautilusObjectType::Record => {
let default_instructions =
parse_top_level_attributes_for_record(&ident_string, &item_struct.attrs);
let mut primary_key_ident_opt: Option<(Ident, Type)> = None;
let mut autoincrement_enabled: bool = true;
let mut authorities: Vec<Ident> = vec![];
let mut _optionized_struct_fields: Vec<(Ident, TokenStream, TokenStream)> = vec![];
for f in data_fields.iter() {
let parsed_attributes = parse_field_attributes(&f);
if !parsed_attributes.autoincrement_enabled {
autoincrement_enabled = parsed_attributes.autoincrement_enabled;
}
if parsed_attributes.is_primary_key {
primary_key_ident_opt = Some((f.ident.clone().unwrap(), f.ty.clone()));
}
if parsed_attributes.is_authority {
authorities.push(f.ident.clone().unwrap());
}
}
let (primary_key_ident, primary_key_ty) = match primary_key_ident_opt {
Some((ident, ty)) => (ident, ty),
None => return None,
};
Some(NautilusObjectConfig::RecordConfig {
table_name: discrminator_str,
data_fields,
autoincrement_enabled,
primary_key_ident,
primary_key_ty,
authorities,
default_instructions,
})
}
NautilusObjectType::Account => {
let seeds = parse_top_level_attributes_for_account(&item_struct.attrs);
let mut authorities: Vec<Ident> = vec![];
let mut _optionized_struct_fields: Vec<(Ident, TokenStream, TokenStream)> = vec![];
for f in data_fields.iter() {
let parsed_attributes = parse_field_attributes(&f);
if parsed_attributes.is_authority {
authorities.push(f.ident.clone().unwrap());
}
}
Some(NautilusObjectConfig::AccountConfig {
discrminator_str,
data_fields,
authorities,
seeds,
})
}
}
}
/// Parses the field attributes of the struct, such as `#[authority]` and
/// `#[primary_key(..)]`.
pub fn parse_field_attributes(field: &syn::Field) -> NautilusAccountFieldAttributes {
let mut is_primary_key = false;
let mut autoincrement_enabled = true;
let mut is_authority = false;
for attr in field.attrs.iter() {
if let Ok(syn::Meta::List(meta_list)) = attr.parse_meta() {
if meta_list.path.is_ident("primary_key") {
is_primary_key = true;
for nested_meta in &meta_list.nested {
if let syn::NestedMeta::Meta(syn::Meta::NameValue(meta_name_value)) =
nested_meta
{
if meta_name_value.path.is_ident("autoincrement") {
if let syn::Lit::Bool(lit_bool) = &meta_name_value.lit {
autoincrement_enabled = lit_bool.value();
}
}
}
}
}
} else if attr.path.is_ident("primary_key") {
is_primary_key = true;
} else if attr.path.is_ident("authority") {
is_authority = true;
}
}
NautilusAccountFieldAttributes {
is_primary_key,
autoincrement_enabled,
is_authority,
}
}
/// Attempts to parse the top-level macro attributes for
/// `#[derive(nautilus::Table)]`, such as `#[default_instructions(..)]`.
pub fn parse_top_level_attributes_for_record(
struct_name: &str,
attrs: &Vec<syn::Attribute>,
) -> Vec<DefaultInstruction> {
let mut default_instructions = Vec::new();
for attr in attrs.iter() {
if attr.path.is_ident("default_instructions") {
let mut parsed_instructions = DefaultInstructionParser::parse(attr, struct_name)
.expect("Invalid format for `default_instructions` attribute");
default_instructions.append(&mut parsed_instructions.instructions);
}
}
default_instructions
}
/// Attempts to parse the top-level macro attributes for
/// `#[derive(nautilus::State)]`, such as `#[seeds(..)]`.
pub fn parse_top_level_attributes_for_account(attrs: &Vec<syn::Attribute>) -> Vec<Seed> {
let mut seeds = Vec::new();
for attr in attrs.iter() {
if attr.path.is_ident("seeds") {
let mut parsed_seeds: SeedParser =
syn::parse2(attr.tokens.clone()).expect("Invalid format for `seeds` attribute");
seeds.append(&mut parsed_seeds.seeds);
};
}
seeds
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana
|
solana_public_repos/nautilus-project/nautilus/solana/src/error.rs
|
//! Nautilus custom errors.
use num_traits::{FromPrimitive, ToPrimitive};
use solana_program::{
decode_error::DecodeError,
program_error::{PrintProgramError, ProgramError},
};
use splogger::{error, Splog};
use thiserror::Error;
/// Custom errors for Nautilus functionality. Convertible to
/// `solana_program::program_error::ProgramError`.
#[derive(Clone, Debug, Eq, Error, PartialEq)]
pub enum NautilusError {
/// The inner data of an account could not be loaded. This usually means the
/// account is empty.
#[error("The inner data of an account could not be loaded. This usually means the account is empty.")]
LoadDataFailed(String, String),
/// The inner data of an account could not be deserialized. This usually
/// means an account type mismatch.
#[error("The inner data of an account could not be deserialized. This usually means an account type mismatch.")]
DeserializeDataFailed(String, String),
/// Nautilus couldn't write a new record to a table. This usually means an
/// error with the primary key provided.
#[error("Nautilus couldn't write a new record to a table. This usually means an error with the primary key provided.")]
WriteRecordFailed(String),
/// The underlying account for a `Mut<T>` declared object was not marked as
/// mutable.
#[error("The underlying account for a `Mut<T>` declared object was not marked as mutable.")]
AccountNotMutable(String),
/// The underlying account for a `Signer<T>` declared object was not marked
/// as signer.
#[error("The underlying account for a `Signer<T>` declared object was not marked as signer.")]
AccountNotSigner(String),
/// The underlying account for a `Create<T>` declared object already exists.
#[error("The underlying account for a `Create<T>` declared object already exists.")]
AccountExists(String),
}
impl<T> DecodeError<T> for NautilusError {
fn type_of() -> &'static str {
"NautilusError"
}
}
impl FromPrimitive for NautilusError {
fn from_i64(n: i64) -> Option<Self> {
match n {
200 => Some(Self::LoadDataFailed(String::default(), String::default())),
201 => Some(Self::DeserializeDataFailed(
String::default(),
String::default(),
)),
202 => Some(Self::WriteRecordFailed(String::default())),
203 => Some(Self::AccountNotMutable(String::default())),
204 => Some(Self::AccountNotSigner(String::default())),
205 => Some(Self::AccountExists(String::default())),
_ => None,
}
}
fn from_u64(n: u64) -> Option<Self> {
Self::from_i64(n as i64)
}
}
impl ToPrimitive for NautilusError {
fn to_i64(&self) -> Option<i64> {
match self {
Self::LoadDataFailed(..) => Some(200),
Self::DeserializeDataFailed(..) => Some(201),
Self::WriteRecordFailed(..) => Some(202),
Self::AccountNotMutable(..) => Some(203),
Self::AccountNotSigner(..) => Some(204),
Self::AccountExists(..) => Some(205),
}
}
fn to_u64(&self) -> Option<u64> {
self.to_i64().map(|n| n as u64)
}
}
impl PrintProgramError for NautilusError {
fn print<E>(&self)
where
E: 'static + std::error::Error + DecodeError<E> + PrintProgramError + FromPrimitive,
{
match self {
Self::LoadDataFailed(state_type, pubkey) => {
error!(
"Failed to load {} data from account: {}",
state_type, pubkey
);
error!("Could not borrow account data");
error!(
"Failed to load {} data from account: {}",
state_type, pubkey
);
}
Self::DeserializeDataFailed(state_type, pubkey) => {
error!(
"Failed to deserialize {} data from account: {}",
state_type, pubkey
);
error!("Could not deserialize");
error!(
"Failed to deserialize {} data from account: {}",
state_type, pubkey
);
}
Self::WriteRecordFailed(table_name) => {
error!("Failed to create a new record for table: {}", table_name);
}
Self::AccountNotMutable(pubkey) => error!(
"This account was marked with `Mut<T>` but was not passed in as mutable: {}",
pubkey
),
Self::AccountNotSigner(pubkey) => error!(
"This account was marked with `Signer<T>` but was not passed in as signer: {}",
pubkey
),
Self::AccountExists(pubkey) => error!(
"This account was marked with `Create<T>` but it exists already: {}",
pubkey
),
}
}
}
impl From<NautilusError> for ProgramError {
fn from(e: NautilusError) -> Self {
e.print::<NautilusError>();
ProgramError::Custom(e.to_u32().unwrap())
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana
|
solana_public_repos/nautilus-project/nautilus/solana/src/lib.rs
|
//
//
// ----------------------------------------------------------------
// Nautilus
// ----------------------------------------------------------------
//
//
extern crate self as nautilus;
pub mod cpi;
pub mod error;
pub mod objects;
pub mod properties;
pub use mpl_token_metadata;
pub use solana_program;
pub use spl_associated_token_account;
pub use spl_token;
pub use spl_token_2022;
pub use splogger;
pub use borsh::{self, BorshDeserialize, BorshSerialize};
pub use nautilus_derive::{nautilus, State, Table};
pub use solana_program::{
account_info::{next_account_info, AccountInfo, IntoAccountInfo},
declare_id, entrypoint,
entrypoint::ProgramResult,
msg,
program::{invoke, invoke_signed},
program_error::ProgramError,
pubkey::Pubkey,
system_instruction, system_program, sysvar,
};
pub use objects::{
accounts::*,
records::{index::*, *},
tokens::{associated_token::*, metadata::*, mint::*, nft::*, token::*, *},
wallets::*,
};
pub use properties::{create::*, data::*, mutable::*, signer::*, *};
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/src
|
solana_public_repos/nautilus-project/nautilus/solana/src/cpi/token_metadata.rs
|
//! Cross-Program invocations to the Metaplex Token Metadata Program.
use solana_program::{
account_info::AccountInfo, entrypoint::ProgramResult, program::invoke, pubkey::Pubkey,
};
use crate::{Create, Metadata, NautilusAccountInfo, NautilusMut, NautilusSigner};
/// Creates a Metadata account with the Token Metadata Program.
#[allow(clippy::boxed_local)]
#[allow(clippy::too_many_arguments)]
pub fn create_metadata_v3<'a>(
token_metadata_program_id: &Pubkey,
metadata: Create<'a, Metadata<'a>>,
title: String,
symbol: String,
uri: String,
mint: impl NautilusAccountInfo<'a>,
mint_authority: impl NautilusSigner<'a>,
update_authority: impl NautilusAccountInfo<'a>,
payer: impl NautilusSigner<'a>,
rent: Box<AccountInfo<'a>>,
) -> ProgramResult {
invoke(
&mpl_token_metadata::instruction::create_metadata_accounts_v3(
*token_metadata_program_id,
*metadata.key(),
*mint.key(),
*mint_authority.key(),
*payer.key(),
*update_authority.key(),
title,
symbol,
uri,
None,
0,
true,
false,
None,
None,
None,
),
&[
*metadata.account_info(),
*mint.account_info(),
*mint_authority.account_info(),
*payer.account_info(),
*rent,
],
)
}
/// Creates a MasterEdition account with the Token Metadata Program.
#[allow(clippy::boxed_local)]
#[allow(clippy::too_many_arguments)]
pub fn create_master_edition_v3<'a>(
token_metadata_program_id: &Pubkey,
edition: impl NautilusMut<'a>,
mint: impl NautilusAccountInfo<'a>,
metadata: impl NautilusAccountInfo<'a>,
update_authority: impl NautilusSigner<'a>,
mint_authority: impl NautilusSigner<'a>,
payer: impl NautilusSigner<'a>,
rent: Box<AccountInfo<'a>>,
max_supply: Option<u64>,
) -> ProgramResult {
invoke(
&mpl_token_metadata::instruction::create_master_edition_v3(
*token_metadata_program_id,
*edition.key(),
*mint.key(),
*update_authority.key(),
*mint_authority.key(),
*metadata.key(),
*payer.key(),
max_supply,
),
&[
*edition.account_info(),
*metadata.account_info(),
*mint.account_info(),
*mint_authority.account_info(),
*payer.account_info(),
*rent,
],
)
}
/// Mints a new Edition from a MasterEdition.
#[allow(clippy::boxed_local)]
#[allow(clippy::too_many_arguments)]
pub fn mint_edition_from_master_edition<'a>(
token_metadata_program_id: &Pubkey,
mint: impl NautilusMut<'a>,
metadata: impl NautilusAccountInfo<'a>,
edition: impl NautilusMut<'a>,
master_edition: impl NautilusAccountInfo<'a>,
master_edition_mint: impl NautilusAccountInfo<'a>,
master_edition_metadata: impl NautilusAccountInfo<'a>,
to: impl NautilusMut<'a>,
to_authority: impl NautilusSigner<'a>,
mint_authority: impl NautilusSigner<'a>,
update_authority: impl NautilusSigner<'a>,
payer: impl NautilusSigner<'a>,
rent: Box<AccountInfo<'a>>,
edition_val: u64,
) -> ProgramResult {
invoke(
&mpl_token_metadata::instruction::mint_new_edition_from_master_edition_via_token(
*token_metadata_program_id,
*metadata.key(),
*edition.key(),
*master_edition.key(),
*mint.key(),
*mint_authority.key(),
*payer.key(),
*to_authority.key(),
*to.key(),
*update_authority.key(),
*master_edition_metadata.key(),
*master_edition_mint.key(),
edition_val,
),
&[
*metadata.account_info(),
*edition.account_info(),
*master_edition.account_info(),
*mint.account_info(),
*mint_authority.account_info(),
*payer.account_info(),
*to_authority.account_info(),
*to.account_info(),
*update_authority.account_info(),
*master_edition_metadata.account_info(),
*master_edition_mint.account_info(),
*rent,
],
)
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/src
|
solana_public_repos/nautilus-project/nautilus/solana/src/cpi/token.rs
|
//! Cross-Program invocations to the Token Program (legacy).
use solana_program::{
account_info::AccountInfo, entrypoint::ProgramResult, program::invoke, pubkey::Pubkey,
};
use spl_token::instruction::AuthorityType;
use crate::{NautilusAccountInfo, NautilusMut, NautilusSigner};
/// Approves a delegate. A delegate is given the authority over tokens on
/// behalf of the source account's owner.
pub fn approve<'a>(
token_program_id: &Pubkey,
source_account: impl NautilusMut<'a>,
delegate: impl NautilusAccountInfo<'a>,
source_owner: impl NautilusSigner<'a>,
multisigs: Option<Vec<impl NautilusSigner<'a>>>,
amount: u64,
) -> ProgramResult {
let mut accounts = vec![
*source_account.account_info(),
*delegate.account_info(),
*source_owner.account_info(),
];
let signer_pubkeys = match multisigs {
Some(sigs) => append_multisig_accounts_and_return_keys(&mut accounts, sigs),
None => vec![],
};
invoke(
&spl_token::instruction::approve(
token_program_id,
source_account.key(),
delegate.key(),
source_owner.key(),
signer_pubkeys.as_slice(),
amount,
)?,
&accounts,
)
}
/// Approves a delegate. A delegate is given the authority over tokens on
/// behalf of the source account's owner.
///
/// This instruction differs from Approve in that the token mint and
/// decimals value is checked by the caller. This may be useful when
/// creating transactions offline or within a hardware wallet.
#[allow(clippy::too_many_arguments)]
pub fn approve_checked<'a>(
token_program_id: &Pubkey,
source_account: impl NautilusMut<'a>,
mint: impl NautilusAccountInfo<'a>,
delegate: impl NautilusAccountInfo<'a>,
source_owner: impl NautilusSigner<'a>,
multisigs: Option<Vec<impl NautilusSigner<'a>>>,
amount: u64,
decimals: u8,
) -> ProgramResult {
let mut accounts = vec![
*source_account.account_info(),
*delegate.account_info(),
*source_owner.account_info(),
];
let signer_pubkeys = match multisigs {
Some(sigs) => append_multisig_accounts_and_return_keys(&mut accounts, sigs),
None => vec![],
};
invoke(
&spl_token::instruction::approve_checked(
token_program_id,
source_account.key(),
mint.key(),
delegate.key(),
source_owner.key(),
signer_pubkeys.as_slice(),
amount,
decimals,
)?,
&accounts,
)
}
/// Burns tokens by removing them from an account.
pub fn burn<'a>(
token_program_id: &Pubkey,
token_account: impl NautilusMut<'a>,
mint: impl NautilusAccountInfo<'a>,
authority: impl NautilusSigner<'a>,
multisigs: Option<Vec<impl NautilusSigner<'a>>>,
amount: u64,
) -> ProgramResult {
let mut accounts = vec![
*token_account.account_info(),
*mint.account_info(),
*authority.account_info(),
];
let signer_pubkeys = match multisigs {
Some(sigs) => append_multisig_accounts_and_return_keys(&mut accounts, sigs),
None => vec![],
};
invoke(
&spl_token::instruction::burn(
token_program_id,
token_account.key(),
mint.key(),
authority.key(),
signer_pubkeys.as_slice(),
amount,
)?,
&accounts,
)
}
/// Burns tokens by removing them from an account. `BurnChecked` does not
/// support accounts associated with the native mint, use `CloseAccount`
/// instead.
///
/// This instruction differs from Burn in that the decimals value is checked
/// by the caller. This may be useful when creating transactions offline or
/// within a hardware wallet.
pub fn burn_checked<'a>(
token_program_id: &Pubkey,
token_account: impl NautilusMut<'a>,
mint: impl NautilusAccountInfo<'a>,
authority: impl NautilusSigner<'a>,
multisigs: Option<Vec<impl NautilusSigner<'a>>>,
amount: u64,
decimals: u8,
) -> ProgramResult {
let mut accounts = vec![
*token_account.account_info(),
*mint.account_info(),
*authority.account_info(),
];
let signer_pubkeys = match multisigs {
Some(sigs) => append_multisig_accounts_and_return_keys(&mut accounts, sigs),
None => vec![],
};
invoke(
&spl_token::instruction::burn_checked(
token_program_id,
token_account.key(),
mint.key(),
authority.key(),
signer_pubkeys.as_slice(),
amount,
decimals,
)?,
&accounts,
)
}
/// Close an account by transferring all its SOL to the destination account.
/// Non-native accounts may only be closed if its token amount is zero.
pub fn close_account<'a>(
token_program_id: &Pubkey,
token_account: impl NautilusMut<'a>,
destination: impl NautilusMut<'a>,
authority: impl NautilusSigner<'a>,
multisigs: Option<Vec<impl NautilusSigner<'a>>>,
) -> ProgramResult {
let mut accounts = vec![
*token_account.account_info(),
*destination.account_info(),
*authority.account_info(),
];
let signer_pubkeys = match multisigs {
Some(sigs) => append_multisig_accounts_and_return_keys(&mut accounts, sigs),
None => vec![],
};
invoke(
&spl_token::instruction::close_account(
token_program_id,
token_account.key(),
destination.key(),
authority.key(),
signer_pubkeys.as_slice(),
)?,
&accounts,
)
}
/// Freeze an Initialized account using the Mint's freeze_authority (if
/// set).
pub fn freeze_account<'a>(
token_program_id: &Pubkey,
token_account: impl NautilusMut<'a>,
mint: impl NautilusAccountInfo<'a>,
freeze_authority: impl NautilusSigner<'a>,
multisigs: Option<Vec<impl NautilusSigner<'a>>>,
) -> ProgramResult {
let mut accounts = vec![
*token_account.account_info(),
*mint.account_info(),
*freeze_authority.account_info(),
];
let signer_pubkeys = match multisigs {
Some(sigs) => append_multisig_accounts_and_return_keys(&mut accounts, sigs),
None => vec![],
};
invoke(
&spl_token::instruction::freeze_account(
token_program_id,
token_account.key(),
mint.key(),
freeze_authority.key(),
signer_pubkeys.as_slice(),
)?,
&accounts,
)
}
/// Initializes a new account to hold tokens. If this account is associated
/// with the native mint then the token balance of the initialized account
/// will be equal to the amount of SOL in the account. If this account is
/// associated with another mint, that mint must be initialized before this
/// command can succeed.
#[allow(clippy::boxed_local)]
pub fn initialize_account<'a>(
token_program_id: &Pubkey,
new_token_account: impl NautilusMut<'a>,
mint: impl NautilusAccountInfo<'a>,
authority: impl NautilusAccountInfo<'a>,
rent: Box<AccountInfo<'a>>,
) -> ProgramResult {
invoke(
&spl_token::instruction::initialize_account(
token_program_id,
new_token_account.key(),
mint.key(),
authority.key(),
)?,
&[
*new_token_account.account_info(),
*mint.account_info(),
*authority.account_info(),
*rent,
],
)
}
/// Like InitializeAccount, but the owner pubkey is passed via instruction data
/// rather than the accounts list. This variant may be preferable when using
/// Cross Program Invocation from an instruction that does not need the owner's
/// `AccountInfo` otherwise.
#[allow(clippy::boxed_local)]
pub fn initialize_account2<'a>(
token_program_id: &Pubkey,
new_token_account: impl NautilusMut<'a>,
mint: impl NautilusAccountInfo<'a>,
authority: &Pubkey,
rent: Box<AccountInfo<'a>>,
) -> ProgramResult {
invoke(
&spl_token::instruction::initialize_account2(
token_program_id,
new_token_account.key(),
mint.key(),
authority,
)?,
&[
*new_token_account.account_info(),
*mint.account_info(),
*rent,
],
)
}
/// Like InitializeAccount2, but does not require the Rent sysvar to be provided
pub fn initialize_account3<'a>(
token_program_id: &Pubkey,
new_token_account: impl NautilusMut<'a>,
mint: impl NautilusAccountInfo<'a>,
authority: &Pubkey,
) -> ProgramResult {
invoke(
&spl_token::instruction::initialize_account3(
token_program_id,
new_token_account.key(),
mint.key(),
authority,
)?,
&[*new_token_account.account_info(), *mint.account_info()],
)
}
/// Initialize the Immutable Owner extension for the given token account
///
/// Fails if the account has already been initialized, so must be called before
/// `InitializeAccount`.
pub fn initialize_immutable_owner<'a>(
token_program_id: &Pubkey,
new_token_account: impl NautilusMut<'a>,
) -> ProgramResult {
invoke(
&spl_token::instruction::initialize_immutable_owner(
token_program_id,
new_token_account.key(),
)?,
&[*new_token_account.account_info()],
)
}
/// Initializes a new mint and optionally deposits all the newly minted
/// tokens in an account.
#[allow(clippy::boxed_local)]
pub fn initialize_mint<'a>(
token_program_id: &Pubkey,
mint: impl NautilusMut<'a>,
mint_authority: &Pubkey,
freeze_authority: Option<&Pubkey>,
decimals: u8,
rent: Box<AccountInfo<'a>>,
) -> ProgramResult {
invoke(
&spl_token::instruction::initialize_mint(
token_program_id,
mint.key(),
mint_authority,
freeze_authority,
decimals,
)?,
&[*mint.account_info(), *rent],
)
}
/// Like InitializeMint, but does not require the Rent sysvar to be provided
pub fn initialize_mint2<'a>(
token_program_id: &Pubkey,
mint: impl NautilusMut<'a>,
mint_authority: &Pubkey,
freeze_authority: Option<&Pubkey>,
decimals: u8,
) -> ProgramResult {
invoke(
&spl_token::instruction::initialize_mint2(
token_program_id,
mint.key(),
mint_authority,
freeze_authority,
decimals,
)?,
&[*mint.account_info()],
)
}
/// Initializes a multisignature account with N provided signers.
///
/// Multisignature accounts can used in place of any single owner/delegate
/// accounts in any token instruction that require an owner/delegate to be
/// present. The variant field represents the number of signers (M)
/// required to validate this multisignature account.
#[allow(clippy::boxed_local)]
pub fn initialize_multisig<'a>(
token_program_id: &Pubkey,
multisig_account: impl NautilusMut<'a>,
multisigs: Vec<impl NautilusAccountInfo<'a>>,
m: u8,
rent: Box<AccountInfo<'a>>,
) -> ProgramResult {
let mut accounts = vec![*multisig_account.account_info(), *rent];
let signer_pubkeys = append_multisig_accounts_and_return_keys(&mut accounts, multisigs);
invoke(
&spl_token::instruction::initialize_multisig(
token_program_id,
multisig_account.key(),
signer_pubkeys.as_slice(),
m,
)?,
&accounts,
)
}
/// Initializes a multisignature account with N provided signers.
///
/// Multisignature accounts can used in place of any single owner/delegate
/// accounts in any token instruction that require an owner/delegate to be
/// present. The variant field represents the number of signers (M)
/// required to validate this multisignature account.
pub fn initialize_multisig2<'a>(
token_program_id: &Pubkey,
multisig_account: impl NautilusMut<'a>,
multisigs: Vec<impl NautilusAccountInfo<'a>>,
m: u8,
) -> ProgramResult {
let mut accounts = vec![*multisig_account.account_info()];
let signer_pubkeys = append_multisig_accounts_and_return_keys(&mut accounts, multisigs);
invoke(
&spl_token::instruction::initialize_multisig2(
token_program_id,
multisig_account.key(),
signer_pubkeys.as_slice(),
m,
)?,
&accounts,
)
}
/// Mints new tokens to an account. The native mint does not support
/// minting.
pub fn mint_to<'a>(
token_program_id: &Pubkey,
mint: impl NautilusMut<'a>,
recipient: impl NautilusMut<'a>,
mint_authority: impl NautilusSigner<'a>,
multisigs: Option<Vec<impl NautilusSigner<'a>>>,
amount: u64,
) -> ProgramResult {
let mut accounts = vec![
*mint.account_info(),
*recipient.account_info(),
*mint_authority.account_info(),
];
let signer_pubkeys = match multisigs {
Some(sigs) => append_multisig_accounts_and_return_keys(&mut accounts, sigs),
None => vec![],
};
invoke(
&spl_token::instruction::mint_to(
token_program_id,
mint.key(),
recipient.key(),
mint_authority.key(),
signer_pubkeys.as_slice(),
amount,
)?,
&accounts,
)
}
/// Mints new tokens to an account. The native mint does not support
/// minting.
///
/// This instruction differs from MintTo in that the decimals value is
/// checked by the caller. This may be useful when creating transactions
/// offline or within a hardware wallet.
pub fn mint_to_checked<'a>(
token_program_id: &Pubkey,
mint: impl NautilusMut<'a>,
recipient: impl NautilusMut<'a>,
mint_authority: impl NautilusSigner<'a>,
multisigs: Option<Vec<impl NautilusSigner<'a>>>,
amount: u64,
decimals: u8,
) -> ProgramResult {
let mut accounts = vec![
*mint.account_info(),
*recipient.account_info(),
*mint_authority.account_info(),
];
let signer_pubkeys = match multisigs {
Some(sigs) => append_multisig_accounts_and_return_keys(&mut accounts, sigs),
None => vec![],
};
invoke(
&spl_token::instruction::mint_to_checked(
token_program_id,
mint.key(),
recipient.key(),
mint_authority.key(),
signer_pubkeys.as_slice(),
amount,
decimals,
)?,
&accounts,
)
}
/// Revokes the delegate's authority.
pub fn revoke<'a>(
token_program_id: &Pubkey,
source_account: impl NautilusMut<'a>,
source_owner: impl NautilusSigner<'a>,
multisigs: Option<Vec<impl NautilusSigner<'a>>>,
) -> ProgramResult {
let mut accounts = vec![*source_account.account_info(), *source_owner.account_info()];
let signer_pubkeys = match multisigs {
Some(sigs) => append_multisig_accounts_and_return_keys(&mut accounts, sigs),
None => vec![],
};
invoke(
&spl_token::instruction::revoke(
token_program_id,
source_account.key(),
source_owner.key(),
signer_pubkeys.as_slice(),
)?,
&accounts,
)
}
/// Sets a new authority of a mint or account.
pub fn set_authority<'a>(
token_program_id: &Pubkey,
mint_or_account: impl NautilusMut<'a>,
new_authority: Option<&Pubkey>,
authority_type: AuthorityType,
current_authority: impl NautilusSigner<'a>,
multisigs: Option<Vec<impl NautilusSigner<'a>>>,
) -> ProgramResult {
let mut accounts = vec![
*mint_or_account.account_info(),
*current_authority.account_info(),
];
let signer_pubkeys = match multisigs {
Some(sigs) => append_multisig_accounts_and_return_keys(&mut accounts, sigs),
None => vec![],
};
invoke(
&spl_token::instruction::set_authority(
token_program_id,
mint_or_account.key(),
new_authority,
authority_type,
current_authority.key(),
signer_pubkeys.as_slice(),
)?,
&accounts,
)
}
/// Given a wrapped / native token account (a token account containing SOL)
/// updates its amount field based on the account's underlying `lamports`.
/// This is useful if a non-wrapped SOL account uses
/// `system_instruction::transfer` to move lamports to a wrapped token account,
/// and needs to have its token `amount` field updated.
pub fn sync_native<'a>(
token_program_id: &Pubkey,
token_account: impl NautilusMut<'a>,
) -> ProgramResult {
invoke(
&spl_token::instruction::sync_native(token_program_id, token_account.key())?,
&[*token_account.account_info()],
)
}
/// Thaw a Frozen account using the Mint's freeze_authority (if set).
pub fn thaw_account<'a>(
token_program_id: &Pubkey,
token_account: impl NautilusMut<'a>,
mint: impl NautilusAccountInfo<'a>,
freeze_authority: impl NautilusSigner<'a>,
multisigs: Option<Vec<impl NautilusSigner<'a>>>,
) -> ProgramResult {
let mut accounts = vec![
*token_account.account_info(),
*mint.account_info(),
*freeze_authority.account_info(),
];
let signer_pubkeys = match multisigs {
Some(sigs) => append_multisig_accounts_and_return_keys(&mut accounts, sigs),
None => vec![],
};
invoke(
&spl_token::instruction::thaw_account(
token_program_id,
token_account.key(),
mint.key(),
freeze_authority.key(),
signer_pubkeys.as_slice(),
)?,
&accounts,
)
}
/// Mints new tokens to an account. The native mint does not support
/// minting.
pub fn transfer<'a>(
token_program_id: &Pubkey,
from: impl NautilusMut<'a>,
to: impl NautilusMut<'a>,
authority: impl NautilusSigner<'a>,
multisigs: Option<Vec<impl NautilusSigner<'a>>>,
amount: u64,
) -> ProgramResult {
let mut accounts = vec![
*from.account_info(),
*to.account_info(),
*authority.account_info(),
];
let signer_pubkeys = match multisigs {
Some(sigs) => append_multisig_accounts_and_return_keys(&mut accounts, sigs),
None => vec![],
};
invoke(
&spl_token::instruction::transfer(
token_program_id,
from.key(),
to.key(),
authority.key(),
signer_pubkeys.as_slice(),
amount,
)?,
&accounts,
)
}
/// Transfers tokens from one account to another either directly or via a
/// delegate. If this account is associated with the native mint then equal
/// amounts of SOL and Tokens will be transferred to the destination
/// account.
///
/// This instruction differs from Transfer in that the token mint and
/// decimals value is checked by the caller. This may be useful when
/// creating transactions offline or within a hardware wallet.
#[allow(clippy::too_many_arguments)]
pub fn transfer_checked<'a>(
token_program_id: &Pubkey,
mint: impl NautilusAccountInfo<'a>,
from: impl NautilusMut<'a>,
to: impl NautilusMut<'a>,
authority: impl NautilusSigner<'a>,
multisigs: Option<Vec<impl NautilusSigner<'a>>>,
amount: u64,
decimals: u8,
) -> ProgramResult {
let mut accounts = vec![
*mint.account_info(),
*from.account_info(),
*to.account_info(),
*authority.account_info(),
];
let signer_pubkeys = match multisigs {
Some(sigs) => append_multisig_accounts_and_return_keys(&mut accounts, sigs),
None => vec![],
};
invoke(
&spl_token::instruction::transfer_checked(
token_program_id,
from.key(),
mint.key(),
to.key(),
authority.key(),
signer_pubkeys.as_slice(),
amount,
decimals,
)?,
&accounts,
)
}
/// Helper function to build lists of pubkeys and accounts from multisig option.
fn append_multisig_accounts_and_return_keys<'a>(
accounts: &mut Vec<AccountInfo<'a>>,
multisigs: Vec<impl NautilusAccountInfo<'a>>,
) -> Vec<&'a Pubkey> {
multisigs
.iter()
.map(|m| {
accounts.push(*m.account_info());
m.key()
})
.collect()
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/src
|
solana_public_repos/nautilus-project/nautilus/solana/src/cpi/system.rs
|
//! Cross-Program invocations to the System Program
use borsh::BorshSerialize;
use solana_program::{
entrypoint::ProgramResult,
program::{invoke, invoke_signed},
pubkey::Pubkey,
system_instruction,
};
use crate::{NautilusAccountInfo, NautilusMut, NautilusSigner};
/// Allocate space for an account.
pub fn allocate<'a>(new_account: impl NautilusSigner<'a>) -> ProgramResult {
invoke(
&system_instruction::allocate(new_account.key(), new_account.size()?),
&[*new_account.account_info()],
)
}
/// Assign ownership of an account from the system program.
pub fn assign<'a>(new_account: impl NautilusSigner<'a>, owner: &Pubkey) -> ProgramResult {
invoke(
&system_instruction::assign(new_account.key(), owner),
&[*new_account.account_info()],
)
}
/// Create an account.
pub fn create_account<'a>(
new_account: impl NautilusSigner<'a>,
owner: &Pubkey,
payer: impl NautilusSigner<'a>,
) -> ProgramResult {
invoke(
&system_instruction::create_account(
payer.key(),
new_account.key(),
new_account.required_rent()?,
new_account.size()?,
owner,
),
&[*payer.account_info(), *new_account.account_info()],
)
}
/// Cross-Program Invocation (CPI) to create a program-derived address account
/// (PDA).
#[allow(clippy::boxed_local)]
pub fn create_pda<'a, T: BorshSerialize>(
new_account: impl NautilusAccountInfo<'a>,
owner: &Pubkey,
payer: impl NautilusSigner<'a>,
data: Box<T>,
signer_seeds: Vec<&[u8]>,
) -> ProgramResult {
invoke_signed(
&system_instruction::create_account(
payer.key(),
new_account.key(),
new_account.required_rent()?,
new_account.size()?,
owner,
),
&[*payer.account_info(), *new_account.account_info()],
&[&signer_seeds],
)?;
data.serialize(&mut &mut new_account.account_info().data.borrow_mut()[..])?;
Ok(())
}
/// Transfer lamports from an account owned by the system program.
pub fn transfer<'a>(
from: impl NautilusSigner<'a>,
to: impl NautilusMut<'a>,
amount: u64,
) -> ProgramResult {
invoke(
&solana_program::system_instruction::transfer(from.key(), to.key(), amount),
&[*from.account_info(), *to.account_info()],
)
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/src
|
solana_public_repos/nautilus-project/nautilus/solana/src/cpi/associated_token.rs
|
//! Cross-Program invocations to the Associated Token Program
use solana_program::{account_info::AccountInfo, entrypoint::ProgramResult, program::invoke};
use crate::{AssociatedTokenAccount, NautilusAccountInfo, NautilusSigner};
/// Creates an associated token account.
#[allow(clippy::boxed_local)]
pub fn create_associated_token_account<'a>(
new_account: AssociatedTokenAccount<'a>,
owner: impl NautilusAccountInfo<'a>,
mint: impl NautilusAccountInfo<'a>,
payer: impl NautilusSigner<'a>,
system_program: Box<AccountInfo<'a>>,
token_program: Box<AccountInfo<'a>>,
associated_token_program: Box<AccountInfo<'a>>,
) -> ProgramResult {
invoke(
&spl_associated_token_account::instruction::create_associated_token_account(
payer.key(),
owner.key(),
mint.key(),
token_program.key,
),
&[
*mint.account_info(),
*new_account.account_info(),
*owner.account_info(),
*payer.account_info(),
*system_program,
*token_program,
*associated_token_program,
],
)
}
/// Recover nested associated token account.
#[allow(clippy::boxed_local)]
pub fn recover_nested<'a>(
wallet: impl NautilusAccountInfo<'a>,
owner_mint: impl NautilusAccountInfo<'a>,
nested_mint: impl NautilusAccountInfo<'a>,
token_program: Box<AccountInfo<'a>>,
associated_token_program: Box<AccountInfo<'a>>,
) -> ProgramResult {
invoke(
&spl_associated_token_account::instruction::recover_nested(
wallet.key(),
owner_mint.key(),
nested_mint.key(),
token_program.key,
),
&[
*wallet.account_info(),
*nested_mint.account_info(),
*owner_mint.account_info(),
*token_program,
*associated_token_program,
],
)
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/src
|
solana_public_repos/nautilus-project/nautilus/solana/src/cpi/mod.rs
|
//! Submodule for cross-program invocations (CPI) to other Solana programs.
pub mod associated_token;
pub mod system;
pub mod token;
pub mod token_metadata;
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/src
|
solana_public_repos/nautilus-project/nautilus/solana/src/objects/mod.rs
|
//! Submodule containing all Nautilus objects and their associated trait
//! implementations.
pub mod accounts;
pub mod records;
pub mod tokens;
pub mod wallets;
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/src/objects
|
solana_public_repos/nautilus-project/nautilus/solana/src/objects/records/index.rs
|
//! The special `NautilusIndex` Nautilus object and all associated trait
//! implementations.
use borsh::{BorshDeserialize, BorshSerialize};
use solana_program::{
account_info::AccountInfo, entrypoint::ProgramResult, program_error::ProgramError,
pubkey::Pubkey,
};
use crate::{
cpi, error::NautilusError, Create, Mut, NautilusAccountInfo, NautilusMut, NautilusRecord,
NautilusRecordData, NautilusSigner, NautilusTransferLamports, Signer, Wallet,
};
/// The account inner data for the `NautilusIndex`.
///
/// This `index` is simply a Hash Map that stores the current record count for
/// each table, where the `String` key is the table name and the `u32` value is
/// the current count.
///
/// This data is kept in one single account and used as a reference to enable
/// autoincrementing of records.
#[derive(Clone, Default)]
pub struct NautilusIndexData {
pub index: std::collections::HashMap<String, u32>,
}
impl NautilusIndexData {
/// Get the current record count for a table.
pub fn get_count(&self, table_name: &str) -> Option<u32> {
self.index.get(&(table_name.to_string())).copied()
}
/// Get the next record count for a table.
pub fn get_next_count(&self, table_name: &str) -> u32 {
match self.index.get(&(table_name.to_string())) {
Some(count) => count + 1,
None => 1,
}
}
/// Add a new record to the index.
pub fn add_record(&mut self, table_name: &str) -> u32 {
match self.index.get_mut(&(table_name.to_string())) {
Some(count) => {
*count += 1;
*count
}
None => {
self.index.insert(table_name.to_string(), 1);
1
}
}
}
}
impl borsh::de::BorshDeserialize for NautilusIndexData
where
std::collections::HashMap<String, u32>: borsh::BorshDeserialize,
{
fn deserialize(buf: &mut &[u8]) -> ::core::result::Result<Self, borsh::maybestd::io::Error> {
let _discrim: [u8; 8] = borsh::BorshDeserialize::deserialize(buf)?; // Skip the first 8 bytes for discriminator
Ok(Self {
index: borsh::BorshDeserialize::deserialize(buf)?,
})
}
}
impl borsh::ser::BorshSerialize for NautilusIndexData
where
std::collections::HashMap<String, u32>: borsh::BorshSerialize,
{
fn serialize<W: borsh::maybestd::io::Write>(
&self,
writer: &mut W,
) -> ::core::result::Result<(), borsh::maybestd::io::Error> {
borsh::BorshSerialize::serialize(&self.discriminator(), writer)?; // Serialize the discriminator first
borsh::BorshSerialize::serialize(&self.index, writer)?;
Ok(())
}
}
impl NautilusRecordData for NautilusIndexData {
const TABLE_NAME: &'static str = "nautilus_index";
const AUTO_INCREMENT: bool = false;
fn primary_key(&self) -> Vec<u8> {
vec![0]
}
fn check_authorities(&self, _accounts: Vec<AccountInfo>) -> Result<(), ProgramError> {
Ok(())
}
fn count_authorities(&self) -> u8 {
0
}
}
/// The special Nautilus object representing the accompanying index for a
/// Nautilus program.
///
/// The underlying account - designated in field `account_info` - is the
/// Nautilus Index.
///
/// This single account is used as a reference to enable autoincrementing of
/// records.
#[derive(Clone)]
pub struct NautilusIndex<'a> {
pub program_id: &'a Pubkey,
pub account_info: Box<AccountInfo<'a>>,
pub data: NautilusIndexData,
}
impl<'a> NautilusIndex<'a> {
/// Instantiate a new `NautilusIndex` without loading the account inner data
/// from on-chain.
pub fn new(program_id: &'a Pubkey, account_info: Box<AccountInfo<'a>>) -> Self {
Self {
program_id,
account_info,
data: NautilusIndexData::default(),
}
}
/// Instantiate a new `NautilusIndex` and load the account inner data from
/// on-chain.
pub fn load(
program_id: &'a Pubkey,
account_info: Box<AccountInfo<'a>>,
) -> Result<Self, ProgramError> {
let data = match NautilusIndexData::try_from_slice(match &account_info.try_borrow_data() {
Ok(acct_data) => acct_data,
Err(_) => {
return Err(NautilusError::LoadDataFailed(
NautilusIndexData::TABLE_NAME.to_string(),
account_info.key.to_string(),
)
.into())
}
}) {
Ok(state_data) => state_data,
Err(_) => {
return Err(NautilusError::DeserializeDataFailed(
NautilusIndexData::TABLE_NAME.to_string(),
account_info.key.to_string(),
)
.into());
}
};
Ok(Self {
program_id,
account_info,
data,
})
}
pub fn get_count(&self, table_name: &str) -> Option<u32> {
self.data.get_count(table_name)
}
pub fn get_next_count(&self, table_name: &str) -> u32 {
self.data.get_next_count(table_name)
}
pub fn add_record(
&mut self,
table_name: &str,
fee_payer: impl NautilusSigner<'a>,
) -> Result<u32, ProgramError> {
let count = self.data.add_record(table_name);
cpi::system::transfer(
fee_payer,
Mut::<Self>::new(self.clone())?,
self.required_rent()? - self.lamports(),
)?;
self.account_info.realloc(self.span()?, true)?;
self.data
.serialize(&mut &mut self.account_info.data.borrow_mut()[..])?;
Ok(count)
}
}
impl<'a> NautilusAccountInfo<'a> for NautilusIndex<'a> {
fn account_info(&self) -> Box<AccountInfo<'a>> {
self.account_info.clone()
}
fn key(&self) -> &'a Pubkey {
self.account_info.key
}
fn is_signer(&self) -> bool {
self.account_info.is_signer
}
fn is_writable(&self) -> bool {
self.account_info.is_writable
}
fn lamports(&self) -> u64 {
self.account_info.lamports()
}
fn mut_lamports(&self) -> Result<std::cell::RefMut<'_, &'a mut u64>, ProgramError> {
self.account_info.try_borrow_mut_lamports()
}
fn owner(&self) -> &'a Pubkey {
self.account_info.owner
}
fn span(&self) -> Result<usize, ProgramError> {
Ok(self.data.try_to_vec()?.len())
}
}
impl<'a> NautilusRecord<'a> for NautilusIndex<'a> {
fn discriminator(&self) -> [u8; 8] {
self.data.discriminator()
}
fn seeds(&self) -> Vec<Vec<u8>> {
self.data.seeds()
}
fn pda(&self) -> (Pubkey, u8) {
self.data.pda(self.program_id)
}
fn primary_key(&self) -> Vec<u8> {
self.data.primary_key()
}
fn check_authorities(&self, accounts: Vec<AccountInfo>) -> Result<(), ProgramError> {
self.data.check_authorities(accounts)
}
fn count_authorities(&self) -> u8 {
self.data.count_authorities()
}
}
impl<'a> NautilusTransferLamports<'a> for NautilusIndex<'a> {
fn transfer_lamports(&self, to: impl NautilusMut<'a>, amount: u64) -> ProgramResult {
let from = self.account_info();
**from.try_borrow_mut_lamports()? -= amount;
**to.mut_lamports()? += amount;
Ok(())
}
}
impl<'a> Create<'a, NautilusIndex<'a>> {
/// Allocate space for the Nautilus Index account using the System Program.
pub fn allocate(&self) -> ProgramResult {
cpi::system::allocate(self.clone())
}
/// Create a new Nautilus Index account. This should only be run once in
/// your program's lifetime.
pub fn create(&mut self) -> ProgramResult {
let payer = Signer::new(Wallet {
account_info: self.fee_payer.clone(),
system_program: self.system_program.clone(),
})?;
let data = NautilusIndexData {
index: std::collections::HashMap::new(),
};
let data_pointer = Box::new(data);
let (pda, bump) = self.pda();
assert_eq!(
&pda,
self.key(),
"Derived PDA does not match data for account {:#?}",
self.key()
);
let mut signer_seeds_vec = self.seeds();
signer_seeds_vec.push(vec![bump]);
let signer_seeds: Vec<&[u8]> = signer_seeds_vec.iter().map(AsRef::as_ref).collect();
cpi::system::create_pda(
self.self_account.clone(),
self.self_account.program_id,
payer,
data_pointer.clone(),
signer_seeds,
)?;
self.self_account.data = *data_pointer;
Ok(())
}
/// This function is the same as `create(&mut self, ..)` but allows you to
/// specify a rent payer.
pub fn create_with_payer(&mut self, payer: impl NautilusSigner<'a>) -> ProgramResult {
let data = NautilusIndexData {
index: std::collections::HashMap::new(),
};
let data_pointer = Box::new(data);
let (pda, bump) = self.pda();
assert_eq!(
&pda,
self.key(),
"Derived PDA does not match data for account {:#?}",
self.key()
);
let mut signer_seeds_vec = self.seeds();
signer_seeds_vec.push(vec![bump]);
let signer_seeds: Vec<&[u8]> = signer_seeds_vec.iter().map(AsRef::as_ref).collect();
cpi::system::create_pda(
self.self_account.clone(),
self.self_account.program_id,
payer,
data_pointer.clone(),
signer_seeds,
)?;
self.self_account.data = *data_pointer;
Ok(())
}
}
impl<'a> NautilusRecord<'a> for Create<'a, NautilusIndex<'a>> {
fn discriminator(&self) -> [u8; 8] {
self.self_account.discriminator()
}
fn seeds(&self) -> Vec<Vec<u8>> {
self.self_account.seeds()
}
fn pda(&self) -> (Pubkey, u8) {
self.self_account.pda()
}
fn primary_key(&self) -> Vec<u8> {
self.self_account.primary_key()
}
fn check_authorities(&self, accounts: Vec<AccountInfo>) -> Result<(), ProgramError> {
self.self_account.check_authorities(accounts)
}
fn count_authorities(&self) -> u8 {
self.self_account.count_authorities()
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/src/objects
|
solana_public_repos/nautilus-project/nautilus/solana/src/objects/records/mod.rs
|
//! The `Record<T>` Nautilus object and all associated trait implementations.
use solana_program::{
account_info::AccountInfo, entrypoint::ProgramResult, program_error::ProgramError,
pubkey::Pubkey,
};
use crate::{
cpi, error::NautilusError, Create, Mut, NautilusAccountInfo, NautilusIndex, NautilusMut,
NautilusRecord, NautilusRecordData, NautilusSigner, NautilusTransferLamports, Signer, Wallet,
};
pub mod index;
/// The struct that allows you to treat a Program-Derived-Address (PDA) account
/// as a table record.
///
/// A user wraps their data type `T` with `Record<'_, T>` in order to combine
/// the data stored within the record and the accounts required to operate on
/// it.
///
/// The `account_info` field represents the PDA itself, while the `index` field
/// is one single account that accompanies a Nautilus program and keeps an index
/// of every table.
///
/// For more information on the `NautilusIndex<'_>` see the docs for that
/// struct.
#[derive(Clone)]
pub struct Record<'a, T>
where
T: NautilusRecordData,
{
pub program_id: &'a Pubkey,
pub account_info: Box<AccountInfo<'a>>,
pub index: NautilusIndex<'a>,
pub data: Box<T>,
}
impl<'a, T> Record<'a, T>
where
T: NautilusRecordData,
{
/// Instantiate a new record without loading the account inner data from
/// on-chain.
pub fn new(
program_id: &'a Pubkey,
account_info: Box<AccountInfo<'a>>,
index: NautilusIndex<'a>,
) -> Self {
Self {
program_id,
index,
account_info,
data: Box::<T>::default(),
}
}
/// Instantiate a new record and load the account inner data from on-chain.
pub fn load(
program_id: &'a Pubkey,
account_info: Box<AccountInfo<'a>>,
index: NautilusIndex<'a>,
) -> Result<Self, ProgramError> {
let data = match T::try_from_slice(match &account_info.try_borrow_data() {
Ok(acct_data) => acct_data,
Err(_) => {
return Err(NautilusError::LoadDataFailed(
T::TABLE_NAME.to_string(),
account_info.key.to_string(),
)
.into())
}
}) {
Ok(state_data) => Box::new(state_data),
Err(_) => {
return Err(NautilusError::DeserializeDataFailed(
T::TABLE_NAME.to_string(),
account_info.key.to_string(),
)
.into())
}
};
Ok(Self {
program_id,
index,
account_info,
data,
})
}
}
impl<'a, T> NautilusAccountInfo<'a> for Record<'a, T>
where
T: NautilusRecordData,
{
fn account_info(&self) -> Box<AccountInfo<'a>> {
self.account_info.clone()
}
fn key(&self) -> &'a Pubkey {
self.account_info.key
}
fn is_signer(&self) -> bool {
self.account_info.is_signer
}
fn is_writable(&self) -> bool {
self.account_info.is_writable
}
fn lamports(&self) -> u64 {
self.account_info.lamports()
}
fn mut_lamports(&self) -> Result<std::cell::RefMut<'_, &'a mut u64>, ProgramError> {
self.account_info.try_borrow_mut_lamports()
}
fn owner(&self) -> &'a Pubkey {
self.account_info.owner
}
fn span(&self) -> Result<usize, ProgramError> {
Ok(self.data.try_to_vec()?.len())
}
}
impl<'a, T> NautilusRecord<'a> for Record<'a, T>
where
T: NautilusRecordData,
{
fn discriminator(&self) -> [u8; 8] {
self.data.discriminator()
}
fn seeds(&self) -> Vec<Vec<u8>> {
self.data.seeds()
}
fn pda(&self) -> (Pubkey, u8) {
self.data.pda(self.program_id)
}
fn primary_key(&self) -> Vec<u8> {
self.data.primary_key()
}
fn check_authorities(&self, accounts: Vec<AccountInfo>) -> Result<(), ProgramError> {
self.data.check_authorities(accounts)
}
fn count_authorities(&self) -> u8 {
self.data.count_authorities()
}
}
impl<'a, T> NautilusTransferLamports<'a> for Mut<Record<'a, T>>
where
T: NautilusRecordData,
{
fn transfer_lamports(
&self,
to: impl NautilusMut<'a>,
amount: u64,
) -> solana_program::entrypoint::ProgramResult {
let from = self.account_info();
**from.try_borrow_mut_lamports()? -= amount;
**to.mut_lamports()? += amount;
Ok(())
}
}
impl<'a, T> Create<'a, Record<'a, T>>
where
T: NautilusRecordData,
{
/// Allocate space for a record using the System Program.
pub fn allocate(&self) -> ProgramResult {
cpi::system::allocate(self.clone())
}
/// Create a new record.
///
/// This function is specifically not named `create` because `create(&mut
/// self, ..)` is added by the derive macro
/// `#[derive(nautilus::Table)]`, which then drives this function.
pub fn create_record(&mut self) -> ProgramResult {
let payer = Signer::new(Wallet {
account_info: self.fee_payer.to_owned(),
system_program: self.system_program.to_owned(),
})?;
let (pda, bump) = self.pda();
assert_eq!(
&pda,
self.key(),
"Derived PDA does not match data for account {:#?}",
self.key()
);
let mut signer_seeds_vec = self.seeds();
signer_seeds_vec.push(vec![bump]);
let signer_seeds: Vec<&[u8]> = signer_seeds_vec.iter().map(AsRef::as_ref).collect();
cpi::system::create_pda(
self.self_account.clone(),
self.self_account.program_id,
payer,
self.self_account.data.clone(),
signer_seeds,
)
}
/// This function is the same as `create_record(&mut self, ..)` but allows
/// you to specify a rent payer.
pub fn create_record_with_payer(&mut self, payer: impl NautilusSigner<'a>) -> ProgramResult {
let (pda, bump) = self.pda();
assert_eq!(
&pda,
self.key(),
"Derived PDA does not match data for account {:#?}",
self.key()
);
let mut signer_seeds_vec = self.seeds();
signer_seeds_vec.push(vec![bump]);
let signer_seeds: Vec<&[u8]> = signer_seeds_vec.iter().map(AsRef::as_ref).collect();
cpi::system::create_pda(
self.self_account.clone(),
self.self_account.program_id,
payer,
self.self_account.data.clone(),
signer_seeds,
)
}
}
impl<'a, T> NautilusRecord<'a> for Create<'a, Record<'a, T>>
where
T: NautilusRecordData,
{
fn discriminator(&self) -> [u8; 8] {
self.self_account.discriminator()
}
fn seeds(&self) -> Vec<Vec<u8>> {
self.self_account.seeds()
}
fn pda(&self) -> (Pubkey, u8) {
self.self_account.pda()
}
fn primary_key(&self) -> Vec<u8> {
self.self_account.primary_key()
}
fn check_authorities(&self, accounts: Vec<AccountInfo>) -> Result<(), ProgramError> {
self.self_account.check_authorities(accounts)
}
fn count_authorities(&self) -> u8 {
self.self_account.count_authorities()
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/src/objects
|
solana_public_repos/nautilus-project/nautilus/solana/src/objects/accounts/mod.rs
|
//! The `Account<T>` Nautilus object and all associated trait implementations.
use solana_program::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey};
use crate::{
error::NautilusError, Mut, NautilusAccount, NautilusAccountData, NautilusAccountInfo,
NautilusMut, NautilusTransferLamports,
};
/// The struct that allows you to create a plain-old program-derived address
/// (PDA) account.
///
/// A user wraps their data type `T` with `Account<'_, T>` in order to combine
/// the data stored within the account and its underlying AccountInfo.
///
/// The `account_info` field represents the PDA itself.
#[derive(Clone)]
pub struct Account<'a, T>
where
T: NautilusAccountData,
{
pub program_id: &'a Pubkey,
pub account_info: Box<AccountInfo<'a>>,
pub data: Box<T>,
}
impl<'a, T> Account<'a, T>
where
T: NautilusAccountData,
{
/// Instantiate a new PDA without loading the account inner data from
/// on-chain.
pub fn new(program_id: &'a Pubkey, account_info: Box<AccountInfo<'a>>) -> Self {
Self {
program_id,
account_info,
data: Box::<T>::default(),
}
}
/// Instantiate a new PDA and load the account inner data from on-chain.
pub fn load(
program_id: &'a Pubkey,
account_info: Box<AccountInfo<'a>>,
) -> Result<Self, ProgramError> {
let data = match T::try_from_slice(match &account_info.try_borrow_data() {
Ok(acct_data) => acct_data,
Err(_) => {
return Err(NautilusError::LoadDataFailed(
T::DISCRIMINATOR_STR.to_string(),
account_info.key.to_string(),
)
.into())
}
}) {
Ok(state_data) => Box::new(state_data),
Err(_) => {
return Err(NautilusError::DeserializeDataFailed(
T::DISCRIMINATOR_STR.to_string(),
account_info.key.to_string(),
)
.into())
}
};
Ok(Self {
program_id,
account_info,
data,
})
}
}
impl<'a, T> NautilusAccountInfo<'a> for Account<'a, T>
where
T: NautilusAccountData,
{
fn account_info(&self) -> Box<AccountInfo<'a>> {
self.account_info.clone()
}
fn key(&self) -> &'a Pubkey {
self.account_info.key
}
fn is_signer(&self) -> bool {
self.account_info.is_signer
}
fn is_writable(&self) -> bool {
self.account_info.is_writable
}
fn lamports(&self) -> u64 {
self.account_info.lamports()
}
fn mut_lamports(&self) -> Result<std::cell::RefMut<'_, &'a mut u64>, ProgramError> {
self.account_info.try_borrow_mut_lamports()
}
fn owner(&self) -> &'a Pubkey {
self.account_info.owner
}
fn span(&self) -> Result<usize, ProgramError> {
Ok(self.data.try_to_vec()?.len())
}
}
impl<'a, T> NautilusAccount<'a> for Account<'a, T>
where
T: NautilusAccountData,
{
fn discriminator(&self) -> [u8; 8] {
self.data.discriminator()
}
fn check_authorities(&self, accounts: Vec<AccountInfo>) -> Result<(), ProgramError> {
self.data.check_authorities(accounts)
}
fn count_authorities(&self) -> u8 {
self.data.count_authorities()
}
}
impl<'a, T> NautilusTransferLamports<'a> for Mut<Account<'a, T>>
where
T: NautilusAccountData,
{
fn transfer_lamports(
&self,
to: impl NautilusMut<'a>,
amount: u64,
) -> solana_program::entrypoint::ProgramResult {
let from = self.account_info();
**from.try_borrow_mut_lamports()? -= amount;
**to.mut_lamports()? += amount;
Ok(())
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/src/objects
|
solana_public_repos/nautilus-project/nautilus/solana/src/objects/wallets/mod.rs
|
//! The `Wallet<T>` Nautilus object and all associated trait implementations.
use solana_program::{
account_info::AccountInfo, entrypoint::ProgramResult, program_error::ProgramError,
pubkey::Pubkey,
};
use crate::{
cpi, Create, NautilusAccountInfo, NautilusAssignable, NautilusMut, NautilusSigner,
NautilusTransferLamports, Signer,
};
/// The Nautilus object representing a Solana system account.
///
/// The underlying account - designated in field `account_info` - is the system
/// account this Wallet represents.
///
/// We also include the read-only System Program for any CPI operations
/// necessary, since we do not own this account.
#[derive(Clone)]
pub struct Wallet<'a> {
pub account_info: Box<AccountInfo<'a>>,
pub system_program: Box<AccountInfo<'a>>,
}
impl<'a> Wallet<'a> {
/// Instantiate a new `Wallet` without loading the account inner data from
/// on-chain.
///
/// This function actually does nothing with on-chain data anyway, since
/// system accounts have no inner data.
pub fn new(account_info: Box<AccountInfo<'a>>, system_program: Box<AccountInfo<'a>>) -> Self {
Self {
account_info,
system_program,
}
}
/// Instantiate a new `Wallet` and load the account inner data from
/// on-chain.
///
/// This function actually does nothing with on-chain data anyway, since
/// system accounts have no inner data.
pub fn load(
account_info: Box<AccountInfo<'a>>,
system_program: Box<AccountInfo<'a>>,
) -> Result<Self, ProgramError> {
Ok(Self {
account_info,
system_program,
})
}
}
impl<'a> NautilusAccountInfo<'a> for Wallet<'a> {
fn account_info(&self) -> Box<AccountInfo<'a>> {
self.account_info.clone()
}
fn key(&self) -> &'a Pubkey {
self.account_info.key
}
fn is_signer(&self) -> bool {
self.account_info.is_signer
}
fn is_writable(&self) -> bool {
self.account_info.is_writable
}
fn lamports(&self) -> u64 {
self.account_info.lamports()
}
fn mut_lamports(&self) -> Result<std::cell::RefMut<'_, &'a mut u64>, ProgramError> {
self.account_info.try_borrow_mut_lamports()
}
fn owner(&self) -> &'a Pubkey {
self.account_info.owner
}
fn span(&self) -> Result<usize, ProgramError> {
Ok(0)
}
}
impl<'a> NautilusAssignable<'a> for Signer<Wallet<'a>> {
fn assign(&self, owner: Pubkey) -> ProgramResult {
cpi::system::assign(self.clone(), &owner)
}
}
impl<'a> NautilusTransferLamports<'a> for Signer<Wallet<'a>> {
fn transfer_lamports(&self, to: impl NautilusMut<'a>, amount: u64) -> ProgramResult {
cpi::system::transfer(self.clone(), to, amount)
}
}
impl<'a> Create<'a, Wallet<'a>> {
/// Allocate space for a system account using the System Program.
pub fn allocate(&self) -> ProgramResult {
cpi::system::allocate(self.clone())
}
/// Create a new system account with the System Program.
pub fn create(&mut self) -> ProgramResult {
let payer = Signer::new(Wallet {
account_info: self.fee_payer.clone(),
system_program: self.system_program.clone(),
})?;
cpi::system::create_account(self.clone(), self.system_program.key, payer)
}
/// This function is the same as `create(&mut self, ..)` but allows you to
/// specify a rent payer.
pub fn create_with_payer(&mut self, payer: impl NautilusSigner<'a>) -> ProgramResult {
cpi::system::create_account(self.clone(), self.system_program.key, payer)
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/src/objects
|
solana_public_repos/nautilus-project/nautilus/solana/src/objects/tokens/nft.rs
|
//! The `Nft<T>` Nautilus object and all associated trait implementations.
use solana_program::{
account_info::AccountInfo, entrypoint::ProgramResult, program_error::ProgramError,
pubkey::Pubkey,
};
use spl_token::instruction::AuthorityType;
use crate::{
cpi, edition::MasterEdition, Create, Metadata, Mint, Mut, NautilusAccountInfo, NautilusMut,
NautilusSigner, Signer, Wallet,
};
/// The Nautilus object representing an NFT.
///
/// Like the `Token` object, this struct is a combination of a mint account and
/// a token metadata account.
///
/// This Nautilus object is designed for easily working with NFTs.
#[derive(Clone)]
pub struct Nft<'a> {
pub mint: Mint<'a>,
pub metadata: Metadata<'a>,
}
impl<'a> Nft<'a> {
/// Instantiate a new `Nft` without loading the account inner data from
/// on-chain.
pub fn new(
mint_account: Box<AccountInfo<'a>>,
metadata_account: Box<AccountInfo<'a>>,
token_program: Box<AccountInfo<'a>>,
token_metadata_program: Box<AccountInfo<'a>>,
) -> Self {
Self {
mint: Mint::new(mint_account, token_program),
metadata: Metadata::new(metadata_account, token_metadata_program),
}
}
/// Instantiate a new `Nft` and load the account inner data from on-chain.
pub fn load(
mint_account: Box<AccountInfo<'a>>,
metadata_account: Box<AccountInfo<'a>>,
token_program: Box<AccountInfo<'a>>,
token_metadata_program: Box<AccountInfo<'a>>,
) -> Result<Self, ProgramError> {
Ok(Self {
mint: Mint::load(mint_account, token_program)?,
metadata: Metadata::load(metadata_account, token_metadata_program)?,
})
}
}
impl<'a> NautilusAccountInfo<'a> for Nft<'a> {
fn account_info(&self) -> Box<AccountInfo<'a>> {
self.mint.account_info()
}
fn key(&self) -> &'a Pubkey {
self.mint.account_info.key
}
fn is_signer(&self) -> bool {
self.mint.account_info.is_signer
}
fn is_writable(&self) -> bool {
self.mint.account_info.is_writable
}
fn lamports(&self) -> u64 {
self.mint.account_info.lamports()
}
fn mut_lamports(&self) -> Result<std::cell::RefMut<'_, &'a mut u64>, ProgramError> {
self.mint.account_info.try_borrow_mut_lamports()
}
fn owner(&self) -> &'a Pubkey {
self.mint.account_info.owner
}
fn span(&self) -> Result<usize, ProgramError> {
self.mint.span()
}
}
impl<'a> Mut<Nft<'a>> {
/// Mint an NFT to an associated token account. This disables minting
/// automatically.
pub fn mint_to(
&self,
recipient: impl NautilusMut<'a>,
mint_authority: impl NautilusSigner<'a>,
) -> ProgramResult {
let multisigs: Option<Vec<Signer<Wallet>>> = None; // TODO: Multisig support
cpi::token::mint_to(
self.self_account.mint.token_program.key,
self.clone(),
recipient,
mint_authority.clone(),
multisigs.clone(),
1,
)?;
cpi::token::set_authority(
self.self_account.mint.token_program.key,
self.clone(),
None,
AuthorityType::MintTokens,
mint_authority,
multisigs,
)
}
/// Mint a new edition from a MasterEdition.
#[allow(clippy::too_many_arguments)]
pub fn mint_edition(
&self,
edition: impl NautilusMut<'a>,
master_edition: MasterEdition<'a>,
master_edition_mint: impl NautilusAccountInfo<'a>,
master_edition_metadata: impl NautilusAccountInfo<'a>,
to: impl NautilusMut<'a>,
to_authority: impl NautilusSigner<'a>,
mint_authority: impl NautilusSigner<'a>,
update_authority: impl NautilusSigner<'a>,
payer: impl NautilusSigner<'a>,
edition_val: u64,
) -> ProgramResult {
cpi::token_metadata::mint_edition_from_master_edition(
self.self_account.mint.token_program.key,
Mut::<Mint>::new(self.self_account.mint.clone())?,
self.self_account.metadata.clone(),
edition,
master_edition.clone(),
master_edition_mint,
master_edition_metadata,
to,
to_authority,
mint_authority,
update_authority,
payer,
master_edition.rent.clone(),
edition_val,
)
}
/// Mint a MasterEdition NFT.
pub fn mint_master_edition(
&self,
master_edition: Mut<MasterEdition<'a>>,
recipient: impl NautilusMut<'a>,
update_authority: impl NautilusSigner<'a>,
mint_authority: impl NautilusSigner<'a>,
payer: impl NautilusSigner<'a>,
) -> ProgramResult {
let multisigs: Option<Vec<Signer<Wallet>>> = None; // TODO: Multisig support
cpi::token::mint_to(
self.self_account.mint.token_program.key,
self.clone(),
recipient,
mint_authority.clone(),
multisigs.clone(),
1,
)?;
cpi::token_metadata::create_master_edition_v3(
self.self_account.mint.token_program.key,
master_edition.clone(),
self.self_account.mint.clone(),
self.self_account.metadata.clone(),
update_authority,
mint_authority,
payer,
master_edition.self_account.rent.clone(),
Some(1),
)
}
/// Change the mint's authority.
pub fn set_authority(
&self,
new_authority: Option<&Pubkey>,
authority_type: AuthorityType,
current_authority: impl NautilusSigner<'a>,
) -> ProgramResult {
let multisigs: Option<Vec<Signer<Wallet>>> = None; // TODO: Multisig support
cpi::token::set_authority(
self.self_account.mint.token_program.key,
self.clone(),
new_authority,
authority_type,
current_authority,
multisigs,
)
}
}
impl<'a> Create<'a, Nft<'a>> {
/// Create a new NFT with a Token Program and
/// a new SPL metadata account with the Token Metadata Program.
#[allow(clippy::too_many_arguments)]
pub fn create(
&mut self,
title: String,
symbol: String,
uri: String,
mint_authority: impl NautilusSigner<'a>,
update_authority: impl NautilusAccountInfo<'a>,
freeze_authority: Option<impl NautilusAccountInfo<'a>>,
) -> ProgramResult {
let mut create_mint: Create<Mint> = self.clone().into();
let mut create_metadata: Create<Metadata> = self.clone().into();
create_mint.create(0, mint_authority.clone(), freeze_authority)?;
create_metadata.create(
title,
symbol,
uri,
self.self_account.mint.to_owned(),
mint_authority,
update_authority,
)?;
Ok(())
}
/// This function is the same as `create(&mut self, ..)` but allows you to
/// specify a rent payer.
#[allow(clippy::too_many_arguments)]
pub fn create_with_payer(
&mut self,
title: String,
symbol: String,
uri: String,
mint_authority: impl NautilusSigner<'a>,
update_authority: impl NautilusAccountInfo<'a>,
freeze_authority: Option<impl NautilusAccountInfo<'a>>,
payer: impl NautilusSigner<'a>,
) -> ProgramResult {
let mut create_mint: Create<Mint> = self.clone().into();
let mut create_metadata: Create<Metadata> = self.clone().into();
create_mint.create_with_payer(
0,
mint_authority.clone(),
freeze_authority,
payer.clone(),
)?;
create_metadata.create_with_payer(
title,
symbol,
uri,
self.self_account.mint.to_owned(),
mint_authority,
update_authority,
payer,
)?;
Ok(())
}
}
// Converters
impl<'a> From<Nft<'a>> for Mint<'a> {
fn from(value: Nft<'a>) -> Self {
value.mint
}
}
impl<'a> From<Create<'a, Nft<'a>>> for Create<'a, Mint<'a>> {
fn from(value: Create<'a, Nft<'a>>) -> Self {
Self {
self_account: value.self_account.into(),
fee_payer: value.fee_payer,
rent: value.rent,
system_program: value.system_program,
}
}
}
impl<'a> From<Nft<'a>> for Metadata<'a> {
fn from(value: Nft<'a>) -> Self {
value.metadata
}
}
impl<'a> From<Create<'a, Nft<'a>>> for Create<'a, Metadata<'a>> {
fn from(value: Create<'a, Nft<'a>>) -> Self {
Self {
self_account: value.self_account.into(),
fee_payer: value.fee_payer,
rent: value.rent,
system_program: value.system_program,
}
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/src/objects
|
solana_public_repos/nautilus-project/nautilus/solana/src/objects/tokens/metadata.rs
|
//! The `Metadata<T>` Nautilus object and all associated trait implementations.
pub use mpl_token_metadata::state::{Metadata as MetadataState, TokenMetadataAccount};
use solana_program::{
account_info::AccountInfo, entrypoint::ProgramResult, program_error::ProgramError,
pubkey::Pubkey,
};
use crate::{
cpi, error::NautilusError, Create, Mint, NautilusAccountInfo, NautilusSigner, Signer, Wallet,
};
/// The Nautilus object representing a token metadata account.
///
/// The underlying account - designated in field `account_info` - is the token
/// metadata account.
///
/// We also include the read-only Token Metadata Program for any CPI operations
/// necessary, since we do not own this account.
#[derive(Clone)]
pub struct Metadata<'a> {
pub account_info: Box<AccountInfo<'a>>,
pub token_metadata_program: Box<AccountInfo<'a>>,
pub data: MetadataState,
}
impl<'a> Metadata<'a> {
/// Instantiate a new `Metadata` without loading the account inner data from
/// on-chain.
pub fn new(
account_info: Box<AccountInfo<'a>>,
token_metadata_program: Box<AccountInfo<'a>>,
) -> Self {
Self {
account_info,
token_metadata_program,
data: MetadataState::default(),
}
}
/// Instantiate a new `Metadata` and load the account inner data from
/// on-chain.
pub fn load(
account_info: Box<AccountInfo<'a>>,
token_metadata_program: Box<AccountInfo<'a>>,
) -> Result<Self, ProgramError> {
let data = match MetadataState::safe_deserialize(match &account_info.try_borrow_data() {
Ok(acct_data) => acct_data,
Err(_) => {
return Err(NautilusError::LoadDataFailed(
String::from("token_metadata"),
account_info.key.to_string(),
)
.into())
}
}) {
Ok(state_data) => state_data,
Err(_) => {
return Err(NautilusError::DeserializeDataFailed(
String::from("token_metadata"),
account_info.key.to_string(),
)
.into())
}
};
Ok(Self {
account_info,
token_metadata_program,
data,
})
}
}
impl<'a> NautilusAccountInfo<'a> for Metadata<'a> {
fn account_info(&self) -> Box<AccountInfo<'a>> {
self.account_info.clone()
}
fn key(&self) -> &'a Pubkey {
self.account_info.key
}
fn is_signer(&self) -> bool {
self.account_info.is_signer
}
fn is_writable(&self) -> bool {
self.account_info.is_writable
}
fn lamports(&self) -> u64 {
self.account_info.lamports()
}
fn mut_lamports(&self) -> Result<std::cell::RefMut<'_, &'a mut u64>, ProgramError> {
self.account_info.try_borrow_mut_lamports()
}
fn owner(&self) -> &'a Pubkey {
self.account_info.owner
}
fn span(&self) -> Result<usize, ProgramError> {
Ok(MetadataState::size())
}
}
impl<'a> Create<'a, Metadata<'a>> {
/// Create a new SPL metadata account with Token Metadata Program.
#[allow(clippy::too_many_arguments)]
pub fn create(
&mut self,
title: String,
symbol: String,
uri: String,
mint: Mint<'a>,
mint_authority: impl NautilusSigner<'a>,
update_authority: impl NautilusAccountInfo<'a>,
) -> ProgramResult {
let payer = Signer::new(Wallet {
account_info: self.fee_payer.to_owned(),
system_program: self.system_program.to_owned(),
})?;
cpi::token_metadata::create_metadata_v3(
self.self_account.token_metadata_program.key,
self.clone(),
title,
symbol,
uri,
mint,
mint_authority,
update_authority,
payer,
self.rent.to_owned(),
)?;
self.self_account = Metadata::load(
self.self_account.account_info.clone(),
self.self_account.token_metadata_program.clone(),
)?;
Ok(())
}
/// This function is the same as `create(&mut self, ..)` but allows you to
/// specify a rent payer.
#[allow(clippy::too_many_arguments)]
pub fn create_with_payer(
&mut self,
title: String,
symbol: String,
uri: String,
mint: super::mint::Mint<'a>,
mint_authority: impl NautilusSigner<'a>,
update_authority: impl NautilusAccountInfo<'a>,
payer: impl NautilusSigner<'a>,
) -> ProgramResult {
cpi::token_metadata::create_metadata_v3(
self.self_account.token_metadata_program.key,
self.clone(),
title,
symbol,
uri,
mint,
mint_authority,
update_authority,
payer,
self.rent.to_owned(),
)?;
self.self_account = Metadata::load(
self.self_account.account_info.clone(),
self.self_account.token_metadata_program.clone(),
)?;
Ok(())
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/src/objects
|
solana_public_repos/nautilus-project/nautilus/solana/src/objects/tokens/token.rs
|
//! The `Token<T>` Nautilus object and all associated trait implementations.
use solana_program::{
account_info::AccountInfo, entrypoint::ProgramResult, program_error::ProgramError,
pubkey::Pubkey,
};
use spl_token::instruction::AuthorityType;
use crate::{
cpi, Create, Metadata, Mint, Mut, NautilusAccountInfo, NautilusMut, NautilusSigner, Signer,
Wallet,
};
/// The Nautilus object representing the combination of a mint account and a
/// token metadata account.
///
/// This Nautilus object is designed for easily working with tokens and metadata
/// together.
///
/// It's comprised of both a `Mint` and `Metadata` struct, which allows you to
/// access either individually, and most of it's implemented methods access the
/// mint account.
#[derive(Clone)]
pub struct Token<'a> {
pub mint: Mint<'a>,
pub metadata: Metadata<'a>,
}
impl<'a> Token<'a> {
/// Instantiate a new `Token` without loading the account inner data from
/// on-chain.
pub fn new(
mint_account: Box<AccountInfo<'a>>,
metadata_account: Box<AccountInfo<'a>>,
token_program: Box<AccountInfo<'a>>,
token_metadata_program: Box<AccountInfo<'a>>,
) -> Self {
Self {
mint: Mint::new(mint_account, token_program),
metadata: Metadata::new(metadata_account, token_metadata_program),
}
}
/// Instantiate a new `Token` and load the account inner data from on-chain.
pub fn load(
mint_account: Box<AccountInfo<'a>>,
metadata_account: Box<AccountInfo<'a>>,
token_program: Box<AccountInfo<'a>>,
token_metadata_program: Box<AccountInfo<'a>>,
) -> Result<Self, ProgramError> {
Ok(Self {
mint: Mint::load(mint_account, token_program)?,
metadata: Metadata::load(metadata_account, token_metadata_program)?,
})
}
}
impl<'a> NautilusAccountInfo<'a> for Token<'a> {
fn account_info(&self) -> Box<AccountInfo<'a>> {
self.mint.account_info()
}
fn key(&self) -> &'a Pubkey {
self.mint.account_info.key
}
fn is_signer(&self) -> bool {
self.mint.account_info.is_signer
}
fn is_writable(&self) -> bool {
self.mint.account_info.is_writable
}
fn lamports(&self) -> u64 {
self.mint.account_info.lamports()
}
fn mut_lamports(&self) -> Result<std::cell::RefMut<'_, &'a mut u64>, ProgramError> {
self.mint.account_info.try_borrow_mut_lamports()
}
fn owner(&self) -> &'a Pubkey {
self.mint.account_info.owner
}
fn span(&self) -> Result<usize, ProgramError> {
self.mint.span()
}
}
impl<'a> Mut<Token<'a>> {
/// Mint new tokens to an associated token account.
pub fn mint_to(
&self,
recipient: impl NautilusMut<'a>,
mint_authority: impl NautilusSigner<'a>,
amount: u64,
) -> ProgramResult {
let multisigs: Option<Vec<Signer<Wallet>>> = None; // TODO: Multisig support
cpi::token::mint_to(
self.self_account.mint.token_program.key,
self.clone(),
recipient,
mint_authority,
multisigs,
amount,
)
}
/// Change the mint's authority.
pub fn set_authority(
&self,
new_authority: Option<&Pubkey>,
authority_type: AuthorityType,
current_authority: impl NautilusSigner<'a>,
) -> ProgramResult {
let multisigs: Option<Vec<Signer<Wallet>>> = None; // TODO: Multisig support
cpi::token::set_authority(
self.self_account.mint.token_program.key,
self.clone(),
new_authority,
authority_type,
current_authority,
multisigs,
)
}
}
impl<'a> Create<'a, Token<'a>> {
/// Create a new SPL mint with a Token Program and
/// a new SPL metadata account with Token Metadata Program.
#[allow(clippy::too_many_arguments)]
pub fn create(
&mut self,
decimals: u8,
title: String,
symbol: String,
uri: String,
mint_authority: impl NautilusSigner<'a>,
update_authority: impl NautilusAccountInfo<'a>,
freeze_authority: Option<impl NautilusAccountInfo<'a>>,
) -> ProgramResult {
let mut create_mint: Create<Mint> = self.clone().into();
let mut create_metadata: Create<Metadata> = self.clone().into();
create_mint.create(decimals, mint_authority.clone(), freeze_authority)?;
create_metadata.create(
title,
symbol,
uri,
self.self_account.mint.to_owned(),
mint_authority,
update_authority,
)?;
Ok(())
}
/// This function is the same as `create(&mut self, ..)` but allows you to
/// specify a rent payer.
#[allow(clippy::too_many_arguments)]
pub fn create_with_payer(
&mut self,
decimals: u8,
title: String,
symbol: String,
uri: String,
mint_authority: impl NautilusSigner<'a>,
update_authority: impl NautilusAccountInfo<'a>,
freeze_authority: Option<impl NautilusAccountInfo<'a>>,
payer: impl NautilusSigner<'a>,
) -> ProgramResult {
let mut create_mint: Create<Mint> = self.clone().into();
let mut create_metadata: Create<Metadata> = self.clone().into();
create_mint.create_with_payer(
decimals,
mint_authority.clone(),
freeze_authority,
payer.clone(),
)?;
create_metadata.create_with_payer(
title,
symbol,
uri,
self.self_account.mint.to_owned(),
mint_authority,
update_authority,
payer,
)?;
Ok(())
}
}
// Converters
impl<'a> From<Token<'a>> for Mint<'a> {
fn from(value: Token<'a>) -> Self {
value.mint
}
}
impl<'a> From<Create<'a, Token<'a>>> for Create<'a, Mint<'a>> {
fn from(value: Create<'a, Token<'a>>) -> Self {
Self {
self_account: value.self_account.into(),
fee_payer: value.fee_payer,
rent: value.rent,
system_program: value.system_program,
}
}
}
impl<'a> From<Token<'a>> for Metadata<'a> {
fn from(value: Token<'a>) -> Self {
value.metadata
}
}
impl<'a> From<Create<'a, Token<'a>>> for Create<'a, Metadata<'a>> {
fn from(value: Create<'a, Token<'a>>) -> Self {
Self {
self_account: value.self_account.into(),
fee_payer: value.fee_payer,
rent: value.rent,
system_program: value.system_program,
}
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/src/objects
|
solana_public_repos/nautilus-project/nautilus/solana/src/objects/tokens/associated_token.rs
|
//! The `AssociatedTokenAccount<T>` Nautilus object and all associated trait
//! implementations.
use solana_program::{
account_info::AccountInfo, entrypoint::ProgramResult, program_error::ProgramError,
program_pack::Pack, pubkey::Pubkey,
};
pub use spl_token::state::Account as AssociatedTokenAccountState;
use crate::{
cpi, error::NautilusError, Create, Mint, Mut, NautilusAccountInfo, NautilusMut, NautilusSigner,
Signer, Wallet,
};
/// The Nautilus object representing an associated token account.
///
/// The underlying account - designated in field `account_info` - is the
/// associated token account.
///
/// We also include the read-only Token Program and Associated Token Program for
/// any CPI operations necessary, since we do not own this account.
#[derive(Clone)]
pub struct AssociatedTokenAccount<'a> {
pub account_info: Box<AccountInfo<'a>>,
pub token_program: Box<AccountInfo<'a>>,
pub associated_token_program: Box<AccountInfo<'a>>,
pub data: AssociatedTokenAccountState,
}
impl<'a> AssociatedTokenAccount<'a> {
/// Instantiate a new `AssociatedTokenAccount` without loading the account
/// inner data from on-chain.
pub fn new(
account_info: Box<AccountInfo<'a>>,
token_program: Box<AccountInfo<'a>>,
associated_token_program: Box<AccountInfo<'a>>,
) -> Self {
Self {
account_info,
token_program,
associated_token_program,
data: AssociatedTokenAccountState::default(),
}
}
/// Instantiate a new `AssociatedTokenAccount` and load the account inner
/// data from on-chain.
pub fn load(
account_info: Box<AccountInfo<'a>>,
token_program: Box<AccountInfo<'a>>,
associated_token_program: Box<AccountInfo<'a>>,
) -> Result<Self, ProgramError> {
let data =
match AssociatedTokenAccountState::unpack(match &account_info.try_borrow_data() {
Ok(acct_data) => acct_data,
Err(_) => {
return Err(NautilusError::LoadDataFailed(
String::from("associated_token_account"),
account_info.key.to_string(),
)
.into())
}
}) {
Ok(state_data) => state_data,
Err(_) => {
return Err(NautilusError::DeserializeDataFailed(
String::from("associated_token_account"),
account_info.key.to_string(),
)
.into())
}
};
Ok(Self {
account_info,
token_program,
associated_token_program,
data,
})
}
}
impl<'a> NautilusAccountInfo<'a> for AssociatedTokenAccount<'a> {
fn account_info(&self) -> Box<AccountInfo<'a>> {
self.account_info.clone()
}
fn key(&self) -> &'a Pubkey {
self.account_info.key
}
fn is_signer(&self) -> bool {
self.account_info.is_signer
}
fn is_writable(&self) -> bool {
self.account_info.is_writable
}
fn lamports(&self) -> u64 {
self.account_info.lamports()
}
fn mut_lamports(&self) -> Result<std::cell::RefMut<'_, &'a mut u64>, ProgramError> {
self.account_info.try_borrow_mut_lamports()
}
fn owner(&self) -> &'a Pubkey {
self.account_info.owner
}
fn span(&self) -> Result<usize, ProgramError> {
Ok(AssociatedTokenAccountState::LEN)
}
}
impl<'a> Mut<AssociatedTokenAccount<'a>> {
/// Burn tokens from this associated token account.
pub fn burn(
&self,
mint: impl NautilusAccountInfo<'a>,
authority: impl NautilusSigner<'a>,
amount: u64,
) -> ProgramResult {
let multisigs: Option<Vec<Signer<Wallet>>> = None; // TODO: Multisig support
cpi::token::burn(
self.self_account.token_program.key,
self.clone(),
mint,
authority,
multisigs,
amount,
)
}
/// Freeze token movement from this associated token account.
pub fn freeze(
&self,
mint: impl NautilusAccountInfo<'a>,
freeze_authority: impl NautilusSigner<'a>,
) -> ProgramResult {
let multisigs: Option<Vec<Signer<Wallet>>> = None; // TODO: Multisig support
cpi::token::freeze_account(
self.self_account.token_program.key,
self.clone(),
mint,
freeze_authority,
multisigs,
)
}
/// Thaw this associated token account. It should be already frozen.
pub fn thaw(
&self,
mint: impl NautilusAccountInfo<'a>,
freeze_authority: impl NautilusSigner<'a>,
) -> ProgramResult {
let multisigs: Option<Vec<Signer<Wallet>>> = None; // TODO: Multisig support
cpi::token::thaw_account(
self.self_account.token_program.key,
self.clone(),
mint,
freeze_authority,
multisigs,
)
}
/// Transfer tokens from this associated token account to another.
pub fn transfer(
&self,
to: impl NautilusMut<'a>,
authority: impl NautilusSigner<'a>,
amount: u64,
) -> ProgramResult {
let multisigs: Option<Vec<Signer<Wallet>>> = None; // TODO: Multisig support
cpi::token::transfer(
self.self_account.token_program.key,
self.clone(),
to,
authority,
multisigs,
amount,
)
}
}
impl<'a> Create<'a, AssociatedTokenAccount<'a>> {
/// Create a new Associated Token Account using the Associated Token
/// Program.
pub fn create(&mut self, mint: Mint<'a>, owner: impl NautilusAccountInfo<'a>) -> ProgramResult {
let payer = Signer::new(Wallet {
account_info: self.fee_payer.to_owned(),
system_program: self.system_program.to_owned(),
})?;
cpi::associated_token::create_associated_token_account(
self.self_account.clone(),
owner,
mint,
payer,
self.system_program.to_owned(),
self.self_account.token_program.to_owned(),
self.self_account.associated_token_program.to_owned(),
)?;
self.self_account = AssociatedTokenAccount::load(
self.self_account.account_info.clone(),
self.self_account.token_program.clone(),
self.self_account.associated_token_program.clone(),
)?;
Ok(())
}
/// This function is the same as `create(&mut self, ..)` but allows you to
/// specify a rent payer.
pub fn create_with_payer(
&mut self,
mint: Mint<'a>,
owner: impl NautilusAccountInfo<'a>,
payer: impl NautilusSigner<'a>,
) -> ProgramResult {
cpi::associated_token::create_associated_token_account(
self.self_account.clone(),
owner,
mint,
payer,
self.system_program.to_owned(),
self.self_account.token_program.to_owned(),
self.self_account.associated_token_program.to_owned(),
)?;
self.self_account = AssociatedTokenAccount::load(
self.self_account.account_info.clone(),
self.self_account.token_program.clone(),
self.self_account.associated_token_program.clone(),
)?;
Ok(())
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/src/objects
|
solana_public_repos/nautilus-project/nautilus/solana/src/objects/tokens/mod.rs
|
//! Submodule containing all token-based Nautilus objects and their associated
//! trait implementations.
pub mod associated_token;
pub mod edition;
pub mod metadata;
pub mod mint;
pub mod nft;
pub mod token;
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/src/objects
|
solana_public_repos/nautilus-project/nautilus/solana/src/objects/tokens/mint.rs
|
//! The `Mint<T>` Nautilus object and all associated trait implementations.
use solana_program::{
account_info::AccountInfo, entrypoint::ProgramResult, program_error::ProgramError,
program_pack::Pack, pubkey::Pubkey,
};
use spl_token::instruction::AuthorityType;
pub use spl_token::state::Mint as MintState;
use crate::{
cpi, error::NautilusError, Create, Mut, NautilusAccountInfo, NautilusMut, NautilusSigner,
Signer, Wallet,
};
/// The Nautilus object representing a mint account.
///
/// The underlying account - designated in field `account_info` - is the mint
/// account.
///
/// We also include the read-only Token Program for any CPI operations
/// necessary, since we do not own this account.
#[derive(Clone)]
pub struct Mint<'a> {
pub account_info: Box<AccountInfo<'a>>,
pub token_program: Box<AccountInfo<'a>>,
pub data: MintState,
}
impl<'a> Mint<'a> {
// Inner data state associated functions
/// Instantiate a new `Mint` without loading the account inner data from
/// on-chain.
pub fn new(account_info: Box<AccountInfo<'a>>, token_program: Box<AccountInfo<'a>>) -> Self {
Self {
account_info,
token_program,
data: MintState::default(),
}
}
/// Instantiate a new `Mint` and load the account inner data from on-chain.
pub fn load(
account_info: Box<AccountInfo<'a>>,
token_program: Box<AccountInfo<'a>>,
) -> Result<Self, ProgramError> {
let data = match MintState::unpack(match &account_info.try_borrow_data() {
Ok(acct_data) => acct_data,
Err(_) => {
return Err(NautilusError::LoadDataFailed(
String::from("token_mint"),
account_info.key.to_string(),
)
.into())
}
}) {
Ok(state_data) => state_data,
Err(_) => {
return Err(NautilusError::DeserializeDataFailed(
String::from("token_mint"),
account_info.key.to_string(),
)
.into())
}
};
Ok(Self {
account_info,
token_program,
data,
})
}
// Token program capabilities
}
impl<'a> NautilusAccountInfo<'a> for Mint<'a> {
fn account_info(&self) -> Box<AccountInfo<'a>> {
self.account_info.clone()
}
fn key(&self) -> &'a Pubkey {
self.account_info.key
}
fn is_signer(&self) -> bool {
self.account_info.is_signer
}
fn is_writable(&self) -> bool {
self.account_info.is_writable
}
fn lamports(&self) -> u64 {
self.account_info.lamports()
}
fn mut_lamports(&self) -> Result<std::cell::RefMut<'_, &'a mut u64>, ProgramError> {
self.account_info.try_borrow_mut_lamports()
}
fn owner(&self) -> &'a Pubkey {
self.account_info.owner
}
fn span(&self) -> Result<usize, ProgramError> {
Ok(spl_token::state::Mint::LEN)
}
}
impl<'a> Mut<Mint<'a>> {
/// Mint new tokens to an associated token account.
pub fn mint_to(
&self,
recipient: impl NautilusMut<'a>,
mint_authority: impl NautilusSigner<'a>,
amount: u64,
) -> ProgramResult {
let multisigs: Option<Vec<Signer<Wallet>>> = None; // TODO: Multisig support
cpi::token::mint_to(
self.self_account.token_program.key,
self.clone(),
recipient,
mint_authority,
multisigs,
amount,
)
}
/// Change the mint's authority.
pub fn set_authority(
&self,
new_authority: Option<&Pubkey>,
authority_type: AuthorityType,
current_authority: impl NautilusSigner<'a>,
) -> ProgramResult {
let multisigs: Option<Vec<Signer<Wallet>>> = None; // TODO: Multisig support
cpi::token::set_authority(
self.self_account.token_program.key,
self.clone(),
new_authority,
authority_type,
current_authority,
multisigs,
)
}
}
impl<'a> Create<'a, Mint<'a>> {
/// Create a new SPL mint with a Token Program.
pub fn create(
&mut self,
decimals: u8,
mint_authority: impl NautilusSigner<'a>,
freeze_authority: Option<impl NautilusAccountInfo<'a>>,
) -> ProgramResult {
let payer = Signer::new(Wallet {
account_info: self.fee_payer.to_owned(),
system_program: self.system_program.to_owned(),
})?;
cpi::system::create_account(self.clone(), self.self_account.token_program.key, payer)?;
cpi::token::initialize_mint(
self.self_account.token_program.key,
self.clone(),
mint_authority.key(),
freeze_authority.map(|f| f.key()),
decimals,
self.rent.to_owned(),
)?;
self.self_account = Mint::load(
self.self_account.account_info.clone(),
self.self_account.token_program.clone(),
)?;
Ok(())
}
/// This function is the same as `create(&mut self, ..)` but allows you to
/// specify a rent payer.
pub fn create_with_payer(
&mut self,
decimals: u8,
mint_authority: impl NautilusSigner<'a>,
freeze_authority: Option<impl NautilusAccountInfo<'a>>,
payer: impl NautilusSigner<'a>,
) -> ProgramResult {
cpi::system::create_account(self.clone(), self.self_account.token_program.key, payer)?;
cpi::token::initialize_mint(
self.self_account.token_program.key,
self.clone(),
mint_authority.key(),
freeze_authority.map(|f| f.key()),
decimals,
self.rent.to_owned(),
)?;
self.self_account = Mint::load(
self.self_account.account_info.clone(),
self.self_account.token_program.clone(),
)?;
Ok(())
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/src/objects
|
solana_public_repos/nautilus-project/nautilus/solana/src/objects/tokens/edition.rs
|
//! The `Edition<T>` and `MasterEdition<T>` Nautilus object` and all associated
//! trait implementations.
pub use mpl_token_metadata::state::{
Edition as EditionState, MasterEditionV2 as MasterEditionState, TokenMetadataAccount,
};
use solana_program::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey};
use crate::{error::NautilusError, NautilusAccountInfo};
/// The Nautilus object representing an Edition of an NFT.
///
/// The underlying account - designated in field `account_info` - is the edition
/// account.
///
/// We also include the read-only Token Metadata Program for any CPI operations
/// necessary, since we do not own this account.
#[derive(Clone)]
pub struct Edition<'a> {
pub account_info: Box<AccountInfo<'a>>,
pub token_metadata_program: Box<AccountInfo<'a>>,
pub rent: Box<AccountInfo<'a>>,
pub data: EditionState,
}
impl<'a> Edition<'a> {
/// Instantiate a new `Edition` without loading the account inner data from
/// on-chain.
pub fn new(
account_info: Box<AccountInfo<'a>>,
token_metadata_program: Box<AccountInfo<'a>>,
rent: Box<AccountInfo<'a>>,
) -> Self {
Self {
account_info,
token_metadata_program,
rent,
data: EditionState::default(),
}
}
/// Instantiate a new `Edition` and load the account inner data from
/// on-chain.
pub fn load(
account_info: Box<AccountInfo<'a>>,
token_metadata_program: Box<AccountInfo<'a>>,
rent: Box<AccountInfo<'a>>,
) -> Result<Self, ProgramError> {
let data = match EditionState::safe_deserialize(match &account_info.try_borrow_data() {
Ok(acct_data) => acct_data,
Err(_) => {
return Err(NautilusError::LoadDataFailed(
String::from("token_metadata"),
account_info.key.to_string(),
)
.into())
}
}) {
Ok(state_data) => state_data,
Err(_) => {
return Err(NautilusError::DeserializeDataFailed(
String::from("token_metadata"),
account_info.key.to_string(),
)
.into())
}
};
Ok(Self {
account_info,
token_metadata_program,
rent,
data,
})
}
}
impl<'a> NautilusAccountInfo<'a> for Edition<'a> {
fn account_info(&self) -> Box<AccountInfo<'a>> {
self.account_info.clone()
}
fn key(&self) -> &'a Pubkey {
self.account_info.key
}
fn is_signer(&self) -> bool {
self.account_info.is_signer
}
fn is_writable(&self) -> bool {
self.account_info.is_writable
}
fn lamports(&self) -> u64 {
self.account_info.lamports()
}
fn mut_lamports(&self) -> Result<std::cell::RefMut<'_, &'a mut u64>, ProgramError> {
self.account_info.try_borrow_mut_lamports()
}
fn owner(&self) -> &'a Pubkey {
self.account_info.owner
}
fn span(&self) -> Result<usize, ProgramError> {
Ok(EditionState::size())
}
}
/// The Nautilus object representing an MasterEdition of an NFT.
///
/// The underlying account - designated in field `account_info` - is the edition
/// account.
///
/// We also include the read-only Token Metadata Program for any CPI operations
/// necessary, since we do not own this account.
#[derive(Clone)]
pub struct MasterEdition<'a> {
pub account_info: Box<AccountInfo<'a>>,
pub token_metadata_program: Box<AccountInfo<'a>>,
pub rent: Box<AccountInfo<'a>>,
pub data: MasterEditionState,
}
impl<'a> MasterEdition<'a> {
/// Instantiate a new `MasterEdition` without loading the account inner data
/// from on-chain.
pub fn new(
account_info: Box<AccountInfo<'a>>,
token_metadata_program: Box<AccountInfo<'a>>,
rent: Box<AccountInfo<'a>>,
) -> Self {
Self {
account_info,
token_metadata_program,
rent,
data: MasterEditionState::default(),
}
}
/// Instantiate a new `MasterEdition` and load the account inner data from
/// on-chain.
pub fn load(
account_info: Box<AccountInfo<'a>>,
token_metadata_program: Box<AccountInfo<'a>>,
rent: Box<AccountInfo<'a>>,
) -> Result<Self, ProgramError> {
let data =
match MasterEditionState::safe_deserialize(match &account_info.try_borrow_data() {
Ok(acct_data) => acct_data,
Err(_) => {
return Err(NautilusError::LoadDataFailed(
String::from("token_metadata"),
account_info.key.to_string(),
)
.into())
}
}) {
Ok(state_data) => state_data,
Err(_) => {
return Err(NautilusError::DeserializeDataFailed(
String::from("token_metadata"),
account_info.key.to_string(),
)
.into())
}
};
Ok(Self {
account_info,
token_metadata_program,
rent,
data,
})
}
}
impl<'a> NautilusAccountInfo<'a> for MasterEdition<'a> {
fn account_info(&self) -> Box<AccountInfo<'a>> {
self.account_info.clone()
}
fn key(&self) -> &'a Pubkey {
self.account_info.key
}
fn is_signer(&self) -> bool {
self.account_info.is_signer
}
fn is_writable(&self) -> bool {
self.account_info.is_writable
}
fn lamports(&self) -> u64 {
self.account_info.lamports()
}
fn mut_lamports(&self) -> Result<std::cell::RefMut<'_, &'a mut u64>, ProgramError> {
self.account_info.try_borrow_mut_lamports()
}
fn owner(&self) -> &'a Pubkey {
self.account_info.owner
}
fn span(&self) -> Result<usize, ProgramError> {
Ok(MasterEditionState::size())
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/src
|
solana_public_repos/nautilus-project/nautilus/solana/src/properties/create.rs
|
//! Traits used for creating Nautilus objects.
use solana_program::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey};
use crate::{error::NautilusError, NautilusMut};
use super::{signer::NautilusSigner, NautilusAccountInfo};
/// The struct to wrap an object so that it has the necessary accounts to create
/// an on-chain instance of itself. A user wraps their object `T` in `Create<'_,
/// T>` in order to make accessible the transaction fee payer, the System
/// Program, and the Rent Sysvar.
///
/// The transaction fee payer can be included by default whenever they provide a
/// signature for transaction fees, and the System Program and Rent Sysvar are
/// always read-only, which means the addition of these accounts will never
/// hinder Sealevel parallel execution.
#[derive(Clone)]
pub struct Create<'a, T>
where
T: NautilusAccountInfo<'a> + 'a,
{
pub fee_payer: Box<AccountInfo<'a>>,
pub system_program: Box<AccountInfo<'a>>,
pub rent: Box<AccountInfo<'a>>,
pub self_account: T,
}
impl<'a, T> Create<'a, T>
where
T: NautilusAccountInfo<'a> + 'a,
{
pub fn new(
fee_payer: Box<AccountInfo<'a>>,
system_program: Box<AccountInfo<'a>>,
rent: Box<AccountInfo<'a>>,
self_account: T,
) -> Result<Self, ProgramError> {
match check_account_does_not_exist(&self_account) {
true => Ok(Self {
fee_payer,
system_program,
rent,
self_account,
}),
false => Err(NautilusError::AccountExists(self_account.key().to_string()).into()),
}
}
}
impl<'a, T> NautilusAccountInfo<'a> for Create<'a, T>
where
T: NautilusAccountInfo<'a> + 'a,
{
fn account_info(&self) -> Box<AccountInfo<'a>> {
self.self_account.account_info()
}
fn key(&self) -> &'a Pubkey {
self.self_account.key()
}
fn is_signer(&self) -> bool {
self.self_account.is_signer()
}
fn is_writable(&self) -> bool {
self.self_account.is_writable()
}
fn lamports(&self) -> u64 {
self.self_account.lamports()
}
fn mut_lamports(&self) -> Result<std::cell::RefMut<'_, &'a mut u64>, ProgramError> {
self.self_account.mut_lamports()
}
fn owner(&self) -> &'a Pubkey {
self.self_account.owner()
}
fn span(&self) -> Result<usize, ProgramError> {
self.self_account.span()
}
}
impl<'a, T> NautilusMut<'a> for Create<'a, T> where T: NautilusAccountInfo<'a> + 'a {}
impl<'a, T> NautilusSigner<'a> for Create<'a, T> where T: NautilusAccountInfo<'a> + 'a {}
fn check_account_does_not_exist<'a>(account: &impl NautilusAccountInfo<'a>) -> bool {
let account_info = account.account_info();
account_info.lamports() == 0
&& account_info.owner.eq(&solana_program::system_program::ID)
&& account_info.data_is_empty()
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/src
|
solana_public_repos/nautilus-project/nautilus/solana/src/properties/mutable.rs
|
//! Traits used for marking Nautilus objects as mutable.
use solana_program::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey};
use crate::error::NautilusError;
use super::NautilusAccountInfo;
/// The trait that ensures an object's underlying `AccountInfo` must be mutable.
pub trait NautilusMut<'a>: NautilusAccountInfo<'a> {}
/// The struct to wrap an object so that it adheres to the `NautilusMut<'_>`
/// trait. A user wraps their object `T` in `Mut<T>` in order to comply with
/// various method constraints and ensure the underlying account is marked as
/// mutable.
#[derive(Clone)]
pub struct Mut<T>
where
T: Clone,
{
pub self_account: T,
}
impl<'a, T> Mut<T>
where
T: Clone + NautilusAccountInfo<'a>,
{
pub fn new(self_account: T) -> Result<Self, ProgramError> {
match self_account.is_writable() {
true => Ok(Self { self_account }),
false => Err(NautilusError::AccountNotMutable(self_account.key().to_string()).into()),
}
}
}
impl<'a, T> NautilusAccountInfo<'a> for Mut<T>
where
T: NautilusAccountInfo<'a>,
{
fn account_info(&self) -> Box<AccountInfo<'a>> {
self.self_account.account_info()
}
fn key(&self) -> &'a Pubkey {
self.self_account.key()
}
fn is_signer(&self) -> bool {
self.self_account.is_signer()
}
fn is_writable(&self) -> bool {
self.self_account.is_writable()
}
fn lamports(&self) -> u64 {
self.self_account.lamports()
}
fn mut_lamports(&self) -> Result<std::cell::RefMut<'_, &'a mut u64>, ProgramError> {
self.self_account.mut_lamports()
}
fn owner(&self) -> &'a Pubkey {
self.self_account.owner()
}
fn span(&self) -> Result<usize, ProgramError> {
self.self_account.span()
}
}
impl<'a, T> NautilusMut<'a> for Mut<T> where T: NautilusAccountInfo<'a> {}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/src
|
solana_public_repos/nautilus-project/nautilus/solana/src/properties/mod.rs
|
//! Submodule defining the trait hierarchy for Nautilus objects.
use solana_program::{
account_info::AccountInfo, entrypoint::ProgramResult, program_error::ProgramError,
pubkey::Pubkey,
};
use self::mutable::NautilusMut;
pub mod create;
pub mod data;
pub mod mutable;
pub mod signer;
/// The core trait that marks an object in a Nautilus program as being comprised
/// of Solana accounts.
///
/// Basically, if a struct implements this trait, that means its built using one
/// or more `Box` pointers to accounts passed into the program, ie.
/// `Box<AccountInfo<'_>>`
///
/// The implementation of this trait allows the instance of the implemented
/// struct to be used in many methods and functions across the Nautilus source
/// library.
pub trait NautilusAccountInfo<'a>: Clone {
/// Returns a `Box` pointer to the `AccountInfo` representing the underlying
/// account.
///
/// Some Nautilus objects (structs) may have multiple `Box<AccountInfo<'_>>`
/// fields, but this method should make its best effort to return the
/// account most closely associated with the object in question.
///
/// For example, a `nautilus::Token` contains two non-program
/// `Box<AccountInfo<'_>>` fields - one for the Mint and one for the
/// Metadata. The account returned by this method for a
/// `nautilus::Token` is the Mint.
fn account_info(&self) -> Box<AccountInfo<'a>>;
/// Returns a reference to the public key representing the underlying
/// account.
///
/// Similar to the `account_info(&self)` method, this method should make its
/// best effort to return the public key of the account most closely
/// associated with the object in question.
///
/// For example, a `nautilus::Token` contains two non-program
/// `Box<AccountInfo<'_>>` fields - one for the Mint and one for the
/// Metadata. The public key returned by this method for a
/// `nautilus::Token` is the address of the Mint.
fn key(&self) -> &'a Pubkey;
/// Similar to the `account_info(&self)` and `key(&self)` methods, this
/// returns whether or not the closest associated underlying
/// `AccountInfo` is a signer.
///
/// For more context on what "closest associated underlying" means, see the
/// documentation for `account_info(&self)` or `key(&self)`.
fn is_signer(&self) -> bool;
/// Similar to the `account_info(&self)` and `key(&self)` methods, this
/// returns whether or not the closest associated underlying
/// `AccountInfo` is mutable.
///
/// For more context on what "closest associated underlying" means, see the
/// documentation for `account_info(&self)` or `key(&self)`.
fn is_writable(&self) -> bool;
/// Returns the lamports balance of the closest associated underlying
/// `AccountInfo`.
///
/// For more context on what "closest associated underlying" means, see the
/// documentation for `account_info(&self)` or `key(&self)`.
fn lamports(&self) -> u64;
/// Returns a mutable reference to the lamports balance of the closest
/// associated underlying `AccountInfo`.
///
/// For more context on what "closest associated underlying" means, see the
/// documentation for `account_info(&self)` or `key(&self)`.
fn mut_lamports(&self) -> Result<std::cell::RefMut<'_, &'a mut u64>, ProgramError>;
/// Returns the address of the owner of the closest associated underlying
/// `AccountInfo`.
///
/// For more context on what "closest associated underlying" means, see the
/// documentation for `account_info(&self)` or `key(&self)`.
fn owner(&self) -> &'a Pubkey;
/// Returns the span (data length) of the closest associated underlying
/// `AccountInfo`.
///
/// For more context on what "closest associated underlying" means, see the
/// documentation for `account_info(&self)` or `key(&self)`.
fn span(&self) -> Result<usize, ProgramError>;
/// Converts the `span` to a u64.
fn size(&self) -> Result<u64, ProgramError> {
Ok(self.span()?.try_into().unwrap())
}
/// The amount of Lamports required to pay rent for the particular data type
/// associated with this Nautilus object.
fn required_rent(&self) -> Result<u64, solana_program::program_error::ProgramError> {
use solana_program::sysvar::Sysvar;
Ok((solana_program::sysvar::rent::Rent::get().unwrap()).minimum_balance(self.span()?))
}
}
/// This is a standalone trait since its really only available to system
/// accounts or PDAs owned by your program.
///
/// One should be careful when conducting `assign` operations, as changing the
/// program owner of an account can have unwanted consequences and/or can be
/// irreversible.
pub trait NautilusAssignable<'a>: NautilusAccountInfo<'a> {
/// Assign ownership of an account to some program.
fn assign(&self, owner: Pubkey) -> ProgramResult;
}
/// Since different types of Solana accounts vary in how they conduct transfers
/// depending on their designated owner, this trait allows for varying
/// implementations depending on the type of account associated with a Nautilus
/// object.
///
/// For example, a system account would have to CPI to the System Program to
/// conduct a transfer, but a PDA would not.
pub trait NautilusTransferLamports<'a>: NautilusAccountInfo<'a> {
/// Conducts a transfer of Lamports from this object (its underlying
/// account) to the designated recipient.
fn transfer_lamports(&self, to: impl NautilusMut<'a>, amount: u64) -> ProgramResult;
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/src
|
solana_public_repos/nautilus-project/nautilus/solana/src/properties/_update.rs
|
//! Traits used for updating Nautilus objects.
use solana_program::entrypoint::ProgramResult;
use super::signer::NautilusSigner;
pub trait NautilusUpdate<'a> {
fn update(&self) -> ProgramResult;
fn update_with_payer(&self, payer: impl NautilusSigner<'a>) -> ProgramResult;
}
pub trait NautilusUpdateMetadata<'a> {
fn update_metadata(
&self,
title: Option<String>,
symbol: Option<String>,
uri: Option<String>,
update_authority: impl NautilusSigner<'a>,
) -> ProgramResult;
}
pub trait NautilusUpdateToken<'a> {
fn update_metadata(
&self,
title: Option<String>,
symbol: Option<String>,
uri: Option<String>,
update_authority: impl NautilusSigner<'a>,
) -> ProgramResult;
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/src
|
solana_public_repos/nautilus-project/nautilus/solana/src/properties/data.rs
|
//! Traits used for managing the account data of Nautilus objects.
use borsh::{BorshDeserialize, BorshSerialize};
use solana_program::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey};
use super::NautilusAccountInfo;
/// The trait that represents account data for non-record Nautilus accounts.
///
/// This type of account is a standard program-derived address account (PDA).
///
/// Note: `seeds(..)` and `pda(..)` are derived from the derive macro - since
/// their arguments will vary.
pub trait NautilusAccountData: BorshDeserialize + BorshSerialize + Clone + Default {
const DISCRIMINATOR_STR: &'static str;
/// The 8-bit discriminator applied to this account as a prefix on any
/// account data containing this data type.
fn discriminator(&self) -> [u8; 8] {
discriminator(Self::DISCRIMINATOR_STR)
}
/// Checks authorities against the data's declared authorities.
fn check_authorities(&self, accounts: Vec<AccountInfo>) -> Result<(), ProgramError>;
/// Counts the data's declared authorities.
fn count_authorities(&self) -> u8;
}
/// The trait that represents account data for record-based, SQL-friendly
/// Nautilus accounts.
///
/// This type of account is a program-derived address account (PDA) but can be
/// treated like a record in a database table, with the data scheme (struct)
/// being the schema of the table.
pub trait NautilusRecordData: BorshDeserialize + BorshSerialize + Clone + Default {
const TABLE_NAME: &'static str;
const AUTO_INCREMENT: bool;
/// The 8-bit discriminator applied to this account as a prefix on any
/// account data containing this data type.
fn discriminator(&self) -> [u8; 8] {
discriminator(Self::TABLE_NAME)
}
/// The primary key of this particular record's account data type. This will
/// return the value of whichever field has been declared as the primary
/// key for this table.
fn primary_key(&self) -> Vec<u8>;
/// The seeds used to derive the program-derived address of this account.
///
/// Accessible through the account's data type since some parameters for
/// seeds may be based on fields in the data.
fn seeds(&self) -> Vec<Vec<u8>> {
vec![Self::TABLE_NAME.as_bytes().to_vec(), self.primary_key()]
}
/// Returns the program-derived address and bump for an account containing
/// this data.
///
/// Accessible through the account's data type since some parameters for
/// seeds may be based on fields in the data.
fn pda(&self, program_id: &Pubkey) -> (Pubkey, u8) {
let seeds_vec = self.seeds();
let seeds: Vec<&[u8]> = seeds_vec.iter().map(AsRef::as_ref).collect();
Pubkey::find_program_address(&seeds, program_id)
}
/// Checks authorities against the data's declared authorities.
fn check_authorities(&self, accounts: Vec<AccountInfo>) -> Result<(), ProgramError>;
/// Counts the data's declared authorities.
fn count_authorities(&self) -> u8;
}
/// This trait provides methods accessible to Nautilus Accounts (PDAs).
///
/// When you define a struct with the `#[derive(nautilus::State)]` macro, any
/// accounts created with this data scheme will have seeds defined and inherit
/// PDA functionality.
///
/// Note: `seeds(..)` and `pda(..)` are derived from the derive macro - since
/// their arguments will vary.
pub trait NautilusAccount<'a>: NautilusAccountInfo<'a> {
/// Returns the data's discriminator.
fn discriminator(&self) -> [u8; 8];
/// Checks authorities against the data's declared authorities.
fn check_authorities(&self, accounts: Vec<AccountInfo>) -> Result<(), ProgramError>;
/// Counts the data's declared authorities.
fn count_authorities(&self) -> u8;
}
/// This trait provides methods only accessible to Nautilus Tables.
///
/// When you define a struct with the `#[derive(nautilus::Table)]` macro, any
/// accounts created with this data scheme can be considered records, and the
/// struct itself can be considered a schema for a "table".
///
/// This trait is where things like autoincrement and authority checks come into
/// play.
pub trait NautilusRecord<'a>: NautilusAccountInfo<'a> {
/// Returns the data's discriminator.
fn discriminator(&self) -> [u8; 8];
/// The seeds used to derive the program-derived address of this account.
fn seeds(&self) -> Vec<Vec<u8>>;
/// Returns the program-derived address and bump for an account.
fn pda(&self) -> (Pubkey, u8);
/// Returns the primary key of a record.
fn primary_key(&self) -> Vec<u8>;
/// Checks authorities against the data's declared authorities.
fn check_authorities(&self, accounts: Vec<AccountInfo>) -> Result<(), ProgramError>;
/// Counts the data's declared authorities.
fn count_authorities(&self) -> u8;
}
/// Helper function to return the 8-bit discriminator of an account data type.
fn discriminator(discrim_str: &str) -> [u8; 8] {
let mut discriminator = [0u8; 8];
let preimage = format!("{}:{}", "global", discrim_str);
discriminator.copy_from_slice(&solana_program::hash::hash(preimage.as_bytes()).to_bytes()[..8]); // First 8 bytes
discriminator
}
| 0
|
solana_public_repos/nautilus-project/nautilus/solana/src
|
solana_public_repos/nautilus-project/nautilus/solana/src/properties/signer.rs
|
//! Traits used for marking Nautilus objects as signers.
use solana_program::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey};
use crate::{error::NautilusError, NautilusMut};
use super::NautilusAccountInfo;
/// The trait that ensures an object's underlying `AccountInfo` must be a
/// signer.
pub trait NautilusSigner<'a>: NautilusAccountInfo<'a> {}
/// The struct to wrap an object so that it adheres to the `NautilusSigner<'_>`
/// trait. A user wraps their object `T` in `Signer<T>` in order to comply with
/// various method constraints and ensure the underlying account is marked as a
/// signer.
#[derive(Clone)]
pub struct Signer<T>
where
T: Clone,
{
pub self_account: T,
}
impl<'a, T> Signer<T>
where
T: Clone + NautilusAccountInfo<'a>,
{
pub fn new(self_account: T) -> Result<Self, ProgramError> {
match self_account.is_signer() {
true => Ok(Self { self_account }),
false => Err(NautilusError::AccountNotSigner(self_account.key().to_string()).into()),
}
}
}
impl<'a, T> NautilusAccountInfo<'a> for Signer<T>
where
T: NautilusAccountInfo<'a>,
{
fn account_info(&self) -> Box<AccountInfo<'a>> {
self.self_account.account_info()
}
fn key(&self) -> &'a Pubkey {
self.self_account.key()
}
fn is_signer(&self) -> bool {
self.self_account.is_signer()
}
fn is_writable(&self) -> bool {
self.self_account.is_writable()
}
fn lamports(&self) -> u64 {
self.self_account.lamports()
}
fn mut_lamports(&self) -> Result<std::cell::RefMut<'_, &'a mut u64>, ProgramError> {
self.self_account.mut_lamports()
}
fn owner(&self) -> &'a Pubkey {
self.self_account.owner()
}
fn span(&self) -> Result<usize, ProgramError> {
self.self_account.span()
}
}
impl<'a, T> NautilusMut<'a> for Signer<T> where T: NautilusAccountInfo<'a> {}
impl<'a, T> NautilusSigner<'a> for Signer<T> where T: NautilusAccountInfo<'a> {}
| 0
|
solana_public_repos/nautilus-project/nautilus
|
solana_public_repos/nautilus-project/nautilus/docs/.babelrc
|
{
"presets": ["next/babel"],
"plugins": []
}
| 0
|
solana_public_repos/nautilus-project/nautilus
|
solana_public_repos/nautilus-project/nautilus/docs/tailwind.config.js
|
/** @type {import('tailwindcss').Config} */
module.exports = {
content: ["./src/**/*.{js,ts,jsx,tsx}"],
plugins: [require("daisyui"), require("@tailwindcss/typography")],
darkMode: "class",
theme: {
backgroundImage: {
hero: "url('/sea.jpeg')",
},
extend: {
colors: {
primary: {
300: "#24e387",
700: "#1bb56b",
800: "#169156",
900: "#0f6139",
},
},
},
fontFamily: {
body: [
"Inter",
"ui-sans-serif",
"system-ui",
"-apple-system",
"system-ui",
"Segoe UI",
"Roboto",
"Helvetica Neue",
"Arial",
"Noto Sans",
"sans-serif",
"Apple Color Emoji",
"Segoe UI Emoji",
"Segoe UI Symbol",
"Noto Color Emoji",
],
sans: [
"Inter",
"ui-sans-serif",
"system-ui",
"-apple-system",
"system-ui",
"Segoe UI",
"Roboto",
"Helvetica Neue",
"Arial",
"Noto Sans",
"sans-serif",
"Apple Color Emoji",
"Segoe UI Emoji",
"Segoe UI Symbol",
"Noto Color Emoji",
],
},
},
};
| 0
|
solana_public_repos/nautilus-project/nautilus
|
solana_public_repos/nautilus-project/nautilus/docs/next.config.js
|
/** @type {import('next').NextConfig} */
const nextConfig = {
reactStrictMode: true,
}
module.exports = nextConfig
| 0
|
solana_public_repos/nautilus-project/nautilus
|
solana_public_repos/nautilus-project/nautilus/docs/yarn.lock
|
# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
# yarn lockfile v1
"@babel/runtime@^7.20.7":
version "7.21.0"
resolved "https://registry.npmjs.org/@babel/runtime/-/runtime-7.21.0.tgz"
integrity sha512-xwII0//EObnq89Ji5AKYQaRYiW/nZ3llSv29d49IuxPhKbtJoLP+9QUUZ4nVragQVtaVGeZrpB+ZtG/Pdy/POw==
dependencies:
regenerator-runtime "^0.13.11"
"@eslint-community/eslint-utils@^4.2.0":
version "4.4.0"
resolved "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz"
integrity sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==
dependencies:
eslint-visitor-keys "^3.3.0"
"@eslint-community/regexpp@^4.4.0":
version "4.5.0"
resolved "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.5.0.tgz"
integrity sha512-vITaYzIcNmjn5tF5uxcZ/ft7/RXGrMUIS9HalWckEOF6ESiwXKoMzAQf2UW0aVd6rnOeExTJVd5hmWXucBKGXQ==
"@eslint/eslintrc@^2.0.2":
version "2.0.2"
resolved "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.0.2.tgz"
integrity sha512-3W4f5tDUra+pA+FzgugqL2pRimUTDJWKr7BINqOpkZrC0uYI0NIc0/JFgBROCU07HR6GieA5m3/rsPIhDmCXTQ==
dependencies:
ajv "^6.12.4"
debug "^4.3.2"
espree "^9.5.1"
globals "^13.19.0"
ignore "^5.2.0"
import-fresh "^3.2.1"
js-yaml "^4.1.0"
minimatch "^3.1.2"
strip-json-comments "^3.1.1"
"@eslint/js@8.37.0":
version "8.37.0"
resolved "https://registry.npmjs.org/@eslint/js/-/js-8.37.0.tgz"
integrity sha512-x5vzdtOOGgFVDCUs81QRB2+liax8rFg3+7hqM+QhBG0/G3F1ZsoYl97UrqgHgQ9KKT7G6c4V+aTUCgu/n22v1A==
"@humanwhocodes/config-array@^0.11.8":
version "0.11.8"
resolved "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.11.8.tgz"
integrity sha512-UybHIJzJnR5Qc/MsD9Kr+RpO2h+/P1GhOwdiLPXK5TWk5sgTdu88bTD9UP+CKbPPh5Rni1u0GjAdYQLemG8g+g==
dependencies:
"@humanwhocodes/object-schema" "^1.2.1"
debug "^4.1.1"
minimatch "^3.0.5"
"@humanwhocodes/module-importer@^1.0.1":
version "1.0.1"
resolved "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz"
integrity sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==
"@humanwhocodes/object-schema@^1.2.1":
version "1.2.1"
resolved "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz"
integrity sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==
"@next/env@13.2.4":
version "13.2.4"
resolved "https://registry.npmjs.org/@next/env/-/env-13.2.4.tgz"
integrity sha512-+Mq3TtpkeeKFZanPturjcXt+KHfKYnLlX6jMLyCrmpq6OOs4i1GqBOAauSkii9QeKCMTYzGppar21JU57b/GEA==
"@next/eslint-plugin-next@13.2.4":
version "13.2.4"
resolved "https://registry.npmjs.org/@next/eslint-plugin-next/-/eslint-plugin-next-13.2.4.tgz"
integrity sha512-ck1lI+7r1mMJpqLNa3LJ5pxCfOB1lfJncKmRJeJxcJqcngaFwylreLP7da6Rrjr6u2gVRTfmnkSkjc80IiQCwQ==
dependencies:
glob "7.1.7"
"@next/swc-android-arm-eabi@13.2.4":
version "13.2.4"
resolved "https://registry.yarnpkg.com/@next/swc-android-arm-eabi/-/swc-android-arm-eabi-13.2.4.tgz#758d0403771e549f9cee71cbabc0cb16a6c947c0"
integrity sha512-DWlalTSkLjDU11MY11jg17O1gGQzpRccM9Oes2yTqj2DpHndajrXHGxj9HGtJ+idq2k7ImUdJVWS2h2l/EDJOw==
"@next/swc-android-arm64@13.2.4":
version "13.2.4"
resolved "https://registry.yarnpkg.com/@next/swc-android-arm64/-/swc-android-arm64-13.2.4.tgz#834d586523045110d5602e0c8aae9028835ac427"
integrity sha512-sRavmUImUCf332Gy+PjIfLkMhiRX1Ez4SI+3vFDRs1N5eXp+uNzjFUK/oLMMOzk6KFSkbiK/3Wt8+dHQR/flNg==
"@next/swc-darwin-arm64@13.2.4":
version "13.2.4"
resolved "https://registry.npmjs.org/@next/swc-darwin-arm64/-/swc-darwin-arm64-13.2.4.tgz"
integrity sha512-S6vBl+OrInP47TM3LlYx65betocKUUlTZDDKzTiRDbsRESeyIkBtZ6Qi5uT2zQs4imqllJznVjFd1bXLx3Aa6A==
"@next/swc-darwin-x64@13.2.4":
version "13.2.4"
resolved "https://registry.yarnpkg.com/@next/swc-darwin-x64/-/swc-darwin-x64-13.2.4.tgz#6549c7c04322766acc3264ccdb3e1b43fcaf7946"
integrity sha512-a6LBuoYGcFOPGd4o8TPo7wmv5FnMr+Prz+vYHopEDuhDoMSHOnC+v+Ab4D7F0NMZkvQjEJQdJS3rqgFhlZmKlw==
"@next/swc-freebsd-x64@13.2.4":
version "13.2.4"
resolved "https://registry.yarnpkg.com/@next/swc-freebsd-x64/-/swc-freebsd-x64-13.2.4.tgz#0bbe28979e3e868debc2cc06e45e186ce195b7f4"
integrity sha512-kkbzKVZGPaXRBPisoAQkh3xh22r+TD+5HwoC5bOkALraJ0dsOQgSMAvzMXKsN3tMzJUPS0tjtRf1cTzrQ0I5vQ==
"@next/swc-linux-arm-gnueabihf@13.2.4":
version "13.2.4"
resolved "https://registry.yarnpkg.com/@next/swc-linux-arm-gnueabihf/-/swc-linux-arm-gnueabihf-13.2.4.tgz#1d28d2203f5a7427d6e7119d7bcb5fc40959fb3e"
integrity sha512-7qA1++UY0fjprqtjBZaOA6cas/7GekpjVsZn/0uHvquuITFCdKGFCsKNBx3S0Rpxmx6WYo0GcmhNRM9ru08BGg==
"@next/swc-linux-arm64-gnu@13.2.4":
version "13.2.4"
resolved "https://registry.yarnpkg.com/@next/swc-linux-arm64-gnu/-/swc-linux-arm64-gnu-13.2.4.tgz#eb26448190948cdf4c44b8f34110a3ecea32f1d0"
integrity sha512-xzYZdAeq883MwXgcwc72hqo/F/dwUxCukpDOkx/j1HTq/J0wJthMGjinN9wH5bPR98Mfeh1MZJ91WWPnZOedOg==
"@next/swc-linux-arm64-musl@13.2.4":
version "13.2.4"
resolved "https://registry.yarnpkg.com/@next/swc-linux-arm64-musl/-/swc-linux-arm64-musl-13.2.4.tgz#c4227c0acd94a420bb14924820710e6284d234d3"
integrity sha512-8rXr3WfmqSiYkb71qzuDP6I6R2T2tpkmf83elDN8z783N9nvTJf2E7eLx86wu2OJCi4T05nuxCsh4IOU3LQ5xw==
"@next/swc-linux-x64-gnu@13.2.4":
version "13.2.4"
resolved "https://registry.yarnpkg.com/@next/swc-linux-x64-gnu/-/swc-linux-x64-gnu-13.2.4.tgz#6bcb540944ee9b0209b33bfc23b240c2044dfc3e"
integrity sha512-Ngxh51zGSlYJ4EfpKG4LI6WfquulNdtmHg1yuOYlaAr33KyPJp4HeN/tivBnAHcZkoNy0hh/SbwDyCnz5PFJQQ==
"@next/swc-linux-x64-musl@13.2.4":
version "13.2.4"
resolved "https://registry.yarnpkg.com/@next/swc-linux-x64-musl/-/swc-linux-x64-musl-13.2.4.tgz#ce21e43251eaf09a09df39372b2c3e38028c30ff"
integrity sha512-gOvwIYoSxd+j14LOcvJr+ekd9fwYT1RyMAHOp7znA10+l40wkFiMONPLWiZuHxfRk+Dy7YdNdDh3ImumvL6VwA==
"@next/swc-win32-arm64-msvc@13.2.4":
version "13.2.4"
resolved "https://registry.yarnpkg.com/@next/swc-win32-arm64-msvc/-/swc-win32-arm64-msvc-13.2.4.tgz#68220063d8e5e082f5465498675640dedb670ff1"
integrity sha512-q3NJzcfClgBm4HvdcnoEncmztxrA5GXqKeiZ/hADvC56pwNALt3ngDC6t6qr1YW9V/EPDxCYeaX4zYxHciW4Dw==
"@next/swc-win32-ia32-msvc@13.2.4":
version "13.2.4"
resolved "https://registry.yarnpkg.com/@next/swc-win32-ia32-msvc/-/swc-win32-ia32-msvc-13.2.4.tgz#7c120ab54a081be9566df310bed834f168252990"
integrity sha512-/eZ5ncmHUYtD2fc6EUmAIZlAJnVT2YmxDsKs1Ourx0ttTtvtma/WKlMV5NoUsyOez0f9ExLyOpeCoz5aj+MPXw==
"@next/swc-win32-x64-msvc@13.2.4":
version "13.2.4"
resolved "https://registry.yarnpkg.com/@next/swc-win32-x64-msvc/-/swc-win32-x64-msvc-13.2.4.tgz#5abda92fe12b9829bf7951c4a221282c56041144"
integrity sha512-0MffFmyv7tBLlji01qc0IaPP/LVExzvj7/R5x1Jph1bTAIj4Vu81yFQWHHQAP6r4ff9Ukj1mBK6MDNVXm7Tcvw==
"@nodelib/fs.scandir@2.1.5":
version "2.1.5"
resolved "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz"
integrity sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==
dependencies:
"@nodelib/fs.stat" "2.0.5"
run-parallel "^1.1.9"
"@nodelib/fs.stat@2.0.5", "@nodelib/fs.stat@^2.0.2":
version "2.0.5"
resolved "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz"
integrity sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==
"@nodelib/fs.walk@^1.2.3", "@nodelib/fs.walk@^1.2.8":
version "1.2.8"
resolved "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz"
integrity sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==
dependencies:
"@nodelib/fs.scandir" "2.1.5"
fastq "^1.6.0"
"@pkgr/utils@^2.3.1":
version "2.3.1"
resolved "https://registry.npmjs.org/@pkgr/utils/-/utils-2.3.1.tgz"
integrity sha512-wfzX8kc1PMyUILA+1Z/EqoE4UCXGy0iRGMhPwdfae1+f0OXlLqCk+By+aMzgJBzR9AzS4CDizioG6Ss1gvAFJw==
dependencies:
cross-spawn "^7.0.3"
is-glob "^4.0.3"
open "^8.4.0"
picocolors "^1.0.0"
tiny-glob "^0.2.9"
tslib "^2.4.0"
"@rushstack/eslint-patch@^1.1.3":
version "1.2.0"
resolved "https://registry.npmjs.org/@rushstack/eslint-patch/-/eslint-patch-1.2.0.tgz"
integrity sha512-sXo/qW2/pAcmT43VoRKOJbDOfV3cYpq3szSVfIThQXNt+E4DfKj361vaAt3c88U5tPUxzEswam7GW48PJqtKAg==
"@swc/helpers@0.4.14":
version "0.4.14"
resolved "https://registry.npmjs.org/@swc/helpers/-/helpers-0.4.14.tgz"
integrity sha512-4C7nX/dvpzB7za4Ql9K81xK3HPxCpHMgwTZVyf+9JQ6VUbn9jjZVN7/Nkdz/Ugzs2CSjqnL/UPXroiVBVHUWUw==
dependencies:
tslib "^2.4.0"
"@tailwindcss/typography@^0.5.9":
version "0.5.9"
resolved "https://registry.npmjs.org/@tailwindcss/typography/-/typography-0.5.9.tgz"
integrity sha512-t8Sg3DyynFysV9f4JDOVISGsjazNb48AeIYQwcL+Bsq5uf4RYL75C1giZ43KISjeDGBaTN3Kxh7Xj/vRSMJUUg==
dependencies:
lodash.castarray "^4.4.0"
lodash.isplainobject "^4.0.6"
lodash.merge "^4.6.2"
postcss-selector-parser "6.0.10"
"@types/debug@^4.0.0":
version "4.1.7"
resolved "https://registry.npmjs.org/@types/debug/-/debug-4.1.7.tgz"
integrity sha512-9AonUzyTjXXhEOa0DnqpzZi6VHlqKMswga9EXjpXnnqxwLtdvPPtlO8evrI5D9S6asFRCQ6v+wpiUKbw+vKqyg==
dependencies:
"@types/ms" "*"
"@types/hast@^2.0.0":
version "2.3.4"
resolved "https://registry.npmjs.org/@types/hast/-/hast-2.3.4.tgz"
integrity sha512-wLEm0QvaoawEDoTRwzTXp4b4jpwiJDvR5KMnFnVodm3scufTlBOWRD6N1OBf9TZMhjlNsSfcO5V+7AF4+Vy+9g==
dependencies:
"@types/unist" "*"
"@types/json5@^0.0.29":
version "0.0.29"
resolved "https://registry.npmjs.org/@types/json5/-/json5-0.0.29.tgz"
integrity sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==
"@types/mdast@^3.0.0":
version "3.0.11"
resolved "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.11.tgz"
integrity sha512-Y/uImid8aAwrEA24/1tcRZwpxX3pIFTSilcNDKSPn+Y2iDywSEachzRuvgAYYLR3wpGXAsMbv5lvKLDZLeYPAw==
dependencies:
"@types/unist" "*"
"@types/ms@*":
version "0.7.31"
resolved "https://registry.npmjs.org/@types/ms/-/ms-0.7.31.tgz"
integrity sha512-iiUgKzV9AuaEkZqkOLDIvlQiL6ltuZd9tGcW3gwpnX8JbuiuhFlEGmmFXEXkN50Cvq7Os88IY2v0dkDqXYWVgA==
"@types/node@18.15.11":
version "18.15.11"
resolved "https://registry.npmjs.org/@types/node/-/node-18.15.11.tgz"
integrity sha512-E5Kwq2n4SbMzQOn6wnmBjuK9ouqlURrcZDVfbo9ftDDTFt3nk7ZKK4GMOzoYgnpQJKcxwQw+lGaBvvlMo0qN/Q==
"@types/parse5@^6.0.0":
version "6.0.3"
resolved "https://registry.npmjs.org/@types/parse5/-/parse5-6.0.3.tgz"
integrity sha512-SuT16Q1K51EAVPz1K29DJ/sXjhSQ0zjvsypYJ6tlwVsRV9jwW5Adq2ch8Dq8kDBCkYnELS7N7VNCSB5nC56t/g==
"@types/prop-types@*":
version "15.7.5"
resolved "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.5.tgz"
integrity sha512-JCB8C6SnDoQf0cNycqd/35A7MjcnK+ZTqE7judS6o7utxUCg6imJg3QK2qzHKszlTjcj2cn+NwMB2i96ubpj7w==
"@types/react-dom@18.0.11":
version "18.0.11"
resolved "https://registry.npmjs.org/@types/react-dom/-/react-dom-18.0.11.tgz"
integrity sha512-O38bPbI2CWtgw/OoQoY+BRelw7uysmXbWvw3nLWO21H1HSh+GOlqPuXshJfjmpNlKiiSDG9cc1JZAaMmVdcTlw==
dependencies:
"@types/react" "*"
"@types/react@*", "@types/react@18.0.32":
version "18.0.32"
resolved "https://registry.npmjs.org/@types/react/-/react-18.0.32.tgz"
integrity sha512-gYGXdtPQ9Cj0w2Fwqg5/ak6BcK3Z15YgjSqtyDizWUfx7mQ8drs0NBUzRRsAdoFVTO8kJ8L2TL8Skm7OFPnLUw==
dependencies:
"@types/prop-types" "*"
"@types/scheduler" "*"
csstype "^3.0.2"
"@types/scheduler@*":
version "0.16.3"
resolved "https://registry.npmjs.org/@types/scheduler/-/scheduler-0.16.3.tgz"
integrity sha512-5cJ8CB4yAx7BH1oMvdU0Jh9lrEXyPkar6F9G/ERswkCuvP4KQZfZkSjcMbAICCpQTN4OuZn8tz0HiKv9TGZgrQ==
"@types/unist@*", "@types/unist@^2.0.0":
version "2.0.6"
resolved "https://registry.npmjs.org/@types/unist/-/unist-2.0.6.tgz"
integrity sha512-PBjIUxZHOuj0R15/xuwJYjFi+KZdNFrehocChv4g5hu6aFroHue8m0lBP0POdK2nKzbw0cgV1mws8+V/JAcEkQ==
"@typescript-eslint/parser@^5.42.0":
version "5.57.0"
resolved "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.57.0.tgz"
integrity sha512-orrduvpWYkgLCyAdNtR1QIWovcNZlEm6yL8nwH/eTxWLd8gsP+25pdLHYzL2QdkqrieaDwLpytHqycncv0woUQ==
dependencies:
"@typescript-eslint/scope-manager" "5.57.0"
"@typescript-eslint/types" "5.57.0"
"@typescript-eslint/typescript-estree" "5.57.0"
debug "^4.3.4"
"@typescript-eslint/scope-manager@5.57.0":
version "5.57.0"
resolved "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.57.0.tgz"
integrity sha512-NANBNOQvllPlizl9LatX8+MHi7bx7WGIWYjPHDmQe5Si/0YEYfxSljJpoTyTWFTgRy3X8gLYSE4xQ2U+aCozSw==
dependencies:
"@typescript-eslint/types" "5.57.0"
"@typescript-eslint/visitor-keys" "5.57.0"
"@typescript-eslint/types@5.57.0":
version "5.57.0"
resolved "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.57.0.tgz"
integrity sha512-mxsod+aZRSyLT+jiqHw1KK6xrANm19/+VFALVFP5qa/aiJnlP38qpyaTd0fEKhWvQk6YeNZ5LGwI1pDpBRBhtQ==
"@typescript-eslint/typescript-estree@5.57.0":
version "5.57.0"
resolved "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-5.57.0.tgz"
integrity sha512-LTzQ23TV82KpO8HPnWuxM2V7ieXW8O142I7hQTxWIHDcCEIjtkat6H96PFkYBQqGFLW/G/eVVOB9Z8rcvdY/Vw==
dependencies:
"@typescript-eslint/types" "5.57.0"
"@typescript-eslint/visitor-keys" "5.57.0"
debug "^4.3.4"
globby "^11.1.0"
is-glob "^4.0.3"
semver "^7.3.7"
tsutils "^3.21.0"
"@typescript-eslint/visitor-keys@5.57.0":
version "5.57.0"
resolved "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.57.0.tgz"
integrity sha512-ery2g3k0hv5BLiKpPuwYt9KBkAp2ugT6VvyShXdLOkax895EC55sP0Tx5L0fZaQueiK3fBLvHVvEl3jFS5ia+g==
dependencies:
"@typescript-eslint/types" "5.57.0"
eslint-visitor-keys "^3.3.0"
acorn-jsx@^5.3.2:
version "5.3.2"
resolved "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz"
integrity sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==
acorn@^8.8.0:
version "8.8.2"
resolved "https://registry.npmjs.org/acorn/-/acorn-8.8.2.tgz"
integrity sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw==
ajv@^6.10.0, ajv@^6.12.4:
version "6.12.6"
resolved "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz"
integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==
dependencies:
fast-deep-equal "^3.1.1"
fast-json-stable-stringify "^2.0.0"
json-schema-traverse "^0.4.1"
uri-js "^4.2.2"
ansi-regex@^5.0.1:
version "5.0.1"
resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz"
integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==
ansi-styles@^4.1.0:
version "4.3.0"
resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz"
integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==
dependencies:
color-convert "^2.0.1"
any-promise@^1.0.0:
version "1.3.0"
resolved "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz"
integrity sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==
anymatch@~3.1.2:
version "3.1.3"
resolved "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz"
integrity sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==
dependencies:
normalize-path "^3.0.0"
picomatch "^2.0.4"
arg@^5.0.2:
version "5.0.2"
resolved "https://registry.npmjs.org/arg/-/arg-5.0.2.tgz"
integrity sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==
argparse@^1.0.7:
version "1.0.10"
resolved "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz"
integrity sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==
dependencies:
sprintf-js "~1.0.2"
argparse@^2.0.1:
version "2.0.1"
resolved "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz"
integrity sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==
aria-query@^5.1.3:
version "5.1.3"
resolved "https://registry.npmjs.org/aria-query/-/aria-query-5.1.3.tgz"
integrity sha512-R5iJ5lkuHybztUfuOAznmboyjWq8O6sqNqtK7CLOqdydi54VNbORp49mb14KbWgG1QD3JFO9hJdZ+y4KutfdOQ==
dependencies:
deep-equal "^2.0.5"
array-buffer-byte-length@^1.0.0:
version "1.0.0"
resolved "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.0.tgz"
integrity sha512-LPuwb2P+NrQw3XhxGc36+XSvuBPopovXYTR9Ew++Du9Yb/bx5AzBfrIsBoj0EZUifjQU+sHL21sseZ3jerWO/A==
dependencies:
call-bind "^1.0.2"
is-array-buffer "^3.0.1"
array-includes@^3.1.5, array-includes@^3.1.6:
version "3.1.6"
resolved "https://registry.npmjs.org/array-includes/-/array-includes-3.1.6.tgz"
integrity sha512-sgTbLvL6cNnw24FnbaDyjmvddQ2ML8arZsgaJhoABMoplz/4QRhtrYS+alr1BUM1Bwp6dhx8vVCBSLG+StwOFw==
dependencies:
call-bind "^1.0.2"
define-properties "^1.1.4"
es-abstract "^1.20.4"
get-intrinsic "^1.1.3"
is-string "^1.0.7"
array-union@^2.1.0:
version "2.1.0"
resolved "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz"
integrity sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==
array.prototype.flat@^1.3.1:
version "1.3.1"
resolved "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.1.tgz"
integrity sha512-roTU0KWIOmJ4DRLmwKd19Otg0/mT3qPNt0Qb3GWW8iObuZXxrjB/pzn0R3hqpRSWg4HCwqx+0vwOnWnvlOyeIA==
dependencies:
call-bind "^1.0.2"
define-properties "^1.1.4"
es-abstract "^1.20.4"
es-shim-unscopables "^1.0.0"
array.prototype.flatmap@^1.3.1:
version "1.3.1"
resolved "https://registry.npmjs.org/array.prototype.flatmap/-/array.prototype.flatmap-1.3.1.tgz"
integrity sha512-8UGn9O1FDVvMNB0UlLv4voxRMze7+FpHyF5mSMRjWHUMlpoDViniy05870VlxhfgTnLbpuwTzvD76MTtWxB/mQ==
dependencies:
call-bind "^1.0.2"
define-properties "^1.1.4"
es-abstract "^1.20.4"
es-shim-unscopables "^1.0.0"
array.prototype.tosorted@^1.1.1:
version "1.1.1"
resolved "https://registry.npmjs.org/array.prototype.tosorted/-/array.prototype.tosorted-1.1.1.tgz"
integrity sha512-pZYPXPRl2PqWcsUs6LOMn+1f1532nEoPTYowBtqLwAW+W8vSVhkIGnmOX1t/UQjD6YGI0vcD2B1U7ZFGQH9jnQ==
dependencies:
call-bind "^1.0.2"
define-properties "^1.1.4"
es-abstract "^1.20.4"
es-shim-unscopables "^1.0.0"
get-intrinsic "^1.1.3"
ast-types-flow@^0.0.7:
version "0.0.7"
resolved "https://registry.npmjs.org/ast-types-flow/-/ast-types-flow-0.0.7.tgz"
integrity sha512-eBvWn1lvIApYMhzQMsu9ciLfkBY499mFZlNqG+/9WR7PVlroQw0vG30cOQQbaKz3sCEc44TAOu2ykzqXSNnwag==
autoprefixer@^10.4.14:
version "10.4.14"
resolved "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.14.tgz"
integrity sha512-FQzyfOsTlwVzjHxKEqRIAdJx9niO6VCBCoEwax/VLSoQF29ggECcPuBqUMZ+u8jCZOPSy8b8/8KnuFbp0SaFZQ==
dependencies:
browserslist "^4.21.5"
caniuse-lite "^1.0.30001464"
fraction.js "^4.2.0"
normalize-range "^0.1.2"
picocolors "^1.0.0"
postcss-value-parser "^4.2.0"
available-typed-arrays@^1.0.5:
version "1.0.5"
resolved "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.5.tgz"
integrity sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw==
axe-core@^4.6.2:
version "4.6.3"
resolved "https://registry.npmjs.org/axe-core/-/axe-core-4.6.3.tgz"
integrity sha512-/BQzOX780JhsxDnPpH4ZiyrJAzcd8AfzFPkv+89veFSr1rcMjuq2JDCwypKaPeB6ljHp9KjXhPpjgCvQlWYuqg==
axobject-query@^3.1.1:
version "3.1.1"
resolved "https://registry.npmjs.org/axobject-query/-/axobject-query-3.1.1.tgz"
integrity sha512-goKlv8DZrK9hUh975fnHzhNIO4jUnFCfv/dszV5VwUGDFjI6vQ2VwoyjYjYNEbBE8AH87TduWP5uyDR1D+Iteg==
dependencies:
deep-equal "^2.0.5"
bail@^2.0.0:
version "2.0.2"
resolved "https://registry.npmjs.org/bail/-/bail-2.0.2.tgz"
integrity sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==
balanced-match@^1.0.0:
version "1.0.2"
resolved "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz"
integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==
binary-extensions@^2.0.0:
version "2.2.0"
resolved "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz"
integrity sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==
brace-expansion@^1.1.7:
version "1.1.11"
resolved "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz"
integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==
dependencies:
balanced-match "^1.0.0"
concat-map "0.0.1"
braces@^3.0.2, braces@~3.0.2:
version "3.0.2"
resolved "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz"
integrity sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==
dependencies:
fill-range "^7.0.1"
browserslist@^4.21.5:
version "4.21.5"
resolved "https://registry.npmjs.org/browserslist/-/browserslist-4.21.5.tgz"
integrity sha512-tUkiguQGW7S3IhB7N+c2MV/HZPSCPAAiYBZXLsBhFB/PCy6ZKKsZrmBayHV9fdGV/ARIfJ14NkxKzRDjvp7L6w==
dependencies:
caniuse-lite "^1.0.30001449"
electron-to-chromium "^1.4.284"
node-releases "^2.0.8"
update-browserslist-db "^1.0.10"
call-bind@^1.0.0, call-bind@^1.0.2:
version "1.0.2"
resolved "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz"
integrity sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==
dependencies:
function-bind "^1.1.1"
get-intrinsic "^1.0.2"
callsites@^3.0.0:
version "3.1.0"
resolved "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz"
integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==
camelcase-css@^2.0.1:
version "2.0.1"
resolved "https://registry.npmjs.org/camelcase-css/-/camelcase-css-2.0.1.tgz"
integrity sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==
caniuse-lite@^1.0.30001406, caniuse-lite@^1.0.30001449, caniuse-lite@^1.0.30001464:
version "1.0.30001473"
resolved "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001473.tgz"
integrity sha512-ewDad7+D2vlyy+E4UJuVfiBsU69IL+8oVmTuZnH5Q6CIUbxNfI50uVpRHbUPDD6SUaN2o0Lh4DhTrvLG/Tn1yg==
ccount@^2.0.0:
version "2.0.1"
resolved "https://registry.npmjs.org/ccount/-/ccount-2.0.1.tgz"
integrity sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==
chalk@^4.0.0:
version "4.1.2"
resolved "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz"
integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==
dependencies:
ansi-styles "^4.1.0"
supports-color "^7.1.0"
character-entities-html4@^2.0.0:
version "2.1.0"
resolved "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-2.1.0.tgz"
integrity sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==
character-entities-legacy@^3.0.0:
version "3.0.0"
resolved "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-3.0.0.tgz"
integrity sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==
character-entities@^2.0.0:
version "2.0.2"
resolved "https://registry.npmjs.org/character-entities/-/character-entities-2.0.2.tgz"
integrity sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ==
chokidar@^3.5.3:
version "3.5.3"
resolved "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz"
integrity sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==
dependencies:
anymatch "~3.1.2"
braces "~3.0.2"
glob-parent "~5.1.2"
is-binary-path "~2.1.0"
is-glob "~4.0.1"
normalize-path "~3.0.0"
readdirp "~3.6.0"
optionalDependencies:
fsevents "~2.3.2"
client-only@0.0.1:
version "0.0.1"
resolved "https://registry.npmjs.org/client-only/-/client-only-0.0.1.tgz"
integrity sha512-IV3Ou0jSMzZrd3pZ48nLkT9DA7Ag1pnPzaiQhpW7c3RbcqqzvzzVu+L8gfqMp/8IM2MQtSiqaCxrrcfu8I8rMA==
color-convert@^2.0.1:
version "2.0.1"
resolved "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz"
integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==
dependencies:
color-name "~1.1.4"
color-name@^1.0.0, color-name@^1.1.4, color-name@~1.1.4:
version "1.1.4"
resolved "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz"
integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==
color-string@^1.9.0:
version "1.9.1"
resolved "https://registry.npmjs.org/color-string/-/color-string-1.9.1.tgz"
integrity sha512-shrVawQFojnZv6xM40anx4CkoDP+fZsw/ZerEMsW/pyzsRbElpsL/DBVW7q3ExxwusdNXI3lXpuhEZkzs8p5Eg==
dependencies:
color-name "^1.0.0"
simple-swizzle "^0.2.2"
color@^4.2:
version "4.2.3"
resolved "https://registry.npmjs.org/color/-/color-4.2.3.tgz"
integrity sha512-1rXeuUUiGGrykh+CeBdu5Ie7OJwinCgQY0bc7GCRxy5xVHy+moaqkpL/jqQq0MtQOeYcrqEz4abc5f0KtU7W4A==
dependencies:
color-convert "^2.0.1"
color-string "^1.9.0"
comma-separated-tokens@^2.0.0:
version "2.0.3"
resolved "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz"
integrity sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==
commander@^4.0.0:
version "4.1.1"
resolved "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz"
integrity sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==
concat-map@0.0.1:
version "0.0.1"
resolved "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz"
integrity sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==
cross-spawn@^7.0.2, cross-spawn@^7.0.3:
version "7.0.3"
resolved "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz"
integrity sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==
dependencies:
path-key "^3.1.0"
shebang-command "^2.0.0"
which "^2.0.1"
css-selector-tokenizer@^0.8.0:
version "0.8.0"
resolved "https://registry.npmjs.org/css-selector-tokenizer/-/css-selector-tokenizer-0.8.0.tgz"
integrity sha512-Jd6Ig3/pe62/qe5SBPTN8h8LeUg/pT4lLgtavPf7updwwHpvFzxvOQBHYj2LZDMjUnBzgvIUSjRcf6oT5HzHFg==
dependencies:
cssesc "^3.0.0"
fastparse "^1.1.2"
cssesc@^3.0.0:
version "3.0.0"
resolved "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz"
integrity sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==
csstype@^3.0.2:
version "3.1.2"
resolved "https://registry.npmjs.org/csstype/-/csstype-3.1.2.tgz"
integrity sha512-I7K1Uu0MBPzaFKg4nI5Q7Vs2t+3gWWW648spaF+Rg7pI9ds18Ugn+lvg4SHczUdKlHI5LWBXyqfS8+DufyBsgQ==
daisyui@^2.51.5:
version "2.51.5"
resolved "https://registry.npmjs.org/daisyui/-/daisyui-2.51.5.tgz"
integrity sha512-L05dRw0tasmz2Ha+10LhftEGLq4kaA8vRR/T0wDaXfHwqcgsf81jfXDJ6NlZ63Z7Rl1k3rj7UHs0l0p7CM3aYA==
dependencies:
color "^4.2"
css-selector-tokenizer "^0.8.0"
postcss-js "^4.0.0"
tailwindcss "^3"
damerau-levenshtein@^1.0.8:
version "1.0.8"
resolved "https://registry.npmjs.org/damerau-levenshtein/-/damerau-levenshtein-1.0.8.tgz"
integrity sha512-sdQSFB7+llfUcQHUQO3+B8ERRj0Oa4w9POWMI/puGtuf7gFywGmkaLCElnudfTiKZV+NvHqL0ifzdrI8Ro7ESA==
debug@^3.2.7:
version "3.2.7"
resolved "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz"
integrity sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==
dependencies:
ms "^2.1.1"
debug@^4.0.0, debug@^4.1.1, debug@^4.3.2, debug@^4.3.4:
version "4.3.4"
resolved "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz"
integrity sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==
dependencies:
ms "2.1.2"
decode-named-character-reference@^1.0.0:
version "1.0.2"
resolved "https://registry.npmjs.org/decode-named-character-reference/-/decode-named-character-reference-1.0.2.tgz"
integrity sha512-O8x12RzrUF8xyVcY0KJowWsmaJxQbmy0/EtnNtHRpsOcT7dFk5W598coHqBVpmWo1oQQfsCqfCmkZN5DJrZVdg==
dependencies:
character-entities "^2.0.0"
deep-equal@^2.0.5:
version "2.2.0"
resolved "https://registry.npmjs.org/deep-equal/-/deep-equal-2.2.0.tgz"
integrity sha512-RdpzE0Hv4lhowpIUKKMJfeH6C1pXdtT1/it80ubgWqwI3qpuxUBpC1S4hnHg+zjnuOoDkzUtUCEEkG+XG5l3Mw==
dependencies:
call-bind "^1.0.2"
es-get-iterator "^1.1.2"
get-intrinsic "^1.1.3"
is-arguments "^1.1.1"
is-array-buffer "^3.0.1"
is-date-object "^1.0.5"
is-regex "^1.1.4"
is-shared-array-buffer "^1.0.2"
isarray "^2.0.5"
object-is "^1.1.5"
object-keys "^1.1.1"
object.assign "^4.1.4"
regexp.prototype.flags "^1.4.3"
side-channel "^1.0.4"
which-boxed-primitive "^1.0.2"
which-collection "^1.0.1"
which-typed-array "^1.1.9"
deep-is@^0.1.3:
version "0.1.4"
resolved "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz"
integrity sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==
define-lazy-prop@^2.0.0:
version "2.0.0"
resolved "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-2.0.0.tgz"
integrity sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==
define-properties@^1.1.3, define-properties@^1.1.4:
version "1.2.0"
resolved "https://registry.npmjs.org/define-properties/-/define-properties-1.2.0.tgz"
integrity sha512-xvqAVKGfT1+UAvPwKTVw/njhdQ8ZhXK4lI0bCIuCMrp2up9nPnaDftrLtmpTazqd1o+UY4zgzU+avtMbDP+ldA==
dependencies:
has-property-descriptors "^1.0.0"
object-keys "^1.1.1"
dequal@^2.0.0:
version "2.0.3"
resolved "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz"
integrity sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==
didyoumean@^1.2.2:
version "1.2.2"
resolved "https://registry.npmjs.org/didyoumean/-/didyoumean-1.2.2.tgz"
integrity sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==
diff@^5.0.0:
version "5.1.0"
resolved "https://registry.npmjs.org/diff/-/diff-5.1.0.tgz"
integrity sha512-D+mk+qE8VC/PAUrlAU34N+VfXev0ghe5ywmpqrawphmVZc1bEfn56uo9qpyGp1p4xpzOHkSW4ztBd6L7Xx4ACw==
dir-glob@^3.0.1:
version "3.0.1"
resolved "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz"
integrity sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==
dependencies:
path-type "^4.0.0"
dlv@^1.1.3:
version "1.1.3"
resolved "https://registry.npmjs.org/dlv/-/dlv-1.1.3.tgz"
integrity sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==
doctrine@^2.1.0:
version "2.1.0"
resolved "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz"
integrity sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==
dependencies:
esutils "^2.0.2"
doctrine@^3.0.0:
version "3.0.0"
resolved "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz"
integrity sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==
dependencies:
esutils "^2.0.2"
electron-to-chromium@^1.4.284:
version "1.4.348"
resolved "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.348.tgz"
integrity sha512-gM7TdwuG3amns/1rlgxMbeeyNoBFPa+4Uu0c7FeROWh4qWmvSOnvcslKmWy51ggLKZ2n/F/4i2HJ+PVNxH9uCQ==
emoji-regex@^9.2.2:
version "9.2.2"
resolved "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz"
integrity sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==
enhanced-resolve@^5.12.0:
version "5.12.0"
resolved "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.12.0.tgz"
integrity sha512-QHTXI/sZQmko1cbDoNAa3mJ5qhWUUNAq3vR0/YiD379fWQrcfuoX1+HW2S0MTt7XmoPLapdaDKUtelUSPic7hQ==
dependencies:
graceful-fs "^4.2.4"
tapable "^2.2.0"
es-abstract@^1.19.0, es-abstract@^1.20.4:
version "1.21.2"
resolved "https://registry.npmjs.org/es-abstract/-/es-abstract-1.21.2.tgz"
integrity sha512-y/B5POM2iBnIxCiernH1G7rC9qQoM77lLIMQLuob0zhp8C56Po81+2Nj0WFKnd0pNReDTnkYryc+zhOzpEIROg==
dependencies:
array-buffer-byte-length "^1.0.0"
available-typed-arrays "^1.0.5"
call-bind "^1.0.2"
es-set-tostringtag "^2.0.1"
es-to-primitive "^1.2.1"
function.prototype.name "^1.1.5"
get-intrinsic "^1.2.0"
get-symbol-description "^1.0.0"
globalthis "^1.0.3"
gopd "^1.0.1"
has "^1.0.3"
has-property-descriptors "^1.0.0"
has-proto "^1.0.1"
has-symbols "^1.0.3"
internal-slot "^1.0.5"
is-array-buffer "^3.0.2"
is-callable "^1.2.7"
is-negative-zero "^2.0.2"
is-regex "^1.1.4"
is-shared-array-buffer "^1.0.2"
is-string "^1.0.7"
is-typed-array "^1.1.10"
is-weakref "^1.0.2"
object-inspect "^1.12.3"
object-keys "^1.1.1"
object.assign "^4.1.4"
regexp.prototype.flags "^1.4.3"
safe-regex-test "^1.0.0"
string.prototype.trim "^1.2.7"
string.prototype.trimend "^1.0.6"
string.prototype.trimstart "^1.0.6"
typed-array-length "^1.0.4"
unbox-primitive "^1.0.2"
which-typed-array "^1.1.9"
es-get-iterator@^1.1.2:
version "1.1.3"
resolved "https://registry.npmjs.org/es-get-iterator/-/es-get-iterator-1.1.3.tgz"
integrity sha512-sPZmqHBe6JIiTfN5q2pEi//TwxmAFHwj/XEuYjTuse78i8KxaqMTTzxPoFKuzRpDpTJ+0NAbpfenkmH2rePtuw==
dependencies:
call-bind "^1.0.2"
get-intrinsic "^1.1.3"
has-symbols "^1.0.3"
is-arguments "^1.1.1"
is-map "^2.0.2"
is-set "^2.0.2"
is-string "^1.0.7"
isarray "^2.0.5"
stop-iteration-iterator "^1.0.0"
es-set-tostringtag@^2.0.1:
version "2.0.1"
resolved "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.0.1.tgz"
integrity sha512-g3OMbtlwY3QewlqAiMLI47KywjWZoEytKr8pf6iTC8uJq5bIAH52Z9pnQ8pVL6whrCto53JZDuUIsifGeLorTg==
dependencies:
get-intrinsic "^1.1.3"
has "^1.0.3"
has-tostringtag "^1.0.0"
es-shim-unscopables@^1.0.0:
version "1.0.0"
resolved "https://registry.npmjs.org/es-shim-unscopables/-/es-shim-unscopables-1.0.0.tgz"
integrity sha512-Jm6GPcCdC30eMLbZ2x8z2WuRwAws3zTBBKuusffYVUrNj/GVSUAZ+xKMaUpfNDR5IbyNA5LJbaecoUVbmUcB1w==
dependencies:
has "^1.0.3"
es-to-primitive@^1.2.1:
version "1.2.1"
resolved "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz"
integrity sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==
dependencies:
is-callable "^1.1.4"
is-date-object "^1.0.1"
is-symbol "^1.0.2"
escalade@^3.1.1:
version "3.1.1"
resolved "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz"
integrity sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==
escape-string-regexp@^4.0.0:
version "4.0.0"
resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz"
integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==
eslint-config-next@13.2.4:
version "13.2.4"
resolved "https://registry.npmjs.org/eslint-config-next/-/eslint-config-next-13.2.4.tgz"
integrity sha512-lunIBhsoeqw6/Lfkd6zPt25w1bn0znLA/JCL+au1HoEpSb4/PpsOYsYtgV/q+YPsoKIOzFyU5xnb04iZnXjUvg==
dependencies:
"@next/eslint-plugin-next" "13.2.4"
"@rushstack/eslint-patch" "^1.1.3"
"@typescript-eslint/parser" "^5.42.0"
eslint-import-resolver-node "^0.3.6"
eslint-import-resolver-typescript "^3.5.2"
eslint-plugin-import "^2.26.0"
eslint-plugin-jsx-a11y "^6.5.1"
eslint-plugin-react "^7.31.7"
eslint-plugin-react-hooks "^4.5.0"
eslint-import-resolver-node@^0.3.6, eslint-import-resolver-node@^0.3.7:
version "0.3.7"
resolved "https://registry.npmjs.org/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.7.tgz"
integrity sha512-gozW2blMLJCeFpBwugLTGyvVjNoeo1knonXAcatC6bjPBZitotxdWf7Gimr25N4c0AAOo4eOUfaG82IJPDpqCA==
dependencies:
debug "^3.2.7"
is-core-module "^2.11.0"
resolve "^1.22.1"
eslint-import-resolver-typescript@^3.5.2:
version "3.5.4"
resolved "https://registry.npmjs.org/eslint-import-resolver-typescript/-/eslint-import-resolver-typescript-3.5.4.tgz"
integrity sha512-9xUpnedEmSfG57sN1UvWPiEhfJ8bPt0Wg2XysA7Mlc79iFGhmJtRUg9LxtkK81FhMUui0YuR2E8iUsVhePkh4A==
dependencies:
debug "^4.3.4"
enhanced-resolve "^5.12.0"
get-tsconfig "^4.5.0"
globby "^13.1.3"
is-core-module "^2.11.0"
is-glob "^4.0.3"
synckit "^0.8.5"
eslint-module-utils@^2.7.4:
version "2.7.4"
resolved "https://registry.npmjs.org/eslint-module-utils/-/eslint-module-utils-2.7.4.tgz"
integrity sha512-j4GT+rqzCoRKHwURX7pddtIPGySnX9Si/cgMI5ztrcqOPtk5dDEeZ34CQVPphnqkJytlc97Vuk05Um2mJ3gEQA==
dependencies:
debug "^3.2.7"
eslint-plugin-import@^2.26.0:
version "2.27.5"
resolved "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.27.5.tgz"
integrity sha512-LmEt3GVofgiGuiE+ORpnvP+kAm3h6MLZJ4Q5HCyHADofsb4VzXFsRiWj3c0OFiV+3DWFh0qg3v9gcPlfc3zRow==
dependencies:
array-includes "^3.1.6"
array.prototype.flat "^1.3.1"
array.prototype.flatmap "^1.3.1"
debug "^3.2.7"
doctrine "^2.1.0"
eslint-import-resolver-node "^0.3.7"
eslint-module-utils "^2.7.4"
has "^1.0.3"
is-core-module "^2.11.0"
is-glob "^4.0.3"
minimatch "^3.1.2"
object.values "^1.1.6"
resolve "^1.22.1"
semver "^6.3.0"
tsconfig-paths "^3.14.1"
eslint-plugin-jsx-a11y@^6.5.1:
version "6.7.1"
resolved "https://registry.npmjs.org/eslint-plugin-jsx-a11y/-/eslint-plugin-jsx-a11y-6.7.1.tgz"
integrity sha512-63Bog4iIethyo8smBklORknVjB0T2dwB8Mr/hIC+fBS0uyHdYYpzM/Ed+YC8VxTjlXHEWFOdmgwcDn1U2L9VCA==
dependencies:
"@babel/runtime" "^7.20.7"
aria-query "^5.1.3"
array-includes "^3.1.6"
array.prototype.flatmap "^1.3.1"
ast-types-flow "^0.0.7"
axe-core "^4.6.2"
axobject-query "^3.1.1"
damerau-levenshtein "^1.0.8"
emoji-regex "^9.2.2"
has "^1.0.3"
jsx-ast-utils "^3.3.3"
language-tags "=1.0.5"
minimatch "^3.1.2"
object.entries "^1.1.6"
object.fromentries "^2.0.6"
semver "^6.3.0"
eslint-plugin-react-hooks@^4.5.0:
version "4.6.0"
resolved "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-4.6.0.tgz"
integrity sha512-oFc7Itz9Qxh2x4gNHStv3BqJq54ExXmfC+a1NjAta66IAN87Wu0R/QArgIS9qKzX3dXKPI9H5crl9QchNMY9+g==
eslint-plugin-react@^7.31.7:
version "7.32.2"
resolved "https://registry.npmjs.org/eslint-plugin-react/-/eslint-plugin-react-7.32.2.tgz"
integrity sha512-t2fBMa+XzonrrNkyVirzKlvn5RXzzPwRHtMvLAtVZrt8oxgnTQaYbU6SXTOO1mwQgp1y5+toMSKInnzGr0Knqg==
dependencies:
array-includes "^3.1.6"
array.prototype.flatmap "^1.3.1"
array.prototype.tosorted "^1.1.1"
doctrine "^2.1.0"
estraverse "^5.3.0"
jsx-ast-utils "^2.4.1 || ^3.0.0"
minimatch "^3.1.2"
object.entries "^1.1.6"
object.fromentries "^2.0.6"
object.hasown "^1.1.2"
object.values "^1.1.6"
prop-types "^15.8.1"
resolve "^2.0.0-next.4"
semver "^6.3.0"
string.prototype.matchall "^4.0.8"
eslint-scope@^7.1.1:
version "7.1.1"
resolved "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.1.1.tgz"
integrity sha512-QKQM/UXpIiHcLqJ5AOyIW7XZmzjkzQXYE54n1++wb0u9V/abW3l9uQnxX8Z5Xd18xyKIMTUAyQ0k1e8pz6LUrw==
dependencies:
esrecurse "^4.3.0"
estraverse "^5.2.0"
eslint-visitor-keys@^3.3.0, eslint-visitor-keys@^3.4.0:
version "3.4.0"
resolved "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.0.tgz"
integrity sha512-HPpKPUBQcAsZOsHAFwTtIKcYlCje62XB7SEAcxjtmW6TD1WVpkS6i6/hOVtTZIl4zGj/mBqpFVGvaDneik+VoQ==
eslint@8.37.0:
version "8.37.0"
resolved "https://registry.npmjs.org/eslint/-/eslint-8.37.0.tgz"
integrity sha512-NU3Ps9nI05GUoVMxcZx1J8CNR6xOvUT4jAUMH5+z8lpp3aEdPVCImKw6PWG4PY+Vfkpr+jvMpxs/qoE7wq0sPw==
dependencies:
"@eslint-community/eslint-utils" "^4.2.0"
"@eslint-community/regexpp" "^4.4.0"
"@eslint/eslintrc" "^2.0.2"
"@eslint/js" "8.37.0"
"@humanwhocodes/config-array" "^0.11.8"
"@humanwhocodes/module-importer" "^1.0.1"
"@nodelib/fs.walk" "^1.2.8"
ajv "^6.10.0"
chalk "^4.0.0"
cross-spawn "^7.0.2"
debug "^4.3.2"
doctrine "^3.0.0"
escape-string-regexp "^4.0.0"
eslint-scope "^7.1.1"
eslint-visitor-keys "^3.4.0"
espree "^9.5.1"
esquery "^1.4.2"
esutils "^2.0.2"
fast-deep-equal "^3.1.3"
file-entry-cache "^6.0.1"
find-up "^5.0.0"
glob-parent "^6.0.2"
globals "^13.19.0"
grapheme-splitter "^1.0.4"
ignore "^5.2.0"
import-fresh "^3.0.0"
imurmurhash "^0.1.4"
is-glob "^4.0.0"
is-path-inside "^3.0.3"
js-sdsl "^4.1.4"
js-yaml "^4.1.0"
json-stable-stringify-without-jsonify "^1.0.1"
levn "^0.4.1"
lodash.merge "^4.6.2"
minimatch "^3.1.2"
natural-compare "^1.4.0"
optionator "^0.9.1"
strip-ansi "^6.0.1"
strip-json-comments "^3.1.0"
text-table "^0.2.0"
espree@^9.5.1:
version "9.5.1"
resolved "https://registry.npmjs.org/espree/-/espree-9.5.1.tgz"
integrity sha512-5yxtHSZXRSW5pvv3hAlXM5+/Oswi1AUFqBmbibKb5s6bp3rGIDkyXU6xCoyuuLhijr4SFwPrXRoZjz0AZDN9tg==
dependencies:
acorn "^8.8.0"
acorn-jsx "^5.3.2"
eslint-visitor-keys "^3.4.0"
esprima@^4.0.0:
version "4.0.1"
resolved "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz"
integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==
esquery@^1.4.2:
version "1.5.0"
resolved "https://registry.npmjs.org/esquery/-/esquery-1.5.0.tgz"
integrity sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg==
dependencies:
estraverse "^5.1.0"
esrecurse@^4.3.0:
version "4.3.0"
resolved "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz"
integrity sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==
dependencies:
estraverse "^5.2.0"
estraverse@^5.1.0, estraverse@^5.2.0, estraverse@^5.3.0:
version "5.3.0"
resolved "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz"
integrity sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==
esutils@^2.0.2:
version "2.0.3"
resolved "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz"
integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==
extend-shallow@^2.0.1:
version "2.0.1"
resolved "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz"
integrity sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug==
dependencies:
is-extendable "^0.1.0"
extend@^3.0.0:
version "3.0.2"
resolved "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz"
integrity sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==
fast-deep-equal@^3.1.1, fast-deep-equal@^3.1.3:
version "3.1.3"
resolved "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz"
integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==
fast-glob@^3.2.11, fast-glob@^3.2.12, fast-glob@^3.2.9:
version "3.2.12"
resolved "https://registry.npmjs.org/fast-glob/-/fast-glob-3.2.12.tgz"
integrity sha512-DVj4CQIYYow0BlaelwK1pHl5n5cRSJfM60UA0zK891sVInoPri2Ekj7+e1CT3/3qxXenpI+nBBmQAcJPJgaj4w==
dependencies:
"@nodelib/fs.stat" "^2.0.2"
"@nodelib/fs.walk" "^1.2.3"
glob-parent "^5.1.2"
merge2 "^1.3.0"
micromatch "^4.0.4"
fast-json-stable-stringify@^2.0.0:
version "2.1.0"
resolved "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz"
integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==
fast-levenshtein@^2.0.6:
version "2.0.6"
resolved "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz"
integrity sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==
fastparse@^1.1.2:
version "1.1.2"
resolved "https://registry.npmjs.org/fastparse/-/fastparse-1.1.2.tgz"
integrity sha512-483XLLxTVIwWK3QTrMGRqUfUpoOs/0hbQrl2oz4J0pAcm3A3bu84wxTFqGqkJzewCLdME38xJLJAxBABfQT8sQ==
fastq@^1.6.0:
version "1.15.0"
resolved "https://registry.npmjs.org/fastq/-/fastq-1.15.0.tgz"
integrity sha512-wBrocU2LCXXa+lWBt8RoIRD89Fi8OdABODa/kEnyeyjS5aZO5/GNvI5sEINADqP/h8M29UHTHUb53sUu5Ihqdw==
dependencies:
reusify "^1.0.4"
file-entry-cache@^6.0.1:
version "6.0.1"
resolved "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz"
integrity sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==
dependencies:
flat-cache "^3.0.4"
fill-range@^7.0.1:
version "7.0.1"
resolved "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz"
integrity sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==
dependencies:
to-regex-range "^5.0.1"
find-up@^5.0.0:
version "5.0.0"
resolved "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz"
integrity sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==
dependencies:
locate-path "^6.0.0"
path-exists "^4.0.0"
flat-cache@^3.0.4:
version "3.0.4"
resolved "https://registry.npmjs.org/flat-cache/-/flat-cache-3.0.4.tgz"
integrity sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg==
dependencies:
flatted "^3.1.0"
rimraf "^3.0.2"
flatted@^3.1.0:
version "3.2.7"
resolved "https://registry.npmjs.org/flatted/-/flatted-3.2.7.tgz"
integrity sha512-5nqDSxl8nn5BSNxyR3n4I6eDmbolI6WT+QqR547RwxQapgjQBmtktdP+HTBb/a/zLsbzERTONyUB5pefh5TtjQ==
for-each@^0.3.3:
version "0.3.3"
resolved "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz"
integrity sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==
dependencies:
is-callable "^1.1.3"
fraction.js@^4.2.0:
version "4.2.0"
resolved "https://registry.npmjs.org/fraction.js/-/fraction.js-4.2.0.tgz"
integrity sha512-MhLuK+2gUcnZe8ZHlaaINnQLl0xRIGRfcGk2yl8xoQAfHrSsL3rYu6FCmBdkdbhc9EPlwyGHewaRsvwRMJtAlA==
fs.realpath@^1.0.0:
version "1.0.0"
resolved "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz"
integrity sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==
fsevents@~2.3.2:
version "2.3.2"
resolved "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz"
integrity sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==
function-bind@^1.1.1:
version "1.1.1"
resolved "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz"
integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==
function.prototype.name@^1.1.5:
version "1.1.5"
resolved "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.5.tgz"
integrity sha512-uN7m/BzVKQnCUF/iW8jYea67v++2u7m5UgENbHRtdDVclOUP+FMPlCNdmk0h/ysGyo2tavMJEDqJAkJdRa1vMA==
dependencies:
call-bind "^1.0.2"
define-properties "^1.1.3"
es-abstract "^1.19.0"
functions-have-names "^1.2.2"
functions-have-names@^1.2.2:
version "1.2.3"
resolved "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz"
integrity sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==
get-intrinsic@^1.0.2, get-intrinsic@^1.1.1, get-intrinsic@^1.1.3, get-intrinsic@^1.2.0:
version "1.2.0"
resolved "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.0.tgz"
integrity sha512-L049y6nFOuom5wGyRc3/gdTLO94dySVKRACj1RmJZBQXlbTMhtNIgkWkUHq+jYmZvKf14EW1EoJnnjbmoHij0Q==
dependencies:
function-bind "^1.1.1"
has "^1.0.3"
has-symbols "^1.0.3"
get-symbol-description@^1.0.0:
version "1.0.0"
resolved "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.0.0.tgz"
integrity sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw==
dependencies:
call-bind "^1.0.2"
get-intrinsic "^1.1.1"
get-tsconfig@^4.5.0:
version "4.5.0"
resolved "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.5.0.tgz"
integrity sha512-MjhiaIWCJ1sAU4pIQ5i5OfOuHHxVo1oYeNsWTON7jxYkod8pHocXeh+SSbmu5OZZZK73B6cbJ2XADzXehLyovQ==
glob-parent@^5.1.2, glob-parent@~5.1.2:
version "5.1.2"
resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz"
integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==
dependencies:
is-glob "^4.0.1"
glob-parent@^6.0.2:
version "6.0.2"
resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz"
integrity sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==
dependencies:
is-glob "^4.0.3"
glob@7.1.6:
version "7.1.6"
resolved "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz"
integrity sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==
dependencies:
fs.realpath "^1.0.0"
inflight "^1.0.4"
inherits "2"
minimatch "^3.0.4"
once "^1.3.0"
path-is-absolute "^1.0.0"
glob@7.1.7, glob@^7.1.3:
version "7.1.7"
resolved "https://registry.npmjs.org/glob/-/glob-7.1.7.tgz"
integrity sha512-OvD9ENzPLbegENnYP5UUfJIirTg4+XwMWGaQfQTY0JenxNvvIKP3U3/tAQSPIu/lHxXYSZmpXlUHeqAIdKzBLQ==
dependencies:
fs.realpath "^1.0.0"
inflight "^1.0.4"
inherits "2"
minimatch "^3.0.4"
once "^1.3.0"
path-is-absolute "^1.0.0"
globals@^13.19.0:
version "13.20.0"
resolved "https://registry.npmjs.org/globals/-/globals-13.20.0.tgz"
integrity sha512-Qg5QtVkCy/kv3FUSlu4ukeZDVf9ee0iXLAUYX13gbR17bnejFTzr4iS9bY7kwCf1NztRNm1t91fjOiyx4CSwPQ==
dependencies:
type-fest "^0.20.2"
globalthis@^1.0.3:
version "1.0.3"
resolved "https://registry.npmjs.org/globalthis/-/globalthis-1.0.3.tgz"
integrity sha512-sFdI5LyBiNTHjRd7cGPWapiHWMOXKyuBNX/cWJ3NfzrZQVa8GI/8cofCl74AOVqq9W5kNmguTIzJ/1s2gyI9wA==
dependencies:
define-properties "^1.1.3"
globalyzer@0.1.0:
version "0.1.0"
resolved "https://registry.npmjs.org/globalyzer/-/globalyzer-0.1.0.tgz"
integrity sha512-40oNTM9UfG6aBmuKxk/giHn5nQ8RVz/SS4Ir6zgzOv9/qC3kKZ9v4etGTcJbEl/NyVQH7FGU7d+X1egr57Md2Q==
globby@^11.1.0:
version "11.1.0"
resolved "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz"
integrity sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==
dependencies:
array-union "^2.1.0"
dir-glob "^3.0.1"
fast-glob "^3.2.9"
ignore "^5.2.0"
merge2 "^1.4.1"
slash "^3.0.0"
globby@^13.1.3:
version "13.1.3"
resolved "https://registry.npmjs.org/globby/-/globby-13.1.3.tgz"
integrity sha512-8krCNHXvlCgHDpegPzleMq07yMYTO2sXKASmZmquEYWEmCx6J5UTRbp5RwMJkTJGtcQ44YpiUYUiN0b9mzy8Bw==
dependencies:
dir-glob "^3.0.1"
fast-glob "^3.2.11"
ignore "^5.2.0"
merge2 "^1.4.1"
slash "^4.0.0"
globrex@^0.1.2:
version "0.1.2"
resolved "https://registry.npmjs.org/globrex/-/globrex-0.1.2.tgz"
integrity sha512-uHJgbwAMwNFf5mLst7IWLNg14x1CkeqglJb/K3doi4dw6q2IvAAmM/Y81kevy83wP+Sst+nutFTYOGg3d1lsxg==
gopd@^1.0.1:
version "1.0.1"
resolved "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz"
integrity sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==
dependencies:
get-intrinsic "^1.1.3"
graceful-fs@^4.2.4:
version "4.2.11"
resolved "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz"
integrity sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==
grapheme-splitter@^1.0.4:
version "1.0.4"
resolved "https://registry.npmjs.org/grapheme-splitter/-/grapheme-splitter-1.0.4.tgz"
integrity sha512-bzh50DW9kTPM00T8y4o8vQg89Di9oLJVLW/KaOGIXJWP/iqCN6WKYkbNOF04vFLJhwcpYUh9ydh/+5vpOqV4YQ==
gray-matter@^4.0.3:
version "4.0.3"
resolved "https://registry.npmjs.org/gray-matter/-/gray-matter-4.0.3.tgz"
integrity sha512-5v6yZd4JK3eMI3FqqCouswVqwugaA9r4dNZB1wwcmrD02QkV5H0y7XBQW8QwQqEaZY1pM9aqORSORhJRdNK44Q==
dependencies:
js-yaml "^3.13.1"
kind-of "^6.0.2"
section-matter "^1.0.0"
strip-bom-string "^1.0.0"
has-bigints@^1.0.1, has-bigints@^1.0.2:
version "1.0.2"
resolved "https://registry.npmjs.org/has-bigints/-/has-bigints-1.0.2.tgz"
integrity sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==
has-flag@^4.0.0:
version "4.0.0"
resolved "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz"
integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==
has-property-descriptors@^1.0.0:
version "1.0.0"
resolved "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz"
integrity sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ==
dependencies:
get-intrinsic "^1.1.1"
has-proto@^1.0.1:
version "1.0.1"
resolved "https://registry.npmjs.org/has-proto/-/has-proto-1.0.1.tgz"
integrity sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg==
has-symbols@^1.0.2, has-symbols@^1.0.3:
version "1.0.3"
resolved "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz"
integrity sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==
has-tostringtag@^1.0.0:
version "1.0.0"
resolved "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.0.tgz"
integrity sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==
dependencies:
has-symbols "^1.0.2"
has@^1.0.3:
version "1.0.3"
resolved "https://registry.npmjs.org/has/-/has-1.0.3.tgz"
integrity sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==
dependencies:
function-bind "^1.1.1"
hast-util-from-parse5@^7.0.0:
version "7.1.2"
resolved "https://registry.npmjs.org/hast-util-from-parse5/-/hast-util-from-parse5-7.1.2.tgz"
integrity sha512-Nz7FfPBuljzsN3tCQ4kCBKqdNhQE2l0Tn+X1ubgKBPRoiDIu1mL08Cfw4k7q71+Duyaw7DXDN+VTAp4Vh3oCOw==
dependencies:
"@types/hast" "^2.0.0"
"@types/unist" "^2.0.0"
hastscript "^7.0.0"
property-information "^6.0.0"
vfile "^5.0.0"
vfile-location "^4.0.0"
web-namespaces "^2.0.0"
hast-util-parse-selector@^3.0.0:
version "3.1.1"
resolved "https://registry.npmjs.org/hast-util-parse-selector/-/hast-util-parse-selector-3.1.1.tgz"
integrity sha512-jdlwBjEexy1oGz0aJ2f4GKMaVKkA9jwjr4MjAAI22E5fM/TXVZHuS5OpONtdeIkRKqAaryQ2E9xNQxijoThSZA==
dependencies:
"@types/hast" "^2.0.0"
hast-util-raw@^7.0.0:
version "7.2.3"
resolved "https://registry.npmjs.org/hast-util-raw/-/hast-util-raw-7.2.3.tgz"
integrity sha512-RujVQfVsOrxzPOPSzZFiwofMArbQke6DJjnFfceiEbFh7S05CbPt0cYN+A5YeD3pso0JQk6O1aHBnx9+Pm2uqg==
dependencies:
"@types/hast" "^2.0.0"
"@types/parse5" "^6.0.0"
hast-util-from-parse5 "^7.0.0"
hast-util-to-parse5 "^7.0.0"
html-void-elements "^2.0.0"
parse5 "^6.0.0"
unist-util-position "^4.0.0"
unist-util-visit "^4.0.0"
vfile "^5.0.0"
web-namespaces "^2.0.0"
zwitch "^2.0.0"
hast-util-sanitize@^4.0.0:
version "4.1.0"
resolved "https://registry.npmjs.org/hast-util-sanitize/-/hast-util-sanitize-4.1.0.tgz"
integrity sha512-Hd9tU0ltknMGRDv+d6Ro/4XKzBqQnP/EZrpiTbpFYfXv/uOhWeKc+2uajcbEvAEH98VZd7eII2PiXm13RihnLw==
dependencies:
"@types/hast" "^2.0.0"
hast-util-to-html@^8.0.0:
version "8.0.4"
resolved "https://registry.npmjs.org/hast-util-to-html/-/hast-util-to-html-8.0.4.tgz"
integrity sha512-4tpQTUOr9BMjtYyNlt0P50mH7xj0Ks2xpo8M943Vykljf99HW6EzulIoJP1N3eKOSScEHzyzi9dm7/cn0RfGwA==
dependencies:
"@types/hast" "^2.0.0"
"@types/unist" "^2.0.0"
ccount "^2.0.0"
comma-separated-tokens "^2.0.0"
hast-util-raw "^7.0.0"
hast-util-whitespace "^2.0.0"
html-void-elements "^2.0.0"
property-information "^6.0.0"
space-separated-tokens "^2.0.0"
stringify-entities "^4.0.0"
zwitch "^2.0.4"
hast-util-to-parse5@^7.0.0:
version "7.1.0"
resolved "https://registry.npmjs.org/hast-util-to-parse5/-/hast-util-to-parse5-7.1.0.tgz"
integrity sha512-YNRgAJkH2Jky5ySkIqFXTQiaqcAtJyVE+D5lkN6CdtOqrnkLfGYYrEcKuHOJZlp+MwjSwuD3fZuawI+sic/RBw==
dependencies:
"@types/hast" "^2.0.0"
comma-separated-tokens "^2.0.0"
property-information "^6.0.0"
space-separated-tokens "^2.0.0"
web-namespaces "^2.0.0"
zwitch "^2.0.0"
hast-util-whitespace@^2.0.0:
version "2.0.1"
resolved "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-2.0.1.tgz"
integrity sha512-nAxA0v8+vXSBDt3AnRUNjyRIQ0rD+ntpbAp4LnPkumc5M9yUbSMa4XDU9Q6etY4f1Wp4bNgvc1yjiZtsTTrSng==
hastscript@^7.0.0:
version "7.2.0"
resolved "https://registry.npmjs.org/hastscript/-/hastscript-7.2.0.tgz"
integrity sha512-TtYPq24IldU8iKoJQqvZOuhi5CyCQRAbvDOX0x1eW6rsHSxa/1i2CCiptNTotGHJ3VoHRGmqiv6/D3q113ikkw==
dependencies:
"@types/hast" "^2.0.0"
comma-separated-tokens "^2.0.0"
hast-util-parse-selector "^3.0.0"
property-information "^6.0.0"
space-separated-tokens "^2.0.0"
html-void-elements@^2.0.0:
version "2.0.1"
resolved "https://registry.npmjs.org/html-void-elements/-/html-void-elements-2.0.1.tgz"
integrity sha512-0quDb7s97CfemeJAnW9wC0hw78MtW7NU3hqtCD75g2vFlDLt36llsYD7uB7SUzojLMP24N5IatXf7ylGXiGG9A==
ignore@^5.2.0:
version "5.2.4"
resolved "https://registry.npmjs.org/ignore/-/ignore-5.2.4.tgz"
integrity sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ==
import-fresh@^3.0.0, import-fresh@^3.2.1:
version "3.3.0"
resolved "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz"
integrity sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==
dependencies:
parent-module "^1.0.0"
resolve-from "^4.0.0"
imurmurhash@^0.1.4:
version "0.1.4"
resolved "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz"
integrity sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==
inflight@^1.0.4:
version "1.0.6"
resolved "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz"
integrity sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==
dependencies:
once "^1.3.0"
wrappy "1"
inherits@2:
version "2.0.4"
resolved "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz"
integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
internal-slot@^1.0.3, internal-slot@^1.0.4, internal-slot@^1.0.5:
version "1.0.5"
resolved "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.5.tgz"
integrity sha512-Y+R5hJrzs52QCG2laLn4udYVnxsfny9CpOhNhUvk/SSSVyF6T27FzRbF0sroPidSu3X8oEAkOn2K804mjpt6UQ==
dependencies:
get-intrinsic "^1.2.0"
has "^1.0.3"
side-channel "^1.0.4"
is-arguments@^1.1.1:
version "1.1.1"
resolved "https://registry.npmjs.org/is-arguments/-/is-arguments-1.1.1.tgz"
integrity sha512-8Q7EARjzEnKpt/PCD7e1cgUS0a6X8u5tdSiMqXhojOdoV9TsMsiO+9VLC5vAmO8N7/GmXn7yjR8qnA6bVAEzfA==
dependencies:
call-bind "^1.0.2"
has-tostringtag "^1.0.0"
is-array-buffer@^3.0.1, is-array-buffer@^3.0.2:
version "3.0.2"
resolved "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.2.tgz"
integrity sha512-y+FyyR/w8vfIRq4eQcM1EYgSTnmHXPqaF+IgzgraytCFq5Xh8lllDVmAZolPJiZttZLeFSINPYMaEJ7/vWUa1w==
dependencies:
call-bind "^1.0.2"
get-intrinsic "^1.2.0"
is-typed-array "^1.1.10"
is-arrayish@^0.3.1:
version "0.3.2"
resolved "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.3.2.tgz"
integrity sha512-eVRqCvVlZbuw3GrM63ovNSNAeA1K16kaR/LRY/92w0zxQ5/1YzwblUX652i4Xs9RwAGjW9d9y6X88t8OaAJfWQ==
is-bigint@^1.0.1:
version "1.0.4"
resolved "https://registry.npmjs.org/is-bigint/-/is-bigint-1.0.4.tgz"
integrity sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==
dependencies:
has-bigints "^1.0.1"
is-binary-path@~2.1.0:
version "2.1.0"
resolved "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz"
integrity sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==
dependencies:
binary-extensions "^2.0.0"
is-boolean-object@^1.1.0:
version "1.1.2"
resolved "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.1.2.tgz"
integrity sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==
dependencies:
call-bind "^1.0.2"
has-tostringtag "^1.0.0"
is-buffer@^2.0.0:
version "2.0.5"
resolved "https://registry.npmjs.org/is-buffer/-/is-buffer-2.0.5.tgz"
integrity sha512-i2R6zNFDwgEHJyQUtJEk0XFi1i0dPFn/oqjK3/vPCcDeJvW5NQ83V8QbicfF1SupOaB0h8ntgBC2YiE7dfyctQ==
is-callable@^1.1.3, is-callable@^1.1.4, is-callable@^1.2.7:
version "1.2.7"
resolved "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz"
integrity sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==
is-core-module@^2.11.0, is-core-module@^2.9.0:
version "2.11.0"
resolved "https://registry.npmjs.org/is-core-module/-/is-core-module-2.11.0.tgz"
integrity sha512-RRjxlvLDkD1YJwDbroBHMb+cukurkDWNyHx7D3oNB5x9rb5ogcksMC5wHCadcXoo67gVr/+3GFySh3134zi6rw==
dependencies:
has "^1.0.3"
is-date-object@^1.0.1, is-date-object@^1.0.5:
version "1.0.5"
resolved "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.5.tgz"
integrity sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==
dependencies:
has-tostringtag "^1.0.0"
is-docker@^2.0.0, is-docker@^2.1.1:
version "2.2.1"
resolved "https://registry.npmjs.org/is-docker/-/is-docker-2.2.1.tgz"
integrity sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==
is-extendable@^0.1.0:
version "0.1.1"
resolved "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz"
integrity sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw==
is-extglob@^2.1.1:
version "2.1.1"
resolved "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz"
integrity sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==
is-glob@^4.0.0, is-glob@^4.0.1, is-glob@^4.0.3, is-glob@~4.0.1:
version "4.0.3"
resolved "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz"
integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==
dependencies:
is-extglob "^2.1.1"
is-map@^2.0.1, is-map@^2.0.2:
version "2.0.2"
resolved "https://registry.npmjs.org/is-map/-/is-map-2.0.2.tgz"
integrity sha512-cOZFQQozTha1f4MxLFzlgKYPTyj26picdZTx82hbc/Xf4K/tZOOXSCkMvU4pKioRXGDLJRn0GM7Upe7kR721yg==
is-negative-zero@^2.0.2:
version "2.0.2"
resolved "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.2.tgz"
integrity sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA==
is-number-object@^1.0.4:
version "1.0.7"
resolved "https://registry.npmjs.org/is-number-object/-/is-number-object-1.0.7.tgz"
integrity sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==
dependencies:
has-tostringtag "^1.0.0"
is-number@^7.0.0:
version "7.0.0"
resolved "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz"
integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==
is-path-inside@^3.0.3:
version "3.0.3"
resolved "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz"
integrity sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==
is-plain-obj@^4.0.0:
version "4.1.0"
resolved "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-4.1.0.tgz"
integrity sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==
is-regex@^1.1.4:
version "1.1.4"
resolved "https://registry.npmjs.org/is-regex/-/is-regex-1.1.4.tgz"
integrity sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==
dependencies:
call-bind "^1.0.2"
has-tostringtag "^1.0.0"
is-set@^2.0.1, is-set@^2.0.2:
version "2.0.2"
resolved "https://registry.npmjs.org/is-set/-/is-set-2.0.2.tgz"
integrity sha512-+2cnTEZeY5z/iXGbLhPrOAaK/Mau5k5eXq9j14CpRTftq0pAJu2MwVRSZhyZWBzx3o6X795Lz6Bpb6R0GKf37g==
is-shared-array-buffer@^1.0.2:
version "1.0.2"
resolved "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.2.tgz"
integrity sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA==
dependencies:
call-bind "^1.0.2"
is-string@^1.0.5, is-string@^1.0.7:
version "1.0.7"
resolved "https://registry.npmjs.org/is-string/-/is-string-1.0.7.tgz"
integrity sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==
dependencies:
has-tostringtag "^1.0.0"
is-symbol@^1.0.2, is-symbol@^1.0.3:
version "1.0.4"
resolved "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.4.tgz"
integrity sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==
dependencies:
has-symbols "^1.0.2"
is-typed-array@^1.1.10, is-typed-array@^1.1.9:
version "1.1.10"
resolved "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.10.tgz"
integrity sha512-PJqgEHiWZvMpaFZ3uTc8kHPM4+4ADTlDniuQL7cU/UDA0Ql7F70yGfHph3cLNe+c9toaigv+DFzTJKhc2CtO6A==
dependencies:
available-typed-arrays "^1.0.5"
call-bind "^1.0.2"
for-each "^0.3.3"
gopd "^1.0.1"
has-tostringtag "^1.0.0"
is-weakmap@^2.0.1:
version "2.0.1"
resolved "https://registry.npmjs.org/is-weakmap/-/is-weakmap-2.0.1.tgz"
integrity sha512-NSBR4kH5oVj1Uwvv970ruUkCV7O1mzgVFO4/rev2cLRda9Tm9HrL70ZPut4rOHgY0FNrUu9BCbXA2sdQ+x0chA==
is-weakref@^1.0.2:
version "1.0.2"
resolved "https://registry.npmjs.org/is-weakref/-/is-weakref-1.0.2.tgz"
integrity sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==
dependencies:
call-bind "^1.0.2"
is-weakset@^2.0.1:
version "2.0.2"
resolved "https://registry.npmjs.org/is-weakset/-/is-weakset-2.0.2.tgz"
integrity sha512-t2yVvttHkQktwnNNmBQ98AhENLdPUTDTE21uPqAQ0ARwQfGeQKRVS0NNurH7bTf7RrvcVn1OOge45CnBeHCSmg==
dependencies:
call-bind "^1.0.2"
get-intrinsic "^1.1.1"
is-wsl@^2.2.0:
version "2.2.0"
resolved "https://registry.npmjs.org/is-wsl/-/is-wsl-2.2.0.tgz"
integrity sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==
dependencies:
is-docker "^2.0.0"
isarray@^2.0.5:
version "2.0.5"
resolved "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz"
integrity sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==
isexe@^2.0.0:
version "2.0.0"
resolved "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz"
integrity sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==
jiti@^1.17.2:
version "1.18.2"
resolved "https://registry.npmjs.org/jiti/-/jiti-1.18.2.tgz"
integrity sha512-QAdOptna2NYiSSpv0O/BwoHBSmz4YhpzJHyi+fnMRTXFjp7B8i/YG5Z8IfusxB1ufjcD2Sre1F3R+nX3fvy7gg==
js-sdsl@^4.1.4:
version "4.4.0"
resolved "https://registry.npmjs.org/js-sdsl/-/js-sdsl-4.4.0.tgz"
integrity sha512-FfVSdx6pJ41Oa+CF7RDaFmTnCaFhua+SNYQX74riGOpl96x+2jQCqEfQ2bnXu/5DPCqlRuiqyvTJM0Qjz26IVg==
"js-tokens@^3.0.0 || ^4.0.0":
version "4.0.0"
resolved "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz"
integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==
js-yaml@^3.13.1:
version "3.14.1"
resolved "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz"
integrity sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==
dependencies:
argparse "^1.0.7"
esprima "^4.0.0"
js-yaml@^4.1.0:
version "4.1.0"
resolved "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz"
integrity sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==
dependencies:
argparse "^2.0.1"
json-schema-traverse@^0.4.1:
version "0.4.1"
resolved "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz"
integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==
json-stable-stringify-without-jsonify@^1.0.1:
version "1.0.1"
resolved "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz"
integrity sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==
json5@^1.0.2:
version "1.0.2"
resolved "https://registry.npmjs.org/json5/-/json5-1.0.2.tgz"
integrity sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==
dependencies:
minimist "^1.2.0"
"jsx-ast-utils@^2.4.1 || ^3.0.0", jsx-ast-utils@^3.3.3:
version "3.3.3"
resolved "https://registry.npmjs.org/jsx-ast-utils/-/jsx-ast-utils-3.3.3.tgz"
integrity sha512-fYQHZTZ8jSfmWZ0iyzfwiU4WDX4HpHbMCZ3gPlWYiCl3BoeOTsqKBqnTVfH2rYT7eP5c3sVbeSPHnnJOaTrWiw==
dependencies:
array-includes "^3.1.5"
object.assign "^4.1.3"
kind-of@^6.0.0, kind-of@^6.0.2:
version "6.0.3"
resolved "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz"
integrity sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==
kleur@^4.0.3:
version "4.1.5"
resolved "https://registry.npmjs.org/kleur/-/kleur-4.1.5.tgz"
integrity sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==
language-subtag-registry@~0.3.2:
version "0.3.22"
resolved "https://registry.npmjs.org/language-subtag-registry/-/language-subtag-registry-0.3.22.tgz"
integrity sha512-tN0MCzyWnoz/4nHS6uxdlFWoUZT7ABptwKPQ52Ea7URk6vll88bWBVhodtnlfEuCcKWNGoc+uGbw1cwa9IKh/w==
language-tags@=1.0.5:
version "1.0.5"
resolved "https://registry.npmjs.org/language-tags/-/language-tags-1.0.5.tgz"
integrity sha512-qJhlO9cGXi6hBGKoxEG/sKZDAHD5Hnu9Hs4WbOY3pCWXDhw0N8x1NenNzm2EnNLkLkk7J2SdxAkDSbb6ftT+UQ==
dependencies:
language-subtag-registry "~0.3.2"
levn@^0.4.1:
version "0.4.1"
resolved "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz"
integrity sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==
dependencies:
prelude-ls "^1.2.1"
type-check "~0.4.0"
lilconfig@^2.0.5, lilconfig@^2.0.6:
version "2.1.0"
resolved "https://registry.npmjs.org/lilconfig/-/lilconfig-2.1.0.tgz"
integrity sha512-utWOt/GHzuUxnLKxB6dk81RoOeoNeHgbrXiuGk4yyF5qlRz+iIVWu56E2fqGHFrXz0QNUhLB/8nKqvRH66JKGQ==
lines-and-columns@^1.1.6:
version "1.2.4"
resolved "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz"
integrity sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==
locate-path@^6.0.0:
version "6.0.0"
resolved "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz"
integrity sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==
dependencies:
p-locate "^5.0.0"
lodash.castarray@^4.4.0:
version "4.4.0"
resolved "https://registry.npmjs.org/lodash.castarray/-/lodash.castarray-4.4.0.tgz"
integrity sha512-aVx8ztPv7/2ULbArGJ2Y42bG1mEQ5mGjpdvrbJcJFU3TbYybe+QlLS4pst9zV52ymy2in1KpFPiZnAOATxD4+Q==
lodash.isplainobject@^4.0.6:
version "4.0.6"
resolved "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz"
integrity sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==
lodash.merge@^4.6.2:
version "4.6.2"
resolved "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz"
integrity sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==
longest-streak@^3.0.0:
version "3.1.0"
resolved "https://registry.npmjs.org/longest-streak/-/longest-streak-3.1.0.tgz"
integrity sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g==
loose-envify@^1.1.0, loose-envify@^1.4.0:
version "1.4.0"
resolved "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz"
integrity sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==
dependencies:
js-tokens "^3.0.0 || ^4.0.0"
lru-cache@^6.0.0:
version "6.0.0"
resolved "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz"
integrity sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==
dependencies:
yallist "^4.0.0"
mdast-util-definitions@^5.0.0:
version "5.1.2"
resolved "https://registry.npmjs.org/mdast-util-definitions/-/mdast-util-definitions-5.1.2.tgz"
integrity sha512-8SVPMuHqlPME/z3gqVwWY4zVXn8lqKv/pAhC57FuJ40ImXyBpmO5ukh98zB2v7Blql2FiHjHv9LVztSIqjY+MA==
dependencies:
"@types/mdast" "^3.0.0"
"@types/unist" "^2.0.0"
unist-util-visit "^4.0.0"
mdast-util-from-markdown@^1.0.0:
version "1.3.0"
resolved "https://registry.npmjs.org/mdast-util-from-markdown/-/mdast-util-from-markdown-1.3.0.tgz"
integrity sha512-HN3W1gRIuN/ZW295c7zi7g9lVBllMgZE40RxCX37wrTPWXCWtpvOZdfnuK+1WNpvZje6XuJeI3Wnb4TJEUem+g==
dependencies:
"@types/mdast" "^3.0.0"
"@types/unist" "^2.0.0"
decode-named-character-reference "^1.0.0"
mdast-util-to-string "^3.1.0"
micromark "^3.0.0"
micromark-util-decode-numeric-character-reference "^1.0.0"
micromark-util-decode-string "^1.0.0"
micromark-util-normalize-identifier "^1.0.0"
micromark-util-symbol "^1.0.0"
micromark-util-types "^1.0.0"
unist-util-stringify-position "^3.0.0"
uvu "^0.5.0"
mdast-util-phrasing@^3.0.0:
version "3.0.1"
resolved "https://registry.npmjs.org/mdast-util-phrasing/-/mdast-util-phrasing-3.0.1.tgz"
integrity sha512-WmI1gTXUBJo4/ZmSk79Wcb2HcjPJBzM1nlI/OUWA8yk2X9ik3ffNbBGsU+09BFmXaL1IBb9fiuvq6/KMiNycSg==
dependencies:
"@types/mdast" "^3.0.0"
unist-util-is "^5.0.0"
mdast-util-to-hast@^12.0.0:
version "12.3.0"
resolved "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-12.3.0.tgz"
integrity sha512-pits93r8PhnIoU4Vy9bjW39M2jJ6/tdHyja9rrot9uujkN7UTU9SDnE6WNJz/IGyQk3XHX6yNNtrBH6cQzm8Hw==
dependencies:
"@types/hast" "^2.0.0"
"@types/mdast" "^3.0.0"
mdast-util-definitions "^5.0.0"
micromark-util-sanitize-uri "^1.1.0"
trim-lines "^3.0.0"
unist-util-generated "^2.0.0"
unist-util-position "^4.0.0"
unist-util-visit "^4.0.0"
mdast-util-to-markdown@^1.0.0:
version "1.5.0"
resolved "https://registry.npmjs.org/mdast-util-to-markdown/-/mdast-util-to-markdown-1.5.0.tgz"
integrity sha512-bbv7TPv/WC49thZPg3jXuqzuvI45IL2EVAr/KxF0BSdHsU0ceFHOmwQn6evxAh1GaoK/6GQ1wp4R4oW2+LFL/A==
dependencies:
"@types/mdast" "^3.0.0"
"@types/unist" "^2.0.0"
longest-streak "^3.0.0"
mdast-util-phrasing "^3.0.0"
mdast-util-to-string "^3.0.0"
micromark-util-decode-string "^1.0.0"
unist-util-visit "^4.0.0"
zwitch "^2.0.0"
mdast-util-to-string@^3.0.0, mdast-util-to-string@^3.1.0:
version "3.2.0"
resolved "https://registry.npmjs.org/mdast-util-to-string/-/mdast-util-to-string-3.2.0.tgz"
integrity sha512-V4Zn/ncyN1QNSqSBxTrMOLpjr+IKdHl2v3KVLoWmDPscP4r9GcCi71gjgvUV1SFSKh92AjAG4peFuBl2/YgCJg==
dependencies:
"@types/mdast" "^3.0.0"
merge2@^1.3.0, merge2@^1.4.1:
version "1.4.1"
resolved "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz"
integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==
micromark-core-commonmark@^1.0.1:
version "1.0.6"
resolved "https://registry.npmjs.org/micromark-core-commonmark/-/micromark-core-commonmark-1.0.6.tgz"
integrity sha512-K+PkJTxqjFfSNkfAhp4GB+cZPfQd6dxtTXnf+RjZOV7T4EEXnvgzOcnp+eSTmpGk9d1S9sL6/lqrgSNn/s0HZA==
dependencies:
decode-named-character-reference "^1.0.0"
micromark-factory-destination "^1.0.0"
micromark-factory-label "^1.0.0"
micromark-factory-space "^1.0.0"
micromark-factory-title "^1.0.0"
micromark-factory-whitespace "^1.0.0"
micromark-util-character "^1.0.0"
micromark-util-chunked "^1.0.0"
micromark-util-classify-character "^1.0.0"
micromark-util-html-tag-name "^1.0.0"
micromark-util-normalize-identifier "^1.0.0"
micromark-util-resolve-all "^1.0.0"
micromark-util-subtokenize "^1.0.0"
micromark-util-symbol "^1.0.0"
micromark-util-types "^1.0.1"
uvu "^0.5.0"
micromark-factory-destination@^1.0.0:
version "1.0.0"
resolved "https://registry.npmjs.org/micromark-factory-destination/-/micromark-factory-destination-1.0.0.tgz"
integrity sha512-eUBA7Rs1/xtTVun9TmV3gjfPz2wEwgK5R5xcbIM5ZYAtvGF6JkyaDsj0agx8urXnO31tEO6Ug83iVH3tdedLnw==
dependencies:
micromark-util-character "^1.0.0"
micromark-util-symbol "^1.0.0"
micromark-util-types "^1.0.0"
micromark-factory-label@^1.0.0:
version "1.0.2"
resolved "https://registry.npmjs.org/micromark-factory-label/-/micromark-factory-label-1.0.2.tgz"
integrity sha512-CTIwxlOnU7dEshXDQ+dsr2n+yxpP0+fn271pu0bwDIS8uqfFcumXpj5mLn3hSC8iw2MUr6Gx8EcKng1dD7i6hg==
dependencies:
micromark-util-character "^1.0.0"
micromark-util-symbol "^1.0.0"
micromark-util-types "^1.0.0"
uvu "^0.5.0"
micromark-factory-space@^1.0.0:
version "1.0.0"
resolved "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-1.0.0.tgz"
integrity sha512-qUmqs4kj9a5yBnk3JMLyjtWYN6Mzfcx8uJfi5XAveBniDevmZasdGBba5b4QsvRcAkmvGo5ACmSUmyGiKTLZew==
dependencies:
micromark-util-character "^1.0.0"
micromark-util-types "^1.0.0"
micromark-factory-title@^1.0.0:
version "1.0.2"
resolved "https://registry.npmjs.org/micromark-factory-title/-/micromark-factory-title-1.0.2.tgz"
integrity sha512-zily+Nr4yFqgMGRKLpTVsNl5L4PMu485fGFDOQJQBl2NFpjGte1e86zC0da93wf97jrc4+2G2GQudFMHn3IX+A==
dependencies:
micromark-factory-space "^1.0.0"
micromark-util-character "^1.0.0"
micromark-util-symbol "^1.0.0"
micromark-util-types "^1.0.0"
uvu "^0.5.0"
micromark-factory-whitespace@^1.0.0:
version "1.0.0"
resolved "https://registry.npmjs.org/micromark-factory-whitespace/-/micromark-factory-whitespace-1.0.0.tgz"
integrity sha512-Qx7uEyahU1lt1RnsECBiuEbfr9INjQTGa6Err+gF3g0Tx4YEviPbqqGKNv/NrBaE7dVHdn1bVZKM/n5I/Bak7A==
dependencies:
micromark-factory-space "^1.0.0"
micromark-util-character "^1.0.0"
micromark-util-symbol "^1.0.0"
micromark-util-types "^1.0.0"
micromark-util-character@^1.0.0:
version "1.1.0"
resolved "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-1.1.0.tgz"
integrity sha512-agJ5B3unGNJ9rJvADMJ5ZiYjBRyDpzKAOk01Kpi1TKhlT1APx3XZk6eN7RtSz1erbWHC2L8T3xLZ81wdtGRZzg==
dependencies:
micromark-util-symbol "^1.0.0"
micromark-util-types "^1.0.0"
micromark-util-chunked@^1.0.0:
version "1.0.0"
resolved "https://registry.npmjs.org/micromark-util-chunked/-/micromark-util-chunked-1.0.0.tgz"
integrity sha512-5e8xTis5tEZKgesfbQMKRCyzvffRRUX+lK/y+DvsMFdabAicPkkZV6gO+FEWi9RfuKKoxxPwNL+dFF0SMImc1g==
dependencies:
micromark-util-symbol "^1.0.0"
micromark-util-classify-character@^1.0.0:
version "1.0.0"
resolved "https://registry.npmjs.org/micromark-util-classify-character/-/micromark-util-classify-character-1.0.0.tgz"
integrity sha512-F8oW2KKrQRb3vS5ud5HIqBVkCqQi224Nm55o5wYLzY/9PwHGXC01tr3d7+TqHHz6zrKQ72Okwtvm/xQm6OVNZA==
dependencies:
micromark-util-character "^1.0.0"
micromark-util-symbol "^1.0.0"
micromark-util-types "^1.0.0"
micromark-util-combine-extensions@^1.0.0:
version "1.0.0"
resolved "https://registry.npmjs.org/micromark-util-combine-extensions/-/micromark-util-combine-extensions-1.0.0.tgz"
integrity sha512-J8H058vFBdo/6+AsjHp2NF7AJ02SZtWaVUjsayNFeAiydTxUwViQPxN0Hf8dp4FmCQi0UUFovFsEyRSUmFH3MA==
dependencies:
micromark-util-chunked "^1.0.0"
micromark-util-types "^1.0.0"
micromark-util-decode-numeric-character-reference@^1.0.0:
version "1.0.0"
resolved "https://registry.npmjs.org/micromark-util-decode-numeric-character-reference/-/micromark-util-decode-numeric-character-reference-1.0.0.tgz"
integrity sha512-OzO9AI5VUtrTD7KSdagf4MWgHMtET17Ua1fIpXTpuhclCqD8egFWo85GxSGvxgkGS74bEahvtM0WP0HjvV0e4w==
dependencies:
micromark-util-symbol "^1.0.0"
micromark-util-decode-string@^1.0.0:
version "1.0.2"
resolved "https://registry.npmjs.org/micromark-util-decode-string/-/micromark-util-decode-string-1.0.2.tgz"
integrity sha512-DLT5Ho02qr6QWVNYbRZ3RYOSSWWFuH3tJexd3dgN1odEuPNxCngTCXJum7+ViRAd9BbdxCvMToPOD/IvVhzG6Q==
dependencies:
decode-named-character-reference "^1.0.0"
micromark-util-character "^1.0.0"
micromark-util-decode-numeric-character-reference "^1.0.0"
micromark-util-symbol "^1.0.0"
micromark-util-encode@^1.0.0:
version "1.0.1"
resolved "https://registry.npmjs.org/micromark-util-encode/-/micromark-util-encode-1.0.1.tgz"
integrity sha512-U2s5YdnAYexjKDel31SVMPbfi+eF8y1U4pfiRW/Y8EFVCy/vgxk/2wWTxzcqE71LHtCuCzlBDRU2a5CQ5j+mQA==
micromark-util-html-tag-name@^1.0.0:
version "1.1.0"
resolved "https://registry.npmjs.org/micromark-util-html-tag-name/-/micromark-util-html-tag-name-1.1.0.tgz"
integrity sha512-BKlClMmYROy9UiV03SwNmckkjn8QHVaWkqoAqzivabvdGcwNGMMMH/5szAnywmsTBUzDsU57/mFi0sp4BQO6dA==
micromark-util-normalize-identifier@^1.0.0:
version "1.0.0"
resolved "https://registry.npmjs.org/micromark-util-normalize-identifier/-/micromark-util-normalize-identifier-1.0.0.tgz"
integrity sha512-yg+zrL14bBTFrQ7n35CmByWUTFsgst5JhA4gJYoty4Dqzj4Z4Fr/DHekSS5aLfH9bdlfnSvKAWsAgJhIbogyBg==
dependencies:
micromark-util-symbol "^1.0.0"
micromark-util-resolve-all@^1.0.0:
version "1.0.0"
resolved "https://registry.npmjs.org/micromark-util-resolve-all/-/micromark-util-resolve-all-1.0.0.tgz"
integrity sha512-CB/AGk98u50k42kvgaMM94wzBqozSzDDaonKU7P7jwQIuH2RU0TeBqGYJz2WY1UdihhjweivStrJ2JdkdEmcfw==
dependencies:
micromark-util-types "^1.0.0"
micromark-util-sanitize-uri@^1.0.0, micromark-util-sanitize-uri@^1.1.0:
version "1.1.0"
resolved "https://registry.npmjs.org/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-1.1.0.tgz"
integrity sha512-RoxtuSCX6sUNtxhbmsEFQfWzs8VN7cTctmBPvYivo98xb/kDEoTCtJQX5wyzIYEmk/lvNFTat4hL8oW0KndFpg==
dependencies:
micromark-util-character "^1.0.0"
micromark-util-encode "^1.0.0"
micromark-util-symbol "^1.0.0"
micromark-util-subtokenize@^1.0.0:
version "1.0.2"
resolved "https://registry.npmjs.org/micromark-util-subtokenize/-/micromark-util-subtokenize-1.0.2.tgz"
integrity sha512-d90uqCnXp/cy4G881Ub4psE57Sf8YD0pim9QdjCRNjfas2M1u6Lbt+XZK9gnHL2XFhnozZiEdCa9CNfXSfQ6xA==
dependencies:
micromark-util-chunked "^1.0.0"
micromark-util-symbol "^1.0.0"
micromark-util-types "^1.0.0"
uvu "^0.5.0"
micromark-util-symbol@^1.0.0:
version "1.0.1"
resolved "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-1.0.1.tgz"
integrity sha512-oKDEMK2u5qqAptasDAwWDXq0tG9AssVwAx3E9bBF3t/shRIGsWIRG+cGafs2p/SnDSOecnt6hZPCE2o6lHfFmQ==
micromark-util-types@^1.0.0, micromark-util-types@^1.0.1:
version "1.0.2"
resolved "https://registry.npmjs.org/micromark-util-types/-/micromark-util-types-1.0.2.tgz"
integrity sha512-DCfg/T8fcrhrRKTPjRrw/5LLvdGV7BHySf/1LOZx7TzWZdYRjogNtyNq885z3nNallwr3QUKARjqvHqX1/7t+w==
micromark@^3.0.0:
version "3.1.0"
resolved "https://registry.npmjs.org/micromark/-/micromark-3.1.0.tgz"
integrity sha512-6Mj0yHLdUZjHnOPgr5xfWIMqMWS12zDN6iws9SLuSz76W8jTtAv24MN4/CL7gJrl5vtxGInkkqDv/JIoRsQOvA==
dependencies:
"@types/debug" "^4.0.0"
debug "^4.0.0"
decode-named-character-reference "^1.0.0"
micromark-core-commonmark "^1.0.1"
micromark-factory-space "^1.0.0"
micromark-util-character "^1.0.0"
micromark-util-chunked "^1.0.0"
micromark-util-combine-extensions "^1.0.0"
micromark-util-decode-numeric-character-reference "^1.0.0"
micromark-util-encode "^1.0.0"
micromark-util-normalize-identifier "^1.0.0"
micromark-util-resolve-all "^1.0.0"
micromark-util-sanitize-uri "^1.0.0"
micromark-util-subtokenize "^1.0.0"
micromark-util-symbol "^1.0.0"
micromark-util-types "^1.0.1"
uvu "^0.5.0"
micromatch@^4.0.4, micromatch@^4.0.5:
version "4.0.5"
resolved "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz"
integrity sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==
dependencies:
braces "^3.0.2"
picomatch "^2.3.1"
minimatch@^3.0.4, minimatch@^3.0.5, minimatch@^3.1.2:
version "3.1.2"
resolved "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz"
integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==
dependencies:
brace-expansion "^1.1.7"
minimist@^1.2.0, minimist@^1.2.6:
version "1.2.8"
resolved "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz"
integrity sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==
mri@^1.1.0:
version "1.2.0"
resolved "https://registry.npmjs.org/mri/-/mri-1.2.0.tgz"
integrity sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==
ms@2.1.2, ms@^2.1.1:
version "2.1.2"
resolved "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz"
integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==
mz@^2.7.0:
version "2.7.0"
resolved "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz"
integrity sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==
dependencies:
any-promise "^1.0.0"
object-assign "^4.0.1"
thenify-all "^1.0.0"
nanoid@^3.3.4:
version "3.3.6"
resolved "https://registry.npmjs.org/nanoid/-/nanoid-3.3.6.tgz"
integrity sha512-BGcqMMJuToF7i1rt+2PWSNVnWIkGCU78jBG3RxO/bZlnZPK2Cmi2QaffxGO/2RvWi9sL+FAiRiXMgsyxQ1DIDA==
natural-compare@^1.4.0:
version "1.4.0"
resolved "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz"
integrity sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==
next@13.2.4:
version "13.2.4"
resolved "https://registry.npmjs.org/next/-/next-13.2.4.tgz"
integrity sha512-g1I30317cThkEpvzfXujf0O4wtaQHtDCLhlivwlTJ885Ld+eOgcz7r3TGQzeU+cSRoNHtD8tsJgzxVdYojFssw==
dependencies:
"@next/env" "13.2.4"
"@swc/helpers" "0.4.14"
caniuse-lite "^1.0.30001406"
postcss "8.4.14"
styled-jsx "5.1.1"
optionalDependencies:
"@next/swc-android-arm-eabi" "13.2.4"
"@next/swc-android-arm64" "13.2.4"
"@next/swc-darwin-arm64" "13.2.4"
"@next/swc-darwin-x64" "13.2.4"
"@next/swc-freebsd-x64" "13.2.4"
"@next/swc-linux-arm-gnueabihf" "13.2.4"
"@next/swc-linux-arm64-gnu" "13.2.4"
"@next/swc-linux-arm64-musl" "13.2.4"
"@next/swc-linux-x64-gnu" "13.2.4"
"@next/swc-linux-x64-musl" "13.2.4"
"@next/swc-win32-arm64-msvc" "13.2.4"
"@next/swc-win32-ia32-msvc" "13.2.4"
"@next/swc-win32-x64-msvc" "13.2.4"
node-releases@^2.0.8:
version "2.0.10"
resolved "https://registry.npmjs.org/node-releases/-/node-releases-2.0.10.tgz"
integrity sha512-5GFldHPXVG/YZmFzJvKK2zDSzPKhEp0+ZR5SVaoSag9fsL5YgHbUHDfnG5494ISANDcK4KwPXAx2xqVEydmd7w==
normalize-path@^3.0.0, normalize-path@~3.0.0:
version "3.0.0"
resolved "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz"
integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==
normalize-range@^0.1.2:
version "0.1.2"
resolved "https://registry.npmjs.org/normalize-range/-/normalize-range-0.1.2.tgz"
integrity sha512-bdok/XvKII3nUpklnV6P2hxtMNrCboOjAcyBuQnWEhO665FwrSNRxU+AqpsyvO6LgGYPspN+lu5CLtw4jPRKNA==
object-assign@^4.0.1, object-assign@^4.1.1:
version "4.1.1"
resolved "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz"
integrity sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==
object-hash@^3.0.0:
version "3.0.0"
resolved "https://registry.npmjs.org/object-hash/-/object-hash-3.0.0.tgz"
integrity sha512-RSn9F68PjH9HqtltsSnqYC1XXoWe9Bju5+213R98cNGttag9q9yAOTzdbsqvIa7aNm5WffBZFpWYr2aWrklWAw==
object-inspect@^1.12.3, object-inspect@^1.9.0:
version "1.12.3"
resolved "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.3.tgz"
integrity sha512-geUvdk7c+eizMNUDkRpW1wJwgfOiOeHbxBR/hLXK1aT6zmVSO0jsQcs7fj6MGw89jC/cjGfLcNOrtMYtGqm81g==
object-is@^1.1.5:
version "1.1.5"
resolved "https://registry.npmjs.org/object-is/-/object-is-1.1.5.tgz"
integrity sha512-3cyDsyHgtmi7I7DfSSI2LDp6SK2lwvtbg0p0R1e0RvTqF5ceGx+K2dfSjm1bKDMVCFEDAQvy+o8c6a7VujOddw==
dependencies:
call-bind "^1.0.2"
define-properties "^1.1.3"
object-keys@^1.1.1:
version "1.1.1"
resolved "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz"
integrity sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==
object.assign@^4.1.3, object.assign@^4.1.4:
version "4.1.4"
resolved "https://registry.npmjs.org/object.assign/-/object.assign-4.1.4.tgz"
integrity sha512-1mxKf0e58bvyjSCtKYY4sRe9itRk3PJpquJOjeIkz885CczcI4IvJJDLPS72oowuSh+pBxUFROpX+TU++hxhZQ==
dependencies:
call-bind "^1.0.2"
define-properties "^1.1.4"
has-symbols "^1.0.3"
object-keys "^1.1.1"
object.entries@^1.1.6:
version "1.1.6"
resolved "https://registry.npmjs.org/object.entries/-/object.entries-1.1.6.tgz"
integrity sha512-leTPzo4Zvg3pmbQ3rDK69Rl8GQvIqMWubrkxONG9/ojtFE2rD9fjMKfSI5BxW3osRH1m6VdzmqK8oAY9aT4x5w==
dependencies:
call-bind "^1.0.2"
define-properties "^1.1.4"
es-abstract "^1.20.4"
object.fromentries@^2.0.6:
version "2.0.6"
resolved "https://registry.npmjs.org/object.fromentries/-/object.fromentries-2.0.6.tgz"
integrity sha512-VciD13dswC4j1Xt5394WR4MzmAQmlgN72phd/riNp9vtD7tp4QQWJ0R4wvclXcafgcYK8veHRed2W6XeGBvcfg==
dependencies:
call-bind "^1.0.2"
define-properties "^1.1.4"
es-abstract "^1.20.4"
object.hasown@^1.1.2:
version "1.1.2"
resolved "https://registry.npmjs.org/object.hasown/-/object.hasown-1.1.2.tgz"
integrity sha512-B5UIT3J1W+WuWIU55h0mjlwaqxiE5vYENJXIXZ4VFe05pNYrkKuK0U/6aFcb0pKywYJh7IhfoqUfKVmrJJHZHw==
dependencies:
define-properties "^1.1.4"
es-abstract "^1.20.4"
object.values@^1.1.6:
version "1.1.6"
resolved "https://registry.npmjs.org/object.values/-/object.values-1.1.6.tgz"
integrity sha512-FVVTkD1vENCsAcwNs9k6jea2uHC/X0+JcjG8YA60FN5CMaJmG95wT9jek/xX9nornqGRrBkKtzuAu2wuHpKqvw==
dependencies:
call-bind "^1.0.2"
define-properties "^1.1.4"
es-abstract "^1.20.4"
once@^1.3.0:
version "1.4.0"
resolved "https://registry.npmjs.org/once/-/once-1.4.0.tgz"
integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==
dependencies:
wrappy "1"
open@^8.4.0:
version "8.4.2"
resolved "https://registry.npmjs.org/open/-/open-8.4.2.tgz"
integrity sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ==
dependencies:
define-lazy-prop "^2.0.0"
is-docker "^2.1.1"
is-wsl "^2.2.0"
optionator@^0.9.1:
version "0.9.1"
resolved "https://registry.npmjs.org/optionator/-/optionator-0.9.1.tgz"
integrity sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw==
dependencies:
deep-is "^0.1.3"
fast-levenshtein "^2.0.6"
levn "^0.4.1"
prelude-ls "^1.2.1"
type-check "^0.4.0"
word-wrap "^1.2.3"
p-limit@^3.0.2:
version "3.1.0"
resolved "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz"
integrity sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==
dependencies:
yocto-queue "^0.1.0"
p-locate@^5.0.0:
version "5.0.0"
resolved "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz"
integrity sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==
dependencies:
p-limit "^3.0.2"
parent-module@^1.0.0:
version "1.0.1"
resolved "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz"
integrity sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==
dependencies:
callsites "^3.0.0"
parse5@^6.0.0:
version "6.0.1"
resolved "https://registry.npmjs.org/parse5/-/parse5-6.0.1.tgz"
integrity sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw==
path-exists@^4.0.0:
version "4.0.0"
resolved "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz"
integrity sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==
path-is-absolute@^1.0.0:
version "1.0.1"
resolved "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz"
integrity sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==
path-key@^3.1.0:
version "3.1.1"
resolved "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz"
integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==
path-parse@^1.0.7:
version "1.0.7"
resolved "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz"
integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==
path-type@^4.0.0:
version "4.0.0"
resolved "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz"
integrity sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==
picocolors@^1.0.0:
version "1.0.0"
resolved "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz"
integrity sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==
picomatch@^2.0.4, picomatch@^2.2.1, picomatch@^2.3.1:
version "2.3.1"
resolved "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz"
integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==
pify@^2.3.0:
version "2.3.0"
resolved "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz"
integrity sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==
pirates@^4.0.1:
version "4.0.5"
resolved "https://registry.npmjs.org/pirates/-/pirates-4.0.5.tgz"
integrity sha512-8V9+HQPupnaXMA23c5hvl69zXvTwTzyAYasnkb0Tts4XvO4CliqONMOnvlq26rkhLC3nWDFBJf73LU1e1VZLaQ==
postcss-import@^14.1.0:
version "14.1.0"
resolved "https://registry.npmjs.org/postcss-import/-/postcss-import-14.1.0.tgz"
integrity sha512-flwI+Vgm4SElObFVPpTIT7SU7R3qk2L7PyduMcokiaVKuWv9d/U+Gm/QAd8NDLuykTWTkcrjOeD2Pp1rMeBTGw==
dependencies:
postcss-value-parser "^4.0.0"
read-cache "^1.0.0"
resolve "^1.1.7"
postcss-js@^4.0.0:
version "4.0.1"
resolved "https://registry.npmjs.org/postcss-js/-/postcss-js-4.0.1.tgz"
integrity sha512-dDLF8pEO191hJMtlHFPRa8xsizHaM82MLfNkUHdUtVEV3tgTp5oj+8qbEqYM57SLfc74KSbw//4SeJma2LRVIw==
dependencies:
camelcase-css "^2.0.1"
postcss-load-config@^3.1.4:
version "3.1.4"
resolved "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-3.1.4.tgz"
integrity sha512-6DiM4E7v4coTE4uzA8U//WhtPwyhiim3eyjEMFCnUpzbrkK9wJHgKDT2mR+HbtSrd/NubVaYTOpSpjUl8NQeRg==
dependencies:
lilconfig "^2.0.5"
yaml "^1.10.2"
postcss-nested@6.0.0:
version "6.0.0"
resolved "https://registry.npmjs.org/postcss-nested/-/postcss-nested-6.0.0.tgz"
integrity sha512-0DkamqrPcmkBDsLn+vQDIrtkSbNkv5AD/M322ySo9kqFkCIYklym2xEmWkwo+Y3/qZo34tzEPNUw4y7yMCdv5w==
dependencies:
postcss-selector-parser "^6.0.10"
postcss-selector-parser@6.0.10, postcss-selector-parser@^6.0.10:
version "6.0.10"
resolved "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.0.10.tgz"
integrity sha512-IQ7TZdoaqbT+LCpShg46jnZVlhWD2w6iQYAcYXfHARZ7X1t/UGhhceQDs5X0cGqKvYlHNOuv7Oa1xmb0oQuA3w==
dependencies:
cssesc "^3.0.0"
util-deprecate "^1.0.2"
postcss-selector-parser@^6.0.11:
version "6.0.11"
resolved "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.0.11.tgz"
integrity sha512-zbARubNdogI9j7WY4nQJBiNqQf3sLS3wCP4WfOidu+p28LofJqDH1tcXypGrcmMHhDk2t9wGhCsYe/+szLTy1g==
dependencies:
cssesc "^3.0.0"
util-deprecate "^1.0.2"
postcss-value-parser@^4.0.0, postcss-value-parser@^4.2.0:
version "4.2.0"
resolved "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz"
integrity sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==
postcss@8.4.14:
version "8.4.14"
resolved "https://registry.npmjs.org/postcss/-/postcss-8.4.14.tgz"
integrity sha512-E398TUmfAYFPBSdzgeieK2Y1+1cpdxJx8yXbK/m57nRhKSmk1GB2tO4lbLBtlkfPQTDKfe4Xqv1ASWPpayPEig==
dependencies:
nanoid "^3.3.4"
picocolors "^1.0.0"
source-map-js "^1.0.2"
postcss@^8.0.9, postcss@^8.4.21:
version "8.4.21"
resolved "https://registry.npmjs.org/postcss/-/postcss-8.4.21.tgz"
integrity sha512-tP7u/Sn/dVxK2NnruI4H9BG+x+Wxz6oeZ1cJ8P6G/PZY0IKk4k/63TDsQf2kQq3+qoJeLm2kIBUNlZe3zgb4Zg==
dependencies:
nanoid "^3.3.4"
picocolors "^1.0.0"
source-map-js "^1.0.2"
prelude-ls@^1.2.1:
version "1.2.1"
resolved "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz"
integrity sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==
prop-types@^15.8.1:
version "15.8.1"
resolved "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz"
integrity sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==
dependencies:
loose-envify "^1.4.0"
object-assign "^4.1.1"
react-is "^16.13.1"
property-information@^6.0.0:
version "6.2.0"
resolved "https://registry.npmjs.org/property-information/-/property-information-6.2.0.tgz"
integrity sha512-kma4U7AFCTwpqq5twzC1YVIDXSqg6qQK6JN0smOw8fgRy1OkMi0CYSzFmsy6dnqSenamAtj0CyXMUJ1Mf6oROg==
punycode@^2.1.0:
version "2.3.0"
resolved "https://registry.npmjs.org/punycode/-/punycode-2.3.0.tgz"
integrity sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA==
queue-microtask@^1.2.2:
version "1.2.3"
resolved "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz"
integrity sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==
quick-lru@^5.1.1:
version "5.1.1"
resolved "https://registry.npmjs.org/quick-lru/-/quick-lru-5.1.1.tgz"
integrity sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==
react-dom@18.2.0:
version "18.2.0"
resolved "https://registry.npmjs.org/react-dom/-/react-dom-18.2.0.tgz"
integrity sha512-6IMTriUmvsjHUjNtEDudZfuDQUoWXVxKHhlEGSk81n4YFS+r/Kl99wXiwlVXtPBtJenozv2P+hxDsw9eA7Xo6g==
dependencies:
loose-envify "^1.1.0"
scheduler "^0.23.0"
react-is@^16.13.1:
version "16.13.1"
resolved "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz"
integrity sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==
react@18.2.0:
version "18.2.0"
resolved "https://registry.npmjs.org/react/-/react-18.2.0.tgz"
integrity sha512-/3IjMdb2L9QbBdWiW5e3P2/npwMBaU9mHCSCUzNln0ZCYbcfTsGbTJrU/kGemdH2IWmB2ioZ+zkxtmq6g09fGQ==
dependencies:
loose-envify "^1.1.0"
read-cache@^1.0.0:
version "1.0.0"
resolved "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz"
integrity sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==
dependencies:
pify "^2.3.0"
readdirp@~3.6.0:
version "3.6.0"
resolved "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz"
integrity sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==
dependencies:
picomatch "^2.2.1"
regenerator-runtime@^0.13.11:
version "0.13.11"
resolved "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.13.11.tgz"
integrity sha512-kY1AZVr2Ra+t+piVaJ4gxaFaReZVH40AKNo7UCX6W+dEwBo/2oZJzqfuN1qLq1oL45o56cPaTXELwrTh8Fpggg==
regexp.prototype.flags@^1.4.3:
version "1.4.3"
resolved "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.4.3.tgz"
integrity sha512-fjggEOO3slI6Wvgjwflkc4NFRCTZAu5CnNfBd5qOMYhWdn67nJBBu34/TkD++eeFmd8C9r9jfXJ27+nSiRkSUA==
dependencies:
call-bind "^1.0.2"
define-properties "^1.1.3"
functions-have-names "^1.2.2"
remark-html@^15.0.2:
version "15.0.2"
resolved "https://registry.npmjs.org/remark-html/-/remark-html-15.0.2.tgz"
integrity sha512-/CIOI7wzHJzsh48AiuIyIe1clxVkUtreul73zcCXLub0FmnevQE0UMFDQm7NUx8/3rl/4zCshlMfqBdWScQthw==
dependencies:
"@types/mdast" "^3.0.0"
hast-util-sanitize "^4.0.0"
hast-util-to-html "^8.0.0"
mdast-util-to-hast "^12.0.0"
unified "^10.0.0"
remark-parse@^10.0.0:
version "10.0.1"
resolved "https://registry.npmjs.org/remark-parse/-/remark-parse-10.0.1.tgz"
integrity sha512-1fUyHr2jLsVOkhbvPRBJ5zTKZZyD6yZzYaWCS6BPBdQ8vEMBCH+9zNCDA6tET/zHCi/jLqjCWtlJZUPk+DbnFw==
dependencies:
"@types/mdast" "^3.0.0"
mdast-util-from-markdown "^1.0.0"
unified "^10.0.0"
remark-stringify@^10.0.0:
version "10.0.2"
resolved "https://registry.npmjs.org/remark-stringify/-/remark-stringify-10.0.2.tgz"
integrity sha512-6wV3pvbPvHkbNnWB0wdDvVFHOe1hBRAx1Q/5g/EpH4RppAII6J8Gnwe7VbHuXaoKIF6LAg6ExTel/+kNqSQ7lw==
dependencies:
"@types/mdast" "^3.0.0"
mdast-util-to-markdown "^1.0.0"
unified "^10.0.0"
remark@^14.0.2:
version "14.0.2"
resolved "https://registry.npmjs.org/remark/-/remark-14.0.2.tgz"
integrity sha512-A3ARm2V4BgiRXaUo5K0dRvJ1lbogrbXnhkJRmD0yw092/Yl0kOCZt1k9ZeElEwkZsWGsMumz6qL5MfNJH9nOBA==
dependencies:
"@types/mdast" "^3.0.0"
remark-parse "^10.0.0"
remark-stringify "^10.0.0"
unified "^10.0.0"
resolve-from@^4.0.0:
version "4.0.0"
resolved "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz"
integrity sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==
resolve@^1.1.7, resolve@^1.22.1:
version "1.22.1"
resolved "https://registry.npmjs.org/resolve/-/resolve-1.22.1.tgz"
integrity sha512-nBpuuYuY5jFsli/JIs1oldw6fOQCBioohqWZg/2hiaOybXOft4lonv85uDOKXdf8rhyK159cxU5cDcK/NKk8zw==
dependencies:
is-core-module "^2.9.0"
path-parse "^1.0.7"
supports-preserve-symlinks-flag "^1.0.0"
resolve@^2.0.0-next.4:
version "2.0.0-next.4"
resolved "https://registry.npmjs.org/resolve/-/resolve-2.0.0-next.4.tgz"
integrity sha512-iMDbmAWtfU+MHpxt/I5iWI7cY6YVEZUQ3MBgPQ++XD1PELuJHIl82xBmObyP2KyQmkNB2dsqF7seoQQiAn5yDQ==
dependencies:
is-core-module "^2.9.0"
path-parse "^1.0.7"
supports-preserve-symlinks-flag "^1.0.0"
reusify@^1.0.4:
version "1.0.4"
resolved "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz"
integrity sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==
rimraf@^3.0.2:
version "3.0.2"
resolved "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz"
integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==
dependencies:
glob "^7.1.3"
run-parallel@^1.1.9:
version "1.2.0"
resolved "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz"
integrity sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==
dependencies:
queue-microtask "^1.2.2"
sade@^1.7.3:
version "1.8.1"
resolved "https://registry.npmjs.org/sade/-/sade-1.8.1.tgz"
integrity sha512-xal3CZX1Xlo/k4ApwCFrHVACi9fBqJ7V+mwhBsuf/1IOKbBy098Fex+Wa/5QMubw09pSZ/u8EY8PWgevJsXp1A==
dependencies:
mri "^1.1.0"
safe-regex-test@^1.0.0:
version "1.0.0"
resolved "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.0.0.tgz"
integrity sha512-JBUUzyOgEwXQY1NuPtvcj/qcBDbDmEvWufhlnXZIm75DEHp+afM1r1ujJpJsV/gSM4t59tpDyPi1sd6ZaPFfsA==
dependencies:
call-bind "^1.0.2"
get-intrinsic "^1.1.3"
is-regex "^1.1.4"
scheduler@^0.23.0:
version "0.23.0"
resolved "https://registry.npmjs.org/scheduler/-/scheduler-0.23.0.tgz"
integrity sha512-CtuThmgHNg7zIZWAXi3AsyIzA3n4xx7aNyjwC2VJldO2LMVDhFK+63xGqq6CsJH4rTAt6/M+N4GhZiDYPx9eUw==
dependencies:
loose-envify "^1.1.0"
section-matter@^1.0.0:
version "1.0.0"
resolved "https://registry.npmjs.org/section-matter/-/section-matter-1.0.0.tgz"
integrity sha512-vfD3pmTzGpufjScBh50YHKzEu2lxBWhVEHsNGoEXmCmn2hKGfeNLYMzCJpe8cD7gqX7TJluOVpBkAequ6dgMmA==
dependencies:
extend-shallow "^2.0.1"
kind-of "^6.0.0"
semver@^6.3.0:
version "6.3.0"
resolved "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz"
integrity sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==
semver@^7.3.7:
version "7.3.8"
resolved "https://registry.npmjs.org/semver/-/semver-7.3.8.tgz"
integrity sha512-NB1ctGL5rlHrPJtFDVIVzTyQylMLu9N9VICA6HSFJo8MCGVTMW6gfpicwKmmK/dAjTOrqu5l63JJOpDSrAis3A==
dependencies:
lru-cache "^6.0.0"
shebang-command@^2.0.0:
version "2.0.0"
resolved "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz"
integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==
dependencies:
shebang-regex "^3.0.0"
shebang-regex@^3.0.0:
version "3.0.0"
resolved "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz"
integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==
side-channel@^1.0.4:
version "1.0.4"
resolved "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz"
integrity sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==
dependencies:
call-bind "^1.0.0"
get-intrinsic "^1.0.2"
object-inspect "^1.9.0"
simple-swizzle@^0.2.2:
version "0.2.2"
resolved "https://registry.npmjs.org/simple-swizzle/-/simple-swizzle-0.2.2.tgz"
integrity sha512-JA//kQgZtbuY83m+xT+tXJkmJncGMTFT+C+g2h2R9uxkYIrE2yy9sgmcLhCnw57/WSD+Eh3J97FPEDFnbXnDUg==
dependencies:
is-arrayish "^0.3.1"
slash@^3.0.0:
version "3.0.0"
resolved "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz"
integrity sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==
slash@^4.0.0:
version "4.0.0"
resolved "https://registry.npmjs.org/slash/-/slash-4.0.0.tgz"
integrity sha512-3dOsAHXXUkQTpOYcoAxLIorMTp4gIQr5IW3iVb7A7lFIp0VHhnynm9izx6TssdrIcVIESAlVjtnO2K8bg+Coew==
source-map-js@^1.0.2:
version "1.0.2"
resolved "https://registry.npmjs.org/source-map-js/-/source-map-js-1.0.2.tgz"
integrity sha512-R0XvVJ9WusLiqTCEiGCmICCMplcCkIwwR11mOSD9CR5u+IXYdiseeEuXCVAjS54zqwkLcPNnmU4OeJ6tUrWhDw==
space-separated-tokens@^2.0.0:
version "2.0.2"
resolved "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz"
integrity sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==
sprintf-js@~1.0.2:
version "1.0.3"
resolved "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz"
integrity sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==
stop-iteration-iterator@^1.0.0:
version "1.0.0"
resolved "https://registry.npmjs.org/stop-iteration-iterator/-/stop-iteration-iterator-1.0.0.tgz"
integrity sha512-iCGQj+0l0HOdZ2AEeBADlsRC+vsnDsZsbdSiH1yNSjcfKM7fdpCMfqAL/dwF5BLiw/XhRft/Wax6zQbhq2BcjQ==
dependencies:
internal-slot "^1.0.4"
string.prototype.matchall@^4.0.8:
version "4.0.8"
resolved "https://registry.npmjs.org/string.prototype.matchall/-/string.prototype.matchall-4.0.8.tgz"
integrity sha512-6zOCOcJ+RJAQshcTvXPHoxoQGONa3e/Lqx90wUA+wEzX78sg5Bo+1tQo4N0pohS0erG9qtCqJDjNCQBjeWVxyg==
dependencies:
call-bind "^1.0.2"
define-properties "^1.1.4"
es-abstract "^1.20.4"
get-intrinsic "^1.1.3"
has-symbols "^1.0.3"
internal-slot "^1.0.3"
regexp.prototype.flags "^1.4.3"
side-channel "^1.0.4"
string.prototype.trim@^1.2.7:
version "1.2.7"
resolved "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.7.tgz"
integrity sha512-p6TmeT1T3411M8Cgg9wBTMRtY2q9+PNy9EV1i2lIXUN/btt763oIfxwN3RR8VU6wHX8j/1CFy0L+YuThm6bgOg==
dependencies:
call-bind "^1.0.2"
define-properties "^1.1.4"
es-abstract "^1.20.4"
string.prototype.trimend@^1.0.6:
version "1.0.6"
resolved "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.6.tgz"
integrity sha512-JySq+4mrPf9EsDBEDYMOb/lM7XQLulwg5R/m1r0PXEFqrV0qHvl58sdTilSXtKOflCsK2E8jxf+GKC0T07RWwQ==
dependencies:
call-bind "^1.0.2"
define-properties "^1.1.4"
es-abstract "^1.20.4"
string.prototype.trimstart@^1.0.6:
version "1.0.6"
resolved "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.6.tgz"
integrity sha512-omqjMDaY92pbn5HOX7f9IccLA+U1tA9GvtU4JrodiXFfYB7jPzzHpRzpglLAjtUV6bB557zwClJezTqnAiYnQA==
dependencies:
call-bind "^1.0.2"
define-properties "^1.1.4"
es-abstract "^1.20.4"
stringify-entities@^4.0.0:
version "4.0.3"
resolved "https://registry.npmjs.org/stringify-entities/-/stringify-entities-4.0.3.tgz"
integrity sha512-BP9nNHMhhfcMbiuQKCqMjhDP5yBCAxsPu4pHFFzJ6Alo9dZgY4VLDPutXqIjpRiMoKdp7Av85Gr73Q5uH9k7+g==
dependencies:
character-entities-html4 "^2.0.0"
character-entities-legacy "^3.0.0"
strip-ansi@^6.0.1:
version "6.0.1"
resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz"
integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==
dependencies:
ansi-regex "^5.0.1"
strip-bom-string@^1.0.0:
version "1.0.0"
resolved "https://registry.npmjs.org/strip-bom-string/-/strip-bom-string-1.0.0.tgz"
integrity sha512-uCC2VHvQRYu+lMh4My/sFNmF2klFymLX1wHJeXnbEJERpV/ZsVuonzerjfrGpIGF7LBVa1O7i9kjiWvJiFck8g==
strip-bom@^3.0.0:
version "3.0.0"
resolved "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz"
integrity sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==
strip-json-comments@^3.1.0, strip-json-comments@^3.1.1:
version "3.1.1"
resolved "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz"
integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==
styled-jsx@5.1.1:
version "5.1.1"
resolved "https://registry.npmjs.org/styled-jsx/-/styled-jsx-5.1.1.tgz"
integrity sha512-pW7uC1l4mBZ8ugbiZrcIsiIvVx1UmTfw7UkC3Um2tmfUq9Bhk8IiyEIPl6F8agHgjzku6j0xQEZbfA5uSgSaCw==
dependencies:
client-only "0.0.1"
sucrase@^3.29.0:
version "3.31.0"
resolved "https://registry.npmjs.org/sucrase/-/sucrase-3.31.0.tgz"
integrity sha512-6QsHnkqyVEzYcaiHsOKkzOtOgdJcb8i54x6AV2hDwyZcY9ZyykGZVw6L/YN98xC0evwTP6utsWWrKRaa8QlfEQ==
dependencies:
commander "^4.0.0"
glob "7.1.6"
lines-and-columns "^1.1.6"
mz "^2.7.0"
pirates "^4.0.1"
ts-interface-checker "^0.1.9"
supports-color@^7.1.0:
version "7.2.0"
resolved "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz"
integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==
dependencies:
has-flag "^4.0.0"
supports-preserve-symlinks-flag@^1.0.0:
version "1.0.0"
resolved "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz"
integrity sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==
synckit@^0.8.5:
version "0.8.5"
resolved "https://registry.npmjs.org/synckit/-/synckit-0.8.5.tgz"
integrity sha512-L1dapNV6vu2s/4Sputv8xGsCdAVlb5nRDMFU/E27D44l5U6cw1g0dGd45uLc+OXjNMmF4ntiMdCimzcjFKQI8Q==
dependencies:
"@pkgr/utils" "^2.3.1"
tslib "^2.5.0"
tailwindcss@^3, tailwindcss@^3.3.1:
version "3.3.1"
resolved "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.3.1.tgz"
integrity sha512-Vkiouc41d4CEq0ujXl6oiGFQ7bA3WEhUZdTgXAhtKxSy49OmKs8rEfQmupsfF0IGW8fv2iQkp1EVUuapCFrZ9g==
dependencies:
arg "^5.0.2"
chokidar "^3.5.3"
color-name "^1.1.4"
didyoumean "^1.2.2"
dlv "^1.1.3"
fast-glob "^3.2.12"
glob-parent "^6.0.2"
is-glob "^4.0.3"
jiti "^1.17.2"
lilconfig "^2.0.6"
micromatch "^4.0.5"
normalize-path "^3.0.0"
object-hash "^3.0.0"
picocolors "^1.0.0"
postcss "^8.0.9"
postcss-import "^14.1.0"
postcss-js "^4.0.0"
postcss-load-config "^3.1.4"
postcss-nested "6.0.0"
postcss-selector-parser "^6.0.11"
postcss-value-parser "^4.2.0"
quick-lru "^5.1.1"
resolve "^1.22.1"
sucrase "^3.29.0"
tapable@^2.2.0:
version "2.2.1"
resolved "https://registry.npmjs.org/tapable/-/tapable-2.2.1.tgz"
integrity sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==
text-table@^0.2.0:
version "0.2.0"
resolved "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz"
integrity sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==
thenify-all@^1.0.0:
version "1.6.0"
resolved "https://registry.npmjs.org/thenify-all/-/thenify-all-1.6.0.tgz"
integrity sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==
dependencies:
thenify ">= 3.1.0 < 4"
"thenify@>= 3.1.0 < 4":
version "3.3.1"
resolved "https://registry.npmjs.org/thenify/-/thenify-3.3.1.tgz"
integrity sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==
dependencies:
any-promise "^1.0.0"
tiny-glob@^0.2.9:
version "0.2.9"
resolved "https://registry.npmjs.org/tiny-glob/-/tiny-glob-0.2.9.tgz"
integrity sha512-g/55ssRPUjShh+xkfx9UPDXqhckHEsHr4Vd9zX55oSdGZc/MD0m3sferOkwWtp98bv+kcVfEHtRJgBVJzelrzg==
dependencies:
globalyzer "0.1.0"
globrex "^0.1.2"
to-regex-range@^5.0.1:
version "5.0.1"
resolved "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz"
integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==
dependencies:
is-number "^7.0.0"
trim-lines@^3.0.0:
version "3.0.1"
resolved "https://registry.npmjs.org/trim-lines/-/trim-lines-3.0.1.tgz"
integrity sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==
trough@^2.0.0:
version "2.1.0"
resolved "https://registry.npmjs.org/trough/-/trough-2.1.0.tgz"
integrity sha512-AqTiAOLcj85xS7vQ8QkAV41hPDIJ71XJB4RCUrzo/1GM2CQwhkJGaf9Hgr7BOugMRpgGUrqRg/DrBDl4H40+8g==
ts-interface-checker@^0.1.9:
version "0.1.13"
resolved "https://registry.npmjs.org/ts-interface-checker/-/ts-interface-checker-0.1.13.tgz"
integrity sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==
tsconfig-paths@^3.14.1:
version "3.14.2"
resolved "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-3.14.2.tgz"
integrity sha512-o/9iXgCYc5L/JxCHPe3Hvh8Q/2xm5Z+p18PESBU6Ff33695QnCHBEjcytY2q19ua7Mbl/DavtBOLq+oG0RCL+g==
dependencies:
"@types/json5" "^0.0.29"
json5 "^1.0.2"
minimist "^1.2.6"
strip-bom "^3.0.0"
tslib@^1.8.1:
version "1.14.1"
resolved "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz"
integrity sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==
tslib@^2.4.0, tslib@^2.5.0:
version "2.5.0"
resolved "https://registry.npmjs.org/tslib/-/tslib-2.5.0.tgz"
integrity sha512-336iVw3rtn2BUK7ORdIAHTyxHGRIHVReokCR3XjbckJMK7ms8FysBfhLR8IXnAgy7T0PTPNBWKiH514FOW/WSg==
tsutils@^3.21.0:
version "3.21.0"
resolved "https://registry.npmjs.org/tsutils/-/tsutils-3.21.0.tgz"
integrity sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==
dependencies:
tslib "^1.8.1"
type-check@^0.4.0, type-check@~0.4.0:
version "0.4.0"
resolved "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz"
integrity sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==
dependencies:
prelude-ls "^1.2.1"
type-fest@^0.20.2:
version "0.20.2"
resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz"
integrity sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==
typed-array-length@^1.0.4:
version "1.0.4"
resolved "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.4.tgz"
integrity sha512-KjZypGq+I/H7HI5HlOoGHkWUUGq+Q0TPhQurLbyrVrvnKTBgzLhIJ7j6J/XTQOi0d1RjyZ0wdas8bKs2p0x3Ng==
dependencies:
call-bind "^1.0.2"
for-each "^0.3.3"
is-typed-array "^1.1.9"
typescript@5.0.3:
version "5.0.3"
resolved "https://registry.npmjs.org/typescript/-/typescript-5.0.3.tgz"
integrity sha512-xv8mOEDnigb/tN9PSMTwSEqAnUvkoXMQlicOb0IUVDBSQCgBSaAAROUZYy2IcUy5qU6XajK5jjjO7TMWqBTKZA==
unbox-primitive@^1.0.2:
version "1.0.2"
resolved "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.2.tgz"
integrity sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==
dependencies:
call-bind "^1.0.2"
has-bigints "^1.0.2"
has-symbols "^1.0.3"
which-boxed-primitive "^1.0.2"
unified@^10.0.0:
version "10.1.2"
resolved "https://registry.npmjs.org/unified/-/unified-10.1.2.tgz"
integrity sha512-pUSWAi/RAnVy1Pif2kAoeWNBa3JVrx0MId2LASj8G+7AiHWoKZNTomq6LG326T68U7/e263X6fTdcXIy7XnF7Q==
dependencies:
"@types/unist" "^2.0.0"
bail "^2.0.0"
extend "^3.0.0"
is-buffer "^2.0.0"
is-plain-obj "^4.0.0"
trough "^2.0.0"
vfile "^5.0.0"
unist-util-generated@^2.0.0:
version "2.0.1"
resolved "https://registry.npmjs.org/unist-util-generated/-/unist-util-generated-2.0.1.tgz"
integrity sha512-qF72kLmPxAw0oN2fwpWIqbXAVyEqUzDHMsbtPvOudIlUzXYFIeQIuxXQCRCFh22B7cixvU0MG7m3MW8FTq/S+A==
unist-util-is@^5.0.0:
version "5.2.1"
resolved "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.2.1.tgz"
integrity sha512-u9njyyfEh43npf1M+yGKDGVPbY/JWEemg5nH05ncKPfi+kBbKBJoTdsogMu33uhytuLlv9y0O7GH7fEdwLdLQw==
dependencies:
"@types/unist" "^2.0.0"
unist-util-position@^4.0.0:
version "4.0.4"
resolved "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.4.tgz"
integrity sha512-kUBE91efOWfIVBo8xzh/uZQ7p9ffYRtUbMRZBNFYwf0RK8koUMx6dGUfwylLOKmaT2cs4wSW96QoYUSXAyEtpg==
dependencies:
"@types/unist" "^2.0.0"
unist-util-stringify-position@^3.0.0:
version "3.0.3"
resolved "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-3.0.3.tgz"
integrity sha512-k5GzIBZ/QatR8N5X2y+drfpWG8IDBzdnVj6OInRNWm1oXrzydiaAT2OQiA8DPRRZyAKb9b6I2a6PxYklZD0gKg==
dependencies:
"@types/unist" "^2.0.0"
unist-util-visit-parents@^5.1.1:
version "5.1.3"
resolved "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.1.3.tgz"
integrity sha512-x6+y8g7wWMyQhL1iZfhIPhDAs7Xwbn9nRosDXl7qoPTSCy0yNxnKc+hWokFifWQIDGi154rdUqKvbCa4+1kLhg==
dependencies:
"@types/unist" "^2.0.0"
unist-util-is "^5.0.0"
unist-util-visit@^4.0.0:
version "4.1.2"
resolved "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.1.2.tgz"
integrity sha512-MSd8OUGISqHdVvfY9TPhyK2VdUrPgxkUtWSuMHF6XAAFuL4LokseigBnZtPnJMu+FbynTkFNnFlyjxpVKujMRg==
dependencies:
"@types/unist" "^2.0.0"
unist-util-is "^5.0.0"
unist-util-visit-parents "^5.1.1"
update-browserslist-db@^1.0.10:
version "1.0.10"
resolved "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.10.tgz"
integrity sha512-OztqDenkfFkbSG+tRxBeAnCVPckDBcvibKd35yDONx6OU8N7sqgwc7rCbkJ/WcYtVRZ4ba68d6byhC21GFh7sQ==
dependencies:
escalade "^3.1.1"
picocolors "^1.0.0"
uri-js@^4.2.2:
version "4.4.1"
resolved "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz"
integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==
dependencies:
punycode "^2.1.0"
util-deprecate@^1.0.2:
version "1.0.2"
resolved "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz"
integrity sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==
uvu@^0.5.0:
version "0.5.6"
resolved "https://registry.npmjs.org/uvu/-/uvu-0.5.6.tgz"
integrity sha512-+g8ENReyr8YsOc6fv/NVJs2vFdHBnBNdfE49rshrTzDWOlUx4Gq7KOS2GD8eqhy2j+Ejq29+SbKH8yjkAqXqoA==
dependencies:
dequal "^2.0.0"
diff "^5.0.0"
kleur "^4.0.3"
sade "^1.7.3"
vfile-location@^4.0.0:
version "4.1.0"
resolved "https://registry.npmjs.org/vfile-location/-/vfile-location-4.1.0.tgz"
integrity sha512-YF23YMyASIIJXpktBa4vIGLJ5Gs88UB/XePgqPmTa7cDA+JeO3yclbpheQYCHjVHBn/yePzrXuygIL+xbvRYHw==
dependencies:
"@types/unist" "^2.0.0"
vfile "^5.0.0"
vfile-message@^3.0.0:
version "3.1.4"
resolved "https://registry.npmjs.org/vfile-message/-/vfile-message-3.1.4.tgz"
integrity sha512-fa0Z6P8HUrQN4BZaX05SIVXic+7kE3b05PWAtPuYP9QLHsLKYR7/AlLW3NtOrpXRLeawpDLMsVkmk5DG0NXgWw==
dependencies:
"@types/unist" "^2.0.0"
unist-util-stringify-position "^3.0.0"
vfile@^5.0.0:
version "5.3.7"
resolved "https://registry.npmjs.org/vfile/-/vfile-5.3.7.tgz"
integrity sha512-r7qlzkgErKjobAmyNIkkSpizsFPYiUPuJb5pNW1RB4JcYVZhs4lIbVqk8XPk033CV/1z8ss5pkax8SuhGpcG8g==
dependencies:
"@types/unist" "^2.0.0"
is-buffer "^2.0.0"
unist-util-stringify-position "^3.0.0"
vfile-message "^3.0.0"
web-namespaces@^2.0.0:
version "2.0.1"
resolved "https://registry.npmjs.org/web-namespaces/-/web-namespaces-2.0.1.tgz"
integrity sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ==
which-boxed-primitive@^1.0.2:
version "1.0.2"
resolved "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz"
integrity sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==
dependencies:
is-bigint "^1.0.1"
is-boolean-object "^1.1.0"
is-number-object "^1.0.4"
is-string "^1.0.5"
is-symbol "^1.0.3"
which-collection@^1.0.1:
version "1.0.1"
resolved "https://registry.npmjs.org/which-collection/-/which-collection-1.0.1.tgz"
integrity sha512-W8xeTUwaln8i3K/cY1nGXzdnVZlidBcagyNFtBdD5kxnb4TvGKR7FfSIS3mYpwWS1QUCutfKz8IY8RjftB0+1A==
dependencies:
is-map "^2.0.1"
is-set "^2.0.1"
is-weakmap "^2.0.1"
is-weakset "^2.0.1"
which-typed-array@^1.1.9:
version "1.1.9"
resolved "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.9.tgz"
integrity sha512-w9c4xkx6mPidwp7180ckYWfMmvxpjlZuIudNtDf4N/tTAUB8VJbX25qZoAsrtGuYNnGw3pa0AXgbGKRB8/EceA==
dependencies:
available-typed-arrays "^1.0.5"
call-bind "^1.0.2"
for-each "^0.3.3"
gopd "^1.0.1"
has-tostringtag "^1.0.0"
is-typed-array "^1.1.10"
which@^2.0.1:
version "2.0.2"
resolved "https://registry.npmjs.org/which/-/which-2.0.2.tgz"
integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==
dependencies:
isexe "^2.0.0"
word-wrap@^1.2.3:
version "1.2.3"
resolved "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.3.tgz"
integrity sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==
wrappy@1:
version "1.0.2"
resolved "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz"
integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==
yallist@^4.0.0:
version "4.0.0"
resolved "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz"
integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==
yaml@^1.10.2:
version "1.10.2"
resolved "https://registry.npmjs.org/yaml/-/yaml-1.10.2.tgz"
integrity sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==
yocto-queue@^0.1.0:
version "0.1.0"
resolved "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz"
integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==
zwitch@^2.0.0, zwitch@^2.0.4:
version "2.0.4"
resolved "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz"
integrity sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==
| 0
|
solana_public_repos/nautilus-project/nautilus
|
solana_public_repos/nautilus-project/nautilus/docs/package-lock.json
|
{
"name": "docs",
"version": "0.1.0",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "docs",
"version": "0.1.0",
"dependencies": {
"@tailwindcss/typography": "^0.5.9",
"@types/node": "18.15.11",
"@types/react": "18.0.32",
"@types/react-dom": "18.0.11",
"daisyui": "^2.51.5",
"eslint": "8.37.0",
"eslint-config-next": "13.2.4",
"gray-matter": "^4.0.3",
"next": "13.2.4",
"react": "18.2.0",
"react-dom": "18.2.0",
"remark": "^14.0.2",
"remark-html": "^15.0.2",
"typescript": "5.0.3"
},
"devDependencies": {
"autoprefixer": "^10.4.14",
"postcss": "^8.4.21",
"tailwindcss": "^3.3.1"
}
},
"node_modules/@babel/runtime": {
"version": "7.21.0",
"resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.21.0.tgz",
"integrity": "sha512-xwII0//EObnq89Ji5AKYQaRYiW/nZ3llSv29d49IuxPhKbtJoLP+9QUUZ4nVragQVtaVGeZrpB+ZtG/Pdy/POw==",
"dependencies": {
"regenerator-runtime": "^0.13.11"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/@eslint-community/eslint-utils": {
"version": "4.4.0",
"resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz",
"integrity": "sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==",
"dependencies": {
"eslint-visitor-keys": "^3.3.0"
},
"engines": {
"node": "^12.22.0 || ^14.17.0 || >=16.0.0"
},
"peerDependencies": {
"eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
}
},
"node_modules/@eslint-community/regexpp": {
"version": "4.5.0",
"resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.5.0.tgz",
"integrity": "sha512-vITaYzIcNmjn5tF5uxcZ/ft7/RXGrMUIS9HalWckEOF6ESiwXKoMzAQf2UW0aVd6rnOeExTJVd5hmWXucBKGXQ==",
"engines": {
"node": "^12.0.0 || ^14.0.0 || >=16.0.0"
}
},
"node_modules/@eslint/eslintrc": {
"version": "2.0.2",
"resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.0.2.tgz",
"integrity": "sha512-3W4f5tDUra+pA+FzgugqL2pRimUTDJWKr7BINqOpkZrC0uYI0NIc0/JFgBROCU07HR6GieA5m3/rsPIhDmCXTQ==",
"dependencies": {
"ajv": "^6.12.4",
"debug": "^4.3.2",
"espree": "^9.5.1",
"globals": "^13.19.0",
"ignore": "^5.2.0",
"import-fresh": "^3.2.1",
"js-yaml": "^4.1.0",
"minimatch": "^3.1.2",
"strip-json-comments": "^3.1.1"
},
"engines": {
"node": "^12.22.0 || ^14.17.0 || >=16.0.0"
},
"funding": {
"url": "https://opencollective.com/eslint"
}
},
"node_modules/@eslint/js": {
"version": "8.37.0",
"resolved": "https://registry.npmjs.org/@eslint/js/-/js-8.37.0.tgz",
"integrity": "sha512-x5vzdtOOGgFVDCUs81QRB2+liax8rFg3+7hqM+QhBG0/G3F1ZsoYl97UrqgHgQ9KKT7G6c4V+aTUCgu/n22v1A==",
"engines": {
"node": "^12.22.0 || ^14.17.0 || >=16.0.0"
}
},
"node_modules/@humanwhocodes/config-array": {
"version": "0.11.8",
"resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.11.8.tgz",
"integrity": "sha512-UybHIJzJnR5Qc/MsD9Kr+RpO2h+/P1GhOwdiLPXK5TWk5sgTdu88bTD9UP+CKbPPh5Rni1u0GjAdYQLemG8g+g==",
"dependencies": {
"@humanwhocodes/object-schema": "^1.2.1",
"debug": "^4.1.1",
"minimatch": "^3.0.5"
},
"engines": {
"node": ">=10.10.0"
}
},
"node_modules/@humanwhocodes/module-importer": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz",
"integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==",
"engines": {
"node": ">=12.22"
},
"funding": {
"type": "github",
"url": "https://github.com/sponsors/nzakas"
}
},
"node_modules/@humanwhocodes/object-schema": {
"version": "1.2.1",
"resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz",
"integrity": "sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA=="
},
"node_modules/@next/env": {
"version": "13.2.4",
"resolved": "https://registry.npmjs.org/@next/env/-/env-13.2.4.tgz",
"integrity": "sha512-+Mq3TtpkeeKFZanPturjcXt+KHfKYnLlX6jMLyCrmpq6OOs4i1GqBOAauSkii9QeKCMTYzGppar21JU57b/GEA=="
},
"node_modules/@next/eslint-plugin-next": {
"version": "13.2.4",
"resolved": "https://registry.npmjs.org/@next/eslint-plugin-next/-/eslint-plugin-next-13.2.4.tgz",
"integrity": "sha512-ck1lI+7r1mMJpqLNa3LJ5pxCfOB1lfJncKmRJeJxcJqcngaFwylreLP7da6Rrjr6u2gVRTfmnkSkjc80IiQCwQ==",
"dependencies": {
"glob": "7.1.7"
}
},
"node_modules/@next/swc-android-arm-eabi": {
"version": "13.2.4",
"resolved": "https://registry.npmjs.org/@next/swc-android-arm-eabi/-/swc-android-arm-eabi-13.2.4.tgz",
"integrity": "sha512-DWlalTSkLjDU11MY11jg17O1gGQzpRccM9Oes2yTqj2DpHndajrXHGxj9HGtJ+idq2k7ImUdJVWS2h2l/EDJOw==",
"cpu": [
"arm"
],
"optional": true,
"os": [
"android"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@next/swc-android-arm64": {
"version": "13.2.4",
"resolved": "https://registry.npmjs.org/@next/swc-android-arm64/-/swc-android-arm64-13.2.4.tgz",
"integrity": "sha512-sRavmUImUCf332Gy+PjIfLkMhiRX1Ez4SI+3vFDRs1N5eXp+uNzjFUK/oLMMOzk6KFSkbiK/3Wt8+dHQR/flNg==",
"cpu": [
"arm64"
],
"optional": true,
"os": [
"android"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@next/swc-darwin-arm64": {
"version": "13.2.4",
"resolved": "https://registry.npmjs.org/@next/swc-darwin-arm64/-/swc-darwin-arm64-13.2.4.tgz",
"integrity": "sha512-S6vBl+OrInP47TM3LlYx65betocKUUlTZDDKzTiRDbsRESeyIkBtZ6Qi5uT2zQs4imqllJznVjFd1bXLx3Aa6A==",
"cpu": [
"arm64"
],
"optional": true,
"os": [
"darwin"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@next/swc-darwin-x64": {
"version": "13.2.4",
"resolved": "https://registry.npmjs.org/@next/swc-darwin-x64/-/swc-darwin-x64-13.2.4.tgz",
"integrity": "sha512-a6LBuoYGcFOPGd4o8TPo7wmv5FnMr+Prz+vYHopEDuhDoMSHOnC+v+Ab4D7F0NMZkvQjEJQdJS3rqgFhlZmKlw==",
"cpu": [
"x64"
],
"optional": true,
"os": [
"darwin"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@next/swc-freebsd-x64": {
"version": "13.2.4",
"resolved": "https://registry.npmjs.org/@next/swc-freebsd-x64/-/swc-freebsd-x64-13.2.4.tgz",
"integrity": "sha512-kkbzKVZGPaXRBPisoAQkh3xh22r+TD+5HwoC5bOkALraJ0dsOQgSMAvzMXKsN3tMzJUPS0tjtRf1cTzrQ0I5vQ==",
"cpu": [
"x64"
],
"optional": true,
"os": [
"freebsd"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@next/swc-linux-arm-gnueabihf": {
"version": "13.2.4",
"resolved": "https://registry.npmjs.org/@next/swc-linux-arm-gnueabihf/-/swc-linux-arm-gnueabihf-13.2.4.tgz",
"integrity": "sha512-7qA1++UY0fjprqtjBZaOA6cas/7GekpjVsZn/0uHvquuITFCdKGFCsKNBx3S0Rpxmx6WYo0GcmhNRM9ru08BGg==",
"cpu": [
"arm"
],
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@next/swc-linux-arm64-gnu": {
"version": "13.2.4",
"resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-gnu/-/swc-linux-arm64-gnu-13.2.4.tgz",
"integrity": "sha512-xzYZdAeq883MwXgcwc72hqo/F/dwUxCukpDOkx/j1HTq/J0wJthMGjinN9wH5bPR98Mfeh1MZJ91WWPnZOedOg==",
"cpu": [
"arm64"
],
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@next/swc-linux-arm64-musl": {
"version": "13.2.4",
"resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-musl/-/swc-linux-arm64-musl-13.2.4.tgz",
"integrity": "sha512-8rXr3WfmqSiYkb71qzuDP6I6R2T2tpkmf83elDN8z783N9nvTJf2E7eLx86wu2OJCi4T05nuxCsh4IOU3LQ5xw==",
"cpu": [
"arm64"
],
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@next/swc-linux-x64-gnu": {
"version": "13.2.4",
"resolved": "https://registry.npmjs.org/@next/swc-linux-x64-gnu/-/swc-linux-x64-gnu-13.2.4.tgz",
"integrity": "sha512-Ngxh51zGSlYJ4EfpKG4LI6WfquulNdtmHg1yuOYlaAr33KyPJp4HeN/tivBnAHcZkoNy0hh/SbwDyCnz5PFJQQ==",
"cpu": [
"x64"
],
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@next/swc-linux-x64-musl": {
"version": "13.2.4",
"resolved": "https://registry.npmjs.org/@next/swc-linux-x64-musl/-/swc-linux-x64-musl-13.2.4.tgz",
"integrity": "sha512-gOvwIYoSxd+j14LOcvJr+ekd9fwYT1RyMAHOp7znA10+l40wkFiMONPLWiZuHxfRk+Dy7YdNdDh3ImumvL6VwA==",
"cpu": [
"x64"
],
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@next/swc-win32-arm64-msvc": {
"version": "13.2.4",
"resolved": "https://registry.npmjs.org/@next/swc-win32-arm64-msvc/-/swc-win32-arm64-msvc-13.2.4.tgz",
"integrity": "sha512-q3NJzcfClgBm4HvdcnoEncmztxrA5GXqKeiZ/hADvC56pwNALt3ngDC6t6qr1YW9V/EPDxCYeaX4zYxHciW4Dw==",
"cpu": [
"arm64"
],
"optional": true,
"os": [
"win32"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@next/swc-win32-ia32-msvc": {
"version": "13.2.4",
"resolved": "https://registry.npmjs.org/@next/swc-win32-ia32-msvc/-/swc-win32-ia32-msvc-13.2.4.tgz",
"integrity": "sha512-/eZ5ncmHUYtD2fc6EUmAIZlAJnVT2YmxDsKs1Ourx0ttTtvtma/WKlMV5NoUsyOez0f9ExLyOpeCoz5aj+MPXw==",
"cpu": [
"ia32"
],
"optional": true,
"os": [
"win32"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@next/swc-win32-x64-msvc": {
"version": "13.2.4",
"resolved": "https://registry.npmjs.org/@next/swc-win32-x64-msvc/-/swc-win32-x64-msvc-13.2.4.tgz",
"integrity": "sha512-0MffFmyv7tBLlji01qc0IaPP/LVExzvj7/R5x1Jph1bTAIj4Vu81yFQWHHQAP6r4ff9Ukj1mBK6MDNVXm7Tcvw==",
"cpu": [
"x64"
],
"optional": true,
"os": [
"win32"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@nodelib/fs.scandir": {
"version": "2.1.5",
"resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
"integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
"dependencies": {
"@nodelib/fs.stat": "2.0.5",
"run-parallel": "^1.1.9"
},
"engines": {
"node": ">= 8"
}
},
"node_modules/@nodelib/fs.stat": {
"version": "2.0.5",
"resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
"integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
"engines": {
"node": ">= 8"
}
},
"node_modules/@nodelib/fs.walk": {
"version": "1.2.8",
"resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
"integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
"dependencies": {
"@nodelib/fs.scandir": "2.1.5",
"fastq": "^1.6.0"
},
"engines": {
"node": ">= 8"
}
},
"node_modules/@pkgr/utils": {
"version": "2.3.1",
"resolved": "https://registry.npmjs.org/@pkgr/utils/-/utils-2.3.1.tgz",
"integrity": "sha512-wfzX8kc1PMyUILA+1Z/EqoE4UCXGy0iRGMhPwdfae1+f0OXlLqCk+By+aMzgJBzR9AzS4CDizioG6Ss1gvAFJw==",
"dependencies": {
"cross-spawn": "^7.0.3",
"is-glob": "^4.0.3",
"open": "^8.4.0",
"picocolors": "^1.0.0",
"tiny-glob": "^0.2.9",
"tslib": "^2.4.0"
},
"engines": {
"node": "^12.20.0 || ^14.18.0 || >=16.0.0"
},
"funding": {
"url": "https://opencollective.com/unts"
}
},
"node_modules/@rushstack/eslint-patch": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/@rushstack/eslint-patch/-/eslint-patch-1.2.0.tgz",
"integrity": "sha512-sXo/qW2/pAcmT43VoRKOJbDOfV3cYpq3szSVfIThQXNt+E4DfKj361vaAt3c88U5tPUxzEswam7GW48PJqtKAg=="
},
"node_modules/@swc/helpers": {
"version": "0.4.14",
"resolved": "https://registry.npmjs.org/@swc/helpers/-/helpers-0.4.14.tgz",
"integrity": "sha512-4C7nX/dvpzB7za4Ql9K81xK3HPxCpHMgwTZVyf+9JQ6VUbn9jjZVN7/Nkdz/Ugzs2CSjqnL/UPXroiVBVHUWUw==",
"dependencies": {
"tslib": "^2.4.0"
}
},
"node_modules/@tailwindcss/typography": {
"version": "0.5.9",
"resolved": "https://registry.npmjs.org/@tailwindcss/typography/-/typography-0.5.9.tgz",
"integrity": "sha512-t8Sg3DyynFysV9f4JDOVISGsjazNb48AeIYQwcL+Bsq5uf4RYL75C1giZ43KISjeDGBaTN3Kxh7Xj/vRSMJUUg==",
"dependencies": {
"lodash.castarray": "^4.4.0",
"lodash.isplainobject": "^4.0.6",
"lodash.merge": "^4.6.2",
"postcss-selector-parser": "6.0.10"
},
"peerDependencies": {
"tailwindcss": ">=3.0.0 || insiders"
}
},
"node_modules/@types/debug": {
"version": "4.1.7",
"resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.7.tgz",
"integrity": "sha512-9AonUzyTjXXhEOa0DnqpzZi6VHlqKMswga9EXjpXnnqxwLtdvPPtlO8evrI5D9S6asFRCQ6v+wpiUKbw+vKqyg==",
"dependencies": {
"@types/ms": "*"
}
},
"node_modules/@types/hast": {
"version": "2.3.4",
"resolved": "https://registry.npmjs.org/@types/hast/-/hast-2.3.4.tgz",
"integrity": "sha512-wLEm0QvaoawEDoTRwzTXp4b4jpwiJDvR5KMnFnVodm3scufTlBOWRD6N1OBf9TZMhjlNsSfcO5V+7AF4+Vy+9g==",
"dependencies": {
"@types/unist": "*"
}
},
"node_modules/@types/json5": {
"version": "0.0.29",
"resolved": "https://registry.npmjs.org/@types/json5/-/json5-0.0.29.tgz",
"integrity": "sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ=="
},
"node_modules/@types/mdast": {
"version": "3.0.11",
"resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.11.tgz",
"integrity": "sha512-Y/uImid8aAwrEA24/1tcRZwpxX3pIFTSilcNDKSPn+Y2iDywSEachzRuvgAYYLR3wpGXAsMbv5lvKLDZLeYPAw==",
"dependencies": {
"@types/unist": "*"
}
},
"node_modules/@types/ms": {
"version": "0.7.31",
"resolved": "https://registry.npmjs.org/@types/ms/-/ms-0.7.31.tgz",
"integrity": "sha512-iiUgKzV9AuaEkZqkOLDIvlQiL6ltuZd9tGcW3gwpnX8JbuiuhFlEGmmFXEXkN50Cvq7Os88IY2v0dkDqXYWVgA=="
},
"node_modules/@types/node": {
"version": "18.15.11",
"resolved": "https://registry.npmjs.org/@types/node/-/node-18.15.11.tgz",
"integrity": "sha512-E5Kwq2n4SbMzQOn6wnmBjuK9ouqlURrcZDVfbo9ftDDTFt3nk7ZKK4GMOzoYgnpQJKcxwQw+lGaBvvlMo0qN/Q=="
},
"node_modules/@types/parse5": {
"version": "6.0.3",
"resolved": "https://registry.npmjs.org/@types/parse5/-/parse5-6.0.3.tgz",
"integrity": "sha512-SuT16Q1K51EAVPz1K29DJ/sXjhSQ0zjvsypYJ6tlwVsRV9jwW5Adq2ch8Dq8kDBCkYnELS7N7VNCSB5nC56t/g=="
},
"node_modules/@types/prop-types": {
"version": "15.7.5",
"resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.5.tgz",
"integrity": "sha512-JCB8C6SnDoQf0cNycqd/35A7MjcnK+ZTqE7judS6o7utxUCg6imJg3QK2qzHKszlTjcj2cn+NwMB2i96ubpj7w=="
},
"node_modules/@types/react": {
"version": "18.0.32",
"resolved": "https://registry.npmjs.org/@types/react/-/react-18.0.32.tgz",
"integrity": "sha512-gYGXdtPQ9Cj0w2Fwqg5/ak6BcK3Z15YgjSqtyDizWUfx7mQ8drs0NBUzRRsAdoFVTO8kJ8L2TL8Skm7OFPnLUw==",
"dependencies": {
"@types/prop-types": "*",
"@types/scheduler": "*",
"csstype": "^3.0.2"
}
},
"node_modules/@types/react-dom": {
"version": "18.0.11",
"resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-18.0.11.tgz",
"integrity": "sha512-O38bPbI2CWtgw/OoQoY+BRelw7uysmXbWvw3nLWO21H1HSh+GOlqPuXshJfjmpNlKiiSDG9cc1JZAaMmVdcTlw==",
"dependencies": {
"@types/react": "*"
}
},
"node_modules/@types/scheduler": {
"version": "0.16.3",
"resolved": "https://registry.npmjs.org/@types/scheduler/-/scheduler-0.16.3.tgz",
"integrity": "sha512-5cJ8CB4yAx7BH1oMvdU0Jh9lrEXyPkar6F9G/ERswkCuvP4KQZfZkSjcMbAICCpQTN4OuZn8tz0HiKv9TGZgrQ=="
},
"node_modules/@types/unist": {
"version": "2.0.6",
"resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.6.tgz",
"integrity": "sha512-PBjIUxZHOuj0R15/xuwJYjFi+KZdNFrehocChv4g5hu6aFroHue8m0lBP0POdK2nKzbw0cgV1mws8+V/JAcEkQ=="
},
"node_modules/@typescript-eslint/parser": {
"version": "5.57.0",
"resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.57.0.tgz",
"integrity": "sha512-orrduvpWYkgLCyAdNtR1QIWovcNZlEm6yL8nwH/eTxWLd8gsP+25pdLHYzL2QdkqrieaDwLpytHqycncv0woUQ==",
"dependencies": {
"@typescript-eslint/scope-manager": "5.57.0",
"@typescript-eslint/types": "5.57.0",
"@typescript-eslint/typescript-estree": "5.57.0",
"debug": "^4.3.4"
},
"engines": {
"node": "^12.22.0 || ^14.17.0 || >=16.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/typescript-eslint"
},
"peerDependencies": {
"eslint": "^6.0.0 || ^7.0.0 || ^8.0.0"
},
"peerDependenciesMeta": {
"typescript": {
"optional": true
}
}
},
"node_modules/@typescript-eslint/scope-manager": {
"version": "5.57.0",
"resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.57.0.tgz",
"integrity": "sha512-NANBNOQvllPlizl9LatX8+MHi7bx7WGIWYjPHDmQe5Si/0YEYfxSljJpoTyTWFTgRy3X8gLYSE4xQ2U+aCozSw==",
"dependencies": {
"@typescript-eslint/types": "5.57.0",
"@typescript-eslint/visitor-keys": "5.57.0"
},
"engines": {
"node": "^12.22.0 || ^14.17.0 || >=16.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/typescript-eslint"
}
},
"node_modules/@typescript-eslint/types": {
"version": "5.57.0",
"resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.57.0.tgz",
"integrity": "sha512-mxsod+aZRSyLT+jiqHw1KK6xrANm19/+VFALVFP5qa/aiJnlP38qpyaTd0fEKhWvQk6YeNZ5LGwI1pDpBRBhtQ==",
"engines": {
"node": "^12.22.0 || ^14.17.0 || >=16.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/typescript-eslint"
}
},
"node_modules/@typescript-eslint/typescript-estree": {
"version": "5.57.0",
"resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-5.57.0.tgz",
"integrity": "sha512-LTzQ23TV82KpO8HPnWuxM2V7ieXW8O142I7hQTxWIHDcCEIjtkat6H96PFkYBQqGFLW/G/eVVOB9Z8rcvdY/Vw==",
"dependencies": {
"@typescript-eslint/types": "5.57.0",
"@typescript-eslint/visitor-keys": "5.57.0",
"debug": "^4.3.4",
"globby": "^11.1.0",
"is-glob": "^4.0.3",
"semver": "^7.3.7",
"tsutils": "^3.21.0"
},
"engines": {
"node": "^12.22.0 || ^14.17.0 || >=16.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/typescript-eslint"
},
"peerDependenciesMeta": {
"typescript": {
"optional": true
}
}
},
"node_modules/@typescript-eslint/visitor-keys": {
"version": "5.57.0",
"resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.57.0.tgz",
"integrity": "sha512-ery2g3k0hv5BLiKpPuwYt9KBkAp2ugT6VvyShXdLOkax895EC55sP0Tx5L0fZaQueiK3fBLvHVvEl3jFS5ia+g==",
"dependencies": {
"@typescript-eslint/types": "5.57.0",
"eslint-visitor-keys": "^3.3.0"
},
"engines": {
"node": "^12.22.0 || ^14.17.0 || >=16.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/typescript-eslint"
}
},
"node_modules/acorn": {
"version": "8.8.2",
"resolved": "https://registry.npmjs.org/acorn/-/acorn-8.8.2.tgz",
"integrity": "sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw==",
"bin": {
"acorn": "bin/acorn"
},
"engines": {
"node": ">=0.4.0"
}
},
"node_modules/acorn-jsx": {
"version": "5.3.2",
"resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
"integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
"peerDependencies": {
"acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
}
},
"node_modules/ajv": {
"version": "6.12.6",
"resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
"integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
"dependencies": {
"fast-deep-equal": "^3.1.1",
"fast-json-stable-stringify": "^2.0.0",
"json-schema-traverse": "^0.4.1",
"uri-js": "^4.2.2"
},
"funding": {
"type": "github",
"url": "https://github.com/sponsors/epoberezkin"
}
},
"node_modules/ansi-regex": {
"version": "5.0.1",
"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
"integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
"engines": {
"node": ">=8"
}
},
"node_modules/ansi-styles": {
"version": "4.3.0",
"resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
"integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
"dependencies": {
"color-convert": "^2.0.1"
},
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/chalk/ansi-styles?sponsor=1"
}
},
"node_modules/any-promise": {
"version": "1.3.0",
"resolved": "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz",
"integrity": "sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A=="
},
"node_modules/anymatch": {
"version": "3.1.3",
"resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
"integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
"dependencies": {
"normalize-path": "^3.0.0",
"picomatch": "^2.0.4"
},
"engines": {
"node": ">= 8"
}
},
"node_modules/arg": {
"version": "5.0.2",
"resolved": "https://registry.npmjs.org/arg/-/arg-5.0.2.tgz",
"integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg=="
},
"node_modules/argparse": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
"integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="
},
"node_modules/aria-query": {
"version": "5.1.3",
"resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.1.3.tgz",
"integrity": "sha512-R5iJ5lkuHybztUfuOAznmboyjWq8O6sqNqtK7CLOqdydi54VNbORp49mb14KbWgG1QD3JFO9hJdZ+y4KutfdOQ==",
"dependencies": {
"deep-equal": "^2.0.5"
}
},
"node_modules/array-buffer-byte-length": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.0.tgz",
"integrity": "sha512-LPuwb2P+NrQw3XhxGc36+XSvuBPopovXYTR9Ew++Du9Yb/bx5AzBfrIsBoj0EZUifjQU+sHL21sseZ3jerWO/A==",
"dependencies": {
"call-bind": "^1.0.2",
"is-array-buffer": "^3.0.1"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/array-includes": {
"version": "3.1.6",
"resolved": "https://registry.npmjs.org/array-includes/-/array-includes-3.1.6.tgz",
"integrity": "sha512-sgTbLvL6cNnw24FnbaDyjmvddQ2ML8arZsgaJhoABMoplz/4QRhtrYS+alr1BUM1Bwp6dhx8vVCBSLG+StwOFw==",
"dependencies": {
"call-bind": "^1.0.2",
"define-properties": "^1.1.4",
"es-abstract": "^1.20.4",
"get-intrinsic": "^1.1.3",
"is-string": "^1.0.7"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/array-union": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz",
"integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==",
"engines": {
"node": ">=8"
}
},
"node_modules/array.prototype.flat": {
"version": "1.3.1",
"resolved": "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.1.tgz",
"integrity": "sha512-roTU0KWIOmJ4DRLmwKd19Otg0/mT3qPNt0Qb3GWW8iObuZXxrjB/pzn0R3hqpRSWg4HCwqx+0vwOnWnvlOyeIA==",
"dependencies": {
"call-bind": "^1.0.2",
"define-properties": "^1.1.4",
"es-abstract": "^1.20.4",
"es-shim-unscopables": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/array.prototype.flatmap": {
"version": "1.3.1",
"resolved": "https://registry.npmjs.org/array.prototype.flatmap/-/array.prototype.flatmap-1.3.1.tgz",
"integrity": "sha512-8UGn9O1FDVvMNB0UlLv4voxRMze7+FpHyF5mSMRjWHUMlpoDViniy05870VlxhfgTnLbpuwTzvD76MTtWxB/mQ==",
"dependencies": {
"call-bind": "^1.0.2",
"define-properties": "^1.1.4",
"es-abstract": "^1.20.4",
"es-shim-unscopables": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/array.prototype.tosorted": {
"version": "1.1.1",
"resolved": "https://registry.npmjs.org/array.prototype.tosorted/-/array.prototype.tosorted-1.1.1.tgz",
"integrity": "sha512-pZYPXPRl2PqWcsUs6LOMn+1f1532nEoPTYowBtqLwAW+W8vSVhkIGnmOX1t/UQjD6YGI0vcD2B1U7ZFGQH9jnQ==",
"dependencies": {
"call-bind": "^1.0.2",
"define-properties": "^1.1.4",
"es-abstract": "^1.20.4",
"es-shim-unscopables": "^1.0.0",
"get-intrinsic": "^1.1.3"
}
},
"node_modules/ast-types-flow": {
"version": "0.0.7",
"resolved": "https://registry.npmjs.org/ast-types-flow/-/ast-types-flow-0.0.7.tgz",
"integrity": "sha512-eBvWn1lvIApYMhzQMsu9ciLfkBY499mFZlNqG+/9WR7PVlroQw0vG30cOQQbaKz3sCEc44TAOu2ykzqXSNnwag=="
},
"node_modules/autoprefixer": {
"version": "10.4.14",
"resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.14.tgz",
"integrity": "sha512-FQzyfOsTlwVzjHxKEqRIAdJx9niO6VCBCoEwax/VLSoQF29ggECcPuBqUMZ+u8jCZOPSy8b8/8KnuFbp0SaFZQ==",
"dev": true,
"funding": [
{
"type": "opencollective",
"url": "https://opencollective.com/postcss/"
},
{
"type": "tidelift",
"url": "https://tidelift.com/funding/github/npm/autoprefixer"
}
],
"dependencies": {
"browserslist": "^4.21.5",
"caniuse-lite": "^1.0.30001464",
"fraction.js": "^4.2.0",
"normalize-range": "^0.1.2",
"picocolors": "^1.0.0",
"postcss-value-parser": "^4.2.0"
},
"bin": {
"autoprefixer": "bin/autoprefixer"
},
"engines": {
"node": "^10 || ^12 || >=14"
},
"peerDependencies": {
"postcss": "^8.1.0"
}
},
"node_modules/available-typed-arrays": {
"version": "1.0.5",
"resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.5.tgz",
"integrity": "sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw==",
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/axe-core": {
"version": "4.6.3",
"resolved": "https://registry.npmjs.org/axe-core/-/axe-core-4.6.3.tgz",
"integrity": "sha512-/BQzOX780JhsxDnPpH4ZiyrJAzcd8AfzFPkv+89veFSr1rcMjuq2JDCwypKaPeB6ljHp9KjXhPpjgCvQlWYuqg==",
"engines": {
"node": ">=4"
}
},
"node_modules/axobject-query": {
"version": "3.1.1",
"resolved": "https://registry.npmjs.org/axobject-query/-/axobject-query-3.1.1.tgz",
"integrity": "sha512-goKlv8DZrK9hUh975fnHzhNIO4jUnFCfv/dszV5VwUGDFjI6vQ2VwoyjYjYNEbBE8AH87TduWP5uyDR1D+Iteg==",
"dependencies": {
"deep-equal": "^2.0.5"
}
},
"node_modules/bail": {
"version": "2.0.2",
"resolved": "https://registry.npmjs.org/bail/-/bail-2.0.2.tgz",
"integrity": "sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==",
"funding": {
"type": "github",
"url": "https://github.com/sponsors/wooorm"
}
},
"node_modules/balanced-match": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
"integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="
},
"node_modules/binary-extensions": {
"version": "2.2.0",
"resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz",
"integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==",
"engines": {
"node": ">=8"
}
},
"node_modules/brace-expansion": {
"version": "1.1.11",
"resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
"integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
"dependencies": {
"balanced-match": "^1.0.0",
"concat-map": "0.0.1"
}
},
"node_modules/braces": {
"version": "3.0.2",
"resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz",
"integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==",
"dependencies": {
"fill-range": "^7.0.1"
},
"engines": {
"node": ">=8"
}
},
"node_modules/browserslist": {
"version": "4.21.5",
"resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.21.5.tgz",
"integrity": "sha512-tUkiguQGW7S3IhB7N+c2MV/HZPSCPAAiYBZXLsBhFB/PCy6ZKKsZrmBayHV9fdGV/ARIfJ14NkxKzRDjvp7L6w==",
"dev": true,
"funding": [
{
"type": "opencollective",
"url": "https://opencollective.com/browserslist"
},
{
"type": "tidelift",
"url": "https://tidelift.com/funding/github/npm/browserslist"
}
],
"dependencies": {
"caniuse-lite": "^1.0.30001449",
"electron-to-chromium": "^1.4.284",
"node-releases": "^2.0.8",
"update-browserslist-db": "^1.0.10"
},
"bin": {
"browserslist": "cli.js"
},
"engines": {
"node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
}
},
"node_modules/call-bind": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz",
"integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==",
"dependencies": {
"function-bind": "^1.1.1",
"get-intrinsic": "^1.0.2"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/callsites": {
"version": "3.1.0",
"resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
"integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
"engines": {
"node": ">=6"
}
},
"node_modules/camelcase-css": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/camelcase-css/-/camelcase-css-2.0.1.tgz",
"integrity": "sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==",
"engines": {
"node": ">= 6"
}
},
"node_modules/caniuse-lite": {
"version": "1.0.30001473",
"resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001473.tgz",
"integrity": "sha512-ewDad7+D2vlyy+E4UJuVfiBsU69IL+8oVmTuZnH5Q6CIUbxNfI50uVpRHbUPDD6SUaN2o0Lh4DhTrvLG/Tn1yg==",
"funding": [
{
"type": "opencollective",
"url": "https://opencollective.com/browserslist"
},
{
"type": "tidelift",
"url": "https://tidelift.com/funding/github/npm/caniuse-lite"
},
{
"type": "github",
"url": "https://github.com/sponsors/ai"
}
]
},
"node_modules/ccount": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/ccount/-/ccount-2.0.1.tgz",
"integrity": "sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==",
"funding": {
"type": "github",
"url": "https://github.com/sponsors/wooorm"
}
},
"node_modules/chalk": {
"version": "4.1.2",
"resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
"integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
"dependencies": {
"ansi-styles": "^4.1.0",
"supports-color": "^7.1.0"
},
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/chalk/chalk?sponsor=1"
}
},
"node_modules/character-entities": {
"version": "2.0.2",
"resolved": "https://registry.npmjs.org/character-entities/-/character-entities-2.0.2.tgz",
"integrity": "sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ==",
"funding": {
"type": "github",
"url": "https://github.com/sponsors/wooorm"
}
},
"node_modules/character-entities-html4": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-2.1.0.tgz",
"integrity": "sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==",
"funding": {
"type": "github",
"url": "https://github.com/sponsors/wooorm"
}
},
"node_modules/character-entities-legacy": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-3.0.0.tgz",
"integrity": "sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==",
"funding": {
"type": "github",
"url": "https://github.com/sponsors/wooorm"
}
},
"node_modules/chokidar": {
"version": "3.5.3",
"resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz",
"integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==",
"funding": [
{
"type": "individual",
"url": "https://paulmillr.com/funding/"
}
],
"dependencies": {
"anymatch": "~3.1.2",
"braces": "~3.0.2",
"glob-parent": "~5.1.2",
"is-binary-path": "~2.1.0",
"is-glob": "~4.0.1",
"normalize-path": "~3.0.0",
"readdirp": "~3.6.0"
},
"engines": {
"node": ">= 8.10.0"
},
"optionalDependencies": {
"fsevents": "~2.3.2"
}
},
"node_modules/chokidar/node_modules/glob-parent": {
"version": "5.1.2",
"resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
"integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
"dependencies": {
"is-glob": "^4.0.1"
},
"engines": {
"node": ">= 6"
}
},
"node_modules/client-only": {
"version": "0.0.1",
"resolved": "https://registry.npmjs.org/client-only/-/client-only-0.0.1.tgz",
"integrity": "sha512-IV3Ou0jSMzZrd3pZ48nLkT9DA7Ag1pnPzaiQhpW7c3RbcqqzvzzVu+L8gfqMp/8IM2MQtSiqaCxrrcfu8I8rMA=="
},
"node_modules/color": {
"version": "4.2.3",
"resolved": "https://registry.npmjs.org/color/-/color-4.2.3.tgz",
"integrity": "sha512-1rXeuUUiGGrykh+CeBdu5Ie7OJwinCgQY0bc7GCRxy5xVHy+moaqkpL/jqQq0MtQOeYcrqEz4abc5f0KtU7W4A==",
"dependencies": {
"color-convert": "^2.0.1",
"color-string": "^1.9.0"
},
"engines": {
"node": ">=12.5.0"
}
},
"node_modules/color-convert": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
"integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
"dependencies": {
"color-name": "~1.1.4"
},
"engines": {
"node": ">=7.0.0"
}
},
"node_modules/color-name": {
"version": "1.1.4",
"resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
"integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="
},
"node_modules/color-string": {
"version": "1.9.1",
"resolved": "https://registry.npmjs.org/color-string/-/color-string-1.9.1.tgz",
"integrity": "sha512-shrVawQFojnZv6xM40anx4CkoDP+fZsw/ZerEMsW/pyzsRbElpsL/DBVW7q3ExxwusdNXI3lXpuhEZkzs8p5Eg==",
"dependencies": {
"color-name": "^1.0.0",
"simple-swizzle": "^0.2.2"
}
},
"node_modules/comma-separated-tokens": {
"version": "2.0.3",
"resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz",
"integrity": "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==",
"funding": {
"type": "github",
"url": "https://github.com/sponsors/wooorm"
}
},
"node_modules/commander": {
"version": "4.1.1",
"resolved": "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz",
"integrity": "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==",
"engines": {
"node": ">= 6"
}
},
"node_modules/concat-map": {
"version": "0.0.1",
"resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
"integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg=="
},
"node_modules/cross-spawn": {
"version": "7.0.3",
"resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz",
"integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==",
"dependencies": {
"path-key": "^3.1.0",
"shebang-command": "^2.0.0",
"which": "^2.0.1"
},
"engines": {
"node": ">= 8"
}
},
"node_modules/css-selector-tokenizer": {
"version": "0.8.0",
"resolved": "https://registry.npmjs.org/css-selector-tokenizer/-/css-selector-tokenizer-0.8.0.tgz",
"integrity": "sha512-Jd6Ig3/pe62/qe5SBPTN8h8LeUg/pT4lLgtavPf7updwwHpvFzxvOQBHYj2LZDMjUnBzgvIUSjRcf6oT5HzHFg==",
"dependencies": {
"cssesc": "^3.0.0",
"fastparse": "^1.1.2"
}
},
"node_modules/cssesc": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz",
"integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==",
"bin": {
"cssesc": "bin/cssesc"
},
"engines": {
"node": ">=4"
}
},
"node_modules/csstype": {
"version": "3.1.2",
"resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.2.tgz",
"integrity": "sha512-I7K1Uu0MBPzaFKg4nI5Q7Vs2t+3gWWW648spaF+Rg7pI9ds18Ugn+lvg4SHczUdKlHI5LWBXyqfS8+DufyBsgQ=="
},
"node_modules/daisyui": {
"version": "2.51.5",
"resolved": "https://registry.npmjs.org/daisyui/-/daisyui-2.51.5.tgz",
"integrity": "sha512-L05dRw0tasmz2Ha+10LhftEGLq4kaA8vRR/T0wDaXfHwqcgsf81jfXDJ6NlZ63Z7Rl1k3rj7UHs0l0p7CM3aYA==",
"dependencies": {
"color": "^4.2",
"css-selector-tokenizer": "^0.8.0",
"postcss-js": "^4.0.0",
"tailwindcss": "^3"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/daisyui"
},
"peerDependencies": {
"autoprefixer": "^10.0.2",
"postcss": "^8.1.6"
}
},
"node_modules/damerau-levenshtein": {
"version": "1.0.8",
"resolved": "https://registry.npmjs.org/damerau-levenshtein/-/damerau-levenshtein-1.0.8.tgz",
"integrity": "sha512-sdQSFB7+llfUcQHUQO3+B8ERRj0Oa4w9POWMI/puGtuf7gFywGmkaLCElnudfTiKZV+NvHqL0ifzdrI8Ro7ESA=="
},
"node_modules/debug": {
"version": "4.3.4",
"resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz",
"integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==",
"dependencies": {
"ms": "2.1.2"
},
"engines": {
"node": ">=6.0"
},
"peerDependenciesMeta": {
"supports-color": {
"optional": true
}
}
},
"node_modules/decode-named-character-reference": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/decode-named-character-reference/-/decode-named-character-reference-1.0.2.tgz",
"integrity": "sha512-O8x12RzrUF8xyVcY0KJowWsmaJxQbmy0/EtnNtHRpsOcT7dFk5W598coHqBVpmWo1oQQfsCqfCmkZN5DJrZVdg==",
"dependencies": {
"character-entities": "^2.0.0"
},
"funding": {
"type": "github",
"url": "https://github.com/sponsors/wooorm"
}
},
"node_modules/deep-equal": {
"version": "2.2.0",
"resolved": "https://registry.npmjs.org/deep-equal/-/deep-equal-2.2.0.tgz",
"integrity": "sha512-RdpzE0Hv4lhowpIUKKMJfeH6C1pXdtT1/it80ubgWqwI3qpuxUBpC1S4hnHg+zjnuOoDkzUtUCEEkG+XG5l3Mw==",
"dependencies": {
"call-bind": "^1.0.2",
"es-get-iterator": "^1.1.2",
"get-intrinsic": "^1.1.3",
"is-arguments": "^1.1.1",
"is-array-buffer": "^3.0.1",
"is-date-object": "^1.0.5",
"is-regex": "^1.1.4",
"is-shared-array-buffer": "^1.0.2",
"isarray": "^2.0.5",
"object-is": "^1.1.5",
"object-keys": "^1.1.1",
"object.assign": "^4.1.4",
"regexp.prototype.flags": "^1.4.3",
"side-channel": "^1.0.4",
"which-boxed-primitive": "^1.0.2",
"which-collection": "^1.0.1",
"which-typed-array": "^1.1.9"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/deep-is": {
"version": "0.1.4",
"resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
"integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ=="
},
"node_modules/define-lazy-prop": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-2.0.0.tgz",
"integrity": "sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==",
"engines": {
"node": ">=8"
}
},
"node_modules/define-properties": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.0.tgz",
"integrity": "sha512-xvqAVKGfT1+UAvPwKTVw/njhdQ8ZhXK4lI0bCIuCMrp2up9nPnaDftrLtmpTazqd1o+UY4zgzU+avtMbDP+ldA==",
"dependencies": {
"has-property-descriptors": "^1.0.0",
"object-keys": "^1.1.1"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/dequal": {
"version": "2.0.3",
"resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
"integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==",
"engines": {
"node": ">=6"
}
},
"node_modules/didyoumean": {
"version": "1.2.2",
"resolved": "https://registry.npmjs.org/didyoumean/-/didyoumean-1.2.2.tgz",
"integrity": "sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw=="
},
"node_modules/diff": {
"version": "5.1.0",
"resolved": "https://registry.npmjs.org/diff/-/diff-5.1.0.tgz",
"integrity": "sha512-D+mk+qE8VC/PAUrlAU34N+VfXev0ghe5ywmpqrawphmVZc1bEfn56uo9qpyGp1p4xpzOHkSW4ztBd6L7Xx4ACw==",
"engines": {
"node": ">=0.3.1"
}
},
"node_modules/dir-glob": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz",
"integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==",
"dependencies": {
"path-type": "^4.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/dlv": {
"version": "1.1.3",
"resolved": "https://registry.npmjs.org/dlv/-/dlv-1.1.3.tgz",
"integrity": "sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA=="
},
"node_modules/doctrine": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz",
"integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==",
"dependencies": {
"esutils": "^2.0.2"
},
"engines": {
"node": ">=6.0.0"
}
},
"node_modules/electron-to-chromium": {
"version": "1.4.348",
"resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.348.tgz",
"integrity": "sha512-gM7TdwuG3amns/1rlgxMbeeyNoBFPa+4Uu0c7FeROWh4qWmvSOnvcslKmWy51ggLKZ2n/F/4i2HJ+PVNxH9uCQ==",
"dev": true
},
"node_modules/emoji-regex": {
"version": "9.2.2",
"resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz",
"integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg=="
},
"node_modules/enhanced-resolve": {
"version": "5.12.0",
"resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.12.0.tgz",
"integrity": "sha512-QHTXI/sZQmko1cbDoNAa3mJ5qhWUUNAq3vR0/YiD379fWQrcfuoX1+HW2S0MTt7XmoPLapdaDKUtelUSPic7hQ==",
"dependencies": {
"graceful-fs": "^4.2.4",
"tapable": "^2.2.0"
},
"engines": {
"node": ">=10.13.0"
}
},
"node_modules/es-abstract": {
"version": "1.21.2",
"resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.21.2.tgz",
"integrity": "sha512-y/B5POM2iBnIxCiernH1G7rC9qQoM77lLIMQLuob0zhp8C56Po81+2Nj0WFKnd0pNReDTnkYryc+zhOzpEIROg==",
"dependencies": {
"array-buffer-byte-length": "^1.0.0",
"available-typed-arrays": "^1.0.5",
"call-bind": "^1.0.2",
"es-set-tostringtag": "^2.0.1",
"es-to-primitive": "^1.2.1",
"function.prototype.name": "^1.1.5",
"get-intrinsic": "^1.2.0",
"get-symbol-description": "^1.0.0",
"globalthis": "^1.0.3",
"gopd": "^1.0.1",
"has": "^1.0.3",
"has-property-descriptors": "^1.0.0",
"has-proto": "^1.0.1",
"has-symbols": "^1.0.3",
"internal-slot": "^1.0.5",
"is-array-buffer": "^3.0.2",
"is-callable": "^1.2.7",
"is-negative-zero": "^2.0.2",
"is-regex": "^1.1.4",
"is-shared-array-buffer": "^1.0.2",
"is-string": "^1.0.7",
"is-typed-array": "^1.1.10",
"is-weakref": "^1.0.2",
"object-inspect": "^1.12.3",
"object-keys": "^1.1.1",
"object.assign": "^4.1.4",
"regexp.prototype.flags": "^1.4.3",
"safe-regex-test": "^1.0.0",
"string.prototype.trim": "^1.2.7",
"string.prototype.trimend": "^1.0.6",
"string.prototype.trimstart": "^1.0.6",
"typed-array-length": "^1.0.4",
"unbox-primitive": "^1.0.2",
"which-typed-array": "^1.1.9"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/es-get-iterator": {
"version": "1.1.3",
"resolved": "https://registry.npmjs.org/es-get-iterator/-/es-get-iterator-1.1.3.tgz",
"integrity": "sha512-sPZmqHBe6JIiTfN5q2pEi//TwxmAFHwj/XEuYjTuse78i8KxaqMTTzxPoFKuzRpDpTJ+0NAbpfenkmH2rePtuw==",
"dependencies": {
"call-bind": "^1.0.2",
"get-intrinsic": "^1.1.3",
"has-symbols": "^1.0.3",
"is-arguments": "^1.1.1",
"is-map": "^2.0.2",
"is-set": "^2.0.2",
"is-string": "^1.0.7",
"isarray": "^2.0.5",
"stop-iteration-iterator": "^1.0.0"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/es-set-tostringtag": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.0.1.tgz",
"integrity": "sha512-g3OMbtlwY3QewlqAiMLI47KywjWZoEytKr8pf6iTC8uJq5bIAH52Z9pnQ8pVL6whrCto53JZDuUIsifGeLorTg==",
"dependencies": {
"get-intrinsic": "^1.1.3",
"has": "^1.0.3",
"has-tostringtag": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
}
},
"node_modules/es-shim-unscopables": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/es-shim-unscopables/-/es-shim-unscopables-1.0.0.tgz",
"integrity": "sha512-Jm6GPcCdC30eMLbZ2x8z2WuRwAws3zTBBKuusffYVUrNj/GVSUAZ+xKMaUpfNDR5IbyNA5LJbaecoUVbmUcB1w==",
"dependencies": {
"has": "^1.0.3"
}
},
"node_modules/es-to-primitive": {
"version": "1.2.1",
"resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz",
"integrity": "sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==",
"dependencies": {
"is-callable": "^1.1.4",
"is-date-object": "^1.0.1",
"is-symbol": "^1.0.2"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/escalade": {
"version": "3.1.1",
"resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz",
"integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==",
"dev": true,
"engines": {
"node": ">=6"
}
},
"node_modules/escape-string-regexp": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
"integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/eslint": {
"version": "8.37.0",
"resolved": "https://registry.npmjs.org/eslint/-/eslint-8.37.0.tgz",
"integrity": "sha512-NU3Ps9nI05GUoVMxcZx1J8CNR6xOvUT4jAUMH5+z8lpp3aEdPVCImKw6PWG4PY+Vfkpr+jvMpxs/qoE7wq0sPw==",
"dependencies": {
"@eslint-community/eslint-utils": "^4.2.0",
"@eslint-community/regexpp": "^4.4.0",
"@eslint/eslintrc": "^2.0.2",
"@eslint/js": "8.37.0",
"@humanwhocodes/config-array": "^0.11.8",
"@humanwhocodes/module-importer": "^1.0.1",
"@nodelib/fs.walk": "^1.2.8",
"ajv": "^6.10.0",
"chalk": "^4.0.0",
"cross-spawn": "^7.0.2",
"debug": "^4.3.2",
"doctrine": "^3.0.0",
"escape-string-regexp": "^4.0.0",
"eslint-scope": "^7.1.1",
"eslint-visitor-keys": "^3.4.0",
"espree": "^9.5.1",
"esquery": "^1.4.2",
"esutils": "^2.0.2",
"fast-deep-equal": "^3.1.3",
"file-entry-cache": "^6.0.1",
"find-up": "^5.0.0",
"glob-parent": "^6.0.2",
"globals": "^13.19.0",
"grapheme-splitter": "^1.0.4",
"ignore": "^5.2.0",
"import-fresh": "^3.0.0",
"imurmurhash": "^0.1.4",
"is-glob": "^4.0.0",
"is-path-inside": "^3.0.3",
"js-sdsl": "^4.1.4",
"js-yaml": "^4.1.0",
"json-stable-stringify-without-jsonify": "^1.0.1",
"levn": "^0.4.1",
"lodash.merge": "^4.6.2",
"minimatch": "^3.1.2",
"natural-compare": "^1.4.0",
"optionator": "^0.9.1",
"strip-ansi": "^6.0.1",
"strip-json-comments": "^3.1.0",
"text-table": "^0.2.0"
},
"bin": {
"eslint": "bin/eslint.js"
},
"engines": {
"node": "^12.22.0 || ^14.17.0 || >=16.0.0"
},
"funding": {
"url": "https://opencollective.com/eslint"
}
},
"node_modules/eslint-config-next": {
"version": "13.2.4",
"resolved": "https://registry.npmjs.org/eslint-config-next/-/eslint-config-next-13.2.4.tgz",
"integrity": "sha512-lunIBhsoeqw6/Lfkd6zPt25w1bn0znLA/JCL+au1HoEpSb4/PpsOYsYtgV/q+YPsoKIOzFyU5xnb04iZnXjUvg==",
"dependencies": {
"@next/eslint-plugin-next": "13.2.4",
"@rushstack/eslint-patch": "^1.1.3",
"@typescript-eslint/parser": "^5.42.0",
"eslint-import-resolver-node": "^0.3.6",
"eslint-import-resolver-typescript": "^3.5.2",
"eslint-plugin-import": "^2.26.0",
"eslint-plugin-jsx-a11y": "^6.5.1",
"eslint-plugin-react": "^7.31.7",
"eslint-plugin-react-hooks": "^4.5.0"
},
"peerDependencies": {
"eslint": "^7.23.0 || ^8.0.0",
"typescript": ">=3.3.1"
},
"peerDependenciesMeta": {
"typescript": {
"optional": true
}
}
},
"node_modules/eslint-import-resolver-node": {
"version": "0.3.7",
"resolved": "https://registry.npmjs.org/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.7.tgz",
"integrity": "sha512-gozW2blMLJCeFpBwugLTGyvVjNoeo1knonXAcatC6bjPBZitotxdWf7Gimr25N4c0AAOo4eOUfaG82IJPDpqCA==",
"dependencies": {
"debug": "^3.2.7",
"is-core-module": "^2.11.0",
"resolve": "^1.22.1"
}
},
"node_modules/eslint-import-resolver-node/node_modules/debug": {
"version": "3.2.7",
"resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz",
"integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==",
"dependencies": {
"ms": "^2.1.1"
}
},
"node_modules/eslint-import-resolver-typescript": {
"version": "3.5.4",
"resolved": "https://registry.npmjs.org/eslint-import-resolver-typescript/-/eslint-import-resolver-typescript-3.5.4.tgz",
"integrity": "sha512-9xUpnedEmSfG57sN1UvWPiEhfJ8bPt0Wg2XysA7Mlc79iFGhmJtRUg9LxtkK81FhMUui0YuR2E8iUsVhePkh4A==",
"dependencies": {
"debug": "^4.3.4",
"enhanced-resolve": "^5.12.0",
"get-tsconfig": "^4.5.0",
"globby": "^13.1.3",
"is-core-module": "^2.11.0",
"is-glob": "^4.0.3",
"synckit": "^0.8.5"
},
"engines": {
"node": "^14.18.0 || >=16.0.0"
},
"funding": {
"url": "https://opencollective.com/unts/projects/eslint-import-resolver-ts"
},
"peerDependencies": {
"eslint": "*",
"eslint-plugin-import": "*"
}
},
"node_modules/eslint-import-resolver-typescript/node_modules/globby": {
"version": "13.1.3",
"resolved": "https://registry.npmjs.org/globby/-/globby-13.1.3.tgz",
"integrity": "sha512-8krCNHXvlCgHDpegPzleMq07yMYTO2sXKASmZmquEYWEmCx6J5UTRbp5RwMJkTJGtcQ44YpiUYUiN0b9mzy8Bw==",
"dependencies": {
"dir-glob": "^3.0.1",
"fast-glob": "^3.2.11",
"ignore": "^5.2.0",
"merge2": "^1.4.1",
"slash": "^4.0.0"
},
"engines": {
"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/eslint-import-resolver-typescript/node_modules/slash": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/slash/-/slash-4.0.0.tgz",
"integrity": "sha512-3dOsAHXXUkQTpOYcoAxLIorMTp4gIQr5IW3iVb7A7lFIp0VHhnynm9izx6TssdrIcVIESAlVjtnO2K8bg+Coew==",
"engines": {
"node": ">=12"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/eslint-module-utils": {
"version": "2.7.4",
"resolved": "https://registry.npmjs.org/eslint-module-utils/-/eslint-module-utils-2.7.4.tgz",
"integrity": "sha512-j4GT+rqzCoRKHwURX7pddtIPGySnX9Si/cgMI5ztrcqOPtk5dDEeZ34CQVPphnqkJytlc97Vuk05Um2mJ3gEQA==",
"dependencies": {
"debug": "^3.2.7"
},
"engines": {
"node": ">=4"
},
"peerDependenciesMeta": {
"eslint": {
"optional": true
}
}
},
"node_modules/eslint-module-utils/node_modules/debug": {
"version": "3.2.7",
"resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz",
"integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==",
"dependencies": {
"ms": "^2.1.1"
}
},
"node_modules/eslint-plugin-import": {
"version": "2.27.5",
"resolved": "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.27.5.tgz",
"integrity": "sha512-LmEt3GVofgiGuiE+ORpnvP+kAm3h6MLZJ4Q5HCyHADofsb4VzXFsRiWj3c0OFiV+3DWFh0qg3v9gcPlfc3zRow==",
"dependencies": {
"array-includes": "^3.1.6",
"array.prototype.flat": "^1.3.1",
"array.prototype.flatmap": "^1.3.1",
"debug": "^3.2.7",
"doctrine": "^2.1.0",
"eslint-import-resolver-node": "^0.3.7",
"eslint-module-utils": "^2.7.4",
"has": "^1.0.3",
"is-core-module": "^2.11.0",
"is-glob": "^4.0.3",
"minimatch": "^3.1.2",
"object.values": "^1.1.6",
"resolve": "^1.22.1",
"semver": "^6.3.0",
"tsconfig-paths": "^3.14.1"
},
"engines": {
"node": ">=4"
},
"peerDependencies": {
"eslint": "^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8"
}
},
"node_modules/eslint-plugin-import/node_modules/debug": {
"version": "3.2.7",
"resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz",
"integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==",
"dependencies": {
"ms": "^2.1.1"
}
},
"node_modules/eslint-plugin-import/node_modules/doctrine": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz",
"integrity": "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==",
"dependencies": {
"esutils": "^2.0.2"
},
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/eslint-plugin-import/node_modules/semver": {
"version": "6.3.0",
"resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz",
"integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==",
"bin": {
"semver": "bin/semver.js"
}
},
"node_modules/eslint-plugin-jsx-a11y": {
"version": "6.7.1",
"resolved": "https://registry.npmjs.org/eslint-plugin-jsx-a11y/-/eslint-plugin-jsx-a11y-6.7.1.tgz",
"integrity": "sha512-63Bog4iIethyo8smBklORknVjB0T2dwB8Mr/hIC+fBS0uyHdYYpzM/Ed+YC8VxTjlXHEWFOdmgwcDn1U2L9VCA==",
"dependencies": {
"@babel/runtime": "^7.20.7",
"aria-query": "^5.1.3",
"array-includes": "^3.1.6",
"array.prototype.flatmap": "^1.3.1",
"ast-types-flow": "^0.0.7",
"axe-core": "^4.6.2",
"axobject-query": "^3.1.1",
"damerau-levenshtein": "^1.0.8",
"emoji-regex": "^9.2.2",
"has": "^1.0.3",
"jsx-ast-utils": "^3.3.3",
"language-tags": "=1.0.5",
"minimatch": "^3.1.2",
"object.entries": "^1.1.6",
"object.fromentries": "^2.0.6",
"semver": "^6.3.0"
},
"engines": {
"node": ">=4.0"
},
"peerDependencies": {
"eslint": "^3 || ^4 || ^5 || ^6 || ^7 || ^8"
}
},
"node_modules/eslint-plugin-jsx-a11y/node_modules/semver": {
"version": "6.3.0",
"resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz",
"integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==",
"bin": {
"semver": "bin/semver.js"
}
},
"node_modules/eslint-plugin-react": {
"version": "7.32.2",
"resolved": "https://registry.npmjs.org/eslint-plugin-react/-/eslint-plugin-react-7.32.2.tgz",
"integrity": "sha512-t2fBMa+XzonrrNkyVirzKlvn5RXzzPwRHtMvLAtVZrt8oxgnTQaYbU6SXTOO1mwQgp1y5+toMSKInnzGr0Knqg==",
"dependencies": {
"array-includes": "^3.1.6",
"array.prototype.flatmap": "^1.3.1",
"array.prototype.tosorted": "^1.1.1",
"doctrine": "^2.1.0",
"estraverse": "^5.3.0",
"jsx-ast-utils": "^2.4.1 || ^3.0.0",
"minimatch": "^3.1.2",
"object.entries": "^1.1.6",
"object.fromentries": "^2.0.6",
"object.hasown": "^1.1.2",
"object.values": "^1.1.6",
"prop-types": "^15.8.1",
"resolve": "^2.0.0-next.4",
"semver": "^6.3.0",
"string.prototype.matchall": "^4.0.8"
},
"engines": {
"node": ">=4"
},
"peerDependencies": {
"eslint": "^3 || ^4 || ^5 || ^6 || ^7 || ^8"
}
},
"node_modules/eslint-plugin-react-hooks": {
"version": "4.6.0",
"resolved": "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-4.6.0.tgz",
"integrity": "sha512-oFc7Itz9Qxh2x4gNHStv3BqJq54ExXmfC+a1NjAta66IAN87Wu0R/QArgIS9qKzX3dXKPI9H5crl9QchNMY9+g==",
"engines": {
"node": ">=10"
},
"peerDependencies": {
"eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0"
}
},
"node_modules/eslint-plugin-react/node_modules/doctrine": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz",
"integrity": "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==",
"dependencies": {
"esutils": "^2.0.2"
},
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/eslint-plugin-react/node_modules/resolve": {
"version": "2.0.0-next.4",
"resolved": "https://registry.npmjs.org/resolve/-/resolve-2.0.0-next.4.tgz",
"integrity": "sha512-iMDbmAWtfU+MHpxt/I5iWI7cY6YVEZUQ3MBgPQ++XD1PELuJHIl82xBmObyP2KyQmkNB2dsqF7seoQQiAn5yDQ==",
"dependencies": {
"is-core-module": "^2.9.0",
"path-parse": "^1.0.7",
"supports-preserve-symlinks-flag": "^1.0.0"
},
"bin": {
"resolve": "bin/resolve"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/eslint-plugin-react/node_modules/semver": {
"version": "6.3.0",
"resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz",
"integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==",
"bin": {
"semver": "bin/semver.js"
}
},
"node_modules/eslint-scope": {
"version": "7.1.1",
"resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.1.1.tgz",
"integrity": "sha512-QKQM/UXpIiHcLqJ5AOyIW7XZmzjkzQXYE54n1++wb0u9V/abW3l9uQnxX8Z5Xd18xyKIMTUAyQ0k1e8pz6LUrw==",
"dependencies": {
"esrecurse": "^4.3.0",
"estraverse": "^5.2.0"
},
"engines": {
"node": "^12.22.0 || ^14.17.0 || >=16.0.0"
}
},
"node_modules/eslint-visitor-keys": {
"version": "3.4.0",
"resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.0.tgz",
"integrity": "sha512-HPpKPUBQcAsZOsHAFwTtIKcYlCje62XB7SEAcxjtmW6TD1WVpkS6i6/hOVtTZIl4zGj/mBqpFVGvaDneik+VoQ==",
"engines": {
"node": "^12.22.0 || ^14.17.0 || >=16.0.0"
},
"funding": {
"url": "https://opencollective.com/eslint"
}
},
"node_modules/espree": {
"version": "9.5.1",
"resolved": "https://registry.npmjs.org/espree/-/espree-9.5.1.tgz",
"integrity": "sha512-5yxtHSZXRSW5pvv3hAlXM5+/Oswi1AUFqBmbibKb5s6bp3rGIDkyXU6xCoyuuLhijr4SFwPrXRoZjz0AZDN9tg==",
"dependencies": {
"acorn": "^8.8.0",
"acorn-jsx": "^5.3.2",
"eslint-visitor-keys": "^3.4.0"
},
"engines": {
"node": "^12.22.0 || ^14.17.0 || >=16.0.0"
},
"funding": {
"url": "https://opencollective.com/eslint"
}
},
"node_modules/esprima": {
"version": "4.0.1",
"resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
"integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
"bin": {
"esparse": "bin/esparse.js",
"esvalidate": "bin/esvalidate.js"
},
"engines": {
"node": ">=4"
}
},
"node_modules/esquery": {
"version": "1.5.0",
"resolved": "https://registry.npmjs.org/esquery/-/esquery-1.5.0.tgz",
"integrity": "sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg==",
"dependencies": {
"estraverse": "^5.1.0"
},
"engines": {
"node": ">=0.10"
}
},
"node_modules/esrecurse": {
"version": "4.3.0",
"resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
"integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
"dependencies": {
"estraverse": "^5.2.0"
},
"engines": {
"node": ">=4.0"
}
},
"node_modules/estraverse": {
"version": "5.3.0",
"resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
"integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
"engines": {
"node": ">=4.0"
}
},
"node_modules/esutils": {
"version": "2.0.3",
"resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
"integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/extend": {
"version": "3.0.2",
"resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz",
"integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g=="
},
"node_modules/extend-shallow": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
"integrity": "sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug==",
"dependencies": {
"is-extendable": "^0.1.0"
},
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/fast-deep-equal": {
"version": "3.1.3",
"resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
"integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="
},
"node_modules/fast-glob": {
"version": "3.2.12",
"resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.2.12.tgz",
"integrity": "sha512-DVj4CQIYYow0BlaelwK1pHl5n5cRSJfM60UA0zK891sVInoPri2Ekj7+e1CT3/3qxXenpI+nBBmQAcJPJgaj4w==",
"dependencies": {
"@nodelib/fs.stat": "^2.0.2",
"@nodelib/fs.walk": "^1.2.3",
"glob-parent": "^5.1.2",
"merge2": "^1.3.0",
"micromatch": "^4.0.4"
},
"engines": {
"node": ">=8.6.0"
}
},
"node_modules/fast-glob/node_modules/glob-parent": {
"version": "5.1.2",
"resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
"integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
"dependencies": {
"is-glob": "^4.0.1"
},
"engines": {
"node": ">= 6"
}
},
"node_modules/fast-json-stable-stringify": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
"integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw=="
},
"node_modules/fast-levenshtein": {
"version": "2.0.6",
"resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
"integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw=="
},
"node_modules/fastparse": {
"version": "1.1.2",
"resolved": "https://registry.npmjs.org/fastparse/-/fastparse-1.1.2.tgz",
"integrity": "sha512-483XLLxTVIwWK3QTrMGRqUfUpoOs/0hbQrl2oz4J0pAcm3A3bu84wxTFqGqkJzewCLdME38xJLJAxBABfQT8sQ=="
},
"node_modules/fastq": {
"version": "1.15.0",
"resolved": "https://registry.npmjs.org/fastq/-/fastq-1.15.0.tgz",
"integrity": "sha512-wBrocU2LCXXa+lWBt8RoIRD89Fi8OdABODa/kEnyeyjS5aZO5/GNvI5sEINADqP/h8M29UHTHUb53sUu5Ihqdw==",
"dependencies": {
"reusify": "^1.0.4"
}
},
"node_modules/file-entry-cache": {
"version": "6.0.1",
"resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz",
"integrity": "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==",
"dependencies": {
"flat-cache": "^3.0.4"
},
"engines": {
"node": "^10.12.0 || >=12.0.0"
}
},
"node_modules/fill-range": {
"version": "7.0.1",
"resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
"integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==",
"dependencies": {
"to-regex-range": "^5.0.1"
},
"engines": {
"node": ">=8"
}
},
"node_modules/find-up": {
"version": "5.0.0",
"resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
"integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
"dependencies": {
"locate-path": "^6.0.0",
"path-exists": "^4.0.0"
},
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/flat-cache": {
"version": "3.0.4",
"resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-3.0.4.tgz",
"integrity": "sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg==",
"dependencies": {
"flatted": "^3.1.0",
"rimraf": "^3.0.2"
},
"engines": {
"node": "^10.12.0 || >=12.0.0"
}
},
"node_modules/flatted": {
"version": "3.2.7",
"resolved": "https://registry.npmjs.org/flatted/-/flatted-3.2.7.tgz",
"integrity": "sha512-5nqDSxl8nn5BSNxyR3n4I6eDmbolI6WT+QqR547RwxQapgjQBmtktdP+HTBb/a/zLsbzERTONyUB5pefh5TtjQ=="
},
"node_modules/for-each": {
"version": "0.3.3",
"resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz",
"integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==",
"dependencies": {
"is-callable": "^1.1.3"
}
},
"node_modules/fraction.js": {
"version": "4.2.0",
"resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-4.2.0.tgz",
"integrity": "sha512-MhLuK+2gUcnZe8ZHlaaINnQLl0xRIGRfcGk2yl8xoQAfHrSsL3rYu6FCmBdkdbhc9EPlwyGHewaRsvwRMJtAlA==",
"dev": true,
"engines": {
"node": "*"
},
"funding": {
"type": "patreon",
"url": "https://www.patreon.com/infusion"
}
},
"node_modules/fs.realpath": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
"integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw=="
},
"node_modules/fsevents": {
"version": "2.3.2",
"resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",
"integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
"hasInstallScript": true,
"optional": true,
"os": [
"darwin"
],
"engines": {
"node": "^8.16.0 || ^10.6.0 || >=11.0.0"
}
},
"node_modules/function-bind": {
"version": "1.1.1",
"resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz",
"integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A=="
},
"node_modules/function.prototype.name": {
"version": "1.1.5",
"resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.5.tgz",
"integrity": "sha512-uN7m/BzVKQnCUF/iW8jYea67v++2u7m5UgENbHRtdDVclOUP+FMPlCNdmk0h/ysGyo2tavMJEDqJAkJdRa1vMA==",
"dependencies": {
"call-bind": "^1.0.2",
"define-properties": "^1.1.3",
"es-abstract": "^1.19.0",
"functions-have-names": "^1.2.2"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/functions-have-names": {
"version": "1.2.3",
"resolved": "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz",
"integrity": "sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==",
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/get-intrinsic": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.0.tgz",
"integrity": "sha512-L049y6nFOuom5wGyRc3/gdTLO94dySVKRACj1RmJZBQXlbTMhtNIgkWkUHq+jYmZvKf14EW1EoJnnjbmoHij0Q==",
"dependencies": {
"function-bind": "^1.1.1",
"has": "^1.0.3",
"has-symbols": "^1.0.3"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/get-symbol-description": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.0.0.tgz",
"integrity": "sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw==",
"dependencies": {
"call-bind": "^1.0.2",
"get-intrinsic": "^1.1.1"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/get-tsconfig": {
"version": "4.5.0",
"resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.5.0.tgz",
"integrity": "sha512-MjhiaIWCJ1sAU4pIQ5i5OfOuHHxVo1oYeNsWTON7jxYkod8pHocXeh+SSbmu5OZZZK73B6cbJ2XADzXehLyovQ==",
"funding": {
"url": "https://github.com/privatenumber/get-tsconfig?sponsor=1"
}
},
"node_modules/glob": {
"version": "7.1.7",
"resolved": "https://registry.npmjs.org/glob/-/glob-7.1.7.tgz",
"integrity": "sha512-OvD9ENzPLbegENnYP5UUfJIirTg4+XwMWGaQfQTY0JenxNvvIKP3U3/tAQSPIu/lHxXYSZmpXlUHeqAIdKzBLQ==",
"dependencies": {
"fs.realpath": "^1.0.0",
"inflight": "^1.0.4",
"inherits": "2",
"minimatch": "^3.0.4",
"once": "^1.3.0",
"path-is-absolute": "^1.0.0"
},
"engines": {
"node": "*"
},
"funding": {
"url": "https://github.com/sponsors/isaacs"
}
},
"node_modules/glob-parent": {
"version": "6.0.2",
"resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
"integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
"dependencies": {
"is-glob": "^4.0.3"
},
"engines": {
"node": ">=10.13.0"
}
},
"node_modules/globals": {
"version": "13.20.0",
"resolved": "https://registry.npmjs.org/globals/-/globals-13.20.0.tgz",
"integrity": "sha512-Qg5QtVkCy/kv3FUSlu4ukeZDVf9ee0iXLAUYX13gbR17bnejFTzr4iS9bY7kwCf1NztRNm1t91fjOiyx4CSwPQ==",
"dependencies": {
"type-fest": "^0.20.2"
},
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/globalthis": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.3.tgz",
"integrity": "sha512-sFdI5LyBiNTHjRd7cGPWapiHWMOXKyuBNX/cWJ3NfzrZQVa8GI/8cofCl74AOVqq9W5kNmguTIzJ/1s2gyI9wA==",
"dependencies": {
"define-properties": "^1.1.3"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/globalyzer": {
"version": "0.1.0",
"resolved": "https://registry.npmjs.org/globalyzer/-/globalyzer-0.1.0.tgz",
"integrity": "sha512-40oNTM9UfG6aBmuKxk/giHn5nQ8RVz/SS4Ir6zgzOv9/qC3kKZ9v4etGTcJbEl/NyVQH7FGU7d+X1egr57Md2Q=="
},
"node_modules/globby": {
"version": "11.1.0",
"resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz",
"integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==",
"dependencies": {
"array-union": "^2.1.0",
"dir-glob": "^3.0.1",
"fast-glob": "^3.2.9",
"ignore": "^5.2.0",
"merge2": "^1.4.1",
"slash": "^3.0.0"
},
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/globrex": {
"version": "0.1.2",
"resolved": "https://registry.npmjs.org/globrex/-/globrex-0.1.2.tgz",
"integrity": "sha512-uHJgbwAMwNFf5mLst7IWLNg14x1CkeqglJb/K3doi4dw6q2IvAAmM/Y81kevy83wP+Sst+nutFTYOGg3d1lsxg=="
},
"node_modules/gopd": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz",
"integrity": "sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==",
"dependencies": {
"get-intrinsic": "^1.1.3"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/graceful-fs": {
"version": "4.2.11",
"resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
"integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="
},
"node_modules/grapheme-splitter": {
"version": "1.0.4",
"resolved": "https://registry.npmjs.org/grapheme-splitter/-/grapheme-splitter-1.0.4.tgz",
"integrity": "sha512-bzh50DW9kTPM00T8y4o8vQg89Di9oLJVLW/KaOGIXJWP/iqCN6WKYkbNOF04vFLJhwcpYUh9ydh/+5vpOqV4YQ=="
},
"node_modules/gray-matter": {
"version": "4.0.3",
"resolved": "https://registry.npmjs.org/gray-matter/-/gray-matter-4.0.3.tgz",
"integrity": "sha512-5v6yZd4JK3eMI3FqqCouswVqwugaA9r4dNZB1wwcmrD02QkV5H0y7XBQW8QwQqEaZY1pM9aqORSORhJRdNK44Q==",
"dependencies": {
"js-yaml": "^3.13.1",
"kind-of": "^6.0.2",
"section-matter": "^1.0.0",
"strip-bom-string": "^1.0.0"
},
"engines": {
"node": ">=6.0"
}
},
"node_modules/gray-matter/node_modules/argparse": {
"version": "1.0.10",
"resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz",
"integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
"dependencies": {
"sprintf-js": "~1.0.2"
}
},
"node_modules/gray-matter/node_modules/js-yaml": {
"version": "3.14.1",
"resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz",
"integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==",
"dependencies": {
"argparse": "^1.0.7",
"esprima": "^4.0.0"
},
"bin": {
"js-yaml": "bin/js-yaml.js"
}
},
"node_modules/has": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
"integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
"dependencies": {
"function-bind": "^1.1.1"
},
"engines": {
"node": ">= 0.4.0"
}
},
"node_modules/has-bigints": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.0.2.tgz",
"integrity": "sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==",
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/has-flag": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
"integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
"engines": {
"node": ">=8"
}
},
"node_modules/has-property-descriptors": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz",
"integrity": "sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ==",
"dependencies": {
"get-intrinsic": "^1.1.1"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/has-proto": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.1.tgz",
"integrity": "sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg==",
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/has-symbols": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz",
"integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==",
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/has-tostringtag": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.0.tgz",
"integrity": "sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==",
"dependencies": {
"has-symbols": "^1.0.2"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/hast-util-from-parse5": {
"version": "7.1.2",
"resolved": "https://registry.npmjs.org/hast-util-from-parse5/-/hast-util-from-parse5-7.1.2.tgz",
"integrity": "sha512-Nz7FfPBuljzsN3tCQ4kCBKqdNhQE2l0Tn+X1ubgKBPRoiDIu1mL08Cfw4k7q71+Duyaw7DXDN+VTAp4Vh3oCOw==",
"dependencies": {
"@types/hast": "^2.0.0",
"@types/unist": "^2.0.0",
"hastscript": "^7.0.0",
"property-information": "^6.0.0",
"vfile": "^5.0.0",
"vfile-location": "^4.0.0",
"web-namespaces": "^2.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/hast-util-parse-selector": {
"version": "3.1.1",
"resolved": "https://registry.npmjs.org/hast-util-parse-selector/-/hast-util-parse-selector-3.1.1.tgz",
"integrity": "sha512-jdlwBjEexy1oGz0aJ2f4GKMaVKkA9jwjr4MjAAI22E5fM/TXVZHuS5OpONtdeIkRKqAaryQ2E9xNQxijoThSZA==",
"dependencies": {
"@types/hast": "^2.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/hast-util-raw": {
"version": "7.2.3",
"resolved": "https://registry.npmjs.org/hast-util-raw/-/hast-util-raw-7.2.3.tgz",
"integrity": "sha512-RujVQfVsOrxzPOPSzZFiwofMArbQke6DJjnFfceiEbFh7S05CbPt0cYN+A5YeD3pso0JQk6O1aHBnx9+Pm2uqg==",
"dependencies": {
"@types/hast": "^2.0.0",
"@types/parse5": "^6.0.0",
"hast-util-from-parse5": "^7.0.0",
"hast-util-to-parse5": "^7.0.0",
"html-void-elements": "^2.0.0",
"parse5": "^6.0.0",
"unist-util-position": "^4.0.0",
"unist-util-visit": "^4.0.0",
"vfile": "^5.0.0",
"web-namespaces": "^2.0.0",
"zwitch": "^2.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/hast-util-sanitize": {
"version": "4.1.0",
"resolved": "https://registry.npmjs.org/hast-util-sanitize/-/hast-util-sanitize-4.1.0.tgz",
"integrity": "sha512-Hd9tU0ltknMGRDv+d6Ro/4XKzBqQnP/EZrpiTbpFYfXv/uOhWeKc+2uajcbEvAEH98VZd7eII2PiXm13RihnLw==",
"dependencies": {
"@types/hast": "^2.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/hast-util-to-html": {
"version": "8.0.4",
"resolved": "https://registry.npmjs.org/hast-util-to-html/-/hast-util-to-html-8.0.4.tgz",
"integrity": "sha512-4tpQTUOr9BMjtYyNlt0P50mH7xj0Ks2xpo8M943Vykljf99HW6EzulIoJP1N3eKOSScEHzyzi9dm7/cn0RfGwA==",
"dependencies": {
"@types/hast": "^2.0.0",
"@types/unist": "^2.0.0",
"ccount": "^2.0.0",
"comma-separated-tokens": "^2.0.0",
"hast-util-raw": "^7.0.0",
"hast-util-whitespace": "^2.0.0",
"html-void-elements": "^2.0.0",
"property-information": "^6.0.0",
"space-separated-tokens": "^2.0.0",
"stringify-entities": "^4.0.0",
"zwitch": "^2.0.4"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/hast-util-to-parse5": {
"version": "7.1.0",
"resolved": "https://registry.npmjs.org/hast-util-to-parse5/-/hast-util-to-parse5-7.1.0.tgz",
"integrity": "sha512-YNRgAJkH2Jky5ySkIqFXTQiaqcAtJyVE+D5lkN6CdtOqrnkLfGYYrEcKuHOJZlp+MwjSwuD3fZuawI+sic/RBw==",
"dependencies": {
"@types/hast": "^2.0.0",
"comma-separated-tokens": "^2.0.0",
"property-information": "^6.0.0",
"space-separated-tokens": "^2.0.0",
"web-namespaces": "^2.0.0",
"zwitch": "^2.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/hast-util-whitespace": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-2.0.1.tgz",
"integrity": "sha512-nAxA0v8+vXSBDt3AnRUNjyRIQ0rD+ntpbAp4LnPkumc5M9yUbSMa4XDU9Q6etY4f1Wp4bNgvc1yjiZtsTTrSng==",
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/hastscript": {
"version": "7.2.0",
"resolved": "https://registry.npmjs.org/hastscript/-/hastscript-7.2.0.tgz",
"integrity": "sha512-TtYPq24IldU8iKoJQqvZOuhi5CyCQRAbvDOX0x1eW6rsHSxa/1i2CCiptNTotGHJ3VoHRGmqiv6/D3q113ikkw==",
"dependencies": {
"@types/hast": "^2.0.0",
"comma-separated-tokens": "^2.0.0",
"hast-util-parse-selector": "^3.0.0",
"property-information": "^6.0.0",
"space-separated-tokens": "^2.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/html-void-elements": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/html-void-elements/-/html-void-elements-2.0.1.tgz",
"integrity": "sha512-0quDb7s97CfemeJAnW9wC0hw78MtW7NU3hqtCD75g2vFlDLt36llsYD7uB7SUzojLMP24N5IatXf7ylGXiGG9A==",
"funding": {
"type": "github",
"url": "https://github.com/sponsors/wooorm"
}
},
"node_modules/ignore": {
"version": "5.2.4",
"resolved": "https://registry.npmjs.org/ignore/-/ignore-5.2.4.tgz",
"integrity": "sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ==",
"engines": {
"node": ">= 4"
}
},
"node_modules/import-fresh": {
"version": "3.3.0",
"resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz",
"integrity": "sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==",
"dependencies": {
"parent-module": "^1.0.0",
"resolve-from": "^4.0.0"
},
"engines": {
"node": ">=6"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/imurmurhash": {
"version": "0.1.4",
"resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
"integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
"engines": {
"node": ">=0.8.19"
}
},
"node_modules/inflight": {
"version": "1.0.6",
"resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
"integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
"dependencies": {
"once": "^1.3.0",
"wrappy": "1"
}
},
"node_modules/inherits": {
"version": "2.0.4",
"resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
"integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
},
"node_modules/internal-slot": {
"version": "1.0.5",
"resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.5.tgz",
"integrity": "sha512-Y+R5hJrzs52QCG2laLn4udYVnxsfny9CpOhNhUvk/SSSVyF6T27FzRbF0sroPidSu3X8oEAkOn2K804mjpt6UQ==",
"dependencies": {
"get-intrinsic": "^1.2.0",
"has": "^1.0.3",
"side-channel": "^1.0.4"
},
"engines": {
"node": ">= 0.4"
}
},
"node_modules/is-arguments": {
"version": "1.1.1",
"resolved": "https://registry.npmjs.org/is-arguments/-/is-arguments-1.1.1.tgz",
"integrity": "sha512-8Q7EARjzEnKpt/PCD7e1cgUS0a6X8u5tdSiMqXhojOdoV9TsMsiO+9VLC5vAmO8N7/GmXn7yjR8qnA6bVAEzfA==",
"dependencies": {
"call-bind": "^1.0.2",
"has-tostringtag": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-array-buffer": {
"version": "3.0.2",
"resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.2.tgz",
"integrity": "sha512-y+FyyR/w8vfIRq4eQcM1EYgSTnmHXPqaF+IgzgraytCFq5Xh8lllDVmAZolPJiZttZLeFSINPYMaEJ7/vWUa1w==",
"dependencies": {
"call-bind": "^1.0.2",
"get-intrinsic": "^1.2.0",
"is-typed-array": "^1.1.10"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-arrayish": {
"version": "0.3.2",
"resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.3.2.tgz",
"integrity": "sha512-eVRqCvVlZbuw3GrM63ovNSNAeA1K16kaR/LRY/92w0zxQ5/1YzwblUX652i4Xs9RwAGjW9d9y6X88t8OaAJfWQ=="
},
"node_modules/is-bigint": {
"version": "1.0.4",
"resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.0.4.tgz",
"integrity": "sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==",
"dependencies": {
"has-bigints": "^1.0.1"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-binary-path": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
"integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
"dependencies": {
"binary-extensions": "^2.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/is-boolean-object": {
"version": "1.1.2",
"resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.1.2.tgz",
"integrity": "sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==",
"dependencies": {
"call-bind": "^1.0.2",
"has-tostringtag": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-buffer": {
"version": "2.0.5",
"resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-2.0.5.tgz",
"integrity": "sha512-i2R6zNFDwgEHJyQUtJEk0XFi1i0dPFn/oqjK3/vPCcDeJvW5NQ83V8QbicfF1SupOaB0h8ntgBC2YiE7dfyctQ==",
"funding": [
{
"type": "github",
"url": "https://github.com/sponsors/feross"
},
{
"type": "patreon",
"url": "https://www.patreon.com/feross"
},
{
"type": "consulting",
"url": "https://feross.org/support"
}
],
"engines": {
"node": ">=4"
}
},
"node_modules/is-callable": {
"version": "1.2.7",
"resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz",
"integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==",
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-core-module": {
"version": "2.11.0",
"resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.11.0.tgz",
"integrity": "sha512-RRjxlvLDkD1YJwDbroBHMb+cukurkDWNyHx7D3oNB5x9rb5ogcksMC5wHCadcXoo67gVr/+3GFySh3134zi6rw==",
"dependencies": {
"has": "^1.0.3"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-date-object": {
"version": "1.0.5",
"resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.5.tgz",
"integrity": "sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==",
"dependencies": {
"has-tostringtag": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-docker": {
"version": "2.2.1",
"resolved": "https://registry.npmjs.org/is-docker/-/is-docker-2.2.1.tgz",
"integrity": "sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==",
"bin": {
"is-docker": "cli.js"
},
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/is-extendable": {
"version": "0.1.1",
"resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz",
"integrity": "sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw==",
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/is-extglob": {
"version": "2.1.1",
"resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
"integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/is-glob": {
"version": "4.0.3",
"resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
"integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
"dependencies": {
"is-extglob": "^2.1.1"
},
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/is-map": {
"version": "2.0.2",
"resolved": "https://registry.npmjs.org/is-map/-/is-map-2.0.2.tgz",
"integrity": "sha512-cOZFQQozTha1f4MxLFzlgKYPTyj26picdZTx82hbc/Xf4K/tZOOXSCkMvU4pKioRXGDLJRn0GM7Upe7kR721yg==",
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-negative-zero": {
"version": "2.0.2",
"resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.2.tgz",
"integrity": "sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA==",
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-number": {
"version": "7.0.0",
"resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
"integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
"engines": {
"node": ">=0.12.0"
}
},
"node_modules/is-number-object": {
"version": "1.0.7",
"resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.0.7.tgz",
"integrity": "sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==",
"dependencies": {
"has-tostringtag": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-path-inside": {
"version": "3.0.3",
"resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz",
"integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==",
"engines": {
"node": ">=8"
}
},
"node_modules/is-plain-obj": {
"version": "4.1.0",
"resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-4.1.0.tgz",
"integrity": "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==",
"engines": {
"node": ">=12"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/is-regex": {
"version": "1.1.4",
"resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.1.4.tgz",
"integrity": "sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==",
"dependencies": {
"call-bind": "^1.0.2",
"has-tostringtag": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-set": {
"version": "2.0.2",
"resolved": "https://registry.npmjs.org/is-set/-/is-set-2.0.2.tgz",
"integrity": "sha512-+2cnTEZeY5z/iXGbLhPrOAaK/Mau5k5eXq9j14CpRTftq0pAJu2MwVRSZhyZWBzx3o6X795Lz6Bpb6R0GKf37g==",
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-shared-array-buffer": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.2.tgz",
"integrity": "sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA==",
"dependencies": {
"call-bind": "^1.0.2"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-string": {
"version": "1.0.7",
"resolved": "https://registry.npmjs.org/is-string/-/is-string-1.0.7.tgz",
"integrity": "sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==",
"dependencies": {
"has-tostringtag": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-symbol": {
"version": "1.0.4",
"resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.4.tgz",
"integrity": "sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==",
"dependencies": {
"has-symbols": "^1.0.2"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-typed-array": {
"version": "1.1.10",
"resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.10.tgz",
"integrity": "sha512-PJqgEHiWZvMpaFZ3uTc8kHPM4+4ADTlDniuQL7cU/UDA0Ql7F70yGfHph3cLNe+c9toaigv+DFzTJKhc2CtO6A==",
"dependencies": {
"available-typed-arrays": "^1.0.5",
"call-bind": "^1.0.2",
"for-each": "^0.3.3",
"gopd": "^1.0.1",
"has-tostringtag": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-weakmap": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/is-weakmap/-/is-weakmap-2.0.1.tgz",
"integrity": "sha512-NSBR4kH5oVj1Uwvv970ruUkCV7O1mzgVFO4/rev2cLRda9Tm9HrL70ZPut4rOHgY0FNrUu9BCbXA2sdQ+x0chA==",
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-weakref": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.0.2.tgz",
"integrity": "sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==",
"dependencies": {
"call-bind": "^1.0.2"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-weakset": {
"version": "2.0.2",
"resolved": "https://registry.npmjs.org/is-weakset/-/is-weakset-2.0.2.tgz",
"integrity": "sha512-t2yVvttHkQktwnNNmBQ98AhENLdPUTDTE21uPqAQ0ARwQfGeQKRVS0NNurH7bTf7RrvcVn1OOge45CnBeHCSmg==",
"dependencies": {
"call-bind": "^1.0.2",
"get-intrinsic": "^1.1.1"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-wsl": {
"version": "2.2.0",
"resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-2.2.0.tgz",
"integrity": "sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==",
"dependencies": {
"is-docker": "^2.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/isarray": {
"version": "2.0.5",
"resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz",
"integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw=="
},
"node_modules/isexe": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
"integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="
},
"node_modules/jiti": {
"version": "1.18.2",
"resolved": "https://registry.npmjs.org/jiti/-/jiti-1.18.2.tgz",
"integrity": "sha512-QAdOptna2NYiSSpv0O/BwoHBSmz4YhpzJHyi+fnMRTXFjp7B8i/YG5Z8IfusxB1ufjcD2Sre1F3R+nX3fvy7gg==",
"bin": {
"jiti": "bin/jiti.js"
}
},
"node_modules/js-sdsl": {
"version": "4.4.0",
"resolved": "https://registry.npmjs.org/js-sdsl/-/js-sdsl-4.4.0.tgz",
"integrity": "sha512-FfVSdx6pJ41Oa+CF7RDaFmTnCaFhua+SNYQX74riGOpl96x+2jQCqEfQ2bnXu/5DPCqlRuiqyvTJM0Qjz26IVg==",
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/js-sdsl"
}
},
"node_modules/js-tokens": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
"integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="
},
"node_modules/js-yaml": {
"version": "4.1.0",
"resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
"integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
"dependencies": {
"argparse": "^2.0.1"
},
"bin": {
"js-yaml": "bin/js-yaml.js"
}
},
"node_modules/json-schema-traverse": {
"version": "0.4.1",
"resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
"integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg=="
},
"node_modules/json-stable-stringify-without-jsonify": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
"integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw=="
},
"node_modules/json5": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/json5/-/json5-1.0.2.tgz",
"integrity": "sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==",
"dependencies": {
"minimist": "^1.2.0"
},
"bin": {
"json5": "lib/cli.js"
}
},
"node_modules/jsx-ast-utils": {
"version": "3.3.3",
"resolved": "https://registry.npmjs.org/jsx-ast-utils/-/jsx-ast-utils-3.3.3.tgz",
"integrity": "sha512-fYQHZTZ8jSfmWZ0iyzfwiU4WDX4HpHbMCZ3gPlWYiCl3BoeOTsqKBqnTVfH2rYT7eP5c3sVbeSPHnnJOaTrWiw==",
"dependencies": {
"array-includes": "^3.1.5",
"object.assign": "^4.1.3"
},
"engines": {
"node": ">=4.0"
}
},
"node_modules/kind-of": {
"version": "6.0.3",
"resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz",
"integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==",
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/kleur": {
"version": "4.1.5",
"resolved": "https://registry.npmjs.org/kleur/-/kleur-4.1.5.tgz",
"integrity": "sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==",
"engines": {
"node": ">=6"
}
},
"node_modules/language-subtag-registry": {
"version": "0.3.22",
"resolved": "https://registry.npmjs.org/language-subtag-registry/-/language-subtag-registry-0.3.22.tgz",
"integrity": "sha512-tN0MCzyWnoz/4nHS6uxdlFWoUZT7ABptwKPQ52Ea7URk6vll88bWBVhodtnlfEuCcKWNGoc+uGbw1cwa9IKh/w=="
},
"node_modules/language-tags": {
"version": "1.0.5",
"resolved": "https://registry.npmjs.org/language-tags/-/language-tags-1.0.5.tgz",
"integrity": "sha512-qJhlO9cGXi6hBGKoxEG/sKZDAHD5Hnu9Hs4WbOY3pCWXDhw0N8x1NenNzm2EnNLkLkk7J2SdxAkDSbb6ftT+UQ==",
"dependencies": {
"language-subtag-registry": "~0.3.2"
}
},
"node_modules/levn": {
"version": "0.4.1",
"resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
"integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
"dependencies": {
"prelude-ls": "^1.2.1",
"type-check": "~0.4.0"
},
"engines": {
"node": ">= 0.8.0"
}
},
"node_modules/lilconfig": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-2.1.0.tgz",
"integrity": "sha512-utWOt/GHzuUxnLKxB6dk81RoOeoNeHgbrXiuGk4yyF5qlRz+iIVWu56E2fqGHFrXz0QNUhLB/8nKqvRH66JKGQ==",
"engines": {
"node": ">=10"
}
},
"node_modules/lines-and-columns": {
"version": "1.2.4",
"resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz",
"integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg=="
},
"node_modules/locate-path": {
"version": "6.0.0",
"resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
"integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
"dependencies": {
"p-locate": "^5.0.0"
},
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/lodash.castarray": {
"version": "4.4.0",
"resolved": "https://registry.npmjs.org/lodash.castarray/-/lodash.castarray-4.4.0.tgz",
"integrity": "sha512-aVx8ztPv7/2ULbArGJ2Y42bG1mEQ5mGjpdvrbJcJFU3TbYybe+QlLS4pst9zV52ymy2in1KpFPiZnAOATxD4+Q=="
},
"node_modules/lodash.isplainobject": {
"version": "4.0.6",
"resolved": "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz",
"integrity": "sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA=="
},
"node_modules/lodash.merge": {
"version": "4.6.2",
"resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
"integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ=="
},
"node_modules/longest-streak": {
"version": "3.1.0",
"resolved": "https://registry.npmjs.org/longest-streak/-/longest-streak-3.1.0.tgz",
"integrity": "sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g==",
"funding": {
"type": "github",
"url": "https://github.com/sponsors/wooorm"
}
},
"node_modules/loose-envify": {
"version": "1.4.0",
"resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
"integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
"dependencies": {
"js-tokens": "^3.0.0 || ^4.0.0"
},
"bin": {
"loose-envify": "cli.js"
}
},
"node_modules/lru-cache": {
"version": "6.0.0",
"resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz",
"integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==",
"dependencies": {
"yallist": "^4.0.0"
},
"engines": {
"node": ">=10"
}
},
"node_modules/mdast-util-definitions": {
"version": "5.1.2",
"resolved": "https://registry.npmjs.org/mdast-util-definitions/-/mdast-util-definitions-5.1.2.tgz",
"integrity": "sha512-8SVPMuHqlPME/z3gqVwWY4zVXn8lqKv/pAhC57FuJ40ImXyBpmO5ukh98zB2v7Blql2FiHjHv9LVztSIqjY+MA==",
"dependencies": {
"@types/mdast": "^3.0.0",
"@types/unist": "^2.0.0",
"unist-util-visit": "^4.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/mdast-util-from-markdown": {
"version": "1.3.0",
"resolved": "https://registry.npmjs.org/mdast-util-from-markdown/-/mdast-util-from-markdown-1.3.0.tgz",
"integrity": "sha512-HN3W1gRIuN/ZW295c7zi7g9lVBllMgZE40RxCX37wrTPWXCWtpvOZdfnuK+1WNpvZje6XuJeI3Wnb4TJEUem+g==",
"dependencies": {
"@types/mdast": "^3.0.0",
"@types/unist": "^2.0.0",
"decode-named-character-reference": "^1.0.0",
"mdast-util-to-string": "^3.1.0",
"micromark": "^3.0.0",
"micromark-util-decode-numeric-character-reference": "^1.0.0",
"micromark-util-decode-string": "^1.0.0",
"micromark-util-normalize-identifier": "^1.0.0",
"micromark-util-symbol": "^1.0.0",
"micromark-util-types": "^1.0.0",
"unist-util-stringify-position": "^3.0.0",
"uvu": "^0.5.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/mdast-util-phrasing": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/mdast-util-phrasing/-/mdast-util-phrasing-3.0.1.tgz",
"integrity": "sha512-WmI1gTXUBJo4/ZmSk79Wcb2HcjPJBzM1nlI/OUWA8yk2X9ik3ffNbBGsU+09BFmXaL1IBb9fiuvq6/KMiNycSg==",
"dependencies": {
"@types/mdast": "^3.0.0",
"unist-util-is": "^5.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/mdast-util-to-hast": {
"version": "12.3.0",
"resolved": "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-12.3.0.tgz",
"integrity": "sha512-pits93r8PhnIoU4Vy9bjW39M2jJ6/tdHyja9rrot9uujkN7UTU9SDnE6WNJz/IGyQk3XHX6yNNtrBH6cQzm8Hw==",
"dependencies": {
"@types/hast": "^2.0.0",
"@types/mdast": "^3.0.0",
"mdast-util-definitions": "^5.0.0",
"micromark-util-sanitize-uri": "^1.1.0",
"trim-lines": "^3.0.0",
"unist-util-generated": "^2.0.0",
"unist-util-position": "^4.0.0",
"unist-util-visit": "^4.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/mdast-util-to-markdown": {
"version": "1.5.0",
"resolved": "https://registry.npmjs.org/mdast-util-to-markdown/-/mdast-util-to-markdown-1.5.0.tgz",
"integrity": "sha512-bbv7TPv/WC49thZPg3jXuqzuvI45IL2EVAr/KxF0BSdHsU0ceFHOmwQn6evxAh1GaoK/6GQ1wp4R4oW2+LFL/A==",
"dependencies": {
"@types/mdast": "^3.0.0",
"@types/unist": "^2.0.0",
"longest-streak": "^3.0.0",
"mdast-util-phrasing": "^3.0.0",
"mdast-util-to-string": "^3.0.0",
"micromark-util-decode-string": "^1.0.0",
"unist-util-visit": "^4.0.0",
"zwitch": "^2.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/mdast-util-to-string": {
"version": "3.2.0",
"resolved": "https://registry.npmjs.org/mdast-util-to-string/-/mdast-util-to-string-3.2.0.tgz",
"integrity": "sha512-V4Zn/ncyN1QNSqSBxTrMOLpjr+IKdHl2v3KVLoWmDPscP4r9GcCi71gjgvUV1SFSKh92AjAG4peFuBl2/YgCJg==",
"dependencies": {
"@types/mdast": "^3.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/merge2": {
"version": "1.4.1",
"resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
"integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
"engines": {
"node": ">= 8"
}
},
"node_modules/micromark": {
"version": "3.1.0",
"resolved": "https://registry.npmjs.org/micromark/-/micromark-3.1.0.tgz",
"integrity": "sha512-6Mj0yHLdUZjHnOPgr5xfWIMqMWS12zDN6iws9SLuSz76W8jTtAv24MN4/CL7gJrl5vtxGInkkqDv/JIoRsQOvA==",
"funding": [
{
"type": "GitHub Sponsors",
"url": "https://github.com/sponsors/unifiedjs"
},
{
"type": "OpenCollective",
"url": "https://opencollective.com/unified"
}
],
"dependencies": {
"@types/debug": "^4.0.0",
"debug": "^4.0.0",
"decode-named-character-reference": "^1.0.0",
"micromark-core-commonmark": "^1.0.1",
"micromark-factory-space": "^1.0.0",
"micromark-util-character": "^1.0.0",
"micromark-util-chunked": "^1.0.0",
"micromark-util-combine-extensions": "^1.0.0",
"micromark-util-decode-numeric-character-reference": "^1.0.0",
"micromark-util-encode": "^1.0.0",
"micromark-util-normalize-identifier": "^1.0.0",
"micromark-util-resolve-all": "^1.0.0",
"micromark-util-sanitize-uri": "^1.0.0",
"micromark-util-subtokenize": "^1.0.0",
"micromark-util-symbol": "^1.0.0",
"micromark-util-types": "^1.0.1",
"uvu": "^0.5.0"
}
},
"node_modules/micromark-core-commonmark": {
"version": "1.0.6",
"resolved": "https://registry.npmjs.org/micromark-core-commonmark/-/micromark-core-commonmark-1.0.6.tgz",
"integrity": "sha512-K+PkJTxqjFfSNkfAhp4GB+cZPfQd6dxtTXnf+RjZOV7T4EEXnvgzOcnp+eSTmpGk9d1S9sL6/lqrgSNn/s0HZA==",
"funding": [
{
"type": "GitHub Sponsors",
"url": "https://github.com/sponsors/unifiedjs"
},
{
"type": "OpenCollective",
"url": "https://opencollective.com/unified"
}
],
"dependencies": {
"decode-named-character-reference": "^1.0.0",
"micromark-factory-destination": "^1.0.0",
"micromark-factory-label": "^1.0.0",
"micromark-factory-space": "^1.0.0",
"micromark-factory-title": "^1.0.0",
"micromark-factory-whitespace": "^1.0.0",
"micromark-util-character": "^1.0.0",
"micromark-util-chunked": "^1.0.0",
"micromark-util-classify-character": "^1.0.0",
"micromark-util-html-tag-name": "^1.0.0",
"micromark-util-normalize-identifier": "^1.0.0",
"micromark-util-resolve-all": "^1.0.0",
"micromark-util-subtokenize": "^1.0.0",
"micromark-util-symbol": "^1.0.0",
"micromark-util-types": "^1.0.1",
"uvu": "^0.5.0"
}
},
"node_modules/micromark-factory-destination": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/micromark-factory-destination/-/micromark-factory-destination-1.0.0.tgz",
"integrity": "sha512-eUBA7Rs1/xtTVun9TmV3gjfPz2wEwgK5R5xcbIM5ZYAtvGF6JkyaDsj0agx8urXnO31tEO6Ug83iVH3tdedLnw==",
"funding": [
{
"type": "GitHub Sponsors",
"url": "https://github.com/sponsors/unifiedjs"
},
{
"type": "OpenCollective",
"url": "https://opencollective.com/unified"
}
],
"dependencies": {
"micromark-util-character": "^1.0.0",
"micromark-util-symbol": "^1.0.0",
"micromark-util-types": "^1.0.0"
}
},
"node_modules/micromark-factory-label": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/micromark-factory-label/-/micromark-factory-label-1.0.2.tgz",
"integrity": "sha512-CTIwxlOnU7dEshXDQ+dsr2n+yxpP0+fn271pu0bwDIS8uqfFcumXpj5mLn3hSC8iw2MUr6Gx8EcKng1dD7i6hg==",
"funding": [
{
"type": "GitHub Sponsors",
"url": "https://github.com/sponsors/unifiedjs"
},
{
"type": "OpenCollective",
"url": "https://opencollective.com/unified"
}
],
"dependencies": {
"micromark-util-character": "^1.0.0",
"micromark-util-symbol": "^1.0.0",
"micromark-util-types": "^1.0.0",
"uvu": "^0.5.0"
}
},
"node_modules/micromark-factory-space": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-1.0.0.tgz",
"integrity": "sha512-qUmqs4kj9a5yBnk3JMLyjtWYN6Mzfcx8uJfi5XAveBniDevmZasdGBba5b4QsvRcAkmvGo5ACmSUmyGiKTLZew==",
"funding": [
{
"type": "GitHub Sponsors",
"url": "https://github.com/sponsors/unifiedjs"
},
{
"type": "OpenCollective",
"url": "https://opencollective.com/unified"
}
],
"dependencies": {
"micromark-util-character": "^1.0.0",
"micromark-util-types": "^1.0.0"
}
},
"node_modules/micromark-factory-title": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/micromark-factory-title/-/micromark-factory-title-1.0.2.tgz",
"integrity": "sha512-zily+Nr4yFqgMGRKLpTVsNl5L4PMu485fGFDOQJQBl2NFpjGte1e86zC0da93wf97jrc4+2G2GQudFMHn3IX+A==",
"funding": [
{
"type": "GitHub Sponsors",
"url": "https://github.com/sponsors/unifiedjs"
},
{
"type": "OpenCollective",
"url": "https://opencollective.com/unified"
}
],
"dependencies": {
"micromark-factory-space": "^1.0.0",
"micromark-util-character": "^1.0.0",
"micromark-util-symbol": "^1.0.0",
"micromark-util-types": "^1.0.0",
"uvu": "^0.5.0"
}
},
"node_modules/micromark-factory-whitespace": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/micromark-factory-whitespace/-/micromark-factory-whitespace-1.0.0.tgz",
"integrity": "sha512-Qx7uEyahU1lt1RnsECBiuEbfr9INjQTGa6Err+gF3g0Tx4YEviPbqqGKNv/NrBaE7dVHdn1bVZKM/n5I/Bak7A==",
"funding": [
{
"type": "GitHub Sponsors",
"url": "https://github.com/sponsors/unifiedjs"
},
{
"type": "OpenCollective",
"url": "https://opencollective.com/unified"
}
],
"dependencies": {
"micromark-factory-space": "^1.0.0",
"micromark-util-character": "^1.0.0",
"micromark-util-symbol": "^1.0.0",
"micromark-util-types": "^1.0.0"
}
},
"node_modules/micromark-util-character": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-1.1.0.tgz",
"integrity": "sha512-agJ5B3unGNJ9rJvADMJ5ZiYjBRyDpzKAOk01Kpi1TKhlT1APx3XZk6eN7RtSz1erbWHC2L8T3xLZ81wdtGRZzg==",
"funding": [
{
"type": "GitHub Sponsors",
"url": "https://github.com/sponsors/unifiedjs"
},
{
"type": "OpenCollective",
"url": "https://opencollective.com/unified"
}
],
"dependencies": {
"micromark-util-symbol": "^1.0.0",
"micromark-util-types": "^1.0.0"
}
},
"node_modules/micromark-util-chunked": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/micromark-util-chunked/-/micromark-util-chunked-1.0.0.tgz",
"integrity": "sha512-5e8xTis5tEZKgesfbQMKRCyzvffRRUX+lK/y+DvsMFdabAicPkkZV6gO+FEWi9RfuKKoxxPwNL+dFF0SMImc1g==",
"funding": [
{
"type": "GitHub Sponsors",
"url": "https://github.com/sponsors/unifiedjs"
},
{
"type": "OpenCollective",
"url": "https://opencollective.com/unified"
}
],
"dependencies": {
"micromark-util-symbol": "^1.0.0"
}
},
"node_modules/micromark-util-classify-character": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/micromark-util-classify-character/-/micromark-util-classify-character-1.0.0.tgz",
"integrity": "sha512-F8oW2KKrQRb3vS5ud5HIqBVkCqQi224Nm55o5wYLzY/9PwHGXC01tr3d7+TqHHz6zrKQ72Okwtvm/xQm6OVNZA==",
"funding": [
{
"type": "GitHub Sponsors",
"url": "https://github.com/sponsors/unifiedjs"
},
{
"type": "OpenCollective",
"url": "https://opencollective.com/unified"
}
],
"dependencies": {
"micromark-util-character": "^1.0.0",
"micromark-util-symbol": "^1.0.0",
"micromark-util-types": "^1.0.0"
}
},
"node_modules/micromark-util-combine-extensions": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/micromark-util-combine-extensions/-/micromark-util-combine-extensions-1.0.0.tgz",
"integrity": "sha512-J8H058vFBdo/6+AsjHp2NF7AJ02SZtWaVUjsayNFeAiydTxUwViQPxN0Hf8dp4FmCQi0UUFovFsEyRSUmFH3MA==",
"funding": [
{
"type": "GitHub Sponsors",
"url": "https://github.com/sponsors/unifiedjs"
},
{
"type": "OpenCollective",
"url": "https://opencollective.com/unified"
}
],
"dependencies": {
"micromark-util-chunked": "^1.0.0",
"micromark-util-types": "^1.0.0"
}
},
"node_modules/micromark-util-decode-numeric-character-reference": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/micromark-util-decode-numeric-character-reference/-/micromark-util-decode-numeric-character-reference-1.0.0.tgz",
"integrity": "sha512-OzO9AI5VUtrTD7KSdagf4MWgHMtET17Ua1fIpXTpuhclCqD8egFWo85GxSGvxgkGS74bEahvtM0WP0HjvV0e4w==",
"funding": [
{
"type": "GitHub Sponsors",
"url": "https://github.com/sponsors/unifiedjs"
},
{
"type": "OpenCollective",
"url": "https://opencollective.com/unified"
}
],
"dependencies": {
"micromark-util-symbol": "^1.0.0"
}
},
"node_modules/micromark-util-decode-string": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/micromark-util-decode-string/-/micromark-util-decode-string-1.0.2.tgz",
"integrity": "sha512-DLT5Ho02qr6QWVNYbRZ3RYOSSWWFuH3tJexd3dgN1odEuPNxCngTCXJum7+ViRAd9BbdxCvMToPOD/IvVhzG6Q==",
"funding": [
{
"type": "GitHub Sponsors",
"url": "https://github.com/sponsors/unifiedjs"
},
{
"type": "OpenCollective",
"url": "https://opencollective.com/unified"
}
],
"dependencies": {
"decode-named-character-reference": "^1.0.0",
"micromark-util-character": "^1.0.0",
"micromark-util-decode-numeric-character-reference": "^1.0.0",
"micromark-util-symbol": "^1.0.0"
}
},
"node_modules/micromark-util-encode": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/micromark-util-encode/-/micromark-util-encode-1.0.1.tgz",
"integrity": "sha512-U2s5YdnAYexjKDel31SVMPbfi+eF8y1U4pfiRW/Y8EFVCy/vgxk/2wWTxzcqE71LHtCuCzlBDRU2a5CQ5j+mQA==",
"funding": [
{
"type": "GitHub Sponsors",
"url": "https://github.com/sponsors/unifiedjs"
},
{
"type": "OpenCollective",
"url": "https://opencollective.com/unified"
}
]
},
"node_modules/micromark-util-html-tag-name": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/micromark-util-html-tag-name/-/micromark-util-html-tag-name-1.1.0.tgz",
"integrity": "sha512-BKlClMmYROy9UiV03SwNmckkjn8QHVaWkqoAqzivabvdGcwNGMMMH/5szAnywmsTBUzDsU57/mFi0sp4BQO6dA==",
"funding": [
{
"type": "GitHub Sponsors",
"url": "https://github.com/sponsors/unifiedjs"
},
{
"type": "OpenCollective",
"url": "https://opencollective.com/unified"
}
]
},
"node_modules/micromark-util-normalize-identifier": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/micromark-util-normalize-identifier/-/micromark-util-normalize-identifier-1.0.0.tgz",
"integrity": "sha512-yg+zrL14bBTFrQ7n35CmByWUTFsgst5JhA4gJYoty4Dqzj4Z4Fr/DHekSS5aLfH9bdlfnSvKAWsAgJhIbogyBg==",
"funding": [
{
"type": "GitHub Sponsors",
"url": "https://github.com/sponsors/unifiedjs"
},
{
"type": "OpenCollective",
"url": "https://opencollective.com/unified"
}
],
"dependencies": {
"micromark-util-symbol": "^1.0.0"
}
},
"node_modules/micromark-util-resolve-all": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/micromark-util-resolve-all/-/micromark-util-resolve-all-1.0.0.tgz",
"integrity": "sha512-CB/AGk98u50k42kvgaMM94wzBqozSzDDaonKU7P7jwQIuH2RU0TeBqGYJz2WY1UdihhjweivStrJ2JdkdEmcfw==",
"funding": [
{
"type": "GitHub Sponsors",
"url": "https://github.com/sponsors/unifiedjs"
},
{
"type": "OpenCollective",
"url": "https://opencollective.com/unified"
}
],
"dependencies": {
"micromark-util-types": "^1.0.0"
}
},
"node_modules/micromark-util-sanitize-uri": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-1.1.0.tgz",
"integrity": "sha512-RoxtuSCX6sUNtxhbmsEFQfWzs8VN7cTctmBPvYivo98xb/kDEoTCtJQX5wyzIYEmk/lvNFTat4hL8oW0KndFpg==",
"funding": [
{
"type": "GitHub Sponsors",
"url": "https://github.com/sponsors/unifiedjs"
},
{
"type": "OpenCollective",
"url": "https://opencollective.com/unified"
}
],
"dependencies": {
"micromark-util-character": "^1.0.0",
"micromark-util-encode": "^1.0.0",
"micromark-util-symbol": "^1.0.0"
}
},
"node_modules/micromark-util-subtokenize": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/micromark-util-subtokenize/-/micromark-util-subtokenize-1.0.2.tgz",
"integrity": "sha512-d90uqCnXp/cy4G881Ub4psE57Sf8YD0pim9QdjCRNjfas2M1u6Lbt+XZK9gnHL2XFhnozZiEdCa9CNfXSfQ6xA==",
"funding": [
{
"type": "GitHub Sponsors",
"url": "https://github.com/sponsors/unifiedjs"
},
{
"type": "OpenCollective",
"url": "https://opencollective.com/unified"
}
],
"dependencies": {
"micromark-util-chunked": "^1.0.0",
"micromark-util-symbol": "^1.0.0",
"micromark-util-types": "^1.0.0",
"uvu": "^0.5.0"
}
},
"node_modules/micromark-util-symbol": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-1.0.1.tgz",
"integrity": "sha512-oKDEMK2u5qqAptasDAwWDXq0tG9AssVwAx3E9bBF3t/shRIGsWIRG+cGafs2p/SnDSOecnt6hZPCE2o6lHfFmQ==",
"funding": [
{
"type": "GitHub Sponsors",
"url": "https://github.com/sponsors/unifiedjs"
},
{
"type": "OpenCollective",
"url": "https://opencollective.com/unified"
}
]
},
"node_modules/micromark-util-types": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/micromark-util-types/-/micromark-util-types-1.0.2.tgz",
"integrity": "sha512-DCfg/T8fcrhrRKTPjRrw/5LLvdGV7BHySf/1LOZx7TzWZdYRjogNtyNq885z3nNallwr3QUKARjqvHqX1/7t+w==",
"funding": [
{
"type": "GitHub Sponsors",
"url": "https://github.com/sponsors/unifiedjs"
},
{
"type": "OpenCollective",
"url": "https://opencollective.com/unified"
}
]
},
"node_modules/micromatch": {
"version": "4.0.5",
"resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz",
"integrity": "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==",
"dependencies": {
"braces": "^3.0.2",
"picomatch": "^2.3.1"
},
"engines": {
"node": ">=8.6"
}
},
"node_modules/minimatch": {
"version": "3.1.2",
"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
"integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
"dependencies": {
"brace-expansion": "^1.1.7"
},
"engines": {
"node": "*"
}
},
"node_modules/minimist": {
"version": "1.2.8",
"resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
"integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/mri": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/mri/-/mri-1.2.0.tgz",
"integrity": "sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==",
"engines": {
"node": ">=4"
}
},
"node_modules/ms": {
"version": "2.1.2",
"resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
"integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="
},
"node_modules/mz": {
"version": "2.7.0",
"resolved": "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz",
"integrity": "sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==",
"dependencies": {
"any-promise": "^1.0.0",
"object-assign": "^4.0.1",
"thenify-all": "^1.0.0"
}
},
"node_modules/nanoid": {
"version": "3.3.6",
"resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.6.tgz",
"integrity": "sha512-BGcqMMJuToF7i1rt+2PWSNVnWIkGCU78jBG3RxO/bZlnZPK2Cmi2QaffxGO/2RvWi9sL+FAiRiXMgsyxQ1DIDA==",
"funding": [
{
"type": "github",
"url": "https://github.com/sponsors/ai"
}
],
"bin": {
"nanoid": "bin/nanoid.cjs"
},
"engines": {
"node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
}
},
"node_modules/natural-compare": {
"version": "1.4.0",
"resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
"integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw=="
},
"node_modules/next": {
"version": "13.2.4",
"resolved": "https://registry.npmjs.org/next/-/next-13.2.4.tgz",
"integrity": "sha512-g1I30317cThkEpvzfXujf0O4wtaQHtDCLhlivwlTJ885Ld+eOgcz7r3TGQzeU+cSRoNHtD8tsJgzxVdYojFssw==",
"dependencies": {
"@next/env": "13.2.4",
"@swc/helpers": "0.4.14",
"caniuse-lite": "^1.0.30001406",
"postcss": "8.4.14",
"styled-jsx": "5.1.1"
},
"bin": {
"next": "dist/bin/next"
},
"engines": {
"node": ">=14.6.0"
},
"optionalDependencies": {
"@next/swc-android-arm-eabi": "13.2.4",
"@next/swc-android-arm64": "13.2.4",
"@next/swc-darwin-arm64": "13.2.4",
"@next/swc-darwin-x64": "13.2.4",
"@next/swc-freebsd-x64": "13.2.4",
"@next/swc-linux-arm-gnueabihf": "13.2.4",
"@next/swc-linux-arm64-gnu": "13.2.4",
"@next/swc-linux-arm64-musl": "13.2.4",
"@next/swc-linux-x64-gnu": "13.2.4",
"@next/swc-linux-x64-musl": "13.2.4",
"@next/swc-win32-arm64-msvc": "13.2.4",
"@next/swc-win32-ia32-msvc": "13.2.4",
"@next/swc-win32-x64-msvc": "13.2.4"
},
"peerDependencies": {
"@opentelemetry/api": "^1.4.0",
"fibers": ">= 3.1.0",
"node-sass": "^6.0.0 || ^7.0.0",
"react": "^18.2.0",
"react-dom": "^18.2.0",
"sass": "^1.3.0"
},
"peerDependenciesMeta": {
"@opentelemetry/api": {
"optional": true
},
"fibers": {
"optional": true
},
"node-sass": {
"optional": true
},
"sass": {
"optional": true
}
}
},
"node_modules/next/node_modules/postcss": {
"version": "8.4.14",
"resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.14.tgz",
"integrity": "sha512-E398TUmfAYFPBSdzgeieK2Y1+1cpdxJx8yXbK/m57nRhKSmk1GB2tO4lbLBtlkfPQTDKfe4Xqv1ASWPpayPEig==",
"funding": [
{
"type": "opencollective",
"url": "https://opencollective.com/postcss/"
},
{
"type": "tidelift",
"url": "https://tidelift.com/funding/github/npm/postcss"
}
],
"dependencies": {
"nanoid": "^3.3.4",
"picocolors": "^1.0.0",
"source-map-js": "^1.0.2"
},
"engines": {
"node": "^10 || ^12 || >=14"
}
},
"node_modules/node-releases": {
"version": "2.0.10",
"resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.10.tgz",
"integrity": "sha512-5GFldHPXVG/YZmFzJvKK2zDSzPKhEp0+ZR5SVaoSag9fsL5YgHbUHDfnG5494ISANDcK4KwPXAx2xqVEydmd7w==",
"dev": true
},
"node_modules/normalize-path": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
"integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/normalize-range": {
"version": "0.1.2",
"resolved": "https://registry.npmjs.org/normalize-range/-/normalize-range-0.1.2.tgz",
"integrity": "sha512-bdok/XvKII3nUpklnV6P2hxtMNrCboOjAcyBuQnWEhO665FwrSNRxU+AqpsyvO6LgGYPspN+lu5CLtw4jPRKNA==",
"dev": true,
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/object-assign": {
"version": "4.1.1",
"resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
"integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/object-hash": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/object-hash/-/object-hash-3.0.0.tgz",
"integrity": "sha512-RSn9F68PjH9HqtltsSnqYC1XXoWe9Bju5+213R98cNGttag9q9yAOTzdbsqvIa7aNm5WffBZFpWYr2aWrklWAw==",
"engines": {
"node": ">= 6"
}
},
"node_modules/object-inspect": {
"version": "1.12.3",
"resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.3.tgz",
"integrity": "sha512-geUvdk7c+eizMNUDkRpW1wJwgfOiOeHbxBR/hLXK1aT6zmVSO0jsQcs7fj6MGw89jC/cjGfLcNOrtMYtGqm81g==",
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/object-is": {
"version": "1.1.5",
"resolved": "https://registry.npmjs.org/object-is/-/object-is-1.1.5.tgz",
"integrity": "sha512-3cyDsyHgtmi7I7DfSSI2LDp6SK2lwvtbg0p0R1e0RvTqF5ceGx+K2dfSjm1bKDMVCFEDAQvy+o8c6a7VujOddw==",
"dependencies": {
"call-bind": "^1.0.2",
"define-properties": "^1.1.3"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/object-keys": {
"version": "1.1.1",
"resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
"integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
"engines": {
"node": ">= 0.4"
}
},
"node_modules/object.assign": {
"version": "4.1.4",
"resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.4.tgz",
"integrity": "sha512-1mxKf0e58bvyjSCtKYY4sRe9itRk3PJpquJOjeIkz885CczcI4IvJJDLPS72oowuSh+pBxUFROpX+TU++hxhZQ==",
"dependencies": {
"call-bind": "^1.0.2",
"define-properties": "^1.1.4",
"has-symbols": "^1.0.3",
"object-keys": "^1.1.1"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/object.entries": {
"version": "1.1.6",
"resolved": "https://registry.npmjs.org/object.entries/-/object.entries-1.1.6.tgz",
"integrity": "sha512-leTPzo4Zvg3pmbQ3rDK69Rl8GQvIqMWubrkxONG9/ojtFE2rD9fjMKfSI5BxW3osRH1m6VdzmqK8oAY9aT4x5w==",
"dependencies": {
"call-bind": "^1.0.2",
"define-properties": "^1.1.4",
"es-abstract": "^1.20.4"
},
"engines": {
"node": ">= 0.4"
}
},
"node_modules/object.fromentries": {
"version": "2.0.6",
"resolved": "https://registry.npmjs.org/object.fromentries/-/object.fromentries-2.0.6.tgz",
"integrity": "sha512-VciD13dswC4j1Xt5394WR4MzmAQmlgN72phd/riNp9vtD7tp4QQWJ0R4wvclXcafgcYK8veHRed2W6XeGBvcfg==",
"dependencies": {
"call-bind": "^1.0.2",
"define-properties": "^1.1.4",
"es-abstract": "^1.20.4"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/object.hasown": {
"version": "1.1.2",
"resolved": "https://registry.npmjs.org/object.hasown/-/object.hasown-1.1.2.tgz",
"integrity": "sha512-B5UIT3J1W+WuWIU55h0mjlwaqxiE5vYENJXIXZ4VFe05pNYrkKuK0U/6aFcb0pKywYJh7IhfoqUfKVmrJJHZHw==",
"dependencies": {
"define-properties": "^1.1.4",
"es-abstract": "^1.20.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/object.values": {
"version": "1.1.6",
"resolved": "https://registry.npmjs.org/object.values/-/object.values-1.1.6.tgz",
"integrity": "sha512-FVVTkD1vENCsAcwNs9k6jea2uHC/X0+JcjG8YA60FN5CMaJmG95wT9jek/xX9nornqGRrBkKtzuAu2wuHpKqvw==",
"dependencies": {
"call-bind": "^1.0.2",
"define-properties": "^1.1.4",
"es-abstract": "^1.20.4"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/once": {
"version": "1.4.0",
"resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
"integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
"dependencies": {
"wrappy": "1"
}
},
"node_modules/open": {
"version": "8.4.2",
"resolved": "https://registry.npmjs.org/open/-/open-8.4.2.tgz",
"integrity": "sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ==",
"dependencies": {
"define-lazy-prop": "^2.0.0",
"is-docker": "^2.1.1",
"is-wsl": "^2.2.0"
},
"engines": {
"node": ">=12"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/optionator": {
"version": "0.9.1",
"resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.1.tgz",
"integrity": "sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw==",
"dependencies": {
"deep-is": "^0.1.3",
"fast-levenshtein": "^2.0.6",
"levn": "^0.4.1",
"prelude-ls": "^1.2.1",
"type-check": "^0.4.0",
"word-wrap": "^1.2.3"
},
"engines": {
"node": ">= 0.8.0"
}
},
"node_modules/p-limit": {
"version": "3.1.0",
"resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
"integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
"dependencies": {
"yocto-queue": "^0.1.0"
},
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/p-locate": {
"version": "5.0.0",
"resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
"integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
"dependencies": {
"p-limit": "^3.0.2"
},
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/parent-module": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
"integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
"dependencies": {
"callsites": "^3.0.0"
},
"engines": {
"node": ">=6"
}
},
"node_modules/parse5": {
"version": "6.0.1",
"resolved": "https://registry.npmjs.org/parse5/-/parse5-6.0.1.tgz",
"integrity": "sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw=="
},
"node_modules/path-exists": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
"integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
"engines": {
"node": ">=8"
}
},
"node_modules/path-is-absolute": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
"integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/path-key": {
"version": "3.1.1",
"resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
"integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
"engines": {
"node": ">=8"
}
},
"node_modules/path-parse": {
"version": "1.0.7",
"resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
"integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw=="
},
"node_modules/path-type": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz",
"integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==",
"engines": {
"node": ">=8"
}
},
"node_modules/picocolors": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz",
"integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ=="
},
"node_modules/picomatch": {
"version": "2.3.1",
"resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
"integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
"engines": {
"node": ">=8.6"
},
"funding": {
"url": "https://github.com/sponsors/jonschlinkert"
}
},
"node_modules/pify": {
"version": "2.3.0",
"resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz",
"integrity": "sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==",
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/pirates": {
"version": "4.0.5",
"resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.5.tgz",
"integrity": "sha512-8V9+HQPupnaXMA23c5hvl69zXvTwTzyAYasnkb0Tts4XvO4CliqONMOnvlq26rkhLC3nWDFBJf73LU1e1VZLaQ==",
"engines": {
"node": ">= 6"
}
},
"node_modules/postcss": {
"version": "8.4.21",
"resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.21.tgz",
"integrity": "sha512-tP7u/Sn/dVxK2NnruI4H9BG+x+Wxz6oeZ1cJ8P6G/PZY0IKk4k/63TDsQf2kQq3+qoJeLm2kIBUNlZe3zgb4Zg==",
"funding": [
{
"type": "opencollective",
"url": "https://opencollective.com/postcss/"
},
{
"type": "tidelift",
"url": "https://tidelift.com/funding/github/npm/postcss"
}
],
"dependencies": {
"nanoid": "^3.3.4",
"picocolors": "^1.0.0",
"source-map-js": "^1.0.2"
},
"engines": {
"node": "^10 || ^12 || >=14"
}
},
"node_modules/postcss-import": {
"version": "14.1.0",
"resolved": "https://registry.npmjs.org/postcss-import/-/postcss-import-14.1.0.tgz",
"integrity": "sha512-flwI+Vgm4SElObFVPpTIT7SU7R3qk2L7PyduMcokiaVKuWv9d/U+Gm/QAd8NDLuykTWTkcrjOeD2Pp1rMeBTGw==",
"dependencies": {
"postcss-value-parser": "^4.0.0",
"read-cache": "^1.0.0",
"resolve": "^1.1.7"
},
"engines": {
"node": ">=10.0.0"
},
"peerDependencies": {
"postcss": "^8.0.0"
}
},
"node_modules/postcss-js": {
"version": "4.0.1",
"resolved": "https://registry.npmjs.org/postcss-js/-/postcss-js-4.0.1.tgz",
"integrity": "sha512-dDLF8pEO191hJMtlHFPRa8xsizHaM82MLfNkUHdUtVEV3tgTp5oj+8qbEqYM57SLfc74KSbw//4SeJma2LRVIw==",
"dependencies": {
"camelcase-css": "^2.0.1"
},
"engines": {
"node": "^12 || ^14 || >= 16"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/postcss/"
},
"peerDependencies": {
"postcss": "^8.4.21"
}
},
"node_modules/postcss-nested": {
"version": "6.0.0",
"resolved": "https://registry.npmjs.org/postcss-nested/-/postcss-nested-6.0.0.tgz",
"integrity": "sha512-0DkamqrPcmkBDsLn+vQDIrtkSbNkv5AD/M322ySo9kqFkCIYklym2xEmWkwo+Y3/qZo34tzEPNUw4y7yMCdv5w==",
"dependencies": {
"postcss-selector-parser": "^6.0.10"
},
"engines": {
"node": ">=12.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/postcss/"
},
"peerDependencies": {
"postcss": "^8.2.14"
}
},
"node_modules/postcss-selector-parser": {
"version": "6.0.10",
"resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.0.10.tgz",
"integrity": "sha512-IQ7TZdoaqbT+LCpShg46jnZVlhWD2w6iQYAcYXfHARZ7X1t/UGhhceQDs5X0cGqKvYlHNOuv7Oa1xmb0oQuA3w==",
"dependencies": {
"cssesc": "^3.0.0",
"util-deprecate": "^1.0.2"
},
"engines": {
"node": ">=4"
}
},
"node_modules/postcss-value-parser": {
"version": "4.2.0",
"resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz",
"integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ=="
},
"node_modules/prelude-ls": {
"version": "1.2.1",
"resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
"integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
"engines": {
"node": ">= 0.8.0"
}
},
"node_modules/prop-types": {
"version": "15.8.1",
"resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz",
"integrity": "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==",
"dependencies": {
"loose-envify": "^1.4.0",
"object-assign": "^4.1.1",
"react-is": "^16.13.1"
}
},
"node_modules/property-information": {
"version": "6.2.0",
"resolved": "https://registry.npmjs.org/property-information/-/property-information-6.2.0.tgz",
"integrity": "sha512-kma4U7AFCTwpqq5twzC1YVIDXSqg6qQK6JN0smOw8fgRy1OkMi0CYSzFmsy6dnqSenamAtj0CyXMUJ1Mf6oROg==",
"funding": {
"type": "github",
"url": "https://github.com/sponsors/wooorm"
}
},
"node_modules/punycode": {
"version": "2.3.0",
"resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.0.tgz",
"integrity": "sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA==",
"engines": {
"node": ">=6"
}
},
"node_modules/queue-microtask": {
"version": "1.2.3",
"resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
"integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
"funding": [
{
"type": "github",
"url": "https://github.com/sponsors/feross"
},
{
"type": "patreon",
"url": "https://www.patreon.com/feross"
},
{
"type": "consulting",
"url": "https://feross.org/support"
}
]
},
"node_modules/quick-lru": {
"version": "5.1.1",
"resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-5.1.1.tgz",
"integrity": "sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==",
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/react": {
"version": "18.2.0",
"resolved": "https://registry.npmjs.org/react/-/react-18.2.0.tgz",
"integrity": "sha512-/3IjMdb2L9QbBdWiW5e3P2/npwMBaU9mHCSCUzNln0ZCYbcfTsGbTJrU/kGemdH2IWmB2ioZ+zkxtmq6g09fGQ==",
"dependencies": {
"loose-envify": "^1.1.0"
},
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/react-dom": {
"version": "18.2.0",
"resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.2.0.tgz",
"integrity": "sha512-6IMTriUmvsjHUjNtEDudZfuDQUoWXVxKHhlEGSk81n4YFS+r/Kl99wXiwlVXtPBtJenozv2P+hxDsw9eA7Xo6g==",
"dependencies": {
"loose-envify": "^1.1.0",
"scheduler": "^0.23.0"
},
"peerDependencies": {
"react": "^18.2.0"
}
},
"node_modules/react-is": {
"version": "16.13.1",
"resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz",
"integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ=="
},
"node_modules/read-cache": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz",
"integrity": "sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==",
"dependencies": {
"pify": "^2.3.0"
}
},
"node_modules/readdirp": {
"version": "3.6.0",
"resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
"integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
"dependencies": {
"picomatch": "^2.2.1"
},
"engines": {
"node": ">=8.10.0"
}
},
"node_modules/regenerator-runtime": {
"version": "0.13.11",
"resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.13.11.tgz",
"integrity": "sha512-kY1AZVr2Ra+t+piVaJ4gxaFaReZVH40AKNo7UCX6W+dEwBo/2oZJzqfuN1qLq1oL45o56cPaTXELwrTh8Fpggg=="
},
"node_modules/regexp.prototype.flags": {
"version": "1.4.3",
"resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.4.3.tgz",
"integrity": "sha512-fjggEOO3slI6Wvgjwflkc4NFRCTZAu5CnNfBd5qOMYhWdn67nJBBu34/TkD++eeFmd8C9r9jfXJ27+nSiRkSUA==",
"dependencies": {
"call-bind": "^1.0.2",
"define-properties": "^1.1.3",
"functions-have-names": "^1.2.2"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/remark": {
"version": "14.0.2",
"resolved": "https://registry.npmjs.org/remark/-/remark-14.0.2.tgz",
"integrity": "sha512-A3ARm2V4BgiRXaUo5K0dRvJ1lbogrbXnhkJRmD0yw092/Yl0kOCZt1k9ZeElEwkZsWGsMumz6qL5MfNJH9nOBA==",
"dependencies": {
"@types/mdast": "^3.0.0",
"remark-parse": "^10.0.0",
"remark-stringify": "^10.0.0",
"unified": "^10.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/remark-html": {
"version": "15.0.2",
"resolved": "https://registry.npmjs.org/remark-html/-/remark-html-15.0.2.tgz",
"integrity": "sha512-/CIOI7wzHJzsh48AiuIyIe1clxVkUtreul73zcCXLub0FmnevQE0UMFDQm7NUx8/3rl/4zCshlMfqBdWScQthw==",
"dependencies": {
"@types/mdast": "^3.0.0",
"hast-util-sanitize": "^4.0.0",
"hast-util-to-html": "^8.0.0",
"mdast-util-to-hast": "^12.0.0",
"unified": "^10.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/remark-parse": {
"version": "10.0.1",
"resolved": "https://registry.npmjs.org/remark-parse/-/remark-parse-10.0.1.tgz",
"integrity": "sha512-1fUyHr2jLsVOkhbvPRBJ5zTKZZyD6yZzYaWCS6BPBdQ8vEMBCH+9zNCDA6tET/zHCi/jLqjCWtlJZUPk+DbnFw==",
"dependencies": {
"@types/mdast": "^3.0.0",
"mdast-util-from-markdown": "^1.0.0",
"unified": "^10.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/remark-stringify": {
"version": "10.0.2",
"resolved": "https://registry.npmjs.org/remark-stringify/-/remark-stringify-10.0.2.tgz",
"integrity": "sha512-6wV3pvbPvHkbNnWB0wdDvVFHOe1hBRAx1Q/5g/EpH4RppAII6J8Gnwe7VbHuXaoKIF6LAg6ExTel/+kNqSQ7lw==",
"dependencies": {
"@types/mdast": "^3.0.0",
"mdast-util-to-markdown": "^1.0.0",
"unified": "^10.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/resolve": {
"version": "1.22.1",
"resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.1.tgz",
"integrity": "sha512-nBpuuYuY5jFsli/JIs1oldw6fOQCBioohqWZg/2hiaOybXOft4lonv85uDOKXdf8rhyK159cxU5cDcK/NKk8zw==",
"dependencies": {
"is-core-module": "^2.9.0",
"path-parse": "^1.0.7",
"supports-preserve-symlinks-flag": "^1.0.0"
},
"bin": {
"resolve": "bin/resolve"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/resolve-from": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
"integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
"engines": {
"node": ">=4"
}
},
"node_modules/reusify": {
"version": "1.0.4",
"resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz",
"integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==",
"engines": {
"iojs": ">=1.0.0",
"node": ">=0.10.0"
}
},
"node_modules/rimraf": {
"version": "3.0.2",
"resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz",
"integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==",
"dependencies": {
"glob": "^7.1.3"
},
"bin": {
"rimraf": "bin.js"
},
"funding": {
"url": "https://github.com/sponsors/isaacs"
}
},
"node_modules/run-parallel": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
"integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
"funding": [
{
"type": "github",
"url": "https://github.com/sponsors/feross"
},
{
"type": "patreon",
"url": "https://www.patreon.com/feross"
},
{
"type": "consulting",
"url": "https://feross.org/support"
}
],
"dependencies": {
"queue-microtask": "^1.2.2"
}
},
"node_modules/sade": {
"version": "1.8.1",
"resolved": "https://registry.npmjs.org/sade/-/sade-1.8.1.tgz",
"integrity": "sha512-xal3CZX1Xlo/k4ApwCFrHVACi9fBqJ7V+mwhBsuf/1IOKbBy098Fex+Wa/5QMubw09pSZ/u8EY8PWgevJsXp1A==",
"dependencies": {
"mri": "^1.1.0"
},
"engines": {
"node": ">=6"
}
},
"node_modules/safe-regex-test": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.0.0.tgz",
"integrity": "sha512-JBUUzyOgEwXQY1NuPtvcj/qcBDbDmEvWufhlnXZIm75DEHp+afM1r1ujJpJsV/gSM4t59tpDyPi1sd6ZaPFfsA==",
"dependencies": {
"call-bind": "^1.0.2",
"get-intrinsic": "^1.1.3",
"is-regex": "^1.1.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/scheduler": {
"version": "0.23.0",
"resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.0.tgz",
"integrity": "sha512-CtuThmgHNg7zIZWAXi3AsyIzA3n4xx7aNyjwC2VJldO2LMVDhFK+63xGqq6CsJH4rTAt6/M+N4GhZiDYPx9eUw==",
"dependencies": {
"loose-envify": "^1.1.0"
}
},
"node_modules/section-matter": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/section-matter/-/section-matter-1.0.0.tgz",
"integrity": "sha512-vfD3pmTzGpufjScBh50YHKzEu2lxBWhVEHsNGoEXmCmn2hKGfeNLYMzCJpe8cD7gqX7TJluOVpBkAequ6dgMmA==",
"dependencies": {
"extend-shallow": "^2.0.1",
"kind-of": "^6.0.0"
},
"engines": {
"node": ">=4"
}
},
"node_modules/semver": {
"version": "7.3.8",
"resolved": "https://registry.npmjs.org/semver/-/semver-7.3.8.tgz",
"integrity": "sha512-NB1ctGL5rlHrPJtFDVIVzTyQylMLu9N9VICA6HSFJo8MCGVTMW6gfpicwKmmK/dAjTOrqu5l63JJOpDSrAis3A==",
"dependencies": {
"lru-cache": "^6.0.0"
},
"bin": {
"semver": "bin/semver.js"
},
"engines": {
"node": ">=10"
}
},
"node_modules/shebang-command": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
"integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
"dependencies": {
"shebang-regex": "^3.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/shebang-regex": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
"integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
"engines": {
"node": ">=8"
}
},
"node_modules/side-channel": {
"version": "1.0.4",
"resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz",
"integrity": "sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==",
"dependencies": {
"call-bind": "^1.0.0",
"get-intrinsic": "^1.0.2",
"object-inspect": "^1.9.0"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/simple-swizzle": {
"version": "0.2.2",
"resolved": "https://registry.npmjs.org/simple-swizzle/-/simple-swizzle-0.2.2.tgz",
"integrity": "sha512-JA//kQgZtbuY83m+xT+tXJkmJncGMTFT+C+g2h2R9uxkYIrE2yy9sgmcLhCnw57/WSD+Eh3J97FPEDFnbXnDUg==",
"dependencies": {
"is-arrayish": "^0.3.1"
}
},
"node_modules/slash": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz",
"integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==",
"engines": {
"node": ">=8"
}
},
"node_modules/source-map-js": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.0.2.tgz",
"integrity": "sha512-R0XvVJ9WusLiqTCEiGCmICCMplcCkIwwR11mOSD9CR5u+IXYdiseeEuXCVAjS54zqwkLcPNnmU4OeJ6tUrWhDw==",
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/space-separated-tokens": {
"version": "2.0.2",
"resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz",
"integrity": "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==",
"funding": {
"type": "github",
"url": "https://github.com/sponsors/wooorm"
}
},
"node_modules/sprintf-js": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz",
"integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g=="
},
"node_modules/stop-iteration-iterator": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/stop-iteration-iterator/-/stop-iteration-iterator-1.0.0.tgz",
"integrity": "sha512-iCGQj+0l0HOdZ2AEeBADlsRC+vsnDsZsbdSiH1yNSjcfKM7fdpCMfqAL/dwF5BLiw/XhRft/Wax6zQbhq2BcjQ==",
"dependencies": {
"internal-slot": "^1.0.4"
},
"engines": {
"node": ">= 0.4"
}
},
"node_modules/string.prototype.matchall": {
"version": "4.0.8",
"resolved": "https://registry.npmjs.org/string.prototype.matchall/-/string.prototype.matchall-4.0.8.tgz",
"integrity": "sha512-6zOCOcJ+RJAQshcTvXPHoxoQGONa3e/Lqx90wUA+wEzX78sg5Bo+1tQo4N0pohS0erG9qtCqJDjNCQBjeWVxyg==",
"dependencies": {
"call-bind": "^1.0.2",
"define-properties": "^1.1.4",
"es-abstract": "^1.20.4",
"get-intrinsic": "^1.1.3",
"has-symbols": "^1.0.3",
"internal-slot": "^1.0.3",
"regexp.prototype.flags": "^1.4.3",
"side-channel": "^1.0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/string.prototype.trim": {
"version": "1.2.7",
"resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.7.tgz",
"integrity": "sha512-p6TmeT1T3411M8Cgg9wBTMRtY2q9+PNy9EV1i2lIXUN/btt763oIfxwN3RR8VU6wHX8j/1CFy0L+YuThm6bgOg==",
"dependencies": {
"call-bind": "^1.0.2",
"define-properties": "^1.1.4",
"es-abstract": "^1.20.4"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/string.prototype.trimend": {
"version": "1.0.6",
"resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.6.tgz",
"integrity": "sha512-JySq+4mrPf9EsDBEDYMOb/lM7XQLulwg5R/m1r0PXEFqrV0qHvl58sdTilSXtKOflCsK2E8jxf+GKC0T07RWwQ==",
"dependencies": {
"call-bind": "^1.0.2",
"define-properties": "^1.1.4",
"es-abstract": "^1.20.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/string.prototype.trimstart": {
"version": "1.0.6",
"resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.6.tgz",
"integrity": "sha512-omqjMDaY92pbn5HOX7f9IccLA+U1tA9GvtU4JrodiXFfYB7jPzzHpRzpglLAjtUV6bB557zwClJezTqnAiYnQA==",
"dependencies": {
"call-bind": "^1.0.2",
"define-properties": "^1.1.4",
"es-abstract": "^1.20.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/stringify-entities": {
"version": "4.0.3",
"resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-4.0.3.tgz",
"integrity": "sha512-BP9nNHMhhfcMbiuQKCqMjhDP5yBCAxsPu4pHFFzJ6Alo9dZgY4VLDPutXqIjpRiMoKdp7Av85Gr73Q5uH9k7+g==",
"dependencies": {
"character-entities-html4": "^2.0.0",
"character-entities-legacy": "^3.0.0"
},
"funding": {
"type": "github",
"url": "https://github.com/sponsors/wooorm"
}
},
"node_modules/strip-ansi": {
"version": "6.0.1",
"resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
"integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
"dependencies": {
"ansi-regex": "^5.0.1"
},
"engines": {
"node": ">=8"
}
},
"node_modules/strip-bom": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz",
"integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==",
"engines": {
"node": ">=4"
}
},
"node_modules/strip-bom-string": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/strip-bom-string/-/strip-bom-string-1.0.0.tgz",
"integrity": "sha512-uCC2VHvQRYu+lMh4My/sFNmF2klFymLX1wHJeXnbEJERpV/ZsVuonzerjfrGpIGF7LBVa1O7i9kjiWvJiFck8g==",
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/strip-json-comments": {
"version": "3.1.1",
"resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
"integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/styled-jsx": {
"version": "5.1.1",
"resolved": "https://registry.npmjs.org/styled-jsx/-/styled-jsx-5.1.1.tgz",
"integrity": "sha512-pW7uC1l4mBZ8ugbiZrcIsiIvVx1UmTfw7UkC3Um2tmfUq9Bhk8IiyEIPl6F8agHgjzku6j0xQEZbfA5uSgSaCw==",
"dependencies": {
"client-only": "0.0.1"
},
"engines": {
"node": ">= 12.0.0"
},
"peerDependencies": {
"react": ">= 16.8.0 || 17.x.x || ^18.0.0-0"
},
"peerDependenciesMeta": {
"@babel/core": {
"optional": true
},
"babel-plugin-macros": {
"optional": true
}
}
},
"node_modules/sucrase": {
"version": "3.31.0",
"resolved": "https://registry.npmjs.org/sucrase/-/sucrase-3.31.0.tgz",
"integrity": "sha512-6QsHnkqyVEzYcaiHsOKkzOtOgdJcb8i54x6AV2hDwyZcY9ZyykGZVw6L/YN98xC0evwTP6utsWWrKRaa8QlfEQ==",
"dependencies": {
"commander": "^4.0.0",
"glob": "7.1.6",
"lines-and-columns": "^1.1.6",
"mz": "^2.7.0",
"pirates": "^4.0.1",
"ts-interface-checker": "^0.1.9"
},
"bin": {
"sucrase": "bin/sucrase",
"sucrase-node": "bin/sucrase-node"
},
"engines": {
"node": ">=8"
}
},
"node_modules/sucrase/node_modules/glob": {
"version": "7.1.6",
"resolved": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz",
"integrity": "sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==",
"dependencies": {
"fs.realpath": "^1.0.0",
"inflight": "^1.0.4",
"inherits": "2",
"minimatch": "^3.0.4",
"once": "^1.3.0",
"path-is-absolute": "^1.0.0"
},
"engines": {
"node": "*"
},
"funding": {
"url": "https://github.com/sponsors/isaacs"
}
},
"node_modules/supports-color": {
"version": "7.2.0",
"resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
"integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
"dependencies": {
"has-flag": "^4.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/supports-preserve-symlinks-flag": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
"integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==",
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/synckit": {
"version": "0.8.5",
"resolved": "https://registry.npmjs.org/synckit/-/synckit-0.8.5.tgz",
"integrity": "sha512-L1dapNV6vu2s/4Sputv8xGsCdAVlb5nRDMFU/E27D44l5U6cw1g0dGd45uLc+OXjNMmF4ntiMdCimzcjFKQI8Q==",
"dependencies": {
"@pkgr/utils": "^2.3.1",
"tslib": "^2.5.0"
},
"engines": {
"node": "^14.18.0 || >=16.0.0"
},
"funding": {
"url": "https://opencollective.com/unts"
}
},
"node_modules/tailwindcss": {
"version": "3.3.1",
"resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.3.1.tgz",
"integrity": "sha512-Vkiouc41d4CEq0ujXl6oiGFQ7bA3WEhUZdTgXAhtKxSy49OmKs8rEfQmupsfF0IGW8fv2iQkp1EVUuapCFrZ9g==",
"dependencies": {
"arg": "^5.0.2",
"chokidar": "^3.5.3",
"color-name": "^1.1.4",
"didyoumean": "^1.2.2",
"dlv": "^1.1.3",
"fast-glob": "^3.2.12",
"glob-parent": "^6.0.2",
"is-glob": "^4.0.3",
"jiti": "^1.17.2",
"lilconfig": "^2.0.6",
"micromatch": "^4.0.5",
"normalize-path": "^3.0.0",
"object-hash": "^3.0.0",
"picocolors": "^1.0.0",
"postcss": "^8.0.9",
"postcss-import": "^14.1.0",
"postcss-js": "^4.0.0",
"postcss-load-config": "^3.1.4",
"postcss-nested": "6.0.0",
"postcss-selector-parser": "^6.0.11",
"postcss-value-parser": "^4.2.0",
"quick-lru": "^5.1.1",
"resolve": "^1.22.1",
"sucrase": "^3.29.0"
},
"bin": {
"tailwind": "lib/cli.js",
"tailwindcss": "lib/cli.js"
},
"engines": {
"node": ">=12.13.0"
},
"peerDependencies": {
"postcss": "^8.0.9"
}
},
"node_modules/tailwindcss/node_modules/postcss-load-config": {
"version": "3.1.4",
"resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-3.1.4.tgz",
"integrity": "sha512-6DiM4E7v4coTE4uzA8U//WhtPwyhiim3eyjEMFCnUpzbrkK9wJHgKDT2mR+HbtSrd/NubVaYTOpSpjUl8NQeRg==",
"dependencies": {
"lilconfig": "^2.0.5",
"yaml": "^1.10.2"
},
"engines": {
"node": ">= 10"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/postcss/"
},
"peerDependencies": {
"postcss": ">=8.0.9",
"ts-node": ">=9.0.0"
},
"peerDependenciesMeta": {
"postcss": {
"optional": true
},
"ts-node": {
"optional": true
}
}
},
"node_modules/tailwindcss/node_modules/postcss-selector-parser": {
"version": "6.0.11",
"resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.0.11.tgz",
"integrity": "sha512-zbARubNdogI9j7WY4nQJBiNqQf3sLS3wCP4WfOidu+p28LofJqDH1tcXypGrcmMHhDk2t9wGhCsYe/+szLTy1g==",
"dependencies": {
"cssesc": "^3.0.0",
"util-deprecate": "^1.0.2"
},
"engines": {
"node": ">=4"
}
},
"node_modules/tapable": {
"version": "2.2.1",
"resolved": "https://registry.npmjs.org/tapable/-/tapable-2.2.1.tgz",
"integrity": "sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==",
"engines": {
"node": ">=6"
}
},
"node_modules/text-table": {
"version": "0.2.0",
"resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz",
"integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw=="
},
"node_modules/thenify": {
"version": "3.3.1",
"resolved": "https://registry.npmjs.org/thenify/-/thenify-3.3.1.tgz",
"integrity": "sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==",
"dependencies": {
"any-promise": "^1.0.0"
}
},
"node_modules/thenify-all": {
"version": "1.6.0",
"resolved": "https://registry.npmjs.org/thenify-all/-/thenify-all-1.6.0.tgz",
"integrity": "sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==",
"dependencies": {
"thenify": ">= 3.1.0 < 4"
},
"engines": {
"node": ">=0.8"
}
},
"node_modules/tiny-glob": {
"version": "0.2.9",
"resolved": "https://registry.npmjs.org/tiny-glob/-/tiny-glob-0.2.9.tgz",
"integrity": "sha512-g/55ssRPUjShh+xkfx9UPDXqhckHEsHr4Vd9zX55oSdGZc/MD0m3sferOkwWtp98bv+kcVfEHtRJgBVJzelrzg==",
"dependencies": {
"globalyzer": "0.1.0",
"globrex": "^0.1.2"
}
},
"node_modules/to-regex-range": {
"version": "5.0.1",
"resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
"integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
"dependencies": {
"is-number": "^7.0.0"
},
"engines": {
"node": ">=8.0"
}
},
"node_modules/trim-lines": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/trim-lines/-/trim-lines-3.0.1.tgz",
"integrity": "sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==",
"funding": {
"type": "github",
"url": "https://github.com/sponsors/wooorm"
}
},
"node_modules/trough": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/trough/-/trough-2.1.0.tgz",
"integrity": "sha512-AqTiAOLcj85xS7vQ8QkAV41hPDIJ71XJB4RCUrzo/1GM2CQwhkJGaf9Hgr7BOugMRpgGUrqRg/DrBDl4H40+8g==",
"funding": {
"type": "github",
"url": "https://github.com/sponsors/wooorm"
}
},
"node_modules/ts-interface-checker": {
"version": "0.1.13",
"resolved": "https://registry.npmjs.org/ts-interface-checker/-/ts-interface-checker-0.1.13.tgz",
"integrity": "sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA=="
},
"node_modules/tsconfig-paths": {
"version": "3.14.2",
"resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-3.14.2.tgz",
"integrity": "sha512-o/9iXgCYc5L/JxCHPe3Hvh8Q/2xm5Z+p18PESBU6Ff33695QnCHBEjcytY2q19ua7Mbl/DavtBOLq+oG0RCL+g==",
"dependencies": {
"@types/json5": "^0.0.29",
"json5": "^1.0.2",
"minimist": "^1.2.6",
"strip-bom": "^3.0.0"
}
},
"node_modules/tslib": {
"version": "2.5.0",
"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.5.0.tgz",
"integrity": "sha512-336iVw3rtn2BUK7ORdIAHTyxHGRIHVReokCR3XjbckJMK7ms8FysBfhLR8IXnAgy7T0PTPNBWKiH514FOW/WSg=="
},
"node_modules/tsutils": {
"version": "3.21.0",
"resolved": "https://registry.npmjs.org/tsutils/-/tsutils-3.21.0.tgz",
"integrity": "sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==",
"dependencies": {
"tslib": "^1.8.1"
},
"engines": {
"node": ">= 6"
},
"peerDependencies": {
"typescript": ">=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta"
}
},
"node_modules/tsutils/node_modules/tslib": {
"version": "1.14.1",
"resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz",
"integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg=="
},
"node_modules/type-check": {
"version": "0.4.0",
"resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
"integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
"dependencies": {
"prelude-ls": "^1.2.1"
},
"engines": {
"node": ">= 0.8.0"
}
},
"node_modules/type-fest": {
"version": "0.20.2",
"resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz",
"integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==",
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/typed-array-length": {
"version": "1.0.4",
"resolved": "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.4.tgz",
"integrity": "sha512-KjZypGq+I/H7HI5HlOoGHkWUUGq+Q0TPhQurLbyrVrvnKTBgzLhIJ7j6J/XTQOi0d1RjyZ0wdas8bKs2p0x3Ng==",
"dependencies": {
"call-bind": "^1.0.2",
"for-each": "^0.3.3",
"is-typed-array": "^1.1.9"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/typescript": {
"version": "5.0.3",
"resolved": "https://registry.npmjs.org/typescript/-/typescript-5.0.3.tgz",
"integrity": "sha512-xv8mOEDnigb/tN9PSMTwSEqAnUvkoXMQlicOb0IUVDBSQCgBSaAAROUZYy2IcUy5qU6XajK5jjjO7TMWqBTKZA==",
"bin": {
"tsc": "bin/tsc",
"tsserver": "bin/tsserver"
},
"engines": {
"node": ">=12.20"
}
},
"node_modules/unbox-primitive": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.2.tgz",
"integrity": "sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==",
"dependencies": {
"call-bind": "^1.0.2",
"has-bigints": "^1.0.2",
"has-symbols": "^1.0.3",
"which-boxed-primitive": "^1.0.2"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/unified": {
"version": "10.1.2",
"resolved": "https://registry.npmjs.org/unified/-/unified-10.1.2.tgz",
"integrity": "sha512-pUSWAi/RAnVy1Pif2kAoeWNBa3JVrx0MId2LASj8G+7AiHWoKZNTomq6LG326T68U7/e263X6fTdcXIy7XnF7Q==",
"dependencies": {
"@types/unist": "^2.0.0",
"bail": "^2.0.0",
"extend": "^3.0.0",
"is-buffer": "^2.0.0",
"is-plain-obj": "^4.0.0",
"trough": "^2.0.0",
"vfile": "^5.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/unist-util-generated": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/unist-util-generated/-/unist-util-generated-2.0.1.tgz",
"integrity": "sha512-qF72kLmPxAw0oN2fwpWIqbXAVyEqUzDHMsbtPvOudIlUzXYFIeQIuxXQCRCFh22B7cixvU0MG7m3MW8FTq/S+A==",
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/unist-util-is": {
"version": "5.2.1",
"resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.2.1.tgz",
"integrity": "sha512-u9njyyfEh43npf1M+yGKDGVPbY/JWEemg5nH05ncKPfi+kBbKBJoTdsogMu33uhytuLlv9y0O7GH7fEdwLdLQw==",
"dependencies": {
"@types/unist": "^2.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/unist-util-position": {
"version": "4.0.4",
"resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.4.tgz",
"integrity": "sha512-kUBE91efOWfIVBo8xzh/uZQ7p9ffYRtUbMRZBNFYwf0RK8koUMx6dGUfwylLOKmaT2cs4wSW96QoYUSXAyEtpg==",
"dependencies": {
"@types/unist": "^2.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/unist-util-stringify-position": {
"version": "3.0.3",
"resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-3.0.3.tgz",
"integrity": "sha512-k5GzIBZ/QatR8N5X2y+drfpWG8IDBzdnVj6OInRNWm1oXrzydiaAT2OQiA8DPRRZyAKb9b6I2a6PxYklZD0gKg==",
"dependencies": {
"@types/unist": "^2.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/unist-util-visit": {
"version": "4.1.2",
"resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.1.2.tgz",
"integrity": "sha512-MSd8OUGISqHdVvfY9TPhyK2VdUrPgxkUtWSuMHF6XAAFuL4LokseigBnZtPnJMu+FbynTkFNnFlyjxpVKujMRg==",
"dependencies": {
"@types/unist": "^2.0.0",
"unist-util-is": "^5.0.0",
"unist-util-visit-parents": "^5.1.1"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/unist-util-visit-parents": {
"version": "5.1.3",
"resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.1.3.tgz",
"integrity": "sha512-x6+y8g7wWMyQhL1iZfhIPhDAs7Xwbn9nRosDXl7qoPTSCy0yNxnKc+hWokFifWQIDGi154rdUqKvbCa4+1kLhg==",
"dependencies": {
"@types/unist": "^2.0.0",
"unist-util-is": "^5.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/update-browserslist-db": {
"version": "1.0.10",
"resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.10.tgz",
"integrity": "sha512-OztqDenkfFkbSG+tRxBeAnCVPckDBcvibKd35yDONx6OU8N7sqgwc7rCbkJ/WcYtVRZ4ba68d6byhC21GFh7sQ==",
"dev": true,
"funding": [
{
"type": "opencollective",
"url": "https://opencollective.com/browserslist"
},
{
"type": "tidelift",
"url": "https://tidelift.com/funding/github/npm/browserslist"
}
],
"dependencies": {
"escalade": "^3.1.1",
"picocolors": "^1.0.0"
},
"bin": {
"browserslist-lint": "cli.js"
},
"peerDependencies": {
"browserslist": ">= 4.21.0"
}
},
"node_modules/uri-js": {
"version": "4.4.1",
"resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
"integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
"dependencies": {
"punycode": "^2.1.0"
}
},
"node_modules/util-deprecate": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
"integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="
},
"node_modules/uvu": {
"version": "0.5.6",
"resolved": "https://registry.npmjs.org/uvu/-/uvu-0.5.6.tgz",
"integrity": "sha512-+g8ENReyr8YsOc6fv/NVJs2vFdHBnBNdfE49rshrTzDWOlUx4Gq7KOS2GD8eqhy2j+Ejq29+SbKH8yjkAqXqoA==",
"dependencies": {
"dequal": "^2.0.0",
"diff": "^5.0.0",
"kleur": "^4.0.3",
"sade": "^1.7.3"
},
"bin": {
"uvu": "bin.js"
},
"engines": {
"node": ">=8"
}
},
"node_modules/vfile": {
"version": "5.3.7",
"resolved": "https://registry.npmjs.org/vfile/-/vfile-5.3.7.tgz",
"integrity": "sha512-r7qlzkgErKjobAmyNIkkSpizsFPYiUPuJb5pNW1RB4JcYVZhs4lIbVqk8XPk033CV/1z8ss5pkax8SuhGpcG8g==",
"dependencies": {
"@types/unist": "^2.0.0",
"is-buffer": "^2.0.0",
"unist-util-stringify-position": "^3.0.0",
"vfile-message": "^3.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/vfile-location": {
"version": "4.1.0",
"resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-4.1.0.tgz",
"integrity": "sha512-YF23YMyASIIJXpktBa4vIGLJ5Gs88UB/XePgqPmTa7cDA+JeO3yclbpheQYCHjVHBn/yePzrXuygIL+xbvRYHw==",
"dependencies": {
"@types/unist": "^2.0.0",
"vfile": "^5.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/vfile-message": {
"version": "3.1.4",
"resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-3.1.4.tgz",
"integrity": "sha512-fa0Z6P8HUrQN4BZaX05SIVXic+7kE3b05PWAtPuYP9QLHsLKYR7/AlLW3NtOrpXRLeawpDLMsVkmk5DG0NXgWw==",
"dependencies": {
"@types/unist": "^2.0.0",
"unist-util-stringify-position": "^3.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/web-namespaces": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/web-namespaces/-/web-namespaces-2.0.1.tgz",
"integrity": "sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ==",
"funding": {
"type": "github",
"url": "https://github.com/sponsors/wooorm"
}
},
"node_modules/which": {
"version": "2.0.2",
"resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
"integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
"dependencies": {
"isexe": "^2.0.0"
},
"bin": {
"node-which": "bin/node-which"
},
"engines": {
"node": ">= 8"
}
},
"node_modules/which-boxed-primitive": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz",
"integrity": "sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==",
"dependencies": {
"is-bigint": "^1.0.1",
"is-boolean-object": "^1.1.0",
"is-number-object": "^1.0.4",
"is-string": "^1.0.5",
"is-symbol": "^1.0.3"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/which-collection": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/which-collection/-/which-collection-1.0.1.tgz",
"integrity": "sha512-W8xeTUwaln8i3K/cY1nGXzdnVZlidBcagyNFtBdD5kxnb4TvGKR7FfSIS3mYpwWS1QUCutfKz8IY8RjftB0+1A==",
"dependencies": {
"is-map": "^2.0.1",
"is-set": "^2.0.1",
"is-weakmap": "^2.0.1",
"is-weakset": "^2.0.1"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/which-typed-array": {
"version": "1.1.9",
"resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.9.tgz",
"integrity": "sha512-w9c4xkx6mPidwp7180ckYWfMmvxpjlZuIudNtDf4N/tTAUB8VJbX25qZoAsrtGuYNnGw3pa0AXgbGKRB8/EceA==",
"dependencies": {
"available-typed-arrays": "^1.0.5",
"call-bind": "^1.0.2",
"for-each": "^0.3.3",
"gopd": "^1.0.1",
"has-tostringtag": "^1.0.0",
"is-typed-array": "^1.1.10"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/word-wrap": {
"version": "1.2.3",
"resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.3.tgz",
"integrity": "sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==",
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/wrappy": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
"integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="
},
"node_modules/yallist": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
"integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="
},
"node_modules/yaml": {
"version": "1.10.2",
"resolved": "https://registry.npmjs.org/yaml/-/yaml-1.10.2.tgz",
"integrity": "sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==",
"engines": {
"node": ">= 6"
}
},
"node_modules/yocto-queue": {
"version": "0.1.0",
"resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
"integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/zwitch": {
"version": "2.0.4",
"resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz",
"integrity": "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==",
"funding": {
"type": "github",
"url": "https://github.com/sponsors/wooorm"
}
}
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus
|
solana_public_repos/nautilus-project/nautilus/docs/package.json
|
{
"name": "docs",
"version": "0.1.0",
"private": true,
"scripts": {
"dev": "next dev",
"build": "next build",
"start": "next start",
"lint": "next lint"
},
"dependencies": {
"@tailwindcss/typography": "^0.5.9",
"@types/node": "18.15.11",
"@types/react": "18.0.32",
"@types/react-dom": "18.0.11",
"daisyui": "^2.51.5",
"eslint": "8.37.0",
"eslint-config-next": "13.2.4",
"gray-matter": "^4.0.3",
"next": "13.2.4",
"react": "18.2.0",
"react-dom": "18.2.0",
"remark": "^14.0.2",
"remark-html": "^15.0.2",
"typescript": "5.0.3"
},
"devDependencies": {
"autoprefixer": "^10.4.14",
"postcss": "^8.4.21",
"tailwindcss": "^3.3.1"
}
}
| 0
|
solana_public_repos/nautilus-project/nautilus
|
solana_public_repos/nautilus-project/nautilus/docs/tsconfig.json
|
{
"compilerOptions": {
"target": "es5",
"lib": ["dom", "dom.iterable", "esnext"],
"allowJs": true,
"skipLibCheck": true,
"strict": true,
"forceConsistentCasingInFileNames": true,
"noEmit": true,
"esModuleInterop": true,
"module": "esnext",
"moduleResolution": "node",
"resolveJsonModule": true,
"isolatedModules": true,
"jsx": "preserve",
"incremental": true,
"paths": {
"@/*": ["./src/*"]
}
},
"include": ["next-env.d.ts", "**/*.ts", "**/*.tsx"],
"exclude": ["node_modules"]
}
| 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.