tunzo-player 1.0.0

package/dist/core/api-calles.d.ts

@@ -0,0 +1,9 @@
+export declare class TunzoPlayerAPI {
+    /**
+     * Search for songs using the saavn.dev API
+     * @param query Search keyword (e.g., artist name, song name)
+     * @param limit Number of results to return (default: 250)
+     * @returns Array of song result objects
+     */
+    searchSongs(query: string, limit?: number): Promise<any[]>;
+}

package/dist/core/api-calles.js

@@ -0,0 +1,38 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TunzoPlayerAPI = void 0;
+class TunzoPlayerAPI {
+    /**
+     * Search for songs using the saavn.dev API
+     * @param query Search keyword (e.g., artist name, song name)
+     * @param limit Number of results to return (default: 250)
+     * @returns Array of song result objects
+     */
+    searchSongs(query_1) {
+        return __awaiter(this, arguments, void 0, function* (query, limit = 250) {
+            var _a;
+            try {
+                const response = yield fetch(`https://saavn.dev/api/search/songs?query=${encodeURIComponent(query)}&limit=${limit}`);
+                if (!response.ok) {
+                    throw new Error(`HTTP error! status: ${response.status}`);
+                }
+                const json = yield response.json();
+                return ((_a = json === null || json === void 0 ? void 0 : json.data) === null || _a === void 0 ? void 0 : _a.results) || [];
+            }
+            catch (error) {
+                console.error("TunzoPlayerAPI Error:", error);
+                return [];
+            }
+        });
+    }
+}
+exports.TunzoPlayerAPI = TunzoPlayerAPI;

package/dist/core/player.d.ts

@@ -0,0 +1,35 @@
+export declare class Player {
+    private static audio;
+    private static currentSong;
+    private static currentIndex;
+    private static isPlaying;
+    private static currentTime;
+    private static duration;
+    private static isShuffle;
+    private static queue;
+    private static playlist;
+    private static selectedQuality;
+    /** Initialize with playlist and quality */
+    static initialize(playlist: any[], quality?: number): void;
+    static play(song: any, index?: number): void;
+    static pause(): void;
+    static resume(): void;
+    static togglePlayPause(): void;
+    static next(): void;
+    static prev(): void;
+    static seek(seconds: number): void;
+    static autoNext(): void;
+    static playRandom(): void;
+    static toggleShuffle(): void;
+    static addToQueue(song: any): void;
+    static removeFromQueue(index: number): void;
+    static reorderQueue(from: number, to: number): void;
+    static getCurrentTime(): number;
+    static getDuration(): number;
+    static formatTime(time: number): string;
+    static isPlayingSong(): boolean;
+    static getCurrentSong(): any;
+    static setQuality(index: number): void;
+    static getQueue(): any[];
+    static getPlaylist(): any[];
+}

