@venn-lang/project 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,599 @@
+import { BuildTarget, BuildTarget as BuildTarget$1, Dependency, FileSystem, Manifest, Manifest as Manifest$1, PackageInfo, PackageManagerName, Profile, WorkspaceSettings } from "@venn-lang/contracts";
+//#region src/discover/conventional-targets.d.ts
+/**
+ * What a package builds when its manifest does not say.
+ *
+ * `src/lib.vn` is a library, `src/main.vn` is a program, and each file in
+ * `src/bin/` is another program. A package that builds the obvious thing should
+ * not have to write it down. A declared target always wins, matched by kind and
+ * name, so writing `[lib]` with a different `path` moves the library rather
+ * than adding a second one.
+ *
+ * @param args.declared What the manifest spelled out.
+ * @param args.packageName Names the `lib` and the `src/main.vn` program.
+ * @returns The declared targets, followed by every convention found on disk.
+ */
+declare function conventionalTargets(args: {
+  fs: FileSystem;
+  dir: string;
+  declared: readonly BuildTarget$1[];
+  packageName: string;
+}): Promise<BuildTarget$1[]>;
+//#endregion
+//#region src/model/project.types.d.ts
+/**
+ * A package on disk: one `venn.toml`, and what it turned out to describe.
+ *
+ * `targets` is what the manifest declared plus what the conventions filled in.
+ * The difference between the two matters to whoever writes a manifest and to
+ * nobody downstream, so it is settled here rather than carried further.
+ */
+interface Package {
+  /** The directory holding the `venn.toml`, with no trailing separator. */
+  dir: string;
+  manifest: Manifest$1;
+  targets: readonly BuildTarget$1[];
+}
+/**
+ * What a command is acting on: one root, and every package under it.
+ *
+ * A lone package is a workspace of one, so nothing downstream has to ask which
+ * it is. `isWorkspace` is for the two places that genuinely differ: where
+ * `target/` goes, and what a bare command means.
+ */
+interface Project {
+  /** The workspace root, or the package's own directory when there is none. */
+  root: string;
+  isWorkspace: boolean;
+  /**
+   * The manifest at the root, carried whether or not the root is a package.
+   *
+   * A workspace root often declares no `[package]` at all and still carries the
+   * `[env]` tables and path aliases everything under it uses, so it cannot be
+   * inferred from the member list.
+   */
+  rootManifest: Manifest$1;
+  /** Every member, in the order the globs found them. A lone package is one. */
+  packages: readonly Package[];
+  /** What a command with no target acts on: `default-members`, or all of them. */
+  defaultPackages: readonly Package[];
+}
+/** Reading a project failed, and why. Never a raw error from the disk. */
+interface ProjectProblem {
+  code: string;
+  title: string;
+  /** The path the problem is about, when there is one. */
+  path?: string;
+}
+/** The result of a lookup: the project, or why there is none. */
+interface FoundProject {
+  /** Absent when no manifest was found, in which case `problems` says so. */
+  project?: Project;
+  problems: readonly ProjectProblem[];
+}
+//#endregion
+//#region src/discover/find-project.d.ts
+/**
+ * The project a path belongs to: the nearest package, and the root that owns it.
+ *
+ * Walking up is what lets a command run from anywhere inside a project, the way
+ * `cargo` and `git` do. A package is claimed by an ancestor workspace only when
+ * that workspace's members name it, so a project checked out inside another
+ * never joins it by accident.
+ *
+ * @param args.fs Where the manifests are read from.
+ * @param args.from Any path inside the project; the walk starts here.
+ * @returns The project with its members loaded and inheritance applied, or one
+ * `VN2101` problem when no `venn.toml` sits here or above. Reading a project
+ * never throws: a failure comes back as a problem.
+ */
+declare function findProject(args: {
+  fs: FileSystem;
+  from: string;
+}): Promise<FoundProject>;
+//#endregion
+//#region src/discover/load-package.d.ts
+/**
+ * One package: its manifest, whatever it inherits, and what it builds.
+ *
+ * Inheritance is applied here rather than at the point of use, so nothing
+ * downstream ever holds a manifest that is only half the answer.
+ *
+ * @param args.dir The directory holding the `venn.toml`.
+ * @returns The package, or `undefined` when that directory has no manifest.
+ */
+declare function loadPackage(args: {
+  fs: FileSystem;
+  dir: string;
+  /** The workspace this package belongs to, when it belongs to one. */
+  workspace?: Manifest$1;
+  /** Where that workspace's manifest lives, which is what its paths mean. */
+  workspaceDir?: string;
+}): Promise<Package | undefined>;
+//#endregion
+//#region src/discover/read-manifest.d.ts
+/** The file that makes a directory a package or a workspace root. */
+declare const MANIFEST_FILE = "venn.toml";
+/**
+ * Reads and parses the `venn.toml` in one directory.
+ *
+ * @returns The manifest, or `undefined` when the file is absent or unreadable.
+ * A directory that cannot be read is a directory without a manifest, so the
+ * caller keeps walking instead of failing.
+ */
+declare function readManifest(args: {
+  fs: FileSystem;
+  dir: string;
+}): Promise<Manifest$1 | undefined>;
+//#endregion
+//#region src/glob/expand-members.d.ts
+/**
+ * Expands a workspace's `members` patterns against the disk.
+ *
+ * `*` stands for one path segment, the way Cargo reads it, so `packages/*` is
+ * every package one level down and nothing deeper. `**` is deliberately not
+ * read: a member list that can reach arbitrarily far is one nobody can predict.
+ *
+ * @param args.root The workspace root the patterns are written against.
+ * @returns The directories matched, duplicates dropped, in pattern order with
+ * names sorted inside each pattern, so two machines list a workspace alike.
+ */
+declare function expandMembers(args: {
+  fs: FileSystem;
+  root: string;
+  patterns: readonly string[];
+}): Promise<string[]>;
+//#endregion
+//#region src/glob/matches-member.d.ts
+/**
+ * Whether a path would be caught by a workspace's `members`, without looking at
+ * the disk.
+ *
+ * Needed before the directory exists: creating `packages/api` inside a
+ * workspace should produce a manifest that inherits, and expanding the globs
+ * cannot answer that yet because there is nothing there to find.
+ *
+ * @returns `true` when some pattern matches segment for segment, `*` standing
+ * for exactly one segment.
+ */
+declare function matchesMember(args: {
+  /** The candidate directory, written relative to the workspace root. */
+  path: string;
+  patterns: readonly string[];
+}): boolean;
+//#endregion
+//#region src/npm/hash-package.d.ts
+/**
+ * A hash of everything a package installed.
+ *
+ * Not the registry's integrity hash, which lives in each manager's own lock in
+ * each manager's format. This is computed from what landed on disk, which every
+ * manager produces the same way. The guarantee differs: the registry's hash
+ * says "this is the tarball that was served", this one says "this is the tree
+ * that was installed when the lock was written". Trust on first use, and any
+ * divergence after that is caught.
+ *
+ * A hash of hashes rather than of the concatenated bytes, because a package can
+ * hold tens of megabytes and digesting it in one buffer costs more than the
+ * answer is worth.
+ *
+ * @param args.dir The installed package directory.
+ * @returns `sha256-…` over every file under `dir`, sorted by path, with
+ * `node_modules`, `.git` and `.bin` skipped. A file that cannot be read is left
+ * out rather than raising.
+ */
+declare function hashPackage(args: {
+  fs: FileSystem;
+  dir: string;
+}): Promise<string>;
+//#endregion
+//#region src/npm/lockfile.types.d.ts
+/** One package that ended up installed. */
+interface LockedPackage {
+  name: string;
+  version: string;
+  /**
+   * `sha256-…` over the files this package installed.
+   *
+   * Not the registry's integrity hash, which lives in each manager's own lock
+   * in each manager's format. This is computed from what landed on disk and
+   * catches any divergence from the moment the lock was written. Absent in a
+   * lock written before hashes existed. See `hashPackage`.
+   */
+  integrity?: string;
+  /** What it says it needs, so the graph can be read without the disk. */
+  dependencies?: Record<string, string>;
+}
+/**
+ * `venn.lock`: what this project resolved to, in a form no tool owns.
+ *
+ * Read from what is actually installed rather than translated out of whichever
+ * manager's lock produced it, because tracking three formats that change
+ * without asking would mean two machines building different things the day the
+ * translation drifts.
+ *
+ * It pins the exact version of every package and a hash of the files each one
+ * installed, so `venn install --frozen` can refuse a tree that has drifted,
+ * whether a registry answered differently or something was changed by hand.
+ */
+interface Lockfile {
+  version: 1;
+  /** Which tool did the resolving. The answer can differ between them. */
+  manager: string;
+  /** Every package installed, in name order. */
+  packages: readonly LockedPackage[];
+}
+/** The lock file's name, at the project root beside the manifest. */
+declare const LOCK_FILE = "venn.lock";
+/** The format version written into every lock. */
+declare const LOCK_VERSION = 1;
+//#endregion
+//#region src/npm/lockfile.d.ts
+/**
+ * Writes `venn.lock` from what is installed.
+ *
+ * It goes at the project root, beside the manifest, and is meant to be
+ * committed. The manager's own lock stays inside `target/`, which is derived
+ * and thrown away.
+ *
+ * @param args.manager Which tool did the resolving, recorded in the file.
+ * @returns The lock as written.
+ * @throws Whatever the file system raises when the write fails.
+ */
+declare function writeLockfile(args: {
+  fs: FileSystem;
+  root: string;
+  manager: string;
+}): Promise<Lockfile>;
+/**
+ * Reads the lock this project committed.
+ *
+ * @returns The lock, or `undefined` when the file is absent or will not parse.
+ * A lock nobody can read is a project without one, which `install` can fix.
+ */
+declare function readLockfile(args: {
+  fs: FileSystem;
+  root: string;
+}): Promise<Lockfile | undefined>;
+//#endregion
+//#region src/npm/manager-command.d.ts
+/** The four verbs Venn proxies to whichever package manager the project chose. */
+type ProxiedVerb = "add" | "remove" | "update" | "install";
+/** A package manager invocation, ready to spawn. */
+interface ManagerCommand {
+  command: string;
+  args: readonly string[];
+  /**
+   * Whether it has to go through a shell.
+   *
+   * Every one of these managers ships as a script, and on Windows that means a
+   * `.cmd`, which Node refuses to spawn directly because `.cmd` files were used
+   * to slip arguments past programs that believed they were spawning an
+   * executable. So a shell it is, and because a shell re-reads what it is
+   * handed, what goes in is checked first. See {@link isSafeSpec}.
+   */
+  shell: boolean;
+}
+/**
+ * The command a verb becomes, in the manager this project chose.
+ *
+ * The interface is ours, the resolution is not: working out which versions
+ * satisfy which ranges is years of work against three moving targets, so the
+ * four verbs are spelled once here and handed to the tool the project named.
+ *
+ * @param args.packages Specifiers to act on. Pass each through
+ * {@link isSafeSpec} first when `shell` comes back `true`.
+ * @returns The command, its arguments, and whether a shell is required.
+ */
+declare function managerCommand(args: {
+  manager: PackageManagerName;
+  verb: ProxiedVerb;
+  packages?: readonly string[];
+  dev?: boolean;
+  /** `process.platform`. It decides whether a shell is needed. */
+  platform: string;
+}): ManagerCommand;
+/**
+ * Whether a string is a package specifier and nothing else.
+ *
+ * The command goes through a shell on Windows, and a shell reads `&`, `|` and
+ * `>` as instructions rather than text, so `venn add "x & del /q ."` would
+ * delete a directory while looking like an install. A real package name holds
+ * none of those characters, so checking costs nothing and closes the hole
+ * instead of documenting it.
+ *
+ * @returns `true` when the string is safe to hand to a shell.
+ */
+declare function isSafeSpec(spec: string): boolean;
+//#endregion
+//#region src/npm/package-json.d.ts
+/**
+ * The `package.json` a package manager is shown, generated from `venn.toml`.
+ *
+ * Nobody edits it and nobody commits it: the manifest is the source, this is
+ * what the tool underneath happens to read. It is written into `target/`, and
+ * that placement is the whole trick: a manager writes `node_modules` beside the
+ * `package.json` it was pointed at, so the modules land in
+ * `target/node_modules` with nothing fighting anything.
+ *
+ * @param args.members Their dependencies are merged in too, when the root is a
+ * workspace.
+ * @returns The file's text, marked private, with path dependencies left out and
+ * `[patch]` turned into `overrides`.
+ */
+declare function packageJsonFor(args: {
+  manifest: Manifest$1;
+  /** Every member's dependencies as well, when the root is a workspace. */
+  members?: readonly Manifest$1[];
+}): string;
+//#endregion
+//#region src/npm/read-installed.d.ts
+/**
+ * Every package installed, read from `target/node_modules`.
+ *
+ * The installed tree is the strongest statement there is about what a project
+ * resolved to: it is what will actually be imported, whichever tool put it
+ * there and whatever that tool's own lock says. One walk, the same for every
+ * manager. A scope is a directory of packages rather than a package, so
+ * `@types/node` is found one level further down.
+ *
+ * @param args.root The project root, not the modules directory.
+ * @returns Every package with its version and content hash, in name order.
+ * Dot-directories and anything without a readable `package.json` are skipped,
+ * because a directory that is not a package is not a package.
+ */
+declare function readInstalled(args: {
+  fs: FileSystem;
+  root: string;
+}): Promise<LockedPackage[]>;
+//#endregion
+//#region src/npm/verify-lock.d.ts
+/** How one package differs from what the lock recorded. */
+interface Drift {
+  name: string;
+  /**
+   * In the lock but absent, installed but not locked, a different version, or
+   * the same version with different files.
+   */
+  kind: "missing" | "unexpected" | "version" | "contents";
+  /** What the lock recorded: a version, or an `integrity` hash. */
+  expected?: string;
+  /** What is on disk, when the two can be compared side by side. */
+  found?: string;
+}
+/**
+ * Checks what is installed against what the lock says should be.
+ *
+ * This is what the hashes are for. Checked, they turn a registry that answered
+ * differently today, or a file edited by hand inside `node_modules`, into
+ * something a build refuses to start with rather than something found in
+ * production.
+ *
+ * @returns One `Drift` per difference, empty when the tree matches. A lock
+ * entry carrying no `integrity` is not checked for contents, so a lock written
+ * before hashes existed still passes.
+ */
+declare function verifyLock(args: {
+  fs: FileSystem;
+  root: string;
+  lock: Lockfile;
+}): Promise<Drift[]>;
+/**
+ * Renders drift for a person to read.
+ *
+ * @returns One indented line per package that differs, in the voice of what
+ * went wrong. Empty for an empty list.
+ */
+declare function describeDrift(drift: readonly Drift[]): string;
+//#endregion
+//#region src/paths/paths.d.ts
+/**
+ * Path arithmetic on manifest paths, with no `node:path`.
+ *
+ * This package runs in a Web Worker as well as in the CLI, so paths are handled
+ * as text with forward slashes. A Windows path arrives with backslashes and is
+ * normalised on the way in, which is the one place the difference is allowed to
+ * exist.
+ */
+/**
+ * One path, written the one way the rest of this package understands.
+ *
+ * @returns The path with backslashes turned into forward slashes, runs of
+ * separators collapsed, and any trailing separator dropped. `"/"` stays `"/"`.
+ */
+declare function normalise(path: string): string;
+/**
+ * Joins path segments, ignoring empty ones.
+ *
+ * @returns The joined path, normalised. No `..` is resolved: these are manifest
+ * paths, and what a manifest wrote is what gets written down.
+ */
+declare function join(...parts: readonly string[]): string;
+/**
+ * The directory holding this path.
+ *
+ * @returns The parent, or `undefined` when there is nothing above. A relative
+ * path with one segment has the empty string as its parent, which is the
+ * directory it was written against; stopping short of it would leave a walk up
+ * from `packages/api` never reaching the workspace root beside it.
+ */
+declare function parentOf(path: string): string | undefined;
+/** The last segment of a path, which is the file or directory's own name. */
+declare function baseName(path: string): string;
+/**
+ * Every directory from `path` up to the top, `path` itself first.
+ *
+ * @returns The chain, ending in `""` for a relative path and `"/"` for an
+ * absolute one.
+ */
+declare function ancestors(path: string): string[];
+/** Whether `path` is `base` or sits inside it. */
+declare function isInside(path: string, base: string): boolean;
+/** `path` written relative to `base`, or the path itself when it is not inside. */
+declare function relativeTo(path: string, base: string): string;
+/**
+ * A relative path written in one directory, rewritten to mean the same thing
+ * from another inside it.
+ *
+ * A workspace root writes `"#shared" = "./shared"` once and every member uses
+ * it, but a member reads it from further down, where `./shared` is somewhere
+ * else entirely.
+ *
+ * @param args.declaredIn Where the path was written.
+ * @param args.usedIn Where it will be read.
+ * @returns The path with one `../` per directory of depth. An absolute path is
+ * returned unchanged: it already means the same thing everywhere.
+ */
+declare function reanchor(args: {
+  path: string;
+  declaredIn: string;
+  usedIn: string;
+}): string;
+//#endregion
+//#region src/scaffold/scaffold.types.d.ts
+/** What kind of thing is being started. */
+type ScaffoldKind = "lib" | "bin" | "workspace";
+/** What to start, and what the surroundings already provide. */
+interface ScaffoldRequest {
+  kind: ScaffoldKind;
+  /** The package name, which is also the directory when one is created. */
+  name: string;
+  /**
+   * Whether a workspace above will claim this package as a member.
+   *
+   * Changes what is written rather than only where: a member leaves out what it
+   * would inherit and carries no ignore file, because the root already owns the
+   * one `target/` there is.
+   */
+  insideWorkspace?: boolean;
+}
+/** One file to write, its path relative to the directory being started. */
+interface ScaffoldFile {
+  path: string;
+  content: string;
+}
+//#endregion
+//#region src/scaffold/scaffold.d.ts
+/**
+ * The files a new project starts as.
+ *
+ * Pure: it says what should exist and the caller writes it, so `--dry-run`, the
+ * tests and the disk all see one answer. What is generated is deliberately
+ * small, because a starting point that has to be deleted before it can be used
+ * is worse than one that is missing something.
+ *
+ * @returns The manifest, a source file for anything that is not a workspace,
+ * and a `.gitignore` unless a workspace above already owns one.
+ */
+declare function scaffold(request: ScaffoldRequest): ScaffoldFile[];
+//#endregion
+//#region src/target/layout.d.ts
+/**
+ * Where everything a build produces or fetches goes.
+ *
+ * One directory at the workspace root holds every derived thing, the way
+ * Cargo's `target/` does, so deleting it costs time and nothing else.
+ *
+ * The dependencies live inside it, and that placement is load-bearing rather
+ * than tidiness: Node resolves a package by walking up from the importing file
+ * looking for `node_modules`, and built output sits in `target/debug` or
+ * `target/release`, one level below `target/node_modules`. The ordinary
+ * resolver finds them with no loader and no symlink. Moving the output out of
+ * `target/` breaks that quietly.
+ */
+declare const TARGET_DIR = "target";
+/** The names inside `target/`. */
+declare const TARGET_LAYOUT: {
+  /** What the package manager installs, and what Node's resolver will find. */
+  readonly modules: "node_modules";
+  /** Compiled addons, kept apart because they are per-platform, not per-project. */
+  readonly native: "native_modules";
+  /** Built output, one directory per profile. */
+  readonly debug: "debug";
+  readonly release: "release";
+};
+/** Which build profile an output directory belongs to. */
+type ProfileName = "debug" | "release";
+/** The `target/` of a project, given its root. */
+declare function targetDir(root: string): string;
+/** Where the package manager installs, and where Node's resolver will look. */
+declare function modulesDir(root: string): string;
+/** Where compiled addons go, kept apart because they are per-platform. */
+declare function nativeModulesDir(root: string): string;
+/** Where a build of this profile is written. */
+declare function outputDir(args: {
+  root: string;
+  profile: ProfileName;
+}): string;
+//#endregion
+//#region src/target/build-record.d.ts
+/** One target a build covered, and where it starts. */
+interface BuiltTarget {
+  package: string;
+  kind: string;
+  name: string;
+  /** The entry file, relative to the workspace root. */
+  path: string;
+}
+/** What one build covered, and how it went. */
+interface BuildRecord {
+  profile: ProfileName;
+  targets: readonly BuiltTarget[];
+  /** How many `.vn` files were read, and how many problems were found. */
+  files: number;
+  problems: number;
+}
+/** The record's name, inside the profile's output directory. */
+declare const RECORD_FILE = "build.json";
+/**
+ * Writes what a build produced, where that build's outputs go.
+ *
+ * It answers "what does this project build, and did it hold together", and it
+ * is what an incremental build compares against once there is generated code to
+ * skip.
+ *
+ * @returns The path written.
+ * @throws Whatever the file system raises when the write fails.
+ */
+declare function writeBuildRecord(args: {
+  fs: FileSystem;
+  root: string;
+  record: BuildRecord;
+}): Promise<string>;
+//#endregion
+//#region src/workspace/inherit.d.ts
+/**
+ * A member manifest with what the workspace root supplies filled in.
+ *
+ * Two things are inherited and they work differently. `[workspace.package]` is
+ * a default: the member's own value wins wherever it wrote one. A dependency
+ * marked `{ workspace = true }` is a request, so the root's answer replaces
+ * whatever was there. Writing both a version and `workspace = true` is a
+ * contradiction, and the request is the deliberate half.
+ *
+ * @param args.from The workspace root's manifest. A root with no `[workspace]`
+ * table supplies nothing, and the member is returned untouched.
+ * @returns The merged manifest. The member's own `name` always survives.
+ */
+declare function inherit(args: {
+  manifest: Manifest$1;
+  from: Manifest$1;
+}): Manifest$1;
+//#endregion
+//#region src/workspace/member-dirs.d.ts
+/**
+ * The directories a workspace's members occupy, exclusions already applied.
+ *
+ * @returns The member directories, normalised. One holding no `venn.toml` is
+ * dropped rather than reported: a glob describes a shape, and `packages/*`
+ * catching a `dist` folder on the way past is the glob working, not the
+ * workspace being wrong.
+ */
+declare function memberDirs(args: {
+  fs: FileSystem;
+  root: string;
+  workspace: WorkspaceSettings;
+}): Promise<string[]>;
+//#endregion
+export { type BuildRecord, type BuildTarget, type BuiltTarget, type Dependency, type Drift, type FoundProject, LOCK_FILE, LOCK_VERSION, type LockedPackage, type Lockfile, MANIFEST_FILE, type ManagerCommand, type Manifest, type Package, type PackageInfo, type Profile, type ProfileName, type Project, type ProjectProblem, type ProxiedVerb, RECORD_FILE, type ScaffoldFile, type ScaffoldKind, type ScaffoldRequest, TARGET_DIR, TARGET_LAYOUT, ancestors, baseName, conventionalTargets, describeDrift, expandMembers, findProject, hashPackage, inherit, isInside, isSafeSpec, join, loadPackage, managerCommand, matchesMember, memberDirs, modulesDir, nativeModulesDir, normalise, outputDir, packageJsonFor, parentOf, readInstalled, readLockfile, readManifest, reanchor, relativeTo, scaffold, targetDir, verifyLock, writeBuildRecord, writeLockfile };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/discover/conventional-targets.ts","../src/model/project.types.ts","../src/discover/find-project.ts","../src/discover/load-package.ts","../src/discover/read-manifest.ts","../src/glob/expand-members.ts","../src/glob/matches-member.ts","../src/npm/hash-package.ts","../src/npm/lockfile.types.ts","../src/npm/lockfile.ts","../src/npm/manager-command.ts","../src/npm/package-json.ts","../src/npm/read-installed.ts","../src/npm/verify-lock.ts","../src/paths/paths.ts","../src/scaffold/scaffold.types.ts","../src/scaffold/scaffold.ts","../src/target/layout.ts","../src/target/build-record.ts","../src/workspace/inherit.ts","../src/workspace/member-dirs.ts"],"mappings":";;;;;;;;;;;;;;;iBAsBsB,oBAAoB;EACxC,IAAI;EACJ;EACA,mBAAmB;EACnB;IACE,QAAQ;;;;;;;;;;UClBK;;EAEf;EACA,UAAU;EACV,kBAAkB;;;;;;;;;UAUH;;EAEf;EACA;;;;;;;;EAQA,cAAc;;EAEd,mBAAmB;;EAEnB,0BAA0B;;;UAIX;EACf;EACA;;EAEA;;;UAIe;;EAEf,UAAU;EACV,mBAAmB;;;;;;;;;;;;;;;;;;iBChCC,YAAY;EAAQ,IAAI;EAAY;IAAiB,QAAQ;;;;;;;;;;;;iBCL7D,YAAY;EAChC,IAAI;EACJ;;EAEA,YAAY;;EAEZ;IACE,QAAQ;;;;cCnBC;;;;;;;;iBASS,aAAa;EACjC,IAAI;EACJ;IACE,QAAQ;;;;;;;;;;;;;;iBCFU,cAAc;EAClC,IAAI;EACJ;EACA;IACE;;;;;;;;;;;;;;iBCLY,cAAc;;EAE5B;EACA;;;;;;;;;;;;;;;;;;;;;;;iBCSoB,YAAY;EAAQ,IAAI;EAAY;IAAgB;;;;UCxBzD;EACf;EACA;;;;;;;;;EASA;;EAEA,eAAe;;;;;;;;;;;;;;UAeA;EACf;;EAEA;;EAEA,mBAAmB;;;cAIR;;cAGA;;;;;;;;;;;;;;iBCzBS,cAAc;EAClC,IAAI;EACJ;EACA;IACE,QAAQ;;;;;;;iBAiBU,aAAa;EACjC,IAAI;EACJ;IACE,QAAQ;;;;KCrCA;;UAGK;EACf;EACA;;;;;;;;;;EAUA;;;;;;;;;;;;;iBAcc,eAAe;EAC7B,SAAS;EACT,MAAM;EACN;EACA;;EAEA;IACE;;;;;;;;;;;;iBA2CY,WAAW;;;;;;;;;;;;;;;;;iBClEX,eAAe;EAC7B,UAAU;;EAEV,mBAAmB;;;;;;;;;;;;;;;;;;iBCCC,cAAc;EAClC,IAAI;EACJ;IACE,QAAQ;;;;UClBK;EACf;;;;;EAKA;;EAEA;;EAEA;;;;;;;;;;;;;;iBAeoB,WAAW;EAC/B,IAAI;EACJ;EACA,MAAM;IACJ,QAAQ;;;;;;;iBA8BI,cAAc,gBAAgB;;;;;;;;;;;;;;;;;iBCjD9B,UAAU;;;;;;;iBAWV,QAAQ;;;;;;;;;iBAaR,SAAS;;iBAST,SAAS;;;;;;;iBAWT,UAAU;;iBAWV,SAAS,cAAc;;iBAOvB,WAAW,cAAc;;;;;;;;;;;;;;iBAmBzB,SAAS;EAAQ;EAAc;EAAoB;;;;;KC/FvD;;UAGK;EACf,MAAM;;EAEN;;;;;;;;EAQA;;;UAIe;EACf;EACA;;;;;;;;;;;;;;;iBCNc,SAAS,SAAS,kBAAkB;;;;;;;;;;;;;;;;cCAvC;;cAGA;;WAEX;;WAEA;;WAEA;WACA;;;KAIU;;iBAGI,UAAU;;iBAKV,WAAW;;iBAKX,iBAAiB;;iBAKjB,UAAU;EAAQ;EAAc,SAAS;;;;;UC1CxC;EACf;EACA;EACA;;EAEA;;;UAIe;EACf,SAAS;EACT,kBAAkB;;EAElB;EACA;;;cAIW;;;;;;;;;;;iBAYS,iBAAiB;EACrC,IAAI;EACJ;EACA,QAAQ;IACN;;;;;;;;;;;;;;;;iBCxBY,QAAQ;EAAQ,UAAU;EAAU,MAAM;IAAa;;;;;;;;;;;iBCHjD,WAAW;EAC/B,IAAI;EACJ;EACA,WAAW;IACT"}