import { A as __toCommonJS, D as __esmMin, E as __commonJSMin, O as __exportAll } from "./dist-fA4EItr0.mjs";
import { S as createState, X as generateId, g as baseLoadFromInput, h as baseCreateDocument, k as isDocumentAction, v as baseSaveToFileHandle, w as defaultBaseState, x as createReducer } from "./document-drive-DjL9iikf.mjs";
import { t as require_graphql } from "./graphql-DskHmkMe.mjs";
//#region ../reactor/dist/drive-container-types-CAhznKRr.js
/**
* Error thrown when a document model module is not found in the registry.
*/
var ModuleNotFoundError = class extends Error {
	documentType;
	requestedVersion;
	constructor(documentType, version) {
		const versionSuffix = version !== void 0 ? ` version ${version}` : "";
		super(`Document model module not found for type: ${documentType}${versionSuffix}`);
		this.name = "ModuleNotFoundError";
		this.documentType = documentType;
		this.requestedVersion = version;
	}
	static isError(error) {
		return Error.isError(error) && error.name === "ModuleNotFoundError";
	}
};
function driveCollectionId(branch, driveId) {
	return `drive.${branch}.${driveId}`;
}
//#endregion
//#region ../reactor/dist/index.js
let SyncStatus = /* @__PURE__ */ function(SyncStatus) {
	SyncStatus["Synced"] = "SYNCED";
	SyncStatus["Outgoing"] = "OUTGOING";
	SyncStatus["Incoming"] = "INCOMING";
	SyncStatus["OutgoingAndIncoming"] = "OUTGOING_AND_INCOMING";
	SyncStatus["Error"] = "ERROR";
	return SyncStatus;
}({});
//#endregion
//#region ../../node_modules/.pnpm/tslib@2.8.1/node_modules/tslib/tslib.es6.mjs
var tslib_es6_exports = /* @__PURE__ */ __exportAll({
	__addDisposableResource: () => __addDisposableResource,
	__assign: () => __assign,
	__asyncDelegator: () => __asyncDelegator,
	__asyncGenerator: () => __asyncGenerator,
	__asyncValues: () => __asyncValues,
	__await: () => __await,
	__awaiter: () => __awaiter,
	__classPrivateFieldGet: () => __classPrivateFieldGet,
	__classPrivateFieldIn: () => __classPrivateFieldIn,
	__classPrivateFieldSet: () => __classPrivateFieldSet,
	__createBinding: () => __createBinding,
	__decorate: () => __decorate,
	__disposeResources: () => __disposeResources,
	__esDecorate: () => __esDecorate,
	__exportStar: () => __exportStar,
	__extends: () => __extends,
	__generator: () => __generator,
	__importDefault: () => __importDefault,
	__importStar: () => __importStar,
	__makeTemplateObject: () => __makeTemplateObject,
	__metadata: () => __metadata,
	__param: () => __param,
	__propKey: () => __propKey,
	__read: () => __read,
	__rest: () => __rest,
	__rewriteRelativeImportExtension: () => __rewriteRelativeImportExtension,
	__runInitializers: () => __runInitializers,
	__setFunctionName: () => __setFunctionName,
	__spread: () => __spread,
	__spreadArray: () => __spreadArray,
	__spreadArrays: () => __spreadArrays,
	__values: () => __values,
	default: () => tslib_es6_default
});
function __extends(d, b) {
	if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
	extendStatics(d, b);
	function __() {
		this.constructor = d;
	}
	d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
function __rest(s, e) {
	var t = {};
	for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	if (s != null && typeof Object.getOwnPropertySymbols === "function") {
		for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
	}
	return t;
}
function __decorate(decorators, target, key, desc) {
	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function __param(paramIndex, decorator) {
	return function(target, key) {
		decorator(target, key, paramIndex);
	};
}
function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
	function accept(f) {
		if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
		return f;
	}
	var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
	var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
	var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
	var _, done = false;
	for (var i = decorators.length - 1; i >= 0; i--) {
		var context = {};
		for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
		for (var p in contextIn.access) context.access[p] = contextIn.access[p];
		context.addInitializer = function(f) {
			if (done) throw new TypeError("Cannot add initializers after decoration has completed");
			extraInitializers.push(accept(f || null));
		};
		var result = (0, decorators[i])(kind === "accessor" ? {
			get: descriptor.get,
			set: descriptor.set
		} : descriptor[key], context);
		if (kind === "accessor") {
			if (result === void 0) continue;
			if (result === null || typeof result !== "object") throw new TypeError("Object expected");
			if (_ = accept(result.get)) descriptor.get = _;
			if (_ = accept(result.set)) descriptor.set = _;
			if (_ = accept(result.init)) initializers.unshift(_);
		} else if (_ = accept(result)) if (kind === "field") initializers.unshift(_);
		else descriptor[key] = _;
	}
	if (target) Object.defineProperty(target, contextIn.name, descriptor);
	done = true;
}
function __runInitializers(thisArg, initializers, value) {
	var useValue = arguments.length > 2;
	for (var i = 0; i < initializers.length; i++) value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
	return useValue ? value : void 0;
}
function __propKey(x) {
	return typeof x === "symbol" ? x : "".concat(x);
}
function __setFunctionName(f, name, prefix) {
	if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
	return Object.defineProperty(f, "name", {
		configurable: true,
		value: prefix ? "".concat(prefix, " ", name) : name
	});
}
function __metadata(metadataKey, metadataValue) {
	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
}
function __awaiter(thisArg, _arguments, P, generator) {
	function adopt(value) {
		return value instanceof P ? value : new P(function(resolve) {
			resolve(value);
		});
	}
	return new (P || (P = Promise))(function(resolve, reject) {
		function fulfilled(value) {
			try {
				step(generator.next(value));
			} catch (e) {
				reject(e);
			}
		}
		function rejected(value) {
			try {
				step(generator["throw"](value));
			} catch (e) {
				reject(e);
			}
		}
		function step(result) {
			result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
		}
		step((generator = generator.apply(thisArg, _arguments || [])).next());
	});
}
function __generator(thisArg, body) {
	var _ = {
		label: 0,
		sent: function() {
			if (t[0] & 1) throw t[1];
			return t[1];
		},
		trys: [],
		ops: []
	}, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
	return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
		return this;
	}), g;
	function verb(n) {
		return function(v) {
			return step([n, v]);
		};
	}
	function step(op) {
		if (f) throw new TypeError("Generator is already executing.");
		while (g && (g = 0, op[0] && (_ = 0)), _) try {
			if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
			if (y = 0, t) op = [op[0] & 2, t.value];
			switch (op[0]) {
				case 0:
				case 1:
					t = op;
					break;
				case 4:
					_.label++;
					return {
						value: op[1],
						done: false
					};
				case 5:
					_.label++;
					y = op[1];
					op = [0];
					continue;
				case 7:
					op = _.ops.pop();
					_.trys.pop();
					continue;
				default:
					if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
						_ = 0;
						continue;
					}
					if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
						_.label = op[1];
						break;
					}
					if (op[0] === 6 && _.label < t[1]) {
						_.label = t[1];
						t = op;
						break;
					}
					if (t && _.label < t[2]) {
						_.label = t[2];
						_.ops.push(op);
						break;
					}
					if (t[2]) _.ops.pop();
					_.trys.pop();
					continue;
			}
			op = body.call(thisArg, _);
		} catch (e) {
			op = [6, e];
			y = 0;
		} finally {
			f = t = 0;
		}
		if (op[0] & 5) throw op[1];
		return {
			value: op[0] ? op[1] : void 0,
			done: true
		};
	}
}
function __exportStar(m, o) {
	for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
}
function __values(o) {
	var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
	if (m) return m.call(o);
	if (o && typeof o.length === "number") return { next: function() {
		if (o && i >= o.length) o = void 0;
		return {
			value: o && o[i++],
			done: !o
		};
	} };
	throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function __read(o, n) {
	var m = typeof Symbol === "function" && o[Symbol.iterator];
	if (!m) return o;
	var i = m.call(o), r, ar = [], e;
	try {
		while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
	} catch (error) {
		e = { error };
	} finally {
		try {
			if (r && !r.done && (m = i["return"])) m.call(i);
		} finally {
			if (e) throw e.error;
		}
	}
	return ar;
}
/** @deprecated */
function __spread() {
	for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
	return ar;
}
/** @deprecated */
function __spreadArrays() {
	for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
	for (var r = Array(s), k = 0, i = 0; i < il; i++) for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) r[k] = a[j];
	return r;
}
function __spreadArray(to, from, pack) {
	if (pack || arguments.length === 2) {
		for (var i = 0, l = from.length, ar; i < l; i++) if (ar || !(i in from)) {
			if (!ar) ar = Array.prototype.slice.call(from, 0, i);
			ar[i] = from[i];
		}
	}
	return to.concat(ar || Array.prototype.slice.call(from));
}
function __await(v) {
	return this instanceof __await ? (this.v = v, this) : new __await(v);
}
function __asyncGenerator(thisArg, _arguments, generator) {
	if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
	var g = generator.apply(thisArg, _arguments || []), i, q = [];
	return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
		return this;
	}, i;
	function awaitReturn(f) {
		return function(v) {
			return Promise.resolve(v).then(f, reject);
		};
	}
	function verb(n, f) {
		if (g[n]) {
			i[n] = function(v) {
				return new Promise(function(a, b) {
					q.push([
						n,
						v,
						a,
						b
					]) > 1 || resume(n, v);
				});
			};
			if (f) i[n] = f(i[n]);
		}
	}
	function resume(n, v) {
		try {
			step(g[n](v));
		} catch (e) {
			settle(q[0][3], e);
		}
	}
	function step(r) {
		r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
	}
	function fulfill(value) {
		resume("next", value);
	}
	function reject(value) {
		resume("throw", value);
	}
	function settle(f, v) {
		if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
	}
}
function __asyncDelegator(o) {
	var i, p;
	return i = {}, verb("next"), verb("throw", function(e) {
		throw e;
	}), verb("return"), i[Symbol.iterator] = function() {
		return this;
	}, i;
	function verb(n, f) {
		i[n] = o[n] ? function(v) {
			return (p = !p) ? {
				value: __await(o[n](v)),
				done: false
			} : f ? f(v) : v;
		} : f;
	}
}
function __asyncValues(o) {
	if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
	var m = o[Symbol.asyncIterator], i;
	return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
		return this;
	}, i);
	function verb(n) {
		i[n] = o[n] && function(v) {
			return new Promise(function(resolve, reject) {
				v = o[n](v), settle(resolve, reject, v.done, v.value);
			});
		};
	}
	function settle(resolve, reject, d, v) {
		Promise.resolve(v).then(function(v) {
			resolve({
				value: v,
				done: d
			});
		}, reject);
	}
}
function __makeTemplateObject(cooked, raw) {
	if (Object.defineProperty) Object.defineProperty(cooked, "raw", { value: raw });
	else cooked.raw = raw;
	return cooked;
}
function __importStar(mod) {
	if (mod && mod.__esModule) return mod;
	var result = {};
	if (mod != null) {
		for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
	}
	__setModuleDefault(result, mod);
	return result;
}
function __importDefault(mod) {
	return mod && mod.__esModule ? mod : { default: mod };
}
function __classPrivateFieldGet(receiver, state, kind, f) {
	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
	return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
}
function __classPrivateFieldSet(receiver, state, value, kind, f) {
	if (kind === "m") throw new TypeError("Private method is not writable");
	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
	return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
}
function __classPrivateFieldIn(state, receiver) {
	if (receiver === null || typeof receiver !== "object" && typeof receiver !== "function") throw new TypeError("Cannot use 'in' operator on non-object");
	return typeof state === "function" ? receiver === state : state.has(receiver);
}
function __addDisposableResource(env, value, async) {
	if (value !== null && value !== void 0) {
		if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
		var dispose, inner;
		if (async) {
			if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
			dispose = value[Symbol.asyncDispose];
		}
		if (dispose === void 0) {
			if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
			dispose = value[Symbol.dispose];
			if (async) inner = dispose;
		}
		if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
		if (inner) dispose = function() {
			try {
				inner.call(this);
			} catch (e) {
				return Promise.reject(e);
			}
		};
		env.stack.push({
			value,
			dispose,
			async
		});
	} else if (async) env.stack.push({ async: true });
	return value;
}
function __disposeResources(env) {
	function fail(e) {
		env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
		env.hasError = true;
	}
	var r, s = 0;
	function next() {
		while (r = env.stack.pop()) try {
			if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
			if (r.dispose) {
				var result = r.dispose.call(r.value);
				if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
					fail(e);
					return next();
				});
			} else s |= 1;
		} catch (e) {
			fail(e);
		}
		if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
		if (env.hasError) throw env.error;
	}
	return next();
}
function __rewriteRelativeImportExtension(path, preserveJsx) {
	if (typeof path === "string" && /^\.\.?\//.test(path)) return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
		return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : d + ext + "." + cm.toLowerCase() + "js";
	});
	return path;
}
var extendStatics, __assign, __createBinding, __setModuleDefault, ownKeys, _SuppressedError, tslib_es6_default;
var init_tslib_es6 = __esmMin((() => {
	extendStatics = function(d, b) {
		extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
			d.__proto__ = b;
		} || function(d, b) {
			for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
		};
		return extendStatics(d, b);
	};
	__assign = function() {
		__assign = Object.assign || function __assign(t) {
			for (var s, i = 1, n = arguments.length; i < n; i++) {
				s = arguments[i];
				for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
			}
			return t;
		};
		return __assign.apply(this, arguments);
	};
	__createBinding = Object.create ? (function(o, m, k, k2) {
		if (k2 === void 0) k2 = k;
		var desc = Object.getOwnPropertyDescriptor(m, k);
		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
			enumerable: true,
			get: function() {
				return m[k];
			}
		};
		Object.defineProperty(o, k2, desc);
	}) : (function(o, m, k, k2) {
		if (k2 === void 0) k2 = k;
		o[k2] = m[k];
	});
	__setModuleDefault = Object.create ? (function(o, v) {
		Object.defineProperty(o, "default", {
			enumerable: true,
			value: v
		});
	}) : function(o, v) {
		o["default"] = v;
	};
	ownKeys = function(o) {
		ownKeys = Object.getOwnPropertyNames || function(o) {
			var ar = [];
			for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
			return ar;
		};
		return ownKeys(o);
	};
	_SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
		var e = new Error(message);
		return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
	};
	tslib_es6_default = {
		__extends,
		__assign,
		__rest,
		__decorate,
		__param,
		__esDecorate,
		__runInitializers,
		__propKey,
		__setFunctionName,
		__metadata,
		__awaiter,
		__generator,
		__createBinding,
		__exportStar,
		__values,
		__read,
		__spread,
		__spreadArrays,
		__spreadArray,
		__await,
		__asyncGenerator,
		__asyncDelegator,
		__asyncValues,
		__makeTemplateObject,
		__importStar,
		__importDefault,
		__classPrivateFieldGet,
		__classPrivateFieldSet,
		__classPrivateFieldIn,
		__addDisposableResource,
		__disposeResources,
		__rewriteRelativeImportExtension
	};
}));
//#endregion
//#region ../../node_modules/.pnpm/graphql-tag@2.12.6_graphql@16.12.0/node_modules/graphql-tag/lib/graphql-tag.umd.js
var require_graphql_tag_umd = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	(function(global, factory) {
		typeof exports === "object" && typeof module !== "undefined" ? factory(exports, (init_tslib_es6(), __toCommonJS(tslib_es6_exports)), require_graphql()) : typeof define === "function" && define.amd ? define([
			"exports",
			"tslib",
			"graphql"
		], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["graphql-tag"] = {}, global.tslib, global.graphql));
	})(exports, (function(exports$1, tslib, graphql) {
		"use strict";
		var docCache = /* @__PURE__ */ new Map();
		var fragmentSourceMap = /* @__PURE__ */ new Map();
		var printFragmentWarnings = true;
		var experimentalFragmentVariables = false;
		function normalize(string) {
			return string.replace(/[\s,]+/g, " ").trim();
		}
		function cacheKeyFromLoc(loc) {
			return normalize(loc.source.body.substring(loc.start, loc.end));
		}
		function processFragments(ast) {
			var seenKeys = /* @__PURE__ */ new Set();
			var definitions = [];
			ast.definitions.forEach(function(fragmentDefinition) {
				if (fragmentDefinition.kind === "FragmentDefinition") {
					var fragmentName = fragmentDefinition.name.value;
					var sourceKey = cacheKeyFromLoc(fragmentDefinition.loc);
					var sourceKeySet = fragmentSourceMap.get(fragmentName);
					if (sourceKeySet && !sourceKeySet.has(sourceKey)) {
						if (printFragmentWarnings) console.warn("Warning: fragment with name " + fragmentName + " already exists.\ngraphql-tag enforces all fragment names across your application to be unique; read more about\nthis in the docs: http://dev.apollodata.com/core/fragments.html#unique-names");
					} else if (!sourceKeySet) fragmentSourceMap.set(fragmentName, sourceKeySet = /* @__PURE__ */ new Set());
					sourceKeySet.add(sourceKey);
					if (!seenKeys.has(sourceKey)) {
						seenKeys.add(sourceKey);
						definitions.push(fragmentDefinition);
					}
				} else definitions.push(fragmentDefinition);
			});
			return tslib.__assign(tslib.__assign({}, ast), { definitions });
		}
		function stripLoc(doc) {
			var workSet = new Set(doc.definitions);
			workSet.forEach(function(node) {
				if (node.loc) delete node.loc;
				Object.keys(node).forEach(function(key) {
					var value = node[key];
					if (value && typeof value === "object") workSet.add(value);
				});
			});
			var loc = doc.loc;
			if (loc) {
				delete loc.startToken;
				delete loc.endToken;
			}
			return doc;
		}
		function parseDocument(source) {
			var cacheKey = normalize(source);
			if (!docCache.has(cacheKey)) {
				var parsed = graphql.parse(source, {
					experimentalFragmentVariables,
					allowLegacyFragmentVariables: experimentalFragmentVariables
				});
				if (!parsed || parsed.kind !== "Document") throw new Error("Not a valid GraphQL document.");
				docCache.set(cacheKey, stripLoc(processFragments(parsed)));
			}
			return docCache.get(cacheKey);
		}
		function gql(literals) {
			var args = [];
			for (var _i = 1; _i < arguments.length; _i++) args[_i - 1] = arguments[_i];
			if (typeof literals === "string") literals = [literals];
			var result = literals[0];
			args.forEach(function(arg, i) {
				if (arg && arg.kind === "Document") result += arg.loc.source.body;
				else result += arg;
				result += literals[i + 1];
			});
			return parseDocument(result);
		}
		function resetCaches() {
			docCache.clear();
			fragmentSourceMap.clear();
		}
		function disableFragmentWarnings() {
			printFragmentWarnings = false;
		}
		function enableExperimentalFragmentVariables() {
			experimentalFragmentVariables = true;
		}
		function disableExperimentalFragmentVariables() {
			experimentalFragmentVariables = false;
		}
		var extras = {
			gql,
			resetCaches,
			disableFragmentWarnings,
			enableExperimentalFragmentVariables,
			disableExperimentalFragmentVariables
		};
		(function(gql_1) {
			gql_1.gql = extras.gql, gql_1.resetCaches = extras.resetCaches, gql_1.disableFragmentWarnings = extras.disableFragmentWarnings, gql_1.enableExperimentalFragmentVariables = extras.enableExperimentalFragmentVariables, gql_1.disableExperimentalFragmentVariables = extras.disableExperimentalFragmentVariables;
		})(gql || (gql = {}));
		gql["default"] = gql;
		exports$1.default = gql;
		exports$1.disableExperimentalFragmentVariables = disableExperimentalFragmentVariables;
		exports$1.disableFragmentWarnings = disableFragmentWarnings;
		exports$1.enableExperimentalFragmentVariables = enableExperimentalFragmentVariables;
		exports$1.gql = gql;
		exports$1.resetCaches = resetCaches;
		Object.defineProperty(exports$1, "__esModule", { value: true });
	}));
}));
//#endregion
//#region ../../node_modules/.pnpm/graphql-tag@2.12.6_graphql@16.12.0/node_modules/graphql-tag/main.js
var require_main = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	module.exports = require_graphql_tag_umd().gql;
}));
//#endregion
//#region ../reactor-drive/dist/index.js
var import_main = require_main();
const REACTOR_DRIVE_DOCUMENT_TYPE = "powerhouse/reactor-drive";
const REACTOR_DRIVE_FILE_EXTENSION = "phrd";
function setDriveNameAction(input) {
	return {
		id: generateId(),
		type: "SET_DRIVE_NAME",
		scope: "global",
		timestampUtcMs: (/* @__PURE__ */ new Date()).toISOString(),
		input
	};
}
function setDriveIconAction(input) {
	return {
		id: generateId(),
		type: "SET_DRIVE_ICON",
		scope: "global",
		timestampUtcMs: (/* @__PURE__ */ new Date()).toISOString(),
		input
	};
}
function setSharingTypeAction(input) {
	return {
		id: generateId(),
		type: "SET_SHARING_TYPE",
		scope: "local",
		timestampUtcMs: (/* @__PURE__ */ new Date()).toISOString(),
		input
	};
}
function setAvailableOfflineAction(input) {
	return {
		id: generateId(),
		type: "SET_AVAILABLE_OFFLINE",
		scope: "local",
		timestampUtcMs: (/* @__PURE__ */ new Date()).toISOString(),
		input
	};
}
function addFolderAction(input) {
	return {
		id: generateId(),
		type: "ADD_FOLDER",
		scope: "document",
		timestampUtcMs: (/* @__PURE__ */ new Date()).toISOString(),
		input
	};
}
function updateFolderAction(input) {
	return {
		id: generateId(),
		type: "UPDATE_FOLDER",
		scope: "document",
		timestampUtcMs: (/* @__PURE__ */ new Date()).toISOString(),
		input
	};
}
function removeFolderAction(input) {
	return {
		id: generateId(),
		type: "REMOVE_FOLDER",
		scope: "document",
		timestampUtcMs: (/* @__PURE__ */ new Date()).toISOString(),
		input
	};
}
const reactorDriveActions = {
	setDriveName: setDriveNameAction,
	setDriveIcon: setDriveIconAction,
	setSharingType: setSharingTypeAction,
	setAvailableOffline: setAvailableOfflineAction,
	addFolder: addFolderAction,
	updateFolder: updateFolderAction,
	removeFolder: removeFolderAction
};
const reactorDriveStateReducer = (state, action) => {
	if (isDocumentAction(action)) return state;
	const typedAction = action;
	switch (typedAction.type) {
		case "SET_DRIVE_NAME": {
			const input = typedAction.input;
			state.global.name = input.name;
			return state;
		}
		case "SET_DRIVE_ICON": {
			const input = typedAction.input;
			state.global.icon = input.icon;
			return state;
		}
		case "SET_SHARING_TYPE": {
			const input = typedAction.input;
			state.local.sharingType = input.sharingType;
			return state;
		}
		case "SET_AVAILABLE_OFFLINE": {
			const input = typedAction.input;
			state.local.availableOffline = input.availableOffline;
			return state;
		}
		case "ADD_FOLDER":
		case "UPDATE_FOLDER":
		case "REMOVE_FOLDER": return state;
		default: return state;
	}
};
const initialGlobalState = {
	name: "",
	icon: null
};
const initialLocalState = {
	sharingType: "private",
	availableOffline: false
};
const reactorDriveCreateState = (state) => {
	return {
		...defaultBaseState(),
		global: {
			...initialGlobalState,
			...state?.global
		},
		local: {
			...initialLocalState,
			...state?.local
		}
	};
};
const reactorDriveCreateDocument = (state) => {
	return baseCreateDocument(reactorDriveCreateState, state, REACTOR_DRIVE_DOCUMENT_TYPE);
};
const reactorDriveSaveToFileHandle = (document, input) => {
	return baseSaveToFileHandle(document, input);
};
const reactorDriveLoadFromInput = (input) => {
	return baseLoadFromInput(input, reactorDriveDocumentReducer);
};
const isReactorDriveState = (state) => {
	return typeof state === "object" && state !== null && "global" in state && "local" in state;
};
const assertIsReactorDriveState = (state) => {
	if (!isReactorDriveState(state)) throw new Error("Not a reactor-drive state");
};
const isReactorDriveDocument = (document) => {
	return typeof document === "object" && document !== null && "header" in document && document.header.documentType === "powerhouse/reactor-drive";
};
const assertIsReactorDriveDocument = (document) => {
	if (!isReactorDriveDocument(document)) throw new Error("Not a reactor-drive document");
};
const reactorDriveDocumentReducer = createReducer(reactorDriveStateReducer);
const reactorDriveDocumentGlobalState = {
	id: REACTOR_DRIVE_DOCUMENT_TYPE,
	name: "ReactorDrive",
	extension: REACTOR_DRIVE_FILE_EXTENSION,
	description: "",
	author: {
		name: "Powerhouse Inc",
		website: "https://www.powerhouse.inc/"
	},
	specifications: [{
		version: 1,
		changeLog: [],
		state: {
			global: {
				schema: "type ReactorDriveState {\n  name: String!\n  icon: String\n}",
				initialValue: JSON.stringify(JSON.stringify(initialGlobalState)),
				examples: []
			},
			local: {
				schema: "type ReactorDriveLocalState {\n  sharingType: String!\n  availableOffline: Boolean!\n}",
				initialValue: JSON.stringify(JSON.stringify(initialLocalState)),
				examples: []
			}
		},
		modules: [{
			id: "reactor-drive/base-operations",
			name: "base_operations",
			description: "",
			operations: [
				{
					id: "SET_DRIVE_NAME",
					name: "SET_DRIVE_NAME",
					description: "",
					schema: "input SetDriveNameInput { name: String! }",
					template: "",
					reducer: "",
					errors: [],
					examples: [],
					scope: "global"
				},
				{
					id: "SET_DRIVE_ICON",
					name: "SET_DRIVE_ICON",
					description: "",
					schema: "input SetDriveIconInput { icon: String }",
					template: "",
					reducer: "",
					errors: [],
					examples: [],
					scope: "global"
				},
				{
					id: "SET_SHARING_TYPE",
					name: "SET_SHARING_TYPE",
					description: "",
					schema: "input SetSharingTypeInput { sharingType: String! }",
					template: "",
					reducer: "",
					errors: [],
					examples: [],
					scope: "local"
				},
				{
					id: "SET_AVAILABLE_OFFLINE",
					name: "SET_AVAILABLE_OFFLINE",
					description: "",
					schema: "input SetAvailableOfflineInput { availableOffline: Boolean! }",
					template: "",
					reducer: "",
					errors: [],
					examples: [],
					scope: "local"
				},
				{
					id: "ADD_FOLDER",
					name: "ADD_FOLDER",
					description: "",
					schema: "input AddFolderInput { folderId: String! parentFolderId: String name: String! }",
					template: "",
					reducer: "",
					errors: [],
					examples: [],
					scope: "document"
				},
				{
					id: "UPDATE_FOLDER",
					name: "UPDATE_FOLDER",
					description: "",
					schema: "input UpdateFolderInput { folderId: String! name: String parentFolderId: String }",
					template: "",
					reducer: "",
					errors: [],
					examples: [],
					scope: "document"
				},
				{
					id: "REMOVE_FOLDER",
					name: "REMOVE_FOLDER",
					description: "",
					schema: "input RemoveFolderInput { folderId: String! }",
					template: "",
					reducer: "",
					errors: [],
					examples: [],
					scope: "document"
				}
			]
		}]
	}]
};
const reactorDriveDocumentModelModule = {
	actions: reactorDriveActions,
	reducer: reactorDriveDocumentReducer,
	documentModel: createState(defaultBaseState(), reactorDriveDocumentGlobalState),
	utils: {
		fileExtension: REACTOR_DRIVE_FILE_EXTENSION,
		createState: reactorDriveCreateState,
		createDocument: reactorDriveCreateDocument,
		loadFromInput: reactorDriveLoadFromInput,
		saveToFileHandle: reactorDriveSaveToFileHandle,
		isStateOfType: isReactorDriveState,
		assertIsStateOfType: assertIsReactorDriveState,
		isDocumentOfType: isReactorDriveDocument,
		assertIsDocumentOfType: assertIsReactorDriveDocument
	}
};
import_main.gql`
  enum ReactorDriveNodeKind {
    FILE
    FOLDER
  }

  input ReactorDrivePagingInput {
    cursor: String
    limit: Int
  }

  type ReactorDriveFileNode {
    id: ID!
    driveId: ID!
    name: String!
    parentFolder: ID
    documentType: String!
  }

  type ReactorDriveFolderNode {
    id: ID!
    driveId: ID!
    name: String!
    parentFolder: ID
    children(
      paging: ReactorDrivePagingInput
      kind: ReactorDriveNodeKind
    ): ReactorDriveNodePage!
  }

  union ReactorDriveNode = ReactorDriveFileNode | ReactorDriveFolderNode

  type ReactorDriveNodePage {
    results: [ReactorDriveNode!]!
    nextCursor: String
    hasMore: Boolean!
    totalCount: Int
  }

  type ReactorDrive {
    id: ID!
    name: String!
    icon: String
    sharingType: String!
    availableOffline: Boolean!
    rootNodes(
      paging: ReactorDrivePagingInput
      kind: ReactorDriveNodeKind
    ): ReactorDriveNodePage!
  }

  type Query {
    reactorDrive(id: ID!): ReactorDrive
    reactorDriveNode(driveId: ID!, id: ID!): ReactorDriveNode
    reactorDriveDescendants(driveId: ID!, root: ID!): [ReactorDriveNode!]!
  }
`;
//#endregion
export { SyncStatus as a, tslib_es6_exports as i, require_main as n, ModuleNotFoundError as o, init_tslib_es6 as r, driveCollectionId as s, reactorDriveDocumentModelModule as t };

//# sourceMappingURL=dist-vA9scgbK.mjs.map