@xyo-network/payload-model 3.6.0-rc.4 → 3.6.0-rc.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/payload-model",
-  "version": "3.6.0-rc.4",
+  "version": "3.6.0-rc.6",
   "description": "Primary SDK for using XYO Protocol 2.0",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -37,13 +37,15 @@
   "module": "dist/neutral/index.mjs",
   "types": "dist/neutral/index.d.ts",
   "dependencies": {
-    "@xylabs/hex": "^4.4.13",
-    "@xylabs/object": "^4.4.13"
+    "@xylabs/arraybuffer": "^4.4.15",
+    "@xylabs/assert": "^4.4.15",
+    "@xylabs/hex": "^4.4.15",
+    "@xylabs/object": "^4.4.15"
   },
   "devDependencies": {
     "@xylabs/ts-scripts-yarn3": "^4.2.4",
     "@xylabs/tsconfig": "^4.2.4",
-    "@xylabs/vitest-extended": "^4.4.13",
+    "@xylabs/vitest-extended": "^4.4.15",
     "typescript": "^5.7.2",
     "vitest": "^2.1.8"
   },

package/src/Payload.ts

@@ -3,33 +3,65 @@ import type { EmptyObject } from '@xylabs/object'
 
 import type { Schema, WithSchema } from './Schema.ts'
 
