@animus-ui/next-plugin 0.1.11 → 0.1.12

package/dist/index.cjs

@@ -1,19 +1,12 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("./turbopack-loader.cjs");
 let _animus_ui_extract_pipeline = require("@animus-ui/extract/pipeline");
 let _animus_ui_extract_session = require("@animus-ui/extract/session");
 let fs = require("fs");
 let path = require("path");
 let url = require("url");
 //#region src/loader-path.ts
-const __dirname$2 = (0, path.dirname)((0, url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
-/**
-* The one loader-path derivation: first existing dist candidate under the
-* plugin dir, else the in-repo source fallback. Both loader resolvers below
-* are thin wrappers, so rule registration and any loader-chain predicate
-* can never drift (openspec: next-webpack-served-transform-coherence,
-* design D1).
-*/
+const __filename$2 = (0, url.fileURLToPath)(require("url").pathToFileURL(__filename).href);
+const __dirname$2 = (0, path.dirname)(__filename$2);
 function resolveLoaderPath(pluginDir, distCandidates, sourceFallback) {
 	for (const candidate of distCandidates) {
 		const distPath = (0, path.resolve)(pluginDir, candidate);
@@ -21,69 +14,38 @@ function resolveLoaderPath(pluginDir, distCandidates, sourceFallback) {
 	}
 	return (0, path.resolve)(pluginDir, sourceFallback);
 }
-/**
-* This package's webpack loader path, shared by the rule registration
-* (with-animus) and the needBuild loader-chain predicate (plugin). Compiled
-* dist ships `loader.mjs` next to this module; running from source falls
-* back to the TypeScript loader.
-*/
 function resolveAnimusLoaderPath() {
 	return resolveLoaderPath(__dirname$2, ["loader.mjs"], "loader.ts");
 }
 //#endregion
 //#region src/plugin.ts
-/** Loud unsupported-version failure (design D7): the coherence mechanism
-*  cannot exist without the per-compilation needBuild hook, so a webpack
-*  that lacks it fails immediately instead of serving stale transforms. */
-const UNSUPPORTED_WEBPACK_MESSAGE = "[animus-extract] Unsupported webpack: NormalModule.getCompilationHooks(compilation).needBuild is required for dev transform coherence and this webpack does not expose it. Use a Next.js version covered by the animus webpack gauntlet.";
+/** The value arrives from a consumer's `next.config`, so the union above is a
+*  model of what webpack accepts, not a proof about the value in hand. */
+const isWatchIgnoreString = (ignored) => Object.prototype.toString.call(ignored) === "[object String]";
+const isWatchIgnoreMatcher = (ignored) => Object.prototype.toString.call(ignored) === "[object Function]";
+const UNSUPPORTED_WEBPACK_MESSAGE = "[animus-extract] Unsupported webpack: NormalModule.getCompilationHooks(compilation).needBuild is required for dev transform coherence and this webpack does not expose it. Use a Next.js version whose webpack exposes this hook.";
 const PLUGIN_NAME = "AnimusWebpackPlugin";
-/**
-* Webpack adapter for the extraction pipeline. All pipeline logic lives in
-* the bundler-agnostic ExtractionSession — this class owns only the webpack
-* wiring: hook registration, cross-compiler analysis dedup, alias
-* harvesting from the compiler config, watch-event translation, and
-* in-memory CSS asset replacement.
-*/
 var AnimusWebpackPlugin = class {
 	options;
 	session;
 	initialized = false;
 	aliasesExtracted = false;
-	/** Loader paths counting as "the animus loader" in a module's chain —
-	*  this package's own loader plus an optional harness override. */
 	animusLoaderPaths;
-	/** Epoch THIS compiler last proceeded with (set after every awaited
-	*  watchRun transaction — including joined ones). Null until the
-	*  initialization pipeline publishes. */
 	lastBuiltEpoch = null;
-	/** Armed by watchRun when the transaction moved the epoch; captured and
-	*  disarmed by the next compilation's needBuild wiring (design D1). */
 	epochMovedForNextCompilation = false;
 	constructor(options) {
 		this.options = options;
 		(0, _animus_ui_extract_pipeline.assertNoRetiredEngineSelection)(options.engine);
 		(0, _animus_ui_extract_session.setSharedEngine)(options.engine ?? "v2");
 		this.session = new _animus_ui_extract_session.ExtractionSession(options);
-		this.animusLoaderPaths = new Set([resolveAnimusLoaderPath()]);
+		this.animusLoaderPaths = /* @__PURE__ */ new Set([resolveAnimusLoaderPath()]);
 		if (options.loaderPath) this.animusLoaderPaths.add(options.loaderPath);
 	}
-	/** True when the module's loader chain contains the animus loader — the
-	*  needBuild fan-out predicate (design D1: no historical records; covers
-	*  restored persistent-cache modules and raw passthroughs alike). */
 	moduleUsesAnimusLoader(module) {
 		const loaders = module?.loaders;
 		if (!Array.isArray(loaders)) return false;
-		return loaders.some((entry) => typeof entry?.loader === "string" && this.animusLoaderPaths.has(entry.loader));
+		return loaders.some((entry) => entry?.loader !== void 0 && this.animusLoaderPaths.has(entry.loader));
 	}
-	/** Append the exact epoch artifact path to `watchOptions.ignored`,
-	*  preserving the user's shape (design D2: the artifact participates in
-	*  module snapshots via addDependency but never triggers live watch
-	*  turns — no echo compilations). Session identity is process-claimed,
-	*  so every compiler's plugin instance derives the SAME session-scoped
-	*  path here regardless of which instance ends up owning the pipeline.
-	*  Derived from the ONE root (session.rootDir, set at config time by
-	*  with-animus); compiler.context is the fallback for bare-apply
-	*  harnesses — identical when compiler.context === cwd. */
 	appendEpochWatchIgnore(compiler) {
 		const options = compiler.options;
 		if (!options) return;
@@ -94,25 +56,22 @@ var AnimusWebpackPlugin = class {
 		if (ignored === void 0 || ignored === null) watchOptions.ignored = [epochPath];
 		else if (Array.isArray(ignored)) {
 			if (!ignored.includes(epochPath)) ignored.push(epochPath);
-		} else if (typeof ignored === "string") watchOptions.ignored = [ignored, epochPath];
+		} else if (isWatchIgnoreString(ignored)) watchOptions.ignored = [ignored, epochPath];
 		else if (ignored instanceof RegExp) watchOptions.ignored = (path) => path === epochPath || ignored.test(path);
-		else if (typeof ignored === "function") {
-			const original = ignored;
-			watchOptions.ignored = (path) => path === epochPath || Boolean(original(path));
-		}
+		else if (isWatchIgnoreMatcher(ignored)) watchOptions.ignored = (path) => path === epochPath || Boolean(ignored(path));
 	}
-	/** Extract path aliases from webpack's resolve.alias config. Runs once per
-	*  plugin instance — the resolve config is immutable after apply. */
 	extractAliases(compiler) {
 		if (this.aliasesExtracted) return;
 		this.aliasesExtracted = true;
 		const rootDir = compiler.context;
 		const rawAlias = compiler.options?.resolve?.alias;
-		if (!rawAlias || typeof rawAlias !== "object") return;
+		if (rawAlias === void 0) return;
+		if (Object.prototype.toString.call(rawAlias) !== "[object Object]") return;
 		const pairs = [];
 		for (const [key, value] of Object.entries(rawAlias)) {
-			const target = Array.isArray(value) ? value[0] : value;
-			if (typeof target !== "string") continue;
+			if (value === false) continue;
+			const target = Array.isArray(value) ? value.at(0) : value;
+			if (target === void 0) continue;
 			if (key === _animus_ui_extract_session.ANIMUS_CSS_MODULE_ID) continue;
 			pairs.push({
 				pattern: key,
@@ -125,13 +84,13 @@ var AnimusWebpackPlugin = class {
 	apply(compiler) {
 		if (compiler.options?.name === "edge-server") return;
 		const NormalModule = compiler.webpack?.NormalModule;
-		if (typeof NormalModule?.getCompilationHooks !== "function") throw new Error(UNSUPPORTED_WEBPACK_MESSAGE);
+		if (NormalModule?.getCompilationHooks === void 0) throw new Error(UNSUPPORTED_WEBPACK_MESSAGE);
 		this.appendEpochWatchIgnore(compiler);
 		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			const epochMoved = this.epochMovedForNextCompilation;
 			this.epochMovedForNextCompilation = false;
 			const needBuild = NormalModule.getCompilationHooks(compilation).needBuild;
-			if (typeof needBuild?.tapAsync !== "function") throw new Error(UNSUPPORTED_WEBPACK_MESSAGE);
+			if (needBuild === void 0) throw new Error(UNSUPPORTED_WEBPACK_MESSAGE);
 			needBuild.tapAsync(PLUGIN_NAME, (module, _context, callback) => {
 				if (epochMoved && this.moduleUsesAnimusLoader(module)) {
 					callback(null, true);
@@ -158,7 +117,8 @@ var AnimusWebpackPlugin = class {
 				registerSystemDependencies();
 				const css = (0, _animus_ui_extract_session.getSharedCss)();
 				if (!css || !RawSource) return;
-				const cssPath = (0, _animus_ui_extract_session.stylesPath)((0, _animus_ui_extract_session.sessionArtifactDir)(this.session.rootDir || compiler.context, this.session.sessionId));
+				const rootDir = this.session.rootDir || compiler.context;
+				const cssPath = (0, _animus_ui_extract_session.stylesPath)((0, _animus_ui_extract_session.sessionArtifactDir)(rootDir, this.session.sessionId));
 				if (compilation.getAsset(cssPath)) {
 					compilation.updateAsset(cssPath, new RawSource(css));
 					return;
@@ -169,24 +129,24 @@ var AnimusWebpackPlugin = class {
 		compiler.hooks.run.tapPromise(PLUGIN_NAME, async (_compiler) => {
 			this.adoptCompilerContext(_compiler);
 			this.extractAliases(_compiler);
-			const existing = (0, _animus_ui_extract_session.getAnalysisPromise)();
+			const existing = (0, _animus_ui_extract_session.getAnalysisStartedPromise)();
 			if (existing) {
 				await existing;
 				return;
 			}
 			const promise = this.session.runFullPipeline();
-			(0, _animus_ui_extract_session.setAnalysisPromise)(promise);
+			(0, _animus_ui_extract_session.setAnalysisStartedPromise)(promise);
 			await promise;
 		});
 		compiler.hooks.watchRun.tapPromise(PLUGIN_NAME, async (_compiler) => {
 			this.adoptCompilerContext(_compiler);
 			this.extractAliases(_compiler);
 			if (!this.initialized) {
-				const existing = (0, _animus_ui_extract_session.getAnalysisPromise)();
+				const existing = (0, _animus_ui_extract_session.getAnalysisStartedPromise)();
 				if (existing) await existing;
 				else {
 					const promise = this.session.runFullPipeline();
-					(0, _animus_ui_extract_session.setAnalysisPromise)(promise);
+					(0, _animus_ui_extract_session.setAnalysisStartedPromise)(promise);
 					await promise;
 				}
 				this.initialized = true;
@@ -202,35 +162,20 @@ var AnimusWebpackPlugin = class {
 			if (epoch !== null) this.lastBuiltEpoch = epoch;
 		});
 	}
-	/**
-	* Reset analysis state for HMR geological reset.
-	*/
 	resetForHmr() {
 		this.session.resetForHmr();
 	}
-	/** Session identity (process-claimed) — with-animus derives the
-	*  session-scoped alias/stub paths from it (design D2). */
 	get sessionId() {
 		return this.session.sessionId;
 	}
-	/** Set the project root at CONFIG time (with-animus) — the ONE root all
-	*  session-path derivations use. The compiler hooks ADOPT
-	*  compiler.context only when no root was published (bare-apply
-	*  harnesses); they never overwrite this. */
 	setRootDir(rootDir) {
 		this.session.rootDir = rootDir;
 	}
-	/** One warning per plugin instance for a context/root mismatch. */
 	warnedRootDivergence = false;
-	/** The run/watchRun taps' root handling: adopt compiler.context when no
-	*  config-time root exists; otherwise KEEP the configured root — every
-	*  frozen config-time derivation (stub path, css alias target,
-	*  virtual:animus/system-props target, watch-ignore) came from it, and a
-	*  silent overwrite re-keys sessionDir so the pipeline publishes
-	*  artifacts where none of those consumers look. A disagreement is
-	*  surfaced loudly instead (with-animus derives the root from Next's own
-	*  `dir`, which equals compiler.context in real Next runs — a mismatch
-	*  means a custom-webpack setup wired the plugin differently). */
+	/** Adopts `compiler.context` only when no config-time root exists: every
+	*  frozen derivation came from that root, so an overwrite re-keys it.
+	*  Stub path, css alias, virtual system-props target and watch-ignore are
+	*  all frozen from it, so a disagreement is warned, never reconciled. */
 	adoptCompilerContext(compiler) {
 		const context = compiler.context;
 		if (!this.session.rootDir) {
@@ -242,73 +187,47 @@ var AnimusWebpackPlugin = class {
 			console.warn(`[animus-extract] compiler.context (${context}) differs from the configured project root (${this.session.rootDir}); keeping the configured root — run next against the app directory (or align your custom webpack context) so both agree`);
 		}
 	}
-	/** This session's artifact directory, derived from the one root. */
 	get sessionDir() {
 		return this.session.sessionDir;
 	}
-	/** Expose options for the loader */
 	getOptions() {
 		return this.options;
 	}
-	/** Expose external package directories for webpack loader allowlisting.
-	*  Falls back to shared globalThis state for non-owning compiler instances. */
 	getExternalPackageDirs() {
 		return this.session.externalPackageDirs.length > 0 ? this.session.externalPackageDirs : (0, _animus_ui_extract_session.getSharedExternalDirs)();
 	}
-	/** Expose external package source entries for webpack resolve alias.
-	*  Falls back to shared globalThis state for non-owning compiler instances. */
 	getExternalSourceEntries() {
 		return this.session.externalSourceEntries.size > 0 ? this.session.externalSourceEntries : (0, _animus_ui_extract_session.getSharedExternalEntries)();
 	}
 };
 //#endregion
 //#region src/turbopack-config.ts
-/** The single glob the Animus loader registers under — derived from the
-*  ONE shared engine extension set (also the unplugin transform gate's
-*  source), so the two bundler families cannot drift. `.mjs` is in that
-*  set for webpack parity: an external package without `src/` is ingested
-*  via its resolved dist entry (often `dist/index.mjs`) and must still
-*  reach the loader — manifest lookup remains the file-level gate. */
+/** The one glob the loader registers under, derived from the shared engine
+*  extension set so the bundler families cannot drift. `.mjs` belongs in that
+*  set: an external package with no src/ is ingested through its dist entry
+*  and must still reach the loader, so do not trim it. */
 const ANIMUS_TURBOPACK_RULE_GLOB = `*.{${_animus_ui_extract_pipeline.ENGINE_TRANSFORM_EXTENSIONS.join(",")}}`;
-/**
-* Resolve whether Turbopack wiring is active for this process. Default is
-* `'auto'`: active exactly when the TURBOPACK environment variable is set
-* (Next sets it for every Turbopack dev/build). The stable `turbopack`
-* option wins over the deprecated `unstable_turbopack` alias.
-*/
 function resolveTurbopackMode(options, env = process.env) {
 	const mode = options.turbopack?.mode ?? options.unstable_turbopack?.mode ?? "auto";
 	if (mode === "on") return true;
 	if (mode === "auto") return env.TURBOPACK !== void 0;
 	return false;
 }
-/** rootDir-relative module request for an absolute path — always forward
-*  slashes, even when path.relative produced Windows separators. */
 function rootRelativeRequest(rootDir, absPath) {
 	return `./${(0, path.relative)(rootDir, absPath).replace(/\\/g, "/")}`;
 }
-/**
-* Build the `turbopack` config fragment: one glob-keyed loader rule
-* (file-level allowlisting lives in the loader via manifest lookup — Next 15
-* rules have no condition algebra) plus resolve aliases for the virtual
-* system-props id, the emitter's stylesheet id, and each collected external
-* package specifier redirected to its source entry. Loader options carry
-* the session identity (design D2: an options-borne, JSON-serializable
-* Turbopack task input — restart-cold by construction), and the artifact
-* aliases point into the session-scoped tree.
-*/
 function buildTurbopackConfig(args) {
 	const { rootDir, loaderPath, options, externalSourceEntries, sessionId, sessionDir } = args;
 	const loaderOptions = {
 		rootDir,
 		sessionId,
-		sessionDir,
-		...options.strict !== void 0 ? { strict: options.strict } : {},
-		...options.cssImportTarget !== void 0 ? { cssImportTarget: options.cssImportTarget } : {}
+		sessionDir
 	};
+	if (options.strict !== void 0) loaderOptions.strict = options.strict;
+	if (options.cssImportTarget !== void 0) loaderOptions.cssImportTarget = options.cssImportTarget;
 	const resolveAlias = {
 		[_animus_ui_extract_session.TURBOPACK_SYSTEM_PROPS_ID]: rootRelativeRequest(rootDir, (0, path.join)(sessionDir, _animus_ui_extract_session.SYSTEM_PROPS_ARTIFACT)),
-		".animus/styles.css": rootRelativeRequest(rootDir, (0, path.join)(sessionDir, _animus_ui_extract_session.STYLES_ARTIFACT))
+		[_animus_ui_extract_session.ANIMUS_CSS_MODULE_ID]: rootRelativeRequest(rootDir, (0, path.join)(sessionDir, _animus_ui_extract_session.STYLES_ARTIFACT))
 	};
 	for (const [specifier, srcEntry] of externalSourceEntries) resolveAlias[specifier] = rootRelativeRequest(rootDir, srcEntry);
 	return {
@@ -319,40 +238,25 @@ function buildTurbopackConfig(args) {
 		resolveAlias
 	};
 }
-/**
-* Locate the Turbopack loader module: built dist first, source fallback for
-* in-repo development. CJS preferred — Turbopack's loader-runner follows
-* the webpack loader contract (`module.exports = fn`), and the .cjs build
-* is loadable by every runner version; ESM default-export acceptance is
-* not guaranteed.
-*/
 function resolveTurbopackLoaderPath(pluginDir) {
 	return resolveLoaderPath(pluginDir, ["turbopack-loader.cjs", "turbopack-loader.mjs"], "turbopack-loader.ts");
 }
 //#endregion
 //#region src/with-animus.ts
-const __dirname$1 = (0, path.dirname)((0, url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
+const __filename$1 = (0, url.fileURLToPath)(require("url").pathToFileURL(__filename).href);
+const __dirname$1 = (0, path.dirname)(__filename$1);
 let warnedGitignore = false;
 let warnedUnstableTurbopack = false;
-/**
-* Wrap a Next.js config to enable Animus static CSS extraction.
-*
-* ```ts
-* // next.config.ts
-* import { withAnimus } from '@animus-ui/next-plugin';
-* export default withAnimus({ system: './src/ds.ts' })({});
-* ```
-*/
 function withAnimus(options) {
 	if (!options.system) throw new Error("[animus-extract] Missing required option `system`. Provide the path to your SystemInstance module: withAnimus({ system: \"./src/ds.ts\" })");
-	(0, _animus_ui_extract_pipeline.assertKnownOptionKeys)(options, [
+	(0, _animus_ui_extract_pipeline.assertKnownOptionKeys)({ ...options }, [
 		"cssImportTarget",
 		"turbopack",
 		"unstable_turbopack",
 		"loaderPath"
 	], [{
 		key: "root",
-		reason: "the Next driver's root is Next's `dir` at config time"
+		reason: "this driver derives its own root — Next's `dir` under webpack, `process.cwd()` under Turbopack (Next passes no dir to a config module)"
 	}], {
 		onUnknownKey: "warn",
 		warn: (message) => console.warn(`[animus-extract] ${message}`)
@@ -367,8 +271,8 @@ function withAnimus(options) {
 		return {
 			...nextConfig,
 			webpack(config, context) {
-				if (typeof existingWebpack === "function") config = existingWebpack(config, context);
-				const rootDir = typeof context.dir === "string" && context.dir.length > 0 ? context.dir : process.cwd();
+				if (existingWebpack) config = existingWebpack(config, context);
+				const rootDir = context.dir?.length ? context.dir : process.cwd();
 				const plugin = new AnimusWebpackPlugin(options);
 				plugin.setRootDir(rootDir);
 				const sessionDir = plugin.sessionDir;
@@ -395,8 +299,8 @@ function withAnimus(options) {
 				const isExternalPackageFile = (filePath) => plugin.getExternalPackageDirs().some((dir) => (0, _animus_ui_extract_pipeline.isPathWithinRoot)(dir, filePath));
 				config.plugins = config.plugins || [];
 				config.plugins.push(plugin);
-				const { DefinePlugin } = context.webpack ?? {};
-				if (typeof DefinePlugin === "function") config.plugins.push(new DefinePlugin({ __ANIMUS_DEV__: JSON.stringify((0, _animus_ui_extract_pipeline.resolveMode)(options.mode, () => context.dev === true ? "development" : "production").mode === "development") }));
+				const DefinePlugin = context.webpack?.DefinePlugin;
+				if (DefinePlugin) config.plugins.push(new DefinePlugin({ __ANIMUS_DEV__: JSON.stringify((0, _animus_ui_extract_pipeline.resolveMode)(options.mode, () => context.dev === true ? "development" : "production").mode === "development") }));
 				config.resolve = config.resolve || {};
 				config.resolve.alias = config.resolve.alias || {};
 				config.resolve.alias[_animus_ui_extract_session.ANIMUS_CSS_MODULE_ID] = (0, _animus_ui_extract_session.stylesPath)(sessionDir);
@@ -415,10 +319,7 @@ function withAnimus(options) {
 				config.module = config.module || {};
 				config.module.rules = config.module.rules || [];
 				config.module.rules.push({
-					test: (filePath) => {
-						if (/\.[jt]sx?$/.test(filePath)) return true;
-						return /\.mjs$/.test(filePath) && isExternalPackageFile(filePath);
-					},
+					test: (filePath) => (0, _animus_ui_extract_pipeline.isEngineTransformExtension)(filePath),
 					exclude: (filePath) => {
 						if (!filePath.includes("node_modules")) return false;
 						return !isExternalPackageFile(filePath);
@@ -437,20 +338,25 @@ function withAnimus(options) {
 		};
 	};
 }
-/**
-* Turbopack wiring: run the full extraction now (artifacts on disk before
-* bundling), start the dev watcher, and merge the generated rules/aliases
-* into `nextConfig.turbopack`. Consumer-managed rules for the same glob are
-* a hard error — silently stacking loaders would be undebuggable.
-*/
+function bindTurbopackWatchDeathReport(outcome, rootDir) {
+	if (outcome.kind !== "started") return;
+	const handle = outcome.handle;
+	handle.onDied = () => {
+		console.error(`[animus-extract] dev watcher for ${rootDir} died — source edits are no longer extracted; restart the dev server`);
+	};
+}
+let liveTurbopackSession = null;
 async function wireTurbopack(nextConfig, options) {
 	const rootDir = process.cwd();
 	const session = new _animus_ui_extract_session.ExtractionSession(options);
+	liveTurbopackSession?.close();
+	liveTurbopackSession = session;
 	session.rootDir = rootDir;
-	const builtAliases = (0, _animus_ui_extract_pipeline.buildPathAliasesJson)((0, _animus_ui_extract_pipeline.readTsconfigAliasPairs)(rootDir), rootDir);
+	const aliasPairs = (0, _animus_ui_extract_pipeline.readTsconfigAliasPairs)(rootDir);
+	const builtAliases = (0, _animus_ui_extract_pipeline.buildPathAliasesJson)(aliasPairs, rootDir);
 	if (builtAliases) session.pathAliasesJson = builtAliases.json;
 	await (0, _animus_ui_extract_session.runSessionPipeline)(session);
-	if (process.env.NODE_ENV === "development") (0, _animus_ui_extract_session.startTurbopackWatcher)(session, rootDir);
+	if (process.env.NODE_ENV === "development") bindTurbopackWatchDeathReport((0, _animus_ui_extract_session.startTurbopackWatcher)(session, rootDir), rootDir);
 	const fragment = buildTurbopackConfig({
 		rootDir,
 		loaderPath: resolveTurbopackLoaderPath(__dirname$1),

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export type { AnimusNextOptions } from './types';
 export { withAnimus } from './with-animus';
+export type { AnimusNextConfigBoundary, NextConfigInput, TurbopackNextConfig, WebpackNextConfig, } from './with-animus';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3C,YAAY,EACV,wBAAwB,EACxB,eAAe,EACf,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,eAAe,CAAC"}