llama-stack-client 0.4.3 → 0.4.5

package/tests/qs/utils.test.ts

@@ -0,0 +1,175 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+// All rights reserved.
+//
+// This source code is licensed under the terms described in the LICENSE file in
+// the root directory of this source tree.
+
+import { combine, merge, is_buffer, assign_single_source } from 'llama-stack-client/internal/qs/utils';
+
+describe('merge()', function () {
+  // t.deepEqual(merge(null, true), [null, true], 'merges true into null');
+  expect(merge(null, true)).toEqual([null, true]);
+
+  // t.deepEqual(merge(null, [42]), [null, 42], 'merges null into an array');
+  expect(merge(null, [42])).toEqual([null, 42]);
+
+  // t.deepEqual(
+  // 	merge({ a: 'b' }, { a: 'c' }),
+  // 	{ a: ['b', 'c'] },
+  // 	'merges two objects with the same key',
+  // );
+  expect(merge({ a: 'b' }, { a: 'c' })).toEqual({ a: ['b', 'c'] });
+
+  var oneMerged = merge({ foo: 'bar' }, { foo: { first: '123' } });
+  // t.deepEqual(
+  // 	oneMerged,
+  // 	{ foo: ['bar', { first: '123' }] },
+  // 	'merges a standalone and an object into an array',
+  // );
+  expect(oneMerged).toEqual({ foo: ['bar', { first: '123' }] });
+
+  var twoMerged = merge({ foo: ['bar', { first: '123' }] }, { foo: { second: '456' } });
+  // t.deepEqual(
+  // 	twoMerged,
+  // 	{ foo: { 0: 'bar', 1: { first: '123' }, second: '456' } },
+  // 	'merges a standalone and two objects into an array',
+  // );
+  expect(twoMerged).toEqual({ foo: { 0: 'bar', 1: { first: '123' }, second: '456' } });
+
+  var sandwiched = merge({ foo: ['bar', { first: '123', second: '456' }] }, { foo: 'baz' });
+  // t.deepEqual(
+  // 	sandwiched,
+  // 	{ foo: ['bar', { first: '123', second: '456' }, 'baz'] },
+  // 	'merges an object sandwiched by two standalones into an array',
+  // );
+  expect(sandwiched).toEqual({ foo: ['bar', { first: '123', second: '456' }, 'baz'] });
+
+  var nestedArrays = merge({ foo: ['baz'] }, { foo: ['bar', 'xyzzy'] });
+  // t.deepEqual(nestedArrays, { foo: ['baz', 'bar', 'xyzzy'] });
+  expect(nestedArrays).toEqual({ foo: ['baz', 'bar', 'xyzzy'] });
+
+  var noOptionsNonObjectSource = merge({ foo: 'baz' }, 'bar');
+  // t.deepEqual(noOptionsNonObjectSource, { foo: 'baz', bar: true });
+  expect(noOptionsNonObjectSource).toEqual({ foo: 'baz', bar: true });
+
+  (typeof Object.defineProperty !== 'function' ? test.skip : test)(
+    'avoids invoking array setters unnecessarily',
+    function () {
+      var setCount = 0;
+      var getCount = 0;
+      var observed: any[] = [];
+      Object.defineProperty(observed, 0, {
+        get: function () {
+          getCount += 1;
+          return { bar: 'baz' };
+        },
+        set: function () {
+          setCount += 1;
+        },
+      });
+      merge(observed, [null]);
+      // st.equal(setCount, 0);
+      // st.equal(getCount, 1);
+      expect(setCount).toEqual(0);
+      expect(getCount).toEqual(1);
+      observed[0] = observed[0]; // eslint-disable-line no-self-assign
+      // st.equal(setCount, 1);
+      // st.equal(getCount, 2);
+      expect(setCount).toEqual(1);
+      expect(getCount).toEqual(2);
+    },
+  );
+});
+
+test('assign()', function () {
+  var target = { a: 1, b: 2 };
+  var source = { b: 3, c: 4 };
+  var result = assign_single_source(target, source);
+
+  expect(result).toEqual(target);
+  expect(target).toEqual({ a: 1, b: 3, c: 4 });
+  expect(source).toEqual({ b: 3, c: 4 });
+});
+
+describe('combine()', function () {
+  test('both arrays', function () {
+    var a = [1];
+    var b = [2];
+    var combined = combine(a, b);
+
+    // st.deepEqual(a, [1], 'a is not mutated');
+    // st.deepEqual(b, [2], 'b is not mutated');
+    // st.notEqual(a, combined, 'a !== combined');
+    // st.notEqual(b, combined, 'b !== combined');
+    // st.deepEqual(combined, [1, 2], 'combined is a + b');
+    expect(a).toEqual([1]);
+    expect(b).toEqual([2]);
+    expect(combined).toEqual([1, 2]);
+    expect(a).not.toEqual(combined);
+    expect(b).not.toEqual(combined);
+  });
+
+  test('one array, one non-array', function () {
+    var aN = 1;
+    var a = [aN];
+    var bN = 2;
+    var b = [bN];
+
+    var combinedAnB = combine(aN, b);
+    // st.deepEqual(b, [bN], 'b is not mutated');
+    // st.notEqual(aN, combinedAnB, 'aN + b !== aN');
+    // st.notEqual(a, combinedAnB, 'aN + b !== a');
+    // st.notEqual(bN, combinedAnB, 'aN + b !== bN');
+    // st.notEqual(b, combinedAnB, 'aN + b !== b');
+    // st.deepEqual([1, 2], combinedAnB, 'first argument is array-wrapped when not an array');
+    expect(b).toEqual([bN]);
+    expect(combinedAnB).not.toEqual(aN);
+    expect(combinedAnB).not.toEqual(a);
+    expect(combinedAnB).not.toEqual(bN);
+    expect(combinedAnB).not.toEqual(b);
+    expect(combinedAnB).toEqual([1, 2]);
+
+    var combinedABn = combine(a, bN);
+    // st.deepEqual(a, [aN], 'a is not mutated');
+    // st.notEqual(aN, combinedABn, 'a + bN !== aN');
+    // st.notEqual(a, combinedABn, 'a + bN !== a');
+    // st.notEqual(bN, combinedABn, 'a + bN !== bN');
+    // st.notEqual(b, combinedABn, 'a + bN !== b');
+    // st.deepEqual([1, 2], combinedABn, 'second argument is array-wrapped when not an array');
+    expect(a).toEqual([aN]);
+    expect(combinedABn).not.toEqual(aN);
+    expect(combinedABn).not.toEqual(a);
+    expect(combinedABn).not.toEqual(bN);
+    expect(combinedABn).not.toEqual(b);
+    expect(combinedABn).toEqual([1, 2]);
+  });
+
+  test('neither is an array', function () {
+    var combined = combine(1, 2);
+    // st.notEqual(1, combined, '1 + 2 !== 1');
+    // st.notEqual(2, combined, '1 + 2 !== 2');
+    // st.deepEqual([1, 2], combined, 'both arguments are array-wrapped when not an array');
+    expect(combined).not.toEqual(1);
+    expect(combined).not.toEqual(2);
+    expect(combined).toEqual([1, 2]);
+  });
+});
+
+test('is_buffer()', function () {
+  for (const x of [null, undefined, true, false, '', 'abc', 42, 0, NaN, {}, [], function () {}, /a/g]) {
+    // t.equal(is_buffer(x), false, inspect(x) + ' is not a buffer');
+    expect(is_buffer(x)).toEqual(false);
+  }
+
+  var fakeBuffer = { constructor: Buffer };
+  // t.equal(is_buffer(fakeBuffer), false, 'fake buffer is not a buffer');
+  expect(is_buffer(fakeBuffer)).toEqual(false);
+
+  var saferBuffer = Buffer.from('abc');
+  // t.equal(is_buffer(saferBuffer), true, 'SaferBuffer instance is a buffer');
+  expect(is_buffer(saferBuffer)).toEqual(true);
+
+  var buffer = Buffer.from('abc');
+  // t.equal(is_buffer(buffer), true, 'real Buffer instance is a buffer');
+  expect(is_buffer(buffer)).toEqual(true);
+});

