@aurabase/aurabase-js 0.3.0

package/packages/realtime/tests/dispatch.test.ts

@@ -0,0 +1,191 @@
+import { describe, it, expect, vi } from 'vitest'
+import { RealtimeService } from '../src/RealtimeService'
+import { AuraChannel } from '../src/AuraChannel'
+import { BaseAuthStore } from '@aurabase/core'
+import type { AuraClientLike } from '@aurabase/core'
+
+function client(): AuraClientLike {
+  return {
+    baseUrl: 'http://x',
+    projectId: 'proj',
+    apiKey: 'k',
+    authStore: new BaseAuthStore(),
+    fetchFn: (async () => new Response('{}')) as unknown as typeof globalThis.fetch,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    auth: { refreshSession: async () => ({ data: null, error: null }) as any },
+  }
+}
+
+describe('RealtimeService._dispatch — routage CDC borné par ":"', () => {
+  it('un event de `room2` ne fuite pas vers le channel `room` (préfixe)', () => {
+    const rt = new RealtimeService(client())
+    const room = new AuraChannel('room', 'proj')
+    const room2 = new AuraChannel('room2', 'proj')
+    // Insère `room` en PREMIER (l'ancien startsWith non borné l'aurait fait matcher d'abord).
+    const map = (rt as unknown as { _channels: Map<string, AuraChannel> })._channels
+    map.set('room', room)
+    map.set('room2', room2)
+    const spyRoom = vi.spyOn(room, '_onMessage').mockImplementation(() => {})
+    const spyRoom2 = vi.spyOn(room2, '_onMessage').mockImplementation(() => {})
+
+    // Message CDC : topic composite `proj:room2:public.x` (pas de channel exact de ce nom).
+    ;(rt as unknown as { _dispatch: (m: unknown) => void })._dispatch({
+      type: 'event',
+      id: '1',
+      event: 'insert',
+      topic: 'proj:room2:public.x',
+      payload: {},
+      timestamp: '',
+    })
+
+    expect(spyRoom2).toHaveBeenCalledTimes(1)
+    expect(spyRoom).not.toHaveBeenCalled()
+  })
+})
+
+describe('AuraChannel._dispatchEvent — fallback client filtre colonne (second rideau)', () => {
+  it("un event dont le record ne matche pas `filter` n'atteint pas le callback", () => {
+    const channel = new AuraChannel('room', 'proj')
+    const cb = vi.fn()
+    channel.on(
+      'postgres_changes',
+      { event: '*', schema: 'public', table: 'messages', filter: 'room_id=eq.42' },
+      cb,
+    )
+
+    channel._onMessage({
+      type: 'event',
+      id: '1',
+      event: 'insert',
+      topic: 'proj:room:public.messages',
+      payload: {
+        schema: 'public',
+        table: 'messages',
+        type: 'INSERT',
+        record: { room_id: 7 },
+        old_record: null,
+      },
+      timestamp: '',
+    })
+
+    expect(cb).not.toHaveBeenCalled()
+  })
+
+  it('un event dont le record matche `filter` atteint le callback', () => {
+    const channel = new AuraChannel('room', 'proj')
+    const cb = vi.fn()
+    channel.on(
+      'postgres_changes',
+      { event: '*', schema: 'public', table: 'messages', filter: 'room_id=eq.42' },
+      cb,
+    )
+
+    channel._onMessage({
+      type: 'event',
+      id: '2',
+      event: 'insert',
+      topic: 'proj:room:public.messages',
+      payload: {
+        schema: 'public',
+        table: 'messages',
+        type: 'INSERT',
+        record: { room_id: 42 },
+        old_record: null,
+      },
+      timestamp: '',
+    })
+
+    expect(cb).toHaveBeenCalledTimes(1)
+  })
+
+  it('DELETE : le filtre est évalué sur old_record (record CDC vide)', () => {
+    const channel = new AuraChannel('room', 'proj')
+    const matched = vi.fn()
+    const notMatched = vi.fn()
+    channel.on(
+      'postgres_changes',
+      { event: '*', schema: 'public', table: 'messages', filter: 'room_id=eq.42' },
+      matched,
+    )
+
+    channel._onMessage({
+      type: 'event',
+      id: '3',
+      event: 'delete',
+      topic: 'proj:room:public.messages',
+      payload: {
+        schema: 'public',
+        table: 'messages',
+        type: 'DELETE',
+        record: {},
+        old_record: { room_id: 42 },
+      },
+      timestamp: '',
+    })
+    expect(matched).toHaveBeenCalledTimes(1)
+
+    channel.on(
+      'postgres_changes',
+      { event: '*', schema: 'public', table: 'messages', filter: 'room_id=eq.42' },
+      notMatched,
+    )
+    channel._onMessage({
+      type: 'event',
+      id: '4',
+      event: 'delete',
+      topic: 'proj:room:public.messages',
+      payload: {
+        schema: 'public',
+        table: 'messages',
+        type: 'DELETE',
+        record: {},
+        old_record: { room_id: 7 },
+      },
+      timestamp: '',
+    })
+    expect(notMatched).not.toHaveBeenCalled()
+  })
+
+  it('cible absente/non-objet => ne filtre pas (le serveur a déjà filtré, pas de faux négatif)', () => {
+    const channel = new AuraChannel('room', 'proj')
+    const cb = vi.fn()
+    channel.on(
+      'postgres_changes',
+      { event: '*', schema: 'public', table: 'messages', filter: 'room_id=eq.42' },
+      cb,
+    )
+
+    channel._onMessage({
+      type: 'event',
+      id: '5',
+      event: 'insert',
+      topic: 'proj:room:public.messages',
+      payload: {
+        schema: 'public',
+        table: 'messages',
+        type: 'INSERT',
+        // pas de champ `record` du tout
+      },
+      timestamp: '',
+    })
+
+    expect(cb).toHaveBeenCalledTimes(1)
+  })
+
+  it('filtre absent (non défini) => pas de fallback appliqué, event livré normalement', () => {
+    const channel = new AuraChannel('room', 'proj')
+    const cb = vi.fn()
+    channel.on('postgres_changes', { event: '*', schema: 'public', table: 'messages' }, cb)
+
+    channel._onMessage({
+      type: 'event',
+      id: '6',
+      event: 'insert',
+      topic: 'proj:room:public.messages',
+      payload: { schema: 'public', table: 'messages', type: 'INSERT', record: { room_id: 999 } },
+      timestamp: '',
+    })
+
+    expect(cb).toHaveBeenCalledTimes(1)
+  })
+})

