@visulima/fs 3.0.1 → 3.1.1

package/dist/error.d.ts

@@ -1,4 +1,4 @@
-export { J as JSONError } from './packem_shared/json-error-ZPgZIXcg.d.mjs';
+export { J as JSONError } from './packem_shared/json-error-ZPgZIXcg.js';
 
 declare class AlreadyExistsError extends Error {
     constructor(message: string);

package/dist/index.cjs

@@ -12,11 +12,11 @@ const ensureLinkSync = require('./packem_shared/ensureLinkSync-BVw3h6sK.cjs');
 const ensureSymlink = require('./packem_shared/ensureSymlink-CFSfreco.cjs');
 const ensureSymlinkSync = require('./packem_shared/ensureSymlinkSync-BCd9bzsx.cjs');
 const LF = require('./packem_shared/LF-bB2qO80j.cjs');
-const collect = require('./packem_shared/collect-DxUriHCH.cjs');
+const collect = require('./packem_shared/collect-DZVa0P7v.cjs');
 const collectSync = require('./packem_shared/collectSync-BaA0s001.cjs');
 const findUp = require('./packem_shared/findUp-DA511Swp.cjs');
 const findUpSync = require('./packem_shared/findUpSync-u1rGibzw.cjs');
-const walk = require('./packem_shared/walk-BW7b4GXI.cjs');
+const walk = require('./packem_shared/walk-1LfF6MKY.cjs');
 const walkSync = require('./packem_shared/walkSync-DgPj93NL.cjs');
 const isAccessible = require('./packem_shared/isAccessible-ZNVGsSb7.cjs');
 const isAccessibleSync = require('./packem_shared/isAccessibleSync-VWjQa-US.cjs');

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import { W as WalkOptions, F as FindUpName, a as FindUpOptions, b as FindUpNameSync, c as WalkEntry, R as ReadFileOptions, C as ContentType, d as ReadJsonOptions, J as JsonReviver, E as EmptyDirOptions, e as WriteFileOptions, f as WriteJsonOptions } from './packem_shared/types-CiwAWOQj.d.mjs';
-export { k as CodeFrameLocation, h as FIND_UP_STOP, g as F_OK, l as FindUpNameFnResult, m as FindUpNameSyncFnResult, n as JsonReplacer, i as R_OK, o as ReadFileEncoding, j as W_OK, X as X_OK } from './packem_shared/types-CiwAWOQj.d.mjs';
+import { W as WalkOptions, F as FindUpName, a as FindUpOptions, b as FindUpNameSync, c as WalkEntry, R as ReadFileOptions, C as ContentType, d as ReadJsonOptions, J as JsonReviver, E as EmptyDirOptions, e as WriteFileOptions, f as WriteJsonOptions } from './packem_shared/types-CiwAWOQj.js';
+export { k as CodeFrameLocation, h as FIND_UP_STOP, g as F_OK, l as FindUpNameFnResult, m as FindUpNameSyncFnResult, n as JsonReplacer, i as R_OK, o as ReadFileEncoding, j as W_OK, X as X_OK } from './packem_shared/types-CiwAWOQj.js';
 import { symlink } from 'node:fs';
 import { brotliDecompress, unzip, brotliDecompressSync, unzipSync } from 'node:zlib';
-import { J as JsonValue } from './packem_shared/observable-like.d-BlD8q22s.d.mjs';
+import { J as JsonValue } from './packem_shared/observable-like.d-BlD8q22s.js';
 import 'yaml';
 
 declare const ensureDir: (directory: URL | string) => Promise<void>;

package/dist/index.mjs

@@ -8,11 +8,11 @@ export { default as ensureLinkSync } from './packem_shared/ensureLinkSync-Dk-YeR
 export { default as ensureSymlink } from './packem_shared/ensureSymlink-CSqngPoI.mjs';
 export { default as ensureSymlinkSync } from './packem_shared/ensureSymlinkSync-QRaNZX2E.mjs';
 export { CRLF, EOL, LF, detect, format } from './packem_shared/LF-CU3KsvZC.mjs';
-export { default as collect } from './packem_shared/collect-BtDVJEOm.mjs';
+export { default as collect } from './packem_shared/collect-DIZ3yuRZ.mjs';
 export { default as collectSync } from './packem_shared/collectSync-CGjdb50I.mjs';
 export { default as findUp } from './packem_shared/findUp-C8_QpAtD.mjs';
 export { default as findUpSync } from './packem_shared/findUpSync-DVOd3V-q.mjs';
-export { default as walk } from './packem_shared/walk-CNcSYQVq.mjs';
+export { default as walk } from './packem_shared/walk-CSp2zlI2.mjs';
 export { default as walkSync } from './packem_shared/walkSync-BzxdFWLU.mjs';
 export { default as isAccessible } from './packem_shared/isAccessible-Bonsm1Ez.mjs';
 export { default as isAccessibleSync } from './packem_shared/isAccessibleSync-3gnUWUwX.mjs';

package/dist/packem_shared/{collect-BtDVJEOm.mjs → collect-DIZ3yuRZ.mjs}

@@ -1,4 +1,4 @@
-import walk from './walk-CNcSYQVq.mjs';
+import walk from './walk-CSp2zlI2.mjs';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });

