stated-protocol-parser 1.0.7 → 5.0.0

package/src/types.ts

@@ -1,186 +1,185 @@
-export type StatementTypeValue =
-    | 'statement'
-    | 'quotation'
-    | 'organisation_verification'
-    | 'person_verification'
-    | 'poll'
-    | 'vote'
-    | 'response'
-    | 'dispute_statement_content'
-    | 'dispute_statement_authenticity'
-    | 'boycott'
-    | 'observation'
-    | 'rating'
-    | 'sign_pdf'
-    | 'bounty'
+import type { SupportedLanguage } from './constants';
+
+export type LegalForm =
+  | 'local government'
+  | 'state government'
+  | 'foreign affairs ministry'
+  | 'corporation';
+
+export type PeopleCountBucket =
+  | '0-10'
+  | '10-100'
+  | '100-1000'
+  | '1000-10,000'
+  | '10,000-100,000'
+  | '100,000+'
+  | '1,000,000+'
+  | '10,000,000+';
+
+// Type guards
+export function isLegalForm(value: string): value is LegalForm {
+  return [
+    'local government',
+    'state government',
+    'foreign affairs ministry',
+    'corporation',
+  ].includes(value);
+}
 
-export type Statement = {
-    domain: string
-    author: string
-    time: Date
-    tags?: string[]
-    content: string
-    representative?: string
-    supersededStatement?: string
-    formatVersion?: string
+export function isPeopleCountBucket(value: string): value is PeopleCountBucket {
+  return [
+    '0-10',
+    '10-100',
+    '100-1000',
+    '1000-10,000',
+    '10,000-100,000',
+    '100,000+',
+    '1,000,000+',
+    '10,000,000+',
+  ].includes(value);
 }
 
-export type Quotation = {
-    originalAuthor: string
-    authorVerification: string
-    originalTime?: string
-    source?: string
-    quotation?: string
-    paraphrasedStatement?: string
-    picture?: string
-    confidence?: string
+export function isRatingValue(value: number): value is RatingValue {
+  return [1, 2, 3, 4, 5].includes(value);
 }
 
+export type StatementTypeValue =
+  | 'statement'
+  | 'organisation_verification'
+  | 'person_verification'
+  | 'poll'
+  | 'vote'
+  | 'response'
+  | 'dispute_statement_content'
+  | 'dispute_statement_authenticity'
+  | 'rating'
+  | 'sign_pdf';
+
+export type Statement = {
+  domain: string;
+  author: string;
+  time: Date;
+  tags?: string[];
+  content: string;
+  representative?: string;
+  supersededStatement?: string;
+  formatVersion?: string;
+  translations?: Partial<Record<SupportedLanguage, string>>;
+  attachments?: string[];
+};
+
+export type CryptographicallySignedStatement = {
+  statement: string;
+  statementHash: string;
+  publicKey: string;
+  signature: string;
+  algorithm: string;
+};
+
 export type Poll = {
-    country: string | undefined
-    city: string | undefined
-    legalEntity: string | undefined
-    domainScope: string[] | undefined
-    judges?: string
-    deadline: Date | undefined
-    poll: string
-    scopeDescription?: string
-    scopeQueryLink?: string
-    options: string[]
-    allowArbitraryVote?: boolean
-    requiredProperty?: string
-    requiredPropertyValue?: string
-    requiredPropertyObserver?: string
-    requiredMinConfidence?: number
-}
+  deadline: Date | undefined;
+  poll: string;
+  scopeDescription?: string;
+  options: string[];
+  allowArbitraryVote?: boolean;
+};
 
 export type OrganisationVerification = {
-    name: string
-    englishName?: string
-    country: string
-    city: string
-    province: string
-    legalForm: string
-    department?: string
-    domain: string
-    foreignDomain: string
-    serialNumber: string
-    confidence?: number
-    reliabilityPolicy?: string
-    employeeCount?: string
-    pictureHash?: string
-    latitude?: number
-    longitude?: number
-    population?: string
-}
+  name: string;
+  englishName?: string;
+  country: string;
+  city?: string;
+  province?: string;
+  legalForm: LegalForm;
+  department?: string;
+  domain: string;
+  foreignDomain?: string;
+  serialNumber?: string;
+  confidence?: number;
+  reliabilityPolicy?: string;
+  employeeCount?: PeopleCountBucket;
+  pictureHash?: string;
+  latitude?: number;
+  longitude?: number;
+  population?: PeopleCountBucket;
+  publicKey?: string;
+};
 
 export type withOwnDomain = {
-    ownDomain: string
-    foreignDomain?: string
-}
+  ownDomain: string;
+  foreignDomain?: string;
+};
 
 export type withForeignDomain = {
-    foreignDomain: string
-    ownDomain?: string
-}
+  foreignDomain: string;
+  ownDomain?: string;
+};
 
 export type PersonVerification = {
-    name: string
-    countryOfBirth: string
-    cityOfBirth: string
-    dateOfBirth: Date
-    jobTitle?: string
-    employer?: string
-    verificationMethod?: string
-    confidence?: number
-    picture?: string
-    reliabilityPolicy?: string
-} & (withOwnDomain | withForeignDomain)
+  name: string;
+  countryOfBirth: string;
+  cityOfBirth: string;
+  dateOfBirth: Date;
+  jobTitle?: string;
+  employer?: string;
+  verificationMethod?: string;
+  confidence?: number;
+  picture?: string;
+  reliabilityPolicy?: string;
+  publicKey?: string;
+} & (withOwnDomain | withForeignDomain);
 
 export type Vote = {
-    pollHash: string
-    poll: string
-    vote: string
-}
+  pollHash: string;
+  poll: string;
+  vote: string;
+};
 
 export type DisputeAuthenticity = {
-    hash: string
-    confidence?: number
-    reliabilityPolicy?: string
-}
+  hash: string;
+  confidence?: number;
+  reliabilityPolicy?: string;
+};
 
 export type DisputeContent = {
-    hash: string
-    confidence?: number
-    reliabilityPolicy?: string
-}
+  hash: string;
+  confidence?: number;
+  reliabilityPolicy?: string;
+};
 
 export type ResponseContent = {
-    hash: string
-    response: string
-}
+  hash: string;
+  response: string;
+};
 
 export type PDFSigning = {
-    hash: string
-}
+  hash: string;
+};
 
 export type RatingSubjectTypeValue =