package/packages/realtime/tests/heartbeat.test.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect, vi, afterEach, beforeEach } from 'vitest'
+import { HeartbeatManager } from '../src/HeartbeatManager'
+
+class FakeWorker {
+  static instances: FakeWorker[] = []
+  onmessage: ((e: unknown) => void) | null = null
+  posted: unknown[] = []
+  terminated = false
+  constructor(public url: string) {
+    FakeWorker.instances.push(this)
+  }
+  postMessage(d: unknown) {
+    this.posted.push(d)
+  }
+  terminate() {
+    this.terminated = true
+  }
+}
+
+const g = globalThis as unknown as Record<string, unknown>
+let revoke: ReturnType<typeof vi.fn>
+
+beforeEach(() => {
+  FakeWorker.instances = []
+  revoke = vi.fn()
+  g.Worker = FakeWorker
+  g.URL = { createObjectURL: vi.fn(() => 'blob:x'), revokeObjectURL: revoke }
+})
+afterEach(() => {
+  vi.useRealTimers()
+  delete g.Worker
+  delete g.URL
+})
+
+describe('HeartbeatManager — Worker dédié', () => {
+  it('start() crée un Worker, ping au message worker, URL non révoquée avant stop', () => {
+    const hm = new HeartbeatManager()
+    const ping = vi.fn()
+    hm.start(ping, 25000)
+    expect(FakeWorker.instances.length).toBe(1)
+    expect(revoke).not.toHaveBeenCalled()
+    FakeWorker.instances[0].onmessage!({})
+    expect(ping).toHaveBeenCalledTimes(1)
+  })
+
+  it('stop() termine le worker et révoque l’URL', () => {
+    const hm = new HeartbeatManager()
+    hm.start(vi.fn())
+    hm.stop()
+    expect(FakeWorker.instances[0].terminated).toBe(true)
+    expect(revoke).toHaveBeenCalledWith('blob:x')
+    expect(hm.isActive).toBe(false)
+  })
+
+  it('sans Worker → fallback setInterval', () => {
+    delete g.Worker
+    vi.useFakeTimers()
+    const hm = new HeartbeatManager()
+    const ping = vi.fn()
+    hm.start(ping, 1000)
+    vi.advanceTimersByTime(1000)
+    expect(ping).toHaveBeenCalledTimes(1)
+    hm.stop()
+    vi.advanceTimersByTime(2000)
+    expect(ping).toHaveBeenCalledTimes(1)
+  })
+})

