Brunobkr/llama.cpp_AlgMor24_github

1//#region rolldown:runtime2var __create = Object.create;3var __defProp = Object.defineProperty;4var __getOwnPropDesc = Object.getOwnPropertyDescriptor;5var __getOwnPropNames = Object.getOwnPropertyNames;6var __getProtoOf = Object.getPrototypeOf;7var __hasOwnProp = Object.prototype.hasOwnProperty;8var __copyProps = (to, from, except, desc) => {9	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {10		key = keys[i];11		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {12			get: ((k) => from[k]).bind(null, key),13			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable14		});15	}16	return to;17};18var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {19	value: mod,20	enumerable: true21}) : target, mod));22 23//#endregion24const path = __toESM(require("path"));25const fs = __toESM(require("fs"));26 27//#region src/utils.ts28function cleanPath(path$1) {29	let normalized = (0, path.normalize)(path$1);30	if (normalized.length > 1 && normalized[normalized.length - 1] === path.sep) normalized = normalized.substring(0, normalized.length - 1);31	return normalized;32}33const SLASHES_REGEX = /[\\/]/g;34function convertSlashes(path$1, separator) {35	return path$1.replace(SLASHES_REGEX, separator);36}37const WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;38function isRootDirectory(path$1) {39	return path$1 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path$1);40}41function normalizePath(path$1, options) {42	const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;43	const pathNeedsCleaning = process.platform === "win32" && path$1.includes("/") || path$1.startsWith(".");44	if (resolvePaths) path$1 = (0, path.resolve)(path$1);45	if (normalizePath$1 || pathNeedsCleaning) path$1 = cleanPath(path$1);46	if (path$1 === ".") return "";47	const needsSeperator = path$1[path$1.length - 1] !== pathSeparator;48	return convertSlashes(needsSeperator ? path$1 + pathSeparator : path$1, pathSeparator);49}50 51//#endregion52//#region src/api/functions/join-path.ts53function joinPathWithBasePath(filename, directoryPath) {54	return directoryPath + filename;55}56function joinPathWithRelativePath(root, options) {57	return function(filename, directoryPath) {58		const sameRoot = directoryPath.startsWith(root);59		if (sameRoot) return directoryPath.slice(root.length) + filename;60		else return convertSlashes((0, path.relative)(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename;61	};62}63function joinPath(filename) {64	return filename;65}66function joinDirectoryPath(filename, directoryPath, separator) {67	return directoryPath + filename + separator;68}69function build$7(root, options) {70	const { relativePaths, includeBasePath } = options;71	return relativePaths && root ? joinPathWithRelativePath(root, options) : includeBasePath ? joinPathWithBasePath : joinPath;72}73 74//#endregion75//#region src/api/functions/push-directory.ts76function pushDirectoryWithRelativePath(root) {77	return function(directoryPath, paths) {78		paths.push(directoryPath.substring(root.length) || ".");79	};80}81function pushDirectoryFilterWithRelativePath(root) {82	return function(directoryPath, paths, filters) {83		const relativePath = directoryPath.substring(root.length) || ".";84		if (filters.every((filter) => filter(relativePath, true))) paths.push(relativePath);85	};86}87const pushDirectory = (directoryPath, paths) => {88	paths.push(directoryPath || ".");89};90const pushDirectoryFilter = (directoryPath, paths, filters) => {91	const path$1 = directoryPath || ".";92	if (filters.every((filter) => filter(path$1, true))) paths.push(path$1);93};94const empty$2 = () => {};95function build$6(root, options) {96	const { includeDirs, filters, relativePaths } = options;97	if (!includeDirs) return empty$2;98	if (relativePaths) return filters && filters.length ? pushDirectoryFilterWithRelativePath(root) : pushDirectoryWithRelativePath(root);99	return filters && filters.length ? pushDirectoryFilter : pushDirectory;100}101 102//#endregion103//#region src/api/functions/push-file.ts104const pushFileFilterAndCount = (filename, _paths, counts, filters) => {105	if (filters.every((filter) => filter(filename, false))) counts.files++;106};107const pushFileFilter = (filename, paths, _counts, filters) => {108	if (filters.every((filter) => filter(filename, false))) paths.push(filename);109};110const pushFileCount = (_filename, _paths, counts, _filters) => {111	counts.files++;112};113const pushFile = (filename, paths) => {114	paths.push(filename);115};116const empty$1 = () => {};117function build$5(options) {118	const { excludeFiles, filters, onlyCounts } = options;119	if (excludeFiles) return empty$1;120	if (filters && filters.length) return onlyCounts ? pushFileFilterAndCount : pushFileFilter;121	else if (onlyCounts) return pushFileCount;122	else return pushFile;123}124 125//#endregion126//#region src/api/functions/get-array.ts127const getArray = (paths) => {128	return paths;129};130const getArrayGroup = () => {131	return [""].slice(0, 0);132};133function build$4(options) {134	return options.group ? getArrayGroup : getArray;135}136 137//#endregion138//#region src/api/functions/group-files.ts139const groupFiles = (groups, directory, files) => {140	groups.push({141		directory,142		files,143		dir: directory144	});145};146const empty = () => {};147function build$3(options) {148	return options.group ? groupFiles : empty;149}150 151//#endregion152//#region src/api/functions/resolve-symlink.ts153const resolveSymlinksAsync = function(path$1, state, callback$1) {154	const { queue, fs: fs$1, options: { suppressErrors } } = state;155	queue.enqueue();156	fs$1.realpath(path$1, (error, resolvedPath) => {157		if (error) return queue.dequeue(suppressErrors ? null : error, state);158		fs$1.stat(resolvedPath, (error$1, stat) => {159			if (error$1) return queue.dequeue(suppressErrors ? null : error$1, state);160			if (stat.isDirectory() && isRecursive(path$1, resolvedPath, state)) return queue.dequeue(null, state);161			callback$1(stat, resolvedPath);162			queue.dequeue(null, state);163		});164	});165};166const resolveSymlinks = function(path$1, state, callback$1) {167	const { queue, fs: fs$1, options: { suppressErrors } } = state;168	queue.enqueue();169	try {170		const resolvedPath = fs$1.realpathSync(path$1);171		const stat = fs$1.statSync(resolvedPath);172		if (stat.isDirectory() && isRecursive(path$1, resolvedPath, state)) return;173		callback$1(stat, resolvedPath);174	} catch (e) {175		if (!suppressErrors) throw e;176	}177};178function build$2(options, isSynchronous) {179	if (!options.resolveSymlinks || options.excludeSymlinks) return null;180	return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;181}182function isRecursive(path$1, resolved, state) {183	if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state);184	let parent = (0, path.dirname)(path$1);185	let depth = 1;186	while (parent !== state.root && depth < 2) {187		const resolvedPath = state.symlinks.get(parent);188		const isSameRoot = !!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath));189		if (isSameRoot) depth++;190		else parent = (0, path.dirname)(parent);191	}192	state.symlinks.set(path$1, resolved);193	return depth > 1;194}195function isRecursiveUsingRealPaths(resolved, state) {196	return state.visited.includes(resolved + state.options.pathSeparator);197}198 199//#endregion200//#region src/api/functions/invoke-callback.ts201const onlyCountsSync = (state) => {202	return state.counts;203};204const groupsSync = (state) => {205	return state.groups;206};207const defaultSync = (state) => {208	return state.paths;209};210const limitFilesSync = (state) => {211	return state.paths.slice(0, state.options.maxFiles);212};213const onlyCountsAsync = (state, error, callback$1) => {214	report(error, callback$1, state.counts, state.options.suppressErrors);215	return null;216};217const defaultAsync = (state, error, callback$1) => {218	report(error, callback$1, state.paths, state.options.suppressErrors);219	return null;220};221const limitFilesAsync = (state, error, callback$1) => {222	report(error, callback$1, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors);223	return null;224};225const groupsAsync = (state, error, callback$1) => {226	report(error, callback$1, state.groups, state.options.suppressErrors);227	return null;228};229function report(error, callback$1, output, suppressErrors) {230	if (error && !suppressErrors) callback$1(error, output);231	else callback$1(null, output);232}233function build$1(options, isSynchronous) {234	const { onlyCounts, group, maxFiles } = options;235	if (onlyCounts) return isSynchronous ? onlyCountsSync : onlyCountsAsync;236	else if (group) return isSynchronous ? groupsSync : groupsAsync;237	else if (maxFiles) return isSynchronous ? limitFilesSync : limitFilesAsync;238	else return isSynchronous ? defaultSync : defaultAsync;239}240 241//#endregion242//#region src/api/functions/walk-directory.ts243const readdirOpts = { withFileTypes: true };244const walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {245	state.queue.enqueue();246	if (currentDepth < 0) return state.queue.dequeue(null, state);247	const { fs: fs$1 } = state;248	state.visited.push(crawlPath);249	state.counts.directories++;250	fs$1.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => {251		callback$1(entries, directoryPath, currentDepth);252		state.queue.dequeue(state.options.suppressErrors ? null : error, state);253	});254};255const walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {256	const { fs: fs$1 } = state;257	if (currentDepth < 0) return;258	state.visited.push(crawlPath);259	state.counts.directories++;260	let entries = [];261	try {262		entries = fs$1.readdirSync(crawlPath || ".", readdirOpts);263	} catch (e) {264		if (!state.options.suppressErrors) throw e;265	}266	callback$1(entries, directoryPath, currentDepth);267};268function build(isSynchronous) {269	return isSynchronous ? walkSync : walkAsync;270}271 272//#endregion273//#region src/api/queue.ts274/**275* This is a custom stateless queue to track concurrent async fs calls.276* It increments a counter whenever a call is queued and decrements it277* as soon as it completes. When the counter hits 0, it calls onQueueEmpty.278*/279var Queue = class {280	count = 0;281	constructor(onQueueEmpty) {282		this.onQueueEmpty = onQueueEmpty;283	}284	enqueue() {285		this.count++;286		return this.count;287	}288	dequeue(error, output) {289		if (this.onQueueEmpty && (--this.count <= 0 || error)) {290			this.onQueueEmpty(error, output);291			if (error) {292				output.controller.abort();293				this.onQueueEmpty = void 0;294			}295		}296	}297};298 299//#endregion300//#region src/api/counter.ts301var Counter = class {302	_files = 0;303	_directories = 0;304	set files(num) {305		this._files = num;306	}307	get files() {308		return this._files;309	}310	set directories(num) {311		this._directories = num;312	}313	get directories() {314		return this._directories;315	}316	/**317	* @deprecated use `directories` instead318	*/319	/* c8 ignore next 3 */320	get dirs() {321		return this._directories;322	}323};324 325//#endregion326//#region src/api/aborter.ts327/**328* AbortController is not supported on Node 14 so we use this until we can drop329* support for Node 14.330*/331var Aborter = class {332	aborted = false;333	abort() {334		this.aborted = true;335	}336};337 338//#endregion339//#region src/api/walker.ts340var Walker = class {341	root;342	isSynchronous;343	state;344	joinPath;345	pushDirectory;346	pushFile;347	getArray;348	groupFiles;349	resolveSymlink;350	walkDirectory;351	callbackInvoker;352	constructor(root, options, callback$1) {353		this.isSynchronous = !callback$1;354		this.callbackInvoker = build$1(options, this.isSynchronous);355		this.root = normalizePath(root, options);356		this.state = {357			root: isRootDirectory(this.root) ? this.root : this.root.slice(0, -1),358			paths: [""].slice(0, 0),359			groups: [],360			counts: new Counter(),361			options,362			queue: new Queue((error, state) => this.callbackInvoker(state, error, callback$1)),363			symlinks: /* @__PURE__ */ new Map(),364			visited: [""].slice(0, 0),365			controller: new Aborter(),366			fs: options.fs || fs367		};368		this.joinPath = build$7(this.root, options);369		this.pushDirectory = build$6(this.root, options);370		this.pushFile = build$5(options);371		this.getArray = build$4(options);372		this.groupFiles = build$3(options);373		this.resolveSymlink = build$2(options, this.isSynchronous);374		this.walkDirectory = build(this.isSynchronous);375	}376	start() {377		this.pushDirectory(this.root, this.state.paths, this.state.options.filters);378		this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk);379		return this.isSynchronous ? this.callbackInvoker(this.state, null) : null;380	}381	walk = (entries, directoryPath, depth) => {382		const { paths, options: { filters, resolveSymlinks: resolveSymlinks$1, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator }, controller } = this.state;383		if (controller.aborted || signal && signal.aborted || maxFiles && paths.length > maxFiles) return;384		const files = this.getArray(this.state.paths);385		for (let i = 0; i < entries.length; ++i) {386			const entry = entries[i];387			if (entry.isFile() || entry.isSymbolicLink() && !resolveSymlinks$1 && !excludeSymlinks) {388				const filename = this.joinPath(entry.name, directoryPath);389				this.pushFile(filename, files, this.state.counts, filters);390			} else if (entry.isDirectory()) {391				let path$1 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);392				if (exclude && exclude(entry.name, path$1)) continue;393				this.pushDirectory(path$1, paths, filters);394				this.walkDirectory(this.state, path$1, path$1, depth - 1, this.walk);395			} else if (this.resolveSymlink && entry.isSymbolicLink()) {396				let path$1 = joinPathWithBasePath(entry.name, directoryPath);397				this.resolveSymlink(path$1, this.state, (stat, resolvedPath) => {398					if (stat.isDirectory()) {399						resolvedPath = normalizePath(resolvedPath, this.state.options);400						if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path$1 + pathSeparator)) return;401						this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path$1 + pathSeparator, depth - 1, this.walk);402					} else {403						resolvedPath = useRealPaths ? resolvedPath : path$1;404						const filename = (0, path.basename)(resolvedPath);405						const directoryPath$1 = normalizePath((0, path.dirname)(resolvedPath), this.state.options);406						resolvedPath = this.joinPath(filename, directoryPath$1);407						this.pushFile(resolvedPath, files, this.state.counts, filters);408					}409				});410			}411		}412		this.groupFiles(this.state.groups, directoryPath, files);413	};414};415 416//#endregion417//#region src/api/async.ts418function promise(root, options) {419	return new Promise((resolve$1, reject) => {420		callback(root, options, (err, output) => {421			if (err) return reject(err);422			resolve$1(output);423		});424	});425}426function callback(root, options, callback$1) {427	let walker = new Walker(root, options, callback$1);428	walker.start();429}430 431//#endregion432//#region src/api/sync.ts433function sync(root, options) {434	const walker = new Walker(root, options);435	return walker.start();436}437 438//#endregion439//#region src/builder/api-builder.ts440var APIBuilder = class {441	constructor(root, options) {442		this.root = root;443		this.options = options;444	}445	withPromise() {446		return promise(this.root, this.options);447	}448	withCallback(cb) {449		callback(this.root, this.options, cb);450	}451	sync() {452		return sync(this.root, this.options);453	}454};455 456//#endregion457//#region src/builder/index.ts458let pm = null;459/* c8 ignore next 6 */460try {461	require.resolve("picomatch");462	pm = require("picomatch");463} catch {}464var Builder = class {465	globCache = {};466	options = {467		maxDepth: Infinity,468		suppressErrors: true,469		pathSeparator: path.sep,470		filters: []471	};472	globFunction;473	constructor(options) {474		this.options = {475			...this.options,476			...options477		};478		this.globFunction = this.options.globFunction;479	}480	group() {481		this.options.group = true;482		return this;483	}484	withPathSeparator(separator) {485		this.options.pathSeparator = separator;486		return this;487	}488	withBasePath() {489		this.options.includeBasePath = true;490		return this;491	}492	withRelativePaths() {493		this.options.relativePaths = true;494		return this;495	}496	withDirs() {497		this.options.includeDirs = true;498		return this;499	}500	withMaxDepth(depth) {501		this.options.maxDepth = depth;502		return this;503	}504	withMaxFiles(limit) {505		this.options.maxFiles = limit;506		return this;507	}508	withFullPaths() {509		this.options.resolvePaths = true;510		this.options.includeBasePath = true;511		return this;512	}513	withErrors() {514		this.options.suppressErrors = false;515		return this;516	}517	withSymlinks({ resolvePaths = true } = {}) {518		this.options.resolveSymlinks = true;519		this.options.useRealPaths = resolvePaths;520		return this.withFullPaths();521	}522	withAbortSignal(signal) {523		this.options.signal = signal;524		return this;525	}526	normalize() {527		this.options.normalizePath = true;528		return this;529	}530	filter(predicate) {531		this.options.filters.push(predicate);532		return this;533	}534	onlyDirs() {535		this.options.excludeFiles = true;536		this.options.includeDirs = true;537		return this;538	}539	exclude(predicate) {540		this.options.exclude = predicate;541		return this;542	}543	onlyCounts() {544		this.options.onlyCounts = true;545		return this;546	}547	crawl(root) {548		return new APIBuilder(root || ".", this.options);549	}550	withGlobFunction(fn) {551		this.globFunction = fn;552		return this;553	}554	/**555	* @deprecated Pass options using the constructor instead:556	* ```ts557	* new fdir(options).crawl("/path/to/root");558	* ```559	* This method will be removed in v7.0560	*/561	/* c8 ignore next 4 */562	crawlWithOptions(root, options) {563		this.options = {564			...this.options,565			...options566		};567		return new APIBuilder(root || ".", this.options);568	}569	glob(...patterns) {570		if (this.globFunction) return this.globWithOptions(patterns);571		return this.globWithOptions(patterns, ...[{ dot: true }]);572	}573	globWithOptions(patterns, ...options) {574		const globFn = this.globFunction || pm;575		/* c8 ignore next 5 */576		if (!globFn) throw new Error("Please specify a glob function to use glob matching.");577		var isMatch = this.globCache[patterns.join("\0")];578		if (!isMatch) {579			isMatch = globFn(patterns, ...options);580			this.globCache[patterns.join("\0")] = isMatch;581		}582		this.options.filters.push((path$1) => isMatch(path$1));583		return this;584	}585};586 587//#endregion588exports.fdir = Builder;