next-intlayer 9.5.10 → 9.5.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-intlayer",
-  "version": "9.5.10",
+  "version": "9.5.12",
   "private": false,
   "description": "Simplify internationalization i18n in Next.js with context providers, hooks, locale detection, and multilingual content integration.",
   "keywords": [
@@ -147,14 +147,14 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/config": "9.5.10",
-    "@intlayer/core": "9.5.10",
-    "@intlayer/dictionaries-entry": "9.5.10",
-    "@intlayer/engine": "9.5.10",
-    "@intlayer/types": "9.5.10",
+    "@intlayer/config": "9.5.12",
+    "@intlayer/core": "9.5.12",
+    "@intlayer/dictionaries-entry": "9.5.12",
+    "@intlayer/engine": "9.5.12",
+    "@intlayer/types": "9.5.12",
     "defu": "6.1.7",
     "node-loader": "2.1.0",
-    "react-intlayer": "9.5.10"
+    "react-intlayer": "9.5.12"
   },
   "devDependencies": {
     "@types/node": "^22",

package/dist/cjs/server/startContentWatcher.cjs

@@ -1,98 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-let _intlayer_config_logger = require("@intlayer/config/logger");
-let _intlayer_engine_utils = require("@intlayer/engine/utils");
-
-//#region src/server/startContentWatcher.ts
-/**
-* How often a process that lost the ownership race checks whether the owner is
-* gone. Next.js's short-lived config processes release the lock when they exit,
-* so the long-lived dev server has to be able to pick it up afterwards.
-*/
-const TAKEOVER_POLL_INTERVAL_MS = 5e3;
-/**
-* Next.js helper processes that evaluate `next.config.*` without being the dev
-* server, matched on their entry script.
-*
-* `detached-flush` is the telemetry flusher Next spawns **detached**: it loads
-* the config, outlives the dev server, and — left unchecked — wins the watcher
-* lock and keeps watching after Ctrl-C, while the next `next dev` finds the
-* lock taken and runs with no watcher at all.
-*/
-const NEXT_HELPER_ENTRY_SCRIPTS = ["detached-flush"];
-/**
-* Whether this process is a Next.js helper rather than the dev server itself.
-*
-* Ownership of the watcher has to follow the process the user actually stops,
-* so a helper must never take it.
-*/
-const getIsNextHelperProcess = () => process.argv.some((argument) => NEXT_HELPER_ENTRY_SCRIPTS.some((script) => argument.includes(script)));
-/** Set once the watcher is running in this process. */
-let isWatching = false;
-/**
-* Set while an ownership attempt is in flight.
-*
-* Taking the lock is asynchronous, and `next.config.*` is evaluated several
-* times per command — without this, those evaluations would pile up concurrent
-* attempts, each awaiting the same lock.
-*/
-let isClaimInFlight = false;
-/** Reports a redundant `intlayer watch` running alongside this dev server. */
-const reportRedundantCliWatcher = (configuration, cliWatcherLabel) => (0, _intlayer_engine_utils.reportRedundantContentWatcher)(configuration, {
-	cliLabel: cliWatcherLabel,
-	bundlerLabel: "next-intlayer"
-});
-/**
-* Starts the content declaration watcher for a Next.js dev server, on webpack
-* as well as on Turbopack.
-*
-* Stands down — with an explanation — when that CLI watcher is running anyway,
-* since two watchers would rebuild the same dictionaries at the same time.
-* Otherwise starting is idempotent: the first process to take the lock watches,
-* and the others retry in the background so a short-lived config process
-* handing the lock back does not leave the session unwatched.
-*
-* @param configuration - The resolved Intlayer configuration.
-*/
-const claimAndWatch = async (configuration) => {
-	const appLogger = (0, _intlayer_config_logger.getAppLogger)(configuration);
-	if (!await (0, _intlayer_engine_utils.acquireContentWatcherLock)(configuration, {
-		source: "bundler",
-		label: "next-intlayer"
-	})) {
-		const owner = await (0, _intlayer_engine_utils.getContentWatcherOwner)(configuration);
-		if (owner?.source === "cli") {
-			reportRedundantCliWatcher(configuration, owner.label);
-			return;
-		}
-		setTimeout(() => {
-			startContentWatcher(configuration);
-		}, TAKEOVER_POLL_INTERVAL_MS).unref?.();
-		return;
-	}
-	isWatching = true;
-	try {
-		const { watch } = await import("@intlayer/engine/watcher");
-		await watch({ configuration });
-	} catch (error) {
-		isWatching = false;
-		appLogger(["Failed to watch Intlayer content declarations:", error], { level: "error" });
-	}
-};
-const startContentWatcher = (configuration) => {
-	if (isWatching || isClaimInFlight) return;
-	if (!configuration.content.watch) return;
-	if (getIsNextHelperProcess()) return;
-	const cliWatcherLabel = (0, _intlayer_engine_utils.getCliContentWatcherLabel)();
-	if (cliWatcherLabel) {
-		reportRedundantCliWatcher(configuration, cliWatcherLabel);
-		return;
-	}
-	isClaimInFlight = true;
-	claimAndWatch(configuration).finally(() => {
-		isClaimInFlight = false;
-	});
-};
-
-//#endregion
-exports.startContentWatcher = startContentWatcher;
-//# sourceMappingURL=startContentWatcher.cjs.map

package/dist/cjs/server/startContentWatcher.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"startContentWatcher.cjs","names":["reportRedundantContentWatcher","getAppLogger","acquireContentWatcherLock","getContentWatcherOwner","getCliContentWatcherLabel"],"sources":["../../../src/server/startContentWatcher.ts"],"sourcesContent":["import { getAppLogger } from '@intlayer/config/logger';\nimport {\n  acquireContentWatcherLock,\n  getCliContentWatcherLabel,\n  getContentWatcherOwner,\n  reportRedundantContentWatcher,\n} from '@intlayer/engine/utils';\nimport type { IntlayerConfig } from '@intlayer/types/config';\n\n/**\n * How often a process that lost the ownership race checks whether the owner is\n * gone. Next.js's short-lived config processes release the lock when they exit,\n * so the long-lived dev server has to be able to pick it up afterwards.\n */\nconst TAKEOVER_POLL_INTERVAL_MS = 5000;\n\n/**\n * Next.js helper processes that evaluate `next.config.*` without being the dev\n * server, matched on their entry script.\n *\n * `detached-flush` is the telemetry flusher Next spawns **detached**: it loads\n * the config, outlives the dev server, and — left unchecked — wins the watcher\n * lock and keeps watching after Ctrl-C, while the next `next dev` finds the\n * lock taken and runs with no watcher at all.\n */\nconst NEXT_HELPER_ENTRY_SCRIPTS = ['detached-flush'];\n\n/**\n * Whether this process is a Next.js helper rather than the dev server itself.\n *\n * Ownership of the watcher has to follow the process the user actually stops,\n * so a helper must never take it.\n */\nconst getIsNextHelperProcess = (): boolean =>\n  process.argv.some((argument) =>\n    NEXT_HELPER_ENTRY_SCRIPTS.some((script) => argument.includes(script))\n  );\n\n/** Set once the watcher is running in this process. */\nlet isWatching = false;\n\n/**\n * Set while an ownership attempt is in flight.\n *\n * Taking the lock is asynchronous, and `next.config.*` is evaluated several\n * times per command — without this, those evaluations would pile up concurrent\n * attempts, each awaiting the same lock.\n */\nlet isClaimInFlight = false;\n\n/** Reports a redundant `intlayer watch` running alongside this dev server. */\nconst reportRedundantCliWatcher = (\n  configuration: IntlayerConfig,\n  cliWatcherLabel: string\n): void =>\n  reportRedundantContentWatcher(configuration, {\n    cliLabel: cliWatcherLabel,\n    bundlerLabel: 'next-intlayer',\n  });\n\n/**\n * Starts the content declaration watcher for a Next.js dev server, on webpack\n * as well as on Turbopack.\n *\n * Stands down — with an explanation — when that CLI watcher is running anyway,\n * since two watchers would rebuild the same dictionaries at the same time.\n * Otherwise starting is idempotent: the first process to take the lock watches,\n * and the others retry in the background so a short-lived config process\n * handing the lock back does not leave the session unwatched.\n *\n * @param configuration - The resolved Intlayer configuration.\n */\nconst claimAndWatch = async (configuration: IntlayerConfig): Promise<void> => {\n  const appLogger = getAppLogger(configuration);\n\n  const hasAcquiredLock = await acquireContentWatcherLock(configuration, {\n    source: 'bundler',\n    label: 'next-intlayer',\n  });\n\n  if (!hasAcquiredLock) {\n    // A CLI watcher started from another terminal is just as redundant as one\n    // wrapping this command, and worth the same explanation.\n    const owner = await getContentWatcherOwner(configuration);\n\n    if (owner?.source === 'cli') {\n      reportRedundantCliWatcher(configuration, owner.label);\n      return;\n    }\n\n    const retryTimer = setTimeout(() => {\n      startContentWatcher(configuration);\n    }, TAKEOVER_POLL_INTERVAL_MS);\n\n    // Unreferenced so a process whose only remaining work is this retry can\n    // still exit.\n    retryTimer.unref?.();\n\n    return;\n  }\n\n  isWatching = true;\n\n  try {\n    // Imported lazily: `@intlayer/engine/watcher` pulls in `@parcel/watcher`, a\n    // native module that has no business being loaded during a production\n    // build. `withIntlayer` already awaited `prepareIntlayer`, so the watcher\n    // only has to pick up the changes that follow.\n    const { watch } = await import('@intlayer/engine/watcher');\n\n    await watch({ configuration });\n  } catch (error) {\n    isWatching = false;\n\n    appLogger(['Failed to watch Intlayer content declarations:', error], {\n      level: 'error',\n    });\n  }\n};\n\nexport const startContentWatcher = (configuration: IntlayerConfig): void => {\n  if (isWatching || isClaimInFlight) return;\n  if (!configuration.content.watch) return;\n  if (getIsNextHelperProcess()) return;\n\n  // Spawned by `intlayer watch --with`: the CLI watcher covers the project, and\n  // this is known from the environment alone — no need to touch the lock.\n  const cliWatcherLabel = getCliContentWatcherLabel();\n\n  if (cliWatcherLabel) {\n    reportRedundantCliWatcher(configuration, cliWatcherLabel);\n    return;\n  }\n\n  isClaimInFlight = true;\n\n  // Deliberately not awaited: `withIntlayerSync` is synchronous, and the dev\n  // server must not wait on the watcher to start serving.\n  claimAndWatch(configuration).finally(() => {\n    isClaimInFlight = false;\n  });\n};\n"],"mappings":";;;;;;;;;;AAcA,MAAM,4BAA4B;;;;;;;;;;AAWlC,MAAM,4BAA4B,CAAC,gBAAgB;;;;;;;AAQnD,MAAM,+BACJ,QAAQ,KAAK,MAAM,aACjB,0BAA0B,MAAM,WAAW,SAAS,SAAS,MAAM,CAAC,CACtE;;AAGF,IAAI,aAAa;;;;;;;;AASjB,IAAI,kBAAkB;;AAGtB,MAAM,6BACJ,eACA,wBAEAA,sDAA8B,eAAe;CAC3C,UAAU;CACV,cAAc;AAChB,CAAC;;;;;;;;;;;;;AAcH,MAAM,gBAAgB,OAAO,kBAAiD;CAC5E,MAAM,gBAAYC,sCAAa,aAAa;CAO5C,IAAI,CAAC,UALyBC,kDAA0B,eAAe;EACrE,QAAQ;EACR,OAAO;CACT,CAAC,GAEqB;EAGpB,MAAM,QAAQ,UAAMC,+CAAuB,aAAa;EAExD,IAAI,OAAO,WAAW,OAAO;GAC3B,0BAA0B,eAAe,MAAM,KAAK;GACpD;EACF;EAQA,AANmB,iBAAiB;GAClC,oBAAoB,aAAa;EACnC,GAAG,yBAIM,CAAC,CAAC,QAAQ;EAEnB;CACF;CAEA,aAAa;CAEb,IAAI;EAKF,MAAM,EAAE,UAAU,MAAM,OAAO;EAE/B,MAAM,MAAM,EAAE,cAAc,CAAC;CAC/B,SAAS,OAAO;EACd,aAAa;EAEb,UAAU,CAAC,kDAAkD,KAAK,GAAG,EACnE,OAAO,QACT,CAAC;CACH;AACF;AAEA,MAAa,uBAAuB,kBAAwC;CAC1E,IAAI,cAAc,iBAAiB;CACnC,IAAI,CAAC,cAAc,QAAQ,OAAO;CAClC,IAAI,uBAAuB,GAAG;CAI9B,MAAM,sBAAkBC,kDAA0B;CAElD,IAAI,iBAAiB;EACnB,0BAA0B,eAAe,eAAe;EACxD;CACF;CAEA,kBAAkB;CAIlB,cAAc,aAAa,CAAC,CAAC,cAAc;EACzC,kBAAkB;CACpB,CAAC;AACH"}