package/packages/realtime/tests/http-broadcast.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect, vi } from 'vitest'
+import { RealtimeService } from '../src/RealtimeService'
+import { BaseAuthStore } from '@aurabase/core'
+import type { AuraClientLike } from '@aurabase/core'
+
+type Captured = { url: string; init: RequestInit }
+
+function clientWithSpy(): { client: AuraClientLike; calls: Captured[] } {
+  const calls: Captured[] = []
+  const fetchFn = (async (url: string, init: RequestInit) => {
+    calls.push({ url, init })
+    return new Response(JSON.stringify({ data: null, meta: null }), {
+      status: 200,
+      headers: { 'content-type': 'application/json' },
+    })
+  }) as unknown as typeof globalThis.fetch
+  const store = new BaseAuthStore()
+  return {
+    calls,
+    client: {
+      baseUrl: 'http://x',
+      projectId: 'proj',
+      apiKey: 'k',
+      authStore: store,
+      fetchFn,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      auth: { refreshSession: async () => ({ data: null, error: null }) as any },
+    },
+  }
+}
+
+describe('RealtimeService.httpBroadcast — envoi REST hors WebSocket', () => {
+  it('POST /v1/realtime/{projectId}/broadcast avec corps { channel, payload:{event,...} } + apikey', async () => {
+    const { client, calls } = clientWithSpy()
+    const rt = new RealtimeService(client)
+
+    const res = await rt.httpBroadcast('room-1', 'ping', { a: 1 })
+
+    expect(res.error).toBeNull()
+    expect(calls).toHaveLength(1)
+    const { url, init } = calls[0]!
+    expect(url).toBe('http://x/v1/realtime/proj/broadcast')
+    expect(init.method).toBe('POST')
+    expect(JSON.parse(init.body as string)).toEqual({
+      channel: 'proj:room-1',
+      payload: { event: 'ping', a: 1 },
+    })
+    expect((init.headers as Record<string, string>)['apikey']).toBe('k')
+  })
+
+  it("ne préfixe pas deux fois un canal déjà préfixé par le projet", async () => {
+    const { client, calls } = clientWithSpy()
+    const rt = new RealtimeService(client)
+
+    await rt.httpBroadcast('proj:room-x', 'evt', {})
+
+    expect(JSON.parse(calls[0]!.init.body as string).channel).toBe('proj:room-x')
+  })
+
+  it("n'ouvre aucune connexion WebSocket", async () => {
+    const { client } = clientWithSpy()
+    const rt = new RealtimeService(client)
+
+    await rt.httpBroadcast('room-1', 'ping', {})
+
+    expect(rt.connectionState).toBe('disconnected')
+  })
+})

