@prisma/orm-toolchain 0.16.0-dev.36

package/dist/import-roots-NDOIEDVj.mjs

@@ -0,0 +1,217 @@
+import { n as publicShells } from "./shells-BenrJHp2.mjs";
+//#region ../../../0-shared/publish-surface/dist/import-roots.mjs
+/**
+* Import-root resolution: the one place that turns an internal workspace
+* specifier into the name generated code should carry.
+*
+* Emission writes package names into files the user keeps — generated
+* contract types, scaffolded migrations, `prisma-next init` output. Which
+* name is correct depends on how the application installed Prisma Next, so
+* every emitter resolves through an {@link ImportRoot} rather than hardcoding
+* a specifier. The mapping itself is `./shells`; nothing here duplicates it.
+*/
+const INTERNAL_SCOPE = "@internal/";
+const PUBLISHED_SCOPE = "@prisma/";
+/** An import root that emitted code cannot express. */
+var ImportRootError = class extends Error {};
+const internalImportRoot = { mode: "internal" };
+/**
+* The import root an application's own dependency list expresses.
+*
+* Emission has to name packages the application can actually resolve, and the
+* application already states which those are. Reading its manifest keeps the
+* two from drifting and lets consumers move to published names one project at
+* a time instead of behind a repository-wide switch.
+*
+* A project that names exactly one facade is on the facade root; one that
+* names platform shells without a facade is a decomposed install; anything
+* else — including a project with no `@prisma/orm-*` dependency at all — is on
+* the internal root, which emits workspace names unchanged.
+*
+* @throws {ImportRootError} when the project depends on two facades, which no
+* single generated file can be emitted for.
+*/
+function importRootForDependencies(dependencies) {
+	const named = new Set(dependencies);
+	const facades = [];
+	let hasPlatform = false;
+	for (const [shell, definition] of publicShells) {
+		if (!named.has(shell)) continue;
+		if (definition.kind === "facade") facades.push(shell);
+		if (definition.kind === "platform") hasPlatform = true;
+	}
+	if (facades.length > 1) throw new ImportRootError(`an application may depend on only one database facade, but this one depends on ${facades.join(" and ")}`);
+	const [facade] = facades;
+	if (facade !== void 0) return {
+		mode: "facade",
+		facade
+	};
+	return hasPlatform ? { mode: "platform" } : internalImportRoot;
+}
+const owners = buildOwnerIndex(publicShells);
+/**
+* Takes the shell map as an argument rather than closing over `publicShells`
+* so the duplicate-owner guard is reachable from a test: the real map is
+* valid by construction, and a guard nothing can exercise is a guard nobody
+* knows still works.
+*/
+function buildOwnerIndex(shells) {
+	const index = /* @__PURE__ */ new Map();
+	for (const [shell, definition] of shells) for (const pkg of definition.packages) {
+		const existing = index.get(pkg.name);
+		if (existing !== void 0) throw new ImportRootError(`${pkg.name} is mapped to both ${existing.shell} and ${shell}; one module may live in only one published package (ADR 242)`);
+		index.set(pkg.name, {
+			shell,
+			entry: pkg.entry
+		});
+	}
+	return index;
+}
+function splitSpecifier(specifier) {
+	const [scope, pkg, ...rest] = specifier.split("/");
+	return {
+		name: `${scope}/${pkg}`,
+		subpath: rest.join("/")
+	};
+}
+function joinEntrypoint(shell, entry, subpath) {
+	const tail = [entry, subpath].filter(Boolean).join("/");
+	return tail === "" ? shell : `${shell}/${tail}`;
+}
+/**
+* The shells an application installs directly under this root. Emitted code
+* may name only these: a package manager puts a package's own dependencies in
+* its own `node_modules`, so importing a transitively installed package fails
+* to resolve at run time even though the files are on disk.
+*/
+function directDependencyShells(root) {
+	const direct = /* @__PURE__ */ new Set();
+	if (root.mode === "internal") return direct;
+	for (const [shell, definition] of publicShells) {
+		if (definition.kind === "extension") direct.add(shell);
+		if (root.mode === "platform" && definition.kind === "platform") direct.add(shell);
+	}
+	if (root.mode === "facade") direct.add(root.facade);
+	return direct;
+}
+function owningShell(specifier, name) {
+	const owner = owners.get(name);
+	if (owner === void 0) throw new ImportRootError(`${specifier} is not mapped to any published shell`);
+	return owner;
+}
+/**
+* The platform-install name for an internal specifier, with the shell that
+* owns it. The shell build needs both: an import that stays inside the shell
+* being built is bundled rather than externalized.
+*/
+function platformEntrypointOf(specifier) {
+	const { name, subpath } = splitSpecifier(specifier);
+	const owner = owningShell(specifier, name);
+	return {
+		shell: owner.shell,
+		id: joinEntrypoint(owner.shell, owner.entry, subpath)
+	};
+}
+/**
+* The facade's own name for an internal specifier it republishes, or
+* `undefined` when the facade does not carry that surface.
+*/
+function facadeEntrypoint(facade, name, subpath) {
+	const definition = publicShells.get(facade);
+	/* v8 ignore next -- @preserve: every ShellName is a key of publicShells */
+	if (definition === void 0) throw new ImportRootError(`unknown shell ${facade}`);
+	if (definition.kind !== "facade") throw new ImportRootError(`${facade} is a ${definition.kind} shell, not a facade`);
+	for (const reexport of definition.reexports ?? []) {
+		if (reexport.package !== name) continue;
+		if (subpath === "" && reexport.root === false) return void 0;
+		if (reexport.subpaths !== void 0 && !reexport.subpaths.includes(subpath)) return void 0;
+		return joinEntrypoint(facade, reexport.entry, subpath);
+	}
+}
+function describe(root) {
+	return root.mode === "facade" ? `${root.mode} (${root.facade})` : root.mode;
+}
+function resolveImportSpecifier(specifier, root) {
+	if (root.mode === "internal") return specifier;
+	if (!specifier.startsWith(INTERNAL_SCOPE)) return specifier;
+	const { name, subpath } = splitSpecifier(specifier);
+	if (root.mode === "facade") {
+		const republished = facadeEntrypoint(root.facade, name, subpath);
+		if (republished !== void 0) return republished;
+	}
+	const owner = owningShell(specifier, name);
+	const published = joinEntrypoint(owner.shell, owner.entry, subpath);
+	if (!directDependencyShells(root).has(owner.shell)) throw new ImportRootError(unreachableUnder(specifier, published, root));
+	return published;
+}
+/**
+* Why a specifier has no name under `root`.
+*
+* The facade wording deliberately does not say "not a direct dependency":
+* under ADR 242 the answer to that is never "install the platform package
+* too", it is that the facade has to republish the surface.
+*/
+function unreachableUnder(specifier, published, root) {
+	if (root.mode === "facade") return `${specifier} has no name under ${root.facade}: the facade does not republish ${published}. An application installs one facade and nothing else, so every surface it reaches has to be one of that facade’s own entrypoints (ADR 242).`;
+	return `${specifier} resolves to ${published}, which an application on the ${describe(root)} import root does not depend on directly. Emitted code may name only direct dependencies (ADR 242).`;
+}
+function createImportSpecifierResolver(root) {
+	if (root.mode === "internal") return (specifier) => specifier;
+	return (specifier) => resolveImportSpecifier(specifier, root);
+}
+/**
+* Builds the resolver `prisma-next init` scaffolds with. Identical to
+* {@link createImportSpecifierResolver} except that it will not accept a root
+* a scaffold cannot express, so the impossible case is rejected where the
+* resolver is made rather than when a template happens to hit a name.
+*/
+function createScaffoldSpecifierResolver(root) {
+	return createImportSpecifierResolver(root);
+}
+const MODULE_SPECIFIER = /\b(?:from|import)\s*\(?\s*(['"])([^'"\n]+)\1/g;
+/**
+* True when `source` contains module syntax that must carry a quoted
+* specifier: `import '<s>'`, `import('<s>')`, or an import/export clause
+* followed by `from '<s>'`.
+*
+* Deliberately independent of {@link MODULE_SPECIFIER} — it exists to notice
+* when that scanner has stopped matching, so it accepts any quote character,
+* including the backtick a renderer must never emit. It does still require a
+* quote: the word "import" on its own appears in prose and comments all the
+* time, and treating that as module syntax made the check below fire on files
+* that have no imports at all.
+*/
+const HAS_IMPORT_SYNTAX = /(?:^|[\s(;}])import\s*[('"`]|(?:^|[\s;}])(?:import|export)\b[\w$*,{}\s]*?\bfrom\s*['"`]/;
+/** The module specifiers a generated source file names. */
+function importedSpecifiers(source) {
+	return [...source.matchAll(MODULE_SPECIFIER)].map(([, , specifier]) => specifier ?? "");
+}
+/**
+* The specifiers in a generated file that the application would not have as a
+* direct dependency under `root` — the thing no emitted file may contain.
+*
+* Under the `internal` root nothing is reported: those names are the
+* repository's own, and every in-repo consumer resolves them through the
+* workspace.
+*
+* Throws rather than returning `[]` when the source plainly has imports but
+* the scan found none. An audit whose scanner has stopped matching would
+* otherwise report every file as clean, which is the one failure mode that
+* makes the audit worse than not having it.
+*/
+function transitiveImports(source, root) {
+	const specifiers = importedSpecifiers(source);
+	if (specifiers.length === 0 && HAS_IMPORT_SYNTAX.test(source)) throw new ImportRootError("source contains import syntax but no specifier was recognised; the audit would pass vacuously");
+	if (root.mode === "internal") return [];
+	const direct = new Set(directDependencyShells(root));
+	return specifiers.filter((specifier) => {
+		if (specifier.startsWith(INTERNAL_SCOPE)) return true;
+		if (!specifier.startsWith(PUBLISHED_SCOPE)) return false;
+		const [scope, shell] = specifier.split("/");
+		return !direct.has(`${scope}/${shell}`);
+	});
+}
+//#endregion
+export { directDependencyShells as a, internalImportRoot as c, transitiveImports as d, createScaffoldSpecifierResolver as i, platformEntrypointOf as l, buildOwnerIndex as n, importRootForDependencies as o, createImportSpecifierResolver as r, importedSpecifiers as s, ImportRootError as t, resolveImportSpecifier as u };
+
+//# sourceMappingURL=import-roots-NDOIEDVj.mjs.map

package/dist/import-roots-NDOIEDVj.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-roots-NDOIEDVj.mjs","names":[],"sources":["../../../../0-shared/publish-surface/dist/import-roots.mjs"],"sourcesContent":["import { publicShells } from \"./shells.mjs\";\n//#region src/import-roots.ts\n/**\n* Import-root resolution: the one place that turns an internal workspace\n* specifier into the name generated code should carry.\n*\n* Emission writes package names into files the user keeps — generated\n* contract types, scaffolded migrations, `prisma-next init` output. Which\n* name is correct depends on how the application installed Prisma Next, so\n* every emitter resolves through an {@link ImportRoot} rather than hardcoding\n* a specifier. The mapping itself is `./shells`; nothing here duplicates it.\n*/\nconst INTERNAL_SCOPE = \"@internal/\";\nconst PUBLISHED_SCOPE = \"@prisma/\";\n/** An import root that emitted code cannot express. */\nvar ImportRootError = class extends Error {};\nconst internalImportRoot = { mode: \"internal\" };\n/**\n* The import root an application's own dependency list expresses.\n*\n* Emission has to name packages the application can actually resolve, and the\n* application already states which those are. Reading its manifest keeps the\n* two from drifting and lets consumers move to published names one project at\n* a time instead of behind a repository-wide switch.\n*\n* A project that names exactly one facade is on the facade root; one that\n* names platform shells without a facade is a decomposed install; anything\n* else — including a project with no `@prisma/orm-*` dependency at all — is on\n* the internal root, which emits workspace names unchanged.\n*\n* @throws {ImportRootError} when the project depends on two facades, which no\n* single generated file can be emitted for.\n*/\nfunction importRootForDependencies(dependencies) {\n\tconst named = new Set(dependencies);\n\tconst facades = [];\n\tlet hasPlatform = false;\n\tfor (const [shell, definition] of publicShells) {\n\t\tif (!named.has(shell)) continue;\n\t\tif (definition.kind === \"facade\") facades.push(shell);\n\t\tif (definition.kind === \"platform\") hasPlatform = true;\n\t}\n\tif (facades.length > 1) throw new ImportRootError(`an application may depend on only one database facade, but this one depends on ${facades.join(\" and \")}`);\n\tconst [facade] = facades;\n\tif (facade !== void 0) return {\n\t\tmode: \"facade\",\n\t\tfacade\n\t};\n\treturn hasPlatform ? { mode: \"platform\" } : internalImportRoot;\n}\nconst owners = buildOwnerIndex(publicShells);\n/**\n* Takes the shell map as an argument rather than closing over `publicShells`\n* so the duplicate-owner guard is reachable from a test: the real map is\n* valid by construction, and a guard nothing can exercise is a guard nobody\n* knows still works.\n*/\nfunction buildOwnerIndex(shells) {\n\tconst index = /* @__PURE__ */ new Map();\n\tfor (const [shell, definition] of shells) for (const pkg of definition.packages) {\n\t\tconst existing = index.get(pkg.name);\n\t\tif (existing !== void 0) throw new ImportRootError(`${pkg.name} is mapped to both ${existing.shell} and ${shell}; one module may live in only one published package (ADR 242)`);\n\t\tindex.set(pkg.name, {\n\t\t\tshell,\n\t\t\tentry: pkg.entry\n\t\t});\n\t}\n\treturn index;\n}\nfunction splitSpecifier(specifier) {\n\tconst [scope, pkg, ...rest] = specifier.split(\"/\");\n\treturn {\n\t\tname: `${scope}/${pkg}`,\n\t\tsubpath: rest.join(\"/\")\n\t};\n}\nfunction joinEntrypoint(shell, entry, subpath) {\n\tconst tail = [entry, subpath].filter(Boolean).join(\"/\");\n\treturn tail === \"\" ? shell : `${shell}/${tail}`;\n}\n/**\n* The shells an application installs directly under this root. Emitted code\n* may name only these: a package manager puts a package's own dependencies in\n* its own `node_modules`, so importing a transitively installed package fails\n* to resolve at run time even though the files are on disk.\n*/\nfunction directDependencyShells(root) {\n\tconst direct = /* @__PURE__ */ new Set();\n\tif (root.mode === \"internal\") return direct;\n\tfor (const [shell, definition] of publicShells) {\n\t\tif (definition.kind === \"extension\") direct.add(shell);\n\t\tif (root.mode === \"platform\" && definition.kind === \"platform\") direct.add(shell);\n\t}\n\tif (root.mode === \"facade\") direct.add(root.facade);\n\treturn direct;\n}\nfunction owningShell(specifier, name) {\n\tconst owner = owners.get(name);\n\tif (owner === void 0) throw new ImportRootError(`${specifier} is not mapped to any published shell`);\n\treturn owner;\n}\n/**\n* The platform-install name for an internal specifier, with the shell that\n* owns it. The shell build needs both: an import that stays inside the shell\n* being built is bundled rather than externalized.\n*/\nfunction platformEntrypointOf(specifier) {\n\tconst { name, subpath } = splitSpecifier(specifier);\n\tconst owner = owningShell(specifier, name);\n\treturn {\n\t\tshell: owner.shell,\n\t\tid: joinEntrypoint(owner.shell, owner.entry, subpath)\n\t};\n}\n/**\n* The facade's own name for an internal specifier it republishes, or\n* `undefined` when the facade does not carry that surface.\n*/\nfunction facadeEntrypoint(facade, name, subpath) {\n\tconst definition = publicShells.get(facade);\n\t/* v8 ignore next -- @preserve: every ShellName is a key of publicShells */\n\tif (definition === void 0) throw new ImportRootError(`unknown shell ${facade}`);\n\tif (definition.kind !== \"facade\") throw new ImportRootError(`${facade} is a ${definition.kind} shell, not a facade`);\n\tfor (const reexport of definition.reexports ?? []) {\n\t\tif (reexport.package !== name) continue;\n\t\tif (subpath === \"\" && reexport.root === false) return void 0;\n\t\tif (reexport.subpaths !== void 0 && !reexport.subpaths.includes(subpath)) return void 0;\n\t\treturn joinEntrypoint(facade, reexport.entry, subpath);\n\t}\n}\nfunction describe(root) {\n\treturn root.mode === \"facade\" ? `${root.mode} (${root.facade})` : root.mode;\n}\nfunction resolveImportSpecifier(specifier, root) {\n\tif (root.mode === \"internal\") return specifier;\n\tif (!specifier.startsWith(INTERNAL_SCOPE)) return specifier;\n\tconst { name, subpath } = splitSpecifier(specifier);\n\tif (root.mode === \"facade\") {\n\t\tconst republished = facadeEntrypoint(root.facade, name, subpath);\n\t\tif (republished !== void 0) return republished;\n\t}\n\tconst owner = owningShell(specifier, name);\n\tconst published = joinEntrypoint(owner.shell, owner.entry, subpath);\n\tif (!directDependencyShells(root).has(owner.shell)) throw new ImportRootError(unreachableUnder(specifier, published, root));\n\treturn published;\n}\n/**\n* Why a specifier has no name under `root`.\n*\n* The facade wording deliberately does not say \"not a direct dependency\":\n* under ADR 242 the answer to that is never \"install the platform package\n* too\", it is that the facade has to republish the surface.\n*/\nfunction unreachableUnder(specifier, published, root) {\n\tif (root.mode === \"facade\") return `${specifier} has no name under ${root.facade}: the facade does not republish ${published}. An application installs one facade and nothing else, so every surface it reaches has to be one of that facade’s own entrypoints (ADR 242).`;\n\treturn `${specifier} resolves to ${published}, which an application on the ${describe(root)} import root does not depend on directly. Emitted code may name only direct dependencies (ADR 242).`;\n}\nfunction createImportSpecifierResolver(root) {\n\tif (root.mode === \"internal\") return (specifier) => specifier;\n\treturn (specifier) => resolveImportSpecifier(specifier, root);\n}\n/**\n* Builds the resolver `prisma-next init` scaffolds with. Identical to\n* {@link createImportSpecifierResolver} except that it will not accept a root\n* a scaffold cannot express, so the impossible case is rejected where the\n* resolver is made rather than when a template happens to hit a name.\n*/\nfunction createScaffoldSpecifierResolver(root) {\n\treturn createImportSpecifierResolver(root);\n}\nconst MODULE_SPECIFIER = /\\b(?:from|import)\\s*\\(?\\s*(['\"])([^'\"\\n]+)\\1/g;\n/**\n* True when `source` contains module syntax that must carry a quoted\n* specifier: `import '<s>'`, `import('<s>')`, or an import/export clause\n* followed by `from '<s>'`.\n*\n* Deliberately independent of {@link MODULE_SPECIFIER} — it exists to notice\n* when that scanner has stopped matching, so it accepts any quote character,\n* including the backtick a renderer must never emit. It does still require a\n* quote: the word \"import\" on its own appears in prose and comments all the\n* time, and treating that as module syntax made the check below fire on files\n* that have no imports at all.\n*/\nconst HAS_IMPORT_SYNTAX = /(?:^|[\\s(;}])import\\s*[('\"`]|(?:^|[\\s;}])(?:import|export)\\b[\\w$*,{}\\s]*?\\bfrom\\s*['\"`]/;\n/** The module specifiers a generated source file names. */\nfunction importedSpecifiers(source) {\n\treturn [...source.matchAll(MODULE_SPECIFIER)].map(([, , specifier]) => specifier ?? \"\");\n}\n/**\n* The specifiers in a generated file that the application would not have as a\n* direct dependency under `root` — the thing no emitted file may contain.\n*\n* Under the `internal` root nothing is reported: those names are the\n* repository's own, and every in-repo consumer resolves them through the\n* workspace.\n*\n* Throws rather than returning `[]` when the source plainly has imports but\n* the scan found none. An audit whose scanner has stopped matching would\n* otherwise report every file as clean, which is the one failure mode that\n* makes the audit worse than not having it.\n*/\nfunction transitiveImports(source, root) {\n\tconst specifiers = importedSpecifiers(source);\n\tif (specifiers.length === 0 && HAS_IMPORT_SYNTAX.test(source)) throw new ImportRootError(\"source contains import syntax but no specifier was recognised; the audit would pass vacuously\");\n\tif (root.mode === \"internal\") return [];\n\tconst direct = new Set(directDependencyShells(root));\n\treturn specifiers.filter((specifier) => {\n\t\tif (specifier.startsWith(INTERNAL_SCOPE)) return true;\n\t\tif (!specifier.startsWith(PUBLISHED_SCOPE)) return false;\n\t\tconst [scope, shell] = specifier.split(\"/\");\n\t\treturn !direct.has(`${scope}/${shell}`);\n\t});\n}\n//#endregion\nexport { ImportRootError, buildOwnerIndex, createImportSpecifierResolver, createScaffoldSpecifierResolver, directDependencyShells, importRootForDependencies, importedSpecifiers, internalImportRoot, platformEntrypointOf, resolveImportSpecifier, transitiveImports };\n\n//# sourceMappingURL=import-roots.mjs.map"],"mappings":";;;;;;;;;;;;AAYA,MAAM,iBAAiB;AACvB,MAAM,kBAAkB;;AAExB,IAAI,kBAAkB,cAAc,MAAM,CAAC;AAC3C,MAAM,qBAAqB,EAAE,MAAM,WAAW;;;;;;;;;;;;;;;;;AAiB9C,SAAS,0BAA0B,cAAc;CAChD,MAAM,QAAQ,IAAI,IAAI,YAAY;CAClC,MAAM,UAAU,CAAC;CACjB,IAAI,cAAc;CAClB,KAAK,MAAM,CAAC,OAAO,eAAe,cAAc;EAC/C,IAAI,CAAC,MAAM,IAAI,KAAK,GAAG;EACvB,IAAI,WAAW,SAAS,UAAU,QAAQ,KAAK,KAAK;EACpD,IAAI,WAAW,SAAS,YAAY,cAAc;CACnD;CACA,IAAI,QAAQ,SAAS,GAAG,MAAM,IAAI,gBAAgB,kFAAkF,QAAQ,KAAK,OAAO,GAAG;CAC3J,MAAM,CAAC,UAAU;CACjB,IAAI,WAAW,KAAK,GAAG,OAAO;EAC7B,MAAM;EACN;CACD;CACA,OAAO,cAAc,EAAE,MAAM,WAAW,IAAI;AAC7C;AACA,MAAM,SAAS,gBAAgB,YAAY;;;;;;;AAO3C,SAAS,gBAAgB,QAAQ;CAChC,MAAM,wBAAwB,IAAI,IAAI;CACtC,KAAK,MAAM,CAAC,OAAO,eAAe,QAAQ,KAAK,MAAM,OAAO,WAAW,UAAU;EAChF,MAAM,WAAW,MAAM,IAAI,IAAI,IAAI;EACnC,IAAI,aAAa,KAAK,GAAG,MAAM,IAAI,gBAAgB,GAAG,IAAI,KAAK,qBAAqB,SAAS,MAAM,OAAO,MAAM,8DAA8D;EAC9K,MAAM,IAAI,IAAI,MAAM;GACnB;GACA,OAAO,IAAI;EACZ,CAAC;CACF;CACA,OAAO;AACR;AACA,SAAS,eAAe,WAAW;CAClC,MAAM,CAAC,OAAO,KAAK,GAAG,QAAQ,UAAU,MAAM,GAAG;CACjD,OAAO;EACN,MAAM,GAAG,MAAM,GAAG;EAClB,SAAS,KAAK,KAAK,GAAG;CACvB;AACD;AACA,SAAS,eAAe,OAAO,OAAO,SAAS;CAC9C,MAAM,OAAO,CAAC,OAAO,OAAO,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,KAAK,GAAG;CACtD,OAAO,SAAS,KAAK,QAAQ,GAAG,MAAM,GAAG;AAC1C;;;;;;;AAOA,SAAS,uBAAuB,MAAM;CACrC,MAAM,yBAAyB,IAAI,IAAI;CACvC,IAAI,KAAK,SAAS,YAAY,OAAO;CACrC,KAAK,MAAM,CAAC,OAAO,eAAe,cAAc;EAC/C,IAAI,WAAW,SAAS,aAAa,OAAO,IAAI,KAAK;EACrD,IAAI,KAAK,SAAS,cAAc,WAAW,SAAS,YAAY,OAAO,IAAI,KAAK;CACjF;CACA,IAAI,KAAK,SAAS,UAAU,OAAO,IAAI,KAAK,MAAM;CAClD,OAAO;AACR;AACA,SAAS,YAAY,WAAW,MAAM;CACrC,MAAM,QAAQ,OAAO,IAAI,IAAI;CAC7B,IAAI,UAAU,KAAK,GAAG,MAAM,IAAI,gBAAgB,GAAG,UAAU,sCAAsC;CACnG,OAAO;AACR;;;;;;AAMA,SAAS,qBAAqB,WAAW;CACxC,MAAM,EAAE,MAAM,YAAY,eAAe,SAAS;CAClD,MAAM,QAAQ,YAAY,WAAW,IAAI;CACzC,OAAO;EACN,OAAO,MAAM;EACb,IAAI,eAAe,MAAM,OAAO,MAAM,OAAO,OAAO;CACrD;AACD;;;;;AAKA,SAAS,iBAAiB,QAAQ,MAAM,SAAS;CAChD,MAAM,aAAa,aAAa,IAAI,MAAM;;CAE1C,IAAI,eAAe,KAAK,GAAG,MAAM,IAAI,gBAAgB,iBAAiB,QAAQ;CAC9E,IAAI,WAAW,SAAS,UAAU,MAAM,IAAI,gBAAgB,GAAG,OAAO,QAAQ,WAAW,KAAK,qBAAqB;CACnH,KAAK,MAAM,YAAY,WAAW,aAAa,CAAC,GAAG;EAClD,IAAI,SAAS,YAAY,MAAM;EAC/B,IAAI,YAAY,MAAM,SAAS,SAAS,OAAO,OAAO,KAAK;EAC3D,IAAI,SAAS,aAAa,KAAK,KAAK,CAAC,SAAS,SAAS,SAAS,OAAO,GAAG,OAAO,KAAK;EACtF,OAAO,eAAe,QAAQ,SAAS,OAAO,OAAO;CACtD;AACD;AACA,SAAS,SAAS,MAAM;CACvB,OAAO,KAAK,SAAS,WAAW,GAAG,KAAK,KAAK,IAAI,KAAK,OAAO,KAAK,KAAK;AACxE;AACA,SAAS,uBAAuB,WAAW,MAAM;CAChD,IAAI,KAAK,SAAS,YAAY,OAAO;CACrC,IAAI,CAAC,UAAU,WAAW,cAAc,GAAG,OAAO;CAClD,MAAM,EAAE,MAAM,YAAY,eAAe,SAAS;CAClD,IAAI,KAAK,SAAS,UAAU;EAC3B,MAAM,cAAc,iBAAiB,KAAK,QAAQ,MAAM,OAAO;EAC/D,IAAI,gBAAgB,KAAK,GAAG,OAAO;CACpC;CACA,MAAM,QAAQ,YAAY,WAAW,IAAI;CACzC,MAAM,YAAY,eAAe,MAAM,OAAO,MAAM,OAAO,OAAO;CAClE,IAAI,CAAC,uBAAuB,IAAI,CAAC,CAAC,IAAI,MAAM,KAAK,GAAG,MAAM,IAAI,gBAAgB,iBAAiB,WAAW,WAAW,IAAI,CAAC;CAC1H,OAAO;AACR;;;;;;;;AAQA,SAAS,iBAAiB,WAAW,WAAW,MAAM;CACrD,IAAI,KAAK,SAAS,UAAU,OAAO,GAAG,UAAU,qBAAqB,KAAK,OAAO,kCAAkC,UAAU;CAC7H,OAAO,GAAG,UAAU,eAAe,UAAU,gCAAgC,SAAS,IAAI,EAAE;AAC7F;AACA,SAAS,8BAA8B,MAAM;CAC5C,IAAI,KAAK,SAAS,YAAY,QAAQ,cAAc;CACpD,QAAQ,cAAc,uBAAuB,WAAW,IAAI;AAC7D;;;;;;;AAOA,SAAS,gCAAgC,MAAM;CAC9C,OAAO,8BAA8B,IAAI;AAC1C;AACA,MAAM,mBAAmB;;;;;;;;;;;;;AAazB,MAAM,oBAAoB;;AAE1B,SAAS,mBAAmB,QAAQ;CACnC,OAAO,CAAC,GAAG,OAAO,SAAS,gBAAgB,CAAC,CAAC,CAAC,KAAK,KAAK,eAAe,aAAa,EAAE;AACvF;;;;;;;;;;;;;;AAcA,SAAS,kBAAkB,QAAQ,MAAM;CACxC,MAAM,aAAa,mBAAmB,MAAM;CAC5C,IAAI,WAAW,WAAW,KAAK,kBAAkB,KAAK,MAAM,GAAG,MAAM,IAAI,gBAAgB,+FAA+F;CACxL,IAAI,KAAK,SAAS,YAAY,OAAO,CAAC;CACtC,MAAM,SAAS,IAAI,IAAI,uBAAuB,IAAI,CAAC;CACnD,OAAO,WAAW,QAAQ,cAAc;EACvC,IAAI,UAAU,WAAW,cAAc,GAAG,OAAO;EACjD,IAAI,CAAC,UAAU,WAAW,eAAe,GAAG,OAAO;EACnD,MAAM,CAAC,OAAO,SAAS,UAAU,MAAM,GAAG;EAC1C,OAAO,CAAC,OAAO,IAAI,GAAG,MAAM,GAAG,OAAO;CACvC,CAAC;AACF"}