better-supabase 0.12.0 → 0.14.0

package/dist/cli/files-DDvAwTko.js

@@ -1,963 +0,0 @@
-import { i as plain } from "./style-2JfIPVMQ.js";
-import { n as CliError } from "./errors-Caiz_0so.js";
-import { a as sameText, r as readIfExists, t as display } from "./io-BiPX-_J1.js";
-import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
-import { chmod, mkdir, rename, rm, writeFile } from "node:fs/promises";
-//#region ../../node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/diff/base.js
-var Diff = class {
-	diff(oldStr, newStr, options = {}) {
-		let callback;
-		if (typeof options === "function") {
-			callback = options;
-			options = {};
-		} else if ("callback" in options) callback = options.callback;
-		const oldString = this.castInput(oldStr, options);
-		const newString = this.castInput(newStr, options);
-		const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
-		const newTokens = this.removeEmpty(this.tokenize(newString, options));
-		return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
-	}
-	diffWithOptionsObj(oldTokens, newTokens, options, callback) {
-		var _a;
-		const done = (value) => {
-			value = this.postProcess(value, options);
-			if (callback) {
-				setTimeout(function() {
-					callback(value);
-				}, 0);
-				return;
-			} else return value;
-		};
-		const newLen = newTokens.length, oldLen = oldTokens.length;
-		let editLength = 1;
-		let maxEditLength = newLen + oldLen;
-		if (options.maxEditLength != null) maxEditLength = Math.min(maxEditLength, options.maxEditLength);
-		const maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;
-		const abortAfterTimestamp = Date.now() + maxExecutionTime;
-		const bestPath = [{
-			oldPos: -1,
-			lastComponent: void 0
-		}];
-		let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
-		if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
-		let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
-		const execEditLength = () => {
-			for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
-				let basePath;
-				const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
-				if (removePath) bestPath[diagonalPath - 1] = void 0;
-				let canAdd = false;
-				if (addPath) {
-					const addPathNewPos = addPath.oldPos - diagonalPath;
-					canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
-				}
-				const canRemove = removePath && removePath.oldPos + 1 < oldLen;
-				if (!canAdd && !canRemove) {
-					bestPath[diagonalPath] = void 0;
-					continue;
-				}
-				if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) basePath = this.addToPath(addPath, true, false, 0, options);
-				else basePath = this.addToPath(removePath, false, true, 1, options);
-				newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
-				if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
-				else {
-					bestPath[diagonalPath] = basePath;
-					if (basePath.oldPos + 1 >= oldLen) maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
-					if (newPos + 1 >= newLen) minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
-				}
-			}
-			editLength++;
-		};
-		if (callback) (function exec() {
-			setTimeout(function() {
-				if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) return callback(void 0);
-				if (!execEditLength()) exec();
-			}, 0);
-		})();
-		else while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
-			const ret = execEditLength();
-			if (ret) return ret;
-		}
-	}
-	addToPath(path, added, removed, oldPosInc, options) {
-		const last = path.lastComponent;
-		if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) return {
-			oldPos: path.oldPos + oldPosInc,
-			lastComponent: {
-				count: last.count + 1,
-				added,
-				removed,
-				previousComponent: last.previousComponent
-			}
-		};
-		else return {
-			oldPos: path.oldPos + oldPosInc,
-			lastComponent: {
-				count: 1,
-				added,
-				removed,
-				previousComponent: last
-			}
-		};
-	}
-	extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
-		const newLen = newTokens.length, oldLen = oldTokens.length;
-		let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
-		while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
-			newPos++;
-			oldPos++;
-			commonCount++;
-			if (options.oneChangePerToken) basePath.lastComponent = {
-				count: 1,
-				previousComponent: basePath.lastComponent,
-				added: false,
-				removed: false
-			};
-		}
-		if (commonCount && !options.oneChangePerToken) basePath.lastComponent = {
-			count: commonCount,
-			previousComponent: basePath.lastComponent,
-			added: false,
-			removed: false
-		};
-		basePath.oldPos = oldPos;
-		return newPos;
-	}
-	equals(left, right, options) {
-		if (options.comparator) return options.comparator(left, right);
-		else return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
-	}
-	removeEmpty(array) {
-		const ret = [];
-		for (let i = 0; i < array.length; i++) if (array[i]) ret.push(array[i]);
-		return ret;
-	}
-	castInput(value, options) {
-		return value;
-	}
-	tokenize(value, options) {
-		return Array.from(value);
-	}
-	join(chars) {
-		return chars.join("");
-	}
-	postProcess(changeObjects, options) {
-		return changeObjects;
-	}
-	get useLongestToken() {
-		return false;
-	}
-	buildValues(lastComponent, newTokens, oldTokens) {
-		const components = [];
-		let nextComponent;
-		while (lastComponent) {
-			components.push(lastComponent);
-			nextComponent = lastComponent.previousComponent;
-			delete lastComponent.previousComponent;
-			lastComponent = nextComponent;
-		}
-		components.reverse();
-		const componentLen = components.length;
-		let componentPos = 0, newPos = 0, oldPos = 0;
-		for (; componentPos < componentLen; componentPos++) {
-			const component = components[componentPos];
-			if (!component.removed) {
-				if (!component.added && this.useLongestToken) {
-					let value = newTokens.slice(newPos, newPos + component.count);
-					value = value.map(function(value, i) {
-						const oldValue = oldTokens[oldPos + i];
-						return oldValue.length > value.length ? oldValue : value;
-					});
-					component.value = this.join(value);
-				} else component.value = this.join(newTokens.slice(newPos, newPos + component.count));
-				newPos += component.count;
-				if (!component.added) oldPos += component.count;
-			} else {
-				component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
-				oldPos += component.count;
-			}
-		}
-		return components;
-	}
-};
-//#endregion
-//#region ../../node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/diff/character.js
-var CharacterDiff = class extends Diff {};
-new CharacterDiff();
-//#endregion
-//#region ../../node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/util/string.js
-function longestCommonPrefix(str1, str2) {
-	let i = 0;
-	for (; i < str1.length && i < str2.length; i++) if (str1[i] != str2[i]) return str1.slice(0, i);
-	return str1.slice(0, i);
-}
-function longestCommonSuffix(str1, str2) {
-	let i;
-	if (!str1 || !str2 || str1[str1.length - 1] != str2[str2.length - 1]) return "";
-	for (i = 0; i < str1.length && i < str2.length; i++) if (str1[str1.length - (i + 1)] != str2[str2.length - (i + 1)]) return str1.slice(-i);
-	return str1.slice(-i);
-}
-function replacePrefix(string, oldPrefix, newPrefix) {
-	if (string.slice(0, oldPrefix.length) != oldPrefix) throw Error(`string ${JSON.stringify(string)} doesn't start with prefix ${JSON.stringify(oldPrefix)}; this is a bug`);
-	return newPrefix + string.slice(oldPrefix.length);
-}
-function replaceSuffix(string, oldSuffix, newSuffix) {
-	if (!oldSuffix) return string + newSuffix;
-	if (string.slice(-oldSuffix.length) != oldSuffix) throw Error(`string ${JSON.stringify(string)} doesn't end with suffix ${JSON.stringify(oldSuffix)}; this is a bug`);
-	return string.slice(0, -oldSuffix.length) + newSuffix;
-}
-function removePrefix(string, oldPrefix) {
-	return replacePrefix(string, oldPrefix, "");
-}
-function removeSuffix(string, oldSuffix) {
-	return replaceSuffix(string, oldSuffix, "");
-}
-function maximumOverlap(string1, string2) {
-	return string2.slice(0, overlapCount(string1, string2));
-}
-function overlapCount(a, b) {
-	let startA = 0;
-	if (a.length > b.length) startA = a.length - b.length;
-	let endB = b.length;
-	if (a.length < b.length) endB = a.length;
-	const map = Array(endB);
-	let k = 0;
-	map[0] = 0;
-	for (let j = 1; j < endB; j++) {
-		if (b[j] == b[k]) map[j] = map[k];
-		else map[j] = k;
-		while (k > 0 && b[j] != b[k]) k = map[k];
-		if (b[j] == b[k]) k++;
-	}
-	k = 0;
-	for (let i = startA; i < a.length; i++) {
-		while (k > 0 && a[i] != b[k]) k = map[k];
-		if (a[i] == b[k]) k++;
-	}
-	return k;
-}
-/**
-* Split a string into segments using a word segmenter, merging consecutive
-* segments if they are both whitespace segments. Whitespace segments can
-* appear adjacent to one another for two reasons:
-* - newlines always get their own segment
-* - where a diacritic is attached to a whitespace character in the text, the
-*   segment ends after the diacritic, so e.g. " \u0300 " becomes two segments.
-* This function therefore runs the segmenter's .segment() method and then
-* merges consecutive segments of whitespace into a single part.
-*/
-function segment(string, segmenter) {
-	const parts = [];
-	for (const segmentObj of Array.from(segmenter.segment(string))) {
-		const segment = segmentObj.segment;
-		if (parts.length && /\s/.test(parts[parts.length - 1]) && /\s/.test(segment)) parts[parts.length - 1] += segment;
-		else parts.push(segment);
-	}
-	return parts;
-}
-function trailingWs(string, segmenter) {
-	if (segmenter) return leadingAndTrailingWs(string, segmenter)[1];
-	let i;
-	for (i = string.length - 1; i >= 0; i--) if (!string[i].match(/\s/)) break;
-	return string.substring(i + 1);
-}
-function leadingWs(string, segmenter) {
-	if (segmenter) return leadingAndTrailingWs(string, segmenter)[0];
-	const match = string.match(/^\s*/);
-	return match ? match[0] : "";
-}
-function leadingAndTrailingWs(string, segmenter) {
-	if (!segmenter) return [leadingWs(string), trailingWs(string)];
-	if (segmenter.resolvedOptions().granularity != "word") throw new Error("The segmenter passed must have a granularity of \"word\"");
-	const segments = segment(string, segmenter);
-	const firstSeg = segments[0];
-	const lastSeg = segments[segments.length - 1];
-	return [/\s/.test(firstSeg) ? firstSeg : "", /\s/.test(lastSeg) ? lastSeg : ""];
-}
-//#endregion
-//#region ../../node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/diff/word.js
-const extendedWordChars = "a-zA-Z0-9_\\u{AD}\\u{C0}-\\u{D6}\\u{D8}-\\u{F6}\\u{F8}-\\u{2C6}\\u{2C8}-\\u{2D7}\\u{2DE}-\\u{2FF}\\u{1E00}-\\u{1EFF}";
-const tokenizeIncludingWhitespace = new RegExp(`[${extendedWordChars}]+|\\s+|[^${extendedWordChars}]`, "ug");
-var WordDiff = class extends Diff {
-	equals(left, right, options) {
-		if (options.ignoreCase) {
-			left = left.toLowerCase();
-			right = right.toLowerCase();
-		}
-		return left.trim() === right.trim();
-	}
-	tokenize(value, options = {}) {
-		let parts;
-		if (options.intlSegmenter) {
-			const segmenter = options.intlSegmenter;
-			if (segmenter.resolvedOptions().granularity != "word") throw new Error("The segmenter passed must have a granularity of \"word\"");
-			parts = segment(value, segmenter);
-		} else parts = value.match(tokenizeIncludingWhitespace) || [];
-		const tokens = [];
-		let prevPart = null;
-		parts.forEach((part) => {
-			if (/\s/.test(part)) {
-				if (prevPart == null) tokens.push(part);
-				else tokens.push(tokens.pop() + part);
-			} else if (prevPart != null && /\s/.test(prevPart)) {
-				if (tokens[tokens.length - 1] == prevPart) tokens.push(tokens.pop() + part);
-				else tokens.push(prevPart + part);
-			} else tokens.push(part);
-			prevPart = part;
-		});
-		return tokens;
-	}
-	join(tokens) {
-		return tokens.map((token, i) => {
-			if (i == 0) return token;
-			else return token.replace(/^\s+/, "");
-		}).join("");
-	}
-	postProcess(changes, options) {
-		if (!changes || options.oneChangePerToken) return changes;
-		let lastKeep = null;
-		let insertion = null;
-		let deletion = null;
-		changes.forEach((change) => {
-			if (change.added) insertion = change;
-			else if (change.removed) deletion = change;
-			else {
-				if (insertion || deletion) dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change, options.intlSegmenter);
-				lastKeep = change;
-				insertion = null;
-				deletion = null;
-			}
-		});
-		if (insertion || deletion) dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null, options.intlSegmenter);
-		return changes;
-	}
-};
-new WordDiff();
-function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep, segmenter) {
-	if (deletion && insertion) {
-		const [oldWsPrefix, oldWsSuffix] = leadingAndTrailingWs(deletion.value, segmenter);
-		const [newWsPrefix, newWsSuffix] = leadingAndTrailingWs(insertion.value, segmenter);
-		if (startKeep) {
-			const commonWsPrefix = longestCommonPrefix(oldWsPrefix, newWsPrefix);
-			startKeep.value = replaceSuffix(startKeep.value, newWsPrefix, commonWsPrefix);
-			deletion.value = removePrefix(deletion.value, commonWsPrefix);
-			insertion.value = removePrefix(insertion.value, commonWsPrefix);
-		}
-		if (endKeep) {
-			const commonWsSuffix = longestCommonSuffix(oldWsSuffix, newWsSuffix);
-			endKeep.value = replacePrefix(endKeep.value, newWsSuffix, commonWsSuffix);
-			deletion.value = removeSuffix(deletion.value, commonWsSuffix);
-			insertion.value = removeSuffix(insertion.value, commonWsSuffix);
-		}
-	} else if (insertion) {
-		if (startKeep) {
-			const ws = leadingWs(insertion.value, segmenter);
-			insertion.value = insertion.value.substring(ws.length);
-		}
-		if (endKeep) {
-			const ws = leadingWs(endKeep.value, segmenter);
-			endKeep.value = endKeep.value.substring(ws.length);
-		}
-	} else if (startKeep && endKeep) {
-		const newWsFull = leadingWs(endKeep.value, segmenter), [delWsStart, delWsEnd] = leadingAndTrailingWs(deletion.value, segmenter);
-		const newWsStart = longestCommonPrefix(newWsFull, delWsStart);
-		deletion.value = removePrefix(deletion.value, newWsStart);
-		const newWsEnd = longestCommonSuffix(removePrefix(newWsFull, newWsStart), delWsEnd);
-		deletion.value = removeSuffix(deletion.value, newWsEnd);
-		endKeep.value = replacePrefix(endKeep.value, newWsFull, newWsEnd);
-		startKeep.value = replaceSuffix(startKeep.value, newWsFull, newWsFull.slice(0, newWsFull.length - newWsEnd.length));
-	} else if (endKeep) {
-		const endKeepWsPrefix = leadingWs(endKeep.value, segmenter);
-		const overlap = maximumOverlap(trailingWs(deletion.value, segmenter), endKeepWsPrefix);
-		deletion.value = removeSuffix(deletion.value, overlap);
-	} else if (startKeep) {
-		const overlap = maximumOverlap(trailingWs(startKeep.value, segmenter), leadingWs(deletion.value, segmenter));
-		deletion.value = removePrefix(deletion.value, overlap);
-	}
-}
-var WordsWithSpaceDiff = class extends Diff {
-	tokenize(value) {
-		const regex = new RegExp(`(\\r?\\n)|[${extendedWordChars}]+|[^\\S\\n\\r]+|[^${extendedWordChars}]`, "ug");
-		return value.match(regex) || [];
-	}
-};
-new WordsWithSpaceDiff();
-//#endregion
-//#region ../../node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/diff/line.js
-var LineDiff = class extends Diff {
-	constructor() {
-		super(...arguments);
-		this.tokenize = tokenize;
-	}
-	equals(left, right, options) {
-		if (options.ignoreWhitespace) {
-			if (!options.newlineIsToken || !left.includes("\n")) left = left.trim();
-			if (!options.newlineIsToken || !right.includes("\n")) right = right.trim();
-		} else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
-			if (left.endsWith("\n")) left = left.slice(0, -1);
-			if (right.endsWith("\n")) right = right.slice(0, -1);
-		}
-		return super.equals(left, right, options);
-	}
-};
-const lineDiff = new LineDiff();
-function diffLines(oldStr, newStr, options) {
-	return lineDiff.diff(oldStr, newStr, options);
-}
-function tokenize(value, options) {
-	if (options.stripTrailingCr) value = value.replace(/\r\n/g, "\n");
-	const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
-	if (!linesAndNewlines[linesAndNewlines.length - 1]) linesAndNewlines.pop();
-	for (let i = 0; i < linesAndNewlines.length; i++) {
-		const line = linesAndNewlines[i];
-		if (i % 2 && !options.newlineIsToken) retLines[retLines.length - 1] += line;
-		else retLines.push(line);
-	}
-	return retLines;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/diff/sentence.js
-function isSentenceEndPunct(char) {
-	return char == "." || char == "!" || char == "?";
-}
-var SentenceDiff = class extends Diff {
-	tokenize(value) {
-		var _a;
-		const result = [];
-		let tokenStartI = 0;
-		for (let i = 0; i < value.length; i++) {
-			if (i == value.length - 1) {
-				result.push(value.slice(tokenStartI));
-				break;
-			}
-			if (isSentenceEndPunct(value[i]) && value[i + 1].match(/\s/)) {
-				result.push(value.slice(tokenStartI, i + 1));
-				i = tokenStartI = i + 1;
-				while ((_a = value[i + 1]) === null || _a === void 0 ? void 0 : _a.match(/\s/)) i++;
-				result.push(value.slice(tokenStartI, i + 1));
-				tokenStartI = i + 1;
-			}
-		}
-		return result;
-	}
-};
-new SentenceDiff();
-//#endregion
-//#region ../../node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/diff/css.js
-var CssDiff = class extends Diff {
-	tokenize(value) {
-		return value.split(/([{}:;,]|\s+)/);
-	}
-};
-new CssDiff();
-//#endregion
-//#region ../../node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/diff/json.js
-var JsonDiff = class extends Diff {
-	constructor() {
-		super(...arguments);
-		this.tokenize = tokenize;
-	}
-	get useLongestToken() {
-		return true;
-	}
-	castInput(value, options) {
-		const { undefinedReplacement, stringifyReplacer = (k, v) => typeof v === "undefined" ? undefinedReplacement : v } = options;
-		return typeof value === "string" ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), null, "  ");
-	}
-	equals(left, right, options) {
-		return super.equals(left.replace(/,([\r\n])/g, "$1"), right.replace(/,([\r\n])/g, "$1"), options);
-	}
-};
-new JsonDiff();
-function canonicalize(obj, stack, replacementStack, replacer, key) {
-	stack = stack || [];
-	replacementStack = replacementStack || [];
-	if (replacer) obj = replacer(key === void 0 ? "" : key, obj);
-	let i = 0;
-	for (; i < stack.length; i += 1) if (stack[i] === obj) return replacementStack[i];
-	let canonicalizedObj;
-	if ("[object Array]" === Object.prototype.toString.call(obj)) {
-		stack.push(obj);
-		canonicalizedObj = new Array(obj.length);
-		replacementStack.push(canonicalizedObj);
-		for (i = 0; i < obj.length; i += 1) canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, String(i));
-		stack.pop();
-		replacementStack.pop();
-		return canonicalizedObj;
-	}
-	if (obj && obj.toJSON) obj = obj.toJSON();
-	if (typeof obj === "object" && obj !== null) {
-		stack.push(obj);
-		canonicalizedObj = {};
-		replacementStack.push(canonicalizedObj);
-		const sortedKeys = [];
-		let key;
-		for (key in obj)
- /* istanbul ignore else */
-		if (Object.prototype.hasOwnProperty.call(obj, key)) sortedKeys.push(key);
-		sortedKeys.sort();
-		for (i = 0; i < sortedKeys.length; i += 1) {
-			key = sortedKeys[i];
-			canonicalizedObj[key] = canonicalize(obj[key], stack, replacementStack, replacer, key);
-		}
-		stack.pop();
-		replacementStack.pop();
-	} else canonicalizedObj = obj;
-	return canonicalizedObj;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/diff/array.js
-var ArrayDiff = class extends Diff {
-	tokenize(value) {
-		return value.slice();
-	}
-	join(value) {
-		return value;
-	}
-	removeEmpty(value) {
-		return value;
-	}
-};
-new ArrayDiff();
-//#endregion
-//#region ../../node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/patch/create.js
-/**
-* Returns true if the filename contains characters that require C-style
-* quoting (as used by Git and GNU diffutils in diff output).
-*/
-function needsQuoting(s) {
-	for (let i = 0; i < s.length; i++) if (s[i] < " " || s[i] > "~" || s[i] === "\"" || s[i] === "\\") return true;
-	return false;
-}
-/**
-* C-style quotes a filename, encoding special characters as escape sequences
-* and non-ASCII bytes as octal escapes. This is the inverse of
-* `parseQuotedFileName` in parse.ts.
-*
-* Non-ASCII bytes are encoded as UTF-8 before being emitted as octal escapes.
-* This matches the behaviour of both Git and GNU diffutils, which always emit
-* UTF-8 octal escapes regardless of the underlying filesystem encoding (e.g.
-* Git for Windows converts from NTFS's UTF-16 to UTF-8 internally).
-*
-* If the filename doesn't need quoting, returns it as-is.
-*/
-function quoteFileNameIfNeeded(s) {
-	if (!needsQuoting(s)) return s;
-	let result = "\"";
-	const bytes = new TextEncoder().encode(s);
-	let i = 0;
-	while (i < bytes.length) {
-		const b = bytes[i];
-		if (b === 7) result += "\\a";
-		else if (b === 8) result += "\\b";
-		else if (b === 9) result += "\\t";
-		else if (b === 10) result += "\\n";
-		else if (b === 11) result += "\\v";
-		else if (b === 12) result += "\\f";
-		else if (b === 13) result += "\\r";
-		else if (b === 34) result += "\\\"";
-		else if (b === 92) result += "\\\\";
-		else if (b >= 32 && b <= 126) result += String.fromCharCode(b);
-		else result += "\\" + b.toString(8).padStart(3, "0");
-		i++;
-	}
-	result += "\"";
-	return result;
-}
-const INCLUDE_HEADERS = {
-	includeIndex: true,
-	includeUnderline: true,
-	includeFileHeaders: true
-};
-function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
-	let optionsObj;
-	if (!options) optionsObj = {};
-	else if (typeof options === "function") optionsObj = { callback: options };
-	else optionsObj = options;
-	if (typeof optionsObj.context === "undefined") optionsObj.context = 4;
-	const context = optionsObj.context;
-	if (optionsObj.newlineIsToken) throw new Error("newlineIsToken may not be used with patch-generation functions, only with diffing functions");
-	if (!optionsObj.callback) return diffLinesResultToPatch(diffLines(oldStr, newStr, optionsObj));
-	else {
-		const { callback } = optionsObj;
-		diffLines(oldStr, newStr, Object.assign(Object.assign({}, optionsObj), { callback: (diff) => {
-			const patch = diffLinesResultToPatch(diff);
-			callback(patch);
-		} }));
-	}
-	function diffLinesResultToPatch(diff) {
-		if (!diff) return;
-		diff.push({
-			value: "",
-			lines: []
-		});
-		function contextLines(lines) {
-			return lines.map(function(entry) {
-				return " " + entry;
-			});
-		}
-		const hunks = [];
-		let oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
-		for (let i = 0; i < diff.length; i++) {
-			const current = diff[i], lines = current.lines || splitLines(current.value);
-			current.lines = lines;
-			if (current.added || current.removed) {
-				if (!oldRangeStart) {
-					const prev = diff[i - 1];
-					oldRangeStart = oldLine;
-					newRangeStart = newLine;
-					if (prev) {
-						curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];
-						oldRangeStart -= curRange.length;
-						newRangeStart -= curRange.length;
-					}
-				}
-				for (const line of lines) curRange.push((current.added ? "+" : "-") + line);
-				if (current.added) newLine += lines.length;
-				else oldLine += lines.length;
-			} else {
-				if (oldRangeStart) {
-					if (lines.length <= context * 2 && i < diff.length - 2) for (const line of contextLines(lines)) curRange.push(line);
-					else {
-						const contextSize = Math.min(lines.length, context);
-						for (const line of contextLines(lines.slice(0, contextSize))) curRange.push(line);
-						const hunk = {
-							oldStart: oldRangeStart,
-							oldLines: oldLine - oldRangeStart + contextSize,
-							newStart: newRangeStart,
-							newLines: newLine - newRangeStart + contextSize,
-							lines: curRange
-						};
-						hunks.push(hunk);
-						oldRangeStart = 0;
-						newRangeStart = 0;
-						curRange = [];
-					}
-				}
-				oldLine += lines.length;
-				newLine += lines.length;
-			}
-		}
-		for (const hunk of hunks) for (let i = 0; i < hunk.lines.length; i++) if (hunk.lines[i].endsWith("\n")) hunk.lines[i] = hunk.lines[i].slice(0, -1);
-		else {
-			hunk.lines.splice(i + 1, 0, "\");
-			i++;
-		}
-		return {
-			oldFileName,
-			newFileName,
-			oldHeader,
-			newHeader,
-			hunks
-		};
-	}
-}
-/**
-* creates a unified diff patch.
-*
-* @param patch either a single structured patch object (as returned by `structuredPatch`) or an
-*   array of them (as returned by `parsePatch`).
-* @param headerOptions behaves the same as the `headerOptions` option of `createTwoFilesPatch`.
-*   Ignored for patches where `isGit` is `true`.
-*
-* When a patch has `isGit: true`, `formatPatch` output is changed to more closely match Git's
-* output: it emits a `diff --git` header, emits Git extended headers as appropriate based on
-* properties like `isRename`, `isCreate`, `newMode`, etc, and will omit `---`/`+++` file
-* headers for patches with no hunks (e.g. renames without content changes).
-*/
-function formatPatch(patch, headerOptions) {
-	var _a, _b, _c, _d, _e, _f;
-	if (!headerOptions) headerOptions = INCLUDE_HEADERS;
-	if (Array.isArray(patch)) {
-		if (patch.length > 1 && !headerOptions.includeFileHeaders && !patch.every((p) => p.isGit)) throw new Error("Cannot omit file headers on a multi-file patch. (The result would be unparseable; how would a tool trying to apply the patch know which changes are to which file?)");
-		return patch.map((p) => formatPatch(p, headerOptions)).join("\n");
-	}
-	const ret = [];
-	if (patch.isGit) {
-		headerOptions = INCLUDE_HEADERS;
-		if (!patch.oldFileName) throw new Error("oldFileName must be specified for Git patches");
-		if (!patch.newFileName) throw new Error("newFileName must be specified for Git patches");
-		let gitOldName = patch.oldFileName;
-		let gitNewName = patch.newFileName;
-		if (patch.isCreate && gitOldName === "/dev/null") gitOldName = gitNewName.replace(/^b\//, "a/");
-		else if (patch.isDelete && gitNewName === "/dev/null") gitNewName = gitOldName.replace(/^a\//, "b/");
-		ret.push("diff --git " + quoteFileNameIfNeeded(gitOldName) + " " + quoteFileNameIfNeeded(gitNewName));
-		if (patch.isDelete) ret.push("deleted file mode " + ((_a = patch.oldMode) !== null && _a !== void 0 ? _a : "100644"));
-		if (patch.isCreate) ret.push("new file mode " + ((_b = patch.newMode) !== null && _b !== void 0 ? _b : "100644"));
-		if (patch.oldMode && patch.newMode && !patch.isDelete && !patch.isCreate) {
-			ret.push("old mode " + patch.oldMode);
-			ret.push("new mode " + patch.newMode);
-		}
-		if (patch.isRename) {
-			ret.push("rename from " + quoteFileNameIfNeeded(((_c = patch.oldFileName) !== null && _c !== void 0 ? _c : "").replace(/^a\//, "")));
-			ret.push("rename to " + quoteFileNameIfNeeded(((_d = patch.newFileName) !== null && _d !== void 0 ? _d : "").replace(/^b\//, "")));
-		}
-		if (patch.isCopy) {
-			ret.push("copy from " + quoteFileNameIfNeeded(((_e = patch.oldFileName) !== null && _e !== void 0 ? _e : "").replace(/^a\//, "")));
-			ret.push("copy to " + quoteFileNameIfNeeded(((_f = patch.newFileName) !== null && _f !== void 0 ? _f : "").replace(/^b\//, "")));
-		}
-	} else {
-		if (headerOptions.includeIndex && patch.oldFileName == patch.newFileName && patch.oldFileName !== void 0) ret.push("Index: " + patch.oldFileName);
-		if (headerOptions.includeUnderline) ret.push("===================================================================");
-	}
-	const hasHunks = patch.hunks.length > 0;
-	if (headerOptions.includeFileHeaders && patch.oldFileName !== void 0 && patch.newFileName !== void 0 && (!patch.isGit || hasHunks)) {
-		ret.push("--- " + quoteFileNameIfNeeded(patch.oldFileName) + (patch.oldHeader ? "	" + patch.oldHeader : ""));
-		ret.push("+++ " + quoteFileNameIfNeeded(patch.newFileName) + (patch.newHeader ? "	" + patch.newHeader : ""));
-	}
-	for (let i = 0; i < patch.hunks.length; i++) {
-		const hunk = patch.hunks[i];
-		const oldStart = hunk.oldLines === 0 ? hunk.oldStart - 1 : hunk.oldStart;
-		const newStart = hunk.newLines === 0 ? hunk.newStart - 1 : hunk.newStart;
-		ret.push("@@ -" + oldStart + "," + hunk.oldLines + " +" + newStart + "," + hunk.newLines + " @@");
-		for (const line of hunk.lines) ret.push(line);
-	}
-	return ret.join("\n") + "\n";
-}
-function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
-	if (typeof options === "function") options = { callback: options };
-	if (!(options === null || options === void 0 ? void 0 : options.callback)) {
-		const patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
-		if (!patchObj) return;
-		return formatPatch(patchObj, options === null || options === void 0 ? void 0 : options.headerOptions);
-	} else {
-		const { callback } = options;
-		structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, Object.assign(Object.assign({}, options), { callback: (patchObj) => {
-			if (!patchObj) callback(void 0);
-			else callback(formatPatch(patchObj, options.headerOptions));
-		} }));
-	}
-}
-/**
-* Split `text` into an array of lines, including the trailing newline character (where present)
-*/
-function splitLines(text) {
-	const hasTrailingNl = text.endsWith("\n");
-	const result = text.split("\n").map((line) => line + "\n");
-	if (hasTrailingNl) result.pop();
-	else result.push(result.pop().slice(0, -1));
-	return result;
-}
-function paintLine(line, paint) {
-	if (line.startsWith("---") || line.startsWith("+++")) return paint("bold", line);
-	if (line.startsWith("@@")) return paint("cyan", line);
-	if (line.startsWith("+")) return paint("green", line);
-	if (line.startsWith("-")) return paint("red", line);
-	return line;
-}
-/** A unified diff from the file on disk (`current`, missing when `undefined`) to `next`, capped at `DIFF_LINES`. */
-function fileDiff(path, current, next, paint = plain) {
-	const lines = createTwoFilesPatch(path, path, current ?? "", next, current === void 0 ? "missing" : "on disk", "generated", { context: 2 }).split("\n").filter((line) => line !== "" && !line.startsWith("=====") && !line.startsWith("Index:"));
-	const shown = lines.slice(0, 40).map((line) => paintLine(line, paint));
-	const hidden = lines.length - shown.length;
-	return [...shown, ...hidden > 0 ? [paint("dim", `... ${hidden} more diff lines`)] : []].join("\n");
-}
-//#endregion
-//#region src/cli/core/files.ts
-/**
-* `path` resolved under `root`, or an error when it leaves the root (an
-* absolute path elsewhere, or one that climbs out with `..`).
-*/
-function insideRoot(root, path, flag) {
-	const resolved = resolve(root, path);
-	const inside = relative(root, resolved);
-	if (inside === ".." || inside.startsWith(`..${sep}`) || isAbsolute(inside)) throw new CliError("outside_root", `${flag} ${path} is outside the project root ${root}. Run the command from the project that owns the file.`, { flag });
-	return resolved;
-}
-/** `--dry-run`, `--check` and `--force`, for a command's `args`. */
-const PLAN_ARGS = {
-	"dry-run": {
-		type: "boolean",
-		description: "Print what would change, with a diff, and write nothing"
-	},
-	check: {
-		type: "boolean",
-		description: "Write nothing; exit 1 with a diff when a file would change"
-	},
-	force: {
-		type: "boolean",
-		description: "Overwrite files the CLI did not generate"
-	}
-};
-const HEADER = /generated by `?better-supabase/i;
-/** Whether `text` carries the better-supabase header in its first lines. */
-function ownedByUs(text) {
-	return HEADER.test(text.split("\n", 5).join("\n"));
-}
-const FORCE_HINT = "pass --force to overwrite";
-const NOT_OURS = `not generated by better-supabase; ${FORCE_HINT}`;
-/** Whether the plan skipped a generated file the app wrote by hand. */
-const hasConflicts = (applied) => applied.changes.some(({ reason }) => reason === NOT_OURS);
-function outcomeOf(file, current, force) {
-	const policy = file.policy ?? (ownedByUs(file.contents) ? "owned" : "generated");
-	if (current === void 0) return policy === "edit" ? {
-		outcome: "skip",
-		reason: "missing"
-	} : { outcome: "create" };
-	if (file.same ? file.same(current, file.contents) : sameText(current, file.contents)) return { outcome: "unchanged" };
-	if (force) return { outcome: "update" };
-	switch (policy) {
-		case "generated":
-		case "edit": return { outcome: "update" };
-		case "owned": return ownedByUs(current) ? { outcome: "update" } : {
-			outcome: "skip",
-			reason: NOT_OURS
-		};
-		case "create": return {
-			outcome: "skip",
-			reason: `exists; ${FORCE_HINT}`
-		};
-		default: return policy;
-	}
-}
-/** Writes every file next to its target first, then renames them all, so a failed write leaves no file half written. */
-async function writeAll(files) {
-	const temporary = files.map((file, index) => `${file.path}.${process.pid}.${index}.tmp`);
-	try {
-		for (const [index, file] of files.entries()) {
-			await mkdir(dirname(file.path), { recursive: true });
-			await writeFile(temporary[index] ?? file.path, file.contents, { ...file.mode === void 0 ? {} : { mode: file.mode } });
-		}
-	} catch (error) {
-		await Promise.all(temporary.map((path) => rm(path, { force: true }).catch(() => void 0)));
-		throw error;
-	}
-	for (const [index, file] of files.entries()) {
-		await rename(temporary[index] ?? file.path, file.path);
-		if (file.mode !== void 0) await chmod(file.path, file.mode);
-	}
-}
-/**
-* Applies `plan`: checks every path stays inside the root, decides what
-* happens to each file, then writes nothing (`--dry-run`, `--check`) or
-* writes every change at once.
-*/
-async function applyPlan(plan, flags, paint = plain) {
-	const mode = flags.check === true ? "check" : flags["dry-run"] === true ? "dry-run" : "write";
-	const force = flags.force === true;
-	const base = plan.base ?? plan.root;
-	const changes = [];
-	const diffs = [];
-	const staged = [];
-	const modes = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const file of plan.files) {
-		const path = insideRoot(plan.root, file.path, "path");
-		if (seen.has(path)) continue;
-		seen.add(path);
-		const shown = display(base, path);
-		const current = await readIfExists(path);
-		const { outcome, reason } = outcomeOf(file, current, force);
-		changes.push({
-			file: shown,
-			outcome,
-			...file.note ? { note: file.note } : {},
-			...reason ? { reason } : {}
-		});
-		if (outcome === "create" || outcome === "update" || reason === NOT_OURS) diffs.push(file.secret === true ? `${shown} would change (the diff is hidden: the file holds secrets).` : fileDiff(shown, current, file.contents, paint));
-		if (outcome === "create" || outcome === "update") staged.push({
-			path,
-			contents: file.contents,
-			mode: file.mode
-		});
-		else if (outcome === "unchanged" && file.mode !== void 0) modes.push({
-			path,
-			mode: file.mode
-		});
-	}
-	const removed = [];
-	for (const file of plan.remove ?? []) {
-		const path = insideRoot(plan.root, file, "path");
-		const current = await readIfExists(path);
-		if (current !== void 0) {
-			const shown = display(base, path);
-			changes.push({
-				file: shown,
-				outcome: "remove"
-			});
-			diffs.push(fileDiff(shown, current, "", paint));
-			removed.push(path);
-		}
-	}
-	if (mode === "write") {
-		await writeAll(staged);
-		for (const path of removed) await rm(path, { force: true });
-		for (const { path, mode: fileMode } of modes) await chmod(path, fileMode);
-	}
-	return {
-		mode,
-		changes,
-		diffs,
-		drift: staged.length > 0 || removed.length > 0
-	};
-}
-const VERB = {
-	create: ["Created", "Would create"],
-	update: ["Updated", "Would update"],
-	remove: ["Removed", "Would remove"],
-	unchanged: ["Unchanged", "Unchanged"],
-	skip: ["Skipped", "Skipped"]
-};
-/** One `Created`, `Updated`, `Skipped`, `Unchanged` or `Would create` line per file. */
-function changeLines(applied) {
-	return applied.changes.map(({ file, outcome, note, reason }) => {
-		const [done, planned] = VERB[outcome];
-		const verb = applied.mode === "write" ? done : planned;
-		const extra = [note, reason].filter(Boolean).join("; ");
-		return `${verb} ${file}${extra ? ` (${extra})` : ""}`;
-	});
-}
-/** The files a plan changed, for `data.files`. */
-const changedFiles = (applied) => applied.changes.filter(({ outcome }) => outcome === "create" || outcome === "update" || outcome === "remove").map(({ file }) => file);
-/**
-* The result of an applied plan. `--check` fails with the diffs when a file
-* would change; `--dry-run` prints the diffs and the lines; a write prints
-* the lines. `summary` follows the lines, and `data` joins `data.files`.
-*/
-function planResult(plan, applied, options = {}) {
-	const data = {
-		...options.data,
-		files: applied.changes,
-		...applied.mode === "write" ? {} : { upToDate: !applied.drift && !hasConflicts(applied) }
-	};
-	const text = [...changeLines(applied), ...options.summary ? [options.summary] : []].join("\n");
-	const conflicts = applied.changes.filter(({ reason }) => reason === NOT_OURS);
-	if (conflicts.length > 0) return {
-		code: 1,
-		output: [...applied.mode === "write" ? [] : applied.diffs, text].filter(Boolean).join("\n\n"),
-		error: `${conflicts.map(({ file }) => file).join(", ")} ${conflicts.length === 1 ? "was" : "were"} not generated by better-supabase, so the CLI left ${conflicts.length === 1 ? "it" : "them"} alone. Pass --force to overwrite.`,
-		errorCode: "file_conflict",
-		data
-	};
-	if (applied.mode === "check") {
-		if (!applied.drift) return {
-			code: 0,
-			output: applied.changes.length === 1 ? `${applied.changes[0]?.file} is up to date.` : `${applied.changes.length} files are up to date.`,
-			data
-		};
-		const stale = changedFiles(applied);
-		return {
-			code: 1,
-			output: applied.diffs.join("\n\n"),
-			error: `${stale.length === 1 ? `${stale[0]} is` : `${stale.length} files are`} out of date. Run \`${plan.regenerate}\`.`,
-			errorCode: "check_failed",
-			next: [{
-				command: plan.regenerate,
-				when: "rewrites the files"
-			}],
-			data
-		};
-	}
-	if (applied.mode === "dry-run") return {
-		code: 0,
-		output: [...applied.diffs, text].filter(Boolean).join("\n\n"),
-		data
-	};
-	return {
-		code: 0,
-		output: text,
-		data
-	};
-}
-//#endregion
-export { hasConflicts as a, fileDiff as c, changedFiles as i, applyPlan as n, insideRoot as o, changeLines as r, planResult as s, PLAN_ARGS as t };