package/packages/realtime/tests/realtime-token.test.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect, vi } from 'vitest'
+import { RealtimeService } from '../src/RealtimeService'
+import { BaseAuthStore } from '@aurabase/core'
+import type { AuraClientLike } from '@aurabase/core'
+
+function makeClient(): AuraClientLike {
+  return {
+    baseUrl: 'http://x',
+    projectId: 'p',
+    apiKey: 'k',
+    fetchFn: (async () => new Response('{}')) as unknown as typeof globalThis.fetch,
+    authStore: new BaseAuthStore(), // vide → _scheduleTokenRefresh no-op
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    auth: { refreshSession: async () => ({ data: null, error: null }) as any },
+  }
+}
+
+describe('RealtimeService — propagation token différentielle', () => {
+  it('ne renvoie pas un token identique, renvoie un token changé', () => {
+    const rt = new RealtimeService(makeClient())
+    const send = vi
+      .spyOn(rt as unknown as { _send: (d: string) => void }, '_send')
+      .mockImplementation(() => {})
+    rt.refreshToken('t1')
+    expect(send).toHaveBeenCalledTimes(1)
+    rt.refreshToken('t1')
+    expect(send).toHaveBeenCalledTimes(1) // identique → pas renvoyé
+    rt.refreshToken('t2')
+    expect(send).toHaveBeenCalledTimes(2)
+  })
+
+  it('disconnect() réarme la propagation (renvoie le token après reconnexion)', () => {
+    const rt = new RealtimeService(makeClient())
+    const send = vi
+      .spyOn(rt as unknown as { _send: (d: string) => void }, '_send')
+      .mockImplementation(() => {})
+    rt.refreshToken('t1')
+    expect(send).toHaveBeenCalledTimes(1)
+    rt.disconnect()
+    rt.refreshToken('t1')
+    expect(send).toHaveBeenCalledTimes(2) // _lastSentToken reset → renvoyé
+  })
+})

package/packages/realtime/tests/reconnect-race.test.ts

