zeed 1.3.0 → 1.4.0

package/dist/node/log/log-rotation.mjs

@@ -1,4 +1,539 @@
-import e from"node:process";import{access as t,constants as n,createReadStream as r,createWriteStream as i}from"node:fs";import{sep as a}from"node:path";import{mkdir as o,open as s,readFile as c,rename as l,stat as u,unlink as d,writeFile as f}from"node:fs/promises";import{exec as p}from"node:child_process";import{Writable as m}from"node:stream";import{setTimeout as h}from"node:timers";import{TextDecoder as g}from"node:util";import{createGzip as _}from"node:zlib";async function v(e){return new Promise(r=>t(e,n.F_OK,e=>r(!e)))}var y=class extends Error{code=`RFS-TOO-MANY`;constructor(){super(`Too many destination file attempts`)}},b=class extends m{createGzip;exec;file;filename;finished;fsCreateReadStream;fsCreateWriteStream;fsOpen;fsReadFile;fsStat;fsUnlink;generator;last;maxTimeout;next;options;size;stdout;prev;rotation;initPromise;timeout;timeoutPromise;constructor(t,n){let{encoding:a,history:o,maxFiles:l,maxSize:f,path:m}=n;super({decodeStrings:!0,defaultEncoding:a}),this.createGzip=_,this.exec=p,this.filename=(m||``)+t(null),this.fsCreateReadStream=r,this.fsCreateWriteStream=i,this.fsOpen=s,this.fsReadFile=c,this.fsStat=u,this.fsUnlink=d,this.generator=t,this.maxTimeout=2147483640,this.options=n,this.stdout=e.stdout,this.file=null,this.initPromise=null,this.timeout=null,this.timeoutPromise=null,this.prev=null,this.next=null,this.rotation=null,this.last=``,this.finished=!1,this.size=0,(l||f)&&(n.history=(m||``)+(o||`${this.generator(null)}.txt`)),this.on(`close`,()=>this.finished?null:this.emit(`finish`)),this.on(`finish`,()=>this.finished=this.clear()),(async()=>{try{this.initPromise=this.init(),await this.initPromise,this.initPromise=null}catch{}})()}_destroy(e,t){this.refinal(e,t)}_final(e){this.refinal(void 0,e)}_write(e,t,n){this.rewrite([{chunk:e,encoding:t}],0,n)}_writev(e,t){this.rewrite(e,0,t)}async refinal(e,t){try{this.clear(),this.initPromise&&await this.initPromise,this.timeoutPromise&&await this.timeoutPromise,await this.reclose()}catch(n){return t(e||n)}t(e)}async rewrite(e,t,n){let{size:r,teeToStdout:i}=this.options;try{this.initPromise&&await this.initPromise;for(let t=0;t<e.length;++t){let{chunk:n}=e[t];this.size+=n.length,this.timeoutPromise&&await this.timeoutPromise,await this.file.write(n),i&&!this.stdout.destroyed&&this.stdout.write(n),r&&this.size>=r&&await this.rotate()}}catch(e){return n(e)}n()}async init(){let{immutable:t,initialRotation:n,interval:r,size:i}=this.options;if(t)return new Promise((t,n)=>e.nextTick(()=>this.immutate(!0).then(t).catch(e=>n(e))));let a;try{a=await u(this.filename)}catch(e){if(e.code!==`ENOENT`)throw e;return this.reopen(0)}if(!a.isFile())throw Error(`Can't write on: ${this.filename} (it is not a file)`);if(n){this.intervalBounds(this.now());let e=this.prev;if(this.intervalBounds(new Date(a.mtime.getTime())),e!==this.prev)return this.rotate()}return this.size=a.size,!i||a.size<i?this.reopen(a.size):(r&&this.intervalBounds(this.now()),this.rotate())}async makePath(e){return await o(e.split(a).slice(0,-1).join(a),{recursive:!0}),e}async reopen(e){let t;try{t=await s(this.filename,`a`,this.options.mode)}catch(e){if(e.code!==`ENOENT`)throw e;await this.makePath(this.filename),t=await s(this.filename,`a`,this.options.mode)}this.file=t,this.size=e,this.interval(),this.emit(`open`,this.filename)}async reclose(){let{file:e}=this;if(e)return this.file=null,e.close()}now(){return new Date}async rotate(){let{immutable:e,rotate:t}=this.options;return this.size=0,this.rotation=this.now(),this.clear(),this.emit(`rotation`),await this.reclose(),t?this.classical():e?this.immutate(!1):this.move()}async findName(){let{interval:e,path:t,intervalBoundary:n}=this.options;for(let r=1;r<1e3;++r){let i=(t||``)+this.generator(e&&n?new Date(this.prev):this.rotation,r);if(!await v(i))return i}throw new y}async move(){let{compress:e}=this.options,t=await this.findName();return await this.touch(t),e?await this.compress(t):await l(this.filename,t),this.rotated(t)}async touch(e){let t;try{t=await this.fsOpen(e,`a`)}catch(n){if(n.code!==`ENOENT`)throw n;await this.makePath(e),t=await s(e,`a`)}return await t.close(),this.unlink(e)}async classical(){let{compress:e,path:t,rotate:n=0}=this.options,r=``;for(let i=n;i>0;--i){let n=t+this.generator(i),a=i===1?this.filename:t+this.generator(i-1);if(await v(a))if(r||=n,i===1&&e)await this.compress(n);else try{await l(a,n)}catch(e){if(e.code!==`ENOENT`)throw e;await this.makePath(n),await l(a,n)}}return this.rotated(r)}clear(){return this.timeout&&=(clearTimeout(this.timeout),null),!0}intervalBoundsBig(e){let t=this.options.intervalUTC?e.getUTCFullYear():e.getFullYear(),n=this.options.intervalUTC?e.getUTCMonth():e.getMonth(),r=this.options.intervalUTC?e.getUTCDate():e.getDate(),i=this.options.intervalUTC?e.getUTCHours():e.getHours(),{num:a,unit:o}=this.options.interval;o===`M`?(r=1,i=0):i=o===`d`?0:Number.parseInt(i/a,10)*a,this.prev=new Date(t,n,r,i,0,0,0).getTime(),o===`M`?n+=a:o===`d`?r+=a:i+=a,this.next=new Date(t,n,r,i,0,0,0).getTime()}intervalBounds(e){let t=this.options.interval.unit;if(t===`M`||t===`d`||t===`h`)this.intervalBoundsBig(e);else{let n=1e3*this.options.interval.num;t===`m`&&(n*=60),this.prev=Number.parseInt(String(e.getTime()/n),10)*n,this.next=this.prev+n}return new Date(this.prev)}interval(){if(!this.options.interval)return;this.intervalBounds(this.now());let e=async()=>{let t=this.next-this.now().getTime();if(t<=0)try{this.timeoutPromise=this.rotate(),await this.timeoutPromise,this.timeoutPromise=null}catch{}else this.timeout=h(e,t>this.maxTimeout?this.maxTimeout:t),this.timeout&&typeof this.timeout.unref==`function`&&this.timeout.unref()};e()}async compress(e){let{compress:t}=this.options;return typeof t==`function`?await new Promise((n,r)=>{this.exec(t(this.filename,e),(e,t,i)=>{this.emit(`external`,t,i),e?r(e):n()})}):await this.gzip(e),this.unlink(this.filename)}async gzip(e){let{mode:t}=this.options,n=t?{mode:t}:{},r=this.fsCreateReadStream(this.filename,{}),i=this.fsCreateWriteStream(e,n),a=this.createGzip();return new Promise((e,t)=>{r.once(`error`,t),i.once(`error`,t),a.once(`error`,t),i.once(`finish`,e),r.pipe(a).pipe(i)})}async rotated(e){let{maxFiles:t,maxSize:n}=this.options;return(t||n)&&await this.history(e),this.emit(`rotated`,e),this.reopen(0)}async history(e){let{history:t,maxFiles:n,maxSize:r}=this.options,i=[],a=[e];try{t&&(a=[...(await this.fsReadFile(t,`utf8`)).toString().split(`
-`),e])}catch(e){if(e.code!==`ENOENT`)throw e}for(let e of a)if(e)try{let t=await this.fsStat(e);t.isFile()?i.push({name:e,size:t.size,time:t.mtime.getTime()}):this.emit(`warning`,Error(`File '${e}' contained in history is not a regular file`))}catch(e){if(e.code!==`ENOENT`)throw e}if(i.sort((e,t)=>e.time-t.time),n)for(;i.length>n;){let e=i.shift();e&&await this.unlink(e.name),e&&this.emit(`removed`,e.name,!0)}if(r)for(;i.reduce((e,t)=>e+t.size,0)>r;){let e=i.shift();e&&await this.unlink(e.name),e&&this.emit(`removed`,e.name,!1)}t&&await f(t,`${i.map(e=>e.name).join(`
-`)}\n`,`utf-8`),this.emit(`history`)}async immutate(e){let{size:t}=this.options,n=this.now();for(let r=1;r<1e3;++r){let i=0,a;this.filename=this.options.path+this.generator(n,r);try{a=await this.fsStat(this.filename)}catch(e){if(e.code!==`ENOENT`)throw e}if(a){if(i=a.size,!a.isFile())throw Error(`Can't write on: '${this.filename}' (it is not a file)`);if(t&&i>=t)continue}if(e)return this.last=this.filename,this.reopen(i);await this.rotated(this.last),this.last=this.filename;return}throw new y}async unlink(e){try{await this.fsUnlink(e)}catch(e){if(e.code!==`ENOENT`)throw e;this.emit(`warning`,e)}}};function x(e){return(t,n,r)=>{let i=Number.parseInt(String(r),10);if(t!==`number`||Number.isNaN(i)||i<=0)throw Error(`'${e}' option must be a positive integer number`)}}function S(e,t){return(n,r,i)=>{if(n!==`string`)throw Error(`Don't know how to handle 'options.${String(e)}' type: ${n}`);r[e]=t(i)}}function C(e,t,n){let r={};if(r.num=Number.parseInt(e,10),Number.isNaN(r.num))throw Error(`Unknown 'options.${t}' format: ${e}`);if(r.num<=0)throw Error(`A positive integer number is expected for 'options.${t}'`);if(r.unit=e.replace(/^[ 0]*/g,``).substr(`${r.num}`.length,1),r.unit.length===0)throw Error(`Missing unit for 'options.${t}'`);if(!n[r.unit])throw Error(`Unknown 'options.${t}' unit: ${r.unit}`);return r}const w={M:!0,d:!0,h:!0,m:!0,s:!0};function T(e,t,n){if(Number.parseInt(n/e.num,10)*e.num!==n)throw Error(`An integer divider of ${n} is expected as ${t} for 'options.interval'`)}function E(e){let t=C(e,`interval`,w);switch(t.unit){case`h`:T(t,`hours`,24);break;case`m`:T(t,`minutes`,60);break;case`s`:T(t,`seconds`,60);break}return t}const D={B:!0,G:!0,K:!0,M:!0};function O(e){let t=C(e,`size`,D);return t.unit===`K`?t.num*1024:t.unit===`M`?t.num*1048576:t.unit===`G`?t.num*1073741824:t.num}const k={encoding:(e,t,n)=>new g(n),immutable:()=>{},initialRotation:()=>{},interval:S(`interval`,E),intervalBoundary:()=>{},intervalUTC:()=>{},maxFiles:x(`maxFiles`),maxSize:S(`maxSize`,O),mode:()=>{},omitExtension:()=>{},rotate:x(`rotate`),size:S(`size`,O),teeToStdout:()=>{},compress:(e,t,n)=>{if(n!==!1){if(!n)throw Error(`A value for 'options.compress' must be specified`);if(e===`boolean`)return t.compress=(e,t)=>`cat ${e} | gzip -c9 > ${t}`;if(e!==`function`){if(e!==`string`)throw Error(`Don't know how to handle 'options.compress' type: ${e}`);if(n!==`gzip`)throw Error(`Don't know how to handle compression method: ${n}`)}}},history:e=>{if(e!==`string`)throw Error(`Don't know how to handle 'options.history' type: ${e}`)},path:(e,t,n)=>{if(e!==`string`)throw Error(`Don't know how to handle 'options.path' type: ${e}`);n.at(-1)!==a&&(t.path=n+a)}};function A(e){let t={};for(let n of Object.keys(e)){let r=n,i=e[r],a=typeof i;if(t[r]=i,!(r in k))throw Error(`Unknown option: ${r}`);k[r](a,t,i)}return t.path||=``,t.interval||(delete t.immutable,delete t.initialRotation,delete t.intervalBoundary,delete t.intervalUTC),t.rotate&&(delete t.history,delete t.immutable,delete t.maxFiles,delete t.maxSize,delete t.intervalBoundary,delete t.intervalUTC),t.immutable&&delete t.compress,t.intervalBoundary||delete t.initialRotation,t}function j(e,t,n){return(r,i)=>{let a=i||0;return a?`${e}.${a}${t&&!n?`.gz`:``}`:e}}function M(e,t,n){let r=e=>(e>9?``:`0`)+e;return(i,a)=>{if(!i)return e;let o=typeof i==`number`?new Date(i):i,s=`${o.getFullYear()}${r(o.getMonth()+1)}`,c=r(o.getDate()),l=r(o.getHours()),u=r(o.getMinutes());return`${s+c}-${l}${u}-${r(a||0)}-${e}${t&&!n?`.gz`:``}`}}function N(e,t){if(t===void 0)t={};else if(typeof t!=`object`)throw Error(`The "options" argument must be of type object. Received type ${typeof t}`);let n=A(t),{compress:r,omitExtension:i}=n,a;if(typeof e==`string`)a=n.rotate?j(e,!!r,!!i):M(e,!!r,!!i);else if(typeof e==`function`)a=e;else throw Error(`The "filename" argument must be one of type string or function. Received type ${typeof e}`);return new b(a,n)}export{b as RotatingFileStream,y as RotatingFileStreamError,N as createRotationStream};
+import process from "node:process";
+import { access, constants, createReadStream, createWriteStream } from "node:fs";
+import { sep } from "node:path";
+import { mkdir, open, readFile, rename, stat, unlink, writeFile } from "node:fs/promises";
+import { exec } from "node:child_process";
+import { Writable } from "node:stream";
+import { setTimeout } from "node:timers";
+import { TextDecoder } from "node:util";
+import { createGzip } from "node:zlib";
+
+//#region src/node/log/log-rotation.ts
+async function exists(filename) {
+	return new Promise((resolve) => access(filename, constants.F_OK, (error) => resolve(!error)));
+}
+var RotatingFileStreamError = class extends Error {
+	code = "RFS-TOO-MANY";
+	constructor() {
+		super("Too many destination file attempts");
+	}
+};
+var RotatingFileStream = class extends Writable {
+	createGzip;
+	exec;
+	file;
+	filename;
+	finished;
+	fsCreateReadStream;
+	fsCreateWriteStream;
+	fsOpen;
+	fsReadFile;
+	fsStat;
+	fsUnlink;
+	generator;
+	last;
+	maxTimeout;
+	next;
+	options;
+	size;
+	stdout;
+	prev;
+	rotation;
+	initPromise;
+	timeout;
+	timeoutPromise;
+	constructor(generator, options) {
+		const { encoding, history, maxFiles, maxSize, path } = options;
+		super({
+			decodeStrings: true,
+			defaultEncoding: encoding
+		});
+		this.createGzip = createGzip;
+		this.exec = exec;
+		this.filename = (path || "") + generator(null);
+		this.fsCreateReadStream = createReadStream;
+		this.fsCreateWriteStream = createWriteStream;
+		this.fsOpen = open;
+		this.fsReadFile = readFile;
+		this.fsStat = stat;
+		this.fsUnlink = unlink;
+		this.generator = generator;
+		this.maxTimeout = 2147483640;
+		this.options = options;
+		this.stdout = process.stdout;
+		this.file = null;
+		this.initPromise = null;
+		this.timeout = null;
+		this.timeoutPromise = null;
+		this.prev = null;
+		this.next = null;
+		this.rotation = null;
+		this.last = "";
+		this.finished = false;
+		this.size = 0;
+		if (maxFiles || maxSize) options.history = (path || "") + (history || `${this.generator(null)}.txt`);
+		this.on("close", () => this.finished ? null : this.emit("finish"));
+		this.on("finish", () => this.finished = this.clear());
+		(async () => {
+			try {
+				this.initPromise = this.init();
+				await this.initPromise;
+				this.initPromise = null;
+			} catch (e) {}
+		})();
+	}
+	_destroy(error, callback) {
+		this.refinal(error, callback);
+	}
+	_final(callback) {
+		this.refinal(void 0, callback);
+	}
+	_write(chunk, encoding, callback) {
+		this.rewrite([{
+			chunk,
+			encoding
+		}], 0, callback);
+	}
+	_writev(chunks, callback) {
+		this.rewrite(chunks, 0, callback);
+	}
+	async refinal(error, callback) {
+		try {
+			this.clear();
+			if (this.initPromise) await this.initPromise;
+			if (this.timeoutPromise) await this.timeoutPromise;
+			await this.reclose();
+		} catch (e) {
+			return callback(error || e);
+		}
+		callback(error);
+	}
+	async rewrite(chunks, index, callback) {
+		const { size, teeToStdout } = this.options;
+		try {
+			if (this.initPromise) await this.initPromise;
+			for (let i = 0; i < chunks.length; ++i) {
+				const { chunk } = chunks[i];
+				this.size += chunk.length;
+				if (this.timeoutPromise) await this.timeoutPromise;
+				await this.file.write(chunk);
+				if (teeToStdout && !this.stdout.destroyed) this.stdout.write(chunk);
+				if (size && this.size >= size) await this.rotate();
+			}
+		} catch (e) {
+			return callback(e);
+		}
+		callback();
+	}
+	async init() {
+		const { immutable, initialRotation, interval, size } = this.options;
+		if (immutable) return new Promise((resolve, reject) => process.nextTick(() => this.immutate(true).then(resolve).catch((err) => reject(err))));
+		let stats;
+		try {
+			stats = await stat(this.filename);
+		} catch (e) {
+			if (e.code !== "ENOENT") throw e;
+			return this.reopen(0);
+		}
+		if (!stats.isFile()) throw new Error(`Can't write on: ${this.filename} (it is not a file)`);
+		if (initialRotation) {
+			this.intervalBounds(this.now());
+			const prev = this.prev;
+			this.intervalBounds(new Date(stats.mtime.getTime()));
+			if (prev !== this.prev) return this.rotate();
+		}
+		this.size = stats.size;
+		if (!size || stats.size < size) return this.reopen(stats.size);
+		if (interval) this.intervalBounds(this.now());
+		return this.rotate();
+	}
+	async makePath(name) {
+		await mkdir(name.split(sep).slice(0, -1).join(sep), { recursive: true });
+		return name;
+	}
+	async reopen(size) {
+		let file;
+		try {
+			file = await open(this.filename, "a", this.options.mode);
+		} catch (e) {
+			if (e.code !== "ENOENT") throw e;
+			await this.makePath(this.filename);
+			file = await open(this.filename, "a", this.options.mode);
+		}
+		this.file = file;
+		this.size = size;
+		this.interval();
+		this.emit("open", this.filename);
+	}
+	async reclose() {
+		const { file } = this;
+		if (!file) return;
+		this.file = null;
+		return file.close();
+	}
+	now() {
+		return /* @__PURE__ */ new Date();
+	}
+	async rotate() {
+		const { immutable, rotate } = this.options;
+		this.size = 0;
+		this.rotation = this.now();
+		this.clear();
+		this.emit("rotation");
+		await this.reclose();
+		if (rotate) return this.classical();
+		if (immutable) return this.immutate(false);
+		return this.move();
+	}
+	async findName() {
+		const { interval, path, intervalBoundary } = this.options;
+		for (let index = 1; index < 1e3; ++index) {
+			const filename = (path || "") + this.generator(interval && intervalBoundary ? new Date(this.prev) : this.rotation, index);
+			if (!await exists(filename)) return filename;
+		}
+		throw new RotatingFileStreamError();
+	}
+	async move() {
+		const { compress } = this.options;
+		const filename = await this.findName();
+		await this.touch(filename);
+		if (compress) await this.compress(filename);
+		else await rename(this.filename, filename);
+		return this.rotated(filename);
+	}
+	async touch(filename) {
+		let file;
+		try {
+			file = await this.fsOpen(filename, "a");
+		} catch (e) {
+			if (e.code !== "ENOENT") throw e;
+			await this.makePath(filename);
+			file = await open(filename, "a");
+		}
+		await file.close();
+		return this.unlink(filename);
+	}
+	async classical() {
+		const { compress, path, rotate = 0 } = this.options;
+		let rotatedName = "";
+		for (let count = rotate; count > 0; --count) {
+			const currName = path + this.generator(count);
+			const prevName = count === 1 ? this.filename : path + this.generator(count - 1);
+			if (!await exists(prevName)) continue;
+			if (!rotatedName) rotatedName = currName;
+			if (count === 1 && compress) await this.compress(currName);
+			else try {
+				await rename(prevName, currName);
+			} catch (e) {
+				if (e.code !== "ENOENT") throw e;
+				await this.makePath(currName);
+				await rename(prevName, currName);
+			}
+		}
+		return this.rotated(rotatedName);
+	}
+	clear() {
+		if (this.timeout) {
+			clearTimeout(this.timeout);
+			this.timeout = null;
+		}
+		return true;
+	}
+	intervalBoundsBig(now) {
+		const year = this.options.intervalUTC ? now.getUTCFullYear() : now.getFullYear();
+		let month = this.options.intervalUTC ? now.getUTCMonth() : now.getMonth();
+		let day = this.options.intervalUTC ? now.getUTCDate() : now.getDate();
+		let hours = this.options.intervalUTC ? now.getUTCHours() : now.getHours();
+		const { num, unit } = this.options.interval;
+		if (unit === "M") {
+			day = 1;
+			hours = 0;
+		} else if (unit === "d") hours = 0;
+		else hours = Number.parseInt(hours / num, 10) * num;
+		this.prev = new Date(year, month, day, hours, 0, 0, 0).getTime();
+		if (unit === "M") month += num;
+		else if (unit === "d") day += num;
+		else hours += num;
+		this.next = new Date(year, month, day, hours, 0, 0, 0).getTime();
+	}
+	intervalBounds(now) {
+		const unit = this.options.interval.unit;
+		if (unit === "M" || unit === "d" || unit === "h") this.intervalBoundsBig(now);
+		else {
+			let period = 1e3 * this.options.interval.num;
+			if (unit === "m") period *= 60;
+			this.prev = Number.parseInt(String(now.getTime() / period), 10) * period;
+			this.next = this.prev + period;
+		}
+		return new Date(this.prev);
+	}
+	interval() {
+		if (!this.options.interval) return;
+		this.intervalBounds(this.now());
+		const set = async () => {
+			const time = this.next - this.now().getTime();
+			if (time <= 0) try {
+				this.timeoutPromise = this.rotate();
+				await this.timeoutPromise;
+				this.timeoutPromise = null;
+			} catch (e) {}
+			else {
+				this.timeout = setTimeout(set, time > this.maxTimeout ? this.maxTimeout : time);
+				if (this.timeout && typeof this.timeout.unref === "function") this.timeout.unref();
+			}
+		};
+		set();
+	}
+	async compress(filename) {
+		const { compress } = this.options;
+		if (typeof compress === "function") await new Promise((resolve, reject) => {
+			this.exec(compress(this.filename, filename), (error, stdout, stderr) => {
+				this.emit("external", stdout, stderr);
+				error ? reject(error) : resolve();
+			});
+		});
+		else await this.gzip(filename);
+		return this.unlink(this.filename);
+	}
+	async gzip(filename) {
+		const { mode } = this.options;
+		const options = mode ? { mode } : {};
+		const inp = this.fsCreateReadStream(this.filename, {});
+		const out = this.fsCreateWriteStream(filename, options);
+		const zip = this.createGzip();
+		return new Promise((resolve, reject) => {
+			inp.once("error", reject);
+			out.once("error", reject);
+			zip.once("error", reject);
+			out.once("finish", resolve);
+			inp.pipe(zip).pipe(out);
+		});
+	}
+	async rotated(filename) {
+		const { maxFiles, maxSize } = this.options;
+		if (maxFiles || maxSize) await this.history(filename);
+		this.emit("rotated", filename);
+		return this.reopen(0);
+	}
+	async history(filename) {
+		const { history, maxFiles, maxSize } = this.options;
+		const res = [];
+		let files = [filename];
+		try {
+			if (history) files = [...(await this.fsReadFile(history, "utf8")).toString().split("\n"), filename];
+		} catch (e) {
+			if (e.code !== "ENOENT") throw e;
+		}
+		for (const file of files) if (file) try {
+			const stats = await this.fsStat(file);
+			if (stats.isFile()) res.push({
+				name: file,
+				size: stats.size,
+				time: stats.mtime.getTime()
+			});
+			else this.emit("warning", /* @__PURE__ */ new Error(`File '${file}' contained in history is not a regular file`));
+		} catch (e) {
+			if (e.code !== "ENOENT") throw e;
+		}
+		res.sort((a, b) => a.time - b.time);
+		if (maxFiles) while (res.length > maxFiles) {
+			const file = res.shift();
+			if (file) await this.unlink(file.name);
+			if (file) this.emit("removed", file.name, true);
+		}
+		if (maxSize) while (res.reduce((size, file) => size + file.size, 0) > maxSize) {
+			const file = res.shift();
+			if (file) await this.unlink(file.name);
+			if (file) this.emit("removed", file.name, false);
+		}
+		if (history) await writeFile(history, `${res.map((e) => e.name).join("\n")}\n`, "utf-8");
+		this.emit("history");
+	}
+	async immutate(first) {
+		const { size } = this.options;
+		const now = this.now();
+		for (let index = 1; index < 1e3; ++index) {
+			let fileSize = 0;
+			let stats;
+			this.filename = this.options.path + this.generator(now, index);
+			try {
+				stats = await this.fsStat(this.filename);
+			} catch (e) {
+				if (e.code !== "ENOENT") throw e;
+			}
+			if (stats) {
+				fileSize = stats.size;
+				if (!stats.isFile()) throw new Error(`Can't write on: '${this.filename}' (it is not a file)`);
+				if (size && fileSize >= size) continue;
+			}
+			if (first) {
+				this.last = this.filename;
+				return this.reopen(fileSize);
+			}
+			await this.rotated(this.last);
+			this.last = this.filename;
+			return;
+		}
+		throw new RotatingFileStreamError();
+	}
+	async unlink(filename) {
+		try {
+			await this.fsUnlink(filename);
+		} catch (e) {
+			if (e.code !== "ENOENT") throw e;
+			this.emit("warning", e);
+		}
+	}
+};
+function buildNumberCheck(field) {
+	return (type, options, value) => {
+		const converted = Number.parseInt(String(value), 10);
+		if (type !== "number" || Number.isNaN(converted) || converted <= 0) throw new Error(`'${field}' option must be a positive integer number`);
+	};
+}
+function buildStringCheck(field, check) {
+	return (type, options, value) => {
+		if (type !== "string") throw new Error(`Don't know how to handle 'options.${String(field)}' type: ${type}`);
+		options[field] = check(value);
+	};
+}
+function checkMeasure(value, what, units) {
+	const ret = {};
+	ret.num = Number.parseInt(value, 10);
+	if (Number.isNaN(ret.num)) throw new Error(`Unknown 'options.${what}' format: ${value}`);
+	if (ret.num <= 0) throw new Error(`A positive integer number is expected for 'options.${what}'`);
+	ret.unit = value.replace(/^[ 0]*/g, "").substr(`${ret.num}`.length, 1);
+	if (ret.unit.length === 0) throw new Error(`Missing unit for 'options.${what}'`);
+	if (!units[ret.unit]) throw new Error(`Unknown 'options.${what}' unit: ${ret.unit}`);
+	return ret;
+}
+const intervalUnits = {
+	M: true,
+	d: true,
+	h: true,
+	m: true,
+	s: true
+};
+function checkIntervalUnit(ret, unit, amount) {
+	if (Number.parseInt(amount / ret.num, 10) * ret.num !== amount) throw new Error(`An integer divider of ${amount} is expected as ${unit} for 'options.interval'`);
+}
+function checkInterval(value) {
+	const ret = checkMeasure(value, "interval", intervalUnits);
+	switch (ret.unit) {
+		case "h":
+			checkIntervalUnit(ret, "hours", 24);
+			break;
+		case "m":
+			checkIntervalUnit(ret, "minutes", 60);
+			break;
+		case "s":
+			checkIntervalUnit(ret, "seconds", 60);
+			break;
+	}
+	return ret;
+}
+const sizeUnits = {
+	B: true,
+	G: true,
+	K: true,
+	M: true
+};
+function checkSize(value) {
+	const ret = checkMeasure(value, "size", sizeUnits);
+	if (ret.unit === "K") return ret.num * 1024;
+	if (ret.unit === "M") return ret.num * 1048576;
+	if (ret.unit === "G") return ret.num * 1073741824;
+	return ret.num;
+}
+const checks = {
+	encoding: (type, options, value) => new TextDecoder(value),
+	immutable: () => {},
+	initialRotation: () => {},
+	interval: buildStringCheck("interval", checkInterval),
+	intervalBoundary: () => {},
+	intervalUTC: () => {},
+	maxFiles: buildNumberCheck("maxFiles"),
+	maxSize: buildStringCheck("maxSize", checkSize),
+	mode: () => {},
+	omitExtension: () => {},
+	rotate: buildNumberCheck("rotate"),
+	size: buildStringCheck("size", checkSize),
+	teeToStdout: () => {},
+	compress: (type, options, value) => {
+		if (value === false) return;
+		if (!value) throw new Error("A value for 'options.compress' must be specified");
+		if (type === "boolean") return options.compress = (source, dest) => `cat ${source} | gzip -c9 > ${dest}`;
+		if (type === "function") return;
+		if (type !== "string") throw new Error(`Don't know how to handle 'options.compress' type: ${type}`);
+		if (value !== "gzip") throw new Error(`Don't know how to handle compression method: ${value}`);
+	},
+	history: (type) => {
+		if (type !== "string") throw new Error(`Don't know how to handle 'options.history' type: ${type}`);
+	},
+	path: (type, options, value) => {
+		if (type !== "string") throw new Error(`Don't know how to handle 'options.path' type: ${type}`);
+		if (value.at(-1) !== sep) options.path = value + sep;
+	}
+};
+function checkOpts(options) {
+	const ret = {};
+	for (const k of Object.keys(options)) {
+		const opt = k;
+		const value = options[opt];
+		const type = typeof value;
+		ret[opt] = value;
+		if (!(opt in checks)) throw new Error(`Unknown option: ${opt}`);
+		checks[opt](type, ret, value);
+	}
+	if (!ret.path) ret.path = "";
+	if (!ret.interval) {
+		delete ret.immutable;
+		delete ret.initialRotation;
+		delete ret.intervalBoundary;
+		delete ret.intervalUTC;
+	}
+	if (ret.rotate) {
+		delete ret.history;
+		delete ret.immutable;
+		delete ret.maxFiles;
+		delete ret.maxSize;
+		delete ret.intervalBoundary;
+		delete ret.intervalUTC;
+	}
+	if (ret.immutable) delete ret.compress;
+	if (!ret.intervalBoundary) delete ret.initialRotation;
+	return ret;
+}
+function createClassical(filename, compress, omitExtension) {
+	return (time, index) => {
+		const idx = index || 0;
+		return idx ? `${filename}.${idx}${compress && !omitExtension ? ".gz" : ""}` : filename;
+	};
+}
+function createGenerator(filename, compress, omitExtension) {
+	const pad = (num) => (num > 9 ? "" : "0") + num;
+	return (time, index) => {
+		if (!time) return filename;
+		const t = typeof time === "number" ? new Date(time) : time;
+		const month = `${t.getFullYear()}${pad(t.getMonth() + 1)}`;
+		const day = pad(t.getDate());
+		const hour = pad(t.getHours());
+		const minute = pad(t.getMinutes());
+		return `${month + day}-${hour}${minute}-${pad(index || 0)}-${filename}${compress && !omitExtension ? ".gz" : ""}`;
+	};
+}
+function createRotationStream(filename, options) {
+	if (typeof options === "undefined") options = {};
+	else if (typeof options !== "object") throw new Error(`The "options" argument must be of type object. Received type ${typeof options}`);
+	const opts = checkOpts(options);
+	const { compress, omitExtension } = opts;
+	let generator;
+	if (typeof filename === "string") generator = opts.rotate ? createClassical(filename, !!compress, !!omitExtension) : createGenerator(filename, !!compress, !!omitExtension);
+	else if (typeof filename === "function") generator = filename;
+	else throw new Error(`The "filename" argument must be one of type string or function. Received type ${typeof filename}`);
+	return new RotatingFileStream(generator, opts);
+}
+
+//#endregion
+export { RotatingFileStream, RotatingFileStreamError, createRotationStream };
 //# sourceMappingURL=log-rotation.mjs.map