package/tests/responses.test.ts

@@ -0,0 +1,91 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+// All rights reserved.
+//
+// This source code is licensed under the terms described in the LICENSE file in
+// the root directory of this source tree.
+
+import { getResponseOutputText } from 'llama-stack-client';
+import { createResponseHeaders } from 'llama-stack-client/core';
+import { Headers } from 'llama-stack-client/_shims/index';
+
+describe('response parsing', () => {
+  // TODO: test unicode characters
+  test('headers are case agnostic', async () => {
+    const headers = createResponseHeaders(new Headers({ 'Content-Type': 'foo', Accept: 'text/plain' }));
+    expect(headers['content-type']).toEqual('foo');
+    expect(headers['Content-type']).toEqual('foo');
+    expect(headers['Content-Type']).toEqual('foo');
+    expect(headers['accept']).toEqual('text/plain');
+    expect(headers['Accept']).toEqual('text/plain');
+    expect(headers['Hello-World']).toBeUndefined();
+  });
+
+  test('duplicate headers are concatenated', () => {
+    const headers = createResponseHeaders(
+      new Headers([
+        ['Content-Type', 'text/xml'],
+        ['Content-Type', 'application/json'],
+      ]),
+    );
+    expect(headers['content-type']).toBe('text/xml, application/json');
+  });
+});
+
+describe('getResponseOutputText helper', () => {
+  test('can be imported from package entry point and concatenates text', () => {
+    const response = {
+      id: 'resp_123',
+      created_at: 0,
+      model: 'llama-example',
+      status: 'completed',
+      output: [
+        {
+          type: 'message',
+          role: 'assistant',
+          content: [
+            { type: 'output_text', text: 'Hello ' },
+            { type: 'output_text', text: 'world' },
+          ],
+        },
+        {
+          type: 'message',
+          role: 'assistant',
+          content: '!',
+        },
+      ],
+    };
+
+    expect(getResponseOutputText(response as any)).toBe('Hello world!');
+  });
+});
+
+describe('getResponseOutputText package export', () => {
+  test('allows streaming responses to be flattened when imported from llama-stack-client', () => {
+    const response = {
+      id: 'resp_stream',
+      created_at: 0,
+      model: 'llama-example',
+      status: 'completed',
+      output: [
+        {
+          type: 'message',
+          role: 'assistant',
+          content: [
+            'Streaming ',
+            { type: 'output_text', text: 'chunks ' },
+            { type: 'output_text', text: 'are ' },
+            { type: 'output_text', text: 'supported.' },
+          ],
+        },
+        {
+          type: 'message',
+          role: 'assistant',
+          content: ' Enjoy!',
+        },
+      ],
+    };
+
+    expect(typeof getResponseOutputText).toBe('function');
+    expect(getResponseOutputText(response as any)).toBe('Streaming chunks are supported. Enjoy!');
+  });
+});

