@jterrazz/test 16.1.1 → 18.0.0

package/dist/shared-in-place.js

@@ -0,0 +1,172 @@
+import { i as safeRealpath } from "./shared-resolve.js";
+import { t as isRecord } from "./shared-json-shape.js";
+import { n as refusal } from "./shared-refusal.js";
+import { r as closingOf, t as argumentSpans } from "./shared-source-scan.js";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+//#region src/chain/paths/caller.ts
+const TEST_FILE = /\.test\.[cm]?[jt]s$/u;
+const FRAME_LOCATION = /^at (?:.*? \((?<wrapped>[^()]+)\)|(?:async )?(?<bare>[^()\s]+))$/u;
+const POSITION = /^(?<file>.+):(?<line>\d+):(?<column>\d+)$/u;
+function stackFrames(stack) {
+	const frames = [];
+	for (const text of stack.split("\n")) {
+		const groups = FRAME_LOCATION.exec(text.trim())?.groups;
+		const position = POSITION.exec(groups?.wrapped ?? groups?.bare ?? "")?.groups;
+		if (position?.file === void 0 || position.file.startsWith("node:")) continue;
+		const file = position.file.startsWith("file:") ? fileURLToPath(position.file) : position.file;
+		frames.push({
+			column: Number(position.column),
+			file,
+			line: Number(position.line)
+		});
+	}
+	return frames;
+}
+function callerFrames() {
+	const { stack } = /* @__PURE__ */ new Error("@jterrazz/test: reading the call site");
+	return stackFrames(stack ?? "").filter(({ file }) => file !== import.meta.filename);
+}
+const SOURCE_LOCATION = join("chain", "paths");
+const FRAMEWORK_DIR = safeRealpath(import.meta.dirname);
+/** From a build, `dist/` plus the `src/` its source maps point back to: a mapped frame is still the framework's. */
+function frameworkTreesOf(frameworkDir) {
+	return frameworkDir.endsWith(`${sep}${SOURCE_LOCATION}`) ? [resolve(frameworkDir, "../..")] : [frameworkDir, resolve(frameworkDir, "..", "src")];
+}
+const FRAMEWORK_TREES = frameworkTreesOf(FRAMEWORK_DIR);
+function isStrictlyInside(directory, path) {
+	const rest = relative(directory, path);
+	return rest !== "" && !rest.startsWith("..") && !isAbsolute(rest);
+}
+/** By identity, never by substring: a consumer's own `src/chain/` is not this package's. */
+function isFrameworkFrame(filePath, frameworkTrees = FRAMEWORK_TREES) {
+	if (TEST_FILE.test(filePath)) return false;
+	const real = safeRealpath(filePath);
+	return frameworkTrees.some((tree) => isStrictlyInside(safeRealpath(tree), real));
+}
+/** Must be called before the first `await`: async resumption drops the caller's frames. */
+function getCallerDir() {
+	const caller = callerFrames().find(({ file }) => !file.includes("node_modules") && !isFrameworkFrame(file));
+	return caller === void 0 ? process.cwd() : dirname(caller.file);
+}
+//#endregion
+//#region src/expectations/in-place/formatter.ts
+const FORMATTER = join("node_modules", ".bin", "oxfmt");
+function formatterOf(file) {
+	for (let directory = dirname(file);; directory = dirname(directory)) {
+		const binary = join(directory, FORMATTER);
+		if (existsSync(binary)) return binary;
+		if (dirname(directory) === directory) return;
+	}
+}
+function formatRewritten(files) {
+	for (const file of files) {
+		const binary = formatterOf(file);
+		if (binary !== void 0) {
+			const project = dirname(dirname(dirname(binary)));
+			spawnSync(binary, [file], {
+				cwd: project,
+				stdio: "ignore"
+			});
+		}
+	}
+}
+//#endregion
+//#region src/expectations/in-place/in-place.ts
+const TO_MATCH = /\btoMatch\s*\(/gu;
+const LITERAL = /^(?:['"`{[]|-?\d|(?:null|true|false|undefined)$)/u;
+function callSiteOf(stack) {
+	return stackFrames(stack).find(({ file }) => !file.includes(`${sep}node_modules${sep}`) && !isFrameworkFrame(file));
+}
+function lineStartOf(source, line) {
+	let offset = 0;
+	for (let current = 1; current < line; current += 1) offset = source.indexOf("\n", offset) + 1;
+	return offset;
+}
+/** The call a frame points at, by its name or its parenthesis, among the calls of its line; its value's span, trimmed. */
+function locateArgument(source, site) {
+	const lineStart = lineStartOf(source, site.line);
+	const position = lineStart + site.column - 1;
+	TO_MATCH.lastIndex = lineStart;
+	for (const found of source.matchAll(TO_MATCH)) {
+		if (found.index + 7 < position) continue;
+		const open = found.index + found[0].length - 1;
+		const [span = {
+			end: open + 1,
+			start: open + 1
+		}] = argumentSpans(source, open + 1, closingOf(source, open));
+		const line = source.slice(source.lastIndexOf("\n", found.index) + 1);
+		return {
+			...span,
+			indent: line.slice(0, line.length - line.trimStart().length)
+		};
+	}
+}
+const LEDGERS = /* @__PURE__ */ new Map();
+const isPending = (value) => isRecord(value) && typeof value.file === "string" && typeof value.source === "string";
+let pendingFolder = null;
+/** Read at each write: the folder is the project's, and one worker may serve several. */
+function deferRewritesTo(folder) {
+	pendingFolder = folder;
+}
+function save(file, source, folder) {
+	if (folder === void 0) {
+		writeFileSync(file, source);
+		return;
+	}
+	mkdirSync(folder, { recursive: true });
+	const name = createHash("sha256").update(file).digest("hex");
+	const pending = {
+		file,
+		source
+	};
+	writeFileSync(join(folder, `${name}.json`), JSON.stringify(pending));
+}
+function writePendingRewrites(folder) {
+	if (!existsSync(folder)) return;
+	const written = [];
+	for (const name of readdirSync(folder).filter((entry) => entry.endsWith(".json"))) {
+		const pending = JSON.parse(readFileSync(join(folder, name), "utf8"));
+		if (isPending(pending)) {
+			writeFileSync(pending.file, pending.source);
+			written.push(pending.file);
+		}
+	}
+	rmSync(folder, { recursive: true });
+	formatRewritten(written);
+}
+function writeInPlace(site, render, folder = pendingFolder?.()) {
+	const ledger = LEDGERS.get(site.file) ?? {
+		edits: /* @__PURE__ */ new Map(),
+		original: readFileSync(site.file, "utf8")
+	};
+	LEDGERS.set(site.file, ledger);
+	const span = locateArgument(ledger.original, site);
+	if (span === void 0) throw new Error(refusal({
+		fix: "call `.toMatch(` on the expect() written at that line, not through an alias",
+		found: `update mode: no toMatch( stands at ${site.file}:${site.line}:${site.column}, so the value in place cannot be written`,
+		read: "docs/reference/tokens.md#a-value-written-in-place-is-rewritten-in-the-test",
+		why: "A value written in place is rewritten where its `toMatch(` stands."
+	}));
+	const written = ledger.original.slice(span.start, span.end);
+	if (written !== "" && !LITERAL.test(written)) throw new Error(refusal({
+		fix: "write the expectation as a literal in `toMatch(`, or record it by hand: a table's rows are recorded one by one, never from the last row",
+		found: `update mode: toMatch(${written}) at ${site.file}:${site.line}:${site.column} holds a name or a call, not a literal`,
+		read: "docs/reference/tokens.md#a-value-written-in-place-is-rewritten-in-the-test",
+		why: "Update mode rewrites the literal a `toMatch(` holds; a variable stands for values the rewrite would replace by the last one it saw."
+	}));
+	ledger.edits.set(span.start, {
+		end: span.end,
+		text: render(span.indent)
+	});
+	let source = ledger.original;
+	for (const [start, edit] of [...ledger.edits].toSorted(([a], [b]) => b - a)) source = source.slice(0, start) + edit.text + source.slice(edit.end);
+	save(site.file, source, folder);
+}
+//#endregion
+export { getCallerDir as a, writePendingRewrites as i, deferRewritesTo as n, writeInPlace as r, callSiteOf as t };
+
+//# sourceMappingURL=shared-in-place.js.map

package/dist/shared-index.services.d.ts

@@ -0,0 +1,346 @@
+import { t as ContainerOptions } from "./shared-container.port.js";
+//#region src/chain/config.d.ts
+type ChainConfig = {
+  root?: string | undefined;
+};
+//#endregion
+//#region src/chain/context/with.capability.d.ts
+/** Merged over `process.env`; a `null` value unsets the variable. */
+type EnvRecord = Record<string, null | string>;
+/** What a file shares on every chain it starts: settings, never state. */
+type ChainContext = {
+  /** The instant every chain pins; a chain's own `.clock()` wins. */
+  clock?: string;
+  /** The environment every command runs with; a chain's own `.env()` merges over it. */
+  env?: EnvRecord;
+  /** The headers every request carries; a chain's own `.headers()` merges over them. */
+  headers?: Record<string, string>;
+};
+//#endregion
+//#region src/chain/capability.d.ts
+type MatrixGroup = 'Constructor option' | 'Result accessor' | 'Route option' | 'Setup' | 'Target' | 'Terminal action' | 'Verb';
+/** `probe` is a call in `lint/self/corpus/matrix-calls.ts`'s grammar, or a literal. */
+type MatrixRow = {
+  readonly group: MatrixGroup;
+  readonly member?: string;
+  readonly name: string;
+  readonly probe: string;
+};
+type ContextKey = keyof ChainContext;
+type Intersect<Union> = (Union extends unknown ? (member: Union) => void : never) extends ((all: infer All) => void) ? All : never;
+type SpecificationParams = {
+  readonly databaseKey: string;
+  readonly services: Record<string, unknown>;
+};
+/** Each definition extends this, naming its methods over `this['self']` and `this['params']`; `ChainOf` fills both in. */
+interface ChainSignature {
+  readonly chain: object;
+  readonly params: SpecificationParams;
+  readonly self: unknown;
+}
+type Armed = {
+  /** Released in reverse arm order; an adapter may defer it to the test's end. */
+  readonly release?: () => void;
+  /** Preferred over the action's own error. */
+  readonly violation?: () => Error | null;
+};
+type Run<Config extends ChainConfig = ChainConfig> = {
+  readonly config: Config;
+  readonly testDir: string;
+  readonly workDir: null | string;
+};
+type SetupContext<Needs, Config extends ChainConfig = ChainConfig> = {
+  readonly config: Config;
+  readonly adapters: Needs;
+};
+type Capability<Name extends string, Slice, Args extends readonly unknown[], Signature extends ChainSignature = ChainSignature, Needs extends object = Record<never, never>, Context extends ContextKey = never, Config extends ChainConfig = ChainConfig> = {
+  readonly context?: Context;
+  readonly initial: Slice;
+  readonly kind: 'setup';
+  readonly name: Name;
+  /** Arm order across the setups of a chain: a lower phase arms first, and each setup states its own. */
+  readonly phase: number;
+  readonly row: MatrixRow;
+  /** A type alone, never set at runtime: `ChainOf` reads it. */
+  readonly signature?: Signature;
+  /** Absent when the action reads the slice instead. */
+  arm?(slice: Slice, adapters: Needs, run: Run<Config>): Armed | Promise<Armed | undefined> | undefined;
+  reduce(slice: Slice, args: Args, setup: SetupContext<Needs, Config>): Slice;
+};
+type AnyCapability = Capability<string, unknown, readonly unknown[], ChainSignature, object, ContextKey>;
+type ActionOption<Name extends string> = {
+  readonly kind: 'option';
+  readonly name: Name;
+  readonly row: MatrixRow;
+};
+type Sharing = {
+  readonly kind: 'context';
+  readonly name: 'with';
+  readonly row: MatrixRow;
+};
+//#endregion
+//#region src/services/database.port.d.ts
+/** Database port for specification runners; implement it to plug in your stack. */
+type DatabasePort = {
+  /** Execute raw SQL (for seeding test data). */
+  seed: (sql: string) => Promise<void>;
+  /** Query a table and return rows as arrays of values. */
+  query: (table: string, columns: string[]) => Promise<unknown[][]>;
+  /** The table's columns, in the order the table declares them: what a whole-table comparison reads. */
+  columns: (table: string) => Promise<string[]>;
+  /** Reset database to clean state between tests. */
+  reset: () => Promise<void>;
+};
+//#endregion
+//#region src/services/isolation.port.d.ts
+/** Isolates service state across parallel workers: `acquire()` per worker, `reset()` per run, `release()` at shutdown. */
+type IsolationStrategy = {
+  /** Create this worker's isolated namespace, once at worker start. */
+  acquire: (workerId: string) => Promise<void>;
+  /** Fast reset within the namespace between runs. */
+  reset: () => Promise<void>;
+  /** Tear down the namespace, once at worker shutdown. */
+  release: () => Promise<void>;
+};
+//#endregion
+//#region src/services/service.port.d.ts
+/** A service handle, as `postgres()` or `redis()` return it; `connectionString` fills in once started. */
+type ServiceHandle = {
+  readonly type: string;
+  /** The kebab-case record key, assigned at start: `{ analyticsDb: postgres() }` reads `docker/analytics-db/`. */
+  serviceName: null | string;
+  /** Default container port for this service type. */
+  readonly defaultPort: number;
+  /** Default Docker image for this service type. */
+  readonly defaultImage: string;
+  /** Environment variables to pass to the container. */
+  readonly environment: Record<string, string>;
+  /** How the container runs beyond its image, port and environment; none when absent. */
+  readonly containerOptions?: ContainerOptions;
+  /** Connection string, populated after start. */
+  connectionString: string;
+  /** Build the connection string from host and port. */
+  buildConnectionString: (host: string, port: number) => string;
+  /** Create a DatabasePort adapter (if this is a database). Returns null otherwise. */
+  createDatabaseAdapter: () => DatabasePort | null;
+  /** Verify the service is ready and accepting connections. Throws with context if not. */
+  healthcheck: () => Promise<void>;
+  /** Run the init scripts from `<root>/docker/<name>/`; a cache goes under `<root>/.artifacts/`, never a machine-global directory. */
+  initialize: (dockerDir: string, root: string) => Promise<void>;
+  /** Reset state between tests (truncate tables, flush cache, etc.) */
+  reset: () => Promise<void>;
+  isolation: () => IsolationStrategy;
+};
+//#endregion
+//#region src/services/services.d.ts
+/** Services declared as a named record: the keys are the spec's database vocabulary. */
+type ServiceRecord = Record<string, ServiceHandle>;
+/** Keys of a services record whose handles are databases. */
+type DatabaseKeys<Services extends ServiceRecord> = { [K in keyof Services]: Services[K] extends DatabasePort ? K & string : never; }[keyof Services];
+type ServicesConfig = ChainConfig & {
+  database?: DatabasePort | undefined;
+  /** Drives `database-named-only-when-several-at-runtime`: with 2+ databases `database` is required on `.seed()` / `.table()`, with one it is refused. */
+  databaseKeys?: string[] | undefined;
+  databases?: Map<string, DatabasePort> | undefined;
+  /** In cli mode, drives the `<KEY>_URL` injection (`service-urls-injected`), plus `DATABASE_URL` / `REDIS_URL` when unambiguous. */
+  services?: Record<string, ServiceHandle> | undefined;
+};
+//#endregion
+//#region src/disk/spec-path.d.ts
+/** A path relative to the spec file; `Extension` narrows its tail. */
+type RelativePath<Extension extends string = string> = `../${string}${Extension}` | `./${string}${Extension}`;
+declare const DISK: unique symbol;
+/** A file the spec names, at `Path`. */
+type FileAt<Path extends string> = {
+  readonly [DISK]: 'file';
+  readonly path: Path;
+};
+/** A file whose path ends in `Extension`: what a verb that reads one file accepts. */
+type DiskFile<Extension extends string = string> = FileAt<RelativePath<Extension>>;
+/** A directory the spec names; its path ends in `/`. */
+type DiskDirectory = {
+  readonly [DISK]: 'directory';
+  readonly path: RelativePath<'/'>;
+};
+/** Either of the two: what a verb that takes a file or a directory accepts. */
+type DiskTarget = DiskDirectory | DiskFile;
+/** Name one file, by its path from the spec file. */
+declare function file<const Path extends RelativePath>(path: Path extends `${string}/` ? never : Path): FileAt<Path>;
+/** Name one directory, by its path from the spec file, ending in `/`. */
+declare function directory<const Path extends RelativePath<'/'>>(path: Path): DiskDirectory & {
+  readonly path: Path;
+};
+//#endregion
+//#region src/services/postgres/postgres.adapter.d.ts
+type PostgresOptions = {
+  /** Override image. */
+  image?: string;
+  /** Override environment variables. */
+  env?: Record<string, string>;
+};
+declare class PostgresHandle implements DatabasePort, ServiceHandle {
+  readonly type = "postgres";
+  serviceName: null | string;
+  readonly defaultPort = 5432;
+  readonly defaultImage: string;
+  readonly environment: Record<string, string>;
+  readonly containerOptions: ContainerOptions;
+  connectionString: string;
+  private client;
+  private template;
+  private clone;
+  constructor(options?: PostgresOptions);
+  buildConnectionString(host: string, port: number): string;
+  createDatabaseAdapter(): DatabasePort;
+  healthcheck(): Promise<void>;
+  initialize(dockerDir: string): Promise<void>;
+  private getClient;
+  seed(sql: string): Promise<void>;
+  reset(): Promise<void>;
+  query(table: string, columns: string[]): Promise<unknown[][]>;
+  columns(table: string): Promise<string[]>;
+  isolation(): IsolationStrategy;
+  private closeClient;
+}
+/** Create a PostgreSQL service handle; its record key names the init script folder (`docker/<key>/init.sql`). */
+declare function postgres(options?: PostgresOptions): PostgresHandle;
+//#endregion
+//#region src/services/redis/redis.adapter.d.ts
+type RedisOptions = {
+  /** Override image. */
+  image?: string;
+};
+declare class RedisHandle implements ServiceHandle {
+  readonly type = "redis";
+  serviceName: null | string;
+  readonly defaultPort = 6379;
+  readonly defaultImage: string;
+  readonly environment: Record<string, string>;
+  readonly containerOptions: ContainerOptions;
+  connectionString: string;
+  private dbIndex;
+  /** What this handle holds: its slot's release, and the container's own string it extended. */
+  private pair;
+  constructor(options?: RedisOptions);
+  buildConnectionString(host: string, port: number): string;
+  createDatabaseAdapter(): DatabasePort | null;
+  healthcheck(): Promise<void>;
+  initialize(): Promise<void>;
+  reset(): Promise<void>;
+  isolation(): IsolationStrategy;
+  private letGo;
+}
+/** Create a Redis service handle, reported under its record key. */
+declare function redis(options?: RedisOptions): RedisHandle;
+//#endregion
+//#region src/services/sqlite/sqlite-template.d.ts
+type SqliteOptions = {
+  /** Path to a SQL file initializing the schema; exclusive with `prismaSchema`. */
+  init?: string;
+  /** Path to a Prisma schema, resolved against the cwd and handed to `prisma db push --schema`; exclusive with `init`. */
+  prismaSchema?: string;
+};
+//#endregion
+//#region src/services/sqlite/sqlite.adapter.d.ts
+declare class SqliteHandle implements DatabasePort, ServiceHandle {
+  readonly type = "sqlite";
+  serviceName: null | string;
+  readonly defaultPort = 0;
+  readonly defaultImage = "";
+  readonly environment: Record<string, string>;
+  connectionString: string;
+  private db;
+  private templatePath;
+  private workerDbPath;
+  private readonly initSql;
+  private readonly prismaSchema;
+  private readonly options;
+  constructor(options?: SqliteOptions);
+  buildConnectionString(): string;
+  createDatabaseAdapter(): DatabasePort;
+  healthcheck(): Promise<void>;
+  /** One worker builds under an exclusive lock, the others wait: two concurrent `prisma db push` on one file is `database is locked`. */
+  initialize(_dockerDir?: string, root?: string): Promise<void>;
+  /** Built on a private path, then renamed into place: `prisma db push` writes the header long before the tables exist. */
+  private buildTemplate;
+  private writeTemplate;
+  private getDb;
+  private closeDb;
+  seed(sql: string): Promise<void>;
+  query(table: string, columns: string[]): Promise<unknown[][]>;
+  columns(table: string): Promise<string[]>;
+  reset(): Promise<void>;
+  isolation(): IsolationStrategy;
+}
+/** Create a SQLite service handle, isolated per test by file copy. */
+declare function sqlite(options?: SqliteOptions): SqliteHandle;
+//#endregion
+//#region src/services/process/process.adapter.d.ts
+/** The one shape an external process takes: `website({ server })`, `services: { api: process(...) }`, `serve:`. */
+type ProcessOptions = {
+  /** A one-shot command run once per specification before the spawn, which must exit 0. */
+  before?: string;
+  /** Shell command that starts the process. Receives the chosen port as `PORT`. */
+  command: string;
+  /** Working directory, relative to the project root. Default: the root itself. A function is called when the process starts, once per file: a spec that lays a fresh project for each file returns the path it laid. */
+  cwd?: (() => string) | string;
+  /** Environment on top of the runner's; a function receives the services already started. */
+  env?: ((services: Record<string, {
+    connectionString: string;
+  }>) => Record<string, string>) | Record<string, string>;
+  /** Fixed port. Default: an OS-assigned free port, injected as `PORT`. */
+  port?: number;
+  /** Readiness: a path polled until any HTTP status answers (`PORT` injected), or a regex over the output whose one group captures the port. */
+  ready?: RegExp | string;
+  /** Readiness budget in milliseconds. Default 30 000. */
+  timeout?: number;
+};
+declare class ProcessHandle implements ServiceHandle {
+  /** Embedded: nothing to pull, nothing to run in a container. */
+  readonly defaultImage = "";
+  readonly defaultPort = 0;
+  readonly environment: Record<string, string>;
+  readonly type = "process";
+  serviceName: null | string;
+  connectionString: string;
+  started: boolean;
+  private served;
+  private readonly options;
+  constructor(options: ProcessOptions);
+  buildConnectionString(host: string, port: number): string;
+  createDatabaseAdapter(): DatabasePort | null;
+  healthcheck(): Promise<void>;
+  initialize(): Promise<void>;
+  /** Isolation is the run's: one child per evaluation of the specification module, told apart by the minted id. */
+  isolation(): IsolationStrategy;
+  reset(): Promise<void>;
+  /** Spawn it and wait until it answers; `services` is every sibling, already started. */
+  spawnWith(root: string, services: Record<string, {
+    connectionString: string;
+  }>, runId: string): Promise<void>;
+  /** Terminate the process group. Idempotent. */
+  shutdown(): Promise<void>;
+  /** What it was declared as: what a specification reads to start it in a slot of its own. */
+  get spec(): ProcessOptions;
+  /** The base URL it came up on, known only once it is started. */
+  get url(): string;
+}
+/** Declare an external process the framework owns for the life of the specification. */
+declare function processService(options: ProcessOptions): ProcessHandle;
+//#endregion
+//#region src/services/seed/seed.capability.d.ts
+/** What `.seed()` takes: a `.sql` file, never the statements themselves: SQL is not written in a test. */
+type SeedSource = DiskFile<'.sql'>;
+type SeedMethod<Self, DatabaseKey extends string> = (source: SeedSource, options?: {
+  database?: DatabaseKey;
+}) => Self;
+type SeedChain<Self, DatabaseKey extends string> = {
+  /** Queue a SQL seed (`file('./__seeds__/<name>.sql')`) to run before the action. */
+  seed: SeedMethod<Self, DatabaseKey>;
+};
+interface SeedSignature extends ChainSignature {
+  readonly chain: SeedChain<this['self'], this['params']['databaseKey']>;
+}
+//#endregion
+export { Intersect as A, IsolationStrategy as C, Armed as D, AnyCapability as E, ChainContext as F, EnvRecord as I, ChainConfig as L, Run as M, Sharing as N, Capability as O, SpecificationParams as P, ServiceHandle as S, ActionOption as T, directory as _, processService as a, ServiceRecord as b, RedisOptions as c, postgres as d, DiskDirectory as f, RelativePath as g, FileAt as h, ProcessOptions as i, MatrixRow as j, ChainSignature as k, redis as l, DiskTarget as m, SeedSource as n, sqlite as o, DiskFile as p, ProcessHandle as r, SqliteOptions as s, SeedSignature as t, PostgresOptions as u, file as v, DatabasePort as w, ServicesConfig as x, DatabaseKeys as y };
+//# sourceMappingURL=shared-index.services.d.ts.map