@venizia/dev-configs 0.3.0 → 0.3.1-1

package/README.md

@@ -6,12 +6,12 @@ it as a dev dependency in an application that wants the same rules.
 ## Install
 
 ```bash
-bun add -d @venizia/dev-configs oxlint oxlint-tsgolint oxfmt eslint jiti typescript
+bun add -d @venizia/dev-configs oxlint oxlint-tsgolint oxfmt eslint typescript
 ```
 
 `oxlint` (>=1.88.0), `oxlint-tsgolint` (>=7.0.2004), `oxfmt` (>=0.73.0), `eslint` (9 or 10),
-`jiti` (>=2.2), `prettier` (3) and `typescript` (5 or 6) are optional peers. Install only the tools
-you use. ESLint loads an `eslint.config.mts` through `jiti`, so a project with one needs it. A
+`prettier` (3) and `typescript` (5 or 6) are optional peers. Install only the tools you use. Keep the
+ESLint config `.mjs`: a TypeScript one (`.mts`) makes ESLint require `jiti`, one more dependency. A
 project that still runs ESLint and Prettier installs `eslint prettier` and skips the oxc tools.
 
 ## Use it
@@ -35,15 +35,15 @@ export default defineConfig(oxfmtConfigs);
 ```
 
 ```typescript
-// .configs/eslint.config.mts - the one rule oxlint cannot run yet
-import { namingConventionConfigs } from '@venizia/dev-configs/linters';
+// .configs/eslint.config.mjs - what oxlint cannot run: naming convention + house rules
+import { houseConfigs } from '@venizia/dev-configs/linters';
 
-export default namingConventionConfigs;
+export default houseConfigs;
 ```
 
 ```bash
 oxlint -c .configs/oxlint.config.mts --deny-warnings
-eslint -c .configs/eslint.config.mts .
+eslint -c .configs/eslint.config.mjs .
 oxfmt -c .configs/oxfmt.config.mts --check "**/*.{ts,tsx,mts,js,mjs}"
 ```
 
@@ -58,25 +58,53 @@ there.
     "outDir": "dist",
     "rootDir": "src",
     "experimentalDecorators": true,
-    "emitDecoratorMetadata": true
+    "useDefineForClassFields": false
   },
   "include": ["src"]
 }
 ```
 
