@packall/core 0.0.1 → 0.1.0

package/dist/input-file.d.ts

@@ -0,0 +1,77 @@
+/**
+ * `--file` handling.
+ *
+ * One flag, three accepted shapes, detected from the content rather than the
+ * extension so that `--file deps.json` and `--file my-packages` both do the
+ * obvious thing:
+ *
+ * - a **package.json** — bundle everything it depends on
+ * - a **lockfile** — npm, pnpm or bun; bundle the exact versions it pins
+ * - a **newline-delimited list** — one spec per line, `#` and `//` comments
+ *   allowed, blank lines ignored
+ *
+ * A lockfile is checked for first, because `package-lock.json` and
+ * `package.json` are both JSON objects and only the content tells them apart.
+ */
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import { InputFileKind } from "./enums/input-file-kind.js";
+import type { LockfileError } from "./errors.js";
+import { InvalidInputFileError } from "./errors.js";
+import type { LockedTree } from "./lockfile/types.js";
+import type { PackageSpec } from "./spec.js";
+export type InputFileResult = {
+    readonly kind: InputFileKind;
+    readonly specs: ReadonlyArray<PackageSpec>;
+    /** Entries that were recognised but cannot be bundled from a registry. */
+    readonly warnings: ReadonlyArray<string>;
+    /**
+     * The pinned graph, set only for a lockfile.
+     *
+     * `specs` carries the same roots for display, but a lockfile run must resolve
+     * from this — see `locked-resolve` for why re-resolving the roots' ranges
+     * would quietly produce a different bundle.
+     */
+    readonly lockfile?: LockedTree | undefined;
+    /**
+     * Names from the blocks a package.json always installs — `dependencies` and,
+     * unless `--prod`, `devDependencies`.
+     *
+     * Used to check a lockfile against the manifest beside it. Deliberately
+     * excludes optional and peer entries: both are legitimately absent from a
+     * lockfile (an optional dependency that failed to build, a peer the consumer
+     * is expected to supply), so including them would turn a useful staleness
+     * check into a false alarm.
+     */
+    readonly required?: ReadonlyArray<string> | undefined;
+};
+/** Which dependency blocks of a package.json become root specs. */
+export type InputFileOptions = {
+    /**
+     * Include `devDependencies`.
+     *
+     * On by default: if you are pointing this tool at a package.json, you are
+     * almost certainly trying to make that project installable behind the
+     * firewall, and a project without its dev tooling does not build. `--prod`
+     * turns it off.
+     */
+    readonly includeDev: boolean;
+    /**
+     * For a lockfile, which workspace member's dependencies are the roots.
+     *
+     * Set when a package.json found its lockfile by walking up: the file then
+     * covers the whole repository, and only one member of it was asked for.
+     */
+    readonly importer?: string | undefined;
+};
+export declare const defaultInputFileOptions: InputFileOptions;
+/** Reads and parses an input file. */
+export declare const readInputFile: (filePath: string, options?: InputFileOptions) => Effect.Effect<InputFileResult, InvalidInputFileError | LockfileError, FileSystem.FileSystem>;
+/**
+ * Parses file content that has already been read.
+ *
+ * Split out from the IO so the whole of this logic is testable with plain
+ * strings and no file system at all.
+ */
+export declare const parseInputFile: (filePath: string, content: string, options?: InputFileOptions) => InputFileResult;
+//# sourceMappingURL=input-file.d.ts.map

package/dist/input-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-file.d.ts","sourceRoot":"","sources":["../src/input-file.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAA;AAG/C,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAE1D,OAAO,KAAK,EAAoB,aAAa,EAAE,MAAM,aAAa,CAAA;AAClE,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAGnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAGrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAG5C,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAA;IAC5B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,WAAW,CAAC,CAAA;IAC1C,0EAA0E;IAC1E,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IACxC;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,UAAU,GAAG,SAAS,CAAA;IAC1C;;;;;;;;;OASG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,SAAS,CAAA;CACtD,CAAA;AAED,mEAAmE;AACnE,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;;;;;;OAOG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;IAC5B;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACvC,CAAA;AAED,eAAO,MAAM,uBAAuB,EAAE,gBAAuC,CAAA;AAE7E,sCAAsC;AACtC,eAAO,MAAM,aAAa,aACd,MAAM,YACP,gBAAgB,KACxB,MAAM,CAAC,MAAM,CAAC,eAAe,EAAE,qBAAqB,GAAG,aAAa,EAAE,UAAU,CAAC,UAAU,CAwB1F,CAAA;AAKJ;;;;;GAKG;AACH,eAAO,MAAM,cAAc,aACf,MAAM,WACP,MAAM,YACN,gBAAgB,KACxB,eAoBF,CAAA"}