package/dist/packem_shared/{collect-DxUriHCH.cjs → collect-DZVa0P7v.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-const walk = require('./walk-BW7b4GXI.cjs');
+const walk = require('./walk-1LfF6MKY.cjs');
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });

package/dist/packem_shared/{walk-BW7b4GXI.cjs → walk-1LfF6MKY.cjs}

@@ -14,12 +14,9 @@ const _createWalkEntry = /* @__PURE__ */ __name(async (path$1) => {
   const name = path.basename(normalizePath);
   const info = await promises.stat(normalizePath);
   return {
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    isDirectory: info.isDirectory,
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    isFile: info.isFile,
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    isSymbolicLink: info.isSymbolicLink,
+    isDirectory: /* @__PURE__ */ __name(() => info.isDirectory(), "isDirectory"),
+    isFile: /* @__PURE__ */ __name(() => info.isFile(), "isFile"),
+    isSymbolicLink: /* @__PURE__ */ __name(() => info.isSymbolicLink(), "isSymbolicLink"),
     name,
     path: normalizePath
   };
@@ -83,12 +80,9 @@ async function* walk(directory, {
         });
       } else if (entry.isFile() && includeFiles && walkInclude.walkInclude(path$1, extensions, mappedMatch, mappedSkip)) {
         yield {
-          // eslint-disable-next-line @typescript-eslint/unbound-method
-          isDirectory: entry.isDirectory,
-          // eslint-disable-next-line @typescript-eslint/unbound-method
-          isFile: entry.isFile,
-          // eslint-disable-next-line @typescript-eslint/unbound-method
-          isSymbolicLink: entry.isSymbolicLink,
+          isDirectory: /* @__PURE__ */ __name(() => entry.isDirectory(), "isDirectory"),
+          isFile: /* @__PURE__ */ __name(() => entry.isFile(), "isFile"),
+          isSymbolicLink: /* @__PURE__ */ __name(() => entry.isSymbolicLink(), "isSymbolicLink"),
           name: entry.name,
           path: path$1
         };

package/dist/packem_shared/{walk-CNcSYQVq.mjs → walk-CSp2zlI2.mjs}

@@ -12,12 +12,9 @@ const _createWalkEntry = /* @__PURE__ */ __name(async (path) => {
   const name = basename(normalizePath);
   const info = await stat(normalizePath);
   return {
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    isDirectory: info.isDirectory,
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    isFile: info.isFile,
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    isSymbolicLink: info.isSymbolicLink,
+    isDirectory: /* @__PURE__ */ __name(() => info.isDirectory(), "isDirectory"),
+    isFile: /* @__PURE__ */ __name(() => info.isFile(), "isFile"),
+    isSymbolicLink: /* @__PURE__ */ __name(() => info.isSymbolicLink(), "isSymbolicLink"),
     name,
     path: normalizePath
   };
@@ -81,12 +78,9 @@ async function* walk(directory, {
         });
       } else if (entry.isFile() && includeFiles && walkInclude(path, extensions, mappedMatch, mappedSkip)) {
         yield {
-          // eslint-disable-next-line @typescript-eslint/unbound-method
-          isDirectory: entry.isDirectory,
-          // eslint-disable-next-line @typescript-eslint/unbound-method
-          isFile: entry.isFile,
-          // eslint-disable-next-line @typescript-eslint/unbound-method
-          isSymbolicLink: entry.isSymbolicLink,
+          isDirectory: /* @__PURE__ */ __name(() => entry.isDirectory(), "isDirectory"),
+          isFile: /* @__PURE__ */ __name(() => entry.isFile(), "isFile"),
+          isSymbolicLink: /* @__PURE__ */ __name(() => entry.isSymbolicLink(), "isSymbolicLink"),
           name: entry.name,
           path
         };

package/dist/size.cjs

@@ -0,0 +1,118 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const node_fs = require('node:fs');
+const promises = require('node:fs/promises');
+const node_path = require('node:path');
+const node_stream = require('node:stream');
+const node_url = require('node:url');
+const node_zlib = require('node:zlib');
+const utils = require('@visulima/path/utils');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const fileExists = /* @__PURE__ */ __name((input) => {
+  if (node_path.isAbsolute(input)) {
+    return node_fs.existsSync(input);
+  }
+  try {
+    return node_fs.existsSync(node_path.resolve(input));
+  } catch {
+    return false;
+  }
+}, "fileExists");
+const getStreamSizeEfficient = /* @__PURE__ */ __name(async (stream) => {
+  let totalSize = 0;
+  for await (const chunk of stream) {
+    totalSize += Buffer.from(chunk).length;
+  }
+  return totalSize;
+}, "getStreamSizeEfficient");
+const getCompressedStreamSizeEfficient = /* @__PURE__ */ __name(async (stream, createCompressor) => {
+  let totalSize = 0;
+  const compressor = createCompressor();
+  return await new Promise((resolve2, reject) => {
+    compressor.on("data", (chunk) => {
+      totalSize += chunk.length;
+    });
+    compressor.on("end", () => resolve2(totalSize));
+    compressor.on("error", reject);
+    stream.on("error", reject);
+    stream.pipe(compressor);
+  });
+}, "getCompressedStreamSizeEfficient");
+const processInputEfficiently = /* @__PURE__ */ __name(async (input, processor, streamProcessor) => {
+  if (input instanceof node_url.URL || typeof input === "string") {
+    const path = utils.toPath(input);
+    if (fileExists(path)) {
+      const fileStream = node_stream.Readable.from(await promises.readFile(path));
+      return await streamProcessor(fileStream);
+    }
+    if (typeof input === "string") {
+      return processor(Buffer.from(input));
+    }
+  }
+  if (input instanceof node_stream.Readable) {
+    return await streamProcessor(input);
+  }
+  return processor(input);
+}, "processInputEfficiently");
+const gzipSize = /* @__PURE__ */ __name(async (input, options) => {
+  const streamProcessor = /* @__PURE__ */ __name(async (stream) => await getCompressedStreamSizeEfficient(stream, () => node_zlib.createGzip(options)), "streamProcessor");
+  const bufferProcessor = /* @__PURE__ */ __name((data) => node_zlib.gzipSync(data, options).length, "bufferProcessor");
+  return await processInputEfficiently(input, bufferProcessor, streamProcessor);
+}, "gzipSize");
+const brotliSize = /* @__PURE__ */ __name(async (input, options) => {
+  const streamProcessor = /* @__PURE__ */ __name(async (stream) => await getCompressedStreamSizeEfficient(stream, () => node_zlib.createBrotliCompress(options)), "streamProcessor");
+  const bufferProcessor = /* @__PURE__ */ __name((data) => node_zlib.brotliCompressSync(data, options).length, "bufferProcessor");
+  return await processInputEfficiently(input, bufferProcessor, streamProcessor);
+}, "brotliSize");
+const rawSize = /* @__PURE__ */ __name(async (input) => {
+  const streamProcessor = /* @__PURE__ */ __name(async (stream) => await getStreamSizeEfficient(stream), "streamProcessor");
+  const bufferProcessor = /* @__PURE__ */ __name((data) => data.length, "bufferProcessor");
+  return await processInputEfficiently(input, bufferProcessor, streamProcessor);
+}, "rawSize");
+const gzipSizeSync = /* @__PURE__ */ __name((input, options) => {
+  if (input instanceof node_url.URL || typeof input === "string") {
+    const path = utils.toPath(input);
+    if (fileExists(path)) {
+      return node_zlib.gzipSync(node_fs.readFileSync(path), options).length;
+    }
+    if (typeof input === "string") {
+      return node_zlib.gzipSync(Buffer.from(input), options).length;
+    }
+  }
+  return node_zlib.gzipSync(input, options).length;
+}, "gzipSizeSync");
+const brotliSizeSync = /* @__PURE__ */ __name((input, options) => {
+  if (input instanceof node_url.URL || typeof input === "string") {
+    const path = utils.toPath(input);
+    if (fileExists(path)) {
+      return node_zlib.brotliCompressSync(node_fs.readFileSync(path), options).length;
+    }
+    if (typeof input === "string") {
+      return node_zlib.brotliCompressSync(Buffer.from(input), options).length;
+    }
+  }
+  return node_zlib.brotliCompressSync(input, options).length;
+}, "brotliSizeSync");
+const rawSizeSync = /* @__PURE__ */ __name((input) => {
+  if (input instanceof node_url.URL || typeof input === "string") {
+    const path = utils.toPath(input);
+    if (fileExists(path)) {
+      return node_fs.statSync(path).size;
+    }
+    if (typeof input === "string") {
+      return Buffer.from(input).length;
+    }
+  }
+  return input.length;
+}, "rawSizeSync");
+
+exports.brotliSize = brotliSize;
+exports.brotliSizeSync = brotliSizeSync;
+exports.gzipSize = gzipSize;
+exports.gzipSizeSync = gzipSizeSync;
+exports.rawSize = rawSize;
+exports.rawSizeSync = rawSizeSync;

package/dist/size.d.cts

@@ -0,0 +1,12 @@
+import { Readable } from 'node:stream';
+import { URL } from 'node:url';
+import { ZlibOptions, BrotliOptions } from 'node:zlib';
+
+declare const gzipSize: (input: Buffer | Readable | URL | string, options?: ZlibOptions) => Promise<number>;
+declare const brotliSize: (input: Buffer | Readable | URL | string, options?: BrotliOptions) => Promise<number>;
+declare const rawSize: (input: Buffer | Readable | URL | string) => Promise<number>;
+declare const gzipSizeSync: (input: Buffer | URL | string, options?: ZlibOptions) => number;
+declare const brotliSizeSync: (input: Buffer | URL | string, options?: BrotliOptions) => number;
+declare const rawSizeSync: (input: Buffer | URL | string) => number;
+
+export { brotliSize, brotliSizeSync, gzipSize, gzipSizeSync, rawSize, rawSizeSync };

package/dist/size.d.mts

@@ -0,0 +1,12 @@
+import { Readable } from 'node:stream';
+import { URL } from 'node:url';
+import { ZlibOptions, BrotliOptions } from 'node:zlib';
+
+declare const gzipSize: (input: Buffer | Readable | URL | string, options?: ZlibOptions) => Promise<number>;
+declare const brotliSize: (input: Buffer | Readable | URL | string, options?: BrotliOptions) => Promise<number>;
+declare const rawSize: (input: Buffer | Readable | URL | string) => Promise<number>;
+declare const gzipSizeSync: (input: Buffer | URL | string, options?: ZlibOptions) => number;
+declare const brotliSizeSync: (input: Buffer | URL | string, options?: BrotliOptions) => number;
+declare const rawSizeSync: (input: Buffer | URL | string) => number;
+
+export { brotliSize, brotliSizeSync, gzipSize, gzipSizeSync, rawSize, rawSizeSync };

package/dist/size.d.ts

@@ -0,0 +1,12 @@
+import { Readable } from 'node:stream';
+import { URL } from 'node:url';
+import { ZlibOptions, BrotliOptions } from 'node:zlib';
+
+declare const gzipSize: (input: Buffer | Readable | URL | string, options?: ZlibOptions) => Promise<number>;
+declare const brotliSize: (input: Buffer | Readable | URL | string, options?: BrotliOptions) => Promise<number>;
+declare const rawSize: (input: Buffer | Readable | URL | string) => Promise<number>;
+declare const gzipSizeSync: (input: Buffer | URL | string, options?: ZlibOptions) => number;
+declare const brotliSizeSync: (input: Buffer | URL | string, options?: BrotliOptions) => number;
+declare const rawSizeSync: (input: Buffer | URL | string) => number;
+
+export { brotliSize, brotliSizeSync, gzipSize, gzipSizeSync, rawSize, rawSizeSync };

package/dist/size.mjs

@@ -0,0 +1,109 @@
+import { readFileSync, statSync, existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { isAbsolute, resolve } from 'node:path';
+import { Readable } from 'node:stream';
+import { URL } from 'node:url';
+import { gzipSync, brotliCompressSync, createGzip, createBrotliCompress } from 'node:zlib';
+import { toPath } from '@visulima/path/utils';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const fileExists = /* @__PURE__ */ __name((input) => {
+  if (isAbsolute(input)) {
+    return existsSync(input);
+  }
+  try {
+    return existsSync(resolve(input));
+  } catch {
+    return false;
+  }
+}, "fileExists");
+const getStreamSizeEfficient = /* @__PURE__ */ __name(async (stream) => {
+  let totalSize = 0;
+  for await (const chunk of stream) {
+    totalSize += Buffer.from(chunk).length;
+  }
+  return totalSize;
+}, "getStreamSizeEfficient");
+const getCompressedStreamSizeEfficient = /* @__PURE__ */ __name(async (stream, createCompressor) => {
+  let totalSize = 0;
+  const compressor = createCompressor();
+  return await new Promise((resolve2, reject) => {
+    compressor.on("data", (chunk) => {
+      totalSize += chunk.length;
+    });
+    compressor.on("end", () => resolve2(totalSize));
+    compressor.on("error", reject);
+    stream.on("error", reject);
+    stream.pipe(compressor);
+  });
+}, "getCompressedStreamSizeEfficient");
+const processInputEfficiently = /* @__PURE__ */ __name(async (input, processor, streamProcessor) => {
+  if (input instanceof URL || typeof input === "string") {
+    const path = toPath(input);
+    if (fileExists(path)) {
+      const fileStream = Readable.from(await readFile(path));
+      return await streamProcessor(fileStream);
+    }
+    if (typeof input === "string") {
+      return processor(Buffer.from(input));
+    }
+  }
+  if (input instanceof Readable) {
+    return await streamProcessor(input);
+  }
+  return processor(input);
+}, "processInputEfficiently");
+const gzipSize = /* @__PURE__ */ __name(async (input, options) => {
+  const streamProcessor = /* @__PURE__ */ __name(async (stream) => await getCompressedStreamSizeEfficient(stream, () => createGzip(options)), "streamProcessor");
+  const bufferProcessor = /* @__PURE__ */ __name((data) => gzipSync(data, options).length, "bufferProcessor");
+  return await processInputEfficiently(input, bufferProcessor, streamProcessor);
+}, "gzipSize");
+const brotliSize = /* @__PURE__ */ __name(async (input, options) => {
+  const streamProcessor = /* @__PURE__ */ __name(async (stream) => await getCompressedStreamSizeEfficient(stream, () => createBrotliCompress(options)), "streamProcessor");
+  const bufferProcessor = /* @__PURE__ */ __name((data) => brotliCompressSync(data, options).length, "bufferProcessor");
+  return await processInputEfficiently(input, bufferProcessor, streamProcessor);
+}, "brotliSize");
+const rawSize = /* @__PURE__ */ __name(async (input) => {
+  const streamProcessor = /* @__PURE__ */ __name(async (stream) => await getStreamSizeEfficient(stream), "streamProcessor");
+  const bufferProcessor = /* @__PURE__ */ __name((data) => data.length, "bufferProcessor");
+  return await processInputEfficiently(input, bufferProcessor, streamProcessor);
+}, "rawSize");
+const gzipSizeSync = /* @__PURE__ */ __name((input, options) => {
+  if (input instanceof URL || typeof input === "string") {
+    const path = toPath(input);
+    if (fileExists(path)) {
+      return gzipSync(readFileSync(path), options).length;
+    }
+    if (typeof input === "string") {
+      return gzipSync(Buffer.from(input), options).length;
+    }
+  }
+  return gzipSync(input, options).length;
+}, "gzipSizeSync");
+const brotliSizeSync = /* @__PURE__ */ __name((input, options) => {
+  if (input instanceof URL || typeof input === "string") {
+    const path = toPath(input);
+    if (fileExists(path)) {
+      return brotliCompressSync(readFileSync(path), options).length;
+    }
+    if (typeof input === "string") {
+      return brotliCompressSync(Buffer.from(input), options).length;
+    }
+  }
+  return brotliCompressSync(input, options).length;
+}, "brotliSizeSync");
+const rawSizeSync = /* @__PURE__ */ __name((input) => {
+  if (input instanceof URL || typeof input === "string") {
+    const path = toPath(input);
+    if (fileExists(path)) {
+      return statSync(path).size;
+    }
+    if (typeof input === "string") {
+      return Buffer.from(input).length;
+    }
+  }
+  return input.length;
+}, "rawSizeSync");
+
+export { brotliSize, brotliSizeSync, gzipSize, gzipSizeSync, rawSize, rawSizeSync };

package/dist/utils.d.ts

@@ -1,6 +1,6 @@
-export { J as JSONError } from './packem_shared/json-error-ZPgZIXcg.d.mjs';
-import { J as JsonValue } from './packem_shared/observable-like.d-BlD8q22s.d.mjs';
-import { p as CodeFrameOptions, J as JsonReviver } from './packem_shared/types-CiwAWOQj.d.mjs';
+export { J as JSONError } from './packem_shared/json-error-ZPgZIXcg.js';
+import { J as JsonValue } from './packem_shared/observable-like.d-BlD8q22s.js';
+import { p as CodeFrameOptions, J as JsonReviver } from './packem_shared/types-CiwAWOQj.js';
 export { toPath } from '@visulima/path/utils';
 import 'node:fs';
 import 'yaml';

package/dist/yaml.d.ts

@@ -1,4 +1,4 @@
-import { q as ReadYamlOptions, Y as YamlReviver, r as YamlReplacer } from './packem_shared/types-CiwAWOQj.d.mjs';
+import { q as ReadYamlOptions, Y as YamlReviver, r as YamlReplacer } from './packem_shared/types-CiwAWOQj.js';
 import { CreateNodeOptions, DocumentOptions, ParseOptions, SchemaOptions, ToStringOptions } from 'yaml';
 import 'node:fs';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visulima/fs",
-  "version": "3.0.1",
+  "version": "3.1.1",
   "description": "Human friendly file system utilities for Node.js",
   "keywords": [
     "anolilab",
@@ -48,7 +48,10 @@
     "write-dir",
     "write-file",
     "write-safe",
-    "yaml"
+    "yaml",
+    "size",
+    "brotli",
+    "gzip"
   ],
   "homepage": "https://www.visulima.com/docs/package/fs",
   "bugs": {
@@ -117,6 +120,16 @@
         "default": "./dist/yaml.mjs"
       }
     },
+    "./size": {
+      "require": {
+        "types": "./dist/size.d.cts",
+        "default": "./dist/size.cjs"
+      },
+      "import": {
+        "types": "./dist/size.d.mts",
+        "default": "./dist/size.mjs"
+      }
+    },
     "./package.json": "./package.json"
   },
   "main": "dist/index.cjs",
@@ -135,6 +148,9 @@
       ],
       "yaml": [
         "./dist/yaml.d.ts"
+      ],
+      "size": [
+        "./dist/size.d.ts"
       ]
     }
   },