-    | 'Organisation'
-    | 'Policy proposal'
-    | 'Treaty draft'
-    | 'Research publication'
-    | 'Regulation'
-    | 'Product'
+  | 'Organisation'
+  | 'Policy proposal'
+  | 'Treaty draft'
+  | 'Research publication'
+  | 'Regulation'
+  | 'Product';
+
+export type RatingValue = 1 | 2 | 3 | 4 | 5;
 
 export type Rating = {
-    subjectType?: RatingSubjectTypeValue
-    subjectName: string
-    subjectReference?: string
-    documentFileHash?: string
-    rating: number
-    quality?: string
-    comment?: string
-}
+  subjectType?: RatingSubjectTypeValue;
+  subjectName: string;
+  subjectReference?: string;
+  documentFileHash?: string;
+  rating: RatingValue;
+  quality?: string;
+  comment?: string;
+};
 
 export type Bounty = {
-    motivation?: string
-    bounty: string
-    reward: string
-    judge: string
-    judgePay?: string
-}
-
-export type Observation = {
-    description?: string
-    approach?: string
-    confidence?: number
-    reliabilityPolicy?: string
-    subject: string
-    subjectReference?: string
-    observationReference?: string
-    property: string
-    value?: string
-}
-
-export type PollV3 = {
-    country: string | undefined
-    city: string | undefined
-    legalEntity: string | undefined
-    domainScope: string[] | undefined
-    judges?: string
-    deadline: Date
-    poll: string
-    scopeDescription?: string
-    scopeQueryLink?: string
-    scopeProperty?: string
-    propertyScopeObserver?: string
-    pollType?: string
-    options: string[]
-}
-
-export type Boycott = {
-    description?: string
-    reliabilityPolicy?: string
-    subject: string
-    subjectReference?: string
-}
+  motivation?: string;
+  bounty: string;
+  reward: string;
+  judge: string;
+  judgePay?: string;
+};