package/dist/{Integrity.d.ts → integrity.d.ts}

@@ -1,9 +1,9 @@
 /** One parsed SRI hash. */
-export interface IntegrityHash {
+export type IntegrityHash = {
     readonly algorithm: string;
     /** Base64 digest, exactly as written in the SRI string. */
     readonly digest: string;
-}
+};
 /**
  * Parses an SRI string such as `sha512-abc...==`.
  *
@@ -45,4 +45,4 @@ export declare const verify: (data: Uint8Array, dist: {
     readonly integrity?: string | undefined;
     readonly shasum?: string | undefined;
 }) => VerificationResult;
-//# sourceMappingURL=Integrity.d.ts.map
+//# sourceMappingURL=integrity.d.ts.map

package/dist/integrity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integrity.d.ts","sourceRoot":"","sources":["../src/integrity.ts"],"names":[],"mappings":"AAcA,2BAA2B;AAC3B,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,2DAA2D;IAC3D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB,CAAA;AAID;;;;;GAKG;AACH,eAAO,MAAM,cAAc,cAAe,MAAM,KAAG,aAAa,CAAC,aAAa,CAY7E,CAAA;AAED,oEAAoE;AACpE,eAAO,MAAM,QAAQ,SAAU,UAAU,aAAa,MAAM,KAAG,MACV,CAAA;AAErD,6EAA6E;AAC7E,eAAO,MAAM,WAAW,SAAU,UAAU,aAAa,MAAM,KAAG,MAChB,CAAA;AAElD,qCAAqC;AACrC,MAAM,MAAM,kBAAkB;AAC5B,8CAA8C;AAC5C;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE;AACvD,wDAAwD;GACtD;IAAE,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE;AAC5D,gDAAgD;GAC9C;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAUrF;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,SACX,UAAU,QACV;IAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,KACtF,kBA4BF,CAAA"}

package/dist/{Layout.d.ts → layout.d.ts}

@@ -50,4 +50,4 @@ export declare const importGuide: (options: {
     readonly createdAt: string;
     readonly toolVersion: string;
 }) => string;
-//# sourceMappingURL=Layout.d.ts.map
+//# sourceMappingURL=layout.d.ts.map

package/dist/{Layout.d.ts.map → layout.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"Layout.d.ts","sourceRoot":"","sources":["../src/Layout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,+EAA+E;AAC/E,eAAO,MAAM,SAAS,SACd,MAAM,KACX;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAK7D,CAAA;AAED,oDAAoD;AACpD,eAAO,MAAM,eAAe,SAAU,MAAM,WAAW,MAAM,KAAG,MAG/D,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,WAAW,SAAU,MAAM,WAAW,MAAM,KAAG,MACb,CAAA;AAE/C,gEAAgE;AAChE,eAAO,MAAM,aAAa,yBAAyB,CAAA;AAEnD,0EAA0E;AAC1E,eAAO,MAAM,WAAW,cAAc,CAAA;AAEtC;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,SAAU,MAAM,WAAW,MAAM,KAAG,MAIlE,CAAA;AAED,uDAAuD;AACvD,eAAO,MAAM,iBAAiB,qBAAsB,MAAuB,CAAA;AAE3E;;;;;GAKG;AACH,eAAO,MAAM,WAAW,YAAa;IACnC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAC7B,KAAG,MA+BH,CAAA"}
+{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../src/layout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,+EAA+E;AAC/E,eAAO,MAAM,SAAS,SACd,MAAM,KACX;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAK7D,CAAA;AAED,oDAAoD;AACpD,eAAO,MAAM,eAAe,SAAU,MAAM,WAAW,MAAM,KAAG,MAG/D,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,WAAW,SAAU,MAAM,WAAW,MAAM,KAAG,MACb,CAAA;AAE/C,gEAAgE;AAChE,eAAO,MAAM,aAAa,yBAAyB,CAAA;AAEnD,0EAA0E;AAC1E,eAAO,MAAM,WAAW,cAAc,CAAA;AAEtC;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,SAAU,MAAM,WAAW,MAAM,KAAG,MAIlE,CAAA;AAED,uDAAuD;AACvD,eAAO,MAAM,iBAAiB,qBAAsB,MAAuB,CAAA;AAE3E;;;;;GAKG;AACH,eAAO,MAAM,WAAW,YAAa;IACnC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAC7B,KAAG,MA+BH,CAAA"}

package/dist/locked-resolve.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Resolution driven by a lockfile instead of by semver.
+ *
+ * The distinction matters more than it first looks. Feeding a lockfile's
+ * versions in as exact root specs and letting the ordinary walk run would still
+ * produce the wrong bundle: every *transitive* edge is a range, and
+ * `Resolve.walk` answers a range with whatever is newest today. Lock `tslib` at
+ * 2.6.0 and let something depending on `tslib@^2` be re-resolved, and the
+ * bundle grows a second copy at 2.8.1 that CI never installed.
+ *
+ * So the lockfile is treated as the graph, not as a set of hints. The package
+ * set *is* what the file pins, and every edge is satisfied from inside it.
+ * Nothing here calls `selectVersions`; the only thing the registry is asked for
+ * is the metadata that a lockfile does not record — `dist`, and the `os`/`cpu`
+ * constraints that `--platform` narrows on.
+ *
+ * The result is an ordinary `Resolution`, so layout, archiving, the manifest
+ * and the summary cannot tell which path produced it.
+ */
+import * as Effect from "effect/Effect";
+import type { BundlerError } from "./errors.js";
+import type { LockedTree } from "./lockfile/types.js";
+import type { ResolveOptions } from "./options.js";
+import * as Progress from "./progress.js";
+import { Registry } from "./registry.js";
+import type { Resolution } from "./resolve.js";
+/** Options for a lockfile-pinned resolution. */
+export type LockedResolveOptions = ResolveOptions & {
+    /**
+     * Include the project's `devDependencies`.
+     *
+     * Matches `--file package.json`: on by default, because a project without its
+     * dev tooling does not build behind the firewall either.
+     */
+    readonly includeDev: boolean;
+    /**
+     * Direct dependency names declared by the accompanying package.json.
+     *
+     * When present, anything declared there but absent from the lockfile's roots
+     * means the two have drifted — which is exactly the silent-mismatch case this
+     * whole feature exists to catch, so it is reported rather than papered over.
+     */
+    readonly declared?: ReadonlyArray<string> | undefined;
+};
+/** Turns a parsed lockfile into a resolution, pinning every version. */
+export declare const resolveLocked: (lock: LockedTree, options: LockedResolveOptions) => Effect.Effect<Resolution, BundlerError, Registry | Progress.Progress>;
+//# sourceMappingURL=locked-resolve.d.ts.map