package/dist/core/player.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Player = void 0;
+class Player {
+    /** Initialize with playlist and quality */
+    static initialize(playlist, quality = 3) {
+        this.playlist = playlist;
+        this.selectedQuality = quality;
+    }
+    static play(song, index = 0) {
+        var _a;
+        if (!song || !song.downloadUrl)
+            return;
+        this.currentSong = song;
+        this.currentIndex = index;
+        this.audio.src = ((_a = song.downloadUrl[this.selectedQuality]) === null || _a === void 0 ? void 0 : _a.url) || '';
+        this.audio.play();
+        this.isPlaying = true;
+        // Set duration
+        this.audio.onloadedmetadata = () => {
+            this.duration = this.audio.duration;
+        };
+        // Set current time
+        this.audio.ontimeupdate = () => {
+            this.currentTime = this.audio.currentTime;
+        };
+        // Auto-play next song
+        this.audio.onended = () => {
+            this.autoNext();
+        };
+    }
+    static pause() {
+        this.audio.pause();
+        this.isPlaying = false;
+    }
+    static resume() {
+        this.audio.play();
+        this.isPlaying = true;
+    }
+    static togglePlayPause() {
+        if (this.isPlaying) {
+            this.pause();
+        }
+        else {
+            this.resume();
+        }
+    }
+    static next() {
+        if (this.queue.length > 0) {
+            const nextQueued = this.queue.shift();
+            const index = this.playlist.findIndex(s => s.id === nextQueued.id);
+            this.play(nextQueued, index);
+        }
+        else if (this.isShuffle) {
+            this.playRandom();
+        }
+        else if (this.currentIndex < this.playlist.length - 1) {
+            this.play(this.playlist[this.currentIndex + 1], this.currentIndex + 1);
+        }
+    }
+    static prev() {
+        if (this.currentIndex > 0) {
+            this.play(this.playlist[this.currentIndex - 1], this.currentIndex - 1);
+        }
+    }
+    static seek(seconds) {
+        this.audio.currentTime = seconds;
+    }
+    static autoNext() {
+        this.next();
+    }
+    static playRandom() {
+        if (this.playlist.length <= 1)
+            return;
+        let randomIndex;
+        do {
+            randomIndex = Math.floor(Math.random() * this.playlist.length);
+        } while (randomIndex === this.currentIndex);
+        this.play(this.playlist[randomIndex], randomIndex);
+    }
+    static toggleShuffle() {
+        this.isShuffle = !this.isShuffle;
+    }
+    static addToQueue(song) {
+        if (!this.queue.some(q => q.id === song.id)) {
+            this.queue.push(song);
+        }
+    }
+    static removeFromQueue(index) {
+        this.queue.splice(index, 1);
+    }
+    static reorderQueue(from, to) {
+        const item = this.queue.splice(from, 1)[0];
+        this.queue.splice(to, 0, item);
+    }
+    static getCurrentTime() {
+        return this.currentTime;
+    }
+    static getDuration() {
+        return this.duration;
+    }
+    static formatTime(time) {
+        const minutes = Math.floor(time / 60);
+        const seconds = Math.floor(time % 60);
+        return `${minutes}:${seconds < 10 ? '0' : ''}${seconds}`;
+    }
+    static isPlayingSong() {
+        return this.isPlaying;
+    }
+    static getCurrentSong() {
+        return this.currentSong;
+    }
+    static setQuality(index) {
+        this.selectedQuality = index;
+    }
+    static getQueue() {
+        return this.queue;
+    }
+    static getPlaylist() {
+        return this.playlist;
+    }
+}
+exports.Player = Player;
+Player.audio = new Audio();
+Player.currentSong = null;
+Player.currentIndex = 0;
+Player.isPlaying = false;
+Player.currentTime = 0;
+Player.duration = 0;
+Player.isShuffle = true;
+Player.queue = [];
+Player.playlist = [];
+Player.selectedQuality = 3;

package/dist/core/settings.d.ts

@@ -0,0 +1,33 @@
+export interface StreamQuality {
+    value: number;
+    label: string;
+}
+export declare class StreamSettings {
+    static readonly qualityOptions: StreamQuality[];
+    static readonly qualityValueKey = "qualityValue";
+    static readonly qualityLabelKey = "qualityLabel";
+    /**
+     * Loads stream quality from localStorage
+     */
+    static loadQuality(): StreamQuality;
+    /**
+     * Saves stream quality to localStorage
+     * @param value Index of quality option
+     * @param label Display label of selected quality
+     */
+    static saveQuality(value: number, label: string): void;
+    /**
+     * Updates quality using value index only
+     * @param value Stream quality index (0 to 4)
+     */
+    static updateQuality(value: number): StreamQuality;
+    /**
+     * Returns the label for a given value
+     * @param value Quality value index
+     */
+    static getLabel(value: number): string;
+    /**
+     * Returns the available quality options
+     */
+    static getOptions(): StreamQuality[];
+}

package/dist/core/settings.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamSettings = void 0;
+class StreamSettings {
+    /**
+     * Loads stream quality from localStorage
+     */
+    static loadQuality() {
+        var _a;
+        const value = parseInt(localStorage.getItem(this.qualityValueKey) || '3');
+        const label = localStorage.getItem(this.qualityLabelKey) ||
+            ((_a = this.qualityOptions.find(q => q.value === value)) === null || _a === void 0 ? void 0 : _a.label) ||
+            'High (160kbps)';
+        return { value, label };
+    }
+    /**
+     * Saves stream quality to localStorage
+     * @param value Index of quality option
+     * @param label Display label of selected quality
+     */
+    static saveQuality(value, label) {
+        localStorage.setItem(this.qualityValueKey, value.toString());
+        localStorage.setItem(this.qualityLabelKey, label);
+    }
+    /**
+     * Updates quality using value index only
+     * @param value Stream quality index (0 to 4)
+     */
+    static updateQuality(value) {
+        const quality = this.qualityOptions.find(q => q.value === value);
+        if (!quality)
+            throw new Error('Invalid quality value');
+        this.saveQuality(quality.value, quality.label);
+        return quality;
+    }
+    /**
+     * Returns the label for a given value
+     * @param value Quality value index
+     */
+    static getLabel(value) {
+        var _a;
+        return ((_a = this.qualityOptions.find(q => q.value === value)) === null || _a === void 0 ? void 0 : _a.label) || '';
+    }
+    /**
+     * Returns the available quality options
+     */
+    static getOptions() {
+        return this.qualityOptions;
+    }
+}
+exports.StreamSettings = StreamSettings;
+// All available stream quality options
+StreamSettings.qualityOptions = [
+    { value: 0, label: 'Very Low (12kbps)' },
+    { value: 1, label: 'Low (48kbps)' },
+    { value: 2, label: 'Medium (96kbps)' },
+    { value: 3, label: 'High (160kbps)' },
+    { value: 4, label: 'Ultra (320kbps)' },
+];
+StreamSettings.qualityValueKey = 'qualityValue';
+StreamSettings.qualityLabelKey = 'qualityLabel';

