svelteesp32 1.9.4 → 1.11.0

package/README.md

@@ -12,6 +12,8 @@ In order to be able to easily update OTA, it is important - from the users' poin
 
 This npm package provides a solution for **inserting any JS client application into the ESP web server** (PsychicHttp and also ESPAsyncWebServer (https://github.com/ESP32Async/ESPAsyncWebServer) and ESP-IDF available, PsychicHttp is the default). For this, JS, html, css, font, assets, etc. files must be converted to binary byte array. Npm mode is easy to use and easy to **integrate into your CI/CD pipeline**.
 
+> Starting with version v1.10.0, we reduced npm dependencies
+
 > Starting with version v1.9.0, code generator for esp-idf is available
 
 > Starting with version v1.8.0, use the new and maintained ESPAsyncWebserver available at https://github.com/ESP32Async/ESPAsyncWebServer
@@ -35,6 +37,51 @@ This npm package provides a solution for **inserting any JS client application i
 - Node.js >= 20
 - npm >= 9
 
+### Development
+
+#### Testing
+
+The project includes comprehensive unit tests using Vitest:
+
+```bash
+# Run tests once
+npm run test
+
+# Run tests in watch mode (for development)
+npm run test:watch
+
+# Generate coverage report
+npm run test:coverage
+```
+
+**Test Coverage:** ~68% overall with focus on core functionality:
+
+- `commandLine.ts`: 84.56% - CLI argument parsing and validation
+- `file.ts`: 100% - File operations and duplicate detection
+- `cppCode.ts`: 96.62% - C++ code generation and templates
+- `consoleColor.ts`: 100% - Console output utilities
+
+Coverage reports are generated in the `coverage/` directory and can be viewed by opening `coverage/index.html` in a browser.
+
+#### Code Quality
+
+```bash
+# Check formatting
+npm run format:check
+
+# Fix formatting
+npm run format:fix
+
+# Check linting
+npm run lint:check
+
+# Fix linting issues
+npm run lint:fix
+
+# Fix all formatting and linting issues
+npm run fix
+```
+
 ### Usage
 
 **Install package** as devDependency (it is practical if the package is part of the project so that you always receive updates)
@@ -256,6 +303,71 @@ At the same time, it can be an advantage that the content is cached by the brows
 
 Typically, the entry point for web applications is the **index.htm or index.html** file. This does not need to be listed in the browser's address bar because web servers know that this file should be served by default. Svelteesp32 also does this: if there is an index.htm or index.html file, it sets it as the main file to be served. So using `http://esp_xxx.local` or just entering the `http://x.y.w.z/` IP address will serve this main file.
 
+### File Exclusion
+
+The `--exclude` option allows you to exclude files from being embedded in the ESP32 firmware using glob patterns. This is useful for excluding source maps, documentation, and test files that shouldn't be part of the deployed application.
+
+#### Basic Usage
+
+```bash
+# Exclude source maps
+npx svelteesp32 -e psychic -s ./dist -o ./output.h --exclude="*.map"
+
+# Exclude documentation files
+npx svelteesp32 -e psychic -s ./dist -o ./output.h --exclude="*.md"
+
+# Exclude multiple file types (comma-separated)
+npx svelteesp32 -e psychic -s ./dist -o ./output.h --exclude="*.map,*.md,*.txt"
+
+# Exclude using multiple flags
+npx svelteesp32 -e psychic -s ./dist -o ./output.h --exclude="*.map" --exclude="*.md"
+
+# Exclude entire directories
+npx svelteesp32 -e psychic -s ./dist -o ./output.h --exclude="test/**/*"
+
+# Combine multiple approaches
+npx svelteesp32 -e psychic -s ./dist -o ./output.h --exclude="*.map,*.md" --exclude="docs/**/*"
+```
+
+#### Pattern Syntax
+
+The exclude patterns use standard glob syntax:
+
+- `*.map` - Match all files ending with `.map`
+- `**/*.test.js` - Match all `.test.js` files in any directory
+- `test/**/*` - Match all files in the `test` directory and subdirectories
+- `.DS_Store` - Match specific filename
+
+#### Default Exclusions
+
+By default, the following system and development files are automatically excluded:
+
+- `.DS_Store` (macOS system file)
+- `Thumbs.db` (Windows thumbnail cache)
+- `.git` (Git directory)
+- `.svn` (SVN directory)
+- `*.swp` (Vim swap files)
+- `*~` (Backup files)
+- `.gitignore` (Git ignore file)
+- `.gitattributes` (Git attributes file)
+
+Custom exclude patterns are added to these defaults.
+
+#### Exclusion Output
+
+When files are excluded, you'll see a summary in the build output:
+
+```
+Excluded 5 file(s):
+  - assets/index.js.map
+  - assets/vendor.js.map
+  - README.md
+  - docs/guide.md
+  - test/unit.test.js
+```
+
+This helps you verify that the correct files are being excluded from your build.
+
 ### C++ defines
 
 To make it easy to integrate into a larger c++ project, we have made a couple of variables available as c++ defines.
@@ -305,6 +417,7 @@ You can use the following c++ directives at the project level if you want to con
 | `-s`          | **Source dist folder contains compiled web files**                                   | (required)              |
 | `-e`          | The engine for which the include file is created (psychic/psychic2/async/espidf)     | psychic                 |
 | `-o`          | Generated output file with path                                                      | `svelteesp32.h`         |
+| `--exclude`   | Exclude files matching glob pattern (repeatable or comma-separated)                  | Default system files    |
 | `--etag`      | Use ETag header for cache (true/false/compiler)                                      | false                   |
 | `--cachetime` | Override no-cache response with a max-age=\<cachetime\> response (seconds)           | 0                       |
 | `--gzip`      | Compress content with gzip (true/false/compiler)                                     | true                    |

package/dist/commandLine.d.ts

@@ -9,6 +9,7 @@ interface ICopyFilesArguments {
     cachetime: number;
     created: boolean;
     version: string;
+    exclude: string[];
     help?: boolean;
 }
 export declare const cmdLine: ICopyFilesArguments;

package/dist/commandLine.js

@@ -2,91 +2,214 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cmdLine = void 0;
 const node_fs_1 = require("node:fs");
-const ts_command_line_args_1 = require("ts-command-line-args");
-exports.cmdLine = (0, ts_command_line_args_1.parse)({
-    engine: {
-        type: (value) => {
-            if (value === 'psychic')
-                return 'psychic';
-            if (value === 'psychic2')
-                return 'psychic2';
-            if (value === 'async')
-                return 'async';
-            if (value === 'espidf')
-                return 'espidf';
-            throw new Error(`Invalid engine: ${value}`);
-        },
-        alias: 'e',
-        description: 'The engine for which the include file is created (psychic|psychic2|async)',
-        defaultValue: 'psychic'
-    },
-    sourcepath: {
-        type: String,
-        alias: 's',
-        description: 'Source dist folder contains compiled web files'
-    },
-    outputfile: {
-        type: String,
-        alias: 'o',
-        description: 'Generated output file with path',
-        defaultValue: 'svelteesp32.h'
-    },
-    etag: {
-        type: (value) => {
-            if (value === 'true')
-                return 'true';
-            if (value === 'false')
-                return 'false';
-            if (value === 'compiler')
-                return 'compiler';
-            throw new Error(`Invalid etag: ${value}`);
-        },
-        description: 'Use ETAG header for cache',
-        defaultValue: 'false'
-    },
-    gzip: {
-        type: (value) => {
-            if (value === 'true')
-                return 'true';
-            if (value === 'false')
-                return 'false';
-            if (value === 'compiler')
-                return 'compiler';
-            throw new Error(`Invalid etag: ${value}`);
-        },
-        description: 'Compress content with gzip',
-        defaultValue: 'true'
-    },
-    created: {
-        type: Boolean,
-        description: 'Include creation time in the output file',
-        defaultValue: false
-    },
-    version: {
-        type: String,
-        description: 'Include version info in the output file',
-        defaultValue: ''
-    },
-    espmethod: {
-        type: String,
-        description: 'Name of generated method',
-        defaultValue: 'initSvelteStaticFiles'
-    },
-    define: {
-        type: String,
-        description: 'Prefix of c++ defines',
-        defaultValue: 'SVELTEESP32'
-    },
-    cachetime: {
-        type: Number,
-        description: 'max-age cache time in seconds',
-        defaultValue: 0
-    },
-    help: { type: Boolean, optional: true, alias: 'h', description: 'Shows this help' }
-}, {
-    helpArg: 'help',
-    headerContentSections: [{ header: 'svelteesp32', content: 'Svelte JS to ESP32 converter' }]
-});
+function showHelp() {
+    console.log(`
+svelteesp32 - Svelte JS to ESP32 converter
+
+Options:
+  -e, --engine <value>       The engine for which the include file is created
+                             (psychic|psychic2|async|espidf) (default: "psychic")
+  -s, --sourcepath <path>    Source dist folder contains compiled web files (required)
+  -o, --outputfile <path>    Generated output file with path (default: "svelteesp32.h")
+  --etag <value>             Use ETAG header for cache (true|false|compiler) (default: "false")
+  --gzip <value>             Compress content with gzip (true|false|compiler) (default: "true")
+  --created                  Include creation time in the output file (default: false)
+  --version <value>          Include version info in the output file (default: "")
+  --espmethod <name>         Name of generated method (default: "initSvelteStaticFiles")
+  --define <prefix>          Prefix of c++ defines (default: "SVELTEESP32")
+  --cachetime <seconds>      max-age cache time in seconds (default: 0)
+  --exclude <pattern>        Exclude files matching glob pattern (repeatable or comma-separated)
+                             Examples: --exclude="*.map" --exclude="test/**/*.ts"
+  -h, --help                 Shows this help
+`);
+    process.exit(0);
+}
+function validateEngine(value) {
+    if (value === 'psychic' || value === 'psychic2' || value === 'async' || value === 'espidf')
+        return value;
+    throw new Error(`Invalid engine: ${value}`);
+}
+function validateTriState(value, name) {
+    if (value === 'true' || value === 'false' || value === 'compiler')
+        return value;
+    throw new Error(`Invalid ${name}: ${value}`);
+}
+const DEFAULT_EXCLUDE_PATTERNS = [
+    '.DS_Store',
+    'Thumbs.db',
+    '.git',
+    '.svn',
+    '*.swp',
+    '*~',
+    '.gitignore',
+    '.gitattributes'
+];
+function parseArguments() {
+    const arguments_ = process.argv.slice(2);
+    const result = {
+        engine: 'psychic',
+        outputfile: 'svelteesp32.h',
+        etag: 'false',
+        gzip: 'true',
+        created: false,
+        version: '',
+        espmethod: 'initSvelteStaticFiles',
+        define: 'SVELTEESP32',
+        cachetime: 0,
+        exclude: [...DEFAULT_EXCLUDE_PATTERNS]
+    };
+    for (let index = 0; index < arguments_.length; index++) {
+        const argument = arguments_[index];
+        if (!argument)
+            continue;
+        if (argument === '--help' || argument === '-h')
+            showHelp();
+        if (argument.startsWith('--') && argument.includes('=')) {
+            const parts = argument.split('=');
+            const flag = parts[0];
+            const value = parts.slice(1).join('=');
+            if (!flag || !value)
+                throw new Error(`Invalid argument format: ${argument}`);
+            const flagName = flag.slice(2);
+            switch (flagName) {
+                case 'engine':
+                    result.engine = validateEngine(value);
+                    break;
+                case 'sourcepath':
+                    result.sourcepath = value;
+                    break;
+                case 'outputfile':
+                    result.outputfile = value;
+                    break;
+                case 'etag':
+                    result.etag = validateTriState(value, 'etag');
+                    break;
+                case 'gzip':
+                    result.gzip = validateTriState(value, 'gzip');
+                    break;
+                case 'version':
+                    result.version = value;
+                    break;
+                case 'espmethod':
+                    result.espmethod = value;
+                    break;
+                case 'define':
+                    result.define = value;
+                    break;
+                case 'cachetime':
+                    result.cachetime = Number.parseInt(value, 10);
+                    if (Number.isNaN(result.cachetime))
+                        throw new TypeError(`Invalid cachetime: ${value}`);
+                    break;
+                case 'exclude': {
+                    const patterns = value
+                        .split(',')
+                        .map((p) => p.trim())
+                        .filter(Boolean);
+                    result.exclude = result.exclude || [...DEFAULT_EXCLUDE_PATTERNS];
+                    result.exclude.push(...patterns);
+                    break;
+                }
+                default:
+                    throw new Error(`Unknown flag: ${flag}`);
+            }
+            continue;
+        }
+        if (argument === '--created') {
+            result.created = true;
+            continue;
+        }
+        if (argument.startsWith('-') && !argument.startsWith('--')) {
+            const flag = argument.slice(1);
+            const nextArgument = arguments_[index + 1];
+            if (!nextArgument || nextArgument.startsWith('-'))
+                throw new Error(`Missing value for flag: ${argument}`);
+            switch (flag) {
+                case 'e':
+                    result.engine = validateEngine(nextArgument);
+                    index++;
+                    break;
+                case 's':
+                    result.sourcepath = nextArgument;
+                    index++;
+                    break;
+                case 'o':
+                    result.outputfile = nextArgument;
+                    index++;
+                    break;
+                default:
+                    throw new Error(`Unknown flag: ${argument}`);
+            }
+            continue;
+        }
+        if (argument.startsWith('--')) {
+            const flag = argument.slice(2);
+            const nextArgument = arguments_[index + 1];
+            if (!nextArgument || nextArgument.startsWith('-'))
+                throw new Error(`Missing value for flag: ${argument}`);
+            switch (flag) {
+                case 'engine':
+                    result.engine = validateEngine(nextArgument);
+                    index++;
+                    break;
+                case 'sourcepath':
+                    result.sourcepath = nextArgument;
+                    index++;
+                    break;
+                case 'outputfile':
+                    result.outputfile = nextArgument;
+                    index++;
+                    break;
+                case 'etag':
+                    result.etag = validateTriState(nextArgument, 'etag');
+                    index++;
+                    break;
+                case 'gzip':
+                    result.gzip = validateTriState(nextArgument, 'gzip');
+                    index++;
+                    break;
+                case 'version':
+                    result.version = nextArgument;
+                    index++;
+                    break;
+                case 'espmethod':
+                    result.espmethod = nextArgument;
+                    index++;
+                    break;
+                case 'define':
+                    result.define = nextArgument;
+                    index++;
+                    break;
+                case 'cachetime':
+                    result.cachetime = Number.parseInt(nextArgument, 10);
+                    if (Number.isNaN(result.cachetime))
+                        throw new TypeError(`Invalid cachetime: ${nextArgument}`);
+                    index++;
+                    break;
+                case 'exclude': {
+                    const patterns = nextArgument
+                        .split(',')
+                        .map((p) => p.trim())
+                        .filter(Boolean);
+                    result.exclude = result.exclude || [...DEFAULT_EXCLUDE_PATTERNS];
+                    result.exclude.push(...patterns);
+                    index++;
+                    break;
+                }
+                default:
+                    throw new Error(`Unknown flag: --${flag}`);
+            }
+            continue;
+        }
+        throw new Error(`Unknown argument: ${argument}`);
+    }
+    if (!result.sourcepath) {
+        console.error('Error: --sourcepath is required');
+        showHelp();
+    }
+    return result;
+}
+exports.cmdLine = parseArguments();
 if (!(0, node_fs_1.existsSync)(exports.cmdLine.sourcepath) || !(0, node_fs_1.statSync)(exports.cmdLine.sourcepath).isDirectory()) {
     console.error(`Directory ${exports.cmdLine.sourcepath} not exists or not a directory`);
     process.exit(1);

package/dist/consoleColor.d.ts

@@ -1,3 +1,4 @@
 export declare const greenLog: (s: string) => string;
 export declare const yellowLog: (s: string) => string;
 export declare const redLog: (s: string) => string;
+export declare const cyanLog: (s: string) => string;

package/dist/consoleColor.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.redLog = exports.yellowLog = exports.greenLog = void 0;
+exports.cyanLog = exports.redLog = exports.yellowLog = exports.greenLog = void 0;
 const greenLog = (s) => `\u001B[32m${s}\u001B[0m`;
 exports.greenLog = greenLog;
 const yellowLog = (s) => `\u001B[33m${s}\u001B[0m`;
 exports.yellowLog = yellowLog;
 const redLog = (s) => `\u001B[31m${s}\u001B[0m`;
 exports.redLog = redLog;
+const cyanLog = (s) => `\u001B[36m${s}\u001B[0m`;
+exports.cyanLog = cyanLog;

package/dist/file.js

@@ -7,7 +7,8 @@ exports.getFiles = void 0;
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
-const glob_1 = require("glob");
+const picomatch_1 = __importDefault(require("picomatch"));
+const tinyglobby_1 = require("tinyglobby");
 const commandLine_1 = require("./commandLine");
 const consoleColor_1 = require("./consoleColor");
 const findSimilarFiles = (files) => {
@@ -15,19 +16,15 @@ const findSimilarFiles = (files) => {
     for (const [filename, content] of files.entries()) {
         const hash = (0, node_crypto_1.createHash)('sha256').update(content).digest('hex');
         const existingFiles = contentComparer.get(hash);
-        if (existingFiles) {
+        if (existingFiles)
             existingFiles.push(filename);
-        }
-        else {
+        else
             contentComparer.set(hash, [filename]);
-        }
     }
     const result = [];
-    for (const filenames of contentComparer.values()) {
-        if (filenames.length > 1) {
+    for (const filenames of contentComparer.values())
+        if (filenames.length > 1)
             result.push(filenames);
-        }
-    }
     return result;
 };
 const shouldSkipFile = (filename, allFilenames) => {
@@ -42,18 +39,46 @@ const shouldSkipFile = (filename, allFilenames) => {
     }
     return false;
 };
+const isExcluded = (filename, excludePatterns) => {
+    if (excludePatterns.length === 0)
+        return false;
+    const normalizedFilename = filename.replace(/\\/g, '/');
+    const isMatch = (0, picomatch_1.default)(excludePatterns, {
+        dot: true,
+        noglobstar: false,
+        matchBase: false
+    });
+    return isMatch(normalizedFilename);
+};
 const getFiles = () => {
-    const allFilenames = (0, glob_1.globSync)('**/*', { cwd: commandLine_1.cmdLine.sourcepath, nodir: true });
-    const filenames = allFilenames.filter((filename) => !shouldSkipFile(filename, allFilenames));
+    const allFilenames = (0, tinyglobby_1.globSync)('**/*', { cwd: commandLine_1.cmdLine.sourcepath, onlyFiles: true, dot: false });
+    const withoutCompressed = allFilenames.filter((filename) => !shouldSkipFile(filename, allFilenames));
+    const excludePatterns = commandLine_1.cmdLine.exclude || [];
+    const excludedFiles = [];
+    const filenames = withoutCompressed.filter((filename) => {
+        if (isExcluded(filename, excludePatterns)) {
+            excludedFiles.push(filename);
+            return false;
+        }
+        return true;
+    });
+    if (excludedFiles.length > 0) {
+        console.log((0, consoleColor_1.cyanLog)(`\n Excluded ${excludedFiles.length} file(s):`));
+        const displayLimit = 10;
+        for (const file of excludedFiles.slice(0, displayLimit))
+            console.log((0, consoleColor_1.cyanLog)(`  - ${file}`));
+        if (excludedFiles.length > displayLimit)
+            console.log((0, consoleColor_1.cyanLog)(`  ... and ${excludedFiles.length - displayLimit} more`));
+        console.log();
+    }
     const result = new Map();
     for (const filename of filenames) {
         const filePath = node_path_1.default.join(commandLine_1.cmdLine.sourcepath, filename);
         result.set(filename, (0, node_fs_1.readFileSync)(filePath, { flag: 'r' }));
     }
     const duplicates = findSimilarFiles(result);
-    for (const sameFiles of duplicates) {
+    for (const sameFiles of duplicates)
         console.log((0, consoleColor_1.yellowLog)(` ${sameFiles.join(', ')} files look like identical`));
-    }
     return result;
 };
 exports.getFiles = getFiles;

package/dist/index.js

@@ -26,9 +26,8 @@ const calculateCompressionRatio = (originalSize, compressedSize) => Math.round((
 const formatCompressionLog = (filename, padding, originalSize, compressedSize, useGzip) => {
     const ratio = calculateCompressionRatio(originalSize, compressedSize);
     const sizeInfo = `(${originalSize} -> ${compressedSize} = ${ratio}%)`;
-    if (useGzip) {
+    if (useGzip)
         return (0, consoleColor_1.greenLog)(` [${filename}] ${padding} ✓ gzip used ${sizeInfo}`);
-    }
     const tooSmall = originalSize <= GZIP_MIN_SIZE ? '(too small) ' : '';
     return (0, consoleColor_1.yellowLog)(` [${filename}] ${padding} x gzip unused ${tooSmall}${sizeInfo}`);
 };
@@ -44,12 +43,10 @@ const createSourceEntry = (filename, dataname, content, contentGzip, mimeType, m
 });
 const updateExtensionGroup = (extension) => {
     const group = filesByExtension.find((fe) => fe.extension === extension);
-    if (group) {
+    if (group)
         group.count += 1;
-    }
-    else {
+    else
         filesByExtension.push({ extension, count: 1 });
-    }
 };
 console.log('Collecting source files');
 const files = (0, file_1.getFiles)();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelteesp32",
-  "version": "1.9.4",
+  "version": "1.11.0",
   "description": "Convert Svelte (or any frontend) JS application to serve it from ESP32 webserver (PsychicHttp)",
   "author": "BCsabaEngine",
   "license": "ISC",
@@ -31,6 +31,9 @@
     "dev:async": "nodemon src/index.ts -- -e async -s ./demo/svelte/dist -o ./demo/esp32/include/svelteesp32.h --etag=true --gzip=true --cachetime=86400 --version=v$npm_package_version",
     "dev:psychic": "nodemon src/index.ts -- -e psychic -s ./demo/svelte/dist -o ./demo/esp32/include/svelteesp32.h --etag=false --gzip=false --version=v$npm_package_version",
     "dev:psychic2": "nodemon src/index.ts -- -e psychic2 -s ./demo/svelte/dist -o ./demo/esp32/include/svelteesp32.h --etag=false --gzip=false --version=v$npm_package_version",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
     "test:esp32": "./package.script && ~/.platformio/penv/bin/pio run -d ./demo/esp32",
     "test:esp32idf": "./package.script && ~/.platformio/penv/bin/pio run -d ./demo/esp32idf",
     "test:all": "node --run test:esp32 && node --run test:esp32idf",
@@ -41,7 +44,7 @@
     "lint:check": "eslint .",
     "lint:fix": "eslint --fix .",
     "fix": "node --run format:fix && node --run lint:fix && node --run format:fix",
-    "all": "node --run fix && node --run build",
+    "all": "node --run fix && node --run build && node --run test",
     "npm:reinstall": "rm -rf ./node_modules && rm -f ./package-lock.json && npm i && npm i"
   },
   "keywords": [
@@ -59,22 +62,26 @@
   "devDependencies": {
     "@types/mime-types": "^3.0.1",
     "@types/node": "^24.10.1",
-    "@typescript-eslint/eslint-plugin": "^8.47.0",
-    "@typescript-eslint/parser": "^8.47.0",
+    "@types/picomatch": "^4.0.2",
+    "@typescript-eslint/eslint-plugin": "^8.48.1",
+    "@typescript-eslint/parser": "^8.48.1",
+    "@vitest/coverage-v8": "^4.0.15",
     "eslint": "^9.39.1",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-simple-import-sort": "^12.1.1",
     "eslint-plugin-unicorn": "^62.0.0",
+    "memfs": "^4.51.1",
     "nodemon": "^3.1.11",
-    "prettier": "^3.6.2",
+    "prettier": "^3.7.4",
     "ts-node": "^10.9.2",
-    "tsx": "^4.20.6",
-    "typescript": "^5.9.3"
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.15"
   },
   "dependencies": {
-    "glob": "^12.0.0",
     "handlebars": "^4.7.8",
-    "mime-types": "^3.0.1",
-    "ts-command-line-args": "^2.5.1"
+    "mime-types": "^3.0.2",
+    "picomatch": "^4.0.3",
+    "tinyglobby": "^0.2.15"
   }
 }