package/src/utils.test.ts

@@ -0,0 +1,140 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { buildStatement } from './protocol';
+import {
+  generateFileHash,
+  validateFileHash,
+  generateStatementContentHash,
+  validateStatementContentHash,
+  generateStatementHash,
+  validateStatementHash,
+  generateStatementsFile,
+  parseStatementsFile,
+  generateStatementFilename,
+  generateAttachmentFilename,
+} from './utils';
+
+describe('Statement Utils', () => {
+  const testContent = 'test content';
+  const testFileContent = Buffer.from('test file content');
+
+  describe('File Hash Functions', () => {
+    it('should generate file hash', () => {
+      const hash = generateFileHash(testFileContent);
+      assert.ok(hash);
+      assert.strictEqual(typeof hash, 'string');
+    });
+
+    it('should validate file hash', () => {
+      const hash = generateFileHash(testFileContent);
+      assert.strictEqual(validateFileHash(testFileContent, hash), true);
+      assert.strictEqual(validateFileHash(testFileContent, 'invalid-hash'), false);
+    });
+
+    it('should generate attachment filename', () => {
+      const filename = generateAttachmentFilename(testFileContent, 'pdf');
+      assert.ok(/^[A-Za-z0-9_-]+\.pdf$/.test(filename));
+    });
+
+    it('should handle extension with dot', () => {
+      const filename = generateAttachmentFilename(testFileContent, '.jpg');
+      assert.ok(/^[A-Za-z0-9_-]+\.jpg$/.test(filename));
+    });
+  });
+
+  describe('Statement Content Hash Functions', () => {
+    it('should generate statement content hash', () => {
+      const hash = generateStatementContentHash(testContent);
+      assert.ok(hash);
+      assert.strictEqual(typeof hash, 'string');
+    });
+
+    it('should validate statement content hash', () => {
+      const hash = generateStatementContentHash(testContent);
+      assert.strictEqual(validateStatementContentHash(testContent, hash), true);
+      assert.strictEqual(validateStatementContentHash(testContent, 'invalid-hash'), false);
+    });
+  });
+
+  describe('Statement Hash Functions', () => {
+    const statement = buildStatement({
+      domain: 'example.com',
+      author: 'Test Author',
+      time: new Date('2023-06-15T20:01:26.000Z'),
+      content: 'Test statement content',
+    });
+
+    it('should generate statement hash', () => {
+      const hash = generateStatementHash(statement);
+      assert.ok(hash);
+      assert.strictEqual(typeof hash, 'string');
+    });
+
+    it('should validate statement hash', () => {
+      const hash = generateStatementHash(statement);
+      assert.strictEqual(validateStatementHash(statement, hash), true);
+      assert.strictEqual(validateStatementHash(statement, 'invalid-hash'), false);
+    });
+
+    it('should generate statement filename', () => {
+      const filename = generateStatementFilename(statement);
+      assert.ok(/^[A-Za-z0-9_-]+\.txt$/.test(filename));
+    });
+
+    it('should exclude signature fields from hash', () => {
+      const signedStatement =
+        statement +
+        '---\n' +
+        'Statement hash: test-hash\n' +
+        'Public key: test-key\n' +
+        'Signature: test-signature\n' +
+        'Algorithm: Ed25519\n';
+
+      const hash = generateStatementHash(signedStatement);
+      const hashWithoutSignature = generateStatementHash(statement);
+      assert.strictEqual(hash, hashWithoutSignature);
+    });
+  });
+
+  describe('Statements File Functions', () => {
+    const statement1 = buildStatement({
+      domain: 'example.com',
+      author: 'Test Author',
+      time: new Date('2023-06-15T20:01:26.000Z'),
+      content: 'First statement',
+    });
+
+    const statement2 = buildStatement({
+      domain: 'example.com',
+      author: 'Test Author',
+      time: new Date('2023-06-16T10:30:00.000Z'),
+      content: 'Second statement',
+    });
+
+    it('should generate statements file', () => {
+      const statementsFile = generateStatementsFile([statement1, statement2]);
+      assert.ok(statementsFile.includes(statement1));
+      assert.ok(statementsFile.includes(statement2));
+      assert.ok(statementsFile.includes('\n\n'));
+    });
+
+    it('should parse statements file', () => {
+      const statementsFile = generateStatementsFile([statement1, statement2]);
+      const parsed = parseStatementsFile(statementsFile);
+      assert.strictEqual(parsed.length, 2);
+      assert.strictEqual(parsed[0], statement1);
+      assert.strictEqual(parsed[1], statement2);
+    });
+
+    it('should throw error for invalid statement in file', () => {
+      const invalidFile = 'Invalid statement\n\nAnother invalid statement';
+      assert.throws(() => parseStatementsFile(invalidFile));
+    });
+
+    it('should filter empty statements', () => {
+      const fileWithEmpty = statement1 + '\n\n\n\n' + statement2;
+      const parsed = parseStatementsFile(fileWithEmpty);
+      assert.strictEqual(parsed.length, 2);
+    });
+  });
+});