package/dist/locked-resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locked-resolve.d.ts","sourceRoot":"","sources":["../src/locked-resolve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAKvC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,OAAO,KAAK,EAAc,UAAU,EAAE,MAAM,qBAAqB,CAAA;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAElD,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,OAAO,KAAK,EAGR,UAAU,EAIb,MAAM,cAAc,CAAA;AAKrB,gDAAgD;AAChD,MAAM,MAAM,oBAAoB,GAAG,cAAc,GAAG;IAChD;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;IAC5B;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,SAAS,CAAA;CACxD,CAAA;AAED,wEAAwE;AACxE,eAAO,MAAM,aAAa,SAChB,UAAU,WACP,oBAAoB,KAC9B,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,YAAY,EAAE,QAAQ,GAAG,QAAQ,CAAC,QAAQ,CA6EjE,CAAA"}

package/dist/lockfile/bun.d.ts

@@ -0,0 +1,3 @@
+import type { LockedTree } from "./types.js";
+export declare const parseBunLockfile: (path: string, content: string, importer: string | undefined) => LockedTree;
+//# sourceMappingURL=bun.d.ts.map

package/dist/lockfile/bun.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bun.d.ts","sourceRoot":"","sources":["../../src/lockfile/bun.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAc,UAAU,EAAE,MAAM,YAAY,CAAA;AAqBxD,eAAO,MAAM,gBAAgB,SACrB,MAAM,WACH,MAAM,YACL,MAAM,GAAG,SAAS,KAC3B,UAsBF,CAAA"}