package/dist/core/theme.d.ts

@@ -0,0 +1,25 @@
+export declare class ThemeManager {
+    private static readonly key;
+    private static readonly darkClass;
+    /**
+     * Initializes the theme based on system preference or stored value
+     */
+    static initialize(): void;
+    /**
+     * Applies dark/light theme class
+     * @param shouldAdd Whether to add dark class
+     */
+    static apply(shouldAdd: boolean): void;
+    /**
+     * Toggles current theme between light and dark
+     */
+    static toggle(): void;
+    /**
+     * Returns current theme value
+     */
+    static getCurrent(): 'light' | 'dark';
+    /**
+     * Returns true if dark mode is active
+     */
+    static isDark(): boolean;
+}

package/dist/core/theme.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThemeManager = void 0;
+class ThemeManager {
+    /**
+     * Initializes the theme based on system preference or stored value
+     */
+    static initialize() {
+        const stored = localStorage.getItem(this.key);
+        if (stored !== null) {
+            const shouldAdd = stored === 'dark';
+            this.apply(shouldAdd);
+        }
+        else {
+            const prefersDark = window.matchMedia('(prefers-color-scheme: dark)');
+            this.apply(prefersDark.matches);
+            // Save for future
+            localStorage.setItem(this.key, prefersDark.matches ? 'dark' : 'light');
+        }
+        // Optional: listen to system change
+        window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', (event) => {
+            this.apply(event.matches);
+            localStorage.setItem(this.key, event.matches ? 'dark' : 'light');
+        });
+    }
+    /**
+     * Applies dark/light theme class
+     * @param shouldAdd Whether to add dark class
+     */
+    static apply(shouldAdd) {
+        document.documentElement.classList.toggle(this.darkClass, shouldAdd);
+    }
+    /**
+     * Toggles current theme between light and dark
+     */
+    static toggle() {
+        const isDark = document.documentElement.classList.contains(this.darkClass);
+        const newMode = isDark ? 'light' : 'dark';
+        this.apply(!isDark);
+        localStorage.setItem(this.key, newMode);
+    }
+    /**
+     * Returns current theme value
+     */
+    static getCurrent() {
+        return document.documentElement.classList.contains(this.darkClass) ? 'dark' : 'light';
+    }
+    /**
+     * Returns true if dark mode is active
+     */
+    static isDark() {
+        return this.getCurrent() === 'dark';
+    }
+}
+exports.ThemeManager = ThemeManager;
+ThemeManager.key = 'themePalette'; // localStorage key
+ThemeManager.darkClass = 'ion-palette-dark'; // CSS class to toggle

package/dist/core/tunzo-player.js

@@ -0,0 +1 @@
+"use strict";

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './core/player';
+export * from './core/api-calles';
+export * from './core/settings';
+export * from './core/theme';

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./core/player"), exports);
+__exportStar(require("./core/api-calles"), exports);
+__exportStar(require("./core/settings"), exports);
+__exportStar(require("./core/theme"), exports);

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "tunzo-player",
+  "version": "1.0.0",
+  "description": "A music playback service for Angular and Ionic apps with native audio control support.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": ["music", "player", "angular", "ionic", "audio"],
+  "author": "Kulasekaran",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/core/api-calles.ts

@@ -0,0 +1,26 @@
+export class TunzoPlayerAPI {
+    /**
+     * Search for songs using the saavn.dev API
+     * @param query Search keyword (e.g., artist name, song name)
+     * @param limit Number of results to return (default: 250)
+     * @returns Array of song result objects
+     */
+    async searchSongs(query: string, limit: number = 250): Promise<any[]> {
+      try {
+        const response = await fetch(
+          `https://saavn.dev/api/search/songs?query=${encodeURIComponent(query)}&limit=${limit}`
+        );
+  
+        if (!response.ok) {
+          throw new Error(`HTTP error! status: ${response.status}`);
+        }
+  
+        const json = await response.json();
+        return json?.data?.results || [];
+      } catch (error) {
+        console.error("TunzoPlayerAPI Error:", error);
+        return [];
+      }
+    }
+  }
+  