package/src/utils.ts

@@ -1,18 +1,104 @@
-import { peopleCountBuckets } from './constants'
+import { peopleCountBuckets } from './constants';
+
+import { sha256, verify } from './hash';
+import { parseStatement } from './protocol';
+
+export const generateFileHash = (fileContent: Buffer | string): string => {
+  return sha256(fileContent);
+};
+
+export const validateFileHash = (fileContent: Buffer | string, expectedHash: string): boolean => {
+  return verify(fileContent, expectedHash);
+};
+
+export const generateStatementContentHash = (statementContent: string): string => {
+  return sha256(statementContent);
+};
+
+export const validateStatementContentHash = (
+  statementContent: string,
+  expectedHash: string
+): boolean => {
+  return verify(statementContent, expectedHash);
+};
+
+export const generateStatementHash = (statement: string): string => {
+  const signatureRegex = /^([\s\S]+?)---\n[\s\S]+$/;
+  const match = statement.match(signatureRegex);
+
+  if (match && match[1]) {
+    return sha256(match[1]);
+  }
+
+  return sha256(statement);
+};
+
+export const validateStatementHash = (statement: string, expectedHash: string): boolean => {
+  const computedHash = generateStatementHash(statement);
+  return computedHash === expectedHash;
+};
+
+export const generateStatementsFile = (statements: string[]): string => {
+  return statements.join('\n\n');
+};
+
+export const parseStatementsFile = (statementsFileContent: string): string[] => {
+  const statementParts = statementsFileContent.split(/\n\nStated protocol version: /);
+  const statements: string[] = [];
+
+  for (let i = 0; i < statementParts.length; i++) {
+    let statement = statementParts[i];
+
+    if (i === 0 && statement.trim().length === 0) continue;
+
+    if (i > 0) {
+      statement = 'Stated protocol version: ' + statement;
+    }
+
+    statement = statement.replace(/\n+$/, '\n');
+
+    try {
+      parseStatement({ statement });
+      statements.push(statement);
+    } catch (error) {
+      throw new Error(
+        `Invalid statement at index ${i}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  return statements;
+};
+
+export const generateStatementFilename = (statement: string): string => {
+  const hash = generateStatementHash(statement);
+  return `${hash}.txt`;
+};
+
+export const generateAttachmentFilename = (
+  fileContent: Buffer | string,
+  extension: string
+): string => {
+  const hash = generateFileHash(fileContent);
+  const ext = extension.startsWith('.') ? extension.substring(1) : extension;
+  return `${hash}.${ext}`;
+};
 
 export const minPeopleCountToRange = (n: number): string | undefined => {
-    if (n >= 10000000) return peopleCountBuckets["10000000"]
-    if (n >= 1000000) return peopleCountBuckets["1000000"]
-    if (n >= 100000) return peopleCountBuckets["100000"]
-    if (n >= 10000) return peopleCountBuckets["10000"]
-    if (n >= 1000) return peopleCountBuckets["1000"]
-    if (n >= 100) return peopleCountBuckets["100"]
-    if (n >= 10) return peopleCountBuckets["10"]
-    if (n >= 0) return peopleCountBuckets["0"]
-}
-
-export const monthIndex = (month: string): number => 
-    ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"]
-        .indexOf(month.toLowerCase().substr(0, 3))
-
-export const birthDateFormat: RegExp = /(?<d>\d{1,2})\s(?<month>Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(?<y>\d{4})/
+  if (n >= 10000000) return peopleCountBuckets['10000000'];
+  if (n >= 1000000) return peopleCountBuckets['1000000'];
+  if (n >= 100000) return peopleCountBuckets['100000'];
+  if (n >= 10000) return peopleCountBuckets['10000'];
+  if (n >= 1000) return peopleCountBuckets['1000'];
+  if (n >= 100) return peopleCountBuckets['100'];
+  if (n >= 10) return peopleCountBuckets['10'];
+  if (n >= 0) return peopleCountBuckets['0'];
+};
+
+export const monthIndex = (month: string): number =>
+  ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec'].indexOf(
+    month.toLowerCase().substr(0, 3)
+  );
+
+export const birthDateFormat: RegExp =
+  /(?<d>\d{1,2})\s(?<month>Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(?<y>\d{4})/;

package/dist/esm/constants.js

@@ -1,47 +0,0 @@
-export const legalForms = {
-    local_government: 'local government',
-    state_government: 'state government',
-    foreign_affairs_ministry: 'foreign affairs ministry',
-    corporation: 'corporation',
-};
-export const statementTypes = {
-    statement: 'statement',
-    quotation: 'quotation',
-    organisationVerification: 'organisation_verification',
-    personVerification: 'person_verification',
-    poll: 'poll',
-    vote: 'vote',
-    response: 'response',
-    disputeContent: 'dispute_statement_content',
-    disputeAuthenticity: 'dispute_statement_authenticity',
-    boycott: 'boycott',
-    observation: 'observation',
-    rating: 'rating',
-    signPdf: "sign_pdf",
-    bounty: "bounty",
-    unsupported: "unsupported",
-};
-export const peopleCountBuckets = {
-    "0": "0-10",
-    "10": "10-100",
-    "100": "100-1000",
-    "1000": "1000-10,000",
-    "10000": "10,000-100,000",
-    "100000": "100,000+",
-    "1000000": "1,000,000+",
-    "10000000": "10,000,000+",
-};
-export const UTCFormat = /(Mon|Tue|Wed|Thu|Fri|Sat|Sun),\s\d{2}\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s\d{4}\s\d{2}:\d{2}:\d{2}\sGMT/;
-export const pollKeys = /(Type: |The poll outcome is finalized when the following nodes agree: |Voting deadline: |Poll: |Option 1: |Option 2: |Option 3: |Option 4: |Option 5: |Allow free text votes: |Who can vote: |Description: |Country scope: |City scope: |Legal form scope: |Domain scope: |All entities with the following property: |As observed by: |Link to query defining who can vote: )/g;
-export const organisationVerificationKeys = /(Type: |Description: |Name: |English name: |Country: |Legal entity: |Legal form: |Department using the domain: |Owner of the domain: |Foreign domain used for publishing statements: |Province or state: |Business register number: |City: |Longitude: |Latitude: |Population: |Logo: |Employee count: |Reliability policy: |Confidence: )/g;
-export const personVerificationKeys = /(Type: |Description: |Name: |Date of birth: |City of birth: |Country of birth: |Job title: |Employer: |Owner of the domain: |Foreign domain used for publishing statements: |Picture: |Verification method: |Confidence: |Reliability policy: )/g;
-export const voteKeys = /(Type: |Poll id: |Poll: |Option: )/g;
-export const disputeAuthenticityKeys = /(Type: |Description: |Hash of referenced statement: |Confidence: |Reliability policy: )/g;
-export const disputeContentKeys = /(Type: |Description: |Hash of referenced statement: |Confidence: |Reliability policy: )/g;
-export const responseKeys = /(Type: |Hash of referenced statement: |Response: )/;
-export const PDFSigningKeys = /(Type: |Description: |PDF file hash: )/;
-export const ratingKeys = /(Type: |Subject type: |Subject name: |URL that identifies the subject: |Document file hash: |Rated quality: |Our rating: |Comment: )/;
-export const BountyKeys = /(Type: |In order to: |We will reward any entity that: |The reward is: |In case of dispute, bounty claims are judged by: |The judge will be paid per investigated case with a maxium of: )/;
-export const ObservationKeys = /(Type: |Approach: |Confidence: |Reliability policy: |Subject: |Subject identity reference: |Observation reference: |Observed property: |Observed value: )/;
-export const BoycottKeys = /(Type: |Description: |Subject: |Subject identity reference: )/;
-//# sourceMappingURL=constants.js.map

package/dist/esm/constants.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,UAAU,GAAG;IACtB,gBAAgB,EAAE,kBAAkB;IACpC,gBAAgB,EAAE,kBAAkB;IACpC,wBAAwB,EAAE,0BAA0B;IACpD,WAAW,EAAE,aAAa;CAC7B,CAAA;AAED,MAAM,CAAC,MAAM,cAAc,GAAG;IAC1B,SAAS,EAAE,WAAW;IACtB,SAAS,EAAE,WAAW;IACtB,wBAAwB,EAAE,2BAA2B;IACrD,kBAAkB,EAAE,qBAAqB;IACzC,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,QAAQ,EAAE,UAAU;IACpB,cAAc,EAAE,2BAA2B;IAC3C,mBAAmB,EAAE,gCAAgC;IACrD,OAAO,EAAE,SAAS;IAClB,WAAW,EAAE,aAAa;IAC1B,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,UAAU;IACnB,MAAM,EAAE,QAAQ;IAChB,WAAW,EAAE,aAAa;CAC7B,CAAA;AAED,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAC9B,GAAG,EAAE,MAAM;IACX,IAAI,EAAE,QAAQ;IACd,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,aAAa;IACrB,OAAO,EAAE,gBAAgB;IACzB,QAAQ,EAAE,UAAU;IACpB,SAAS,EAAE,YAAY;IACvB,UAAU,EAAE,aAAa;CAC5B,CAAA;AAED,MAAM,CAAC,MAAM,SAAS,GAAW,yHAAyH,CAAA;AAE1J,MAAM,CAAC,MAAM,QAAQ,GAAG,gXAAgX,CAAA;AAExY,MAAM,CAAC,MAAM,4BAA4B,GAAG,6UAA6U,CAAA;AAEzX,MAAM,CAAC,MAAM,sBAAsB,GAAG,kPAAkP,CAAA;AAExR,MAAM,CAAC,MAAM,QAAQ,GAAG,qCAAqC,CAAA;AAE7D,MAAM,CAAC,MAAM,uBAAuB,GAAG,0FAA0F,CAAA;AAEjI,MAAM,CAAC,MAAM,kBAAkB,GAAG,0FAA0F,CAAA;AAE5H,MAAM,CAAC,MAAM,YAAY,GAAG,oDAAoD,CAAA;AAEhF,MAAM,CAAC,MAAM,cAAc,GAAG,wCAAwC,CAAA;AAEtE,MAAM,CAAC,MAAM,UAAU,GAAG,sIAAsI,CAAA;AAEhK,MAAM,CAAC,MAAM,UAAU,GAAG,2LAA2L,CAAA;AAErN,MAAM,CAAC,MAAM,eAAe,GAAG,2JAA2J,CAAA;AAE1L,MAAM,CAAC,MAAM,WAAW,GAAG,+DAA+D,CAAA"}

package/dist/esm/hash.browser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hash.browser.d.ts","sourceRoot":"","sources":["../../src/hash.browser.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GAAU,OAAO,MAAM,GAAG,UAAU,KAAG,OAAO,CAAC,MAAM,CAqBvE,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GAAU,SAAS,MAAM,GAAG,UAAU,EAAE,MAAM,MAAM,KAAG,OAAO,CAAC,OAAO,CAGxF,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,SAAS,MAAM,KAAG,MAKnD,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAAI,QAAQ,MAAM,KAAG,MAEhD,CAAA"}