-## Declare the decorator flag in your own tsconfig
+The two options in `compilerOptions` repeat the base on purpose - see
+[Restate the runtime options](#restate-the-runtime-options-in-your-own-tsconfig).
 
-The base config sets `experimentalDecorators`. But Bun can miss a flag inherited through `extends`
-when it runs your source. Parameter decorators are then dropped with no error, and an `@inject`
-value is `undefined` at run time.
+### Browser and React projects
 
-Declare `experimentalDecorators: true` in your application's own `tsconfig.json`, as in the example
-earlier. Every IGNIS example does.
+The presets above target a Bun or Node backend. Code that runs in a browser swaps each one for its
+browser version. A React project swaps it for the React version, which builds on the browser one.
+
+| Tool | Backend | Browser | React |
+| :--- | :--- | :--- | :--- |
+| oxlint | `oxlintConfigs` | `BrowserOxlintConfigs.create()` | `ReactOxlintConfigs.create()` |
+| oxfmt | `oxfmtConfigs` | `browserOxfmtConfigs` | `browserOxfmtConfigs` |
+| ESLint | `houseConfigs` | `houseConfigs` | `reactHouseConfigs` |
+| tsconfig | `tsconfig.common.json` | `tsconfig.browser.json` | `tsconfig.react.json` |
+
+## Restate the runtime options in your own tsconfig
+
+Bun ignores an `extends` that names a package. With `"extends": "@venizia/dev-configs/tsconfig.common.json"`,
+`bun run` and `bun test` see none of the preset's options - even one level deep (measured on Bun 1.4.2).
+Bun then compiles TC39 decorators: a parameter decorator such as `@inject` is dropped with no error,
+and a method decorator such as `@provide` receives the wrong arguments. Class fields get define
+semantics, while the `tsc` build uses assign semantics.
+
+`tsc` follows the whole chain, so typecheck and build stay green. Only what Bun runs diverges, which
+is why nothing reports it.
+
+In every `tsconfig.json` that Bun runs - an application, a package whose tests run under
+`bun test`, a browser or React project tested with Bun - restate the options that change the emitted
+code:
+
+```json
+"experimentalDecorators": true,
+"useDefineForClassFields": false
+```
+
+Every IGNIS package and example does.
 
 | Flag | Base value | Why |
 | :--- | :--- | :--- |
 | `experimentalDecorators` | `true` | `@inject`, `@controller`, `@repository` and the other decorators need it |
-| `emitDecoratorMetadata` | `true` | Optional. IGNIS reads `design:paramtypes` once, to validate a `@repository` constructor, and skips the check when the metadata is absent |
+| `emitDecoratorMetadata` | `true` | Optional - restate it only if your code reads `design:*` metadata. IGNIS reads `design:paramtypes` once, to validate a `@repository` constructor, and skips the check when the metadata is absent. Under Bun it turns an interface-typed constructor parameter into a runtime import (`Export named 'X' not found`), so import such names with `import type`; `tsc --noEmit --isolatedModules` (TS1272) finds most of them, loading `src/index.ts` under Bun the rest |
 | `useDefineForClassFields` | `false` | Class fields are assigned, not defined, so a subclass field initializer does not shadow a value the base constructor set |
 
 ## Entry points
@@ -85,10 +113,13 @@ earlier. Every IGNIS example does.
 | :--- | :--- |
 | `@venizia/dev-configs` | Everything below, re-exported |
 | `@venizia/dev-configs/compilers` | `BunCompiler` |
-| `@venizia/dev-configs/formatters` | `oxfmtConfigs`, `prettierConfigs` |
-| `@venizia/dev-configs/linters` | `oxlintConfigs`, `namingConventionConfigs`, `eslintConfigs`, `ReactEslintConfigs`, the rule classes and their types |
+| `@venizia/dev-configs/formatters` | `oxfmtConfigs`, `browserOxfmtConfigs`, `prettierConfigs` |
+| `@venizia/dev-configs/testing` | `rejectionOf`, `expectRejection` - test helpers for a promise that must reject (imports `bun:test`; tests only) |
+| `@venizia/dev-configs/linters` | `oxlintConfigs`, `OxlintConfigs`, `BrowserOxlintConfigs`, `ReactOxlintConfigs`, `namingConventionConfigs`, `reactNamingConventionConfigs`, `eslintConfigs`, `ReactEslintConfigs`, the rule classes and their types |
 | `@venizia/dev-configs/tsconfig.base.json` | Target and lib ES2025, `module` Node16, strict mode with `noImplicitAny`, `strictPropertyInitialization` and `useUnknownInCatchVariables` off, `noEmitOnError`, tests excluded |
 | `@venizia/dev-configs/tsconfig.common.json` | Extends the base and switches `module` and `moduleResolution` to `nodenext` |
+| `@venizia/dev-configs/tsconfig.browser.json` | Extends the base for a browser library built with a bundler: `module` ESNext, `moduleResolution` bundler, lib ES2025 + `DOM` + `DOM.Iterable`, `types: []` so no Bun types reach `dist` |
+| `@venizia/dev-configs/tsconfig.react.json` | Extends `tsconfig.browser.json` and sets `jsx: react-jsx` |
 
 ## What each config sets
 
@@ -96,7 +127,10 @@ earlier. Every IGNIS example does.
 
 `oxlintConfigs` (type `OxlintConfig`) is a static port of the `eslintConfigs` rules, generated with
 `@oxlint/migrate`. It enables the `typescript` and `unicorn` plugins and type-aware linting, so it needs
-`oxlint-tsgolint`.
+`oxlint-tsgolint`. It also enforces `typescript/consistent-type-imports` (`prefer: type-imports`,
+`fixStyle: inline-type-imports`; `import('pkg').T` annotations stay allowed): a value import of a type
+becomes a runtime import when Bun runs a decorated class's source, and loading fails with
+`Export named 'X' not found`. `oxlint --fix` rewrites them.
 
 Not ported:
 
@@ -107,6 +141,35 @@ Not ported:
 | `no-invalid-this` | `noImplicitThis` in `tsconfig.base.json` covers it |
 | `n/prefer-node-protocol` | Maps to `unicorn/prefer-node-protocol` |
 
+#### lenientFallback
+
+`prefer-nullish-coalescing` flags `||` on any nullable left side, so `opts.name || 'guest'` fails when
+`name` is `string | undefined`. That is the default: `||` also swallows a real `''` or `0`. A project
+where `''` and `0` fall back on purpose opts out in one line:
+
+```ts
+// .configs/oxlint.config.mts
+import { defineConfig } from 'oxlint';
+import { OxlintConfigs } from '@venizia/dev-configs/linters';
+
+export default defineConfig(OxlintConfigs.create({ lenientFallback: true }));
+```
+
+It allows `||` where the left side is a string or a number, and still flags it on objects and
+booleans. `BrowserOxlintConfigs.create()` and `ReactOxlintConfigs.create()` take the same option.
+`OxlintConfigs.create()` with no option is `oxlintConfigs`.
+
+### houseConfigs and the house rules
+
+`houseConfigs` is `namingConventionConfigs` plus the house rules oxlint cannot express;
+`reactHouseConfigs` is the same over `reactNamingConventionConfigs`. The rules ship as the ESLint plugin
+`houseEslintPlugin`, registered as `venizia`:
+
+| Class | Rule | Default | What it enforces |
+| :--- | :--- | :--- | :--- |
+| `MaxParamsOwnRule` | `venizia/max-params-own` | `build({ max: 5 })` | A function we write takes at most `max` positional parameters. Not counted: an inline callback passed to a call or a JSX prop, a signature a declared type fixes, a constructor whose parameters are all `@inject`. A hook callback counts. |
+| `NoNewErrorRule` | `venizia/no-new-error` | `error` | Throw through `getError` (or an `ApplicationError`), never `new Error(...)` / `Error(...)`. Off in tests. |
+
 ### namingConventionConfigs
 
 `namingConventionConfigs` (type `Linter.Config[]`) sets only `@typescript-eslint/naming-convention`, with
@@ -122,11 +185,11 @@ entry with the IGNIS defaults. Every `severity` defaults to `'error'`.
 | Class | Rule name | `build` options (default) |
 | :--- | :--- | :--- |
 | `EqeqeqRule` | `eqeqeq` | `mode`: `'always' \| 'smart'` (`'smart'`) |
-| `NoUnusedVarsRule` | `no-unused-vars` | `vars` (`'all'`), `args` (`'none'`), `ignoreRestSiblings` (`false`) |
+| `NoUnusedVarsRule` | `no-unused-vars` | `vars` (`'all'`), `args` (`'none'`), `ignoreRestSiblings` (`false`), `argsIgnorePattern` / `varsIgnorePattern` / `caughtErrorsIgnorePattern` / `destructuredArrayIgnorePattern` (none) |
 | `SwitchCaseBracesRule` | `unicorn/switch-case-braces` | `mode`: `'always' \| 'avoid'` (`'always'`) |
 | `NoRestrictedImportsRule` | `no-restricted-imports` | `extraPaths`: `IRestrictedImportPath[]` (none), added to `PATHS` (lodash) |
 | `NoRestrictedPropertiesRule` | `no-restricted-properties` | `extraProperties`: `IRestrictedProperty[]` (none), added to `SECURE_CONTEXT` (`crypto.randomUUID`) |
-| `PreferNullishCoalescingRule` | `typescript/prefer-nullish-coalescing` | `ignoreConditionalTests`, `ignoreMixedLogicalExpressions`, `ignoreTernaryTests` (oxlint's own defaults) |
+| `PreferNullishCoalescingRule` | `typescript/prefer-nullish-coalescing` | `ignoreConditionalTests`, `ignoreMixedLogicalExpressions`, `ignoreTernaryTests`, `ignorePrimitives` (`{ string: true, ... }`; oxlint's own defaults) |
 | `NamingConventionRule` | `@typescript-eslint/naming-convention` | `extraSelectors`: `TNamingSelector[]` (none), added after `SELECTORS` |
 
 Types: `TRuleSeverity`, `TOxlintRuleEntry`, `TNamingSelector`, `IRestrictedImportPath`.
@@ -169,6 +232,13 @@ matches. oxfmt differs from Prettier on long union types, which it breaks with a
 | `bracketSpacing` | `true` |
 | `arrowParens` | `'avoid'` |
 
+`browserOxfmtConfigs` is `oxfmtConfigs` with two changes for browser and React code:
+
+| Setting | Value | Effect |
+| :--- | :--- | :--- |
+| `arrowParens` | `'always'` | `(x) => x` instead of `x => x` |
+| `bracketSameLine` | `true` | The closing `>` of a multi-line JSX element stays on its last attribute line, which keeps JSX diffs small |
+
 ### eslintConfigs
 
 `eslintConfigs` keeps its shape and resolves to the same rules as before, but is now owned here instead
@@ -205,7 +275,7 @@ export default [
 | React correctness (`jsx-key`, `no-children-prop`, `no-deprecated`, ... - 14 rules) | `error`, `.jsx`/`.tsx` |
 | `jsx-a11y` basics (`alt-text`, `aria-props`, `aria-role`, ... - 9 rules) | `error`, `.jsx`/`.tsx` |
 | `react-hooks/rules-of-hooks` / `exhaustive-deps` | `error`, every source file |
-| `@typescript-eslint/consistent-type-imports` | `['error', { prefer: 'type-imports' }]` |
+| `@typescript-eslint/consistent-type-imports` | `['error', { prefer: 'type-imports', fixStyle: 'inline-type-imports', disallowTypeAnnotations: false }]` |
 | `naming-convention` | the base rule, plus PascalCase functions (`function App()`), `.jsx`/`.tsx` |
 | `no-restricted-properties` | `NoRestrictedPropertiesRule.build()` - bans `crypto.randomUUID` |
 
@@ -218,8 +288,22 @@ Rules the automatic JSX runtime or `tsc` already enforce (`react-in-jsx-scope`,
 - `reactVersion` defaults to `'detect'`. Under ESLint 10, eslint-plugin-react 7 cannot detect it and
   aborts - pass the version: `create({ plugins, reactVersion: '19.2' })`.
 - In an `eslint.config.ts`, `eslint-plugin-jsx-a11y` needs `@types/eslint-plugin-jsx-a11y`.
-- `consistent-type-imports` keeps the default `fixStyle`; a codebase that prefers
-  `inline-type-imports` sets it on top.
+- `consistent-type-imports` uses `fixStyle: inline-type-imports`, the same as the base preset.
+
+### BrowserOxlintConfigs
+
+`BrowserOxlintConfigs.create()` is `oxlintConfigs` plus `NoRestrictedPropertiesRule.build()`. That
+rule bans `crypto.randomUUID`, which exists only in a secure context (https, localhost). On a
+plain-http origin or in a WebView, the method is `undefined`. Use this preset for browser code that
+does not use React.
+
+```ts
+// .configs/oxlint.config.mts
+import { defineConfig } from 'oxlint';
+import { BrowserOxlintConfigs } from '@venizia/dev-configs/linters';
+
+export default defineConfig(BrowserOxlintConfigs.create());
+```
 
 ### ReactOxlintConfigs and reactNamingConventionConfigs
 
@@ -233,16 +317,14 @@ import { ReactOxlintConfigs } from '@venizia/dev-configs/linters';
 
 export default defineConfig(ReactOxlintConfigs.create());
 
-// .configs/eslint.config.mts
+// .configs/eslint.config.mjs
 import { reactNamingConventionConfigs } from '@venizia/dev-configs/linters';
 
 export default reactNamingConventionConfigs;
 ```
 
-`ReactOxlintConfigs.create()` is `oxlintConfigs` plus the same rules as the ESLint table above, as
-strict as the base. `react/no-deprecated` is left out: oxlint has no port of it. `crypto.randomUUID`
-is banned because it exists only in a secure context (https, localhost), and is `undefined` on a
-plain-http origin or in a WebView.
+`ReactOxlintConfigs.create()` is `BrowserOxlintConfigs.create()` plus the same rules as the ESLint
+table above, as strict as the base. `react/no-deprecated` is left out: oxlint has no port of it.
 
 The presets start strict. An application that wants less overrides the rule after the preset:
 
@@ -256,8 +338,7 @@ export default defineConfig({
 ```
 
 `reactNamingConventionConfigs` is `namingConventionConfigs` plus PascalCase functions in `.jsx` and
-`.tsx` files. To ban `crypto.randomUUID` in a project without React, add
-`[NoRestrictedPropertiesRule.NAME]: NoRestrictedPropertiesRule.build()` to its rules.
+`.tsx` files.
 
 ### BunCompiler
 
@@ -273,7 +354,7 @@ await BunCompiler.compile({ entrypoint: './src/index.ts', outfile: './dist/app'
 ## Where it sits
 
 The root of the chain, with no IGNIS dependency: **dev-configs** -> inversion -> {filter, helpers}
--> {boot, kernel} -> connectors -> {core-worker, core-server} -> atlas.
+-> {boot, kernel} -> connectors -> {core-worker, core-server}.
 
 ## Links
 

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

@@ -1 +1 @@
-{"version":3,"file":"bun.d.ts","sourceRoot":"","sources":["../../src/compilers/bun.ts"],"names":[],"mappings":"AAIA,gHAAgH;AAChH,qBAAa,WAAW;IACtB;;;;OAIG;WACU,OAAO,CAClB,IAAI,GAAE;QACJ,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,OAAO,CAAC,EAAE,GAAG,CAAC,SAAS,EAAE,CAAC;KACtB,GACL,OAAO,CAAC,IAAI,CAAC;CAgCjB"}
+{"version":3,"file":"bun.d.ts","sourceRoot":"","sources":["../../src/compilers/bun.ts"],"names":[],"mappings":"AAIA,gHAAgH;AAChH,qBAAa,WAAW;IACtB;;;;OAIG;WACU,OAAO,CAClB,IAAI,GAAE;QACJ,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,OAAO,CAAC,EAAE,GAAG,CAAC,SAAS,EAAE,CAAC;KACtB,GACL,OAAO,CAAC,IAAI,CAAC;CAiCjB"}

package/dist/compilers/bun.js

@@ -28,6 +28,7 @@ class BunCompiler {
         if (!built.success) {
             // `getError` lives in `inversion`, which depends on `dev-configs` - importing it here would
             // create a circular workspace dependency, so a failed compile throws a plain `Error` instead.
+            // eslint-disable-next-line venizia/no-new-error -- getError would be a dev-configs -> inversion cycle
             throw new Error([
                 `[BunCompiler] compile failed for entrypoint "${entrypoint}":`,
                 ...built.logs.map(log => `[${log.level}] ${log.message}`),

package/dist/compilers/bun.js.map

@@ -1 +1 @@
-{"version":3,"file":"bun.js","sourceRoot":"","sources":["../../src/compilers/bun.ts"],"names":[],"mappings":";;;AAAA,MAAM,kBAAkB,GAAG,iBAAiB,CAAC;AAC7C,MAAM,eAAe,GAAG,YAAY,CAAC;AACrC,MAAM,sBAAsB,GAAG,eAAe,CAAC;AAE/C,gHAAgH;AAChH,MAAa,WAAW;IACtB;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,OAAO,CAClB,OAKI,EAAE;QAEN,MAAM,EACJ,UAAU,GAAG,kBAAkB,EAC/B,OAAO,GAAG,eAAe,EACzB,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,UAAU,IAAI,sBAAsB,EACrD,OAAO,GAAG,EAAE,GACb,GAAG,IAAI,CAAC;QAET,MAAM,KAAK,GAAG,MAAM,GAAG,CAAC,KAAK,CAAC;YAC5B,WAAW,EAAE,CAAC,UAAU,CAAC;YACzB,MAAM,EAAE,KAAK;YACb,MAAM,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE;YAC1C,SAAS,EAAE,QAAQ;YACnB,KAAK,EAAE,KAAK;YACZ,OAAO,EAAE;gBACP,MAAM,EAAE,MAAiC;gBACzC,OAAO;aACR;YACD,OAAO;SACR,CAAC,CAAC;QAEH,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;YACnB,4FAA4F;YAC5F,8FAA8F;YAC9F,MAAM,IAAI,KAAK,CACb;gBACE,gDAAgD,UAAU,IAAI;gBAC9D,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,GAAG,CAAC,KAAK,KAAK,GAAG,CAAC,OAAO,EAAE,CAAC;aAC1D,CAAC,IAAI,CAAC,IAAI,CAAC,CACb,CAAC;QACJ,CAAC;IACH,CAAC;CACF;AA7CD,kCA6CC"}
+{"version":3,"file":"bun.js","sourceRoot":"","sources":["../../src/compilers/bun.ts"],"names":[],"mappings":";;;AAAA,MAAM,kBAAkB,GAAG,iBAAiB,CAAC;AAC7C,MAAM,eAAe,GAAG,YAAY,CAAC;AACrC,MAAM,sBAAsB,GAAG,eAAe,CAAC;AAE/C,gHAAgH;AAChH,MAAa,WAAW;IACtB;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,OAAO,CAClB,OAKI,EAAE;QAEN,MAAM,EACJ,UAAU,GAAG,kBAAkB,EAC/B,OAAO,GAAG,eAAe,EACzB,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,UAAU,IAAI,sBAAsB,EACrD,OAAO,GAAG,EAAE,GACb,GAAG,IAAI,CAAC;QAET,MAAM,KAAK,GAAG,MAAM,GAAG,CAAC,KAAK,CAAC;YAC5B,WAAW,EAAE,CAAC,UAAU,CAAC;YACzB,MAAM,EAAE,KAAK;YACb,MAAM,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE;YAC1C,SAAS,EAAE,QAAQ;YACnB,KAAK,EAAE,KAAK;YACZ,OAAO,EAAE;gBACP,MAAM,EAAE,MAAiC;gBACzC,OAAO;aACR;YACD,OAAO;SACR,CAAC,CAAC;QAEH,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;YACnB,4FAA4F;YAC5F,8FAA8F;YAC9F,sGAAsG;YACtG,MAAM,IAAI,KAAK,CACb;gBACE,gDAAgD,UAAU,IAAI;gBAC9D,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,GAAG,CAAC,KAAK,KAAK,GAAG,CAAC,OAAO,EAAE,CAAC;aAC1D,CAAC,IAAI,CAAC,IAAI,CAAC,CACb,CAAC;QACJ,CAAC;IACH,CAAC;CACF;AA9CD,kCA8CC"}

package/dist/formatters/oxfmt.d.ts

@@ -11,4 +11,18 @@ import type { OxfmtConfig } from 'oxfmt';
  * ```
  */
 export declare const oxfmtConfigs: OxfmtConfig;
+/**
+ * `oxfmtConfigs` for browser and React code: arrow parameters always in parentheses (`(x) => x`),
+ * and the closing `>` of a multi-line JSX element on its last attribute line, which keeps JSX diffs
+ * small. `bracketSameLine` changes nothing outside JSX.
+ *
+ * ```ts
+ * // .configs/oxfmt.config.mts
+ * import { defineConfig } from 'oxfmt';
+ * import { browserOxfmtConfigs } from '@venizia/dev-configs/formatters';
+ *
+ * export default defineConfig(browserOxfmtConfigs);
+ * ```
+ */
+export declare const browserOxfmtConfigs: OxfmtConfig;
 //# sourceMappingURL=oxfmt.d.ts.map

package/dist/formatters/oxfmt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"oxfmt.d.ts","sourceRoot":"","sources":["../../src/formatters/oxfmt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AAEzC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY,EAAE,WAQ1B,CAAC"}
+{"version":3,"file":"oxfmt.d.ts","sourceRoot":"","sources":["../../src/formatters/oxfmt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AAEzC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY,EAAE,WAQ1B,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,mBAAmB,EAAE,WAIjC,CAAC"}

package/dist/formatters/oxfmt.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.oxfmtConfigs = void 0;
+exports.browserOxfmtConfigs = exports.oxfmtConfigs = void 0;
 /**
  * The oxfmt port of `prettierConfigs` - the same seven options, so the output matches Prettier's.
  *
@@ -21,4 +21,22 @@ exports.oxfmtConfigs = {
     arrowParens: 'avoid',
     semi: true,
 };
+/**
+ * `oxfmtConfigs` for browser and React code: arrow parameters always in parentheses (`(x) => x`),
+ * and the closing `>` of a multi-line JSX element on its last attribute line, which keeps JSX diffs
+ * small. `bracketSameLine` changes nothing outside JSX.
+ *
+ * ```ts
+ * // .configs/oxfmt.config.mts
+ * import { defineConfig } from 'oxfmt';
+ * import { browserOxfmtConfigs } from '@venizia/dev-configs/formatters';
+ *
+ * export default defineConfig(browserOxfmtConfigs);
+ * ```
+ */
+exports.browserOxfmtConfigs = {
+    ...exports.oxfmtConfigs,
+    arrowParens: 'always',
+    bracketSameLine: true,
+};
 //# sourceMappingURL=oxfmt.js.map

package/dist/formatters/oxfmt.js.map

@@ -1 +1 @@
-{"version":3,"file":"oxfmt.js","sourceRoot":"","sources":["../../src/formatters/oxfmt.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;GAUG;AACU,QAAA,YAAY,GAAgB;IACvC,cAAc,EAAE,IAAI;IACpB,WAAW,EAAE,IAAI;IACjB,UAAU,EAAE,GAAG;IACf,QAAQ,EAAE,CAAC;IACX,aAAa,EAAE,KAAK;IACpB,WAAW,EAAE,OAAO;IACpB,IAAI,EAAE,IAAI;CACX,CAAC"}
+{"version":3,"file":"oxfmt.js","sourceRoot":"","sources":["../../src/formatters/oxfmt.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;GAUG;AACU,QAAA,YAAY,GAAgB;IACvC,cAAc,EAAE,IAAI;IACpB,WAAW,EAAE,IAAI;IACjB,UAAU,EAAE,GAAG;IACf,QAAQ,EAAE,CAAC;IACX,aAAa,EAAE,KAAK;IACpB,WAAW,EAAE,OAAO;IACpB,IAAI,EAAE,IAAI;CACX,CAAC;AAEF;;;;;;;;;;;;GAYG;AACU,QAAA,mBAAmB,GAAgB;IAC9C,GAAG,oBAAY;IACf,WAAW,EAAE,QAAQ;IACrB,eAAe,EAAE,IAAI;CACtB,CAAC"}

package/dist/linters/browser.d.ts

@@ -0,0 +1,19 @@
+import type { OxlintConfig } from 'oxlint';
+import { type IOxlintPresetOptions } from './oxlint';
+/**
+ * `oxlintConfigs` for code that runs in a browser, React or not: the base rules plus the
+ * secure-context ban (`crypto.randomUUID` is `undefined` on a plain-http origin). Nothing in the base
+ * is relaxed. `ReactOxlintConfigs` builds on this preset. Takes the same options as `OxlintConfigs`.
+ *
+ * ```ts
+ * // .configs/oxlint.config.mts
+ * import { defineConfig } from 'oxlint';
+ * import { BrowserOxlintConfigs } from '@venizia/dev-configs/linters';
+ *
+ * export default defineConfig(BrowserOxlintConfigs.create());
+ * ```
+ */
+export declare class BrowserOxlintConfigs {
+    static create(opts?: IOxlintPresetOptions): OxlintConfig;
+}
+//# sourceMappingURL=browser.d.ts.map

package/dist/linters/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../src/linters/browser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAC3C,OAAO,EAAE,KAAK,oBAAoB,EAAiB,MAAM,UAAU,CAAC;AAGpE;;;;;;;;;;;;GAYG;AACH,qBAAa,oBAAoB;IAC/B,MAAM,CAAC,MAAM,CAAC,IAAI,GAAE,oBAAyB,GAAG,YAAY;CAW7D"}

package/dist/linters/browser.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserOxlintConfigs = void 0;
+const oxlint_1 = require("./oxlint");
+const rules_1 = require("./rules");
+/**
+ * `oxlintConfigs` for code that runs in a browser, React or not: the base rules plus the
+ * secure-context ban (`crypto.randomUUID` is `undefined` on a plain-http origin). Nothing in the base
+ * is relaxed. `ReactOxlintConfigs` builds on this preset. Takes the same options as `OxlintConfigs`.
+ *
+ * ```ts
+ * // .configs/oxlint.config.mts
+ * import { defineConfig } from 'oxlint';
+ * import { BrowserOxlintConfigs } from '@venizia/dev-configs/linters';
+ *
+ * export default defineConfig(BrowserOxlintConfigs.create());
+ * ```
+ */
+class BrowserOxlintConfigs {
+    static create(opts = {}) {
+        const baseConfigs = oxlint_1.OxlintConfigs.create(opts);
+        return {
+            ...baseConfigs,
+            rules: {
+                ...baseConfigs.rules,
+                [rules_1.NoRestrictedPropertiesRule.NAME]: rules_1.NoRestrictedPropertiesRule.build(),
+            },
+        };
+    }
+}
+exports.BrowserOxlintConfigs = BrowserOxlintConfigs;
+//# sourceMappingURL=browser.js.map

package/dist/linters/browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.js","sourceRoot":"","sources":["../../src/linters/browser.ts"],"names":[],"mappings":";;;AACA,qCAAoE;AACpE,mCAAqD;AAErD;;;;;;;;;;;;GAYG;AACH,MAAa,oBAAoB;IAC/B,MAAM,CAAC,MAAM,CAAC,OAA6B,EAAE;QAC3C,MAAM,WAAW,GAAG,sBAAa,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAE/C,OAAO;YACL,GAAG,WAAW;YACd,KAAK,EAAE;gBACL,GAAG,WAAW,CAAC,KAAK;gBACpB,CAAC,kCAA0B,CAAC,IAAI,CAAC,EAAE,kCAA0B,CAAC,KAAK,EAAE;aACtE;SACF,CAAC;IACJ,CAAC;CACF;AAZD,oDAYC"}

package/dist/linters/eslint.d.ts

@@ -10,7 +10,7 @@ export declare const eslintConfigs: Linter.Config[];
  * next to `oxlintConfigs`. It needs no type information, so ESLint stays fast.
  *
  * ```js
- * // .configs/eslint.config.mts
+ * // .configs/eslint.config.mjs
  * import { namingConventionConfigs } from '@venizia/dev-configs/linters';
  *
  * export default namingConventionConfigs;

package/dist/linters/eslint.js

@@ -131,7 +131,7 @@ exports.eslintConfigs = (0, config_1.defineConfig)([
  * next to `oxlintConfigs`. It needs no type information, so ESLint stays fast.
  *
  * ```js
- * // .configs/eslint.config.mts
+ * // .configs/eslint.config.mjs
  * import { namingConventionConfigs } from '@venizia/dev-configs/linters';
  *
  * export default namingConventionConfigs;

package/dist/linters/house/common.d.ts

@@ -0,0 +1,20 @@
+/** The estree node types the house rules visit - computed visitor keys, so the names stay PascalCase as ESLint needs them. */
+export declare class AstNodeTypes {
+    static readonly NEW_EXPRESSION = "NewExpression";
+    static readonly CALL_EXPRESSION = "CallExpression";
+    static readonly FUNCTION_DECLARATION = "FunctionDeclaration";
+    static readonly FUNCTION_EXPRESSION = "FunctionExpression";
+    static readonly ARROW_FUNCTION_EXPRESSION = "ArrowFunctionExpression";
+}
+/** The ESLint namespace the house rules live under: `venizia/<rule>`. */
+export declare const HOUSE_PLUGIN_NAMESPACE = "venizia";
+/** A field of an AST node, read without trusting its type: TypeScript nodes carry fields estree does not declare. */
+export declare const readField: (opts: {
+    node: unknown;
+    key: string;
+}) => unknown;
+/** The node's `type`, or `undefined` for anything that is not an AST node. */
+export declare const nodeType: (opts: {
+    node: unknown;
+}) => string | undefined;
+//# sourceMappingURL=common.d.ts.map

package/dist/linters/house/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/linters/house/common.ts"],"names":[],"mappings":"AAAA,8HAA8H;AAC9H,qBAAa,YAAY;IACvB,MAAM,CAAC,QAAQ,CAAC,cAAc,mBAAmB;IACjD,MAAM,CAAC,QAAQ,CAAC,eAAe,oBAAoB;IACnD,MAAM,CAAC,QAAQ,CAAC,oBAAoB,yBAAyB;IAC7D,MAAM,CAAC,QAAQ,CAAC,mBAAmB,wBAAwB;IAC3D,MAAM,CAAC,QAAQ,CAAC,yBAAyB,6BAA6B;CACvE;AAED,yEAAyE;AACzE,eAAO,MAAM,sBAAsB,YAAY,CAAC;AAEhD,qHAAqH;AACrH,eAAO,MAAM,SAAS,GAAI,MAAM;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,KAAG,OAKhE,CAAC;AAEF,8EAA8E;AAC9E,eAAO,MAAM,QAAQ,GAAI,MAAM;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,KAAG,MAAM,GAAG,SAG3D,CAAC"}

package/dist/linters/house/common.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeType = exports.readField = exports.HOUSE_PLUGIN_NAMESPACE = exports.AstNodeTypes = void 0;
+/** The estree node types the house rules visit - computed visitor keys, so the names stay PascalCase as ESLint needs them. */
+class AstNodeTypes {
+    static { this.NEW_EXPRESSION = 'NewExpression'; }
+    static { this.CALL_EXPRESSION = 'CallExpression'; }
+    static { this.FUNCTION_DECLARATION = 'FunctionDeclaration'; }
+    static { this.FUNCTION_EXPRESSION = 'FunctionExpression'; }
+    static { this.ARROW_FUNCTION_EXPRESSION = 'ArrowFunctionExpression'; }
+}
+exports.AstNodeTypes = AstNodeTypes;
+/** The ESLint namespace the house rules live under: `venizia/<rule>`. */
+exports.HOUSE_PLUGIN_NAMESPACE = 'venizia';
+/** A field of an AST node, read without trusting its type: TypeScript nodes carry fields estree does not declare. */
+const readField = (opts) => {
+    const { node, key } = opts;
+    return typeof node === 'object' && node !== null && key in node
+        ? Reflect.get(node, key)
+        : undefined;
+};
+exports.readField = readField;
+/** The node's `type`, or `undefined` for anything that is not an AST node. */
+const nodeType = (opts) => {
+    const type = (0, exports.readField)({ node: opts.node, key: 'type' });
+    return typeof type === 'string' ? type : undefined;
+};
+exports.nodeType = nodeType;
+//# sourceMappingURL=common.js.map

package/dist/linters/house/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../../../src/linters/house/common.ts"],"names":[],"mappings":";;;AAAA,8HAA8H;AAC9H,MAAa,YAAY;aACP,mBAAc,GAAG,eAAe,CAAC;aACjC,oBAAe,GAAG,gBAAgB,CAAC;aACnC,yBAAoB,GAAG,qBAAqB,CAAC;aAC7C,wBAAmB,GAAG,oBAAoB,CAAC;aAC3C,8BAAyB,GAAG,yBAAyB,CAAC;;AALxE,oCAMC;AAED,yEAAyE;AAC5D,QAAA,sBAAsB,GAAG,SAAS,CAAC;AAEhD,qHAAqH;AAC9G,MAAM,SAAS,GAAG,CAAC,IAAoC,EAAW,EAAE;IACzE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC3B,OAAO,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI;QAC7D,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC;QACxB,CAAC,CAAC,SAAS,CAAC;AAChB,CAAC,CAAC;AALW,QAAA,SAAS,aAKpB;AAEF,8EAA8E;AACvE,MAAM,QAAQ,GAAG,CAAC,IAAuB,EAAsB,EAAE;IACtE,MAAM,IAAI,GAAG,IAAA,iBAAS,EAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,CAAC;IACzD,OAAO,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;AACrD,CAAC,CAAC;AAHW,QAAA,QAAQ,YAGnB"}

package/dist/linters/house/configs.d.ts

@@ -0,0 +1,16 @@
+import type { Linter } from 'eslint';
+/**
+ * The ESLint side of a project that lints with oxlint: the naming convention plus the house rules -
+ * everything oxlint cannot express. Run it next to `oxlintConfigs`.
+ *
+ * ```js
+ * // .configs/eslint.config.mjs
+ * import { houseConfigs } from '@venizia/dev-configs/linters';
+ *
+ * export default houseConfigs;
+ * ```
+ */
+export declare const houseConfigs: Linter.Config[];
+/** `houseConfigs` for a React project: `reactNamingConventionConfigs` plus the house rules. */
+export declare const reactHouseConfigs: Linter.Config[];
+//# sourceMappingURL=configs.d.ts.map

package/dist/linters/house/configs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configs.d.ts","sourceRoot":"","sources":["../../../src/linters/house/configs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AA4BrC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAsD,CAAC;AAE/F,+FAA+F;AAC/F,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAG5C,CAAC"}

package/dist/linters/house/configs.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reactHouseConfigs = exports.houseConfigs = void 0;
+const eslint_1 = require("../eslint");
+const react_1 = require("../react");
+const common_1 = require("./common");
+const max_params_own_rule_1 = require("./max-params-own.rule");
+const no_new_error_rule_1 = require("./no-new-error.rule");
+const plugin_1 = require("./plugin");
+const SOURCE_FILES = ['**/*.{ts,tsx,mts,cts}'];
+const TEST_FILES = ['**/__tests__/**', '**/*.test.{ts,tsx}', '**/*.spec.{ts,tsx}'];
+/**
+ * The house rules: at most 5 positional parameters on a function we write, and errors thrown through
+ * `getError` only. Tests are exempt from `no-new-error`: a test throws a plain `Error` on purpose, to
+ * stand in for what a driver or a third-party library throws.
+ */
+const houseRuleConfigs = [
+    {
+        files: SOURCE_FILES,
+        plugins: { [common_1.HOUSE_PLUGIN_NAMESPACE]: plugin_1.houseEslintPlugin },
+        rules: {
+            [max_params_own_rule_1.MaxParamsOwnRule.NAME]: max_params_own_rule_1.MaxParamsOwnRule.build(),
+            [no_new_error_rule_1.NoNewErrorRule.NAME]: no_new_error_rule_1.NoNewErrorRule.build(),
+        },
+    },
+    { files: TEST_FILES, rules: { [no_new_error_rule_1.NoNewErrorRule.NAME]: 'off' } },
+];
+/**
+ * The ESLint side of a project that lints with oxlint: the naming convention plus the house rules -
+ * everything oxlint cannot express. Run it next to `oxlintConfigs`.
+ *
+ * ```js
+ * // .configs/eslint.config.mjs
+ * import { houseConfigs } from '@venizia/dev-configs/linters';
+ *
+ * export default houseConfigs;
+ * ```
+ */
+exports.houseConfigs = [...eslint_1.namingConventionConfigs, ...houseRuleConfigs];
+/** `houseConfigs` for a React project: `reactNamingConventionConfigs` plus the house rules. */
+exports.reactHouseConfigs = [
+    ...react_1.reactNamingConventionConfigs,
+    ...houseRuleConfigs,
+];
+//# sourceMappingURL=configs.js.map

package/dist/linters/house/configs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"configs.js","sourceRoot":"","sources":["../../../src/linters/house/configs.ts"],"names":[],"mappings":";;;AACA,sCAAoD;AACpD,oCAAwD;AACxD,qCAAkD;AAClD,+DAAyD;AACzD,2DAAqD;AACrD,qCAA6C;AAE7C,MAAM,YAAY,GAAG,CAAC,uBAAuB,CAAC,CAAC;AAC/C,MAAM,UAAU,GAAG,CAAC,iBAAiB,EAAE,oBAAoB,EAAE,oBAAoB,CAAC,CAAC;AAEnF;;;;GAIG;AACH,MAAM,gBAAgB,GAAoB;IACxC;QACE,KAAK,EAAE,YAAY;QACnB,OAAO,EAAE,EAAE,CAAC,+BAAsB,CAAC,EAAE,0BAAiB,EAAE;QACxD,KAAK,EAAE;YACL,CAAC,sCAAgB,CAAC,IAAI,CAAC,EAAE,sCAAgB,CAAC,KAAK,EAAE;YACjD,CAAC,kCAAc,CAAC,IAAI,CAAC,EAAE,kCAAc,CAAC,KAAK,EAAE;SAC9C;KACF;IACD,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,EAAE,CAAC,kCAAc,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,EAAE;CAC/D,CAAC;AAEF;;;;;;;;;;GAUG;AACU,QAAA,YAAY,GAAoB,CAAC,GAAG,gCAAuB,EAAE,GAAG,gBAAgB,CAAC,CAAC;AAE/F,+FAA+F;AAClF,QAAA,iBAAiB,GAAoB;IAChD,GAAG,oCAA4B;IAC/B,GAAG,gBAAgB;CACpB,CAAC"}

package/dist/linters/house/index.d.ts

@@ -0,0 +1,6 @@
+export * from './common';
+export * from './max-params-own.rule';
+export * from './no-new-error.rule';
+export * from './plugin';
+export * from './configs';
+//# sourceMappingURL=index.d.ts.map

package/dist/linters/house/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/linters/house/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC"}

package/dist/linters/house/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./common"), exports);
+__exportStar(require("./max-params-own.rule"), exports);
+__exportStar(require("./no-new-error.rule"), exports);
+__exportStar(require("./plugin"), exports);
+__exportStar(require("./configs"), exports);
+//# sourceMappingURL=index.js.map

package/dist/linters/house/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/linters/house/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,2CAAyB;AACzB,wDAAsC;AACtC,sDAAoC;AACpC,2CAAyB;AACzB,4CAA0B"}

package/dist/linters/house/max-params-own.rule.d.ts

@@ -0,0 +1,19 @@
+import type { Linter, Rule } from 'eslint';
+import type { TRuleSeverity } from '../rules/common';
+/**
+ * `venizia/max-params-own`. A function we write takes at most `max` (default 5) positional parameters;
+ * beyond that it takes one options object. A signature that belongs to someone else is not counted: an
+ * inline callback handed to a call (map, reduce, sort, a library handler) or to a JSX prop, a function a
+ * declared type fixes (`const x: TFn = (...)`, a member of a typed or `satisfies` object), and a
+ * constructor whose every parameter is injected (`@inject`). A hook's callback (`useCallback(...)`) is ours.
+ */
+export declare class MaxParamsOwnRule {
+    static readonly NAME = "venizia/max-params-own";
+    static readonly DEFAULT_MAX = 5;
+    static readonly RULE: Rule.RuleModule;
+    static build(opts?: {
+        severity?: TRuleSeverity;
+        max?: number;
+    }): Linter.RuleEntry;
+}
+//# sourceMappingURL=max-params-own.rule.d.ts.map

package/dist/linters/house/max-params-own.rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"max-params-own.rule.d.ts","sourceRoot":"","sources":["../../../src/linters/house/max-params-own.rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC3C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAyDrD;;;;;;GAMG;AACH,qBAAa,gBAAgB;IAC3B,MAAM,CAAC,QAAQ,CAAC,IAAI,4BAA8C;IAElE,MAAM,CAAC,QAAQ,CAAC,WAAW,KAAK;IAEhC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,UAAU,CAmFnC;IAEF,MAAM,CAAC,KAAK,CAAC,IAAI,GAAE;QAAE,QAAQ,CAAC,EAAE,aAAa,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAO,GAAG,MAAM,CAAC,SAAS;CAItF"}