package/dist/esm/server/startContentWatcher.mjs

@@ -1,97 +0,0 @@
-import { getAppLogger } from "@intlayer/config/logger";
-import { acquireContentWatcherLock, getCliContentWatcherLabel, getContentWatcherOwner, reportRedundantContentWatcher } from "@intlayer/engine/utils";
-
-//#region src/server/startContentWatcher.ts
-/**
-* How often a process that lost the ownership race checks whether the owner is
-* gone. Next.js's short-lived config processes release the lock when they exit,
-* so the long-lived dev server has to be able to pick it up afterwards.
-*/
-const TAKEOVER_POLL_INTERVAL_MS = 5e3;
-/**
-* Next.js helper processes that evaluate `next.config.*` without being the dev
-* server, matched on their entry script.
-*
-* `detached-flush` is the telemetry flusher Next spawns **detached**: it loads
-* the config, outlives the dev server, and — left unchecked — wins the watcher
-* lock and keeps watching after Ctrl-C, while the next `next dev` finds the
-* lock taken and runs with no watcher at all.
-*/
-const NEXT_HELPER_ENTRY_SCRIPTS = ["detached-flush"];
-/**
-* Whether this process is a Next.js helper rather than the dev server itself.
-*
-* Ownership of the watcher has to follow the process the user actually stops,
-* so a helper must never take it.
-*/
-const getIsNextHelperProcess = () => process.argv.some((argument) => NEXT_HELPER_ENTRY_SCRIPTS.some((script) => argument.includes(script)));
-/** Set once the watcher is running in this process. */
-let isWatching = false;
-/**
-* Set while an ownership attempt is in flight.
-*
-* Taking the lock is asynchronous, and `next.config.*` is evaluated several
-* times per command — without this, those evaluations would pile up concurrent
-* attempts, each awaiting the same lock.
-*/
-let isClaimInFlight = false;
-/** Reports a redundant `intlayer watch` running alongside this dev server. */
-const reportRedundantCliWatcher = (configuration, cliWatcherLabel) => reportRedundantContentWatcher(configuration, {
-	cliLabel: cliWatcherLabel,
-	bundlerLabel: "next-intlayer"
-});
-/**
-* Starts the content declaration watcher for a Next.js dev server, on webpack
-* as well as on Turbopack.
-*
-* Stands down — with an explanation — when that CLI watcher is running anyway,
-* since two watchers would rebuild the same dictionaries at the same time.
-* Otherwise starting is idempotent: the first process to take the lock watches,
-* and the others retry in the background so a short-lived config process
-* handing the lock back does not leave the session unwatched.
-*
-* @param configuration - The resolved Intlayer configuration.
-*/
-const claimAndWatch = async (configuration) => {
-	const appLogger = getAppLogger(configuration);
-	if (!await acquireContentWatcherLock(configuration, {
-		source: "bundler",
-		label: "next-intlayer"
-	})) {
-		const owner = await getContentWatcherOwner(configuration);
-		if (owner?.source === "cli") {
-			reportRedundantCliWatcher(configuration, owner.label);
-			return;
-		}
-		setTimeout(() => {
-			startContentWatcher(configuration);
-		}, TAKEOVER_POLL_INTERVAL_MS).unref?.();
-		return;
-	}
-	isWatching = true;
-	try {
-		const { watch } = await import("@intlayer/engine/watcher");
-		await watch({ configuration });
-	} catch (error) {
-		isWatching = false;
-		appLogger(["Failed to watch Intlayer content declarations:", error], { level: "error" });
-	}
-};
-const startContentWatcher = (configuration) => {
-	if (isWatching || isClaimInFlight) return;
-	if (!configuration.content.watch) return;
-	if (getIsNextHelperProcess()) return;
-	const cliWatcherLabel = getCliContentWatcherLabel();
-	if (cliWatcherLabel) {
-		reportRedundantCliWatcher(configuration, cliWatcherLabel);
-		return;
-	}
-	isClaimInFlight = true;
-	claimAndWatch(configuration).finally(() => {
-		isClaimInFlight = false;
-	});
-};
-
-//#endregion
-export { startContentWatcher };
-//# sourceMappingURL=startContentWatcher.mjs.map