package/dist/lockfile/detect.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Working out which lockfile — if any — some content is.
+ *
+ * Detection is by content, matching how `--file` treats everything else: a
+ * lockfile renamed to `deps.txt` still parses, and a `package-lock.json` that
+ * is actually a package.json still gets read as one.
+ */
+import { LockfileFormat } from "../enums/lockfile-format.js";
+/** What a blob of file content turned out to be. */
+export type LockfileDetection = {
+    readonly _tag: "Supported";
+    readonly format: LockfileFormat;
+}
+/**
+ * Recognisably a lockfile, but not one we can read. Named explicitly so the
+ * error says "yarn.lock is not supported yet" rather than leaving somebody to
+ * work out why their file parsed as a spec list.
+ */
+ | {
+    readonly _tag: "Unsupported";
+    readonly label: string;
+    readonly hint: string;
+} | {
+    readonly _tag: "NotALockfile";
+};
+/**
+ * Deliberately cheap and total: it never throws, so `--file` can try this
+ * first and fall through to its other shapes when the answer is `NotALockfile`.
+ */
+export declare const detectLockfile: (content: string) => LockfileDetection;
+//# sourceMappingURL=detect.d.ts.map

package/dist/lockfile/detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect.d.ts","sourceRoot":"","sources":["../../src/lockfile/detect.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AAI5D,oDAAoD;AACpD,MAAM,MAAM,iBAAiB,GACzB;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAA;CAAE;AACjE;;;;GAIG;GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC/E;IAAE,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAA;CAAE,CAAA;AAErC;;;GAGG;AACH,eAAO,MAAM,cAAc,YAAa,MAAM,KAAG,iBA8BhD,CAAA"}

package/dist/lockfile/json.d.ts

@@ -0,0 +1,23 @@
+export declare const stringOr: (value: unknown, fallback: string) => string;
+/** Keeps only the string-valued members of an untyped object. */
+export declare const stringRecord: (value: unknown) => Readonly<Record<string, string>>;
+/** Names a package marked its peers optional with. */
+export declare const optionalPeerNames: (value: unknown) => ReadonlySet<string>;
+export declare const parseJsonObject: (path: string, content: string) => Record<string, unknown>;
+/**
+ * Parses JSON, tolerating the comments and trailing commas bun writes.
+ *
+ * `bun.lock` is JSONC by design — bun puts explanatory comments in it — so
+ * plain `JSON.parse` rejects real lockfiles. Returns `undefined` rather than
+ * throwing so detection can use it as a probe.
+ */
+export declare const tryParseJsonc: (content: string) => unknown;
+/**
+ * Removes comments and trailing commas.
+ *
+ * String-aware, because a `//` inside a tarball URL is not a comment and an
+ * escaped quote does not end a string. Both appear in every real lockfile.
+ */
+export declare const stripJsonc: (content: string) => string;
+export declare const describeError: (error: unknown) => string;
+//# sourceMappingURL=json.d.ts.map

package/dist/lockfile/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../src/lockfile/json.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,QAAQ,UAAW,OAAO,YAAY,MAAM,KAAG,MACd,CAAA;AAI9C,iEAAiE;AACjE,eAAO,MAAM,YAAY,UAAW,OAAO,KAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CACI,CAAA;AAIjF,sDAAsD;AACtD,eAAO,MAAM,iBAAiB,UAAW,OAAO,KAAG,WAAW,CAAC,MAAM,CAQpE,CAAA;AAED,eAAO,MAAM,eAAe,SAAU,MAAM,WAAW,MAAM,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CASrF,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,YAAa,MAAM,KAAG,OAU/C,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,UAAU,YAAa,MAAM,KAAG,MAuD5C,CAAA;AAED,eAAO,MAAM,aAAa,UAAW,OAAO,KAAG,MACS,CAAA"}

package/dist/lockfile/names.d.ts

@@ -0,0 +1,16 @@
+import { LockfileFormat } from "../enums/lockfile-format.js";
+/**
+ * The file name each supported manager writes, in detection order.
+ *
+ * Ordered: `package-lock.json` before `npm-shrinkwrap.json` before pnpm's and
+ * bun's, so a directory holding several is searched the way npm itself would.
+ */
+export declare const formatByLockfileName: {
+    readonly "package-lock.json": "npm";
+    readonly "npm-shrinkwrap.json": "npm";
+    readonly "pnpm-lock.yaml": "pnpm";
+    readonly "bun.lock": "bun";
+};
+/** The names a given manager writes. */
+export declare const lockfileNamesFor: (format: LockfileFormat) => ReadonlyArray<string>;
+//# sourceMappingURL=names.d.ts.map

package/dist/lockfile/names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"names.d.ts","sourceRoot":"","sources":["../../src/lockfile/names.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AAE5D;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;;;CAKkB,CAAA;AAEnD,wCAAwC;AACxC,eAAO,MAAM,gBAAgB,WAAY,cAAc,KAAG,aAAa,CAAC,MAAM,CAG3E,CAAA"}

package/dist/lockfile/npm.d.ts

