@adamhl8/configs 1.6.0 → 1.6.1

package/README.md

@@ -6,6 +6,21 @@ Configs (`tsconfig`, `oxfmt`, `oxlint`, etc.) I use across my projects.
 bun add -D @adamhl8/configs
 ```
 
+### Config merging
+
+Each `fooConfig({ ... })` function deep merges your config into the base config. Arrays are appended to the base array by default. To control this per key, any array-typed key can instead take `{ value: [...], mode: "merge" | "replace" }`:
+
+```ts
+const config = oxlintConfig({
+  // appended to the base plugins (same as passing a plain array)
+  plugins: { value: ["my-plugin"], mode: "merge" },
+  // used as-is, the base overrides are dropped
+  overrides: { value: [], mode: "replace" },
+})
+```
+
+The wrapper works at any depth and never appears in the merged result, in the types or at runtime.
+
 ### just
 
 Scripts live in a shared [`just`](https://github.com/casey/just) base justfile instead of being copied into every project's `package.json`. Your `justfile`:

package/dist/configs/justfile.base.just

@@ -3,8 +3,6 @@ set unstable
 set default-list
 set allow-duplicate-recipes
 
-export PATH := justfile_directory() + "/node_modules/.bin:" + env("PATH")
-
 # runs cmd if the condition command succeeds, echoing cmd only when it runs
 run-when(cmd, condition) := f"if {{condition}}; then echo {{style("command", cmd)}}; {{cmd}}; fi"
 
@@ -17,9 +15,9 @@ tofu-run-condition := '[ -z "${CI:-}" ] && ls *.tofu >/dev/null 2>&1 && aws conf
 prepare: _prepare
 _prepare:
     lefthook install
-    adamhl8-gitignore
-    adamhl8-bunfig
-    oxfmt bunfig.toml
+    bun adamhl8-gitignore
+    bun adamhl8-bunfig
+    bun oxfmt bunfig.toml
     @{{ run-when("tofu init -upgrade", tofu-run-condition) }}
 
 bump-deps: _bump-deps
@@ -35,15 +33,15 @@ _tofu-check:
 
 lint: _lint
 _lint:
-    markdown-toc -i --bullets '-' --maxdepth 3 ./README.md
-    oxlint --fix --fix-suggestions --fix-dangerously
-    oxfmt
-    knip-bun
+    bun markdown-toc -i --bullets '-' --maxdepth 3 ./README.md
+    bun oxlint --fix --fix-suggestions --fix-dangerously
+    bun oxfmt
+    bun knip-bun
     @just test
 
 build: _build
 _build: lint && tofu-check
-    @{{ run-when("tsdown", "[ -f tsdown.config.ts ]") }}
+    @{{ run-when("bun tsdown", "[ -f tsdown.config.ts ]") }}
 
 test: _test
 _test:
@@ -57,4 +55,4 @@ _release:
 release-run: _release-run
 
 _release-run:
-    release-it -VV --ci -i "$(adamhl8-cliff --bumped-version)"
+    bun release-it -VV --ci -i "$(adamhl8-cliff --bumped-version)"

package/dist/configs/knip.base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"knip.base.d.ts","names":[],"sources":["../../src/configs/knip.base.ts"],"mappings":";;;cAuBa,YAAU,sBAAA;;;;;aAJnB"}
+{"version":3,"file":"knip.base.d.ts","names":[],"sources":["../../src/configs/knip.base.ts"],"mappings":";;;cAsBa,YAAU,sBAAA;;;;;aAJnB"}

package/dist/configs/knip.base.js.map

@@ -1 +1 @@
-{"version":3,"file":"knip.base.js","names":[],"sources":["../../src/configs/knip.base.ts"],"sourcesContent":["import type { KnipConfig } from \"knip\"\n\nimport { createMergeConfigFn } from \"#utils.ts\"\n\n/** Knip sees `just` in the `prepare` script and the release-it hooks, but it isn't a package.json dependency */\nconst IGNORE_BINARIES = [\"just\"] as const satisfies string[]\n\n/**\n * - Knip resolves `@adamhl8/eslint-plugin-clean-modules` via the oxlint config, but we don't need to install it directly\n *   in the consuming project, so it shows as unlisted\n */\nconst IGNORE_DEPENDENCIES = [\"@adamhl8/eslint-plugin-clean-modules\"] as const satisfies string[]\n\nconst baseConfig = {\n  project: [\"**/*\"],\n  // entry: [\"**/*.test.ts\"],\n  ignoreBinaries: IGNORE_BINARIES,\n  ignoreDependencies: IGNORE_DEPENDENCIES,\n  bun: {\n    entry: [\"**/*.test.ts\"],\n  },\n} as const satisfies KnipConfig\n\nexport const knipConfig = createMergeConfigFn<KnipConfig, typeof baseConfig>(baseConfig)\n"],"mappings":";AAuBA,MAAa,aAAa,oBAAmD;CAT3E,SAAS,CAAC,MAAM;CAEhB,gBAAgB,CAXO,MAWO;CAC9B,oBAAoB,CANO,sCAMW;CACtC,KAAK,EACH,OAAO,CAAC,cAAc,EACxB;AAG2E,CAAU"}
+{"version":3,"file":"knip.base.js","names":[],"sources":["../../src/configs/knip.base.ts"],"sourcesContent":["import type { KnipConfig } from \"knip\"\n\nimport { createMergeConfigFn } from \"#utils.ts\"\n\n/** Knip sees `just` in the `prepare` script and the release-it hooks, but it isn't a package.json dependency */\nconst IGNORE_BINARIES = [\"just\"] as const satisfies string[]\n\n/**\n * - Knip resolves `@adamhl8/eslint-plugin-clean-modules` via the oxlint config, but we don't need to install it directly\n *   in the consuming project, so it shows as unlisted\n */\nconst IGNORE_DEPENDENCIES = [\"@adamhl8/eslint-plugin-clean-modules\"] as const satisfies string[]\n\nconst baseConfig = {\n  project: [\"**/*\"],\n  ignoreBinaries: IGNORE_BINARIES,\n  ignoreDependencies: IGNORE_DEPENDENCIES,\n  bun: {\n    entry: [\"**/*.test.ts\"],\n  },\n} as const satisfies KnipConfig\n\nexport const knipConfig = createMergeConfigFn<KnipConfig, typeof baseConfig>(baseConfig)\n"],"mappings":";AAsBA,MAAa,aAAa,oBAAmD;CAR3E,SAAS,CAAC,MAAM;CAChB,gBAAgB,CAVO,MAUO;CAC9B,oBAAoB,CALO,sCAKW;CACtC,KAAK,EACH,OAAO,CAAC,cAAc,EACxB;AAG2E,CAAU"}

package/dist/configs/tsdown.base.d.ts

@@ -1,8 +1,8 @@
-import { MergeConfigFn, OptionalMergeConfigFn } from "../utils.js";
+import { MergeConfigFn } from "../utils.js";
 import { SetRequired } from "type-fest";
 import { UserConfig } from "tsdown";
 //#region src/configs/tsdown.base.d.ts
-type StrictUserConfig = SetRequired<UserConfig, "platform">;
+type StrictConfig = SetRequired<UserConfig, "platform">;
 declare const baseConfig: {
   readonly entry: ["./src/index.ts"];
   readonly platform: "neutral";
@@ -27,8 +27,8 @@ declare const baseConfig: {
   readonly publint: true;
   readonly failOnWarn: true;
 };
+type StrictBundleConfig = SetRequired<UserConfig, "platform" | "entry">;
 declare const bundleConfig: {
-  readonly entry: ["./src/index.ts"];
   readonly platform: "neutral";
   readonly target: false;
   readonly minify: "dce-only";
@@ -38,6 +38,7 @@ declare const bundleConfig: {
     readonly neverBundle: ["bun"];
   };
   readonly failOnWarn: true;
+  readonly entry: [];
   readonly unbundle: false;
   readonly sourcemap: false;
   readonly dts: false;
@@ -49,9 +50,8 @@ declare const bundleConfig: {
     };
   };
 };
-declare const tsdownConfig: MergeConfigFn<StrictUserConfig, typeof baseConfig>;
-declare const tsdownBundleConfig: MergeConfigFn<StrictUserConfig, typeof bundleConfig>;
-declare const tsdownBinConfig: OptionalMergeConfigFn<UserConfig, {
+type StrictBinConfig = SetRequired<UserConfig, "entry">;
+declare const binConfig: {
   readonly target: false;
   readonly minify: "dce-only";
   readonly fixedExtension: false;
@@ -60,6 +60,7 @@ declare const tsdownBinConfig: OptionalMergeConfigFn<UserConfig, {
     readonly neverBundle: ["bun"];
   };
   readonly failOnWarn: true;
+  readonly entry: [];
   readonly unbundle: false;
   readonly sourcemap: false;
   readonly dts: false;
@@ -70,12 +71,14 @@ declare const tsdownBinConfig: OptionalMergeConfigFn<UserConfig, {
       readonly attachDebugInfo: "none";
     };
   };
-  readonly entry: [];
   readonly platform: "node";
   readonly outExtensions: () => {
     readonly js: "";
   };
-}>;
+};
+declare const tsdownConfig: MergeConfigFn<StrictConfig, typeof baseConfig>;
+declare const tsdownBundleConfig: MergeConfigFn<StrictBundleConfig, typeof bundleConfig>;
+declare const tsdownBinConfig: MergeConfigFn<StrictBinConfig, typeof binConfig>;
 //#endregion
 export { tsdownBinConfig, tsdownBundleConfig, tsdownConfig };
 //# sourceMappingURL=tsdown.base.d.ts.map

package/dist/configs/tsdown.base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tsdown.base.d.ts","names":[],"sources":["../../src/configs/tsdown.base.ts"],"mappings":";;;;KAOK,mBAAmB,YAAY;cAE9B;;;;;;;;;;aAUF;aACA;aACA;;;aAGA;;;aAGA;aACA;;;;;cAOE;;;;;;;;aAXF;;;;;;;;;aAmBA;eACE;;;;cAcO,cAAc,cAAc,yBAAyB;cAKrD,oBAAoB,cAAc,yBAAyB;cAK3D,iBAAe,sBAAA;;;;;;aA5CxB;;;;;;;;;aAmBA;eACE"}
+{"version":3,"file":"tsdown.base.d.ts","names":[],"sources":["../../src/configs/tsdown.base.ts"],"mappings":";;;;KAOK,eAAe,YAAY;cAE1B;;;;;;;;;;aAUF;aACA;aACA;;;aAGA;;;aAGA;aACA;;;;;KAOC,qBAAqB,YAAY;cAGhC;;;;;;;aAdF;;;;;;;;;;aAuBA;eACE;;;;KAMD,kBAAkB,YAAY;cAG7B;;;;;;aAjCF;;;;;;;;;;aAuBA;eACE;;;;;;;;cAeO,cAAc,cAAc,qBAAqB;cAKjD,oBAAoB,cAAc,2BAA2B;cAK7D,iBAAiB,cAAc,wBAAwB"}

package/dist/configs/tsdown.base.js

@@ -24,6 +24,7 @@ const baseConfig = {
 };
 const bundleConfig = {
 	...baseConfig,
+	entry: [],
 	unbundle: false,
 	sourcemap: false,
 	dts: false,
@@ -33,7 +34,6 @@ const bundleConfig = {
 };
 const binConfig = {
 	...bundleConfig,
-	entry: [],
 	platform: "node",
 	outExtensions: () => ({ js: "" })
 };

package/dist/configs/tsdown.base.js.map

@@ -1 +1 @@
-{"version":3,"file":"tsdown.base.js","names":[],"sources":["../../src/configs/tsdown.base.ts"],"sourcesContent":["import type { UserConfig } from \"tsdown\"\nimport type { SetRequired } from \"type-fest\"\n\nimport type { MergeConfigFn } from \"#utils.ts\"\nimport { createMergeConfigFn } from \"#utils.ts\"\n\n// Force projects to specify platform\ntype StrictUserConfig = SetRequired<UserConfig, \"platform\">\n\nconst baseConfig = {\n  entry: [\"./src/index.ts\"],\n  platform: \"neutral\",\n  target: false,\n  unbundle: true,\n  sourcemap: true,\n  minify: \"dce-only\",\n  fixedExtension: false,\n  hash: false,\n  dts: {\n    newContext: true,\n    tsgo: true,\n    sourcemap: true,\n  },\n  deps: {\n    neverBundle: [\"bun\"],\n  },\n  attw: {\n    level: \"error\",\n    profile: \"esm-only\",\n  },\n  publint: true,\n  failOnWarn: true,\n} as const satisfies StrictUserConfig\n\n// Single-file bundle (not a published library): bundle everything, drop types/lint/sourcemap.\nconst bundleConfig = {\n  ...baseConfig,\n  unbundle: false,\n  sourcemap: false,\n  dts: false,\n  attw: false,\n  publint: false,\n  inputOptions: {\n    experimental: {\n      attachDebugInfo: \"none\", // remove region comments from bundled output\n    },\n  },\n} as const satisfies StrictUserConfig\n\n// A bin is a node bundle with no output file extension.\nconst binConfig = {\n  ...bundleConfig,\n  entry: [],\n  platform: \"node\",\n  outExtensions: () => ({ js: \"\" }) as const,\n} as const satisfies UserConfig\n\n// Annotated as the non-optional MergeConfigFn so projects must pass a config (platform is required)\nexport const tsdownConfig: MergeConfigFn<StrictUserConfig, typeof baseConfig> = createMergeConfigFn<\n  StrictUserConfig,\n  typeof baseConfig\n>(baseConfig)\n\nexport const tsdownBundleConfig: MergeConfigFn<StrictUserConfig, typeof bundleConfig> = createMergeConfigFn<\n  StrictUserConfig,\n  typeof bundleConfig\n>(bundleConfig)\n\nexport const tsdownBinConfig = createMergeConfigFn<UserConfig, typeof binConfig>(binConfig)\n"],"mappings":";;AASA,MAAM,aAAa;CACjB,OAAO,CAAC,gBAAgB;CACxB,UAAU;CACV,QAAQ;CACR,UAAU;CACV,WAAW;CACX,QAAQ;CACR,gBAAgB;CAChB,MAAM;CACN,KAAK;EACH,YAAY;EACZ,MAAM;EACN,WAAW;CACb;CACA,MAAM,EACJ,aAAa,CAAC,KAAK,EACrB;CACA,MAAM;EACJ,OAAO;EACP,SAAS;CACX;CACA,SAAS;CACT,YAAY;AACd;AAGA,MAAM,eAAe;CACnB,GAAG;CACH,UAAU;CACV,WAAW;CACX,KAAK;CACL,MAAM;CACN,SAAS;CACT,cAAc,EACZ,cAAc,EACZ,iBAAiB,OACnB,EACF;AACF;AAGA,MAAM,YAAY;CAChB,GAAG;CACH,OAAO,CAAC;CACR,UAAU;CACV,sBAAsB,EAAE,IAAI,GAAG;AACjC;AAGA,MAAa,eAAmE,oBAG9E,UAAU;AAEZ,MAAa,qBAA2E,oBAGtF,YAAY;AAEd,MAAa,kBAAkB,oBAAkD,SAAS"}
+{"version":3,"file":"tsdown.base.js","names":[],"sources":["../../src/configs/tsdown.base.ts"],"sourcesContent":["import type { UserConfig } from \"tsdown\"\nimport type { SetRequired } from \"type-fest\"\n\nimport type { MergeConfigFn } from \"#utils.ts\"\nimport { createMergeConfigFn } from \"#utils.ts\"\n\n// Force projects to specify platform\ntype StrictConfig = SetRequired<UserConfig, \"platform\">\n\nconst baseConfig = {\n  entry: [\"./src/index.ts\"],\n  platform: \"neutral\",\n  target: false,\n  unbundle: true,\n  sourcemap: true,\n  minify: \"dce-only\",\n  fixedExtension: false,\n  hash: false,\n  dts: {\n    newContext: true,\n    tsgo: true,\n    sourcemap: true,\n  },\n  deps: {\n    neverBundle: [\"bun\"],\n  },\n  attw: {\n    level: \"error\",\n    profile: \"esm-only\",\n  },\n  publint: true,\n  failOnWarn: true,\n} as const satisfies StrictConfig\n\n// Force projects to specify platform and entry\ntype StrictBundleConfig = SetRequired<UserConfig, \"platform\" | \"entry\">\n\n// Single-file bundle (not a published library): bundle everything, drop types/lint/sourcemap.\nconst bundleConfig = {\n  ...baseConfig,\n  entry: [],\n  unbundle: false,\n  sourcemap: false,\n  dts: false,\n  attw: false,\n  publint: false,\n  inputOptions: {\n    experimental: {\n      attachDebugInfo: \"none\", // remove region comments from bundled output\n    },\n  },\n} as const satisfies StrictBundleConfig\n\n// Force projects to specify platform and entry\ntype StrictBinConfig = SetRequired<UserConfig, \"entry\">\n\n// A bin is a node bundle with no output file extension.\nconst binConfig = {\n  ...bundleConfig,\n  platform: \"node\",\n  outExtensions: () => ({ js: \"\" }) as const,\n} as const satisfies StrictBinConfig\n\nexport const tsdownConfig: MergeConfigFn<StrictConfig, typeof baseConfig> = createMergeConfigFn<\n  StrictConfig,\n  typeof baseConfig\n>(baseConfig)\n\nexport const tsdownBundleConfig: MergeConfigFn<StrictBundleConfig, typeof bundleConfig> = createMergeConfigFn<\n  StrictBundleConfig,\n  typeof bundleConfig\n>(bundleConfig)\n\nexport const tsdownBinConfig: MergeConfigFn<StrictBinConfig, typeof binConfig> = createMergeConfigFn<\n  StrictBinConfig,\n  typeof binConfig\n>(binConfig)\n"],"mappings":";;AASA,MAAM,aAAa;CACjB,OAAO,CAAC,gBAAgB;CACxB,UAAU;CACV,QAAQ;CACR,UAAU;CACV,WAAW;CACX,QAAQ;CACR,gBAAgB;CAChB,MAAM;CACN,KAAK;EACH,YAAY;EACZ,MAAM;EACN,WAAW;CACb;CACA,MAAM,EACJ,aAAa,CAAC,KAAK,EACrB;CACA,MAAM;EACJ,OAAO;EACP,SAAS;CACX;CACA,SAAS;CACT,YAAY;AACd;AAMA,MAAM,eAAe;CACnB,GAAG;CACH,OAAO,CAAC;CACR,UAAU;CACV,WAAW;CACX,KAAK;CACL,MAAM;CACN,SAAS;CACT,cAAc,EACZ,cAAc,EACZ,iBAAiB,OACnB,EACF;AACF;AAMA,MAAM,YAAY;CAChB,GAAG;CACH,UAAU;CACV,sBAAsB,EAAE,IAAI,GAAG;AACjC;AAEA,MAAa,eAA+D,oBAG1E,UAAU;AAEZ,MAAa,qBAA6E,oBAGxF,YAAY;AAEd,MAAa,kBAAoE,oBAG/E,SAAS"}

package/dist/utils.d.ts

@@ -1,37 +1,79 @@
 import { MergeDeep, ReadonlyDeep, SimplifyDeep, WritableDeep } from "type-fest";
 //#region src/utils.d.ts
+type AnyFunction = (...args: never[]) => unknown;
+/**
+ * How a wrapped user array is combined with the base array. - `"merge"` (the default for plain arrays): the user array
+ * is appended to the base array - `"replace"`: the user array is used as-is
+ */
+type ArrayMergeMode = "merge" | "replace";
+/**
+ * A per-key array override. Wherever a config key takes an array, `{ value: [...], mode: "merge" | "replace" }` may be
+ * passed instead; `mode` controls how that key's array combines with the base config's. The wrapper never appears in
+ * the merged result. A config value that is exactly this shape is always consumed as a wrapper; an object with extra
+ * keys is treated as a plain config object.
+ */
+interface ArrayOverride<Value extends readonly unknown[], Mode extends ArrayMergeMode = ArrayMergeMode> {
+  readonly value: Value;
+  readonly mode: Mode;
+}
+/** True only when T is exactly the wrapper shape (keys value + mode, nothing else), mirroring isArrayOverride. */
+type IsArrayOverride<T> = T extends {
+  readonly value: readonly unknown[];
+  readonly mode: ArrayMergeMode;
+} ? [keyof T] extends [keyof ArrayOverride<readonly unknown[]>] ? true : false : false;
+/**
+ * For every array-typed value in T, additionally allow `{ value: <that array type>, mode: ArrayMergeMode }`.
+ * Distributes over unions, does not recurse into array elements, and leaves functions/primitives alone.
+ */
+type WithArrayOverrides<T> = T extends readonly unknown[] ? T | ArrayOverride<T> : T extends AnyFunction ? T : T extends object ? { [K in keyof T]: WithArrayOverrides<T[K]>; } : T;
+/**
+ * True if T contains (at any object depth, not inside arrays) a replace-mode wrapper. Depth is a recursion budget: when
+ * a call fails the generic constraint, this type runs over the full constraint (the whole tool config type), and the
+ * eager `{ ... }[keyof T]` walk would hit TS2615 on circular types in it (e.g. Console) and bury the real error.
+ */
+type HasReplaceWrapper<T, Depth extends readonly unknown[] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]> = Depth extends readonly [unknown, ...infer RemainingDepth] ? T extends readonly unknown[] ? false : T extends AnyFunction ? false : T extends object ? IsArrayOverride<T> extends true ? T extends {
+  readonly mode: "replace";
+} ? true : false : true extends { [K in keyof T]: HasReplaceWrapper<T[K], RemainingDepth>; }[keyof T] ? true : false : false : false;
+/** Keep only the key paths whose leaf is a replace-mode wrapper; unwrap those leaves to their `value` type. */
+type DeepPickReplaceWrappers<T> = { [K in keyof T as HasReplaceWrapper<T[K]> extends true ? K : never]: IsArrayOverride<T[K]> extends true ? T[K] extends {
+  readonly value: infer V extends readonly unknown[];
+} ? V : never : DeepPickReplaceWrappers<T[K]>; };
+/** Drop key paths whose leaf is a replace-mode wrapper; unwrap merge-mode wrappers in place. */
+type DeepDropReplaceWrappers<T> = { [K in keyof T as IsArrayOverride<T[K]> extends true ? T[K] extends {
+  readonly mode: "replace";
+} ? never : K : K]: T[K] extends readonly unknown[] ? T[K] : T[K] extends AnyFunction ? T[K] : IsArrayOverride<T[K]> extends true ? T[K] extends {
+  readonly value: infer V extends readonly unknown[];
+} ? V : never : T[K] extends object ? DeepDropReplaceWrappers<T[K]> : T[K]; };
+/**
+ * The merged result type, exact for per-key overrides: pass 1 merges the user config minus replace-wrapper keys
+ * (unwrapping merge-mode wrappers, which behave like plain arrays) with array spreading; pass 2 merges the unwrapped
+ * replace-wrapper keys with array replacement. Instead of returning `BaseConfig & UserConfig` (from `merge`), this is a
+ * more friendly type via `MergeDeep`.
+ */
+type MergedConfig<BaseConfig, UserConfig> = MergeDeep<MergeDeep<SimplifyDeep<WritableDeep<BaseConfig>>, SimplifyDeep<WritableDeep<DeepDropReplaceWrappers<UserConfig>>>, {
+  arrayMergeMode: "spread";
+}>, SimplifyDeep<WritableDeep<DeepPickReplaceWrappers<UserConfig>>>, {
+  arrayMergeMode: "replace";
+}>;
 /**
  * The merge config function, where the `UserConfig` passed in is merged with `BaseConfig`.
  *
- * Each `arrays` mode gets its own overload so the return type's `arrayMergeMode` matches the runtime behavior. The
- * `"replace"` overload comes first so it wins overload resolution when `{ arrays: "replace" }` is passed.
- *
  * The `const` type parameter keeps literal types without requiring `as const` at the call site. The constraint is
- * `ReadonlyDeep` so readonly arrays/objects (e.g. from `as const`) are accepted, and the result is `WritableDeep` so it
- * stays assignable to the tools' own (mutable) config types.
+ * `WithArrayOverrides<ReadonlyDeep<...>>` so readonly arrays/objects (e.g. from `as const`) are accepted and any
+ * array-typed key can alternatively take an ArrayOverride wrapper; the result is `WritableDeep` so it stays assignable
+ * to the tools' own (mutable) config types.
  */
-interface MergeConfigFn<UserConfig, BaseConfig> {
-  <const UserConfigToMerge extends ReadonlyDeep<UserConfig>>(userConfig: UserConfigToMerge, options: {
-    arrays: "replace";
-  }): MergeDeep<SimplifyDeep<WritableDeep<BaseConfig>>, SimplifyDeep<WritableDeep<UserConfigToMerge>>, {
-    arrayMergeMode: "replace";
-  }>;
-  <const UserConfigToMerge extends ReadonlyDeep<UserConfig>>(userConfig: UserConfigToMerge, options?: {
-    arrays?: "merge";
-  }): MergeDeep<SimplifyDeep<WritableDeep<BaseConfig>>, SimplifyDeep<WritableDeep<UserConfigToMerge>>, {
-    arrayMergeMode: "spread";
-  }>;
-}
+type MergeConfigFn<UserConfig, BaseConfig> = <const UserConfigToMerge extends WithArrayOverrides<ReadonlyDeep<UserConfig>>>(userConfig: UserConfigToMerge) => MergedConfig<BaseConfig, UserConfigToMerge>;
 /**
  * The optional merge config function, where the `userConfig` argument is optional. - if `UserConfig` is not provided,
  * the return type is `BaseConfig` - if `UserConfig` is provided, the return type is the merged type of `BaseConfig` and
  * `UserConfig`.
  *
- * Note that this extends `MergeConfigFn`, so this type has both function signatures on it.
+ * CRITICAL: must stay a type-alias intersection (NOT `interface ... extends MergeConfigFn`): checking the
+ * interface-inheritance relation forces tsc to relate the no-arg signature's return type against the recursive
+ * `MergedConfig` type, which explodes to millions of type instantiations.
  */
-interface OptionalMergeConfigFn<UserConfig, BaseConfig> extends MergeConfigFn<UserConfig, BaseConfig> {
-  (): SimplifyDeep<WritableDeep<BaseConfig>>;
-}
+type OptionalMergeConfigFn<UserConfig, BaseConfig> = MergeConfigFn<UserConfig, BaseConfig> & (() => SimplifyDeep<WritableDeep<BaseConfig>>);
 //#endregion
 export { MergeConfigFn, OptionalMergeConfigFn };
 //# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","names":[],"sources":["../src/utils.ts"],"mappings":";;;;;;;;;;;;UA+BiB,cAAc,YAAY;SAClC,0BAA0B,aAAa,aAC5C,YAAY,mBACZ;IAAW;MACV,UACD,aAAa,aAAa,cAC1B,aAAa,aAAa;IACxB;;SAEG,0BAA0B,aAAa,aAC5C,YAAY,mBACZ;IAAY;MACX,UACD,aAAa,aAAa,cAC1B,aAAa,aAAa;IACxB;;;;;;;;;;UAYW,sBAAsB,YAAY,oBAAoB,cAAc,YAAY;MAC3F,aAAa,aAAa"}
+{"version":3,"file":"utils.d.ts","names":[],"sources":["../src/utils.ts"],"mappings":";;KAIK,kBAAkB;;;;;KAMlB;;;;;;;UAQK,cAAc,kCAAkC,aAAa,iBAAiB;WAC7E,OAAO;WACP,MAAM;;;KAiCZ,gBAAgB,KAAK;WAAqB;WAAoC,MAAM;WAC9E,kBAAkB;;;;;KASxB,mBAAmB,KAAK,+BACzB,IAAI,cAAc,KAClB,UAAU,cACR,IACA,sBACK,WAAW,IAAI,mBAAmB,EAAE,SACvC;;;;;;KAOH,kBAAkB,GAAG,qEAAqE,0CAEpF,kBAEP,uCAEE,UAAU,sBAER,mBACE,gBAAgB,kBACd;WAAqB;mCAGL,WAAW,IAAI,kBAAkB,EAAE,IAAI,yBAAwB;;KAOtF,wBAAwB,QAC1B,WAAW,KAAK,kBAAkB,EAAE,mBAAmB,YAAY,gBAAgB,EAAE,mBAClF,EAAE;WAAsB,aAAa;IACnC,YAEF,wBAAwB,EAAE;;KAI3B,wBAAwB,QAC1B,WAAW,KAAK,gBAAgB,EAAE,mBAC/B,EAAE;WAAsB;YAEtB,IACF,IAAI,EAAE,gCACN,EAAE,KACF,EAAE,WAAW,cACX,EAAE,KACF,gBAAgB,EAAE,mBAChB,EAAE;WAAsB,aAAa;IACnC,YAEF,EAAE,oBACA,wBAAwB,EAAE,MAC1B,EAAE;;;;;;;KAST,aAAa,YAAY,cAAc,UAC1C,UACE,aAAa,aAAa,cAC1B,aAAa,aAAa,wBAAwB;EAChD;IAEJ,aAAa,aAAa,wBAAwB;EAChD;;;;;;;;;;KAWQ,cAAc,YAAY,qBAC9B,0BAA0B,mBAAmB,aAAa,cAEhE,YAAY,sBACT,aAAa,YAAY;;;;;;;;;;KAWlB,sBAAsB,YAAY,cAAc,cAAc,YAAY,qBAC7E,aAAa,aAAa"}

package/dist/utils.js

@@ -1,15 +1,32 @@
-import { cloneDeep, mergeWith } from "es-toolkit";
+import { cloneDeep, isPlainObject, mergeWith } from "es-toolkit";
 //#region src/utils.ts
-/** A wrapper around es-toolkit's `mergeWith` with a custom merge function that concatenates or replaces arrays. */
-const merge = (target, source, arrays) => mergeWith(target, source, (objValue, srcValue) => {
+/** Runtime wrapper check, mirrored by IsArrayOverride: plain object with exactly the keys value (array) + mode. */
+const isArrayOverride = (v) => {
+	if (!isPlainObject(v)) return false;
+	if (Object.keys(v).length !== 2) return false;
+	const { value } = v;
+	const { mode } = v;
+	return Array.isArray(value) && (mode === "merge" || mode === "replace");
+};
+/**
+* A wrapper around es-toolkit's `mergeWith` with a custom merge function that concatenates arrays, honoring per-key
+* ArrayOverride wrappers. Wrapper interception must come first: the default path would deep-merge the wrapper as a
+* plain object.
+*/
+const merge = (target, source) => mergeWith(target, source, (objValue, srcValue) => {
+	if (isArrayOverride(srcValue)) {
+		const { value: userArray, mode } = srcValue;
+		if (!Array.isArray(objValue)) return userArray;
+		return mode === "merge" ? [...objValue, ...userArray] : userArray;
+	}
 	if (!Array.isArray(objValue)) return;
 	if (!Array.isArray(srcValue)) return srcValue;
 	const baseArray = objValue;
 	const userArray = srcValue;
-	return arrays === "merge" ? [...baseArray, ...userArray] : userArray;
+	return [...baseArray, ...userArray];
 });
 /**
-* Creates a config merge function with proper type overloads for merging with a base config.
+* Creates a config merge function with proper types for merging with a base config.
 *
 * `UserConfig` is not inferrable, so both type arguments must be passed explicitly. Returning the exact
 * `OptionalMergeConfigFn` instantiation (instead of relating a looser type to an annotation at the export site) keeps
@@ -17,9 +34,9 @@ const merge = (target, source, arrays) => mergeWith(target, source, (objValue, s
 * limit on large configs like tsdown's.
 */
 const createMergeConfigFn = (baseConfig) => {
-	const mergeConfigFn = (userConfig, options) => {
+	const mergeConfigFn = (userConfig) => {
 		if (userConfig === void 0) return cloneDeep(baseConfig);
-		return merge(cloneDeep(baseConfig), cloneDeep(userConfig), options?.arrays ?? "merge");
+		return merge(cloneDeep(baseConfig), cloneDeep(userConfig));
 	};
 	return mergeConfigFn;
 };

package/dist/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","names":[],"sources":["../src/utils.ts"],"sourcesContent":["import { cloneDeep, mergeWith } from \"es-toolkit\"\nimport type { MergeDeep, ReadonlyDeep, WritableDeep, SimplifyDeep } from \"type-fest\"\n\ntype AnyObj = object\n\n/**\n * How arrays in the user config are combined with arrays in the base config. - `\"merge\"` (default): the user array is\n * appended to the base array - `\"replace\"`: the user array is used as-is\n */\ntype ArrayMergeMode = \"merge\" | \"replace\"\n\n/** A wrapper around es-toolkit's `mergeWith` with a custom merge function that concatenates or replaces arrays. */\nconst merge = <T extends AnyObj, S extends AnyObj>(target: T, source: S, arrays: ArrayMergeMode): T & S =>\n  mergeWith(target, source, (objValue: unknown, srcValue: unknown) => {\n    if (!Array.isArray(objValue)) return\n    if (!Array.isArray(srcValue)) return srcValue\n    const baseArray: unknown[] = objValue\n    const userArray: unknown[] = srcValue\n    return arrays === \"merge\" ? [...baseArray, ...userArray] : userArray\n  })\n\n/**\n * The merge config function, where the `UserConfig` passed in is merged with `BaseConfig`.\n *\n * Each `arrays` mode gets its own overload so the return type's `arrayMergeMode` matches the runtime behavior. The\n * `\"replace\"` overload comes first so it wins overload resolution when `{ arrays: \"replace\" }` is passed.\n *\n * The `const` type parameter keeps literal types without requiring `as const` at the call site. The constraint is\n * `ReadonlyDeep` so readonly arrays/objects (e.g. from `as const`) are accepted, and the result is `WritableDeep` so it\n * stays assignable to the tools' own (mutable) config types.\n */\nexport interface MergeConfigFn<UserConfig, BaseConfig> {\n  <const UserConfigToMerge extends ReadonlyDeep<UserConfig>>(\n    userConfig: UserConfigToMerge,\n    options: { arrays: \"replace\" },\n  ): MergeDeep<\n    SimplifyDeep<WritableDeep<BaseConfig>>,\n    SimplifyDeep<WritableDeep<UserConfigToMerge>>,\n    { arrayMergeMode: \"replace\" }\n  >\n  <const UserConfigToMerge extends ReadonlyDeep<UserConfig>>(\n    userConfig: UserConfigToMerge,\n    options?: { arrays?: \"merge\" },\n  ): MergeDeep<\n    SimplifyDeep<WritableDeep<BaseConfig>>,\n    SimplifyDeep<WritableDeep<UserConfigToMerge>>,\n    { arrayMergeMode: \"spread\" }\n  >\n  // Instead of returning `BaseConfig & UserConfig` (from `merge`), return a more friendly type using `MergeDeep`\n}\n\n/**\n * The optional merge config function, where the `userConfig` argument is optional. - if `UserConfig` is not provided,\n * the return type is `BaseConfig` - if `UserConfig` is provided, the return type is the merged type of `BaseConfig` and\n * `UserConfig`.\n *\n * Note that this extends `MergeConfigFn`, so this type has both function signatures on it.\n */\nexport interface OptionalMergeConfigFn<UserConfig, BaseConfig> extends MergeConfigFn<UserConfig, BaseConfig> {\n  (): SimplifyDeep<WritableDeep<BaseConfig>>\n}\n\n/**\n * Creates a config merge function with proper type overloads for merging with a base config.\n *\n * `UserConfig` is not inferrable, so both type arguments must be passed explicitly. Returning the exact\n * `OptionalMergeConfigFn` instantiation (instead of relating a looser type to an annotation at the export site) keeps\n * tsc from eagerly evaluating the deep-mapped types over the full config type, which blows the instantiation depth\n * limit on large configs like tsdown's.\n */\nexport const createMergeConfigFn = <UserConfig extends AnyObj, BaseConfig extends ReadonlyDeep<UserConfig>>(\n  baseConfig: BaseConfig,\n): OptionalMergeConfigFn<UserConfig, BaseConfig> => {\n  // We don't care about the specific type of userConfig here because we assert mergeConfigFn as the correct type below\n  const mergeConfigFn = (userConfig?: AnyObj, options?: { arrays?: ArrayMergeMode }) => {\n    // Return a clone so consumers can't mutate the shared base config\n    // oxlint-disable-next-line unicorn/prefer-structured-clone - structuredClone does not properly clone functions\n    if (userConfig === undefined) return cloneDeep(baseConfig)\n    // Clone both target and source so we never mutate the original objects\n    // oxlint-disable-next-line unicorn/prefer-structured-clone - structuredClone does not properly clone functions\n    return merge(cloneDeep(baseConfig), cloneDeep(userConfig), options?.arrays ?? \"merge\")\n  }\n\n  // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n  return mergeConfigFn as OptionalMergeConfigFn<UserConfig, BaseConfig>\n}\n"],"mappings":";;;AAYA,MAAM,SAA6C,QAAW,QAAW,WACvE,UAAU,QAAQ,SAAS,UAAmB,aAAsB;CAClE,IAAI,CAAC,MAAM,QAAQ,QAAQ,GAAG;CAC9B,IAAI,CAAC,MAAM,QAAQ,QAAQ,GAAG,OAAO;CACrC,MAAM,YAAuB;CAC7B,MAAM,YAAuB;CAC7B,OAAO,WAAW,UAAU,CAAC,GAAG,WAAW,GAAG,SAAS,IAAI;AAC7D,CAAC;;;;;;;;;AAmDH,MAAa,uBACX,eACkD;CAElD,MAAM,iBAAiB,YAAqB,YAA0C;EAGpF,IAAI,eAAe,KAAA,GAAW,OAAO,UAAU,UAAU;EAGzD,OAAO,MAAM,UAAU,UAAU,GAAG,UAAU,UAAU,GAAG,SAAS,UAAU,OAAO;CACvF;CAGA,OAAO;AACT"}
+{"version":3,"file":"utils.js","names":["baseArray"],"sources":["../src/utils.ts"],"sourcesContent":["import { cloneDeep, isPlainObject, mergeWith } from \"es-toolkit\"\nimport type { MergeDeep, ReadonlyDeep, WritableDeep, SimplifyDeep } from \"type-fest\"\n\ntype AnyObj = object\ntype AnyFunction = (...args: never[]) => unknown\n\n/**\n * How a wrapped user array is combined with the base array. - `\"merge\"` (the default for plain arrays): the user array\n * is appended to the base array - `\"replace\"`: the user array is used as-is\n */\ntype ArrayMergeMode = \"merge\" | \"replace\"\n\n/**\n * A per-key array override. Wherever a config key takes an array, `{ value: [...], mode: \"merge\" | \"replace\" }` may be\n * passed instead; `mode` controls how that key's array combines with the base config's. The wrapper never appears in\n * the merged result. A config value that is exactly this shape is always consumed as a wrapper; an object with extra\n * keys is treated as a plain config object.\n */\ninterface ArrayOverride<Value extends readonly unknown[], Mode extends ArrayMergeMode = ArrayMergeMode> {\n  readonly value: Value\n  readonly mode: Mode\n}\n\n/** Runtime wrapper check, mirrored by IsArrayOverride: plain object with exactly the keys value (array) + mode. */\nconst isArrayOverride = (v: unknown): v is { value: unknown[]; mode: ArrayMergeMode } => {\n  if (!isPlainObject(v)) return false\n  if (Object.keys(v).length !== 2) return false\n  const { value } = v\n  const { mode } = v\n  return Array.isArray(value) && (mode === \"merge\" || mode === \"replace\")\n}\n\n/**\n * A wrapper around es-toolkit's `mergeWith` with a custom merge function that concatenates arrays, honoring per-key\n * ArrayOverride wrappers. Wrapper interception must come first: the default path would deep-merge the wrapper as a\n * plain object.\n */\nconst merge = <T extends AnyObj, S extends AnyObj>(target: T, source: S): T & S =>\n  mergeWith(target, source, (objValue: unknown, srcValue: unknown) => {\n    if (isArrayOverride(srcValue)) {\n      const { value: userArray, mode } = srcValue\n      if (!Array.isArray(objValue)) return userArray\n      const baseArray: unknown[] = objValue\n      return mode === \"merge\" ? [...baseArray, ...userArray] : userArray\n    }\n    if (!Array.isArray(objValue)) return\n    if (!Array.isArray(srcValue)) return srcValue\n    const baseArray: unknown[] = objValue\n    const userArray: unknown[] = srcValue\n    return [...baseArray, ...userArray]\n  })\n\n/** True only when T is exactly the wrapper shape (keys value + mode, nothing else), mirroring isArrayOverride. */\ntype IsArrayOverride<T> = T extends { readonly value: readonly unknown[]; readonly mode: ArrayMergeMode }\n  ? [keyof T] extends [keyof ArrayOverride<readonly unknown[]>]\n    ? true\n    : false\n  : false\n\n/**\n * For every array-typed value in T, additionally allow `{ value: <that array type>, mode: ArrayMergeMode }`.\n * Distributes over unions, does not recurse into array elements, and leaves functions/primitives alone.\n */\ntype WithArrayOverrides<T> = T extends readonly unknown[]\n  ? T | ArrayOverride<T>\n  : T extends AnyFunction\n    ? T\n    : T extends object\n      ? { [K in keyof T]: WithArrayOverrides<T[K]> }\n      : T\n\n/**\n * True if T contains (at any object depth, not inside arrays) a replace-mode wrapper. Depth is a recursion budget: when\n * a call fails the generic constraint, this type runs over the full constraint (the whole tool config type), and the\n * eager `{ ... }[keyof T]` walk would hit TS2615 on circular types in it (e.g. Console) and bury the real error.\n */\ntype HasReplaceWrapper<T, Depth extends readonly unknown[] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]> = Depth extends readonly [\n  unknown,\n  ...infer RemainingDepth,\n]\n  ? T extends readonly unknown[]\n    ? false\n    : T extends AnyFunction\n      ? false\n      : T extends object\n        ? IsArrayOverride<T> extends true\n          ? T extends { readonly mode: \"replace\" }\n            ? true\n            : false\n          : true extends { [K in keyof T]: HasReplaceWrapper<T[K], RemainingDepth> }[keyof T]\n            ? true\n            : false\n        : false\n  : false\n\n/** Keep only the key paths whose leaf is a replace-mode wrapper; unwrap those leaves to their `value` type. */\ntype DeepPickReplaceWrappers<T> = {\n  [K in keyof T as HasReplaceWrapper<T[K]> extends true ? K : never]: IsArrayOverride<T[K]> extends true\n    ? T[K] extends { readonly value: infer V extends readonly unknown[] }\n      ? V\n      : never\n    : DeepPickReplaceWrappers<T[K]>\n}\n\n/** Drop key paths whose leaf is a replace-mode wrapper; unwrap merge-mode wrappers in place. */\ntype DeepDropReplaceWrappers<T> = {\n  [K in keyof T as IsArrayOverride<T[K]> extends true\n    ? T[K] extends { readonly mode: \"replace\" }\n      ? never\n      : K\n    : K]: T[K] extends readonly unknown[]\n    ? T[K]\n    : T[K] extends AnyFunction\n      ? T[K]\n      : IsArrayOverride<T[K]> extends true\n        ? T[K] extends { readonly value: infer V extends readonly unknown[] }\n          ? V\n          : never\n        : T[K] extends object\n          ? DeepDropReplaceWrappers<T[K]>\n          : T[K]\n}\n\n/**\n * The merged result type, exact for per-key overrides: pass 1 merges the user config minus replace-wrapper keys\n * (unwrapping merge-mode wrappers, which behave like plain arrays) with array spreading; pass 2 merges the unwrapped\n * replace-wrapper keys with array replacement. Instead of returning `BaseConfig & UserConfig` (from `merge`), this is a\n * more friendly type via `MergeDeep`.\n */\ntype MergedConfig<BaseConfig, UserConfig> = MergeDeep<\n  MergeDeep<\n    SimplifyDeep<WritableDeep<BaseConfig>>,\n    SimplifyDeep<WritableDeep<DeepDropReplaceWrappers<UserConfig>>>,\n    { arrayMergeMode: \"spread\" }\n  >,\n  SimplifyDeep<WritableDeep<DeepPickReplaceWrappers<UserConfig>>>,\n  { arrayMergeMode: \"replace\" }\n>\n\n/**\n * The merge config function, where the `UserConfig` passed in is merged with `BaseConfig`.\n *\n * The `const` type parameter keeps literal types without requiring `as const` at the call site. The constraint is\n * `WithArrayOverrides<ReadonlyDeep<...>>` so readonly arrays/objects (e.g. from `as const`) are accepted and any\n * array-typed key can alternatively take an ArrayOverride wrapper; the result is `WritableDeep` so it stays assignable\n * to the tools' own (mutable) config types.\n */\nexport type MergeConfigFn<UserConfig, BaseConfig> = <\n  const UserConfigToMerge extends WithArrayOverrides<ReadonlyDeep<UserConfig>>,\n>(\n  userConfig: UserConfigToMerge,\n) => MergedConfig<BaseConfig, UserConfigToMerge>\n\n/**\n * The optional merge config function, where the `userConfig` argument is optional. - if `UserConfig` is not provided,\n * the return type is `BaseConfig` - if `UserConfig` is provided, the return type is the merged type of `BaseConfig` and\n * `UserConfig`.\n *\n * CRITICAL: must stay a type-alias intersection (NOT `interface ... extends MergeConfigFn`): checking the\n * interface-inheritance relation forces tsc to relate the no-arg signature's return type against the recursive\n * `MergedConfig` type, which explodes to millions of type instantiations.\n */\nexport type OptionalMergeConfigFn<UserConfig, BaseConfig> = MergeConfigFn<UserConfig, BaseConfig> &\n  (() => SimplifyDeep<WritableDeep<BaseConfig>>)\n\n/**\n * Creates a config merge function with proper types for merging with a base config.\n *\n * `UserConfig` is not inferrable, so both type arguments must be passed explicitly. Returning the exact\n * `OptionalMergeConfigFn` instantiation (instead of relating a looser type to an annotation at the export site) keeps\n * tsc from eagerly evaluating the deep-mapped types over the full config type, which blows the instantiation depth\n * limit on large configs like tsdown's.\n */\nexport const createMergeConfigFn = <UserConfig extends AnyObj, BaseConfig extends ReadonlyDeep<UserConfig>>(\n  baseConfig: BaseConfig,\n): OptionalMergeConfigFn<UserConfig, BaseConfig> => {\n  // We don't care about the specific type of userConfig here because we assert mergeConfigFn as the correct type below\n  const mergeConfigFn = (userConfig?: AnyObj) => {\n    // Return a clone so consumers can't mutate the shared base config\n    // oxlint-disable-next-line unicorn/prefer-structured-clone - structuredClone does not properly clone functions\n    if (userConfig === undefined) return cloneDeep(baseConfig)\n    // Clone both target and source so we never mutate the original objects\n    // oxlint-disable-next-line unicorn/prefer-structured-clone - structuredClone does not properly clone functions\n    return merge(cloneDeep(baseConfig), cloneDeep(userConfig))\n  }\n\n  // CRITICAL: two-step assertion required: a direct cast makes tsc run a comparability check relating the\n  // implementation signature against the recursive MergedConfig type (millions of instantiations).\n  // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n  return mergeConfigFn as unknown as OptionalMergeConfigFn<UserConfig, BaseConfig>\n}\n"],"mappings":";;;AAwBA,MAAM,mBAAmB,MAAgE;CACvF,IAAI,CAAC,cAAc,CAAC,GAAG,OAAO;CAC9B,IAAI,OAAO,KAAK,CAAC,CAAC,CAAC,WAAW,GAAG,OAAO;CACxC,MAAM,EAAE,UAAU;CAClB,MAAM,EAAE,SAAS;CACjB,OAAO,MAAM,QAAQ,KAAK,MAAM,SAAS,WAAW,SAAS;AAC/D;;;;;;AAOA,MAAM,SAA6C,QAAW,WAC5D,UAAU,QAAQ,SAAS,UAAmB,aAAsB;CAClE,IAAI,gBAAgB,QAAQ,GAAG;EAC7B,MAAM,EAAE,OAAO,WAAW,SAAS;EACnC,IAAI,CAAC,MAAM,QAAQ,QAAQ,GAAG,OAAO;EAErC,OAAO,SAAS,UAAU,CAAC,GAAGA,UAAW,GAAG,SAAS,IAAI;CAC3D;CACA,IAAI,CAAC,MAAM,QAAQ,QAAQ,GAAG;CAC9B,IAAI,CAAC,MAAM,QAAQ,QAAQ,GAAG,OAAO;CACrC,MAAM,YAAuB;CAC7B,MAAM,YAAuB;CAC7B,OAAO,CAAC,GAAG,WAAW,GAAG,SAAS;AACpC,CAAC;;;;;;;;;AA2HH,MAAa,uBACX,eACkD;CAElD,MAAM,iBAAiB,eAAwB;EAG7C,IAAI,eAAe,KAAA,GAAW,OAAO,UAAU,UAAU;EAGzD,OAAO,MAAM,UAAU,UAAU,GAAG,UAAU,UAAU,CAAC;CAC3D;CAKA,OAAO;AACT"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adamhl8/configs",
-  "version": "1.6.0",
+  "version": "1.6.1",
   "description": "My shared configs for TS projects",
   "homepage": "https://github.com/adamhl8/configs",
   "bugs": {