package/dist/esm/server/startContentWatcher.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"startContentWatcher.mjs","names":[],"sources":["../../../src/server/startContentWatcher.ts"],"sourcesContent":["import { getAppLogger } from '@intlayer/config/logger';\nimport {\n  acquireContentWatcherLock,\n  getCliContentWatcherLabel,\n  getContentWatcherOwner,\n  reportRedundantContentWatcher,\n} from '@intlayer/engine/utils';\nimport type { IntlayerConfig } from '@intlayer/types/config';\n\n/**\n * How often a process that lost the ownership race checks whether the owner is\n * gone. Next.js's short-lived config processes release the lock when they exit,\n * so the long-lived dev server has to be able to pick it up afterwards.\n */\nconst TAKEOVER_POLL_INTERVAL_MS = 5000;\n\n/**\n * Next.js helper processes that evaluate `next.config.*` without being the dev\n * server, matched on their entry script.\n *\n * `detached-flush` is the telemetry flusher Next spawns **detached**: it loads\n * the config, outlives the dev server, and — left unchecked — wins the watcher\n * lock and keeps watching after Ctrl-C, while the next `next dev` finds the\n * lock taken and runs with no watcher at all.\n */\nconst NEXT_HELPER_ENTRY_SCRIPTS = ['detached-flush'];\n\n/**\n * Whether this process is a Next.js helper rather than the dev server itself.\n *\n * Ownership of the watcher has to follow the process the user actually stops,\n * so a helper must never take it.\n */\nconst getIsNextHelperProcess = (): boolean =>\n  process.argv.some((argument) =>\n    NEXT_HELPER_ENTRY_SCRIPTS.some((script) => argument.includes(script))\n  );\n\n/** Set once the watcher is running in this process. */\nlet isWatching = false;\n\n/**\n * Set while an ownership attempt is in flight.\n *\n * Taking the lock is asynchronous, and `next.config.*` is evaluated several\n * times per command — without this, those evaluations would pile up concurrent\n * attempts, each awaiting the same lock.\n */\nlet isClaimInFlight = false;\n\n/** Reports a redundant `intlayer watch` running alongside this dev server. */\nconst reportRedundantCliWatcher = (\n  configuration: IntlayerConfig,\n  cliWatcherLabel: string\n): void =>\n  reportRedundantContentWatcher(configuration, {\n    cliLabel: cliWatcherLabel,\n    bundlerLabel: 'next-intlayer',\n  });\n\n/**\n * Starts the content declaration watcher for a Next.js dev server, on webpack\n * as well as on Turbopack.\n *\n * Stands down — with an explanation — when that CLI watcher is running anyway,\n * since two watchers would rebuild the same dictionaries at the same time.\n * Otherwise starting is idempotent: the first process to take the lock watches,\n * and the others retry in the background so a short-lived config process\n * handing the lock back does not leave the session unwatched.\n *\n * @param configuration - The resolved Intlayer configuration.\n */\nconst claimAndWatch = async (configuration: IntlayerConfig): Promise<void> => {\n  const appLogger = getAppLogger(configuration);\n\n  const hasAcquiredLock = await acquireContentWatcherLock(configuration, {\n    source: 'bundler',\n    label: 'next-intlayer',\n  });\n\n  if (!hasAcquiredLock) {\n    // A CLI watcher started from another terminal is just as redundant as one\n    // wrapping this command, and worth the same explanation.\n    const owner = await getContentWatcherOwner(configuration);\n\n    if (owner?.source === 'cli') {\n      reportRedundantCliWatcher(configuration, owner.label);\n      return;\n    }\n\n    const retryTimer = setTimeout(() => {\n      startContentWatcher(configuration);\n    }, TAKEOVER_POLL_INTERVAL_MS);\n\n    // Unreferenced so a process whose only remaining work is this retry can\n    // still exit.\n    retryTimer.unref?.();\n\n    return;\n  }\n\n  isWatching = true;\n\n  try {\n    // Imported lazily: `@intlayer/engine/watcher` pulls in `@parcel/watcher`, a\n    // native module that has no business being loaded during a production\n    // build. `withIntlayer` already awaited `prepareIntlayer`, so the watcher\n    // only has to pick up the changes that follow.\n    const { watch } = await import('@intlayer/engine/watcher');\n\n    await watch({ configuration });\n  } catch (error) {\n    isWatching = false;\n\n    appLogger(['Failed to watch Intlayer content declarations:', error], {\n      level: 'error',\n    });\n  }\n};\n\nexport const startContentWatcher = (configuration: IntlayerConfig): void => {\n  if (isWatching || isClaimInFlight) return;\n  if (!configuration.content.watch) return;\n  if (getIsNextHelperProcess()) return;\n\n  // Spawned by `intlayer watch --with`: the CLI watcher covers the project, and\n  // this is known from the environment alone — no need to touch the lock.\n  const cliWatcherLabel = getCliContentWatcherLabel();\n\n  if (cliWatcherLabel) {\n    reportRedundantCliWatcher(configuration, cliWatcherLabel);\n    return;\n  }\n\n  isClaimInFlight = true;\n\n  // Deliberately not awaited: `withIntlayerSync` is synchronous, and the dev\n  // server must not wait on the watcher to start serving.\n  claimAndWatch(configuration).finally(() => {\n    isClaimInFlight = false;\n  });\n};\n"],"mappings":";;;;;;;;;AAcA,MAAM,4BAA4B;;;;;;;;;;AAWlC,MAAM,4BAA4B,CAAC,gBAAgB;;;;;;;AAQnD,MAAM,+BACJ,QAAQ,KAAK,MAAM,aACjB,0BAA0B,MAAM,WAAW,SAAS,SAAS,MAAM,CAAC,CACtE;;AAGF,IAAI,aAAa;;;;;;;;AASjB,IAAI,kBAAkB;;AAGtB,MAAM,6BACJ,eACA,oBAEA,8BAA8B,eAAe;CAC3C,UAAU;CACV,cAAc;AAChB,CAAC;;;;;;;;;;;;;AAcH,MAAM,gBAAgB,OAAO,kBAAiD;CAC5E,MAAM,YAAY,aAAa,aAAa;CAO5C,IAAI,CAAC,MALyB,0BAA0B,eAAe;EACrE,QAAQ;EACR,OAAO;CACT,CAAC,GAEqB;EAGpB,MAAM,QAAQ,MAAM,uBAAuB,aAAa;EAExD,IAAI,OAAO,WAAW,OAAO;GAC3B,0BAA0B,eAAe,MAAM,KAAK;GACpD;EACF;EAQA,AANmB,iBAAiB;GAClC,oBAAoB,aAAa;EACnC,GAAG,yBAIM,CAAC,CAAC,QAAQ;EAEnB;CACF;CAEA,aAAa;CAEb,IAAI;EAKF,MAAM,EAAE,UAAU,MAAM,OAAO;EAE/B,MAAM,MAAM,EAAE,cAAc,CAAC;CAC/B,SAAS,OAAO;EACd,aAAa;EAEb,UAAU,CAAC,kDAAkD,KAAK,GAAG,EACnE,OAAO,QACT,CAAC;CACH;AACF;AAEA,MAAa,uBAAuB,kBAAwC;CAC1E,IAAI,cAAc,iBAAiB;CACnC,IAAI,CAAC,cAAc,QAAQ,OAAO;CAClC,IAAI,uBAAuB,GAAG;CAI9B,MAAM,kBAAkB,0BAA0B;CAElD,IAAI,iBAAiB;EACnB,0BAA0B,eAAe,eAAe;EACxD;CACF;CAEA,kBAAkB;CAIlB,cAAc,aAAa,CAAC,CAAC,cAAc;EACzC,kBAAkB;CACpB,CAAC;AACH"}

package/dist/types/server/startContentWatcher.d.ts

@@ -1,5 +0,0 @@
-import { IntlayerConfig } from "@intlayer/types/config";
-//#region src/server/startContentWatcher.d.ts
-export declare const startContentWatcher: (configuration: IntlayerConfig) => void;
-//#endregion
-//# sourceMappingURL=startContentWatcher.d.ts.map

package/dist/types/server/startContentWatcher.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"startContentWatcher.d.ts","names":[],"sources":["../../../src/server/startContentWatcher.ts"],"mappings":";;qBAwHa,sBAAmB,eAAmB"}