@learncard/linked-claims-plugin 0.2.24 → 0.2.25

package/README.md

@@ -3,10 +3,11 @@
 Create, verify, store, and retrieve endorsement credentials using Open Badges v3 EndorsementCredential, linked to original credentials by subject id or original credential id.
 
 ## Install
+
 Workspace package. Build with Nx:
 
 ```
-pnpm nx run linked-claims-plugin:build
+bunx nx run linked-claims-plugin:build
 ```
 
 ## Usage
@@ -17,10 +18,10 @@ import { getLinkedClaimsPlugin } from '@learncard/linked-claims-plugin';
 const lc = await LearnCard.fromSomewhere().then(lc => lc.addPlugin(getLinkedClaimsPlugin(lc)));
 
 const endorsement = await lc.invoke.endorseCredential(originalVc, {
-  // OBv3 fields
-  endorsementComment: 'I endorse this credential.',
-  name: `Endorsement of ${originalVc.id ?? originalVc.credentialSubject?.id}`,
-  description: 'Peer endorsement',
+    // OBv3 fields
+    endorsementComment: 'I endorse this credential.',
+    name: `Endorsement of ${originalVc.id ?? originalVc.credentialSubject?.id}`,
+    description: 'Peer endorsement',
 });
 
 const verified = await lc.invoke.verifyEndorsement(endorsement);
@@ -31,6 +32,7 @@ const endorsements = await lc.invoke.getEndorsements(originalVc);
 ```
 
 ## Endorsement Context
+
 Uses VC v2 and OBv3 contexts:
 
 ```
@@ -42,6 +44,6 @@ Uses VC v2 and OBv3 contexts:
 
 ### Endorsement Fields (details input)
 
-- `endorsementComment?: string`
-- `name?: string`
-- `description?: string`
+-   `endorsementComment?: string`
+-   `name?: string`
+-   `description?: string`

package/package.json

@@ -1,58 +1,60 @@
 {
-  "name": "@learncard/linked-claims-plugin",
-  "version": "0.2.24",
-  "description": "LinkedClaims plugin to create, verify, store, and query endorsement credentials.",
-  "type": "module",
-  "main": "./dist/index.cjs",
-  "module": "./dist/linked-claims-plugin.esm.js",
-  "exports": {
-    ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/linked-claims-plugin.esm.js"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "author": "Learning Economy Foundation (www.learningeconomy.io)",
-  "license": "MIT",
-  "homepage": "https://github.com/learningeconomy/LearnCard/tree/main/packages/plugins/linked-claims/README.md",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/learningeconomy/LearnCard"
-  },
-  "bugs": {
-    "url": "https://github.com/learningeconomy/LearnCard/issues"
-  },
-  "devDependencies": {
-    "@types/jest": "^29.2.2",
-    "@types/node": "^17.0.31",
-    "aqu": "0.4.3",
-    "esbuild": "^0.27.1",
-    "esbuild-jest": "^0.5.0",
-    "esbuild-plugin-copy": "^1.3.0",
-    "jest": "^29.3.0",
-    "shx": "^0.3.4",
-    "ts-jest": "^29.0.3"
-  },
-  "types": "./dist/index.d.ts",
-  "dependencies": {
-    "why-is-node-running": "^2.2.2",
-    "@learncard/core": "9.4.24",
-    "@learncard/types": "5.17.4",
-    "@learncard/vc-plugin": "^1.5.4"
-  },
-  "sideEffects": false,
-  "scripts": {
-    "build": "node ./scripts/build.mjs && shx cp ./scripts/mixedEntypoint.js ./dist/index.cjs && tsc --p tsconfig.json && shx cp ./dist/index.d.ts ./dist/index.d.cts",
-    "test": "jest --passWithNoTests",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --silent --ci --coverage --coverageReporters=\"text\" --coverageReporters=\"text-summary\""
-  }
-}
+    "name": "@learncard/linked-claims-plugin",
+    "version": "0.2.25",
+    "description": "LinkedClaims plugin to create, verify, store, and query endorsement credentials.",
+    "type": "module",
+    "main": "./dist/index.cjs",
+    "module": "./dist/linked-claims-plugin.esm.js",
+    "exports": {
+        ".": {
+            "development": "./src/index.ts",
+            "import": {
+                "types": "./dist/index.d.ts",
+                "default": "./dist/linked-claims-plugin.esm.js"
+            },
+            "require": {
+                "types": "./dist/index.d.cts",
+                "default": "./dist/index.cjs"
+            }
+        }
+    },
+    "files": [
+        "dist",
+        "src"
+    ],
+    "scripts": {
+        "build": "node ./scripts/build.mjs && shx cp ./scripts/mixedEntypoint.js ./dist/index.cjs && tsc --p tsconfig.json && shx cp ./dist/index.d.ts ./dist/index.d.cts",
+        "test": "jest --passWithNoTests",
+        "test:watch": "jest --watch",
+        "test:coverage": "jest --silent --ci --coverage --coverageReporters=\"text\" --coverageReporters=\"text-summary\""
+    },
+    "author": "Learning Economy Foundation (www.learningeconomy.io)",
+    "license": "MIT",
+    "homepage": "https://github.com/learningeconomy/LearnCard/tree/main/packages/plugins/linked-claims/README.md",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/learningeconomy/LearnCard"
+    },
+    "bugs": {
+        "url": "https://github.com/learningeconomy/LearnCard/issues"
+    },
+    "devDependencies": {
+        "@types/jest": "^29.2.2",
+        "@types/node": "^17.0.31",
+        "aqu": "0.4.3",
+        "esbuild": "^0.27.1",
+        "esbuild-jest": "^0.5.0",
+        "esbuild-plugin-copy": "^1.3.0",
+        "jest": "^29.3.0",
+        "shx": "^0.3.4",
+        "ts-jest": "^29.0.3"
+    },
+    "types": "./dist/index.d.ts",
+    "dependencies": {
+        "@learncard/core": "workspace:*",
+        "@learncard/types": "workspace:*",
+        "@learncard/vc-plugin": "workspace:^",
+        "why-is-node-running": "^2.2.2"
+    },
+    "sideEffects": false
+}