package/src/core/player.ts

@@ -0,0 +1,152 @@
+export class Player {
+    private static audio = new Audio();
+    private static currentSong: any = null;
+    private static currentIndex = 0;
+    private static isPlaying = false;
+    private static currentTime = 0;
+    private static duration = 0;
+    private static isShuffle = true;
+    private static queue: any[] = [];
+    private static playlist: any[] = [];
+    private static selectedQuality = 3;
+  
+    /** Initialize with playlist and quality */
+    static initialize(playlist: any[], quality = 3) {
+      this.playlist = playlist;
+      this.selectedQuality = quality;
+    }
+  
+    static play(song: any, index: number = 0) {
+      if (!song || !song.downloadUrl) return;
+  
+      this.currentSong = song;
+      this.currentIndex = index;
+      this.audio.src = song.downloadUrl[this.selectedQuality]?.url || '';
+      this.audio.play();
+      this.isPlaying = true;
+  
+      // Set duration
+      this.audio.onloadedmetadata = () => {
+        this.duration = this.audio.duration;
+      };
+  
+      // Set current time
+      this.audio.ontimeupdate = () => {
+        this.currentTime = this.audio.currentTime;
+      };
+  
+      // Auto-play next song
+      this.audio.onended = () => {
+        this.autoNext();
+      };
+    }
+  
+    static pause() {
+      this.audio.pause();
+      this.isPlaying = false;
+    }
+  
+    static resume() {
+      this.audio.play();
+      this.isPlaying = true;
+    }
+  
+    static togglePlayPause() {
+      if (this.isPlaying) {
+        this.pause();
+      } else {
+        this.resume();
+      }
+    }
+  
+    static next() {
+      if (this.queue.length > 0) {
+        const nextQueued = this.queue.shift();
+        const index = this.playlist.findIndex(s => s.id === nextQueued.id);
+        this.play(nextQueued, index);
+      } else if (this.isShuffle) {
+        this.playRandom();
+      } else if (this.currentIndex < this.playlist.length - 1) {
+        this.play(this.playlist[this.currentIndex + 1], this.currentIndex + 1);
+      }
+    }
+  
+    static prev() {
+      if (this.currentIndex > 0) {
+        this.play(this.playlist[this.currentIndex - 1], this.currentIndex - 1);
+      }
+    }
+  
+    static seek(seconds: number) {
+      this.audio.currentTime = seconds;
+    }
+  
+    static autoNext() {
+      this.next();
+    }
+  
+    static playRandom() {
+      if (this.playlist.length <= 1) return;
+  
+      let randomIndex;
+      do {
+        randomIndex = Math.floor(Math.random() * this.playlist.length);
+      } while (randomIndex === this.currentIndex);
+  
+      this.play(this.playlist[randomIndex], randomIndex);
+    }
+  
+    static toggleShuffle() {
+      this.isShuffle = !this.isShuffle;
+    }
+  
+    static addToQueue(song: any) {
+      if (!this.queue.some(q => q.id === song.id)) {
+        this.queue.push(song);
+      }
+    }
+  
+    static removeFromQueue(index: number) {
+      this.queue.splice(index, 1);
+    }
+  
+    static reorderQueue(from: number, to: number) {
+      const item = this.queue.splice(from, 1)[0];
+      this.queue.splice(to, 0, item);
+    }
+  
+    static getCurrentTime(): number {
+      return this.currentTime;
+    }
+  
+    static getDuration(): number {
+      return this.duration;
+    }
+  
+    static formatTime(time: number): string {
+      const minutes = Math.floor(time / 60);
+      const seconds = Math.floor(time % 60);
+      return `${minutes}:${seconds < 10 ? '0' : ''}${seconds}`;
+    }
+  
+    static isPlayingSong(): boolean {
+      return this.isPlaying;
+    }
+  
+    static getCurrentSong(): any {
+      return this.currentSong;
+    }
+  
+    static setQuality(index: number) {
+      this.selectedQuality = index;
+    }
+  
+    static getQueue(): any[] {
+      return this.queue;
+    }
+  
+    static getPlaylist(): any[] {
+      return this.playlist;
+    }
+  }
+  

package/src/core/settings.ts