@@ -0,0 +1,3 @@
+import type { LockedTree } from "./types.js";
+export declare const parseNpmLockfile: (path: string, content: string, importer: string | undefined) => LockedTree;
+//# sourceMappingURL=npm.d.ts.map

package/dist/lockfile/npm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"npm.d.ts","sourceRoot":"","sources":["../../src/lockfile/npm.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAc,UAAU,EAAE,MAAM,YAAY,CAAA;AAgCxD,eAAO,MAAM,gBAAgB,SACrB,MAAM,WACH,MAAM,YACL,MAAM,GAAG,SAAS,KAC3B,UAuBF,CAAA"}

package/dist/lockfile/parse.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Lockfile parsing — npm, pnpm and bun.
+ *
+ * `--file package.json` reads *ranges*, and a range resolves to whatever is
+ * newest at the moment the command runs. That is the right answer for "bundle
+ * me something installable" and the wrong one for "bundle exactly what CI
+ * installed" — which is what a lockfile records and what this module reads.
+ *
+ * Three formats, one output shape. Each parser's real job is the same: turn a
+ * manager-specific encoding of "package X at path P depends on Y" into a flat
+ * graph keyed by `name@version`, with every edge already pointing at a concrete
+ * version. Once that is done, nothing downstream has to know which manager
+ * wrote the file.
+ */
+import { LockfileFormat } from "../enums/lockfile-format.js";
+import type { LockedTree, LockfileParseOptions } from "./types.js";
+/**
+ * Parses lockfile content into a flat graph.
+ *
+ * Throws `LockfileError`; the caller is expected to be inside an `Effect.try`.
+ */
+export declare const parseLockfile: (path: string, content: string, format?: LockfileFormat, options?: LockfileParseOptions) => LockedTree;
+//# sourceMappingURL=parse.d.ts.map

package/dist/lockfile/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/lockfile/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AAM5D,OAAO,KAAK,EAAE,UAAU,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AAElE;;;;GAIG;AACH,eAAO,MAAM,aAAa,SAClB,MAAM,WACH,MAAM,WACN,cAAc,YACd,oBAAoB,KAC5B,UAWF,CAAA"}

package/dist/lockfile/pnpm.d.ts

@@ -0,0 +1,20 @@
+import type { LockedTree } from "./types.js";
+/** `name@version`, as a snapshot or importer entry resolves to. */
+type PnpmReference = {
+    readonly name: string;
+    readonly version: string;
+};
+export declare const parsePnpmLockfile: (path: string, content: string, importer: string | undefined) => LockedTree;
+/**
+ * Splits a package key into name and version.
+ *
+ * Three encodings across the versions still in the wild:
+ *   v5  `/@babel/core/7.0.0`
+ *   v6  `/@babel/core@7.0.0`
+ *   v9  `@babel/core@7.0.0`
+ *
+ * plus an optional `(peer@1.0.0)` or `(patch_hash=…)` suffix on any of them.
+ */
+export declare const parsePnpmKey: (key: string) => PnpmReference | null;
+export {};
+//# sourceMappingURL=pnpm.d.ts.map

package/dist/lockfile/pnpm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pnpm.d.ts","sourceRoot":"","sources":["../../src/lockfile/pnpm.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAc,UAAU,EAAE,MAAM,YAAY,CAAA;AAExD,mEAAmE;AACnE,KAAK,aAAa,GAAG;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB,CAAA;AASD,eAAO,MAAM,iBAAiB,SACtB,MAAM,WACH,MAAM,YACL,MAAM,GAAG,SAAS,KAC3B,UA2CF,CAAA;AA6FD;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,QAAS,MAAM,KAAG,aAAa,GAAG,IAc1D,CAAA"}

package/dist/lockfile/tree-builder.d.ts