package/src/index.ts

@@ -0,0 +1,180 @@
+import type { LearnCard } from '@learncard/core';
+import type { VC, UnsignedVC } from '@learncard/types';
+import type { LinkedClaimsPlugin, LinkedClaimsPluginDependentMethods } from './types';
+
+export * from './types';
+
+const ENDORSEMENT_CONTEXT = 'https://purl.imsglobal.org/spec/ob/v3p0/context-3.0.3.json';
+
+const getSubjectIds = (credential: VC): string[] => {
+    const subject = credential.credentialSubject as any;
+    if (Array.isArray(subject)) return subject.map(s => s?.id).filter(Boolean);
+    return subject?.id ? [subject.id] : [];
+};
+
+const pickIndexProvider = (learnCard: any, preferred?: string): string | undefined => {
+    const providers = Object.keys(learnCard.index || {}).filter(
+        k => !['providers', 'all'].includes(k)
+    );
+    if (!providers.length) return undefined;
+    if (preferred && providers.includes(preferred)) return preferred;
+    if (providers.includes('LearnCloud')) return 'LearnCloud';
+    return providers[0];
+};
+
+const pickStoreProvider = (learnCard: any, preferred?: string): string | undefined => {
+    const providers = Object.keys(learnCard.store || {}).filter(k => k !== 'providers');
+    if (!providers.length) return undefined;
+    if (preferred && providers.includes(preferred)) return preferred;
+    return providers[0];
+};
+
+const ensureArray = <T>(arr: T | T[] | undefined): T[] =>
+    Array.isArray(arr) ? arr : arr ? [arr] : [];
+
+export const getLinkedClaimsPlugin = (
+    learnCard: LearnCard<any, 'id' | 'store' | 'index' | 'read', LinkedClaimsPluginDependentMethods>
+): LinkedClaimsPlugin => ({
+    name: 'LinkedClaims',
+    displayName: 'LinkedClaims',
+    description: 'Create, verify, store, and retrieve endorsement credentials linked to originals.',
+    methods: {
+        endorseCredential: async (_learnCard, original, details, opts) => {
+            const issuer = learnCard.id.did();
+
+            const originalId: string | undefined = (original as any).id;
+            const subjectIds = getSubjectIds(original);
+            const targetId = originalId || subjectIds[0];
+            if (!targetId)
+                throw new Error('Original credential must have either id or credentialSubject.id');
+
+            const context: (string | Record<string, any>)[] = [
+                'https://www.w3.org/ns/credentials/v2',
+                ENDORSEMENT_CONTEXT,
+            ];
+
+            const types: [string, ...string[]] = ['VerifiableCredential', 'EndorsementCredential'];
+
+            const unsigned: UnsignedVC = {
+                '@context': context as any,
+                type: types,
+                issuer,
+                validFrom: new Date().toISOString(),
+                credentialSubject: {
+                    type: ['EndorsementSubject'],
+                    id: targetId,
+                    ...(details.endorsementComment
+                        ? { endorsementComment: details.endorsementComment }
+                        : {}),
+                },
+                ...(details.name ? { name: details.name } : { name: `Endorsement of ${targetId}` }),
+                ...(details.description ? { description: details.description } : {}),
+                ...(details.evidence && { evidence: details.evidence as any }),
+            };
+
+            return learnCard.invoke.issueCredential(unsigned);
+        },
+
+        verifyEndorsement: async (_learnCard, endorsement, options) => {
+            const check = await learnCard.invoke.verifyCredential(endorsement, options);
+
+            const ctx = ensureArray((endorsement as any)['@context']);
+            const types = ensureArray((endorsement as any)['type']);
+
+            if (
+                !ctx.some((c: string) => c === 'https://www.w3.org/ns/credentials/v2') ||
+                !ctx.some((c: string) => c === ENDORSEMENT_CONTEXT)
+            ) {
+                check.errors.push('linked-claims error: missing VCv2 or OBv3 context');
+            }
+            if (!types.includes('EndorsementCredential')) {
+                check.errors.push('linked-claims error: missing EndorsementCredential type');
+            }
+
+            const cs: any = (endorsement as any).credentialSubject;
+            const csObj = Array.isArray(cs) ? cs[0] : cs;
+            const csTypes = ensureArray<string>(csObj?.type);
+            if (!csTypes.includes('EndorsementSubject')) {
+                check.errors.push(
+                    'linked-claims error: credentialSubject.type must include EndorsementSubject'
+                );
+            }
+            if (!csObj?.id) {
+                check.errors.push('linked-claims error: credentialSubject.id missing');
+            }
+
+            if (!check.errors.length) check.checks.push('linked-claims');
+            return check;
+        },
+
+        storeEndorsement: async (_learnCard, endorsement, options) => {
+            const storeName = pickStoreProvider(learnCard, options?.storeName);
+            if (!storeName) throw new Error('No store plane provider available');
+            if (
+                !learnCard.store[storeName].uploadEncrypted ||
+                typeof learnCard.store[storeName].uploadEncrypted !== 'function'
+            ) {
+                throw new Error(
+                    `Store provider '${storeName}' does not support uploadEncrypted method`
+                );
+            }
+            const uri: string = await (learnCard.store as any)[storeName].uploadEncrypted(
+                endorsement
+            );
+
+            const indexName = pickIndexProvider(learnCard, options?.indexName);
+            let indexed = false;
+            let id =
+                (endorsement as any).id ||
+                `urn:uuid:${(globalThis as any).crypto?.randomUUID?.() ||
+                (() => {
+                    throw new Error(
+                        'Secure random UUID generation is not available. Please use an environment that supports crypto.randomUUID().'
+                    );
+                })()
+                }`;
+
+            if (indexName) {
+                const cs: any = (endorsement as any).credentialSubject;
+                const csObj = Array.isArray(cs) ? cs[0] : cs;
+                const record = {
+                    id,
+                    uri,
+                    type: ensureArray((endorsement as any).type),
+                    endorsedId: csObj?.id,
+                    subjectId: csObj?.id,
+                    originalCredentialId: csObj?.id,
+                    issuedOn: (endorsement as any).validFrom || (endorsement as any).issuanceDate,
+                    category: 'Endorsement',
+                    credentialId: options?.credentialId, // original credential id
+                    sharedUri: options?.sharedUri, // original credential shared uri
+                    relationship: options?.relationship,
+                    visibility: options?.visibility ?? 'public',
+                };
+                indexed = await (learnCard.index as any)[indexName].add(record);
+            }
+
+            return { uri, indexed, id, indexName, storeName };
+        },
+
+        getEndorsements: async (_learnCard, original, options) => {
+            const indexName = pickIndexProvider(learnCard, options?.indexName);
+            if (!indexName) return [];
+
+            const subjectIds = getSubjectIds(original);
+            const originalId = (original as any).id;
+
+            const query = originalId
+                ? { originalCredentialId: originalId }
+                : { endorsedId: subjectIds[0] };
+            const records = await (learnCard.index as any)[indexName].get(query);
+
+            const results: VC[] = [];
+            for (const rec of records) {
+                const vc = await learnCard.read.get(rec.uri);
+                if (vc) results.push(vc as VC);
+            }
+            return results;
+        },
+    },
+});