@@ -0,0 +1,69 @@
+export interface StreamQuality {
+    value: number;
+    label: string;
+  }
+  
+  export class StreamSettings {
+    // All available stream quality options
+    static readonly qualityOptions: StreamQuality[] = [
+      { value: 0, label: 'Very Low (12kbps)' },
+      { value: 1, label: 'Low (48kbps)' },
+      { value: 2, label: 'Medium (96kbps)' },
+      { value: 3, label: 'High (160kbps)' },
+      { value: 4, label: 'Ultra (320kbps)' },
+    ];
+  
+    static readonly qualityValueKey = 'qualityValue';
+    static readonly qualityLabelKey = 'qualityLabel';
+  
+    /**
+     * Loads stream quality from localStorage
+     */
+    static loadQuality(): StreamQuality {
+      const value = parseInt(localStorage.getItem(this.qualityValueKey) || '3');
+      const label =
+        localStorage.getItem(this.qualityLabelKey) ||
+        this.qualityOptions.find(q => q.value === value)?.label ||
+        'High (160kbps)';
+  
+      return { value, label };
+    }
+  
+    /**
+     * Saves stream quality to localStorage
+     * @param value Index of quality option
+     * @param label Display label of selected quality
+     */
+    static saveQuality(value: number, label: string) {
+      localStorage.setItem(this.qualityValueKey, value.toString());
+      localStorage.setItem(this.qualityLabelKey, label);
+    }
+  
+    /**
+     * Updates quality using value index only
+     * @param value Stream quality index (0 to 4)
+     */
+    static updateQuality(value: number): StreamQuality {
+      const quality = this.qualityOptions.find(q => q.value === value);
+      if (!quality) throw new Error('Invalid quality value');
+  
+      this.saveQuality(quality.value, quality.label);
+      return quality;
+    }
+  
+    /**
+     * Returns the label for a given value
+     * @param value Quality value index
+     */
+    static getLabel(value: number): string {
+      return this.qualityOptions.find(q => q.value === value)?.label || '';
+    }
+  
+    /**
+     * Returns the available quality options
+     */
+    static getOptions(): StreamQuality[] {
+      return this.qualityOptions;
+    }
+  }
+  

package/src/core/theme.ts

@@ -0,0 +1,61 @@
+export class ThemeManager {
+    private static readonly key = 'themePalette'; // localStorage key
+    private static readonly darkClass = 'ion-palette-dark'; // CSS class to toggle
+  
+    /**
+     * Initializes the theme based on system preference or stored value
+     */
+    static initialize() {
+      const stored = localStorage.getItem(this.key);
+  
+      if (stored !== null) {
+        const shouldAdd = stored === 'dark';
+        this.apply(shouldAdd);
+      } else {
+        const prefersDark = window.matchMedia('(prefers-color-scheme: dark)');
+        this.apply(prefersDark.matches);
+  
+        // Save for future
+        localStorage.setItem(this.key, prefersDark.matches ? 'dark' : 'light');
+      }
+  
+      // Optional: listen to system change
+      window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', (event) => {
+        this.apply(event.matches);
+        localStorage.setItem(this.key, event.matches ? 'dark' : 'light');
+      });
+    }
+  
+    /**
+     * Applies dark/light theme class
+     * @param shouldAdd Whether to add dark class
+     */
+    static apply(shouldAdd: boolean) {
+      document.documentElement.classList.toggle(this.darkClass, shouldAdd);
+    }
+  
+    /**
+     * Toggles current theme between light and dark
+     */
+    static toggle() {
+      const isDark = document.documentElement.classList.contains(this.darkClass);
+      const newMode = isDark ? 'light' : 'dark';
+      this.apply(!isDark);
+      localStorage.setItem(this.key, newMode);
+    }
+  
+    /**
+     * Returns current theme value
+     */
+    static getCurrent(): 'light' | 'dark' {
+      return document.documentElement.classList.contains(this.darkClass) ? 'dark' : 'light';
+    }
+  
+    /**
+     * Returns true if dark mode is active
+     */
+    static isDark(): boolean {
+      return this.getCurrent() === 'dark';
+    }
+  }
+  

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from './core/player';
+export * from './core/api-calles'
+export * from './core/settings'
+export * from './core/theme'

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    /* Output settings */
+    "outDir": "./dist",               // output compiled files here
+    "rootDir": "./src",               // source files are inside src/
+    "declaration": true,              // generate .d.ts types
+    "declarationDir": "./dist",       // put .d.ts files in dist too
+
+    /* Module & Target */
+    "module": "CommonJS",             // compatible with Node/npm
+    "target": "ES2016",               // or ES2020 if you prefer
+
+    /* Type Compatibility */
+    "esModuleInterop": true,          // allow default imports from CommonJS
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true              // speed up builds, safe for libs
+  },
+  "include": ["src"]                  // only compile the src folder
+}