-/** Additional fields for a payload */
-export interface PayloadFields extends EmptyObject {
-  schema: Schema
+export interface SchemaField<T extends Schema = Schema> {
+  schema: T
 }
 
-export type WithPayload<T extends EmptyObject | void = void> = WithSchema<T extends EmptyObject ? PayloadFields & T : PayloadFields>
+/** Additional fields for a payload */
+export interface PayloadFields extends SchemaField {}
+
+export type WithPayload<T extends EmptyObject | void = void> =
+  DeepRestrictToStringKeys<WithoutMeta<WithSchema<T extends EmptyObject ? PayloadFields & T : PayloadFields>>>
 
 /** Base Type for Payloads */
 export type Payload<T extends void | EmptyObject | WithSchema = void, S extends Schema | void = void> =
   T extends WithSchema ?
     S extends Schema ?
       /* T (w/Schema) & S provided */
-      WithPayload<Omit<T, 'schema'> & { schema: S } & PayloadFields>
+      WithPayload<Omit<T, 'schema'> & { schema: S }>
       : /* Only T (w/Schema) provided */ WithPayload<T>
     : T extends object ?
       S extends Schema ?
       /* T (w/o Schema) & S provided */
-        WithPayload<T & { schema: S } & PayloadFields>
-        : /* Only T (w/o Schema) provided */ WithPayload<T & { schema: Schema } & PayloadFields>
+        WithPayload<T & { schema: S }>
+        : /* Only T (w/o Schema) provided */ WithPayload<T & PayloadFields>
       : /* Either just S or neither S or T provided */
-        {
-          schema: S extends Schema ? S : Schema
-        } & PayloadFields
+      WithPayload<{
+        schema: S extends Schema ? S : Schema
+      }>
 
-export type OverridablePayload<T extends Payload> = Omit<T, 'schema'> & { schema: string }
+export type OverridablePayload<T extends Payload> = WithoutMeta<Omit<T, 'schema'> & PayloadFields>
 
 export type WithSources<T extends EmptyObject> = T & { sources?: Hash[] }
 export type PayloadWithSources<T extends void | EmptyObject | WithSchema = void, S extends Schema | void = void> = WithSources<Payload<T, S>>
 
-export type WithAnySchema<T extends Payload> = Omit<T, 'schema'> & { schema: string }
+export type WithAnySchema<T extends Payload> = OverridablePayload<T>
+
+export type DeepOmitStartsWith<T, Prefix extends string> = T extends (infer U)[]
+  ? DeepOmitStartsWith<U, Prefix>[] // Special handling for arrays
+  : T extends object
+    ? {
+        [K in keyof T as K extends string
+          ? K extends `${Prefix}${string}`
+            ? never
+            : K
+          : K]: DeepOmitStartsWith<T[K], Prefix>;
+      }
+    : T
+
+export type DeepRestrictToStringKeys<T> = {
+  [K in keyof T as K extends string ? K : never]: T[K] extends (infer U)[]
+    ? DeepRestrictToStringKeys<U>[] // Handle arrays recursively
+    : T[K] extends object
+      ? DeepRestrictToStringKeys<T[K]> // Handle objects recursively
+      : T[K]; // Leave other types untouched
+}
+
+export type WithoutClientMeta<T extends EmptyObject> = DeepOmitStartsWith<T, '$'>
+export type WithoutStorageMeta<T extends EmptyObject> = DeepOmitStartsWith<T, '_'>
+export type WithoutPrivateStorageMeta<T extends EmptyObject> = DeepOmitStartsWith<T, '__'>
+export type WithoutMeta<T extends EmptyObject> = WithoutClientMeta<WithoutStorageMeta<T>>
+
+export type WithoutSchema<T extends WithOptionalSchema<Payload>> = Omit<T, 'schema'>
+
+export type WithOptionalSchema<T extends EmptyObject = EmptyObject> = WithoutSchema<T> & Partial<T & SchemaField>

package/src/Query.ts

@@ -22,7 +22,7 @@ export type Query<T extends void | EmptyObject | WithSchema = void, S extends Sc
   T extends void ? QueryFields : T & QueryFields,
   S extends void ?
     T extends WithSchema ? T['schema']
-      : T extends void ? string
+      : T extends void ? Schema
         : void
     : S
 >

package/src/StorageMeta/Sequence.ts

@@ -0,0 +1,72 @@
+import type { Address, Hex } from '@xylabs/hex'
+import { isHex } from '@xylabs/hex'
+
+// we use Exclude to intentionally make the type not equal to string
+export type LocalSequence = Hex & Exclude<string, 'reserved-local-sequence-value'>
+export type QualifiedSequence = Hex & Exclude<string, 'reserved-qualified-sequence-value'>
+export type Sequence = LocalSequence | QualifiedSequence
+
+export type Epoch = Hex & Exclude<string, 'reserved-epoch-sequence-value'>
+
+export const isEpoch = (value: unknown): value is Epoch => {
+  return isHex(value) && (value as string).length === SequenceConstants.epochBytes * 2
+}
+
+export type Nonce = Hex & Exclude<string, 'reserved-nonce-sequence-value'>
+
+export const isNonce = (value: unknown): value is Epoch => {
+  return isHex(value) && (value as string).length === SequenceConstants.nonceBytes * 2
+}
+
+export const isLocalSequence = (value: unknown): value is Sequence => {
+  return isHex(value) && (value as string).length === SequenceConstants.localSequenceBytes * 2
+}
+
+export const isQualifiedSequence = (value: unknown): value is Sequence => {
+  return isHex(value) && (value as string).length === SequenceConstants.qualifiedSequenceBytes * 2
+}
+
+export const isSequence = (value: unknown): value is Sequence => {
+  return isLocalSequence(value) || isQualifiedSequence(value)
+}
+
+export const SequenceComponentLengths = {
+  epochBytes: 8,
+  nonceBytes: 8,
+  addressBytes: 20,
+}
+
+export const SequenceComponentMinMax = {
+  minEpoch: '0'.repeat(SequenceComponentLengths.epochBytes * 2) as Epoch,
+  maxEpoch: 'f'.repeat(SequenceComponentLengths.epochBytes * 2) as Epoch,
+  minNonce: '0'.repeat(SequenceComponentLengths.nonceBytes * 2) as Nonce,
+  maxNonce: 'f'.repeat(SequenceComponentLengths.nonceBytes * 2) as Nonce,
+  minAddress: '0'.repeat(SequenceComponentLengths.addressBytes * 2) as Address,
+  maxAddress: 'f'.repeat(SequenceComponentLengths.addressBytes * 2) as Address,
+}
+
+export const LocalSequenceConstants = {
+  ...SequenceComponentLengths,
+  ...SequenceComponentMinMax,
+  localSequenceBytes: SequenceComponentLengths.epochBytes + SequenceComponentLengths.nonceBytes,
+  minLocalSequence: SequenceComponentMinMax.minEpoch + SequenceComponentMinMax.minNonce as LocalSequence,
+  maxLocalSequence: SequenceComponentMinMax.maxEpoch + SequenceComponentMinMax.maxNonce as LocalSequence,
+}
+
+export const QualifiedSequenceConstants = {
+  qualifiedSequenceBytes: LocalSequenceConstants.localSequenceBytes + SequenceComponentLengths.addressBytes,
+  minLocalSequence: LocalSequenceConstants.minLocalSequence + SequenceComponentMinMax.minAddress as QualifiedSequence,
+  maxLocalSequence: LocalSequenceConstants.maxLocalSequence + SequenceComponentMinMax.maxAddress as QualifiedSequence,
+}
+
+export const SequenceConstants = {
+  ...LocalSequenceConstants,
+  ...QualifiedSequenceConstants,
+}
+
+// "11111111111111112222222222222222" is and example of a local sequence string
+
+// "111111111111111122222222222222223333333333333333333333333333333333333333" is and example of a local sequence string
+// epoch = "1111111111111111"
+// nonce = "2222222222222222"
+// address = "3333333333333333333333333333333333333333"

package/src/StorageMeta/SequenceParser.ts

@@ -0,0 +1,125 @@
+import { toUint8Array } from '@xylabs/arraybuffer'
+import { assertEx } from '@xylabs/assert'
+import {
+  type Address,
+  type Hash, type Hex,
+  isAddress,
+  toHex,
+} from '@xylabs/hex'
+
+import type {
+  Epoch, LocalSequence, Nonce, QualifiedSequence,
+  Sequence,
+} from './Sequence.ts'
+import {
+  isQualifiedSequence, isSequence, SequenceConstants,
+} from './Sequence.ts'
+
+export class SequenceParser {
+  protected static privateConstructorKey = Date.now().toString()
+
+  private readonly data: Readonly<Uint8Array>
+
+  protected constructor(privateConstructorKey: string, hex: Hex) {
+    assertEx(SequenceParser.privateConstructorKey === privateConstructorKey, () => 'Use create function instead of constructor')
+    const paddedHex = toHex(hex, {
+      prefix: false,
+      bitLength: (hex.length <= SequenceConstants.localSequenceBytes * 2)
+        ? SequenceConstants.localSequenceBytes * 8
+        : SequenceConstants.qualifiedSequenceBytes * 8,
+    })
+    this.data = toUint8Array(paddedHex)
+  }
+
+  get address(): Address {
+    const start = SequenceConstants.localSequenceBytes
+    const end = SequenceConstants.qualifiedSequenceBytes
+    return toHex(this.data.slice(start, end).buffer, { prefix: false })
+  }
+
+  get epoch(): Epoch {
+    const start = 0
+    const end = SequenceConstants.epochBytes
+    return toHex(this.data.slice(start, end).buffer, { prefix: false })
+  }
+
+  get localSequence(): LocalSequence {
+    const start = 0
+    const end = SequenceConstants.localSequenceBytes
+    return toHex(this.data.slice(start, end).buffer, { prefix: false })
+  }
+
+  get nonce(): Nonce {
+    const start = SequenceConstants.epochBytes
+    const end = SequenceConstants.localSequenceBytes
+    return toHex(this.data.slice(start, end).buffer, { prefix: false })
+  }
+
+  get qualifiedSequence(): QualifiedSequence {
+    const start = 0
+    const end = SequenceConstants.qualifiedSequenceBytes
+    return toHex(this.data.slice(start, end).buffer, { prefix: false })
+  }
+
+  static from(sequence: Sequence, address?: Address): SequenceParser
+  static from(timestamp: Hex, hash: Hash, address?: Address): SequenceParser
+  static from(timestamp: Hex, hash: Hex, address?: Address): SequenceParser
+  static from(timestamp: Hex, nonce: Nonce, address?: Address): SequenceParser
+  static from(timestamp: number, hash: Hash, address?: Address): SequenceParser
+  static from(timestamp: number, hash: Hex, address?: Address): SequenceParser
+  static from(timestamp: number, nonce: Nonce, address?: Address): SequenceParser
+  static from(timestampOrSequence: Sequence | Hex | number, nonceOrAddress: Hash | Nonce, address?: Address): SequenceParser {
+    if (isSequence(timestampOrSequence)) {
+      if (nonceOrAddress) {
+        assertEx(!isQualifiedSequence(timestampOrSequence), () => 'Providing both a qualified sequence and a address is not allowed')
+        assertEx(isAddress(nonceOrAddress), () => 'Invalid address provided')
+        return new this(SequenceParser.privateConstructorKey, (timestampOrSequence + address) as Hex)
+      }
+      return new this(SequenceParser.privateConstructorKey, timestampOrSequence)
+    }
+    const epoch = SequenceParser.toEpoch(timestampOrSequence)
+    const nonce = SequenceParser.toNonce(nonceOrAddress)
+    const addressHex: Hex = address ? toHex(address, { bitLength: SequenceConstants.addressBytes * 8 }) : '' as Hex
+    const hexString = (epoch + nonce + addressHex) as Hex
+    assertEx(isSequence(hexString), () => `Invalid sequence [${hexString}] [${epoch}, ${nonce}, ${addressHex}]`)
+    return new this(SequenceParser.privateConstructorKey, hexString)
+  }
+
+  static parse(value: Hex | string | ArrayBufferLike): SequenceParser {
+    const hex = toHex(value)
+    if (isSequence(hex)) {
+      return new this(SequenceParser.privateConstructorKey, hex)
+    }
+    throw new Error(`Invalid sequence [${value}]`)
+  }
+
+  // can convert a short number/hex to an epoch (treats it as the whole value) or extract an epoch from a sequence
+  static toEpoch(value: number | Hex | Epoch): Epoch {
+    assertEx(
+      typeof value !== 'number' || Number.isInteger(value),
+      () => 'Value must be in integer',
+    )
+    const hex = toHex(value, { prefix: false })
+    if (hex.length <= SequenceConstants.epochBytes * 2) {
+      return toHex(value, { prefix: false, bitLength: SequenceConstants.epochBytes * 8 }) as Epoch
+    }
+    if (isSequence(hex)) {
+      return hex.slice(0, SequenceConstants.epochBytes * 2) as Epoch
+    }
+    throw new Error(`Value could not be converted to epoch [${hex}]`)
+  }
+
+  // can convert a short number/hex to a nonce (treats it as the whole value) or extract an nonce from a sequence
+  static toNonce(value: Hash | Hex): Nonce {
+    assertEx(
+      typeof value !== 'number' || Number.isInteger(value),
+      () => 'Value must be in integer',
+    )
+    const hex = toHex(value, { prefix: false })
+    if (isSequence(hex)) {
+      return hex.slice(SequenceConstants.epochBytes * 2, SequenceConstants.localSequenceBytes * 2) as Nonce
+    }
+    const hash = toHex((hex as string), { prefix: false, bitLength: SequenceConstants.nonceBytes * 8 })
+    return hash.slice(-SequenceConstants.nonceBytes * 2) as Nonce
+  }
+}

package/src/{StorageMeta.ts → StorageMeta/StorageMeta.ts}

@@ -1,11 +1,10 @@
-import {
-  type Hash, type Hex, isHash,
-} from '@xylabs/hex'
+import { type Hash, isHash } from '@xylabs/hex'
 
-import type { Payload } from './Payload.ts'
+import type { Payload } from '../Payload.ts'
+import type { Sequence } from './Sequence.ts'
 
 export interface SequenceMeta {
-  _sequence: Hex
+  _sequence: Sequence
 }
 
 export type WithPartialSequenceMeta<T extends Payload = Payload> = Partial<WithSequenceMeta<T>>
@@ -27,27 +26,6 @@ export type WithPartialStorageMeta<T extends Payload = Payload> = Partial<WithSt
 
 export type WithStorageMeta<T extends Payload = Payload> = T & StorageMeta
 
-const StorageMetaComponentConstants = {
-  epochBytes: 8,
-  nonceBytes: 8,
-  addressBytes: 20,
-}
-
-const StorageMetaLocalConstants = {
-  maxEpoch: Math.pow(256, StorageMetaComponentConstants.epochBytes) - 1,
-  localSequenceBytes: StorageMetaComponentConstants.epochBytes + StorageMetaComponentConstants.nonceBytes,
-  minLocalSequence: '00000000000000000000000000000000' as Hex,
-  maxLocalSequence: 'ffffffffffffffffffffffffffffffff' as Hex,
-  ...StorageMetaComponentConstants,
-}
-
-export const StorageMetaConstants = {
-  qualifiedSequenceBytes: StorageMetaLocalConstants.localSequenceBytes + StorageMetaComponentConstants.addressBytes,
-  minSequence: `${StorageMetaLocalConstants}0000000000000000000000000000000000000000` as Hex,
-  maxSequence: `${StorageMetaLocalConstants}ffffffffffffffffffffffffffffffffffffffff` as Hex,
-  ...StorageMetaLocalConstants,
-}
-
 export const isSequenceMeta = (value: unknown): value is SequenceMeta => {
   return (value as WithSequenceMeta)?._sequence !== undefined
 }

package/src/StorageMeta/index.ts

@@ -0,0 +1,3 @@
+export * from './Sequence.ts'
+export * from './SequenceParser.ts'
+export * from './StorageMeta.ts'

package/src/index.ts

@@ -8,4 +8,4 @@ export * from './PayloadValidationFunction.ts'
 export * from './PayloadValueExpression.ts'
 export * from './Query.ts'
 export * from './Schema.ts'
-export * from './StorageMeta.ts'
+export * from './StorageMeta/index.ts'

package/dist/browser/StorageMeta.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"StorageMeta.d.ts","sourceRoot":"","sources":["../../src/StorageMeta.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,IAAI,EAAE,KAAK,GAAG,EACpB,MAAM,aAAa,CAAA;AAEpB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAE3C,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,GAAG,CAAA;CACf;AAED,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAA;AAE/F,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,CAAC,GAAG,YAAY,CAAA;AAE5E,MAAM,WAAW,QAAQ;IACvB,SAAS,EAAE,IAAI,CAAA;IACf,KAAK,EAAE,IAAI,CAAA;CACZ;AAED,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAA;AAEvF,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,CAAC,GAAG,QAAQ,CAAA;AAEpE,MAAM,WAAW,WAAY,SAAQ,YAAY,EAAE,QAAQ;CAAG;AAE9D,MAAM,MAAM,sBAAsB,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAA;AAE7F,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,CAAC,GAAG,WAAW,CAAA;AAgB1E,eAAO,MAAM,oBAAoB;;;;;;sBALyB,GAAG;sBACH,GAAG;;iBAM4B,GAAG;iBACH,GAAG;CAE3F,CAAA;AAED,eAAO,MAAM,cAAc,UAAW,OAAO,KAAG,KAAK,IAAI,YAExD,CAAA;AAED,eAAO,MAAM,UAAU,UAAW,OAAO,KAAG,KAAK,IAAI,QAEpD,CAAA;AAED,eAAO,MAAM,aAAa,UAAW,OAAO,KAAG,KAAK,IAAI,WAEvD,CAAA"}

package/dist/neutral/StorageMeta.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"StorageMeta.d.ts","sourceRoot":"","sources":["../../src/StorageMeta.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,IAAI,EAAE,KAAK,GAAG,EACpB,MAAM,aAAa,CAAA;AAEpB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAE3C,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,GAAG,CAAA;CACf;AAED,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAA;AAE/F,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,CAAC,GAAG,YAAY,CAAA;AAE5E,MAAM,WAAW,QAAQ;IACvB,SAAS,EAAE,IAAI,CAAA;IACf,KAAK,EAAE,IAAI,CAAA;CACZ;AAED,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAA;AAEvF,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,CAAC,GAAG,QAAQ,CAAA;AAEpE,MAAM,WAAW,WAAY,SAAQ,YAAY,EAAE,QAAQ;CAAG;AAE9D,MAAM,MAAM,sBAAsB,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAA;AAE7F,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,CAAC,GAAG,WAAW,CAAA;AAgB1E,eAAO,MAAM,oBAAoB;;;;;;sBALyB,GAAG;sBACH,GAAG;;iBAM4B,GAAG;iBACH,GAAG;CAE3F,CAAA;AAED,eAAO,MAAM,cAAc,UAAW,OAAO,KAAG,KAAK,IAAI,YAExD,CAAA;AAED,eAAO,MAAM,UAAU,UAAW,OAAO,KAAG,KAAK,IAAI,QAEpD,CAAA;AAED,eAAO,MAAM,aAAa,UAAW,OAAO,KAAG,KAAK,IAAI,WAEvD,CAAA"}

package/dist/node/StorageMeta.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"StorageMeta.d.ts","sourceRoot":"","sources":["../../src/StorageMeta.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,IAAI,EAAE,KAAK,GAAG,EACpB,MAAM,aAAa,CAAA;AAEpB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAE3C,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,GAAG,CAAA;CACf;AAED,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAA;AAE/F,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,CAAC,GAAG,YAAY,CAAA;AAE5E,MAAM,WAAW,QAAQ;IACvB,SAAS,EAAE,IAAI,CAAA;IACf,KAAK,EAAE,IAAI,CAAA;CACZ;AAED,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAA;AAEvF,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,CAAC,GAAG,QAAQ,CAAA;AAEpE,MAAM,WAAW,WAAY,SAAQ,YAAY,EAAE,QAAQ;CAAG;AAE9D,MAAM,MAAM,sBAAsB,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAA;AAE7F,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,CAAC,GAAG,WAAW,CAAA;AAgB1E,eAAO,MAAM,oBAAoB;;;;;;sBALyB,GAAG;sBACH,GAAG;;iBAM4B,GAAG;iBACH,GAAG;CAE3F,CAAA;AAED,eAAO,MAAM,cAAc,UAAW,OAAO,KAAG,KAAK,IAAI,YAExD,CAAA;AAED,eAAO,MAAM,UAAU,UAAW,OAAO,KAAG,KAAK,IAAI,QAEpD,CAAA;AAED,eAAO,MAAM,aAAa,UAAW,OAAO,KAAG,KAAK,IAAI,WAEvD,CAAA"}