package/src/test/linked-claims.test.ts

@@ -0,0 +1,205 @@
+import { getLinkedClaimsPlugin } from '../index';
+import type { VC, VerificationCheck } from '@learncard/types';
+
+// Minimal mock LearnCard with just the surfaces the plugin uses
+const createMockLearnCard = () => {
+  const mock = {
+    id: { did: () => 'did:example:issuer' },
+    invoke: {
+      issueCredential: async (unsigned: any): Promise<VC> => ({
+        id: 'urn:uuid:endorsement-1',
+        ...unsigned,
+      }) as any,
+      verifyCredential: async (_vc: VC, _opts?: any): Promise<VerificationCheck> => ({
+        checks: [],
+        warnings: [],
+        errors: [],
+      }),
+    },
+    // Not used in these tests, but kept for completeness
+    store: { TestStore: { uploadEncrypted: async (_: any) => 'lc://test-uri' } },
+    index: {
+      LearnCloud: {
+        add: async (_: any) => true,
+        get: async (_: any) => [],
+      },
+    },
+    read: { get: async (_: string) => undefined },
+  } as unknown as any;
+
+  return mock;
+};
+
+const VC_V2 = 'https://www.w3.org/ns/credentials/v2';
+const OBV3 = 'https://purl.imsglobal.org/spec/ob/v3p0/context-3.0.3.json';
+
+const makeOriginalWithId = (): VC => ({
+  '@context': [VC_V2],
+  type: ['VerifiableCredential'],
+  issuer: 'did:example:someone',
+  validFrom: new Date().toISOString(),
+  credentialSubject: { id: 'did:example:subject-123' },
+  id: 'urn:uuid:original-123',
+} as any);
+
+const makeOriginalWithoutIdButSubject = (): VC => ({
+  '@context': [VC_V2],
+  type: ['VerifiableCredential'],
+  issuer: 'did:example:someone',
+  validFrom: new Date().toISOString(),
+  credentialSubject: { id: 'did:example:subject-abc' },
+} as any);
+
+const clone = <T>(obj: T): T => JSON.parse(JSON.stringify(obj));
+
+describe('LinkedClaims Plugin', () => {
+  test('endorseCredential: minimal (comment only) with original id', async () => {
+    const lc = createMockLearnCard();
+    const plugin = getLinkedClaimsPlugin(lc);
+
+    const original = makeOriginalWithId();
+
+    const endorsement = await plugin.methods.endorseCredential(
+      lc,
+      original,
+      { endorsementComment: 'Solid work' },
+      {}
+    );
+
+    const ctx = endorsement['@context'] as any[];
+    expect(Array.isArray(ctx)).toBe(true);
+    expect(ctx).toEqual(expect.arrayContaining([VC_V2, OBV3]));
+
+    const types = endorsement.type as string[];
+    expect(types).toEqual(expect.arrayContaining(['VerifiableCredential', 'EndorsementCredential']));
+
+    expect((endorsement as any).issuer).toBe('did:example:issuer');
+
+    const cs = (endorsement as any).credentialSubject;
+    const csObj = Array.isArray(cs) ? cs[0] : cs;
+    expect(csObj.id).toBe('urn:uuid:original-123'); // prefers original.id when present
+    expect(csObj.type).toEqual(expect.arrayContaining(['EndorsementSubject']));
+    expect(csObj.endorsementComment).toBe('Solid work');
+
+    // default name applied when not provided
+    expect((endorsement as any).name).toBe('Endorsement of urn:uuid:original-123');
+  });
+
+  test('endorseCredential: with name and description only, resolves subject id fallback', async () => {
+    const lc = createMockLearnCard();
+    const plugin = getLinkedClaimsPlugin(lc);
+    const original = makeOriginalWithoutIdButSubject();
+
+    const endorsement = await plugin.methods.endorseCredential(
+      lc,
+      original,
+      { name: 'Kudos', description: 'Peer endorsement' },
+      {}
+    );
+
+    const cs = (endorsement as any).credentialSubject;
+    const csObj = Array.isArray(cs) ? cs[0] : cs;
+    expect(csObj.id).toBe('did:example:subject-abc');
+    expect((endorsement as any).name).toBe('Kudos');
+    expect((endorsement as any).description).toBe('Peer endorsement');
+    expect(csObj.endorsementComment).toBeUndefined();
+  });
+
+  test('endorseCredential: throws if original lacks id and credentialSubject.id', async () => {
+    const lc = createMockLearnCard();
+    const plugin = getLinkedClaimsPlugin(lc);
+
+    const original = {
+      '@context': [VC_V2],
+      type: ['VerifiableCredential'],
+      issuer: 'did:example:none',
+      validFrom: new Date().toISOString(),
+      credentialSubject: {},
+    } as any as VC;
+
+    await expect(
+      plugin.methods.endorseCredential(lc, original, { endorsementComment: 'x' }, {})
+    ).rejects.toThrow('Original credential must have either id or credentialSubject.id');
+  });
+
+  test('verifyEndorsement: valid endorsement passes and adds linked-claims check', async () => {
+    const lc = createMockLearnCard();
+    const plugin = getLinkedClaimsPlugin(lc);
+    const original = makeOriginalWithId();
+
+    const endorsement = await plugin.methods.endorseCredential(lc, original, { endorsementComment: 'Nice' }, {});
+
+    const result = await plugin.methods.verifyEndorsement(lc, endorsement, {});
+    expect(result.errors).toHaveLength(0);
+    expect(result.checks).toEqual(expect.arrayContaining(['linked-claims']));
+  });
+
+  test('verifyEndorsement: missing OBv3 context -> error', async () => {
+    const lc = createMockLearnCard();
+    const plugin = getLinkedClaimsPlugin(lc);
+    const original = makeOriginalWithId();
+
+    const endorsement = await plugin.methods.endorseCredential(lc, original, { endorsementComment: 'x' }, {});
+    const bad = clone(endorsement);
+    (bad as any)['@context'] = [VC_V2];
+
+    const res = await plugin.methods.verifyEndorsement(lc, bad as any, {});
+    expect(res.errors.join(' ')).toMatch(/missing VCv2 or OBv3 context/);
+  });
+
+  test('verifyEndorsement: missing VC v2 context -> error', async () => {
+    const lc = createMockLearnCard();
+    const plugin = getLinkedClaimsPlugin(lc);
+    const original = makeOriginalWithId();
+
+    const endorsement = await plugin.methods.endorseCredential(lc, original, { endorsementComment: 'x' }, {});
+    const bad = clone(endorsement);
+    (bad as any)['@context'] = [OBV3];
+
+    const res = await plugin.methods.verifyEndorsement(lc, bad as any, {});
+    expect(res.errors.join(' ')).toMatch(/missing VCv2 or OBv3 context/);
+  });
+
+  test('verifyEndorsement: missing EndorsementCredential type -> error', async () => {
+    const lc = createMockLearnCard();
+    const plugin = getLinkedClaimsPlugin(lc);
+    const original = makeOriginalWithId();
+
+    const endorsement = await plugin.methods.endorseCredential(lc, original, { endorsementComment: 'x' }, {});
+    const bad = clone(endorsement);
+    (bad as any).type = ['VerifiableCredential'];
+
+    const res = await plugin.methods.verifyEndorsement(lc, bad as any, {});
+    expect(res.errors.join(' ')).toMatch(/missing EndorsementCredential type/);
+  });
+
+  test('verifyEndorsement: subject type missing EndorsementSubject -> error', async () => {
+    const lc = createMockLearnCard();
+    const plugin = getLinkedClaimsPlugin(lc);
+    const original = makeOriginalWithId();
+
+    const endorsement = await plugin.methods.endorseCredential(lc, original, { endorsementComment: 'x' }, {});
+    const bad = clone(endorsement);
+    const cs = (bad as any).credentialSubject;
+    const csObj = Array.isArray(cs) ? cs[0] : cs;
+    csObj.type = ['SomeOtherType'];
+
+    const res = await plugin.methods.verifyEndorsement(lc, bad as any, {});
+    expect(res.errors.join(' ')).toMatch(/credentialSubject\.type must include EndorsementSubject/);
+  });
+
+  test('verifyEndorsement: missing credentialSubject.id -> error', async () => {
+    const lc = createMockLearnCard();
+    const plugin = getLinkedClaimsPlugin(lc);
+    const original = makeOriginalWithId();
+
+    const endorsement = await plugin.methods.endorseCredential(lc, original, { endorsementComment: 'x' }, {});
+    const bad = clone(endorsement);
+    const cs = (bad as any).credentialSubject;
+    const csObj = Array.isArray(cs) ? cs[0] : cs;
+    delete csObj.id;
+
+    const res = await plugin.methods.verifyEndorsement(lc, bad as any, {});
+    expect(res.errors.join(' ')).toMatch(/credentialSubject\.id missing/);
+  });
+});