@@ -0,0 +1,149 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { RealtimeService } from '../src/RealtimeService'
+import { BaseAuthStore } from '@aurabase/core'
+import type { AuraClientLike } from '@aurabase/core'
+
+/**
+ * Faux WebSocket contrôlable : les transitions (open/close) sont déclenchées
+ * manuellement pour reproduire de façon déterministe la race « stale onclose »
+ * (un ancien socket dont le onclose se déclenche APRÈS qu'un nouveau socket a
+ * été créé).
+ */
+class FakeWebSocket {
+  static readonly CONNECTING = 0
+  static readonly OPEN = 1
+  static readonly CLOSING = 2
+  static readonly CLOSED = 3
+  static instances: FakeWebSocket[] = []
+
+  url: string
+  readyState: number = FakeWebSocket.CONNECTING
+  onopen: (() => void) | null = null
+  onmessage: ((evt: { data: string }) => void) | null = null
+  onclose: (() => void) | null = null
+  onerror: ((evt: unknown) => void) | null = null
+  sent: string[] = []
+
+  constructor(url: string) {
+    this.url = url
+    FakeWebSocket.instances.push(this)
+  }
+
+  send(data: string): void {
+    this.sent.push(data)
+  }
+
+  close(): void {
+    this.readyState = FakeWebSocket.CLOSING
+  }
+
+  // ─── Helpers de test ───
+  fireOpen(): void {
+    this.readyState = FakeWebSocket.OPEN
+    this.onopen?.()
+  }
+
+  fireClose(): void {
+    this.readyState = FakeWebSocket.CLOSED
+    this.onclose?.()
+  }
+}
+
+function client(): AuraClientLike {
+  return {
+    baseUrl: 'http://x',
+    projectId: 'proj',
+    apiKey: 'k',
+    authStore: new BaseAuthStore(),
+    fetchFn: (async () => new Response('{}')) as unknown as typeof globalThis.fetch,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    auth: { refreshSession: async () => ({ data: null, error: null }) as any },
+  }
+}
+
+describe('RealtimeService — race « stale onclose »', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+    FakeWebSocket.instances = []
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ;(globalThis as any).WebSocket = FakeWebSocket
+  })
+
+  afterEach(() => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    delete (globalThis as any).WebSocket
+    vi.useRealTimers()
+    vi.restoreAllMocks()
+  })
+
+  it("le onclose tardif d'un ancien socket n'écrase PAS la connexion courante", () => {
+    const rt = new RealtimeService(client())
+    rt.setAutoReconnect(false) // isole le test du scheduler de reconnexion
+
+    rt.connect()
+    const ws1 = FakeWebSocket.instances[0]
+    ws1.fireOpen()
+    expect(rt.connectionState).toBe('connected')
+
+    // Déconnexion intentionnelle : ferme ws1, mais son onclose est différé.
+    rt.disconnect()
+    expect(rt.connectionState).toBe('disconnected')
+
+    // Une nouvelle connexion est établie AVANT que le onclose de ws1 n'arrive.
+    rt.connect()
+    const ws2 = FakeWebSocket.instances[1]
+    expect(ws2).toBeDefined()
+    ws2.fireOpen()
+    expect(rt.connectionState).toBe('connected')
+
+    // Le onclose TARDIF de l'ancien socket se déclenche maintenant.
+    ws1.fireClose()
+
+    // Il ne doit ni annuler l'état 'connected', ni détacher le nouveau socket.
+    expect(rt.connectionState).toBe('connected')
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expect((rt as any)._ws).toBe(ws2)
+  })
+
+  it('un socket périmé qui s\'ouvre tardivement est fermé et n\'active rien', () => {
+    const rt = new RealtimeService(client())
+    rt.setAutoReconnect(false)
+
+    rt.connect()
+    const ws1 = FakeWebSocket.instances[0]
+
+    // Avant que ws1 ne s'ouvre, on repart sur une nouvelle connexion.
+    rt.disconnect()
+    rt.connect()
+    const ws2 = FakeWebSocket.instances[1]
+    ws2.fireOpen()
+    expect(rt.connectionState).toBe('connected')
+
+    // ws1 (périmé) s'ouvre tardivement : doit être fermé, sans toucher l'état.
+    const closeSpy = vi.spyOn(ws1, 'close')
+    ws1.fireOpen()
+    expect(closeSpy).toHaveBeenCalled()
+    expect(rt.connectionState).toBe('connected')
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expect((rt as any)._ws).toBe(ws2)
+  })
+
+  it('après disconnect+reconnect, une coupure inattendue reconnecte bien (flag _intentionalClose non bloqué)', () => {
+    const rt = new RealtimeService(client())
+
+    rt.connect()
+    const ws1 = FakeWebSocket.instances[0]
+    ws1.fireOpen()
+
+    rt.disconnect() // pose _intentionalClose = true
+    rt.connect() // doit remettre le flag à false
+    const ws2 = FakeWebSocket.instances[1]
+    ws2.fireOpen()
+    expect(rt.connectionState).toBe('connected')
+
+    // Coupure inattendue de ws2 : doit repasser en 'reconnecting'
+    // (et non rester 'disconnected' à cause d'un flag resté à true).
+    ws2.fireClose()
+    expect(rt.connectionState).toBe('reconnecting')
+  })
+})

