better-supabase 0.2.0 → 0.4.0

package/dist/cli/read-sets-CMa29t9a.js

@@ -0,0 +1,971 @@
+import { i as plain } from "./style-C0NFdJRL.js";
+import { i as importModule } from "./config-D9R0o1LH.js";
+import { resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { compileReadSets } from "better-supabase/sql";
+import { isReadSet } from "better-supabase";
+//#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/permdock.ts
+const PERMDOCK_CONFIGS = [
+	"permdock.config.ts",
+	"permdock.config.mts",
+	"permdock.config.js",
+	"permdock.config.mjs"
+];
+/** The PermDock config file in `root`, if there is one. */
+function permdockConfig(root) {
+	return PERMDOCK_CONFIGS.find((file) => existsSync(resolve(root, file)));
+}
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isString = (value) => typeof value === "string";
+const strings = (value) => Array.isArray(value) ? value.filter(isString) : [];
+const column = (value) => isRecord(value) && isString(value["column"]) ? { column: value["column"] } : void 0;
+function manifestValue(value, accept) {
+	if (!isRecord(value)) return void 0;
+	if (isString(value["column"])) return { column: value["column"] };
+	return accept(value["value"]) ? { value: value["value"] } : void 0;
+}
+const roleValue = (value) => isString(value) || Array.isArray(value) && value.every(isString);
+function membership(value) {
+	if (!isRecord(value) || !isString(value["table"])) return void 0;
+	const user = column(value["user"]);
+	const id = column(value["id"]);
+	const scope = manifestValue(value["scope"], isString);
+	if (!user || !id || !scope) return void 0;
+	const role = manifestValue(value["role"], roleValue);
+	const expiresAt = column(value["expiresAt"]);
+	return {
+		table: value["table"],
+		user,
+		scope,
+		id,
+		...role ? { role } : {},
+		...expiresAt ? { expiresAt } : {},
+		columns: strings(value["columns"])
+	};
+}
+/** Reads a parsed manifest; throws with the reason when it isn't version 1. */
+function parseManifest(json) {
+	if (!isRecord(json)) throw new TypeError("not a JSON object");
+	if (json["version"] !== 1) throw new TypeError(`version ${String(json["version"])} is not supported (this release reads version 1)`);
+	const hook = json["hook"];
+	const rls = json["rls"];
+	const budget = isRecord(json["budget"]) ? json["budget"]["bytes"] : void 0;
+	return {
+		version: 1,
+		...typeof budget === "number" ? { budget } : {},
+		...isRecord(hook) && isString(hook["schema"]) && isString(hook["function"]) ? { hook: {
+			schema: hook["schema"],
+			function: hook["function"]
+		} } : {},
+		...isString(json["tenantClaim"]) ? { tenantClaim: json["tenantClaim"] } : {},
+		claims: (Array.isArray(json["claims"]) ? json["claims"] : []).flatMap((claim) => isRecord(claim) && isString(claim["name"]) && isString(claim["source"]) ? [{
+			name: claim["name"],
+			source: claim["source"]
+		}] : []),
+		memberships: (Array.isArray(json["memberships"]) ? json["memberships"] : []).flatMap((entry) => {
+			const parsed = membership(entry);
+			return parsed ? [parsed] : [];
+		}),
+		...isRecord(rls) && isString(rls["schema"]) ? { rls: {
+			schema: rls["schema"],
+			mode: rls["mode"] === "jwt" ? "jwt" : "database",
+			scopes: (Array.isArray(rls["scopes"]) ? rls["scopes"] : []).flatMap((scope) => isRecord(scope) && isString(scope["name"]) && isString(scope["type"]) ? [{
+				name: scope["name"],
+				type: scope["type"]
+			}] : []),
+			helpers: (Array.isArray(rls["helpers"]) ? rls["helpers"] : []).flatMap((helper) => isRecord(helper) && isString(helper["name"]) && isString(helper["args"]) && isString(helper["returns"]) ? [{
+				name: helper["name"],
+				args: helper["args"],
+				returns: helper["returns"],
+				execute: strings(helper["execute"])
+			}] : [])
+		} } : {},
+		decidingColumns: strings(json["decidingColumns"])
+	};
+}
+/** The keys of a parsed `permissions.catalog.json` whose entry has `rowConditions: true`. */
+function rowConditionKeys(json) {
+	if (!isRecord(json) || !Array.isArray(json["permissions"])) throw new TypeError("has no permissions array");
+	const keys = /* @__PURE__ */ new Set();
+	for (const permission of json["permissions"]) if (isRecord(permission) && isString(permission["key"]) && permission["rowConditions"] === true) keys.add(permission["key"]);
+	return keys;
+}
+async function readJson(root, path) {
+	const absolute = resolve(root, path);
+	if (!existsSync(absolute)) return { missing: true };
+	try {
+		return { json: JSON.parse(await readFile(absolute, "utf8")) };
+	} catch (cause) {
+		return { problem: `${path}: ${cause instanceof Error ? cause.message : String(cause)}` };
+	}
+}
+/**
+* Reads PermDock's JSON outputs: the manifest `permdock supabase inspect
+* --out` writes and the catalog `permdock catalog` writes. Nothing is
+* imported from PermDock. Returns `undefined` when the project has neither a
+* PermDock config nor a manifest.
+*/
+async function readPermdock(root, paths) {
+	const config = permdockConfig(root);
+	const problems = [];
+	const manifestFile = await readJson(root, paths.manifest);
+	let manifest;
+	if ("json" in manifestFile) try {
+		manifest = parseManifest(manifestFile.json);
+	} catch (cause) {
+		problems.push(`${paths.manifest}: ${cause instanceof Error ? cause.message : String(cause)}`);
+	}
+	else if ("problem" in manifestFile) problems.push(manifestFile.problem);
+	if (!config && !manifest && "missing" in manifestFile) return void 0;
+	const catalogFile = await readJson(root, paths.catalog);
+	let rowConditions;
+	if ("json" in catalogFile) try {
+		rowConditions = rowConditionKeys(catalogFile.json);
+	} catch (cause) {
+		problems.push(`${paths.catalog}: ${cause instanceof Error ? cause.message : String(cause)}`);
+	}
+	else if ("problem" in catalogFile) problems.push(catalogFile.problem);
+	return {
+		...config ? { config } : {},
+		manifestPath: paths.manifest,
+		...manifest ? { manifest } : {},
+		catalogPath: paths.catalog,
+		...rowConditions ? { rowConditions } : {},
+		problems
+	};
+}
+/** How findings name the PermDock project: its config file or its manifest. */
+const permdockSource = (project) => project.config ?? project.manifestPath;
+const HOOK_MARKER = /^--\s*permdock:hook\s+v(\d+)([^\n]*)$/m;
+const GRANTS_MARKER = /^--\s*permdock:grants\s+v(\d+)([^\n]*)$/m;
+function markerFields(rest) {
+	const fields = /* @__PURE__ */ new Map();
+	for (const match of rest.matchAll(/(\w+)=(\S*)/g)) fields.set(match[1], match[2]);
+	return fields;
+}
+/** The `-- permdock:hook v1 schema=... tenant=... budget=... claims=...` line PermDock's hook file starts with. */
+function parseHookMarker(sql) {
+	const match = HOOK_MARKER.exec(sql);
+	if (!match) return void 0;
+	const fields = markerFields(match[2]);
+	const budget = Number(fields.get("budget"));
+	const schema = fields.get("schema");
+	const tenantClaim = fields.get("tenant");
+	return {
+		version: Number(match[1]),
+		...schema ? { schema } : {},
+		...tenantClaim ? { tenantClaim } : {},
+		...Number.isFinite(budget) && fields.has("budget") ? { budget } : {},
+		claims: (fields.get("claims") ?? "").split(",").filter(Boolean)
+	};
+}
+/** The `-- permdock:grants v1 schema=...` line of the migration `--grants-out` writes. */
+function parseGrantsMarker(sql) {
+	const match = GRANTS_MARKER.exec(sql);
+	if (!match) return void 0;
+	const schema = markerFields(match[2]).get("schema");
+	return {
+		version: Number(match[1]),
+		...schema ? { schema } : {}
+	};
+}
+/**
+* PermDock mode, when the manifest has an `rls` block and
+* `entitlements.permdock` is not `false`: the scope must be one of the
+* manifest's `rls.scopes`. Without a manifest the module keeps using `tenant`.
+*/
+function entitlementsMode(config, project) {
+	const setting = config.entitlements.permdock;
+	const rls = project?.manifest?.rls;
+	if (setting === false || !project?.manifest || !rls) return { kind: "tenant" };
+	if (!rls.scopes.some((scope) => scope.name === setting.scope)) return {
+		kind: "invalid",
+		problem: `entitlements.permdock.scope is "${setting.scope}", but ${project.manifestPath} has the scopes ${rls.scopes.map((scope) => scope.name).join(", ") || "(none)"}. Set entitlements.permdock: { scope } to one of them.`
+	};
+	return {
+		kind: "permdock",
+		permdock: {
+			schema: rls.schema,
+			scope: setting.scope,
+			memberships: project.manifest.memberships.map((source) => ({
+				table: source.table,
+				userColumn: source.user.column,
+				scope: source.scope,
+				idColumn: source.id.column
+			}))
+		}
+	};
+}
+/** The `member_<scope>_ids` helpers PermDock mode calls, as `schema.name`. */
+const entitlementHelpers = (permdock) => [`${permdock.schema}.member_${permdock.scope}_ids`, `${permdock.schema}.member_${permdock.scope}_ids_for`];
+//#endregion
+//#region src/cli/read-sets.ts
+/** Every read set exported by the modules in `config.readSets`. */
+async function loadReadSets(config) {
+	const sets = [];
+	for (const entry of config.readSets) {
+		const loaded = await importModule(resolve(config.root, entry));
+		const found = Object.values(loaded).filter(isReadSet);
+		if (found.length === 0) throw new Error(`${entry} exports no read set (defineReadSet)`);
+		for (const set of found) if (!sets.includes(set)) sets.push(set);
+	}
+	return sets;
+}
+/** The compiled functions for `config.readSets`; empty when none are configured. */
+async function compiledReadSets(config) {
+	if (config.readSets.length === 0) return [];
+	return compileReadSets(await loadReadSets(config));
+}
+//#endregion
+export { parseHookMarker as a, readPermdock as c, parseGrantsMarker as i, fileDiff as l, entitlementHelpers as n, permdockConfig as o, entitlementsMode as r, permdockSource as s, compiledReadSets as t };