package/src/types.ts

@@ -0,0 +1,75 @@
+import { Plugin } from '@learncard/core';
+import { VC, VerificationCheck } from '@learncard/types';
+import { VCPluginMethods } from '@learncard/vc-plugin';
+import { ProofOptions } from '@learncard/didkit-plugin';
+
+export type EndorsementEvidence = {
+    id?: string;
+    type: string | [string, ...string[]]; // Changed from string[] to match VC2Evidence
+    name?: string;
+    narrative?: string;
+    description?: string;
+    genre?: string;
+    audience?: string;
+    [key: string]: any; // Allow additional properties
+};
+
+export type EndorsementDetails = {
+    // OBv3 Endorsement fields
+    endorsementComment?: string;
+    name?: string;
+    description?: string;
+    evidence?: EndorsementEvidence;
+};
+
+export type EndorsementRelationship = {
+    type: string;
+    label: string;
+};
+
+export type EndorsementVisibility = 'public' | 'private';
+
+export type StoreIndexOptions = {
+    storeName?: string;
+    indexName?: string;
+    credentialId?: string;
+    sharedUri?: string;
+    relationship?: EndorsementRelationship;
+    visibility?: EndorsementVisibility;
+};
+
+export type LinkedClaimsPluginDependentMethods = VCPluginMethods;
+
+export type LinkedClaimsPluginMethods = {
+    endorseCredential: (
+        original: VC,
+        details: EndorsementDetails,
+        options?: { contextUrl?: string }
+    ) => Promise<VC>;
+
+    verifyEndorsement: (
+        endorsement: VC,
+        options?: Partial<ProofOptions>
+    ) => Promise<VerificationCheck>;
+
+    storeEndorsement: (
+        endorsement: VC,
+        options?: StoreIndexOptions
+    ) => Promise<{
+        uri: string;
+        indexed: boolean;
+        id: string;
+        indexName?: string;
+        storeName?: string;
+    }>;
+
+    getEndorsements: (original: VC, options?: { indexName?: string }) => Promise<VC[]>;
+};
+
+export type LinkedClaimsPlugin = Plugin<
+    'LinkedClaims',
+    any,
+    LinkedClaimsPluginMethods,
+    'id' | 'store' | 'index' | 'read',
+    LinkedClaimsPluginDependentMethods
+>;

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Learning Economy Foundation <sdk@learningeconomy.io>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.