cspell-io 6.26.3 → 6.28.0

package/dist/{CSpellIO.d.ts → cjs/CSpellIO.d.ts}

@@ -1,7 +1,6 @@
-/// <reference types="node" />
-import type { Stats } from './models';
-import type { BufferEncoding } from './models/BufferEncoding';
-import type { TextFileResource } from './models/FileResource';
+import type { BufferEncoding } from './models/BufferEncoding.js';
+import type { TextFileResource } from './models/FileResource.js';
+import type { Stats } from './models/index.js';
 export type UrlOrFilename = string | URL;
 export interface CSpellIO {
     /**

package/dist/{CSpellIONode.d.ts → cjs/CSpellIONode.d.ts}

@@ -1,9 +1,8 @@
 /// <reference types="node" />
-/// <reference types="node" />
 import { ServiceBus } from '@cspell/cspell-service-bus';
-import type { CSpellIO } from './CSpellIO';
-import type { TextFileResource } from './models/FileResource';
-import type { Stats } from './models/Stats';
+import type { CSpellIO } from './CSpellIO.js';
+import type { TextFileResource } from './models/FileResource.js';
+import type { Stats } from './models/Stats.js';
 export declare class CSpellIONode implements CSpellIO {
     readonly serviceBus: ServiceBus;
     constructor(serviceBus?: ServiceBus);

package/dist/{CSpellIONode.js → cjs/CSpellIONode.js}

@@ -2,73 +2,73 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDefaultCSpellIO = exports.CSpellIONode = void 0;
 const cspell_service_bus_1 = require("@cspell/cspell-service-bus");
-const stat_1 = require("./common/stat");
-const ErrorNotImplemented_1 = require("./errors/ErrorNotImplemented");
-const file_1 = require("./handlers/node/file");
-const util_1 = require("./node/file/util");
-const requests_1 = require("./requests");
+const stat_js_1 = require("./common/stat.js");
+const ErrorNotImplemented_js_1 = require("./errors/ErrorNotImplemented.js");
+const file_js_1 = require("./handlers/node/file.js");
+const util_js_1 = require("./node/file/util.js");
+const index_js_1 = require("./requests/index.js");
 let defaultCSpellIONode = undefined;
 class CSpellIONode {
     constructor(serviceBus = new cspell_service_bus_1.ServiceBus()) {
         this.serviceBus = serviceBus;
-        (0, file_1.registerHandlers)(serviceBus);
+        (0, file_js_1.registerHandlers)(serviceBus);
     }
     readFile(uriOrFilename, encoding = 'utf8') {
-        const url = (0, util_1.toURL)(uriOrFilename);
-        const res = this.serviceBus.dispatch(requests_1.RequestFsReadFile.create({ url, encoding }));
+        const url = (0, util_js_1.toURL)(uriOrFilename);
+        const res = this.serviceBus.dispatch(index_js_1.RequestFsReadFile.create({ url, encoding }));
         if (!(0, cspell_service_bus_1.isServiceResponseSuccess)(res)) {
             throw genError(res.error, 'readFile');
         }
         return res.value;
     }
     readFileSync(uriOrFilename, encoding = 'utf8') {
-        const url = (0, util_1.toURL)(uriOrFilename);
-        const res = this.serviceBus.dispatch(requests_1.RequestFsReadFileSync.create({ url, encoding }));
+        const url = (0, util_js_1.toURL)(uriOrFilename);
+        const res = this.serviceBus.dispatch(index_js_1.RequestFsReadFileSync.create({ url, encoding }));
         if (!(0, cspell_service_bus_1.isServiceResponseSuccess)(res)) {
             throw genError(res.error, 'readFileSync');
         }
         return res.value;
     }
     writeFile(uriOrFilename, content) {
-        const url = (0, util_1.toURL)(uriOrFilename);
-        const res = this.serviceBus.dispatch(requests_1.RequestFsWriteFile.create({ url, content }));
+        const url = (0, util_js_1.toURL)(uriOrFilename);
+        const res = this.serviceBus.dispatch(index_js_1.RequestFsWriteFile.create({ url, content }));
         if (!(0, cspell_service_bus_1.isServiceResponseSuccess)(res)) {
             throw genError(res.error, 'writeFile');
         }
         return res.value;
     }
     getStat(uriOrFilename) {
-        const url = (0, util_1.toURL)(uriOrFilename);
-        const res = this.serviceBus.dispatch(requests_1.RequestFsStat.create({ url }));
+        const url = (0, util_js_1.toURL)(uriOrFilename);
+        const res = this.serviceBus.dispatch(index_js_1.RequestFsStat.create({ url }));
         if (!(0, cspell_service_bus_1.isServiceResponseSuccess)(res)) {
             throw genError(res.error, 'getStat');
         }
         return res.value;
     }
     getStatSync(uriOrFilename) {
-        const url = (0, util_1.toURL)(uriOrFilename);
-        const res = this.serviceBus.dispatch(requests_1.RequestFsStatSync.create({ url }));
+        const url = (0, util_js_1.toURL)(uriOrFilename);
+        const res = this.serviceBus.dispatch(index_js_1.RequestFsStatSync.create({ url }));
         if (!(0, cspell_service_bus_1.isServiceResponseSuccess)(res)) {
             throw genError(res.error, 'getStatSync');
         }
         return res.value;
     }
     compareStats(left, right) {
-        return (0, stat_1.compareStats)(left, right);
+        return (0, stat_js_1.compareStats)(left, right);
     }
     toURL(uriOrFilename) {
-        return (0, util_1.toURL)(uriOrFilename);
+        return (0, util_js_1.toURL)(uriOrFilename);
     }
     uriBasename(uriOrFilename) {
-        return (0, util_1.urlBasename)(uriOrFilename);
+        return (0, util_js_1.urlBasename)(uriOrFilename);
     }
     uriDirname(uriOrFilename) {
-        return (0, util_1.urlDirname)(uriOrFilename);
+        return (0, util_js_1.urlDirname)(uriOrFilename);
     }
 }
 exports.CSpellIONode = CSpellIONode;
 function genError(err, alt) {
-    return err || new ErrorNotImplemented_1.ErrorNotImplemented(alt);
+    return err || new ErrorNotImplemented_js_1.ErrorNotImplemented(alt);
 }
 function getDefaultCSpellIO() {
     if (defaultCSpellIONode)

package/dist/{CSpellIOWeb.d.ts → cjs/CSpellIOWeb.d.ts}

@@ -1,7 +1,6 @@
-/// <reference types="node" />
-import type { CSpellIO } from './CSpellIO';
-import type { TextFileResource } from './models/FileResource';
-import type { Stats } from './models/Stats';
+import type { CSpellIO } from './CSpellIO.js';
+import type { TextFileResource } from './models/FileResource.js';
+import type { Stats } from './models/Stats.js';
 export declare class CSpellIOWeb implements CSpellIO {
     readFile(_uriOrFilename: string | URL): Promise<TextFileResource>;
     readFileSync(_uriOrFilename: string | URL): TextFileResource;

package/dist/cjs/CSpellIOWeb.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSpellIOWeb = void 0;
+const stat_js_1 = require("./common/stat.js");
+const ErrorNotImplemented_js_1 = require("./errors/ErrorNotImplemented.js");
+class CSpellIOWeb {
+    readFile(_uriOrFilename) {
+        throw new ErrorNotImplemented_js_1.ErrorNotImplemented('readFile');
+    }
+    readFileSync(_uriOrFilename) {
+        throw new ErrorNotImplemented_js_1.ErrorNotImplemented('readFileSync');
+    }
+    writeFile(_uriOrFilename, _content) {
+        throw new ErrorNotImplemented_js_1.ErrorNotImplemented('writeFile');
+    }
+    getStat(_uriOrFilename) {
+        throw new ErrorNotImplemented_js_1.ErrorNotImplemented('getStat');
+    }
+    getStatSync(_uriOrFilename) {
+        throw new ErrorNotImplemented_js_1.ErrorNotImplemented('getStatSync');
+    }
+    compareStats(left, right) {
+        return (0, stat_js_1.compareStats)(left, right);
+    }
+    toURL(_uriOrFilename) {
+        throw new ErrorNotImplemented_js_1.ErrorNotImplemented('toURL');
+    }
+    uriBasename(_uriOrFilename) {
+        throw new ErrorNotImplemented_js_1.ErrorNotImplemented('uriBasename');
+    }
+    uriDirname(_uriOrFilename) {
+        throw new ErrorNotImplemented_js_1.ErrorNotImplemented('uriDirname');
+    }
+}
+exports.CSpellIOWeb = CSpellIOWeb;
+//# sourceMappingURL=CSpellIOWeb.js.map

package/dist/cjs/common/BufferEncoding.d.ts

@@ -0,0 +1,4 @@
+import type { BufferEncoding } from '../models/BufferEncoding.js';
+export type { BufferEncoding } from '../models/BufferEncoding.js';
+export type BufferEncodingExt = BufferEncoding | 'utf16be';
+//# sourceMappingURL=BufferEncoding.d.ts.map

package/dist/cjs/common/encode-decode.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import type { BufferEncodingExt } from './BufferEncoding.js';
+export declare function decodeUtf16LE(buf: Buffer): string;
+export declare function decodeUtf16BE(buf: Buffer): string;
+export declare function decode(buf: Buffer, encoding?: BufferEncodingExt): string;
+export declare function swapBytesInPlace(buf: Buffer): Buffer;
+export declare function swapBytes(buf: Buffer): Buffer;
+export declare function encodeString(str: string, encoding?: BufferEncodingExt, bom?: boolean): Buffer;
+export declare function encodeUtf16LE(str: string, bom?: boolean): Buffer;
+export declare function encodeUtf16BE(str: string, bom?: boolean): Buffer;
+export declare function calcEncodingFromBom(buf: Buffer): 'utf16be' | 'utf16le' | undefined;
+//# sourceMappingURL=encode-decode.d.ts.map

package/dist/cjs/common/encode-decode.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calcEncodingFromBom = exports.encodeUtf16BE = exports.encodeUtf16LE = exports.encodeString = exports.swapBytes = exports.swapBytesInPlace = exports.decode = exports.decodeUtf16BE = exports.decodeUtf16LE = void 0;
+const BOM_BE = 0xfeff;
+const BOM_LE = 0xfffe;
+function decodeUtf16LE(buf) {
+    const bom = (buf[0] << 8) | buf[1];
+    buf = bom === BOM_LE ? buf.subarray(2) : buf;
+    return buf.toString('utf16le');
+}
+exports.decodeUtf16LE = decodeUtf16LE;
+function decodeUtf16BE(buf) {
+    return decodeUtf16LE(swapBytes(buf));
+}
+exports.decodeUtf16BE = decodeUtf16BE;
+function decode(buf, encoding) {
+    switch (encoding) {
+        case 'utf16be':
+            return decodeUtf16BE(buf);
+        case 'utf16le':
+            return decodeUtf16LE(buf);
+    }
+    if (buf.length < 2 || (encoding && !encoding.startsWith('utf')))
+        return buf.toString(encoding);
+    const bom = (buf[0] << 8) | buf[1];
+    if (bom === BOM_BE || (buf[0] === 0 && buf[1] !== 0))
+        return decodeUtf16BE(buf);
+    if (bom === BOM_LE || (buf[0] !== 0 && buf[1] === 0))
+        return decodeUtf16LE(buf);
+    return buf.toString(encoding);
+}
+exports.decode = decode;
+function swapBytesInPlace(buf) {
+    for (let i = 0; i < buf.length - 1; i += 2) {
+        const v = buf[i];
+        buf[i] = buf[i + 1];
+        buf[i + 1] = v;
+    }
+    return buf;
+}
+exports.swapBytesInPlace = swapBytesInPlace;
+function swapBytes(buf) {
+    const tBuf = Buffer.from(buf);
+    return swapBytesInPlace(tBuf);
+}
+exports.swapBytes = swapBytes;
+function encodeString(str, encoding, bom) {
+    switch (encoding) {
+        case 'utf16be':
+            return encodeUtf16BE(str, bom);
+        case 'utf16le':
+            return encodeUtf16LE(str, bom);
+    }
+    return Buffer.from(str, encoding);
+}
+exports.encodeString = encodeString;
+function encodeUtf16LE(str, bom = true) {
+    const buf = Buffer.from(str, 'utf16le');
+    if (bom) {
+        const target = Buffer.alloc(buf.length + 2);
+        target.writeUint16LE(BOM_BE);
+        buf.copy(target, 2);
+        return target;
+    }
+    return buf;
+}
+exports.encodeUtf16LE = encodeUtf16LE;
+function encodeUtf16BE(str, bom = true) {
+    return swapBytesInPlace(encodeUtf16LE(str, bom));
+}
+exports.encodeUtf16BE = encodeUtf16BE;
+function calcEncodingFromBom(buf) {
+    if (buf.length < 2)
+        return undefined;
+    switch ((buf[0] << 8) | buf[1]) {
+        case BOM_BE:
+            return 'utf16be';
+        case BOM_LE:
+            return 'utf16le';
+    }
+    return undefined;
+}
+exports.calcEncodingFromBom = calcEncodingFromBom;
+//# sourceMappingURL=encode-decode.js.map

package/dist/{common → cjs/common}/stat.d.ts

@@ -1,4 +1,4 @@
-import type { Stats } from '../models/Stats';
+import type { Stats } from '../models/Stats.js';
 /**
  * Compare two Stats to see if they have the same value.
  * @param left - Stats

package/dist/cjs/common/transformers.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import type { BufferEncodingExt } from './BufferEncoding.js';
+export declare function createDecoderTransformer(encoding?: BufferEncodingExt): (iterable: AsyncIterable<string | Buffer> | Iterable<string | Buffer>) => AsyncIterable<string>;
+export declare function encoderTransformer(iterable: Iterable<string>, encoding?: BufferEncodingExt): Iterable<Buffer>;
+export declare function encoderTransformer(iterable: AsyncIterable<string>, encoding?: BufferEncodingExt): AsyncIterable<Buffer>;
+export declare function encoderTransformer(iterable: Iterable<string> | AsyncIterable<string>, encoding?: BufferEncodingExt): Iterable<Buffer> | AsyncIterable<Buffer>;
+//# sourceMappingURL=transformers.d.ts.map

package/dist/cjs/common/transformers.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encoderTransformer = exports.createDecoderTransformer = void 0;
+const encode_decode_js_1 = require("./encode-decode.js");
+function createDecoderTransformer(encoding) {
+    function standardDecoder(buf) {
+        return (0, encode_decode_js_1.decode)(buf, encoding);
+    }
+    let decoder = undefined;
+    if (encoding && !encoding.startsWith('utf'))
+        return decoderNonUtf;
+    return decoderUtf;
+    async function* decoderNonUtf(iterable) {
+        for await (const buf of iterable) {
+            yield typeof buf === 'string' ? buf : (0, encode_decode_js_1.decode)(buf, encoding);
+        }
+    }
+    async function* decoderUtf(iterable) {
+        for await (const sb of iterable) {
+            if (typeof sb === 'string') {
+                yield sb;
+                continue;
+            }
+            if (sb.length < 2) {
+                yield standardDecoder(sb);
+                continue;
+            }
+            if (decoder) {
+                yield decoder(sb);
+                continue;
+            }
+            decoder = standardDecoder;
+            const _encoding = (0, encode_decode_js_1.calcEncodingFromBom)(sb);
+            if (_encoding === 'utf16le') {
+                decoder = encode_decode_js_1.decodeUtf16LE;
+                yield decoder(sb.subarray(2));
+                continue;
+            }
+            if (_encoding === 'utf16be') {
+                decoder = encode_decode_js_1.decodeUtf16BE;
+                yield decoder(sb.subarray(2));
+                continue;
+            }
+            yield decoder(sb);
+        }
+    }
+}
+exports.createDecoderTransformer = createDecoderTransformer;
+function encoderTransformer(iterable, encoding) {
+    return isAsyncIterable(iterable) ? encoderAsyncIterable(iterable, encoding) : encoderIterable(iterable, encoding);
+}
+exports.encoderTransformer = encoderTransformer;
+function* encoderIterable(iterable, encoding) {
+    let useBom = true;
+    for (const chunk of iterable) {
+        yield (0, encode_decode_js_1.encodeString)(chunk, encoding, useBom);
+        useBom = false;
+    }
+}
+async function* encoderAsyncIterable(iterable, encoding) {
+    let useBom = true;
+    for await (const chunk of iterable) {
+        yield (0, encode_decode_js_1.encodeString)(chunk, encoding, useBom);
+        useBom = false;
+    }
+}
+function isAsyncIterable(v) {
+    return v && typeof v === 'object' && !!v[Symbol.asyncIterator];
+}
+//# sourceMappingURL=transformers.js.map

package/dist/cjs/errors/index.d.ts

@@ -0,0 +1,3 @@
+export { toError } from './error.js';
+export { ErrorNotImplemented } from './ErrorNotImplemented.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/errors/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorNotImplemented = exports.toError = void 0;
+var error_js_1 = require("./error.js");
+Object.defineProperty(exports, "toError", { enumerable: true, get: function () { return error_js_1.toError; } });
+var ErrorNotImplemented_js_1 = require("./ErrorNotImplemented.js");
+Object.defineProperty(exports, "ErrorNotImplemented", { enumerable: true, get: function () { return ErrorNotImplemented_js_1.ErrorNotImplemented; } });
+//# sourceMappingURL=index.js.map

package/dist/{file → cjs/file}/file.d.ts

@@ -1,4 +1,4 @@
-import type { getStat as GetStatFn, getStatSync as GetStatSyncFn, readFile as ReadFileFn, readFileSync as ReadFileSyncFn } from '../node/file';
+import type { getStat as GetStatFn, getStatSync as GetStatSyncFn, readFile as ReadFileFn, readFileSync as ReadFileSyncFn } from '../node/file/index.js';
 export declare const readFile: typeof ReadFileFn;
 export declare const readFileSync: typeof ReadFileSyncFn;
 export declare const getStat: typeof GetStatFn;

package/dist/{file → cjs/file}/file.js

@@ -1,28 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getStatSync = exports.getStat = exports.readFileSync = exports.readFile = void 0;
-const CSpellIONode_1 = require("../CSpellIONode");
-const errors_1 = require("../errors");
+const CSpellIONode_js_1 = require("../CSpellIONode.js");
+const index_js_1 = require("../errors/index.js");
 const readFile = function (filename, encoding) {
-    return (0, CSpellIONode_1.getDefaultCSpellIO)()
+    return (0, CSpellIONode_js_1.getDefaultCSpellIO)()
         .readFile(filename, encoding)
         .then((fr) => fr.content);
 };
 exports.readFile = readFile;
 const readFileSync = function (filename, encoding) {
-    return (0, CSpellIONode_1.getDefaultCSpellIO)().readFileSync(filename, encoding).content;
+    return (0, CSpellIONode_js_1.getDefaultCSpellIO)().readFileSync(filename, encoding).content;
 };
 exports.readFileSync = readFileSync;
 const getStat = function (filenameOrUri) {
-    return (0, CSpellIONode_1.getDefaultCSpellIO)().getStat(filenameOrUri).catch(errors_1.toError);
+    return (0, CSpellIONode_js_1.getDefaultCSpellIO)().getStat(filenameOrUri).catch(index_js_1.toError);
 };
 exports.getStat = getStat;
 const getStatSync = function (filenameOrUri) {
     try {
-        return (0, CSpellIONode_1.getDefaultCSpellIO)().getStatSync(filenameOrUri);
+        return (0, CSpellIONode_js_1.getDefaultCSpellIO)().getStatSync(filenameOrUri);
     }
     catch (e) {
-        return (0, errors_1.toError)(e);
+        return (0, index_js_1.toError)(e);
     }
 };
 exports.getStatSync = getStatSync;

package/dist/cjs/file/index.d.ts

@@ -0,0 +1,3 @@
+export { writeToFile, writeToFileIterable, writeToFileIterable as writeToFileIterableP } from './../node/file/index.js';
+export { getStat, getStatSync, readFile, readFileSync } from './file.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/{file → cjs/file}/index.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readFileSync = exports.readFile = exports.getStatSync = exports.getStat = exports.writeToFileIterableP = exports.writeToFileIterable = exports.writeToFile = void 0;
-var file_1 = require("./../node/file");
-Object.defineProperty(exports, "writeToFile", { enumerable: true, get: function () { return file_1.writeToFile; } });
-Object.defineProperty(exports, "writeToFileIterable", { enumerable: true, get: function () { return file_1.writeToFileIterable; } });
-Object.defineProperty(exports, "writeToFileIterableP", { enumerable: true, get: function () { return file_1.writeToFileIterableP; } });
-var file_2 = require("./file");
-Object.defineProperty(exports, "getStat", { enumerable: true, get: function () { return file_2.getStat; } });
-Object.defineProperty(exports, "getStatSync", { enumerable: true, get: function () { return file_2.getStatSync; } });
-Object.defineProperty(exports, "readFile", { enumerable: true, get: function () { return file_2.readFile; } });
-Object.defineProperty(exports, "readFileSync", { enumerable: true, get: function () { return file_2.readFileSync; } });
+var index_js_1 = require("./../node/file/index.js");
+Object.defineProperty(exports, "writeToFile", { enumerable: true, get: function () { return index_js_1.writeToFile; } });
+Object.defineProperty(exports, "writeToFileIterable", { enumerable: true, get: function () { return index_js_1.writeToFileIterable; } });
+Object.defineProperty(exports, "writeToFileIterableP", { enumerable: true, get: function () { return index_js_1.writeToFileIterable; } });
+var file_js_1 = require("./file.js");
+Object.defineProperty(exports, "getStat", { enumerable: true, get: function () { return file_js_1.getStat; } });
+Object.defineProperty(exports, "getStatSync", { enumerable: true, get: function () { return file_js_1.getStatSync; } });
+Object.defineProperty(exports, "readFile", { enumerable: true, get: function () { return file_js_1.readFile; } });
+Object.defineProperty(exports, "readFileSync", { enumerable: true, get: function () { return file_js_1.readFileSync; } });
 //# sourceMappingURL=index.js.map

package/dist/{handlers → cjs/handlers}/node/file.js

@@ -9,11 +9,12 @@ const assert_1 = __importDefault(require("assert"));
 const fs_1 = require("fs");
 const url_1 = require("url");
 const zlib_1 = require("zlib");
-const errors_1 = require("../../errors");
-const dataUrl_1 = require("../../node/dataUrl");
-const fetch_1 = require("../../node/file/fetch");
-const stat_1 = require("../../node/file/stat");
-const requests_1 = require("../../requests");
+const encode_decode_js_1 = require("../../common/encode-decode.js");
+const index_js_1 = require("../../errors/index.js");
+const dataUrl_js_1 = require("../../node/dataUrl.js");
+const fetch_js_1 = require("../../node/file/fetch.js");
+const stat_js_1 = require("../../node/file/stat.js");
+const index_js_2 = require("../../requests/index.js");
 const isGzFileRegExp = /\.gz($|[?#])/;
 function isGzFile(url) {
     return isGzFileRegExp.test(url.pathname);
@@ -24,17 +25,17 @@ function isGzFile(url) {
 /**
  * Handle Binary File Reads
  */
-const handleRequestFsReadBinaryFile = requests_1.RequestFsReadBinaryFile.createRequestHandler(({ params }) => (0, cspell_service_bus_1.createResponse)(fs_1.promises.readFile((0, url_1.fileURLToPath)(params.url)).then((content) => ({ url: params.url, content }))), undefined, 'Node: Read Binary File.');
+const handleRequestFsReadBinaryFile = index_js_2.RequestFsReadBinaryFile.createRequestHandler(({ params }) => (0, cspell_service_bus_1.createResponse)(fs_1.promises.readFile((0, url_1.fileURLToPath)(params.url)).then((content) => ({ url: params.url, content }))), undefined, 'Node: Read Binary File.');
 /**
  * Handle Binary File Sync Reads
  */
-const handleRequestFsReadBinaryFileSync = requests_1.RequestFsReadBinaryFileSync.createRequestHandler(({ params }) => (0, cspell_service_bus_1.createResponse)({ url: params.url, content: (0, fs_1.readFileSync)((0, url_1.fileURLToPath)(params.url)) }), undefined, 'Node: Sync Read Binary File.');
+const handleRequestFsReadBinaryFileSync = index_js_2.RequestFsReadBinaryFileSync.createRequestHandler(({ params }) => (0, cspell_service_bus_1.createResponse)({ url: params.url, content: (0, fs_1.readFileSync)((0, url_1.fileURLToPath)(params.url)) }), undefined, 'Node: Sync Read Binary File.');
 /**
  * Handle UTF-8 Text File Reads
  */
-const handleRequestFsReadFile = requests_1.RequestFsReadFile.createRequestHandler((req, _, dispatcher) => {
+const handleRequestFsReadFile = index_js_2.RequestFsReadFile.createRequestHandler((req, _, dispatcher) => {
     const { url, encoding } = req.params;
-    const res = dispatcher.dispatch(requests_1.RequestFsReadBinaryFile.create({ url }));
+    const res = dispatcher.dispatch(index_js_2.RequestFsReadBinaryFile.create({ url }));
     if (!(0, cspell_service_bus_1.isServiceResponseSuccess)(res)) {
         (0, assert_1.default)((0, cspell_service_bus_1.isServiceResponseFailure)(res));
         return (0, cspell_service_bus_1.createResponseFail)(req, res.error);
@@ -48,9 +49,9 @@ const handleRequestFsReadFile = requests_1.RequestFsReadFile.createRequestHandle
 /**
  * Handle UTF-8 Text File Reads
  */
-const handleRequestFsReadFileSync = requests_1.RequestFsReadFileSync.createRequestHandler((req, _, dispatcher) => {
+const handleRequestFsReadFileSync = index_js_2.RequestFsReadFileSync.createRequestHandler((req, _, dispatcher) => {
     const { url, encoding } = req.params;
-    const res = dispatcher.dispatch(requests_1.RequestFsReadBinaryFileSync.create({ url }));
+    const res = dispatcher.dispatch(index_js_2.RequestFsReadBinaryFileSync.create({ url }));
     if (!(0, cspell_service_bus_1.isServiceResponseSuccess)(res)) {
         (0, assert_1.default)((0, cspell_service_bus_1.isServiceResponseFailure)(res));
         return (0, cspell_service_bus_1.createResponseFail)(req, res.error);
@@ -63,75 +64,75 @@ const handleRequestFsReadFileSync = requests_1.RequestFsReadFileSync.createReque
 /**
  * Handle deflating gzip data
  */
-const handleRequestZlibInflate = requests_1.RequestZlibInflate.createRequestHandler(({ params }) => (0, cspell_service_bus_1.createResponse)((0, zlib_1.gunzipSync)(params.data).toString('utf-8')), undefined, 'Node: gz deflate.');
+const handleRequestZlibInflate = index_js_2.RequestZlibInflate.createRequestHandler(({ params }) => (0, cspell_service_bus_1.createResponse)((0, zlib_1.gunzipSync)(params.data).toString('utf-8')), undefined, 'Node: gz deflate.');
 const supportedFetchProtocols = { 'http:': true, 'https:': true };
 /**
  * Handle fetching a file from http
  */
-const handleRequestFsReadBinaryFileHttp = requests_1.RequestFsReadBinaryFile.createRequestHandler((req, next) => {
+const handleRequestFsReadBinaryFileHttp = index_js_2.RequestFsReadBinaryFile.createRequestHandler((req, next) => {
     const { url } = req.params;
     if (!(url.protocol in supportedFetchProtocols))
         return next(req);
-    return (0, cspell_service_bus_1.createResponse)((0, fetch_1.fetchURL)(url).then((content) => ({ url, content })));
+    return (0, cspell_service_bus_1.createResponse)((0, fetch_js_1.fetchURL)(url).then((content) => ({ url, content })));
 }, undefined, 'Node: Read Http(s) file.');
 /**
  * Handle decoding a data url
  */
-const handleRequestFsReadBinaryFileSyncData = requests_1.RequestFsReadBinaryFileSync.createRequestHandler((req, next) => {
+const handleRequestFsReadBinaryFileSyncData = index_js_2.RequestFsReadBinaryFileSync.createRequestHandler((req, next) => {
     const { url } = req.params;
     if (url.protocol !== 'data:')
         return next(req);
-    const data = (0, dataUrl_1.decodeDataUrl)(url);
+    const data = (0, dataUrl_js_1.decodeDataUrl)(url);
     return (0, cspell_service_bus_1.createResponse)({ url, content: data.data, baseFilename: data.attributes.get('filename') });
 }, undefined, 'Node: Read data: urls.');
 /**
  * Handle decoding a data url
  */
-const handleRequestFsReadBinaryFileData = requests_1.RequestFsReadBinaryFile.createRequestHandler((req, next, dispatcher) => {
+const handleRequestFsReadBinaryFileData = index_js_2.RequestFsReadBinaryFile.createRequestHandler((req, next, dispatcher) => {
     const { url } = req.params;
     if (url.protocol !== 'data:')
         return next(req);
-    const res = dispatcher.dispatch(requests_1.RequestFsReadBinaryFileSync.create(req.params));
+    const res = dispatcher.dispatch(index_js_2.RequestFsReadBinaryFileSync.create(req.params));
     if (!(0, cspell_service_bus_1.isServiceResponseSuccess)(res))
         return res;
     return (0, cspell_service_bus_1.createResponse)(Promise.resolve(res.value));
 }, undefined, 'Node: Read data: urls.');
 function bufferToText(buf, encoding) {
-    return buf[0] === 0x1f && buf[1] === 0x8b ? bufferToText((0, zlib_1.gunzipSync)(buf), encoding) : buf.toString(encoding);
+    return buf[0] === 0x1f && buf[1] === 0x8b ? (0, encode_decode_js_1.decode)((0, zlib_1.gunzipSync)(buf), encoding) : (0, encode_decode_js_1.decode)(buf, encoding);
 }
 /**
  * Handle fs:stat
  */
-const handleRequestFsStat = requests_1.RequestFsStat.createRequestHandler(({ params }) => (0, cspell_service_bus_1.createResponse)(fs_1.promises.stat((0, url_1.fileURLToPath)(params.url))), undefined, 'Node: fs.stat.');
+const handleRequestFsStat = index_js_2.RequestFsStat.createRequestHandler(({ params }) => (0, cspell_service_bus_1.createResponse)(fs_1.promises.stat((0, url_1.fileURLToPath)(params.url))), undefined, 'Node: fs.stat.');
 /**
  * Handle fs:statSync
  */
-const handleRequestFsStatSync = requests_1.RequestFsStatSync.createRequestHandler((req) => {
+const handleRequestFsStatSync = index_js_2.RequestFsStatSync.createRequestHandler((req) => {
     const { params } = req;
     try {
         return (0, cspell_service_bus_1.createResponse)((0, fs_1.statSync)((0, url_1.fileURLToPath)(params.url)));
     }
     catch (e) {
-        return (0, cspell_service_bus_1.createResponseFail)(req, (0, errors_1.toError)(e));
+        return (0, cspell_service_bus_1.createResponseFail)(req, (0, index_js_1.toError)(e));
     }
 }, undefined, 'Node: fs.stat.');
 /**
  * Handle deflating gzip data
  */
-const handleRequestFsStatHttp = requests_1.RequestFsStat.createRequestHandler((req, next) => {
+const handleRequestFsStatHttp = index_js_2.RequestFsStat.createRequestHandler((req, next) => {
     const { url } = req.params;
     if (!(url.protocol in supportedFetchProtocols))
         return next(req);
-    return (0, cspell_service_bus_1.createResponse)((0, stat_1.getStatHttp)(url));
+    return (0, cspell_service_bus_1.createResponse)((0, stat_js_1.getStatHttp)(url));
 }, undefined, 'Node: http get stat');
 /**
  * Handle fs:writeFile
  */
-const handleRequestFsWriteFile = requests_1.RequestFsWriteFile.createRequestHandler(({ params }) => (0, cspell_service_bus_1.createResponse)(fs_1.promises.writeFile(params.url, params.content)), undefined, 'Node: fs.writeFile');
+const handleRequestFsWriteFile = index_js_2.RequestFsWriteFile.createRequestHandler(({ params }) => (0, cspell_service_bus_1.createResponse)(fs_1.promises.writeFile(params.url, params.content)), undefined, 'Node: fs.writeFile');
 /**
  * Handle fs:writeFile compressed
  */
-const handleRequestFsWriteFileGz = requests_1.RequestFsWriteFile.createRequestHandler((req, next) => {
+const handleRequestFsWriteFileGz = index_js_2.RequestFsWriteFile.createRequestHandler((req, next) => {
     const { url, content } = req.params;
     if (!isGzFile(url))
         return next(req);

package/dist/cjs/index.d.ts

@@ -0,0 +1,7 @@
+export { toArray as asyncIterableToArray } from './async/asyncIterable.js';
+export type { CSpellIO } from './CSpellIO.js';
+export { CSpellIONode, getDefaultCSpellIO } from './CSpellIONode.js';
+export { getStat, getStatSync, readFile, readFileSync, writeToFile, writeToFileIterable, writeToFileIterableP, } from './file/index.js';
+export type { Stats } from './models/Stats.js';
+export { encodeDataUrl, toDataUrl } from './node/dataUrl.js';
+//# sourceMappingURL=index.d.ts.map