package/tests/streaming.test.ts

@@ -0,0 +1,250 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+// All rights reserved.
+//
+// This source code is licensed under the terms described in the LICENSE file in
+// the root directory of this source tree.
+
+import { Response } from 'node-fetch';
+import { PassThrough } from 'stream';
+import assert from 'assert';
+import { _iterSSEMessages } from 'llama-stack-client/streaming';
+
+describe('streaming decoding', () => {
+  test('basic', async () => {
+    async function* body(): AsyncGenerator<Buffer> {
+      yield Buffer.from('event: completion\n');
+      yield Buffer.from('data: {"foo":true}\n');
+      yield Buffer.from('\n');
+    }
+
+    const stream = _iterSSEMessages(new Response(await iteratorToStream(body())), new AbortController())[
+      Symbol.asyncIterator
+    ]();
+
+    let event = await stream.next();
+    assert(event.value);
+    expect(JSON.parse(event.value.data)).toEqual({ foo: true });
+
+    event = await stream.next();
+    expect(event.done).toBeTruthy();
+  });
+
+  test('data without event', async () => {
+    async function* body(): AsyncGenerator<Buffer> {
+      yield Buffer.from('data: {"foo":true}\n');
+      yield Buffer.from('\n');
+    }
+
+    const stream = _iterSSEMessages(new Response(await iteratorToStream(body())), new AbortController())[
+      Symbol.asyncIterator
+    ]();
+
+    let event = await stream.next();
+    assert(event.value);
+    expect(event.value.event).toBeNull();
+    expect(JSON.parse(event.value.data)).toEqual({ foo: true });
+
+    event = await stream.next();
+    expect(event.done).toBeTruthy();
+  });
+
+  test('event without data', async () => {
+    async function* body(): AsyncGenerator<Buffer> {
+      yield Buffer.from('event: foo\n');
+      yield Buffer.from('\n');
+    }
+
+    const stream = _iterSSEMessages(new Response(await iteratorToStream(body())), new AbortController())[
+      Symbol.asyncIterator
+    ]();
+
+    let event = await stream.next();
+    assert(event.value);
+    expect(event.value.event).toEqual('foo');
+    expect(event.value.data).toEqual('');
+
+    event = await stream.next();
+    expect(event.done).toBeTruthy();
+  });
+
+  test('multiple events', async () => {
+    async function* body(): AsyncGenerator<Buffer> {
+      yield Buffer.from('event: foo\n');
+      yield Buffer.from('\n');
+      yield Buffer.from('event: ping\n');
+      yield Buffer.from('\n');
+    }
+
+    const stream = _iterSSEMessages(new Response(await iteratorToStream(body())), new AbortController())[
+      Symbol.asyncIterator
+    ]();
+
+    let event = await stream.next();
+    assert(event.value);
+    expect(event.value.event).toEqual('foo');
+    expect(event.value.data).toEqual('');
+
+    event = await stream.next();
+    assert(event.value);
+    expect(event.value.event).toEqual('ping');
+    expect(event.value.data).toEqual('');
+
+    event = await stream.next();
+    expect(event.done).toBeTruthy();
+  });
+
+  test('multiple events with data', async () => {
+    async function* body(): AsyncGenerator<Buffer> {
+      yield Buffer.from('event: foo\n');
+      yield Buffer.from('data: {"foo":true}\n');
+      yield Buffer.from('\n');
+      yield Buffer.from('event: ping\n');
+      yield Buffer.from('data: {"bar":false}\n');
+      yield Buffer.from('\n');
+    }
+
+    const stream = _iterSSEMessages(new Response(await iteratorToStream(body())), new AbortController())[
+      Symbol.asyncIterator
+    ]();
+
+    let event = await stream.next();
+    assert(event.value);
+    expect(event.value.event).toEqual('foo');
+    expect(JSON.parse(event.value.data)).toEqual({ foo: true });
+
+    event = await stream.next();
+    assert(event.value);
+    expect(event.value.event).toEqual('ping');
+    expect(JSON.parse(event.value.data)).toEqual({ bar: false });
+
+    event = await stream.next();
+    expect(event.done).toBeTruthy();
+  });
+
+  test('multiple data lines with empty line', async () => {
+    async function* body(): AsyncGenerator<Buffer> {
+      yield Buffer.from('event: ping\n');
+      yield Buffer.from('data: {\n');
+      yield Buffer.from('data: "foo":\n');
+      yield Buffer.from('data: \n');
+      yield Buffer.from('data:\n');
+      yield Buffer.from('data: true}\n');
+      yield Buffer.from('\n\n');
+    }
+
+    const stream = _iterSSEMessages(new Response(await iteratorToStream(body())), new AbortController())[
+      Symbol.asyncIterator
+    ]();
+
+    let event = await stream.next();
+    assert(event.value);
+    expect(event.value.event).toEqual('ping');
+    expect(JSON.parse(event.value.data)).toEqual({ foo: true });
+    expect(event.value.data).toEqual('{\n"foo":\n\n\ntrue}');
+
+    event = await stream.next();
+    expect(event.done).toBeTruthy();
+  });
+
+  test('data json escaped double new line', async () => {
+    async function* body(): AsyncGenerator<Buffer> {
+      yield Buffer.from('event: ping\n');
+      yield Buffer.from('data: {"foo": "my long\\n\\ncontent"}');
+      yield Buffer.from('\n\n');
+    }
+
+    const stream = _iterSSEMessages(new Response(await iteratorToStream(body())), new AbortController())[
+      Symbol.asyncIterator
+    ]();
+
+    let event = await stream.next();
+    assert(event.value);
+    expect(event.value.event).toEqual('ping');
+    expect(JSON.parse(event.value.data)).toEqual({ foo: 'my long\n\ncontent' });
+
+    event = await stream.next();
+    expect(event.done).toBeTruthy();
+  });
+
+  test('special new line characters', async () => {
+    async function* body(): AsyncGenerator<Buffer> {
+      yield Buffer.from('data: {"content": "culpa "}\n');
+      yield Buffer.from('\n');
+      yield Buffer.from('data: {"content": "');
+      yield Buffer.from([0xe2, 0x80, 0xa8]);
+      yield Buffer.from('"}\n');
+      yield Buffer.from('\n');
+      yield Buffer.from('data: {"content": "foo"}\n');
+      yield Buffer.from('\n');
+    }
+
+    const stream = _iterSSEMessages(new Response(await iteratorToStream(body())), new AbortController())[
+      Symbol.asyncIterator
+    ]();
+
+    let event = await stream.next();
+    assert(event.value);
+    expect(JSON.parse(event.value.data)).toEqual({ content: 'culpa ' });
+
+    event = await stream.next();
+    assert(event.value);
+    expect(JSON.parse(event.value.data)).toEqual({ content: Buffer.from([0xe2, 0x80, 0xa8]).toString() });
+
+    event = await stream.next();
+    assert(event.value);
+    expect(JSON.parse(event.value.data)).toEqual({ content: 'foo' });
+
+    event = await stream.next();
+    expect(event.done).toBeTruthy();
+  });
+
+  test('multi-byte characters across chunks', async () => {
+    async function* body(): AsyncGenerator<Buffer> {
+      yield Buffer.from('event: completion\n');
+      yield Buffer.from('data: {"content": "');
+      // bytes taken from the string 'известни' and arbitrarily split
+      // so that some multi-byte characters span multiple chunks
+      yield Buffer.from([0xd0]);
+      yield Buffer.from([0xb8, 0xd0, 0xb7, 0xd0]);
+      yield Buffer.from([0xb2, 0xd0, 0xb5, 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xbd, 0xd0, 0xb8]);
+      yield Buffer.from('"}\n');
+      yield Buffer.from('\n');
+    }
+
+    const stream = _iterSSEMessages(new Response(await iteratorToStream(body())), new AbortController())[
+      Symbol.asyncIterator
+    ]();
+
+    let event = await stream.next();
+    assert(event.value);
+    expect(event.value.event).toEqual('completion');
+    expect(JSON.parse(event.value.data)).toEqual({ content: 'известни' });
+
+    event = await stream.next();
+    expect(event.done).toBeTruthy();
+  });
+});
+
+async function iteratorToStream(iterator: AsyncGenerator<any>): Promise<PassThrough> {
+  const parts: unknown[] = [];
+
+  for await (const chunk of iterator) {
+    parts.push(chunk);
+  }
+
+  let index = 0;
+
+  const stream = new PassThrough({
+    read() {
+      const value = parts[index];
+      if (value === undefined) {
+        stream.end();
+      } else {
+        index += 1;
+        stream.write(value);
+      }
+    },
+  });
+
+  return stream;
+}