@@ -0,0 +1,70 @@
+import type { LockfileFormat } from "../enums/lockfile-format.js";
+import type { LockedPackage, LockedRoot, LockedTree } from "./types.js";
+/**
+ * Which manifest block each root kind is declared in.
+ *
+ * The block names are the same across npm, pnpm and bun; only which of them a
+ * given format writes differs, which is why each parser supplies its own order
+ * rather than iterating this.
+ */
+export declare const fieldByRootKind: {
+    readonly prod: "dependencies";
+    readonly optional: "optionalDependencies";
+    readonly dev: "devDependencies";
+    readonly peer: "peerDependencies";
+};
+export declare class TreeBuilder {
+    readonly packages: Map<string, LockedPackage>;
+    readonly roots: Array<LockedRoot>;
+    readonly warnings: Array<string>;
+    readonly incomplete: Array<string>;
+    /** Names dropped on purpose, so an edge into one is explained, not alarming. */
+    private readonly skipped;
+    private readonly seenWarnings;
+    add(pkg: LockedPackage): void;
+    addRoot(root: LockedRoot): void;
+    warn(message: string): void;
+    /** Notes an entry that is real but cannot come from a registry. */
+    skip(name: string, spec: string, reason: string): void;
+    /**
+     * Records a required edge that resolved to nothing.
+     *
+     * An edge into something skipped on purpose is expected — you cannot bundle a
+     * `workspace:` sibling from a registry — so it stays a warning. Anything else
+     * means the file does not pin what it claims to.
+     */
+    dangling(from: string, name: string): void;
+    finish(input: {
+        readonly format: LockfileFormat;
+        readonly lockfileVersion: string;
+        readonly path: string;
+        readonly importer?: string | undefined;
+    }): LockedTree;
+}
+/**
+ * Reads the right-hand side of a locked entry as an exact version.
+ *
+ * Returns the version when it is one, or the reason it is not — `file:../x`,
+ * `workspace:*`, a git URL. `parseDependencyTarget` already classifies every
+ * one of those for package.json parsing, so the vocabulary of skip reasons
+ * stays identical between the two paths.
+ */
+export declare const asExactVersion: (name: string, raw: string) => {
+    readonly _tag: "Version";
+    readonly version: string;
+} | {
+    readonly _tag: "Unsupported";
+    readonly reason: string;
+};
+/**
+ * Raised when a lockfile found by walking up turns out not to cover the
+ * package.json that went looking for it.
+ *
+ * Worth distinguishing from "no lockfile at all": the file exists and is
+ * readable, it simply belongs to a different project, and bundling it would
+ * produce someone else's dependency set.
+ */
+export declare const notCovered: (path: string, importer: string, known: ReadonlyArray<string>) => never;
+/** `""` is how npm and bun spell the project at the lockfile's own level. */
+export declare const importerKey: (importer: string) => string;
+//# sourceMappingURL=tree-builder.d.ts.map

package/dist/lockfile/tree-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-builder.d.ts","sourceRoot":"","sources":["../../src/lockfile/tree-builder.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AAGjE,OAAO,KAAK,EAAc,aAAa,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAEnF;;;;;;GAMG;AACH,eAAO,MAAM,eAAe;mBACH,cAAc;uBACV,sBAAsB;kBAC3B,iBAAiB;mBAChB,kBAAkB;CACQ,CAAA;AAEnD,qBAAa,WAAW;IACtB,QAAQ,CAAC,QAAQ,6BAAmC;IACpD,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,CAAK;IACtC,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,CAAK;IACrC,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC,CAAK;IACvC,gFAAgF;IAChF,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;IAC5C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAoB;IAEjD,GAAG,CAAC,GAAG,EAAE,aAAa,GAAG,IAAI,CAc5B;IAED,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAG9B;IAED,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAI1B;IAED,mEAAmE;IACnE,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAGrD;IAED;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAMzC;IAED,MAAM,CAAC,KAAK,EAAE;QACZ,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAA;QAC/B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;QAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;QACrB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KACvC,GAAG,UAAU,CAcb;CACF;AAaD;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,SACnB,MAAM,OACP,MAAM,KAET;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACtD;IAAE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAO1D,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,SACf,MAAM,YACF,MAAM,SACT,aAAa,CAAC,MAAM,CAAC,KAC3B,KAUF,CAAA;AAED,6EAA6E;AAC7E,eAAO,MAAM,WAAW,aAAc,MAAM,KAAG,MAA4C,CAAA"}

package/dist/lockfile/types.d.ts