package/packages/realtime/tests/ref-id.test.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect, vi, afterEach } from 'vitest'
+import { AuraChannel } from '../src/AuraChannel'
+
+afterEach(() => vi.useRealTimers())
+
+describe('AuraChannel — ref_id global-unique', () => {
+  it('deux channels produisent des refs distincts préfixés par fullName', () => {
+    vi.useFakeTimers()
+    const a = new AuraChannel('a', 'p', { broadcast: { ack: true } })
+    const b = new AuraChannel('b', 'p', { broadcast: { ack: true } })
+    const sentA: Array<Record<string, unknown>> = []
+    const sentB: Array<Record<string, unknown>> = []
+    a._bindSend((d) => sentA.push(JSON.parse(d)))
+    b._bindSend((d) => sentB.push(JSON.parse(d)))
+
+    const pa = a.send({ type: 'broadcast', event: 'e', payload: {} })
+    const pb = b.send({ type: 'broadcast', event: 'e', payload: {} })
+
+    const rA = sentA[0].ref_id as string
+    const rB = sentB[0].ref_id as string
+    expect(rA).not.toBe(rB)
+    expect(rA.startsWith('p:a:')).toBe(true)
+    expect(rB.startsWith('p:b:')).toBe(true)
+
+    // broadcast_ack du ref de A → seul A résout ; le pending de B reste
+    a._onMessage({ type: 'broadcast_ack', ref_id: rA } as never)
+    return Promise.resolve().then(async () => {
+      await expect(pa).resolves.toBe('ok')
+      expect((b as unknown as { _pendingAcks: Map<string, unknown> })._pendingAcks.has(rB)).toBe(true)
+      vi.advanceTimersByTime(5000) // laisse pb timeout (nettoyage)
+      await expect(pb).resolves.toBe('timeout')
+    })
+  })
+})

package/packages/realtime/tests/set-auth.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect, vi } from 'vitest'
+import { RealtimeService } from '../src/RealtimeService'
+import { BaseAuthStore } from '@aurabase/core'
+import type { AuraClientLike } from '@aurabase/core'
+
+function makeClient(store = new BaseAuthStore()): AuraClientLike {
+  return {
+    baseUrl: 'http://x',
+    projectId: 'p',
+    apiKey: 'k',
+    fetchFn: (async () => new Response('{}')) as unknown as typeof globalThis.fetch,
+    authStore: store,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    auth: { refreshSession: async () => ({ data: null, error: null }) as any },
+  }
+}
+
+function spySend(rt: RealtimeService) {
+  return vi
+    .spyOn(rt as unknown as { _send: (d: string) => void }, '_send')
+    .mockImplementation(() => {})
+}
+
+describe('RealtimeService.setAuth — parité Supabase', () => {
+  it("setAuth(token) pousse un seul { type:'access_token', token } (dédupliqué)", () => {
+    const rt = new RealtimeService(makeClient())
+    const send = spySend(rt)
+
+    rt.setAuth('tok')
+    expect(send).toHaveBeenCalledTimes(1)
+    expect(JSON.parse(send.mock.calls[0]![0] as string)).toEqual({
+      type: 'access_token',
+      token: 'tok',
+    })
+
+    // Second appel identique → pas de renvoi (déduplication _lastSentToken).
+    rt.setAuth('tok')
+    expect(send).toHaveBeenCalledTimes(1)
+  })
+
+  it('setAuth() sans argument reprend client.authStore.token', () => {
+    const store = new BaseAuthStore()
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    store.save('from-store', 'r', {} as any)
+    const rt = new RealtimeService(makeClient(store))
+    const send = spySend(rt)
+
+    rt.setAuth()
+
+    expect(send).toHaveBeenCalledTimes(1)
+    expect(JSON.parse(send.mock.calls[0]![0] as string)).toEqual({
+      type: 'access_token',
+      token: 'from-store',
+    })
+  })
+
+  it("setAuth() no-op si aucun token disponible", () => {
+    const rt = new RealtimeService(makeClient())
+    const send = spySend(rt)
+    rt.setAuth()
+    expect(send).not.toHaveBeenCalled()
+  })
+
+  it('ne provoque aucune reconnexion WS', () => {
+    const rt = new RealtimeService(makeClient())
+    spySend(rt)
+    rt.setAuth('tok')
+    expect(rt.connectionState).toBe('disconnected')
+  })
+})

package/packages/realtime/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": { "outDir": "dist", "rootDir": "src" },
+  "include": ["src"]
+}

package/packages/realtime/tsup.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['cjs', 'esm'],
+  dts: true,
+  splitting: false,
+  clean: true,
+  treeshake: true,
+  minify: false,
+})

package/packages/storage/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aurabase
+
+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.