package/tests/stringifyQuery.test.ts

@@ -0,0 +1,29 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+// All rights reserved.
+//
+// This source code is licensed under the terms described in the LICENSE file in
+// the root directory of this source tree.
+//
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { LlamaStackClient } from 'llama-stack-client';
+
+const { stringifyQuery } = LlamaStackClient.prototype as any;
+
+describe(stringifyQuery, () => {
+  for (const [input, expected] of [
+    [{ a: '1', b: 2, c: true }, 'a=1&b=2&c=true'],
+    [{ a: null, b: false, c: undefined }, 'a=&b=false'],
+    [{ 'a/b': 1.28341 }, `${encodeURIComponent('a/b')}=1.28341`],
+    [
+      { 'a/b': 'c/d', 'e=f': 'g&h' },
+      `${encodeURIComponent('a/b')}=${encodeURIComponent('c/d')}&${encodeURIComponent(
+        'e=f',
+      )}=${encodeURIComponent('g&h')}`,
+    ],
+  ]) {
+    it(`${JSON.stringify(input)} -> ${expected}`, () => {
+      expect(stringifyQuery(input)).toEqual(expected);
+    });
+  }
+});

package/tests/uploads.test.ts

@@ -0,0 +1,71 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+// All rights reserved.
+//
+// This source code is licensed under the terms described in the LICENSE file in
+// the root directory of this source tree.
+
+import fs from 'fs';
+import { toFile, type ResponseLike } from 'llama-stack-client/uploads';
+import { File } from 'llama-stack-client/_shims/index';
+
+class MyClass {
+  name: string = 'foo';
+}
+
+function mockResponse({ url, content }: { url: string; content?: Blob }): ResponseLike {
+  return {
+    url,
+    blob: async () => content as any,
+  };
+}
+
+describe('toFile', () => {
+  it('throws a helpful error for mismatched types', async () => {
+    await expect(
+      // @ts-expect-error intentionally mismatched type
+      toFile({ foo: 'string' }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `"Unexpected data type: object; constructor: Object; props: ["foo"]"`,
+    );
+
+    await expect(
+      // @ts-expect-error intentionally mismatched type
+      toFile(new MyClass()),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `"Unexpected data type: object; constructor: MyClass; props: ["name"]"`,
+    );
+  });
+
+  it('disallows string at the type-level', async () => {
+    // @ts-expect-error we intentionally do not type support for `string`
+    // to help people avoid passing a file path
+    const file = await toFile('contents');
+    expect(file.text()).resolves.toEqual('contents');
+  });
+
+  it('extracts a file name from a Response', async () => {
+    const response = mockResponse({ url: 'https://example.com/my/audio.mp3' });
+    const file = await toFile(response);
+    expect(file.name).toEqual('audio.mp3');
+  });
+
+  it('extracts a file name from a File', async () => {
+    const input = new File(['foo'], 'input.jsonl');
+    const file = await toFile(input);
+    expect(file.name).toEqual('input.jsonl');
+  });
+
+  it('extracts a file name from a ReadStream', async () => {
+    const input = fs.createReadStream('tests/uploads.test.ts');
+    const file = await toFile(input);
+    expect(file.name).toEqual('uploads.test.ts');
+  });
+
+  it('does not copy File objects', async () => {
+    const input = new File(['foo'], 'input.jsonl', { type: 'jsonl' });
+    const file = await toFile(input);
+    expect(file).toBe(input);
+    expect(file.name).toEqual('input.jsonl');
+    expect(file.type).toBe('jsonl');
+  });
+});

package/tsc-multi.json

@@ -0,0 +1,7 @@
+{
+  "targets": [
+    { "extname": ".js", "module": "commonjs" },
+    { "extname": ".mjs", "module": "esnext" }
+  ],
+  "projects": ["tsconfig.build.json"]
+}

package/tsconfig.build.json

@@ -0,0 +1,18 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["dist/src"],
+  "exclude": ["dist/src/_shims/*-deno.ts"],
+  "compilerOptions": {
+    "rootDir": "./dist/src",
+    "paths": {
+      "llama-stack-client/*": ["./dist/src/*"],
+      "llama-stack-client": ["./dist/src/index.ts"]
+    },
+    "noEmit": false,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "dist",
+    "pretty": true,
+    "sourceMap": true
+  }
+}

package/tsconfig.deno.json

@@ -0,0 +1,15 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["dist-deno"],
+  "exclude": [],
+  "compilerOptions": {
+    "rootDir": "./dist-deno",
+    "lib": ["es2020", "DOM"],
+    "noEmit": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "dist-deno",
+    "pretty": true,
+    "sourceMap": true
+  }
+}

package/tsconfig.dist-src.json

@@ -0,0 +1,11 @@
+{
+  // this config is included in the published src directory to prevent TS errors
+  // from appearing when users go to source, and VSCode opens the source .ts file
+  // via declaration maps
+  "include": ["index.ts"],
+  "compilerOptions": {
+    "target": "es2015",
+    "lib": ["DOM"],
+    "moduleResolution": "node"
+  }
+}