@@ -0,0 +1,70 @@
+/**
+ * The one output shape every lockfile parser produces.
+ *
+ * npm, pnpm and bun encode "package X at path P depends on Y" in three
+ * different ways; once flattened into this graph, nothing downstream has to
+ * know which manager wrote the file.
+ */
+import type { EdgeKind, LockedRootKind } from "../enums/edge-kind.js";
+import type { LockfileFormat } from "../enums/lockfile-format.js";
+/** One edge out of a locked package, already pinned to an exact version. */
+export type LockedEdge = {
+    readonly name: string;
+    readonly version: string;
+    readonly kind: EdgeKind;
+};
+/** One package pinned by a lockfile. */
+export type LockedPackage = {
+    readonly name: string;
+    readonly version: string;
+    readonly dependencies: ReadonlyArray<LockedEdge>;
+};
+/** A direct dependency of the locked project. */
+export type LockedRoot = {
+    readonly name: string;
+    readonly version: string;
+    readonly kind: LockedRootKind;
+    /** The range the manifest asked for, kept for reporting. */
+    readonly specifier?: string | undefined;
+};
+/** Options for reading a lockfile. */
+export type LockfileParseOptions = {
+    /**
+     * Which workspace member's dependencies become the roots, as a path relative
+     * to the lockfile in POSIX form — `"packages/core"`, or `"."` for the project
+     * at the lockfile's own level.
+     *
+     * Left undefined, every workspace member in the file contributes, which is
+     * what pointing `--file` straight at a lockfile should mean. It matters when
+     * a package.json found a lockfile by walking *up*: the file then pins the
+     * whole repository, and only one member of it was asked for.
+     */
+    readonly importer?: string | undefined;
+};
+/** A whole lockfile, flattened. */
+export type LockedTree = {
+    readonly format: LockfileFormat;
+    /** As the file declares it: `3`, `'9.0'`, `1`. */
+    readonly lockfileVersion: string;
+    /** Where it was read from, for error messages. */
+    readonly path: string;
+    /** The workspace member the roots came from, when one was selected. */
+    readonly importer?: string | undefined;
+    /** Every pinned package, keyed by `name@version`. */
+    readonly packages: ReadonlyMap<string, LockedPackage>;
+    /** The project's direct dependencies. */
+    readonly roots: ReadonlyArray<LockedRoot>;
+    /** Entries that were recognised but cannot be fetched from a registry. */
+    readonly warnings: ReadonlyArray<string>;
+    /**
+     * Required edges pointing at nothing the file pins.
+     *
+     * Distinct from `warnings`: a `workspace:` dependency that cannot be bundled
+     * is expected and gets a warning, while an ordinary registry dependency with
+     * no entry means the lockfile is genuinely partial and the bundle it produces
+     * would be missing a package. The caller decides what to do about it, but the
+     * two must not be confused.
+     */
+    readonly incomplete: ReadonlyArray<string>;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/lockfile/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lockfile/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AACrE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AAEjE,4EAA4E;AAC5E,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CACxB,CAAA;AAED,wCAAwC;AACxC,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,YAAY,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;CACjD,CAAA;AAED,iDAAiD;AACjD,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAA;IAC7B,4DAA4D;IAC5D,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACxC,CAAA;AAED,sCAAsC;AACtC,MAAM,MAAM,oBAAoB,GAAG;IACjC;;;;;;;;;OASG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACvC,CAAA;AAED,mCAAmC;AACnC,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAA;IAC/B,kDAAkD;IAClD,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;IAChC,kDAAkD;IAClD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,uEAAuE;IACvE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACtC,qDAAqD;IACrD,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IACrD,yCAAyC;IACzC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;IACzC,0EAA0E;IAC1E,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IACxC;;;;;;;;OAQG;IACH,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAC3C,CAAA"}

package/dist/{Manifest.d.ts → manifest.d.ts}

@@ -1,16 +1,8 @@
-/**
- * The manifest written into every bundle.
- *
- * This is the audit trail. Before anything is imported into a corporate
- * registry somebody is usually required to answer "what exactly is in here and
- * where did it come from" — this file answers that without unpacking a single
- * tarball.
- */
-import type { Resolution, ResolvedPackage } from "./Resolve.js";
-import type { BundleOptions } from "./Options.js";
+import type { BundleOptions } from "./options.js";
+import type { Resolution, ResolvedPackage } from "./resolve.js";
 /** Schema version, bumped when the shape changes incompatibly. */
 export declare const MANIFEST_VERSION = 1;
-export interface ManifestEntry {
+export type ManifestEntry = {
     readonly name: string;
     readonly version: string;
     /** Path of this tarball inside the bundle. */
@@ -25,8 +17,8 @@ export interface ManifestEntry {
     readonly bytes?: number | undefined;
     /** Human-readable justifications: `root:react@18.2.0`, `prod:scheduler@0.23.0`. */
     readonly reasons: ReadonlyArray<string>;
-}
-export interface BundleManifest {
+};
+export type BundleManifest = {
     readonly manifestVersion: number;
     readonly tool: {
         readonly name: string;
@@ -60,7 +52,7 @@ export interface BundleManifest {
         readonly packages: number;
         readonly bytes: number;
     };
-}
+};
 /** Renders a package's reasons into short, greppable strings. */
 export declare const formatReasons: (pkg: ResolvedPackage) => ReadonlyArray<string>;
 /** Builds the manifest for a completed (or dry) run. */
@@ -79,4 +71,4 @@ export declare const buildManifest: (input: {
 }) => BundleManifest;
 /** Serialises a manifest with stable key order and a trailing newline. */
 export declare const serializeManifest: (manifest: BundleManifest) => string;
-//# sourceMappingURL=Manifest.d.ts.map
+//# sourceMappingURL=manifest.d.ts.map

package/dist/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../src/manifest.ts"],"names":[],"mappings":"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"}

package/dist/{Options.d.ts → options.d.ts}

@@ -5,28 +5,10 @@
  * actually installs offline on a machine that is not the one you built it on.
  * Every switch that makes the bundle smaller is opt-in.
  */
-import type { PlatformFilter } from "./Platform.js";
-/** How the resulting tarball(s) are shaped. */
-export type Layout = 
-/**
- * One tarball per requested spec, each carrying its own complete dependency
- * closure. Shared dependencies repeat across tarballs, so the total is
- * larger — but each one imports, rolls back and hands off independently.
- */
-"per-spec"
-/**
- * One tarball for everything, with the union of all closures deduplicated.
- * Smallest output and a single import step; all-or-nothing to roll back.
- */
- | "single"
-/**
- * No archive at all — just the npm-layout directory tree, ready for
- * `jf rt upload` or rsync.
- */
- | "dir";
-export declare const layouts: ReadonlyArray<Layout>;
+import { Layout } from "./enums/layout.js";
+import type { PlatformFilter } from "./platform.js";
 /** Which dependency edges the resolver follows. */
-export interface DependencyScope {
+export type DependencyScope = {
     /**
      * Follow `optionalDependencies`. On by default — this is where per-platform
      * native binaries live, and omitting them is the most common reason an
@@ -40,10 +22,10 @@ export interface DependencyScope {
     readonly peer: boolean;
     /** Which platforms optional dependencies are kept for. */
     readonly platforms: PlatformFilter;
-}
+};
 export declare const defaultScope: DependencyScope;
 /** Options governing version selection and the dependency walk. */
-export interface ResolveOptions {
+export type ResolveOptions = {
     readonly scope: DependencyScope;
     /**
      * When a root spec is a range, take *every* published version that satisfies
@@ -59,10 +41,10 @@ export interface ResolveOptions {
     readonly includePrerelease: boolean;
     /** How many registry requests to have in flight at once. */
     readonly concurrency: number;
-}
+};
 export declare const defaultResolveOptions: ResolveOptions;
 /** Options for a full bundle run. */
-export interface BundleOptions extends ResolveOptions {
+export type BundleOptions = ResolveOptions & {
     readonly layout: Layout;
     /** Directory the finished artifacts are written to. */
     readonly outDir: string;
@@ -95,6 +77,6 @@ export interface BundleOptions extends ResolveOptions {
      * still ask about anything else".
      */
     readonly overwrite?: ReadonlySet<string> | undefined;
-}
+};
 export declare const defaultBundleOptions: Omit<BundleOptions, "outDir">;
-//# sourceMappingURL=Options.d.ts.map
+//# sourceMappingURL=options.d.ts.map

package/dist/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../src/options.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAC1C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAGnD,mDAAmD;AACnD,MAAM,MAAM,eAAe,GAAG;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,0DAA0D;IAC1D,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAA;CACnC,CAAA;AAED,eAAO,MAAM,YAAY,EAAE,eAI1B,CAAA;AAED,mEAAmE;AACnE,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAA;IAC/B;;;;;;OAMG;IACH,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAA;IAC7B,iEAAiE;IACjE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACzC,yEAAyE;IACzE,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAA;IACnC,4DAA4D;IAC5D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAC7B,CAAA;AAED,eAAO,MAAM,qBAAqB,EAAE,cAKnC,CAAA;AAED,qCAAqC;AACrC,MAAM,MAAM,aAAa,GAAG,cAAc,GAAG;IAC3C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,uDAAuD;IACvD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,0EAA0E;IAC1E,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACzC,kEAAkE;IAClE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;IACxB;;;;;OAKG;IACH,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAA;IACjC,gEAAgE;IAChE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB;;;;;;;OAOG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,CAAA;IACvD;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,CAAA;CACrD,CAAA;AAED,eAAO,MAAM,oBAAoB,EAAE,IAAI,CAAC,aAAa,EAAE,QAAQ,CAM9D,CAAA"}